The most common situation for a Lie algebra L (in this package) is that it is finitely presented, i.e., L is given by a finite number of generators, yielding a free Lie algebra F, modulo a finite list of homogeneous elements in F. The ambient Lie algebra of L, see ambient(LieAlgebra), is equal to F.
i1 : F = lieAlgebra{a,b,c} o1 = F o1 : LieAlgebra |
i2 : M = F/{a a b, a a c} o2 = M o2 : LieAlgebra |
i3 : L1 = M/{a b c} o3 = L1 o3 : LieAlgebra |
i4 : describe M o4 = generators => {a, b, c} Weights => {{1, 0}, {1, 0}, {1, 0}} Signs => {0, 0, 0} ideal => { - (a b a), - (a c a)} ambient => F diff => {} Field => QQ computedDegree => 3 |
i5 : describe L1 o5 = generators => {a, b, c} Weights => {{1, 0}, {1, 0}, {1, 0}} Signs => {0, 0, 0} ideal => { - (a b a), - (a c a), - (b c a) + (c b a)} ambient => F diff => {} Field => QQ computedDegree => 0 |
There is also the possibility to build quotients by Lie ideals. A Lie ideal is of type LieIdeal, and may be constructed in different ways, e.g., as the kernel of a homomorphism. In general, Lie ideals are not finitely generated (or not known to be, as J below), but a finitely generated Lie ideal may be formed using the constructor lieIdeal. Building a quotient by a finitely generated ideal is the same as above, taking the Lie algebra modulo the generators of the ideal.
i6 : F = lieAlgebra{a,b,c} o6 = F o6 : LieAlgebra |
i7 : I = lieIdeal{a a b,a a c,a b c} o7 = I o7 : FGLieIdeal |
i8 : L2=F/I o8 = L2 o8 : LieAlgebra |
i9 : describe L2 o9 = generators => {a, b, c} Weights => {{1, 0}, {1, 0}, {1, 0}} Signs => {0, 0, 0} ideal => { - (a b a), - (a c a), - (b c a) + (c b a)} ambient => F diff => {} Field => QQ computedDegree => 0 |
i10 : L1==L2 o10 = true |
The Lie algebra L3 below is a quotient of the finitely presented Lie algebra M by the ideal J, which is not known to be finitely generated. The ambient Lie algebra of L3 is M and ideal(L3) is J. The Lie algebras L2 and L3 are isomorphic, but are presented in different ways.
i11 : f = map(L1,M) o11 = f o11 : LieAlgebraMap |
i12 : J = kernel f o12 = J o12 : LieIdeal |
i13 : L3 = M/J o13 = L3 o13 : LieAlgebra |
i14 : describe L3 o14 = generators => {a, b, c} Weights => {{1, 0}, {1, 0}, {1, 0}} Signs => {0, 0, 0} ideal => J ambient => M diff => {} Field => QQ computedDegree => 0 |
i15 : dims(1,6,L2) o15 = {3, 3, 5, 9, 22, 44} o15 : List |
i16 : dims(1,6,L3) o16 = {3, 3, 5, 9, 22, 44} o16 : List |
If two quotients by Lie ideals are performed successively, then the program converts the final result to a quotient of the first Lie algebra by a singel ideal. In the example below, L5=(M/J)/K and this is transformed to M/P, where P is the inverse image of K under the natural map M → M/J.
i17 : L4 = L3/{a b,a c} o17 = L4 o17 : LieAlgebra |
i18 : g = map(L4,L3) warning: the map might not be well defined, use isWellDefined o18 = g o18 : LieAlgebraMap |
i19 : K = kernel g o19 = K o19 : LieIdeal |
i20 : L5 = L3/K o20 = L5 o20 : LieAlgebra |
i21 : ambient L5 o21 = M o21 : LieAlgebra |
i22 : ideal L5===inverse(map(L3,M),K) o22 = true |
If a quotient by a Lie ideal that is not known to be finitely generated is followed by a quotient with finitely many generators, then the programs converts it by changing the order of the operations. In the example below, L6=(M/J)/{a b} and this is transformed to (M/{a b})/Q, where Q is the image of J under the natural map M → M/{a b} (this in fact is an ideal since the map is surjective).
i23 : L6 = (M/J)/{a b} o23 = L6 o23 : LieAlgebra |
i24 : L7 = ambient L6 o24 = L7 o24 : LieAlgebra |
i25 : use M |
i26 : L7 == M/{a b} o26 = true |
i27 : Q = image(map(L7,M),J) o27 = Q o27 : LieSubAlgebra |
i28 : ideal L6===new LieIdeal from Q o28 = true |
It may also happen that L has a non-zero differential, see differentialLieAlgebra. The differential is given as the list diff(L) of elements in F that consists of the values of the differential on the generators of F, see diff(LieAlgebra). Note that ideal(D) (shown below) has been produced by the program to get the square of the differential to be zero. The extra - (b b a) in ideal(L) below is added by the program to ensure that the ideal generated by b c2 is invariant under the differential.
i29 : F = lieAlgebra({a,b,c2,c3,c4},Signs=>{0,0,1,0,1}, Weights => {{1,0},{1,0},{2,1},{3,2},{5,3}}, LastWeightHomological=>true) o29 = F o29 : LieAlgebra |
i30 : D=differentialLieAlgebra{0_F,0_F,a b,a c2,a b c3} o30 = D o30 : LieAlgebra |
i31 : describe D o31 = generators => {a, b, c2, c3, c4} Weights => {{1, 0}, {1, 0}, {2, 1}, {3, 2}, {5, 3}} Signs => {0, 0, 1, 0, 1} ideal => { - (a b a), (a b a c2)} ambient => F diff => {0, 0, - (b a), (a c2), (a b c3)} Field => QQ computedDegree => 0 |
i32 : L=D/{b c2} o32 = L o32 : LieAlgebra |
i33 : describe L o33 = generators => {a, b, c2, c3, c4} Weights => {{1, 0}, {1, 0}, {2, 1}, {3, 2}, {5, 3}} Signs => {0, 0, 1, 0, 1} ideal => { - (a b a), (a b a c2), (b c2), - (b b a)} ambient => F diff => {0, 0, - (b a), (a c2), (a b c3)} Field => QQ computedDegree => 0 |
In addition to the constructor lieIdeal there are also the constructors lieSubAlgebra and lieSubSpace yielding finitely generated Lie subalgebras and finitely generated subspaces respectively.
i34 : L = lieAlgebra{a,b,c} o34 = L o34 : LieAlgebra |
i35 : A = lieSubAlgebra{a,b c} o35 = A o35 : FGLieSubAlgebra |
i36 : basis(4,A) o36 = {2 (a c b a) - (b a c a) - (c a b a)} o36 : List |
i37 : S=lieSubSpace{a,b c} o37 = S o37 : LieSubSpace |
i38 : dims(1,4,S) o38 = {1, 1, 0, 0} o38 : List |
Ideals, subalgebras and subspaces are both inputs and possible outputs of several methods. The methods image(LieAlgebraMap,LieSubSpace) and inverse(LieAlgebraMap,LieSubSpace), which are used above, have image and kernel of a Lie algebra map or derivation as special cases. The method quotient(LieIdeal,FGLieSubAlgebra) has annihilator(FGLieSubAlgebra) and center as special cases.
i39 : L = lieAlgebra{a,b,c} o39 = L o39 : LieAlgebra |
i40 : I = lieIdeal{a a c+b a c-a b a,c c a-b b a } o40 = I o40 : FGLieIdeal |
i41 : M = L/I o41 = M o41 : LieAlgebra |
i42 : J=lieIdeal{a b} o42 = J o42 : FGLieIdeal |
i43 : A = quotient(J,lieSubAlgebra{a c}) o43 = A o43 : LieSubAlgebra |
i44 : dims(1,3,A) o44 = {2, 3, 5} o44 : List |
i45 : basis(2,A) o45 = {(b a), (c a), (c b)} o45 : List |
i46 : member((c b) (a c),J) o46 = true |
One may also form the sum, LieSubSpace + LieSubSpace, and intersection, LieSubSpace @ LieSubSpace, of two Lie subspaces (in particular subalgebras or ideals).
i47 : L = lieAlgebra{a,b,c} o47 = L o47 : LieAlgebra |
i48 : I = lieIdeal{a b} o48 = I o48 : FGLieIdeal |
i49 : J = lieIdeal{b c} o49 = J o49 : FGLieIdeal |
i50 : T = I+J o50 = T o50 : FGLieIdeal |
i51 : U = I@J o51 = U o51 : LieIdeal |
i52 : dims(1,5,T) o52 = {0, 2, 6, 15, 42} o52 : List |
i53 : dims(1,5,U) o53 = {0, 0, 0, 1, 6} o53 : List |
i54 : 2*dims(1,5,I) o54 = {0, 2, 6, 16, 48} o54 : List |
Finally, the methods boundaries and cycles give the subalgebras image(d) and kernel(d) respectively, where d is the differential, while lieHomology gives the homology as a vector space.