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 a
subfield. A **complex reflection** is an element *s∈ GL(V)* of finite order
whose fixed point set is an hyperplane (we will in the following just call
it a **reflection** to abbreviate; in some literature the term reflection is
only employed when the order is 2 and the more general case is called a
**pseudo-reflection**). Thus a reflection has a unique eigenvalue not equal
to *1*. If *K* is a subfield of the real numbers, we get a real reflection
which is necessarily of order 2 and the non-trivial eigenvalue is equal to
*-1*.

A reflection group `W` is a group generated by a finite number of complex
reflections.

Since when `W` contains a reflection *s* it contains its powers, `W` 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 reflection groups in **CHEVIE** are
always distinguished reflections. In a real reflection group all
reflections are distinguished.

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

A (complex) reflection `s` acting on the vector space `V` (over some
subfield of the complex numbers), is a linear map of finite order whose
fixed points are an hyperplane `H` (called the **reflecting hyperplane** of
`s`); an eigenvector `r` for the non-trivial eigenvalue *ζ* (a root of
unity) is called a **root** of `s`. We may chose a linear form *r ^{∨}*
(called a

A first way of specifying a reflection is by giving a root and a coroot,
which 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`

gives the matrix of the corresponding reflection in the
standard basis of `V`, 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 |

so *s* is specified by just `root` and `eigenvalue`. When `eigenvalue` is
omitted it is assumed to be equal to -1. The function `Reflection`

gives
again the matrix of the reflection.

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). Note that
one would not get the same result with `W.reflections[i]`

since this entry
might not yet be bound (not yet have been computed), and also it is not
guaranteed apart from the generating roots (and the positive roots of Weyl
groups) that the *i*-th reflection corresponds to the *i*-th root, since
two roots corresponding to the same reflection may have been obtained
before all the reflections have been obtained.

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 root and coroot, which otherwise are
determined only up to a scalar and its inverse). 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 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 reflections of `W` are 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` where `W` effectively
acts, which is the subspace 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. `W` is called **essential** if `V'=V`.

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

gap3-jm

11 Mar 2019