next | previous | forward | backward | up | top | index | toc | Macaulay2 web site
GradedLieAlgebras :: Second LieAlgebra Tutorial

Second LieAlgebra Tutorial -- Second tutorial of the package GradedLieAlgebras

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},
         {{{3,5*x},{[a_1,a_2,a_3],[a_2,a_1,a_3]}},
             [a_3,a_2,a_3,a_1]}, field => F)

o2 = L

o2 : LieAlgebra

The example above specifies the Lie algebra over the fraction field of ZZ/7[x] on three generators a1,a2,a3, modulo the ideal generated by 3[a1,[a2,a3]] + 5x[a2,[a1,a3]] and [a3,[a2,[a3,a1]]]. 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 genWeights. The weights are lists of integers of the same length, where the first degree is positive, also just called the degree, see degLie. The degree is input for the function computeLie. The last degree is the homological degree, which is non-negative and less than the first degree. If the user does not specify a differential, the program defines the homological degree to be zero and adds a last degree 0 to the existing degrees. Use weightLie to compute the weight of an arbitrary expression, see How to write Lie elements.

i3 : L1 = lieAlgebra({a,b,c},{},genWeights=>{{1,-1},{1,4},{2,3}})

o3 = L1

o3 : LieAlgebra
i4 : weightLie b

o4 = {1, 4, 0}

o4 : List
i5 : ex={{1,1/3},{[a,b],[c]}}

          1
o5 = {{1, -}, {[a, b], [c]}}
          3

o5 : List
i6 : weightLie ex

o6 = {2, 3, 0}

o6 : List
i7 : degLie ex

o7 = 2

To specify signs of the generators, use the option genSigns. 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 "genSigns => 1" defines the sign of all the generators to be 1. The signs affect the axioms of a Lie superalgebra, see axiomsLie. Use signLie to compute the sign of an arbitrary expression, see How to write Lie elements for the use of mbRing, indexFormLie and defLie.

i8 : 
     L2 = lieAlgebra({a,b,c},{},genWeights=>{{1,-1},{1,4},{2,3}},
         genSigns=>{0,1,1})

o8 = L2

o8 : LieAlgebra
i9 : signLie ex

o9 = 1
i10 : computeLie 3

o10 = {2, 3, 4}

o10 : List
i11 : S=L2.cache.mbRing

o11 = S

o11 : PolynomialRing
i12 : indexFormLie ex

                   1
o12 = - mb       + -mb
          {2, 0}   3  {2, 2}

o12 : S
i13 : signLie mb_{3,1}

o13 = 0

The relations may contain a linear part. Use minPresLie to get a minimal presentation. In order to use a relation which contains Lie products, which are not of the form monomialLie, use toMonomialLie. Use peek to get information about the Lie algebra. This contains the value of the four options and also the keys compdeg, deglength, gensLie, numGen and relsLie. In L.cache there is more information about L collected during a computation, which is not visible for the user, except maxDeg, lieRing and mbRing.

i14 : 
      rel=toMonomialLie([[a,b],a],{a,b},{1,0})

o14 = {{1, -1}, {[a, b, a], [b, a, a]}}

o14 : List
i15 : L3=lieAlgebra({a,b,c},{{{-1,1},{[c],[a,a]}},rel},
          genWeights=>{1,1,2},genSigns=>{1,0,0})

o15 = L3

o15 : LieAlgebra
i16 : computeLie 4

o16 = {2, 2, 1, 2}

o16 : List
i17 : peek L3

o17 = LieAlgebra{cache => CacheTable{...9...}                                            }
                 compdeg => 4
                 deglength => 2
                 field => QQ
                 genDiffs => {[], [], []}
                 genSigns => {1, 0, 0}
                 gensLie => {a, b, c}
                 genWeights => {{1, 0}, {1, 0}, {2, 0}}
                 numGen => 3
                 relsLie => {{{-1, 1}, {[c], [a, a]}}, {{1, -1}, {[a, b, a], [b, a, a]}}}
i18 : M=minPresLie 4

o18 = M

o18 : LieAlgebra
i19 : peek M

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

Observe that the output of toMonomialLie may not be a basicExpressionLie in the free Lie algebra. In fact, we may use normalFormLie, see How to write Lie elements, to reduce the expression rel as follows.

i20 : L=lieAlgebra({a,b},{},genSigns=>{1,0})

o20 = L

o20 : LieAlgebra
i21 : normalFormLie rel

          1
o21 = {{- -}, {[b, a, a]}}
          2

o21 : List

This explains why the relation in the minimal presentation M above has changed from rel to [b,a,a].

The differential of the generators is defined by the option genDiffs. The expressions used should be generalExpressionLie, see How to write Lie elements. The differential preserves all weights except the last homological degree which is lowered by 1 and it changes the sign. Also the square of the differential is zero. All this is checked when lieAlgebra is executed. Use evalDiffLie to compute the value of the differential of an arbitrary expression. The differential is a derivation and may also be constructed using the constructor derLie, see Constructing Lie algebras.

i22 : L4 = lieAlgebra({a,b,c},{},genWeights=>{{1,0},{2,1},{3,2}},
          genSigns=>{1,1,1},genDiffs=>{[],[],[a,b]})

o22 = L4

o22 : LieAlgebra
i23 : peek L4

o23 = LieAlgebra{cache => CacheTable{...9...}          }
                 compdeg => 3
                 deglength => 2
                 field => QQ
                 genDiffs => {[], [], [a, b]}
                 genSigns => {1, 1, 1}
                 gensLie => {a, b, c}
                 genWeights => {{1, 0}, {2, 1}, {3, 2}}
                 numGen => 3
                 relsLie => {}
i24 : {{1,1/3},{[a,b,b],[a,a,c]}}

           1
o24 = {{1, -}, {[a, b, b], [a, a, c]}}
           3

o24 : List
i25 : evalDiffLie oo

        1
o25 = {{-}, {[a, a, a, b]}}
        3

o25 : List

The key maxDeg in L.cache is by default 5. If computeLie n is executed for n>L.cache.maxDeg, then the program changes the key to n+5. The value of maxDeg defines the internal representation of Lie elements in the polynomial ring "L.cache.lieRing", which cannot be used by the user but can be looked upon by writing "L.cache.lieRing". The Lie monomials are represented as commutative monomials in this ring.

i26 : 
      L5=lieAlgebra({a,b},{[a,a,a,b],[b,b,b,a]})

o26 = L5

o26 : LieAlgebra
i27 : computeLie 4

o27 = {2, 1, 2, 1}

o27 : List
i28 : peek L5.cache

o28 = CacheTable{bas => MutableHashTable{...5...}                                        }
                 deglist => MutableHashTable{...4...}
                 diffl => false
                 dims => MutableHashTable{...5...}
                 gr => MutableHashTable{...4...}
                 lieRing => QQ[aR , aR , aR , aR , aR , aR , aR , aR , aR , aR ]
                                 0    1    2    3    4    5    6    7    8    9
                 maxDeg => 5
                 mbRing => QQ[mb      , mb      , mb      , mb      , mb      , mb      ]
                                {1, 0}    {1, 1}    {2, 0}    {3, 0}    {3, 1}    {4, 0}
                 opL => MutableHashTable{}
i29 : L5.cache.lieRing

o29 = QQ[aR , aR , aR , aR , aR , aR , aR , aR , aR , aR ]
           0    1    2    3    4    5    6    7    8    9

o29 : PolynomialRing
i30 : computeLie 6

o30 = {2, 1, 2, 1, 2, 1}

o30 : List
i31 : L5.cache.maxDeg

o31 = 11
i32 : L5.cache.lieRing

o32 = QQ[aR , aR , aR , aR , aR , aR , aR , aR , aR , aR , aR  , aR  , aR  , aR  , aR  , aR  , aR  , aR  , aR  , aR  , aR  , aR  ]
           0    1    2    3    4    5    6    7    8    9    10    11    12    13    14    15    16    17    18    19    20    21

o32 : PolynomialRing

The interested reader may continue to read about the functions idealLie, subalgLie, divisorLie, invImageLie, intersectionLie, annLie, and centreLie.

See also