<html><head><title>[ANUPQ] 4 Non-interactive ANUPQ functions</title></head>
<body text="#000000" bgcolor="#ffffff">
[<a href = "chapters.htm">Up</a>] [<a href ="CHAP003.htm">Previous</a>] [<a href ="CHAP005.htm">Next</a>] [<a href = "theindex.htm">Index</a>]
<h1>4 Non-interactive ANUPQ functions</h1><p>
<P>
<H3>Sections</H3>
<oL>
<li> <A HREF="CHAP004.htm#SECT001">Computing p-Quotients</a>
<li> <A HREF="CHAP004.htm#SECT002">Computing Standard Presentations</a>
<li> <A HREF="CHAP004.htm#SECT003">Testing p-Groups for Isomorphism</a>
<li> <A HREF="CHAP004.htm#SECT004">Computing Descendants of a p-Group</a>
</ol><p>
<p>
Here we describe all the non-interactive functions of the <font face="Gill Sans,Helvetica,Arial">ANUPQ</font>
package; i.e. ``one-shot'' functions that invoke the <code>pq</code> program in such
a way that once <font face="Gill Sans,Helvetica,Arial">GAP</font> has got what it needs, the <code>pq</code> 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 <a href="CHAP001.htm">Introduction</a>) provided by the ANU <code>pq</code> C program, and are
mainly grouped according to the algorithm of the <code>pq</code> program they relate
to.
<p>
In Section <a href="CHAP004.htm#SECT001">Computing p-Quotients</a>, we describe the functions that give
access to the <i>p</i>-quotient algorithm.
<p>
Section <a href="CHAP004.htm#SECT002">Computing Standard Presentations</a> describe functions that give
access to the standard presentation algorithm.
<p>
Section <a href="CHAP004.htm#SECT003">Testing p-Groups for Isomorphism</a> describe functions that
implement an isomorphism test for <i>p</i>-groups using the standard
presentation algorithm.
<p>
In Section <a href="CHAP004.htm#SECT004">Computing Descendants of a p-Group</a>, we describe functions
that give access to the <i>p</i>-group generation algorithm.
<p>
To use any of the functions one must have at some stage previously typed:
<p>
<pre>
gap> LoadPackage("anupq");
</pre>
<p>
(the response of which we have omitted; see <a href="CHAP003.htm#SECT001">Loading the ANUPQ Package</a>).
<p>
It is strongly recommended that the user try the examples provided. To
save typing there is a <code>PqExample</code> equivalent for each manual example. We
also suggest that to start with you may find the examples more
instructive if you set the <code>InfoANUPQ</code> level to 2 (see <a href="CHAP007.htm#SSEC003.1">InfoANUPQ</a>).
<p>
<p>
<h2><a name="SECT001">4.1 Computing p-Quotients</a></h2>
<p><p>
<a name = "SSEC001.1"></a>
<li><code>Pq( </code><var>F</var><code> : </code><var>options</var><code> ) F</code>
<p>
returns for the fp or pc group <var>F</var>, the <i>p</i>-quotient of <var>F</var> specified by
<var>options</var>, as a pc group. Following the colon, <var>options</var> is a selection
of the options from the following list, separated by commas like record
components (see Section <a href="../../../doc/htm/ref/CHAP004.htm#SSEC010.2">function call!with options</a> in the <font face="Gill Sans,Helvetica,Arial">GAP</font>
Reference Manual). As a minimum the user <strong>must</strong> supply a value for the
<code>Prime</code> option. Below we list the options recognised by <code>Pq</code> (see
Chapter <a href="CHAP006.htm">ANUPQ options</a> for detailed descriptions).
<p>
<ul>
<p>
<a name = "I0"></a>
<li><code>Prime := </code><var>p</var><code></code>
<p>
<a name = "I1"></a>
<li><code>ClassBound := </code><var>n</var><code></code>
<p>
<a name = "I2"></a>
<li><code>Exponent := </code><var>n</var><code></code>
<p>
<a name = "I3"></a>
<li><code>Relators := </code><var>rels</var><code></code>
<p>
<a name = "I4"></a>
<li><code>Metabelian</code>
<p>
<a name = "I5"></a>
<li><code>Identities := </code><var>funcs</var><code></code>
<p>
<a name = "I6"></a>
<li><code>GroupName := </code><var>name</var><code></code>
<p>
<a name = "I7"></a>
<li><code>OutputLevel := </code><var>n</var><code></code>
<p>
<a name = "I8"></a>
<li><code>SetupFile := </code><var>filename</var><code></code>
<p>
<a name = "I9"></a>
<li><code>PqWorkspace := </code><var>workspace</var><code></code>
<p>
</ul>
<p>
<strong>Notes:</strong> <code>Pq</code> may also be called with no arguments or one integer
argument, in which case it is being used interactively
(see <a href="CHAP005.htm#SSEC003.1">Pq!interactive</a>); the same options may be used, except that
<code>SetupFile</code> and <code>PqWorkspace</code> are ignored by the interactive <code>Pq</code>
function.
<p>
See Section <a href="CHAP003.htm#SECT005">Attributes and a Property for fp and pc p-groups</a> for the
attributes and property <code>NuclearRank</code>, <code>MultiplicatorRank</code> and
<code>IsCapable</code> which may be applied to the group returned by <code>Pq</code>.
<p>
See also <code>PqEpimorphism</code> (<a href="CHAP004.htm#SSEC001.2">PqEpimorphism</a>).
<p>
We now give a few examples of the use of <code>Pq</code>. Except for the addition of
a few comments and the non-suppression of output (by not using duplicated
semicolons) the next 3 examples may be run by typing: <code>PqExample( "Pq"
);</code> (see <a href="CHAP003.htm#SSEC004.4">PqExample</a>).
<p>
<pre>
gap> LoadPackage("anupq");; # does nothing if ANUPQ is already loaded
gap> # First we get a p-quotient of a free group of rank 2
gap> F := FreeGroup("a", "b");; a := F.1;; b := F.2;;
gap> Pq( F : Prime := 2, ClassBound := 3 );
<pc group of size 1024 with 10 generators>
gap> # Now let us get a p-quotient of an fp group
gap> G := F / [a^4, b^4];
<fp group on the generators [ a, b ]>
gap> Pq( G : Prime := 2, ClassBound := 3 );
<pc group of size 256 with 8 generators>
gap> # Now let's get a different p-quotient of the same group
gap> Pq( G : Prime := 2, ClassBound := 3, Exponent := 4 );
<pc group of size 128 with 7 generators>
gap> # Now we'll get a p-quotient of another fp group
gap> # which we will redo using the `Relators' option
gap> R := [ a^25, Comm(Comm(b, a), a), b^5 ];
[ a^25, a^-1*b^-1*a*b*a^-1*b^-1*a^-1*b*a^2, b^5 ]
gap> H := F / R;
<fp group on the generators [ a, b ]>
gap> Pq( H : Prime := 5, ClassBound := 5, Metabelian );
<pc group of size 78125 with 7 generators>
</pre>
<p>
<a name = "I10"></a>
Now we redo the last example to show how one may use the <code>Relators</code>
option. Observe that <code>Comm(Comm(b, a), a)</code> is a left normed commutator
which must be written in square bracket notation for the <code>pq</code> program and
embedded in a pair of double quotes. The function <code>PqGAPRelators</code>
(see <a href="CHAP007.htm#SSEC004.2">PqGAPRelators</a>) can be used to translate a list of strings prepared
for the <code>Relators</code> option into <font face="Gill Sans,Helvetica,Arial">GAP</font> format. Below we use it. Observe
that the value of <code>R</code> is the same as before.
<p>
<pre>
gap> F := FreeGroup("a", "b");;
gap> # `F' was defined for `Relators'. We use the same strings that GAP uses
gap> # for printing the free group generators. It is *not* necessary to
gap> # predefine: a := F.1; etc. (as it was above).
gap> rels := [ "a^25", "[b, a, a]", "b^5" ];
[ "a^25", "[b, a, a]", "b^5" ]
gap> R := PqGAPRelators(F, rels);
[ a^25, a^-1*b^-1*a*b*a^-1*b^-1*a^-1*b*a^2, b^5 ]
gap> H := F / R;
<fp group on the generators [ a, b ]>
gap> Pq( H : Prime := 5, ClassBound := 5, Metabelian,
> Relators := rels );
<pc group of size 78125 with 7 generators>
</pre>
<p>
In fact, above we could have just passed <code>F</code> (rather than <code>H</code>), i.e. we
could have done:
<p>
<pre>
gap> F := FreeGroup("a", "b");;
gap> rels := [ "a^25", "[b, a, a]", "b^5" ];
[ "a^25", "[b, a, a]", "b^5" ]
gap> Pq( F : Prime := 5, ClassBound := 5, Metabelian,
> Relators := rels );
<pc group of size 78125 with 7 generators>
</pre>
<p>
The non-interactive <code>Pq</code> function also allows the options to be passed in
two other ways; these alternatives have been included for those familiar
with the <font face="Gill Sans,Helvetica,Arial">GAP</font> 3 version of the <font face="Gill Sans,Helvetica,Arial">ANUPQ</font> package; the preferred method
of passing options is the one already described. Firstly, they may be
passed in a record as a second argument; note that any boolean options
must be set explicitly e.g.
<p>
<pre>
gap> Pq( H, rec( Prime := 5, ClassBound := 5, Metabelian := true ) );
<pc group of size 78125 with 7 generators>
</pre>
<p>
It is also possible to pass them as extra arguments, where each option
name appears as a string followed immediately by its value (if not a
boolean option) e.g.
<p>
<pre>
gap> Pq( H, "Prime", 5, "ClassBound", 5, "Metabelian" );
<pc group of size 78125 with 7 generators>
</pre>
<p>
The preceding two examples can be run from <font face="Gill Sans,Helvetica,Arial">GAP</font> via <code>PqExample( "Pq-ni"
);</code> (see <a href="CHAP003.htm#SSEC004.4">PqExample</a>).
<p>
This method of passing options permits abbreviation; the only restriction
is that the abbreviation must be unique. So <code>"Pr"</code> may be used for
<code>"Prime"</code>, <code>"Class"</code> or even just <code>"C"</code> for <code>"ClassBound"</code>, etc.
<p>
<a name = "I11"></a>
The following example illustrates the use of the option <code>Identities</code>. We
compute the largest finite Burnside group of exponent 5 that also
satisfies the 3-Engel identity. Each identity is defined by a function
whose arguments correspond to the variables of the identity. The return
value of each of those functions is the identity evaluated on the
arguments of the function.
<p>
<pre>
gap> F := FreeGroup(2);
<free group on the generators [ f1, f2 ]>
gap> Burnside5 := x->x^5;
function( x ) ... end
gap> Engel3 := function( x,y ) return PqLeftNormComm( [x,y,y,y] ); end;
function( x, y ) ... end
gap> Pq( F : Prime := 5, Identities := [ Burnside5, Engel3 ] );
#I Class 1 with 2 generators.
#I Class 2 with 3 generators.
#I Class 3 with 5 generators.
#I Class 3 with 5 generators.
<pc group of size 3125 with 5 generators>
</pre>
<p>
The above example can be run from <font face="Gill Sans,Helvetica,Arial">GAP</font> via <code>PqExample( "B5-5-Engel3-Id"
);</code> (see <a href="CHAP003.htm#SSEC004.4">PqExample</a>).
<p>
<a name = "SSEC001.2"></a>
<li><code>PqEpimorphism( </code><var>F</var><code> : </code><var>options</var><code> ) F</code>
<p>
returns for the fp or pc group <var>F</var> an epimorphism from <var>F</var> onto the
<i>p</i>-quotient of <var>F</var> specified by <var>options</var>; the possible options
<var>options</var> and <strong>required</strong> option (<code>"Prime"</code>) are as for <code>Pq</code> (see <a href="CHAP004.htm#SSEC001.1">Pq</a>).
<code>PqEpimorphism</code> only differs from <code>Pq</code> in what it outputs; everything
about what must/may be passed as input to <code>PqEpimorphism</code> is the same as
for <code>Pq</code>. The same alternative methods of passing options to the
non-interactive <code>Pq</code> function are available to the non-interactive
version of <code>PqEpimorphism</code>.
<p>
<strong>Notes:</strong> <code>PqEpimorphism</code> may also be called with no arguments or one
integer argument, in which case it is being used interactively
(see <a href="CHAP005.htm#SSEC003.2">PqEpimorphism!interactive</a>), and the options <code>SetupFile</code> and
<code>PqWorkspace</code> are ignored by the interactive <code>PqEpimorphism</code> function.
<p>
See Section <a href="CHAP003.htm#SECT005">Attributes and a Property for fp and pc p-groups</a> for the
attributes and property <code>NuclearRank</code>, <code>MultiplicatorRank</code> and
<code>IsCapable</code> which may be applied to the image group of the epimorphism
returned by <code>PqEpimorphism</code>.
<p>
<pre>
gap> F := FreeGroup (2, "F");
<free group on the generators [ F1, F2 ]>
gap> phi := PqEpimorphism( F : Prime := 5, ClassBound := 2 );
[ F1, F2 ] -> [ f1, f2 ]
gap> Image( phi );
<pc group of size 3125 with 5 generators>
</pre>
<p>
Typing: <code>PqExample( "PqEpimorphism" );</code> runs the above example in <font face="Gill Sans,Helvetica,Arial">GAP</font>
(see <a href="CHAP003.htm#SSEC004.4">PqExample</a>).
<p>
<a name = "SSEC001.3"></a>
<li><code>PqPCover( </code><var>F</var><code> : </code><var>options</var><code> ) F</code>
<p>
returns for the fp or pc group <var>F</var>, the <i>p</i>-covering group of the
<i>p</i>-quotient of <var>F</var> specified by <var>options</var>, as a pc group, i.e. the
<i>p</i>-covering group of the <i>p</i>-quotient <code>Pq( </code><var>F</var><code> : </code><var>options</var><code> )</code>. Thus the
options that <code>PqPCover</code> accepts are exactly those expected for <code>Pq</code> (and
hence as a minimum the user <strong>must</strong> supply a value for the <code>Prime</code> option;
see <a href="CHAP004.htm#SSEC001.1">Pq</a> for more details), except in the following special case.
<p>
If <var>F</var> is already a <i>p</i>-group, in the sense that <code>HasIsPGroup(</code><var>F</var><code>) and
IsPGroup(</code><var>F</var><code>)</code> is <code>true</code>, then
<p>
<p>
<dl compact>
<p>
<dt><code>Prime</code><dd>
defaults to <code>PrimePGroup(</code><var>F</var><code>)</code>, if not supplied and <code>HasPrimePGroup(</code><var>F</var><code>)
= true</code>; and
<p>
<dt><code>ClassBound</code><dd>
defaults to <code>PClassPGroup(</code><var>F</var><code>)</code> if <code>HasPClassPGroup(</code><var>F</var><code>) = true</code> if not
supplied, or to the usual default of 63, otherwise.
<p>
</dl>
<p>
The same alternative methods of passing options to the non-interactive
<code>Pq</code> function are available to the non-interactive version of <code>PqPCover</code>.
<p>
We now give a few examples of the use of <code>PqPCover</code>. These examples are
just a subset of the ones we gave for <code>Pq</code> (see <a href="CHAP004.htm#SSEC001.1">Pq</a>), except that in
each instance the command <code>Pq</code> has been replaced with <code>PqPCover</code>.
Essentially the same examples may be run by typing: <code>PqExample(
"PqPCover" );</code> (see <a href="CHAP003.htm#SSEC004.4">PqExample</a>).
<p>
<pre>
gap> F := FreeGroup("a", "b");; a := F.1;; b := F.2;;
gap> PqPCover( F : Prime := 2, ClassBound := 3 );
<pc group of size 262144 with 18 generators>
gap>
gap> # Now let's get a p-cover of a p-quotient of an fp group
gap> G := F / [a^4, b^4];
<fp group on the generators [ a, b ]>
gap> PqPCover( G : Prime := 2, ClassBound := 3 );
<pc group of size 16384 with 14 generators>
gap>
gap> # Now let's get a p-cover of a different p-quotient of the same group
gap> PqPCover( G : Prime := 2, ClassBound := 3, Exponent := 4 );
<pc group of size 8192 with 13 generators>
gap>
gap> # Now we'll get a p-cover of a p-quotient of another fp group
gap> # which we will redo using the `Relators' option
gap> R := [ a^25, Comm(Comm(b, a), a), b^5 ];
[ a^25, a^-1*b^-1*a*b*a^-1*b^-1*a^-1*b*a^2, b^5 ]
gap> H := F / R;
<fp group on the generators [ a, b ]>
gap> PqPCover( H : Prime := 5, ClassBound := 5, Metabelian );
<pc group of size 48828125 with 11 generators>
gap>
gap> # Now we redo the previous example using the `Relators' option
gap> F := FreeGroup("a", "b");;
gap> rels := [ "a^25", "[b, a, a]", "b^5" ];
[ "a^25", "[b, a, a]", "b^5" ]
gap> PqPCover( F : Prime := 5, ClassBound := 5, Metabelian,
> Relators := rels );
<pc group of size 48828125 with 11 generators>
</pre>
<p>
<p>
<h2><a name="SECT002">4.2 Computing Standard Presentations</a></h2>
<p><p>
<a name = "I12"></a>
<a name = "SSEC002.1"></a>
<li><code>PqStandardPresentation( </code><var>F</var><code> : </code><var>options</var><code> ) F</code>
<a name = "SSEC002.1"></a>
<li><code>StandardPresentation( </code><var>F</var><code> : </code><var>options</var><code> ) M</code>
<p>
return the <var>p</var>-quotient specified by <var>options</var> of the fp or pc <i>p</i>-group
<var>F</var>, as an <strong>fp group</strong> which has a standard presentation. Here <var>options</var>
is a selection of the options from the following list (see Chapter <a href="CHAP006.htm">ANUPQ options</a> for detailed descriptions). Section <a href="CHAP003.htm#SECT006">Hints and Warnings regarding the use of Options</a> gives some important hints and warnings
regarding option usage, and Section <a href="../../../doc/htm/ref/CHAP004.htm#SSEC010.2">function call!with options</a> in
the <font face="Gill Sans,Helvetica,Arial">GAP</font> Reference Manual describes their ``record''-like syntax.
<p>
<ul>
<p>
<a name = "I13"></a>
<li><code>Prime := </code><var>p</var><code></code>
<p>
<a name = "I14"></a>
<li><code>pQuotient := </code><var>Q</var><code></code>
<p>
<a name = "I15"></a>
<li><code>ClassBound := </code><var>n</var><code></code>
<p>
<a name = "I16"></a>
<li><code>Exponent := </code><var>n</var><code></code>
<p>
<a name = "I17"></a>
<li><code>Metabelian</code>
<p>
<a name = "I18"></a>
<li><code>GroupName := </code><var>name</var><code></code>
<p>
<a name = "I19"></a>
<li><code>OutputLevel := </code><var>n</var><code></code>
<p>
<a name = "I20"></a>
<li><code>StandardPresentationFile := </code><var>filename</var><code></code>
<p>
<a name = "I21"></a>
<li><code>SetupFile := </code><var>filename</var><code></code>
<p>
<a name = "I22"></a>
<li><code>PqWorkspace := </code><var>workspace</var><code></code>
<p>
</ul>
<p>
Unless <var>F</var> is a pc <var>p</var>-group, the user <strong>must</strong> supply either the option
<code>Prime</code> or the option <code>pQuotient</code> (if both <code>Prime</code> and <code>pQuotient</code> are
supplied, the prime <var>p</var> is determined by applying <code>PrimePGroup</code>
(see <a href="../../../doc/htm/ref/CHAP037.htm#SSEC015.15">PrimePGroup</a> in the Reference Manual) to the value of
<code>pQuotient</code>).
<p>
The options for <code>PqStandardPresentation</code> may also be passed in the two
alternative ways described for <code>Pq</code> (see <a href="CHAP004.htm#SSEC001.1">Pq</a>). <code>StandardPresentation</code>
does not provide these alternative ways of passing options.
<p>
<strong>Notes:</strong>
In contrast to the function <code>Pq</code> (see <a href="CHAP004.htm#SSEC001.1">Pq</a>) which returns a pc group,
<code>PqStandardPresentation</code> or <code>StandardPresentation</code> returns an fp group.
This is because the output is mainly used for isomorphism testing for
which an fp group is enough. However, the presentation is a polycyclic
presentation and if you need to do any further computation with this
group (e.g. to find the order) you can use the function <code>PcGroupFpGroup</code>
(see <a href="../../../doc/htm/ref/CHAP044.htm#SSEC004.1">PcGroupFpGroup</a> in the <font face="Gill Sans,Helvetica,Arial">GAP</font> Reference Manual) to form a pc
group.
<p>
If the user does not supply a <var>p</var>-quotient <var>Q</var> via the <code>pQuotient</code> option
and the prime <var>p</var> is either supplied or <var>F</var> is a pc <var>p</var>-group, then a
<var>p</var>-quotient <var>Q</var> is computed. If the user does supply a <var>p</var>-quotient <var>Q</var>
via the <code>pQuotient</code> option, the package <font face="Gill Sans,Helvetica,Arial">AutPGrp</font> is called to compute
the automorphism group of <var>Q</var>; an error will occur that asks the user to
install the package <font face="Gill Sans,Helvetica,Arial">AutPGrp</font> if the automorphism group cannot be
computed.
<p>
The attributes and property <code>NuclearRank</code>, <code>MultiplicatorRank</code> and
<code>IsCapable</code> are set for the group returned by <code>PqStandardPresentation</code> or
<code>StandardPresentation</code> (see Section <a href="CHAP003.htm#SECT005">Attributes and a Property for fp and pc p-groups</a>).
<p>
We illustrate the method with the following examples.
<p>
<pre>
gap> F := FreeGroup( "a", "b" );; a := F.1;; b := F.2;;
gap> G := F / [a^25, Comm(Comm(b, a), a), b^5];
<fp group on the generators [ a, b ]>
gap> S := StandardPresentation( G : Prime := 5, ClassBound := 10 );
<fp group on the generators [ f1, f2, f3, f4, f5, f6, f7, f8, f9, f10, f11,
f12, f13, f14, f15, f16, f17, f18, f19, f20, f21, f22, f23, f24, f25, f26 ]>
gap> IsPcGroup( S );
false
gap> # if we need to compute with S we should convert it to a pc group
gap> Spc := PcGroupFpGroup( S );
<pc group of size 1490116119384765625 with 26 generators>
gap>
gap> H := F / [ a^625, Comm(Comm(Comm(Comm(b, a), a), a), a)/Comm(b, a)^5,
> Comm(Comm(b, a), b), b^625 ];;
gap> StandardPresentation( H : Prime := 5, ClassBound := 15, Metabelian );
<fp group on the generators [ f1, f2, f3, f4, f5, f6, f7, f8, f9, f10, f11,
f12, f13, f14, f15, f16, f17, f18, f19, f20 ]>
gap>
gap> F4 := FreeGroup( "a", "b", "c", "d" );;
gap> a := F4.1;; b := F4.2;; c := F4.3;; d := F4.4;;
gap> G4 := F4 / [ b^4, b^2 / Comm(Comm (b, a), a), d^16,
> a^16 / (c * d), b^8 / (d * c^4) ];
<fp group on the generators [ a, b, c, d ]>
gap> K := Pq( G4 : Prime := 2, ClassBound := 1 );
<pc group of size 4 with 2 generators>
gap> StandardPresentation( G4 : pQuotient := K, ClassBound := 14 );
<fp group with 53 generators>
</pre>
<p>
Typing: <code>PqExample( "StandardPresentation" );</code> runs the above example in
<font face="Gill Sans,Helvetica,Arial">GAP</font> (see <a href="CHAP003.htm#SSEC004.4">PqExample</a>).
<p>
<a name = "SSEC002.2"></a>
<li><code>EpimorphismPqStandardPresentation( </code><var>F</var><code> : </code><var>options</var><code> ) F</code>
<a name = "SSEC002.2"></a>
<li><code>EpimorphismStandardPresentation( </code><var>F</var><code> : </code><var>options</var><code> ) M</code>
<p>
Each of the above functions accepts the same arguments and options as the
function <code>StandardPresentation</code> (see <a href="CHAP004.htm#SSEC002.1">StandardPresentation</a>) and returns
an epimorphism from the fp or pc group <var>F</var> onto the finitely presented
group given by a standard presentation, i.e. if <var>S</var> is the standard
presentation computed for the <i>p</i>-quotient of <var>F</var> by
<code>StandardPresentation</code> then <code>EpimorphismStandardPresentation</code> returns the
epimorphism from <var>F</var> to the group with presentation <var>S</var>.
<p>
<strong>Note:</strong>
The attributes and property <code>NuclearRank</code>, <code>MultiplicatorRank</code> and
<code>IsCapable</code> are set for the image group of the epimorphism returned by
<code>EpimorphismPqStandardPresentation</code> or <code>EpimorphismStandardPresentation</code>
(see Section <a href="CHAP003.htm#SECT005">Attributes and a Property for fp and pc p-groups</a>).
<p>
We illustrate the function with the following example.
<p>
<pre>
gap> F := FreeGroup(6, "F");
<free group on the generators [ F1, F2, F3, F4, F5, F6 ]>
gap> # For printing GAP uses the symbols F1, ... for the generators of F
gap> x := F.1;; y := F.2;; z := F.3;; w := F.4;; a := F.5;; b := F.6;;
gap> R := [x^3 / w, y^3 / w * a^2 * b^2, w^3 / b,
> Comm (y, x) / z, Comm (z, x), Comm (z, y) / a, z^3 ];;
gap> Q := F / R;
<fp group on the generators [ F1, F2, F3, F4, F5, F6 ]>
gap> # For printing GAP also uses the symbols F1, ... for the generators of Q
gap> # (the same as used for F) ... but the gen'rs of Q and F are different:
gap> GeneratorsOfGroup(F) = GeneratorsOfGroup(Q);
false
gap> G := Pq( Q : Prime := 3, ClassBound := 3 );
<pc group of size 729 with 6 generators>
gap> phi := EpimorphismStandardPresentation( Q : Prime := 3,
> ClassBound := 3 );
[ F1, F2, F3, F4, F5, F6 ] -> [ f1*f2^2*f3*f4^2*f5^2, f1*f2*f3*f5, f3^2,
f4*f6^2, f5, f6 ]
gap> NamesOfComponents(phi);
[ "Source", "Range", "MappingGeneratorsImages" ]
gap> phi!.Source; # This is the group Q (GAP uses F1, ... for gen'r symbols)
<fp group of size infinity on the generators [ F1, F2, F3, F4, F5, F6 ]>
gap> phi!.Range; # This is the group G (GAP uses f1, ... for gen'r symbols)
<fp group on the generators [ f1, f2, f3, f4, f5, f6 ]>
gap> AssignGeneratorVariables(G);
#I Assigned the global variables [ f1, f2, f3, f4, f5, f6 ]
gap> # Just to see that the images of [F1, ..., F6] do generate G
gap> Group([ f1*f2^2*f3, f1*f2*f3*f4*f5^2*f6^2, f3^2, f4, f5, f6 ]) = G;
true
gap> Size( Image(phi) );
729
</pre>
<p>
Typing: <code>PqExample( "EpimorphismStandardPresentation" );</code> runs the above
example in <font face="Gill Sans,Helvetica,Arial">GAP</font> (see <a href="CHAP003.htm#SSEC004.4">PqExample</a>). Note that <code>AssignGeneratorVariables</code>
(see <a href="../../../doc/htm/ref/CHAP035.htm#SSEC002.5">AssignGeneratorVariables</a>) has only been available since
<font face="Gill Sans,Helvetica,Arial">GAP</font> 4.3.
<p>
<p>
<h2><a name="SECT003">4.3 Testing p-Groups for Isomorphism</a></h2>
<p><p>
<a name = "SSEC003.1"></a>
<li><code>IsPqIsomorphicPGroup( </code><var>G</var><code>, </code><var>H</var><code> ) F</code>
<a name = "SSEC003.1"></a>
<li><code>IsIsomorphicPGroup( </code><var>G</var><code>, </code><var>H</var><code> ) M</code>
<p>
each return true if <var>G</var> is isomorphic to <var>H</var>, where both <var>G</var> and <var>H</var> must
be pc groups of prime power order. These functions compute and compare
in <font face="Gill Sans,Helvetica,Arial">GAP</font> the fp groups given by standard presentations for <var>G</var> and <var>H</var>
(see <a href="CHAP004.htm#SSEC002.1">StandardPresentation</a>).
<p>
<pre>
gap> G := Group( (1,2,3,4), (1,3) );
Group([ (1,2,3,4), (1,3) ])
gap> P1 := Image( IsomorphismPcGroup( G ) );
Group([ f1, f2, f3 ])
gap> P2 := SmallGroup( 8, 5 );
<pc group of size 8 with 3 generators>
gap> IsIsomorphicPGroup( P1, P2 );
false
gap> P3 := SmallGroup( 8, 4 );
<pc group of size 8 with 3 generators>
gap> IsIsomorphicPGroup( P1, P3 );
false
gap> P4 := SmallGroup( 8, 3 );
<pc group of size 8 with 3 generators>
gap> IsIsomorphicPGroup( P1, P4 );
true
</pre>
<p>
Typing: <code>PqExample( "IsIsomorphicPGroup" );</code> runs the above example in
<font face="Gill Sans,Helvetica,Arial">GAP</font> (see <a href="CHAP003.htm#SSEC004.4">PqExample</a>).
<p>
<p>
<h2><a name="SECT004">4.4 Computing Descendants of a p-Group</a></h2>
<p><p>
<a name = "SSEC004.1"></a>
<li><code>PqDescendants( </code><var>G</var><code> : </code><var>options</var><code> ) F</code>
<p>
returns, for the pc group <var>G</var> which must be of prime power order with a
confluent pc presentation (see <a href="../../../doc/htm/ref/CHAP044.htm#SSEC004.7">IsConfluent!for pc groups</a> in the
<font face="Gill Sans,Helvetica,Arial">GAP</font> Reference Manual), a list of descendants (pc groups) of <var>G</var>.
Following the colon <var>options</var> a selection of the options listed below
should be given, separated by commas like record components (see
Section <a href="../../../doc/htm/ref/CHAP004.htm#SSEC010.2">function call!with options</a> in the <font face="Gill Sans,Helvetica,Arial">GAP</font> Reference Manual).
See Chapter <a href="CHAP006.htm">ANUPQ options</a> for detailed descriptions of the options.
<p>
The automorphism group of each descendant <var>D</var> is also computed via a call
to the <code>AutomorphismGroupPGroup</code> function of the <font face="Gill Sans,Helvetica,Arial">AutPGrp</font> package.
<p>
<ul>
<p>
<a name = "I23"></a>
<li><code>ClassBound := </code><var>n</var><code></code>
<p>
<a name = "I24"></a>
<li><code>Relators := </code><var>rels</var><code></code>
<p>
<a name = "I25"></a>
<li><code>OrderBound := </code><var>n</var><code></code>
<p>
<a name = "I26"></a>
<li><code>StepSize := </code><var>n</var><code></code>, <code>StepSize := </code><var>list</var><code></code>
<p>
<a name = "I27"></a>
<li><code>RankInitialSegmentSubgroups := </code><var>n</var><code></code>
<p>
<a name = "I28"></a>
<li><code>SpaceEfficient</code>
<p>
<a name = "I29"></a>
<li><code>CapableDescendants</code>
<p>
<a name = "I30"></a>
<li><code>AllDescendants := false</code>
<p>
<a name = "I31"></a>
<li><code>Exponent := </code><var>n</var><code></code>
<p>
<a name = "I32"></a>
<li><code>Metabelian</code>
<p>
<a name = "I33"></a>
<li><code>GroupName := </code><var>name</var><code></code>
<p>
<a name = "I34"></a>
<li><code>SubList := </code><var>sub</var><code></code>
<p>
<a name = "I35"></a>
<li><code>BasicAlgorithm</code>
<p>
<a name = "I36"></a>
<li><code>CustomiseOutput := </code><var>rec</var><code></code>
<p>
<a name = "I37"></a>
<li><code>SetupFile := </code><var>filename</var><code></code>
<p>
<a name = "I38"></a>
<li><code>PqWorkspace := </code><var>workspace</var><code></code>
<p>
</ul>
<p>
<strong>Notes:</strong>
The function <code>PqDescendants</code> uses the automorphism group of <var>G</var> which it
computes via the package <font face="Gill Sans,Helvetica,Arial">AutPGrp</font>. If this package is not installed an
error may be raised. If the automorphism group of <var>G</var> is insoluble, the
<code>pq</code> program will call <font face="Gill Sans,Helvetica,Arial">GAP</font> together with the <font face="Gill Sans,Helvetica,Arial">AutPGrp</font> package for
certain orbit-stabilizer calculations. (So, in any case, one should
ensure the <font face="Gill Sans,Helvetica,Arial">AutPGrp</font> package is installed.)
<p>
The attributes and property <code>NuclearRank</code>, <code>MultiplicatorRank</code> and
<code>IsCapable</code> are set for each group of the list returned by
<code>PqDescendants</code> (see Section <a href="CHAP003.htm#SECT005">Attributes and a Property for fp and pc p-groups</a>).
<p>
The options <var>options</var> for <code>PqDescendants</code> may be passed in an alternative
manner to that already described, namely you can pass <code>PqDescendants</code> a
record as an argument, which contains as entries some (or all) of the
above mentioned. Those parameters which do not occur in the record are
set to their default values.
<p>
Note that you cannot set both <code>OrderBound</code> and <code>StepSize</code>.
<p>
In the first example we compute all descendants of the Klein four group
which have exponent-2 class at most 5 and order at most 2<sup>6</sup>.
<p>
<pre>
gap> F := FreeGroup( "a", "b" );; a := F.1;; b := F.2;;
gap> G := PcGroupFpGroup( F / [ a^2, b^2, Comm(b, a) ] );
<pc group of size 4 with 2 generators>
gap> des := PqDescendants( G : OrderBound := 6, ClassBound := 5 );;
gap> Length(des);
83
gap> List(des, Size);
[ 8, 8, 8, 16, 16, 16, 32, 16, 16, 16, 16, 16, 32, 32, 64, 64, 32, 32, 32,
32, 32, 32, 32, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 32, 32, 32, 32,
64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 32, 32, 32, 32, 32, 64, 64, 64,
64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64,
64, 64, 64, 64, 64, 64, 64 ]
gap> List(des, d -> Length( PCentralSeries( d, 2 ) ) - 1 );
[ 2, 2, 2, 2, 2, 2, 2, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 4,
4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
4, 4, 4, 5, 5, 5, 5, 5 ]
</pre>
<p>
Below, we compute all capable descendants of order 27 of the elementary
abelian group of order 9.
<p>
<pre>
gap> F := FreeGroup( 2, "g" );
<free group on the generators [ g1, g2 ]>
gap> G := PcGroupFpGroup( F / [ F.1^3, F.2^3, Comm(F.1, F.2) ] );
<pc group of size 9 with 2 generators>
gap> des := PqDescendants( G : OrderBound := 3, ClassBound := 2,
> CapableDescendants );
[ <pc group of size 27 with 3 generators>,
<pc group of size 27 with 3 generators> ]
gap> List(des, d -> Length( PCentralSeries( d, 3 ) ) - 1 );
[ 2, 2 ]
gap> # For comparison let us now compute all descendants
gap> PqDescendants( G : OrderBound := 3, ClassBound := 2);
[ <pc group of size 27 with 3 generators>,
<pc group of size 27 with 3 generators>,
<pc group of size 27 with 3 generators> ]
</pre>
<p>
In the third example, we compute all capable descendants of the
elementary abelian group of order 5<sup>2</sup> which have exponent-5 class at
most 3, exponent 5, and are metabelian.
<p>
<pre>
gap> F := FreeGroup( 2, "g" );;
gap> G := PcGroupFpGroup( F / [ F.1^5, F.2^5, Comm(F.2, F.1) ] );
<pc group of size 25 with 2 generators>
gap> des := PqDescendants( G : Metabelian, ClassBound := 3,
> Exponent := 5, CapableDescendants );
[ <pc group of size 125 with 3 generators>,
<pc group of size 625 with 4 generators>,
<pc group of size 3125 with 5 generators> ]
gap> List(des, d -> Length( PCentralSeries( d, 5 ) ) - 1 );
[ 2, 3, 3 ]
gap> List(des, d -> Length( DerivedSeries( d ) ) );
[ 3, 3, 3 ]
gap> List(des, d -> Maximum( List( Elements(d), Order ) ) );
[ 5, 5, 5 ]
</pre>
<p>
The examples <code>"PqDescendants-1"</code>, <code>"PqDescendants-2"</code> and
<code>"PqDescendants-3"</code> (in order) are essentially the same as the above
three examples (see <a href="CHAP003.htm#SSEC004.4">PqExample</a>).
<p>
<a name = "SSEC004.2"></a>
<li><code>PqSupplementInnerAutomorphisms( </code><var>D</var><code> ) F</code>
<p>
returns a generating set for a supplement to the inner automorphisms of
<var>D</var>, in the form of a record with fields <code>agAutos</code>, <code>agOrder</code> and
<code>glAutos</code>, as provided by the <code>pq</code> program. One should be very careful in
using these automorphisms for a descendant calculation.
<p>
<strong>Note:</strong>
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 <code>pq</code> program.
<p>
<pre>
gap> Q := Pq( FreeGroup(2) : Prime := 3, ClassBound := 1 );
<pc group of size 9 with 2 generators>
gap> des := PqDescendants( Q : StepSize := 1 );
[ <pc group of size 27 with 3 generators>,
<pc group of size 27 with 3 generators>,
<pc group of size 27 with 3 generators> ]
gap> S := PqSupplementInnerAutomorphisms( des[3] );
rec( agAutos := [ ], agOrder := [ 3, 2, 2, 2 ],
glAutos := [ Pcgs([ f1, f2, f3 ]) -> [ f1*f2^2, f2, f3 ],
Pcgs([ f1, f2, f3 ]) -> [ f1^2, f2, f3^2 ],
Pcgs([ f1, f2, f3 ]) -> [ f1^2, f2, f3^2 ] ] )
gap> A := AutomorphismGroupPGroup( des[3] );
rec( glAutos := [ ], glOrder := 1,
agAutos := [ Pcgs([ f1, f2, f3 ]) -> [ f1^2, f2, f3^2 ],
Pcgs([ f1, f2, f3 ]) -> [ f1*f2^2, f2, f3 ],
Pcgs([ f1, f2, f3 ]) -> [ f1*f3, f2, f3 ],
Pcgs([ f1, f2, f3 ]) -> [ f1, f2*f3, f3 ] ], agOrder := [ 2, 3, 3, 3 ],
one := IdentityMapping( <pc group of size 27 with 3 generators> ),
group := <pc group of size 27 with 3 generators>, size := 54,
glOper := [ ]
</pre>
<p>
The above example may be executed on-line via <code>PqExample(
"PqSupplementInnerAutomorphisms" );</code> (see <a href="CHAP003.htm#SSEC004.4">PqExample</a>).
<p>
Note that by also including <code>PqStart</code> as a second argument to <code>PqExample</code>
one can see how it is possible, with the aid of <code>PqSetPQuotientToGroup</code>
(see <a href="CHAP005.htm#SSEC003.7">PqSetPQuotientToGroup</a>), to do the equivalent computations with the
interactive versions of <code>Pq</code> and <code>PqDescendants</code> and a single <code>pq</code>
process (recall <code>pq</code> is the name of the external C program).
<p>
<a name = "SSEC004.3"></a>
<li><code>PqList( </code><var>filename</var><code> [: SubList := </code><var>sub</var><code> ]) F</code>
<p>
reads a file with name <var>filename</var> (a string) and returns the list <var>L</var> of
pc groups (or with option <code>SubList</code> a sublist of <var>L</var> or a single pc group
in <var>L</var>) defined in that file. If the option <code>SubList</code> is passed and has
the value <var>sub</var>, then it has the same meaning as for <code>PqDescendants</code>,
i.e. if <var>sub</var> is an integer then <code>PqList</code> returns <code></code><var>L</var><code>[</code><var>sub</var><code>]</code>;
otherwise, if <var>sub</var> is a list of integers <code>PqList</code> returns <code>Sublist(</code><var>L</var><code>,
</code><var>sub</var><code> )</code>.
<p>
Both <code>PqList</code> and <code>SavePqList</code> (see <a href="CHAP004.htm#SSEC004.4">SavePqList</a>) can be used to save and
restore a list of descendants (see <a href="CHAP004.htm#SSEC004.1">PqDescendants</a>).
<p>
<a name = "SSEC004.4"></a>
<li><code>SavePqList( </code><var>filename</var><code>, </code><var>list</var><code> ) F</code>
<p>
writes a list of descendants <var>list</var> to a file with name <var>filename</var> (a
string).
<p>
<code>SavePqList</code> and <code>PqList</code> (see <a href="CHAP004.htm#SSEC004.3">PqList</a>) can be used to save and restore,
respectively, the results of <code>PqDescendants</code> (see <a href="CHAP004.htm#SSEC004.1">PqDescendants</a>).
<p>
<p>
[<a href = "chapters.htm">Up</a>] [<a href ="CHAP003.htm">Previous</a>] [<a href ="CHAP005.htm">Next</a>] [<a href = "theindex.htm">Index</a>]
<P>
<address>ANUPQ manual<br>Januar 2006
</address></body></html>
distrib
>
Mandriva
>
2010.0
>
i586
>
media
>
contrib-release
>
by-pkgid
>
91213ddcfbe7f54821d42c2d9e091326
>
files
>
437
