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},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 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 dimsLie. 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 weights may also be given as just positive integers; 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 homogeneous Lie expression.

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 = a b+(1/3) c

o5 = (1/3)c - (b a)

o5 : L1
i6 : weightLie ex

o6 = {2, 3, 0}

o6 : List
i7 : degLie ex

o7 = 2
i8 : L11 = lieAlgebra({a,b,c},genWeights=>{1,1,2})

o8 = L11

o8 : LieAlgebra
i9 : L11.genWeights

o9 = {{1, 0}, {1, 0}, {2, 0}}

o9 : List

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 homogeneous Lie expression.

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

o10 = L2

o10 : LieAlgebra
i11 : ex2 = a b+(1/3) c

o11 = (1/3)c - (b a)

o11 : L2
i12 : signLie ex2

o12 = 1

The forth option diffl is false by default and is set to be true if a differential is defined, see Differential LieAlgebra Tutorial. For each Lie algebra L, ambient(L) is a free Lie algebra M such that L (without differential) is a quotient of M. Moreover, the relations belong to M, even if L is defined as a quotient in two steps from M. This is somewhat different from the situation for Rings, where ambient(R) might not be a polynomial ring.

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 : Q.relsLie

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 contain a linear part. Use minPresLie to get a minimal presentation. Use peekLie to get information about the Lie algebra. This contains the value of the four options and also the keys gensLie, relsLie, genDiffs and compdeg. If minmodelLie has been computed (e.g., through minPresLie or extTableLie) then also the key minmodel is given by peekLie.

i20 : L3 = lieAlgebra({a,b,c},genWeights=>{1,1,2},
            genSigns=>{1,0,0})/{-c+a a,(a b) a}

o20 = L3

o20 : LieAlgebra
i21 : dimsLie 4

o21 = {2, 2, 1, 2}

o21 : List
i22 : peekLie L3

o22 = gensLie => {a, b, c}
      genWeights => {{1, 0}, {1, 0}, {2, 0}}
      genSigns => {1, 0, 0}
      relsLie => { - c + (a a),  - (1/2)(b a a)}
      genDiffs => {0, 0, 0}
      field => QQ
      diffl => false
      compdeg => 4
i23 : M = minPresLie 4

o23 = M

o23 : LieAlgebra
i24 : peekLie L3

o24 = gensLie => {a, b, c}
      genWeights => {{1, 0}, {1, 0}, {2, 0}}
      genSigns => {1, 0, 0}
      relsLie => { - c + (a a),  - (1/2)(b a a)}
      genDiffs => {0, 0, 0}
      field => QQ
      diffl => false
      compdeg => 4
      minmodel => LieAlgebra{...14...}
i25 : peekLie M

o25 = gensLie => {a, b}
      genWeights => {{1, 0}, {1, 0}}
      genSigns => {1, 0}
      relsLie => {(b a a)}
      genDiffs => {0, 0}
      field => QQ
      diffl => false
      compdeg => 1

In L.cache there is more information about L collected during a computation, which is not visible for the user, except lieRing and mbRing. L.cache.lieRing is the internal polynomial ring representation of Lie elements, 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. The number of generators in lieRing is the number of generators in the Lie algebra times the internal counter "L.cache.maxDeg" which initially is set to 5 and is changed to n+5 if dimsLie n is performed with n>maxdeg.

i26 : L4 = lieAlgebra({a,b})/{a a a b,b b b a}

o26 = L4

o26 : LieAlgebra
i27 : dimsLie 4

o27 = {2, 1, 2, 1}

o27 : List
i28 : peek L4.cache

o28 = CacheTable{bas => MutableHashTable{...5...}                                        }
                 bound => MutableHashTable{}
                 cyc => MutableHashTable{}
                 deglist => MutableHashTable{...4...}
                 dims => MutableHashTable{...5...}
                 genslie => {a, b}
                 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 : dimsLie 6

o29 = {2, 1, 2, 1, 2, 1}

o29 : List
i30 : peek L4.cache

o30 = CacheTable{bas => MutableHashTable{...7...}                                                                                                       }
                 bound => MutableHashTable{}
                 cyc => MutableHashTable{}
                 deglist => MutableHashTable{...6...}
                 dims => MutableHashTable{...7...}
                 genslie => {a, b}
                 gr => MutableHashTable{...6...}
                 lieRing => 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
                 maxDeg => 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{...5...}

The ring L.cache.mbRing is used to get an output of LieElements with indexed basis elements, which sometimes is better to use than the iterated Lie products of generators, especially in high degrees. Use indexFormLie to get the output in mbRing and defLie to get back the standard output. The ring L.cache.mbRing is very large, it has as many generators as the total dimension of the computed Lie algebra, so to avoid a large output you should give the ring a name.

i31 : L = lieAlgebra{a,b,c}

o31 = L

o31 : LieAlgebra
i32 : x = (a b c a) (b c)

o32 = (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)

o32 : L
i33 : Q = L.cache.mbRing

o33 = Q

o33 : PolynomialRing
i34 : indexFormLie x

o34 = mb        - mb        - mb        + mb        + mb        - mb
        {6, 22}     {6, 24}     {6, 43}     {6, 45}     {6, 74}     {6, 76}

o34 : Q
i35 : defLie oo

o35 = (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)

o35 : L

The interested reader may continue to read about the functions (among other) idealTableLie, subalgTableLie, annLie, and centerLie.

See also