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.

zero — Method

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

Return the zero element of the Lie algebra L.

iszero — Method

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

Check whether the Lie algebra element x is zero.

dim — Method

dim(L::LieAlgebra) -> Int

Return the dimension of the Lie algebra L.

basis — Method

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

Return a basis of the Lie algebra L.

basis — Method

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

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

coefficients — Method

coefficients(x::LieAlgebraElem{C}) -> Vector{C}

Return the coefficients of x with respect to basis(::LieAlgebra).

coeff — Method

coeff(x::LieAlgebraElem{C}, i::Int) -> C

Return the i-th coefficient of x with respect to basis(::LieAlgebra).

getindex — Method

getindex(x::LieAlgebraElem{C}, i::Int) -> C

Return the i-th coefficient of x with respect to basis(::LieAlgebra).

symbols — Method

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

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

Special functions for `LinearLieAlgebra`s

matrix_repr_basis — Method

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

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

matrix_repr_basis — Method

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.

matrix_repr — Method

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_abelian — Method

is_abelian(L::LieAlgebra) -> Bool

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

is_nilpotent — Method

is_nilpotent(L::LieAlgebra) -> Bool

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

is_perfect — Method

is_perfect(L::LieAlgebra) -> Bool

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

is_simple — Method

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.

is_solvable — Method

is_solvable(L::LieAlgebra) -> Bool

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

More functions

center — Method

center(L::LieAlgebra) -> LieAlgebraIdeal

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

centralizer — Method

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\}$.

centralizer — Method

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

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

derived_algebra — Method

derived_algebra(L::LieAlgebra) -> LieAlgebraIdeal

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

derived_series — Method

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)}]$.

lower_central_series — Method

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)}]$.

Lie algebra constructors

lie_algebra — Function

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.

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.

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

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.

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.

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.

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.

Classical Lie algebras

abelian_lie_algebra — Method

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.

general_linear_lie_algebra — Method

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]

special_linear_lie_algebra — Method

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]

special_orthogonal_lie_algebra — Method

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]

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.