# 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`

.

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

`iszero`

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

Check whether the Lie algebra element `x`

is zero.

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

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

`dim`

— Method`dim(L::LieAlgebra) -> Int`

Return the dimension of the Lie algebra `L`

.

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

`basis`

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

Return a basis of the Lie algebra `L`

.

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

`basis`

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

Return the `i`

-th basis element of the Lie algebra `L`

.

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

`coefficients`

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

Return the coefficients of `x`

with respect to `basis(::LieAlgebra)`

.

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

`coeff`

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

Return the `i`

-th coefficient of `x`

with respect to `basis(::LieAlgebra)`

.

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

`getindex`

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

Return the `i`

-th coefficient of `x`

with respect to `basis(::LieAlgebra)`

.

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

`symbols`

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

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

.

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

`characteristic`

— Method`characteristic(L::LieAlgebra) -> Int`

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

.

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

## Special functions for `LinearLieAlgebra`

s

`coerce_to_lie_algebra_elem`

— Method`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.

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

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

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

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

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

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

## Arithmetics

The usual arithmetics, e.g. `+`

, `-`

, and `*`

, are defined for `LieAlgebraElem`

s.

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

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

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

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

`is_perfect`

— Method`is_perfect(L::LieAlgebra) -> Bool`

Return `true`

if `L`

is perfect, i.e. $[L, L] = L$.

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

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

This function is not implemented yet.

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

`is_solvable`

— Method`is_solvable(L::LieAlgebra) -> Bool`

Return `true`

if `L`

is solvable, i.e. the derived series of `L`

terminates in $0$.

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

## More functions

`center`

— Method`center(L::LieAlgebra) -> LieAlgebraIdeal`

Return the center of `L`

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

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

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

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

`centralizer`

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

Return the centralizer of `x`

in `L`

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

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

`derived_algebra`

— Method`derived_algebra(L::LieAlgebra) -> LieAlgebraIdeal`

Return the derived algebra of `L`

, i.e. $[L, L]$.

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

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

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

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

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

## Lie algebra constructors

`lie_algebra`

— Function`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.

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

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

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

`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
```

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

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

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

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

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

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

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

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

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

## Classical Lie algebras

`abelian_lie_algebra`

— Method```
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.

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

`general_linear_lie_algebra`

— Method`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]
```

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

`special_linear_lie_algebra`

— Method`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]
```

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

`special_orthogonal_lie_algebra`

— Function```
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]
```

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

`symplectic_lie_algebra`

— Function```
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]
```

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

## 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`

.