Debian Codegraph @

doc/chapA_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) - Appendix A: Examples</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="chapA" 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="chap7_mj.html">[Previous Chapter]</a>&nbsp; &nbsp;<a href="chapBib_mj.html">[Next Chapter]</a>&nbsp; </div>
24
25 <p id="mathjaxlink" class="pcenter"><a href="chapA.html">[MathJax off]</a></p>
26 <p><a id="X7A489A5D79DA9E5C" name="X7A489A5D79DA9E5C"></a></p>
27 <div class="ChapSects"><a href="chapA_mj.html#X7A489A5D79DA9E5C">A <span class="Heading">Examples</span></a>
28 <div class="ContSect"><span class="tocline"><span class="nocss">&nbsp;</span><a href="chapA_mj.html#X80676E317BF4DF13">A.1 <span class="Heading">The Relators Option</span></a>
29 </span>
30 </div>
31 <div class="ContSect"><span class="tocline"><span class="nocss">&nbsp;</span><a href="chapA_mj.html#X80B2AA7084C57F5D">A.2 <span class="Heading">The Identities Option and PqEvaluateIdentities Function</span></a>
32 </span>
33 </div>
34 <div class="ContSect"><span class="tocline"><span class="nocss">&nbsp;</span><a href="chapA_mj.html#X7A997D1A8532A84B">A.3 <span class="Heading">A Large Example</span></a>
35 </span>
36 </div>
37 <div class="ContSect"><span class="tocline"><span class="nocss">&nbsp;</span><a href="chapA_mj.html#X7FB6DA8D7BB90D8C">A.4 <span class="Heading">Developing descendants trees</span></a>
38 </span>
39 <div class="ContSSBlock">
40 <span class="ContSS"><br /><span class="nocss">&nbsp;&nbsp;</span><a href="chapA_mj.html#X805E6B418193CF2D">A.4-1 PqDescendantsTreeCoclassOne</a></span>
41 </div></div>
42 </div>
43
44 <h3>A <span class="Heading">Examples</span></h3>
45
46 <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_mj.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>
47
48 <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>
49
50
51 <div class="example"><pre>
52 <span class="GAPprompt">gap&gt;</span> <span class="GAPinput">PqExample();</span>
53 #I PqExample Index (Table of Contents)
54 #I -----------------------------------
55 #I This table of possible examples is displayed when calling `PqExample'
56 #I with no arguments, or with the argument: "index" (meant in the sense
57 #I of ``list''), or with a non-existent example name.
58 #I
59 #I Examples that have a name ending in `-ni' are non-interactive only.
60 #I Examples that have a name ending in `-i' are interactive only.
61 #I Examples with names ending in `.g' also have only one form. Other
62 #I examples have both a non-interactive and an interactive form; call
63 #I `PqExample' with 2nd argument `PqStart' to get the interactive form
64 #I of the example. The substring `PG' in an example name indicates a
65 #I p-Group Generation example, `SP' indicates a Standard Presentation
66 #I example, `Rel' indicates it uses the `Relators' option, and `Id'
67 #I indicates it uses the `Identities' option.
68 #I
69 #I The following ANUPQ examples are available:
70 #I
71 #I p-Quotient examples:
72 #I general:
73 #I "Pq" "Pq-ni" "PqEpimorphism"
74 #I "PqPCover" "PqSupplementInnerAutomorphisms"
75 #I 2-groups:
76 #I "2gp-Rel" "2gp-Rel-i" "2gp-a-Rel-i"
77 #I "B2-4" "B2-4-Id" "B2-8-i"
78 #I "B4-4-i" "B4-4-a-i" "B5-4.g"
79 #I 3-groups:
80 #I "3gp-Rel-i" "3gp-a-Rel" "3gp-a-Rel-i"
81 #I "3gp-a-x-Rel-i" "3gp-maxoccur-Rel-i"
82 #I 5-groups:
83 #I "5gp-Rel-i" "5gp-a-Rel-i" "5gp-b-Rel-i"
84 #I "5gp-c-Rel-i" "5gp-metabelian-Rel-i" "5gp-maxoccur-Rel-i"
85 #I "F2-5-i" "B2-5-i" "R2-5-i"
86 #I "R2-5-x-i" "B5-5-Engel3-Id"
87 #I 7-groups:
88 #I "7gp-Rel-i"
89 #I 11-groups:
90 #I "11gp-i" "11gp-Rel-i" "11gp-a-Rel-i"
91 #I "11gp-3-Engel-Id" "11gp-3-Engel-Id-i"
92 #I
93 #I p-Group Generation examples:
94 #I general:
95 #I "PqDescendants-1" "PqDescendants-2" "PqDescendants-3"
96 #I "PqDescendants-1-i"
97 #I 2-groups:
98 #I "2gp-PG-i" "2gp-PG-2-i" "2gp-PG-3-i"
99 #I "2gp-PG-4-i" "2gp-PG-e4-i"
100 #I "PqDescendantsTreeCoclassOne-16-i"
101 #I 3-groups:
102 #I "3gp-PG-i" "3gp-PG-4-i" "3gp-PG-x-i"
103 #I "3gp-PG-x-1-i" "PqDescendants-treetraverse-i"
104 #I "PqDescendantsTreeCoclassOne-9-i"
105 #I 5-groups:
106 #I "5gp-PG-i" "Nott-PG-Rel-i" "Nott-APG-Rel-i"
107 #I "PqDescendantsTreeCoclassOne-25-i"
108 #I 7,11-groups:
109 #I "7gp-PG-i" "11gp-PG-i"
110 #I
111 #I Standard Presentation examples:
112 #I general:
113 #I "StandardPresentation" "StandardPresentation-i"
114 #I "EpimorphismStandardPresentation"
115 #I "EpimorphismStandardPresentation-i" "IsIsomorphicPGroup-ni"
116 #I 2-groups:
117 #I "2gp-SP-Rel-i" "2gp-SP-1-Rel-i" "2gp-SP-2-Rel-i"
118 #I "2gp-SP-3-Rel-i" "2gp-SP-4-Rel-i" "2gp-SP-d-Rel-i"
119 #I "gp-256-SP-Rel-i" "B2-4-SP-i" "G2-SP-Rel-i"
120 #I 3-groups:
121 #I "3gp-SP-Rel-i" "3gp-SP-1-Rel-i" "3gp-SP-2-Rel-i"
122 #I "3gp-SP-3-Rel-i" "3gp-SP-4-Rel-i" "G3-SP-Rel-i"
123 #I 5-groups:
124 #I "5gp-SP-Rel-i" "5gp-SP-a-Rel-i" "5gp-SP-b-Rel-i"
125 #I "5gp-SP-big-Rel-i" "5gp-SP-d-Rel-i" "G5-SP-Rel-i"
126 #I "G5-SP-a-Rel-i" "Nott-SP-Rel-i"
127 #I 7-groups:
128 #I "7gp-SP-Rel-i" "7gp-SP-a-Rel-i" "7gp-SP-b-Rel-i"
129 #I 11-groups:
130 #I "11gp-SP-a-i" "11gp-SP-a-Rel-i" "11gp-SP-a-Rel-1-i"
131 #I "11gp-SP-b-i" "11gp-SP-b-Rel-i" "11gp-SP-c-Rel-i"
132 #I
133 #I Notes
134 #I -----
135 #I 1. The example (first) argument of `PqExample' is a string; each
136 #I example above is in double quotes to remind you to include them.
137 #I 2. Some examples accept options. To find out whether a particular
138 #I example accepts options, display it first (by including `Display'
139 #I as last argument) which will also indicate how `PqExample'
140 #I interprets the options, e.g. `PqExample("11gp-SP-a-i", Display);'.
141 #I 3. Try `SetInfoLevel(InfoANUPQ, &lt;n&gt;);' for some &lt;n&gt; in [2 .. 4]
142 #I before calling PqExample, to see what's going on behind the scenes.
143 #I
144 </pre></div>
145
146 <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>
147
148
149 <div class="example"><pre>
150 <span class="GAPprompt">gap&gt;</span> <span class="GAPinput">?anupq:examples</span>
151 </pre></div>
152
153 <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_mj.html#X823C93FC7B87F5BC"><span class="RefLink">3.4-5</span></a>)).</p>
154
155 <p>In the remainder of this appendix we will discuss particular aspects related to the <code class="code">Relators</code> (see <a href="chap6_mj.html#X87EE6DD67C9996A3"><span class="RefLink">6.2</span></a>) and <code class="code">Identities</code> (see <a href="chap6_mj.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>
156
157 <p><a id="X80676E317BF4DF13" name="X80676E317BF4DF13"></a></p>
158
159 <h4>A.1 <span class="Heading">The Relators Option</span></h4>
160
161 <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>
162
163 <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_mj.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>
164
165
166 <div class="example"><pre>
167 <span class="GAPprompt">gap&gt;</span> <span class="GAPinput">SetInfoLevel(InfoANUPQ, 2); #to see timing information</span>
168 <span class="GAPprompt">gap&gt;</span> <span class="GAPinput">PqExample("11gp-i");</span>
169 #I #Example: "11gp-i" . . . based on: examples/11gp
170 #I F, a, b, c, R, procId are local to `PqExample'
171 <span class="GAPprompt">gap&gt;</span> <span class="GAPinput">F := FreeGroup("a", "b", "c"); a := F.1; b := F.2; c := F.3;</span>
172 &lt;free group on the generators [ a, b, c ]&gt;
173 a
174 b
175 c
176 <span class="GAPprompt">gap&gt;</span> <span class="GAPinput">R := [PqLeftNormComm([b, a, a, b, c])^11, </span>
177 <span class="GAPprompt">&gt;</span> <span class="GAPinput"> PqLeftNormComm([a, b, b, a, b, c])^11, (a * b)^11];;</span>
178 <span class="GAPprompt">gap&gt;</span> <span class="GAPinput">procId := PqStart(F/R : Prime := 11);;</span>
179 <span class="GAPprompt">gap&gt;</span> <span class="GAPinput">PqPcPresentation(procId : ClassBound := 7, </span>
180 <span class="GAPprompt">&gt;</span> <span class="GAPinput"> OutputLevel := 1);</span>
181 #I Lower exponent-11 central series for [grp]
182 #I Group: [grp] to lower exponent-11 central class 1 has order 11^3
183 #I Group: [grp] to lower exponent-11 central class 2 has order 11^8
184 #I Group: [grp] to lower exponent-11 central class 3 has order 11^19
185 #I Group: [grp] to lower exponent-11 central class 4 has order 11^42
186 #I Group: [grp] to lower exponent-11 central class 5 has order 11^98
187 #I Group: [grp] to lower exponent-11 central class 6 has order 11^228
188 #I Group: [grp] to lower exponent-11 central class 7 has order 11^563
189 #I Computation of presentation took 27.04 seconds
190 <span class="GAPprompt">gap&gt;</span> <span class="GAPinput">PqSavePcPresentation(procId, ANUPQData.outfile);</span>
191 #I Variables used in `PqExample' are saved in `ANUPQData.example.vars'.
192 </pre></div>
193
194 <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>
195
196
197 <div class="example"><pre>
198 <span class="GAPprompt">gap&gt;</span> <span class="GAPinput">PqExample("11gp-Rel-i");</span>
199 #I #Example: "11gp-Rel-i" . . . based on: examples/11gp
200 #I #(equivalent to "11gp-i" example but uses `Relators' option)
201 #I F, rels, procId are local to `PqExample'
202 <span class="GAPprompt">gap&gt;</span> <span class="GAPinput">F := FreeGroup("a", "b", "c");</span>
203 &lt;free group on the generators [ a, b, c ]&gt;
204 <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>
205 [ "[b, a, a, b, c]^11", "[a, b, b, a, b, c]^11", "(a * b)^11" ]
206 <span class="GAPprompt">gap&gt;</span> <span class="GAPinput">procId := PqStart(F : Prime := 11, Relators := rels);;</span>
207 <span class="GAPprompt">gap&gt;</span> <span class="GAPinput">PqPcPresentation(procId : ClassBound := 7, </span>
208 <span class="GAPprompt">&gt;</span> <span class="GAPinput"> OutputLevel := 1);</span>
209 #I Relators parsed ok.
210 #I Lower exponent-11 central series for [grp]
211 #I Group: [grp] to lower exponent-11 central class 1 has order 11^3
212 #I Group: [grp] to lower exponent-11 central class 2 has order 11^8
213 #I Group: [grp] to lower exponent-11 central class 3 has order 11^19
214 #I Group: [grp] to lower exponent-11 central class 4 has order 11^42
215 #I Group: [grp] to lower exponent-11 central class 5 has order 11^98
216 #I Group: [grp] to lower exponent-11 central class 6 has order 11^228
217 #I Group: [grp] to lower exponent-11 central class 7 has order 11^563
218 #I Computation of presentation took 0.27 seconds
219 <span class="GAPprompt">gap&gt;</span> <span class="GAPinput">PqSavePcPresentation(procId, ANUPQData.outfile);</span>
220 #I Variables used in `PqExample' are saved in `ANUPQData.example.vars'.
221 </pre></div>
222
223 <p><a id="X80B2AA7084C57F5D" name="X80B2AA7084C57F5D"></a></p>
224
225 <h4>A.2 <span class="Heading">The Identities Option and PqEvaluateIdentities Function</span></h4>
226
227 <p>Please pay heed to the warnings given for the <code class="code">Identities</code> option (see <a href="chap6_mj.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>
228
229
230 <div class="example"><pre>
231 <span class="GAPprompt">gap&gt;</span> <span class="GAPinput">SetInfoLevel(InfoANUPQ, 1);</span>
232 <span class="GAPprompt">gap&gt;</span> <span class="GAPinput">PqExample("B2-4-Id");</span>
233 #I #Example: "B2-4-Id" . . . alternative way to generate B(2, 4)
234 #I #Generates B(2, 4) by using the `Identities' option
235 #I #... this is not as efficient as using `Exponent' but
236 #I #demonstrates the usage of the `Identities' option.
237 #I F, f, procId are local to `PqExample'
238 <span class="GAPprompt">gap&gt;</span> <span class="GAPinput">F := FreeGroup("a", "b");</span>
239 &lt;free group on the generators [ a, b ]&gt;
240 <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>
241 <span class="GAPprompt">gap&gt;</span> <span class="GAPinput">f := w -&gt; w^4;</span>
242 function( w ) ... end
243 <span class="GAPprompt">gap&gt;</span> <span class="GAPinput">Pq( F : Prime := 2, Identities := [ f ] );</span>
244 #I Class 1 with 2 generators.
245 #I Class 2 with 5 generators.
246 #I Class 3 with 7 generators.
247 #I Class 4 with 10 generators.
248 #I Class 5 with 12 generators.
249 #I Class 5 with 12 generators.
250 &lt;pc group of size 4096 with 12 generators&gt;
251 #I Variables used in `PqExample' are saved in `ANUPQData.example.vars'.
252 <span class="GAPprompt">gap&gt;</span> <span class="GAPinput">time; </span>
253 1400
254 </pre></div>
255
256 <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>
257
258 <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_mj.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>
259
260
261 <div class="example"><pre>
262 <span class="GAPprompt">gap&gt;</span> <span class="GAPinput">SetInfoLevel(InfoANUPQ, 2); # to see time spent by the `pq' program</span>
263 <span class="GAPprompt">gap&gt;</span> <span class="GAPinput">PqExample("B2-4");</span>
264 #I #Example: "B2-4" . . . the ``right'' way to generate B(2, 4)
265 #I #Generates B(2, 4) by using the `Exponent' option
266 #I F, procId are local to `PqExample'
267 <span class="GAPprompt">gap&gt;</span> <span class="GAPinput">F := FreeGroup("a", "b");</span>
268 &lt;free group on the generators [ a, b ]&gt;
269 <span class="GAPprompt">gap&gt;</span> <span class="GAPinput">Pq( F : Prime := 2, Exponent := 4 );</span>
270 #I Computation of presentation took 0.00 seconds
271 &lt;pc group of size 4096 with 12 generators&gt;
272 #I Variables used in `PqExample' are saved in `ANUPQData.example.vars'.
273 <span class="GAPprompt">gap&gt;</span> <span class="GAPinput">time; # time spent by GAP in executing `PqExample("B2-4");' </span>
274 50
275 </pre></div>
276
277 <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>
278
279
280 <div class="example"><pre>
281 <span class="GAPprompt">gap&gt;</span> <span class="GAPinput">SetInfoLevel(InfoANUPQ, 1); # reset InfoANUPQ to default level</span>
282 <span class="GAPprompt">gap&gt;</span> <span class="GAPinput">PqExample("11gp-3-Engel-Id", PqStart);</span>
283 #I #Example: "11gp-3-Engel-Id" . . . 3-Engel group for prime 11
284 #I #Non-trivial example of using the `Identities' option
285 #I F, a, b, G, f, procId, Q are local to `PqExample'
286 <span class="GAPprompt">gap&gt;</span> <span class="GAPinput">F := FreeGroup("a", "b"); a := F.1; b := F.2;</span>
287 &lt;free group on the generators [ a, b ]&gt;
288 a
289 b
290 <span class="GAPprompt">gap&gt;</span> <span class="GAPinput">G := F/[ a^11, b^11 ];</span>
291 &lt;fp group on the generators [ a, b ]&gt;
292 <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>
293 <span class="GAPprompt">gap&gt;</span> <span class="GAPinput"># must satisfy the Engel identity: [u, v, v, v] = 1.</span>
294 <span class="GAPprompt">gap&gt;</span> <span class="GAPinput">f := function(u, v) return PqLeftNormComm( [u, v, v, v] ); end;</span>
295 function( u, v ) ... end
296 <span class="GAPprompt">gap&gt;</span> <span class="GAPinput">procId := PqStart( G );;</span>
297 <span class="GAPprompt">gap&gt;</span> <span class="GAPinput">Q := Pq( procId : Prime := 11, Identities := [ f ] );</span>
298 #I Class 1 with 2 generators.
299 #I Class 2 with 3 generators.
300 #I Class 3 with 5 generators.
301 #I Class 3 with 5 generators.
302 &lt;pc group of size 161051 with 5 generators&gt;
303 <span class="GAPprompt">gap&gt;</span> <span class="GAPinput"># We do a ``sample'' check that pairs of elements of Q do satisfy</span>
304 <span class="GAPprompt">gap&gt;</span> <span class="GAPinput"># the given identity:</span>
305 <span class="GAPprompt">gap&gt;</span> <span class="GAPinput">f( Random(Q), Random(Q) );</span>
306 &lt;identity&gt; of ...
307 <span class="GAPprompt">gap&gt;</span> <span class="GAPinput">f( Q.1, Q.2 );</span>
308 &lt;identity&gt; of ...
309 #I Variables used in `PqExample' are saved in `ANUPQData.example.vars'.
310 </pre></div>
311
312 <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_mj.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>
313
314
315 <div class="example"><pre>
316 <span class="GAPprompt">gap&gt;</span> <span class="GAPinput">PqExample("11gp-3-Engel-Id-i");</span>
317 #I #Example: "11gp-3-Engel-Id-i" . . . 3-Engel grp for prime 11
318 #I #Variation of "11gp-3-Engel-Id" broken down into its lower-level component
319 #I #command parts.
320 #I F, a, b, G, f, procId, Q are local to `PqExample'
321 <span class="GAPprompt">gap&gt;</span> <span class="GAPinput">F := FreeGroup("a", "b"); a := F.1; b := F.2;</span>
322 &lt;free group on the generators [ a, b ]&gt;
323 a
324 b
325 <span class="GAPprompt">gap&gt;</span> <span class="GAPinput">G := F/[ a^11, b^11 ];</span>
326 &lt;fp group on the generators [ a, b ]&gt;
327 <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>
328 <span class="GAPprompt">gap&gt;</span> <span class="GAPinput"># must satisfy the Engel identity: [u, v, v, v] = 1.</span>
329 <span class="GAPprompt">gap&gt;</span> <span class="GAPinput">f := function(u, v) return PqLeftNormComm( [u, v, v, v] ); end;</span>
330 function( u, v ) ... end
331 <span class="GAPprompt">gap&gt;</span> <span class="GAPinput">procId := PqStart( G : Prime := 11 );;</span>
332 <span class="GAPprompt">gap&gt;</span> <span class="GAPinput">PqPcPresentation( procId : ClassBound := 1);</span>
333 <span class="GAPprompt">gap&gt;</span> <span class="GAPinput">PqEvaluateIdentities( procId : Identities := [f] );</span>
334 #I Class 1 with 2 generators.
335 <span class="GAPprompt">gap&gt;</span> <span class="GAPinput">for c in [2 .. 4] do</span>
336 <span class="GAPprompt">&gt;</span> <span class="GAPinput"> PqNextClass( procId : Identities := [] ); #reset `Identities' option</span>
337 <span class="GAPprompt">&gt;</span> <span class="GAPinput"> PqEvaluateIdentities( procId : Identities := [f] );</span>
338 <span class="GAPprompt">&gt;</span> <span class="GAPinput"> od;</span>
339 #I Class 2 with 3 generators.
340 #I Class 3 with 5 generators.
341 #I Class 3 with 5 generators.
342 <span class="GAPprompt">gap&gt;</span> <span class="GAPinput">Q := PqCurrentGroup( procId );</span>
343 &lt;pc group of size 161051 with 5 generators&gt;
344 <span class="GAPprompt">gap&gt;</span> <span class="GAPinput"># We do a ``sample'' check that pairs of elements of Q do satisfy</span>
345 <span class="GAPprompt">gap&gt;</span> <span class="GAPinput"># the given identity:</span>
346 <span class="GAPprompt">gap&gt;</span> <span class="GAPinput">f( Random(Q), Random(Q) );</span>
347 &lt;identity&gt; of ...
348 <span class="GAPprompt">gap&gt;</span> <span class="GAPinput">f( Q.1, Q.2 );</span>
349 &lt;identity&gt; of ...
350 #I Variables used in `PqExample' are saved in `ANUPQData.example.vars'.
351 </pre></div>
352
353 <p><a id="X7A997D1A8532A84B" name="X7A997D1A8532A84B"></a></p>
354
355 <h4>A.3 <span class="Heading">A Large Example</span></h4>
356
357 <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>
358
359 <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>
360
361 <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>
362
363
364 <div class="example"><pre>
365 procId := PqStart( FreeGroup(5) : Exponent := 4, Prime := 2 );
366 Pq( procId : ClassBound := 2 );
367 PqSupplyAutomorphisms( procId,
368 [
369 [ [ 1, 1, 0, 0, 0], # first automorphism
370 [ 0, 1, 0, 0, 0],
371 [ 0, 0, 1, 0, 0],
372 [ 0, 0, 0, 1, 0],
373 [ 0, 0, 0, 0, 1] ],
374
375 [ [ 0, 0, 0, 0, 1], # second automorphism
376 [ 1, 0, 0, 0, 0],
377 [ 0, 1, 0, 0, 0],
378 [ 0, 0, 1, 0, 0],
379 [ 0, 0, 0, 1, 0] ]
380 ] );;
381
382 Relations :=
383 [ [], ## class 1
384 [], ## class 2
385 [], ## class 3
386 [], ## class 4
387 [], ## class 5
388 [], ## class 6
389 ## class 7
390 [ [ "x2","x1","x1","x3","x4","x4","x4" ] ],
391 ## class 8
392 [ [ "x2","x1","x1","x3","x4","x5","x5","x5" ] ],
393 ## class 9
394 [ [ "x2","x1","x1","x3","x4","x4","x5","x5","x5" ],
395 [ "x2","x1","x1","x2","x3","x4","x5","x5","x5" ],
396 [ "x2","x1","x1","x3","x3","x4","x5","x5","x5" ] ],
397 ## class 10
398 [ [ "x2","x1","x1","x2","x3","x3","x4","x5","x5","x5" ],
399 [ "x2","x1","x1","x3","x3","x4","x4","x5","x5","x5" ] ],
400 ## class 11
401 [ [ "x2","x1","x1","x2","x3","x3","x4","x4","x5","x5","x5" ],
402 [ "x2","x1","x1","x2","x3","x1","x3","x4","x2","x4","x3" ] ],
403 ## class 12
404 [ [ "x2","x1","x1","x2","x3","x1","x3","x4","x2","x5","x5","x5" ],
405 [ "x2","x1","x1","x3","x2","x4","x3","x5","x4","x5","x5","x5" ] ],
406 ## class 13
407 [ [ "x2","x1","x1","x2","x3","x1","x3","x4","x2","x4","x5","x5","x5"
408 ] ]
409 ];
410
411 for class in [ 3 .. 13 ] do
412 Print( "Computing class ", class, "\n" );
413 PqSetupTablesForNextClass( procId );
414
415 for w in [ class, class-1 .. 7 ] do
416
417 PqAddTails( procId, w );
418 PqDisplayPcPresentation( procId );
419
420 if Relations[ w ] &lt;&gt; [] then
421 # recalculate automorphisms
422 PqExtendAutomorphisms( procId );
423
424 for r in Relations[ w ] do
425 Print( "Collecting ", r, "\n" );
426 PqCommutator( procId, r, 1 );
427 PqEchelonise( procId );
428 PqApplyAutomorphisms( procId, 15 ); #queue factor = 15
429 od;
430
431 PqEliminateRedundantGenerators( procId );
432 fi;
433 PqComputeTails( procId, w );
434 od;
435 PqDisplayPcPresentation( procId );
436
437 smallclass := Minimum( class, 6 );
438 for w in [ smallclass, smallclass-1 .. 2 ] do
439 PqTails( procId, w );
440 od;
441 # recalculate automorphisms
442 PqExtendAutomorphisms( procId );
443 PqCollect( procId, "x5^4" );
444 PqEchelonise( procId );
445 PqApplyAutomorphisms( procId, 15 ); #queue factor = 15
446 PqEliminateRedundantGenerators( procId );
447 PqDisplayPcPresentation( procId );
448 od;
449 </pre></div>
450
451 <p><a id="X7FB6DA8D7BB90D8C" name="X7FB6DA8D7BB90D8C"></a></p>
452
453 <h4>A.4 <span class="Heading">Developing descendants trees</span></h4>
454
455 <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_mj.html#X7BB0EB607F337265"><span class="RefLink">3.4-4</span></a>)).</p>
456
457
458 <div class="example"><pre>
459 <span class="GAPprompt">gap&gt;</span> <span class="GAPinput">G := ElementaryAbelianGroup( 9 );</span>
460 &lt;pc group of size 9 with 2 generators&gt;
461 <span class="GAPprompt">gap&gt;</span> <span class="GAPinput">procId := PqStart( G );;</span>
462 <span class="GAPprompt">gap&gt;</span> <span class="GAPinput">#</span>
463 <span class="GAPprompt">gap&gt;</span> <span class="GAPinput"># Below, we use the option StepSize in order to construct descendants</span>
464 <span class="GAPprompt">gap&gt;</span> <span class="GAPinput"># of coclass 1. This is equivalent to setting the StepSize to 1 in</span>
465 <span class="GAPprompt">gap&gt;</span> <span class="GAPinput"># each descendant calculation.</span>
466 <span class="GAPprompt">gap&gt;</span> <span class="GAPinput">#</span>
467 <span class="GAPprompt">gap&gt;</span> <span class="GAPinput"># The elementary abelian group of order 9 has 3 descendants of</span>
468 <span class="GAPprompt">gap&gt;</span> <span class="GAPinput"># 3-class 2 and 3-coclass 1, as the result of the next command</span>
469 <span class="GAPprompt">gap&gt;</span> <span class="GAPinput"># shows. </span>
470 <span class="GAPprompt">gap&gt;</span> <span class="GAPinput">#</span>
471 <span class="GAPprompt">gap&gt;</span> <span class="GAPinput">PqDescendants( procId : StepSize := 1 );</span>
472 [ &lt;pc group of size 27 with 3 generators&gt;,
473 &lt;pc group of size 27 with 3 generators&gt;,
474 &lt;pc group of size 27 with 3 generators&gt; ]
475 <span class="GAPprompt">gap&gt;</span> <span class="GAPinput">#</span>
476 <span class="GAPprompt">gap&gt;</span> <span class="GAPinput"># Now we will compute the descendants of coclass 1 for each of the</span>
477 <span class="GAPprompt">gap&gt;</span> <span class="GAPinput"># groups above. Then we will compute the descendants of coclass 1</span>
478 <span class="GAPprompt">gap&gt;</span> <span class="GAPinput"># of each descendant and so on. Note that the pq program keeps</span>
479 <span class="GAPprompt">gap&gt;</span> <span class="GAPinput"># one file for each class at a time. For example, the descendants</span>
480 <span class="GAPprompt">gap&gt;</span> <span class="GAPinput"># calculation for the second group of class 2 overwrites the</span>
481 <span class="GAPprompt">gap&gt;</span> <span class="GAPinput"># descendant file obtained from the first group of class 2.</span>
482 <span class="GAPprompt">gap&gt;</span> <span class="GAPinput"># Hence, we have to traverse the descendants tree in depth first</span>
483 <span class="GAPprompt">gap&gt;</span> <span class="GAPinput"># order.</span>
484 <span class="GAPprompt">gap&gt;</span> <span class="GAPinput">#</span>
485 <span class="GAPprompt">gap&gt;</span> <span class="GAPinput">PqPGSetDescendantToPcp( procId, 2, 1 );</span>
486 <span class="GAPprompt">gap&gt;</span> <span class="GAPinput">PqPGExtendAutomorphisms( procId );</span>
487 <span class="GAPprompt">gap&gt;</span> <span class="GAPinput">PqPGConstructDescendants( procId : StepSize := 1 );</span>
488 2
489 <span class="GAPprompt">gap&gt;</span> <span class="GAPinput">PqPGSetDescendantToPcp( procId, 3, 1 );</span>
490 <span class="GAPprompt">gap&gt;</span> <span class="GAPinput">PqPGExtendAutomorphisms( procId );</span>
491 <span class="GAPprompt">gap&gt;</span> <span class="GAPinput">PqPGConstructDescendants( procId : StepSize := 1 );</span>
492 2
493 <span class="GAPprompt">gap&gt;</span> <span class="GAPinput">PqPGSetDescendantToPcp( procId, 4, 1 );</span>
494 <span class="GAPprompt">gap&gt;</span> <span class="GAPinput">PqPGExtendAutomorphisms( procId );</span>
495 <span class="GAPprompt">gap&gt;</span> <span class="GAPinput">PqPGConstructDescendants( procId : StepSize := 1 );</span>
496 2
497 <span class="GAPprompt">gap&gt;</span> <span class="GAPinput">#</span>
498 <span class="GAPprompt">gap&gt;</span> <span class="GAPinput"># At this point we stop traversing the ``left most'' branch of the</span>
499 <span class="GAPprompt">gap&gt;</span> <span class="GAPinput"># descendants tree and move upwards.</span>
500 <span class="GAPprompt">gap&gt;</span> <span class="GAPinput">#</span>
501 <span class="GAPprompt">gap&gt;</span> <span class="GAPinput">PqPGSetDescendantToPcp( procId, 4, 2 );</span>
502 <span class="GAPprompt">gap&gt;</span> <span class="GAPinput">PqPGExtendAutomorphisms( procId );</span>
503 <span class="GAPprompt">gap&gt;</span> <span class="GAPinput">PqPGConstructDescendants( procId : StepSize := 1 );</span>
504 #I group restored from file is incapable
505 0
506 <span class="GAPprompt">gap&gt;</span> <span class="GAPinput">PqPGSetDescendantToPcp( procId, 3, 2 );</span>
507 <span class="GAPprompt">gap&gt;</span> <span class="GAPinput">PqPGExtendAutomorphisms( procId );</span>
508 <span class="GAPprompt">gap&gt;</span> <span class="GAPinput">PqPGConstructDescendants( procId : StepSize := 1 );</span>
509 #I group restored from file is incapable
510 0
511 <span class="GAPprompt">gap&gt;</span> <span class="GAPinput"># </span>
512 <span class="GAPprompt">gap&gt;</span> <span class="GAPinput"># The computations above indicate that the descendants subtree under</span>
513 <span class="GAPprompt">gap&gt;</span> <span class="GAPinput"># the first descendant of the elementary abelian group of order 9</span>
514 <span class="GAPprompt">gap&gt;</span> <span class="GAPinput"># will have only one path of infinite length.</span>
515 <span class="GAPprompt">gap&gt;</span> <span class="GAPinput">#</span>
516 <span class="GAPprompt">gap&gt;</span> <span class="GAPinput">PqPGSetDescendantToPcp( procId, 2, 2 );</span>
517 <span class="GAPprompt">gap&gt;</span> <span class="GAPinput">PqPGExtendAutomorphisms( procId );</span>
518 <span class="GAPprompt">gap&gt;</span> <span class="GAPinput">PqPGConstructDescendants( procId : StepSize := 1 );</span>
519 4
520 <span class="GAPprompt">gap&gt;</span> <span class="GAPinput">#</span>
521 <span class="GAPprompt">gap&gt;</span> <span class="GAPinput"># We get four descendants here, three of which will turn out to be</span>
522 <span class="GAPprompt">gap&gt;</span> <span class="GAPinput"># incapable, i.e., they have no descendants and are terminal nodes</span>
523 <span class="GAPprompt">gap&gt;</span> <span class="GAPinput"># in the descendants tree.</span>
524 <span class="GAPprompt">gap&gt;</span> <span class="GAPinput">#</span>
525 <span class="GAPprompt">gap&gt;</span> <span class="GAPinput">PqPGSetDescendantToPcp( procId, 2, 3 );</span>
526 <span class="GAPprompt">gap&gt;</span> <span class="GAPinput">PqPGExtendAutomorphisms( procId );</span>
527 <span class="GAPprompt">gap&gt;</span> <span class="GAPinput">PqPGConstructDescendants( procId : StepSize := 1 );</span>
528 #I group restored from file is incapable
529 0
530 <span class="GAPprompt">gap&gt;</span> <span class="GAPinput">#</span>
531 <span class="GAPprompt">gap&gt;</span> <span class="GAPinput"># The third descendant of class three is incapable. Let us return</span>
532 <span class="GAPprompt">gap&gt;</span> <span class="GAPinput"># to the second descendant of class 2.</span>
533 <span class="GAPprompt">gap&gt;</span> <span class="GAPinput">#</span>
534 <span class="GAPprompt">gap&gt;</span> <span class="GAPinput">PqPGSetDescendantToPcp( procId, 2, 2 );</span>
535 <span class="GAPprompt">gap&gt;</span> <span class="GAPinput">PqPGExtendAutomorphisms( procId );</span>
536 <span class="GAPprompt">gap&gt;</span> <span class="GAPinput">PqPGConstructDescendants( procId : StepSize := 1 );</span>
537 4
538 <span class="GAPprompt">gap&gt;</span> <span class="GAPinput">PqPGSetDescendantToPcp( procId, 3, 1 );</span>
539 <span class="GAPprompt">gap&gt;</span> <span class="GAPinput">PqPGExtendAutomorphisms( procId );</span>
540 <span class="GAPprompt">gap&gt;</span> <span class="GAPinput">PqPGConstructDescendants( procId : StepSize := 1 );</span>
541 #I group restored from file is incapable
542 0
543 <span class="GAPprompt">gap&gt;</span> <span class="GAPinput">PqPGSetDescendantToPcp( procId, 3, 2 );</span>
544 <span class="GAPprompt">gap&gt;</span> <span class="GAPinput">PqPGExtendAutomorphisms( procId );</span>
545 <span class="GAPprompt">gap&gt;</span> <span class="GAPinput">PqPGConstructDescendants( procId : StepSize := 1 );</span>
546 #I group restored from file is incapable
547 0
548 <span class="GAPprompt">gap&gt;</span> <span class="GAPinput">#</span>
549 <span class="GAPprompt">gap&gt;</span> <span class="GAPinput"># We skip the third descendant for the moment ... </span>
550 <span class="GAPprompt">gap&gt;</span> <span class="GAPinput">#</span>
551 <span class="GAPprompt">gap&gt;</span> <span class="GAPinput">PqPGSetDescendantToPcp( procId, 3, 4 );</span>
552 <span class="GAPprompt">gap&gt;</span> <span class="GAPinput">PqPGExtendAutomorphisms( procId );</span>
553 <span class="GAPprompt">gap&gt;</span> <span class="GAPinput">PqPGConstructDescendants( procId : StepSize := 1 );</span>
554 #I group restored from file is incapable
555 0
556 <span class="GAPprompt">gap&gt;</span> <span class="GAPinput">#</span>
557 <span class="GAPprompt">gap&gt;</span> <span class="GAPinput"># ... and look at it now.</span>
558 <span class="GAPprompt">gap&gt;</span> <span class="GAPinput">#</span>
559 <span class="GAPprompt">gap&gt;</span> <span class="GAPinput">PqPGSetDescendantToPcp( procId, 3, 3 );</span>
560 <span class="GAPprompt">gap&gt;</span> <span class="GAPinput">PqPGExtendAutomorphisms( procId );</span>
561 <span class="GAPprompt">gap&gt;</span> <span class="GAPinput">PqPGConstructDescendants( procId : StepSize := 1 );</span>
562 6
563 <span class="GAPprompt">gap&gt;</span> <span class="GAPinput">#</span>
564 <span class="GAPprompt">gap&gt;</span> <span class="GAPinput"># In this branch of the descendant tree we get 6 descendants of class</span>
565 <span class="GAPprompt">gap&gt;</span> <span class="GAPinput"># three. Of those 5 will turn out to be incapable and one will have</span>
566 <span class="GAPprompt">gap&gt;</span> <span class="GAPinput"># 7 descendants.</span>
567 <span class="GAPprompt">gap&gt;</span> <span class="GAPinput">#</span>
568 <span class="GAPprompt">gap&gt;</span> <span class="GAPinput">PqPGSetDescendantToPcp( procId, 4, 1 );</span>
569 <span class="GAPprompt">gap&gt;</span> <span class="GAPinput">PqPGExtendAutomorphisms( procId );</span>
570 <span class="GAPprompt">gap&gt;</span> <span class="GAPinput">PqPGConstructDescendants( procId : StepSize := 1 );</span>
571 #I group restored from file is incapable
572 0
573 <span class="GAPprompt">gap&gt;</span> <span class="GAPinput">PqPGSetDescendantToPcp( procId, 4, 2 );</span>
574 <span class="GAPprompt">gap&gt;</span> <span class="GAPinput">PqPGExtendAutomorphisms( procId );</span>
575 <span class="GAPprompt">gap&gt;</span> <span class="GAPinput">PqPGConstructDescendants( procId : StepSize := 1 );</span>
576 7
577 <span class="GAPprompt">gap&gt;</span> <span class="GAPinput">PqPGSetDescendantToPcp( procId, 4, 3 );</span>
578 <span class="GAPprompt">gap&gt;</span> <span class="GAPinput">PqPGExtendAutomorphisms( procId );</span>
579 <span class="GAPprompt">gap&gt;</span> <span class="GAPinput">PqPGConstructDescendants( procId : StepSize := 1 );</span>
580 #I group restored from file is incapable
581 0
582 </pre></div>
583
584 <p>To automate the above procedure to some extent we provide:</p>
585
586 <p><a id="X805E6B418193CF2D" name="X805E6B418193CF2D"></a></p>
587
588 <h5>A.4-1 PqDescendantsTreeCoclassOne</h5>
589
590 <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>
591 <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>
592 <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_mj.html#X795817217C53AB89"><span class="RefLink">5.3-6</span></a>)).</p>
593
594 <p><em>Notes</em></p>
595
596 <ol>
597 <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>
598
599 </li>
600 <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>
601
602 </li>
603 <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>
604
605 </li>
606 </ol>
607 <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>
608
609
610 <div class="example"><pre>
611 PqDescendantsTreeCoclassOne := function( procId )
612 local des, i;
613
614 des := PqDescendants( procId : StepSize := 1 );
615 RecurseDescendants( procId, 2, Length(des) );
616 end;
617 </pre></div>
618
619 <p>where <code class="code">RecurseDescendants</code> is (approximately) defined as follows:</p>
620
621
622 <div class="example"><pre>
623 RecurseDescendants := function( procId, class, n )
624 local i, nr;
625
626 if class &gt; ValueOption("TreeDepth") then return; fi;
627
628 for i in [1..n] do
629 PqPGSetDescendantToPcp( procId, class, i );
630 PqPGExtendAutomorphisms( procId );
631 nr := PqPGConstructDescendants( procId : StepSize := 1 );
632 Print( "Number of descendants of group ", i,
633 " at class ", class, ": ", nr, "\n" );
634 RecurseDescendants( procId, class+1, nr );
635 od;
636 return;
637 end;
638 </pre></div>
639
640 <p>The following examples (executed via <code class="code">PqExample</code>; see <code class="func">PqExample</code> (<a href="chap3_mj.html#X7BB0EB607F337265"><span class="RefLink">3.4-4</span></a>)), demonstrate the use of <code class="code">PqDescendantsTreeCoclassOne</code>:</p>
641
642
643 <dl>
644 <dt><strong class="Mark"><code class="code">"PqDescendantsTreeCoclassOne-9-i"</code></strong></dt>
645 <dd><p>approximately does example <code class="code">"PqDescendants-treetraverse-i"</code> again using <code class="code">PqDescendantsTreeCoclassOne</code>;</p>
646
647 </dd>
648 <dt><strong class="Mark"><code class="code">"PqDescendantsTreeCoclassOne-16-i"</code></strong></dt>
649 <dd><p>uses the option <code class="code">CapableDescendants</code>; and</p>
650
651 </dd>
652 <dt><strong class="Mark"><code class="code">"PqDescendantsTreeCoclassOne-25-i"</code></strong></dt>
653 <dd><p>calculates all descendants by omitting the <code class="code">CapableDescendants</code> option.</p>
654
655 </dd>
656 </dl>
657 <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>
658
659
660 <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="chap7_mj.html">[Previous Chapter]</a>&nbsp; &nbsp;<a href="chapBib_mj.html">[Next Chapter]</a>&nbsp; </div>
661
662
663 <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>
664
665 <hr />
666 <p class="foot">generated by <a href="https://www.math.rwth-aachen.de/~Frank.Luebeck/GAPDoc">GAPDoc2HTML</a></p>
667 </body>
668 </html>