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 single 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 \ \to\ 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 \ \to\ 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.

Quotient Lie algebras and subspaces

See also