[Next][Prev] [Right] [Left] [Up] [Index] [Root]

Roots, Coroots and Weights

We store the roots as an indexed set

{@ alpha_1, ..., alpha_N, alpha_(N + 1), ..., alpha_(2N) @},

where alpha_1, ..., alpha_N are the positive roots in an order compatible with height; and alpha_(N + 1), ..., alpha_(2N) are the corresponding negative roots (i.e. alpha_(i + N)= - alpha_i). The simple roots are alpha_1, ..., alpha_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).
Subsections

Accessing Roots and Coroots

RootSpace( R ) : RootDtm -> Lat
CorootSpace( R ) : RootDtm -> Lat
The lattice containing the (co)roots of the root datum R, i.e. X (resp. Y).
SimpleRoots( R ) : RootDtm -> Mtrx
SimpleCoroots( R ) : RootDtm -> Mtrx
The simple (co)roots of the root datum R as the rows of a matrix, i.e. A (resp. B).
NumberOfPositiveRoots( R ) : RootDtm -> RngIntElt
NumPosRoots( R ) : RootDtm -> 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 ) : RootDtm -> {@@}
Coroots( R ) : RootDtm -> {@@}
    Basis: MonStgElt                    Default: "Standard"
The indexed set of (co)roots of the root datum R, i.e. {@ alpha_1, dotsalpha_(2N) @} (resp. {@ alpha_1^star, dotsalpha_(2N)^star @}).
PositiveRoots( R ) : RootDtm -> {@@}
PositiveCoroots( R ) : RootDtm -> {@@}
    Basis: MonStgElt                    Default: "Standard"
The indexed set of positive (co)roots of the root datum R, i.e. {@ alpha_1, dotsalpha_N @} (resp. {@ alpha_1^star, dotsalpha_N^star @}).
Root( R, r ) : RootDtm, RngIntElt -> {@@}
Coroot( R, r ) : RootDtm, RngIntElt -> {@@}
    Basis: MonStgElt                    Default: "Standard"
The rth (co)root alpha_r (resp. alpha_r^star) of the root datum R.
RootPosition( R, v ) : RootDtm, . -> {@@}
CorootPosition( R, v ) : RootDtm, . -> {@@}
    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.

Example RootDtm_RootsCoroots (H80E10)

> 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

HighestRoot( R ) : RootDtm -> .
HighestLongRoot( R ) : RootDtm -> .
    Basis: MonStgElt                    Default: "Standard"
The unique (long) root of greatest height in the irreducible root datum R.
HighestShortRoot( R ) : RootDtm -> .
    Basis: MonStgElt                    Default: "Standard"
The unique short root of greatest height in the irreducible root datum R.

Example RootDtm_HeighestRoots (H80E11)

> R := RootDatum( "G2" );
> HighestRoot( R );
(3 2)
> HighestLongRoot( R );
(3 2)
> HighestShortRoot( R );
(2 1)

CoxeterForm( R ) : RootSys -> AlgMatElt
DualCoxeterForm( R ) : RootSys -> AlgMatElt
    Basis: MonStgElt                    Default: "Standard"
The matrix of an inner product on the (co)root space of R which is invariant under the action of the (co)roots. This inner product is uniquely determined up to a constant on each irreducible component of R. We normalise the inner product so that the short roots in each component have length one.

Reflections

The root alpha acts on the root space via the reflection s_alpha; the coroot alpha^star acts on the coroot space via the coreflection s_alpha^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_(alpha_1), ..., s_(alpha_n) (resp. s_(alpha_1)^star, ..., s_(alpha_n)^star).
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_(alpha_1), ..., s_(alpha_(2N)) (resp. s_(alpha_1)^star, ..., s_(alpha_(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_(alpha_r) (resp. s_(alpha_r)^star).
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 = [a_1, ..., a_l] = ReflectionWords(R)[r], then s_(alpha_r) = s_(alpha_(a_1)) ... s_(alpha_(a_l)).
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 = [a_1, ..., a_l] = ReflectionWord(R, r), then s_(alpha_r) = s_(alpha_(a_1)) ... s_(alpha_(a_l)).

Example RootDtm_Action (H80E12)

> 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 alpha_t=alpha_r + alpha_s. We require alpha_r != +-alpha_s.
IsPositive( R, r ) : RootDtm, RngIntElt -> BoolElt
Returns true if, and only if, the rth (co)root of the root datum R is a positive root.
IsNegative( R, r ) : RootDtm, RngIntElt -> BoolElt
Returns true if, and only if, the rth (co)root of the root datum R is a negative root.
Negative( R, r ) : RootDtm, 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 alpha_s= - alpha_r.
LeftString( R, r, s ) : RootDtm, RngIntElt, RngIntElt -> RngIntElt
Indices in the root datum R of the left string through alpha_s in the direction of alpha_r, i.e. the indices of alpha_s - alpha_r, alpha_s - 2alpha_r, ..., alpha_s - palpha_r. In other words, this returns the sequence [r_1, ..., r_p] where alpha_(r_i)=alpha_s - ialpha_r and alpha_s - (p + 1)alpha_r is not a root. We require that alpha_r != +-alpha_s.
RightString( R, r, s ) : RootDtm, RngIntElt, RngIntElt -> RngIntElt
Indices in the root datum R of the left string through alpha_s in the direction of alpha_r, i.e. the indices of alpha_s + alpha_r, alpha_s + 2alpha_r, ..., alpha_s + qalpha_r. In other words, this returns the sequence [r_1, ..., r_q] where alpha_(r_i)=alpha_s + ialpha_r and alpha_s + (q + 1)alpha_r is not a root. We require that alpha_r != +-alpha_s.
LeftStringLength( R, r, s ) : RootDtm, RngIntElt, RngIntElt -> RngIntElt
The largest p such that alpha_s - palpha_r is a root. We require that alpha_s != +-alpha_r.
RightStringLength( R, r, s ) : RootDtm, RngIntElt, RngIntElt -> RngIntElt
The largest q such that alpha_s + qalpha_r is a root. We require that alpha_s != +-alpha_r.

Example RootDtm_RootArithmetic (H80E13)

> 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 ) : RootDtm, RngIntElt -> RngIntElt
CorootHeight( R, r ) : RootDtm, RngIntElt -> RngIntElt
The height of the rth (co)root of the root datum R, i.e. the sum of the coefficients of alpha_r (resp. alpha_r^star) with respect to the simple (co)roots.
RootNorms( R ) : RootDtm -> [RngIntElt]
CorootNorms( R ) : RootDtm -> [RngIntElt]
The sequence of squares of the lengths of the (co)roots of the root datum R.
RootNorm( R, r ) : RootDtm, RngIntElt -> RngIntElt
CorootNorm( R, r ) : RootDtm, RngIntElt -> RngIntElt
The square of the length of the rth (co)root of the root datum R.
IsLongRoot( R, r ) : RootDtm, RngIntElt -> BoolElt
Returns true if, and only if, the rth root of the root datum R is long, i.e. the rth coroot is short. This only makes sense for irreducible crystallographic root data.
IsShortRoot( R, r ) : RootDtm, RngIntElt -> BoolElt
Returns true if, and only if, the rth root of the root datum R is short, i.e. the rth coroot is long. This only makes sense for irreducible crystallographic root data.

Example RootDtm_RootOperations (H80E14)

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

AdditiveOrder( R ) : RootDtm -> SeqEnum
An additive order on the positive roots of the root datum R, ie. a sequence containing the numbers 1, ..., N in some order so that alpha_r + alpha_s=alpha_t implies t is between r and s. This is computed using the techniques of [Pap94]

Example RootDtm_AdditiveOrder (H80E15)

> 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 Lambda of the root datum R. i.e. the lambda in Q Phi <= Q tensor X such that < lambda, alpha^star > in Z for every coroot alpha^star.
CoweightLattice( R ) : RootDtm -> Lat
The coweight lattice Lambda^star of the root datum R, i.e. the lambda^star in Q Phi^star <= Q tensor Y such that < alpha, lambda^star > in Z for every root alpha.
FundamentalWeights( R ) : RootDtm -> Mtrx
    Basis: MonStgElt                    Default: "Standard"
The fundamental weights lambda_1, ..., lambda_n of the root datum R given as the rows of a matrix. This is the basis of the weight lattice Lambda dual to the simple coroots, i.e. < lambda_i, alpha_j^star >=delta_(ij).
FundamentalCoweights( R ) : RootDtm -> Mtrx
    Basis: MonStgElt                    Default: "Standard"
The fundamental coweights lambda_1^star, ..., lambda_n^star of the root datum R given as the rows of a matrix. This is the basis of the coweight lattice Lambda^star dual to the simple roots, i.e. < alpha_i, lambda_j^star >=delta_(ij).

Example RootDtm_Weights (H80E16)

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


 [Next][Prev] [Right] [Left] [Up] [Index] [Root]