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.