# Lie algebras

Lie algebras in OSCAR are currently always finite dimensional, and represented by two different types, namely LinearLieAlgebra{C} and AbstractLieAlgebra{C}, depending on whether a matrix representation is available or not. Both types are subtypes of LieAlgebra{C}. Similar to other types in OSCAR, each Lie algebra type has a corresponding element type. The type parameter C is the element type of the coefficient ring.

zeroMethod
zero(L::LieAlgebra{C}) -> LieAlgebraElem{C}

Return the zero element of the Lie algebra L.

source
iszeroMethod
iszero(x::LieAlgebraElem{C}) -> Bool

Check whether the Lie algebra element x is zero.

source
dimMethod
dim(L::LieAlgebra) -> Int

Return the dimension of the Lie algebra L.

source
basisMethod
basis(L::LieAlgebra{C}) -> Vector{LieAlgebraElem{C}}

Return a basis of the Lie algebra L.

source
basisMethod
basis(L::LieAlgebra{C}, i::Int) -> LieAlgebraElem{C}

Return the i-th basis element of the Lie algebra L.

source
symbolsMethod
symbols(L::LieAlgebra{C}) -> Vector{Symbol}

Return the symbols used for printing basis elements of the Lie algebra L.

source

## Special functions for LinearLieAlgebras

matrix_repr_basisMethod
matrix_repr_basis(L::LinearLieAlgebra{C}) -> Vector{MatElem{C}}

Return the basis basis(L) of the Lie algebra L in the underlying matrix representation.

source
matrix_repr_basisMethod
matrix_repr_basis(L::LinearLieAlgebra{C}, i::Int) -> MatElem{C}

Return the i-th element of the basis basis(L) of the Lie algebra L in the underlying matrix representation.

source
matrix_reprMethod
matrix_repr(a::Perm)

Return the permutation matrix as a sparse matrix representing a via natural embedding of the permutation group into the general linear group over $\mathbb{Z}$.

Examples

julia> p = Perm([2,3,1])
(1,2,3)

julia> matrix_repr(p)
3×3 SparseArrays.SparseMatrixCSC{Int64, Int64} with 3 stored entries:
⋅  1  ⋅
⋅  ⋅  1
1  ⋅  ⋅

julia> Array(ans)
3×3 Matrix{Int64}:
0  1  0
0  0  1
1  0  0
matrix_repr(Y::YoungTableau)

Construct sparse integer matrix representing the tableau.

Examples

julia> y = YoungTableau([4,3,1]);

julia> matrix_repr(y)
3×4 SparseArrays.SparseMatrixCSC{Int64, Int64} with 8 stored entries:
1  2  3  4
5  6  7  ⋅
8  ⋅  ⋅  ⋅

## Element constructors

(L::LieAlgebra{C})() returns the zero element of the Lie algebra L.

(L::LieAlgebra{C})(x::LieAlgebraElem{C}) returns x if x is an element of L, and fails otherwise.

(L::LieAlgebra{C})(v) constructs the element of L with coefficient vector v. v can be of type Vector{C}, Vector{Int}, SRow{C}, or MatElem{C} (of size $1 \times \dim(L)$).

If L is a LinearLieAlgebra of dim(L) > 1, the call (L::LinearLieAlgebra{C})(m::MatElem{C}) returns the Lie algebra element whose matrix representation corresponds to m. This requires m to be a square matrix of size n > 1 (the dimension of L), and to lie in the Lie algebra L (i.e. to be in the span of basis(L)). The case of m being a $1 \times \dim(L)$ matrix still works as explained above.

## Arithmetics

The usual arithmetics, e.g. +, -, and *, are defined for LieAlgebraElems.

Warning

Please note that * refers to the Lie bracket and is thus not associative.

## Properties

is_abelianMethod
is_abelian(L::LieAlgebra) -> Bool

Return true if L is abelian, i.e. $[L, L] = 0$.

source
is_nilpotentMethod
is_nilpotent(L::LieAlgebra) -> Bool

Return true if L is nilpotent, i.e. the lower central series of L terminates in $0$.

source
is_perfectMethod
is_perfect(L::LieAlgebra) -> Bool

Return true if L is perfect, i.e. $[L, L] = L$.

source
is_simpleMethod
is_simple(L::LieAlgebra) -> Bool

Return true if L is simple, i.e. L is not abelian and has no non-trivial ideals.

Warning

This function is not implemented yet.

source
is_solvableMethod
is_solvable(L::LieAlgebra) -> Bool

Return true if L is solvable, i.e. the derived series of L terminates in $0$.

source

## More functions

centerMethod
center(L::LieAlgebra) -> LieAlgebraIdeal

Return the center of L, i.e. $\{x \in L \mid [x, L] = 0\}$

source
centralizerMethod
centralizer(L::LieAlgebra, xs::AbstractVector{<:LieAlgebraElem}) -> LieSubalgebra

Return the centralizer of xs in L, i.e. $\{y \in L \mid [x, y] = 0 \forall x \in xs\}$.

source
centralizerMethod
centralizer(L::LieAlgebra, x::LieAlgebraElem) -> LieSubalgebra

Return the centralizer of x in L, i.e. $\{y \in L \mid [x, y] = 0\}$.

source
derived_algebraMethod
derived_algebra(L::LieAlgebra) -> LieAlgebraIdeal

Return the derived algebra of L, i.e. $[L, L]$.

source
derived_seriesMethod
derived_series(L::LieAlgebra) -> Vector{LieAlgebraIdeal}

Return the derived series of L, i.e. the sequence of ideals $L^{(0)} = L$, $L^{(i + 1)} = [L^{(i)}, L^{(i)}]$.

source
lower_central_seriesMethod
lower_central_series(L::LieAlgebra) -> Vector{LieAlgebraIdeal}

Return the lower central series of L, i.e. the sequence of ideals $L^{(0)} = L$, $L^{(i + 1)} = [L, L^{(i)}]$.

source

## Lie algebra constructors

lie_algebraFunction
lie_algebra(gapL::GAP.GapObj, s::Vector{<:VarName}; cached::Bool) -> LieAlgebra{elem_type(R)}

Construct a Lie algebra isomorphic to the GAP Lie algebra gapL. Its basis element are named by s, or by x_i by default. We require gapL to be a finite-dimensional GAP Lie algebra. The return type is dependent on properties of gapL, in particular, whether GAP knows about a matrix representation.

If cached is true, the constructed Lie algebra is cached.

source
lie_algebra(R::Ring, struct_consts::Matrix{SRow{elem_type(R)}}, s::Vector{<:VarName}; cached::Bool, check::Bool) -> AbstractLieAlgebra{elem_type(R)}

Construct the Lie algebra over the ring R with structure constants struct_consts and with basis element names s.

The Lie bracket on the newly constructed Lie algebra L is determined by the structure constants in struct_consts as follows: let $x_i$ denote the $i$-th standard basis vector of L. Then the entry struct_consts[i,j][k] is a scalar $a_{i,j,k}$ such that $[x_i, x_j] = \sum_k a_{i,j,k} x_k$.

• s: A vector of basis element names. This is [Symbol("x_$i") for i in 1:size(struct_consts, 1)] by default. • cached: If true, cache the result. This is true by default. • check: If true, check that the structure constants are anti-symmetric and satisfy the Jacobi identity. This is true by default. source lie_algebra(R::Ring, struct_consts::Array{elem_type(R),3}, s::Vector{<:VarName}; cached::Bool, check::Bool) -> AbstractLieAlgebra{elem_type(R)} Construct the Lie algebra over the ring R with structure constants struct_consts and with basis element names s. The Lie bracket on the newly constructed Lie algebra L is determined by the structure constants in struct_consts as follows: let$x_i$denote the$i$-th standard basis vector of L. Then the entry struct_consts[i,j,k] is a scalar$a_{i,j,k}$such that$[x_i, x_j] = \sum_k a_{i,j,k} x_k$. • s: A vector of basis element names. This is [Symbol("x_$i") for i in 1:size(struct_consts, 1)] by default.
• cached: If true, cache the result. This is true by default.
• check: If true, check that the structure constants are anti-symmetric and satisfy the Jacobi identity. This is true by default.

Examples

julia> struct_consts = zeros(QQ, 3, 3, 3);

julia> struct_consts[1, 2, 3] = QQ(1);

julia> struct_consts[2, 1, 3] = QQ(-1);

julia> struct_consts[3, 1, 1] = QQ(2);

julia> struct_consts[1, 3, 1] = QQ(-2);

julia> struct_consts[3, 2, 2] = QQ(-2);

julia> struct_consts[2, 3, 2] = QQ(2);

julia> sl2 = lie_algebra(QQ, struct_consts, ["e", "f", "h"])
Abstract Lie algebra
of dimension 3
over rational field

julia> e, f, h = basis(sl2)
3-element Vector{AbstractLieAlgebraElem{QQFieldElem}}:
e
f
h

julia> e * f
h

julia> h * e
2*e

julia> h * f
-2*f
source
lie_algebra(R::Ring, dynkin::Tuple{Char,Int}; cached::Bool) -> AbstractLieAlgebra{elem_type(R)}

Construct the simple Lie algebra over the ring R with Dynkin type given by dynkin. The actual construction is done in GAP.

If cached is true, the constructed Lie algebra is cached.

source
lie_algebra(R::Ring, n::Int, basis::Vector{<:MatElem{elem_type(R)}}, s::Vector{<:VarName}; cached::Bool) -> LinearLieAlgebra{elem_type(R)}

Construct the Lie algebra over the ring R with basis basis and basis element names given by s. The basis elements must be square matrices of size n. We require basis to be linearly independent, and to contain the Lie bracket of any two basis elements in its span.

If cached is true, the constructed Lie algebra is cached.

source
lie_algebra(S::LieSubalgebra) -> LieAlgebra

Return S as a Lie algebra LS, together with an embedding LS -> L, where L is the Lie algebra where S lives in.

source
lie_algebra(I::LieAlgebraIdeal) -> LieAlgebra

Return I as a Lie algebra LI, together with an embedding LI -> L, where L is the Lie algebra where I lives in.

source

## Classical Lie algebras

abelian_lie_algebraMethod
abelian_lie_algebra(R::Ring, n::Int) -> LinearLieAlgebra{elem_type(R)}
abelian_lie_algebra(::Type{LinearLieAlgebra}, R::Ring, n::Int) -> LinearLieAlgebra{elem_type(R)}
abelian_lie_algebra(::Type{AbstractLieAlgebra}, R::Ring, n::Int) -> AbstractLieAlgebra{elem_type(R)}

Return the abelian Lie algebra of dimension n over the ring R. The first argument can be optionally provided to specify the type of the returned Lie algebra.

source
general_linear_lie_algebraMethod
general_linear_lie_algebra(R::Ring, n::Int) -> LinearLieAlgebra{elem_type(R)}

Return the general linear Lie algebra $\mathfrak{gl}_n(R)$.

Examples

julia> L = general_linear_lie_algebra(QQ, 2)
General linear Lie algebra of degree 2
of dimension 4
over rational field

julia> basis(L)
4-element Vector{LinearLieAlgebraElem{QQFieldElem}}:
x_1_1
x_1_2
x_2_1
x_2_2

julia> matrix_repr_basis(L)
4-element Vector{QQMatrix}:
[1 0; 0 0]
[0 1; 0 0]
[0 0; 1 0]
[0 0; 0 1]
source
special_linear_lie_algebraMethod
special_linear_lie_algebra(R::Ring, n::Int) -> LinearLieAlgebra{elem_type(R)}

Return the special linear Lie algebra $\mathfrak{sl}_n(R)$.

Examples

julia> L = special_linear_lie_algebra(QQ, 2)
Special linear Lie algebra of degree 2
of dimension 3
over rational field

julia> basis(L)
3-element Vector{LinearLieAlgebraElem{QQFieldElem}}:
e_1_2
f_1_2
h_1

julia> matrix_repr_basis(L)
3-element Vector{QQMatrix}:
[0 1; 0 0]
[0 0; 1 0]
[1 0; 0 -1]
source
special_orthogonal_lie_algebraMethod
special_orthogonal_lie_algebra(R::Ring, n::Int) -> LinearLieAlgebra{elem_type(R)}

Return the special orthogonal Lie algebra $\mathfrak{so}_n(R)$.

Examples

julia> L = special_orthogonal_lie_algebra(QQ, 3)
Special orthogonal Lie algebra of degree 3
of dimension 3
over rational field

julia> basis(L)
3-element Vector{LinearLieAlgebraElem{QQFieldElem}}:
x_1_2
x_1_3
x_2_3

julia> matrix_repr_basis(L)
3-element Vector{QQMatrix}:
[0 1 0; -1 0 0; 0 0 0]
[0 0 1; 0 0 0; -1 0 0]
[0 0 0; 0 0 1; 0 -1 0]
source

## Relation to GAP Lie algebras

Using Oscar.iso_oscar_gap(L), one can get an isomorphism from the OSCAR Lie algebra L to some isomorphic GAP Lie algebra. For more details, please refer to iso_oscar_gap.