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

Constructing Lie algebras -- An overview of ways to construct Lie algebras and maps

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.

See also