Let *R* be a root system in the real vector space *V* as in Chapter Root
systems and finite Coxeter groups. We say that *F _{0}∈ *GL

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

Let * T* be a maximal torus of

If * T* is

It turns out that an interesting part of the objects attached to this datum
depends only on *(V,W, F _{0})*: the order of the maximal tori, the ``fake
degrees", the order of

We assume now that * T* is contained in an

`.phi`

of the coset record. It may be defined without mentioning
the roots, as follows: `.phi`

when `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 * G^{F}* where

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=W _{1}× ... × W_{k}* is
cyclically permuted by

• 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): * ^{2}A_{n}*,

• For non-crystallographic root systems where all the roots have the
same length the additional cases * ^{2}B_{2}*,

• In case * ^{3}D_{4}* the group

• In case * ^{2}D_{n}* the group

• In the remaining crystallographic cases *φ* identifies to *-w _{0}*
where

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
*F _{0}:V→ V* (see the commands

`CoxeterCoset`

and
`CoxeterSubCoset`

). As for Coxeter groups, the elements of `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

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 *B _{2}*,
which corresponds to a subgroup of type

gap> W:=CoxeterGroup("B",2); CoxeterGroup("B",2) gap> Twistings(W,[2,4]); [ A1<2>xA1<4>, (A1xA1)<2,4> ]

- CoxeterCoset
- CoxeterSubCoset
- Functions on Coxeter cosets
- ReflectionType for Coxeter cosets
- ChevieClassInfo for Coxeter cosets
- CharTable for Coxeter cosets
- Frobenius
- GraphAutomorphisms
- Twistings for Coxeter cosets
- RootDatum for Coxeter cosets
- Torus for Coxeter cosets
- StructureRationalPointsConnectedCentre
- ClassTypes
- Quasi-Semisimple elements of non-connected reductive groups
- Centralizer for quasisemisimple elements
- QuasiIsolatedRepresentatives for Coxeter cosets
- IsIsolated for Coxeter cosets

`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(`

, representing an automorphism
`W`)*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`

:

true

`reflectionGroup`

:

the Coxeter group`W`

`F0Mat`

:

the matrix acting on*V*which represents the unique element*φ*in*WF*which preserves the positive roots._{0}

`phi`

:

the permutation of the roots of`W`induced by`F0Mat`

(also the element of smallest length in the Coset*WF*)._{0}

In the first example we create a Coxeter coset corresponding to the
general unitary groups *GU _{3}(q)* over finite fields with

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(`

. If specified, `WF`)`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

All functions for reflection cosets are implemented for Coxeter cosets.

This includes `Group( `

which returns the Coxeter group of which `WF` )`WF`
is a coset; the functions `Elements`

, `Random`

, `Representative`

, `Size`

,
`in`

, Rank, SemisimpleRank, which use the corresponding functions for
`Group( `

; `WF` )`ConjugacyClasses( `

, which returns the
`WF` )*φ*-conjugacy classes of `W`; the corresponding `PositionClass( `

and `WF` ,
`x` )`FusionConjugacyClasses( `

, `HF`, `WF` )`InductionTable( `

.
`HF`,
`WF` )

For Weyl coset associated to a finite reductive group * G^{F}*, 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( `

and `WF` )`PrintDiagram( `

show
the isomorphism type of the reductive group `WF` )* G^{F}*. An orbit of

`phi`

on the components is put in brackets if of length `"2(A2xA2)"`

denotes 2 components of type `3D4`

denotes an orbit of length 1 on
which

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( `

, see the explicit description in
ChevieClassInfo for Coxeter cosets.
`WF` )

`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*.

`ReflectionType( `

`WF` )

returns the type of the Coxeter coset `WF`. This consists of a list of
records, one for each orbit of

on the irreducible components
of the Dynkin diagram of `WF`.phi`CoxeterGroup(`

, which have two fields:`WF`)

`orbit`

:

is a list of types of the irreducible components in the orbit. These types are the same as returned by the function`ReflectionType`

for an irreducible untwisted Coxeter group (see`ReflectionType`

in chapter Root systems and finite Coxeter groups): a couple`[`

(a triple for type`type`,`indices`]*I*). The components are ordered according to the action of_{2}(n)

, 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`WF`.phi*...*

`phi`

:

if*k*is the number of irreducible components in the orbit, this is the permutation which describes the action of`WF`.phion the simple roots of the first irreducible component in the orbit.^{k}

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

`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(`

. In the case
where `WF`)*-1∉ W*, i.e., *φ=-w _{0}*, they are obtained by multiplying
by

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

`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(`

returns a function which
makes `WF`)

act on its argument which is some object for which this
action has been defined. If `WF`.phi`o` is a list, it applies recursively
`Frobenius`

to each element of the list. If it is a permutation or an
integer, it returns

. If a second argument `o`^(`WF`.phi^-1)`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

is defined and if so calls this function with
arguments `o`.operations.Frobenius`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

`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(`

for a coset), or
a sublist of the generating reflections of `W`)`W` (resp. `Group(W)`

), in which
case the call is the same as `Twistings(`

(resp. `W`,ReflectionSubgroup(`W`,`L`))`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 *N _{W}(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 ]

`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))`

.

`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

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

`StructureRationalPointsConnectedCentre(`

`G`,q)

`W` should be a Coxeter group record or a Coxeter coset record,
representing a finite reductive group * G^{F}*, and

In the following example one determines the structure of * T(\mathbb
F_{3})* where

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 * G^{F}* and

The function `ClassTypes`

is presently only implemented for simply
connected groups, where *C _{G}(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 `CoxeterSubCoset`

s and
contain additionnaly information on the unipotent classes of *C _{G}(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.

- Let us give some examples:

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
* G^{F}* have a given type. The answer in general involves variables of the
form

`q_d`

which represent gcd

- Finally an example in bad characteristic:

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

We may also use Coxeter cosets to represented non-connected reductive
groups of the form * G⋊σ* where

We have extended the functions for semi-simple elements to work with
quasi-semisimple elements *tσ∈ T.σ*. Here, as in
ss,

Here are some examples:

gap> WF:=RootDatum("u",6); 2A5.(q+1)

The above defines the coset GL* _{6}.σ* where

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

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 *C _{G}(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

gap> List(l,s->IsIsolated(WF,s)); [ true, false, true, true ]

`Centralizer(`

`WF`, `t`)

`WF` should be a Coxeter coset representing an algebraic coset
* G.σ*, where

`W:=Group(WF)`

), and

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

`W:=Group(WF)`

), and

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

`W:=Group(WF)`

), and

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

24 Apr 2021