\documentstyle[12pt]{article}
%
%page layout - A4 paper is 210mm by 297mm.
%
\hoffset -25truemm                 
\oddsidemargin=30truemm             % 
\evensidemargin=25truemm            % inner margin of 30mm, outer 25mm
\textwidth=155truemm                %
\voffset -25truemm                  
\topmargin=25truemm                 % top margin of 25mm
\headheight=0truemm                 % no head
\headsep=0truemm                    % no head
\textheight=240truemm               % bottom margin of 25mm, page nos. inside
%
\def\pq{the $p$-quotient implementation}
\begin{document}
\title{A guide to the ANU {\it p}-Quotient Program}
\author{}
\date{}
\maketitle

\section{Program content}
The ANU {\it p}-Quotient Program (PQ) provides access to implementations 
of an algorithm to construct a power-commutator presentation (pcp) for 
a {\it p}-group and of an algorithm to generate descriptions of 
{\it p}-groups.  It also allows access to an implementation
of an algorithm which can be used to construct a ``canonical" 
pcp for a $p$-group and via this construction it allows a user 
to determine whether two $p$-groups are isomorphic. The latter
can be used to generate a description of its automorphism group.

It is written in traditional C and contains about 19000 lines of code.
It was developed in a SUN OS environment and has been ported successfully
to each of VMS, AIX and Ultrix environments.  The interface and 
input/output facilities of the program are rudimentary.  Interfaces 
have been developed which allow parts of this program to be called
from within the computational group theory systems, 
Magma and {\sf GAP}.  
This program is supplied as a package within {\sf GAP}.
The link from {\sf GAP} to pq is described in the manual
for {\sf GAP} 3.2 (and later releases); all of the necessary 
code with documentation 
can be found in the gap directory of this distribution.
The program is also distributed as part of Quotpic.

The FORTRAN version of this program was known as the 
Nilpotent Quotient Program.
\section{Basic organisation}
Access to the implementation of each algorithm is provided by two menus. 
The first of these, the ``Basic menu", is designed for the new or 
occasional user; the second, the ``Advanced menu", is designed for 
the knowledgeable user with specialised needs.
Levels of control by the user are low in the first menu -- with little
attendant risk of obtaining inaccurate information. The second menu 
allows the user to make almost all decisions and provides little protection.
These menus are discussed in some more detail later. 

The following conventions apply for all menus.
\begin{itemize}
\item At a number of points in running the program, you will
be asked questions.  A non-zero integer response signifies a positive 
response to the question; a response of ``0" is a negative response.
In this guide, a ``Yes" means a non-zero integer response;
a ``No" is a zero response.

\item 
Under all menus, the option  ``-1" lists the current menu; 
``0" exits from this menu.

\item If the program cannot open a file for any reason, it simply 
reports this and if it not running interactively exits.

\item Input from the first occurrence of a ``\#" symbol to the 
      end of that line is interpreted as a comment and is ignored. 
\end{itemize}

Language used in the menus for the construction of the pcp 
follows that used in Havas and Newman (1980);
that in the {\it p}-group generation menus follows O'Brien (1990);
that in the standard presentation menu follows O'Brien (1994a).

\section{Runtime parameters}
The program may be invoked with the following runtime parameters: 

\begin{itemize}

\item $-b$  \\
      A ``basic" format can be used to input a group presentation.

\item $-c$  \\
      If groups are generated using $p$-group generation, then 
      their presentations are written to a file
      in a CAYLEY compatible format.
      The name of the file may be selected using the $-w$ option;
      the default is CAYLEY\_library.

\item $-g$  \\
      If groups are generated using $p$-group generation, then 
      their presentations are written to a file
      in a {\sf GAP} compatible format.
      The name of the file may be selected using the $-w$ option;
      the default is GAP\_library.

\item $-i$ \\
      This provides access to the Standard Presentation Menu,
      which can be used to construct the standard presentation
      of a given $p$-group.

\item $-k$ \\
      The presentation may be defined and supplied using certain
      key words. Examples of this format can be found in those 
      files in the examples directory whose names commence with 
      ``keywords\_".

\item $-m$  \\
      If groups are generated using $p$-group generation, then 
      their presentations are written to a file
      in a {\sc Magma} compatible format.
      The name of the file may be selected using the $-w$ option;
      the default is Magma\_library.

\item $-s$ $integer$ \\
      All computations of power-commutator presentations occur
      in an integer array, $y$ -- the space of this array,  by 
      default 1000000, is set to $integer$. See the discussion
      on strategies to minimise time and space later in this document.

\item $-w$ {\em file} \\
      Group descriptions are written in CAYLEY or {\sf GAP} format
      to {\em file}. One of $-c$ or $-g$ or $-m$ must be used in
      conjunction with this parameter.

\end{itemize}

\section{The {\it p}-Quotient implementation}

The performance of the program is significantly enhanced if 
it can store the defining relations in their unexpanded form.
It is currently only possible to store a supplied relation in its
unexpanded form if the relation is either a power OR a commutator, 
and the components of the power or commutator are only
defining generators or their inverses. Hence, it is frequently 
appropriate for the user to introduce redundant generators into 
the supplied presentation. 

There are two formats available for supplying
generators and relations.  Examples of both formats 
can be found in the examples directory.

\subsection{The default format}
Under the default format, a user is prompted for a list of 
generators, which must be supplied as a set.
The user is then prompted for a defining set of relations,
again supplied as a set.

Any combination of relations and relators may be supplied. 
Note, however, you may NOT use relations of the form $u = v = w$.
Relations are separated by commas, $\wedge$ is used for powers and 
conjugation, [ and ] are used to indicate the beginning and end 
of a commutator, and ``1" is the identity of the group.  
The following are examples of valid input for relations: \\
\mbox{
\tt
\{x $\wedge$ 5 = [x, y, y], z $\wedge$ x = 1, z * y * x * z $\wedge$ -1 = 1\}
}
\\
\mbox{
\tt
\{a3 * [a2, a1], a4 $\wedge$ a1 * a3 $\wedge$ a2 * [a2, a1 $\wedge$ -1, a4, a1 $\wedge$ 7] = 1 \}
}

\subsection{The basic format}
In the pcp, the defining generators and the pcp generators are 
labeled as positive integers; in each case they commence at 1.
Inverses of generators are labelled by the corresponding negative number.

The format for word input is the following:
\begin{displaymath}
Exp\; Gen_1\; Gen_2 \ldots ;
\end{displaymath}
where ``Exp" is the exponent;
if $Gen_i$ is a positive integer, it represents the corresponding
generator of the group; if it is a negative integer, it represents
the inverse of that generator.  Word input is terminated by a ``;". 
Entries in the word can be separated by any positive 
number of spaces.

Defining relations may only be supplied as relations -- not as relators.
Each side of the relation is supplied as a word using the above
format. Where the input is a power of a left-normed commutator, the 
following simpler format may be used
\begin{displaymath}
Exp\; [ Gen_1\; Gen_2 \ldots ];
\end{displaymath}
where [ and ] are used to indicate the beginning and end of the commutator.
As before, entries in the commutator can be separated by an optional number 
of spaces.  The identity word is indicated by supplying a word with 
exponent 0 -- ``0;" is sufficient.

Examples of acceptable input are the following:
\begin{itemize}
\item The input $5\; 2\; 1\; -\!\!3\; 4;$
represents the word $(2 \times 1 \times 3^{-1} \times 4)^5$.
\item The input $3\; [2\; 1\; 1\; 3];$ represents
the commutator  $[2,\; 1,\; 1,\; 3]^3$.
\end{itemize}
Under the basic format, the program only accepts input of 
either type in a word; you may not combine them. This may affect 
how you supply the defining relations for the presentation.

\subsection{Advanced Menu input}
Words are supplied as input to options on the advanced menu 
on a number of occasions. Usually, these are words in the 
pcp generators of the group.

Under the default format, the $n$ pcp generators of the group
are, for convenience, automatically labelled as $x1, x2, \ldots, xn$.  
All words in the pcp generators are then supplied as words 
in $x1, \ldots, xn$, using the format prescribed above 
for the defining relators. Word input is terminated by a ``;". 

A few options allow input involving the defining generators.
The $m$ defining generators of the group are also automatically 
labelled as $x1, x2, \ldots, xm$.  All words in the defining 
generators are then supplied as words in $x1, \ldots, xm$, 
using the format prescribed above for the defining relators. 
As before, word input is terminated by a ``;". 

If you use the basic input format, then all words are
supplied as specified in the basic format discussion.

\subsection{Input and output facilities}
Currently, facilities exist to save the computed presentation to file
and to later restore and restart the computation. The files are saved and
restored using the ``fread" and  ``fwrite" facilities, respectively. 
For both save and restore, the user supplies a name for the file, 
which can be any valid (UNIX or VMS) name. In the case of writing to file, 
the program does not query the user before overwriting 
an existing file -- it is the user's responsibility to prevent 
such situations from occurring.

\subsection{Basic menu}
The first menu obtained on running the program is listed below.
\begin{verbatim}
p-Quotient Menu
-------------------------
1. Compute pc presentation
2. Save presentation to file
3. Restore presentation from file
4. Display presentation of group
5. Set print level
6. Calculate next class
7. Compute p-covering group
8. Interactive manipulation of presentation
9. Begin p-group generation
10. Exit from program

\end{verbatim}
We now discuss each of these options.
\begin{itemize}
\item Compute pc presentation -- 
When you select this option, you will be asked the following series
of questions.
\begin{itemize}
\item Input group identifier: you may supply any sequence of characters, 
excluding spaces, as a valid identifier for the group.
\item Input prime: supply the prime $p$ used in computing the {\it p}-quotient.
\item Input maximum class: supply the maximum exponent-{\it p} class of 
the quotient to be constructed.
\item Input print level: see discussion below.

If the default format is used then
\item Input generators: supply generating set. 
\item Input relations: supply defining set of relations.

If the basic format is used then 
\item Input number of generators: supply number of defining generators.
\item Input number of relations: supply number of defining relations.

In both cases you will be asked 
\item Input exponent law (0 if none): if the group is to satisfy a 
particular exponent law, supply that value.

In the basic case, you will now be requested to input each 
relation for the group (if any).
\end{itemize}

\item Save presentation to file -- prompts for file name, saves  
group presentation to file.

\item Restore presentation from file -- prompts for file name,
restores group presentation from that file if it exists.

\item Display presentation of group -- displays group presentation;
detail depends on print level; if level is one, then display order
of group, otherwise display full pcp.

\item Set print level -- ranges from 0, providing no output, to 3. 
Default of 1, providing minimal output. 

\item Calculate next class -- calculates pcp for quotient
having one class greater than the class of the existing group.

\item Interactive manipulation of presentation -- 
permits access to ``Advanced menu" for user manipulation of
presentation.

\item Begin {\it p}-group generation -- permits access to 
{\it p}-group generation implementation.
\end{itemize}

\subsection{Advanced menu}

\begin{verbatim}
Advanced p-Quotient Menu
----------------------------------
1. Do individual collection
2. Solve the equation ax = b for x
3. Calculate commutator
4. Display group presentation
5. Set print level
6. Set up tables for next class
7. Insert tails for some or all classes
8. Check consistency for some or all classes
9. Collect defining relations
10. Carry out exponent checks
11. Eliminate redundant generators
12. Revert to presentation for previous class
13. Set maximal occurrences for pcp generators
14. Set metabelian flag
15. Carry out an individual consistency calculation
16. Carry out compaction
17. Carry out echelonisation
18. Supply and/or extend automorphisms
19. Close relations under automorphism actions
20. Print structure of one/all pcp generators
21. Evaluate Engel (p - 1)-identity
22. Process contents of relation file
23. Collect word in defining generators
24. Compute commutator of defining generators
25. Write presentation to file in CAYLEY/GAP/Magma format
26. Write compact description of group to file
27. Evaluate certain formulae
28. Evaluate action specified on defining generators
29. Exit from advanced p-quotient menu
\end{verbatim}

\section{The {\it p}-group generation implementation}
\subsection{Required input}
The required input is the {\it p}-covering group of the starting group,
together with a description of its automorphism group.
Before you commence to construct descendants,  
you should construct or restore its {\it p}-covering group.
It is the user's responsibility to do this -- no check is performed.

\subsection{The automorphism group description}
You must also supply a description of its automorphism group.
This description is the action of each automorphism on each of the 
pcp generators of the Frattini quotient of the group.
The action is described by a vector of exponents -- the length
of the vector is the number of pcp generators of the group,
its entries are the powers of each of these generators 
which occur in the image.

Where the automorphism group is soluble, a PAG-generating system should 
be supplied which works up a composition series for the group via 
cyclic factors of prime order. In such cases, the calculations may be
carried out completely within PQ.  If the soluble 
group machinery is selected by the user, but a PAG-generating system is 
not supplied, then the program will give wrong information.

If the automorphism group is insoluble or a PAG-generating sequence 
is not supplied, a call is made by the program to one of 
CAYLEY, {\sc Magma} or {\sf GAP}, which computes stabilisers of particular 
orbit representatives.
If the automorphism group of any of the intermediate (reduced) 
{\it p}-covering groups is found to be soluble, a PAG-generating sequence 
is computed by CAYLEY/{\sc Magma}/{\sf GAP} and handed back to PQ.  The soluble machinery 
is now automatically invoked for the rest of the computation.

\subsection{Saving group descriptions}
The constructed groups of a particular class, $c$, are saved to a file,
whose name is obtained by concatenating the following strings:
``starting group identifier" and ``class\_c".  As before, the 
program does not query the user before overwriting an existing file.

\subsection{Basic menu}
\begin{verbatim}
Menu for p-group generation
-----------------------------
1. Read automorphism information for starting group
2. Extend and display automorphisms 
3. Specify input file and group number
4. List group presentation
5. Construct descendants
6. Interactive construction
7. Exit to main menu
\end{verbatim}

\begin{itemize}
\item Read automorphism information for starting group --
prompts for the number of automorphisms; for each automorphism
in turn, it prompts for its action on each of the pcp
generators of the Frattini quotient of the group. 

\item Extend and display automorphisms -- compute the extensions
of these automorphisms to act on the pcp generators of the 
{\it p}-covering group and display the results. 

\item Specify input file and group number -- prompts for the
input file name and the group number.

\item List group presentation -- display at output level 3 the 
presentation for the group.

\item Construct descendants -- see next section.

\item Interactive construction -- permits access to ``Advanced menu" 
for user controlled construction and manipulation.

\end{itemize}
\subsection{Construct descendants option}

If you select this option you have to answer a series of questions.
\begin{itemize}
\item Class bound -- a positive integer greater than the class 
	   of the starting group, and which is an upper bound
	   on the class of the descendants constructed. 

\item Construct all descendants? -- 

\begin{itemize}
\item ``Yes":  You will be asked  ``Set an order bound for descendants?". 
If you answer ``Yes", you will be prompted for this order bound, which  
      will apply in addition to the class bound selected.

\item ``No": you will be asked whether you wish to have a constant step size; \\
      \hspace*{1cm}``Yes": you will be prompted for this constant step size; \\
      \hspace*{1cm} ``No": you will asked to input a series of positive
      step sizes.
\end{itemize}

\item PAG-generating sequence for automorphism group? -- 
This determines the algorithm used in constructing the orbits
and stabilisers of representative allowable subgroups.

\item Default algorithm?  

\begin{itemize}
\item ``Yes":  construct immediate descendants using the smallest possible 
 characteristic initial segment subgroups in the {\it p}-multiplicator.
This minimises the degree of the permutation group constructed. 

 \item ``No": You will be prompted ``Rank of the initial segment 
 subgroup?" If you want to proceed as in the default, respond ``0"; 
 otherwise any positive value is accepted. If the value is 
 larger than the rank of the {\it p}-multiplicator, the program
 takes this upper bound as the selected value. The initial segment 
 subgroup determined by this response is characteristically  
 closed by the program.

If a PAG-generating sequence is supplied, 
you will also be prompted ``Space efficient computation?"
By default, all of the permutations constructed are stored.
If you answer ``Yes", at any one time only one permutation is 
stored, consequently reducing the amount of space significantly.
However, the time taken in computing the automorphism group
of each descendant is also significantly increased.

You will then be prompted ``Completely process terminal descendants?". 
By default, automorphism groups are computed for and descriptions of 
capable groups only are saved to file.  
If you wish to compute automorphism groups and save descriptions of 
all descendants to file, then answer ``Yes". In this case, 
for both terminal and capable groups, the automorphism group is 
saved to file;  if capable, the pcp of the {\it p}-covering group 
is saved; if terminal, the pcp for the group.

You will then be prompted ``Input exponent law (0 if none)". 
If you wish to construct only those immediate descendants
which satisfy a particular exponent law, supply that exponent; if 
you do not wish to enforce an exponent law, supply 0.

Finally, you will be prompted ``Enforce metabelian law?".
If you answer ``Yes", you seek to ensure that all of the immediate
descendants constructed have the following property -- if any one of them 
is used as a starting group to a later iteration, only the metabelian
immediate descendants (if any) of this group are constructed.
For this requirement to be enforceable, the starting group for 
this iteration must also have that property. To ensure that the
starting group has that property, construct its $p$-covering group 
after having first set the metabelian flag under 
the ``Advanced $p$-Quotient Menu".
\end{itemize}

\item ``Do you want default output?"  
\begin{itemize}
\item ``Yes": minimal output is displayed for each group: its identifier, 
the ranks of its {\it p}-multiplicator and nucleus, the number of its 
immediate descendants of each order, and, if there are any, the 
number of its capable immediate descendants.

\item ``No": For many applications, this is sufficient. If not, then 
you may select default output for any or all of the following categories:
permutation group, orbits, group descriptions, automorphism group
descriptions, algorithm trace. The last is designed to permit
one to trace the intermediate stages of the algorithm.
If you desire additional information for any or all of these categories, 
you will be asked to answer ``Yes" or ``No" to a series of questions.
\end{itemize}
\end{itemize}

At the commencement of the application, each starting group
is checked to determine whether it meets the selected step size
order, and class criteria. If it does not, a message is displayed 
stating that this starting group is invalid. 

%\newpage
\subsection{Advanced menu}
\begin{verbatim}
Advanced menu for p-group generation
--------------------------------------
1. Read automorphism information for starting group
2. Extend and display automorphisms
3. Specify input file and group number
4. List group presentation
5. Carry out intermediate stage calculation
6. Compute definition sets & find degree
7. Construct permutations of subgroups under automorphisms
8. Compute and list orbit information
9. Process all orbit representatives
10. Process individual orbit representative
11. Compute label for standard matrix of subgroup
12. Compute standard matrix for subgroup from label
13. Find image of allowable subgroup under automorphism
14. Find rank of closure of initial segment subgroup
15. List representative and orbit for supplied label
16. Write compact descriptions of generated groups to file
17. Find automorphism classes of elements of vector space
18. Exit to main p-group generation menu
\end{verbatim}

\subsection{Strategies to minimise time and space} 
Where a PAG-generating sequence is supplied, the minimum space 
requirement is achieved by supplying ``0" as the rank of the 
initial segment subgroup and ``Yes" as the answer to the question 
of space efficiency. 
This space efficiency is achieved at the cost of some additional
time in computing the stabilisers of orbit representatives.
However, if you simply wish to compute orbits, it is the 
best overall strategy, both from space and time considerations.
The ``efficient space" option is currently available only 
where a PAG-generating sequence is supplied. 

In general, the most efficient time performance is obtained by 
taking the default algorithm. This also gives significant space 
saving over most other strategies. 

As mentioned earlier, the workspace size used in computing pcps -- 
that is, the size of the array $y$ -- may be passed as a command 
line argument to the program at invocation. Much of the storage used in the 
implementation of {\it p}-group generation is separate from that 
allocated for $y$. Hence, if the program is to be used to 
generate group descriptions, it is probably sensible 
to invoke the program with a workspace size of no more than 
$100\;000$ rather than its default value, PQSPACE 
(which is defined in the header file, constants.h).
See also the discussion on this point in the README file.
\section{The Standard Presentation and Automorphism Group implementation}
To access the menu controlling this facility, run the program 
with $-i$ as a run-time parameter. This menu allows a user 
to input a finite presentation for a group and to construct 
a ``standard" presentation for a specified $p$-quotient of the group. 
It also allows the user to construct a description of the automorphism
group of the $p$-group.

The appropriate way to view the standard presentation algorithm is the
following.
The pcp constructed by supplying a finite presentation to
the $p$-quotient algorithm depends on the supplied presentation.
The standard presentation of a $p$-group obtained using
the standard presentation algorithm is independent of the
supplied presentation. Hence it allows us to determine whether 
two $p$-groups are isomorphic.

In its most general form, the ``standard" presentation 
of a $p$-group is obtained by constructing a description of this
group using the $p$-group generation algorithm. 

The standard presentation of a class 1 $p$-quotient
is identical to that obtained from the $p$-quotient.
A user can choose to take the presentation returned
from the $p$-quotient implementation to class $k$ 
as an acceptable ``standard" presentation up to that 
class and then proceed to standardise the presentation 
from class $k + 1$ to some desired later class.
This is particularly relevant if the user is seeking
to verify that two groups are isomorphic.
It may turn out that the two pcps 
constructed by \pq\ are identical up to class $k$.
Since the standardisation procedure is significantly more
expensive than a call to \pq, it makes sense in such 
situations to begin to standardise only from class $k + 1$ onwards.
However, the user must supply as input a description
of the automorphism group of the class $k$ $p$-quotient
-- which may be more difficult to obtain for larger $k$.

In checking for isomorphism, it also makes sense
to standardise each of the presentations,
class by class. The standard presentations
at the end of each class should be compared --
if they are distinct, then the groups are non-isomorphic.
In order to facilitate this, the program writes a 
file containing necessary details of the standard presentation and the 
automorphism group of the group up to the end of the specified class 
-- this file can be used as input to the program later to
continue the standardisation procedure. 
A generating set for a supplement to the inner automorphisms of the
group is stored there; each generator is described by  an $n \times n$
 matrix whose exponents represent the image of each of the $n$
pcp generators of the standard presentation.

\begin{verbatim}
Standard Presentation Menu
-----------------------------
1. Supply start information
2. Compute standard presentation to supplied class
3. Save presentation to file
4. Display presentation
5. Set print level for construction
6. Compare two presentations stored in files
7. Call p-Quotient menu
8. Exit from program
\end{verbatim}

\begin{itemize}
\item Supply start information -- you must supply a finite presentation
for the $p$-group; the queries are identical to that uses in
option 1 of the $p$-Quotient menu. All of the valid formats for
supplying a presentation can be accessed, 
using the ``$-b$" and ``$-k$" options. 
If the class supplied is $c$, then standardisation 
(selected under option 2) begins at class $c + 1$ only. 
In general the supplied value for the class will be one -- 
however, see the preceding discussion. 
A pcp for the class $c$ $p$-quotient of the group
is now computed using the \pq. 

\item Compute standard presentation to supplied class -- 
If you did not select option 1 to supply a finite presentation, 
you will be asked the name of the input file which contains 
presentation and automorphism information for the $p$-group. 
We assume that such a file was generated from a previous 
run of the Standard Presentation algorithm. 

You will then be prompted for the name of a file to which iteration
information will be saved. This file can be used as input
later to continue the construction of the standard pcp.

You will also be asked to specify the end class for the
standardisation procedure.  (The start class is one greater 
than the class of the $p$-quotient selected using option 1 
or that stored on the input file.)

If you selected option 1 to supply a finite presentation, 
you will now be prompted for automorphism information --
in exactly the same manner as under option 1 of
the $p$-group generation menu.  Finally, you will be 
asked whether the supplied description
is a PAG-generating sequence or not. 

\item Display the standard presentation -- 
print out the standard presentation to the current class.

\item Compare two power-commutator presentations -- 
supply the names of two data files containing these
presentations; a check will be run to determine if the
presentations are identical. 
This comparison facility may be applied to any two
pcps -- not just standard ones.

\item  Set print level for construction -- ranges from 0 to 2.
At print level 0, only timing information is printed.
At print level 1, the standard presentation at the end
of each class is also printed.
At print level 2, full detail of the construction is
reported. The default print level is 1.

\item Call $p$-Quotient menu -- provides access to the 
basic $p$-Quotient menu.
\end{itemize}

Various files, all having prefixes ``ISOM\_", are first created and 
then deleted by PQ while executing the standard presentation algorithm. 
\section{Warning}
This program is still under development.  Pay attention to the results, 
and where possible confirm their correctness with other established sources.

%\newpage

\begin{description}
\item\begin{center}{\bf References}\end{center}

\item George Havas and M.F.\ Newman (1980), ``Application of computers to
questions like those of Burnside", {\it Burnside Groups} (Bielefeld, 1977),
{\it Lecture Notes in Math.\ }{\bf 806}, pp.\ 211-230.
Springer-Verlag, Berlin, Heidelberg, New York.
 
\item E.A.\ O'Brien (1990), ``The {\it p}-group generation
algorithm", {\it J.\ Symbolic Comput.} {\bf 9}, 677-698.

\item E.A.\ O'Brien (1994a), ``Isomorphism testing
for \mbox{{\it p}-groups}", {\it J. Symbolic Comput.} {\bf 17}.

\item E.A.\ O'Brien (1994b), ``Computing automorphism groups for
{\it p}-groups", to appear in Proceedings of CANT '92 (Sydney).

\end{description}

%\vspace*{0.5cm}
\noindent 
Eamonn A.\ O'Brien \\
School of Mathematical Sciences \\
Australian National University \\
Canberra, ACT 0200 

\vspace*{0.25cm}
\noindent 
E-mail address: obrien@maths.anu.edu.au

\vspace*{0.35cm}
\noindent 
Last revised March 1994
\end{document}