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_ringCategory 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 elementselfofg(wheregis 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
selfas 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) ifTruefor 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
Sinself.INPUT:
S– a subalgebra ofselfor 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
Sinself.INPUT:
S– a subalgebra ofselfor 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 ofselfsparse– (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
selfas 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
selfwhere 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
selfis 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
selfcorresponding to the vectorvinself.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 ofselfsparse– (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
selfgenerated 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
selfas 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
selfis 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
selfis 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
selfis 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
selfif 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
selfis 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
xandy, wherexandyare 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
xandy, wherexandyare 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
selfwhere 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
selfoverR.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\) incodomainof elements \(X\) ofdomaincodomain– a Lie algebra (optional); this is inferred from the values ofon_generatorsif not givenbase_map– a homomorphism from the base ring to something coercing into the codomaincheck– (default:True) boolean; ifFalsethe values on the Lie brackets implied byon_generatorswill not be checked for contradictory values
Note
The keys of
on_generatorsneed to generatedomainas 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 ofselfsubmodule– (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
selfby 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. Ifnamesis 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
selfgenerated 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:
SubobjectsCategoryA 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