Dismiss Notice
Join Physics Forums Today!
The friendliest, high quality science and math community on the planet! Everyone who loves science is here!

Spinors in SO(6,6)

  1. Jul 26, 2011 #1


    User Avatar

    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 dont 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.

  2. jcsd
  3. Jul 26, 2011 #2
    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 [Broken] 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).
    Last edited by a moderator: May 5, 2017
  4. Jul 27, 2011 #3


    User Avatar

    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) ? Im gonna install the mathematica in this computer this week and run your program, wich seems to be very very usefull. Thank you again.
  5. Jul 27, 2011 #4
    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
    RT.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
    LT.g + g.L = 0

    A solution for them is
    (Lab)ij = - i*(daigbj - dbigaj)

    It has commutator
    [Lab,Lcd] = i*(gacLbd - gadLbc - gbcLad + gbdLac)

    and 2nd-order Casimir invariant
    (1/2)(gacgbdLabLcd)ij = (N-1)dij
    where N = n + m

    Let gij = (si)2dij
    The s's are +-1 for the + parts of g, and +-i for the - parts of g. Let Lab = sasbL'ab. Then
    [L'ab,L'cd] = i*(dacL'bd - dadL'bc - dbcL'ad + dbdL'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.
    Last edited: Jul 27, 2011
  6. Jul 27, 2011 #5
    For the spinor case, one constructs a "Clifford algebra", N G's satisfying an anticommutation relation:
    {Gi,Gj} = 2gij

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

    Then, Lab = - (i/4)*[Ga,Gb]

    It has the same commutator as before, but its 2nd-order Casimir invariant
    (1/2)(gacgbdLabLcd) = (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: X1i1*X2i2*X3i3*...*Xkik, thus having total dimension 2k. On each one operates Pauli matrices S1, S2, and S3. Separately, of course.

    G2i-1 = S31*S32 *...*S3i-1*S1i*Ii+1*...*Ik
    G2i = S31*S32 *...*S3i-1*S2i*Ii+1*...*Ik
    G2k+1 = S31*S32 *...*S3k

    This gives {Gi,Gj} = 2dij
    Do analytic continuation again, taking
    S1i -> s2i-1S1i
    S2i -> s2iS2i
    S3k -> s2k+1S3k
    and one gets gij = (si)2dij, as before.

    One thus gets a spinor representation for both SO(2k) and SO(2k+1) with dimension 2k. But while it is irreducible in SO(2k+1), it is not in SO(2k). To see why, construct G2k+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 G2k+1.

    Its eigenvalues can be found by taking the square of it:
    (G2k+1)2 = (s2k+1)2

    yielding eigenvalues
    +- s2k+1

    The operator G2k+1 thus splits the SO(2k) spinor rep into two irreducible ones, both with size 2k-1, and with opposite-sign eigenvalues of G2k+1.
  7. Jul 27, 2011 #6


    User Avatar

    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.
  8. Jul 27, 2011 #7
    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" [Broken]

    The d's are http://en.wikipedia.org/wiki/Kronecker_delta" [Broken] d_{ij} = 1 if i=j and 0 otherwise.
    Last edited by a moderator: May 5, 2017
  9. Jul 27, 2011 #8


    User Avatar

    thank you very much simon! i will read the links. I'll search for the books you recommend.
  10. Jul 27, 2011 #9
    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.
  11. Jul 28, 2011 #10
    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)
  12. Jul 28, 2011 #11
    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.
  13. Jul 28, 2011 #12
    By the way: I just noticed the http://magma.maths.usyd.edu.au/calc/" [Broken], is it new? You can get a fair bit done in 60secs of cpu time...

    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 [Broken]
    That's handy - but it seems broken in my install of sage 4.7.
    Last edited by a moderator: May 5, 2017
  14. Jul 28, 2011 #13
    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
    Code (Text):

    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];
    Code (Text):

    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:
    Code (Text):

    (((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.
  15. Jul 29, 2011 #14
    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
  16. Jul 31, 2011 #15
    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.
  17. Aug 1, 2011 #16
    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!
  18. Aug 1, 2011 #17
    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?
  19. Aug 1, 2011 #18
  20. Aug 13, 2011 #19
    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 [Broken]

    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.
    Last edited by a moderator: May 5, 2017
  21. Aug 20, 2011 #20
    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.
Share this great discussion with others via Reddit, Google+, Twitter, or Facebook