Lie Algebra Elements¶
AUTHORS:
Travis Scrimshaw (2013-05-04): Initial implementation
-
class
sage.algebras.lie_algebras.lie_algebra_element.
FreeLieAlgebraElement
¶ Bases:
sage.algebras.lie_algebras.lie_algebra_element.LieAlgebraElement
An element of a free Lie algebra.
-
lift
()¶ Lift
self
to the universal enveloping algebra.EXAMPLES:
sage: L = LieAlgebra(QQ, 'x,y,z') sage: Lyn = L.Lyndon() sage: x,y,z = Lyn.gens() sage: a = Lyn([z, [[x, y], x]]); a [x, [x, [y, z]]] + [x, [[x, z], y]] - [[x, y], [x, z]] sage: a.lift() x^2*y*z - 2*x*y*x*z + y*x^2*z - z*x^2*y + 2*z*x*y*x - z*y*x^2
-
list
()¶ Return
self
as a list of pairs(m, c)
wherem
is a basis key (i.e., a key of one of the basis elements) andc
is its coefficient. This list is sorted from highest to lowest degree.EXAMPLES:
sage: L.<x, y> = LieAlgebra(QQ) sage: elt = x + L.bracket(y, x) sage: elt.list() [([x, y], -1), (x, 1)]
-
-
class
sage.algebras.lie_algebras.lie_algebra_element.
GradedLieBracket
¶ Bases:
sage.algebras.lie_algebras.lie_algebra_element.LieBracket
A Lie bracket (
LieBracket
) for a graded Lie algebra.Unlike the vanilla Lie bracket class, this also stores a degree, and uses it as a first criterion when comparing graded Lie brackets. (Graded Lie brackets still compare greater than Lie generators.)
-
class
sage.algebras.lie_algebras.lie_algebra_element.
LieAlgebraElement
¶ Bases:
sage.modules.with_basis.indexed_element.IndexedFreeModuleElement
A Lie algebra element.
-
lift
()¶ Lift
self
to the universal enveloping algebra.EXAMPLES:
sage: L.<x,y,z> = LieAlgebra(QQ, {('x','y'):{'z':1}}) sage: x.lift().parent() == L.universal_enveloping_algebra() True
-
-
class
sage.algebras.lie_algebras.lie_algebra_element.
LieAlgebraElementWrapper
¶ Bases:
sage.structure.element_wrapper.ElementWrapper
Wrap an element as a Lie algebra element.
-
class
sage.algebras.lie_algebras.lie_algebra_element.
LieAlgebraMatrixWrapper
¶ Bases:
sage.algebras.lie_algebras.lie_algebra_element.LieAlgebraElementWrapper
Lie algebra element wrapper around a matrix.
-
class
sage.algebras.lie_algebras.lie_algebra_element.
LieBracket
¶ Bases:
sage.algebras.lie_algebras.lie_algebra_element.LieObject
An abstract Lie bracket (formally, just a binary tree).
-
lift
(UEA_gens_dict)¶ Lift
self
to the universal enveloping algebra.UEA_gens_dict
should be the dictionary for the generators of the universal enveloping algebra.EXAMPLES:
sage: L = LieAlgebra(QQ, 'x,y,z') sage: Lyn = L.Lyndon() sage: x,y,z = Lyn.gens() sage: a = Lyn([z, [[x, y], x]]); a [x, [x, [y, z]]] + [x, [[x, z], y]] - [[x, y], [x, z]] sage: a.lift() # indirect doctest x^2*y*z - 2*x*y*x*z + y*x^2*z - z*x^2*y + 2*z*x*y*x - z*y*x^2
-
to_word
()¶ Return the word (“flattening”) of
self
.If
self
is a tree of Lie brackets, this word is usually obtained by “forgetting the brackets”.EXAMPLES:
sage: from sage.algebras.lie_algebras.lie_algebra_element import LieGenerator, LieBracket sage: x = LieGenerator('x', 0) sage: y = LieGenerator('y', 1) sage: b = LieBracket(x, y) sage: c = LieBracket(b, x) sage: c.to_word() ('x', 'y', 'x')
-
-
class
sage.algebras.lie_algebras.lie_algebra_element.
LieGenerator
¶ Bases:
sage.algebras.lie_algebras.lie_algebra_element.LieObject
A wrapper around an object so it can ducktype with and do comparison operations with
LieBracket
.-
to_word
()¶ Return the word (“flattening”) of
self
.If
self
is a tree of Lie brackets, this word is usually obtained by “forgetting the brackets”.EXAMPLES:
sage: from sage.algebras.lie_algebras.lie_algebra_element import LieGenerator sage: x = LieGenerator('x', 0) sage: x.to_word() ('x',)
-
-
class
sage.algebras.lie_algebras.lie_algebra_element.
LieObject
¶ Bases:
sage.structure.sage_object.SageObject
Abstract base class for
LieGenerator
andLieBracket
.-
to_word
()¶ Return the word (“flattening”) of
self
.If
self
is a tree of Lie brackets, this word is usually obtained by “forgetting the brackets”.
-
-
class
sage.algebras.lie_algebras.lie_algebra_element.
LieSubalgebraElementWrapper
¶ Bases:
sage.algebras.lie_algebras.lie_algebra_element.LieAlgebraElementWrapper
Wrap an element of the ambient Lie algebra as an element.
-
monomial_coefficients
(copy=True)¶ Return a dictionary whose keys are indices of basis elements in the support of
self
and whose values are the corresponding coefficients.INPUT:
copy
– (default:True
) ifself
is internally represented by a dictionaryd
, then make a copy ofd
; ifFalse
, then this can cause undesired behavior by mutatingd
EXAMPLES:
sage: L.<X,Y,Z> = LieAlgebra(ZZ, {('X','Y'): {'Z': 3}}) sage: S = L.subalgebra([X, Y]) sage: S(2*Y + 9*Z).monomial_coefficients() {1: 2, 2: 3} sage: S2 = L.subalgebra([Y, Z]) sage: S2(2*Y + 9*Z).monomial_coefficients() {0: 2, 1: 9}
-
to_vector
()¶ Return the vector in
g.module()
corresponding to the elementself
ofg
(whereg
is the parent ofself
).EXAMPLES:
sage: L.<X,Y,Z> = LieAlgebra(ZZ, {('X','Y'): {'Z': 3}}) sage: S = L.subalgebra([X, Y]) sage: S.basis() Family (X, Y, 3*Z) sage: S(2*Y + 9*Z).to_vector() (0, 2, 9) sage: S2 = L.subalgebra([Y, Z]) sage: S2.basis() Family (Y, Z) sage: S2(2*Y + 9*Z).to_vector() (0, 2, 9)
-
-
class
sage.algebras.lie_algebras.lie_algebra_element.
LyndonBracket
¶ Bases:
sage.algebras.lie_algebras.lie_algebra_element.GradedLieBracket
A Lie bracket (
LieBracket
) tailored for the Lyndon basis.The order on these brackets is defined by \(l < r\) if \(w(l) < w(r)\), where \(w(l)\) is the word corresponding to \(l\). (This is also true if one or both of \(l\) and \(r\) is a
LieGenerator
.)
-
class
sage.algebras.lie_algebras.lie_algebra_element.
StructureCoefficientsElement
¶ Bases:
sage.algebras.lie_algebras.lie_algebra_element.LieAlgebraMatrixWrapper
An element of a Lie algebra given by structure coefficients.
-
bracket
(right)¶ Return the Lie bracket
[self, right]
.EXAMPLES:
sage: L.<x,y,z> = LieAlgebra(QQ, {('x','y'): {'z':1}, ('y','z'): {'x':1}, ('z','x'): {'y':1}}) sage: x.bracket(y) z sage: y.bracket(x) -z sage: (x + y - z).bracket(x - y + z) -2*y - 2*z
-
lift
()¶ Return the lift of
self
to the universal enveloping algebra.EXAMPLES:
sage: L.<x,y> = LieAlgebra(QQ, {('x','y'): {'x':1}}) sage: elt = x - 3/2 * y sage: l = elt.lift(); l x - 3/2*y sage: l.parent() Noncommutative Multivariate Polynomial Ring in x, y over Rational Field, nc-relations: {y*x: x*y - x}
-
monomial_coefficients
(copy=True)¶ Return the monomial coefficients of
self
as a dictionary.EXAMPLES:
sage: L.<x,y,z> = LieAlgebra(QQ, {('x','y'): {'z':1}}) sage: a = 2*x - 3/2*y + z sage: a.monomial_coefficients() {'x': 2, 'y': -3/2, 'z': 1} sage: a = 2*x - 3/2*z sage: a.monomial_coefficients() {'x': 2, 'z': -3/2}
-
to_vector
()¶ Return
self
as a vector.EXAMPLES:
sage: L.<x,y,z> = LieAlgebra(QQ, {('x','y'): {'z':1}}) sage: a = x + 3*y - z/2 sage: a.to_vector() (1, 3, -1/2)
-
-
class
sage.algebras.lie_algebras.lie_algebra_element.
UntwistedAffineLieAlgebraElement
¶ Bases:
sage.structure.element.Element
An element of an untwisted affine Lie algebra.
-
bracket
(right)¶ Return the Lie bracket
[self, right]
.EXAMPLES:
sage: L = LieAlgebra(QQ, cartan_type=['A',1,1]) sage: e1,f1,h1,e0,f0,c,d = list(L.lie_algebra_generators()) sage: e0.bracket(f0) (-h1)#t^0 + 4*c sage: e1.bracket(0) 0 sage: e1.bracket(1) Traceback (most recent call last): ... TypeError: no common canonical parent for objects with parents: 'Affine Kac-Moody algebra of ['A', 1] in the Chevalley basis' and 'Integer Ring'
-
c_coefficient
()¶ Return the coefficient of \(c\) of
self
.EXAMPLES:
sage: L = lie_algebras.Affine(QQ, ['A',1,1]) sage: x = L.an_element() - 3 * L.c() sage: x.c_coefficient() -2
-
canonical_derivation
()¶ Return the canonical derivation \(d\) applied to
self
.The canonical derivation \(d\) is defined as
\[d(a \otimes t^m + \alpha c) = a \otimes m t^m.\]Another formulation is by \(d = t \frac{d}{dt}\).
EXAMPLES:
sage: L = lie_algebras.Affine(QQ, ['E',6,1]) sage: al = RootSystem(['E',6]).root_lattice().simple_roots() sage: x = L.basis()[al[2]+al[3]+2*al[4]+al[5],5] + 4*L.c() + L.d() sage: x.canonical_derivation() (5*E[alpha[2] + alpha[3] + 2*alpha[4] + alpha[5]])#t^5
-
d_coefficient
()¶ Return the coefficient of \(d\) of
self
.EXAMPLES:
sage: L = lie_algebras.Affine(QQ, ['A',1,1]) sage: x = L.an_element() + L.d() sage: x.d_coefficient() 2
-
monomial_coefficients
(copy=True)¶ Return the monomial coefficients of
self
.EXAMPLES:
sage: L = lie_algebras.Affine(QQ, ['C',2,1]) sage: x = L.an_element() sage: sorted(x.monomial_coefficients(), key=str) [(-2*alpha[1] - alpha[2], 1), (-alpha[1], 0), (-alpha[2], 0), (2*alpha[1] + alpha[2], -1), (alpha[1], 0), (alpha[2], 0), (alphacheck[1], 0), (alphacheck[2], 0), 'c', 'd']
-
t_dict
()¶ Return the
dict
, whose keys are powers of \(t\) and values are elements of the classical Lie algebra, ofself
.EXAMPLES:
sage: L = lie_algebras.Affine(QQ, ['A',1,1]) sage: x = L.an_element() sage: x.t_dict() {-1: E[alpha[1]], 0: E[alpha[1]] + h1 + E[-alpha[1]], 1: E[-alpha[1]]}
-