Skip to content

Commit

Permalink
LieAlgebras: Collect and update rep theory stuff (#4541)
Browse files Browse the repository at this point in the history
  • Loading branch information
@lgoettgens
lgoettgens authored Feb 11, 2025
1 parent 0caad7b commit 12ab2af
Show file tree
Hide file tree
Showing 16 changed files with 1,447 additions and 1,425 deletions.
11 changes: 11 additions & 0 deletions docs/oscar_references.bib
View file
Original file line number Diff line number Diff line change
Expand Up @@ -937,6 +937,17 @@ @Book{DSS09
zbmath = {5303649}
}

@Article{Dem74,
author = {Demazure, Michel},
title = {Une nouvelle formule des caractères},
journal = {Bull. Sci. Math. (2)},
fjournal = {Bulletin des Sciences Mathématiques. 2e Série},
volume = {98},
number = {3},
pages = {163--172},
year = {1974}
}

@Article{Der99,
author = {Derksen, Harm},
title = {Computation of invariants for reductive groups},
Expand Down
1 change: 1 addition & 0 deletions experimental/LieAlgebras/docs/src/lie_algebras.md
View file
Original file line number Diff line number Diff line change
Expand Up @@ -58,6 +58,7 @@ The usual arithmetics, e.g. `+`, `-`, and `*`, are defined for `LieAlgebraElem`s
is_abelian(L::LieAlgebra)
is_nilpotent(L::LieAlgebra)
is_perfect(L::LieAlgebra)
is_semisimple(L::LieAlgebra)
is_simple(L::LieAlgebra)
is_solvable(L::LieAlgebra)
```
Expand Down
20 changes: 20 additions & 0 deletions experimental/LieAlgebras/docs/src/modules.md
View file
Original file line number Diff line number Diff line change
Expand Up @@ -61,3 +61,23 @@ tensor_power(::LieAlgebraModule{C}, ::Int) where {C<:FieldElem}
abstract_module(::LieAlgebra{C}, ::Int, ::Vector{<:MatElem{C}}, ::Vector{<:VarName}; ::Bool) where {C<:FieldElem}
abstract_module(::LieAlgebra{C}, ::Int, ::Matrix{SRow{C}}, ::Vector{<:VarName}; ::Bool) where {C<:FieldElem}
```

## Representation theory of semisimple Lie algebras in characteristic 0

### Functions concerning simple modules

```@docs
simple_module(::LieAlgebra, ::WeightLatticeElem)
dim_of_simple_module(::LieAlgebra, ::WeightLatticeElem)
dominant_weights(::LieAlgebra, ::WeightLatticeElem)
dominant_character(::LieAlgebra, ::WeightLatticeElem)
character(::LieAlgebra, ::WeightLatticeElem)
tensor_product_decomposition(::LieAlgebra, ::WeightLatticeElem, ::WeightLatticeElem)
```

### Functions concerning Demazure modules

```@docs
demazure_operator(::RootSpaceElem, ::Dict{WeightLatticeElem,<:IntegerUnion})
demazure_character(::LieAlgebra, ::WeightLatticeElem, ::WeylGroupElem)
```
12 changes: 12 additions & 0 deletions experimental/LieAlgebras/src/AbstractLieAlgebra.jl
View file
Original file line number Diff line number Diff line change
Expand Up @@ -377,6 +377,18 @@ function _struct_consts(R::Field, rs::RootSystem, extraspecial_pair_signs)
return struct_consts
end

# computes the maximum `p` such that `beta - p*alpha` is still a root
# beta is assumed to be a root
function _root_string_length_down(alpha::RootSpaceElem, beta::RootSpaceElem)
p = 0
beta_sub_p_alpha = beta - alpha
while is_root(beta_sub_p_alpha)
p += 1
beta_sub_p_alpha = sub!(beta_sub_p_alpha, alpha)
end
return p
end

function _N_matrix(rs::RootSystem, extraspecial_pair_signs::Vector{Bool})
# computes the matrix N_αβ from CTM04 Ch. 3 indexed by root indices
nroots = n_roots(rs)
Expand Down
15 changes: 15 additions & 0 deletions experimental/LieAlgebras/src/LieAlgebra.jl
View file
Original file line number Diff line number Diff line change
Expand Up @@ -410,6 +410,21 @@ Return `true` if `L` is perfect, i.e. $[L, L] = L$.
return dim(derived_algebra(L)) == dim(L)
end

@doc raw"""
is_semisimple(L::LieAlgebra) -> Bool
Return `true` if `L` is semisimple, i.e. the solvable radical of `L` is zero.
!!! warning
This function is not implemented yet for all cases in positive characteristic.
"""
@attr Bool function is_semisimple(L::LieAlgebra)
has_attribute(L, :is_simple) && is_simple(L) && return true
is_invertible(killing_matrix(L)) && return true
characteristic(L) == 0 && return false
error("Not implemented.") # TODO
end

@doc raw"""
is_simple(L::LieAlgebra) -> Bool
Expand Down
285 changes: 0 additions & 285 deletions experimental/LieAlgebras/src/LieAlgebraModule.jl
View file
Original file line number Diff line number Diff line change
Expand Up @@ -1376,288 +1376,3 @@ function tensor_power(

return T, mult_map
end

###############################################################################
#
# Simple modules (via highest weight) of semisimple Lie algebras
#
###############################################################################

# TODO: add semisimplicity check once that is available

# TODO: move to RootSystem.jl
function is_dominant_weight(hw::Vector{<:IntegerUnion})
return all(>=(0), hw)
end

@doc raw"""
simple_module(L::LieAlgebra{C}, hw::Vector{Int}) -> LieAlgebraModule{C}
Construct the simple module of the Lie algebra `L` with highest weight `hw`.
"""
function simple_module(L::LieAlgebra, hw::Vector{Int})
@req is_dominant_weight(hw) "Not a dominant weight."
struct_consts = lie_algebra_simple_module_struct_consts_gap(L, hw)
dimV = size(struct_consts, 2)
V = abstract_module(L, dimV, struct_consts; check=false)
# TODO: set appropriate attributes
return V
end

@doc raw"""
dim_of_simple_module([T = Int], L::LieAlgebra{C}, hw::WeightLatticeElem) -> T
dim_of_simple_module([T = Int], L::LieAlgebra{C}, hw::Vector{<:IntegerUnion}) -> T
Compute the dimension of the simple module of the Lie algebra `L` with highest weight `hw`
using Weyl's dimension formula.
The return value is of type `T`.
# Examples
```jldoctest
julia> L = lie_algebra(QQ, :A, 3);
julia> dim_of_simple_module(L, [1, 1, 1])
64
```
"""
function dim_of_simple_module(L::LieAlgebra, hw::WeightLatticeElem)
return dim_of_simple_module(root_system(L), hw)
end

function dim_of_simple_module(T::Type, L::LieAlgebra, hw::WeightLatticeElem)
return dim_of_simple_module(T, root_system(L), hw)
end

function dim_of_simple_module(L::LieAlgebra, hw::Vector{<:IntegerUnion})
return dim_of_simple_module(root_system(L), hw)
end

function dim_of_simple_module(T::Type, L::LieAlgebra, hw::Vector{<:IntegerUnion})
return dim_of_simple_module(T, root_system(L), hw)
end

@doc raw"""
dominant_weights(L::LieAlgebra{C}, hw::WeightLatticeElem) -> Vector{WeightLatticeElem}
dominant_weights(L::LieAlgebra{C}, hw::Vector{<:IntegerUnion}) -> Vector{WeightLatticeElem}
Computes the dominant weights occurring in the simple module of the Lie algebra `L` with highest weight `hw`,
sorted ascendingly by the total height of roots needed to reach them from `hw`.
See [MP82](@cite) for details and the implemented algorithm.
# Examples
```jldoctest
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
```
"""
function dominant_weights(L::LieAlgebra, hw::WeightLatticeElem)
return dominant_weights(root_system(L), hw)
end

function dominant_weights(L::LieAlgebra, hw::Vector{<:IntegerUnion})
return dominant_weights(root_system(L), hw)
end

@doc raw"""
dominant_character([T = Int], L::LieAlgebra{C}, hw::WeightLatticeElem) -> Dict{WeightLatticeElem, T}
dominant_character([T = Int], L::LieAlgebra{C}, hw::Vector{<:IntegerUnion}) -> Dict{WeightLatticeElem, T}
Computes the dominant weights occurring in the simple module of the Lie algebra `L` with highest weight `hw`,
together with their multiplicities.
This function uses an optimized version of the Freudenthal formula, see [MP82](@cite) for details.
# Examples
```jldoctest
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
```
"""
function dominant_character(L::LieAlgebra, hw::WeightLatticeElem)
return dominant_character(root_system(L), hw)
end

function dominant_character(T::DataType, L::LieAlgebra, hw::WeightLatticeElem)
return dominant_character(T, root_system(L), hw)
end

function dominant_character(L::LieAlgebra, hw::Vector{<:IntegerUnion})
return dominant_character(root_system(L), hw)
end

function dominant_character(T::DataType, L::LieAlgebra, hw::Vector{<:IntegerUnion})
return dominant_character(T, root_system(L), hw)
end

@doc raw"""
character([T = Int], L::LieAlgebra{C}, hw::WeightLatticeElem) -> Dict{WeightLatticeElem, T}
character([T = Int], L::LieAlgebra{C}, hw::Vector{<:IntegerUnion}) -> Dict{WeightLatticeElem, T}
Computes all weights occurring in the simple module of the Lie algebra `L` with highest weight `hw`,
together with their multiplicities.
This is achieved by acting with the Weyl group on the [`dominant_character`](@ref dominant_character(::LieAlgebra, ::Vector{<:IntegerUnion})).
# Examples
```jldoctest
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
```
"""
function character(L::LieAlgebra, hw::WeightLatticeElem)
return character(root_system(L), hw)
end

function character(T::DataType, L::LieAlgebra, hw::WeightLatticeElem)
return character(T, root_system(L), hw)
end

function character(L::LieAlgebra, hw::Vector{<:IntegerUnion})
return character(root_system(L), hw)
end

function character(T::DataType, L::LieAlgebra, hw::Vector{<:IntegerUnion})
return character(T, root_system(L), hw)
end

@doc raw"""
tensor_product_decomposition(L::LieAlgebra, hw1::WeightLatticeElem, hw2::WeightLatticeElem) -> MSet{Vector{Int}}
tensor_product_decomposition(L::LieAlgebra, hw1::Vector{<:IntegerUnion}, hw2::Vector{<:IntegerUnion}) -> MSet{Vector{Int}}
Computes the decomposition of the tensor product of the simple modules of the Lie algebra `L` with highest weights `hw1` and `hw2`
into simple modules with their multiplicities.
This function uses Klimyk's formula (see [Hum72; Exercise 24.9](@cite)).
The return type may change in the future.
# Examples
```jldoctest
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]
```
"""
function tensor_product_decomposition(
L::LieAlgebra, hw1::Vector{<:IntegerUnion}, hw2::Vector{<:IntegerUnion}
)
return tensor_product_decomposition(root_system(L), hw1, hw2)
end

function tensor_product_decomposition(
L::LieAlgebra, hw1::WeightLatticeElem, hw2::WeightLatticeElem
)
return tensor_product_decomposition(root_system(L), hw1, hw2)
end

@doc raw"""
demazure_character([T = Int], L::LieAlgebra, w::WeightLatticeElem, x::WeylGroupElem) -> Dict{WeightLatticeElem, T}
demazure_character([T = Int], L::LieAlgebra, w::Vector{<:IntegerUnion}, x::WeylGroupElem) -> Dict{WeightLatticeElem, T}
demazure_character([T = Int], L::LieAlgebra, w::WeightLatticeElem, reduced_expr::Vector{<:IntegerUnion}) -> Dict{WeightLatticeElem, T}
demazure_character([T = Int], L::LieAlgebra, w::Vector{<:IntegerUnion}, reduced_expr::Vector{<:IntegerUnion}) -> Dict{WeightLatticeElem, T}
Computes all weights occurring in the Demazure module of the Lie algebra `L``
with extremal weight `w * x`, together with their multiplicities.
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
```jldoctest
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
```
"""
function demazure_character(L::LieAlgebra, w::WeightLatticeElem, x::WeylGroupElem)
return demazure_character(root_system(L), w, x)
end

function demazure_character(
T::DataType, L::LieAlgebra, w::WeightLatticeElem, x::WeylGroupElem
)
return demazure_character(T, root_system(L), w, x)
end

function demazure_character(
L::LieAlgebra, w::WeightLatticeElem, reduced_expression::Vector{<:IntegerUnion}
)
return demazure_character(root_system(L), w, reduced_expression)
end

function demazure_character(
T::DataType,
L::LieAlgebra,
w::WeightLatticeElem,
reduced_expression::Vector{<:IntegerUnion},
)
return demazure_character(T, root_system(L), w, reduced_expression)
end

function demazure_character(L::LieAlgebra, w::Vector{<:IntegerUnion}, x::WeylGroupElem)
return demazure_character(root_system(L), w, x)
end

function demazure_character(
T::DataType, L::LieAlgebra, w::Vector{<:IntegerUnion}, x::WeylGroupElem
)
return demazure_character(T, root_system(L), w, x)
end

function demazure_character(
L::LieAlgebra, w::Vector{<:IntegerUnion}, reduced_expression::Vector{<:IntegerUnion}
)
return demazure_character(root_system(L), w, reduced_expression)
end

function demazure_character(
T::DataType,
L::LieAlgebra,
w::Vector{<:IntegerUnion},
reduced_expression::Vector{<:IntegerUnion},
)
return demazure_character(T, root_system(L), w, reduced_expression)
end
Loading

0 comments on commit 12ab2af

Please sign in to comment.