## Quantum Gravity Seminar

### Week 7, Track 1

#### Noveber 13, 2000

The Wizard strode into class and noticed someone missing. "Where's that rascal Toby?" he exclaimed.

"I haven't seen him since Saturday." said Miguel.

"Humph!" said the Wizard "Where could he have gotten to? He often forgets our top-secret category theory seminar, but this -- this is really pushing it! Maybe a fireball or two will help him shape up.".

Oz smiled at the thought of that know-it-all Toby getting a taste of the Wizard's pyrotechnics.

"Okay," said the Wizard "today we're going to build spacetime from spin! More precisely, we'll start with the vector space for a spin-1/2 particle, V = C2, and the cup and cap operators we talked about before:

```         |           |
|           |
V v           v V
\         /
\_______/

_______
/       \
/         \
V v           v V
|           |
|           |

```
These are the cup and cap that my friend the wizard JB talked about. You do remember that cup and cap, don't you?

The class shifted nervously in its seats.

"We'll use these to build a lot of vector spaces and linear operators." the Wizard continued "First we'll build a vector space for each number j = 0, 1/2, 1, 3/2, ... . Physicists call these numbers "spins", and our original vector space V will correspond to j = 1/2. Then we'll build a bunch of operators like this:

```   \         /
\       /
j1 \     / j2
\   /
\ /
|
|
j3 |
|
|
```
where j1, j2 and j3 are spins. Using these, --".

"Excuse me," said Oz "my brain must be flummoxed, because I can't see the arrows on that diagram there. Did you forget to draw them in, or do I need new glasses?".

"There's another possiblity that you forgot:" said the Wizard "You might need a fireball upside the head.". Oz began quivering with fear. "But I won't give you one, because that's actually a good and profound question.". Oz relaxed noticeably. "Remember," said the Wizard "because of this symplectic form on V, there are isomorphisms # and b that go between V and V*. Because of that, we can just ignore the arrows on V. Of course, V is just the vector space for j = 1/2. But we'll see, soon, that we can ignore the arrows for every j.

Anyway, using these symbols and some other stuff I'll explain, we can start drawing all sorts of pictures, like this:

```          /|\
/ | \
j1 /  |  \ j3
/ j2|   \
/    |    \
-----|-----
\    | j4 /
\   |   /
j5 \  |  / j6
\ | /
\|/

```
This is a tetrahedron with all its edges labelled by spins. But in our diagrammatic calculus, what does this represent?".

The class sat staring at the picture, jaws slack in amazement.

"Come on!" said the Wizard impatiently "We have a bunch of rules for interpreting diagrams like this. What is this thing?".

Richard the Acolyte cautiously ventured a reply: "A number?".

"Right!" said the Wizard "A complex number! Remember, a picture with nothing coming in on top and nothing going out on the bottom denotes a linear operator from C to C -- which is just multiplication by some complex number. So, we have a recipe to get a number from a tetrahedron with edges labelled by spins.

Now, topologists like to take a 3-dimensional manifold and chop it into tetrahedra. If we do this, and label all the edges by spins, we'll get a number for each tetrahedron, and we can multiply all these together to get a number for the whole thing. Eventually, this will give us some cool ways to assign numbers to manifolds. There's a lot more to say about this; right now I'm just sketching the idea.

Now in physics, we can think of a 3-dimensional manifold as spacetime -- at least if we're doing 3D quantum gravity, which is a kind of warmup for the 4D theory. So what we really have here is a recipe for assigning a complex number -- or amplitude -- to a spacetime that's been chopped up into tetrahedra, with all the edges labelled by spins. And what do you think these spins correspond to?".

"They correspond to representations of SU(2)!" said Miguel the Acolyte.

"Yeah, yeah," growled the Wizard "but that's too fancy -- we haven't talked about that stuff yet. Come on: If someone walked up to you and showed you a tetrahedron with nonnegative numbers labelling its edges, what would you *guess* the numbers stood for?".

Oz got his courage up and said "Lengths?".

"Yes!" cried the Wizard "The spins stand for the edges' *lengths*! So we are seeing some new theory of geometry emerge naturally from our diagrammatic approach to vector spaces and linear operators. But what's funny about these lengths?".

"They're quantized!" said Jay the Acolyte. He had already seen this sort of thing before. "They can't be any old number: they can only be numbers like 0, 1/2, 1, 3/2 and so on.".

"*Right*!" exulted the Wizard, hurling a fireball in his joy. Foom! It whizzed past Oz, singing his right ear, and exploded into fragments against the back wall of the classroom.

After catching his breath, the Wizard continued:

"Yes, we'll see that our mathematics leads naturally to theories where things like lengths take on a discrete set of values. In quantum mechanics, it's common for observables like energy to be quantized this way. But when we build spacetime from spin, *geometry* will be quantized!

Now, before we start, I have one final question. All our vector spaces and linear operators will be built starting only from the symplectic vector space V = C2. Remember, we draw a symplectic structure on V as a cup:

```         |           |
|           |
|           |
\         /
\_______/
```
It doesn't really matter which symplectic structure we use. Since the symplectic structure is antisymmetric, we have
```         |           |           |     |
|           |           |     |
|           |           |     |
|           |            \   /
|           |             \ /
|           |     = -      /
|           |             / \
|           |            /   \
\         /            |     |
\       /              \   /
\_____/                \_/
```
Since it's nondegenerate, we've seen there's a cap:
```            _______
/       \
/         \
|           |
|           |
|           |
```
for which these marvelous identities hold:
```            _____
/     \
/       \
|         |     =     -2
\       /
\_____/

\   /       |   |      \   /
\ /        |   |       \_/
/     =   |   |   +    _
/ \        |   |       / \
/   \       |   |      /   \
```
This is all we'll need to build spacetime from spin! But my question is: What's so great about the symplectic vector space C2? Why is it a worthy foundation for all the constructions to come?".

The Acolytes, who'd been busy taking notes, looked up and started pondering this question.

"Well," said the Wizard "one answer is that C2 is the simplest symplectic vector space. At least, the simplest one that's not completely silly. Symplectic vector spaces have to be even-dimensional, so, barring the 0-dimensional one, the 2-dimensional is the smallest. But that's not the answer I want.".

The class continued to ponder.

"Well then," said the Wizard a bit irritably "here's a homework problem! First, suppose V is any vector space with a symplectic structure w. We say a linear operator T: V -> V "preserves" the symplectic structure if w(Tu, Tv) = w(u, v) for all u,v in V, or, in pictures, if:

```     |           |          |           |
|           |          |           |
/ \         / \         |           |
| T |       | T |        |           |
\_/         \_/   =     |           |
|           |          |           |
|           |           \         /
\         /             \       /
\_______/               \_____/

```
Now, suppose V = C2. Show that, no matter what symplectic structure we take, T: V -> V will preserve it if and only if det T = 1.

There are some very slick ways to show this, but, if you're not feeling smart, you can just grind it out with a grungy calculation.".

Various students gulped and looked nervous.

"Now, the linear transformations of C2 with determinant 1 form a group called SL(2,C). If we build a bunch of vector spaces and operators using only C2 and a symplectic structure on this space, then SL(2,C) will act as symmetries of everything we build! So my question really is: What's so great about SL(2,C)?".

Cyrill the Part-Time Acolyte said "It plays a basic role in the classification of semisimple Lie groups ... blah, blah, blah ... Dynkin diagrams ... blah, blah --".

The Wizard cut him off. "Too fancy! And we're doing physics now! What's so great about SL(2,C) in physics?".

Miguel the Acolyte took a guess. "It's the double cover of SU(2)?".

Foom!

"No!" roared the Wizard "It's the double cover of the Lorentz group -- the group generated by rotations and Lorentz transformations! Einstein showed that this is the symmetry group of spacetime in special relativity. It also plays a big role in general relativity. But when we throw quantum mechanics into the mix, the Lorentz group isn't good enough. Remember, when you rotate an electron by a full turn, its state gets multiplied by -1. Only when you give it two full turns does it get back to where it was. To distinguish between a full turn and no turn at all, we need to replace the Lorentz group by its double cover -- SL(2,C).

That is why we start with the symplectic vector space C2: its symmetry group is the right group for combining relativity and quantum mechanics.".

At this point the Wizard noticed two of the Track 1 students exchanging nervous glances.

"But don't worry about this physics stuff -- we won't really need it! I just wanted to explain why we're starting with these particular ingredients. I hate it when mathematicians do stuff without saying why. Okay, so now we'll start ... .".

At this point, he looked at the clock and saw how late it was.

"Ack! The class is almost over and I haven't even started yet!

Okay, let's hurry. First, say we have any vector space V. We can make a new vector space by tensoring V with itself n times -- we call this the "nth tensor power" of V. There's a group Sn called the "symmetric group", which consists of all permutations of n things. This group acts as linear operators on the nth tensor power of V in an obvious way. How? Well, we can draw any permutation as a diagram like this:

```  \   \   /   /   /
\   \ /   /   /
\   /   /   /
\ / \ /   /
/   /   /
/ \ / \ /
/   /   /
/   / \ / \
/   /   /   \
/   /   / \   \
```
Then label all the strands with the vector space V, and intrepret the diagram as a linear operator using our rules. Get it?".

"Erm, no." said Oz.

The Wizard sighed. "Well, suppose we have a guy in the 5th tensor power of V that's a tensor product of 5 vectors in V:

```v = v1 (X) v2 (x) v3 (x) v4 (x) v5.
```
To apply the above permutation to this guy, we feed v1 through v5 into the diagram and see what pops out at the bottom:
```  v1  v2   v3  v4  v5
\   \   /   /   /
\   \ /   /   /
\   /   /   /
\ / \ /   /
/   /   /
/ \ / \ /
/   /   /
/   / \ / \
/   /   /   \
/   /   / \   \
v3  v4  v5  v1  v2
```
Voila! The answer is v3 (x) v4 (x) v5 (x) v1 (x) v2. Get it now?".

"Got it." said Oz.

"Good. Next, we define an operator called the "symmetrizer" on the nth tensor power of V by taking all of these operators corresponding to permutations, adding them up, and dividing by n factorial. We denote this operator by a horizontal line. For example, when n = 2 we have:

``` |  |            |  |           \   /
|  |            |  |            \ /
----   =  (1/2) |  |  +  (1/2)   /
|  |            |  |            / \
|  |            |  |           /   \
```
For n = 3 we have:
```                      |  |  |           \   /  |           |   \   /
|  |  |            \ /   |           |    \ /
(1/6) |  |  |  +  (1/6)   /    |   + (1/6) |     /
|  |  |              |  |  |            / \   |           |    / \
|  |  |              |  |  |           /   \  |           |   /   \
-------    =
|  |  |              \ \   /           \   / /            \  |  /
|  |  |               \ \ /             \ / /              \ | /
\ /               / /                \|/
+ (1/6)  / \   +  (1/6)  / /       + (1/6)   /|\
/ \ \           / / \               / | \
/   \ \         / /   \             /  |  \
```
If we apply this symmetrizer to any vector in the nth tensor power of V, we get a vector on which further permutations have no effect. For example, we have
```  |   |   |           |   |   |
|   |   |           |   |   |
|   |   |           |   |   |
|   |   |           |   |   |
|   |   |           |   |   |
---------     =     ---------
\   /   |           |   |   |
\ /    |           |   |   |
/     |           |   |   |
/ \    |           |   |   |
/   \   |           |   |   |
```
Since the symmetrizer is just a linear combination of permutations, it follows that after we apply the symmetrizer once, applying it again has no further effect. For example:
``` |  |  |           |  |  |
|  |  |           |  |  |
-------           |  |  |
|  |  |     =     -------
-------           |  |  |
|  |  |           |  |  |
|  |  |           |  |  |
```
In other words, the symmetrizer is a projection operator: it maps the nth tensor power of V onto the subspace of vectors that are invariant under permutations. We call this subspace the "nth symmetric power" of V, or Sn(V) for short.

Now let V be C2. In this case, all the symmetric powers of V are representations of SL_2(C), and for any spin j = 0, 1/2, 1, 3/2 ... , physicists call S2j(V) the "spin-j representation". The dimension of this vector space is 2j + 1. For example:

```j = 0  :  S0(V) = C
j = 1/2:  S1(V) = C2
j = 1  :  S2(V) = C3
j = 3/2:  S3(V) = C4
```
and so on. We'll often just use the number j to stand for the vector space S2j(V).

Okay, we've got our list of vector spaces! Now for our operators. First, let's set up some handy notation. From now on, when a strand is unlabelled, that means it's labelled by the vector space V = C2 -- or in other words, spin 1/2. If we think of the symmetrizer as a "projection operator" from the (2j)th tensor power of V to the space j, then we can write it like this:

```     | |   | |
| |...| |
| |   | |
---------
|
| j
|
```
with 2j unlabelled strands coming in and one strand labelled by "j" coming out. Also, we know how to turn operators upside-down, and when we do this here:
```         |
| j
|
---------
| |   | |
| |...| |
| |   | |
```
we get the "inclusion operator" from j to the (2j)th tensor power of V.

Now, for any vector space j on our list we have a cup operator:

```     |       |
j |       | j
|       |
\     /
\___/
```
For j = 1/2 this is the cup we already know and love: the symplectic structure on C2. For other values of j, here's how we define it:
```                         j |          | j
-------    -------
||...||    ||...||
\\...\\  //...//
|       |            \\...\\//...//
j |       | j           \\...\/...//
|       |     =        \\......//
\     /                \\....//
\___/                  \\..//
\\//
\/
```
Second, for any j we have a cap operator:
```        ___
/   \
/     \
|       |
j |       | j
|       |
```
defined in a similar way:
```                             /\
//\\
___                //..\\
/   \              //....\\
/     \            //......\\
|       |     =    //.../\...\\
j |       | j       //...//\\...\\
|       |        //...//  \\...\\
||...||    ||...||
-------    -------
j |          | j
```
Third and finally, we want some operators that look like this:
```     \     /
j1 \   / j2
\ /
|
| j3
|
```
These go as follows....". But before writing down the formula, the Wiz glanced at the clock. It was very late! "Hmm. Given the hour, I'll leave this as a puzzle for you. How can you cook up an operator like this, using only cups and symmetrizers?".

The Acolytes began to guess, but I will not tell you what they guessed. Figure it out for yourself!