Classical Lie Algebras

These are the Lie algebras corresponding to types \(A_n\), \(B_n\), \(C_n\), and \(D_n\). We also include support for the exceptional types \(E_{6,7,8}\), \(F_4\), and \(G_2\) in the Chevalley basis, and we give the matrix representation given in [HRT2000].

AUTHORS:

  • Travis Scrimshaw (2013-05-03): Initial version
  • Sebastian Oehms (2018-03-18): matrix method of the element class of ClassicalMatrixLieAlgebra added
class sage.algebras.lie_algebras.classical_lie_algebra.ClassicalMatrixLieAlgebra(R, ct, e, f, h)

Bases: sage.algebras.lie_algebras.lie_algebra.LieAlgebraFromAssociative

A classical Lie algebra represented using matrices.

INPUT:

  • R – the base ring
  • ct – the finite Cartan type

EXAMPLES:

sage: lie_algebras.ClassicalMatrix(QQ, ['A', 4])
Special linear Lie algebra of rank 5 over Rational Field
sage: lie_algebras.ClassicalMatrix(QQ, CartanType(['B',4]))
Special orthogonal Lie algebra of rank 9 over Rational Field
sage: lie_algebras.ClassicalMatrix(QQ, 'C4')
Symplectic Lie algebra of rank 8 over Rational Field
sage: lie_algebras.ClassicalMatrix(QQ, cartan_type=['D',4])
Special orthogonal Lie algebra of rank 8 over Rational Field
class Element

Bases: sage.algebras.lie_algebras.lie_algebra.LieAlgebraFromAssociative.Element

matrix()

Return self as element of the underlying matrix algebra.

OUTPUT:

An instance of the element class of MatrixSpace.

EXAMPLES:

sage: sl3m = lie_algebras.sl(ZZ, 3, representation='matrix')
sage: e1,e2, f1, f2, h1, h2 = sl3m.gens()
sage: h1m = h1.matrix(); h1m
[ 1  0  0]
[ 0 -1  0]
[ 0  0  0]
sage: h1m.parent()
Full MatrixSpace of 3 by 3 sparse matrices over Integer Ring
sage: matrix(h2)
[ 0  0  0]
[ 0  1  0]
[ 0  0 -1]
sage: L = lie_algebras.so(QQ['z'], 5, representation='matrix')
sage: matrix(L.an_element())
[ 1  1  0  0  0]
[ 1  1  0  0  2]
[ 0  0 -1 -1  0]
[ 0  0 -1 -1 -1]
[ 0  1  0 -2  0]
affine(kac_moody=False)

Return the affine (Kac-Moody) Lie algebra of self.

EXAMPLES:

sage: so5 = lie_algebras.so(QQ, 5, 'matrix')
sage: so5
Special orthogonal Lie algebra of rank 5 over Rational Field
sage: so5.affine()
Affine Special orthogonal Kac-Moody algebra of rank 5 over Rational Field
basis()

Return a basis of self.

EXAMPLES:

sage: M = LieAlgebra(ZZ, cartan_type=['A',2], representation='matrix')
sage: list(M.basis())
[
[ 1  0  0]  [0 1 0]  [0 0 1]  [0 0 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 1]  [0 0 0]
[ 0  0 -1], [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]
]
cartan_type()

Return the Cartan type of self.

EXAMPLES:

sage: g = lie_algebras.sl(QQ, 3, representation='matrix')
sage: g.cartan_type()
['A', 2]
e(i)

Return the generator \(e_i\).

EXAMPLES:

sage: g = lie_algebras.sl(QQ, 3, representation='matrix')
sage: g.e(2)
[0 0 0]
[0 0 1]
[0 0 0]
epsilon(i, h)

Return the action of the functional \(\varepsilon_i \colon \mathfrak{h} \to R\), where \(R\) is the base ring of self, on the element h.

EXAMPLES:

sage: g = lie_algebras.sl(QQ, 3, representation='matrix')
sage: g.epsilon(1, g.h(1))
1
sage: g.epsilon(2, g.h(1))
-1
sage: g.epsilon(3, g.h(1))
0
f(i)

Return the generator \(f_i\).-

EXAMPLES:

sage: g = lie_algebras.sl(QQ, 3, representation='matrix')
sage: g.f(2)
[0 0 0]
[0 0 0]
[0 1 0]
h(i)

Return the generator \(h_i\).

EXAMPLES:

sage: g = lie_algebras.sl(QQ, 3, representation='matrix')
sage: g.h(2)
[ 0  0  0]
[ 0  1  0]
[ 0  0 -1]
highest_root_basis_elt(pos=True)

Return the basis element corresponding to the highest root \(\theta\). If pos is True, then returns \(e_{\theta}\), otherwise it returns \(f_{\theta}\).

EXAMPLES:

sage: g = lie_algebras.sl(QQ, 3, representation='matrix')
sage: g.highest_root_basis_elt()
[0 0 1]
[0 0 0]
[0 0 0]
index_set()

Return the index_set of self.

EXAMPLES:

sage: g = lie_algebras.sl(QQ, 3, representation='matrix')
sage: g.index_set()
(1, 2)
simple_root(i, h)

Return the action of the simple root \(\alpha_i \colon \mathfrak{h} \to R\), where \(R\) is the base ring of self, on the element h.

EXAMPLES:

sage: g = lie_algebras.sl(QQ, 3, representation='matrix')
sage: g.simple_root(1, g.h(1))
2
sage: g.simple_root(1, g.h(2))
-1
class sage.algebras.lie_algebras.classical_lie_algebra.ExceptionalMatrixLieAlgebra(R, cartan_type, e, f, h=None)

Bases: sage.algebras.lie_algebras.classical_lie_algebra.ClassicalMatrixLieAlgebra

A matrix Lie algebra of exceptional type.

class sage.algebras.lie_algebras.classical_lie_algebra.LieAlgebraChevalleyBasis(R, cartan_type)

Bases: sage.algebras.lie_algebras.structure_coefficients.LieAlgebraWithStructureCoefficients

A simple finite dimensional Lie algebra in the Chevalley basis.

Let \(L\) be a simple (complex) Lie algebra with roots \(\Phi\), then the Chevalley basis is given by \(e_{\alpha}\) for all \(\alpha \in \Phi\) and \(h_{\alpha_i} := h_i\) where \(\alpha_i\) is a simple root subject. These generators are subject to the relations:

\[\begin{split}\begin{aligned} [h_i, h_j] & = 0 \\ [h_i, e_{\beta}] & = A_{\alpha_i, \beta} e_{\beta} \\ [e_{\beta}, e_{-\beta}] & = \sum_i A_{\beta, \alpha_i} h_i \\ [e_{\beta}, e_{\gamma}] & = \begin{cases} N_{\beta,\gamma} e_{\beta + \gamma} & \beta + \gamma \in \Phi \\ 0 & \text{otherwise.} \end{cases} \end{aligned}\end{split}\]

where \(A_{\alpha, \beta} = \frac{2 (\alpha, \beta)}{(\alpha, \alpha)}\) and \(N_{\alpha, \beta}\) is the maximum such that \(\alpha - N_{\alpha, \beta} \beta \in \Phi\).

For computing the signs of the coefficients, see Section 3 of [CMT2003].

affine(kac_moody=False)

Return the affine Lie algebra of self.

EXAMPLES:

sage: sp6 = lie_algebras.sp(QQ, 6)
sage: sp6
Lie algebra of ['C', 3] in the Chevalley basis
sage: sp6.affine()
Affine Kac-Moody algebra of ['C', 3] in the Chevalley basis
degree_on_basis(m)

Return the degree of the basis element indexed by m.

EXAMPLES:

sage: L = LieAlgebra(QQ, cartan_type=['G', 2])
sage: [L.degree_on_basis(m) for m in L.basis().keys()]
[alpha[2], alpha[1], alpha[1] + alpha[2],
 2*alpha[1] + alpha[2], 3*alpha[1] + alpha[2],
 3*alpha[1] + 2*alpha[2],
 0, 0,
 -alpha[2], -alpha[1], -alpha[1] - alpha[2],
 -2*alpha[1] - alpha[2], -3*alpha[1] - alpha[2],
 -3*alpha[1] - 2*alpha[2]]
gens()

Return the generators of self in the order of \(e_i\), \(f_i\), and \(h_i\).

EXAMPLES:

sage: L = LieAlgebra(QQ, cartan_type=['A', 2])
sage: L.gens()
(E[alpha[1]], E[alpha[2]], E[-alpha[1]], E[-alpha[2]], h1, h2)
highest_root_basis_elt(pos=True)

Return the basis element corresponding to the highest root \(\theta\).

INPUT:

  • pos – (default: True) if True, then return \(e_{\theta}\), otherwise return \(f_{\theta}\)

EXAMPLES:

sage: L = LieAlgebra(QQ, cartan_type=['A', 2])
sage: L.highest_root_basis_elt()
E[alpha[1] + alpha[2]]
sage: L.highest_root_basis_elt(False)
E[-alpha[1] - alpha[2]]
indices_to_positive_roots_map()

Return the map from indices to positive roots.

EXAMPLES:

sage: L = LieAlgebra(QQ, cartan_type=['A', 2])
sage: L.indices_to_positive_roots_map()
{1: alpha[1], 2: alpha[2], 3: alpha[1] + alpha[2]}
lie_algebra_generators(str_keys=False)

Return the Chevalley Lie algebra generators of self.

INPUT:

  • str_keys – (default: False) set to True to have the indices indexed by strings instead of simple (co)roots

EXAMPLES:

sage: L = LieAlgebra(QQ, cartan_type=['A', 1])
sage: L.lie_algebra_generators()
Finite family {alpha[1]: E[alpha[1]], -alpha[1]: E[-alpha[1]], alphacheck[1]: h1}
sage: L.lie_algebra_generators(True)
Finite family {'e1': E[alpha[1]], 'f1': E[-alpha[1]], 'h1': h1}
class sage.algebras.lie_algebras.classical_lie_algebra.e6(R)

Bases: sage.algebras.lie_algebras.classical_lie_algebra.ExceptionalMatrixLieAlgebra

The matrix Lie algebra \(\mathfrak{e}_6\).

The simple Lie algebra \(\mathfrak{e}_6\) of type \(E_6\). The matrix representation is given following [HRT2000].

class sage.algebras.lie_algebras.classical_lie_algebra.f4(R)

Bases: sage.algebras.lie_algebras.classical_lie_algebra.ExceptionalMatrixLieAlgebra

The matrix Lie algebra \(\mathfrak{f}_4\).

The simple Lie algebra \(\mathfrak{f}_f\) of type \(F_4\). The matrix representation is given following [HRT2000] but indexed in the reversed order (i.e., interchange 1 with 4 and 2 with 3).

class sage.algebras.lie_algebras.classical_lie_algebra.g2(R)

Bases: sage.algebras.lie_algebras.classical_lie_algebra.ExceptionalMatrixLieAlgebra

The matrix Lie algebra \(\mathfrak{g}_2\).

The simple Lie algebra \(\mathfrak{g}_2\) of type \(G_2\). The matrix representation is given following [HRT2000].

class sage.algebras.lie_algebras.classical_lie_algebra.gl(R, n)

Bases: sage.algebras.lie_algebras.lie_algebra.LieAlgebraFromAssociative

The matrix Lie algebra \(\mathfrak{gl}_n\).

The Lie algebra \(\mathfrak{gl}_n\) which consists of all \(n \times n\) matrices.

INPUT:

  • R – the base ring
  • n – the size of the matrix
class Element

Bases: sage.algebras.lie_algebras.classical_lie_algebra.ClassicalMatrixLieAlgebra.Element

monomial_coefficients(copy=True)

Return the monomial coefficients of self.

EXAMPLES:

sage: gl4 = lie_algebras.gl(QQ, 4)
sage: x = gl4.monomial('E_2_1') + 3*gl4.monomial('E_0_3')
sage: x.monomial_coefficients()
{'E_0_3': 3, 'E_2_1': 1}
basis()

Return the basis of self.

EXAMPLES:

sage: g = lie_algebras.gl(QQ, 2)
sage: tuple(g.basis())
(
[1 0]  [0 1]  [0 0]  [0 0]
[0 0], [0 0], [1 0], [0 1]
)
killing_form(x, y)

Return the Killing form on x and y.

The Killing form on \(\mathfrak{gl}_n\) is:

\[\langle x \mid y \rangle = 2n \mathrm{tr}(xy) - 2 \mathrm{tr}(x) \mathrm{tr}(y).\]

EXAMPLES:

sage: g = lie_algebras.gl(QQ, 4)
sage: x = g.an_element()
sage: y = g.gens()[1]
sage: g.killing_form(x, y)
8
monomial(i)

Return the basis element indexed by i.

INPUT:

  • i – an element of the index set

EXAMPLES:

sage: gl4 = lie_algebras.gl(QQ, 4)
sage: gl4.monomial('E_2_1')
[0 0 0 0]
[0 0 0 0]
[0 1 0 0]
[0 0 0 0]
sage: gl4.monomial((2,1))
[0 0 0 0]
[0 0 0 0]
[0 1 0 0]
[0 0 0 0]
class sage.algebras.lie_algebras.classical_lie_algebra.sl(R, n)

Bases: sage.algebras.lie_algebras.classical_lie_algebra.ClassicalMatrixLieAlgebra

The matrix Lie algebra \(\mathfrak{sl}_n\).

The Lie algebra \(\mathfrak{sl}_n\), which consists of all \(n \times n\) matrices with trace 0. This is the Lie algebra of type \(A_{n-1}\).

killing_form(x, y)

Return the Killing form on x and y.

The Killing form on \(\mathfrak{sl}_n\) is:

\[\langle x \mid y \rangle = 2n \mathrm{tr}(xy).\]

EXAMPLES:

sage: g = lie_algebras.sl(QQ, 5, representation='matrix')
sage: x = g.an_element()
sage: y = g.lie_algebra_generators()['e1']
sage: g.killing_form(x, y)
10
simple_root(i, h)

Return the action of the simple root \(\alpha_i \colon \mathfrak{h} \to R\), where \(R\) is the base ring of self, on the element j.

EXAMPLES:

sage: g = lie_algebras.sl(QQ, 5, representation='matrix')
sage: matrix([[g.simple_root(i, g.h(j)) for i in g.index_set()] for j in g.index_set()])
[ 2 -1  0  0]
[-1  2 -1  0]
[ 0 -1  2 -1]
[ 0  0 -1  2]
class sage.algebras.lie_algebras.classical_lie_algebra.so(R, n)

Bases: sage.algebras.lie_algebras.classical_lie_algebra.ClassicalMatrixLieAlgebra

The matrix Lie algebra \(\mathfrak{so}_n\).

The Lie algebra \(\mathfrak{so}_n\), which consists of all real anti-symmetric \(n \times n\) matrices. This is the Lie algebra of type \(B_{(n-1)/2}\) or \(D_{n/2}\) if \(n\) is odd or even respectively.

killing_form(x, y)

Return the Killing form on x and y.

The Killing form on \(\mathfrak{so}_n\) is:

\[\langle x \mid y \rangle = (n - 2) \mathrm{tr}(xy).\]

EXAMPLES:

sage: g = lie_algebras.so(QQ, 8, representation='matrix')
sage: x = g.an_element()
sage: y = g.lie_algebra_generators()['e1']
sage: g.killing_form(x, y)
12
sage: g = lie_algebras.so(QQ, 9, representation='matrix')
sage: x = g.an_element()
sage: y = g.lie_algebra_generators()['e1']
sage: g.killing_form(x, y)
14
simple_root(i, h)

Return the action of the simple root \(\alpha_i \colon \mathfrak{h} \to R\), where \(R\) is the base ring of self, on the element j.

EXAMPLES:

The even or type \(D\) case:

sage: g = lie_algebras.so(QQ, 8, representation='matrix')
sage: matrix([[g.simple_root(i, g.h(j)) for i in g.index_set()] for j in g.index_set()])
[ 2 -1  0  0]
[-1  2 -1 -1]
[ 0 -1  2  0]
[ 0 -1  0  2]

The odd or type \(B\) case:

sage: g = lie_algebras.so(QQ, 9, representation='matrix')
sage: matrix([[g.simple_root(i, g.h(j)) for i in g.index_set()] for j in g.index_set()])
[ 2 -1  0  0]
[-1  2 -1  0]
[ 0 -1  2 -1]
[ 0  0 -2  2]
class sage.algebras.lie_algebras.classical_lie_algebra.sp(R, n)

Bases: sage.algebras.lie_algebras.classical_lie_algebra.ClassicalMatrixLieAlgebra

The matrix Lie algebra \(\mathfrak{sp}_n\).

The Lie algebra \(\mathfrak{sp}_{2k}\), which consists of all \(2k \times 2k\) matrices \(X\) that satisfy the equation:

\[X^T M - M X = 0\]

where

\[\begin{split}M = \begin{pmatrix} 0 & I_k \\ -I_k & 0 \end{pmatrix}.\end{split}\]

This is the Lie algebra of type \(C_k\).

killing_form(x, y)

Return the Killing form on x and y.

The Killing form on \(\mathfrak{sp}_n\) is:

\[\langle x \mid y \rangle = (2n + 2) \mathrm{tr}(xy).\]

EXAMPLES:

sage: g = lie_algebras.sp(QQ, 8, representation='matrix')
sage: x = g.an_element()
sage: y = g.lie_algebra_generators()['e1']
sage: g.killing_form(x, y)
36
simple_root(i, h)

Return the action of the simple root \(\alpha_i \colon \mathfrak{h} \to R\), where \(R\) is the base ring of self, on the element j.

EXAMPLES:

sage: g = lie_algebras.sp(QQ, 8, representation='matrix')
sage: matrix([[g.simple_root(i, g.h(j)) for i in g.index_set()] for j in g.index_set()])
[ 2 -1  0  0]
[-1  2 -1  0]
[ 0 -1  2 -2]
[ 0  0 -1  2]