\catcode``=\active
\def`#1'{{\tt #1}}
\def\>#1{\noindent{\tt #1}\hfill\break\hang\ignorespaces}
\parindent 0pt
\parskip 1ex plus 0.5ex minus 0.5ex

\centerline{\bf  PRIMITIVE SIMPLE PERMUTATION  GROUPS  OF ORDER  LESS THAN  A
MILLION}

\beginsection What the file contains

When you read the  file `coco.grp' into GAP,  a function will be defined that
allows you to  construct   the primitive permutation  representations  of the
simple groups  of  order  less  than~$10^6$, except  for  the two-dimensional
linear  groups. The groups come together  with  the computer package COCO for
calculations with COherent  COnfigurations. COCO was written by A.~A.~Ivanov,
I.~Farad\v{z}ev and  M.~Klin and ported to  UNIX machines  by A.~Brouwer. The
information  about primitive groups was   translated into GAP-format by Heiko
Thei{\ss}en (email: Heiko.Theissen@math.rwth-aachen.de).

\beginsection What the file does not contain

The file `coco.grp'  contains none of the functions  that COCO can perform on
permutation groups  or coherent configurations.  It only contains the list of
primitive permutation groups that accompanies COCO as a data/example library.

\beginsection How the groups are constructed

The     COCO package contains  for  each   group  $G$  in question generating
permutations for  the primitive representation  of smallest  degree. (It also
contains some not necessarily primitive representations of larger groups.) If
$\Omega$  denotes    this original  operation    domain, then   new primitive
representations of larger degrees are  obtained by letting  the group (in its
original representation) act  on  certain  objects  associated with~$\Omega$,
such as subsets, unordered partitions or graphs with vertex set~$\Omega$. The
idea behind this is that  if a point stabilizer  $H$ of the new action (which
is a maximal subgroup of $G$) leaves invariant any object not invariant under
$G$, then $H$ must be the stabilizer of this object, and so the new primitive
operation of $G$ (which is equivalent to the  operation on the cosets of $H$)
is  the operation on  the $G$-orbit  of this  object. For example,  if $H$ is
intransitive any of  its  orbits will  suffice, if  $H$  is imprimitive,  any
invariant unordered partition (i.e., a block system) will do.

The objects on which $G$ operates are of the following type:

{\parindent 2em
\>{[$s_1$,...,$s_n$]}  denotes a set  of objects  with setwise operation. All
$s_i$  must have the  same  arbitrary type. This   type is one  of  the types
mentioned here, but it can also be the  integers (in which case the operation
is the GAP function `OnSets').

\>{rec( s:=$set$,  d:=$deg$  )} denotes    a set  of   objects with   setwise
operation, but the  operation is performed in  two steps: first  the orbit of
the first element `$set$[ 1 ]' is calculated, it must have length $deg$. Then
the  elements of $set$  are replaced by their  positions in this orbit (using
`G.operation.numberElement', see  below) and the  final operation  on sets is
performed on sets  of these numbers. (Of  course this does  not make sense if
the elements in $set$ are integers.)

\>{rec( t:=[$s_1$,...,$s_n$] )} denotes a list  of objects $s_i$ which can be
of varying types. The operation is done on ordered $n$-tuples.

\>{rec(  c:=($p_1$,...,$p_n$),  p:=[$i_1$,...,$i_m$] )}  denotes a  one-cycle
permutation     $\pi=(p_1,\ldots,p_n)$      together   with     a    subgroup
$\{i_1,\ldots,i_m\}$ of the prime  residue class group modulo~$n$. The object
under consideration is then  the set $\{\pi^{i_1},\ldots,\pi^{i_m}\}$ and the
action is done setwise, then by conjugation.\par}

\beginsection How to instruct GAP to create such a group

Before  you can use the  new function, you have  to  load the file `coco.grp'
into  GAP, either  by  putting it  into  your current  directory  and  saying
`Read("coco.grp")' or by putting it into the `grp' subdirectory of GAP (e.g.,
as `\~/gap/grp/coco.grp' if `\~/gap' is the directory where you keep GAP) and
saying `ReadGrp("coco")'.

Then to construct  one of the primitive representations  in GAP, you have  to
use the command `CocoGroup( $name$, $deg$ )' where $name$  is the name of the
group and $deg$  is the degree  of the primitive operation, possibly extended
by a letter if there  are several inequivalent  operations of the same degree
(i.e.,  several  non-conjugate maximal  subgroups of   the same  index). Both
$name$ and $deg$ are strings, but if $deg$ does not contain a letter, you can
also type it  as a  number.  For example,  to  obtain the  second of the  two
primitive representations of     degree~136 of~$PSp(4,4)$ you    have to  say
`CocoGroup( "sp44", "136b" )'. If you do  not know what degrees are available
for a certain group, type `CocoGroup( $name$, "?" )'. If you do not know what
groups are available, type `CocoGroup( "?", "?" )'.

If the resulting group `G' is  not in its  original action, it will contain a
record  component  `G.operation' which  gives information  about  how the new
operation was constructed.

{\parindent 2em
\>{G.operation.structure} holds the group in its original action.

\>{G.operation.domain}  holds the domain for the  new operation as a list, so
`G.operation.domain[ $p$ ]' is the object numbered $p$ in the new action.

\>{G.operation.numberElement} holds a GAP function which performs the inverse
mapping: `G.operation.numberElement( $obj$  )'  will  return the  number  $p$
which is associated to the object $obj$, i.e., such that `G.operation.domain[
$p$ ] = $obj$'.

\>{G.operation.operation} holds a GAP function  that  performs the action  on
the elements of   `G.operation.domain', you can say   `G.operation.operation(
$obj$,  $g$    )'   to    find     the  image   of   $obj$   under      $g\in
`G.operation.structure'$.

\>{G.operation.genimages} holds the list `G.generators' again.\par}

\bye
 
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
% Local Variables:
% mode:        text
% fill-column: 77
% End:
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
