Roots, Coroots and Weights

The 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(R) : RootStr -> ModTupFld
CorootSpace(R) : RootStr -> ModTupFld
The vector spacecontaining the (co)roots of the root datum R, i.e. X⊗Q (respectively, Y⊗Q).
FullRootLattice(R) : RootDtm -> Lat, Map
FullCorootLattice(R) : RootDtm -> Lat, Map
The latticecontaining the (co)roots of the root datum R, i.e. X (respectively, Y). An inclusion map into the (co)root space of R is returned as the second value.
RootLattice(R) : RootDtm -> Lat, Map
CorootLattice(R) : RootDtm -> Lat, Map
The latticespanned by the (co)roots of the root datum R. An inclusion map into the (co)root space of R is returned as the second value.

Example RootDtm_RtLat (H104E14)

The root space, full root lattice and the root lattice of the standard root datum of type A2:
> R := StandardRootDatum("A",2);
> V := RootSpace(R);
> FullRootLattice(R);
Standard Lattice of rank 3 and degree 3
Mapping from: Standard Lattice of rank 3 and degree 3 to ModTupFld: V
> RootLattice(R);
Lattice of rank 2 and degree 3
Basis:
( 1 -1  0)
( 0  1 -1)
Mapping from: Lattice of rank 2 and degree 3 to ModTupFld: V
IsRootSpace(V) : ModTupFld -> BoolElt
IsCorootSpace(V) : ModTupFld -> BoolElt
Return true if, and only if, V is the (co)root space of some root datum.
IsInRootSpace(v) : ModTupFldElt -> BoolElt
IsCorootSpace(v) : ModTupFldElt -> BoolElt
Return true if, and only if, V is an element of the (co)root space of some root datum.
RootDatum(V) : ModTupFld -> RootDtm
If V is the (co)root space of some root datum, this returns the datum.

Example RootDtm_RtIsSpace (H104E15)

> R := RootDatum("a3");
> V := RootSpace(R);
> v := V.1;
> IsRootSpace(V);
true
> RootDatum(V);
R: Adjoint root datum of dimension 3 of type A3
> IsInRootSpace(v);
true
ZeroRootLattice(R) : RootDtm -> Lat
ZeroRootSpace(R) : RootDtm -> ModTupFld, Map
For the given root datum R, return the lattice X0 and the vector space X0⊗Q, respectively (see Section Extended Root Data).
RelativeRootSpace(R) : RootDtm -> ModTupFld, Map
For the given root datum R, return the vector space bar(X) = (X⊗Q)/(X0⊗Q) containing the relative roots (see Section Extended Root Data). The projection from X⊗Q onto bar(X) is returned as second return value.
SimpleRoots(R) : RootStr -> Mtrx
SimpleCoroots(R) : RootStr -> Mtrx
The simple (co)rootsof the root datum R as the rows of a matrix, i.e. A (respectively, B).

Example RootDtm_BasicOperations (H104E16)

> R := RootDatum("G2");
> RootSpace(R);
Full Vector space of degree 2 over Rational Field
> FullRootLattice(R);
Standard Lattice of rank 2 and degree 2
Mapping from: Standard Lattice of rank 2 and degree 2 to Full Vector space of
degree 2 over Rational Field
> RootLattice(R);
Standard Lattice of rank 2 and degree 2
Mapping from: Standard Lattice of rank 2 and degree 2 to Full Vector space of
degree 2 over Rational Field
> CorootSpace(R);
Full Vector space of degree 2 over Rational Field
> SimpleRoots(R);
[1 0]
[0 1]
> SimpleCoroots(R);
[ 2 -3]
[-1  2]
> CartanMatrix(R);
[ 2 -1]
[-3  2]
> Rank(R) eq Dimension(R);
true
NumberOfPositiveRoots(R) : RootStr -> RngIntElt
NumPosRoots(R) : RootStr -> RngIntElt
The number of positive roots of the root datum R. This is also the number of positive coroots. The total number of (co)roots is twice the number of positive (co)roots.
Roots(R) : RootStr -> (@@)
Coroots(R) : RootStr -> (@@)
    Basis: MonStgElt                    Default: "Standard"
The indexed set of (co)roots of the root datum R, i.e. {@ α1, ... α2N @} (respectively, {@ α1star, ... α2Nstar @}).
PositiveRoots(R) : RootStr -> (@@)
PositiveCoroots(R) : RootStr -> (@@)
    Basis: MonStgElt                    Default: "Standard"
The indexed set of positive (co)rootsof the root datum R, i.e. {@ α1, ... αN @} (respectively, {@ α1star, ... αNstar @}).
Root(R, r) : RootStr, RngIntElt -> (@@)
Coroot(R, r) : RootStr, RngIntElt -> (@@)
    Basis: MonStgElt                    Default: "Standard"
The rth (co)root αr (respectively, αrstar) of the root datum R.
RootPosition(R, v) : RootStr, . -> (@@)
CorootPosition(R, v) : RootStr, . -> (@@)
    Basis: MonStgElt                    Default: "Standard"
If v is a (co)root in the root datum R, return its index; otherwise return 0. These functions will try to coerce v into the appropriate lattice; v should be written with respect to the basis specified by the parameter Basis.
BasisChange(R,v) : RootStr, Any -> SeqEnum
    InBasis: MonStgElt                  Default: "Standard"
    OutBasis: MonStgElt                 Default: "Standard"
    Coroots: BoolElt                    Default: false
Changes the basis of the vector v contained in the space spanned by the (co)roots of the root datum R. The vector v is considered as an element of the root space by default. If the parameter Coroots is set to true, v is considered as an element of the coroot space. The optional arguments InBasis and OutBasis may take the same values as the parameter Basis as described at the beginning of the current section.

Example RootDtm_RootsCoroots (H104E17)

> R := RootDatum("A3" : Isogeny := 2);
> Roots(R);
{@
    (1 0 0),
    (0 1 0),
    (1 0 2),
    (1 1 0),
    (1 1 2),
    (2 1 2),
    (-1  0  0),
    (0 -1  0),
    (-1  0 -2),
    (-1 -1  0),
    (-1 -1 -2),
    (-2 -1 -2)
@}
> PositiveCoroots(R);
{@
    (2 -1 -1),
    (-1  2  0),
    (0 -1  1),
    (1  1 -1),
    (-1  1  1),
    (1 0 0)
@}
> #Roots(R) eq 2*NumPosRoots(R);
true
> Coroot(R, 4);
(1  1 -1)
> Coroot(R, 4 : Basis := "Root");
(1 1 0)
> CorootPosition(R, [1,1,-1]);
4
> CorootPosition(R, [1,1,0] : Basis := "Root");
4
> BasisChange(R, [1,0,0] : InBasis:="Root");
(1 0 0)
> BasisChange(R, [1,0,0] : InBasis:="Root", Coroots);
( 2 -1 -1)
IsInRootSpace(R,v) : RootDtm, ModTupFldElt -> BoolElt
IsInCorootSpace(R,v) : RootDtm, ModTupFldElt -> BoolElt
Returns true if and only if the vector v is contained in the (co)root space of the root datum R.
HighestRoot(R) : RootStr -> .
HighestCoroot(R) : RootStr -> .
    Basis: MonStgElt                    Default: "Standard"
The unique (co)root of greatest heightin the irreducible root datum R.
HighestLongRoot(R) : RootStr -> .
HighestLongCoroot(R) : RootStr -> .
    Basis: MonStgElt                    Default: "Standard"
The unique long (co)root of greatest heightin the irreducible root datum R.
HighestShortRoot(R) : RootStr -> .
HighestShortCoroot(R) : RootStr -> .
    Basis: MonStgElt                    Default: "Standard"
The unique short (co)root of greatest heightin the irreducible root datum R.

Example RootDtm_HighestRoots (H104E18)

> R := RootDatum("G2");
> HighestRoot(R);
(3 2)
> HighestLongRoot(R);
(3 2)
> HighestShortRoot(R);
(2 1)
RelativeRoots(R) : RootDtm -> SetIndx
PositiveRelativeRoots(R) : RootDtm -> SetIndx
NegativeRelativeRoots(R) : RootDtm -> SetIndx
SimpleRelativeRoots(R) : RootDtm -> SetIndx
The indexed set of all (resp. positive, negative, simple) relative roots of the root datum R. Note that the relative roots are returned in the order induced by the standard ordering on the (nonrelative) roots of R.
RelativeRootDatum(R) : RootDtm -> RootDtm
The relative root datum of the root datum R.
GammaOrbitsRepresentatives(R, delta) : RootDtm, RngIntElt -> SeqEnum
The preimage of a relative root δ is a disjoint union of Γ-orbits on the set of all roots of the root datum R. This intrinsic returns a sequence of representatives of these orbits.

Example RootDtm_TwoTwistedEsixes (H104E19)

We first consider the twisted root datum of type ()2E6, which is quasisplit:
> DynkinDiagram(RootDatum("E6"));
E6    1 - 3 - 4 - 5 - 6
              |
              2
>
> R := RootDatum("E6" : Twist:=2 ); R;
R: Twisted adjoint root datum of type 2E6,4
> OrbitsOnSimples(R);
[
     GSet{ 2 },
     GSet{ 4 },
     GSet{ 1, 6 },
     GSet{ 3, 5 }
]
> DistinguishedOrbitsOnSimples(R) eq OrbitsOnSimples(R);
true
> AnisotropicSubdatum(R);
Twisted toral root datum of dimension 6
[]
> RR := RelativeRootDatum(R);RR;
RR: Adjoint root datum of type F4
> _,pi := RelativeRootSpace(R);
> DynkinDiagram(RR);
F4    1 - 2 =>= 4 - 3
> [ Position(Roots(RR), pi(Root(R,i)) ) : i in [1,6, 3,5, 4, 2]];
[ 3, 3, 4, 4, 2, 1 ]
now one with distinguished orbits {2} and {4}:
> R := RootDatum("E6" : Twist := <{{2},{4}},2> ); R;
R: Twisted adjoint root datum of type 2E6,2
> OrbitsOnSimples(R);
[
     GSet{ 2 },
     GSet{ 4 },
     GSet{ 1, 6 },
     GSet{ 3, 5 }
]
> DistinguishedOrbitsOnSimples(R);
[
     GSet{ 2 },
     GSet{ 4 }
]
> AnisotropicSubdatum(R);
Twisted root datum of type 2(A2 A2)4,0
[ 1, 3, 5, 6, 7, 11, 37, 39, 41, 42, 43, 47 ]
> RR := RelativeRootDatum(R);RR;
RR: Adjoint root datum of type G2
> DynkinDiagram(RR);
G2    2 =<= 1
         3
> _,pi := RelativeRootSpace(R);
> [ Position(Roots(RR), pi(Root(R,i)) ) : i in [2,4]];
[ 1, 2 ]
and now the one with distinguished orbits {2} and {1, 6}, which has a non-reduced relative root datum:
> R := RootDatum("E6" : Twist := <{{2},{1,6}},2> ); R;
R: Twisted adjoint root datum of dimension 6 of type 2E6,2
> OrbitsOnSimples(R);
[
     GSet{ 2 },
     GSet{ 4 },
     GSet{ 1, 6 },
     GSet{ 3, 5 }
]
> DistinguishedOrbitsOnSimples(R);
[
     GSet{ 2 },
     GSet{ 1, 6 }
]
> AnisotropicSubdatum(R);
Twisted root datum of type 2A3,0
[ 3, 4, 5, 9, 10, 15, 39, 40, 41, 45, 46, 51 ]
> RR := RelativeRootDatum(R);RR;
RR: Adjoint root datum of type BC2
> DynkinDiagram(RR);
BC2    1 =>= 2
> _,pi := RelativeRootSpace(R);
> [ Position(Roots(RR), pi(Root(R,i)) ) : i in [2, 1,6]];
[ 1, 2, 2 ]
Finally, the twisted root Datum of type ()6D4, 1:
> T := RootDatum( "D4" : Twist:=<{{2}},6> );
> T;
T: Twisted adjoint root datum of dimension 4 of type 6D4,1
> RelativeRootDatum(T);
Adjoint root datum of type BC1
> GammaOrbitsRepresentatives(T,1);
[ 11, 5 ]
> GammaOrbitsRepresentatives(T,2);
[ 12 ]
CoxeterForm(R) : RootDtm -> AlgMatElt
DualCoxeterForm(R) : RootDtm -> AlgMatElt
    Basis: MonStgElt                    Default: "Standard"
The matrix of an inner producton the (co)root space of the root datum R which is invariant under the action of the (co)roots. The inner product is normalised so that the short roots in each irreducible component have length one.

Reflections

The root α acts on the root space via the reflection sα; the coroot αstar acts on the coroot space via the coreflection sαstar.

SimpleReflectionMatrices(R) : RootDtm -> []
SimpleCoreflectionMatrices(R) : RootDtm -> []
    Basis: MonStgElt                    Default: "Standard"
The sequence of matrices giving the action of the simple (co)roots of the root datum R on the (co)root space, i.e. the matrices of sα1, ..., sαn (respectively, sα1star, ..., sαnstar).
ReflectionMatrices(R) : RootDtm -> []
CoreflectionMatrices(R) : RootDtm -> []
    Basis: MonStgElt                    Default: "Standard"
The sequence of matrices giving the action of the (co)roots of the root datum R on the (co)root space, i.e. the matrices of sα1, ..., s_(α2N) (respectively, sα1star, ..., s_(α2N)star).
ReflectionMatrix(R, r) : RootDtm, RngIntElt -> []
CoreflectionMatrix(R, r) : RootDtm, RngIntElt -> []
    Basis: MonStgElt                    Default: "Standard"
The matrix giving the action of the rth (co)root of the root datum R on the (co)root space, i.e. the matrix of sαr (respectively, sαrstar).
SimpleReflectionPermutations(R) : RootDtm -> []
The sequence of permutations giving the action of the simple (co)roots of the root datum R on the (co)roots. This action is the same for roots and coroots.
ReflectionPermutations(R) : RootDtm -> []
The sequence of permutations giving the action of the (co)roots of the root datum R on the (co)roots. This action is the same for roots and coroots.
ReflectionPermutation(R, r) : RootDtm, RngIntElt -> []
The permutation giving the action of the rth (co)root of the root datum R on the (co)roots. This action is the same for roots and coroots.
ReflectionWords(R) : RootDtm -> []
The sequence of words in the simple reflections for all the reflections of the root datum R. These words are given as sequences of integers. In other words, if a = [a1, ..., al] = ReflectionWords(R)[r], then sαr = s_(αa1) ... s_(αal).
ReflectionWord(R, r) : RootDtm, RngIntElt -> []
The word in the simple reflections for the rth reflection of the root datum R. The word is given as a sequence of integers. In other words, if a = [a1, ..., al] = ReflectionWord(R, r), then sαr = s_(αa1) ... s_(αal).

Example RootDtm_Action (H104E20)

> R := RootDatum("A3" : Isogeny := 2);
> mx := ReflectionMatrix(R, 4);
> perm := ReflectionPermutation(R, 4);
> wd := ReflectionWord(R, 4);
> RootPosition(R, Root(R,2) * mx) eq 2^perm;
true
> perm eq &*[ ReflectionPermutation(R, r) : r in wd ];
true
>
> mx := CoreflectionMatrix(R, 4);
> CorootPosition(R, Coroot(R,2) * mx) eq 2^perm;
true

Operations and Properties for Root and Coroot Indices

Sum(R, r, s) : RootDtm, RngIntElt, RngIntElt -> RngIntElt
The index of the sum of the rth and sth roots in the root datum R, or 0 if the sum is not a root. In other words, if t = hbox(Sum(R,r,s)) ≠0 then αtr + αs. The condition αr≠∓αs must be satisfied.
IsPositive(R, r) : RootStr, RngIntElt -> BoolElt
Returns true if, and only if, the rth (co)root of the root datum R is a positive root.
IsNegative(R, r) : RootStr, RngIntElt -> BoolElt
Returns true if, and only if, the rth (co)root of the root datum R is a negative root.
Negative(R, r) : RootStr, RngIntElt -> RngIntElt
The index of the negative of the rth (co)root of the root datum R. In other words, if s = hbox(Negative(R,r)) then αs= - αr.
LeftString(R, r, s) : RootDtm, RngIntElt, RngIntElt -> RngIntElt
Indices in the root datum R 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.
RightString(R, r, s) : RootDtm, RngIntElt, RngIntElt -> RngIntElt
Indices in the root datum R 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.
LeftStringLength(R, r, s) : RootDtm, RngIntElt, RngIntElt -> RngIntElt
The largest p such that αs - pαr is a root of the root datum R. The condition αs≠∓αr must be satisfied.
RightStringLength(R, r, s) : RootDtm, RngIntElt, RngIntElt -> RngIntElt
The largest q such that αs + qαr is a root of the root datum R. The condition αs≠∓αr must be satisfied.

Example RootDtm_RootArithmetic (H104E21)

> R := RootDatum("G2");
> Sum(R, 1, Negative(R,5));
10
> IsPositive(R, 10);
false
> Negative(R, 10);
4
> P := PositiveRoots(R);
> P[1] - P[5] eq -P[4];
true
RootHeight(R, r) : RootStr, RngIntElt -> RngIntElt
CorootHeight(R, r) : RootStr, RngIntElt -> RngIntElt
The height of the rth (co)root of the root datum R, i.e. the sum of the coefficients of αr (respectively, αrstar) with respect to the simple (co)roots.
RootNorms(R) : RootStr -> [RngIntElt]
CorootNorms(R) : RootStr -> [RngIntElt]
The sequence of squares of the lengthsof the (co)roots of the root datum R.
RootNorm(R, r) : RootStr, RngIntElt -> RngIntElt
CorootNorm(R, r) : RootStr, RngIntElt -> RngIntElt
The square of the length of the rth (co)root of the root datum R.
IsLongRoot(R, r) : RootStr, RngIntElt -> BoolElt
Returns true if, and only if, the rth root of the root datum R is long. This only makes sense for irreducible crystallographic root data. Note that for non-reduced root data, the roots which are not indivisible, are actually longer than the long ones.
IsShortRoot(R, r) : RootStr, RngIntElt -> BoolElt
Returns true if, and only if, the rth root of the root datum R is short. This only makes sense for irreducible crystallographic root data.
IsIndivisibleRoot(R, r) : RootStr, RngIntElt -> BoolElt
Returns true if, and only if, the rth root of the root system R is indivisible.

Example RootDtm_RootOperations (H104E22)

Note that the Coxeter form is defined over the rationals. Since it is not possible to multiply a lattice element by a rational matrix, (co)roots must be coerced into a rational vector space first.
> R := RootDatum("G2");
> RootHeight(R, 5);
4
> F := CoxeterForm(R);
> v := VectorSpace(Rationals(),2) ! Root(R, 5);
> (v*F, v) eq RootNorm(R, 5);
true
> IsLongRoot(R, 5);
true
> LeftString(R, 1, 5);
[ 4, 3, 2 ]
> roots := Roots(R);
> for i in [1..3] do
>   RootPosition(R, roots[5]-i*roots[1]);
> end for;
4
3
2
RootClosure(R, S) : RootDtm, SetEnum[RngIntElt] -> SetEnum[RngIntElt]
The closure in the root datum R of the set S of root indices. That is the indices of every root that can be written as a sum of roots with indices in S.
AdditiveOrder(R) : RootStr -> SeqEnum
An additive orderon the positive roots of the root datum R, ie. 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 [Pap94]
IsAdditiveOrder(R, Q) : RootStr, [RngIntElt] -> BoolElt
Returns true if, and only if, Q gives an additive order on a set of positive roots of R. Q must be a sequence of integers in the range [1..N] with no gaps or repeats.

Example RootDtm_AdditiveOrder (H104E23)

> R := RootDatum("A5");
> a := AdditiveOrder(R);
> Position(a, 2);
6
> Position(a, 3);
10
> Position(a, Sum(R, 2, 3));
7

Weights

WeightLattice(R) : RootDtm -> Lat
The weight lattice Λ of the root datum R.i.e. the λ in QΦ≤Q tensor X such that < λ, αstar >∈Z for every coroot αstar.
CoweightLattice(R) : RootDtm -> Lat
The coweight lattice Λstar of the root datum R,i.e. the λstar in QΦstar≤Q tensor Y such that < α, λstar >∈Z for every root α.
FundamentalWeights(R) : RootDtm -> Mtrx
    Basis: MonStgElt                    Default: "Standard"
The fundamental weightsλ1, ..., λn of the root datum R given as the rows of a matrix. This is the basis of the weight lattice Λ dual to the simple coroots, i.e. < λi, αjstar >=δij.
FundamentalCoweights(R) : RootDtm -> Mtrx
    Basis: MonStgElt                    Default: "Standard"
The fundamental coweightsλ1star, ..., λnstar of the root datum R given as the rows of a matrix. This is the basis of the coweight lattice Λstar dual to the simple roots, i.e. < αi, λjstar >=δij.

Example RootDtm_Weights (H104E24)

> R := RootDatum("E6");
> WeightLattice(R);
Lattice of rank 6 and degree 6
Basis:
(4  3  5  6  4  2)
(3  6  6  9  6  3)
(5  6 10 12  8  4)
(6  9 12 18 12  6)
(4  6  8 12 10  5)
(2  3  4  6  5  4)
Basis Denominator: 3
> FundamentalWeights(R);
[ 4/3    1  5/3    2  4/3  2/3]
[   1    2    2    3    2    1]
[ 5/3    2 10/3    4  8/3  4/3]
[   2    3    4    6    4    2]
[ 4/3    2  8/3    4 10/3  5/3]
[ 2/3    1  4/3    2  5/3  4/3]
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(R, v) : RootDtm, . -> ModTupFldElt, GrpFPCoxElt
    Basis: MonStgElt                    Default: "Standard"
The unique dominant weight in the same W-orbit as the weight v, where W is the Weyl group of the root datum R. The second value returned is a Weyl group element taking v to the dominant weight. 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(R, v) : RootDtm, . -> @ ModTupFldElt @, [GrpFPCoxElt]
    Basis: MonStgElt                    Default: "Standard"
The W-orbit of the weight v as an indexed set, where W is the Weyl group of the root datum R. The first element in the orbit is always dominant. The second value returned is a sequence of Weyl group elements taking the weight to the corresponding element of the orbit. 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 RootDtm_DominantWeights (H104E25)

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