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_algebra
— Methodbase_lie_algebra(V::LieAlgebraModule{C}) -> LieAlgebra{C}
Return the Lie algebra V
is a module over.
This function is part of the experimental code in Oscar. Please read here for more details.
zero
— Methodzero(V::LieAlgebraModule{C}) -> LieAlgebraModuleElem{C}
Return the zero element of the Lie algebra module V
.
This function is part of the experimental code in Oscar. Please read here for more details.
iszero
— Methodiszero(v::LieAlgebraModuleElem{C}) -> Bool
Check whether the Lie algebra module element v
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
— Methoddim(V::LieAlgebraModule{C}) -> Int
Return the dimension of the Lie algebra module V
.
This function is part of the experimental code in Oscar. Please read here for more details.
basis
— Methodbasis(V::LieAlgebraModule{C}) -> Vector{LieAlgebraModuleElem{C}}
Return a basis of the Lie algebra module V
.
This function is part of the experimental code in Oscar. Please read here for more details.
basis
— Methodbasis(V::LieAlgebraModule{C}, i::Int) -> LieAlgebraModuleElem{C}
Return the i
-th basis element of the Lie algebra module V
.
This function is part of the experimental code in Oscar. Please read here for more details.
coefficients
— Methodcoefficients(v::LieAlgebraModuleElem{C}) -> Vector{C}
Return the coefficients of v
with respect to basis(::LieAlgebraModule)
.
This function is part of the experimental code in Oscar. Please read here for more details.
coeff
— Methodcoeff(v::LieAlgebraModuleElem{C}, i::Int) -> C
Return the i
-th coefficient of v
with respect to basis(::LieAlgebraModule)
.
This function is part of the experimental code in Oscar. Please read here for more details.
getindex
— Methodgetindex(v::LieAlgebraModuleElem{C}, i::Int) -> C
Return the i
-th coefficient of v
with respect to basis(::LieAlgebraModule)
.
This function is part of the experimental code in Oscar. Please read here for more details.
symbols
— Methodsymbols(V::LieAlgebraModule{C}) -> Vector{Symbol}
Return the symbols used for printing basis elements of the Lie algebra module V
.
This function is part of the experimental code in Oscar. Please read here for more details.
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 LieAlgebraModuleElem
s.
The module action is defined as *
.
*
— Methodaction(x::LieAlgebraElem{C}, v::LieAlgebraModuleElem{C}) -> LieAlgebraModuleElem{C}
*(x::LieAlgebraElem{C}, v::LieAlgebraModuleElem{C}) -> LieAlgebraModuleElem{C}
Apply the action of x
on v
.
This function is part of the experimental code in Oscar. Please read here for more details.
Module constructors
trivial_module
— Functiontrivial_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
This function is part of the experimental code in Oscar. Please read here for more details.
standard_module
— Methodstandard_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.
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
This function is part of the experimental code in Oscar. Please read here for more details.
dual
— Methoddual(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
This function is part of the experimental code in Oscar. Please read here for more details.
direct_sum
— Methoddirect_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
This function is part of the experimental code in Oscar. Please read here for more details.
tensor_product
— Methodtensor_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
This function is part of the experimental code in Oscar. Please read here for more details.
exterior_power
— Methodexterior_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)
This function is part of the experimental code in Oscar. Please read here for more details.
symmetric_power
— Methodsymmetric_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
This function is part of the experimental code in Oscar. Please read here for more details.
tensor_power
— Methodtensor_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)
This function is part of the experimental code in Oscar. Please read here for more details.
abstract_module
— Methodabstract_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 ofL
on some element $v$ of the constructed module is given by right multiplication of the matrixtransformation_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
: Iftrue
, check that the structure constants are anti-symmetric and satisfy the Jacobi identity. This istrue
by default.
This function is part of the experimental code in Oscar. Please read here for more details.
abstract_module
— Methodabstract_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
: Iftrue
, check that the structure constants are anti-symmetric and satisfy the Jacobi identity. This istrue
by default.
This function is part of the experimental code in Oscar. Please read here for more details.
Representation theory of semisimple Lie algebras in characteristic 0
Functions concerning simple modules
simple_module
— Methodsimple_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$.
This function is part of the experimental code in Oscar. Please read here for more details.
dim_of_simple_module
— Methoddim_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
This function is part of the experimental code in Oscar. Please read here for more details.
dominant_weights
— Methoddominant_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
This function is part of the experimental code in Oscar. Please read here for more details.
dominant_character
— Methoddominant_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
This function is part of the experimental code in Oscar. Please read here for more details.
character
— Methodcharacter(
[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
This function is part of the experimental code in Oscar. Please read here for more details.
tensor_product_decomposition
— Methodtensor_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
This function is part of the experimental code in Oscar. Please read here for more details.
Functions concerning Demazure modules
demazure_operator
— Methoddemazure_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
This function is part of the experimental code in Oscar. Please read here for more details.
demazure_character
— Methoddemazure_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
This function is part of the experimental code in Oscar. Please read here for more details.