# 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)[source]#

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 Issue #16820.

class ElementMethods[source]#

Bases: object

Return the matrix of the adjoint action of self.

EXAMPLES:

sage: # needs sage.combinat sage.modules
sage: L = LieAlgebras(QQ).FiniteDimensional().WithBasis().example()
[0 0 0]
[0 0 0]
[0 0 0]
True

>>> from sage.all import *
>>> # needs sage.combinat sage.modules
>>> L = LieAlgebras(QQ).FiniteDimensional().WithBasis().example()
[0 0 0]
[0 0 0]
[0 0 0]
True

sage: # needs sage.combinat sage.modules
sage: L.<x,y> = LieAlgebra(QQ, {('x','y'): {'x':1}})
[0 1]
[0 0]
[-1  0]
[ 0  0]

>>> from sage.all import *
>>> # needs sage.combinat sage.modules
>>> L = LieAlgebra(QQ, {('x','y'): {'x':Integer(1)}}, names=('x', 'y',)); (x, y,) = L._first_ngens(2)
[0 1]
[0 0]
[-1  0]
[ 0  0]


We verify that this forms a representation:

sage: # needs sage.combinat sage.modules
sage: sl3 = lie_algebras.sl(QQ, 3)
sage: e1, e2 = sl3.e(1), sl3.e(2)
sage: e12 = e1.bracket(e2)
sage: E1 * E2 - E2 * E1 == e12.adjoint_matrix()
True

>>> from sage.all import *
>>> # needs sage.combinat sage.modules
>>> sl3 = lie_algebras.sl(QQ, Integer(3))
>>> e1, e2 = sl3.e(Integer(1)), sl3.e(Integer(2))
>>> e12 = e1.bracket(e2)
>>> E1 * E2 - E2 * E1 == e12.adjoint_matrix()
True

to_vector(sparse=False, order=None)[source]#

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: # needs sage.combinat sage.modules
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: # needs sage.combinat sage.groupssage.modules
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)

>>> from sage.all import *
>>> # needs sage.combinat sage.modules
>>> L = LieAlgebras(QQ).FiniteDimensional().WithBasis().example()
>>> L.an_element().to_vector()
(0, 0, 0)
>>> L.an_element().to_vector(sparse=True)
(0, 0, 0)

>>> # needs sage.combinat sage.groupssage.modules
>>> D = DescentAlgebra(QQ, Integer(4)).D()
>>> L = LieAlgebra(associative=D)
>>> L.an_element().to_vector()
(1, 1, 1, 1, 1, 1, 1, 1)

Nilpotent[source]#
class ParentMethods[source]#

Bases: object

as_finite_dimensional_algebra()[source]#

Return self as a FiniteDimensionalAlgebra.

EXAMPLES:

sage: # needs sage.combinat sage.modules
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

>>> from sage.all import *
>>> # needs sage.combinat sage.modules
>>> L = lie_algebras.cross_product(QQ)
>>> x, y, z = L.basis()
>>> F = L.as_finite_dimensional_algebra()
>>> X, Y, Z = F.basis()
>>> x.bracket(y)
Z
>>> X * Y
Z

casimir_element(order=2, UEA=None, force_generic=False, basis=False)[source]#

Return a Casimir element of order order 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 element

• UEA – (optional) the universal enveloping algebra implementation to return the result in

• force_generic – (default: False) if True for the quadratic order, then this uses the default algorithm; otherwise this is ignored

• basis – (default: False) if True, this returns a basis of all Casimir elements of order order as a list

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: # needs sage.combinat sage.modules
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: # needs sage.combinat sage.modules
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: # needs sage.combinat sage.modules
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: # needs sage.combinat sage.modules
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: # needs sage.combinat sage.modules
sage: L = lie_algebras.Heisenberg(QQ, 2)
sage: L.casimir_element()
0

sage: # needs sage.combinat sage.modules
sage: g = LieAlgebra(QQ, cartan_type=['D',2])
sage: U = g.pbw_basis()
sage: U.casimir_element(2, basis=True)
[2*PBW[alpha[2]]*PBW[-alpha[2]] + 1/2*PBW[alphacheck[2]]^2 - PBW[alphacheck[2]],
2*PBW[alpha[1]]*PBW[-alpha[1]] + 1/2*PBW[alphacheck[1]]^2 - PBW[alphacheck[1]]]

>>> from sage.all import *
>>> # needs sage.combinat sage.modules
>>> L = LieAlgebra(QQ, cartan_type=['A', Integer(1)])
>>> C = L.casimir_element(); C
1/8*b1^2 + 1/2*b0*b2 - 1/4*b1
>>> U = L.universal_enveloping_algebra()
>>> all(g * C == C * g for g in U.gens())
True
>>> U = L.pbw_basis()
>>> 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]]
>>> all(g * C == C * g for g in U.algebra_generators())
True

>>> # needs sage.combinat sage.modules
>>> L = LieAlgebra(QQ, cartan_type=['B', Integer(2)])
>>> U = L.pbw_basis()
>>> C = L.casimir_element(UEA=U)
>>> all(g * C == C * g for g in U.algebra_generators())
True

>>> # needs sage.combinat sage.modules
>>> L = LieAlgebra(QQ, cartan_type=['C', Integer(3)])
>>> U = L.pbw_basis()
>>> C = L.casimir_element(UEA=U)
>>> all(g * C == C * g for g in U.algebra_generators())
True

>>> # needs sage.combinat sage.modules
>>> L = LieAlgebra(QQ, cartan_type=['A', Integer(1)])
>>> C4 = L.casimir_element(order=Integer(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]]
>>> all(g * C4 == C4 * g for g in L.pbw_basis().algebra_generators())
True

>>> # needs sage.combinat sage.modules
>>> L = lie_algebras.Heisenberg(QQ, Integer(2))
>>> L.casimir_element()
0

>>> # needs sage.combinat sage.modules
>>> g = LieAlgebra(QQ, cartan_type=['D',Integer(2)])
>>> U = g.pbw_basis()
>>> U.casimir_element(Integer(2), basis=True)
[2*PBW[alpha[2]]*PBW[-alpha[2]] + 1/2*PBW[alphacheck[2]]^2 - PBW[alphacheck[2]],
2*PBW[alpha[1]]*PBW[-alpha[1]] + 1/2*PBW[alphacheck[1]]^2 - PBW[alphacheck[1]]]


Todo

Use the symmetry of the tensor to reduce the number of equations and/or variables to solve.

center()[source]#

Return the center of self.

EXAMPLES:

sage: # needs sage.combinat sage.modules
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]

>>> from sage.all import *
>>> # needs sage.combinat sage.modules
>>> L = LieAlgebras(QQ).FiniteDimensional().WithBasis().example()
>>> Z = L.center(); Z
An example of a finite dimensional Lie algebra with basis: the
3-dimensional abelian Lie algebra over Rational Field
>>> Z.basis_matrix()
[1 0 0]
[0 1 0]
[0 0 1]

centralizer(S)[source]#

Return the centralizer of S in self.

INPUT:

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

EXAMPLES:

sage: # needs sage.combinat sage.modules
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]

>>> from sage.all import *
>>> # needs sage.combinat sage.modules
>>> L = LieAlgebras(QQ).FiniteDimensional().WithBasis().example()
>>> a, b, c = L.lie_algebra_generators()
>>> S = L.centralizer([a + b, Integer(2)*a + c]); S
An example of a finite dimensional Lie algebra with basis:
the 3-dimensional abelian Lie algebra over Rational Field
>>> S.basis_matrix()
[1 0 0]
[0 1 0]
[0 0 1]

centralizer_basis(S)[source]#

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

EXAMPLES:

sage: # needs sage.combinat sage.modules
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: # needs sage.combinat sage.modules
sage: H = lie_algebras.Heisenberg(QQ, 2)
sage: H.centralizer_basis(H)
[z]

sage: # needs sage.combinat sage.groups sage.modules
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})

sage: scoeffs = {('a','d'): {'a':1}, ('a','e'): {'b':-1},
....:            ('b','d'): {'b':1}, ('b','e'): {'a':1},
....:            ('d','e'): {'c':1}}
sage: L.<a,b,c,d,e> = LieAlgebra(QQ, scoeffs)
sage: L.centralizer_basis([a, c])
[a, b, c]
sage: L.centralizer_basis([a, e])
[c]

>>> from sage.all import *
>>> # needs sage.combinat sage.modules
>>> L = LieAlgebras(QQ).FiniteDimensional().WithBasis().example()
>>> a, b, c = L.lie_algebra_generators()
>>> L.centralizer_basis([a + b, Integer(2)*a + c])
[(1, 0, 0), (0, 1, 0), (0, 0, 1)]

>>> # needs sage.combinat sage.modules
>>> H = lie_algebras.Heisenberg(QQ, Integer(2))
>>> H.centralizer_basis(H)
[z]

>>> # needs sage.combinat sage.groups sage.modules
>>> D = DescentAlgebra(QQ, Integer(4)).D()
>>> L = LieAlgebra(associative=D)
>>> L.centralizer_basis(L)
[D{},
D{1} + D{1, 2} + D{2, 3} + D{3},
D{1, 2, 3} + D{1, 3} + D{2}]
>>> D.center_basis()
(D{},
D{1} + D{1, 2} + D{2, 3} + D{3},
D{1, 2, 3} + D{1, 3} + D{2})

>>> scoeffs = {('a','d'): {'a':Integer(1)}, ('a','e'): {'b':-Integer(1)},
...            ('b','d'): {'b':Integer(1)}, ('b','e'): {'a':Integer(1)},
...            ('d','e'): {'c':Integer(1)}}
>>> L = LieAlgebra(QQ, scoeffs, names=('a', 'b', 'c', 'd', 'e',)); (a, b, c, d, e,) = L._first_ngens(5)
>>> L.centralizer_basis([a, c])
[a, b, c]
>>> L.centralizer_basis([a, e])
[c]

chevalley_eilenberg_complex(M=None, dual=False, sparse=True, ncpus=None)[source]#

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) one of the following:

• a module $$M$$ with an action of self

• a dictionary whose keys are basis elements and values are matrices representing a Lie algebra homomorphism defining the representation

• 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: # needs sage.combinat sage.modules
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: # needs sage.combinat sage.modules
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: # needs sage.combinat sage.modules
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

sage: L.<x,y> = LieAlgebra(QQ, {('x','y'): {'y':1}})
sage: f = ({x: Matrix([[1,0],[0,0]]), y: Matrix([[0,1],[0,0]])})
sage: C = L.chevalley_eilenberg_complex(f); C
Chain complex with at most 3 nonzero terms over Rational Field
sage: ascii_art(C)
[ 0 -1]
[ 2  0]
[1 0 0 1]       [ 0  0]
[0 0 0 0]       [ 0  1]
0 <-- C_0 <---------- C_1 <-------- C_2 <-- 0

sage: ascii_art(L.chevalley_eilenberg_complex(f, sparse=False))
[ 0 -1]
[ 2  0]
[1 0 0 1]       [ 0  0]
[0 0 0 0]       [ 0  1]
0 <-- C_0 <---------- C_1 <-------- C_2 <-- 0

>>> from sage.all import *
>>> # needs sage.combinat sage.modules
>>> L = lie_algebras.sl(ZZ, Integer(2))
>>> C = L.chevalley_eilenberg_complex(); C
Chain complex with at most 4 nonzero terms over Integer Ring
>>> 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

>>> # needs sage.combinat sage.modules
>>> L = LieAlgebra(QQ, cartan_type=['C',Integer(2)])
>>> C = L.chevalley_eilenberg_complex()  # long time
>>> [C.free_module_rank(i) for i in range(Integer(11))]  # long time
[1, 10, 45, 120, 210, 252, 210, 120, 45, 10, 1]

>>> # needs sage.combinat sage.modules
>>> g = lie_algebras.sl(QQ, Integer(2))
>>> E, F, H = g.basis()
>>> n = g.subalgebra([F, H])
>>> ascii_art(n.chevalley_eilenberg_complex())
[ 0]
[0 0]       [-2]
0 <-- C_0 <------ C_1 <----- C_2 <-- 0

>>> L = LieAlgebra(QQ, {('x','y'): {'y':Integer(1)}}, names=('x', 'y',)); (x, y,) = L._first_ngens(2)
>>> f = ({x: Matrix([[Integer(1),Integer(0)],[Integer(0),Integer(0)]]), y: Matrix([[Integer(0),Integer(1)],[Integer(0),Integer(0)]])})
>>> C = L.chevalley_eilenberg_complex(f); C
Chain complex with at most 3 nonzero terms over Rational Field
>>> ascii_art(C)
[ 0 -1]
[ 2  0]
[1 0 0 1]       [ 0  0]
[0 0 0 0]       [ 0  1]
0 <-- C_0 <---------- C_1 <-------- C_2 <-- 0

>>> ascii_art(L.chevalley_eilenberg_complex(f, sparse=False))
[ 0 -1]
[ 2  0]
[1 0 0 1]       [ 0  0]
[0 0 0 0]       [ 0  1]
0 <-- C_0 <---------- C_1 <-------- C_2 <-- 0


REFERENCES:

cohomology(deg=None, M=None, sparse=True, ncpus=None)[source]#

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: # needs sage.combinat sage.modules
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: # needs sage.combinat sage.modules
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: # needs sage.combinat sage.modules
sage: d = {('x', 'y'): {'y': 2}}
sage: L.<x,y> = LieAlgebra(ZZ, d)
sage: L.cohomology()
{0: Z, 1: Z, 2: C2}

>>> from sage.all import *
>>> # needs sage.combinat sage.modules
>>> L = lie_algebras.so(QQ, Integer(4))
>>> 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}

>>> # needs sage.combinat sage.modules
>>> L = lie_algebras.Heisenberg(QQ, Integer(2))
>>> 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}

>>> # needs sage.combinat sage.modules
>>> d = {('x', 'y'): {'y': Integer(2)}}
>>> L = LieAlgebra(ZZ, d, names=('x', 'y',)); (x, y,) = L._first_ngens(2)
>>> L.cohomology()
{0: Z, 1: Z, 2: C2}


REFERENCES:

derivations_basis()[source]#

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: # needs sage.combinat sage.modules
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]
)

>>> from sage.all import *
>>> # needs sage.combinat sage.modules
>>> H = lie_algebras.Heisenberg(QQ, Integer(1))
>>> 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: # needs sage.combinat sage.modules
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]
)

>>> from sage.all import *
>>> # needs sage.combinat sage.modules
>>> sl2 = lie_algebras.sl(QQ, Integer(2))
>>> 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: # needs sage.combinat sage.modules
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

>>> from sage.all import *
>>> # needs sage.combinat sage.modules
>>> D = [sl2.module_morphism(matrix=M, codomain=sl2)
...      for M in sl2.derivations_basis()]
>>> 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()[source]#

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: # needs sage.combinat sage.modules
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: [])

>>> from sage.all import *
>>> # needs sage.combinat sage.modules
>>> L = LieAlgebras(QQ).FiniteDimensional().WithBasis().example()
>>> 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: # needs sage.combinat sage.modules
sage: L.<x,y> = LieAlgebra(QQ, {('x','y'): {'x':1}})
sage: L.derived_series()
(Lie algebra on 2 generators (x, y) over Rational Field,
Ideal (x) of Lie algebra on 2 generators (x, y) over Rational Field,
Ideal () of Lie algebra on 2 generators (x, y) over Rational Field)

sage: scoeffs = {('a','d'): {'a':1}, ('a','e'): {'b':-1},
....:            ('b','d'): {'b':1}, ('b','e'): {'a':1},
....:            ('d','e'): {'c':1}}
sage: L.<a,b,c,d,e> = LieAlgebra(QQ, scoeffs)
sage: L.derived_series()
(Lie algebra on 5 generators (a, b, c, d, e) over Rational Field,
Ideal (a, b, c) of Lie algebra on 5 generators (a, b, c, d, e) over Rational Field,
Ideal () of Lie algebra on 5 generators (a, b, c, d, e) over Rational Field)

>>> from sage.all import *
>>> # needs sage.combinat sage.modules
>>> L = LieAlgebra(QQ, {('x','y'): {'x':Integer(1)}}, names=('x', 'y',)); (x, y,) = L._first_ngens(2)
>>> L.derived_series()
(Lie algebra on 2 generators (x, y) over Rational Field,
Ideal (x) of Lie algebra on 2 generators (x, y) over Rational Field,
Ideal () of Lie algebra on 2 generators (x, y) over Rational Field)

>>> scoeffs = {('a','d'): {'a':Integer(1)}, ('a','e'): {'b':-Integer(1)},
...            ('b','d'): {'b':Integer(1)}, ('b','e'): {'a':Integer(1)},
...            ('d','e'): {'c':Integer(1)}}
>>> L = LieAlgebra(QQ, scoeffs, names=('a', 'b', 'c', 'd', 'e',)); (a, b, c, d, e,) = L._first_ngens(5)
>>> L.derived_series()
(Lie algebra on 5 generators (a, b, c, d, e) over Rational Field,
Ideal (a, b, c) of Lie algebra on 5 generators (a, b, c, d, e) over Rational Field,
Ideal () of Lie algebra on 5 generators (a, b, c, d, e) over Rational Field)

derived_subalgebra()[source]#

Return the derived subalgebra of self.

EXAMPLES:

sage: # needs sage.combinat sage.modules
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:
[]

>>> from sage.all import *
>>> # needs sage.combinat sage.modules
>>> L = LieAlgebras(QQ).FiniteDimensional().WithBasis().example()
>>> 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: # needs sage.combinat sage.modules
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 sage.all import *
>>> # needs sage.combinat sage.modules
>>> sl3 = LieAlgebra(QQ, cartan_type=['A', Integer(2)])
>>> sl3.derived_subalgebra()
Lie algebra of ['A', 2] in the Chevalley basis
>>> sl3 is sl3.derived_subalgebra()
True

faithful_representation(algorithm=None)[source]#

Return a faithful representation of self.

By Ado’s and Iwasawa’s theorems, every finite dimensional Lie algebra has a faithful finite dimensional representation.

INPUT:

• algorithm – one of the following depending on the classification of the Lie algebra:

Nilpotent:

Solvable:

• Not implemented

Semisimple:

• Not implemented

General case

• 'generic' – generic algortihm (only implemented currently for positive characteristic)

Note that the algorithm for any more generic cases can be used in the specialized cases. For instance, using 'generic' for any Lie algebra (e.g., even if nilpotent) will use the generic implementation.

EXAMPLES:

sage: H2 = lie_algebras.Heisenberg(QQ, 2)
sage: H2.is_nilpotent()
True
sage: F = H2.faithful_representation(); F
Faithful 16 dimensional representation of
Heisenberg algebra of rank 2 over Rational Field
sage: M = H2.faithful_representation(algorithm="minimal"); M
Minimal faithful representation of
Heisenberg algebra of rank 2 over Rational Field
sage: M.dimension()
4
sage: H2.faithful_representation(algorithm="invalid")
Traceback (most recent call last):
...
ValueError: invalid algorithm 'invalid'

sage: scoeffs = {('a','d'): {'a':1}, ('a','e'): {'b':-1},
....:            ('b','d'): {'b':1}, ('b','e'): {'a':1},
....:            ('d','e'): {'c':1}}
sage: L.<a,b,c,d,e> = LieAlgebra(QQ, scoeffs)
sage: L.is_nilpotent()
False
sage: L.is_solvable()
True
sage: L.faithful_representation()
Traceback (most recent call last):
...
NotImplementedError: only implemented for nilpotent Lie algebras

sage: sl3 = LieAlgebra(QQ, cartan_type=['A', 2])
sage: sl3.is_semisimple()
True
sage: sl3.faithful_representation()
Traceback (most recent call last):
...
NotImplementedError: only implemented for nilpotent Lie algebras

>>> from sage.all import *
>>> H2 = lie_algebras.Heisenberg(QQ, Integer(2))
>>> H2.is_nilpotent()
True
>>> F = H2.faithful_representation(); F
Faithful 16 dimensional representation of
Heisenberg algebra of rank 2 over Rational Field
>>> M = H2.faithful_representation(algorithm="minimal"); M
Minimal faithful representation of
Heisenberg algebra of rank 2 over Rational Field
>>> M.dimension()
4
>>> H2.faithful_representation(algorithm="invalid")
Traceback (most recent call last):
...
ValueError: invalid algorithm 'invalid'

>>> scoeffs = {('a','d'): {'a':Integer(1)}, ('a','e'): {'b':-Integer(1)},
...            ('b','d'): {'b':Integer(1)}, ('b','e'): {'a':Integer(1)},
...            ('d','e'): {'c':Integer(1)}}
>>> L = LieAlgebra(QQ, scoeffs, names=('a', 'b', 'c', 'd', 'e',)); (a, b, c, d, e,) = L._first_ngens(5)
>>> L.is_nilpotent()
False
>>> L.is_solvable()
True
>>> L.faithful_representation()
Traceback (most recent call last):
...
NotImplementedError: only implemented for nilpotent Lie algebras

>>> sl3 = LieAlgebra(QQ, cartan_type=['A', Integer(2)])
>>> sl3.is_semisimple()
True
>>> sl3.faithful_representation()
Traceback (most recent call last):
...
NotImplementedError: only implemented for nilpotent Lie algebras

from_vector(v, order=None)[source]#

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()     # needs sage.modules
sage: u = L.from_vector(vector(QQ, (1, 0, 0))); u                       # needs sage.modules
(1, 0, 0)
sage: parent(u) is L                                                    # needs sage.modules
True

>>> from sage.all import *
>>> L = LieAlgebras(QQ).FiniteDimensional().WithBasis().example()     # needs sage.modules
>>> u = L.from_vector(vector(QQ, (Integer(1), Integer(0), Integer(0)))); u                       # needs sage.modules
(1, 0, 0)
>>> parent(u) is L                                                    # needs sage.modules
True

homology(deg=None, M=None, sparse=True, ncpus=None)[source]#

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: # needs sage.combinat sage.modules
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: # needs sage.combinat sage.modules
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: # needs sage.combinat sage.modules
sage: d = {('x', 'y'): {'y': 2}}
sage: L.<x,y> = LieAlgebra(ZZ, d)
sage: L.homology()
{0: Z, 1: Z x C2, 2: 0}

>>> from sage.all import *
>>> # needs sage.combinat sage.modules
>>> L = lie_algebras.cross_product(QQ)
>>> 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}

>>> # needs sage.combinat sage.modules
>>> L = lie_algebras.pwitt(GF(Integer(5)), Integer(5))
>>> 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}

>>> # needs sage.combinat sage.modules
>>> d = {('x', 'y'): {'y': Integer(2)}}
>>> L = LieAlgebra(ZZ, d, names=('x', 'y',)); (x, y,) = L._first_ngens(2)
>>> L.homology()
{0: Z, 1: Z x C2, 2: 0}

hypercenter()[source]#

Return the hypercenter of self.

EXAMPLES:

sage: SGA3 = SymmetricGroup(3).algebra(QQ)
sage: L = LieAlgebra(associative=SGA3)
sage: L.hypercenter()
Ideal ((), (1,2,3) + (1,3,2), (2,3) + (1,2) + (1,3)) of
Lie algebra of Symmetric group algebra of order 3
over Rational Field

sage: L = lie_algebras.Heisenberg(QQ, 3)
sage: L.hypercenter()
Heisenberg algebra of rank 3 over Rational Field

>>> from sage.all import *
>>> SGA3 = SymmetricGroup(Integer(3)).algebra(QQ)
>>> L = LieAlgebra(associative=SGA3)
>>> L.hypercenter()
Ideal ((), (1,2,3) + (1,3,2), (2,3) + (1,2) + (1,3)) of
Lie algebra of Symmetric group algebra of order 3
over Rational Field

>>> L = lie_algebras.Heisenberg(QQ, Integer(3))
>>> L.hypercenter()
Heisenberg algebra of rank 3 over Rational Field

ideal(*gens, **kwds)[source]#

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: # needs sage.combinat sage.modules
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

>>> from sage.all import *
>>> # needs sage.combinat sage.modules
>>> H = lie_algebras.Heisenberg(QQ, Integer(2))
>>> p1,p2,q1,q2,z = H.basis()
>>> I = H.ideal([p1 - p2, q1 - q2])
>>> I.basis().list()
[-p1 + p2, -q1 + q2, z]
>>> I.reduce(p1 + p2 + q1 + q2 + z)
2*p1 + 2*q1


Passing an extra category to an ideal:

sage: # needs sage.combinat sage.modules
sage: L.<x,y,z> = LieAlgebra(QQ, abelian=True)
sage: C = LieAlgebras(QQ).FiniteDimensional().WithBasis()
sage: I = L.ideal(x, y, category=C)
sage: I.homogeneous_component_basis(1).list()
[x, y]

>>> from sage.all import *
>>> # needs sage.combinat sage.modules
>>> L = LieAlgebra(QQ, abelian=True, names=('x', 'y', 'z',)); (x, y, z,) = L._first_ngens(3)
>>> C = LieAlgebras(QQ).FiniteDimensional().WithBasis()
>>> I = L.ideal(x, y, category=C)
>>> I.homogeneous_component_basis(Integer(1)).list()
[x, y]

inner_derivations_basis()[source]#

Return a basis for the Lie algebra of inner derivations of self as matrices.

EXAMPLES:

sage: # needs sage.combinat sage.modules
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]
)

>>> from sage.all import *
>>> # needs sage.combinat sage.modules
>>> H = lie_algebras.Heisenberg(QQ, Integer(1))
>>> H.inner_derivations_basis()
(
[0 0 0]  [0 0 0]
[0 0 0]  [0 0 0]
[1 0 0], [0 1 0]
)

is_abelian()[source]#

Return if self is an abelian Lie algebra.

EXAMPLES:

sage: # needs sage.combinat sage.modules
sage: L = LieAlgebras(QQ).FiniteDimensional().WithBasis().example()
sage: L.is_abelian()
True

>>> from sage.all import *
>>> # needs sage.combinat sage.modules
>>> L = LieAlgebras(QQ).FiniteDimensional().WithBasis().example()
>>> L.is_abelian()
True

sage: # needs sage.combinat sage.modules
sage: L.<x,y> = LieAlgebra(QQ, {('x','y'): {'x':1}})
sage: L.is_abelian()
False

>>> from sage.all import *
>>> # needs sage.combinat sage.modules
>>> L = LieAlgebra(QQ, {('x','y'): {'x':Integer(1)}}, names=('x', 'y',)); (x, y,) = L._first_ngens(2)
>>> L.is_abelian()
False

is_ideal(A)[source]#

Return if self is an ideal of A.

EXAMPLES:

sage: # needs sage.combinat sage.modules
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}})                     # needs sage.combinat sage.modules
sage: L.is_ideal(L)                                                     # needs sage.combinat sage.modules
True

sage: F = LieAlgebra(QQ, 'F', representation='polynomial')              # needs sage.combinat sage.modules
sage: L.is_ideal(F)                                                     # needs sage.combinat sage.modules
Traceback (most recent call last):
...
NotImplementedError: A must be a finite dimensional Lie algebra
with basis

>>> from sage.all import *
>>> # needs sage.combinat sage.modules
>>> L = LieAlgebras(QQ).FiniteDimensional().WithBasis().example()
>>> a, b, c = L.lie_algebra_generators()
>>> I = L.ideal([Integer(2)*a - c, b + c])
>>> I.is_ideal(L)
True

>>> L = LieAlgebra(QQ, {('x','y'):{'x':Integer(1)}}, names=('x', 'y',)); (x, y,) = L._first_ngens(2)# needs sage.combinat sage.modules
>>> L.is_ideal(L)                                                     # needs sage.combinat sage.modules
True

>>> F = LieAlgebra(QQ, 'F', representation='polynomial')              # needs sage.combinat sage.modules
>>> L.is_ideal(F)                                                     # needs sage.combinat sage.modules
Traceback (most recent call last):
...
NotImplementedError: A must be a finite dimensional Lie algebra
with basis

is_nilpotent()[source]#

Return if self is a nilpotent Lie algebra.

A Lie algebra is nilpotent if the lower central series eventually becomes $$0$$.

EXAMPLES:

sage: # needs sage.combinat sage.modules
sage: L = LieAlgebras(QQ).FiniteDimensional().WithBasis().example()
sage: L.is_nilpotent()
True

>>> from sage.all import *
>>> # needs sage.combinat sage.modules
>>> L = LieAlgebras(QQ).FiniteDimensional().WithBasis().example()
>>> L.is_nilpotent()
True

is_semisimple()[source]#

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: # needs sage.combinat sage.modules
sage: L = LieAlgebras(QQ).FiniteDimensional().WithBasis().example()
sage: L.is_semisimple()
False

>>> from sage.all import *
>>> # needs sage.combinat sage.modules
>>> L = LieAlgebras(QQ).FiniteDimensional().WithBasis().example()
>>> L.is_semisimple()
False


Positive characteristic examples:

sage: L.<x,y,z> = LieAlgebra(GF(3), {('x','z'): {'x':1, 'y':1}, ('y','z'): {'y':1}})
sage: L.is_semisimple()
False

sage: sp4 = LieAlgebra(GF(3), cartan_type=['C',2])
sage: sp4.killing_form_matrix().det()
0
()
sage: sp4.is_semisimple()  # long time
True

>>> from sage.all import *
>>> L = LieAlgebra(GF(Integer(3)), {('x','z'): {'x':Integer(1), 'y':Integer(1)}, ('y','z'): {'y':Integer(1)}}, names=('x', 'y', 'z',)); (x, y, z,) = L._first_ngens(3)
>>> L.is_semisimple()
False

>>> sp4 = LieAlgebra(GF(Integer(3)), cartan_type=['C',Integer(2)])
>>> sp4.killing_form_matrix().det()
0
()
>>> sp4.is_semisimple()  # long time
True

is_solvable()[source]#

Return if self is a solvable Lie algebra.

A Lie algebra is solvable if the derived series eventually becomes $$0$$.

EXAMPLES:

sage: # needs sage.combinat sage.modules
sage: L = LieAlgebras(QQ).FiniteDimensional().WithBasis().example()
sage: L.is_solvable()
True

>>> from sage.all import *
>>> # needs sage.combinat sage.modules
>>> L = LieAlgebras(QQ).FiniteDimensional().WithBasis().example()
>>> L.is_solvable()
True

sage: # needs sage.combinat sage.modules
sage: L.<x,y> = LieAlgebra(QQ, {('x','y'): {'x':1}})
sage: L.is_solvable()           # not implemented
False

>>> from sage.all import *
>>> # needs sage.combinat sage.modules
>>> L = LieAlgebra(QQ, {('x','y'): {'x':Integer(1)}}, names=('x', 'y',)); (x, y,) = L._first_ngens(2)
>>> L.is_solvable()           # not implemented
False

killing_form(x, y)[source]#

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()     # needs sage.modules
sage: a, b, c = L.lie_algebra_generators()                              # needs sage.modules
sage: L.killing_form(a, b)                                              # needs sage.modules
0

>>> from sage.all import *
>>> L = LieAlgebras(QQ).FiniteDimensional().WithBasis().example()     # needs sage.modules
>>> a, b, c = L.lie_algebra_generators()                              # needs sage.modules
>>> L.killing_form(a, b)                                              # needs sage.modules
0

killing_form_matrix()[source]#

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: # needs sage.modules
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

>>> from sage.all import *
>>> # needs sage.modules
>>> L = LieAlgebras(QQ).FiniteDimensional().WithBasis().example()
>>> L.killing_form_matrix()
[0 0 0]
[0 0 0]
[0 0 0]
>>> L = LieAlgebras(QQ).FiniteDimensional().WithBasis().example(Integer(0))
>>> m = L.killing_form_matrix(); m
[]
>>> parent(m)
Full MatrixSpace of 0 by 0 dense matrices over Rational Field

killing_matrix(x, y)[source]#

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()     # needs sage.modules
sage: a, b, c = L.lie_algebra_generators()                              # needs sage.modules
sage: L.killing_matrix(a, b)                                            # needs sage.modules
[0 0 0]
[0 0 0]
[0 0 0]

>>> from sage.all import *
>>> L = LieAlgebras(QQ).FiniteDimensional().WithBasis().example()     # needs sage.modules
>>> a, b, c = L.lie_algebra_generators()                              # needs sage.modules
>>> L.killing_matrix(a, b)                                            # needs sage.modules
[0 0 0]
[0 0 0]
[0 0 0]

sage: L.<x,y> = LieAlgebra(QQ, {('x','y'): {'x':1}})                    # needs sage.combinat sage.modules
sage: L.killing_matrix(y, x)                                            # needs sage.combinat sage.modules
[ 0 -1]
[ 0  0]

>>> from sage.all import *
>>> L = LieAlgebra(QQ, {('x','y'): {'x':Integer(1)}}, names=('x', 'y',)); (x, y,) = L._first_ngens(2)# needs sage.combinat sage.modules
>>> L.killing_matrix(y, x)                                            # needs sage.combinat sage.modules
[ 0 -1]
[ 0  0]

lower_central_series(submodule=False)[source]#

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 \Bigl[\bigl[ [\mathfrak{g}, \mathfrak{g}], \mathfrak{g} \bigr], \mathfrak{g}\Bigr] \supseteq \cdots.$

EXAMPLES:

sage: # needs sage.combinat sage.modules
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: [])

>>> from sage.all import *
>>> # needs sage.combinat sage.modules
>>> L = LieAlgebras(QQ).FiniteDimensional().WithBasis().example()
>>> 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: # needs sage.combinat sage.modules
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])

>>> from sage.all import *
>>> # needs sage.combinat sage.modules
>>> L = LieAlgebra(QQ, {('x','y'): {'x':Integer(1)}}, names=('x', 'y',)); (x, y,) = L._first_ngens(2)
>>> 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: # needs sage.combinat sage.modules
sage: L.<x,y> = LieAlgebra(QQ, {('x','y'): {'x':1}})
sage: L.lower_central_series()
(Lie algebra on 2 generators (x, y) over Rational Field,
Ideal (x) of Lie algebra on 2 generators (x, y) over Rational Field)

sage: scoeffs = {('a','d'): {'a':1}, ('a','e'): {'b':-1},
....:            ('b','d'): {'b':1}, ('b','e'): {'a':1},
....:            ('d','e'): {'c':1}}
sage: L.<a,b,c,d,e> = LieAlgebra(QQ, scoeffs)
sage: L.lower_central_series()
(Lie algebra on 5 generators (a, b, c, d, e) over Rational Field,
Ideal (a, b, c) of Lie algebra on 5 generators (a, b, c, d, e) over Rational Field,
Ideal (a, b) of Lie algebra on 5 generators (a, b, c, d, e) over Rational Field)

>>> from sage.all import *
>>> # needs sage.combinat sage.modules
>>> L = LieAlgebra(QQ, {('x','y'): {'x':Integer(1)}}, names=('x', 'y',)); (x, y,) = L._first_ngens(2)
>>> L.lower_central_series()
(Lie algebra on 2 generators (x, y) over Rational Field,
Ideal (x) of Lie algebra on 2 generators (x, y) over Rational Field)

>>> scoeffs = {('a','d'): {'a':Integer(1)}, ('a','e'): {'b':-Integer(1)},
...            ('b','d'): {'b':Integer(1)}, ('b','e'): {'a':Integer(1)},
...            ('d','e'): {'c':Integer(1)}}
>>> L = LieAlgebra(QQ, scoeffs, names=('a', 'b', 'c', 'd', 'e',)); (a, b, c, d, e,) = L._first_ngens(5)
>>> L.lower_central_series()
(Lie algebra on 5 generators (a, b, c, d, e) over Rational Field,
Ideal (a, b, c) of Lie algebra on 5 generators (a, b, c, d, e) over Rational Field,
Ideal (a, b) of Lie algebra on 5 generators (a, b, c, d, e) over Rational Field)

module(R=None)[source]#

Return a dense free module associated to self over R.

EXAMPLES:

sage: L = LieAlgebras(QQ).FiniteDimensional().WithBasis().example()     # needs sage.modules
sage: L._dense_free_module()                                            # needs sage.modules
Vector space of dimension 3 over Rational Field

>>> from sage.all import *
>>> L = LieAlgebras(QQ).FiniteDimensional().WithBasis().example()     # needs sage.modules
>>> L._dense_free_module()                                            # needs sage.modules
Vector space of dimension 3 over Rational Field

morphism(on_generators, codomain=None, base_map=None, check=True)[source]#

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.

EXAMPLES:

A quotient type Lie algebra morphism

sage: # needs sage.combinat sage.modules
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

>>> from sage.all import *
>>> # needs sage.combinat sage.modules
>>> L = LieAlgebra(QQ, {('X','Y'): {'Z': Integer(1)},
...                               ('X','Z'): {'W': Integer(1)}}, names=('X', 'Y', 'Z', 'W',)); (X, Y, Z, W,) = L._first_ngens(4)
>>> K = LieAlgebra(QQ, abelian=True, names=('A', 'B',)); (A, B,) = K._first_ngens(2)
>>> 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: # needs sage.combinat sage.modules
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

>>> from sage.all import *
>>> # needs sage.combinat sage.modules
>>> 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: # needs sage.combinat sage.modules sage.rings.number_fields
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

>>> from sage.all import *
>>> # needs sage.combinat sage.modules sage.rings.number_fields
>>> R = ZZ['x']; (x,) = R._first_ngens(1)
>>> K = NumberField(x**Integer(2) + Integer(1), names=('i',)); (i,) = K._first_ngens(1)
>>> cc = K.hom([-i])
>>> L = LieAlgebra(K, {('X','Y'): {'Z': Integer(1)},
...                              ('X','Z'): {'W': Integer(1)}}, names=('X', 'Y', 'Z', 'W',)); (X, Y, Z, W,) = L._first_ngens(4)
>>> M = LieAlgebra(K, abelian=True, names=('A', 'B',)); (A, B,) = M._first_ngens(2)
>>> phi = L.morphism({X: A, Y: B}, base_map=cc)
>>> phi(X)
A
>>> phi(i*X)
-i*A


Return the nilradical of self.

The nilradical of a Lie algebra $$L$$ is the largest nilpotent ideal of $$L$$.

EXAMPLES:

sage: scoeffs = {('a','d'): {'a':1}, ('a','e'): {'b':-1},
....:            ('b','d'): {'b':1}, ('b','e'): {'a':1},
....:            ('d','e'): {'c':1}}
sage: L.<a,b,c,d,e> = LieAlgebra(QQ, scoeffs)
Ideal (a, b, c, d, e) of
Lie algebra on 5 generators (a, b, c, d, e) over Rational Field

>>> from sage.all import *
>>> scoeffs = {('a','d'): {'a':Integer(1)}, ('a','e'): {'b':-Integer(1)},
...            ('b','d'): {'b':Integer(1)}, ('b','e'): {'a':Integer(1)},
...            ('d','e'): {'c':Integer(1)}}
>>> L = LieAlgebra(QQ, scoeffs, names=('a', 'b', 'c', 'd', 'e',)); (a, b, c, d, e,) = L._first_ngens(5)
Ideal (a, b, c, d, e) of
Lie algebra on 5 generators (a, b, c, d, e) over Rational Field


Return a basis of the nilradical of self.

EXAMPLES:

sage: scoeffs = {('a','d'): {'a':1}, ('a','e'): {'b':-1},
....:            ('b','d'): {'b':1}, ('b','e'): {'a':1},
....:            ('d','e'): {'c':1}}
sage: L.<a,b,c,d,e> = LieAlgebra(QQ, scoeffs)
(a, b, c)
sage: L.is_nilpotent()
False

sage: sl3 = LieAlgebra(QQ, cartan_type=['A',2])
()

sage: scoeffs = {('a','e'): {'a':1}, ('b','e'): {'a':1,'b':1},
....:            ('c','d'): {'a':1}, ('c','e'): {'c':1}}
sage: L.<a,b,c,d,e> = LieAlgebra(QQ, scoeffs)
(a, b, c, d)
sage: L.is_solvable()
True
sage: L.is_nilpotent()
False

sage: K1 = L.quotient([a])
(b, c, d)

sage: SL = L.subalgebra([a,b,c,d]); SL
Subalgebra generated by (a, b, c, d) of
Lie algebra on 5 generators (a, b, c, d, e) over Rational Field
(a, b, c, d)

sage: scoeffs = {('x','z'): {'x':1, 'y':1}, ('y','z'): {'y':1}}
sage: L.<x,y,z> = LieAlgebra(GF(3), scoeffs)
(x, y)

>>> from sage.all import *
>>> scoeffs = {('a','d'): {'a':Integer(1)}, ('a','e'): {'b':-Integer(1)},
...            ('b','d'): {'b':Integer(1)}, ('b','e'): {'a':Integer(1)},
...            ('d','e'): {'c':Integer(1)}}
>>> L = LieAlgebra(QQ, scoeffs, names=('a', 'b', 'c', 'd', 'e',)); (a, b, c, d, e,) = L._first_ngens(5)
(a, b, c)
>>> L.is_nilpotent()
False

>>> sl3 = LieAlgebra(QQ, cartan_type=['A',Integer(2)])
()

>>> scoeffs = {('a','e'): {'a':Integer(1)}, ('b','e'): {'a':Integer(1),'b':Integer(1)},
...            ('c','d'): {'a':Integer(1)}, ('c','e'): {'c':Integer(1)}}
>>> L = LieAlgebra(QQ, scoeffs, names=('a', 'b', 'c', 'd', 'e',)); (a, b, c, d, e,) = L._first_ngens(5)
(a, b, c, d)
>>> L.is_solvable()
True
>>> L.is_nilpotent()
False

>>> K1 = L.quotient([a])
(b, c, d)

>>> SL = L.subalgebra([a,b,c,d]); SL
Subalgebra generated by (a, b, c, d) of
Lie algebra on 5 generators (a, b, c, d, e) over Rational Field
(a, b, c, d)

>>> scoeffs = {('x','z'): {'x':Integer(1), 'y':Integer(1)}, ('y','z'): {'y':Integer(1)}}
>>> L = LieAlgebra(GF(Integer(3)), scoeffs, names=('x', 'y', 'z',)); (x, y, z,) = L._first_ngens(3)
(x, y)


We check against the generic algorithm:

sage: L.<x,y,z> = LieAlgebra(QQ, {('x','z'): {'x':1,'y':1}, ('y','z'): {'y':1}})
(x, y)

sage: dim = L.dimension()
sage: MS = MatrixSpace(L.base_ring(), dim)
sage: gens = [b.adjoint_matrix() for b in L.basis()]
sage: A = MS.subalgebra(gens)
sage: mat = matrix(L.base_ring(),
....:              [g._vector_() for g in gens]
....:              + [A.lift(r)._vector_() for r in RB])
sage: tuple([L.from_vector(w) for v in mat.right_kernel().basis()
....:               if (w := v[:dim])])
(x, y)

>>> from sage.all import *
>>> L = LieAlgebra(QQ, {('x','z'): {'x':Integer(1),'y':Integer(1)}, ('y','z'): {'y':Integer(1)}}, names=('x', 'y', 'z',)); (x, y, z,) = L._first_ngens(3)
(x, y)

>>> dim = L.dimension()
>>> MS = MatrixSpace(L.base_ring(), dim)
>>> gens = [b.adjoint_matrix() for b in L.basis()]
>>> A = MS.subalgebra(gens)
>>> mat = matrix(L.base_ring(),
...              [g._vector_() for g in gens]
...              + [A.lift(r)._vector_() for r in RB])
>>> tuple([L.from_vector(w) for v in mat.right_kernel().basis()
...               if (w := v[:dim])])
(x, y)


A positive characteristic example:

sage: scoeffs = {('x','z'): {'x':1,'y':1}, ('y','z'): {'y':1}}
sage: L.<x,y,z> = LieAlgebra(GF(3), scoeffs)
(x, y)

>>> from sage.all import *
>>> scoeffs = {('x','z'): {'x':Integer(1),'y':Integer(1)}, ('y','z'): {'y':Integer(1)}}
>>> L = LieAlgebra(GF(Integer(3)), scoeffs, names=('x', 'y', 'z',)); (x, y, z,) = L._first_ngens(3)
(x, y)

normalizer(S)[source]#

Return the normalizer of S in self.

INPUT:

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

EXAMPLES:

sage: scoeffs = {('a','d'): {'a':1}, ('a','e'): {'b':-1},
....:            ('b','d'): {'b':1}, ('b','e'): {'a':1},
....:            ('d','e'): {'c':1}}
sage: L.<a,b,c,d,e> = LieAlgebra(QQ, scoeffs)
sage: L.normalizer([a, e])
Subalgebra generated by (b, c) of Lie algebra on
5 generators (a, b, c, d, e) over Rational Field
sage: L.normalizer([a, c, e])
Subalgebra generated by (b, c, d) of Lie algebra on
5 generators (a, b, c, d, e) over Rational Field

>>> from sage.all import *
>>> scoeffs = {('a','d'): {'a':Integer(1)}, ('a','e'): {'b':-Integer(1)},
...            ('b','d'): {'b':Integer(1)}, ('b','e'): {'a':Integer(1)},
...            ('d','e'): {'c':Integer(1)}}
>>> L = LieAlgebra(QQ, scoeffs, names=('a', 'b', 'c', 'd', 'e',)); (a, b, c, d, e,) = L._first_ngens(5)
>>> L.normalizer([a, e])
Subalgebra generated by (b, c) of Lie algebra on
5 generators (a, b, c, d, e) over Rational Field
>>> L.normalizer([a, c, e])
Subalgebra generated by (b, c, d) of Lie algebra on
5 generators (a, b, c, d, e) over Rational Field

normalizer_basis(S)[source]#

Return a basis of the normalizer of S in self.

INPUT:

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

EXAMPLES:

sage: scoeffs = {('a','d'): {'a':1}, ('a','e'): {'b':-1},
....:            ('b','d'): {'b':1}, ('b','e'): {'a':1},
....:            ('d','e'): {'c':1}}
sage: L.<a,b,c,d,e> = LieAlgebra(QQ, scoeffs)
sage: L.normalizer_basis([a, e])
[b, c]

sage: S = L.subalgebra([a, e])
sage: L.normalizer_basis(S)
[a, b, c, e]

>>> from sage.all import *
>>> scoeffs = {('a','d'): {'a':Integer(1)}, ('a','e'): {'b':-Integer(1)},
...            ('b','d'): {'b':Integer(1)}, ('b','e'): {'a':Integer(1)},
...            ('d','e'): {'c':Integer(1)}}
>>> L = LieAlgebra(QQ, scoeffs, names=('a', 'b', 'c', 'd', 'e',)); (a, b, c, d, e,) = L._first_ngens(5)
>>> L.normalizer_basis([a, e])
[b, c]

>>> S = L.subalgebra([a, e])
>>> L.normalizer_basis(S)
[a, b, c, e]


When the subalgebra is the ambient Lie algebra, we return the basis of the ambient Lie algebra:

sage: L.normalizer_basis(L)
Finite family {'a': a, 'b': b, 'c': c, 'd': d, 'e': e}
sage: L.normalizer_basis([a, b, c, a, d + e, a + e])
Finite family {'a': a, 'b': b, 'c': c, 'd': d, 'e': e}

>>> from sage.all import *
>>> L.normalizer_basis(L)
Finite family {'a': a, 'b': b, 'c': c, 'd': d, 'e': e}
>>> L.normalizer_basis([a, b, c, a, d + e, a + e])
Finite family {'a': a, 'b': b, 'c': c, 'd': d, 'e': e}

product_space(L, submodule=False)[source]#

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: # needs sage.combinat sage.modules
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: []

>>> from sage.all import *
>>> # needs sage.combinat sage.modules
>>> L = LieAlgebras(QQ).FiniteDimensional().WithBasis().example()
>>> a,b,c = L.lie_algebra_generators()
>>> X = L.subalgebra([a, b + c])
>>> 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: []
>>> Y = L.subalgebra([a, Integer(2)*b - c])
>>> 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: # needs sage.combinat sage.modules
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]

>>> from sage.all import *
>>> # needs sage.combinat sage.modules
>>> H = lie_algebras.Heisenberg(ZZ, Integer(4))
>>> Hp = H.product_space(H, submodule=True).basis()
>>> [H.from_vector(v) for v in Hp]
[z]

sage: # needs sage.combinat sage.modules
sage: L.<x,y> = LieAlgebra(QQ, {('x','y'):{'x':1}})
sage: Lp = L.product_space(L)   # not implemented
sage: Lp                        # not implemented
Subalgebra generated of
Lie algebra on 2 generators (x, y) over Rational Field
with basis: (x,)
sage: Lp.product_space(L)       # not implemented
Subalgebra generated of
Lie algebra on 2 generators (x, y) over Rational Field
with basis: (x,)
sage: L.product_space(Lp)       # not implemented
Subalgebra generated of
Lie algebra on 2 generators (x, y) over Rational Field
with basis: (x,)
sage: Lp.product_space(Lp)      # not implemented
Subalgebra generated of
Lie algebra on 2 generators (x, y) over Rational Field
with basis: ()

>>> from sage.all import *
>>> # needs sage.combinat sage.modules
>>> L = LieAlgebra(QQ, {('x','y'):{'x':Integer(1)}}, names=('x', 'y',)); (x, y,) = L._first_ngens(2)
>>> Lp = L.product_space(L)   # not implemented
>>> Lp                        # not implemented
Subalgebra generated of
Lie algebra on 2 generators (x, y) over Rational Field
with basis: (x,)
>>> Lp.product_space(L)       # not implemented
Subalgebra generated of
Lie algebra on 2 generators (x, y) over Rational Field
with basis: (x,)
>>> L.product_space(Lp)       # not implemented
Subalgebra generated of
Lie algebra on 2 generators (x, y) over Rational Field
with basis: (x,)
>>> Lp.product_space(Lp)      # not implemented
Subalgebra generated of
Lie algebra on 2 generators (x, y) over Rational Field
with basis: ()

quotient(I, names=None, category=None)[source]#

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: # needs sage.combinat sage.modules
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

>>> from sage.all import *
>>> # needs sage.combinat sage.modules
>>> L = LieAlgebra(QQ, Integer(2), step=Integer(3), names=('X', 'Y', 'Z', 'W', 'U',)); (X, Y, Z, W, U,) = L._first_ngens(5)
>>> 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)
>>> E.basis().list()
[X, Y, Z, W]
>>> E(X).bracket(E(Y))
Z
>>> Y.bracket(Z)
-U
>>> E(Y).bracket(E(Z))
0
>>> E(U)
0


Quotients when the base ring is not a field are not implemented:

sage: # needs sage.combinat sage.modules
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

>>> from sage.all import *
>>> # needs sage.combinat sage.modules
>>> L = lie_algebras.Heisenberg(ZZ, Integer(1))
>>> L.quotient(L.an_element())
Traceback (most recent call last):
...
NotImplementedError: quotients over non-fields not implemented


Return the solvable radical of self.

The solvable radical of a Lie algebra $$L$$ is the largest solvable ideal of $$L$$.

EXAMPLES:

sage: scoeffs = {('a','d'): {'a':1}, ('a','e'): {'b':-1},
....:            ('b','d'): {'b':1}, ('b','e'): {'a':1},
....:            ('d','e'): {'c':1}}
sage: L.<a,b,c,d,e> = LieAlgebra(QQ, scoeffs)
Ideal (a, b, c, d, e) of Lie algebra on 5 generators (a, b, c, d, e) over Rational Field

>>> from sage.all import *
>>> scoeffs = {('a','d'): {'a':Integer(1)}, ('a','e'): {'b':-Integer(1)},
...            ('b','d'): {'b':Integer(1)}, ('b','e'): {'a':Integer(1)},
...            ('d','e'): {'c':Integer(1)}}
>>> L = LieAlgebra(QQ, scoeffs, names=('a', 'b', 'c', 'd', 'e',)); (a, b, c, d, e,) = L._first_ngens(5)
Ideal (a, b, c, d, e) of Lie algebra on 5 generators (a, b, c, d, e) over Rational Field


Return a basis of the solvable radical of self.

EXAMPLES:

sage: scoeffs = {('a','d'): {'a':1}, ('a','e'): {'b':-1},
....:            ('b','d'): {'b':1}, ('b','e'): {'a':1},
....:            ('d','e'): {'c':1}}
sage: L.<a,b,c,d,e> = LieAlgebra(QQ, scoeffs)
(a, b, c, d, e)
sage: L.is_solvable()
True

sage: sl3 = LieAlgebra(QQ, cartan_type=['A',2])
()

sage: L.<x,y,z> = LieAlgebra(QQ, {('x','z'): {'x':1,'y':1}, ('y','z'): {'y':1}})
sage: S = L.subalgebra([x, y])
(x, y)
sage: S.is_solvable()
True

>>> from sage.all import *
>>> scoeffs = {('a','d'): {'a':Integer(1)}, ('a','e'): {'b':-Integer(1)},
...            ('b','d'): {'b':Integer(1)}, ('b','e'): {'a':Integer(1)},
...            ('d','e'): {'c':Integer(1)}}
>>> L = LieAlgebra(QQ, scoeffs, names=('a', 'b', 'c', 'd', 'e',)); (a, b, c, d, e,) = L._first_ngens(5)
(a, b, c, d, e)
>>> L.is_solvable()
True

>>> sl3 = LieAlgebra(QQ, cartan_type=['A',Integer(2)])
()

>>> L = LieAlgebra(QQ, {('x','z'): {'x':Integer(1),'y':Integer(1)}, ('y','z'): {'y':Integer(1)}}, names=('x', 'y', 'z',)); (x, y, z,) = L._first_ngens(3)
>>> S = L.subalgebra([x, y])
(x, y)
>>> S.is_solvable()
True


Positive characteristic examples:

sage: scoeffs = {('x','z'): {'x':1,'y':1}, ('y','z'): {'y':1}}
sage: L.<x,y,z> = LieAlgebra(GF(3), scoeffs)
(x, y, z)
sage: sl3 = LieAlgebra(GF(3), cartan_type=['A',2])
(2*h1 + h2,)

>>> from sage.all import *
>>> scoeffs = {('x','z'): {'x':Integer(1),'y':Integer(1)}, ('y','z'): {'y':Integer(1)}}
>>> L = LieAlgebra(GF(Integer(3)), scoeffs, names=('x', 'y', 'z',)); (x, y, z,) = L._first_ngens(3)
(x, y, z)
>>> sl3 = LieAlgebra(GF(Integer(3)), cartan_type=['A',Integer(2)])
(2*h1 + h2,)

structure_coefficients(include_zeros=False)[source]#

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()     # needs sage.modules
sage: L.structure_coefficients()                                        # needs sage.modules
Finite family {}
sage: L.structure_coefficients(True)                                    # needs sage.modules
Finite family {(0, 1): (0, 0, 0), (0, 2): (0, 0, 0), (1, 2): (0, 0, 0)}

>>> from sage.all import *
>>> L = LieAlgebras(QQ).FiniteDimensional().WithBasis().example()     # needs sage.modules
>>> L.structure_coefficients()                                        # needs sage.modules
Finite family {}
>>> L.structure_coefficients(True)                                    # needs sage.modules
Finite family {(0, 1): (0, 0, 0), (0, 2): (0, 0, 0), (1, 2): (0, 0, 0)}

sage: # needs sage.combinat sage.groups sage.modules
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)}

>>> from sage.all import *
>>> # needs sage.combinat sage.groups sage.modules
>>> G = SymmetricGroup(Integer(3))
>>> S = GroupAlgebra(G, QQ)
>>> L = LieAlgebra(associative=S)
>>> 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)[source]#

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: # needs sage.combinat sage.modules
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]

>>> from sage.all import *
>>> # needs sage.combinat sage.modules
>>> H = lie_algebras.Heisenberg(QQ, Integer(2))
>>> p1,p2,q1,q2,z = H.basis()
>>> S = H.subalgebra([p1, q1])
>>> S.basis().list()
[p1, q1, z]
>>> 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: # needs sage.combinat sage.modules
sage: L = LieAlgebra(QQ, 3, step=2)
sage: x,y,z = L.homogeneous_component_basis(1)
sage: C = LieAlgebras(QQ).FiniteDimensional().WithBasis()
sage: S = L.subalgebra([x, y], category=C)
sage: S.homogeneous_component_basis(2).list()
[X_12]

>>> from sage.all import *
>>> # needs sage.combinat sage.modules
>>> L = LieAlgebra(QQ, Integer(3), step=Integer(2))
>>> x,y,z = L.homogeneous_component_basis(Integer(1))
>>> C = LieAlgebras(QQ).FiniteDimensional().WithBasis()
>>> S = L.subalgebra([x, y], category=C)
>>> S.homogeneous_component_basis(Integer(2)).list()
[X_12]

universal_commutative_algebra()[source]#

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: # needs sage.combinat sage.modules
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

>>> from sage.all import *
>>> # needs sage.combinat sage.modules
>>> L = LieAlgebra(QQ, {('x','y'): {'x':Integer(1)}}, names=('x', 'y',)); (x, y,) = L._first_ngens(2)
>>> A = L.universal_commutative_algebra()
>>> a, b, c, d = A.gens()
>>> a, b, c, d
(X00bar, X01bar, 0, X11bar)
>>> a*d - a
0

universal_polynomials()[source]#

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: # needs sage.combinat sage.modules
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: # needs sage.combinat sage.modules
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: # long time, needs sage.combinat sage.modules
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()
sage: len(UP)
450
sage: UP[al[2], al[1], -al[1]]
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

>>> from sage.all import *
>>> # needs sage.combinat sage.modules
>>> L = LieAlgebra(QQ, {('x','y'): {'x':Integer(1)}}, names=('x', 'y',)); (x, y,) = L._first_ngens(2)
>>> L.universal_polynomials()
Finite family {('x', 'x', 'y'): X01*X10 - X00*X11 + X00,
('y', 'x', 'y'): X10}

>>> # needs sage.combinat sage.modules
>>> L = LieAlgebra(QQ, cartan_type=['A',Integer(1)])
>>> 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]

>>> # long time, needs sage.combinat sage.modules
>>> L = LieAlgebra(QQ, cartan_type=['B', Integer(2)])
>>> al = RootSystem(['B', Integer(2)]).root_lattice().simple_roots()
>>> k = list(L.basis().keys())[Integer(0)]
>>> UP = L.universal_polynomials()
>>> len(UP)
450
>>> UP[al[Integer(2)], al[Integer(1)], -al[Integer(1)]]
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

upper_central_series()[source]#

Return the upper central series $$(Z_i(\mathfrak{g}))_i$$ of self where the rightmost $$Z_k(\mathfrak{g}) = Z_{k+1}(\mathfrak{g}) = \cdots$$.

The upper central series of a Lie algebra $$\mathfrak{g}$$ is defined recursively by $$Z_0(\mathfrak{g}) := Z(\mathfrak{g})$$ and

$Z_{k+1}(\mathfrak{g}) / Z_k(\mathfrak{g}) = Z(\mathfrak{g} / Z_k(\mathfrak{g}),$

and recall that $$Z(\mathfrak{g})$$ is the center() of $$\mathfrak{g}$$.

EXAMPLES:

sage: L = LieAlgebras(QQ).FiniteDimensional().WithBasis().example()
sage: L.upper_central_series()
[An example of a finite dimensional Lie algebra with basis:
the 3-dimensional abelian Lie algebra over Rational Field]

sage: L.<x,y> = LieAlgebra(QQ, {('x','y'): {'x':1}})
sage: L.upper_central_series()
[Ideal () of Lie algebra on 2 generators (x, y) over Rational Field]

sage: scoeffs = {('a','d'): {'a':1}, ('a','e'): {'b':-1},
....:            ('b','d'): {'b':1}, ('b','e'): {'a':1},
....:            ('d','e'): {'c':1}}
sage: L.<a,b,c,d,e> = LieAlgebra(QQ, scoeffs)
sage: L.upper_central_series()
[Ideal (c) of Lie algebra on 5 generators (a, b, c, d, e) over Rational Field]

sage: L = lie_algebras.Heisenberg(QQ, 3)
sage: L.upper_central_series()
[Ideal (z) of Heisenberg algebra of rank 3 over Rational Field,
Heisenberg algebra of rank 3 over Rational Field]

>>> from sage.all import *
>>> L = LieAlgebras(QQ).FiniteDimensional().WithBasis().example()
>>> L.upper_central_series()
[An example of a finite dimensional Lie algebra with basis:
the 3-dimensional abelian Lie algebra over Rational Field]

>>> L = LieAlgebra(QQ, {('x','y'): {'x':Integer(1)}}, names=('x', 'y',)); (x, y,) = L._first_ngens(2)
>>> L.upper_central_series()
[Ideal () of Lie algebra on 2 generators (x, y) over Rational Field]

>>> scoeffs = {('a','d'): {'a':Integer(1)}, ('a','e'): {'b':-Integer(1)},
...            ('b','d'): {'b':Integer(1)}, ('b','e'): {'a':Integer(1)},
...            ('d','e'): {'c':Integer(1)}}
>>> L = LieAlgebra(QQ, scoeffs, names=('a', 'b', 'c', 'd', 'e',)); (a, b, c, d, e,) = L._first_ngens(5)
>>> L.upper_central_series()
[Ideal (c) of Lie algebra on 5 generators (a, b, c, d, e) over Rational Field]

>>> L = lie_algebras.Heisenberg(QQ, Integer(3))
>>> L.upper_central_series()
[Ideal (z) of Heisenberg algebra of rank 3 over Rational Field,
Heisenberg algebra of rank 3 over Rational Field]

class Subobjects(category, *args)[source]#

A category for subalgebras of a finite dimensional Lie algebra with basis.

class ParentMethods[source]#

Bases: object

ambient()[source]#

Return the ambient Lie algebra of self.

EXAMPLES:

sage: # needs sage.combinat sage.modules
sage: C = LieAlgebras(QQ).FiniteDimensional().WithBasis()
sage: L = C.example()
sage: a, b, c = L.lie_algebra_generators()
sage: S = L.subalgebra([2*a + b, b + c])
sage: S.ambient() == L
True

>>> from sage.all import *
>>> # needs sage.combinat sage.modules
>>> C = LieAlgebras(QQ).FiniteDimensional().WithBasis()
>>> L = C.example()
>>> a, b, c = L.lie_algebra_generators()
>>> S = L.subalgebra([Integer(2)*a + b, b + c])
>>> S.ambient() == L
True

basis_matrix()[source]#

Return the basis matrix of self.

EXAMPLES:

sage: # needs sage.combinat sage.modules
sage: C = LieAlgebras(QQ).FiniteDimensional().WithBasis()
sage: L = C.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]

>>> from sage.all import *
>>> # needs sage.combinat sage.modules
>>> C = LieAlgebras(QQ).FiniteDimensional().WithBasis()
>>> L = C.example()
>>> a, b, c = L.lie_algebra_generators()
>>> S = L.subalgebra([Integer(2)*a + b, b + c])
>>> S.basis_matrix()
[   1    0 -1/2]
[   0    1    1]

reduce(X)[source]#

Reduce an element of the ambient Lie algebra modulo the ideal self.

INPUT:

• X – an element of the ambient Lie algebra

OUTPUT:

An element $$Y$$ of the ambient Lie algebra that is contained in a fixed complementary submodule $$V$$ to self such that $$X = Y$$ mod self.

When the base ring of self is a field, the complementary submodule $$V$$ is spanned by the elements of the basis that are not the leading supports of the basis of self.

EXAMPLES:

An example reduction in a 6 dimensional Lie algebra:

sage: sc = {('a','b'): {'d': 1}, ('a','c'): {'e': 1},
....:       ('b','c'): {'f': 1}}
sage: L.<a,b,c,d,e,f> = LieAlgebra(QQ, sc)
sage: I = L.ideal(c)
sage: I.reduce(a + b + c + d + e + f)
a + b + d

>>> from sage.all import *
>>> sc = {('a','b'): {'d': Integer(1)}, ('a','c'): {'e': Integer(1)},
...       ('b','c'): {'f': Integer(1)}}
>>> L = LieAlgebra(QQ, sc, names=('a', 'b', 'c', 'd', 'e', 'f',)); (a, b, c, d, e, f,) = L._first_ngens(6)
>>> I = L.ideal(c)
>>> I.reduce(a + b + c + d + e + f)
a + b + d


The reduction of an element is zero if and only if the element belongs to the subalgebra:

sage: I.reduce(c + e)
0
sage: c + e in I
True

>>> from sage.all import *
>>> I.reduce(c + e)
0
>>> c + e in I
True


Over non-fields, the complementary submodule may not be spanned by a subset of the basis of the ambient Lie algebra:

sage: L.<X,Y,Z> = LieAlgebra(ZZ, {('X','Y'): {'Z': 3}})
sage: I = L.ideal(Y)
sage: I.basis()
Family (Y, 3*Z)
sage: I.reduce(3*Z)
0
sage: I.reduce(Y + 14*Z)
2*Z

>>> from sage.all import *
>>> L = LieAlgebra(ZZ, {('X','Y'): {'Z': Integer(3)}}, names=('X', 'Y', 'Z',)); (X, Y, Z,) = L._first_ngens(3)
>>> I = L.ideal(Y)
>>> I.basis()
Family (Y, 3*Z)
>>> I.reduce(Integer(3)*Z)
0
>>> I.reduce(Y + Integer(14)*Z)
2*Z

example(n=3)[source]#

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()                                                           # needs sage.modules
An example of a finite dimensional Lie algebra with basis:
the 3-dimensional abelian Lie algebra over Rational Field

>>> from sage.all import *
>>> C = LieAlgebras(QQ).FiniteDimensional().WithBasis()
>>> C.example()                                                           # needs 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)                                                          # needs sage.modules
An example of a finite dimensional Lie algebra with basis:
the 5-dimensional abelian Lie algebra over Rational Field

>>> from sage.all import *
>>> C.example(Integer(5))                                                          # needs sage.modules
An example of a finite dimensional Lie algebra with basis:
the 5-dimensional abelian Lie algebra over Rational Field