Let R be a root system in the real vector space V as in Chapter Root systems and finite Coxeter groups. We say that F0∈ GL(V) is an automorphism of R if it permutes R and is of finite order (finite order is automatic if R generates V). It follows by Bou68, chap. VI, \S1.1, lemme 1 that the dual F0*∈GL(V∨) permutes the coroots R∨⊂ V∨; thus F0 normalizes the reflection group W associated to R, that is w→ F0wF0-1 is an automorphism of W. Thus (see Reflection cosets) we get a reflection coset WF0, called here a Coxeter coset.
The motivation for introducing Coxeter cosets comes from automorphisms of algebraic reductive groups, in particular non-split reductive groups over finite fields. Let us, as in Algebraic groups and semi-simple elements fix a connected reductive algebraic group G. We assume G is a group over an algebraic closure 𝔽q of a finite field 𝔽q, defined over 𝔽q, which corresponds to be given a Frobenius endomorphism F so that the finite group of rational points G(𝔽q) identifies to the subgroup GF of fixed points under F.
Let T be a maximal torus of G, and Φ (resp. Φ∨) be the roots (resp. coroots) of G with respect to T in the character group X(T) (resp. the group of one-parameter subgroups Y(T)). As explained in Algebraic groups and semi-simple elements then G is determined up to isomorphism by (X(T),Φ,Y(T),Φ∨) and in CHEVIE this corresponds to give a rational reflection group W=NG(T)/T acting on the vector space V=ℚ⊗ X(T) together with a root system.
If T is F-stable the Frobenius endomorphism F acts also naturally on X(T) and defines thus an endomorphism of V, which is of the form q F0, where F0∈GL(V) is of finite order and normalizes W. We get thus a Coxeter coset WF0⊂GL(V). The data (X(T), Φ, Y(T), Φ∨, F0), and the integer q completely determine up to isomorphism the associated reductive finite group GF. Thus these data is a way of representing in CHEVIE the essential information which determines a finite reductive group. Indeed, all properties of Chevalley groups can be computed from that datum: symbols representing characters, conjugacy classes, and finally the whole character table of GF.
It turns out that an interesting part of the objects attached to this datum depends only on (V,W, F0): the order of the maximal tori, the ``fake degrees", the order of GF, symbols representing unipotent characters, Deligne-Lusztig induction in terms of ``almost characters", the Fourier matrix relating characters and almost characters, etc... (see, e.g., BMM93). It is thus possible to extend their construction to non-crystallographic groups (or even to more general complex reflection groups, see Spets); this is why we did not include a root system in the definition of a reflection coset. However, unipotent conjugacy classes for instance depend on the root system thus do not exist in general.
We assume now that T is contained in an F-stable Borel subgroup of
G. This defines an order on the roots, and there is a unique element
φ∈ W F0, the reduced element of the coset, which preserves the
set of positive roots. It thus defines a diagram automorphism, that is an
automorphism of the Coxeter system (W,S). This element is stored in the
component .phi of the coset record. It may be defined without mentioning
the roots, as follows: (W,F0(S)) is another Coxeter system, thus
conjugate to S by a unique element of W, thus there is a unique element
φ∈ WF0 which stabilizes S (a proof follows from Bou68, Theoreme 1,
chap. V, \S 3). We consider thus cosets of the form Wφ where
φ stabilizes S. The coset W φ is completely defined by the
permutation .phi when G is semi-simple --- equivalently when Φ
generates V; in this case we just need to specify phi to define the
coset.
There is a slight generalisation of the above setup, covering in particular the case of the Ree and Suzuki groups. We consider GF where F not a Frobenius endomorphism, but an isogeny such that some power Fn is a Frobenius endomorphism. Then F still defines an endomorphism of V which normalizes W; we define a real number q such that Fn is attached to an 𝔽qn-structure. Then we still have F=q F0 where F0 is of finite order but q is no more an integer. Thus F0∈GL(V⊗ℝ) but F0∉GL(V). For instance, for the Ree and Suzuki groups, F0 is an automorphism of order 2 of W, which is of type G2, B2 or F4, and q=√ 2 for B2 and F4 and q=√ 3 for G2 To get this, we need to start from root systems for G2, B2 or F4 where all the roots have the same length. This kind of root system is not crystallographic. Such more general root systems also exist for all finite Coxeter groups such as the dihedral groups and H3 and H4. We will call here Weyl cosets the cosets corresponding to rational forms of algebraic groups, which include thus some non-rational roots systems for B2, G2 and F4.
Conjugacy classes and irreducible characters of Coxeter cosets are defined
as for general reflection cosets. For irreducible characters of Weyl
cosets, in CHEVIE we choose (following Lusztig) for each φ-stable
character of W a particular extension to a character of W⋊⟨
φ ⟩, which we will call the preferred extension. The character
table of the coset Wφ is the table of the restrictions to Wφ of
the preferred extensions (See also the section below CharTable for Coxeter
cosets). The question of finding the conjugacy classes and character table
of a Coxeter coset can be reduced to the case of irreducible root systems
R.
• The automorphism φ permutes the irreducible components of W, and Wφ is a direct product of cosets where φ permutes cyclically the irreducible components of W. The preferred extension is defined to be the direct product of the preferred extension in each of these situations.
• Assume now that Wφ is a descent of scalars, that is the decomposition in irreducible components W=W1× ... × Wk is cyclically permuted by φ. Then there are natural bijections from the φ-conjugacy classes of W to the φk-conjugacy classes of W1 as well as from the φ-stable characters of W to the φk-stable characters of W1, which reduce the definition of preferred extensions on Wφ to the definition for W1φk.
• Assume now that W is the Coxeter group of an irreducible root system. φ permutes the simple roots, hence induces a graph automorphism on the corresponding Dynkin diagram. If φ=1 then conjugacy classes and characters coincide with those of the Coxeter group W.
• The nontrivial cases for crystallographic roots systems are (the order of φ is written as left exponent to the type): 2An, 2Dn, 3D4, 2E6.
• For non-crystallographic root systems where all the roots have the same length the additional cases 2B2, 2G2, 2F4 and 2I2(k) arise.
• In case 3D4 the group W⋊⟨ φ⟩ can be embedded into the Coxeter group of type F4, which induces a labeling for the conjugacy classes of the coset. The preferred extension is chosen as the (single) extension with rational values.
• In case 2Dn the group W⋊⟨ φ⟩ is isomorphic to a Coxeter group of type Bn. This induces a canonical labeling for the conjugacy classes of the coset and allows to define the preferred extension in a combinatorial way using the labels (pairs of partitions) for the characters of the Coxeter group of type Bn.
• In the remaining crystallographic cases φ identifies to -w0 where w0 is the longest element of W. So, there is a canonical labeling of the conjugacy classes and characters of the coset by those of W. The preferred extensions are defined by describing the signs of the character values on -w0.
In GAP3 the most general construction of a Coxeter coset is by starting
from a Coxeter datum specified by the matrices of simpleRoots and
simpleCoroots, and giving in addition the matrix F0Mat of the map
F0:V→ V (see the commands CoxeterCoset and
CoxeterSubCoset). As for Coxeter groups, the elements of Wφ are
uniquely determined by the permutation they induce on the set of roots R.
We consider these permutations as Elements of the Coxeter coset.
Coxeter cosets are implemented in GAP3 by a record which points to a
Coxeter datum record and has additional fields holding F0Mat and the
corresponding element phi. Functions on the coset (for example,
ChevieClassInfo) are about properties of the group coset W φ ;
however, most definitions for elements of untwisted Coxeter groups apply
without change to elements in W φ: e.g., if we define the length of
an element wφ∈ W φ as the number of positive roots it sends to
negative ones, it is the same as the length of w, i.e., φ is of
length 0, since φ has been chosen to preserve the set of positive
roots. Similarly, the CoxeterWord describing wφ is the same as the
one for w, etc...
We associate to a Coxeter coset Wφ a twisted Dynkin diagram,
consisting of the Dynkin diagram of W and the graph automorphism induced
by φ on this diagram (this specifies the group W⋊⟨
F⟩, mentioned above, up to isomorphism). See the functions
ReflectionType, ReflectionName and PrintDiagram for Coxeter cosets.
Below is an example showing first how to not define, then how to define, the Weyl coset for a Suzuki group:
gap> 2B2:=CoxeterCoset(CoxeterGroup("B",2),(1,2));
#I transposed of matrix for F0 must normalize set of coroots of parent.
false
gap> 2B2:=CoxeterCoset(CoxeterGroup("Bsym",2),(1,2));
2Bsym2
gap> Display(CharTable(2B2));
2Bsym2
2 1 2 2
1 121
2. 1 1 1
.11 1 -1 -1
1.1 . -ER(2) ER(2)
A subcoset Hwφ of Wφ is given by a reflection subgroup H of W and an element w of W such that wφ induces an automorphism of the root system of H. For algebraic groups, this corresponds to a rational form of a reductive subgroup of maximal rank. For example, if Wφ corresponds to the algebraic group G and H is the trivial subgroup, the coset Hwφ corresponds to a maximal torus Tw of type w.
gap> CoxeterSubCoset(2B2,[],Group(2B2).1);
(q^2-ER(2)q+1)
A subgroup H which is a parabolic subgroup corresponds to a rational form
of a Levi subgroup of G. The command Twistings gives all rational
forms of such a Levi.
gap> W:=CoxeterGroup("B",2);
CoxeterGroup("B",2)
gap> Twistings(W,[1]);
[ ~A1.(q-1), ~A1.(q+1) ]
gap> Twistings(W,[2]);
[ A1<2>.(q-1), A1<2>.(q+1) ]
Notice how we distinguish between subgroups generated by short roots and by long roots. A general H corresponds to a reductive subgroup of maximal rank. Here we consider the subgroup generated by the long roots in B2, which corresponds to a subgroup of type SL2× SL2 in SP4, and show its possible rational forms.
gap> W:=CoxeterGroup("B",2);
CoxeterGroup("B",2)
gap> Twistings(W,[2,4]);
[ A1<2>xA1<4>, (A1xA1)<2,4> ]
CoxeterCoset( W[, FMat ] )
CoxeterCoset( W[, FPerm] )
This function returns a Coxeter coset as a GAP3 object. The argument W
must be a Coxeter group (created by CoxeterGroup or
ReflectionSubgroup). In the first form the argument F0Mat must be an
invertible matrix of dimension Rank(W), representing an automorphism
F of the root system of the parent of W. In the second form FPerm is
a permutation of the roots of the parent group of W; it is assumed that
the corresponding FMat acts trivially on the orthogonal of these roots. A
shortcut is accepted if W has same rank as semisimple rank and FPerm
preserves its simple roots: one need only give the induced permutation of
the simple roots.
If there is no second argument the default for F0Mat is the identity matrix.
CoxeterCoset returns a record from which we document the following
components:
isDomain, isFinite:
reflectionGroup:
F0Mat:
phi:F0Mat
(also the element of smallest length in the Coset WF0).
In the first example we create a Coxeter coset corresponding to the general unitary groups GU3(q) over finite fields with q elements.
gap> W := RootDatum("gl",3);;
gap> gu3 := CoxeterCoset( W, -IdentityMat( 3 ) );
2A2.(q+1)
gap> F4 := CoxeterGroup( "F", 4 );;
gap> D4 := ReflectionSubgroup( F4, [ 1, 2, 16, 48 ] );;
gap> PrintDiagram( D4 );
D4 9
\
1 - 16
/
2
gap> CoxeterCoset( D4, MatXPerm(D4,(2,9,16)) );
3D4<9,16,1,2>
gap> CoxeterCoset( D4, (2,9,16));
3D4<9,16,1,2>
CoxeterSubCoset( WF, r[, w])
Returns the reflection subcoset of the Coxeter coset WF generated by
the reflections with roots specified by r. r is a list of indices
specifying a subset of the roots of W where W is the Coxeter group
CoxeterGroup(WF). If specified, w must be an element of W such
that w*WF.phi normalizes the subroot system generated by r. If
absent, the default value for w is (). It is an error, if
w*WF.phi does not normalize the subsystem.
gap> CoxeterSubCoset( CoxeterCoset( CoxeterGroup( "A", 2 ), (1,2) ),
> [ 1 ] );
Error, must give w, such that w * WF.phi normalizes subroot system.
in
CoxeterSubCoset( CoxeterCoset( CoxeterGroup( "A", 2 ), (1,2) ), [ 1 ]
) called from
main loop
brk>
gap> f4coset := CoxeterCoset( CoxeterGroup( "F", 4 ) );
F4
gap> w := RepresentativeOperation( CoxeterGroup( f4coset ),
> [ 1, 2, 9, 16 ], [ 1, 9, 16, 2], OnTuples );;
gap> 3d4again := CoxeterSubCoset( f4coset, [ 1, 2, 9, 16], w );
3D4<9,16,1,2>
gap> PrintDiagram( 3d4again );
phi acts as ( 2, 9,16) on the component below
D4 9
\
1 - 2
/
16
96.3 Functions on Coxeter cosets
All functions for reflection cosets are implemented for Coxeter cosets.
This includes Group( WF ) which returns the Coxeter group of which WF
is a coset; the functions Elements, Random, Representative, Size,
in, Rank, SemisimpleRank, which use the corresponding functions for
Group( WF ); ConjugacyClasses( WF ), which returns the
φ-conjugacy classes of W; the corresponding PositionClass( WF ,
x ) and FusionConjugacyClasses( HF, WF ), InductionTable( HF,
WF ).
For Weyl coset associated to a finite reductive group GF, the characters of the coset correspond to unipotent Deligne-Lusztig characters, and the induction from a subcoset corresponding to a Levi subgroup corresponds to the Lusztig induction of the Deligne-Lusztig characters (see more details in the next chapter). Here are some examples:
Harish-Chandra induction in the basis of almost characters:
gap> WF := CoxeterCoset( CoxeterGroup( "A", 4 ), (1,4)(2,3) );
2A4
gap> Display( InductionTable( CoxeterSubCoset( WF, [ 2, 3 ] ), WF ) );
Induction from 2A2<2,3>.(q-1)(q+1) to 2A4
|111 21 3
________________
11111 | 1 . .
2111 | . 1 .
221 | 1 . .
311 | 1 . 1
32 | . . 1
41 | . 1 .
5 | . . 1
Lusztig induction from a diagonal Levi:
gap> HF := CoxeterSubCoset( WF, [1, 2],
> LongestCoxeterElement( CoxeterGroup( WF ) ) );;
gap> Display( InductionTable( HF, WF ) );
Induction from 2A2.(q+1)^2 to 2A4
|111 21 3
_________________
11111 | -1 . .
2111 | -2 -1 .
221 | -1 -2 .
311 | 1 2 -1
32 | . -2 1
41 | . 1 -2
5 | . . 1
A descent of scalars:
gap> W := CoxeterCoset( CoxeterGroup( "A", 2, "A", 2 ), (1,3)(2,4) );
(A2xA2)
gap> Display( InductionTable( CoxeterSubCoset( W, [ 1, 3 ] ), W ) );
Induction from (A1xA1)<1,3>.(q-1)(q+1) to (A2xA2)
|11 2
__________
111 | 1 .
21 | 1 1
3 | . 1
Print( WF ), ReflectionName( WF ) and PrintDiagram( WF ) show
the isomorphism type of the reductive group GF. An orbit of
φ=WF.phi on the components is put in brackets if of length k
greater than 1, and is preceded by the order of φk on it, if this
is not 1. For example "2(A2xA2)" denotes 2 components of type A2
permuted by φ, and such that φ2 induces the non-trivial diagram
automorphism on any of them, while 3D4 denotes an orbit of length 1 on
which φ is of order 3.
gap> W := CoxeterCoset( CoxeterGroup( "A", 2, "G", 2, "A", 2 ),
> (1,5,2,6) );
2(A2xA2)<1,2,5,6>xG2<3,4>
gap> ReflectionName( W );
"2(A2xA2)<1,2,5,6>xG2<3,4>"
gap> W := CoxeterCoset( CoxeterGroup( "A", 2, "A", 2 ), (1,3,2,4) );
2(A2xA2)
gap> PrintDiagram( W );
phi permutes the next 2 components
phi^2 acts as (1,2) on the component below
A2 1 - 2
A2 3 - 4
ChevieClassInfo( WF ), see the explicit description in
ChevieClassInfo for Coxeter cosets.
ChevieCharInfo returns additional information on the irreducible
characters, see ChevieCharInfo for reflection cosets.
Finally, some functions for elements of a Coxeter group work naturally for
elements of a Coxeter coset: CoxeterWord, EltWord, CoxeterLength,
LeftDescentSet, RightDescentSet, ReducedInRightCoset, etc...
These functions take the same value on wφ∈ Wφ that they take on
w∈ W.
96.4 ReflectionType for Coxeter cosets
ReflectionType( WF )
returns the type of the Coxeter coset WF. This consists of a list of
records, one for each orbit of WF.phi on the irreducible components
of the Dynkin diagram of CoxeterGroup(WF), which have two fields:
orbit:ReflectionType
for an irreducible untwisted Coxeter group (see ReflectionType in
chapter Root systems and finite Coxeter groups): a couple
[type,indices] (a triple for type I2(n)). The components are
ordered according to the action of WF.phi, so WF.phi maps the
generating permutations with indices in the first type to indices in the
second type in the same order as stored in the type, etc ...phi:WF.phik on
the simple roots of the first irreducible component in the orbit.
gap> W := CoxeterCoset( CoxeterGroup( "A", 2, "A", 2 ), (1,3,2,4) );
2(A2xA2)
gap> ReflectionType( W );
[ rec(orbit := [ rec(rank := 2,
series := "A",
indices := [ 1, 2 ]), rec(rank := 2,
series := "A",
indices := [ 3, 4 ]) ],
twist := (1,2)) ]
96.5 ChevieClassInfo for Coxeter cosets
ChevieClassInfo( WF )
returns information about the conjugacy classes of the Coxeter coset
WF. The result is a record with three components: classtext
contains a list of reduced words for the representatives in
ConjugacyClasses(WF), classnames contains corresponding names for
the classes, and classparams gives corresponding parameters for the
classes. Let W be the Coxeter group CoxeterGroup(WF). In the case
where -1∉ W, i.e., φ=-w0, they are obtained by multiplying
by w0 a set of representatives of maximal length of the classes
of W.
gap> W := CoxeterGroup( "D", 4 );;
gap> ChevieClassInfo( CoxeterCoset( W, (1,2,4) ) );
rec(
classtext := [ [ 1 ], [ ], [ 1, 2, 3, 1, 2, 3 ], [ 3 ], [ 1, 3 ],
[ 1, 2, 3, 1, 2, 4, 3, 2 ], [ 1, 2, 3, 2 ] ],
classnames := [ "C_3", "\\tilde A_2", "C_3+A_1", "\\tilde A_2+A_1",
"F_4", "\\tilde A_2+A_2", "F_4(a_1)" ],
classparams :=
[ [ "C_3" ], [ "\\tilde A_2" ], [ "C_3+A_1" ], [ "\\tilde A_2+A_1"
], [ "F_4" ], [ "\\tilde A_2+A_2" ], [ "F_4(a_1)" ] ] )
96.6 CharTable for Coxeter cosets
CharTable( WF )
This function returns the character table of the Coxeter coset WF (see also the introduction of this Chapter). We call ``characters'' of the Coxeter coset WF with corresponding Coxeter group W the restriction to W φ of a set containing one extension of each φ-invariant character of W to the semidirect product of W with the cyclic group generated by φ. (We choose, following Lusztig, in each case one non-canonical extension, called the preferred extension.)
The returned record contains almost all components present in the character
table of a Coxeter group. But if φ is not trivial then there are no
components powermap (since powers of elements in the coset need not be in
the coset) and orders (if you really need them, use MatXPerm to
determine the order of elements in the coset).
gap> W := CoxeterCoset( CoxeterGroup( "D", 4 ), (1,2,4) );
3D4
gap> Display( CharTable( W ) );
3D4
2 2 2 2 2 2 3 3
3 1 1 1 . . 1 1
C3 ~A2 C3+A1 ~A2+A1 F4 ~A2+A2 F4(a1)
.4 1 1 1 1 1 1 1
.1111 -1 1 1 -1 1 1 1
.22 . 2 2 . -1 -1 -1
11.2 . . . . -1 3 3
1.3 1 1 -1 -1 . -2 2
1.111 -1 1 -1 1 . -2 2
1.21 . 2 -2 . . 2 -2
Frobenius( WF )( o [, i])
Given a Coxeter coset WF, Frobenius(WF) returns a function which
makes WF.phi act on its argument which is some object for which this
action has been defined. If o is a list, it applies recursively
Frobenius to each element of the list. If it is a permutation or an
integer, it returns o^(WF.phi^-1). If a second argument i is
given, it applies Frobenius raised to the i-th power (this is
convenient for instance to apply the inverse of Frobenius). Finally, for
an arbitrary object defined by a record, it looks if the method
o.operations.Frobenius is defined and if so calls this function with
arguments WF, o and i (with i=1 if it was omitted).
Such an action of the Frobenius is defined for instance for braids, Hecke elements and semisimple elements.
gap> W:=CoxeterGroup("E",6);;WF:=CoxeterCoset(W,(1,6)(3,5));
2E6
gap> T:=Basis(Hecke(Group(WF)),"T");;Frobenius(WF)(T(1));
T(6)
gap> B:=Braid(W);; Frobenius(WF)(B(1,2,3));
265
gap> s:=SemisimpleElement(W,[1..6]/6);
<1/6,1/3,1/2,2/3,5/6,0>
gap> Frobenius(WF)(s);
<0,1/3,5/6,2/3,1/2,1/6>
gap> W:=CoxeterGroup("D",4);WF:=CoxeterCoset(W,(1,2,4));
CoxeterGroup("D",4)
3D4
gap> B:=Braid(W);;b:=B(1,3);
13
gap> Frobenius(WF)(b);
43
gap> Frobenius(WF)(b,-1);
23
GraphAutomorphisms( t )
t should be the reflection type of a Coxeter group. The function returns the group of all Graph automorphisms of t.
gap> W:=CoxeterGroup("D",4,"D",4);
CoxeterGroup("D",4,"D",4)
gap> GraphAutomorphisms(ReflectionType(W));
Group( (1,5)(2,6)(3,7)(4,8), (1,2), (1,4) )
gap> Size(last);
72
96.9 Twistings for Coxeter cosets
Twistings( W )
W should be a Coxeter group record which is not a proper reflection
subgroup of another reflection group. The function returns all
CoxeterCosets representing twisted forms of algebraic groups of type W.
gap> Twistings(CoxeterGroup("A",3,"A",3));
[ A3xA3, A3x2A3, 2A3xA3, 2A3x2A3, (A3xA3), 2(A3xA3),
2(A3xA3)<1,2,3,6,5,4>, (A3xA3)<1,2,3,6,5,4> ]
gap> Twistings(CoxeterGroup("D",4));
[ D4, 2D4<2,4,3,1>, 2D4, 3D4, 3'D4<1,4,3,2>, 2D4<1,4,3,2> ]
gap> Twistings(RootDatum("so",8));
[ D4, 2D4 ]
Twistings( W, L )
W should be a Coxeter group record or a Coxeter coset record, and L
should be a reflection subgroup of W (or of Group(W) for a coset), or
a sublist of the generating reflections of W (resp. Group(W)), in which
case the call is the same as Twistings(W,ReflectionSubgroup(W,L))
(resp. Twistings(W,ReflectionSubgroup(Group(W),L))).
The function returns the list, up to W-conjugacy, of Coxeter sub-cosets of W whose Coxeter group is L --- In term of algebraic groups, it corresponds to representatives of the possible twisted forms of the reductive subgroup of maximal rank L. In the case that W represents a coset Wφ, the subgroup L must be conjugate to φ(L) for a rational form to exist. If wφ normalizes L, then the rational forms are classified by the the φ-classes of NW(L)/L.
gap> W:=CoxeterGroup("E",6);
CoxeterGroup("E",6)
gap> WF:=CoxeterCoset(W,(1,6)(3,5));
2E6
gap> L:=ReflectionSubgroup(W,[2..5]);
ReflectionSubgroup(CoxeterGroup("E",6), [ 2, 3, 4, 5 ])
gap> Twistings(W,L);
[ D4<2,3,4,5>.(q-1)^2, 3D4<2,3,4,5>.(q^2+q+1),
2D4<2,3,4,5>.(q-1)(q+1) ]
gap> Twistings(WF,L);
[ 2D4<2,5,4,3>.(q-1)(q+1), 3'D4<2,5,4,3>.(q^2-q+1),
D4<2,3,4,5>.(q+1)^2 ]
96.10 RootDatum for Coxeter cosets
RootDatum(type[,rank])
The function RootDatum can be used to get Coxeter cosets corresponding to
known types of algebraic groups. The twisted types known are "2B2",
"suzuki", "2E6", "2E6sc", "2F4", "2G2", "ree",
"2I", "3D4", "triality", "3D4sc", "3gpin8", "pso-",
"so-", "spin-", "gpin-", "psu", "su", "u".
gap> RootDatum("su",4);
2A3
The above call is same as CoxeterCoset(CoxeterGroup("A",3,"sc"),(1,3))
or CoxeterCoset(RootDatum("sl",4),(1,3)).
96.11 Torus for Coxeter cosets
Torus(M)
M should be an integral matrix of finite order. Torus returns the coset
WF of the trivial Coxeter group such that WF.F0Mat=M. This
corresponds to an algebraic torus T of rank Length(M), with an
isogeny which acts by M on X(T).
gap> m:=[[0,-1],[1,-1]];
[ [ 0, -1 ], [ 1, -1 ] ]
gap> Torus(m);
(q^2+q+1)
Torus(W,i)
This returns the Torus twisted by the i-th conjugacy class of W. For
Coxeter groups or cosets it is the same as Twistings(W,[])[i].
gap> W:=CoxeterGroup("A",3);
CoxeterGroup("A",3)
gap> Twistings(W,[]);
[ (q-1)^3, (q-1)^2(q+1), (q-1)(q+1)^2, (q-1)(q^2+q+1), (q+1)(q^2+1) ]
gap> Torus(W,2);
(q-1)^2(q+1)
gap> W:=CoxeterCoset(CoxeterGroup("A",3),(1,3));
2A3
gap> Twistings(W,[]);
[ (q+1)^3, (q-1)(q+1)^2, (q-1)^2(q+1), (q+1)(q^2-q+1), (q-1)(q^2+1) ]
gap> Torus(W,2);
(q-1)(q+1)^2
96.12 StructureRationalPointsConnectedCentre
StructureRationalPointsConnectedCentre(G,q)
W should be a Coxeter group record or a Coxeter coset record, representing a finite reductive group GF, and q should be the prime power associated to the isogeny F. The function returns the abelian invariants of the finite abelian group Z0GF where Z0G is the connected center of G.
In the following example one determines the structure of T(\mathbb F3) where T runs over all the maximal tori of SL4.
gap> G:=RootDatum("sl",4);
RootDatum("sl",4)
gap> List(Twistings(G,[]),T->StructureRationalPointsConnectedCentre(T,3));
[ [ 2, 2, 2 ], [ 2, 8 ], [ 4, 8 ], [ 26 ], [ 40 ] ]
ClassTypes(G [,p])
G should be a root datum or a twisted root datum representing a finite reductive group GF and p should be a prime. The function returns the class types of G. Two elements of GF have the same class type if their centralizers are conjugate. If su is the Jordan decomposition of an element x, the class type of x is determined by the class type of its semisimple part s and the unipotent class of u in CG(s).
The function ClassTypes is presently only implemented for simply
connected groups, where CG(s) is connected. This section is a bit
experimental and may change in the future.
ClassTypes returns a record which contains a list of classtypes for
semisimple elements, which are represented by CoxeterSubCosets and
contain additionnaly information on the unipotent classes of CG(s).
The list of class types is different in bad characteristic, so the argument p should give a characteristic. If p is omitted or equal to 0, then good characteristic is assumed.
gap> t:=ClassTypes(RootDatum("sl",3));
ClassTypes(CoxeterCoset(RootDatum("sl",3)),good characteristic)
gap> Display(t);
ClassTypes(CoxeterCoset(RootDatum("sl",3)),good characteristic)
Type |Centralizer
________________________
(q-1)^2 | P1^2
(q-1)(q+1) | P1P2
(q^2+q+1) | P3
A1.(q-1) | qP1^2P2
A2 |q^3P1^2P2P3
By default, only information about semisimple centralizer types is returned: the type, and its generic order.
gap> Display(t,rec(unip:=true));
ClassTypes(CoxeterCoset(RootDatum("sl",3)),good characteristic)
Type | u Centralizer
_______________________________
(q-1)^2 | P1^2
(q-1)(q+1) | P1P2
(q^2+q+1) | P3
A1.(q-1) | 11 qP1^2P2
| 2 qP1
A2 | 111 q^3P1^2P2P3
| 21 q^3P1
| 3 3q^2
| 3_E3 3q^2
|3_E3^2 3q^2
Here we have displayed information on unipotent classes, with their centralizer.
gap> Display(t,rec(nrClasses:=true));
ClassTypes(CoxeterCoset(RootDatum("sl",3)),good characteristic)
Type | nrClasses Centralizer
__________________________________________
(q-1)^2 |(4-5q+2q_3+q^2)/6 P1^2
(q-1)(q+1) | (-q+q^2)/2 P1P2
(q^2+q+1) | (1+q-q_3+q^2)/3 P3
A1.(q-1) | -1+q-q_3 qP1^2P2
A2 | q_3 q^3P1^2P2P3
Here we have added information on how many semisimple conjugacy classes of
GF have a given type. The answer in general involves variables of the
form q_d which represent gcd(q-1,d).
gap> t:=ClassTypes(CoxeterGroup("G",2),2);
ClassTypes(CoxeterCoset(CoxeterGroup("G",2)),char. 2)
gap> Display(t,rec(nrClasses:=true));
ClassTypes(CoxeterCoset(CoxeterGroup("G",2)),char. 2)
Type | nrClasses Centralizer
__________________________________________________
(q-1)^2 |(10-8q+2q_3+q^2)/12 P1^2
(q-1)(q+1) | (-2q+q^2)/4 P1P2
(q-1)(q+1) | (-2q+q^2)/4 P1P2
(q^2-q+1) | (1-q-q_3+q^2)/6 P6
(q^2+q+1) | (1+q-q_3+q^2)/6 P3
(q+1)^2 |(-2-4q+2q_3+q^2)/12 P2^2
A1.(q-1) | (-1+q-q_3)/2 qP1^2P2
A1.(q+1) | (1+q-q_3)/2 qP1P2^2
G2 | 1 q^6P1^2P2^2P3P6
A2<1,5> | (-1+q_3)/2 q^3P1^2P2P3
2A2<1,5> | (-1+q_3)/2 q^3P1P2^2P6
~A1<2>.(q-1) | (-2+q)/2 qP1^2P2
~A1<2>.(q+1) | q/2 qP1P2^2
We notice that if q is a power of 2 such that q≡ 2(mod 3), so
that q_3=1, some class types do not exist. We can see what happens by
using the function Value to give a specific value to q_3:
gap> Display(Value(t,["q_3",1]),rec(nrClasses:=true));
ClassTypes(CoxeterCoset(CoxeterGroup("G",2)),char. 2) q_3=1
Type | nrClasses Centralizer
_____________________________________________
(q-1)^2 |(12-8q+q^2)/12 P1^2
(q-1)(q+1) | (-2q+q^2)/4 P1P2
(q-1)(q+1) | (-2q+q^2)/4 P1P2
(q^2-q+1) | (-q+q^2)/6 P6
(q^2+q+1) | (q+q^2)/6 P3
(q+1)^2 | (-4q+q^2)/12 P2^2
A1.(q-1) | (-2+q)/2 qP1^2P2
A1.(q+1) | q/2 qP1P2^2
G2 | 1 q^6P1^2P2^2P3P6
~A1<2>.(q-1) | (-2+q)/2 qP1^2P2
~A1<2>.(q+1) | q/2 qP1P2^2
96.14 Quasi-Semisimple elements of non-connected reductive groups
We may also use Coxeter cosets to represented non-connected reductive groups of the form G⋊σ where G is a connected reductive group and σ an algebraic automorphism of G, and more specifically the coset G.σ. We may always choose σ∈G.σ quasi-semisimple, which means that σ preserves a pair T⊂B of a maximal torus and a Borel subgroup of G. If σ is of finite order, it then defines an automorphism F0 of the root datum (X(T), Φ, Y(T), Φ∨), thus a Coxeter coset. We refer to ss for details.
We have extended the functions for semi-simple elements to work with quasi-semisimple elements tσ∈T.σ. Here, as in ss, σ is a quasi-central automorphism uniquely defined by a diagram automorphism of (W,S), taking σ symplectic in type A2n. We recall that a quasi-central element is a quasi-semisimple element such that the Weyl group of CG(σ) is equal to Wσ; such an element always exists in the coset G.σ.
Here are some examples:
gap> WF:=RootDatum("u",6);
2A5.(q+1)
The above defines the coset GL6.σ where σ is the composed of transpose, inverse and the longest element of W.
gap> l:=QuasiIsolatedRepresentatives(WF);
[ <0,0,0,0,0,0>, <1/4,0,0,0,0,3/4>, <1/4,1/4,0,0,3/4,3/4>,
<1/4,1/4,1/4,3/4,3/4,3/4> ]
we define an element tσ∈T.σ to be quasi-isolated if the Weyl group of CG(tσ) is not in any proper parabolic subgroup of Wσ. This generalizes the definition for connected groups. The above shows the elements t where tσ runs over representatives of quasi-isolated quasi-semisimple classes of G.σ. The given representatives have been chosen σ-stable.
gap> List(l,s->Centralizer(WF,s));
[ C3<3,2,1>, B2.(q+1), (A1xA1)<1,3>xA1<2>, 2A3<3,1,2> ]
in the above, the groups CG(tσ) are computed and displayed as extended Coxeter groups (following the same convention as for centralisers in connected reductive groups).
We define an element tσ∈T.σ to be isolated if the Weyl group of CG(tσ)0 is not in any proper parabolic subgroup of Wσ. This generalizes the definition for connected groups.
gap> List(l,s->IsIsolated(WF,s));
[ true, false, true, true ]
96.15 Centralizer for quasisemisimple elements
Centralizer(WF, t)
WF should be a Coxeter coset representing an algebraic coset
G.σ, where G is a connected reductive group (represented
by W:=Group(WF)), and σ is a quasi-central automorphism of G
defined by WF. The element t should be a semisimple element of G.
The function returns an extended reflection group describing
CG(tσ), with the reflection group part representing
CG0(tσ), and the diagram automorphism part being those induced
by CG(tσ)/CG(tσ)0 on CG(tσ)0.
gap> WF:=RootDatum("u",6);
2A5.(q+1)
gap> s:=SemisimpleElement(Group(WF),[1/4,0,0,0,0,3/4]);
<1/4,0,0,0,0,3/4>
gap> Centralizer(WF,s);
B2.(q+1)
gap> Centralizer(WF,s^0);
C3<3,2,1>
QuasiIsolatedRepresentatives(WF[, p])
WF should be a Coxeter coset representing an algebraic coset
G.σ, where G is a connected reductive group (represented
by W:=Group(WF)), and σ is a quasi-central automorphism of G
defined by WF. The function returns a list of semisimple elements of
G such that tσ, when t runs over this list, are
representatives of the conjugacy classes of quasi-isolated quasisemisimple
elements of G.σ (an element tσ∈T.σ is
quasi-isolated if the Weyl group of CG(tσ) is not in any proper
parabolic subgroup of Wσ). If a second argument p is given, it
lists only those representatives which exist in characteristic p.
gap> QuasiIsolatedRepresentatives(RootDatum("2E6sc"));
[ <0,0,0,0,0,0>, <0,0,0,1/2,0,0>, <0,1/2,1/4,0,1/4,0>,
<0,2/3,0,1/3,0,0>, <0,3/4,0,1/2,0,0> ]
gap> QuasiIsolatedRepresentatives(RootDatum("2E6sc"),2);
[ <0,0,0,0,0,0>, <0,2/3,0,1/3,0,0> ]
gap> QuasiIsolatedRepresentatives(RootDatum("2E6sc"),3);
[ <0,0,0,0,0,0>, <0,0,0,1/2,0,0>, <0,1/2,1/4,0,1/4,0>,
<0,3/4,0,1/2,0,0> ]
IsIsolated(WF, t)
WF should be a Coxeter coset representing an algebraic coset
G.σ, where G is a connected reductive group (represented
by W:=Group(WF)), and σ is a quasi-central automorphism of G
defined by WF. The element t should be a semisimple element of G.
The function returns a boolean describing whether tσ is isolated,
that is whether the Weyl group of CG(tσ)0 is not in any proper
parabolic subgroup of Wσ.
gap> WF:=RootDatum("u",6);
2A5.(q+1)
gap> l:=QuasiIsolatedRepresentatives(WF);
[ <0,0,0,0,0,0>, <1/4,0,0,0,0,3/4>, <1/4,1/4,0,0,3/4,3/4>,
<1/4,1/4,1/4,3/4,3/4,3/4> ]
gap> List(l,s->IsIsolated(WF,s));
[ true, false, true, true ]
gap3-jm