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 |