Finite Dimensional Lie Algebras With Basis#

AUTHORS:

  • Travis Scrimshaw (07-15-2013): Initial implementation

class sage.categories.finite_dimensional_lie_algebras_with_basis.FiniteDimensionalLieAlgebrasWithBasis(base_category)#

Bases: CategoryWithAxiom_over_base_ring

Category of finite dimensional Lie algebras with a basis.

Todo

Many of these tests should use non-abelian Lie algebras and need to be added after github issue #16820.

class ElementMethods#

Bases: object

adjoint_matrix(sparse=False)#

Return the matrix of the adjoint action of self.

EXAMPLES:

sage: L = LieAlgebras(QQ).FiniteDimensional().WithBasis().example()     # optional - sage.combinat sage.modules
sage: L.an_element().adjoint_matrix()                                   # optional - sage.combinat sage.modules
[0 0 0]
[0 0 0]
[0 0 0]
sage: L.an_element().adjoint_matrix(sparse=True).is_sparse()            # optional - sage.combinat sage.modules
True
sage: L.<x,y> = LieAlgebra(QQ, {('x','y'): {'x':1}})                    # optional - sage.combinat sage.modules
sage: x.adjoint_matrix()                                                # optional - sage.combinat sage.modules
[0 1]
[0 0]
sage: y.adjoint_matrix()                                                # optional - sage.combinat sage.modules
[-1  0]
[ 0  0]

We verify that this forms a representation:

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

Return the vector in g.module() corresponding to the 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()     # optional - sage.combinat sage.modules
sage: L.an_element().to_vector()                                        # optional - sage.combinat sage.modules
(0, 0, 0)

sage: L.an_element().to_vector(sparse=True)                             # optional - sage.combinat sage.modules
(0, 0, 0)

sage: D = DescentAlgebra(QQ, 4).D()                                     # optional - sage.combinat sage.modules
sage: L = LieAlgebra(associative=D)                                     # optional - sage.combinat sage.modules
sage: L.an_element().to_vector()                                        # optional - sage.combinat sage.modules
(1, 1, 1, 1, 1, 1, 1, 1)
Nilpotent#

alias of FiniteDimensionalNilpotentLieAlgebrasWithBasis

class ParentMethods#

Bases: object

as_finite_dimensional_algebra()#

Return self as a FiniteDimensionalAlgebra.

EXAMPLES:

sage: L = lie_algebras.cross_product(QQ)                                # optional - sage.combinat sage.modules
sage: x, y, z = L.basis()                                               # optional - sage.combinat sage.modules
sage: F = L.as_finite_dimensional_algebra()                             # optional - sage.combinat sage.modules
sage: X, Y, Z = F.basis()                                               # optional - sage.combinat sage.modules
sage: x.bracket(y)                                                      # optional - sage.combinat sage.modules
Z
sage: X * Y                                                             # optional - sage.combinat sage.modules
Z
casimir_element(order=2, UEA=None, force_generic=False)#

Return the Casimir element in the universal enveloping algebra of self.

A Casimir element of order \(k\) is a distinguished basis element for the center of \(U(\mathfrak{g})\) of homogeneous degree \(k\) (that is, it is an element of \(U_k \setminus U_{k-1}\), where \(\{U_i\}_{i=0}^{\infty}\) is the natural filtration of \(U(\mathfrak{g})\)). When \(\mathfrak{g}\) is a simple Lie algebra, then this spans \(Z(U(\mathfrak{g}))_k\).

INPUT:

  • order – (default: 2) the order of the Casimir element

  • UEA – (optional) the universal enveloping algebra 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

ALGORITHM:

For the quadratic order (i.e., order=2), then this uses \(K^{ij}\), the inverse of the Killing form matrix, to compute \(C_{(2)} = \sum_{i,j} K^{ij} X_i \cdots X_j\), where \(\{X_1, \ldots, X_n\}\) is a basis for \(\mathfrak{g}\). Otherwise this solves the system of equations

\[f_{aj}^b \kappa^{jc\cdots d} + f_{aj}^c \kappa^{cj\cdots d} \cdots + f_{aj}^d \kappa^{bc \cdots j}\]

for the symmetric tensor \(\kappa^{i_1 \cdots i_k}\), where \(k\) is the order. This system comes from \([X_i, C_{(k)}] = 0\) with

\[C_{(k)} = \sum_{i_1, \ldots, i_k}^n \kappa^{i_1 \cdots i_k} X_{i_1} \cdots X_{i_k}.\]

EXAMPLES:

sage: L = LieAlgebra(QQ, cartan_type=['A', 1])
sage: C = L.casimir_element(); C
1/8*b1^2 + 1/2*b0*b2 - 1/4*b1
sage: U = L.universal_enveloping_algebra()
sage: all(g * C == C * g for g in U.gens())
True
sage: U = L.pbw_basis()
sage: C = L.casimir_element(UEA=U); C
1/2*PBW[alpha[1]]*PBW[-alpha[1]] + 1/8*PBW[alphacheck[1]]^2
 - 1/4*PBW[alphacheck[1]]
sage: all(g * C == C * g for g in U.algebra_generators())
True

sage: L = LieAlgebra(QQ, cartan_type=['B', 2])
sage: U = L.pbw_basis()
sage: C = L.casimir_element(UEA=U)
sage: all(g * C == C * g for g in U.algebra_generators())
True

sage: L = LieAlgebra(QQ, cartan_type=['C', 3])
sage: U = L.pbw_basis()
sage: C = L.casimir_element(UEA=U)
sage: all(g * C == C * g for g in U.algebra_generators())
True

sage: L = LieAlgebra(QQ, cartan_type=['A', 1])
sage: C4 = L.casimir_element(order=4, UEA=L.pbw_basis()); C4
4*PBW[alpha[1]]^2*PBW[-alpha[1]]^2
 + 2*PBW[alpha[1]]*PBW[alphacheck[1]]^2*PBW[-alpha[1]]
 + 1/4*PBW[alphacheck[1]]^4 - PBW[alphacheck[1]]^3
 - 4*PBW[alpha[1]]*PBW[-alpha[1]] + 2*PBW[alphacheck[1]]
sage: all(g * C4 == C4 * g for g in L.pbw_basis().algebra_generators())
True

sage: L = lie_algebras.Heisenberg(QQ, 2)
sage: L.casimir_element()
0

Todo

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

center()#

Return the center of self.

EXAMPLES:

sage: L = LieAlgebras(QQ).FiniteDimensional().WithBasis().example()     # optional - sage.modules
sage: Z = L.center(); Z                                                 # optional - sage.modules
An example of a finite dimensional Lie algebra with basis: the
 3-dimensional abelian Lie algebra over Rational Field
sage: Z.basis_matrix()                                                  # optional - sage.modules
[1 0 0]
[0 1 0]
[0 0 1]
centralizer(S)#

Return the centralizer of S in self.

INPUT:

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

EXAMPLES:

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

Return a basis of the centralizer of S 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()     # optional - sage.modules
sage: a, b, c = L.lie_algebra_generators()                              # optional - sage.modules
sage: L.centralizer_basis([a + b, 2*a + c])                             # optional - sage.modules
[(1, 0, 0), (0, 1, 0), (0, 0, 1)]

sage: H = lie_algebras.Heisenberg(QQ, 2)                                # optional - sage.combinat sage.modules
sage: H.centralizer_basis(H)                                            # optional - sage.combinat sage.modules
[z]


sage: D = DescentAlgebra(QQ, 4).D()                                     # optional - sage.combinat sage.modules
sage: L = LieAlgebra(associative=D)                                     # optional - sage.combinat sage.modules
sage: L.centralizer_basis(L)                                            # optional - sage.combinat sage.modules
[D{},
 D{1} + D{1, 2} + D{2, 3} + D{3},
 D{1, 2, 3} + D{1, 3} + D{2}]
sage: D.center_basis()                                                  # optional - sage.combinat sage.modules
(D{},
 D{1} + D{1, 2} + D{2, 3} + D{3},
 D{1, 2, 3} + D{1, 3} + D{2})
chevalley_eilenberg_complex(M=None, dual=False, sparse=True, ncpus=None)#

Return the Chevalley-Eilenberg complex of self.

Let \(\mathfrak{g}\) be a Lie algebra and \(M\) be a right \(\mathfrak{g}\)-module. The Chevalley-Eilenberg complex is the chain complex on

\[C_{\bullet}(\mathfrak{g}, M) = M \otimes \bigwedge\nolimits^{\bullet} \mathfrak{g},\]

where the differential is given by

\[d(m \otimes g_1 \wedge \cdots \wedge g_p) = \sum_{i=1}^p (-1)^{i+1} (m g_i) \otimes g_1 \wedge \cdots \wedge \hat{g}_i \wedge \cdots \wedge g_p + \sum_{1 \leq i < j \leq p} (-1)^{i+j} m \otimes [g_i, g_j] \wedge g_1 \wedge \cdots \wedge \hat{g}_i \wedge \cdots \wedge \hat{g}_j \wedge \cdots \wedge g_p.\]

INPUT:

  • M – (default: the trivial 1-dimensional module) the module \(M\)

  • dual – (default: False) 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)                                        # optional - sage.combinat sage.modules
sage: C = L.chevalley_eilenberg_complex(); C                            # optional - sage.combinat sage.modules
Chain complex with at most 4 nonzero terms over Integer Ring
sage: ascii_art(C)                                                      # optional - sage.combinat sage.modules
                          [ 2  0  0]       [0]
                          [ 0 -1  0]       [0]
            [0 0 0]       [ 0  0  2]       [0]
 0 <-- C_0 <-------- C_1 <----------- C_2 <---- C_3 <-- 0

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

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

REFERENCES:

Todo

Currently this is only implemented for coefficients given by the trivial module \(R\), where \(R\) is the base ring and \(g R = 0\) for all \(g \in \mathfrak{g}\). Allow generic coefficient modules \(M\).

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

Return the Lie algebra cohomology of self.

The Lie algebra cohomology is the cohomology of the Chevalley-Eilenberg cochain complex (which is the dual of the Chevalley-Eilenberg chain complex).

Let \(\mathfrak{g}\) be a Lie algebra and \(M\) a left \(\mathfrak{g}\)-module. It is known that \(H^0(\mathfrak{g}; M)\) is the subspace of \(\mathfrak{g}\)-invariants of \(M\):

\[H^0(\mathfrak{g}; M) = M^{\mathfrak{g}} = \{ m \in M \mid g m = 0 \text{ for all } g \in \mathfrak{g} \}.\]

Additionally, \(H^1(\mathfrak{g}; M)\) is the space of derivations \(\mathfrak{g} \to M\) modulo the space of inner derivations, and \(H^2(\mathfrak{g}; M)\) is the space of equivalence classes of Lie algebra extensions of \(\mathfrak{g}\) by \(M\).

INPUT:

  • deg – the degree of the homology (optional)

  • M – (default: the trivial module) a right module 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)                                        # optional - sage.combinat sage.modules
sage: L.cohomology()                                                    # optional - sage.combinat sage.modules
{0: Vector space of dimension 1 over Rational Field,
 1: Vector space of dimension 0 over Rational Field,
 2: Vector space of dimension 0 over Rational Field,
 3: Vector space of dimension 2 over Rational Field,
 4: Vector space of dimension 0 over Rational Field,
 5: Vector space of dimension 0 over Rational Field,
 6: Vector space of dimension 1 over Rational Field}

sage: L = lie_algebras.Heisenberg(QQ, 2)                                # optional - sage.combinat sage.modules
sage: L.cohomology()                                                    # optional - sage.combinat sage.modules
{0: Vector space of dimension 1 over Rational Field,
 1: Vector space of dimension 4 over Rational Field,
 2: Vector space of dimension 5 over Rational Field,
 3: Vector space of dimension 5 over Rational Field,
 4: Vector space of dimension 4 over Rational Field,
 5: Vector space of dimension 1 over Rational Field}

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

REFERENCES:

derivations_basis()#

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

A derivation \(D\) of an algebra is an endomorphism of \(A\) such that

\[D([a, b]) = [D(a), b] + [a, D(b)]\]

for all \(a, b \in A\). The set of all derivations form a Lie algebra.

EXAMPLES:

We construct the derivations of the Heisenberg Lie algebra:

sage: H = lie_algebras.Heisenberg(QQ, 1)                                # optional - sage.combinat sage.modules
sage: H.derivations_basis()                                             # optional - sage.combinat sage.modules
(
[1 0 0]  [0 1 0]  [0 0 0]  [0 0 0]  [0 0 0]  [0 0 0]
[0 0 0]  [0 0 0]  [1 0 0]  [0 1 0]  [0 0 0]  [0 0 0]
[0 0 1], [0 0 0], [0 0 0], [0 0 1], [1 0 0], [0 1 0]
)

We construct the derivations of \(\mathfrak{sl}_2\):

sage: sl2 = lie_algebras.sl(QQ, 2)                                      # optional - sage.combinat sage.modules
sage: sl2.derivations_basis()                                           # optional - sage.combinat sage.modules
(
[ 1  0  0]  [   0    1    0]  [ 0  0  0]
[ 0  0  0]  [   0    0 -1/2]  [ 1  0  0]
[ 0  0 -1], [   0    0    0], [ 0 -2  0]
)

We verify these are derivations:

sage: D = [sl2.module_morphism(matrix=M, codomain=sl2)                  # optional - sage.combinat sage.modules
....:      for M in sl2.derivations_basis()]
sage: all(d(a.bracket(b)) == d(a).bracket(b) + a.bracket(d(b))          # optional - sage.combinat sage.modules
....:     for a in sl2.basis() for b in sl2.basis() for d in D)
True

REFERENCES:

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()     # optional - sage.combinat sage.modules
sage: L.derived_series()                                                # optional - sage.combinat sage.modules
(An example of a finite dimensional Lie algebra with basis:
    the 3-dimensional abelian Lie algebra over Rational Field,
 An example of a finite dimensional Lie algebra with basis:
    the 0-dimensional abelian Lie algebra over Rational Field
    with basis matrix: [])
sage: L.<x,y> = LieAlgebra(QQ, {('x','y'): {'x':1}})                    # optional - sage.combinat sage.modules
sage: L.derived_series() # todo: not implemented - #17416               # optional - sage.combinat sage.modules
(Lie algebra on 2 generators (x, y) over Rational Field,
 Subalgebra generated of
  Lie algebra on 2 generators (x, y) over Rational Field
  with basis: (x,),
 Subalgebra generated of
  Lie algebra on 2 generators (x, y) over Rational Field
  with basis: ())
derived_subalgebra()#

Return the derived subalgebra of self.

EXAMPLES:

sage: L = LieAlgebras(QQ).FiniteDimensional().WithBasis().example()     # optional - sage.combinat sage.modules
sage: L.derived_subalgebra()                                            # optional - sage.combinat sage.modules
An example of a finite dimensional Lie algebra with basis:
 the 0-dimensional abelian Lie algebra over Rational Field
 with basis matrix:
[]

If self is semisimple, then the derived subalgebra is self:

sage: sl3 = LieAlgebra(QQ, cartan_type=['A', 2])                        # optional - sage.combinat sage.modules
sage: sl3.derived_subalgebra()                                          # optional - sage.combinat sage.modules
Lie algebra of ['A', 2] in the Chevalley basis
sage: sl3 is sl3.derived_subalgebra()                                   # optional - sage.combinat sage.modules
True
from_vector(v, order=None)#

Return the element of self corresponding to the 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()     # optional - sage.modules
sage: u = L.from_vector(vector(QQ, (1, 0, 0))); u                       # optional - sage.modules
(1, 0, 0)
sage: parent(u) is L                                                    # optional - sage.modules
True
homology(deg=None, M=None, sparse=True, ncpus=None)#

Return the Lie algebra homology of self.

The Lie algebra homology is the homology of the Chevalley-Eilenberg chain complex.

INPUT:

  • deg – the degree of the homology (optional)

  • M – (default: the trivial module) a right module 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)                                # optional - sage.combinat sage.modules
sage: L.homology()                                                      # optional - sage.combinat sage.modules
{0: Vector space of dimension 1 over Rational Field,
 1: Vector space of dimension 0 over Rational Field,
 2: Vector space of dimension 0 over Rational Field,
 3: Vector space of dimension 1 over Rational Field}

sage: L = lie_algebras.pwitt(GF(5), 5)                                  # optional - sage.combinat sage.libs.pari sage.modules
sage: L.homology()                                                      # optional - sage.combinat sage.libs.pari sage.modules
{0: Vector space of dimension 1 over Finite Field of size 5,
 1: Vector space of dimension 0 over Finite Field of size 5,
 2: Vector space of dimension 1 over Finite Field of size 5,
 3: Vector space of dimension 1 over Finite Field of size 5,
 4: Vector space of dimension 0 over Finite Field of size 5,
 5: Vector space of dimension 1 over Finite Field of size 5}

sage: d = {('x', 'y'): {'y': 2}}                                        # optional - sage.combinat sage.modules
sage: L.<x,y> = LieAlgebra(ZZ, d)                                       # optional - sage.combinat sage.modules
sage: L.homology()                                                      # optional - sage.combinat sage.modules
{0: Z, 1: Z x C2, 2: 0}
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)                                # optional - sage.combinat sage.modules
sage: p1,p2,q1,q2,z = H.basis()                                         # optional - sage.combinat sage.modules
sage: I = H.ideal([p1-p2, q1-q2])                                       # optional - sage.combinat sage.modules
sage: I.basis().list()                                                  # optional - sage.combinat sage.modules
[-p1 + p2, -q1 + q2, z]
sage: I.reduce(p1 + p2 + q1 + q2 + z)                                   # optional - sage.combinat sage.modules
2*p1 + 2*q1

Passing an extra category to an ideal:

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

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

EXAMPLES:

sage: H = lie_algebras.Heisenberg(QQ, 1)                                # optional - sage.combinat sage.modules
sage: H.inner_derivations_basis()                                       # optional - sage.combinat sage.modules
(
[0 0 0]  [0 0 0]
[0 0 0]  [0 0 0]
[1 0 0], [0 1 0]
)
is_abelian()#

Return if self is an abelian Lie algebra.

EXAMPLES:

sage: L = LieAlgebras(QQ).FiniteDimensional().WithBasis().example()     # optional - sage.combinat sage.modules
sage: L.is_abelian()                                                    # optional - sage.combinat sage.modules
True
sage: L.<x,y> = LieAlgebra(QQ, {('x','y'): {'x':1}})                    # optional - sage.combinat sage.modules
sage: L.is_abelian()                                                    # optional - sage.combinat sage.modules
False
is_ideal(A)#

Return if self is an ideal of A.

EXAMPLES:

sage: L = LieAlgebras(QQ).FiniteDimensional().WithBasis().example()     # optional - sage.combinat sage.modules
sage: a, b, c = L.lie_algebra_generators()                              # optional - sage.combinat sage.modules
sage: I = L.ideal([2*a - c, b + c])                                     # optional - sage.combinat sage.modules
sage: I.is_ideal(L)                                                     # optional - sage.combinat sage.modules
True

sage: L.<x,y> = LieAlgebra(QQ, {('x','y'):{'x':1}})                     # optional - sage.combinat sage.modules
sage: L.is_ideal(L)                                                     # optional - sage.combinat sage.modules
True

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

Return if self is a nilpotent Lie algebra.

A Lie algebra is nilpotent if the lower central series eventually becomes \(0\).

EXAMPLES:

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

Return if self if a semisimple Lie algebra.

A Lie algebra is semisimple if the solvable radical is zero. In characteristic 0, this is equivalent to saying the Killing form is non-degenerate.

EXAMPLES:

sage: L = LieAlgebras(QQ).FiniteDimensional().WithBasis().example()     # optional - sage.combinat sage.modules
sage: L.is_semisimple()                                                 # optional - sage.combinat sage.modules
False
is_solvable()#

Return if self is a solvable Lie algebra.

A Lie algebra is solvable if the derived series eventually becomes \(0\).

EXAMPLES:

sage: L = LieAlgebras(QQ).FiniteDimensional().WithBasis().example()     # optional - sage.combinat sage.modules
sage: L.is_solvable()                                                   # optional - sage.combinat sage.modules
True
sage: L.<x,y> = LieAlgebra(QQ, {('x','y'): {'x':1}})                    # optional - sage.combinat sage.modules
sage: L.is_solvable() # todo: not implemented - #17416                  # optional - sage.combinat sage.modules
False
killing_form(x, y)#

Return the Killing form on x 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()     # optional - sage.combinat sage.modules
sage: a, b, c = L.lie_algebra_generators()                              # optional - sage.combinat sage.modules
sage: L.killing_form(a, b)                                              # optional - sage.combinat sage.modules
0
killing_form_matrix()#

Return the matrix of the Killing form of self.

The rows and the columns of this matrix are indexed by the elements of the basis of self (in the order provided by basis()).

EXAMPLES:

sage: L = LieAlgebras(QQ).FiniteDimensional().WithBasis().example()     # optional - sage.modules
sage: L.killing_form_matrix()                                           # optional - sage.modules
[0 0 0]
[0 0 0]
[0 0 0]

sage: L = LieAlgebras(QQ).FiniteDimensional().WithBasis().example(0)    # optional - sage.modules
sage: m = L.killing_form_matrix(); m                                    # optional - sage.modules
[]
sage: parent(m)                                                         # optional - sage.modules
Full MatrixSpace of 0 by 0 dense matrices over Rational Field
killing_matrix(x, y)#

Return the Killing matrix of x 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()     # optional - sage.modules
sage: a, b, c = L.lie_algebra_generators()                              # optional - sage.modules
sage: L.killing_matrix(a, b)                                            # optional - sage.modules
[0 0 0]
[0 0 0]
[0 0 0]
sage: L.<x,y> = LieAlgebra(QQ, {('x','y'): {'x':1}})                    # optional - sage.combinat sage.modules
sage: L.killing_matrix(y, x)                                            # optional - sage.combinat sage.modules
[ 0 -1]
[ 0  0]
lower_central_series(submodule=False)#

Return the lower central series \((\mathfrak{g}_{i})_i\) of self where the rightmost \(\mathfrak{g}_k = \mathfrak{g}_{k+1} = \cdots\).

INPUT:

  • submodule – (default: False) 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()     # optional - sage.combinat sage.modules
sage: L.derived_series()                                                # optional - sage.combinat sage.modules
(An example of a finite dimensional Lie algebra with basis:
  the 3-dimensional abelian Lie algebra over Rational Field,
 An example of a finite dimensional Lie algebra with basis:
  the 0-dimensional abelian Lie algebra over Rational Field
   with basis matrix: [])

The lower central series as submodules:

sage: L.<x,y> = LieAlgebra(QQ, {('x','y'): {'x':1}})                    # optional - sage.combinat sage.modules
sage: L.lower_central_series(submodule=True)                            # optional - sage.combinat sage.modules
(Sparse vector space of dimension 2 over Rational Field,
 Vector space of degree 2 and dimension 1 over Rational Field
  Basis matrix: [1 0])
sage: L.<x,y> = LieAlgebra(QQ, {('x','y'): {'x':1}})                    # optional - sage.combinat sage.modules
sage: L.lower_central_series() # todo: not implemented - #17416         # optional - sage.combinat sage.modules
(Lie algebra on 2 generators (x, y) over Rational Field,
 Subalgebra generated of
  Lie algebra on 2 generators (x, y) over Rational Field
  with basis: (x,))
module(R=None)#

Return a dense free module associated to self over R.

EXAMPLES:

sage: L = LieAlgebras(QQ).FiniteDimensional().WithBasis().example()     # optional - sage.modules
sage: L._dense_free_module()                                            # optional - sage.modules
Vector space of dimension 3 over Rational Field
morphism(on_generators, codomain=None, base_map=None, check=True)#

Return a Lie algebra morphism defined by images of a Lie generating subset of self.

INPUT:

  • on_generators – dictionary {X: Y} of the images \(Y\) 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: L.<X,Y,Z,W> = LieAlgebra(QQ, {('X','Y'): {'Z': 1},                # optional - sage.combinat sage.modules
....:                               ('X','Z'): {'W': 1}})
sage: K.<A,B> = LieAlgebra(QQ, abelian=True)                            # optional - sage.combinat sage.modules
sage: L.morphism({X: A, Y: B})                                          # optional - sage.combinat sage.modules
Lie algebra morphism:
  From: Lie algebra on 4 generators (X, Y, Z, W) over Rational Field
  To:   Abelian Lie algebra on 2 generators (A, B) over Rational Field
  Defn: X |--> A
        Y |--> B
        Z |--> 0
        W |--> 0

The reverse map \(A \mapsto X\), \(B \mapsto Y\) does not define a Lie algebra morphism, since \([A,B] = 0\), but \([X,Y] \neq 0\):

sage: K.morphism({A:X, B: Y})                                           # optional - sage.combinat sage.modules
Traceback (most recent call last):
...
ValueError: this does not define a Lie algebra morphism;
 contradictory values for brackets of length 2

However, it is still possible to create a morphism that acts nontrivially on the coefficients, even though it’s not a Lie algebra morphism (since it isn’t linear):

sage: R.<x> = ZZ[]                                                      # optional - sage.combinat sage.modules
sage: K.<i> = NumberField(x^2 + 1)                                      # optional - sage.combinat sage.modules sage.rings.number_fields
sage: cc = K.hom([-i])                                                  # optional - sage.combinat sage.modules sage.rings.number_fields
sage: L.<X,Y,Z,W> = LieAlgebra(K, {('X','Y'): {'Z': 1},                 # optional - sage.combinat sage.modules sage.rings.number_fields
....:                              ('X','Z'): {'W': 1}})
sage: M.<A,B> = LieAlgebra(K, abelian=True)                             # optional - sage.combinat sage.modules sage.rings.number_fields
sage: phi = L.morphism({X: A, Y: B}, base_map=cc)                       # optional - sage.combinat sage.modules sage.rings.number_fields
sage: phi(X)                                                            # optional - sage.combinat sage.modules sage.rings.number_fields
A
sage: phi(i*X)                                                          # optional - sage.combinat sage.modules sage.rings.number_fields
-i*A
product_space(L, submodule=False)#

Return the product space [self, L].

INPUT:

  • L – a Lie subalgebra 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()     # optional - sage.combinat sage.modules
sage: a,b,c = L.lie_algebra_generators()                                # optional - sage.combinat sage.modules
sage: X = L.subalgebra([a, b+c])                                        # optional - sage.combinat sage.modules
sage: L.product_space(X)                                                # optional - sage.combinat sage.modules
An example of a finite dimensional Lie algebra with basis:
 the 0-dimensional abelian Lie algebra over Rational Field
  with basis matrix: []
sage: Y = L.subalgebra([a, 2*b-c])                                      # optional - sage.combinat sage.modules
sage: X.product_space(Y)                                                # optional - sage.combinat sage.modules
An example of a finite dimensional Lie algebra with basis:
 the 0-dimensional abelian Lie algebra over Rational Field
  with basis matrix: []
sage: H = lie_algebras.Heisenberg(ZZ, 4)                                # optional - sage.combinat sage.modules
sage: Hp = H.product_space(H, submodule=True).basis()                   # optional - sage.combinat sage.modules
sage: [H.from_vector(v) for v in Hp]                                    # optional - sage.combinat sage.modules
[z]
sage: L.<x,y> = LieAlgebra(QQ, {('x','y'):{'x':1}})                     # optional - sage.combinat sage.modules
sage: Lp = L.product_space(L)  # todo: not implemented - #17416         # optional - sage.combinat sage.modules
sage: Lp  # todo: not implemented - #17416                              # optional - sage.combinat sage.modules
Subalgebra generated of
 Lie algebra on 2 generators (x, y) over Rational Field
 with basis: (x,)
sage: Lp.product_space(L) # todo: not implemented - #17416              # optional - sage.combinat sage.modules
Subalgebra generated of
 Lie algebra on 2 generators (x, y) over Rational Field
 with basis: (x,)
sage: L.product_space(Lp) # todo: not implemented - #17416              # optional - sage.combinat sage.modules
Subalgebra generated of
 Lie algebra on 2 generators (x, y) over Rational Field
 with basis: (x,)
sage: Lp.product_space(Lp) # todo: not implemented - #17416             # optional - sage.combinat sage.modules
Subalgebra generated of
 Lie algebra on 2 generators (x, y) over Rational Field
 with basis: ()
quotient(I, names=None, category=None)#

Return the quotient of self by the 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)                         # optional - sage.combinat sage.modules
sage: E = L.quotient(U); E                                              # optional - sage.combinat sage.modules
Lie algebra quotient L/I of dimension 4 over Rational Field where
 L: Free Nilpotent Lie algebra on 5 generators (X, Y, Z, W, U)
    over Rational Field
 I: Ideal (U)
sage: E.basis().list()                                                  # optional - sage.combinat sage.modules
[X, Y, Z, W]
sage: E(X).bracket(E(Y))                                                # optional - sage.combinat sage.modules
Z
sage: Y.bracket(Z)                                                      # optional - sage.combinat sage.modules
-U
sage: E(Y).bracket(E(Z))                                                # optional - sage.combinat sage.modules
0
sage: E(U)                                                              # optional - sage.combinat sage.modules
0

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

sage: L = lie_algebras.Heisenberg(ZZ, 1)                                # optional - sage.combinat sage.modules
sage: L.quotient(L.an_element())                                        # optional - sage.combinat sage.modules
Traceback (most recent call last):
...
NotImplementedError: quotients over non-fields not implemented
structure_coefficients(include_zeros=False)#

Return the structure coefficients of self.

INPUT:

  • include_zeros – (default: False) 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()     # optional - sage.modules
sage: L.structure_coefficients()                                        # optional - sage.modules
Finite family {}
sage: L.structure_coefficients(True)                                    # optional - sage.modules
Finite family {(0, 1): (0, 0, 0), (0, 2): (0, 0, 0), (1, 2): (0, 0, 0)}
sage: G = SymmetricGroup(3)                                             # optional - sage.groups
sage: S = GroupAlgebra(G, QQ)                                           # optional - sage.groups sage.modules
sage: L = LieAlgebra(associative=S)                                     # optional - sage.groups sage.modules sage.combinat
sage: L.structure_coefficients()                                        # optional - sage.groups sage.modules sage.combinat
Finite family {((2,3), (1,2)): (1,2,3) - (1,3,2),
               ((2,3), (1,3)): -(1,2,3) + (1,3,2),
               ((1,2,3), (2,3)): -(1,2) + (1,3),
               ((1,2,3), (1,2)): (2,3) - (1,3),
               ((1,2,3), (1,3)): -(2,3) + (1,2),
               ((1,3,2), (2,3)): (1,2) - (1,3),
               ((1,3,2), (1,2)): -(2,3) + (1,3),
               ((1,3,2), (1,3)): (2,3) - (1,2),
               ((1,3), (1,2)): -(1,2,3) + (1,3,2)}
subalgebra(*gens, **kwds)#

Return the subalgebra of self generated 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)                                # optional - sage.combinat sage.modules
sage: p1,p2,q1,q2,z = H.basis()                                         # optional - sage.combinat sage.modules
sage: S = H.subalgebra([p1, q1])                                        # optional - sage.combinat sage.modules
sage: S.basis().list()                                                  # optional - sage.combinat sage.modules
[p1, q1, z]
sage: S.basis_matrix()                                                  # optional - sage.combinat sage.modules
[1 0 0 0 0]
[0 0 1 0 0]
[0 0 0 0 1]

Passing an extra category to a subalgebra:

sage: L = LieAlgebra(QQ, 3, step=2)                                     # optional - sage.combinat sage.modules
sage: x,y,z = L.homogeneous_component_basis(1)                          # optional - sage.combinat sage.modules
sage: C = LieAlgebras(QQ).FiniteDimensional().WithBasis()               # optional - sage.combinat sage.modules
sage: C = C.Subobjects().Graded().Stratified()                          # optional - sage.combinat sage.modules
sage: S = L.subalgebra([x, y], category=C)                              # optional - sage.combinat sage.modules
sage: S.homogeneous_component_basis(2).list()                           # optional - sage.combinat sage.modules
[X_12]
universal_commutative_algebra()#

Return the universal commutative algebra associated to self.

Let \(I\) be the index set of the basis of self. Let \(\mathcal{P} = \{P_{a,i,j}\}_{a,i,j \in I}\) denote the universal polynomials of a Lie algebra \(L\). The universal commutative algebra associated to \(L\) is the quotient ring \(R[X_{ij}]_{i,j \in I} / (\mathcal{P})\).

EXAMPLES:

sage: L.<x,y> = LieAlgebra(QQ, {('x','y'): {'x':1}})                    # optional - sage.combinat sage.modules
sage: A = L.universal_commutative_algebra()                             # optional - sage.combinat sage.modules
sage: a, b, c, d = A.gens()                                             # optional - sage.combinat sage.modules
sage: a, b, c, d                                                        # optional - sage.combinat sage.modules
(X00bar, X01bar, 0, X11bar)
sage: a*d - a                                                           # optional - sage.combinat sage.modules
0
universal_polynomials()#

Return the family of universal polynomials of self.

The universal polynomials of a Lie algebra \(L\) with basis \(\{e_i\}_{i \in I}\) and structure coefficients \([e_i, e_j] = \tau_{ij}^a e_a\) is given by

\[P_{aij} = \sum_{u \in I} \tau_{ij}^u X_{au} - \sum_{s,t \in I} \tau_{st}^a X_{si} X_{tj},\]

where \(a,i,j \in I\).

REFERENCES:

EXAMPLES:

sage: L.<x,y> = LieAlgebra(QQ, {('x','y'): {'x':1}})                    # optional - sage.combinat sage.modules
sage: L.universal_polynomials()                                         # optional - sage.combinat sage.modules
Finite family {('x', 'x', 'y'): X01*X10 - X00*X11 + X00,
               ('y', 'x', 'y'): X10}

sage: L = LieAlgebra(QQ, cartan_type=['A',1])                           # optional - sage.combinat sage.modules
sage: list(L.universal_polynomials())                                   # optional - sage.combinat sage.modules
[-2*X01*X10 + 2*X00*X11 - 2*X00,
 -2*X02*X10 + 2*X00*X12 + X01,
 -2*X02*X11 + 2*X01*X12 - 2*X02,
 X01*X20 - X00*X21 - 2*X10,
 X02*X20 - X00*X22 + X11,
 X02*X21 - X01*X22 - 2*X12,
 -2*X11*X20 + 2*X10*X21 - 2*X20,
 -2*X12*X20 + 2*X10*X22 + X21,
 -2*X12*X21 + 2*X11*X22 - 2*X22]

sage: L = LieAlgebra(QQ, cartan_type=['B', 2])                          # optional - sage.combinat sage.modules
sage: al = RootSystem(['B', 2]).root_lattice().simple_roots()           # optional - sage.combinat sage.modules
sage: k = list(L.basis().keys())[0]                                     # optional - sage.combinat sage.modules
sage: UP = L.universal_polynomials()  # long time                       # optional - sage.combinat sage.modules
sage: len(UP)  # long time                                              # optional - sage.combinat sage.modules
450
sage: UP[al[2], al[1], -al[1]]  # long time                             # optional - sage.combinat sage.modules
X0_7*X4_1 - X0_1*X4_7 - 2*X0_7*X5_1 + 2*X0_1*X5_7 + X2_7*X7_1
 - X2_1*X7_7 - X3_7*X8_1 + X3_1*X8_7 + X0_4
class Subobjects(category, *args)#

Bases: SubobjectsCategory

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

class ParentMethods#

Bases: object

ambient()#

Return the ambient Lie algebra of self.

EXAMPLES:

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

Return the basis matrix of self.

EXAMPLES:

sage: C = LieAlgebras(QQ).FiniteDimensional().WithBasis()
sage: L = C.example()                                               # optional - sage.combinat sage.modules
sage: a, b, c = L.lie_algebra_generators()                          # optional - sage.combinat sage.modules
sage: S = L.subalgebra([2*a + b, b + c])                            # optional - sage.combinat sage.modules
sage: S.basis_matrix()                                              # optional - sage.combinat sage.modules
[   1    0 -1/2]
[   0    1    1]
example(n=3)#

Return an example of a finite dimensional Lie algebra with basis as per Category.example.

EXAMPLES:

sage: C = LieAlgebras(QQ).FiniteDimensional().WithBasis()
sage: C.example()                                                           # optional - sage.modules
An example of a finite dimensional Lie algebra with basis:
 the 3-dimensional abelian Lie algebra over Rational Field

Other dimensions can be specified as an optional argument:

sage: C.example(5)                                                          # optional - sage.modules
An example of a finite dimensional Lie algebra with basis:
 the 5-dimensional abelian Lie algebra over Rational Field