Anyone interested in Lie algebras?

[lpetrich]

I've found it difficult to find online some software to calculate what I was looking for, so I wrote it myself: SemisimpleLieAlgebras.zip I've also done that with some other mathematical-physics stuff, like differential geometry for general relativity. I've succeeded, and I've written it in Mathematica, Python, and C++. It does:

• The algebras themselves
• Representations
• Products and symmetrized powers of representations ("plethysms")
• Subalgebras and branching rules

I was able to get some notable physics results from it:

• The three light quark flavors -> the spectrum of light baryons
• Various Grand Unified Theory results: SU(5), SO(10), E6, E8

Mathematica is overall the nicest for developing, but Python and C++ are non-proprietary. C++ was the most awkward for developing, though its Standard Template Library was a big help. The Mma and Python versions have similar speeds, with the C++ version being much faster, a factor of 45 or so at full optimization.

The smallest of the "simple" Lie algebras is SU(2) ~ SO(3) ~ Sp(2). It's the algebra of quantum-mechanical angular momentum, and if you've ever done operator algebra with QM AM, you've worked with a Lie algebra. If you've ever worked with QM AM states, you've worked with that algebra's representations.

[sol invictus]

lpetrich, this looks very impressive and potentially very useful. Thank you for posting it.

Have you considered submitting it to the arxiv?

[Soapy Sam]

As someone who has trouble with such mathematical concepts as subtraction (what are numbers, really?), I'm happy to accept that if Sol thinks this is good work, it is good work- but could anyone explain in idiot-readable terms, what it is?

[lpetrich]

Originally Posted by sol invictus

lpetrich, this looks very impressive and potentially very useful. Thank you for posting it.

Thanx.

Quote:

Have you considered submitting it to the arxiv?

I hadn't thought of that.

[lpetrich]

I'll try to explain what a Lie algebra is. It's named after Norwegian mathematician Sophus Lie ("Lee"), who first studied that kind of mathematical entity.

It's based on group theory.

An abstract-algebra group is a set of entities and a binary operation * that satisfy these properties:
Associative: a*(b*c) = (a*b)*c
Identity e: a*e = e*a = a
Inverse: a*inv(a) = inv(a)*a = e
It's easy to show that integers with addition are a group.

Here is a property that some groups have:
Commutative; a*b = b*a
Commutative groups are often called abelian after 19th cy. Norwegian mathematician Niels Henrik Abel. Their opposite is nonabelian.

Addition of integers is, of course, abelian.


The simplest group is the identity group, like {0} under addition or {1} under multiplication.

All the finite abelian groups are known, and all the finite "simple" groups are also known, though the classification of the latter was an enormous effort.

But what leads to Lie algebras are continuous groups. These have an infinite number of elements, of course. Groups like real numbers under addition.

More interesting is groups of rotations and reflections. The group of all R and R's in an n-dimensional space is called O(n), after how they can be implemented as orthogonal matrices. All the pure rotations without reflections are called SO(n), after the special orthogonal matrices, those with determinant 1.

For a line, SO(1) is the identity group, and O(1) is the reflection group.

For a surface, the groups are SO(2) and O(2), and for 3-space, they are SO(3) and O(3). For space-time, it's trickier, but one gets a remarkable result. Lorentz boosts can be treated much like rotations, and one gets groups much like SO(4) and O(4).

All these groups have finite subgroups, and for low numbers of dimensions, all of them are known.

[fuelair]

I am impressed even though this is way out of my league. I am passing it to a Physics teacher or so in case they have really good kids this might help. Or just who could have fun with it!!!

[lpetrich]

The groups SO(n) are connected: one can get to any element by increasing the amount of rotation from zero, the identity-element amount.

But the groups O(n) are not. They consist of two connected parts, SO(n) and the n-D rotation-reflections. It's a more complicated for the "Lorentz group" of space-time rotations and boosts. It has 4 connected parts. One for pure rotations/boosts, one with space reflections, one with time reflections, and one with space and time reflections combined.

The groups SO(n) and O(n) are "Lie groups".

Connected Lie groups have a very nice property. Consider a rotation element. It can be produced from a large number of small rotations:
D(a) = D(a/n)ⁿ ~ (1 + L*a/n)ⁿ
where L is that rotation's generator.

One can get every connected-Lie-group element from elements arbitrarily close to the identity element. The departures from identity form a "Lie algebra", and my OP is for calculating some important sorts of Lie algebras.

Quantum-mechanical angular momentum is related to rotation generators by
(angular momentum) ~ (hbar) * (rotation generators)

Lie-algebra elements are related by their "commutators":
[L_i,L_j] = L_i.L_j - L_j.L_i = sum over k of f_ij^k*L_k
The f's are the algebra's "structure constants".


One can generalize the matrices in O(n) and SO(n) from real to complex ones. One gets groups of "unitary" matrices, U(n) and SU(n). How are these groups related?
U(n) = SU(n) * U(1)
O(n) = SO(n) * {I, -I} only for odd n. For even n, -I is in SO(n)

The math for the groups' matrices D:

Orthogonality: D.D^T = I
T = transpose

Hermitian conjugate: D⁺ = D^*T
Complex-conjugate and transpose

Unitarity: D.D⁺ = 1

There's an additional sort of matrix groups, the "symplectic" ones of real matrices:
D.J.D^T = J
where
J^T = -J (antisymmetry)
J.J^T ~ I
A convenient choice of J: {{0,-I},{I,0}}

The Lorentz group of space-time symmetries is a group of real matrices that satisfy
D.g.D^T = g
where g is the space-time metric. Since g is symmetric, one can get the Lorentz group by analytically continuing O(4). So it's just a version of O(4).

[lpetrich]

Let's look at the generators. What constraints do they satisfy?

SO(n):
L + L^T = 0 -- L is antisymmetric (i*L is Hermitian)
SU(n):
L + L⁺ = 0 -- L is anti-Hermitian (i*L is Hermitian)
Sp(2n) -- symplectic group:
L.J + J.L^T = 0

We get some isomorphisms:
SO(2) ~ U(1)
SO(3) ~ SU(2) ~ Sp(2)
SO(4) ~ SU(2) * SU(2)
SO(5) ~ Sp(4)
SO(6) ~ SU(4)

What does it mean that SO(3) and SU(2) are related? The rotation group for spinor (spin-1/2) wavefunctions is SU(2). They are related by SO(3) matrices being sort-of-squares of SU(2) ones, so a 360-degree rotation multiplies a spinor wavefunction by -1.

More generally, spinor groups for n-D space are groups Spin(n), though they are locally isomorphic to SO(n). Not globally, however, as we've seen for SU(2) and SO(3).

[lpetrich]

What's with two different groups having the same algebra? That gets me into the next subject, group representations.

A representation or rep of a group is a set of matrices that follow its operation table: D(a).D(b) = D(a*b)

There's one that always exists, the regular rep. Use the group's elements as its basis space, then set D(a)_cb = 1 if c = a*b, 0 otherwise.

It may be possible to turn a rep's matrices into the a shared block-diagonal form. The blocks can be separated out as reps on their own. If it's possible to do that reduction, then a rep is reducible, otherwise, it's irreducible, an irrep. More formally, if a matrix X satisfies
X.D(a) = D(a).X
for all a in the group, then for an irrep, X can only be proportional to I.

It's easy to show that all the irreps of an abelian group are 1-dimensional.

A finite group has a finite number of irreps, an infinite group an infinite number. Here are all the irreps of U(1):
D^(k)(a) = exp(i*k*a) for integer k and real a
This ought to remind you of 2D quantum-mechanical angular-momentum wavefunctions.


Representations can easily be extended to Lie algebras. Here, one can learn much of what one is likely to want by constructing the basis space of a rep without bothering to construct its matrices.

That's what one does for 3D quantum-mechanical angular-momentum wavefunctions. One constructs a set of states that share some total angular momentum while varying in projected angular momentum (the "magnetic" quantum number). These states serve as a basis space. One can construct a rotation matrix for them, and while it's fairly easy for rotating around the projection axis, its very complicated in general.
Spin 0: trivial
Spin 1/2: SU(2) ~ Spin(3) matrices
Spin 1: SO(3) matrices (derived from SU(2) ones)
Higher spins: matrices derived from SU(2) ones

For bigger algebras, one does a more complicated version of this procedure.

[lpetrich]

There are four infinite families of "simple" Lie algebras and five "exceptional" ones.
A(n) = SU(n+1)
B(n) = SO(2n+1)
C(n) = Sp(2n)
D(n) = SO(2n)
G2, F4, E6, E7, E8
Strictly speaking, D2 is "semisimple" rather than simple, since it is SO(4) ~ SU(2)*SU(2)

To see the connection between Lie algebras and field structure, let's start with a (relatively) simple example: spin and 3-space tensors.

We start with a direction vector: n = {sin(θ)*cos(φ),sin(θ)*sin(φ),cos(θ)}

We compare it with the orbital-angular-momentum wavefunctions: Y(j,m,θ,φ) for angular momentum j and projection m.

For a vector, it's easy, the 3 components of Y(1,...) map onto the 3 components of n.

Now consider a 2-tensor. N_ij = n_i*n_j. Y(2,...) has 5 components and N has 6 independent components. So while Y maps onto N, N has one component left over. What is it? Consider the identity matrix, I_ij = δ_ij. It's a 2-index object that transforms as a scalar. So one subtracts it out of N: N' = N - (1/3)I, with the (1/3) chosen to give N' 5 independent components. One now finds an exact match.

So, in general, Y(j,...) and j n's with appropriate δ's map onto each other. Thus, a j-index symmetric and traceless tensor can reasonably be said to have spin j.

We can now consider a more general 2-tensor. It splits up into a symmetric traceless 2-tensor, an antisymmetric part that contains a vector, and a part proportional to the identity matrix that's a scalar. That exactly matches how two angular momenta combine when they both have value 1:
(1) * (1) = (2) + (1) + (0)

One can continue in this vein with spinors. Two spinors combine to make a vector and a scalar:
(1/2) * (1/2) = (1) + (0)
A vector and a spinor make a vector-spinor and a spinor:
(1) * (1/2) = (3/2) + (1/2)


One gets the same connection between Lie-algebra reps and field structure in many other cases, even though the reps are often much more complicated. This has been a powerful tool for analyzing field structure and particle interactions, and that's the main reason that I wrote my Lie-algebra software.

[lpetrich]

Let's see what happens with space-time. It's 4D, and the appropriate algebra is the SO(4) one. We can express its irreps as pairs of angular momenta.

A scalar is, of course, (0,0)
A vector is (1/2,1/2) -- 2*2 = 4 components
A Dirac spinor is (1/2,0) + (0,1/2) -- 2+2 = 4 components
A Dirac spinor is reducible to two parts, one for each chirality (handedness).

Let's now consider a 2-tensor. One takes a product of two vectors:

(1/2,1/2) * (1/2,1/2) = (1,1) + (1,0) + (0,1) + (0,0)
A symmetric traceless 2-tensor, the two parts of an antisymmetric 2-tensor, and a scalar:
4*4 = 9 + 3 + 3 + 1 = 16

The antisymmetric 2-tensor splits into two, from multiplying by the 4D antisymmetric symbol. For the electromagnetic field, the electric and magnetic fields E and B combine into
E + i*B and E - i*B
It's easy to show that the two combinations get Lorentz boosted separately.

One can also get the two EM-field invariants from the two compoments.
|E + i*B|² = (E² - B²) + 2*i*(E.B)
|E - i*B|² = (E² - B²) - 2*i*(E.B)

Spinors (spin-1/2 wavefunctions) are rather complicated entities, but like vectors and tensors, they can be generalized to more space and space-time dimensions, and one finds:
Even (2n) space(-time) dimensions: two irreps with 2^n-1 components each.
Odd (2n+1) space(-time) dimensions: one irrep with 2ⁿ components.

[lpetrich]

Going from space-time and spin to quark flavors, we find some additional Lie-algebra applications.

The up, down, and strange quarks all have masses smaller than the QCD color-confinement scale, with the up and down ones being especially small. That produces some approximate flavor symmetries.

The first one discovered is between the up and down quarks, "isotopic/isobaric spin" or "isospin". It's SU(2) because of the quarks' complex wavefunctions and because of their 2 flavors, and the "spin" in its name is from what it behaves like.

Mesons have a quark-antiquark structure, and their isospins combine as:
(1/2) * (1/2) = (1) + (0)
pion and rho / eta and omega

Baryons have 3 quarks, and their isospins combine as:
(1/2) * (1/2) * (1/2) = ( (1) + (0) ) * (1/2) = (3/2) + 2 (1/2)
delta baryon / nucleon

With the strange quark, one gets the group SU(3), with the ordinary quarks being in a rep called 3, and antiquarks in a rep called 3* (properly 3 bar), because it's not equivalent to ordinary reps. In this notation, a state with spin j would be called "2j+1".

There's a nice graphical technique called "Young diagrams" for constructing SU(n) reps, and a technique called the "Littlewood-Richardson rule" for finding product reps.

The light quarks are
*
(size 3)
The light antiquarks are
*
*
(size 3*)
Quarks and antiquarks combine as
**
*
(size 8)
and * (size 1)

Two quarks make combinations ** (size 6) and
*
*
(size 3*)
Adding a third one makes combinations *** (size 10)
two
**
*
(size 8) and
*
*
*
(size 1)

The spin-3/2 light baryons form a 10 in the quark flavors, and the quarks' wavefunctions are symmetric in both spin and flavor.

The spin-1/2 light baryons form a 8 in the quark flavors, and to get their magnetic moments correct, it's necessary for the spins and flavors to have a symmetric combination.

This was a big difficulty for the quark model, because it implied that quarks follow Bose-Einstein statistics rather than the Fermi-Dirac statistics that one expects from their spins. But in QCD, the quarks also have color states, with SU(3) color symmetry. Their colors combine to make a colorless combination, a state with size 1. This is antisymmetric, and that rescues quarks' Fermi-Dirac statistics.

I could crunch through all of this with the software I'd written.

[lpetrich]

Now for symmetry breaking. Many symmetries are only approximate, and some symmetries are hidden enough to take some effort to discover. We indeed see that here.

In this thread, we first encountered it in orbital-angular-momentum wavefunctions, where we find a breakdown from rotation around all axes to rotation around some selected axis. That produces breakdown
SO(3) -> SO(2)
or
SU(2) -> U(1)

For the light quarks, we get a breakdown
SU(3) -> SU(2) * U(1)
uds to isospin (ud) and strangeness (s) + something
Yes, strangeness. Back in the 1950's or so, it became evident that some particles lasted much longer than what one might expect, and this strange property led to the naming of a new quantum number: strangeness.

The light mesons and spin-1/2 baryons:
8 -> (1,0) + (0,0) + (1/2,1) + (1/2,-1) -- pseudo angular momentum
8 -> (3,0) + (1,0) + (2,1) + (2,-1) -- multiplicity
pion, eta, kaon, antikaon
sigma, lambda, nucleon, xi

The light spin-3/2 baryons:
10 -> (3/2,1) + (1,0) + (1/2,-1) + (0,-2) -- pseudo angular momentum
10 -> (4,1) + (3,0) + (2,-1) + (1,-2) -- multiplicity
delta, sigma-x, xi-x, omega

I'm able to crunch through all of that also.

[xtifr]

Have you looked at R or Octave? Seems like one or the other or both might be a better fit that python or c++. http://www.r-project.org/ http://www.gnu.org/software/octave/

(If you already considered and rejected them, I'm curious why.)

[lpetrich]

I'm not very familiar with either R or Octave, and I hadn't considered either. But I'm willing to take requests.

Octave is an open-source imitation of Matlab, so some of my experience there could carry over.

Rosetta Code seems like a good place to look if one wants to check on how easy or hard it is to do various things in various programming languages. For instance, I didn't do a plain-C version because I would have had to write an associative array: Associative arrays/Creation/C - Rosetta Code vs. Associative array/Creation - Rosetta Code and Associative array/Iteration - Rosetta Code

I also had to integerize some of the calculations for Python, because its implementation of fractions is dog slow, at least in version 2.7.3. I carried that implementation over to C++, IIRC. I had to do fractions explicitly for C++: Arithmetic/Rational - Rosetta Code.

I have a way of estimating how much work my code has to do -- or how feasible it would be by my code's brute-force methods. For E8, especially, some simple-looking reps are surprisingly large. The difficulty is that my code calculates complete rep bases in the Cartan-Weyl basis, giving results as a list of {multiplicity, root, weight}. I use Weyl's formula for the total degeneracy or multiplicity of a rep; one that does not need an explicit rep basis. To succeed, I needed to implement bignums (Arbitrary-precision integers (included) - Rosetta Code). They are built into Mma and Python, but I had to use the GNU Scientific Library for C++.

I had to do a lot of Matrix multiplication - Rosetta Code, and I inverted matrices with Gaussian elimination - Rosetta Code. They are built into Mma, and I implemented both in Python and C++. At least I didn't have to do eigensystems.

[Klimax]

For C++ side have you looked at Boost?
http://www.boost.org/doc/libs/1_54_0.../rational.html
http://www.boost.org/doc/libs/1_54_0...tml/index.html

[ctamblyn]

Happy birthday, lpetrich, and thanks for sharing this too! Do you plan to host the source on sourceforge / github / google code or similar?

[lpetrich]

Originally Posted by Klimax

For C++ side have you looked at Boost?
http://www.boost.org/doc/libs/1_54_0.../rational.html
http://www.boost.org/doc/libs/1_54_0...tml/index.html

Titled links:
Rational Number Library - 1.54.0
Math Toolkit - 1.54.0
I like Firefox's Copy Link Text extension.

Looks good. I guess I ought to benchmark my rational-number code vs. Boost's. I didn't find any linear algebra in the Boost library, however.

I had wanted to avoid outside libraries as much as possible, but I threw in the towel about C++ bignums.

Originally Posted by ctamblyn

Happy birthday, lpetrich, and thanks for sharing this too! Do you plan to host the source on sourceforge / github / google code or similar?

I hadn't thought about that. Any good comparisons of those sites? Or should I choose one that's already hosting similar sorts of software?

I checked on simplie - a simple program for Lie algebras - Google Project Hosting and it didn't have much of what I'd implemented.

[Klimax]

Originally Posted by lpetrich

Titled links:
Rational Number Library - 1.54.0
Math Toolkit - 1.54.0
I like Firefox's Copy Link Text extension.

Looks good. I guess I ought to benchmark my rational-number code vs. Boost's. I didn't find any linear algebra in the Boost library, however.

I had wanted to avoid outside libraries as much as possible, but I threw in the towel about C++ bignums.
...

Understandable. Although you don't need full Boost, just headers and maybe implementation files. (For Pools it was sufficient...)

Was uBLAS insufficient?

[lpetrich]

A bit more that I want to explain. Gauge theory^WP, which states:

Quote:

Later Hermann Weyl, in an attempt to unify general relativity and electromagnetism, conjectured that Eichinvarianz or invariance under the change of scale (or "gauge") might also be a local symmetry of general relativity.

But the term has stuck for symmetries that are local in a theory.

Imagine a system that transforms with continuous parameters p that have the same value everywhere in it. The parameters are for a global or rigid symmetry. Now make the symmetry local or varying: p = p(x), x = space-time position. One quickly gets terms in gradients of p: D(p). So one adds a gauge particle whose field varies under the symmetry transformations so as to cancel out the D(p) terms.

My code is only for the symmetry groups of gauge theories, and these are Lie groups, of course.

Gauge particles are multiplets in the gauge symmetry, with one member for each gauge-group generator. That puts gauge particles in the gauge algebra's "adjoint representation". Its basis is the algebra generators themselves, and its matrices are composed from the algebra's structure constants.

For SO(n), the adjoint rep is antisymmetric 2-tensors. Its size is n(n-1)/2.
For SU(n), the adjoint rep is from a vector * a vector's conjugate - scalar. Its size is n^2 - 1.
For Sp(2n), the adjoint rep is symmetric 2-tensors. Its size is n(2n+1).
The five exceptional algebras are more complicated, but their adjoint-rep sizes are:
G2: 14, F4: 52, E6: 78, E7: 133, E8: 248


The first gauge theory discovered was electromagnetism or the photon. It has symmetry U(1). The unbroken Standard Model has gauge symmetry
SU(3) * SU(2) * U(1)
SU(3) = QCD, SU(2) = "weak isospin", U(1) = "weak hypercharge"
The electroweak part has symmetry SU(2) * U(1) when unbroken. But its breaking does SU(2) -> U(1) and mixes the two U(1)'s, with the only survivor being the electromagnetic U(1).

The QCD part is not broken, but instead, confined. Its gauge particle, the gluon, has 8 color states: color*anticolor with no colorless state.


Grand Unified Theories involve bigger groups: SU(5), SO(10), E6, E8, etc. I was able to work out how they break down to the Standard Model, and what reps become the Standard Model particle reps. I found it satisfying to be able to calculate that. I could also calculate which interactions are possible, something also satisfying.

[lpetrich]

Originally Posted by Klimax

Understandable. Although you don't need full Boost, just headers and maybe implementation files. (For Pools it was sufficient...)

Fair enough.

Quote:

Was uBLAS insufficient?

Thanx for pointing that out. I didn't notice it when I was looking through the list of Boost packages. It looks rather complicated, however.

I also haven't given much thought to what would be a good open-source license.

[Klimax]

Originally Posted by lpetrich

Fair enough.

Thanx for pointing that out. I didn't notice it when I was looking through the list of Boost packages. It looks rather complicated, however.

I also haven't given much thought to what would be a good open-source license.

Never tried L. Algebra in code (never got there), so can't comment on that.

Maybe LGPL to start with? (Seems to strike good balance) IMHO of course.

[Perpetual Student]

Originally Posted by lpetrich

The smallest of the "simple" Lie algebras is SU(2) ~ SO(3) ~ Sp(2). It's the algebra of quantum-mechanical angular momentum, and if you've ever done operator algebra with QM AM, you've worked with a Lie algebra. If you've ever worked with QM AM states, you've worked with that algebra's representations.

Thanks for these posts. I'm sure you know the Poisson bracket in (classical) Hamiltonian mechanics forms a Lie algebra. It's quite remarkable that this structure, which was developed in the 1830s, is so fundamental for QM when identified with the commutator.

[Senex]

Originally Posted by lpetrich

The antisymmetric 2-tensor splits into two, from multiplying by the 4D antisymmetric symbol.

I'll bite. How come you wrote "the 4D antisymmetric symbol" instead of using it? Is there really such a thing?

[xtifr]

In addition to Boost (a great project I use all the time), there's also Blitz++, a highly optimized array/vector library for scientific computing. Looking up Blitz++ also led me to C++QED, which seems like something that not only might be of interest to you, but might even be something you might be able to contribute to. It includes Python bindings.

[lpetrich]

What I mean by the antisymmetric symbol: ε_ij...k with n indices for n space dimensions. It is 1 for indices 1,2,3, ..., n, and also for even permutations of that sequence of indices, and -1 for odd permutations.

Let's see how a 2-tensor decomposes.

T_ij =
(T_ij + T_ji)/2 (symmetric: ji = ij)
+ (T_ij - T_ji)/2 (antisymmetric: ji = - ij)
n² = n(n+1)/2 + n(n-1)/2

This is as far as it goes for SU(n), but for SO(n), one can go further. The symmetric case decomposes
T_ij =
(T_ij - (1/n)*δ_ij*T_kk) (traceless)
+ (1/n)*δ_ij*T_kk (scalar)
n(n+1)/2 = (n-1)(n+2)/2 + 1

The antisymmetric case depends rather strongly on the number of dimensions.
2D:
T_ij = (1/2)*ε_ij*(ε_klT_kl) (scalar)
3D:
T_ij = (1/2)*ε_ijk*(ε_lmkT_lm) (vector)
4D:
T_ij splits in two:
T_ij = (1/2)*ε_ijkl*T_kl (self-dual, 3-vector)
T_ij = - (1/2)*ε_ijkl*T_kl (anti-self-dual, 3-vector)
6 = 3 + 3
More than 4D: no decomposition

One has to be more careful in the space-time case. Instead of the multipliers being 1 and -1, they are i and -i. That's what makes the E+i*B and E-i*B for the electromagnetic field.

[Senex]

I see, you wrote "the 4D antisymmetric symbol" instead of the equation so these other guys reading this would more easily understand, thanks.

Maybe you could proof read the math part of my paper on parallel universes that I'm almost finished with if you get a chance. I'm certain it will raise an eyebrow or two.

[lpetrich]

I'd be willing to do so.


Turning to Grand Unified Theories, here are some of the more-discussed gauge-symmetry groups that I've found:

• SU(5) -- Georgi-Glashow (the smallest SM superset with a simple group)
• SU(4)*SU(2)*SU(2) ~ SO(6)*SO(4) -- Pati-Salam (leptonness is a 4th "color" in it)
• SO(10) -- can break down to SU(5) or SO(6)*SO(4)
• SU(6) -- can break down to SU(5)
• SU(3)*SU(3)*SU(3) -- trinification (a GUT without proton decay)
• E6 -- can break down to SO(10), SU(6), or trinification
• E8 -- can break down to E6*SU(3), SO(10)*SO(6), or SU(5)*SU(5)

I've also found some speculations about "horizontal symmetries" between the generations of elementary fermions.


With my code, I was able to verify which reps of these groups break into which Standard-Model reps.

SU(5):

• G 24 -- adjoint (vector * conjg vector - scalar)
• L 1 -- scalar
• R, H 5 -- vector
• L 10 -- AS 2-tensor
• R 10* -- AS 3-tensor = conjg AS 2-tensor
• L, H 5* -- AS 4-tensor = conjg vector
• R 1 -- AS 5-tensor = scalar

L = left-handed EF, R = right-handed EF
G= gauge, H = Higgs, EF= elementary fermion
conjg = conjugate, AS = antisymmetric

SO(10):

• G 45 -- adjoint (AS 2-tensor)
• H 10 -- vector
• L 16 -- spinor
• R 16* -- conjg spinor

The elementary fermions are spinor multiplets in this gauge symmetry as well as in space-time.

[lpetrich]

The Standard Model is rather byzantine, it must be said. Its gauge-symmetry group is SU(3) * SU(2) * U(1) -- QCD + electroweak (weak isospin + weak hypercharge).

Its multiplet structures I'll list as (QCD multiplicity, WIS multiplicity, WHC "charge")

Gauge: (8,1,0), (1,3,0), (1,1,0)
Gluon, W (weak isospin), B (weak hypercharge). The latter two make the low-energy W+-, Z, and photon.

Higgs: (1,2,1/2), (1,2,-1/2)
Standard Model: 2nd = complex conjugate of 1st (same particle), supersymmetric extensions: separate particles

Elementary fermions:
Left-handed: (3,2,1/6), (1,2,-1/2), (antiparticles) (3*,1,-2/3), (3*,1,1/3), (1,1,0), (1,1,1/2)
quark, lepton, up quark, down quark, neutrino, electron
Right-handed: (3,1,2/3), (3,1,-1/3), (1,1,0), (1,1,-1/2), (antiparticles) (3*,2,-1/6), (1,2,1/2)
up quark, down quark, neutrino, electron, quark, lepton


The main difficulty with GUT's is that they exchange this complicated structure for complicated symmetry breaking. I've surveyed the literature for proposed GUT Higgs particles, and I've found quite a lot. They are also in multiplets that can get very big.

SU(5):
24: adjoint: (vector * conjg vector) - scalar
SO(10):
10: vector
45: adjoint: antisymmetric 2-tensor
16, 16*: spinors
54: symmetric traceless 2-tensor
120: AS 3-tensor
210: AS 4-tensor
126, 126*: AS 5-tensor split by antisymmetric symbol
144, 144*: (vector * spinor) - spinor
(not necessarily all of them together!)

E6:
Gauge multiplet: adjoint of course, with size 78.
Each generation of elementary fermions, and also the Higgs particles, can fit into an irrep with size 27. Their antiparticles go into 27*, its conjugate.

The GUT Higgs particles go into reps with sizes like 351, 351', 351*, 351'*, 650.

But E6 has a nice property. A symmetric product of three 27's yields, among other irreps, a scalar one. So an E6 GUT can reduce the EF-Higgs interactions to very simple form. One gets a similar result for SO(10), though it is not quite as simple. The downside of this EF-Higgs interaction unification is that it is too successful. It does not allow cross-generation decays.

I concede my code is not able to verify the detailed workings of these GUT Higgs mechanisms, since it isn't designed for that. However, I'm able to verify how all these multiplets are constructed, and what products and powers of them contain.


The sizes of some of these Higgs multiplets ought to make one suspicious, and superstring compactification (6 out of 10 space-time dimensions becoming a tiny ball) usually involves some different GUT symmetry-breaking mechanism.

[W.D.Clinger]

Originally Posted by lpetrich

I've found it difficult to find online some software to calculate what I was looking for, so I wrote it myself: SemisimpleLieAlgebras.zip

Nice.

You might consider adding a copyright notice to that software, along with a statement (such as a Creative Commons license) telling people what you are allowing them to do with it.

[lpetrich]

Still trying to decide on a good open-source license.

I was reminded of The AIPS (Astronomical Image Processing System) FAQ

Quote:

First, it was labelled as proprietary code to prevent third parties from taking the code (for free), slightly changing it, slapping a copyright on it and sueing NRAO to cease and desist from distributing the original AIPS. While this may sound unlikely, this sort of thing has happened to others. The GNU General Public License now protects NRAO and our users from this sort of scenario in a less restrictive way.

I must say that I've also put together a Mathematica notebook for finding properties of finite groups. Given an operator and some elements, it finds the rest of the group's elements and calculates various properties. I particularly like how it calculates a composition series. It finds the group's commutator group, then the commutator group's quotient group. That quotient group is abelian, and I find which prime-power cyclic groups it's composed of. After that, it repeats the process on the commutator group until it either reaches the identity group or repeats itself.

G -(Q1)-> G1 -(Q2)-> G2 ... until it stops

I'll have to get it into releasable form so I can upload it.

[lpetrich]

There are some important sorts of Lie algebras that my code won't work on, since it's only designed for semisimple ones and their decompositions.

Consider the Euclidean group, Euc(n), the group of symmetries of a flat n-space. As elsewhere, it's often much easier to study the algebra of its generators than the full group directly, and that algebra is n-space rotations, SO(n), with n-space translations or shifts, T^n, added.

The Poincaré group, the group of space-time symmetries, is related to Euc(4), much as the Lorentz group is related to SO(4). Its reps are related to elementary-particle states with:
Translation operators ~ linear momentum
Rotation operators ~ angular momentum