Root systems

Root systems in this module are meant to be abstract root systems, i.e. they are represented by a set of roots (vectors in an euclidean space).

The relevant types around root systems are:

RootSystem for the root system itself,
RootSpaceElem for elements in the root space, i.e. roots and linear combinations thereof,
DualRootSpaceElem for elements in the dual root space, i.e. coroots and linear combinations thereof.

Warning

Most functionality around root systems is currently only intended to be used with root systems of finite type. For root systems of affine type, some documentation may be ill-phrased or incorrect, and some functions may not work as intended.

Note

See Cartan types for our conventions on Cartan types and ordering of simple roots.

Table of contents

Table of contents
Constructing root systems
Properties of root systems
Root space elements
- Root testing
- Reflections
Dual root space elements
- Coroot testing

Constructing root systems

root_system — Method

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 — Method

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 — Method

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 []

Properties of root systems

is_simple — Method

is_simple(R::RootSystem) -> Bool

Check if R is a simple root system.

Warning

Currently only root systems of finite type are supported.

rank — Method

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 and Weyl group

cartan_matrix — Method

cartan_matrix(R::RootSystem) -> ZZMatrix

Return the Cartan matrix defining R.

weight_lattice — Method

weight_lattice(R::RootSystem) -> WeightLattice

Return the weight lattice of R, i.e. the lattice spanned by the fundamental weights.

This is the parent of all weights of R.

Examples

julia> weight_lattice(root_system([2 -1; -1 2]))
Weight lattice
  of root system of rank 2
    of type A2

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

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

weyl_group — Method

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)

Root system type

has_root_system_type — Method

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 — Method

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

Warning

This function will error if the type is not known yet and the Weyl group is infinite.

root_system_type_with_ordering — Method

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

Warning

This function will error if the type is not known yet and the Weyl group is infinite.

Root getters

number_of_roots — Method

number_of_roots(R::RootSystem) -> Int

Return the number of roots of R.

See also: roots(::RootSystem).

number_of_positive_roots — Method

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 — Method

number_of_simple_roots(R::RootSystem) -> Int

Return the number of simple roots of R.

See also: simple_roots(::RootSystem).

The following functions return roots, see Root space elements for more information.

root — Method

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

Note

This function does not return a copy of the asked for object, but the internal field of the root system. Mutating the returned object will lead to undefined behavior.

roots — Method

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

Note

This function does not return a copy of the asked for object, but the internal field of the root system. Mutating the returned object will lead to undefined behavior.

simple_root — Method

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

Note

This function does not return a copy of the asked for object, but the internal field of the root system. Mutating the returned object will lead to undefined behavior.

simple_roots — Method

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

Return the simple roots of R.

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

Note

This function does not return a copy of the asked for object, but the internal field of the root system. Mutating the returned object will lead to undefined behavior.

positive_root — Method

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

Note

This function does not return a copy of the asked for object, but the internal field of the root system. Mutating the returned object will lead to undefined behavior.

positive_roots — Method

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

Note

This function does not return a copy of the asked for object, but the internal field of the root system. Mutating the returned object will lead to undefined behavior.

Examples

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

negative_root — Method

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

Note

This function does not return a copy of the asked for object, but the internal field of the root system. Mutating the returned object will lead to undefined behavior.

negative_roots — Method

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

Note

This function does not return a copy of the asked for object, but the internal field of the root system. Mutating the returned object will lead to undefined behavior.

Examples

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

Coroot getters

The following functions return coroots, see Dual root space elements for more information.

coroot — Method

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

Note

This function does not return a copy of the asked for object, but the internal field of the root system. Mutating the returned object will lead to undefined behavior.

coroots — Method

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), respectively.

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

Note

This function does not return a copy of the asked for object, but the internal field of the root system. Mutating the returned object will lead to undefined behavior.

simple_coroot — Method

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

Note

This function does not return a copy of the asked for object, but the internal field of the root system. Mutating the returned object will lead to undefined behavior.

simple_coroots — Method

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

Note

This function does not return a copy of the asked for object, but the internal field of the root system. Mutating the returned object will lead to undefined behavior.

positive_coroot — Method

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

Note

This function does not return a copy of the asked for object, but the internal field of the root system. Mutating the returned object will lead to undefined behavior.

positive_coroots — Method

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

Note

This function does not return a copy of the asked for object, but the internal field of the root system. Mutating the returned object will lead to undefined behavior.

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 — Method

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

Note

This function does not return a copy of the asked for object, but the internal field of the root system. Mutating the returned object will lead to undefined behavior.

negative_coroots — Method

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

Note

This function does not return a copy of the asked for object, but the internal field of the root system. Mutating the returned object will lead to undefined behavior.

Examples

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

Weight getters

The following functions return weights, see Weight lattice elements for more information.

fundamental_weight — Method

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 — Method

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 — Method

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.

Root space elements

RootSpaceElem — Method

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 — Method

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 — Method

RootSpaceElem(w::WeightLatticeElem) -> RootSpaceElem

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

zero — Method

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

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

root_system — Method

root_system(r::RootSpaceElem) -> RootSystem

Return the root system r belongs to.

Basic arithmetic operations like zero, +, -, * (with rational scalars), and == are supported.

coeff — Method

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 — Method

coefficients(r::RootSpaceElem) -> QQMatrix

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

Note

The return type may not be relied on; we only guarantee that it is a one-dimensional iterable with eltype QQFieldElem that can be indexed with integers.

height — Method

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 — Method

iszero(r::RootSpaceElem) -> Bool

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

Root testing

is_root — Method

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 — Method

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 — Method

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 — Method

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 — Method

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 — Method

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 — Method

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 — Method

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

Reflections

reflect — Method

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! — Method

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

Dual root space elements

DualRootSpaceElem — Method

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 — Method

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 — Method

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

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

root_system — Method

root_system(r::DualRootSpaceElem) -> RootSystem

Return the root system r belongs to.

Basic arithmetic operations like zero, +, -, * (with rational scalars), and == are supported.

coeff — Method

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 — Method

coefficients(r::DualRootSpaceElem) -> QQMatrix

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

Note

The return type may not be relied on; we only guarantee that it is a one-dimensional iterable with eltype QQFieldElem that can be indexed with integers.

height — Method

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 — Method

iszero(r::DualRootSpaceElem) -> Bool

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

Coroot testing

is_coroot — Method

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 — Method

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 — Method

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 — Method

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 — Method

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 — Method

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 — Method

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 — Method

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