Debian Codegraph @

doc/chapA.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 <title>GAP (ANUPQ) - Appendix A: Examples</title>
9 <meta http-equiv="content-type" content="text/html; charset=UTF-8" />
10 <meta name="generator" content="GAPDoc2HTML" />
11 <link rel="stylesheet" type="text/css" href="manual.css" />
12 <script src="manual.js" type="text/javascript"></script>
13 <script type="text/javascript">overwriteStyle();</script>
14 </head>
15 <body class="chapA" onload="jscontent()">
16
17
18 <div class="chlinktop"><span class="chlink1">Goto Chapter: </span><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>
19
20 <div class="chlinkprevnexttop">&nbsp;<a href="chap0.html">[Top of Book]</a>&nbsp; <a href="chap0.html#contents">[Contents]</a>&nbsp; &nbsp;<a href="chap7.html">[Previous Chapter]</a>&nbsp; &nbsp;<a href="chapBib.html">[Next Chapter]</a>&nbsp; </div>
21
22 <p id="mathjaxlink" class="pcenter"><a href="chapA_mj.html">[MathJax on]</a></p>
23 <p><a id="X7A489A5D79DA9E5C" name="X7A489A5D79DA9E5C"></a></p>
24 <div class="ChapSects"><a href="chapA.html#X7A489A5D79DA9E5C">A <span class="Heading">Examples</span></a>
25 <div class="ContSect"><span class="tocline"><span class="nocss">&nbsp;</span><a href="chapA.html#X80676E317BF4DF13">A.1 <span class="Heading">The Relators Option</span></a>
26 </span>
27 </div>
28 <div class="ContSect"><span class="tocline"><span class="nocss">&nbsp;</span><a href="chapA.html#X80B2AA7084C57F5D">A.2 <span class="Heading">The Identities Option and PqEvaluateIdentities Function</span></a>
29 </span>
30 </div>
31 <div class="ContSect"><span class="tocline"><span class="nocss">&nbsp;</span><a href="chapA.html#X7A997D1A8532A84B">A.3 <span class="Heading">A Large Example</span></a>
32 </span>
33 </div>
34 <div class="ContSect"><span class="tocline"><span class="nocss">&nbsp;</span><a href="chapA.html#X7FB6DA8D7BB90D8C">A.4 <span class="Heading">Developing descendants trees</span></a>
35 </span>
36 <div class="ContSSBlock">
37 <span class="ContSS"><br /><span class="nocss">&nbsp;&nbsp;</span><a href="chapA.html#X805E6B418193CF2D">A.4-1 PqDescendantsTreeCoclassOne</a></span>
38 </div></div>
39 </div>
40
41 <h3>A <span class="Heading">Examples</span></h3>
42
43 <p>There are a large number of examples provided with the <strong class="pkg">ANUPQ</strong> package. These may be executed or displayed via the function <code class="code">PqExample</code> (see <code class="func">PqExample</code> (<a href="chap3.html#X7BB0EB607F337265"><span class="RefLink">3.4-4</span></a>)). Each example resides in a file of the same name in the directory <code class="code">examples</code>. Most of the examples are translations to <strong class="pkg">GAP</strong> of examples provided for the <code class="code">pq</code> standalone by Eamonn O'Brien; the standalone examples are found in directories <code class="code">standalone/examples</code> (<span class="SimpleMath">p</span>-quotient and <span class="SimpleMath">p</span>-group generation examples) and <code class="code">standalone/isom</code> (standard presentation examples). The first line of each example indicates its origin. All the examples seen in earlier chapters of this manual are also available as examples, in a slightly modified form (the example which one can run in order to see something very close to the text example <q>live</q> is always indicated near -- usually immediately after -- the text example). The format of the (<code class="code">PqExample</code>) examples is such that they can be read by the standard <code class="code">Read</code> function of <strong class="pkg">GAP</strong>, but certain features and comments are interpreted by the function <code class="code">PqExample</code> to do somewhat more than <code class="code">Read</code> does. In particular, any function without a <code class="code">-i</code>, <code class="code">-ni</code> or <code class="code">.g</code> suffix has both a non-interactive and interactive form; in these cases, the default form is the non-interactive form, and giving <code class="code">PqStart</code> as second argument generates the interactive form.</p>
44
45 <p>Running <code class="code">PqExample</code> without an argument or with a non-existent example <code class="code">Info</code>s the available examples and some hints on usage:</p>
46
47
48 <div class="example"><pre>
49 <span class="GAPprompt">gap&gt;</span> <span class="GAPinput">PqExample();</span>
50 #I PqExample Index (Table of Contents)
51 #I -----------------------------------
52 #I This table of possible examples is displayed when calling `PqExample'
53 #I with no arguments, or with the argument: "index" (meant in the sense
54 #I of ``list''), or with a non-existent example name.
55 #I
56 #I Examples that have a name ending in `-ni' are non-interactive only.
57 #I Examples that have a name ending in `-i' are interactive only.
58 #I Examples with names ending in `.g' also have only one form. Other
59 #I examples have both a non-interactive and an interactive form; call
60 #I `PqExample' with 2nd argument `PqStart' to get the interactive form
61 #I of the example. The substring `PG' in an example name indicates a
62 #I p-Group Generation example, `SP' indicates a Standard Presentation
63 #I example, `Rel' indicates it uses the `Relators' option, and `Id'
64 #I indicates it uses the `Identities' option.
65 #I
66 #I The following ANUPQ examples are available:
67 #I
68 #I p-Quotient examples:
69 #I general:
70 #I "Pq" "Pq-ni" "PqEpimorphism"
71 #I "PqPCover" "PqSupplementInnerAutomorphisms"
72 #I 2-groups:
73 #I "2gp-Rel" "2gp-Rel-i" "2gp-a-Rel-i"
74 #I "B2-4" "B2-4-Id" "B2-8-i"
75 #I "B4-4-i" "B4-4-a-i" "B5-4.g"
76 #I 3-groups:
77 #I "3gp-Rel-i" "3gp-a-Rel" "3gp-a-Rel-i"
78 #I "3gp-a-x-Rel-i" "3gp-maxoccur-Rel-i"
79 #I 5-groups:
80 #I "5gp-Rel-i" "5gp-a-Rel-i" "5gp-b-Rel-i"
81 #I "5gp-c-Rel-i" "5gp-metabelian-Rel-i" "5gp-maxoccur-Rel-i"
82 #I "F2-5-i" "B2-5-i" "R2-5-i"
83 #I "R2-5-x-i" "B5-5-Engel3-Id"
84 #I 7-groups:
85 #I "7gp-Rel-i"
86 #I 11-groups:
87 #I "11gp-i" "11gp-Rel-i" "11gp-a-Rel-i"
88 #I "11gp-3-Engel-Id" "11gp-3-Engel-Id-i"
89 #I
90 #I p-Group Generation examples:
91 #I general:
92 #I "PqDescendants-1" "PqDescendants-2" "PqDescendants-3"
93 #I "PqDescendants-1-i"
94 #I 2-groups:
95 #I "2gp-PG-i" "2gp-PG-2-i" "2gp-PG-3-i"
96 #I "2gp-PG-4-i" "2gp-PG-e4-i"
97 #I "PqDescendantsTreeCoclassOne-16-i"
98 #I 3-groups:
99 #I "3gp-PG-i" "3gp-PG-4-i" "3gp-PG-x-i"
100 #I "3gp-PG-x-1-i" "PqDescendants-treetraverse-i"
101 #I "PqDescendantsTreeCoclassOne-9-i"
102 #I 5-groups:
103 #I "5gp-PG-i" "Nott-PG-Rel-i" "Nott-APG-Rel-i"
104 #I "PqDescendantsTreeCoclassOne-25-i"
105 #I 7,11-groups:
106 #I "7gp-PG-i" "11gp-PG-i"
107 #I
108 #I Standard Presentation examples:
109 #I general:
110 #I "StandardPresentation" "StandardPresentation-i"
111 #I "EpimorphismStandardPresentation"
112 #I "EpimorphismStandardPresentation-i" "IsIsomorphicPGroup-ni"
113 #I 2-groups:
114 #I "2gp-SP-Rel-i" "2gp-SP-1-Rel-i" "2gp-SP-2-Rel-i"
115 #I "2gp-SP-3-Rel-i" "2gp-SP-4-Rel-i" "2gp-SP-d-Rel-i"
116 #I "gp-256-SP-Rel-i" "B2-4-SP-i" "G2-SP-Rel-i"
117 #I 3-groups:
118 #I "3gp-SP-Rel-i" "3gp-SP-1-Rel-i" "3gp-SP-2-Rel-i"
119 #I "3gp-SP-3-Rel-i" "3gp-SP-4-Rel-i" "G3-SP-Rel-i"
120 #I 5-groups:
121 #I "5gp-SP-Rel-i" "5gp-SP-a-Rel-i" "5gp-SP-b-Rel-i"
122 #I "5gp-SP-big-Rel-i" "5gp-SP-d-Rel-i" "G5-SP-Rel-i"
123 #I "G5-SP-a-Rel-i" "Nott-SP-Rel-i"
124 #I 7-groups:
125 #I "7gp-SP-Rel-i" "7gp-SP-a-Rel-i" "7gp-SP-b-Rel-i"
126 #I 11-groups:
127 #I "11gp-SP-a-i" "11gp-SP-a-Rel-i" "11gp-SP-a-Rel-1-i"
128 #I "11gp-SP-b-i" "11gp-SP-b-Rel-i" "11gp-SP-c-Rel-i"
129 #I
130 #I Notes
131 #I -----
132 #I 1. The example (first) argument of `PqExample' is a string; each
133 #I example above is in double quotes to remind you to include them.
134 #I 2. Some examples accept options. To find out whether a particular
135 #I example accepts options, display it first (by including `Display'
136 #I as last argument) which will also indicate how `PqExample'
137 #I interprets the options, e.g. `PqExample("11gp-SP-a-i", Display);'.
138 #I 3. Try `SetInfoLevel(InfoANUPQ, &lt;n&gt;);' for some &lt;n&gt; in [2 .. 4]
139 #I before calling PqExample, to see what's going on behind the scenes.
140 #I
141 </pre></div>
142
143 <p>If on your terminal you are unable to scroll back, an alternative to typing <code class="code">PqExample();</code> to see the displayed examples is to use on-line help, i.e.  you may type:</p>
144
145
146 <div class="example"><pre>
147 <span class="GAPprompt">gap&gt;</span> <span class="GAPinput">?anupq:examples</span>
148 </pre></div>
149
150 <p>which will display this appendix in a <strong class="pkg">GAP</strong> session. If you are not fussed about the order in which the examples are organised, <code class="code">AllPqExamples();</code> lists the available examples relatively compactly (see <code class="func">AllPqExamples</code> (<a href="chap3.html#X823C93FC7B87F5BC"><span class="RefLink">3.4-5</span></a>)).</p>
151
152 <p>In the remainder of this appendix we will discuss particular aspects related to the <code class="code">Relators</code> (see <a href="chap6.html#X87EE6DD67C9996A3"><span class="RefLink">6.2</span></a>) and <code class="code">Identities</code> (see <a href="chap6.html#X87EE6DD67C9996A3"><span class="RefLink">6.2</span></a>) options, and the construction of the Burnside group <span class="SimpleMath">B(5, 4)</span>.</p>
153
154 <p><a id="X80676E317BF4DF13" name="X80676E317BF4DF13"></a></p>
155
156 <h4>A.1 <span class="Heading">The Relators Option</span></h4>
157
158 <p>The <code class="code">Relators</code> option was included because computations involving words containing commutators that are pre-expanded by <strong class="pkg">GAP</strong> before being passed to the <code class="code">pq</code> program may run considerably more slowly, than the same computations being run with <strong class="pkg">GAP</strong> pre-expansions avoided. The following examples demonstrate a case where the performance hit due to pre-expansion of commutators by <strong class="pkg">GAP</strong> is a factor of order 100 (in order to see timing information from the <code class="code">pq</code> program, we set the <code class="code">InfoANUPQ</code> level to 2).</p>
159
160 <p>Firstly, we run the example that allows pre-expansion of commutators (the function <code class="code">PqLeftNormComm</code> is provided by the <strong class="pkg">ANUPQ</strong> package; see <code class="func">PqLeftNormComm</code> (<a href="chap3.html#X8771393B7F53F534"><span class="RefLink">3.4-1</span></a>)). Note that since the two commutators of this example are <em>very</em> long (taking more than an page to print), we have edited the output at this point.</p>
161
162
163 <div class="example"><pre>
164 <span class="GAPprompt">gap&gt;</span> <span class="GAPinput">SetInfoLevel(InfoANUPQ, 2); #to see timing information</span>
165 <span class="GAPprompt">gap&gt;</span> <span class="GAPinput">PqExample("11gp-i");</span>
166 #I #Example: "11gp-i" . . . based on: examples/11gp
167 #I F, a, b, c, R, procId are local to `PqExample'
168 <span class="GAPprompt">gap&gt;</span> <span class="GAPinput">F := FreeGroup("a", "b", "c"); a := F.1; b := F.2; c := F.3;</span>
169 &lt;free group on the generators [ a, b, c ]&gt;
170 a
171 b
172 c
173 <span class="GAPprompt">gap&gt;</span> <span class="GAPinput">R := [PqLeftNormComm([b, a, a, b, c])^11, </span>
174 <span class="GAPprompt">&gt;</span> <span class="GAPinput"> PqLeftNormComm([a, b, b, a, b, c])^11, (a * b)^11];;</span>
175 <span class="GAPprompt">gap&gt;</span> <span class="GAPinput">procId := PqStart(F/R : Prime := 11);;</span>
176 <span class="GAPprompt">gap&gt;</span> <span class="GAPinput">PqPcPresentation(procId : ClassBound := 7, </span>
177 <span class="GAPprompt">&gt;</span> <span class="GAPinput"> OutputLevel := 1);</span>
178 #I Lower exponent-11 central series for [grp]
179 #I Group: [grp] to lower exponent-11 central class 1 has order 11^3
180 #I Group: [grp] to lower exponent-11 central class 2 has order 11^8
181 #I Group: [grp] to lower exponent-11 central class 3 has order 11^19
182 #I Group: [grp] to lower exponent-11 central class 4 has order 11^42
183 #I Group: [grp] to lower exponent-11 central class 5 has order 11^98
184 #I Group: [grp] to lower exponent-11 central class 6 has order 11^228
185 #I Group: [grp] to lower exponent-11 central class 7 has order 11^563
186 #I Computation of presentation took 27.04 seconds
187 <span class="GAPprompt">gap&gt;</span> <span class="GAPinput">PqSavePcPresentation(procId, ANUPQData.outfile);</span>
188 #I Variables used in `PqExample' are saved in `ANUPQData.example.vars'.
189 </pre></div>
190
191 <p>Now we do the same calculation using the <code class="code">Relators</code> option. In this way, the commutators are passed directly as strings to the <code class="code">pq</code> program, so that <strong class="pkg">GAP</strong> does not <q>see</q> them and pre-expand them.</p>
192
193
194 <div class="example"><pre>
195 <span class="GAPprompt">gap&gt;</span> <span class="GAPinput">PqExample("11gp-Rel-i");</span>
196 #I #Example: "11gp-Rel-i" . . . based on: examples/11gp
197 #I #(equivalent to "11gp-i" example but uses `Relators' option)
198 #I F, rels, procId are local to `PqExample'
199 <span class="GAPprompt">gap&gt;</span> <span class="GAPinput">F := FreeGroup("a", "b", "c");</span>
200 &lt;free group on the generators [ a, b, c ]&gt;
201 <span class="GAPprompt">gap&gt;</span> <span class="GAPinput">rels := ["[b, a, a, b, c]^11", "[a, b, b, a, b, c]^11", "(a * b)^11"];</span>
202 [ "[b, a, a, b, c]^11", "[a, b, b, a, b, c]^11", "(a * b)^11" ]
203 <span class="GAPprompt">gap&gt;</span> <span class="GAPinput">procId := PqStart(F : Prime := 11, Relators := rels);;</span>
204 <span class="GAPprompt">gap&gt;</span> <span class="GAPinput">PqPcPresentation(procId : ClassBound := 7, </span>
205 <span class="GAPprompt">&gt;</span> <span class="GAPinput"> OutputLevel := 1);</span>
206 #I Relators parsed ok.
207 #I Lower exponent-11 central series for [grp]
208 #I Group: [grp] to lower exponent-11 central class 1 has order 11^3
209 #I Group: [grp] to lower exponent-11 central class 2 has order 11^8
210 #I Group: [grp] to lower exponent-11 central class 3 has order 11^19
211 #I Group: [grp] to lower exponent-11 central class 4 has order 11^42
212 #I Group: [grp] to lower exponent-11 central class 5 has order 11^98
213 #I Group: [grp] to lower exponent-11 central class 6 has order 11^228
214 #I Group: [grp] to lower exponent-11 central class 7 has order 11^563
215 #I Computation of presentation took 0.27 seconds
216 <span class="GAPprompt">gap&gt;</span> <span class="GAPinput">PqSavePcPresentation(procId, ANUPQData.outfile);</span>
217 #I Variables used in `PqExample' are saved in `ANUPQData.example.vars'.
218 </pre></div>
219
220 <p><a id="X80B2AA7084C57F5D" name="X80B2AA7084C57F5D"></a></p>
221
222 <h4>A.2 <span class="Heading">The Identities Option and PqEvaluateIdentities Function</span></h4>
223
224 <p>Please pay heed to the warnings given for the <code class="code">Identities</code> option (see <a href="chap6.html#X87EE6DD67C9996A3"><span class="RefLink">6.2</span></a>); it is written mainly at the <strong class="pkg">GAP</strong> level and is not particularly optimised. The <code class="code">Identities</code> option allows one to compute <span class="SimpleMath">p</span>-quotients that satisfy an identity. A trivial example better done using the <code class="code">Exponent</code> option, but which nevertheless demonstrates the usage of the <code class="code">Identities</code> option, is as follows:</p>
225
226
227 <div class="example"><pre>
228 <span class="GAPprompt">gap&gt;</span> <span class="GAPinput">SetInfoLevel(InfoANUPQ, 1);</span>
229 <span class="GAPprompt">gap&gt;</span> <span class="GAPinput">PqExample("B2-4-Id");</span>
230 #I #Example: "B2-4-Id" . . . alternative way to generate B(2, 4)
231 #I #Generates B(2, 4) by using the `Identities' option
232 #I #... this is not as efficient as using `Exponent' but
233 #I #demonstrates the usage of the `Identities' option.
234 #I F, f, procId are local to `PqExample'
235 <span class="GAPprompt">gap&gt;</span> <span class="GAPinput">F := FreeGroup("a", "b");</span>
236 &lt;free group on the generators [ a, b ]&gt;
237 <span class="GAPprompt">gap&gt;</span> <span class="GAPinput"># All words w in the pc generators of B(2, 4) satisfy f(w) = 1 </span>
238 <span class="GAPprompt">gap&gt;</span> <span class="GAPinput">f := w -&gt; w^4;</span>
239 function( w ) ... end
240 <span class="GAPprompt">gap&gt;</span> <span class="GAPinput">Pq( F : Prime := 2, Identities := [ f ] );</span>
241 #I Class 1 with 2 generators.
242 #I Class 2 with 5 generators.
243 #I Class 3 with 7 generators.
244 #I Class 4 with 10 generators.
245 #I Class 5 with 12 generators.
246 #I Class 5 with 12 generators.
247 &lt;pc group of size 4096 with 12 generators&gt;
248 #I Variables used in `PqExample' are saved in `ANUPQData.example.vars'.
249 <span class="GAPprompt">gap&gt;</span> <span class="GAPinput">time; </span>
250 1400
251 </pre></div>
252
253 <p>Note that the <code class="code">time</code> statement gives the time in milliseconds spent by <strong class="pkg">GAP</strong> in executing the <code class="code">PqExample("B2-4-Id");</code> command (i.e. everything up to the <code class="code">Info</code>-ing of the variables used), but over 90% of that time is spent in the final <code class="code">Pq</code> statement. The time spent by the <code class="code">pq</code> program, which is negligible anyway (you can check this by running the example while the <code class="code">InfoANUPQ</code> level is set to 2), is not counted by <code class="code">time</code>.</p>
254
255 <p>Since the identity used in the above construction of <span class="SimpleMath">B(2, 4)</span> is just an exponent law, the <q>right</q> way to compute it is via the <code class="code">Exponent</code> option (see <a href="chap6.html#X87EE6DD67C9996A3"><span class="RefLink">6.2</span></a>), which is implemented at the C level and <em>is</em> highly optimised. Consequently, the <code class="code">Exponent</code> option is significantly faster, generally by several orders of magnitude:</p>
256
257
258 <div class="example"><pre>
259 <span class="GAPprompt">gap&gt;</span> <span class="GAPinput">SetInfoLevel(InfoANUPQ, 2); # to see time spent by the `pq' program</span>
260 <span class="GAPprompt">gap&gt;</span> <span class="GAPinput">PqExample("B2-4");</span>
261 #I #Example: "B2-4" . . . the ``right'' way to generate B(2, 4)
262 #I #Generates B(2, 4) by using the `Exponent' option
263 #I F, procId are local to `PqExample'
264 <span class="GAPprompt">gap&gt;</span> <span class="GAPinput">F := FreeGroup("a", "b");</span>
265 &lt;free group on the generators [ a, b ]&gt;
266 <span class="GAPprompt">gap&gt;</span> <span class="GAPinput">Pq( F : Prime := 2, Exponent := 4 );</span>
267 #I Computation of presentation took 0.00 seconds
268 &lt;pc group of size 4096 with 12 generators&gt;
269 #I Variables used in `PqExample' are saved in `ANUPQData.example.vars'.
270 <span class="GAPprompt">gap&gt;</span> <span class="GAPinput">time; # time spent by GAP in executing `PqExample("B2-4");' </span>
271 50
272 </pre></div>
273
274 <p>The following example uses the <code class="code">Identities</code> option to compute a 3-Engel group for the prime 11. As is the case for the example <code class="code">"B2-4-Id"</code>, the example has both a non-interactive and an interactive form; below, we demonstrate the interactive form.</p>
275
276
277 <div class="example"><pre>
278 <span class="GAPprompt">gap&gt;</span> <span class="GAPinput">SetInfoLevel(InfoANUPQ, 1); # reset InfoANUPQ to default level</span>
279 <span class="GAPprompt">gap&gt;</span> <span class="GAPinput">PqExample("11gp-3-Engel-Id", PqStart);</span>
280 #I #Example: "11gp-3-Engel-Id" . . . 3-Engel group for prime 11
281 #I #Non-trivial example of using the `Identities' option
282 #I F, a, b, G, f, procId, Q are local to `PqExample'
283 <span class="GAPprompt">gap&gt;</span> <span class="GAPinput">F := FreeGroup("a", "b"); a := F.1; b := F.2;</span>
284 &lt;free group on the generators [ a, b ]&gt;
285 a
286 b
287 <span class="GAPprompt">gap&gt;</span> <span class="GAPinput">G := F/[ a^11, b^11 ];</span>
288 &lt;fp group on the generators [ a, b ]&gt;
289 <span class="GAPprompt">gap&gt;</span> <span class="GAPinput"># All word pairs u, v in the pc generators of the 11-quotient Q of G </span>
290 <span class="GAPprompt">gap&gt;</span> <span class="GAPinput"># must satisfy the Engel identity: [u, v, v, v] = 1.</span>
291 <span class="GAPprompt">gap&gt;</span> <span class="GAPinput">f := function(u, v) return PqLeftNormComm( [u, v, v, v] ); end;</span>
292 function( u, v ) ... end
293 <span class="GAPprompt">gap&gt;</span> <span class="GAPinput">procId := PqStart( G );;</span>
294 <span class="GAPprompt">gap&gt;</span> <span class="GAPinput">Q := Pq( procId : Prime := 11, Identities := [ f ] );</span>
295 #I Class 1 with 2 generators.
296 #I Class 2 with 3 generators.
297 #I Class 3 with 5 generators.
298 #I Class 3 with 5 generators.
299 &lt;pc group of size 161051 with 5 generators&gt;
300 <span class="GAPprompt">gap&gt;</span> <span class="GAPinput"># We do a ``sample'' check that pairs of elements of Q do satisfy</span>
301 <span class="GAPprompt">gap&gt;</span> <span class="GAPinput"># the given identity:</span>
302 <span class="GAPprompt">gap&gt;</span> <span class="GAPinput">f( Random(Q), Random(Q) );</span>
303 &lt;identity&gt; of ...
304 <span class="GAPprompt">gap&gt;</span> <span class="GAPinput">f( Q.1, Q.2 );</span>
305 &lt;identity&gt; of ...
306 #I Variables used in `PqExample' are saved in `ANUPQData.example.vars'.
307 </pre></div>
308
309 <p>The (interactive) call to <code class="code">Pq</code> above is essentially equivalent to a call to <code class="code">PqPcPresentation</code> with the same arguments and options followed by a call to <code class="code">PqCurrentGroup</code>. Moreover, the call to <code class="code">PqPcPresentation</code> (as described in <code class="func">PqPcPresentation</code> (<a href="chap5.html#X7BF135DD84A781EB"><span class="RefLink">5.6-1</span></a>)) is equivalent to a <q>class 1</q> call to <code class="code">PqPcPresentation</code> followed by the requisite number of calls to <code class="code">PqNextClass</code>, and with the <code class="code">Identities</code> option set, both <code class="code">PqPcPresentation</code> and <code class="code">PqNextClass</code> <q>quietly</q> perform the equivalent of a <code class="code">PqEvaluateIdentities</code> call. In the following example we break down the <code class="code">Pq</code> call into its low-level equivalents, and set and unset the <code class="code">Identities</code> option to show where <code class="code">PqEvaluateIdentities</code> fits into this scheme.</p>
310
311
312 <div class="example"><pre>
313 <span class="GAPprompt">gap&gt;</span> <span class="GAPinput">PqExample("11gp-3-Engel-Id-i");</span>
314 #I #Example: "11gp-3-Engel-Id-i" . . . 3-Engel grp for prime 11
315 #I #Variation of "11gp-3-Engel-Id" broken down into its lower-level component
316 #I #command parts.
317 #I F, a, b, G, f, procId, Q are local to `PqExample'
318 <span class="GAPprompt">gap&gt;</span> <span class="GAPinput">F := FreeGroup("a", "b"); a := F.1; b := F.2;</span>
319 &lt;free group on the generators [ a, b ]&gt;
320 a
321 b
322 <span class="GAPprompt">gap&gt;</span> <span class="GAPinput">G := F/[ a^11, b^11 ];</span>
323 &lt;fp group on the generators [ a, b ]&gt;
324 <span class="GAPprompt">gap&gt;</span> <span class="GAPinput"># All word pairs u, v in the pc generators of the 11-quotient Q of G </span>
325 <span class="GAPprompt">gap&gt;</span> <span class="GAPinput"># must satisfy the Engel identity: [u, v, v, v] = 1.</span>
326 <span class="GAPprompt">gap&gt;</span> <span class="GAPinput">f := function(u, v) return PqLeftNormComm( [u, v, v, v] ); end;</span>
327 function( u, v ) ... end
328 <span class="GAPprompt">gap&gt;</span> <span class="GAPinput">procId := PqStart( G : Prime := 11 );;</span>
329 <span class="GAPprompt">gap&gt;</span> <span class="GAPinput">PqPcPresentation( procId : ClassBound := 1);</span>
330 <span class="GAPprompt">gap&gt;</span> <span class="GAPinput">PqEvaluateIdentities( procId : Identities := [f] );</span>
331 #I Class 1 with 2 generators.
332 <span class="GAPprompt">gap&gt;</span> <span class="GAPinput">for c in [2 .. 4] do</span>
333 <span class="GAPprompt">&gt;</span> <span class="GAPinput"> PqNextClass( procId : Identities := [] ); #reset `Identities' option</span>
334 <span class="GAPprompt">&gt;</span> <span class="GAPinput"> PqEvaluateIdentities( procId : Identities := [f] );</span>
335 <span class="GAPprompt">&gt;</span> <span class="GAPinput"> od;</span>
336 #I Class 2 with 3 generators.
337 #I Class 3 with 5 generators.
338 #I Class 3 with 5 generators.
339 <span class="GAPprompt">gap&gt;</span> <span class="GAPinput">Q := PqCurrentGroup( procId );</span>
340 &lt;pc group of size 161051 with 5 generators&gt;
341 <span class="GAPprompt">gap&gt;</span> <span class="GAPinput"># We do a ``sample'' check that pairs of elements of Q do satisfy</span>
342 <span class="GAPprompt">gap&gt;</span> <span class="GAPinput"># the given identity:</span>
343 <span class="GAPprompt">gap&gt;</span> <span class="GAPinput">f( Random(Q), Random(Q) );</span>
344 &lt;identity&gt; of ...
345 <span class="GAPprompt">gap&gt;</span> <span class="GAPinput">f( Q.1, Q.2 );</span>
346 &lt;identity&gt; of ...
347 #I Variables used in `PqExample' are saved in `ANUPQData.example.vars'.
348 </pre></div>
349
350 <p><a id="X7A997D1A8532A84B" name="X7A997D1A8532A84B"></a></p>
351
352 <h4>A.3 <span class="Heading">A Large Example</span></h4>
353
354 <p>An example demonstrating how a large computation can be organised with the <strong class="pkg">ANUPQ</strong> package is the computation of the Burnside group <span class="SimpleMath">B(5, 4)</span>, the largest group of exponent 4 generated by 5 elements. It has order <span class="SimpleMath">2^2728</span> and lower exponent-<span class="SimpleMath">p</span> central class 13. The example <code class="code">"B5-4.g"</code> computes <span class="SimpleMath">B(5, 4)</span>; it is based on a <code class="code">pq</code> standalone input file written by M. F. Newman.</p>
355
356 <p>To be able to do examples like this was part of the motivation to provide access to the low-level functions of the standalone program from within <strong class="pkg">GAP</strong>.</p>
357
358 <p>Please note that the construction uses the knowledge gained by Newman and O'Brien in their initial construction of <span class="SimpleMath">B(5, 4)</span>, in particular, insight into the commutator structure of the group and the knowledge of the <span class="SimpleMath">p</span>-central class and the order of <span class="SimpleMath">B(5, 4)</span>. Therefore, the construction cannot be used to prove that <span class="SimpleMath">B(5, 4)</span> has the order and class mentioned above. It is merely a reconstruction of the group. More information is contained in the header of the file <code class="code">examples/B5-4.g</code>.</p>
359
360
361 <div class="example"><pre>
362 procId := PqStart( FreeGroup(5) : Exponent := 4, Prime := 2 );
363 Pq( procId : ClassBound := 2 );
364 PqSupplyAutomorphisms( procId,
365 [
366 [ [ 1, 1, 0, 0, 0], # first automorphism
367 [ 0, 1, 0, 0, 0],
368 [ 0, 0, 1, 0, 0],
369 [ 0, 0, 0, 1, 0],
370 [ 0, 0, 0, 0, 1] ],
371
372 [ [ 0, 0, 0, 0, 1], # second automorphism
373 [ 1, 0, 0, 0, 0],
374 [ 0, 1, 0, 0, 0],
375 [ 0, 0, 1, 0, 0],
376 [ 0, 0, 0, 1, 0] ]
377 ] );;
378
379 Relations :=
380 [ [], ## class 1
381 [], ## class 2
382 [], ## class 3
383 [], ## class 4
384 [], ## class 5
385 [], ## class 6
386 ## class 7
387 [ [ "x2","x1","x1","x3","x4","x4","x4" ] ],
388 ## class 8
389 [ [ "x2","x1","x1","x3","x4","x5","x5","x5" ] ],
390 ## class 9
391 [ [ "x2","x1","x1","x3","x4","x4","x5","x5","x5" ],
392 [ "x2","x1","x1","x2","x3","x4","x5","x5","x5" ],
393 [ "x2","x1","x1","x3","x3","x4","x5","x5","x5" ] ],
394 ## class 10
395 [ [ "x2","x1","x1","x2","x3","x3","x4","x5","x5","x5" ],
396 [ "x2","x1","x1","x3","x3","x4","x4","x5","x5","x5" ] ],
397 ## class 11
398 [ [ "x2","x1","x1","x2","x3","x3","x4","x4","x5","x5","x5" ],
399 [ "x2","x1","x1","x2","x3","x1","x3","x4","x2","x4","x3" ] ],
400 ## class 12
401 [ [ "x2","x1","x1","x2","x3","x1","x3","x4","x2","x5","x5","x5" ],
402 [ "x2","x1","x1","x3","x2","x4","x3","x5","x4","x5","x5","x5" ] ],
403 ## class 13
404 [ [ "x2","x1","x1","x2","x3","x1","x3","x4","x2","x4","x5","x5","x5"
405 ] ]
406 ];
407
408 for class in [ 3 .. 13 ] do
409 Print( "Computing class ", class, "\n" );
410 PqSetupTablesForNextClass( procId );
411
412 for w in [ class, class-1 .. 7 ] do
413
414 PqAddTails( procId, w );
415 PqDisplayPcPresentation( procId );
416
417 if Relations[ w ] &lt;&gt; [] then
418 # recalculate automorphisms
419 PqExtendAutomorphisms( procId );
420
421 for r in Relations[ w ] do
422 Print( "Collecting ", r, "\n" );
423 PqCommutator( procId, r, 1 );
424 PqEchelonise( procId );
425 PqApplyAutomorphisms( procId, 15 ); #queue factor = 15
426 od;
427
428 PqEliminateRedundantGenerators( procId );
429 fi;
430 PqComputeTails( procId, w );
431 od;
432 PqDisplayPcPresentation( procId );
433
434 smallclass := Minimum( class, 6 );
435 for w in [ smallclass, smallclass-1 .. 2 ] do
436 PqTails( procId, w );
437 od;
438 # recalculate automorphisms
439 PqExtendAutomorphisms( procId );
440 PqCollect( procId, "x5^4" );
441 PqEchelonise( procId );
442 PqApplyAutomorphisms( procId, 15 ); #queue factor = 15
443 PqEliminateRedundantGenerators( procId );
444 PqDisplayPcPresentation( procId );
445 od;
446 </pre></div>
447
448 <p><a id="X7FB6DA8D7BB90D8C" name="X7FB6DA8D7BB90D8C"></a></p>
449
450 <h4>A.4 <span class="Heading">Developing descendants trees</span></h4>
451
452 <p>In the following example we will explore the 3-groups of rank 2 and 3-coclass 1 up to 3-class 5. This will be done using the <span class="SimpleMath">p</span>-group generation machinery of the package. We start with the elementary abelian 3-group of rank 2. From within <strong class="pkg">GAP</strong>, run the example <code class="code">"PqDescendants-treetraverse-i"</code> via <code class="code">PqExample</code> (see <code class="func">PqExample</code> (<a href="chap3.html#X7BB0EB607F337265"><span class="RefLink">3.4-4</span></a>)).</p>
453
454
455 <div class="example"><pre>
456 <span class="GAPprompt">gap&gt;</span> <span class="GAPinput">G := ElementaryAbelianGroup( 9 );</span>
457 &lt;pc group of size 9 with 2 generators&gt;
458 <span class="GAPprompt">gap&gt;</span> <span class="GAPinput">procId := PqStart( G );;</span>
459 <span class="GAPprompt">gap&gt;</span> <span class="GAPinput">#</span>
460 <span class="GAPprompt">gap&gt;</span> <span class="GAPinput"># Below, we use the option StepSize in order to construct descendants</span>
461 <span class="GAPprompt">gap&gt;</span> <span class="GAPinput"># of coclass 1. This is equivalent to setting the StepSize to 1 in</span>
462 <span class="GAPprompt">gap&gt;</span> <span class="GAPinput"># each descendant calculation.</span>
463 <span class="GAPprompt">gap&gt;</span> <span class="GAPinput">#</span>
464 <span class="GAPprompt">gap&gt;</span> <span class="GAPinput"># The elementary abelian group of order 9 has 3 descendants of</span>
465 <span class="GAPprompt">gap&gt;</span> <span class="GAPinput"># 3-class 2 and 3-coclass 1, as the result of the next command</span>
466 <span class="GAPprompt">gap&gt;</span> <span class="GAPinput"># shows. </span>
467 <span class="GAPprompt">gap&gt;</span> <span class="GAPinput">#</span>
468 <span class="GAPprompt">gap&gt;</span> <span class="GAPinput">PqDescendants( procId : StepSize := 1 );</span>
469 [ &lt;pc group of size 27 with 3 generators&gt;,
470 &lt;pc group of size 27 with 3 generators&gt;,
471 &lt;pc group of size 27 with 3 generators&gt; ]
472 <span class="GAPprompt">gap&gt;</span> <span class="GAPinput">#</span>
473 <span class="GAPprompt">gap&gt;</span> <span class="GAPinput"># Now we will compute the descendants of coclass 1 for each of the</span>
474 <span class="GAPprompt">gap&gt;</span> <span class="GAPinput"># groups above. Then we will compute the descendants of coclass 1</span>
475 <span class="GAPprompt">gap&gt;</span> <span class="GAPinput"># of each descendant and so on. Note that the pq program keeps</span>
476 <span class="GAPprompt">gap&gt;</span> <span class="GAPinput"># one file for each class at a time. For example, the descendants</span>
477 <span class="GAPprompt">gap&gt;</span> <span class="GAPinput"># calculation for the second group of class 2 overwrites the</span>
478 <span class="GAPprompt">gap&gt;</span> <span class="GAPinput"># descendant file obtained from the first group of class 2.</span>
479 <span class="GAPprompt">gap&gt;</span> <span class="GAPinput"># Hence, we have to traverse the descendants tree in depth first</span>
480 <span class="GAPprompt">gap&gt;</span> <span class="GAPinput"># order.</span>
481 <span class="GAPprompt">gap&gt;</span> <span class="GAPinput">#</span>
482 <span class="GAPprompt">gap&gt;</span> <span class="GAPinput">PqPGSetDescendantToPcp( procId, 2, 1 );</span>
483 <span class="GAPprompt">gap&gt;</span> <span class="GAPinput">PqPGExtendAutomorphisms( procId );</span>
484 <span class="GAPprompt">gap&gt;</span> <span class="GAPinput">PqPGConstructDescendants( procId : StepSize := 1 );</span>
485 2
486 <span class="GAPprompt">gap&gt;</span> <span class="GAPinput">PqPGSetDescendantToPcp( procId, 3, 1 );</span>
487 <span class="GAPprompt">gap&gt;</span> <span class="GAPinput">PqPGExtendAutomorphisms( procId );</span>
488 <span class="GAPprompt">gap&gt;</span> <span class="GAPinput">PqPGConstructDescendants( procId : StepSize := 1 );</span>
489 2
490 <span class="GAPprompt">gap&gt;</span> <span class="GAPinput">PqPGSetDescendantToPcp( procId, 4, 1 );</span>
491 <span class="GAPprompt">gap&gt;</span> <span class="GAPinput">PqPGExtendAutomorphisms( procId );</span>
492 <span class="GAPprompt">gap&gt;</span> <span class="GAPinput">PqPGConstructDescendants( procId : StepSize := 1 );</span>
493 2
494 <span class="GAPprompt">gap&gt;</span> <span class="GAPinput">#</span>
495 <span class="GAPprompt">gap&gt;</span> <span class="GAPinput"># At this point we stop traversing the ``left most'' branch of the</span>
496 <span class="GAPprompt">gap&gt;</span> <span class="GAPinput"># descendants tree and move upwards.</span>
497 <span class="GAPprompt">gap&gt;</span> <span class="GAPinput">#</span>
498 <span class="GAPprompt">gap&gt;</span> <span class="GAPinput">PqPGSetDescendantToPcp( procId, 4, 2 );</span>
499 <span class="GAPprompt">gap&gt;</span> <span class="GAPinput">PqPGExtendAutomorphisms( procId );</span>
500 <span class="GAPprompt">gap&gt;</span> <span class="GAPinput">PqPGConstructDescendants( procId : StepSize := 1 );</span>
501 #I group restored from file is incapable
502 0
503 <span class="GAPprompt">gap&gt;</span> <span class="GAPinput">PqPGSetDescendantToPcp( procId, 3, 2 );</span>
504 <span class="GAPprompt">gap&gt;</span> <span class="GAPinput">PqPGExtendAutomorphisms( procId );</span>
505 <span class="GAPprompt">gap&gt;</span> <span class="GAPinput">PqPGConstructDescendants( procId : StepSize := 1 );</span>
506 #I group restored from file is incapable
507 0
508 <span class="GAPprompt">gap&gt;</span> <span class="GAPinput"># </span>
509 <span class="GAPprompt">gap&gt;</span> <span class="GAPinput"># The computations above indicate that the descendants subtree under</span>
510 <span class="GAPprompt">gap&gt;</span> <span class="GAPinput"># the first descendant of the elementary abelian group of order 9</span>
511 <span class="GAPprompt">gap&gt;</span> <span class="GAPinput"># will have only one path of infinite length.</span>
512 <span class="GAPprompt">gap&gt;</span> <span class="GAPinput">#</span>
513 <span class="GAPprompt">gap&gt;</span> <span class="GAPinput">PqPGSetDescendantToPcp( procId, 2, 2 );</span>
514 <span class="GAPprompt">gap&gt;</span> <span class="GAPinput">PqPGExtendAutomorphisms( procId );</span>
515 <span class="GAPprompt">gap&gt;</span> <span class="GAPinput">PqPGConstructDescendants( procId : StepSize := 1 );</span>
516 4
517 <span class="GAPprompt">gap&gt;</span> <span class="GAPinput">#</span>
518 <span class="GAPprompt">gap&gt;</span> <span class="GAPinput"># We get four descendants here, three of which will turn out to be</span>
519 <span class="GAPprompt">gap&gt;</span> <span class="GAPinput"># incapable, i.e., they have no descendants and are terminal nodes</span>
520 <span class="GAPprompt">gap&gt;</span> <span class="GAPinput"># in the descendants tree.</span>
521 <span class="GAPprompt">gap&gt;</span> <span class="GAPinput">#</span>
522 <span class="GAPprompt">gap&gt;</span> <span class="GAPinput">PqPGSetDescendantToPcp( procId, 2, 3 );</span>
523 <span class="GAPprompt">gap&gt;</span> <span class="GAPinput">PqPGExtendAutomorphisms( procId );</span>
524 <span class="GAPprompt">gap&gt;</span> <span class="GAPinput">PqPGConstructDescendants( procId : StepSize := 1 );</span>
525 #I group restored from file is incapable
526 0
527 <span class="GAPprompt">gap&gt;</span> <span class="GAPinput">#</span>
528 <span class="GAPprompt">gap&gt;</span> <span class="GAPinput"># The third descendant of class three is incapable. Let us return</span>
529 <span class="GAPprompt">gap&gt;</span> <span class="GAPinput"># to the second descendant of class 2.</span>
530 <span class="GAPprompt">gap&gt;</span> <span class="GAPinput">#</span>
531 <span class="GAPprompt">gap&gt;</span> <span class="GAPinput">PqPGSetDescendantToPcp( procId, 2, 2 );</span>
532 <span class="GAPprompt">gap&gt;</span> <span class="GAPinput">PqPGExtendAutomorphisms( procId );</span>
533 <span class="GAPprompt">gap&gt;</span> <span class="GAPinput">PqPGConstructDescendants( procId : StepSize := 1 );</span>
534 4
535 <span class="GAPprompt">gap&gt;</span> <span class="GAPinput">PqPGSetDescendantToPcp( procId, 3, 1 );</span>
536 <span class="GAPprompt">gap&gt;</span> <span class="GAPinput">PqPGExtendAutomorphisms( procId );</span>
537 <span class="GAPprompt">gap&gt;</span> <span class="GAPinput">PqPGConstructDescendants( procId : StepSize := 1 );</span>
538 #I group restored from file is incapable
539 0
540 <span class="GAPprompt">gap&gt;</span> <span class="GAPinput">PqPGSetDescendantToPcp( procId, 3, 2 );</span>
541 <span class="GAPprompt">gap&gt;</span> <span class="GAPinput">PqPGExtendAutomorphisms( procId );</span>
542 <span class="GAPprompt">gap&gt;</span> <span class="GAPinput">PqPGConstructDescendants( procId : StepSize := 1 );</span>
543 #I group restored from file is incapable
544 0
545 <span class="GAPprompt">gap&gt;</span> <span class="GAPinput">#</span>
546 <span class="GAPprompt">gap&gt;</span> <span class="GAPinput"># We skip the third descendant for the moment ... </span>
547 <span class="GAPprompt">gap&gt;</span> <span class="GAPinput">#</span>
548 <span class="GAPprompt">gap&gt;</span> <span class="GAPinput">PqPGSetDescendantToPcp( procId, 3, 4 );</span>
549 <span class="GAPprompt">gap&gt;</span> <span class="GAPinput">PqPGExtendAutomorphisms( procId );</span>
550 <span class="GAPprompt">gap&gt;</span> <span class="GAPinput">PqPGConstructDescendants( procId : StepSize := 1 );</span>
551 #I group restored from file is incapable
552 0
553 <span class="GAPprompt">gap&gt;</span> <span class="GAPinput">#</span>
554 <span class="GAPprompt">gap&gt;</span> <span class="GAPinput"># ... and look at it now.</span>
555 <span class="GAPprompt">gap&gt;</span> <span class="GAPinput">#</span>
556 <span class="GAPprompt">gap&gt;</span> <span class="GAPinput">PqPGSetDescendantToPcp( procId, 3, 3 );</span>
557 <span class="GAPprompt">gap&gt;</span> <span class="GAPinput">PqPGExtendAutomorphisms( procId );</span>
558 <span class="GAPprompt">gap&gt;</span> <span class="GAPinput">PqPGConstructDescendants( procId : StepSize := 1 );</span>
559 6
560 <span class="GAPprompt">gap&gt;</span> <span class="GAPinput">#</span>
561 <span class="GAPprompt">gap&gt;</span> <span class="GAPinput"># In this branch of the descendant tree we get 6 descendants of class</span>
562 <span class="GAPprompt">gap&gt;</span> <span class="GAPinput"># three. Of those 5 will turn out to be incapable and one will have</span>
563 <span class="GAPprompt">gap&gt;</span> <span class="GAPinput"># 7 descendants.</span>
564 <span class="GAPprompt">gap&gt;</span> <span class="GAPinput">#</span>
565 <span class="GAPprompt">gap&gt;</span> <span class="GAPinput">PqPGSetDescendantToPcp( procId, 4, 1 );</span>
566 <span class="GAPprompt">gap&gt;</span> <span class="GAPinput">PqPGExtendAutomorphisms( procId );</span>
567 <span class="GAPprompt">gap&gt;</span> <span class="GAPinput">PqPGConstructDescendants( procId : StepSize := 1 );</span>
568 #I group restored from file is incapable
569 0
570 <span class="GAPprompt">gap&gt;</span> <span class="GAPinput">PqPGSetDescendantToPcp( procId, 4, 2 );</span>
571 <span class="GAPprompt">gap&gt;</span> <span class="GAPinput">PqPGExtendAutomorphisms( procId );</span>
572 <span class="GAPprompt">gap&gt;</span> <span class="GAPinput">PqPGConstructDescendants( procId : StepSize := 1 );</span>
573 7
574 <span class="GAPprompt">gap&gt;</span> <span class="GAPinput">PqPGSetDescendantToPcp( procId, 4, 3 );</span>
575 <span class="GAPprompt">gap&gt;</span> <span class="GAPinput">PqPGExtendAutomorphisms( procId );</span>
576 <span class="GAPprompt">gap&gt;</span> <span class="GAPinput">PqPGConstructDescendants( procId : StepSize := 1 );</span>
577 #I group restored from file is incapable
578 0
579 </pre></div>
580
581 <p>To automate the above procedure to some extent we provide:</p>
582
583 <p><a id="X805E6B418193CF2D" name="X805E6B418193CF2D"></a></p>
584
585 <h5>A.4-1 PqDescendantsTreeCoclassOne</h5>
586
587 <div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">&#8227; PqDescendantsTreeCoclassOne</code>( <var class="Arg">i</var> )</td><td class="tdright">(&nbsp;function&nbsp;)</td></tr></table></div>
588 <div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">&#8227; PqDescendantsTreeCoclassOne</code>( )</td><td class="tdright">(&nbsp;function&nbsp;)</td></tr></table></div>
589 <p>for the <var class="Arg">i</var>th or default interactive <strong class="pkg">ANUPQ</strong> process, generate a descendant tree for the group of the process (which must be a pc <span class="SimpleMath">p</span>-group) consisting of descendants of <span class="SimpleMath">p</span>-coclass 1 and extending to the class determined by the option <code class="code">TreeDepth</code> (or 6 if the option is omitted). In an <strong class="pkg">XGAP</strong> session, a graphical representation of the descendants tree appears in a separate window. Subsequent calls to <code class="code">PqDescendantsTreeCoclassOne</code> for the same process may be used to extend the descendant tree from the last descendant computed that itself has more than one descendant. <code class="code">PqDescendantsTreeCoclassOne</code> also accepts the options <code class="code">CapableDescendants</code> (or <code class="code">AllDescendants</code>) and any options accepted by the interactive <code class="code">PqDescendants</code> function (see <code class="func">PqDescendants</code> (<a href="chap5.html#X795817217C53AB89"><span class="RefLink">5.3-6</span></a>)).</p>
590
591 <p><em>Notes</em></p>
592
593 <ol>
594 <li><p><code class="code">PqDescendantsTreeCoclassOne</code> first calls <code class="code">PqDescendants</code>. If <code class="code">PqDescendants</code> has already been called for the process, the previous value computed is used and a warning is <code class="code">Info</code>-ed at <code class="code">InfoANUPQ</code> level 1.</p>
595
596 </li>
597 <li><p>As each descendant is processed its unique label defined by the <code class="code">pq</code> program and number of descendants is <code class="code">Info</code>-ed at <code class="code">InfoANUPQ</code> level 1.</p>
598
599 </li>
600 <li><p><code class="code">PqDescendantsTreeCoclassOne</code> is an <q>experimental</q> function that is included to demonstrate the sort of things that are possible with the <span class="SimpleMath">p</span>-group generation machinery.</p>
601
602 </li>
603 </ol>
604 <p>Ignoring the extra functionality provided in an <strong class="pkg">XGAP</strong> session, <code class="code">PqDescendantsTreeCoclassOne</code>, with one argument that is the index of an interactive <strong class="pkg">ANUPQ</strong> process, is approximately equivalent to:</p>
605
606
607 <div class="example"><pre>
608 PqDescendantsTreeCoclassOne := function( procId )
609 local des, i;
610
611 des := PqDescendants( procId : StepSize := 1 );
612 RecurseDescendants( procId, 2, Length(des) );
613 end;
614 </pre></div>
615
616 <p>where <code class="code">RecurseDescendants</code> is (approximately) defined as follows:</p>
617
618
619 <div class="example"><pre>
620 RecurseDescendants := function( procId, class, n )
621 local i, nr;
622
623 if class &gt; ValueOption("TreeDepth") then return; fi;
624
625 for i in [1..n] do
626 PqPGSetDescendantToPcp( procId, class, i );
627 PqPGExtendAutomorphisms( procId );
628 nr := PqPGConstructDescendants( procId : StepSize := 1 );
629 Print( "Number of descendants of group ", i,
630 " at class ", class, ": ", nr, "\n" );
631 RecurseDescendants( procId, class+1, nr );
632 od;
633 return;
634 end;
635 </pre></div>
636
637 <p>The following examples (executed via <code class="code">PqExample</code>; see <code class="func">PqExample</code> (<a href="chap3.html#X7BB0EB607F337265"><span class="RefLink">3.4-4</span></a>)), demonstrate the use of <code class="code">PqDescendantsTreeCoclassOne</code>:</p>
638
639
640 <dl>
641 <dt><strong class="Mark"><code class="code">"PqDescendantsTreeCoclassOne-9-i"</code></strong></dt>
642 <dd><p>approximately does example <code class="code">"PqDescendants-treetraverse-i"</code> again using <code class="code">PqDescendantsTreeCoclassOne</code>;</p>
643
644 </dd>
645 <dt><strong class="Mark"><code class="code">"PqDescendantsTreeCoclassOne-16-i"</code></strong></dt>
646 <dd><p>uses the option <code class="code">CapableDescendants</code>; and</p>
647
648 </dd>
649 <dt><strong class="Mark"><code class="code">"PqDescendantsTreeCoclassOne-25-i"</code></strong></dt>
650 <dd><p>calculates all descendants by omitting the <code class="code">CapableDescendants</code> option.</p>
651
652 </dd>
653 </dl>
654 <p>The numbers <code class="code">9</code>, <code class="code">16</code> and <code class="code">25</code> respectively, indicate the order of the elementary abelian group to which <code class="code">PqDescendantsTreeCoclassOne</code> is applied for these examples.</p>
655
656
657 <div class="chlinkprevnextbot">&nbsp;<a href="chap0.html">[Top of Book]</a>&nbsp; <a href="chap0.html#contents">[Contents]</a>&nbsp; &nbsp;<a href="chap7.html">[Previous Chapter]</a>&nbsp; &nbsp;<a href="chapBib.html">[Next Chapter]</a>&nbsp; </div>
658
659
660 <div class="chlinkbot"><span class="chlink1">Goto Chapter: </span><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>
661
662 <hr />
663 <p class="foot">generated by <a href="https://www.math.rwth-aachen.de/~Frank.Luebeck/GAPDoc">GAPDoc2HTML</a></p>
664 </body>
665 </html>