% generated by GAPDoc2LaTeX from XML source (Frank Luebeck)
\documentclass[a4paper,11pt]{report}

\usepackage[top=37mm,bottom=37mm,left=27mm,right=27mm]{geometry}
\sloppy
\pagestyle{myheadings}
\usepackage{amssymb}
\usepackage[utf8]{inputenc}
\usepackage{makeidx}
\makeindex
\usepackage{color}
\definecolor{FireBrick}{rgb}{0.5812,0.0074,0.0083}
\definecolor{RoyalBlue}{rgb}{0.0236,0.0894,0.6179}
\definecolor{RoyalGreen}{rgb}{0.0236,0.6179,0.0894}
\definecolor{RoyalRed}{rgb}{0.6179,0.0236,0.0894}
\definecolor{LightBlue}{rgb}{0.8544,0.9511,1.0000}
\definecolor{Black}{rgb}{0.0,0.0,0.0}

\definecolor{linkColor}{rgb}{0.0,0.0,0.554}
\definecolor{citeColor}{rgb}{0.0,0.0,0.554}
\definecolor{fileColor}{rgb}{0.0,0.0,0.554}
\definecolor{urlColor}{rgb}{0.0,0.0,0.554}
\definecolor{promptColor}{rgb}{0.0,0.0,0.589}
\definecolor{brkpromptColor}{rgb}{0.589,0.0,0.0}
\definecolor{gapinputColor}{rgb}{0.589,0.0,0.0}
\definecolor{gapoutputColor}{rgb}{0.0,0.0,0.0}

%%  for a long time these were red and blue by default,
%%  now black, but keep variables to overwrite
\definecolor{FuncColor}{rgb}{0.0,0.0,0.0}
%% strange name because of pdflatex bug:
\definecolor{Chapter }{rgb}{0.0,0.0,0.0}
\definecolor{DarkOlive}{rgb}{0.1047,0.2412,0.0064}


\usepackage{fancyvrb}

\usepackage{mathptmx,helvet}
\usepackage[T1]{fontenc}
\usepackage{textcomp}


\usepackage[
            pdftex=true,
            bookmarks=true,        
            a4paper=true,
            pdftitle={Written with GAPDoc},
            pdfcreator={LaTeX with hyperref package / GAPDoc},
            colorlinks=true,
            backref=page,
            breaklinks=true,
            linkcolor=linkColor,
            citecolor=citeColor,
            filecolor=fileColor,
            urlcolor=urlColor,
            pdfpagemode={UseNone}, 
           ]{hyperref}

\newcommand{\maintitlesize}{\fontsize{50}{55}\selectfont}

% write page numbers to a .pnr log file for online help
\newwrite\pagenrlog
\immediate\openout\pagenrlog =\jobname.pnr
\immediate\write\pagenrlog{PAGENRS := [}
\newcommand{\logpage}[1]{\protect\write\pagenrlog{#1, \thepage,}}
%% were never documented, give conflicts with some additional packages

\newcommand{\GAP}{\textsf{GAP}}

%% nicer description environments, allows long labels
\usepackage{enumitem}
\setdescription{style=nextline}

%% depth of toc
\setcounter{tocdepth}{1}





%% command for ColorPrompt style examples
\newcommand{\gapprompt}[1]{\color{promptColor}{\bfseries #1}}
\newcommand{\gapbrkprompt}[1]{\color{brkpromptColor}{\bfseries #1}}
\newcommand{\gapinput}[1]{\color{gapinputColor}{#1}}


\begin{document}

\logpage{[ 0, 0, 0 ]}
\begin{titlepage}
\mbox{}\vfill

\begin{center}{\maintitlesize \textbf{ AutPGrp \\
\mbox{}}}\\
\vfill

\hypersetup{pdftitle={ AutPGrp }}
\markright{\scriptsize \mbox{}\hfill  AutPGrp  \hfill\mbox{}}
{\Huge \textbf{ Computing the Automorphism Group of a p\texttt{\symbol{45}}Group \\
\mbox{}}}\\
\vfill

{\Huge  1.12.0 \mbox{}}\\[1cm]
{ 17 May 2026 \mbox{}}\\[1cm]
\mbox{}\\[2cm]
{\Large \textbf{\strut  Bettina Eick     \strut\mbox{}}}\\
{\Large \textbf{\strut  Eamonn O'Brien     \strut\mbox{}}}\\
\hypersetup{pdfauthor={ Bettina Eick    ;  Eamonn O'Brien    }}
\end{center}\vfill

\mbox{}\\
{\mbox{}\\
\small \noindent \textbf{ Bettina Eick    }  Email: \href{mailto://beick@tu-bs.de} {\texttt{beick@tu\texttt{\symbol{45}}bs.de}}\\
  Homepage: \href{http://www.iaa.tu-bs.de/beick} {\texttt{http://www.iaa.tu\texttt{\symbol{45}}bs.de/beick}}\\
  Address: \begin{minipage}[t]{8cm}\noindent
 Institut Analysis und Algebra\\
 TU Braunschweig\\
 Universit{\"a}tsplatz 2\\
 D\texttt{\symbol{45}}38106 Braunschweig\\
 Germany\\
 \end{minipage}
}\\
{\mbox{}\\
\small \noindent \textbf{ Eamonn O'Brien    }  Email: \href{mailto://obrien@math.auckland.ac.nz} {\texttt{obrien@math.auckland.ac.nz}}\\
  Homepage: \href{http://www.math.auckland.ac.nz/~obrien} {\texttt{http://www.math.auckland.ac.nz/\texttt{\symbol{126}}obrien}}\\
  Address: \begin{minipage}[t]{8cm}\noindent
 Department of Mathematics\\
 University of Auckland\\
 Private Bag 92019\\
 Auckland\\
 New Zealand\\
 \end{minipage}
}\\
\end{titlepage}

\newpage\setcounter{page}{2}
{\small 
\section*{Abstract}
\logpage{[ 0, 0, 1 ]}
 The \textsf{AutPGrp} package introduces a new function to compute the automorphism group of a
finite $p$\texttt{\symbol{45}}group. The underlying algorithm is a refinement of the
methods described in O'Brien (1995). In particular, this implementation is
more efficient in both time and space requirements and hence has a wider range
of applications than the ANUPQ method. Our package is written in \textsf{GAP} code and it makes use of a number of methods from the \textsf{GAP} library such as the MeatAxe for matrix groups and permutation group functions.
We have compared our method to the others available in \textsf{GAP}. Our package usually out\texttt{\symbol{45}}performs all but the method
designed for finite abelian groups. We note that our method uses the small
groups library in certain cases and hence our algorithm is more effective if
the small groups library is installed. \mbox{}}\\[1cm]
{\small 
\section*{Copyright}
\logpage{[ 0, 0, 2 ]}
 Bettina Eick and Eamonn O'Brien.

 AutPGrp is free software; you can redistribute it and/or modify it under the
terms of the \href{ https://www.fsf.org/licenses/gpl.html} {GNU General Public License} as published by the Free Software Foundation; either version 2 of the License,
or (at your option) any later version. \mbox{}}\\[1cm]
{\small 
\section*{Acknowledgements}
\logpage{[ 0, 0, 3 ]}
 We thank Alexander Hulpke for helping us with efficiency problems. Werner
Nickel provided some functions from the \textsf{GAP} \texttt{PQuotient} which are used in this package. \mbox{}}\\[1cm]
\newpage

\def\contentsname{Contents\logpage{[ 0, 0, 4 ]}}

\tableofcontents
\newpage

 
\chapter{\textcolor{Chapter }{Introduction}}\label{Introduction}
\logpage{[ 1, 0, 0 ]}
\hyperdef{L}{X7DFB63A97E67C0A1}{}
{
  
\section{\textcolor{Chapter }{Introduction}}\logpage{[ 1, 1, 0 ]}
\hyperdef{L}{X7DFB63A97E67C0A1}{}
{
  Given an arbitrary finite group, the computation of its automorphism group is
a very difficult task. Pioneer work in this area was carried out by Felsch and
Neubueser (1970), whose algorithm used the output of their subgroup lattice
program. A technique developed by Neubueser in the early 1970s sought to
compute the automorphism group viewed as a permutation group acting on unions
of certain conjugacy classes of the group. A similar method was implemented by
Hulpke (1997) in the \textsf{GAP} 4 library. Recently, Cannon and Holt (1999) presented a new algorithm which
uses a \emph{hybrid group} approach. 

 More efficient approaches are available to determine the automorphism group
for groups satisfying certain properties. Following the work of Shoda (1928),
Hulpke in 1997 implemented a practical method for finite abelian groups in the \textsf{GAP} 4 library. Wursthorn (1993) adapted modular group algebra techniques to
compute the automorphism groups of $p$\texttt{\symbol{45}}groups; the \textsf{GAP} 3 share package \textsf{Sisyphos} includes an implementation. Smith (1994) introduced an algorithm for finite
solvable groups which is available in the \textsf{AutAg} share package of \textsf{GAP} 3. 

 Moreover, the $p$\texttt{\symbol{45}}group generation method of Newman (1977) and O'Brien
(1990) can be modified to compute the automorphism group of a finite $p$\texttt{\symbol{45}}group as outlined in O'Brien (1995). This algorithm is
implemented in the ANU \texttt{pq} C program. 

 Here we introduce a new function to compute the automorphism group of a finite $p$\texttt{\symbol{45}}group. The underlying algorithm is a refinement of the
methods described in O'Brien (1995). In particular, this implementation is
more efficient in both time and space requirements and hence has a wider range
of applications than the ANU \texttt{pq} method. Our package is written in \textsf{GAP} code and it makes use of a number of methods from the \textsf{GAP} library such as the MeatAxe for matrix groups and permutation group functions. 

 The \textsf{GAP} 4 package \textsf{ANUPQ}, which is an interface to most of the functionality of the ANU \texttt{pq} C program, uses the \textsf{AutPGrp} package to compute automorphism groups of $p$\texttt{\symbol{45}}groups. 

 We have compared our method to the others available in \textsf{GAP}. Our package usually out\texttt{\symbol{45}}performs all but the method
designed for finite abelian groups. We note that our method uses the small
groups library in certain cases and hence our algorithm is more effective if
the small groups library is installed. }

 }

 
\chapter{\textcolor{Chapter }{The automorphism group method}}\label{The automorphism group method}
\logpage{[ 2, 0, 0 ]}
\hyperdef{L}{X858BB98D85D78C8C}{}
{
  
\section{\textcolor{Chapter }{The automorphism group method}}\logpage{[ 2, 1, 0 ]}
\hyperdef{L}{X858BB98D85D78C8C}{}
{
  The \textsf{AutPGrp} package installs a method for \texttt{AutomorphismGroup} for a finite $p$\texttt{\symbol{45}}group (see also Section{\nobreakspace} (\textbf{Reference: Groups of Automorphisms}) in the \textsf{GAP} Reference Manual). 

\subsection{\textcolor{Chapter }{AutomorphismGroup}}
\logpage{[ 2, 1, 1 ]}\nobreak
\hyperdef{L}{X87677B0787B4461A}{}
{\noindent\textcolor{FuncColor}{$\triangleright$\enspace\texttt{AutomorphismGroup({\mdseries\slshape G})\index{AutomorphismGroup@\texttt{AutomorphismGroup}}
\label{AutomorphismGroup}
}\hfill{\scriptsize (operation)}}\\
\textbf{\indent Returns:\ }
The automorphism group of \mbox{\texttt{\mdseries\slshape G}}. 



 The input is a finite $p$\texttt{\symbol{45}}group \mbox{\texttt{\mdseries\slshape G}}. If the filters \texttt{IsPGroup}, \texttt{IsFinite} and \texttt{CanEasilyComputePcgs} are set and true for \mbox{\texttt{\mdseries\slshape G}}, the method selection of \textsf{GAP}{\nobreakspace}4 invokes this algorithm. 

 The output of the method is an automorphism group, whose generators are given
in \texttt{GroupHomomorphismByImages} format in terms of their action on the underlying group \mbox{\texttt{\mdseries\slshape G}}. }

 

\subsection{\textcolor{Chapter }{InfoAutGrp}}
\logpage{[ 2, 1, 2 ]}\nobreak
\hyperdef{L}{X7D16AFE27E0B7133}{}
{\noindent\textcolor{FuncColor}{$\triangleright$\enspace\texttt{InfoAutGrp\index{InfoAutGrp@\texttt{InfoAutGrp}}
\label{InfoAutGrp}
}\hfill{\scriptsize (info class)}}\\


 This is a \textsf{GAP} \texttt{InfoClass} (\textbf{Reference: InfoClass for a GAP package}). By assigning an \texttt{level} in the range 1 to 4 via 
\begin{Verbatim}[commandchars=!@|,fontsize=\small,frame=single,label=Example]
  SetInfoLevel(InfoAutGrp, level);
\end{Verbatim}
 varying levels of information on the progress of the computation, will be
obtained. 

 
\begin{Verbatim}[commandchars=!@|,fontsize=\small,frame=single,label=Example]
  !gapprompt@gap>| !gapinput@LoadPackage("autpgrp", false);|
  true
  !gapprompt@gap>| !gapinput@G := PcGroupCode(619031068735, 32);  # SmallGroup( 32, 15 );|
  <pc group of size 32 with 5 generators>
  !gapprompt@gap>| !gapinput@SetInfoLevel( InfoAutGrp, 1 );|
  !gapprompt@gap>| !gapinput@AutomorphismGroup(G);|
  #I  step 1: 2^2 -- init automorphisms
  #I  step 2: 2^2 -- aut grp has size 2
  #I  step 3: 2^1 -- aut grp has size 32
  #I  final step: convert
  <group of size 64 with 6 generators>
\end{Verbatim}
 

 The algorithm proceeds by induction down the lower $p$\texttt{\symbol{45}}central series of \texttt{G} and the information corresponds to the steps of this induction. In the
following example we observe that the method also accepts permutation groups
as input, provided they satisfy the required filters. 

 
\begin{Verbatim}[commandchars=!@|,fontsize=\small,frame=single,label=Example]
  !gapprompt@gap>| !gapinput@G := DihedralGroup( IsPermGroup, 2^5 );;|
  !gapprompt@gap>| !gapinput@IsPGroup(G);|
  true
  !gapprompt@gap>| !gapinput@CanEasilyComputePcgs(G);|
  true
  !gapprompt@gap>| !gapinput@IsFinite(G);|
  true
  !gapprompt@gap>| !gapinput@A := AutomorphismGroup(G);|
  #I  step 1: 2^2 -- init automorphisms
  #I  step 2: 2^1 -- aut grp has size 2
  #I  step 3: 2^1 -- aut grp has size 8
  #I  step 4: 2^1 -- aut grp has size 32
  #I  final step: convert
  <group of size 128 with 7 generators>
  !gapprompt@gap>| !gapinput@A.1;|
  Pcgs([ ( 2,16)( 3,15)( 4,14)( 5,13)( 6,12)( 7,11)( 8,10),
    ( 1, 2, 3, 4, 5, 6, 7, 8, 9,10,11,12,13,14,15,16),
    ( 1, 3, 5, 7, 9,11,13,15)( 2, 4, 6, 8,10,12,14,16),
    ( 1, 5, 9,13)( 2, 6,10,14)( 3, 7,11,15)( 4, 8,12,16),
    ( 1, 9)( 2,10)( 3,11)( 4,12)( 5,13)( 6,14)( 7,15)( 8,16) ]) ->
  [ ( 1, 2)( 3,16)( 4,15)( 5,14)( 6,13)( 7,12)( 8,11)( 9,10),
    ( 1, 2, 3, 4, 5, 6, 7, 8, 9,10,11,12,13,14,15,16),
    ( 1, 3, 5, 7, 9,11,13,15)( 2, 4, 6, 8,10,12,14,16),
    ( 1, 5, 9,13)( 2, 6,10,14)( 3, 7,11,15)( 4, 8,12,16),
    ( 1, 9)( 2,10)( 3,11)( 4,12)( 5,13)( 6,14)( 7,15)( 8,16) ]
  !gapprompt@gap>| !gapinput@Order(A.1);|
  16
\end{Verbatim}
 }

 }

 }

 
\chapter{\textcolor{Chapter }{The underlying function}}\label{The underlying function}
\logpage{[ 3, 0, 0 ]}
\hyperdef{L}{X79DCF7D9853381F3}{}
{
  
\section{\textcolor{Chapter }{The underlying function}}\logpage{[ 3, 1, 0 ]}
\hyperdef{L}{X79DCF7D9853381F3}{}
{
  Underlying the method installation for \texttt{AutomorphismGroup} is the function \texttt{AutomorphismGroupPGroup}. This function is intended for expert users who wish to influence the steps
of the algorithm. Note also that \texttt{AutomorphismGroup} will always choose default values. 

\subsection{\textcolor{Chapter }{AutomorphismGroupPGroup}}
\logpage{[ 3, 1, 1 ]}\nobreak
\hyperdef{L}{X83ABE66C83446A0B}{}
{\noindent\textcolor{FuncColor}{$\triangleright$\enspace\texttt{AutomorphismGroupPGroup({\mdseries\slshape G[, flag]})\index{AutomorphismGroupPGroup@\texttt{AutomorphismGroupPGroup}}
\label{AutomorphismGroupPGroup}
}\hfill{\scriptsize (function)}}\\


The input is a finite $p$\texttt{\symbol{45}}group as above and an optional \mbox{\texttt{\mdseries\slshape flag}} which can be true or false. Here the filters for \mbox{\texttt{\mdseries\slshape G}} need not be set, but they should be true for \mbox{\texttt{\mdseries\slshape G}}. The possible values for \mbox{\texttt{\mdseries\slshape flag}} are considered later in Chapter \ref{Influencing the algorithm}. If \mbox{\texttt{\mdseries\slshape flag}} is not supplied, the algorithm proceeds similarly to the method installed for \texttt{AutomorphismGroup}, but it produces slightly more detailed output. The output of the function is
a record which contains the following fields: 

 
\begin{description}
\item[{ \texttt{glAutos} }] a set of automorphisms which together with \texttt{agAutos} generate the automorphism group;
\item[{ \texttt{glOrder} }] an integer whose product with the \texttt{agOrders} gives the size of the automorphism group;
\item[{ \texttt{agAutos} }] a polycyclic generating sequence for a soluble normal subgroup of the
automorphism group;
\item[{ \texttt{agOrder} }] the relative orders corresponding to \texttt{agAutos};
\item[{ \texttt{one} }] the identity element of the automorphism group;
\item[{ \texttt{group} }] the underlying group \mbox{\texttt{\mdseries\slshape G}};
\item[{ \texttt{size} }] the size of the automorphism group.
\end{description}
 

We do not return an automorphism group in the standard form because we wish to
distinguish between \texttt{agAutos} and \texttt{glAutos}; the latter act non\texttt{\symbol{45}}trivially on the Frattini quotient of \mbox{\texttt{\mdseries\slshape G}}. This hybrid\texttt{\symbol{45}}group description of the automorphism group
permits more efficient computations with it. The following function converts
the output of \texttt{AutomorphismGroupPGroup} to the output of \texttt{AutomorphismGroup}. }

 

\subsection{\textcolor{Chapter }{ConvertHybridAutGroup}}
\logpage{[ 3, 1, 2 ]}\nobreak
\hyperdef{L}{X7DEE06CF79DC7A7C}{}
{\noindent\textcolor{FuncColor}{$\triangleright$\enspace\texttt{ConvertHybridAutGroup({\mdseries\slshape A})\index{ConvertHybridAutGroup@\texttt{ConvertHybridAutGroup}}
\label{ConvertHybridAutGroup}
}\hfill{\scriptsize (function)}}\\
\textbf{\indent Returns:\ }
A record.



Let \mbox{\texttt{\mdseries\slshape A}} be the automorphism group of a $p$\texttt{\symbol{45}}group $G$ as computed by \texttt{AutomorphismGroupPGroup}. Then \texttt{ConvertHybridAutGroup} can compute a pc group isomorphic to the solvable part of \mbox{\texttt{\mdseries\slshape A}} stored in the record component \texttt{\mbox{\texttt{\mdseries\slshape A}}.agGroup}. This solvable part forms a subgroup of the automorphism group which contains
at least the automorphisms centralizing the Frattini factor of $G$. The pc group facilitates various further computations with \mbox{\texttt{\mdseries\slshape A}}. 
\begin{Verbatim}[commandchars=!@|,fontsize=\small,frame=single,label=Example]
  !gapprompt@gap>| !gapinput@LoadPackage("autpgrp", false);|
  true
  !gapprompt@gap>| !gapinput@H := PcGroupCode(297368117289422176, 729);  # SmallGroup (729, 34);|
  <pc group of size 729 with 6 generators>
  !gapprompt@gap>| !gapinput@A := AutomorphismGroupPGroup(H);|
  #I  step 1: 3^2 -- init automorphisms
  #I  step 2: 3^1 -- aut grp has size 8
  #I  step 3: 3^2 -- aut grp has size 72
  #I  step 4: 3^1 -- aut grp has size 5832
  #I  final step: convert
  rec(
    agAutos :=
      [ Pcgs([ f1, f2, f3, f4, f5, f6 ]) -> [ f2, f1, f3^2, f5^2, f4^2, f6^2 ],
        Pcgs([ f1, f2, f3, f4, f5, f6 ]) -> [ f1, f2^2, f3^2*f5, f4^2*f6, f5,
            f6 ], Pcgs([ f1, f2, f3, f4, f5, f6 ]) ->
          [ f1^2, f2^2, f3*f4^2*f5^2*f6, f4^2*f6, f5^2*f6, f6 ],
        Pcgs([ f1, f2, f3, f4, f5, f6 ]) -> [ f1*f3, f2, f3*f5^2, f4*f6^2, f5,
            f6 ], Pcgs([ f1, f2, f3, f4, f5, f6 ]) ->
          [ f1, f2*f3, f3*f4, f4, f5*f6, f6 ],
        Pcgs([ f1, f2, f3, f4, f5, f6 ]) -> [ f1*f4, f2, f3*f6^2, f4, f5, f6 ],
        Pcgs([ f1, f2, f3, f4, f5, f6 ]) -> [ f1, f2*f4, f3, f4, f5, f6 ],
        Pcgs([ f1, f2, f3, f4, f5, f6 ]) -> [ f1*f5, f2, f3, f4, f5, f6 ],
        Pcgs([ f1, f2, f3, f4, f5, f6 ]) -> [ f1, f2*f5, f3*f6, f4, f5, f6 ],
        Pcgs([ f1, f2, f3, f4, f5, f6 ]) -> [ f1*f6, f2, f3, f4, f5, f6 ],
        Pcgs([ f1, f2, f3, f4, f5, f6 ]) -> [ f1, f2*f6, f3, f4, f5, f6 ] ],
    agOrder := [ 2, 2, 2, 3, 3, 3, 3, 3, 3, 3, 3 ], glAutos := [  ],
    glOper := [  ], glOrder := 1, group := <pc group of size 729 with
      6 generators>, one := IdentityMapping( <pc group of size 729 with
      6 generators> ), size := 52488 )
  !gapprompt@gap>| !gapinput@ConvertHybridAutGroup( A );|
  <group of size 52488 with 11 generators>
\end{Verbatim}
}

 

\subsection{\textcolor{Chapter }{PcGroupAutPGroup}}
\logpage{[ 3, 1, 3 ]}\nobreak
\hyperdef{L}{X7ED1F7C6849CA658}{}
{\noindent\textcolor{FuncColor}{$\triangleright$\enspace\texttt{PcGroupAutPGroup({\mdseries\slshape A})\index{PcGroupAutPGroup@\texttt{PcGroupAutPGroup}}
\label{PcGroupAutPGroup}
}\hfill{\scriptsize (function)}}\\


This function computes a pc presentation for the solvable part of the
automorphism group \mbox{\texttt{\mdseries\slshape A}} defined by \texttt{\mbox{\texttt{\mdseries\slshape A}}.agGroup}. \mbox{\texttt{\mdseries\slshape A}} is the output of the function \texttt{AutomorphismGroupPGroup}. 
\begin{Verbatim}[commandchars=!@|,fontsize=\small,frame=single,label=Example]
  !gapprompt@gap>| !gapinput@H := PcGroupCode(297368117289422176, 729);;  # SmallGroup (729, 34);|
  !gapprompt@gap>| !gapinput@A := AutomorphismGroupPGroup(H);;|
  #I  step 1: 3^2 -- init automorphisms
  #I  step 2: 3^1 -- aut grp has size 8
  #I  step 3: 3^2 -- aut grp has size 72
  #I  step 4: 3^1 -- aut grp has size 5832
  #I  final step: convert
  !gapprompt@gap>| !gapinput@B := PcGroupAutPGroup( A );|
  <pc group of size 52488 with 11 generators>
  !gapprompt@gap>| !gapinput@I := InnerAutGroupPGroup( B );|
  Group([ f5, f4^2*f8, f6^2*f9^2, f11^2, f10^2, <identity> of ... ])
\end{Verbatim}
}

}

 }

 
\chapter{\textcolor{Chapter }{Influencing the algorithm}}\label{Influencing the algorithm}
\logpage{[ 4, 0, 0 ]}
\hyperdef{L}{X86240F237D909E1C}{}
{
  A number of choices can be made by the user to influence the performance of \texttt{AutomorphismGroupPGroup}. Below we identify these choices and their default values used in \texttt{AutomorphismGroup} (\ref{AutomorphismGroup}). We use the optional argument \mbox{\texttt{\mdseries\slshape flag}} of \texttt{AutomorphismGroupPGroup} to invoke user\texttt{\symbol{45}}defined choices. The possible values for \mbox{\texttt{\mdseries\slshape flag}} are 

 
\begin{description}
\item[{\texttt{\mbox{\texttt{\mdseries\slshape flag}} = false} }]  the user\texttt{\symbol{45}}defined defaults are employed in the algorithm.
See below for a list of possibilities. 
\item[{\texttt{\mbox{\texttt{\mdseries\slshape flag}} = true} }]  invokes the interactive version of the algorithm as described in Section \ref{An interactive version of
                 the algorithm}. 
\end{description}
 

 In the next section we give a brief outline of the algorithm which is
necessary to understand the possible choices. Then we introduce the choices
the later sections of this chapter. 
\section{\textcolor{Chapter }{Outline of the algorithm}}\label{Outline of the algorithm}
\logpage{[ 4, 1, 0 ]}
\hyperdef{L}{X85D2ECC779E3CF7D}{}
{
  The basic algorithm proceeds by induction down the lower $p$\texttt{\symbol{45}}central series of a given $p$\texttt{\symbol{45}}group $G$; that is, it successively computes $Aut(G_i)$ for the quotients $G_i = G / P_i(G)$ of the descending sequence of subgroups defined by $P_1(G) = G$ and $P_{i+1}(G)=[P_i(G),G] P_i(G)^p$ for $i\geq 1$. Hence, in the initial step of the algorithm, $Aut(G_2) = GL(d,p)$ where $d$ is the rank of the elementary abelian group $G_2$. In the inductive step it determines $Aut(G_{i+1})$ from $Aut(G_i)$. For this purpose we introduce an action of $Aut(G_i)$ on a certain elementary abelian $p$\texttt{\symbol{45}}group $M$ (the \emph{$p$\texttt{\symbol{45}}multiplicator} of $G_i$). The main computation of the inductive step is the determination of the
stabiliser in $Aut(G_i)$ of a subgroup $U$ of $M$ (the \emph{allowable subgroup} for $G_{i+1}$). This stabiliser calculation is the bottle\texttt{\symbol{45}}neck of the
algorithm. 

 Our package incorporates a number of refinements designed to simplify this
stabiliser computation. Some of these refinements incur overheads and hence
they are not always invoked. The features outlined below allow the user to
select them. 

 Observe that the initial step of the algorithm returns $GL(d,p)$. But $Aut(G)$ may induce on $G_2$ a proper subgroup, say $K$, of $GL(d,p)$. Any intermediate subgroup of $GL(d,p)$ which contains $K$ suffices for the algorithm and we supply two methods to construct a suitable
subgroup: these use characteristic subgroups or invariants of normal subgroups
of $G$. (See Section \ref{The initialisation step}.) 

 In the inductive step an action of $Aut(G_i)$ on an elementary abelian group $M$ is used. This action is computed as a matrix action on a vector space. To
simplify the orbit\texttt{\symbol{45}}stabiliser computation of the subspace $U$ of $M$, we can construct the stabiliser of $U$ by iteration over a sequence of $Aut(G_i)$\texttt{\symbol{45}}invariant subspaces of $M$. (See Section \ref{Stabilisers in matrix groups}.) 

 Orbit\texttt{\symbol{45}}stabiliser computations in finite solvable groups
given by a polycyclic generating sequence are much more efficient than generic
computations of this type. Thus our algorithm makes use of a large solvable
normal subgroup $S$ of $Aut(G_i)$. Further, it is useful if the generating set of $Aut(G_i)$ outside $S$ is as small as possible. To achieve this we determine a permutation
representation of $Aut(G_i)/S$ and use this to reduce the number of generators if possible. (See Section \ref{Searching for a small generating set}.) }

 
\section{\textcolor{Chapter }{The initialisation step}}\label{The initialisation step}
\logpage{[ 4, 2, 0 ]}
\hyperdef{L}{X87B27C1F810822F3}{}
{
  Assume we seek to compute the automorphism group of a $p$\texttt{\symbol{45}}group $G$ having Frattini rank $d$. We first determine as small as possible a subgroup of $GL(d, p)$ whose extension can act on $G$. 

 The user can choose the initialisation routine by assigning \texttt{InitAutGroup} to any one of the following: 
\begin{description}
\item[{\texttt{InitAutomorphismGroupOver} }]  to use the minimal overgroups: We determine the minimal
over\texttt{\symbol{45}}groups of the Frattini subgroup of $G$ and compute invariants of these which must be respected by the automorphism
group of $G$. We partition the minimal overgroups and compute the stabiliser in $GL(d, p)$ of this partition. 

 The partition of the minimal overgroups is computed using the function \texttt{PGFingerprint( G, U )}. This is the time\texttt{\symbol{45}}consuming part of this initialisation
method. The user can overwrite the function \texttt{PGFingerprint}. 
\item[{\texttt{InitAutomorphismGroupChar} }]  to use the characteristic subgroups: Compute a generating set for the
stabiliser in $GL (d, p)$ of a chain of characteristic subgroups of $G$. In practice, we construct a characteristic chain by determining
2\texttt{\symbol{45}}step centralisers and omega subgroups of factors of the
lower $p$\texttt{\symbol{45}}central series. 

 However, there are often other characteristic subgroups which are not found by
these approaches. The user can overwrite the function \texttt{PGCharSubgroups( G )} to supply a set of characteristic subgroups. 
\item[{\texttt{InitAutomorphismGroupFull} }]  to use the full $GL(d,p)$. 
\end{description}
 In the method for \texttt{AutomorphismGroup} (\ref{AutomorphismGroup}) we use a default strategy: if the value $\frac{p^d-1}{p-1}$ is less than 1000, then we use the minimal overgroup approach, otherwise the
characteristic subgroups are employed. An exception is made for homogeneous
abelian groups where we initialise the algorithm with the full group $GL(d,p)$. }

 
\section{\textcolor{Chapter }{Stabilisers in matrix groups}}\label{Stabilisers in matrix groups}
\logpage{[ 4, 3, 0 ]}
\hyperdef{L}{X869B678180AD5E21}{}
{
  Consider the $i$th inductive step of the algorithm. Here $A \leq Aut(G_i)$ acts as matrix group on the elementary abelian $p$\texttt{\symbol{45}}group $M$ and we want to determine the stabiliser of a subgroup $U \leq M$. 

 We use the MeatAxe to compute a series of $A$\texttt{\symbol{45}}invariant subspaces through $M$ such that each factor in the series is irreducible as $A$\texttt{\symbol{45}}module. Then we use this series to break the computation
of $Stab_A(U)$ into several smaller orbit\texttt{\symbol{45}}stabiliser calculations. 

 Note that a theoretic argument yields an $A$\texttt{\symbol{45}}invariant subspace of $M$ a priori: the nucleus $N$. This is always used to split the computation up. However, it may happen that $N = M$ and hence results in no improvement. 

\subsection{\textcolor{Chapter }{CHOP{\textunderscore}MULT}}
\logpage{[ 4, 3, 1 ]}\nobreak
\hyperdef{L}{X86529C2080159D8A}{}
{\noindent\textcolor{FuncColor}{$\triangleright$\enspace\texttt{CHOP{\textunderscore}MULT\index{CHOP{\textunderscore}MULT@\texttt{CHOP{\textunderscore}MULT}}
\label{CHOPuScoreMULT}
}\hfill{\scriptsize (global variable)}}\\


 The invariant series through $M$ is computed and used if the global variable \texttt{CHOP{\textunderscore}MULT} is set to \texttt{true}. Otherwise, the algorithm tries to determine $Stab_A(U)$ in one step. By default, \texttt{CHOP{\textunderscore}MULT} is \texttt{true}. }

 }

 
\section{\textcolor{Chapter }{Searching for a small generating set}}\label{Searching for a small generating set}
\logpage{[ 4, 4, 0 ]}
\hyperdef{L}{X859CF9757A1F51EB}{}
{
  After each step of the computation, we attempt to find a nice generating set
for the automorphism group of the current factor. 

 If the automorphism group is soluble, we store a polycyclic generating set;
otherwise, we store such a generating set for a large soluble normal subgroup $S$ of the automorphism group $A$, and as few generators outside as possible. If $S = A$ and a polycyclic generating set for $S$ is known, many steps of the algorithm proceed more rapidly. 

\subsection{\textcolor{Chapter }{NICE{\textunderscore}STAB}}
\logpage{[ 4, 4, 1 ]}\nobreak
\hyperdef{L}{X83C095D17D35A8DE}{}
{\noindent\textcolor{FuncColor}{$\triangleright$\enspace\texttt{NICE{\textunderscore}STAB\index{NICE{\textunderscore}STAB@\texttt{NICE{\textunderscore}STAB}}
\label{NICEuScoreSTAB}
}\hfill{\scriptsize (global variable)}}\\


 It may be both time\texttt{\symbol{45}}consuming and difficult to reduce the
number of generators for $A$ outside $S$. Note that if the initialisation of the algorithm is by \texttt{InitAutomorphismGroupOver}, then we always know a permutation representation for $A/S$. Occasionally the search for a small generating set is expensive. If this is
observed, one could set the flag \texttt{NICE{\textunderscore}STAB} to \texttt{false} and the algorithm no longer invokes this search. }

 }

 
\section{\textcolor{Chapter }{An interactive version of the algorithm}}\label{An interactive version of the algorithm}
\logpage{[ 4, 5, 0 ]}
\hyperdef{L}{X81A0235D7E15DFBD}{}
{
  The choice of initialisation and the choice of chopping of the $p$\texttt{\symbol{45}}multiplicator can also be driven by an interactive version
of the algorithm. We give an example. 

 
\begin{Verbatim}[commandchars=!@|,fontsize=\small,frame=single,label=Example]
  !gapprompt@gap>| !gapinput@G := PcGroupCode(2504972218445939562621471375, 256);;  # SmallGroup( 2^8, 1000 );|
  !gapprompt@gap>| !gapinput@SetInfoLevel( InfoAutGrp, 3 );|
  
  !gapprompt@gap>| !gapinput@AutomorphismGroupPGroup( G, true );|
  #I  step 1: 2^3 -- init automorphisms
  
  choose initialisation (Over/Char/Full):     # we choose Full
  #I    init automorphism group : Full
  #I  step 2: 2^3 -- aut grp has size 168
  #I    computing cover
  #I    computing matrix action
  #I    computing stabilizer of U
  #I    dim U = 3  dim N = 6  dim M = 6
  
  chop M/N and N: (y/n):                      # we choose n
  #I    induce autos and add central autos
  #I  step 3: 2^2 -- aut grp has size 12288
  #I    computing cover
  #I    computing matrix action
  #I    computing stabilizer of U
  #I    dim U = 6  dim N = 5  dim M = 8
  
  chop M/N and N: (y/n):                      # we choose y
  #I    induce autos and add central autos
  #I  final step: convert
  rec(
    glAutos := [ Pcgs([ f1, f2, f3, f4, f5, f6, f7, f8 ]) -> [ f1, f2*f3, f3,
            f4, f5, f6*f7, f7, f8 ],
        Pcgs([ f1, f2, f3, f4, f5, f6, f7, f8 ]) ->
          [ f1*f3*f5*f6, f2*f3, f3, f4, f5*f8, f6*f7, f7, f8 ],
        Pcgs([ f1, f2, f3, f4, f5, f6, f7, f8 ]) ->
          [ f1*f3, f2*f4, f3, f4*f7, f5*f7, f6*f7*f8, f7, f8 ] ], glOrder := 4,
    agAutos :=
      [ Pcgs([ f1, f2, f3, f4, f5, f6, f7, f8 ]) -> [ f1*f4, f2, f3, f4*f8, f5,
            f6, f7, f8 ], Pcgs([ f1, f2, f3, f4, f5, f6, f7, f8 ]) ->
          [ f1, f2*f4, f3, f4*f7, f5, f6*f7*f8, f7, f8 ],
        Pcgs([ f1, f2, f3, f4, f5, f6, f7, f8 ]) ->
          [ f1*f5, f2, f3, f4, f5, f6, f7, f8 ],
        Pcgs([ f1, f2, f3, f4, f5, f6, f7, f8 ]) ->
          [ f1, f2*f5, f3, f4, f5, f6, f7, f8 ],
        Pcgs([ f1, f2, f3, f4, f5, f6, f7, f8 ]) ->
          [ f1, f2, f3*f5, f4, f5, f6, f7, f8 ],
        Pcgs([ f1, f2, f3, f4, f5, f6, f7, f8 ]) ->
          [ f1*f6, f2, f3, f4, f5*f7*f8, f6, f7, f8 ],
        Pcgs([ f1, f2, f3, f4, f5, f6, f7, f8 ]) ->
          [ f1, f2*f6, f3, f4*f7*f8, f5, f6, f7, f8 ],
        Pcgs([ f1, f2, f3, f4, f5, f6, f7, f8 ]) ->
          [ f1*f8, f2, f3, f4, f5, f6, f7, f8 ],
        Pcgs([ f1, f2, f3, f4, f5, f6, f7, f8 ]) ->
          [ f1, f2*f8, f3, f4, f5, f6, f7, f8 ],
        Pcgs([ f1, f2, f3, f4, f5, f6, f7, f8 ]) ->
          [ f1, f2, f3*f8, f4, f5, f6, f7, f8 ],
        Pcgs([ f1, f2, f3, f4, f5, f6, f7, f8 ]) ->
          [ f1*f7, f2, f3, f4, f5, f6, f7, f8 ],
        Pcgs([ f1, f2, f3, f4, f5, f6, f7, f8 ]) ->
          [ f1, f2*f7, f3, f4, f5, f6, f7, f8 ],
        Pcgs([ f1, f2, f3, f4, f5, f6, f7, f8 ]) ->
          [ f1, f2, f3*f7, f4, f5, f6, f7, f8 ] ],
    agOrder := [ 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2 ],
    one := IdentityMapping( <pc group of size 256 with 8 generators> ),
    group := <pc group of size 256 with 8 generators>, size := 32768 )
\end{Verbatim}
 

 Two points are worthy of comment. First, the interactive version of the
algorithm permits the user to make a suitable choice in each step of the
algorithm instead of making one choice at the beginning. Secondly, the output
of the \texttt{Info} function shows the ranks of the $p$\texttt{\symbol{45}}multiplicator and allowable subgroup, and thus allow the
user to observe the scale of difficulty of the computation. }

 }

 
\chapter{\textcolor{Chapter }{Additional features of the package}}\label{Additional features of the package}
\logpage{[ 5, 0, 0 ]}
\hyperdef{L}{X7C0BF58A85D48781}{}
{
  
\section{\textcolor{Chapter }{Additional features of the package}}\logpage{[ 5, 1, 0 ]}
\hyperdef{L}{X7C0BF58A85D48781}{}
{
  As an additional feature of this package we provide some functions to count
extensions of $p$\texttt{\symbol{45}}groups and Lie algebras over $GF(p)$. These functions have been used in counting the $2$\texttt{\symbol{45}}groups of size $2^{10}$. 

 

\subsection{\textcolor{Chapter }{NumberOfPClass2PGroups (for 3 arguments)}}
\logpage{[ 5, 1, 1 ]}\nobreak
\hyperdef{L}{X7E472D2579705246}{}
{\noindent\textcolor{FuncColor}{$\triangleright$\enspace\texttt{NumberOfPClass2PGroups({\mdseries\slshape n, p, k})\index{NumberOfPClass2PGroups@\texttt{NumberOfPClass2PGroups}!for 3 arguments}
\label{NumberOfPClass2PGroups:for 3 arguments}
}\hfill{\scriptsize (operation)}}\\


 This function determines the number of \mbox{\texttt{\mdseries\slshape n}}\texttt{\symbol{45}}generator \mbox{\texttt{\mdseries\slshape p}}\texttt{\symbol{45}}groups of \mbox{\texttt{\mdseries\slshape p}}\texttt{\symbol{45}}class 2 with Frattini subgroup of order \texttt{2\texttt{\symbol{94}}\mbox{\texttt{\mdseries\slshape k}}}. }

 

\subsection{\textcolor{Chapter }{NumberOfPClass2PGroups (for 2 arguments)}}
\logpage{[ 5, 1, 2 ]}\nobreak
\hyperdef{L}{X825FC0D9796B0D97}{}
{\noindent\textcolor{FuncColor}{$\triangleright$\enspace\texttt{NumberOfPClass2PGroups({\mdseries\slshape n, p})\index{NumberOfPClass2PGroups@\texttt{NumberOfPClass2PGroups}!for 2 arguments}
\label{NumberOfPClass2PGroups:for 2 arguments}
}\hfill{\scriptsize (operation)}}\\


 This function returns a list of of numbers of \mbox{\texttt{\mdseries\slshape n}}\texttt{\symbol{45}}generator \mbox{\texttt{\mdseries\slshape p}}\texttt{\symbol{45}}groups of \mbox{\texttt{\mdseries\slshape p}}\texttt{\symbol{45}}class 2 with Frattini subgroup of order \texttt{2\texttt{\symbol{94}}k} for \texttt{k} in $1, \ldots, n(n+1)/2$. }

 

\subsection{\textcolor{Chapter }{NumberOfClass2LieAlgebras (for 3 arguments)}}
\logpage{[ 5, 1, 3 ]}\nobreak
\hyperdef{L}{X8399B9137982EBAC}{}
{\noindent\textcolor{FuncColor}{$\triangleright$\enspace\texttt{NumberOfClass2LieAlgebras({\mdseries\slshape n, p, k})\index{NumberOfClass2LieAlgebras@\texttt{NumberOfClass2LieAlgebras}!for 3 arguments}
\label{NumberOfClass2LieAlgebras:for 3 arguments}
}\hfill{\scriptsize (operation)}}\\


 This function determines the number of \mbox{\texttt{\mdseries\slshape n}}\texttt{\symbol{45}}generator Lie algebras of class 2 over \mbox{\texttt{\mdseries\slshape GF(p)}} with derived Lie subalgebra of dimension \mbox{\texttt{\mdseries\slshape k}}. }

 

\subsection{\textcolor{Chapter }{NumberOfClass2LieAlgbras (for 2 arguments)}}
\logpage{[ 5, 1, 4 ]}\nobreak
\hyperdef{L}{X824DFC307CA9626E}{}
{\noindent\textcolor{FuncColor}{$\triangleright$\enspace\texttt{NumberOfClass2LieAlgbras({\mdseries\slshape n, p})\index{NumberOfClass2LieAlgbras@\texttt{NumberOfClass2LieAlgbras}!for 2 arguments}
\label{NumberOfClass2LieAlgbras:for 2 arguments}
}\hfill{\scriptsize (operation)}}\\


 This function returns a list of of numbers of \mbox{\texttt{\mdseries\slshape n}}\texttt{\symbol{45}}generator Lie algebras of class 2 over $GF(p)$ with derived Lie subalgebra of dimension $k$ for $k$ in $1, \ldots, n(n-1)/2$. }

 }

 }

   {\nobreakspace} \def\indexname{Index\logpage{[ "Ind", 0, 0 ]}
\hyperdef{L}{X83A0356F839C696F}{}
}

\cleardoublepage
\phantomsection
\addcontentsline{toc}{chapter}{Index}


\printindex

\immediate\write\pagenrlog{["Ind", 0, 0], \arabic{page},}
\newpage
\immediate\write\pagenrlog{["End"], \arabic{page}];}
\immediate\closeout\pagenrlog
\end{document}
