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.

Experimental

This function is part of the experimental code in Oscar. Please read here for more details.

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

Check whether the Lie algebra element x is zero.

Experimental

This function is part of the experimental code in Oscar. Please read here for more details.

Experimental

This function is part of the experimental code in Oscar. Please read here for more details.

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

Return the dimension of the Lie algebra L.

Experimental

This function is part of the experimental code in Oscar. Please read here for more details.

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

Return a basis of the Lie algebra L.

Experimental

This function is part of the experimental code in Oscar. Please read here for more details.

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

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

Experimental

This function is part of the experimental code in Oscar. Please read here for more details.

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

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

Experimental

This function is part of the experimental code in Oscar. Please read here for more details.

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

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

Experimental

This function is part of the experimental code in Oscar. Please read here for more details.

source
characteristicMethod
characteristic(L::LieAlgebra) -> Int

Return the characteristic of the coefficient ring of the Lie algebra L.

Experimental

This function is part of the experimental code in Oscar. Please read here for more details.

source

Special functions for LinearLieAlgebras

coerce_to_lie_algebra_elemMethod
coerce_to_lie_algebra_elem(L::LinearLieAlgebra{C}, x::MatElem{C}) -> LinearLieAlgebraElem{C}

Return the element of L whose matrix representation corresponds to x. If no such element exists, an error is thrown.

Experimental

This function is part of the experimental code in Oscar. Please read here for more details.

source
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.

Experimental

This function is part of the experimental code in Oscar. Please read here for more details.

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.

Experimental

This function is part of the experimental code in Oscar. Please read here for more details.

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
source
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  ⋅  ⋅  ⋅
source

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

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

Experimental

This function is part of the experimental code in Oscar. Please read here for more details.

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

Experimental

This function is part of the experimental code in Oscar. Please read here for more details.

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

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

Experimental

This function is part of the experimental code in Oscar. Please read here for more details.

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.

Experimental

This function is part of the experimental code in Oscar. Please read here for more details.

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

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

Experimental

This function is part of the experimental code in Oscar. Please read here for more details.

source

More functions

centerMethod
center(L::LieAlgebra) -> LieAlgebraIdeal

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

Experimental

This function is part of the experimental code in Oscar. Please read here for more details.

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

Experimental

This function is part of the experimental code in Oscar. Please read here for more details.

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

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

Experimental

This function is part of the experimental code in Oscar. Please read here for more details.

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

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

Experimental

This function is part of the experimental code in Oscar. Please read here for more details.

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

Experimental

This function is part of the experimental code in Oscar. Please read here for more details.

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

Experimental

This function is part of the experimental code in Oscar. Please read here for more details.

source

Lie algebra constructors

lie_algebraFunction
lie_algebra(gapL::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.

Experimental

This function is part of the experimental code in Oscar. Please read here for more details.

source
lie_algebra(R::Field, 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. Experimental This function is part of the experimental code in Oscar. Please read here for more details. source lie_algebra(R::Field, 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
Experimental

This function is part of the experimental code in Oscar. Please read here for more details.

source
lie_algebra(R::Field, 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 internally used basis of this Lie algebra is the Chevalley basis.

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

Experimental

This function is part of the experimental code in Oscar. Please read here for more details.

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

Construct the Lie algebra over the field 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.

Experimental

This function is part of the experimental code in Oscar. Please read here for more details.

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.

Experimental

This function is part of the experimental code in Oscar. Please read here for more details.

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.

Experimental

This function is part of the experimental code in Oscar. Please read here for more details.

source

Classical Lie algebras

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

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

Experimental

This function is part of the experimental code in Oscar. Please read here for more details.

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

Return the general linear Lie algebra $\mathfrak{gl}_n(R)$, i.e., the Lie algebra of all $n \times n$ matrices over the field 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]
Experimental

This function is part of the experimental code in Oscar. Please read here for more details.

source
special_linear_lie_algebraMethod
special_linear_lie_algebra(R::Field, n::Int) -> LinearLieAlgebra{elem_type(R)}

Return the special linear Lie algebra $\mathfrak{sl}_n(R)$, i.e., the Lie algebra of all $n \times n$ matrices over the field R with trace zero.

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]
Experimental

This function is part of the experimental code in Oscar. Please read here for more details.

source
special_orthogonal_lie_algebraFunction
special_orthogonal_lie_algebra(R::Field, n::Int) -> LinearLieAlgebra{elem_type(R)}
special_orthogonal_lie_algebra(R::Field, n::Int, gram::MatElem) -> LinearLieAlgebra{elem_type(R)}
special_orthogonal_lie_algebra(R::Field, n::Int, gram::Matrix) -> LinearLieAlgebra{elem_type(R)}

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

Given a non-degenerate symmetric bilinear form $f$ via its Gram matrix gram, $\mathfrak{so}_n(R)$ is the Lie algebra of all $n \times n$ matrices $x$ over the field R such that $f(xv, w) = -f(v, xw)$ for all $v, w \in R^n$.

If gram is not provided, for $n = 2k$ the form defined by $\begin{matrix} 0 & I_k \\ -I_k & 0 \end{matrix}$ is used, and for $n = 2k + 1$ the form defined by $\begin{matrix} 1 & 0 & 0 \\ 0 & 0 I_k \\ 0 & I_k & 0 \end{matrix}$.

Examples

julia> L1 = special_orthogonal_lie_algebra(QQ, 4)
Special orthogonal Lie algebra of degree 4
of dimension 6
over rational field

julia> basis(L1)
6-element Vector{LinearLieAlgebraElem{QQFieldElem}}:
x_1
x_2
x_3
x_4
x_5
x_6

julia> matrix_repr_basis(L1)
6-element Vector{QQMatrix}:
[1 0 0 0; 0 0 0 0; 0 0 -1 0; 0 0 0 0]
[0 1 0 0; 0 0 0 0; 0 0 0 0; 0 0 -1 0]
[0 0 0 1; 0 0 -1 0; 0 0 0 0; 0 0 0 0]
[0 0 0 0; 1 0 0 0; 0 0 0 -1; 0 0 0 0]
[0 0 0 0; 0 1 0 0; 0 0 0 0; 0 0 0 -1]
[0 0 0 0; 0 0 0 0; 0 1 0 0; -1 0 0 0]

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

julia> basis(L2)
3-element Vector{LinearLieAlgebraElem{QQFieldElem}}:
x_1
x_2
x_3

julia> matrix_repr_basis(L2)
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]
Experimental

This function is part of the experimental code in Oscar. Please read here for more details.

source
symplectic_lie_algebraFunction
symplectic_lie_algebra(R::Field, n::Int) -> LinearLieAlgebra{elem_type(R)}
symplectic_lie_algebra(R::Field, n::Int, gram::MatElem) -> LinearLieAlgebra{elem_type(R)}
symplectic_lie_algebra(R::Field, n::Int, gram::Matrix) -> LinearLieAlgebra{elem_type(R)}

Return the symplectic Lie algebra $\mathfrak{sp}_n(R)$.

Given a non-degenerate skew-symmetric bilinear form $f$ via its Gram matrix gram, $\mathfrak{sp}_n(R)$ is the Lie algebra of all $n \times n$ matrices $x$ over the field R such that $f(xv, w) = -f(v, xw)$ for all $v, w \in R^n$.

If gram is not provided, for $n = 2k$ the form defined by $\begin{matrix} 0 & I_k \\ -I_k & 0 \end{matrix}$ is used. For odd $n$ there is no non-degenerate skew-symmetric bilinear form on $R^n$.

Examples

julia> L = symplectic_lie_algebra(QQ, 4)
Symplectic Lie algebra of degree 4
of dimension 10
over rational field

julia> basis(L)
10-element Vector{LinearLieAlgebraElem{QQFieldElem}}:
x_1
x_2
x_3
x_4
x_5
x_6
x_7
x_8
x_9
x_10

julia> matrix_repr_basis(L)
10-element Vector{QQMatrix}:
[1 0 0 0; 0 0 0 0; 0 0 -1 0; 0 0 0 0]
[0 1 0 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; 0 0 0 0]
[0 0 0 1; 0 0 1 0; 0 0 0 0; 0 0 0 0]
[0 0 0 0; 1 0 0 0; 0 0 0 -1; 0 0 0 0]
[0 0 0 0; 0 1 0 0; 0 0 0 0; 0 0 0 -1]
[0 0 0 0; 0 0 0 1; 0 0 0 0; 0 0 0 0]
[0 0 0 0; 0 0 0 0; 1 0 0 0; 0 0 0 0]
[0 0 0 0; 0 0 0 0; 0 1 0 0; 1 0 0 0]
[0 0 0 0; 0 0 0 0; 0 0 0 0; 0 1 0 0]
Experimental

This function is part of the experimental code in Oscar. Please read here for more details.

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.