Lie Algebra Elements¶
AUTHORS:
- Travis Scrimshaw (2013-05-04): Initial implementation 
- class sage.algebras.lie_algebras.lie_algebra_element.FreeLieAlgebraElement[source]¶
- Bases: - LieAlgebraElement- An element of a free Lie algebra. - lift()[source]¶
- Lift - selfto 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 - >>> from sage.all import * >>> L = LieAlgebra(QQ, 'x,y,z') >>> Lyn = L.Lyndon() >>> x,y,z = Lyn.gens() >>> a = Lyn([z, [[x, y], x]]); a [x, [x, [y, z]]] + [x, [[x, z], y]] - [[x, y], [x, z]] >>> 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()[source]¶
- Return - selfas a list of pairs- (m, c)where- mis a basis key (i.e., a key of one of the basis elements) and- cis 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)] - >>> from sage.all import * >>> L = LieAlgebra(QQ, names=('x', 'y',)); (x, y,) = L._first_ngens(2) >>> elt = x + L.bracket(y, x) >>> elt.list() [([x, y], -1), (x, 1)] 
 
- class sage.algebras.lie_algebras.lie_algebra_element.GradedLieBracket[source]¶
- Bases: - 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[source]¶
- Bases: - IndexedFreeModuleElement- A Lie algebra element. - lift()[source]¶
- Lift - selfto 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 - >>> from sage.all import * >>> L = LieAlgebra(QQ, {('x','y'):{'z':Integer(1)}}, names=('x', 'y', 'z',)); (x, y, z,) = L._first_ngens(3) >>> x.lift().parent() == L.universal_enveloping_algebra() True 
 
- class sage.algebras.lie_algebras.lie_algebra_element.LieAlgebraElementWrapper[source]¶
- Bases: - ElementWrapper- Wrap an element as a Lie algebra element. 
- class sage.algebras.lie_algebras.lie_algebra_element.LieAlgebraMatrixWrapper[source]¶
- Bases: - LieAlgebraElementWrapper- Lie algebra element wrapper around a matrix. 
- class sage.algebras.lie_algebras.lie_algebra_element.LieBracket[source]¶
- Bases: - LieObject- An abstract Lie bracket (formally, just a binary tree). - lift(UEA_gens_dict)[source]¶
- Lift - selfto the universal enveloping algebra.- UEA_gens_dictshould 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 - >>> from sage.all import * >>> L = LieAlgebra(QQ, 'x,y,z') >>> Lyn = L.Lyndon() >>> x,y,z = Lyn.gens() >>> a = Lyn([z, [[x, y], x]]); a [x, [x, [y, z]]] + [x, [[x, z], y]] - [[x, y], [x, z]] >>> 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()[source]¶
- Return the word (“flattening”) of - self.- If - selfis 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') - >>> from sage.all import * >>> from sage.algebras.lie_algebras.lie_algebra_element import LieGenerator, LieBracket >>> x = LieGenerator('x', Integer(0)) >>> y = LieGenerator('y', Integer(1)) >>> b = LieBracket(x, y) >>> c = LieBracket(b, x) >>> c.to_word() ('x', 'y', 'x') 
 
- class sage.algebras.lie_algebras.lie_algebra_element.LieGenerator[source]¶
- Bases: - LieObject- A wrapper around an object so it can ducktype with and do comparison operations with - LieBracket.- lift(UEA_gens_dict)[source]¶
- Lift - selfto the universal enveloping algebra.- UEA_gens_dictshould 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: x.lift() x sage: x.lift().parent() Free Algebra on 3 generators (x, y, z) over Rational Field - >>> from sage.all import * >>> L = LieAlgebra(QQ, 'x,y,z') >>> Lyn = L.Lyndon() >>> x,y,z = Lyn.gens() >>> x.lift() x >>> x.lift().parent() Free Algebra on 3 generators (x, y, z) over Rational Field 
 - to_word()[source]¶
- Return the word (“flattening”) of - self.- If - selfis 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',) - >>> from sage.all import * >>> from sage.algebras.lie_algebras.lie_algebra_element import LieGenerator >>> x = LieGenerator('x', Integer(0)) >>> x.to_word() ('x',) 
 
- class sage.algebras.lie_algebras.lie_algebra_element.LieObject[source]¶
- Bases: - SageObject- Abstract base class for - LieGeneratorand- LieBracket.
- class sage.algebras.lie_algebras.lie_algebra_element.LieSubalgebraElementWrapper[source]¶
- Bases: - LieAlgebraElementWrapper- Wrap an element of the ambient Lie algebra as an element. - monomial_coefficients(copy=True)[source]¶
- Return a dictionary whose keys are indices of basis elements in the support of - selfand whose values are the corresponding coefficients.- INPUT: - copy– boolean (default:- True); if- selfis internally represented by a dictionary- d, then make a copy of- d; if- False, then this can cause undesired behavior by mutating- d
 - 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} - >>> from sage.all import * >>> L = LieAlgebra(ZZ, {('X','Y'): {'Z': Integer(3)}}, names=('X', 'Y', 'Z',)); (X, Y, Z,) = L._first_ngens(3) >>> S = L.subalgebra([X, Y]) >>> S(Integer(2)*Y + Integer(9)*Z).monomial_coefficients() {1: 2, 2: 3} >>> S2 = L.subalgebra([Y, Z]) >>> S2(Integer(2)*Y + Integer(9)*Z).monomial_coefficients() {0: 2, 1: 9} 
 - to_vector(sparse=False, order=None)[source]¶
- Return the vector in - g.module()corresponding to the element- selfof- g(where- gis the parent of- self).- 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) - >>> from sage.all import * >>> L = LieAlgebra(ZZ, {('X','Y'): {'Z': Integer(3)}}, names=('X', 'Y', 'Z',)); (X, Y, Z,) = L._first_ngens(3) >>> S = L.subalgebra([X, Y]) >>> S.basis() Family (X, Y, 3*Z) >>> S(Integer(2)*Y + Integer(9)*Z).to_vector() (0, 2, 9) >>> S2 = L.subalgebra([Y, Z]) >>> S2.basis() Family (Y, Z) >>> S2(Integer(2)*Y + Integer(9)*Z).to_vector() (0, 2, 9) 
 
- class sage.algebras.lie_algebras.lie_algebra_element.LyndonBracket[source]¶
- Bases: - 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[source]¶
- Bases: - LieAlgebraMatrixWrapper- An element of a Lie algebra given by structure coefficients. - bracket(right)[source]¶
- 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 - >>> from sage.all import * >>> L = LieAlgebra(QQ, {('x','y'): {'z':Integer(1)}, ('y','z'): {'x':Integer(1)}, ('z','x'): {'y':Integer(1)}}, names=('x', 'y', 'z',)); (x, y, z,) = L._first_ngens(3) >>> x.bracket(y) z >>> y.bracket(x) -z >>> (x + y - z).bracket(x - y + z) -2*y - 2*z 
 - lift()[source]¶
- Return the lift of - selfto 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} - >>> from sage.all import * >>> L = LieAlgebra(QQ, {('x','y'): {'x':Integer(1)}}, names=('x', 'y',)); (x, y,) = L._first_ngens(2) >>> elt = x - Integer(3)/Integer(2) * y >>> l = elt.lift(); l x - 3/2*y >>> l.parent() Noncommutative Multivariate Polynomial Ring in x, y over Rational Field, nc-relations: {y*x: x*y - x} 
 - monomial_coefficients(copy=True)[source]¶
- Return the monomial coefficients of - selfas 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} - >>> from sage.all import * >>> L = LieAlgebra(QQ, {('x','y'): {'z':Integer(1)}}, names=('x', 'y', 'z',)); (x, y, z,) = L._first_ngens(3) >>> a = Integer(2)*x - Integer(3)/Integer(2)*y + z >>> a.monomial_coefficients() {'x': 2, 'y': -3/2, 'z': 1} >>> a = Integer(2)*x - Integer(3)/Integer(2)*z >>> a.monomial_coefficients() {'x': 2, 'z': -3/2} 
 - to_vector(sparse=False, order=None)[source]¶
- Return - selfas 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) - >>> from sage.all import * >>> L = LieAlgebra(QQ, {('x','y'): {'z':Integer(1)}}, names=('x', 'y', 'z',)); (x, y, z,) = L._first_ngens(3) >>> a = x + Integer(3)*y - z/Integer(2) >>> a.to_vector() (1, 3, -1/2) 
 
- class sage.algebras.lie_algebras.lie_algebra_element.UntwistedAffineLieAlgebraElement[source]¶
- Bases: - Element- An element of an untwisted affine Lie algebra. - bracket(right)[source]¶
- 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' - >>> from sage.all import * >>> L = LieAlgebra(QQ, cartan_type=['A',Integer(1),Integer(1)]) >>> e1,f1,h1,e0,f0,c,d = list(L.lie_algebra_generators()) >>> e0.bracket(f0) (-h1)#t^0 + 4*c >>> e1.bracket(Integer(0)) 0 >>> e1.bracket(Integer(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()[source]¶
- 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 - >>> from sage.all import * >>> L = lie_algebras.Affine(QQ, ['A',Integer(1),Integer(1)]) >>> x = L.an_element() - Integer(3) * L.c() >>> x.c_coefficient() -2 
 - canonical_derivation()[source]¶
- 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 - >>> from sage.all import * >>> L = lie_algebras.Affine(QQ, ['E',Integer(6),Integer(1)]) >>> al = RootSystem(['E',Integer(6)]).root_lattice().simple_roots() >>> x = L.basis()[al[Integer(2)]+al[Integer(3)]+Integer(2)*al[Integer(4)]+al[Integer(5)],Integer(5)] + Integer(4)*L.c() + L.d() >>> x.canonical_derivation() (5*E[alpha[2] + alpha[3] + 2*alpha[4] + alpha[5]])#t^5 
 - d_coefficient()[source]¶
- 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 - >>> from sage.all import * >>> L = lie_algebras.Affine(QQ, ['A',Integer(1),Integer(1)]) >>> x = L.an_element() + L.d() >>> x.d_coefficient() 2 
 - monomial_coefficients(copy=True)[source]¶
- 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'] - >>> from sage.all import * >>> L = lie_algebras.Affine(QQ, ['C',Integer(2),Integer(1)]) >>> x = L.an_element() >>> 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()[source]¶
- Return the - dict, whose keys are powers of \(t\) and values are elements of the classical Lie algebra, of- self.- 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]]} - >>> from sage.all import * >>> L = lie_algebras.Affine(QQ, ['A',Integer(1),Integer(1)]) >>> x = L.an_element() >>> x.t_dict() {-1: E[alpha[1]], 0: E[alpha[1]] + h1 + E[-alpha[1]], 1: E[-alpha[1]]}