%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%%
%W  otheroptions.tex    ACE appendix - other options     Alexander Hulpke
%W                                                      Joachim Neub"user
%W                                                            Greg Gamble
%%
%H  $Id: otheroptions.tex,v 1.18 2001/09/29 22:30:32 gap Exp $
%%
%Y  Copyright (C) 2000  Centre for Discrete Mathematics and Computing
%Y                      Department of Computer Science & Electrical Eng.
%Y                      University of Queensland, Australia.
%%

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
\Chapter{Other ACE Options}

Here we list all the known {\ACE} options not provided  earlier.  Most
of the options provided here have  interactive  function  alternatives
(each such alternative is noted at the end of the  section  describing
the corresponding option  and  introduced  by  ``*INTERACTIVELY*,  use
\dots''). A few options have only limited usefulness from {\GAP}; many
options, users will normally only wish to use if generating  an  input
file,  by  using  the  option  `aceinfile'  (see~"option  aceinfile").
However all  options  here  are  functional,  both  interactively  and
non-interactively.

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
\Section{Experimentation Options}

\beginitems

\>`aep:=<val>'{option aep}@{option `aep'}&
Runs the enumeration for `a'll `e'quivalent `p'resentations;
<val> is in the integer range 1 to 7.

The `aep' option runs  an  enumeration  for  combinations  of  relator
ordering, relator rotations, and relator inversions.

The argument <val> is considered as a binary number.  Its  three  bits
are treated as flags, and control relator rotations (the  $2^0$  bit),
relator inversions (the $2^1$ bit) and relator  orderings  (the  $2^2$
bit),  respectively;  where  $1$  means  ``active''  and   $0$   means
``inactive''. (See below for an example).

The `aep' option first performs a ``priming run'' using the options as
they stand. In particular,  the  `asis'  and  `messages'  options  are
honoured.

It then turns `asis' on and `messages' off  (i.e.~sets  `messages'  to
0), and generates and tests the  requested  equivalent  presentations.
The maximum and minimum values attained by `m' (the maximum number  of
coset numbers defined at any stage) and `t' (the total number of coset
numbers defined) are tracked, and each time a new ``record'' is found,
the relators  used  and  the  summary  result  line  is  printed.  See
Appendix~"The Meanings of ACE's output messages" for a  discussion  of
the statistics `m' and `t'. To observe these messages either  set  the
`InfoLevel' of `InfoACE' to 3 or non-interactively you can peruse  the
{\ACE} output file (see~"option aceoutfile").

Normally when a non-interactive {\ACE} interface function  is  called,
the option `start' (see~"option start"), is quietly inserted after all
the options provided by the user, to  initiate  a  coset  enumeration.
Since the `aep' option invokes an enumeration, the quiet insertion  of
the `start' option is neither needed nor done, when a  non-interactive
{\ACE} interface function is called with the `aep' option.

The order in which the  equivalent  presentations  are  generated  and
tested has no particular significance, but note that the  presentation
as given *after* the initial priming run) is the  *last*  presentation
to be generated and tested, so that  the  group's  relators  are  left
`unchanged' by running the `aep' option, (not that  a  non-interactive
user cares).

As discussed by Cannon, Dimino, Havas  and  Watson  \cite{CDHW73}  and
Havas and Ramsay \cite{HR01} such equivalent presentations  can  yield
large variations in  the  number  of  coset  numbers  required  in  an
enumeration. For this command, we are interested in this variation.

After  the  final  presentation  is  run,   some   additional   status
information messages are printed to the {\ACE} output file:

\beginlist%unordered

\item{--}  the number of runs which yielded a finite index; 

\item{--}  the total number of runs (excluding the priming run); and 

\item{--}  the range of values observed for `m' and `t'.

\endlist

As an example (drawn from the discussion in \cite{HR99a}) consider the
enumeration   of   the   $448$   coset   numbers   of   the   subgroup
$\langle  a^2,a^{-1}b \rangle$ of the group
$$
(8,7 \mid 2,3) 
    = \langle a,b \mid a^8 = b^7 = (ab)^2 = (a^{-1}b)^3 = 1 \rangle.
$$
There are $4!=24$  relator  orderings  and  $2^4=16$  combinations  of
relator or inverted relator. Exponents are  taken  into  account  when
rotating relators, so the relators given give rise to 1, 1,  2  and  2
rotations respectively, for a total of $1.1.2.2=4$  combinations.  So,
for  `aep'  =  $7$   (resp.~$3$),   $24.16.4=1536$   (resp.~$16.4=64$)
equivalent presentations are tested.

*Notes:*
There is no way to stop the `aep'  option  before  it  has  completed,
other than killing the task. So do a reality check beforehand  on  the
size of the search space and the time for each enumeration. If you are
interested in finding a ``good'' enumeration, it can be very  helpful,
in terms of running time, to put a tight limit on the number of  coset
numbers via the `max' option. You may also have to set `compaction'  =
$100$  to  prevent  time-wasting  attempts  to   recover   space   via
compaction.  This  maximises  throughput  by   causing   the   ``bad''
enumerations, which are in  the  majority,  to  overflow  quickly  and
abort. If you wish to explore  a  very  large  search-space,  consider
firing up many copies of {\ACE}, and starting each with  a  ``random''
equivalent  presentation.  Alternatively,  you  could  use  the  `rep'
command.

*INTERACTIVELY*,            use             `ACEAllEquivPresentations'
(see~"ACEAllEquivPresentations").

\>`rep:=<val>'{option rep}@{option `rep'}
\>`rep:=[<val>, <Npresentations>]'{option rep}@{option `rep'}&
Run the enumeration for `r'andom `e'quivalent `p'resentations;
<val> is in the integer range 1 to 7;
<Npresentations> must be a positive integer.

The `rep' (random equivalent  presentations)  option  complements  the
`aep'  option.  It  generates  and  tests   some   random   equivalent
presentations. The argument <val>  acts  as  for  `aep'.  It  is  also
possible to set the number <Npresentations>  of  random  presentations
used (by default, eight  are  used),  by  using  the  extended  syntax
`rep:=[<val>,<Npresentations>]'.

The routine first  turns  `asis'  on  and  `messages'  off  (i.e.~sets
`messages' to 0), and then generates and tests the requested number of
random equivalent presentations. For each presentation,  the  relators
used and the  summary  result  line  are  printed.  To  observe  these
messages either set the `InfoLevel' of `InfoACE'  to  at  least  3  or
non-interactively you can peruse the {\ACE} output  file  (see~"option
aceoutfile").

Normally when a non-interactive {\ACE} interface function  is  called,
the option `start' (see~"option start"), is quietly inserted after all
the options provided by the user, to  initiate  a  coset  enumeration.
Since the `rep' option invokes an enumeration, the quiet insertion  of
the `start' option is neither needed nor done, when a  non-interactive
{\ACE} interface function is called with the `rep' option.

*Notes:*
The relator inversions and rotations  are  ``genuinely''  random.  The
relator permuting is a little bit of a kludge, with the ``quality'' of
the permutations tending to  improve  with  successive  presentations.
When the `rep' command  completes,  the  presentation  active  is  the
*last* one generated, (not that the non-interactive user cares).

*Guru Notes:*
It might appear that neglecting to restore the  original  presentation
is an error. In fact, it is a useful feature! Suppose that  the  space
of equivalent presentations is too  large  to  exhaustively  test.  As
noted in the entry for `aep', we can start up multiple copies of `aep'
at random points in the  search-space.  Manually  generating  `random'
equivalent presentations to serve as starting-points  is  tedious  and
error-prone. The `rep' option provides a simple solution;  simply  run
`rep := 7' before `aep := 7'.

*INTERACTIVELY*,           use           `ACERandomEquivPresentations'
(see~"ACERandomEquivPresentations").

\enditems

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
\Section{Options that Modify a Presentation}

\beginitems

\>`group:=<grpgens>'{option group}@{option `group'}&
Defines the `group' generators; <grpgens> should be an  integer  (that
is the number of generators) or a string that is the concatenation of,
or a list of, single-lowercase-letter group generator  names,  i.e.~it
should be in a form suitable  for  the  {\ACE}  binary  to  interpret.
(Shortest abbreviation: `gr'.)

The group generators should normally be input as one of the  arguments
of an {\ACE} interface function, though this option may be useful when
`ACEStart' (see~"ACEStart") is called with the single argument 0. This
option may also be useful for re-using an interactive  process  for  a
new enumeration, rather than using `ACEQuit' to kill the  process  and
`ACEStart' to initiate a new process.  If  the  generators  each  have
names that as strings are single lowercase letters, those same strings
are used to represent the same generators by {\ACE}; otherwise, {\ACE}
will represent each generator by  an  integer,  numbered  sequentially
from 1.

To convert a {\GAP} list <fgens> of free group generators into a  form
suitable   for   the   `group'   option,   use    the    construction:
`ToACEGroupGenerators(<fgens>)'  (see~"ToACEGroupGenerators").  It  is
*strongly recommended* that users  of  the  `group'  option  use  this
construction.

*Notes:*
Any use of the  `group'  command  which  actually  defines  generators
invalidates any previous enumeration, and stays in  effect  until  the
next `group' command. Any words for the  group  or  subgroup  must  be
entered using the nominated generator format, and  all  printout  will
use this format. A valid set of generators is the minimum  information
necessary before {\ACE} will attempt an enumeration.

*Guru Notes:*
The columns of the coset table are allocated in the same order as  the
generators are listed, insofar as this is  possible,  given  that  the
first two columns must be  a  generator/inverse  pair  or  a  pair  of
involutions. The ordering of the columns can, in  some  cases,  affect
the definition sequence of cosets and  impact  the  statistics  of  an
enumeration.

\>`relators:=<relators>'{option relators}@{option `relators'}&
Defines the group `relators'; <relators> must be a string or  list  of
strings that the {\ACE} binary can interpret as  words  in  the  group
generators. (Shortest abbreviation: `rel'.)

The group relators should normally be input as one of the arguments of
an {\ACE} interface function, but  this  option  may  occasionally  be
useful with interactive processes (see~"option group"). If  <wordList>
is an empty list, the group is free.

To convert a  {\GAP}  list  <rels>  of  relators  in  the  free  group
generators <fgens> into a form suitable for the `relators' option, use
the construction: `ToACEWords(<fgens>, <rels>)' (see~"ToACEWords").

\>`generators:=<subgens>'{option  generators}@{option `generators'}&
Defines the subgroup `generators'; <subgens> must be a string or  list
of strings that the {\ACE} binary can interpret as words in the  group
generators. (Shortest abbreviation: `gen'.)

The subgroup generators  should  normally  be  input  as  one  of  the
arguments of  an  {\ACE}  interface  function,  but  this  option  may
occasionally  be  useful  with  interactive   processes   (see~"option
group"). By default, there are no subgroup generators and the subgroup
is trivial. This command allows a list of subgroup generating words to
be entered.

To convert a {\GAP} list <sgens> of subgroup generators  in  the  free
group generators <fgens> into a form  suitable  for  the  `generators'
option,   use   the   construction:   `ToACEWords(<fgens>,   <sgens>)'
(see~"ToACEWords").

\>`sg:=<subgens>'{option sg}@{option `sg'}&
Adds the words in <subgens> to  any  `s'ubgroup  `g'enerators  already
present; <subgens> must be a string or list of strings that the {\ACE}
binary can interpret as words in the group generators.

The enumeration must  be  (re)`start'ed  or  `redo'ne,  it  cannot  be
`continu'ed.

To convert a {\GAP} list <sgens> of subgroup generators  in  the  free
group generators <fgens> into a form  suitable  for  the  `generators'
option,   use   the   construction:   `ToACEWords(<fgens>,   <sgens>)'
(see~"ToACEWords").

*INTERACTIVELY*,            use             `ACEAddSubgroupGenerators'
(see~"ACEAddSubgroupGenerators").

\>`rl:=<relators>'{option rl}@{option `rl'}&
Appends the `r'elator  `l'ist  <relators>  to  the  existing  list  of
relators present; <relators> must be a string or list of strings  that
the {\ACE} binary can interpret as words in the group generators.

The enumeration must  be  (re)`start'ed  or  `redo'ne,  it  cannot  be
`continu'ed.

To convert a  {\GAP}  list  <rels>  of  relators  in  the  free  group
generators <fgens> into a form suitable for the `rl' option,  use  the
construction: `ToACEWords(<fgens>, <rels>)' (see~"ToACEWords").

*INTERACTIVELY*, use `ACEAddRelators' (see~"ACEAddRelators").

\>`ds:=<list>'{option ds}@{option `ds'}&
`D'eletes `s'ubgroup generators; <list> must be  a  list  of  positive
integers.

This command  allows  subgroup  generators  to  be  deleted  from  the
presentation. If the generators are numbered from 1 in the output  of,
say, the `sr' command (see~"option sr"), then the generators listed in
`<list>' are deleted; `<list>' must be a strictly increasing sequence.

*INTERACTIVELY*,           use           `ACEDeleteSubgroupGenerators'
(see~"ACEDeleteSubgroupGenerators").

\>`dr:=<list>'{option dr}@{option `dr'}&
`D'eletes relators; <list> must be a list of positive integers.

This  command  allows  group  relators  to   be   deleted   from   the
presentation. If the relators are numbered from 1 in  the  output  of,
say, the `sr' command (see~"option sr"), then the relators  listed  in
`<list>' are deleted; `<list>' must be a strictly increasing sequence.

*INTERACTIVELY*, use `ACEDeleteRelators' (see~"ACEDeleteRelators").

\>`cc:=<val>'{option cc}@{option `cc'}&
Makes `c'oset <val>  `c'oincide  with  coset  1;  <val>  should  be  a
positive integer.

Prints out the representative of coset `<val>', and  adds  it  to  the
subgroup generators; i.e., forces coset `<val>' to coincide with coset
1, the subgroup.

*INTERACTIVELY*,               use               `ACECosetCoincidence'
(see~"ACECosetCoincidence").

\>`rc:=<val>'{option rc}@{option `rc'}
\>`rc:=[<val>]'{option rc}@{option `rc'}
\>`rc:=[<val>, <attempts>]'{option rc}@{option `rc'}&
Enforce `r'andom `c'oincidences; <val> and <attempts> must be positive
integers.

This option attempts upto <attempts> (or,  in  the  first  and  second
forms, 8) times to find nontrivial subgroups with index a multiple  of
<val> by repeatedly making random coset numbers coincident with  coset
1 and seeing what happens. The starting coset table must be non-empty,
but should not be complete. For each attempt, we repeatedly add random
coset representatives to the subgroup and `redo' the  enumeration.  If
the table becomes too small, the  attempt  is  aborted,  the  original
subgroup generators restored, and another attempt made. If an  attempt
succeeds, then the new set of subgroup generators is retained.

*Guru Notes:*
A coset number can have many different coset representatives. Consider
running `standard' before `rc', to canonicise the table and hence  the
coset representatives.

*INTERACTIVELY*,              use              `ACERandomCoincidences'
(see~"ACERandomCoincidences").

\enditems

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
\Section{Mode Options}

\beginitems

\>`mode'{option mode}@{option `mode'}&
Prints the possible enumeration `mode's.
(Shortest abbreviation: `mo'.)

Prints the possible  enumeration  `mode's  (i.e.~which  of  `continu',
`redo' or `start' are possible (see~"option  continu",  "option  redo"
and "option start").

*INTERACTIVELY*, use `ACEModes' (see~"ACEModes").

\>`begin'{option begin}@{option `begin'}
\>`start'{option start}@{option `start'}&
Start an enumeration. (Shortest abbreviation of `begin' is `beg'.)

Any existing information in the table is cleared, and the  enumeration
starts from coset 1 (i.e., the subgroup).

Normally when a non-interactive {\ACE} interface function  is  called,
the option `start' (see~"option start"), is quietly inserted after all
the options provided by the user, to  initiate  a  coset  enumeration;
however, this is not done, if the user  herself  supplies  either  the
`begin' or `start' option.

*INTERACTIVELY*, use `ACEStart' (see~"ACEStart").

\>`check'{option check}@{option `check'}
\>`redo'{option redo}@{option `redo'}&
`Redo' an extant enumeration, using the current parameters.

As opposed to `start' (see~"option start"), which clears  an  existing
coset table, any existing information in the table  is  retained,  and
the enumeration is restarted from coset 1 (i.e., the subgroup).

*Notes:*
This option is really intended for the case where additional  relators
(option `rl'; see~"option  rl")  and/or  subgroup  generators  (option
`sg'; see~"option sg") have been introduced. The current table,  which
may be incomplete  or  exhibit  a  finite  index,  is  still  *valid*.
However, the additional data may allow the enumeration to complete, or
cause a collapse to a smaller index.

*INTERACTIVELY*, use `ACERedo' (see~"ACERedo").

\atindex{option continue!deprecated: use continu}%
{@option \noexpand`continue'!deprecated: use \noexpand`continu'}
\>`continu'{option continu}@{option `continu'}&
`Continu'es the current enumeration, building upon the existing table.
(Shortest abbreviation: `cont'.)

If a previous run stopped without producing a finite index you can, in
principle, change any of the parameters and `continu'e on. Of  course,
if you make any changes which invalidate the current table, you  won't
be allowed to `continue',  although  you  may  be  allowed  to  `redo'
(see~"option redo"). If `redo' is not  allowed,  you  must  re-`start'
(see~"option start").

*Note:* The {\ACE} standalone allows the option `continue',  but  this
is (as of {\GAP} 4.3) a {\GAP} keyword, and so {\GAP} users  must  use
(mixed-case abbreviations of) `continu'.

*INTERACTIVELY*, use `ACEContinue' (see~"ACEContinue").

\enditems

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
\Section{Options that Interact with the Operating System}

\beginitems

\>`ai'{option ai}@{option `ai'}
\>`ai:=<filename>'{option ai}@{option `ai'}&
`A'lter `i'nput to standard input or <filename>; <filename> must be  a
string.

By default, commands to {\ACE} are read from standard input (i.e., the
keyboard). With no value `ai' causes {\ACE} to revert to reading  from
standard input; otherwise, the `ai' command closes the  current  input
file,  and  opens  `<filename>'  as  the  source   of   commands.   If
`<filename>' can't be opened, input reverts to standard input.

*Notes:*
If you switch to taking input from (another) file, remember to  switch
back before the end of that file; otherwise the `EOF' there will cause
{\ACE} to terminate.

\>`bye'{option bye}@{option `bye'}
\>`exit'{option exit}@{option `exit'}
\>`qui'{option qui}@{option `qui'}&
Quit {\ACE}. (Shortest abbreviation of `qui' is `q'.)

This quits {\ACE} nicely, printing the date and  the  time.  An  `EOF'
(end-of-file;  i.e.,  `\^{}d')  has  the  same   effect,   so   proper
termination occurs if {\ACE} is taking its input from a script file.

Note  that  `qui'  actually  abbreviates  the   corresponding   {\ACE}
directive `quit', but since `quit' is  a  {\GAP}  keyword  it  is  not
available via the {\GAP} interface to {\ACE}.

*INTERACTIVELY*, use `ACEQuit' (see~"ACEQuit").

\>`system:=<string>'{option system}@{option `system'}&
Does a shell escape, to execute <string>; <string> must be a string.
(Shortest abbreviation: `sys'.)

Since {\GAP} already provides `Exec()' for this purpose,  this  option
is unlikely to have a use.

\enditems

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
\Section{Query Options}

\beginitems

\>`cycles'{option cycles}@{option `cycles'}&
Prints out the table in `cycles'. (Shortest abbreviation: `cy'.)

This option prints out the permutation representation.

*INTERACTIVELY*, use `ACECycles' (see~"ACECycles").

\>`dump'{option dump}@{option `dump'}
\>`dump:=<level>'{option dump}@{option `dump'}
\>`dump:=[<level>]'{option dump}@{option `dump'}
\>`dump:=[<level>, <detail>]'{option dump}@{option `dump'}&
`Dump' the internal variables of {\ACE}; <level> must be an integer in
the range 0 to 2, and <detail> must be 0 or 1.
(Shortest abbreviation: `d'.)

The value of <level> determines which of the three levels of {\ACE} to
dump. (You will need to read the standalone manual  `acce3001.dvi'  in
the `standalone-doc' directory to understand what Levels 0,  1  and  2
are all about.) The value of <detail> determines the amount of  detail
(`<detail> = 0' means less detail). The first form (with no arguments)
selects `<level> = 0, <detail> = 0'. The second form of  this  command
makes `<detail> = 0'. This option is intended for  gurus;  the  source
code should be consulted to see what the output means.

*INTERACTIVELY*, use `ACEDumpVariables' (see~"ACEDumpVariables").

\>`help'{option help}@{option `help'}&
Prints the {\ACE} help screen. (Shortest abbreviation: `h'.)

This option prints the list of options of the {\ACE} binary. Note that
this list is longer than a standard screenful.

\>`nc'{option nc}@{option `nc'}
\>`nc:=<val>'{option nc}@{option `nc'}
\>`normal'{option normal}@{option `normal'}
\>`normal:=<val>'{option normal}@{option `normal'}&
Check or attempt to enforce normal closure; <val> must be 0 or 1.

This option tests the subgroup for normal closure within the group. If
a conjugate of a subgroup generator by a generator, is  determined  to
belong to a coset other than coset 1, it is printed out, and if `<val>
=  1',  then  any  such  conjugate  is  also  added  to  the  subgroup
generators. With no argument or if `<val> = 0', {\ACE}  does  not  add
any new subgroup generators.

*Notes:*
The method of determination of  whether  a  conjugate  of  a  subgroup
generator is in the subgroup, is by testing whether it can  be  traced
from coset 1 to coset 1  (see  `trace':~"option trace").

The resultant subgroup need not be  normally  closed  after  executing
option `nc'  with  the  value  1.  It  is  still  possible  that  some
conjugates of the newly added subgroup generators will not be elements
of the subgroup.

*INTERACTIVELY*,      use      `ACEConjugatesForSubgroupNormalClosure'
(see~"ACEConjugatesForSubgroupNormalClosure").

\>`options'{option options}@{option `options'}&
Dumps version information of the {\ACE} binary.
(Shortest abbreviation: `opt'.)

A rather unfortunate name for an option; this command dumps details of
the ``options'' included in the version  of  {\ACE}  when  the  {\ACE}
binary was compiled.

A typical output, is as follows:

\begintt
Executable built:
  Sat Feb 27 15:57:59 EST 1999
Level 0 options:
  statistics package = on
  coinc processing messages = on
  dedn processing messages = on
Level 1 options:
  workspace multipliers = decimal
Level 2 options:
  host info = on
\endtt

*INTERACTIVELY*    and    non-interactively,    use    the     command
`ACEBinaryVersion();' (see~"ACEBinaryVersion") for  this  information,
instead, unless you want it in an {\ACE} standalone input file.

\>`oo:=<val>'{option oo}@{option `oo'}
\>`order:=<val>'{option order}@{option `order'}&
Print a coset representative of a coset number with order  a  multiple
of <val> modulo the subgroup; <val> must be an integer.

This option finds a coset with order a multiple  of  `|<val>|'  modulo
the subgroup, and prints out its coset representative.  If  `<val>  \<
0', then all coset numbers meeting the  requirement  are  printed.  If
`<val> > 0', then just the first coset number meeting the  requirement
is printed. Also, `<val> = 0' is permitted; this special value effects
the printing of the orders (modulo the subgroup) of all coset numbers.

*INTERACTIVELY*,  use  `ACEOrders'  (see~"ACEOrders"),  for  the  case
`<val> = 0', or `ACEOrder' (see~"ACEOrder"), otherwise.

\>`sr'{option sr}@{option `sr'}
\>`sr:=<val>'{option sr}@{option `sr'}&
Print out parameters of the current presentation;  <val>  must  be  an
integer in the range 0 to 5.

No argument, or `<val> = 0', prints out the `Group Name', the  group's
`relators', `Subgroup Name' and the subgroup's `generators'. If `<val>
= 1', then the `Group Generators' and the current setting of the ``run
parameters'' is also  printed.  The  printout  is  the  same  as  that
produced at the start of a run  when  option  `messages'  (see~"option
messages") is non-zero. Also, <val> equal to 2, 3, 4, or 5  print  out
just the `Group Name', just the group's `relators', just the `Subgroup
Name', or just the subgroup's `generators', respectively.

*Notes:*
The `sr' option should  only  be  used  *after*  an  enumeration  run;
otherwise, the value 0 for some options will be unreliable. To  ensure
this occurs non-interactively, ensure one of the options that  invokes
an enumeration: `start' (see~"option  start")  or  `aep'  (see~"option
aep") or `rep' (see~"option rep"), precedes the `sr' option. (When  an
enumeration-invoking option is included  non-interactively  the  quiet
inclusion step of the `start' option is omitted.)

*INTERACTIVELY*, use `ACEGroupGenerators'  (see~"ACEGroupGenerators"),
`ACERelators'   (see~"ACERelators"),   `ACESubgroupGenerators'    (see
"ACESubgroupGenerators"), and `ACEParameters' (see~"ACEParameters").

\>`print'{option print}@{option `print'}
\>`print:=<val>'{option print}@{option `print'}
\>`print:=[<val>]'{option print}@{option `print'}
\>`print:=[<val>, <last>]'{option print}@{option `print'}
\>`print:=[<val>, <last>, <by>]'{option print}@{option `print'}&
Compact and print the coset table;  <val>  must  be  an  integer,  and
<last> and <by> must be positive integers.
(Shortest abbreviation: `pr'.)

In the first (no value) form, `print' prints the entire  coset  table,
without orders or coset  representatives.  In  the  second  and  third
forms, the absolute value of <val> is taken to be the last line of the
table to be printed (and 1 is taken to be the first);  in  the  fourth
and fifth forms, `|<val>|' is taken to be the first line of the  table
to be printed, and <last> is taken to be the number of the  last  line
to be printed. In the last  form,  the  table  is  printed  from  line
`|<val>|' to line <last> in steps of <by>. If <val> is negative,  then
the  orders   modulo   the   subgroup   (if   available)   and   coset
representatives are printed also.

*INTERACTIVELY*,              use               `ACEDisplayCosetTable'
(see~"ACEDisplayCosetTable").

\>`sc:=<val>'{option sc}@{option `sc'}
\>`stabilising:=<val>'{option stabilising}@{option `stabilising'}&
Print out the coset numbers whose elements normalise the subgroup; 
<val> must be an integer.
(Shortest abbreviation of `stabilising' is `stabil'.)

If `<val> > 0', the first `<val>' non-trivial (i.e.~other  than  coset
1) coset numbers whose elements normalise the subgroup are printed. If
`<val> = 0', all non-trivial coset numbers  whose  elements  normalise
the subgroup, plus their representatives, are printed.  If  `<val>  \<
0', the first  `|<val>|'  non-trivial  coset  numbers  whose  elements
normalise the subgroup, plus their representatives, are printed.

*Note:*
The name of this option is an historical hangover. It is named for the
property that elements that ``normalise'' a subgroup, may be  said  to
``stabilise'' that subgroup when they act  ``by  conjugation''.  Also,
the option `normal' (see~"option normal") already performs a different
function.

*INTERACTIVELY*,         use          `ACECosetsThatNormaliseSubgroup'
(see~"ACECosetsThatNormaliseSubgroup").

\>`statistics'{option statistics}@{option `statistics'}
\>`stats'{option stats}@{option `stats'}&
Dump enumeration statistics.
(Shortest abbreviation of `statistics' is `stat'.)

If the statistics package is compiled into the {\ACE} code,  which  it
is by default (see the `options'~"option options" option),  then  this
option  dumps  the  statistics  accumulated  during  the  most  recent
enumeration. See the `enum.c' source  file  for  the  meaning  of  the
variables.

*INTERACTIVELY*, use `ACEDumpStatistics' (see~"ACEDumpStatistics").

\>`style'{option style}@{option `style'}&
Prints the current enumeration style.

This option prints the current enumeration style, as deduced from  the
current `ct' and `rt' parameters (see~"Enumeration Style").

*INTERACTIVELY*, use `ACEStyle' (see~"ACEStyle").

\>`tw:=[<val>, <word>]'{option tw}@{option `tw'}
\>`trace:=[<val>, <word>]'{option trace}@{option `trace'}&
Trace `<word>' through the coset table,  starting  at  coset  `<val>';
<val> must be a positive integer, and <word> must be  a  word  in  the
group generators.

This option prints the final coset number of the trace, if  the  trace
completes.

*INTERACTIVELY*, use `ACETraceWord' (see~"ACETraceWord").

\enditems

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
\Section{Options that Modify the Coset Table}

\beginitems

\index{dead coset (number)}
\>`recover'{option recover}@{option `recover'}
\>`contiguous'{option contiguous}@{option `contiguous'}&
`Recover' space used by dead coset numbers.
(Shortest  abbreviation  of  `recover'   is   `reco',   and   shortest
abbreviation of `contiguous' is `contig'.)

This option invokes the compaction routine on the table to recover the
space used by any dead coset numbers. A `CO' message line  is  printed
if any cosets were recovered, and a  `co'  line  if  none  were.  This
routine is called automatically if  the  `cycles',  `nc',  `print'  or
`standard' options (see~"option cycles", "option nc",  "option  print"
and "option standard") are invoked.

*INTERACTIVELY*, use `ACERecover' (see~"ACERecover").

\>`standard'{option standard}@{option `standard'}&
Compacts {\ACE}'s  coset  table  and  standardises  the  numbering  of
cosets, according to the `lenlex'  scheme  (see  Section~"Coset  Table
Standardisation Schemes"). (Shortest abbreviation: `st'.)

For a given ordering of the generators in the columns of the table, it
produces a canonical numbering of the cosets. This function  does  not
display the new table; use the `print' (see~"option print") for  that.
Such a table has the property that a scan of the  successive  rows  of
the *body* of the table row by row, from  left  to  right,  encounters
previously unseen cosets in numeric order.

*Notes:*
In a `lenlex' standard table, the coset  representatives  are  ordered
first according to length and then the lexicographic order defined  by
the order the generators and their inverses  head  the  columns.  Note
that, since {\ACE} avoids having an involutory generator in the  first
column when it can, this  lexicographic  order  does  not  necessarily
correspond with the order in which the generators were  first  put  to
{\ACE}. Two tables are equivalent only if their canonic forms are  the
same. Invoking this option directly does *not* affect the {\GAP} coset
table obtained via  `ACECosetTable';  use  the  `lenlex'  (see~"option
lenlex") option, if you want your table  `lenlex'  standardised.  (The
`lenlex' option restarts the enumeration, if it is necessary to ensure
the generators have not been rearranged.)

*Guru Notes:*
In  five  of  the  ten  standard  enumeration   strategies   of   Sims
\cite{Sim94} (i.e.~the five Sims strategies not provided  by  {\ACE}),
the   table   is   standardised   repeatedly.   This   is    expensive
computationally, but can result in fewer cosets being  necessary.  The
effect of doing this can be investigated  in  {\ACE}  by  (repeatedly)
halting the enumeration (via restrictive options),  standardising  the
coset numbering, and continuing (see Section~"Emulating Sims"  for  an
interactive example).

*INTERACTIVELY*,            use            `ACEStandardCosetNumbering'
(see~"ACEStandardCosetNumbering").

\enditems

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
\Section{Options for Comments}

\beginitems

\>`text:=<string>'{option text}@{option `text'}&
Prints <string> in the output; <string> must be a string.

This allows the user to add comments to the output from {\ACE}.

*Note:*
Please avoid using this option to insert comments starting with  three
asterisks: `***', since this string is used as a  sentinel  internally
in flushing output from {\ACE}.

\>`aceincomment:=<string>'{option aceincomment!different to option text}%
@{option `aceincomment'!different to option `text'}&
Prints comment <string> in the {\ACE} input; <string> must be a string.
(Shortest abbreviation: `aceinc'.)

This option prints the comment <string> behind a sharp sign (`\#')  in
the input to {\ACE}. Only useful  for  adding  comments  (that  {\ACE}
ignores) to standalone input files.

\enditems

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%%
%E
