Decomposing Spinor Representation of SO(6,6)

[gda]

HI!
i have to face the problem of decomposition of the spinor representation of SO(6,6) into smaller subgroups of SO(6,6), in a generic way, as possible. Because I almost don't know too much about decomposition of representations of the classical groups, I wonder if someone knows where I can start reading information about decomposition of representations of classical groups and decomposition of spinor representation? I think there is a general procedure, and i want it to apply to my specific case. Thank you all.

pd: In polchinsky volume II there is an appendix about that, but with 1 temporal coordinate.

gda

 

[lpetrich]

gda, which subalgebras do you have in mind?

It has been awfully hard to find anything on that subject, so I took what I could find and created a Mathematica notebook that does that: http://homepage.mac.com/lpetrich/Science/SemisimpleLieAlgebras.zip mentions it and some other software for manipulating Lie algebras and their representations.

My software doesn't work with SO(m,n), only with SO(n), but the reps carry over. So what you have is essentially SO(m+n) = SO(12) or D6. With the Dynkin-diagram convention that the last two roots are the short branched ends, the spinor reps of SO(12) are (0,0,0,0,1,0) and (0,0,0,0,0,1), with dimension 32. The are both self-conjugate and pseudoreal, with height 15.

The maximal subalgebras of SO(12) are SO(9)*SO(3), SO(8)*SO(4), SO(7)*SO(5), and SO(6)*SO(6). I ran my software on the SO(12) spinor reps and I got spinor reps in the subalgebra parts.

Demoting a root to a U(1) factor gives SO(10), SU(2)*SO(8), SU(3)*SO(6), SU(4)*SO(4), or SU(6).

 

[gda]

thank you so much lpetrich, i really appreciate it. There is a lot of information i have to understand! And thank you for running my specific case. Any way, what would be the essential difference with the reps you obtained using SO(12) instead of SO(6,6) ? I am going to install the mathematica in this computer this week and run your program, which seems to be very very usefull. Thank you again.

 

[lpetrich]

Not a really big difference. The SO(n,m)'s can be found by analytically continuing the SO(N)'s, where N = n + m.

For the vector representations, it's rather easy to construct the SO(n,m) generators. The vector representation one gets from the Lie group, whose elements R satisfy
R^T.g.R = g
for some metric g with signature n +'s and m -'s.

Letting R ~ I + e.L for small e, we get for the generators L
L^T.g + g.L = 0

A solution for them is
(L_ab)_ij = - i*(d_aig_bj - d_big_aj)

It has commutator
[L_ab,L_cd] = i*(g_acL_bd - g_adL_bc - g_bcL_ad + g_bdL_ac)

and 2nd-order Casimir invariant
(1/2)(g^acg^bdL_abL_cd)_ij = (N-1)d_ij
where N = n + m

Let g_ij = (s_i)²d_ij
The s's are +-1 for the + parts of g, and +-i for the - parts of g. Let L_ab = s_as_bL'_ab. Then
[L'_ab,L'_cd] = i*(d_acL'_bd - d_adL'_bc - d_bcL'_ad + d_bdL'_ac)

the commutator for SO(N). This demonstrates analytic continuation in the vector case and all representations derived from it. So when one gets a SO(N) vector-derived rep, one can easily get a SO(n,m) rep. One might infer continuity to the spinor case by self-consistency, but it would be desirable to prove that.

 

[lpetrich]

For the spinor case, one constructs a "Clifford algebra", N G's satisfying an anticommutation relation:
{G_i,G_j} = 2g_ij

[a,b] = a.b - b.a, {a,b} = a.b + b.a

Then, L_ab = - (i/4)*[G_a,G_b]

It has the same commutator as before, but its 2nd-order Casimir invariant
(1/2)(g^acg^bdL_abL_cd) = (1/4)*N*(N-1)

For N = 3, one gets the familiar vector and spinor results, angular momentum 1 and 1/2.

We must now find some realization of the G's. We do this by considering basis states that are the outer product of k basis 2-spinors: X1_i1*X2_i2*X3_i3*...*Xk_ik, thus having total dimension 2^k. On each one operates Pauli matrices S1, S2, and S3. Separately, of course.

G_2i-1 = S3₁*S3₂ *...*S3_i-1*S1_i*I_i+1*...*I_k
G_2i = S3₁*S3₂ *...*S3_i-1*S2_i*I_i+1*...*I_k
G_2k+1 = S3₁*S3₂ *...*S3_k

This gives {G_i,G_j} = 2d_ij
Do analytic continuation again, taking
S1_i -> s_2i-1S1_i
S2_i -> s_2iS2_i
S3_k -> s_2k+1S3_k
and one gets g_ij = (s_i)²d_ij, as before.

One thus gets a spinor representation for both SO(2k) and SO(2k+1) with dimension 2^k. But while it is irreducible in SO(2k+1), it is not in SO(2k). To see why, construct G_2k+1 in SO(2k). One can show that it commutes with all the spinor L's in SO(2k), meaning that the spinor rep of SO(2k) gets split by G_2k+1.

Its eigenvalues can be found by taking the square of it:
(G_2k+1)² = (s_2k+1)²

yielding eigenvalues
+- s_2k+1

The operator G_2k+1 thus splits the SO(2k) spinor rep into two irreducible ones, both with size 2^k-1, and with opposite-sign eigenvalues of G_2k+1.

 

[gda]

thank you really very much for your time lpetrich. It helps me a lot. I will read it carefully everything. What are the d's ? ( (L_{ab})_{ij} = - i*(d_{ai}g_{bj} - d_{bi}g_{aj}) ) Are any literature you recommend for this ? thank you.

 

[Simon_Tyler]

Nice work lpetrich! So I take it that you haven't ported you Mathematica code to another (more OOP) language yet? (Not that I'm criticizing, I also haven't done any more work on my code)

Gda: I suggest that you read the http://match.stanford.edu/bump/thematic_tutorials/lie/branching_rules.html"

The d's are http://en.wikipedia.org/wiki/Kronecker_delta" d_{ij} = 1 if i=j and 0 otherwise.

 

[gda]

thank you very much simon! i will read the links. I'll search for the books you recommend.

 

[lpetrich]

I'm in the middle of porting it to Python. I have the algebras themselves, the reps, and the rep products working, and I'm now working on the branching rules.

I was stymied for a while when I discovered that it was much slower than the Mathematica version, but I soon discovered that the Python implementation of fractions is very slow, much slower than Mathematica's. It took me a while to think of an alternative, but I came up with one. I get a vector from a weight vector by multiplying the latter by the inverse of the Cartan matrix. Since that matrix is all rational numbers, I found the least common multiple of its denominators and multiplied the whole matrix by that. Using this instead of the original matrix gave me root vectors scaled to all-integer, but I had to adjust the rest of the code to cope with these scaled roots.

However, I've implemented a global cache of the reps that I've calculated in both versions, and I'm thinking of implementing an algebra cache in my Python version.

I think that I may have to compose a rather gory test suite for both versions, so I can cehck that all features of the code are working properly.

 

[rntsai]

I'm in the middle of porting it to Python. I have the algebras themselves, the reps, and the rep products working, and I'm now working on the branching rules.

Just a suggestion, but a lot of this already exists in other computer algebra software...
MAGMA and GAP have these. GAP is my favorite (and it's free). You might want to look
into what they have and add any extra constructions on top. For example, the mathematica
notebooks you posted earlier look really interesting (I downloaded a mma reader to view since
I don't have mma), but if they were for example written as a gap package the calculations
would have been more valuable (to me at least)

 

[Simon_Tyler]

Magma is kind of hard to get if you're not in a math department somewhere. So I've never played with it.

I have used some of the nice Lie Algebra code in GAP (which you can access and mix with sage). I found it really useful that given a basis set of matrices it can generate a Lie algebra object, perform the Levi decomposition and identify the complexified semisimple part. I think that Magma is the only other software that can do the same with a finitely presented Lie algebra...

De Graaf, who wrote a fair chunk of the Lie Algebra code in GAP, has a good book on and called "Lie algebras: theory and algorithms". (I've only read a fraction of it).

That said, it is instructive to write your own code. It makes sure you really understand the algorithms and theory given in the standard texts.

 

[Simon_Tyler]

By the way: I just noticed the http://magma.maths.usyd.edu.au/calc/" , is it new? You can get a fair bit done in 60secs of cpu time...

EDIT:
Oh, it's been around for ages. The original commit of the sage interface to it, magma_free.py, by William Stein was in 2007
http://hg.sagemath.org/sage-main/file/83cdf160bd1e/sage/interfaces/magma_free.py
That's handy - but it seems broken in my install of sage 4.7.

 

[lpetrich]

I don't know how one would find Lie-algebra branching rules in it -- given all that Magma can do, it looks like I'd have to do a LOT of digging.

BTW, in my translation to Python, I've had to revise my Mma branching code to something easier to translate into Python. My original I'd set up when I didn't know how it would turn out, so I made it very general. But now that it fit the patterns I'd expected, I can specialize it.

For E6 with one of the long-end roots demoted to a U(1) factor, I've rewritten the code for the branching-rule data from

AppendTo[subtypes, {4, 5}];
smat = Table[0, {6}, {5}];
smat[[1, 1]] = smat[[2, 2]] = smat[[3, 3]] = smat[[4, 4]] = smat[[6, 5]] = 1;
smat[[m]] = {-1/2, -1, -3/2, -5/4, -3/4};
AppendTo[submats, smat];

to

stsmdata = {{{4, 5}, {1, 2, 3, 4, 6}, {-1/2, -1, -3/2, -5/4, -3/4}}}

with a function that gets subtypes and submats from stsmdata.

I eventually expect to write a function that will convert that version to a Python version:

(((4,5), (1,2,3,4,6), (Fraction(-1,2),-1,Fraction(-3,2),Fraction(-5,4),Fraction(-3,4))))

BTW, {4,5} is how I specify D5 / SO(10). E6 is {5,6}. Dumb, but easy to parse.

 

[lpetrich]

Exhaustion. I just finished reworking the setup of the branching-rule projection matrices. The code for them is a lot smaller, it now looks a heck of a lot cleaner, and it's better-organized.

Robert N. Cahn's book Semi-Simple Lie Algebras and Their Representations is another good reference, even if short on branching-rule projection-matrix algorithms.

Notes on Clifford Algebras and Spin(N) Representations explains how to construct Clifford algebras and spinor-SO(N) generators. The spinor version of SO(N) is sometimes called Spin(N).

The spinor reps and their Clifford algebras have some symmetry properties that repeat with a period of 8 in N, the Bott periodicity.

There are some Clifford algebras that some of you people may already have seen.
The Pauli matrices
The Dirac matrices

 

[lpetrich]

Progress report. I've completed the code that takes branching data and does branching with it. But so far, I've only tested it on SU(n) root demotion, like demoting root 3 of SU(5) / A4. That's in Georgi-Glashow -> Standard-Model symmetry breaking. I'll have to do the rest of the branching data, and then my notable-results page.

gda, if you don't mind me asking, and if it's something that it would be OK to talk about, where does this SO(6,6) algebra appear? It does not seem like a typical gauge algebra, and if it's for a space-time, it would have 6 space and 6 time dimensions.

 

[Simon_Tyler]

Ipetrich: It could be some sort of space-time algebra. E.g. the 4-dimensional conformal group is SO(2,4) < SO(1,3) and deSitter is SO(1,4) < SO(1,3) and anti-deSitter is SO(2,3)...

Also, nice going on your code work!
Just a note to not make the code too cryptic (ie E6 is {5,6}) - think of other people who want to use and extend your code!
And you should try to hand code as little as possible into the branching rules - that way the system should be more extendable.

Also, I agree about Cahn. It's a nice clear book - if a little short on detail and proofs!

 

[lpetrich]

I use {5,6} instead of E6 in the code, because it's easier to parse. However, in my description output, I use the letter-number as well as the number-list format; I write:
{5,6} E6

As to my branching-rule software, it creates a generic branching-rule object that contains the original algebra type, the subalgebra types, the subalgebra projection matrices, and a list of roots that become U(1) factors. My software generates the projection matrices for the four infinite families, but the matrices for the exceptional algebras are all hard-coded. It had taken me a LOT of experimentation and trial and error to discover them; I don't know of any algorithm for generating them.

From your description, for s space dimensions and t time dimensions, we get these symmetry groups:
Generalized Lorentz: SO(t,s)
DeSitter: SO(t,s+1)
AntiDeSitter: SO(t+1,s)
Conformal: SO(t+1,s+1)

For some reason, anti-de-Sitter spacetimes feature rather prominently in the string-theory literature. Or so it seems to me. If that's the case, then what might be the reason?

 

[Simon_Tyler]

AdS spaces appear appear in the string theory literature a heap because of AdS/CFT:
http://en.wikipedia.org/wiki/AdS/CFT_correspondence
Which started with one of the most highly cited papers of all time:
http://arxiv.org/abs/hep-th/9711200

 

[lpetrich]

I looked online for references to SO(6,6), and I found a few papers, but not much.

I also have an updated version of my Lie-algebra code, with both Mathematica and Python versions. The Python version does not have all the Mathematica version's features, but it does have Lie-algebra construction, product-representation decomposition, and all of the branching rules. In fact, I've added some more branching-rule construction since last time, and it's in both versions.

http://homepage.mac.com/lpetrich/Science/SemisimpleLieAlgebras.zip


Here's some more about spinor representations. In particular, real vs. pseudoreal vs. complex. Some familiar examples: real-valued rotations and adjoint representations are all real. The Pauli matrices form a pseudoreal representation of SU(2). The fundamental representations of SU(n) for n > 2, are all complex.

Their pattern of reality forms an interesting pattern with periodicity 8, the Bott periodicity:
SO(8n) -- real
SO(8n+1) -- real
SO(8n+2) -- complex
SO(8n+3) -- pseudoreal
SO(8n+4) -- pseudoreal
SO(8n+5) -- pseudoreal
SO(8n+6) -- complex
SO(8n+7) -- real

The complex ones are conjugates of each other. One can understand this (pseudo)real vs. complex dichotomy by considering how the spinor representations are constructed.

 

[lpetrich]

I've updated my code with some additional extra branching rules, like
SU(m1*m2*...*mn) = SU(m1)*SU(m2)*...*SU(mn)

and a counterpart for SO(n) and Sp(n) -- multiply SO(n)'s and Sp(n)'s together to get SO(product of n's) for an even number of Sp's, and Sp(product of n's) for an odd number. I got the idea from "Selected Papers of E.B. Dynkin", which contains papers on finding the maximal subalgebras of various Lie algebras.

Inspired by some of Cahn's book, I've also implemented symmetry decomposition of tensor-product powers of irreps.
Square -> symmetric, antisymmetric
Cube -> symmetric, 2 * mixed, antisymmetric
Extending to higher powers has been more difficult, however. But it's possible to do that because index-permuting operators commute with Lie-algebra operators here.

 

[gda]

Hi everyone. Sorry for my long delay lpetrich. I'm already still working with my problem, and still reading information. You guys know a lot of group theory! I'm just starting with all of these. The group SO(6,6) arises in the context of flux compactification in string theory. Specifically when you try to understand the truncation of gauged N=8 supergravity to N=4 supergravity. Appears E7(7) -> SL(2)XSO(6,6). The next paper:
http://arxiv.org/PS_cache/arxiv/pdf/1104/1104.3587v3.pdf
have an appendix talking about spinor in SO(6,6). I am still learning from that because, like I've just said, I'm just starting with spinor rep of the classical groups (already done with all the introductory part). In this moment, I am reading the spinor representation of SO(N) from georgi's book, Lie algebras for particle physics. I think its the best place to start with it. If i can understand it, the next move is to read the appendix of that paper and the references.

 

[gda]

and thanks againg lpetrich for your mathematicas ' notebook