Root systems

root_system(cartan_matrix::ZZMatrix; check::Bool=true, detect_type::Bool=true) -> RootSystem
root_system(cartan_matrix::Matrix{<:Integer}; check::Bool=true, detect_type::Bool=true) -> RootSystem

Construct the root system defined by the given (generalized) Cartan matrix.

If check=true the function will verify that cartan_matrix is indeed a generalized Cartan matrix. Passing detect_type=false will skip the detection of the root system type.

Examples

julia> root_system([2 -1; -1 2])
Root system of rank 2
  of type A2

julia> root_system(matrix(ZZ, 2, 2, [2, -1, -1, 2]); detect_type=false)
Root system of rank 2
  of unknown type

julia> root_system(matrix(ZZ, [2 -1 -2; -1 2 0; -1 0 2]))
Root system of rank 3
  of type C3 (with non-canonical ordering of simple roots)

root_system(fam::Symbol, rk::Int) -> RootSystem

Construct the root system of the given type.

The input must be a valid Cartan type, see is_cartan_type(::Symbol, ::Int).

Examples

julia> root_system(:A, 2)
Root system of rank 2
  of type A2

root_system(type::Vector{Tuple{Symbol,Int}}) -> RootSystem
root_system(type::Tuple{Symbol,Int}...) -> RootSystem

Construct the root system of the given type.

Each element of type must be a valid Cartan type, see is_cartan_type(::Symbol, ::Int). The vararg version needs at least one element.

Examples

julia> root_system([(:A, 2), (:F, 4)])
Root system of rank 6
  of type A2 x F4

julia> root_system(Tuple{Symbol,Int}[])
Root system of rank 0
  of type []

is_simple(R::RootSystem) -> Bool

Check if R is a simple root system.

rank(R::RootSystem) -> Int

Return the rank of R, i.e., the number of simple roots.

See also: number_of_simple_roots(::RootSystem).

cartan_matrix(R::RootSystem) -> ZZMatrix

Return the Cartan matrix defining R.

weyl_group(R::RootSystem) -> WeylGroup

Return the Weyl group of R.

Examples

julia> weyl_group(root_system([2 -1; -1 2]))
Weyl group
  of root system of rank 2
    of type A2

julia> weyl_group(root_system(matrix(ZZ, 2, 2, [2, -1, -1, 2]); detect_type=false))
Weyl group
  of root system of rank 2
    of unknown type

julia> weyl_group(root_system(matrix(ZZ, [2 -1 -2; -1 2 0; -1 0 2])))
Weyl group
  of root system of rank 3
    of type C3 (with non-canonical ordering of simple roots)

has_root_system_type(R::RootSystem) -> Bool

Check if the root system R already knows its Cartan type.

The type can then be queried with root_system_type(::RootSystem) and root_system_type_with_ordering(::RootSystem).

root_system_type(R::RootSystem) -> Vector{Tuple{Symbol,Int}}

Return the Cartan type of R.

If the type is already known, it is returned directly. This can be checked with has_root_system_type(::RootSystem).

If the type is not known, it is determined and stored in R.

See also: root_system_type_with_ordering(::RootSystem).

root_system_type_with_ordering(R::RootSystem) -> Vector{Tuple{Symbol,Int}}, Vector{Int}

Return the Cartan type of R, together with the ordering of the simple roots.

If the type is already known, it is returned directly. This can be checked with has_root_system_type(::RootSystem).

If the type is not known, it is determined and stored in R.

See also: root_system_type(::RootSystem).

number_of_roots(R::RootSystem) -> Int

Return the number of roots of R.

See also: roots(::RootSystem).

number_of_positive_roots(R::RootSystem) -> Int

Return the number of positive roots of R. This is the same as the number of negative roots.

See also: positive_roots(::RootSystem), negative_roots(::RootSystem).

number_of_simple_roots(R::RootSystem) -> Int

Return the number of simple roots of R.

See also: simple_roots(::RootSystem).

root(R::RootSystem, i::Int) -> RootSpaceElem

Return the i-th root of R.

This is a more efficient version for roots(R)[i].

See also: roots(::RootSystem).

roots(R::RootSystem) -> Vector{RootSpaceElem}

Return the roots of R, starting with the positive roots and then the negative roots, in the order of positive_roots(::RootSystem) and negative_roots(::RootSystem).

See also: root(::RootSystem, ::Int).

simple_root(R::RootSystem, i::Int) -> RootSpaceElem

Return the i-th simple root of R.

This is a more efficient version for simple_roots(R)[i].

See also: simple_roots(::RootSystem).

simple_roots(R::RootSystem) -> Vector{RootSpaceElem}

Return the simple roots of R.

See also: simple_root(::RootSystem, ::Int).

positive_root(R::RootSystem, i::Int) -> RootSpaceElem

Return the i-th positive root of R.

This is a more efficient version for positive_roots(R)[i].

See also: positive_roots(::RootSystem).

positive_roots(R::RootSystem) -> Vector{RootSpaceElem}

Return the positive roots of R, starting with the simple roots in the order of simple_roots(::RootSystem), and then increasing in height.

See also: positive_root(::RootSystem, ::Int).

Examples

julia> positive_roots(root_system(:A, 2))
3-element Vector{RootSpaceElem}:
 a_1
 a_2
 a_1 + a_2

negative_root(R::RootSystem, i::Int) -> RootSpaceElem

Return the i-th negative root of R, i.e. the negative of the i-th positive root.

This is a more efficient version for negative_roots(R)[i].

See also: negative_roots(::RootSystem).

negative_roots(R::RootSystem) -> Vector{RootSpaceElem}

Return the negative roots of R.

The $i$-th element of the returned vector is the negative root corresponding to the $i$-th positive root.

See also: positive_root(::RootSystem, ::Int).

Examples

julia> negative_roots(root_system(:A, 2))
3-element Vector{RootSpaceElem}:
 -a_1
 -a_2
 -a_1 - a_2

coroot(R::RootSystem, i::Int) -> DualRootSpaceElem

Return the coroot of the i-th root of R.

This is a more efficient version for coroots(R)[i].

See also: coroots(::RootSystem).

coroots(R::RootSystem) -> Vector{DualRootSpaceElem}

Return the coroots of R in the order of roots(::RootSystem), i.e. starting with the coroots of positive roots and then those of negative roots, each in the order of positive_coroots(::RootSystem) and negative_coroots(::RootSystem), repectively.

See also: coroot(::RootSystem, ::Int).

simple_coroot(R::RootSystem, i::Int) -> DualRootSpaceElem

Return the coroot of the i-th simple root of R.

This is a more efficient version for simple_coroots(R)[i].

See also: simple_coroots(::RootSystem).

simple_coroots(R::RootSystem) -> DualRootSpaceElem

Return the coroots corresponding to the simple roots of R, in the order of simple_roots(::RootSystem).

See also: simple_coroot(::RootSystem, ::Int).

positive_coroot(R::RootSystem, i::Int) -> DualRootSpaceElem

Return the coroot of the i-th positive root of R.

This is a more efficient version for positive_coroots(R)[i].

See also: positive_coroots(::RootSystem).

positive_coroots(R::RootSystem) -> DualRootSpaceElem

Return the coroots corresponding to the positive roots of R, in the order of positive_roots(::RootSystem).

See also: positive_coroot(::RootSystem, ::Int).

Examples

julia> positive_coroots(root_system(:A, 2))
3-element Vector{DualRootSpaceElem}:
 a_1^v
 a_2^v
 a_1^v + a_2^v

negative_coroot(R::RootSystem, i::Int) -> DualRootSpaceElem

Return the coroot of the i-th negative root of R.

This is a more efficient version for negative_coroots(R)[i].

See also: negative_coroots(::RootSystem).

negative_coroots(R::RootSystem) -> DualRootSpaceElem

Return the coroots corresponding to the negative roots of R, in the order of negative_roots(::RootSystem).

See also: negative_coroot(::RootSystem, ::Int).

Examples

julia> negative_coroots(root_system(:A, 2))
3-element Vector{DualRootSpaceElem}:
 -a_1^v
 -a_2^v
 -a_1^v - a_2^v

fundamental_weight(R::RootSystem, i::Int) -> WeightLatticeElem

Return the i-th fundamental weight of R.

This is a more efficient version for fundamental_weights(R)[i].

See also: fundamental_weight(::RootSystem).

fundamental_weights(R::RootSystem) -> Vector{WeightLatticeElem}

Return the fundamental weights corresponding to the simple roots of R, in the order of simple_roots(::RootSystem).

See also: fundamental_weight(::RootSystem, ::Int).

Examples

julia> fundamental_weights(root_system(:A, 2))
2-element Vector{WeightLatticeElem}:
 w_1
 w_2

weyl_vector(R::RootSystem) -> WeightLatticeElem

Return the Weyl vector $\rho$ of R, that is the sum of all fundamental weights or, equivalently, half the sum of all positive roots.

RootSpaceElem(R::RootSystem, vec::Vector{<:RationalUnion}) -> RootSpaceElem

Construct a root space element in the root system R with the given coefficients w.r.t. the simple roots of R.

RootSpaceElem(R::RootSystem, vec::QQMatrix) -> RootSpaceElem

Construct a root space element in the root system R with the given coefficien vector w.r.t. the simple roots of R.

vec must be a row vector of the same length as the rank of R.

RootSpaceElem(w::WeightLatticeElem) -> RootSpaceElem

Construct a root space element from the weight lattice element w.

zero(::Type{RootSpaceElem}, R::RootSystem) -> RootSpaceElem

Return the neutral additive element in the root space of R.

root_system(r::RootSpaceElem) -> RootSystem

Return the root system r belongs to.

coeff(r::RootSpaceElem, i::Int) -> QQFieldElem

Return the coefficient of the i-th simple root in r.

This can be also accessed via r[i].

coefficients(r::RootSpaceElem) -> QQMatrix

Return the coefficients of the root space element r w.r.t. the simple roots as a row vector.

height(r::RootSpaceElem) -> QQFieldElem

For a root r, returns the height of r, i.e. the sum of the coefficients of the simple roots. If r is not a root, the return value is arbitrary.

iszero(r::RootSpaceElem) -> Bool

Check if r is the neutral additive element in the root space of its root system.

is_root(r::RootSpaceElem) -> Bool

Check if r is a root of its root system.

See also: is_root_with_index(::RootSpaceElem).

is_root_with_index(r::RootSpaceElem) -> Bool, Int

Check if r is a root of its root system and return this together with the index of the root in roots(::RootSystem).

If r is not a root, the second return value is arbitrary.

See also: is_root(::RootSpaceElem).

is_simple_root(r::RootSpaceElem) -> Bool

Check if r is a simple root of its root system.

See also: is_simple_root_with_index(::RootSpaceElem).

is_simple_root_with_index(r::RootSpaceElem) -> Bool, Int

Check if r is a simple root of its root system and return this together with the index of the root in simple_roots(::RootSystem).

If r is not a simple root, the second return value is arbitrary.

See also: is_simple_root(::RootSpaceElem).

is_positive_root(r::RootSpaceElem) -> Bool

Check if r is a positive root of its root system.

See also: is_positive_root_with_index(::RootSpaceElem).

is_positive_root_with_index(r::RootSpaceElem) -> Bool, Int

Check if r is a positive root of its root system and return this together with the index of the root in positive_roots(::RootSystem).

If r is not a positive root, the second return value is arbitrary.

See also: is_positive_root(::RootSpaceElem).

is_negative_root(r::RootSpaceElem) -> Bool

Check if r is a negative root of its root system.

See also: is_negative_root_with_index(::RootSpaceElem).

is_negative_root_with_index(r::RootSpaceElem) -> Bool, Int

Check if r is a negative root of its root system and return this together with the index of the root in negative_roots(::RootSystem).

If r is not a negative root, the second return value is arbitrary.

See also: is_negative_root(::RootSpaceElem).

reflect(r::RootSpaceElem, s::Int) -> RootSpaceElem

Return the reflection of r in the hyperplane orthogonal to the s-th simple root.

See also: reflect!(::RootSpaceElem, ::Int).

reflect!(r::RootSpaceElem, s::Int) -> RootSpaceElem

Reflect r in the hyperplane orthogonal to the s-th simple root, and return it.

This is a mutating version of reflect(::RootSpaceElem, ::Int).

DualRootSpaceElem(R::RootSystem, vec::Vector{<:RationalUnion}) -> DualRootSpaceElem

Construct a dual root space element in the root system R with the given coefficients w.r.t. the simple coroots of R.

DualRootSpaceElem(R::RootSystem, vec::QQMatrix) -> DualRootSpaceElem

Construct a dual root space element in the root system R with the given coefficien vector w.r.t. the simple coroots of R.

vec must be a row vector of the same length as the rank of R.

zero(::Type{DualRootSpaceElem}, R::RootSystem) -> DualRootSpaceElem

Return the neutral additive element in the dual root space of R.

root_system(r::DualRootSpaceElem) -> RootSystem

Return the root system r belongs to.

coeff(r::DualRootSpaceElem, i::Int) -> QQFieldElem

Returns the coefficient of the i-th simple coroot in r.

This can be also accessed via r[i].

coefficients(r::DualRootSpaceElem) -> QQMatrix

Return the coefficients of the dual root space element r w.r.t. the simple coroots as a row vector.

height(r::DualRootSpaceElem) -> QQFieldElem

For a coroot r, returns the height of r, i.e. the sum of the coefficients of the simple coroots. If r is not a coroot, the return value is arbitrary.

iszero(r::DualRootSpaceElem) -> Bool

Check if r is the neutral additive element in the dual root space of its root system.

is_coroot(r::DualRootSpaceElem) -> Bool

Check if r is a coroot of its root system.

See also: is_coroot_with_index(::DualRootSpaceElem).

is_coroot_with_index(r::DualRootSpaceElem) -> Bool, Int

Check if r is a coroot of its root system and return this together with the index of the coroot in coroots(::RootSystem).

If r is not a coroot, the second return value is arbitrary.

See also: is_coroot(::DualRootSpaceElem).

is_simple_coroot(r::DualRootSpaceElem) -> Bool

Check if r is a simple coroot of its root system.

See also: is_simple_coroot_with_index(::DualRootSpaceElem).

is_simple_coroot_with_index(r::DualRootSpaceElem) -> Bool, Int

Check if r is a simple coroot of its root system and return this together with the index of the coroot in simple_coroots(::RootSystem).

If r is not a simple coroot, the second return value is arbitrary.

See also: is_simple_coroot(::DualRootSpaceElem).

is_positive_coroot(r::DualRootSpaceElem) -> Bool

Check if r is a positive coroot of its root system.

See also: is_positive_coroot_with_index(::DualRootSpaceElem).

is_positive_coroot_with_index(r::DualRootSpaceElem) -> Bool, Int

Check if r is a positive coroot of its root system and return this together with the index of the coroot in positive_coroots(::RootSystem).

If r is not a positive coroot, the second return value is arbitrary.

See also: is_positive_coroot(::DualRootSpaceElem).

is_negative_coroot(r::DualRootSpaceElem) -> Bool

Check if r is a negative coroot of its root system.

See also: is_negative_coroot_with_index(::DualRootSpaceElem).

is_negative_coroot_with_index(r::DualRootSpaceElem) -> Bool, Int

Check if r is a negative coroot of its root system and return this together with the index of the coroot in negative_coroots(::RootSystem).

If r is not a negative coroot, the second return value is arbitrary.

See also: is_negative_coroot(::DualRootSpaceElem).

WeightLatticeElem(R::RootSystem, vec::Vector{<:IntegerUnion}) -> WeightLatticeElem

Construct a weight lattice element in the root system R with the given coefficients w.r.t. the fundamental weights of R.

WeightLatticeElem(R::RootSystem, vec::ZZMatrix) -> WeightLatticeElem

Construct a weight lattice element in the root system R with the given coefficient vector w.r.t. the fundamental weights of R.

vec must be a row vector of the same length as the rank of R.

WeightLatticeElem(r::RootSpaceElem) -> WeightLatticeElem

Construct a weight lattice element from the root space element r.

zero(::Type{WeightLatticeElem}, R::RootSystem) -> WeightLatticeElem

Return the neutral additive element in the weight lattice of R.

root_system(w::WeightLatticeElem) -> RootSystem

Return the root system w belongs to.

coeff(w::WeightLatticeElem, i::Int) -> ZZRingElem

Return the coefficient of the i-th fundamental weight in w.

This can be also accessed via w[i].

coefficients(w::WeightLatticeElem) -> ZZMatrix

Return the coefficients of the weight lattice element w w.r.t. the fundamental weights as a row vector.

iszero(w::WeightLatticeElem) -> Bool

Return whether w is zero.

is_dominant(w::WeightLatticeElem) -> Bool

Check if w is a dominant weight, i.e. if all coefficients are non-negative.

is_fundamental_weight(w::WeightLatticeElem) -> Bool

Check if w is a fundamental weight, i.e. exactly one coefficient is equal to 1 and all others are zero.

See also: is_fundamental_weight_with_index(::WeightLatticeElem).

is_fundamental_weight_with_index(w::WeightLatticeElem) -> Bool, Int

Check if w is a fundamental weight and return this together with the index of the fundamental weight in fundamental_weights(::RootSystem).

If w is not a fundamental weight, the second return value is arbitrary.

See also: is_fundamental_weight(::WeightLatticeElem).

reflect(w::WeightLatticeElem, s::Int) -> WeightLatticeElem

Return the reflection of w in the hyperplane orthogonal to the s-th simple root.

See also: reflect!(::WeightLatticeElem, ::Int).

reflect!(w::WeightLatticeElem, s::Int) -> WeightLatticeElem

Reflect w in the hyperplane orthogonal to the s-th simple root, and return it.

This is a mutating version of reflect(::WeightLatticeElem, ::Int).

conjugate_dominant_weight(w::WeightLatticeElem) -> WeightLatticeElem

Return the unique dominant weight conjugate to w.

See also: conjugate_dominant_weight_with_left_elem(::WeightLatticeElem), conjugate_dominant_weight_with_right_elem(::WeightLatticeElem).

conjugate_dominant_weight_with_left_elem(w::WeightLatticeElem) -> Tuple{WeightLatticeElem, WeylGroupElem}

Returns the unique dominant weight dom conjugate to w and a Weyl group element x such that x * w == dom.

See also: conjugate_dominant_weight_with_right_elem(::WeightLatticeElem).

conjugate_dominant_weight_with_right_elem(w::WeightLatticeElem) -> Tuple{WeightLatticeElem, WeylGroupElem}

Returns the unique dominant weight dom conjugate to w and a Weyl group element x such that w * x == dom.

See also: conjugate_dominant_weight_with_left_elem(::WeightLatticeElem).