Finite Dimensional Lie Algebras With Basis#
AUTHORS:
Travis Scrimshaw (07-15-2013): Initial implementation
- class sage.categories.finite_dimensional_lie_algebras_with_basis.FiniteDimensionalLieAlgebrasWithBasis(base_category)#
Bases:
CategoryWithAxiom_over_base_ring
Category of finite dimensional Lie algebras with a basis.
Todo
Many of these tests should use non-abelian Lie algebras and need to be added after github issue #16820.
- class ElementMethods#
Bases:
object
- adjoint_matrix(sparse=False)#
Return the matrix of the adjoint action of
self
.EXAMPLES:
sage: L = LieAlgebras(QQ).FiniteDimensional().WithBasis().example() # optional - sage.combinat sage.modules sage: L.an_element().adjoint_matrix() # optional - sage.combinat sage.modules [0 0 0] [0 0 0] [0 0 0] sage: L.an_element().adjoint_matrix(sparse=True).is_sparse() # optional - sage.combinat sage.modules True
sage: L.<x,y> = LieAlgebra(QQ, {('x','y'): {'x':1}}) # optional - sage.combinat sage.modules sage: x.adjoint_matrix() # optional - sage.combinat sage.modules [0 1] [0 0] sage: y.adjoint_matrix() # optional - sage.combinat sage.modules [-1 0] [ 0 0]
We verify that this forms a representation:
sage: sl3 = lie_algebras.sl(QQ, 3) # optional - sage.combinat sage.modules sage: e1, e2 = sl3.e(1), sl3.e(2) # optional - sage.combinat sage.modules sage: e12 = e1.bracket(e2) # optional - sage.combinat sage.modules sage: E1, E2 = e1.adjoint_matrix(), e2.adjoint_matrix() # optional - sage.combinat sage.modules sage: E1 * E2 - E2 * E1 == e12.adjoint_matrix() # optional - sage.combinat sage.modules True
- to_vector(order=None, sparse=False)#
Return the vector in
g.module()
corresponding to the elementself
ofg
(whereg
is the parent ofself
).Implement this if you implement
g.module()
. Seesage.categories.lie_algebras.LieAlgebras.module()
for how this is to be done.EXAMPLES:
sage: L = LieAlgebras(QQ).FiniteDimensional().WithBasis().example() # optional - sage.combinat sage.modules sage: L.an_element().to_vector() # optional - sage.combinat sage.modules (0, 0, 0) sage: L.an_element().to_vector(sparse=True) # optional - sage.combinat sage.modules (0, 0, 0) sage: D = DescentAlgebra(QQ, 4).D() # optional - sage.combinat sage.modules sage: L = LieAlgebra(associative=D) # optional - sage.combinat sage.modules sage: L.an_element().to_vector() # optional - sage.combinat sage.modules (1, 1, 1, 1, 1, 1, 1, 1)
- Nilpotent#
- class ParentMethods#
Bases:
object
- as_finite_dimensional_algebra()#
Return
self
as aFiniteDimensionalAlgebra
.EXAMPLES:
sage: L = lie_algebras.cross_product(QQ) # optional - sage.combinat sage.modules sage: x, y, z = L.basis() # optional - sage.combinat sage.modules sage: F = L.as_finite_dimensional_algebra() # optional - sage.combinat sage.modules sage: X, Y, Z = F.basis() # optional - sage.combinat sage.modules sage: x.bracket(y) # optional - sage.combinat sage.modules Z sage: X * Y # optional - sage.combinat sage.modules Z
- casimir_element(order=2, UEA=None, force_generic=False)#
Return the Casimir element in the universal enveloping algebra of
self
.A Casimir element of order \(k\) is a distinguished basis element for the center of \(U(\mathfrak{g})\) of homogeneous degree \(k\) (that is, it is an element of \(U_k \setminus U_{k-1}\), where \(\{U_i\}_{i=0}^{\infty}\) is the natural filtration of \(U(\mathfrak{g})\)). When \(\mathfrak{g}\) is a simple Lie algebra, then this spans \(Z(U(\mathfrak{g}))_k\).
INPUT:
order
– (default:2
) the order of the Casimir elementUEA
– (optional) the universal enveloping algebra to return the result inforce_generic
– (default:False
) ifTrue
for the quadratic order, then this uses the default algorithm; otherwise this is ignored
ALGORITHM:
For the quadratic order (i.e.,
order=2
), then this uses \(K^{ij}\), the inverse of the Killing form matrix, to compute \(C_{(2)} = \sum_{i,j} K^{ij} X_i \cdots X_j\), where \(\{X_1, \ldots, X_n\}\) is a basis for \(\mathfrak{g}\). Otherwise this solves the system of equations\[f_{aj}^b \kappa^{jc\cdots d} + f_{aj}^c \kappa^{cj\cdots d} \cdots + f_{aj}^d \kappa^{bc \cdots j}\]for the symmetric tensor \(\kappa^{i_1 \cdots i_k}\), where \(k\) is the
order
. This system comes from \([X_i, C_{(k)}] = 0\) with\[C_{(k)} = \sum_{i_1, \ldots, i_k}^n \kappa^{i_1 \cdots i_k} X_{i_1} \cdots X_{i_k}.\]EXAMPLES:
sage: L = LieAlgebra(QQ, cartan_type=['A', 1]) sage: C = L.casimir_element(); C 1/8*b1^2 + 1/2*b0*b2 - 1/4*b1 sage: U = L.universal_enveloping_algebra() sage: all(g * C == C * g for g in U.gens()) True sage: U = L.pbw_basis() sage: C = L.casimir_element(UEA=U); C 1/2*PBW[alpha[1]]*PBW[-alpha[1]] + 1/8*PBW[alphacheck[1]]^2 - 1/4*PBW[alphacheck[1]] sage: all(g * C == C * g for g in U.algebra_generators()) True sage: L = LieAlgebra(QQ, cartan_type=['B', 2]) sage: U = L.pbw_basis() sage: C = L.casimir_element(UEA=U) sage: all(g * C == C * g for g in U.algebra_generators()) True sage: L = LieAlgebra(QQ, cartan_type=['C', 3]) sage: U = L.pbw_basis() sage: C = L.casimir_element(UEA=U) sage: all(g * C == C * g for g in U.algebra_generators()) True sage: L = LieAlgebra(QQ, cartan_type=['A', 1]) sage: C4 = L.casimir_element(order=4, UEA=L.pbw_basis()); C4 4*PBW[alpha[1]]^2*PBW[-alpha[1]]^2 + 2*PBW[alpha[1]]*PBW[alphacheck[1]]^2*PBW[-alpha[1]] + 1/4*PBW[alphacheck[1]]^4 - PBW[alphacheck[1]]^3 - 4*PBW[alpha[1]]*PBW[-alpha[1]] + 2*PBW[alphacheck[1]] sage: all(g * C4 == C4 * g for g in L.pbw_basis().algebra_generators()) True sage: L = lie_algebras.Heisenberg(QQ, 2) sage: L.casimir_element() 0
Todo
Use the symmetry of the tensor to reduce the number of equations and/or variables to solve.
- center()#
Return the center of
self
.EXAMPLES:
sage: L = LieAlgebras(QQ).FiniteDimensional().WithBasis().example() # optional - sage.modules sage: Z = L.center(); Z # optional - sage.modules An example of a finite dimensional Lie algebra with basis: the 3-dimensional abelian Lie algebra over Rational Field sage: Z.basis_matrix() # optional - sage.modules [1 0 0] [0 1 0] [0 0 1]
- centralizer(S)#
Return the centralizer of
S
inself
.INPUT:
S
– a subalgebra ofself
or a list of elements that represent generators for a subalgebra
See also
EXAMPLES:
sage: L = LieAlgebras(QQ).FiniteDimensional().WithBasis().example() # optional - sage.modules sage: a, b, c = L.lie_algebra_generators() # optional - sage.modules sage: S = L.centralizer([a + b, 2*a + c]); S # optional - sage.modules An example of a finite dimensional Lie algebra with basis: the 3-dimensional abelian Lie algebra over Rational Field sage: S.basis_matrix() # optional - sage.modules [1 0 0] [0 1 0] [0 0 1]
- centralizer_basis(S)#
Return a basis of the centralizer of
S
inself
.INPUT:
S
– a subalgebra ofself
or a list of elements that represent generators for a subalgebra
See also
EXAMPLES:
sage: L = LieAlgebras(QQ).FiniteDimensional().WithBasis().example() # optional - sage.modules sage: a, b, c = L.lie_algebra_generators() # optional - sage.modules sage: L.centralizer_basis([a + b, 2*a + c]) # optional - sage.modules [(1, 0, 0), (0, 1, 0), (0, 0, 1)] sage: H = lie_algebras.Heisenberg(QQ, 2) # optional - sage.combinat sage.modules sage: H.centralizer_basis(H) # optional - sage.combinat sage.modules [z] sage: D = DescentAlgebra(QQ, 4).D() # optional - sage.combinat sage.modules sage: L = LieAlgebra(associative=D) # optional - sage.combinat sage.modules sage: L.centralizer_basis(L) # optional - sage.combinat sage.modules [D{}, D{1} + D{1, 2} + D{2, 3} + D{3}, D{1, 2, 3} + D{1, 3} + D{2}] sage: D.center_basis() # optional - sage.combinat sage.modules (D{}, D{1} + D{1, 2} + D{2, 3} + D{3}, D{1, 2, 3} + D{1, 3} + D{2})
- chevalley_eilenberg_complex(M=None, dual=False, sparse=True, ncpus=None)#
Return the Chevalley-Eilenberg complex of
self
.Let \(\mathfrak{g}\) be a Lie algebra and \(M\) be a right \(\mathfrak{g}\)-module. The Chevalley-Eilenberg complex is the chain complex on
\[C_{\bullet}(\mathfrak{g}, M) = M \otimes \bigwedge\nolimits^{\bullet} \mathfrak{g},\]where the differential is given by
\[d(m \otimes g_1 \wedge \cdots \wedge g_p) = \sum_{i=1}^p (-1)^{i+1} (m g_i) \otimes g_1 \wedge \cdots \wedge \hat{g}_i \wedge \cdots \wedge g_p + \sum_{1 \leq i < j \leq p} (-1)^{i+j} m \otimes [g_i, g_j] \wedge g_1 \wedge \cdots \wedge \hat{g}_i \wedge \cdots \wedge \hat{g}_j \wedge \cdots \wedge g_p.\]INPUT:
M
– (default: the trivial 1-dimensional module) the module \(M\)dual
– (default:False
) ifTrue
, causes the dual of the complex to be computedsparse
– (default:True
) whether to use sparse or dense matricesncpus
– (optional) how many cpus to use
EXAMPLES:
sage: L = lie_algebras.sl(ZZ, 2) # optional - sage.combinat sage.modules sage: C = L.chevalley_eilenberg_complex(); C # optional - sage.combinat sage.modules Chain complex with at most 4 nonzero terms over Integer Ring sage: ascii_art(C) # optional - sage.combinat sage.modules [ 2 0 0] [0] [ 0 -1 0] [0] [0 0 0] [ 0 0 2] [0] 0 <-- C_0 <-------- C_1 <----------- C_2 <---- C_3 <-- 0 sage: L = LieAlgebra(QQ, cartan_type=['C',2]) # optional - sage.combinat sage.modules sage: C = L.chevalley_eilenberg_complex() # long time # optional - sage.combinat sage.modules sage: [C.free_module_rank(i) for i in range(11)] # long time # optional - sage.combinat sage.modules [1, 10, 45, 120, 210, 252, 210, 120, 45, 10, 1] sage: g = lie_algebras.sl(QQ, 2) # optional - sage.combinat sage.modules sage: E, F, H = g.basis() # optional - sage.combinat sage.modules sage: n = g.subalgebra([F, H]) # optional - sage.combinat sage.modules sage: ascii_art(n.chevalley_eilenberg_complex()) # optional - sage.combinat sage.modules [0] [0 0] [2] 0 <-- C_0 <------ C_1 <---- C_2 <-- 0
REFERENCES:
Todo
Currently this is only implemented for coefficients given by the trivial module \(R\), where \(R\) is the base ring and \(g R = 0\) for all \(g \in \mathfrak{g}\). Allow generic coefficient modules \(M\).
- cohomology(deg=None, M=None, sparse=True, ncpus=None)#
Return the Lie algebra cohomology of
self
.The Lie algebra cohomology is the cohomology of the Chevalley-Eilenberg cochain complex (which is the dual of the Chevalley-Eilenberg chain complex).
Let \(\mathfrak{g}\) be a Lie algebra and \(M\) a left \(\mathfrak{g}\)-module. It is known that \(H^0(\mathfrak{g}; M)\) is the subspace of \(\mathfrak{g}\)-invariants of \(M\):
\[H^0(\mathfrak{g}; M) = M^{\mathfrak{g}} = \{ m \in M \mid g m = 0 \text{ for all } g \in \mathfrak{g} \}.\]Additionally, \(H^1(\mathfrak{g}; M)\) is the space of derivations \(\mathfrak{g} \to M\) modulo the space of inner derivations, and \(H^2(\mathfrak{g}; M)\) is the space of equivalence classes of Lie algebra extensions of \(\mathfrak{g}\) by \(M\).
INPUT:
deg
– the degree of the homology (optional)M
– (default: the trivial module) a right module ofself
sparse
– (default:True
) whether to use sparse matrices for the Chevalley-Eilenberg chain complexncpus
– (optional) how many cpus to use when computing the Chevalley-Eilenberg chain complex
EXAMPLES:
sage: L = lie_algebras.so(QQ, 4) # optional - sage.combinat sage.modules sage: L.cohomology() # optional - sage.combinat sage.modules {0: Vector space of dimension 1 over Rational Field, 1: Vector space of dimension 0 over Rational Field, 2: Vector space of dimension 0 over Rational Field, 3: Vector space of dimension 2 over Rational Field, 4: Vector space of dimension 0 over Rational Field, 5: Vector space of dimension 0 over Rational Field, 6: Vector space of dimension 1 over Rational Field} sage: L = lie_algebras.Heisenberg(QQ, 2) # optional - sage.combinat sage.modules sage: L.cohomology() # optional - sage.combinat sage.modules {0: Vector space of dimension 1 over Rational Field, 1: Vector space of dimension 4 over Rational Field, 2: Vector space of dimension 5 over Rational Field, 3: Vector space of dimension 5 over Rational Field, 4: Vector space of dimension 4 over Rational Field, 5: Vector space of dimension 1 over Rational Field} sage: d = {('x', 'y'): {'y': 2}} # optional - sage.combinat sage.modules sage: L.<x,y> = LieAlgebra(ZZ, d) # optional - sage.combinat sage.modules sage: L.cohomology() # optional - sage.combinat sage.modules {0: Z, 1: Z, 2: C2}
See also
REFERENCES:
- derivations_basis()#
Return a basis for the Lie algebra of derivations of
self
as matrices.A derivation \(D\) of an algebra is an endomorphism of \(A\) such that
\[D([a, b]) = [D(a), b] + [a, D(b)]\]for all \(a, b \in A\). The set of all derivations form a Lie algebra.
EXAMPLES:
We construct the derivations of the Heisenberg Lie algebra:
sage: H = lie_algebras.Heisenberg(QQ, 1) # optional - sage.combinat sage.modules sage: H.derivations_basis() # optional - sage.combinat sage.modules ( [1 0 0] [0 1 0] [0 0 0] [0 0 0] [0 0 0] [0 0 0] [0 0 0] [0 0 0] [1 0 0] [0 1 0] [0 0 0] [0 0 0] [0 0 1], [0 0 0], [0 0 0], [0 0 1], [1 0 0], [0 1 0] )
We construct the derivations of \(\mathfrak{sl}_2\):
sage: sl2 = lie_algebras.sl(QQ, 2) # optional - sage.combinat sage.modules sage: sl2.derivations_basis() # optional - sage.combinat sage.modules ( [ 1 0 0] [ 0 1 0] [ 0 0 0] [ 0 0 0] [ 0 0 -1/2] [ 1 0 0] [ 0 0 -1], [ 0 0 0], [ 0 -2 0] )
We verify these are derivations:
sage: D = [sl2.module_morphism(matrix=M, codomain=sl2) # optional - sage.combinat sage.modules ....: for M in sl2.derivations_basis()] sage: all(d(a.bracket(b)) == d(a).bracket(b) + a.bracket(d(b)) # optional - sage.combinat sage.modules ....: for a in sl2.basis() for b in sl2.basis() for d in D) True
REFERENCES:
- derived_series()#
Return the derived series \((\mathfrak{g}^{(i)})_i\) of
self
where the rightmost \(\mathfrak{g}^{(k)} = \mathfrak{g}^{(k+1)} = \cdots\).We define the derived series of a Lie algebra \(\mathfrak{g}\) recursively by \(\mathfrak{g}^{(0)} := \mathfrak{g}\) and
\[\mathfrak{g}^{(k+1)} = [\mathfrak{g}^{(k)}, \mathfrak{g}^{(k)}]\]and recall that \(\mathfrak{g}^{(k)} \supseteq \mathfrak{g}^{(k+1)}\). Alternatively we can express this as
\[\mathfrak{g} \supseteq [\mathfrak{g}, \mathfrak{g}] \supseteq \bigl[ [\mathfrak{g}, \mathfrak{g}], [\mathfrak{g}, \mathfrak{g}] \bigr] \supseteq \biggl[ \bigl[ [\mathfrak{g}, \mathfrak{g}], [\mathfrak{g}, \mathfrak{g}] \bigr], \bigl[ [\mathfrak{g}, \mathfrak{g}], [\mathfrak{g}, \mathfrak{g}] \bigr] \biggr] \supseteq \cdots.\]EXAMPLES:
sage: L = LieAlgebras(QQ).FiniteDimensional().WithBasis().example() # optional - sage.combinat sage.modules sage: L.derived_series() # optional - sage.combinat sage.modules (An example of a finite dimensional Lie algebra with basis: the 3-dimensional abelian Lie algebra over Rational Field, An example of a finite dimensional Lie algebra with basis: the 0-dimensional abelian Lie algebra over Rational Field with basis matrix: [])
sage: L.<x,y> = LieAlgebra(QQ, {('x','y'): {'x':1}}) # optional - sage.combinat sage.modules sage: L.derived_series() # todo: not implemented - #17416 # optional - sage.combinat sage.modules (Lie algebra on 2 generators (x, y) over Rational Field, Subalgebra generated of Lie algebra on 2 generators (x, y) over Rational Field with basis: (x,), Subalgebra generated of Lie algebra on 2 generators (x, y) over Rational Field with basis: ())
- derived_subalgebra()#
Return the derived subalgebra of
self
.EXAMPLES:
sage: L = LieAlgebras(QQ).FiniteDimensional().WithBasis().example() # optional - sage.combinat sage.modules sage: L.derived_subalgebra() # optional - sage.combinat sage.modules An example of a finite dimensional Lie algebra with basis: the 0-dimensional abelian Lie algebra over Rational Field with basis matrix: []
If
self
is semisimple, then the derived subalgebra isself
:sage: sl3 = LieAlgebra(QQ, cartan_type=['A', 2]) # optional - sage.combinat sage.modules sage: sl3.derived_subalgebra() # optional - sage.combinat sage.modules Lie algebra of ['A', 2] in the Chevalley basis sage: sl3 is sl3.derived_subalgebra() # optional - sage.combinat sage.modules True
- from_vector(v, order=None)#
Return the element of
self
corresponding to the vectorv
inself.module()
.Implement this if you implement
module()
; see the documentation ofsage.categories.lie_algebras.LieAlgebras.module()
for how this is to be done.EXAMPLES:
sage: L = LieAlgebras(QQ).FiniteDimensional().WithBasis().example() # optional - sage.modules sage: u = L.from_vector(vector(QQ, (1, 0, 0))); u # optional - sage.modules (1, 0, 0) sage: parent(u) is L # optional - sage.modules True
- homology(deg=None, M=None, sparse=True, ncpus=None)#
Return the Lie algebra homology of
self
.The Lie algebra homology is the homology of the Chevalley-Eilenberg chain complex.
INPUT:
deg
– the degree of the homology (optional)M
– (default: the trivial module) a right module ofself
sparse
– (default:True
) whether to use sparse matrices for the Chevalley-Eilenberg chain complexncpus
– (optional) how many cpus to use when computing the Chevalley-Eilenberg chain complex
EXAMPLES:
sage: L = lie_algebras.cross_product(QQ) # optional - sage.combinat sage.modules sage: L.homology() # optional - sage.combinat sage.modules {0: Vector space of dimension 1 over Rational Field, 1: Vector space of dimension 0 over Rational Field, 2: Vector space of dimension 0 over Rational Field, 3: Vector space of dimension 1 over Rational Field} sage: L = lie_algebras.pwitt(GF(5), 5) # optional - sage.combinat sage.libs.pari sage.modules sage: L.homology() # optional - sage.combinat sage.libs.pari sage.modules {0: Vector space of dimension 1 over Finite Field of size 5, 1: Vector space of dimension 0 over Finite Field of size 5, 2: Vector space of dimension 1 over Finite Field of size 5, 3: Vector space of dimension 1 over Finite Field of size 5, 4: Vector space of dimension 0 over Finite Field of size 5, 5: Vector space of dimension 1 over Finite Field of size 5} sage: d = {('x', 'y'): {'y': 2}} # optional - sage.combinat sage.modules sage: L.<x,y> = LieAlgebra(ZZ, d) # optional - sage.combinat sage.modules sage: L.homology() # optional - sage.combinat sage.modules {0: Z, 1: Z x C2, 2: 0}
See also
- ideal(*gens, **kwds)#
Return the ideal of
self
generated bygens
.INPUT:
gens
– a list of generators of the idealcategory
– (optional) a subcategory of subobjects of finite dimensional Lie algebras with basis
EXAMPLES:
sage: H = lie_algebras.Heisenberg(QQ, 2) # optional - sage.combinat sage.modules sage: p1,p2,q1,q2,z = H.basis() # optional - sage.combinat sage.modules sage: I = H.ideal([p1-p2, q1-q2]) # optional - sage.combinat sage.modules sage: I.basis().list() # optional - sage.combinat sage.modules [-p1 + p2, -q1 + q2, z] sage: I.reduce(p1 + p2 + q1 + q2 + z) # optional - sage.combinat sage.modules 2*p1 + 2*q1
Passing an extra category to an ideal:
sage: L.<x,y,z> = LieAlgebra(QQ, abelian=True) # optional - sage.combinat sage.modules sage: C = LieAlgebras(QQ).FiniteDimensional().WithBasis() # optional - sage.combinat sage.modules sage: C = C.Subobjects().Graded().Stratified() # optional - sage.combinat sage.modules sage: I = L.ideal(x, y, category=C) # optional - sage.combinat sage.modules sage: I.homogeneous_component_basis(1).list() # optional - sage.combinat sage.modules [x, y]
- inner_derivations_basis()#
Return a basis for the Lie algebra of inner derivations of
self
as matrices.EXAMPLES:
sage: H = lie_algebras.Heisenberg(QQ, 1) # optional - sage.combinat sage.modules sage: H.inner_derivations_basis() # optional - sage.combinat sage.modules ( [0 0 0] [0 0 0] [0 0 0] [0 0 0] [1 0 0], [0 1 0] )
- is_abelian()#
Return if
self
is an abelian Lie algebra.EXAMPLES:
sage: L = LieAlgebras(QQ).FiniteDimensional().WithBasis().example() # optional - sage.combinat sage.modules sage: L.is_abelian() # optional - sage.combinat sage.modules True
sage: L.<x,y> = LieAlgebra(QQ, {('x','y'): {'x':1}}) # optional - sage.combinat sage.modules sage: L.is_abelian() # optional - sage.combinat sage.modules False
- is_ideal(A)#
Return if
self
is an ideal ofA
.EXAMPLES:
sage: L = LieAlgebras(QQ).FiniteDimensional().WithBasis().example() # optional - sage.combinat sage.modules sage: a, b, c = L.lie_algebra_generators() # optional - sage.combinat sage.modules sage: I = L.ideal([2*a - c, b + c]) # optional - sage.combinat sage.modules sage: I.is_ideal(L) # optional - sage.combinat sage.modules True sage: L.<x,y> = LieAlgebra(QQ, {('x','y'):{'x':1}}) # optional - sage.combinat sage.modules sage: L.is_ideal(L) # optional - sage.combinat sage.modules True sage: F = LieAlgebra(QQ, 'F', representation='polynomial') # optional - sage.combinat sage.modules sage: L.is_ideal(F) # optional - sage.combinat sage.modules Traceback (most recent call last): ... NotImplementedError: A must be a finite dimensional Lie algebra with basis
- is_nilpotent()#
Return if
self
is a nilpotent Lie algebra.A Lie algebra is nilpotent if the lower central series eventually becomes \(0\).
EXAMPLES:
sage: L = LieAlgebras(QQ).FiniteDimensional().WithBasis().example() # optional - sage.combinat sage.modules sage: L.is_nilpotent() # optional - sage.combinat sage.modules True
- is_semisimple()#
Return if
self
if a semisimple Lie algebra.A Lie algebra is semisimple if the solvable radical is zero. In characteristic 0, this is equivalent to saying the Killing form is non-degenerate.
EXAMPLES:
sage: L = LieAlgebras(QQ).FiniteDimensional().WithBasis().example() # optional - sage.combinat sage.modules sage: L.is_semisimple() # optional - sage.combinat sage.modules False
- is_solvable()#
Return if
self
is a solvable Lie algebra.A Lie algebra is solvable if the derived series eventually becomes \(0\).
EXAMPLES:
sage: L = LieAlgebras(QQ).FiniteDimensional().WithBasis().example() # optional - sage.combinat sage.modules sage: L.is_solvable() # optional - sage.combinat sage.modules True
sage: L.<x,y> = LieAlgebra(QQ, {('x','y'): {'x':1}}) # optional - sage.combinat sage.modules sage: L.is_solvable() # todo: not implemented - #17416 # optional - sage.combinat sage.modules False
- killing_form(x, y)#
Return the Killing form on
x
andy
, wherex
andy
are two elements ofself
.The Killing form is defined as
\[\langle x \mid y \rangle = \operatorname{tr}\left( \operatorname{ad}_x \circ \operatorname{ad}_y \right).\]EXAMPLES:
sage: L = LieAlgebras(QQ).FiniteDimensional().WithBasis().example() # optional - sage.combinat sage.modules sage: a, b, c = L.lie_algebra_generators() # optional - sage.combinat sage.modules sage: L.killing_form(a, b) # optional - sage.combinat sage.modules 0
- killing_form_matrix()#
Return the matrix of the Killing form of
self
.The rows and the columns of this matrix are indexed by the elements of the basis of
self
(in the order provided bybasis()
).EXAMPLES:
sage: L = LieAlgebras(QQ).FiniteDimensional().WithBasis().example() # optional - sage.modules sage: L.killing_form_matrix() # optional - sage.modules [0 0 0] [0 0 0] [0 0 0] sage: L = LieAlgebras(QQ).FiniteDimensional().WithBasis().example(0) # optional - sage.modules sage: m = L.killing_form_matrix(); m # optional - sage.modules [] sage: parent(m) # optional - sage.modules Full MatrixSpace of 0 by 0 dense matrices over Rational Field
- killing_matrix(x, y)#
Return the Killing matrix of
x
andy
, wherex
andy
are two elements ofself
.The Killing matrix is defined as the matrix corresponding to the action of \(\operatorname{ad}_x \circ \operatorname{ad}_y\) in the basis of
self
.EXAMPLES:
sage: L = LieAlgebras(QQ).FiniteDimensional().WithBasis().example() # optional - sage.modules sage: a, b, c = L.lie_algebra_generators() # optional - sage.modules sage: L.killing_matrix(a, b) # optional - sage.modules [0 0 0] [0 0 0] [0 0 0]
sage: L.<x,y> = LieAlgebra(QQ, {('x','y'): {'x':1}}) # optional - sage.combinat sage.modules sage: L.killing_matrix(y, x) # optional - sage.combinat sage.modules [ 0 -1] [ 0 0]
- lower_central_series(submodule=False)#
Return the lower central series \((\mathfrak{g}_{i})_i\) of
self
where the rightmost \(\mathfrak{g}_k = \mathfrak{g}_{k+1} = \cdots\).INPUT:
submodule
– (default:False
) ifTrue
, then the result is given as submodules ofself
We define the lower central series of a Lie algebra \(\mathfrak{g}\) recursively by \(\mathfrak{g}_0 := \mathfrak{g}\) and
\[\mathfrak{g}_{k+1} = [\mathfrak{g}, \mathfrak{g}_{k}]\]and recall that \(\mathfrak{g}_{k} \supseteq \mathfrak{g}_{k+1}\). Alternatively we can express this as
\[\mathfrak{g} \supseteq [\mathfrak{g}, \mathfrak{g}] \supseteq \bigl[ [\mathfrak{g}, \mathfrak{g}], \mathfrak{g} \bigr] \supseteq\biggl[\bigl[ [\mathfrak{g}, \mathfrak{g}], \mathfrak{g} \bigr], \mathfrak{g}\biggr] \supseteq \cdots.\]EXAMPLES:
sage: L = LieAlgebras(QQ).FiniteDimensional().WithBasis().example() # optional - sage.combinat sage.modules sage: L.derived_series() # optional - sage.combinat sage.modules (An example of a finite dimensional Lie algebra with basis: the 3-dimensional abelian Lie algebra over Rational Field, An example of a finite dimensional Lie algebra with basis: the 0-dimensional abelian Lie algebra over Rational Field with basis matrix: [])
The lower central series as submodules:
sage: L.<x,y> = LieAlgebra(QQ, {('x','y'): {'x':1}}) # optional - sage.combinat sage.modules sage: L.lower_central_series(submodule=True) # optional - sage.combinat sage.modules (Sparse vector space of dimension 2 over Rational Field, Vector space of degree 2 and dimension 1 over Rational Field Basis matrix: [1 0])
sage: L.<x,y> = LieAlgebra(QQ, {('x','y'): {'x':1}}) # optional - sage.combinat sage.modules sage: L.lower_central_series() # todo: not implemented - #17416 # optional - sage.combinat sage.modules (Lie algebra on 2 generators (x, y) over Rational Field, Subalgebra generated of Lie algebra on 2 generators (x, y) over Rational Field with basis: (x,))
- module(R=None)#
Return a dense free module associated to
self
overR
.EXAMPLES:
sage: L = LieAlgebras(QQ).FiniteDimensional().WithBasis().example() # optional - sage.modules sage: L._dense_free_module() # optional - sage.modules Vector space of dimension 3 over Rational Field
- morphism(on_generators, codomain=None, base_map=None, check=True)#
Return a Lie algebra morphism defined by images of a Lie generating subset of
self
.INPUT:
on_generators
– dictionary{X: Y}
of the images \(Y\) incodomain
of elements \(X\) ofdomain
codomain
– a Lie algebra (optional); this is inferred from the values ofon_generators
if not givenbase_map
– a homomorphism from the base ring to something coercing into the codomaincheck
– (default:True
) boolean; ifFalse
the values on the Lie brackets implied byon_generators
will not be checked for contradictory values
Note
The keys of
on_generators
need to generatedomain
as a Lie algebra.EXAMPLES:
A quotient type Lie algebra morphism
sage: L.<X,Y,Z,W> = LieAlgebra(QQ, {('X','Y'): {'Z': 1}, # optional - sage.combinat sage.modules ....: ('X','Z'): {'W': 1}}) sage: K.<A,B> = LieAlgebra(QQ, abelian=True) # optional - sage.combinat sage.modules sage: L.morphism({X: A, Y: B}) # optional - sage.combinat sage.modules Lie algebra morphism: From: Lie algebra on 4 generators (X, Y, Z, W) over Rational Field To: Abelian Lie algebra on 2 generators (A, B) over Rational Field Defn: X |--> A Y |--> B Z |--> 0 W |--> 0
The reverse map \(A \mapsto X\), \(B \mapsto Y\) does not define a Lie algebra morphism, since \([A,B] = 0\), but \([X,Y] \neq 0\):
sage: K.morphism({A:X, B: Y}) # optional - sage.combinat sage.modules Traceback (most recent call last): ... ValueError: this does not define a Lie algebra morphism; contradictory values for brackets of length 2
However, it is still possible to create a morphism that acts nontrivially on the coefficients, even though it’s not a Lie algebra morphism (since it isn’t linear):
sage: R.<x> = ZZ[] # optional - sage.combinat sage.modules sage: K.<i> = NumberField(x^2 + 1) # optional - sage.combinat sage.modules sage.rings.number_fields sage: cc = K.hom([-i]) # optional - sage.combinat sage.modules sage.rings.number_fields sage: L.<X,Y,Z,W> = LieAlgebra(K, {('X','Y'): {'Z': 1}, # optional - sage.combinat sage.modules sage.rings.number_fields ....: ('X','Z'): {'W': 1}}) sage: M.<A,B> = LieAlgebra(K, abelian=True) # optional - sage.combinat sage.modules sage.rings.number_fields sage: phi = L.morphism({X: A, Y: B}, base_map=cc) # optional - sage.combinat sage.modules sage.rings.number_fields sage: phi(X) # optional - sage.combinat sage.modules sage.rings.number_fields A sage: phi(i*X) # optional - sage.combinat sage.modules sage.rings.number_fields -i*A
- product_space(L, submodule=False)#
Return the product space
[self, L]
.INPUT:
L
– a Lie subalgebra ofself
submodule
– (default:False
) ifTrue
, then the result is forced to be a submodule ofself
EXAMPLES:
sage: L = LieAlgebras(QQ).FiniteDimensional().WithBasis().example() # optional - sage.combinat sage.modules sage: a,b,c = L.lie_algebra_generators() # optional - sage.combinat sage.modules sage: X = L.subalgebra([a, b+c]) # optional - sage.combinat sage.modules sage: L.product_space(X) # optional - sage.combinat sage.modules An example of a finite dimensional Lie algebra with basis: the 0-dimensional abelian Lie algebra over Rational Field with basis matrix: [] sage: Y = L.subalgebra([a, 2*b-c]) # optional - sage.combinat sage.modules sage: X.product_space(Y) # optional - sage.combinat sage.modules An example of a finite dimensional Lie algebra with basis: the 0-dimensional abelian Lie algebra over Rational Field with basis matrix: []
sage: H = lie_algebras.Heisenberg(ZZ, 4) # optional - sage.combinat sage.modules sage: Hp = H.product_space(H, submodule=True).basis() # optional - sage.combinat sage.modules sage: [H.from_vector(v) for v in Hp] # optional - sage.combinat sage.modules [z]
sage: L.<x,y> = LieAlgebra(QQ, {('x','y'):{'x':1}}) # optional - sage.combinat sage.modules sage: Lp = L.product_space(L) # todo: not implemented - #17416 # optional - sage.combinat sage.modules sage: Lp # todo: not implemented - #17416 # optional - sage.combinat sage.modules Subalgebra generated of Lie algebra on 2 generators (x, y) over Rational Field with basis: (x,) sage: Lp.product_space(L) # todo: not implemented - #17416 # optional - sage.combinat sage.modules Subalgebra generated of Lie algebra on 2 generators (x, y) over Rational Field with basis: (x,) sage: L.product_space(Lp) # todo: not implemented - #17416 # optional - sage.combinat sage.modules Subalgebra generated of Lie algebra on 2 generators (x, y) over Rational Field with basis: (x,) sage: Lp.product_space(Lp) # todo: not implemented - #17416 # optional - sage.combinat sage.modules Subalgebra generated of Lie algebra on 2 generators (x, y) over Rational Field with basis: ()
- quotient(I, names=None, category=None)#
Return the quotient of
self
by the idealI
.A quotient Lie algebra.
INPUT:
I
– an ideal or a list of generators of the idealnames
– (optional) a string or a list of strings; names for the basis elements of the quotient. Ifnames
is a string, the basis will be namednames_1
,…,``names_n``.
EXAMPLES:
The Engel Lie algebra as a quotient of the free nilpotent Lie algebra of step 3 with 2 generators:
sage: L.<X,Y,Z,W,U> = LieAlgebra(QQ, 2, step=3) # optional - sage.combinat sage.modules sage: E = L.quotient(U); E # optional - sage.combinat sage.modules Lie algebra quotient L/I of dimension 4 over Rational Field where L: Free Nilpotent Lie algebra on 5 generators (X, Y, Z, W, U) over Rational Field I: Ideal (U) sage: E.basis().list() # optional - sage.combinat sage.modules [X, Y, Z, W] sage: E(X).bracket(E(Y)) # optional - sage.combinat sage.modules Z sage: Y.bracket(Z) # optional - sage.combinat sage.modules -U sage: E(Y).bracket(E(Z)) # optional - sage.combinat sage.modules 0 sage: E(U) # optional - sage.combinat sage.modules 0
Quotients when the base ring is not a field are not implemented:
sage: L = lie_algebras.Heisenberg(ZZ, 1) # optional - sage.combinat sage.modules sage: L.quotient(L.an_element()) # optional - sage.combinat sage.modules Traceback (most recent call last): ... NotImplementedError: quotients over non-fields not implemented
- structure_coefficients(include_zeros=False)#
Return the structure coefficients of
self
.INPUT:
include_zeros
– (default:False
) ifTrue
, then include the \([x, y] = 0\) pairs in the output
OUTPUT:
A dictionary whose keys are pairs of basis indices \((i, j)\) with \(i < j\), and whose values are the corresponding elements \([b_i, b_j]\) in the Lie algebra.
EXAMPLES:
sage: L = LieAlgebras(QQ).FiniteDimensional().WithBasis().example() # optional - sage.modules sage: L.structure_coefficients() # optional - sage.modules Finite family {} sage: L.structure_coefficients(True) # optional - sage.modules Finite family {(0, 1): (0, 0, 0), (0, 2): (0, 0, 0), (1, 2): (0, 0, 0)}
sage: G = SymmetricGroup(3) # optional - sage.groups sage: S = GroupAlgebra(G, QQ) # optional - sage.groups sage.modules sage: L = LieAlgebra(associative=S) # optional - sage.groups sage.modules sage.combinat sage: L.structure_coefficients() # optional - sage.groups sage.modules sage.combinat Finite family {((2,3), (1,2)): (1,2,3) - (1,3,2), ((2,3), (1,3)): -(1,2,3) + (1,3,2), ((1,2,3), (2,3)): -(1,2) + (1,3), ((1,2,3), (1,2)): (2,3) - (1,3), ((1,2,3), (1,3)): -(2,3) + (1,2), ((1,3,2), (2,3)): (1,2) - (1,3), ((1,3,2), (1,2)): -(2,3) + (1,3), ((1,3,2), (1,3)): (2,3) - (1,2), ((1,3), (1,2)): -(1,2,3) + (1,3,2)}
- subalgebra(*gens, **kwds)#
Return the subalgebra of
self
generated bygens
.INPUT:
gens
– a list of generators of the subalgebracategory
– (optional) a subcategory of subobjects of finite dimensional Lie algebras with basis
EXAMPLES:
sage: H = lie_algebras.Heisenberg(QQ, 2) # optional - sage.combinat sage.modules sage: p1,p2,q1,q2,z = H.basis() # optional - sage.combinat sage.modules sage: S = H.subalgebra([p1, q1]) # optional - sage.combinat sage.modules sage: S.basis().list() # optional - sage.combinat sage.modules [p1, q1, z] sage: S.basis_matrix() # optional - sage.combinat sage.modules [1 0 0 0 0] [0 0 1 0 0] [0 0 0 0 1]
Passing an extra category to a subalgebra:
sage: L = LieAlgebra(QQ, 3, step=2) # optional - sage.combinat sage.modules sage: x,y,z = L.homogeneous_component_basis(1) # optional - sage.combinat sage.modules sage: C = LieAlgebras(QQ).FiniteDimensional().WithBasis() # optional - sage.combinat sage.modules sage: C = C.Subobjects().Graded().Stratified() # optional - sage.combinat sage.modules sage: S = L.subalgebra([x, y], category=C) # optional - sage.combinat sage.modules sage: S.homogeneous_component_basis(2).list() # optional - sage.combinat sage.modules [X_12]
- universal_commutative_algebra()#
Return the universal commutative algebra associated to
self
.Let \(I\) be the index set of the basis of
self
. Let \(\mathcal{P} = \{P_{a,i,j}\}_{a,i,j \in I}\) denote the universal polynomials of a Lie algebra \(L\). The universal commutative algebra associated to \(L\) is the quotient ring \(R[X_{ij}]_{i,j \in I} / (\mathcal{P})\).EXAMPLES:
sage: L.<x,y> = LieAlgebra(QQ, {('x','y'): {'x':1}}) # optional - sage.combinat sage.modules sage: A = L.universal_commutative_algebra() # optional - sage.combinat sage.modules sage: a, b, c, d = A.gens() # optional - sage.combinat sage.modules sage: a, b, c, d # optional - sage.combinat sage.modules (X00bar, X01bar, 0, X11bar) sage: a*d - a # optional - sage.combinat sage.modules 0
- universal_polynomials()#
Return the family of universal polynomials of
self
.The universal polynomials of a Lie algebra \(L\) with basis \(\{e_i\}_{i \in I}\) and structure coefficients \([e_i, e_j] = \tau_{ij}^a e_a\) is given by
\[P_{aij} = \sum_{u \in I} \tau_{ij}^u X_{au} - \sum_{s,t \in I} \tau_{st}^a X_{si} X_{tj},\]where \(a,i,j \in I\).
REFERENCES:
EXAMPLES:
sage: L.<x,y> = LieAlgebra(QQ, {('x','y'): {'x':1}}) # optional - sage.combinat sage.modules sage: L.universal_polynomials() # optional - sage.combinat sage.modules Finite family {('x', 'x', 'y'): X01*X10 - X00*X11 + X00, ('y', 'x', 'y'): X10} sage: L = LieAlgebra(QQ, cartan_type=['A',1]) # optional - sage.combinat sage.modules sage: list(L.universal_polynomials()) # optional - sage.combinat sage.modules [-2*X01*X10 + 2*X00*X11 - 2*X00, -2*X02*X10 + 2*X00*X12 + X01, -2*X02*X11 + 2*X01*X12 - 2*X02, X01*X20 - X00*X21 - 2*X10, X02*X20 - X00*X22 + X11, X02*X21 - X01*X22 - 2*X12, -2*X11*X20 + 2*X10*X21 - 2*X20, -2*X12*X20 + 2*X10*X22 + X21, -2*X12*X21 + 2*X11*X22 - 2*X22] sage: L = LieAlgebra(QQ, cartan_type=['B', 2]) # optional - sage.combinat sage.modules sage: al = RootSystem(['B', 2]).root_lattice().simple_roots() # optional - sage.combinat sage.modules sage: k = list(L.basis().keys())[0] # optional - sage.combinat sage.modules sage: UP = L.universal_polynomials() # long time # optional - sage.combinat sage.modules sage: len(UP) # long time # optional - sage.combinat sage.modules 450 sage: UP[al[2], al[1], -al[1]] # long time # optional - sage.combinat sage.modules X0_7*X4_1 - X0_1*X4_7 - 2*X0_7*X5_1 + 2*X0_1*X5_7 + X2_7*X7_1 - X2_1*X7_7 - X3_7*X8_1 + X3_1*X8_7 + X0_4
- class Subobjects(category, *args)#
Bases:
SubobjectsCategory
A category for subalgebras of a finite dimensional Lie algebra with basis.
- class ParentMethods#
Bases:
object
- ambient()#
Return the ambient Lie algebra of
self
.EXAMPLES:
sage: C = LieAlgebras(QQ).FiniteDimensional().WithBasis() sage: L = C.example() # optional - sage.combinat sage.modules sage: a, b, c = L.lie_algebra_generators() # optional - sage.combinat sage.modules sage: S = L.subalgebra([2*a + b, b + c]) # optional - sage.combinat sage.modules sage: S.ambient() == L # optional - sage.combinat sage.modules True
- basis_matrix()#
Return the basis matrix of
self
.EXAMPLES:
sage: C = LieAlgebras(QQ).FiniteDimensional().WithBasis() sage: L = C.example() # optional - sage.combinat sage.modules sage: a, b, c = L.lie_algebra_generators() # optional - sage.combinat sage.modules sage: S = L.subalgebra([2*a + b, b + c]) # optional - sage.combinat sage.modules sage: S.basis_matrix() # optional - sage.combinat sage.modules [ 1 0 -1/2] [ 0 1 1]
- example(n=3)#
Return an example of a finite dimensional Lie algebra with basis as per
Category.example
.EXAMPLES:
sage: C = LieAlgebras(QQ).FiniteDimensional().WithBasis() sage: C.example() # optional - sage.modules An example of a finite dimensional Lie algebra with basis: the 3-dimensional abelian Lie algebra over Rational Field
Other dimensions can be specified as an optional argument:
sage: C.example(5) # optional - sage.modules An example of a finite dimensional Lie algebra with basis: the 5-dimensional abelian Lie algebra over Rational Field