Weyl groups

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)

weyl_group(cartan_matrix::ZZMatrix) -> WeylGroup

Construct the Weyl group defined by the given (generalized) Cartan matrix.

weyl_group(fam::Symbol, rk::Int) -> WeylGroup

Construct the Weyl group of the given type.

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

Examples

julia> weyl_group(:A, 2)
Weyl group
  of root system of rank 2
    of type A2

weyl_group(type::Vector{Tuple{Symbol,Int}}) -> WeylGroup
weyl_group(type::Tuple{Symbol,Int}...) -> WeylGroup

Construct the Weyl group 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> weyl_group([(:G, 2), (:D, 4)])
Weyl group
  of root system of rank 6
    of type G2 x D4

is_finite(W::WeylGroup) -> Bool

Return whether W is finite.

one(W::WeylGroup) -> WeylGroupElem

Return the identity element of W.

isone(x::WeylGroupElem) -> Bool

Return whether x is the identity element of its parent.

gen(W::WeylGroup, i::Int) -> WeylGroupElem

Return the i-th simple reflection (with respect to the underlying root system) of W.

gens(W::WeylGroup) -> WeylGroupElem

Return the simple reflections (with respect to the underlying root system) of W.

number_of_generators(W::WeylGroup) -> Int

Return the number of generators of the W, i.e. the rank of the underyling root system.

order(W::WeylGroup) -> ZZRingELem
order(::Type{T}, W::WeylGroup) where {T} -> T

Return the order of W.

If W is infinite, an InfiniteOrderError exception will be thrown.

root_system(W::WeylGroup) -> RootSystem

Return the underlying root system of W.

word(x::WeylGroupElem) -> Vector{UInt8}

Return x as a list of indices of simple reflections, in reduced form.

This function is right inverse to calling (W::WeylGroup)(word::Vector{<:Integer}).

length(x::WeylGroupElem) -> Int

Return the length of x.

longest_element(W::WeylGroup) -> WeylGroupElem

Return the unique longest element of W. This only exists if W is finite.

<(x::WeylGroupElem, y::WeylGroupElem) -> Bool

Return whether x is smaller than y with respect to the Bruhat order, i.e., whether some (not necessarily connected) subexpression of a reduced decomposition of y, is a reduced decomposition of x.

fp_group(W::WeylGroup) -> FPGroup

Construct a group of type FPGroup that is isomorphic to W.

The FPGroup will be the quotient of a free group with the same rank as W, where we have the natural 1-to-1 correspondence of generators, modulo the Coxeter relations of W.

Also see: isomorphism(::Type{FPGroup}, ::WeylGroup).

isomorphism(::Type{FPGroup}, W::WeylGroup) -> Map{WeylGroup, FPGroup}

Construct an isomorphism between W and a group of type FPGroup.

The properties of the codomain group and the isomorphism are described in fp_group(::WeylGroup).

reduced_expressions(x::WeylGroupElem; up_to_commutation::Bool=false) -> ReducedExpressionIterator

Return an iterator over all reduced expressions of x.

If up_to_commutation is true, the iterator will not return an expression that only differs from a previous one by a swap of two adjacent commuting simple reflections.

Examples

julia> W = weyl_group(:A, 3);

julia> x = W([1,2,3,1]);

julia> collect(reduced_expressions(x))
3-element Vector{Vector{UInt8}}:
 [0x01, 0x02, 0x03, 0x01]
 [0x01, 0x02, 0x01, 0x03]
 [0x02, 0x01, 0x02, 0x03]

julia> collect(reduced_expressions(x; up_to_commutation=true))
2-element Vector{Vector{UInt8}}:
 [0x01, 0x02, 0x03, 0x01]
 [0x02, 0x01, 0x02, 0x03]

The second expression of the first iterator is not contained in the second iterator because it only differs from the first expression by a swap of two the two commuting simple reflections s1 and s3.

*(x::WeylGroupElem, r::RootSpaceElem) -> RootSpaceElem
*(x::WeylGroupElem, w::WeightLatticeElem) -> WeightLatticeElem

Return the result of acting with x from the left on r or w.

See also: *(::Union{RootSpaceElem,WeightLatticeElem}, ::WeylGroupElem).

*(r::RootSpaceElem, x::WeylGroupElem) -> RootSpaceElem
*(w::WeightLatticeElem, x::WeylGroupElem) -> WeightLatticeElem

Return the result of acting with x from the right on r or w.

See also: *(::WeylGroupElem, ::Union{RootSpaceElem,WeightLatticeElem}).