# Subalgebras and ideals of Lie algebras#

AUTHORS:

• Eero Hakavuori (2018-08-29): initial version

class sage.algebras.lie_algebras.subalgebra.LieSubalgebra_finite_dimensional_with_basis(ambient, gens, ideal, order=None, category=None)#

A Lie subalgebra of a finite dimensional Lie algebra with basis.

INPUT:

• ambient – the Lie algebra containing the subalgebra

• gens – a list of generators of the subalgebra

• ideal – (default: False) a boolean; if True, then gens is interpreted as the generating set of an ideal instead of a subalgebra

• order – (optional) the key used to sort the indices of ambient

• category – (optional) a subcategory of subobjects of finite dimensional Lie algebras with basis

EXAMPLES:

Subalgebras and ideals are defined by giving a list of generators:

sage: L = lie_algebras.Heisenberg(QQ, 1)
sage: X, Y, Z = L.basis()
sage: S =  L.subalgebra([X, Z]); S
Subalgebra generated by (p1, z) of Heisenberg algebra of rank 1 over Rational Field
sage: I =  L.ideal([X, Z]); I
Ideal (p1, z) of Heisenberg algebra of rank 1 over Rational Field


An ideal is in general larger than the subalgebra with the same generators:

sage: S = L.subalgebra(Y)
sage: S.basis()
Family (q1,)
sage: I = L.ideal(Y)
sage: I.basis()
Family (q1, z)


The zero dimensional subalgebra can be created by giving 0 as a generator or with an empty list of generators:

sage: L.<X,Y,Z> = LieAlgebra(QQ, {('X','Y'): {'Z': 1}})
sage: S1 = L.subalgebra(0)
sage: S2 = L.subalgebra([])
sage: S1 is S2
True
sage: S1.basis()
Family ()


Elements of the ambient Lie algebra can be reduced modulo an ideal or subalgebra:

sage: L.<X,Y,Z> = LieAlgebra(SR, {('X','Y'): {'Z': 1}})
sage: I = L.ideal(Y)
sage: I.reduce(X + 2*Y + 3*Z)
X
sage: S = L.subalgebra(Y)
sage: S.reduce(X + 2*Y + 3*Z)
X + 3*Z


The reduction gives elements in a fixed complementary subspace. When the base ring is a field, the complementary subspace is spanned by those basis elements which are not leading supports of the basis:

sage: I =  L.ideal(X + Y)
sage: I.basis()
Family (X + Y, Z)
sage: el = var('x')*X + var('y')*Y + var('z')*Z; el
x*X + y*Y + z*Z
sage: I.reduce(el)
(x-y)*X


Giving a different order may change the reduction of elements:

sage: I =  L.ideal(X + Y, order=lambda s: ['Z','Y','X'].index(s))
sage: I.basis()
Family (Z, X + Y)
sage: I.reduce(el)
(-x+y)*Y


A subalgebra of a subalgebra is a subalgebra of the original:

sage: sc = {('X','Y'): {'Z': 1}, ('X','Z'): {'W': 1}}
sage: L.<X,Y,Z,W> = LieAlgebra(QQ, sc)
sage: S1 = L.subalgebra([Y, Z, W]); S1
Subalgebra generated by (Y, Z, W) of Lie algebra on 4 generators (X, Y, Z, W) over Rational Field
sage: S2 = S1.subalgebra(S1.gens()[1:]); S2
Subalgebra generated by (Z, W) of Lie algebra on 4 generators (X, Y, Z, W) over Rational Field
sage: S3 = S2.subalgebra(S2.gens()[1:]); S3
Subalgebra generated by (W) of Lie algebra on 4 generators (X, Y, Z, W) over Rational Field


An ideal of an ideal is not necessarily an ideal of the original:

sage: I = L.ideal(Y); I
Ideal (Y) of Lie algebra on 4 generators (X, Y, Z, W) over Rational Field
sage: J = I.ideal(Z); J
Ideal (Z) of Ideal (Y) of Lie algebra on 4 generators (X, Y, Z, W) over Rational Field
sage: J.basis()
Family (Z,)
sage: J.is_ideal(L)
False
sage: K = L.ideal(J.basis().list())
sage: K.basis()
Family (Z, W)

class Element#

Return the matrix of the adjoint action of self.

EXAMPLES:

sage: MS = MatrixSpace(QQ, 2)
sage: m = MS([[0, -1], [1, 0]])
sage: L = LieAlgebra(associative=MS)
sage: S = L.subalgebra([m])
sage: x = S.basis()
sage: x.parent() is S
True


sage: m1 = MS([[0, 1], [0, 0]])
sage: m2 = MS([[0, 0], [1, 0]])
sage: S = L.subalgebra([m1, m2])
sage: e,f = S.lie_algebra_generators()
sage: ascii_art([b.value.value for b in S.basis()])
[ [0 1]  [0 0]  [-1  0] ]
[ [0 0], [1 0], [ 0  1] ]
[ 0  0  2]
[ 0  0  0]
[ 0 -1  0]
[ 0  0  0]
[ 0  0 -2]
[ 1  0  0]
sage: h = e.bracket(f)
sage: E * F - F * E == h.adjoint_matrix()
True

ambient()#

Return the ambient Lie algebra of self.

EXAMPLES:

sage: L.<x,y> = LieAlgebra(QQ, abelian=True)
sage: S = L.subalgebra(x)
sage: S.ambient() is L
True

basis()#

Return a basis of self.

EXAMPLES:

A basis of a subalgebra:

sage: sc = {('a','b'): {'c': 1}, ('a','c'): {'d': 1}}
sage: L.<a,b,c,d> = LieAlgebra(QQ, sc)
sage: L.subalgebra([a + b, c + d]).basis()
Family (a + b, c, d)


A basis of an ideal:

sage: sc = {('x','y'): {'z': 1}, ('x','z'): {'w': 1}}
sage: L.<x,y,z,w> = LieAlgebra(QQ, sc)
sage: L.ideal([x + y + z + w]).basis()
Family (x + y, z, w)


This also works for Lie algebras whose natural basis elements are not comparable (but have a well-defined basis ordering):

sage: sl3 = LieAlgebra(QQ, cartan_type=['A',2])
sage: D = sl3.derived_subalgebra()
sage: len(D.basis())
8
sage: e = list(sl3.e())
sage: sl3.ideal(e).dimension()
8
sage: sl3.subalgebra(e).dimension()
3

basis_matrix()#

Return the basis matrix of self as a submodule of the ambient Lie algebra.

EXAMPLES:

sage: L.<X,Y,Z> = LieAlgebra(ZZ, {('X','Y'): {'Z': 3}})
sage: S1 = L.subalgebra([4*X + Y, Y])
sage: S1.basis_matrix()
[ 4  0  0]
[ 0  1  0]
[ 0  0 12]
sage: K.<X,Y,Z> = LieAlgebra(QQ, {('X','Y'): {'Z': 3}})
sage: S2 = K.subalgebra([4*X + Y, Y])
sage: S2.basis_matrix()
[1 0 0]
[0 1 0]
[0 0 1]

from_vector(v, order=None, coerce=False)#

Return the element of self corresponding to the vector v

INPUT:

• v – a vector in self.module() or self.ambient().module()

EXAMPLES:

An element from a vector of the intrinsic module:

sage: L.<X,Y,Z> = LieAlgebra(ZZ, abelian=True)
sage: L.dimension()
3
sage: S = L.subalgebra([X, Y])
sage: S.dimension()
2
sage: el = S.from_vector([1, 2]); el
X + 2*Y
sage: el.parent() == S
True


An element from a vector of the ambient module

sage: el = S.from_vector([1, 2, 0]); el X + 2*Y sage: el.parent() == S True

gens()#

Return the generating set of self.

EXAMPLES:

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

indices()#

Return the set of indices for the basis of self.

EXAMPLES:

sage: L.<x,y,z> = LieAlgebra(QQ, abelian=True)
sage: S = L.subalgebra([x, y])
sage: S.indices()
{0, 1}
sage: [S.basis()[k] for k in S.indices()]
[x, y]

is_ideal(A)#

Return if self is an ideal of A.

EXAMPLES:

Some subalgebras are ideals:

sage: L.<x,y,z> = LieAlgebra(QQ, {('x','y'): {'z': 1}})
sage: S1 = L.subalgebra([x])
sage: S1.is_ideal(L)
False
sage: S2 = L.subalgebra([x, y])
sage: S2.is_ideal(L)
True
sage: S3 = L.subalgebra([y, z])
sage: S3.is_ideal(L)
True


All ideals are ideals:

sage: L.<x,y> = LieAlgebra(QQ, {('x','y'): {'x': 1}})
sage: I = L.ideal(x)
sage: I.is_ideal(L)
True
sage: I.is_ideal(I)
True


Return the set of leading monomials of the basis of self.

EXAMPLES:

A basis of an ideal and the corresponding leading monomials:

sage: sc = {('a','b'): {'c': 2}, ('a','c'): {'d': 4}}
sage: L.<a,b,c,d> = LieAlgebra(ZZ, sc)
sage: I = L.ideal(a + b)
sage: I.basis()
Family (a + b, 2*c, 4*d)
Family (b, c, d)


A different ordering can give different leading monomials:

sage: key = lambda s: ['d','c','b','a'].index(s)
sage: I = L.ideal(a + b, order=key)
sage: I.basis()
Family (4*d, 2*c, a + b)
Family (d, c, a)

lie_algebra_generators()#

Return the generating set of self as a Lie algebra.

EXAMPLES:

The Lie algebra generators of a subalgebra are the original generators:

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


The Lie algebra generators of an ideal is usually a larger set:

sage: I = L.ideal(x)
sage: I.lie_algebra_generators()
Family (x, z)

lift(X)#

Coerce an element X of self into the ambient Lie algebra.

INPUT:

• X – an element of self

EXAMPLES:

sage: L.<x,y> = LieAlgebra(QQ, abelian=True)
sage: S = L.subalgebra(x)
sage: sx = S(x); sx
x
sage: sx.parent()
Subalgebra generated by (x) of Abelian Lie algebra on 2 generators (x, y) over Rational Field
sage: a = S.lift(sx); a
x
sage: a.parent()
Abelian Lie algebra on 2 generators (x, y) over Rational Field

module(sparse=False)#

Return the submodule of the ambient Lie algebra corresponding to self.

EXAMPLES:

sage: L.<X,Y,Z> = LieAlgebra(ZZ, {('X','Y'): {'Z': 3}})
sage: S = L.subalgebra([X, Y])
sage: S.module()
Free module of degree 3 and rank 3 over Integer Ring
User basis matrix:
[1 0 0]
[0 1 0]
[0 0 3]

reduce(X)#

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


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


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

retract(X)#

Retract X to self.

INPUT:

• X – an element of the ambient Lie algebra

EXAMPLES:

Retraction to a subalgebra of a free nilpotent Lie algebra:

sage: L = LieAlgebra(QQ, 3, step=2)
sage: L.inject_variables()
Defining X_1, X_2, X_3, X_12, X_13, X_23
sage: S = L.subalgebra([X_1, X_2])
sage: el = S.retract(2*X_1 + 3*X_2 + 5*X_12); el
2*X_1 + 3*X_2 + 5*X_12
sage: el.parent()
Subalgebra generated by (X_1, X_2) of Free Nilpotent Lie algebra on
6 generators (X_1, X_2, X_3, X_12, X_13, X_23) over Rational Field


Retraction raises an error if the element is not contained in the subalgebra:

sage: S.retract(X_3)
Traceback (most recent call last):
...
ValueError: the element X_3 is not in Subalgebra generated
by (X_1, X_2) of Free Nilpotent Lie algebra on 6 generators
(X_1, X_2, X_3, X_12, X_13, X_23) over Rational Field

zero()#

Return the element $$0$$.

EXAMPLES:

sage: L.<x,y> = LieAlgebra(QQ, abelian=True)
sage: S = L.subalgebra(x)
sage: S.zero()
0
sage: S.zero() == S(L.zero())
True