%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%%
%A  interact.tex    ANUPQ documentation - interactive f'ns      Werner Nickel
%A                                                                Greg Gamble
%%
%A  @(#)$Id: interact.tex,v 1.74 2005/07/05 10:01:09 werner Exp $
%%
%%

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
\Chapter{Interactive ANUPQ functions}

Here we describe  the  interactive  functions  defined  by  the  {\ANUPQ}
package, i.e.~the functions  that  manipulate  and  initiate  interactive
{\ANUPQ} processes. These are functions that extract  information  via  a
dialogue with a running `pq' process (process used in  the  UNIX  sense).
Occasionally, a user needs the ``next step''; the functions  provided  in
this chapter make use of data from previous steps retained  by  the  `pq'
program, thus allowing the user to interact with the  `pq'  program  like
one can when one uses the `pq' program as a stand-alone  (see~`guide.dvi'
in the `standalone-doc' directory).

An interactive {\ANUPQ} process is initiated by `PqStart' and  terminated
via `PqQuit'; these functions  are  described  in  Section~"Starting  and
Stopping Interactive ANUPQ Processes".

Each interactive {\ANUPQ} function that manipulates  an  already  started
interactive {\ANUPQ} process, has a form where the first argument is  the
integer <i> returned by the initiating `PqStart' command,  and  a  second
form with one argument fewer (where the integer <i> is  discovered  by  a
default mechanism, namely by determining the least integer <i> for  which
there is a currently active interactive {\ANUPQ} process). We  will  thus
commonly say that ``for  the  <i>th  (or  default)  interactive  {\ANUPQ}
process'' a certain function performs a given action. In each case, it is
an error if <i> is not the index of an  active  interactive  process,  or
there are no current active interactive processes.

*Notes*: 
The global method of passing options (via `PushOptions'), should  not  be
used with any of the interactive functions. In fact,  the  `OptionsStack'
should be empty at the time any of the interactive functions is called.

On `quit'ting  {\GAP}, `PqQuitAll();'  is executed, which  terminates all
active  interactive  {\ANUPQ} processes.   If  {\GAP}  is killed  without
`quit'ting,  before all  interactive {\ANUPQ}  processes  are terminated,
*zombie* processes  (still living *child* processes  whose *parents* have
died), may result. Since zombie processes do consume resources,  in  such
an event, the responsible computer user should  seek  out  and  terminate
those zombie processes (e.g.~on  Linux:  `ps xw  |  grep  pq'  gives  you
information on  the  `pq'  processes  corresponding  to  any  interactive
{\ANUPQ} processes started in a {\GAP} session; you  can  then  do  `kill
<N>' for each number <N> appearing in the first column of this output).

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
\Section{Starting and Stopping Interactive ANUPQ Processes}

\>PqStart( <G>, <workspace> : <options> ) F
\>PqStart( <G> : <options> ) F
\>PqStart( <workspace> : <options> ) F
\>PqStart(: <options> ) F

activate an iostream for an interactive {\ANUPQ} process (i.e.  `PqStart'
starts up a `pq' process and  opens a {\GAP} iostream to ``talk'' to that
process) and  returns an integer  <i> that can  be used to  identify that
process.  The argument <G> should be an *fp group* or *pc group* that the
user intends to manipulate  using interactive {\ANUPQ} functions.  If the
function is  called without  specifying <G>,  a group can  be read  in by
using the function `PqRestorePcPresentation' (see~"PqRestorePcPresentation").
If `PqStart' is given an integer  argument  <workspace>,  then  the  `pq'
program is started up  with  a  workspace  (an  integer  array)  of  size
<workspace> (i.e. $4 \times <workspace>$ bytes in a 32-bit  environment);
otherwise, the `pq' program sets a default workspace of $10000000$.

The  only  <options>  currently  recognised  by  `PqStart'  are  `Prime',
`Exponent' and  `Relators'  (see  Chapter~"ANUPQ  options"  for  detailed
descriptions of these options)  and  if  provided  they  are  essentially
global for the interactive {\ANUPQ} process, except that any  interactive
function interacting with the process and passing new  values  for  these
options will over-ride the global values.

\>PqQuit( <i> ) F
\>PqQuit() F

closes the stream of the <i>th or default  interactive  {\ANUPQ}  process
and unbinds its `ANUPQData.io' record.

*Note:*
It can happen that the  `pq'  process,  and  hence  the  {\GAP}  iostream
assigned to communicate with it, can  die,  e.g.~by  the  user  typing  a
`Ctrl-C' while the  `pq'  process  is  engaged  in  a  long  calculation.
`IsPqProcessAlive' (see~"IsPqProcessAlive")  is  provided  to  check  the
status of the {\GAP} iostream (and hence the status of the  `pq'  process
it was communicating with).

\>PqQuitAll() F

is provided  as  a  convenience,  to  terminate  all  active  interactive
{\ANUPQ} processes with a single command. It is equivalent  to  executing
`PqQuit(<i>)'  for  all  active  interactive   {\ANUPQ}   processes   <i>
(see~"PqQuit").

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
\Section{Interactive ANUPQ Process Utility Functions}

\>PqProcessIndex( <i> ) F
\>PqProcessIndex() F

With argument <i>, which must be  a  positive  integer,  `PqProcessIndex'
returns <i> if it corresponds to an active interactive process, or raises
an error. With no arguments it returns  the  default  active  interactive
process or returns `fail' and  emits  a  warning  message  to  `Info'  at
`InfoANUPQ' or `InfoWarning' level 1.

*Note:*
Essentially,  an  interactive  {\ANUPQ}  process  <i>  is  ``active''  if
`ANUPQData.io[<i>]' is bound (i.e.~we still have  some  data  telling  us
about it). Also see~"PqStart".

\>PqProcessIndices() F

returns the list of integer indices of all  active  interactive  {\ANUPQ}
processes (see~"PqProcessIndex" for the meaning of ``active'').

\>IsPqProcessAlive( <i> ) F
\>IsPqProcessAlive() F

return  `true'  if  the  {\GAP}  iostream  of  the  <i>th  (or   default)
interactive {\ANUPQ} process started  by  `PqStart'  is  alive  (i.e.~can
still be written to), or `false', otherwise. (See the notes for~"PqStart"
and~"PqQuit".)

\atindex{interruption}{@interruption of an interactive ANUPQ process}
If the user does not yet have a  `gap>'  prompt  then  usually  the  `pq'
program is still away doing something and an {\ANUPQ}  interface  function
is still waiting for a reply. Typing a `Ctrl-C'  (i.e.~holding  down  the
`Ctrl' key and typing `c') will stop the waiting and send {\GAP}  into  a
`break'-loop, from which one has no option but to `quit;'. The typing  of
`Ctrl-C', in such a  circumstance,  usually  causes  the  stream  of  the
interactive  {\ANUPQ}  process  to  die;  to  check   this   we   provide
`IsPqProcessAlive' (see~"IsPqProcessAlive").

The {\GAP} iostream of an interactive {\ANUPQ} process will also  die  if
the `pq' program has a segmentation fault. We do  hope  that  this  never
happens to you, but if it does and the failure is reproducible, then it's
a bug and we'd like to know about it. Please read the `README' that comes
with the {\ANUPQ} package to find out what to include in a bug report and
who to email it to.

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
\Section{Interactive Versions of Non-interactive ANUPQ Functions}

\>Pq( <i> : <options> )!{interactive} F
\>Pq( : <options> )!{interactive} F

return, for the fp  or pc group (let us call it  <F>), of the <i>th or
default  interactive   {\ANUPQ}  process,  the   $p$-quotient  of  <F>
specified by <options>,  as a pc group; <F>  must previously have been
given  (as  first argument)  to  `PqStart'  to  start the  interactive
{\ANUPQ}  process  (see~"PqStart") or  restored  from  file using  the
function  `PqRestorePcPresentation'  (see~"PqRestorePcPresentation").  
Following the colon <options> is a selection of the options listed for
the non-interactive `Pq' function (see~"Pq"), separated by commas like
record components (see Section~"ref:function call!with options" in the
{\GAP}  Reference  Manual), except  that  the  options `SetupFile'  or
`PqWorkspace' are ignored by the interactive `Pq', and `RedoPcp' is an
option  only recognised  by  the interactive  `Pq' i.e.~the  following
options are recognised by the interactive `Pq' function:

\beginlist%unordered

\atindex{option Prime}{@option \noexpand`Prime'}
\item{}`Prime := <p>'

\atindex{option ClassBound}{@option \noexpand`ClassBound'}
\item{}`ClassBound := <n>'

\atindex{option Exponent}{@option \noexpand`Exponent'}
\item{}`Exponent := <n>'

\atindex{option Relators}{@option \noexpand`Relators'}
\item{}`Relators := <rels>'

\atindex{option Metabelian}{@option \noexpand`Metabelian'}
\item{}`Metabelian'

\atindex{option Identities}{@option \noexpand`Identities'}
\item{}`Identities := <funcs>'

\atindex{option GroupName}{@option \noexpand`GroupName'}
\item{}`GroupName := <name>'

\atindex{option OutputLevel}{@option \noexpand`OutputLevel'}
\item{}`OutputLevel := <n>'

\atindex{option RedoPcp}{@option \noexpand`RedoPcp'}
\item{}`RedoPcp'

\endlist

Detailed descriptions of the above options may be found in Chapter~"ANUPQ
options".

As a minimum the `Pq' function  *must*  have  a  value  for  the  `Prime'
option, though `Prime' need not be  passed  again  in  the  case  it  has
previously been provided, e.g. to `PqStart' (see~"PqStart") when starting
the interactive process.

The behaviour of the interactive `Pq' function  depends  on  the  current
state of the pc presentation stored by the `pq' program:

\beginlist%ordered

\item{1.}
If no pc presentation has yet been computed (the case  immediately  after
the `PqStart' call initiating the process) then the quotient group of the
input group of the process of largest lower exponent-<p> class bounded by
the  value  of  the  `ClassBound'  option  (see~"option  ClassBound")  is
returned.

\item{2.}
If the current pc  presentation  of  the  process  was  determined  by  a
previous call to `Pq' or `PqEpimorphism', and  the  current  call  has  a
larger value `ClassBound' then the  class  is  extended  as  much  as  is
possible and the quotient group of the input group of the process of  the
new lower exponent-<p> class is returned.

\item{3.}
If the current pc  presentation  of  the  process  was  determined  by  a
previous call to `PqPCover'  then  a  consistent  pc  presentation  of  a
quotient for the current class is determined before proceeding as in 2.

\item{4.}
If the `RedoPcp' option  is  supplied  the  current  pc  presentation  is
scrapped, all options must be re-supplied (in particular, `Prime'  *must*
be supplied) and then the `Pq' function proceeds as in 1.

\endlist

See Section~"Attributes and a Property for fp and pc  p-groups"  for  the
attributes   and   property   `NuclearRank',   `MultiplicatorRank'    and
`IsCapable' which may be applied to the group returned by `Pq'.

The following is one of the examples for the non-interactive `Pq'  redone
with the interactive version. Also, we set the option `OutputLevel' to  1
(see~"option   Outputlevel"), in order to see the orders of the quotients
of all the classes determined, and we set  the  `InfoANUPQ'  level  to  2
(see~"InfoANUPQ"), so that we catch the timing information.

\beginexample
gap> F := FreeGroup("a", "b");; a := F.1;; b := F.2;;
gap> G := F / [a^4, b^4];
<fp group on the generators [ a, b ]>
gap> PqStart(G);
1
gap> SetInfoLevel(InfoANUPQ, 2); #To see timing information               
gap> Pq(: Prime := 2, ClassBound := 3, OutputLevel := 1 );
#I  Lower exponent-2 central series for [grp]
#I  Group: [grp] to lower exponent-2 central class 1 has order 2^2
#I  Group: [grp] to lower exponent-2 central class 2 has order 2^5
#I  Group: [grp] to lower exponent-2 central class 3 has order 2^8
#I  Computation of presentation took 0.00 seconds
<pc group of size 256 with 8 generators>
\endexample

\>PqEpimorphism( <i> : <options> )!{interactive} F
\>PqEpimorphism( : <options> )!{interactive} F

return, for  the fp  or pc group (let us  call it <F>),  of the  <i>th or
default interactive  {\ANUPQ} process, an  epimorphism from <F>  onto the
$p$-quotient of <F> specified by <options>; <F> must previously have been
given (as first argument) to  `PqStart' to start the interactive {\ANUPQ}
process (see~"PqStart"). Since the  underlying interactions with the `pq'
program  effected by  the  interactive `PqEpimorphism'  are identical  to
those  effected by the  interactive `Pq',  everything said  regarding the
requirements   and   behaviour   of   the   interactive   `Pq'   function
(see~"Pq!interactive")   is   also   the   case   for   the   interactive
`PqEpimorphism'.

*Note:*
See Section~"Attributes and a Property for fp and pc  p-groups"  for  the
attributes   and   property   `NuclearRank',   `MultiplicatorRank'    and
`IsCapable' which may be applied to the image group  of  the  epimorphism
returned by `PqEpimorphism'.

\>PqPCover( <i> : <options> )!{interactive} F
\>PqPCover( : <options> )!{interactive} F

return,  for the  fp or  pc  group of  the <i>th  or default  interactive
{\ANUPQ} process,  the $p$-covering group  of the $p$-quotient  `Pq(<i> :
<options>)' or `Pq(: <options>)', modulo the following:

\beginlist%ordered

\item{1.}
If no pc presentation has yet been computed (the case  immediately  after
the `PqStart' call initiating the process)  and  the  group  <F>  of  the
process is already a $p$-group, in the sense that  `HasIsPGroup(<F>)  and
IsPGroup(<F>)' is `true', then

\endlist
\beginitems

`Prime'& 
defaults to `PrimePGroup(<F>)', if not supplied and  `HasPrimePGroup(<F>)
= true'; and

`ClassBound'&
defaults to `PClassPGroup(<F>)' if `HasPClassPGroup(<F>) =  true'  if  not
supplied, or to the usual default of 63, otherwise.

\enditems
\beginlist%ordered{1}{2}

\item{2.}
If a pc presentation has been computed and none of <options> is `RedoPcp'
or if no pc presentation has yet been computed but 1. does not apply then
`PqPCover(<i> : <options>);' is equivalent to:

\){\kernttindent}Pq(<i> : <options>);
\){\kernttindent}PqPCover(<i>);

\item{3.}
If the `RedoPcp' option  is  supplied  the  current  pc  presentation  is
scrapped, and `PqPCover'  proceeds  as  in  1.  or  2.  but  without  the
`RedoPcp' option.

\endlist

\index{automorphisms!of $p$-groups}
\>PqStandardPresentation([ <i> ]: <options> )!{interactive} F
\>StandardPresentation([ <i> ]: <options> )!{interactive} M

return, for the  <i>th  or  default  interactive  {\ANUPQ}  process,  the
<p>-quotient of the group <F> of the process, specified by <options>,  as
an *fp group* which has a standard  presentation.  Here  <options>  is  a
selection of the options from  the  following  list  (see  Chapter~"ANUPQ
options" for detailed descriptions); this list is the  same  as  for  the
non-interactive  version  of  `PqStandardPresentation'  except  for   the
omission     of      options      `SetupFile'      and      `PqWorkspace'
(see~"PqStandardPresentation").

\beginlist%unordered

\atindex{option Prime}{@option \noexpand`Prime'}
\item{}`Prime := <p>'

\atindex{option pQuotient}{@option \noexpand`pQuotient'}
\item{}`pQuotient := <Q>'

\atindex{option ClassBound}{@option \noexpand`ClassBound'}
\item{}`ClassBound := <n>'

\atindex{option Exponent}{@option \noexpand`Exponent'}
\item{}`Exponent := <n>'

\atindex{option Metabelian}{@option \noexpand`Metabelian'}
\item{}`Metabelian'

\atindex{option GroupName}{@option \noexpand`GroupName'}
\item{}`GroupName := <name>'

\atindex{option OutputLevel}{@option \noexpand`OutputLevel'}
\item{}`OutputLevel := <n>'

\atindex{option StandardPresentationFile}%
{@option \noexpand`StandardPresentationFile'}
\item{}`StandardPresentationFile := <filename>'

\endlist

Unless <F> is a pc <p>-group, or the option `Prime' has been passed to  a
previous interactive function for the process to compute  a  <p>-quotient
for <F>, the user *must* supply either the option `Prime' or  the  option
`pQuotient' (if both `Prime' and `pQuotient' are supplied, the prime  <p>
is determined by applying  `PrimePGroup'  (see~"ref:PrimePGroup"  in  the
Reference Manual) to the value of `pQuotient').

Taking  one  of  the  examples  for  the   non-interactive   version   of
`StandardPresentation'  (see~"StandardPresentation")  that  required  two
separate calls to the `pq' program, we now show how it  can  be  done  by
setting up  a  dialogue  with  just  the  one  `pq'  process,  using  the
interactive version of `StandardPresentation':

\beginexample
gap> F4 := FreeGroup( "a", "b", "c", "d" );;
gap> a := F4.1;; b := F4.2;; c := F4.3;; d := F4.4;;
gap> G4 := F4 / [ b^4, b^2 / Comm(Comm (b, a), a), d^16,
>                 a^16 / (c * d), b^8 / (d * c^4) ];
<fp group on the generators [ a, b, c, d ]>
gap> SetInfoLevel(InfoANUPQ, 1); #Only essential Info please
gap> PqStart(G4); #Start a new interactive process for a new group
2
gap> K := Pq( 2 : Prime := 2, ClassBound := 1 ); #`pq' process no. is 2
<pc group of size 4 with 2 generators>
gap> StandardPresentation( 2 : pQuotient := K, ClassBound := 14 );
<fp group with 53 generators>
\endexample

*Notes*

In contrast  to the  function `Pq' (see~"Pq")  which returns a  pc group,
`PqStandardPresentation' or `StandardPresentation' returns an  fp  group.
This is because the output is mainly used  for  isomorphism  testing  for
which an fp group is enough. However, the presentation  is  a  polycyclic
presentation and if you need to do  any  further  computation  with  this
group (e.g.~to find the order) you can use the function  `PcGroupFpGroup'
(see~"ref:PcGroupFpGroup" in the {\GAP} Reference Manual) to  form  a  pc
group.

If  the user  does  not supply  a  <p>-quotient <Q>  via the  `pQuotient'
option, and  the prime  <p> is either  supplied, stored,  or <F> is  a pc
<p>-group, then a  <p>-quotient <Q> is computed. (The  value of the prime
<p>  is  stored if  passed  initially to  `PqStart'  or  to a  subsequent
interactive process.)  Note that a  stored value for `pQuotient'  (from a
prior call to `Pq') does *not* have precedence over a value for the prime
<p>.  If the  user does  supply a  <p>-quotient <Q>  via  the `pQuotient'
option,  the package  {\AutPGrp} is  called to  compute  the automorphism
group  of <Q>; an  error will  occur that  asks the  user to  install the
package {\AutPGrp} if the automorphism group cannot be computed.

If   any   of   the   interactive   functions   `PqStandardPresentation',
`StandardPresentation',      `EpimorphismPqStandardPresentation'       or
`EpimorphismStandardPresentation'  has  been  called  previously  for  an
interactive process, a subsequent call to any of these functions for  the
same process returns the previously computed value. Note that  all  these
functions compute both an epimorphism and  an  fp  group  and  store  the
results in the `SPepi' and `SP' fields of the data record associated with
the    process.    See    the     example     for     the     interactive
`EpimorphismStandardPresentation'
("EpimorphismStandardPresentation!interactive").

The  attributes  and  property  `NuclearRank',  `MultiplicatorRank'   and
`IsCapable' are set for the group returned by `PqStandardPresentation' or
`StandardPresentation' (see Section~"Attributes and a Property for fp and  
pc p-groups").

\>EpimorphismPqStandardPresentation([ <i> ]: <options> )!{interactive} F
\>EpimorphismStandardPresentation([ <i> ]: <options> )!{interactive} M

Each of the above functions accepts the same arguments and options as the
interactive           form           of            `StandardPresentation'
(see~"StandardPresentation!interactive") and returns an epimorphism  from
the fp or pc group <F> of  the  <i>th  or  default  interactive  {\ANUPQ}
process  onto  the  finitely  presented  group  given   by   a   standard
presentation, i.e.~if <S> is the standard presentation computed  for  the
$p$-quotient     of     <F>      by      `StandardPresentation'      then
`EpimorphismStandardPresentation' returns the epimorphism from <F> to the
group with presentation <S>. The group <F> must have been given (as first
argument)  to  `PqStart'  to  start  the  interactive  {\ANUPQ}   process
(see~"PqStart").

Taking        our         earlier         non-interactive         example
(see~"EpimorphismPqStandardPresentation") and modifying it a  little,  we
illustrate,    as    for    the    interactive     `StandardPresentation'
(see~"StandardPresentation!interactive"), how something that required two
separate calls to the `pq' program can now be achieved  with  a  dialogue
with just one `pq' process. Also,  observe  that  calls  to  one  of  the
standard   presentation   functions   (as   mentioned   in   the    notes
of~"StandardPresentation!interactive") computes and  stores  both  an  fp
group with a standard presentation and an epimorphism;  subsequent  calls
to a standard presentation function for the same  process  simply  return
the appropriate stored value.

\beginexample
gap> F := FreeGroup(6, "F");;
gap> x := F.1;; y := F.2;; z := F.3;; w := F.4;; a := F.5;; b := F.6;;
gap> R := [x^3 / w, y^3 / w * a^2 * b^2, w^3 / b,
>          Comm (y, x) / z, Comm (z, x), Comm (z, y) / a, z^3 ];
[ F1^3*F4^-1, F2^3*F4^-1*F5^2*F6^2, F4^3*F6^-1, F2^-1*F1^-1*F2*F1*F3^-1, 
  F3^-1*F1^-1*F3*F1, F3^-1*F2^-1*F3*F2*F5^-1, F3^3 ]
gap> Q := F / R;
<fp group on the generators [ F1, F2, F3, F4, F5, F6 ]>
gap> PqStart( Q );
3
gap> G := Pq( 3 : Prime := 3, ClassBound := 3 );
<pc group of size 729 with 6 generators>
gap> lev := InfoLevel(InfoANUPQ);; # Save current InfoANUPQ level
gap> SetInfoLevel(InfoANUPQ, 2); # To see computation times
gap> # It is not necessary to pass the `Prime' option to
gap> # `EpimorphismStandardPresentation' since it was previously
gap> # passed to `Pq':
gap> phi := EpimorphismStandardPresentation( 3 : ClassBound := 3 );
#I  Class 1 3-quotient and its 3-covering group computed in 0.00 seconds
#I  Order of GL subgroup is 48
#I  No. of soluble autos is 0
#I    dim U = 1  dim N = 3  dim M = 3
#I    nice stabilizer with perm rep
#I  Computing standard presentation for class 2 took 0.00 seconds
#I  Computing standard presentation for class 3 took 0.01 seconds
[ F1, F2, F3, F4, F5, F6 ] -> [ f1*f2^2*f3*f4^2*f5^2, f1*f2*f3*f5, f3^2, 
  f4*f6^2, f5, f6 ]
gap> # Image of phi should be isomorphic to G ...
gap> # let's check the order is correct:
gap> Size( Image(phi) );
729
gap> # `StandardPresentation' and `EpimorphismStandardPresentation'
gap> # behave like attributes, so no computation is done when
gap> # either is called again for the same process ...
gap> StandardPresentation( 3 : ClassBound := 3 );
<fp group of size 729 on the generators [ f1, f2, f3, f4, f5, f6 ]>
gap> # No timing data was Info-ed since no computation was done
gap> SetInfoLevel(InfoANUPQ, lev); # Restore previous InfoANUPQ level
\endexample

A very similar (essential details are the same) example to the above may
be executed live, by typing:
`PqExample( "EpimorphismStandardPresentation-i" );'.

*Note:*
The  notes   for   `PqStandardPresentation'   or   `StandardPresentation'
(see~"PqStandardPresentation!interactive")      apply       also       to
`EpimorphismPqStandardPresentation' or  `EpimorphismStandardPresentation'
except that their return value is an  *epimorphism  onto*  an  fp  group,
i.e.~one should interpret the phrase ``returns an fp group'' as ``returns
an epimorphism onto an fp group'' etc.

\>PqDescendants( <i> : <options> )!{interactive} F
\>PqDescendants( : <options> )!{interactive} F

return for the pc group <G> of the <i>th or default interactive  {\ANUPQ}
process, which  must  be  of  prime  power  order  with  a  confluent  pc
presentation (see~"ref:IsConfluent!for pc groups" in the {\GAP} Reference
Manual), a list of descendants (pc groups)  of  <G>.  The  group  <G>  is
usually  given  as  first  argument  to  `PqStart'  when   starting   the
interactive {\ANUPQ}  process  (see~"PqStart").  Alternatively,  one  may
initiate  the  process  with  an  fp  group,   use   `Pq'   interactively
(see~"Pq!interactive")    to    create    a    pc    group    and     use
`PqSetPQuotientToGroup'  (see~"PqSetPQuotientToGroup"),  which   involves
*no* computation, to set the pc group returned by `Pq' as  the  group  of
the process. Note that repeating a call to `PqDescendants' for  the  same
interactive {\ANUPQ} process  simply  returns  the  list  of  descendants
originally calculated; a  warning  is  emitted  at  `InfoANUPQ'  level  1
reminding you of this should you do this.

Following the colon <options> a selection of the options listed  for  the
non-interactive `PqDescendants' function (see~"PqDescendants") should  be
given,   separated   by    commas    like    record    components    (see
Section~"ref:function call!with options" in the {\GAP} Reference Manual),
except that the options `SetupFile' or `PqWorkspace' are ignored  by  the
interactive `PqDescendants', i.e.~the following options are recognised by
the interactive `PqDescendants' function:

\beginlist%unordered

\atindex{option ClassBound}{@option \noexpand`ClassBound'}
\item{}`ClassBound := <n>'

\atindex{option Relators}{@option \noexpand`Relators'}
\item{}`Relators := <rels>'

\atindex{option OrderBound}{@option \noexpand`OrderBound'}
\item{}`OrderBound := <n>'

\atindex{option StepSize}{@option \noexpand`StepSize'}
\item{}`StepSize := <n>', `StepSize := <list>'

\atindex{option RankInitialSegmentSubgroups}%
{@option \noexpand`RankInitialSegmentSubgroups'}
\item{}`RankInitialSegmentSubgroups := <n>'

\atindex{option SpaceEfficient}{@option \noexpand`SpaceEfficient'}
\item{}`SpaceEfficient'

\atindex{option CapableDescendants}{@option \noexpand`CapableDescendants'}
\item{}`CapableDescendants'

\atindex{option AllDescendants}{@option \noexpand`AllDescendants'}
\item{}`AllDescendants := false'

\atindex{option Exponent}{@option \noexpand`Exponent'}
\item{}`Exponent := <n>'

\atindex{option Metabelian}{@option \noexpand`Metabelian'}
\item{}`Metabelian'

\atindex{option GroupName}{@option \noexpand`GroupName'}
\item{}`GroupName := <name>'

\atindex{option SubList}{@option \noexpand`SubList'}
\item{}`SubList := <sub>'

\atindex{option BasicAlgorithm}{@option \noexpand`BasicAlgorithm'}
\item{}`BasicAlgorithm'

\atindex{option CustomiseOutput}{@option \noexpand`CustomiseOutput'}
\item{}`CustomiseOutput := <rec>'

\endlist

*Notes:* The function `PqDescendants'  uses the automorphism group of <G>
which it computes via the package {\AutPGrp} if the automorphism group of
<G> is not already present.  If  {\AutPGrp} is not installed an error may
be  raised.  If  the  automorphism group  of  <G> is  insoluble the  `pq'
program will call {\GAP} together with the {\AutPGrp} package for certain
orbit-stabilizer calculations.

The  attributes  and  property  `NuclearRank',  `MultiplicatorRank'   and
`IsCapable'  are  set  for  each  group   of   the   list   returned   by
`PqDescendants' (see Section~"Attributes and a Property  for  fp  and  pc
p-groups").

Let us now repeat the examples previously given for  the  non-interactive
`PqDescendants',  but  this  time  with  the   interactive   version   of
`PqDescendants':

\beginexample
gap> F := FreeGroup( "a", "b" );; a := F.1;; b := F.2;;
gap> G := PcGroupFpGroup( F / [ a^2, b^2, Comm(b, a) ] );
<pc group of size 4 with 2 generators>
gap> PqStart(G); #This will now be the 4th interactive process running
4
gap> des := PqDescendants( 4 : OrderBound := 6, ClassBound := 5 );;
gap> Length(des);
83
gap> List(des, Size);
[ 8, 8, 8, 16, 16, 16, 32, 16, 16, 16, 16, 16, 32, 32, 64, 64, 32, 32, 32, 
  32, 32, 32, 32, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 32, 32, 32, 32, 
  64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 32, 32, 32, 32, 32, 64, 64, 64, 
  64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 
  64, 64, 64, 64, 64, 64, 64 ]
gap> List(des, d -> Length( PCentralSeries( d, 2 ) ) - 1 );
[ 2, 2, 2, 2, 2, 2, 2, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 
  3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 4, 
  4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 
  4, 4, 4, 5, 5, 5, 5, 5 ]
\endexample

In the second example we compute all  capable descendants of order  27 of
the  elementary abelian group of order 9.  

\beginexample
gap> F := FreeGroup( 2, "g" );;                                 
gap> G := PcGroupFpGroup( F / [ F.1^3, F.2^3, Comm(F.1, F.2) ] );
<pc group of size 9 with 2 generators>
gap> PqStart(G); #This will now be the 5th interactive process running
5
gap> des := PqDescendants( 5 : OrderBound := 3, ClassBound := 2,
>                              CapableDescendants );
[ <pc group of size 27 with 3 generators>, 
  <pc group of size 27 with 3 generators> ]
gap> List(des, d -> Length( PCentralSeries( d, 3 ) ) - 1 );
[ 2, 2 ]
gap> # For comparison let us now compute all descendants
gap> # (using the non-interactive Pq function)
gap> PqDescendants( G : OrderBound := 3, ClassBound := 2);
[ <pc group of size 27 with 3 generators>, 
  <pc group of size 27 with 3 generators>, 
  <pc group of size 27 with 3 generators> ]
\endexample

In  the  third  example,  we  compute  all  capable  descendants  of  the
elementary abelian group of order  $5^2$ which have exponent-$5$ class at
most $3$, exponent $5$, and are metabelian.

\beginexample
gap> F := FreeGroup( 2, "g" );;
gap> G := PcGroupFpGroup( F / [ F.1^5, F.2^5, Comm(F.2, F.1) ] );
<pc group of size 25 with 2 generators>
gap> PqStart(G); #This will now be the 6th interactive process running
6
gap> des := PqDescendants( 6 : Metabelian, ClassBound := 3,
>                              Exponent := 5, CapableDescendants );
[ <pc group of size 125 with 3 generators>, 
  <pc group of size 625 with 4 generators>, 
  <pc group of size 3125 with 5 generators> ]
gap> List(des, d -> Length( PCentralSeries( d, 5 ) ) - 1 );
[ 2, 3, 3 ]
gap> List(des, d -> Length( DerivedSeries( d ) ) );
[ 3, 3, 3 ]
gap> List(des, d -> Maximum( List( Elements(d), Order ) ) );
[ 5, 5, 5 ]
\endexample

\>PqSetPQuotientToGroup( <i> ) F
\>PqSetPQuotientToGroup() F

for  the  <i>th  or  default  interactive  {\ANUPQ}  process,   set   the
$p$-quotient  previously  computed  by  the  interactive  `Pq'   function
(see~"Pq!interactive") to be the group of the process. This  function  is
supplied to enable the computation of descendants of a $p$-quotient  that
is already known to the `pq' program, via the interactive  `PqDescendants'
function (see~"PqDescendants!interactive"), thus  avoiding  the  need  to
re-submit it and have the `pq' program recompute it.

*Note:*       See       the       function       `PqPGSetDescendantToPcp'
("PqPGSetDescendantToPcp") for  a mechanism to make (the  $p$-cover of) a
particular descendants the current group of the process.

The following example of the usage of `PqSetPQuotientToGroup',  which  is
essentially   equivalent    to    what    is    obtained    by    running
`PqExample("PqDescendants-1-i");',   redoes   the   first   example    of
"PqDescendants!interactive" (which computes the descendants of the  Klein
four group).

\beginexample
gap> F := FreeGroup( "a", "b" );
<free group on the generators [ a, b ]>
gap> procId := PqStart( F : Prime := 2 );
7
gap> Pq( procId : ClassBound := 1 );
<pc group of size 4 with 2 generators>
gap> PqSetPQuotientToGroup( procId );
gap> des := PqDescendants( procId : OrderBound := 6, ClassBound := 5 );;
gap> Length(des);
83
gap> List(des, Size);
[ 8, 8, 8, 16, 16, 16, 32, 16, 16, 16, 16, 16, 32, 32, 64, 64, 32, 32, 32, 
  32, 32, 32, 32, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 32, 32, 32, 32, 
  64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 32, 32, 32, 32, 32, 64, 64, 64, 
  64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 
  64, 64, 64, 64, 64, 64, 64 ]
gap> List(des, d -> Length( PCentralSeries( d, 2 ) ) - 1 );
[ 2, 2, 2, 2, 2, 2, 2, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 
  3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 4, 
  4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 
  4, 4, 4, 5, 5, 5, 5, 5 ]
\endexample

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
\Section{Low-level Interactive ANUPQ Functions based on menu items of the
pq program}

The `pq' program has 5 menus, the details of which  the  reader  will  not
normally need to know, but if she wishes to know the details they may  be
found in the standalone manual: `guide.dvi'.  Both  `guide.dvi'  and  the
`pq' program refer to the items of these 5 menus as ``options'', which  do
*not* correspond in any way to the options used  by  any  of  the  {\GAP}
functions that interface with the `pq' program.

*Warning:*
The commands provided in this section are intended to  provide  something
like the interactive functionality one has when running  the  standalone,
from within {\GAP}. The `pq' standalone (in particular, its  ``advanced''
menus) assumes some expertise of the user; doing the ``wrong'' thing  can
cause the program to crash.  While  a  number  of  safeguards  have  been
provided in the {\GAP} interface to the `pq'  program,  these  are  *not*
foolproof, and the user should exercise care and ensure pre-requisites of
the various commands are met.

*General commands*

The following commands either use a  menu  item  from  whatever  menu  is
``current'' for the `pq' program, or have general application and are  not
associated with just one menu item of the `pq' program.

\>PqNrPcGenerators( <i> ) F
\>PqNrPcGenerators() F

for the <i>th or default  interactive {\ANUPQ} process, return the number
of pc  generators of the lower  exponent $p$-class quotient  of the group
currently  determined  by the  process.   This  also  applies if  the  pc
presentation is not consistent.

\>PqFactoredOrder( <i> ) F
\>PqFactoredOrder() F

for the <i>th or default interactive {\ANUPQ} process, return an  integer
pair `[<p>, <n>]' where <p> is a prime  and  <n>  is  the  number  of  pc
generators  (see~"PqNrPcGenerators")  in  the  pc  presentation  of   the
quotient group currently determined by the process. If this  presentation
is consistent, then $p^n$ is the order of the quotient  group.  Otherwise
(if tails have been added but the necessary consistency checks,  relation
collections, exponent law checks  and  redundant  generator  eliminations
have not yet been done), $p^n$ is an upper bound for  the  order  of  the
group.

\>PqOrder( <i> ) F
\>PqOrder() F

for the <i>th or default  interactive  {\ANUPQ}  process,  return  $p^n$
where  `[<p>,  <n>]'  is  the  pair  as  returned  by   `PqFactoredOrder'
(see~"PqFactoredOrder").

\>PqPClass( <i> ) F
\>PqPClass() F

for the <i>th or default interactive {\ANUPQ} process, return  the  lower
exponent $p$-class of the quotient  group  currently  determined  by  the
process.

\>PqWeight( <i>, <j> ) F
\>PqWeight( <j> ) F

for the <i>th or default interactive {\ANUPQ} process, return the  weight
of the <j>th pc generator of the lower exponent $p$-class quotient of the
group currently determined by the process, or `fail' if there is no  such
numbered pc generator.

\>PqCurrentGroup( <i> ) F
\>PqCurrentGroup() F

for the <i>th or default interactive {\ANUPQ} process, return  the  group
whose pc presentation is determined by the process as a {\GAP}  pc  group
(either a lower exponent $p$-class quotient of the  start  group  or  the
$p$-cover of such a quotient).

*Notes:*
See Section~"Attributes and a Property for fp and pc  p-groups"  for  the
attributes   and   property   `NuclearRank',   `MultiplicatorRank'    and
`IsCapable'  which  may   be   applied   to   the   group   returned   by
`PqCurrentGroup'.

\>PqDisplayPcPresentation( <i> [: OutputLevel := <lev> ]) F
\>PqDisplayPcPresentation([: OutputLevel := <lev> ]) F

for the <i>th or default interactive {\ANUPQ} process,  direct  the  `pq'
program to display the pc presentation of  the  lower  exponent  $p$-class
quotient of the group currently determined by the process.

Except if the last command communicating  with  the  `pq'  program  was  a
$p$-group generation command (for which there is only  a  verbose  output
level), to set the amount of information this command  displays  you  may
wish  to  call  `PqSetOutputLevel'  first  (see~"PqSetOutputLevel"),   or
equivalently pass the option `OutputLevel' (see~"option OutputLevel").

*Note:*
For  those  familiar  with  the  `pq'  program,  `PqDisplayPcPresentation'
performs menu item 4 of the current menu of the `pq' program.

\>PqSetOutputLevel( <i>, <lev> ) F
\>PqSetOutputLevel( <lev> ) F

for the <i>th or default interactive {\ANUPQ} process,  direct  the  `pq'
program to set the output level of the `pq' program to <lev>.

*Note:* For those  familiar  with  the  `pq'  program,  `PqSetOutputLevel'
performs menu item 5 of the main (or advanced) $p$-Quotient menu, or  the
Standard Presentation menu.

\>PqEvaluateIdentities( <i> [: Identities := <funcs> ]) F
\>PqEvaluateIdentities([: Identities := <funcs> ]) F

for the  <i>th  or  default  interactive  {\ANUPQ}  process,  invoke  the
evaluation  of  identities  defined  by  the  `Identities'  option,   and
eliminate any redundant pc generators formed. Since a previous  value  of
`Identities'  is  saved  in  the  data  record  of  the  process,  it  is
unnecessary to pass the `Identities' if set previously.

*Note:* This function is mainly implemented at the {\GAP} level. It  does
not correspond to a menu item of the `pq' program.

\goodbreak%
*Commands from the Main $p$-Quotient menu*

\>PqPcPresentation( <i> : <options> ) F
\>PqPcPresentation( : <options> ) F

for the <i>th or default interactive {\ANUPQ} process,  direct  the  `pq'
program to compute the pc presentation of  the  quotient  (determined  by
<options>) of the group of the process, which for process <i>  is  stored
as `ANUPQData.io[<i>].group'.

The  possible  <options>  are  the  same  as  for  the  interactive  `Pq'
(see~"Pq!interactive") function, except  for  `RedoPcp'  (which,  in  any
case, would be superfluous), namely: `Prime',  `ClassBound',  `Exponent',
`Relators', `GroupName',  `Metabelian',  `Identities'  and  `OutputLevel'
(see  Chapter~"ANUPQ  options"  for  a  detailed  description  for  these
options). The option `Prime'  is  required  unless  already  provided  to
`PqStart'.

*Notes* 

The pc presentation is held by the `pq'  program.  In  contrast  to  `Pq'
(see~"Pq!interactive"),    no    {\GAP}    pc    group    is    returned;
see~`PqCurrentGroup' ("PqCurrentGroup") if  you  need  the  corresponding
{\GAP} pc group.

`PqPcPresentation(<i>:  <options>);'  is  roughly   equivalent   to   the
following sequence of low-level commands:

\){\kernttindent}PqPcPresentation(<i>: <opts>); \#class 1 call
\){\kernttindent}for c in [2 .. <class>] do
\){\kernttindent}{\quad}PqNextClass(<i>);
\){\kernttindent}od;

where <opts> is <options> except with the `ClassBound' option set  to  1,
and <class> is either the maximum class of a <p>-quotient of the group of
the process  or  the  user-supplied  value  of  the  option  `ClassBound'
(whichever is smaller). If the `Identities' option has been set, both the
first `PqPcPresentation' class 1 call and the `PqNextClass' calls  invoke
`PqEvaluateIdentities(<i>);' as their final step.

For those familiar with the  `pq'  program,  `PqPcPresentation'  performs
menu item 1 of the main $p$-Quotient menu.

\>PqSavePcPresentation( <i>, <filename> ) F
\>PqSavePcPresentation( <filename> ) F

for the <i>th or default interactive {\ANUPQ} process,  direct  the  `pq'
program to save the pc presentation previously computed for the  quotient
of the group of that process to the file with  name  <filename>.  If  the
first character of the  string  <filename>  is  not  `/',  <filename>  is
assumed to be the path of a writable file relative to  the  directory  in
which  {\GAP}  was  started.  A   saved   file   may   be   restored   by
`PqRestorePcPresentation' (see~"PqRestorePcPresentation").

*Note:* For those familiar with the `pq'  program,  `PqSavePcPresentation'
performs menu item 2 of the main $p$-Quotient menu.

\>PqRestorePcPresentation( <i>, <filename> ) F
\>PqRestorePcPresentation( <filename> ) F

for the <i>th or default interactive {\ANUPQ} process,  direct  the  `pq'
program to restore the pc presentation previously saved to <filename>, by
`PqSavePcPresentation'   (see~"PqSavePcPresentation").   If   the   first
character of the string <filename> is not `/', <filename> is  assumed  to
be the path of a readable file relative to the directory in which  {\GAP}
was started.

*Note:*
For  those  familiar  with  the  `pq'  program,  `PqRestorePcPresentation'
performs menu item 3 of the main $p$-Quotient menu.

\>PqNextClass( <i> [: QueueFactor ]) F
\>PqNextClass([: QueueFactor ]) F

for the <i>th or default interactive {\ANUPQ} process, direct the `pq' to
calculate the next class of `ANUPQData.io[<i>].group'.

\atindex{option QueueFactor}{@option \noexpand`QueueFactor'}
`PqNextClass'  accepts  the  option   `QueueFactor'   (see   also~"option
QueueFactor") which should be a positive integer  if  automorphisms  have
been previously supplied. If the `pq' program requires a queue factor  and
none is supplied via the option `QueueFactor' a default of 15 is taken.

*Notes*

The single command: `PqNextClass(<i>);' is equivalent to executing

\){\kernttindent}PqComputePCover(<i>);
\){\kernttindent}PqCollectDefiningRelations(<i>);
\){\kernttindent}PqDoExponentChecks(<i>);
\){\kernttindent}PqEliminateRedundantGenerators(<i>);

If the `Identities' option is set the `PqEliminateRedundantGenerators(<i>);'
step is essentially replaced by `PqEvaluateIdentities(<i>);' (which invokes
its own elimination of redundant generators).

For those familiar with the `pq' program, `PqNextClass' performs menu item
6 of the main $p$-Quotient menu.

\>PqComputePCover( <i> ) F
\>PqComputePCover() F

for the <i>th or default interactive {\ANUPQ} process, direct the `pq' to
compute the $p$-covering group of `ANUPQData.io[<i>].group'.  In contrast
to the function  `PqPCover'  (see~"PqPCover"),  this  function  does  not
return a {\GAP} pc group.

*Notes*

The single command: `PqComputePCover(<i>);' is equivalent to executing
\goodbreak%

\){\kernttindent}PqSetupTablesForNextClass(<i>);
\){\kernttindent}PqTails(<i>, 0);
\){\kernttindent}PqDoConsistencyChecks(<i>, 0, 0);
\){\kernttindent}PqEliminateRedundantGenerators(<i>);

For those familiar with the `pq' program, `PqComputePCover' performs  menu
item 7 of the main $p$-Quotient menu.

*Commands from the Advanced $p$-Quotient menu*

\>PqCollect( <i>, <word> ) F
\>PqCollect( <word> ) F

for the <i>th or default interactive {\ANUPQ} process, instruct the  `pq'
program to do a collection on <word>, a word in the current pc generators
(the form of <word> required is described below). `PqCollect' returns the
resulting word of the collection as a list of generator number,  exponent
pairs (the same form as the second allowed  input  form  of  <word>;  see
below).

The argument <word> may be input in either of the following ways:

\beginlist%ordered

\item{1.}
<word> may be a string, where the <i>th pc generator  is  represented  by
`x<i>', e.g.~`"x3*x2^2*x1"'. This way is quite versatile  as  parentheses
and left-normed commutators -- using square brackets, in the same way  as
`PqGAPRelators' (see~"PqGAPRelators") -- are permitted; <word> is checked
for correct syntax via `PqParseWord' (see~"PqParseWord").

\item{2.}
Otherwise, <word> must be a list of generator number, exponent  pairs  of
integers, i.e.~ each pair represents a ``syllable'' so that  `[  [3,  1],
[2, 2], [1, 1] ]' represents the same word as that of the  example  given
for the first allowed form of <word>.

\endlist

*Note:* For those familiar with the  `pq'  program,  `PqCollect'  performs
menu item 1 of the Advanced $p$-Quotient menu.

\>PqSolveEquation( <i>, <a>, <b> ) F
\>PqSolveEquation( <a>, <b> ) F

for the  <i>th or default  interactive {\ANUPQ} process, direct  the `pq'
program to solve $<a>  * <x> = <b>$ for <x>, where  <a> and <b> are words
in the pc generators. For the  representation  of  these  words  see  the
description of the function `PqCollect' ("PqCollect").

*Note:* 
For those familiar  with  the  `pq'  program,  `PqSolveEquation'  performs
menu item 2 of the Advanced $p$-Quotient menu.

\>PqCommutator( <i>, <words>, <pow> ) F
\>PqCommutator( <words>, <pow> ) F

for the <i>th or default interactive {\ANUPQ} process, instruct the  `pq'
program to compute the left normed commutator  of  the  list  <words>  of
words in the current pc generators raised to the integer power <pow>, and
return the resulting word as a list of generator number, exponent  pairs.
The form required for each word of <words> is the same as  that  required
for the <word> argument of `PqCollect' (see~"PqCollect"). The form of the
output word is also the same as for `PqCollect'.

*Note:*
For those familiar with the `pq' program,  `PqCommutator'  performs  menu
item 3 of the Advanced $p$-Quotient menu.

\>PqSetupTablesForNextClass( <i> ) F
\>PqSetupTablesForNextClass() F

for the <i>th or default interactive {\ANUPQ} process,  direct  the  `pq'
program  to  set  up  tables  for  the  next  class.  As  as  side-effect,
after   `PqSetupTablesForNextClass(<i>)'   the    value    returned    by
`PqPClass(<i>)' will be one more than it was previously.

*Note:* 
For those familiar  with  the  `pq'  program,  `PqSetupTablesForNextClass'
performs menu item 6 of the Advanced $p$-Quotient menu.

\>PqTails( <i>, <weight> ) F
\>PqTails( <weight> ) F

for the <i>th or default interactive {\ANUPQ} process,  direct  the  `pq'
program to compute and add tails of weight <weight> if <weight> is in  the
integer range `[2 .. PqPClass(<i>)]' (assuming <i> is the number  of  the
process, even in the default case) or for all weights if `<weight> = 0'.

If <weight> is non-zero, then tails that  introduce  new  generators  for
only weight <weight> are computed and added, and  in  this  case  and  if
`<weight> \< PqPClass(<i>)', it is assumed that the tails that  introduce
new generators for  each  weight  from  `PqPClass(<i>)'  down  to  weight
`<weight>  +  1'  have  already  been  added.  You  may  wish   to   call
`PqSetMetabelian' (see~"PqSetMetabelian") prior to calling `PqTails'.

*Notes*

For its use in the context of finding the next class  see  "PqNextClass";
in     particular,     a     call     to      `PqSetupTablesForNextClass'
(see~"PqSetupTablesForNextClass")  needs  to  have  been  made  prior  to
calling `PqTails'.

The single command: `PqTails(<i>, <weight>);' is equivalent to

\){\kernttindent}PqComputeTails(<i>, <weight>);
\){\kernttindent}PqAddTails(<i>, <weight>);

For those familiar with the `pq' program, `PqTails' uses menu  item  7  of
the Advanced $p$-Quotient menu.

\>PqComputeTails( <i>, <weight> ) F
\>PqComputeTails( <weight> ) F

for the <i>th or default interactive {\ANUPQ} process,  direct  the  `pq'
program to compute tails of weight <weight> if <weight> is in the  integer
range `[2 .. PqPClass(<i>)]' (assuming <i> is the number of the  process,
even in the default case) or for all  weights  if  `<weight>  =  0'.  See
`PqTails' ("PqTails") for more details.

*Note:*
For those familiar with the `pq' program, `PqComputeTails' uses menu  item
7 of the Advanced $p$-Quotient menu.

\>PqAddTails( <i>, <weight> ) F
\>PqAddTails( <weight> ) F

for the <i>th or default interactive {\ANUPQ} process,  direct  the  `pq'
program to add the  tails  of  weight  <weight>,  previously  computed  by
`PqComputeTails' (see~"PqComputeTails"), if <weight> is  in  the  integer
range `[2 .. PqPClass(<i>)]' (assuming <i> is the number of the  process,
even in the default case) or for all  weights  if  `<weight>  =  0'.  See
`PqTails' ("PqTails") for more details.

*Note:*
For those familiar with the `pq' program, `PqAddTails' uses menu item 7 of
the Advanced $p$-Quotient menu.

\>PqDoConsistencyChecks( <i>, <weight>, <type> ) F
\>PqDoConsistencyChecks( <weight>, <type> ) F

for the <i>th or default interactive  {\ANUPQ}  process,  do  consistency
checks for weight <weight> if <weight> is in the  integer  range  `[3  ..
PqPClass(<i>)]' (assuming <i> is the number of the process)  or  for  all
weights if `<weight> = 0', and for type <type> if <type> is in the  range
`[1, 2, 3]' (see below) or for all types if `<type> = 0'. (For its use in
the context of finding the next class see "PqNextClass".)

The  *type*   of   a   consistency   check   is   defined   as   follows.
`PqDoConsistencyChecks(<i>, <weight>, <type>)' for  <weight>  in  `[3  ..
PqPClass(<i>)]' and the given value of <type> invokes the  equivalent  of
the following `PqDoConsistencyCheck' calls (see~"PqDoConsistencyCheck"):

\beginitems

`<type> = 1':&
`PqDoConsistencyCheck(<i>, <a>, <a>, <a>)' checks `2 * PqWeight(<i>, <a>)
+ 1 = <weight>', for pc generators of index <a>.

`<type> = 2':&
`PqDoConsistencyCheck(<i>, <b>, <b>, <a>)' checks for  pc  generators  of
indices <b>, <a>  satisfying  `<b>  >  <a>'  and  `PqWeight(<i>,  <b>)  +
PqWeight(<i>, <a>) + 1 = <weight>'.

`<type> = 3':&
`PqDoConsistencyCheck(<i>, <c>, <b>, <a>)' checks for  pc  generators  of
indices <c>, <b>, <a> satisfying `<c> > <b> > <a>' and  the  sum  of  the
weights of these generators equals <weight>.

\enditems

*Notes*

`PqWeight(<i>, <j>)' returns the weight of the <j>th  pc  generator,  for
process <i> (see~"PqWeight").

It is assumed that tails for the given weight (or weights)  have  already
been added (see~"PqTails").

For those familiar with the `pq' program, `PqDoConsistencyChecks' performs
menu item 8 of the Advanced $p$-Quotient menu.

\>PqCollectDefiningRelations( <i> ) F
\>PqCollectDefiningRelations() F

for the <i>th or default interactive {\ANUPQ} process,  direct  the  `pq'
program to collect the images of the defining relations of the original fp
group of the process, with respect to the current pc presentation, in the
context of finding the  next  class  (see~"PqNextClass").  If  the  tails
operation  is  not  complete  then  the  relations   may   be   evaluated
incorrectly.

*Note:*
For those familiar with  the  `pq'  program,  `PqCollectDefiningRelations'
performs menu item 9 of the Advanced $p$-Quotient menu.

\>PqCollectWordInDefiningGenerators( <i>, <word> ) F
\>PqCollectWordInDefiningGenerators( <word> ) F

for  the   <i>th  or  default  interactive  {\ANUPQ}   process,  take   a
user-defined word <word> in  the  defining  generators  of  the  original
presentation of the fp or pc group of  the  process.  Each  generator  is
mapped into the current  pc  presentation,  and  the  resulting  word  is
collected with respect to the current pc presentation. The result of  the
collection is returned as a list of generator number, exponent pairs.

The <word> argument may be input  in either of the two ways described for
`PqCollect' (see~"PqCollect").

*Note:*
For those familiar with the  `pq'  program,  `PqCollectDefiningGenerators'
performs menu item 23 of the Advanced $p$-Quotient menu.

\>PqCommutatorDefiningGenerators( <i>, <words>, <pow> ) F
\>PqCommutatorDefiningGenerators( <words>, <pow> ) F

for the <i>th or  default  interactive  {\ANUPQ}  process,  take  a  list
<words> of user-defined words in the defining generators of the  original
presentation of the fp or pc group of the process, and an  integer  power
<pow>. Each generator is mapped into the  current  pc  presentation.  The
list <words> is interpreted as a left-normed  commutator  which  is  then
raised  to  <pow>  and  collected  with  respect  to   the   current   pc
presentation. The result of the collection  is  returned  as  a  list  of
generator number, exponent pairs.

\goodbreak%
*Note*
For those familiar with the `pq' program, `PqCommutatorDefiningGenerators'
performs menu item 24 of the Advanced $p$-Quotient menu.

\>PqDoExponentChecks( <i> [: Bounds := <list> ]) F
\>PqDoExponentChecks([: Bounds := <list> ]) F

for the  <i>th or  default interactive {\ANUPQ}  process, direct  the `pq'
program to do exponent checks for weights (inclusively) between the bounds
of `Bounds' or for all weights  if `Bounds' is not given. The value <list>
of `Bounds' (assuming the interactive process is numbered <i>) should be a
list of two integers <low>, <high>  satisfying $1 \le <low> \le <high> \le
`PqPClass(<i>)'$ (see~"PqPClass").  If no exponent law has been specified,
no exponent checks are performed.

*Note:*
For those familiar with the `pq'  program,  `PqDoExponentChecks'  performs
menu item 10 of the Advanced $p$-Quotient menu.

\>PqEliminateRedundantGenerators( <i> ) F
\>PqEliminateRedundantGenerators() F

for the <i>th or default interactive {\ANUPQ} process, direct  the  `pq'
program to eliminate redundant generators of the current $p$-quotient.

*Note:* 
For those familiar with the `pq' program, `PqEliminateRedundantGenerators'
performs menu item 11 of the Advanced $p$-Quotient menu.

\>PqRevertToPreviousClass( <i> ) F
\>PqRevertToPreviousClass() F

for the <i>th or default interactive {\ANUPQ} process, direct  the  `pq'
program to abandon the current class and revert to the previous class.

*Note:*
For  those  familiar  with  the  `pq'  program,  `PqRevertToPreviousClass'
performs menu item 12 of the Advanced $p$-Quotient menu.

\>PqSetMaximalOccurrences( <i>, <noccur> ) F
\>PqSetMaximalOccurrences( <noccur> ) F

for the  <i>th or default  interactive {\ANUPQ} process, direct  the `pq'
program  to set maximal  occurrences of  the weight  1 generators  in the
definitions of pcp  generators of the group of the  process.  This can be
used  to  avoid the  definition  of generators  of  which  one knows  for
theoretical reasons that they would be eliminated later on.

The argument <noccur>  must be a list of  non-negative integers of length
the  number  of  weight  1  generators  (i.e.~the rank  of  the  class  1
$p$-quotient  of  the group  of  the  process). An  entry  of  `0' for  a
particular generator  indicates that there is  no limit on  the number of
occurrences for the generator.


*Note:*
For  those  familiar  with  the  `pq'  program,  `PqSetMaximalOccurrences'
performs menu item 13 of the Advanced $p$-Quotient menu.

\>PqSetMetabelian( <i> ) F
\>PqSetMetabelian() F

for the <i>th or default interactive {\ANUPQ} process,  direct  the  `pq'
program to enforce metabelian-ness.

*Note:* 
For those familiar  with  the  `pq'  program,  `PqSetMetabelian'  performs
menu item 14 of the Advanced $p$-Quotient menu.

\>PqDoConsistencyCheck( <i>, <c>, <b>, <a> ) F
\>PqDoConsistencyCheck( <c>, <b>, <a> ) F
\>PqJacobi( <i>, <c>, <b>, <a> ) F
\>PqJacobi( <c>, <b>, <a> ) F

for the <i>th or default interactive {\ANUPQ} process,  direct  the  `pq'
program to do the consistency check for the  pc  generators  with  indices
<c>, <b>, <a> which should be non-increasing positive integers, i.e.~$<c>
\ge <b> \ge <a>$.

There are 3 types of consistency checks:
$$
\matrix{
(a^n)a &=& a(a^n)                               \hfill     &{\rm (Type\ 1)}\cr
(b^n)a &=& b^{(n-1)}(ba), b(a^n) = (ba)a^{(n-1)}\hfill     &{\rm (Type\ 2)}\cr
c(ba)  &=& (cb)a                                \hfill     &{\rm (Type\ 3)}\cr
}
$$
The reason some people talk about Jacobi relations instead of consistency
checks becomes clear when one looks at the consistency check of type 3:
$$
\matrix{
c(ba) &=& a c[c,a] b[b,a] = acb [c,a][c,a,b][b,a] = \dots\hfill\cr
(cb)a &=& b c[c,b] a = a b[b,a] c[c,a] [c,b][c,b,a] 
                     = abc [b,a] [b,a,c] [c,a] [c,b] [c,b,a] = \dots\hfill\cr
}
$$
Each collection  would  normally  carry  on  further.  But  one  can  see
already that no other commutators of weight 3 will occur. After all terms
of weight one and weight two have been moved to the left we end up with:
$$
\matrix{
  &abc [b,a] [c,a] [c,b] [c,a,b] \dots\hfill\cr
= &abc [b,a] [c,a] [c,b] [c,b,a] [b,a,c] \dots\hfill\cr
}
$$
Modulo terms of weight 4 this is equivalent to
$$
[c,a,b] [b,c,a] [a,b,c] = 1
$$
which is the Jacobi identity.

See also `PqDoConsistencyChecks' ("PqDoConsistencyChecks").

*Note:*
For those familiar  with  the  `pq'  program,  `PqDoConsistencyCheck'  and
`PqJacobi' perform menu item 15 of the Advanced $p$-Quotient menu.

\>PqCompact( <i> ) F
\>PqCompact() F

for the  <i>th or default  interactive {\ANUPQ} process, direct  the `pq'
program to do  a compaction of its work space.  This  function is safe to
perform only at certain points in time.

*Note:*
For those familiar with the `pq' program, `PqCompact' performs  menu  item
16 of the Advanced $p$-Quotient menu.

\>PqEchelonise( <i> ) F
\>PqEchelonise() F

for the <i>th or default interactive {\ANUPQ} process,  direct  the  `pq'
program to echelonise the word most recently collected by `PqCollect'  or
`PqCommutator' against the relations of the current pc presentation,  and
return the number of  the  generator  made  redundant  or  `fail'  if  no
generator was made redundant. A call to `PqCollect' (see~"PqCollect")  or
`PqCommutator' (see~"PqCommutator") needs to be performed prior to  using
this command.

*Note:*
For those familiar with the `pq'  program,  `PqEchelonise'  performs  menu
item 17 of the Advanced $p$-Quotient menu.

\>PqSupplyAutomorphisms( <i>, <mlist> ) F
\>PqSupplyAutomorphisms( <mlist> ) F

for  the  <i>th  or  default  interactive {\ANUPQ}  process,  supply  the
automorphism  data  provided  by   the  list  <mlist>  of  matrices  with
non-negative integer coefficients.  Each  matrix in <mlist> describes one
automorphism in the following way.

\beginlist%unordered
\item{--}The rows of each matrix  correspond  to  the  pc  generators  of
weight one.

\item{--}Each  row  is  the  exponent  vector  of  the   image   of   the
corresponding weight one generator under the respective automorphism.

\endlist

*Note:* 
For those familiar with the  `pq'  program,  `PqSupplyAutomorphisms'  uses
menu item 18 of the Advanced $p$-Quotient menu.

\>PqExtendAutomorphisms( <i> ) F
\>PqExtendAutomorphisms() F

for the <i>th or default interactive {\ANUPQ} process,  direct  the  `pq'
program to extend automorphisms of the $p$-quotient of the previous class
to the $p$-quotient of the present class.     

*Note:*
For those familiar with the  `pq'  program,  `PqExtendAutomorphisms'  uses
menu item 18 of the Advanced $p$-Quotient menu.

\>PqApplyAutomorphisms( <i>, <qfac> ) F
\>PqApplyAutomorphisms( <qfac> ) F

for the <i>th or default interactive {\ANUPQ} process,  direct  the  `pq'
program to apply automorphisms; <qfac> is the queue factor e.g. `15'.

*Note:* 
For those familiar with  the  `pq'  program,  `PqCloseRelations'  performs
menu item 19 of the Advanced $p$-Quotient menu.

\>PqDisplayStructure( <i> [: Bounds := <list> ]) F
\>PqDisplayStructure([: Bounds := <list> ]) F

for the <i>th or default interactive {\ANUPQ} process,  direct  the  `pq'
program  to  display  the  structure  for  the  pcp  generators   numbered
(inclusively) between the bounds of `Bounds' or  for  all  generators  if
`Bounds' is not  given.  The  value  <list>  of  `Bounds'  (assuming  the
interactive process is numbered <i>) should be a  list  of  two  integers
<low>,   <high>   satisfying   $1    \le    <low>    \le    <high>    \le
`PqNrPcGenerators(<i>)'$  (see~"PqNrPcGenerators").  `PqDisplayStructure'
also accepts the option `OutputLevel' (see "option OutputLevel").

*Explanation of output*

New  generators are  defined as  commutators of  previous  generators and
generators  of  class 1  or  as $p$-th  powers  of  generators that  have
themselves been defined as $p$-th powers. A generator is never defined as
$p$-th power of a commutator.

Therefore, there are two cases: all the numbers on the righthand side are
either the same or  they  differ.  Below,  `g<i>'  refers  to  the  <i>th
defining generator.

\beginlist%unordered

\item{$\bullet$}
If the righthand side numbers are all the same, then the generator  is  a
$p$-th power (of a $p$-th power of a $p$-th power, etc.). The  number  of
repeated digits say how often a $p$-th power has to be taken.

In the following example, the generator number 31 is the  eleventh  power
of generator 17 which in turn is an eleventh power and so on:

\begintt
#I  31 is defined on 17^11 = 1 1 1 1 1 
\endtt
                    
So generator 31 is obtained by taking the eleventh power of  generator  1
five times.

\item{$\bullet$}
If the numbers are not all the same, the generator is defined by a
commutator.   If the first two generator numbers differ, the generator is
defined as a left-normed commutator of the weight one generators, e.g.

\begintt
#I  19 is defined on [11, 1] = 2 1 1 1 1    
\endtt
        
Here, generator 19 is defined as  the  commutator  of  generator  11  and
generator  1  which  is  the   same   as   the   left-normed   commutator
`[x2, x1, x1, x1, x1]'. One can check this by tracing back the definition
of generator 11 until one gets to a generator of class 1.


\item{$\bullet$}
If the first two generator numbers are identical, then the left most
component of the left-normed commutator is a $p$-th power, e.g.

\begintt
#I  25 is defined on [14, 1] = 1 1 2 1 1 
\endtt

In this example, generator 25 is defined as commutator  of  generator  14
and generator 1. The left-normed commutator is
$$
[(`x1'^{11})^{11}, `x2', `x1', `x1']
$$
Again, this can be verified by tracing back the definitions.

\endlist

*Note:*
For those familiar with the `pq'  program,  `PqDisplayStructure'  performs
menu item 20 of the Advanced $p$-Quotient menu.

\>PqDisplayAutomorphisms( <i> [: Bounds := <list> ]) F
\>PqDisplayAutomorphisms([: Bounds := <list> ]) F

for the <i>th or default interactive {\ANUPQ} process,  direct  the  `pq'
program to display the automorphism actions on the pcp generators numbered
(inclusively) between the bounds of `Bounds' or  for  all  generators  if
`Bounds' is not  given.  The  value  <list>  of  `Bounds'  (assuming  the
interactive process is numbered <i>) should be a  list  of  two  integers
<low>,   <high>   satisfying   $1    \le    <low>    \le    <high>    \le
`PqNrPcGenerators(<i>)'$  (see~"PqNrPcGenerators").  `PqDisplayStructure'
also accepts the option `OutputLevel' (see "option OutputLevel").

*Note:*
For  those  familiar  with  the  `pq'  program,   `PqDisplayAutomorphisms'
performs menu item 21 of the Advanced $p$-Quotient menu.

\>PqWritePcPresentation( <i>, <filename> ) F
\>PqWritePcPresentation( <filename> ) F

for the <i>th or default interactive {\ANUPQ} process,  direct  the  `pq'
program to write a pc presentation of a previously-computed  quotient  of
the group of that process, to the file with  name  <filename>.  Here  the
group of a process is the one given as first argument when `PqStart'  was
called to initiate that process (for process <i> the group is  stored  as
`ANUPQData.io[<i>].group').  If  the  first  character  of   the   string
<filename> is not `/', <filename> is assumed to be the path of a writable
file relative to the directory in which  {\GAP}  was  started.  If  a  pc
presentation has not been previously computed by the `pq'  program,  then
`pq'   is   called   to   compute   it   first,   effectively    invoking
`PqPcPresentation' (see~"PqPcPresentation").

*Note:* For those familiar with the `pq' program, `PqPcWritePresentation'
performs menu item 25 of the Advanced $p$-Quotient menu.

%We may include this in the future.
%\>PqWriteCompactDescription( <i> ) F
%\>PqWriteCompactDescription() F
%
%for the <i>th or default interactive {\ANUPQ} process,  direct  the  `pq'
%program to write a compact description 
%
%*OF ....*
%
%to a file.
%
%*Note:* 
%For those familiar  with  the  `pq'  program,  `PqWriteCompactDescription'
%performs menu item 26 of the Advanced $p$-Quotient menu.

*Commands from the Standard Presentation menu*

\>PqSPComputePcpAndPCover( <i> : <options> ) F
\>PqSPComputePcpAndPCover( : <options> ) F

for the <i>th or default interactive {\ANUPQ} process, directs  the  `pq'
program to compute for the group of that process a pc presentation  up  to
the $p$-quotient of maximum class or the value of the option `ClassBound'
and the $p$-cover of that  quotient,  and  sets  up  tabular  information
required for computation of a standard presentation. Here the group of  a
process is the one given as first argument when `PqStart' was  called  to
initiate  that  process  (for  process  <i>  the  group  is   stored   as
`ANUPQData.io[<i>].group').

The possible <options> are `Prime', `ClassBound', `Relators', `Exponent',
`Metabelian' and `OutputLevel' (see Chapter~"ANUPQ Options" for  detailed
descriptions of these options). The option `Prime' is normally determined
via `PrimePGroup', and so is not required unless the group  doesn't  know
it's a $p$-group and `HasPrimePGroup' returns `false'.

*Note:*
For  those  familiar  with  the  `pq'  program,  `PqSPComputePcpAndPCover'
performs option 1 of the Standard Presentation menu.

\>PqSPStandardPresentation( <i>[, <mlist>][: <options>]) F
\>PqSPStandardPresentation( [<mlist>][: <options>]) F

for the <i>th or default interactive {\ANUPQ} process, inputs data  given
by <options> to compute a standard presentation for  the  group  of  that
process.  If  argument  <mlist>  is  given  it  is  assumed  to  be   the
automorphism group data required. Otherwise it is assumed that a call  to
either      `Pq'      (see~"Pq!interactive")      or      `PqEpimorphism'
(see~"PqEpimorphism!interactive") has generated a $p$-quotient  and  that
{\GAP} can compute  its  automorphism  group  from  which  the  necessary
automorphism group data can be derived. The group of the process  is  the
one given as first argument when `PqStart' was  called  to  initiate  the
process (for process <i> the group is stored as `ANUPQData.io[<i>].group'
and     the     $p$-quotient     if     existent     is     stored     as
`ANUPQData.io[<i>].pQuotient').  If  <mlist>   is   not   given   and   a
$p$-quotient of the group has not been  previously  computed  a  class  1
$p$-quotient is computed.

`PqSPStandardPresentation' accepts three options, all optional:

\beginlist%unordered

\atindex{option ClassBound}{@option \noexpand`ClassBound'}
\item{}`ClassBound := <n>'

\atindex{option PcgsAutomorphisms}{@option \noexpand`PcgsAutomorphisms'}
\item{}`PcgsAutomorphisms'

\atindex{option StandardPresentationFile}%
{@option \noexpand`StandardPresentationFile'}
\item{}`StandardPresentationFile := <filename>'

\endlist

If `ClassBound' is omitted it defaults to 63.

Detailed descriptions of the above options may be found in Chapter~"ANUPQ
options".

*Note:* For those familiar with  the  `pq'  program,  `PqSPPcPresentation'
performs menu item 2 of the Standard Presentation menu.

\>PqSPSavePresentation( <i>, <filename> ) F
\>PqSPSavePresentation( <filename> ) F

for the <i>th or default interactive {\ANUPQ} process, directs  the  `pq'
program to save the standard  presentation  previously  computed  for  the
group of that process to the file with name <filename>, where  the  group
of a process is the one given as first argument when `PqStart' was called
to initiate that process. If the first character of the string <filename>
is not `/', <filename> is assumed to be  the  path  of  a  writable  file
relative to the directory in which {\GAP} was started.

*Note:* For those familiar with the `pq'  program,  `PqSPSavePresentation'
performs menu item 3 of the Standard Presentation menu.

\>PqSPCompareTwoFilePresentations( <i>, <f1>, <f2> ) F
\>PqSPCompareTwoFilePresentations( <f1>, <f2> ) F

for the <i>th or default interactive {\ANUPQ} process, direct  the  `pq'
program to compare the presentations in the files with names <f1> and <f2>
and returns `true' if they are identical and `false' otherwise. For  each
of the strings <f1> and <f2>, if the first character is not a `/' then it
is assumed to be the path of a readable file relative to the directory in
which {\GAP} was started.

*Notes*

The presentations in files <f1> and  <f2> must have been generated by the
`pq' program but they do *not* need to be *standard* presentations. If If
the  presentations  in files  <f1>  and  <f2>  *have* been  generated  by
`PqSPStandardPresentation'    (see~"PqSPStandardPresentation")   then   a
`false' response  from `PqSPCompareTwoFilePresentations' says  the groups
defined by those presentations are *not* isomorphic.

For      those      familiar      with       the       `pq'       program,
`PqSPCompareTwoFilePresentations' performs menu item 6  of  the  Standard
Presentation menu.

\>PqSPIsomorphism( <i> ) F
\>PqSPIsomorphism() F

for the <i>th or default interactive {\ANUPQ} process,  direct  the  `pq'
program to compute the isomorphism mapping  from  the  $p$-group  of  the
process  to  its  standard  presentation.  This   function   provides   a
description      only;      for      a      {\GAP}      object,       use
`EpimorphismStandardPresentation'
(see~"EpimorphismStandardPresentation!interactive").

*Note:* For  those  familiar  with  the  `pq'  program,  `PqSPIsomorphism'
performs menu item 8 of the Standard Presentation menu.

*Commands from the Main $p$-Group Generation menu*

Note that the $p$-group generation commands can only be applied once  the
`pq' program has produced a pc presentation of some quotient group of the
``group of the process''.

\>PqPGSupplyAutomorphisms( <i>[, <mlist>] : <options> ) F
\>PqPGSupplyAutomorphisms([<mlist>] : <options> ) F

for the  <i>th or default  interactive {\ANUPQ} process, supply  the `pq'
program with the automorphism group  data needed for the current quotient
of the  group of  that process (for  process <i>  the group is  stored as
`ANUPQData.io[<i>].group').  For  a description of the  format of <mlist>
see~"PqSupplyAutomorphisms".      The      options      possible      are
`NumberOfSolubleAutomorphisms'    and     `RelativeOrders'.     (Detailed
descriptions of these options may be found in Chapter~"ANUPQ Options".)

If <mlist> is omitted, the automorphism data is determined from the group
of  the process  which must  have been  a $p$-group  in  pc presentation.

*Note:*
For  those  familiar  with  the  `pq'  program,  `PqPGSupplyAutomorphisms'
performs menu item 1 of the main $p$-Group Generation menu.

\>PqPGExtendAutomorphisms( <i> ) F
\>PqPGExtendAutomorphisms() F

for the <i>th  or default interactive {\ANUPQ} process,  direct  the `pq'
program  to   compute  the  extensions   of  the  automorphisms   of  the
$p$-quotient of  the previous  class to the  $p$-quotient of  the current
class.  You may wish to set the `InfoLevel' of `InfoANUPQ' to 2 (or more)
in order to see the output from the `pq' program (see~"InfoANUPQ").

*Note:*    
For  those  familiar  with  the  `pq'  program,  `PqPGExtendAutomorphisms'
performs menu item 2 of the main or advanced $p$-Group Generation menu. 

\>PqPGConstructDescendants( <i> : <options> ) F
\>PqPGConstructDescendants( : <options> ) F

for the  <i>th or default  interactive {\ANUPQ} process, direct  the `pq'
program to construct descendants  prescribed by <options>, and return the
number of descendants constructed (compare function~"PqDescendants" which
returns the list of descendants).  The options possible are `ClassBound',
`OrderBound',               `StepSize',              `PcgsAutomorphisms',
`RankInitialSegmentSubgroups',   `SpaceEfficient',  `CapableDescendants',
`AllDescendants',     `Exponent',     `Metabelian',     `BasicAlgorithm',
`CustomiseOutput'.  (Detailed descriptions of  these options may be found
in Chapter~"ANUPQ Options".)

`PqPGConstructDescendants' requires that the `pq' program  has  previously
computed a pc presentation and a $p$-cover for  a  $p$-quotient  of  some
class of the group of the process.

*Note:* 
For those  familiar  with  the  `pq'  program,  `PqPGConstructDescendants'
performs menu item 5 of the main $p$-Group Generation menu.

\>PqPGSetDescendantToPcp( <i>, <cls>, <n> ) F
\>PqPGSetDescendantToPcp( <cls>, <n> ) F
\>PqPGSetDescendantToPcp( <i> [: Filename := <name> ]) F
\>PqPGSetDescendantToPcp([: Filename := <name> ]) F
\>PqPGRestoreDescendantFromFile(<i>, <cls>, <n>) F
\>PqPGRestoreDescendantFromFile( <cls>, <n> ) F
\>PqPGRestoreDescendantFromFile( <i> [: Filename := <name> ]) F
\>PqPGRestoreDescendantFromFile([: Filename := <name> ]) F

for the <i>th or default interactive {\ANUPQ} process,  direct  the  `pq'
program to restore group <n> of class <cls> from a temporary file,  where
<cls> and <n> are positive integers,  or  the  group  stored  in  <name>.
`PqPGSetDescendantToPcp'    and    `PqPGRestoreDescendantFromFile'    are
synonyms;  they  make  sense  only  after  a  prior  call  to   construct
descendants          by          say           `PqPGConstructDescendants'
(see~"PqPGConstructDescendants")  or  the   interactive   `PqDescendants'
(see~"PqDescendants!interactive"). In the `Filename'  option  forms,  the
option defaults to the last filename in which a presentation  was  stored
by the `pq' program.

*Notes*

Since the  `PqPGSetDescendantToPcp'  and  `PqPGRestoreDescendantFromFile'
are intended to be used in calculation of further  descendants  the  `pq'
program computes  the  $p$-cover  of  the  restored  descendant.   Hence,
`PqCurrentGroup' used immediately after one of these commands returns the
$p$-cover of the restored descendant rather than the descendant itself.

For those familiar with the `pq'  program,  `PqPGSetDescendantToPcp'  and
`PqPGRestoreDescendantFromFile' perform  menu  item  3  of  the  main  or
advanced $p$-Group Generation menu.

\goodbreak%
*Commands from the Advanced $p$-Group Generation menu*

The   functions   below   perform    the    component    algorithms    of
`PqPGConstructDescendants' (see~"PqPGConstructDescendants"). You can  get
some idea of their usage by  trying  `PqExample("Nott-APG-Rel-i");'.  You
can get some idea of the  breakdown  of  `PqPGConstructDescendants'  into
these   functions    by    comparing    the    previous    output    with
`PqExample("Nott-PG-Rel-i");'. 

These functions are intended for  use only by ``experts''; please contact
the authors of the package if you genuinely have a need for them and need
any amplified descriptions.

\>PqAPGDegree( <i>, <step>, <rank> [: Exponent := <n> ]) F
\>PqAPGDegree( <step>, <rank> [: Exponent := <n> ]) F

%for the <i>th or default interactive {\ANUPQ} process,  direct  the  `pq'
%program  to  compute  definition  sets  and  return  the  degree  of  the
%permutation group. Here the step-size <step> and the rank <rank>  of  the
%initial segment subgroup are positive integers. See~"option Exponent" for
%the one recognised option `Exponent'.

for the  <i>th or default  interactive {\ANUPQ} process, direct  the `pq'
program to invoke menu item  6 of the Advanced $p$-Group Generation menu.
Here the step-size  <step> and the rank <rank>  are positive integers and
are the  arguments required by  the `pq' program.   See~"option Exponent"
for the one recognised option `Exponent'.

%*Note:* For those familiar with the `pq' program,  `PqAPGDegree'  performs
%menu item 6 of the Advanced $p$-Group Generation menu.

\>PqAPGPermutations( <i> : <options> ) F
\>PqAPGPermutations( : <options> ) F

%for the <i>th or default interactive {\ANUPQ} process,  direct  the  `pq'
%program to compute permutations of subgroups. 

for the  <i>th or default  interactive {\ANUPQ} process, direct  the `pq'
program to perform menu item 7 of the Advanced $p$-Group Generation menu.
Here   the   options   <options>  recognised   are   `PcgsAutomorphisms',
`SpaceEfficient',   `PrintAutomorphisms'  and   `PrintPermutations'  (see
Chapter~"ANUPQ Options" for details).

%*Note:* For those familiar  with  the  `pq'  program,  `PqAPGPermutations'
%performs menu item 7 of the Advanced $p$-Group Generation menu.

\>PqAPGOrbits( <i> : <options> ) F
\>PqAPGOrbits( : <options> ) F

%for the  <i>th or default  interactive {\ANUPQ} process, direct  the `pq'
%program to compute  the orbits of the automorphism  group, and return the
%number of orbits, if either a  summary or a complete listing (or both) of
%orbit information  was requested.  

for the  <i>th or default  interactive {\ANUPQ} process, direct  the `pq'
to perform menu item 8 of the Advanced $p$-Group Generation menu.

Here   the   options   <options>  recognised   are   `PcgsAutomorphisms',
`SpaceEfficient', and `CustomiseOutput'  (see Chapter~"ANUPQ Options" for
details).   For the  `CustomiseOutput'  option only  the  setting of  the
`orbit' is recognised (all other fields if set are ignored).

%*Note:* For those familiar with the `pq' program,  `PqAPGOrbits'  performs
%menu item 8 of the Advanced $p$-Group Generation menu.

\>PqAPGOrbitRepresentatives( <i> : <options> ) F
\>PqAPGOrbitRepresentatives(: <options> ) F

%for the  <i>th or default  interactive {\ANUPQ} process, direct  the `pq'
%program  to process  the  orbit representatives  and  output the  reduced
%$p$-cover to a  file. 

for the  <i>th or default  interactive {\ANUPQ} process, direct  the `pq'
to perform item 9 of the Advanced $p$-Group Generation menu.

The  options  <options>  may  be  any   selection   of   the   following:
`PcgsAutomorphisms',    `SpaceEfficient',    `Exponent',    `Metabelian',
`CapableDescendants' (or `AllDescendants'), `CustomiseOutput' (where only
the `group' and `autgroup' fields are  recognised)  and  `Filename'  (see
Chapter~"ANUPQ Options"  for  details).  If  `Filename'  is  omitted  the
reduced $p$-cover is written to the file `"redPCover"' in  the  temporary
directory whose name is stored in `ANUPQData.tmpdir'.

%*Note:*
%For those familiar  with  the  `pq'  program,  `PqAPGOrbitRepresentatives'
%performs option 9 of the Advanced $p$-Group Generation menu.

\>PqAPGSingleStage( <i> : <options> ) F
\>PqAPGSingleStage( : <options> ) F

%for the <i>th or default interactive {\ANUPQ} process,  direct  the  `pq'
%program to do a single stage of the descendants construction algorithm as
%prescribed  by  <options>.   

for the <i>th or default interactive {\ANUPQ} process,  direct  the  `pq'
to perform option 5 of the Advanced $p$-Group Generation menu.

The    possible     options    are    `StepSize',    `PcgsAutomorphisms',
`RankInitialSegmentSubgroups',   `SpaceEfficient',  `CapableDescendants',
`AllDescendants',   `Exponent',    `Metabelian',   `BasicAlgorithm'   and
`CustomiseOutput'. (Detailed  descriptions of these options  may be found
in Chapter~"ANUPQ Options".)

%*Note:*
%For those familiar with  the  `pq'  program,  `PqAPGSingleStage'  performs
%option 5 of the Advanced $p$-Group Generation menu.

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
\Section{Primitive Interactive ANUPQ Process Read/Write Functions}

For those familiar with using the `pq' program as a standalone we  provide
primitive read/write tools to communicate directly  with  an  interactive
{\ANUPQ} process, started via `PqStart'. For the most part, it is  up  to
the user to translate the output strings from `pq'  program  into  a  form
useful in {\GAP}.

\>PqRead( <i> ) F
\>PqRead() F

read a complete line of  {\ANUPQ}  output,  from  the  <i>th  or  default
interactive {\ANUPQ} process, if there is output to be read  and  returns
`fail' otherwise. When successful, the  line  is  returned  as  a  string
complete with trailing newline, colon, or question-mark character. Please
note that it is possible to be ``too  quick''  (i.e.~the  return  can  be
`fail' purely because the output from {\ANUPQ} is not there yet), but  if
`PqRead' finds any output at all, it waits for a complete line.  `PqRead'
also writes the line read via `Info' at `InfoANUPQ' level 2.  It  doesn't
try to distinguish banner and menu output from other output of  the  `pq'
program.

\>PqReadAll( <i> ) F
\>PqReadAll() F

read and return as many *complete* lines of  {\ANUPQ}  output,  from  the
<i>th or default interactive {\ANUPQ} process, as there are to  be  read,
*at the time of the call*,  as  a  list  of  strings  with  any  trailing
newlines removed and returns the empty list otherwise.  `PqReadAll'  also
writes each line read via `Info' at `InfoANUPQ' level 2. It  doesn't  try
to distinguish banner and menu output  from  other  output  of  the  `pq'
program. Whenever `PqReadAll' finds only a partial line, it waits for  the
complete line, thus increasing the probability that it has  captured  all
the output to be had from {\ANUPQ}.

\>PqReadUntil( <i>, <IsMyLine> ) F
\>PqReadUntil( <IsMyLine> ) F
\>PqReadUntil( <i>, <IsMyLine>, <Modify> ) F
\>PqReadUntil( <IsMyLine>, <Modify> ) F

read complete lines  of  {\ANUPQ}  output,  from  the  <i>th  or  default
interactive {\ANUPQ} process, ``chomps'' them (i.e.~removes any  trailing
newline character), emits them to `Info' at `InfoANUPQ' level 2  (without
trying to distinguish banner and menu output from  other  output  of  the
`pq' program), and applies the function <Modify> (where <Modify>  is  just
the identity map/function for the first two forms)  until  a  ``chomped''
line  <line>  for  which  `<IsMyLine>(  <Modify>(<line>)  )'   is   true.
`PqReadUntil' returns the list of <Modify>-ed ``chomped'' lines read.

*Notes:* 
When provided by the user, <Modify> should be a function that  accepts  a
single string argument.

<IsMyLine> should be a function that is able  to  accept  the  output  of
<Modify> (or take a single string argument when <Modify> is not provided)
and should return a boolean.

If `<IsMyLine>( <Modify>(<line>) )' is  never  true,  `PqReadUntil'  will
wait indefinitely.

\>PqWrite( <i>, <string> ) F
\>PqWrite( <string> ) F

write <string> to the <i>th  or  default  interactive  {\ANUPQ}  process;
<string> must be in exactly the form the {\ANUPQ} standalone expects. The
command is echoed via `Info' at `InfoANUPQ' level 3 (with a  ```ToPQ> '''
prompt); i.e.~do `SetInfoLevel(InfoANUPQ, 3);' to see what is transmitted
to the `pq' program. `PqWrite' returns `true' if successful in writing  to
the stream of the interactive {\ANUPQ} process, and `fail' otherwise.

*Note:*
If `PqWrite' returns `fail' it means that the {\ANUPQ} process has died.

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