Central in **CHEVIE** is the notion of **reflection groups**.

Let *V* be a vector space over a subfield *K* of the complex numbers; in
**GAP3** this usually means the `Rationals`

, the `Cyclotomics`

, or one of its
subfields. A **complex reflection** (that we will in the following just call
a **reflection** to abbreviate) is an element *s∈ GL(V)* whose fixed point
set is an hyperplane and which is of finite order --- here we abuse the
term reflection which is usually only employed when the order is 2. Thus a
reflection has a unique eigenvalue not equal to *1*. If *K* is the field of
real numbers, then a complex reflection is necessarily of order 2 and the
non-trivial eigenvalue equal to *-1*. A reflection group is a group
generated by a finite number of complex reflections.

Since a group containing *s* contains its powers, a group generated by
reflections is always generated by reflections *s* with eigenvalue `E(d)`

where *d* is the order of *s*; we may in addition assume that *s* is not a
power of another reflection with eigenvalue `E(d')`

with `d'>d`

. Such a
reflection is called **distinguished**; we take it as the canonical generator
of the cyclic subgroup it generates. The generators of the reflection
groups in **CHEVIE** are always distinguished reflections.

Reflection groups in **CHEVIE** are groups `W` with the following fields (in
the group record) defined

`.nbGeneratingReflections`

:

the number of reflections which generate`W`

`.reflections`

:

a list of distinguished reflections, given as elements of`W`, such that a list of reflections which generate`W`is`W.reflections{[1..W.nbGeneratingReflections]}`

.

`.OrdersGeneratingReflections`

:

a list (of length at least`W.nbGeneratingReflections`

) such that its*i*-th element is the order of`W.reflections[i]`

. By the above conventions`W.reflections[i]`

thus has`E(W.OrdersGeneratingReflections[i])`

as its nontrivial eigenvalue.

Note that `W` does **not** need to be a matrix group. The meaning of the
above fields is just that `W` has a representation (called the
**reflection representation** of `W`) where the elements `W.reflections`

operate as reflections. It is much more efficient to compute with
permutation groups which have such fields defined, than with matrix
groups, when possible. Information sufficient to determine a particular
reflection representation is stored for such groups (see `CartanMat`

).

Also note that, although `.reflections`

is usually just initialized to the
generating reflections, it is usually augmented by adding other reflections
to it as computations require. For instance, when *W* is finite, the set of
all reflections in *W* is finite (they are just the elements of the
conjugacy classes of the generating reflections and their powers), and all
the distinguished reflections in *W* are added to `.reflections`

when
required, for instance when calling `Reflections(`

which returns the
list of all (distinguished) reflections. Note that when `W`)*W* is finite, the
distinguished reflections are in bijection with the reflecting hyperplanes.

There are very few functions in **CHEVIE** which deal with reflections
groups in full generality. Usually the groups one wants to deal with is
in a more restricted class (Coxeter groups, finite reflection groups)
which are described in the following chapters.

`Reflection( `

`root`, `coroot`)

If `s` is a (complex) reflection acting on the vector space `V`, with fixed
hyperplane `H` (called the **reflecting hyperplane** of `s`) and with
eigenvector `r` (called a **root** of `s`) for its non-trivial value *ζ*,
then as a linear map `s` is given by * x→ x-r ^{∨}(x)r*, where

Thus a first way of specifying a reflection is by giving a root and a
coroot. The root and coroot are uniquely determined by the reflection up to
multiplication of the root by a scalar and of the coroot by the inverse
scalar. The function `Reflection`

in this form gives the matrix of the
corresponding reflection, where the `root` and the `coroot` are vectors
given in the standard bases of `V` and *V ^{∨}* (thus in

`root`*`coroot`

).

gap> r:=Reflection([1,0,0],[2,-1,0]); [ [ -1, 0, 0 ], [ 1, 1, 0 ], [ 0, 0, 1 ] ] gap> r=CoxeterGroup("A",3).matgens[1]; true gap> [1,0,0]*r; [ -1, 0, 0 ]

As we see in the last line, in **GAP3** the matrices operate **from the right**
on the vector space.

`Reflection( `

`root` [, `eigenvalue`] )

We may give slightly less information if we assume that the
standard hermitian scalar product *(x,y)* on *V* (given in **GAP3** by
`x*ComplexConjugate(y)`

) is *s*-invariant. Then, identifying *V* and
*V ^{∨}* via this scalar product,

x→ x-(1-ζ)(x,r)/(r,r)r |

where *ζ* is the non-trivial eigenvalue of *s*, so *s* is specified
by just `root` and `eigenvalue`. When `eigenvalue` is omitted it is
assumed to be equal to -1. The function `Reflection`

in this form gives
the matrix of the reflection given such data.

gap> Reflection([0,0,1],E(3)); [ [ 1, 0, 0 ], [ 0, 1, 0 ], [ 0, 0, E(3) ] ] gap> last=ComplexReflectionGroup(25).matgens[1]; true

`Reflection( `

`W`, `i` )

This form returns the reflection with respect to the `i`-th root in the
finite reflection group `W` (this works only for groups represented as
permutation groups of the roots, see Finite Reflection Groups). The point
of using this function rather than `W.reflections[i]`

is that this entry
might not yet be bound (not yet have been computed). The above function
then computes it and returns it.

gap> Reflection(CoxeterGroup("A",3),6); ( 1,11)( 3,10)( 4, 9)( 5, 7)( 6,12)

`AsReflection( `

`s` [,`r`])

Here `s` is a square matrix with entries cyclotomic numbers, and if given
`r` is a vector of the same length as `s` of cyclotomic numbers. The
function determines if `s` is the matrix of a reflection (resp. if `r` is
given if it is the matrix of a reflection of root `r`; the point of giving
`r` is to specify exactly the desired coroot, which otherwise is determined
only up to a scalar). The returned result is `false`

if `s` is not a
reflection (resp. not a reflection with root `r`), and otherwise is a
record with four fields :

`.root`

:-

the root of the reflection`s`(equal to`r`if given)

`.coroot`

:-

the coroot of`s`

`.eigenvalue`

:-

the non-trivial eigenvalue of`s`

`.isOrthogonal`

:-

a boolean which is`true`

if and only if`s`is orthogonal with respect to the usual scalar product (then the root and eigenvalue are sufficient to determine`s`)

gap> AsReflection([[-1,0,0],[1,1,0],[0,0,1]]); rec( root := [ 2, 0, 0 ], coroot := [ 1, -1/2, 0 ], eigenvalue := -1, isOrthogonal := false ) gap> AsReflection([[-1,0,0],[1,1,0],[0,0,1]],[1,0,0]); rec( root := [ 1, 0, 0 ], coroot := [ 2, -1, 0 ], eigenvalue := -1, isOrthogonal := false )

`CartanMat( `

`W` )

Let *s _{1},...,s_{n}* be a list of reflections with associated root vectors

If *s _{1},...,s_{n}* are the generators of a reflection group

`C`

up to conjugation by diagonal matrices is an invariant invariant
of the reflection representation of `C`

is invertible), since in the `C`

has been subtracted.

gap> W:=CoxeterGroup("A",3);; gap> CartanMat(W); [ [ 2, -1, 0 ], [ -1, 2, -1 ], [ 0, -1, 2 ] ]

`CartanMat( `

`W`, `l` )

Returns the Cartan matrix of the roots of `W` specified by the list of
integers `l` (for a finite reflection group represented as a group of
permutation of root vectors, these integers are indices in the list of
roots of the parent reflection group).

`CartanMat( `

`type` )

This form returns the Cartan matrix of some standard reflection representations for Coxeter groups, taking a symbolic description of the Coxeter group given by the arguments. See CartanMat for Dynkin types

`Rank( `

`W` )

Let `W` be a reflection group in the vector space `V`. This function
returns the dimension of `V`, if known. If a reflection is generated by a
root and a coroot, it is the length of the root as a list. If `W` is a
matrix group it is the dimension of the matrices.

gap> W:=ReflectionSubgroup(CoxeterGroup("A",3),[1,3]); ReflectionSubgroup(CoxeterGroup("A",3), [ 1, 3 ]) gap> Rank(W); 3

`SemisimpleRank( `

`W` )

Let `W` be a reflection group in the vector space `V`. This function
returns the dimension of the subspace `V'` of `V` generated by the roots
of the reflections of `W`. The space `V'` is `W`-stable and has a
`W`-stable complement on which `W` acts trivially. The `SemisimpleRank`

is
independent of the reflection representation.

gap> W:=ReflectionSubgroup(CoxeterGroup("A",3),[1,3]); ReflectionSubgroup(CoxeterGroup("A",3), [ 1, 3 ]) gap> SemisimpleRank(W); 2

gap3-jm

08 Sep 2017