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() sage: L.an_element().adjoint_matrix() [0 0 0] [0 0 0] [0 0 0] sage: L.an_element().adjoint_matrix(sparse=True).is_sparse() True
sage: L.<x,y> = LieAlgebra(QQ, {('x','y'):{'x':1}}) sage: x.adjoint_matrix() [0 1] [0 0] sage: y.adjoint_matrix() [-1 0] [ 0 0]
We verify that this forms a representation:
sage: sl3 = lie_algebras.sl(QQ, 3) sage: e1, e2 = sl3.e(1), sl3.e(2) sage: e12 = e1.bracket(e2) sage: E1, E2 = e1.adjoint_matrix(), e2.adjoint_matrix() sage: E1 * E2 - E2 * E1 == e12.adjoint_matrix() 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() sage: L.an_element().to_vector() (0, 0, 0) sage: L.an_element().to_vector(sparse=True) (0, 0, 0) sage: D = DescentAlgebra(QQ, 4).D() sage: L = LieAlgebra(associative=D) sage: L.an_element().to_vector() (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) sage: x,y,z = L.basis() sage: F = L.as_finite_dimensional_algebra() sage: X,Y,Z = F.basis() sage: x.bracket(y) Z sage: X * Y Z
- center()#
Return the center of
self
.EXAMPLES:
sage: L = LieAlgebras(QQ).FiniteDimensional().WithBasis().example() sage: Z = L.center(); Z An example of a finite dimensional Lie algebra with basis: the 3-dimensional abelian Lie algebra over Rational Field sage: Z.basis_matrix() [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() sage: a,b,c = L.lie_algebra_generators() sage: S = L.centralizer([a + b, 2*a + c]); S An example of a finite dimensional Lie algebra with basis: the 3-dimensional abelian Lie algebra over Rational Field sage: S.basis_matrix() [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() sage: a,b,c = L.lie_algebra_generators() sage: L.centralizer_basis([a + b, 2*a + c]) [(1, 0, 0), (0, 1, 0), (0, 0, 1)] sage: H = lie_algebras.Heisenberg(QQ, 2) sage: H.centralizer_basis(H) [z] sage: D = DescentAlgebra(QQ, 4).D() sage: L = LieAlgebra(associative=D) sage: L.centralizer_basis(L) [D{}, D{1} + D{1, 2} + D{2, 3} + D{3}, D{1, 2, 3} + D{1, 3} + D{2}] sage: D.center_basis() (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) sage: C = L.chevalley_eilenberg_complex(); C Chain complex with at most 4 nonzero terms over Integer Ring sage: ascii_art(C) [ 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]) sage: C = L.chevalley_eilenberg_complex() # long time sage: [C.free_module_rank(i) for i in range(11)] # long time [1, 10, 45, 120, 210, 252, 210, 120, 45, 10, 1] sage: g = lie_algebras.sl(QQ,2) sage: E,F,H = g.basis() sage: n = g.subalgebra([F,H]) sage: ascii_art(n.chevalley_eilenberg_complex()) [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) sage: L.cohomology() {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) sage: L.cohomology() {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}} sage: L.<x,y> = LieAlgebra(ZZ, d) sage: L.cohomology() {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) sage: H.derivations_basis() ( [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) sage: sl2.derivations_basis() ( [ 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) ....: for M in sl2.derivations_basis()] sage: all(d(a.bracket(b)) == d(a).bracket(b) + a.bracket(d(b)) ....: 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() sage: L.derived_series() (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}}) sage: L.derived_series() # todo: not implemented - #17416 (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() sage: L.derived_subalgebra() 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]) sage: sl3.derived_subalgebra() Lie algebra of ['A', 2] in the Chevalley basis sage: sl3 is sl3.derived_subalgebra() 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() sage: u = L.from_vector(vector(QQ, (1, 0, 0))); u (1, 0, 0) sage: parent(u) is L 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) sage: L.homology() {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) sage: L.homology() {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}} sage: L.<x,y> = LieAlgebra(ZZ, d) sage: L.homology() {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) sage: p1,p2,q1,q2,z = H.basis() sage: I = H.ideal([p1-p2, q1-q2]) sage: I.basis().list() [-p1 + p2, -q1 + q2, z] sage: I.reduce(p1 + p2 + q1 + q2 + z) 2*p1 + 2*q1
Passing an extra category to an ideal:
sage: L.<x,y,z> = LieAlgebra(QQ, abelian=True) sage: C = LieAlgebras(QQ).FiniteDimensional().WithBasis() sage: C = C.Subobjects().Graded().Stratified() sage: I = L.ideal(x, y, category=C) sage: I.homogeneous_component_basis(1).list() [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) sage: H.inner_derivations_basis() ( [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() sage: L.is_abelian() True
sage: L.<x,y> = LieAlgebra(QQ, {('x','y'): {'x':1}}) sage: L.is_abelian() False
- is_ideal(A)#
Return if
self
is an ideal ofA
.EXAMPLES:
sage: L = LieAlgebras(QQ).FiniteDimensional().WithBasis().example() sage: a, b, c = L.lie_algebra_generators() sage: I = L.ideal([2*a - c, b + c]) sage: I.is_ideal(L) True sage: L.<x,y> = LieAlgebra(QQ, {('x','y'):{'x':1}}) sage: L.is_ideal(L) True sage: F = LieAlgebra(QQ, 'F', representation='polynomial') sage: L.is_ideal(F) 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() sage: L.is_nilpotent() 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() sage: L.is_semisimple() 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() sage: L.is_solvable() True
sage: L.<x,y> = LieAlgebra(QQ, {('x','y'):{'x':1}}) sage: L.is_solvable() # todo: not implemented - #17416 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() sage: a,b,c = L.lie_algebra_generators() sage: L.killing_form(a, b) 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() sage: L.killing_form_matrix() [0 0 0] [0 0 0] [0 0 0] sage: L = LieAlgebras(QQ).FiniteDimensional().WithBasis().example(0) sage: m = L.killing_form_matrix(); m [] sage: parent(m) 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() sage: a,b,c = L.lie_algebra_generators() sage: L.killing_matrix(a, b) [0 0 0] [0 0 0] [0 0 0]
sage: L.<x,y> = LieAlgebra(QQ, {('x','y'):{'x':1}}) sage: L.killing_matrix(y, x) [ 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() sage: L.derived_series() (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}}) sage: L.lower_central_series(submodule=True) (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}}) sage: L.lower_central_series() # todo: not implemented - #17416 (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() sage: L._dense_free_module() 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}, ('X','Z'): {'W':1}}) sage: K.<A,B> = LieAlgebra(QQ, abelian=True) sage: L.morphism({X: A, Y: B}) 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}) 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[] sage: K.<i> = NumberField(x^2 + 1) sage: cc = K.hom([-i]) sage: L.<X,Y,Z,W> = LieAlgebra(K, {('X','Y'): {'Z':1}, ('X','Z'): {'W':1}}) sage: M.<A,B> = LieAlgebra(K, abelian=True) sage: phi = L.morphism({X: A, Y: B}, base_map=cc) sage: phi(X) A sage: phi(i*X) -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() sage: a,b,c = L.lie_algebra_generators() sage: X = L.subalgebra([a, b+c]) sage: L.product_space(X) 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]) sage: X.product_space(Y) 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) sage: Hp = H.product_space(H, submodule=True).basis() sage: [H.from_vector(v) for v in Hp] [z]
sage: L.<x,y> = LieAlgebra(QQ, {('x','y'):{'x':1}}) sage: Lp = L.product_space(L) # todo: not implemented - #17416 sage: Lp # todo: not implemented - #17416 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 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 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 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) sage: E = L.quotient(U); E 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() [X, Y, Z, W] sage: E(X).bracket(E(Y)) Z sage: Y.bracket(Z) -U sage: E(Y).bracket(E(Z)) 0 sage: E(U) 0
Quotients when the base ring is not a field are not implemented:
sage: L = lie_algebras.Heisenberg(ZZ, 1) sage: L.quotient(L.an_element()) 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() sage: L.structure_coefficients() Finite family {} sage: L.structure_coefficients(True) Finite family {(0, 1): (0, 0, 0), (0, 2): (0, 0, 0), (1, 2): (0, 0, 0)}
sage: G = SymmetricGroup(3) sage: S = GroupAlgebra(G, QQ) sage: L = LieAlgebra(associative=S) sage: L.structure_coefficients() 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) sage: p1,p2,q1,q2,z = H.basis() sage: S = H.subalgebra([p1, q1]) sage: S.basis().list() [p1, q1, z] sage: S.basis_matrix() [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) sage: x,y,z = L.homogeneous_component_basis(1) sage: C = LieAlgebras(QQ).FiniteDimensional().WithBasis() sage: C = C.Subobjects().Graded().Stratified() sage: S = L.subalgebra([x, y], category=C) sage: S.homogeneous_component_basis(2).list() [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}}) sage: A = L.universal_commutative_algebra() sage: a,b,c,d = A.gens() sage: (a,b,c,d) (X00bar, X01bar, 0, X11bar) sage: a*d - a 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}}) sage: L.universal_polynomials() Finite family {('x', 'x', 'y'): X01*X10 - X00*X11 + X00, ('y', 'x', 'y'): X10} sage: L = LieAlgebra(QQ, cartan_type=['A',1]) sage: list(L.universal_polynomials()) [-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]) sage: al = RootSystem(['B',2]).root_lattice().simple_roots() sage: k = list(L.basis().keys())[0] sage: UP = L.universal_polynomials() # long time sage: len(UP) # long time 450 sage: UP[al[2],al[1],-al[1]] # long time 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: L = LieAlgebras(QQ).FiniteDimensional().WithBasis().example() sage: a, b, c = L.lie_algebra_generators() sage: S = L.subalgebra([2*a+b, b + c]) sage: S.ambient() == L True
- basis_matrix()#
Return the basis matrix of
self
.EXAMPLES:
sage: L = LieAlgebras(QQ).FiniteDimensional().WithBasis().example() sage: a, b, c = L.lie_algebra_generators() sage: S = L.subalgebra([2*a+b, b + c]) sage: S.basis_matrix() [ 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() 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) An example of a finite dimensional Lie algebra with basis: the 5-dimensional abelian Lie algebra over Rational Field