Roots, Coroots and Reflections

The functions in this section give access to the underlying root system (or datum) of a permutation Coxeter group. These functions do not apply to finitely presented Coxeter groups

Roots are stored as an indexed set

{@ α1, ..., αN, αN + 1, ..., α2N @},

where α1, ..., αN are the positive roots in an order compatible with height; and αN + 1, ..., α2N are the corresponding negative roots (i.e. αi + N= - αi). The simple roots are α1, ..., αn where n is the rank.

Many of these functions have an optional argument Basis which may take one of the following values

1.
"Standard": the standard basis for the (co)root space. This is the default.
2.
"Root": the basis of simple (co)roots.
3.
"Weight": the basis of fundamental (co)weights (see Subsection Weights below).

Contents

Accessing Roots and Coroots

RootSpace(W) : GrpPermCox -> .
CorootSpace(W) : GrpPermCox -> .
The (co)root spaceof the Coxeter group W. This can be a vector space over a field of characteristic zero (Chapter VECTOR SPACES), or an integer lattice in the crystallographic case (Chapter LATTICES). The (co)reflection group of W acts on the (co)root space.
SimpleRoots(W) : GrpPermCox -> Mtrx
SimpleCoroots(W) : GrpPermCox -> Mtrx
The simple (co)rootsof the Coxeter group W as the rows of a matrix.

Example GrpCox_RootSpace (H105E16)

> W := CoxeterGroup("G2");
> RootSpace(W);
Full Vector space of degree 2 over Rational Field
> CorootSpace(W);
Full Vector space of degree 2 over Rational Field
> SimpleRoots(W);
[1 0]
[0 1]
> SimpleCoroots(W);
[ 2 -3]
[-1  2]
> CartanMatrix(W);
[ 2 -1]
[-3  2]
NumberOfPositiveRoots(W) : GrpPermCox -> RngIntElt
NumPosRoots(W) : GrpPermCox -> RngIntElt
The number of positive roots of the Coxeter group W.
Roots(W) : GrpPermCox -> (@@)
Coroots(W) : GrpPermCox -> (@@)
    Basis: MonStgElt                    Default: "Standard"
An indexed set containing the (co)rootsof the Coxeter group W.
PositiveRoots(W) : GrpPermCox -> (@@)
PositiveCoroots(W) : GrpPermCox -> (@@)
    Basis: MonStgElt                    Default: "Standard"
An indexed set containing the positive (co)rootsof the Coxeter group W.
Root(W, r) : GrpPermCox, RngIntElt -> (@@)
Coroot(W, r) : GrpPermCox, RngIntElt -> (@@)
    Basis: MonStgElt                    Default: "Standard"
The rth (co)root of the Coxeter group W.
RootPosition(W, v) : GrpPermCox, . -> (@@)
CorootPosition(W, v) : GrpPermCox, . -> (@@)
    Basis: MonStgElt                    Default: "Standard"
If v is a (co)root of the Coxeter group W, this returns its position; otherwise it returns 0. These functions will try to coerce v, which can be a vector or a sequence representing a vector, into the appropriate vector space; v should be written with respect to the basis specified by the parameter Basis.

Example GrpCox_RootsCoroots (H105E17)

> A := Matrix(2,3, [1,-1,0, -1,1,-1]);
> B := Matrix(2,3, [1,-1,1, 0,1,-1]);
> W := CoxeterGroup(A, B);
> Roots(W);
{@
    (1 -1  0),
    (-1  1 -1),
    (0  0 -1),
    (1 -1 -1),
    (2 -2 -1),
    (1 -1 -2),
    (-1  1  0),
    (1 -1  1),
    (0 0 1),
    (-1  1  1),
    (-2  2  1),
    (-1  1  2)
@}
> PositiveCoroots(W);
{@
    (1 -1  1),
    (0  1 -1),
    (1  2 -2),
    (2  1 -1),
    (1 0 0),
    (1  1 -1)
@}
> #Roots(W) eq 2*NumPosRoots(W);
true
> Root(W, 4);
(1 -1 -1)
> Root(W, 4 : Basis := "Root");
(2 1)
> RootPosition(W, [1,-1,-1]);
4
> RootPosition(W, [2,1] : Basis := "Root");
4
HighestRoot(W) : GrpPermCox -> .
HighestLongRoot(W) : GrpPermCox -> .
    Basis: MonStgElt                    Default: "Standard"
The unique (long) root of greatest heightof the irreducible Coxeter group W.
HighestShortRoot(W) : GrpPermCox -> .
    Basis: MonStgElt                    Default: "Standard"
The unique short root of greatest heightof the irreducible Coxeter group W.

Example GrpCox_HeighestRoots (H105E18)

> W := RootDatum("G2");
> HighestRoot(W);
(3 2)
> HighestLongRoot(W);
(3 2)
> HighestShortRoot(W);
(2 1)
CoxeterForm(W) : GrpPermCox -> AlgMatElt
DualCoxeterForm(W) : GrpPermCox -> AlgMatElt
    Basis: MonStgElt                    Default: "Standard"
The matrix of an inner producton the (co)root space of the finite Coxeter group W which is invariant under the action of W. This inner product is uniquely determined up to a constant on each irreducible component of W. The inner product is normalised so that the short roots in each crystallographic component have length one.
AdditiveOrder(W) : GrpPermCox -> SeqEnum
An additive orderon the positive roots of the finite Coxeter group W, i.e. a sequence containing the numbers 1, ..., N in some order such that αr + αst implies t is between r and s. This is computed using the techniques of Papi [Pap94].
PapiOrder(W,w) : GrpPermCox, GrpPermElt -> SeqEnum
PapiOrder(W, wd) : GrpPermCox, SeqEnum[RngIntElt] -> SeqEnum
An additive order for the set of positive roots of the finite Coxeter group W sent negative by w - 1. The element w can be supplied either as an element of the permutation group W or as a sequence representing a word in its generators.

Operations and Properties for Root and Coroot Indices

Sum(W, r, s) : GrpPermCox, RngIntElt, RngIntElt -> RngIntElt
The index of the sum of the rth and sth roots in the Coxeter group W, or 0 if the sum is not a root. In other words, if t = hbox(Sum(W,r,s)) ≠0 then αtr + αs. The condition αr≠∓αs must be satisfied. If W is noncrystallographic, an error is flagged.
IsPositive(W, r) : GrpPermCox, RngIntElt -> BoolElt
Returns true if, and only if, the rth (co)root of the Coxeter group W is a positive root.
IsNegative(W, r) : GrpPermCox, RngIntElt -> BoolElt
Returns true if, and only if, the rth (co)root of the Coxeter group W is a negative root.
Negative(W, r) : GrpPermCox, RngIntElt -> RngIntElt
The index of the negative of the rth (co)root of the Coxeter group W. In other words, if s = hbox(Negative(W,r)) then αs= - αr.
LeftString(W, r, s) : GrpPermCox, RngIntElt, RngIntElt -> RngIntElt
Root indices in the Coxeter group W of the left string through αs in the direction of αr, i.e. the indices of αs - αr, αs - 2αr, ..., αs - pαr. In other words, this returns the sequence [r1, ..., rp] where αris - iαr and αs - (p + 1)αr is not a root. The condition αr≠∓αs must be satisfied. If W is noncrystallographic, an error is flagged.
RightString(W, r, s) : GrpPermCox, RngIntElt, RngIntElt -> RngIntElt
Root indices of the Coxeter group W of the left string through αs in the direction of αr, i.e. the indices of αs + αr, αs + 2αr, ..., αs + qαr. In other words, this returns the sequence [r1, ..., rq] where αris + iαr and αs + (q + 1)αr is not a root. The condition αr≠∓αs must be satisfied. If W is noncrystallographic, an error is flagged.
LeftStringLength(W, r, s) : GrpPermCox, RngIntElt, RngIntElt -> RngIntElt
The largest p such that αs - pαr is a root of the Coxeter group W. The condition αr≠∓αs must be satisfied. If W is noncrystallographic, an error is flagged.
RightStringLength(W, r, s) : GrpPermCox, RngIntElt, RngIntElt -> RngIntElt
The largest q such that αs + qαr is a root of the Coxeter group W. The condition αr≠∓αs must be satisfied. If W is noncrystallographic, an error is flagged.

Example GrpCox_RootArithmetic (H105E19)

> W := RootDatum("G2");
> Sum(W, 1, Negative(W,5));
10
> IsPositive(W, 10);
false
> Negative(W, 10);
4
> P := PositiveRoots(W);
> P[1] - P[5] eq -P[4];
true
RootHeight(W, r) : GrpPermCox, RngIntElt -> RngIntElt
CorootHeight(W, r) : GrpPermCox, RngIntElt -> RngIntElt
The height of the rth (co)root of the Coxeter group W, i.e. the sum of the coefficients of αr (respectively, αrstar) with respect to the simple (co)roots.
RootNorms(W) : GrpPermCox -> [RngIntElt]
CorootNorms(W) : GrpPermCox -> [RngIntElt]
The sequence of squares of the lengthsof the (co)roots of the Coxeter group W.
RootNorm(W, r) : GrpPermCox, RngIntElt -> RngIntElt
CorootNorm(W, r) : GrpPermCox, RngIntElt -> RngIntElt
The square of the length of the rth (co)root of the Coxeter group W.
IsLongRoot(W, r) : GrpPermCox, RngIntElt -> BoolElt
Returns true if, and only if, the rth root of the Coxeter group W is long, i.e. the rth coroot is short. An error is flagged unless W is irreducible and crystallographic.
IsShortRoot(W, r) : GrpPermCox, RngIntElt -> BoolElt
Returns true if, and only if, the rth root of the Coxeter group W is short, i.e. the rth coroot is long. An error is flagged unless W is irreducible and crystallographic.

Example GrpCox_RootOperations (H105E20)

> W := RootDatum("G2");
> RootHeight(W, 5);
4
> F := CoxeterForm(W);
> v := VectorSpace(Rationals(),2) ! Root(W, 5);
> (v*F, v) eq RootNorm(W, 5);
true
> IsLongRoot(W, 5);
true
> LeftString(W, 1, 5);
[ 4, 3, 2 ]
> roots := Roots(W);
> for i in [1..3] do
>   RootPosition(W, roots[5]-i*roots[1]);
> end for;
4
3
2

Weights

WeightLattice(W) : GrpPermCox -> Lat
CoweightLattice(W) : GrpPermCox -> Lat
The (co)weight latticeof the Coxeter group W. The roots and coroots of W must have integral components.
FundamentalWeights(W) : GrpPermCox -> SeqEnum
FundamentalCoweights(W) : GrpPermCox -> SeqEnum
    Basis: MonStgElt                    Default: "Standard"
The fundamental (co)weightsof the Coxeter group W. The roots and coroots of W must have integral components.
IsDominant(R, v) : RootDtm, . -> ModTupFldElt, GrpFPCoxElt
    Basis: MonStgElt                    Default: "Standard"
Returns true if, and only if, v is a dominant weight for the root datum R, ie, a nonnegative integral linear combination of the fundamental weights.
DominantWeight(W, v) : GrpPermCox, . -> ModTupFldElt, GrpFPCoxElt
    Basis: MonStgElt                    Default: "Standard"
The unique element in the W-orbit of the weight v which lies in the fundamental Weyl chamber, and the word in the generators which sends v to this element. The Coxeter group W must have a root datum. The weight v can be given either as a vector or as a sequence representing the vector and is coerced into the weight lattice first.
WeightOrbit(W, v) : GrpPermCox, . -> @ ModTupFldElt @, [GrpFPCoxElt]
    Basis: MonStgElt                    Default: "Standard"
The orbit of the weight v under the action of W. The Coxeter group W must have a root datum. The weight v can be given either as a vector or as a sequence representing the vector and is coerced into the weight lattice first.

Example GrpCox_DominantWeights (H105E21)

> W := CoxeterGroup("B3");
> DominantWeight(W, [1,-1,0] : Basis:="Weight");
(1 0 0)
[ 2, 3, 2, 1 ]
> #WeightOrbit(W, [1,-1,0] : Basis:="Weight");
6
V2.28, 13 July 2023