Lesson 3: New Lie Algebras from Old
Construct a Lie algebra from a subalgebra
Change the basis of a Lie algebra
Form the direct sums of a list of Lie algebras
Quotient (or factor) Lie algebras
In Lesson 1, we saw how to construct a Lie algebra data structure which can then be used to initialize a Lie algebra with the DGsetup command. In this lesson, we show how to construct new Lie algebras from a Lie algebra which has already been initialized.
You will learn to do the following:
Construct a Lie algebra from a subalgebra.
Change the basis of a Lie algebra.
Form the direct sums of a list of Lie algebras.
Quotient (or factor) a Lie algebra by an ideal.
There are other commands in the LieAlgebras package for creating Lie algebras, not covered in this lesson. See Complexify, SemiDirectSum, Extensions.
If h is a subalgebra of a Lie algebra g, then the command LieAlgebraData can be used to create a Lie algebra data structure for h. With this data structure, h can then be initialized as a Lie algebra in its own right.
with(DifferentialGeometry): with(LieAlgebras): with(Library):
Retrieve a Lie algebra from the DifferentialGeometry Library and initialize it with the DGsetup command.
L := Retrieve("Winternitz", 1, [5, 23], Alg1);
L ≔ e1,e5=2⁢e1,e2,e3=e1,e2,e5=e2+e3,e3,e5=e3,e4,e5=b⁢e4
Lie algebra: Alg1
Check that the span of the vectors S define a subalgebra of Alg1.
S := [e3, e4, e5];
S ≔ e3,e4,e5
Generate the structure equations for the subalgebra. Since we are now viewing S as defining an abstract Lie algebra (and not as a subalgebra of Alg1), the labeling of the vectors has changed e3 -> e1, e4 -> e2, e5 -> e3.
L2 := LieAlgebraData(S, Alg2);
L2 ≔ e1,e3=e1,e2,e3=b⁢e2
Lie algebra: Alg2
MultiplicationTable(Alg1, "LieTable"), MultiplicationTable(Alg2, "LieTable");
If we want to keep track of the fact that the vectors for the new Lie algebra Alg2 corresponded to e3, e4, e5 in Alg1, we can, for example, specify labels f3, f4, f5 for the vectors in Alg2.
DGsetup(L2, [f3, f4, f5], [sigma3, sigma4, sigma5]);
If h is a subalgebra of g, then the inclusion map iota: h -> g is a Lie algebra homomorphism. The matrix representation of this homomorphism can be obtained from the LieAlgebraData command by adding the option argument "Matrix" to the calling sequence.
L2, M := LieAlgebraData(S, Alg2, "Matrix");
L2,M ≔ e1,e3=e1,e2,e3=b⁢e2,000000100010001
We can use the Query command to check that the matrix M is the matrix representation of a homomorphism from Alg2 to Alg1.
Query(Alg2, Alg1, M, "Homomorphism");
Finally, we can use the matrix M to define a transformation from Alg2 to Alg1. The output shows that f3 -> e3, f4 -> e4, and f5 -> e5.
iota := Transformation(Alg2, Alg1, M);
ι ≔ f3,e3,f4,e4,f5,e5
The are many situations where it is desirable to reinitialize a given Lie algebra in a different basis. This can be done with the LieAlgebraData procedure using the same calling sequences as in the previous paragraph. (Think of the new basis as specifying a subalgebra of the given algebra.)
In the example, that follows we shall define a 4 dimensional Lie algebra, calculate its derived algebra (DerivedAlgebra), and then reinitialize the Lie algebra so that the derived algebra is [e1, e2, e3]. The structure equations for the reinitialized algebra are much simpler.
Define a certain 4-dimensional Lie algebra. Note that there are 6 non-zero brackets.
L1 := _DG([["LieAlgebra", Alg1, ], [[[1, 2, 2], -1], [[1, 2, 4], 2], [[1, 4, 4], 1], [[2, 3, 2], 1], [[2, 3, 4], -2], [[2, 4, 1], 1], [[2, 4, 3], -1], [[3, 4, 4], 1]]]);
L1 ≔ e1,e2=−e2+2⁢e4,e1,e4=e4,e2,e3=e2−2⁢e4,e2,e4=e1−e3,e3,e4=e4
Calculate the derived algebra of Alg1.
DA := DerivedAlgebra();
DA ≔ −e2+2⁢e4,e4,e1−e3
Define a new basis for Alg1 using the vectors in the derived algebra and any 4th vector which is independent of the vectors in the derived algebra. We chose e3.
B:= [op(DA), e3];
B ≔ −e2+2⁢e4,e4,e1−e3,e3
Obtain the structure equations which respect to this new basis. Note that there are now only 3 non-zero brackets.
L2, M := LieAlgebraData(B, Alg2, M);
L2,M ≔ e1,e2=−⁢e3,e1,e4=e1−2⁢e2,e2,e4=−⁢e2,0010−100000−112100
Initialize the Lie algebra Alg2.
DGsetup(L2, [f], [theta]);
Check that the matrix M defines a Lie algebra isomorphism from Alg2 to Alg1.
The DirectSum command accepts a sequence of Lie algebra names or Lie algebra data structures and returns the direct sum of the algebras. In the following example, we create a 7 dimensional Lie algebra from a 2 dimensional abelian Lie algebra, a 2 dimensional solvable Lie algebra, and the 3 dimensional algebra of 2x2 trace-free matrices.
L1 := LieAlgebraData([[x1, x2]=0], [x1, x2], Alg1);
L2 := LieAlgebraData([[x1, x2] = x1], [x1, x2], Alg2);
L2 ≔ e1,e2=e1
L3 := LieAlgebraData([Matrix([[0, 1], [0, 0]]), Matrix([[1, 0], [0, -1]]), Matrix([[0, 0], [1, 0]])], Alg3);
L3 ≔ e1,e2=−2⁢e1,e1,e3=e2,e2,e3=−2⁢e3
Use the command DirectSum to create the direct sum of the Lie algebras L1, L2, L3.
L4 := DirectSum([L1, L2, L3], Alg4);
L4 ≔ e3,e4=e3,e5,e6=−2⁢e5,e5,e7=e6,e6,e7=−2⁢e7
Lie algebra: Alg4
Let g be a Lie algebra and h an ideal in g. Then elements of the quotient algebra g/h are the h cosets x + h, where x in g. The Lie bracket on g/h is defined by [x + h, y + h] = [x, y] + h. The fact that h is an ideal of g insures that this bracket is well-defined. If vectors y_1, y_2, ... y_r form a basis for a complement m to h, then the cosets y_1 + h, y_2 + h, ..., y_r + h form a basis for g/h. The program QuotientAlgebra creates a Lie algebra data structure for the quotient algebra g/h using the vectors in the complement m as the representative basis elements for g/h.
In the example that follows, we do the following:
[i] initialize a 7 dimensional Lie algebra.
[ii] calculate its nilradical.
[iii] check that the nilradical is an ideal.
[iv] calculate a complement to the nilradical n in g.
[v] calculate the quotient algebra g/n.
[vi] define the projection map from g to g/n and verify that it is a homomorphism.
restart: with(DifferentialGeometry): with(LieAlgebras): with(Library):
Part [i] Retrieve a Lie algebra from the DifferentialGeometry Library and initialize it with the DGsetup command.
L := Retrieve("Turkowski", 1, [7, 5], Alg1);
L ≔ e1,e2=2⁢e2,e1,e3=−2⁢e3,e1,e4=2⁢e4,e1,e6=−2⁢e6,e2,e3=e1,e2,e5=2⁢e4,e2,e6=e5,e3,e4=e5,e3,e5=2⁢e6,e4,e7=e4,e5,e7=e5,e6,e7=e6
Part [ii] Calculate the nilradical of Alg1.
n := Nilradical();
n ≔ e4,e5,e6
Part [iii] Use the Query program to check that the nilradical is an ideal.
Part [iv] In order to calculate the structure equations for the quotient algebra g/n, it is necessary to specify a basis for g/n. We do this by giving a basis for a complementary subspace to n in g. In this example, it is easy to see that [e1, e2, e3, e7] is such a complement -- in more complicated examples a complement can be calculated using the ComplementaryBasis program.
F := Tools:-DGinfo("FrameBaseVectors");
F ≔ e1,e2,e3,e4,e5,e6,e7
m := ComplementaryBasis(n, F);
m ≔ e1,e2,e3,e7
So the basis we will use for the quotient consists of the 4 independent cosets e1 + n, e2 + n, e3 + n, e7 + n. Pass this information to the QuotientAlgebra command.
L2 := QuotientAlgebra(n, m, Alg2);
L2 ≔ e1,e2=2⁢e2,e1,e3=−2⁢e3,e2,e3=e1
DGsetup(L2, [f], [alpha]);
We can obtain the matrix defining the projection map from g to g/n by including the optional argument "Matrix" in the calling sequence for QuotientAlgebra.
L2, M := QuotientAlgebra(n, m, Alg2, "Matrix");
L2,M ≔ e1,e2=2⁢e2,e1,e3=−⋅2⁢e3,e2,e3=e1,1000000010000000100000000001
Check that M defines a homomorphism from Alg1 to Alg2 and define the associated transformation.
Query(Alg1, Alg2, M, "Homomorphism");
pi := Transformation(Alg1, Alg2, M);
π ≔ e1,f1,e2,f2,e3,f3,e4,0⁢f1,e5,0⁢f1,e6,0⁢f1,e7,f4
To see this transformation 'at work', let us apply it to the vector X.
X := e1 + 2*e3 - 4*e4 + e6 + 5 *e7;
X ≔ e1+2⁢e3−4⁢e4+e6+5⁢e7
The kernel of the projection map g -> g/n is the nilradical n. This can be computed with the command HomomorphismSubalgebras.
Download Help Document
What kind of issue would you like to report? (Optional)