LieAlgebra Lessons
Lesson 6: Decompositions
|
Overview
|
|
In this lesson you will learn to do the following.
–
|
Determine if a Lie algebra is decomposable into a direct sum of 2 or more Lie algebras and, if so, explicitly find the decomposition.
|
–
|
Calculate a Levi decomposition of a Lie algebra into a semi-direct sum of its radical and a semi-simple Lie algebra.
|
|
|
Decompose a Lie into a direct sum of Lie algebras
|
|
An (internal) direct sum decomposition of a Lie algebra g is given by a collection of subalgebras g1, g2, ..., gN such that [i] g = g1 + g2 + ... + gN, [ii] the intersection of any two distinct summands gi and gj, i <> j is trivial, and [iii] the Lie bracket of any two distinct gi and gj is trivial, that is, [gi, gj] = 0.
The decomposition of a Lie algebra can obtained using the Decompose command. Note that the Decompose command admits a number of keyword optional arguments which are described in detail in the help page. In section we shall define a define a 7 dimensional Lie algebra Alg and use the Decompose command to
show that Alg is a direct sum of 3 dimensional Lie algebra which is semi-simple, a 2 dimensional solvable algebra, and a 2 dimensional Abelian algebra.
>
|
with(DifferentialGeometry): with(LieAlgebras):
|
Define and initialize the 7 dimensional algebra Alg.
>
|
L := _DG([["LieAlgebra", Alg1, [7]], [[[1, 2, 1], 2], [[1, 2, 2], 1], [[1, 2, 3], 3], [[1, 2, 4], 3], [[1, 2, 5], 1], [[1, 2, 6], -2], [[1, 2, 7], -4], [[1, 4, 5], 1/3], [[1, 4, 6], -2/3], [[1, 5, 4], -4], [[1, 6, 4], 1], [[1, 7, 4], -1], [[1, 7, 5], 1/3], [[1, 7, 6], -2/3], [[2, 3, 1], 2], [[2, 3, 2], 1], [[2, 3, 3], 3], [[2, 3, 4], 3], [[2, 3, 5], 2/3], [[2, 3, 6], -4/3], [[2, 3, 7], -4], [[2, 5, 1], 4], [[2, 5, 3], 4], [[2, 5, 4], 4], [[2, 5, 5], 1], [[2, 5, 6], -2], [[2, 5, 7], -4], [[2, 6, 1], -1], [[2, 6, 3], -1], [[2, 6, 4], -1], [[2, 6, 7], 1], [[2, 7, 1], 1], [[2, 7, 3], 1], [[2, 7, 4], 1], [[2, 7, 7], -1], [[4, 5, 1], 4], [[4, 5, 3], 4], [[4, 5, 4], 4], [[4, 5, 5], 1], [[4, 5, 6], -2], [[4, 5, 7], -4], [[4, 6, 1], -1], [[4, 6, 3], -1], [[4, 6, 4], -1], [[4, 6, 7], 1], [[4, 7, 1], 1], [[4, 7, 3], 1], [[4, 7, 4], 1], [[4, 7, 7], -1], [[5, 6, 4], -3], [[5, 7, 1], -4], [[5, 7, 3], -4], [[5, 7, 4], -1], [[5, 7, 5], -1], [[5, 7, 6], 2], [[5, 7, 7], 4], [[6, 7, 1], 1], [[6, 7, 3], 1], [[6, 7, 4], 1], [[6, 7, 7], -1]]]);
|
| (2.1) |
We can use the Query command to determine that the algebra is decomposable.
Alg1 >
|
Query("Indecomposable");
|
| (2.2) |
To actually find the direct sum decomposition, we use the Decompose command. With the optional argument factoralgebras = true, the Decompose procedure will return the Lie algebra data structures for each Lie algebra summand in the direct sum decomposition.
Alg1 >
|
decomposition := Decompose(factoralgebras = true);
|
| (2.3) |
The output here is a list consisting of three entries. The first entry in the list is a matrix which defines a Lie algebra isomorphism from Alg1 to the Lie algebra defined by the basis given in the second entry. It is in this basis that the Lie algebra decomposes into a direct sum. The third entry is the list of Lie algebra data structures for each of the summands. There are a variety of ways one can verify that this decomposition is correct.
One approach is to calculate the structure equations for the Lie algebra with respect to the basis decomposition[2], initialize the result and verify that the Lie algebra is a direct sum in this new basis.
Alg1 >
|
L2 := LieAlgebraData(decomposition[2], Alg2);
|
| (2.4) |
Alg1 >
|
DGsetup(L2, [f], [omega]);
|
| (2.5) |
Alg2 >
|
MultiplicationTable("LieTable");
|
| (2.6) |
From the multiplication table we see that Alg2, which is same abstract Lie algebra as Alg1(just given in a different basis) is the direct sum of the
subalgebras S1, S2, S3 defined by:
Alg2 >
|
S1 := [f1, f2, f3];
|
| (2.7) |
| (2.8) |
| (2.9) |
We check that each of S1, S2, S3 is a subalgebra and that [Si, Sj] = 0 for i <>j.
Alg2 >
|
Query(S1, "Subalgebra"), Query(S2, "Subalgebra"), Query(S3, "Subalgebra");
|
| (2.10) |
Alg2 >
|
BracketOfSubspaces(S1,S2), BracketOfSubspaces(S1,S3),BracketOfSubspaces(S2,S3);
|
| (2.11) |
This can be all be checked with the Query command.
Alg2 >
|
Query([S1,S2,S3], "DirectSumDecomposition");
|
| (2.12) |
We can also use the Query command to verify that the the matrix A =decomposition[1] is a Lie algebra homomorphism from Alg1 to Alg2
Alg2 >
|
Query(Alg1, Alg2, decomposition[1], "Homomorphism");
|
| (2.13) |
Note that this check can actully be performed in the orginal basis for Alg1:
| (2.14) |
| (2.15) |
| (2.16) |
| (2.17) |
Alg1 >
|
Query([T1, T2, T3], "DirectSumDecomposition");
|
| (2.18) |
We can also use the third entry in the ouput of the Decompose command to construct the direct sum of the 3 given algebras. The resulting structure equations are
identical to the structure equations L2 for the basis decomposition[2].
Alg1 >
|
L3 := DirectSum(decomposition[3], Alg3);
|
| (2.19) |
| (2.20) |
Finally, we can initialize any one of the summands in the third entry of the output and study its properties. For example, we find that the first summand is seni-simple.
Alg1 >
|
DGsetup(decomposition[3][1]);
|
| (2.21) |
Alg1:Factor1 >
|
Query("Semisimple");
|
| (2.22) |
|
|
Calculate the Levi decomposition of a Lie algebra
|
|
Every Lie algebra g admits a decomposition into the semi-direct sum g = r + s, where r is the radical of g and s is a semi-simple subalgebra. Such a decomposition is called a Levi decomposition. Since the radical is an ideal we have [r, r] in r, [r, s] in r, and [s, s] in s. The radical r is uniquely defined but the semi-simple subalgebra s is not.
We demostrate the calculation of the Levi decomposition using the LeviDecomposition command.
>
|
with(DifferentialGeometry): with(LieAlgebras):
|
>
|
L := _DG([["LieAlgebra", Alg1, [7]], [[[1, 2, 2], 2], [[1, 3, 2], -1], [[1, 3, 3], -2], [[1, 3, 4], 1], [[1, 3, 5], -1], [[1, 3, 7], 2], [[1, 4, 4], 2], [[1, 6, 6], -2], [[1, 7, 2], -1], [[1, 7, 4], 1], [[2, 3, 1], 1], [[2, 3, 2], 1], [[2, 3, 4], -1], [[2, 5, 2], -2], [[2, 5, 4], 2], [[2, 6, 5], 1], [[3, 4, 1], -1], [[3, 4, 5], 1], [[3, 5, 5], -1], [[3, 5, 6], 2], [[3, 6, 6], -1], [[4, 5, 2], -2], [[4, 5, 4], 2], [[4, 6, 5], 1], [[4, 7, 2], -1], [[4, 7, 4], 1], [[5, 7, 5], 1], [[6, 7, 6], 1]]]);
|
Alg1:Factor1 >
|
DGsetup(L);
|
| (3.1) |
Alg1 >
|
LD := LeviDecomposition();
|
| (3.2) |
The radical is given by the first list, the semisimple subalgebra by the second:
| (3.3) |
| (3.4) |
We use the Query command to check that that R and S have the required properties.
Alg1 >
|
Query(R, "Ideal"), Query(R, "Solvable"),Query(S,"Semisimple");
|
| (3.5) |
Let us change to a basis adapted to the Levi decomposition.
Alg1 >
|
B := [op(R), op(S)];
|
| (3.6) |
Alg1 >
|
L1 := LieAlgebraData(B, Alg2);
|
| (3.7) |
| (3.8) |
The structure equations in this adapted basis are much simpler. From the multiplication table, we can see clearly that [e1, e2, e3, e4] (the radical in the new basis) is an ideal and [e5, e6, e7] (the semisimple part) is a subalgebra.
Alg2 >
|
MultiplicationTable("LieTable");
|
| (3.9) |
To show that the semisimple subalgebra is S is not unique, we find an automorphism of the orginal Lie algebra Alg and apply it to the vectors in our Levi decomposition.
Alg2 >
|
ChangeFrame(Alg1);
|
| (3.10) |
Define a matrix A and use it to define a linear transformation from Alg1 to Alg1.
Alg1 >
|
A := Matrix([[1, 0, -1, 0, 0, 0, 0], [0, 1, 1, 0, 2, -1, 1], [0, 0, 1, 0, 0, 0, 0], [2, 0, -2, 1, -2, 1, -1], [0, 0, 1, 0, 1, -1, 0], [0, 0, 0, 0, 0, 1, 0], [0, 0, 0, 0, 0, 0, 1]]);
|
| (3.11) |
Alg1 >
|
phi := Transformation(Alg1, Alg1, A);
|
| (3.12) |
Check that phi is a Lie algebra homomorphism.
Alg1 >
|
Query(phi,"Homomorphism");
|
| (3.13) |
Apply the automorphism phi to the vectors in the radical.
| (3.14) |
Alg1 >
|
newR := map2(ApplyHomomorphism, phi, R);
|
| (3.15) |
Alg1 >
|
newR := Tools:-CanonicalBasis(newR, [e1,e2,e3,e4,e5,e6,e7]);
|
| (3.16) |
This is exactly the same same as R, illustrating the fact that the radical is an automorphism invariant.
Apply the automorphism phi to the vectors in the semisimple algebral.
| (3.17) |
Alg1 >
|
newS := map2(ApplyHomomorphism, phi, S);
|
| (3.18) |
Alg1 >
|
newS := Tools:-CanonicalBasis(newS, [e1,e2,e3,e4,e5,e6,e7]);
|
| (3.19) |
Alg1 >
|
Tools:-DGequal(S,newS);
|
| (3.20) |
Thus the semisimple algebra S is changed by the automorphism phi. This gives us a second Levi-decomposition:
Alg1 >
|
newLD := [newR, newS];
|
| (3.21) |
|
�Ian M. Anderson 2006
|