--- a/standalone-doc/guide.tex
+++ b/standalone-doc/guide.tex
@@ -99,7 +99,7 @@
 a $p$-group. The algorithm implemented here is described in O'Brien (1995).
 \end{enumerate}
 
-The pq program is written in traditional C and contains about 
+The anu-pq program is written in traditional C and contains about
 22000 lines of code.
 It was developed in a SUN OS environment and has been ported successfully
 to each of Solaris, AIX and Ultrix environments.  The interface and 
@@ -114,7 +114,7 @@
 distributions.
 The program is also distributed as part of Quotpic.
 
-Version 1.9 of the pq program (i.e.~the version you are currently reading
+Version 1.9 of the anu-pq program (i.e.~the version you are currently reading
 the documentation for) is configured to call {\sf GAP}, at least version
 4.5, to compute stabilisers when needed.
 
@@ -143,11 +143,11 @@
 directory containing those packages of {\sf ANUPQ} and {\sf AutPGrp}
 that are missing from the {\sf GAP} 4 distribution \texttt{pkg} directory.
 
-The pq program only needs {\sf GAP} for computing stabilisers when you
+The anu-pq program only needs {\sf GAP} for computing stabilisers when you
 answer ``No'' (\texttt{0}) to the question 
 ``\texttt{PAG-generating sequence for automorphism group?}''.
 If you neglect to add: ``\verb|GAP=|\textit{GAPPATH}'' to the \verb|make|
-command, never mind; the pq program first checks to see if the environment
+command, never mind; the anu-pq program first checks to see if the environment
 variable \verb|ANUPQ_GAP_EXEC| is set. For \texttt{csh} doing:
 
 \begin{quote}
@@ -173,7 +173,7 @@
 \emph{standard presentation algorithm} and \emph{automorphism group algorithm}
 implementations may be accessed via the ``Standard Presentation Menu".
 
-By default, the pq program opens with the Basic Menu [for {\it p}-Quotient
+By default, the anu-pq program opens with the Basic Menu [for {\it p}-Quotient
 Program] (see~\ref{sec:basic-menu}), which provides ``basic'' options for
 the {\it p}-Quotient algorithm and via options \texttt{8} and \texttt{9}
 gives (immediate) access to two further menus, 
@@ -184,7 +184,7 @@
 access to a further menu: the Advanced Menu for {\it p}-Group Generation 
 (see~\ref{sec:pgrp-gen-advanced-menu}).
 
-If the pq program is invoked with the \texttt{-i} switch (see
+If the anu-pq program is invoked with the \texttt{-i} switch (see
 Section~\ref{sec:runtime}), the program opens with the 
 Standard Presentation Menu (see Section~\ref{sec:stnd-pres-menu}) 
 which gives one immediate access to the 
@@ -192,10 +192,10 @@
 and via option \texttt{7} access to the Basic Menu
 and hence the other menus.
 
-To cleanly exit the pq program one must retrace one's path through the menus
+To cleanly exit the anu-pq program one must retrace one's path through the menus
 (by typing the number of the option that exits each menu or \texttt{0}).
-Exiting the menu that the pq program opened with (either the Basic Menu
-or the Standard Presentation Menu), exits the pq program.
+Exiting the menu that the anu-pq program opened with (either the Basic Menu
+or the Standard Presentation Menu), exits the anu-pq program.
 
 The Basic Menu, the main Menu for {\it p}-Group Generation and
 the Standard Presentation Menu
@@ -302,10 +302,10 @@
 \item 
 For each menu, the option \texttt{-1} lists the menu,
 and \texttt{0} exits the menu.
-To cleanly exit the pq program one must retrace one's path through the menus
+To cleanly exit the anu-pq program one must retrace one's path through the menus
 (by typing the number of the option that exits each menu or \texttt{0}).
-Exiting the menu that the pq program opened with (either the Basic Menu
-or the Standard Presentation Menu), exits the pq program.
+Exiting the menu that the anu-pq program opened with (either the Basic Menu
+or the Standard Presentation Menu), exits the anu-pq program.
 
 \item If the program cannot open a file for any reason, it simply 
 reports this and if not running interactively exits.
@@ -452,7 +452,7 @@
 \begin{description}
 \item[\texttt{1.\ Compute pc presentation}]\ \\ 
  When you select this option, you will be given the following sequence
- of prompts for input. [If you start the pq program with the \texttt{-k}
+ of prompts for input. [If you start the anu-pq program with the \texttt{-k}
  switch (see Section~\ref{sec:runtime}), you will not be prompted;
  instead you must supply input in the form:
  \begin{quote}
@@ -552,7 +552,7 @@
  provides access to the main menu for {\it p}-group generation.
 
 \item[\texttt{10.\ Exit from p-quotient program}]\ \\
- causes the pq program to exit, or if pq was called with the \texttt{-i}
+ causes the anu-pq program to exit, or if pq was called with the \texttt{-i}
  switch (see Section~\ref{sec:runtime}) exits to the Standard Presentation
  Menu. Selecting option \texttt{0} performs the same function.
 
@@ -641,7 +641,7 @@
 \textit{starting-group-identifier} is the group identifier defined at option
 \texttt{1} of the Basic Menu (see Section~\ref{sec:basic-menu})
 e.g.~if you use the \texttt{-k} switch (see Section~\ref{sec:runtime})
-when you started the pq program and settled for the default group identifier
+when you started the anu-pq program and settled for the default group identifier
 \texttt{G} then for class 2, the groups will be saved to a file with name:
 \texttt{G\_class2}. As before, the 
 program does not query the user before overwriting an existing file.
@@ -940,7 +940,7 @@
 to input a finite presentation for a group, to construct 
 a ``standard" presentation for a specified $p$-quotient of the group,
 and also to construct a description of the automorphism group of the $p$-group.
-To access this menu, you need to run the pq program 
+To access this menu, you need to run the anu-pq program
 with the \texttt{-i} run-time parameter switch (see~\ref{sec:runtime}).
 
 The appropriate way to view the standard presentation algorithm is the
@@ -1031,7 +1031,7 @@
    The assumption is that such a file containing the presentation and
    automorphism information for the $p$-group was generated from a previous
    run of the Standard Presentation algorithm. If you don't supply a
-   valid filename the pq program bails out of option \texttt{2}.
+   valid filename the anu-pq program bails out of option \texttt{2}.
  \end{description}
  %
  Whether or not you have previously selected option \texttt{1},
@@ -1083,7 +1083,7 @@
  to the generators for the standard presentation.
 
 \item[\texttt{9.\ Exit from program}]\ \\
- causes the pq program to exit.
+ causes the anu-pq program to exit.
  Selecting option \texttt{0} performs the same function.
 
 \end{description}
@@ -1099,7 +1099,7 @@
 \section{Examples}
 \subsection{A Basic Menu example}
 The following example exercises options within the Basic Menu
-(see~\ref{sec:basic-menu}). When the pq program is used without any switches
+(see~\ref{sec:basic-menu}). When the anu-pq program is used without any switches
 (see Section~\ref{sec:runtime}), it opens with the Basic Menu.
 \begin{verbatim}
 Basic Menu for p-Quotient Program
@@ -1150,15 +1150,15 @@
 
 This is essentially example \texttt{2gp} in the \texttt{examples} directory
 (except some of our \texttt{\#}\textit{comment}s are different).
-If the binary for the pq program is \texttt{pq}, then
+If the binary for the anu-pq program is \texttt{pq}, then
 \begin{quote}
  \verb|pq < 2gp|
 \end{quote}
 executes the example non-interactively, with something similar to the above
 output to the screen, minus the menu. Note that
-the menus from the pq program are only displayed when it is used interactively.
-A script file for the pq program (like \texttt{2gp}) should contain the
-responses that the pq program will expect, in the correct sequence.
+the menus from the anu-pq program are only displayed when it is used interactively.
+A script file for the anu-pq program (like \texttt{2gp}) should contain the
+responses that the anu-pq program will expect, in the correct sequence.
 
 \subsection{A {\it p}-Group Generation example}\label{sec:pgrp-gen-eg}
 
@@ -1171,7 +1171,7 @@
 if you run into problemsm, at this point.)
 
 For this example (which generates all groups with lower exponent-3 series of
-shape 2-2-3-1), the pq program is invoked without any of the switches
+shape 2-2-3-1), the anu-pq program is invoked without any of the switches
 of Section~\ref{sec:runtime}.
 
 \begin{verbatim}
@@ -1334,7 +1334,7 @@
 have not used the \texttt{-k} (keywords) runtime switch and to reduce the
 output we have only computed the standard presentation to class 3 (instead
 of class 10, as in the \verb|2gp| example).
-For this example, the pq program is invoked with the \texttt{-i} runtime
+For this example, the anu-pq program is invoked with the \texttt{-i} runtime
 switch (see Section~\ref{sec:runtime}), which gives us access to the
 Standard Presentation Menu (see Section~\ref{sec:stnd-pres-menu}).
 
@@ -1419,7 +1419,7 @@
 (see Section~\ref{sec:runtime}). For this example we are again
 using the Standard Presentation Menu; so we also use the \texttt{-i} runtime
 switch. The example is \verb|2gp.com| from the \texttt{isom} directory.
-If the binary for the pq program is \texttt{pq}, then
+If the binary for the anu-pq program is \texttt{pq}, then
 \begin{quote}
  \verb|pq -i -k < 2gp.com|
 \end{quote}
--- a/doc/basics.xml
+++ b/doc/basics.xml
@@ -2,7 +2,7 @@
 <Heading>Mathematical Background and Terminology</Heading>
 
 In this chapter we will give a brief description of the mathematical
-notions used in the algorithms implemented in the ANU <C>pq</C> program
+notions used in the algorithms implemented in the ANU <C>anu-pq</C> program
 that are made accessible from &GAP; through this package. For proofs
 and details we will point to relevant places in the published
 literature. Also we will try to give some explanation of terminology
@@ -91,7 +91,7 @@
 <Index>class</Index><Index>p-class</Index><!-- @<M>p</M>-class -->
 has <E><M>p</M>-class</E> <M>c</M> if <M>c</M> is the smallest integer such that <M>P_c(G)</M>
 is the trivial group. In this manual, as well as in much of the
-literature about the <C>pq</C>- and related algorithms, the <M>p</M>-class is
+literature about the <C>anu-pq</C>- and related algorithms, the <M>p</M>-class is
 often referred to simply by <E>class</E>.
 <P/>
 
@@ -198,7 +198,7 @@
 descriptions of the algorithm are given in <Cite Key="Sims94"/>.
 <P/>
 
-The <C>pq</C> algorithm successively determines the factor groups of the
+The <C>anu-pq</C> algorithm successively determines the factor groups of the
 groups of the <M>p</M>-central series of a finitely presented (fp) group
 <M>G</M>. If a bound <M>b</M> for the <M>p</M>-class is given, the algorithm will
 determine those factor groups up to at most <M>p</M>-class <M>b</M>. If the
@@ -291,14 +291,14 @@
 
 <Index>exponent check</Index>
 In this form, starting with a free group and imposing an exponent law
-(also referred to as an <E>exponent check</E>) the <C>pq</C> program has, in
+(also referred to as an <E>exponent check</E>) the <C>anu-pq</C> program has, in
 fact, found its most noted application in the determination of
 (restricted) Burnside groups (as reported in e.g.&nbsp;<Cite Key="HN80"/>,
 <Cite Key="NO96"/> and <Cite Key="VL90b"/>).
 <P/>
 
 Via a &GAP; program using the <Q>local</Q> interactive functions of the
-<C>pq</C> program made available through this interface also arbitrary laws
+<C>anu-pq</C> program made available through this interface also arbitrary laws
 can be imposed via the option <C>Identities</C>
 (see&nbsp;<Ref Label="option Identities" Style="Text"/>).
 </Subsection>
@@ -324,12 +324,12 @@
 <P/>
 
 The main practical problem here is the determination of these
-representatives. <Cite Key="OBr90"/> describes methods for this and the <C>pq</C>
+representatives. <Cite Key="OBr90"/> describes methods for this and the <C>anu-pq</C>
 program allows choices according to whether space or time limitations
 must be met.
 <P/>
 
-As well as the descendants of <M>G</M>, the <C>pq</C> program determines their
+As well as the descendants of <M>G</M>, the <C>anu-pq</C> program determines their
 automorphism groups from that of <M>G</M> (see&nbsp;<Cite Key="OBr95"/>), which is
 important for an iteration of the process; this has been used by
 Eamonn O'Brien, e.g.&nbsp;in the classification of the <M>2</M>-groups that are
--- a/doc/examples.xml
+++ b/doc/examples.xml
@@ -5,7 +5,7 @@
 These may be executed or displayed via the function <C>PqExample</C>
 (see&nbsp;<Ref Func="PqExample" Style="Text"/>). Each example resides in a file of the same name in the
 directory <C>examples</C>. Most of the examples are translations to &GAP; of
-examples provided for the <C>pq</C> standalone by Eamonn O'Brien; the
+examples provided for the <C>anu-pq</C> standalone by Eamonn O'Brien; the
 standalone examples are found in directories <C>standalone/examples</C>
 (<M>p</M>-quotient and <M>p</M>-group generation examples) and <C>standalone/isom</C>
 (standard presentation examples). The first line of each example
@@ -146,11 +146,11 @@
 
 The <C>Relators</C> option was included because computations involving words
 containing commutators that are pre-expanded by &GAP; before being
-passed to the <C>pq</C> program may run considerably more slowly, than the
+passed to the <C>anu-pq</C> program may run considerably more slowly, than the
 same computations being run with &GAP; pre-expansions avoided. The
 following examples demonstrate a case where the performance hit due to
 pre-expansion of commutators by &GAP; is a factor of order 100 (in order
-to see timing information from the <C>pq</C> program, we set the <C>InfoANUPQ</C>
+to see timing information from the <C>anu-pq</C> program, we set the <C>InfoANUPQ</C>
 level to 2).
 
 <P/>
@@ -191,7 +191,7 @@
 ]]></Log>
 
 Now we do the same calculation using the <C>Relators</C> option. In this way,
-the commutators are passed directly as strings to the <C>pq</C> program, so
+the commutators are passed directly as strings to the <C>anu-pq</C> program, so
 that &GAP; does not <Q>see</Q> them and pre-expand them.
 
 <Log><![CDATA[
@@ -262,7 +262,7 @@
 Note that the <C>time</C> statement gives the time in milliseconds spent by
 &GAP; in executing the <C>PqExample("B2-4-Id");</C> command (i.e.&nbsp;everything
 up to the <C>Info</C>-ing of the variables used), but over 90% of that time
-is spent in the final <C>Pq</C> statement. The time spent by the <C>pq</C> program,
+is spent in the final <C>Pq</C> statement. The time spent by the <C>anu-pq</C> program,
 which is negligible anyway (you can check this by running the example
 while the <C>InfoANUPQ</C> level is set to 2), is not counted by <C>time</C>.
 
@@ -390,7 +390,7 @@
 &ANUPQ; package is the computation of the Burnside group <M>B(5, 4)</M>, the
 largest group of exponent 4 generated by 5 elements. It has order
 <M>2^{2728}</M> and lower exponent-<M>p</M> central class 13. The example
-<C>"B5-4.g"</C> computes <M>B(5, 4)</M>; it is based on a <C>pq</C> standalone input
+<C>"B5-4.g"</C> computes <M>B(5, 4)</M>; it is based on a <C>anu-pq</C> standalone input
 file written by M.&nbsp;F.&nbsp;Newman.
 <P/>
 
@@ -663,7 +663,7 @@
     </Item>
 
     <Item>
-    As each descendant is processed its unique label defined by the <C>pq</C>
+    As each descendant is processed its unique label defined by the <C>anu-pq</C>
     program and number of descendants is <C>Info</C>-ed at <C>InfoANUPQ</C> level 1.
     </Item>
 
--- a/doc/infra.xml
+++ b/doc/infra.xml
@@ -76,7 +76,7 @@
 to load.
 <P/>
 
-Also, if &GAP; cannot find a working <C>pq</C> binary, the call to
+Also, if &GAP; cannot find a working <C>anu-pq</C> binary, the call to
 <C>LoadPackage</C> will return <K>fail</K>.
 <P/>
 
@@ -112,26 +112,26 @@
 <List>
 <Mark><C>binary</C></Mark>
 <Item>
-the path of the <C>pq</C> binary;
+the path of the <C>anu-pq</C> binary;
 </Item>
 <Mark><C>tmpdir</C></Mark>
 <Item>
-the path of the temporary directory used by the <C>pq</C>
-binary and &GAP; (i.e.&nbsp;the directory in which all the <C>pq</C>'s temporary
+the path of the temporary directory used by the <C>anu-pq</C>
+binary and &GAP; (i.e.&nbsp;the directory in which all the <C>anu-pq</C>'s temporary
 files are created) (also see <Ref Func="ANUPQDirectoryTemporary" Style="Text"/> below);
 </Item>
 <Mark><C>outfile</C></Mark>
 <Item>
-the full path of the default <C>pq</C> output file;
+the full path of the default <C>anu-pq</C> output file;
 </Item>
 <Mark><C>SPimages</C></Mark>
 <Item>
 the full path of the file <C>GAP_library</C> to which the
-<C>pq</C> program writes its Standard Presentation images;
+<C>anu-pq</C> program writes its Standard Presentation images;
 </Item>
 <Mark><C>version</C></Mark>
 <Item>
-the version of the current <C>pq</C> binary;
+the version of the current <C>anu-pq</C> binary;
 </Item>
 <Mark><C>ni</C></Mark>
 <Item>
@@ -177,7 +177,7 @@
 <Mark><C>haspcp</C></Mark>
 <Item>
 is bound and set to <K>true</K> when a pc presentation is first
-set inside the <C>pq</C> program (e.g.&nbsp;by <C>PqPcPresentation</C> or
+set inside the <C>anu-pq</C> program (e.g.&nbsp;by <C>PqPcPresentation</C> or
 <C>PqRestorePcPresentation</C> or a higher order function like <C>Pq</C>,
 <C>PqEpimorphism</C>, <C>PqPCover</C>, <C>PqDescendants</C> or <C>PqStandardPresentation</C>
 that does a <C>PqPcPresentation</C> operation, but <E>not</E> <C>PqStart</C> which only
@@ -186,17 +186,17 @@
 <Mark><C>gens</C></Mark>
 <Item>
 a list of the generators of the group <C>group</C> as strings
-(the same as those passed to the <C>pq</C> program);
+(the same as those passed to the <C>anu-pq</C> program);
 </Item>
 <Mark><C>rels</C></Mark>
 <Item>
 a list of the relators of the group <C>group</C> as strings (the
-same as those passed to the <C>pq</C> program);
+same as those passed to the <C>anu-pq</C> program);
 </Item>
 <Mark><C>name</C></Mark>
 <Item>
 the name of the group whose pc presentation is defined by a
-call to the <C>pq</C> program (according to the <C>pq</C> program -- unless you
+call to the <C>anu-pq</C> program (according to the <C>anu-pq</C> program -- unless you
 have used the <C>GroupName</C> option (see e.g.&nbsp;<Ref Func="Pq" Style="Text"/>) or applied the function
 <C>SetName</C> (see&nbsp;<Ref BookName="ref" Func="SetName" Style="Text"/>) to the group, the <Q>generic</Q> name
 <C>"[grp]"</C> is set as a default);
@@ -204,18 +204,18 @@
 <Mark><C>gpnum</C></Mark>
 <Item>
 if not a null string, the <Q>number</Q> (i.e.&nbsp;the unique label
-assigned by the <C>pq</C> program) of the last descendant processed;
+assigned by the <C>anu-pq</C> program) of the last descendant processed;
 </Item>
 <Mark><C>class</C></Mark>
 <Item>
 the largest lower exponent-<M>p</M> central class of a quotient
-group of the group (usually <C>group</C>) found by a call to the <C>pq</C> program;
+group of the group (usually <C>group</C>) found by a call to the <C>anu-pq</C> program;
 </Item>
 <Mark><C>forder</C></Mark>
 <Item>
 the factored order of the quotient group of largest lower
 exponent-<M>p</M> central class found for the group (usually <C>group</C>) by a
-call to the <C>pq</C> program (this factored order is given as a list
+call to the <C>anu-pq</C> program (this factored order is given as a list
 <!-- FIXME: [p,n] reformatted -->
 <C>[p,n]</C>, indicating an order of <M>p^n</M>);
 </Item>
@@ -223,23 +223,23 @@
 <Item>
  the lower exponent-<M>p</M> central class of the
 <M>p</M>-covering group of a <M>p</M>-quotient of the group (usually <C>group</C>) found
-by a call to the <C>pq</C> program;
+by a call to the <C>anu-pq</C> program;
 </Item>
 <Mark><C>workspace</C></Mark>
 <Item>
-the workspace set for the <C>pq</C> process (either given as
+the workspace set for the <C>anu-pq</C> process (either given as
 a second argument to <C>PqStart</C>, or set by default to 10000000);
 </Item>
 <Mark><C>menu</C></Mark>
 <Item>
-the current menu of the <C>pq</C> process (the <C>pq</C> program is
+the current menu of the <C>anu-pq</C> process (the <C>anu-pq</C> program is
 managed by various menus, the details of which the user shouldn't
 normally need to know about -- the <C>menu</C> field remembers which menu the
-<C>pq</C> process is currently <Q>in</Q>);
+<C>anu-pq</C> process is currently <Q>in</Q>);
 </Item>
 <Mark><C>outfname</C></Mark>
 <Item>
-is the file to which <C>pq</C> output is directed, which is
+is the file to which <C>anu-pq</C> output is directed, which is
 always <C>ANUPQData.outfile</C>, except when option <C>SetupFile</C> is used with a
 non-interactive function, in which case <C>outfname</C> is set to
 <C>"PQ_OUTPUT"</C>;
@@ -331,16 +331,16 @@
 <ManSection>
 <InfoClass Name="InfoANUPQ"/>
 <Description>
-The input to and the output from the <C>pq</C> program is, by default, not
+The input to and the output from the <C>anu-pq</C> program is, by default, not
 displayed. However the user may choose to see some, or all, of this
 input/output. This is done via the <C>Info</C> mechanism (see
 Section&nbsp;<Ref BookName="ref" Label="Info Functions" Style="Text"/> in the &GAP; Reference Manual). For this
 purpose, there is the <A>InfoClass</A> <C>InfoANUPQ</C>. If the <C>InfoLevel</C> of
-<C>InfoANUPQ</C> is high enough each line of <C>pq</C> input/output is directed to
+<C>InfoANUPQ</C> is high enough each line of <C>anu-pq</C> input/output is directed to
 a call to <C>Info</C> and will be displayed for the user to see. By default,
 the <C>InfoLevel</C> of <C>InfoANUPQ</C> is 1, and it is recommended that you leave
 it at this level, or higher. Messages that the user should presumably
-want to see and output from the <C>pq</C> program influenced by the value of
+want to see and output from the <C>anu-pq</C> program influenced by the value of
 the option <C>OutputLevel</C> (see the options listed in Section&nbsp;<Ref Func="Pq" Style="Text"/>), other
 than timing and memory usage are directed to <C>Info</C> at <C>InfoANUPQ</C> level
 1.
@@ -355,14 +355,14 @@
 gap> SetInfoLevel(InfoANUPQ, 2);
 ]]></Example>
 
-enables the display of most timing and memory usage data from the <C>pq</C>
+enables the display of most timing and memory usage data from the <C>anu-pq</C>
 program, and also the number of identity instances when the <C>Identities</C>
 option is used. (Some timing and memory usage data, particularly when
 profuse in quantity, is <C>Info</C>-ed at <C>InfoANUPQ</C> level 3 instead.) Note
 that the the &GAP; functions <C>time</C> and <C>Runtime</C>
 (see&nbsp;<Ref BookName="ref" Func="Runtime" Style="Text"/> in
 the &GAP; Reference Manual) count the time spent by &GAP; and <E>not</E> the
-time spent by the (external) <C>pq</C> program.
+time spent by the (external) <C>anu-pq</C> program.
 
 <Example><![CDATA[
 gap> SetInfoLevel(InfoANUPQ, 3);
@@ -370,9 +370,9 @@
 
 enables the display of output of the nature of the first two <C>InfoANUPQ</C>
 that was not directly invoked by the user (e.g.&nbsp;some commands require
-&GAP; to discover something about the current state known to the <C>pq</C>
+&GAP; to discover something about the current state known to the <C>anu-pq</C>
 program). The identity instances processed under the <C>Identities</C> option
-are also displayed at this level. In some cases, the <C>pq</C> program
+are also displayed at this level. In some cases, the <C>anu-pq</C> program
 produces a lot of output despite the fact that the <C>OutputLevel</C>
 (see&nbsp;<Ref Label="option OutputLevel" Style="Text"/>) is unset or is set to 0; such output is also
 <C>Info</C>-ed at <C>InfoANUPQ</C> level 3.
@@ -381,23 +381,23 @@
 gap> SetInfoLevel(InfoANUPQ, 4);
 ]]></Example>
 
-enables the display of all the commands directed to the <C>pq</C> program,
+enables the display of all the commands directed to the <C>anu-pq</C> program,
 behind a <Q><C>ToPQ> </C></Q> prompt (so that you can distinguish it from the
-output from the <C>pq</C> program). See Section&nbsp;<Ref Sect="Hints and Warnings regarding the use of Options" Style="Text"/> for an example of how this can be a useful
+output from the <C>anu-pq</C> program). See Section&nbsp;<Ref Sect="Hints and Warnings regarding the use of Options" Style="Text"/> for an example of how this can be a useful
 troubleshooting tool.
 
 <Example><![CDATA[
 gap> SetInfoLevel(InfoANUPQ, 5);
 ]]></Example>
 
-enables the display of the <C>pq</C> program's prompts for input. Finally,
+enables the display of the <C>anu-pq</C> program's prompts for input. Finally,
 
 <Example><![CDATA[
 gap> SetInfoLevel(InfoANUPQ, 6);
 ]]></Example>
 
-enables the display of all other output from the <C>pq</C> program, namely the
-banner and menus. However, the timing data printed when the <C>pq</C> program
+enables the display of all other output from the <C>anu-pq</C> program, namely the
+banner and menus. However, the timing data printed when the <C>anu-pq</C> program
 exits can never be observed.
 
 </Description>
@@ -428,13 +428,13 @@
 <Description>
 returns a list of words that &GAP; understands, given a list <A>rels</A> of
 strings in the string representations of the generators of the fp group
-<A>group</A> prepared as a list of relators for the <C>pq</C> program.
+<A>group</A> prepared as a list of relators for the <C>anu-pq</C> program.
 <P/>
 
 <E>Note:</E>
-The <C>pq</C> program does not use <C>/</C> to indicate multiplication by an
+The <C>anu-pq</C> program does not use <C>/</C> to indicate multiplication by an
 inverse and uses square brackets to represent (left normed) commutators.
-Also, even though the <C>pq</C> program accepts relations, all elements of
+Also, even though the <C>anu-pq</C> program accepts relations, all elements of
 <A>rels</A> <E>must</E> be in relator form, i.e.&nbsp;a relation of form <C><A>w1</A> = <A>w2</A></C>
 must be written as <C><A>w1</A>*(<A>w2</A>)^-1</C>.
 <P/>
@@ -466,9 +466,9 @@
 
 <E>Note:</E>
 The reason the generators <E>must</E> be <C>x1,...,x<A>n</A></C> is that these are the
-pc generator names used by the <C>pq</C> program (as distinct from the
+pc generator names used by the <C>anu-pq</C> program (as distinct from the
 generator names for the group provided by the user to a function like
-<C>Pq</C> that invokes the <C>pq</C> program).
+<C>Pq</C> that invokes the <C>anu-pq</C> program).
 </Description>
 </ManSection>
 
@@ -539,7 +539,7 @@
 <Func Name="ToPQLog" Arg="[ filename ]"/>
 <Description>
 With string argument <A>filename</A>, <C>ToPQLog</C> opens the file with name
-<A>filename</A> for logging; all commands written to the <C>pq</C> binary (that are
+<A>filename</A> for logging; all commands written to the <C>anu-pq</C> binary (that are
 <C>Info</C>-ed behind a <Q><C>ToPQ> </C></Q> prompt at <C>InfoANUPQ</C> level 4) are then
 also written to that file (but without prompts). With no argument,
 <C>ToPQLog</C> stops logging to whatever file was being logged to. If a file
@@ -617,9 +617,9 @@
 <Index Subkey="of pq program">menu item</Index>
 <Index Subkey="of pq program is a menu item">option</Index> <!-- FIXME: is this right? -->
 <E>Note:</E>
-By <Q>options</Q> we refer to &GAP; options. The <C>pq</C> program also uses the
+By <Q>options</Q> we refer to &GAP; options. The <C>anu-pq</C> program also uses the
 term <Q>option</Q>; to distinguish the two usages of <Q>option</Q>, in this
-manual we use the term <E>menu item</E> to refer to what the <C>pq</C> program
+manual we use the term <E>menu item</E> to refer to what the <C>anu-pq</C> program
 refers to as an <Q>option</Q>.
 <P/>
 
@@ -756,7 +756,7 @@
 
 There are some other strategies which may have helped us to see our error
 above. The function <C>Pq</C> recognises the option <C>OutputLevel</C>
-(see&nbsp;<Ref Label="option OutputLevel" Style="Text"/>); if this option is set to at least 1, the <C>pq</C> program
+(see&nbsp;<Ref Label="option OutputLevel" Style="Text"/>); if this option is set to at least 1, the <C>anu-pq</C> program
 provides information on each class quotient as it is generated:
 <Log><![CDATA[
 gap> ANUPQWarnOfOtherOptions := false;; # Set back to normal
@@ -787,7 +787,7 @@
 value of <C>ClassBound</C>).
 <P/>
 
-If you have some familiarity with <Q>keyword</Q> command input to the <C>pq</C>
+If you have some familiarity with <Q>keyword</Q> command input to the <C>anu-pq</C>
 binary, then setting the level of <C>InfoANUPQ</C> to 4 would also have
 indicated a problem:
 <Log><![CDATA[
@@ -807,7 +807,7 @@
 ]]></Log>
 
 Here the line <Q><C>#I ToPQ> class 63</C></Q> indicates that a directive to set
-the classbound to 63 was sent to the <C>pq</C> program.
+the classbound to 63 was sent to the <C>anu-pq</C> program.
 
 </Section>
 </Chapter>
--- a/doc/install.xml
+++ b/doc/install.xml
@@ -1,7 +1,7 @@
 <Chapter Label="Installing-ANUPQ">
 <Heading>Installing the ANUPQ Package</Heading>
 
-The ANU <C>pq</C> program is written in C and the package can be installed
+The ANU <C>anu-pq</C> program is written in C and the package can be installed
 under UNIX and in environments similar to UNIX. In particular
 it is known to work on Linux and Mac OS X, and also on Windows
 equipped with cygwin.
@@ -66,8 +66,8 @@
 
 What this does is look for a file <C>sysinfo.gap</C> in the root directory of
 &GAP; in order to determine an architecture name for the subdirectory of
-<C>bin</C> in which to put the compiled <C>pq</C> binary. This only makes sense if
-&GAP; was compiled for the same architecture that <C>pq</C> will be. If you
+<C>bin</C> in which to put the compiled <C>anu-pq</C> binary. This only makes sense if
+&GAP; was compiled for the same architecture that <C>anu-pq</C> will be. If you
 have a shared file system mounted across different architectures, then
 you should run <C>configure</C> and <C>make</C> for &ANUPQ; for each architecture
 immediately after compiling &GAP; on the same architecture.
@@ -98,12 +98,12 @@
 <P/>
 
 <Index Key="ANUPQ_GAP_EXEC" Subkey="environment variable"><C>ANUPQ_GAP_EXEC</C></Index>
-The path of &GAP; (see <E>Note</E> below) used by the <C>pq</C> binary (the value
+The path of &GAP; (see <E>Note</E> below) used by the <C>anu-pq</C> binary (the value
 <C>GAP</C> is set to in the <C>make</C> command) may be over-ridden by setting the
 environment variable <C>ANUPQ_GAP_EXEC</C>. These values are only of interest
-when the <C>pq</C> program is run as a standalone; however, the <C>testPq</C>
-script assumes you have set one of these correctly (see Section&nbsp;<Ref Sect="Testing your ANUPQ installation" Style="Text"/>). When the <C>pq</C> program is started from &GAP;
-communication occurs via an iostream, so that the <C>pq</C> binary does not
+when the <C>anu-pq</C> program is run as a standalone; however, the <C>testPq</C>
+script assumes you have set one of these correctly (see Section&nbsp;<Ref Sect="Testing your ANUPQ installation" Style="Text"/>). When the <C>anu-pq</C> program is started from &GAP;
+communication occurs via an iostream, so that the <C>anu-pq</C> binary does not
 actually need to know a valid path for &GAP; is this case.
 <P/>
 
@@ -124,7 +124,7 @@
 Now it is time to test the installation. After doing <C>configure</C> and
 <C>make</C> you will have a <C>testPq</C> script. The script assumes that, if the
 environment variable <C>ANUPQ_GAP_EXEC</C> is set, it is a correct path for
-&GAP;, or otherwise that the <C>make</C> call that compiled the <C>pq</C> program
+&GAP;, or otherwise that the <C>make</C> call that compiled the <C>anu-pq</C> program
 set <C>GAP</C> to a correct path for &GAP; (see Section&nbsp;<Ref Sect="Running the pq program as a standalone" Style="Text"/> for more details). To run the tests, just type:
 
 <Listing><![CDATA[
@@ -134,7 +134,7 @@
 Some of the tests the script runs take a while. Please be patient. The
 script checks that you not only have a correct &GAP; (at least version
 4.4) installation that includes the &AutPGrp; package, but that the
-&ANUPQ; package and its <C>pq</C> binary interact correctly. You should see
+&ANUPQ; package and its <C>anu-pq</C> binary interact correctly. You should see
 something like the following output:
 
 <Log><![CDATA[
@@ -174,12 +174,12 @@
 <Heading>Running the pq program as a standalone</Heading>
 
 <Index Key="ANUPQ_GAP_EXEC" Subkey="environment variable"><C>ANUPQ_GAP_EXEC</C></Index>
-When the <C>pq</C> program is run as a standalone it sometimes needs to call
+When the <C>anu-pq</C> program is run as a standalone it sometimes needs to call
 &GAP; to compute stabilisers of subgroups; in doing so, it first checks
 the value of the environment variable <C>ANUPQ_GAP_EXEC</C>, and uses that, if
 set, or otherwise the value of <C>GAP</C> it was compiled with, as the path
 for &GAP;. If you ran <C>testPq</C> (see Section&nbsp;<Ref Sect="Testing your ANUPQ installation" Style="Text"/>) and you got both &GAP; is <C>OK</C> and the link between the
-<C>pq</C> binary and &GAP; is <C>OK</C>, you should be fine. Otherwise heed the
+<C>anu-pq</C> binary and &GAP; is <C>OK</C>, you should be fine. Otherwise heed the
 recommendations of the error messages you get and run the <C>testPq</C> until
 all tests are passed.
 <P/>
@@ -190,7 +190,7 @@
 to install the needed packages in your own directory (because, say, you
 are not a system administrator) then you should create your own shell
 script that runs &GAP; with a correct setting of the <C>-l</C> option and set
-the path used by the <C>pq</C> binary to the path of that script. To create
+the path used by the <C>anu-pq</C> binary to the path of that script. To create
 the script that runs &GAP; it is easiest to copy the system one and edit
 it, e.g. start by executing the following UNIX commands (skip the second
 step if you already have a <C>bin</C> directory; <C>you@unix></C> is your UNIX
@@ -223,7 +223,7 @@
 ]]></Listing>
 
 assuming that your personal &GAP; <C>pkg</C> directory is a subdirectory of
-<C>gapstuff</C> in your home directory. Finally, to let the <C>pq</C> program know
+<C>gapstuff</C> in your home directory. Finally, to let the <C>anu-pq</C> program know
 where &GAP; is and also know where your <C>pkg</C> directory is that contains
 &ANUPQ;, set the environment variable <C>ANUPQ_GAP_EXEC</C> to the complete
 (i.e. absolute) path of your <C>mygap</C> script (do not use the tilde
--- a/doc/interact.xml
+++ b/doc/interact.xml
@@ -4,11 +4,11 @@
 Here we describe the interactive functions defined by the &ANUPQ;
 package, i.e.&nbsp;the functions that manipulate and initiate interactive
 &ANUPQ; processes. These are functions that extract information via a
-dialogue with a running <C>pq</C> process (process used in the UNIX sense).
+dialogue with a running <C>anu-pq</C> process (process used in the UNIX sense).
 Occasionally, a user needs the <Q>next step</Q>; the functions provided in
-this chapter make use of data from previous steps retained by the <C>pq</C>
-program, thus allowing the user to interact with the <C>pq</C> program like
-one can when one uses the <C>pq</C> program as a stand-alone (see&nbsp;<C>guide.dvi</C>
+this chapter make use of data from previous steps retained by the <C>anu-pq</C>
+program, thus allowing the user to interact with the <C>anu-pq</C> program like
+one can when one uses the <C>anu-pq</C> program as a stand-alone (see&nbsp;<C>guide.dvi</C>
 in the <C>standalone-doc</C> directory).
 <P/>
 
@@ -42,7 +42,7 @@
 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.&nbsp;on Linux: <C>ps xw | grep pq</C> gives you
-information on the <C>pq</C> processes corresponding to any interactive
+information on the <C>anu-pq</C> processes corresponding to any interactive
 &ANUPQ; processes started in a &GAP; session; you can then do <C>kill
 <A>N</A></C> for each number <A>N</A> appearing in the first column of this output).
 
@@ -56,16 +56,16 @@
 <Func Name="PqStart" Arg=": options"/>
 <Description>
 activate an iostream for an interactive &ANUPQ; process (i.e. <C>PqStart</C>
-starts up a <C>pq</C> process and opens a &GAP; iostream to <Q>talk</Q> to that
+starts up a <C>anu-pq</C> process and opens a &GAP; iostream to <Q>talk</Q> to that
 process) and returns an integer <A>i</A> that can be used to identify that
 process. The argument <A>G</A> should be an <E>fp group</E> or <E>pc group</E> that the
 user intends to manipulate using interactive &ANUPQ; functions. If the
 function is called without specifying <A>G</A>, a group can be read in by
 using the function <C>PqRestorePcPresentation</C> (see&nbsp;<Ref Func="PqRestorePcPresentation" Style="Text"/>).
-If <C>PqStart</C> is given an integer argument <A>workspace</A>, then the <C>pq</C>
+If <C>PqStart</C> is given an integer argument <A>workspace</A>, then the <C>anu-pq</C>
 program is started up with a workspace (an integer array) of size
 <A>workspace</A> (i.e. <M>4 \times <A>workspace</A></M> bytes in a 32-bit environment);
-otherwise, the <C>pq</C> program sets a default workspace of <M>10000000</M>.
+otherwise, the <C>anu-pq</C> program sets a default workspace of <M>10000000</M>.
 <P/>
 
 The only <A>options</A> currently recognised by <C>PqStart</C> are <C>Prime</C>,
@@ -86,11 +86,11 @@
 <P/>
 
 <E>Note:</E>
-It can happen that the <C>pq</C> process, and hence the &GAP; iostream
+It can happen that the <C>anu-pq</C> process, and hence the &GAP; iostream
 assigned to communicate with it, can die, e.g.&nbsp;by the user typing a
-<C>Ctrl-C</C> while the <C>pq</C> process is engaged in a long calculation.
+<C>Ctrl-C</C> while the <C>anu-pq</C> process is engaged in a long calculation.
 <C>IsPqProcessAlive</C> (see&nbsp;<Ref Func="IsPqProcessAlive" Style="Text"/>) is provided to check the
-status of the &GAP; iostream (and hence the status of the <C>pq</C> process
+status of the &GAP; iostream (and hence the status of the <C>anu-pq</C> process
 it was communicating with).
 </Description>
 </ManSection>
@@ -148,7 +148,7 @@
 <P/>
 
 <Index>interruption</Index><!-- @interruption of an interactive ANUPQ process -->
-If the user does not yet have a <C>gap></C> prompt then usually the <C>pq</C>
+If the user does not yet have a <C>gap></C> prompt then usually the <C>anu-pq</C>
 program is still away doing something and an &ANUPQ; interface function
 is still waiting for a reply. Typing a <C>Ctrl-C</C> (i.e.&nbsp;holding down the
 <C>Ctrl</C> key and typing <C>c</C>) will stop the waiting and send &GAP; into a
@@ -159,7 +159,7 @@
 <P/>
 
 The &GAP; iostream of an interactive &ANUPQ; process will also die if
-the <C>pq</C> program has a segmentation fault. We do hope that this never
+the <C>anu-pq</C> 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 <C>README</C> that comes
 with the &ANUPQ; package to find out what to include in a bug report and
@@ -231,7 +231,7 @@
 <P/>
 
 The behaviour of the interactive <C>Pq</C> function depends on the current
-state of the pc presentation stored by the <C>pq</C> program:
+state of the pc presentation stored by the <C>anu-pq</C> program:
 
 <Enum>
 <Item>
@@ -300,7 +300,7 @@
 default interactive &ANUPQ; process, an epimorphism from <A>F</A> onto the
 <M>p</M>-quotient of <A>F</A> specified by <A>options</A>; <A>F</A> must previously have been
 given (as first argument) to <C>PqStart</C> to start the interactive &ANUPQ;
-process (see&nbsp;<Ref Func="PqStart" Style="Text"/>). Since the underlying interactions with the <C>pq</C>
+process (see&nbsp;<Ref Func="PqStart" Style="Text"/>). Since the underlying interactions with the <C>anu-pq</C>
 program effected by the interactive <C>PqEpimorphism</C> are identical to
 those effected by the interactive <C>Pq</C>, everything said regarding the
 requirements and behaviour of the interactive <C>Pq</C> function
@@ -414,8 +414,8 @@
 
 Taking one of the examples for the non-interactive version of
 <C>StandardPresentation</C> (see&nbsp;<Ref Func="StandardPresentation" Style="Text"/>) that required two
-separate calls to the <C>pq</C> program, we now show how it can be done by
-setting up a dialogue with just the one <C>pq</C> process, using the
+separate calls to the <C>anu-pq</C> program, we now show how it can be done by
+setting up a dialogue with just the one <C>anu-pq</C> process, using the
 interactive version of <C>StandardPresentation</C>:
 
 <Example><![CDATA[
@@ -498,8 +498,8 @@
 (see&nbsp;<Ref Func="EpimorphismPqStandardPresentation" Style="Text"/>) and modifying it a little, we
 illustrate, as for the interactive <C>StandardPresentation</C>
 (see&nbsp;<Ref Func="StandardPresentation" Label="interactive" Style="Text"/>), how something that required two
-separate calls to the <C>pq</C> program can now be achieved with a dialogue
-with just one <C>pq</C> process. Also, observe that calls to one of the
+separate calls to the <C>anu-pq</C> program can now be achieved with a dialogue
+with just one <C>anu-pq</C> process. Also, observe that calls to one of the
 standard presentation functions (as mentioned in the notes
 of&nbsp;<Ref Func="StandardPresentation" Label="interactive" Style="Text"/>) computes and stores both an fp
 group with a standard presentation and an epimorphism; subsequent calls
@@ -639,7 +639,7 @@
 <E>Notes:</E> The function <C>PqDescendants</C> uses the automorphism group of <A>G</A>
 which it computes via the package &AutPGrp; if the automorphism group of
 <A>G</A> is not already present. If &AutPGrp; is not installed an error may
-be raised. If the automorphism group of <A>G</A> is insoluble the <C>pq</C>
+be raised. If the automorphism group of <A>G</A> is insoluble the <C>anu-pq</C>
 program will call &GAP; together with the &AutPGrp; package for certain
 orbit-stabilizer calculations.
 <P/>
@@ -731,9 +731,9 @@
 <M>p</M>-quotient previously computed by the interactive <C>Pq</C> function
 (see&nbsp;<Ref Func="Pq" Label="interactive" Style="Text"/>) to be the group of the process. This function is
 supplied to enable the computation of descendants of a <M>p</M>-quotient that
-is already known to the <C>pq</C> program, via the interactive <C>PqDescendants</C>
+is already known to the <C>anu-pq</C> program, via the interactive <C>PqDescendants</C>
 function (see&nbsp;<Ref Func="PqDescendants" Label="interactive" Style="Text"/>), thus avoiding the need to
-re-submit it and have the <C>pq</C> program recompute it.
+re-submit it and have the <C>anu-pq</C> program recompute it.
 <P/>
 
 <E>Note:</E> See the function <C>PqPGSetDescendantToPcp</C>
@@ -780,21 +780,21 @@
 <Heading>Low-level Interactive ANUPQ functions based on menu items of the
 pq program</Heading>
 
-The <C>pq</C> program has 5 menus, the details of which the reader will not
+The <C>anu-pq</C> 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: <C>guide.dvi</C>. Both <C>guide.dvi</C> and the
-<C>pq</C> program refer to the items of these 5 menus as <Q>options</Q>, which do
+<C>anu-pq</C> program refer to the items of these 5 menus as <Q>options</Q>, which do
 <E>not</E> correspond in any way to the options used by any of the &GAP;
-functions that interface with the <C>pq</C> program.
+functions that interface with the <C>anu-pq</C> program.
 <P/>
 
 <E>Warning:</E>
 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 <C>pq</C> standalone (in particular, its <Q>advanced</Q>
+from within &GAP;. The <C>anu-pq</C> standalone (in particular, its <Q>advanced</Q>
 menus) assumes some expertise of the user; doing the <Q>wrong</Q> thing can
 cause the program to crash. While a number of safeguards have been
-provided in the &GAP; interface to the <C>pq</C> program, these are <E>not</E>
+provided in the &GAP; interface to the <C>anu-pq</C> program, these are <E>not</E>
 foolproof, and the user should exercise care and ensure pre-requisites of
 the various commands are met.
 </Section>
@@ -802,8 +802,8 @@
 <Section><Heading>General commands</Heading>
 
 The following commands either use a menu item from whatever menu is
-<Q>current</Q> for the <C>pq</C> program, or have general application and are not
-associated with just one menu item of the <C>pq</C> program.
+<Q>current</Q> for the <C>anu-pq</C> program, or have general application and are not
+associated with just one menu item of the <C>anu-pq</C> program.
 
 <ManSection>
 <Func Name="PqNrPcGenerators" Arg="i"/>
@@ -885,12 +885,12 @@
 <Func Name="PqDisplayPcPresentation" Arg="i : [OutputLevel := lev ]"/>
 <Func Name="PqDisplayPcPresentation" Arg=": [OutputLevel := lev ]" Label="for default process"/>
 <Description>
-for the <A>i</A>th or default interactive &ANUPQ; process, direct the <C>pq</C>
+for the <A>i</A>th or default interactive &ANUPQ; process, direct the <C>anu-pq</C>
 program to display the pc presentation of the lower exponent <M>p</M>-class
 quotient of the group currently determined by the process.
 <P/>
 
-Except if the last command communicating with the <C>pq</C> program was a
+Except if the last command communicating with the <C>anu-pq</C> program was a
 <M>p</M>-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 <C>PqSetOutputLevel</C> first (see&nbsp;<Ref Func="PqSetOutputLevel" Style="Text"/>), or
@@ -898,8 +898,8 @@
 <P/>
 
 <E>Note:</E>
-For those familiar with the <C>pq</C> program, <C>PqDisplayPcPresentation</C>
-performs menu item 4 of the current menu of the <C>pq</C> program.
+For those familiar with the <C>anu-pq</C> program, <C>PqDisplayPcPresentation</C>
+performs menu item 4 of the current menu of the <C>anu-pq</C> program.
 </Description>
 </ManSection>
 
@@ -907,11 +907,11 @@
 <Func Name="PqSetOutputLevel" Arg="i, lev"/>
 <Func Name="PqSetOutputLevel" Arg="lev" Label="for default process"/>
 <Description>
-for the <A>i</A>th or default interactive &ANUPQ; process, direct the <C>pq</C>
-program to set the output level of the <C>pq</C> program to <A>lev</A>.
+for the <A>i</A>th or default interactive &ANUPQ; process, direct the <C>anu-pq</C>
+program to set the output level of the <C>anu-pq</C> program to <A>lev</A>.
 <P/>
 
-<E>Note:</E> For those familiar with the <C>pq</C> program, <C>PqSetOutputLevel</C>
+<E>Note:</E> For those familiar with the <C>anu-pq</C> program, <C>PqSetOutputLevel</C>
 performs menu item 5 of the main (or advanced) <M>p</M>-Quotient menu, or the
 Standard Presentation menu.
 </Description>
@@ -929,7 +929,7 @@
 <P/>
 
 <E>Note:</E> This function is mainly implemented at the &GAP; level. It does
-not correspond to a menu item of the <C>pq</C> program.
+not correspond to a menu item of the <C>anu-pq</C> program.
 </Description>
 </ManSection>
 
@@ -941,7 +941,7 @@
 <Func Name="PqPcPresentation" Arg="i : options"/>
 <Func Name="PqPcPresentation" Arg=": options" Label="for default process"/>
 <Description>
-for the <A>i</A>th or default interactive &ANUPQ; process, direct the <C>pq</C>
+for the <A>i</A>th or default interactive &ANUPQ; process, direct the <C>anu-pq</C>
 program to compute the pc presentation of the quotient (determined by
 <A>options</A>) of the group of the process, which for process <A>i</A> is stored
 as <C>ANUPQData.io[<A>i</A>].group</C>.
@@ -959,7 +959,7 @@
 <E>Notes</E> 
 <P/>
 
-The pc presentation is held by the <C>pq</C> program. In contrast to <C>Pq</C>
+The pc presentation is held by the <C>anu-pq</C> program. In contrast to <C>Pq</C>
 (see&nbsp;<Ref Func="Pq" Label="interactive" Style="Text"/>), no &GAP; pc group is returned;
 see&nbsp;<C>PqCurrentGroup</C> (<Ref Func="PqCurrentGroup" Style="Text"/>) if you need the corresponding
 &GAP; pc group.
@@ -984,7 +984,7 @@
 <C>PqEvaluateIdentities(<A>i</A>);</C> as their final step.
 <P/>
 
-For those familiar with the <C>pq</C> program, <C>PqPcPresentation</C> performs
+For those familiar with the <C>anu-pq</C> program, <C>PqPcPresentation</C> performs
 menu item 1 of the main <M>p</M>-Quotient menu.
 </Description>
 </ManSection>
@@ -993,7 +993,7 @@
 <Func Name="PqSavePcPresentation" Arg="i, filename"/>
 <Func Name="PqSavePcPresentation" Arg="filename" Label="for default process"/>
 <Description>
-for the <A>i</A>th or default interactive &ANUPQ; process, direct the <C>pq</C>
+for the <A>i</A>th or default interactive &ANUPQ; process, direct the <C>anu-pq</C>
 program to save the pc presentation previously computed for the quotient
 of the group of that process to the file with name <A>filename</A>. If the
 first character of the string <A>filename</A> is not <C>/</C>, <A>filename</A> is
@@ -1002,7 +1002,7 @@
 <C>PqRestorePcPresentation</C> (see&nbsp;<Ref Func="PqRestorePcPresentation" Style="Text"/>).
 <P/>
 
-<E>Note:</E> For those familiar with the <C>pq</C> program, <C>PqSavePcPresentation</C>
+<E>Note:</E> For those familiar with the <C>anu-pq</C> program, <C>PqSavePcPresentation</C>
 performs menu item 2 of the main <M>p</M>-Quotient menu.
 </Description>
 </ManSection>
@@ -1011,7 +1011,7 @@
 <Func Name="PqRestorePcPresentation" Arg="i, filename"/>
 <Func Name="PqRestorePcPresentation" Arg="filename" Label="for default process"/>
 <Description>
-for the <A>i</A>th or default interactive &ANUPQ; process, direct the <C>pq</C>
+for the <A>i</A>th or default interactive &ANUPQ; process, direct the <C>anu-pq</C>
 program to restore the pc presentation previously saved to <A>filename</A>, by
 <C>PqSavePcPresentation</C> (see&nbsp;<Ref Func="PqSavePcPresentation" Style="Text"/>). If the first
 character of the string <A>filename</A> is not <C>/</C>, <A>filename</A> is assumed to
@@ -1020,7 +1020,7 @@
 <P/>
 
 <E>Note:</E>
-For those familiar with the <C>pq</C> program, <C>PqRestorePcPresentation</C>
+For those familiar with the <C>anu-pq</C> program, <C>PqRestorePcPresentation</C>
 performs menu item 3 of the main <M>p</M>-Quotient menu.
 </Description>
 </ManSection>
@@ -1029,13 +1029,13 @@
 <Func Name="PqNextClass" Arg="i : [ QueueFactor ]"/>
 <Func Name="PqNextClass" Arg=": [ QueueFactor ]" Label="for default process"/>
 <Description>
-for the <A>i</A>th or default interactive &ANUPQ; process, direct the <C>pq</C> 
+for the <A>i</A>th or default interactive &ANUPQ; process, direct the <C>anu-pq</C>
 program to calculate the next class of <C>ANUPQData.io[<A>i</A>].group</C>.
 <P/>
 
 <Index>option QueueFactor</Index>
 <C>PqNextClass</C> accepts the option <C>QueueFactor</C> (see also&nbsp;<Ref Label="option QueueFactor" Style="Text"/>) which should be a positive integer if automorphisms have
-been previously supplied. If the <C>pq</C> program requires a queue factor and
+been previously supplied. If the <C>anu-pq</C> program requires a queue factor and
 none is supplied via the option <C>QueueFactor</C> a default of 15 is taken.
 <P/>
 
@@ -1056,7 +1056,7 @@
 its own elimination of redundant generators).
 <P/>
 
-For those familiar with the <C>pq</C> program, <C>PqNextClass</C> performs menu item
+For those familiar with the <C>anu-pq</C> program, <C>PqNextClass</C> performs menu item
 6 of the main <M>p</M>-Quotient menu.
 </Description>
 </ManSection>
@@ -1065,7 +1065,7 @@
 <Func Name="PqComputePCover" Arg="i"/>
 <Func Name="PqComputePCover" Arg="" Label="for default process"/>
 <Description>
-for the <A>i</A>th or default interactive &ANUPQ; processi, directi, the <C>pq</C>
+for the <A>i</A>th or default interactive &ANUPQ; processi, directi, the <C>anu-pq</C>
 program to compute the <M>p</M>-covering group of <C>ANUPQData.io[<A>i</A>].group</C>.
 In contrast to the function <C>PqPCover</C> (see&nbsp;<Ref Func="PqPCover" Style="Text"/>), this function does
 not return a &GAP; pc group.
@@ -1083,7 +1083,7 @@
 PqEliminateRedundantGenerators(i);
 ]]></Listing>
 
-For those familiar with the <C>pq</C> program, <C>PqComputePCover</C> performs menu
+For those familiar with the <C>anu-pq</C> program, <C>PqComputePCover</C> performs menu
 item 7 of the main <M>p</M>-Quotient menu.
 </Description>
 </ManSection>
@@ -1096,7 +1096,7 @@
 <Func Name="PqCollect" Arg="i, word"/>
 <Func Name="PqCollect" Arg="word" Label="for default process"/>
 <Description>
-for the <A>i</A>th or default interactive &ANUPQ; process, instruct the <C>pq</C>
+for the <A>i</A>th or default interactive &ANUPQ; process, instruct the <C>anu-pq</C>
 program to do a collection on <A>word</A>, a word in the current pc generators
 (the form of <A>word</A> required is described below). <C>PqCollect</C> returns the
 resulting word of the collection as a list of generator number, exponent
@@ -1123,7 +1123,7 @@
 </Item>
 </Enum>
 
-<E>Note:</E> For those familiar with the <C>pq</C> program, <C>PqCollect</C> performs
+<E>Note:</E> For those familiar with the <C>anu-pq</C> program, <C>PqCollect</C> performs
 menu item 1 of the Advanced <M>p</M>-Quotient menu.
 </Description>
 </ManSection>
@@ -1132,14 +1132,14 @@
 <Func Name="PqSolveEquation" Arg="i, a, b"/>
 <Func Name="PqSolveEquation" Arg="a, b" Label="for default process"/>
 <Description>
-for the <A>i</A>th or default interactive &ANUPQ; process, direct the <C>pq</C>
+for the <A>i</A>th or default interactive &ANUPQ; process, direct the <C>anu-pq</C>
 program to solve <M><A>a</A> * <A>x</A> = <A>b</A></M> for <A>x</A>, where <A>a</A> and <A>b</A> are words
 in the pc generators. For the representation of these words see the
 description of the function <C>PqCollect</C> (<Ref Func="PqCollect" Style="Text"/>).
 <P/>
 
 <E>Note:</E> 
-For those familiar with the <C>pq</C> program, <C>PqSolveEquation</C> performs
+For those familiar with the <C>anu-pq</C> program, <C>PqSolveEquation</C> performs
 menu item 2 of the Advanced <M>p</M>-Quotient menu.
 </Description>
 </ManSection>
@@ -1148,7 +1148,7 @@
 <Func Name="PqCommutator" Arg="i, words, pow"/>
 <Func Name="PqCommutator" Arg="words, pow" Label="for default process"/>
 <Description>
-for the <A>i</A>th or default interactive &ANUPQ; process, instruct the <C>pq</C>
+for the <A>i</A>th or default interactive &ANUPQ; process, instruct the <C>anu-pq</C>
 program to compute the left normed commutator of the list <A>words</A> of
 words in the current pc generators raised to the integer power <A>pow</A>, and
 return the resulting word as a list of generator number, exponent pairs.
@@ -1158,7 +1158,7 @@
 <P/>
 
 <E>Note:</E>
-For those familiar with the <C>pq</C> program, <C>PqCommutator</C> performs menu
+For those familiar with the <C>anu-pq</C> program, <C>PqCommutator</C> performs menu
 item 3 of the Advanced <M>p</M>-Quotient menu.
 </Description>
 </ManSection>
@@ -1167,14 +1167,14 @@
 <Func Name="PqSetupTablesForNextClass" Arg="i"/>
 <Func Name="PqSetupTablesForNextClass" Arg="" Label="for default process"/>
 <Description>
-for the <A>i</A>th or default interactive &ANUPQ; process, direct the <C>pq</C>
+for the <A>i</A>th or default interactive &ANUPQ; process, direct the <C>anu-pq</C>
 program to set up tables for the next class. As as side-effect,
 after <C>PqSetupTablesForNextClass(<A>i</A>)</C> the value returned by
 <C>PqPClass(<A>i</A>)</C> will be one more than it was previously.
 <P/>
 
 <E>Note:</E> 
-For those familiar with the <C>pq</C> program, <C>PqSetupTablesForNextClass</C>
+For those familiar with the <C>anu-pq</C> program, <C>PqSetupTablesForNextClass</C>
 performs menu item 6 of the Advanced <M>p</M>-Quotient menu.
 </Description>
 </ManSection>
@@ -1183,7 +1183,7 @@
 <Func Name="PqTails" Arg="i, weight"/>
 <Func Name="PqTails" Arg="weight" Label="for default process"/>
 <Description>
-for the <A>i</A>th or default interactive &ANUPQ; process, direct the <C>pq</C>
+for the <A>i</A>th or default interactive &ANUPQ; process, direct the <C>anu-pq</C>
 program to compute and add tails of weight <A>weight</A> if <A>weight</A> is in the
 integer range <C>[2 .. PqPClass(<A>i</A>)]</C> (assuming <A>i</A> is the number of the
 process, even in the default case) or for all weights if <C><A>weight</A> = 0</C>.
@@ -1213,7 +1213,7 @@
 PqAddTails(i, weight);
 ]]></Listing>
 
-For those familiar with the <C>pq</C> program, <C>PqTails</C> uses menu item 7 of
+For those familiar with the <C>anu-pq</C> program, <C>PqTails</C> uses menu item 7 of
 the Advanced <M>p</M>-Quotient menu.
 </Description>
 </ManSection>
@@ -1222,7 +1222,7 @@
 <Func Name="PqComputeTails" Arg="i, weight"/>
 <Func Name="PqComputeTails" Arg="weight" Label="for default process"/>
 <Description>
-for the <A>i</A>th or default interactive &ANUPQ; process, direct the <C>pq</C>
+for the <A>i</A>th or default interactive &ANUPQ; process, direct the <C>anu-pq</C>
 program to compute tails of weight <A>weight</A> if <A>weight</A> is in the integer
 range <C>[2 .. PqPClass(<A>i</A>)]</C> (assuming <A>i</A> is the number of the process,
 even in the default case) or for all weights if <C><A>weight</A> = 0</C>. See
@@ -1230,7 +1230,7 @@
 <P/>
 
 <E>Note:</E>
-For those familiar with the <C>pq</C> program, <C>PqComputeTails</C> uses menu item
+For those familiar with the <C>anu-pq</C> program, <C>PqComputeTails</C> uses menu item
 7 of the Advanced <M>p</M>-Quotient menu.
 </Description>
 </ManSection>
@@ -1239,7 +1239,7 @@
 <Func Name="PqAddTails" Arg="i, weight"/>
 <Func Name="PqAddTails" Arg="weight" Label="for default process"/>
 <Description>
-for the <A>i</A>th or default interactive &ANUPQ; process, direct the <C>pq</C>
+for the <A>i</A>th or default interactive &ANUPQ; process, direct the <C>anu-pq</C>
 program to add the tails of weight <A>weight</A>, previously computed by
 <C>PqComputeTails</C> (see&nbsp;<Ref Func="PqComputeTails" Style="Text"/>), if <A>weight</A> is in the integer
 range <C>[2 .. PqPClass(<A>i</A>)]</C> (assuming <A>i</A> is the number of the process,
@@ -1248,7 +1248,7 @@
 <P/>
 
 <E>Note:</E>
-For those familiar with the <C>pq</C> program, <C>PqAddTails</C> uses menu item 7 of
+For those familiar with the <C>anu-pq</C> program, <C>PqAddTails</C> uses menu item 7 of
 the Advanced <M>p</M>-Quotient menu.
 </Description>
 </ManSection>
@@ -1302,7 +1302,7 @@
 been added (see&nbsp;<Ref Func="PqTails" Style="Text"/>).
 <P/>
 
-For those familiar with the <C>pq</C> program, <C>PqDoConsistencyChecks</C> performs
+For those familiar with the <C>anu-pq</C> program, <C>PqDoConsistencyChecks</C> performs
 menu item 8 of the Advanced <M>p</M>-Quotient menu.
 </Description>
 </ManSection>
@@ -1311,7 +1311,7 @@
 <Func Name="PqCollectDefiningRelations" Arg="i"/>
 <Func Name="PqCollectDefiningRelations" Arg="" Label="for default process"/>
 <Description>
-for the <A>i</A>th or default interactive &ANUPQ; process, direct the <C>pq</C>
+for the <A>i</A>th or default interactive &ANUPQ; process, direct the <C>anu-pq</C>
 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&nbsp;<Ref Func="PqNextClass" Style="Text"/>). If the tails
@@ -1320,7 +1320,7 @@
 <P/>
 
 <E>Note:</E>
-For those familiar with the <C>pq</C> program, <C>PqCollectDefiningRelations</C>
+For those familiar with the <C>anu-pq</C> program, <C>PqCollectDefiningRelations</C>
 performs menu item 9 of the Advanced <M>p</M>-Quotient menu.
 </Description>
 </ManSection>
@@ -1342,7 +1342,7 @@
 <P/>
 
 <E>Note:</E>
-For those familiar with the <C>pq</C> program, <C>PqCollectDefiningGenerators</C>
+For those familiar with the <C>anu-pq</C> program, <C>PqCollectDefiningGenerators</C>
 performs menu item 23 of the Advanced <M>p</M>-Quotient menu.
 </Description>
 </ManSection>
@@ -1362,7 +1362,7 @@
 <P/>
 
 <E>Note</E>
-For those familiar with the <C>pq</C> program, <C>PqCommutatorDefiningGenerators</C>
+For those familiar with the <C>anu-pq</C> program, <C>PqCommutatorDefiningGenerators</C>
 performs menu item 24 of the Advanced <M>p</M>-Quotient menu.
 </Description>
 </ManSection>
@@ -1371,7 +1371,7 @@
 <Func Name="PqDoExponentChecks" Arg="i : [ Bounds := list ]"/>
 <Func Name="PqDoExponentChecks" Arg=": [ Bounds := list ]" Label="for default process"/>
 <Description>
-for the <A>i</A>th or default interactive &ANUPQ; process, direct the <C>pq</C>
+for the <A>i</A>th or default interactive &ANUPQ; process, direct the <C>anu-pq</C>
 program to do exponent checks for weights (inclusively) between the bounds
 of <C>Bounds</C> or for all weights if <C>Bounds</C> is not given. The value <A>list</A>
 of <C>Bounds</C> (assuming the interactive process is numbered <A>i</A>) should be a
@@ -1383,7 +1383,7 @@
 <P/>
 
 <E>Note:</E>
-For those familiar with the <C>pq</C> program, <C>PqDoExponentChecks</C> performs
+For those familiar with the <C>anu-pq</C> program, <C>PqDoExponentChecks</C> performs
 menu item 10 of the Advanced <M>p</M>-Quotient menu.
 </Description>
 </ManSection>
@@ -1392,12 +1392,12 @@
 <Func Name="PqEliminateRedundantGenerators" Arg="i"/>
 <Func Name="PqEliminateRedundantGenerators" Arg="" Label="for default process"/>
 <Description>
-for the <A>i</A>th or default interactive &ANUPQ; process, direct the <C>pq</C>
+for the <A>i</A>th or default interactive &ANUPQ; process, direct the <C>anu-pq</C>
 program to eliminate redundant generators of the current <M>p</M>-quotient.
 <P/>
 
 <E>Note:</E> 
-For those familiar with the <C>pq</C> program, <C>PqEliminateRedundantGenerators</C>
+For those familiar with the <C>anu-pq</C> program, <C>PqEliminateRedundantGenerators</C>
 performs menu item 11 of the Advanced <M>p</M>-Quotient menu.
 </Description>
 </ManSection>
@@ -1406,12 +1406,12 @@
 <Func Name="PqRevertToPreviousClass" Arg="i"/>
 <Func Name="PqRevertToPreviousClass" Arg="" Label="for default process"/>
 <Description>
-for the <A>i</A>th or default interactive &ANUPQ; process, direct the <C>pq</C>
+for the <A>i</A>th or default interactive &ANUPQ; process, direct the <C>anu-pq</C>
 program to abandon the current class and revert to the previous class.
 <P/>
 
 <E>Note:</E>
-For those familiar with the <C>pq</C> program, <C>PqRevertToPreviousClass</C>
+For those familiar with the <C>anu-pq</C> program, <C>PqRevertToPreviousClass</C>
 performs menu item 12 of the Advanced <M>p</M>-Quotient menu.
 </Description>
 </ManSection>
@@ -1420,7 +1420,7 @@
 <Func Name="PqSetMaximalOccurrences" Arg="i, noccur"/>
 <Func Name="PqSetMaximalOccurrences" Arg="noccur" Label="for default process"/>
 <Description>
-for the <A>i</A>th or default interactive &ANUPQ; process, direct the <C>pq</C>
+for the <A>i</A>th or default interactive &ANUPQ; process, direct the <C>anu-pq</C>
 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
@@ -1435,7 +1435,7 @@
 <P/>
 
 <E>Note:</E>
-For those familiar with the <C>pq</C> program, <C>PqSetMaximalOccurrences</C>
+For those familiar with the <C>anu-pq</C> program, <C>PqSetMaximalOccurrences</C>
 performs menu item 13 of the Advanced <M>p</M>-Quotient menu.
 </Description>
 </ManSection>
@@ -1444,12 +1444,12 @@
 <Func Name="PqSetMetabelian" Arg="i"/>
 <Func Name="PqSetMetabelian" Arg="" Label="for default process"/>
 <Description>
-for the <A>i</A>th or default interactive &ANUPQ; process, direct the <C>pq</C>
+for the <A>i</A>th or default interactive &ANUPQ; process, direct the <C>anu-pq</C>
 program to enforce metabelian-ness.
 <P/>
 
 <E>Note:</E> 
-For those familiar with the <C>pq</C> program, <C>PqSetMetabelian</C> performs
+For those familiar with the <C>anu-pq</C> program, <C>PqSetMetabelian</C> performs
 menu item 14 of the Advanced <M>p</M>-Quotient menu.
 </Description>
 </ManSection>
@@ -1460,7 +1460,7 @@
 <Func Name="PqJacobi" Arg="i, c, b, a"/>
 <Func Name="PqJacobi" Arg="c, b, a" Label="for default process"/>
 <Description>
-for the <A>i</A>th or default interactive &ANUPQ; process, direct the <C>pq</C>
+for the <A>i</A>th or default interactive &ANUPQ; process, direct the <C>anu-pq</C>
 program to do the consistency check for the pc generators with indices
 <A>c</A>, <A>b</A>, <A>a</A> which should be non-increasing positive integers, i.e.&nbsp;<M><A>c</A>
 \ge <A>b</A> \ge <A>a</A></M>.
@@ -1503,7 +1503,7 @@
 <P/>
 
 <E>Note:</E>
-For those familiar with the <C>pq</C> program, <C>PqDoConsistencyCheck</C> and
+For those familiar with the <C>anu-pq</C> program, <C>PqDoConsistencyCheck</C> and
 <C>PqJacobi</C> perform menu item 15 of the Advanced <M>p</M>-Quotient menu.
 </Description>
 </ManSection>
@@ -1512,13 +1512,13 @@
 <Func Name="PqCompact" Arg="i"/>
 <Func Name="PqCompact" Arg="" Label="for default process"/>
 <Description>
-for the <A>i</A>th or default interactive &ANUPQ; process, direct the <C>pq</C>
+for the <A>i</A>th or default interactive &ANUPQ; process, direct the <C>anu-pq</C>
 program to do a compaction of its work space. This function is safe to
 perform only at certain points in time.
 <P/>
 
 <E>Note:</E>
-For those familiar with the <C>pq</C> program, <C>PqCompact</C> performs menu item
+For those familiar with the <C>anu-pq</C> program, <C>PqCompact</C> performs menu item
 16 of the Advanced <M>p</M>-Quotient menu.
 </Description>
 </ManSection>
@@ -1527,7 +1527,7 @@
 <Func Name="PqEchelonise" Arg="i"/>
 <Func Name="PqEchelonise" Arg="" Label="for default process"/>
 <Description>
-for the <A>i</A>th or default interactive &ANUPQ; process, direct the <C>pq</C>
+for the <A>i</A>th or default interactive &ANUPQ; process, direct the <C>anu-pq</C>
 program to echelonise the word most recently collected by <C>PqCollect</C> or
 <C>PqCommutator</C> against the relations of the current pc presentation, and
 return the number of the generator made redundant or <K>fail</K> if no
@@ -1537,7 +1537,7 @@
 <P/>
 
 <E>Note:</E>
-For those familiar with the <C>pq</C> program, <C>PqEchelonise</C> performs menu
+For those familiar with the <C>anu-pq</C> program, <C>PqEchelonise</C> performs menu
 item 17 of the Advanced <M>p</M>-Quotient menu.
 </Description>
 </ManSection>
@@ -1563,7 +1563,7 @@
 </List>
 
 <E>Note:</E> 
-For those familiar with the <C>pq</C> program, <C>PqSupplyAutomorphisms</C> uses
+For those familiar with the <C>anu-pq</C> program, <C>PqSupplyAutomorphisms</C> uses
 menu item 18 of the Advanced <M>p</M>-Quotient menu.
 </Description>
 </ManSection>
@@ -1572,13 +1572,13 @@
 <Func Name="PqExtendAutomorphisms" Arg="i"/>
 <Func Name="PqExtendAutomorphisms" Arg="" Label="for default process"/>
 <Description>
-for the <A>i</A>th or default interactive &ANUPQ; process, direct the <C>pq</C>
+for the <A>i</A>th or default interactive &ANUPQ; process, direct the <C>anu-pq</C>
 program to extend automorphisms of the <M>p</M>-quotient of the previous class
 to the <M>p</M>-quotient of the present class. 
 <P/>
 
 <E>Note:</E>
-For those familiar with the <C>pq</C> program, <C>PqExtendAutomorphisms</C> uses
+For those familiar with the <C>anu-pq</C> program, <C>PqExtendAutomorphisms</C> uses
 menu item 18 of the Advanced <M>p</M>-Quotient menu.
 </Description>
 </ManSection>
@@ -1587,12 +1587,12 @@
 <Func Name="PqApplyAutomorphisms" Arg="i, qfac"/>
 <Func Name="PqApplyAutomorphisms" Arg="qfac" Label="for default process"/>
 <Description>
-for the <A>i</A>th or default interactive &ANUPQ; process, direct the <C>pq</C>
+for the <A>i</A>th or default interactive &ANUPQ; process, direct the <C>anu-pq</C>
 program to apply automorphisms; <A>qfac</A> is the queue factor e.g. <C>15</C>.
 <P/>
 
 <E>Note:</E> 
-For those familiar with the <C>pq</C> program, <C>PqCloseRelations</C> performs
+For those familiar with the <C>anu-pq</C> program, <C>PqCloseRelations</C> performs
 menu item 19 of the Advanced <M>p</M>-Quotient menu.
 </Description>
 </ManSection>
@@ -1601,7 +1601,7 @@
 <Func Name="PqDisplayStructure" Arg="i : [ Bounds := list ]"/>
 <Func Name="PqDisplayStructure" Arg=": [ Bounds := list ]" Label="for default process"/>
 <Description>
-for the <A>i</A>th or default interactive &ANUPQ; process, direct the <C>pq</C>
+for the <A>i</A>th or default interactive &ANUPQ; process, direct the <C>anu-pq</C>
 program to display the structure for the pcp generators numbered
 (inclusively) between the bounds of <C>Bounds</C> or for all generators if
 <C>Bounds</C> is not given. The value <A>list</A> of <C>Bounds</C> (assuming the
@@ -1680,7 +1680,7 @@
 </List>
 
 <E>Note:</E>
-For those familiar with the <C>pq</C> program, <C>PqDisplayStructure</C> performs
+For those familiar with the <C>anu-pq</C> program, <C>PqDisplayStructure</C> performs
 menu item 20 of the Advanced <M>p</M>-Quotient menu.
 </Description>
 </ManSection>
@@ -1689,7 +1689,7 @@
 <Func Name="PqDisplayAutomorphisms" Arg="i : [ Bounds := list ]"/>
 <Func Name="PqDisplayAutomorphisms" Arg=": [ Bounds := list ]" Label="for default process"/>
 <Description>
-for the <A>i</A>th or default interactive &ANUPQ; process, direct the <C>pq</C>
+for the <A>i</A>th or default interactive &ANUPQ; process, direct the <C>anu-pq</C>
 program to display the automorphism actions on the pcp generators numbered
 (inclusively) between the bounds of <C>Bounds</C> or for all generators if
 <C>Bounds</C> is not given. The value <A>list</A> of <C>Bounds</C> (assuming the
@@ -1701,7 +1701,7 @@
 <P/>
 
 <E>Note:</E>
-For those familiar with the <C>pq</C> program, <C>PqDisplayAutomorphisms</C>
+For those familiar with the <C>anu-pq</C> program, <C>PqDisplayAutomorphisms</C>
 performs menu item 21 of the Advanced <M>p</M>-Quotient menu.
 </Description>
 </ManSection>
@@ -1710,7 +1710,7 @@
 <Func Name="PqWritePcPresentation" Arg="i, filename"/>
 <Func Name="PqWritePcPresentation" Arg="filename" Label="for default process"/>
 <Description>
-for the <A>i</A>th or default interactive &ANUPQ; process, direct the <C>pq</C>
+for the <A>i</A>th or default interactive &ANUPQ; process, direct the <C>anu-pq</C>
 program to write a pc presentation of a previously-computed quotient of
 the group of that process, to the file with name <A>filename</A>. Here the
 group of a process is the one given as first argument when <C>PqStart</C> was
@@ -1718,12 +1718,12 @@
 <C>ANUPQData.io[<A>i</A>].group</C>). If the first character of the string
 <A>filename</A> is not <C>/</C>, <A>filename</A> 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 <C>pq</C> program, then
-<C>pq</C> is called to compute it first, effectively invoking
+presentation has not been previously computed by the <C>anu-pq</C> program, then
+<C>anu-pq</C> is called to compute it first, effectively invoking
 <C>PqPcPresentation</C> (see&nbsp;<Ref Func="PqPcPresentation" Style="Text"/>).
 <P/>
 
-<E>Note:</E> For those familiar with the <C>pq</C> program, <C>PqPcWritePresentation</C>
+<E>Note:</E> For those familiar with the <C>anu-pq</C> program, <C>PqPcWritePresentation</C>
 performs menu item 25 of the Advanced <M>p</M>-Quotient menu.
 <P/>
 
@@ -1731,7 +1731,7 @@
 <!-- %\>PqWriteCompactDescription( <A>i</A> ) F -->
 <!-- %\>PqWriteCompactDescription() F -->
 <!-- % -->
-<!-- %for the <A>i</A>th or default interactive &ANUPQ; process, direct the <C>pq</C> -->
+<!-- %for the <A>i</A>th or default interactive &ANUPQ; process, direct the <C>anu-pq</C> -->
 <!-- %program to write a compact description -->
 <!-- % -->
 <!-- %<E>OF ....</E> -->
@@ -1739,7 +1739,7 @@
 <!-- %to a file. -->
 <!-- % -->
 <!-- %<E>Note:</E> -->
-<!-- %For those familiar with the <C>pq</C> program, <C>PqWriteCompactDescription</C> -->
+<!-- %For those familiar with the <C>anu-pq</C> program, <C>PqWriteCompactDescription</C> -->
 <!-- %performs menu item 26 of the Advanced <M>p</M>-Quotient menu. -->
 </Description>
 </ManSection>
@@ -1752,7 +1752,7 @@
 <Func Name="PqSPComputePcpAndPCover" Arg="i : options"/>
 <Func Name="PqSPComputePcpAndPCover" Arg=": options" Label="for default process"/>
 <Description>
-for the <A>i</A>th or default interactive &ANUPQ; process, directs the <C>pq</C>
+for the <A>i</A>th or default interactive &ANUPQ; process, directs the <C>anu-pq</C>
 program to compute for the group of that process a pc presentation up to
 the <M>p</M>-quotient of maximum class or the value of the option <C>ClassBound</C>
 and the <M>p</M>-cover of that quotient, and sets up tabular information
@@ -1770,7 +1770,7 @@
 <P/>
 
 <E>Note:</E>
-For those familiar with the <C>pq</C> program, <C>PqSPComputePcpAndPCover</C>
+For those familiar with the <C>anu-pq</C> program, <C>PqSPComputePcpAndPCover</C>
 performs option 1 of the Standard Presentation menu.
 </Description>
 </ManSection>
@@ -1815,7 +1815,7 @@
 Detailed descriptions of the above options may be found in Chapter&nbsp;<Ref Chap="ANUPQ Options" Style="Text"/>.
 <P/>
 
-<E>Note:</E> For those familiar with the <C>pq</C> program, <C>PqSPPcPresentation</C>
+<E>Note:</E> For those familiar with the <C>anu-pq</C> program, <C>PqSPPcPresentation</C>
 performs menu item 2 of the Standard Presentation menu.
 </Description>
 </ManSection>
@@ -1824,7 +1824,7 @@
 <Func Name="PqSPSavePresentation" Arg="i, filename"/>
 <Func Name="PqSPSavePresentation" Arg="filename" Label="for default process"/>
 <Description>
-for the <A>i</A>th or default interactive &ANUPQ; process, directs the <C>pq</C>
+for the <A>i</A>th or default interactive &ANUPQ; process, directs the <C>anu-pq</C>
 program to save the standard presentation previously computed for the
 group of that process to the file with name <A>filename</A>, where the group
 of a process is the one given as first argument when <C>PqStart</C> was called
@@ -1833,7 +1833,7 @@
 relative to the directory in which &GAP; was started.
 <P/>
 
-<E>Note:</E> For those familiar with the <C>pq</C> program, <C>PqSPSavePresentation</C>
+<E>Note:</E> For those familiar with the <C>anu-pq</C> program, <C>PqSPSavePresentation</C>
 performs menu item 3 of the Standard Presentation menu.
 </Description>
 </ManSection>
@@ -1842,7 +1842,7 @@
 <Func Name="PqSPCompareTwoFilePresentations" Arg="i, f1, f2"/>
 <Func Name="PqSPCompareTwoFilePresentations" Arg="f1, f2" Label="for default process"/>
 <Description>
-for the <A>i</A>th or default interactive &ANUPQ; process, direct the <C>pq</C>
+for the <A>i</A>th or default interactive &ANUPQ; process, direct the <C>anu-pq</C>
 program to compare the presentations in the files with names <A>f1</A> and <A>f2</A>
 and returns <K>true</K> if they are identical and <K>false</K> otherwise. For each
 of the strings <A>f1</A> and <A>f2</A>, if the first character is not a <C>/</C> then it
@@ -1854,14 +1854,14 @@
 <P/>
 
 The presentations in files <A>f1</A> and <A>f2</A> must have been generated by the
-<C>pq</C> program but they do <E>not</E> need to be <E>standard</E> presentations. If If
+<C>anu-pq</C> program but they do <E>not</E> need to be <E>standard</E> presentations. If If
 the presentations in files <A>f1</A> and <A>f2</A> <E>have</E> been generated by
 <C>PqSPStandardPresentation</C> (see&nbsp;<Ref Func="PqSPStandardPresentation" Style="Text"/>) then a
 <K>false</K> response from <C>PqSPCompareTwoFilePresentations</C> says the groups
 defined by those presentations are <E>not</E> isomorphic.
 <P/>
 
-For those familiar with the <C>pq</C> program,
+For those familiar with the <C>anu-pq</C> program,
 <C>PqSPCompareTwoFilePresentations</C> performs menu item 6 of the Standard
 Presentation menu.
 </Description>
@@ -1871,7 +1871,7 @@
 <Func Name="PqSPIsomorphism" Arg="i"/>
 <Func Name="PqSPIsomorphism" Arg="" Label="for default process"/>
 <Description>
-for the <A>i</A>th or default interactive &ANUPQ; process, direct the <C>pq</C>
+for the <A>i</A>th or default interactive &ANUPQ; process, direct the <C>anu-pq</C>
 program to compute the isomorphism mapping from the <M>p</M>-group of the
 process to its standard presentation. This function provides a
 description only; for a &GAP; object, use
@@ -1879,7 +1879,7 @@
 (see&nbsp;<Ref Func="EpimorphismStandardPresentation" Label="interactive" Style="Text"/>).
 <P/>
 
-<E>Note:</E> For those familiar with the <C>pq</C> program, <C>PqSPIsomorphism</C>
+<E>Note:</E> For those familiar with the <C>anu-pq</C> program, <C>PqSPIsomorphism</C>
 performs menu item 8 of the Standard Presentation menu.
 </Description>
 </ManSection>
@@ -1889,14 +1889,14 @@
 <Section><Heading>Commands from the Main <M>p</M>-Group Generation menu</Heading>
 
 Note that the <M>p</M>-group generation commands can only be applied once the
-<C>pq</C> program has produced a pc presentation of some quotient group of the
+<C>anu-pq</C> program has produced a pc presentation of some quotient group of the
 <Q>group of the process</Q>.
 
 <ManSection>
 <Func Name="PqPGSupplyAutomorphisms" Arg="i[, mlist] : options"/>
 <Func Name="PqPGSupplyAutomorphisms" Arg="[mlist] : options" Label="for default process"/>
 <Description>
-for the <A>i</A>th or default interactive &ANUPQ; process, supply the <C>pq</C>
+for the <A>i</A>th or default interactive &ANUPQ; process, supply the <C>anu-pq</C>
 program with the automorphism group data needed for the current quotient
 of the group of that process (for process <A>i</A> the group is stored as
 <C>ANUPQData.io[<A>i</A>].group</C>). For a description of the format of <A>mlist</A>
@@ -1910,7 +1910,7 @@
 <P/>
 
 <E>Note:</E>
-For those familiar with the <C>pq</C> program, <C>PqPGSupplyAutomorphisms</C>
+For those familiar with the <C>anu-pq</C> program, <C>PqPGSupplyAutomorphisms</C>
 performs menu item 1 of the main <M>p</M>-Group Generation menu.
 </Description>
 </ManSection>
@@ -1919,15 +1919,15 @@
 <Func Name="PqPGExtendAutomorphisms" Arg="i"/>
 <Func Name="PqPGExtendAutomorphisms" Arg="" Label="for default process"/>
 <Description>
-for the <A>i</A>th or default interactive &ANUPQ; process, direct the <C>pq</C>
+for the <A>i</A>th or default interactive &ANUPQ; process, direct the <C>anu-pq</C>
 program to compute the extensions of the automorphisms of the
 <M>p</M>-quotient of the previous class to the <M>p</M>-quotient of the current
 class. You may wish to set the <C>InfoLevel</C> of <C>InfoANUPQ</C> to 2 (or more)
-in order to see the output from the <C>pq</C> program (see&nbsp;<Ref Func="InfoANUPQ" Style="Text"/>).
+in order to see the output from the <C>anu-pq</C> program (see&nbsp;<Ref Func="InfoANUPQ" Style="Text"/>).
 <P/>
 
 <E>Note:</E> 
-For those familiar with the <C>pq</C> program, <C>PqPGExtendAutomorphisms</C>
+For those familiar with the <C>anu-pq</C> program, <C>PqPGExtendAutomorphisms</C>
 performs menu item 2 of the main or advanced <M>p</M>-Group Generation menu. 
 </Description>
 </ManSection>
@@ -1936,7 +1936,7 @@
 <Func Name="PqPGConstructDescendants" Arg="i : options"/>
 <Func Name="PqPGConstructDescendants" Arg=": options" Label="for default process"/>
 <Description>
-for the <A>i</A>th or default interactive &ANUPQ; process, direct the <C>pq</C>
+for the <A>i</A>th or default interactive &ANUPQ; process, direct the <C>anu-pq</C>
 program to construct descendants prescribed by <A>options</A>, and return the
 number of descendants constructed (compare function&nbsp;<Ref Func="PqDescendants" Style="Text"/> which
 returns the list of descendants). The options possible are <C>ClassBound</C>,
@@ -1947,13 +1947,13 @@
 in Chapter&nbsp;<Ref Chap="ANUPQ Options" Style="Text"/>.)
 <P/>
 
-<C>PqPGConstructDescendants</C> requires that the <C>pq</C> program has previously
+<C>PqPGConstructDescendants</C> requires that the <C>anu-pq</C> program has previously
 computed a pc presentation and a <M>p</M>-cover for a <M>p</M>-quotient of some
 class of the group of the process.
 <P/>
 
 <E>Note:</E> 
-For those familiar with the <C>pq</C> program, <C>PqPGConstructDescendants</C>
+For those familiar with the <C>anu-pq</C> program, <C>PqPGConstructDescendants</C>
 performs menu item 5 of the main <M>p</M>-Group Generation menu.
 </Description>
 </ManSection>
@@ -1968,7 +1968,7 @@
 <Func Name="PqPGRestoreDescendantFromFile" Arg="i : [ Filename := name ]"/>
 <Func Name="PqPGRestoreDescendantFromFile" Arg=": [ Filename := name ]" Label="for default process"/>
 <Description>
-for the <A>i</A>th or default interactive &ANUPQ; process, direct the <C>pq</C>
+for the <A>i</A>th or default interactive &ANUPQ; process, direct the <C>anu-pq</C>
 program to restore group <A>n</A> of class <A>cls</A> from a temporary file, where
 <A>cls</A> and <A>n</A> are positive integers, or the group stored in <A>name</A>.
 <C>PqPGSetDescendantToPcp</C> and <C>PqPGRestoreDescendantFromFile</C> are
@@ -1977,20 +1977,20 @@
 (see&nbsp;<Ref Func="PqPGConstructDescendants" Style="Text"/>) or the interactive <C>PqDescendants</C>
 (see&nbsp;<Ref Func="PqDescendants" Label="interactive" Style="Text"/>). In the <C>Filename</C> option forms, the
 option defaults to the last filename in which a presentation was stored
-by the <C>pq</C> program.
+by the <C>anu-pq</C> program.
 <P/>
 
 <E>Notes</E>
 <P/>
 
 Since the <C>PqPGSetDescendantToPcp</C> and <C>PqPGRestoreDescendantFromFile</C>
-are intended to be used in calculation of further descendants the <C>pq</C>
+are intended to be used in calculation of further descendants the <C>anu-pq</C>
 program computes the <M>p</M>-cover of the restored descendant. Hence,
 <C>PqCurrentGroup</C> used immediately after one of these commands returns the
 <M>p</M>-cover of the restored descendant rather than the descendant itself.
 <P/>
 
-For those familiar with the <C>pq</C> program, <C>PqPGSetDescendantToPcp</C> and
+For those familiar with the <C>anu-pq</C> program, <C>PqPGSetDescendantToPcp</C> and
 <C>PqPGRestoreDescendantFromFile</C> perform menu item 3 of the main or
 advanced <M>p</M>-Group Generation menu.
 </Description>
@@ -2016,17 +2016,17 @@
 <Func Name="PqAPGDegree" Arg="i, step, rank : [ Exponent := n ]"/>
 <Func Name="PqAPGDegree" Arg="step, rank : [ Exponent := n ]" Label="for default process"/>
 <Description>
-<!-- %for the <A>i</A>th or default interactive &ANUPQ; process, direct the <C>pq</C> -->
+<!-- %for the <A>i</A>th or default interactive &ANUPQ; process, direct the <C>anu-pq</C> -->
 <!-- %program to compute definition sets and return the degree of the -->
 <!-- %permutation group. Here the step-size <A>step</A> and the rank <A>rank</A> of the -->
 <!-- %initial segment subgroup are positive integers. See&nbsp;<Ref Label="option Exponent" Style="Text"/> for -->
 <!-- %the one recognised option <C>Exponent</C>. -->
-for the <A>i</A>th or default interactive &ANUPQ; process, direct the <C>pq</C>
+for the <A>i</A>th or default interactive &ANUPQ; process, direct the <C>anu-pq</C>
 program to invoke menu item 6 of the Advanced <M>p</M>-Group Generation menu.
 Here the step-size <A>step</A> and the rank <A>rank</A> are positive integers and
-are the arguments required by the <C>pq</C> program. See&nbsp;<Ref Label="option Exponent" Style="Text"/>
+are the arguments required by the <C>anu-pq</C> program. See&nbsp;<Ref Label="option Exponent" Style="Text"/>
 for the one recognised option <C>Exponent</C>.
-<!-- %<E>Note:</E> For those familiar with the <C>pq</C> program, <C>PqAPGDegree</C> performs -->
+<!-- %<E>Note:</E> For those familiar with the <C>anu-pq</C> program, <C>PqAPGDegree</C> performs -->
 <!-- %menu item 6 of the Advanced <M>p</M>-Group Generation menu. -->
 </Description>
 </ManSection>
@@ -2035,14 +2035,14 @@
 <Func Name="PqAPGPermutations" Arg="i : options"/>
 <Func Name="PqAPGPermutations" Arg=": options" Label="for default process"/>
 <Description>
-<!-- %for the <A>i</A>th or default interactive &ANUPQ; process, direct the <C>pq</C> -->
+<!-- %for the <A>i</A>th or default interactive &ANUPQ; process, direct the <C>anu-pq</C> -->
 <!-- %program to compute permutations of subgroups. -->
-for the <A>i</A>th or default interactive &ANUPQ; process, direct the <C>pq</C>
+for the <A>i</A>th or default interactive &ANUPQ; process, direct the <C>anu-pq</C>
 program to perform menu item 7 of the Advanced <M>p</M>-Group Generation menu.
 Here the options <A>options</A> recognised are <C>PcgsAutomorphisms</C>,
 <C>SpaceEfficient</C>, <C>PrintAutomorphisms</C> and <C>PrintPermutations</C> (see
 Chapter&nbsp;<Ref Chap="ANUPQ Options" Style="Text"/> for details).
-<!-- %<E>Note:</E> For those familiar with the <C>pq</C> program, <C>PqAPGPermutations</C> -->
+<!-- %<E>Note:</E> For those familiar with the <C>anu-pq</C> program, <C>PqAPGPermutations</C> -->
 <!-- %performs menu item 7 of the Advanced <M>p</M>-Group Generation menu. -->
 </Description>
 </ManSection>
@@ -2051,11 +2051,11 @@
 <Func Name="PqAPGOrbits" Arg="i : options"/>
 <Func Name="PqAPGOrbits" Arg=": options" Label="for default process"/>
 <Description>
-<!-- %for the <A>i</A>th or default interactive &ANUPQ; process, direct the <C>pq</C> -->
+<!-- %for the <A>i</A>th or default interactive &ANUPQ; process, direct the <C>anu-pq</C> -->
 <!-- %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 <A>i</A>th or default interactive &ANUPQ; process, direct the <C>pq</C>
+for the <A>i</A>th or default interactive &ANUPQ; process, direct the <C>anu-pq</C>
 to perform menu item 8 of the Advanced <M>p</M>-Group Generation menu.
 <P/>
 
@@ -2063,7 +2063,7 @@
 <C>SpaceEfficient</C> and <C>CustomiseOutput</C> (see Chapter&nbsp;<Ref Chap="ANUPQ Options" Style="Text"/> for
 details). For the <C>CustomiseOutput</C> option only the setting of the
 <C>orbit</C> is recognised (all other fields if set are ignored).
-<!-- %<E>Note:</E> For those familiar with the <C>pq</C> program, <C>PqAPGOrbits</C> performs -->
+<!-- %<E>Note:</E> For those familiar with the <C>anu-pq</C> program, <C>PqAPGOrbits</C> performs -->
 <!-- %menu item 8 of the Advanced <M>p</M>-Group Generation menu. -->
 </Description>
 </ManSection>
@@ -2072,10 +2072,10 @@
 <Func Name="PqAPGOrbitRepresentatives" Arg="i : options"/>
 <Func Name="PqAPGOrbitRepresentatives" Arg=": options" Label="for default process"/>
 <Description>
-<!-- %for the <A>i</A>th or default interactive &ANUPQ; process, direct the <C>pq</C> -->
+<!-- %for the <A>i</A>th or default interactive &ANUPQ; process, direct the <C>anu-pq</C> -->
 <!-- %program to process the orbit representatives and output the reduced -->
 <!-- %<M>p</M>-cover to a file. -->
-for the <A>i</A>th or default interactive &ANUPQ; process, direct the <C>pq</C>
+for the <A>i</A>th or default interactive &ANUPQ; process, direct the <C>anu-pq</C>
 to perform item 9 of the Advanced <M>p</M>-Group Generation menu.
 <P/>
 
@@ -2087,7 +2087,7 @@
 reduced <M>p</M>-cover is written to the file <C>"redPCover"</C> in the temporary
 directory whose name is stored in <C>ANUPQData.tmpdir</C>.
 <!-- %<E>Note:</E> -->
-<!-- %For those familiar with the <C>pq</C> program, <C>PqAPGOrbitRepresentatives</C> -->
+<!-- %For those familiar with the <C>anu-pq</C> program, <C>PqAPGOrbitRepresentatives</C> -->
 <!-- %performs option 9 of the Advanced <M>p</M>-Group Generation menu. -->
 </Description>
 </ManSection>
@@ -2096,10 +2096,10 @@
 <Func Name="PqAPGSingleStage" Arg="i : options"/>
 <Func Name="PqAPGSingleStage" Arg=": options" Label="for default process"/>
 <Description>
-<!-- %for the <A>i</A>th or default interactive &ANUPQ; process, direct the <C>pq</C> -->
+<!-- %for the <A>i</A>th or default interactive &ANUPQ; process, direct the <C>anu-pq</C> -->
 <!-- %program to do a single stage of the descendants construction algorithm as -->
 <!-- %prescribed by <A>options</A>. -->
-for the <A>i</A>th or default interactive &ANUPQ; process, direct the <C>pq</C>
+for the <A>i</A>th or default interactive &ANUPQ; process, direct the <C>anu-pq</C>
 to perform option 5 of the Advanced <M>p</M>-Group Generation menu.
 <P/>
 
@@ -2109,7 +2109,7 @@
 <C>CustomiseOutput</C>. (Detailed descriptions of these options may be found
 in Chapter&nbsp;<Ref Chap="ANUPQ Options" Style="Text"/>.)
 <!-- %<E>Note:</E> -->
-<!-- %For those familiar with the <C>pq</C> program, <C>PqAPGSingleStage</C> performs -->
+<!-- %For those familiar with the <C>anu-pq</C> program, <C>PqAPGSingleStage</C> performs -->
 <!-- %option 5 of the Advanced <M>p</M>-Group Generation menu. -->
 </Description>
 </ManSection>
@@ -2120,10 +2120,10 @@
 <Section Label="Primitive Interactive ANUPQ Process Read/Write Functions">
 <Heading>Primitive Interactive ANUPQ Process Read/Write Functions</Heading>
 
-For those familiar with using the <C>pq</C> program as a standalone we provide
+For those familiar with using the <C>anu-pq</C> program as a standalone we provide
 primitive read/write tools to communicate directly with an interactive
 &ANUPQ; process, started via <C>PqStart</C>. For the most part, it is up to
-the user to translate the output strings from <C>pq</C> program into a form
+the user to translate the output strings from <C>anu-pq</C> program into a form
 useful in &GAP;.
 
 <ManSection>
@@ -2138,7 +2138,7 @@
 <K>fail</K> purely because the output from &ANUPQ; is not there yet), but if
 <C>PqRead</C> finds any output at all, it waits for a complete line. <C>PqRead</C>
 also writes the line read via <C>Info</C> at <C>InfoANUPQ</C> level 2. It doesn't
-try to distinguish banner and menu output from other output of the <C>pq</C>
+try to distinguish banner and menu output from other output of the <C>anu-pq</C>
 program.
 </Description>
 </ManSection>
@@ -2152,7 +2152,7 @@
 <E>at the time of the call</E>, as a list of strings with any trailing
 newlines removed and returns the empty list otherwise. <C>PqReadAll</C> also
 writes each line read via <C>Info</C> at <C>InfoANUPQ</C> level 2. It doesn't try
-to distinguish banner and menu output from other output of the <C>pq</C>
+to distinguish banner and menu output from other output of the <C>anu-pq</C>
 program. Whenever <C>PqReadAll</C> 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;.
@@ -2169,7 +2169,7 @@
 interactive &ANUPQ; process, <Q>chomps</Q> them (i.e.&nbsp;removes any trailing
 newline character), emits them to <C>Info</C> at <C>InfoANUPQ</C> level 2 (without
 trying to distinguish banner and menu output from other output of the
-<C>pq</C> program), and applies the function <A>Modify</A> (where <A>Modify</A> is just
+<C>anu-pq</C> program), and applies the function <A>Modify</A> (where <A>Modify</A> is just
 the identity map/function for the first two forms) until a <Q>chomped</Q>
 line <A>line</A> for which <C><A>IsMyLine</A>( <A>Modify</A>(<A>line</A>) )</C> is true.
 <C>PqReadUntil</C> returns the list of <A>Modify</A>-ed <Q>chomped</Q> lines read.
@@ -2198,7 +2198,7 @@
 <A>string</A> must be in exactly the form the &ANUPQ; standalone expects. The
 command is echoed via <C>Info</C> at <C>InfoANUPQ</C> level 3 (with a <Q><C>ToPQ> </C></Q>
 prompt); i.e.&nbsp;do <C>SetInfoLevel(InfoANUPQ, 3);</C> to see what is transmitted
-to the <C>pq</C> program. <C>PqWrite</C> returns <K>true</K> if successful in writing to
+to the <C>anu-pq</C> program. <C>PqWrite</C> returns <K>true</K> if successful in writing to
 the stream of the interactive &ANUPQ; process, and <K>fail</K> otherwise.
 <P/>
 
--- a/doc/intro.xml
+++ b/doc/intro.xml
@@ -6,14 +6,14 @@
 
 
 <Index>ANUPQ</Index>
-The &GAP;&nbsp;4 package &ANUPQ; provides an interface to the ANU <C>pq</C> C
+The &GAP;&nbsp;4 package &ANUPQ; provides an interface to the ANU <C>anu-pq</C> C
 program written by Eamonn O'Brien, making the functionality of the C
 program available to &GAP;. Henceforth, we shall refer to the &ANUPQ;
-package when referring to the &GAP; interface, and to the ANU <C>pq</C>
-program or just <C>pq</C> when referring to that C program.
+package when referring to the &GAP; interface, and to the ANU <C>anu-pq</C>
+program or just <C>anu-pq</C> when referring to that C program.
 <P/>
 
-The <C>pq</C> program consists of implementations of the following algorithms:
+The <C>anu-pq</C> program consists of implementations of the following algorithms:
 <P/>
 
 <Enum>
@@ -50,7 +50,7 @@
 <M>p</M>-group.
 <P/>
 
-This part of the <C>pq</C> program is not accessible through the &ANUPQ;
+This part of the <C>anu-pq</C> program is not accessible through the &ANUPQ;
 package. Instead, users are advised to consider the &GAP;&nbsp;4 package
 &AutPGrp; by Bettina Eick and Eamonn O'Brien, which implements a better
 algorithm in &GAP; for the computation of automorphism groups of
@@ -97,18 +97,18 @@
 for the options of the functions that are described. The user will become
 best acquainted with the &ANUPQ; package by trying the examples. This
 chapter describes the non-interactive functions of the &ANUPQ; package,
-i.e.&nbsp;<Q>one-shot</Q> functions that invoke the <C>pq</C> program in such a way
-that once &GAP; has got what it needs, the <C>pq</C> is allowed to exit. It
+i.e.&nbsp;<Q>one-shot</Q> functions that invoke the <C>anu-pq</C> program in such a way
+that once &GAP; has got what it needs, the <C>anu-pq</C> is allowed to exit. It
 is expected that most of the time, users will only need these functions.
 <P/>
 
 Advanced users will want to explore Chapter&nbsp;<Ref Chap="Interactive ANUPQ functions" Style="Text"/>
 which describes all the interactive functions of the &ANUPQ; package;
 these are functions that extract information via a dialogue with a
-running <C>pq</C> process. Occasionally, a user needs the <Q>next step</Q>; the
+running <C>anu-pq</C> process. Occasionally, a user needs the <Q>next step</Q>; the
 functions provided in this chapter make use of data from previous steps
-retained by the <C>pq</C> program, thus allowing the user to interact with the
-<C>pq</C> program like one can when one uses the <C>pq</C> program as a stand-alone
+retained by the <C>anu-pq</C> program, thus allowing the user to interact with the
+<C>anu-pq</C> program like one can when one uses the <C>anu-pq</C> program as a stand-alone
 (see&nbsp;<C>guide.dvi</C> in the <C>standalone-doc</C> directory).
 <P/>
 
@@ -134,7 +134,7 @@
 <Section Label="Authors and Acknowledgements">
 <Heading>Authors and Acknowledgements</Heading>
 
-The C implementation of the ANU <C>pq</C> standalone was developed by Eamonn O'Brien.
+The C implementation of the ANU <C>anu-pq</C> standalone was developed by Eamonn O'Brien.
 <P/>
 
 An interactive interface using iostreams was developed with the
--- a/doc/non-interact.xml
+++ b/doc/non-interact.xml
@@ -2,12 +2,12 @@
 <Heading>Non-interactive ANUPQ functions</Heading>
 
 Here we describe all the non-interactive functions of the &ANUPQ;
-package; i.e.&nbsp;<Q>one-shot</Q> functions that invoke the <C>pq</C> program in such
-a way that once &GAP; has got what it needs, the <C>pq</C> program is allowed
+package; i.e.&nbsp;<Q>one-shot</Q> functions that invoke the <C>anu-pq</C> program in such
+a way that once &GAP; has got what it needs, the <C>anu-pq</C> program is allowed
 to exit. It is expected that most of the time users will only need these
 functions. The functions interface with three of the four algorithms (see
-Chapter&nbsp;<Ref Chap="Introduction" Style="Text"/>) provided by the ANU <C>pq</C> C program, and are
-mainly grouped according to the algorithm of the <C>pq</C> program they relate
+Chapter&nbsp;<Ref Chap="Introduction" Style="Text"/>) provided by the ANU <C>anu-pq</C> C program, and are
+mainly grouped according to the algorithm of the <C>anu-pq</C> program they relate
 to.
 <P/>
 
@@ -137,7 +137,7 @@
 
 Now we redo the last example to show how one may use the <C>Relators</C>
 option. Observe that <C>Comm(Comm(b, a), a)</C> is a left normed commutator
-which must be written in square bracket notation for the <C>pq</C> program and
+which must be written in square bracket notation for the <C>anu-pq</C> program and
 embedded in a pair of double quotes. The function <C>PqGAPRelators</C>
 (see&nbsp;<Ref Func="PqGAPRelators" Style="Text"/>) can be used to translate a list of strings prepared
 for the <C>Relators</C> option into &GAP; format. Below we use it. Observe
@@ -648,7 +648,7 @@
 The function <C>PqDescendants</C> uses the automorphism group of <A>G</A> which it
 computes via the package &AutPGrp;. If this package is not installed an
 error may be raised. If the automorphism group of <A>G</A> is insoluble, the
-<C>pq</C> program will call &GAP; together with the &AutPGrp; package for
+<C>anu-pq</C> program will call &GAP; together with the &AutPGrp; package for
 certain orbit-stabilizer calculations. (So, in any case, one should
 ensure the &AutPGrp; package is installed.)
 <P/>
@@ -744,7 +744,7 @@
 <Description>
 returns a generating set for a supplement to the inner automorphisms of
 <A>D</A>, in the form of a record with fields <C>agAutos</C>, <C>agOrder</C> and
-<C>glAutos</C>, as provided by the <C>pq</C> program. One should be very careful in
+<C>glAutos</C>, as provided by the <C>anu-pq</C> program. One should be very careful in
 using these automorphisms for a descendant calculation.
 <!-- %The automorphisms generate a subgroup of the automorphism group of the pc -->
 <!-- %group <A>D</A> that supplements the inner automorphism group of <A>D</A> in the -->
@@ -757,7 +757,7 @@
 <E>Note:</E>
 In principle there must be a way to use those automorphisms in order to
 compute descendants but there does not seem to be a way to hand back
-these automorphisms properly to the <C>pq</C> program.
+these automorphisms properly to the <C>anu-pq</C> program.
 
 <Example><![CDATA[
 gap> Q := Pq( FreeGroup(2) : Prime := 3, ClassBound := 1 );
@@ -790,8 +790,8 @@
 Note that by also including <C>PqStart</C> as a second argument to <C>PqExample</C>
 one can see how it is possible, with the aid of <C>PqSetPQuotientToGroup</C>
 (see&nbsp;<Ref Func="PqSetPQuotientToGroup" Style="Text"/>), to do the equivalent computations with the
-interactive versions of <C>Pq</C> and <C>PqDescendants</C> and a single <C>pq</C>
-process (recall <C>pq</C> is the name of the external C program).
+interactive versions of <C>Pq</C> and <C>PqDescendants</C> and a single <C>anu-pq</C>
+process (recall <C>anu-pq</C> is the name of the external C program).
 </Description>
 </ManSection>
 
--- a/doc/options.xml
+++ b/doc/options.xml
@@ -96,7 +96,7 @@
 <Item>
 Specifies that the <M>p</M>-quotient to be computed has lower exponent-<M>p</M>
 class at most <A>n</A>. If this option is omitted a default of 63 (which is
-the maximum possible for the <C>pq</C> program) is taken, except for
+the maximum possible for the <C>anu-pq</C> program) is taken, except for
 <C>PqDescendants</C> (see&nbsp;<Ref Func="PqDescendants" Style="Text"/>) and in a special case of <C>PqPCover</C>
 (see&nbsp;<Ref Func="PqPCover" Style="Text"/>). Let <A>F</A> be the argument (or start group of the process
 in the interactive case) for the function; then for <C>PqDescendants</C> the
@@ -127,12 +127,12 @@
 <Mark><C>Relators := <A>rels</A></C>
 <Label Name="option Relators"/><Index>option Relators</Index></Mark>
 <Item>
-Specifies that the relators sent to the <C>pq</C> program should be <A>rels</A>
+Specifies that the relators sent to the <C>anu-pq</C> program should be <A>rels</A>
 instead of the relators of the argument group <A>F</A> (or start group in the
 interactive case) of the calling function; <A>rels</A> should be a list of
 <E>strings</E> in the string representations of the generators of <A>F</A>, and <A>F</A>
 must be an <E>fp group</E> (even if the calling function accepts a pc group).
-This option provides a way of giving relators to the <C>pq</C> program,
+This option provides a way of giving relators to the <C>anu-pq</C> program,
 without having them pre-expanded by &GAP;, which can sometimes effect a
 performance loss of the order of 100 (see Section&nbsp;<Ref Sect="The Relators Option" Style="Text"/>).
 <P/>
@@ -140,9 +140,9 @@
 <E>Notes</E>
 <Enum>
     <Item>
-    The <C>pq</C> program does not use <C>/</C> to indicate multiplication by an
+    The <C>anu-pq</C> program does not use <C>/</C> to indicate multiplication by an
     inverse and uses square brackets to represent (left normed) commutators.
-    Also, even though the <C>pq</C> program accepts relations, all elements of
+    Also, even though the <C>anu-pq</C> program accepts relations, all elements of
     <A>rels</A> <E>must</E> be in relator form, i.e.&nbsp;a relation of form <C><A>w1</A> = <A>w2</A></C>
     must be written as <C><A>w1</A>*(<A>w2</A>)^-1</C> and then put in a pair of
     double-quotes to make it a string. See the example below.
@@ -166,10 +166,10 @@
 <Mark><C>GroupName := <A>name</A></C>
 <Label Name="option GroupName"/><Index>option GroupName</Index></Mark>
 <Item>
-Specifies that the <C>pq</C> program should refer to the group by the name
+Specifies that the <C>anu-pq</C> program should refer to the group by the name
 <A>name</A> (a string). If <C>GroupName</C> is not set and the group has been
 assigned a name via <C>SetName</C> (see&nbsp;<Ref BookName="ref" Label="SetName" Style="Text"/>) it is set as the name
-the <C>pq</C> program should use. Otherwise, the <Q>generic</Q> name <C>"[grp]"</C>
+the <C>anu-pq</C> program should use. Otherwise, the <Q>generic</Q> name <C>"[grp]"</C>
 is set as a default.
 </Item>
 
@@ -188,7 +188,7 @@
 level 1, the number of instances is <C>Info</C>-ed at <C>InfoANUPQ</C> level 2, and
 the instances that are evaluated are <C>Info</C>-ed at <C>InfoANUPQ</C> level 3. As
 usual timing information is <C>Info</C>-ed at <C>InfoANUPQ</C> level 2; and details
-of the processing of each instance from the <C>pq</C> program (which is often
+of the processing of each instance from the <C>anu-pq</C> program (which is often
 quite <E>voluminous</E>) is <C>Info</C>-ed at <C>InfoANUPQ</C> level 3. Try the examples
 <C>"B2-4-Id"</C> and <C>"11gp-3-Engel-Id"</C> which demonstrate the usage of the
 <C>Identities</C> option; these are run using <C>PqExample</C> (see&nbsp;<Ref Func="PqExample" Style="Text"/>).
@@ -224,11 +224,11 @@
 <Label Name="option OutputLevel"/><Index>option OutputLevel</Index></Mark>
 <Item>
 Specifies the level of <Q>verbosity</Q> of the information output by the ANU
-<C>pq</C> program when computing a pc presentation; <A>n</A> must be an integer in
+<C>anu-pq</C> program when computing a pc presentation; <A>n</A> must be an integer in
 the range 0 to 3. <C>OutputLevel := 0</C> displays at most one line of output
 and is the default; <C>OutputLevel := 1</C> displays (usually) slightly more
 output and <C>OutputLevel</C>s of 2 and 3 are two levels of verbose output. To
-see these messages from the <C>pq</C> program, the <C>InfoANUPQ</C> level must be
+see these messages from the <C>anu-pq</C> program, the <C>InfoANUPQ</C> level must be
 set to at least 1 (see&nbsp;<Ref Func="InfoANUPQ" Style="Text"/>). See
 Section&nbsp;<Ref Sect="Hints and Warnings regarding the use of Options" Style="Text"/>
 for an example of how <C>OutputLevel</C> can be used as a troubleshooting tool.
@@ -238,7 +238,7 @@
 <Label Name="option RedoPcp"/><Index>option RedoPcp</Index></Mark>
 <Item>
 Specifies that the current pc presentation (for an interactive process)
-stored by the <C>pq</C> program be scrapped and clears the current values
+stored by the <C>anu-pq</C> program be scrapped and clears the current values
 stored for the options <C>Prime</C>, <C>ClassBound</C>, <C>Exponent</C> and <C>Metabelian</C>
 and also clears the <C>pQuotient</C>, <C>pQepi</C> and <C>pCover</C> fields of the data
 record of the process.
@@ -247,21 +247,21 @@
 <Mark><C>SetupFile := <A>filename</A></C>
 <Label Name="option SetupFile"/><Index>option SetupFile</Index></Mark>
 <Item>
-Non-interactively, this option directs that <C>pq</C> should not be called and
+Non-interactively, this option directs that <C>anu-pq</C> should not be called and
 that an input file with name <A>filename</A> (a string), containing the
-commands necessary for the ANU <C>pq</C> standalone, be constructed. The
+commands necessary for the ANU <C>anu-pq</C> standalone, be constructed. The
 commands written to <A>filename</A> are also <C>Info</C>-ed behind a <Q><C>ToPQ> </C></Q>
 prompt at <C>InfoANUPQ</C> level 4 (see&nbsp;<Ref Func="InfoANUPQ" Style="Text"/>). Except in the case
 following, the calling function returns <K>true</K>. If the calling function
 is the non-interactive version of one of <C>Pq</C>, <C>PqPCover</C> or
 <C>PqEpimorphism</C> and the group provided as argument is trivial given with
 an empty set of generators, then no setup file is written and <K>fail</K> is
-returned (the <C>pq</C> program cannot do anything useful with such a group).
+returned (the <C>anu-pq</C> program cannot do anything useful with such a group).
 Interactively, <C>SetupFile</C> is ignored.
 <P/>
 
 <E>Note:</E>
-Since commands emitted to the <C>pq</C> program may depend on knowing what the
+Since commands emitted to the <C>anu-pq</C> program may depend on knowing what the
 <Q>current state</Q> is, to form a setup file some <Q>close enough guesses</Q>
 may sometimes be necessary; when this occurs a warning is <C>Info</C>-ed at
 <C>InfoANUPQ</C> or <C>InfoWarning</C> level 1. To determine whether the <Q>close
@@ -269,15 +269,15 @@
 command without the <C>SetupFile</C> option, after either setting the
 <C>InfoANUPQ</C> level to at least 4 (the setup file script can then be
 compared with the <Q><C>ToPQ> </C></Q> commands that are <C>Info</C>-ed) or setting a
-<C>pq</C> command log file by using <C>ToPQLog</C> (see&nbsp;<Ref Func="ToPQLog" Style="Text"/>).
+<C>anu-pq</C> command log file by using <C>ToPQLog</C> (see&nbsp;<Ref Func="ToPQLog" Style="Text"/>).
 </Item>
 
 <Mark><C>PqWorkspace := <A>workspace</A></C>
 <Label Name="option PqWorkspace"/><Index>option PqWorkspace</Index></Mark>
 <Item>
-Non-interactively, this option sets the memory used by the <C>pq</C> program.
+Non-interactively, this option sets the memory used by the <C>anu-pq</C> program.
 It sets the maximum number of integer-sized elements to allocate in its
-main storage array. By default, the <C>pq</C> program sets this figure to
+main storage array. By default, the <C>anu-pq</C> program sets this figure to
 10000000. Interactively, <C>PqWorkspace</C> is ignored; the memory used in
 this case may be set by giving <C>PqStart</C> a second argument
 (see&nbsp;<Ref Func="PqStart" Style="Text"/>).
@@ -295,8 +295,8 @@
 interactive process). Passing the option <C>PcgsAutomorphisms</C> without a
 value (or equivalently setting it to <K>true</K>), specifies that a polycyclic
 generating sequence for the automorphism group (which must be <E>soluble</E>)
-of <A>G</A>, be computed and passed to the <C>pq</C> program. This increases the
-efficiency of the computation; it also prevents the <C>pq</C> from calling
+of <A>G</A>, be computed and passed to the <C>anu-pq</C> program. This increases the
+efficiency of the computation; it also prevents the <C>anu-pq</C> from calling
 &GAP; for orbit-stabilizer calculations. By default, <C>PcgsAutomorphisms</C>
 is set to the value returned by <C>IsSolvable( AutomorphismGroup( <A>G</A> ) )</C>,
 and uses the package &AutPGrp; to compute <C>AutomorphismGroup( <A>G</A> )</C> if
@@ -347,7 +347,7 @@
 <Mark><C>SpaceEfficient</C>
 <Label Name="option SpaceEfficient"/><Index>option SpaceEfficient</Index></Mark>
 <Item>
-Specifies that the <C>pq</C> program performs certain calculations of <M>p</M>-group
+Specifies that the <C>anu-pq</C> program performs certain calculations of <M>p</M>-group
 generation more slowly but with greater space efficiency. This flag is
 frequently necessary for groups of large Frattini quotient rank. The
 space saving occurs because only one permutation is stored at any one
@@ -420,7 +420,7 @@
 <Mark><C>BasicAlgorithm</C>
 <Label Name="option BasicAlgorithm"/><Index>option BasicAlgorithm</Index></Mark>
 <Item>
-Specifies that an algorithm that the <C>pq</C> program calls its <Q>default</Q>
+Specifies that an algorithm that the <C>anu-pq</C> program calls its <Q>default</Q>
 algorithm be used for <M>p</M>-group generation. By default this algorithm is
 <E>not</E> used. If this option is supplied the settings of options
 <C>RankInitialSegmentSubgroups</C>, <C>AllDescendants</C>, <C>Exponent</C> and
@@ -495,7 +495,7 @@
 the directory in which &GAP; was started. If this option is omitted it
 is written to the file with the name generated by the command <C>Filename(
 ANUPQData.tmpdir, "SPres" );</C>, i.e.&nbsp;the file with name <C>"SPres"</C> in the
-temporary directory in which the <C>pq</C> program executes.
+temporary directory in which the <C>anu-pq</C> program executes.
 </Item>
 
 <Mark><C>QueueFactor := <A>n</A></C>
@@ -505,7 +505,7 @@
 This option may be used with <C>PqNextClass</C> (see&nbsp;<Ref Func="PqNextClass" Style="Text"/>).
 <P/>
 
-The queue factor is used when the <C>pq</C> program uses automorphisms to close
+The queue factor is used when the <C>anu-pq</C> program uses automorphisms to close
 a set of elements of the <M>p</M>-multiplicator under their action.
 <P/>
 
@@ -554,7 +554,7 @@
 <Label Name="option Filename"/><Index>option Filename</Index></Mark>
 <Item>
 Specifies that an output or input file to be written to or read from by
-the <C>pq</C> program should have the name <A>string</A>.
+the <C>anu-pq</C> program should have the name <A>string</A>.
 </Item>
 </List>
 
