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 as immediate ancestor MutableHashTable. To each Type, there is a general constructor, lieAlgebra, mapLie and derLie.

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 peek is used to look at the different hashTables and finally extAlgLie gives the dimensions of ExtUL(QQ,QQ), an expected result, since the KoszulDual of UL is QQ[x].

i1 : L = lieAlgebra({a},{[a,a]},genSigns=>1)

o1 = L

o1 : LieAlgebra
i2 : M = minmodelLie 5

o2 = M

o2 : LieAlgebra
i3 : L.minmodel

o3 = M

o3 : LieAlgebra
i4 : f = M.modelmap

o4 = f

o4 : MapLie
i5 : useLie M

o5 = M

o5 : LieAlgebra
i6 : d = diffLie()

o6 = d

o6 : DerLie
i7 : peek L

o7 = LieAlgebra{cache => CacheTable{...10...}}
                compdeg => 5
                deglength => 2
                field => QQ
                genDiffs => {[]}
                genSigns => {1}
                gensLie => {a}
                genWeights => {{1, 0}}
                minmodel => M
                numGen => 1
                relsLie => {[a, a]}
i8 : peek M

o8 = LieAlgebra{cache => CacheTable{...10...}                                                                                   }
                compdeg => 5
                deglength => 2
                field => QQ
                genDiffs => {[], [fr , fr ], [fr , fr ], {{1, 4}, {[fr , fr ], [fr , fr ]}}, {{2, 1}, {[fr , fr ], [fr , fr ]}}}
                                    0    0      0    1                1    1      0    2                  1    2      0    3
                genSigns => {1, 1, 1, 1, 1}
                gensLie => {fr , fr , fr , fr , fr }
                              0    1    2    3    4
                genWeights => {{1, 0}, {2, 1}, {3, 2}, {4, 3}, {5, 4}}
                modelmap => f
                numGen => 5
                relsLie => {}
                targetLie => L
i9 : peek f

o9 = MapLie{fr  => []     }
              1
            fr  => []
              2
            fr  => []
              3
            fr  => []
              4
            fr  => [a]
              0
            sourceLie => M
            targetLie => L
i10 : peek d

o10 = DerLie{fr  => []                                }
               0
             fr  => [fr , fr ]
               1       0    0
             fr  => [fr , fr ]
               2       0    1
             fr  => {{1, 4}, {[fr , fr ], [fr , fr ]}}
               3                 1    1      0    2
             fr  => {{2, 1}, {[fr , fr ], [fr , fr ]}}
               4                 1    2      0    3
             maplie => MapLie{...7...}
             signDer => 1
             sourceLie => M
             targetLie => M
             weightDer => {0, -1}
i11 : useLie L

o11 = L

o11 : LieAlgebra
i12 : extAlgLie 5

o12 = | 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
o12 : Matrix ZZ  <--- ZZ
i13 : L1=koszulDualLie(QQ[x])

o13 = L1

o13 : LieAlgebra
i14 : peek L1

o14 = LieAlgebra{cache => CacheTable{...9...}}
                 compdeg => 0
                 deglength => 2
                 field => QQ
                 genDiffs => {[]}
                 genSigns => {1}
                 gensLie => {ko }
                               0
                 genWeights => {{1, 0}}
                 numGen => 1
                 relsLie => {[ko , ko ]}
                                0    0

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=0 which means that L has been computed up to degree 5 while L1 is not computed.

The differential d in M may also be constructed using derLie.

i15 : useLie M

o15 = M

o15 : LieAlgebra
i16 : d1=derLie({[],[fr_0,fr_0],[fr_0,fr_1],
              {{1,4},{[fr_1,fr_1],[fr_0,fr_2]}},
              {{2,1},{[fr_1,fr_2],[fr_0,fr_3]}}})

o16 = d1

o16 : DerLie
i17 : peek d1

o17 = DerLie{fr  => []                                }
               0
             fr  => [fr , fr ]
               1       0    0
             fr  => [fr , fr ]
               2       0    1
             fr  => {{1, 4}, {[fr , fr ], [fr , fr ]}}
               3                 1    1      0    2
             fr  => {{2, 1}, {[fr , fr ], [fr , fr ]}}
               4                 1    2      0    3
             maplie => MapLie{...7...}
             signDer => 1
             sourceLie => M
             targetLie => M
             weightDer => {0, -1}
i18 : peek d1.maplie

o18 = MapLie{fr  => [fr ]  }
               0       0
             fr  => [fr ]
               1       1
             fr  => [fr ]
               2       2
             fr  => [fr ]
               3       3
             fr  => [fr ]
               4       4
             sourceLie => M
             targetLie => M

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.

i19 : R=QQ[x,y,z,u]

o19 = R

o19 : PolynomialRing
i20 : I={x^2,y^2,z^2,u^2,x*y+z*u}

        2   2   2   2
o20 = {x , y , z , u , x*y + z*u}

o20 : List
i21 : S=R/ideal I

o21 = S

o21 : QuotientRing
i22 : hilbertSeries(S,Order=>4)

                 2
o22 = 1 + 4T + 5T

o22 : ZZ[T]
i23 : L=koszulDualLie(S)

o23 = L

o23 : LieAlgebra
i24 : extAlgLie 4

o24 = | 4 0 0 0 |
      | 0 5 0 0 |
      | 0 0 0 5 |
      | 0 0 0 0 |

               4        4
o24 : Matrix ZZ  <--- ZZ

The following example shows a way to determine the derivations of the Lie algebra L, which was found by David Anick and may be seen as the positive part of the twisted loop algebra on sl2.

i25 : L=lieAlgebra({a,b},{[a,a,a,b],[b,b,b,a]})

o25 = L

o25 : LieAlgebra
i26 : computeLie 20

o26 = {2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1}

o26 : List

The derivations of degree 0 is 2-dimensional and contains the Euler derivation, which is the identity in degree one.

i27 : deuler=derLie({[a],[b]})

o27 = deuler

o27 : DerLie
i28 : evalDerLie(deuler,[b,a,b,a,b,a,b,a])

o28 = {{8}, {[b, a, b, a, b, a, b, a]}}

o28 : List

The linear maps from degree 1 to degree 7 is 4-dimensional. Not all of them define derivations.

i29 : basisLie 7

o29 = {[a, b, a, b, a, b, a], [b, b, a, b, a, b, a]}

o29 : List
i30 : da61=derLie({[a,b,a,b,a,b,a],[]})

o30 = da61

o30 : DerLie
i31 : db61=derLie({[],[a,b,a,b,a,b,a]})
the derivation is not welldefined
i32 : da62=derLie({[b,b,a,b,a,b,a],[]})
the derivation is not welldefined
i33 : db62=derLie({[],[b,b,a,b,a,b,a]})

o33 = db62

o33 : 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.

i34 : M=lieAlgebra({a,b},{})

o34 = M

o34 : LieAlgebra
i35 : f=mapLie(L,M,{[a],[b]})

o35 = f

o35 : MapLie
i36 : dMb61=derLie(f,{[],[a,b,a,b,a,b,a]})

o36 = dMb61

o36 : DerLie
i37 : dMa62=derLie(f,{[b,b,a,b,a,b,a],[]})

o37 = dMa62

o37 : DerLie
i38 : evalDerLie(dMb61,[a,a,a,b])

o38 = []

o38 : Array
i39 : evalDerLie(dMa62,[a,a,a,b])

o39 = {{2}, {[b, a, b, a, b, a, b, a, b, a]}}

o39 : List

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].

i40 : useLie L

o40 = L

o40 : LieAlgebra
i41 : da7=derLie({[b,a,b,a,b,a,b,a],[]})

o41 = da7

o41 : DerLie
i42 : db7=derLie({[],[b,a,b,a,b,a,b,a]})

o42 = db7

o42 : DerLie
i43 : multListLie({[a],[b]},{(basisLie 7)_0})

o43 = {[], [b, a, b, a, b, a, b, a]}

o43 : List
i44 : multListLie({[a],[b]},{(basisLie 7)_1})

o44 = {[b, a, b, a, b, a, b, a], []}

o44 : 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 multDerLie to examine the structure of this quotient Lie algebra.

i45 : d2=derLie({[a,b,a],[]})

o45 = d2

o45 : DerLie
i46 : d4=derLie({[a,b,a,b,a],[]})

o46 = d4

o46 : DerLie
i47 : d=multDerLie(d2,d4)

o47 = d

o47 : DerLie
i48 : evalDerLie(d,[a])

o48 = [a, b, a, b, a, b, a]

o48 : Array
i49 : evalDerLie(d,[b])

o49 = []

o49 : Array

Define dn (n>=2) as the derivation which maps a to [a,b,a,b,...,a] of length n+1 and b to []. It follows from above that [d2,d4]=d6.

i50 : d6=derLie({[a,b,a,b,a,b,a],[]})

o50 = d6

o50 : DerLie
i51 : d=multDerLie(d2,d6)

o51 = d

o51 : DerLie
i52 : evalDerLie(d,[a])

o52 = {{2}, {[a, b, a, b, a, b, a, b, a]}}

o52 : List
i53 : evalDerLie(d,[b])

o53 = []

o53 : Array
i54 : d16=derLie({[a,b,a,b,a,b,a,b,a,b,a,b,a,b,a,b,a],[]})

o54 = d16

o54 : DerLie
i55 : d=multDerLie(d2,d16)

o55 = d

o55 : DerLie
i56 : evalDerLie(d,[a])

o56 = {{7}, {[a, b, a, b, a, b, a, b, a, b, a, b, a, b, a, b, a, b, a]}}

o56 : List
i57 : evalDerLie(d,[b])

o57 = []

o57 : Array

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 Symmetries for some examples on how to use the constructor holonomyLie.

See also