Let us fix an algebraically closed field *K* and let * G* be a connected
reductive algebraic group over

Then * G* is determined up to isomorphism by the

This is obtained by a slight generalization of our setup for a Coxeter
group *W*. This time we assume the canonical basis of the vector space *V*
on which *W* acts is a *ℤ*-basis of *X*, and *Φ* is specified by a
matrix `W.simpleRoots`

whose lines are the simple roots expressed in this
basis of *X*. Similarly *Φ ^{∨}* is described by a matrix

`W.simpleCoroots`

whose lines are the simple coroots in the basis of `x*y`

. Thus, we must have the relation
`W.simpleCoroots*TransposedMat(W.simpleRoots)=CartanMat(W)`

.
We get that in **CHEVIE** by a new form of the function `CoxeterGroup`

, where
the arguments are the two matrices `W.simpleRoots`

and `W.simpleCoroots`

described above. The roots need not generate *V*, so the matrices need not
be square. For instance, the root datum of the linear group of rank 3 can
be specified as:

gap> W := CoxeterGroup( [ [ -1, 1, 0], [ 0, -1, 1 ] ], > [ [ -1, 1, 0], [ 0, -1, 1 ] ] ); CoxeterGroup([[-1,1,0],[0,-1,1]],[[-1,1,0],[0,-1,1]]) gap> MatXPerm( W, W.1); [ [ 0, 1, 0 ], [ 1, 0, 0 ], [ 0, 0, 1 ] ]

here the symmetric group on 3 letters acts by permutation of the basis of
*X*. The dimension of *X* (the length of the vectors in `.simpleRoots`

) is
the **rank** and the dimension of the subspace generated by the roots (the
length of `.simpleroots`

) is called the **semi-simple rank**. In the example
the rank is 3 and the semisimple rank is 2.

The default form `W:=CoxeterGroup("A",2)`

defines the adjoint algebraic
group (the group with a trivial center). In that case *Φ* is a basis of
*X*, so `W.simpleRoots`

is the identity matrix and `W.simpleCoroots`

is the Cartan matrix `CartanMat(W)`

of the root system. The form
`CoxeterGroup("A",2,"sc")`

constructs the semisimple simply connected
algebraic group, where `W.simpleRoots`

is the transposed of `CartanMat(W)`

and `W.simpleCoroots`

is the identity matrix.

There is an extreme form of root data which requires another function to
specify: when `W` is the trivial `CoxeterGroup()`

and there are thus no
roots (in this case * G* is a torus), the root datum cannot be determined
by the roots, but is entirely determined by the rank

`Torus(``r`)

constructs such a root datum.
Finally, there is also a function `RootDatum`

which understands some
familiar names for the algebraic groups and gives the results that could be
obtained by giving the appropriate matrices `W.simpleRoots`

and
`W.simpleCoroots`

:

gap> RootDatum("gl",3); # same as the previous example RootDatum("gl",3)

** Semisimple elements**

It is also possible to compute with semi-simple elements. The first type
are finite order elements of * T*, which over an algebraically closed
field

`Mod1`

whenever the
need arises, where `Mod1`

is the function which replaces the numerator of a
fraction with the numerator `mod`

the denominator; the fraction
`Mod1`

of rationals and raising to the power
Here is an example of computations with semisimple-elements given as list
of *r* elements of *ℚ/ℤ*.

gap> G:=RootDatum("sl",4); RootDatum("sl",4) gap> L:=ReflectionSubgroup(G,[1,3]); ReflectionSubgroup(RootDatum("sl",4), [ 1, 3 ]) gap> AlgebraicCentre(L); rec( Z0 := SubTorus(ReflectionSubgroup(RootDatum("sl",4), [ 1, 3 ]),[ [ 1, 2, \ 1 ] ]), AZ := Group( <0,0,1/2> ), ZD := Group( <1/2,0,0>, <0,0,1/2> ), descAZ := [ [ 1, 2 ] ] ) gap> SemisimpleSubgroup(last.Z0,3); Group( <1/3,2/3,1/3> ) gap> e:=Elements(last); [ <0,0,0>, <1/3,2/3,1/3>, <2/3,1/3,2/3> ]

First, the group * G=SL_{4}* is constructed, then the Levi subgroup

`AlgebraicCentre`

returns a record with : the neutral component `.descAZ`

, see AlgebraicCentre for an explanation.
Finally the semi-simple elements of order 3 in

gap> e[2]^G.2; <1/3,0,1/3> gap> Orbit(G,e[2]); [ <1/3,2/3,1/3>, <1/3,0,1/3>, <2/3,0,1/3>, <1/3,0,2/3>, <2/3,0,2/3>, <2/3,1/3,2/3> ]

Since over an algebraically closed field *K* the points of * T* are in
bijection with

`GF(4)`

:

gap> s:=SemisimpleElement(G,List([1,2,1],i->Z(4)^i)); <Z(2^2),Z(2^2)^2,Z(2^2)> gap> s^G.2; <Z(2^2),Z(2)^0,Z(2^2)> gap> Orbit(G,s); [ <Z(2^2),Z(2^2)^2,Z(2^2)>, <Z(2^2),Z(2)^0,Z(2^2)>, <Z(2^2)^2,Z(2)^0,Z(2^2)>, <Z(2^2),Z(2)^0,Z(2^2)^2>, <Z(2^2)^2,Z(2)^0,Z(2^2)^2>, <Z(2^2)^2,Z(2^2),Z(2^2)^2> ]

We can compute the centralizer *C _{G}(s)* of a semisimple element in

gap> G:=CoxeterGroup("A",3); CoxeterGroup("A",3) gap> s:=SemisimpleElement(G,[0,1/2,0]); <0,1/2,0> gap> Centralizer(G,s); (A1xA1)<1,3>.(q+1)

The result is an extended reflection group; the reflection group part is
the Weyl group of *C _{G}^{0}(s)* and the extended part are representatives of

- CoxeterGroup (extended form)
- RootDatum
- Dual for root Data
- Torus
- FundamentalGroup for algebraic groups
- IntermediateGroup
- WeightInfo
- SemisimpleElement
- Operations for semisimple elements
- Centralizer for semisimple elements
- SubTorus
- Operations for Subtori
- AlgebraicCentre
- SemisimpleSubgroup
- IsIsolated
- IsQuasiIsolated
- QuasiIsolatedRepresentatives
- SemisimpleCentralizerRepresentatives

`CoxeterGroup( `

`simpleRoots`, `simpleCoroots` )

`CoxeterGroup( `

`C`[, "sc"] )

`CoxeterGroup( `

`type1`, `n1`, ... , `typek`, `nk`[, "sc"] )

The above are extended forms of the function `CoxeterGroup`

allowing to
specify more general root data. In the first form a set of roots is given
explicitly as the lines of the matrix `simpleRoots`, representing vectors
in a vector space `V`, as well as a set of coroots as the lines of the
matrix `simpleCoroots` expressed in the dual basis of *V ^{∨}*. The product

`C`=`simpleCoroots`*TransposedMat(`simpleRoots`)

must be a valid Cartan
matrix. The dimension of `Length(``C`)

. The length
of
In the second form `C` is a Cartan matrix, and the call `CoxeterGroup(`

is equivalent to `C`)`CoxeterGroup(IdentityMat(Length(`

. When the
optional `C`)),`C`)`"sc"`

argument is given the situation is reversed: the simple
coroots are given by the identity matrix, and the simple roots by the
transposed of `C` (this corresponds to the embedding of the root system in
the lattice of characters of a maximal torus in a **simply connected**
algebraic group).

The argument `"sc"`

can also be given in the third form with the same
effect.

The following fields in a Coxeter group record complete the description of
the corresponding **root datum**:

`simpleRoots`

:

the matrix of simple roots

`simpleCoroots`

:

the matrix of simple coroots

`matgens`

:

the matrices (in row convention --- that is, the matrices operate**from the right**) of the simple reflections of the Coxeter group.

`RootDatum(`

`type`,`n`)

This function returns the root datum for the algebraic group described by
`type` and `n`. The types understood as of now are: `"gl"`

, `"sl"`

,
`"pgl"`

, `"slmod"`

, `"tgl"`

`"sp"`

, `"so"`

, `"psp"`

, `"csp"`

,
`"pso"`

, `"halfspin"`

, `"spin"`

, `"gpin"`

, `"E6"`

, `"E6sc "`

,
`"E7"`

, `"E8"`

, `"F4"`

, `"G2"`

. Most of these names should be
familar; let us explain those which may not be:

`gpin(2n)`

:

is a group of type*D*simply connected and with a connected center (of dimension 2)._{n}

`slmod(n,q)`

:

is the quotient of*Sl*by the subgroup of the center isomorphic to_{n}*ℤ/qℤ*(*q*must divide*n*).

`tgl(n,k)`

:

is the ``twisted'' version of*Gl*described in tay19, Example 5.17_{n}

gap> RootDatum("spin",8);# same as CoxeterGroup("D",4,"sc") RootDatum("spin",8)

`Dual(`

`W`)

This function returns the dual root datum of the root datum `W`, describing
the Langlands dual algebraic group. The fields `.simpleRoots`

and
`.simpleCoroots`

are swapped in the dual compared to `W`.

gap> W:=CoxeterGroup("B",3); CoxeterGroup("B",3) gap> Dual(W); CoxeterGroup("C",3,sc)

`Torus(`

`rank`)

This function returns the **CHEVIE** object corresponding to the notion of a
torus of dimension `rank`, a Coxeter group of semisimple rank 0 and given
`rank`. This corresponds to a split torus; the extension to Coxeter cosets
is more useful (see Torus for Coxeter cosets).

gap> Torus(3); Torus(3) gap> ReflectionName(last); "(q-1)^3"

`FundamentalGroup(`

`W`)

This function returns the fundamental group of the algebraic group defined
by the Coxeter group record `W`. This group is returned as a group of
diagram automorphisms of the corresponding affine Weyl group, that is as a
group of permutations of the set of simple roots enriched by the lowest
root of each irreducible component. The definition we take of the
fundamental group of a (not necessarily semisimple) reductive group is
*(P∩ Y( T))/Q* where

gap> W:=CoxeterGroup("A",3); CoxeterGroup("A",3) gap> FundamentalGroup(W); Group( ( 1,12, 3, 2) ) gap> W:=CoxeterGroup("A",3,"sc"); CoxeterGroup("A",3,"sc") gap> FundamentalGroup(W); Group( () )

`IntermediateGroup(`

`W`, `indices`)

This computes a Weyl group record representing a semisimple algebraic group
intermediate between the adjoint group --- obtained by a call like
`CoxeterGroup("A",3)`

--- and the simply connected semi-simple group ---
obtained by a call like `CoxeterGroup("A",3,"sc")`

. The group is
specified by specifying a subset of the **minuscule weights**, which are
weights whose scalar product with every coroot is in *-1,0,1* (the weights
are the elements of the **weight lattice**, the lattice in *X( T)⊗ℚ*
dual to the coroot lattice). The non-trivial characters of the (algebraic)
center of a semi-simple simply connected algebraic group are in bijection
with the minuscule weights; this set is also in bijection with

gap> W:=CoxeterGroup("A",3);; gap> IntermediateGroup(W,[]); # adjoint CoxeterGroup("A",3) gap> FundamentalGroup(last); Group( ( 1,12, 3, 2) ) gap> IntermediateGroup(W,[2]);# intermediate CoxeterGroup([[2,0,-1],[0,1,0],[0,0,1]],[[1,-1,0],[-1,2,-1],[1,-1,2]]) gap> FundamentalGroup(last); Group( ( 1, 3)( 2,12) )

`WeightInfo(`

`W`)

*W* is a Coxeter group record describing an algebraic group * G*, or an
irreducible type. The function is independent of the isogeny type of

`ReflectionType(W)`

, that is on the root system). It
returns a record with the following fields:

`.minusculeWeights`

:- the minuscule weights, described as their position in the list of fundamental weights. For non-irreducible groups, a weight is the sum of at most one weight in each irreducible component. It is represented as the list of its components. For consistency, in the case of an irreducible system, a weight is represented as a one-element list.

`.minusculeCoweights`

:- the minuscule coweights, represented in the same manner as the minuscule weights

`.decompositions`

:- for each coweight, its decomposition in terms of the generators of the adjoint fundamental group (given by the list of the exponents of the generators). Together with the next field it enables to work out the group structure of the adjoint fundamental group.

`.moduli`

:- the list of orders of the generators of the fundamental group.

`.AdjointFundamentalGroup`

:- the list of generators of the adjoint fundamental group, given as permutations.

`.CenterSimplyConnected`

:- A list of semisimple elements generating the center
of the universal covering of
.**G**

gap> WeightInfo(CoxeterGroup("A",2,"B",2)); rec( minusculeWeights := [ [ 1, 3 ], [ 1 ], [ 2, 3 ], [ 2 ], [ 3 ] ], minusculeCoweights := [ [ 1, 4 ], [ 1 ], [ 2, 4 ], [ 2 ], [ 4 ] ], decompositions := [ [ 1, 1 ], [ 1, 0 ], [ 2, 1 ], [ 2, 0 ], [ 0, 1 ] ], moduli := [ 3, 2 ], CenterSimplyConnected := [ [ 2/3, 1/3, 0, 0 ], [ 0, 0, 1/2, 0 ] ], AdjointFundamentalGroup := [ ( 1, 2,12), ( 4,14) ] )

`SemisimpleElement(`

`W`,`v`[,`additive`])

`W` should be a root datum, given as a Coxeter group record for a Weyl
group, and `v` a list of length `W.rank`

. The result is a semisimple
element record, which has the fields:

`.v`

:- the given list, taken
`Mod1`

if its elements are rationals.

`.group`

:- the parent of the group
`W`.

gap> G:=CoxeterGroup("A",3);; gap> s:=SemisimpleElement(G,[0,1/2,0]); <0,1/2,0>

If all elements of *v* are rational numbers, they are converted by `Mod1`

to fractions between *0* and *1* representing roots of unity, and these
roots of unity are multiplied by adding `Mod1`

the fractions. In this way
any semisimple element of finite order can be represented.

If the entries are not rational numbers, they are assumed to represent
elements of a field which are multiplied or added normally. To explicitly
control if the entries are to be treated additively or not, a third
argument can be given: if `true`

the entries are treated additively, or
not if `false`

. For entries to be treated additively, they must belong to a
domain for which the method `Mod1`

had been defined.

The arithmetic operations `*`

, `/`

and `^`

work for semisimple elements.
They also have `Print`

and `String`

methods. We first give an element with
elements of *ℚ/ℤ* representing roots of unity.

gap> G:=CoxeterGroup("A",3); CoxeterGroup("A",3) gap> s:=SemisimpleElement(G,[0,1/2,0]); <0,1/2,0> gap> t:=SemisimpleElement(G,[1/2,1/3,1/7]); <1/2,1/3,1/7> gap> s*t; <1/2,5/6,1/7> gap> t^3; <1/2,0,3/7> gap> t^-1; <1/2,2/3,6/7> gap> t^0; <0,0,0> gap> String(t); "<1/2,1/3,1/7>"

- then a similar example with elements of
`GF(5)`

:

gap> s:=SemisimpleElement(G,Z(5)*[1,2,1]); <Z(5),Z(5)^2,Z(5)> gap> t:=SemisimpleElement(G,Z(5)*[2,3,4]); <Z(5)^2,Z(5)^0,Z(5)^3> gap> s*t; <Z(5)^3,Z(5)^2,Z(5)^0> gap> t^3; <Z(5)^2,Z(5)^0,Z(5)> gap> t^-1; <Z(5)^2,Z(5)^0,Z(5)> gap> t^0; <Z(5)^0,Z(5)^0,Z(5)^0> gap> String(t); "<Z(5)^2,Z(5)^0,Z(5)^3>"

The operation `^`

also works for applying an element of its defining Weyl
group to a semisimple element, which allows orbit computations:

gap> s:=SemisimpleElement(G,[0,1/2,0]); <0,1/2,0> gap> s^G.2; <1/2,1/2,1/2> gap> Orbit(G,s); [ <0,1/2,0>, <1/2,1/2,1/2>, <1/2,0,1/2> ]

The operation `^`

also works for applying a root to a semisimple element:

gap> s:=SemisimpleElement(G,[0,1/2,0]); <0,1/2,0> gap> s^G.roots[4]; 1/2 gap> s:=SemisimpleElement(G,Z(5)*[1,1,1]); <Z(5),Z(5),Z(5)> gap> s^G.roots[4]; Z(5)^2

`Frobenius(`

:`WF`)

If`WF`

is a Coxeter coset associated to the Coxeter group`W`, the function`Frobenius`

returns the associated automorphism which can be applied to semisimple elements, see Frobenius.

gap> W:=CoxeterGroup("D",4);;WF:=CoxeterCoset(W,(1,2,4));; gap> s:=SemisimpleElement(W,[1/2,0,0,0]); <1/2,0,0,0> gap> F:=Frobenius(WF); function ( arg ) ... end gap> F(s); <0,0,0,1/2> gap> F(s,-1); <0,1/2,0,0>

`Centralizer( `

`W`, `s`)

`W` should be a Weyl group record or and extended reflection group and `s`
a semisimple element for `W`. This function returns the stabilizer of the
semisimple element `s` in `W`, which describes also *C _{G}(s)*, if

gap> G:=CoxeterGroup("A",3); CoxeterGroup("A",3) gap> s:=SemisimpleElement(G,[0,1/2,0]); <0,1/2,0> gap> Centralizer(G,s); (A1xA1)<1,3>.(q+1)

`SubTorus(`

`W`,`Y`)

The function returns the subtorus * S* of the maximal torus

`S.generators`

of the returned subtorus object. Here, adapted means
that there is a set of integral vectors, stored in `S.complement`

, such
that `M:=Concatenation(S.generators,S.complement)`

is a basis of

gap> W:=CoxeterGroup("A",4);; gap> SubTorus(W,[[1,2,3,4],[2,3,4,1],[3,4,1,2]]); Error, not a pure sublattice in SubTorus( W, [ [ 1, 2, 3, 4 ], [ 2, 3, 4, 1 ], [ 3, 4, 1, 2 ] ] ) called from main loop brk> gap> SubTorus(W,[[1,2,3,4],[2,3,4,1],[3,4,1,1]]); SubTorus(CoxeterGroup("A",4),[ [ 1, 0, 3, -13 ], [ 0, 1, 2, 7 ], [ 0, 0, 4, -3 ] ])

The operation `in`

can test if a semisimple element belongs to a subtorus:

gap> W:=RootDatum("gl",4);; gap> r:=AlgebraicCentre(W); rec( Z0 := SubTorus(RootDatum("gl",4),[ [ 1, 1, 1, 1 ] ]), AZ := Group( <0,0,0,0> ), ZD := Group( <3/4,3/4,3/4,3/4> ), descAZ := [ [ 1 ] ] ) gap> SemisimpleElement(W,[1/4,1/4,1/4,1/4]) in r.Z0; true

The operation `Rank`

gives the rank of the subtorus:

gap> Rank(r.Z0); 1

`AlgebraicCentre( `

`W` )

`W` should be a Weyl group record, or an extended Weyl group record. This
function returns a description of the centre *Z G* of the algebraic group

`Z0`

:- the neutral component
*Z*of^{0}*Z*as a subtorus of**G**.**T**

`AZ`

:- representatives in
*Z*of**G***A(Z):=Z*given as a group of semisimple elements.**G**/(Z**G**)^{0}

`ZD`

:- center of the derived subgroup of
given as a group of semisimple elements.**G**

`descAZ`

:- if
`W`is not an extended Weyl group, describes*A(Z)*as a quotient of the center`pi`

of the simply connected covering of. It contains a list of elements given as words in the generators of**G**`pi`

which generate the kernel of the quotient map.

gap> G:=CoxeterGroup("A",3,"sc");; gap> L:=ReflectionSubgroup(G,[1,3]); ReflectionSubgroup(CoxeterGroup("A",3,"sc"), [ 1, 3 ]) gap> AlgebraicCentre(L); rec( Z0 := SubTorus(ReflectionSubgroup(CoxeterGroup("A",3,"sc"), [ 1, 3 ]),[ [\ 1, 2, 1 ] ]), AZ := Group( <0,0,1/2> ), ZD := Group( <1/2,0,0>, <0,0,1/2> ), descAZ := [ [ 1, 2 ] ] ) gap> G:=CoxeterGroup("A",3);; gap> s:=SemisimpleElement(G,[0,1/2,0]);; gap> Centralizer(G,s); (A1xA1)<1,3>.(q+1) gap> AlgebraicCentre(last); rec( Z0 := SubTorus(ReflectionSubgroup(CoxeterGroup("A",3), [ 1, 3 ]),), AZ := Group( <0,1/2,0> ) )

Note that in versions of **CHEVIE** prior to april 2017, the field `Z0`

was
not a subtorus but what is now `Z0.generators`

, and there was a field
`complement`

which is now `Z0.complement`

.

`SemisimpleSubgroup( `

`S`, `n` )

This function returns the subgroup of semi-simple elements of order
dividing `n` in the subtorus *S*.

gap> G:=CoxeterGroup("A",3,"sc");; gap> L:=ReflectionSubgroup(G,[1,3]);; gap> z:=AlgebraicCentre(L);; gap> z.Z0; SubTorus(ReflectionSubgroup(CoxeterGroup("A",3,"sc"), [ 1, 3 ]),[ [ 1,\ 2, 1 ] ]) gap> SemisimpleSubgroup(z.Z0,3); Group( <1/3,2/3,1/3> ) gap> Elements(last); [ <0,0,0>, <1/3,2/3,1/3>, <2/3,1/3,2/3> ]

`IsIsolated(`

`W`,`s`)

`s` should be a semi-simple element for the algebraic group * G* specified
by the Weyl group record

gap> W:=CoxeterGroup("E",6);; gap> QuasiIsolatedRepresentatives(W); [ <0,0,0,0,0,0>, <0,0,0,1/3,0,0>, <0,1/6,1/6,0,1/6,0>, <0,1/2,0,0,0,0>, <1/3,0,0,0,0,1/3> ] gap> Filtered(last,x->IsIsolated(W,x)); [ <0,0,0,0,0,0>, <0,0,0,1/3,0,0>, <0,1/2,0,0,0,0> ]

`IsQuasiIsolated(`

`W`,`s`)

`s` should be a semi-simple element for the algebraic group * G* specified
by the Weyl group record

gap> W:=CoxeterGroup("E",6);; gap> QuasiIsolatedRepresentatives(W); [ <0,0,0,0,0,0>, <0,0,0,1/3,0,0>, <0,1/6,1/6,0,1/6,0>, <0,1/2,0,0,0,0>, <1/3,0,0,0,0,1/3> ] gap> Filtered(last,x->IsQuasiIsolated(ReflectionSubgroup(W,[1,3,5,6]),x)); [ <0,0,0,0,0,0>, <0,0,0,1/3,0,0>, <0,1/2,0,0,0,0> ]

`QuasiIsolatedRepresentatives(`

`W`[,`p`])

`W` should be a Weyl group record corresponding to an algebraic group
* G*. This function returns a list of semisimple elements for

gap> W:=CoxeterGroup("E",6);;QuasiIsolatedRepresentatives(W); [ <0,0,0,0,0,0>, <0,0,0,1/3,0,0>, <0,1/6,1/6,0,1/6,0>, <0,1/2,0,0,0,0>, <1/3,0,0,0,0,1/3> ] gap> List(last,x->IsIsolated(W,x)); [ true, true, false, true, false ] gap> W:=CoxeterGroup("E",6,"sc");;QuasiIsolatedRepresentatives(W); [ <0,0,0,0,0,0>, <1/3,0,2/3,0,1/3,2/3>, <1/2,0,0,1/2,0,1/2>, <2/3,0,1/3,0,1/3,2/3>, <2/3,0,1/3,0,2/3,1/3>, <2/3,0,1/3,0,2/3,5/6>, <5/6,0,2/3,0,1/3,2/3> ] gap> List(last,x->IsIsolated(W,x)); [ true, true, true, true, true, true, true ] gap> QuasiIsolatedRepresentatives(W,3); [ <0,0,0,0,0,0>, <1/2,0,0,1/2,0,1/2> ]

`SemisimpleCentralizerRepresentatives(`

`W` [,`p`])

`W` should be a Weyl group record corresponding to an algebraic group
* G*. This function returns a list giving representatives

`ReflectionSubgroup(W,h)`

. If a second argument

gap> W:=CoxeterGroup("G",2); CoxeterGroup("G",2) gap> l:=SemisimpleCentralizerRepresentatives(W); [ [ ], [ 1 ], [ 1, 2 ], [ 1, 5 ], [ 2 ], [ 2, 6 ] ] gap> List(last,h->ReflectionName(ReflectionSubgroup(W,h))); [ "(q-1)^2", "A1.(q-1)", "G2", "A2<1,5>", "~A1<2>.(q-1)", "~A1<2>xA1<6>" ] gap> SemisimpleCentralizerRepresentatives(W,2); [ [ ], [ 1 ], [ 1, 2 ], [ 1, 5 ], [ 2 ] ]

gap3-jm

24 Apr 2021