next | previous | forward | backward | up | top | index | toc | Macaulay2 website
GradedLieAlgebras :: Second Lie algebra tutorial

Second Lie algebra tutorial

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 $\mathbb Z/7$ [ $x$ ] on three generators $a_1, a_2, a_3$, modulo the ideal generated by $3$ [$a_1$, [ $a_2$, $a_3$ ]] + $5x$ [ $a_2$, [ $a_1$, $a_3$ ]] and [$a_3$, [ $a_2$, [ $a_3$, $a_1$ ]]]. 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 lieAlgebra(...,Weights=>...). The weights are lists of integers of the same length, where the first degree is positive, also just called the degree, see firstDegree(LieElement). The degree is the two first inputs for the function dims(ZZ,ZZ,LieAlgebra). If the option lieAlgebra(...,LastWeightHomological=>...) is true, then the last degree is the homological degree, which is non-negative and less than the first degree. If the option lieAlgebra(...,LastWeightHomological=>...) is false, which is the default value, then the program defines the homological degree to be zero, and adds a last component 0 to the existing degrees. In this case the weights can also be given as a list of positive integers that will be the degrees. See Differential Lie algebra tutorial how to define a differential. Use weight to compute the weight of an arbitrary homogeneous Lie expression.

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

o3 = L

o3 : LieAlgebra
i4 : weight b

o4 = {1, 4, 0}

o4 : List
i5 : ex = a b+(1/3) c

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

o5 : L
i6 : weight ex

o6 = {2, 3, 0}

o6 : List
i7 : firstDegree ex

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

o8 = L1

o8 : LieAlgebra
i9 : describe L1

o9 = generators => {a, b, c}
     Weights => {{1, 0}, {1, 0}, {2, 0}}
     Signs => {0, 0, 0}
     ideal => {}
     ambient => L1
     diff => {}
     Field => QQ
     computedDegree => 0

To specify signs of the generators, use the option lieAlgebra(...,Signs=>...). 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 "Signs => 1" defines the signs of all the generators to be 1. The signs affect the axioms of a Lie superalgebra, see LieAlgebra. Use sign to compute the sign of an arbitrary homogeneous Lie expression.

i10 : L = lieAlgebra({a,b,c},Weights => {{1,-1},{1,4},{2,3}},
            Signs=>{0,1,1})

o10 = L

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

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

o11 : L
i12 : sign ex

o12 = 1

For each finitely presented Lie algebra $L$, ambient(L) represents a free Lie algebra $M$ such that $L$ (without differential) is a quotient of $M$, see also Quotient Lie algebras and subspaces. Moreover, the relations belong to $M$, even if $L$ is defined as a quotient in two or more steps from $M$. This is somewhat different from the situation for rings.

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 : ideal(Q)

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 have a non-zero linear part. Use minimalPresentation(ZZ,LieAlgebra) to get a minimal presentation. Use describe(LieAlgebra) to get information about the Lie algebra. This contains the value of the three options lieAlgebra(...,Weights=>...), lieAlgebra(...,Signs=>...), lieAlgebra(...,Field=>...), and also the values generators(LieAlgebra), ideal(LieAlgebra), ambient(LieAlgebra), diff(LieAlgebra) and computedDegree(LieAlgebra)

i20 : F = lieAlgebra({a,b,c},Weights => {1,1,2},
            Signs=>{1,0,0})

o20 = F

o20 : LieAlgebra
i21 : L = F/{-c+a a,(a b) a}

o21 = L

o21 : LieAlgebra
i22 : dims(1,4,L)

o22 = {2, 2, 1, 2}

o22 : List
i23 : describe L

o23 = generators => {a, b, c}
      Weights => {{1, 0}, {1, 0}, {2, 0}}
      Signs => {1, 0, 0}
      ideal => { - c + (a a),  - (1/2)(b a a)}
      ambient => F
      diff => {}
      Field => QQ
      computedDegree => 4
i24 : M = minimalPresentation(4,L)

o24 = M

o24 : LieAlgebra
i25 : describe M

o25 = generators => {a, b}
      Weights => {{1, 0}, {1, 0}}
      Signs => {1, 0}
      ideal => {(b a a)}
      ambient => LieAlgebra{...10...}
      diff => {}
      Field => QQ
      computedDegree => 0

In L#cache there is more information about $L$ collected during a computation. Some parts of the information are visible to the user, e.g., lieRing and mbRing. The ring L#cache.lieRing is the internal polynomial ring representation of Lie elements. The Lie monomials are represented as commutative monomials in this ring. The program produces internally an ideal of relations and a basis, which may be seen as L#cache.gb and L#cache.basis. The number of generators in lieRing is the number of generators in the Lie algebra times the internal counter L#cache.max, which initially is set to $5$, and is changed to $n+5$ if the computation of $L$ is performed up to degree $n$ with $n\ >$ L#cache.max.

i26 : 
      L = lieAlgebra{a,b}/{a a a b,b b b a}

o26 = L

o26 : LieAlgebra
i27 : dims(1,4,L)

o27 = {2, 1, 2, 1}

o27 : List
i28 : peek L#cache

o28 = CacheTable{ambient => LieAlgebra{...10...}                                         }
                 basis => MutableHashTable{...15...}
                 degree => 4
                 degrees => MutableHashTable{...4...}
                 dim => MutableHashTable{...5...}
                 gb => MutableHashTable{...4...}
                 generators => {a, b}
                 lieRing => QQ[aR ..aR ]
                                 0    9
                 max => 5
                 mbRing => QQ[mb      , mb      , mb      , mb      , mb      , mb      ]
                                {1, 0}    {1, 1}    {2, 0}    {3, 0}    {3, 1}    {4, 0}
                 opL => MutableHashTable{}
i29 : L#cache.basis#4

o29 = {aR aR aR aR }
         0  3  4  7

o29 : List
i30 : basis(4,L)

o30 = {(b a b a)}

o30 : List
i31 : L#cache.gb#4

o31 = ideal (aR aR aR aR , aR aR aR aR  - aR aR aR aR , aR aR aR aR )
               0  3  5  7    0  3  5  6     0  3  4  7    0  3  4  6

o31 : Ideal of QQ[aR ..aR ]
                    0    9
i32 : a b b a

o32 = (b a b a)

o32 : L
i33 : dims(1,6,L)

o33 = {2, 1, 2, 1, 2, 1}

o33 : List
i34 : peek L#cache

o34 = CacheTable{ambient => LieAlgebra{...10...}                                                                       }
                 basis => MutableHashTable{...28...}
                 degree => 6
                 degrees => MutableHashTable{...6...}
                 dim => MutableHashTable{...7...}
                 gb => MutableHashTable{...6...}
                 generators => {a, b}
                 lieRing => QQ[aR ..aR  ]
                                 0    21
                 max => 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{...10...}

The ring L#cache.mbRing is used to get an output of Lie elements with indexed basis elements, which sometimes is better to use than the iterated Lie products of generators, especially in high degrees. Use indexForm to get the output in mbRing and standardForm(RingElement,LieAlgebra) to get back the standard output. The ring mbRing is very large; it has as many generators as the total dimension of the computed Lie algebra. For this reason, you should give the ring a name to avoid a large output.

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

o35 = L

o35 : LieAlgebra
i36 : x = (a b c a) (b c)

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

o36 : L
i37 : Q = L#cache.mbRing

o37 = Q

o37 : PolynomialRing
i38 : numgens Q

o38 = 196
i39 : indexForm x

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

o39 : Q
i40 : standardForm(oo,L)

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

o40 : L

See also