In this second tutorial, we continue the introduction on how to use the package GradedLieAlgebras.

By default, the scalars are assumed to be rational numbers, but it is also possible to define the coefficient field with the option Field, which is one out of four options that can be used in the constructor lieAlgebra.

i1 : F = frac(ZZ/7[x]) o1 = F o1 : FractionField |

i2 : L = lieAlgebra({a_1,a_2,a_3},Field => F)/ {3 a_1 a_2 a_3+(5*x) a_2 a_1 a_3, a_3 a_2 a_3 a_1} o2 = L o2 : LieAlgebra |

The example above specifies the Lie algebra over the fraction field of $\mathbb Z/7$ [ $x$ ] on three generators $a_1, a_2, a_3$, modulo the ideal generated by $3$ [$a_1$, [ $a_2$, $a_3$ ]] + $5x$ [ $a_2$, [ $a_1$, $a_3$ ]] and [$a_3$, [ $a_2$, [ $a_3$, $a_1$ ]]]. As input coefficients one may always use an integer or a quotient of integers with non-zero denominator in the field.

To specify weights of the generators, use the option lieAlgebra(...,Weights=>...). The weights are lists of integers of the same length, where the first degree is positive, also just called the degree, see firstDegree(LieElement). The degree is the two first inputs for the function dims(ZZ,ZZ,LieAlgebra). If the option lieAlgebra(...,LastWeightHomological=>...) is `true`, then the last degree is the homological degree, which is non-negative and less than the first degree. If the option lieAlgebra(...,LastWeightHomological=>...) is `false`, which is the default value, then the program defines the homological degree to be zero, and adds a last component 0 to the existing degrees. In this case the weights can also be given as a list of positive integers that will be the degrees. See Differential Lie algebra tutorial how to define a differential. Use weight to compute the weight of an arbitrary homogeneous Lie expression.

i3 : L = lieAlgebra({a,b,c},Weights => {{1,-1},{1,4},{2,3}}) o3 = L o3 : LieAlgebra |

i4 : weight b o4 = {1, 4, 0} o4 : List |

i5 : ex = a b+(1/3) c o5 = (1/3)c - (b a) o5 : L |

i6 : weight ex o6 = {2, 3, 0} o6 : List |

i7 : firstDegree ex o7 = 2 |

i8 : L1 = lieAlgebra({a,b,c},Weights => {1,1,2}) o8 = L1 o8 : LieAlgebra |

i9 : describe L1 o9 = generators => {a, b, c} Weights => {{1, 0}, {1, 0}, {2, 0}} Signs => {0, 0, 0} ideal => {} ambient => L1 diff => {} Field => QQ computedDegree => 0 |

To specify signs of the generators, use the option lieAlgebra(...,Signs=>...). The sign of a generator is either 0 (even) or 1 (odd). By default, the sign of all generators are 0. Writing the option as "Signs => 1" defines the signs of all the generators to be 1. The signs affect the axioms of a Lie superalgebra, see LieAlgebra. Use sign to compute the sign of an arbitrary homogeneous Lie expression.

i10 : L = lieAlgebra({a,b,c},Weights => {{1,-1},{1,4},{2,3}}, Signs=>{0,1,1}) o10 = L o10 : LieAlgebra |

i11 : ex = a b+(1/3) c o11 = (1/3)c - (b a) o11 : L |

i12 : sign ex o12 = 1 |

For each finitely presented Lie algebra $L$, `ambient(L)` represents a free Lie algebra $M$ such that $L$ (without differential) is a quotient of $M$, see also Quotient Lie algebras and subspaces. Moreover, the relations belong to $M$, even if $L$ is defined as a quotient in two or more steps from $M$. This is somewhat different from the situation for rings.

i13 : M = lieAlgebra{a,b,c} o13 = M o13 : LieAlgebra |

i14 : L = M/{a b} o14 = L o14 : LieAlgebra |

i15 : a c o15 = - (c a) o15 : L |

i16 : Q = L/{a c} o16 = Q o16 : LieAlgebra |

i17 : ideal(Q) o17 = { - (b a), - (c a)} o17 : List |

i18 : oo_1 o18 = - (c a) o18 : M |

i19 : ambient Q o19 = M o19 : LieAlgebra |

The relations may have a non-zero linear part. Use minimalPresentation(ZZ,LieAlgebra) to get a minimal presentation. Use describe(LieAlgebra) to get information about the Lie algebra. This contains the value of the three options lieAlgebra(...,Weights=>...), lieAlgebra(...,Signs=>...), lieAlgebra(...,Field=>...), and also the values generators(LieAlgebra), ideal(LieAlgebra), ambient(LieAlgebra), diff(LieAlgebra) and computedDegree(LieAlgebra)

i20 : F = lieAlgebra({a,b,c},Weights => {1,1,2}, Signs=>{1,0,0}) o20 = F o20 : LieAlgebra |

i21 : L = F/{-c+a a,(a b) a} o21 = L o21 : LieAlgebra |

i22 : dims(1,4,L) o22 = {2, 2, 1, 2} o22 : List |

i23 : describe L o23 = generators => {a, b, c} Weights => {{1, 0}, {1, 0}, {2, 0}} Signs => {1, 0, 0} ideal => { - c + (a a), - (1/2)(b a a)} ambient => F diff => {} Field => QQ computedDegree => 4 |

i24 : M = minimalPresentation(4,L) o24 = M o24 : LieAlgebra |

i25 : describe M o25 = generators => {a, b} Weights => {{1, 0}, {1, 0}} Signs => {1, 0} ideal => {(b a a)} ambient => LieAlgebra{...10...} diff => {} Field => QQ computedDegree => 0 |

In `L#cache` there is more information about $L$ collected during a computation. Some parts of the information are visible to the user, e.g., lieRing and mbRing. The ring `L#cache.lieRing` is the internal polynomial ring representation of Lie elements. The Lie monomials are represented as commutative monomials in this ring. The program produces internally an ideal of relations and a basis, which may be seen as `L#cache.gb` and `L#cache.basis`. The number of generators in lieRing is the number of generators in the Lie algebra times the internal counter `L#cache.max`, which initially is set to $5$, and is changed to $n+5$ if the computation of $L$ is performed up to degree $n$ with $n\ >$ `L#cache.max`.

i26 : L = lieAlgebra{a,b}/{a a a b,b b b a} o26 = L o26 : LieAlgebra |

i27 : dims(1,4,L) o27 = {2, 1, 2, 1} o27 : List |

i28 : peek L#cache o28 = CacheTable{ambient => LieAlgebra{...10...} } basis => MutableHashTable{...15...} degree => 4 degrees => MutableHashTable{...4...} dim => MutableHashTable{...5...} gb => MutableHashTable{...4...} generators => {a, b} lieRing => QQ[aR ..aR ] 0 9 max => 5 mbRing => QQ[mb , mb , mb , mb , mb , mb ] {1, 0} {1, 1} {2, 0} {3, 0} {3, 1} {4, 0} opL => MutableHashTable{} |

i29 : L#cache.basis#4 o29 = {aR aR aR aR } 0 3 4 7 o29 : List |

i30 : basis(4,L) o30 = {(b a b a)} o30 : List |

i31 : L#cache.gb#4 o31 = ideal (aR aR aR aR , aR aR aR aR - aR aR aR aR , aR aR aR aR ) 0 3 5 7 0 3 5 6 0 3 4 7 0 3 4 6 o31 : Ideal of QQ[aR ..aR ] 0 9 |

i32 : a b b a o32 = (b a b a) o32 : L |

i33 : dims(1,6,L) o33 = {2, 1, 2, 1, 2, 1} o33 : List |

i34 : peek L#cache o34 = CacheTable{ambient => LieAlgebra{...10...} } basis => MutableHashTable{...28...} degree => 6 degrees => MutableHashTable{...6...} dim => MutableHashTable{...7...} gb => MutableHashTable{...6...} generators => {a, b} lieRing => QQ[aR ..aR ] 0 21 max => 11 mbRing => QQ[mb , mb , mb , mb , mb , mb , mb , mb , mb ] {1, 0} {1, 1} {2, 0} {3, 0} {3, 1} {4, 0} {5, 0} {5, 1} {6, 0} opL => MutableHashTable{...10...} |

The ring `L#cache.mbRing` is used to get an output of Lie elements with indexed basis elements, which sometimes is better to use than the iterated Lie products of generators, especially in high degrees. Use indexForm to get the output in mbRing and standardForm(RingElement,LieAlgebra) to get back the standard output. The ring mbRing is very large; it has as many generators as the total dimension of the computed Lie algebra. For this reason, you should give the ring a name to avoid a large output.

i35 : L = lieAlgebra{a,b,c} o35 = L o35 : LieAlgebra |

i36 : x = (a b c a) (b c) o36 = (b c a c b a) - (b c b a c a) - (b c c a b a) - (c b a c b a) + (c b b a c a) + (c b c a b a) o36 : L |

i37 : Q = L#cache.mbRing o37 = Q o37 : PolynomialRing |

i38 : numgens Q o38 = 196 |

i39 : indexForm x o39 = mb - mb - mb + mb + mb - mb {6, 22} {6, 24} {6, 43} {6, 45} {6, 74} {6, 76} o39 : Q |

i40 : standardForm(oo,L) o40 = (b c a c b a) - (b c b a c a) - (b c c a b a) - (c b a c b a) + (c b b a c a) + (c b c a b a) o40 : L |