## Quantum Gravity Seminar

### Week 8, Track 1

#### November 20, 2000

Just before class started, an ugly green frog hopped in and jumped onto Toby's usual seat. "So, you're back!" said the Wizard. "Are you over your hiccups?"

The frog nodded slightly.

"Okay," said the Wizard, and with a snap of his fingers he turned the frog back into Toby. "But I have some bad news. From now on, you will never write another episode of this story! It will have to be me."

"Huh?" asked Toby, still a bit dazed and brushing traces of algae off his hands.

"Yes, I have ventured into the future and seen this to be true. You were simply too irresponsible to stick to your original intention. Getting the hiccups like that, and then hopping off and sitting by the pond for a week, eating flies, when you should have been writing... always some excuse or other! I can't have a coauthor like that. And so, as a fitting punishment, I shall now turn you into something even lower than a frog."

"No!" said the Wizard, "a fictional character! Henceforth, whenever I want someone to ask a silly question, I can have Toby do it, regardless of whether he would have in real life." And with a wave of the Wizard's staff, Toby was fictionalized, starting with his feet and quickly working on up.

The rest of the class stared in shock at this transformation. For a minute the Toby character sat inert and silent. But then its eyes lit up and it said cheerfullly: "So - what are we doing in class today?"

"Toby would never say that!" protested Oz.

"You're one to talk," said the Wiz. "You're fictional too! In real life you're not even in this class. Heck, even I am somewhat fictionalized! Do you think I actually walk around town with this long wizard's cloak, the tall pointed hat and staff? Don't worry, Toby won't really mind being fictional; it has its advantages.

"But enough of this nonsense. Let's get to work. Today we'll build operators like this:

```     \     /
j1 \   / j2
\ /
|
| j3
|
```
from cups and symmetrizers. Some of you have already guessed how, but I want to go over it carefully.

Remember the rules. The spin-j representation is the symmetrized (2j)th tensor power of C2, and the symmetrizer is drawn as

```     | |   | |
| |...| |
| |   | |
---------
|
| j
|
```
with 2j unlabelled spin-1/2 strands coming in and one spin-j strand coming out. Turning this upside down, we get the inclusion operator
```         |
| j
|
---------
| |   | |
| |...| |
| |   | |
```
Using these and the "cup"
```    |         |
|         |
\       /
\_____/
```
we can build the operators we're looking for. I'll start with some examples.

Suppose we want an operator from spin-3/2 tensor spin-1 to spin-5/2:

```        \     /
3/2\   /1
\ /
|
5/2|
|
```
Then we write down this:
```    3/2|             1|
|              |
------         -----
\ \ \         / /
\ \ \       / /
\ \ \     / /
\ \ \   / /
| | | | |
| | | | |
---------
|
5/2|
```
Suppose instead we want spin-3/2 coming out:
```        \     /
3/2\   /1
\ /
|
3/2|
|
```
Then we write down this:
```    3/2|           1|
|            |
------       -----
\ \ \       / /
\ \ \     / /
\ \ \___/ /
\ \     /
\ \   /
| | |
-----
|
3/2|
```
Or suppose we want spin-1/2 coming out:
```        \     /
3/2\   /1
\ /
|
1/2|
|
```
Then we use this:
```    3/2|           1|
|            |
-----        -----
\ \ \       / /
\ \ \     / /
\ \ \___/ /
\ \_____/
\
\
|
---
|
1/2|
```
See the pattern?"

Miguel was giving the last diagram a funny look. "You don't really need that symmetrizer on the bottom for a single spin-1/2 edge, do you?"

"No," admitted the Wizard, "but I'm trying to show you a systematic recipe for getting these operators."

Toby asked, "But what if you wanted an operator like this?" And with his finger, he drew this picture in the air in lines of pale blue light:

```     \     /
3/2\   /2
\ /
|
1|
|
```
Miguel groaned. "The real Toby would never have asked such a dumb question!"

"True," conceded the Wizard. "But he couldn't draw like that, either. Anyway, the answer is that we can't build an operator like this. Since each cup eats a pair of spin-1/2 edges, the spin coming out can only differ from the total spin coming in by an integer.

In fact, let's figure out exactly when we can cook up an operator like this:

```                   \     /
j1 \   / j2
\ /
|
| j3
|
```
To do it, we need to draw a picture like this:
```         j1 |              j2 |
|                 |
---------        -----------
\..\ \..\       /../ /.../
\..\ \..\     /../ /.../
\..\ \..\___/../ /.../
\..\ \......./ /.../
\..\ \__A__/ /.../
\..\       |...|
|..|B    C|...|
------------------
|
j3 |
```
Here A is the number of strands that fold back from j1 to j2, B is the number of strands that go down from j1 to j3, and C is the number of strands that go down from j2 to j3. Clearly we have:
```j1 = (A + B)/2
j2 = (A + C)/2
j3 = (B + C)/2
```
Solving these, we get:
```A = j1 + j2 - j3
B = j1 + j3 - j2
C = j2 + j3 - j1
```
so the operator we're looking for is unique, and it exists iff these numbers:
```j1 + j2 - j3
j1 + j3 - j2
j2 + j3 - j1
```
are nonnegative integers. This, in turn, happens iff both these conditions hold:
1. j1, j2, j3 are the side lengths of some triangle.
2. j1 + j2 + j3 is an integer.
If these hold, we call the triple (j1,j2,j3) "admissible". They are precisely the conditions for there to exist an intertwining operator from the spin-j1 representation of SL(2,C) tensored with the spin-j2 representation to the spin-j3 representation! We've just seen how to build such an interwtining operator. In fact, it's unique up to a scalar multiple.

Now we can build spin networks!

A "closed" spin network is basically just a graph, with edges labelled by spins, with 3 edges meeting at each vertex, these edges always being labelled by an admissible triple of spins. In short, something like this:

```       _______
1/2/   /   \   ________
/   /     \ /    |   \
\  /1      \  1/2|    \
\/       / \    |     \3/2
\      /   \  / \     \
3/2\___ /____/ /   \     \
/      /1    \3/2  \
/      /       \     \
\_____/_________\____/
2       3
```
Using the rules we've painstakingly developed, any such picture determines an operator from C to C, and thus a number.

A few more details: The embedding of the graph in 3d space doesn't really matter, but we do need to think of the edges as ribbons, since a twist gives a minus sign if the edge is "fermionic":

```                       | j                          | j
____      |                            |
/    \     |                            |
/      \   /                             |
/        \ /                              |
|          /             =  (-1)2j + 1      |
\        / \                              |
\      /   \                             |
\____/     |                            |
|                            |
|                            |
```
Similarly, we should treat the vertices as flat little patches where three ribbons meet, since they too can switch sign when twisted:
```      j1 \   / j2                           j1 |     | j2
\ /                                  |     |
/                                   |     |
/ \                                  |     |
/   \     =                           |     |
\   /             (-1)j1 + j2 - j3       \    /
\ /                                    \ /
|                                      |
|                                      |
j3 |                                   j3 |

```

"Gotcha!" said the Wizard. "I knew you were going to ask that. I'll make it a homework problem."

The rest of the class groaned.

"Anyway," said the Wizard, "so much for closed spin networks. We can also do more general "open" spin networks, with loose edges at the top and bottom, like this:

```   1/2|              2|     |3/2
|               |     |
|   ____        |     |
\ /    \   ____|     |
/      \ /1/2 |     |
/ \      \     |     |
/   \    / \     \___/
\    \  /   \
3\    \/    /
\_  / ___/      ___
/           /   \
/           /     \
0/        7/2/       \7/2
```
These describe more general operators. For example, this one gives an operator
```f: 1/2 (x) 2 (x) 3/2 -> 0 (x) 7/2 (x) 7/2
```
Eventually, we'll use these open spin networks to describe states of quantum gravity in a region of space. The edges will be "flux tubes of area", giving area to any surface they puncture. Similarly, the vertices will carry volume!

But I'm getting ahead of myself. Let's end with a puzzle. Consider a little spin network like this:

```       |
1|
|
/ \
/   \
1\   /1
\ /
|
1|
|
```
Can you show this is some constant multiple of the identity operator
```       |
1 |
|
|
|
|
```
on the spin-1 space? More importantly: can you calculate the constant? We'll need to get good at this.

Okay - let's all take a little break before Track 2."