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 element self of g (where g is the parent of self).

Implement this if you implement g.module(). See sage.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#

alias of FiniteDimensionalNilpotentLieAlgebrasWithBasis

class ParentMethods#

Bases: object

as_finite_dimensional_algebra()#

Return self as a FiniteDimensionalAlgebra.

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 in self.

INPUT:

  • S – a subalgebra of self or a list of elements that represent generators for a subalgebra

See also

centralizer_basis()

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 in self.

INPUT:

  • S – a subalgebra of self or a list of elements that represent generators for a subalgebra

See also

centralizer()

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) if True, causes the dual of the complex to be computed

  • sparse – (default: True) whether to use sparse or dense matrices

  • ncpus – (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 of self

  • sparse – (default: True) whether to use sparse matrices for the Chevalley-Eilenberg chain complex

  • ncpus – (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

chevalley_eilenberg_complex()

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:

Wikipedia article Derivation_(differential_algebra)

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 is self:

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 vector v in self.module().

Implement this if you implement module(); see the documentation of sage.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 of self

  • sparse – (default: True) whether to use sparse matrices for the Chevalley-Eilenberg chain complex

  • ncpus – (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

chevalley_eilenberg_complex()

ideal(*gens, **kwds)#

Return the ideal of self generated by gens.

INPUT:

  • gens – a list of generators of the ideal

  • category – (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 of A.

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 and y, where x and y are two elements of self.

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 by basis()).

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 and y, where x and y are two elements of self.

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) if True, then the result is given as submodules of self

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 over R.

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\) in codomain of elements \(X\) of domain

  • codomain – a Lie algebra (optional); this is inferred from the values of on_generators if not given

  • base_map – a homomorphism from the base ring to something coercing into the codomain

  • check – (default: True) boolean; if False the values on the Lie brackets implied by on_generators will not be checked for contradictory values

Note

The keys of on_generators need to generate domain as a Lie algebra.

See also

sage.algebras.lie_algebras.morphism.LieAlgebraMorphism_from_generators

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 of self

  • submodule – (default: False) if True, then the result is forced to be a submodule of self

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 ideal I.

A quotient Lie algebra.

INPUT:

  • I – an ideal or a list of generators of the ideal

  • names – (optional) a string or a list of strings; names for the basis elements of the quotient. If names is a string, the basis will be named names_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) if True, 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 by gens.

INPUT:

  • gens – a list of generators of the subalgebra

  • category – (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