Quelle chap4.html Sprache: HTML

products/Sources/formale Sprachen/GAP/pkg/anupq/doc/chap4.html

<?xml version="1.0" encoding="UTF-8"?>

<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN"
 "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">

<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en">
<head>
<title>GAP (ANUPQ) - Chapter 4: Non-interactive ANUPQ functions</title>
<meta http-equiv="content-type" content="text/html; charset=UTF-8" />
<meta name="generator" content="GAPDoc2HTML" />
<link rel="stylesheet" type="text/css" href="manual.css" />
<script src="manual.js" type="text/javascript"></script>
<script type="text/javascript">overwriteStyle();</script>
</head>
<body class="chap4" onload="jscontent()">

<div class="chlinktop">Goto Chapter: <a href="chap0.html">Top</a> <a href="chap1.html">1</a> <a href="chap2.html">2</a> <a href="chap3.html">3</a> <a href="chap4.html">4</a> <a href="chap5.html">5</a> <a href="chap6.html">6</a> <a href="chap7.html">7</a> <a href="chapA.html">A</a> <a href="chapBib.html">Bib</a> <a href="chapInd.html">Ind</a> </div>

<div class="chlinkprevnexttop"> <a href="chap0.html">[Top of Book]</a> <a href="chap0.html#contents">[Contents]</a> <a href="chap3.html">[Previous Chapter]</a> <a href="chap5.html">[Next Chapter]</a> </div>

<a href="chap4_mj.html">[MathJax on]</a>
<a id="X7C51F26D839279FF" name="X7C51F26D839279FF"></a>
<div class="ChapSects"><a href="chap4.html#X7C51F26D839279FF">4 Non-interactive ANUPQ functions</a>
<div class="ContSect"> <a href="chap4.html#X80406BD47EB186E9">4.1 Computing p-Quotients</a>

<div class="ContSSBlock">
 <a href="chap4.html#X86DD32D5803CF2C8">4.1-1 Pq</a>
 <a href="chap4.html#X7ADE5DDB87B99CC0">4.1-2 PqEpimorphism</a>
 <a href="chap4.html#X81C3CE1E850DA252">4.1-3 PqPCover</a>
</div></div>
<div class="ContSect"> <a href="chap4.html#X7F05F8DC79733A8E">4.2 Computing Standard Presentations</a>

<div class="ContSSBlock">
 <a href="chap4.html#X86C9575D7CB65FBB">4.2-1 PqStandardPresentation</a>
 <a href="chap4.html#X828C06D083C0D089">4.2-2 EpimorphismPqStandardPresentation</a>
</div></div>
<div class="ContSect"> <a href="chap4.html#X8030FAE586423615">4.3 Testing p-Groups for Isomorphism</a>

<div class="ContSSBlock">
 <a href="chap4.html#X854389FC780BB178">4.3-1 IsPqIsomorphicPGroup</a>
</div></div>
<div class="ContSect"> <a href="chap4.html#X8450C72580D91245">4.4 Computing Descendants of a p-Group</a>

<div class="ContSSBlock">
 <a href="chap4.html#X80985CC479CD9FA3">4.4-1 PqDescendants</a>
 <a href="chap4.html#X8364566A80A8C24B">4.4-2 PqSupplementInnerAutomorphisms</a>
 <a href="chap4.html#X79AD54E987FCACBA">4.4-3 PqList</a>
 <a href="chap4.html#X85ADB9E6870EC3D1">4.4-4 SavePqList</a>
</div></div>
</div>

<h3>4 Non-interactive ANUPQ functions</h3>

Here we describe all the non-interactive functions of the ANUPQ package; i.e. <q>one-shot</q> functions that invoke the <code class="code">pq</code> program in such a way that once GAP has got what it needs, the <code class="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="chap1.html#X7DFB63A97E67C0A1">Introduction</a>) provided by the ANU <code class="code">pq</code> C program, and are mainly grouped according to the algorithm of the <code class="code">pq</code> program they relate to.

In Section <a href="chap4.html#X80406BD47EB186E9">Computing p-Quotients</a>, we describe the functions that give access to the p-quotient algorithm.

Section <a href="chap4.html#X7F05F8DC79733A8E">Computing Standard Presentations</a> describe functions that give access to the standard presentation algorithm.

Section <a href="chap4.html#X8030FAE586423615">Testing p-Groups for Isomorphism</a> describe functions that implement an isomorphism test for p-groups using the standard presentation algorithm.

In Section <a href="chap4.html#X8450C72580D91245">Computing Descendants of a p-Group</a>, we describe functions that give access to the p-group generation algorithm.

To use any of the functions one must have at some stage previously typed:

<div class="example"><pre>
gap> LoadPackage("anupq");
</pre></div>

(the response of which we have omitted; see <a href="chap3.html#X833D58248067E13B">Loading the ANUPQ Package</a>).

It is strongly recommended that the user try the examples provided. To save typing there is a <code class="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 class="code">InfoANUPQ</code> level to 2 (see <code class="func">InfoANUPQ</code> (<a href="chap3.html#X7CBC9B458497BFF1">3.3-1</a>)).

<a id="X80406BD47EB186E9" name="X80406BD47EB186E9"></a>

<h4>4.1 Computing p-Quotients</h4>

<a id="X86DD32D5803CF2C8" name="X86DD32D5803CF2C8"></a>

<h5>4.1-1 Pq</h5>

<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ Pq</code>( <var class="Arg">F:</var> <var class="Arg">options</var> )</td><td class="tdright">( function )</td></tr></table></div>
returns for the fp or pc group <var class="Arg">F</var>, the p-quotient of <var class="Arg">F</var> specified by <var class="Arg">options</var>, as a pc group. Following the colon, <var class="Arg">options</var> is a selection of the options from the following list, separated by commas like record components (see Section <a href="../../../doc/ref/chap4_mj.html#X867D54987EF86D1D">Reference: Function Call With Options</a> in the GAP Reference Manual). As a minimum the user must supply a value for the <code class="code">Prime</code> option. Below we list the options recognised by <code class="code">Pq</code> (see Chapter <a href="chap6.html#X7B0946E97E7EB359">ANUPQ Options</a> for detailed descriptions).

<ul>
<li><code class="code">Prime := <var class="Arg">p</var></code>

</li>
<li><code class="code">ClassBound := <var class="Arg">n</var></code>

</li>
<li><code class="code">Exponent := <var class="Arg">n</var></code>

</li>
<li><code class="code">Relators := <var class="Arg">rels</var></code>

</li>
<li><code class="code">Metabelian</code>

</li>
<li><code class="code">Identities := <var class="Arg">funcs</var></code>

</li>
<li><code class="code">GroupName := <var class="Arg">name</var></code>

</li>
<li><code class="code">OutputLevel := <var class="Arg">n</var></code>

</li>
<li><code class="code">SetupFile := <var class="Arg">filename</var></code>

</li>
<li><code class="code">PqWorkspace := <var class="Arg">workspace</var></code>

</li>
</ul>
Notes: <code class="code">Pq</code> may also be called with no arguments or one integer argument, in which case it is being used interactively (see <code class="func">Pq</code> (<a href="chap5.html#X85408C4C790439E7">5.3-1</a>)); the same options may be used, except that <code class="code">SetupFile</code> and <code class="code">PqWorkspace</code> are ignored by the interactive <code class="code">Pq</code> function.

See Section <a href="chap3.html#X818175EF85CAA807">Attributes and a Property for fp and pc p-groups</a> for the attributes and property <code class="code">NuclearRank</code>, <code class="code">MultiplicatorRank</code> and <code class="code">IsCapable</code> which may be applied to the group returned by <code class="code">Pq</code>.

See also <code class="code">PqEpimorphism</code> (<code class="func">PqEpimorphism</code> (<a href="chap4.html#X7ADE5DDB87B99CC0">4.1-2</a>)).

We now give a few examples of the use of <code class="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 class="code">PqExample( "Pq" );</code> (see <code class="func">PqExample</code> (<a href="chap3.html#X7BB0EB607F337265">3.4-4</a>)).

<div class="example"><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></div>

Now we redo the last example to show how one may use the <code class="code">Relators</code> option. Observe that <code class="code">Comm(Comm(b, a), a)</code> is a left normed commutator which must be written in square bracket notation for the <code class="code">pq</code> program and embedded in a pair of double quotes. The function <code class="code">PqGAPRelators</code> (see <code class="func">PqGAPRelators</code> (<a href="chap3.html#X7A567432879510A6">3.4-2</a>)) can be used to translate a list of strings prepared for the <code class="code">Relators</code> option into GAP format. Below we use it. Observe that the value of <code class="code">R</code> is the same as before.

<div class="example"><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></div>

In fact, above we could have just passed <code class="code">F</code> (rather than <code class="code">H</code>), i.e. we could have done:

<div class="example"><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></div>

The non-interactive <code class="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 GAP 3 version of the ANUPQ 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.

<div class="example"><pre>
gap> Pq( H, rec( Prime := 5, ClassBound := 5, Metabelian := true ) );
<pc group of size 78125 with 7 generators>
</pre></div>

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.

<div class="example"><pre>
gap> Pq( H, "Prime", 5, "ClassBound", 5, "Metabelian" );
<pc group of size 78125 with 7 generators>
</pre></div>

The preceding two examples can be run from GAP via <code class="code">PqExample( "Pq-ni" );</code> (see <code class="func">PqExample</code> (<a href="chap3.html#X7BB0EB607F337265">3.4-4</a>)).

This method of passing options permits abbreviation; the only restriction is that the abbreviation must be unique. So <code class="code">"Pr"</code> may be used for <code class="code">"Prime"</code>, <code class="code">"Class"</code> or even just <code class="code">"C"</code> for <code class="code">"ClassBound"</code>, etc.

The following example illustrates the use of the option <code class="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.

<div class="example"><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></div>

The above example can be run from GAP via <code class="code">PqExample( "B5-5-Engel3-Id" );</code> (see <code class="func">PqExample</code> (<a href="chap3.html#X7BB0EB607F337265">3.4-4</a>)).

<a id="X7ADE5DDB87B99CC0" name="X7ADE5DDB87B99CC0"></a>

<h5>4.1-2 PqEpimorphism</h5>

<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ PqEpimorphism</code>( <var class="Arg">F:</var> <var class="Arg">options</var> )</td><td class="tdright">( function )</td></tr></table></div>
returns for the fp or pc group <var class="Arg">F</var> an epimorphism from <var class="Arg">F</var> onto the p-quotient of <var class="Arg">F</var> specified by <var class="Arg">options</var>; the possible options <var class="Arg">options</var> and required option (<code class="code">"Prime"</code>) are as for <code class="code">Pq</code> (see <code class="func">Pq</code> (<a href="chap4.html#X86DD32D5803CF2C8">4.1-1</a>)). <code class="code">PqEpimorphism</code> only differs from <code class="code">Pq</code> in what it outputs; everything about what must/may be passed as input to <code class="code">PqEpimorphism</code> is the same as for <code class="code">Pq</code>. The same alternative methods of passing options to the non-interactive <code class="code">Pq</code> function are available to the non-interactive version of <code class="code">PqEpimorphism</code>.

Notes: <code class="code">PqEpimorphism</code> may also be called with no arguments or one integer argument, in which case it is being used interactively (see <code class="func">PqEpimorphism</code> (<a href="chap5.html#X839E6F578227A8EA">5.3-2</a>)), and the options <code class="code">SetupFile</code> and <code class="code">PqWorkspace</code> are ignored by the interactive <code class="code">PqEpimorphism</code> function.

See Section <a href="chap3.html#X818175EF85CAA807">Attributes and a Property for fp and pc p-groups</a> for the attributes and property <code class="code">NuclearRank</code>, <code class="code">MultiplicatorRank</code> and <code class="code">IsCapable</code> which may be applied to the image group of the epimorphism returned by <code class="code">PqEpimorphism</code>.

<div class="example"><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></div>

Typing: <code class="code">PqExample( "PqEpimorphism" );</code> runs the above example in GAP (see <code class="func">PqExample</code> (<a href="chap3.html#X7BB0EB607F337265">3.4-4</a>)).

<a id="X81C3CE1E850DA252" name="X81C3CE1E850DA252"></a>

<h5>4.1-3 PqPCover</h5>

<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ PqPCover</code>( <var class="Arg">F:</var> <var class="Arg">options</var> )</td><td class="tdright">( function )</td></tr></table></div>
returns for the fp or pc group <var class="Arg">F</var>, the p-covering group of the p-quotient of <var class="Arg">F</var> specified by <var class="Arg">options</var>, as a pc group, i.e. the p-covering group of the p-quotient <code class="code">Pq( <var class="Arg">F</var> : <var class="Arg">options</var> )</code>. Thus the options that <code class="code">PqPCover</code> accepts are exactly those expected for <code class="code">Pq</code> (and hence as a minimum the user must supply a value for the <code class="code">Prime</code> option; see <code class="func">Pq</code> (<a href="chap4.html#X86DD32D5803CF2C8">4.1-1</a>) for more details), except in the following special case.

If <var class="Arg">F</var> is already a p-group, in the sense that <code class="code">IsPGroup(<var class="Arg">F</var>)</code> is <code class="keyw">true</code>, then

<dl>
<dt><code class="code">Prime</code></dt>
<dd>defaults to <code class="code">PrimePGroup(<var class="Arg">F</var>)</code>, if not supplied and <code class="code">HasPrimePGroup(<var class="Arg">F</var>) = true</code>; and

</dd>
<dt><code class="code">ClassBound</code></dt>
<dd>defaults to <code class="code">PClassPGroup(<var class="Arg">F</var>)</code> if <code class="code">HasPClassPGroup(<var class="Arg">F</var>) = true</code> if not supplied, or to the usual default of 63, otherwise.

</dd>
</dl>
The same alternative methods of passing options to the non-interactive <code class="code">Pq</code> function are available to the non-interactive version of <code class="code">PqPCover</code>.

We now give a few examples of the use of <code class="code">PqPCover</code>. These examples are just a subset of the ones we gave for <code class="code">Pq</code> (see <code class="func">Pq</code> (<a href="chap4.html#X86DD32D5803CF2C8">4.1-1</a>)), except that in each instance the command <code class="code">Pq</code> has been replaced with <code class="code">PqPCover</code>. Essentially the same examples may be run by typing: <code class="code">PqExample( "PqPCover" );</code> (see <code class="func">PqExample</code> (<a href="chap3.html#X7BB0EB607F337265">3.4-4</a>)).

<div class="example"><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></div>

<a id="X7F05F8DC79733A8E" name="X7F05F8DC79733A8E"></a>

<h4>4.2 Computing Standard Presentations</h4>

<a id="X86C9575D7CB65FBB" name="X86C9575D7CB65FBB"></a>

<h5>4.2-1 PqStandardPresentation</h5>

<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ PqStandardPresentation</code>( <var class="Arg">F:</var> <var class="Arg">options</var> )</td><td class="tdright">( function )</td></tr></table></div>
<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ StandardPresentation</code>( <var class="Arg">F:</var> <var class="Arg">options</var> )</td><td class="tdright">( method )</td></tr></table></div>
return the <var class="Arg">p</var>-quotient specified by <var class="Arg">options</var> of the fp or pc p-group <var class="Arg">F</var>, as an fp group which has a standard presentation. Here <var class="Arg">options</var> is a selection of the options from the following list (see Chapter <a href="chap6.html#X7B0946E97E7EB359">ANUPQ Options</a> for detailed descriptions). Section <a href="chap3.html#X7BA20FA07B166B37">Hints and Warnings regarding the use of Options</a> gives some important hints and warnings regarding option usage, and Section <a href="../../../doc/ref/chap4_mj.html#X867D54987EF86D1D">Reference: Function Call With Options</a> in the GAP Reference Manual describes their <q>record</q>-like syntax.

<ul>
<li><code class="code">Prime := <var class="Arg">p</var></code>

</li>
<li><code class="code">pQuotient := <var class="Arg">Q</var></code>

</li>
<li><code class="code">ClassBound := <var class="Arg">n</var></code>

</li>
<li><code class="code">Exponent := <var class="Arg">n</var></code>

</li>
<li><code class="code">Metabelian</code>

</li>
<li><code class="code">GroupName := <var class="Arg">name</var></code>

</li>
<li><code class="code">OutputLevel := <var class="Arg">n</var></code>

</li>
<li><code class="code">StandardPresentationFile := <var class="Arg">filename</var></code>

</li>
<li><code class="code">SetupFile := <var class="Arg">filename</var></code>

</li>
<li><code class="code">PqWorkspace := <var class="Arg">workspace</var></code>

</li>
</ul>
Unless <var class="Arg">F</var> is a pc <var class="Arg">p</var>-group, the user must supply either the option <code class="code">Prime</code> or the option <code class="code">pQuotient</code> (if both <code class="code">Prime</code> and <code class="code">pQuotient</code> are supplied, the prime <var class="Arg">p</var> is determined by applying <code class="code">PrimePGroup</code> (see <code class="func">PrimePGroup</code> (<a href="../../../doc/ref/chap39_mj.html#X87356BAA7E9E2142">Reference: PrimePGroup</a>) in the Reference Manual) to the value of <code class="code">pQuotient</code>).

The options for <code class="code">PqStandardPresentation</code> may also be passed in the two other alternative ways described for <code class="code">Pq</code> (see <code class="func">Pq</code> (<a href="chap4.html#X86DD32D5803CF2C8">4.1-1</a>)). <code class="code">StandardPresentation</code> does not provide these alternative ways of passing options.

Notes: In contrast to the function <code class="code">Pq</code> (see <code class="func">Pq</code> (<a href="chap4.html#X86DD32D5803CF2C8">4.1-1</a>)) which returns a pc group, <code class="code">PqStandardPresentation</code> or <code class="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 class="code">PcGroupFpGroup</code> (see <code class="func">PcGroupFpGroup</code> (<a href="../../../doc/ref/chap46_mj.html#X84C10D1F7CB5274F">Reference: PcGroupFpGroup</a>) in the GAP Reference Manual) to form a pc group.

If the user does not supply a <var class="Arg">p</var>-quotient <var class="Arg">Q</var> via the <code class="code">pQuotient</code> option and the prime <var class="Arg">p</var> is either supplied or <var class="Arg">F</var> is a pc <var class="Arg">p</var>-group, then a <var class="Arg">p</var>-quotient <var class="Arg">Q</var> is computed. If the user does supply a <var class="Arg">p</var>-quotient <var class="Arg">Q</var> via the <code class="code">pQuotient</code> option, the package AutPGrp is called to compute the automorphism group of <var class="Arg">Q</var>; an error will occur that asks the user to install the package AutPGrp if the automorphism group cannot be computed.

The attributes and property <code class="code">NuclearRank</code>, <code class="code">MultiplicatorRank</code> and <code class="code">IsCapable</code> are set for the group returned by <code class="code">PqStandardPresentation</code> or <code class="code">StandardPresentation</code> (see Section <a href="chap3.html#X818175EF85CAA807">Attributes and a Property for fp and pc p-groups</a>).

We illustrate the method with the following examples.

<div class="example"><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></div>

Typing: <code class="code">PqExample( "StandardPresentation" );</code> runs the above example in GAP (see <code class="func">PqExample</code> (<a href="chap3.html#X7BB0EB607F337265">3.4-4</a>)).

<a id="X828C06D083C0D089" name="X828C06D083C0D089"></a>

<h5>4.2-2 EpimorphismPqStandardPresentation</h5>

<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ EpimorphismPqStandardPresentation</code>( <var class="Arg">F:</var> <var class="Arg">options</var> )</td><td class="tdright">( function )</td></tr></table></div>
<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ EpimorphismStandardPresentation</code>( <var class="Arg">F:</var> <var class="Arg">options</var> )</td><td class="tdright">( method )</td></tr></table></div>
Each of the above functions accepts the same arguments and options as the function <code class="code">StandardPresentation</code> (see <code class="func">StandardPresentation</code> (<a href="chap4.html#X86C9575D7CB65FBB">4.2-1</a>)) and returns an epimorphism from the fp or pc group <var class="Arg">F</var> onto the finitely presented group given by a standard presentation, i.e. if <var class="Arg">S</var> is the standard presentation computed for the p-quotient of <var class="Arg">F</var> by <code class="code">StandardPresentation</code> then <code class="code">EpimorphismStandardPresentation</code> returns the epimorphism from <var class="Arg">F</var> to the group with presentation <var class="Arg">S</var>.

Note: The attributes and property <code class="code">NuclearRank</code>, <code class="code">MultiplicatorRank</code> and <code class="code">IsCapable</code> are set for the image group of the epimorphism returned by <code class="code">EpimorphismPqStandardPresentation</code> or <code class="code">EpimorphismStandardPresentation</code> (see Section <a href="chap3.html#X818175EF85CAA807">Attributes and a Property for fp and pc p-groups</a>).

We illustrate the function with the following example.

<div class="example"><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> Source(phi); # 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> Range(phi); # 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></div>

Typing: <code class="code">PqExample( "EpimorphismStandardPresentation" );</code> runs the above example in GAP (see <code class="func">PqExample</code> (<a href="chap3.html#X7BB0EB607F337265">3.4-4</a>)). Note that <code class="code">AssignGeneratorVariables</code> (see <code class="func">AssignGeneratorVariables</code> (<a href="../../../doc/ref/chap37_mj.html#X814203E281F3272E">Reference: AssignGeneratorVariables</a>)) has only been available since GAP 4.3.

<a id="X8030FAE586423615" name="X8030FAE586423615"></a>

<h4>4.3 Testing p-Groups for Isomorphism</h4>

<a id="X854389FC780BB178" name="X854389FC780BB178"></a>

<h5>4.3-1 IsPqIsomorphicPGroup</h5>

<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ IsPqIsomorphicPGroup</code>( <var class="Arg">G</var>, <var class="Arg">H</var> )</td><td class="tdright">( function )</td></tr></table></div>
<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ IsIsomorphicPGroup</code>( <var class="Arg">G</var>, <var class="Arg">H</var> )</td><td class="tdright">( method )</td></tr></table></div>
each return true if <var class="Arg">G</var> is isomorphic to <var class="Arg">H</var>, where both <var class="Arg">G</var> and <var class="Arg">H</var> must be pc groups of prime power order. These functions compute and compare in GAP the fp groups given by standard presentations for <var class="Arg">G</var> and <var class="Arg">H</var> (see <code class="func">StandardPresentation</code> (<a href="chap4.html#X86C9575D7CB65FBB">4.2-1</a>)).

<div class="example"><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 := ElementaryAbelianGroup( 8 );;
<pc group of size 8 with 3 generators>
gap> IsIsomorphicPGroup( P1, P2 );
false
gap> P3 := QuaternionGroup( 8 );
<pc group of size 8 with 3 generators>
gap> IsIsomorphicPGroup( P1, P3 );
false
gap> P4 := DihedralGroup( 8 );
<pc group of size 8 with 3 generators>
gap> IsIsomorphicPGroup( P1, P4 );
true
</pre></div>

Typing: <code class="code">PqExample( "IsIsomorphicPGroup" );</code> runs the above example in GAP (see <code class="func">PqExample</code> (<a href="chap3.html#X7BB0EB607F337265">3.4-4</a>)).

<a id="X8450C72580D91245" name="X8450C72580D91245"></a>

<h4>4.4 Computing Descendants of a p-Group</h4>

<a id="X80985CC479CD9FA3" name="X80985CC479CD9FA3"></a>

<h5>4.4-1 PqDescendants</h5>

<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ PqDescendants</code>( <var class="Arg">G:</var> <var class="Arg">options</var> )</td><td class="tdright">( function )</td></tr></table></div>
returns, for the pc group <var class="Arg">G</var> which must be of prime power order with a confluent pc presentation (see <code class="func">IsConfluent</code> (<a href="../../../doc/ref/chap46_mj.html#X7DF4835F79667099">Reference: IsConfluent for pc groups</a>) in the GAP Reference Manual), a list of descendants (pc groups) of <var class="Arg">G</var>. Following the colon <var class="Arg">options</var> a selection of the options listed below should be given, separated by commas like record components (see Section <a href="../../../doc/ref/chap4_mj.html#X867D54987EF86D1D">Reference: Function Call With Options</a> in the GAP Reference Manual). See Chapter <a href="chap6.html#X7B0946E97E7EB359">ANUPQ Options</a> for detailed descriptions of the options.

The automorphism group of each descendant <var class="Arg">D</var> is also computed via a call to the <code class="code">AutomorphismGroupPGroup</code> function of the AutPGrp package.

<ul>
<li><code class="code">ClassBound := <var class="Arg">n</var></code>

</li>
<li><code class="code">Relators := <var class="Arg">rels</var></code>

</li>
<li><code class="code">OrderBound := <var class="Arg">n</var></code>

</li>
<li><code class="code">StepSize := <var class="Arg">n</var></code>, <code class="code">StepSize := <var class="Arg">list</var></code>

</li>
<li><code class="code">RankInitialSegmentSubgroups := <var class="Arg">n</var></code>

</li>
<li><code class="code">SpaceEfficient</code>

</li>
<li><code class="code">CapableDescendants</code>

</li>
<li><code class="code">AllDescendants := false</code>

</li>
<li><code class="code">Exponent := <var class="Arg">n</var></code>

</li>
<li><code class="code">Metabelian</code>

</li>
<li><code class="code">GroupName := <var class="Arg">name</var></code>

</li>
<li><code class="code">SubList := <var class="Arg">sub</var></code>

</li>
<li><code class="code">BasicAlgorithm</code>

</li>
<li><code class="code">CustomiseOutput := <var class="Arg">rec</var></code>

</li>
<li><code class="code">SetupFile := <var class="Arg">filename</var></code>

</li>
<li><code class="code">PqWorkspace := <var class="Arg">workspace</var></code>

</li>
</ul>
Notes: The function <code class="code">PqDescendants</code> uses the automorphism group of <var class="Arg">G</var> which it computes via the package AutPGrp. If this package is not installed an error may be raised. If the automorphism group of <var class="Arg">G</var> is insoluble, the <code class="code">pq</code> program will call GAP together with the AutPGrp package for certain orbit-stabilizer calculations. (So, in any case, one should ensure the AutPGrp package is installed.)

The attributes and property <code class="code">NuclearRank</code>, <code class="code">MultiplicatorRank</code> and <code class="code">IsCapable</code> are set for each group of the list returned by <code class="code">PqDescendants</code> (see Section <a href="chap3.html#X818175EF85CAA807">Attributes and a Property for fp and pc p-groups</a>).

The options <var class="Arg">options</var> for <code class="code">PqDescendants</code> may be passed in an alternative manner to that already described, namely you can pass <code class="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.

Note that you cannot set both <code class="code">OrderBound</code> and <code class="code">StepSize</code>.

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^6.

<div class="example"><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></div>

Below, we compute all capable descendants of order 27 of the elementary abelian group of order 9.

<div class="example"><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></div>

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

<div class="example"><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( d, Order ) ) );
[ 5, 5, 5 ]
</pre></div>

The examples <code class="code">"PqDescendants-1"</code>, <code class="code">"PqDescendants-2"</code> and <code class="code">"PqDescendants-3"</code> (in order) are essentially the same as the above three examples (see <code class="func">PqExample</code> (<a href="chap3.html#X7BB0EB607F337265">3.4-4</a>)).

<a id="X8364566A80A8C24B" name="X8364566A80A8C24B"></a>

<h5>4.4-2 PqSupplementInnerAutomorphisms</h5>

<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ PqSupplementInnerAutomorphisms</code>( <var class="Arg">D</var> )</td><td class="tdright">( function )</td></tr></table></div>
returns a generating set for a supplement to the inner automorphisms of <var class="Arg">D</var>, in the form of a record with fields <code class="code">agAutos</code>, <code class="code">agOrder</code> and <code class="code">glAutos</code>, as provided by the <code class="code">pq</code> program. One should be very careful in using these automorphisms for a descendant calculation.

Note: 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 class="code">pq</code> program.

<div class="example"><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(
 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 ],
 glAutos := [ ], glOper := [ ], glOrder := 1,
 group := <pc group of size 27 with 3 generators>,
 one := IdentityMapping( <pc group of size 27 with 3 generators> ),
 size := 54 )
</pre></div>

Typing: <code class="code">PqExample( "PqSupplementInnerAutomorphisms" );</code> runs the above example in GAP (see <code class="func">PqExample</code> (<a href="chap3.html#X7BB0EB607F337265">3.4-4</a>)).

Note that by also including <code class="code">PqStart</code> as a second argument to <code class="code">PqExample</code> one can see how it is possible, with the aid of <code class="code">PqSetPQuotientToGroup</code> (see <code class="func">PqSetPQuotientToGroup</code> (<a href="chap5.html#X80CCF6D379E5A3B4">5.3-7</a>)), to do the equivalent computations with the interactive versions of <code class="code">Pq</code> and <code class="code">PqDescendants</code> and a single <code class="code">pq</code> process (recall <code class="code">pq</code> is the name of the external C program).

<a id="X79AD54E987FCACBA" name="X79AD54E987FCACBA"></a>

<h5>4.4-3 PqList</h5>

<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ PqList</code>( <var class="Arg">filename:</var> [<var class="Arg">SubList</var> <var class="Arg">:=</var> <var class="Arg">sub</var>] )</td><td class="tdright">( function )</td></tr></table></div>
reads a file with name <var class="Arg">filename</var> (a string) and returns the list <var class="Arg">L</var> of pc groups (or with option <code class="code">SubList</code> a sublist of <var class="Arg">L</var> or a single pc group in <var class="Arg">L</var>) defined in that file. If the option <code class="code">SubList</code> is passed and has the value <var class="Arg">sub</var>, then it has the same meaning as for <code class="code">PqDescendants</code>, i.e. if <var class="Arg">sub</var> is an integer then <code class="code">PqList</code> returns <code class="code"><var class="Arg">L</var>[<var class="Arg">sub</var>]</code>; otherwise, if <var class="Arg">sub</var> is a list of integers <code class="code">PqList</code> returns <code class="code">Sublist(<var class="Arg">L</var>, <var class="Arg">sub</var> )</code>.

Both <code class="code">PqList</code> and <code class="code">SavePqList</code> (see <code class="func">SavePqList</code> (<a href="chap4.html#X85ADB9E6870EC3D1">4.4-4</a>)) can be used to save and restore a list of descendants (see <code class="func">PqDescendants</code> (<a href="chap4.html#X80985CC479CD9FA3">4.4-1</a>)).

<a id="X85ADB9E6870EC3D1" name="X85ADB9E6870EC3D1"></a>

<h5>4.4-4 SavePqList</h5>

<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ SavePqList</code>( <var class="Arg">filename</var>, <var class="Arg">list</var> )</td><td class="tdright">( function )</td></tr></table></div>
writes a list of descendants <var class="Arg">list</var> to a file with name <var class="Arg">filename</var> (a string).

<code class="code">SavePqList</code> and <code class="code">PqList</code> (see <code class="func">PqList</code> (<a href="chap4.html#X79AD54E987FCACBA">4.4-3</a>)) can be used to save and restore, respectively, the results of <code class="code">PqDescendants</code> (see <code class="func">PqDescendants</code> (<a href="chap4.html#X80985CC479CD9FA3">4.4-1</a>)).

<div class="chlinkprevnextbot"> <a href="chap0.html">[Top of Book]</a> <a href="chap0.html#contents">[Contents]</a> <a href="chap3.html">[Previous Chapter]</a> <a href="chap5.html">[Next Chapter]</a> </div>

<div class="chlinkbot">Goto Chapter: <a href="chap0.html">Top</a> <a href="chap1.html">1</a> <a href="chap2.html">2</a> <a href="chap3.html">3</a> <a href="chap4.html">4</a> <a href="chap5.html">5</a> <a href="chap6.html">6</a> <a href="chap7.html">7</a> <a href="chapA.html">A</a> <a href="chapBib.html">Bib</a> <a href="chapInd.html">Ind</a> </div>

<hr />
generated by <a href="https://www.math.rwth-aachen.de/~Frank.Luebeck/GAPDoc">GAPDoc2HTML</a>
</body>
</html>

quality100%

¤ Dauer der Verarbeitung: 0.25 Sekunden (vorverarbeitet) ¤

Wurzel

Suchen

Beweissystem der NASA

Beweissystem Isabelle

NIST Cobol Testsuite

Cephes Mathematical Library

Wiener Entwicklungsmethode

Haftungshinweis

Die Informationen auf dieser Webseite wurden nach bestem Wissen sorgfältig zusammengestellt. Es wird jedoch weder Vollständigkeit, noch Richtigkeit, noch Qualität der bereit gestellten Informationen zugesichert.

Bemerkung:

Die farbliche Syntaxdarstellung ist noch experimentell.