Lie algebra modules

Lie algebra modules in OSCAR are always finite dimensional and represented by the type LieAlgebraModule{C}. Similar to other types in OSCAR, there is the corresponding element type LieAlgebraModuleElem{C}. The type parameter C is the element type of the coefficient ring.

base_lie_algebraMethod
base_lie_algebra(V::LieAlgebraModule{C}) -> LieAlgebra{C}

Return the Lie algebra V is a module over.

Experimental

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

source
zeroMethod
zero(V::LieAlgebraModule{C}) -> LieAlgebraModuleElem{C}

Return the zero element of the Lie algebra module V.

Experimental

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

source
iszeroMethod
iszero(v::LieAlgebraModuleElem{C}) -> Bool

Check whether the Lie algebra module element v 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(V::LieAlgebraModule{C}) -> Int

Return the dimension of the Lie algebra module V.

Experimental

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

source
basisMethod
basis(V::LieAlgebraModule{C}) -> Vector{LieAlgebraModuleElem{C}}

Return a basis of the Lie algebra module V.

Experimental

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

source
basisMethod
basis(V::LieAlgebraModule{C}, i::Int) -> LieAlgebraModuleElem{C}

Return the i-th basis element of the Lie algebra module V.

Experimental

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

source
coefficientsMethod
coefficients(v::LieAlgebraModuleElem{C}) -> Vector{C}

Return the coefficients of v with respect to basis(::LieAlgebraModule).

Experimental

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

source
coeffMethod
coeff(v::LieAlgebraModuleElem{C}, i::Int) -> C

Return the i-th coefficient of v with respect to basis(::LieAlgebraModule).

Experimental

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

source
getindexMethod
getindex(v::LieAlgebraModuleElem{C}, i::Int) -> C

Return the i-th coefficient of v with respect to basis(::LieAlgebraModule).

Experimental

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

source
symbolsMethod
symbols(V::LieAlgebraModule{C}) -> Vector{Symbol}

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

Experimental

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

source

Element constructors

(V::LieAlgebraModule{C})() returns the zero element of the Lie algebra module V.

(V::LieAlgebraModule{C})(v::LieAlgebraModuleElem{C}) returns v if v is an element of L. If V is the dual module of the parent of v, it returns the dual of v. In all other cases, it fails.

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

(V::LieAlgebraModule{C})(a::Vector{T}) where {T<:LieAlgebraModuleElem{C}}): If V is a direct sum, return its element, where the $i$-th component is equal to a[i]. If V is a tensor product, return the tensor product of the a[i]. If V is a exterior (symmetric, tensor) power, return the wedge product (product, tensor product) of the a[i]. Requires that a has a suitable length, and that the a[i] are elements of the correct modules, where correct depends on the case above.

Arithmetics

The usual arithmetics, e.g. +, -, and * (scalar multiplication), are defined for LieAlgebraModuleElems.

The module action is defined as *.

*Method
action(x::LieAlgebraElem{C}, v::LieAlgebraModuleElem{C}) -> LieAlgebraModuleElem{C}
*(x::LieAlgebraElem{C}, v::LieAlgebraModuleElem{C}) -> LieAlgebraModuleElem{C}

Apply the action of x on v.

Experimental

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

source

Module constructors

trivial_moduleFunction
trivial_module(L::LieAlgebra{C}, d=1) -> LieAlgebraModule{C}

Construct the d-dimensional module of the Lie algebra L with trivial action.

Examples

julia> L = special_linear_lie_algebra(QQ, 3);

julia> trivial_module(L)
Abstract Lie algebra module
  of dimension 1
over special linear Lie algebra of degree 3 over QQ
Experimental

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

source
standard_moduleMethod
standard_module(L::LinearLieAlgebra{C}; cached::Bool=true) -> LieAlgebraModule{C}

Construct the standard module of the linear Lie algebra L. If L is a Lie subalgebra of $\mathfrak{gl}_n(R)$, then the standard module is $R^n$ with the action of $L$ given by left multiplication.

Note

This uses the left action of $L$, and converts that to internally use the equivalent right action.

Examples

julia> L = special_linear_lie_algebra(QQ, 3);

julia> standard_module(L)
Standard module
  of dimension 3
over special linear Lie algebra of degree 3 over QQ
Experimental

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

source
dualMethod
dual(V::LieAlgebraModule{C}; cached::Bool=true) -> LieAlgebraModule{C}

Construct the dual module of V.

Examples

julia> L = special_linear_lie_algebra(QQ, 3);

julia> V = exterior_power(standard_module(L), 2)[1]; # some module

julia> dual(V)
Dual module
  of dimension 3
  dual of
    2nd exterior power of
      standard module
over special linear Lie algebra of degree 3 over QQ
Experimental

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

source
direct_sumMethod
direct_sum(V::LieAlgebraModule{C}...) -> LieAlgebraModule{C}
⊕(V::LieAlgebraModule{C}...) -> LieAlgebraModule{C}

Construct the direct sum of the modules V....

Examples

julia> L = special_linear_lie_algebra(QQ, 3);

julia> V1 = exterior_power(standard_module(L), 2)[1]; # some module

julia> V2 = symmetric_power(standard_module(L), 3)[1]; # some module

julia> direct_sum(V1, V2)
Direct sum module
  of dimension 13
  direct sum with direct summands
    2nd exterior power of
      standard module
    3rd symmetric power of
      standard module
over special linear Lie algebra of degree 3 over QQ
Experimental

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

source
tensor_productMethod
tensor_product(Vs::LieAlgebraModule{C}...) -> LieAlgebraModule{C}
⊗(Vs::LieAlgebraModule{C}...) -> LieAlgebraModule{C}

Given modules $V_1,\dots,V_n$ over the same Lie algebra $L$, construct their tensor product $V_1 \otimes \cdots \otimes V_n$.

Examples

julia> L = special_linear_lie_algebra(QQ, 3);

julia> V1 = exterior_power(standard_module(L), 2)[1]; # some module

julia> V2 = symmetric_power(standard_module(L), 3)[1]; # some module

julia> tensor_product(V1, V2)
Tensor product module
  of dimension 30
  tensor product with tensor factors
    2nd exterior power of
      standard module
    3rd symmetric power of
      standard module
over special linear Lie algebra of degree 3 over QQ
Experimental

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

source
exterior_powerMethod
exterior_power(V::LieAlgebraModule{C}, k::Int; cached::Bool=true) -> LieAlgebraModule{C}, Map

Construct the k-th exterior power $\bigwedge^k (V)$ of the module V, together with a map that computes the wedge product of k elements of V.

Examples

julia> L = special_linear_lie_algebra(QQ, 2);

julia> V = symmetric_power(standard_module(L), 2)[1]; # some module

julia> E, map = exterior_power(V, 2)
(Exterior power module of dimension 3 over L, Map: parent of tuples of type Tuple{LieAlgebraModuleElem{QQFieldElem, LinearLieAlgebraElem{QQFieldElem}}, LieAlgebraModuleElem{QQFieldElem, LinearLieAlgebraElem{QQFieldElem}}} -> E)

julia> E
Exterior power module
  of dimension 3
  2nd exterior power of
    2nd symmetric power of
      standard module
over special linear Lie algebra of degree 2 over QQ

julia> basis(E)
3-element Vector{LieAlgebraModuleElem{QQFieldElem, LinearLieAlgebraElem{QQFieldElem}}}:
 (v_1^2)^(v_1*v_2)
 (v_1^2)^(v_2^2)
 (v_1*v_2)^(v_2^2)
Experimental

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

source
symmetric_powerMethod
symmetric_power(V::LieAlgebraModule{C}, k::Int; cached::Bool=true) -> LieAlgebraModule{C}, Map

Construct the k-th symmetric power $S^k (V)$ of the module V, together with a map that computes the product of k elements of V.

Examples

julia> L = special_linear_lie_algebra(QQ, 4);

julia> V = exterior_power(standard_module(L), 3)[1]; # some module

julia> S, map = symmetric_power(V, 2)
(Symmetric power module of dimension 10 over L, Map: parent of tuples of type Tuple{LieAlgebraModuleElem{QQFieldElem, LinearLieAlgebraElem{QQFieldElem}}, LieAlgebraModuleElem{QQFieldElem, LinearLieAlgebraElem{QQFieldElem}}} -> S)

julia> S
Symmetric power module
  of dimension 10
  2nd symmetric power of
    3rd exterior power of
      standard module
over special linear Lie algebra of degree 4 over QQ

julia> basis(S)
10-element Vector{LieAlgebraModuleElem{QQFieldElem, LinearLieAlgebraElem{QQFieldElem}}}:
 (v_1^v_2^v_3)^2
 (v_1^v_2^v_3)*(v_1^v_2^v_4)
 (v_1^v_2^v_3)*(v_1^v_3^v_4)
 (v_1^v_2^v_3)*(v_2^v_3^v_4)
 (v_1^v_2^v_4)^2
 (v_1^v_2^v_4)*(v_1^v_3^v_4)
 (v_1^v_2^v_4)*(v_2^v_3^v_4)
 (v_1^v_3^v_4)^2
 (v_1^v_3^v_4)*(v_2^v_3^v_4)
 (v_2^v_3^v_4)^2
Experimental

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

source
tensor_powerMethod
tensor_power(V::LieAlgebraModule{C}, k::Int; cached::Bool=true) -> LieAlgebraModule{C}, Map

Construct the k-th tensor power $T^k (V)$ of the module V, together with a map that computes the tensor product of k elements of V.

Examples

julia> L = special_linear_lie_algebra(QQ, 3);

julia> V = exterior_power(standard_module(L), 2)[1]; # some module

julia> T, map = tensor_power(V, 2)
(Tensor power module of dimension 9 over L, Map: parent of tuples of type Tuple{LieAlgebraModuleElem{QQFieldElem, LinearLieAlgebraElem{QQFieldElem}}, LieAlgebraModuleElem{QQFieldElem, LinearLieAlgebraElem{QQFieldElem}}} -> T)

julia> T
Tensor power module
  of dimension 9
  2nd tensor power of
    2nd exterior power of
      standard module
over special linear Lie algebra of degree 3 over QQ

julia> basis(T)
9-element Vector{LieAlgebraModuleElem{QQFieldElem, LinearLieAlgebraElem{QQFieldElem}}}:
 (v_1^v_2)(x)(v_1^v_2)
 (v_1^v_2)(x)(v_1^v_3)
 (v_1^v_2)(x)(v_2^v_3)
 (v_1^v_3)(x)(v_1^v_2)
 (v_1^v_3)(x)(v_1^v_3)
 (v_1^v_3)(x)(v_2^v_3)
 (v_2^v_3)(x)(v_1^v_2)
 (v_2^v_3)(x)(v_1^v_3)
 (v_2^v_3)(x)(v_2^v_3)
Experimental

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

source
abstract_moduleMethod
abstract_module(L::LieAlgebra{C}, dimV::Int, transformation_matrices::Vector{<:MatElem{C}}, s::Vector{<:VarName}; check::Bool) -> LieAlgebraModule{C}

Construct the the Lie algebra module over L of dimension dimV given by transformation_matrices and with basis element names s.

  • transformation_matrices: The action of the $i$-th basis element of L on some element $v$ of the constructed module is given by right multiplication of the matrix transformation_matrices[i] to the coefficient vector of $v$.
  • s: A vector of basis element names. This is [Symbol("v_$i") for i in 1:dimV] 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
abstract_moduleMethod
abstract_module(L::LieAlgebra{C}, dimV::Int, struct_consts::Matrix{sparse_row_type{C}}, s::Vector{<:VarName}; check::Bool) -> LieAlgebraModule{C}

Construct the the Lie algebra module over L of dimension dimV given by structure constants struct_consts and with basis element names s.

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

  • s: A vector of basis element names. This is [Symbol("v_$i") for i in 1:dimV] 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

Representation theory of semisimple Lie algebras in characteristic 0

Functions concerning simple modules

simple_moduleMethod
simple_module(L::LieAlgebra{C}, hw::WeightLatticeElem) -> LieAlgebraModule{C}
simple_module(L::LieAlgebra{C}, hw::Vector{<:IntegerUnion}) -> LieAlgebraModule{C}

Construct the simple module of the Lie algebra L with highest weight hw.

L needs to be a semisimple Lie algebra of characteristic $0$.

Experimental

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

source
dim_of_simple_moduleMethod
dim_of_simple_module(
  [T = Int],
  L::LieAlgebra *or* R::RootSystem,
  hw::WeightLatticeElem *or* hw::Vector{<:IntegerUnion},
) -> T

Compute the dimension of the simple module with highest weight hw using Weyl's dimension formula.

One can either provide a semisimple Lie algebra of characteristic $0$, or its root system.

The return value is of type T.

Examples

julia> L = lie_algebra(QQ, :A, 3);

julia> dim_of_simple_module(L, [1, 1, 1])
64
julia> R = root_system(:B, 2);

julia> dim_of_simple_module(R, fundamental_weight(R, 1))
5
Experimental

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

source
dominant_weightsMethod
dominant_weights(
  L::LieAlgebra *or* R::RootSystem, 
  hw::WeightLatticeElem *or* hw::Vector{<:IntegerUnion},
) -> Vector{WeightLatticeElem}

Compute the dominant weights occurring in the simple module with highest weight hw, sorted ascendingly by the total height of roots needed to reach them from hw.

One can either provide a semisimple Lie algebra of characteristic $0$, or its root system.

Examples

julia> L = lie_algebra(QQ, :B, 3);

julia> dominant_weights(L, [1, 0, 3])
7-element Vector{WeightLatticeElem}:
 w_1 + 3*w_3
 w_1 + w_2 + w_3
 2*w_1 + w_3
 3*w_3
 w_2 + w_3
 w_1 + w_3
 w_3
julia> R = root_system(:B, 3);

julia> dominant_weights(R, 3 * fundamental_weight(R, 1) + fundamental_weight(R, 3))
7-element Vector{WeightLatticeElem}:
 3*w_1 + w_3
 w_1 + w_2 + w_3
 2*w_1 + w_3
 3*w_3
 w_2 + w_3
 w_1 + w_3
 w_3
Experimental

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

source
dominant_characterMethod
dominant_character(
  [T = Int],
  L::LieAlgebra *or* R::RootSystem,
  hw::WeightLatticeElem *or* hw::Vector{<:IntegerUnion}
) -> Dict{WeightLatticeElem, T}

Compute the dominant weights occurring in the simple module with highest weight hw together with their multiplicities.

One can either provide a semisimple Lie algebra of characteristic $0$, or its root system.

This function uses an optimized version of the Freudenthal formula, see [MP82] for details.

Examples

julia> L = lie_algebra(QQ, :A, 3);

julia> dominant_character(L, [2, 1, 0])
Dict{WeightLatticeElem, Int64} with 4 entries:
  0           => 3
  2*w_2       => 1
  w_1 + w_3   => 2
  2*w_1 + w_2 => 1
julia> R = root_system(:B, 3);

julia> dominant_character(R, 2 * fundamental_weight(R, 1) + fundamental_weight(R, 3))
Dict{WeightLatticeElem, Int64} with 4 entries:
  w_2 + w_3   => 1
  2*w_1 + w_3 => 1
  w_1 + w_3   => 3
  w_3         => 6
Experimental

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

source
characterMethod
character(
  [T = Int],
  L::LieAlgebra *or* R::RootSystem,
  hw::WeightLatticeElem *or* hw::Vector{<:IntegerUnion},
) -> Dict{WeightLatticeElem, T}

Compute all dominant weights occurring in the simple module with highest weight hw together with their multiplicities.

One can either provide a semisimple Lie algebra of characteristic $0$, or its root system.

This is achieved by acting with the Weyl group on the dominant_character.

Examples

julia> L = lie_algebra(QQ, :A, 3);

julia> character(L, [2, 0, 0])
Dict{WeightLatticeElem, Int64} with 10 entries:
  -2*w_3           => 1
  -2*w_2 + 2*w_3   => 1
  2*w_1            => 1
  -2*w_1 + 2*w_2   => 1
  -w_1 + w_3       => 1
  w_2              => 1
  w_1 - w_2 + w_3  => 1
  w_1 - w_3        => 1
  -w_1 + w_2 - w_3 => 1
  -w_2             => 1
julia> R = root_system(:B, 3);

julia> character(R, fundamental_weight(R, 3))
Dict{WeightLatticeElem, Int64} with 8 entries:
  -w_1 + w_2 - w_3 => 1
  w_1 - w_3        => 1
  -w_2 + w_3       => 1
  w_3              => 1
  w_2 - w_3        => 1
  -w_3             => 1
  w_1 - w_2 + w_3  => 1
  -w_1 + w_3       => 1
Experimental

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

source
tensor_product_decompositionMethod
tensor_product_decomposition(
  L::LieAlgebra *or* R::RootSystem,
  hw1::WeightLatticeElem *or* hw1::Vector{<:IntegerUnion},
  hw2::WeightLatticeElem *or* hw1::Vector{<:IntegerUnion},
) -> MSet{Vector{Int}}

Compute the decomposition of the tensor product of the simple modules with highest weights hw1 and hw2 into simple modules with their multiplicities.

One can either provide a semisimple Lie algebra of characteristic $0$, or its root system.

This function uses Klimyk's formula (see [Hum72, Exercise 24.9]).

The return type may change in the future.

Examples

julia> L = lie_algebra(QQ, :A, 2);

julia> tensor_product_decomposition(L, [1, 0], [0, 1])
MSet{Vector{Int64}} with 2 elements:
  [0, 0]
  [1, 1]

julia> tensor_product_decomposition(L, [1, 1], [1, 1])
MSet{Vector{Int64}} with 6 elements:
  [0, 0]
  [1, 1] : 2
  [2, 2]
  [3, 0]
  [0, 3]
julia> R = root_system(:B, 2);

julia> tensor_product_decomposition(R, fundamental_weight(R, 1), fundamental_weight(R, 2))
MSet{Vector{Int64}} with 2 elements:
  [1, 1]
  [0, 1]

julia> tensor_product_decomposition(R, weyl_vector(R), weyl_vector(R))
MSet{Vector{Int64}} with 10 elements:
  [0, 0]
  [0, 4]
  [0, 2] : 2
  [2, 0]
  [1, 0]
  [2, 2]
  [3, 0]
  [1, 2] : 2
Experimental

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

source

Functions concerning Demazure modules

demazure_operatorMethod
demazure_operator(r::RootSpaceElem, w::WeightLatticeElem) -> Dict{WeightLatticeElem,Int}
demazure_operator(r::RootSpaceElem, groupringelem::Dict{WeightLatticeElem,T}) where {T<:IntegerUnion} -> Dict{WeightLatticeElem,T}

Compute the action of the Demazure operator (see [Dem74]) associated to the positive root r on the given element of the group ring $\mathbb{Z}[P]$, where $P$ denotes the additive group of the weight lattice.

If a single weight lattice element w is supplied, this is interpreted as Dict(w => 1).

Examples

julia> R = root_system(:A, 3);

julia> pos_r = positive_root(R, 4)
a_1 + a_2

julia> w = fundamental_weight(R, 1)
w_1

julia> demazure_operator(pos_r, w)
Dict{WeightLatticeElem, Int64} with 2 entries:
  -w_2 + w_3 => 1
  w_1        => 1
Experimental

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

source
demazure_characterMethod
demazure_character(
  [T = Int],
  L::LieAlgebra *or* R::RootSystem,
  w::WeightLatticeElem *or* w::Vector{<:IntegerUnion},
  x::WeylGroupElem *or* reduced_expr::Vector{<:IntegerUnion},
) -> Dict{WeightLatticeElem, T}

Compute all weights occurring in the Demazure module with extremal weight w * x together with their multiplicities, using the Demazure dimension formula (see [Dem74]).

One can either provide a semisimple Lie algebra of characteristic $0$, or its root system.

Instead of a Weyl group element x, a reduced expression for x can be supplied. This function may return arbitrary results if the provided expression is not reduced.

Examples

julia> L = lie_algebra(QQ, :A, 2);

julia> demazure_character(L, [1, 1], [2, 1])
Dict{WeightLatticeElem, Int64} with 5 entries:
  2*w_1 - w_2  => 1
  w_1 + w_2    => 1
  0            => 1
  -w_1 + 2*w_2 => 1
  -2*w_1 + w_2 => 1
julia> R = root_system(:B, 3);

julia> demazure_character(R, fundamental_weight(R, 2), weyl_group(R)([1, 2, 3]))
Dict{WeightLatticeElem, Int64} with 4 entries:
  w_1 + w_2 - 2*w_3 => 1
  w_1               => 1
  w_1 - w_2 + 2*w_3 => 1
  w_2               => 1
Experimental

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

source