Examples of Lie Algebras

There are the following examples of Lie algebras:

• A rather comprehensive family of 3-dimensional Lie algebras

• The Lie algebra of affine transformations of the line

• All abelian Lie algebras on free modules

• The Lie algebra of upper triangular matrices

• The Lie algebra of strictly upper triangular matrices

• The symplectic derivation Lie algebra

• The rank two Heisenberg Virasoro algebra

See also sage.algebras.lie_algebras.virasoro.LieAlgebraRegularVectorFields and sage.algebras.lie_algebras.virasoro.VirasoroAlgebra for other examples.

AUTHORS:

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

sage.algebras.lie_algebras.examples.Heisenberg(R, n, representation='structure')

Return the rank n Heisenberg algebra in the given representation.

INPUT:

• R – the base ring

• n – the rank (a nonnegative integer or infinity)

• representation – (default: 'structure') can be one of the following:

  • 'structure' – using structure coefficients

  • 'matrix' – using matrices

EXAMPLES:

Sage

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

Python

>>> from sage.all import *
>>> lie_algebras.Heisenberg(QQ, Integer(3))
Heisenberg algebra of rank 3 over Rational Field

Sage Live

lie_algebras.Heisenberg(QQ, 3)

sage.algebras.lie_algebras.examples.abelian(R, names=None, index_set=None)

Return the abelian Lie algebra generated by names.

EXAMPLES:

Sage

sage: lie_algebras.abelian(QQ, 'x, y, z')
Abelian Lie algebra on 3 generators (x, y, z) over Rational Field

Python

>>> from sage.all import *
>>> lie_algebras.abelian(QQ, 'x, y, z')
Abelian Lie algebra on 3 generators (x, y, z) over Rational Field

Sage Live

lie_algebras.abelian(QQ, 'x, y, z')

sage.algebras.lie_algebras.examples.affine_transformations_line(R, names=['X', 'Y'], representation='bracket')

The Lie algebra of affine transformations of the line.

EXAMPLES:

Sage

sage: L = lie_algebras.affine_transformations_line(QQ)
sage: L.structure_coefficients()
Finite family {('X', 'Y'): Y}
sage: X, Y = L.lie_algebra_generators()
sage: L[X, Y] == Y
True
sage: TestSuite(L).run()
sage: L = lie_algebras.affine_transformations_line(QQ, representation='matrix')
sage: X, Y = L.lie_algebra_generators()
sage: L[X, Y] == Y
True
sage: TestSuite(L).run()

Python

>>> from sage.all import *
>>> L = lie_algebras.affine_transformations_line(QQ)
>>> L.structure_coefficients()
Finite family {('X', 'Y'): Y}
>>> X, Y = L.lie_algebra_generators()
>>> L[X, Y] == Y
True
>>> TestSuite(L).run()
>>> L = lie_algebras.affine_transformations_line(QQ, representation='matrix')
>>> X, Y = L.lie_algebra_generators()
>>> L[X, Y] == Y
True
>>> TestSuite(L).run()

Sage Live

L = lie_algebras.affine_transformations_line(QQ)
L.structure_coefficients()
X, Y = L.lie_algebra_generators()
L[X, Y] == Y
TestSuite(L).run()
L = lie_algebras.affine_transformations_line(QQ, representation='matrix')
X, Y = L.lie_algebra_generators()
L[X, Y] == Y
TestSuite(L).run()

sage.algebras.lie_algebras.examples.cross_product(R, names=['X', 'Y', 'Z'])

The Lie algebra of ${\mathbf{R}}^3$ defined by the usual cross product $\times$.

EXAMPLES:

Sage

sage: L = lie_algebras.cross_product(QQ)
sage: L.structure_coefficients()
Finite family {('X', 'Y'): Z, ('X', 'Z'): -Y, ('Y', 'Z'): X}
sage: TestSuite(L).run()

Python

>>> from sage.all import *
>>> L = lie_algebras.cross_product(QQ)
>>> L.structure_coefficients()
Finite family {('X', 'Y'): Z, ('X', 'Z'): -Y, ('Y', 'Z'): X}
>>> TestSuite(L).run()

Sage Live

L = lie_algebras.cross_product(QQ)
L.structure_coefficients()
TestSuite(L).run()

sage.algebras.lie_algebras.examples.pwitt(R, p)

Return the $p$-Witt Lie algebra over $R$.

INPUT:

• R – the base ring

• p – positive integer that is $0$ in $R$

EXAMPLES:

Sage

sage: lie_algebras.pwitt(GF(5), 5)
The 5-Witt Lie algebra over Finite Field of size 5

Python

>>> from sage.all import *
>>> lie_algebras.pwitt(GF(Integer(5)), Integer(5))
The 5-Witt Lie algebra over Finite Field of size 5

Sage Live

lie_algebras.pwitt(GF(5), 5)

sage.algebras.lie_algebras.examples.regular_vector_fields(R)

Return the Lie algebra of regular vector fields on ${\mathbf{C}}^{\times }$.

This is also known as the Witt (Lie) algebra.

See also

LieAlgebraRegularVectorFields

EXAMPLES:

Sage

sage: lie_algebras.regular_vector_fields(QQ)
The Lie algebra of regular vector fields over Rational Field

Python

>>> from sage.all import *
>>> lie_algebras.regular_vector_fields(QQ)
The Lie algebra of regular vector fields over Rational Field

Sage Live

lie_algebras.regular_vector_fields(QQ)

sage.algebras.lie_algebras.examples.sl(R, n, representation='bracket')

The Lie algebra ${\mathfrak{sl}}_n$.

The Lie algebra ${\mathfrak{sl}}_n$ is the type $A_{n-1}$ Lie algebra and is finite dimensional. As a matrix Lie algebra, it is given by the set of all $n\times n$ matrices with trace 0.

INPUT:

• R – the base ring

• n – the size of the matrix

• representation – (default: 'bracket') can be one of the following:

  • 'bracket' – use brackets and the Chevalley basis

  • 'matrix' – use matrices

EXAMPLES:

We first construct ${\mathfrak{sl}}_2$ using the Chevalley basis:

Sage

sage: sl2 = lie_algebras.sl(QQ, 2); sl2
Lie algebra of ['A', 1] in the Chevalley basis
sage: E,F,H = sl2.gens()
sage: E.bracket(F) == H
True
sage: H.bracket(E) == 2*E
True
sage: H.bracket(F) == -2*F
True

Python

>>> from sage.all import *
>>> sl2 = lie_algebras.sl(QQ, Integer(2)); sl2
Lie algebra of ['A', 1] in the Chevalley basis
>>> E,F,H = sl2.gens()
>>> E.bracket(F) == H
True
>>> H.bracket(E) == Integer(2)*E
True
>>> H.bracket(F) == -Integer(2)*F
True

Sage Live

sl2 = lie_algebras.sl(QQ, 2); sl2
E,F,H = sl2.gens()
E.bracket(F) == H
H.bracket(E) == 2*E
H.bracket(F) == -2*F

We now construct ${\mathfrak{sl}}_2$ as a matrix Lie algebra:

Sage

sage: sl2 = lie_algebras.sl(QQ, 2, representation='matrix')
sage: E,F,H = sl2.gens()
sage: E.bracket(F) == H
True
sage: H.bracket(E) == 2*E
True
sage: H.bracket(F) == -2*F
True

Python

>>> from sage.all import *
>>> sl2 = lie_algebras.sl(QQ, Integer(2), representation='matrix')
>>> E,F,H = sl2.gens()
>>> E.bracket(F) == H
True
>>> H.bracket(E) == Integer(2)*E
True
>>> H.bracket(F) == -Integer(2)*F
True

Sage Live

sl2 = lie_algebras.sl(QQ, 2, representation='matrix')
E,F,H = sl2.gens()
E.bracket(F) == H
H.bracket(E) == 2*E
H.bracket(F) == -2*F

sage.algebras.lie_algebras.examples.so(R, n, representation='bracket')

The Lie algebra ${\mathfrak{so}}_n$.

The Lie algebra ${\mathfrak{so}}_n$ is the type $B_k$ Lie algebra if $n=2k-1$ or the type $D_k$ Lie algebra if $n=2k$, and in either case is finite dimensional.

A classical description of this as a matrix Lie algebra is the set of all anti-symmetric $n\times n$ matrices. However, the implementation here uses a different bilinear form for the Lie group and follows the description in Chapter 8 of [HK2002]. See sage.algebras.lie_algebras.classical_lie_algebra.so for a precise description.

INPUT:

• R – the base ring

• n – the size of the matrix

• representation – (default: 'bracket') can be one of the following:

  • 'bracket' – use brackets and the Chevalley basis

  • 'matrix' – use matrices

EXAMPLES:

We first construct ${\mathfrak{so}}_5$ using the Chevalley basis:

Sage

sage: so5 = lie_algebras.so(QQ, 5); so5
Lie algebra of ['B', 2] in the Chevalley basis
sage: E1,E2, F1,F2, H1,H2 = so5.gens()
sage: so5([E1, [E1, E2]])
0
sage: X = so5([E2, [E2, E1]]); X
-2*E[alpha[1] + 2*alpha[2]]
sage: H1.bracket(X)
0
sage: H2.bracket(X)
-4*E[alpha[1] + 2*alpha[2]]
sage: so5([H1, [E1, E2]])
-E[alpha[1] + alpha[2]]
sage: so5([H2, [E1, E2]])
0

Python

>>> from sage.all import *
>>> so5 = lie_algebras.so(QQ, Integer(5)); so5
Lie algebra of ['B', 2] in the Chevalley basis
>>> E1,E2, F1,F2, H1,H2 = so5.gens()
>>> so5([E1, [E1, E2]])
0
>>> X = so5([E2, [E2, E1]]); X
-2*E[alpha[1] + 2*alpha[2]]
>>> H1.bracket(X)
0
>>> H2.bracket(X)
-4*E[alpha[1] + 2*alpha[2]]
>>> so5([H1, [E1, E2]])
-E[alpha[1] + alpha[2]]
>>> so5([H2, [E1, E2]])
0

Sage Live

so5 = lie_algebras.so(QQ, 5); so5
E1,E2, F1,F2, H1,H2 = so5.gens()
so5([E1, [E1, E2]])
X = so5([E2, [E2, E1]]); X
H1.bracket(X)
H2.bracket(X)
so5([H1, [E1, E2]])
so5([H2, [E1, E2]])

We do the same construction of ${\mathfrak{so}}_4$ using the Chevalley basis:

Sage

sage: so4 = lie_algebras.so(QQ, 4); so4
Lie algebra of ['D', 2] in the Chevalley basis
sage: E1,E2, F1,F2, H1,H2 = so4.gens()
sage: H1.bracket(E1)
2*E[alpha[1]]
sage: H2.bracket(E1) == so4.zero()
True
sage: E1.bracket(E2) == so4.zero()
True

Python

>>> from sage.all import *
>>> so4 = lie_algebras.so(QQ, Integer(4)); so4
Lie algebra of ['D', 2] in the Chevalley basis
>>> E1,E2, F1,F2, H1,H2 = so4.gens()
>>> H1.bracket(E1)
2*E[alpha[1]]
>>> H2.bracket(E1) == so4.zero()
True
>>> E1.bracket(E2) == so4.zero()
True

Sage Live

so4 = lie_algebras.so(QQ, 4); so4
E1,E2, F1,F2, H1,H2 = so4.gens()
H1.bracket(E1)
H2.bracket(E1) == so4.zero()
E1.bracket(E2) == so4.zero()

We now construct ${\mathfrak{so}}_4$ as a matrix Lie algebra:

Sage

sage: sl2 = lie_algebras.sl(QQ, 2, representation='matrix')
sage: E1,E2, F1,F2, H1,H2 = so4.gens()
sage: H2.bracket(E1) == so4.zero()
True
sage: E1.bracket(E2) == so4.zero()
True

Python

>>> from sage.all import *
>>> sl2 = lie_algebras.sl(QQ, Integer(2), representation='matrix')
>>> E1,E2, F1,F2, H1,H2 = so4.gens()
>>> H2.bracket(E1) == so4.zero()
True
>>> E1.bracket(E2) == so4.zero()
True

Sage Live

sl2 = lie_algebras.sl(QQ, 2, representation='matrix')
E1,E2, F1,F2, H1,H2 = so4.gens()
H2.bracket(E1) == so4.zero()
E1.bracket(E2) == so4.zero()

sage.algebras.lie_algebras.examples.sp(R, n, representation='bracket')

The Lie algebra ${\mathfrak{sp}}_n$.

The Lie algebra ${\mathfrak{sp}}_n$ where $n=2k$ is the type $C_k$ Lie algebra and is finite dimensional. As a matrix Lie algebra, it is given by the set of all matrices $X$ that satisfy the equation:

$$X^{T}M-MX=0$$

where

$$\begin{array}{r}M=\left(\begin{array}{cc}0& I_k\\ -I_k& 0\end{array}\right).\end{array}$$

This is the Lie algebra of type $C_k$.

INPUT:

• R – the base ring

• n – the size of the matrix

• representation – (default: 'bracket') can be one of the following:

  • 'bracket' – use brackets and the Chevalley basis

  • 'matrix' – use matrices

EXAMPLES:

We first construct ${\mathfrak{sp}}_4$ using the Chevalley basis:

Sage

sage: sp4 = lie_algebras.sp(QQ, 4); sp4
Lie algebra of ['C', 2] in the Chevalley basis
sage: E1,E2, F1,F2, H1,H2 = sp4.gens()
sage: sp4([E2, [E2, E1]])
0
sage: X = sp4([E1, [E1, E2]]); X
2*E[2*alpha[1] + alpha[2]]
sage: H1.bracket(X)
4*E[2*alpha[1] + alpha[2]]
sage: H2.bracket(X)
0
sage: sp4([H1, [E1, E2]])
0
sage: sp4([H2, [E1, E2]])
-E[alpha[1] + alpha[2]]

Python

>>> from sage.all import *
>>> sp4 = lie_algebras.sp(QQ, Integer(4)); sp4
Lie algebra of ['C', 2] in the Chevalley basis
>>> E1,E2, F1,F2, H1,H2 = sp4.gens()
>>> sp4([E2, [E2, E1]])
0
>>> X = sp4([E1, [E1, E2]]); X
2*E[2*alpha[1] + alpha[2]]
>>> H1.bracket(X)
4*E[2*alpha[1] + alpha[2]]
>>> H2.bracket(X)
0
>>> sp4([H1, [E1, E2]])
0
>>> sp4([H2, [E1, E2]])
-E[alpha[1] + alpha[2]]

Sage Live

sp4 = lie_algebras.sp(QQ, 4); sp4
E1,E2, F1,F2, H1,H2 = sp4.gens()
sp4([E2, [E2, E1]])
X = sp4([E1, [E1, E2]]); X
H1.bracket(X)
H2.bracket(X)
sp4([H1, [E1, E2]])
sp4([H2, [E1, E2]])

We now construct ${\mathfrak{sp}}_4$ as a matrix Lie algebra:

Sage

sage: sp4 = lie_algebras.sp(QQ, 4, representation='matrix'); sp4
Symplectic Lie algebra of rank 4 over Rational Field
sage: E1,E2, F1,F2, H1,H2 = sp4.gens()
sage: H1.bracket(E1)
[ 0  2  0  0]
[ 0  0  0  0]
[ 0  0  0  0]
[ 0  0 -2  0]
sage: sp4([E1, [E1, E2]])
[0 0 2 0]
[0 0 0 0]
[0 0 0 0]
[0 0 0 0]

Python

>>> from sage.all import *
>>> sp4 = lie_algebras.sp(QQ, Integer(4), representation='matrix'); sp4
Symplectic Lie algebra of rank 4 over Rational Field
>>> E1,E2, F1,F2, H1,H2 = sp4.gens()
>>> H1.bracket(E1)
[ 0  2  0  0]
[ 0  0  0  0]
[ 0  0  0  0]
[ 0  0 -2  0]
>>> sp4([E1, [E1, E2]])
[0 0 2 0]
[0 0 0 0]
[0 0 0 0]
[0 0 0 0]

Sage Live

sp4 = lie_algebras.sp(QQ, 4, representation='matrix'); sp4
E1,E2, F1,F2, H1,H2 = sp4.gens()
H1.bracket(E1)
sp4([E1, [E1, E2]])

sage.algebras.lie_algebras.examples.strictly_upper_triangular_matrices(R, n)

Return the Lie algebra ${\mathfrak{n}}_k$ of strictly $k\times k$ upper triangular matrices.

Todo

This implementation does not know it is finite-dimensional and does not know its basis.

EXAMPLES:

Sage

sage: L = lie_algebras.strictly_upper_triangular_matrices(QQ, 4); L
Lie algebra of 4-dimensional strictly upper triangular matrices over Rational Field
sage: TestSuite(L).run()
sage: n0, n1, n2 = L.lie_algebra_generators()
sage: L[n2, n1]
[ 0  0  0  0]
[ 0  0  0 -1]
[ 0  0  0  0]
[ 0  0  0  0]

Python

>>> from sage.all import *
>>> L = lie_algebras.strictly_upper_triangular_matrices(QQ, Integer(4)); L
Lie algebra of 4-dimensional strictly upper triangular matrices over Rational Field
>>> TestSuite(L).run()
>>> n0, n1, n2 = L.lie_algebra_generators()
>>> L[n2, n1]
[ 0  0  0  0]
[ 0  0  0 -1]
[ 0  0  0  0]
[ 0  0  0  0]

Sage Live

L = lie_algebras.strictly_upper_triangular_matrices(QQ, 4); L
TestSuite(L).run()
n0, n1, n2 = L.lie_algebra_generators()
L[n2, n1]

sage.algebras.lie_algebras.examples.su(R, n, representation='matrix')

The Lie algebra ${\mathfrak{su}}_n$.

The Lie algebra ${\mathfrak{su}}_n$ is the compact real form of the type $A_{n-1}$ Lie algebra and is finite-dimensional. As a matrix Lie algebra, it is given by the set of all $n\times n$ skew-Hermitian matrices with trace 0.

INPUT:

• R – the base ring

• n – the size of the matrix

• representation – (default: 'matrix') can be one of the following:

  • 'bracket' – use brackets and the Chevalley basis

  • 'matrix' – use matrices

EXAMPLES:

We construct ${\mathfrak{su}}_2$, where the default is as a matrix Lie algebra:

Sage

sage: su2 = lie_algebras.su(QQ, 2)
sage: E,H,F = su2.basis()
sage: E.bracket(F) == 2*H
True
sage: H.bracket(E) == 2*F
True
sage: H.bracket(F) == -2*E
True

Python

>>> from sage.all import *
>>> su2 = lie_algebras.su(QQ, Integer(2))
>>> E,H,F = su2.basis()
>>> E.bracket(F) == Integer(2)*H
True
>>> H.bracket(E) == Integer(2)*F
True
>>> H.bracket(F) == -Integer(2)*E
True

Sage Live

su2 = lie_algebras.su(QQ, 2)
E,H,F = su2.basis()
E.bracket(F) == 2*H
H.bracket(E) == 2*F
H.bracket(F) == -2*E

Since ${\mathfrak{su}}_n$ is the same as the type $A_{n-1}$ Lie algebra, the bracket is the same as sl():

Sage

sage: su2 = lie_algebras.su(QQ, 2, representation='bracket')
sage: su2 is lie_algebras.sl(QQ, 2, representation='bracket')
True

Python

>>> from sage.all import *
>>> su2 = lie_algebras.su(QQ, Integer(2), representation='bracket')
>>> su2 is lie_algebras.sl(QQ, Integer(2), representation='bracket')
True

Sage Live

su2 = lie_algebras.su(QQ, 2, representation='bracket')
su2 is lie_algebras.sl(QQ, 2, representation='bracket')

sage.algebras.lie_algebras.examples.three_dimensional(R, a, b, c, d, names=['X', 'Y', 'Z'])

The 3-dimensional Lie algebra over a given commutative ring $R$ with basis $\{X,Y,Z\}$ subject to the relations:

$$[X,Y]=aZ+dY,[Y,Z]=bX,[Z,X]=cY+dZ$$

where $a,b,c,d\in R$.

This is always a well-defined 3-dimensional Lie algebra, as can be easily proven by computation.

EXAMPLES:

Sage

sage: L = lie_algebras.three_dimensional(QQ, 4, 1, -1, 2)
sage: L.structure_coefficients()
Finite family {('X', 'Y'): 2*Y + 4*Z, ('X', 'Z'): Y - 2*Z, ('Y', 'Z'): X}
sage: TestSuite(L).run()
sage: L = lie_algebras.three_dimensional(QQ, 1, 0, 0, 0)
sage: L.structure_coefficients()
Finite family {('X', 'Y'): Z}
sage: L = lie_algebras.three_dimensional(QQ, 0, 0, -1, -1)
sage: L.structure_coefficients()
Finite family {('X', 'Y'): -Y, ('X', 'Z'): Y + Z}
sage: L = lie_algebras.three_dimensional(QQ, 0, 1, 0, 0)
sage: L.structure_coefficients()
Finite family {('Y', 'Z'): X}
sage: lie_algebras.three_dimensional(QQ, 0, 0, 0, 0)
Abelian Lie algebra on 3 generators (X, Y, Z) over Rational Field
sage: Q.<a,b,c,d> = PolynomialRing(QQ)
sage: L = lie_algebras.three_dimensional(Q, a, b, c, d)
sage: L.structure_coefficients()
Finite family {('X', 'Y'): d*Y + a*Z, ('X', 'Z'): -c*Y - d*Z, ('Y', 'Z'): b*X}
sage: TestSuite(L).run()

Python

>>> from sage.all import *
>>> L = lie_algebras.three_dimensional(QQ, Integer(4), Integer(1), -Integer(1), Integer(2))
>>> L.structure_coefficients()
Finite family {('X', 'Y'): 2*Y + 4*Z, ('X', 'Z'): Y - 2*Z, ('Y', 'Z'): X}
>>> TestSuite(L).run()
>>> L = lie_algebras.three_dimensional(QQ, Integer(1), Integer(0), Integer(0), Integer(0))
>>> L.structure_coefficients()
Finite family {('X', 'Y'): Z}
>>> L = lie_algebras.three_dimensional(QQ, Integer(0), Integer(0), -Integer(1), -Integer(1))
>>> L.structure_coefficients()
Finite family {('X', 'Y'): -Y, ('X', 'Z'): Y + Z}
>>> L = lie_algebras.three_dimensional(QQ, Integer(0), Integer(1), Integer(0), Integer(0))
>>> L.structure_coefficients()
Finite family {('Y', 'Z'): X}
>>> lie_algebras.three_dimensional(QQ, Integer(0), Integer(0), Integer(0), Integer(0))
Abelian Lie algebra on 3 generators (X, Y, Z) over Rational Field
>>> Q = PolynomialRing(QQ, names=('a', 'b', 'c', 'd',)); (a, b, c, d,) = Q._first_ngens(4)
>>> L = lie_algebras.three_dimensional(Q, a, b, c, d)
>>> L.structure_coefficients()
Finite family {('X', 'Y'): d*Y + a*Z, ('X', 'Z'): -c*Y - d*Z, ('Y', 'Z'): b*X}
>>> TestSuite(L).run()

Sage Live

L = lie_algebras.three_dimensional(QQ, 4, 1, -1, 2)
L.structure_coefficients()
TestSuite(L).run()
L = lie_algebras.three_dimensional(QQ, 1, 0, 0, 0)
L.structure_coefficients()
L = lie_algebras.three_dimensional(QQ, 0, 0, -1, -1)
L.structure_coefficients()
L = lie_algebras.three_dimensional(QQ, 0, 1, 0, 0)
L.structure_coefficients()
lie_algebras.three_dimensional(QQ, 0, 0, 0, 0)
Q.<a,b,c,d> = PolynomialRing(QQ)
L = lie_algebras.three_dimensional(Q, a, b, c, d)
L.structure_coefficients()
TestSuite(L).run()

sage.algebras.lie_algebras.examples.three_dimensional_by_rank(R, n, a=None, names=['X', 'Y', 'Z'])

Return a 3-dimensional Lie algebra of rank n, where $0\le n\le 3$.

Here, the rank of a Lie algebra $L$ is defined as the dimension of its derived subalgebra $[L,L]$. (We are assuming that $R$ is a field of characteristic $0$; otherwise the Lie algebras constructed by this function are still well-defined but no longer might have the correct ranks.) This is not to be confused with the other standard definition of a rank (namely, as the dimension of a Cartan subalgebra, when $L$ is semisimple).

INPUT:

• R – the base ring

• n – the rank

• a – the deformation parameter (used for $n=2$); this should be a nonzero element of $R$ in order for the resulting Lie algebra to actually have the right rank(?)

• names – (optional) the generator names

EXAMPLES:

Sage

sage: lie_algebras.three_dimensional_by_rank(QQ, 0)
Abelian Lie algebra on 3 generators (X, Y, Z) over Rational Field
sage: L = lie_algebras.three_dimensional_by_rank(QQ, 1)
sage: L.structure_coefficients()
Finite family {('Y', 'Z'): X}
sage: L = lie_algebras.three_dimensional_by_rank(QQ, 2, 4)
sage: L.structure_coefficients()
Finite family {('X', 'Y'): Y, ('X', 'Z'): Y + Z}
sage: L = lie_algebras.three_dimensional_by_rank(QQ, 2, 0)
sage: L.structure_coefficients()
Finite family {('X', 'Y'): Y}
sage: lie_algebras.three_dimensional_by_rank(QQ, 3)
sl2 over Rational Field

Python

>>> from sage.all import *
>>> lie_algebras.three_dimensional_by_rank(QQ, Integer(0))
Abelian Lie algebra on 3 generators (X, Y, Z) over Rational Field
>>> L = lie_algebras.three_dimensional_by_rank(QQ, Integer(1))
>>> L.structure_coefficients()
Finite family {('Y', 'Z'): X}
>>> L = lie_algebras.three_dimensional_by_rank(QQ, Integer(2), Integer(4))
>>> L.structure_coefficients()
Finite family {('X', 'Y'): Y, ('X', 'Z'): Y + Z}
>>> L = lie_algebras.three_dimensional_by_rank(QQ, Integer(2), Integer(0))
>>> L.structure_coefficients()
Finite family {('X', 'Y'): Y}
>>> lie_algebras.three_dimensional_by_rank(QQ, Integer(3))
sl2 over Rational Field

Sage Live

lie_algebras.three_dimensional_by_rank(QQ, 0)
L = lie_algebras.three_dimensional_by_rank(QQ, 1)
L.structure_coefficients()
L = lie_algebras.three_dimensional_by_rank(QQ, 2, 4)
L.structure_coefficients()
L = lie_algebras.three_dimensional_by_rank(QQ, 2, 0)
L.structure_coefficients()
lie_algebras.three_dimensional_by_rank(QQ, 3)

sage.algebras.lie_algebras.examples.upper_triangular_matrices(R, n)

Return the Lie algebra ${\mathfrak{b}}_k$ of $k\times k$ upper triangular matrices.

Todo

This implementation does not know it is finite-dimensional and does not know its basis.

EXAMPLES:

Sage

sage: L = lie_algebras.upper_triangular_matrices(QQ, 4); L
Lie algebra of 4-dimensional upper triangular matrices over Rational Field
sage: TestSuite(L).run()
sage: n0, n1, n2, t0, t1, t2, t3 = L.lie_algebra_generators()
sage: L[n2, t2] == -n2
True

Python

>>> from sage.all import *
>>> L = lie_algebras.upper_triangular_matrices(QQ, Integer(4)); L
Lie algebra of 4-dimensional upper triangular matrices over Rational Field
>>> TestSuite(L).run()
>>> n0, n1, n2, t0, t1, t2, t3 = L.lie_algebra_generators()
>>> L[n2, t2] == -n2
True

Sage Live

L = lie_algebras.upper_triangular_matrices(QQ, 4); L
TestSuite(L).run()
n0, n1, n2, t0, t1, t2, t3 = L.lie_algebra_generators()
L[n2, t2] == -n2

sage.algebras.lie_algebras.examples.witt(R)

Return the Lie algebra of regular vector fields on ${\mathbf{C}}^{\times }$.

This is also known as the Witt (Lie) algebra.

See also

LieAlgebraRegularVectorFields

EXAMPLES:

Sage

sage: lie_algebras.regular_vector_fields(QQ)
The Lie algebra of regular vector fields over Rational Field

Python

>>> from sage.all import *
>>> lie_algebras.regular_vector_fields(QQ)
The Lie algebra of regular vector fields over Rational Field

Sage Live

lie_algebras.regular_vector_fields(QQ)

Make live