next | previous | forward | backward | up | top | index | toc | Macaulay2 web site
GradedLieAlgebras :: Quotient Lie algebras and subspaces

Quotient Lie algebras and subspaces

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.

See also