Lie algebra modules

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

Return the Lie algebra V is a module over.

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

Return the zero element of the Lie algebra module V.

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

Check whether the Lie algebra module element v is zero.

dim(V::LieAlgebraModule{C}) -> Int

Return the dimension of the Lie algebra module V.

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

Return a basis of the Lie algebra module V.

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

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

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

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

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

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

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

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

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

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

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

Apply the action of x on v.

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

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.

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

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

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

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

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)

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

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)

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.

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.

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

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

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

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

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

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

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

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.

For Demazure characters of generalized flag manifolds, as in [PS09], see demazure_character(::AbstractVector, ::PermGroupElem).

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