Debian Codegraph @

doc/chap4_mj.html

raw
1 <?xml version="1.0" encoding="UTF-8"?>
2
3 <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN"
4 "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">
5
6 <html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en">
7 <head>
8 <script type="text/javascript"
9 src="https://cdn.jsdelivr.net/npm/mathjax@2/MathJax.js?config=TeX-AMS-MML_HTMLorMML">
10 </script>
11 <title>GAP (ANUPQ) - Chapter 4: Non-interactive ANUPQ functions</title>
12 <meta http-equiv="content-type" content="text/html; charset=UTF-8" />
13 <meta name="generator" content="GAPDoc2HTML" />
14 <link rel="stylesheet" type="text/css" href="manual.css" />
15 <script src="manual.js" type="text/javascript"></script>
16 <script type="text/javascript">overwriteStyle();</script>
17 </head>
18 <body class="chap4" onload="jscontent()">
19
20
21 <div class="chlinktop"><span class="chlink1">Goto Chapter: </span><a href="chap0_mj.html">Top</a> <a href="chap1_mj.html">1</a> <a href="chap2_mj.html">2</a> <a href="chap3_mj.html">3</a> <a href="chap4_mj.html">4</a> <a href="chap5_mj.html">5</a> <a href="chap6_mj.html">6</a> <a href="chap7_mj.html">7</a> <a href="chapA_mj.html">A</a> <a href="chapBib_mj.html">Bib</a> <a href="chapInd_mj.html">Ind</a> </div>
22
23 <div class="chlinkprevnexttop">&nbsp;<a href="chap0_mj.html">[Top of Book]</a>&nbsp; <a href="chap0_mj.html#contents">[Contents]</a>&nbsp; &nbsp;<a href="chap3_mj.html">[Previous Chapter]</a>&nbsp; &nbsp;<a href="chap5_mj.html">[Next Chapter]</a>&nbsp; </div>
24
25 <p id="mathjaxlink" class="pcenter"><a href="chap4.html">[MathJax off]</a></p>
26 <p><a id="X7C51F26D839279FF" name="X7C51F26D839279FF"></a></p>
27 <div class="ChapSects"><a href="chap4_mj.html#X7C51F26D839279FF">4 <span class="Heading">Non-interactive ANUPQ functions</span></a>
28 <div class="ContSect"><span class="tocline"><span class="nocss">&nbsp;</span><a href="chap4_mj.html#X80406BD47EB186E9">4.1 <span class="Heading">Computing p-Quotients</span></a>
29 </span>
30 <div class="ContSSBlock">
31 <span class="ContSS"><br /><span class="nocss">&nbsp;&nbsp;</span><a href="chap4_mj.html#X86DD32D5803CF2C8">4.1-1 Pq</a></span>
32 <span class="ContSS"><br /><span class="nocss">&nbsp;&nbsp;</span><a href="chap4_mj.html#X7ADE5DDB87B99CC0">4.1-2 PqEpimorphism</a></span>
33 <span class="ContSS"><br /><span class="nocss">&nbsp;&nbsp;</span><a href="chap4_mj.html#X81C3CE1E850DA252">4.1-3 PqPCover</a></span>
34 </div></div>
35 <div class="ContSect"><span class="tocline"><span class="nocss">&nbsp;</span><a href="chap4_mj.html#X7F05F8DC79733A8E">4.2 <span class="Heading">Computing Standard Presentations</span></a>
36 </span>
37 <div class="ContSSBlock">
38 <span class="ContSS"><br /><span class="nocss">&nbsp;&nbsp;</span><a href="chap4_mj.html#X86C9575D7CB65FBB">4.2-1 PqStandardPresentation</a></span>
39 <span class="ContSS"><br /><span class="nocss">&nbsp;&nbsp;</span><a href="chap4_mj.html#X828C06D083C0D089">4.2-2 EpimorphismPqStandardPresentation</a></span>
40 </div></div>
41 <div class="ContSect"><span class="tocline"><span class="nocss">&nbsp;</span><a href="chap4_mj.html#X8030FAE586423615">4.3 <span class="Heading">Testing p-Groups for Isomorphism</span></a>
42 </span>
43 <div class="ContSSBlock">
44 <span class="ContSS"><br /><span class="nocss">&nbsp;&nbsp;</span><a href="chap4_mj.html#X854389FC780BB178">4.3-1 IsPqIsomorphicPGroup</a></span>
45 </div></div>
46 <div class="ContSect"><span class="tocline"><span class="nocss">&nbsp;</span><a href="chap4_mj.html#X8450C72580D91245">4.4 <span class="Heading">Computing Descendants of a p-Group</span></a>
47 </span>
48 <div class="ContSSBlock">
49 <span class="ContSS"><br /><span class="nocss">&nbsp;&nbsp;</span><a href="chap4_mj.html#X80985CC479CD9FA3">4.4-1 PqDescendants</a></span>
50 <span class="ContSS"><br /><span class="nocss">&nbsp;&nbsp;</span><a href="chap4_mj.html#X8364566A80A8C24B">4.4-2 PqSupplementInnerAutomorphisms</a></span>
51 <span class="ContSS"><br /><span class="nocss">&nbsp;&nbsp;</span><a href="chap4_mj.html#X79AD54E987FCACBA">4.4-3 PqList</a></span>
52 <span class="ContSS"><br /><span class="nocss">&nbsp;&nbsp;</span><a href="chap4_mj.html#X85ADB9E6870EC3D1">4.4-4 SavePqList</a></span>
53 </div></div>
54 </div>
55
56 <h3>4 <span class="Heading">Non-interactive ANUPQ functions</span></h3>
57
58 <p>Here we describe all the non-interactive functions of the <strong class="pkg">ANUPQ</strong> package; i.e. <q>one-shot</q> functions that invoke the <code class="code">pq</code> program in such a way that once <strong class="pkg">GAP</strong> 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_mj.html#X7DFB63A97E67C0A1"><span class="RefLink"><span class="Heading">Introduction</span></span></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.</p>
59
60 <p>In Section <a href="chap4_mj.html#X80406BD47EB186E9"><span class="RefLink"><span class="Heading">Computing p-Quotients</span></span></a>, we describe the functions that give access to the <span class="SimpleMath">\(p\)</span>-quotient algorithm.</p>
61
62 <p>Section <a href="chap4_mj.html#X7F05F8DC79733A8E"><span class="RefLink"><span class="Heading">Computing Standard Presentations</span></span></a> describe functions that give access to the standard presentation algorithm.</p>
63
64 <p>Section <a href="chap4_mj.html#X8030FAE586423615"><span class="RefLink"><span class="Heading">Testing p-Groups for Isomorphism</span></span></a> describe functions that implement an isomorphism test for <span class="SimpleMath">\(p\)</span>-groups using the standard presentation algorithm.</p>
65
66 <p>In Section <a href="chap4_mj.html#X8450C72580D91245"><span class="RefLink"><span class="Heading">Computing Descendants of a p-Group</span></span></a>, we describe functions that give access to the <span class="SimpleMath">\(p\)</span>-group generation algorithm.</p>
67
68 <p>To use any of the functions one must have at some stage previously typed:</p>
69
70
71 <div class="example"><pre>
72 <span class="GAPprompt">gap&gt;</span> <span class="GAPinput">LoadPackage("anupq");</span>
73 </pre></div>
74
75 <p>(the response of which we have omitted; see <a href="chap3_mj.html#X833D58248067E13B"><span class="RefLink"><span class="Heading">Loading the ANUPQ Package</span></span></a>).</p>
76
77 <p>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_mj.html#X7CBC9B458497BFF1"><span class="RefLink">3.3-1</span></a>)).</p>
78
79 <p><a id="X80406BD47EB186E9" name="X80406BD47EB186E9"></a></p>
80
81 <h4>4.1 <span class="Heading">Computing p-Quotients</span></h4>
82
83 <p><a id="X86DD32D5803CF2C8" name="X86DD32D5803CF2C8"></a></p>
84
85 <h5>4.1-1 Pq</h5>
86
87 <div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">&#8227; Pq</code>( <var class="Arg">F:</var> <var class="Arg">options</var> )</td><td class="tdright">(&nbsp;function&nbsp;)</td></tr></table></div>
88 <p>returns for the fp or pc group <var class="Arg">F</var>, the <span class="SimpleMath">\(p\)</span>-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"><span class="RefLink">Reference: Function Call With Options</span></a> in the <strong class="pkg">GAP</strong> Reference Manual). As a minimum the user <em>must</em> 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_mj.html#X7B0946E97E7EB359"><span class="RefLink"><span class="Heading">ANUPQ Options</span></span></a> for detailed descriptions).</p>
89
90
91 <ul>
92 <li><p><code class="code">Prime := <var class="Arg">p</var></code></p>
93
94 </li>
95 <li><p><code class="code">ClassBound := <var class="Arg">n</var></code></p>
96
97 </li>
98 <li><p><code class="code">Exponent := <var class="Arg">n</var></code></p>
99
100 </li>
101 <li><p><code class="code">Relators := <var class="Arg">rels</var></code></p>
102
103 </li>
104 <li><p><code class="code">Metabelian</code></p>
105
106 </li>
107 <li><p><code class="code">Identities := <var class="Arg">funcs</var></code></p>
108
109 </li>
110 <li><p><code class="code">GroupName := <var class="Arg">name</var></code></p>
111
112 </li>
113 <li><p><code class="code">OutputLevel := <var class="Arg">n</var></code></p>
114
115 </li>
116 <li><p><code class="code">SetupFile := <var class="Arg">filename</var></code></p>
117
118 </li>
119 <li><p><code class="code">PqWorkspace := <var class="Arg">workspace</var></code></p>
120
121 </li>
122 </ul>
123 <p><em>Notes:</em> <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_mj.html#X85408C4C790439E7"><span class="RefLink">5.3-1</span></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.</p>
124
125 <p>See Section <a href="chap3_mj.html#X818175EF85CAA807"><span class="RefLink"><span class="Heading">Attributes and a Property for fp and pc p-groups</span></span></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>.</p>
126
127 <p>See also <code class="code">PqEpimorphism</code> (<code class="func">PqEpimorphism</code> (<a href="chap4_mj.html#X7ADE5DDB87B99CC0"><span class="RefLink">4.1-2</span></a>)).</p>
128
129 <p>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_mj.html#X7BB0EB607F337265"><span class="RefLink">3.4-4</span></a>)).</p>
130
131
132 <div class="example"><pre>
133 <span class="GAPprompt">gap&gt;</span> <span class="GAPinput">LoadPackage("anupq");; # does nothing if ANUPQ is already loaded</span>
134 <span class="GAPprompt">gap&gt;</span> <span class="GAPinput"># First we get a p-quotient of a free group of rank 2</span>
135 <span class="GAPprompt">gap&gt;</span> <span class="GAPinput">F := FreeGroup("a", "b");; a := F.1;; b := F.2;;</span>
136 <span class="GAPprompt">gap&gt;</span> <span class="GAPinput">Pq( F : Prime := 2, ClassBound := 3 ); </span>
137 &lt;pc group of size 1024 with 10 generators&gt;
138 <span class="GAPprompt">gap&gt;</span> <span class="GAPinput"># Now let us get a p-quotient of an fp group</span>
139 <span class="GAPprompt">gap&gt;</span> <span class="GAPinput">G := F / [a^4, b^4];</span>
140 &lt;fp group on the generators [ a, b ]&gt;
141 <span class="GAPprompt">gap&gt;</span> <span class="GAPinput">Pq( G : Prime := 2, ClassBound := 3 ); </span>
142 &lt;pc group of size 256 with 8 generators&gt;
143 <span class="GAPprompt">gap&gt;</span> <span class="GAPinput"># Now let's get a different p-quotient of the same group</span>
144 <span class="GAPprompt">gap&gt;</span> <span class="GAPinput">Pq( G : Prime := 2, ClassBound := 3, Exponent := 4 ); </span>
145 &lt;pc group of size 128 with 7 generators&gt;
146 <span class="GAPprompt">gap&gt;</span> <span class="GAPinput"># Now we'll get a p-quotient of another fp group</span>
147 <span class="GAPprompt">gap&gt;</span> <span class="GAPinput"># which we will redo using the `Relators' option</span>
148 <span class="GAPprompt">gap&gt;</span> <span class="GAPinput">R := [ a^25, Comm(Comm(b, a), a), b^5 ];</span>
149 [ a^25, a^-1*b^-1*a*b*a^-1*b^-1*a^-1*b*a^2, b^5 ]
150 <span class="GAPprompt">gap&gt;</span> <span class="GAPinput">H := F / R;</span>
151 &lt;fp group on the generators [ a, b ]&gt;
152 <span class="GAPprompt">gap&gt;</span> <span class="GAPinput">Pq( H : Prime := 5, ClassBound := 5, Metabelian );</span>
153 &lt;pc group of size 78125 with 7 generators&gt;
154 </pre></div>
155
156 <p>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_mj.html#X7A567432879510A6"><span class="RefLink">3.4-2</span></a>)) can be used to translate a list of strings prepared for the <code class="code">Relators</code> option into <strong class="pkg">GAP</strong> format. Below we use it. Observe that the value of <code class="code">R</code> is the same as before.</p>
157
158
159 <div class="example"><pre>
160 <span class="GAPprompt">gap&gt;</span> <span class="GAPinput">F := FreeGroup("a", "b");;</span>
161 <span class="GAPprompt">gap&gt;</span> <span class="GAPinput"># `F' was defined for `Relators'. We use the same strings that GAP uses</span>
162 <span class="GAPprompt">gap&gt;</span> <span class="GAPinput"># for printing the free group generators. It is *not* necessary to</span>
163 <span class="GAPprompt">gap&gt;</span> <span class="GAPinput"># predefine: a := F.1; etc. (as it was above).</span>
164 <span class="GAPprompt">gap&gt;</span> <span class="GAPinput">rels := [ "a^25", "[b, a, a]", "b^5" ];</span>
165 [ "a^25", "[b, a, a]", "b^5" ]
166 <span class="GAPprompt">gap&gt;</span> <span class="GAPinput">R := PqGAPRelators(F, rels);</span>
167 [ a^25, a^-1*b^-1*a*b*a^-1*b^-1*a^-1*b*a^2, b^5 ]
168 <span class="GAPprompt">gap&gt;</span> <span class="GAPinput">H := F / R;</span>
169 &lt;fp group on the generators [ a, b ]&gt;
170 <span class="GAPprompt">gap&gt;</span> <span class="GAPinput">Pq( H : Prime := 5, ClassBound := 5, Metabelian, </span>
171 <span class="GAPprompt">&gt;</span> <span class="GAPinput"> Relators := rels );</span>
172 &lt;pc group of size 78125 with 7 generators&gt;
173 </pre></div>
174
175 <p>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:</p>
176
177
178 <div class="example"><pre>
179 <span class="GAPprompt">gap&gt;</span> <span class="GAPinput">F := FreeGroup("a", "b");;</span>
180 <span class="GAPprompt">gap&gt;</span> <span class="GAPinput">rels := [ "a^25", "[b, a, a]", "b^5" ];</span>
181 [ "a^25", "[b, a, a]", "b^5" ]
182 <span class="GAPprompt">gap&gt;</span> <span class="GAPinput">Pq( F : Prime := 5, ClassBound := 5, Metabelian, </span>
183 <span class="GAPprompt">&gt;</span> <span class="GAPinput"> Relators := rels );</span>
184 &lt;pc group of size 78125 with 7 generators&gt;
185 </pre></div>
186
187 <p>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 <strong class="pkg">GAP</strong> 3 version of the <strong class="pkg">ANUPQ</strong> 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>
188
189
190 <div class="example"><pre>
191 <span class="GAPprompt">gap&gt;</span> <span class="GAPinput">Pq( H, rec( Prime := 5, ClassBound := 5, Metabelian := true ) );</span>
192 &lt;pc group of size 78125 with 7 generators&gt;
193 </pre></div>
194
195 <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>
196
197
198 <div class="example"><pre>
199 <span class="GAPprompt">gap&gt;</span> <span class="GAPinput">Pq( H, "Prime", 5, "ClassBound", 5, "Metabelian" );</span>
200 &lt;pc group of size 78125 with 7 generators&gt;
201 </pre></div>
202
203 <p>The preceding two examples can be run from <strong class="pkg">GAP</strong> via <code class="code">PqExample( "Pq-ni" );</code> (see <code class="func">PqExample</code> (<a href="chap3_mj.html#X7BB0EB607F337265"><span class="RefLink">3.4-4</span></a>)).</p>
204
205 <p>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.</p>
206
207 <p>The following example illustrates the use of the option <code class="code">Identities</code>. We compute the largest finite Burnside group of exponent <span class="SimpleMath">\(5\)</span> that also satisfies the <span class="SimpleMath">\(3\)</span>-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>
208
209
210 <div class="example"><pre>
211 <span class="GAPprompt">gap&gt;</span> <span class="GAPinput">F := FreeGroup(2);</span>
212 &lt;free group on the generators [ f1, f2 ]&gt;
213 <span class="GAPprompt">gap&gt;</span> <span class="GAPinput">Burnside5 := x-&gt;x^5;</span>
214 function( x ) ... end
215 <span class="GAPprompt">gap&gt;</span> <span class="GAPinput">Engel3 := function( x,y ) return PqLeftNormComm( [x,y,y,y] ); end;</span>
216 function( x, y ) ... end
217 <span class="GAPprompt">gap&gt;</span> <span class="GAPinput">Pq( F : Prime := 5, Identities := [ Burnside5, Engel3 ] );</span>
218 #I Class 1 with 2 generators.
219 #I Class 2 with 3 generators.
220 #I Class 3 with 5 generators.
221 #I Class 3 with 5 generators.
222 &lt;pc group of size 3125 with 5 generators&gt;
223 </pre></div>
224
225 <p>The above example can be run from <strong class="pkg">GAP</strong> via <code class="code">PqExample( "B5-5-Engel3-Id" );</code> (see <code class="func">PqExample</code> (<a href="chap3_mj.html#X7BB0EB607F337265"><span class="RefLink">3.4-4</span></a>)).</p>
226
227 <p><a id="X7ADE5DDB87B99CC0" name="X7ADE5DDB87B99CC0"></a></p>
228
229 <h5>4.1-2 PqEpimorphism</h5>
230
231 <div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">&#8227; PqEpimorphism</code>( <var class="Arg">F:</var> <var class="Arg">options</var> )</td><td class="tdright">(&nbsp;function&nbsp;)</td></tr></table></div>
232 <p>returns for the fp or pc group <var class="Arg">F</var> an epimorphism from <var class="Arg">F</var> onto the <span class="SimpleMath">\(p\)</span>-quotient of <var class="Arg">F</var> specified by <var class="Arg">options</var>; the possible options <var class="Arg">options</var> and <em>required</em> option (<code class="code">"Prime"</code>) are as for <code class="code">Pq</code> (see <code class="func">Pq</code> (<a href="chap4_mj.html#X86DD32D5803CF2C8"><span class="RefLink">4.1-1</span></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>.</p>
233
234 <p><em>Notes:</em> <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_mj.html#X839E6F578227A8EA"><span class="RefLink">5.3-2</span></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.</p>
235
236 <p>See Section <a href="chap3_mj.html#X818175EF85CAA807"><span class="RefLink"><span class="Heading">Attributes and a Property for fp and pc p-groups</span></span></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>.</p>
237
238
239 <div class="example"><pre>
240 <span class="GAPprompt">gap&gt;</span> <span class="GAPinput">F := FreeGroup (2, "F");</span>
241 &lt;free group on the generators [ F1, F2 ]&gt;
242 <span class="GAPprompt">gap&gt;</span> <span class="GAPinput">phi := PqEpimorphism( F : Prime := 5, ClassBound := 2 );</span>
243 [ F1, F2 ] -&gt; [ f1, f2 ]
244 <span class="GAPprompt">gap&gt;</span> <span class="GAPinput">Image( phi );</span>
245 &lt;pc group of size 3125 with 5 generators&gt;
246 </pre></div>
247
248 <p>Typing: <code class="code">PqExample( "PqEpimorphism" );</code> runs the above example in <strong class="pkg">GAP</strong> (see <code class="func">PqExample</code> (<a href="chap3_mj.html#X7BB0EB607F337265"><span class="RefLink">3.4-4</span></a>)).</p>
249
250 <p><a id="X81C3CE1E850DA252" name="X81C3CE1E850DA252"></a></p>
251
252 <h5>4.1-3 PqPCover</h5>
253
254 <div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">&#8227; PqPCover</code>( <var class="Arg">F:</var> <var class="Arg">options</var> )</td><td class="tdright">(&nbsp;function&nbsp;)</td></tr></table></div>
255 <p>returns for the fp or pc group <var class="Arg">F</var>, the <span class="SimpleMath">\(p\)</span>-covering group of the <span class="SimpleMath">\(p\)</span>-quotient of <var class="Arg">F</var> specified by <var class="Arg">options</var>, as a pc group, i.e. the <span class="SimpleMath">\(p\)</span>-covering group of the <span class="SimpleMath">\(p\)</span>-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 <em>must</em> supply a value for the <code class="code">Prime</code> option; see <code class="func">Pq</code> (<a href="chap4_mj.html#X86DD32D5803CF2C8"><span class="RefLink">4.1-1</span></a>) for more details), except in the following special case.</p>
256
257 <p>If <var class="Arg">F</var> is already a <span class="SimpleMath">\(p\)</span>-group, in the sense that <code class="code">IsPGroup(<var class="Arg">F</var>)</code> is <code class="keyw">true</code>, then</p>
258
259
260 <dl>
261 <dt><strong class="Mark"><code class="code">Prime</code></strong></dt>
262 <dd><p>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</p>
263
264 </dd>
265 <dt><strong class="Mark"><code class="code">ClassBound</code></strong></dt>
266 <dd><p>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.</p>
267
268 </dd>
269 </dl>
270 <p>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>.</p>
271
272 <p>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_mj.html#X86DD32D5803CF2C8"><span class="RefLink">4.1-1</span></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_mj.html#X7BB0EB607F337265"><span class="RefLink">3.4-4</span></a>)).</p>
273
274
275 <div class="example"><pre>
276 <span class="GAPprompt">gap&gt;</span> <span class="GAPinput">F := FreeGroup("a", "b");; a := F.1;; b := F.2;;</span>
277 <span class="GAPprompt">gap&gt;</span> <span class="GAPinput">PqPCover( F : Prime := 2, ClassBound := 3 );</span>
278 &lt;pc group of size 262144 with 18 generators&gt;
279 <span class="GAPprompt">gap&gt;</span> <span class="GAPinput"></span>
280 <span class="GAPprompt">gap&gt;</span> <span class="GAPinput"># Now let's get a p-cover of a p-quotient of an fp group</span>
281 <span class="GAPprompt">gap&gt;</span> <span class="GAPinput">G := F / [a^4, b^4];</span>
282 &lt;fp group on the generators [ a, b ]&gt;
283 <span class="GAPprompt">gap&gt;</span> <span class="GAPinput">PqPCover( G : Prime := 2, ClassBound := 3 );</span>
284 &lt;pc group of size 16384 with 14 generators&gt;
285 <span class="GAPprompt">gap&gt;</span> <span class="GAPinput"></span>
286 <span class="GAPprompt">gap&gt;</span> <span class="GAPinput"># Now let's get a p-cover of a different p-quotient of the same group</span>
287 <span class="GAPprompt">gap&gt;</span> <span class="GAPinput">PqPCover( G : Prime := 2, ClassBound := 3, Exponent := 4 );</span>
288 &lt;pc group of size 8192 with 13 generators&gt;
289 <span class="GAPprompt">gap&gt;</span> <span class="GAPinput"></span>
290 <span class="GAPprompt">gap&gt;</span> <span class="GAPinput"># Now we'll get a p-cover of a p-quotient of another fp group</span>
291 <span class="GAPprompt">gap&gt;</span> <span class="GAPinput"># which we will redo using the `Relators' option</span>
292 <span class="GAPprompt">gap&gt;</span> <span class="GAPinput">R := [ a^25, Comm(Comm(b, a), a), b^5 ];</span>
293 [ a^25, a^-1*b^-1*a*b*a^-1*b^-1*a^-1*b*a^2, b^5 ]
294 <span class="GAPprompt">gap&gt;</span> <span class="GAPinput">H := F / R;</span>
295 &lt;fp group on the generators [ a, b ]&gt;
296 <span class="GAPprompt">gap&gt;</span> <span class="GAPinput">PqPCover( H : Prime := 5, ClassBound := 5, Metabelian );</span>
297 &lt;pc group of size 48828125 with 11 generators&gt;
298 <span class="GAPprompt">gap&gt;</span> <span class="GAPinput"></span>
299 <span class="GAPprompt">gap&gt;</span> <span class="GAPinput"># Now we redo the previous example using the `Relators' option</span>
300 <span class="GAPprompt">gap&gt;</span> <span class="GAPinput">F := FreeGroup("a", "b");;</span>
301 <span class="GAPprompt">gap&gt;</span> <span class="GAPinput">rels := [ "a^25", "[b, a, a]", "b^5" ];</span>
302 [ "a^25", "[b, a, a]", "b^5" ]
303 <span class="GAPprompt">gap&gt;</span> <span class="GAPinput">PqPCover( F : Prime := 5, ClassBound := 5, Metabelian, </span>
304 <span class="GAPprompt">&gt;</span> <span class="GAPinput"> Relators := rels );</span>
305 &lt;pc group of size 48828125 with 11 generators&gt;
306 </pre></div>
307
308 <p><a id="X7F05F8DC79733A8E" name="X7F05F8DC79733A8E"></a></p>
309
310 <h4>4.2 <span class="Heading">Computing Standard Presentations</span></h4>
311
312 <p><a id="X86C9575D7CB65FBB" name="X86C9575D7CB65FBB"></a></p>
313
314 <h5>4.2-1 PqStandardPresentation</h5>
315
316 <div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">&#8227; PqStandardPresentation</code>( <var class="Arg">F:</var> <var class="Arg">options</var> )</td><td class="tdright">(&nbsp;function&nbsp;)</td></tr></table></div>
317 <div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">&#8227; StandardPresentation</code>( <var class="Arg">F:</var> <var class="Arg">options</var> )</td><td class="tdright">(&nbsp;method&nbsp;)</td></tr></table></div>
318 <p>return the <var class="Arg">p</var>-quotient specified by <var class="Arg">options</var> of the fp or pc <span class="SimpleMath">\(p\)</span>-group <var class="Arg">F</var>, as an <em>fp group</em> 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_mj.html#X7B0946E97E7EB359"><span class="RefLink"><span class="Heading">ANUPQ Options</span></span></a> for detailed descriptions). Section <a href="chap3_mj.html#X7BA20FA07B166B37"><span class="RefLink"><span class="Heading">Hints and Warnings regarding the use of Options</span></span></a> gives some important hints and warnings regarding option usage, and Section <a href="../../../doc/ref/chap4_mj.html#X867D54987EF86D1D"><span class="RefLink">Reference: Function Call With Options</span></a> in the <strong class="pkg">GAP</strong> Reference Manual describes their <q>record</q>-like syntax.</p>
319
320
321 <ul>
322 <li><p><code class="code">Prime := <var class="Arg">p</var></code></p>
323
324 </li>
325 <li><p><code class="code">pQuotient := <var class="Arg">Q</var></code></p>
326
327 </li>
328 <li><p><code class="code">ClassBound := <var class="Arg">n</var></code></p>
329
330 </li>
331 <li><p><code class="code">Exponent := <var class="Arg">n</var></code></p>
332
333 </li>
334 <li><p><code class="code">Metabelian</code></p>
335
336 </li>
337 <li><p><code class="code">GroupName := <var class="Arg">name</var></code></p>
338
339 </li>
340 <li><p><code class="code">OutputLevel := <var class="Arg">n</var></code></p>
341
342 </li>
343 <li><p><code class="code">StandardPresentationFile := <var class="Arg">filename</var></code></p>
344
345 </li>
346 <li><p><code class="code">SetupFile := <var class="Arg">filename</var></code></p>
347
348 </li>
349 <li><p><code class="code">PqWorkspace := <var class="Arg">workspace</var></code></p>
350
351 </li>
352 </ul>
353 <p>Unless <var class="Arg">F</var> is a pc <var class="Arg">p</var>-group, the user <em>must</em> 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"><span class="RefLink">Reference: PrimePGroup</span></a>) in the Reference Manual) to the value of <code class="code">pQuotient</code>).</p>
354
355 <p>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_mj.html#X86DD32D5803CF2C8"><span class="RefLink">4.1-1</span></a>)). <code class="code">StandardPresentation</code> does not provide these alternative ways of passing options.</p>
356
357 <p><em>Notes:</em> In contrast to the function <code class="code">Pq</code> (see <code class="func">Pq</code> (<a href="chap4_mj.html#X86DD32D5803CF2C8"><span class="RefLink">4.1-1</span></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"><span class="RefLink">Reference: PcGroupFpGroup</span></a>) in the <strong class="pkg">GAP</strong> Reference Manual) to form a pc group.</p>
358
359 <p>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 <strong class="pkg">AutPGrp</strong> 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 <strong class="pkg">AutPGrp</strong> if the automorphism group cannot be computed.</p>
360
361 <p>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_mj.html#X818175EF85CAA807"><span class="RefLink"><span class="Heading">Attributes and a Property for fp and pc p-groups</span></span></a>).</p>
362
363 <p>We illustrate the method with the following examples.</p>
364
365
366 <div class="example"><pre>
367 <span class="GAPprompt">gap&gt;</span> <span class="GAPinput">F := FreeGroup( "a", "b" );; a := F.1;; b := F.2;;</span>
368 <span class="GAPprompt">gap&gt;</span> <span class="GAPinput">G := F / [a^25, Comm(Comm(b, a), a), b^5];</span>
369 &lt;fp group on the generators [ a, b ]&gt;
370 <span class="GAPprompt">gap&gt;</span> <span class="GAPinput">S := StandardPresentation( G : Prime := 5, ClassBound := 10 );</span>
371 &lt;fp group on the generators [ f1, f2, f3, f4, f5, f6, f7, f8, f9, f10, f11,
372 f12, f13, f14, f15, f16, f17, f18, f19, f20, f21, f22, f23, f24, f25, f26 ]&gt;
373 <span class="GAPprompt">gap&gt;</span> <span class="GAPinput">IsPcGroup( S );</span>
374 false
375 <span class="GAPprompt">gap&gt;</span> <span class="GAPinput"># if we need to compute with S we should convert it to a pc group</span>
376 <span class="GAPprompt">gap&gt;</span> <span class="GAPinput">Spc := PcGroupFpGroup( S );</span>
377 &lt;pc group of size 1490116119384765625 with 26 generators&gt;
378 <span class="GAPprompt">gap&gt;</span> <span class="GAPinput"></span>
379 <span class="GAPprompt">gap&gt;</span> <span class="GAPinput">H := F / [ a^625, Comm(Comm(Comm(Comm(b, a), a), a), a)/Comm(b, a)^5,</span>
380 <span class="GAPprompt">&gt;</span> <span class="GAPinput"> Comm(Comm(b, a), b), b^625 ];;</span>
381 <span class="GAPprompt">gap&gt;</span> <span class="GAPinput">StandardPresentation( H : Prime := 5, ClassBound := 15, Metabelian );</span>
382 &lt;fp group on the generators [ f1, f2, f3, f4, f5, f6, f7, f8, f9, f10, f11,
383 f12, f13, f14, f15, f16, f17, f18, f19, f20 ]&gt;
384 <span class="GAPprompt">gap&gt;</span> <span class="GAPinput"></span>
385 <span class="GAPprompt">gap&gt;</span> <span class="GAPinput">F4 := FreeGroup( "a", "b", "c", "d" );;</span>
386 <span class="GAPprompt">gap&gt;</span> <span class="GAPinput">a := F4.1;; b := F4.2;; c := F4.3;; d := F4.4;;</span>
387 <span class="GAPprompt">gap&gt;</span> <span class="GAPinput">G4 := F4 / [ b^4, b^2 / Comm(Comm (b, a), a), d^16,</span>
388 <span class="GAPprompt">&gt;</span> <span class="GAPinput"> a^16 / (c * d), b^8 / (d * c^4) ];</span>
389 &lt;fp group on the generators [ a, b, c, d ]&gt;
390 <span class="GAPprompt">gap&gt;</span> <span class="GAPinput">K := Pq( G4 : Prime := 2, ClassBound := 1 );</span>
391 &lt;pc group of size 4 with 2 generators&gt;
392 <span class="GAPprompt">gap&gt;</span> <span class="GAPinput">StandardPresentation( G4 : pQuotient := K, ClassBound := 14 );</span>
393 &lt;fp group with 53 generators&gt;
394 </pre></div>
395
396 <p>Typing: <code class="code">PqExample( "StandardPresentation" );</code> runs the above example in <strong class="pkg">GAP</strong> (see <code class="func">PqExample</code> (<a href="chap3_mj.html#X7BB0EB607F337265"><span class="RefLink">3.4-4</span></a>)).</p>
397
398 <p><a id="X828C06D083C0D089" name="X828C06D083C0D089"></a></p>
399
400 <h5>4.2-2 EpimorphismPqStandardPresentation</h5>
401
402 <div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">&#8227; EpimorphismPqStandardPresentation</code>( <var class="Arg">F:</var> <var class="Arg">options</var> )</td><td class="tdright">(&nbsp;function&nbsp;)</td></tr></table></div>
403 <div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">&#8227; EpimorphismStandardPresentation</code>( <var class="Arg">F:</var> <var class="Arg">options</var> )</td><td class="tdright">(&nbsp;method&nbsp;)</td></tr></table></div>
404 <p>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_mj.html#X86C9575D7CB65FBB"><span class="RefLink">4.2-1</span></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 <span class="SimpleMath">\(p\)</span>-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>.</p>
405
406 <p><em>Note:</em> 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_mj.html#X818175EF85CAA807"><span class="RefLink"><span class="Heading">Attributes and a Property for fp and pc p-groups</span></span></a>).</p>
407
408 <p>We illustrate the function with the following example.</p>
409
410
411 <div class="example"><pre>
412 <span class="GAPprompt">gap&gt;</span> <span class="GAPinput">F := FreeGroup(6, "F");</span>
413 &lt;free group on the generators [ F1, F2, F3, F4, F5, F6 ]&gt;
414 <span class="GAPprompt">gap&gt;</span> <span class="GAPinput"># For printing GAP uses the symbols F1, ... for the generators of F</span>
415 <span class="GAPprompt">gap&gt;</span> <span class="GAPinput">x := F.1;; y := F.2;; z := F.3;; w := F.4;; a := F.5;; b := F.6;;</span>
416 <span class="GAPprompt">gap&gt;</span> <span class="GAPinput">R := [x^3 / w, y^3 / w * a^2 * b^2, w^3 / b,</span>
417 <span class="GAPprompt">&gt;</span> <span class="GAPinput"> Comm (y, x) / z, Comm (z, x), Comm (z, y) / a, z^3 ];;</span>
418 <span class="GAPprompt">gap&gt;</span> <span class="GAPinput">Q := F / R;</span>
419 &lt;fp group on the generators [ F1, F2, F3, F4, F5, F6 ]&gt;
420 <span class="GAPprompt">gap&gt;</span> <span class="GAPinput"># For printing GAP also uses the symbols F1, ... for the generators of Q</span>
421 <span class="GAPprompt">gap&gt;</span> <span class="GAPinput"># (the same as used for F) ... but the gen'rs of Q and F are different:</span>
422 <span class="GAPprompt">gap&gt;</span> <span class="GAPinput">GeneratorsOfGroup(F) = GeneratorsOfGroup(Q);</span>
423 false
424 <span class="GAPprompt">gap&gt;</span> <span class="GAPinput">G := Pq( Q : Prime := 3, ClassBound := 3 );</span>
425 &lt;pc group of size 729 with 6 generators&gt;
426 <span class="GAPprompt">gap&gt;</span> <span class="GAPinput">phi := EpimorphismStandardPresentation( Q : Prime := 3,</span>
427 <span class="GAPprompt">&gt;</span> <span class="GAPinput"> ClassBound := 3 );</span>
428 [ F1, F2, F3, F4, F5, F6 ] -&gt; [ f1*f2^2*f3*f4^2*f5^2, f1*f2*f3*f5, f3^2,
429 f4*f6^2, f5, f6 ]
430 <span class="GAPprompt">gap&gt;</span> <span class="GAPinput">Source(phi); # This is the group Q (GAP uses F1, ... for gen'r symbols)</span>
431 &lt;fp group of size infinity on the generators [ F1, F2, F3, F4, F5, F6 ]&gt;
432 <span class="GAPprompt">gap&gt;</span> <span class="GAPinput">Range(phi); # This is the group G (GAP uses f1, ... for gen'r symbols)</span>
433 &lt;fp group on the generators [ f1, f2, f3, f4, f5, f6 ]&gt;
434 <span class="GAPprompt">gap&gt;</span> <span class="GAPinput">AssignGeneratorVariables(G);</span>
435 #I Assigned the global variables [ f1, f2, f3, f4, f5, f6 ]
436 <span class="GAPprompt">gap&gt;</span> <span class="GAPinput"># Just to see that the images of [F1, ..., F6] do generate G</span>
437 <span class="GAPprompt">gap&gt;</span> <span class="GAPinput">Group([ f1*f2^2*f3, f1*f2*f3*f4*f5^2*f6^2, f3^2, f4, f5, f6 ]) = G;</span>
438 true
439 <span class="GAPprompt">gap&gt;</span> <span class="GAPinput">Size( Image(phi) );</span>
440 729
441 </pre></div>
442
443 <p>Typing: <code class="code">PqExample( "EpimorphismStandardPresentation" );</code> runs the above example in <strong class="pkg">GAP</strong> (see <code class="func">PqExample</code> (<a href="chap3_mj.html#X7BB0EB607F337265"><span class="RefLink">3.4-4</span></a>)). Note that <code class="code">AssignGeneratorVariables</code> (see <code class="func">AssignGeneratorVariables</code> (<a href="../../../doc/ref/chap37_mj.html#X814203E281F3272E"><span class="RefLink">Reference: AssignGeneratorVariables</span></a>)) has only been available since <strong class="pkg">GAP</strong> 4.3.</p>
444
445 <p><a id="X8030FAE586423615" name="X8030FAE586423615"></a></p>
446
447 <h4>4.3 <span class="Heading">Testing p-Groups for Isomorphism</span></h4>
448
449 <p><a id="X854389FC780BB178" name="X854389FC780BB178"></a></p>
450
451 <h5>4.3-1 IsPqIsomorphicPGroup</h5>
452
453 <div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">&#8227; IsPqIsomorphicPGroup</code>( <var class="Arg">G</var>, <var class="Arg">H</var> )</td><td class="tdright">(&nbsp;function&nbsp;)</td></tr></table></div>
454 <div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">&#8227; IsIsomorphicPGroup</code>( <var class="Arg">G</var>, <var class="Arg">H</var> )</td><td class="tdright">(&nbsp;method&nbsp;)</td></tr></table></div>
455 <p>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 <strong class="pkg">GAP</strong> 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_mj.html#X86C9575D7CB65FBB"><span class="RefLink">4.2-1</span></a>)).</p>
456
457
458 <div class="example"><pre>
459 <span class="GAPprompt">gap&gt;</span> <span class="GAPinput">G := Group( (1,2,3,4), (1,3) );</span>
460 Group([ (1,2,3,4), (1,3) ])
461 <span class="GAPprompt">gap&gt;</span> <span class="GAPinput">P1 := Image( IsomorphismPcGroup( G ) );</span>
462 Group([ f1, f2, f3 ])
463 <span class="GAPprompt">gap&gt;</span> <span class="GAPinput">P2 := ElementaryAbelianGroup( 8 );</span>
464 &lt;pc group of size 8 with 3 generators&gt;
465 <span class="GAPprompt">gap&gt;</span> <span class="GAPinput">IsIsomorphicPGroup( P1, P2 );</span>
466 false
467 <span class="GAPprompt">gap&gt;</span> <span class="GAPinput">P3 := QuaternionGroup( 8 );</span>
468 &lt;pc group of size 8 with 3 generators&gt;
469 <span class="GAPprompt">gap&gt;</span> <span class="GAPinput">IsIsomorphicPGroup( P1, P3 );</span>
470 false
471 <span class="GAPprompt">gap&gt;</span> <span class="GAPinput">P4 := DihedralGroup( 8 );</span>
472 &lt;pc group of size 8 with 3 generators&gt;
473 <span class="GAPprompt">gap&gt;</span> <span class="GAPinput">IsIsomorphicPGroup( P1, P4 );</span>
474 true
475 </pre></div>
476
477 <p>Typing: <code class="code">PqExample( "IsIsomorphicPGroup" );</code> runs the above example in <strong class="pkg">GAP</strong> (see <code class="func">PqExample</code> (<a href="chap3_mj.html#X7BB0EB607F337265"><span class="RefLink">3.4-4</span></a>)).</p>
478
479 <p><a id="X8450C72580D91245" name="X8450C72580D91245"></a></p>
480
481 <h4>4.4 <span class="Heading">Computing Descendants of a p-Group</span></h4>
482
483 <p><a id="X80985CC479CD9FA3" name="X80985CC479CD9FA3"></a></p>
484
485 <h5>4.4-1 PqDescendants</h5>
486
487 <div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">&#8227; PqDescendants</code>( <var class="Arg">G:</var> <var class="Arg">options</var> )</td><td class="tdright">(&nbsp;function&nbsp;)</td></tr></table></div>
488 <p>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"><span class="RefLink">Reference: IsConfluent for pc groups</span></a>) in the <strong class="pkg">GAP</strong> Reference Manual), a list of proper 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"><span class="RefLink">Reference: Function Call With Options</span></a> in the <strong class="pkg">GAP</strong> Reference Manual). See Chapter <a href="chap6_mj.html#X7B0946E97E7EB359"><span class="RefLink"><span class="Heading">ANUPQ Options</span></span></a> for detailed descriptions of the options.</p>
489
490 <p>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 <strong class="pkg">AutPGrp</strong> package.</p>
491
492
493 <ul>
494 <li><p><code class="code">ClassBound := <var class="Arg">n</var></code></p>
495
496 </li>
497 <li><p><code class="code">Relators := <var class="Arg">rels</var></code></p>
498
499 </li>
500 <li><p><code class="code">OrderBound := <var class="Arg">n</var></code></p>
501
502 </li>
503 <li><p><code class="code">StepSize := <var class="Arg">n</var></code>, <code class="code">StepSize := <var class="Arg">list</var></code></p>
504
505 </li>
506 <li><p><code class="code">RankInitialSegmentSubgroups := <var class="Arg">n</var></code></p>
507
508 </li>
509 <li><p><code class="code">SpaceEfficient</code></p>
510
511 </li>
512 <li><p><code class="code">CapableDescendants</code></p>
513
514 </li>
515 <li><p><code class="code">AllDescendants := false</code></p>
516
517 </li>
518 <li><p><code class="code">Exponent := <var class="Arg">n</var></code></p>
519
520 </li>
521 <li><p><code class="code">Metabelian</code></p>
522
523 </li>
524 <li><p><code class="code">GroupName := <var class="Arg">name</var></code></p>
525
526 </li>
527 <li><p><code class="code">SubList := <var class="Arg">sub</var></code></p>
528
529 </li>
530 <li><p><code class="code">BasicAlgorithm</code></p>
531
532 </li>
533 <li><p><code class="code">CustomiseOutput := <var class="Arg">rec</var></code></p>
534
535 </li>
536 <li><p><code class="code">SetupFile := <var class="Arg">filename</var></code></p>
537
538 </li>
539 <li><p><code class="code">PqWorkspace := <var class="Arg">workspace</var></code></p>
540
541 </li>
542 </ul>
543 <p><em>Notes:</em> The function <code class="code">PqDescendants</code> uses the automorphism group of <var class="Arg">G</var> which it computes via the package <strong class="pkg">AutPGrp</strong>. 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 <strong class="pkg">GAP</strong> together with the <strong class="pkg">AutPGrp</strong> package for certain orbit-stabilizer calculations. (So, in any case, one should ensure the <strong class="pkg">AutPGrp</strong> package is installed.)</p>
544
545 <p>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_mj.html#X818175EF85CAA807"><span class="RefLink"><span class="Heading">Attributes and a Property for fp and pc p-groups</span></span></a>).</p>
546
547 <p>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.</p>
548
549 <p>Note that you cannot set both <code class="code">OrderBound</code> and <code class="code">StepSize</code>.</p>
550
551 <p>In the first example we compute all proper descendants of the Klein four group which have exponent-2 class at most 5 and order at most <span class="SimpleMath">\(2^6\)</span>.</p>
552
553
554 <div class="example"><pre>
555 <span class="GAPprompt">gap&gt;</span> <span class="GAPinput">F := FreeGroup( "a", "b" );; a := F.1;; b := F.2;;</span>
556 <span class="GAPprompt">gap&gt;</span> <span class="GAPinput">G := PcGroupFpGroup( F / [ a^2, b^2, Comm(b, a) ] );</span>
557 &lt;pc group of size 4 with 2 generators&gt;
558 <span class="GAPprompt">gap&gt;</span> <span class="GAPinput">des := PqDescendants( G : OrderBound := 6, ClassBound := 5 );;</span>
559 <span class="GAPprompt">gap&gt;</span> <span class="GAPinput">Length(des);</span>
560 83
561 <span class="GAPprompt">gap&gt;</span> <span class="GAPinput">List(des, Size); </span>
562 [ 8, 8, 8, 16, 16, 16, 32, 16, 16, 16, 16, 16, 32, 32, 64, 64, 32, 32, 32,
563 32, 32, 32, 32, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 32, 32, 32, 32,
564 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 32, 32, 32, 32, 32, 64, 64, 64,
565 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64,
566 64, 64, 64, 64, 64, 64, 64 ]
567 <span class="GAPprompt">gap&gt;</span> <span class="GAPinput">List(des, d -&gt; Length( PCentralSeries( d, 2 ) ) - 1 );</span>
568 [ 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,
569 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,
570 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,
571 4, 4, 4, 5, 5, 5, 5, 5 ]
572 </pre></div>
573
574 <p>Below, we compute all capable descendants of order 27 of the elementary abelian group of order 9.</p>
575
576
577 <div class="example"><pre>
578 <span class="GAPprompt">gap&gt;</span> <span class="GAPinput">F := FreeGroup( 2, "g" );</span>
579 &lt;free group on the generators [ g1, g2 ]&gt;
580 <span class="GAPprompt">gap&gt;</span> <span class="GAPinput">G := PcGroupFpGroup( F / [ F.1^3, F.2^3, Comm(F.1, F.2) ] );</span>
581 &lt;pc group of size 9 with 2 generators&gt;
582 <span class="GAPprompt">gap&gt;</span> <span class="GAPinput">des := PqDescendants( G : OrderBound := 3, ClassBound := 2,</span>
583 <span class="GAPprompt">&gt;</span> <span class="GAPinput"> CapableDescendants );</span>
584 [ &lt;pc group of size 27 with 3 generators&gt;,
585 &lt;pc group of size 27 with 3 generators&gt; ]
586 <span class="GAPprompt">gap&gt;</span> <span class="GAPinput">List(des, d -&gt; Length( PCentralSeries( d, 3 ) ) - 1 );</span>
587 [ 2, 2 ]
588 <span class="GAPprompt">gap&gt;</span> <span class="GAPinput"># For comparison let us now compute all proper descendants</span>
589 <span class="GAPprompt">gap&gt;</span> <span class="GAPinput">PqDescendants( G : OrderBound := 3, ClassBound := 2);</span>
590 [ &lt;pc group of size 27 with 3 generators&gt;,
591 &lt;pc group of size 27 with 3 generators&gt;,
592 &lt;pc group of size 27 with 3 generators&gt; ]
593 </pre></div>
594
595 <p>In the third example, we compute all proper capable descendants of the elementary abelian group of order <span class="SimpleMath">\(5^2\)</span> which have exponent-<span class="SimpleMath">\(5\)</span> class at most <span class="SimpleMath">\(3\)</span>, exponent <span class="SimpleMath">\(5\)</span>, and are metabelian.</p>
596
597
598 <div class="example"><pre>
599 <span class="GAPprompt">gap&gt;</span> <span class="GAPinput">F := FreeGroup( 2, "g" );;</span>
600 <span class="GAPprompt">gap&gt;</span> <span class="GAPinput">G := PcGroupFpGroup( F / [ F.1^5, F.2^5, Comm(F.2, F.1) ] );</span>
601 &lt;pc group of size 25 with 2 generators&gt;
602 <span class="GAPprompt">gap&gt;</span> <span class="GAPinput">des := PqDescendants( G : Metabelian, ClassBound := 3,</span>
603 <span class="GAPprompt">&gt;</span> <span class="GAPinput"> Exponent := 5, CapableDescendants );</span>
604 [ &lt;pc group of size 125 with 3 generators&gt;,
605 &lt;pc group of size 625 with 4 generators&gt;,
606 &lt;pc group of size 3125 with 5 generators&gt; ]
607 <span class="GAPprompt">gap&gt;</span> <span class="GAPinput">List(des, d -&gt; Length( PCentralSeries( d, 5 ) ) - 1 );</span>
608 [ 2, 3, 3 ]
609 <span class="GAPprompt">gap&gt;</span> <span class="GAPinput">List(des, d -&gt; Length( DerivedSeries( d ) ) );</span>
610 [ 3, 3, 3 ]
611 <span class="GAPprompt">gap&gt;</span> <span class="GAPinput">List(des, d -&gt; Maximum( List( d, Order ) ) );</span>
612 [ 5, 5, 5 ]
613 </pre></div>
614
615 <p>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_mj.html#X7BB0EB607F337265"><span class="RefLink">3.4-4</span></a>)).</p>
616
617 <p><a id="X8364566A80A8C24B" name="X8364566A80A8C24B"></a></p>
618
619 <h5>4.4-2 PqSupplementInnerAutomorphisms</h5>
620
621 <div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">&#8227; PqSupplementInnerAutomorphisms</code>( <var class="Arg">D</var> )</td><td class="tdright">(&nbsp;function&nbsp;)</td></tr></table></div>
622 <p>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.</p>
623
624 <p><em>Note:</em> 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.</p>
625
626
627 <div class="example"><pre>
628 <span class="GAPprompt">gap&gt;</span> <span class="GAPinput">Q := Pq( FreeGroup(2) : Prime := 3, ClassBound := 1 );</span>
629 &lt;pc group of size 9 with 2 generators&gt;
630 <span class="GAPprompt">gap&gt;</span> <span class="GAPinput">des := PqDescendants( Q : StepSize := 1 );</span>
631 [ &lt;pc group of size 27 with 3 generators&gt;,
632 &lt;pc group of size 27 with 3 generators&gt;,
633 &lt;pc group of size 27 with 3 generators&gt; ]
634 <span class="GAPprompt">gap&gt;</span> <span class="GAPinput">S := PqSupplementInnerAutomorphisms( des[3] );</span>
635 rec( agAutos := [ ], agOrder := [ 3, 2, 2, 2 ],
636 glAutos := [ Pcgs([ f1, f2, f3 ]) -&gt; [ f1*f2^2, f2, f3 ],
637 Pcgs([ f1, f2, f3 ]) -&gt; [ f1^2, f2, f3^2 ],
638 Pcgs([ f1, f2, f3 ]) -&gt; [ f1^2, f2, f3^2 ] ] )
639 <span class="GAPprompt">gap&gt;</span> <span class="GAPinput">A := AutomorphismGroupPGroup( des[3] );</span>
640 rec(
641 agAutos := [ Pcgs([ f1, f2, f3 ]) -&gt; [ f1^2, f2, f3^2 ],
642 Pcgs([ f1, f2, f3 ]) -&gt; [ f1*f2^2, f2, f3 ],
643 Pcgs([ f1, f2, f3 ]) -&gt; [ f1*f3, f2, f3 ],
644 Pcgs([ f1, f2, f3 ]) -&gt; [ f1, f2*f3, f3 ] ], agOrder := [ 2, 3, 3, 3 ],
645 glAutos := [ ], glOper := [ ], glOrder := 1,
646 group := &lt;pc group of size 27 with 3 generators&gt;,
647 one := IdentityMapping( &lt;pc group of size 27 with 3 generators&gt; ),
648 size := 54 )
649 </pre></div>
650
651 <p>Typing: <code class="code">PqExample( "PqSupplementInnerAutomorphisms" );</code> runs the above example in <strong class="pkg">GAP</strong> (see <code class="func">PqExample</code> (<a href="chap3_mj.html#X7BB0EB607F337265"><span class="RefLink">3.4-4</span></a>)).</p>
652
653 <p>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_mj.html#X80CCF6D379E5A3B4"><span class="RefLink">5.3-7</span></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).</p>
654
655 <p><a id="X79AD54E987FCACBA" name="X79AD54E987FCACBA"></a></p>
656
657 <h5>4.4-3 PqList</h5>
658
659 <div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">&#8227; 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">(&nbsp;function&nbsp;)</td></tr></table></div>
660 <p>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>.</p>
661
662 <p>Both <code class="code">PqList</code> and <code class="code">SavePqList</code> (see <code class="func">SavePqList</code> (<a href="chap4_mj.html#X85ADB9E6870EC3D1"><span class="RefLink">4.4-4</span></a>)) can be used to save and restore a list of descendants (see <code class="func">PqDescendants</code> (<a href="chap4_mj.html#X80985CC479CD9FA3"><span class="RefLink">4.4-1</span></a>)).</p>
663
664 <p><a id="X85ADB9E6870EC3D1" name="X85ADB9E6870EC3D1"></a></p>
665
666 <h5>4.4-4 SavePqList</h5>
667
668 <div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">&#8227; SavePqList</code>( <var class="Arg">filename</var>, <var class="Arg">list</var> )</td><td class="tdright">(&nbsp;function&nbsp;)</td></tr></table></div>
669 <p>writes a list of descendants <var class="Arg">list</var> to a file with name <var class="Arg">filename</var> (a string).</p>
670
671 <p><code class="code">SavePqList</code> and <code class="code">PqList</code> (see <code class="func">PqList</code> (<a href="chap4_mj.html#X79AD54E987FCACBA"><span class="RefLink">4.4-3</span></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_mj.html#X80985CC479CD9FA3"><span class="RefLink">4.4-1</span></a>)).</p>
672
673
674 <div class="chlinkprevnextbot">&nbsp;<a href="chap0_mj.html">[Top of Book]</a>&nbsp; <a href="chap0_mj.html#contents">[Contents]</a>&nbsp; &nbsp;<a href="chap3_mj.html">[Previous Chapter]</a>&nbsp; &nbsp;<a href="chap5_mj.html">[Next Chapter]</a>&nbsp; </div>
675
676
677 <div class="chlinkbot"><span class="chlink1">Goto Chapter: </span><a href="chap0_mj.html">Top</a> <a href="chap1_mj.html">1</a> <a href="chap2_mj.html">2</a> <a href="chap3_mj.html">3</a> <a href="chap4_mj.html">4</a> <a href="chap5_mj.html">5</a> <a href="chap6_mj.html">6</a> <a href="chap7_mj.html">7</a> <a href="chapA_mj.html">A</a> <a href="chapBib_mj.html">Bib</a> <a href="chapInd_mj.html">Ind</a> </div>
678
679 <hr />
680 <p class="foot">generated by <a href="https://www.math.rwth-aachen.de/~Frank.Luebeck/GAPDoc">GAPDoc2HTML</a></p>
681 </body>
682 </html>