Calculating Lie-Algebra Branching Rules

[lpetrich]

I have a problem with doing that. I've discovered some formulas for doing that, which I've found by making certain plausible assumptions and requiring self-consistency in various special cases, like

adjoint -> (adjoint,scalar) + (scalar, adjoint) + (extra stuff)

but I haven't found anything in the literature on these formulas, though I don't have access to many journal articles.

I've created a Mathematica notebook that calculates Lie-algebra properties that a physicist may find useful, like breakdown of product representations and the aforementioned branching rules: breakdown of a irreducible representation (irrep) into irreps of subgroups.

Nearly all of that notebook's content except for branching-rule details is from Robert N. Cahn's book Semi-Simple Lie Algebras and their Representations, which he has generously placed online. I've been able to calculate Dynkin diagrams, Cartan matrices, irreducible representations' root and weight vectors from their highest weights, and decompositions of products of irreps (irreducible representations). My branching-rule calculations proceed much like the product-rep calculations, but instead with

(root vector in subalgebra) = (matrix).(root vector in original algebra)
(U(1) weight) = (vector).(root vector in original algebra)

The problem I have is demonstrating the correctness of the matrices and vectors I have found. I did so by making some reasonable assumptions and imposing self-consistency in simple cases, like fundamental and adjoint reps. Is anyone familiar enough with the professional literature on Lie-algebra branching rules to point me to some discussions of this question?

-

However, I've found general formulas for the matrices and vectors for all the infinite families (SU, SO, Sp), and explicit values of them for all the exceptional algebras (G2, F4, E6, E7, E8). These are valid for all the breakdowns, as far as I've been able to find out.

I can do demotion of roots, making them into U(1) weights and getting the subalgebras by removing those roots from the originals' Dynkin diagrams.

I can also do removing of roots from extended Dynkin diagrams, using those in Robert Cahn's book.

I can even do some additional cases: SO(7) -> G2 and SO(even) -> SO(odd) * SO(odd)

Does anyone want to see the explicit matrices and the formulas that I've found?

-

Here's a classic case of root demotion: the breaking of the gauge symmetry of the Georgi-Glashow GUT into the Standard-Model gauge symmetry:

SU(5) -> SU(3) * SU(2) * U(1)

Original Dynkin diagram: o - o - o - o
With demoted root (#3): o - o (o) o

Notice that it's broken down into SU(3), U(1), and SU(2) in that order.

I get the correct decompositions of these SU(5) irreps:
1 -> (1,1,0)
5 -> (3,1,2/5) + (1,2,-3/5)
10 -> (3,2,-1/5) + (3*,1,4/5) + (1,1,-6/5)
10* -> (3*,2,1/5) + (3,1,-4/5) + (1,1,6/5)
5* -> (3*,1,-2/5) + (1,2,3/5)
24 -> (8,1,0) + (1,3,0) + (3,2,1) + (3*,2,-1)

-

Here's a case of extension splitting that happens in string theory: E8 -> E6 * SU(3), something that's involved in some symmetry-breaking scenarios.

Dynkin diagram: o - o - o [ - o] - o - o - o - o
Extended Dynkin diagram: o - o - o [ - o] - o - o - o - o - o
Split at root #6: o - o - o [ - o] - o - o (x) o - o

You can see that it's broken down into E6 * SU(3).

Here's what the happens to the fundamental / adjoint irrep of E8, which one gets out of the E8*E8 heterotic superstring:

248 -> (78,1) + (1,8) + (27,3) + (27*,3*)

The first two parts are adjoints and scalars, while the remaining parts are fundamental * fundamental.

 

[Simon_Tyler]

Hi there,

I've also got a Mathematica program for calculating various properties of Lie algebras. It's not as complete as yours since for the calculations I was doing, I only needed the branching rules following from root demotion. But it works ok:
https://www.physicsforums.com/showthread.php?t=383716
I'd be interested in exchanging code with you, if you want.

The standard reference for physicists and Lie algebra data is Slansky
http://www-spires.slac.stanford.edu/spires/find/hep/www?j=PRPLC,79,1
You could compare some formulas with his (probably need to correct for different convention choices). Note that there's a KEK scan you can download.

You can also compare your results with that which http://www.sagemath.org/" calculates:
http://match.stanford.edu/bump/thematic_tutorials/lie/branching_rules.html

Or with LiE:
http://www-math.univ-poitiers.fr/~maavl/LiE/
http://davidsd.org/2010/03/lie-group-computations-with-python/

 

[lpetrich]

Thanx so much. At first sight, xino's algorithm in your link Group representations/branching rules question looked simpler than mine, but in post 5, xino had to calculate a projection matrix for going from E7 to E6 weights.

My algorithms go as follows:

Calculate all the root vectors, corresponding weights, and degeneracies for an irrep. Brute force, but I don't know how to do anything quicker, like with Weyl orbits.

For each member of that list, do:

If demoting a root, get its value from the root vector; it'll be the U(1) factor.

For each subalgebra, multiply the root vector by a projection matrix, calculating the root vector in that subalgebra. Then multiply by the subalgebra's Cartan matrix to get the weight vector in that subalgebra.

The result is a list of weight vectors in each of the subalgebras, and also a U(1) weight for root demotions.

I then find out what's the highest weight in each of the subalgebras, expand the appropriate irreps, and subtract out that irrep product. I repeat until there are none left. Just like getting irreps out of a product representation.

-

I'd have to add some more documentation to my notebook before I'd want to post it here. Like data formats and descriptions of some of the functions and better error checking.

-

As to Weyl orbits, I'm not familiar with those or how to use them for decomposing representations. Here's what I understand of them.

One starts with a Lie algebra's Weyl group, which is the group generated by reflections by the simple root vectors:

D(a).x = x - 2*a*(a.x)/(a.a)

The Weyl groups' orders increase factorially by the rank of the algebra, but one can often avoid calculating all the elements.

A Weyl group's elements operating on a root vector in an irrep will produce a set of root vectors that are also in that irrep -- that's a Weyl orbit. An irrep may contain more than one Weyl orbit of root vectors.

 

[Simon_Tyler]

Calculating the projection matrix is easy if you use the Dynkin basis - in my answer to Xino's question E7->E6 it is just the matrix with a 1 in the [1,1] position and 0's everywhere else.

Anyway, the algorithm I used is basically the same as yours - it seems like the most straight forward way of doing it, and you'd have to have a really big algebra before it becomes slow.

I agree with everything you said about the Weyl groups (I also don't know that much about them).

I've put my mma package and a test notebook on https://github.com/simonjtyler/SemisimpleLieAlg" feel free to use any of the code you want. It's been ~8 months since I've worked on it - so I might as well set it free.

If you want, I'd be more than happy to collaborate with you to make a solid and flexible package - though I don't have too much time to work on it at the moment (trying to finish off my PhD and all that).

 

[lpetrich]

I've found a nicer typeset version at a physics professor's site.

I'm getting my notebook ready for release. I'll also release a notebook containing a sort of Lie-algebra greatest hits of physics. It will use my Lie-algebra notebook to calculate various interesting quantities and features, like getting the Standard Model out of the Georgi-Glashow SU(5) GUT model.

Simon_Tyler, is your code capable of such a calculation? I couldn't find anything on branching rules in it.

-

I'd mentioned Weyl orbits because they're an alternate technique for product-rep decompositions and branching rules. But until I find some algorithms for those, I'll stick to my brute-force approach of calculating all the root vectors.

I've thought of porting my code to C++, but doing so would require rational numbers and bignums. One will definitely need bignums for calculating the sizes of some of the irreps of E8, for instance. Mathematica does bignums automatically, but I'd have to find some suitable bignum package for C++.

As for rational numbers, I once found a rational-number template class, so all one needs is some bignum class, and one's all set.

 

[lpetrich]

Here is my package, as a zip archive: file:///Volumes/lpetrich/Sites/Science/SemisimpleLieAlgebras.zip[/URL] I hope that it doesn't look too amateurish. :(

I've included a notebook with my Lie-algebra manipulations, a notebook that is a sort of "Greatest Hits of Particle-Physics Lie Algebras" notebook, and a notebook that implements Young diagrams for SU(n).

 

[lpetrich]

Oops. That's was for my local copy. Here's a downloadable copy:

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