There are three new Types in this package, LieAlgebra, MapLie and DerLie. All of them have MutableHashTable as parent. To each Type, there is a general constructor, lieAlgebra, mapLie and derLie, where the first returns a free Lie algebra. Also each element of type LieAlgebra is a Type with parent LieElement. There are two general constructions of a new Lie algebra given two Lie algebras, namely the free product, LieAlgebra * LieAlgebra, which corresponds to the free product of enveloping algebras, and the direct sum (product), LieAlgebra ** LieAlgebra, which corresponds to the tensor product of enveloping algebras. Other constructions of new Lie algebras are
diffLieAlgebra, a differential Lie algebra
LieAlgebra / List, a quotient Lie algebra
ambient, applied to L it gives a free Lie algebra of which L (without differential) is a quotient
minmodelLie, the minimal model
koszulDualLie, the Lie algebra whose enveloping algebra is the Koszul dual of a quadratic algebra
holonomyLie, the holonomy Lie algebra of a hyperplane arrangement (or matroid)
minPresLie, a minimal presentation
In the example below, we first define a Lie algebra L by the constructor lieAlgebra. Then minmodelLie is used to construct the Lie algebra M, together with the quasi-isomorphism f:M->L, which is obtained by use of the key modelmap. Also, M itself can be obtained as L.minmodel, if minmodelLie has been executed. Observe that the current Lie algebra is not changed to M. The differential in M is obtained by use of the function diffLie. Now peekLie is used to look at the different hashTables and finally extTableLie gives the dimensions of ExtUL(QQ,QQ), an expected result, since the KoszulDual of UL is QQ[x].
i1 : L = lieAlgebra({a},genSigns=>1)/{a a} o1 = L o1 : LieAlgebra |
i2 : M = minmodelLie 5 o2 = M o2 : LieAlgebra |
i3 : f = M.modelmap o3 = f o3 : MapLie |
i4 : L.minmodel o4 = M o4 : LieAlgebra |
i5 : useLie M o5 = M o5 : LieAlgebra |
i6 : d = diffLie() o6 = d o6 : DerLie |
i7 : d fr_1 o7 = (fr_0 fr_0) o7 : M |
i8 : peekLie L o8 = gensLie => {a} genWeights => {{1, 0}} genSigns => {1} relsLie => {(a a)} genDiffs => {0} field => QQ diffl => false compdeg => 5 minmodel => M |
i9 : peekLie M o9 = gensLie => {fr , fr , fr , fr , fr } 0 1 2 3 4 genWeights => {{1, 0}, {2, 1}, {3, 2}, {4, 3}, {5, 4}} genSigns => {1, 1, 1, 1, 1} relsLie => {} genDiffs => {0, (fr_0 fr_0), (fr_0 fr_1), (fr_1 fr_1) + 4 (fr_0 fr_2), 2 (fr_1 fr_2) + (fr_0 fr_3)} field => QQ diffl => true compdeg => 5 modelmap => MapLie{fr_0 => a } fr_1 => 0 fr_2 => 0 fr_3 => 0 fr_4 => 0 sourceLie => M targetLie => L |
i10 : peekLie f o10 = MapLie{fr_0 => a } fr_1 => 0 fr_2 => 0 fr_3 => 0 fr_4 => 0 sourceLie => M targetLie => L |
i11 : peekLie d o11 = fr_0 => 0 fr_1 => (fr_0 fr_0) fr_2 => (fr_0 fr_1) fr_3 => (fr_1 fr_1) + 4 (fr_0 fr_2) fr_4 => 2 (fr_1 fr_2) + (fr_0 fr_3) maplie => id sign => 1 weight => {0, -1} sourceLie => M targetLie => M |
i12 : useLie L o12 = L o12 : LieAlgebra |
i13 : extTableLie 5 o13 = | 1 0 0 0 0 | | 0 1 0 0 0 | | 0 0 1 0 0 | | 0 0 0 1 0 | | 0 0 0 0 1 | 5 5 o13 : Matrix ZZ <--- ZZ |
i14 : L1 = koszulDualLie(QQ[x]) o14 = L1 o14 : LieAlgebra |
i15 : peekLie L1 o15 = gensLie => {ko } 0 genWeights => {{1, 0}} genSigns => {1} relsLie => { - (1/2)(ko_0 ko_0)} genDiffs => {0} field => QQ diffl => false compdeg => 1 |
We see that L1 is the same Lie algebra as L, except that the name of the generator is different. Also L.compdeg=5 while L1.compdeg=1 which means that L has been computed up to degree 5 while L1 has been computed up to degree 1.
Here is the first found example of a non-Koszul algebra, due to Christer Lech. It is the polynomial algebra in four variables modulo five general quadratic forms, which may be specialized as follows.
i16 : R = QQ[x,y,z,u] o16 = R o16 : PolynomialRing |
i17 : I = {x^2,y^2,z^2,u^2,x*y+z*u} 2 2 2 2 o17 = {x , y , z , u , x*y + z*u} o17 : List |
i18 : S = R/ideal I o18 = S o18 : QuotientRing |
i19 : hilbertSeries(S,Order=>4) 2 o19 = 1 + 4T + 5T o19 : ZZ[T] |
i20 : L = koszulDualLie(S) o20 = L o20 : LieAlgebra |
i21 : extTableLie 4 o21 = | 4 0 0 0 | | 0 5 0 0 | | 0 0 0 5 | | 0 0 0 0 | 4 4 o21 : Matrix ZZ <--- ZZ |
Below is an example of the use of "formal" Lie multiplication to compute the Lie algebra of strictly upper triangular 5x5-matrices by means of its multiplication table. The relation (e14 e15) is of degree 7 and in order to compute this, the free algebra F below must be computed in degree 7, where it is of dimension 7596. To avoid this, the relations are not normalized and in this way F need not be computed. The dimensions of the quotient are then easy to compute and also a minimal presentation. The "at sign" is used as formal Lie multiplication and formal multiplication by scalars, ++ is used as formal addition and / is used as formal subtraction. Observe that "at sign" like SPACE is right associative, while / is left associative, so a/b/c means a-b-c and not a-b+c. Here is an example of a formal expression, whose normal form is zero. The normal form may be obtained by copying and pasting the expression or applying normalFormLie.
i22 : L=lieAlgebra{a,b,c} o22 = L o22 : LieAlgebra |
i23 : a@b@c/3@a@b@c/2@a@b@c++4@a@b@c o23 = (a b c) - 3 (a b c) - 2 (a b c) + 4 (a b c) o23 : L |
i24 : normalFormLie oo o24 = 0 o24 : L |
Here is the matrix example. Observe that the quotient algebra is defined by just giving the value of F.relsLie. In this way there is no checking done of the correctness of the relations. Writing the quotient in the usual way as F/(F.relsLie) has however the effect that F.relsLie is computed.
i25 : F=lieAlgebra({e12,e23,e34,e45,e13,e24,e35,e14,e25,e15}, genWeights=>{1,1,1,1,2,2,2,3,3,4}) o25 = F o25 : LieAlgebra |
i26 : F.relsLie={e12@e34,e12@e45,e23@e45,e12@e13,e12@e35,e12@e14, e12@e15,e23@e45,e23@e13,e23@e24,e23@e14,e23@e25, e23@e15,e34@e24,e34@e35,e34@e14,e34@e25,e34@e15, e45@e13,e45@e35,e45@e25,e45@e15,e13@e24,e13@e14, e13@e25,e13@e15,e24@e35,e24@e14,e24@e25,e24@e15, e35@e14,e35@e25,e35@e15,e14@e25,e14@e15,e25@e15, e12@e23/e13, e12@e24/e14, e12@e25/e15, e13@e34/e14, e13@e35/e15, e14@e45/e15, e23@e34/e24, e23@e35/e25, e24@e45/e25, e34@e45/e35} o26 = {(e12 e34), (e12 e45), (e23 e45), (e12 e13), (e12 e35), (e12 e14), (e12 ----------------------------------------------------------------------- e15), (e23 e45), (e23 e13), (e23 e24), (e23 e14), (e23 e25), (e23 e15), ----------------------------------------------------------------------- (e34 e24), (e34 e35), (e34 e14), (e34 e25), (e34 e15), (e45 e13), (e45 ----------------------------------------------------------------------- e35), (e45 e25), (e45 e15), (e13 e24), (e13 e14), (e13 e25), (e13 e15), ----------------------------------------------------------------------- (e24 e35), (e24 e14), (e24 e25), (e24 e15), (e35 e14), (e35 e25), (e35 ----------------------------------------------------------------------- e15), (e14 e25), (e14 e15), (e25 e15), (e12 e23) - e13, (e12 e24) - ----------------------------------------------------------------------- e14, (e12 e25) - e15, (e13 e34) - e14, (e13 e35) - e15, (e14 e45) - ----------------------------------------------------------------------- e15, (e23 e34) - e24, (e23 e35) - e25, (e24 e45) - e25, (e34 e45) - ----------------------------------------------------------------------- e35} o26 : List |
i27 : dimsLie 5 o27 = {4, 3, 2, 1, 0} o27 : List |
i28 : peekLie minPresLie 4 o28 = gensLie => {e12, e23, e34, e45} genWeights => {{1, 0}, {1, 0}, {1, 0}, {1, 0}} genSigns => {0, 0, 0, 0} relsLie => {(e45 e23), (e45 e12), (e34 e12), (e45 e45 e34), (e34 e45 e34), (e34 e34 e23), (e23 e34 e23), (e23 e23 e12), (e12 e23 e12)} genDiffs => {0, 0, 0, 0} field => QQ diffl => false compdeg => 1 |
The following example shows a way to determine the derivations of a Lie algebra studied by David Anick, which may be seen as the positive part of the twisted loop algebra on sl2.
i29 : L = lieAlgebra({a,b})/{a a a b,b b b a} o29 = L o29 : LieAlgebra |
i30 : dimsLie 20 o30 = {2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1} o30 : List |
The derivations of degree 0 is 2-dimensional and contains the Euler derivation, which is the identity in degree one.
i31 : deuler = derLie({a,b}) o31 = deuler o31 : DerLie |
i32 : deuler b a b a b a b a o32 = 8 (b a b a b a b a) o32 : L |
The linear maps from degree 1 to degree 7 is 4-dimensional. Not all of them define derivations.
i33 : basisLie 7 o33 = {(a b a b a b a), (b b a b a b a)} o33 : List |
i34 : da61 = derLie{a b a b a b a,L.zz} o34 = da61 o34 : DerLie |
i35 : db61 = derLie{L.zz,a b a b a b a} the derivation is not welldefined |
i36 : da62 = derLie{b b a b a b a,L.zz} the derivation is not welldefined |
i37 : db62 = derLie{L.zz,b b a b a b a} o37 = db62 o37 : DerLie |
Hence, da61 and db62 are derivations. To determine if a linear combination of db61 and da62 is a derivation (i.e., maps the relations in L to zero), we consider derivations from the free Lie algebra on a,b to L.
i38 : M = lieAlgebra({a,b}) o38 = M o38 : LieAlgebra |
i39 : f = imapLie(L,M) o39 = f o39 : MapLie |
i40 : useLie L o40 = L o40 : LieAlgebra |
i41 : dMb61 = derLie(f,{L.zz,a b a b a b a}) o41 = dMb61 o41 : DerLie |
i42 : dMa62 = derLie(f,{b b a b a b a,L.zz}) o42 = dMa62 o42 : DerLie |
i43 : useLie M o43 = M o43 : LieAlgebra |
i44 : dMb61 a a a b o44 = 0 o44 : L |
i45 : dMa62 a a a b o45 = 2 (b a b a b a b a b a) o45 : L |
It follows that the only linear combination of dMb61 and dMa62 which is zero on (a a a b) is dMb61, but we have seen that db61 is not a derivation on L. Hence the derivations of degree 6 is 2-dimensional. Also, da61 + db62 is the inner derivation corresponding to right multiplication with the basis element of degree 6, (b a b a b a). This is seen by using multListLie (one could also have used SPACE as multiplication operator on the lists).
i46 : peekLie(da61+db62) o46 = a => (a b a b a b a) b => (b b a b a b a) maplie => id sign => 0 weight => {6, 0} sourceLie => L targetLie => L |
i47 : multListLie({a,b},{b a b a b a}) o47 = {(a b a b a b a), (b b a b a b a)} o47 : List |
Since the dimension of the Lie algebra in degree 8 is one, the dimension of the derivations of degree 7 is at most 2.
i48 : useLie L o48 = L o48 : LieAlgebra |
i49 : peekLie derLie({b a b a b a b a,L.zz}) o49 = a => (b a b a b a b a) b => 0 maplie => id sign => 0 weight => {7, 0} sourceLie => L targetLie => L |
i50 : peekLie derLie({L.zz,b a b a b a b a}) o50 = a => 0 b => (b a b a b a b a) maplie => id sign => 0 weight => {7, 0} sourceLie => L targetLie => L |
i51 : {a,b} {(basisLie 7)_1} o51 = {(b a b a b a b a), 0} o51 : List |
i52 : {a,b} {(basisLie 7)_0} o52 = {0, (b a b a b a b a)} o52 : List |
From the above, it follows that the derivations of degree 7 is also 2-dimensional, but all are inner derivations. The conclusion is that the derivations of L of positive degree modulo the inner derivations is 1-dimensional in all even degrees, and 0 in all odd degrees. We may also use DerLie DerLie to examine the structure of this quotient Lie algebra.
i53 : d2 = derLie({a b a,L.zz}) o53 = d2 o53 : DerLie |
i54 : d4 = derLie({a b a b a,L.zz}) o54 = d4 o54 : DerLie |
i55 : peekLie d2 d4 o55 = a => (a b a b a b a) b => 0 maplie => id sign => 0 weight => {6, 0} sourceLie => L targetLie => L |
Define dn (n>=2, n even) as the derivation which maps a to (a b a b ... a] of length n+1 and b to 0. It follows from above that [d2,d4]=d6.
i56 : d6 = derLie({a b a b a b a,L.zz}) o56 = d6 o56 : DerLie |
i57 : peekLie d2 d6 o57 = a => 2 (a b a b a b a b a) b => 0 maplie => id sign => 0 weight => {8, 0} sourceLie => L targetLie => L |
i58 : d16 = derLie({a b a b a b a b a b a b a b a b a,L.zz}) o58 = d16 o58 : DerLie |
i59 : peekLie d2 d16 o59 = a => 7 (a b a b a b a b a b a b a b a b a b a) b => 0 maplie => id sign => 0 weight => {18, 0} sourceLie => L targetLie => L |
It follows that [d2,d6]=2d8 and [d2,d16]=7d18. In fact, this Lie algebra is the infinite dimensional filiform Lie algebra, which is the Witt algebra in positive degrees (with a degree doubling).
See Holonomy Lie algebras and Symmetries for some examples on how to use the constructor holonomyLie.