next | previous | forward | backward | up | top | index | toc | Macaulay2 web site
GradedLieAlgebras :: How to write Lie elements

How to write Lie elements -- An overview of the different representations of elements of a graded Lie Algebra

An array of generators, [a,b,c], is interpreted as [a,[b,c]], i.e., as an iterated Lie product of the generators in the array starting from the right. The empty array, [], is the zero element in the Lie algebra and just one generator, a, is written [a]. A generator may be of class Symbol, IndexedVariable or Integer. It follows from the axioms, see axiomsLie that any Lie element is a linear combination of such iterated products, see monomialLie. When executing computeLie n, the program chooses some of the Lie monomials as a basis for the Lie algebra up to (first) degree n, see basicMonomialLie.

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

o1 = L

o1 : LieAlgebra
i2 : computeLie 6

o2 = {2, 1, 2, 1, 2, 1}

o2 : List
i3 : basisLie 5

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

o3 : List
i4 : monomialLie[a,b,a,a,b]

o4 = true
i5 : basicMonomialLie[a,b,a,a,b]

o5 = false

A general Lie expression, see generalExpressionLie, is either a monomialLie or of the form {{coefs},{liemons}}, where coefs belong to L.field, specified in the option field, and liemons are Lie monomials, monomialLie, not [], of the same weight and sign. These expressions should be used when specifying the relations in lieAlgebra and optionally also the values of the generators for a differential, see genDiffs. The output of many functions in the package is a (list of) basic Lie expressions, basicExpressionLie, which are general Lie expressions containing only non-zero coefficients and basic Lie monomials, basicMonomialLie.

i6 : L1=lieAlgebra({a,b,c},{{{1,-1},{[a,b],[a,c]}}})

o6 = L1

o6 : LieAlgebra
i7 : multLie([a,b],[b,c])

o7 = {{1, -1}, {[b, c, c, a], [c, b, c, a]}}

o7 : List
i8 : basicExpressionLie oo

o8 = true
i9 : L2=lieAlgebra({a,b,c},{[a,b],[a,c]},genWeights=>{{1,0},{1,0},{2,1}},
         genSigns=>{1,1,1},
         genDiffs=>{[],[],{{1,1},{[a,a],[b,b]}}})

o9 = L2

o9 : LieAlgebra
i10 : peek L2

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

Any general Lie expression is equal in the Lie algebra to a basic Lie expression, which is unique up to the order of the basic Lie monomials. One such expression can be obtained using normalFormLie. Two general Lie expressions are equal in the Lie algebra iff their normal forms are equal.

i11 : L=lieAlgebra({a,b},{})

o11 = L

o11 : LieAlgebra
i12 : basisLie 6

o12 = {[a, a, a, a, b, a], [b, a, a, a, b, a], [a, b, a, a, b, a], [b, b, a,
      -----------------------------------------------------------------------
      a, b, a], [b, a, b, a, b, a], [a, b, b, a, b, a], [b, b, b, a, b, a],
      -----------------------------------------------------------------------
      [b, a, b, b, b, a], [b, b, b, b, b, a]}

o12 : List
i13 : normalFormLie[a,a,a,b,a,b]

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

o13 : List

The notation with separate lists for coefficients and Lie monomials might feel unintuitive. Also, in high degrees the Lie monomials will be long and hard to identify. For that reason we have another representation of Lie elements, namely as linear polynomials in a ring with variables constituting a basis for the Lie algebra. This ring can be accessed as L.cache.mbRing, see mbRing. It is a good idea to give a name for L.cache.mbRing, since this ring is rather big and if a name is given only this name is displayed. The variable in L.cache.mbRing corresponding to the i:th basis element of degree d in L is denoted mb{d,i} (beginning with i=0).

i14 : L.cache.mbRing

o14 = QQ[mb      , mb      , mb      , mb      , mb      , mb      , mb      , mb      , mb      , mb      , mb      , mb      , mb      , mb      , mb      , mb      , mb      , mb      , mb      , mb      , mb      , mb      , mb      ]
           {1, 0}    {1, 1}    {2, 0}    {3, 0}    {3, 1}    {4, 0}    {4, 1}    {4, 2}    {5, 0}    {5, 1}    {5, 2}    {5, 3}    {5, 4}    {5, 5}    {6, 0}    {6, 1}    {6, 2}    {6, 3}    {6, 4}    {6, 5}    {6, 6}    {6, 7}    {6, 8}

o14 : PolynomialRing
i15 : S=oo

o15 = S

o15 : PolynomialRing
i16 : mb_{2,0}

o16 = mb
        {2, 0}

o16 : S

Use indexFormLie to translate a general Lie expression or a generator or a list of such elements to the ring L.cache.mbRing and use defLie in the other direction, i.e., to translate a (list of) linear polynomial(s) in L.cache.mbRing to a (list of) basicExpressionLie. There is no direct way to build linear combinations of general Lie expressions, but this can be done using the functions indexFormLie and defLie.

i17 : indexFormLie[a,a,a,b,a,b]

o17 = mb       - 2mb
        {6, 1}      {6, 2}

o17 : S
i18 : de=defLie oo

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

o18 : List
i19 : indexFormLie basisLie 6

o19 = {mb      , mb      , mb      , mb      , mb      , mb      , mb      ,
         {6, 0}    {6, 1}    {6, 2}    {6, 3}    {6, 4}    {6, 5}    {6, 6} 
      -----------------------------------------------------------------------
      mb      , mb      }
        {6, 7}    {6, 8}

o19 : List
i20 : defLie oo

o20 = {[a, a, a, a, b, a], [b, a, a, a, b, a], [a, b, a, a, b, a], [b, b, a,
      -----------------------------------------------------------------------
      a, b, a], [b, a, b, a, b, a], [a, b, b, a, b, a], [b, b, b, a, b, a],
      -----------------------------------------------------------------------
      [b, a, b, b, b, a], [b, b, b, b, b, a]}

o20 : List
i21 : indexFormLie{[a],[b],[a,b],de}

o21 = {mb      , mb      , -mb      , mb       - 2mb      }
         {1, 0}    {1, 1}     {2, 0}    {6, 1}      {6, 2}

o21 : List
i22 : defLie(2*indexFormLie{{1,2},{[a,a,b],[b,b,a]}}-
          3*indexFormLie{{2},{[a,a,b]}})

o22 = {{4, 4}, {[a, b, a], [b, b, a]}}

o22 : List

When there are several Lie algebras, the variables mb{d,i} may belong to different rings. To get the basis element mb{2,0} in S=L.cache.mbRing, one can just write useLie L, see useLie.

i23 : L1=lieAlgebra({a,b},{})

o23 = L1

o23 : LieAlgebra
i24 : computeLie 3

o24 = {2, 1, 2}

o24 : List
i25 : S1=L1.cache.mbRing

o25 = S1

o25 : PolynomialRing
i26 : L2=lieAlgebra({c,d,e},{})

o26 = L2

o26 : LieAlgebra
i27 : computeLie 3

o27 = {3, 3, 8}

o27 : List
i28 : S2=L2.cache.mbRing

o28 = S2

o28 : PolynomialRing
i29 : mb_{2,0}

o29 = mb
        {2, 0}

o29 : S2
i30 : defLie oo

o30 = [d, c]

o30 : Array
i31 : useLie L1

o31 = L1

o31 : LieAlgebra
i32 : mb_{2,0}

o32 = mb
        {2, 0}

o32 : S1
i33 : defLie oo

o33 = [b, a]

o33 : Array

See also