anupq-3.3.3/0000755000175100017510000000000015111342315012246 5ustar runnerrunneranupq-3.3.3/CHANGES0000644000175100017510000003411515111342310013240 0ustar runnerrunnerIn this file we record the changes since the first GAP 4 release of the ANUPQ package. Version 3.3.3 (2025-11-25) * Define the term "proper descendant" and clarify in various places that all computed descendants are "proper" (i.e. not isomorphic to the original group) * Janitorial changes Version 3.3.2 (2025-08-28) * Various janitorial changes Version 3.3.1 (2024-10-21) * Fix a bug where calling `PqDescendants` too many times will result in a `"failed to launch child process"` error in `PQ_START` * Require GMP library for multiprecesion integer arithmetic, which is already required by GAP itself, and without which some computations may produce strange errors or even wrong results * Improve build system to find GMP more reliably * Update maintainers and contact details Version 3.3.0 (2023-01-05) * Fix some issues in the documentation * Remove `ANUPQGlobalVariables` * Remove most uses of `HideGlobalVariables` * Avoid using internal undocumented GAP functions * Update build system * Remove GAP 4.2 compatibility code Version 3.2.6 (2022-03-07) * Declared the ANUPQ package to be under the Artistic License 2.0. * Fix crash in PqDescendantsTreeCoclassOne * Various janitorial changes Version 3.2.5 (2022-02-22) * Fixed a hang on macOS 10.15 and later Version 3.2.4 (2022-02-22) * Fixed more compatibly issues under Windows/Cygwin * Fixed an issue that prevents anupq from linking on some systems Version 3.2.3 (2021-10-31) * Various janitorial changes, e.g. to the build system Version 3.2.2 (2021-04-11) * Fixed compatibly issues under Windows/Cygwin * Fixed many compiler warnings * Removed use of TemporaryGlobalVarName * Fixed building the manual on Linux * Update Max Horn's contact details Version 3.2.1 (2019-04-18) * After some back and forth, drop the limitation on 32-bit builds again; it turns out that 64-bit builds can work just fine * Added a patch by Laurent Bartholdi to the ANUPQ standalone binary, which helps computing lower central quotients in certain cases * Fixed a bug in PqEpimorphism which could produce a wrong result if the input was a p-group but not an fp-group * Various janitorial changes, e.g. to the build system Version 3.2 (2017-11-29) * Document that ANUPQ is 32-bit only and requires a 32-bit compiler. * Change build system to enforce 32-bit compilation by adding -m32 to CFLAGS and LDFLAGS. * Fix compilation if GMP was not found, and fix interaction between GAP code and the anupq binary in that case * Compatible with GAP 4.9 * Internal changes (avoid using GAP function SetFeatureObj, and the unix functions tmpnam() and tempnam()) Version 3.1.5 (2017-07-20) * Fix bug in configure script which made it warn about testPq missing when running configure the first time * Improve error message when launching child processes fails * Updated README section about the ANUPQ documentation Version 3.1.4 (2016-03-08) * Remove some obsolete test scripts * Revise how the manual is built Version 3.1.3 (2016-01-10) * Fixed version and release date in the manual * Fixed some minor issues with the manual contents * Fixed the PackageDoc entry in the PackageInfo.g file Version 3.1.2 (2016-01-07) o Converted manual to GAPDoc format. o Once again tweaked the build system. It now uses automake, and shares code with other packages like io and nq. This fixes various annoyances and will make it easy to share future fixes and improvements between multiple GAP packages. o Moved package homepage to https://gap-packages.github.io/anupq/ Version 3.1.1 (2013-11-19) o Updated the manual to match recent changes. o Corrected Greg Gamble's email address. o Further improved the build system. o Fixed the testPq script. Version 3.1 (2013-09-24; never publicly announced) o Requires at least GAP 4.5 and AutPGrp 1.5. o include/pq_author.h: pq program is now version 1.9 o Improved the build system: It now makes use of GNU autoconf, and the various Makefiles are now more robust, and compatible with both GAP 4.4 and 4.5. This should simplify building anupq for many users. o Werner Nickel is no longer maintainer. o Max Horn is new (co-)maintainer. o Fixed some warnings in the C code. Version 3.0 (2006-01-24) o lib/{anupga.gi,anupq.gi,anupqprop.gi,anupqxdesc.gi}: deprecated `PrimeOfPGroup' replaced by `PrimePGroup' o lib/anusp.gi: improved non-isomorphism test in `IsPqIsomorphicPGroup' from checking the exponent-p length to checking the order of the terms in the lower exponent-p central series (suggested by Marco Costantini), and corrected by Jack Schmidt o pre-GAP 4.4 compatibility features removed: - lib/anupqhead.g: . banner removed ... this role is performed by PackageInfo.g since GAP 4.4; thus `pkgbanner' option no longer exists . file split into lib/anupqhead.gd and lib/anupqhead.gi - lib/anupq4r2cpt.g[di]: (GAP 4.2 compatibility) deleted from distribution - lib/anustab.gi: changed `AutPGrp' package test to corresponding GAP 4.4 test - read.g,init.g: . removed all but the `ReadPkg' commands . changed `ReadPkg' to `ReadPackage' . made adjustments for lib/anupqhead.g split o src/GAP_link_via_file.c: deprecated GAP code updated for version 4.4 o include/pq_author.h: pq program is now version 1.8 o standalone-doc/{README,guide.tex}: modified for version 1.8 of the pq program o testPq.in - updated to check for GAP 4.4 and AutPGrp 1.2 as minimum versions - now also checks the version of the pq program o PackageInfo.g,README,VERSION,doc/{manual,intro,infra,install}.tex: - package version changed from 2.2 to 3.0 - AutPGrp package (at least 1.2) is now essential, not just recommended - pq program now version 1.8 Version 2.2: o PackageInfo.g, README, VERSION, doc/{intro,infra,install}.tex: - fixed typo. in PackageInfo.g: test file is tst/anupqeg.tst - package version changed from 2.1 to 2.2 Version 2.1: o lib/anupqi, tst/anupqeg.tst fix for a bug discovered by Tobias Rossmann: this bug was caused in the ANUPQ package's interface by not passing on the parameter StepSize to the standalone properly. This bug could result in computing the wrong number of descendants. Produced a new test file o lib/anupqi.gi, Makefile.in, tst/anupqeg.tsk, tst/anupqeg.tst changes suggested by Gary Zablackis in order to make the package run under Windows: - use '[grp]' as intermediate filename instead of '' - add target to the makefile for compiling the standalone with cygwin - run PqQuitAll() more often in test example o src/store_definition_sets.c: binomial coefficient algorithm modified to avoid overflow o include/pq_author.h: pq program is now version 1.7 o standalone-doc/{README,guide.tex}: modified for version 1.7 of the pq program o PackageInfo.g, README, VERSION, doc/{manual,intro,infra,anupq,options,install}.tex: - package version changed from 2.0 to 2.1 - pq program version changed from 1.6 to 1.7 Version 2.0: o include/pq_author.h: pq program is now version 1.6 o src/GAP_link_via_file.c: newline now added to output to GAP o src/{GAP_present.c,pgroup.c}, lib/{anupga.gi,anupqi.gi,anustab.gi}: changes to remedy bug reported by Boris Girnat (thanks Boris!) where too many descendants were generated for a group of class more than 1 with insoluble automorphism group o standalone/examples/README: updated with version 1.6 change o standalone/examples/pga_*, tst/test[123].pga: each file modified due to version 1.6 change (pq now asks an additional question: how many soluble automorphisms? - for all pga examples answer is 0) o standalone-doc/{README,guide.tex}: modified for version 1.6 of the pq program o tst/out/test[123].out modified as per above o examples/PqSupplementInnerAutomorphisms: `PqSupplementInnerAutomorphisms' now returns a record rather than a group; example modified accordingly o lib/anupq.gi: `GAPInfo.DirectoriesTemporary' replaces `DIRECTORIES_TEMPORARY' o lib/anupqopt.gi: added two new options for `PqPGSupplyAutomorphisms', namely `NumberOfSolubleAutomorphisms' and `RelativeOrders' o README, VERSION, doc/{manual,intro,infra,anupq,options,install}.tex: - package version changed from 1.5 to 2.0 - pq program version changed from 1.5 to 1.6 - various GAP 4.4 documentation changes - `PqSupplementInnerAutomorphisms' example modified o PkgInfo.g replaced by PackageInfo.g - `Pkg...' fields replaced by `Package...' fields - `AutoLoad' fields replaced by `Autoload' - now defines `Subtitle' fields - package version changed from 1.5 to 2.0 o testPq.in: changes for GAP 4.4 o init.g: - for GAP 4.3 compatibility, if GAP 4.3 then `GAPInfo' record defined with entries: . `DirectoriesTemporary' defined to be `DIRECTORIES_TEMPORARY' . `Version' which is defined to be the contents of VERSION - commented out deprecated stuff deleted - undocumented ANUPQPackageVersion() function removed o make_zoo: now includes doc/manual.{lab,toc} o tst/anupqeg.tst: modified for `PqSupplementInnerAutomorphisms' change Version 1.5: o lib/anupqios.gi: typo. (and bug!) on line 541 fixed (1 changed to i); thanks to Robert Morse for spotting it. o PkgInfo.g, lib/anupqhead.g: banner generated by `BannerString' field of PkgInfo.g record, rather than by lib/anupqhead.g for GAP 4.4+. o README, VERSION, PkgInfo.g, doc/{install,intro,infra}.tex 1.4 changed to 1.5 Version 1.4: o src/malloc.h: debugging file removed o src/print_multiweight.c: removed unnecessary line: #include o README, VERSION, PkgInfo.g, doc/{install,intro,infra}.tex 1.3 changed to 1.4 o testPq.in: Added more bullet-proofing, and more intelligent messages when things go wrong Version 1.3: o init.g: - now use `StringFile' rather than iostreams to read `VERSION' (more efficient) - now looks for version 1.1 of AutPGrp o testPq.in: - Added -A option to GAP command. - now looks for version 1.1 of AutPGrp o lib/{anusp.gi,anupga.gi}: On suggestion of Alexander Hulpke added `IsSyllableWordsFamily' as first argument to `FreeGroup' commands when the group is subsequently converted to a pc group (more efficient) o tst/anupqeg.tst: Remade. o doc/basics.tex: Fixed typo. o README, VERSION, PkgInfo.g, doc/{install,intro,infra}.tex 1.2 changed to 1.3 Version 1.2: A number of bugs to do with the input of generators/relations were identified by Robert Morse (thanks Robert): o PQ_GROUP_FROM_PCP (lib/anupq.gi line 531): `GroupHomomorphismByImages' replaced by `GroupHomomorphismByImagesNC' Reason: The check was unnecessary and slowed things down enormously. o PQ_PC_PRESENTATION (lib/anupq.gi): - datarec.gens, datarec.rels: previously `String' was applied to the generators/relators provided and then stored in datarec.gens, datarec.rels; this can be enormously costly. Now, no processing is done when GAP already has them in another form (for pc groups, however, the relators are calculated as before and stored as strings, in datec.rels). The conversion to String is now only done at the point of transmission to the pq program, and done in `ToPQk'. - datarec.gens: an Error is now emitted if the number of defining gen'rs is larger than 511 (the limit imposed by the pq program, see MAXGENS in `include/runtime.h'). o ToPQk (lib/anupqios.gi): When `ToPQk' is called with `cmd' equal to "gens" or "rels", cmd is treated as the field of `datarec' so that the transmission of generators and relators to the pq program can be treated specially, to improve efficiency. The data is still split into ``nice'' lines of length < 69 characters, but care is taken to avoid infinite loops when there are no nice places to break the lines. Also updated for changes made in GAP 4.3fix4. o PqSupplementInnerAutomorphisms (lib/anupga.gi): `SetPcgs' changed to `SetGeneralizedPcgs'. o PQ_AUT_INPUT (lib/anupqi.gi): `Pcgs' changed to `GeneralizedPcgs'. Now requires at least GAP 4.3fix4 and updated AutPGrp package (in .../autpgrp/gap/autos.gi `ConvertHybridAutGroup' uses `SetGeneralizedPcgs' in lieu of `SetPcgs'.) o lib/anupq4r2cpt.g[id]: deprecated. o init.g: commented out backward compatibility with GAP 4.2, since version 1.2 requires GAP 4.3fix4 anyway. Updated: o testPq.in: checks for new requirements mentioned above. o make_zoo o README o doc/{intro.tex,install.tex} Added: o PkgInfo.g Version 1.1: First GAP 4 release (GAP 4.2 compatible). Updates the GAP 3 release (Version 1.0). Basically, Version 1.0 and 1.1 are incompatible, being for different versions of GAP, but as much as was feasible of the original was retained. Principal differences are: o the key commands all take one argument, with any of the previous arguments being input as options; the GAP 3 way of inputting arguments is still supported for Pq, PqEpimorphism, PqDescendants etc.; o iostreams are used instead of files to communicate with the pq program; o the source code has been modified to support a -G option that allows the pq program to communicate with GAP via the iostream, rather than start up a new GAP, when it needs GAP to compute stabilisers; o the source code has also been modified to remove a few bugs; o the functionality has been significantly increased. - Greg Gamble -- 9 July, 2002; 3 November, 2002; 28 January, 2004. anupq-3.3.3/doc/0000755000175100017510000000000015111342310013006 5ustar runnerrunneranupq-3.3.3/doc/manual.lab0000644000175100017510000006500315111342310014747 0ustar runnerrunner\GAPDocLabFile{anupq} \makelabel{anupq:Title page}{}{X7D2C85EC87DD46E5} \makelabel{anupq:Copyright}{}{X81488B807F2A1CF1} \makelabel{anupq:Table of Contents}{}{X8537FEB07AF2BEC8} \makelabel{anupq:Introduction}{1}{X7DFB63A97E67C0A1} \makelabel{anupq:Overview}{1.1}{X8389AD927B74BA4A} \makelabel{anupq:How to read this manual}{1.2}{X8416D2657E7831A1} \makelabel{anupq:Authors and Acknowledgements}{1.3}{X79D2480A7810A7CC} \makelabel{anupq:Mathematical Background and Terminology}{2}{X7E7F3B617F42EF03} \makelabel{anupq:Basic notions}{2.1}{X79A052C47C92AF09} \makelabel{anupq:pc Presentations and Consistency}{2.1.1}{X7BD675838609D547} \makelabel{anupq:Exponent-p Central Series and Weighted pc Presentations}{2.1.2}{X7944DB037F2277A6} \makelabel{anupq:p-Cover, p-Multiplicator}{2.1.3}{X7C43ACA37D391EBD} \makelabel{anupq:Descendants, Capable, Terminal, Nucleus}{2.1.4}{X801A27A08462AFAB} \makelabel{anupq:Laws}{2.1.5}{X81FBE7ED79EFF5EF} \makelabel{anupq:The p-quotient Algorithm}{2.2}{X7C8CE96D80FC3614} \makelabel{anupq:Finding the p-cover}{2.2.1}{X791EB6F77899CB3D} \makelabel{anupq:Imposing the Relations of the fp Group}{2.2.2}{X804CF5C97F7BB880} \makelabel{anupq:Imposing Laws}{2.2.3}{X7F1A8CCD84462775} \makelabel{anupq:The p-group generation Algorithm, Standard Presentation, Isomorphism Testing}{2.3}{X807FB2EC85E6648D} \makelabel{anupq:Infrastructure}{3}{X7917EFDF7AC06F04} \makelabel{anupq:Loading the ANUPQ Package}{3.1}{X833D58248067E13B} \makelabel{anupq:The ANUPQData Record}{3.2}{X83DE155A79C38DBE} \makelabel{anupq:Setting the Verbosity of ANUPQ via Info and InfoANUPQ}{3.3}{X83E5C7CF7D8739DF} \makelabel{anupq:Utility Functions}{3.4}{X810FFB1C8035C8BE} \makelabel{anupq:Attributes and a Property for fp and pc p-groups}{3.5}{X818175EF85CAA807} \makelabel{anupq:Hints and Warnings regarding the use of Options}{3.6}{X7BA20FA07B166B37} \makelabel{anupq:Non-interactive ANUPQ functions}{4}{X7C51F26D839279FF} \makelabel{anupq:Computing p-Quotients}{4.1}{X80406BD47EB186E9} \makelabel{anupq:Computing Standard Presentations}{4.2}{X7F05F8DC79733A8E} \makelabel{anupq:Testing p-Groups for Isomorphism}{4.3}{X8030FAE586423615} \makelabel{anupq:Computing Descendants of a p-Group}{4.4}{X8450C72580D91245} \makelabel{anupq:Interactive ANUPQ functions}{5}{X842C13C27B941744} \makelabel{anupq:Starting and Stopping Interactive ANUPQ Processes}{5.1}{X7935CDAD7936CA0A} \makelabel{anupq:Interactive ANUPQ Process Utility Functions}{5.2}{X7EE8000A800CEE2D} \makelabel{anupq:Interactive Versions of Non-interactive ANUPQ Functions}{5.3}{X823D2BBF7C4515D4} \makelabel{anupq:Low-level Interactive ANUPQ functions based on menu items of the pq program}{5.4}{X857F050C832A1FE4} \makelabel{anupq:General commands}{5.5}{X868B10557D470CF6} \makelabel{anupq:Commands from the Main p-Quotient menu}{5.6}{X7BDD5B278719C630} \makelabel{anupq:Commands from the Advanced p-Quotient menu}{5.7}{X7D27BE937B1DE16E} \makelabel{anupq:Commands from the Standard Presentation menu}{5.8}{X7B94EDA385FDD904} \makelabel{anupq:Commands from the Main p-Group Generation menu}{5.9}{X8490031B7AA7F237} \makelabel{anupq:Commands from the Advanced p-Group Generation menu}{5.10}{X7E8FBC2D83C43481} \makelabel{anupq:ANUPQ Options}{6}{X7B0946E97E7EB359} \makelabel{anupq:Overview}{6.1}{X8389AD927B74BA4A} \makelabel{anupq:Detailed descriptions of ANUPQ Options}{6.2}{X87EE6DD67C9996A3} \makelabel{anupq:Installing the ANUPQ Package}{7}{X7FB487238298CF42} \makelabel{anupq:Testing your ANUPQ installation}{7.1}{X854577C8800DC7C2} \makelabel{anupq:Running the pq program as a standalone}{7.2}{X82906B5184C61063} \makelabel{anupq:Examples}{A}{X7A489A5D79DA9E5C} \makelabel{anupq:The Relators Option}{A.1}{X80676E317BF4DF13} \makelabel{anupq:The Identities Option and PqEvaluateIdentities Function}{A.2}{X80B2AA7084C57F5D} \makelabel{anupq:A Large Example}{A.3}{X7A997D1A8532A84B} \makelabel{anupq:Developing descendants trees}{A.4}{X7FB6DA8D7BB90D8C} \makelabel{anupq:Bibliography}{Bib}{X7A6F98FD85F02BFE} \makelabel{anupq:References}{Bib}{X7A6F98FD85F02BFE} \makelabel{anupq:Index}{Ind}{X83A0356F839C696F} \makelabel{anupq:ANUPQ}{1.1}{X8389AD927B74BA4A} \makelabel{anupq:bug reports}{1.3}{X79D2480A7810A7CC} \makelabel{anupq:power-commutator presentation}{2.1.1}{X7BD675838609D547} \makelabel{anupq:pc presentation}{2.1.1}{X7BD675838609D547} \makelabel{anupq:pcp}{2.1.1}{X7BD675838609D547} \makelabel{anupq:pc generators}{2.1.1}{X7BD675838609D547} \makelabel{anupq:collection}{2.1.1}{X7BD675838609D547} \makelabel{anupq:consistent}{2.1.1}{X7BD675838609D547} \makelabel{anupq:confluent rewriting system}{2.1.1}{X7BD675838609D547} \makelabel{anupq:confluent}{2.1.1}{X7BD675838609D547} \makelabel{anupq:consistency conditions}{2.1.1}{X7BD675838609D547} \makelabel{anupq:exponent-p central series}{2.1.2}{X7944DB037F2277A6} \makelabel{anupq:class}{2.1.2}{X7944DB037F2277A6} \makelabel{anupq:p-class}{2.1.2}{X7944DB037F2277A6} \makelabel{anupq:weight function}{2.1.2}{X7944DB037F2277A6} \makelabel{anupq:weighted pcp}{2.1.2}{X7944DB037F2277A6} \makelabel{anupq:p-covering group}{2.1.3}{X7C43ACA37D391EBD} \makelabel{anupq:p-cover}{2.1.3}{X7C43ACA37D391EBD} \makelabel{anupq:p-multiplicator}{2.1.3}{X7C43ACA37D391EBD} \makelabel{anupq:p-multiplicator rank}{2.1.3}{X7C43ACA37D391EBD} \makelabel{anupq:multiplicator rank}{2.1.3}{X7C43ACA37D391EBD} \makelabel{anupq:descendant}{2.1.4}{X801A27A08462AFAB} \makelabel{anupq:immediate descendant}{2.1.4}{X801A27A08462AFAB} \makelabel{anupq:nucleus}{2.1.4}{X801A27A08462AFAB} \makelabel{anupq:capable}{2.1.4}{X801A27A08462AFAB} \makelabel{anupq:terminal}{2.1.4}{X801A27A08462AFAB} \makelabel{anupq:nucleus}{2.1.4}{X801A27A08462AFAB} \makelabel{anupq:allowable subgroup}{2.1.4}{X801A27A08462AFAB} \makelabel{anupq:extended automorphism}{2.1.4}{X801A27A08462AFAB} \makelabel{anupq:permutations}{2.1.4}{X801A27A08462AFAB} \makelabel{anupq:law}{2.1.5}{X81FBE7ED79EFF5EF} \makelabel{anupq:identical relation}{2.1.5}{X81FBE7ED79EFF5EF} \makelabel{anupq:exponent law}{2.1.5}{X81FBE7ED79EFF5EF} \makelabel{anupq:metabelian law}{2.1.5}{X81FBE7ED79EFF5EF} \makelabel{anupq:Engel identity}{2.1.5}{X81FBE7ED79EFF5EF} \makelabel{anupq:labelled pcp}{2.2.1}{X791EB6F77899CB3D} \makelabel{anupq:definition of generator}{2.2.1}{X791EB6F77899CB3D} \makelabel{anupq:tails}{2.2.1}{X791EB6F77899CB3D} \makelabel{anupq:exponent check}{2.2.3}{X7F1A8CCD84462775} \makelabel{anupq:p-group generation}{2.3}{X807FB2EC85E6648D} \makelabel{anupq:orbits}{2.3}{X807FB2EC85E6648D} \makelabel{anupq:standard presentation}{2.3}{X807FB2EC85E6648D} \makelabel{anupq:echelonised matrix}{2.3}{X807FB2EC85E6648D} \makelabel{anupq:label of standard matrix}{2.3}{X807FB2EC85E6648D} \makelabel{anupq:isomorphism testing}{2.3}{X807FB2EC85E6648D} \makelabel{anupq:compaction}{2.3}{X807FB2EC85E6648D} \makelabel{anupq:banner}{3.1}{X833D58248067E13B} \makelabel{anupq:ANUPQData}{3.2.1}{X7B90E89782BDA6D7} \makelabel{anupq:ANUPQDirectoryTemporary}{3.2.2}{X7FBB2F457E4BD6AB} \makelabel{anupq:InfoANUPQ}{3.3.1}{X7CBC9B458497BFF1} \makelabel{anupq:PqLeftNormComm}{3.4.1}{X8771393B7F53F534} \makelabel{anupq:PqGAPRelators}{3.4.2}{X7A567432879510A6} \makelabel{anupq:PqParseWord}{3.4.3}{X7F3C5D1C7EC36EAE} \makelabel{anupq:PqExample no arguments}{3.4.4}{X7BB0EB607F337265} \makelabel{anupq:PqExample}{3.4.4}{X7BB0EB607F337265} \makelabel{anupq:PqExample with filename}{3.4.4}{X7BB0EB607F337265} \makelabel{anupq:AllPqExamples}{3.4.5}{X823C93FC7B87F5BC} \makelabel{anupq:GrepPqExamples}{3.4.6}{X7E3E4B047DC2E323} \makelabel{anupq:ToPQLog}{3.4.7}{X8104B2BA872EFCCB} \makelabel{anupq:NuclearRank}{3.5.1}{X87DC922A78EB0DD6} \makelabel{anupq:MultiplicatorRank}{3.5.1}{X87DC922A78EB0DD6} \makelabel{anupq:IsCapable}{3.5.1}{X87DC922A78EB0DD6} \makelabel{anupq:menu item of pq program}{3.6}{X7BA20FA07B166B37} \makelabel{anupq:option of pq program is a menu item}{3.6}{X7BA20FA07B166B37} \makelabel{anupq:troubleshooting tips}{3.6}{X7BA20FA07B166B37} \makelabel{anupq:ANUPQWarnOfOtherOptions}{3.6.1}{X81F4AAE084C34B4B} \makelabel{anupq:Pq}{4.1.1}{X86DD32D5803CF2C8} \makelabel{anupq:option Prime}{4.1.1}{X86DD32D5803CF2C8} \makelabel{anupq:option ClassBound}{4.1.1}{X86DD32D5803CF2C8} \makelabel{anupq:option Exponent}{4.1.1}{X86DD32D5803CF2C8} \makelabel{anupq:option Relators}{4.1.1}{X86DD32D5803CF2C8} \makelabel{anupq:option Metabelian}{4.1.1}{X86DD32D5803CF2C8} \makelabel{anupq:option Identities}{4.1.1}{X86DD32D5803CF2C8} \makelabel{anupq:option GroupName}{4.1.1}{X86DD32D5803CF2C8} \makelabel{anupq:option OutputLevel}{4.1.1}{X86DD32D5803CF2C8} \makelabel{anupq:option SetupFile}{4.1.1}{X86DD32D5803CF2C8} \makelabel{anupq:option PqWorkspace}{4.1.1}{X86DD32D5803CF2C8} \makelabel{anupq:option Relators example of usage}{4.1.1}{X86DD32D5803CF2C8} \makelabel{anupq:option Identities example of usage}{4.1.1}{X86DD32D5803CF2C8} \makelabel{anupq:PqEpimorphism}{4.1.2}{X7ADE5DDB87B99CC0} \makelabel{anupq:PqPCover}{4.1.3}{X81C3CE1E850DA252} \makelabel{anupq:automorphisms of p-groups}{4.2}{X7F05F8DC79733A8E} \makelabel{anupq:PqStandardPresentation}{4.2.1}{X86C9575D7CB65FBB} \makelabel{anupq:StandardPresentation}{4.2.1}{X86C9575D7CB65FBB} \makelabel{anupq:option Prime}{4.2.1}{X86C9575D7CB65FBB} \makelabel{anupq:option pQuotient}{4.2.1}{X86C9575D7CB65FBB} \makelabel{anupq:option ClassBound}{4.2.1}{X86C9575D7CB65FBB} \makelabel{anupq:option Exponent}{4.2.1}{X86C9575D7CB65FBB} \makelabel{anupq:option Metabelian}{4.2.1}{X86C9575D7CB65FBB} \makelabel{anupq:option GroupName}{4.2.1}{X86C9575D7CB65FBB} \makelabel{anupq:option OutputLevel}{4.2.1}{X86C9575D7CB65FBB} \makelabel{anupq:option StandardPresentationFile}{4.2.1}{X86C9575D7CB65FBB} \makelabel{anupq:option SetupFile}{4.2.1}{X86C9575D7CB65FBB} \makelabel{anupq:option PqWorkspace}{4.2.1}{X86C9575D7CB65FBB} \makelabel{anupq:EpimorphismPqStandardPresentation}{4.2.2}{X828C06D083C0D089} \makelabel{anupq:EpimorphismStandardPresentation}{4.2.2}{X828C06D083C0D089} \makelabel{anupq:IsPqIsomorphicPGroup}{4.3.1}{X854389FC780BB178} \makelabel{anupq:IsIsomorphicPGroup}{4.3.1}{X854389FC780BB178} \makelabel{anupq:PqDescendants}{4.4.1}{X80985CC479CD9FA3} \makelabel{anupq:option ClassBound}{4.4.1}{X80985CC479CD9FA3} \makelabel{anupq:option Relators}{4.4.1}{X80985CC479CD9FA3} \makelabel{anupq:option OrderBound}{4.4.1}{X80985CC479CD9FA3} \makelabel{anupq:option StepSize}{4.4.1}{X80985CC479CD9FA3} \makelabel{anupq:option RankInitialSegmentSubgroups}{4.4.1}{X80985CC479CD9FA3} \makelabel{anupq:option SpaceEfficient}{4.4.1}{X80985CC479CD9FA3} \makelabel{anupq:option CapableDescendants}{4.4.1}{X80985CC479CD9FA3} \makelabel{anupq:option AllDescendants}{4.4.1}{X80985CC479CD9FA3} \makelabel{anupq:option Exponent}{4.4.1}{X80985CC479CD9FA3} \makelabel{anupq:option Metabelian}{4.4.1}{X80985CC479CD9FA3} \makelabel{anupq:option GroupName}{4.4.1}{X80985CC479CD9FA3} \makelabel{anupq:option SubList}{4.4.1}{X80985CC479CD9FA3} \makelabel{anupq:option BasicAlgorithm}{4.4.1}{X80985CC479CD9FA3} \makelabel{anupq:option CustomiseOutput}{4.4.1}{X80985CC479CD9FA3} \makelabel{anupq:option SetupFile}{4.4.1}{X80985CC479CD9FA3} \makelabel{anupq:option PqWorkspace}{4.4.1}{X80985CC479CD9FA3} \makelabel{anupq:PqSupplementInnerAutomorphisms}{4.4.2}{X8364566A80A8C24B} \makelabel{anupq:PqList}{4.4.3}{X79AD54E987FCACBA} \makelabel{anupq:SavePqList}{4.4.4}{X85ADB9E6870EC3D1} \makelabel{anupq:PqStart with group and workspace size}{5.1.1}{X83B2EC237F37623C} \makelabel{anupq:PqStart with group}{5.1.1}{X83B2EC237F37623C} \makelabel{anupq:PqStart with workspace size}{5.1.1}{X83B2EC237F37623C} \makelabel{anupq:PqStart}{5.1.1}{X83B2EC237F37623C} \makelabel{anupq:PqQuit}{5.1.2}{X79DB761185BAB9C8} \makelabel{anupq:PqQuit for default process}{5.1.2}{X79DB761185BAB9C8} \makelabel{anupq:PqQuitAll}{5.1.3}{X7FF8F2657B1B008E} \makelabel{anupq:PqProcessIndex}{5.2.1}{X8558B20A80B999AE} \makelabel{anupq:PqProcessIndex for default process}{5.2.1}{X8558B20A80B999AE} \makelabel{anupq:PqProcessIndices}{5.2.2}{X7E4A56D67C865291} \makelabel{anupq:IsPqProcessAlive}{5.2.3}{X7C103DF78435AEC7} \makelabel{anupq:IsPqProcessAlive for default process}{5.2.3}{X7C103DF78435AEC7} \makelabel{anupq:interruption}{5.2.3}{X7C103DF78435AEC7} \makelabel{anupq:Pq interactive}{5.3.1}{X85408C4C790439E7} \makelabel{anupq:Pq interactive, for default process}{5.3.1}{X85408C4C790439E7} \makelabel{anupq:option Prime}{5.3.1}{X85408C4C790439E7} \makelabel{anupq:option ClassBound}{5.3.1}{X85408C4C790439E7} \makelabel{anupq:option Exponent}{5.3.1}{X85408C4C790439E7} \makelabel{anupq:option Relators}{5.3.1}{X85408C4C790439E7} \makelabel{anupq:option Metabelian}{5.3.1}{X85408C4C790439E7} \makelabel{anupq:option Identities}{5.3.1}{X85408C4C790439E7} \makelabel{anupq:option GroupName}{5.3.1}{X85408C4C790439E7} \makelabel{anupq:option OutputLevel}{5.3.1}{X85408C4C790439E7} \makelabel{anupq:option RedoPcp}{5.3.1}{X85408C4C790439E7} \makelabel{anupq:PqEpimorphism interactive}{5.3.2}{X839E6F578227A8EA} \makelabel{anupq:PqEpimorphism interactive, for default process}{5.3.2}{X839E6F578227A8EA} \makelabel{anupq:PqPCover interactive}{5.3.3}{X7AA64A2F8509A39A} \makelabel{anupq:PqPCover interactive, for default process}{5.3.3}{X7AA64A2F8509A39A} \makelabel{anupq:automorphisms of p-groups}{5.3.3}{X7AA64A2F8509A39A} \makelabel{anupq:PqStandardPresentation interactive}{5.3.4}{X805F32618005C087} \makelabel{anupq:StandardPresentation interactive}{5.3.4}{X805F32618005C087} \makelabel{anupq:option Prime}{5.3.4}{X805F32618005C087} \makelabel{anupq:option pQuotient}{5.3.4}{X805F32618005C087} \makelabel{anupq:option ClassBound}{5.3.4}{X805F32618005C087} \makelabel{anupq:option Exponent}{5.3.4}{X805F32618005C087} \makelabel{anupq:option Metabelian}{5.3.4}{X805F32618005C087} \makelabel{anupq:option GroupName}{5.3.4}{X805F32618005C087} \makelabel{anupq:option OutputLevel}{5.3.4}{X805F32618005C087} \makelabel{anupq:option StandardPresentationFile}{5.3.4}{X805F32618005C087} \makelabel{anupq:EpimorphismPqStandardPresentation interactive}{5.3.5}{X791392977B2D692D} \makelabel{anupq:EpimorphismStandardPresentation interactive}{5.3.5}{X791392977B2D692D} \makelabel{anupq:PqDescendants interactive}{5.3.6}{X795817217C53AB89} \makelabel{anupq:PqDescendants interactive, for default process}{5.3.6}{X795817217C53AB89} \makelabel{anupq:option ClassBound}{5.3.6}{X795817217C53AB89} \makelabel{anupq:option Relators}{5.3.6}{X795817217C53AB89} \makelabel{anupq:option OrderBound}{5.3.6}{X795817217C53AB89} \makelabel{anupq:option StepSize}{5.3.6}{X795817217C53AB89} \makelabel{anupq:option RankInitialSegmentSubgroups}{5.3.6}{X795817217C53AB89} \makelabel{anupq:option SpaceEfficient}{5.3.6}{X795817217C53AB89} \makelabel{anupq:option CapableDescendants}{5.3.6}{X795817217C53AB89} \makelabel{anupq:option AllDescendants}{5.3.6}{X795817217C53AB89} \makelabel{anupq:option Exponent}{5.3.6}{X795817217C53AB89} \makelabel{anupq:option Metabelian}{5.3.6}{X795817217C53AB89} \makelabel{anupq:option GroupName}{5.3.6}{X795817217C53AB89} \makelabel{anupq:option SubList}{5.3.6}{X795817217C53AB89} \makelabel{anupq:option BasicAlgorithm}{5.3.6}{X795817217C53AB89} \makelabel{anupq:option CustomiseOutput}{5.3.6}{X795817217C53AB89} \makelabel{anupq:PqSetPQuotientToGroup}{5.3.7}{X80CCF6D379E5A3B4} \makelabel{anupq:PqSetPQuotientToGroup for default process}{5.3.7}{X80CCF6D379E5A3B4} \makelabel{anupq:PqNrPcGenerators}{5.5.1}{X7DE2F6C686C672DD} \makelabel{anupq:PqNrPcGenerators for default process}{5.5.1}{X7DE2F6C686C672DD} \makelabel{anupq:PqFactoredOrder}{5.5.2}{X87FF98867E8FFB3C} \makelabel{anupq:PqFactoredOrder for default process}{5.5.2}{X87FF98867E8FFB3C} \makelabel{anupq:PqOrder}{5.5.3}{X7B4FC9E380001A71} \makelabel{anupq:PqOrder for default process}{5.5.3}{X7B4FC9E380001A71} \makelabel{anupq:PqPClass}{5.5.4}{X87C7F7EB7C10DC4B} \makelabel{anupq:PqPClass for default process}{5.5.4}{X87C7F7EB7C10DC4B} \makelabel{anupq:PqWeight}{5.5.5}{X7EA3B6917908C20A} \makelabel{anupq:PqWeight for default process}{5.5.5}{X7EA3B6917908C20A} \makelabel{anupq:PqCurrentGroup}{5.5.6}{X79862B83817E20E1} \makelabel{anupq:PqCurrentGroup for default process}{5.5.6}{X79862B83817E20E1} \makelabel{anupq:PqDisplayPcPresentation}{5.5.7}{X805A50687D82B9EC} \makelabel{anupq:PqDisplayPcPresentation for default process}{5.5.7}{X805A50687D82B9EC} \makelabel{anupq:PqSetOutputLevel}{5.5.8}{X80410979854280E1} \makelabel{anupq:PqSetOutputLevel for default process}{5.5.8}{X80410979854280E1} \makelabel{anupq:PqEvaluateIdentities}{5.5.9}{X7B8C72B37AE667F7} \makelabel{anupq:PqEvaluateIdentities for default process}{5.5.9}{X7B8C72B37AE667F7} \makelabel{anupq:PqPcPresentation}{5.6.1}{X7BF135DD84A781EB} \makelabel{anupq:PqPcPresentation for default process}{5.6.1}{X7BF135DD84A781EB} \makelabel{anupq:PqSavePcPresentation}{5.6.2}{X7D947CEA82C44898} \makelabel{anupq:PqSavePcPresentation for default process}{5.6.2}{X7D947CEA82C44898} \makelabel{anupq:PqRestorePcPresentation}{5.6.3}{X7FD001C0798EF219} \makelabel{anupq:PqRestorePcPresentation for default process}{5.6.3}{X7FD001C0798EF219} \makelabel{anupq:PqNextClass}{5.6.4}{X832F69597C095A27} \makelabel{anupq:PqNextClass for default process}{5.6.4}{X832F69597C095A27} \makelabel{anupq:option QueueFactor}{5.6.4}{X832F69597C095A27} \makelabel{anupq:PqComputePCover}{5.6.5}{X7CF9DF7A84D387CB} \makelabel{anupq:PqComputePCover for default process}{5.6.5}{X7CF9DF7A84D387CB} \makelabel{anupq:PqCollect}{5.7.1}{X8633356078CA4115} \makelabel{anupq:PqCollect for default process}{5.7.1}{X8633356078CA4115} \makelabel{anupq:PqSolveEquation}{5.7.2}{X86CCB77281FDC0FC} \makelabel{anupq:PqSolveEquation for default process}{5.7.2}{X86CCB77281FDC0FC} \makelabel{anupq:PqCommutator}{5.7.3}{X789B120B7E2F3017} \makelabel{anupq:PqCommutator for default process}{5.7.3}{X789B120B7E2F3017} \makelabel{anupq:PqSetupTablesForNextClass}{5.7.4}{X7A61A15E78F52743} \makelabel{anupq:PqSetupTablesForNextClass for default process}{5.7.4}{X7A61A15E78F52743} \makelabel{anupq:PqTails}{5.7.5}{X84F7DD8582B368D3} \makelabel{anupq:PqTails for default process}{5.7.5}{X84F7DD8582B368D3} \makelabel{anupq:PqComputeTails}{5.7.6}{X8389F6437ED634B8} \makelabel{anupq:PqComputeTails for default process}{5.7.6}{X8389F6437ED634B8} \makelabel{anupq:PqAddTails}{5.7.7}{X83CD6D888372DFB8} \makelabel{anupq:PqAddTails for default process}{5.7.7}{X83CD6D888372DFB8} \makelabel{anupq:PqDoConsistencyChecks}{5.7.8}{X82AA8FAE85826BB9} \makelabel{anupq:PqDoConsistencyChecks for default process}{5.7.8}{X82AA8FAE85826BB9} \makelabel{anupq:PqCollectDefiningRelations}{5.7.9}{X7A01EE0382689928} \makelabel{anupq:PqCollectDefiningRelations for default process}{5.7.9}{X7A01EE0382689928} \makelabel{anupq:PqCollectWordInDefiningGenerators}{5.7.10}{X7C2B4C1E7BEB19D5} \makelabel{anupq:PqCollectWordInDefiningGenerators for default process}{5.7.10}{X7C2B4C1E7BEB19D5} \makelabel{anupq:PqCommutatorDefiningGenerators}{5.7.11}{X7DB05AA587D7A052} \makelabel{anupq:PqCommutatorDefiningGenerators for default process}{5.7.11}{X7DB05AA587D7A052} \makelabel{anupq:PqDoExponentChecks}{5.7.12}{X80E563A97EDE083E} \makelabel{anupq:PqDoExponentChecks for default process}{5.7.12}{X80E563A97EDE083E} \makelabel{anupq:PqEliminateRedundantGenerators}{5.7.13}{X7BBAB2787B305516} \makelabel{anupq:PqEliminateRedundantGenerators for default process}{5.7.13}{X7BBAB2787B305516} \makelabel{anupq:PqRevertToPreviousClass}{5.7.14}{X783E53B5853F45E6} \makelabel{anupq:PqRevertToPreviousClass for default process}{5.7.14}{X783E53B5853F45E6} \makelabel{anupq:PqSetMaximalOccurrences}{5.7.15}{X8265A6DB81CD24DB} \makelabel{anupq:PqSetMaximalOccurrences for default process}{5.7.15}{X8265A6DB81CD24DB} \makelabel{anupq:PqSetMetabelian}{5.7.16}{X87A35ABB7E11595E} \makelabel{anupq:PqSetMetabelian for default process}{5.7.16}{X87A35ABB7E11595E} \makelabel{anupq:PqDoConsistencyCheck}{5.7.17}{X7C7D17F878AA1BAA} \makelabel{anupq:PqDoConsistencyCheck for default process}{5.7.17}{X7C7D17F878AA1BAA} \makelabel{anupq:PqJacobi}{5.7.17}{X7C7D17F878AA1BAA} \makelabel{anupq:PqJacobi for default process}{5.7.17}{X7C7D17F878AA1BAA} \makelabel{anupq:PqCompact}{5.7.18}{X843953F48319FDE1} \makelabel{anupq:PqCompact for default process}{5.7.18}{X843953F48319FDE1} \makelabel{anupq:PqEchelonise}{5.7.19}{X80344EEC78A09ACF} \makelabel{anupq:PqEchelonise for default process}{5.7.19}{X80344EEC78A09ACF} \makelabel{anupq:PqSupplyAutomorphisms}{5.7.20}{X852947327FC39DDF} \makelabel{anupq:PqSupplyAutomorphisms for default process}{5.7.20}{X852947327FC39DDF} \makelabel{anupq:PqExtendAutomorphisms}{5.7.21}{X7B919B537C042DAD} \makelabel{anupq:PqExtendAutomorphisms for default process}{5.7.21}{X7B919B537C042DAD} \makelabel{anupq:PqApplyAutomorphisms}{5.7.22}{X7CFD54657DE4BD39} \makelabel{anupq:PqApplyAutomorphisms for default process}{5.7.22}{X7CFD54657DE4BD39} \makelabel{anupq:PqDisplayStructure}{5.7.23}{X81A3D5BF87A34934} \makelabel{anupq:PqDisplayStructure for default process}{5.7.23}{X81A3D5BF87A34934} \makelabel{anupq:PqDisplayAutomorphisms}{5.7.24}{X853834B478C4EEE2} \makelabel{anupq:PqDisplayAutomorphisms for default process}{5.7.24}{X853834B478C4EEE2} \makelabel{anupq:PqWritePcPresentation}{5.7.25}{X80687A138626EB2D} \makelabel{anupq:PqWritePcPresentation for default process}{5.7.25}{X80687A138626EB2D} \makelabel{anupq:PqSPComputePcpAndPCover}{5.8.1}{X78D1963D85C71B7B} \makelabel{anupq:PqSPComputePcpAndPCover for default process}{5.8.1}{X78D1963D85C71B7B} \makelabel{anupq:PqSPStandardPresentation}{5.8.2}{X876F30187E89E467} \makelabel{anupq:PqSPStandardPresentation for default process}{5.8.2}{X876F30187E89E467} \makelabel{anupq:option ClassBound}{5.8.2}{X876F30187E89E467} \makelabel{anupq:option PcgsAutomorphisms}{5.8.2}{X876F30187E89E467} \makelabel{anupq:option StandardPresentationFile}{5.8.2}{X876F30187E89E467} \makelabel{anupq:PqSPSavePresentation}{5.8.3}{X7E1B2B088322F48A} \makelabel{anupq:PqSPSavePresentation for default process}{5.8.3}{X7E1B2B088322F48A} \makelabel{anupq:PqSPCompareTwoFilePresentations}{5.8.4}{X81D2F9FF7C241D1E} \makelabel{anupq:PqSPCompareTwoFilePresentations for default process}{5.8.4}{X81D2F9FF7C241D1E} \makelabel{anupq:PqSPIsomorphism}{5.8.5}{X7D1277E584590ECE} \makelabel{anupq:PqSPIsomorphism for default process}{5.8.5}{X7D1277E584590ECE} \makelabel{anupq:PqPGSupplyAutomorphisms}{5.9.1}{X794A8D667A9D725A} \makelabel{anupq:PqPGSupplyAutomorphisms for default process}{5.9.1}{X794A8D667A9D725A} \makelabel{anupq:PqPGExtendAutomorphisms}{5.9.2}{X87F251077C65B6DD} \makelabel{anupq:PqPGExtendAutomorphisms for default process}{5.9.2}{X87F251077C65B6DD} \makelabel{anupq:PqPGConstructDescendants}{5.9.3}{X82FD51A27D269E43} \makelabel{anupq:PqPGConstructDescendants for default process}{5.9.3}{X82FD51A27D269E43} \makelabel{anupq:PqPGSetDescendantToPcp with class}{5.9.4}{X7E9D511385D48A98} \makelabel{anupq:PqPGSetDescendantToPcp with class, for default process}{5.9.4}{X7E9D511385D48A98} \makelabel{anupq:PqPGSetDescendantToPcp}{5.9.4}{X7E9D511385D48A98} \makelabel{anupq:PqPGSetDescendantToPcp for default process}{5.9.4}{X7E9D511385D48A98} \makelabel{anupq:PqPGRestoreDescendantFromFile with class}{5.9.4}{X7E9D511385D48A98} \makelabel{anupq:PqPGRestoreDescendantFromFile with class, for default process}{5.9.4}{X7E9D511385D48A98} \makelabel{anupq:PqPGRestoreDescendantFromFile}{5.9.4}{X7E9D511385D48A98} \makelabel{anupq:PqPGRestoreDescendantFromFile for default process}{5.9.4}{X7E9D511385D48A98} \makelabel{anupq:PqAPGDegree}{5.10.1}{X7E539E4B78A6CE8D} \makelabel{anupq:PqAPGDegree for default process}{5.10.1}{X7E539E4B78A6CE8D} \makelabel{anupq:PqAPGPermutations}{5.10.2}{X7F1182A77AB7650C} \makelabel{anupq:PqAPGPermutations for default process}{5.10.2}{X7F1182A77AB7650C} \makelabel{anupq:PqAPGOrbits}{5.10.3}{X7DD9E7507AA888CC} \makelabel{anupq:PqAPGOrbits for default process}{5.10.3}{X7DD9E7507AA888CC} \makelabel{anupq:PqAPGOrbitRepresentatives}{5.10.4}{X795A756C78BE5923} \makelabel{anupq:PqAPGOrbitRepresentatives for default process}{5.10.4}{X795A756C78BE5923} \makelabel{anupq:PqAPGSingleStage}{5.10.5}{X7E5D6D5782FE190E} \makelabel{anupq:PqAPGSingleStage for default process}{5.10.5}{X7E5D6D5782FE190E} \makelabel{anupq:PqRead}{5.11.1}{X8464AF7E83A523C1} \makelabel{anupq:PqRead for default process}{5.11.1}{X8464AF7E83A523C1} \makelabel{anupq:PqReadAll}{5.11.2}{X7ADD82207D049A87} \makelabel{anupq:PqReadAll for default process}{5.11.2}{X7ADD82207D049A87} \makelabel{anupq:PqReadUntil}{5.11.3}{X7EBF3C3681671879} \makelabel{anupq:PqReadUntil for default process}{5.11.3}{X7EBF3C3681671879} \makelabel{anupq:PqReadUntil with modify map}{5.11.3}{X7EBF3C3681671879} \makelabel{anupq:PqReadUntil with modify map, for default process}{5.11.3}{X7EBF3C3681671879} \makelabel{anupq:PqWrite}{5.11.4}{X83CBE77F78057E21} \makelabel{anupq:PqWrite for default process}{5.11.4}{X83CBE77F78057E21} \makelabel{anupq:AllANUPQoptions}{6.1.1}{X7846E25D8065D78F} \makelabel{anupq:ANUPQoptions}{6.1.2}{X82D560C77D195089} \makelabel{anupq:option Prime}{6.2}{X87EE6DD67C9996A3} \makelabel{anupq:option ClassBound}{6.2}{X87EE6DD67C9996A3} \makelabel{anupq:option pQuotient}{6.2}{X87EE6DD67C9996A3} \makelabel{anupq:option Exponent}{6.2}{X87EE6DD67C9996A3} \makelabel{anupq:option Relators}{6.2}{X87EE6DD67C9996A3} \makelabel{anupq:option Metabelian}{6.2}{X87EE6DD67C9996A3} \makelabel{anupq:option GroupName}{6.2}{X87EE6DD67C9996A3} \makelabel{anupq:option Identities}{6.2}{X87EE6DD67C9996A3} \makelabel{anupq:option OutputLevel}{6.2}{X87EE6DD67C9996A3} \makelabel{anupq:option RedoPcp}{6.2}{X87EE6DD67C9996A3} \makelabel{anupq:option SetupFile}{6.2}{X87EE6DD67C9996A3} \makelabel{anupq:option PqWorkspace}{6.2}{X87EE6DD67C9996A3} \makelabel{anupq:option PcgsAutomorphisms}{6.2}{X87EE6DD67C9996A3} \makelabel{anupq:option OrderBound}{6.2}{X87EE6DD67C9996A3} \makelabel{anupq:option StepSize}{6.2}{X87EE6DD67C9996A3} \makelabel{anupq:option RankInitialSegmentSubgroups}{6.2}{X87EE6DD67C9996A3} \makelabel{anupq:option SpaceEfficient}{6.2}{X87EE6DD67C9996A3} \makelabel{anupq:option CapableDescendants}{6.2}{X87EE6DD67C9996A3} \makelabel{anupq:option AllDescendants}{6.2}{X87EE6DD67C9996A3} \makelabel{anupq:option TreeDepth}{6.2}{X87EE6DD67C9996A3} \makelabel{anupq:option SubList}{6.2}{X87EE6DD67C9996A3} \makelabel{anupq:option NumberOfSolubleAutomorphisms}{6.2}{X87EE6DD67C9996A3} \makelabel{anupq:option RelativeOrders}{6.2}{X87EE6DD67C9996A3} \makelabel{anupq:option BasicAlgorithm}{6.2}{X87EE6DD67C9996A3} \makelabel{anupq:option CustomiseOutput}{6.2}{X87EE6DD67C9996A3} \makelabel{anupq:option StandardPresentationFile}{6.2}{X87EE6DD67C9996A3} \makelabel{anupq:option QueueFactor}{6.2}{X87EE6DD67C9996A3} \makelabel{anupq:option Bounds}{6.2}{X87EE6DD67C9996A3} \makelabel{anupq:option PrintAutomorphisms}{6.2}{X87EE6DD67C9996A3} \makelabel{anupq:option PrintPermutations}{6.2}{X87EE6DD67C9996A3} \makelabel{anupq:option Filename}{6.2}{X87EE6DD67C9996A3} \makelabel{anupq:ANUPQGAPEXEC environment variable}{7}{X7FB487238298CF42} \makelabel{anupq:ANUPQGAPEXEC environment variable}{7.1}{X854577C8800DC7C2} \makelabel{anupq:ANUPQGAPEXEC environment variable}{7.2}{X82906B5184C61063} \makelabel{anupq:B(5,4)}{A.3}{X7A997D1A8532A84B} \makelabel{anupq:PqDescendantsTreeCoclassOne}{A.4.1}{X805E6B418193CF2D} \makelabel{anupq:PqDescendantsTreeCoclassOne for default process}{A.4.1}{X805E6B418193CF2D} anupq-3.3.3/doc/chap4.txt0000644000175100017510000012560015111342310014552 0ustar runnerrunner 4 Non-interactive ANUPQ functions Here we describe all the non-interactive functions of the ANUPQ package; i.e. one-shot functions that invoke the pq program in such a way that once GAP has got what it needs, the pq program is allowed to exit. It is expected that most of the time users will only need these functions. The functions interface with three of the four algorithms (see Chapter 'Introduction') provided by the ANU pq C program, and are mainly grouped according to the algorithm of the pq program they relate to. In Section 'Computing p-Quotients', we describe the functions that give access to the p-quotient algorithm. Section 'Computing Standard Presentations' describe functions that give access to the standard presentation algorithm. Section 'Testing p-Groups for Isomorphism' describe functions that implement an isomorphism test for p-groups using the standard presentation algorithm. In Section 'Computing Descendants of a p-Group', we describe functions that give access to the p-group generation algorithm. To use any of the functions one must have at some stage previously typed:  Example  gap> LoadPackage("anupq");  (the response of which we have omitted; see 'Loading the ANUPQ Package'). It is strongly recommended that the user try the examples provided. To save typing there is a PqExample equivalent for each manual example. We also suggest that to start with you may find the examples more instructive if you set the InfoANUPQ level to 2 (see InfoANUPQ (3.3-1)). 4.1 Computing p-Quotients 4.1-1 Pq Pq( F: options )  function returns for the fp or pc group F, the p-quotient of F specified by options, as a pc group. Following the colon, options is a selection of the options from the following list, separated by commas like record components (see Section Reference: Function Call With Options in the GAP Reference Manual). As a minimum the user must supply a value for the Prime option. Below we list the options recognised by Pq (see Chapter 'ANUPQ Options' for detailed descriptions).  Prime := p  ClassBound := n  Exponent := n  Relators := rels  Metabelian  Identities := funcs  GroupName := name  OutputLevel := n  SetupFile := filename  PqWorkspace := workspace Notes: Pq may also be called with no arguments or one integer argument, in which case it is being used interactively (see Pq (5.3-1)); the same options may be used, except that SetupFile and PqWorkspace are ignored by the interactive Pq function. See Section 'Attributes and a Property for fp and pc p-groups' for the attributes and property NuclearRank, MultiplicatorRank and IsCapable which may be applied to the group returned by Pq. See also PqEpimorphism (PqEpimorphism (4.1-2)). We now give a few examples of the use of Pq. Except for the addition of a few comments and the non-suppression of output (by not using duplicated semicolons) the next 3 examples may be run by typing: PqExample( "Pq" ); (see PqExample (3.4-4)).  Example  gap> LoadPackage("anupq");; # does nothing if ANUPQ is already loaded gap> # First we get a p-quotient of a free group of rank 2 gap> F := FreeGroup("a", "b");; a := F.1;; b := F.2;; gap> Pq( F : Prime := 2, ClassBound := 3 );   gap> # Now let us get a p-quotient of an fp group gap> G := F / [a^4, b^4];  gap> Pq( G : Prime := 2, ClassBound := 3 );   gap> # Now let's get a different p-quotient of the same group gap> Pq( G : Prime := 2, ClassBound := 3, Exponent := 4 );   gap> # Now we'll get a p-quotient of another fp group gap> # which we will redo using the `Relators' option gap> R := [ a^25, Comm(Comm(b, a), a), b^5 ]; [ a^25, a^-1*b^-1*a*b*a^-1*b^-1*a^-1*b*a^2, b^5 ] gap> H := F / R;  gap> Pq( H : Prime := 5, ClassBound := 5, Metabelian );   Now we redo the last example to show how one may use the Relators option. Observe that Comm(Comm(b, a), a) is a left normed commutator which must be written in square bracket notation for the pq program and embedded in a pair of double quotes. The function PqGAPRelators (see PqGAPRelators (3.4-2)) can be used to translate a list of strings prepared for the Relators option into GAP format. Below we use it. Observe that the value of R is the same as before.  Example  gap> F := FreeGroup("a", "b");; gap> # `F' was defined for `Relators'. We use the same strings that GAP uses gap> # for printing the free group generators. It is *not* necessary to gap> # predefine: a := F.1; etc. (as it was above). gap> rels := [ "a^25", "[b, a, a]", "b^5" ]; [ "a^25", "[b, a, a]", "b^5" ] gap> R := PqGAPRelators(F, rels); [ a^25, a^-1*b^-1*a*b*a^-1*b^-1*a^-1*b*a^2, b^5 ] gap> H := F / R;  gap> Pq( H : Prime := 5, ClassBound := 5, Metabelian,  >  Relators := rels );   In fact, above we could have just passed F (rather than H), i.e. we could have done:  Example  gap> F := FreeGroup("a", "b");; gap> rels := [ "a^25", "[b, a, a]", "b^5" ]; [ "a^25", "[b, a, a]", "b^5" ] gap> Pq( F : Prime := 5, ClassBound := 5, Metabelian,  >  Relators := rels );   The non-interactive Pq function also allows the options to be passed in two other ways; these alternatives have been included for those familiar with the GAP 3 version of the ANUPQ package; the preferred method of passing options is the one already described. Firstly, they may be passed in a record as a second argument; note that any boolean options must be set explicitly e.g.  Example  gap> Pq( H, rec( Prime := 5, ClassBound := 5, Metabelian := true ) );   It is also possible to pass them as extra arguments, where each option name appears as a string followed immediately by its value (if not a boolean option) e.g.  Example  gap> Pq( H, "Prime", 5, "ClassBound", 5, "Metabelian" );   The preceding two examples can be run from GAP via PqExample( "Pq-ni" ); (see PqExample (3.4-4)). This method of passing options permits abbreviation; the only restriction is that the abbreviation must be unique. So "Pr" may be used for "Prime", "Class" or even just "C" for "ClassBound", etc. The following example illustrates the use of the option Identities. We compute the largest finite Burnside group of exponent 5 that also satisfies the 3-Engel identity. Each identity is defined by a function whose arguments correspond to the variables of the identity. The return value of each of those functions is the identity evaluated on the arguments of the function.  Example  gap> F := FreeGroup(2);  gap> Burnside5 := x->x^5; function( x ) ... end gap> Engel3 := function( x,y ) return PqLeftNormComm( [x,y,y,y] ); end; function( x, y ) ... end gap> Pq( F : Prime := 5, Identities := [ Burnside5, Engel3 ] ); #I Class 1 with 2 generators. #I Class 2 with 3 generators. #I Class 3 with 5 generators. #I Class 3 with 5 generators.   The above example can be run from GAP via PqExample( "B5-5-Engel3-Id" ); (see PqExample (3.4-4)). 4.1-2 PqEpimorphism PqEpimorphism( F: options )  function returns for the fp or pc group F an epimorphism from F onto the p-quotient of F specified by options; the possible options options and required option ("Prime") are as for Pq (see Pq (4.1-1)). PqEpimorphism only differs from Pq in what it outputs; everything about what must/may be passed as input to PqEpimorphism is the same as for Pq. The same alternative methods of passing options to the non-interactive Pq function are available to the non-interactive version of PqEpimorphism. Notes: PqEpimorphism may also be called with no arguments or one integer argument, in which case it is being used interactively (see PqEpimorphism (5.3-2)), and the options SetupFile and PqWorkspace are ignored by the interactive PqEpimorphism function. See Section 'Attributes and a Property for fp and pc p-groups' for the attributes and property NuclearRank, MultiplicatorRank and IsCapable which may be applied to the image group of the epimorphism returned by PqEpimorphism.  Example  gap> F := FreeGroup (2, "F");  gap> phi := PqEpimorphism( F : Prime := 5, ClassBound := 2 ); [ F1, F2 ] -> [ f1, f2 ] gap> Image( phi );   Typing: PqExample( "PqEpimorphism" ); runs the above example in GAP (see PqExample (3.4-4)). 4.1-3 PqPCover PqPCover( F: options )  function returns for the fp or pc group F, the p-covering group of the p-quotient of F specified by options, as a pc group, i.e. the p-covering group of the p-quotient Pq( F : options ). Thus the options that PqPCover accepts are exactly those expected for Pq (and hence as a minimum the user must supply a value for the Prime option; see Pq (4.1-1) for more details), except in the following special case. If F is already a p-group, in the sense that IsPGroup(F) is true, then Prime defaults to PrimePGroup(F), if not supplied and HasPrimePGroup(F) = true; and ClassBound defaults to PClassPGroup(F) if HasPClassPGroup(F) = true if not supplied, or to the usual default of 63, otherwise. The same alternative methods of passing options to the non-interactive Pq function are available to the non-interactive version of PqPCover. We now give a few examples of the use of PqPCover. These examples are just a subset of the ones we gave for Pq (see Pq (4.1-1)), except that in each instance the command Pq has been replaced with PqPCover. Essentially the same examples may be run by typing: PqExample( "PqPCover" ); (see PqExample (3.4-4)).  Example  gap> F := FreeGroup("a", "b");; a := F.1;; b := F.2;; gap> PqPCover( F : Prime := 2, ClassBound := 3 );  gap>  gap> # Now let's get a p-cover of a p-quotient of an fp group gap> G := F / [a^4, b^4];  gap> PqPCover( G : Prime := 2, ClassBound := 3 );  gap>  gap> # Now let's get a p-cover of a different p-quotient of the same group gap> PqPCover( G : Prime := 2, ClassBound := 3, Exponent := 4 );  gap>  gap> # Now we'll get a p-cover of a p-quotient of another fp group gap> # which we will redo using the `Relators' option gap> R := [ a^25, Comm(Comm(b, a), a), b^5 ]; [ a^25, a^-1*b^-1*a*b*a^-1*b^-1*a^-1*b*a^2, b^5 ] gap> H := F / R;  gap> PqPCover( H : Prime := 5, ClassBound := 5, Metabelian );  gap>  gap> # Now we redo the previous example using the `Relators' option gap> F := FreeGroup("a", "b");; gap> rels := [ "a^25", "[b, a, a]", "b^5" ]; [ "a^25", "[b, a, a]", "b^5" ] gap> PqPCover( F : Prime := 5, ClassBound := 5, Metabelian,  >  Relators := rels );   4.2 Computing Standard Presentations 4.2-1 PqStandardPresentation PqStandardPresentation( F: options )  function StandardPresentation( F: options )  method return the p-quotient specified by options of the fp or pc p-group F, as an fp group which has a standard presentation. Here options is a selection of the options from the following list (see Chapter 'ANUPQ Options' for detailed descriptions). Section 'Hints and Warnings regarding the use of Options' gives some important hints and warnings regarding option usage, and Section Reference: Function Call With Options in the GAP Reference Manual describes their record-like syntax.  Prime := p  pQuotient := Q  ClassBound := n  Exponent := n  Metabelian  GroupName := name  OutputLevel := n  StandardPresentationFile := filename  SetupFile := filename  PqWorkspace := workspace Unless F is a pc p-group, the user must supply either the option Prime or the option pQuotient (if both Prime and pQuotient are supplied, the prime p is determined by applying PrimePGroup (see PrimePGroup (Reference: PrimePGroup) in the Reference Manual) to the value of pQuotient). The options for PqStandardPresentation may also be passed in the two other alternative ways described for Pq (see Pq (4.1-1)). StandardPresentation does not provide these alternative ways of passing options. Notes: In contrast to the function Pq (see Pq (4.1-1)) which returns a pc group, PqStandardPresentation or StandardPresentation returns an fp group. This is because the output is mainly used for isomorphism testing for which an fp group is enough. However, the presentation is a polycyclic presentation and if you need to do any further computation with this group (e.g. to find the order) you can use the function PcGroupFpGroup (see PcGroupFpGroup (Reference: PcGroupFpGroup) in the GAP Reference Manual) to form a pc group. If the user does not supply a p-quotient Q via the pQuotient option and the prime p is either supplied or F is a pc p-group, then a p-quotient Q is computed. If the user does supply a p-quotient Q via the pQuotient option, the package AutPGrp is called to compute the automorphism group of Q; an error will occur that asks the user to install the package AutPGrp if the automorphism group cannot be computed. The attributes and property NuclearRank, MultiplicatorRank and IsCapable are set for the group returned by PqStandardPresentation or StandardPresentation (see Section 'Attributes and a Property for fp and pc p-groups'). We illustrate the method with the following examples.  Example  gap> F := FreeGroup( "a", "b" );; a := F.1;; b := F.2;; gap> G := F / [a^25, Comm(Comm(b, a), a), b^5];  gap> S := StandardPresentation( G : Prime := 5, ClassBound := 10 );  gap> IsPcGroup( S ); false gap> # if we need to compute with S we should convert it to a pc group gap> Spc := PcGroupFpGroup( S );  gap>  gap> H := F / [ a^625, Comm(Comm(Comm(Comm(b, a), a), a), a)/Comm(b, a)^5, >  Comm(Comm(b, a), b), b^625 ];; gap> StandardPresentation( H : Prime := 5, ClassBound := 15, Metabelian );  gap>  gap> F4 := FreeGroup( "a", "b", "c", "d" );; gap> a := F4.1;; b := F4.2;; c := F4.3;; d := F4.4;; gap> G4 := F4 / [ b^4, b^2 / Comm(Comm (b, a), a), d^16, >  a^16 / (c * d), b^8 / (d * c^4) ];  gap> K := Pq( G4 : Prime := 2, ClassBound := 1 );  gap> StandardPresentation( G4 : pQuotient := K, ClassBound := 14 );   Typing: PqExample( "StandardPresentation" ); runs the above example in GAP (see PqExample (3.4-4)). 4.2-2 EpimorphismPqStandardPresentation EpimorphismPqStandardPresentation( F: options )  function EpimorphismStandardPresentation( F: options )  method Each of the above functions accepts the same arguments and options as the function StandardPresentation (see StandardPresentation (4.2-1)) and returns an epimorphism from the fp or pc group F onto the finitely presented group given by a standard presentation, i.e. if S is the standard presentation computed for the p-quotient of F by StandardPresentation then EpimorphismStandardPresentation returns the epimorphism from F to the group with presentation S. Note: The attributes and property NuclearRank, MultiplicatorRank and IsCapable are set for the image group of the epimorphism returned by EpimorphismPqStandardPresentation or EpimorphismStandardPresentation (see Section 'Attributes and a Property for fp and pc p-groups'). We illustrate the function with the following example.  Example  gap> F := FreeGroup(6, "F");  gap> # For printing GAP uses the symbols F1, ... for the generators of F gap> x := F.1;; y := F.2;; z := F.3;; w := F.4;; a := F.5;; b := F.6;; gap> R := [x^3 / w, y^3 / w * a^2 * b^2, w^3 / b, >  Comm (y, x) / z, Comm (z, x), Comm (z, y) / a, z^3 ];; gap> Q := F / R;  gap> # For printing GAP also uses the symbols F1, ... for the generators of Q gap> # (the same as used for F) ... but the gen'rs of Q and F are different: gap> GeneratorsOfGroup(F) = GeneratorsOfGroup(Q); false gap> G := Pq( Q : Prime := 3, ClassBound := 3 );  gap> phi := EpimorphismStandardPresentation( Q : Prime := 3, >  ClassBound := 3 ); [ F1, F2, F3, F4, F5, F6 ] -> [ f1*f2^2*f3*f4^2*f5^2, f1*f2*f3*f5, f3^2,   f4*f6^2, f5, f6 ] gap> Source(phi); # This is the group Q (GAP uses F1, ... for gen'r symbols)  gap> Range(phi); # This is the group G (GAP uses f1, ... for gen'r symbols)  gap> AssignGeneratorVariables(G); #I Assigned the global variables [ f1, f2, f3, f4, f5, f6 ] gap> # Just to see that the images of [F1, ..., F6] do generate G gap> Group([ f1*f2^2*f3, f1*f2*f3*f4*f5^2*f6^2, f3^2, f4, f5, f6 ]) = G; true gap> Size( Image(phi) ); 729  Typing: PqExample( "EpimorphismStandardPresentation" ); runs the above example in GAP (see PqExample (3.4-4)). Note that AssignGeneratorVariables (see AssignGeneratorVariables (Reference: AssignGeneratorVariables)) has only been available since GAP 4.3. 4.3 Testing p-Groups for Isomorphism 4.3-1 IsPqIsomorphicPGroup IsPqIsomorphicPGroup( G, H )  function IsIsomorphicPGroup( G, H )  method each return true if G is isomorphic to H, where both G and H must be pc groups of prime power order. These functions compute and compare in GAP the fp groups given by standard presentations for G and H (see StandardPresentation (4.2-1)).  Example  gap> G := Group( (1,2,3,4), (1,3) ); Group([ (1,2,3,4), (1,3) ]) gap> P1 := Image( IsomorphismPcGroup( G ) ); Group([ f1, f2, f3 ]) gap> P2 := ElementaryAbelianGroup( 8 );  gap> IsIsomorphicPGroup( P1, P2 ); false gap> P3 := QuaternionGroup( 8 );  gap> IsIsomorphicPGroup( P1, P3 ); false gap> P4 := DihedralGroup( 8 );  gap> IsIsomorphicPGroup( P1, P4 ); true  Typing: PqExample( "IsIsomorphicPGroup" ); runs the above example in GAP (see PqExample (3.4-4)). 4.4 Computing Descendants of a p-Group 4.4-1 PqDescendants PqDescendants( G: options )  function returns, for the pc group G which must be of prime power order with a confluent pc presentation (see IsConfluent (Reference: IsConfluent for pc groups) in the GAP Reference Manual), a list of proper descendants (pc groups) of G. Following the colon options a selection of the options listed below should be given, separated by commas like record components (see Section Reference: Function Call With Options in the GAP Reference Manual). See Chapter 'ANUPQ Options' for detailed descriptions of the options. The automorphism group of each descendant D is also computed via a call to the AutomorphismGroupPGroup function of the AutPGrp package.  ClassBound := n  Relators := rels  OrderBound := n  StepSize := n, StepSize := list  RankInitialSegmentSubgroups := n  SpaceEfficient  CapableDescendants  AllDescendants := false  Exponent := n  Metabelian  GroupName := name  SubList := sub  BasicAlgorithm  CustomiseOutput := rec  SetupFile := filename  PqWorkspace := workspace Notes: The function PqDescendants uses the automorphism group of G which it computes via the package AutPGrp. If this package is not installed an error may be raised. If the automorphism group of G is insoluble, the pq program will call GAP together with the AutPGrp package for certain orbit-stabilizer calculations. (So, in any case, one should ensure the AutPGrp package is installed.) The attributes and property NuclearRank, MultiplicatorRank and IsCapable are set for each group of the list returned by PqDescendants (see Section 'Attributes and a Property for fp and pc p-groups'). The options options for PqDescendants may be passed in an alternative manner to that already described, namely you can pass PqDescendants a record as an argument, which contains as entries some (or all) of the above mentioned. Those parameters which do not occur in the record are set to their default values. Note that you cannot set both OrderBound and StepSize. In the first example we compute all proper descendants of the Klein four group which have exponent-2 class at most 5 and order at most 2^6.  Example  gap> F := FreeGroup( "a", "b" );; a := F.1;; b := F.2;; gap> G := PcGroupFpGroup( F / [ a^2, b^2, Comm(b, a) ] );  gap> des := PqDescendants( G : OrderBound := 6, ClassBound := 5 );; gap> Length(des); 83 gap> List(des, Size);  [ 8, 8, 8, 16, 16, 16, 32, 16, 16, 16, 16, 16, 32, 32, 64, 64, 32, 32, 32,   32, 32, 32, 32, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 32, 32, 32, 32,   64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 32, 32, 32, 32, 32, 64, 64, 64,   64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64,   64, 64, 64, 64, 64, 64, 64 ] gap> List(des, d -> Length( PCentralSeries( d, 2 ) ) - 1 ); [ 2, 2, 2, 2, 2, 2, 2, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,   3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 4,   4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,   4, 4, 4, 5, 5, 5, 5, 5 ]  Below, we compute all capable descendants of order 27 of the elementary abelian group of order 9.  Example  gap> F := FreeGroup( 2, "g" );  gap> G := PcGroupFpGroup( F / [ F.1^3, F.2^3, Comm(F.1, F.2) ] );  gap> des := PqDescendants( G : OrderBound := 3, ClassBound := 2, >  CapableDescendants ); [ ,   ] gap> List(des, d -> Length( PCentralSeries( d, 3 ) ) - 1 ); [ 2, 2 ] gap> # For comparison let us now compute all proper descendants gap> PqDescendants( G : OrderBound := 3, ClassBound := 2); [ ,   ,   ]  In the third example, we compute all proper capable descendants of the elementary abelian group of order 5^2 which have exponent-5 class at most 3, exponent 5, and are metabelian.  Example  gap> F := FreeGroup( 2, "g" );; gap> G := PcGroupFpGroup( F / [ F.1^5, F.2^5, Comm(F.2, F.1) ] );  gap> des := PqDescendants( G : Metabelian, ClassBound := 3, >  Exponent := 5, CapableDescendants ); [ ,   ,   ] gap> List(des, d -> Length( PCentralSeries( d, 5 ) ) - 1 ); [ 2, 3, 3 ] gap> List(des, d -> Length( DerivedSeries( d ) ) ); [ 3, 3, 3 ] gap> List(des, d -> Maximum( List( d, Order ) ) ); [ 5, 5, 5 ]  The examples "PqDescendants-1", "PqDescendants-2" and "PqDescendants-3" (in order) are essentially the same as the above three examples (see PqExample (3.4-4)). 4.4-2 PqSupplementInnerAutomorphisms PqSupplementInnerAutomorphisms( D )  function returns a generating set for a supplement to the inner automorphisms of D, in the form of a record with fields agAutos, agOrder and glAutos, as provided by the pq program. One should be very careful in using these automorphisms for a descendant calculation. Note: In principle there must be a way to use those automorphisms in order to compute descendants but there does not seem to be a way to hand back these automorphisms properly to the pq program.  Example  gap> Q := Pq( FreeGroup(2) : Prime := 3, ClassBound := 1 );  gap> des := PqDescendants( Q : StepSize := 1 ); [ ,   ,   ] gap> S := PqSupplementInnerAutomorphisms( des[3] ); rec( agAutos := [ ], agOrder := [ 3, 2, 2, 2 ],   glAutos := [ Pcgs([ f1, f2, f3 ]) -> [ f1*f2^2, f2, f3 ],   Pcgs([ f1, f2, f3 ]) -> [ f1^2, f2, f3^2 ],   Pcgs([ f1, f2, f3 ]) -> [ f1^2, f2, f3^2 ] ] ) gap> A := AutomorphismGroupPGroup( des[3] ); rec(   agAutos := [ Pcgs([ f1, f2, f3 ]) -> [ f1^2, f2, f3^2 ],   Pcgs([ f1, f2, f3 ]) -> [ f1*f2^2, f2, f3 ],   Pcgs([ f1, f2, f3 ]) -> [ f1*f3, f2, f3 ],   Pcgs([ f1, f2, f3 ]) -> [ f1, f2*f3, f3 ] ], agOrder := [ 2, 3, 3, 3 ],   glAutos := [ ], glOper := [ ], glOrder := 1,   group := ,   one := IdentityMapping( ),   size := 54 )  Typing: PqExample( "PqSupplementInnerAutomorphisms" ); runs the above example in GAP (see PqExample (3.4-4)). Note that by also including PqStart as a second argument to PqExample one can see how it is possible, with the aid of PqSetPQuotientToGroup (see PqSetPQuotientToGroup (5.3-7)), to do the equivalent computations with the interactive versions of Pq and PqDescendants and a single pq process (recall pq is the name of the external C program). 4.4-3 PqList PqList( filename: [SubList := sub] )  function reads a file with name filename (a string) and returns the list L of pc groups (or with option SubList a sublist of L or a single pc group in L) defined in that file. If the option SubList is passed and has the value sub, then it has the same meaning as for PqDescendants, i.e. if sub is an integer then PqList returns L[sub]; otherwise, if sub is a list of integers PqList returns Sublist(L, sub ). Both PqList and SavePqList (see SavePqList (4.4-4)) can be used to save and restore a list of descendants (see PqDescendants (4.4-1)). 4.4-4 SavePqList SavePqList( filename, list )  function writes a list of descendants list to a file with name filename (a string). SavePqList and PqList (see PqList (4.4-3)) can be used to save and restore, respectively, the results of PqDescendants (see PqDescendants (4.4-1)). anupq-3.3.3/doc/install.xml0000644000175100017510000002272215111342310015203 0ustar runnerrunner Installing the ANUPQ Package The ANU pq program is written in C and the package can be installed under UNIX and in environments similar to UNIX. In particular it is known to work on Linux and Mac OS X, and also on Windows equipped with cygwin.

The current version of the &ANUPQ; package requires &GAP; 4.9, and version 1.2 of the &AutPGrp; package. However, we recommend using at least &GAP; 4.6 and &AutPGrp; 1.5.

To install the &ANUPQ; package, move the file anupq-XXX.tar.gz for some version number XXX into the pkg directory in which you plan to install &ANUPQ;. Usually, this will be the directory pkg in the hierarchy of your version of &GAP;; it is however also possible to keep an additional pkg directory in your private directories. The only essential difference with installing &ANUPQ; in a pkg directory different to the &GAP; home directory is that one must start &GAP; with the -l switch (see Section ), e.g. if your private pkg directory is a subdirectory of mygap in your home directory you might type:

where myhomedir is the path to your home directory, which may be replaced by a tilde. The empty path before the semicolon is filled in by the default path of the &GAP; home directory.

Then, in your chosen pkg directory, unpack anupq-XXX.tar.gz by

.tar.gz ]]> Change to the newly created anupq directory. Now you need to call configure. If you installed &ANUPQ; into the main pkg directory, call If you installed ANUPQ in another directory than the usual 'pkg' subdirectory, instead call ]]> where path is the path to the &GAP; home directory. (You can also call for further options.)

What this does is look for a file sysinfo.gap in the root directory of &GAP; in order to determine an architecture name for the subdirectory of bin in which to put the compiled pq binary. This only makes sense if &GAP; was compiled for the same architecture that pq will be. If you have a shared file system mounted across different architectures, then you should run configure and make for &ANUPQ; for each architecture immediately after compiling &GAP; on the same architecture.

If you had to install the package in your own directory but wish to use the system &GAP; then you will need to find out what path is. To do this, start up &GAP; and find out what &GAP;'s root path is from finding the value of the variable GAPInfo.RootPaths, e.g. GAPInfo.RootPaths; [ "/usr/local/lib/gap4r4/" ] ]]> would tell you to use /usr/local/lib/gap4r4 for path.

The configure command will fetch the architecture type for which &GAP; has been compiled last and create a Makefile. You can now simply call

to compile the binary and to install it in the appropriate place.

ANUPQ_GAP_EXEC The path of &GAP; (see Note below) used by the pq binary (the value GAP is set to in the make command) may be over-ridden by setting the environment variable ANUPQ_GAP_EXEC. These values are only of interest when the pq program is run as a standalone; however, the testPq script assumes you have set one of these correctly (see Section ). When the pq program is started from &GAP; communication occurs via an iostream, so that the pq binary does not actually need to know a valid path for &GAP; is this case.

Note. By path of &GAP; we mean the path of the command used to invoke &GAP; (which should be a script, e.g. the gap.sh script generated in the bin directory for the version of &GAP; when &GAP; was compiled). The usual strategy is to copy the gap.sh script to a standard location, e.g. /usr/local/bin/gap. It is a mistake to copy the &GAP; executable gap (in a directory with name of form bin/compile-platform) to the standard location, since direct invocation of the executable results in &GAP; starting without being able to find its own library (a fatal error).

Testing your ANUPQ installation ANUPQ_GAP_EXEC Now it is time to test the installation. After doing configure and make you will have a testPq script. The script assumes that, if the environment variable ANUPQ_GAP_EXEC is set, it is a correct path for &GAP;, or otherwise that the make call that compiled the pq program set GAP to a correct path for &GAP; (see Section  for more details). To run the tests, just type: Some of the tests the script runs take a while. Please be patient. The script checks that you not only have a correct &GAP; (at least version 4.4) installation that includes the &AutPGrp; package, but that the &ANUPQ; package and its pq binary interact correctly. You should see something like the following output:
Running the pq program as a standalone ANUPQ_GAP_EXEC When the pq program is run as a standalone it sometimes needs to call &GAP; to compute stabilisers of subgroups; in doing so, it first checks the value of the environment variable ANUPQ_GAP_EXEC, and uses that, if set, or otherwise the value of GAP it was compiled with, as the path for &GAP;. If you ran testPq (see Section ) and you got both &GAP; is OK and the link between the pq binary and &GAP; is OK, you should be fine. Otherwise heed the recommendations of the error messages you get and run the testPq until all tests are passed.

It is especially important that the &GAP;, whose path you gave, should know where to find the &ANUPQ; and &AutPGrp; packages. To ensure this the path should be to a shell script that invokes &GAP;. If you needed to install the needed packages in your own directory (because, say, you are not a system administrator) then you should create your own shell script that runs &GAP; with a correct setting of the -l option and set the path used by the pq binary to the path of that script. To create the script that runs &GAP; it is easiest to copy the system one and edit it, e.g. start by executing the following UNIX commands (skip the second step if you already have a bin directory; you@unix> is your UNIX prompt):

cd you@unix> mkdir bin you@unix> cd bin you@unix> which gap /usr/local/bin/gap you@unix> cp /usr/local/bin/gap mygap you@unix> chmod +x mygap ]]> At the second-last step use the path of &GAP; returned by which gap. Now hopefully you will have a copy of the script that runs the system &GAP; in mygap. Now use your favourite editor to edit the -l part of the last line of mygap which should initially look something like: so that it becomes (the tilde is a UNIX abbreviation for your home directory): assuming that your personal &GAP; pkg directory is a subdirectory of gapstuff in your home directory. Finally, to let the pq program know where &GAP; is and also know where your pkg directory is that contains &ANUPQ;, set the environment variable ANUPQ_GAP_EXEC to the complete (i.e. absolute) path of your mygap script (do not use the tilde abbreviation).
anupq-3.3.3/doc/chap3.html0000644000175100017510000015442715111342310014707 0ustar runnerrunner GAP (ANUPQ) - Chapter 3: Infrastructure
Goto Chapter: Top 1 2 3 4 5 6 7 A Bib Ind
 [Top of Book]  [Contents]   [Previous Chapter]   [Next Chapter] 

3 Infrastructure
 3.1 Loading the ANUPQ Package
 3.2 The ANUPQData Record

  3.2-1 ANUPQData
  3.2-2 ANUPQDirectoryTemporary
 3.3 Setting the Verbosity of ANUPQ via Info and InfoANUPQ

  3.3-1 InfoANUPQ
 3.4 Utility Functions

  3.4-1 PqLeftNormComm
  3.4-2 PqGAPRelators
  3.4-3 PqParseWord
  3.4-4 PqExample
  3.4-5 AllPqExamples
  3.4-6 GrepPqExamples
  3.4-7 ToPQLog
 3.5 Attributes and a Property for fp and pc p-groups

  3.5-1 NuclearRank
 3.6 Hints and Warnings regarding the use of Options

  3.6-1 ANUPQWarnOfOtherOptions

3 Infrastructure

Most of the details in this chapter are of a technical nature; the user need only skim over this chapter on a first reading. Mostly, it is enough to know that

  • you must do a LoadPackage("anupq"); before you can expect to use a command defined by the ANUPQ package (details are in Section Loading the ANUPQ Package);

  • partial results of ANUPQ commands and some other data are stored in the ANUPQData global variable (details are in Section The ANUPQData Record);

  • doing SetInfoLevel(InfoANUPQ, n); for n greater than the default value 1 will give progressively more information of what is going on behind the scenes (details are in Section Setting the Verbosity of ANUPQ via Info and InfoANUPQ);

  • in Section Utility Functions we describe some utility functions and functions that run examples from the collection of examples of this package;

  • in Section Attributes and a Property for fp and pc p-groups we describe the attributes and property NuclearRank, MultiplicatorRank and IsCapable; and

  • in Section Hints and Warnings regarding the use of Options we describe some troubleshooting strategies. Also this section explains the utility of setting ANUPQWarnOfOtherOptions := true; (particularly for novice users) for detecting misspelt options and diagnosing other option usage problems.

3.1 Loading the ANUPQ Package

To use the ANUPQ package, as with any GAP package, it must be requested explicitly. This is done by calling

gap> LoadPackage( "anupq" );
---------------------------------------------------------------------------
Loading ANUPQ 3.3.3 (ANU p-Quotient)
by Greg Gamble (GAP code, Greg.Gamble@uwa.edu.au),
   Werner Nickel (GAP code), and
   Eamonn O'Brien (C code, https://www.math.auckland.ac.nz/~obrien).
maintained by:
   Max Horn (https://www.quendi.de/math).
uses ANU pq binary (C code program) version: 1.9
Homepage: https://gap-packages.github.io/anupq/
Report issues at https://github.com/gap-packages/anupq/issues
---------------------------------------------------------------------------
true

Note that since the ANUPQ package uses the AutomorphimGroupPGroup function of the AutPGrp package and, in any case, often needs other AutPGrp functions when computing descendants, the user must ensure that the AutPGrp package is also installed, at least version 1.5. If the AutPGrp package is not installed, the ANUPQ package will fail to load.

Also, if GAP cannot find a working pq binary, the call to LoadPackage will return fail.

If you want to load the ANUPQ package by default, you can put the LoadPackage command into your gap.ini file (see Section Reference: The gap.ini and gaprc files in the GAP Reference Manual). By the way, the novice user of the ANUPQ package should probably also append the line

ANUPQWarnOfOtherOptions := true;

to their gap.ini file, somewhere after the LoadPackage( "anupq" ); command (see ANUPQWarnOfOtherOptions (3.6-1)).

3.2 The ANUPQData Record

This section contains fairly technical details which may be skipped on an initial reading.

3.2-1 ANUPQData
‣ ANUPQData( global variable )

is a GAP record in which the essential data for an ANUPQ session within GAP is stored; its fields are:

binary

the path of the pq binary;

tmpdir

the path of the temporary directory used by the pq binary and GAP (i.e. the directory in which all the pq's temporary files are created) (also see ANUPQDirectoryTemporary (3.2-2) below);

outfile

the full path of the default pq output file;

SPimages

the full path of the file GAP_library to which the pq program writes its Standard Presentation images;

version

the version of the current pq binary;

ni

a data record used by non-interactive functions (see below and Chapter Non-interactive ANUPQ functions);

io

list of data records for PqStart (see below and PqStart (5.1-1)) processes;

topqlogfile

name of file logged to by ToPQLog (see ToPQLog (3.4-7)); and

logstream

stream of file logged to by ToPQLog (see ToPQLog (3.4-7)).

Each time an interactive ANUPQ process is initiated via PqStart (see PqStart (5.1-1)), an identifying number ioIndex is generated for the interactive process and a record ANUPQData.io[ioIndex] with some or all of the fields listed below is created. Whenever a non-interactive function is called (see Chapter Non-interactive ANUPQ functions), the record ANUPQData.ni is updated with fields that, if bound, have exactly the same purpose as for a ANUPQData.io[ioIndex] record.

stream

the IOStream opened for interactive ANUPQ process ioIndex or non-interactive ANUPQ function;

group

the group given as first argument to PqStart, Pq, PqEpimorphism, PqDescendants or PqStandardPresentation (or any synonymous methods);

haspcp

is bound and set to true when a pc presentation is first set inside the pq program (e.g. by PqPcPresentation or PqRestorePcPresentation or a higher order function like Pq, PqEpimorphism, PqPCover, PqDescendants or PqStandardPresentation that does a PqPcPresentation operation, but not PqStart which only starts up an interactive ANUPQ process);

gens

a list of the generators of the group group as strings (the same as those passed to the pq program);

rels

a list of the relators of the group group as strings (the same as those passed to the pq program);

name

the name of the group whose pc presentation is defined by a call to the pq program (according to the pq program -- unless you have used the GroupName option (see e.g. Pq (4.1-1)) or applied the function SetName (see SetName (Reference: Name)) to the group, the generic name "[grp]" is set as a default);

gpnum

if not a null string, the number (i.e. the unique label assigned by the pq program) of the last descendant processed;

class

the largest lower exponent-p central class of a quotient group of the group (usually group) found by a call to the pq program;

forder

the factored order of the quotient group of largest lower exponent-p central class found for the group (usually group) by a call to the pq program (this factored order is given as a list [p,n], indicating an order of p^n);

pcoverclass

the lower exponent-p central class of the p-covering group of a p-quotient of the group (usually group) found by a call to the pq program;

workspace

the workspace set for the pq process (either given as a second argument to PqStart, or set by default to 10000000);

menu

the current menu of the pq process (the pq program is managed by various menus, the details of which the user shouldn't normally need to know about -- the menu field remembers which menu the pq process is currently in);

outfname

is the file to which pq output is directed, which is always ANUPQData.outfile, except when option SetupFile is used with a non-interactive function, in which case outfname is set to "PQ_OUTPUT";

pQuotient

is set to the value returned by Pq (see Pq (4.1-1)) (the field pQepi is also set at the same time);

pQepi

is set to the value returned by PqEpimorphism (see PqEpimorphism (4.1-2)) (the field pQuotient is also set at the same time);

pCover

is set to the value returned by PqPCover (see PqPCover (4.1-3));

SP

is set to the value returned by PqStandardPresentation or StandardPresentation (see PqStandardPresentation (5.3-4)) when called interactively, for process i (the field SPepi is also set at the same time);

SPepi

is set to the value returned by EpimorphismPqStandardPresentation or EpimorphismStandardPresentation (see EpimorphismPqStandardPresentation (5.3-5)) when called interactively, for process i (the field SP is also set at the same time);

descendants

is set to the value returned by PqDescendants (see PqDescendants (4.4-1));

treepos

if set by a call to PqDescendantsTreeCoclassOne (see PqDescendantsTreeCoclassOne (A.4-1)), it contains a record with fields class, node and ndes being the information that determines the last descendant with a non-zero number of descendants processed;

xgapsheet

if set by a call to PqDescendantsTreeCoclassOne (see PqDescendantsTreeCoclassOne (A.4-1)) during an XGAP session, it contains the XGAP Sheet on which the descendants tree is displayed; and

nextX

if set by a call to PqDescendantsTreeCoclassOne (see PqDescendantsTreeCoclassOne (A.4-1)) during an XGAP session, it contains a list of integers, the ith entry of which is the x-coordinate of the next node (representing a descendant) for the ith class.

3.2-2 ANUPQDirectoryTemporary
‣ ANUPQDirectoryTemporary( dir )( function )

calls the UNIX command mkdir to create dir, which must be a string, and if successful a directory object for dir is both assigned to ANUPQData.tmpdir and returned. The field ANUPQData.outfile is also set to be a file in ANUPQData.tmpdir, and on exit from GAP dir is removed. Most users will never need this command; by default, GAP typically chooses a random subdirectory of /tmp for ANUPQData.tmpdir which may occasionally have limits on what may be written there. ANUPQDirectoryTemporary permits the user to choose a directory (object) where one is not so limited.

3.3 Setting the Verbosity of ANUPQ via Info and InfoANUPQ

3.3-1 InfoANUPQ
‣ InfoANUPQ( info class )

The input to and the output from the pq program is, by default, not displayed. However the user may choose to see some, or all, of this input/output. This is done via the Info mechanism (see Section Reference: Info Functions in the GAP Reference Manual). For this purpose, there is the InfoClass InfoANUPQ. If the InfoLevel of InfoANUPQ is high enough each line of pq input/output is directed to a call to Info and will be displayed for the user to see. By default, the InfoLevel of InfoANUPQ is 1, and it is recommended that you leave it at this level, or higher. Messages that the user should presumably want to see and output from the pq program influenced by the value of the option OutputLevel (see the options listed in Section Pq (4.1-1)), other than timing and memory usage are directed to Info at InfoANUPQ level 1.

To turn off all InfoANUPQ messaging, set the InfoANUPQ level to 0.

There are five other user-intended InfoANUPQ levels: 2, 3, 4, 5 and 6.

gap> SetInfoLevel(InfoANUPQ, 2);

enables the display of most timing and memory usage data from the pq program, and also the number of identity instances when the Identities option is used. (Some timing and memory usage data, particularly when profuse in quantity, is Info-ed at InfoANUPQ level 3 instead.) Note that the the GAP functions time and Runtime (see Runtime (Reference: Runtime) in the GAP Reference Manual) count the time spent by GAP and not the time spent by the (external) pq program.

gap> SetInfoLevel(InfoANUPQ, 3);

enables the display of output of the nature of the first two InfoANUPQ that was not directly invoked by the user (e.g. some commands require GAP to discover something about the current state known to the pq program). The identity instances processed under the Identities option are also displayed at this level. In some cases, the pq program produces a lot of output despite the fact that the OutputLevel (see 6.2) is unset or is set to 0; such output is also Info-ed at InfoANUPQ level 3.

gap> SetInfoLevel(InfoANUPQ, 4);

enables the display of all the commands directed to the pq program, behind a ToPQ> prompt (so that you can distinguish it from the output from the pq program). See Section Hints and Warnings regarding the use of Options for an example of how this can be a useful troubleshooting tool.

gap> SetInfoLevel(InfoANUPQ, 5);

enables the display of the pq program's prompts for input. Finally,

gap> SetInfoLevel(InfoANUPQ, 6);

enables the display of all other output from the pq program, namely the banner and menus. However, the timing data printed when the pq program exits can never be observed.

3.4 Utility Functions

3.4-1 PqLeftNormComm
‣ PqLeftNormComm( elts )( function )

returns for a list of elements of some group (e.g. elts may be a list of words in the generators of a free or fp group) the left normed commutator of elts, e.g. if w1, w2, w3 are such elements then PqLeftNormComm( [w1, w2, w3] ); is equivalent to Comm( Comm( w1, w2 ), w3 );.

Note: elts must contain at least two elements.

3.4-2 PqGAPRelators
‣ PqGAPRelators( group, rels )( function )

returns a list of words that GAP understands, given a list rels of strings in the string representations of the generators of the fp group group prepared as a list of relators for the pq program.

Note: The pq program does not use / to indicate multiplication by an inverse and uses square brackets to represent (left normed) commutators. Also, even though the pq program accepts relations, all elements of rels must be in relator form, i.e. a relation of form w1 = w2 must be written as w1*(w2)^-1.

Here is an example:

gap> F := FreeGroup("a", "b");
<free group on the generators [ a, b ]>
gap> PqGAPRelators(F, [ "a*b^2", "[a,b]^2*a", "[a,b,a,b]^a" ]);
[ a*b^2, (a^-1*b^-1*a*b)^2*a, 
  a^-2*b^-1*a^-1*b*(a*b^-1)^2*a^-1*b*a^-1*b^-1*(a*b)^2*a ]

3.4-3 PqParseWord
‣ PqParseWord( word, n )( function )

parses a word, a string representing a word in the pc generators x1,...,xn, through GAP. This function is provided as a rough-and-ready check of word for syntax errors. A syntax error will cause the entering of a break-loop, in which the error message may or may not be meaningful (depending on whether the syntax error gets caught at the GAP or kernel level).

Note: The reason the generators must be x1,...,xn is that these are the pc generator names used by the pq program (as distinct from the generator names for the group provided by the user to a function like Pq that invokes the pq program).

3.4-4 PqExample
‣ PqExample( )( function )
‣ PqExample( example[, PqStart][, Display] )( function )
‣ PqExample( example[, PqStart][, filename] )( function )

With no arguments, or with single argument "index", or a string example that is not the name of a file in the examples directory, an index of available examples is displayed.

With just the one argument example that is the name of a file in the examples directory, the example contained in that file is executed in its simplest form. Some examples accept options which you may use to modify some of the options used in the commands of the example. To find out which options an example accepts, use one of the mechanisms for displaying the example described below.

Some examples have both non-interactive and interactive forms; those that are non-interactive only have a name ending in -ni; those that are interactive only have a name ending in -i; examples with names ending in .g also have only one form; all other examples have both non-interactive and interactive forms and for these giving PqStart as second argument invokes PqStart initially and makes the appropriate adjustments so that the example is executed or displayed using interactive functions.

If PqExample is called with last (second or third) argument Display then the example is displayed without being executed. If the last argument is a non-empty string filename then the example is also displayed without being executed but is also written to a file with that name. Passing an empty string as last argument has the same effect as passing Display.

Note: The variables used in PqExample are local to the running of PqExample, so there's no danger of having some of your variables over-written. However, they are not completely lost either. They are saved to a record ANUPQData.examples.vars, i.e. if F is a variable used in the example then you will be able to access it after PqExample has finished as ANUPQData.examples.vars.F.

3.4-5 AllPqExamples
‣ AllPqExamples( )( function )

returns a list of all currently available examples in default UNIX-listing (i.e. alphabetic) order.

3.4-6 GrepPqExamples
‣ GrepPqExamples( string )( function )

runs the UNIX command grep string over the ANUPQ examples and returns the list of examples for which there is a match. The actual matches are Info-ed at InfoANUPQ level 2.

3.4-7 ToPQLog
‣ ToPQLog( [filename] )( function )

With string argument filename, ToPQLog opens the file with name filename for logging; all commands written to the pq binary (that are Info-ed behind a ToPQ> prompt at InfoANUPQ level 4) are then also written to that file (but without prompts). With no argument, ToPQLog stops logging to whatever file was being logged to. If a file was already being logged to, that file is closed and the file with name filename is opened for logging.

3.5 Attributes and a Property for fp and pc p-groups

3.5-1 NuclearRank
‣ NuclearRank( G )( attribute )
‣ MultiplicatorRank( G )( attribute )
‣ IsCapable( G )( property )

return the nuclear rank of G, p-multiplicator rank of G, and whether G is capable (i.e. true if it is, or false if it is not), respectively.

These attributes and property are set automatically if G is one of the following:

  • an fp group returned by PqStandardPresentation or StandardPresentation (see PqStandardPresentation (4.2-1));

  • the image (fp group) of the epimorphism returned by an EpimorphismPqStandardPresentation or EpimorphismStandardPresentation call (see EpimorphismPqStandardPresentation (4.2-2)); or

  • one of the pc groups of the list of descendants returned by PqDescendants (see PqDescendants (4.4-1)).

If G is an fp group or a pc p-group and not one of the above and the attribute or property has not otherwise been set for G, then PqStandardPresentation is called to set all three of NuclearRank, MultiplicatorRank and IsCapable, before returning the value of the attribute or property actually called. Such a group G must know in advance that it is a p-group; this is the case for the groups returned by the functions Pq and PqPCover, and the image group of the epimorphism returned by PqEpimorphism. Otherwise, if you know the group to be a p-group, then this can be set by typing

SetIsPGroup( G, true );

or by invoking IsPGroup( G ). Note that for an fp group G, the latter may result in a coset enumeration which might not terminate in a reasonable time.

Note: For G such that HasNuclearRank(G) = true, IsCapable(G) is equivalent to (the truth or falsity of) NuclearRank( G ) = 0.

3.6 Hints and Warnings regarding the use of Options

On a first reading we recommend you skip this section and come back to it if and when you run into trouble.

Note: By options we refer to GAP options. The pq program also uses the term option; to distinguish the two usages of option, in this manual we use the term menu item to refer to what the pq program refers to as an option.

Options are passed to the ANUPQ interface functions in either of the two usual mechanisms provided by GAP, namely:

  • options may be set globally using the function PushOptions (see Chapter Reference: Options Stack in the GAP Reference Manual); or

  • options may be appended to the argument list of any function call, separated by a colon from the argument list (see Chapter Reference: Function Calls in the GAP Reference Manual), in which case they are then passed on recursively to any subsequent inner function call, which may in turn have options of their own.

Particularly, when one is using the interactive functions of Chapter Interactive ANUPQ functions, one should, in general, avoid using the global method of passing options. In fact, it is recommended that prior to calling PqStart the OptionsStack be empty. The essential problem with setting options globally using the function PushOptions is that options pushed onto OptionsStack, in this way, (generally) remain there until an explicit PopOptions() call is made.

In contrast, options passed in the usual way behind a colon following a function's arguments (see Reference: Function Call With Options in the GAP Reference Manual) are local, and disappear from OptionsStack after the function has executed successfully. If the function does not execute successfully, i.e. it runs into error and the user quits the resulting break loop (see Section Reference: Break Loops in the Reference Manual) rather than attempting to repair the problem and typing return; then, unless the error at the kernel level, the OptionsStack is reset. If an error is detected inside the kernel (hopefully, this should occur only rarely, if at all) then the options of that function will not be cleared from OptionsStack; in such cases:

gap> ResetOptionsStack();
#I  Options stack is already empty

is usually necessary (see Chapter ResetOptionsStack (Reference: ResetOptionsStack) in the GAP Reference Manual), which recursively calls PopOptions() until OptionsStack is empty, or as in the above case warns you that the OptionsStack is already empty.

Note that a function, that is passed options after the colon, will also see any global options or any options passed down recursively from functions calling that function, unless those options are over-ridden by options passed via the function. Also, note that duplication of option names for different programs may lead to misinterpretations, and mis-spelled options will not be seen.

The non-interactive functions of Chapter Non-interactive ANUPQ functions that have Pq somewhere in their name provide an alternative method of passing options as additional arguments. This has the advantages that options can be abbreviated and mis-spelled options will be trapped.

3.6-1 ANUPQWarnOfOtherOptions
‣ ANUPQWarnOfOtherOptions( global variable )

is a global variable that is by default false. If it is set to true then any function provided by the ANUPQ function that recognises at least one option, will warn you of other options, i.e. options that the function does not recognise. These warnings are emitted at InfoWarning or InfoANUPQ level 1. This is useful for detecting mis-spelled options. Here is an example using the function Pq (first described in Chapter Non-interactive ANUPQ functions):

gap> SetInfoLevel(InfoANUPQ, 1);        # Set InfoANUPQ to default level
gap> ANUPQWarnOfOtherOptions := true;;
gap> # The following makes entry into break loops very ``quiet'' ...
gap> OnBreak := function() Where(0); end;;
gap> F := FreeGroup( "a", "b" );
<free group on the generators [ a, b ]>
gap> Pq( F : Prime := 2, Classbound := 1 );
#I  ANUPQ Warning: Options: [ "Classbound" ] ignored
#I  (invalid for generic function: `Pq').
user interrupt at
moreOfline := ReadLine( iostream );
Entering break read-eval-print loop ...
you can 'quit;' to quit to outer loop, or
you can 'return;' to continue

Here we mistyped ClassBound as Classbound, and after seeing the Info-ed warning that Classbound was ignored, we typed a control-C (that's the user interrupt at message) which took us into a break loop. Since the Pq command was not able to finish, the options Prime and Classbound, in particular, will still be on the OptionsStack:

brk> OptionsStack;
[ rec( Prime := 2, Classbound := 1 ), 
  rec( Prime := 2, Classbound := 1, PqEpiOrPCover := "pQuotient" ) ]

The option PqEpiOrPCover is a behind-the-scenes option that need not concern the user. On quitting the break-loop the OptionsStack is reset and a warning telling you this is emitted:

brk> quit; # to get back to the `gap>' prompt
#I  Options stack has been reset

Above, we altered OnBreak (see OnBreak (Reference: OnBreak) in the Reference manual) to reduce the back-tracing on entry into a break loop. We now restore OnBreak to its usual value.

gap> OnBreak := Where;;

Notes

In cases where functions recursively call others with options (e.g. when using PqExample with options), setting ANUPQWarnOfOtherOptions := true may give rise to spurious other option detections.

It is recommended that the novice user set ANUPQWarnOfOtherOptions to true in their gap.ini file (see Section Loading the ANUPQ Package).

Other Troubleshooting Strategies

There are some other strategies which may have helped us to see our error above. The function Pq recognises the option OutputLevel (see 6.2); if this option is set to at least 1, the pq program provides information on each class quotient as it is generated:

gap> ANUPQWarnOfOtherOptions := false;; # Set back to normal
gap> F := FreeGroup( "a", "b" );;
gap> Pq( F : Prime := 2, Classbound := 1, OutputLevel := 1 ); 
#I  Lower exponent-2 central series for [grp]
#I  Group: [grp] to lower exponent-2 central class 1 has order 2^2
#I  Group: [grp] to lower exponent-2 central class 2 has order 2^5
#I  Group: [grp] to lower exponent-2 central class 3 has order 2^10
#I  Group: [grp] to lower exponent-2 central class 4 has order 2^18
#I  Group: [grp] to lower exponent-2 central class 5 has order 2^32
#I  Group: [grp] to lower exponent-2 central class 6 has order 2^55
#I  Group: [grp] to lower exponent-2 central class 7 has order 2^96
#I  Group: [grp] to lower exponent-2 central class 8 has order 2^167
#I  Group: [grp] to lower exponent-2 central class 9 has order 2^294
#I  Group: [grp] to lower exponent-2 central class 10 has order 2^520
#I  Group: [grp] to lower exponent-2 central class 11 has order 2^932
#I  Group: [grp] to lower exponent-2 central class 12 has order 2^1679
[... output truncated ...]

After seeing the information for the class 2 quotient we may have got the idea that the Classbound option was not recognised and may have realised that this was due to a mis-spelling. The above will ordinarily cause the available space to be exhausted, necessitating user-intervention by typing control-C and quit; (to escape the break loop); otherwise Pq terminates when the class reaches 63 (the default value of ClassBound).

If you have some familiarity with keyword command input to the pq binary, then setting the level of InfoANUPQ to 4 would also have indicated a problem:

gap> ResetOptionsStack(); # Necessary, if a break-loop was entered above
gap> SetInfoLevel(InfoANUPQ, 4);
gap> Pq( F : Prime := 2, Classbound := 1 );
#I  ToPQ> 7  #to (Main) p-Quotient Menu
#I  ToPQ> 1  #define group
#I  ToPQ> name [grp]
#I  ToPQ> prime 2
#I  ToPQ> class 63
#I  ToPQ> exponent 0
#I  ToPQ> output 0
#I  ToPQ> generators { a,b }
#I  ToPQ> relators   {  };
[... output truncated ...]

Here the line #I ToPQ> class 63 indicates that a directive to set the classbound to 63 was sent to the pq program.

 [Top of Book]  [Contents]   [Previous Chapter]   [Next Chapter] 
Goto Chapter: Top 1 2 3 4 5 6 7 A Bib Ind

generated by GAPDoc2HTML

anupq-3.3.3/doc/chapInd_mj.html0000644000175100017510000007736615111342310015753 0ustar runnerrunner GAP (ANUPQ) - Index
Goto Chapter: Top 1 2 3 4 5 6 7 A Bib Ind
 [Top of Book]  [Contents]   [Previous Chapter] 

Index

AllANUPQoptions 6.1-1
allowable subgroup 2.1-4
AllPqExamples 3.4-5
ANUPQ 1.1
ANUPQ_GAP_EXEC, environment variable 7. 7.1 7.2
ANUPQData 3.2-1
ANUPQDirectoryTemporary 3.2-2
ANUPQoptions 6.1-2
ANUPQWarnOfOtherOptions 3.6-1
automorphisms, of \(p\)-groups 4.2 5.3-3
\(B(5,4)\) A.3
banner 3.1
bug reports 1.3
capable 2.1-4
class 2.1-2
collection 2.1-1
compaction 2.3
confluent 2.1-1
confluent rewriting system 2.1-1
consistency conditions 2.1-1
consistent 2.1-1
definition, of generator 2.2-1
descendant 2.1-4
echelonised matrix 2.3
Engel identity 2.1-5
EpimorphismPqStandardPresentation 4.2-2
    interactive 5.3-5
EpimorphismStandardPresentation 4.2-2
    interactive 5.3-5
exponent check 2.2-3
exponent law 2.1-5
exponent-p central series 2.1-2
extended automorphism 2.1-4
GrepPqExamples 3.4-6
identical relation 2.1-5
immediate descendant 2.1-4
InfoANUPQ 3.3-1
interruption 5.2-3
IsCapable 3.5-1
IsIsomorphicPGroup 4.3-1
isomorphism testing 2.3
IsPqIsomorphicPGroup 4.3-1
IsPqProcessAlive 5.2-3
    for default process 5.2-3
label of standard matrix 2.3
labelled pcp 2.2-1
law 2.1-5
menu item, of pq program 3.6
metabelian law 2.1-5
multiplicator rank 2.1-3
MultiplicatorRank 3.5-1
NuclearRank 3.5-1
nucleus 2.1-4 2.1-4
option, of pq program is a menu item 3.6
option AllDescendants 4.4-1 5.3-6 6.2
option BasicAlgorithm 4.4-1 5.3-6 6.2
option Bounds 6.2
option CapableDescendants 4.4-1 5.3-6 6.2
option ClassBound 4.1-1 4.2-1 4.4-1 5.3-1 5.3-4 5.3-6 5.8-2 6.2
option CustomiseOutput 4.4-1 5.3-6 6.2
option Exponent 4.1-1 4.2-1 4.4-1 5.3-1 5.3-4 5.3-6 6.2
option Filename 6.2
option GroupName 4.1-1 4.2-1 4.4-1 5.3-1 5.3-4 5.3-6 6.2
option Identities 4.1-1 5.3-1 6.2
    example of usage 4.1-1
option Metabelian 4.1-1 4.2-1 4.4-1 5.3-1 5.3-4 5.3-6 6.2
option NumberOfSolubleAutomorphisms 6.2
option OrderBound 4.4-1 5.3-6 6.2
option OutputLevel 4.1-1 4.2-1 5.3-1 5.3-4 6.2
option PcgsAutomorphisms 5.8-2 6.2
option pQuotient 4.2-1 5.3-4 6.2
option PqWorkspace 4.1-1 4.2-1 4.4-1 6.2
option Prime 4.1-1 4.2-1 5.3-1 5.3-4 6.2
option PrintAutomorphisms 6.2
option PrintPermutations 6.2
option QueueFactor 5.6-4 6.2
option RankInitialSegmentSubgroups 4.4-1 5.3-6 6.2
option RedoPcp 5.3-1 6.2
option RelativeOrders 6.2
option Relators 4.1-1 4.4-1 5.3-1 5.3-6 6.2
    example of usage 4.1-1
option SetupFile 4.1-1 4.2-1 4.4-1 6.2
option SpaceEfficient 4.4-1 5.3-6 6.2
option StandardPresentationFile 4.2-1 5.3-4 5.8-2 6.2
option StepSize 4.4-1 5.3-6 6.2
option SubList 4.4-1 5.3-6 6.2
option TreeDepth 6.2
orbits 2.3
p-class 2.1-2
p-cover 2.1-3
p-covering group 2.1-3
p-group generation 2.3
p-multiplicator 2.1-3
p-multiplicator rank 2.1-3
pc generators 2.1-1
pc presentation 2.1-1
pcp 2.1-1
permutations 2.1-4
power-commutator presentation 2.1-1
Pq 4.1-1
    interactive 5.3-1
    interactive, for default process 5.3-1
PqAddTails 5.7-7
    for default process 5.7-7
PqAPGDegree 5.10-1
    for default process 5.10-1
PqAPGOrbitRepresentatives 5.10-4
    for default process 5.10-4
PqAPGOrbits 5.10-3
    for default process 5.10-3
PqAPGPermutations 5.10-2
    for default process 5.10-2
PqAPGSingleStage 5.10-5
    for default process 5.10-5
PqApplyAutomorphisms 5.7-22
    for default process 5.7-22
PqCollect 5.7-1
    for default process 5.7-1
PqCollectDefiningRelations 5.7-9
    for default process 5.7-9
PqCollectWordInDefiningGenerators 5.7-10
    for default process 5.7-10
PqCommutator 5.7-3
    for default process 5.7-3
PqCommutatorDefiningGenerators 5.7-11
    for default process 5.7-11
PqCompact 5.7-18
    for default process 5.7-18
PqComputePCover 5.6-5
    for default process 5.6-5
PqComputeTails 5.7-6
    for default process 5.7-6
PqCurrentGroup 5.5-6
    for default process 5.5-6
PqDescendants 4.4-1
    interactive 5.3-6
    interactive, for default process 5.3-6
PqDescendantsTreeCoclassOne A.4-1
    for default process A.4-1
PqDisplayAutomorphisms 5.7-24
    for default process 5.7-24
PqDisplayPcPresentation 5.5-7
    for default process 5.5-7
PqDisplayStructure 5.7-23
    for default process 5.7-23
PqDoConsistencyCheck 5.7-17
    for default process 5.7-17
PqDoConsistencyChecks 5.7-8
    for default process 5.7-8
PqDoExponentChecks 5.7-12
    for default process 5.7-12
PqEchelonise 5.7-19
    for default process 5.7-19
PqEliminateRedundantGenerators 5.7-13
    for default process 5.7-13
PqEpimorphism 4.1-2
    interactive 5.3-2
    interactive, for default process 5.3-2
PqEvaluateIdentities 5.5-9
    for default process 5.5-9
PqExample 3.4-4
    no arguments 3.4-4
    with filename 3.4-4
PqExtendAutomorphisms 5.7-21
    for default process 5.7-21
PqFactoredOrder 5.5-2
    for default process 5.5-2
PqGAPRelators 3.4-2
PqJacobi 5.7-17
    for default process 5.7-17
PqLeftNormComm 3.4-1
PqList 4.4-3
PqNextClass 5.6-4
    for default process 5.6-4
PqNrPcGenerators 5.5-1
    for default process 5.5-1
PqOrder 5.5-3
    for default process 5.5-3
PqParseWord 3.4-3
PqPClass 5.5-4
    for default process 5.5-4
PqPCover 4.1-3
    interactive 5.3-3
    interactive, for default process 5.3-3
PqPcPresentation 5.6-1
    for default process 5.6-1
PqPGConstructDescendants 5.9-3
    for default process 5.9-3
PqPGExtendAutomorphisms 5.9-2
    for default process 5.9-2
PqPGRestoreDescendantFromFile 5.9-4
    for default process 5.9-4
    with class 5.9-4
    with class, for default process 5.9-4
PqPGSetDescendantToPcp 5.9-4
    for default process 5.9-4
    with class 5.9-4
    with class, for default process 5.9-4
PqPGSupplyAutomorphisms 5.9-1
    for default process 5.9-1
PqProcessIndex 5.2-1
    for default process 5.2-1
PqProcessIndices 5.2-2
PqQuit 5.1-2
    for default process 5.1-2
PqQuitAll 5.1-3
PqRead 5.11-1
    for default process 5.11-1
PqReadAll 5.11-2
    for default process 5.11-2
PqReadUntil 5.11-3
    for default process 5.11-3
    with modify map 5.11-3
    with modify map, for default process 5.11-3
PqRestorePcPresentation 5.6-3
    for default process 5.6-3
PqRevertToPreviousClass 5.7-14
    for default process 5.7-14
PqSavePcPresentation 5.6-2
    for default process 5.6-2
PqSetMaximalOccurrences 5.7-15
    for default process 5.7-15
PqSetMetabelian 5.7-16
    for default process 5.7-16
PqSetOutputLevel 5.5-8
    for default process 5.5-8
PqSetPQuotientToGroup 5.3-7
    for default process 5.3-7
PqSetupTablesForNextClass 5.7-4
    for default process 5.7-4
PqSolveEquation 5.7-2
    for default process 5.7-2
PqSPCompareTwoFilePresentations 5.8-4
    for default process 5.8-4
PqSPComputePcpAndPCover 5.8-1
    for default process 5.8-1
PqSPIsomorphism 5.8-5
    for default process 5.8-5
PqSPSavePresentation 5.8-3
    for default process 5.8-3
PqSPStandardPresentation 5.8-2
    for default process 5.8-2
PqStandardPresentation 4.2-1
    interactive 5.3-4
PqStart 5.1-1
    with group 5.1-1
    with group and workspace size 5.1-1
    with workspace size 5.1-1
PqSupplementInnerAutomorphisms 4.4-2
PqSupplyAutomorphisms 5.7-20
    for default process 5.7-20
PqTails 5.7-5
    for default process 5.7-5
PqWeight 5.5-5
    for default process 5.5-5
PqWrite 5.11-4
    for default process 5.11-4
PqWritePcPresentation 5.7-25
    for default process 5.7-25
SavePqList 4.4-4
standard presentation 2.3
StandardPresentation 4.2-1
    interactive 5.3-4
tails 2.2-1
terminal 2.1-4
ToPQLog 3.4-7
troubleshooting tips 3.6
weight function 2.1-2
weighted pcp 2.1-2

 [Top of Book]  [Contents]   [Previous Chapter] 
Goto Chapter: Top 1 2 3 4 5 6 7 A Bib Ind

generated by GAPDoc2HTML

anupq-3.3.3/doc/basics.xml0000644000175100017510000004410015111342310014773 0ustar runnerrunner Mathematical Background and Terminology In this chapter we will give a brief description of the mathematical notions used in the algorithms implemented in the ANU pq program that are made accessible from &GAP; through this package. For proofs and details we will point to relevant places in the published literature. Also we will try to give some explanation of terminology that may help to use the low-level interactive functions described in Section . However, users who intend to use these functions are strongly advised to acquire a thorough understanding of the algorithms from the quoted literature. There is little or no checking done in these functions and naive use may result in incorrect results.

Basic notions Throughout this manual, by p-group we always mean finite p-group. pc Presentations and Consistency For details, see e.g. .

Every finite p-group G has a presentation of the form: \{a_1,\dots,a_n \mid a_i^p = v_{ii}, 1 \le i \le n, [a_k, a_j] = v_{jk}, 1 \le j < k \le n \}. where v_{jk} is a word in the elements a_{k+1},\dots,a_n for 1 \le j \leq k \le n.

power-commutator presentationpc presentationpcp pc generatorscollection This is called a power-commutator presentation (or pc presentation or pcp) of G, generators from such a presentation will be referred to as pc generators. In terms of such pc generators every element of G can be written in a normal form a_1^{e_1}\dots a_n^{e_n} with 0 \le e_i < p. Moreover any given product of the generators can be brought into such a normal form using the defining relations in the above presentation as rewrite rules. Any such process is called collection. For the discussion of various collection methods see and .

consistentconfluent rewriting systemconfluent Every p-group of order p^n has such a pcp on n generators and conversely every such presentation defines a p-group. However a p-group defined by a pcp on n generators can be of smaller order p^m with m<n. A pcp on n generators that does in fact define a p-group of order p^n is called consistent in this manual, in line with most of the literature on the algorithms occurring here. A consistent pcp determines a confluent rewriting system (see  of the &GAP; Reference Manual) for the group it defines and for this reason often (in particular in the &GAP; Reference Manual) such a pcp presentation is also called confluent.

Consistency of a pcp is tantamount to the fact that for any given word in the generators any two collections will yield the same normal form.

consistency conditions Consistency of a pcp can be checked by a finite set of consistency conditions, demanding that collection of the left hand side and of the right hand side of certain equations, starting with subproducts indicated by bracketing, will result in the same normal form. There are 3 types of such equations (that will be referred to in the manual): \begin{array}{rclrl} (a^n)a &=& a(a^n) &&{\rm (Type 1)} \\ (b^n)a &=& b^{(n-1)}(ba), b(a^n) = (ba)a^{(n-1)} &&{\rm (Type 2)} \\ c(ba) &=& (cb)a &&{\rm (Type 3)} \\ \end{array} See for a description of a sufficient set of consistency conditions in the context of the p-quotient algorithm. Exponent-p Central Series and Weighted pc Presentations For details, see .

exponent-p central series The (descending or lower) (exponent-)p-central series of an arbitrary group G is defined by P_0(G) := G, P_i(G) := [G, P_{i-1}(G)] P_{i-1}(G)^p. For a p-group G this series terminates with the trivial group. G classp-class has p-class c if c is the smallest integer such that P_c(G) is the trivial group. In this manual, as well as in much of the literature about the pq- and related algorithms, the p-class is often referred to simply by class.

Let the p-group G have a consistent pcp as above. Then the subgroups \langle1\rangle < {\langle}a_n\rangle < {\langle}a_n, a_{n-1}\rangle < \dots < {\langle}a_n,\dots,a_i\rangle < \dots < G form a central series of G. If this refines the p-central series, weight function we can define the weight function w for the pc generators by w(a_i) = k, if a_i is contained in P_{k-1}(G) but not in P_k(G).

weighted pcp The pair of such a weight function and a pcp allowing it, is called a weighted pcp. p-Cover, p-Multiplicator For details, see .

p-covering groupp-cover p-multiplicator p-multiplicator rank multiplicator rank Let d be the minimal number of generators of the p-group G of p-class c. Then G is isomorphic to a factor group F/R of a free group F of rank d. We denote [F, R] R^p by R^*. It can be proved (see e.g. ) that the isomorphism type of G^* := F/R^* depends only on G. G^* is called the p-covering group or p-cover of G, and R/R^* the p-multiplicator of G. The p-multiplicator is, of course, an elementary abelian p-group; its minimal number of generators is called the (p-)multiplicator rank. Descendants, Capable, Terminal, Nucleus For details, see and .

descendantimmediate descendantnucleus capableterminal Let again G be a p-group of p-class c and d the minimal number of generators of G. A p-group H is a descendant of G if the minimal number of generators of H is d and H/P_c(H) is isomorphic to G. A descendant H of G is a proper descendant if it has p-class at least c+1. A descendant H of G is an immediate descendant if it has p-class c+1. G is called capable if it has immediate descendants; otherwise it is terminal.

Let G^* = F/R^* again be the p-cover of G. Then the group P_c(G^*) is called the nucleus of G. Note that P_c(G^*) is contained in the p-multiplicator R/R^*.

nucleusallowable subgroup It is proved (e.g. in ) that the immediate descendants of G are obtained as factor groups of the p-cover by (proper) supplements of the nucleus in the (elementary abelian) p-multiplicator. These are also called allowable.

extended automorphismpermutations It is further proved there that every automorphism \alpha of F/R extends to an automorphism \alpha^* of the p-cover F/R^* and that the restriction of \alpha^* to the multiplicator R/R^* is uniquely determined by \alpha. Each extended automorphism \alpha^* induces a permutation of the allowable subgroups. Thus the extended automorphisms determine a group P of permutations on the set A of allowable subgroups (The group P of permutations will appear in the description of some interactive functions). Choosing a representative S from each orbit of P on A, the set of factor groups F/S contains each (isomorphism type of) immediate descendant of G exactly once. For each immediate descendant, the procedure of computing the p-cover, extending the automorphisms and computing the orbits on allowable subgroups can be repeated. Iteration of this procedure can in principle be used to determine all descendants of a p-group. Laws lawidentical relationexponent law metabelian lawEngel identity Let l(x_1, \dots, x_n) be a word in the free generators x_1, \dots, x_n of a free group of rank n. Then l(x_1, \dots, x_n) = 1 is called a law or identical relation in a group G if l(g_1, \dots, g_n) = 1 for any choice of elements g_1, \dots, g_n in G. In particular, x^e = 1 is called an exponent law, [[x,y],[u,v]] = 1 the metabelian law, and [\dots [[x_1,x_2],x_2],\dots, x_2] = 1 an Engel identity.

The p-quotient Algorithm For details, see , and . Other descriptions of the algorithm are given in .

The pq algorithm successively determines the factor groups of the groups of the p-central series of a finitely presented (fp) group G. If a bound b for the p-class is given, the algorithm will determine those factor groups up to at most p-class b. If the p-central series terminates with a subgroup P_k(G) with k < b, the algorithm will stop with that group. If no such bound is given, it will try to find the biggest such factor group.

G/P_1(G) is the largest elementary abelian p-factor group of G and this can be found from the relation matrix of G using matrix diagonalisation modulo p. So it suffices to explain how G/P_{i+1}(G) is found from G and G/P_i(G) for some i \ge 1.

This is done, in principle, in two steps: first the p-cover of G_i := G/P_i(G) is determined (which depends only on G_i, not on G) and then G/P_{i+1}(G) as a factor group of this p-cover. Finding the p-cover A very detailed description of the first step is given in , from which we just extract some passages in order to point to some terms occurring in this manual.

labelled pcpdefinitionof generator Let H be a p-group and p^{d(b)} be the order of H/P_b(H). So d := d(1) is the minimal number of generators of H. A weighted pcp of H will be called labelled if for each generator a_k, k > d one relation, having this generator as its right hand side, is marked as definition of this generator.

As described in , a weighted labelled pcp of a p-group can be obtained stepping down its p-central series.

So let us assume that a weighted labelled pcp of G_i is given. A straightforward way of of writing down a (not necessarily consistent) pcp for its p-cover is to add generators, one for each relation which is not a definition, and modify the right hand side of each such relation by multiplying it on the right by one of the new generators -- a different generator for each such relation. Further relations are then added to make the new generators central and of order p. This procedure is called adding tails. A more formal description of it is again given in .

tails It is important to realise that the new generators will generate an elementary abelian group, that is, in additive notation, a vector space over the field of p elements. As said, the pcp of the p-cover obtained in this way need not be consistent. Since the pcp of G_i was consistent, applying the consistency conditions to the pcp of the p-cover, in case the presentation obtained for p-cover is not consistent, will produce a set of equations between the new generators, that, written additively, are linear equations over the field of p elements and can hence be used to remove redundant generators until a consistent pcp is obtained.

In reality, to follow this straightforward procedure would be forbiddingly inefficient except for very small examples. There are many ways of a priori reducing the number of new generators to be introduced, using e.g. the weights attached to the generators, and the main part of is devoted to a detailed discussion with proofs of these possibilities. Imposing the Relations of the fp Group In order to obtain G/P_{i+1}(G) from the pcp of the p-cover of G_i = G/P_i(G), the defining relations from the original presentation of G must be imposed. Since G_i is a homomorphic image of G, these relations again yield relations between the new generators in the presentation of the p-cover of G_i. Imposing Laws While we have so far only considered the computation of the factor groups of a given fp group by the groups of its descending p-central series, the p-quotient algorithm allows a very important variant of this idea: laws can be prescribed that should be fulfilled by the p-factor groups computed by the algorithm. The key observation here is the fact that at each step down the descending p-central series it suffices to impose these laws only for a finite number of words. Again for efficiency of the method it is crucial to keep the number of such words small, and much of and the literature quoted in this paper is devoted to this problem.

exponent check In this form, starting with a free group and imposing an exponent law (also referred to as an exponent check) the pq program has, in fact, found its most noted application in the determination of (restricted) Burnside groups (as reported in e.g. , and ).

Via a &GAP; program using the local interactive functions of the pq program made available through this interface also arbitrary laws can be imposed via the option Identities (see ).

The p-group generation Algorithm, Standard Presentation, Isomorphism Testing For details, see and .

p-group generationorbits The p-group generation algorithm determines the immediate descendants of a given p-group G up to isomorphism. From what has been explained in Section , it is clear that this amounts to the construction of the p-cover, the extension of the automorphisms of G to the p-cover and the determination of representatives of the orbits of the action of these automorphisms on the set of supplements of the nucleus in the p-multiplicator.

The main practical problem here is the determination of these representatives. describes methods for this and the pq program allows choices according to whether space or time limitations must be met.

As well as the descendants of G, the pq program determines their automorphism groups from that of G (see ), which is important for an iteration of the process; this has been used by Eamonn O'Brien, e.g. in the classification of the 2-groups that are now also part of the Small Groups library available through &GAP;.

standard presentationechelonised matrix label of standard matrix A variant of the p-group generation algorithm is also used to define a standard presentation of a given p-group. This is done by constructing an isomorphic copy of the given group through a chain of descendants and at each step making a choice of a particular representative for the respective orbit of capable groups. In a fairly delicate process, subgroups of the p-multiplicator are represented by echelonised matrices and a first among the labels for standard matrices is chosen (this is described in detail in ).

isomorphism testingcompaction Finally, the standard presentation provides a way of testing if two given p-groups are isomorphic: the standard presentations of the groups are computed, for practical purposes compacted and the results compared for being identical, i.e. the groups are isomorphic if and only if their standard presentations are identical.

anupq-3.3.3/doc/ANUPQ.tex0000644000175100017510000124016015111342310014420 0ustar runnerrunner% generated by GAPDoc2LaTeX from XML source (Frank Luebeck) \documentclass[a4paper,11pt]{report} \usepackage[top=37mm,bottom=37mm,left=27mm,right=27mm]{geometry} \sloppy \pagestyle{myheadings} \usepackage{amssymb} \usepackage[utf8]{inputenc} \usepackage{makeidx} \makeindex \usepackage{color} \definecolor{FireBrick}{rgb}{0.5812,0.0074,0.0083} \definecolor{RoyalBlue}{rgb}{0.0236,0.0894,0.6179} \definecolor{RoyalGreen}{rgb}{0.0236,0.6179,0.0894} \definecolor{RoyalRed}{rgb}{0.6179,0.0236,0.0894} \definecolor{LightBlue}{rgb}{0.8544,0.9511,1.0000} \definecolor{Black}{rgb}{0.0,0.0,0.0} \definecolor{linkColor}{rgb}{0.0,0.0,0.554} \definecolor{citeColor}{rgb}{0.0,0.0,0.554} \definecolor{fileColor}{rgb}{0.0,0.0,0.554} \definecolor{urlColor}{rgb}{0.0,0.0,0.554} \definecolor{promptColor}{rgb}{0.0,0.0,0.589} \definecolor{brkpromptColor}{rgb}{0.589,0.0,0.0} \definecolor{gapinputColor}{rgb}{0.589,0.0,0.0} \definecolor{gapoutputColor}{rgb}{0.0,0.0,0.0} %% for a long time these were red and blue by default, %% now black, but keep variables to overwrite \definecolor{FuncColor}{rgb}{0.0,0.0,0.0} %% strange name because of pdflatex bug: \definecolor{Chapter }{rgb}{0.0,0.0,0.0} \definecolor{DarkOlive}{rgb}{0.1047,0.2412,0.0064} \usepackage{fancyvrb} \usepackage{mathptmx,helvet} \usepackage[T1]{fontenc} \usepackage{textcomp} \usepackage[ pdftex=true, bookmarks=true, a4paper=true, pdftitle={Written with GAPDoc}, pdfcreator={LaTeX with hyperref package / GAPDoc}, colorlinks=true, backref=page, breaklinks=true, linkcolor=linkColor, citecolor=citeColor, filecolor=fileColor, urlcolor=urlColor, pdfpagemode={UseNone}, ]{hyperref} \newcommand{\maintitlesize}{\fontsize{50}{55}\selectfont} % write page numbers to a .pnr log file for online help \newwrite\pagenrlog \immediate\openout\pagenrlog =\jobname.pnr \immediate\write\pagenrlog{PAGENRS := [} \newcommand{\logpage}[1]{\protect\write\pagenrlog{#1, \thepage,}} %% were never documented, give conflicts with some additional packages \newcommand{\GAP}{\textsf{GAP}} %% nicer description environments, allows long labels \usepackage{enumitem} \setdescription{style=nextline} %% depth of toc \setcounter{tocdepth}{1} %% command for ColorPrompt style examples \newcommand{\gapprompt}[1]{\color{promptColor}{\bfseries #1}} \newcommand{\gapbrkprompt}[1]{\color{brkpromptColor}{\bfseries #1}} \newcommand{\gapinput}[1]{\color{gapinputColor}{#1}} \begin{document} \logpage{[ 0, 0, 0 ]} \begin{titlepage} \mbox{}\vfill \begin{center}{\maintitlesize \textbf{ \textsf{ANUPQ} \mbox{}}}\\ \vfill \hypersetup{pdftitle= \textsf{ANUPQ} } \markright{\scriptsize \mbox{}\hfill \textsf{ANUPQ} \hfill\mbox{}} {\Huge \textbf{ ANU p\texttt{\symbol{45}}Quotient \mbox{}}}\\ \vfill {\Huge 3.3.3 \mbox{}}\\[1cm] { 25 November 2025 \mbox{}}\\[1cm] \mbox{}\\[2cm] {\Large \textbf{ Greg Gamble\\ \mbox{}}}\\ {\Large \textbf{ Werner Nickel\\ \mbox{}}}\\ {\Large \textbf{ Eamonn O'Brien\\ \mbox{}}}\\ \hypersetup{pdfauthor= Greg Gamble\\ ; Werner Nickel\\ ; Eamonn O'Brien\\ } \mbox{}\\[2cm] \begin{minipage}{12cm}\noindent \textsf{ANUPQ} is maintained by \href{mailto:mhorn@rptu.de} {Max Horn}. For support requests, please use \href{https://github.com/gap-packages/anupq/issues} {our issue tracker}. \end{minipage} \end{center}\vfill \mbox{}\\ {\mbox{}\\ \small \noindent \textbf{ Greg Gamble\\ } Email: \href{mailto://Greg.Gamble@uwa.edu.au} {\texttt{Greg.Gamble@uwa.edu.au}}}\\ {\mbox{}\\ \small \noindent \textbf{ Eamonn O'Brien\\ } Email: \href{mailto://obrien@math.auckland.ac.nz} {\texttt{obrien@math.auckland.ac.nz}}\\ Homepage: \href{https://www.math.auckland.ac.nz/~obrien} {\texttt{https://www.math.auckland.ac.nz/\texttt{\symbol{126}}obrien}}}\\ \end{titlepage} \newpage\setcounter{page}{2} {\small \section*{Copyright} \logpage{[ 0, 0, 1 ]} {\copyright} 2001\texttt{\symbol{45}}2016 by Greg Gamble {\copyright} 2001\texttt{\symbol{45}}2005 by Werner Nickel {\copyright} 1995\texttt{\symbol{45}}2001 by Eamon O'Brien The \textsf{GAP} package \textsf{ANUPQ} is licensed under the \href{https://opensource.org/licenses/artistic-license-2.0} {Artistic License 2.0}. \mbox{}}\\[1cm] \newpage \def\contentsname{Contents\logpage{[ 0, 0, 2 ]}} \tableofcontents \newpage \chapter{\textcolor{Chapter }{Introduction}}\label{Introduction} \logpage{[ 1, 0, 0 ]} \hyperdef{L}{X7DFB63A97E67C0A1}{} { \section{\textcolor{Chapter }{Overview}}\logpage{[ 1, 1, 0 ]} \hyperdef{L}{X8389AD927B74BA4A}{} { \index{ANUPQ} The \textsf{GAP}{\nobreakspace}4 package \textsf{ANUPQ} provides an interface to the ANU \texttt{pq} C program written by Eamonn O'Brien, making the functionality of the C program available to \textsf{GAP}. Henceforth, we shall refer to the \textsf{ANUPQ} package when referring to the \textsf{GAP} interface, and to the ANU \texttt{pq} program or just \texttt{pq} when referring to that C program. The \texttt{pq} program consists of implementations of the following algorithms: \begin{enumerate} \item A \emph{$p$\texttt{\symbol{45}}quotient algorithm} to compute pc\texttt{\symbol{45}}presentations for $p$\texttt{\symbol{45}}factor groups of finitely presented groups. \item A \emph{$p$\texttt{\symbol{45}}group generation algorithm} to generate pc presentations of groups of prime power order. \item A \emph{standard presentation algorithm} used to compute a canonical pc\texttt{\symbol{45}}presentation of a $p$\texttt{\symbol{45}}group. \item An algorithm which can be used to compute the \emph{automorphism group} of a $p$\texttt{\symbol{45}}group. This part of the \texttt{pq} program is not accessible through the \textsf{ANUPQ} package. Instead, users are advised to consider the \textsf{GAP}{\nobreakspace}4 package \textsf{AutPGrp} by Bettina Eick and Eamonn O'Brien, which implements a better algorithm in \textsf{GAP} for the computation of automorphism groups of $p$\texttt{\symbol{45}}groups. \end{enumerate} The current version of the \textsf{ANUPQ} package requires \textsf{GAP}{\nobreakspace}4.5, and version 1.5 of the \textsf{AutPGrp} package. All code that made the package compatible with earlier versions of \textsf{GAP} has been removed. If you must use an older \textsf{GAP} version and cannot upgrade, then you may try using an older \textsf{ANUPQ} version. However, you should not use versions of the \textsf{ANUPQ} package older than 2.2, since they are known to have bugs. } \section{\textcolor{Chapter }{How to read this manual}}\logpage{[ 1, 2, 0 ]} \hyperdef{L}{X8416D2657E7831A1}{} { It is not expected that readers of this manual will read it in a linear fashion from cover to cover; some sections contain material that is far too technical to be absorbed on a first reading. Firstly, installers of the \textsf{ANUPQ} package will need to read Chapter{\nobreakspace}\hyperref[Installing-ANUPQ]{`Installing the ANUPQ Package'}, if they have not already gleaned these details from the \texttt{README} file. Once the \textsf{ANUPQ} package is installed, users of the \textsf{ANUPQ} package will benefit most by first reading Chapter{\nobreakspace}\hyperref[Mathematical Background and Terminology]{`Mathematical Background and Terminology'}, which gives a brief description of the background and terminology used (this chapter also cites a number of references for further reading), and the introduction of Chapter{\nobreakspace}\hyperref[Infrastructure]{`Infrastructure'} (skip the remainder of the chapter on a first reading). Then the user/reader should pursue Chapter{\nobreakspace}\hyperref[non-interact]{`Non\texttt{\symbol{45}}interactive ANUPQ functions'} in detail, delving into Chapter{\nobreakspace}\hyperref[ANUPQ Options]{`ANUPQ Options'} as necessary for the options of the functions that are described. The user will become best acquainted with the \textsf{ANUPQ} package by trying the examples. This chapter describes the non\texttt{\symbol{45}}interactive functions of the \textsf{ANUPQ} package, i.e.{\nobreakspace}``one\texttt{\symbol{45}}shot'' functions that invoke the \texttt{pq} program in such a way that once \textsf{GAP} has got what it needs, the \texttt{pq} is allowed to exit. It is expected that most of the time, users will only need these functions. Advanced users will want to explore Chapter{\nobreakspace}\hyperref[Interactive ANUPQ functions]{`Interactive ANUPQ functions'} which describes all the interactive functions of the \textsf{ANUPQ} package; these are functions that extract information via a dialogue with a running \texttt{pq} process. Occasionally, a user needs the ``next step''; the functions provided in this chapter make use of data from previous steps retained by the \texttt{pq} program, thus allowing the user to interact with the \texttt{pq} program like one can when one uses the \texttt{pq} program as a stand\texttt{\symbol{45}}alone (see{\nobreakspace}\texttt{guide.dvi} in the \texttt{standalone\texttt{\symbol{45}}doc} directory). After having read Chapters{\nobreakspace}\hyperref[non-interact]{`Non\texttt{\symbol{45}}interactive ANUPQ functions'} and{\nobreakspace}\hyperref[Interactive ANUPQ functions]{`Interactive ANUPQ functions'}, cross\texttt{\symbol{45}}references will have taken the reader into Chapter{\nobreakspace}\hyperref[ANUPQ Options]{`ANUPQ Options'}; by this stage, the reader need only read the introduction of Chapter{\nobreakspace}\hyperref[ANUPQ Options]{`ANUPQ Options'}. After the reader has developed some facility with the \textsf{ANUPQ} package, she should explore the examples described in Appendix{\nobreakspace}\hyperref[Examples]{`Examples'}. If you run into trouble using the \textsf{ANUPQ} functions, some troubleshooting hints are given in Section{\nobreakspace}\hyperref[Hints and Warnings regarding the use of Options]{`Hints and Warnings regarding the use of Options'}. If the troubleshooting hints don't help, Section{\nobreakspace}\hyperref[Authors and Acknowledgements]{`Authors and Acknowledgements'} below, gives contact details for the authors of the components of the \textsf{ANUPQ} package. } \section{\textcolor{Chapter }{Authors and Acknowledgements}}\label{Authors and Acknowledgements} \logpage{[ 1, 3, 0 ]} \hyperdef{L}{X79D2480A7810A7CC}{} { The C implementation of the ANU \texttt{pq} standalone was developed by Eamonn O'Brien. An interactive interface using iostreams was developed with the assistance of Werner Nickel by Greg Gamble. The \textsf{GAP} 4 version of this package was adapted from the \textsf{GAP} 3 version by Werner Nickel. A new co\texttt{\symbol{45}}maintainer, Max Horn, joined the team in November, 2011. The authors would like to thank Joachim Neub{\"u}ser for his careful proof\texttt{\symbol{45}}reading and advice, and for formulating Chapter{\nobreakspace}\hyperref[Mathematical Background and Terminology]{`Mathematical Background and Terminology'}. We would also like to thank Bettina Eick who by her testing and provision of examples helped us to eliminate a number of bugs and who provided a number of valuable suggestions for extensions of the package beyond the \textsf{GAP}{\nobreakspace}3 capabilities. \index{bug reports} If you find a bug, the last section of \textsf{ANUPQ}'s \texttt{README} describes the information we need and where to send us a bug report; please take the time to read this (i.e.{\nobreakspace}help us to help you). } } \chapter{\textcolor{Chapter }{Mathematical Background and Terminology}}\label{Mathematical Background and Terminology} \logpage{[ 2, 0, 0 ]} \hyperdef{L}{X7E7F3B617F42EF03}{} { In this chapter we will give a brief description of the mathematical notions used in the algorithms implemented in the ANU \texttt{pq} program that are made accessible from \textsf{GAP} through this package. For proofs and details we will point to relevant places in the published literature. Also we will try to give some explanation of terminology that may help to use the ``low\texttt{\symbol{45}}level'' interactive functions described in Section{\nobreakspace}\hyperref[Low-level Interactive ANUPQ functions based on menu items of the pq program]{`Low\texttt{\symbol{45}}level Interactive ANUPQ functions based on menu items of the pq program'}. However, users who intend to use these functions are strongly advised to acquire a thorough understanding of the algorithms from the quoted literature. There is little or no checking done in these functions and naive use may result in incorrect results. \section{\textcolor{Chapter }{Basic notions}}\label{Basic-notions} \logpage{[ 2, 1, 0 ]} \hyperdef{L}{X79A052C47C92AF09}{} { Throughout this manual, by $p$\texttt{\symbol{45}}group we always mean \emph{finite} $p$\texttt{\symbol{45}}group. \subsection{\textcolor{Chapter }{pc Presentations and Consistency}}\logpage{[ 2, 1, 1 ]} \hyperdef{L}{X7BD675838609D547}{} { For details, see e.g.{\nobreakspace}\cite{NNN98}. Every finite $p$\texttt{\symbol{45}}group $G$ has a presentation of the form: \[ \{a_1,\dots,a_n \mid a_i^p = v_{ii}, 1 \le i \le n, [a_k, a_j] = v_{jk}, 1 \le j < k \le n \}. \] where $v_{jk}$ is a word in the elements $a_{k+1},\dots,a_n$ for $1 \le j \leq k \le n$. \index{power\texttt{\symbol{45}}commutator presentation}\index{pc presentation}\index{pcp} \index{pc generators}\index{collection} This is called a \emph{power\texttt{\symbol{45}}commutator} presentation (or \emph{pc presentation} or \emph{pcp}) of $G$, generators from such a presentation will be referred to as \emph{pc generators}. In terms of such pc generators every element of $G$ can be written in a ``normal form'' $a_1^{e_1}\dots a_n^{e_n}$ with $0 \le e_i < p$. Moreover any given product of the generators can be brought into such a normal form using the defining relations in the above presentation as rewrite rules. Any such process is called \emph{collection}. For the discussion of various collection methods see \cite{LGS90} and \cite{VL90a}. \index{consistent}\index{confluent rewriting system}\index{confluent} Every $p$\texttt{\symbol{45}}group of order $p^n$ has such a pcp on $n$ generators and conversely every such presentation defines a $p$\texttt{\symbol{45}}group. However a $p$\texttt{\symbol{45}}group defined by a pcp on $n$ generators can be of smaller order $p^m$ with $m d$ one relation, having this generator as its right hand side, is marked as \emph{definition} of this generator. As described in \cite{NNN98}, a weighted labelled pcp of a $p$\texttt{\symbol{45}}group can be obtained stepping down its $p$\texttt{\symbol{45}}central series. So let us assume that a weighted labelled pcp of $G_i$ is given. A straightforward way of of writing down a (not necessarily consistent) pcp for its $p$\texttt{\symbol{45}}cover is to add generators, one for each relation which is not a definition, and modify the right hand side of each such relation by multiplying it on the right by one of the new generators \texttt{\symbol{45}}\texttt{\symbol{45}} a different generator for each such relation. Further relations are then added to make the new generators central and of order $p$. This procedure is called \emph{adding tails}. A more formal description of it is again given in \cite{NNN98}. \index{tails} It is important to realise that the ``new'' generators will generate an elementary abelian group, that is, in additive notation, a vector space over the field of $p$ elements. As said, the pcp of the $p$\texttt{\symbol{45}}cover obtained in this way need not be consistent. Since the pcp of $G_i$ was consistent, applying the consistency conditions to the pcp of the $p$\texttt{\symbol{45}}cover, in case the presentation obtained for $p$\texttt{\symbol{45}}cover is not consistent, will produce a set of equations between the new generators, that, written additively, are linear equations over the field of $p$ elements and can hence be used to remove redundant generators until a consistent pcp is obtained. In reality, to follow this straightforward procedure would be forbiddingly inefficient except for very small examples. There are many ways of a priori reducing the number of ``new generators'' to be introduced, using e.g.{\nobreakspace}the weights attached to the generators, and the main part of \cite{NNN98} is devoted to a detailed discussion with proofs of these possibilities. } \subsection{\textcolor{Chapter }{Imposing the Relations of the fp Group}}\logpage{[ 2, 2, 2 ]} \hyperdef{L}{X804CF5C97F7BB880}{} { In order to obtain $G/P_{i+1}(G)$ from the pcp of the $p$\texttt{\symbol{45}}cover of $G_i = G/P_i(G)$, the defining relations from the original presentation of $G$ must be imposed. Since $G_i$ is a homomorphic image of $G$, these relations again yield relations between the ``new generators'' in the presentation of the $p$\texttt{\symbol{45}}cover of $G_i$. } \subsection{\textcolor{Chapter }{Imposing Laws}}\logpage{[ 2, 2, 3 ]} \hyperdef{L}{X7F1A8CCD84462775}{} { While we have so far only considered the computation of the factor groups of a given fp group by the groups of its descending $p$\texttt{\symbol{45}}central series, the $p$\texttt{\symbol{45}}quotient algorithm allows a very important variant of this idea: laws can be prescribed that should be fulfilled by the $p$\texttt{\symbol{45}}factor groups computed by the algorithm. The key observation here is the fact that at each step down the descending $p$\texttt{\symbol{45}}central series it suffices to impose these laws only for a finite number of words. Again for efficiency of the method it is crucial to keep the number of such words small, and much of \cite{NO96} and the literature quoted in this paper is devoted to this problem. \index{exponent check} In this form, starting with a free group and imposing an exponent law (also referred to as an \emph{exponent check}) the \texttt{pq} program has, in fact, found its most noted application in the determination of (restricted) Burnside groups (as reported in e.g.{\nobreakspace}\cite{HN80}, \cite{NO96} and \cite{VL90b}). Via a \textsf{GAP} program using the ``local'' interactive functions of the \texttt{pq} program made available through this interface also arbitrary laws can be imposed via the option \texttt{Identities} (see{\nobreakspace}\ref{option Identities}). } } \section{\textcolor{Chapter }{The p\texttt{\symbol{45}}group generation Algorithm, Standard Presentation, Isomorphism Testing}}\label{The p-group generation Algorithm, Standard Presentation, Isomorphism Testing} \logpage{[ 2, 3, 0 ]} \hyperdef{L}{X807FB2EC85E6648D}{} { For details, see \cite{New77} and \cite{OBr90}. \index{p\texttt{\symbol{45}}group generation}\index{orbits} The $p$\texttt{\symbol{45}}group generation algorithm determines the immediate descendants of a given $p$\texttt{\symbol{45}}group $G$ up to isomorphism. From what has been explained in Section{\nobreakspace}\hyperref[Basic-notions]{`Basic notions'}, it is clear that this amounts to the construction of the $p$\texttt{\symbol{45}}cover, the extension of the automorphisms of $G$ to the $p$\texttt{\symbol{45}}cover and the determination of representatives of the orbits of the action of these automorphisms on the set of supplements of the nucleus in the $p$\texttt{\symbol{45}}multiplicator. The main practical problem here is the determination of these representatives. \cite{OBr90} describes methods for this and the \texttt{pq} program allows choices according to whether space or time limitations must be met. As well as the descendants of $G$, the \texttt{pq} program determines their automorphism groups from that of $G$ (see{\nobreakspace}\cite{OBr95}), which is important for an iteration of the process; this has been used by Eamonn O'Brien, e.g.{\nobreakspace}in the classification of the $2$\texttt{\symbol{45}}groups that are now also part of the \emph{Small Groups} library available through \textsf{GAP}. \index{standard presentation}\index{echelonised matrix} \index{label of standard matrix} A variant of the $p$\texttt{\symbol{45}}group generation algorithm is also used to define a \emph{standard presentation} of a given $p$\texttt{\symbol{45}}group. This is done by constructing an isomorphic copy of the given group through a chain of descendants and at each step making a choice of a particular representative for the respective orbit of capable groups. In a fairly delicate process, subgroups of the $p$\texttt{\symbol{45}}multiplicator are represented by \emph{echelonised matrices} and a first among the \emph{labels for standard matrices} is chosen (this is described in detail in \cite{OBr94}). \index{isomorphism testing}\index{compaction} Finally, the standard presentation provides a way of testing if two given $p$\texttt{\symbol{45}}groups are isomorphic: the standard presentations of the groups are computed, for practical purposes \emph{compacted} and the results compared for being identical, i.e.{\nobreakspace}the groups are isomorphic if and only if their standard presentations are identical. } } \chapter{\textcolor{Chapter }{Infrastructure}}\label{Infrastructure} \logpage{[ 3, 0, 0 ]} \hyperdef{L}{X7917EFDF7AC06F04}{} { Most of the details in this chapter are of a technical nature; the user need only skim over this chapter on a first reading. Mostly, it is enough to know that \begin{itemize} \item you must do a \texttt{LoadPackage("anupq");} before you can expect to use a command defined by the \textsf{ANUPQ} package (details are in Section{\nobreakspace}\hyperref[Loading the ANUPQ Package]{`Loading the ANUPQ Package'}); \item partial results of \textsf{ANUPQ} commands and some other data are stored in the \texttt{ANUPQData} global variable (details are in Section{\nobreakspace}\hyperref[The ANUPQData Record]{`The ANUPQData Record'}); \item doing \texttt{SetInfoLevel(InfoANUPQ, \mbox{\texttt{\mdseries\slshape n}});} for \mbox{\texttt{\mdseries\slshape n}} greater than the default value 1 will give progressively more information of what is going on ``behind the scenes'' (details are in Section{\nobreakspace}\hyperref[Setting the Verbosity of ANUPQ via Info and InfoANUPQ]{`Setting the Verbosity of ANUPQ via Info and InfoANUPQ'}); \item in Section{\nobreakspace}\hyperref[Utility-Functions]{`Utility Functions'} we describe some utility functions and functions that run examples from the collection of examples of this package; \item in Section{\nobreakspace}\hyperref[Attributes and a Property for fp and pc p-groups]{`Attributes and a Property for fp and pc p\texttt{\symbol{45}}groups'} we describe the attributes and property \texttt{NuclearRank}, \texttt{MultiplicatorRank} and \texttt{IsCapable}; and \item in Section{\nobreakspace}\hyperref[Hints and Warnings regarding the use of Options]{`Hints and Warnings regarding the use of Options'} we describe some troubleshooting strategies. Also this section explains the utility of setting \texttt{ANUPQWarnOfOtherOptions := true;} (particularly for novice users) for detecting misspelt options and diagnosing other option usage problems. \end{itemize} \section{\textcolor{Chapter }{Loading the ANUPQ Package}}\label{Loading the ANUPQ Package} \logpage{[ 3, 1, 0 ]} \hyperdef{L}{X833D58248067E13B}{} { \index{banner} To use the \textsf{ANUPQ} package, as with any \textsf{GAP} package, it must be requested explicitly. This is done by calling \begin{Verbatim}[commandchars=!|D,fontsize=\small,frame=single,label=Example] !gapprompt|gap>D !gapinput|LoadPackage( "anupq" );D --------------------------------------------------------------------------- Loading ANUPQ 3.3.3 (ANU p-Quotient) by Greg Gamble (GAP code, Greg.Gamble@uwa.edu.au), Werner Nickel (GAP code), and Eamonn O'Brien (C code, https://www.math.auckland.ac.nz/~obrien). maintained by: Max Horn (https://www.quendi.de/math). uses ANU pq binary (C code program) version: 1.9 Homepage: https://gap-packages.github.io/anupq/ Report issues at https://github.com/gap-packages/anupq/issues --------------------------------------------------------------------------- true \end{Verbatim} Note that since the \textsf{ANUPQ} package uses the \texttt{AutomorphimGroupPGroup} function of the \textsf{AutPGrp} package and, in any case, often needs other \textsf{AutPGrp} functions when computing descendants, the user must ensure that the \textsf{AutPGrp} package is also installed, at least version 1.5. If the \textsf{AutPGrp} package is not installed, the \textsf{ANUPQ} package will \texttt{fail} to load. Also, if \textsf{GAP} cannot find a working \texttt{pq} binary, the call to \texttt{LoadPackage} will return \texttt{fail}. If you want to load the \textsf{ANUPQ} package by default, you can put the \texttt{LoadPackage} command into your \texttt{gap.ini} file (see Section{\nobreakspace} \textbf{Reference: The gap.ini and gaprc files} in the \textsf{GAP} Reference Manual). By the way, the novice user of the \textsf{ANUPQ} package should probably also append the line \begin{Verbatim}[commandchars=!@|,fontsize=\small,frame=single,label=Example] ANUPQWarnOfOtherOptions := true; \end{Verbatim} to their \texttt{gap.ini} file, somewhere after the \texttt{LoadPackage( "anupq" );} command (see{\nobreakspace}\texttt{ANUPQWarnOfOtherOptions} (\ref{ANUPQWarnOfOtherOptions})). } \section{\textcolor{Chapter }{The ANUPQData Record}}\label{The ANUPQData Record} \logpage{[ 3, 2, 0 ]} \hyperdef{L}{X83DE155A79C38DBE}{} { This section contains fairly technical details which may be skipped on an initial reading. \subsection{\textcolor{Chapter }{ANUPQData}} \logpage{[ 3, 2, 1 ]}\nobreak \hyperdef{L}{X7B90E89782BDA6D7}{} {\noindent\textcolor{FuncColor}{$\triangleright$\enspace\texttt{ANUPQData\index{ANUPQData@\texttt{ANUPQData}} \label{ANUPQData} }\hfill{\scriptsize (global variable)}}\\ is a \textsf{GAP} record in which the essential data for an \textsf{ANUPQ} session within \textsf{GAP} is stored; its fields are: \begin{description} \item[{\texttt{binary}}] the path of the \texttt{pq} binary; \item[{\texttt{tmpdir}}] the path of the temporary directory used by the \texttt{pq} binary and \textsf{GAP} (i.e.{\nobreakspace}the directory in which all the \texttt{pq}'s temporary files are created) (also see \texttt{ANUPQDirectoryTemporary} (\ref{ANUPQDirectoryTemporary}) below); \item[{\texttt{outfile}}] the full path of the default \texttt{pq} output file; \item[{\texttt{SPimages}}] the full path of the file \texttt{GAP{\textunderscore}library} to which the \texttt{pq} program writes its Standard Presentation images; \item[{\texttt{version}}] the version of the current \texttt{pq} binary; \item[{\texttt{ni}}] a data record used by non\texttt{\symbol{45}}interactive functions (see below and Chapter{\nobreakspace}\hyperref[non-interact]{`Non\texttt{\symbol{45}}interactive ANUPQ functions'}); \item[{\texttt{io}}] list of data records for \texttt{PqStart} (see below and{\nobreakspace}\texttt{PqStart} (\ref{PqStart})) processes; \item[{\texttt{topqlogfile}}] name of file logged to by \texttt{ToPQLog} (see{\nobreakspace}\texttt{ToPQLog} (\ref{ToPQLog})); and \item[{\texttt{logstream}}] stream of file logged to by \texttt{ToPQLog} (see{\nobreakspace}\texttt{ToPQLog} (\ref{ToPQLog})). \end{description} Each time an interactive \textsf{ANUPQ} process is initiated via \texttt{PqStart} (see{\nobreakspace}\texttt{PqStart} (\ref{PqStart})), an identifying number \mbox{\texttt{\mdseries\slshape ioIndex}} is generated for the interactive process and a record \texttt{ANUPQData.io[\mbox{\texttt{\mdseries\slshape ioIndex}}]} with some or all of the fields listed below is created. Whenever a non\texttt{\symbol{45}}interactive function is called (see Chapter{\nobreakspace}\hyperref[non-interact]{`Non\texttt{\symbol{45}}interactive ANUPQ functions'}), the record \texttt{ANUPQData.ni} is updated with fields that, if bound, have exactly the same purpose as for a \texttt{ANUPQData.io[\mbox{\texttt{\mdseries\slshape ioIndex}}]} record. \begin{description} \item[{\texttt{stream}}] the IOStream opened for interactive \textsf{ANUPQ} process \mbox{\texttt{\mdseries\slshape ioIndex}} or non\texttt{\symbol{45}}interactive \textsf{ANUPQ} function; \item[{\texttt{group}}] the group given as first argument to \texttt{PqStart}, \texttt{Pq}, \texttt{PqEpimorphism}, \texttt{PqDescendants} or \texttt{PqStandardPresentation} (or any synonymous methods); \item[{\texttt{haspcp}}] is bound and set to \texttt{true} when a pc presentation is first set inside the \texttt{pq} program (e.g.{\nobreakspace}by \texttt{PqPcPresentation} or \texttt{PqRestorePcPresentation} or a higher order function like \texttt{Pq}, \texttt{PqEpimorphism}, \texttt{PqPCover}, \texttt{PqDescendants} or \texttt{PqStandardPresentation} that does a \texttt{PqPcPresentation} operation, but \emph{not} \texttt{PqStart} which only starts up an interactive \textsf{ANUPQ} process); \item[{\texttt{gens}}] a list of the generators of the group \texttt{group} as strings (the same as those passed to the \texttt{pq} program); \item[{\texttt{rels}}] a list of the relators of the group \texttt{group} as strings (the same as those passed to the \texttt{pq} program); \item[{\texttt{name}}] the name of the group whose pc presentation is defined by a call to the \texttt{pq} program (according to the \texttt{pq} program \texttt{\symbol{45}}\texttt{\symbol{45}} unless you have used the \texttt{GroupName} option (see e.g.{\nobreakspace}\texttt{Pq} (\ref{Pq})) or applied the function \texttt{SetName} (see{\nobreakspace}\texttt{SetName} (\textbf{Reference: Name})) to the group, the ``generic'' name \texttt{"[grp]"} is set as a default); \item[{\texttt{gpnum}}] if not a null string, the ``number'' (i.e.{\nobreakspace}the unique label assigned by the \texttt{pq} program) of the last descendant processed; \item[{\texttt{class}}] the largest lower exponent\texttt{\symbol{45}}$p$ central class of a quotient group of the group (usually \texttt{group}) found by a call to the \texttt{pq} program; \item[{\texttt{forder}}] the factored order of the quotient group of largest lower exponent\texttt{\symbol{45}}$p$ central class found for the group (usually \texttt{group}) by a call to the \texttt{pq} program (this factored order is given as a list \texttt{[p,n]}, indicating an order of $p^n$); \item[{\texttt{pcoverclass}}] the lower exponent\texttt{\symbol{45}}$p$ central class of the $p$\texttt{\symbol{45}}covering group of a $p$\texttt{\symbol{45}}quotient of the group (usually \texttt{group}) found by a call to the \texttt{pq} program; \item[{\texttt{workspace}}] the workspace set for the \texttt{pq} process (either given as a second argument to \texttt{PqStart}, or set by default to 10000000); \item[{\texttt{menu}}] the current menu of the \texttt{pq} process (the \texttt{pq} program is managed by various menus, the details of which the user shouldn't normally need to know about \texttt{\symbol{45}}\texttt{\symbol{45}} the \texttt{menu} field remembers which menu the \texttt{pq} process is currently ``in''); \item[{\texttt{outfname}}] is the file to which \texttt{pq} output is directed, which is always \texttt{ANUPQData.outfile}, except when option \texttt{SetupFile} is used with a non\texttt{\symbol{45}}interactive function, in which case \texttt{outfname} is set to \texttt{"PQ{\textunderscore}OUTPUT"}; \item[{\texttt{pQuotient}}] is set to the value returned by \texttt{Pq} (see{\nobreakspace}\texttt{Pq} (\ref{Pq})) (the field \texttt{pQepi} is also set at the same time); \item[{\texttt{pQepi}}] is set to the value returned by \texttt{PqEpimorphism} (see{\nobreakspace}\texttt{PqEpimorphism} (\ref{PqEpimorphism})) (the field \texttt{pQuotient} is also set at the same time); \item[{\texttt{pCover}}] is set to the value returned by \texttt{PqPCover} (see{\nobreakspace}\texttt{PqPCover} (\ref{PqPCover})); \item[{\texttt{SP}}] is set to the value returned by \texttt{PqStandardPresentation} or \texttt{StandardPresentation} (see{\nobreakspace}\texttt{PqStandardPresentation} (\ref{PqStandardPresentation:interactive})) when called interactively, for process \mbox{\texttt{\mdseries\slshape i}} (the field \texttt{SPepi} is also set at the same time); \item[{\texttt{SPepi}}] is set to the value returned by \texttt{EpimorphismPqStandardPresentation} or \texttt{EpimorphismStandardPresentation} (see{\nobreakspace}\texttt{EpimorphismPqStandardPresentation} (\ref{EpimorphismPqStandardPresentation:interactive})) when called interactively, for process \mbox{\texttt{\mdseries\slshape i}} (the field \texttt{SP} is also set at the same time); \item[{\texttt{descendants}}] is set to the value returned by \texttt{PqDescendants} (see{\nobreakspace}\texttt{PqDescendants} (\ref{PqDescendants})); \item[{\texttt{treepos}}] if set by a call to \texttt{PqDescendantsTreeCoclassOne} (see{\nobreakspace}\texttt{PqDescendantsTreeCoclassOne} (\ref{PqDescendantsTreeCoclassOne})), it contains a record with fields \texttt{class}, \texttt{node} and \texttt{ndes} being the information that determines the last descendant with a non\texttt{\symbol{45}}zero number of descendants processed; \item[{\texttt{xgapsheet}}] if set by a call to \texttt{PqDescendantsTreeCoclassOne} (see{\nobreakspace}\texttt{PqDescendantsTreeCoclassOne} (\ref{PqDescendantsTreeCoclassOne})) during an \textsf{XGAP} session, it contains the \textsf{XGAP} \texttt{Sheet} on which the descendants tree is displayed; and \item[{\texttt{nextX}}] if set by a call to \texttt{PqDescendantsTreeCoclassOne} (see{\nobreakspace}\texttt{PqDescendantsTreeCoclassOne} (\ref{PqDescendantsTreeCoclassOne})) during an \textsf{XGAP} session, it contains a list of integers, the \mbox{\texttt{\mdseries\slshape i}}th entry of which is the \mbox{\texttt{\mdseries\slshape x}}\texttt{\symbol{45}}coordinate of the next node (representing a descendant) for the \mbox{\texttt{\mdseries\slshape i}}th class. \end{description} } \subsection{\textcolor{Chapter }{ANUPQDirectoryTemporary}} \logpage{[ 3, 2, 2 ]}\nobreak \hyperdef{L}{X7FBB2F457E4BD6AB}{} {\noindent\textcolor{FuncColor}{$\triangleright$\enspace\texttt{ANUPQDirectoryTemporary({\mdseries\slshape dir})\index{ANUPQDirectoryTemporary@\texttt{ANUPQDirectoryTemporary}} \label{ANUPQDirectoryTemporary} }\hfill{\scriptsize (function)}}\\ calls the UNIX command \texttt{mkdir} to create \mbox{\texttt{\mdseries\slshape dir}}, which must be a string, and if successful a directory object for \mbox{\texttt{\mdseries\slshape dir}} is both assigned to \texttt{ANUPQData.tmpdir} and returned. The field \texttt{ANUPQData.outfile} is also set to be a file in \texttt{ANUPQData.tmpdir}, and on exit from \textsf{GAP} \mbox{\texttt{\mdseries\slshape dir}} is removed. Most users will never need this command; by default, \textsf{GAP} typically chooses a ``random'' subdirectory of \texttt{/tmp} for \texttt{ANUPQData.tmpdir} which may occasionally have limits on what may be written there. \texttt{ANUPQDirectoryTemporary} permits the user to choose a directory (object) where one is not so limited. } } \section{\textcolor{Chapter }{Setting the Verbosity of ANUPQ via Info and InfoANUPQ}}\label{Setting the Verbosity of ANUPQ via Info and InfoANUPQ} \logpage{[ 3, 3, 0 ]} \hyperdef{L}{X83E5C7CF7D8739DF}{} { \subsection{\textcolor{Chapter }{InfoANUPQ}} \logpage{[ 3, 3, 1 ]}\nobreak \hyperdef{L}{X7CBC9B458497BFF1}{} {\noindent\textcolor{FuncColor}{$\triangleright$\enspace\texttt{InfoANUPQ\index{InfoANUPQ@\texttt{InfoANUPQ}} \label{InfoANUPQ} }\hfill{\scriptsize (info class)}}\\ The input to and the output from the \texttt{pq} program is, by default, not displayed. However the user may choose to see some, or all, of this input/output. This is done via the \texttt{Info} mechanism (see Section{\nobreakspace} \textbf{Reference: Info Functions} in the \textsf{GAP} Reference Manual). For this purpose, there is the \mbox{\texttt{\mdseries\slshape InfoClass}} \texttt{InfoANUPQ}. If the \texttt{InfoLevel} of \texttt{InfoANUPQ} is high enough each line of \texttt{pq} input/output is directed to a call to \texttt{Info} and will be displayed for the user to see. By default, the \texttt{InfoLevel} of \texttt{InfoANUPQ} is 1, and it is recommended that you leave it at this level, or higher. Messages that the user should presumably want to see and output from the \texttt{pq} program influenced by the value of the option \texttt{OutputLevel} (see the options listed in Section{\nobreakspace}\texttt{Pq} (\ref{Pq})), other than timing and memory usage are directed to \texttt{Info} at \texttt{InfoANUPQ} level 1. To turn off \emph{all} \texttt{InfoANUPQ} messaging, set the \texttt{InfoANUPQ} level to 0. There are five other user\texttt{\symbol{45}}intended \texttt{InfoANUPQ} levels: 2, 3, 4, 5 and 6. \begin{Verbatim}[commandchars=!@|,fontsize=\small,frame=single,label=Example] !gapprompt@gap>| !gapinput@SetInfoLevel(InfoANUPQ, 2);| \end{Verbatim} enables the display of most timing and memory usage data from the \texttt{pq} program, and also the number of identity instances when the \texttt{Identities} option is used. (Some timing and memory usage data, particularly when profuse in quantity, is \texttt{Info}\texttt{\symbol{45}}ed at \texttt{InfoANUPQ} level 3 instead.) Note that the the \textsf{GAP} functions \texttt{time} and \texttt{Runtime} (see{\nobreakspace}\texttt{Runtime} (\textbf{Reference: Runtime}) in the \textsf{GAP} Reference Manual) count the time spent by \textsf{GAP} and \emph{not} the time spent by the (external) \texttt{pq} program. \begin{Verbatim}[commandchars=!@|,fontsize=\small,frame=single,label=Example] !gapprompt@gap>| !gapinput@SetInfoLevel(InfoANUPQ, 3);| \end{Verbatim} enables the display of output of the nature of the first two \texttt{InfoANUPQ} that was not directly invoked by the user (e.g.{\nobreakspace}some commands require \textsf{GAP} to discover something about the current state known to the \texttt{pq} program). The identity instances processed under the \texttt{Identities} option are also displayed at this level. In some cases, the \texttt{pq} program produces a lot of output despite the fact that the \texttt{OutputLevel} (see{\nobreakspace}\ref{option OutputLevel}) is unset or is set to 0; such output is also \texttt{Info}\texttt{\symbol{45}}ed at \texttt{InfoANUPQ} level 3. \begin{Verbatim}[commandchars=!@|,fontsize=\small,frame=single,label=Example] !gapprompt@gap>| !gapinput@SetInfoLevel(InfoANUPQ, 4);| \end{Verbatim} enables the display of all the commands directed to the \texttt{pq} program, behind a ``\texttt{ToPQ{\textgreater} }'' prompt (so that you can distinguish it from the output from the \texttt{pq} program). See Section{\nobreakspace}\hyperref[Hints and Warnings regarding the use of Options]{`Hints and Warnings regarding the use of Options'} for an example of how this can be a useful troubleshooting tool. \begin{Verbatim}[commandchars=!@|,fontsize=\small,frame=single,label=Example] !gapprompt@gap>| !gapinput@SetInfoLevel(InfoANUPQ, 5);| \end{Verbatim} enables the display of the \texttt{pq} program's prompts for input. Finally, \begin{Verbatim}[commandchars=!@|,fontsize=\small,frame=single,label=Example] !gapprompt@gap>| !gapinput@SetInfoLevel(InfoANUPQ, 6);| \end{Verbatim} enables the display of all other output from the \texttt{pq} program, namely the banner and menus. However, the timing data printed when the \texttt{pq} program exits can never be observed. } } \section{\textcolor{Chapter }{Utility Functions}}\label{Utility-Functions} \logpage{[ 3, 4, 0 ]} \hyperdef{L}{X810FFB1C8035C8BE}{} { \subsection{\textcolor{Chapter }{PqLeftNormComm}} \logpage{[ 3, 4, 1 ]}\nobreak \hyperdef{L}{X8771393B7F53F534}{} {\noindent\textcolor{FuncColor}{$\triangleright$\enspace\texttt{PqLeftNormComm({\mdseries\slshape elts})\index{PqLeftNormComm@\texttt{PqLeftNormComm}} \label{PqLeftNormComm} }\hfill{\scriptsize (function)}}\\ returns for a list of elements of some group (e.g.{\nobreakspace}\mbox{\texttt{\mdseries\slshape elts}} may be a list of words in the generators of a free or fp group) the left normed commutator of \mbox{\texttt{\mdseries\slshape elts}}, e.g.{\nobreakspace}if \mbox{\texttt{\mdseries\slshape w1}}, \mbox{\texttt{\mdseries\slshape w2}}, \mbox{\texttt{\mdseries\slshape w3}} are such elements then \texttt{PqLeftNormComm( [\mbox{\texttt{\mdseries\slshape w1}}, \mbox{\texttt{\mdseries\slshape w2}}, \mbox{\texttt{\mdseries\slshape w3}}] );} is equivalent to \texttt{Comm( Comm( \mbox{\texttt{\mdseries\slshape w1}}, \mbox{\texttt{\mdseries\slshape w2}} ), \mbox{\texttt{\mdseries\slshape w3}} );}. \emph{Note:} \mbox{\texttt{\mdseries\slshape elts}} must contain at least two elements. } \subsection{\textcolor{Chapter }{PqGAPRelators}} \logpage{[ 3, 4, 2 ]}\nobreak \hyperdef{L}{X7A567432879510A6}{} {\noindent\textcolor{FuncColor}{$\triangleright$\enspace\texttt{PqGAPRelators({\mdseries\slshape group, rels})\index{PqGAPRelators@\texttt{PqGAPRelators}} \label{PqGAPRelators} }\hfill{\scriptsize (function)}}\\ returns a list of words that \textsf{GAP} understands, given a list \mbox{\texttt{\mdseries\slshape rels}} of strings in the string representations of the generators of the fp group \mbox{\texttt{\mdseries\slshape group}} prepared as a list of relators for the \texttt{pq} program. \emph{Note:} The \texttt{pq} program does not use \texttt{/} to indicate multiplication by an inverse and uses square brackets to represent (left normed) commutators. Also, even though the \texttt{pq} program accepts relations, all elements of \mbox{\texttt{\mdseries\slshape rels}} \emph{must} be in relator form, i.e.{\nobreakspace}a relation of form \texttt{\mbox{\texttt{\mdseries\slshape w1}} = \mbox{\texttt{\mdseries\slshape w2}}} must be written as \texttt{\mbox{\texttt{\mdseries\slshape w1}}*(\mbox{\texttt{\mdseries\slshape w2}})\texttt{\symbol{94}}\texttt{\symbol{45}}1}. Here is an example: \begin{Verbatim}[commandchars=!@|,fontsize=\small,frame=single,label=Example] !gapprompt@gap>| !gapinput@F := FreeGroup("a", "b");| !gapprompt@gap>| !gapinput@PqGAPRelators(F, [ "a*b^2", "[a,b]^2*a", "[a,b,a,b]^a" ]);| [ a*b^2, (a^-1*b^-1*a*b)^2*a, a^-2*b^-1*a^-1*b*(a*b^-1)^2*a^-1*b*a^-1*b^-1*(a*b)^2*a ] \end{Verbatim} } \subsection{\textcolor{Chapter }{PqParseWord}} \logpage{[ 3, 4, 3 ]}\nobreak \hyperdef{L}{X7F3C5D1C7EC36EAE}{} {\noindent\textcolor{FuncColor}{$\triangleright$\enspace\texttt{PqParseWord({\mdseries\slshape word, n})\index{PqParseWord@\texttt{PqParseWord}} \label{PqParseWord} }\hfill{\scriptsize (function)}}\\ parses a \mbox{\texttt{\mdseries\slshape word}}, a string representing a word in the pc generators \texttt{x1,...,x\mbox{\texttt{\mdseries\slshape n}}}, through \textsf{GAP}. This function is provided as a rough\texttt{\symbol{45}}and\texttt{\symbol{45}}ready check of \mbox{\texttt{\mdseries\slshape word}} for syntax errors. A syntax error will cause the entering of a \texttt{break}\texttt{\symbol{45}}loop, in which the error message may or may not be meaningful (depending on whether the syntax error gets caught at the \textsf{GAP} or kernel level). \emph{Note:} The reason the generators \emph{must} be \texttt{x1,...,x\mbox{\texttt{\mdseries\slshape n}}} is that these are the pc generator names used by the \texttt{pq} program (as distinct from the generator names for the group provided by the user to a function like \texttt{Pq} that invokes the \texttt{pq} program). } \subsection{\textcolor{Chapter }{PqExample (no arguments)}} \logpage{[ 3, 4, 4 ]}\nobreak \hyperdef{L}{X7BB0EB607F337265}{} {\noindent\textcolor{FuncColor}{$\triangleright$\enspace\texttt{PqExample({\mdseries\slshape })\index{PqExample@\texttt{PqExample}!no arguments} \label{PqExample:no arguments} }\hfill{\scriptsize (function)}}\\ \noindent\textcolor{FuncColor}{$\triangleright$\enspace\texttt{PqExample({\mdseries\slshape example[, PqStart][, Display]})\index{PqExample@\texttt{PqExample}} \label{PqExample} }\hfill{\scriptsize (function)}}\\ \noindent\textcolor{FuncColor}{$\triangleright$\enspace\texttt{PqExample({\mdseries\slshape example[, PqStart][, filename]})\index{PqExample@\texttt{PqExample}!with filename} \label{PqExample:with filename} }\hfill{\scriptsize (function)}}\\ With no arguments, or with single argument \texttt{"index"}, or a string \mbox{\texttt{\mdseries\slshape example}} that is not the name of a file in the \texttt{examples} directory, an index of available examples is displayed. With just the one argument \mbox{\texttt{\mdseries\slshape example}} that is the name of a file in the \texttt{examples} directory, the example contained in that file is executed in its simplest form. Some examples accept options which you may use to modify some of the options used in the commands of the example. To find out which options an example accepts, use one of the mechanisms for displaying the example described below. Some examples have both non\texttt{\symbol{45}}interactive and interactive forms; those that are non\texttt{\symbol{45}}interactive only have a name ending in \texttt{\texttt{\symbol{45}}ni}; those that are interactive only have a name ending in \texttt{\texttt{\symbol{45}}i}; examples with names ending in \texttt{.g} also have only one form; all other examples have both non\texttt{\symbol{45}}interactive and interactive forms and for these giving \texttt{PqStart} as second argument invokes \texttt{PqStart} initially and makes the appropriate adjustments so that the example is executed or displayed using interactive functions. If \texttt{PqExample} is called with last (second or third) argument \texttt{Display} then the example is displayed without being executed. If the last argument is a non\texttt{\symbol{45}}empty string \mbox{\texttt{\mdseries\slshape filename}} then the example is also displayed without being executed but is also written to a file with that name. Passing an empty string as last argument has the same effect as passing \texttt{Display}. \emph{Note:} The variables used in \texttt{PqExample} are local to the running of \texttt{PqExample}, so there's no danger of having some of your variables over\texttt{\symbol{45}}written. However, they are not completely lost either. They are saved to a record \texttt{ANUPQData.examples.vars}, i.e.{\nobreakspace}if \texttt{F} is a variable used in the example then you will be able to access it after \texttt{PqExample} has finished as \texttt{ANUPQData.examples.vars.F}. } \subsection{\textcolor{Chapter }{AllPqExamples}} \logpage{[ 3, 4, 5 ]}\nobreak \hyperdef{L}{X823C93FC7B87F5BC}{} {\noindent\textcolor{FuncColor}{$\triangleright$\enspace\texttt{AllPqExamples({\mdseries\slshape })\index{AllPqExamples@\texttt{AllPqExamples}} \label{AllPqExamples} }\hfill{\scriptsize (function)}}\\ returns a list of all currently available examples in default UNIX\texttt{\symbol{45}}listing (i.e.{\nobreakspace}alphabetic) order. } \subsection{\textcolor{Chapter }{GrepPqExamples}} \logpage{[ 3, 4, 6 ]}\nobreak \hyperdef{L}{X7E3E4B047DC2E323}{} {\noindent\textcolor{FuncColor}{$\triangleright$\enspace\texttt{GrepPqExamples({\mdseries\slshape string})\index{GrepPqExamples@\texttt{GrepPqExamples}} \label{GrepPqExamples} }\hfill{\scriptsize (function)}}\\ runs the UNIX command \texttt{grep \mbox{\texttt{\mdseries\slshape string}}} over the \textsf{ANUPQ} examples and returns the list of examples for which there is a match. The actual matches are \texttt{Info}\texttt{\symbol{45}}ed at \texttt{InfoANUPQ} level 2. } \subsection{\textcolor{Chapter }{ToPQLog}} \logpage{[ 3, 4, 7 ]}\nobreak \hyperdef{L}{X8104B2BA872EFCCB}{} {\noindent\textcolor{FuncColor}{$\triangleright$\enspace\texttt{ToPQLog({\mdseries\slshape [filename]})\index{ToPQLog@\texttt{ToPQLog}} \label{ToPQLog} }\hfill{\scriptsize (function)}}\\ With string argument \mbox{\texttt{\mdseries\slshape filename}}, \texttt{ToPQLog} opens the file with name \mbox{\texttt{\mdseries\slshape filename}} for logging; all commands written to the \texttt{pq} binary (that are \texttt{Info}\texttt{\symbol{45}}ed behind a ``\texttt{ToPQ{\textgreater} }'' prompt at \texttt{InfoANUPQ} level 4) are then also written to that file (but without prompts). With no argument, \texttt{ToPQLog} stops logging to whatever file was being logged to. If a file was already being logged to, that file is closed and the file with name \mbox{\texttt{\mdseries\slshape filename}} is opened for logging. } } \section{\textcolor{Chapter }{Attributes and a Property for fp and pc p\texttt{\symbol{45}}groups}}\label{Attributes and a Property for fp and pc p-groups} \logpage{[ 3, 5, 0 ]} \hyperdef{L}{X818175EF85CAA807}{} { \subsection{\textcolor{Chapter }{NuclearRank}} \logpage{[ 3, 5, 1 ]}\nobreak \hyperdef{L}{X87DC922A78EB0DD6}{} {\noindent\textcolor{FuncColor}{$\triangleright$\enspace\texttt{NuclearRank({\mdseries\slshape G})\index{NuclearRank@\texttt{NuclearRank}} \label{NuclearRank} }\hfill{\scriptsize (attribute)}}\\ \noindent\textcolor{FuncColor}{$\triangleright$\enspace\texttt{MultiplicatorRank({\mdseries\slshape G})\index{MultiplicatorRank@\texttt{MultiplicatorRank}} \label{MultiplicatorRank} }\hfill{\scriptsize (attribute)}}\\ \noindent\textcolor{FuncColor}{$\triangleright$\enspace\texttt{IsCapable({\mdseries\slshape G})\index{IsCapable@\texttt{IsCapable}} \label{IsCapable} }\hfill{\scriptsize (property)}}\\ return the nuclear rank of \mbox{\texttt{\mdseries\slshape G}}, $p$\texttt{\symbol{45}}multiplicator rank of \mbox{\texttt{\mdseries\slshape G}}, and whether \mbox{\texttt{\mdseries\slshape G}} is capable (i.e.{\nobreakspace}\texttt{true} if it is, or \texttt{false} if it is not), respectively. These attributes and property are set automatically if \mbox{\texttt{\mdseries\slshape G}} is one of the following: \begin{itemize} \item an fp group returned by \texttt{PqStandardPresentation} or \texttt{StandardPresentation} (see{\nobreakspace}\texttt{PqStandardPresentation} (\ref{PqStandardPresentation})); \item the image (fp group) of the epimorphism returned by an \texttt{EpimorphismPqStandardPresentation} or \texttt{EpimorphismStandardPresentation} call (see{\nobreakspace}\texttt{EpimorphismPqStandardPresentation} (\ref{EpimorphismPqStandardPresentation})); or \item one of the pc groups of the list of descendants returned by \texttt{PqDescendants} (see{\nobreakspace}\texttt{PqDescendants} (\ref{PqDescendants})). \end{itemize} If \mbox{\texttt{\mdseries\slshape G}} is an fp group or a pc $p$\texttt{\symbol{45}}group and not one of the above and the attribute or property has not otherwise been set for \mbox{\texttt{\mdseries\slshape G}}, then \texttt{PqStandardPresentation} is called to set all three of \texttt{NuclearRank}, \texttt{MultiplicatorRank} and \texttt{IsCapable}, before returning the value of the attribute or property actually called. Such a group \mbox{\texttt{\mdseries\slshape G}} must know in advance that it is a $p$\texttt{\symbol{45}}group; this is the case for the groups returned by the functions \texttt{Pq} and \texttt{PqPCover}, and the image group of the epimorphism returned by \texttt{PqEpimorphism}. Otherwise, if you know the group to be a $p$\texttt{\symbol{45}}group, then this can be set by typing \begin{Verbatim}[commandchars=!@|,fontsize=\small,frame=single,label=] SetIsPGroup( G, true ); \end{Verbatim} or by invoking \texttt{IsPGroup( \mbox{\texttt{\mdseries\slshape G}} )}. Note that for an fp group \mbox{\texttt{\mdseries\slshape G}}, the latter may result in a coset enumeration which might not terminate in a reasonable time. \emph{Note:} For \mbox{\texttt{\mdseries\slshape G}} such that \texttt{HasNuclearRank(\mbox{\texttt{\mdseries\slshape G}}) = true}, \texttt{IsCapable(\mbox{\texttt{\mdseries\slshape G}})} is equivalent to (the truth or falsity of) \texttt{NuclearRank( \mbox{\texttt{\mdseries\slshape G}} ) = 0}. } } \section{\textcolor{Chapter }{Hints and Warnings regarding the use of Options}}\label{Hints and Warnings regarding the use of Options} \logpage{[ 3, 6, 0 ]} \hyperdef{L}{X7BA20FA07B166B37}{} { On a first reading we recommend you skip this section and come back to it if and when you run into trouble. \index{menu item!of pq program} \index{option!of pq program is a menu item} \emph{Note:} By ``options'' we refer to \textsf{GAP} options. The \texttt{pq} program also uses the term ``option''; to distinguish the two usages of ``option'', in this manual we use the term \emph{menu item} to refer to what the \texttt{pq} program refers to as an ``option''. Options are passed to the \textsf{ANUPQ} interface functions in either of the two usual mechanisms provided by \textsf{GAP}, namely: \begin{itemize} \item options may be set globally using the function \texttt{PushOptions} (see Chapter{\nobreakspace} \textbf{Reference: Options Stack} in the \textsf{GAP} Reference Manual); or \item options may be appended to the argument list of any function call, separated by a colon from the argument list (see Chapter{\nobreakspace} \textbf{Reference: Function Calls} in the \textsf{GAP} Reference Manual), in which case they are then passed on recursively to any subsequent inner function call, which may in turn have options of their own. \end{itemize} Particularly, when one is using the interactive functions of Chapter{\nobreakspace}\hyperref[Interactive ANUPQ functions]{`Interactive ANUPQ functions'}, one should, in general, avoid using the global method of passing options. In fact, it is recommended that prior to calling \texttt{PqStart} the \texttt{OptionsStack} be empty. The essential problem with setting options globally using the function \texttt{PushOptions} is that options pushed onto \texttt{OptionsStack}, in this way, (generally) remain there until an explicit \texttt{PopOptions()} call is made. In contrast, options passed in the usual way behind a colon following a function's arguments (see \textbf{Reference: Function Call With Options} in the \textsf{GAP} Reference Manual) are local, and disappear from \texttt{OptionsStack} after the function has executed successfully. If the function does \emph{not} execute successfully, i.e.{\nobreakspace}it runs into error and the user \texttt{quit}s the resulting \texttt{break} loop (see Section{\nobreakspace} \textbf{Reference: Break Loops} in the Reference Manual) rather than attempting to repair the problem and typing \texttt{return;} then, unless the error at the kernel level, the \texttt{OptionsStack} is reset. If an error is detected inside the kernel (hopefully, this should occur only rarely, if at all) then the options of that function will \emph{not} be cleared from \texttt{OptionsStack}; in such cases: \begin{Verbatim}[commandchars=!@|,fontsize=\small,frame=single,label=Example] !gapprompt@gap>| !gapinput@ResetOptionsStack();| #I Options stack is already empty \end{Verbatim} is usually necessary (see Chapter{\nobreakspace}\texttt{ResetOptionsStack} (\textbf{Reference: ResetOptionsStack}) in the \textsf{GAP} Reference Manual), which recursively calls \texttt{PopOptions()} until \texttt{OptionsStack} is empty, or as in the above case warns you that the \texttt{OptionsStack} is already empty. Note that a function, that is passed options after the colon, will also see any global options or any options passed down recursively from functions calling that function, unless those options are over\texttt{\symbol{45}}ridden by options passed via the function. Also, note that duplication of option names for different programs may lead to misinterpretations, and mis\texttt{\symbol{45}}spelled options will not be ``seen''. The non\texttt{\symbol{45}}interactive functions of Chapter{\nobreakspace}\hyperref[non-interact]{`Non\texttt{\symbol{45}}interactive ANUPQ functions'} that have \texttt{Pq} somewhere in their name provide an alternative method of passing options as additional arguments. This has the advantages that options can be abbreviated and mis\texttt{\symbol{45}}spelled options will be trapped. \index{troubleshooting tips} \subsection{\textcolor{Chapter }{ANUPQWarnOfOtherOptions}} \logpage{[ 3, 6, 1 ]}\nobreak \hyperdef{L}{X81F4AAE084C34B4B}{} {\noindent\textcolor{FuncColor}{$\triangleright$\enspace\texttt{ANUPQWarnOfOtherOptions\index{ANUPQWarnOfOtherOptions@\texttt{ANUPQWarnOfOtherOptions}} \label{ANUPQWarnOfOtherOptions} }\hfill{\scriptsize (global variable)}}\\ is a global variable that is by default \texttt{false}. If it is set to \texttt{true} then any function provided by the \textsf{ANUPQ} function that recognises at least one option, will warn you of ``other'' options, i.e.{\nobreakspace}options that the function does not recognise. These warnings are emitted at \texttt{InfoWarning} or \texttt{InfoANUPQ} level 1. This is useful for detecting mis\texttt{\symbol{45}}spelled options. Here is an example using the function \texttt{Pq} (first described in Chapter{\nobreakspace}\hyperref[non-interact]{`Non\texttt{\symbol{45}}interactive ANUPQ functions'}): \begin{Verbatim}[commandchars=!@|,fontsize=\small,frame=single,label=Example] !gapprompt@gap>| !gapinput@SetInfoLevel(InfoANUPQ, 1); # Set InfoANUPQ to default level| !gapprompt@gap>| !gapinput@ANUPQWarnOfOtherOptions := true;;| !gapprompt@gap>| !gapinput@# The following makes entry into break loops very ``quiet'' ...| !gapprompt@gap>| !gapinput@OnBreak := function() Where(0); end;;| !gapprompt@gap>| !gapinput@F := FreeGroup( "a", "b" );| !gapprompt@gap>| !gapinput@Pq( F : Prime := 2, Classbound := 1 );| #I ANUPQ Warning: Options: [ "Classbound" ] ignored #I (invalid for generic function: `Pq'). user interrupt at moreOfline := ReadLine( iostream ); Entering break read-eval-print loop ... you can 'quit;' to quit to outer loop, or you can 'return;' to continue \end{Verbatim} Here we mistyped \texttt{ClassBound} as \texttt{Classbound}, and after seeing the \texttt{Info}\texttt{\symbol{45}}ed warning that \texttt{Classbound} was ignored, we typed a \mbox{\texttt{\mdseries\slshape control}}\texttt{\symbol{45}}C (that's the ``\texttt{user interrupt at}'' message) which took us into a break loop. Since the \texttt{Pq} command was not able to finish, the options \texttt{Prime} and \texttt{Classbound}, in particular, will still be on the \texttt{OptionsStack}: \begin{Verbatim}[commandchars=!@|,fontsize=\small,frame=single,label=Example] !gapbrkprompt@brk>| !gapinput@OptionsStack;| [ rec( Prime := 2, Classbound := 1 ), rec( Prime := 2, Classbound := 1, PqEpiOrPCover := "pQuotient" ) ] \end{Verbatim} The option \texttt{PqEpiOrPCover} is a behind\texttt{\symbol{45}}the\texttt{\symbol{45}}scenes option that need not concern the user. On \texttt{quit}ting the \texttt{break}\texttt{\symbol{45}}loop the \texttt{OptionsStack} is reset and a warning telling you this is emitted: \begin{Verbatim}[commandchars=!@|,fontsize=\small,frame=single,label=Example] !gapbrkprompt@brk>| !gapinput@quit; # to get back to the `gap>' prompt| #I Options stack has been reset \end{Verbatim} Above, we altered \texttt{OnBreak} (see{\nobreakspace}\texttt{OnBreak} (\textbf{Reference: OnBreak}) in the Reference manual) to reduce the back\texttt{\symbol{45}}tracing on entry into a break loop. We now restore \texttt{OnBreak} to its usual value. \begin{Verbatim}[commandchars=!@|,fontsize=\small,frame=single,label=Example] !gapprompt@gap>| !gapinput@OnBreak := Where;;| \end{Verbatim} \emph{Notes} In cases where functions recursively call others with options (e.g.{\nobreakspace}when using \texttt{PqExample} with options), setting \texttt{ANUPQWarnOfOtherOptions := true} may give rise to spurious ``other'' option detections. It is recommended that the novice user set \texttt{ANUPQWarnOfOtherOptions} to \texttt{true} in their \texttt{gap.ini} file (see Section{\nobreakspace}\hyperref[Loading the ANUPQ Package]{`Loading the ANUPQ Package'}). } \emph{Other Troubleshooting Strategies} There are some other strategies which may have helped us to see our error above. The function \texttt{Pq} recognises the option \texttt{OutputLevel} (see{\nobreakspace}\ref{option OutputLevel}); if this option is set to at least 1, the \texttt{pq} program provides information on each class quotient as it is generated: \begin{Verbatim}[commandchars=!@|,fontsize=\small,frame=single,label=Example] !gapprompt@gap>| !gapinput@ANUPQWarnOfOtherOptions := false;; # Set back to normal| !gapprompt@gap>| !gapinput@F := FreeGroup( "a", "b" );;| !gapprompt@gap>| !gapinput@Pq( F : Prime := 2, Classbound := 1, OutputLevel := 1 ); | #I Lower exponent-2 central series for [grp] #I Group: [grp] to lower exponent-2 central class 1 has order 2^2 #I Group: [grp] to lower exponent-2 central class 2 has order 2^5 #I Group: [grp] to lower exponent-2 central class 3 has order 2^10 #I Group: [grp] to lower exponent-2 central class 4 has order 2^18 #I Group: [grp] to lower exponent-2 central class 5 has order 2^32 #I Group: [grp] to lower exponent-2 central class 6 has order 2^55 #I Group: [grp] to lower exponent-2 central class 7 has order 2^96 #I Group: [grp] to lower exponent-2 central class 8 has order 2^167 #I Group: [grp] to lower exponent-2 central class 9 has order 2^294 #I Group: [grp] to lower exponent-2 central class 10 has order 2^520 #I Group: [grp] to lower exponent-2 central class 11 has order 2^932 #I Group: [grp] to lower exponent-2 central class 12 has order 2^1679 [... output truncated ...] \end{Verbatim} After seeing the information for the class 2 quotient we may have got the idea that the \texttt{Classbound} option was not recognised and may have realised that this was due to a mis\texttt{\symbol{45}}spelling. The above will ordinarily cause the available space to be exhausted, necessitating user\texttt{\symbol{45}}intervention by typing \mbox{\texttt{\mdseries\slshape control}}\texttt{\symbol{45}}C and \texttt{quit;} (to escape the break loop); otherwise \texttt{Pq} terminates when the class reaches 63 (the default value of \texttt{ClassBound}). If you have some familiarity with ``keyword'' command input to the \texttt{pq} binary, then setting the level of \texttt{InfoANUPQ} to 4 would also have indicated a problem: \begin{Verbatim}[commandchars=!@|,fontsize=\small,frame=single,label=Example] !gapprompt@gap>| !gapinput@ResetOptionsStack(); # Necessary, if a break-loop was entered above| !gapprompt@gap>| !gapinput@SetInfoLevel(InfoANUPQ, 4);| !gapprompt@gap>| !gapinput@Pq( F : Prime := 2, Classbound := 1 );| #I ToPQ> 7 #to (Main) p-Quotient Menu #I ToPQ> 1 #define group #I ToPQ> name [grp] #I ToPQ> prime 2 #I ToPQ> class 63 #I ToPQ> exponent 0 #I ToPQ> output 0 #I ToPQ> generators { a,b } #I ToPQ> relators { }; [... output truncated ...] \end{Verbatim} Here the line ``\texttt{\#I ToPQ{\textgreater} class 63}'' indicates that a directive to set the classbound to 63 was sent to the \texttt{pq} program. } } \chapter{\textcolor{Chapter }{Non\texttt{\symbol{45}}interactive ANUPQ functions}}\label{non-interact} \logpage{[ 4, 0, 0 ]} \hyperdef{L}{X7C51F26D839279FF}{} { Here we describe all the non\texttt{\symbol{45}}interactive functions of the \textsf{ANUPQ} package; i.e.{\nobreakspace}``one\texttt{\symbol{45}}shot'' functions that invoke the \texttt{pq} program in such a way that once \textsf{GAP} has got what it needs, the \texttt{pq} program is allowed to exit. It is expected that most of the time users will only need these functions. The functions interface with three of the four algorithms (see Chapter{\nobreakspace}\hyperref[Introduction]{`Introduction'}) provided by the ANU \texttt{pq} C program, and are mainly grouped according to the algorithm of the \texttt{pq} program they relate to. In Section{\nobreakspace}\hyperref[Computing p-Quotients]{`Computing p\texttt{\symbol{45}}Quotients'}, we describe the functions that give access to the $p$\texttt{\symbol{45}}quotient algorithm. Section{\nobreakspace}\hyperref[Computing Standard Presentations]{`Computing Standard Presentations'} describe functions that give access to the standard presentation algorithm. Section{\nobreakspace}\hyperref[Testing p-Groups for Isomorphism]{`Testing p\texttt{\symbol{45}}Groups for Isomorphism'} describe functions that implement an isomorphism test for $p$\texttt{\symbol{45}}groups using the standard presentation algorithm. In Section{\nobreakspace}\hyperref[Computing Descendants of a p-Group]{`Computing Descendants of a p\texttt{\symbol{45}}Group'}, we describe functions that give access to the $p$\texttt{\symbol{45}}group generation algorithm. To use any of the functions one must have at some stage previously typed: \begin{Verbatim}[commandchars=!@|,fontsize=\small,frame=single,label=Example] !gapprompt@gap>| !gapinput@LoadPackage("anupq");| \end{Verbatim} (the response of which we have omitted; see{\nobreakspace}\hyperref[Loading the ANUPQ Package]{`Loading the ANUPQ Package'}). It is strongly recommended that the user try the examples provided. To save typing there is a \texttt{PqExample} equivalent for each manual example. We also suggest that to start with you may find the examples more instructive if you set the \texttt{InfoANUPQ} level to 2 (see{\nobreakspace}\texttt{InfoANUPQ} (\ref{InfoANUPQ})). \section{\textcolor{Chapter }{Computing p\texttt{\symbol{45}}Quotients}}\label{Computing p-Quotients} \logpage{[ 4, 1, 0 ]} \hyperdef{L}{X80406BD47EB186E9}{} { \subsection{\textcolor{Chapter }{Pq}} \logpage{[ 4, 1, 1 ]}\nobreak \hyperdef{L}{X86DD32D5803CF2C8}{} {\noindent\textcolor{FuncColor}{$\triangleright$\enspace\texttt{Pq({\mdseries\slshape F: options})\index{Pq@\texttt{Pq}} \label{Pq} }\hfill{\scriptsize (function)}}\\ returns for the fp or pc group \mbox{\texttt{\mdseries\slshape F}}, the $p$\texttt{\symbol{45}}quotient of \mbox{\texttt{\mdseries\slshape F}} specified by \mbox{\texttt{\mdseries\slshape options}}, as a pc group. Following the colon, \mbox{\texttt{\mdseries\slshape options}} is a selection of the options from the following list, separated by commas like record components (see Section{\nobreakspace} \textbf{Reference: Function Call With Options} in the \textsf{GAP} Reference Manual). As a minimum the user \emph{must} supply a value for the \texttt{Prime} option. Below we list the options recognised by \texttt{Pq} (see Chapter{\nobreakspace}\hyperref[ANUPQ Options]{`ANUPQ Options'} for detailed descriptions). \begin{itemize} \item \texttt{Prime := \mbox{\texttt{\mdseries\slshape p}}}\index{option Prime} \item \texttt{ClassBound := \mbox{\texttt{\mdseries\slshape n}}}\index{option ClassBound} \item \texttt{Exponent := \mbox{\texttt{\mdseries\slshape n}}}\index{option Exponent} \item \texttt{Relators := \mbox{\texttt{\mdseries\slshape rels}}}\index{option Relators} \item \texttt{Metabelian}\index{option Metabelian} \item \texttt{Identities := \mbox{\texttt{\mdseries\slshape funcs}}}\index{option Identities} \item \texttt{GroupName := \mbox{\texttt{\mdseries\slshape name}}}\index{option GroupName} \item \texttt{OutputLevel := \mbox{\texttt{\mdseries\slshape n}}}\index{option OutputLevel} \item \texttt{SetupFile := \mbox{\texttt{\mdseries\slshape filename}}}\index{option SetupFile} \item \texttt{PqWorkspace := \mbox{\texttt{\mdseries\slshape workspace}}}\index{option PqWorkspace} \end{itemize} \emph{Notes:} \texttt{Pq} may also be called with no arguments or one integer argument, in which case it is being used interactively (see{\nobreakspace}\texttt{Pq} (\ref{Pq:interactive})); the same options may be used, except that \texttt{SetupFile} and \texttt{PqWorkspace} are ignored by the interactive \texttt{Pq} function. See Section{\nobreakspace}\hyperref[Attributes and a Property for fp and pc p-groups]{`Attributes and a Property for fp and pc p\texttt{\symbol{45}}groups'} for the attributes and property \texttt{NuclearRank}, \texttt{MultiplicatorRank} and \texttt{IsCapable} which may be applied to the group returned by \texttt{Pq}. See also \texttt{PqEpimorphism} (\texttt{PqEpimorphism} (\ref{PqEpimorphism})). We now give a few examples of the use of \texttt{Pq}. Except for the addition of a few comments and the non\texttt{\symbol{45}}suppression of output (by not using duplicated semicolons) the next 3 examples may be run by typing: \texttt{PqExample( "Pq" );} (see{\nobreakspace}\texttt{PqExample} (\ref{PqExample})). \begin{Verbatim}[commandchars=!@|,fontsize=\small,frame=single,label=Example] !gapprompt@gap>| !gapinput@LoadPackage("anupq");; # does nothing if ANUPQ is already loaded| !gapprompt@gap>| !gapinput@# First we get a p-quotient of a free group of rank 2| !gapprompt@gap>| !gapinput@F := FreeGroup("a", "b");; a := F.1;; b := F.2;;| !gapprompt@gap>| !gapinput@Pq( F : Prime := 2, ClassBound := 3 ); | !gapprompt@gap>| !gapinput@# Now let us get a p-quotient of an fp group| !gapprompt@gap>| !gapinput@G := F / [a^4, b^4];| !gapprompt@gap>| !gapinput@Pq( G : Prime := 2, ClassBound := 3 ); | !gapprompt@gap>| !gapinput@# Now let's get a different p-quotient of the same group| !gapprompt@gap>| !gapinput@Pq( G : Prime := 2, ClassBound := 3, Exponent := 4 ); | !gapprompt@gap>| !gapinput@# Now we'll get a p-quotient of another fp group| !gapprompt@gap>| !gapinput@# which we will redo using the `Relators' option| !gapprompt@gap>| !gapinput@R := [ a^25, Comm(Comm(b, a), a), b^5 ];| [ a^25, a^-1*b^-1*a*b*a^-1*b^-1*a^-1*b*a^2, b^5 ] !gapprompt@gap>| !gapinput@H := F / R;| !gapprompt@gap>| !gapinput@Pq( H : Prime := 5, ClassBound := 5, Metabelian );| \end{Verbatim} \index{option Relators!example of usage} Now we redo the last example to show how one may use the \texttt{Relators} option. Observe that \texttt{Comm(Comm(b, a), a)} is a left normed commutator which must be written in square bracket notation for the \texttt{pq} program and embedded in a pair of double quotes. The function \texttt{PqGAPRelators} (see{\nobreakspace}\texttt{PqGAPRelators} (\ref{PqGAPRelators})) can be used to translate a list of strings prepared for the \texttt{Relators} option into \textsf{GAP} format. Below we use it. Observe that the value of \texttt{R} is the same as before. \begin{Verbatim}[commandchars=!@|,fontsize=\small,frame=single,label=Example] !gapprompt@gap>| !gapinput@F := FreeGroup("a", "b");;| !gapprompt@gap>| !gapinput@# `F' was defined for `Relators'. We use the same strings that GAP uses| !gapprompt@gap>| !gapinput@# for printing the free group generators. It is *not* necessary to| !gapprompt@gap>| !gapinput@# predefine: a := F.1; etc. (as it was above).| !gapprompt@gap>| !gapinput@rels := [ "a^25", "[b, a, a]", "b^5" ];| [ "a^25", "[b, a, a]", "b^5" ] !gapprompt@gap>| !gapinput@R := PqGAPRelators(F, rels);| [ a^25, a^-1*b^-1*a*b*a^-1*b^-1*a^-1*b*a^2, b^5 ] !gapprompt@gap>| !gapinput@H := F / R;| !gapprompt@gap>| !gapinput@Pq( H : Prime := 5, ClassBound := 5, Metabelian, | !gapprompt@>| !gapinput@ Relators := rels );| \end{Verbatim} In fact, above we could have just passed \texttt{F} (rather than \texttt{H}), i.e.{\nobreakspace}we could have done: \begin{Verbatim}[commandchars=!@|,fontsize=\small,frame=single,label=Example] !gapprompt@gap>| !gapinput@F := FreeGroup("a", "b");;| !gapprompt@gap>| !gapinput@rels := [ "a^25", "[b, a, a]", "b^5" ];| [ "a^25", "[b, a, a]", "b^5" ] !gapprompt@gap>| !gapinput@Pq( F : Prime := 5, ClassBound := 5, Metabelian, | !gapprompt@>| !gapinput@ Relators := rels );| \end{Verbatim} The non\texttt{\symbol{45}}interactive \texttt{Pq} function also allows the options to be passed in two other ways; these alternatives have been included for those familiar with the \textsf{GAP}{\nobreakspace}3 version of the \textsf{ANUPQ} package; the preferred method of passing options is the one already described. Firstly, they may be passed in a record as a second argument; note that any boolean options must be set explicitly e.g. \begin{Verbatim}[commandchars=!@|,fontsize=\small,frame=single,label=Example] !gapprompt@gap>| !gapinput@Pq( H, rec( Prime := 5, ClassBound := 5, Metabelian := true ) );| \end{Verbatim} It is also possible to pass them as extra arguments, where each option name appears as a string followed immediately by its value (if not a boolean option) e.g. \begin{Verbatim}[commandchars=!@|,fontsize=\small,frame=single,label=Example] !gapprompt@gap>| !gapinput@Pq( H, "Prime", 5, "ClassBound", 5, "Metabelian" );| \end{Verbatim} The preceding two examples can be run from \textsf{GAP} via \texttt{PqExample( "Pq\texttt{\symbol{45}}ni" );} (see{\nobreakspace}\texttt{PqExample} (\ref{PqExample})). This method of passing options permits abbreviation; the only restriction is that the abbreviation must be unique. So \texttt{"Pr"} may be used for \texttt{"Prime"}, \texttt{"Class"} or even just \texttt{"C"} for \texttt{"ClassBound"}, etc. \index{option Identities!example of usage} The following example illustrates the use of the option \texttt{Identities}. We compute the largest finite Burnside group of exponent $5$ that also satisfies the $3$\texttt{\symbol{45}}Engel identity. Each identity is defined by a function whose arguments correspond to the variables of the identity. The return value of each of those functions is the identity evaluated on the arguments of the function. \begin{Verbatim}[commandchars=!@|,fontsize=\small,frame=single,label=Example] !gapprompt@gap>| !gapinput@F := FreeGroup(2);| !gapprompt@gap>| !gapinput@Burnside5 := x->x^5;| function( x ) ... end !gapprompt@gap>| !gapinput@Engel3 := function( x,y ) return PqLeftNormComm( [x,y,y,y] ); end;| function( x, y ) ... end !gapprompt@gap>| !gapinput@Pq( F : Prime := 5, Identities := [ Burnside5, Engel3 ] );| #I Class 1 with 2 generators. #I Class 2 with 3 generators. #I Class 3 with 5 generators. #I Class 3 with 5 generators. \end{Verbatim} The above example can be run from \textsf{GAP} via \texttt{PqExample( "B5\texttt{\symbol{45}}5\texttt{\symbol{45}}Engel3\texttt{\symbol{45}}Id" );} (see{\nobreakspace}\texttt{PqExample} (\ref{PqExample})). } \subsection{\textcolor{Chapter }{PqEpimorphism}} \logpage{[ 4, 1, 2 ]}\nobreak \hyperdef{L}{X7ADE5DDB87B99CC0}{} {\noindent\textcolor{FuncColor}{$\triangleright$\enspace\texttt{PqEpimorphism({\mdseries\slshape F: options})\index{PqEpimorphism@\texttt{PqEpimorphism}} \label{PqEpimorphism} }\hfill{\scriptsize (function)}}\\ returns for the fp or pc group \mbox{\texttt{\mdseries\slshape F}} an epimorphism from \mbox{\texttt{\mdseries\slshape F}} onto the $p$\texttt{\symbol{45}}quotient of \mbox{\texttt{\mdseries\slshape F}} specified by \mbox{\texttt{\mdseries\slshape options}}; the possible options \mbox{\texttt{\mdseries\slshape options}} and \emph{required} option (\texttt{"Prime"}) are as for \texttt{Pq} (see{\nobreakspace}\texttt{Pq} (\ref{Pq})). \texttt{PqEpimorphism} only differs from \texttt{Pq} in what it outputs; everything about what must/may be passed as input to \texttt{PqEpimorphism} is the same as for \texttt{Pq}. The same alternative methods of passing options to the non\texttt{\symbol{45}}interactive \texttt{Pq} function are available to the non\texttt{\symbol{45}}interactive version of \texttt{PqEpimorphism}. \emph{Notes:} \texttt{PqEpimorphism} may also be called with no arguments or one integer argument, in which case it is being used interactively (see{\nobreakspace}\texttt{PqEpimorphism} (\ref{PqEpimorphism:interactive})), and the options \texttt{SetupFile} and \texttt{PqWorkspace} are ignored by the interactive \texttt{PqEpimorphism} function. See Section{\nobreakspace}\hyperref[Attributes and a Property for fp and pc p-groups]{`Attributes and a Property for fp and pc p\texttt{\symbol{45}}groups'} for the attributes and property \texttt{NuclearRank}, \texttt{MultiplicatorRank} and \texttt{IsCapable} which may be applied to the image group of the epimorphism returned by \texttt{PqEpimorphism}. \begin{Verbatim}[commandchars=!@|,fontsize=\small,frame=single,label=Example] !gapprompt@gap>| !gapinput@F := FreeGroup (2, "F");| !gapprompt@gap>| !gapinput@phi := PqEpimorphism( F : Prime := 5, ClassBound := 2 );| [ F1, F2 ] -> [ f1, f2 ] !gapprompt@gap>| !gapinput@Image( phi );| \end{Verbatim} Typing: \texttt{PqExample( "PqEpimorphism" );} runs the above example in \textsf{GAP} (see{\nobreakspace}\texttt{PqExample} (\ref{PqExample})). } \subsection{\textcolor{Chapter }{PqPCover}} \logpage{[ 4, 1, 3 ]}\nobreak \hyperdef{L}{X81C3CE1E850DA252}{} {\noindent\textcolor{FuncColor}{$\triangleright$\enspace\texttt{PqPCover({\mdseries\slshape F: options})\index{PqPCover@\texttt{PqPCover}} \label{PqPCover} }\hfill{\scriptsize (function)}}\\ returns for the fp or pc group \mbox{\texttt{\mdseries\slshape F}}, the $p$\texttt{\symbol{45}}covering group of the $p$\texttt{\symbol{45}}quotient of \mbox{\texttt{\mdseries\slshape F}} specified by \mbox{\texttt{\mdseries\slshape options}}, as a pc group, i.e.{\nobreakspace}the $p$\texttt{\symbol{45}}covering group of the $p$\texttt{\symbol{45}}quotient \texttt{Pq( \mbox{\texttt{\mdseries\slshape F}} : \mbox{\texttt{\mdseries\slshape options}} )}. Thus the options that \texttt{PqPCover} accepts are exactly those expected for \texttt{Pq} (and hence as a minimum the user \emph{must} supply a value for the \texttt{Prime} option; see{\nobreakspace}\texttt{Pq} (\ref{Pq}) for more details), except in the following special case. If \mbox{\texttt{\mdseries\slshape F}} is already a $p$\texttt{\symbol{45}}group, in the sense that \texttt{IsPGroup(\mbox{\texttt{\mdseries\slshape F}})} is \texttt{true}, then \begin{description} \item[{\texttt{Prime}}] defaults to \texttt{PrimePGroup(\mbox{\texttt{\mdseries\slshape F}})}, if not supplied and \texttt{HasPrimePGroup(\mbox{\texttt{\mdseries\slshape F}}) = true}; and \item[{\texttt{ClassBound}}] defaults to \texttt{PClassPGroup(\mbox{\texttt{\mdseries\slshape F}})} if \texttt{HasPClassPGroup(\mbox{\texttt{\mdseries\slshape F}}) = true} if not supplied, or to the usual default of 63, otherwise. \end{description} The same alternative methods of passing options to the non\texttt{\symbol{45}}interactive \texttt{Pq} function are available to the non\texttt{\symbol{45}}interactive version of \texttt{PqPCover}. We now give a few examples of the use of \texttt{PqPCover}. These examples are just a subset of the ones we gave for \texttt{Pq} (see{\nobreakspace}\texttt{Pq} (\ref{Pq})), except that in each instance the command \texttt{Pq} has been replaced with \texttt{PqPCover}. Essentially the same examples may be run by typing: \texttt{PqExample( "PqPCover" );} (see{\nobreakspace}\texttt{PqExample} (\ref{PqExample})). \begin{Verbatim}[commandchars=!@|,fontsize=\small,frame=single,label=Example] !gapprompt@gap>| !gapinput@F := FreeGroup("a", "b");; a := F.1;; b := F.2;;| !gapprompt@gap>| !gapinput@PqPCover( F : Prime := 2, ClassBound := 3 );| !gapprompt@gap>| !gapinput@| !gapprompt@gap>| !gapinput@# Now let's get a p-cover of a p-quotient of an fp group| !gapprompt@gap>| !gapinput@G := F / [a^4, b^4];| !gapprompt@gap>| !gapinput@PqPCover( G : Prime := 2, ClassBound := 3 );| !gapprompt@gap>| !gapinput@| !gapprompt@gap>| !gapinput@# Now let's get a p-cover of a different p-quotient of the same group| !gapprompt@gap>| !gapinput@PqPCover( G : Prime := 2, ClassBound := 3, Exponent := 4 );| !gapprompt@gap>| !gapinput@| !gapprompt@gap>| !gapinput@# Now we'll get a p-cover of a p-quotient of another fp group| !gapprompt@gap>| !gapinput@# which we will redo using the `Relators' option| !gapprompt@gap>| !gapinput@R := [ a^25, Comm(Comm(b, a), a), b^5 ];| [ a^25, a^-1*b^-1*a*b*a^-1*b^-1*a^-1*b*a^2, b^5 ] !gapprompt@gap>| !gapinput@H := F / R;| !gapprompt@gap>| !gapinput@PqPCover( H : Prime := 5, ClassBound := 5, Metabelian );| !gapprompt@gap>| !gapinput@| !gapprompt@gap>| !gapinput@# Now we redo the previous example using the `Relators' option| !gapprompt@gap>| !gapinput@F := FreeGroup("a", "b");;| !gapprompt@gap>| !gapinput@rels := [ "a^25", "[b, a, a]", "b^5" ];| [ "a^25", "[b, a, a]", "b^5" ] !gapprompt@gap>| !gapinput@PqPCover( F : Prime := 5, ClassBound := 5, Metabelian, | !gapprompt@>| !gapinput@ Relators := rels );| \end{Verbatim} } } \section{\textcolor{Chapter }{Computing Standard Presentations}}\label{Computing Standard Presentations} \logpage{[ 4, 2, 0 ]} \hyperdef{L}{X7F05F8DC79733A8E}{} { \index{automorphisms!of $p$\texttt{\symbol{45}}groups} \subsection{\textcolor{Chapter }{PqStandardPresentation}} \logpage{[ 4, 2, 1 ]}\nobreak \hyperdef{L}{X86C9575D7CB65FBB}{} {\noindent\textcolor{FuncColor}{$\triangleright$\enspace\texttt{PqStandardPresentation({\mdseries\slshape F: options})\index{PqStandardPresentation@\texttt{PqStandardPresentation}} \label{PqStandardPresentation} }\hfill{\scriptsize (function)}}\\ \noindent\textcolor{FuncColor}{$\triangleright$\enspace\texttt{StandardPresentation({\mdseries\slshape F: options})\index{StandardPresentation@\texttt{StandardPresentation}} \label{StandardPresentation} }\hfill{\scriptsize (method)}}\\ return the \mbox{\texttt{\mdseries\slshape p}}\texttt{\symbol{45}}quotient specified by \mbox{\texttt{\mdseries\slshape options}} of the fp or pc $p$\texttt{\symbol{45}}group \mbox{\texttt{\mdseries\slshape F}}, as an \emph{fp group} which has a standard presentation. Here \mbox{\texttt{\mdseries\slshape options}} is a selection of the options from the following list (see Chapter{\nobreakspace}\hyperref[ANUPQ Options]{`ANUPQ Options'} for detailed descriptions). Section{\nobreakspace}\hyperref[Hints and Warnings regarding the use of Options]{`Hints and Warnings regarding the use of Options'} gives some important hints and warnings regarding option usage, and Section{\nobreakspace} \textbf{Reference: Function Call With Options} in the \textsf{GAP} Reference Manual describes their ``record''\texttt{\symbol{45}}like syntax. \begin{itemize} \item \texttt{Prime := \mbox{\texttt{\mdseries\slshape p}}}\index{option Prime} \item \texttt{pQuotient := \mbox{\texttt{\mdseries\slshape Q}}}\index{option pQuotient} \item \texttt{ClassBound := \mbox{\texttt{\mdseries\slshape n}}}\index{option ClassBound} \item \texttt{Exponent := \mbox{\texttt{\mdseries\slshape n}}}\index{option Exponent} \item \texttt{Metabelian}\index{option Metabelian} \item \texttt{GroupName := \mbox{\texttt{\mdseries\slshape name}}}\index{option GroupName} \item \texttt{OutputLevel := \mbox{\texttt{\mdseries\slshape n}}}\index{option OutputLevel} \item \texttt{StandardPresentationFile := \mbox{\texttt{\mdseries\slshape filename}}}\index{option StandardPresentationFile} \item \texttt{SetupFile := \mbox{\texttt{\mdseries\slshape filename}}}\index{option SetupFile} \item \texttt{PqWorkspace := \mbox{\texttt{\mdseries\slshape workspace}}}\index{option PqWorkspace} \end{itemize} Unless \mbox{\texttt{\mdseries\slshape F}} is a pc \mbox{\texttt{\mdseries\slshape p}}\texttt{\symbol{45}}group, the user \emph{must} supply either the option \texttt{Prime} or the option \texttt{pQuotient} (if both \texttt{Prime} and \texttt{pQuotient} are supplied, the prime \mbox{\texttt{\mdseries\slshape p}} is determined by applying \texttt{PrimePGroup} (see{\nobreakspace}\texttt{PrimePGroup} (\textbf{Reference: PrimePGroup}) in the Reference Manual) to the value of \texttt{pQuotient}). The options for \texttt{PqStandardPresentation} may also be passed in the two other alternative ways described for \texttt{Pq} (see{\nobreakspace}\texttt{Pq} (\ref{Pq})). \texttt{StandardPresentation} does not provide these alternative ways of passing options. \emph{Notes:} In contrast to the function \texttt{Pq} (see{\nobreakspace}\texttt{Pq} (\ref{Pq})) which returns a pc group, \texttt{PqStandardPresentation} or \texttt{StandardPresentation} returns an fp group. This is because the output is mainly used for isomorphism testing for which an fp group is enough. However, the presentation is a polycyclic presentation and if you need to do any further computation with this group (e.g.{\nobreakspace}to find the order) you can use the function \texttt{PcGroupFpGroup} (see{\nobreakspace}\texttt{PcGroupFpGroup} (\textbf{Reference: PcGroupFpGroup}) in the \textsf{GAP} Reference Manual) to form a pc group. If the user does not supply a \mbox{\texttt{\mdseries\slshape p}}\texttt{\symbol{45}}quotient \mbox{\texttt{\mdseries\slshape Q}} via the \texttt{pQuotient} option and the prime \mbox{\texttt{\mdseries\slshape p}} is either supplied or \mbox{\texttt{\mdseries\slshape F}} is a pc \mbox{\texttt{\mdseries\slshape p}}\texttt{\symbol{45}}group, then a \mbox{\texttt{\mdseries\slshape p}}\texttt{\symbol{45}}quotient \mbox{\texttt{\mdseries\slshape Q}} is computed. If the user does supply a \mbox{\texttt{\mdseries\slshape p}}\texttt{\symbol{45}}quotient \mbox{\texttt{\mdseries\slshape Q}} via the \texttt{pQuotient} option, the package \textsf{AutPGrp} is called to compute the automorphism group of \mbox{\texttt{\mdseries\slshape Q}}; an error will occur that asks the user to install the package \textsf{AutPGrp} if the automorphism group cannot be computed. The attributes and property \texttt{NuclearRank}, \texttt{MultiplicatorRank} and \texttt{IsCapable} are set for the group returned by \texttt{PqStandardPresentation} or \texttt{StandardPresentation} (see Section{\nobreakspace}\hyperref[Attributes and a Property for fp and pc p-groups]{`Attributes and a Property for fp and pc p\texttt{\symbol{45}}groups'}). We illustrate the method with the following examples. \begin{Verbatim}[commandchars=!@|,fontsize=\small,frame=single,label=Example] !gapprompt@gap>| !gapinput@F := FreeGroup( "a", "b" );; a := F.1;; b := F.2;;| !gapprompt@gap>| !gapinput@G := F / [a^25, Comm(Comm(b, a), a), b^5];| !gapprompt@gap>| !gapinput@S := StandardPresentation( G : Prime := 5, ClassBound := 10 );| !gapprompt@gap>| !gapinput@IsPcGroup( S );| false !gapprompt@gap>| !gapinput@# if we need to compute with S we should convert it to a pc group| !gapprompt@gap>| !gapinput@Spc := PcGroupFpGroup( S );| !gapprompt@gap>| !gapinput@| !gapprompt@gap>| !gapinput@H := F / [ a^625, Comm(Comm(Comm(Comm(b, a), a), a), a)/Comm(b, a)^5,| !gapprompt@>| !gapinput@ Comm(Comm(b, a), b), b^625 ];;| !gapprompt@gap>| !gapinput@StandardPresentation( H : Prime := 5, ClassBound := 15, Metabelian );| !gapprompt@gap>| !gapinput@| !gapprompt@gap>| !gapinput@F4 := FreeGroup( "a", "b", "c", "d" );;| !gapprompt@gap>| !gapinput@a := F4.1;; b := F4.2;; c := F4.3;; d := F4.4;;| !gapprompt@gap>| !gapinput@G4 := F4 / [ b^4, b^2 / Comm(Comm (b, a), a), d^16,| !gapprompt@>| !gapinput@ a^16 / (c * d), b^8 / (d * c^4) ];| !gapprompt@gap>| !gapinput@K := Pq( G4 : Prime := 2, ClassBound := 1 );| !gapprompt@gap>| !gapinput@StandardPresentation( G4 : pQuotient := K, ClassBound := 14 );| \end{Verbatim} Typing: \texttt{PqExample( "StandardPresentation" );} runs the above example in \textsf{GAP} (see{\nobreakspace}\texttt{PqExample} (\ref{PqExample})). } \subsection{\textcolor{Chapter }{EpimorphismPqStandardPresentation}} \logpage{[ 4, 2, 2 ]}\nobreak \hyperdef{L}{X828C06D083C0D089}{} {\noindent\textcolor{FuncColor}{$\triangleright$\enspace\texttt{EpimorphismPqStandardPresentation({\mdseries\slshape F: options})\index{EpimorphismPqStandardPresentation@\texttt{EpimorphismPqStandardPresentation}} \label{EpimorphismPqStandardPresentation} }\hfill{\scriptsize (function)}}\\ \noindent\textcolor{FuncColor}{$\triangleright$\enspace\texttt{EpimorphismStandardPresentation({\mdseries\slshape F: options})\index{EpimorphismStandardPresentation@\texttt{EpimorphismStandardPresentation}} \label{EpimorphismStandardPresentation} }\hfill{\scriptsize (method)}}\\ Each of the above functions accepts the same arguments and options as the function \texttt{StandardPresentation} (see{\nobreakspace}\texttt{StandardPresentation} (\ref{StandardPresentation})) and returns an epimorphism from the fp or pc group \mbox{\texttt{\mdseries\slshape F}} onto the finitely presented group given by a standard presentation, i.e.{\nobreakspace}if \mbox{\texttt{\mdseries\slshape S}} is the standard presentation computed for the $p$\texttt{\symbol{45}}quotient of \mbox{\texttt{\mdseries\slshape F}} by \texttt{StandardPresentation} then \texttt{EpimorphismStandardPresentation} returns the epimorphism from \mbox{\texttt{\mdseries\slshape F}} to the group with presentation \mbox{\texttt{\mdseries\slshape S}}. \emph{Note:} The attributes and property \texttt{NuclearRank}, \texttt{MultiplicatorRank} and \texttt{IsCapable} are set for the image group of the epimorphism returned by \texttt{EpimorphismPqStandardPresentation} or \texttt{EpimorphismStandardPresentation} (see Section{\nobreakspace}\hyperref[Attributes and a Property for fp and pc p-groups]{`Attributes and a Property for fp and pc p\texttt{\symbol{45}}groups'}). We illustrate the function with the following example. \begin{Verbatim}[commandchars=!@|,fontsize=\small,frame=single,label=Example] !gapprompt@gap>| !gapinput@F := FreeGroup(6, "F");| !gapprompt@gap>| !gapinput@# For printing GAP uses the symbols F1, ... for the generators of F| !gapprompt@gap>| !gapinput@x := F.1;; y := F.2;; z := F.3;; w := F.4;; a := F.5;; b := F.6;;| !gapprompt@gap>| !gapinput@R := [x^3 / w, y^3 / w * a^2 * b^2, w^3 / b,| !gapprompt@>| !gapinput@ Comm (y, x) / z, Comm (z, x), Comm (z, y) / a, z^3 ];;| !gapprompt@gap>| !gapinput@Q := F / R;| !gapprompt@gap>| !gapinput@# For printing GAP also uses the symbols F1, ... for the generators of Q| !gapprompt@gap>| !gapinput@# (the same as used for F) ... but the gen'rs of Q and F are different:| !gapprompt@gap>| !gapinput@GeneratorsOfGroup(F) = GeneratorsOfGroup(Q);| false !gapprompt@gap>| !gapinput@G := Pq( Q : Prime := 3, ClassBound := 3 );| !gapprompt@gap>| !gapinput@phi := EpimorphismStandardPresentation( Q : Prime := 3,| !gapprompt@>| !gapinput@ ClassBound := 3 );| [ F1, F2, F3, F4, F5, F6 ] -> [ f1*f2^2*f3*f4^2*f5^2, f1*f2*f3*f5, f3^2, f4*f6^2, f5, f6 ] !gapprompt@gap>| !gapinput@Source(phi); # This is the group Q (GAP uses F1, ... for gen'r symbols)| !gapprompt@gap>| !gapinput@Range(phi); # This is the group G (GAP uses f1, ... for gen'r symbols)| !gapprompt@gap>| !gapinput@AssignGeneratorVariables(G);| #I Assigned the global variables [ f1, f2, f3, f4, f5, f6 ] !gapprompt@gap>| !gapinput@# Just to see that the images of [F1, ..., F6] do generate G| !gapprompt@gap>| !gapinput@Group([ f1*f2^2*f3, f1*f2*f3*f4*f5^2*f6^2, f3^2, f4, f5, f6 ]) = G;| true !gapprompt@gap>| !gapinput@Size( Image(phi) );| 729 \end{Verbatim} Typing: \texttt{PqExample( "EpimorphismStandardPresentation" );} runs the above example in \textsf{GAP} (see{\nobreakspace}\texttt{PqExample} (\ref{PqExample})). Note that \texttt{AssignGeneratorVariables} (see{\nobreakspace}\texttt{AssignGeneratorVariables} (\textbf{Reference: AssignGeneratorVariables})) has only been available since \textsf{GAP}{\nobreakspace}4.3. } } \section{\textcolor{Chapter }{Testing p\texttt{\symbol{45}}Groups for Isomorphism}}\label{Testing p-Groups for Isomorphism} \logpage{[ 4, 3, 0 ]} \hyperdef{L}{X8030FAE586423615}{} { \subsection{\textcolor{Chapter }{IsPqIsomorphicPGroup}} \logpage{[ 4, 3, 1 ]}\nobreak \hyperdef{L}{X854389FC780BB178}{} {\noindent\textcolor{FuncColor}{$\triangleright$\enspace\texttt{IsPqIsomorphicPGroup({\mdseries\slshape G, H})\index{IsPqIsomorphicPGroup@\texttt{IsPqIsomorphicPGroup}} \label{IsPqIsomorphicPGroup} }\hfill{\scriptsize (function)}}\\ \noindent\textcolor{FuncColor}{$\triangleright$\enspace\texttt{IsIsomorphicPGroup({\mdseries\slshape G, H})\index{IsIsomorphicPGroup@\texttt{IsIsomorphicPGroup}} \label{IsIsomorphicPGroup} }\hfill{\scriptsize (method)}}\\ each return true if \mbox{\texttt{\mdseries\slshape G}} is isomorphic to \mbox{\texttt{\mdseries\slshape H}}, where both \mbox{\texttt{\mdseries\slshape G}} and \mbox{\texttt{\mdseries\slshape H}} must be pc groups of prime power order. These functions compute and compare in \textsf{GAP} the fp groups given by standard presentations for \mbox{\texttt{\mdseries\slshape G}} and \mbox{\texttt{\mdseries\slshape H}} (see \texttt{StandardPresentation} (\ref{StandardPresentation})). \begin{Verbatim}[commandchars=!@|,fontsize=\small,frame=single,label=Example] !gapprompt@gap>| !gapinput@G := Group( (1,2,3,4), (1,3) );| Group([ (1,2,3,4), (1,3) ]) !gapprompt@gap>| !gapinput@P1 := Image( IsomorphismPcGroup( G ) );| Group([ f1, f2, f3 ]) !gapprompt@gap>| !gapinput@P2 := ElementaryAbelianGroup( 8 );| !gapprompt@gap>| !gapinput@IsIsomorphicPGroup( P1, P2 );| false !gapprompt@gap>| !gapinput@P3 := QuaternionGroup( 8 );| !gapprompt@gap>| !gapinput@IsIsomorphicPGroup( P1, P3 );| false !gapprompt@gap>| !gapinput@P4 := DihedralGroup( 8 );| !gapprompt@gap>| !gapinput@IsIsomorphicPGroup( P1, P4 );| true \end{Verbatim} Typing: \texttt{PqExample( "IsIsomorphicPGroup" );} runs the above example in \textsf{GAP} (see{\nobreakspace}\texttt{PqExample} (\ref{PqExample})). } } \section{\textcolor{Chapter }{Computing Descendants of a p\texttt{\symbol{45}}Group}}\label{Computing Descendants of a p-Group} \logpage{[ 4, 4, 0 ]} \hyperdef{L}{X8450C72580D91245}{} { \subsection{\textcolor{Chapter }{PqDescendants}} \logpage{[ 4, 4, 1 ]}\nobreak \hyperdef{L}{X80985CC479CD9FA3}{} {\noindent\textcolor{FuncColor}{$\triangleright$\enspace\texttt{PqDescendants({\mdseries\slshape G: options})\index{PqDescendants@\texttt{PqDescendants}} \label{PqDescendants} }\hfill{\scriptsize (function)}}\\ returns, for the pc group \mbox{\texttt{\mdseries\slshape G}} which must be of prime power order with a confluent pc presentation (see{\nobreakspace}\texttt{IsConfluent} (\textbf{Reference: IsConfluent for pc groups}) in the \textsf{GAP} Reference Manual), a list of proper descendants (pc groups) of \mbox{\texttt{\mdseries\slshape G}}. Following the colon \mbox{\texttt{\mdseries\slshape options}} a selection of the options listed below should be given, separated by commas like record components (see Section{\nobreakspace} \textbf{Reference: Function Call With Options} in the \textsf{GAP} Reference Manual). See Chapter{\nobreakspace}\hyperref[ANUPQ Options]{`ANUPQ Options'} for detailed descriptions of the options. The automorphism group of each descendant \mbox{\texttt{\mdseries\slshape D}} is also computed via a call to the \texttt{AutomorphismGroupPGroup} function of the \textsf{AutPGrp} package. \begin{itemize} \item \texttt{ClassBound := \mbox{\texttt{\mdseries\slshape n}}}\index{option ClassBound} \item \texttt{Relators := \mbox{\texttt{\mdseries\slshape rels}}}\index{option Relators} \item \texttt{OrderBound := \mbox{\texttt{\mdseries\slshape n}}}\index{option OrderBound} \item \texttt{StepSize := \mbox{\texttt{\mdseries\slshape n}}}, \texttt{StepSize := \mbox{\texttt{\mdseries\slshape list}}} \index{option StepSize} \item \texttt{RankInitialSegmentSubgroups := \mbox{\texttt{\mdseries\slshape n}}}\index{option RankInitialSegmentSubgroups} \item \texttt{SpaceEfficient}\index{option SpaceEfficient} \item \texttt{CapableDescendants}\index{option CapableDescendants} \item \texttt{AllDescendants := false}\index{option AllDescendants} \item \texttt{Exponent := \mbox{\texttt{\mdseries\slshape n}}}\index{option Exponent} \item \texttt{Metabelian}\index{option Metabelian} \item \texttt{GroupName := \mbox{\texttt{\mdseries\slshape name}}}\index{option GroupName} \item \texttt{SubList := \mbox{\texttt{\mdseries\slshape sub}}}\index{option SubList} \item \texttt{BasicAlgorithm}\index{option BasicAlgorithm} \item \texttt{CustomiseOutput := \mbox{\texttt{\mdseries\slshape rec}}}\index{option CustomiseOutput} \item \texttt{SetupFile := \mbox{\texttt{\mdseries\slshape filename}}}\index{option SetupFile} \item \texttt{PqWorkspace := \mbox{\texttt{\mdseries\slshape workspace}}}\index{option PqWorkspace} \end{itemize} \emph{Notes:} The function \texttt{PqDescendants} uses the automorphism group of \mbox{\texttt{\mdseries\slshape G}} which it computes via the package \textsf{AutPGrp}. If this package is not installed an error may be raised. If the automorphism group of \mbox{\texttt{\mdseries\slshape G}} is insoluble, the \texttt{pq} program will call \textsf{GAP} together with the \textsf{AutPGrp} package for certain orbit\texttt{\symbol{45}}stabilizer calculations. (So, in any case, one should ensure the \textsf{AutPGrp} package is installed.) The attributes and property \texttt{NuclearRank}, \texttt{MultiplicatorRank} and \texttt{IsCapable} are set for each group of the list returned by \texttt{PqDescendants} (see Section{\nobreakspace}\hyperref[Attributes and a Property for fp and pc p-groups]{`Attributes and a Property for fp and pc p\texttt{\symbol{45}}groups'}). The options \mbox{\texttt{\mdseries\slshape options}} for \texttt{PqDescendants} may be passed in an alternative manner to that already described, namely you can pass \texttt{PqDescendants} a record as an argument, which contains as entries some (or all) of the above mentioned. Those parameters which do not occur in the record are set to their default values. Note that you cannot set both \texttt{OrderBound} and \texttt{StepSize}. In the first example we compute all proper descendants of the Klein four group which have exponent\texttt{\symbol{45}}2 class at most 5 and order at most $2^6$. \begin{Verbatim}[commandchars=!@|,fontsize=\small,frame=single,label=Example] !gapprompt@gap>| !gapinput@F := FreeGroup( "a", "b" );; a := F.1;; b := F.2;;| !gapprompt@gap>| !gapinput@G := PcGroupFpGroup( F / [ a^2, b^2, Comm(b, a) ] );| !gapprompt@gap>| !gapinput@des := PqDescendants( G : OrderBound := 6, ClassBound := 5 );;| !gapprompt@gap>| !gapinput@Length(des);| 83 !gapprompt@gap>| !gapinput@List(des, Size); | [ 8, 8, 8, 16, 16, 16, 32, 16, 16, 16, 16, 16, 32, 32, 64, 64, 32, 32, 32, 32, 32, 32, 32, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 32, 32, 32, 32, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 32, 32, 32, 32, 32, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64 ] !gapprompt@gap>| !gapinput@List(des, d -> Length( PCentralSeries( d, 2 ) ) - 1 );| [ 2, 2, 2, 2, 2, 2, 2, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 5, 5, 5, 5, 5 ] \end{Verbatim} Below, we compute all capable descendants of order 27 of the elementary abelian group of order 9. \begin{Verbatim}[commandchars=!@|,fontsize=\small,frame=single,label=Example] !gapprompt@gap>| !gapinput@F := FreeGroup( 2, "g" );| !gapprompt@gap>| !gapinput@G := PcGroupFpGroup( F / [ F.1^3, F.2^3, Comm(F.1, F.2) ] );| !gapprompt@gap>| !gapinput@des := PqDescendants( G : OrderBound := 3, ClassBound := 2,| !gapprompt@>| !gapinput@ CapableDescendants );| [ , ] !gapprompt@gap>| !gapinput@List(des, d -> Length( PCentralSeries( d, 3 ) ) - 1 );| [ 2, 2 ] !gapprompt@gap>| !gapinput@# For comparison let us now compute all proper descendants| !gapprompt@gap>| !gapinput@PqDescendants( G : OrderBound := 3, ClassBound := 2);| [ , , ] \end{Verbatim} In the third example, we compute all proper capable descendants of the elementary abelian group of order $5^2$ which have exponent\texttt{\symbol{45}}$5$ class at most $3$, exponent $5$, and are metabelian. \begin{Verbatim}[commandchars=!@|,fontsize=\small,frame=single,label=Example] !gapprompt@gap>| !gapinput@F := FreeGroup( 2, "g" );;| !gapprompt@gap>| !gapinput@G := PcGroupFpGroup( F / [ F.1^5, F.2^5, Comm(F.2, F.1) ] );| !gapprompt@gap>| !gapinput@des := PqDescendants( G : Metabelian, ClassBound := 3,| !gapprompt@>| !gapinput@ Exponent := 5, CapableDescendants );| [ , , ] !gapprompt@gap>| !gapinput@List(des, d -> Length( PCentralSeries( d, 5 ) ) - 1 );| [ 2, 3, 3 ] !gapprompt@gap>| !gapinput@List(des, d -> Length( DerivedSeries( d ) ) );| [ 3, 3, 3 ] !gapprompt@gap>| !gapinput@List(des, d -> Maximum( List( d, Order ) ) );| [ 5, 5, 5 ] \end{Verbatim} The examples \texttt{"PqDescendants\texttt{\symbol{45}}1"}, \texttt{"PqDescendants\texttt{\symbol{45}}2"} and \texttt{"PqDescendants\texttt{\symbol{45}}3"} (in order) are essentially the same as the above three examples (see{\nobreakspace}\texttt{PqExample} (\ref{PqExample})). } \subsection{\textcolor{Chapter }{PqSupplementInnerAutomorphisms}} \logpage{[ 4, 4, 2 ]}\nobreak \hyperdef{L}{X8364566A80A8C24B}{} {\noindent\textcolor{FuncColor}{$\triangleright$\enspace\texttt{PqSupplementInnerAutomorphisms({\mdseries\slshape D})\index{PqSupplementInnerAutomorphisms@\texttt{PqSupplementInnerAutomorphisms}} \label{PqSupplementInnerAutomorphisms} }\hfill{\scriptsize (function)}}\\ returns a generating set for a supplement to the inner automorphisms of \mbox{\texttt{\mdseries\slshape D}}, in the form of a record with fields \texttt{agAutos}, \texttt{agOrder} and \texttt{glAutos}, as provided by the \texttt{pq} program. One should be very careful in using these automorphisms for a descendant calculation. \emph{Note:} In principle there must be a way to use those automorphisms in order to compute descendants but there does not seem to be a way to hand back these automorphisms properly to the \texttt{pq} program. \begin{Verbatim}[commandchars=!@|,fontsize=\small,frame=single,label=Example] !gapprompt@gap>| !gapinput@Q := Pq( FreeGroup(2) : Prime := 3, ClassBound := 1 );| !gapprompt@gap>| !gapinput@des := PqDescendants( Q : StepSize := 1 );| [ , , ] !gapprompt@gap>| !gapinput@S := PqSupplementInnerAutomorphisms( des[3] );| rec( agAutos := [ ], agOrder := [ 3, 2, 2, 2 ], glAutos := [ Pcgs([ f1, f2, f3 ]) -> [ f1*f2^2, f2, f3 ], Pcgs([ f1, f2, f3 ]) -> [ f1^2, f2, f3^2 ], Pcgs([ f1, f2, f3 ]) -> [ f1^2, f2, f3^2 ] ] ) !gapprompt@gap>| !gapinput@A := AutomorphismGroupPGroup( des[3] );| rec( agAutos := [ Pcgs([ f1, f2, f3 ]) -> [ f1^2, f2, f3^2 ], Pcgs([ f1, f2, f3 ]) -> [ f1*f2^2, f2, f3 ], Pcgs([ f1, f2, f3 ]) -> [ f1*f3, f2, f3 ], Pcgs([ f1, f2, f3 ]) -> [ f1, f2*f3, f3 ] ], agOrder := [ 2, 3, 3, 3 ], glAutos := [ ], glOper := [ ], glOrder := 1, group := , one := IdentityMapping( ), size := 54 ) \end{Verbatim} Typing: \texttt{PqExample( "PqSupplementInnerAutomorphisms" );} runs the above example in \textsf{GAP} (see{\nobreakspace}\texttt{PqExample} (\ref{PqExample})). Note that by also including \texttt{PqStart} as a second argument to \texttt{PqExample} one can see how it is possible, with the aid of \texttt{PqSetPQuotientToGroup} (see{\nobreakspace}\texttt{PqSetPQuotientToGroup} (\ref{PqSetPQuotientToGroup})), to do the equivalent computations with the interactive versions of \texttt{Pq} and \texttt{PqDescendants} and a single \texttt{pq} process (recall \texttt{pq} is the name of the external C program). } \subsection{\textcolor{Chapter }{PqList}} \logpage{[ 4, 4, 3 ]}\nobreak \hyperdef{L}{X79AD54E987FCACBA}{} {\noindent\textcolor{FuncColor}{$\triangleright$\enspace\texttt{PqList({\mdseries\slshape filename: [SubList := sub]})\index{PqList@\texttt{PqList}} \label{PqList} }\hfill{\scriptsize (function)}}\\ reads a file with name \mbox{\texttt{\mdseries\slshape filename}} (a string) and returns the list \mbox{\texttt{\mdseries\slshape L}} of pc groups (or with option \texttt{SubList} a sublist of \mbox{\texttt{\mdseries\slshape L}} or a single pc group in \mbox{\texttt{\mdseries\slshape L}}) defined in that file. If the option \texttt{SubList} is passed and has the value \mbox{\texttt{\mdseries\slshape sub}}, then it has the same meaning as for \texttt{PqDescendants}, i.e.{\nobreakspace}if \mbox{\texttt{\mdseries\slshape sub}} is an integer then \texttt{PqList} returns \texttt{\mbox{\texttt{\mdseries\slshape L}}[\mbox{\texttt{\mdseries\slshape sub}}]}; otherwise, if \mbox{\texttt{\mdseries\slshape sub}} is a list of integers \texttt{PqList} returns \texttt{Sublist(\mbox{\texttt{\mdseries\slshape L}}, \mbox{\texttt{\mdseries\slshape sub}} )}. Both \texttt{PqList} and \texttt{SavePqList} (see \texttt{SavePqList} (\ref{SavePqList})) can be used to save and restore a list of descendants (see \texttt{PqDescendants} (\ref{PqDescendants})). } \subsection{\textcolor{Chapter }{SavePqList}} \logpage{[ 4, 4, 4 ]}\nobreak \hyperdef{L}{X85ADB9E6870EC3D1}{} {\noindent\textcolor{FuncColor}{$\triangleright$\enspace\texttt{SavePqList({\mdseries\slshape filename, list})\index{SavePqList@\texttt{SavePqList}} \label{SavePqList} }\hfill{\scriptsize (function)}}\\ writes a list of descendants \mbox{\texttt{\mdseries\slshape list}} to a file with name \mbox{\texttt{\mdseries\slshape filename}} (a string). \texttt{SavePqList} and \texttt{PqList} (see \texttt{PqList} (\ref{PqList})) can be used to save and restore, respectively, the results of \texttt{PqDescendants} (see \texttt{PqDescendants} (\ref{PqDescendants})). } } } \chapter{\textcolor{Chapter }{Interactive ANUPQ functions}}\label{Interactive ANUPQ functions} \logpage{[ 5, 0, 0 ]} \hyperdef{L}{X842C13C27B941744}{} { Here we describe the interactive functions defined by the \textsf{ANUPQ} package, i.e.{\nobreakspace}the functions that manipulate and initiate interactive \textsf{ANUPQ} processes. These are functions that extract information via a dialogue with a running \texttt{pq} process (process used in the UNIX sense). Occasionally, a user needs the ``next step''; the functions provided in this chapter make use of data from previous steps retained by the \texttt{pq} program, thus allowing the user to interact with the \texttt{pq} program like one can when one uses the \texttt{pq} program as a stand\texttt{\symbol{45}}alone (see{\nobreakspace}\texttt{guide.dvi} in the \texttt{standalone\texttt{\symbol{45}}doc} directory). An interactive \textsf{ANUPQ} process is initiated by \texttt{PqStart} and terminated via \texttt{PqQuit}; these functions are described in ection{\nobreakspace}\hyperref[Starting and Stopping Interactive ANUPQ Processes]{`Starting and Stopping Interactive ANUPQ Processes'}. Each interactive \textsf{ANUPQ} function that manipulates an already started interactive \textsf{ANUPQ} process, has a form where the first argument is the integer \mbox{\texttt{\mdseries\slshape i}} returned by the initiating \texttt{PqStart} command, and a second form with one argument fewer (where the integer \mbox{\texttt{\mdseries\slshape i}} is discovered by a default mechanism, namely by determining the least integer \mbox{\texttt{\mdseries\slshape i}} for which there is a currently active interactive \textsf{ANUPQ} process). We will thus commonly say that ``for the \mbox{\texttt{\mdseries\slshape i}}th (or default) interactive \textsf{ANUPQ} process'' a certain function performs a given action. In each case, it is an error if \mbox{\texttt{\mdseries\slshape i}} is not the index of an active interactive process, or there are no current active interactive processes. \emph{Notes}: The global method of passing options (via \texttt{PushOptions}), should not be used with any of the interactive functions. In fact, the \texttt{OptionsStack} should be empty at the time any of the interactive functions is called. On \texttt{quit}ting \textsf{GAP}, \texttt{PqQuitAll();} is executed, which terminates all active interactive \textsf{ANUPQ} processes. If \textsf{GAP} is killed without \texttt{quit}ting, before all interactive \textsf{ANUPQ} processes are terminated, \emph{zombie} processes (still living \emph{child} processes whose \emph{parents} have died), may result. Since zombie processes do consume resources, in such an event, the responsible computer user should seek out and terminate those zombie processes (e.g.{\nobreakspace}on Linux: \texttt{ps xw | grep pq} gives you information on the \texttt{pq} processes corresponding to any interactive \textsf{ANUPQ} processes started in a \textsf{GAP} session; you can then do \texttt{kill \mbox{\texttt{\mdseries\slshape N}}} for each number \mbox{\texttt{\mdseries\slshape N}} appearing in the first column of this output). \section{\textcolor{Chapter }{Starting and Stopping Interactive ANUPQ Processes}}\label{Starting and Stopping Interactive ANUPQ Processes} \logpage{[ 5, 1, 0 ]} \hyperdef{L}{X7935CDAD7936CA0A}{} { \subsection{\textcolor{Chapter }{PqStart (with group and workspace size)}} \logpage{[ 5, 1, 1 ]}\nobreak \hyperdef{L}{X83B2EC237F37623C}{} {\noindent\textcolor{FuncColor}{$\triangleright$\enspace\texttt{PqStart({\mdseries\slshape G, workspace: options})\index{PqStart@\texttt{PqStart}!with group and workspace size} \label{PqStart:with group and workspace size} }\hfill{\scriptsize (function)}}\\ \noindent\textcolor{FuncColor}{$\triangleright$\enspace\texttt{PqStart({\mdseries\slshape G: options})\index{PqStart@\texttt{PqStart}!with group} \label{PqStart:with group} }\hfill{\scriptsize (function)}}\\ \noindent\textcolor{FuncColor}{$\triangleright$\enspace\texttt{PqStart({\mdseries\slshape workspace: options})\index{PqStart@\texttt{PqStart}!with workspace size} \label{PqStart:with workspace size} }\hfill{\scriptsize (function)}}\\ \noindent\textcolor{FuncColor}{$\triangleright$\enspace\texttt{PqStart({\mdseries\slshape : options})\index{PqStart@\texttt{PqStart}} \label{PqStart} }\hfill{\scriptsize (function)}}\\ activate an iostream for an interactive \textsf{ANUPQ} process (i.e. \texttt{PqStart} starts up a \texttt{pq} process and opens a \textsf{GAP} iostream to ``talk'' to that process) and returns an integer \mbox{\texttt{\mdseries\slshape i}} that can be used to identify that process. The argument \mbox{\texttt{\mdseries\slshape G}} should be an \emph{fp group} or \emph{pc group} that the user intends to manipulate using interactive \textsf{ANUPQ} functions. If the function is called without specifying \mbox{\texttt{\mdseries\slshape G}}, a group can be read in by using the function \texttt{PqRestorePcPresentation} (see{\nobreakspace}\texttt{PqRestorePcPresentation} (\ref{PqRestorePcPresentation})). If \texttt{PqStart} is given an integer argument \mbox{\texttt{\mdseries\slshape workspace}}, then the \texttt{pq} program is started up with a workspace (an integer array) of size \mbox{\texttt{\mdseries\slshape workspace}} (i.e. $4 \times \mbox{\texttt{\mdseries\slshape workspace}}$ bytes in a 32\texttt{\symbol{45}}bit environment); otherwise, the \texttt{pq} program sets a default workspace of $10000000$. The only \mbox{\texttt{\mdseries\slshape options}} currently recognised by \texttt{PqStart} are \texttt{Prime}, \texttt{Exponent} and \texttt{Relators} (see Chapter{\nobreakspace}\hyperref[ANUPQ Options]{`ANUPQ Options'} for detailed descriptions of these options) and if provided they are essentially global for the interactive \textsf{ANUPQ} process, except that any interactive function interacting with the process and passing new values for these options will over\texttt{\symbol{45}}ride the global values. } \subsection{\textcolor{Chapter }{PqQuit}} \logpage{[ 5, 1, 2 ]}\nobreak \hyperdef{L}{X79DB761185BAB9C8}{} {\noindent\textcolor{FuncColor}{$\triangleright$\enspace\texttt{PqQuit({\mdseries\slshape i})\index{PqQuit@\texttt{PqQuit}} \label{PqQuit} }\hfill{\scriptsize (function)}}\\ \noindent\textcolor{FuncColor}{$\triangleright$\enspace\texttt{PqQuit({\mdseries\slshape })\index{PqQuit@\texttt{PqQuit}!for default process} \label{PqQuit:for default process} }\hfill{\scriptsize (function)}}\\ closes the stream of the \mbox{\texttt{\mdseries\slshape i}}th or default interactive \textsf{ANUPQ} process and unbinds its \texttt{ANUPQData.io} record. \emph{Note:} It can happen that the \texttt{pq} process, and hence the \textsf{GAP} iostream assigned to communicate with it, can die, e.g.{\nobreakspace}by the user typing a \texttt{Ctrl\texttt{\symbol{45}}C} while the \texttt{pq} process is engaged in a long calculation. \texttt{IsPqProcessAlive} (see{\nobreakspace}\texttt{IsPqProcessAlive} (\ref{IsPqProcessAlive})) is provided to check the status of the \textsf{GAP} iostream (and hence the status of the \texttt{pq} process it was communicating with). } \subsection{\textcolor{Chapter }{PqQuitAll}} \logpage{[ 5, 1, 3 ]}\nobreak \hyperdef{L}{X7FF8F2657B1B008E}{} {\noindent\textcolor{FuncColor}{$\triangleright$\enspace\texttt{PqQuitAll({\mdseries\slshape })\index{PqQuitAll@\texttt{PqQuitAll}} \label{PqQuitAll} }\hfill{\scriptsize (function)}}\\ is provided as a convenience, to terminate all active interactive \textsf{ANUPQ} processes with a single command. It is equivalent to executing \texttt{PqQuit(\mbox{\texttt{\mdseries\slshape i}})} for all active interactive \textsf{ANUPQ} processes \mbox{\texttt{\mdseries\slshape i}} (see{\nobreakspace}\texttt{PqQuit} (\ref{PqQuit})). } } \section{\textcolor{Chapter }{Interactive ANUPQ Process Utility Functions}}\label{Interactive ANUPQ Process Utility Functions} \logpage{[ 5, 2, 0 ]} \hyperdef{L}{X7EE8000A800CEE2D}{} { \subsection{\textcolor{Chapter }{PqProcessIndex}} \logpage{[ 5, 2, 1 ]}\nobreak \hyperdef{L}{X8558B20A80B999AE}{} {\noindent\textcolor{FuncColor}{$\triangleright$\enspace\texttt{PqProcessIndex({\mdseries\slshape i})\index{PqProcessIndex@\texttt{PqProcessIndex}} \label{PqProcessIndex} }\hfill{\scriptsize (function)}}\\ \noindent\textcolor{FuncColor}{$\triangleright$\enspace\texttt{PqProcessIndex({\mdseries\slshape })\index{PqProcessIndex@\texttt{PqProcessIndex}!for default process} \label{PqProcessIndex:for default process} }\hfill{\scriptsize (function)}}\\ With argument \mbox{\texttt{\mdseries\slshape i}}, which must be a positive integer, \texttt{PqProcessIndex} returns \mbox{\texttt{\mdseries\slshape i}} if it corresponds to an active interactive process, or raises an error. With no arguments it returns the default active interactive process or returns \texttt{fail} and emits a warning message to \texttt{Info} at \texttt{InfoANUPQ} or \texttt{InfoWarning} level 1. \emph{Note:} Essentially, an interactive \textsf{ANUPQ} process \mbox{\texttt{\mdseries\slshape i}} is ``active'' if \texttt{ANUPQData.io[\mbox{\texttt{\mdseries\slshape i}}]} is bound (i.e.{\nobreakspace}we still have some data telling us about it). Also see{\nobreakspace}\texttt{PqStart} (\ref{PqStart}). } \subsection{\textcolor{Chapter }{PqProcessIndices}} \logpage{[ 5, 2, 2 ]}\nobreak \hyperdef{L}{X7E4A56D67C865291}{} {\noindent\textcolor{FuncColor}{$\triangleright$\enspace\texttt{PqProcessIndices({\mdseries\slshape })\index{PqProcessIndices@\texttt{PqProcessIndices}} \label{PqProcessIndices} }\hfill{\scriptsize (function)}}\\ returns the list of integer indices of all active interactive \textsf{ANUPQ} processes (see{\nobreakspace}\texttt{PqProcessIndex} (\ref{PqProcessIndex}) for the meaning of ``active''). } \subsection{\textcolor{Chapter }{IsPqProcessAlive}} \logpage{[ 5, 2, 3 ]}\nobreak \hyperdef{L}{X7C103DF78435AEC7}{} {\noindent\textcolor{FuncColor}{$\triangleright$\enspace\texttt{IsPqProcessAlive({\mdseries\slshape i})\index{IsPqProcessAlive@\texttt{IsPqProcessAlive}} \label{IsPqProcessAlive} }\hfill{\scriptsize (function)}}\\ \noindent\textcolor{FuncColor}{$\triangleright$\enspace\texttt{IsPqProcessAlive({\mdseries\slshape })\index{IsPqProcessAlive@\texttt{IsPqProcessAlive}!for default process} \label{IsPqProcessAlive:for default process} }\hfill{\scriptsize (function)}}\\ return \texttt{true} if the \textsf{GAP} iostream of the \mbox{\texttt{\mdseries\slshape i}}th (or default) interactive \textsf{ANUPQ} process started by \texttt{PqStart} is alive (i.e.{\nobreakspace}can still be written to), or \texttt{false}, otherwise. (See the notes for{\nobreakspace}\texttt{PqStart} (\ref{PqStart}) and{\nobreakspace}\texttt{PqQuit} (\ref{PqQuit}).) \index{interruption} If the user does not yet have a \texttt{gap{\textgreater}} prompt then usually the \texttt{pq} program is still away doing something and an \textsf{ANUPQ} interface function is still waiting for a reply. Typing a \texttt{Ctrl\texttt{\symbol{45}}C} (i.e.{\nobreakspace}holding down the \texttt{Ctrl} key and typing \texttt{c}) will stop the waiting and send \textsf{GAP} into a \texttt{break}\texttt{\symbol{45}}loop, from which one has no option but to \texttt{quit;}. The typing of \texttt{Ctrl\texttt{\symbol{45}}C}, in such a circumstance, usually causes the stream of the interactive \textsf{ANUPQ} process to die; to check this we provide \texttt{IsPqProcessAlive} (see{\nobreakspace}\texttt{IsPqProcessAlive}). The \textsf{GAP} iostream of an interactive \textsf{ANUPQ} process will also die if the \texttt{pq} program has a segmentation fault. We do hope that this never happens to you, but if it does and the failure is reproducible, then it's a bug and we'd like to know about it. Please read the \texttt{README} that comes with the \textsf{ANUPQ} package to find out what to include in a bug report and who to email it to. } } \section{\textcolor{Chapter }{Interactive Versions of Non\texttt{\symbol{45}}interactive ANUPQ Functions}}\label{Interactive Versions of Non-interactive ANUPQ Functions} \logpage{[ 5, 3, 0 ]} \hyperdef{L}{X823D2BBF7C4515D4}{} { \subsection{\textcolor{Chapter }{Pq (interactive)}} \logpage{[ 5, 3, 1 ]}\nobreak \hyperdef{L}{X85408C4C790439E7}{} {\noindent\textcolor{FuncColor}{$\triangleright$\enspace\texttt{Pq({\mdseries\slshape i: options})\index{Pq@\texttt{Pq}!interactive} \label{Pq:interactive} }\hfill{\scriptsize (function)}}\\ \noindent\textcolor{FuncColor}{$\triangleright$\enspace\texttt{Pq({\mdseries\slshape : options})\index{Pq@\texttt{Pq}!interactive, for default process} \label{Pq:interactive, for default process} }\hfill{\scriptsize (function)}}\\ return, for the fp or pc group (let us call it \mbox{\texttt{\mdseries\slshape F}}), of the \mbox{\texttt{\mdseries\slshape i}}th or default interactive \textsf{ANUPQ} process, the $p$\texttt{\symbol{45}}quotient of \mbox{\texttt{\mdseries\slshape F}} specified by \mbox{\texttt{\mdseries\slshape options}}, as a pc group; \mbox{\texttt{\mdseries\slshape F}} must previously have been given (as first argument) to \texttt{PqStart} to start the interactive \textsf{ANUPQ} process (see{\nobreakspace}\texttt{PqStart} (\ref{PqStart})) or restored from file using the function \texttt{PqRestorePcPresentation} (see{\nobreakspace}\texttt{PqRestorePcPresentation} (\ref{PqRestorePcPresentation})). Following the colon \mbox{\texttt{\mdseries\slshape options}} is a selection of the options listed for the non\texttt{\symbol{45}}interactive \texttt{Pq} function (see{\nobreakspace}\texttt{Pq} (\ref{Pq})), separated by commas like record components (see Section{\nobreakspace} \textbf{Reference: Function Call With Options} in the \textsf{GAP} Reference Manual), except that the options \texttt{SetupFile} or \texttt{PqWorkspace} are ignored by the interactive \texttt{Pq}, and \texttt{RedoPcp} is an option only recognised by the interactive \texttt{Pq} i.e.{\nobreakspace}the following options are recognised by the interactive \texttt{Pq} function: \begin{itemize} \item \texttt{Prime := \mbox{\texttt{\mdseries\slshape p}}}\index{option Prime} \item \texttt{ClassBound := \mbox{\texttt{\mdseries\slshape n}}}\index{option ClassBound} \item \texttt{Exponent := \mbox{\texttt{\mdseries\slshape n}}}\index{option Exponent} \item \texttt{Relators := \mbox{\texttt{\mdseries\slshape rels}}}\index{option Relators} \item \texttt{Metabelian}\index{option Metabelian} \item \texttt{Identities := \mbox{\texttt{\mdseries\slshape funcs}}}\index{option Identities} \item \texttt{GroupName := \mbox{\texttt{\mdseries\slshape name}}}\index{option GroupName} \item \texttt{OutputLevel := \mbox{\texttt{\mdseries\slshape n}}}\index{option OutputLevel} \item \texttt{RedoPcp}\index{option RedoPcp} \end{itemize} Detailed descriptions of the above options may be found in Chapter{\nobreakspace}\hyperref[ANUPQ Options]{`ANUPQ Options'}. As a minimum the \texttt{Pq} function \emph{must} have a value for the \texttt{Prime} option, though \texttt{Prime} need not be passed again in the case it has previously been provided, e.g. to \texttt{PqStart} (see{\nobreakspace}\texttt{PqStart} (\ref{PqStart})) when starting the interactive process. The behaviour of the interactive \texttt{Pq} function depends on the current state of the pc presentation stored by the \texttt{pq} program: \begin{enumerate} \item If no pc presentation has yet been computed (the case immediately after the \texttt{PqStart} call initiating the process) then the quotient group of the input group of the process of largest lower exponent\texttt{\symbol{45}}\mbox{\texttt{\mdseries\slshape p}} class bounded by the value of the \texttt{ClassBound} option (see{\nobreakspace}\ref{option ClassBound}) is returned. \item If the current pc presentation of the process was determined by a previous call to \texttt{Pq} or \texttt{PqEpimorphism}, and the current call has a larger value \texttt{ClassBound} then the class is extended as much as is possible and the quotient group of the input group of the process of the new lower exponent\texttt{\symbol{45}}\mbox{\texttt{\mdseries\slshape p}} class is returned. \item If the current pc presentation of the process was determined by a previous call to \texttt{PqPCover} then a consistent pc presentation of a quotient for the current class is determined before proceeding as in 2. \item If the \texttt{RedoPcp} option is supplied the current pc presentation is scrapped, all options must be re\texttt{\symbol{45}}supplied (in particular, \texttt{Prime} \emph{must} be supplied) and then the \texttt{Pq} function proceeds as in 1. \end{enumerate} See Section{\nobreakspace}\hyperref[Attributes and a Property for fp and pc p-groups]{`Attributes and a Property for fp and pc p\texttt{\symbol{45}}groups'} for the attributes and property \texttt{NuclearRank}, \texttt{MultiplicatorRank} and \texttt{IsCapable} which may be applied to the group returned by \texttt{Pq}. The following is one of the examples for the non\texttt{\symbol{45}}interactive \texttt{Pq} redone with the interactive version. Also, we set the option \texttt{OutputLevel} to 1 (see{\nobreakspace}\ref{option OutputLevel}), in order to see the orders of the quotients of all the classes determined, and we set the \texttt{InfoANUPQ} level to 2 (see{\nobreakspace}\texttt{InfoANUPQ} (\ref{InfoANUPQ})), so that we catch the timing information. \begin{Verbatim}[commandchars=!@|,fontsize=\small,frame=single,label=Example] !gapprompt@gap>| !gapinput@F := FreeGroup("a", "b");; a := F.1;; b := F.2;;| !gapprompt@gap>| !gapinput@G := F / [a^4, b^4];| !gapprompt@gap>| !gapinput@PqStart(G);| 1 !gapprompt@gap>| !gapinput@SetInfoLevel(InfoANUPQ, 2); #To see timing information| !gapprompt@gap>| !gapinput@Pq(: Prime := 2, ClassBound := 3, OutputLevel := 1 );| #I Lower exponent-2 central series for [grp] #I Group: [grp] to lower exponent-2 central class 1 has order 2^2 #I Group: [grp] to lower exponent-2 central class 2 has order 2^5 #I Group: [grp] to lower exponent-2 central class 3 has order 2^8 #I Computation of presentation took 0.00 seconds \end{Verbatim} } \subsection{\textcolor{Chapter }{PqEpimorphism (interactive)}} \logpage{[ 5, 3, 2 ]}\nobreak \hyperdef{L}{X839E6F578227A8EA}{} {\noindent\textcolor{FuncColor}{$\triangleright$\enspace\texttt{PqEpimorphism({\mdseries\slshape i: options})\index{PqEpimorphism@\texttt{PqEpimorphism}!interactive} \label{PqEpimorphism:interactive} }\hfill{\scriptsize (function)}}\\ \noindent\textcolor{FuncColor}{$\triangleright$\enspace\texttt{PqEpimorphism({\mdseries\slshape : options})\index{PqEpimorphism@\texttt{PqEpimorphism}!interactive, for default process} \label{PqEpimorphism:interactive, for default process} }\hfill{\scriptsize (function)}}\\ return, for the fp or pc group (let us call it \mbox{\texttt{\mdseries\slshape F}}), of the \mbox{\texttt{\mdseries\slshape i}}th or default interactive \textsf{ANUPQ} process, an epimorphism from \mbox{\texttt{\mdseries\slshape F}} onto the $p$\texttt{\symbol{45}}quotient of \mbox{\texttt{\mdseries\slshape F}} specified by \mbox{\texttt{\mdseries\slshape options}}; \mbox{\texttt{\mdseries\slshape F}} must previously have been given (as first argument) to \texttt{PqStart} to start the interactive \textsf{ANUPQ} process (see{\nobreakspace}\texttt{PqStart} (\ref{PqStart})). Since the underlying interactions with the \texttt{pq} program effected by the interactive \texttt{PqEpimorphism} are identical to those effected by the interactive \texttt{Pq}, everything said regarding the requirements and behaviour of the interactive \texttt{Pq} function (see{\nobreakspace}\texttt{Pq} (\ref{Pq:interactive})) is also the case for the interactive \texttt{PqEpimorphism}. \emph{Note:} See Section{\nobreakspace}\hyperref[Attributes and a Property for fp and pc p-groups]{`Attributes and a Property for fp and pc p\texttt{\symbol{45}}groups'} for the attributes and property \texttt{NuclearRank}, \texttt{MultiplicatorRank} and \texttt{IsCapable} which may be applied to the image group of the epimorphism returned by \texttt{PqEpimorphism}. } \subsection{\textcolor{Chapter }{PqPCover (interactive)}} \logpage{[ 5, 3, 3 ]}\nobreak \hyperdef{L}{X7AA64A2F8509A39A}{} {\noindent\textcolor{FuncColor}{$\triangleright$\enspace\texttt{PqPCover({\mdseries\slshape i: options})\index{PqPCover@\texttt{PqPCover}!interactive} \label{PqPCover:interactive} }\hfill{\scriptsize (function)}}\\ \noindent\textcolor{FuncColor}{$\triangleright$\enspace\texttt{PqPCover({\mdseries\slshape : options})\index{PqPCover@\texttt{PqPCover}!interactive, for default process} \label{PqPCover:interactive, for default process} }\hfill{\scriptsize (function)}}\\ return, for the fp or pc group of the \mbox{\texttt{\mdseries\slshape i}}th or default interactive \textsf{ANUPQ} process, the $p$\texttt{\symbol{45}}covering group of the $p$\texttt{\symbol{45}}quotient \texttt{Pq(\mbox{\texttt{\mdseries\slshape i}} : \mbox{\texttt{\mdseries\slshape options}})} or \texttt{Pq(: \mbox{\texttt{\mdseries\slshape options}})}, modulo the following: \begin{enumerate} \item If no pc presentation has yet been computed (the case immediately after the \texttt{PqStart} call initiating the process) and the group \mbox{\texttt{\mdseries\slshape F}} of the process is already a $p$\texttt{\symbol{45}}group, in the sense that \texttt{HasIsPGroup(\mbox{\texttt{\mdseries\slshape F}}) and IsPGroup(\mbox{\texttt{\mdseries\slshape F}})} is \texttt{true}, then \begin{description} \item[{\texttt{Prime}}] defaults to \texttt{PrimePGroup(\mbox{\texttt{\mdseries\slshape F}})}, if not supplied and \texttt{HasPrimePGroup(\mbox{\texttt{\mdseries\slshape F}}) = true}; and \item[{\texttt{ClassBound}}] defaults to \texttt{PClassPGroup(\mbox{\texttt{\mdseries\slshape F}})} if \texttt{HasPClassPGroup(\mbox{\texttt{\mdseries\slshape F}}) = true} if not supplied, or to the usual default of 63, otherwise. \end{description} \item If a pc presentation has been computed and none of \mbox{\texttt{\mdseries\slshape options}} is \texttt{RedoPcp} or if no pc presentation has yet been computed but 1. does not apply then \texttt{PqPCover(\mbox{\texttt{\mdseries\slshape i}} : \mbox{\texttt{\mdseries\slshape options}});} is equivalent to: \begin{Verbatim}[commandchars=!@|,fontsize=\small,frame=single,label=] Pq(i : options); PqPCover(i); \end{Verbatim} \item If the \texttt{RedoPcp} option is supplied the current pc presentation is scrapped, and \texttt{PqPCover} proceeds as in 1. or 2. but without the \texttt{RedoPcp} option. \end{enumerate} } \index{automorphisms!of $p$\texttt{\symbol{45}}groups} \subsection{\textcolor{Chapter }{PqStandardPresentation (interactive)}} \logpage{[ 5, 3, 4 ]}\nobreak \hyperdef{L}{X805F32618005C087}{} {\noindent\textcolor{FuncColor}{$\triangleright$\enspace\texttt{PqStandardPresentation({\mdseries\slshape [i]: options})\index{PqStandardPresentation@\texttt{PqStandardPresentation}!interactive} \label{PqStandardPresentation:interactive} }\hfill{\scriptsize (function)}}\\ \noindent\textcolor{FuncColor}{$\triangleright$\enspace\texttt{StandardPresentation({\mdseries\slshape [i]: options})\index{StandardPresentation@\texttt{StandardPresentation}!interactive} \label{StandardPresentation:interactive} }\hfill{\scriptsize (function)}}\\ return, for the \mbox{\texttt{\mdseries\slshape i}}th or default interactive \textsf{ANUPQ} process, the \mbox{\texttt{\mdseries\slshape p}}\texttt{\symbol{45}}quotient of the group \mbox{\texttt{\mdseries\slshape F}} of the process, specified by \mbox{\texttt{\mdseries\slshape options}}, as an \emph{fp group} which has a standard presentation. Here \mbox{\texttt{\mdseries\slshape options}} is a selection of the options from the following list (see Chapter{\nobreakspace}\hyperref[ANUPQ Options]{`ANUPQ Options'} for detailed descriptions); this list is the same as for the non\texttt{\symbol{45}}interactive version of \texttt{PqStandardPresentation} except for the omission of options \texttt{SetupFile} and \texttt{PqWorkspace} (see{\nobreakspace}\texttt{PqStandardPresentation} (\ref{PqStandardPresentation})). \begin{itemize} \item \texttt{Prime := \mbox{\texttt{\mdseries\slshape p}}}\index{option Prime} \item \texttt{pQuotient := \mbox{\texttt{\mdseries\slshape Q}}}\index{option pQuotient} \item \texttt{ClassBound := \mbox{\texttt{\mdseries\slshape n}}}\index{option ClassBound} \item \texttt{Exponent := \mbox{\texttt{\mdseries\slshape n}}}\index{option Exponent} \item \texttt{Metabelian}\index{option Metabelian} \item \texttt{GroupName := \mbox{\texttt{\mdseries\slshape name}}}\index{option GroupName} \item \texttt{OutputLevel := \mbox{\texttt{\mdseries\slshape n}}}\index{option OutputLevel} \item \texttt{StandardPresentationFile := \mbox{\texttt{\mdseries\slshape filename}}}\index{option StandardPresentationFile} \end{itemize} Unless \mbox{\texttt{\mdseries\slshape F}} is a pc \mbox{\texttt{\mdseries\slshape p}}\texttt{\symbol{45}}group, or the option \texttt{Prime} has been passed to a previous interactive function for the process to compute a \mbox{\texttt{\mdseries\slshape p}}\texttt{\symbol{45}}quotient for \mbox{\texttt{\mdseries\slshape F}}, the user \emph{must} supply either the option \texttt{Prime} or the option \texttt{pQuotient} (if both \texttt{Prime} and \texttt{pQuotient} are supplied, the prime \mbox{\texttt{\mdseries\slshape p}} is determined by applying \texttt{PrimePGroup} (see{\nobreakspace}\texttt{PrimePGroup} (\textbf{Reference: PrimePGroup}) in the Reference Manual) to the value of \texttt{pQuotient}). Taking one of the examples for the non\texttt{\symbol{45}}interactive version of \texttt{StandardPresentation} (see{\nobreakspace}\texttt{StandardPresentation} (\ref{StandardPresentation})) that required two separate calls to the \texttt{pq} program, we now show how it can be done by setting up a dialogue with just the one \texttt{pq} process, using the interactive version of \texttt{StandardPresentation}: \begin{Verbatim}[commandchars=!@|,fontsize=\small,frame=single,label=Example] !gapprompt@gap>| !gapinput@F4 := FreeGroup( "a", "b", "c", "d" );;| !gapprompt@gap>| !gapinput@a := F4.1;; b := F4.2;; c := F4.3;; d := F4.4;;| !gapprompt@gap>| !gapinput@G4 := F4 / [ b^4, b^2 / Comm(Comm (b, a), a), d^16,| !gapprompt@>| !gapinput@ a^16 / (c * d), b^8 / (d * c^4) ];| !gapprompt@gap>| !gapinput@SetInfoLevel(InfoANUPQ, 1); #Only essential Info please| !gapprompt@gap>| !gapinput@procId := PqStart(G4);; #Start a new interactive process for a new group| !gapprompt@gap>| !gapinput@K := Pq( procId : Prime := 2, ClassBound := 1 );| !gapprompt@gap>| !gapinput@StandardPresentation( procId : pQuotient := K, ClassBound := 14 );| \end{Verbatim} \emph{Notes} In contrast to the function \texttt{Pq} (see{\nobreakspace}\texttt{Pq} (\ref{Pq})) which returns a pc group, \texttt{PqStandardPresentation} or \texttt{StandardPresentation} returns an fp group. This is because the output is mainly used for isomorphism testing for which an fp group is enough. However, the presentation is a polycyclic presentation and if you need to do any further computation with this group (e.g.{\nobreakspace}to find the order) you can use the function \texttt{PcGroupFpGroup} (see{\nobreakspace}\texttt{PcGroupFpGroup} (\textbf{Reference: PcGroupFpGroup}) in the \textsf{GAP} Reference Manual) to form a pc group. If the user does not supply a \mbox{\texttt{\mdseries\slshape p}}\texttt{\symbol{45}}quotient \mbox{\texttt{\mdseries\slshape Q}} via the \texttt{pQuotient} option, and the prime \mbox{\texttt{\mdseries\slshape p}} is either supplied, stored, or \mbox{\texttt{\mdseries\slshape F}} is a pc \mbox{\texttt{\mdseries\slshape p}}\texttt{\symbol{45}}group, then a \mbox{\texttt{\mdseries\slshape p}}\texttt{\symbol{45}}quotient \mbox{\texttt{\mdseries\slshape Q}} is computed. (The value of the prime \mbox{\texttt{\mdseries\slshape p}} is stored if passed initially to \texttt{PqStart} or to a subsequent interactive process.) Note that a stored value for \texttt{pQuotient} (from a prior call to \texttt{Pq}) does \emph{not} have precedence over a value for the prime \mbox{\texttt{\mdseries\slshape p}}. If the user does supply a \mbox{\texttt{\mdseries\slshape p}}\texttt{\symbol{45}}quotient \mbox{\texttt{\mdseries\slshape Q}} via the \texttt{pQuotient} option, the package \textsf{AutPGrp} is called to compute the automorphism group of \mbox{\texttt{\mdseries\slshape Q}}; an error will occur that asks the user to install the package \textsf{AutPGrp} if the automorphism group cannot be computed. If any of the interactive functions \texttt{PqStandardPresentation}, \texttt{StandardPresentation}, \texttt{EpimorphismPqStandardPresentation} or \texttt{EpimorphismStandardPresentation} has been called previously for an interactive process, a subsequent call to any of these functions for the same process returns the previously computed value. Note that all these functions compute both an epimorphism and an fp group and store the results in the \texttt{SPepi} and \texttt{SP} fields of the data record associated with the process. See the example for the interactive \texttt{EpimorphismStandardPresentation} (\texttt{EpimorphismStandardPresentation} (\ref{EpimorphismStandardPresentation:interactive})). The attributes and property \texttt{NuclearRank}, \texttt{MultiplicatorRank} and \texttt{IsCapable} are set for the group returned by \texttt{PqStandardPresentation} or \texttt{StandardPresentation} (see Section{\nobreakspace}\hyperref[Attributes and a Property for fp and pc p-groups]{`Attributes and a Property for fp and pc p\texttt{\symbol{45}}groups'}). } \subsection{\textcolor{Chapter }{EpimorphismPqStandardPresentation (interactive)}} \logpage{[ 5, 3, 5 ]}\nobreak \hyperdef{L}{X791392977B2D692D}{} {\noindent\textcolor{FuncColor}{$\triangleright$\enspace\texttt{EpimorphismPqStandardPresentation({\mdseries\slshape [i]: options})\index{EpimorphismPqStandardPresentation@\texttt{EpimorphismPqStandardPresentation}!interactive} \label{EpimorphismPqStandardPresentation:interactive} }\hfill{\scriptsize (function)}}\\ \noindent\textcolor{FuncColor}{$\triangleright$\enspace\texttt{EpimorphismStandardPresentation({\mdseries\slshape [i]: options})\index{EpimorphismStandardPresentation@\texttt{EpimorphismStandardPresentation}!interactive} \label{EpimorphismStandardPresentation:interactive} }\hfill{\scriptsize (method)}}\\ Each of the above functions accepts the same arguments and options as the interactive form of \texttt{StandardPresentation} (see{\nobreakspace}\texttt{StandardPresentation} (\ref{StandardPresentation:interactive})) and returns an epimorphism from the fp or pc group \mbox{\texttt{\mdseries\slshape F}} of the \mbox{\texttt{\mdseries\slshape i}}th or default interactive \textsf{ANUPQ} process onto the finitely presented group given by a standard presentation, i.e.{\nobreakspace}if \mbox{\texttt{\mdseries\slshape S}} is the standard presentation computed for the $p$\texttt{\symbol{45}}quotient of \mbox{\texttt{\mdseries\slshape F}} by \texttt{StandardPresentation} then \texttt{EpimorphismStandardPresentation} returns the epimorphism from \mbox{\texttt{\mdseries\slshape F}} to the group with presentation \mbox{\texttt{\mdseries\slshape S}}. The group \mbox{\texttt{\mdseries\slshape F}} must have been given (as first argument) to \texttt{PqStart} to start the interactive \textsf{ANUPQ} process (see{\nobreakspace}\texttt{PqStart} (\ref{PqStart})). Taking our earlier non\texttt{\symbol{45}}interactive example (see{\nobreakspace}\texttt{EpimorphismPqStandardPresentation} (\ref{EpimorphismPqStandardPresentation})) and modifying it a little, we illustrate, as for the interactive \texttt{StandardPresentation} (see{\nobreakspace}\texttt{StandardPresentation} (\ref{StandardPresentation:interactive})), how something that required two separate calls to the \texttt{pq} program can now be achieved with a dialogue with just one \texttt{pq} process. Also, observe that calls to one of the standard presentation functions (as mentioned in the notes of{\nobreakspace}\texttt{StandardPresentation} (\ref{StandardPresentation:interactive})) computes and stores both an fp group with a standard presentation and an epimorphism; subsequent calls to a standard presentation function for the same process simply return the appropriate stored value. \begin{Verbatim}[commandchars=!@|,fontsize=\small,frame=single,label=Example] !gapprompt@gap>| !gapinput@F := FreeGroup(6, "F");;| !gapprompt@gap>| !gapinput@x := F.1;; y := F.2;; z := F.3;; w := F.4;; a := F.5;; b := F.6;;| !gapprompt@gap>| !gapinput@R := [x^3 / w, y^3 / w * a^2 * b^2, w^3 / b,| !gapprompt@>| !gapinput@ Comm (y, x) / z, Comm (z, x), Comm (z, y) / a, z^3 ];| [ F1^3*F4^-1, F2^3*F4^-1*F5^2*F6^2, F4^3*F6^-1, F2^-1*F1^-1*F2*F1*F3^-1, F3^-1*F1^-1*F3*F1, F3^-1*F2^-1*F3*F2*F5^-1, F3^3 ] !gapprompt@gap>| !gapinput@Q := F / R;| !gapprompt@gap>| !gapinput@procId := PqStart( Q );;| !gapprompt@gap>| !gapinput@G := Pq( procId : Prime := 3, ClassBound := 3 );| !gapprompt@gap>| !gapinput@lev := InfoLevel(InfoANUPQ);; # Save current InfoANUPQ level| !gapprompt@gap>| !gapinput@SetInfoLevel(InfoANUPQ, 2); # To see computation times| !gapprompt@gap>| !gapinput@# It is not necessary to pass the `Prime' option to| !gapprompt@gap>| !gapinput@# `EpimorphismStandardPresentation' since it was previously| !gapprompt@gap>| !gapinput@# passed to `Pq':| !gapprompt@gap>| !gapinput@phi := EpimorphismStandardPresentation( 3 : ClassBound := 3 );| #I Class 1 3-quotient and its 3-covering group computed in 0.00 seconds #I Order of GL subgroup is 48 #I No. of soluble autos is 0 #I dim U = 1 dim N = 3 dim M = 3 #I nice stabilizer with perm rep #I Computing standard presentation for class 2 took 0.00 seconds #I Computing standard presentation for class 3 took 0.01 seconds [ F1, F2, F3, F4, F5, F6 ] -> [ f1*f2^2*f3*f4^2*f5^2, f1*f2*f3*f5, f3^2, f4*f6^2, f5, f6 ] !gapprompt@gap>| !gapinput@# Image of phi should be isomorphic to G ...| !gapprompt@gap>| !gapinput@# let's check the order is correct:| !gapprompt@gap>| !gapinput@Size( Image(phi) );| 729 !gapprompt@gap>| !gapinput@# `StandardPresentation' and `EpimorphismStandardPresentation'| !gapprompt@gap>| !gapinput@# behave like attributes, so no computation is done when| !gapprompt@gap>| !gapinput@# either is called again for the same process ...| !gapprompt@gap>| !gapinput@StandardPresentation( 3 : ClassBound := 3 );| !gapprompt@gap>| !gapinput@# No timing data was Info-ed since no computation was done| !gapprompt@gap>| !gapinput@SetInfoLevel(InfoANUPQ, lev); # Restore previous InfoANUPQ level| \end{Verbatim} A very similar (essential details are the same) example to the above may be executed live, by typing: \texttt{PqExample( "EpimorphismStandardPresentation\texttt{\symbol{45}}i" );}. \emph{Note:} The notes for \texttt{PqStandardPresentation} or \texttt{StandardPresentation} (see{\nobreakspace}\texttt{PqStandardPresentation} (\ref{PqStandardPresentation:interactive})) apply also to \texttt{EpimorphismPqStandardPresentation} or \texttt{EpimorphismStandardPresentation} except that their return value is an \emph{epimorphism onto} an fp group, i.e.{\nobreakspace}one should interpret the phrase ``returns an fp group'' as ``returns an epimorphism onto an fp group'' etc. } \subsection{\textcolor{Chapter }{PqDescendants (interactive)}} \logpage{[ 5, 3, 6 ]}\nobreak \hyperdef{L}{X795817217C53AB89}{} {\noindent\textcolor{FuncColor}{$\triangleright$\enspace\texttt{PqDescendants({\mdseries\slshape i: options})\index{PqDescendants@\texttt{PqDescendants}!interactive} \label{PqDescendants:interactive} }\hfill{\scriptsize (function)}}\\ \noindent\textcolor{FuncColor}{$\triangleright$\enspace\texttt{PqDescendants({\mdseries\slshape : options})\index{PqDescendants@\texttt{PqDescendants}!interactive, for default process} \label{PqDescendants:interactive, for default process} }\hfill{\scriptsize (function)}}\\ return for the pc group \mbox{\texttt{\mdseries\slshape G}} of the \mbox{\texttt{\mdseries\slshape i}}th or default interactive \textsf{ANUPQ} process, which must be of prime power order with a confluent pc presentation (see{\nobreakspace}\texttt{IsConfluent} (\textbf{Reference: IsConfluent for pc groups}) in the \textsf{GAP} Reference Manual), a list of proper descendants (pc groups) of \mbox{\texttt{\mdseries\slshape G}}. The group \mbox{\texttt{\mdseries\slshape G}} is usually given as first argument to \texttt{PqStart} when starting the interactive \textsf{ANUPQ} process (see{\nobreakspace}\texttt{PqStart} (\ref{PqStart})). Alternatively, one may initiate the process with an fp group, use \texttt{Pq} interactively (see{\nobreakspace}\texttt{Pq} (\ref{Pq:interactive})) to create a pc group and use \texttt{PqSetPQuotientToGroup} (see{\nobreakspace}\texttt{PqSetPQuotientToGroup} (\ref{PqSetPQuotientToGroup})), which involves \emph{no} computation, to set the pc group returned by \texttt{Pq} as the group of the process. Note that repeating a call to \texttt{PqDescendants} for the same interactive \textsf{ANUPQ} process simply returns the list of descendants originally calculated; a warning is emitted at \texttt{InfoANUPQ} level 1 reminding you of this should you do this. After the colon, \mbox{\texttt{\mdseries\slshape options}} a selection of the options listed for the non\texttt{\symbol{45}}interactive \texttt{PqDescendants} function (see{\nobreakspace}\texttt{PqDescendants} (\ref{PqDescendants})), should be given, separated by commas like record components (see Section{\nobreakspace} \textbf{Reference: Function Call With Options} in the \textsf{GAP} Reference Manual), except that the options \texttt{SetupFile} or \texttt{PqWorkspace} are ignored by the interactive \texttt{PqDescendants}, i.e.{\nobreakspace}the following options are recognised by the interactive \texttt{PqDescendants} function: \begin{itemize} \item \texttt{ClassBound := \mbox{\texttt{\mdseries\slshape n}}}\index{option ClassBound} \item \texttt{Relators := \mbox{\texttt{\mdseries\slshape rels}}}\index{option Relators} \item \texttt{OrderBound := \mbox{\texttt{\mdseries\slshape n}}}\index{option OrderBound} \item \texttt{StepSize := \mbox{\texttt{\mdseries\slshape n}}}, \texttt{StepSize := \mbox{\texttt{\mdseries\slshape list}}} \index{option StepSize} \item \texttt{RankInitialSegmentSubgroups := \mbox{\texttt{\mdseries\slshape n}}}\index{option RankInitialSegmentSubgroups} \item \texttt{SpaceEfficient}\index{option SpaceEfficient} \item \texttt{CapableDescendants}\index{option CapableDescendants} \item \texttt{AllDescendants := false}\index{option AllDescendants} \item \texttt{Exponent := \mbox{\texttt{\mdseries\slshape n}}}\index{option Exponent} \item \texttt{Metabelian}\index{option Metabelian} \item \texttt{GroupName := \mbox{\texttt{\mdseries\slshape name}}}\index{option GroupName} \item \texttt{SubList := \mbox{\texttt{\mdseries\slshape sub}}}\index{option SubList} \item \texttt{BasicAlgorithm}\index{option BasicAlgorithm} \item \texttt{CustomiseOutput := \mbox{\texttt{\mdseries\slshape rec}}}\index{option CustomiseOutput} \end{itemize} \emph{Notes:} The function \texttt{PqDescendants} uses the automorphism group of \mbox{\texttt{\mdseries\slshape G}} which it computes via the package \textsf{AutPGrp} if the automorphism group of \mbox{\texttt{\mdseries\slshape G}} is not already present. If \textsf{AutPGrp} is not installed an error may be raised. If the automorphism group of \mbox{\texttt{\mdseries\slshape G}} is insoluble the \texttt{pq} program will call \textsf{GAP} together with the \textsf{AutPGrp} package for certain orbit\texttt{\symbol{45}}stabilizer calculations. The attributes and property \texttt{NuclearRank}, \texttt{MultiplicatorRank} and \texttt{IsCapable} are set for each group of the list returned by \texttt{PqDescendants} (see Section{\nobreakspace}\hyperref[Attributes and a Property for fp and pc p-groups]{`Attributes and a Property for fp and pc p\texttt{\symbol{45}}groups'}). Let us now repeat the examples previously given for the non\texttt{\symbol{45}}interactive \texttt{PqDescendants}, but this time with the interactive version of \texttt{PqDescendants}: \begin{Verbatim}[commandchars=!@|,fontsize=\small,frame=single,label=Example] !gapprompt@gap>| !gapinput@F := FreeGroup( "a", "b" );; a := F.1;; b := F.2;;| !gapprompt@gap>| !gapinput@G := PcGroupFpGroup( F / [ a^2, b^2, Comm(b, a) ] );| !gapprompt@gap>| !gapinput@procId := PqStart(G);;| !gapprompt@gap>| !gapinput@des := PqDescendants( procId : OrderBound := 6, ClassBound := 5 );;| !gapprompt@gap>| !gapinput@Length(des);| 83 !gapprompt@gap>| !gapinput@List(des, Size);| [ 8, 8, 8, 16, 16, 16, 32, 16, 16, 16, 16, 16, 32, 32, 64, 64, 32, 32, 32, 32, 32, 32, 32, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 32, 32, 32, 32, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 32, 32, 32, 32, 32, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64 ] !gapprompt@gap>| !gapinput@List(des, d -> Length( PCentralSeries( d, 2 ) ) - 1 );| [ 2, 2, 2, 2, 2, 2, 2, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 5, 5, 5, 5, 5 ] \end{Verbatim} In the second example we compute all capable descendants of order 27 of the elementary abelian group of order 9. \begin{Verbatim}[commandchars=!@|,fontsize=\small,frame=single,label=Example] !gapprompt@gap>| !gapinput@F := FreeGroup( 2, "g" );;| !gapprompt@gap>| !gapinput@G := PcGroupFpGroup( F / [ F.1^3, F.2^3, Comm(F.1, F.2) ] );| !gapprompt@gap>| !gapinput@procId := PqStart(G);;| !gapprompt@gap>| !gapinput@des := PqDescendants( procId : OrderBound := 3, ClassBound := 2,| !gapprompt@>| !gapinput@ CapableDescendants );| [ , ] !gapprompt@gap>| !gapinput@List(des, d -> Length( PCentralSeries( d, 3 ) ) - 1 );| [ 2, 2 ] !gapprompt@gap>| !gapinput@# For comparison let us now compute all proper descendants| !gapprompt@gap>| !gapinput@# (using the non-interactive Pq function)| !gapprompt@gap>| !gapinput@PqDescendants( G : OrderBound := 3, ClassBound := 2);| [ , , ] \end{Verbatim} In the third example, we compute all proper capable descendants of the elementary abelian group of order $5^2$ which have exponent\texttt{\symbol{45}}$5$ class at most $3$, exponent $5$, and are metabelian. \begin{Verbatim}[commandchars=!@|,fontsize=\small,frame=single,label=Example] !gapprompt@gap>| !gapinput@F := FreeGroup( 2, "g" );;| !gapprompt@gap>| !gapinput@G := PcGroupFpGroup( F / [ F.1^5, F.2^5, Comm(F.2, F.1) ] );| !gapprompt@gap>| !gapinput@procId := PqStart(G);;| !gapprompt@gap>| !gapinput@des := PqDescendants( procId : Metabelian, ClassBound := 3,| !gapprompt@>| !gapinput@ Exponent := 5, CapableDescendants );| [ , , ] !gapprompt@gap>| !gapinput@List(des, d -> Length( PCentralSeries( d, 5 ) ) - 1 );| [ 2, 3, 3 ] !gapprompt@gap>| !gapinput@List(des, d -> Length( DerivedSeries( d ) ) );| [ 3, 3, 3 ] !gapprompt@gap>| !gapinput@List(des, d -> Maximum( List( d, Order ) ) );| [ 5, 5, 5 ] \end{Verbatim} } \subsection{\textcolor{Chapter }{PqSetPQuotientToGroup}} \logpage{[ 5, 3, 7 ]}\nobreak \hyperdef{L}{X80CCF6D379E5A3B4}{} {\noindent\textcolor{FuncColor}{$\triangleright$\enspace\texttt{PqSetPQuotientToGroup({\mdseries\slshape i})\index{PqSetPQuotientToGroup@\texttt{PqSetPQuotientToGroup}} \label{PqSetPQuotientToGroup} }\hfill{\scriptsize (function)}}\\ \noindent\textcolor{FuncColor}{$\triangleright$\enspace\texttt{PqSetPQuotientToGroup({\mdseries\slshape })\index{PqSetPQuotientToGroup@\texttt{PqSetPQuotientToGroup}!for default process} \label{PqSetPQuotientToGroup:for default process} }\hfill{\scriptsize (function)}}\\ for the \mbox{\texttt{\mdseries\slshape i}}th or default interactive \textsf{ANUPQ} process, set the $p$\texttt{\symbol{45}}quotient previously computed by the interactive \texttt{Pq} function (see{\nobreakspace}\texttt{Pq} (\ref{Pq:interactive})) to be the group of the process. This function is supplied to enable the computation of descendants of a $p$\texttt{\symbol{45}}quotient that is already known to the \texttt{pq} program, via the interactive \texttt{PqDescendants} function (see{\nobreakspace}\texttt{PqDescendants} (\ref{PqDescendants:interactive})), thus avoiding the need to re\texttt{\symbol{45}}submit it and have the \texttt{pq} program recompute it. \emph{Note:} See the function \texttt{PqPGSetDescendantToPcp} (\texttt{PqPGSetDescendantToPcp} (\ref{PqPGSetDescendantToPcp})) for a mechanism to make (the $p$\texttt{\symbol{45}}cover of) a particular descendants the current group of the process. The following example of the usage of \texttt{PqSetPQuotientToGroup}, which is essentially equivalent to what is obtained by running \texttt{PqExample("PqDescendants\texttt{\symbol{45}}1\texttt{\symbol{45}}i");}, redoes the first example of \texttt{PqDescendants} (\ref{PqDescendants:interactive}) (which computes the descendants of the Klein four group). \begin{Verbatim}[commandchars=!@|,fontsize=\small,frame=single,label=Example] !gapprompt@gap>| !gapinput@F := FreeGroup( "a", "b" );| !gapprompt@gap>| !gapinput@procId := PqStart( F : Prime := 2 );;| !gapprompt@gap>| !gapinput@Pq( procId : ClassBound := 1 );| !gapprompt@gap>| !gapinput@PqSetPQuotientToGroup( procId );| !gapprompt@gap>| !gapinput@des := PqDescendants( procId : OrderBound := 6, ClassBound := 5 );;| !gapprompt@gap>| !gapinput@Length(des);| 83 !gapprompt@gap>| !gapinput@List(des, Size);| [ 8, 8, 8, 16, 16, 16, 32, 16, 16, 16, 16, 16, 32, 32, 64, 64, 32, 32, 32, 32, 32, 32, 32, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 32, 32, 32, 32, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 32, 32, 32, 32, 32, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64 ] !gapprompt@gap>| !gapinput@List(des, d -> Length( PCentralSeries( d, 2 ) ) - 1 );| [ 2, 2, 2, 2, 2, 2, 2, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 5, 5, 5, 5, 5 ] \end{Verbatim} } } \section{\textcolor{Chapter }{Low\texttt{\symbol{45}}level Interactive ANUPQ functions based on menu items of the pq program}}\label{Low-level Interactive ANUPQ functions based on menu items of the pq program} \logpage{[ 5, 4, 0 ]} \hyperdef{L}{X857F050C832A1FE4}{} { The \texttt{pq} program has 5 menus, the details of which the reader will not normally need to know, but if she wishes to know the details they may be found in the standalone manual: \texttt{guide.dvi}. Both \texttt{guide.dvi} and the \texttt{pq} program refer to the items of these 5 menus as ``options'', which do \emph{not} correspond in any way to the options used by any of the \textsf{GAP} functions that interface with the \texttt{pq} program. \emph{Warning:} The commands provided in this section are intended to provide something like the interactive functionality one has when running the standalone, from within \textsf{GAP}. The \texttt{pq} standalone (in particular, its ``advanced'' menus) assumes some expertise of the user; doing the ``wrong'' thing can cause the program to crash. While a number of safeguards have been provided in the \textsf{GAP} interface to the \texttt{pq} program, these are \emph{not} foolproof, and the user should exercise care and ensure pre\texttt{\symbol{45}}requisites of the various commands are met. } \section{\textcolor{Chapter }{General commands}}\logpage{[ 5, 5, 0 ]} \hyperdef{L}{X868B10557D470CF6}{} { The following commands either use a menu item from whatever menu is ``current'' for the \texttt{pq} program, or have general application and are not associated with just one menu item of the \texttt{pq} program. \subsection{\textcolor{Chapter }{PqNrPcGenerators}} \logpage{[ 5, 5, 1 ]}\nobreak \hyperdef{L}{X7DE2F6C686C672DD}{} {\noindent\textcolor{FuncColor}{$\triangleright$\enspace\texttt{PqNrPcGenerators({\mdseries\slshape i})\index{PqNrPcGenerators@\texttt{PqNrPcGenerators}} \label{PqNrPcGenerators} }\hfill{\scriptsize (function)}}\\ \noindent\textcolor{FuncColor}{$\triangleright$\enspace\texttt{PqNrPcGenerators({\mdseries\slshape })\index{PqNrPcGenerators@\texttt{PqNrPcGenerators}!for default process} \label{PqNrPcGenerators:for default process} }\hfill{\scriptsize (function)}}\\ for the \mbox{\texttt{\mdseries\slshape i}}th or default interactive \textsf{ANUPQ} process, return the number of pc generators of the lower exponent $p$\texttt{\symbol{45}}class quotient of the group currently determined by the process. This also applies if the pc presentation is not consistent. } \subsection{\textcolor{Chapter }{PqFactoredOrder}} \logpage{[ 5, 5, 2 ]}\nobreak \hyperdef{L}{X87FF98867E8FFB3C}{} {\noindent\textcolor{FuncColor}{$\triangleright$\enspace\texttt{PqFactoredOrder({\mdseries\slshape i})\index{PqFactoredOrder@\texttt{PqFactoredOrder}} \label{PqFactoredOrder} }\hfill{\scriptsize (function)}}\\ \noindent\textcolor{FuncColor}{$\triangleright$\enspace\texttt{PqFactoredOrder({\mdseries\slshape })\index{PqFactoredOrder@\texttt{PqFactoredOrder}!for default process} \label{PqFactoredOrder:for default process} }\hfill{\scriptsize (function)}}\\ for the \mbox{\texttt{\mdseries\slshape i}}th or default interactive \textsf{ANUPQ} process, return an integer pair \texttt{[\mbox{\texttt{\mdseries\slshape p}}, \mbox{\texttt{\mdseries\slshape n}}]} where \mbox{\texttt{\mdseries\slshape p}} is a prime and \mbox{\texttt{\mdseries\slshape n}} is the number of pc generators (see{\nobreakspace}\texttt{PqNrPcGenerators} (\ref{PqNrPcGenerators})) in the pc presentation of the quotient group currently determined by the process. If this presentation is consistent, then $p^n$ is the order of the quotient group. Otherwise (if tails have been added but the necessary consistency checks, relation collections, exponent law checks and redundant generator eliminations have not yet been done), $p^n$ is an upper bound for the order of the group. } \subsection{\textcolor{Chapter }{PqOrder}} \logpage{[ 5, 5, 3 ]}\nobreak \hyperdef{L}{X7B4FC9E380001A71}{} {\noindent\textcolor{FuncColor}{$\triangleright$\enspace\texttt{PqOrder({\mdseries\slshape i})\index{PqOrder@\texttt{PqOrder}} \label{PqOrder} }\hfill{\scriptsize (function)}}\\ \noindent\textcolor{FuncColor}{$\triangleright$\enspace\texttt{PqOrder({\mdseries\slshape })\index{PqOrder@\texttt{PqOrder}!for default process} \label{PqOrder:for default process} }\hfill{\scriptsize (function)}}\\ for the \mbox{\texttt{\mdseries\slshape i}}th or default interactive \textsf{ANUPQ} process, return $p^n$ where \texttt{[\mbox{\texttt{\mdseries\slshape p}}, \mbox{\texttt{\mdseries\slshape n}}]} is the pair as returned by \texttt{PqFactoredOrder} (see{\nobreakspace}\texttt{PqFactoredOrder} (\ref{PqFactoredOrder})). } \subsection{\textcolor{Chapter }{PqPClass}} \logpage{[ 5, 5, 4 ]}\nobreak \hyperdef{L}{X87C7F7EB7C10DC4B}{} {\noindent\textcolor{FuncColor}{$\triangleright$\enspace\texttt{PqPClass({\mdseries\slshape i})\index{PqPClass@\texttt{PqPClass}} \label{PqPClass} }\hfill{\scriptsize (function)}}\\ \noindent\textcolor{FuncColor}{$\triangleright$\enspace\texttt{PqPClass({\mdseries\slshape })\index{PqPClass@\texttt{PqPClass}!for default process} \label{PqPClass:for default process} }\hfill{\scriptsize (function)}}\\ for the \mbox{\texttt{\mdseries\slshape i}}th or default interactive \textsf{ANUPQ} process, return the lower exponent $p$\texttt{\symbol{45}}class of the quotient group currently determined by the process. } \subsection{\textcolor{Chapter }{PqWeight}} \logpage{[ 5, 5, 5 ]}\nobreak \hyperdef{L}{X7EA3B6917908C20A}{} {\noindent\textcolor{FuncColor}{$\triangleright$\enspace\texttt{PqWeight({\mdseries\slshape i, j})\index{PqWeight@\texttt{PqWeight}} \label{PqWeight} }\hfill{\scriptsize (function)}}\\ \noindent\textcolor{FuncColor}{$\triangleright$\enspace\texttt{PqWeight({\mdseries\slshape j})\index{PqWeight@\texttt{PqWeight}!for default process} \label{PqWeight:for default process} }\hfill{\scriptsize (function)}}\\ for the \mbox{\texttt{\mdseries\slshape i}}th or default interactive \textsf{ANUPQ} process, return the weight of the \mbox{\texttt{\mdseries\slshape j}}th pc generator of the lower exponent $p$\texttt{\symbol{45}}class quotient of the group currently determined by the process, or \texttt{fail} if there is no such numbered pc generator. } \subsection{\textcolor{Chapter }{PqCurrentGroup}} \logpage{[ 5, 5, 6 ]}\nobreak \hyperdef{L}{X79862B83817E20E1}{} {\noindent\textcolor{FuncColor}{$\triangleright$\enspace\texttt{PqCurrentGroup({\mdseries\slshape i})\index{PqCurrentGroup@\texttt{PqCurrentGroup}} \label{PqCurrentGroup} }\hfill{\scriptsize (function)}}\\ \noindent\textcolor{FuncColor}{$\triangleright$\enspace\texttt{PqCurrentGroup({\mdseries\slshape })\index{PqCurrentGroup@\texttt{PqCurrentGroup}!for default process} \label{PqCurrentGroup:for default process} }\hfill{\scriptsize (function)}}\\ for the \mbox{\texttt{\mdseries\slshape i}}th or default interactive \textsf{ANUPQ} process, return the group whose pc presentation is determined by the process as a \textsf{GAP} pc group (either a lower exponent $p$\texttt{\symbol{45}}class quotient of the start group or the $p$\texttt{\symbol{45}}cover of such a quotient). \emph{Notes:} See Section{\nobreakspace}\hyperref[Attributes and a Property for fp and pc p-groups]{`Attributes and a Property for fp and pc p\texttt{\symbol{45}}groups'} for the attributes and property \texttt{NuclearRank}, \texttt{MultiplicatorRank} and \texttt{IsCapable} which may be applied to the group returned by \texttt{PqCurrentGroup}. } \subsection{\textcolor{Chapter }{PqDisplayPcPresentation}} \logpage{[ 5, 5, 7 ]}\nobreak \hyperdef{L}{X805A50687D82B9EC}{} {\noindent\textcolor{FuncColor}{$\triangleright$\enspace\texttt{PqDisplayPcPresentation({\mdseries\slshape i: [OutputLevel := lev]})\index{PqDisplayPcPresentation@\texttt{PqDisplayPcPresentation}} \label{PqDisplayPcPresentation} }\hfill{\scriptsize (function)}}\\ \noindent\textcolor{FuncColor}{$\triangleright$\enspace\texttt{PqDisplayPcPresentation({\mdseries\slshape : [OutputLevel := lev]})\index{PqDisplayPcPresentation@\texttt{PqDisplayPcPresentation}!for default process} \label{PqDisplayPcPresentation:for default process} }\hfill{\scriptsize (function)}}\\ for the \mbox{\texttt{\mdseries\slshape i}}th or default interactive \textsf{ANUPQ} process, direct the \texttt{pq} program to display the pc presentation of the lower exponent $p$\texttt{\symbol{45}}class quotient of the group currently determined by the process. Except if the last command communicating with the \texttt{pq} program was a $p$\texttt{\symbol{45}}group generation command (for which there is only a verbose output level), to set the amount of information this command displays you may wish to call \texttt{PqSetOutputLevel} first (see{\nobreakspace}\texttt{PqSetOutputLevel} (\ref{PqSetOutputLevel})), or equivalently pass the option \texttt{OutputLevel} (see{\nobreakspace}\ref{option OutputLevel}). \emph{Note:} For those familiar with the \texttt{pq} program, \texttt{PqDisplayPcPresentation} performs menu item 4 of the current menu of the \texttt{pq} program. } \subsection{\textcolor{Chapter }{PqSetOutputLevel}} \logpage{[ 5, 5, 8 ]}\nobreak \hyperdef{L}{X80410979854280E1}{} {\noindent\textcolor{FuncColor}{$\triangleright$\enspace\texttt{PqSetOutputLevel({\mdseries\slshape i, lev})\index{PqSetOutputLevel@\texttt{PqSetOutputLevel}} \label{PqSetOutputLevel} }\hfill{\scriptsize (function)}}\\ \noindent\textcolor{FuncColor}{$\triangleright$\enspace\texttt{PqSetOutputLevel({\mdseries\slshape lev})\index{PqSetOutputLevel@\texttt{PqSetOutputLevel}!for default process} \label{PqSetOutputLevel:for default process} }\hfill{\scriptsize (function)}}\\ for the \mbox{\texttt{\mdseries\slshape i}}th or default interactive \textsf{ANUPQ} process, direct the \texttt{pq} program to set the output level of the \texttt{pq} program to \mbox{\texttt{\mdseries\slshape lev}}. \emph{Note:} For those familiar with the \texttt{pq} program, \texttt{PqSetOutputLevel} performs menu item 5 of the main (or advanced) $p$\texttt{\symbol{45}}Quotient menu, or the Standard Presentation menu. } \subsection{\textcolor{Chapter }{PqEvaluateIdentities}} \logpage{[ 5, 5, 9 ]}\nobreak \hyperdef{L}{X7B8C72B37AE667F7}{} {\noindent\textcolor{FuncColor}{$\triangleright$\enspace\texttt{PqEvaluateIdentities({\mdseries\slshape i: [Identities := funcs]})\index{PqEvaluateIdentities@\texttt{PqEvaluateIdentities}} \label{PqEvaluateIdentities} }\hfill{\scriptsize (function)}}\\ \noindent\textcolor{FuncColor}{$\triangleright$\enspace\texttt{PqEvaluateIdentities({\mdseries\slshape : [Identities := funcs]})\index{PqEvaluateIdentities@\texttt{PqEvaluateIdentities}!for default process} \label{PqEvaluateIdentities:for default process} }\hfill{\scriptsize (function)}}\\ for the \mbox{\texttt{\mdseries\slshape i}}th or default interactive \textsf{ANUPQ} process, invoke the evaluation of identities defined by the \texttt{Identities} option, and eliminate any redundant pc generators formed. Since a previous value of \texttt{Identities} is saved in the data record of the process, it is unnecessary to pass the \texttt{Identities} if set previously. \emph{Note:} This function is mainly implemented at the \textsf{GAP} level. It does not correspond to a menu item of the \texttt{pq} program. } } \section{\textcolor{Chapter }{Commands from the Main $p$\texttt{\symbol{45}}Quotient menu}}\logpage{[ 5, 6, 0 ]} \hyperdef{L}{X7BDD5B278719C630}{} { \subsection{\textcolor{Chapter }{PqPcPresentation}} \logpage{[ 5, 6, 1 ]}\nobreak \hyperdef{L}{X7BF135DD84A781EB}{} {\noindent\textcolor{FuncColor}{$\triangleright$\enspace\texttt{PqPcPresentation({\mdseries\slshape i: options})\index{PqPcPresentation@\texttt{PqPcPresentation}} \label{PqPcPresentation} }\hfill{\scriptsize (function)}}\\ \noindent\textcolor{FuncColor}{$\triangleright$\enspace\texttt{PqPcPresentation({\mdseries\slshape : options})\index{PqPcPresentation@\texttt{PqPcPresentation}!for default process} \label{PqPcPresentation:for default process} }\hfill{\scriptsize (function)}}\\ for the \mbox{\texttt{\mdseries\slshape i}}th or default interactive \textsf{ANUPQ} process, direct the \texttt{pq} program to compute the pc presentation of the quotient (determined by \mbox{\texttt{\mdseries\slshape options}}) of the group of the process, which for process \mbox{\texttt{\mdseries\slshape i}} is stored as \texttt{ANUPQData.io[\mbox{\texttt{\mdseries\slshape i}}].group}. The possible \mbox{\texttt{\mdseries\slshape options}} are the same as for the interactive \texttt{Pq} (see{\nobreakspace}\texttt{Pq} (\ref{Pq:interactive})) function, except for \texttt{RedoPcp} (which, in any case, would be superfluous), namely: \texttt{Prime}, \texttt{ClassBound}, \texttt{Exponent}, \texttt{Relators}, \texttt{GroupName}, \texttt{Metabelian}, \texttt{Identities} and \texttt{OutputLevel} (see Chapter{\nobreakspace}\hyperref[ANUPQ Options]{`ANUPQ Options'} for a detailed description for these options). The option \texttt{Prime} is required unless already provided to \texttt{PqStart}. \emph{Notes} The pc presentation is held by the \texttt{pq} program. In contrast to \texttt{Pq} (see{\nobreakspace}\texttt{Pq} (\ref{Pq:interactive})), no \textsf{GAP} pc group is returned; see{\nobreakspace}\texttt{PqCurrentGroup} (\texttt{PqCurrentGroup} (\ref{PqCurrentGroup})) if you need the corresponding \textsf{GAP} pc group. \texttt{PqPcPresentation(\mbox{\texttt{\mdseries\slshape i}}: \mbox{\texttt{\mdseries\slshape options}});} is roughly equivalent to the following sequence of low\texttt{\symbol{45}}level commands: \begin{Verbatim}[commandchars=!@|,fontsize=\small,frame=single,label=] PqPcPresentation(i: opts); #class 1 call for c in [2 .. class] do PqNextClass(i); od; \end{Verbatim} where \mbox{\texttt{\mdseries\slshape opts}} is \mbox{\texttt{\mdseries\slshape options}} except with the \texttt{ClassBound} option set to 1, and \mbox{\texttt{\mdseries\slshape class}} is either the maximum class of a \mbox{\texttt{\mdseries\slshape p}}\texttt{\symbol{45}}quotient of the group of the process or the user\texttt{\symbol{45}}supplied value of the option \texttt{ClassBound} (whichever is smaller). If the \texttt{Identities} option has been set, both the first \texttt{PqPcPresentation} class 1 call and the \texttt{PqNextClass} calls invoke \texttt{PqEvaluateIdentities(\mbox{\texttt{\mdseries\slshape i}});} as their final step. For those familiar with the \texttt{pq} program, \texttt{PqPcPresentation} performs menu item 1 of the main $p$\texttt{\symbol{45}}Quotient menu. } \subsection{\textcolor{Chapter }{PqSavePcPresentation}} \logpage{[ 5, 6, 2 ]}\nobreak \hyperdef{L}{X7D947CEA82C44898}{} {\noindent\textcolor{FuncColor}{$\triangleright$\enspace\texttt{PqSavePcPresentation({\mdseries\slshape i, filename})\index{PqSavePcPresentation@\texttt{PqSavePcPresentation}} \label{PqSavePcPresentation} }\hfill{\scriptsize (function)}}\\ \noindent\textcolor{FuncColor}{$\triangleright$\enspace\texttt{PqSavePcPresentation({\mdseries\slshape filename})\index{PqSavePcPresentation@\texttt{PqSavePcPresentation}!for default process} \label{PqSavePcPresentation:for default process} }\hfill{\scriptsize (function)}}\\ for the \mbox{\texttt{\mdseries\slshape i}}th or default interactive \textsf{ANUPQ} process, direct the \texttt{pq} program to save the pc presentation previously computed for the quotient of the group of that process to the file with name \mbox{\texttt{\mdseries\slshape filename}}. If the first character of the string \mbox{\texttt{\mdseries\slshape filename}} is not \texttt{/}, \mbox{\texttt{\mdseries\slshape filename}} is assumed to be the path of a writable file relative to the directory in which \textsf{GAP} was started. A saved file may be restored by \texttt{PqRestorePcPresentation} (see{\nobreakspace}\texttt{PqRestorePcPresentation} (\ref{PqRestorePcPresentation})). \emph{Note:} For those familiar with the \texttt{pq} program, \texttt{PqSavePcPresentation} performs menu item 2 of the main $p$\texttt{\symbol{45}}Quotient menu. } \subsection{\textcolor{Chapter }{PqRestorePcPresentation}} \logpage{[ 5, 6, 3 ]}\nobreak \hyperdef{L}{X7FD001C0798EF219}{} {\noindent\textcolor{FuncColor}{$\triangleright$\enspace\texttt{PqRestorePcPresentation({\mdseries\slshape i, filename})\index{PqRestorePcPresentation@\texttt{PqRestorePcPresentation}} \label{PqRestorePcPresentation} }\hfill{\scriptsize (function)}}\\ \noindent\textcolor{FuncColor}{$\triangleright$\enspace\texttt{PqRestorePcPresentation({\mdseries\slshape filename})\index{PqRestorePcPresentation@\texttt{PqRestorePcPresentation}!for default process} \label{PqRestorePcPresentation:for default process} }\hfill{\scriptsize (function)}}\\ for the \mbox{\texttt{\mdseries\slshape i}}th or default interactive \textsf{ANUPQ} process, direct the \texttt{pq} program to restore the pc presentation previously saved to \mbox{\texttt{\mdseries\slshape filename}}, by \texttt{PqSavePcPresentation} (see{\nobreakspace}\texttt{PqSavePcPresentation} (\ref{PqSavePcPresentation})). If the first character of the string \mbox{\texttt{\mdseries\slshape filename}} is not \texttt{/}, \mbox{\texttt{\mdseries\slshape filename}} is assumed to be the path of a readable file relative to the directory in which \textsf{GAP} was started. \emph{Note:} For those familiar with the \texttt{pq} program, \texttt{PqRestorePcPresentation} performs menu item 3 of the main $p$\texttt{\symbol{45}}Quotient menu. } \subsection{\textcolor{Chapter }{PqNextClass}} \logpage{[ 5, 6, 4 ]}\nobreak \hyperdef{L}{X832F69597C095A27}{} {\noindent\textcolor{FuncColor}{$\triangleright$\enspace\texttt{PqNextClass({\mdseries\slshape i: [QueueFactor]})\index{PqNextClass@\texttt{PqNextClass}} \label{PqNextClass} }\hfill{\scriptsize (function)}}\\ \noindent\textcolor{FuncColor}{$\triangleright$\enspace\texttt{PqNextClass({\mdseries\slshape : [QueueFactor]})\index{PqNextClass@\texttt{PqNextClass}!for default process} \label{PqNextClass:for default process} }\hfill{\scriptsize (function)}}\\ for the \mbox{\texttt{\mdseries\slshape i}}th or default interactive \textsf{ANUPQ} process, direct the \texttt{pq} program to calculate the next class of \texttt{ANUPQData.io[\mbox{\texttt{\mdseries\slshape i}}].group}. \index{option QueueFactor} \texttt{PqNextClass} accepts the option \texttt{QueueFactor} (see also{\nobreakspace}\ref{option QueueFactor}) which should be a positive integer if automorphisms have been previously supplied. If the \texttt{pq} program requires a queue factor and none is supplied via the option \texttt{QueueFactor} a default of 15 is taken. \emph{Notes} The single command: \texttt{PqNextClass(\mbox{\texttt{\mdseries\slshape i}});} is equivalent to executing \begin{Verbatim}[commandchars=!@|,fontsize=\small,frame=single,label=] PqComputePCover(i); PqCollectDefiningRelations(i); PqDoExponentChecks(i); PqEliminateRedundantGenerators(i); \end{Verbatim} If the \texttt{Identities} option is set the \texttt{PqEliminateRedundantGenerators(\mbox{\texttt{\mdseries\slshape i}});} step is essentially replaced by \texttt{PqEvaluateIdentities(\mbox{\texttt{\mdseries\slshape i}});} (which invokes its own elimination of redundant generators). For those familiar with the \texttt{pq} program, \texttt{PqNextClass} performs menu item 6 of the main $p$\texttt{\symbol{45}}Quotient menu. } \subsection{\textcolor{Chapter }{PqComputePCover}} \logpage{[ 5, 6, 5 ]}\nobreak \hyperdef{L}{X7CF9DF7A84D387CB}{} {\noindent\textcolor{FuncColor}{$\triangleright$\enspace\texttt{PqComputePCover({\mdseries\slshape i})\index{PqComputePCover@\texttt{PqComputePCover}} \label{PqComputePCover} }\hfill{\scriptsize (function)}}\\ \noindent\textcolor{FuncColor}{$\triangleright$\enspace\texttt{PqComputePCover({\mdseries\slshape })\index{PqComputePCover@\texttt{PqComputePCover}!for default process} \label{PqComputePCover:for default process} }\hfill{\scriptsize (function)}}\\ for the \mbox{\texttt{\mdseries\slshape i}}th or default interactive \textsf{ANUPQ} processi, directi, the \texttt{pq} program to compute the $p$\texttt{\symbol{45}}covering group of \texttt{ANUPQData.io[\mbox{\texttt{\mdseries\slshape i}}].group}. In contrast to the function \texttt{PqPCover} (see{\nobreakspace}\texttt{PqPCover} (\ref{PqPCover})), this function does not return a \textsf{GAP} pc group. \emph{Notes} The single command: \texttt{PqComputePCover(\mbox{\texttt{\mdseries\slshape i}});} is equivalent to executing \begin{Verbatim}[commandchars=!@|,fontsize=\small,frame=single,label=] PqSetupTablesForNextClass(i); PqTails(i, 0); PqDoConsistencyChecks(i, 0, 0); PqEliminateRedundantGenerators(i); \end{Verbatim} For those familiar with the \texttt{pq} program, \texttt{PqComputePCover} performs menu item 7 of the main $p$\texttt{\symbol{45}}Quotient menu. } } \section{\textcolor{Chapter }{Commands from the Advanced $p$\texttt{\symbol{45}}Quotient menu}}\logpage{[ 5, 7, 0 ]} \hyperdef{L}{X7D27BE937B1DE16E}{} { \subsection{\textcolor{Chapter }{PqCollect}} \logpage{[ 5, 7, 1 ]}\nobreak \hyperdef{L}{X8633356078CA4115}{} {\noindent\textcolor{FuncColor}{$\triangleright$\enspace\texttt{PqCollect({\mdseries\slshape i, word})\index{PqCollect@\texttt{PqCollect}} \label{PqCollect} }\hfill{\scriptsize (function)}}\\ \noindent\textcolor{FuncColor}{$\triangleright$\enspace\texttt{PqCollect({\mdseries\slshape word})\index{PqCollect@\texttt{PqCollect}!for default process} \label{PqCollect:for default process} }\hfill{\scriptsize (function)}}\\ for the \mbox{\texttt{\mdseries\slshape i}}th or default interactive \textsf{ANUPQ} process, instruct the \texttt{pq} program to do a collection on \mbox{\texttt{\mdseries\slshape word}}, a word in the current pc generators (the form of \mbox{\texttt{\mdseries\slshape word}} required is described below). \texttt{PqCollect} returns the resulting word of the collection as a list of generator number, exponent pairs (the same form as the second allowed input form of \mbox{\texttt{\mdseries\slshape word}}; see below). The argument \mbox{\texttt{\mdseries\slshape word}} may be input in either of the following ways: \begin{enumerate} \item \mbox{\texttt{\mdseries\slshape word}} may be a string, where the \mbox{\texttt{\mdseries\slshape i}}th pc generator is represented by \texttt{x\mbox{\texttt{\mdseries\slshape i}}}, e.g.{\nobreakspace}\texttt{"x3*x2\texttt{\symbol{94}}2*x1"}. This way is quite versatile as parentheses and left\texttt{\symbol{45}}normed commutators \texttt{\symbol{45}}\texttt{\symbol{45}} using square brackets, in the same way as \texttt{PqGAPRelators} (see{\nobreakspace}\texttt{PqGAPRelators} (\ref{PqGAPRelators})) \texttt{\symbol{45}}\texttt{\symbol{45}} are permitted; \mbox{\texttt{\mdseries\slshape word}} is checked for correct syntax via \texttt{PqParseWord} (see{\nobreakspace}\texttt{PqParseWord} (\ref{PqParseWord})). \item Otherwise, \mbox{\texttt{\mdseries\slshape word}} must be a list of generator number, exponent pairs of integers, i.e.{\nobreakspace} each pair represents a ``syllable'' so that \texttt{[ [3, 1], [2, 2], [1, 1] ]} represents the same word as that of the example given for the first allowed form of \mbox{\texttt{\mdseries\slshape word}}. \end{enumerate} \emph{Note:} For those familiar with the \texttt{pq} program, \texttt{PqCollect} performs menu item 1 of the Advanced $p$\texttt{\symbol{45}}Quotient menu. } \subsection{\textcolor{Chapter }{PqSolveEquation}} \logpage{[ 5, 7, 2 ]}\nobreak \hyperdef{L}{X86CCB77281FDC0FC}{} {\noindent\textcolor{FuncColor}{$\triangleright$\enspace\texttt{PqSolveEquation({\mdseries\slshape i, a, b})\index{PqSolveEquation@\texttt{PqSolveEquation}} \label{PqSolveEquation} }\hfill{\scriptsize (function)}}\\ \noindent\textcolor{FuncColor}{$\triangleright$\enspace\texttt{PqSolveEquation({\mdseries\slshape a, b})\index{PqSolveEquation@\texttt{PqSolveEquation}!for default process} \label{PqSolveEquation:for default process} }\hfill{\scriptsize (function)}}\\ for the \mbox{\texttt{\mdseries\slshape i}}th or default interactive \textsf{ANUPQ} process, direct the \texttt{pq} program to solve $\mbox{\texttt{\mdseries\slshape a}} * \mbox{\texttt{\mdseries\slshape x}} = \mbox{\texttt{\mdseries\slshape b}}$ for \mbox{\texttt{\mdseries\slshape x}}, where \mbox{\texttt{\mdseries\slshape a}} and \mbox{\texttt{\mdseries\slshape b}} are words in the pc generators. For the representation of these words see the description of the function \texttt{PqCollect} (\texttt{PqCollect} (\ref{PqCollect})). \emph{Note:} For those familiar with the \texttt{pq} program, \texttt{PqSolveEquation} performs menu item 2 of the Advanced $p$\texttt{\symbol{45}}Quotient menu. } \subsection{\textcolor{Chapter }{PqCommutator}} \logpage{[ 5, 7, 3 ]}\nobreak \hyperdef{L}{X789B120B7E2F3017}{} {\noindent\textcolor{FuncColor}{$\triangleright$\enspace\texttt{PqCommutator({\mdseries\slshape i, words, pow})\index{PqCommutator@\texttt{PqCommutator}} \label{PqCommutator} }\hfill{\scriptsize (function)}}\\ \noindent\textcolor{FuncColor}{$\triangleright$\enspace\texttt{PqCommutator({\mdseries\slshape words, pow})\index{PqCommutator@\texttt{PqCommutator}!for default process} \label{PqCommutator:for default process} }\hfill{\scriptsize (function)}}\\ for the \mbox{\texttt{\mdseries\slshape i}}th or default interactive \textsf{ANUPQ} process, instruct the \texttt{pq} program to compute the left normed commutator of the list \mbox{\texttt{\mdseries\slshape words}} of words in the current pc generators raised to the integer power \mbox{\texttt{\mdseries\slshape pow}}, and return the resulting word as a list of generator number, exponent pairs. The form required for each word of \mbox{\texttt{\mdseries\slshape words}} is the same as that required for the \mbox{\texttt{\mdseries\slshape word}} argument of \texttt{PqCollect} (see{\nobreakspace}\texttt{PqCollect} (\ref{PqCollect})). The form of the output word is also the same as for \texttt{PqCollect}. \emph{Note:} For those familiar with the \texttt{pq} program, \texttt{PqCommutator} performs menu item 3 of the Advanced $p$\texttt{\symbol{45}}Quotient menu. } \subsection{\textcolor{Chapter }{PqSetupTablesForNextClass}} \logpage{[ 5, 7, 4 ]}\nobreak \hyperdef{L}{X7A61A15E78F52743}{} {\noindent\textcolor{FuncColor}{$\triangleright$\enspace\texttt{PqSetupTablesForNextClass({\mdseries\slshape i})\index{PqSetupTablesForNextClass@\texttt{PqSetupTablesForNextClass}} \label{PqSetupTablesForNextClass} }\hfill{\scriptsize (function)}}\\ \noindent\textcolor{FuncColor}{$\triangleright$\enspace\texttt{PqSetupTablesForNextClass({\mdseries\slshape })\index{PqSetupTablesForNextClass@\texttt{PqSetupTablesForNextClass}!for default process} \label{PqSetupTablesForNextClass:for default process} }\hfill{\scriptsize (function)}}\\ for the \mbox{\texttt{\mdseries\slshape i}}th or default interactive \textsf{ANUPQ} process, direct the \texttt{pq} program to set up tables for the next class. As as side\texttt{\symbol{45}}effect, after \texttt{PqSetupTablesForNextClass(\mbox{\texttt{\mdseries\slshape i}})} the value returned by \texttt{PqPClass(\mbox{\texttt{\mdseries\slshape i}})} will be one more than it was previously. \emph{Note:} For those familiar with the \texttt{pq} program, \texttt{PqSetupTablesForNextClass} performs menu item 6 of the Advanced $p$\texttt{\symbol{45}}Quotient menu. } \subsection{\textcolor{Chapter }{PqTails}} \logpage{[ 5, 7, 5 ]}\nobreak \hyperdef{L}{X84F7DD8582B368D3}{} {\noindent\textcolor{FuncColor}{$\triangleright$\enspace\texttt{PqTails({\mdseries\slshape i, weight})\index{PqTails@\texttt{PqTails}} \label{PqTails} }\hfill{\scriptsize (function)}}\\ \noindent\textcolor{FuncColor}{$\triangleright$\enspace\texttt{PqTails({\mdseries\slshape weight})\index{PqTails@\texttt{PqTails}!for default process} \label{PqTails:for default process} }\hfill{\scriptsize (function)}}\\ for the \mbox{\texttt{\mdseries\slshape i}}th or default interactive \textsf{ANUPQ} process, direct the \texttt{pq} program to compute and add tails of weight \mbox{\texttt{\mdseries\slshape weight}} if \mbox{\texttt{\mdseries\slshape weight}} is in the integer range \texttt{[2 .. PqPClass(\mbox{\texttt{\mdseries\slshape i}})]} (assuming \mbox{\texttt{\mdseries\slshape i}} is the number of the process, even in the default case) or for all weights if \texttt{\mbox{\texttt{\mdseries\slshape weight}} = 0}. If \mbox{\texttt{\mdseries\slshape weight}} is non\texttt{\symbol{45}}zero, then tails that introduce new generators for only weight \mbox{\texttt{\mdseries\slshape weight}} are computed and added, and in this case and if \texttt{\mbox{\texttt{\mdseries\slshape weight}} {\textless} PqPClass(\mbox{\texttt{\mdseries\slshape i}})}, it is assumed that the tails that introduce new generators for each weight from \texttt{PqPClass(\mbox{\texttt{\mdseries\slshape i}})} down to weight \texttt{\mbox{\texttt{\mdseries\slshape weight}} + 1} have already been added. You may wish to call \texttt{PqSetMetabelian} (see{\nobreakspace}\texttt{PqSetMetabelian} (\ref{PqSetMetabelian})) prior to calling \texttt{PqTails}. \emph{Notes} For its use in the context of finding the next class see \texttt{PqNextClass} (\ref{PqNextClass}); in particular, a call to \texttt{PqSetupTablesForNextClass} (see{\nobreakspace}\texttt{PqSetupTablesForNextClass} (\ref{PqSetupTablesForNextClass})) needs to have been made prior to calling \texttt{PqTails}. The single command: \texttt{PqTails(\mbox{\texttt{\mdseries\slshape i}}, \mbox{\texttt{\mdseries\slshape weight}});} is equivalent to \begin{Verbatim}[commandchars=!@|,fontsize=\small,frame=single,label=] PqComputeTails(i, weight); PqAddTails(i, weight); \end{Verbatim} For those familiar with the \texttt{pq} program, \texttt{PqTails} uses menu item 7 of the Advanced $p$\texttt{\symbol{45}}Quotient menu. } \subsection{\textcolor{Chapter }{PqComputeTails}} \logpage{[ 5, 7, 6 ]}\nobreak \hyperdef{L}{X8389F6437ED634B8}{} {\noindent\textcolor{FuncColor}{$\triangleright$\enspace\texttt{PqComputeTails({\mdseries\slshape i, weight})\index{PqComputeTails@\texttt{PqComputeTails}} \label{PqComputeTails} }\hfill{\scriptsize (function)}}\\ \noindent\textcolor{FuncColor}{$\triangleright$\enspace\texttt{PqComputeTails({\mdseries\slshape weight})\index{PqComputeTails@\texttt{PqComputeTails}!for default process} \label{PqComputeTails:for default process} }\hfill{\scriptsize (function)}}\\ for the \mbox{\texttt{\mdseries\slshape i}}th or default interactive \textsf{ANUPQ} process, direct the \texttt{pq} program to compute tails of weight \mbox{\texttt{\mdseries\slshape weight}} if \mbox{\texttt{\mdseries\slshape weight}} is in the integer range \texttt{[2 .. PqPClass(\mbox{\texttt{\mdseries\slshape i}})]} (assuming \mbox{\texttt{\mdseries\slshape i}} is the number of the process, even in the default case) or for all weights if \texttt{\mbox{\texttt{\mdseries\slshape weight}} = 0}. See \texttt{PqTails} (\texttt{PqTails} (\ref{PqTails})) for more details. \emph{Note:} For those familiar with the \texttt{pq} program, \texttt{PqComputeTails} uses menu item 7 of the Advanced $p$\texttt{\symbol{45}}Quotient menu. } \subsection{\textcolor{Chapter }{PqAddTails}} \logpage{[ 5, 7, 7 ]}\nobreak \hyperdef{L}{X83CD6D888372DFB8}{} {\noindent\textcolor{FuncColor}{$\triangleright$\enspace\texttt{PqAddTails({\mdseries\slshape i, weight})\index{PqAddTails@\texttt{PqAddTails}} \label{PqAddTails} }\hfill{\scriptsize (function)}}\\ \noindent\textcolor{FuncColor}{$\triangleright$\enspace\texttt{PqAddTails({\mdseries\slshape weight})\index{PqAddTails@\texttt{PqAddTails}!for default process} \label{PqAddTails:for default process} }\hfill{\scriptsize (function)}}\\ for the \mbox{\texttt{\mdseries\slshape i}}th or default interactive \textsf{ANUPQ} process, direct the \texttt{pq} program to add the tails of weight \mbox{\texttt{\mdseries\slshape weight}}, previously computed by \texttt{PqComputeTails} (see{\nobreakspace}\texttt{PqComputeTails} (\ref{PqComputeTails})), if \mbox{\texttt{\mdseries\slshape weight}} is in the integer range \texttt{[2 .. PqPClass(\mbox{\texttt{\mdseries\slshape i}})]} (assuming \mbox{\texttt{\mdseries\slshape i}} is the number of the process, even in the default case) or for all weights if \texttt{\mbox{\texttt{\mdseries\slshape weight}} = 0}. See \texttt{PqTails} (\texttt{PqTails} (\ref{PqTails})) for more details. \emph{Note:} For those familiar with the \texttt{pq} program, \texttt{PqAddTails} uses menu item 7 of the Advanced $p$\texttt{\symbol{45}}Quotient menu. } \subsection{\textcolor{Chapter }{PqDoConsistencyChecks}} \logpage{[ 5, 7, 8 ]}\nobreak \hyperdef{L}{X82AA8FAE85826BB9}{} {\noindent\textcolor{FuncColor}{$\triangleright$\enspace\texttt{PqDoConsistencyChecks({\mdseries\slshape i, weight, type})\index{PqDoConsistencyChecks@\texttt{PqDoConsistencyChecks}} \label{PqDoConsistencyChecks} }\hfill{\scriptsize (function)}}\\ \noindent\textcolor{FuncColor}{$\triangleright$\enspace\texttt{PqDoConsistencyChecks({\mdseries\slshape weight, type})\index{PqDoConsistencyChecks@\texttt{PqDoConsistencyChecks}!for default process} \label{PqDoConsistencyChecks:for default process} }\hfill{\scriptsize (function)}}\\ for the \mbox{\texttt{\mdseries\slshape i}}th or default interactive \textsf{ANUPQ} process, do consistency checks for weight \mbox{\texttt{\mdseries\slshape weight}} if \mbox{\texttt{\mdseries\slshape weight}} is in the integer range \texttt{[3 .. PqPClass(\mbox{\texttt{\mdseries\slshape i}})]} (assuming \mbox{\texttt{\mdseries\slshape i}} is the number of the process) or for all weights if \texttt{\mbox{\texttt{\mdseries\slshape weight}} = 0}, and for type \mbox{\texttt{\mdseries\slshape type}} if \mbox{\texttt{\mdseries\slshape type}} is in the range \texttt{[1, 2, 3]} (see below) or for all types if \texttt{\mbox{\texttt{\mdseries\slshape type}} = 0}. (For its use in the context of finding the next class see \texttt{PqNextClass} (\ref{PqNextClass}).) The \emph{type} of a consistency check is defined as follows. \texttt{PqDoConsistencyChecks(\mbox{\texttt{\mdseries\slshape i}}, \mbox{\texttt{\mdseries\slshape weight}}, \mbox{\texttt{\mdseries\slshape type}})} for \mbox{\texttt{\mdseries\slshape weight}} in \texttt{[3 .. PqPClass(\mbox{\texttt{\mdseries\slshape i}})]} and the given value of \mbox{\texttt{\mdseries\slshape type}} invokes the equivalent of the following \texttt{PqDoConsistencyCheck} calls (see{\nobreakspace}\texttt{PqDoConsistencyCheck} (\ref{PqDoConsistencyCheck})): \begin{description} \item[{\texttt{\mbox{\texttt{\mdseries\slshape type}} = 1}:}] \texttt{PqDoConsistencyCheck(\mbox{\texttt{\mdseries\slshape i}}, \mbox{\texttt{\mdseries\slshape a}}, \mbox{\texttt{\mdseries\slshape a}}, \mbox{\texttt{\mdseries\slshape a}})} checks \texttt{2 * PqWeight(\mbox{\texttt{\mdseries\slshape i}}, \mbox{\texttt{\mdseries\slshape a}}) + 1 = \mbox{\texttt{\mdseries\slshape weight}}}, for pc generators of index \mbox{\texttt{\mdseries\slshape a}}. \item[{\texttt{\mbox{\texttt{\mdseries\slshape type}} = 2}:}] \texttt{PqDoConsistencyCheck(\mbox{\texttt{\mdseries\slshape i}}, \mbox{\texttt{\mdseries\slshape b}}, \mbox{\texttt{\mdseries\slshape b}}, \mbox{\texttt{\mdseries\slshape a}})} checks for pc generators of indices \mbox{\texttt{\mdseries\slshape b}}, \mbox{\texttt{\mdseries\slshape a}} satisfyingx both \texttt{\mbox{\texttt{\mdseries\slshape b}} {\textgreater} \mbox{\texttt{\mdseries\slshape a}}} and \texttt{PqWeight(\mbox{\texttt{\mdseries\slshape i}}, \mbox{\texttt{\mdseries\slshape b}}) + PqWeight(\mbox{\texttt{\mdseries\slshape i}}, \mbox{\texttt{\mdseries\slshape a}}) + 1 = \mbox{\texttt{\mdseries\slshape weight}}}. \item[{\texttt{\mbox{\texttt{\mdseries\slshape type}} = 3}:}] \texttt{PqDoConsistencyCheck(\mbox{\texttt{\mdseries\slshape i}}, \mbox{\texttt{\mdseries\slshape c}}, \mbox{\texttt{\mdseries\slshape b}}, \mbox{\texttt{\mdseries\slshape a}})} checks for pc generators of indices \mbox{\texttt{\mdseries\slshape c}}, \mbox{\texttt{\mdseries\slshape b}}, \mbox{\texttt{\mdseries\slshape a}} satisfying \texttt{\mbox{\texttt{\mdseries\slshape c}} {\textgreater} \mbox{\texttt{\mdseries\slshape b}} {\textgreater} \mbox{\texttt{\mdseries\slshape a}}} and the sum of the weights of these generators equals \mbox{\texttt{\mdseries\slshape weight}}. \end{description} \emph{Notes} \texttt{PqWeight(\mbox{\texttt{\mdseries\slshape i}}, \mbox{\texttt{\mdseries\slshape j}})} returns the weight of the \mbox{\texttt{\mdseries\slshape j}}th pc generator, for process \mbox{\texttt{\mdseries\slshape i}} (see{\nobreakspace}\texttt{PqWeight} (\ref{PqWeight})). It is assumed that tails for the given weight (or weights) have already been added (see{\nobreakspace}\texttt{PqTails} (\ref{PqTails})). For those familiar with the \texttt{pq} program, \texttt{PqDoConsistencyChecks} performs menu item 8 of the Advanced $p$\texttt{\symbol{45}}Quotient menu. } \subsection{\textcolor{Chapter }{PqCollectDefiningRelations}} \logpage{[ 5, 7, 9 ]}\nobreak \hyperdef{L}{X7A01EE0382689928}{} {\noindent\textcolor{FuncColor}{$\triangleright$\enspace\texttt{PqCollectDefiningRelations({\mdseries\slshape i})\index{PqCollectDefiningRelations@\texttt{PqCollectDefiningRelations}} \label{PqCollectDefiningRelations} }\hfill{\scriptsize (function)}}\\ \noindent\textcolor{FuncColor}{$\triangleright$\enspace\texttt{PqCollectDefiningRelations({\mdseries\slshape })\index{PqCollectDefiningRelations@\texttt{PqCollectDefiningRelations}!for default process} \label{PqCollectDefiningRelations:for default process} }\hfill{\scriptsize (function)}}\\ for the \mbox{\texttt{\mdseries\slshape i}}th or default interactive \textsf{ANUPQ} process, direct the \texttt{pq} program to collect the images of the defining relations of the original fp group of the process, with respect to the current pc presentation, in the context of finding the next class (see{\nobreakspace}\texttt{PqNextClass} (\ref{PqNextClass})). If the tails operation is not complete then the relations may be evaluated incorrectly. \emph{Note:} For those familiar with the \texttt{pq} program, \texttt{PqCollectDefiningRelations} performs menu item 9 of the Advanced $p$\texttt{\symbol{45}}Quotient menu. } \subsection{\textcolor{Chapter }{PqCollectWordInDefiningGenerators}} \logpage{[ 5, 7, 10 ]}\nobreak \hyperdef{L}{X7C2B4C1E7BEB19D5}{} {\noindent\textcolor{FuncColor}{$\triangleright$\enspace\texttt{PqCollectWordInDefiningGenerators({\mdseries\slshape i, word})\index{PqCollectWordInDefiningGenerators@\texttt{PqCollectWordInDefiningGenerators}} \label{PqCollectWordInDefiningGenerators} }\hfill{\scriptsize (function)}}\\ \noindent\textcolor{FuncColor}{$\triangleright$\enspace\texttt{PqCollectWordInDefiningGenerators({\mdseries\slshape word})\index{PqCollectWordInDefiningGenerators@\texttt{PqCollectWordInDefiningGenerators}!for default process} \label{PqCollectWordInDefiningGenerators:for default process} }\hfill{\scriptsize (function)}}\\ for the \mbox{\texttt{\mdseries\slshape i}}th or default interactive \textsf{ANUPQ} process, take a user\texttt{\symbol{45}}defined word \mbox{\texttt{\mdseries\slshape word}} in the defining generators of the original presentation of the fp or pc group of the process. Each generator is mapped into the current pc presentation, and the resulting word is collected with respect to the current pc presentation. The result of the collection is returned as a list of generator number, exponent pairs. The \mbox{\texttt{\mdseries\slshape word}} argument may be input in either of the two ways described for \texttt{PqCollect} (see{\nobreakspace}\texttt{PqCollect} (\ref{PqCollect})). \emph{Note:} For those familiar with the \texttt{pq} program, \texttt{PqCollectDefiningGenerators} performs menu item 23 of the Advanced $p$\texttt{\symbol{45}}Quotient menu. } \subsection{\textcolor{Chapter }{PqCommutatorDefiningGenerators}} \logpage{[ 5, 7, 11 ]}\nobreak \hyperdef{L}{X7DB05AA587D7A052}{} {\noindent\textcolor{FuncColor}{$\triangleright$\enspace\texttt{PqCommutatorDefiningGenerators({\mdseries\slshape i, words, pow})\index{PqCommutatorDefiningGenerators@\texttt{PqCommutatorDefiningGenerators}} \label{PqCommutatorDefiningGenerators} }\hfill{\scriptsize (function)}}\\ \noindent\textcolor{FuncColor}{$\triangleright$\enspace\texttt{PqCommutatorDefiningGenerators({\mdseries\slshape words, pow})\index{PqCommutatorDefiningGenerators@\texttt{PqCommutatorDefiningGenerators}!for default process} \label{PqCommutatorDefiningGenerators:for default process} }\hfill{\scriptsize (function)}}\\ for the \mbox{\texttt{\mdseries\slshape i}}th or default interactive \textsf{ANUPQ} process, take a list \mbox{\texttt{\mdseries\slshape words}} of user\texttt{\symbol{45}}defined words in the defining generators of the original presentation of the fp or pc group of the process, and an integer power \mbox{\texttt{\mdseries\slshape pow}}. Each generator is mapped into the current pc presentation. The list \mbox{\texttt{\mdseries\slshape words}} is interpreted as a left\texttt{\symbol{45}}normed commutator which is then raised to \mbox{\texttt{\mdseries\slshape pow}} and collected with respect to the current pc presentation. The result of the collection is returned as a list of generator number, exponent pairs. \emph{Note} For those familiar with the \texttt{pq} program, \texttt{PqCommutatorDefiningGenerators} performs menu item 24 of the Advanced $p$\texttt{\symbol{45}}Quotient menu. } \subsection{\textcolor{Chapter }{PqDoExponentChecks}} \logpage{[ 5, 7, 12 ]}\nobreak \hyperdef{L}{X80E563A97EDE083E}{} {\noindent\textcolor{FuncColor}{$\triangleright$\enspace\texttt{PqDoExponentChecks({\mdseries\slshape i: [Bounds := list]})\index{PqDoExponentChecks@\texttt{PqDoExponentChecks}} \label{PqDoExponentChecks} }\hfill{\scriptsize (function)}}\\ \noindent\textcolor{FuncColor}{$\triangleright$\enspace\texttt{PqDoExponentChecks({\mdseries\slshape : [Bounds := list]})\index{PqDoExponentChecks@\texttt{PqDoExponentChecks}!for default process} \label{PqDoExponentChecks:for default process} }\hfill{\scriptsize (function)}}\\ for the \mbox{\texttt{\mdseries\slshape i}}th or default interactive \textsf{ANUPQ} process, direct the \texttt{pq} program to do exponent checks for weights (inclusively) between the bounds of \texttt{Bounds} or for all weights if \texttt{Bounds} is not given. The value \mbox{\texttt{\mdseries\slshape list}} of \texttt{Bounds} (assuming the interactive process is numbered \mbox{\texttt{\mdseries\slshape i}}) should be a list of two integers \mbox{\texttt{\mdseries\slshape low}}, \mbox{\texttt{\mdseries\slshape high}} satisfying $1 \le \mbox{\texttt{\mdseries\slshape low}} \le \mbox{\texttt{\mdseries\slshape high}} \le $ \texttt{PqPClass(\mbox{\texttt{\mdseries\slshape i}})} (see{\nobreakspace}\texttt{PqPClass} (\ref{PqPClass})). If no exponent law has been specified, no exponent checks are performed. \emph{Note:} For those familiar with the \texttt{pq} program, \texttt{PqDoExponentChecks} performs menu item 10 of the Advanced $p$\texttt{\symbol{45}}Quotient menu. } \subsection{\textcolor{Chapter }{PqEliminateRedundantGenerators}} \logpage{[ 5, 7, 13 ]}\nobreak \hyperdef{L}{X7BBAB2787B305516}{} {\noindent\textcolor{FuncColor}{$\triangleright$\enspace\texttt{PqEliminateRedundantGenerators({\mdseries\slshape i})\index{PqEliminateRedundantGenerators@\texttt{PqEliminateRedundantGenerators}} \label{PqEliminateRedundantGenerators} }\hfill{\scriptsize (function)}}\\ \noindent\textcolor{FuncColor}{$\triangleright$\enspace\texttt{PqEliminateRedundantGenerators({\mdseries\slshape })\index{PqEliminateRedundantGenerators@\texttt{PqEliminateRedundantGenerators}!for default process} \label{PqEliminateRedundantGenerators:for default process} }\hfill{\scriptsize (function)}}\\ for the \mbox{\texttt{\mdseries\slshape i}}th or default interactive \textsf{ANUPQ} process, direct the \texttt{pq} program to eliminate redundant generators of the current $p$\texttt{\symbol{45}}quotient. \emph{Note:} For those familiar with the \texttt{pq} program, \texttt{PqEliminateRedundantGenerators} performs menu item 11 of the Advanced $p$\texttt{\symbol{45}}Quotient menu. } \subsection{\textcolor{Chapter }{PqRevertToPreviousClass}} \logpage{[ 5, 7, 14 ]}\nobreak \hyperdef{L}{X783E53B5853F45E6}{} {\noindent\textcolor{FuncColor}{$\triangleright$\enspace\texttt{PqRevertToPreviousClass({\mdseries\slshape i})\index{PqRevertToPreviousClass@\texttt{PqRevertToPreviousClass}} \label{PqRevertToPreviousClass} }\hfill{\scriptsize (function)}}\\ \noindent\textcolor{FuncColor}{$\triangleright$\enspace\texttt{PqRevertToPreviousClass({\mdseries\slshape })\index{PqRevertToPreviousClass@\texttt{PqRevertToPreviousClass}!for default process} \label{PqRevertToPreviousClass:for default process} }\hfill{\scriptsize (function)}}\\ for the \mbox{\texttt{\mdseries\slshape i}}th or default interactive \textsf{ANUPQ} process, direct the \texttt{pq} program to abandon the current class and revert to the previous class. \emph{Note:} For those familiar with the \texttt{pq} program, \texttt{PqRevertToPreviousClass} performs menu item 12 of the Advanced $p$\texttt{\symbol{45}}Quotient menu. } \subsection{\textcolor{Chapter }{PqSetMaximalOccurrences}} \logpage{[ 5, 7, 15 ]}\nobreak \hyperdef{L}{X8265A6DB81CD24DB}{} {\noindent\textcolor{FuncColor}{$\triangleright$\enspace\texttt{PqSetMaximalOccurrences({\mdseries\slshape i, noccur})\index{PqSetMaximalOccurrences@\texttt{PqSetMaximalOccurrences}} \label{PqSetMaximalOccurrences} }\hfill{\scriptsize (function)}}\\ \noindent\textcolor{FuncColor}{$\triangleright$\enspace\texttt{PqSetMaximalOccurrences({\mdseries\slshape noccur})\index{PqSetMaximalOccurrences@\texttt{PqSetMaximalOccurrences}!for default process} \label{PqSetMaximalOccurrences:for default process} }\hfill{\scriptsize (function)}}\\ for the \mbox{\texttt{\mdseries\slshape i}}th or default interactive \textsf{ANUPQ} process, direct the \texttt{pq} program to set maximal occurrences of the weight 1 generators in the definitions of pcp generators of the group of the process. This can be used to avoid the definition of generators of which one knows for theoretical reasons that they would be eliminated later on. The argument \mbox{\texttt{\mdseries\slshape noccur}} must be a list of non\texttt{\symbol{45}}negative integers of length the number of weight 1 generators (i.e.{\nobreakspace}the rank of the class 1 $p$\texttt{\symbol{45}}quotient of the group of the process). An entry of \texttt{0} for a particular generator indicates that there is no limit on the number of occurrences for the generator. \emph{Note:} For those familiar with the \texttt{pq} program, \texttt{PqSetMaximalOccurrences} performs menu item 13 of the Advanced $p$\texttt{\symbol{45}}Quotient menu. } \subsection{\textcolor{Chapter }{PqSetMetabelian}} \logpage{[ 5, 7, 16 ]}\nobreak \hyperdef{L}{X87A35ABB7E11595E}{} {\noindent\textcolor{FuncColor}{$\triangleright$\enspace\texttt{PqSetMetabelian({\mdseries\slshape i})\index{PqSetMetabelian@\texttt{PqSetMetabelian}} \label{PqSetMetabelian} }\hfill{\scriptsize (function)}}\\ \noindent\textcolor{FuncColor}{$\triangleright$\enspace\texttt{PqSetMetabelian({\mdseries\slshape })\index{PqSetMetabelian@\texttt{PqSetMetabelian}!for default process} \label{PqSetMetabelian:for default process} }\hfill{\scriptsize (function)}}\\ for the \mbox{\texttt{\mdseries\slshape i}}th or default interactive \textsf{ANUPQ} process, direct the \texttt{pq} program to enforce metabelian\texttt{\symbol{45}}ness. \emph{Note:} For those familiar with the \texttt{pq} program, \texttt{PqSetMetabelian} performs menu item 14 of the Advanced $p$\texttt{\symbol{45}}Quotient menu. } \subsection{\textcolor{Chapter }{PqDoConsistencyCheck}} \logpage{[ 5, 7, 17 ]}\nobreak \hyperdef{L}{X7C7D17F878AA1BAA}{} {\noindent\textcolor{FuncColor}{$\triangleright$\enspace\texttt{PqDoConsistencyCheck({\mdseries\slshape i, c, b, a})\index{PqDoConsistencyCheck@\texttt{PqDoConsistencyCheck}} \label{PqDoConsistencyCheck} }\hfill{\scriptsize (function)}}\\ \noindent\textcolor{FuncColor}{$\triangleright$\enspace\texttt{PqDoConsistencyCheck({\mdseries\slshape c, b, a})\index{PqDoConsistencyCheck@\texttt{PqDoConsistencyCheck}!for default process} \label{PqDoConsistencyCheck:for default process} }\hfill{\scriptsize (function)}}\\ \noindent\textcolor{FuncColor}{$\triangleright$\enspace\texttt{PqJacobi({\mdseries\slshape i, c, b, a})\index{PqJacobi@\texttt{PqJacobi}} \label{PqJacobi} }\hfill{\scriptsize (function)}}\\ \noindent\textcolor{FuncColor}{$\triangleright$\enspace\texttt{PqJacobi({\mdseries\slshape c, b, a})\index{PqJacobi@\texttt{PqJacobi}!for default process} \label{PqJacobi:for default process} }\hfill{\scriptsize (function)}}\\ for the \mbox{\texttt{\mdseries\slshape i}}th or default interactive \textsf{ANUPQ} process, direct the \texttt{pq} program to do the consistency check for the pc generators with indices \mbox{\texttt{\mdseries\slshape c}}, \mbox{\texttt{\mdseries\slshape b}}, \mbox{\texttt{\mdseries\slshape a}} which should be non\texttt{\symbol{45}}increasing positive integers, i.e.{\nobreakspace}$\mbox{\texttt{\mdseries\slshape c}} \ge \mbox{\texttt{\mdseries\slshape b}} \ge \mbox{\texttt{\mdseries\slshape a}}$. There are 3 types of consistency checks: \[ \begin{array}{rclrl} (a^n)a &=& a(a^n) && {\rm (Type\ 1)} \\ (b^n)a &=& b^{(n-1)}(ba), b(a^n) = (ba)a^{(n-1)} && {\rm (Type\ 2)} \\ c(ba) &=& (cb)a && {\rm (Type\ 3)} \\ \end{array} \] The reason some people talk about Jacobi relations instead of consistency checks becomes clear when one looks at the consistency check of type 3: \[ \begin{array}{rcl} c(ba) &=& a c[c,a] b[b,a] = acb [c,a][c,a,b][b,a] = \dots \\ (cb)a &=& b c[c,b] a = a b[b,a] c[c,a] [c,b][c,b,a] \\ &=& abc [b,a] [b,a,c] [c,a] [c,b] [c,b,a] = \dots \\ \end{array} \] Each collection would normally carry on further. But one can see already that no other commutators of weight 3 will occur. After all terms of weight one and weight two have been moved to the left we end up with: \[ \begin{array}{rcl} & &abc [b,a] [c,a] [c,b] [c,a,b] \dots \\ &=&abc [b,a] [c,a] [c,b] [c,b,a] [b,a,c] \dots \\ \end{array} \] Modulo terms of weight 4 this is equivalent to \[ [c,a,b] [b,c,a] [a,b,c] = 1 \] which is the Jacobi identity. See also \texttt{PqDoConsistencyChecks} (\texttt{PqDoConsistencyChecks} (\ref{PqDoConsistencyChecks})). \emph{Note:} For those familiar with the \texttt{pq} program, \texttt{PqDoConsistencyCheck} and \texttt{PqJacobi} perform menu item 15 of the Advanced $p$\texttt{\symbol{45}}Quotient menu. } \subsection{\textcolor{Chapter }{PqCompact}} \logpage{[ 5, 7, 18 ]}\nobreak \hyperdef{L}{X843953F48319FDE1}{} {\noindent\textcolor{FuncColor}{$\triangleright$\enspace\texttt{PqCompact({\mdseries\slshape i})\index{PqCompact@\texttt{PqCompact}} \label{PqCompact} }\hfill{\scriptsize (function)}}\\ \noindent\textcolor{FuncColor}{$\triangleright$\enspace\texttt{PqCompact({\mdseries\slshape })\index{PqCompact@\texttt{PqCompact}!for default process} \label{PqCompact:for default process} }\hfill{\scriptsize (function)}}\\ for the \mbox{\texttt{\mdseries\slshape i}}th or default interactive \textsf{ANUPQ} process, direct the \texttt{pq} program to do a compaction of its work space. This function is safe to perform only at certain points in time. \emph{Note:} For those familiar with the \texttt{pq} program, \texttt{PqCompact} performs menu item 16 of the Advanced $p$\texttt{\symbol{45}}Quotient menu. } \subsection{\textcolor{Chapter }{PqEchelonise}} \logpage{[ 5, 7, 19 ]}\nobreak \hyperdef{L}{X80344EEC78A09ACF}{} {\noindent\textcolor{FuncColor}{$\triangleright$\enspace\texttt{PqEchelonise({\mdseries\slshape i})\index{PqEchelonise@\texttt{PqEchelonise}} \label{PqEchelonise} }\hfill{\scriptsize (function)}}\\ \noindent\textcolor{FuncColor}{$\triangleright$\enspace\texttt{PqEchelonise({\mdseries\slshape })\index{PqEchelonise@\texttt{PqEchelonise}!for default process} \label{PqEchelonise:for default process} }\hfill{\scriptsize (function)}}\\ for the \mbox{\texttt{\mdseries\slshape i}}th or default interactive \textsf{ANUPQ} process, direct the \texttt{pq} program to echelonise the word most recently collected by \texttt{PqCollect} or \texttt{PqCommutator} against the relations of the current pc presentation, and return the number of the generator made redundant or \texttt{fail} if no generator was made redundant. A call to \texttt{PqCollect} (see{\nobreakspace}\texttt{PqCollect} (\ref{PqCollect})) or \texttt{PqCommutator} (see{\nobreakspace}\texttt{PqCommutator} (\ref{PqCommutator})) needs to be performed prior to using this command. \emph{Note:} For those familiar with the \texttt{pq} program, \texttt{PqEchelonise} performs menu item 17 of the Advanced $p$\texttt{\symbol{45}}Quotient menu. } \subsection{\textcolor{Chapter }{PqSupplyAutomorphisms}} \logpage{[ 5, 7, 20 ]}\nobreak \hyperdef{L}{X852947327FC39DDF}{} {\noindent\textcolor{FuncColor}{$\triangleright$\enspace\texttt{PqSupplyAutomorphisms({\mdseries\slshape i, mlist})\index{PqSupplyAutomorphisms@\texttt{PqSupplyAutomorphisms}} \label{PqSupplyAutomorphisms} }\hfill{\scriptsize (function)}}\\ \noindent\textcolor{FuncColor}{$\triangleright$\enspace\texttt{PqSupplyAutomorphisms({\mdseries\slshape mlist})\index{PqSupplyAutomorphisms@\texttt{PqSupplyAutomorphisms}!for default process} \label{PqSupplyAutomorphisms:for default process} }\hfill{\scriptsize (function)}}\\ for the \mbox{\texttt{\mdseries\slshape i}}th or default interactive \textsf{ANUPQ} process, supply the automorphism data provided by the list \mbox{\texttt{\mdseries\slshape mlist}} of matrices with non\texttt{\symbol{45}}negative integer coefficients. Each matrix in \mbox{\texttt{\mdseries\slshape mlist}} describes one automorphism in the following way. \begin{itemize} \item The rows of each matrix correspond to the pc generators of weight one. \item Each row is the exponent vector of the image of the corresponding weight one generator under the respective automorphism. \end{itemize} \emph{Note:} For those familiar with the \texttt{pq} program, \texttt{PqSupplyAutomorphisms} uses menu item 18 of the Advanced $p$\texttt{\symbol{45}}Quotient menu. } \subsection{\textcolor{Chapter }{PqExtendAutomorphisms}} \logpage{[ 5, 7, 21 ]}\nobreak \hyperdef{L}{X7B919B537C042DAD}{} {\noindent\textcolor{FuncColor}{$\triangleright$\enspace\texttt{PqExtendAutomorphisms({\mdseries\slshape i})\index{PqExtendAutomorphisms@\texttt{PqExtendAutomorphisms}} \label{PqExtendAutomorphisms} }\hfill{\scriptsize (function)}}\\ \noindent\textcolor{FuncColor}{$\triangleright$\enspace\texttt{PqExtendAutomorphisms({\mdseries\slshape })\index{PqExtendAutomorphisms@\texttt{PqExtendAutomorphisms}!for default process} \label{PqExtendAutomorphisms:for default process} }\hfill{\scriptsize (function)}}\\ for the \mbox{\texttt{\mdseries\slshape i}}th or default interactive \textsf{ANUPQ} process, direct the \texttt{pq} program to extend automorphisms of the $p$\texttt{\symbol{45}}quotient of the previous class to the $p$\texttt{\symbol{45}}quotient of the present class. \emph{Note:} For those familiar with the \texttt{pq} program, \texttt{PqExtendAutomorphisms} uses menu item 18 of the Advanced $p$\texttt{\symbol{45}}Quotient menu. } \subsection{\textcolor{Chapter }{PqApplyAutomorphisms}} \logpage{[ 5, 7, 22 ]}\nobreak \hyperdef{L}{X7CFD54657DE4BD39}{} {\noindent\textcolor{FuncColor}{$\triangleright$\enspace\texttt{PqApplyAutomorphisms({\mdseries\slshape i, qfac})\index{PqApplyAutomorphisms@\texttt{PqApplyAutomorphisms}} \label{PqApplyAutomorphisms} }\hfill{\scriptsize (function)}}\\ \noindent\textcolor{FuncColor}{$\triangleright$\enspace\texttt{PqApplyAutomorphisms({\mdseries\slshape qfac})\index{PqApplyAutomorphisms@\texttt{PqApplyAutomorphisms}!for default process} \label{PqApplyAutomorphisms:for default process} }\hfill{\scriptsize (function)}}\\ for the \mbox{\texttt{\mdseries\slshape i}}th or default interactive \textsf{ANUPQ} process, direct the \texttt{pq} program to apply automorphisms; \mbox{\texttt{\mdseries\slshape qfac}} is the queue factor e.g. \texttt{15}. \emph{Note:} For those familiar with the \texttt{pq} program, \texttt{PqCloseRelations} performs menu item 19 of the Advanced $p$\texttt{\symbol{45}}Quotient menu. } \subsection{\textcolor{Chapter }{PqDisplayStructure}} \logpage{[ 5, 7, 23 ]}\nobreak \hyperdef{L}{X81A3D5BF87A34934}{} {\noindent\textcolor{FuncColor}{$\triangleright$\enspace\texttt{PqDisplayStructure({\mdseries\slshape i: [Bounds := list]})\index{PqDisplayStructure@\texttt{PqDisplayStructure}} \label{PqDisplayStructure} }\hfill{\scriptsize (function)}}\\ \noindent\textcolor{FuncColor}{$\triangleright$\enspace\texttt{PqDisplayStructure({\mdseries\slshape : [Bounds := list]})\index{PqDisplayStructure@\texttt{PqDisplayStructure}!for default process} \label{PqDisplayStructure:for default process} }\hfill{\scriptsize (function)}}\\ for the \mbox{\texttt{\mdseries\slshape i}}th or default interactive \textsf{ANUPQ} process, direct the \texttt{pq} program to display the structure for the pcp generators numbered (inclusively) between the bounds of \texttt{Bounds} or for all generators if \texttt{Bounds} is not given. The value \mbox{\texttt{\mdseries\slshape list}} of \texttt{Bounds} (assuming the interactive process is numbered \mbox{\texttt{\mdseries\slshape i}}) should be a list of two integers \mbox{\texttt{\mdseries\slshape low}}, \mbox{\texttt{\mdseries\slshape high}} satisfying $1 \le \mbox{\texttt{\mdseries\slshape low}} \le \mbox{\texttt{\mdseries\slshape high}} \le $ \texttt{PqNrPcGenerators(\mbox{\texttt{\mdseries\slshape i}})} (see{\nobreakspace}\texttt{PqNrPcGenerators} (\ref{PqNrPcGenerators})). \texttt{PqDisplayStructure} also accepts the option \texttt{OutputLevel} (see \ref{option OutputLevel}). \emph{Explanation of output} New generators are defined as commutators of previous generators and generators of class 1 or as $p$\texttt{\symbol{45}}th powers of generators that have themselves been defined as $p$\texttt{\symbol{45}}th powers. A generator is never defined as $p$\texttt{\symbol{45}}th power of a commutator. Therefore, there are two cases: all the numbers on the righthand side are either the same or they differ. Below, \texttt{g\mbox{\texttt{\mdseries\slshape i}}} refers to the \mbox{\texttt{\mdseries\slshape i}}th defining generator. \begin{itemize} \item If the righthand side numbers are all the same, then the generator is a $p$\texttt{\symbol{45}}th power (of a $p$\texttt{\symbol{45}}th power of a $p$\texttt{\symbol{45}}th power, etc.). The number of repeated digits say how often a $p$\texttt{\symbol{45}}th power has to be taken. In the following example, the generator number 31 is the eleventh power of generator 17 which in turn is an eleventh power and so on: \texttt{\symbol{92}}begintt \#I 31 is defined on 17\texttt{\symbol{94}}11 = 1 1 1 1 1 \texttt{\symbol{92}}endtt So generator 31 is obtained by taking the eleventh power of generator 1 five times. \item If the numbers are not all the same, the generator is defined by a commutator. If the first two generator numbers differ, the generator is defined as a left\texttt{\symbol{45}}normed commutator of the weight one generators, e.g. \texttt{\symbol{92}}begintt \#I 19 is defined on [11, 1] = 2 1 1 1 1 \texttt{\symbol{92}}endtt Here, generator 19 is defined as the commutator of generator 11 and generator 1 which is the same as the left\texttt{\symbol{45}}normed commutator \texttt{[x2, x1, x1, x1, x1]}. One can check this by tracing back the definition of generator 11 until one gets to a generator of class 1. \item If the first two generator numbers are identical, then the left most component of the left\texttt{\symbol{45}}normed commutator is a $p$\texttt{\symbol{45}}th power, e.g. \texttt{\symbol{92}}begintt \#I 25 is defined on [14, 1] = 1 1 2 1 1 \texttt{\symbol{92}}endtt In this example, generator 25 is defined as commutator of generator 14 and generator 1. The left\texttt{\symbol{45}}normed commutator is \[ [(x1^{11})^{11}, x2, x1, x1] \] Again, this can be verified by tracing back the definitions. \end{itemize} \emph{Note:} For those familiar with the \texttt{pq} program, \texttt{PqDisplayStructure} performs menu item 20 of the Advanced $p$\texttt{\symbol{45}}Quotient menu. } \subsection{\textcolor{Chapter }{PqDisplayAutomorphisms}} \logpage{[ 5, 7, 24 ]}\nobreak \hyperdef{L}{X853834B478C4EEE2}{} {\noindent\textcolor{FuncColor}{$\triangleright$\enspace\texttt{PqDisplayAutomorphisms({\mdseries\slshape i: [Bounds := list]})\index{PqDisplayAutomorphisms@\texttt{PqDisplayAutomorphisms}} \label{PqDisplayAutomorphisms} }\hfill{\scriptsize (function)}}\\ \noindent\textcolor{FuncColor}{$\triangleright$\enspace\texttt{PqDisplayAutomorphisms({\mdseries\slshape : [Bounds := list]})\index{PqDisplayAutomorphisms@\texttt{PqDisplayAutomorphisms}!for default process} \label{PqDisplayAutomorphisms:for default process} }\hfill{\scriptsize (function)}}\\ for the \mbox{\texttt{\mdseries\slshape i}}th or default interactive \textsf{ANUPQ} process, direct the \texttt{pq} program to display the automorphism actions on the pcp generators numbered (inclusively) between the bounds of \texttt{Bounds} or for all generators if \texttt{Bounds} is not given. The value \mbox{\texttt{\mdseries\slshape list}} of \texttt{Bounds} (assuming the interactive process is numbered \mbox{\texttt{\mdseries\slshape i}}) should be a list of two integers \mbox{\texttt{\mdseries\slshape low}}, \mbox{\texttt{\mdseries\slshape high}} satisfying $1 \le \mbox{\texttt{\mdseries\slshape low}} \le \mbox{\texttt{\mdseries\slshape high}} \le $ \texttt{PqNrPcGenerators(\mbox{\texttt{\mdseries\slshape i}})} (see{\nobreakspace}\texttt{PqNrPcGenerators} (\ref{PqNrPcGenerators})). \texttt{PqDisplayStructure} also accepts the option \texttt{OutputLevel} (see \ref{option OutputLevel}). \emph{Note:} For those familiar with the \texttt{pq} program, \texttt{PqDisplayAutomorphisms} performs menu item 21 of the Advanced $p$\texttt{\symbol{45}}Quotient menu. } \subsection{\textcolor{Chapter }{PqWritePcPresentation}} \logpage{[ 5, 7, 25 ]}\nobreak \hyperdef{L}{X80687A138626EB2D}{} {\noindent\textcolor{FuncColor}{$\triangleright$\enspace\texttt{PqWritePcPresentation({\mdseries\slshape i, filename})\index{PqWritePcPresentation@\texttt{PqWritePcPresentation}} \label{PqWritePcPresentation} }\hfill{\scriptsize (function)}}\\ \noindent\textcolor{FuncColor}{$\triangleright$\enspace\texttt{PqWritePcPresentation({\mdseries\slshape filename})\index{PqWritePcPresentation@\texttt{PqWritePcPresentation}!for default process} \label{PqWritePcPresentation:for default process} }\hfill{\scriptsize (function)}}\\ for the \mbox{\texttt{\mdseries\slshape i}}th or default interactive \textsf{ANUPQ} process, direct the \texttt{pq} program to write a pc presentation of a previously\texttt{\symbol{45}}computed quotient of the group of that process, to the file with name \mbox{\texttt{\mdseries\slshape filename}}. Here the group of a process is the one given as first argument when \texttt{PqStart} was called to initiate that process (for process \mbox{\texttt{\mdseries\slshape i}} the group is stored as \texttt{ANUPQData.io[\mbox{\texttt{\mdseries\slshape i}}].group}). If the first character of the string \mbox{\texttt{\mdseries\slshape filename}} is not \texttt{/}, \mbox{\texttt{\mdseries\slshape filename}} is assumed to be the path of a writable file relative to the directory in which \textsf{GAP} was started. If a pc presentation has not been previously computed by the \texttt{pq} program, then \texttt{pq} is called to compute it first, effectively invoking \texttt{PqPcPresentation} (see{\nobreakspace}\texttt{PqPcPresentation} (\ref{PqPcPresentation})). \emph{Note:} For those familiar with the \texttt{pq} program, \texttt{PqPcWritePresentation} performs menu item 25 of the Advanced $p$\texttt{\symbol{45}}Quotient menu. } } \section{\textcolor{Chapter }{Commands from the Standard Presentation menu}}\logpage{[ 5, 8, 0 ]} \hyperdef{L}{X7B94EDA385FDD904}{} { \subsection{\textcolor{Chapter }{PqSPComputePcpAndPCover}} \logpage{[ 5, 8, 1 ]}\nobreak \hyperdef{L}{X78D1963D85C71B7B}{} {\noindent\textcolor{FuncColor}{$\triangleright$\enspace\texttt{PqSPComputePcpAndPCover({\mdseries\slshape i: options})\index{PqSPComputePcpAndPCover@\texttt{PqSPComputePcpAndPCover}} \label{PqSPComputePcpAndPCover} }\hfill{\scriptsize (function)}}\\ \noindent\textcolor{FuncColor}{$\triangleright$\enspace\texttt{PqSPComputePcpAndPCover({\mdseries\slshape : options})\index{PqSPComputePcpAndPCover@\texttt{PqSPComputePcpAndPCover}!for default process} \label{PqSPComputePcpAndPCover:for default process} }\hfill{\scriptsize (function)}}\\ for the \mbox{\texttt{\mdseries\slshape i}}th or default interactive \textsf{ANUPQ} process, directs the \texttt{pq} program to compute for the group of that process a pc presentation up to the $p$\texttt{\symbol{45}}quotient of maximum class or the value of the option \texttt{ClassBound} and the $p$\texttt{\symbol{45}}cover of that quotient, and sets up tabular information required for computation of a standard presentation. Here the group of a process is the one given as first argument when \texttt{PqStart} was called to initiate that process (for process \mbox{\texttt{\mdseries\slshape i}} the group is stored as \texttt{ANUPQData.io[\mbox{\texttt{\mdseries\slshape i}}].group}). The possible \mbox{\texttt{\mdseries\slshape options}} are \texttt{Prime}, \texttt{ClassBound}, \texttt{Relators}, \texttt{Exponent}, \texttt{Metabelian} and \texttt{OutputLevel} (see Chapter{\nobreakspace}\hyperref[ANUPQ Options]{`ANUPQ Options'} for detailed descriptions of these options). The option \texttt{Prime} is normally determined via \texttt{PrimePGroup}, and so is not required unless the group doesn't know it's a $p$\texttt{\symbol{45}}group and \texttt{HasPrimePGroup} returns \texttt{false}. \emph{Note:} For those familiar with the \texttt{pq} program, \texttt{PqSPComputePcpAndPCover} performs option 1 of the Standard Presentation menu. } \subsection{\textcolor{Chapter }{PqSPStandardPresentation}} \logpage{[ 5, 8, 2 ]}\nobreak \hyperdef{L}{X876F30187E89E467}{} {\noindent\textcolor{FuncColor}{$\triangleright$\enspace\texttt{PqSPStandardPresentation({\mdseries\slshape i[, mlist]: [options]})\index{PqSPStandardPresentation@\texttt{PqSPStandardPresentation}} \label{PqSPStandardPresentation} }\hfill{\scriptsize (function)}}\\ \noindent\textcolor{FuncColor}{$\triangleright$\enspace\texttt{PqSPStandardPresentation({\mdseries\slshape [mlist]: [options]})\index{PqSPStandardPresentation@\texttt{PqSPStandardPresentation}!for default process} \label{PqSPStandardPresentation:for default process} }\hfill{\scriptsize (function)}}\\ for the \mbox{\texttt{\mdseries\slshape i}}th or default interactive \textsf{ANUPQ} process, inputs data given by \mbox{\texttt{\mdseries\slshape options}} to compute a standard presentation for the group of that process. If argument \mbox{\texttt{\mdseries\slshape mlist}} is given it is assumed to be the automorphism group data required. Otherwise it is assumed that a call to either \texttt{Pq} (see{\nobreakspace}\texttt{Pq} (\ref{Pq:interactive})) or \texttt{PqEpimorphism} (see{\nobreakspace}\texttt{PqEpimorphism} (\ref{PqEpimorphism:interactive})) has generated a $p$\texttt{\symbol{45}}quotient and that \textsf{GAP} can compute its automorphism group from which the necessary automorphism group data can be derived. The group of the process is the one given as first argument when \texttt{PqStart} was called to initiate the process (for process \mbox{\texttt{\mdseries\slshape i}} the group is stored as \texttt{ANUPQData.io[\mbox{\texttt{\mdseries\slshape i}}].group} and the $p$\texttt{\symbol{45}}quotient if existent is stored as \texttt{ANUPQData.io[\mbox{\texttt{\mdseries\slshape i}}].pQuotient}). If \mbox{\texttt{\mdseries\slshape mlist}} is not given and a $p$\texttt{\symbol{45}}quotient of the group has not been previously computed a class 1 $p$\texttt{\symbol{45}}quotient is computed. \texttt{PqSPStandardPresentation} accepts three options, all optional: \begin{itemize} \item \texttt{ClassBound := \mbox{\texttt{\mdseries\slshape n}}}\index{option ClassBound} \item \texttt{PcgsAutomorphisms}\index{option PcgsAutomorphisms} \item \texttt{StandardPresentationFile := \mbox{\texttt{\mdseries\slshape filename}}}\index{option StandardPresentationFile} \end{itemize} If \texttt{ClassBound} is omitted it defaults to 63. Detailed descriptions of the above options may be found in Chapter{\nobreakspace}\hyperref[ANUPQ Options]{`ANUPQ Options'}. \emph{Note:} For those familiar with the \texttt{pq} program, \texttt{PqSPPcPresentation} performs menu item 2 of the Standard Presentation menu. } \subsection{\textcolor{Chapter }{PqSPSavePresentation}} \logpage{[ 5, 8, 3 ]}\nobreak \hyperdef{L}{X7E1B2B088322F48A}{} {\noindent\textcolor{FuncColor}{$\triangleright$\enspace\texttt{PqSPSavePresentation({\mdseries\slshape i, filename})\index{PqSPSavePresentation@\texttt{PqSPSavePresentation}} \label{PqSPSavePresentation} }\hfill{\scriptsize (function)}}\\ \noindent\textcolor{FuncColor}{$\triangleright$\enspace\texttt{PqSPSavePresentation({\mdseries\slshape filename})\index{PqSPSavePresentation@\texttt{PqSPSavePresentation}!for default process} \label{PqSPSavePresentation:for default process} }\hfill{\scriptsize (function)}}\\ for the \mbox{\texttt{\mdseries\slshape i}}th or default interactive \textsf{ANUPQ} process, directs the \texttt{pq} program to save the standard presentation previously computed for the group of that process to the file with name \mbox{\texttt{\mdseries\slshape filename}}, where the group of a process is the one given as first argument when \texttt{PqStart} was called to initiate that process. If the first character of the string \mbox{\texttt{\mdseries\slshape filename}} is not \texttt{/}, \mbox{\texttt{\mdseries\slshape filename}} is assumed to be the path of a writable file relative to the directory in which \textsf{GAP} was started. \emph{Note:} For those familiar with the \texttt{pq} program, \texttt{PqSPSavePresentation} performs menu item 3 of the Standard Presentation menu. } \subsection{\textcolor{Chapter }{PqSPCompareTwoFilePresentations}} \logpage{[ 5, 8, 4 ]}\nobreak \hyperdef{L}{X81D2F9FF7C241D1E}{} {\noindent\textcolor{FuncColor}{$\triangleright$\enspace\texttt{PqSPCompareTwoFilePresentations({\mdseries\slshape i, f1, f2})\index{PqSPCompareTwoFilePresentations@\texttt{PqSPCompareTwoFilePresentations}} \label{PqSPCompareTwoFilePresentations} }\hfill{\scriptsize (function)}}\\ \noindent\textcolor{FuncColor}{$\triangleright$\enspace\texttt{PqSPCompareTwoFilePresentations({\mdseries\slshape f1, f2})\index{PqSPCompareTwoFilePresentations@\texttt{PqSPCompareTwoFilePresentations}!for default process} \label{PqSPCompareTwoFilePresentations:for default process} }\hfill{\scriptsize (function)}}\\ for the \mbox{\texttt{\mdseries\slshape i}}th or default interactive \textsf{ANUPQ} process, direct the \texttt{pq} program to compare the presentations in the files with names \mbox{\texttt{\mdseries\slshape f1}} and \mbox{\texttt{\mdseries\slshape f2}} and returns \texttt{true} if they are identical and \texttt{false} otherwise. For each of the strings \mbox{\texttt{\mdseries\slshape f1}} and \mbox{\texttt{\mdseries\slshape f2}}, if the first character is not a \texttt{/} then it is assumed to be the path of a readable file relative to the directory in which \textsf{GAP} was started. \emph{Notes} The presentations in files \mbox{\texttt{\mdseries\slshape f1}} and \mbox{\texttt{\mdseries\slshape f2}} must have been generated by the \texttt{pq} program but they do \emph{not} need to be \emph{standard} presentations. If If the presentations in files \mbox{\texttt{\mdseries\slshape f1}} and \mbox{\texttt{\mdseries\slshape f2}} \emph{have} been generated by \texttt{PqSPStandardPresentation} (see{\nobreakspace}\texttt{PqSPStandardPresentation} (\ref{PqSPStandardPresentation})) then a \texttt{false} response from \texttt{PqSPCompareTwoFilePresentations} says the groups defined by those presentations are \emph{not} isomorphic. For those familiar with the \texttt{pq} program, \texttt{PqSPCompareTwoFilePresentations} performs menu item 6 of the Standard Presentation menu. } \subsection{\textcolor{Chapter }{PqSPIsomorphism}} \logpage{[ 5, 8, 5 ]}\nobreak \hyperdef{L}{X7D1277E584590ECE}{} {\noindent\textcolor{FuncColor}{$\triangleright$\enspace\texttt{PqSPIsomorphism({\mdseries\slshape i})\index{PqSPIsomorphism@\texttt{PqSPIsomorphism}} \label{PqSPIsomorphism} }\hfill{\scriptsize (function)}}\\ \noindent\textcolor{FuncColor}{$\triangleright$\enspace\texttt{PqSPIsomorphism({\mdseries\slshape })\index{PqSPIsomorphism@\texttt{PqSPIsomorphism}!for default process} \label{PqSPIsomorphism:for default process} }\hfill{\scriptsize (function)}}\\ for the \mbox{\texttt{\mdseries\slshape i}}th or default interactive \textsf{ANUPQ} process, direct the \texttt{pq} program to compute the isomorphism mapping from the $p$\texttt{\symbol{45}}group of the process to its standard presentation. This function provides a description only; for a \textsf{GAP} object, use \texttt{EpimorphismStandardPresentation} (see{\nobreakspace}\texttt{EpimorphismStandardPresentation} (\ref{EpimorphismStandardPresentation:interactive})). \emph{Note:} For those familiar with the \texttt{pq} program, \texttt{PqSPIsomorphism} performs menu item 8 of the Standard Presentation menu. } } \section{\textcolor{Chapter }{Commands from the Main $p$\texttt{\symbol{45}}Group Generation menu}}\logpage{[ 5, 9, 0 ]} \hyperdef{L}{X8490031B7AA7F237}{} { Note that the $p$\texttt{\symbol{45}}group generation commands can only be applied once the \texttt{pq} program has produced a pc presentation of some quotient group of the ``group of the process''. \subsection{\textcolor{Chapter }{PqPGSupplyAutomorphisms}} \logpage{[ 5, 9, 1 ]}\nobreak \hyperdef{L}{X794A8D667A9D725A}{} {\noindent\textcolor{FuncColor}{$\triangleright$\enspace\texttt{PqPGSupplyAutomorphisms({\mdseries\slshape i[, mlist]: options})\index{PqPGSupplyAutomorphisms@\texttt{PqPGSupplyAutomorphisms}} \label{PqPGSupplyAutomorphisms} }\hfill{\scriptsize (function)}}\\ \noindent\textcolor{FuncColor}{$\triangleright$\enspace\texttt{PqPGSupplyAutomorphisms({\mdseries\slshape [mlist]: options})\index{PqPGSupplyAutomorphisms@\texttt{PqPGSupplyAutomorphisms}!for default process} \label{PqPGSupplyAutomorphisms:for default process} }\hfill{\scriptsize (function)}}\\ for the \mbox{\texttt{\mdseries\slshape i}}th or default interactive \textsf{ANUPQ} process, supply the \texttt{pq} program with the automorphism group data needed for the current quotient of the group of that process (for process \mbox{\texttt{\mdseries\slshape i}} the group is stored as \texttt{ANUPQData.io[\mbox{\texttt{\mdseries\slshape i}}].group}). For a description of the format of \mbox{\texttt{\mdseries\slshape mlist}} see{\nobreakspace}\texttt{PqSupplyAutomorphisms} (\ref{PqSupplyAutomorphisms}). The options possible are \texttt{NumberOfSolubleAutomorphisms} and \texttt{RelativeOrders}. (Detailed descriptions of these options may be found in Chapter{\nobreakspace}\hyperref[ANUPQ Options]{`ANUPQ Options'}.) If \mbox{\texttt{\mdseries\slshape mlist}} is omitted, the automorphism data is determined from the group of the process which must have been a $p$\texttt{\symbol{45}}group in pc presentation. \emph{Note:} For those familiar with the \texttt{pq} program, \texttt{PqPGSupplyAutomorphisms} performs menu item 1 of the main $p$\texttt{\symbol{45}}Group Generation menu. } \subsection{\textcolor{Chapter }{PqPGExtendAutomorphisms}} \logpage{[ 5, 9, 2 ]}\nobreak \hyperdef{L}{X87F251077C65B6DD}{} {\noindent\textcolor{FuncColor}{$\triangleright$\enspace\texttt{PqPGExtendAutomorphisms({\mdseries\slshape i})\index{PqPGExtendAutomorphisms@\texttt{PqPGExtendAutomorphisms}} \label{PqPGExtendAutomorphisms} }\hfill{\scriptsize (function)}}\\ \noindent\textcolor{FuncColor}{$\triangleright$\enspace\texttt{PqPGExtendAutomorphisms({\mdseries\slshape })\index{PqPGExtendAutomorphisms@\texttt{PqPGExtendAutomorphisms}!for default process} \label{PqPGExtendAutomorphisms:for default process} }\hfill{\scriptsize (function)}}\\ for the \mbox{\texttt{\mdseries\slshape i}}th or default interactive \textsf{ANUPQ} process, direct the \texttt{pq} program to compute the extensions of the automorphisms of the $p$\texttt{\symbol{45}}quotient of the previous class to the $p$\texttt{\symbol{45}}quotient of the current class. You may wish to set the \texttt{InfoLevel} of \texttt{InfoANUPQ} to 2 (or more) in order to see the output from the \texttt{pq} program (see{\nobreakspace}\texttt{InfoANUPQ} (\ref{InfoANUPQ})). \emph{Note:} For those familiar with the \texttt{pq} program, \texttt{PqPGExtendAutomorphisms} performs menu item 2 of the main or advanced $p$\texttt{\symbol{45}}Group Generation menu. } \subsection{\textcolor{Chapter }{PqPGConstructDescendants}} \logpage{[ 5, 9, 3 ]}\nobreak \hyperdef{L}{X82FD51A27D269E43}{} {\noindent\textcolor{FuncColor}{$\triangleright$\enspace\texttt{PqPGConstructDescendants({\mdseries\slshape i: options})\index{PqPGConstructDescendants@\texttt{PqPGConstructDescendants}} \label{PqPGConstructDescendants} }\hfill{\scriptsize (function)}}\\ \noindent\textcolor{FuncColor}{$\triangleright$\enspace\texttt{PqPGConstructDescendants({\mdseries\slshape : options})\index{PqPGConstructDescendants@\texttt{PqPGConstructDescendants}!for default process} \label{PqPGConstructDescendants:for default process} }\hfill{\scriptsize (function)}}\\ for the \mbox{\texttt{\mdseries\slshape i}}th or default interactive \textsf{ANUPQ} process, direct the \texttt{pq} program to construct descendants prescribed by \mbox{\texttt{\mdseries\slshape options}}, and return the number of descendants constructed (compare function{\nobreakspace}\texttt{PqDescendants} (\ref{PqDescendants}) which returns the list of descendants). The options possible are \texttt{ClassBound}, \texttt{OrderBound}, \texttt{StepSize}, \texttt{PcgsAutomorphisms}, \texttt{RankInitialSegmentSubgroups}, \texttt{SpaceEfficient}, \texttt{CapableDescendants}, \texttt{AllDescendants}, \texttt{Exponent}, \texttt{Metabelian}, \texttt{BasicAlgorithm}, \texttt{CustomiseOutput}. (Detailed descriptions of these options may be found in Chapter{\nobreakspace}\hyperref[ANUPQ Options]{`ANUPQ Options'}.) \texttt{PqPGConstructDescendants} requires that the \texttt{pq} program has previously computed a pc presentation and a $p$\texttt{\symbol{45}}cover for a $p$\texttt{\symbol{45}}quotient of some class of the group of the process. \emph{Note:} For those familiar with the \texttt{pq} program, \texttt{PqPGConstructDescendants} performs menu item 5 of the main $p$\texttt{\symbol{45}}Group Generation menu. } \subsection{\textcolor{Chapter }{PqPGSetDescendantToPcp (with class)}} \logpage{[ 5, 9, 4 ]}\nobreak \hyperdef{L}{X7E9D511385D48A98}{} {\noindent\textcolor{FuncColor}{$\triangleright$\enspace\texttt{PqPGSetDescendantToPcp({\mdseries\slshape i, cls, n})\index{PqPGSetDescendantToPcp@\texttt{PqPGSetDescendantToPcp}!with class} \label{PqPGSetDescendantToPcp:with class} }\hfill{\scriptsize (function)}}\\ \noindent\textcolor{FuncColor}{$\triangleright$\enspace\texttt{PqPGSetDescendantToPcp({\mdseries\slshape cls, n})\index{PqPGSetDescendantToPcp@\texttt{PqPGSetDescendantToPcp}!with class, for default process} \label{PqPGSetDescendantToPcp:with class, for default process} }\hfill{\scriptsize (function)}}\\ \noindent\textcolor{FuncColor}{$\triangleright$\enspace\texttt{PqPGSetDescendantToPcp({\mdseries\slshape i: [Filename := name]})\index{PqPGSetDescendantToPcp@\texttt{PqPGSetDescendantToPcp}} \label{PqPGSetDescendantToPcp} }\hfill{\scriptsize (function)}}\\ \noindent\textcolor{FuncColor}{$\triangleright$\enspace\texttt{PqPGSetDescendantToPcp({\mdseries\slshape : [Filename := name]})\index{PqPGSetDescendantToPcp@\texttt{PqPGSetDescendantToPcp}!for default process} \label{PqPGSetDescendantToPcp:for default process} }\hfill{\scriptsize (function)}}\\ \noindent\textcolor{FuncColor}{$\triangleright$\enspace\texttt{PqPGRestoreDescendantFromFile({\mdseries\slshape i, cls, n})\index{PqPGRestoreDescendantFromFile@\texttt{PqPGRestoreDescendantFromFile}!with class} \label{PqPGRestoreDescendantFromFile:with class} }\hfill{\scriptsize (function)}}\\ \noindent\textcolor{FuncColor}{$\triangleright$\enspace\texttt{PqPGRestoreDescendantFromFile({\mdseries\slshape cls, n})\index{PqPGRestoreDescendantFromFile@\texttt{PqPGRestoreDescendantFromFile}!with class, for default process} \label{PqPGRestoreDescendantFromFile:with class, for default process} }\hfill{\scriptsize (function)}}\\ \noindent\textcolor{FuncColor}{$\triangleright$\enspace\texttt{PqPGRestoreDescendantFromFile({\mdseries\slshape i: [Filename := name]})\index{PqPGRestoreDescendantFromFile@\texttt{PqPGRestoreDescendantFromFile}} \label{PqPGRestoreDescendantFromFile} }\hfill{\scriptsize (function)}}\\ \noindent\textcolor{FuncColor}{$\triangleright$\enspace\texttt{PqPGRestoreDescendantFromFile({\mdseries\slshape : [Filename := name]})\index{PqPGRestoreDescendantFromFile@\texttt{PqPGRestoreDescendantFromFile}!for default process} \label{PqPGRestoreDescendantFromFile:for default process} }\hfill{\scriptsize (function)}}\\ for the \mbox{\texttt{\mdseries\slshape i}}th or default interactive \textsf{ANUPQ} process, direct the \texttt{pq} program to restore group \mbox{\texttt{\mdseries\slshape n}} of class \mbox{\texttt{\mdseries\slshape cls}} from a temporary file, where \mbox{\texttt{\mdseries\slshape cls}} and \mbox{\texttt{\mdseries\slshape n}} are positive integers, or the group stored in \mbox{\texttt{\mdseries\slshape name}}. \texttt{PqPGSetDescendantToPcp} and \texttt{PqPGRestoreDescendantFromFile} are synonyms; they make sense only after a prior call to construct descendants by say \texttt{PqPGConstructDescendants} (see{\nobreakspace}\texttt{PqPGConstructDescendants} (\ref{PqPGConstructDescendants})) or the interactive \texttt{PqDescendants} (see{\nobreakspace}\texttt{PqDescendants} (\ref{PqDescendants:interactive})). In the \texttt{Filename} option forms, the option defaults to the last filename in which a presentation was stored by the \texttt{pq} program. \emph{Notes} Since the \texttt{PqPGSetDescendantToPcp} and \texttt{PqPGRestoreDescendantFromFile} are intended to be used in calculation of further descendants the \texttt{pq} program computes the $p$\texttt{\symbol{45}}cover of the restored descendant. Hence, \texttt{PqCurrentGroup} used immediately after one of these commands returns the $p$\texttt{\symbol{45}}cover of the restored descendant rather than the descendant itself. For those familiar with the \texttt{pq} program, \texttt{PqPGSetDescendantToPcp} and \texttt{PqPGRestoreDescendantFromFile} perform menu item 3 of the main or advanced $p$\texttt{\symbol{45}}Group Generation menu. } } \section{\textcolor{Chapter }{Commands from the Advanced $p$\texttt{\symbol{45}}Group Generation menu}}\logpage{[ 5, 10, 0 ]} \hyperdef{L}{X7E8FBC2D83C43481}{} { The functions below perform the component algorithms of \texttt{PqPGConstructDescendants} (see{\nobreakspace}\texttt{PqPGConstructDescendants} (\ref{PqPGConstructDescendants})). You can get some idea of their usage by trying \texttt{PqExample("Nott\texttt{\symbol{45}}APG\texttt{\symbol{45}}Rel\texttt{\symbol{45}}i");}. You can get some idea of the breakdown of \texttt{PqPGConstructDescendants} into these functions by comparing the previous output with \texttt{PqExample("Nott\texttt{\symbol{45}}PG\texttt{\symbol{45}}Rel\texttt{\symbol{45}}i");}. These functions are intended for use only by ``experts''; please contact the authors of the package if you genuinely have a need for them and need any amplified descriptions. \subsection{\textcolor{Chapter }{PqAPGDegree}} \logpage{[ 5, 10, 1 ]}\nobreak \hyperdef{L}{X7E539E4B78A6CE8D}{} {\noindent\textcolor{FuncColor}{$\triangleright$\enspace\texttt{PqAPGDegree({\mdseries\slshape i, step, rank: [Exponent := n]})\index{PqAPGDegree@\texttt{PqAPGDegree}} \label{PqAPGDegree} }\hfill{\scriptsize (function)}}\\ \noindent\textcolor{FuncColor}{$\triangleright$\enspace\texttt{PqAPGDegree({\mdseries\slshape step, rank: [Exponent := n]})\index{PqAPGDegree@\texttt{PqAPGDegree}!for default process} \label{PqAPGDegree:for default process} }\hfill{\scriptsize (function)}}\\ for the \mbox{\texttt{\mdseries\slshape i}}th or default interactive \textsf{ANUPQ} process, direct the \texttt{pq} program to invoke menu item 6 of the Advanced $p$\texttt{\symbol{45}}Group Generation menu. Here the step\texttt{\symbol{45}}size \mbox{\texttt{\mdseries\slshape step}} and the rank \mbox{\texttt{\mdseries\slshape rank}} are positive integers and are the arguments required by the \texttt{pq} program. See{\nobreakspace}\ref{option Exponent} for the one recognised option \texttt{Exponent}. } \subsection{\textcolor{Chapter }{PqAPGPermutations}} \logpage{[ 5, 10, 2 ]}\nobreak \hyperdef{L}{X7F1182A77AB7650C}{} {\noindent\textcolor{FuncColor}{$\triangleright$\enspace\texttt{PqAPGPermutations({\mdseries\slshape i: options})\index{PqAPGPermutations@\texttt{PqAPGPermutations}} \label{PqAPGPermutations} }\hfill{\scriptsize (function)}}\\ \noindent\textcolor{FuncColor}{$\triangleright$\enspace\texttt{PqAPGPermutations({\mdseries\slshape : options})\index{PqAPGPermutations@\texttt{PqAPGPermutations}!for default process} \label{PqAPGPermutations:for default process} }\hfill{\scriptsize (function)}}\\ for the \mbox{\texttt{\mdseries\slshape i}}th or default interactive \textsf{ANUPQ} process, direct the \texttt{pq} program to perform menu item 7 of the Advanced $p$\texttt{\symbol{45}}Group Generation menu. Here the options \mbox{\texttt{\mdseries\slshape options}} recognised are \texttt{PcgsAutomorphisms}, \texttt{SpaceEfficient}, \texttt{PrintAutomorphisms} and \texttt{PrintPermutations} (see Chapter{\nobreakspace}\hyperref[ANUPQ Options]{`ANUPQ Options'} for details). } \subsection{\textcolor{Chapter }{PqAPGOrbits}} \logpage{[ 5, 10, 3 ]}\nobreak \hyperdef{L}{X7DD9E7507AA888CC}{} {\noindent\textcolor{FuncColor}{$\triangleright$\enspace\texttt{PqAPGOrbits({\mdseries\slshape i: options})\index{PqAPGOrbits@\texttt{PqAPGOrbits}} \label{PqAPGOrbits} }\hfill{\scriptsize (function)}}\\ \noindent\textcolor{FuncColor}{$\triangleright$\enspace\texttt{PqAPGOrbits({\mdseries\slshape : options})\index{PqAPGOrbits@\texttt{PqAPGOrbits}!for default process} \label{PqAPGOrbits:for default process} }\hfill{\scriptsize (function)}}\\ for the \mbox{\texttt{\mdseries\slshape i}}th or default interactive \textsf{ANUPQ} process, direct the \texttt{pq} to perform menu item 8 of the Advanced $p$\texttt{\symbol{45}}Group Generation menu. Here the options \mbox{\texttt{\mdseries\slshape options}} recognised are \texttt{PcgsAutomorphisms}, \texttt{SpaceEfficient} and \texttt{CustomiseOutput} (see Chapter{\nobreakspace}\hyperref[ANUPQ Options]{`ANUPQ Options'} for details). For the \texttt{CustomiseOutput} option only the setting of the \texttt{orbit} is recognised (all other fields if set are ignored). } \subsection{\textcolor{Chapter }{PqAPGOrbitRepresentatives}} \logpage{[ 5, 10, 4 ]}\nobreak \hyperdef{L}{X795A756C78BE5923}{} {\noindent\textcolor{FuncColor}{$\triangleright$\enspace\texttt{PqAPGOrbitRepresentatives({\mdseries\slshape i: options})\index{PqAPGOrbitRepresentatives@\texttt{PqAPGOrbitRepresentatives}} \label{PqAPGOrbitRepresentatives} }\hfill{\scriptsize (function)}}\\ \noindent\textcolor{FuncColor}{$\triangleright$\enspace\texttt{PqAPGOrbitRepresentatives({\mdseries\slshape : options})\index{PqAPGOrbitRepresentatives@\texttt{PqAPGOrbitRepresentatives}!for default process} \label{PqAPGOrbitRepresentatives:for default process} }\hfill{\scriptsize (function)}}\\ for the \mbox{\texttt{\mdseries\slshape i}}th or default interactive \textsf{ANUPQ} process, direct the \texttt{pq} to perform item 9 of the Advanced $p$\texttt{\symbol{45}}Group Generation menu. The options \mbox{\texttt{\mdseries\slshape options}} may be any selection of the following: \texttt{PcgsAutomorphisms}, \texttt{SpaceEfficient}, \texttt{Exponent}, \texttt{Metabelian}, \texttt{CapableDescendants} (or \texttt{AllDescendants}), \texttt{CustomiseOutput} (where only the \texttt{group} and \texttt{autgroup} fields are recognised) and \texttt{Filename} (see Chapter{\nobreakspace}\hyperref[ANUPQ Options]{`ANUPQ Options'} for details). If \texttt{Filename} is omitted the reduced $p$\texttt{\symbol{45}}cover is written to the file \texttt{"redPCover"} in the temporary directory whose name is stored in \texttt{ANUPQData.tmpdir}. } \subsection{\textcolor{Chapter }{PqAPGSingleStage}} \logpage{[ 5, 10, 5 ]}\nobreak \hyperdef{L}{X7E5D6D5782FE190E}{} {\noindent\textcolor{FuncColor}{$\triangleright$\enspace\texttt{PqAPGSingleStage({\mdseries\slshape i: options})\index{PqAPGSingleStage@\texttt{PqAPGSingleStage}} \label{PqAPGSingleStage} }\hfill{\scriptsize (function)}}\\ \noindent\textcolor{FuncColor}{$\triangleright$\enspace\texttt{PqAPGSingleStage({\mdseries\slshape : options})\index{PqAPGSingleStage@\texttt{PqAPGSingleStage}!for default process} \label{PqAPGSingleStage:for default process} }\hfill{\scriptsize (function)}}\\ for the \mbox{\texttt{\mdseries\slshape i}}th or default interactive \textsf{ANUPQ} process, direct the \texttt{pq} to perform option 5 of the Advanced $p$\texttt{\symbol{45}}Group Generation menu. The possible options are \texttt{StepSize}, \texttt{PcgsAutomorphisms}, \texttt{RankInitialSegmentSubgroups}, \texttt{SpaceEfficient}, \texttt{CapableDescendants}, \texttt{AllDescendants}, \texttt{Exponent}, \texttt{Metabelian}, \texttt{BasicAlgorithm} and \texttt{CustomiseOutput}. (Detailed descriptions of these options may be found in Chapter{\nobreakspace}\hyperref[ANUPQ Options]{`ANUPQ Options'}.) } } \section{\textcolor{Chapter }{Primitive Interactive ANUPQ Process Read/Write Functions}}\label{Primitive Interactive ANUPQ Process Read/Write Functions} \logpage{[ 5, 11, 0 ]} \hyperdef{L}{X84A92E8087762DEE}{} { For those familiar with using the \texttt{pq} program as a standalone we provide primitive read/write tools to communicate directly with an interactive \textsf{ANUPQ} process, started via \texttt{PqStart}. For the most part, it is up to the user to translate the output strings from \texttt{pq} program into a form useful in \textsf{GAP}. \subsection{\textcolor{Chapter }{PqRead}} \logpage{[ 5, 11, 1 ]}\nobreak \hyperdef{L}{X8464AF7E83A523C1}{} {\noindent\textcolor{FuncColor}{$\triangleright$\enspace\texttt{PqRead({\mdseries\slshape i})\index{PqRead@\texttt{PqRead}} \label{PqRead} }\hfill{\scriptsize (function)}}\\ \noindent\textcolor{FuncColor}{$\triangleright$\enspace\texttt{PqRead({\mdseries\slshape })\index{PqRead@\texttt{PqRead}!for default process} \label{PqRead:for default process} }\hfill{\scriptsize (function)}}\\ read a complete line of \textsf{ANUPQ} output, from the \mbox{\texttt{\mdseries\slshape i}}th or default interactive \textsf{ANUPQ} process, if there is output to be read and returns \texttt{fail} otherwise. When successful, the line is returned as a string complete with trailing newline, colon, or question\texttt{\symbol{45}}mark character. Please note that it is possible to be ``too quick'' (i.e.{\nobreakspace}the return can be \texttt{fail} purely because the output from \textsf{ANUPQ} is not there yet), but if \texttt{PqRead} finds any output at all, it waits for a complete line. \texttt{PqRead} also writes the line read via \texttt{Info} at \texttt{InfoANUPQ} level 2. It doesn't try to distinguish banner and menu output from other output of the \texttt{pq} program. } \subsection{\textcolor{Chapter }{PqReadAll}} \logpage{[ 5, 11, 2 ]}\nobreak \hyperdef{L}{X7ADD82207D049A87}{} {\noindent\textcolor{FuncColor}{$\triangleright$\enspace\texttt{PqReadAll({\mdseries\slshape i})\index{PqReadAll@\texttt{PqReadAll}} \label{PqReadAll} }\hfill{\scriptsize (function)}}\\ \noindent\textcolor{FuncColor}{$\triangleright$\enspace\texttt{PqReadAll({\mdseries\slshape })\index{PqReadAll@\texttt{PqReadAll}!for default process} \label{PqReadAll:for default process} }\hfill{\scriptsize (function)}}\\ read and return as many \emph{complete} lines of \textsf{ANUPQ} output, from the \mbox{\texttt{\mdseries\slshape i}}th or default interactive \textsf{ANUPQ} process, as there are to be read, \emph{at the time of the call}, as a list of strings with any trailing newlines removed and returns the empty list otherwise. \texttt{PqReadAll} also writes each line read via \texttt{Info} at \texttt{InfoANUPQ} level 2. It doesn't try to distinguish banner and menu output from other output of the \texttt{pq} program. Whenever \texttt{PqReadAll} finds only a partial line, it waits for the complete line, thus increasing the probability that it has captured all the output to be had from \textsf{ANUPQ}. } \subsection{\textcolor{Chapter }{PqReadUntil}} \logpage{[ 5, 11, 3 ]}\nobreak \hyperdef{L}{X7EBF3C3681671879}{} {\noindent\textcolor{FuncColor}{$\triangleright$\enspace\texttt{PqReadUntil({\mdseries\slshape i, IsMyLine})\index{PqReadUntil@\texttt{PqReadUntil}} \label{PqReadUntil} }\hfill{\scriptsize (function)}}\\ \noindent\textcolor{FuncColor}{$\triangleright$\enspace\texttt{PqReadUntil({\mdseries\slshape IsMyLine})\index{PqReadUntil@\texttt{PqReadUntil}!for default process} \label{PqReadUntil:for default process} }\hfill{\scriptsize (function)}}\\ \noindent\textcolor{FuncColor}{$\triangleright$\enspace\texttt{PqReadUntil({\mdseries\slshape i, IsMyLine, Modify})\index{PqReadUntil@\texttt{PqReadUntil}!with modify map} \label{PqReadUntil:with modify map} }\hfill{\scriptsize (function)}}\\ \noindent\textcolor{FuncColor}{$\triangleright$\enspace\texttt{PqReadUntil({\mdseries\slshape IsMyLine, Modify})\index{PqReadUntil@\texttt{PqReadUntil}!with modify map, for default process} \label{PqReadUntil:with modify map, for default process} }\hfill{\scriptsize (function)}}\\ read complete lines of \textsf{ANUPQ} output, from the \mbox{\texttt{\mdseries\slshape i}}th or default interactive \textsf{ANUPQ} process, ``chomps'' them (i.e.{\nobreakspace}removes any trailing newline character), emits them to \texttt{Info} at \texttt{InfoANUPQ} level 2 (without trying to distinguish banner and menu output from other output of the \texttt{pq} program), and applies the function \mbox{\texttt{\mdseries\slshape Modify}} (where \mbox{\texttt{\mdseries\slshape Modify}} is just the identity map/function for the first two forms) until a ``chomped'' line \mbox{\texttt{\mdseries\slshape line}} for which \texttt{\mbox{\texttt{\mdseries\slshape IsMyLine}}( \mbox{\texttt{\mdseries\slshape Modify}}(\mbox{\texttt{\mdseries\slshape line}}) )} is true. \texttt{PqReadUntil} returns the list of \mbox{\texttt{\mdseries\slshape Modify}}\texttt{\symbol{45}}ed ``chomped'' lines read. \emph{Notes:} When provided by the user, \mbox{\texttt{\mdseries\slshape Modify}} should be a function that accepts a single string argument. \mbox{\texttt{\mdseries\slshape IsMyLine}} should be a function that is able to accept the output of \mbox{\texttt{\mdseries\slshape Modify}} (or take a single string argument when \mbox{\texttt{\mdseries\slshape Modify}} is not provided) and should return a boolean. If \texttt{\mbox{\texttt{\mdseries\slshape IsMyLine}}( \mbox{\texttt{\mdseries\slshape Modify}}(\mbox{\texttt{\mdseries\slshape line}}) )} is never true, \texttt{PqReadUntil} will wait indefinitely. } \subsection{\textcolor{Chapter }{PqWrite}} \logpage{[ 5, 11, 4 ]}\nobreak \hyperdef{L}{X83CBE77F78057E21}{} {\noindent\textcolor{FuncColor}{$\triangleright$\enspace\texttt{PqWrite({\mdseries\slshape i, string})\index{PqWrite@\texttt{PqWrite}} \label{PqWrite} }\hfill{\scriptsize (function)}}\\ \noindent\textcolor{FuncColor}{$\triangleright$\enspace\texttt{PqWrite({\mdseries\slshape string})\index{PqWrite@\texttt{PqWrite}!for default process} \label{PqWrite:for default process} }\hfill{\scriptsize (function)}}\\ write \mbox{\texttt{\mdseries\slshape string}} to the \mbox{\texttt{\mdseries\slshape i}}th or default interactive \textsf{ANUPQ} process; \mbox{\texttt{\mdseries\slshape string}} must be in exactly the form the \textsf{ANUPQ} standalone expects. The command is echoed via \texttt{Info} at \texttt{InfoANUPQ} level 3 (with a ``\texttt{ToPQ{\textgreater} }'' prompt); i.e.{\nobreakspace}do \texttt{SetInfoLevel(InfoANUPQ, 3);} to see what is transmitted to the \texttt{pq} program. \texttt{PqWrite} returns \texttt{true} if successful in writing to the stream of the interactive \textsf{ANUPQ} process, and \texttt{fail} otherwise. \emph{Note:} If \texttt{PqWrite} returns \texttt{fail} it means that the \textsf{ANUPQ} process has died. } } } \chapter{\textcolor{Chapter }{ANUPQ Options}}\label{ANUPQ Options} \logpage{[ 6, 0, 0 ]} \hyperdef{L}{X7B0946E97E7EB359}{} { \section{\textcolor{Chapter }{Overview}}\logpage{[ 6, 1, 0 ]} \hyperdef{L}{X8389AD927B74BA4A}{} { In this chapter we describe in detail all the options used by functions of the \textsf{ANUPQ} package. Note that by ``options'' we mean \textsf{GAP} options that are passed to functions after the arguments and separated from the arguments by a colon as described in Chapter{\nobreakspace} \textbf{Reference: Function Calls} in the Reference Manual. The user is strongly advised to read Section{\nobreakspace}\hyperref[Hints and Warnings regarding the use of Options]{`Hints and Warnings regarding the use of Options'}. \subsection{\textcolor{Chapter }{AllANUPQoptions}} \logpage{[ 6, 1, 1 ]}\nobreak \hyperdef{L}{X7846E25D8065D78F}{} {\noindent\textcolor{FuncColor}{$\triangleright$\enspace\texttt{AllANUPQoptions({\mdseries\slshape })\index{AllANUPQoptions@\texttt{AllANUPQoptions}} \label{AllANUPQoptions} }\hfill{\scriptsize (function)}}\\ lists all the \textsf{GAP} options defined for functions of the \textsf{ANUPQ} package: \begin{Verbatim}[commandchars=!@|,fontsize=\small,frame=single,label=Example] !gapprompt@gap>| !gapinput@AllANUPQoptions();| [ "AllDescendants", "BasicAlgorithm", "Bounds", "CapableDescendants", "ClassBound", "CustomiseOutput", "Exponent", "Filename", "GroupName", "Identities", "Metabelian", "NumberOfSolubleAutomorphisms", "OrderBound", "OutputLevel", "PcgsAutomorphisms", "PqWorkspace", "Prime", "PrintAutomorphisms", "PrintPermutations", "QueueFactor", "RankInitialSegmentSubgroups", "RedoPcp", "RelativeOrders", "Relators", "SetupFile", "SpaceEfficient", "StandardPresentationFile", "StepSize", "SubList", "TreeDepth", "pQuotient" ] \end{Verbatim} } The following global variable gives a partial breakdown of where the above options are used. \subsection{\textcolor{Chapter }{ANUPQoptions}} \logpage{[ 6, 1, 2 ]}\nobreak \hyperdef{L}{X82D560C77D195089}{} {\noindent\textcolor{FuncColor}{$\triangleright$\enspace\texttt{ANUPQoptions\index{ANUPQoptions@\texttt{ANUPQoptions}} \label{ANUPQoptions} }\hfill{\scriptsize (global variable)}}\\ is a record of lists of names of admissible \textsf{ANUPQ} options, such that each field is either the name of a ``key'' \textsf{ANUPQ} function or \texttt{other} (for a miscellaneous list of functions) and the corresponding value is the list of option names that are admissible for the function (or miscellaneous list of functions). Also, from within a \textsf{GAP} session, you may use \textsf{GAP}'s help browser (see Chapter{\nobreakspace} \textbf{Reference: The Help System} in the \textsf{GAP} Reference Manual); to find out about any particular \textsf{ANUPQ} option, simply type: ``\texttt{?option \mbox{\texttt{\mdseries\slshape option}}}'', where \mbox{\texttt{\mdseries\slshape option}} is one of the options listed above without any quotes, e.g. \begin{Verbatim}[commandchars=!@|,fontsize=\small,frame=single,label=Example] !gapprompt@gap>| !gapinput@?option Prime| \end{Verbatim} will display the sections in this manual that describe the \texttt{Prime} option. In fact the first 4 are for the functions that have \texttt{Prime} as an option and the last actually describes the option. So follow up by choosing \begin{Verbatim}[commandchars=!@|,fontsize=\small,frame=single,label=Example] !gapprompt@gap>| !gapinput@?5| \end{Verbatim} This is also the pattern for other options (the last section of the list always describes the option; the other sections are the functions with which the option may be used). In the section following we describe in detail all \textsf{ANUPQ} options. To continue onto the next section on\texttt{\symbol{45}}line using \textsf{GAP}'s help browser, type: \begin{Verbatim}[commandchars=!@|,fontsize=\small,frame=single,label=Example] !gapprompt@gap>| !gapinput@?>| \end{Verbatim} } } \section{\textcolor{Chapter }{Detailed descriptions of ANUPQ Options}}\label{Detailed descriptions of ANUPQ Options} \logpage{[ 6, 2, 0 ]} \hyperdef{L}{X87EE6DD67C9996A3}{} { \begin{description} \item[{\texttt{Prime := \mbox{\texttt{\mdseries\slshape p}}} \label{option Prime}\index{option Prime}}] Specifies that the $p$\texttt{\symbol{45}}quotient for the prime \mbox{\texttt{\mdseries\slshape p}} should be computed. \item[{\texttt{ClassBound := \mbox{\texttt{\mdseries\slshape n}}} \label{option ClassBound}\index{option ClassBound}}] Specifies that the $p$\texttt{\symbol{45}}quotient to be computed has lower exponent\texttt{\symbol{45}}$p$ class at most \mbox{\texttt{\mdseries\slshape n}}. If this option is omitted a default of 63 (which is the maximum possible for the \texttt{pq} program) is taken, except for \texttt{PqDescendants} (see{\nobreakspace}\texttt{PqDescendants} (\ref{PqDescendants})) and in a special case of \texttt{PqPCover} (see{\nobreakspace}\texttt{PqPCover} (\ref{PqPCover})). Let \mbox{\texttt{\mdseries\slshape F}} be the argument (or start group of the process in the interactive case) for the function; then for \texttt{PqDescendants} the default is \texttt{PClassPGroup(\mbox{\texttt{\mdseries\slshape F}}) + 1}, and for the special case of \texttt{PqPCover} the default is \texttt{PClassPGroup(\mbox{\texttt{\mdseries\slshape F}})}. \item[{\texttt{pQuotient := \mbox{\texttt{\mdseries\slshape Q}}} \label{option pQuotient}\index{option pQuotient}}] This option is only available for the standard presentation functions. It specifies that a $p$\texttt{\symbol{45}}quotient of the group argument of the function or group of the process is the pc \mbox{\texttt{\mdseries\slshape p}}\texttt{\symbol{45}}group \mbox{\texttt{\mdseries\slshape Q}}, where \mbox{\texttt{\mdseries\slshape Q}} is of class \emph{less than} the provided (or default) value of \texttt{ClassBound}. If \texttt{pQuotient} is provided, then the option \texttt{Prime} if also provided, is ignored; the prime \mbox{\texttt{\mdseries\slshape p}} is discovered by computing \texttt{PrimePGroup(\mbox{\texttt{\mdseries\slshape Q}})}. \item[{\texttt{Exponent := \mbox{\texttt{\mdseries\slshape n}}} \label{option Exponent}\index{option Exponent}}] Specifies that the $p$\texttt{\symbol{45}}quotient to be computed has exponent \mbox{\texttt{\mdseries\slshape n}}. For an interactive process, \texttt{Exponent} defaults to a previously supplied value for the process. Otherwise (and non\texttt{\symbol{45}}interactively), the default is 0, which means that no exponent law is enforced. \item[{\texttt{Relators := \mbox{\texttt{\mdseries\slshape rels}}} \label{option Relators}\index{option Relators}}] Specifies that the relators sent to the \texttt{pq} program should be \mbox{\texttt{\mdseries\slshape rels}} instead of the relators of the argument group \mbox{\texttt{\mdseries\slshape F}} (or start group in the interactive case) of the calling function; \mbox{\texttt{\mdseries\slshape rels}} should be a list of \emph{strings} in the string representations of the generators of \mbox{\texttt{\mdseries\slshape F}}, and \mbox{\texttt{\mdseries\slshape F}} must be an \emph{fp group} (even if the calling function accepts a pc group). This option provides a way of giving relators to the \texttt{pq} program, without having them pre\texttt{\symbol{45}}expanded by \textsf{GAP}, which can sometimes effect a performance loss of the order of 100 (see Section{\nobreakspace}\hyperref[The Relators Option]{`The Relators Option'}). \emph{Notes} \begin{enumerate} \item The \texttt{pq} program does not use \texttt{/} to indicate multiplication by an inverse and uses square brackets to represent (left normed) commutators. Also, even though the \texttt{pq} program accepts relations, all elements of \mbox{\texttt{\mdseries\slshape rels}} \emph{must} be in relator form, i.e.{\nobreakspace}a relation of form \texttt{\mbox{\texttt{\mdseries\slshape w1}} = \mbox{\texttt{\mdseries\slshape w2}}} must be written as \texttt{\mbox{\texttt{\mdseries\slshape w1}}*(\mbox{\texttt{\mdseries\slshape w2}})\texttt{\symbol{94}}\texttt{\symbol{45}}1} and then put in a pair of double\texttt{\symbol{45}}quotes to make it a string. See the example below. \item To ensure there are no syntax errors in \mbox{\texttt{\mdseries\slshape rels}}, each relator is parsed for validity via \texttt{PqParseWord} (see{\nobreakspace}\texttt{PqParseWord} (\ref{PqParseWord})). If they are ok, a message to say so is \texttt{Info}\texttt{\symbol{45}}ed at \texttt{InfoANUPQ} level 2. \end{enumerate} \item[{\texttt{Metabelian} \label{option Metabelian}\index{option Metabelian}}] Specifies that the largest metabelian $p$\texttt{\symbol{45}}quotient subject to any other conditions specified by other options be constructed. By default this restriction is not enforced. \item[{\texttt{GroupName := \mbox{\texttt{\mdseries\slshape name}}} \label{option GroupName}\index{option GroupName}}] Specifies that the \texttt{pq} program should refer to the group by the name \mbox{\texttt{\mdseries\slshape name}} (a string). If \texttt{GroupName} is not set and the group has been assigned a name via \texttt{SetName} (see{\nobreakspace} \textbf{Reference: Name}) it is set as the name the \texttt{pq} program should use. Otherwise, the ``generic'' name \texttt{"[grp]"} is set as a default. \item[{\texttt{Identities := \mbox{\texttt{\mdseries\slshape funcs}}} \label{option Identities}\index{option Identities}}] Specifies that the pc presentation should satisfy the laws defined by each function in the list \mbox{\texttt{\mdseries\slshape funcs}}. This option may be called by \texttt{Pq}, \texttt{PqEpimorphism}, or \texttt{PqPCover} (see{\nobreakspace}\texttt{Pq} (\ref{Pq})). Each function in the list \mbox{\texttt{\mdseries\slshape funcs}} must return a word in its arguments (there may be any number of arguments). Let \mbox{\texttt{\mdseries\slshape identity}} be one such function in \mbox{\texttt{\mdseries\slshape funcs}}. Then as each lower exponent \mbox{\texttt{\mdseries\slshape p}}\texttt{\symbol{45}}class quotient is formed, instances $\mbox{\texttt{\mdseries\slshape identity}}(\mbox{\texttt{\mdseries\slshape w1}}, \dots, \mbox{\texttt{\mdseries\slshape wn}})$ are added as relators to the pc presentation, where $\mbox{\texttt{\mdseries\slshape w1}}, \dots, \mbox{\texttt{\mdseries\slshape wn}}$ are words in the pc generators of the quotient. At each class the class and number of pc generators is \texttt{Info}\texttt{\symbol{45}}ed at \texttt{InfoANUPQ} level 1, the number of instances is \texttt{Info}\texttt{\symbol{45}}ed at \texttt{InfoANUPQ} level 2, and the instances that are evaluated are \texttt{Info}\texttt{\symbol{45}}ed at \texttt{InfoANUPQ} level 3. As usual timing information is \texttt{Info}\texttt{\symbol{45}}ed at \texttt{InfoANUPQ} level 2; and details of the processing of each instance from the \texttt{pq} program (which is often quite \emph{voluminous}) is \texttt{Info}\texttt{\symbol{45}}ed at \texttt{InfoANUPQ} level 3. Try the examples \texttt{"B2\texttt{\symbol{45}}4\texttt{\symbol{45}}Id"} and \texttt{"11gp\texttt{\symbol{45}}3\texttt{\symbol{45}}Engel\texttt{\symbol{45}}Id"} which demonstrate the usage of the \texttt{Identities} option; these are run using \texttt{PqExample} (see{\nobreakspace}\texttt{PqExample} (\ref{PqExample})). Take note of Note 1.{\nobreakspace}below in relation to the example \texttt{"B2\texttt{\symbol{45}}4\texttt{\symbol{45}}Id"}; the companion example \texttt{"B2\texttt{\symbol{45}}4"} generates the same group using the \texttt{Exponent} option. These examples are discussed at length in Section{\nobreakspace}\hyperref[The Identities Option and PqEvaluateIdentities Function]{`The Identities Option and PqEvaluateIdentities Function'}. \emph{Notes} \begin{enumerate} \item Setting the \texttt{InfoANUPQ} level to 3 or more when setting the \texttt{Identities} option may slow down the computation considerably, by overloading \textsf{GAP} with io operations. \item The \texttt{Identities} option is implemented at the \textsf{GAP} level. An identity that is just an exponent law should be specified using the \texttt{Exponent} option (see{\nobreakspace}\texttt{option Exponent} (\ref{option Exponent})), which is implemented at the C level and is highly optimised and so is much more efficient. \item The number of instances of each identity tends to grow combinatorially with the class. So \emph{care} should be exercised in using the \texttt{Identities} option, by including other restrictions, e.g.{\nobreakspace}by using the \texttt{ClassBound} option (see{\nobreakspace}\texttt{option ClassBound} (\ref{option ClassBound})). \end{enumerate} \item[{\texttt{OutputLevel := \mbox{\texttt{\mdseries\slshape n}}} \label{option OutputLevel}\index{option OutputLevel}}] Specifies the level of ``verbosity'' of the information output by the ANU \texttt{pq} program when computing a pc presentation; \mbox{\texttt{\mdseries\slshape n}} must be an integer in the range 0 to 3. \texttt{OutputLevel := 0} displays at most one line of output and is the default; \texttt{OutputLevel := 1} displays (usually) slightly more output and \texttt{OutputLevel}s of 2 and 3 are two levels of verbose output. To see these messages from the \texttt{pq} program, the \texttt{InfoANUPQ} level must be set to at least 1 (see{\nobreakspace}\texttt{InfoANUPQ} (\ref{InfoANUPQ})). See Section{\nobreakspace}\hyperref[Hints and Warnings regarding the use of Options]{`Hints and Warnings regarding the use of Options'} for an example of how \texttt{OutputLevel} can be used as a troubleshooting tool. \item[{\texttt{RedoPcp} \label{option RedoPcp}\index{option RedoPcp}}] Specifies that the current pc presentation (for an interactive process) stored by the \texttt{pq} program be scrapped and clears the current values stored for the options \texttt{Prime}, \texttt{ClassBound}, \texttt{Exponent} and \texttt{Metabelian} and also clears the \texttt{pQuotient}, \texttt{pQepi} and \texttt{pCover} fields of the data record of the process. \item[{\texttt{SetupFile := \mbox{\texttt{\mdseries\slshape filename}}} \label{option SetupFile}\index{option SetupFile}}] Non\texttt{\symbol{45}}interactively, this option directs that \texttt{pq} should not be called and that an input file with name \mbox{\texttt{\mdseries\slshape filename}} (a string), containing the commands necessary for the ANU \texttt{pq} standalone, be constructed. The commands written to \mbox{\texttt{\mdseries\slshape filename}} are also \texttt{Info}\texttt{\symbol{45}}ed behind a ``\texttt{ToPQ{\textgreater} }'' prompt at \texttt{InfoANUPQ} level 4 (see{\nobreakspace}\texttt{InfoANUPQ} (\ref{InfoANUPQ})). Except in the case following, the calling function returns \texttt{true}. If the calling function is the non\texttt{\symbol{45}}interactive version of one of \texttt{Pq}, \texttt{PqPCover} or \texttt{PqEpimorphism} and the group provided as argument is trivial given with an empty set of generators, then no setup file is written and \texttt{fail} is returned (the \texttt{pq} program cannot do anything useful with such a group). Interactively, \texttt{SetupFile} is ignored. \emph{Note:} Since commands emitted to the \texttt{pq} program may depend on knowing what the ``current state'' is, to form a setup file some ``close enough guesses'' may sometimes be necessary; when this occurs a warning is \texttt{Info}\texttt{\symbol{45}}ed at \texttt{InfoANUPQ} or \texttt{InfoWarning} level 1. To determine whether the ``close enough guesses'' give an accurate setup file, it is necessary to run the command without the \texttt{SetupFile} option, after either setting the \texttt{InfoANUPQ} level to at least 4 (the setup file script can then be compared with the ``\texttt{ToPQ{\textgreater} }'' commands that are \texttt{Info}\texttt{\symbol{45}}ed) or setting a \texttt{pq} command log file by using \texttt{ToPQLog} (see{\nobreakspace}\texttt{ToPQLog} (\ref{ToPQLog})). \item[{\texttt{PqWorkspace := \mbox{\texttt{\mdseries\slshape workspace}}} \label{option PqWorkspace}\index{option PqWorkspace}}] Non\texttt{\symbol{45}}interactively, this option sets the memory used by the \texttt{pq} program. It sets the maximum number of integer\texttt{\symbol{45}}sized elements to allocate in its main storage array. By default, the \texttt{pq} program sets this figure to 10000000. Interactively, \texttt{PqWorkspace} is ignored; the memory used in this case may be set by giving \texttt{PqStart} a second argument (see{\nobreakspace}\texttt{PqStart} (\ref{PqStart})). \item[{\texttt{PcgsAutomorphisms} \label{option PcgsAutomorphisms}\index{option PcgsAutomorphisms}}] \item[{\texttt{PcgsAutomorphisms := false} }] Let \mbox{\texttt{\mdseries\slshape G}} be the group associated with the calling function (or associated interactive process). Passing the option \texttt{PcgsAutomorphisms} without a value (or equivalently setting it to \texttt{true}), specifies that a polycyclic generating sequence for the automorphism group (which must be \emph{soluble}) of \mbox{\texttt{\mdseries\slshape G}}, be computed and passed to the \texttt{pq} program. This increases the efficiency of the computation; it also prevents the \texttt{pq} from calling \textsf{GAP} for orbit\texttt{\symbol{45}}stabilizer calculations. By default, \texttt{PcgsAutomorphisms} is set to the value returned by \texttt{IsSolvable( AutomorphismGroup( \mbox{\texttt{\mdseries\slshape G}} ) )}, and uses the package \textsf{AutPGrp} to compute \texttt{AutomorphismGroup( \mbox{\texttt{\mdseries\slshape G}} )} if it is installed. This flag is set to \texttt{true} or \texttt{false} in the background according to the above criterion by the function \texttt{PqDescendants} (see{\nobreakspace}\texttt{PqDescendants} (\ref{PqDescendants}) and{\nobreakspace}\texttt{PqDescendants} (\ref{PqDescendants:interactive})). \emph{Note:} If \texttt{PcgsAutomorphisms} is used when the automorphism group of \mbox{\texttt{\mdseries\slshape G}} is insoluble, an error message occurs. \item[{\texttt{OrderBound := \mbox{\texttt{\mdseries\slshape n}}} \label{option OrderBound}\index{option OrderBound}}] Specifies that only descendants of size at most $p^{\mbox{\texttt{\mdseries\slshape n}}}$, where \mbox{\texttt{\mdseries\slshape n}} is a non\texttt{\symbol{45}}negative integer, be generated. Note that you cannot set both \texttt{OrderBound} and \texttt{StepSize}. \item[{\texttt{StepSize := \mbox{\texttt{\mdseries\slshape n}}} \label{option StepSize}\index{option StepSize}}] \item[{\texttt{StepSize := \mbox{\texttt{\mdseries\slshape list}}} }] For a positive integer \mbox{\texttt{\mdseries\slshape n}}, \texttt{StepSize} specifies that only those immediate descendants which are a factor $p^{\mbox{\texttt{\mdseries\slshape n}}}$ bigger than their parent group be generated. For a list \mbox{\texttt{\mdseries\slshape list}} of positive integers such that the sum of the length of \mbox{\texttt{\mdseries\slshape list}} and the exponent\texttt{\symbol{45}}$p$ class of \mbox{\texttt{\mdseries\slshape G}} is equal to the class bound defined by the option \texttt{ClassBound}, \texttt{StepSize} specifies that the integers of \mbox{\texttt{\mdseries\slshape list}} are the step sizes for each additional class. \item[{\texttt{RankInitialSegmentSubgroups := \mbox{\texttt{\mdseries\slshape n}}} \label{option RankInitialSegmentSubgroups}\index{option RankInitialSegmentSubgroups}}] Sets the rank of the initial segment subgroup chosen to be \mbox{\texttt{\mdseries\slshape n}}. By default, this has value 0. \item[{\texttt{SpaceEfficient} \label{option SpaceEfficient}\index{option SpaceEfficient}}] Specifies that the \texttt{pq} program performs certain calculations of $p$\texttt{\symbol{45}}group generation more slowly but with greater space efficiency. This flag is frequently necessary for groups of large Frattini quotient rank. The space saving occurs because only one permutation is stored at any one time. This option is only available if the \texttt{PcgsAutomorphisms} flag is set to \texttt{true} (see{\nobreakspace}\texttt{option PcgsAutomorphisms} (\ref{option PcgsAutomorphisms})). For an interactive process, \texttt{SpaceEfficient} defaults to a previously supplied value for the process. Otherwise (and non\texttt{\symbol{45}}interactively), \texttt{SpaceEfficient} is by default \texttt{false}. \item[{\texttt{CapableDescendants} \label{option CapableDescendants}\index{option CapableDescendants}}] By default, \emph{all} (i.e.{\nobreakspace}capable and terminal) descendants are computed. If this flag is set, only capable descendants are computed. Setting this option is equivalent to setting \texttt{AllDescendants := false} (see{\nobreakspace}\texttt{option AllDescendants} (\ref{option AllDescendants})), except if both \texttt{CapableDescendants} and \texttt{AllDescendants} are passed, \texttt{AllDescendants} is essentially ignored. \item[{\texttt{AllDescendants := false} \label{option AllDescendants}\index{option AllDescendants}}] By default, \emph{all} descendants are constructed. If this flag is set to \texttt{false}, only capable descendants are computed. Passing \texttt{AllDescendants} without a value (which is equivalent to setting it to \texttt{true}) is superfluous. This option is provided only for backward compatibility with the \textsf{GAP} 3 version of the \textsf{ANUPQ} package, where by default \texttt{AllDescendants} was set to \texttt{false} (rather than \texttt{true}). It is preferable to use \texttt{CapableDescendants} (see{\nobreakspace}\texttt{option CapableDescendants} (\ref{option CapableDescendants})). \item[{\texttt{TreeDepth := \mbox{\texttt{\mdseries\slshape class}}} \label{option TreeDepth}\index{option TreeDepth}}] Specifies that the descendants tree developed by \texttt{PqDescendantsTreeCoclassOne} (see{\nobreakspace}\texttt{PqDescendantsTreeCoclassOne} (\ref{PqDescendantsTreeCoclassOne})) should be extended to class \mbox{\texttt{\mdseries\slshape class}}, where \mbox{\texttt{\mdseries\slshape class}} is a positive integer. \item[{\texttt{SubList := \mbox{\texttt{\mdseries\slshape sub}}} \label{option SubList}\index{option SubList}}] Suppose that \mbox{\texttt{\mdseries\slshape L}} is the list of descendants generated, then for a list \mbox{\texttt{\mdseries\slshape sub}} of integers this option causes \texttt{PqDescendants} to return \texttt{Sublist( \mbox{\texttt{\mdseries\slshape L}}, \mbox{\texttt{\mdseries\slshape sub}} )}. If an integer \mbox{\texttt{\mdseries\slshape n}} is supplied, \texttt{PqDescendants} returns \texttt{\mbox{\texttt{\mdseries\slshape L}}[\mbox{\texttt{\mdseries\slshape n}}]}. \item[{\texttt{NumberOfSolubleAutomorphisms := \mbox{\texttt{\mdseries\slshape n}}} \label{option NumberOfSolubleAutomorphisms}\index{option NumberOfSolubleAutomorphisms}}] Specifies that the number of soluble automorphisms of the automorphism group supplied by \texttt{PqPGSupplyAutomorphisms} (see{\nobreakspace}\texttt{PqPGSupplyAutomorphisms} (\ref{PqPGSupplyAutomorphisms})) in a $p$\texttt{\symbol{45}}group generation calculation is \mbox{\texttt{\mdseries\slshape n}}. By default, \mbox{\texttt{\mdseries\slshape n}} is taken to be $0$; \mbox{\texttt{\mdseries\slshape n}} must be a non\texttt{\symbol{45}}negative integer. If $\mbox{\texttt{\mdseries\slshape n}} \ge 0$ then a value for the option \texttt{RelativeOrders} (see{\nobreakspace}\ref{option RelativeOrders}) must also be supplied. \item[{\texttt{RelativeOrders := \mbox{\texttt{\mdseries\slshape list}}} \label{option RelativeOrders}\index{option RelativeOrders}}] Specifies the relative orders of each soluble automorphism of the automorphism group supplied by \texttt{PqPGSupplyAutomorphisms} (see{\nobreakspace}\texttt{PqPGSupplyAutomorphisms} (\ref{PqPGSupplyAutomorphisms})) in a $p$\texttt{\symbol{45}}group generation calculation. The list \mbox{\texttt{\mdseries\slshape list}} must consist of \mbox{\texttt{\mdseries\slshape n}} positive integers, where \mbox{\texttt{\mdseries\slshape n}} is the value of the option \texttt{NumberOfSolubleAutomorphisms} (see{\nobreakspace}\ref{option NumberOfSolubleAutomorphisms}). By default \mbox{\texttt{\mdseries\slshape list}} is empty. \item[{\texttt{BasicAlgorithm} \label{option BasicAlgorithm}\index{option BasicAlgorithm}}] Specifies that an algorithm that the \texttt{pq} program calls its ``default'' algorithm be used for $p$\texttt{\symbol{45}}group generation. By default this algorithm is \emph{not} used. If this option is supplied the settings of options \texttt{RankInitialSegmentSubgroups}, \texttt{AllDescendants}, \texttt{Exponent} and \texttt{Metabelian} are ignored. \item[{\texttt{CustomiseOutput := \mbox{\texttt{\mdseries\slshape rec}}} \label{option CustomiseOutput}\index{option CustomiseOutput}}] Specifies that fine tuning of the output is desired. The record \mbox{\texttt{\mdseries\slshape rec}} should have any subset (or all) of the the following fields: \begin{description} \item[{\texttt{perm := \mbox{\texttt{\mdseries\slshape list}}}}] where \mbox{\texttt{\mdseries\slshape list}} is a list of booleans which determine whether the permutation group output for the automorphism group should contain: the degree, the extended automorphisms, the automorphism matrices, and the permutations, respectively. \item[{\texttt{orbit := \mbox{\texttt{\mdseries\slshape list}}}}] where \mbox{\texttt{\mdseries\slshape list}} is a list of booleans which determine whether the orbit output of the action of the automorphism group should contain: a summary, and a complete listing of orbits, respectively. (It's possible to have \emph{both} a summary and a complete listing.) \item[{\texttt{group := \mbox{\texttt{\mdseries\slshape list}}}}] where \mbox{\texttt{\mdseries\slshape list}} is a list of booleans which determine whether the group output should contain: the standard matrix of each allowable subgroup, the presentation of reduced $p$\texttt{\symbol{45}}covering groups, the presentation of immediate descendants, the nuclear rank of descendants, and the $p$\texttt{\symbol{45}}multiplicator rank of descendants, respectively. \item[{\texttt{autgroup := \mbox{\texttt{\mdseries\slshape list}}}}] where \mbox{\texttt{\mdseries\slshape list}} is a list of booleans which determine whether the automorphism group output should contain: the commutator matrix, the automorphism group description of descendants, and the automorphism group order of descendants, respectively. \item[{\texttt{trace := \mbox{\texttt{\mdseries\slshape val}}}}] where \mbox{\texttt{\mdseries\slshape val}} is a boolean which if \texttt{true} specifies algorithm trace data is desired. By default, one does not get algorithm trace data. \end{description} Not providing a field (or mis\texttt{\symbol{45}}spelling it!), specifies that the default output is desired. As a convenience, \texttt{1} is also accepted as \texttt{true}, and any value that is neither \texttt{1} nor \texttt{true} is taken as \texttt{false}. Also for each \mbox{\texttt{\mdseries\slshape list}} above, an unbound list entry is taken as \texttt{false}. Thus, for example \begin{Verbatim}[commandchars=!@|,fontsize=\small,frame=single,label=Example] CustomiseOutput := rec(group := [,,1], autgroup := [,1]) \end{Verbatim} specifies for the group output that only the presentation of immediate descendants is desired, for the automorphism group output only the automorphism group description of descendants should be printed, that there should be no algorithm trace data, and that the default output should be provided for the permutation group and orbit output. \item[{\texttt{StandardPresentationFile := \mbox{\texttt{\mdseries\slshape filename}}} \label{option StandardPresentationFile}\index{option StandardPresentationFile}}] Specifies that the file to which the standard presentation is written has name \mbox{\texttt{\mdseries\slshape filename}}. If the first character of the string \mbox{\texttt{\mdseries\slshape filename}} is not \texttt{/}, \mbox{\texttt{\mdseries\slshape filename}} is assumed to be the path of a writable file relative to the directory in which \textsf{GAP} was started. If this option is omitted it is written to the file with the name generated by the command \texttt{Filename( ANUPQData.tmpdir, "SPres" );}, i.e.{\nobreakspace}the file with name \texttt{"SPres"} in the temporary directory in which the \texttt{pq} program executes. \item[{\texttt{QueueFactor := \mbox{\texttt{\mdseries\slshape n}}} \label{option QueueFactor}\index{option QueueFactor}}] Specifies a queue factor of \mbox{\texttt{\mdseries\slshape n}}, where \mbox{\texttt{\mdseries\slshape n}} must be a positive integer. This option may be used with \texttt{PqNextClass} (see{\nobreakspace}\texttt{PqNextClass} (\ref{PqNextClass})). The queue factor is used when the \texttt{pq} program uses automorphisms to close a set of elements of the $p$\texttt{\symbol{45}}multiplicator under their action. The algorithm used is a spinning algorithm: it starts with a set of vectors in echelonized form (elements of the $p$\texttt{\symbol{45}}multiplicator) and closes the span of these vectors under the action of the automorphisms. For this each automorphism is applied to each vector and it is checked if the result is contained in the span computed so far. If not, the span becomes bigger and the vector is put into a queue and the automorphisms are applied to this vector at a later stage. The process terminates when the automorphisms have been applied to all vectors and no new vectors have been produced. For each new vector it is decided, if its processing should be delayed. If the vector contains too many non\texttt{\symbol{45}}zero entries, it is put into a second queue. The elements in this queue are processed only when there are no elements in the first queue left. The queue factor is a percentage figure. A vector is put into the second queue if the percentage of its non\texttt{\symbol{45}}zero entries exceeds the queue factor. \item[{\texttt{Bounds := \mbox{\texttt{\mdseries\slshape list}}} \label{option Bounds}\index{option Bounds}}] Specifies a lower and upper bound on the indices of a list, where \mbox{\texttt{\mdseries\slshape list}} is a pair of positive non\texttt{\symbol{45}}decreasing integers. See{\nobreakspace}\texttt{PqDisplayStructure} (\ref{PqDisplayStructure}) and{\nobreakspace}\texttt{PqDisplayAutomorphisms} (\ref{PqDisplayAutomorphisms}) where this option may be used. \item[{\texttt{PrintAutomorphisms := \mbox{\texttt{\mdseries\slshape list}}} \label{option PrintAutomorphisms}\index{option PrintAutomorphisms}}] Specifies that automorphism matrices be printed. \item[{\texttt{PrintPermutations := \mbox{\texttt{\mdseries\slshape list}}} \label{option PrintPermutations}\index{option PrintPermutations}}] Specifies that permutations of the subgroups be printed. \item[{\texttt{Filename := \mbox{\texttt{\mdseries\slshape string}}} \label{option Filename}\index{option Filename}}] Specifies that an output or input file to be written to or read from by the \texttt{pq} program should have the name \mbox{\texttt{\mdseries\slshape string}}. \end{description} } } \chapter{\textcolor{Chapter }{Installing the ANUPQ Package}}\label{Installing-ANUPQ} \logpage{[ 7, 0, 0 ]} \hyperdef{L}{X7FB487238298CF42}{} { The ANU \texttt{pq} program is written in C and the package can be installed under UNIX and in environments similar to UNIX. In particular it is known to work on Linux and Mac OS X, and also on Windows equipped with cygwin. The current version of the \textsf{ANUPQ} package requires \textsf{GAP}{\nobreakspace}4.9, and version 1.2 of the \textsf{AutPGrp} package. However, we recommend using at least \textsf{GAP}{\nobreakspace}4.6 and \textsf{AutPGrp}{\nobreakspace}1.5. To install the \textsf{ANUPQ} package, move the file \texttt{anupq\texttt{\symbol{45}}\mbox{\texttt{\mdseries\slshape XXX}}.tar.gz} for some version number \mbox{\texttt{\mdseries\slshape XXX}} into the \texttt{pkg} directory in which you plan to install \textsf{ANUPQ}. Usually, this will be the directory \texttt{pkg} in the hierarchy of your version of \textsf{GAP}; it is however also possible to keep an additional \texttt{pkg} directory in your private directories. The only essential difference with installing \textsf{ANUPQ} in a \texttt{pkg} directory different to the \textsf{GAP} home directory is that one must start \textsf{GAP} with the \texttt{\texttt{\symbol{45}}l} switch (see Section{\nobreakspace} \textbf{Reference: Command Line Options}), e.g.{\nobreakspace}if your private \texttt{pkg} directory is a subdirectory of \texttt{mygap} in your home directory you might type: \begin{Verbatim}[commandchars=!@|,fontsize=\small,frame=single,label=] gap -l ";myhomedir/mygap" \end{Verbatim} where \mbox{\texttt{\mdseries\slshape myhomedir}} is the path to your home directory, which may be replaced by a tilde. The empty path before the semicolon is filled in by the default path of the \textsf{GAP} home directory. Then, in your chosen \texttt{pkg} directory, unpack \texttt{anupq\texttt{\symbol{45}}\mbox{\texttt{\mdseries\slshape XXX}}.tar.gz} by \begin{Verbatim}[commandchars=!@|,fontsize=\small,frame=single,label=] tar xf anupq-.tar.gz \end{Verbatim} Change to the newly created \texttt{anupq} directory. Now you need to call \texttt{configure}. If you installed \textsf{ANUPQ} into the main \texttt{pkg} directory, call \begin{Verbatim}[commandchars=!@|,fontsize=\small,frame=single,label=] ./configure \end{Verbatim} If you installed ANUPQ in another directory than the usual 'pkg' subdirectory, instead call \begin{Verbatim}[commandchars=!@|,fontsize=\small,frame=single,label=] ./configure --with-gaproot= \end{Verbatim} where \mbox{\texttt{\mdseries\slshape path}} is the path to the \textsf{GAP} home directory. (You can also call \begin{Verbatim}[commandchars=!@|,fontsize=\small,frame=single,label=] ./configure --help \end{Verbatim} for further options.) What this does is look for a file \texttt{sysinfo.gap} in the root directory of \textsf{GAP} in order to determine an architecture name for the subdirectory of \texttt{bin} in which to put the compiled \texttt{pq} binary. This only makes sense if \textsf{GAP} was compiled for the same architecture that \texttt{pq} will be. If you have a shared file system mounted across different architectures, then you should run \texttt{configure} and \texttt{make} for \textsf{ANUPQ} for each architecture immediately after compiling \textsf{GAP} on the same architecture. If you had to install the package in your own directory but wish to use the system \textsf{GAP} then you will need to find out what \mbox{\texttt{\mdseries\slshape path}} is. To do this, start up \textsf{GAP} and find out what \textsf{GAP}'s root path is from finding the value of the variable \texttt{GAPInfo.RootPaths}, e.g. \begin{Verbatim}[commandchars=!@|,fontsize=\small,frame=single,label=Example] !gapprompt@gap>| !gapinput@GAPInfo.RootPaths;| [ "/usr/local/lib/gap4r4/" ] \end{Verbatim} would tell you to use \texttt{/usr/local/lib/gap4r4} for \mbox{\texttt{\mdseries\slshape path}}. The \texttt{configure} command will fetch the architecture type for which \textsf{GAP} has been compiled last and create a \texttt{Makefile}. You can now simply call \begin{Verbatim}[commandchars=!@|,fontsize=\small,frame=single,label=] make \end{Verbatim} to compile the binary and to install it in the appropriate place. \index{ANUPQ_GAP_EXEC@\texttt{ANUPQ{\textunderscore}GAP{\textunderscore}EXEC}!environment variable} The path of \textsf{GAP} (see \emph{Note} below) used by the \texttt{pq} binary (the value \texttt{GAP} is set to in the \texttt{make} command) may be over\texttt{\symbol{45}}ridden by setting the environment variable \texttt{ANUPQ{\textunderscore}GAP{\textunderscore}EXEC}. These values are only of interest when the \texttt{pq} program is run as a standalone; however, the \texttt{testPq} script assumes you have set one of these correctly (see Section{\nobreakspace}\hyperref[Testing your ANUPQ installation]{`Testing your ANUPQ installation'}). When the \texttt{pq} program is started from \textsf{GAP} communication occurs via an iostream, so that the \texttt{pq} binary does not actually need to know a valid path for \textsf{GAP} is this case. \emph{Note.} By ``path of \textsf{GAP}'' we mean the path of the command used to invoke \textsf{GAP} (which should be a script, e.g. the \texttt{gap.sh} script generated in the \texttt{bin} directory for the version of \textsf{GAP} when \textsf{GAP} was compiled). The usual strategy is to copy the \texttt{gap.sh} script to a standard location, e.g. \texttt{/usr/local/bin/gap}. It is a mistake to copy the \textsf{GAP} executable \texttt{gap} (in a directory with name of form \texttt{bin/\mbox{\texttt{\mdseries\slshape compile\texttt{\symbol{45}}platform}}}) to the standard location, since direct invocation of the executable results in \textsf{GAP} starting without being able to find its own library (a fatal error). \section{\textcolor{Chapter }{Testing your ANUPQ installation}}\label{Testing your ANUPQ installation} \logpage{[ 7, 1, 0 ]} \hyperdef{L}{X854577C8800DC7C2}{} { \index{ANUPQ_GAP_EXEC@\texttt{ANUPQ{\textunderscore}GAP{\textunderscore}EXEC}!environment variable} Now it is time to test the installation. After doing \texttt{configure} and \texttt{make} you will have a \texttt{testPq} script. The script assumes that, if the environment variable \texttt{ANUPQ{\textunderscore}GAP{\textunderscore}EXEC} is set, it is a correct path for \textsf{GAP}, or otherwise that the \texttt{make} call that compiled the \texttt{pq} program set \texttt{GAP} to a correct path for \textsf{GAP} (see Section{\nobreakspace}\hyperref[Running the pq program as a standalone]{`Running the pq program as a standalone'} for more details). To run the tests, just type: \begin{Verbatim}[commandchars=!@|,fontsize=\small,frame=single,label=] ./testPq \end{Verbatim} Some of the tests the script runs take a while. Please be patient. The script checks that you not only have a correct \textsf{GAP} (at least version 4.4) installation that includes the \textsf{AutPGrp} package, but that the \textsf{ANUPQ} package and its \texttt{pq} binary interact correctly. You should see something like the following output: \begin{Verbatim}[commandchars=@|B,fontsize=\small,frame=single,label=Example] Made dir: /tmp/testPq Testing installation of ANUPQ Package (version 3.1) The first two tests check that the pq C program compiled ok. Testing the pq binary ... OK. Testing the pq binary's stack size ... OK. The pq C program compiled ok! We test it's the right one below. The next tests check that you have the right version of GAP for the ANUPQ package and that GAP is finding the right versions of the ANUPQ and AutPGrp packages. Checking GAP ... pq binary made with GAP set to: /usr/local/bin/gap Starting GAP to determine version and package availability ... GAP version (4.6.5) ... OK. GAP found ANUPQ package (version 3.1) ... good. GAP found pq binary (version 1.9) ... good. GAP found AutPGrp package (version 1.5) ... good. GAP is OK. Checking the link between the pq binary and GAP ... OK. Testing the standard presentation part of the pq binary ... OK. Doing p-group generation (final GAP/ANUPQ) test ... OK. Tests complete. Removed dir: /tmp/testPq Enjoy using your functional ANUPQ package! \end{Verbatim} } \section{\textcolor{Chapter }{Running the pq program as a standalone}}\label{Running the pq program as a standalone} \logpage{[ 7, 2, 0 ]} \hyperdef{L}{X82906B5184C61063}{} { \index{ANUPQ_GAP_EXEC@\texttt{ANUPQ{\textunderscore}GAP{\textunderscore}EXEC}!environment variable} When the \texttt{pq} program is run as a standalone it sometimes needs to call \textsf{GAP} to compute stabilisers of subgroups; in doing so, it first checks the value of the environment variable \texttt{ANUPQ{\textunderscore}GAP{\textunderscore}EXEC}, and uses that, if set, or otherwise the value of \texttt{GAP} it was compiled with, as the path for \textsf{GAP}. If you ran \texttt{testPq} (see Section{\nobreakspace}\hyperref[Testing your ANUPQ installation]{`Testing your ANUPQ installation'}) and you got both \textsf{GAP} is \texttt{OK} and the link between the \texttt{pq} binary and \textsf{GAP} is \texttt{OK}, you should be fine. Otherwise heed the recommendations of the error messages you get and run the \texttt{testPq} until all tests are passed. It is especially important that the \textsf{GAP}, whose path you gave, should know where to find the \textsf{ANUPQ} and \textsf{AutPGrp} packages. To ensure this the path should be to a shell script that invokes \textsf{GAP}. If you needed to install the needed packages in your own directory (because, say, you are not a system administrator) then you should create your own shell script that runs \textsf{GAP} with a correct setting of the \texttt{\texttt{\symbol{45}}l} option and set the path used by the \texttt{pq} binary to the path of that script. To create the script that runs \textsf{GAP} it is easiest to copy the system one and edit it, e.g. start by executing the following UNIX commands (skip the second step if you already have a \texttt{bin} directory; \texttt{you@unix{\textgreater}} is your UNIX prompt): \begin{Verbatim}[commandchars=!|A,fontsize=\small,frame=single,label=] you@unix> cd you@unix> mkdir bin you@unix> cd bin you@unix> which gap /usr/local/bin/gap you@unix> cp /usr/local/bin/gap mygap you@unix> chmod +x mygap \end{Verbatim} At the second\texttt{\symbol{45}}last step use the path of \textsf{GAP} returned by \texttt{which gap}. Now hopefully you will have a copy of the script that runs the system \textsf{GAP} in \texttt{mygap}. Now use your favourite editor to edit the \texttt{\texttt{\symbol{45}}l} part of the last line of \texttt{mygap} which should initially look something like: \begin{Verbatim}[commandchars=!@|,fontsize=\small,frame=single,label=] exec $GAP_DIR/bin/$GAP_PRG -m $GAP_MEM -o 970m -l $GAP_DIR $* \end{Verbatim} so that it becomes (the tilde is a UNIX abbreviation for your home directory): \begin{Verbatim}[commandchars=!@|,fontsize=\small,frame=single,label=] exec $GAP_DIR/bin/$GAP_PRG -m $GAP_MEM -o 970m -l "$GAP_DIR;~/gapstuff" $* \end{Verbatim} assuming that your personal \textsf{GAP} \texttt{pkg} directory is a subdirectory of \texttt{gapstuff} in your home directory. Finally, to let the \texttt{pq} program know where \textsf{GAP} is and also know where your \texttt{pkg} directory is that contains \textsf{ANUPQ}, set the environment variable \texttt{ANUPQ{\textunderscore}GAP{\textunderscore}EXEC} to the complete (i.e. absolute) path of your \texttt{mygap} script (do not use the tilde abbreviation). } } \appendix \chapter{\textcolor{Chapter }{Examples}}\label{Examples} \logpage{[ "A", 0, 0 ]} \hyperdef{L}{X7A489A5D79DA9E5C}{} { There are a large number of examples provided with the \textsf{ANUPQ} package. These may be executed or displayed via the function \texttt{PqExample} (see{\nobreakspace}\texttt{PqExample} (\ref{PqExample})). Each example resides in a file of the same name in the directory \texttt{examples}. Most of the examples are translations to \textsf{GAP} of examples provided for the \texttt{pq} standalone by Eamonn O'Brien; the standalone examples are found in directories \texttt{standalone/examples} ($p$\texttt{\symbol{45}}quotient and $p$\texttt{\symbol{45}}group generation examples) and \texttt{standalone/isom} (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 ``live'' is always indicated near \texttt{\symbol{45}}\texttt{\symbol{45}} usually immediately after \texttt{\symbol{45}}\texttt{\symbol{45}} the text example). The format of the (\texttt{PqExample}) examples is such that they can be read by the standard \texttt{Read} function of \textsf{GAP}, but certain features and comments are interpreted by the function \texttt{PqExample} to do somewhat more than \texttt{Read} does. In particular, any function without a \texttt{\texttt{\symbol{45}}i}, \texttt{\texttt{\symbol{45}}ni} or \texttt{.g} suffix has both a non\texttt{\symbol{45}}interactive and interactive form; in these cases, the default form is the non\texttt{\symbol{45}}interactive form, and giving \texttt{PqStart} as second argument generates the interactive form. Running \texttt{PqExample} without an argument or with a non\texttt{\symbol{45}}existent example \texttt{Info}s the available examples and some hints on usage: \begin{Verbatim}[commandchars=!@|,fontsize=\small,frame=single,label=Example] !gapprompt@gap>| !gapinput@PqExample();| #I PqExample Index (Table of Contents) #I ----------------------------------- #I This table of possible examples is displayed when calling `PqExample' #I with no arguments, or with the argument: "index" (meant in the sense #I of ``list''), or with a non-existent example name. #I #I Examples that have a name ending in `-ni' are non-interactive only. #I Examples that have a name ending in `-i' are interactive only. #I Examples with names ending in `.g' also have only one form. Other #I examples have both a non-interactive and an interactive form; call #I `PqExample' with 2nd argument `PqStart' to get the interactive form #I of the example. The substring `PG' in an example name indicates a #I p-Group Generation example, `SP' indicates a Standard Presentation #I example, `Rel' indicates it uses the `Relators' option, and `Id' #I indicates it uses the `Identities' option. #I #I The following ANUPQ examples are available: #I #I p-Quotient examples: #I general: #I "Pq" "Pq-ni" "PqEpimorphism" #I "PqPCover" "PqSupplementInnerAutomorphisms" #I 2-groups: #I "2gp-Rel" "2gp-Rel-i" "2gp-a-Rel-i" #I "B2-4" "B2-4-Id" "B2-8-i" #I "B4-4-i" "B4-4-a-i" "B5-4.g" #I 3-groups: #I "3gp-Rel-i" "3gp-a-Rel" "3gp-a-Rel-i" #I "3gp-a-x-Rel-i" "3gp-maxoccur-Rel-i" #I 5-groups: #I "5gp-Rel-i" "5gp-a-Rel-i" "5gp-b-Rel-i" #I "5gp-c-Rel-i" "5gp-metabelian-Rel-i" "5gp-maxoccur-Rel-i" #I "F2-5-i" "B2-5-i" "R2-5-i" #I "R2-5-x-i" "B5-5-Engel3-Id" #I 7-groups: #I "7gp-Rel-i" #I 11-groups: #I "11gp-i" "11gp-Rel-i" "11gp-a-Rel-i" #I "11gp-3-Engel-Id" "11gp-3-Engel-Id-i" #I #I p-Group Generation examples: #I general: #I "PqDescendants-1" "PqDescendants-2" "PqDescendants-3" #I "PqDescendants-1-i" #I 2-groups: #I "2gp-PG-i" "2gp-PG-2-i" "2gp-PG-3-i" #I "2gp-PG-4-i" "2gp-PG-e4-i" #I "PqDescendantsTreeCoclassOne-16-i" #I 3-groups: #I "3gp-PG-i" "3gp-PG-4-i" "3gp-PG-x-i" #I "3gp-PG-x-1-i" "PqDescendants-treetraverse-i" #I "PqDescendantsTreeCoclassOne-9-i" #I 5-groups: #I "5gp-PG-i" "Nott-PG-Rel-i" "Nott-APG-Rel-i" #I "PqDescendantsTreeCoclassOne-25-i" #I 7,11-groups: #I "7gp-PG-i" "11gp-PG-i" #I #I Standard Presentation examples: #I general: #I "StandardPresentation" "StandardPresentation-i" #I "EpimorphismStandardPresentation" #I "EpimorphismStandardPresentation-i" "IsIsomorphicPGroup-ni" #I 2-groups: #I "2gp-SP-Rel-i" "2gp-SP-1-Rel-i" "2gp-SP-2-Rel-i" #I "2gp-SP-3-Rel-i" "2gp-SP-4-Rel-i" "2gp-SP-d-Rel-i" #I "gp-256-SP-Rel-i" "B2-4-SP-i" "G2-SP-Rel-i" #I 3-groups: #I "3gp-SP-Rel-i" "3gp-SP-1-Rel-i" "3gp-SP-2-Rel-i" #I "3gp-SP-3-Rel-i" "3gp-SP-4-Rel-i" "G3-SP-Rel-i" #I 5-groups: #I "5gp-SP-Rel-i" "5gp-SP-a-Rel-i" "5gp-SP-b-Rel-i" #I "5gp-SP-big-Rel-i" "5gp-SP-d-Rel-i" "G5-SP-Rel-i" #I "G5-SP-a-Rel-i" "Nott-SP-Rel-i" #I 7-groups: #I "7gp-SP-Rel-i" "7gp-SP-a-Rel-i" "7gp-SP-b-Rel-i" #I 11-groups: #I "11gp-SP-a-i" "11gp-SP-a-Rel-i" "11gp-SP-a-Rel-1-i" #I "11gp-SP-b-i" "11gp-SP-b-Rel-i" "11gp-SP-c-Rel-i" #I #I Notes #I ----- #I 1. The example (first) argument of `PqExample' is a string; each #I example above is in double quotes to remind you to include them. #I 2. Some examples accept options. To find out whether a particular #I example accepts options, display it first (by including `Display' #I as last argument) which will also indicate how `PqExample' #I interprets the options, e.g. `PqExample("11gp-SP-a-i", Display);'. #I 3. Try `SetInfoLevel(InfoANUPQ, );' for some in [2 .. 4] #I before calling PqExample, to see what's going on behind the scenes. #I \end{Verbatim} If on your terminal you are unable to scroll back, an alternative to typing \texttt{PqExample();} to see the displayed examples is to use on\texttt{\symbol{45}}line help, i.e.{\nobreakspace} you may type: \begin{Verbatim}[commandchars=!@|,fontsize=\small,frame=single,label=Example] !gapprompt@gap>| !gapinput@?anupq:examples| \end{Verbatim} which will display this appendix in a \textsf{GAP} session. If you are not fussed about the order in which the examples are organised, \texttt{AllPqExamples();} lists the available examples relatively compactly (see{\nobreakspace}\texttt{AllPqExamples} (\ref{AllPqExamples})). In the remainder of this appendix we will discuss particular aspects related to the \texttt{Relators} (see{\nobreakspace}\ref{option Relators}) and \texttt{Identities} (see{\nobreakspace}\ref{option Identities}) options, and the construction of the Burnside group $B(5, 4)$. \section{\textcolor{Chapter }{The Relators Option}}\label{The Relators Option} \logpage{[ "A", 1, 0 ]} \hyperdef{L}{X80676E317BF4DF13}{} { The \texttt{Relators} option was included because computations involving words containing commutators that are pre\texttt{\symbol{45}}expanded by \textsf{GAP} before being passed to the \texttt{pq} program may run considerably more slowly, than the same computations being run with \textsf{GAP} pre\texttt{\symbol{45}}expansions avoided. The following examples demonstrate a case where the performance hit due to pre\texttt{\symbol{45}}expansion of commutators by \textsf{GAP} is a factor of order 100 (in order to see timing information from the \texttt{pq} program, we set the \texttt{InfoANUPQ} level to 2). Firstly, we run the example that allows pre\texttt{\symbol{45}}expansion of commutators (the function \texttt{PqLeftNormComm} is provided by the \textsf{ANUPQ} package; see{\nobreakspace}\texttt{PqLeftNormComm} (\ref{PqLeftNormComm})). Note that since the two commutators of this example are \emph{very} long (taking more than an page to print), we have edited the output at this point. \begin{Verbatim}[commandchars=!@|,fontsize=\small,frame=single,label=Example] !gapprompt@gap>| !gapinput@SetInfoLevel(InfoANUPQ, 2); #to see timing information| !gapprompt@gap>| !gapinput@PqExample("11gp-i");| #I #Example: "11gp-i" . . . based on: examples/11gp #I F, a, b, c, R, procId are local to `PqExample' !gapprompt@gap>| !gapinput@F := FreeGroup("a", "b", "c"); a := F.1; b := F.2; c := F.3;| a b c !gapprompt@gap>| !gapinput@R := [PqLeftNormComm([b, a, a, b, c])^11, | !gapprompt@>| !gapinput@ PqLeftNormComm([a, b, b, a, b, c])^11, (a * b)^11];;| !gapprompt@gap>| !gapinput@procId := PqStart(F/R : Prime := 11);;| !gapprompt@gap>| !gapinput@PqPcPresentation(procId : ClassBound := 7, | !gapprompt@>| !gapinput@ OutputLevel := 1);| #I Lower exponent-11 central series for [grp] #I Group: [grp] to lower exponent-11 central class 1 has order 11^3 #I Group: [grp] to lower exponent-11 central class 2 has order 11^8 #I Group: [grp] to lower exponent-11 central class 3 has order 11^19 #I Group: [grp] to lower exponent-11 central class 4 has order 11^42 #I Group: [grp] to lower exponent-11 central class 5 has order 11^98 #I Group: [grp] to lower exponent-11 central class 6 has order 11^228 #I Group: [grp] to lower exponent-11 central class 7 has order 11^563 #I Computation of presentation took 27.04 seconds !gapprompt@gap>| !gapinput@PqSavePcPresentation(procId, ANUPQData.outfile);| #I Variables used in `PqExample' are saved in `ANUPQData.example.vars'. \end{Verbatim} Now we do the same calculation using the \texttt{Relators} option. In this way, the commutators are passed directly as strings to the \texttt{pq} program, so that \textsf{GAP} does not ``see'' them and pre\texttt{\symbol{45}}expand them. \begin{Verbatim}[commandchars=!@|,fontsize=\small,frame=single,label=Example] !gapprompt@gap>| !gapinput@PqExample("11gp-Rel-i");| #I #Example: "11gp-Rel-i" . . . based on: examples/11gp #I #(equivalent to "11gp-i" example but uses `Relators' option) #I F, rels, procId are local to `PqExample' !gapprompt@gap>| !gapinput@F := FreeGroup("a", "b", "c");| !gapprompt@gap>| !gapinput@rels := ["[b, a, a, b, c]^11", "[a, b, b, a, b, c]^11", "(a * b)^11"];| [ "[b, a, a, b, c]^11", "[a, b, b, a, b, c]^11", "(a * b)^11" ] !gapprompt@gap>| !gapinput@procId := PqStart(F : Prime := 11, Relators := rels);;| !gapprompt@gap>| !gapinput@PqPcPresentation(procId : ClassBound := 7, | !gapprompt@>| !gapinput@ OutputLevel := 1);| #I Relators parsed ok. #I Lower exponent-11 central series for [grp] #I Group: [grp] to lower exponent-11 central class 1 has order 11^3 #I Group: [grp] to lower exponent-11 central class 2 has order 11^8 #I Group: [grp] to lower exponent-11 central class 3 has order 11^19 #I Group: [grp] to lower exponent-11 central class 4 has order 11^42 #I Group: [grp] to lower exponent-11 central class 5 has order 11^98 #I Group: [grp] to lower exponent-11 central class 6 has order 11^228 #I Group: [grp] to lower exponent-11 central class 7 has order 11^563 #I Computation of presentation took 0.27 seconds !gapprompt@gap>| !gapinput@PqSavePcPresentation(procId, ANUPQData.outfile);| #I Variables used in `PqExample' are saved in `ANUPQData.example.vars'. \end{Verbatim} } \section{\textcolor{Chapter }{The Identities Option and PqEvaluateIdentities Function}}\label{The Identities Option and PqEvaluateIdentities Function} \logpage{[ "A", 2, 0 ]} \hyperdef{L}{X80B2AA7084C57F5D}{} { Please pay heed to the warnings given for the \texttt{Identities} option (see{\nobreakspace}\ref{option Identities}); it is written mainly at the \textsf{GAP} level and is not particularly optimised. The \texttt{Identities} option allows one to compute $p$\texttt{\symbol{45}}quotients that satisfy an identity. A trivial example better done using the \texttt{Exponent} option, but which nevertheless demonstrates the usage of the \texttt{Identities} option, is as follows: \begin{Verbatim}[commandchars=!@|,fontsize=\small,frame=single,label=Example] !gapprompt@gap>| !gapinput@SetInfoLevel(InfoANUPQ, 1);| !gapprompt@gap>| !gapinput@PqExample("B2-4-Id");| #I #Example: "B2-4-Id" . . . alternative way to generate B(2, 4) #I #Generates B(2, 4) by using the `Identities' option #I #... this is not as efficient as using `Exponent' but #I #demonstrates the usage of the `Identities' option. #I F, f, procId are local to `PqExample' !gapprompt@gap>| !gapinput@F := FreeGroup("a", "b");| !gapprompt@gap>| !gapinput@# All words w in the pc generators of B(2, 4) satisfy f(w) = 1 | !gapprompt@gap>| !gapinput@f := w -> w^4;| function( w ) ... end !gapprompt@gap>| !gapinput@Pq( F : Prime := 2, Identities := [ f ] );| #I Class 1 with 2 generators. #I Class 2 with 5 generators. #I Class 3 with 7 generators. #I Class 4 with 10 generators. #I Class 5 with 12 generators. #I Class 5 with 12 generators. #I Variables used in `PqExample' are saved in `ANUPQData.example.vars'. !gapprompt@gap>| !gapinput@time; | 1400 \end{Verbatim} Note that the \texttt{time} statement gives the time in milliseconds spent by \textsf{GAP} in executing the \texttt{PqExample("B2\texttt{\symbol{45}}4\texttt{\symbol{45}}Id");} command (i.e.{\nobreakspace}everything up to the \texttt{Info}\texttt{\symbol{45}}ing of the variables used), but over 90\% of that time is spent in the final \texttt{Pq} statement. The time spent by the \texttt{pq} program, which is negligible anyway (you can check this by running the example while the \texttt{InfoANUPQ} level is set to 2), is not counted by \texttt{time}. Since the identity used in the above construction of $B(2, 4)$ is just an exponent law, the ``right'' way to compute it is via the \texttt{Exponent} option (see{\nobreakspace}\ref{option Exponent}), which is implemented at the C level and \emph{is} highly optimised. Consequently, the \texttt{Exponent} option is significantly faster, generally by several orders of magnitude: \begin{Verbatim}[commandchars=!@|,fontsize=\small,frame=single,label=Example] !gapprompt@gap>| !gapinput@SetInfoLevel(InfoANUPQ, 2); # to see time spent by the `pq' program| !gapprompt@gap>| !gapinput@PqExample("B2-4");| #I #Example: "B2-4" . . . the ``right'' way to generate B(2, 4) #I #Generates B(2, 4) by using the `Exponent' option #I F, procId are local to `PqExample' !gapprompt@gap>| !gapinput@F := FreeGroup("a", "b");| !gapprompt@gap>| !gapinput@Pq( F : Prime := 2, Exponent := 4 );| #I Computation of presentation took 0.00 seconds #I Variables used in `PqExample' are saved in `ANUPQData.example.vars'. !gapprompt@gap>| !gapinput@time; # time spent by GAP in executing `PqExample("B2-4");' | 50 \end{Verbatim} The following example uses the \texttt{Identities} option to compute a 3\texttt{\symbol{45}}Engel group for the prime 11. As is the case for the example \texttt{"B2\texttt{\symbol{45}}4\texttt{\symbol{45}}Id"}, the example has both a non\texttt{\symbol{45}}interactive and an interactive form; below, we demonstrate the interactive form. \begin{Verbatim}[commandchars=!@|,fontsize=\small,frame=single,label=Example] !gapprompt@gap>| !gapinput@SetInfoLevel(InfoANUPQ, 1); # reset InfoANUPQ to default level| !gapprompt@gap>| !gapinput@PqExample("11gp-3-Engel-Id", PqStart);| #I #Example: "11gp-3-Engel-Id" . . . 3-Engel group for prime 11 #I #Non-trivial example of using the `Identities' option #I F, a, b, G, f, procId, Q are local to `PqExample' !gapprompt@gap>| !gapinput@F := FreeGroup("a", "b"); a := F.1; b := F.2;| a b !gapprompt@gap>| !gapinput@G := F/[ a^11, b^11 ];| !gapprompt@gap>| !gapinput@# All word pairs u, v in the pc generators of the 11-quotient Q of G | !gapprompt@gap>| !gapinput@# must satisfy the Engel identity: [u, v, v, v] = 1.| !gapprompt@gap>| !gapinput@f := function(u, v) return PqLeftNormComm( [u, v, v, v] ); end;| function( u, v ) ... end !gapprompt@gap>| !gapinput@procId := PqStart( G );;| !gapprompt@gap>| !gapinput@Q := Pq( procId : Prime := 11, Identities := [ f ] );| #I Class 1 with 2 generators. #I Class 2 with 3 generators. #I Class 3 with 5 generators. #I Class 3 with 5 generators. !gapprompt@gap>| !gapinput@# We do a ``sample'' check that pairs of elements of Q do satisfy| !gapprompt@gap>| !gapinput@# the given identity:| !gapprompt@gap>| !gapinput@f( Random(Q), Random(Q) );| of ... !gapprompt@gap>| !gapinput@f( Q.1, Q.2 );| of ... #I Variables used in `PqExample' are saved in `ANUPQData.example.vars'. \end{Verbatim} The (interactive) call to \texttt{Pq} above is essentially equivalent to a call to \texttt{PqPcPresentation} with the same arguments and options followed by a call to \texttt{PqCurrentGroup}. Moreover, the call to \texttt{PqPcPresentation} (as described in{\nobreakspace}\texttt{PqPcPresentation} (\ref{PqPcPresentation})) is equivalent to a ``class 1'' call to \texttt{PqPcPresentation} followed by the requisite number of calls to \texttt{PqNextClass}, and with the \texttt{Identities} option set, both \texttt{PqPcPresentation} and \texttt{PqNextClass} ``quietly'' perform the equivalent of a \texttt{PqEvaluateIdentities} call. In the following example we break down the \texttt{Pq} call into its low\texttt{\symbol{45}}level equivalents, and set and unset the \texttt{Identities} option to show where \texttt{PqEvaluateIdentities} fits into this scheme. \begin{Verbatim}[commandchars=!@|,fontsize=\small,frame=single,label=Example] !gapprompt@gap>| !gapinput@PqExample("11gp-3-Engel-Id-i");| #I #Example: "11gp-3-Engel-Id-i" . . . 3-Engel grp for prime 11 #I #Variation of "11gp-3-Engel-Id" broken down into its lower-level component #I #command parts. #I F, a, b, G, f, procId, Q are local to `PqExample' !gapprompt@gap>| !gapinput@F := FreeGroup("a", "b"); a := F.1; b := F.2;| a b !gapprompt@gap>| !gapinput@G := F/[ a^11, b^11 ];| !gapprompt@gap>| !gapinput@# All word pairs u, v in the pc generators of the 11-quotient Q of G | !gapprompt@gap>| !gapinput@# must satisfy the Engel identity: [u, v, v, v] = 1.| !gapprompt@gap>| !gapinput@f := function(u, v) return PqLeftNormComm( [u, v, v, v] ); end;| function( u, v ) ... end !gapprompt@gap>| !gapinput@procId := PqStart( G : Prime := 11 );;| !gapprompt@gap>| !gapinput@PqPcPresentation( procId : ClassBound := 1);| !gapprompt@gap>| !gapinput@PqEvaluateIdentities( procId : Identities := [f] );| #I Class 1 with 2 generators. !gapprompt@gap>| !gapinput@for c in [2 .. 4] do| !gapprompt@>| !gapinput@ PqNextClass( procId : Identities := [] ); #reset `Identities' option| !gapprompt@>| !gapinput@ PqEvaluateIdentities( procId : Identities := [f] );| !gapprompt@>| !gapinput@ od;| #I Class 2 with 3 generators. #I Class 3 with 5 generators. #I Class 3 with 5 generators. !gapprompt@gap>| !gapinput@Q := PqCurrentGroup( procId );| !gapprompt@gap>| !gapinput@# We do a ``sample'' check that pairs of elements of Q do satisfy| !gapprompt@gap>| !gapinput@# the given identity:| !gapprompt@gap>| !gapinput@f( Random(Q), Random(Q) );| of ... !gapprompt@gap>| !gapinput@f( Q.1, Q.2 );| of ... #I Variables used in `PqExample' are saved in `ANUPQData.example.vars'. \end{Verbatim} } \section{\textcolor{Chapter }{A Large Example}}\label{A Large Example} \logpage{[ "A", 3, 0 ]} \hyperdef{L}{X7A997D1A8532A84B}{} { \index{B(5,4)@$B(5,4)$} An example demonstrating how a large computation can be organised with the \textsf{ANUPQ} package is the computation of the Burnside group $B(5, 4)$, the largest group of exponent 4 generated by 5 elements. It has order $2^{2728}$ and lower exponent\texttt{\symbol{45}}$p$ central class 13. The example \texttt{"B5\texttt{\symbol{45}}4.g"} computes $B(5, 4)$; it is based on a \texttt{pq} standalone input file written by M.{\nobreakspace}F.{\nobreakspace}Newman. To be able to do examples like this was part of the motivation to provide access to the low\texttt{\symbol{45}}level functions of the standalone program from within \textsf{GAP}. Please note that the construction uses the knowledge gained by Newman and O'Brien in their initial construction of $B(5, 4)$, in particular, insight into the commutator structure of the group and the knowledge of the $p$\texttt{\symbol{45}}central class and the order of $B(5, 4)$. Therefore, the construction cannot be used to prove that $B(5, 4)$ 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 \texttt{examples/B5\texttt{\symbol{45}}4.g}. \begin{Verbatim}[commandchars=!@|,fontsize=\small,frame=single,label=Example] procId := PqStart( FreeGroup(5) : Exponent := 4, Prime := 2 ); Pq( procId : ClassBound := 2 ); PqSupplyAutomorphisms( procId, [ [ [ 1, 1, 0, 0, 0], # first automorphism [ 0, 1, 0, 0, 0], [ 0, 0, 1, 0, 0], [ 0, 0, 0, 1, 0], [ 0, 0, 0, 0, 1] ], [ [ 0, 0, 0, 0, 1], # second automorphism [ 1, 0, 0, 0, 0], [ 0, 1, 0, 0, 0], [ 0, 0, 1, 0, 0], [ 0, 0, 0, 1, 0] ] ] );; Relations := [ [], ## class 1 [], ## class 2 [], ## class 3 [], ## class 4 [], ## class 5 [], ## class 6 ## class 7 [ [ "x2","x1","x1","x3","x4","x4","x4" ] ], ## class 8 [ [ "x2","x1","x1","x3","x4","x5","x5","x5" ] ], ## class 9 [ [ "x2","x1","x1","x3","x4","x4","x5","x5","x5" ], [ "x2","x1","x1","x2","x3","x4","x5","x5","x5" ], [ "x2","x1","x1","x3","x3","x4","x5","x5","x5" ] ], ## class 10 [ [ "x2","x1","x1","x2","x3","x3","x4","x5","x5","x5" ], [ "x2","x1","x1","x3","x3","x4","x4","x5","x5","x5" ] ], ## class 11 [ [ "x2","x1","x1","x2","x3","x3","x4","x4","x5","x5","x5" ], [ "x2","x1","x1","x2","x3","x1","x3","x4","x2","x4","x3" ] ], ## class 12 [ [ "x2","x1","x1","x2","x3","x1","x3","x4","x2","x5","x5","x5" ], [ "x2","x1","x1","x3","x2","x4","x3","x5","x4","x5","x5","x5" ] ], ## class 13 [ [ "x2","x1","x1","x2","x3","x1","x3","x4","x2","x4","x5","x5","x5" ] ] ]; for class in [ 3 .. 13 ] do Print( "Computing class ", class, "\n" ); PqSetupTablesForNextClass( procId ); for w in [ class, class-1 .. 7 ] do PqAddTails( procId, w ); PqDisplayPcPresentation( procId ); if Relations[ w ] <> [] then # recalculate automorphisms PqExtendAutomorphisms( procId ); for r in Relations[ w ] do Print( "Collecting ", r, "\n" ); PqCommutator( procId, r, 1 ); PqEchelonise( procId ); PqApplyAutomorphisms( procId, 15 ); #queue factor = 15 od; PqEliminateRedundantGenerators( procId ); fi; PqComputeTails( procId, w ); od; PqDisplayPcPresentation( procId ); smallclass := Minimum( class, 6 ); for w in [ smallclass, smallclass-1 .. 2 ] do PqTails( procId, w ); od; # recalculate automorphisms PqExtendAutomorphisms( procId ); PqCollect( procId, "x5^4" ); PqEchelonise( procId ); PqApplyAutomorphisms( procId, 15 ); #queue factor = 15 PqEliminateRedundantGenerators( procId ); PqDisplayPcPresentation( procId ); od; \end{Verbatim} } \section{\textcolor{Chapter }{Developing descendants trees}}\label{Developing descendants trees} \logpage{[ "A", 4, 0 ]} \hyperdef{L}{X7FB6DA8D7BB90D8C}{} { In the following example we will explore the 3\texttt{\symbol{45}}groups of rank 2 and 3\texttt{\symbol{45}}coclass 1 up to 3\texttt{\symbol{45}}class 5. This will be done using the $p$\texttt{\symbol{45}}group generation machinery of the package. We start with the elementary abelian 3\texttt{\symbol{45}}group of rank 2. From within \textsf{GAP}, run the example \texttt{"PqDescendants\texttt{\symbol{45}}treetraverse\texttt{\symbol{45}}i"} via \texttt{PqExample} (see{\nobreakspace}\texttt{PqExample} (\ref{PqExample})). \begin{Verbatim}[commandchars=!@|,fontsize=\small,frame=single,label=Example] !gapprompt@gap>| !gapinput@G := ElementaryAbelianGroup( 9 );| !gapprompt@gap>| !gapinput@procId := PqStart( G );;| !gapprompt@gap>| !gapinput@#| !gapprompt@gap>| !gapinput@# Below, we use the option StepSize in order to construct descendants| !gapprompt@gap>| !gapinput@# of coclass 1. This is equivalent to setting the StepSize to 1 in| !gapprompt@gap>| !gapinput@# each descendant calculation.| !gapprompt@gap>| !gapinput@#| !gapprompt@gap>| !gapinput@# The elementary abelian group of order 9 has 3 descendants of| !gapprompt@gap>| !gapinput@# 3-class 2 and 3-coclass 1, as the result of the next command| !gapprompt@gap>| !gapinput@# shows. | !gapprompt@gap>| !gapinput@#| !gapprompt@gap>| !gapinput@PqDescendants( procId : StepSize := 1 );| [ , , ] !gapprompt@gap>| !gapinput@#| !gapprompt@gap>| !gapinput@# Now we will compute the descendants of coclass 1 for each of the| !gapprompt@gap>| !gapinput@# groups above. Then we will compute the descendants of coclass 1| !gapprompt@gap>| !gapinput@# of each descendant and so on. Note that the pq program keeps| !gapprompt@gap>| !gapinput@# one file for each class at a time. For example, the descendants| !gapprompt@gap>| !gapinput@# calculation for the second group of class 2 overwrites the| !gapprompt@gap>| !gapinput@# descendant file obtained from the first group of class 2.| !gapprompt@gap>| !gapinput@# Hence, we have to traverse the descendants tree in depth first| !gapprompt@gap>| !gapinput@# order.| !gapprompt@gap>| !gapinput@#| !gapprompt@gap>| !gapinput@PqPGSetDescendantToPcp( procId, 2, 1 );| !gapprompt@gap>| !gapinput@PqPGExtendAutomorphisms( procId );| !gapprompt@gap>| !gapinput@PqPGConstructDescendants( procId : StepSize := 1 );| 2 !gapprompt@gap>| !gapinput@PqPGSetDescendantToPcp( procId, 3, 1 );| !gapprompt@gap>| !gapinput@PqPGExtendAutomorphisms( procId );| !gapprompt@gap>| !gapinput@PqPGConstructDescendants( procId : StepSize := 1 );| 2 !gapprompt@gap>| !gapinput@PqPGSetDescendantToPcp( procId, 4, 1 );| !gapprompt@gap>| !gapinput@PqPGExtendAutomorphisms( procId );| !gapprompt@gap>| !gapinput@PqPGConstructDescendants( procId : StepSize := 1 );| 2 !gapprompt@gap>| !gapinput@#| !gapprompt@gap>| !gapinput@# At this point we stop traversing the ``left most'' branch of the| !gapprompt@gap>| !gapinput@# descendants tree and move upwards.| !gapprompt@gap>| !gapinput@#| !gapprompt@gap>| !gapinput@PqPGSetDescendantToPcp( procId, 4, 2 );| !gapprompt@gap>| !gapinput@PqPGExtendAutomorphisms( procId );| !gapprompt@gap>| !gapinput@PqPGConstructDescendants( procId : StepSize := 1 );| #I group restored from file is incapable 0 !gapprompt@gap>| !gapinput@PqPGSetDescendantToPcp( procId, 3, 2 );| !gapprompt@gap>| !gapinput@PqPGExtendAutomorphisms( procId );| !gapprompt@gap>| !gapinput@PqPGConstructDescendants( procId : StepSize := 1 );| #I group restored from file is incapable 0 !gapprompt@gap>| !gapinput@# | !gapprompt@gap>| !gapinput@# The computations above indicate that the descendants subtree under| !gapprompt@gap>| !gapinput@# the first descendant of the elementary abelian group of order 9| !gapprompt@gap>| !gapinput@# will have only one path of infinite length.| !gapprompt@gap>| !gapinput@#| !gapprompt@gap>| !gapinput@PqPGSetDescendantToPcp( procId, 2, 2 );| !gapprompt@gap>| !gapinput@PqPGExtendAutomorphisms( procId );| !gapprompt@gap>| !gapinput@PqPGConstructDescendants( procId : StepSize := 1 );| 4 !gapprompt@gap>| !gapinput@#| !gapprompt@gap>| !gapinput@# We get four descendants here, three of which will turn out to be| !gapprompt@gap>| !gapinput@# incapable, i.e., they have no descendants and are terminal nodes| !gapprompt@gap>| !gapinput@# in the descendants tree.| !gapprompt@gap>| !gapinput@#| !gapprompt@gap>| !gapinput@PqPGSetDescendantToPcp( procId, 2, 3 );| !gapprompt@gap>| !gapinput@PqPGExtendAutomorphisms( procId );| !gapprompt@gap>| !gapinput@PqPGConstructDescendants( procId : StepSize := 1 );| #I group restored from file is incapable 0 !gapprompt@gap>| !gapinput@#| !gapprompt@gap>| !gapinput@# The third descendant of class three is incapable. Let us return| !gapprompt@gap>| !gapinput@# to the second descendant of class 2.| !gapprompt@gap>| !gapinput@#| !gapprompt@gap>| !gapinput@PqPGSetDescendantToPcp( procId, 2, 2 );| !gapprompt@gap>| !gapinput@PqPGExtendAutomorphisms( procId );| !gapprompt@gap>| !gapinput@PqPGConstructDescendants( procId : StepSize := 1 );| 4 !gapprompt@gap>| !gapinput@PqPGSetDescendantToPcp( procId, 3, 1 );| !gapprompt@gap>| !gapinput@PqPGExtendAutomorphisms( procId );| !gapprompt@gap>| !gapinput@PqPGConstructDescendants( procId : StepSize := 1 );| #I group restored from file is incapable 0 !gapprompt@gap>| !gapinput@PqPGSetDescendantToPcp( procId, 3, 2 );| !gapprompt@gap>| !gapinput@PqPGExtendAutomorphisms( procId );| !gapprompt@gap>| !gapinput@PqPGConstructDescendants( procId : StepSize := 1 );| #I group restored from file is incapable 0 !gapprompt@gap>| !gapinput@#| !gapprompt@gap>| !gapinput@# We skip the third descendant for the moment ... | !gapprompt@gap>| !gapinput@#| !gapprompt@gap>| !gapinput@PqPGSetDescendantToPcp( procId, 3, 4 );| !gapprompt@gap>| !gapinput@PqPGExtendAutomorphisms( procId );| !gapprompt@gap>| !gapinput@PqPGConstructDescendants( procId : StepSize := 1 );| #I group restored from file is incapable 0 !gapprompt@gap>| !gapinput@#| !gapprompt@gap>| !gapinput@# ... and look at it now.| !gapprompt@gap>| !gapinput@#| !gapprompt@gap>| !gapinput@PqPGSetDescendantToPcp( procId, 3, 3 );| !gapprompt@gap>| !gapinput@PqPGExtendAutomorphisms( procId );| !gapprompt@gap>| !gapinput@PqPGConstructDescendants( procId : StepSize := 1 );| 6 !gapprompt@gap>| !gapinput@#| !gapprompt@gap>| !gapinput@# In this branch of the descendant tree we get 6 descendants of class| !gapprompt@gap>| !gapinput@# three. Of those 5 will turn out to be incapable and one will have| !gapprompt@gap>| !gapinput@# 7 descendants.| !gapprompt@gap>| !gapinput@#| !gapprompt@gap>| !gapinput@PqPGSetDescendantToPcp( procId, 4, 1 );| !gapprompt@gap>| !gapinput@PqPGExtendAutomorphisms( procId );| !gapprompt@gap>| !gapinput@PqPGConstructDescendants( procId : StepSize := 1 );| #I group restored from file is incapable 0 !gapprompt@gap>| !gapinput@PqPGSetDescendantToPcp( procId, 4, 2 );| !gapprompt@gap>| !gapinput@PqPGExtendAutomorphisms( procId );| !gapprompt@gap>| !gapinput@PqPGConstructDescendants( procId : StepSize := 1 );| 7 !gapprompt@gap>| !gapinput@PqPGSetDescendantToPcp( procId, 4, 3 );| !gapprompt@gap>| !gapinput@PqPGExtendAutomorphisms( procId );| !gapprompt@gap>| !gapinput@PqPGConstructDescendants( procId : StepSize := 1 );| #I group restored from file is incapable 0 \end{Verbatim} To automate the above procedure to some extent we provide: \subsection{\textcolor{Chapter }{PqDescendantsTreeCoclassOne}} \logpage{[ "A", 4, 1 ]}\nobreak \hyperdef{L}{X805E6B418193CF2D}{} {\noindent\textcolor{FuncColor}{$\triangleright$\enspace\texttt{PqDescendantsTreeCoclassOne({\mdseries\slshape i})\index{PqDescendantsTreeCoclassOne@\texttt{PqDescendantsTreeCoclassOne}} \label{PqDescendantsTreeCoclassOne} }\hfill{\scriptsize (function)}}\\ \noindent\textcolor{FuncColor}{$\triangleright$\enspace\texttt{PqDescendantsTreeCoclassOne({\mdseries\slshape })\index{PqDescendantsTreeCoclassOne@\texttt{PqDescendantsTreeCoclassOne}!for default process} \label{PqDescendantsTreeCoclassOne:for default process} }\hfill{\scriptsize (function)}}\\ for the \mbox{\texttt{\mdseries\slshape i}}th or default interactive \textsf{ANUPQ} process, generate a descendant tree for the group of the process (which must be a pc $p$\texttt{\symbol{45}}group) consisting of descendants of $p$\texttt{\symbol{45}}coclass 1 and extending to the class determined by the option \texttt{TreeDepth} (or 6 if the option is omitted). In an \textsf{XGAP} session, a graphical representation of the descendants tree appears in a separate window. Subsequent calls to \texttt{PqDescendantsTreeCoclassOne} for the same process may be used to extend the descendant tree from the last descendant computed that itself has more than one descendant. \texttt{PqDescendantsTreeCoclassOne} also accepts the options \texttt{CapableDescendants} (or \texttt{AllDescendants}) and any options accepted by the interactive \texttt{PqDescendants} function (see{\nobreakspace}\texttt{PqDescendants} (\ref{PqDescendants:interactive})). \emph{Notes} \begin{enumerate} \item \texttt{PqDescendantsTreeCoclassOne} first calls \texttt{PqDescendants}. If \texttt{PqDescendants} has already been called for the process, the previous value computed is used and a warning is \texttt{Info}\texttt{\symbol{45}}ed at \texttt{InfoANUPQ} level 1. \item As each descendant is processed its unique label defined by the \texttt{pq} program and number of descendants is \texttt{Info}\texttt{\symbol{45}}ed at \texttt{InfoANUPQ} level 1. \item \texttt{PqDescendantsTreeCoclassOne} is an ``experimental'' function that is included to demonstrate the sort of things that are possible with the $p$\texttt{\symbol{45}}group generation machinery. \end{enumerate} Ignoring the extra functionality provided in an \textsf{XGAP} session, \texttt{PqDescendantsTreeCoclassOne}, with one argument that is the index of an interactive \textsf{ANUPQ} process, is approximately equivalent to: \begin{Verbatim}[commandchars=!@|,fontsize=\small,frame=single,label=] PqDescendantsTreeCoclassOne := function( procId ) local des, i; des := PqDescendants( procId : StepSize := 1 ); RecurseDescendants( procId, 2, Length(des) ); end; \end{Verbatim} where \texttt{RecurseDescendants} is (approximately) defined as follows: \begin{Verbatim}[commandchars=!@|,fontsize=\small,frame=single,label=] RecurseDescendants := function( procId, class, n ) local i, nr; if class > ValueOption("TreeDepth") then return; fi; for i in [1..n] do PqPGSetDescendantToPcp( procId, class, i ); PqPGExtendAutomorphisms( procId ); nr := PqPGConstructDescendants( procId : StepSize := 1 ); Print( "Number of descendants of group ", i, " at class ", class, ": ", nr, "\n" ); RecurseDescendants( procId, class+1, nr ); od; return; end; \end{Verbatim} The following examples (executed via \texttt{PqExample}; see{\nobreakspace}\texttt{PqExample} (\ref{PqExample})), demonstrate the use of \texttt{PqDescendantsTreeCoclassOne}: \begin{description} \item[{\texttt{"PqDescendantsTreeCoclassOne\texttt{\symbol{45}}9\texttt{\symbol{45}}i"}}] approximately does example \texttt{"PqDescendants\texttt{\symbol{45}}treetraverse\texttt{\symbol{45}}i"} again using \texttt{PqDescendantsTreeCoclassOne}; \item[{\texttt{"PqDescendantsTreeCoclassOne\texttt{\symbol{45}}16\texttt{\symbol{45}}i"}}] uses the option \texttt{CapableDescendants}; and \item[{\texttt{"PqDescendantsTreeCoclassOne\texttt{\symbol{45}}25\texttt{\symbol{45}}i"}}] calculates all descendants by omitting the \texttt{CapableDescendants} option. \end{description} The numbers \texttt{9}, \texttt{16} and \texttt{25} respectively, indicate the order of the elementary abelian group to which \texttt{PqDescendantsTreeCoclassOne} is applied for these examples. } } } \def\bibname{References\logpage{[ "Bib", 0, 0 ]} \hyperdef{L}{X7A6F98FD85F02BFE}{} } \bibliographystyle{alpha} \bibliography{ANUPQ.bib} \addcontentsline{toc}{chapter}{References} \def\indexname{Index\logpage{[ "Ind", 0, 0 ]} \hyperdef{L}{X83A0356F839C696F}{} } \cleardoublepage \phantomsection \addcontentsline{toc}{chapter}{Index} \printindex \immediate\write\pagenrlog{["Ind", 0, 0], \arabic{page},} \newpage \immediate\write\pagenrlog{["End"], \arabic{page}];} \immediate\closeout\pagenrlog \end{document} anupq-3.3.3/doc/ragged.css0000644000175100017510000000023115111342310014745 0ustar runnerrunner/* times.css Frank Lübeck */ /* Change default CSS to use Times font. */ body { text-align: left; } anupq-3.3.3/doc/chooser.html0000644000175100017510000000745615111342310015352 0ustar runnerrunner GAPDoc Style Chooser

Setting preferences for GAPDoc manuals

Unfold subsections in menus only by mouse clicks: no (default)     yes

Show GAP examples as in sessions with ColorPrompt(true): yes (default)     no

Display side of table of contents within chapters: right (default)     left

Main document font: Helvetica/sans serif (default)     Times/serif

Paragraph formatting: left-right justified (default)     ragged right

Apply settings to last page.

anupq-3.3.3/doc/chapBib.html0000644000175100017510000002266015111342310015232 0ustar runnerrunner GAP (ANUPQ) - References
Goto Chapter: Top 1 2 3 4 5 6 7 A Bib Ind
 [Top of Book]  [Contents]   [Previous Chapter]   [Next Chapter] 

References

[HN80] Havas, G. and Newman, M. F., Application of computers to questions like those of Burnside, in Burnside groups (Proc. Workshop, Univ. Bielefeld, Bielefeld, 1977), Springer, Lecture Notes in Math., 806, Berlin (1980), 211--230.

[LS90] Leedham-Green, C. R. and Soicher, L. H., Collection from the left and other strategies, J. Symbolic Comput., 9 (5-6) (1990), 665--675
(Computational group theory, Part 1).

[New77] Newman, M. F., Determination of groups of prime-power order, in Group theory (Proc. Miniconf., Australian Nat. Univ., Canberra, 1975), Springer, Berlin (1977), 73--84. Lecture Notes in Math., Vol. 573.

[NNN98] Newman, M. F., Nickel, W. and Niemeyer, A. C., Descriptions of groups of prime-power order, J. Symbolic Comput., 25 (5) (1998), 665--682.

[NO96] Newman, M. F. and O'Brien, E. A., Application of computers to questions like those of Burnside. II, Internat. J. Algebra Comput., 6 (5) (1996), 593--605.

[O'B90] O'Brien, E. A., The p-group generation algorithm, J. Symbolic Comput., 9 (5-6) (1990), 677--698
(Computational group theory, Part 1).

[O'B94] O'Brien, E. A., Isomorphism testing for p-groups, J. Symbolic Comput., 17 (2) (1994), 131, 133--147.

[O'B95] O'Brien, E. A., Computing automorphism groups of p-groups, in Computational algebra and number theory (Sydney, 1992), Kluwer Acad. Publ., Math. Appl., 325, Dordrecht (1995), 83--90.

[Sim94] Sims, C. C., Computation with finitely presented groups, Cambridge University Press, Encyclopedia of Mathematics and its Applications, 48, Cambridge (1994), xiii+604 pages.

[Vau84] Vaughan-Lee, M. R., An aspect of the nilpotent quotient algorithm, in Computational group theory (Durham, 1982), Academic Press, London (1984), 75--83.

[Vau90a] Vaughan-Lee, M., The restricted Burnside problem, The Clarendon Press Oxford University Press, London Mathematical Society Monographs. New Series, 5, New York (1990), xiv+209 pages
(Oxford Science Publications).

[Vau90b] Vaughan-Lee, M. R., Collection from the left, J. Symbolic Comput., 9 (5-6) (1990), 725--733
(Computational group theory, Part 1).

 [Top of Book]  [Contents]   [Previous Chapter]   [Next Chapter] 
Goto Chapter: Top 1 2 3 4 5 6 7 A Bib Ind

generated by GAPDoc2HTML

anupq-3.3.3/doc/chap2_mj.html0000644000175100017510000007205515111342310015370 0ustar runnerrunner GAP (ANUPQ) - Chapter 2: Mathematical Background and Terminology
Goto Chapter: Top 1 2 3 4 5 6 7 A Bib Ind
 [Top of Book]  [Contents]   [Previous Chapter]   [Next Chapter] 

2 Mathematical Background and Terminology
 2.1 Basic notions

  2.1-1 pc Presentations and Consistency
  2.1-2 Exponent-\(p\) Central Series and Weighted pc Presentations
  2.1-3 \(p\)-Cover, \(p\)-Multiplicator
  2.1-4 Descendants, Capable, Terminal, Nucleus
  2.1-5 Laws
 2.2 The p-quotient Algorithm

  2.2-1 Finding the \(p\)-cover
  2.2-2 Imposing the Relations of the fp Group
  2.2-3 Imposing Laws
 2.3 The p-group generation Algorithm, Standard Presentation, Isomorphism Testing

2 Mathematical Background and Terminology

In this chapter we will give a brief description of the mathematical notions used in the algorithms implemented in the ANU pq program that are made accessible from GAP through this package. For proofs and details we will point to relevant places in the published literature. Also we will try to give some explanation of terminology that may help to use the low-level interactive functions described in Section Low-level Interactive ANUPQ functions based on menu items of the pq program. However, users who intend to use these functions are strongly advised to acquire a thorough understanding of the algorithms from the quoted literature. There is little or no checking done in these functions and naive use may result in incorrect results.

2.1 Basic notions

Throughout this manual, by \(p\)-group we always mean finite \(p\)-group.

2.1-1 pc Presentations and Consistency

For details, see e.g. [NNN98].

Every finite \(p\)-group \(G\) has a presentation of the form:

\[ \{a_1,\dots,a_n \mid a_i^p = v_{ii}, 1 \le i \le n, [a_k, a_j] = v_{jk}, 1 \le j < k \le n \}. \]

where \(v_{jk}\) is a word in the elements \(a_{k+1},\dots,a_n\) for \(1 \le j \leq k \le n\).

This is called a power-commutator presentation (or pc presentation or pcp) of \(G\), generators from such a presentation will be referred to as pc generators. In terms of such pc generators every element of \(G\) can be written in a normal form \(a_1^{e_1}\dots a_n^{e_n}\) with \(0 \le e_i < p\). Moreover any given product of the generators can be brought into such a normal form using the defining relations in the above presentation as rewrite rules. Any such process is called collection. For the discussion of various collection methods see [LS90] and [Vau90b].

Every \(p\)-group of order \(p^n\) has such a pcp on \(n\) generators and conversely every such presentation defines a \(p\)-group. However a \(p\)-group defined by a pcp on \(n\) generators can be of smaller order \(p^m\) with \(m<n\). A pcp on \(n\) generators that does in fact define a \(p\)-group of order \(p^n\) is called consistent in this manual, in line with most of the literature on the algorithms occurring here. A consistent pcp determines a confluent rewriting system (see IsConfluent (Reference: IsConfluent) of the GAP Reference Manual) for the group it defines and for this reason often (in particular in the GAP Reference Manual) such a pcp presentation is also called confluent.

Consistency of a pcp is tantamount to the fact that for any given word in the generators any two collections will yield the same normal form.

Consistency of a pcp can be checked by a finite set of consistency conditions, demanding that collection of the left hand side and of the right hand side of certain equations, starting with subproducts indicated by bracketing, will result in the same normal form. There are 3 types of such equations (that will be referred to in the manual):

\[ \begin{array}{rclrl} (a^n)a &=& a(a^n) &&{\rm (Type 1)} \\ (b^n)a &=& b^{(n-1)}(ba), b(a^n) = (ba)a^{(n-1)} &&{\rm (Type 2)} \\ c(ba) &=& (cb)a &&{\rm (Type 3)} \\ \end{array} \]

See [Vau84] for a description of a sufficient set of consistency conditions in the context of the \(p\)-quotient algorithm.

2.1-2 Exponent-\(p\) Central Series and Weighted pc Presentations

For details, see [NNN98].

The (descending or lower) (exponent-)\(p\)-central series of an arbitrary group \(G\) is defined by

\[ P_0(G) := G, P_i(G) := [G, P_{i-1}(G)] P_{i-1}(G)^p. \]

For a \(p\)-group \(G\) this series terminates with the trivial group. \(G\) has \(p\)-class \(c\) if \(c\) is the smallest integer such that \(P_c(G)\) is the trivial group. In this manual, as well as in much of the literature about the pq- and related algorithms, the \(p\)-class is often referred to simply by class.

Let the \(p\)-group \(G\) have a consistent pcp as above. Then the subgroups

\[ \langle1\rangle < {\langle}a_n\rangle < {\langle}a_n, a_{n-1}\rangle < \dots < {\langle}a_n,\dots,a_i\rangle < \dots < G \]

form a central series of \(G\). If this refines the \(p\)-central series, we can define the weight function \(w\) for the pc generators by \(w(a_i) = k\), if \(a_i\) is contained in \(P_{k-1}(G)\) but not in \(P_k(G)\).

The pair of such a weight function and a pcp allowing it, is called a weighted pcp.

2.1-3 \(p\)-Cover, \(p\)-Multiplicator

For details, see [NNN98].

Let \(d\) be the minimal number of generators of the \(p\)-group \(G\) of \(p\)-class \(c\). Then \(G\) is isomorphic to a factor group \(F/R\) of a free group \(F\) of rank \(d\). We denote \([F, R] R^p\) by \(R^*\). It can be proved (see e.g. [O'B90]) that the isomorphism type of \(G^* := F/R^*\) depends only on \(G\). \(G^*\) is called the \(p\)-covering group or \(p\)-cover of \(G\), and \(R/R^*\) the \(p\)-multiplicator of \(G\). The \(p\)-multiplicator is, of course, an elementary abelian \(p\)-group; its minimal number of generators is called the (\(p\)-)multiplicator rank.

2.1-4 Descendants, Capable, Terminal, Nucleus

For details, see [New77] and [O'B90].

Let again \(G\) be a \(p\)-group of \(p\)-class \(c\) and \(d\) the minimal number of generators of \(G\). A \(p\)-group \(H\) is a descendant of \(G\) if the minimal number of generators of \(H\) is \(d\) and \(H/P_c(H)\) is isomorphic to \(G\). A descendant \(H\) of \(G\) is a proper descendant if it has \(p\)-class at least \(c+1\). A descendant \(H\) of \(G\) is an immediate descendant if it has \(p\)-class \(c+1\). \(G\) is called capable if it has immediate descendants; otherwise it is terminal.

Let \(G^* = F/R^*\) again be the \(p\)-cover of \(G\). Then the group \(P_c(G^*)\) is called the nucleus of \(G\). Note that \(P_c(G^*)\) is contained in the \(p\)-multiplicator \(R/R^*\).

It is proved (e.g. in [O'B90]) that the immediate descendants of \(G\) are obtained as factor groups of the \(p\)-cover by (proper) supplements of the nucleus in the (elementary abelian) \(p\)-multiplicator. These are also called allowable.

It is further proved there that every automorphism \(\alpha\) of \(F/R\) extends to an automorphism \(\alpha^*\) of the \(p\)-cover \(F/R^*\) and that the restriction of \(\alpha^*\) to the multiplicator \(R/R^*\) is uniquely determined by \(\alpha\). Each extended automorphism \(\alpha^*\) induces a permutation of the allowable subgroups. Thus the extended automorphisms determine a group \(P\) of permutations on the set \(A\) of allowable subgroups (The group \(P\) of permutations will appear in the description of some interactive functions). Choosing a representative \(S\) from each orbit of \(P\) on \(A\), the set of factor groups \(F/S\) contains each (isomorphism type of) immediate descendant of \(G\) exactly once. For each immediate descendant, the procedure of computing the \(p\)-cover, extending the automorphisms and computing the orbits on allowable subgroups can be repeated. Iteration of this procedure can in principle be used to determine all descendants of a \(p\)-group.

2.1-5 Laws

Let \(l(x_1, \dots, x_n)\) be a word in the free generators \(x_1, \dots, x_n\) of a free group of rank \(n\). Then \(l(x_1, \dots, x_n) = 1\) is called a law or identical relation in a group \(G\) if \(l(g_1, \dots, g_n) = 1\) for any choice of elements \(g_1, \dots, g_n\) in \(G\). In particular, \(x^e = 1\) is called an exponent law, \([[x,y],[u,v]] = 1\) the metabelian law, and \([\dots [[x_1,x_2],x_2],\dots, x_2] = 1\) an Engel identity.

2.2 The p-quotient Algorithm

For details, see [HN80], [NO96] and [Vau84]. Other descriptions of the algorithm are given in [Sim94].

The pq algorithm successively determines the factor groups of the groups of the \(p\)-central series of a finitely presented (fp) group \(G\). If a bound \(b\) for the \(p\)-class is given, the algorithm will determine those factor groups up to at most \(p\)-class \(b\). If the \(p\)-central series terminates with a subgroup \(P_k(G)\) with \(k < b\), the algorithm will stop with that group. If no such bound is given, it will try to find the biggest such factor group.

\(G/P_1(G)\) is the largest elementary abelian \(p\)-factor group of \(G\) and this can be found from the relation matrix of \(G\) using matrix diagonalisation modulo \(p\). So it suffices to explain how \(G/P_{i+1}(G)\) is found from \(G\) and \(G/P_i(G)\) for some \(i \ge 1\).

This is done, in principle, in two steps: first the \(p\)-cover of \(G_i := G/P_i(G)\) is determined (which depends only on \(G_i\), not on \(G\)) and then \(G/P_{i+1}(G)\) as a factor group of this \(p\)-cover.

2.2-1 Finding the \(p\)-cover

A very detailed description of the first step is given in [NNN98], from which we just extract some passages in order to point to some terms occurring in this manual.

Let \(H\) be a \(p\)-group and \(p^{d(b)}\) be the order of \(H/P_b(H)\). So \(d := d(1)\) is the minimal number of generators of \(H\). A weighted pcp of \(H\) will be called labelled if for each generator \(a_k\), \(k > d\) one relation, having this generator as its right hand side, is marked as definition of this generator.

As described in [NNN98], a weighted labelled pcp of a \(p\)-group can be obtained stepping down its \(p\)-central series.

So let us assume that a weighted labelled pcp of \(G_i\) is given. A straightforward way of of writing down a (not necessarily consistent) pcp for its \(p\)-cover is to add generators, one for each relation which is not a definition, and modify the right hand side of each such relation by multiplying it on the right by one of the new generators -- a different generator for each such relation. Further relations are then added to make the new generators central and of order \(p\). This procedure is called adding tails. A more formal description of it is again given in [NNN98].

It is important to realise that the new generators will generate an elementary abelian group, that is, in additive notation, a vector space over the field of \(p\) elements. As said, the pcp of the \(p\)-cover obtained in this way need not be consistent. Since the pcp of \(G_i\) was consistent, applying the consistency conditions to the pcp of the \(p\)-cover, in case the presentation obtained for \(p\)-cover is not consistent, will produce a set of equations between the new generators, that, written additively, are linear equations over the field of \(p\) elements and can hence be used to remove redundant generators until a consistent pcp is obtained.

In reality, to follow this straightforward procedure would be forbiddingly inefficient except for very small examples. There are many ways of a priori reducing the number of new generators to be introduced, using e.g. the weights attached to the generators, and the main part of [NNN98] is devoted to a detailed discussion with proofs of these possibilities.

2.2-2 Imposing the Relations of the fp Group

In order to obtain \(G/P_{i+1}(G)\) from the pcp of the \(p\)-cover of \(G_i = G/P_i(G)\), the defining relations from the original presentation of \(G\) must be imposed. Since \(G_i\) is a homomorphic image of \(G\), these relations again yield relations between the new generators in the presentation of the \(p\)-cover of \(G_i\).

2.2-3 Imposing Laws

While we have so far only considered the computation of the factor groups of a given fp group by the groups of its descending \(p\)-central series, the \(p\)-quotient algorithm allows a very important variant of this idea: laws can be prescribed that should be fulfilled by the \(p\)-factor groups computed by the algorithm. The key observation here is the fact that at each step down the descending \(p\)-central series it suffices to impose these laws only for a finite number of words. Again for efficiency of the method it is crucial to keep the number of such words small, and much of [NO96] and the literature quoted in this paper is devoted to this problem.

In this form, starting with a free group and imposing an exponent law (also referred to as an exponent check) the pq program has, in fact, found its most noted application in the determination of (restricted) Burnside groups (as reported in e.g. [HN80], [NO96] and [Vau90a]).

Via a GAP program using the local interactive functions of the pq program made available through this interface also arbitrary laws can be imposed via the option Identities (see 6.2).

2.3 The p-group generation Algorithm, Standard Presentation, Isomorphism Testing

For details, see [New77] and [O'B90].

The \(p\)-group generation algorithm determines the immediate descendants of a given \(p\)-group \(G\) up to isomorphism. From what has been explained in Section Basic notions, it is clear that this amounts to the construction of the \(p\)-cover, the extension of the automorphisms of \(G\) to the \(p\)-cover and the determination of representatives of the orbits of the action of these automorphisms on the set of supplements of the nucleus in the \(p\)-multiplicator.

The main practical problem here is the determination of these representatives. [O'B90] describes methods for this and the pq program allows choices according to whether space or time limitations must be met.

As well as the descendants of \(G\), the pq program determines their automorphism groups from that of \(G\) (see [O'B95]), which is important for an iteration of the process; this has been used by Eamonn O'Brien, e.g. in the classification of the \(2\)-groups that are now also part of the Small Groups library available through GAP.

A variant of the \(p\)-group generation algorithm is also used to define a standard presentation of a given \(p\)-group. This is done by constructing an isomorphic copy of the given group through a chain of descendants and at each step making a choice of a particular representative for the respective orbit of capable groups. In a fairly delicate process, subgroups of the \(p\)-multiplicator are represented by echelonised matrices and a first among the labels for standard matrices is chosen (this is described in detail in [O'B94]).

Finally, the standard presentation provides a way of testing if two given \(p\)-groups are isomorphic: the standard presentations of the groups are computed, for practical purposes compacted and the results compared for being identical, i.e. the groups are isomorphic if and only if their standard presentations are identical.

 [Top of Book]  [Contents]   [Previous Chapter]   [Next Chapter] 
Goto Chapter: Top 1 2 3 4 5 6 7 A Bib Ind

generated by GAPDoc2HTML

anupq-3.3.3/doc/chap6.txt0000644000175100017510000007261015111342310014556 0ustar runnerrunner 6 ANUPQ Options 6.1 Overview In this chapter we describe in detail all the options used by functions of the ANUPQ package. Note that by options we mean GAP options that are passed to functions after the arguments and separated from the arguments by a colon as described in Chapter Reference: Function Calls in the Reference Manual. The user is strongly advised to read Section 'Hints and Warnings regarding the use of Options'. 6.1-1 AllANUPQoptions AllANUPQoptions( )  function lists all the GAP options defined for functions of the ANUPQ package:  Example  gap> AllANUPQoptions(); [ "AllDescendants", "BasicAlgorithm", "Bounds", "CapableDescendants",   "ClassBound", "CustomiseOutput", "Exponent", "Filename", "GroupName",   "Identities", "Metabelian", "NumberOfSolubleAutomorphisms", "OrderBound",   "OutputLevel", "PcgsAutomorphisms", "PqWorkspace", "Prime",   "PrintAutomorphisms", "PrintPermutations", "QueueFactor",   "RankInitialSegmentSubgroups", "RedoPcp", "RelativeOrders", "Relators",   "SetupFile", "SpaceEfficient", "StandardPresentationFile", "StepSize",   "SubList", "TreeDepth", "pQuotient" ]  The following global variable gives a partial breakdown of where the above options are used. 6.1-2 ANUPQoptions ANUPQoptions  global variable is a record of lists of names of admissible ANUPQ options, such that each field is either the name of a key ANUPQ function or other (for a miscellaneous list of functions) and the corresponding value is the list of option names that are admissible for the function (or miscellaneous list of functions). Also, from within a GAP session, you may use GAP's help browser (see Chapter Reference: The Help System in the GAP Reference Manual); to find out about any particular ANUPQ option, simply type: ?option option, where option is one of the options listed above without any quotes, e.g.  Example  gap> ?option Prime  will display the sections in this manual that describe the Prime option. In fact the first 4 are for the functions that have Prime as an option and the last actually describes the option. So follow up by choosing  Example  gap> ?5  This is also the pattern for other options (the last section of the list always describes the option; the other sections are the functions with which the option may be used). In the section following we describe in detail all ANUPQ options. To continue onto the next section on-line using GAP's help browser, type:  Example  gap> ?>  6.2 Detailed descriptions of ANUPQ Options Prime := p  Specifies that the p-quotient for the prime p should be computed. ClassBound := n  Specifies that the p-quotient to be computed has lower exponent-p class at most n. If this option is omitted a default of 63 (which is the maximum possible for the pq program) is taken, except for PqDescendants (see PqDescendants (4.4-1)) and in a special case of PqPCover (see PqPCover (4.1-3)). Let F be the argument (or start group of the process in the interactive case) for the function; then for PqDescendants the default is PClassPGroup(F) + 1, and for the special case of PqPCover the default is PClassPGroup(F). pQuotient := Q  This option is only available for the standard presentation functions. It specifies that a p-quotient of the group argument of the function or group of the process is the pc p-group Q, where Q is of class less than the provided (or default) value of ClassBound. If pQuotient is provided, then the option Prime if also provided, is ignored; the prime p is discovered by computing PrimePGroup(Q). Exponent := n  Specifies that the p-quotient to be computed has exponent n. For an interactive process, Exponent defaults to a previously supplied value for the process. Otherwise (and non-interactively), the default is 0, which means that no exponent law is enforced. Relators := rels  Specifies that the relators sent to the pq program should be rels instead of the relators of the argument group F (or start group in the interactive case) of the calling function; rels should be a list of strings in the string representations of the generators of F, and F must be an fp group (even if the calling function accepts a pc group). This option provides a way of giving relators to the pq program, without having them pre-expanded by GAP, which can sometimes effect a performance loss of the order of 100 (see Section 'The Relators Option'). Notes 1 The pq program does not use / to indicate multiplication by an inverse and uses square brackets to represent (left normed) commutators. Also, even though the pq program accepts relations, all elements of rels must be in relator form, i.e. a relation of form w1 = w2 must be written as w1*(w2)^-1 and then put in a pair of double-quotes to make it a string. See the example below. 2 To ensure there are no syntax errors in rels, each relator is parsed for validity via PqParseWord (see PqParseWord (3.4-3)). If they are ok, a message to say so is Info-ed at InfoANUPQ level 2. Metabelian  Specifies that the largest metabelian p-quotient subject to any other conditions specified by other options be constructed. By default this restriction is not enforced. GroupName := name  Specifies that the pq program should refer to the group by the name name (a string). If GroupName is not set and the group has been assigned a name via SetName (see Reference: Name) it is set as the name the pq program should use. Otherwise, the generic name "[grp]" is set as a default. Identities := funcs  Specifies that the pc presentation should satisfy the laws defined by each function in the list funcs. This option may be called by Pq, PqEpimorphism, or PqPCover (see Pq (4.1-1)). Each function in the list funcs must return a word in its arguments (there may be any number of arguments). Let identity be one such function in funcs. Then as each lower exponent p-class quotient is formed, instances identity(w1, dots, wn) are added as relators to the pc presentation, where w1, dots, wn are words in the pc generators of the quotient. At each class the class and number of pc generators is Info-ed at InfoANUPQ level 1, the number of instances is Info-ed at InfoANUPQ level 2, and the instances that are evaluated are Info-ed at InfoANUPQ level 3. As usual timing information is Info-ed at InfoANUPQ level 2; and details of the processing of each instance from the pq program (which is often quite voluminous) is Info-ed at InfoANUPQ level 3. Try the examples "B2-4-Id" and "11gp-3-Engel-Id" which demonstrate the usage of the Identities option; these are run using PqExample (see PqExample (3.4-4)). Take note of Note 1. below in relation to the example "B2-4-Id"; the companion example "B2-4" generates the same group using the Exponent option. These examples are discussed at length in Section 'The Identities Option and PqEvaluateIdentities Function'. Notes 1 Setting the InfoANUPQ level to 3 or more when setting the Identities option may slow down the computation considerably, by overloading GAP with io operations. 2 The Identities option is implemented at the GAP level. An identity that is just an exponent law should be specified using the Exponent option (see option Exponent), which is implemented at the C level and is highly optimised and so is much more efficient. 3 The number of instances of each identity tends to grow combinatorially with the class. So care should be exercised in using the Identities option, by including other restrictions, e.g. by using the ClassBound option (see option ClassBound). OutputLevel := n  Specifies the level of verbosity of the information output by the ANU pq program when computing a pc presentation; n must be an integer in the range 0 to 3. OutputLevel := 0 displays at most one line of output and is the default; OutputLevel := 1 displays (usually) slightly more output and OutputLevels of 2 and 3 are two levels of verbose output. To see these messages from the pq program, the InfoANUPQ level must be set to at least 1 (see InfoANUPQ (3.3-1)). See Section 'Hints and Warnings regarding the use of Options' for an example of how OutputLevel can be used as a troubleshooting tool. RedoPcp  Specifies that the current pc presentation (for an interactive process) stored by the pq program be scrapped and clears the current values stored for the options Prime, ClassBound, Exponent and Metabelian and also clears the pQuotient, pQepi and pCover fields of the data record of the process. SetupFile := filename  Non-interactively, this option directs that pq should not be called and that an input file with name filename (a string), containing the commands necessary for the ANU pq standalone, be constructed. The commands written to filename are also Info-ed behind a ToPQ>  prompt at InfoANUPQ level 4 (see InfoANUPQ (3.3-1)). Except in the case following, the calling function returns true. If the calling function is the non-interactive version of one of Pq, PqPCover or PqEpimorphism and the group provided as argument is trivial given with an empty set of generators, then no setup file is written and fail is returned (the pq program cannot do anything useful with such a group). Interactively, SetupFile is ignored. Note: Since commands emitted to the pq program may depend on knowing what the current state is, to form a setup file some close enough guesses may sometimes be necessary; when this occurs a warning is Info-ed at InfoANUPQ or InfoWarning level 1. To determine whether the close enough guesses give an accurate setup file, it is necessary to run the command without the SetupFile option, after either setting the InfoANUPQ level to at least 4 (the setup file script can then be compared with the ToPQ>  commands that are Info-ed) or setting a pq command log file by using ToPQLog (see ToPQLog (3.4-7)). PqWorkspace := workspace  Non-interactively, this option sets the memory used by the pq program. It sets the maximum number of integer-sized elements to allocate in its main storage array. By default, the pq program sets this figure to 10000000. Interactively, PqWorkspace is ignored; the memory used in this case may be set by giving PqStart a second argument (see PqStart (5.1-1)). PcgsAutomorphisms  PcgsAutomorphisms := false  Let G be the group associated with the calling function (or associated interactive process). Passing the option PcgsAutomorphisms without a value (or equivalently setting it to true), specifies that a polycyclic generating sequence for the automorphism group (which must be soluble) of G, be computed and passed to the pq program. This increases the efficiency of the computation; it also prevents the pq from calling GAP for orbit-stabilizer calculations. By default, PcgsAutomorphisms is set to the value returned by IsSolvable( AutomorphismGroup( G ) ), and uses the package AutPGrp to compute AutomorphismGroup( G ) if it is installed. This flag is set to true or false in the background according to the above criterion by the function PqDescendants (see PqDescendants (4.4-1) and PqDescendants (5.3-6)). Note: If PcgsAutomorphisms is used when the automorphism group of G is insoluble, an error message occurs. OrderBound := n  Specifies that only descendants of size at most p^n, where n is a non-negative integer, be generated. Note that you cannot set both OrderBound and StepSize. StepSize := n  StepSize := list  For a positive integer n, StepSize specifies that only those immediate descendants which are a factor p^n bigger than their parent group be generated. For a list list of positive integers such that the sum of the length of list and the exponent-p class of G is equal to the class bound defined by the option ClassBound, StepSize specifies that the integers of list are the step sizes for each additional class. RankInitialSegmentSubgroups := n  Sets the rank of the initial segment subgroup chosen to be n. By default, this has value 0. SpaceEfficient  Specifies that the pq program performs certain calculations of p-group generation more slowly but with greater space efficiency. This flag is frequently necessary for groups of large Frattini quotient rank. The space saving occurs because only one permutation is stored at any one time. This option is only available if the PcgsAutomorphisms flag is set to true (see option PcgsAutomorphisms). For an interactive process, SpaceEfficient defaults to a previously supplied value for the process. Otherwise (and non-interactively), SpaceEfficient is by default false. CapableDescendants  By default, all (i.e. capable and terminal) descendants are computed. If this flag is set, only capable descendants are computed. Setting this option is equivalent to setting AllDescendants := false (see option AllDescendants), except if both CapableDescendants and AllDescendants are passed, AllDescendants is essentially ignored. AllDescendants := false  By default, all descendants are constructed. If this flag is set to false, only capable descendants are computed. Passing AllDescendants without a value (which is equivalent to setting it to true) is superfluous. This option is provided only for backward compatibility with the GAP 3 version of the ANUPQ package, where by default AllDescendants was set to false (rather than true). It is preferable to use CapableDescendants (see option CapableDescendants). TreeDepth := class  Specifies that the descendants tree developed by PqDescendantsTreeCoclassOne (see PqDescendantsTreeCoclassOne (A.4-1)) should be extended to class class, where class is a positive integer. SubList := sub  Suppose that L is the list of descendants generated, then for a list sub of integers this option causes PqDescendants to return Sublist( L, sub ). If an integer n is supplied, PqDescendants returns L[n]. NumberOfSolubleAutomorphisms := n  Specifies that the number of soluble automorphisms of the automorphism group supplied by PqPGSupplyAutomorphisms (see PqPGSupplyAutomorphisms (5.9-1)) in a p-group generation calculation is n. By default, n is taken to be 0; n must be a non-negative integer. If n ≥ 0 then a value for the option RelativeOrders (see 6.2) must also be supplied. RelativeOrders := list  Specifies the relative orders of each soluble automorphism of the automorphism group supplied by PqPGSupplyAutomorphisms (see PqPGSupplyAutomorphisms (5.9-1)) in a p-group generation calculation. The list list must consist of n positive integers, where n is the value of the option NumberOfSolubleAutomorphisms (see 6.2). By default list is empty. BasicAlgorithm  Specifies that an algorithm that the pq program calls its default algorithm be used for p-group generation. By default this algorithm is not used. If this option is supplied the settings of options RankInitialSegmentSubgroups, AllDescendants, Exponent and Metabelian are ignored. CustomiseOutput := rec  Specifies that fine tuning of the output is desired. The record rec should have any subset (or all) of the the following fields: perm := list where list is a list of booleans which determine whether the permutation group output for the automorphism group should contain: the degree, the extended automorphisms, the automorphism matrices, and the permutations, respectively. orbit := list where list is a list of booleans which determine whether the orbit output of the action of the automorphism group should contain: a summary, and a complete listing of orbits, respectively. (It's possible to have both a summary and a complete listing.) group := list where list is a list of booleans which determine whether the group output should contain: the standard matrix of each allowable subgroup, the presentation of reduced p-covering groups, the presentation of immediate descendants, the nuclear rank of descendants, and the p-multiplicator rank of descendants, respectively. autgroup := list where list is a list of booleans which determine whether the automorphism group output should contain: the commutator matrix, the automorphism group description of descendants, and the automorphism group order of descendants, respectively. trace := val where val is a boolean which if true specifies algorithm trace data is desired. By default, one does not get algorithm trace data. Not providing a field (or mis-spelling it!), specifies that the default output is desired. As a convenience, 1 is also accepted as true, and any value that is neither 1 nor true is taken as false. Also for each list above, an unbound list entry is taken as false. Thus, for example   Example  CustomiseOutput := rec(group := [,,1], autgroup := [,1])  specifies for the group output that only the presentation of immediate descendants is desired, for the automorphism group output only the automorphism group description of descendants should be printed, that there should be no algorithm trace data, and that the default output should be provided for the permutation group and orbit output. StandardPresentationFile := filename  Specifies that the file to which the standard presentation is written has name filename. If the first character of the string filename is not /, filename is assumed to be the path of a writable file relative to the directory in which GAP was started. If this option is omitted it is written to the file with the name generated by the command Filename( ANUPQData.tmpdir, "SPres" );, i.e. the file with name "SPres" in the temporary directory in which the pq program executes. QueueFactor := n  Specifies a queue factor of n, where n must be a positive integer. This option may be used with PqNextClass (see PqNextClass (5.6-4)). The queue factor is used when the pq program uses automorphisms to close a set of elements of the p-multiplicator under their action. The algorithm used is a spinning algorithm: it starts with a set of vectors in echelonized form (elements of the p-multiplicator) and closes the span of these vectors under the action of the automorphisms. For this each automorphism is applied to each vector and it is checked if the result is contained in the span computed so far. If not, the span becomes bigger and the vector is put into a queue and the automorphisms are applied to this vector at a later stage. The process terminates when the automorphisms have been applied to all vectors and no new vectors have been produced. For each new vector it is decided, if its processing should be delayed. If the vector contains too many non-zero entries, it is put into a second queue. The elements in this queue are processed only when there are no elements in the first queue left. The queue factor is a percentage figure. A vector is put into the second queue if the percentage of its non-zero entries exceeds the queue factor. Bounds := list  Specifies a lower and upper bound on the indices of a list, where list is a pair of positive non-decreasing integers. See PqDisplayStructure (5.7-23) and PqDisplayAutomorphisms (5.7-24) where this option may be used. PrintAutomorphisms := list  Specifies that automorphism matrices be printed. PrintPermutations := list  Specifies that permutations of the subgroups be printed. Filename := string  Specifies that an output or input file to be written to or read from by the pq program should have the name string. anupq-3.3.3/doc/chap0.html0000644000175100017510000006572515111342310014706 0ustar runnerrunner GAP (ANUPQ) - Contents
Goto Chapter: Top 1 2 3 4 5 6 7 A Bib Ind
 [Top of Book]  [Contents]   [Next Chapter] 

ANUPQ

ANU p-Quotient

3.3.3

25 November 2025

ANUPQ is maintained by Max Horn. For support requests, please use our issue tracker.

Greg Gamble
Email: Greg.Gamble@uwa.edu.au

Werner Nickel

Eamonn O'Brien
Email: obrien@math.auckland.ac.nz
Homepage: https://www.math.auckland.ac.nz/~obrien

Copyright

© 2001-2016 by Greg Gamble

© 2001-2005 by Werner Nickel

© 1995-2001 by Eamon O'Brien

The GAP package ANUPQ is licensed under the Artistic License 2.0.

Contents

1 Introduction
 1.1 Overview
 1.2 How to read this manual
 1.3 Authors and Acknowledgements
2 Mathematical Background and Terminology
 2.1 Basic notions

  2.1-1 pc Presentations and Consistency
  2.1-2 Exponent-p Central Series and Weighted pc Presentations
  2.1-3 p-Cover, p-Multiplicator
  2.1-4 Descendants, Capable, Terminal, Nucleus
  2.1-5 Laws
 2.2 The p-quotient Algorithm

  2.2-1 Finding the p-cover
  2.2-2 Imposing the Relations of the fp Group
  2.2-3 Imposing Laws
 2.3 The p-group generation Algorithm, Standard Presentation, Isomorphism Testing
3 Infrastructure
 3.1 Loading the ANUPQ Package
 3.2 The ANUPQData Record

  3.2-1 ANUPQData
  3.2-2 ANUPQDirectoryTemporary
 3.3 Setting the Verbosity of ANUPQ via Info and InfoANUPQ

  3.3-1 InfoANUPQ
 3.4 Utility Functions

  3.4-1 PqLeftNormComm
  3.4-2 PqGAPRelators
  3.4-3 PqParseWord
  3.4-4 PqExample
  3.4-5 AllPqExamples
  3.4-6 GrepPqExamples
  3.4-7 ToPQLog
 3.5 Attributes and a Property for fp and pc p-groups

  3.5-1 NuclearRank
 3.6 Hints and Warnings regarding the use of Options

  3.6-1 ANUPQWarnOfOtherOptions
4 Non-interactive ANUPQ functions
 4.1 Computing p-Quotients

  4.1-1 Pq
  4.1-2 PqEpimorphism
  4.1-3 PqPCover
 4.2 Computing Standard Presentations

  4.2-1 PqStandardPresentation
  4.2-2 EpimorphismPqStandardPresentation
 4.3 Testing p-Groups for Isomorphism

  4.3-1 IsPqIsomorphicPGroup
 4.4 Computing Descendants of a p-Group

  4.4-1 PqDescendants
  4.4-2 PqSupplementInnerAutomorphisms
  4.4-3 PqList
  4.4-4 SavePqList
5 Interactive ANUPQ functions
 5.1 Starting and Stopping Interactive ANUPQ Processes

  5.1-1 PqStart
  5.1-2 PqQuit
  5.1-3 PqQuitAll
 5.2 Interactive ANUPQ Process Utility Functions

  5.2-1 PqProcessIndex
  5.2-2 PqProcessIndices
  5.2-3 IsPqProcessAlive
 5.3 Interactive Versions of Non-interactive ANUPQ Functions

  5.3-1 Pq
  5.3-2 PqEpimorphism
  5.3-3 PqPCover
  5.3-4 PqStandardPresentation
  5.3-5 EpimorphismPqStandardPresentation
  5.3-6 PqDescendants
  5.3-7 PqSetPQuotientToGroup
 5.4 Low-level Interactive ANUPQ functions based on menu items of the pq program
 5.5 General commands

  5.5-1 PqNrPcGenerators
  5.5-2 PqFactoredOrder
  5.5-3 PqOrder
  5.5-4 PqPClass
  5.5-5 PqWeight
  5.5-6 PqCurrentGroup
  5.5-7 PqDisplayPcPresentation
  5.5-8 PqSetOutputLevel
  5.5-9 PqEvaluateIdentities
 5.6 Commands from the Main p-Quotient menu

  5.6-1 PqPcPresentation
  5.6-2 PqSavePcPresentation
  5.6-3 PqRestorePcPresentation
  5.6-4 PqNextClass
  5.6-5 PqComputePCover
 5.7 Commands from the Advanced p-Quotient menu

  5.7-1 PqCollect
  5.7-2 PqSolveEquation
  5.7-3 PqCommutator
  5.7-4 PqSetupTablesForNextClass
  5.7-5 PqTails
  5.7-6 PqComputeTails
  5.7-7 PqAddTails
  5.7-8 PqDoConsistencyChecks
  5.7-9 PqCollectDefiningRelations
  5.7-10 PqCollectWordInDefiningGenerators
  5.7-11 PqCommutatorDefiningGenerators
  5.7-12 PqDoExponentChecks
  5.7-13 PqEliminateRedundantGenerators
  5.7-14 PqRevertToPreviousClass
  5.7-15 PqSetMaximalOccurrences
  5.7-16 PqSetMetabelian
  5.7-17 PqDoConsistencyCheck
  5.7-18 PqCompact
  5.7-19 PqEchelonise
  5.7-20 PqSupplyAutomorphisms
  5.7-21 PqExtendAutomorphisms
  5.7-22 PqApplyAutomorphisms
  5.7-23 PqDisplayStructure
  5.7-24 PqDisplayAutomorphisms
  5.7-25 PqWritePcPresentation
 5.8 Commands from the Standard Presentation menu

  5.8-1 PqSPComputePcpAndPCover
  5.8-2 PqSPStandardPresentation
  5.8-3 PqSPSavePresentation
  5.8-4 PqSPCompareTwoFilePresentations
  5.8-5 PqSPIsomorphism
 5.9 Commands from the Main p-Group Generation menu

  5.9-1 PqPGSupplyAutomorphisms
  5.9-2 PqPGExtendAutomorphisms
  5.9-3 PqPGConstructDescendants
  5.9-4 PqPGSetDescendantToPcp
 5.10 Commands from the Advanced p-Group Generation menu

  5.10-1 PqAPGDegree
  5.10-2 PqAPGPermutations
  5.10-3 PqAPGOrbits
  5.10-4 PqAPGOrbitRepresentatives
  5.10-5 PqAPGSingleStage
 5.11 Primitive Interactive ANUPQ Process Read/Write Functions

  5.11-1 PqRead
  5.11-2 PqReadAll
  5.11-3 PqReadUntil
  5.11-4 PqWrite
6 ANUPQ Options
 6.1 Overview

  6.1-1 AllANUPQoptions
  6.1-2 ANUPQoptions
 6.2 Detailed descriptions of ANUPQ Options
7 Installing the ANUPQ Package
 7.1 Testing your ANUPQ installation
 7.2 Running the pq program as a standalone
A Examples
 A.1 The Relators Option
 A.2 The Identities Option and PqEvaluateIdentities Function
 A.3 A Large Example
 A.4 Developing descendants trees

  A.4-1 PqDescendantsTreeCoclassOne
References
Index

 [Top of Book]  [Contents]   [Next Chapter] 
Goto Chapter: Top 1 2 3 4 5 6 7 A Bib Ind

generated by GAPDoc2HTML

anupq-3.3.3/doc/chap0_mj.html0000644000175100017510000006720415111342310015366 0ustar runnerrunner GAP (ANUPQ) - Contents
Goto Chapter: Top 1 2 3 4 5 6 7 A Bib Ind
 [Top of Book]  [Contents]   [Next Chapter] 

ANUPQ

ANU p-Quotient

3.3.3

25 November 2025

ANUPQ is maintained by Max Horn. For support requests, please use our issue tracker.

Greg Gamble
Email: Greg.Gamble@uwa.edu.au

Werner Nickel

Eamonn O'Brien
Email: obrien@math.auckland.ac.nz
Homepage: https://www.math.auckland.ac.nz/~obrien

Copyright

© 2001-2016 by Greg Gamble

© 2001-2005 by Werner Nickel

© 1995-2001 by Eamon O'Brien

The GAP package ANUPQ is licensed under the Artistic License 2.0.

Contents

1 Introduction
 1.1 Overview
 1.2 How to read this manual
 1.3 Authors and Acknowledgements
2 Mathematical Background and Terminology
 2.1 Basic notions

  2.1-1 pc Presentations and Consistency
  2.1-2 Exponent-\(p\) Central Series and Weighted pc Presentations
  2.1-3 \(p\)-Cover, \(p\)-Multiplicator
  2.1-4 Descendants, Capable, Terminal, Nucleus
  2.1-5 Laws
 2.2 The p-quotient Algorithm

  2.2-1 Finding the \(p\)-cover
  2.2-2 Imposing the Relations of the fp Group
  2.2-3 Imposing Laws
 2.3 The p-group generation Algorithm, Standard Presentation, Isomorphism Testing
3 Infrastructure
 3.1 Loading the ANUPQ Package
 3.2 The ANUPQData Record

  3.2-1 ANUPQData
  3.2-2 ANUPQDirectoryTemporary
 3.3 Setting the Verbosity of ANUPQ via Info and InfoANUPQ

  3.3-1 InfoANUPQ
 3.4 Utility Functions

  3.4-1 PqLeftNormComm
  3.4-2 PqGAPRelators
  3.4-3 PqParseWord
  3.4-4 PqExample
  3.4-5 AllPqExamples
  3.4-6 GrepPqExamples
  3.4-7 ToPQLog
 3.5 Attributes and a Property for fp and pc p-groups

  3.5-1 NuclearRank
 3.6 Hints and Warnings regarding the use of Options

  3.6-1 ANUPQWarnOfOtherOptions
4 Non-interactive ANUPQ functions
 4.1 Computing p-Quotients

  4.1-1 Pq
  4.1-2 PqEpimorphism
  4.1-3 PqPCover
 4.2 Computing Standard Presentations

  4.2-1 PqStandardPresentation
  4.2-2 EpimorphismPqStandardPresentation
 4.3 Testing p-Groups for Isomorphism

  4.3-1 IsPqIsomorphicPGroup
 4.4 Computing Descendants of a p-Group

  4.4-1 PqDescendants
  4.4-2 PqSupplementInnerAutomorphisms
  4.4-3 PqList
  4.4-4 SavePqList
5 Interactive ANUPQ functions
 5.1 Starting and Stopping Interactive ANUPQ Processes

  5.1-1 PqStart
  5.1-2 PqQuit
  5.1-3 PqQuitAll
 5.2 Interactive ANUPQ Process Utility Functions

  5.2-1 PqProcessIndex
  5.2-2 PqProcessIndices
  5.2-3 IsPqProcessAlive
 5.3 Interactive Versions of Non-interactive ANUPQ Functions

  5.3-1 Pq
  5.3-2 PqEpimorphism
  5.3-3 PqPCover
  5.3-4 PqStandardPresentation
  5.3-5 EpimorphismPqStandardPresentation
  5.3-6 PqDescendants
  5.3-7 PqSetPQuotientToGroup
 5.4 Low-level Interactive ANUPQ functions based on menu items of the pq program
 5.5 General commands

  5.5-1 PqNrPcGenerators
  5.5-2 PqFactoredOrder
  5.5-3 PqOrder
  5.5-4 PqPClass
  5.5-5 PqWeight
  5.5-6 PqCurrentGroup
  5.5-7 PqDisplayPcPresentation
  5.5-8 PqSetOutputLevel
  5.5-9 PqEvaluateIdentities
 5.6 Commands from the Main \(p\)-Quotient menu

  5.6-1 PqPcPresentation
  5.6-2 PqSavePcPresentation
  5.6-3 PqRestorePcPresentation
  5.6-4 PqNextClass
  5.6-5 PqComputePCover
 5.7 Commands from the Advanced \(p\)-Quotient menu

  5.7-1 PqCollect
  5.7-2 PqSolveEquation
  5.7-3 PqCommutator
  5.7-4 PqSetupTablesForNextClass
  5.7-5 PqTails
  5.7-6 PqComputeTails
  5.7-7 PqAddTails
  5.7-8 PqDoConsistencyChecks
  5.7-9 PqCollectDefiningRelations
  5.7-10 PqCollectWordInDefiningGenerators
  5.7-11 PqCommutatorDefiningGenerators
  5.7-12 PqDoExponentChecks
  5.7-13 PqEliminateRedundantGenerators
  5.7-14 PqRevertToPreviousClass
  5.7-15 PqSetMaximalOccurrences
  5.7-16 PqSetMetabelian
  5.7-17 PqDoConsistencyCheck
  5.7-18 PqCompact
  5.7-19 PqEchelonise
  5.7-20 PqSupplyAutomorphisms
  5.7-21 PqExtendAutomorphisms
  5.7-22 PqApplyAutomorphisms
  5.7-23 PqDisplayStructure
  5.7-24 PqDisplayAutomorphisms
  5.7-25 PqWritePcPresentation
 5.8 Commands from the Standard Presentation menu

  5.8-1 PqSPComputePcpAndPCover
  5.8-2 PqSPStandardPresentation
  5.8-3 PqSPSavePresentation
  5.8-4 PqSPCompareTwoFilePresentations
  5.8-5 PqSPIsomorphism
 5.9 Commands from the Main \(p\)-Group Generation menu

  5.9-1 PqPGSupplyAutomorphisms
  5.9-2 PqPGExtendAutomorphisms
  5.9-3 PqPGConstructDescendants
  5.9-4 PqPGSetDescendantToPcp
 5.10 Commands from the Advanced \(p\)-Group Generation menu

  5.10-1 PqAPGDegree
  5.10-2 PqAPGPermutations
  5.10-3 PqAPGOrbits
  5.10-4 PqAPGOrbitRepresentatives
  5.10-5 PqAPGSingleStage
 5.11 Primitive Interactive ANUPQ Process Read/Write Functions

  5.11-1 PqRead
  5.11-2 PqReadAll
  5.11-3 PqReadUntil
  5.11-4 PqWrite
6 ANUPQ Options
 6.1 Overview

  6.1-1 AllANUPQoptions
  6.1-2 ANUPQoptions
 6.2 Detailed descriptions of ANUPQ Options
7 Installing the ANUPQ Package
 7.1 Testing your ANUPQ installation
 7.2 Running the pq program as a standalone
A Examples
 A.1 The Relators Option
 A.2 The Identities Option and PqEvaluateIdentities Function
 A.3 A Large Example
 A.4 Developing descendants trees

  A.4-1 PqDescendantsTreeCoclassOne
References
Index

 [Top of Book]  [Contents]   [Next Chapter] 
Goto Chapter: Top 1 2 3 4 5 6 7 A Bib Ind

generated by GAPDoc2HTML

anupq-3.3.3/doc/chapBib.txt0000644000175100017510000000547515111342310015112 0ustar runnerrunner References [HN80] Havas, G. and Newman, M. F., Application of computers to questions like those of Burnside, in Burnside groups (Proc. Workshop, Univ. Bielefeld, Bielefeld, 1977), Springer, Lecture Notes in Math., 806, Berlin (1980), 211--230. [LS90] Leedham-Green, C. R. and Soicher, L. H., Collection from the left and other strategies, J. Symbolic Comput., 9, 5-6 (1990), 665--675, (Computational group theory, Part 1). [New77] Newman, M. F., Determination of groups of prime-power order, in Group theory (Proc. Miniconf., Australian Nat. Univ., Canberra, 1975), Springer, Berlin (1977), 73--84. Lecture Notes in Math., Vol. 573. [NNN98] Newman, M. F., Nickel, W. and Niemeyer, A. C., Descriptions of groups of prime-power order, J. Symbolic Comput., 25, 5 (1998), 665--682. [NO96] Newman, M. F. and O'Brien, E. A., Application of computers to questions like those of Burnside. II, Internat. J. Algebra Comput., 6, 5 (1996), 593--605. [O'B90] O'Brien, E. A., The p-group generation algorithm, J. Symbolic Comput., 9, 5-6 (1990), 677--698, (Computational group theory, Part 1). [O'B94] O'Brien, E. A., Isomorphism testing for p-groups, J. Symbolic Comput., 17, 2 (1994), 131, 133--147. [O'B95] O'Brien, E. A., Computing automorphism groups of p-groups, in Computational algebra and number theory (Sydney, 1992), Kluwer Acad. Publ., Math. Appl., 325, Dordrecht (1995), 83--90. [Sim94] Sims, C. C., Computation with finitely presented groups, Cambridge University Press, Encyclopedia of Mathematics and its Applications, 48, Cambridge (1994), xiii+604 pages. [Vau84] Vaughan-Lee, M. R., An aspect of the nilpotent quotient algorithm, in Computational group theory (Durham, 1982), Academic Press, London (1984), 75--83. [Vau90a] Vaughan-Lee, M., The restricted Burnside problem, The Clarendon Press Oxford University Press, London Mathematical Society Monographs. New Series, 5, New York (1990), xiv+209 pages, (Oxford Science Publications). [Vau90b] Vaughan-Lee, M. R., Collection from the left, J. Symbolic Comput., 9, 5-6 (1990), 725--733, (Computational group theory, Part 1).  anupq-3.3.3/doc/times.css0000644000175100017510000000026115111342310014640 0ustar runnerrunner/* times.css Frank Lübeck */ /* Change default CSS to use Times font. */ body { font-family: Times,Times New Roman,serif; } anupq-3.3.3/doc/rainbow.js0000644000175100017510000000533615111342310015014 0ustar runnerrunner function randchar(str) { var i = Math.floor(Math.random() * str.length); while (i == str.length) i = Math.floor(Math.random() * str.length); return str[i]; } hexdigits = "0123456789abcdef"; function randlight() { return randchar("cdef")+randchar(hexdigits)+ randchar("cdef")+randchar(hexdigits)+ randchar("cdef")+randchar(hexdigits) } function randdark() { return randchar("012345789")+randchar(hexdigits)+ randchar("012345789")+randchar(hexdigits)+ randchar("102345789")+randchar(hexdigits) } document.write('\n'); anupq-3.3.3/doc/infra.xml0000644000175100017510000010046415111342310014634 0ustar runnerrunner Infrastructure Most of the details in this chapter are of a technical nature; the user need only skim over this chapter on a first reading. Mostly, it is enough to know that you must do a LoadPackage("anupq"); before you can expect to use a command defined by the &ANUPQ; package (details are in Section ); partial results of &ANUPQ; commands and some other data are stored in the ANUPQData global variable (details are in Section ); doing SetInfoLevel(InfoANUPQ, n); for n greater than the default value 1 will give progressively more information of what is going on behind the scenes (details are in Section ); in Section  we describe some utility functions and functions that run examples from the collection of examples of this package; in Section  we describe the attributes and property NuclearRank, MultiplicatorRank and IsCapable; and in Section  we describe some troubleshooting strategies. Also this section explains the utility of setting ANUPQWarnOfOtherOptions := true; (particularly for novice users) for detecting misspelt options and diagnosing other option usage problems.
Loading the ANUPQ Package banner To use the &ANUPQ; package, as with any &GAP; package, it must be requested explicitly. This is done by calling LoadPackage( "anupq" ); --------------------------------------------------------------------------- Loading ANUPQ 3.3.3 (ANU p-Quotient) by Greg Gamble (GAP code, Greg.Gamble@uwa.edu.au), Werner Nickel (GAP code), and Eamonn O'Brien (C code, https://www.math.auckland.ac.nz/~obrien). maintained by: Max Horn (https://www.quendi.de/math). uses ANU pq binary (C code program) version: 1.9 Homepage: https://gap-packages.github.io/anupq/ Report issues at https://github.com/gap-packages/anupq/issues --------------------------------------------------------------------------- true ]]> Note that since the &ANUPQ; package uses the AutomorphimGroupPGroup function of the &AutPGrp; package and, in any case, often needs other &AutPGrp; functions when computing descendants, the user must ensure that the &AutPGrp; package is also installed, at least version 1.5. If the &AutPGrp; package is not installed, the &ANUPQ; package will fail to load.

Also, if &GAP; cannot find a working pq binary, the call to LoadPackage will return fail.

If you want to load the &ANUPQ; package by default, you can put the LoadPackage command into your gap.ini file (see Section  in the &GAP; Reference Manual). By the way, the novice user of the &ANUPQ; package should probably also append the line to their gap.ini file, somewhere after the LoadPackage( "anupq" ); command (see ).

The ANUPQData Record This section contains fairly technical details which may be skipped on an initial reading. is a &GAP; record in which the essential data for an &ANUPQ; session within &GAP; is stored; its fields are: binary the path of the pq binary; tmpdir the path of the temporary directory used by the pq binary and &GAP; (i.e. the directory in which all the pq's temporary files are created) (also see below); outfile the full path of the default pq output file; SPimages the full path of the file GAP_library to which the pq program writes its Standard Presentation images; version the version of the current pq binary; ni a data record used by non-interactive functions (see below and Chapter ); io list of data records for PqStart (see below and ) processes; topqlogfile name of file logged to by ToPQLog (see ); and logstream stream of file logged to by ToPQLog (see ). Each time an interactive &ANUPQ; process is initiated via PqStart (see ), an identifying number ioIndex is generated for the interactive process and a record ANUPQData.io[ioIndex] with some or all of the fields listed below is created. Whenever a non-interactive function is called (see Chapter ), the record ANUPQData.ni is updated with fields that, if bound, have exactly the same purpose as for a ANUPQData.io[ioIndex] record. stream the IOStream opened for interactive &ANUPQ; process ioIndex or non-interactive &ANUPQ; function; group the group given as first argument to PqStart, Pq, PqEpimorphism, PqDescendants or PqStandardPresentation (or any synonymous methods); haspcp is bound and set to true when a pc presentation is first set inside the pq program (e.g. by PqPcPresentation or PqRestorePcPresentation or a higher order function like Pq, PqEpimorphism, PqPCover, PqDescendants or PqStandardPresentation that does a PqPcPresentation operation, but not PqStart which only starts up an interactive &ANUPQ; process); gens a list of the generators of the group group as strings (the same as those passed to the pq program); rels a list of the relators of the group group as strings (the same as those passed to the pq program); name the name of the group whose pc presentation is defined by a call to the pq program (according to the pq program -- unless you have used the GroupName option (see e.g. ) or applied the function SetName (see ) to the group, the generic name "[grp]" is set as a default); gpnum if not a null string, the number (i.e. the unique label assigned by the pq program) of the last descendant processed; class the largest lower exponent-p central class of a quotient group of the group (usually group) found by a call to the pq program; forder the factored order of the quotient group of largest lower exponent-p central class found for the group (usually group) by a call to the pq program (this factored order is given as a list [p,n], indicating an order of p^n); pcoverclass the lower exponent-p central class of the p-covering group of a p-quotient of the group (usually group) found by a call to the pq program; workspace the workspace set for the pq process (either given as a second argument to PqStart, or set by default to 10000000); menu the current menu of the pq process (the pq program is managed by various menus, the details of which the user shouldn't normally need to know about -- the menu field remembers which menu the pq process is currently in); outfname is the file to which pq output is directed, which is always ANUPQData.outfile, except when option SetupFile is used with a non-interactive function, in which case outfname is set to "PQ_OUTPUT"; pQuotient is set to the value returned by Pq (see ) (the field pQepi is also set at the same time); pQepi is set to the value returned by PqEpimorphism (see ) (the field pQuotient is also set at the same time); pCover is set to the value returned by PqPCover (see ); SP is set to the value returned by PqStandardPresentation or StandardPresentation (see ) when called interactively, for process i (the field SPepi is also set at the same time); SPepi is set to the value returned by EpimorphismPqStandardPresentation or EpimorphismStandardPresentation (see ) when called interactively, for process i (the field SP is also set at the same time); descendants is set to the value returned by PqDescendants (see ); treepos if set by a call to PqDescendantsTreeCoclassOne (see ), it contains a record with fields class, node and ndes being the information that determines the last descendant with a non-zero number of descendants processed; xgapsheet if set by a call to PqDescendantsTreeCoclassOne (see ) during an &XGAP; session, it contains the &XGAP; Sheet on which the descendants tree is displayed; and nextX if set by a call to PqDescendantsTreeCoclassOne (see ) during an &XGAP; session, it contains a list of integers, the ith entry of which is the x-coordinate of the next node (representing a descendant) for the ith class. calls the UNIX command mkdir to create dir, which must be a string, and if successful a directory object for dir is both assigned to ANUPQData.tmpdir and returned. The field ANUPQData.outfile is also set to be a file in ANUPQData.tmpdir, and on exit from &GAP; dir is removed. Most users will never need this command; by default, &GAP; typically chooses a random subdirectory of /tmp for ANUPQData.tmpdir which may occasionally have limits on what may be written there. ANUPQDirectoryTemporary permits the user to choose a directory (object) where one is not so limited.
Setting the Verbosity of ANUPQ via Info and InfoANUPQ The input to and the output from the pq program is, by default, not displayed. However the user may choose to see some, or all, of this input/output. This is done via the Info mechanism (see Section  in the &GAP; Reference Manual). For this purpose, there is the InfoClass InfoANUPQ. If the InfoLevel of InfoANUPQ is high enough each line of pq input/output is directed to a call to Info and will be displayed for the user to see. By default, the InfoLevel of InfoANUPQ is 1, and it is recommended that you leave it at this level, or higher. Messages that the user should presumably want to see and output from the pq program influenced by the value of the option OutputLevel (see the options listed in Section ), other than timing and memory usage are directed to Info at InfoANUPQ level 1.

To turn off all InfoANUPQ messaging, set the InfoANUPQ level to 0.

There are five other user-intended InfoANUPQ levels: 2, 3, 4, 5 and 6. SetInfoLevel(InfoANUPQ, 2); ]]> enables the display of most timing and memory usage data from the pq program, and also the number of identity instances when the Identities option is used. (Some timing and memory usage data, particularly when profuse in quantity, is Info-ed at InfoANUPQ level 3 instead.) Note that the the &GAP; functions time and Runtime (see  in the &GAP; Reference Manual) count the time spent by &GAP; and not the time spent by the (external) pq program. SetInfoLevel(InfoANUPQ, 3); ]]> enables the display of output of the nature of the first two InfoANUPQ that was not directly invoked by the user (e.g. some commands require &GAP; to discover something about the current state known to the pq program). The identity instances processed under the Identities option are also displayed at this level. In some cases, the pq program produces a lot of output despite the fact that the OutputLevel (see ) is unset or is set to 0; such output is also Info-ed at InfoANUPQ level 3. SetInfoLevel(InfoANUPQ, 4); ]]> enables the display of all the commands directed to the pq program, behind a ToPQ> prompt (so that you can distinguish it from the output from the pq program). See Section  for an example of how this can be a useful troubleshooting tool. SetInfoLevel(InfoANUPQ, 5); ]]> enables the display of the pq program's prompts for input. Finally, SetInfoLevel(InfoANUPQ, 6); ]]> enables the display of all other output from the pq program, namely the banner and menus. However, the timing data printed when the pq program exits can never be observed.

Utility Functions returns for a list of elements of some group (e.g. elts may be a list of words in the generators of a free or fp group) the left normed commutator of elts, e.g. if w1, w2, w3 are such elements then PqLeftNormComm( [w1, w2, w3] ); is equivalent to Comm( Comm( w1, w2 ), w3 );.

Note: elts must contain at least two elements. returns a list of words that &GAP; understands, given a list rels of strings in the string representations of the generators of the fp group group prepared as a list of relators for the pq program.

Note: The pq program does not use / to indicate multiplication by an inverse and uses square brackets to represent (left normed) commutators. Also, even though the pq program accepts relations, all elements of rels must be in relator form, i.e. a relation of form w1 = w2 must be written as w1*(w2)^-1.

Here is an example: F := FreeGroup("a", "b"); gap> PqGAPRelators(F, [ "a*b^2", "[a,b]^2*a", "[a,b,a,b]^a" ]); [ a*b^2, (a^-1*b^-1*a*b)^2*a, a^-2*b^-1*a^-1*b*(a*b^-1)^2*a^-1*b*a^-1*b^-1*(a*b)^2*a ] ]]> parses a word, a string representing a word in the pc generators x1,...,xn, through &GAP;. This function is provided as a rough-and-ready check of word for syntax errors. A syntax error will cause the entering of a break-loop, in which the error message may or may not be meaningful (depending on whether the syntax error gets caught at the &GAP; or kernel level).

Note: The reason the generators must be x1,...,xn is that these are the pc generator names used by the pq program (as distinct from the generator names for the group provided by the user to a function like Pq that invokes the pq program). With no arguments, or with single argument "index", or a string example that is not the name of a file in the examples directory, an index of available examples is displayed.

With just the one argument example that is the name of a file in the examples directory, the example contained in that file is executed in its simplest form. Some examples accept options which you may use to modify some of the options used in the commands of the example. To find out which options an example accepts, use one of the mechanisms for displaying the example described below.

Some examples have both non-interactive and interactive forms; those that are non-interactive only have a name ending in -ni; those that are interactive only have a name ending in -i; examples with names ending in .g also have only one form; all other examples have both non-interactive and interactive forms and for these giving PqStart as second argument invokes PqStart initially and makes the appropriate adjustments so that the example is executed or displayed using interactive functions.

If PqExample is called with last (second or third) argument Display then the example is displayed without being executed. If the last argument is a non-empty string filename then the example is also displayed without being executed but is also written to a file with that name. Passing an empty string as last argument has the same effect as passing Display.

Note: The variables used in PqExample are local to the running of PqExample, so there's no danger of having some of your variables over-written. However, they are not completely lost either. They are saved to a record ANUPQData.examples.vars, i.e. if F is a variable used in the example then you will be able to access it after PqExample has finished as ANUPQData.examples.vars.F. returns a list of all currently available examples in default UNIX-listing (i.e. alphabetic) order. runs the UNIX command grep string over the &ANUPQ; examples and returns the list of examples for which there is a match. The actual matches are Info-ed at InfoANUPQ level 2. With string argument filename, ToPQLog opens the file with name filename for logging; all commands written to the pq binary (that are Info-ed behind a ToPQ> prompt at InfoANUPQ level 4) are then also written to that file (but without prompts). With no argument, ToPQLog stops logging to whatever file was being logged to. If a file was already being logged to, that file is closed and the file with name filename is opened for logging.

Attributes and a Property for fp and pc p-groups return the nuclear rank of G, p-multiplicator rank of G, and whether G is capable (i.e. true if it is, or false if it is not), respectively.

These attributes and property are set automatically if G is one of the following: an fp group returned by PqStandardPresentation or StandardPresentation (see ); the image (fp group) of the epimorphism returned by an EpimorphismPqStandardPresentation or EpimorphismStandardPresentation call (see ); or one of the pc groups of the list of descendants returned by PqDescendants (see ). If G is an fp group or a pc p-group and not one of the above and the attribute or property has not otherwise been set for G, then PqStandardPresentation is called to set all three of NuclearRank, MultiplicatorRank and IsCapable, before returning the value of the attribute or property actually called. Such a group G must know in advance that it is a p-group; this is the case for the groups returned by the functions Pq and PqPCover, and the image group of the epimorphism returned by PqEpimorphism. Otherwise, if you know the group to be a p-group, then this can be set by typing

or by invoking IsPGroup( G ). Note that for an fp group G, the latter may result in a coset enumeration which might not terminate in a reasonable time.

Note: For G such that HasNuclearRank(G) = true, IsCapable(G) is equivalent to (the truth or falsity of) NuclearRank( G ) = 0.

Hints and Warnings regarding the use of Options On a first reading we recommend you skip this section and come back to it if and when you run into trouble.

menu item option Note: By options we refer to &GAP; options. The pq program also uses the term option; to distinguish the two usages of option, in this manual we use the term menu item to refer to what the pq program refers to as an option.

Options are passed to the &ANUPQ; interface functions in either of the two usual mechanisms provided by &GAP;, namely: options may be set globally using the function PushOptions (see Chapter  in the &GAP; Reference Manual); or options may be appended to the argument list of any function call, separated by a colon from the argument list (see Chapter  in the &GAP; Reference Manual), in which case they are then passed on recursively to any subsequent inner function call, which may in turn have options of their own. Particularly, when one is using the interactive functions of Chapter , one should, in general, avoid using the global method of passing options. In fact, it is recommended that prior to calling PqStart the OptionsStack be empty. The essential problem with setting options globally using the function PushOptions is that options pushed onto OptionsStack, in this way, (generally) remain there until an explicit PopOptions() call is made.

In contrast, options passed in the usual way behind a colon following a function's arguments (see in the &GAP; Reference Manual) are local, and disappear from OptionsStack after the function has executed successfully. If the function does not execute successfully, i.e. it runs into error and the user quits the resulting break loop (see Section  in the Reference Manual) rather than attempting to repair the problem and typing return; then, unless the error at the kernel level, the OptionsStack is reset. If an error is detected inside the kernel (hopefully, this should occur only rarely, if at all) then the options of that function will not be cleared from OptionsStack; in such cases: ResetOptionsStack(); #I Options stack is already empty ]]> is usually necessary (see Chapter  in the &GAP; Reference Manual), which recursively calls PopOptions() until OptionsStack is empty, or as in the above case warns you that the OptionsStack is already empty.

Note that a function, that is passed options after the colon, will also see any global options or any options passed down recursively from functions calling that function, unless those options are over-ridden by options passed via the function. Also, note that duplication of option names for different programs may lead to misinterpretations, and mis-spelled options will not be seen.

The non-interactive functions of Chapter  that have Pq somewhere in their name provide an alternative method of passing options as additional arguments. This has the advantages that options can be abbreviated and mis-spelled options will be trapped. troubleshooting tips is a global variable that is by default false. If it is set to true then any function provided by the &ANUPQ; function that recognises at least one option, will warn you of other options, i.e. options that the function does not recognise. These warnings are emitted at InfoWarning or InfoANUPQ level 1. This is useful for detecting mis-spelled options. Here is an example using the function Pq (first described in Chapter ): SetInfoLevel(InfoANUPQ, 1); # Set InfoANUPQ to default level gap> ANUPQWarnOfOtherOptions := true;; gap> # The following makes entry into break loops very ``quiet'' ... gap> OnBreak := function() Where(0); end;; gap> F := FreeGroup( "a", "b" ); gap> Pq( F : Prime := 2, Classbound := 1 ); #I ANUPQ Warning: Options: [ "Classbound" ] ignored #I (invalid for generic function: `Pq'). user interrupt at moreOfline := ReadLine( iostream ); Entering break read-eval-print loop ... you can 'quit;' to quit to outer loop, or you can 'return;' to continue ]]> Here we mistyped ClassBound as Classbound, and after seeing the Info-ed warning that Classbound was ignored, we typed a control-C (that's the user interrupt at message) which took us into a break loop. Since the Pq command was not able to finish, the options Prime and Classbound, in particular, will still be on the OptionsStack: OptionsStack; [ rec( Prime := 2, Classbound := 1 ), rec( Prime := 2, Classbound := 1, PqEpiOrPCover := "pQuotient" ) ] ]]> The option PqEpiOrPCover is a behind-the-scenes option that need not concern the user. On quitting the break-loop the OptionsStack is reset and a warning telling you this is emitted: quit; # to get back to the `gap>' prompt #I Options stack has been reset ]]> Above, we altered OnBreak (see  in the Reference manual) to reduce the back-tracing on entry into a break loop. We now restore OnBreak to its usual value. OnBreak := Where;; ]]> Notes

In cases where functions recursively call others with options (e.g. when using PqExample with options), setting ANUPQWarnOfOtherOptions := true may give rise to spurious other option detections.

It is recommended that the novice user set ANUPQWarnOfOtherOptions to true in their gap.ini file (see Section ). Other Troubleshooting Strategies

There are some other strategies which may have helped us to see our error above. The function Pq recognises the option OutputLevel (see ); if this option is set to at least 1, the pq program provides information on each class quotient as it is generated: ANUPQWarnOfOtherOptions := false;; # Set back to normal gap> F := FreeGroup( "a", "b" );; gap> Pq( F : Prime := 2, Classbound := 1, OutputLevel := 1 ); #I Lower exponent-2 central series for [grp] #I Group: [grp] to lower exponent-2 central class 1 has order 2^2 #I Group: [grp] to lower exponent-2 central class 2 has order 2^5 #I Group: [grp] to lower exponent-2 central class 3 has order 2^10 #I Group: [grp] to lower exponent-2 central class 4 has order 2^18 #I Group: [grp] to lower exponent-2 central class 5 has order 2^32 #I Group: [grp] to lower exponent-2 central class 6 has order 2^55 #I Group: [grp] to lower exponent-2 central class 7 has order 2^96 #I Group: [grp] to lower exponent-2 central class 8 has order 2^167 #I Group: [grp] to lower exponent-2 central class 9 has order 2^294 #I Group: [grp] to lower exponent-2 central class 10 has order 2^520 #I Group: [grp] to lower exponent-2 central class 11 has order 2^932 #I Group: [grp] to lower exponent-2 central class 12 has order 2^1679 [... output truncated ...] ]]> After seeing the information for the class 2 quotient we may have got the idea that the Classbound option was not recognised and may have realised that this was due to a mis-spelling. The above will ordinarily cause the available space to be exhausted, necessitating user-intervention by typing control-C and quit; (to escape the break loop); otherwise Pq terminates when the class reaches 63 (the default value of ClassBound).

If you have some familiarity with keyword command input to the pq binary, then setting the level of InfoANUPQ to 4 would also have indicated a problem: ResetOptionsStack(); # Necessary, if a break-loop was entered above gap> SetInfoLevel(InfoANUPQ, 4); gap> Pq( F : Prime := 2, Classbound := 1 ); #I ToPQ> 7 #to (Main) p-Quotient Menu #I ToPQ> 1 #define group #I ToPQ> name [grp] #I ToPQ> prime 2 #I ToPQ> class 63 #I ToPQ> exponent 0 #I ToPQ> output 0 #I ToPQ> generators { a,b } #I ToPQ> relators { }; [... output truncated ...] ]]> Here the line #I ToPQ> class 63 indicates that a directive to set the classbound to 63 was sent to the pq program.

anupq-3.3.3/doc/nocolorprompt.css0000644000175100017510000000031315111342310016432 0ustar runnerrunner /* colors for ColorPrompt like examples */ span.GAPprompt { color: #000000; font-weight: normal; } span.GAPbrkprompt { color: #000000; font-weight: normal; } span.GAPinput { color: #000000; } anupq-3.3.3/doc/chap1_mj.html0000644000175100017510000002664615111342310015374 0ustar runnerrunner GAP (ANUPQ) - Chapter 1: Introduction
Goto Chapter: Top 1 2 3 4 5 6 7 A Bib Ind
 [Top of Book]  [Contents]   [Previous Chapter]   [Next Chapter] 

1 Introduction
 1.1 Overview
 1.2 How to read this manual
 1.3 Authors and Acknowledgements

1 Introduction

1.1 Overview

The GAP 4 package ANUPQ provides an interface to the ANU pq C program written by Eamonn O'Brien, making the functionality of the C program available to GAP. Henceforth, we shall refer to the ANUPQ package when referring to the GAP interface, and to the ANU pq program or just pq when referring to that C program.

The pq program consists of implementations of the following algorithms:

  1. A \(p\)-quotient algorithm to compute pc-presentations for \(p\)-factor groups of finitely presented groups.

  2. A \(p\)-group generation algorithm to generate pc presentations of groups of prime power order.

  3. A standard presentation algorithm used to compute a canonical pc-presentation of a \(p\)-group.

  4. An algorithm which can be used to compute the automorphism group of a \(p\)-group.

    This part of the pq program is not accessible through the ANUPQ package. Instead, users are advised to consider the GAP 4 package AutPGrp by Bettina Eick and Eamonn O'Brien, which implements a better algorithm in GAP for the computation of automorphism groups of \(p\)-groups.

The current version of the ANUPQ package requires GAP 4.5, and version 1.5 of the AutPGrp package. All code that made the package compatible with earlier versions of GAP has been removed. If you must use an older GAP version and cannot upgrade, then you may try using an older ANUPQ version. However, you should not use versions of the ANUPQ package older than 2.2, since they are known to have bugs.

1.2 How to read this manual

It is not expected that readers of this manual will read it in a linear fashion from cover to cover; some sections contain material that is far too technical to be absorbed on a first reading.

Firstly, installers of the ANUPQ package will need to read Chapter Installing the ANUPQ Package, if they have not already gleaned these details from the README file.

Once the ANUPQ package is installed, users of the ANUPQ package will benefit most by first reading Chapter Mathematical Background and Terminology, which gives a brief description of the background and terminology used (this chapter also cites a number of references for further reading), and the introduction of Chapter Infrastructure (skip the remainder of the chapter on a first reading).

Then the user/reader should pursue Chapter Non-interactive ANUPQ functions in detail, delving into Chapter ANUPQ Options as necessary for the options of the functions that are described. The user will become best acquainted with the ANUPQ package by trying the examples. This chapter describes the non-interactive functions of the ANUPQ package, i.e. one-shot functions that invoke the pq program in such a way that once GAP has got what it needs, the pq is allowed to exit. It is expected that most of the time, users will only need these functions.

Advanced users will want to explore Chapter Interactive ANUPQ functions which describes all the interactive functions of the ANUPQ package; these are functions that extract information via a dialogue with a running pq process. Occasionally, a user needs the next step; the functions provided in this chapter make use of data from previous steps retained by the pq program, thus allowing the user to interact with the pq program like one can when one uses the pq program as a stand-alone (see guide.dvi in the standalone-doc directory).

After having read Chapters Non-interactive ANUPQ functions and Interactive ANUPQ functions, cross-references will have taken the reader into Chapter ANUPQ Options; by this stage, the reader need only read the introduction of Chapter ANUPQ Options.

After the reader has developed some facility with the ANUPQ package, she should explore the examples described in Appendix Examples.

If you run into trouble using the ANUPQ functions, some troubleshooting hints are given in Section Hints and Warnings regarding the use of Options. If the troubleshooting hints don't help, Section Authors and Acknowledgements below, gives contact details for the authors of the components of the ANUPQ package.

1.3 Authors and Acknowledgements

The C implementation of the ANU pq standalone was developed by Eamonn O'Brien.

An interactive interface using iostreams was developed with the assistance of Werner Nickel by Greg Gamble.

The GAP 4 version of this package was adapted from the GAP 3 version by Werner Nickel.

A new co-maintainer, Max Horn, joined the team in November, 2011.

The authors would like to thank Joachim Neubüser for his careful proof-reading and advice, and for formulating Chapter Mathematical Background and Terminology.

We would also like to thank Bettina Eick who by her testing and provision of examples helped us to eliminate a number of bugs and who provided a number of valuable suggestions for extensions of the package beyond the GAP 3 capabilities.

If you find a bug, the last section of ANUPQ's README describes the information we need and where to send us a bug report; please take the time to read this (i.e. help us to help you).

 [Top of Book]  [Contents]   [Previous Chapter]   [Next Chapter] 
Goto Chapter: Top 1 2 3 4 5 6 7 A Bib Ind

generated by GAPDoc2HTML

anupq-3.3.3/doc/chapA.html0000644000175100017510000013507215111342310014720 0ustar runnerrunner GAP (ANUPQ) - Appendix A: Examples
Goto Chapter: Top 1 2 3 4 5 6 7 A Bib Ind
 [Top of Book]  [Contents]   [Previous Chapter]   [Next Chapter] 

A Examples
 A.1 The Relators Option
 A.2 The Identities Option and PqEvaluateIdentities Function
 A.3 A Large Example
 A.4 Developing descendants trees

  A.4-1 PqDescendantsTreeCoclassOne

A Examples

There are a large number of examples provided with the ANUPQ package. These may be executed or displayed via the function PqExample (see PqExample (3.4-4)). Each example resides in a file of the same name in the directory examples. Most of the examples are translations to GAP of examples provided for the pq standalone by Eamonn O'Brien; the standalone examples are found in directories standalone/examples (p-quotient and p-group generation examples) and standalone/isom (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 live is always indicated near -- usually immediately after -- the text example). The format of the (PqExample) examples is such that they can be read by the standard Read function of GAP, but certain features and comments are interpreted by the function PqExample to do somewhat more than Read does. In particular, any function without a -i, -ni or .g suffix has both a non-interactive and interactive form; in these cases, the default form is the non-interactive form, and giving PqStart as second argument generates the interactive form.

Running PqExample without an argument or with a non-existent example Infos the available examples and some hints on usage:

gap> PqExample();
#I                   PqExample Index (Table of Contents)
#I                   -----------------------------------
#I  This table of possible examples is displayed when calling `PqExample'
#I  with no arguments, or with the argument: "index" (meant in the  sense
#I  of ``list''), or with a non-existent example name.
#I  
#I  Examples that have a name ending in `-ni' are  non-interactive  only.
#I  Examples that have a  name  ending  in  `-i'  are  interactive  only.
#I  Examples with names ending in `.g' also have  only  one  form.  Other
#I  examples have both a non-interactive and an  interactive  form;  call
#I  `PqExample' with 2nd argument `PqStart' to get the  interactive  form
#I  of the example. The substring `PG' in an  example  name  indicates  a
#I  p-Group Generation example, `SP' indicates  a  Standard  Presentation
#I  example, `Rel' indicates it uses  the  `Relators'  option,  and  `Id'
#I  indicates it uses the `Identities' option.
#I  
#I  The following ANUPQ examples are available:
#I  
#I   p-Quotient examples:
#I    general:
#I     "Pq"                   "Pq-ni"                "PqEpimorphism"        
#I     "PqPCover"             "PqSupplementInnerAutomorphisms"
#I    2-groups:
#I     "2gp-Rel"              "2gp-Rel-i"            "2gp-a-Rel-i"
#I     "B2-4"                 "B2-4-Id"              "B2-8-i"
#I     "B4-4-i"               "B4-4-a-i"             "B5-4.g"
#I    3-groups:
#I     "3gp-Rel-i"            "3gp-a-Rel"            "3gp-a-Rel-i"
#I     "3gp-a-x-Rel-i"        "3gp-maxoccur-Rel-i"
#I    5-groups:
#I     "5gp-Rel-i"            "5gp-a-Rel-i"          "5gp-b-Rel-i"
#I     "5gp-c-Rel-i"          "5gp-metabelian-Rel-i" "5gp-maxoccur-Rel-i"
#I     "F2-5-i"               "B2-5-i"               "R2-5-i"
#I     "R2-5-x-i"             "B5-5-Engel3-Id"
#I    7-groups:
#I     "7gp-Rel-i"
#I    11-groups:
#I     "11gp-i"               "11gp-Rel-i"           "11gp-a-Rel-i"
#I     "11gp-3-Engel-Id"      "11gp-3-Engel-Id-i"
#I  
#I   p-Group Generation examples:
#I    general:
#I     "PqDescendants-1"      "PqDescendants-2"      "PqDescendants-3"
#I     "PqDescendants-1-i"
#I    2-groups:
#I     "2gp-PG-i"             "2gp-PG-2-i"           "2gp-PG-3-i"
#I     "2gp-PG-4-i"           "2gp-PG-e4-i"
#I     "PqDescendantsTreeCoclassOne-16-i"
#I    3-groups:
#I     "3gp-PG-i"             "3gp-PG-4-i"           "3gp-PG-x-i"
#I     "3gp-PG-x-1-i"         "PqDescendants-treetraverse-i"
#I     "PqDescendantsTreeCoclassOne-9-i"
#I    5-groups:
#I     "5gp-PG-i"             "Nott-PG-Rel-i"        "Nott-APG-Rel-i"
#I     "PqDescendantsTreeCoclassOne-25-i"
#I    7,11-groups:
#I     "7gp-PG-i"             "11gp-PG-i"
#I  
#I   Standard Presentation examples:
#I    general:
#I     "StandardPresentation" "StandardPresentation-i"
#I     "EpimorphismStandardPresentation"
#I     "EpimorphismStandardPresentation-i"           "IsIsomorphicPGroup-ni"
#I    2-groups:
#I     "2gp-SP-Rel-i"         "2gp-SP-1-Rel-i"       "2gp-SP-2-Rel-i"
#I     "2gp-SP-3-Rel-i"       "2gp-SP-4-Rel-i"       "2gp-SP-d-Rel-i"
#I     "gp-256-SP-Rel-i"      "B2-4-SP-i"            "G2-SP-Rel-i"
#I    3-groups:
#I     "3gp-SP-Rel-i"         "3gp-SP-1-Rel-i"       "3gp-SP-2-Rel-i"
#I     "3gp-SP-3-Rel-i"       "3gp-SP-4-Rel-i"       "G3-SP-Rel-i"
#I    5-groups:
#I     "5gp-SP-Rel-i"         "5gp-SP-a-Rel-i"       "5gp-SP-b-Rel-i"
#I     "5gp-SP-big-Rel-i"     "5gp-SP-d-Rel-i"       "G5-SP-Rel-i"
#I     "G5-SP-a-Rel-i"        "Nott-SP-Rel-i"
#I    7-groups:
#I     "7gp-SP-Rel-i"         "7gp-SP-a-Rel-i"       "7gp-SP-b-Rel-i"
#I    11-groups:
#I     "11gp-SP-a-i"          "11gp-SP-a-Rel-i"      "11gp-SP-a-Rel-1-i"
#I     "11gp-SP-b-i"          "11gp-SP-b-Rel-i"      "11gp-SP-c-Rel-i"
#I  
#I  Notes
#I  -----
#I  1. The example (first) argument of  `PqExample'  is  a  string;  each
#I     example above is in double quotes to remind you to include them.
#I  2. Some examples accept options. To find  out  whether  a  particular
#I     example accepts options, display it first (by including  `Display'
#I     as  last  argument)  which  will  also  indicate  how  `PqExample'
#I     interprets the options, e.g. `PqExample("11gp-SP-a-i", Display);'.
#I  3. Try `SetInfoLevel(InfoANUPQ, <n>);' for  some  <n>  in  [2  ..  4]
#I     before calling PqExample, to see what's going on behind the scenes.
#I

If on your terminal you are unable to scroll back, an alternative to typing PqExample(); to see the displayed examples is to use on-line help, i.e.  you may type:

gap> ?anupq:examples

which will display this appendix in a GAP session. If you are not fussed about the order in which the examples are organised, AllPqExamples(); lists the available examples relatively compactly (see AllPqExamples (3.4-5)).

In the remainder of this appendix we will discuss particular aspects related to the Relators (see 6.2) and Identities (see 6.2) options, and the construction of the Burnside group B(5, 4).

A.1 The Relators Option

The Relators option was included because computations involving words containing commutators that are pre-expanded by GAP before being passed to the pq program may run considerably more slowly, than the same computations being run with GAP pre-expansions avoided. The following examples demonstrate a case where the performance hit due to pre-expansion of commutators by GAP is a factor of order 100 (in order to see timing information from the pq program, we set the InfoANUPQ level to 2).

Firstly, we run the example that allows pre-expansion of commutators (the function PqLeftNormComm is provided by the ANUPQ package; see PqLeftNormComm (3.4-1)). Note that since the two commutators of this example are very long (taking more than an page to print), we have edited the output at this point.

gap> SetInfoLevel(InfoANUPQ, 2); #to see timing information
gap> PqExample("11gp-i");
#I  #Example: "11gp-i" . . . based on: examples/11gp
#I  F, a, b, c, R, procId are local to `PqExample'
gap> F := FreeGroup("a", "b", "c"); a := F.1; b := F.2; c := F.3;
<free group on the generators [ a, b, c ]>
a
b
c
gap> R := [PqLeftNormComm([b, a, a, b, c])^11, 
>          PqLeftNormComm([a, b, b, a, b, c])^11, (a * b)^11];;
gap> procId := PqStart(F/R : Prime := 11);;
gap> PqPcPresentation(procId : ClassBound := 7, 
>                              OutputLevel := 1);
#I  Lower exponent-11 central series for [grp]
#I  Group: [grp] to lower exponent-11 central class 1 has order 11^3
#I  Group: [grp] to lower exponent-11 central class 2 has order 11^8
#I  Group: [grp] to lower exponent-11 central class 3 has order 11^19
#I  Group: [grp] to lower exponent-11 central class 4 has order 11^42
#I  Group: [grp] to lower exponent-11 central class 5 has order 11^98
#I  Group: [grp] to lower exponent-11 central class 6 has order 11^228
#I  Group: [grp] to lower exponent-11 central class 7 has order 11^563
#I  Computation of presentation took 27.04 seconds
gap> PqSavePcPresentation(procId, ANUPQData.outfile);
#I  Variables used in `PqExample' are saved in `ANUPQData.example.vars'.

Now we do the same calculation using the Relators option. In this way, the commutators are passed directly as strings to the pq program, so that GAP does not see them and pre-expand them.

gap> PqExample("11gp-Rel-i");
#I  #Example: "11gp-Rel-i" . . . based on: examples/11gp
#I  #(equivalent to "11gp-i" example but uses `Relators' option)
#I  F, rels, procId are local to `PqExample'
gap> F := FreeGroup("a", "b", "c");
<free group on the generators [ a, b, c ]>
gap> rels := ["[b, a, a, b, c]^11", "[a, b, b, a, b, c]^11", "(a * b)^11"];
[ "[b, a, a, b, c]^11", "[a, b, b, a, b, c]^11", "(a * b)^11" ]
gap> procId := PqStart(F : Prime := 11, Relators := rels);;
gap> PqPcPresentation(procId : ClassBound := 7, 
>                              OutputLevel := 1);
#I  Relators parsed ok.
#I  Lower exponent-11 central series for [grp]
#I  Group: [grp] to lower exponent-11 central class 1 has order 11^3
#I  Group: [grp] to lower exponent-11 central class 2 has order 11^8
#I  Group: [grp] to lower exponent-11 central class 3 has order 11^19
#I  Group: [grp] to lower exponent-11 central class 4 has order 11^42
#I  Group: [grp] to lower exponent-11 central class 5 has order 11^98
#I  Group: [grp] to lower exponent-11 central class 6 has order 11^228
#I  Group: [grp] to lower exponent-11 central class 7 has order 11^563
#I  Computation of presentation took 0.27 seconds
gap> PqSavePcPresentation(procId, ANUPQData.outfile);
#I  Variables used in `PqExample' are saved in `ANUPQData.example.vars'.

A.2 The Identities Option and PqEvaluateIdentities Function

Please pay heed to the warnings given for the Identities option (see 6.2); it is written mainly at the GAP level and is not particularly optimised. The Identities option allows one to compute p-quotients that satisfy an identity. A trivial example better done using the Exponent option, but which nevertheless demonstrates the usage of the Identities option, is as follows:

gap> SetInfoLevel(InfoANUPQ, 1);
gap> PqExample("B2-4-Id");
#I  #Example: "B2-4-Id" . . . alternative way to generate B(2, 4)
#I  #Generates B(2, 4) by using the `Identities' option
#I  #... this is not as efficient as using `Exponent' but
#I  #demonstrates the usage of the `Identities' option.
#I  F, f, procId are local to `PqExample'
gap> F := FreeGroup("a", "b");
<free group on the generators [ a, b ]>
gap> # All words w in the pc generators of B(2, 4) satisfy f(w) = 1 
gap> f := w -> w^4;
function( w ) ... end
gap> Pq( F : Prime := 2, Identities := [ f ] );
#I  Class 1 with 2 generators.
#I  Class 2 with 5 generators.
#I  Class 3 with 7 generators.
#I  Class 4 with 10 generators.
#I  Class 5 with 12 generators.
#I  Class 5 with 12 generators.
<pc group of size 4096 with 12 generators>
#I  Variables used in `PqExample' are saved in `ANUPQData.example.vars'.
gap> time; 
1400

Note that the time statement gives the time in milliseconds spent by GAP in executing the PqExample("B2-4-Id"); command (i.e. everything up to the Info-ing of the variables used), but over 90% of that time is spent in the final Pq statement. The time spent by the pq program, which is negligible anyway (you can check this by running the example while the InfoANUPQ level is set to 2), is not counted by time.

Since the identity used in the above construction of B(2, 4) is just an exponent law, the right way to compute it is via the Exponent option (see 6.2), which is implemented at the C level and is highly optimised. Consequently, the Exponent option is significantly faster, generally by several orders of magnitude:

gap> SetInfoLevel(InfoANUPQ, 2); # to see time spent by the `pq' program
gap> PqExample("B2-4");
#I  #Example: "B2-4" . . . the ``right'' way to generate B(2, 4)
#I  #Generates B(2, 4) by using the `Exponent' option
#I  F, procId are local to `PqExample'
gap> F := FreeGroup("a", "b");
<free group on the generators [ a, b ]>
gap> Pq( F : Prime := 2, Exponent := 4 );
#I  Computation of presentation took 0.00 seconds
<pc group of size 4096 with 12 generators>
#I  Variables used in `PqExample' are saved in `ANUPQData.example.vars'.
gap> time; # time spent by GAP in executing `PqExample("B2-4");' 
50

The following example uses the Identities option to compute a 3-Engel group for the prime 11. As is the case for the example "B2-4-Id", the example has both a non-interactive and an interactive form; below, we demonstrate the interactive form.

gap> SetInfoLevel(InfoANUPQ, 1); # reset InfoANUPQ to default level
gap> PqExample("11gp-3-Engel-Id", PqStart);
#I  #Example: "11gp-3-Engel-Id" . . . 3-Engel group for prime 11
#I  #Non-trivial example of using the `Identities' option
#I  F, a, b, G, f, procId, Q are local to `PqExample'
gap> F := FreeGroup("a", "b"); a := F.1; b := F.2;
<free group on the generators [ a, b ]>
a
b
gap> G := F/[ a^11, b^11 ];
<fp group on the generators [ a, b ]>
gap> # All word pairs u, v in the pc generators of the 11-quotient Q of G 
gap> # must satisfy the Engel identity: [u, v, v, v] = 1.
gap> f := function(u, v) return PqLeftNormComm( [u, v, v, v] ); end;
function( u, v ) ... end
gap> procId := PqStart( G );;
gap> Q := Pq( procId : Prime := 11, Identities := [ f ] );
#I  Class 1 with 2 generators.
#I  Class 2 with 3 generators.
#I  Class 3 with 5 generators.
#I  Class 3 with 5 generators.
<pc group of size 161051 with 5 generators>
gap> # We do a ``sample'' check that pairs of elements of Q do satisfy
gap> # the given identity:
gap> f( Random(Q), Random(Q) );
<identity> of ...
gap> f( Q.1, Q.2 );
<identity> of ...
#I  Variables used in `PqExample' are saved in `ANUPQData.example.vars'.

The (interactive) call to Pq above is essentially equivalent to a call to PqPcPresentation with the same arguments and options followed by a call to PqCurrentGroup. Moreover, the call to PqPcPresentation (as described in PqPcPresentation (5.6-1)) is equivalent to a class 1 call to PqPcPresentation followed by the requisite number of calls to PqNextClass, and with the Identities option set, both PqPcPresentation and PqNextClass quietly perform the equivalent of a PqEvaluateIdentities call. In the following example we break down the Pq call into its low-level equivalents, and set and unset the Identities option to show where PqEvaluateIdentities fits into this scheme.

gap> PqExample("11gp-3-Engel-Id-i");
#I  #Example: "11gp-3-Engel-Id-i" . . . 3-Engel grp for prime 11
#I  #Variation of "11gp-3-Engel-Id" broken down into its lower-level component
#I  #command parts.
#I  F, a, b, G, f, procId, Q are local to `PqExample'
gap> F := FreeGroup("a", "b"); a := F.1; b := F.2;
<free group on the generators [ a, b ]>
a
b
gap> G := F/[ a^11, b^11 ];
<fp group on the generators [ a, b ]>
gap> # All word pairs u, v in the pc generators of the 11-quotient Q of G 
gap> # must satisfy the Engel identity: [u, v, v, v] = 1.
gap> f := function(u, v) return PqLeftNormComm( [u, v, v, v] ); end;
function( u, v ) ... end
gap> procId := PqStart( G : Prime := 11 );;
gap> PqPcPresentation( procId : ClassBound := 1);
gap> PqEvaluateIdentities( procId : Identities := [f] );
#I  Class 1 with 2 generators.
gap> for c in [2 .. 4] do
>      PqNextClass( procId : Identities := [] ); #reset `Identities' option
>      PqEvaluateIdentities( procId : Identities := [f] );
>    od;
#I  Class 2 with 3 generators.
#I  Class 3 with 5 generators.
#I  Class 3 with 5 generators.
gap> Q := PqCurrentGroup( procId );
<pc group of size 161051 with 5 generators>
gap> # We do a ``sample'' check that pairs of elements of Q do satisfy
gap> # the given identity:
gap> f( Random(Q), Random(Q) );
<identity> of ...
gap> f( Q.1, Q.2 );
<identity> of ...
#I  Variables used in `PqExample' are saved in `ANUPQData.example.vars'.

A.3 A Large Example

An example demonstrating how a large computation can be organised with the ANUPQ package is the computation of the Burnside group B(5, 4), the largest group of exponent 4 generated by 5 elements. It has order 2^2728 and lower exponent-p central class 13. The example "B5-4.g" computes B(5, 4); it is based on a pq standalone input file written by M. F. Newman.

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 GAP.

Please note that the construction uses the knowledge gained by Newman and O'Brien in their initial construction of B(5, 4), in particular, insight into the commutator structure of the group and the knowledge of the p-central class and the order of B(5, 4). Therefore, the construction cannot be used to prove that B(5, 4) 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 examples/B5-4.g.

procId := PqStart( FreeGroup(5) : Exponent := 4, Prime := 2 );
Pq( procId : ClassBound := 2 );
PqSupplyAutomorphisms( procId,
      [
        [ [ 1, 1, 0, 0, 0],      # first automorphism
          [ 0, 1, 0, 0, 0],
          [ 0, 0, 1, 0, 0],
          [ 0, 0, 0, 1, 0],
          [ 0, 0, 0, 0, 1] ],

        [ [ 0, 0, 0, 0, 1],      # second automorphism
          [ 1, 0, 0, 0, 0],
          [ 0, 1, 0, 0, 0],
          [ 0, 0, 1, 0, 0],
          [ 0, 0, 0, 1, 0] ]
                             ] );;

Relations :=
  [ [],          ## class 1
    [],          ## class 2
    [],          ## class 3
    [],          ## class 4
    [],          ## class 5
    [],          ## class 6
    ## class 7     
    [ [ "x2","x1","x1","x3","x4","x4","x4" ] ],
    ## class 8
    [ [ "x2","x1","x1","x3","x4","x5","x5","x5" ] ],
    ## class 9
    [ [ "x2","x1","x1","x3","x4","x4","x5","x5","x5" ],
      [ "x2","x1","x1","x2","x3","x4","x5","x5","x5" ],
      [ "x2","x1","x1","x3","x3","x4","x5","x5","x5" ] ],
    ## class 10
    [ [ "x2","x1","x1","x2","x3","x3","x4","x5","x5","x5" ],
      [ "x2","x1","x1","x3","x3","x4","x4","x5","x5","x5" ] ],
    ## class 11
    [ [ "x2","x1","x1","x2","x3","x3","x4","x4","x5","x5","x5" ],
      [ "x2","x1","x1","x2","x3","x1","x3","x4","x2","x4","x3" ] ],
    ## class 12
    [ [ "x2","x1","x1","x2","x3","x1","x3","x4","x2","x5","x5","x5" ],
      [ "x2","x1","x1","x3","x2","x4","x3","x5","x4","x5","x5","x5" ] ],
    ## class 13
    [ [ "x2","x1","x1","x2","x3","x1","x3","x4","x2","x4","x5","x5","x5" 
        ] ]
];

for class in [ 3 .. 13 ] do
    Print( "Computing class ", class, "\n" );
    PqSetupTablesForNextClass( procId );

    for w in [ class, class-1 .. 7 ] do

        PqAddTails( procId, w );   
        PqDisplayPcPresentation( procId );

        if Relations[ w ] <> [] then
            # recalculate automorphisms
            PqExtendAutomorphisms( procId );

            for r in Relations[ w ] do
                Print( "Collecting ", r, "\n" );
                PqCommutator( procId, r, 1 );
                PqEchelonise( procId );
                PqApplyAutomorphisms( procId, 15 ); #queue factor = 15
            od;

            PqEliminateRedundantGenerators( procId );
        fi;   
        PqComputeTails( procId, w );
    od;
    PqDisplayPcPresentation( procId );

    smallclass := Minimum( class, 6 );
    for w in [ smallclass, smallclass-1 .. 2 ] do
        PqTails( procId, w );
    od;
    # recalculate automorphisms
    PqExtendAutomorphisms( procId );
    PqCollect( procId, "x5^4" );
    PqEchelonise( procId );
    PqApplyAutomorphisms( procId, 15 ); #queue factor = 15
    PqEliminateRedundantGenerators( procId );
    PqDisplayPcPresentation( procId );
od;

A.4 Developing descendants trees

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 p-group generation machinery of the package. We start with the elementary abelian 3-group of rank 2. From within GAP, run the example "PqDescendants-treetraverse-i" via PqExample (see PqExample (3.4-4)).

gap> G := ElementaryAbelianGroup( 9 );
<pc group of size 9 with 2 generators>
gap> procId := PqStart( G );;
gap> #
gap> #  Below, we use the option StepSize in order to construct descendants
gap> #  of coclass 1. This is equivalent to setting the StepSize to 1 in
gap> #  each descendant calculation.
gap> #
gap> #  The elementary abelian group of order 9 has 3 descendants of
gap> #  3-class 2 and 3-coclass 1, as the result of the next command
gap> #  shows. 
gap> #
gap> PqDescendants( procId : StepSize := 1 );
[ <pc group of size 27 with 3 generators>, 
  <pc group of size 27 with 3 generators>, 
  <pc group of size 27 with 3 generators> ]
gap> #
gap> #  Now we will compute the descendants of coclass 1 for each of the
gap> #  groups above. Then we will compute the descendants  of coclass 1
gap> #  of each descendant and so  on.  Note  that the  pq program keeps
gap> #  one file for each class at a time.  For example, the descendants
gap> #  calculation for  the  second  group  of class  2  overwrites the
gap> #  descendant file  obtained  from  the  first  group  of  class 2.
gap> #  Hence,  we have to traverse the descendants tree  in depth first
gap> #  order.
gap> #
gap> PqPGSetDescendantToPcp( procId, 2, 1 );
gap> PqPGExtendAutomorphisms( procId );
gap> PqPGConstructDescendants( procId : StepSize := 1 );
2
gap> PqPGSetDescendantToPcp( procId, 3, 1 );
gap> PqPGExtendAutomorphisms( procId );
gap> PqPGConstructDescendants( procId : StepSize := 1 );
2
gap> PqPGSetDescendantToPcp( procId, 4, 1 );
gap> PqPGExtendAutomorphisms( procId );
gap> PqPGConstructDescendants( procId : StepSize := 1 );
2
gap> #
gap> #  At this point we stop traversing the ``left most'' branch of the
gap> #  descendants tree and move upwards.
gap> #
gap> PqPGSetDescendantToPcp( procId, 4, 2 );
gap> PqPGExtendAutomorphisms( procId );
gap> PqPGConstructDescendants( procId : StepSize := 1 );
#I  group restored from file is incapable
0
gap> PqPGSetDescendantToPcp( procId, 3, 2 );
gap> PqPGExtendAutomorphisms( procId );
gap> PqPGConstructDescendants( procId : StepSize := 1 );
#I  group restored from file is incapable
0
gap> #  
gap> #  The computations above indicate that the descendants subtree under
gap> #  the first descendant of the elementary abelian group of order 9
gap> #  will have only one path of infinite length.
gap> #
gap> PqPGSetDescendantToPcp( procId, 2, 2 );
gap> PqPGExtendAutomorphisms( procId );
gap> PqPGConstructDescendants( procId : StepSize := 1 );
4
gap> #
gap> #  We get four descendants here, three of which will turn out to be
gap> #  incapable, i.e., they have no descendants and are terminal nodes
gap> #  in the descendants tree.
gap> #
gap> PqPGSetDescendantToPcp( procId, 2, 3 );
gap> PqPGExtendAutomorphisms( procId );
gap> PqPGConstructDescendants( procId : StepSize := 1 );
#I  group restored from file is incapable
0
gap> #
gap> #  The third descendant of class three is incapable.  Let us return
gap> #  to the second descendant of class 2.
gap> #
gap> PqPGSetDescendantToPcp( procId, 2, 2 );
gap> PqPGExtendAutomorphisms( procId );
gap> PqPGConstructDescendants( procId : StepSize := 1 );
4
gap> PqPGSetDescendantToPcp( procId, 3, 1 );
gap> PqPGExtendAutomorphisms( procId );
gap> PqPGConstructDescendants( procId : StepSize := 1 );
#I  group restored from file is incapable
0
gap> PqPGSetDescendantToPcp( procId, 3, 2 );
gap> PqPGExtendAutomorphisms( procId );
gap> PqPGConstructDescendants( procId : StepSize := 1 );
#I  group restored from file is incapable
0
gap> #
gap> #  We skip the third descendant for the moment ... 
gap> #
gap> PqPGSetDescendantToPcp( procId, 3, 4 );
gap> PqPGExtendAutomorphisms( procId );
gap> PqPGConstructDescendants( procId : StepSize := 1 );
#I  group restored from file is incapable
0
gap> #
gap> #  ... and look at it now.
gap> #
gap> PqPGSetDescendantToPcp( procId, 3, 3 );
gap> PqPGExtendAutomorphisms( procId );
gap> PqPGConstructDescendants( procId : StepSize := 1 );
6
gap> #
gap> #  In this branch of the descendant tree we get 6 descendants of class
gap> #  three.  Of those 5 will turn out to be incapable and one will have
gap> #  7 descendants.
gap> #
gap> PqPGSetDescendantToPcp( procId, 4, 1 );
gap> PqPGExtendAutomorphisms( procId );
gap> PqPGConstructDescendants( procId : StepSize := 1 );
#I  group restored from file is incapable
0
gap> PqPGSetDescendantToPcp( procId, 4, 2 );
gap> PqPGExtendAutomorphisms( procId );
gap> PqPGConstructDescendants( procId : StepSize := 1 );
7
gap> PqPGSetDescendantToPcp( procId, 4, 3 );
gap> PqPGExtendAutomorphisms( procId );
gap> PqPGConstructDescendants( procId : StepSize := 1 );
#I  group restored from file is incapable
0

To automate the above procedure to some extent we provide:

A.4-1 PqDescendantsTreeCoclassOne
‣ PqDescendantsTreeCoclassOne( i )( function )
‣ PqDescendantsTreeCoclassOne( )( function )

for the ith or default interactive ANUPQ process, generate a descendant tree for the group of the process (which must be a pc p-group) consisting of descendants of p-coclass 1 and extending to the class determined by the option TreeDepth (or 6 if the option is omitted). In an XGAP session, a graphical representation of the descendants tree appears in a separate window. Subsequent calls to PqDescendantsTreeCoclassOne for the same process may be used to extend the descendant tree from the last descendant computed that itself has more than one descendant. PqDescendantsTreeCoclassOne also accepts the options CapableDescendants (or AllDescendants) and any options accepted by the interactive PqDescendants function (see PqDescendants (5.3-6)).

Notes

  1. PqDescendantsTreeCoclassOne first calls PqDescendants. If PqDescendants has already been called for the process, the previous value computed is used and a warning is Info-ed at InfoANUPQ level 1.

  2. As each descendant is processed its unique label defined by the pq program and number of descendants is Info-ed at InfoANUPQ level 1.

  3. PqDescendantsTreeCoclassOne is an experimental function that is included to demonstrate the sort of things that are possible with the p-group generation machinery.

Ignoring the extra functionality provided in an XGAP session, PqDescendantsTreeCoclassOne, with one argument that is the index of an interactive ANUPQ process, is approximately equivalent to:

PqDescendantsTreeCoclassOne := function( procId )
    local des, i;

    des := PqDescendants( procId : StepSize := 1 );
    RecurseDescendants( procId, 2, Length(des) );
end;

where RecurseDescendants is (approximately) defined as follows:

RecurseDescendants := function( procId, class, n )
    local i, nr;

    if class > ValueOption("TreeDepth") then return; fi;

    for i in [1..n] do
        PqPGSetDescendantToPcp( procId, class, i );
        PqPGExtendAutomorphisms( procId );
        nr := PqPGConstructDescendants( procId : StepSize := 1 );
        Print( "Number of descendants of group ", i,
               " at class ", class, ": ", nr, "\n" );
        RecurseDescendants( procId, class+1, nr );
    od;
    return;
end;

The following examples (executed via PqExample; see PqExample (3.4-4)), demonstrate the use of PqDescendantsTreeCoclassOne:

"PqDescendantsTreeCoclassOne-9-i"

approximately does example "PqDescendants-treetraverse-i" again using PqDescendantsTreeCoclassOne;

"PqDescendantsTreeCoclassOne-16-i"

uses the option CapableDescendants; and

"PqDescendantsTreeCoclassOne-25-i"

calculates all descendants by omitting the CapableDescendants option.

The numbers 9, 16 and 25 respectively, indicate the order of the elementary abelian group to which PqDescendantsTreeCoclassOne is applied for these examples.

 [Top of Book]  [Contents]   [Previous Chapter]   [Next Chapter] 
Goto Chapter: Top 1 2 3 4 5 6 7 A Bib Ind

generated by GAPDoc2HTML

anupq-3.3.3/doc/chap0.txt0000644000175100017510000001616515111342310014553 0ustar runnerrunner  ANUPQ   ANU p-Quotient  3.3.3 25 November 2025 Greg Gamble Werner Nickel Eamonn O'Brien ANUPQ is maintained by Max Horn (mailto:mhorn@rptu.de). For support requests, please use our issue tracker (https://github.com/gap-packages/anupq/issues). Greg Gamble Email: mailto:Greg.Gamble@uwa.edu.au Eamonn O'Brien Email: mailto:obrien@math.auckland.ac.nz Homepage: https://www.math.auckland.ac.nz/~obrien ------------------------------------------------------- Copyright © 2001-2016 by Greg Gamble © 2001-2005 by Werner Nickel © 1995-2001 by Eamon O'Brien The GAP package ANUPQ is licensed under the Artistic License 2.0 (https://opensource.org/licenses/artistic-license-2.0). ------------------------------------------------------- Contents (ANUPQ) 1 Introduction 1.1 Overview 1.2 How to read this manual 1.3 Authors and Acknowledgements 2 Mathematical Background and Terminology 2.1 Basic notions 2.1-1 pc Presentations and Consistency 2.1-2 Exponent-p Central Series and Weighted pc Presentations 2.1-3 p-Cover, p-Multiplicator 2.1-4 Descendants, Capable, Terminal, Nucleus 2.1-5 Laws 2.2 The p-quotient Algorithm 2.2-1 Finding the p-cover 2.2-2 Imposing the Relations of the fp Group 2.2-3 Imposing Laws 2.3 The p-group generation Algorithm, Standard Presentation, Isomorphism Testing 3 Infrastructure 3.1 Loading the ANUPQ Package 3.2 The ANUPQData Record 3.2-1 ANUPQData 3.2-2 ANUPQDirectoryTemporary 3.3 Setting the Verbosity of ANUPQ via Info and InfoANUPQ 3.3-1 InfoANUPQ 3.4 Utility Functions 3.4-1 PqLeftNormComm 3.4-2 PqGAPRelators 3.4-3 PqParseWord 3.4-4 PqExample 3.4-5 AllPqExamples 3.4-6 GrepPqExamples 3.4-7 ToPQLog 3.5 Attributes and a Property for fp and pc p-groups 3.5-1 NuclearRank 3.6 Hints and Warnings regarding the use of Options 3.6-1 ANUPQWarnOfOtherOptions 4 Non-interactive ANUPQ functions 4.1 Computing p-Quotients 4.1-1 Pq 4.1-2 PqEpimorphism 4.1-3 PqPCover 4.2 Computing Standard Presentations 4.2-1 PqStandardPresentation 4.2-2 EpimorphismPqStandardPresentation 4.3 Testing p-Groups for Isomorphism 4.3-1 IsPqIsomorphicPGroup 4.4 Computing Descendants of a p-Group 4.4-1 PqDescendants 4.4-2 PqSupplementInnerAutomorphisms 4.4-3 PqList 4.4-4 SavePqList 5 Interactive ANUPQ functions 5.1 Starting and Stopping Interactive ANUPQ Processes 5.1-1 PqStart 5.1-2 PqQuit 5.1-3 PqQuitAll 5.2 Interactive ANUPQ Process Utility Functions 5.2-1 PqProcessIndex 5.2-2 PqProcessIndices 5.2-3 IsPqProcessAlive 5.3 Interactive Versions of Non-interactive ANUPQ Functions 5.3-1 Pq 5.3-2 PqEpimorphism 5.3-3 PqPCover 5.3-4 PqStandardPresentation 5.3-5 EpimorphismPqStandardPresentation 5.3-6 PqDescendants 5.3-7 PqSetPQuotientToGroup 5.4 Low-level Interactive ANUPQ functions based on menu items of the pq program 5.5 General commands 5.5-1 PqNrPcGenerators 5.5-2 PqFactoredOrder 5.5-3 PqOrder 5.5-4 PqPClass 5.5-5 PqWeight 5.5-6 PqCurrentGroup 5.5-7 PqDisplayPcPresentation 5.5-8 PqSetOutputLevel 5.5-9 PqEvaluateIdentities 5.6 Commands from the Main p-Quotient menu 5.6-1 PqPcPresentation 5.6-2 PqSavePcPresentation 5.6-3 PqRestorePcPresentation 5.6-4 PqNextClass 5.6-5 PqComputePCover 5.7 Commands from the Advanced p-Quotient menu 5.7-1 PqCollect 5.7-2 PqSolveEquation 5.7-3 PqCommutator 5.7-4 PqSetupTablesForNextClass 5.7-5 PqTails 5.7-6 PqComputeTails 5.7-7 PqAddTails 5.7-8 PqDoConsistencyChecks 5.7-9 PqCollectDefiningRelations 5.7-10 PqCollectWordInDefiningGenerators 5.7-11 PqCommutatorDefiningGenerators 5.7-12 PqDoExponentChecks 5.7-13 PqEliminateRedundantGenerators 5.7-14 PqRevertToPreviousClass 5.7-15 PqSetMaximalOccurrences 5.7-16 PqSetMetabelian 5.7-17 PqDoConsistencyCheck 5.7-18 PqCompact 5.7-19 PqEchelonise 5.7-20 PqSupplyAutomorphisms 5.7-21 PqExtendAutomorphisms 5.7-22 PqApplyAutomorphisms 5.7-23 PqDisplayStructure 5.7-24 PqDisplayAutomorphisms 5.7-25 PqWritePcPresentation 5.8 Commands from the Standard Presentation menu 5.8-1 PqSPComputePcpAndPCover 5.8-2 PqSPStandardPresentation 5.8-3 PqSPSavePresentation 5.8-4 PqSPCompareTwoFilePresentations 5.8-5 PqSPIsomorphism 5.9 Commands from the Main p-Group Generation menu 5.9-1 PqPGSupplyAutomorphisms 5.9-2 PqPGExtendAutomorphisms 5.9-3 PqPGConstructDescendants 5.9-4 PqPGSetDescendantToPcp 5.10 Commands from the Advanced p-Group Generation menu 5.10-1 PqAPGDegree 5.10-2 PqAPGPermutations 5.10-3 PqAPGOrbits 5.10-4 PqAPGOrbitRepresentatives 5.10-5 PqAPGSingleStage 5.11 Primitive Interactive ANUPQ Process Read/Write Functions 5.11-1 PqRead 5.11-2 PqReadAll 5.11-3 PqReadUntil 5.11-4 PqWrite 6 ANUPQ Options 6.1 Overview 6.1-1 AllANUPQoptions 6.1-2 ANUPQoptions 6.2 Detailed descriptions of ANUPQ Options 7 Installing the ANUPQ Package 7.1 Testing your ANUPQ installation 7.2 Running the pq program as a standalone A Examples A.1 The Relators Option A.2 The Identities Option and PqEvaluateIdentities Function A.3 A Large Example A.4 Developing descendants trees A.4-1 PqDescendantsTreeCoclassOne  anupq-3.3.3/doc/examples.xml0000644000175100017510000007304615111342310015360 0ustar runnerrunner Examples There are a large number of examples provided with the &ANUPQ; package. These may be executed or displayed via the function PqExample (see ). Each example resides in a file of the same name in the directory examples. Most of the examples are translations to &GAP; of examples provided for the pq standalone by Eamonn O'Brien; the standalone examples are found in directories standalone/examples (p-quotient and p-group generation examples) and standalone/isom (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 live is always indicated near -- usually immediately after -- the text example). The format of the (PqExample) examples is such that they can be read by the standard Read function of &GAP;, but certain features and comments are interpreted by the function PqExample to do somewhat more than Read does. In particular, any function without a -i, -ni or .g suffix has both a non-interactive and interactive form; in these cases, the default form is the non-interactive form, and giving PqStart as second argument generates the interactive form.

Running PqExample without an argument or with a non-existent example Infos the available examples and some hints on usage: PqExample(); #I PqExample Index (Table of Contents) #I ----------------------------------- #I This table of possible examples is displayed when calling `PqExample' #I with no arguments, or with the argument: "index" (meant in the sense #I of ``list''), or with a non-existent example name. #I #I Examples that have a name ending in `-ni' are non-interactive only. #I Examples that have a name ending in `-i' are interactive only. #I Examples with names ending in `.g' also have only one form. Other #I examples have both a non-interactive and an interactive form; call #I `PqExample' with 2nd argument `PqStart' to get the interactive form #I of the example. The substring `PG' in an example name indicates a #I p-Group Generation example, `SP' indicates a Standard Presentation #I example, `Rel' indicates it uses the `Relators' option, and `Id' #I indicates it uses the `Identities' option. #I #I The following ANUPQ examples are available: #I #I p-Quotient examples: #I general: #I "Pq" "Pq-ni" "PqEpimorphism" #I "PqPCover" "PqSupplementInnerAutomorphisms" #I 2-groups: #I "2gp-Rel" "2gp-Rel-i" "2gp-a-Rel-i" #I "B2-4" "B2-4-Id" "B2-8-i" #I "B4-4-i" "B4-4-a-i" "B5-4.g" #I 3-groups: #I "3gp-Rel-i" "3gp-a-Rel" "3gp-a-Rel-i" #I "3gp-a-x-Rel-i" "3gp-maxoccur-Rel-i" #I 5-groups: #I "5gp-Rel-i" "5gp-a-Rel-i" "5gp-b-Rel-i" #I "5gp-c-Rel-i" "5gp-metabelian-Rel-i" "5gp-maxoccur-Rel-i" #I "F2-5-i" "B2-5-i" "R2-5-i" #I "R2-5-x-i" "B5-5-Engel3-Id" #I 7-groups: #I "7gp-Rel-i" #I 11-groups: #I "11gp-i" "11gp-Rel-i" "11gp-a-Rel-i" #I "11gp-3-Engel-Id" "11gp-3-Engel-Id-i" #I #I p-Group Generation examples: #I general: #I "PqDescendants-1" "PqDescendants-2" "PqDescendants-3" #I "PqDescendants-1-i" #I 2-groups: #I "2gp-PG-i" "2gp-PG-2-i" "2gp-PG-3-i" #I "2gp-PG-4-i" "2gp-PG-e4-i" #I "PqDescendantsTreeCoclassOne-16-i" #I 3-groups: #I "3gp-PG-i" "3gp-PG-4-i" "3gp-PG-x-i" #I "3gp-PG-x-1-i" "PqDescendants-treetraverse-i" #I "PqDescendantsTreeCoclassOne-9-i" #I 5-groups: #I "5gp-PG-i" "Nott-PG-Rel-i" "Nott-APG-Rel-i" #I "PqDescendantsTreeCoclassOne-25-i" #I 7,11-groups: #I "7gp-PG-i" "11gp-PG-i" #I #I Standard Presentation examples: #I general: #I "StandardPresentation" "StandardPresentation-i" #I "EpimorphismStandardPresentation" #I "EpimorphismStandardPresentation-i" "IsIsomorphicPGroup-ni" #I 2-groups: #I "2gp-SP-Rel-i" "2gp-SP-1-Rel-i" "2gp-SP-2-Rel-i" #I "2gp-SP-3-Rel-i" "2gp-SP-4-Rel-i" "2gp-SP-d-Rel-i" #I "gp-256-SP-Rel-i" "B2-4-SP-i" "G2-SP-Rel-i" #I 3-groups: #I "3gp-SP-Rel-i" "3gp-SP-1-Rel-i" "3gp-SP-2-Rel-i" #I "3gp-SP-3-Rel-i" "3gp-SP-4-Rel-i" "G3-SP-Rel-i" #I 5-groups: #I "5gp-SP-Rel-i" "5gp-SP-a-Rel-i" "5gp-SP-b-Rel-i" #I "5gp-SP-big-Rel-i" "5gp-SP-d-Rel-i" "G5-SP-Rel-i" #I "G5-SP-a-Rel-i" "Nott-SP-Rel-i" #I 7-groups: #I "7gp-SP-Rel-i" "7gp-SP-a-Rel-i" "7gp-SP-b-Rel-i" #I 11-groups: #I "11gp-SP-a-i" "11gp-SP-a-Rel-i" "11gp-SP-a-Rel-1-i" #I "11gp-SP-b-i" "11gp-SP-b-Rel-i" "11gp-SP-c-Rel-i" #I #I Notes #I ----- #I 1. The example (first) argument of `PqExample' is a string; each #I example above is in double quotes to remind you to include them. #I 2. Some examples accept options. To find out whether a particular #I example accepts options, display it first (by including `Display' #I as last argument) which will also indicate how `PqExample' #I interprets the options, e.g. `PqExample("11gp-SP-a-i", Display);'. #I 3. Try `SetInfoLevel(InfoANUPQ, );' for some in [2 .. 4] #I before calling PqExample, to see what's going on behind the scenes. #I ]]> If on your terminal you are unable to scroll back, an alternative to typing PqExample(); to see the displayed examples is to use on-line help, i.e.  you may type: ?anupq:examples ]]> which will display this appendix in a &GAP; session. If you are not fussed about the order in which the examples are organised, AllPqExamples(); lists the available examples relatively compactly (see ).

In the remainder of this appendix we will discuss particular aspects related to the Relators (see ) and Identities (see ) options, and the construction of the Burnside group B(5, 4).

The Relators Option The Relators option was included because computations involving words containing commutators that are pre-expanded by &GAP; before being passed to the pq program may run considerably more slowly, than the same computations being run with &GAP; pre-expansions avoided. The following examples demonstrate a case where the performance hit due to pre-expansion of commutators by &GAP; is a factor of order 100 (in order to see timing information from the pq program, we set the InfoANUPQ level to 2).

Firstly, we run the example that allows pre-expansion of commutators (the function PqLeftNormComm is provided by the &ANUPQ; package; see ). Note that since the two commutators of this example are very long (taking more than an page to print), we have edited the output at this point. SetInfoLevel(InfoANUPQ, 2); #to see timing information gap> PqExample("11gp-i"); #I #Example: "11gp-i" . . . based on: examples/11gp #I F, a, b, c, R, procId are local to `PqExample' gap> F := FreeGroup("a", "b", "c"); a := F.1; b := F.2; c := F.3; a b c gap> R := [PqLeftNormComm([b, a, a, b, c])^11, > PqLeftNormComm([a, b, b, a, b, c])^11, (a * b)^11];; gap> procId := PqStart(F/R : Prime := 11);; gap> PqPcPresentation(procId : ClassBound := 7, > OutputLevel := 1); #I Lower exponent-11 central series for [grp] #I Group: [grp] to lower exponent-11 central class 1 has order 11^3 #I Group: [grp] to lower exponent-11 central class 2 has order 11^8 #I Group: [grp] to lower exponent-11 central class 3 has order 11^19 #I Group: [grp] to lower exponent-11 central class 4 has order 11^42 #I Group: [grp] to lower exponent-11 central class 5 has order 11^98 #I Group: [grp] to lower exponent-11 central class 6 has order 11^228 #I Group: [grp] to lower exponent-11 central class 7 has order 11^563 #I Computation of presentation took 27.04 seconds gap> PqSavePcPresentation(procId, ANUPQData.outfile); #I Variables used in `PqExample' are saved in `ANUPQData.example.vars'. ]]> Now we do the same calculation using the Relators option. In this way, the commutators are passed directly as strings to the pq program, so that &GAP; does not see them and pre-expand them. PqExample("11gp-Rel-i"); #I #Example: "11gp-Rel-i" . . . based on: examples/11gp #I #(equivalent to "11gp-i" example but uses `Relators' option) #I F, rels, procId are local to `PqExample' gap> F := FreeGroup("a", "b", "c"); gap> rels := ["[b, a, a, b, c]^11", "[a, b, b, a, b, c]^11", "(a * b)^11"]; [ "[b, a, a, b, c]^11", "[a, b, b, a, b, c]^11", "(a * b)^11" ] gap> procId := PqStart(F : Prime := 11, Relators := rels);; gap> PqPcPresentation(procId : ClassBound := 7, > OutputLevel := 1); #I Relators parsed ok. #I Lower exponent-11 central series for [grp] #I Group: [grp] to lower exponent-11 central class 1 has order 11^3 #I Group: [grp] to lower exponent-11 central class 2 has order 11^8 #I Group: [grp] to lower exponent-11 central class 3 has order 11^19 #I Group: [grp] to lower exponent-11 central class 4 has order 11^42 #I Group: [grp] to lower exponent-11 central class 5 has order 11^98 #I Group: [grp] to lower exponent-11 central class 6 has order 11^228 #I Group: [grp] to lower exponent-11 central class 7 has order 11^563 #I Computation of presentation took 0.27 seconds gap> PqSavePcPresentation(procId, ANUPQData.outfile); #I Variables used in `PqExample' are saved in `ANUPQData.example.vars'. ]]>

The Identities Option and PqEvaluateIdentities Function Please pay heed to the warnings given for the Identities option (see ); it is written mainly at the &GAP; level and is not particularly optimised. The Identities option allows one to compute p-quotients that satisfy an identity. A trivial example better done using the Exponent option, but which nevertheless demonstrates the usage of the Identities option, is as follows: SetInfoLevel(InfoANUPQ, 1); gap> PqExample("B2-4-Id"); #I #Example: "B2-4-Id" . . . alternative way to generate B(2, 4) #I #Generates B(2, 4) by using the `Identities' option #I #... this is not as efficient as using `Exponent' but #I #demonstrates the usage of the `Identities' option. #I F, f, procId are local to `PqExample' gap> F := FreeGroup("a", "b"); gap> # All words w in the pc generators of B(2, 4) satisfy f(w) = 1 gap> f := w -> w^4; function( w ) ... end gap> Pq( F : Prime := 2, Identities := [ f ] ); #I Class 1 with 2 generators. #I Class 2 with 5 generators. #I Class 3 with 7 generators. #I Class 4 with 10 generators. #I Class 5 with 12 generators. #I Class 5 with 12 generators. #I Variables used in `PqExample' are saved in `ANUPQData.example.vars'. gap> time; 1400 ]]> Note that the time statement gives the time in milliseconds spent by &GAP; in executing the PqExample("B2-4-Id"); command (i.e. everything up to the Info-ing of the variables used), but over 90% of that time is spent in the final Pq statement. The time spent by the pq program, which is negligible anyway (you can check this by running the example while the InfoANUPQ level is set to 2), is not counted by time.

Since the identity used in the above construction of B(2, 4) is just an exponent law, the right way to compute it is via the Exponent option (see ), which is implemented at the C level and is highly optimised. Consequently, the Exponent option is significantly faster, generally by several orders of magnitude: SetInfoLevel(InfoANUPQ, 2); # to see time spent by the `pq' program gap> PqExample("B2-4"); #I #Example: "B2-4" . . . the ``right'' way to generate B(2, 4) #I #Generates B(2, 4) by using the `Exponent' option #I F, procId are local to `PqExample' gap> F := FreeGroup("a", "b"); gap> Pq( F : Prime := 2, Exponent := 4 ); #I Computation of presentation took 0.00 seconds #I Variables used in `PqExample' are saved in `ANUPQData.example.vars'. gap> time; # time spent by GAP in executing `PqExample("B2-4");' 50 ]]> The following example uses the Identities option to compute a 3-Engel group for the prime 11. As is the case for the example "B2-4-Id", the example has both a non-interactive and an interactive form; below, we demonstrate the interactive form. SetInfoLevel(InfoANUPQ, 1); # reset InfoANUPQ to default level gap> PqExample("11gp-3-Engel-Id", PqStart); #I #Example: "11gp-3-Engel-Id" . . . 3-Engel group for prime 11 #I #Non-trivial example of using the `Identities' option #I F, a, b, G, f, procId, Q are local to `PqExample' gap> F := FreeGroup("a", "b"); a := F.1; b := F.2; a b gap> G := F/[ a^11, b^11 ]; gap> # All word pairs u, v in the pc generators of the 11-quotient Q of G gap> # must satisfy the Engel identity: [u, v, v, v] = 1. gap> f := function(u, v) return PqLeftNormComm( [u, v, v, v] ); end; function( u, v ) ... end gap> procId := PqStart( G );; gap> Q := Pq( procId : Prime := 11, Identities := [ f ] ); #I Class 1 with 2 generators. #I Class 2 with 3 generators. #I Class 3 with 5 generators. #I Class 3 with 5 generators. gap> # We do a ``sample'' check that pairs of elements of Q do satisfy gap> # the given identity: gap> f( Random(Q), Random(Q) ); of ... gap> f( Q.1, Q.2 ); of ... #I Variables used in `PqExample' are saved in `ANUPQData.example.vars'. ]]> The (interactive) call to Pq above is essentially equivalent to a call to PqPcPresentation with the same arguments and options followed by a call to PqCurrentGroup. Moreover, the call to PqPcPresentation (as described in ) is equivalent to a class 1 call to PqPcPresentation followed by the requisite number of calls to PqNextClass, and with the Identities option set, both PqPcPresentation and PqNextClass quietly perform the equivalent of a PqEvaluateIdentities call. In the following example we break down the Pq call into its low-level equivalents, and set and unset the Identities option to show where PqEvaluateIdentities fits into this scheme. PqExample("11gp-3-Engel-Id-i"); #I #Example: "11gp-3-Engel-Id-i" . . . 3-Engel grp for prime 11 #I #Variation of "11gp-3-Engel-Id" broken down into its lower-level component #I #command parts. #I F, a, b, G, f, procId, Q are local to `PqExample' gap> F := FreeGroup("a", "b"); a := F.1; b := F.2; a b gap> G := F/[ a^11, b^11 ]; gap> # All word pairs u, v in the pc generators of the 11-quotient Q of G gap> # must satisfy the Engel identity: [u, v, v, v] = 1. gap> f := function(u, v) return PqLeftNormComm( [u, v, v, v] ); end; function( u, v ) ... end gap> procId := PqStart( G : Prime := 11 );; gap> PqPcPresentation( procId : ClassBound := 1); gap> PqEvaluateIdentities( procId : Identities := [f] ); #I Class 1 with 2 generators. gap> for c in [2 .. 4] do > PqNextClass( procId : Identities := [] ); #reset `Identities' option > PqEvaluateIdentities( procId : Identities := [f] ); > od; #I Class 2 with 3 generators. #I Class 3 with 5 generators. #I Class 3 with 5 generators. gap> Q := PqCurrentGroup( procId ); gap> # We do a ``sample'' check that pairs of elements of Q do satisfy gap> # the given identity: gap> f( Random(Q), Random(Q) ); of ... gap> f( Q.1, Q.2 ); of ... #I Variables used in `PqExample' are saved in `ANUPQData.example.vars'. ]]>

A Large Example B(5,4) An example demonstrating how a large computation can be organised with the &ANUPQ; package is the computation of the Burnside group B(5, 4), the largest group of exponent 4 generated by 5 elements. It has order 2^{2728} and lower exponent-p central class 13. The example "B5-4.g" computes B(5, 4); it is based on a pq standalone input file written by M. F. Newman.

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 &GAP;.

Please note that the construction uses the knowledge gained by Newman and O'Brien in their initial construction of B(5, 4), in particular, insight into the commutator structure of the group and the knowledge of the p-central class and the order of B(5, 4). Therefore, the construction cannot be used to prove that B(5, 4) 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 examples/B5-4.g. [] then # recalculate automorphisms PqExtendAutomorphisms( procId ); for r in Relations[ w ] do Print( "Collecting ", r, "\n" ); PqCommutator( procId, r, 1 ); PqEchelonise( procId ); PqApplyAutomorphisms( procId, 15 ); #queue factor = 15 od; PqEliminateRedundantGenerators( procId ); fi; PqComputeTails( procId, w ); od; PqDisplayPcPresentation( procId ); smallclass := Minimum( class, 6 ); for w in [ smallclass, smallclass-1 .. 2 ] do PqTails( procId, w ); od; # recalculate automorphisms PqExtendAutomorphisms( procId ); PqCollect( procId, "x5^4" ); PqEchelonise( procId ); PqApplyAutomorphisms( procId, 15 ); #queue factor = 15 PqEliminateRedundantGenerators( procId ); PqDisplayPcPresentation( procId ); od; ]]>

Developing descendants trees 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 p-group generation machinery of the package. We start with the elementary abelian 3-group of rank 2. From within &GAP;, run the example "PqDescendants-treetraverse-i" via PqExample (see ). G := ElementaryAbelianGroup( 9 ); gap> procId := PqStart( G );; gap> # gap> # Below, we use the option StepSize in order to construct descendants gap> # of coclass 1. This is equivalent to setting the StepSize to 1 in gap> # each descendant calculation. gap> # gap> # The elementary abelian group of order 9 has 3 descendants of gap> # 3-class 2 and 3-coclass 1, as the result of the next command gap> # shows. gap> # gap> PqDescendants( procId : StepSize := 1 ); [ , , ] gap> # gap> # Now we will compute the descendants of coclass 1 for each of the gap> # groups above. Then we will compute the descendants of coclass 1 gap> # of each descendant and so on. Note that the pq program keeps gap> # one file for each class at a time. For example, the descendants gap> # calculation for the second group of class 2 overwrites the gap> # descendant file obtained from the first group of class 2. gap> # Hence, we have to traverse the descendants tree in depth first gap> # order. gap> # gap> PqPGSetDescendantToPcp( procId, 2, 1 ); gap> PqPGExtendAutomorphisms( procId ); gap> PqPGConstructDescendants( procId : StepSize := 1 ); 2 gap> PqPGSetDescendantToPcp( procId, 3, 1 ); gap> PqPGExtendAutomorphisms( procId ); gap> PqPGConstructDescendants( procId : StepSize := 1 ); 2 gap> PqPGSetDescendantToPcp( procId, 4, 1 ); gap> PqPGExtendAutomorphisms( procId ); gap> PqPGConstructDescendants( procId : StepSize := 1 ); 2 gap> # gap> # At this point we stop traversing the ``left most'' branch of the gap> # descendants tree and move upwards. gap> # gap> PqPGSetDescendantToPcp( procId, 4, 2 ); gap> PqPGExtendAutomorphisms( procId ); gap> PqPGConstructDescendants( procId : StepSize := 1 ); #I group restored from file is incapable 0 gap> PqPGSetDescendantToPcp( procId, 3, 2 ); gap> PqPGExtendAutomorphisms( procId ); gap> PqPGConstructDescendants( procId : StepSize := 1 ); #I group restored from file is incapable 0 gap> # gap> # The computations above indicate that the descendants subtree under gap> # the first descendant of the elementary abelian group of order 9 gap> # will have only one path of infinite length. gap> # gap> PqPGSetDescendantToPcp( procId, 2, 2 ); gap> PqPGExtendAutomorphisms( procId ); gap> PqPGConstructDescendants( procId : StepSize := 1 ); 4 gap> # gap> # We get four descendants here, three of which will turn out to be gap> # incapable, i.e., they have no descendants and are terminal nodes gap> # in the descendants tree. gap> # gap> PqPGSetDescendantToPcp( procId, 2, 3 ); gap> PqPGExtendAutomorphisms( procId ); gap> PqPGConstructDescendants( procId : StepSize := 1 ); #I group restored from file is incapable 0 gap> # gap> # The third descendant of class three is incapable. Let us return gap> # to the second descendant of class 2. gap> # gap> PqPGSetDescendantToPcp( procId, 2, 2 ); gap> PqPGExtendAutomorphisms( procId ); gap> PqPGConstructDescendants( procId : StepSize := 1 ); 4 gap> PqPGSetDescendantToPcp( procId, 3, 1 ); gap> PqPGExtendAutomorphisms( procId ); gap> PqPGConstructDescendants( procId : StepSize := 1 ); #I group restored from file is incapable 0 gap> PqPGSetDescendantToPcp( procId, 3, 2 ); gap> PqPGExtendAutomorphisms( procId ); gap> PqPGConstructDescendants( procId : StepSize := 1 ); #I group restored from file is incapable 0 gap> # gap> # We skip the third descendant for the moment ... gap> # gap> PqPGSetDescendantToPcp( procId, 3, 4 ); gap> PqPGExtendAutomorphisms( procId ); gap> PqPGConstructDescendants( procId : StepSize := 1 ); #I group restored from file is incapable 0 gap> # gap> # ... and look at it now. gap> # gap> PqPGSetDescendantToPcp( procId, 3, 3 ); gap> PqPGExtendAutomorphisms( procId ); gap> PqPGConstructDescendants( procId : StepSize := 1 ); 6 gap> # gap> # In this branch of the descendant tree we get 6 descendants of class gap> # three. Of those 5 will turn out to be incapable and one will have gap> # 7 descendants. gap> # gap> PqPGSetDescendantToPcp( procId, 4, 1 ); gap> PqPGExtendAutomorphisms( procId ); gap> PqPGConstructDescendants( procId : StepSize := 1 ); #I group restored from file is incapable 0 gap> PqPGSetDescendantToPcp( procId, 4, 2 ); gap> PqPGExtendAutomorphisms( procId ); gap> PqPGConstructDescendants( procId : StepSize := 1 ); 7 gap> PqPGSetDescendantToPcp( procId, 4, 3 ); gap> PqPGExtendAutomorphisms( procId ); gap> PqPGConstructDescendants( procId : StepSize := 1 ); #I group restored from file is incapable 0 ]]> To automate the above procedure to some extent we provide: for the ith or default interactive &ANUPQ; process, generate a descendant tree for the group of the process (which must be a pc p-group) consisting of descendants of p-coclass 1 and extending to the class determined by the option TreeDepth (or 6 if the option is omitted). In an &XGAP; session, a graphical representation of the descendants tree appears in a separate window. Subsequent calls to PqDescendantsTreeCoclassOne for the same process may be used to extend the descendant tree from the last descendant computed that itself has more than one descendant. PqDescendantsTreeCoclassOne also accepts the options CapableDescendants (or AllDescendants) and any options accepted by the interactive PqDescendants function (see ).

Notes PqDescendantsTreeCoclassOne first calls PqDescendants. If PqDescendants has already been called for the process, the previous value computed is used and a warning is Info-ed at InfoANUPQ level 1. As each descendant is processed its unique label defined by the pq program and number of descendants is Info-ed at InfoANUPQ level 1. PqDescendantsTreeCoclassOne is an experimental function that is included to demonstrate the sort of things that are possible with the p-group generation machinery. Ignoring the extra functionality provided in an &XGAP; session, PqDescendantsTreeCoclassOne, with one argument that is the index of an interactive &ANUPQ; process, is approximately equivalent to:

where RecurseDescendants is (approximately) defined as follows: ValueOption("TreeDepth") then return; fi; for i in [1..n] do PqPGSetDescendantToPcp( procId, class, i ); PqPGExtendAutomorphisms( procId ); nr := PqPGConstructDescendants( procId : StepSize := 1 ); Print( "Number of descendants of group ", i, " at class ", class, ": ", nr, "\n" ); RecurseDescendants( procId, class+1, nr ); od; return; end; ]]> The following examples (executed via PqExample; see ), demonstrate the use of PqDescendantsTreeCoclassOne: "PqDescendantsTreeCoclassOne-9-i" approximately does example "PqDescendants-treetraverse-i" again using PqDescendantsTreeCoclassOne; "PqDescendantsTreeCoclassOne-16-i" uses the option CapableDescendants; and "PqDescendantsTreeCoclassOne-25-i" calculates all descendants by omitting the CapableDescendants option. The numbers 9, 16 and 25 respectively, indicate the order of the elementary abelian group to which PqDescendantsTreeCoclassOne is applied for these examples.
anupq-3.3.3/doc/chap1.txt0000644000175100017510000001575115111342310014554 0ustar runnerrunner 1 Introduction 1.1 Overview The GAP 4 package ANUPQ provides an interface to the ANU pq C program written by Eamonn O'Brien, making the functionality of the C program available to GAP. Henceforth, we shall refer to the ANUPQ package when referring to the GAP interface, and to the ANU pq program or just pq when referring to that C program. The pq program consists of implementations of the following algorithms: 1 A p-quotient algorithm to compute pc-presentations for p-factor groups of finitely presented groups. 2 A p-group generation algorithm to generate pc presentations of groups of prime power order. 3 A standard presentation algorithm used to compute a canonical pc-presentation of a p-group. 4 An algorithm which can be used to compute the automorphism group of a p-group. This part of the pq program is not accessible through the ANUPQ package. Instead, users are advised to consider the GAP 4 package AutPGrp by Bettina Eick and Eamonn O'Brien, which implements a better algorithm in GAP for the computation of automorphism groups of p-groups. The current version of the ANUPQ package requires GAP 4.5, and version 1.5 of the AutPGrp package. All code that made the package compatible with earlier versions of GAP has been removed. If you must use an older GAP version and cannot upgrade, then you may try using an older ANUPQ version. However, you should not use versions of the ANUPQ package older than 2.2, since they are known to have bugs. 1.2 How to read this manual It is not expected that readers of this manual will read it in a linear fashion from cover to cover; some sections contain material that is far too technical to be absorbed on a first reading. Firstly, installers of the ANUPQ package will need to read Chapter 'Installing the ANUPQ Package', if they have not already gleaned these details from the README file. Once the ANUPQ package is installed, users of the ANUPQ package will benefit most by first reading Chapter 'Mathematical Background and Terminology', which gives a brief description of the background and terminology used (this chapter also cites a number of references for further reading), and the introduction of Chapter 'Infrastructure' (skip the remainder of the chapter on a first reading). Then the user/reader should pursue Chapter 'Non-interactive ANUPQ functions' in detail, delving into Chapter 'ANUPQ Options' as necessary for the options of the functions that are described. The user will become best acquainted with the ANUPQ package by trying the examples. This chapter describes the non-interactive functions of the ANUPQ package, i.e. one-shot functions that invoke the pq program in such a way that once GAP has got what it needs, the pq is allowed to exit. It is expected that most of the time, users will only need these functions. Advanced users will want to explore Chapter 'Interactive ANUPQ functions' which describes all the interactive functions of the ANUPQ package; these are functions that extract information via a dialogue with a running pq process. Occasionally, a user needs the next step; the functions provided in this chapter make use of data from previous steps retained by the pq program, thus allowing the user to interact with the pq program like one can when one uses the pq program as a stand-alone (see guide.dvi in the standalone-doc directory). After having read Chapters 'Non-interactive ANUPQ functions' and 'Interactive ANUPQ functions', cross-references will have taken the reader into Chapter 'ANUPQ Options'; by this stage, the reader need only read the introduction of Chapter 'ANUPQ Options'. After the reader has developed some facility with the ANUPQ package, she should explore the examples described in Appendix 'Examples'. If you run into trouble using the ANUPQ functions, some troubleshooting hints are given in Section 'Hints and Warnings regarding the use of Options'. If the troubleshooting hints don't help, Section 'Authors and Acknowledgements' below, gives contact details for the authors of the components of the ANUPQ package. 1.3 Authors and Acknowledgements The C implementation of the ANU pq standalone was developed by Eamonn O'Brien. An interactive interface using iostreams was developed with the assistance of Werner Nickel by Greg Gamble. The GAP 4 version of this package was adapted from the GAP 3 version by Werner Nickel. A new co-maintainer, Max Horn, joined the team in November, 2011. The authors would like to thank Joachim Neubüser for his careful proof-reading and advice, and for formulating Chapter 'Mathematical Background and Terminology'. We would also like to thank Bettina Eick who by her testing and provision of examples helped us to eliminate a number of bugs and who provided a number of valuable suggestions for extensions of the package beyond the GAP 3 capabilities. If you find a bug, the last section of ANUPQ's README describes the information we need and where to send us a bug report; please take the time to read this (i.e. help us to help you). anupq-3.3.3/doc/chapA_mj.html0000644000175100017510000013561415111342310015410 0ustar runnerrunner GAP (ANUPQ) - Appendix A: Examples
Goto Chapter: Top 1 2 3 4 5 6 7 A Bib Ind
 [Top of Book]  [Contents]   [Previous Chapter]   [Next Chapter] 

A Examples
 A.1 The Relators Option
 A.2 The Identities Option and PqEvaluateIdentities Function
 A.3 A Large Example
 A.4 Developing descendants trees

  A.4-1 PqDescendantsTreeCoclassOne

A Examples

There are a large number of examples provided with the ANUPQ package. These may be executed or displayed via the function PqExample (see PqExample (3.4-4)). Each example resides in a file of the same name in the directory examples. Most of the examples are translations to GAP of examples provided for the pq standalone by Eamonn O'Brien; the standalone examples are found in directories standalone/examples (\(p\)-quotient and \(p\)-group generation examples) and standalone/isom (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 live is always indicated near -- usually immediately after -- the text example). The format of the (PqExample) examples is such that they can be read by the standard Read function of GAP, but certain features and comments are interpreted by the function PqExample to do somewhat more than Read does. In particular, any function without a -i, -ni or .g suffix has both a non-interactive and interactive form; in these cases, the default form is the non-interactive form, and giving PqStart as second argument generates the interactive form.

Running PqExample without an argument or with a non-existent example Infos the available examples and some hints on usage:

gap> PqExample();
#I                   PqExample Index (Table of Contents)
#I                   -----------------------------------
#I  This table of possible examples is displayed when calling `PqExample'
#I  with no arguments, or with the argument: "index" (meant in the  sense
#I  of ``list''), or with a non-existent example name.
#I  
#I  Examples that have a name ending in `-ni' are  non-interactive  only.
#I  Examples that have a  name  ending  in  `-i'  are  interactive  only.
#I  Examples with names ending in `.g' also have  only  one  form.  Other
#I  examples have both a non-interactive and an  interactive  form;  call
#I  `PqExample' with 2nd argument `PqStart' to get the  interactive  form
#I  of the example. The substring `PG' in an  example  name  indicates  a
#I  p-Group Generation example, `SP' indicates  a  Standard  Presentation
#I  example, `Rel' indicates it uses  the  `Relators'  option,  and  `Id'
#I  indicates it uses the `Identities' option.
#I  
#I  The following ANUPQ examples are available:
#I  
#I   p-Quotient examples:
#I    general:
#I     "Pq"                   "Pq-ni"                "PqEpimorphism"        
#I     "PqPCover"             "PqSupplementInnerAutomorphisms"
#I    2-groups:
#I     "2gp-Rel"              "2gp-Rel-i"            "2gp-a-Rel-i"
#I     "B2-4"                 "B2-4-Id"              "B2-8-i"
#I     "B4-4-i"               "B4-4-a-i"             "B5-4.g"
#I    3-groups:
#I     "3gp-Rel-i"            "3gp-a-Rel"            "3gp-a-Rel-i"
#I     "3gp-a-x-Rel-i"        "3gp-maxoccur-Rel-i"
#I    5-groups:
#I     "5gp-Rel-i"            "5gp-a-Rel-i"          "5gp-b-Rel-i"
#I     "5gp-c-Rel-i"          "5gp-metabelian-Rel-i" "5gp-maxoccur-Rel-i"
#I     "F2-5-i"               "B2-5-i"               "R2-5-i"
#I     "R2-5-x-i"             "B5-5-Engel3-Id"
#I    7-groups:
#I     "7gp-Rel-i"
#I    11-groups:
#I     "11gp-i"               "11gp-Rel-i"           "11gp-a-Rel-i"
#I     "11gp-3-Engel-Id"      "11gp-3-Engel-Id-i"
#I  
#I   p-Group Generation examples:
#I    general:
#I     "PqDescendants-1"      "PqDescendants-2"      "PqDescendants-3"
#I     "PqDescendants-1-i"
#I    2-groups:
#I     "2gp-PG-i"             "2gp-PG-2-i"           "2gp-PG-3-i"
#I     "2gp-PG-4-i"           "2gp-PG-e4-i"
#I     "PqDescendantsTreeCoclassOne-16-i"
#I    3-groups:
#I     "3gp-PG-i"             "3gp-PG-4-i"           "3gp-PG-x-i"
#I     "3gp-PG-x-1-i"         "PqDescendants-treetraverse-i"
#I     "PqDescendantsTreeCoclassOne-9-i"
#I    5-groups:
#I     "5gp-PG-i"             "Nott-PG-Rel-i"        "Nott-APG-Rel-i"
#I     "PqDescendantsTreeCoclassOne-25-i"
#I    7,11-groups:
#I     "7gp-PG-i"             "11gp-PG-i"
#I  
#I   Standard Presentation examples:
#I    general:
#I     "StandardPresentation" "StandardPresentation-i"
#I     "EpimorphismStandardPresentation"
#I     "EpimorphismStandardPresentation-i"           "IsIsomorphicPGroup-ni"
#I    2-groups:
#I     "2gp-SP-Rel-i"         "2gp-SP-1-Rel-i"       "2gp-SP-2-Rel-i"
#I     "2gp-SP-3-Rel-i"       "2gp-SP-4-Rel-i"       "2gp-SP-d-Rel-i"
#I     "gp-256-SP-Rel-i"      "B2-4-SP-i"            "G2-SP-Rel-i"
#I    3-groups:
#I     "3gp-SP-Rel-i"         "3gp-SP-1-Rel-i"       "3gp-SP-2-Rel-i"
#I     "3gp-SP-3-Rel-i"       "3gp-SP-4-Rel-i"       "G3-SP-Rel-i"
#I    5-groups:
#I     "5gp-SP-Rel-i"         "5gp-SP-a-Rel-i"       "5gp-SP-b-Rel-i"
#I     "5gp-SP-big-Rel-i"     "5gp-SP-d-Rel-i"       "G5-SP-Rel-i"
#I     "G5-SP-a-Rel-i"        "Nott-SP-Rel-i"
#I    7-groups:
#I     "7gp-SP-Rel-i"         "7gp-SP-a-Rel-i"       "7gp-SP-b-Rel-i"
#I    11-groups:
#I     "11gp-SP-a-i"          "11gp-SP-a-Rel-i"      "11gp-SP-a-Rel-1-i"
#I     "11gp-SP-b-i"          "11gp-SP-b-Rel-i"      "11gp-SP-c-Rel-i"
#I  
#I  Notes
#I  -----
#I  1. The example (first) argument of  `PqExample'  is  a  string;  each
#I     example above is in double quotes to remind you to include them.
#I  2. Some examples accept options. To find  out  whether  a  particular
#I     example accepts options, display it first (by including  `Display'
#I     as  last  argument)  which  will  also  indicate  how  `PqExample'
#I     interprets the options, e.g. `PqExample("11gp-SP-a-i", Display);'.
#I  3. Try `SetInfoLevel(InfoANUPQ, <n>);' for  some  <n>  in  [2  ..  4]
#I     before calling PqExample, to see what's going on behind the scenes.
#I

If on your terminal you are unable to scroll back, an alternative to typing PqExample(); to see the displayed examples is to use on-line help, i.e.  you may type:

gap> ?anupq:examples

which will display this appendix in a GAP session. If you are not fussed about the order in which the examples are organised, AllPqExamples(); lists the available examples relatively compactly (see AllPqExamples (3.4-5)).

In the remainder of this appendix we will discuss particular aspects related to the Relators (see 6.2) and Identities (see 6.2) options, and the construction of the Burnside group \(B(5, 4)\).

A.1 The Relators Option

The Relators option was included because computations involving words containing commutators that are pre-expanded by GAP before being passed to the pq program may run considerably more slowly, than the same computations being run with GAP pre-expansions avoided. The following examples demonstrate a case where the performance hit due to pre-expansion of commutators by GAP is a factor of order 100 (in order to see timing information from the pq program, we set the InfoANUPQ level to 2).

Firstly, we run the example that allows pre-expansion of commutators (the function PqLeftNormComm is provided by the ANUPQ package; see PqLeftNormComm (3.4-1)). Note that since the two commutators of this example are very long (taking more than an page to print), we have edited the output at this point.

gap> SetInfoLevel(InfoANUPQ, 2); #to see timing information
gap> PqExample("11gp-i");
#I  #Example: "11gp-i" . . . based on: examples/11gp
#I  F, a, b, c, R, procId are local to `PqExample'
gap> F := FreeGroup("a", "b", "c"); a := F.1; b := F.2; c := F.3;
<free group on the generators [ a, b, c ]>
a
b
c
gap> R := [PqLeftNormComm([b, a, a, b, c])^11, 
>          PqLeftNormComm([a, b, b, a, b, c])^11, (a * b)^11];;
gap> procId := PqStart(F/R : Prime := 11);;
gap> PqPcPresentation(procId : ClassBound := 7, 
>                              OutputLevel := 1);
#I  Lower exponent-11 central series for [grp]
#I  Group: [grp] to lower exponent-11 central class 1 has order 11^3
#I  Group: [grp] to lower exponent-11 central class 2 has order 11^8
#I  Group: [grp] to lower exponent-11 central class 3 has order 11^19
#I  Group: [grp] to lower exponent-11 central class 4 has order 11^42
#I  Group: [grp] to lower exponent-11 central class 5 has order 11^98
#I  Group: [grp] to lower exponent-11 central class 6 has order 11^228
#I  Group: [grp] to lower exponent-11 central class 7 has order 11^563
#I  Computation of presentation took 27.04 seconds
gap> PqSavePcPresentation(procId, ANUPQData.outfile);
#I  Variables used in `PqExample' are saved in `ANUPQData.example.vars'.

Now we do the same calculation using the Relators option. In this way, the commutators are passed directly as strings to the pq program, so that GAP does not see them and pre-expand them.

gap> PqExample("11gp-Rel-i");
#I  #Example: "11gp-Rel-i" . . . based on: examples/11gp
#I  #(equivalent to "11gp-i" example but uses `Relators' option)
#I  F, rels, procId are local to `PqExample'
gap> F := FreeGroup("a", "b", "c");
<free group on the generators [ a, b, c ]>
gap> rels := ["[b, a, a, b, c]^11", "[a, b, b, a, b, c]^11", "(a * b)^11"];
[ "[b, a, a, b, c]^11", "[a, b, b, a, b, c]^11", "(a * b)^11" ]
gap> procId := PqStart(F : Prime := 11, Relators := rels);;
gap> PqPcPresentation(procId : ClassBound := 7, 
>                              OutputLevel := 1);
#I  Relators parsed ok.
#I  Lower exponent-11 central series for [grp]
#I  Group: [grp] to lower exponent-11 central class 1 has order 11^3
#I  Group: [grp] to lower exponent-11 central class 2 has order 11^8
#I  Group: [grp] to lower exponent-11 central class 3 has order 11^19
#I  Group: [grp] to lower exponent-11 central class 4 has order 11^42
#I  Group: [grp] to lower exponent-11 central class 5 has order 11^98
#I  Group: [grp] to lower exponent-11 central class 6 has order 11^228
#I  Group: [grp] to lower exponent-11 central class 7 has order 11^563
#I  Computation of presentation took 0.27 seconds
gap> PqSavePcPresentation(procId, ANUPQData.outfile);
#I  Variables used in `PqExample' are saved in `ANUPQData.example.vars'.

A.2 The Identities Option and PqEvaluateIdentities Function

Please pay heed to the warnings given for the Identities option (see 6.2); it is written mainly at the GAP level and is not particularly optimised. The Identities option allows one to compute \(p\)-quotients that satisfy an identity. A trivial example better done using the Exponent option, but which nevertheless demonstrates the usage of the Identities option, is as follows:

gap> SetInfoLevel(InfoANUPQ, 1);
gap> PqExample("B2-4-Id");
#I  #Example: "B2-4-Id" . . . alternative way to generate B(2, 4)
#I  #Generates B(2, 4) by using the `Identities' option
#I  #... this is not as efficient as using `Exponent' but
#I  #demonstrates the usage of the `Identities' option.
#I  F, f, procId are local to `PqExample'
gap> F := FreeGroup("a", "b");
<free group on the generators [ a, b ]>
gap> # All words w in the pc generators of B(2, 4) satisfy f(w) = 1 
gap> f := w -> w^4;
function( w ) ... end
gap> Pq( F : Prime := 2, Identities := [ f ] );
#I  Class 1 with 2 generators.
#I  Class 2 with 5 generators.
#I  Class 3 with 7 generators.
#I  Class 4 with 10 generators.
#I  Class 5 with 12 generators.
#I  Class 5 with 12 generators.
<pc group of size 4096 with 12 generators>
#I  Variables used in `PqExample' are saved in `ANUPQData.example.vars'.
gap> time; 
1400

Note that the time statement gives the time in milliseconds spent by GAP in executing the PqExample("B2-4-Id"); command (i.e. everything up to the Info-ing of the variables used), but over 90% of that time is spent in the final Pq statement. The time spent by the pq program, which is negligible anyway (you can check this by running the example while the InfoANUPQ level is set to 2), is not counted by time.

Since the identity used in the above construction of \(B(2, 4)\) is just an exponent law, the right way to compute it is via the Exponent option (see 6.2), which is implemented at the C level and is highly optimised. Consequently, the Exponent option is significantly faster, generally by several orders of magnitude:

gap> SetInfoLevel(InfoANUPQ, 2); # to see time spent by the `pq' program
gap> PqExample("B2-4");
#I  #Example: "B2-4" . . . the ``right'' way to generate B(2, 4)
#I  #Generates B(2, 4) by using the `Exponent' option
#I  F, procId are local to `PqExample'
gap> F := FreeGroup("a", "b");
<free group on the generators [ a, b ]>
gap> Pq( F : Prime := 2, Exponent := 4 );
#I  Computation of presentation took 0.00 seconds
<pc group of size 4096 with 12 generators>
#I  Variables used in `PqExample' are saved in `ANUPQData.example.vars'.
gap> time; # time spent by GAP in executing `PqExample("B2-4");' 
50

The following example uses the Identities option to compute a 3-Engel group for the prime 11. As is the case for the example "B2-4-Id", the example has both a non-interactive and an interactive form; below, we demonstrate the interactive form.

gap> SetInfoLevel(InfoANUPQ, 1); # reset InfoANUPQ to default level
gap> PqExample("11gp-3-Engel-Id", PqStart);
#I  #Example: "11gp-3-Engel-Id" . . . 3-Engel group for prime 11
#I  #Non-trivial example of using the `Identities' option
#I  F, a, b, G, f, procId, Q are local to `PqExample'
gap> F := FreeGroup("a", "b"); a := F.1; b := F.2;
<free group on the generators [ a, b ]>
a
b
gap> G := F/[ a^11, b^11 ];
<fp group on the generators [ a, b ]>
gap> # All word pairs u, v in the pc generators of the 11-quotient Q of G 
gap> # must satisfy the Engel identity: [u, v, v, v] = 1.
gap> f := function(u, v) return PqLeftNormComm( [u, v, v, v] ); end;
function( u, v ) ... end
gap> procId := PqStart( G );;
gap> Q := Pq( procId : Prime := 11, Identities := [ f ] );
#I  Class 1 with 2 generators.
#I  Class 2 with 3 generators.
#I  Class 3 with 5 generators.
#I  Class 3 with 5 generators.
<pc group of size 161051 with 5 generators>
gap> # We do a ``sample'' check that pairs of elements of Q do satisfy
gap> # the given identity:
gap> f( Random(Q), Random(Q) );
<identity> of ...
gap> f( Q.1, Q.2 );
<identity> of ...
#I  Variables used in `PqExample' are saved in `ANUPQData.example.vars'.

The (interactive) call to Pq above is essentially equivalent to a call to PqPcPresentation with the same arguments and options followed by a call to PqCurrentGroup. Moreover, the call to PqPcPresentation (as described in PqPcPresentation (5.6-1)) is equivalent to a class 1 call to PqPcPresentation followed by the requisite number of calls to PqNextClass, and with the Identities option set, both PqPcPresentation and PqNextClass quietly perform the equivalent of a PqEvaluateIdentities call. In the following example we break down the Pq call into its low-level equivalents, and set and unset the Identities option to show where PqEvaluateIdentities fits into this scheme.

gap> PqExample("11gp-3-Engel-Id-i");
#I  #Example: "11gp-3-Engel-Id-i" . . . 3-Engel grp for prime 11
#I  #Variation of "11gp-3-Engel-Id" broken down into its lower-level component
#I  #command parts.
#I  F, a, b, G, f, procId, Q are local to `PqExample'
gap> F := FreeGroup("a", "b"); a := F.1; b := F.2;
<free group on the generators [ a, b ]>
a
b
gap> G := F/[ a^11, b^11 ];
<fp group on the generators [ a, b ]>
gap> # All word pairs u, v in the pc generators of the 11-quotient Q of G 
gap> # must satisfy the Engel identity: [u, v, v, v] = 1.
gap> f := function(u, v) return PqLeftNormComm( [u, v, v, v] ); end;
function( u, v ) ... end
gap> procId := PqStart( G : Prime := 11 );;
gap> PqPcPresentation( procId : ClassBound := 1);
gap> PqEvaluateIdentities( procId : Identities := [f] );
#I  Class 1 with 2 generators.
gap> for c in [2 .. 4] do
>      PqNextClass( procId : Identities := [] ); #reset `Identities' option
>      PqEvaluateIdentities( procId : Identities := [f] );
>    od;
#I  Class 2 with 3 generators.
#I  Class 3 with 5 generators.
#I  Class 3 with 5 generators.
gap> Q := PqCurrentGroup( procId );
<pc group of size 161051 with 5 generators>
gap> # We do a ``sample'' check that pairs of elements of Q do satisfy
gap> # the given identity:
gap> f( Random(Q), Random(Q) );
<identity> of ...
gap> f( Q.1, Q.2 );
<identity> of ...
#I  Variables used in `PqExample' are saved in `ANUPQData.example.vars'.

A.3 A Large Example

An example demonstrating how a large computation can be organised with the ANUPQ package is the computation of the Burnside group \(B(5, 4)\), the largest group of exponent 4 generated by 5 elements. It has order \(2^{2728}\) and lower exponent-\(p\) central class 13. The example "B5-4.g" computes \(B(5, 4)\); it is based on a pq standalone input file written by M. F. Newman.

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 GAP.

Please note that the construction uses the knowledge gained by Newman and O'Brien in their initial construction of \(B(5, 4)\), in particular, insight into the commutator structure of the group and the knowledge of the \(p\)-central class and the order of \(B(5, 4)\). Therefore, the construction cannot be used to prove that \(B(5, 4)\) 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 examples/B5-4.g.

procId := PqStart( FreeGroup(5) : Exponent := 4, Prime := 2 );
Pq( procId : ClassBound := 2 );
PqSupplyAutomorphisms( procId,
      [
        [ [ 1, 1, 0, 0, 0],      # first automorphism
          [ 0, 1, 0, 0, 0],
          [ 0, 0, 1, 0, 0],
          [ 0, 0, 0, 1, 0],
          [ 0, 0, 0, 0, 1] ],

        [ [ 0, 0, 0, 0, 1],      # second automorphism
          [ 1, 0, 0, 0, 0],
          [ 0, 1, 0, 0, 0],
          [ 0, 0, 1, 0, 0],
          [ 0, 0, 0, 1, 0] ]
                             ] );;

Relations :=
  [ [],          ## class 1
    [],          ## class 2
    [],          ## class 3
    [],          ## class 4
    [],          ## class 5
    [],          ## class 6
    ## class 7     
    [ [ "x2","x1","x1","x3","x4","x4","x4" ] ],
    ## class 8
    [ [ "x2","x1","x1","x3","x4","x5","x5","x5" ] ],
    ## class 9
    [ [ "x2","x1","x1","x3","x4","x4","x5","x5","x5" ],
      [ "x2","x1","x1","x2","x3","x4","x5","x5","x5" ],
      [ "x2","x1","x1","x3","x3","x4","x5","x5","x5" ] ],
    ## class 10
    [ [ "x2","x1","x1","x2","x3","x3","x4","x5","x5","x5" ],
      [ "x2","x1","x1","x3","x3","x4","x4","x5","x5","x5" ] ],
    ## class 11
    [ [ "x2","x1","x1","x2","x3","x3","x4","x4","x5","x5","x5" ],
      [ "x2","x1","x1","x2","x3","x1","x3","x4","x2","x4","x3" ] ],
    ## class 12
    [ [ "x2","x1","x1","x2","x3","x1","x3","x4","x2","x5","x5","x5" ],
      [ "x2","x1","x1","x3","x2","x4","x3","x5","x4","x5","x5","x5" ] ],
    ## class 13
    [ [ "x2","x1","x1","x2","x3","x1","x3","x4","x2","x4","x5","x5","x5" 
        ] ]
];

for class in [ 3 .. 13 ] do
    Print( "Computing class ", class, "\n" );
    PqSetupTablesForNextClass( procId );

    for w in [ class, class-1 .. 7 ] do

        PqAddTails( procId, w );   
        PqDisplayPcPresentation( procId );

        if Relations[ w ] <> [] then
            # recalculate automorphisms
            PqExtendAutomorphisms( procId );

            for r in Relations[ w ] do
                Print( "Collecting ", r, "\n" );
                PqCommutator( procId, r, 1 );
                PqEchelonise( procId );
                PqApplyAutomorphisms( procId, 15 ); #queue factor = 15
            od;

            PqEliminateRedundantGenerators( procId );
        fi;   
        PqComputeTails( procId, w );
    od;
    PqDisplayPcPresentation( procId );

    smallclass := Minimum( class, 6 );
    for w in [ smallclass, smallclass-1 .. 2 ] do
        PqTails( procId, w );
    od;
    # recalculate automorphisms
    PqExtendAutomorphisms( procId );
    PqCollect( procId, "x5^4" );
    PqEchelonise( procId );
    PqApplyAutomorphisms( procId, 15 ); #queue factor = 15
    PqEliminateRedundantGenerators( procId );
    PqDisplayPcPresentation( procId );
od;

A.4 Developing descendants trees

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 \(p\)-group generation machinery of the package. We start with the elementary abelian 3-group of rank 2. From within GAP, run the example "PqDescendants-treetraverse-i" via PqExample (see PqExample (3.4-4)).

gap> G := ElementaryAbelianGroup( 9 );
<pc group of size 9 with 2 generators>
gap> procId := PqStart( G );;
gap> #
gap> #  Below, we use the option StepSize in order to construct descendants
gap> #  of coclass 1. This is equivalent to setting the StepSize to 1 in
gap> #  each descendant calculation.
gap> #
gap> #  The elementary abelian group of order 9 has 3 descendants of
gap> #  3-class 2 and 3-coclass 1, as the result of the next command
gap> #  shows. 
gap> #
gap> PqDescendants( procId : StepSize := 1 );
[ <pc group of size 27 with 3 generators>, 
  <pc group of size 27 with 3 generators>, 
  <pc group of size 27 with 3 generators> ]
gap> #
gap> #  Now we will compute the descendants of coclass 1 for each of the
gap> #  groups above. Then we will compute the descendants  of coclass 1
gap> #  of each descendant and so  on.  Note  that the  pq program keeps
gap> #  one file for each class at a time.  For example, the descendants
gap> #  calculation for  the  second  group  of class  2  overwrites the
gap> #  descendant file  obtained  from  the  first  group  of  class 2.
gap> #  Hence,  we have to traverse the descendants tree  in depth first
gap> #  order.
gap> #
gap> PqPGSetDescendantToPcp( procId, 2, 1 );
gap> PqPGExtendAutomorphisms( procId );
gap> PqPGConstructDescendants( procId : StepSize := 1 );
2
gap> PqPGSetDescendantToPcp( procId, 3, 1 );
gap> PqPGExtendAutomorphisms( procId );
gap> PqPGConstructDescendants( procId : StepSize := 1 );
2
gap> PqPGSetDescendantToPcp( procId, 4, 1 );
gap> PqPGExtendAutomorphisms( procId );
gap> PqPGConstructDescendants( procId : StepSize := 1 );
2
gap> #
gap> #  At this point we stop traversing the ``left most'' branch of the
gap> #  descendants tree and move upwards.
gap> #
gap> PqPGSetDescendantToPcp( procId, 4, 2 );
gap> PqPGExtendAutomorphisms( procId );
gap> PqPGConstructDescendants( procId : StepSize := 1 );
#I  group restored from file is incapable
0
gap> PqPGSetDescendantToPcp( procId, 3, 2 );
gap> PqPGExtendAutomorphisms( procId );
gap> PqPGConstructDescendants( procId : StepSize := 1 );
#I  group restored from file is incapable
0
gap> #  
gap> #  The computations above indicate that the descendants subtree under
gap> #  the first descendant of the elementary abelian group of order 9
gap> #  will have only one path of infinite length.
gap> #
gap> PqPGSetDescendantToPcp( procId, 2, 2 );
gap> PqPGExtendAutomorphisms( procId );
gap> PqPGConstructDescendants( procId : StepSize := 1 );
4
gap> #
gap> #  We get four descendants here, three of which will turn out to be
gap> #  incapable, i.e., they have no descendants and are terminal nodes
gap> #  in the descendants tree.
gap> #
gap> PqPGSetDescendantToPcp( procId, 2, 3 );
gap> PqPGExtendAutomorphisms( procId );
gap> PqPGConstructDescendants( procId : StepSize := 1 );
#I  group restored from file is incapable
0
gap> #
gap> #  The third descendant of class three is incapable.  Let us return
gap> #  to the second descendant of class 2.
gap> #
gap> PqPGSetDescendantToPcp( procId, 2, 2 );
gap> PqPGExtendAutomorphisms( procId );
gap> PqPGConstructDescendants( procId : StepSize := 1 );
4
gap> PqPGSetDescendantToPcp( procId, 3, 1 );
gap> PqPGExtendAutomorphisms( procId );
gap> PqPGConstructDescendants( procId : StepSize := 1 );
#I  group restored from file is incapable
0
gap> PqPGSetDescendantToPcp( procId, 3, 2 );
gap> PqPGExtendAutomorphisms( procId );
gap> PqPGConstructDescendants( procId : StepSize := 1 );
#I  group restored from file is incapable
0
gap> #
gap> #  We skip the third descendant for the moment ... 
gap> #
gap> PqPGSetDescendantToPcp( procId, 3, 4 );
gap> PqPGExtendAutomorphisms( procId );
gap> PqPGConstructDescendants( procId : StepSize := 1 );
#I  group restored from file is incapable
0
gap> #
gap> #  ... and look at it now.
gap> #
gap> PqPGSetDescendantToPcp( procId, 3, 3 );
gap> PqPGExtendAutomorphisms( procId );
gap> PqPGConstructDescendants( procId : StepSize := 1 );
6
gap> #
gap> #  In this branch of the descendant tree we get 6 descendants of class
gap> #  three.  Of those 5 will turn out to be incapable and one will have
gap> #  7 descendants.
gap> #
gap> PqPGSetDescendantToPcp( procId, 4, 1 );
gap> PqPGExtendAutomorphisms( procId );
gap> PqPGConstructDescendants( procId : StepSize := 1 );
#I  group restored from file is incapable
0
gap> PqPGSetDescendantToPcp( procId, 4, 2 );
gap> PqPGExtendAutomorphisms( procId );
gap> PqPGConstructDescendants( procId : StepSize := 1 );
7
gap> PqPGSetDescendantToPcp( procId, 4, 3 );
gap> PqPGExtendAutomorphisms( procId );
gap> PqPGConstructDescendants( procId : StepSize := 1 );
#I  group restored from file is incapable
0

To automate the above procedure to some extent we provide:

A.4-1 PqDescendantsTreeCoclassOne
‣ PqDescendantsTreeCoclassOne( i )( function )
‣ PqDescendantsTreeCoclassOne( )( function )

for the ith or default interactive ANUPQ process, generate a descendant tree for the group of the process (which must be a pc \(p\)-group) consisting of descendants of \(p\)-coclass 1 and extending to the class determined by the option TreeDepth (or 6 if the option is omitted). In an XGAP session, a graphical representation of the descendants tree appears in a separate window. Subsequent calls to PqDescendantsTreeCoclassOne for the same process may be used to extend the descendant tree from the last descendant computed that itself has more than one descendant. PqDescendantsTreeCoclassOne also accepts the options CapableDescendants (or AllDescendants) and any options accepted by the interactive PqDescendants function (see PqDescendants (5.3-6)).

Notes

  1. PqDescendantsTreeCoclassOne first calls PqDescendants. If PqDescendants has already been called for the process, the previous value computed is used and a warning is Info-ed at InfoANUPQ level 1.

  2. As each descendant is processed its unique label defined by the pq program and number of descendants is Info-ed at InfoANUPQ level 1.

  3. PqDescendantsTreeCoclassOne is an experimental function that is included to demonstrate the sort of things that are possible with the \(p\)-group generation machinery.

Ignoring the extra functionality provided in an XGAP session, PqDescendantsTreeCoclassOne, with one argument that is the index of an interactive ANUPQ process, is approximately equivalent to:

PqDescendantsTreeCoclassOne := function( procId )
    local des, i;

    des := PqDescendants( procId : StepSize := 1 );
    RecurseDescendants( procId, 2, Length(des) );
end;

where RecurseDescendants is (approximately) defined as follows:

RecurseDescendants := function( procId, class, n )
    local i, nr;

    if class > ValueOption("TreeDepth") then return; fi;

    for i in [1..n] do
        PqPGSetDescendantToPcp( procId, class, i );
        PqPGExtendAutomorphisms( procId );
        nr := PqPGConstructDescendants( procId : StepSize := 1 );
        Print( "Number of descendants of group ", i,
               " at class ", class, ": ", nr, "\n" );
        RecurseDescendants( procId, class+1, nr );
    od;
    return;
end;

The following examples (executed via PqExample; see PqExample (3.4-4)), demonstrate the use of PqDescendantsTreeCoclassOne:

"PqDescendantsTreeCoclassOne-9-i"

approximately does example "PqDescendants-treetraverse-i" again using PqDescendantsTreeCoclassOne;

"PqDescendantsTreeCoclassOne-16-i"

uses the option CapableDescendants; and

"PqDescendantsTreeCoclassOne-25-i"

calculates all descendants by omitting the CapableDescendants option.

The numbers 9, 16 and 25 respectively, indicate the order of the elementary abelian group to which PqDescendantsTreeCoclassOne is applied for these examples.

 [Top of Book]  [Contents]   [Previous Chapter]   [Next Chapter] 
Goto Chapter: Top 1 2 3 4 5 6 7 A Bib Ind

generated by GAPDoc2HTML

anupq-3.3.3/doc/lefttoc.css0000644000175100017510000000047415111342310015165 0ustar runnerrunner/* leftmenu.css Frank Lübeck */ /* Change default CSS to show section menu on left side */ body { padding-left: 28%; } body.chap0 { padding-left: 2%; } div.ChapSects div.ContSect:hover div.ContSSBlock { left: 15%; } div.ChapSects { left: 1%; width: 25%; } anupq-3.3.3/doc/manual.pdf0000644000175100017510000156050015111342310014765 0ustar runnerrunner%PDF-1.5 % 190 0 obj << /Length 579 /Filter /FlateDecode >> stream xڭTMo@W [/ޞJ4 YҨ6?_#Z.h p BGlpEm HyH06|MNd8K{uSkW"M&d yD3 ڀf ${tju@sʘkS|Kd(bAA,*0Yظ21ȷ튾l}{3M&Y^E}q1 /CbOIbK#9%U-<[5>n-wD( e&W/:lqe@jaݗUuGۍ*^5%"*& Onƅ@ku\CV (jZOC  f9CSXJM[A6ay-Țc+]8)')m XP endstream endobj 2 0 obj << /Type /ObjStm /N 100 /First 836 /Length 2125 /Filter /FlateDecode >> stream xZr8+LfHij'v*ݝy%^#"H,@AAiI8{=^IIBI" M(1)Q$R$ոDp*1Fք YB$ 1)FiRb N`CCp8jB%~G)F8\sa3C8@pSa8H#  KQqDjpTBL8%p**Ri@}P# H pk#.@g $'\+S\9jς*5 K\Yv\/A sD *GC2aIU8 MHQځ2RKt6rHuC!tԞpKf3HI!2F'P¤J)ZSX C,-A4( Q5RK*QX6e&)D3̂jCUᐕB7#,GbؤF5n8+ ԁ0>l'V.cW zr)Z7::"9OW%G㫬jeD~=z*?6ISilMimV_gqIYYD4|M|t&L_kۼMx‖wEr@KX_·]Ǯ{t<;{ }\w˅;kGzfƸehSw`'*vZ6yJ2?~{zO]!kqWQhw4/thS^ؿjϗ4TL/\><kʟM!c/~dΜdT@sg ,/Kkf%bz)6P!.y>C~5AW.]Yx**ߍ򝟛jUgu6Mf[K@E40?Wx+/?-;0έ[mͻ[ qݷW M#ٳG4s% 6vGs12P1@Io0L ߑR}6>_-l_K_N+\*| 3ԟkzښ~2e+jhӥwƍFjb i6N>t,-Ődpnώ(;E 7ht &#  ^}q8]e!^#'ܞsO4B^`yhZX\gnog`t%{b{;F?yB7r/໹> W;-P>x[L &~soB`( v P <+؟Wϝwg\J< (UU^Lfn?ko`8͍.CgKZotA/!<J } e[K}Ne"#/-5[/m{ko9my_U!Oy`i_r?9CY1~敐32k.Qse6Gh 5}ruZs˭,{Z~"o3ˆ)I46#XZaW EQeֻl}4zT___zaqii&HEGkŢ$c&}||tvg"͛U,,fMǀt*.XDUK)!鞨鬹Z]FrOU6~ 8+VՇxV׫>-e2踎Ra?nM2zp+Uì8Մ1Ɂ:Re> stream xڭMO0 l7qC0 1PluOteECC$z"0Fipz$`5H>+`4 K&|L/O/Bazu %ythl͝XIK͍8FDV>}[r[a5&!b>0bFV/6-MtQ f"iq\!AקU޸@Dc~hPiy]OKHh\OPd(Cgo_^24a}v̽-ff<a`wlǼ\UszrsrW|wbP O) uq]°ޔM9W޷ }> stream xZMSH+tbgtdaI8*ɤwlK#` %~uK=x:8:>C$CopqPL=FX#BfEog(%s$A3``cP_̖ ݃WHTP#Bs2t CPRm$y+zR%u+}r?02J`V]QhZ_"GPe4*&F4#/B2$aAAZ<J EY[fQ,S \ %iBa! VQ ME:b+ ^ I*# )C>o nWI9i'CLʹE.r_flhQ3f ns23&+BA0lKR(0̫;OMJ~*k+{ާ47aO{tb׋e&u4Þ_ #]ᅖI r*=1^%_E-n>&tn ΄ H v-nttӹjHmb(!ڣ*`'UGE@,O%ҳc؞eIA5v?GmTDRKgpqG-b3b.d}%bAi»KJ| Ϩ]:N}o%kw9!d4/mnY=[Om>E=i!uT5BFäqdxiB:P;kEf2W2Lg;j6!qXLsYя%BrcK`4kö֎A۴{Hۺii;G4PQdT#LUH&:΄5"Ng#( de2u[+P/ 1t.C֧dĩh[ąӨlBtO*@ = -ʚ0lM4FuoB?8>f{Q'SaD/yᓯ 5,./o_Xi5y.8cr`֭NV{8؋:V4Z>vt. Db ]F [83&&*;K4ƻR _\Z=Ke6BZL&ˣVZ=@pnj(j2|;? ,9Tij4$I_ MuF־iXPg&b{"&a F5vIDdt7c(FM _ < 1M-,6Z. py2ЙTgJveXz P7\inϽcl~8IVRF/4;Տ@[yϟj endstream endobj 263 0 obj << /Length 646 /Filter /FlateDecode >> stream xX]o }ϯ? \xu.=f\:NفITvJ*\s9.h(|'J! (C J@dD3 ߮F߳'QӔ4x;f@CrJ(?!8hy7t1O%P YϺLs644N_fu^}KY-IR)q.<rJ k#&s%_h$E6ق-R湳ha;&== ;ʃPO_BȠ?JtXY.GB.ݼ6EaPr1$ ^_dPlzRcq0(R H^n1Z8TrZ[1>4ܹ)Jw@foxQPFgvVnSF-W!&^uv(d6/)t(THvu-/'ymUІ\ݝݷ)Sn|J ޾;=;C'SELi?A$Gfݹ<]޺(gmms:lW9G.wu{NPtdgn].>< ,؋ endstream endobj 270 0 obj << /Length 2114 /Filter /FlateDecode >> stream xڭYKsFWj97ݓȎ*7@@33= A0h]Vt ׷wo~|DkVwX%J+FOWwYo[o(V?xI,SȔ$L U׬YSuN[&oU \QJ߾@uZ繤x(Ii}BD*%cuDn>!єDsz#xMhvLeBJͯ|[ɉU ;6)0k(TFEz6,W]_!(XD0ILY/˒D%7w9sSt]^'\5r^mUDj0ABF)@Myt0E̥ )NC) 0}kfk"S'p.X* A~?U?MFޔ%4K%r!}uc< *IOF}qTi {}A]I }'P@LXs7/areLlnP_[s/A~#V)靬Q) 'K{cʳi"A#0q$8hhNm!,+f*2S[*n/"Tz,v<Hcr4/rȞ9=E7ޡo3@ɡi5>q_א: 6r1朊>~EkKa6% vq P;T+~۽ *<Uu &-\bA~ìa ״zhVRR.7[$M-061IpFlDC[Ȱ5M"F9$7a|ѸYBEd+NF! 0 SYBX`4~t2B!\1:QED"!9Ѝ[H+!n\ڤp,*8 vQ]hzտ욎Sy6eLQ'B+Pf8 NFpgX"z}s} /vo.P-'įJHrA%_lJV9(@S+&p x>5 K-uk1@e/$j#fs 9:9`1}2ؙven~p筧2`㕾4pۛ͡~] CfR)5FJ9J5{ endstream endobj 294 0 obj << /Length 2970 /Filter /FlateDecode >> stream xڵZY6~Л*xqlCU(HZ"̿nt%jaJ41b]Wo^}C-0OE,di/$ (^ܭ?t09V*Աܺ׼&0MnDӢUa7*ʂngiLnPyX2)-o\evf7W:[۴В+4DqT>=Kr3VM[Z P)9X.F&";C?E]L~1E_ 5 + _ѷ@jM[߸["͡}}x=\r)upt`[̪)톚kMyʺzCKYޫSftt#m45u,|* C#UXu*j6M 6}7~9+<,]^A3>SiL5csY5ȔKy<SVkH0=eb͒$Q*Jngq A&~vW5}圁>قHN̙Wlc@`Y\sWN`䛯mg=OCgfM^\T,giyD ִiK*$2ilf.qфix]˛X Ԋ9GkIB|40M&(C>I^1 S=D:.>* `_<`"xSͥ@9Ң8LzۘFym{ 2@cD1jOx%p- |δݿ甌P*k׭COUDi|0`\hMd@e'OUQ+N9ڢC5rF<8U&ClˡbݺnxIh8(AxQϹ}`t}'L<Gl>,z$~!yR1O0R$]|^G:q:0*K9@Qʺ`n6*k$Gpyխ%tkYyvt.x7GHA!ہ&LMvFG=r|tѐƠˁr02Whʒ0JgФgi29D4>RXq90\dg$E(пA}9{ DlAsLeʛu]mEaJ.u0b5!C @"upinkiW0_x-$z…&/C%Ǐܱ7<͑oES@QD4iO 2B=8vww<>d.rߒrGWRHF%0lL~Rg!(O@pZw9*]h6(%%h{a TFUGa2h)ơǢܗpJ= K2{S;j_"e-I;eȡBFǣ/;rɩE<=5Q 2UW{K~,!S+'ʤ$u7ZjRuO]Q҅ |)F31M|˖g'QÕ[j&aK֍sAϞ4uzo> stream xڵ˒۸- 'Z;Ny]$UPD"ed>h"eh4x3@C|Y'=~$^HXz(`Jf]|ZJ#yO8 m_M5KD|K~ˇmˇkDfEs9 .8MiU&UM[;x,kӴUsTFFöiTxQmIU]hS]I}&rrrM3/j?T۽]{,%+d Gơ/W4yijz/ N/n_pLvLٛ_<&rB3#$g&Ffӵ.Fy0U馊v)(|6D]{l=HDAƛ>^ mdek\@6,NA̾&شVr u2 H#pSW L0]Yݷs(q@f60ݕN%(krViV8L~pOMmz[u7y/[$6dw20*sҷaJ<-rWޚЁ@d0OD>4s,#)),eʙlsI?J$ ' -Ey}ׄ3-7J4 [~ONYכ'ÂHj9"K98xx:L1Г/ q&;1$B&%bcEwylb4Q+ۖFy0!,+C6MTd|<|wn}A ( T&AVR8Ixbχb2LV`ڭm;ִ^lfgWmMM蔡&?~tdC=xwϢ:)HϜeǘ0KJT B)x@N%8b $/+(C5^nϚYJšc a<"m6o;O\7A*s.0($Pa>šJIDeX%Bj5b_ .ͽS[[ށ6C>ѹ/TCD(.tPf|ҧ>a4zy&KO+YNɯ.95P+;PA#^<(k{cUF3cͰu]),`Kh@euP$S~̄e  H J}f5өZL~Z pSPb`qvB GJ'SZ>\+L%`K0 ro &b_EL 3,0pX| !V͸ljTJ/aps.]7Bu%4!H|Ɠ'!ޅ(ƥ|e%ʩSX" TАg2V<7!R1KYe3?b 3CL~1em@2s Vq/[3h"=юyRw\|kKPp ԯ wvf1Hmסc)ԥGxdk 3LdNJz柔t()%'@ 1浯Ž#!KM&u>؄g03&ut~PYE^t&F-J6Jcޖ&yRhwbmd@ ?;16:m)Ž^O;RO8qME͝Drƙ7RjJ?s$ `o2S.v5wiv0-b߁Ā{/psb_I9m mLTwj([ó~Qs_`Y?wnVQ Mr~!ק#](?PksC7/<=z zAX/? A:ZM~)wg>A9!vϳ!2,d#rԉ|zS: 4V8J?5F˾LqCelaQׂѵ`(C]-b1cȚ}wZiU1J[mg |Kָ2ru\w~>A?0_5HWcGUmጾbR>=U3˳m/ #ᆰ" -=Uث: ٻǥ%i6EZ2[u endstream endobj 201 0 obj << /Type /ObjStm /N 100 /First 900 /Length 2564 /Filter /FlateDecode >> stream xڽZko\r@4k[5APC+Hk=å˒2 ܳyj )p@GK 2I0nU)" xH낉Iܑ@N @[ ē.^1 0,g 0 BIʜ r 3(b 2$BA񂅃&&q(%h)(M#BN5AKu! ӂpbڕdIjKxfx5-;8FޥA2YH9.?Қ.Po hqJ-Rڨ\}!m/I-J<}VBSX 'C?U`ToUѺ}Tqcު:JŷR a' RhN|Jh]UCa\+RrCR"P;%)Oi T'$˂ )R w|a58k nSɝB#`8l|& TXGG&s(|):.㉋qqk_g'Mx>{W7wƒVO\'WWuVO\ oRp{ͱϺR-vzÏ/.֐ŗջU.e. 1I]$"lH /M |"//<>:Xm˓_\^e\_.?.~[??zyz9ޜ}?|1} 3 IcBÉb߿}pm{5}|>[gg\Ό+?vƷOMnl0Joi_~ig V, xȐmw(0Rp8!p )jO~hj<Ђ|A#O8aꗷKĎLp1R6!2lE 6?kQgZ؅2?\dC5*0:C7kMh`7ֽ !DjqAUoW0B5C 7V8 [CGL04n>o5_iy\zb&wzbF1{~Nvmu80ދl| ۟ % Fv-&@B%z;G-8, ;0H+_̺%i筡;hc3(Ɗ5T3~~#faEq- Th$]ͪGyyZZn`uTuTuTuTuD}x ڨ4EL r49r.r~Hr{@+X'[dJ_4_M+5ET|N56x&}!SUm A`99El+6X~>FCqd} ٮD(fDT XnO D1W5P 7x^Ad!Cљ|LD'gfn3bܛ랇+"IwJB%WjیeS}Vgie bEEV7S{_?bK|/m>gU|e31n7xy'wjO0?4 xU f6/Z:=%ힷ.}1E?_ endstream endobj 326 0 obj << /Length 3665 /Filter /FlateDecode >> stream x[[w6~ϯT(q%nlvOͦCZmJJRuw/@IvvA3|sq2%_|yZRb҄ήog,5$b*J 7y﫟4фĸќ)ei"+J:[pInл6r_-X*g>[H~n+hj߹fѸ*)IXgV>.*m&MX0)|{UMܯ3Wan Z:m;$cɾb|C7TlA lI]n*ɚ’ =t|hdG$Ovm {0F7Ęl(a>նؽr0 {8a7l2cݗoiEWZ3r3+&a=vz ʭW2f[Ց#*bxh-K<bv"_\ӭ'm|V̏J6&ejʥ*\Kؽ}}iQp/ {oT䮳 G, oѯ-WED!wB |9\ \䢼sӵJU!+znd X( ;}uoȇe^5YW)yݠJAJCi7j/`@@S/qa>̟ΉK.x n\nhx)㲗2uR_߃6vY~ǝհдTtN tFdK|ʰ+TQȦS/@hBI*@Pb ƪ[>I3NrcؒA"QVCh I&e;y/(Չ,tSLGmil޸ KPOO8㛿tLN@}?7͞0 c8聬$cۦFv3DFO.q64bR?ZJ*1FAH&g;I_]HₗԷJƜ:J :'sׂ#bO s|əaZXfbjf3'Pp ?~As-8:@ (;$3O)fa;[/~3΢!h߫^VQ8z^ben7ʍN#{|iA48gaWWɏބ7\B45߲XvrB_Qϻmy2QJ0C4J|tw6 dm9(,%ImI36RQWTպh?U.v1W 01--muE@d؂Z=I=}l}\p㱶O7o} nu ''u: DU4" +TǶk1;:G@J$U#I  p"6EpՖ((}cQCKRz6I0 8}9؟23qsADBu)38Nr@| 2Qn0eDrr#kι"VPMqNѷKֽၶ7y)ʬ;ĖEvH.|cDJ9`ӎ*CN_jO2"A7a4#5`eNS @$ǒ[p#lԼ jE$Onn N*@ #C7^"o˖'w.yVap3ÅE٤ 7۽?2Г:dxdt@}kS̨-uy$[."SDKji6; nx :Rv MQ֒txQpA!yZ/zFݼ׀иlg)B (sNrbZ&1M}8_>c3*"f~$X ++-[?G6/QV{^M#Yxi*HC`{GBpl"@yV(NEx;ҞZqTI<0cu*M%.N-pR]9pP rnVȾ o%D` 6rtT0{}|q/۲ ! N_B Aͤm7~qhwiH18%m8azPcQ\~1ofpTafi1XQƶҜ\J"#Z=NeT@oۄh$Ŷ14e ka3LjvYQ~nW5P s) Gu=*dtIMGy4̡S(>URȀ\OAQ Yf3Y)]4%Ajұ7Gv ~cՕah"0\.uSXtˤ$xCGp"ԣՄS&{9Â7A}=66EY20NFق }:aWMD"@ϰqgv#q{b]-:ɳ K;>> P黉Xaw淕}O3MuUV2q(r7 q $wsr0yN*ȍ8N"=q#qy?ƻ=Qg{7 I%xnJ/=o֫pG8İV#k,p@N~߾4Ɂpr;]p݅7ο(7 f Bf:<87ar׎<':QGP'R"! n9V F]^jCmTu)sRaTS畞!0ʾ5upVH:e#L8Wf6+(lU){l27IPy$蔀 9GA̬WzMΐ@?e3F~˜ rWiu%Qr\!.psR:fu:nu?̓pŁg&6B!vK!q]mh{?|B0n?Œ !8i! GgcZ4'}$s\U8\|ȬlZ7UnֹuX7:/M>ל۰KFjCSUpW'BlNFJ"Scqyڮ{ĤLĠb'UJ_-Ao>jnGnjl#o曩+X:>TMtXlNul 1w( &w2uO9Oj9R{j烽RO &6p%V4caD_mW/f endstream endobj 347 0 obj << /Length 4485 /Filter /FlateDecode >> stream x<ے㶕uŢq#@V9)8)Z"ex~@@L\y!sAܼy׻W.iE S:SB(I3M՗oVꆒLmgsZf9[:'͚Y!s7uUV[5]s"V_ޮaն7U-~1CL_֦4e`d2IU~ܔЕTF4݊|.}xO;Oz*Ԇ_EB)y& uj<|fW޻4e&;Gkˌ|Nq} (ݗ9@]`2͚hha$!_}ˡC[PB<~|YwEEb+&2J.1`,+2"%B)"Q\mݮ&Ѥ3JCyR s6,@HYP 'xy]rbWgݒgSe}ݔ$tWfP2ZQSTÂ*#LΰM,ݰEO_ >M"!ɤ6|XD"S34#eh5Z"|WeqXGb1%@T~Ukoi3`H3`Ug '#WwOUd!x[irq kP\Q "#8g$]E& É9M3*R%JΒ!]scO(hr^L̷P9#EjH OeZuod2*hM نx\ 0PƯ*nzSm) X7Zqt ua dm'A6'@mgUr{lI̒͢Fx+7k;IVܛ%3Qvn~3tA.cɌw;VUwQLlW r6طjpwh7Su趶:8.*E`|b:>T>iϘO>tv v& I+0,ynp^g.T9Arn2†<;ia @4V|."LэbP^ h#p9n0Eba>|c. ck.l*dg)dHJ5>|Sm&r M2יI88#A%PS> (r%gE>G00C q~bdMFctU9V5uI :LR쁲-Op@u9&%& l F?fn6U6ޘM\VŸѾr|aH1L"4⋒hau3;EarvdYb3kJY}Sgu_1V&z]*uq.8_'xN ,cҔl3|P 5؇Ϳ&4Y8JIL/2k(|P+]m9PUX5(5m61 d,`Boi0 4݈ij㜮l~J;ʤ2ə#AE SI,C)')%z!%d IQ3sTG1A_r&|aWKnn2c=hقG\v+ð1eps_ oF1 !!"@u.c|tn|Lй8`~ KS[o*D Y)krPT A_,-lL?Ů=J*:r/4ު @Tʼnr3E-ƨ^=Kb#W~͜ڦ2|kA( $N3~uſ\eDja1>>ާ.b16eFK,.Qdv,<,)_,X w,DgTLs tNh)G %gJ0ǁf: |L`}6S/%)˔o_{]ɗ]xYhž<QpuL;5q+:+gun*}9t֙/kǶ)wunn6-"ln=.$W߷ve{٫=UPm,\}wv 焤ˌƚ?ǦjVce󊬜N%VDeڅMɨd Mr}7!P0&MwN,_ &40 Q\G˝(eBmSϮԾ1l1~CQ36X {%@117 7Y&|{:YnG<Qn&"܈ cwOZ$Xmb6&7o 5W`Tdop^Pe~zs-d9rJtT 3F ]x%4RAy_׮yI s'RɁ*"3!| H]YNSsI^69669U-j*kSϢmx.g8ξ81~vK$].RiwuhU]e8LNT$Ǫoݶr=y+kkǑۏv9v"rXKXwUɄȰcMWf hX=iIi#N&ȸNw9<}XJY6Ku=r Z/eZU(6@E&gMm5Ӭg_ a^^d JDcN+2FtG%Ƀzou.sަ$q{9M~hhА߫r渿JmqK.\-wZKqidJ*rn~oI+P㓭wҰWIKT+=^gEKz0y__рڡ1apY/uͳ|>Q/e}_KUqI )g&,,s~S]h<8ZtA"W~2.vZhm劚 jKo 䉌ϯ^?:۟ endstream endobj 371 0 obj << /Length 3402 /Filter /FlateDecode >> stream xڵZK6Wm5n(Rڪ[)ǛfNj5gZ=:: ^Vۙd\SS|A$~'vo^|si3afDIcBQEjw{}^|^DcQs9H *Rad}Nxf/3m_teChP?IԮ-;?޽_c9M`*j\6%M4Le7yfhN bPǩ˙,x8XhC^6~sͱI4:Lt0QM]&$Mg؃m.DJۇW -:TT}q)ќA*pv[6<2fT݄ʦt7bKJ$*# +pJIIyMs^`9U˻G'K'TA_y.)<ցg/PG-OO-yF!aB:`Uz'Aop0o20bԨ9-UlZ(bx}^ Ց2DY3)X-=GP^/_]ɆrhX-#xɚf?!n,zϔ0,ɑ9)+|יޖ .ҟEfDKϣGc QfǏ #C<#Xtv춯S #*sM"PB%s"+MDyo'\9Hd{hob>kA.^Q`Y+''m%zٌX:E+Bix/̓,}lе䉱Ą Ya8v%:x b*}6Mg\=T&t.R*IDkG:+bLmw4GkB#?^Jv9ӱṢ{EINya<aB mU𡋬&6,$lR聻C ;4B%2xE6{au*␼ zB(9,y}0LgꬃM૫plž)(0(ۮ!<ւoa\ꃻЊM" L:@a3(ˍX]6>\xԇ3qבD2\IjBP;G>qj k- :4^ b-j*#}(_m%* -|u(b X X>̒D.dC2r[|f2UUK5\~km-%0?qkOͩz('Nm T_ S?)=D/e[(luNlfCRcG{Ncim?y\rE>9!q .,ǘ(|?ßSФ¶KK✇ĘK<>%nOl?,ԦmX'xܧqmzjC묮&8R9_~DC^݃Norɩ!'YJ yWb=D=.Nf3/O0@U9. [?/B?qH8TpF]M" ~c^8<|AX=pB'yx2rRO>AL6҃BKϫ8sQ.^6=_΢T8L\'ǞN,Td{j7%K)A*Bx6͑Tg*G[diJ"5`s۵T&!vrك$ ^M>Fy>,SS:j;fx!/;[ cđ1ޘ]0A(פLoEє2:؈M. 휏)$] ǧ!L~k1XHle*[cz#=w>xDxn U{ꬥvnR8JOۆL|{ͥy[y?N2%['byuR8}8ah:~݌ 2 p0]^Ӥe&jh\7 t۞7Ӱ@_?[V/_2G!0hzX@J4≀UXY\|o#Ht\,♞swO{h׻TlﵟOo3qh>;YK$/RP`o^&RB\TE^q6XՂ]?J9ʏ1wEwJmC*2Vq6ss{IպC ٥͡9sؐz;[ h-8շG:.PdΈ?~3G!BN!^lPeC(J|a;"Ep"%g&i4Bѧxݜ;ۤ xz%D$߻x힓RLAs@[8t7YoƪO`|TE4kԡNJ> stream xڭXKT& nw+9$N<9]Hd)j(Oj*h4i|Ui{|R4+wXko_g)wYFi*+eCzJRgjҕTQH"ٵ`7{2H(qe?4ONVMf豯`t{ԓ&:}4jQ5?~"6f}&oJySVSn9beKC!@9(L5 `dzq?L>ۡù糚uV'%OZ8#7 <{$]4nB4Bt?zI_âR4K?u}M:MmojeXd2LzXrKq^ s7vFDȂ(Lp=Sk1H/F';XY2́uV&RK^;m;5+Up!>>)0/kr4b8(Z=Zt?Rn-4+L&UZ=L8} /ߨpzՠMc;y q@@\haJY,-3eK;5"aLzSIwbp^Y[7ST*%\P 52T>-&Mq5%=swz:GYy< q* %ndY cYrɪԷp> stream xڵ]s6ݿR3 ?KM8{yH:%)RGtCbAJhǚJsP;],EE|{fCF!PT\g7zi>rş貛  s?v!P=+s]Y#yg$Awc LGY^rAA]dR_ZEHEc#3X&>b2b\%=/^qvJP0%{ ;GV*}B#0T*".p'78NotGsqsMvyD *aWmLMW(]boBID(-;5:S6t Nh!Pb4\V;<^kNcO`$G'x̕Q,+Ѓu !W9}u;\<'RL/LVՋG9@d< ]oB^;L |1  e)mj_tH*`41. 9Ry8f|;8 e @`@ (:.9"PQ!ȦQRH&'*i62%MF9^kEHj",l6JCeE9̓+mr Pi2SC8re=ޕa'TmfB(WUŽSEz ;+Yԣc+ x%ChŠ$^uѮnY&+C{(MۑY5X8RLE@TzSZȩcJuc* FF+Rh@%7}%Im zIDNq*.P18?Q8tC=7N֡0f"|(FU9 <;)d(hdlM/TOY0͔dtb;|S@hNMDKX$,ڐ_zc+97}Kc?IᗼMV =u]BflR۠ZΰpeCj4L'\ۺM;Y3UU=(~iM0_ME\ } +7mMd`waI=(H^.ܶq-;3v7*N핳еe)I<3-;<ub5 u4 .V=ӸD[r,*{^yzVbw$[ y0EFYFE;z6wxO!"s'Ľ)\bXX ;@ʍG]M(sKzy0K)v4d<׳SIROOpi62RϝiZ{p:yG :%KjUibWtQ: fqc)$A/[|{ XpZ5 LŸޝuU!43?OhB>G{jA[Iܯ;( i.m:}-̡> 6>TxmNGp J4cbfܔ~4߇C6 |%rV'^ۧ d:a̒򿺭ff1!m-ʡ6d Aq"@JR{St@2WZZ՞hP}e(vJ$!c-/wNwNjMtݲnW`}4tʿN\I  :ZCqiJ]bz )Sor?a 4u $ endstream endobj 409 0 obj << /Length 2362 /Filter /FlateDecode >> stream xڭZ[s6~ @هtM6n>Z,N(R!F)[3$s?9 $1e*qL(A,IX,?f~˿n~!FIB;D1Zf saI$EsN"Ƀ⏿hijJDfFo!"t1$K͕QIQby}9\~Үvۼ=eN&m#b+""bXgXLE:'د@E&-&kp]lۼL EƺAM^o:au:2L@JW1 儅.~66˜:t;ߦxڐ׻[WWi~V|iVU@◩*1Vuk͛f"mG,ZE0!` L(Ll- GDFy+¹^?g+slɉTRh]vB .8MD%G:)OB'D$(D':oA)BhZKYĕ5ynf(*OI DW'kgunC%Kֱ;ƄwTvoͶzcxL]hq:`;L*c{ٮ9V'dY<ԕ?|%}jffK4+l dDŽeJ8C(Z_gN>`v坽\f=EZT[ψ ?т99Y3ektPI:fW$󡆻^@Qx^2ǡycES;eӦEp)ԋU; mF~Zy-FehB֋7VF2Zh$謬Z($艴eOK[tG(ƒU k 4/F[iR,͢J*˒yB6V*$߿.ҲݟriשSYU 0-$*C?:AhbigD׫J1sY,6wAdx'`>:yl|e(Y0B=R$noxr UL" }S#lƂ[K7mr]nO*P;|\Vl ܛ$6(Կ`"H =jtG|p6Gt/ܵ)fei @ qvC- mweN#['s# k EH'}#m:$ G˜;l!gsX1/_@ PdJH5Aߴ.?A7}3_=ΗoDE/OG*PU&H!bFC( NB!,|T쒛[ņc֢H'ELξ1XC?{;ޡ+{@}P )  T(;]!TQo$haNX h .CޕSOk 6 >J˭tȒZp KN[6~Us-Ŝ?|߬}'d~D=aUi^GkmX9F{̰p{bmszʁg~Ǯڦz 5SEx6s(mEm]b :2JI?jͶͧ} 6_%^խ3a NBx{ JaZF=o$hN2K;> stream xZYoF~ׯe)f$6, P3"#aE~ר9d =}WWE"\wqHtq}`QDB$bq^|.^]-hH0yHb*a-3 tջw0{D-\XI"ǟ2ABt.}WD񨛑卮U]2|2v6"P87zW;p?m&I)f1b0^~pKʉXLU5 &=w(.%)wwYsiu[Vjw̢)IqѭvuI',p{@qzvR謝V@J+bZ"f;} D;=KU7hn 'GRex[lGg+!x<Ny3Qg $Jw'C~]@T껃BITL$Dh kA6o"ddF:rXÉBpa٘*(rvydicoY:ꢈ8?#Z;Wxc5~&}\%Ay<,y{w]Prr1Ɉ|LVދq“Az<0X]U~ހ3&f`8@brK?C$Y{ +DGO@`w'懬 aZPLw;qkF0@w ; d/iYܬx1FE"c h3SP;!\XNRE=G<8:81:Zdy NJk9# -`/s둕X6m^٠wSmK"A8GnMVeQtD=m 1柱ݘpջ ypbt$ cO^#;<6*Y 4IT[<$Rٞ͹@/N/0Ƌ_HޠάOO7UіG/Gː_Cr;FO s=V46{;^`Ywy/q ?fevWT6Nob au:͛ڻ`L"GJYq)BIb!j WJ=5' $ƌw9\hwEnź>z@%Cl۴.W'+`&`[}nl_J"ߴZA;3pTbAIB$&S?+Uc4TY c߃")Z#1)G:NTmℂH(Y.+Lm61# |`>;%$Hryx6b$ǢbF7Q/4I aqtCe 4ҳU*jr*G18IN.Ku@CWiD EVtDzQjO|ޤD0|m!JĄ(Ddp#&CƸ vvu~ʯ?J㊜@ַHvK-L+eޝl㌥а[SJ])UُVr8Έ&vF?ͳV)kRuV9#C}y&Dj8.g\ )>~^BVW}fI,`jLڰI~{0_`V"Bf C& h* >ۢLa ]PƁnd [잉x\P d> stream xZ[6~_ae5@͈7DmS`-*K$'{i[H }xnwMwo*CyoXF8DSym~燇w>8АP<$JeQNz?y ' N f%Qt?ޗ3'ń|Hse 4 -k'aڗލ0x,{\j:3 򤾧*x6M7'/ >=@!5s#wͶ#s` ),U'[?͓qcP֣ \RBhޘ2<6$Ͽ̈""#k~KELI{Ж\. `xѷ&!|hT5nGax?aTM)̔ϳ0$4ֽ"?W_^.<"҅CBV4iz^kI$ SFxK8g>E P6x~@Ҕ X$l#vTi.So5wTGWqka P4E!Y8f\|r֧$]J4eim5JD$b>>2G(vgLc5FLyoMƺxmc5u(qX(j,ʣϚ ~I#Q UKK"|*갲UK%p}ԭOU0i( <}*#$tq;1oBCgњL<bBHk'> <9 ]$(Qh6673p41O:mH- C(\wÇǯ|+E ]&L-U;QoW~pҤ.\#ޤa5k˦+0n_ ms?׏w0[؂5cqo_ zg{4l+7"IFe9x&2[:^IJT#jT1ULHFpPK[?Mhd '\!u '?$9@H0 3p%4SrIaC.!ܔKLb0(w1Q,ZK>%K5g]Tk"2oK&,\Lqfk~K5=Ԧvm2% 28r5pBY B A4T~2R 0`%NqTmY! @<]gRlA Hb )hطVy*SJ{1GM Y/\[cᯯ]-tkN;RX;ë [\,pD7)mZs0Na_VdInAؚx◧6AЭYBu(CQ C!RzDRSqpCa03w;Ӥ]i\Ó2]{}F,7;`DҞMfnZS{7/¿V` ^=@|WO[?޽=6("VkP+mcRذ(Ȭ#U@YZ;wjHﴬwnBwX?RQ'}7=1sErz PHI0uQO~QuAVMҺ34!14 t2UW'ΜQEI<MQYqSBfV]B{ endstream endobj 317 0 obj << /Type /ObjStm /N 100 /First 883 /Length 2368 /Filter /FlateDecode >> stream xڽZMocr(@0`Pl@ K0:H"!bI!ο{MKܡv٭~S]GsH!0iYK`^1z_Sh*B>eHS\4qqQ$\8' xz*xkIi\Ul鉏c񸥠Jt&As/$XZa UVXN=ȺA.O2/: M+p9(|(*jrAUe@r`Kp i <եr2\pzl9ͭ20wKkpVV+P =Rp*-Qj(k(N؄MN+4nj+a^5N=Aiթ#Є=45]dӎšoők&|"NКul !})Ћ/Ewjd~˽ rVq>W0ك+4`qFN7L +@M{₰w^֝`4wX={Zz?O'(h >_<&mP,Q+6KT-* aGUx,_;=vg70 76hX⍌6r _x o_WY%]?l.?^|\N2ϧI$v]` [/1㛉 8(c1n5{4jV?o.&$p {tX8Ab.Zbk b_N*v<`oj|"(ZN:H"$Vqrr}yZ5ahW< OQ) %6a|@q26FpKAulr845cbC܁N8@OI-f*3f'$#%1|,ɒr9m,`#%+"b,QICܑv??L;?0N !bԽ]fHyPwmmP EԧDky*%:Zk^HX!Ǒ 7q|sҗut.hH^0 Њ#Nsiy ]0`GJI`Bke{OhOkFrGb=2L^#+c}5AOKb`Y1Uppާ$ڀg`'E qjޥ=rO ;IGTΓU8A=vV!$~Pct-!m'<^[Z0߲%8m{K̉T=ܶ(]^#+z806' t)dXΓ(y-C{3@\>9e۳C۝A=4Jc4FYY̘^GGx~b44gPGY=V 02H\l :Զ[-IٓjFĂG%U(6w ZMXQJ<}Wvd4uz,]5/WRUvJ[Dܽ=aܝQefHhqp|&8}$4 G䩸Gvʏ9ч]V6d%;QYVK86[~&O Ĩs,XOjAS6SF~U endstream endobj 453 0 obj << /Length 3214 /Filter /FlateDecode >> stream xZY6~_GN"H$U[^6=rU+2Iy<~)rfTa6}~$_ݭ7W/_*a6bu[$a\UbBnߢ~_$Y ,Zqhu+ח`ੵVIkVkTkF4.vLLj-'ZY, Dt@]6@7N1'L ߺzmV4ME)7*ܜDlNҖV!:BAC v/,= doԦ<CWH+v的dڙDg"\949q_z!ISShz Pn!R2Z:٭]·Ŝ$0{2 ^k&n*oAvl\ J& i EJ P*4s: Hi[ n~CӘBv0C`|i'SUUY cI%m3NC*&gJQ_l$P\2<*O+ZPhu7p% Moֻ7OY+ %e g6CYك"Ǡ)@jm$yއPZ]{vʝb(;f%t*zO{PP3 ](@&y2M:y#?d9;ۀ*bWh'^"nNQhI`RM25jt9,Q-R ``3j!0Kf't!X؎jv_Wg6aDsK @}T F *C 6,3h}|XOޅ3Y (IߌYbvdq7MSW g4`h@d@K"Aa?Rl50TV )zH 2 ԯװ[4) N1=<{_%5%"iTt!Cf@q_.fh djVuƘ}7(p|z7_2mk0z~[4F3iOھHa˚fO|2$@mwʗ0ͨ+mprE@aU"$zUd5*j_TW?:DAC ?ܴedfD閎X,:Ȼ:<7)o l uPicV<9"Ύa?чՋ95FmIgL2->c# ڎbmweA Z\)°m6L-KK?+ Dn޺-4hH| |C6(&bmvGRľ&wU{u hjBj ؐGCʣ#^:U":>LvO*`U`)-\Lpbo·"lCd;Sǣ笓DcQ1߿4;s lP[sӚIRvT{4ٖ'LX6ء21vc@A }J\ ڍ=D';`nùs :.ϹX1f?>"6$u%6fq PPwj.~WX2h/JLJMy.Iߟ0ɵwo?%>> stream xڽZY6~_P[`R*V$rxR`{k9gI*m\ͥf@w׀prٿϞ:Q(S$ U a"% Oɇś?޾[|:KQ37aZvQf:?|F`"QT"uڞ}5|5e:# $9!O2I*b qAηMa%pf "ǰ ay P쀀  NND ,nc2!< \%ӎ_ETE < G2NWGv^b ;`a)H/eX,IW6֠-O.Aի9T.ֈ6$`Gn9EL|ZHE_lvua<]nqnߍF37ő1Mv7 l<FH撀)dS"`pK4 k&\? @"P 1Rm`ͼ bf6l$nD&A08\gw1  #:(x^{|x >CocҴg ls00;t_ihȽve{~%pp=^YMg݆I8SZZ[{BR \ݦd2KS=~ijլW ͂Y.C57OK' kJ]WaR\}&zo<溮A޺peH^?bgp`})A  80ē+&[$ ~<$@+4)g8bXQX8Z21E0G҇8oJVz^/ )gG y`1Lָf`[;DBQ6h",<\3ʕI $H4`%"!I8M}4xv 5=.Љ:(P;bd*dZb"*'w`tnjߚ0DYG"1g<3q9EC|np9`cWvsPWMV4yE[4yvҞvqIɤH DqGWn1$0|,n'8qebPYp|uqٽPp+o׌(k6d,7ie':[N19/Ìgǂ aPd}iʔ5`6aF\>-QW^d ^wkZWP8\?鄂J)T:(]4k/gYnWy1 yW7hn&nC>ecGӲ.«o6`[Ofy*Tڌk870q.PE;ۏpФ1֫2o R!9xwhX{v-Њw*V3bvc&fFɝ >lU]uyY$)=\<;+n6C*_*ĦP `6$tߋMa>q>jJ`c3g XufwIy2iwΧ|4ëq4x7vN{ܹۻfs7"KV#,{XAyMþ{6kZVap_]gS욢ΗdbUX`Z3j7GgP4Eg;9 =皞TT=R9Ȟ mM͐q~DjK}Ug/˜GF" q*?91j]E ~ӕ鱿0#.G16kqEn?sHtn.|~cOd0xjG!VjZmUbƧ9KK:dQ[ H dժ؅5Y6 xQPh5 ړj\ JƜ1=RcF qg邑u3ڻ ;*l:l'ţ Fª VxH+ӛ‹Q>4,h~86Ve(V$"\4G-uOpdj{J endstream endobj 474 0 obj << /Length 3209 /Filter /FlateDecode >> stream xZKs6W|YyF$d7UJ<9&rz(H I~_L!lg=Wq<,\n3i-"HDjv;ǯ nY, rDθه3C>@efVFLxܟ ~qxvg"X|o7gbY’HFd”&a:OLD9zu+ƣHdI0"fFϠX 7OS=1g0 6/o'TE$ o÷d`^'H3pF*V+1O/i|qO9']U5t(Ix (FA$@òg kYU))nz}-w{Pëe8BlHG⏺ڻo{KkՆ>v}9Pyf^.w^.7sKť[5|żJ=5ɾwF6f\ uJL_ B7@]>{XH1CyR ЊXlk8opon6WZ_]Wq'4j9&TL>| _֒InF;IH &H iFŇq !]>O:BV4݇0|v%P #k=4 (wgù07""mJy1E_%LG"vV%)@f./M^Vcv@Vw`2Gb@y`R 3.RL@-H/zlTyW١hМH zjÒT]EС+Fq'q4)6N ~k1%TĒD*fKc>'YZzPN(#nfvHWB1##jP J*/WيV?iCϑ+bjMI:Y^N#f߉r=:y"uk]VD~,Ϫ |7^N[YDEtB'WF8(Me5qx]6~ԙ@Zweyp($6_ni[)`nuGZ5HE"l$YhS*;d sꈱC]84ʀ~c0hU $ 7YST64N\@Ee);f**G l3|3ȘR`ISd_O3ZݠTdk0y ZͤSq[ dj@_,#0[1Th:/_%Ll$3pE4]>"TX{s CQ bhݭ: ntOU^CZ6J 8O2u{mpq[zA@pBTm@'uE<ꡗ]a "]n`hMA&Xu0לPR„*ID/B!oxBJYRq)0S9=Ѕ 0zb}:ă^jtxJd$ydݘϘpCp,!_P)H 12![œ9X6BX'y0[Vy-=^@%ɰG2V9xX>"~J] V.+ lHX2= ΃T$A#>2OOCa#'96ִ`Vѽ5 (Q2[+^5Tf9e {쵒hkGoev<~zez, HI4C(I*_?\M{᪇WwY4uW~o}LO(XE 1BP\74yR^ NiQȆ^l{ xљ^V) ~.]qH, ڔ$/QKB8=f| @YL_Y)w 9)ԴˣR` 㓛ЋoЍt nReO+tZ|I Q˽?WFui>|ʂoajȔvS.\$`t|E#vOM+؈ p!G22w2& "أG"7pܲN_>s"{8}B"fJv~-ztWD~#t2]4܇*O0B吺/i!`ďAN"I^kA M'S^':zJnlu%HInKhe;a_.uFBNd#w_M?hdCHjS'uē;(a&ݪh鞪GP5 ' 7`^ ݁"R*o)L0NhA?o*iuLI%ðSΦoz'k='mZPc(t`-~s4-N^otZ%‰jkbW]{m~ԤO®ɨjʮ/ÍWHYfDdLզ6aކ> stream xYm~mDbI6hK>hm"K>Iu}gHu)wsHaŷyf*Z_߼B"-R$BŔ*ŧw~?}PjA#b"Fh*a-;&xAa)^ N 3b%ѱt8Dy$Z~1|ӚFQ.>or'mx+:IbxػUQ1II{!yHlc$iO^LS 5j<@lRװMy<&6 uegP+y'~ i:N] wٝu>l2];awX-a*RrH5{箬\!\;gpL\#dӜ|0];Ҡ NH"2c[h\ᒳqS[5 {> q~eRw9 yH/eLz6hKտWF939GaݟM"F۳doCDr=kp)@y)Eţ[sE &v~qAo5W>~Z6Dpy@qպ2ʚ&\/uvqo~.;>NHXsHG*B9$k&ĆĒ*Cz\T. a!6! 1=UJ \umؒRÖ`³"mV.]7/(ہj2z@w/eFA1M:p[|_iz z%?cDhgT=<=5j(AFj/i Ōe/5Եvc0۝HY'ɫ4>>[hZз˺b(u7vb .pmԉtі:`kw6mVi?]EGiWѽk ?xvt؎̝ j|MC Gܝ&NJ4U듪e$A{Zj?-3 B%Dg&A+/&Oꇤ}gGH,:ܛ+YL1CƑ QvLvƾt ovʳMҔt9 AWw+A#Sm䄷ף)rk'Sj_Vh\ XAS7cOzߞRЏz9`-)tbp.l@>=2p xC{Big:[l'CV 㻜 WpcBpcěqE^ {Bu5`_qԡ`~ RlݦmNsSBۻ,!(M3ƍYBRive(`y5H-(}5ȹʻTm޷}ٶs~e21hb _=:>؀"j{Wa&8X݉h0 Fhu\vY}#ŐrAi:3u@*V" W14,:V[X^ 5-cof]doMOٱN>,0 4ҬV8sd9Etls2TWТUUqaz%&bcNl!|y|OPJ:he"ec؁; ڵ p67)(hjGG".*2zgW16Z3epjZvAS\Д}yses.Eep{Klz1ijMU?r7jz,v_={|ƘLԘI ٙrQ"Y֡!u7Ns h0+ + f8U쮺BU+Ij+lڌ388D{mw6}B7*·zc"[IDd>uz-8e5viA 7Xܷ6 Oʻ n#H*ܒ؇5%W$/_s rS|.q䈼KU1+̄9C:?qa[ÏO =RT$ > stream xڭZ[o6~`*1ˋ(Q v6hdч3GF~!uƱ>CRyx9lξ}i&eYF)"٤`7v?42lřr$Igܯ`2K6J3hخo*;Q]oԸmWUKF H&lxq*qWՕ2|Qrf<|T[uNwqo|#54{,usc %H t,By4# x+Hͣ~\zplC~Ӭg 6ڹ4=kG,QiHx6UVRkWsZ;?XT7NK|wL|#@ݙVzFN6?f~p@na#AL]nޞ6YCq J~"@H $a"17e&TD|J'+ CZ4d,Kd`bL[۽n/_>q Ϩ5-4m8)]9,_?\K `RLr=|n~T{[7h7ỵOGoKL`$^,ܖJV}kF~i)RwyGG3'OFI%M\Y&*󮳞3m_z OHN?id\H`czqy(nލUo;*8bؼ`٪.@VA_ ZfebԚHmZH'Wd+4%و8Rfr `8U`-ʹ 9~*yob*1MdofwzyBn%fƃ_'ev7έ phF8R#-[p ׺ʷ;5~k7/w4ș 쬝:&vM18CJUˡ 2 {aDP|f՝>LAӉLgi׳ D-XlM-Я֟`O!eyxx3N3P c޶. @PpKΤ"@ pvTq0ePZgLv(w&42h a(Jg!FH7^1`l!!}eg`jx8XN$ 1Yq۞%Ln\u_-jc.mL3>V$2l_E9X(b,IuTMOSqʍ٦Mwu2>c_tX. N]bcjl*t%N#=`v켵H2R)$wĂs@Ɯc0ѿaU5xe}71>,at d}egC^T4$h^p|)9"wh@*A3W9lm >MeKvEO,־ұ Rx"A)mptav\N=E;&c<=%>@uG;7Af[H|*}ۀ[\s03.&JMgix}ǖ V΀s^/q_L(~-u*@x]( 6XsbԃI \*7ӏ $,?\p,s&ٗl}kSW}K"8~&*,;\aͫ_piiG~τ٥t2a~ Wp>] ?_f'h ' Og}~߻D0.M?^éϱu暅K%dVwwrf}" W/LS+25!EE7wl8yns"21U04303LkkJMZQ7x2tx 0͘ϕ?Aړ,.KETfX:DָG|Z<|fyr&=f(}_W|Q!iǟ6ԮrF.P1ß+J}UXL u;%?~M0$W[Z1a I endstream endobj 508 0 obj << /Length 3490 /Filter /FlateDecode >> stream xڽ[o8_adj5WH}w lC*t"T\IN.pH}r%F5pf8děvdzE$dqD!x0 b.'W˿f_>wa8FZf8̳'s%U4j,4=‡ES2+XQ@!VwImmw!Bd[Ey̛ПRrR^M|6}qp5rpnQQ3f_ qcZ Z%2\0nC܁vH4/6ښ &%zI k,Eq$8te;;:@<ˏn4x Bm*KyS4d**YR6nW  8}uX&/kiul%y\eR% ]b|j|\*`A>8Gulz,`!+%\o"f:{k Ϯ f?epx0 XzȮР*p14ot/IeÀ&~17)kDLE]?$)"49j%08tuS51>3+q0]V>b ̭"ƣ0J5}MS{SW\CSb2V ^AE68r0V} pu9"!#[GK ??$RUVx\U6.S4mRݷFa%}W숂qiЁ@H%TYJ)Ӭo1EU`hLO 9Pȕ1s 4&ɩa-X0цu #L\ DjWMt'vq&=8` \1yԕ;QAASO^ -MCn˳n ;u:: !~lv?{3?ym_:Om8_>i|4Z6I禨dǺ\!(͋r{N琽!6uQZnA}0Yjp-!<` Dûޚ3Bz\FRXdIU-Vg8MP4۬Sؤf~ k#>wa szƼ(aWt>G tc_? 3}LФ&ҕ eg& f;e!z;x<$D> 5]&ueJ!G̡<VI 9  :K=?;uiQՐ@lԣY>ZLhQ,r&EBWs =˜Ị>YJ&hZ,RVӦ l~TS|V : *AbHx0qŞ8D]c,rJGlJ*`+^A–R &߱b+h? fdvJ xK ^)^L3!\q ,!vg ohVARS*uxt`h.p"h`C71tj`K]&9%kAs>r/ܲsJ$6y=6II]71Ub! eWHt1{0Kw`r70^brO{x :Ӥ!H;`<  XLa']Ь{"W9 m)r|{S2\d4޻^P J撱N= ź $ F\`KBTK&]"5ݝuܽ3O,qDZOw۸ zHx4(_lq`&0]Ó;pl~?X mmj s$kǛ9n?sD<޿j7ɋ&Qɲ \nmݿg'_f~C,4> stream x[[o۸~ϯڇ#k.,]l.m>=88Be%i/HVD0C 3\80[y{wQHx CIAp|}ϳo6 =ҎfED-3R=;꿟\hbA$B #o> {K#&#֌\{DH;;l ' h`1` #^oRe8؛QH 2a! E2DHp bB8A@XyX$ZW`]Cޗ)T}f^^>R͉{:.8B".#h2*L^٢JRE] z3#W]u!y_6\殮BX`VͱPI|;|3A M9q" X@9(r_vC~ͩ~! e"'xFS# 5~xVE'+ :rN3HJתr,7uui߾R eK5PQ@>Ef̮}gmʖj;_]nFtepFPTmЫ>Ic AʨqI174aMh3x$sW*)zM![uBDIsLQžbLSflܣT*~^GKm*vY7Sm`{R[ /nNFPz),~1TWy^LUR3'~iڴBi\gUh0lnŕmҍxFq]Gmǚ`~f*7(<(r׌/rM҂P#?6aR}0^Z4a VYb4V3lS]mꃺQidl-1G۝f >cz |FO.Ɠ\ʄ*8 knqeKU\,AGx 9 97E*[10,vQzT$̋u[7OkӭEnu .ʾ ʔnr{.2:MZ-`eL<2~ԝLpE$` 0p%#&Jh;e m>δ?D|!NuWLH#U GR }f>o yѡv_Z716D>.脢 :4x'^om4`ES]Po:_uҨ,jm F0QIV| VVZlcgdͩ}_ 2iɹLW_V[w i!E( ) ",-Ɨ_튳9iPaj!r1]=/ _zvgD&1aďK 5Z.^GqcC<hy ȸ4&&#y ddBD8 d8V& cCl] mNS9l(  fXDZp2 @6Z.d4V#DZh0f`$CNbfLIXL$?xEp;cG!GId`8xчo-ԕLк9^.h"7!M6Z.j\ 15H:SryUQg s"W)wX$|i3HmMht9|{5T} S"!l1D`Хfhm"^HxV5Ĵv痽aĶlțCqD|s^{+X="S]^F'XOt-:IpvB]1rgB8ࢇ (6 Y.]9-&S^&df}lpR]#T)(#+O993H4L@^ّnTuhmR`s<+Ϫx]G$Gw͊nk~Ʈ <5tmr{W&eFMQrtGWDBJ9t9Ұ|TCQVSKRdt]G<\(a? זE( tNrE q|WLrI'%>Eq4]! iT,'"fq TW.{iT*T:xBQԎ0րvUl@,ul$Id4 }8TW.X#>`逶v R4a endstream endobj 519 0 obj << /Length 513 /Filter /FlateDecode >> stream xڭTMk@W,"A= 9'ER-%Һ9kcǐӮv޼73%_i4YK 8CIn P $-"\pby'C*6j{&Y;^=!&K4݄ ,吳LV"eGO|w]Lԫ&<3C endstream endobj 531 0 obj << /Length 2486 /Filter /FlateDecode >> stream xڥY[o6~RȰ$Eb,flxч@z,tFu4[Ew.CmDg?:B$M#($\GWS&;Ӝ8g(5h'*C4Z M28zV%B*!UE+dJq™ K]qh3׿^%,ֱ/tU(T[+ix&D82w1)7绝n2\ hh3?l~µkp}'ȀɹLEdp`DfIXV?yu\C!9O,]Pe$yzYXTP;h( NK;_%<ќ T5qW8"rjEշK1Ў<\MN϶_߸Qwxt~UzY&޾\b$enVA Yi_Xc| hA= 8@zg6Jt{4ٿ,'<~׹ͺ6ڛqqs ޏ4]aח{7B8j{3Lʑ^zU[]Y[@1~ fhU߸Un[5gJچ}X*b*NF/ʮ6e @A(鿊 w~F@<*yդag'"Dso(rbP/pڄulr^yoD^SE=x)J+ NhcvygcݞkR9w%Gcx]/o}w^I\/8 SvpǸ'iJ‡,dqԡi[ 냂 J"x|IS"D:G1oDN,%5Yd%M4;ٸr+Ź슃1bGr`48uUX? +#fnv,!Lq 0vu ~޸^xF!1S hpQqߵվjꛢ [`;G{y^,e$І)i,?@'A󗏗6=\bT Pʺ9|" [Pg/_6}>54>M!`l!Ϯ_tI߁|SjJ('NjUgpuA8 vm9 X;+2>XMY!6E`[3XlQm{ ^Zruv{*D;ԬIJuޟ}FYtgW# g},"MtS I%RTr'_ON8#,9z¾B"P4hĉ2uNAB/ !IM  8HN&>]+2i?<~IsaY PRI P ~%ʙkL&cՆRP"H ` qwS`lTc( q5.0X,NX&),8:TS[%m̺CRબ, iWjAS}Xe܌+-x TqC;u_<ӝi/dKd1!Q|Idn{8\RϹ``rt%+|gJ> stream xZ[s۶~3;3m'vi]>ɔ(IIϯ? QdQR5}Ab Hػwyɛ &ģA0^ nޝ;xӛ F!l"dyTI'IZo C4ހ +\%!d_,>oј.0 XK"@b"AQQ|.c\UPHI|VJ!rN0;Kܨ :6P74*ӼRO _2$za=̑I\b>*i_EvٰZ⵳}Db.lQO7j8t!>j}EvL5=!ۍOE=hhEiCvqofIPW4 X,z>PѴHEi<}OI`{nV/fYJsc;'}F_:.)CpQ (mOV- M Dzc<+ѨLΨ:S( C,p]E8J ށg^~5;n 1DdEbQ>V~J2ItЍj48 ⬴CCTv푒HNcch>Hp+:$@i(Oin|> mkP1mv*y1 8t5z(J~K)[y2<_:*TڍDLXdYU4VQݚJ>kW0i\hR *\ijdN!j>`M0f0t YSaRh]q8`77u=ڡ 0y,ȚbXV[qtWv'oOO&#:3)N>bo c?\<3DߛzN~)vm"-{IcxՋy˟/o,8Kb@mEbXAz]mua{ nLttOgʋwbް-+ Ad}f;GKVMuվ2uFj\z/35޶ dP0(Ci b?8/9q}KK*8dkoe@B-P!E#|_^J\|QlRph 0#Dqrim6w'Xan[h $S ;D"%@m9#B>6ԲjW}! @FH$0 ZduTs~i7mQBd j'Д궵BB{նTRJЗRzobScy,mp(Jy_M/ԴE[;tWHNl6Pw*~$'J!~q_-&=%xVGf?oq镋{ڝ˶9c X;GM{\l|t6_ṋ A-=? Wy{C6 T!p"9E@Ӏ֝z~f#]cA;N7hd 1 m@H'_/B?l5mzڵ7m9}(uk[@#B>_!}M9FkrNŢy/[ endstream endobj 550 0 obj << /Length 3170 /Filter /FlateDecode >> stream x]s6ݿB{| ^gN3KS!M( yHEmZ:Mb;{sy"FĊrĕ"#239\>|ՅR#FILc;ZPpqv2jЋܶkmVIYY`dYʍ-vЕgn:m߆f`Ēpf>UREٷJJL1 gKB||4e2i@dp3me}b_WZNl؟^V,/zash[Nu:lk]gV,4fnHNkfOqIna^xiVx! {@zL_ڢOE3Xl}$ia[v, a7ۼ%t Zm67)Nyk*ˆĜY29A>(u?2x2zn ,#rT\ڀ ǂ۠`ByԌeDna!($+an@b{W4oYivUM7b e%z@AEO㩀6WZyL9Ho͛) dUQa͎uR7zwj2-}½>q-= 9hZ9|[pDD(5M]+q]3 p˳3: }0 AhOtDn _[~=Z$%G1CZ"p%:kЙXD0~̭+\|Hp4;;CPEz[ ¢h.m 3>q AbBdb6F;L]o7g'S0D/mϞ{:ȃIԥ DTXgR/6nQ4C%FIq"F暆q:nyLjTBZ=gTa c[WEǷݸG4w?IQmfz2)(5CSP*nX>'tamKWsw0䙃`ҽ6 !9 &n|8($68gO;cApn?( 'a @ưb@diu ^mwJTlF䅼T(Ȣ9 c &R!'\DMBLǔ?AF w/=iߥo<:D<~gi+8<5] qxJb7Myc}"+z + ku6sl|5x ]*=ߘOǜ2+Rx*)76[MWƻUd/œi=&<˦q# yrU-\YҔr"(OCBl]_4K1,mZ];NM`HB 2T!9P,bLJ4fk2u. Ĕ~2^,DŽd3+|Zu25_6F/M`ۋGӔਯuQG{S`z?P^Mlsc/'*CqDIgL!|~+ pOe eEKeTg)=i$W`1 -~AL _mw, ńQy ' vӴ{,TTI[Ia>izIҡ :t8 'ROFB QDBvSq !PqZR*Y]>״.~IJy=heD]q}3(.e1MVe[Zϕߐ-P7TP|KC 70^;6 8+_ã05sWzl^%XX!UYҤ.{ιg8.iںB ˏpoyڰgvVJ.>iׅppc$Z&aqUIJ R =`]I&\iq{ʬM57"5Ŵ#,ca τ+3dBUŝ}Xr^3f*_EY&a0K(B[zDqM%6fm`3 3=n =ϋEv%qE-Еb¢veyթ.ʔJ'.N:ڝqJ)nBČd AGBPEc@"u"((#||Թ4t0s޹HGv@ #e#,qpZ:4| =T$q:SHA=6:Ŷb9`pL1.E# z)VVE ^bn[pAF`3|(3SؒF'Eٜe%oZ/Ҥ^|g[Љ.kԲ_= 6 w>§.x3Ab|~\ƨp#ӨC3<<o+]ӽ3ǶC=BD&bTR013ޕ7"+Ӆ-pȳِ<#D0<4YmUK(`v 食fWze1&!e.[":[Bhwpvg4c/| endstream endobj 445 0 obj << /Type /ObjStm /N 100 /First 883 /Length 2074 /Filter /FlateDecode >> stream xڽZ[[~ׯcBs081h#CZ#F`w Evub\p8ͅGXRIšZKDjB˞ZMqR=⽖ԻT+J[1"4o8*ƠIKV\hR 6TJL bD <(Q托‚H 0qDVy%X4'hqGFz!qqQc.,JUW09{EGwӲ07<,=^yc^{h;8)%hqSC2hKa_+h F hy-t։c^ 9qR6\@Z h^BNY9B@8N˝sY4\@E}'8PQ.EHd"Z5DŽ=s濹@Fa-}^4=nmqqLf#X" -+UCvXD5`1"Z#d_D+ )}@2}v=w$xΎh +%Ȭ2eVr$[`߮g:4I#@0^dNN.44#B)W#V} 74T3࠯QiΕB]R\/vh-{fDKh5_h2E‚. ,m8-(ZUER`kV0ŐzTYS*,biOf|{6}ԪdSZD`XY|szO-;ljŋ"ʗRT/Gz1̧T8j>2*飘(3GQ-HFpIr-mGb5,ZH cj㸶m?zsE%2-Y" Z$Lq^H=Scq`)یA_<*APKP* .=3PgstfWI?w|2Dvxҹms;6.1D KE'V0)O"r4G~ȞJl j#Nw #SW#Ne,q`2B)sAGf'၌HAh FklIӶ'` $fE;8,h_n+oH~N<ՂmT!#S%'a5FL\'hU"&^D8ӑԧų=wOI8= e?W}\&(qgS9l<{85 ض}h0h%w!@YdZ U\]H(=>*L|I64%넎+2gF̊{duQ ܧP MՈ*!DiôNBѳ`B;-:/a]5`2\Һ,ٳ :8>SVLw܃Bg/q endstream endobj 561 0 obj << /Length 2707 /Filter /FlateDecode >> stream xڽn_Ah2!m$XYwe&ViJ~}ϙ᝔,Z?ؤs!n<}8{wy<ՙ^HB͵3-0fJ#ZgxYpFC5l0<zA8X*bOQ0T X 7^w#Bb!V7Q9}begz/ h4WбSXdyUF9a4ItGJk3ffr:'9`U,N 1FyxNW.NV0h>j 54z!4u2C^$ 6e!-e]p(W @ =!0R+>Do#vpzv焥"S; ɫt% 'H7xvH3'|.) Z٨~l|~>S-jۥP oR~QFmM9m/)x^GE@Zkuр }"~nժCJu:P@oZ  Vg`.q7cPjWS3¶7/yr+G[N4GBHtFFu-H q#`6c:d@L4;+h.)ot@#!"A؏q=*$mT8IV]-O`q킲cWXz-^z[l5Y)HE ;h-F )0$GSШX!H/mݒY,jp!wZeW͗A ժMT$Xu\ܦ%v(9'q\̪R-Q8q|~9TlhѡyܱAJkgl퀫t8-'b*r\ioڵ=&s ƟEP&^a?ԷV  dc*#JC4]~JxzFYO&rqEsaeVv ^nro" KX&v{Q(ś8Bm-tWE3b A C4C{8T+Ut `He XU‘06׎fkWeXmΓG)š;zCjR,ZB4UurIj}ud/SMЙCT8)FMjӾY@E'WvFhk y9~\7Ygp}^GIv+ۿLKkyCldcFN F/x86 'M^x9U#"[IJx0DQ񀑳?nG:c҄9zp˶6bvU6QU͉kZdnvi }Yk][5#WOIRߓ $ѧqߓ<S:C?|F&y7JYQ^N^p!O2Ś.!CmCD5x%%G|_2$%.Q&1ktuBQǏ/p1ؼKwӅ=ԗTr%ܽ. dLC2R(,euaȿ) ?#1 91` *H] endstream endobj 570 0 obj << /Length 2854 /Filter /FlateDecode >> stream x[[oF~k:K--ri-ܬXJ--$Q83RHḬ}Μwn$N%Cs8ݵXp)bJ0V}pA@ݛyh%_ muiHWȒ$ aj!1O,mW f3dt=-˷X&dN MNjl,_gbږ{SŋaX  C"4Gy@[ $Ȋ]kϑ>nPϤN@ VF*_@TbAυƎ1]RsW.6&S{%'"Wb,{BZm^5  Rۺ!2ķnE|/;{}sJd$P"pXdqvaX֞8!{B97 L /[^ˀ.ODt>攭+ C-mj+A9KB/@f tJU o0\iVD ee!0ޗ,w8D7yo߬q/܈ڥSLУK[TzP5+ѓb '`'*&w?#T_VAS QeM͞֐ֵT<-V9wwޞ5<ﶗ6wm:#`"koŇDmm2\B.%*h{: %'eAyؖ%L3a A bFj5y8{*t5Bb̾8B%}Cӻkn}H=!Hsޕk~_]W[ 7*ڃ] g,++piŇ9GђPe endstream endobj 579 0 obj << /Length 2622 /Filter /FlateDecode >> stream xڽZKs8WT!^$=dRdvg&[K$CRo7|;@ht7ub|1%qW7 ,"8KZ\m/q~>Y&Zp :gWLHꕒ$Zf&ҴI1AXhbg?W< Uq[,.WB&7ijM`k7iy=c'\&&dwpr=|zĞ_$jP ) а ’Oi;"a[/+(al&Mhmxd2уU!_{nR \D7)jna҈YݜP|H1"fR W{jzJ& 5ebheC/W2A)ӝXα1tZf4/ܹui٧0v"#Yv )r|R,Uϑ)i\{H Rk~P=Uq(g%7ҽdsFiRҚH9b" J#Av|eBL+E.|۹CSwT2(>1`V,1y7 ͆ Ƞ{"ͺ{_wt⛪)b)t%guCjkI=IDc}ڥecIZNP 4Oǿ<ٯAEۤ7^W ږ>x]|;oM:#V9hſ{:.5Lo(:HjS8x{TDxP_ųDŭmYT`d =<0$V|*̰ DhšN< HOh=JJKd7v/>%#ƫtGܜ5;zzw.dRM8)1}6yruiGH3IFv.*~BVv]TZ"<ʙK0֑g™q}!UYO_6w2 +!8.XuJ#aWI~b'WYbEf7xCa/{%\ݳcX:o,w2*~S4 .YEȸ#]+i`9{UД<ئ6R1;ֵIVR?Gʛ3N /7_VI`5j7R贁@'UtTUH'f|!WRI_Vs^vͰx_heܦwtR ];FLP\t)̹E@; YD:-r`tw5)"s&Bދ?+'DX>3w%vv5(:rBEǺܣW#PbSؚԘ ʪm,M~7w"xRTxh2]2˒i"'mőnVҧ_c"o:1fDeJKyʂ43}9 Z|Nnj4 %lt0F6w"ay=gۦwBb8umo;dca%[xvDzmW^MA{V](Yk8@#Y]U i45ZKW+j.DG(P;JK=ZɲMjؾk?JhZ5[_w{Wh[_Kh8m{<Ѕ7 ͵]_uʃdٖa/qbCPM[0(mpcx 8,cTԹᤋ(\2řY)c/;=.CN@4uSC+1 }YfW﹑ϫ0 q:_$@2`~{-&D5K{4l$Vn\xYNCU@ߊ{fʧ-db>lt϶&iNPgBL@A6Ƅ^ANy>m}iNZ߬( ~9hm8! q=RdqٜR;$;0 W4ૡ; iRv6|uxĴ`mix6uo(d#%u `x[r|gG#Նz\#)]\p$9;'](?휥O #I[2~8js&Y N7ƪę7SIKd}>q9gq endstream endobj 589 0 obj << /Length 2843 /Filter /FlateDecode >> stream x[Ys8~PyVڲGfv2sԤ[k)U+4El=M_7bzwu٫K{ IvңJ!LdOI ާ0|˫Kz#o0D,׎a !'1azC&·}LCy?lрvfD^+tK(Cx&Malb&l3]ͦdok "ƷjVy*&y#,x.oPҍGd\'G>1RB!aܮ!!uٮEKMHb_n60d}~$r4`B. QW|VEV4W:߱YݤF~|~r@2}ƽ{T}u-` Pz7gRgTz/d%;wgF "ui _,yHhS  QBK A^D lU$jNM!Yʾ8ުr.4'4 IpGw>BUQڊ 3h<% k w]c`Ti V H]UW)"r>jW"q*lѝ܍rZ#[WoB~9EZS޺~;հ",IܨK)8ߥEgb)Cݱ@X'',rMϛ2= 1οD>z:O"r>ϒ,qKuA#up5F0(:"9`[XOd,Xб`bD.C[lb8/`0$ tO!hATR#Crhh %y)}Ѽ܍O|iH Ta1!:]U {o:c 0 ? 4Cdо%DҜ vh:}:ׯ.4x9_m7 KV|/{\ngu l"O=ı/?egl*lJ ?*lh19:zXˋ{0Kpegҹ5gHN~<MKH4WRH*| J _KYՁa)|*2iO—0?uÊcm[Bۤ=X~杕,.:q 5RW*ʜ i UZjidT 0==\59ė( N6|kicҍgΦɢ=uAu'?p6Ǧ/نN\ $O}Ϫ DF Zg)Qar**]?FF>xغnJu'e ؆ŏ~kv~ k3;;B?o]!vB2-Jw@u%(wV!_wJy0+[>Sn`%`/rXQ,*t(&fM.^7e*BC]9j*s_/ls:M.`ƧB”ҦawLCƥJ1\7` Jɞ1ݗ* qYJX}vj^E)3d,u3Q6f0L?Vz>7#t\ټ; lihe ! C*h@UEx_]װyVD+Vu Fr-ENq y>@IhV?nW\u"$'NR Fx'j\Cf,6؄]25@*b)wAUغ,&%rp5rAx _nMPZ;Yf Oكqjd f#;J|v'O3iN*֕Z<Zџ џΓ?] xul ي)(dđ4)i6 '${fnXQ7.EQ7'͓Wo*~w>>ەZ (]Nݏ@C endstream endobj 598 0 obj << /Length 2815 /Filter /FlateDecode >> stream x[Ys8~`eVJY#MUf*$v}:UM٪D&q~4.J<2} `@w]ӣ_/^h(d&$J!Ld$A6?gë/NJFߛaZ#ԓ'1aHK{w l.VxW0Y/nVl߾LWl ŝJD YD^}>"0XL$DInGW8 F9OQH(,xtQR<1H*=J1( (C7Gf ">CW)š6 h$8y 8 z7$D T?dZd5RQ^w#]ˑ8Iy^ ,#28 |ľtc* _wP$ǡ@c ?^7U#}MI:PJ0-dtrv̾9u5!lVXIZ䆋$|ۇwǽ:@ ineך=A+_|b˗z -z-՝ MF > p*: O̗^zO~)Z/ﮏ{aRgL_J8Cm!neدv@-TC8|LI:cdP:ƀ{yTU0h"J$gQ9x}Z^8l[sO=΋n!@5Šdk<+ -{q[G=`(AgN4) HD~"3 8y(5nl }ɪɪ[߰_V8N'Y>ڝ)MjJHIȽ4ߓ2P[Jʮyo|wK$%},BQDqP ةq}̅DRJl$F}Ŧe}rPQٗ%F#;Mٸ(~Q$TqmsH?B53Mހ|0O9~8HQ}5h< Ou%1a'܊-2']c$7aqSy 8`G00 F<YYGyF5e؁0m&4u~ZcwƑ ]M>缷ߒ%ާ]\;/TSƆ>]L pBcˋ:Εq:IUI@J"9do%0^qNy;%^Q`,tI ,M/"(Blg&ٺvn1viCE7qc r(u%Û- kn,-XuG ,~jx';khdFgx:+P#bV*? ;$j(>$<1~]$aH~\N㻴潬&մ/.k쵁i/&0Aspީ܎Ob\Q wmlS|\e)~ Tg c jzG E:$!WzGy+;P*i [>?Iؼs>FoWwpJKG.F1h3E1[M?'H-bvF}ی]#ܟ[ގ}XNw/[sep{9\: GY]l,!lOƭ^ a|'X2A۶ihoGd2bL˓l8" qey 0ad̏qDE.-`YoJXm4ugi֕TBCgG?rGKw.CtfBp&Q:> V0bX"CG<^pۅ@:ZpkZ z d%>jjnҗ1>CC;QM&޸J vo~m![|:MA A4 uB%T*#t>ô}+a'Euۛ/5SsUBsOɅI..𱱳k xUnD|pqڻ\ԈWE˵ZOuwzKB x[>[(s%;0.M7UY',*< !k嶲J N$.冀qC.+VkQd? \HDwwG?1@z㵗zlNI:=Du 9C5`s& D"Tй*75wps6ft`NlR-sg*te2)z!njB9]mL} endstream endobj 608 0 obj << /Length 1994 /Filter /FlateDecode >> stream xY[s6~e@\tqd3ɜP$CRM_$EJl9gBx.sLG_n~x&̻]x\kBb$b»{{nh1J"%! ˮ 8.:۳g c @zs"f7_=J(ؕ+\ R읳Q /" F>\*"&KoV1k>B"{>B#DP?F^/_@ Bfq]+ Ɣ;T^WY˯s_ܙ4\&tFCRhv W Y̜K {VfȗwjK2s~OE TDF/D:OO%m@`t`6x[vjǣ DPMp:qZ9ZE"\?"`ޭڔYgșgNHd'a$`&E &8 $T;] iLHGݵzPEn5 I 8.3ϛiihj"vPEMGG#B\#qb.::dfu>8b0#ۖ"Kip>(A@}V L`w; H+wOss~+^iƔ]Ǝ߹uf0?Sݵ@Ϊ9g_~|O38vݚ$sC:$U+b:z1!]Tƌπx"qLy1"wh#z; lbz6H, \֐&n4*(,<"X`Mn W&x$o7xs?պ endstream endobj 615 0 obj << /Length 2742 /Filter /FlateDecode >> stream x[s۸_K'A2gOkC>ۚD}wA"%,A`wz@gG/@DS6p e@G$L.W~_j=`$4q%1SˎQ=I48đr?q㟟 ZgEZKftX4|Ӈ rb,pxSBSs"|^oBň 8攫~4eǨ:-gWu^̪~in#YU>ZbTF001GT,:W0)?rNkKY;6Q[1 nբvS)_tmb _ހ"j1f‹hz3%LG5ٔ쒠#YҔNDd+XʹۑdK0z&7r$}ҵb.pAS2q|?k}L7JJWj$pU]*JU"hɆo`B"@ZJL]pݦ(uol\G~Zy Q X$b3M 仌$xW{ l51>C'k˯> n,";),CJ '^=!F٫,HU~m@"nz [""9$2g~®/U:[xV1Z5McrJ". `7e+HNVY$U"?vA+ۂ25&ƿMʦ6rU8rAHHD-ˠXBLp&b v]UU#M޷| n5LZ|Htި')"U]mUe6UiYaWT|f)F\ a 󋝧O NcEʭ2-# K{Bb'FrkR::-}ň,*u/_`)sah13_5 wb1%b :;kBy>:]! }l=_,0_{ s>ϩKH~v3!բ } &P۵$f!lK̜q~3ڒ e;־ O嶐jbSnY1{fD$$vkohZ?>G(iEc(fr'6nE_"턹?Fm1at>-1>{cԆYs"~' _ aQ]PH<қf{k^I$v8"9\fѺCOYoq]P7N@3:&"%:ezao+~HsY}{7m+pIPA5d!L)o[aH_ޝ1{Z5~ΏxG!AJHTm]xl_ZfZ> stream x[[o~ &sml8-1PITHi )RdS>g̹28D88֑BFa]R)I!<G7/oϕFaZnv ?_|?!0H1)J4Onnq4~0bFGnܮf`D$O#HxdTZ P԰'s{ys/$PnD(.e|7;A)Gb/VPP1䯁S!FhB "@b7`#l©xQ$KK?Lg>oGTtuG,,,^2@k (R A<`!H Ew9PhQǹhD3$^vk_ n'fկbлdUM|3?>Aooh)$}e4T2 Ч53#MY$ERKDT[3eti.߳dC|^#f~e+M mt'9ч-mw_ld?E!A8[~ف6Oipd?Ƨw q^|xc>}%h- l:AZ=a(2pQ)l80!`Qp(Q@jS 6)g8T>)llr13/g 3j!,y @vPx e3aE {]aY2*ͻd6oAW‹p 06˩@(Mi[j%$nV=OG}|JFg<2t<{j@B@,/L6H2U ?Jn4#P{{/1n>* P)8}EBB-ݪ^v bL1T~ܙQ4lݸb HLagIra/&)77X;PMs*5XUL/X_ @G!p:G.8+c:al۞7OHQ n*h{P3H9C>7/U1 D"zQ6S$䱌8pu`Ū&GwN.{rwsDBڃ]#b'iڇ%{34PIK5dLu `!X=~vH@PQ)d- *([zV]&"j~ąF8z]33Q~ AVVg>=PS&{eGC'z dPןuy8@Iwػq]XwPS& 1G8 ~=-s:otxnbk]g|G 2c]W"uWG3"KI/ jr}{4HT\v t >Ll1<%򦭨i2VuJRR.t ºk- ,li<:N"WUiKjEpDnr'I\HR|m"=|˞vx?$\ dc6JE*nm뛖)/Z/Kz~c  ௢ևZ5 7o*s)}{NDS߱}j۫pZllPv֋j.7J4` "Al !KVlQ #f'-j ˩CɿRON,F@W.Dژ Uo˝|gz  Tryj]J;[ԳGVAgۼ0_Ū *R+ =z֍(/_@`BCs+(FuJtXj"㾡˳/vGԱ;ͳS agH"n{^o݉fwH:B>'>F+kxZՔ3#ҏR AAv S, p :g%h@ Dy ф*d x6ն*tg|; 5DM/=%9KG X/+gŢJ!gd},`Y us endstream endobj 633 0 obj << /Length 2393 /Filter /FlateDecode >> stream xZr}W JIcƛʛ]ʑU R"u>=܈!EL a0O GG/~xN(A:$[D4I&2J$Anoˇ_^K`vo3 ˾DŽy{?]| 0(a"J(E\haĴ7m-Dn/>5&gC:Om{‘-B*jͬcdӵKJRJDgSV:)pÕuFV2I2'5E)$gt b4<;vG |28|"CU$uy1Q)(kuTh*7O@>y,/_{[ '[lHpwLMhלhD XgYdJH6`m~II`¶A1|`ʼn ѵHx忕 FXǏLK7vYH(GD&vŴvSfe1K{)a,1;]X%Viiը`ggKÍMB+i1d\.i⦬qA^fzZe‡ v0Ę@57ewѱ^Cf {YaD8gq|d P/2=bMЙDCC(=67.b~+#TxV7&m0Ϻ7k&Wu5+tc1":u߲zhLdL-ݹ ]y@aZ@7U9jTU6KW1sDܽ{30(ҵeQ88HWn+\V#9P)}.xtMbDl'8|%.0x׼nF!|C Ǡ/P0h1N2EE{{m]M[oE[ tzE5Ŷ֕T-8b-sM&t{ MfA(&G)ϡ0k" ~ 9{YSn*W?*ʚmUn8̮|L(#_ᏑM@ 'F-=fe[ T\n !B䶓 a-$&&|7vY.INjN;;ڶfs T ڣ:(p\C0!uSB@?fgGoIz?q(q~rdmԒphf!̸̌ whN`&䬾]JǦpdI4t^%|]L> a*%<oψ?yD endstream endobj 643 0 obj << /Length 2721 /Filter /FlateDecode >> stream xڵZ[oܸ~ϯʀ+^%%Oi(oE $*3Ҭ.qsxHJ3ؓ"9<w.ݫ?|ꇟ2)3F"3LK03)z9˦X &{tw?Cb sI罯rWUey&Klrwm :v 54M$]TC3!Ь=RhM:v[E}|35M5ghDڔyaSY]ң1<͐"sT432*=ȌY s79jt)&P^D/ Z9>UkW}>ɲ8 okR5fLgm>I*ftPQ_?e۟J~Y$H HT sמC5KEJx%ޤWx pK܀#m:8=* &Z"\~HR>~ϡ#t`@[cڠFsM)S̤Y &rQ ٽ 0HBmm~A)TJ|'`TElfD%^R0LB^Q*Ƕ/ C8璅߯*P;H%g 1٨C3:3$͡% ;zHй)Q Ht6y <]:!KADjhʐ:q"< ':I7` W"y%XZd/X&F!w+H8[ Gt9laHGT]u(n(IhkKbL֖hu8|Ѥdx:Bp覥s6OgIжpA8h8yp륐`IGss$Z@$=P`\-hvl[W> eO#DѤ -FDpZ!YBdpGO٧3U9@ yF$n]D$wJ!e Ѥui u*)ٶuau; ]dSꦧTFѼ+kjluid.Wһ7K>w6?B>OÇXy`3y4ҷMfM ۗ]G ːO@PL~nq{FOM@]}Ti'^gܗ8hc}*,:qBrUd= &DLY^zի9dF(7qٱ}HCe諝 wB?/+qɏݴנ Qi>Q""_OT|#:)cp|j( 2u9̅>,Ynhhof3)H s\ HqG/rY“^',TVK*@BMs;GCgLi5SDg^$ s]B& lBD)ɝkVyV>5ɊeRDZ)H%9ǂ0D?+\66v}"'-#sM8"@fP/ =m N'Ji-0UEW~@b`J*'J./:6 px3ީnp8~NK+xNn~@~hdlG1lg=͢ﾅjLZ`ĸ޸4Anz*2,Xvh@{U^6 Tvz5ϒo4z={ynlM<#F8~C8`TfL64O~*3Ơ4\NK՚61<Qcl0h2^jA9Q1g)~o66}d߬M"x m۰3!pZp#vXbD.52'>K}OWC -Yov~ǡ-;㗖;aI,7}/W}w;ۅ: p`j)=mE @C*XYx*U,fc&"KcHO,iIAyMyF@e&_RCc-p50wRcz"b,C>k)$αJ% R Sɉ"He49ׯ i endstream endobj 655 0 obj << /Length 2680 /Filter /FlateDecode >> stream xZs6_oY~{嚌CۙwkMdi#i\ɜglR+zo{+2v0.IDݮ~Oo;cVg4[q 㟼+(Mۮfڢl3R:tgKR'MmK+N fцi) җ,'8͓?hy~2l} 1Ud=ʟ3m@B1-> 祼_{.:8yDFÜ v5&~Ruyx9kgHp4;6|T6 5%Bg~g(ock[[uKVJf!ٌ^6lbFf-h|Rɾ*31G{_-뗩Qf,N[hY:C ⪛Y!҃KʩRz9ʫ-؁^0WXpʀsĴJ8EbaKgp3wk֤@O&/KgaRtĎ&+Cރ&#׸B 7s;7x8xihx!»Gj{馽֠34RgftlՍ4pND>~x%!NCPkmhə'iq-BmZaf4gTE' Fcp1KUol^6M:m䓞o 4ķ}B nS:E*x|#KM"jL' @4SXmذIyd3sBLŞ:AH@S`z\y^cg^~(DC`E^D +:Fs"&jK%E ږhӳ Զ4Ggm (? =Hpa6p+sRMU>q#xL$6jV Rd _r Сn&6pzg|{: t=ѿ׀+ _ N &mmSi on p,Z[FZE ~39<uʝm`n~ 2n:e}'Ɠs7@aI auc-1fq0Gڦ17PE01)}jy]͠stEEYaF& {LbX:vgLɴH0 JH: &G%T2GO c0UP/('k, rd`.!Hќ)3ם\TTyiu Zm]b!hS֭3u)Ag(%@߹42pp| 9\dj.uP,?"_cuW-ߵa=I%l]Ί:2XCHpٲ`"RscODtrM$v ˥^,=$NKzHnQ[!TakZjLJƢF_nñ*6BD*ɜOH ,: OJFuC"l.ņwHCmhXm= qP&lf& elZwhǫ~3)~w`KyA,7h캽tC)A X>WLL|Ny-K O#sVK& o6v~irw_Ku'E1=qR D/JDcXsN{ M\M)D_ӍЫfnR&iA\jBbH`۷G5귉X'VN:795*T*XWCQ"^Y`w$~a)8=2YnK4Ⱦ@Ŝe Fs>1EP-HTZFqr7Vb;9@Ky Eag\?N0xf*cz&}9JZ_dQM'nJW!.i\W?\fPypZ\ 9-k_s%a׃;</`@ƕ'(W$K2Հ3 L2":aگzt>y!LTfy/<d}z#IJ3IcRyx8.J͡ne1In`Sۤt:fERk]t <>w)>y!mll{1Kf83WbV&t&ZLTT'Q8iގp9U> stream xZMoϯ1pXU"  H&^`cd!-$3cYKjiz'tWEիT-y$nJŵZWu^#5mCb1w T4:;IT}pIb%&I֓@iR XZVy] u@]g@FżFѡrdb측8՞̨WLoyLa}`GR`1EWu44v\¸åq>Ti7"I.*8W;&j0A˘Mpkp[Kec4hĎ`\N&a Aw4b `(,L43w;" C#36 &7 d<| kBֱA#>KƲQSN L%>Xx4:wN 1Ehijh!ث p 4l귧;u jG01t^XKg^`嗷D_^_/%p؊饗Xfo@'Ob3@//޿\ifu4ԛw?oVo1 ("EZ_m.>^\M<ﾹ-𬰙^%Dߊ}~~&Jdw]lz~?gAyoodAcmdiyU0azZi7 󧫏?^r\E0ŀɰjRdYN3 4lYa#-j;t@p'"欥eaV-U( C @rĴ p1aZĐum?\.mີ#q vm繛/sDy F2:%{2ݯכ Ex"5!|H<-Ȅ/m2\;O6Qa H!iZ#f.c(Yك'w'`Wfe: x'AnҘId}X8;^r~r”dj;YMC;չBK"!ѩxcaG,$ؖ5:$];2gTdS&;?Dwp 3KJM/! Jg;.KI33m]`(`}*<; 0MUN]`Ri峜l9 eEݢѕȭd1r-;"d-x% JB7}贡#e m=5rb3/ZDcEN`Mgcp0s'Zr剫GSEAHgL]_3B# 14 endstream endobj 676 0 obj << /Length 3060 /Filter /FlateDecode >> stream xZKs6Wm9Uڭ&V*[bkׇ8zX1ɱx5idw* h͊~x^hʈ([]]x*Sv_?oW"VC_-(L-Nh\^9^IYJ4D+纳/Qii[[uE^k%oLWLURTmmWLL'$cYORNbqپmB&xP$Y\Y,V^07מpRHND>rRԿ.J u:lFhcߖd7$ >T;\ 'JZ6L 7\ge釷xLc}F;ؓu,ƿŹyEp&˶]+O Qiuyӝ8|MfUx j:ZF < sR`HɝCpÈ{pg,!6R [lL'Hv<'"T uc@'Fa8D)̭ݡ>K[#0h;?U_'4%EdU΢IO0SFOF(j-+AK/P>Dze{൷l^ wAggxƏ7^ŚC<1Ȑ|QGa@jѰ-fXf=dqJScj%Äakv(d )z#D})d0ח'lX]c;Ov@QQ1IݭzDOE;{1.8HA3gT9rZ̿vet0 /9c¥> 2lDG(i:w5|Q hq:/ecҀ1T\Ii7E |g$!Ix9lB,A.̟ u2#cODq@ /bQZR/Ad!Z̒舆{"|Ѯsg$%&c qq1,뽟9|}i~1̲UBaOՁj"Mb?BYC}tzBOyr2򕫜_ L[nQ pСZ6Z_23@ސ8ưh  g A1 B++IloSE^ K[]%'TCB{.b?lTc' el H/Ke {_SL]I;g^FxGC7N!1d'w48xx nNַCl <$N-`R$h]ퟷ>t9F#  *n?Pп8g!|vGhr/lQ0eTԻöXBIkl26VgR8K!m /||ꔙ䲴yk$m x$|o߼7'IPXvP`8a6bP:ЋfϷB)[D{-+my:1M<XE!OxYbI@AO}PNٿa /M ~Nc?3HJMzY6&x?67wSfMjȰ"]U3{Rv$|dÆbv C[AWGX2'{!'@@I!:8Cm?EXQ؂&d3{t7M}Pv|qLQKҰ26"Ptȋ۸‚уehMz -=,ܹl3+lM T$S|LYL'eͩRLƈ}Q2S/`lu{-0MN%9 ^GI6w34vN_-7zFmP;k~ӺJ1DcQy@y.Nrwss:8\1Zb(Q]jrUxa21Ϙ>b #՟Ԑt<vuc%ĆҝeLDH_! p8#[r{ 2XB}Xʀ6$e>RL֮-,&QXd!(F^eɢۺ~: LwBjGkK1+MGU:;du|X'Cxv Zg:BУ^<);ÌLOD; $%:+Js\iϛݗ10 3ΕE,8ۺ aվ ʸWGy/B(7kB/:)P,EDCi].3d7W1;uhܸ&<ݟꐗQFV["CK *nF_b?Lϧz9qtn>{XlibcqI%M>PgC8Xsݏ eƞFxa֧"|qzkwv"{B+$~ʰ;􃛪h9z0z x304q4@ yw펇sŗIB6͗\CJсs{?ɲ_4d!'P盫wE endstream endobj 691 0 obj << /Length 2632 /Filter /FlateDecode >> stream xZms6_ɗf"LisI&k&Oi:GI9dH*bWQ:b(w닟."/dqsa|Pss]mǫ C,c, dqA.|'-VbV4w!hW u =f" Z/*vR\/O q5F,O䏵_EVB0^,r7wCexN 8ew&KRe|e_LM&l&}l8&5pr}7+PMnS"ف߭¯د<44Mvf3a, 1̶ܔsag%L@x_lMҲIfg%Wk*]5E9/vI٘v|^uA `'{._iտl;bqpB Ȩ}Þ>pfcF#\]~+,`#p8jGu3Kݫy)"Ob־ҽ[S6L'E]q͉ך eXyPemAʋ1xdF3"Y-"dA+6Im)mePVM9-u:m/;ݚSj2-W-bn¢?ojh`>2'F& Y)_sp],~f[`Ps7m=QK%a04=lSXhK1؁'l("s"żMe$ê?- c1o!N.YɘOa/nX`du&ø&ETK-nL@G5`K{aǣ t4Ś,QLC!1ӢC890Mhɬˇ,-hF!<'<=HsE4*7ۉ_AS,,:bhI@R> a+"6}{:zրI3x&؞t4J9Vl>'f H5'h%}e]{O/t_T.sǗL*\$DNU 5[R(Fe={U#t!g_(~ 4Խ()|1օ(fp  s8A]u3zuX>va JX.9b}:j6fGŰQS> aQf NgVޞ7\-{Drm[,'nд|8|3jdC.'x{[-)`A{|Q|6l e#;֯ fa0iݐ˱J7qX{TJ(.~ja], h1z|Fr`#Hȓ<$xE4ۡ䴦>e^lgA4v^@F Zo,%*yԽZ{ }POyHoMx0K\9 t8s[7| jIZz&m 8w`>?t3u.'y 2PC{8/Ip zi*]u5I}Y/e{pM=sZ"{;M!6q1U *:ܵpg6IwI9=!9 Z_Y6 2Qg1 .$-C ` zSH9Ü9%ag]#М !gX <)vRm%P r0y g"H>#g^*x8^yL\ 5 MjZ/3Sbɘ{D< Lw3 P{:%vMiݴv}W5 g^ZY] E%XW"bA%ـߓk/)yϸ Ωx=&W[{}T(4$]zْI?f[&/v6e;@yj :]Axmg ;J!>޿(kiӯbu'iûqٹ,4#9w$}^W _^]|@}{CKGBQđwkG!\L8/_F?`C@넦'rwHEa3 P+3,=R?ꃬX%HV 3!D"c@û3F(D."G0AJ Y ϿUe""y򔺞 6>D=z&qb/̃z|2dHE'#}ezɼgT|H\ȏƾ6α}bߑfo*^6grNXEt͏?G ± _2KǢ g]F8#\6hB;4;NKN՟& endstream endobj 702 0 obj << /Length 2951 /Filter /FlateDecode >> stream xڽZ[s6~LVP\pi3MN6ާ;HͩD*$9xt<A8; it觋n.~uPF\0h҈$2J8'b}O-/%Ѱ*z{%m6Qu;~HB ̨aM.|ijϵ 0an.͚m&l;,/.t:\yqyq:m[K41{mJ|!}P?VPW*_{:yJ X?fmd~ZCGg#e`*ykr„^FM)ܾn"+9w h#UjmʳڵoKԻjE+@+"M(eZL0*v{^M!BP0u-FtZ]ĒYF%pbbbgow1ʼnccJ|;{I Y1ljc/5i0n@w˵ @6`-bYM 4I,8Ĝ-Z:\*7cYUE`pH3'N ^ 1)r֡&GUQ k%N'@Uʏ| >חs &/ʢG!qË| XԀhy!ýlz+ r09z}&BbVn*ShJ-[7 Il` @cBDs&g8""P1И`saXCf~V0]hIfCz6ހ_ 28B!VY.]7Ax6Q:L_JFEFĠ“P݃1 7n"$8!\7c+`z1zt:T"8lHLd ) 3z=ul T \ IWoKbٍVDa[6pUPihlodJyt:#h =4Mx2 #,z[M-zO/9mM̎ze3 !xlw,?Gw+F m׀4x\!mVM#NuTYk;`c F@TN{d>\z/spսǶ5tZxRCMbpy@Ac[E_=س!PD=ʵi?6$"yWk7-DE=Xc)v"b*ICBܘF$c%rB'v7eGEA(Nr&{у 2(:B'{I\Ns/]JڲIXeyz V)",B#Y*6g-7%4Nث`ɑM+yTF*Q=R'>~tUp5i cIĿ{lRyb'l{ oSE`y/RMSѼ lpDꮯrU̓t-d:6aBOB#,%6Ѻ[ى =Ev![?'P@%]=- MU Ad7+lPÜDsN?š0ށ~n,'8M_|H3S%K tY\ś\]:z-o.IaS4FH9.T@kR@a1n6L֠ 1}e/Ϊ_}^}žQȂtjo kO5=;V*1 Syq eF=}bziLn )^n\r1ŵdOq5A_nӫE1je)5 )S u i=LI"{pOÃ5xqM>(< & _ɲL\nWe۸-Wg닻1sM = oM Y5~Dqx^/EǾ!x=v-[F1Wc;R 0à|Ζydx6TXiR b;10=ÕmÇSGFCOT)>sX`gt/B85͟ nC²f"&F}i0D5D 9_ޘdHws`NY5t ƞHSzs5(PbU3"7X'_|rP8H_:x~{_eC111(ר]!z+.56qfEk:{ܧX;K#.y"zL,5 ߗPlY^/6{^;b.Pǐz !9h9VCGlmC] nP5{@t?Kg#RLʵoW¿t勔̨)v?W BPCyp g qI0(M 4 <~NU|}3flX?Y3DՄCq,Llǫrf$ Iv:>[ N푝?Ep endstream endobj 715 0 obj << /Length 2855 /Filter /FlateDecode >> stream xڽZ[s6~dމ@0vfiه4%V"i{^Eɒ&~@ԻwvǓByCBBHĄq}˯N?0%$e N[yz3BdIvv@O3Ify: hWv(D͆E~>/H( yQyfWN+|j*M~1ߔevN1ETO2/H3?SdPMG&)' DvfQ3 f, RDvx$ KfPĨSNMm;o*o^vI03Хlj<$%lj393 DX kK (jv\.S4QIӬNx^p@HKCR@ daɺx Zd"s&%l~~y gjj0 \FFu3!,dsGC&NIC<=#Ȟa44vsƺP;~ԛ2C DC lt2%R)SDG-+^"YǛUm;:~黍5#@<*w]gP.]Lfp]zשxeSӸ,M1IJM[_OmM!ZW_x`b Hor +\ ib>11v13PbrS, ;<ͤ"}^+U>rj;QI9 "!GmL[ P2U2oB3 ̼,|-֍/*G#MK۵JڶT*.j{RJ1taC~SMY%I+NH f1P_4`ΛC@qv׉ݐOgy65l;Mse~l`ee% rYwS.OY4 ZIp?IQ7 v^e #Ӫjy7 0B@[}8PiN `j)܁!uy{U a>&=F`mHMPƿQR0 4q.s9 #!P,vdY3~&6,a~-*19Ff+ke s.@8­@Q,?L. ͈݅䵶لjjd\wf%xPIC18wm_l_`̐Lc ڤj6sBm>͈u^#JTq2NI4HLntTMi0I:TdO@מ&)0naVGw Xi1ɭ7) Tb;O^jHr9SkĢqtebl*rg_tt2HȆN %)ifr]fr]x~A GܑUThYqYUUVʻ2lL` 9(?xm6NH0\qW'ܠ#Wg< i鴊~~ r QE#&V<aC ; ذX. )EIhu; PG FҎ\ɨ>-fDpq35ҏaa}o\V\omź#FOURel' ժrf%je~Yk\l%](#P])3I8X-Ɩr0R%umt;74^^bp5}~ םb;!‰, !طĵ{90: `r?LÕ>!aqѭ<_ }15 /7_|LDڻ53B"Cn}8yg6C+R\;q1&4g{̐>[GyWA=?^A"=d-[&`١߀gL`Ek˸9"npS Z'lLȍO3]g3W,4gؼm-ن~5v;xB8ۢ`x H>^OH Mbk7C󭡠Zl G\ HĞFQ`6_''/y  7;Fh/0Qu4";$b$™ pm|d8|Eo^ fϿG|xa|5M#5cI&˪g }f;98P̋RϐLCRɖO r&btc{a9(/^.ҶZU(y47FHSkb7Hi.Jiϙp ~Β[hSg.:cJaSȡmC[BiD(BSKîawI;s7s({;כìe>f𶌰ޯ%|;,Jx0͸ >,ku.HGy@4KcT 'ר㏝hwWYEgf̨&\EXVj7xtSDh2'N* DWދk`VTƿ(? endstream endobj 728 0 obj << /Length 3669 /Filter /FlateDecode >> stream xڽ[o#Bȗ@Mn-p-k $p4@ڞ}gؗ(qM>%p8͐Gg3:pۋof3n Lόf$crv<?\3cd4%)I.hUR03=[EVG?VmѤ3M2af &rekig[ "4v˶v4VBF?'lj,U)5Ƴ"ta6nJa#z jru]$2T:W2|U^)v%%;4֝FTuR ȟ,u*fK;oJKfLoeK;+q ֜T-S$!:Ck,y<:PY=6 U_f@r0 ׷[xbWְ(߫K%S󢾔t5 5Աk;/86/iԞrm2#ذ{_>U_E#^U7?a?$< X@dA%Y*aUPh3JUK=FrΊpxYeDr&@/!F(6I(v[D !A&PD(fEΗA%WVg >NOE6#ޑoO|w7NSh qKA@O,(*߶Z_iP=L I-:S{./R"NU[)N&nhqCUnȯeޯ7lΎFOgݬxv$rFc U%db"s+(Þ3+ng%Ȫ*aڪUVlFl? ^4FHxKn0e3aWDna ]"534sJ;b gn[f囃7n-D҉;d\[utXve[gQ  NFAuHIU1$0Jktz`C4I_{h>$ 6ɀ_ڃd^L,UM>潖 ;w2[.b8$re_0"z<< 3h"ǢM՛JP DnZβJ٣`msYP1B:ARE c0VTBAOګ ~xPOژ`|3H:8'y#={tnCGt#0PP"1!J0/5']( G$abc%44,h]}U@(s>c˛k`38w O){FLdxns/fx֯dy\ӲWaMS-E0aD5҉-(⁦ke"4w&xHp!R/;H(![ gߘ%T:Q43>Zm]99.mNݩ3n}rS|)48/҄eGoe'#tAjA7ݦ8PۼRjKX2)1j"h> ҝwIqZUv0Y T"~3Bdmj & 8-n/$n:G'tH|ILzy\XعL 0g-Y%PxQ_&at =M?!3Z^f^ \T/&7e3 yp#OhAorAX:(2u`8Cg8ТGzi$ 4S**m)_YY#3!P3ˢm9>`ixnPHåP w뱆 hqV5/>~mj'\Rz'>,5u#zU=iV+cMY݉wx.نyl8#O("~M(:y>Ni+jU?9Agن~_lʶ &Ɗ0fsYm7UFbė(S7XE呼N~z$UD);@R:~@N$׮`KRC W ?+9zFUJZ*F;ӗ0 MHJl;z*Tv3oت<3\H/sXz883ď)1Lʝ\KJ%7M(仦ÞEzQg!5|"E8+\pPS-?ß7"MH+hזy⍀KP{jNF! b'`ʰ.6BLݾtQWdG[0* w"2'%UKj0G=_.k7"|BAr_B݃=& H*xw/Аd @j9[n/~VdQof7?%QF2v"]NXe&f2}W2Ag>N)(XQ/!su TG >~H84A/FaO*PKW|g_^E^З +~bz;q/ endstream endobj 738 0 obj << /Length 2949 /Filter /FlateDecode >> stream xڽ[sӸ_Yvղ`Cvp tX:zH`;-?n/ICkY%}.)xp=G^=9 ÁDJb2` ჋ߝ|əfDXgv8zDD󣏟`m 0b*ܙsb0|8zwT?Av=WwTH>PH4R0bsa⮣s< XGx}~vl}=f}GtIkW}w[ߏ !pIb偘D8IZ'q5|oBj~w-߫wo½з(Jt裥\3~9Q 3qIOςRʡv~v(1Cø $|8T@̢cn(ֶYVT5bko/9 o CDi}W7g5{ߋuh@Q>-DߧKKu\1]gqxgQjr􃃚Ei 'wHbg۸ Or I1$.tfR(PQXhߕx6 X )Ő@Xαߗ!g|wI\P7Tm4w1X0 %nĞr:o2f1MoJ 0g#:ǫ,z{qy`>d3m@<ȡ6pgO|  '@X3Y c.RO:_H8a_03-L)Pֽ88O\ܲH]"ye.q Y5o?3LJcgזERIil7R/!>|jlyCss(gqvTcBcǎ1.ʽot{aE'l$\=TEǓ|>z8;цT%"D[A޺r-V)_.d|Kn/ sQ!D0$Dy -n")#ȣ1NoΒu+F~׋:I=Nt7F}8|a_6zHoGw0*D & y]%3HAf까3Gz/}mrCEx ś*Ҙh7°4/u:PkJ}$~l نJq?!9R!6 E~d qޏP a~S?ε.1GNNktuYg74L7n3m𸄴rBA~lOS5A]MH02g *ϣ :IW3]/O IEw`*v ~PCY\;6_[!:852E/ cwڰCs@D JV? u1IzK—)I2`p>Zl5'm;HS1M1G%Ǎ|O4!C݁lB TdTCwA7q,ɢȒ+sWcp' 7M7mPX aI I]3E؉#`ejC)p|hv#ثcWtG 8Cq5LS"%)[a K93CR-uYz# Inʷ&-;cІWub$-[g׋d^$L"jLQ\[0e}=#ЇwƸ&tUx(@SY|>3ʼn_pi;CR?ɠ 9z{nRܘ"eIwQ1v틓xx{BC{(0d7t1j/I4UYn;GI] Kzo|9j=U5ضyto WŽbzrPcIaq#ɰ\Ͽs֧LM%r9[?yrK>#H ަEtӐD70a䮬wT7$O Y@f%, aS0OG*b!p fói"lm!Dsg;!`)+iݰ27 T7B/dĉhxiS|tK&K+djd[ Az8͙g Ґì?1 [KZo"SbZVfq|5bS dۯ҅ǶȐkSsh $R0 *&(FP $厩LE +lbPɢܕYsK/B7TՑN:viƌ.Q3 \^bu|ԙDB鮼hQz1%Oc'ҺeErB鍮Tuh aAauZw[\ۇҼ?9# HZ>!M`׳x$V~'Bڛj1viC)XCI#8ShboG>z©u{`\Xki&2 h JKz#f[ةSOiDȂdXzdӀ*h~x$Z ۰֠2̱CF.O runTn[|vAW`?Z6K{p#5tХvkc2W0c?\Xw 8.]ěe̠BY[[X! X}<X`.A$vQ]{Yle endstream endobj 747 0 obj << /Length 2510 /Filter /FlateDecode >> stream xڵr6=_gV( >8$&qcݙ)H"4u~ETAɗܯ0_V|՛W?U␋v%ÐqW,fջ﫟/sއJpNEB]\WNLz~L^6Rye?W/D]ոC&U4W 3Y?cWNCpٚ!KrwXz5-.Reez6IMIM(E*- j-tX3Ą\j1J G"lg(T͝%"{W#1k;=]B(@dM³u^)b- j<'8^Mօ_$?Ȋ]eEVNe}!\:,#i41ELp0PX'[d|EJz/| N+&noH ] Kī8h{a}rO,iebsg΄z"&BES ɲ fQ&956`t!p[_DDFL?ce/˄pcZc'4?̚v M&48(:P5^ܕmvxS?L>bNڗ|䑟::AY)A OiSP*AQHA$ʜԢ@5 (XN 9-Uׂ)E@$"k ^x6mWfCv"d9oB, 1<?#l7lp~ ekIKTτ.J!PlpK'yD$)2l1${C{_'}pw1? `G(}5پBs{aR Y8K#F".~ ˍӆ$ʣ.5U:h_I•튲 {|>v: nOຢ8[^ ;-DGSԐq덉4rWdn(F$ైp1^}FB_@NTG9.1(y4on{wD!G9dǭ[ Az V_ $eݜIz&oN"ë//ɫ'auݚ:R>6=Th[V!"X&1\:wmb$8yTmn}`>]buYg0tiD;J:`AYWPielD)q!SݶάY>gɄڗ{KtYEb5w3۹ mSZїں!?winWgv~g矺ͪ> stream x[[o~X/2OxMci6>O9 6*9gxYieʒ)7̓;$3+R<1 ->Lk TZQTW}_W?к,7'`D^ \yB$E ,4S)H1 ܚjڽ7*ޝ&Ea*$-pda7-dzQg12g 1}ρ],H0Ԁ(.2 O"M-[hpL*@Y)g{5ϰ%3_|](/Uu9C$ N>;SW=@qoB|o[Yl ݷW6܉Ĕ@a8:T`H{q]. Eپ "xjG(¢_OcuNȁ x*3DaMRa7@N?r1 py(_&ռ\Nū֭Ȟ~h.Z vOevV;ʕ L LW*FCTX-d-'$l!xTmFbA0_;@ˆehGzا8O t&7['A`]gcQHiъ4ﰌcfJAP Eq;ESl8RD):EjSb^l/zlo%iG<Ȥ/z"/u1hܬD?q1J`P_E)mYq؁r>D)xe533a(YiP%e?'YJPtsKiiޱWgk)=,]5V }b㒹xҵ|Oχ˲e 9QJMЂdY#%_F-Xn0Q֝d8sl10zOeWWy5n$:1!/*Pޝy\5Py+kэ̬d7,ߴހ,^#BڶrC8rΚ} 6mHwi؏Tẇ< me/sD=t-]i S@Urߗb: Q ]}e/\4 *kдlhSPJvuST#b8 U, '>/UOw|:x %3k@6aP<^6\Tߥ>hgY|dSJ60Òqy)oyql?~40t׽o_J$Tra "KEyG!w'EVţDSR^^4_FZ$\aҎT_IgJ:7m6n* JA[y+dDokk/,>_$x&jЎet鬻=M-0ߚq_Hl^Ks =mK L |* ~W-t_ICB'4 endstream endobj 760 0 obj << /Length 2388 /Filter /FlateDecode >> stream xZKsFWt"U$R%+"A Ҏ/Rv AOt GWgo\j)d& "x*'[i=dfW {}u:,0K~t.ۋmsfn,yX=hgZ1nxjol>YgdbZ6]al.}yH~Fx`!KㅭO_Py\jb =РqtE\}mY.-B]rپ4Y>IzeD[ h%A;+;D\t˄i&/IBЁnE1֚hQ$]<5bB3#{lb.wAT]8l 3CA`}3u먂3Ek*^!T0明Sس.}{':a=;|ChP7c9ġ=P&|7mIbmvmQk[ܳd f兿ݝӻuhDHgsϳ: -m K-CÐ'[i4xf(̨'P{c=r[5E\3wbl8b}> kqA!bh81n5mGoo}C2/D5D+b1n=Ui9XQf(N2ocQ%E3jn+ʃQ}{"EJ~MAo8ZRc&bsY/["v}~́ɛȴ I!^. wDy c%?x2O ?ro0+feՁħ%. [}~a )·Y*9=;6P1*=@LhmҌ&SS'pNO+3D@A\ m7iC*?¶J5tL * ^M<{صᇪH= X!Q~.GG<_oZC&l"0l_ m7{h4}~ih endstream endobj 667 0 obj << /Type /ObjStm /N 100 /First 881 /Length 2181 /Filter /FlateDecode >> stream xZKϯ1pXO`(1C-?\?ݤivMmBuh폻)MoϺetSʭhrr/*Eڞ>,--"=M67~?7wWF^ts*"sK&TR3Ciޤ_o O?]㽏l29L"gjp{Vy^^SanK%cJ̖! tMڱLpd-@ $}D^6ҲfDԱ~vfsDRMʁ/kkoQ/;%tDl=?CCe^k";86X~nlE(|5P1yRVLbSANVjЭXp{6<#J}t1Yh>&뚫뉐 dpm O<%%eivcYZ]Z[5RdCpuKl^@^CMQ8d6+SMǚ ~ B1bgIAU Dܕc7|j7xR뼋a<ģtEm0!6eL[TGAב4n%G; 5 J|(yef{mڼ l.B/%00.$26dQӰݸC$!YUdk"$#2 lǨz4-WDD=u:([DN+6ʼ (v,F #3os<׾CX{,XD}f`m*q ܛ*gބ`л8/޲"Yfj#5 BJө؊xL`E@O]uH qia>;(hsj,ECp(gBdAh=<ʏm'& LM[_ںj.qMȿ>s3Lɍ%WP[6+VNyIuĶ P}MfNkT}+DZlm3T6Qg endstream endobj 769 0 obj << /Length 2572 /Filter /FlateDecode >> stream xZKQS/pNvUf˩IMʇH-;F75خ6Fkpal޿ͻ{c6Q7"pY6w=}mxl` ta?NozTpwJr&lILifF`Շl>xۿWw<>1\٩~mao<3!bGqfݎ[l:N `sߕС*z|,fU)+;2ۼN_9 5KI&?muҥ IDd7;@.2)Tvhe?d\;1n\#jzvklB[H\ Ӭwt v§c;F:ӬVYS\^9*;! B6<މ`۵/S7 4^;[KwPLR4㺼 ďʔyӴqEUS\vqvIg%i/ڶEc3mU{\S,,Sѻ3BY!oębܪ8u#? ir2 .z$$}_!@3Yh*1:_{*b!,ߛsm-zTu5w3h %3/ѡ \ťCÛO"k=z&䆦V](5<`ěDž $RIs3B@,"mBC9;+q]5*bJ BD =$q)sߧ-Y߯a˅>?:e'f#&&uaT`iHٝAvoqU.ӆcy TQ|rt=M22,VTfA*`0 .[kJ 77Q-ƍ2 XA*$$Il0c_ULS$|EO)$悚Dͱ bNޮ -des} *VsFɢ>wyɺw#`$f=QؠsVUsƘj 1 ޗ,p_QUJb1K; WQSʧIu@FL=lpGtB^h=AF/f$vH1PՁX0XG\ILLu i$OK}(asM!#42NN\TB52r%DrN_>TH(H۪G*`}jE6-'w ԗz6 Ck0ޝ@ZNz=G|w $8of?7+ aO5a K΂hbmvXP׫M3ʞ]ђ`^djt["Gg%: rES#Xe\Ħ?wUIj 8Uw&q4m9%b||^ uV)C\4@ͼ8LD'f)t;^H) H(*v K {d lҟ6O{} mx H(|i. Ji 3tz3tAň Me@Yr+wzudxq5h[gޮa?:~[s h}ti.X֌1wB%'urC.U^b^>vye-v~irD4O Ѭz tZ͡ aԟIJtŻb2ݻU&\>O[;IN /NNq.W1}P#_> +-ڇWxӵ /kp_cq/j{t2sgLm1K>!qHWL!b9omP]f =1ε/A+Ӹ05z l{s֮-{ N ƹv-TC[̋(sN=ۊ p澯>/;kek1c#cblC (/33PL3>^?ia^,LѯdN[u^WեF~U]JYDOVwxOZ5`w~o𻉖Ug3z6b+YCܸJzt^׫E`|我I-jo^bs$}x_g endstream endobj 784 0 obj << /Length 2024 /Filter /FlateDecode >> stream xYMsܸW-* \UI%[jDItf1ɱV> 4/a4#Q`@k.ntq//^zQ^YF(SL1bX\\->&or.C h&a.7Nh;h`0ԨŊKď$Dw.¿f1~pbq(󷛼m'K=wFͦU OFcvJ d\elFIs jݕu=E~E0PML*:|::*%lou^n M_Mk--(zU#3->NҒ~R&zL'kXl!c=HfZzu 5sW r bOΆ) 00'l8!Å]3[kv횢c-^)J /F{݅eI07D>Ş9R" ƉÞi=(-5gDւ 37p\[cnO']t>MA lHendR2U8ZKM'%jPyQh_ UYoυnSʗp8ƲH,5Mt]S^.SaU;N gwEc'6Q8\|e0@"|8?MY &7`m}yjMAtM7QeӨOr)6;0U?SR˜o]~) 0t.Kyqi!"w`"D-<¶rze_>>iٞ٥yD@ʞ$ZM~>GU4$D#; %hA}8ozN._/aK'vŗb5?_l/g21衺1Է )T(̸RzS,L:?cN|'3!m)E>ǖ2||_x[?kw^;D^sE3S q˷q] Gŗfbq(+jwctln~c]\M/},Ca.ѿZ-&pl,+^Xb90]|y쐔&LS W2QA!X:Ec%SdG$Y6;/l/]Yd;jǁ8$EKU/߅m_ Wkt4X}pvt"}tP}GXP@]bc7xbzQ!]\t ы`]:Ά4mUC-N(0ŗ:iX'zsL/* $/%gW#҇| hyk9o%H6 Z89xw7I*hVgul y1TK0KnMC,$O8R3cha!H>L+aaڢۢ&ˮo cfJ_H*>m6.ؤC)0_> stream xZݏ۸߿@bEЇk r.ۧ\jmPr$y;CR$(`Hp>~34]-߯/~٘EJ킧)L/RHz_W_~凟t(hg J S@͓Nb)$BePhgݖ+4e F-"&&ͽdmo/Mæ/]c|\%L%aaCDn%kJ-N}Ul]k]5x#?ŖQmZj;Xƍf˺ ŕKŒ d֪0*ӄ*sU#Rd5 o;5oC!,$S)K Xwec_FmϨg0/kolM g_i6$N'$(ENW766F>֞]حS^ !pÁhpm^vI>*Z?廕]81LńUD1ѢeS]Y@^ۖ 4yu^Uek,orl* N)l*3x~]E E? }X2JaOmyc߮aGiR)9? aJ'LgyKFÀbio vc sD`{l΢@+!88|@j;PIɓZS$,Mi) VL9A9HY:9Q\H PEZmyXL\I9%'D5$]:(p1!:ǽFC.!!ܬ&wJ ma:we,RDTAs7l<"sv$!=5-<^jD3Ȗg!û{}jT%m(O(Xُm N=75.^*=*W0MmXf]ծ C.p[8 #nAGF: m$b @Ac -qcHUB(=׷%3I_uү@+IP+y#%ܰy6MGcŁ a[W+'o20X%!RX#{[KCz;8 I}RЉhR6wJ(񧀒W<(:J9@ ~t.TǀҠs1nҹ2t7@*s @-_ n8HuPRTnXy'#- 0c¾mMHIWΐUa?nE}/V~~FYNSuq2@C0хPƳN P*QoTHQ~򗢡 {{G5BdDQX6'kԫ/뺸ĝScT?k%1=˫@h0~mhάNkC1}Ќz"nQ6J3HFbi㴀.Bbd6x/@ -)VW x M >~jǠHΡ0 W.FdֽOrfX?>m8FeT"LUUl f3q}jKB~>_'ciRS SfTa7:;~]Wgu6 nVu|jOWv^Tv&F;Ѷ.*߃eɫ|luo6b {Һ׉Cn3`m2-M^l|?S}GLuvx  ;A} GUt?u0:1N,YOg:X:7׏o@7QCne{1A;M^5%0>j4zhRVCofͽ#7~dsZ'o3P-Q ͒aUknjeIq"{"7e}=wʍLve  LwDATw$nL%F^CG<ètFWsy3)[]$NPݦeX:gmP{I.Zmdw,`Nztn :Mjn>O7 wLӹ8ytNu9Ջ. M[b"_m/>|5lZ^fnTf ,N0:F8PǢodyh.._p݉mхq˱8ZsΕ~!Ӧٷ87)<-ڞS.Qni 嚛N{m52S6Ev$ Z"K?I9TT }TY򫸿EJ?|_N".+b~bˑ:J1)fb{B=Ӱw`(ӹ~mZy0wmֿ&o:@'9p}7;pe˾7qi?={' 2qr` }%I 5Wl pB3[/Ȏ<{X> XSܔ);+o endstream endobj 816 0 obj << /Length 2456 /Filter /FlateDecode >> stream xŚIs۸]g\_h)d&mDBHI *OW_( 67H\?m3_@NgQ#HK_|\^IdU\y66afr`LΈQe^8[>siNjI['odX)T æٜٷ9ų9ѱDTv.?Wk:'*Mʿ шiZ Q3;C7Xn!&T`kcLxo*"+."0S/Drxa "2N{Z=GD(AZØ#!UӧxjLgGy E'm^lJ?M[doo[|8 C[52Tz3ߎ: t)YcO(٢BFƷԀE8{Yt c0xNuxk9ѳi\$(ͻ*agF]%tVpt4/Qtd^LI!v#YN$aF;.[V~6VYpa F}$ Gd/]1GfUn(?%ljS@Ƒ|,iӘȥ$*k4"9h7фdIt2)KpBlɲ7([ ?!![o 2HͽelKVЦ=.}öH\ցk{_ rӷ-vW%+WN0\<4)޹}|WY\9Å|`p\<}DL6E rǟ6Ose[usYiv78L`bܪj$˫1')ڔDAsmsX#7:V{!HYSYiؕw"YǽvnXSGyӷ@XS -mr!\Sze%֙ ] ԁYm⟾ѯ9]o~-rgn(#D`e2TPiɬOd'ШW7mCG3WYB}hɤRǼJ^.%)35Sk<仍/_b _a# !~0n1c0u lۨX n3B@I0q*XP$8=IHہ/!bzM4+P o&C_M7\|V.w ^yj@8*a~S%٧b&tKŏp>xn`8ۧb E]8 f= PbS:1pT#ٖσHڒHe!SB=R9 /}^t_0uC1@ΏLձ0 {Ե9  C>ԭ5r{ @ٱE/=ǾI NaT[9CӐy`uU{B; >ʏD!5<}u{PlNP)Sm !:6IXPp՜"x: )TcH,!`3![f|!%0$C*PcXĐowB-9L]K.b_F2@N 69$FC&%t4 bڝqV;88FD SFDHi{po=&7םSk]dUGzAl3V ]\(ͯGL1D5?Y`_?QQ.~ǂoCnJHrl+[|o"2X2]N\fT7T.Ai%8w땿 vdƄKP14CSC,U&/iiLwvo[nĝR]<-w: 4@ X@1 MHzA4[E#[Y%&ܑ b&A,hﾥ ݉dң;=n@ƁH(=48DoZv#56/,z@Y!W68/M?|XP \Ռ ;Wgg6CA툔to" ZGW_ 0]MDa몕uSGe`YB`"M1 8h- =j=*jxURqa6H,o7˷7[RXI%Kʽ1/$4(^+KBi9"ƝbѤf~J endstream endobj 828 0 obj << /Length 2761 /Filter /FlateDecode >> stream xr8PIX)NRCI{jhI{$9@Dg73:p?3$Ԕίg\kBiHȂzv1g^$-(1L,O2tB=2P͖Bz̫X](jqV%Uc+J|[%y'{qiZݻ4$YT_w:ʪqQW*d2%cg)b(ތ$ US%$J'x̖L"ަ hXDWOcHC١>Jw@9o>M13|3(H6pnI~<`/*?\2w"طYk'L7"]:P%x^܌=LTy^,^y5bm4ˇj!;nM kĵ-"ڼH"C SXQ9nCpiy)8۹QR7R|)r{#CFv/K܎*$ ZZ!+AN堡VZ\FvPJn1}/h$T~E^t~t嗨 !i ZzrX){a8({aŗvx%`F^Z2ʦBdF*_W+_i'흮| a V"Wԥu dț:۵- M Z480 6\Q!ftUW؄ HS(~yoOͤ֫30XAg {~lK^9=/PeCk{&ʪح*Tj'zl^r-tnʩ+(oMJQ}k5dxALBRP{ efvչBXXy%X,tr\GmjwU4#j=@Z޶ ȶ̂q*z*N]ishLp5xs!|AӖ8ݕ1#.rԦ/~i\AP&yf%[QRxppRFò  *e$ĄܙDa*k#75}c!$j kưR2emh=! rŸhu^3u`LT8x3"CNaFk"$843r#*0 ɿ ‘2G}]U#go@x&.!#Aq#Y~7:yM@CPML9&f]K 2~5%CѢL4;{c|4.턇Krpdy~\%9A[|;  <.!1Y,l# s!ZC >lsQ>it0jݰChb(q aZ5g~/ Wإ{^`MOOɆKPe@C\cZƳ'hin:Y6櫯&ʃY$<.BzVxQz"6jM g~WsY `+xx zQGM+1Dd]Gc(3 Q4v1Կs6s{6 endstream endobj 842 0 obj << /Length 2636 /Filter /FlateDecode >> stream xZݏ۸_G~S,zip9@\}({]Hmҿ3$E6=(jǑ~EWͫ7te5nVB^͈eru[}J~_׿{cVK-(IYn8 a^1)V6BT1$G?yaU׌&ϟOY[TdR޼r]m81Cl47;%e)akxx(f]urHX"5^ɬ7h%F(zw*a-lp#Xm Jl,$j ."D{)殻VmEUzåHڇ<xi$/uӾeyUn0qJjى]HɈ j7kJ&ηLSF968b4}_*3Mm1t)y TD%H⇈b-L)*)sSق3#Gr:fc&!!)~nRBŗr`=6yD])8For?K궪$\~xøAMlV4y>˛m]\h 9aE,4l]cD 6cPډ䍠\)9sp )_jLtjU9-^~O` p,žqizx$Cy'H )&:F?5K> [")KZ ᐜ&|=+.ic )"U˛ۀTsT l(VK@ijػp8? /23q=""vcsM_\T?{Uk%k(M/HL/1;bcBe6&,:6W1'Z_fcb#lLhS5m}ڶ3  |ǜ빭SS>k;؂ f|Y`m8(qwr)RMBbZ:+NPI}k?X?qR H;1U6IDɁ96@~S]_CFԬYX35:g16b^<nAI靲_UCYh4H12? {&fȳ-w/r\[̖}(1pZ(?A~1 PMV%A|`k4 ;eg*b:ȉCƐ\G*_`h&nj! ':E=s[ lT&æ!Z6Вa3=01h_08UO1==ƦO9=OUXJzLQ\C$gƸrύ1W owr̨)2&ZH,1,W?ެ-O}޼GeC}ϚG0jJ`Y/d22|H/D8@VU/cAa-\8ݵlJ.\uB\:ЖCh`HVWy(7P7=uxH܎Nל A;ѥKui9 '-0`_45-q}"t<}O(r1IMjgͰ}OYX4\1rbC;Y#o{KiH;I~w!X}XV]vlQ($.'h867U endstream endobj 862 0 obj << /Length 2404 /Filter /FlateDecode >> stream x͚KsF8UxޏlFAe'%ԒLo$hqכ.oj(d&rP&2Q Cx\'g򷷷J%#aY>M78H{kD'1aHK+0$' w;'bV ,D͎,X=UYT}Zn1:/zݫmz8 ,^s?|޻f#L7B8!덵+G"?@A)WMsgo`Y̑nV2[CS$ T;OYu|Zp[dvnʄrhcS=V +wc::LgYQۗ ɨop]}n؞Zahƺa C04ڀ[ !7"^cP܆UۥA 9S["@|HD4 JI+߲ykYxAAR?1S۬e덵(NC$HĈJv7d ~ob0o]B 6e}y|ؑ0'QVi,tFN(2ڜHD7爨&A WnO 2:ܯA²vXeKH]d-t&`34K/S3k5;cH"c ;Lz݆UZaD|:( )X41u- +(mj.i-5CՏBu0qS>ݽU.\!]&C»8z*1۸ gڧb2 -OC DbHScY61$]*@A nJYa mM}^q'c fm y!0kN#uJgv)u4jhraOԙ&Nqkugs,VU^?huGbzx-k) i.YA9d/@3T9vq"60msCOHA]бrltVB>=8tB5Mid5;iir}zӋa퉼⪟Or=! t6]١  X#jo$ Vej,h}|~`4@?SAnjA|phI#Su/#$0 k>+Pu!mS7U0}mo jĂ5~4 o8*=dw]gmb25x[mٯ/\ -O#mͦ:iOR)T6t UoM܇t HHipʀ5&o90yFjsȈXIh# !ɚB{T4;GaNp"!$ @7@d$,֪WIcи&>:c6FPaĨ%:K< y ZH xcViԸ1X{.B֗2.ZTafZ^db"/jOyњtn_hyhdhn'ً@3yynq?OJeẍqFڼsO nӉ Da7lk`! t{ lpu%)> stream xZMo7ϯqa}؇dgJ$zƎFYpChr5Y]z|Ŷ(tZE@/ k^HϫQzoŽftt텲=h;R'\Yqu` |hpMS0G+diEPf c40` x|H€#rQ1& tPa"acӇxEClh-(]{aϷpA4L1f(0E(bT0FJ逎͋X)0".^J ȘO2HrNA`ky>RՁ24 lfBqhb4+X0*3ּ5 ҊiG\FXh"&D9Mgn9x7 0gGVz[0Q?DA >`] TSlB /}p/S#) ћ=emX7DncuA8D: Sg|8a6ek:s #IhC{8.OSD~L7茷$ACNS得 9ʌ#\^z.geWOξm/m_^hfvwuj~|YNn*%Xj%( x0W̕[,ٛ^~qqrs3Z:i+V‘ T% #\]Ӡ?+\<(X] Ͼ8t*p٨:G.]M"ؤJ3Mc2"d`:=MayTsҠA}SުMF pynMX~䇾g+}8QMg'5y)֣BTl0 E&3+y( V =wB sҚwy o),yeú,sXu& 699Oau),^S OaJ<V{ԟ$\mb\Ĕ1ް"cߏuITJ\;$@pKnda5&C.5'B ּo׻뙱0JVrP؜ USY!&{Hx YYr./A{EW@xNH<+I?{1UDn6(Y:E4Ί{Tz,nKwqk`dU+>׊-$ 8 +$ zS+V Pvy-d^gb`EhEݩTv5\Dp}Na#XZur$Oa氨x`"x#X!9>#St3T󴜳Pi5s_"72@QS 5sTBa0 u%Kjy@X#I4 Am(d6ݜfІcx|˩Rp!r9K5z,GeyػPjG#a >\lW15i) Ɍ.`ƨvlD#1ۘNI=G6U/a{6VQNJV'>lkx?㜇,<.cpE!3T+[5g ]WaGt(;c)F\Ӛs{0 ՞_-d:c̚g`B$\i fP#yS** ҏN5<3[b.NA4p '^x9)*qNasۋfs endstream endobj 877 0 obj << /Length 2544 /Filter /FlateDecode >> stream xZK6ϯѽf& d;`0CV%%L")ѐDEV꫏EzFg?^[;3$1gBH~5y}ژ$ZPbY;%W4H-$DdXWO,JbyEGdDf>OeYU^Yajox+yV/"[ޡl+fȆ3me3ߕww7l#UPE}oTםq MylMq!pc 08(mg &#,5o$,>D>"RCa+Dk"6-4hGY,3sBn nVӫ%̢$+klꔷI t.5xYZE lb-o0!TKlV|:/atUdaBnYQ9I@ AL{V؉PHsA"i͸L7ʏ+XeQהk"0a3R`Rr_φ ?C"z8VjL%D>ğhExC eG?kӨ0KZ'1 m*і$7WoxѰ ,N;=['Vg<7QPb/d܁N;184-u>}@  ӄڊp5^z3$D(͜"_5Od\͖hF"\hEh_̗Y5A4ʌ=qU!ٓޜk/ΫgݟBPOǁ˞\]%ڈ3ObCY"{L l*JP/ //3QZ*.0 [(5F(\0 F=hkFY  @c*9\@Q:ڃ-'\yyvQb$E21 šUUo\4do`Eծ̉״P" uoΌ WoFU*,6F=>!Z=oMofg/!yҧL."Gp&3)j6ں fJUnMstl|FJr(Ҵ݇ڂʝ}8\::m=ɶZll۬opmi v+2[V";biTm.b*؏C}+@:HwN, ID2r!:t g(`rɖw2O{oq(3_{0HX$# RKүe7Wu)185|ʚc@txuXuuߗ|}y{GB5YРV{BKv}MWHP\wb4־Z7~zj^uA͋K<6_HJ^mv'nQׅŕɵ- koG6\iC yЭ(}n!wqi]4 X.%}7};b;ujry*눱 s|=[R≟#%x;$%9dQR@2?^FJa\)cj8j≇a|xO& 6,7/M`E αF#wI'o :M1S@pnBӌ%aD뎱"GQ@6 {aߝ4h6U29g; _‡z EyfDuUSHS!D*yNPe(5`d{9pb?HʎL9vhz? i%X%KcBhs7,ơ| >vОe.KmXWl ,)i I1bv)r3ѰLi"!7[Hmߴ=BǺ]1J6(y:lzQ"|rV]sDBDbRX"FCea4ihMeW#yyq>dME3%䞻h.t~08|9o.1;_npdvU+͋ݡnn5=nw>WiU}Wrdős#k3)d8vd% e/ɒQ]ibik#7T4We؇⤗%Dt%I$"Gh$퉻0dF)ŵ(@EU#'S endstream endobj 887 0 obj << /Length 2219 /Filter /FlateDecode >> stream xYIFБr틁9$m999%JMD"eypUisz<WoWij >p3dQ&r$Aj%_ 6~6HCH"&P :|V^in! liJ.H|N6sܸ!5UɋtUVg=Չ{?`lK;sWIZ4aÆ[ҖaK0/1 Ym-M4l'!XVC!3ͭѕJv~aNJWnWby*0k` 1w )Ҕ .+MWV϶Sv{qc~9MŃ6Än.Ԁ : &S!Dlgxq&KX –wHߣJyAbD/K^ Ib._mFkJ(\2+yL*čgWbqB fRl22Ǝ,`SSڼXnN?݄Ǭy_Lh;{ 6aQ q#YmEclFΣKjh[ohAbQ6b3#X: =F8!*C<ҭgG o4:BPWda=i]vK!xڋX!ì O ]b NT׶>zhz Q]:S%Pk ff8@a̻gF&7 w3)eE&-I(!s%*$g8,^z^C )p 0u2wEa3ؖ5C/T}U+`("[f-mJL^ 80luS.Q*tۮ}ܮ؇aTt4`b@-9}hv-<#Ў=!ּGvEQM :vSaM9[E=V\>&>)d7fDMN i:o;.7W#&F/0a ~ң~٬ҳ֡~j l+Giԁ_:J#(Tuzv_anhRWs=zCx9{.0γm Jh`>uvYꏵ*y M@ula=*yOUv9*U+ƴ`t5YLjBhI ۇY6YQ; q dJ7@co$6@bFO E/7@+ џxN*.i ؏I\M/3.7|V=.}A `; endstream endobj 900 0 obj << /Length 2413 /Filter /FlateDecode >> stream xZIs8WHUEV2=fr"2#h,@k|, Y2R L}F`nRbbz$B4Fɛ9ʐ},ঊ{{gtXeL1DeGUq/WއcY|+Mz U %>zI>VڌhkЋ 8%a{+.vК>"6]raE nª8o1/ՠ&]ý[- ?u $#$֠ﴷw< E[.ǼvKBٲEwe땏P)AN.-] vBuwEP0#9T!aC[yG >{Hp&N\wqk #`?vQ RBëaV T P=aFD#8qOa0"/40xGs o˚aM"owlypfp~q)༘!8:ݑd-H7'0 0GnCRf1\f ZC'B$AhIC+BT Iں O d] fI>( Pmb{jtn&wb:u9W \ɯQ Uw0w,hBӭ O&퓚+l2sCX4e'(u:IaPiB2N_+TcI>a eU:y>`J!(d|QȌkQ5BՕsBuB굍B4 p*r XJ'eq1iM6nh <쨙!^x)jk.ƍ3("uߘնHN"jCoﰵ8}8LuwP^?ZZF]KUd$a/Ĵ6rd*pt09kAP# !Gfɉ?=4=0 ;# 5"OH@bHd=/NDKq;˞S@ }9j7Kŧݐ$d/u۞..ȾUSIK05-<ѓ64Uv 7"k'ߢʴpv5E3y 4[}ժxV3""df4IU8@Y=SISc?U *J 8 \$JP>ScvPREb_azN0{g>ʽy/+vnRhݞ]ܜ3}Nh&^w)a ʱ,bN ?nw"mXY;H;JVCNoU C드>Jsg JKaJG|\gzיy:j^' NWG  &]c"_ l:gxZ*~ggev2eBpbJ=g> stream xZK6ϯQ#0D,;Nfk*Z@2nԻ$ݯ4i:m0qEl.TovwmubVk&۶q]e רNOn\On6/܊m4eUք![H3QgƵki]sPď'kyo˿VD,; :r,5r|ԡ%k>fڹAB:E3zIXǢX΋~ cSڍt@\nĿB2812zocEºD^4 %_օ}EmuW/nޣ}vsmz&c,_$K1˿!g_?!OHܬ'Kt7O0F{<5U AK6/v8M;6}m_¿J QG d$nm>M>9;m_&FӚRҁ[uYf*ugFѓPӋ"Ye]sgN !˳vR{,鐵̢;App~cU>TUHp.X?8-5$Is ik ݻg@Qƺp&n{Eݼ"b !}T:(R KqV2J8G/㧶lާ؄ %`{,  F DN|=;?^1Xmy8&i3rߝf;8RF<laѐ&gU41X2`@oS HnKHm޸Yaj.d R]5IKؕgMvA !谐r @sx;' ؄Et,Xt55m)gL8_8@)YhI`RaHE=_ .xͬ'$r`w cVt6<1.Z6mUOc/h5`rvvQ#ծM,9ksXęo! z07z4> stream xZKWViTDr%Rd{s}Y⡕}r^'΁E`0j_y$Y,Xܮd3.*BnO}a߿{+YS8KY~Ip+JWWZ(&SR%쟥4OW]ٯQY&;pkaN5|MT~]{٦(KWm~нwV6,C;wre֮au%J L5:%IJr񬩋cQyudԌ=|%c+%3/^쇢vo8vDžPORT/ut1?Y>4ת!Ƃ,[B3~NY:$N+&f~9߮[gEk"6~T"Ԑuy4&ƭQ(Sܓ~N 턎N޺Yi'UH}ì?4ESB(mv% >LL Jsf=O[o9%8$ǻw_kw^a)3Fw zP vդ }nTgn8ZYiyV{Dٔ6 8uN|LY _t-XҔidQxGyʧP~Md|A}H'RhT?[u. X3g15 ?^+}(P҈86px$ūS\,1nYr:T8A+LЂ^ )=4g LϊieBϊ'zVfgY0Ez= a@Є(@`Q3̨@fu׸$O*;[gɸ-&h5x&ar fSy/f'uv{xy.>̓fY'+!LHڎzG!ı1z5·Oul.!H<'Sqpc&߬Oo洭VB!/ Sfb뒷j_Vbӗd̏YG @<;Gxd~4,)rTE~T vPGYZI38ҏVmwǁrS*ysٕnKOqT#O(?޹L6,q:e+:6~QEOΎ (ypY苰hՇ%mt*j؍rb}*nиNvaWyXؕvm'I xsGpiJ vV.`BfJ>i/Luc\EsЄ]ȣ yd AВ+@n:,]{_J,*}/l mhۂ1r):%ސ0)g =q PRP~|?/V;LXmB ;qq*Qo=U:\اJcVuZ>셛7?lWJ?ZT1dwefuE/o ?p_!.'+-pHN2rX$3w__'ߕL/ oJ >k\ Ԉ) }V:Bq+7ԣ/2lXnf^ҟ HO^`3j4}#b*etpOzXYMWl-˱rj5^fȗ<h!py=[On ٲ{rI_xY5͑=xm 5? GͽjR%#%JƛMV 5z|(3hi SxonM>.F`]!B u?GH,`pv~<z4y^ex ѿJF,o tW8 ^vۉѦ NZ״8Bee `3Rtz C5GT 5im>ذj3x&\aWJqp.IƐg1d.̨|_ MKذT } g8=î#bS׻W.sv endstream endobj 936 0 obj << /Length 2727 /Filter /FlateDecode >> stream xZK8W؋9|R9d,M/j[v #K%U,i:N >DbWQ݂/~}ͳ^²r.ha#7_~?v!8KxBg0 ˍ3 zƽJs͸T2, zS^6>ʶ*JC^+f99D]VfǴ,]JP׳"CPjV6{Impai{[ ŌNh?9e}eہw<J]QY/HqqhB)̝./dGz7XzAۭMsYfjV% V"d"u2% F # $γr]E^;&{%}QM''e)$ḼZģۙcsa ,g5X¤T코f:ve8_Czc[5(ǿuGT"֏C;K5oRs]m^4fɮV*ь(X7JQ~ۓ&ߢ6|͗)IoNiTmJc.hY#I-K}}m/RLE3۫lfWsBlǾ([EE "ʱxX `PCR0 P߳cW2;I}2i!˖ʱ\(̟{PT>MB\D4tR`?閊BG; z⠷%,\%*v\ZY'7wg?ܻӃ9kJ]: R)M^yq4cV59l?6>-h|O " ;A_JAQ]GT/\tZN WC?$s}Es)hΚilē)隟݌%[b:ч 2݈|B0zk(HSJ0ǩ[*okC$Qu$fo@jWNT\BstMRo,ƸwO"1 @9&܄#LA abټLWo@fSv)j)@oIcЂ4mOD?b'| 2h)$O3 v蹼d"Q^24 ΢YY1L @-6A,>y tv;sx׺8:]&i\YH+Qmd/71S1qeb UQu2EXt)I`x=>SjwLCdJׇ"9=f 8Ĩil7ٞjSt,4WT#)|Xk'hNA<~o&\w|G 40Q\E;\%8P_]\mS4`zt}]ܑD. ُ+ZNܭbmafaz_\0_ԔtxIe !D+/ -ߨRS#TvIc@Xx"ɢQ ;`(as".H)D E,(ۢH-!ȘO>8h2 \2$ˀ+ -lv7UzA\[9[/$rLh p m FL)pttoqX2\PxGv뢭G-8p!JjＭJ@ CЖ.7*ń]w8 Ph9|ג@'X r=^tTTB+o"Tц}BM.[mz >u3x@۽zp[M3, * w&:@A$sb-6TǤ˔ @Q=U[lR`L gQ=9<( zj N~kgCM=Ug (>LLF†̥E.96S@2Ƿێ)jn98H&o,q;uozv5[',3d #eg#$?H ;5 3 HsL(cI =:;455܂o;?+s~Q͡m}ʊkf ƣTɐ$'4FߴIꔤaW fEfGQ4\ m 's~`ivi42Icf &'͗hZ 8?ς6D̓G ^f5̜vn9Z Zz>KQ!dՉ%~ J.p )+6]qJ9m.-NJp >~S #rʶDz-'[wHyJNG&{-wnB rR4 J8}y:1&-3rLVV[N;yŗXGlU8N|Q g&'ݱjgiC4TwVew0m{vQGLESO'qDU#w$_R 33/{I?.9J59wgXH7x;Tonx6}gө endstream endobj 947 0 obj << /Length 2972 /Filter /FlateDecode >> stream xZY~ׯU*+ش<( wQ& %ߧ{zp8y`0a>ot0p.d0."9wߞ$ V+Ra_g9.zŭVIgʰZ>fͭzyu4xcoz)o*d۲CnIч:h|C,l&94HGkf^GK7%i랿aTDr5J-A,TuT~l5kR{+3 )hloqEȤ&Db>l8Vu,6TG1;Q,K\z5or[4ǽ7GEA'a8d#M=}_mv v:emqFeX;c3iXh;.7E0ۢbH|jIիۗ&L7{MmK&s$#\p&/[ =v }j/|Q]d]G؇t dVHA 2^7pQ7Lo <˛[- )+蚉lL$&I#S.9I~r19 fn&gO39i2!1yy$1؞gO4^nޡf嚜x~ H[!&EbX;HBh42b!D&PrlO- Ug妡H~_[X191bb)c<?g]uBj}xYnMo}"k;15u?ls X'LVopD ҋ ʚ*`WBٌV.㸳=k$ٽJp,W)B5ƂɋIX2y5b KxNO 4֞-Kt"IrS$>ZzPPfk *Z9NJfӡv O] !QArՐ΃!tkmT|B3>t G}c7^8bLG Ǣ {K\},>P{YNTLǟSu!ZM)wG=p㯪c.G?:0ܺB'`ێ_èS/Je{ӆ. Ċ+؇:{,x;U1Ynj=w/X]> M:6X50P3#p eG`4@ ,:hOe|&=|'h˿bS;<6b};B7ۿ-2pwX0='',j|"3Ny zX`9@qo1ERȈfHEkR}YVs_94lѦDqB95-w.Jٰ$u [iw|ڮoRO'2/f=F/m@ƪYE0F +\0TϽ# -9GmCO$N0ޑNOAi<z{S6-C- ·[0bʛ m(CbPOU[YazOb~qc24Yt#F}Ξ癟rm~S[+>`l\ȏqR9X"?'Lj9 Oz:-uq|IB~Pz1E 2‚HC\փ'sˇHu*-NC"|P E/K\1bq&0{3Dq;T+O;NGJށ !e1H䭎U <)14Ip() گ+O6f\2eNyy1iàu8 udu~h΃<# &x-QMg_ vRu@7D&,w'kDE0l_.*/7tiJ| WCrAf;\{[ endstream endobj 959 0 obj << /Length 2481 /Filter /FlateDecode >> stream xZK-RśS9ksp&ɛp$j)IIS@CH묷| ]7oȈ([<eziF,w?,[0J,8ZPbY~fnwb- Z(bџ8Wo߃ԁtKx&:]]4űWlٖ}/VkŲ25TFbv0n(`kΉack6 }ϛ|ܦ*KX7lVk:m[lGb-v+Fy߆amI^'LAJZעaWNH˓M7.{*!VL-uj!v緆k=b)?E#tq1' gV0Y4Bx?UmmLmWkhj ȗC/laE P$~I$&cߤIp8ww $(]U\8q{e[cS@QEf{`< >NIs7 Ek1s+؝W@DD1ﯜq8"Ԛk* bI%]XAKC y-͛JM*a\1 m'+&tW(#~RϘ S)&[XD8gT{bYHmIHܒʱq;wձ0@asݴAg-5Sxуu:8;Az=cq Eٖy[t;ѥq5Ł5r;w+j|WM7m]bzz@>VmR.bD6IYQVܼl6 `mFC1)z |.aDt*x}>x#~r f$qk?~w䄊d:@8$+<3vē 3!e7Oȡ^#D<0$a/[;rOC䞮O`sO })?{Ă_eRrDNEqm[cC4ˀKV^xjzEI&ƴj>/lFAqMA!y/ER$jSîEuPSTf &3TpVj.*2&Uٺ[ V £"\EtJhRG}vd!Ņ"9tDܤp"c\vx&ɯ.s}l!AHjs1Qe@+/8 jim nXnܹ>4ujMX,vIN.bO'!Okeİ(TZWxQ%V>%F9P31\]ۯ(!1JJ֗IBG;:*v(} *~-Z\Ut8cIOWsaN!xq-%@WPW35*qvBaY}rU|f4jr|kna@/3H3tprr;Xtm W[ cF{# aPsC4"5%E=>A"-m @Y \LꯠKWci"aiin^8~9*TnCt ExoB CRW l+&ڥWB1s&qvGg4#й-'}x]XL= skfZr0@eS9 IV۝K.t.ok7]P]gt)9S[ͦDދCoE($=̍<{Py ‡ZaFTax\9S *G98jͮ_ /B^NP햺I뤎|~P얫'+d"M {Mdoٛ'WOI6\ SVj8YGѲ3j]]>.{H$F U$MkF*Eﭰ-/a6Ȩ1P6ak P8C0I/@޸?/34 ʓ2rH *=܁s$Q?δ./hhG`Yoe0a Io}' endstream endobj 975 0 obj << /Length 2421 /Filter /FlateDecode >> stream xYKs8WR qWvo9LyR٬H2 OAg==D`6z&2ngw 7G}QgȽ5-m7ũyPoi TG w< v\ A$G p*F`g;tjuijFO * \1=n?8; *8ѲkcK?1q]%JmFGAD1{'$qI E!(AG&ADA@O֘W% TD^椲ʸ$n"k/x &vmL!BbȾL%= !*i*{r#FNǐ;pÒ  uTʹ`CNcN!Yr0lK&jJ Ƭ0qԝP"&0ܗ>zk⻹ԯr6^L("$ɐ7fj%߾ҙ,iFhLtGlL*, ' X#"$x%L,K^8pp&HҺ Ht MA?#*=se7",S /$ yM16unlw6S#鮨lSi6Ij3~.La}[l duMstu4JT> p/C2ePI[s{MfˉLF,K_vP~~u ?.ĺt`{Aُ5[aq, |`\I01wGoh$G6kRnw#_teA,ǃuYت+xo;'-"-+US>ّ1禡b(zRBK E] 0oenжe@HqͽňdZ`^'`iG7&_U|k}>;칊L_^gr3D(P^=(L}' 5b  ^  )GE g}Ve=px,1g02J0(pbVSS3#@@?ڇtlrԣR='juO#fwXfuH1þx"ﻂSe `84CCqƇ\.F\k7ZQH8{w"ʈ6^F,QGo-IRyTJr`ߨ 1}G$J-&>4moc.\Ʈ۰,mk8!R6y{܋/M/szێ!>3רm ml4C>`R%#o"4 i#Rlc37z [.iirif`*[^,fPԀ ܏iwyVg<@>~aaƣ8ݿv[%;drnwҼY-pI]}Xk@'H~ٜoOU"?b`GӅҜ_3o^wx endstream endobj 870 0 obj << /Type /ObjStm /N 100 /First 887 /Length 1957 /Filter /FlateDecode >> stream xZKod5cvl4BHbZ0(HSQI_F({\.*鵧z=V+NT{SR熧&Gz"0 NX FK$^DzDcSh@OCݡ'=N K aC#t_z /$!9‹d!cb(6J/S-Fz8ĽpMR&,4')41dAO^){tнL/ =aS¹$5`@gC 1fjX;:MP=&LI V.srdAҒ±0СOZ fX` =Z} ?+ =/KCOOTK S^[TjЌ^P/04G::4 #@•gVIMF++iq1!%tB{CcZ&Ŝ<ݜ/^,GIߥ?Zpb^G\׋?~PV,W6x#,^!뛗 0;1]'@˹}`m'2m-z6]巟__^ ?eX~[WW7)w뷫)O߬~~_22G5F{s pyوruˉ¤͓O>79lX|O?' ˯]6d4l8R2xrL2-XZ',ntW2ֽ}ŜP L@,2⬝ .YnY:fFc{.HUHB >nM:5d1n6iƢ1a \{;&= PSdI. !Y,=b7sYy;>+W!G#ɀZH{( =-U ,\d c;=Uye N)ق>*9g.M@ə{zʹ~{9) Q0Z?Q`'ahG}̘,_ Gܫ6EHyT"]t&*2b^rlY#DW2o`CN͌Zp&GASCCH endstream endobj 991 0 obj << /Length 2553 /Filter /FlateDecode >> stream xZK6WrYʄ$@ؙ!:CNr$heI*P8|@H7 |Փg,4I5e͂kM(K:a$erq^^, ~0kqAOhX`"DIguz) I9o7yꇌN:Mk$JvYƌSMoz+Fk[/Y}E Ų7.л)OX˘+<~.RrQ, o/,޹I]?cc$(csBOWJSVk +[dBt"PُbR(kڒ;Ҏ;$I1UySe;m6WvUG^-9V؏Y&Զ=W^. MXz\b 5K*7K<*D|"C(=gi= (gPcR-ͣ>a0caRoւ[]YЈ]Ta8]EQ1 N"LWcXHcz\cO嘓 |}!G)ׅˍm6υIL$GLp~̲$ut C~izeZӔ\ FK^{yXmELrҷ!G3%?CUXfҨ dѝkj~VsV8x/yBK/JX\Ψ;Yn{'z=͝9K=xk3f^M.$w;γ:UgS5Z ۰ pށ־VPu7jm*[H5z3/~JVL&OMmi$O` >%* 8}yQJ&{VO?Y|Wdps\/&n&f $ @ge`LxO1F?9Uwqݣfd&o$/1<0/ŕ)A>L(øjVyM\!E WD䫝dai-YDX쑣cz%>iS "Sa~a@ d G%T8 / ,q]woQO 0)ǨqZ_kq>p_F endstream endobj 1001 0 obj << /Length 2185 /Filter /FlateDecode >> stream xZ[s6~e >dػٍxΔ STHҢ]mI87;Pb\zQ,n D.$,>D럖R`g34 'tk0[.+F.VL -_$$~!‹_[_X|Xqt˗DG*xFy[ol;  x2NĒQ#H˞ۤ TDUr =$0_9P}R0;fJ(}Z5r0e` {F 5D9m05] Sy O9:.α?݋uݓJNׁv/D2C(:.FtU+lvq $xHU@+HU<  F>:] xJUI PqTwy$ ~;tC[1FmPhsB}V;tΠzulu"L&R>iK,t_2(U1nڛ"Xx uncV fSԫmkQ.r$+B53!8o Hk8P?T7xpry#*@r637P4;%̾Hw4 vM?(pLoqM lcaWNQ *QcjTC LUPo*v1L!цuc>eV:=Kz{Fo.nӝ ˩gC/lj Zr5gi_lCtjYn̿=}^LJvobmӍ&rc @=!8 }S[ <3aA ܳTQQP]ux A m%aqc9)S=lh3xT?Nh&@;um9%$ux%WB԰B̤uV;d3TtABeEeS ǩ;Y φ\gzLo;RoUaRbGW2h?ߐR;pu`FG31I!#> stream xYKs6W-*Gű]ZoR9$[G2!Ek Jl& 6 >՛iJL0YW4I&b$W/~y>IV#0J Yvf+쥯61Ž}U7$Q{ȝPT*H աx{pҜTHuEtZ<_eS<Ip]9I?TWY4a)Ƣ=NΌKcD>Z;5x茬NJ7q];j1W9"4]mCֵ(uu OvAbC4J/d9z AR#幺fG ш89a>P xЋ6Gx#lɷ1̒&I,tWNXI83YxwZ % F@"×t`;/@Li#6ѭ12O(i†y`M;;2'tGf\:ҩ*ʫas?呈% G=?}S .$K.4Ä3|2刏{UyS~gJ%֏Qptsp[UBۣP5¸9x)䣁V>M1BX].F3"@UQV]$礑%OGmh7D 5_~x8@!3 yaRjhq|y)9)9)btE/}kэ?`^ yzVJC83&ހ=~lLyG/0TQ,\vLY-tuO]gW fM(0mݓnbřxjL)tNhug@#7g:b$'lBͺWpVY^B8c#s)2u ,wۼ;/<7(4&Dg.I,TavE&&i!8 _52xnEc@r(ɟa'O\!m/|vz^3|S $FK.L@x#1|A.s endstream endobj 1027 0 obj << /Length 1831 /Filter /FlateDecode >> stream xXݏ41'!pCu4)Ize{7]w xL|ft񰠋o^}yy07PF3b\o/~ݏ}1 Fw JrWاFde+Hj]Y$ͳu?TwfUY?4[<-Մ|U \0ym=)6ɉ*S5."Ӎ.͊cㇲ][rUiT撚1Fx썚f[uDI[>p.;0s+\q4U$[X1-J+unCzWx]] |k}w *ggcM2f0UѧXP>tդ UErFPsJ0 x*1'|nʮvHXԵkq]\]},1^,@y爾0C2|Wm^B)1Dd1á*Cʶ¾I[7rKm`t H[Y!(ǮG2+7zP)|R"<4M=ъZY1#VvɳCM^ tKQ㶋DӨp=.VJnoXMj"Yi1It \2;E0Ob˕etTr#`=TD?Kfz=հu4\6 .EAZ:WKO b%]%AqjUccRAC]?GM!^?4>Kf(ȧu ByiHK_;HItA݀röн .u|丷Pſw}Dp:xK6Л؈xۺQH䩡 5!<8 4+j*Y8U_۴-VP\ Eԉ fov3ZTVU 0eqOUKТyWP=dr_ *[$X.οa1} &+F)mT?r :H@t۰μk !a/Љc>qB~8 )`AHvǿ4TeJhs;\ۜ˗'qyV$.B 0ۨ8OfyI-qR:vh.^s;=l['oG/\9b~DT3<A|:/_I83h1;L?j{r1XR"){YcGt=Tj¨Q[wӺ OCE/;HTIg 8ckNAV0G*e3''Aݏ'`x=[Jexs?m)9#z]* .2ORajg vℭ/oۗ}zuOrKR<M^ń+, 1'0q OeOXB [+cG(rǵǍXF&^PcBitM4|b0'+ T^^M Cz:ntۨpu*;wenf?5&F(]бMI8끟A(*=%S HMEB".6}W# endstream endobj 1034 0 obj << /Length 1924 /Filter /FlateDecode >> stream xڭXo6_!e60$Ec]u4ЇdvȒd_;~Ȓ[x;=]P|y}< ?q[#U""ύJC2WNVCjDA#z$]J .s]S.`e('bʢɺۨuԨjf`BIk'ܘ7+9ޗ[` HP A=N(ޓ Y1ȾGS"1V qcObN_lQ &%ۘϻ\6Gh,a2N5p "M?ڡI-uYgfKhuE|T"WܽGh=@'|?{W9u^][+-7pڪk{*d, ,WEQ=.-2m>4p"xhࠈ|5oR02k3lO/T%EOzm~BywgW\7 {wujD<}Gqgr&I:1NCTޛv\7.&qCY6p:mξ%G؁ճ`A}yEFyCR՛D'~}:u,۲~GNB URܾ) Ntse-֘^igIeS:&azQSq q}tڮԸst׫ŬitV iwAzHFyqsmp  "T:n׵v8WVﻲ G=VBUR~{-G q B@:rZ>!j6k!y^N{]"iCw8rh;l+̣J6sPbߦFr1.moTU(QkهSf`+`|\5I-oZYѰVUX'*\)3N m]([E/l1m"ԛV6,Xև> stream xڽZ[w~[ $'Imrf7>%y%DjE*}g0o,<Ap07C6b.xu'&g<^v<,1jв2.-$P&ZL9jysHovFLUwW4.h+[,I3wz ?  -۶jjC' dqj'0R%wzK]s-w4+S-Kvphgc<S :.e%<βQy"Q l!6q V!%J(yh7֏Kѽ]cGiLb4X P+؋jSO1SD ,C!fORH'}(HDP2MRf0xOL WNSz ht&Hcl[.ôM0 FwP9ZeU@,-S}n~8=r!!P7escٵnVOs7oݰ܆T ȾzPS2e>5H9?tZB(63&+hny(h;woف +/jʲSCwo -o%Ciڪ=N^)z1q:z?}Cg*˜$ʈD3o"<;|O?q@hK4BѫkDpMW@APS 9 EEM6hr&.~l 48}aMc( ܕ3D: tzp\-T݄zpE(fi3rw !bPSnݐ lWTkC4&Mr3-,ե.˦zfv \h$LП*P֓Zdq,$s+U% VJQ sP]WGed+B;Id+[MȞa8i^O3q'%2ȻeNd߼J"{&NxO>Hz"I!UP&D̦6PVq#·)(>O! Y- }xuU 3󐴀2OrYa]R>Aݐ( 6t1@c.`vR4NۡV 3VA+ڻf^MSl]Jfha0KrI]B1%̐9ǕI?Ǖ$2>; *IsGIvۆ~ G^4{W8>8.)o*pƒTϳd٘#*Q,QE٦i4LtЫNW  ƫj}Hz)nؚMQ& [=د;!nd {DIGU8)6 n[jCmu1~b)xf ?e {r&X[ԍL-!cqWEݵ!훣C#dp|޿ۙFD 9UcbFcA])x"I lgYX.h-&}GgPґ&o^+v-5ؘYc"nUC1\@Ⴁqhסd۹+#3WYvjZqđ88H&3OUm0h(/{\) ș T'1鯔yx{BKk%= 񅺭:YDw&E<)pp< \{ZGۏ=x ;M8vqg>P)6t\psҘG3{> * [vWpb w XqLCG71#E7 a^ȹzk lv0 ‚yqmN.3B>gG6{Zah ̊>{ PW;>ĭfUEi s86`%`cU@k1 7b_W+ Ga!q0r&Y$&wK!&\K"Q͓Ệ!Q O5TO-R 7&a0da~fS}R])YnfW7GJb33H0[\Urs0߻L25L37SHM8ϼT?4v魯Rr`Di/m\/>)sʓ< aF 4=bcJ{=>i4Dmڅ3nBv½"0`f&_5o ,NN2r C`mkFX5εv] q(pM 1,! 1`ˑ@0֭G)(F I!Hsd@7\_צ,Ncݸ6Eu8u?%[ ɖm?kvzW][:?;xұq0 kSї*SP:I(28(Ive=,v9~m oafyjn9{Yb>⤦ Vzz$QWl[}5p$s~URhSỳs`v~ //1mܓ䶬AC {y]`cd輻3=}$oOŨKf뎸[W;Wi endstream endobj 1059 0 obj << /Length 3542 /Filter /FlateDecode >> stream xڭZK6W|YjkA`\{pRNʩ]l-GhḢ'ۍ{sP@<_[Wlon_|֫$LW+$!j(ʣPIJoSW:;`iXUZ~^f#NwtPFC%"G)q]ft~Y߿~זE uPlJ*41o# {}ΌQaM>f(fj*'VԻhۆrR=![/U_M+~|[7ONYۏF 2ccXf]:dRUmL>PJb"8z4&f,kI Mb=P7 M^UKU](MCWqҐ ZeawE+Y(ЮyPXi AMMc)h18ucgPed; H*դbVwu1"oN(5y+!o%he]mu597hG~ȏ0lLS*EYS{BzrvP:u vEw+'_O~^!O6v),|"G9DOѴhx>E_ /YOe0oZ%7Z_p>R%ݮn>+j*M Oww>]`-M1#۷ilp SXd7}p.wB_`+CVq0mXIkcZ[dHA0* ssfoڸ,,Wca4`6y}gs@Q(},Q[[Tzō6P#)9UsME&5h`my_y-HY(eL@q#^#y [ƅpU))WGf`EV^Y؇S-~aL.ax5Xu5>oZ8NA SI,8z b)H 6B/Byo? @ ;emo"d(,|c`\.4 !aA-yU~U{ %eG`Uߋ'2߀_SM ˚FC%/ iX?A`4 {k|r@Q&yyKb.Z(23^Bދ1@πe6-D!! U[3]~wCmb_CҬT,*F4D8viޑ^i{\@B-_ҰhR"xB =ܰ eT ʜ%Sa leاi#bcf 2̀b4ow`\V}}o~a  .psIY߸8F̸O:LEG?@3;umv͔r*`<) v8Ը=2eoϳozG.ǡȘζ&҈!oE9-  gza\h=fzDoRHDb@Dpqc'-M H2OUI|uzys*U}Y}Nԍ]I hOG$S^{Q)>f S6ibL$b (kA(uj@S24J[h:xgdr'7ضضThIcQldq#220Ͳ]p!c9 '" VqS&"ǁ d 95i!.(nn E<{_ )/Lrft_Ӄ+?k2Fof 5.=較YBUƇZ>3s?r h4gջ6(zԟ-IЫA'Ɲ  i [v%RG:JBW,iq9!'g"Tiy3? ]v=l ΚIqp>,5)5YT^'K2*s|t>k'I1VL*Zc/mр $c-lGrOK"" i2`=?(0h溻P]P c(Qы?KTbY :}AVsGU0,퐻͊CC/~`BGPʀC*hRMc*|ZWG_ hDPɓ!V'-:Vw,.Gq{:߁]|>|lxyP̀YlOV٤K,\ij$-8?Ehe,"~|qP "&CF7bm^.2Ic@=xїOyS :b<\qG%5ߓu&Oʬs쫹Ⱈm[?"[x _Rcҹ".Xw%tRvH"N98?; ' jswڎL,T®9C T'N9)O3 ~mumKwT S%a{5$,GQ anX;nq+s̐| E~4X+1f6TDD ɬ%f"$x:fpa}C5DPm=3޵$(?]_H^<=*?,KvP*&C0,VrQ ظ+ uP,%d1@ӎsQ""^(|K9` 7:{(3QǢm6!o:hn6o PkI endstream endobj 1073 0 obj << /Length 3457 /Filter /FlateDecode >> stream xڽZmܶ_ߪ _$RJI.@uZޞ֋_=]PEe83em!6:5u̸h'ͯѷ?տ>p,ޒOa,O3}\*͡ƙJW7nSƢwj+5tTooL釢)MlV);U; @\סrߵW"l7US mWu7REW[ɲ}Kӥ$8lP4ie]Ixڱ\n 抧teE@ǾjTeҒjI-֓1WzPk^G74MՔfmaڎ釮*5 !c "Z `nL6ۅN{=wmb7O裔kGO͖gq8s6ɦo G*'p[rR& WP[pgSUi<]},ghNfZnXd'h7Z5Y̳6hV@Ew`А,d~ :vvN[^4I5RLQFSx+6Iص8Рw! z=$ *%)dz03og5Cx:h9aNlU3Xأ!⋪$h:3fd kLHqвR$(tsWǺx@}***ݓn 5ՕYҟ=~6hWn$"TvЖD"c[AÚOb4q:*Τ\L_W&` 2't >\%z7-b*2/fG12瓁f[^m=OWEF4 !Kc& G'-!oT)Ok֟C0_iZ; 𠟵έTIs˜8wW` "zoO:MbiGod= @ HEԺWU ͞8ػUT(޼)wf|T*d;G'bdӱ#' ŃMtĨkǛGl-m}* VDk㓎_ /2`w#CS9v>z@oޠ S֑uhlGn[|={VNҒHH;0S"@P1,+ofK/x SCzjD3,7Yԣq-; T)Q>ـ|:c,_/\|&VK`<ڛ/G0<Zιl 0Cqc24s1u^-JI)g'n <Z"KߙcH%Lw?6 ,I. 65[񡣈S.NC4\R]zDE]5 WC#5D&+tI``^n/{`sW5^n0¡jJ|h%a@g(s8Uqxuy_ N%X %!1y4 .pLpH-Eo鶭k"`fl-X=f-!{ޅL"L F&.QEoo="D)5 [UW1 i.~iZ\sPChI60p̧9KQ20jDb7vGqZAUȗp=4Gj#F}v;Ϣxq:zUn)4ԇrvb,j#q|MNJ4p@{nsȜaq6yu\'3s~饳-`(8K& Ⱦ,rJr}U(!CjIncRH4 ADގ5aw~,VLߞ'W!%3 m%Vr}X  @D=gu﫦DglP5v`3=yEZ&=Tٙiܜ og䬁 ygtҚt קJ&끖z޷W֔eGӴCܛ~n>@ӣ჉~ϚI~vXyԖgW/ RHQCՇ)FPGԊ@\A"k$pӍV!ZW8o2}. Kv>ؔݝׅ?\+tџ~~sFh%($}ToU t3/gW6[Äݨnp\M~DuglN^珯fa``aS:8)<Zq.f> stream xڽZK6W訩 x|d+I6vy7=Pa"e3 q@hA9n?Mn%\l>62I&D}_yMlgh,^q7>RmfiiTsӹd*fzZ-fݽj3mќΗ܉;6wݤo4B6!,*O!1Dt1mslbXvBY;Ӎ چ9IsY.>8P{as/iBC}ѱږ=6ZZq S( \ۺͭo6'ZȫJʧq>}Ўb3mZiw*fi>4fJ]ʪiťׁqJ?=Hm~ס%8G27=`.$X1ˠ,vdž 30.[_)K1y]>4|W߸Wom> eOg.N$fDÌK2'h!>r]:,4xs{~4!;\2xC{S|{߿E g[<(I`V0>sпҮ Fp]g-F:4"QHO.TO*SG0$TOF/?|%+ƣ9*`?d|")Etm KRϲhJNNg>]TIJ:]uRh ͮ퓧[yKL!?"LSϢJ/m+3H!%saL*(:\ !A]}'$&vH/X!-1XoKjX!őJM/5KCߡ}#ߵ)0lhc:sNۣ =p,KӗQ" i6s<϶$32Zz3E~@Glu.L bOdn){8t8PDCX>Z$̲*xk)KX84AӸ \҅ Ř%V5B|2-*7mfIU׫UiiJE> }u8kl*-KNL@lA_毘!3WArsW|JKlG I>. ۟Rv!:]++5 ξH8 5&iȅ:\5rQCbhS)^ݐQ<59s"_XOyT!?#t2.xUr_]Hv%<F|˫*5#8$4&[h$$V,getk>E.A^g| Ad")Yg*[Aՙu5 y""7ڱެ&PU>z; XeӫA(``pPߕCP)qVpG/00"49? Ny\ZȆQ!t$J;Q p\P5.+1ݬBd[dZ7O=Odo˽M1b; .bͻuPO2MY|0/Wkh6hOH\ٲhmyd`WSьI6}Eb7ݭ]̒,ES)&*Ư:Wl(OFn;/i w)~}7#rETrΖZ6ӃiMî|Ⱥ_GGȐItP%"D)~X/`M ?LCWp?~|_|Y endstream endobj 985 0 obj << /Type /ObjStm /N 100 /First 952 /Length 2039 /Filter /FlateDecode >> stream xڽZo5x>lKR T >QJ9AEUI*o|{U6$d"e缳|<3^Rh\j)JC_18q`_KA)ZW e\ØsR0HpPVL@p_NaD@`V!(H?H0s@ҶVBNZ/J6CTPsqJ@A[$ͩ*!BP%F$92X$9@3,YYj\?/1fn)8KVv'րjwQC{}) T׻$PnrCm!%[]暜jA%섹 RrjвD-u>h˨/,$`ҕ ,Nق n`G6p%&.I(҅2 EEխg%*,*C]B]Nu#CjE)jѴzl~NJ᧰_ƨҚ =ÛW_k YQ= w#\56&CCٰk*;ٞ]gaԉ; {? vkӛNpω n`h) Wp?8 כ.g_qoج@ϼZ~:Hڇ~©OO fRmo1EhVvζ48Hk_?ZeV믷oӛwoNpYa%:*""p{B ~W[nWa6_y/]_H\bf"tPO]۳4$JG};8,ݢ0jR@L56""R ѣ5ҕ`H݈II\jCqWpWb#39<:ĎX:VL oĞ-l0cxW;h,r!Bc'"/s{GODObc}X:XJ𺚐>DSQy6 QˀAƻ%z?LP2[(c)3K(̚gC(BcɢC̤=[cFZvys dfB^@.V-|Ն73ފbؑAH:3}5bKcF* l2#BRPF"@+NA(  z63 AX;Ĭ(CL7> stream xZK6WRA0N┷7=9PfTHʏx =\`npqA??{u,[(+ ,]%ݯy|Z$-(ɘYf8ukN#@_97]9 <7D$DPZdC2% (FO3lEdٲy=ÎG]9[ۑ"ӓ AXf'rND>`XlPnt>Q!H l=08vqwi2`7x oul$!B >}rJ̚S@/E3p mVT &#@.<-dCwF IZh6 ZwDE_T*sx6h_1D=nN8l BɊ5c_n>o*@t}Ec#,$8'.8jc1tFC6>ַڙTp2cxpx@`z3RpHc H, JґySIK7D *.'@LɘGTJ9*}`<d3Z*)Ry=VQ]a/J<._}2wa0g8JEfˁ'eş([;1s1|ҿy<&D6xvj+,f9VɱB "0Adkb,;>P.!L NR+G@Q]h-rn)(M#4?tɍ61G:檮ۆ+qԘƑ.Og'c*5Nxv"G<\o}zkt*X~*/Fxƣ4˷l^`E/> F>56&ryoR :[06ָYuYh$(I>CAirZbNB)Ψ"YƿbQSQ2h*(sO@׸6II9Klw<1m M'1B dѳD~1),*zwf+wcӖ"/^9$8h;laEp |6-cF"W jshǶp VN8 g├*g#<&?qJ}2R26wbyH1nYZ߆$ό[apejBeD>S|U~I *.3Wne_ttH6E1ecU~#Ɯoq{1WUrnCS:z tZQ^C"JS=ƐY0,립!:j 5o_1fUJL T$h\bo]ٶ5qé҉lEDe>&M%bFeDҁM<.T8 BD:_pw܀6F-KRpy Xp,Lj2C㡩's>eNu//ZN~-R" ͳ8%:gY ϡnȽh&4L ;iAϦi*]nڧ0=lDp 1{Ћ'rE>0!XdQW{Jo'"ʽamH%_b2"v6k~823[n鰰 bgV(aYmUjktVwaZݒp<;U.dg PL0.GtQT䓜N0f@PwcT=#!$DR`@ua^97}1#N:; Lh;EkLl`3P<KRA-1`9ox; _ Hw+ /ǒ)׌ޚ:]+W{S7q?j.|™<#d7:M*I$m}lC/ @!i$KS2k`{`S2`EBT$"IJEh6َX_2 [&_9Υ<Eʐ); zåHDz_m +m=fڦ1aq0ܖޕE&2-d؛.}XN9(UʴJm[evM(i6~&䩂+laH9a,׆xj4̙AO@˧hZpAі>KC&_ڐIR{}??/k endstream endobj 1097 0 obj << /Length 3045 /Filter /FlateDecode >> stream xڥr6$W @2[{$qjsNvh X1Ӎ2%8&ho~zp>7K".6ME `7͇ݯ{LJ_GFpfKbItv|s'nC2ͭT,֊wM3׷JDE 5[846vL -r2YE$py9Sq'emmJǪMZ˗S;0fB5gB0UfuÐ%:99?VM֝ zu,>R7m֘=o>yZm Қi-|Jīv_ٽaTV W5!@,_Ѷnk}V Co=~W 8 kL*vXŴ&|a׬l"n-s#5)uw'C  P]w4?k$G$K͒d]U^|b̔;sv\͙R6a" j+Vnۙ3{X@5YPnc.,O:P@CoձFҀ.f]šI~jOx4qd_nK\C$ _(f"AK Њ80)5'i>(~ݙ(9)}$jv,g_>V=J_,:ڿ'fLaf2 C>"Vt4϶0 jwz0/2X<6@ Z!g"8'cr8*'skƴO.J@0,D;SӲsg+<=osi?n*>e-)\Tǁj;ZjZ{-#MV a>fG"degO%Bw6CrXVVbbs1* yM40gif;1lN 4E?H3IJHAȸ<-a?;P5VWӳ.B5!>dڌV!ɢ36s S ZEAW#4# YΒ7%P]T͋z ًx=miiw3.=̝$tXBȝB5&lr@AANvU6C5+ L*j󙌴ʝwrdź0hiٚ)D27zޙu\1 {D* ~0xdda4~)MDa* tkkzQ0 =4u`~*+j ޿kIΉY\=d4A&ZϘa{bع@G^46BBG3 _6!ԪkAk5N *'$ ĮcJ k3 Gs8>gm7)O<oe*5hAy9@l HZ<̄u P BA(pBٚ)K 4A.tנxrT6J!9>l"k]YS%|=B0QV<њ=,-ҧ9% IתxT"gszWGCz=p1R)fUC΂(zAro 渙̆™R9?מa)qkrT$ -M6;g ;W/Zf,I;=9]^I v% l܄Ma(3'kb jcX<굳**γ]/f̠37 f*Tvugk[geiUc PqV-t1gX ʼnUTa'We'J( QP27>$ 1/$|Q&LlCﺛTN ߶-p2a ysC 4L"ǝlۜ.\R#e1~9sl{WW˵1 q>LQw&ܻOj -?(&-0*m^VeKIOJ`@<T41>*@u "Y( 093xcUx^djzsIm6XE"Ģ|eCP㿁ʯ;Neewm0 X0ӃPdzaj>+a5ػZ Sz=~4.%q|N Sʊ<˙鳝W1 ;,CIl,+PD1]9'\UA3_N>}6(ngVs Њ]U(i1\ZP2-OT/2c[Q@,˷d ˠ@AZIZ Y 0azz:ƭq,6ԒO”k*fml;lJ7c2tHHjpNz>aB|T{9+&fdN7)+"f%s7URng̾]c Km|XE#./Y{ 5݅2@q(]#۱IBm$A_[wPV(XΣ5}X^EF9T q:͚9j>j0-gH`rcRqi}Z ׋9c(Ђ1kkpﻦu=$j+ xmai\3]'`(zg4R <_Auxjg*yS%G7 kW\ë17 q|EZ/] RʞvDloW?=\= endstream endobj 1102 0 obj << /Length 407 /Filter /FlateDecode >> stream x}S=O0+<:C$Ā0m#Ip'N*RN>{Lt4D-bJ)I!eo_VO{LB@Bp<O2uBQ`Da$ LQٕ6涨6S1Ai Q&h iP$A!@W=7x#iv[o53"N9mޙkzt7:'#` tҢU~нpk $W:e@%Oy=ugΎ:R{o{MaA߃clM} \7A|` 9:yo1cv_wFW@2W)vrnw"Ny3';$w endstream endobj 1106 0 obj << /Length 2324 /Filter /FlateDecode >> stream xZ[6~_a63_nlMMf͢Ɩm!Hr_sHJ=؇M}<<΍:Z//^`S5Whiňnt9:~ʶm^O\ѱ~ JW/GkT:bxo˦\vΫw'lmFG]o&LX?{%9d9uM@-^E%>qQסyA3]Y_Ł""ɻrOظO߽t-K:FS- )DxjuUnE7ŦXgո 0 C۬nٮZa?8CaRWQ Ca0lF~>8 8;z΋ri_/bE5uѮBo6aj_^%XL'1 wj<5,)bԦ#:X) )Ң{1uƉS d-'CO;F1'CEK3TpZ|)u=#r2 :)WاOp0O"mVn&U7qQAЦD9nsJw7d;e23*A%z?p2[P>2o1V>zUСi1W0]gN-)a aq4p?6;OI`<@q OOS {IDES |2.*ƫ"n?xϦ%j# SRJ<Pɷæo*찷Zmq3<,ʛE gn9ڒePM/ro'Gg"ܦ.Ž0~y*$yT@#f4i @|g,N. 8Ő3\2H#{YR^$Ct)>|Icv=*BsNѳQZX*We5q\iHQb"v TLlN2Ug9 `"oT&[[-B  ɋ/"͒s12# BRLii5N~ %DLɒׁScJhi´@DD6BN&t] N7et#z2#_wWEcΦXbp0XXխXf_9)vtgn|Jh}]>\|!`!< 1^ .:Yw@VЉ`8Aލ }94מp0"08 лN/sa+Ж5c@n endstream endobj 1113 0 obj << /Length 3631 /Filter /FlateDecode >> stream xڭZmo6_藮Z;8 =A \>IʻW]i+i ԛخ^<3$[ݮٷWg9Ij_]ݬ fe ORVW_~gIR-YZ~58 %y"R:qFӨ>oNuKullLs&I]]phҧnwEOlb˾>R M|`LsZ `X"y\HsMfǹe8-ࢌ,4K]UmQ盶謹!jf"aDro^5H=^@œyׇDɳt, >̮z+Z`Tbevȩ9]]qAY.Q^s bf x+6;S;adS>N*m?*1 `EF +_`rMO!9M>d9[GkɃ*1NS6'ݺ͢~󼾏6LgvdbZK~O4sTb 5W'ze炭Yӭ*0i3<mpWC2P-xEٴW_gc]+B+{ҡ.0EE{ϵ,42huXb`L%C6+]9+[zλ]p=V`Tw|,6W 8 kw[>ۂJְ9uK|]1e|hP;Xx&D2ay!p"/ 1\CnIn@NL]OTl l]d ǀp="w[d SFǯHn:  ȘhWKn9 UVw~bW?D0ԪUFRr i4뿲ÑV7Y G[Ͼ8)l#\ЊB`A  x+@]޽1L"p*//a ￋTjt1v^s^>ENX~M#NB rG"z ݼNaSh|ZE̮'TcPT!3{nQEOkx;h@>k.j8\u s%IOCgz}SgtRol9jfF- Z@T#@KQC"@MSU&%ɏ7mXBEhҥ%ؾTPጞ!z EjsTԁUٸ ySـ>v[RTZa1uU&`଄2zo ^?瘳hr54nc^st(}@ $(sl:oZz W ubN8ẺC!Xg /(پ*o,)qA蘁E[XYF%>78tE@CX5=BLB|^Ҿ㦪i$^,۩OTIg8͗yB/^!sV#yF5#ڏ!('/SYlij9M",tU<`M , D5xp$`r*&YB(/` 6Fţ"HJ&Y[>ŧMPTF cZuPLt] +qn Osx@U(r. Ţ6yo\JiP:qTtx4R j{~$Dp ƌS( s!*ޅ5nfȤf6.ᩙY6/:! l^Lw(rF H8)l Q^g!ID1>ΐN2A;Х]dSߩ@2{j)<# ~ v̴?ތ=/a[H+t<ܣV&  qy 9I_8{dQ $P@}_Lc3ib~~.Hɯ҃XZGoFC]3+x3ڋ ;4w$Ofz9[9“3jmOxr ;`Es6@TpwE H<J&D!l}ڷMϨ dJgY!8sk`A<qx$M~@?2|e.wBEX<'y;OVBN@({+w0px&4X*.L,OOŝ_Gd8'RE'K<K8i`Yѻ)zKuw/.oQ`+)uBn7"?(b23~SY>N\:2M\?xhYox{3B. ԄI_/`/:yP/뿀Dds@npڽ=ga\$>H">61.+ YY"şuUExS]V5B޾ǻ }5׺B}?m}Lۥ|LpFyW/}o8gs(XMN A߀ հI t&f]Mb2dvnbڇgH<\lP{Zi8gPvJИTt9t|SIY b-!9گGjpgYD endstream endobj 1119 0 obj << /Length 3000 /Filter /FlateDecode >> stream xڭZmo6_~ZhR n]E6E EOiG[JfsfXD?(j4ph"Iijʢeĵ&őI?^}u(IiV J]5. 4b@("cen.~F xmDHD,Di|o|cR(%icdJ&"R17vm,/ ӿڲ/HЈ4I{K P5N֤J0 Pd)w}-Rq5[ntlWlּǶj2S=4%b <9dqL銮f7yUnLqC Ƥk_\ňYUBND޾~7ɢѢ(- YgZՁ{yb1 BwK̋:LJQJ*R]"ȵ`5V.QHUO؈5yt+mz,#qP'җF)''? ̨p-m(شC{#gmS+CٰḺZ (]%!\9#jm|0&Ѳ=u[|ɛǗd F4 ("ZLJGt,$(ՒuE)t~"CN8?PK,w[=R(d7E]b @g2X'<Ȑ'HTE7И,J ;>e %?F "#=1.PDc}G* LD{:}94'RSh6bJϑrHc1s9:/Cf{$/@Q#$s U|B݀7WKU6EB?S?oCj}DL8-AͮCi{ʝwR+S؞A %n'_$`&KK’D{&T?5XPƄI_ 2 fS~ mc-|EXyz-fխ-?;HX nь{ >"Մ'H7@2BJP3Uoq$2樂@,^;#@UE%Kt~WVM\Q[q^9KB'_Ź5'O&it 1wc{(-bN2;,nO;,RŴ~117nY]nLo_]C1 1٫JAژHE-MfƴA-fH$Rղ |_! QsxpÅ$\& q@&e{mz38Ld3n}/ hPǼ* D%ljq3016si0eG][/qs /`͝VS] na-ndpgq(>!]j; VX!ڸŁ ^!&A)I.F_Q/ :~Ͽ\Vu7@&d @Zzkn1Gh-+~;Ps#3蹔HM\;w%*? 3L`sj;>Y./Jt<5jMeP e+8- %!^Z$+ k3%xϮ P5E_P|6 o \ٝ VOZV]^.? DҺFxfSU8yָ{e?v׏uc6VJ/[l"*f=FF>'kme2o2Vvg~iX4% V { fBM=mݭʖ==w;(c(ۏ]Diϔ[ca`OD!Xp50n Qve7=x{y6ްv~a怘Wŗc?u=ʇ잉~?F6dun;V` [m{p™E'}v-m3CVf?d O6>ڲ\Y.mZ/?| 0S;[w=,eQpǶVs 0֠ţۋdXAYѠJT?csy*70t}(B-6ξw|)N dž@hON"[ILBN $Pbk9G/I(I>Բ.w妳З+Y'D?SH_?U#Mf/7?ߩNH"'H30Puɰr'sjZsLg+#1 endstream endobj 1124 0 obj << /Length 1390 /Filter /FlateDecode >> stream xڵXIoFWAT[g_ZhF$HR%,ɐ_3$a˽ǧ/GG\Nδ2 bQ&2R Cxt1>/~|~əR`F)F8H?}8∀@KV_p4w#M˹rܠ[(6*d$N~ Dd]W'Y1K4?L֜3Hp;]@6!ڷu~m<Tij?[otYi@xa3.Wqx8@B"(2IXd`F0I"]mGz1;a"ٵf} ?94?&kP $8Ɩ}eҌI_Ta~|78v$W^f]vNo 2,_,!jj;VDG $~[oeQ:nWcwMe#S_MbMj iI[xVcc'NJczVeSu^ec up1P4=Q-$ "kD' DʏV,=YBWĭً€*T]s'‚\ fpL?>})ʺaw&MZ䞺h'ȃ< f-(#w0>{B(1UdѹB(P?w D9 |ݬ}CTȣ2t],3u2_rT]W~ b3BU]I6(C=|Qcrh7D]mh<; @8ԻA] 1ʶ0ܝ(f)y 0Ҽ39[Z6@` :( Ƌ#ezVVeԫNVv(yp#<|o.NCwVxžR,m (b> stream xڭZmo8_a}ԬQjvݠm}] ْ+IoCz@E gyVpv{xC\g:fJY"&x:_~*rY|s_ Y8sլRL':Bl.SD~mw!J!FϢaQI~\"l&J]-/yM&R;Ӭ מe$2Ew:G]~8pJ |0ﴯϷ,L۶V98A16{ɗ$/_[` hOYIW)@D PMOkazKs`XJɾi`g=D"5l&:'7(iݟa7>RJX@ 0h~fiYIU4vXYFttix}?fO&Cj3znb+#ncwR$)*C9F!G4qxg#S}(8u{6+٦*s"ٶ*K(.=,hE0rQ K}i(JA2B@spd3i ;Hy᭱D0 [@]l 4}u7uX$n}xhZԩK"T'RlrnZF3鋑f"ya>P]Ąَu8 5F҇^R'rӒ́HtCqDY@R論qV)1kíM1c&qn e LEѾ4l3UXc=o@VE^Yacڗu,Efr1(|Q&k"PL  `T Cbd#eEa@'~&›mxq*WU|,)Z&X챻Bn-t|B-qqf:.b^L.LV\{d<6ՑcI2in"L,HIP G\h6~~i4̇oAƃzF x B=)NYC5MC ZZfdaPx۳-h&I?<냗~n2`fekEN {%.(05Er:-xR1C0Y*t//|ڗ$^;WҙӇzpL* z=S+-qZna>dFq0t#°$Mj 2`bbAiڷ&¸oUQ|z:|. 1b{_l ,c2ٹB6W;9KYHS&D ĸ^OT_B| ÒDğCգBXHHB(#P"tTX ڱ>wU~teVܧmeatH?R>Bq(eC j92+UV4f5e`, E4mEp;Z@^`ASgZ|^ӭ4φb&bu 9rhy̓E `S}tfGw4 8f <,͏,CZcrF.C>~Z[0Owc%"vA+"kxrҴu/GFdm@TVԳ6`#?Q|\||gIr^5[^|D)Em7aDqcJeGLEg?}H_!S6UcTϾ/aM6'{J0 +^FuabȃWgr%bi#u:0?&#J endstream endobj 1135 0 obj << /Length 1761 /Filter /FlateDecode >> stream xڭZKs6Wp܋2S".iqLͺ$GS.H=(-I $.0, Y\]ܜ}DpR7*.nowyۏJ C3нy^Igr}7g? pB[(ng߾>R`iM6x,Ͼ4.l|jVHGvTƙSyzf73^&ӧjG mQ^^ӢE1eAhrt_ͪqE2#%XУsi4I?!8hz Dˇ|rz6*g0!f~n_Ղ. v唶Ռ}O0_QOͩ;-"u^ b4u8 < Z+u*O;ԴEqBX['e4XOF͉I* q*EJ3m/ʫ*е,A?d*zBU@۩&vQL]$/'>ι0CLarty#*Z:%8 :# 'l9:Y;+Y|kާɘ9m:ʣB |RjCr'/q`_C`" Pn5wk:NÅ,<;%3;մ%dGKC [ BIaHvЛVɏެSt*|5`;b/4ef6SMəj^Tj{)EYP,\NKSp@tPA٨k9G$=s=->_i~Ӻ&kQ :2"#9R J0jy7oiuQ ΃/JX 彐rBa#',z*ntzbmTfInʯqHN(2v`<$4Pw6_)RHVtwshloZLEևw*КO<5'V<m#8 M ̛ߛ1ɛ)UP \RV U8fK`u endstream endobj 1143 0 obj << /Length 3084 /Filter /FlateDecode >> stream xڭZmo۶_at5wR.0fmm%f[$'˿9$%[/vQ$uxJNn't׿Z;1$2Mo&BHz9<}r_0J"قr,I4P&0 HP9O_d cM(ܻ k+5YO>]y4rHsF0E _3(mcłb(ɞC_ AQs1$4bh./.gln٧d=KC gCB|qFCAG@Jg3)'LD'P 0q:yo5QY@ÓY1$'k?r=/D˳6pn;fk7<Мh{Ӛp3cflq5cv}'; Jwh&rKgCr"n2Vo19a7Y{ivzCGK"PS@bqa-CVG+ ѡ8ۣ /b=ON!V$ FA: *0ÿ"_/¾D0׫7M/)7iQV`+.nw n+2ieUt{680 Ah(тwܐx݅&[\fy=YkW&.}!۵bŖVJ6xgOYMW yPO٦xHZ*EmY+of*(ikJ"qKu\o}<'$DV^K|?}jQ*s }xy! ꎳ &$1ۈNܠ 븬j8oy-rf.Vz^#WXq5Q} c0K|'X8D{^7!t)% ޭUW/0*:i[k ,M/*xuPp.hdcπt`sDKVMV]_4Pd;!Qr 2D =#hA_̈́"QJ5bh{ۺv$!<]9 !X<4x&Kg[G,'إ8rWN0/h8fVqaA:L[bns0L2h  ߟА8a(nZ!6C&^\d;ڮn2H9 ߆2/"xF0bcdE(`.uQk5"@zFבxZZxc#wV!9 %< `OPrzPlKH TPOycwފ,2tܯ"4|'&.B ]=7 SAQQ1j8^ u %QZ q :˯v9EGB,4۶:?;tSb. ,Mv$IU}⁊.BeRyt7 G n"d\}Fu+^6oU6"36~b@t؊kK)ČQ/O@hxmu%Ϋstt?@y3+լPl#w14ˀX#QwG u_m\#fm@+vBȺSxHx%sMHq(u>KUl¿6;\n릧7:n) ۄxU j2"H)YWZ86,1"x}_HZCmj`ox˫&˴Ji?9S<F&1縑yǍOXwH$h$9z FV=㼑 NX+>Oh\UQMCUpr9~0㰘x&hs9#{6I%,|`)r:?x  $ǓpQ~cWf7ot[59~8^N# endstream endobj 1149 0 obj << /Length 2197 /Filter /FlateDecode >> stream x՚[s۶+8C3%i;^I'*ՙ2j*2%%? ԅBAYZ `X%8yy $MR(I!u{՛%]>]ot8z#~yc iH"&m)ޖxMے5 kۓm5Pcy%$ps4jC eשW*-ʳxZ&W]Lf^B]7D a-KguJW|n)*zЗ;C#dHW%=ND(.{?W2}̦ s|PxPk,aV?eE%xyϳj@;yůIܽ6+W}p |D)M5Qг]QiORwmuVT!k$J*E^ #h7h+/+X`ZGA&4#cȈia*3z.oei `}h@hHq 3̴P}d@\(EtdgmЂEaT+5!ێ`=jA nvN !@kԮw8#vfyD>Ok GPӏDQ^Eo/l ~RWiGSWb882͛_b^Ok}\$9^XHqe /M%sZ~\ǴX>F-,JBMb 4a3ӻI7 JZ#)^jlN $MUSfKٻɫEttVݶyy K`Iwn"rMeàa{5,l?Ry7_e>5mٚ`\0v2ڀ;? lfRdOh lO[.WHGOYKHj!7lxۦt ?]UjF̆Ãׯ țYqP@nvC t"k:hkb($iDAɄ#jﵾFfG8O/BD//N_tub4cu#&n1mb09wj2rj2#m:m:KɢVe˧dd>Meiiidt ~P6ڦJ<q>o1䜏)ckr-QI؛D;R #y.E6]Ҳˎc hb&-W8+7x}(V _LC Zwd} juم38)(ݹ޽>m8F_ &FbTS ޚp㠭F+\C9bpUW/"?Ys{uhUE/ # #a(6ph>w hmPma'*_iԩIrQ/b,1|^h %$aR)뼊p |2jGAixnE>35c8 ϯg^6qĕ~ ЈЈBa. <"IhX !CO؃F@bLÐ$XSSaԈ&H s,EIck Y )Bdi;?b̧^^DZ>.2XKb%w_Ѕw=fEmDurv endstream endobj 1154 0 obj << /Length 3024 /Filter /FlateDecode >> stream x[mo8_a8\-Ew_ز[Yr%9i IɒeQpE<39Od5gޞ}˜I@€LOHbn_FIHC[Pbl?#Co=a9Id&1Z wo:դgw3F)/f\EUIĥM䙻ytU+/ܾ'tGE:qIGuG%H n[ӫ8^*+~ȒlUΫ䂫)Hq:-bE>F"(Qnq$*$uܣqR 768Q\][c82`ӤrJ%WHVk%Yz G(!nQ2tB6jք=0 Lu4ށX55lJ4*Ђh2^6:A{pb=4%2={di7z; A<_oU-j:H?6UDAg=h=>ms$P&4QʨJ%kLZM3p~Dk(&]e RNwhݖ0UoD "S-x7)& BBL//8nSP@8U2rq"kyURq#"^YY\|KUǧmm=;N"wެx"]{=3۳Og.L2D4Z 9}<B\OX{nŒMa0I.Խ/ }>?:"1ń3`k5CBA  VS07D+° <r#W@P <ƫh^gl7hիl ɦqK6 0V#B  @rE:3>WG!:># åh :O{8o $G$q'KŀM3XgcxUlݯg2n+~iv8B9ʈf|^z҃JϕX gGZ ѪVZT_mFg7e2,ψ[c~kp[}Qz-5>9ar}_s.Ûp/9NHTA_9J>YF;j8[(A>od( eb.dwNۇ>z_3(7־e[QON~BseĜ&Օo?xWUkÍj@ w\W`A* e1vBUj0DrUh:Y&,<ו!]ǮB.ʪ&`IPz#9uY(;XҾr2ro_Qǯg:NCAQNv"}3*2CxNs{]^İ=iLnz`' $;0lpTb_9tB(*^X&%lX<~]ԅ`%ı*͛$:r=R ;*^s=jDY6_u>r 2w]'i<sC <#?(k(TϹmAq4f2F SSn*DFǾ, VIFXz ̕ra eҡ4BuS/Ǻ>l0iK@upgQWsW!QwQŌ: _܍=lpzMY=vSʳ(=Ml?4zCS5BN-̡7ǿȸ)U `pjnYx3ի4Y%XR ns ܺmuU<ӵ 6Zՠf 8vO;,|10W)ad Z-dW^5pbjMͮ&۬=ͬ6]d//FDn{'vul&2i7Kl{1l$4渝F0;3GtIND&"ÚCt4$6?%JM((1pEl,cm {[V-VO0-iM7w©ƃ"Y]Up#]S=-0XFh^t$r7wD/؁8`v thD* | S!v ~O^D{ 9jP+JatieLڂ7`Qs0 5 9z" *Kp[Y"<\Z*1!i-u[?@;+dV; JߑCvO2xW Q q ){pW˺XZ5'uޢ,OM~~Qf6^}~8}8($f`aHiȾ}K9v*7p"~W$ ӿ_ $ZoN;7mb}l`C(1Pn G<߃!#Y#a@/EÕ〄PΆ"&<#7lk!Y@`5rvkS%bi;֩;=L6 !+x]_% endstream endobj 1160 0 obj << /Length 2980 /Filter /FlateDecode >> stream x[[oF~҇@4+gH &fQZm(Ss") 9Μntpqo_3jo\kBY2 #\^|˷0J,~0kyF3V-0Xhs">>| e@ffq6`6xwvir`MxZo`E*7#F3-,[W*_)r=iULI)!yHs0!J#8mP+;,A ?e져T~8' t.Jt}|3@]f^׋UOxؖPJdG1@ޗmUƍ:ܐQba)ՏBSN ~g يD^ WRq@ DDZAJN8E ^ 4'It@Û|6AZPvw%|@'߸7Pi9Z|r/깿r]SmNRH"LjqzE^F-wfY8[\v0#&@ŗ OFUp`2?ǡNVmRHH3ћɳVިS0.o4TĈߥ뼼CXH V%32+q9Ez-b6\ZfzYB8ȴ38!|]gA]a~1I6H0ీvɀ, YMf5u^\["DM*@uga=f$=ɇD$Y$ibteMk!aXAa"[e!|=d>x f7z2آ(⦔&HHX!m%>.Gb; w._Jˬ@ZAL|HY,o~3 Wq#V*u &4 {"![9ҕ|7}]dZjT}ٳg;q'}G ދ iS(R+\ňa `Uf? "||úüUڊKbC`M7N Pp>Ї:ݔK,Ӌ'@y=~s,]P?N1+;^KbV~NhW*x=jUv?ΫkgB ˉb^M*꼪v'ɫsaCI+^;51$Usb7b nk5O?M %\d. >Xθ4hy* ]m$w&H/(B[ys&h┹$BU!׏UigLLl'-Z0N$CHԚ+֒ΐ4PGݏPJd-NLȕ,g} PEklwN[ׂ? Kf*\A O3#W=(u -^oC>xS˼ ܁*]޷1=-NIs# elٿׁ*Ԕ;Rċ ١r|]H2-u$n.] $Ѭp jA5 o1!Y!n;J4|Áv! . 4ƚ6@|lo9P<@<28{CT @]J@nD]ņLɓ$[5⅏nL|+'YGt5 pCEÂ_{BJ?}/p.ƾGcM:aU콢Hr'*"h9b&~TUV U$4@̭ex\Y1\$tuRpj %m} ڝ^)76ak*5), ̀z4 GBܦh*l4;g x<j"62FfS82+L ]pT԰MHĥ:ދkɎ_=uZf9Caz?T-hLᛅ.ּ*]81/,M7;00b;X{ODL@a.^g!tAQcvdڡ8܄aST+4mתlF֋0&[Zi| .+% 0RujPʴWo?(i[y)Ŋ)p2#Glȁm KD"&ReOGg=> rės8,Ksk۫lg**1M=8А~]I9xOgc~|/0<ǭ3M(GӏAVȒF>1k*Ct''`ϰl endstream endobj 1164 0 obj << /Length 3011 /Filter /FlateDecode >> stream x[Is8WCN2N՝=3wBK͊D$1e9 V,޵GӃ7/NIS]=2Ib]Nů/N|c4%S0(t@o/nT`@ 7]\~ Q"bz.7̭<84 IYC\*C;wG*:9y~xDr+\=oV4Zjۯr.l0bP(v@?`JTzn$4tV w(ff ]\N,[=3!D8h(Y ,=TO/HO˗d%~@586dp!'lPM$$7F,MTz „{`B{* 4T{RRJ{g%뺶YFV\k!1$CWݞM0;-zf_QQiG̊` AG^J'}J໣sXGf&^&qqn曢o&C`G.CۗRcxf}di@L;YeÃs*ab_z(aRvv0ʴ_*R?FQAn? I|HL L`& }E^]^^|-}VGPb!|_&9 U\rlDMv`0>z_ $P͇3J'8k 0""cD0$ƻL ` "(ZRͫ:>>##W_0:>*$R¤;f&/<o|j,Gñ-}"q4K1RT66Pf(vcW3 xldgPD=kRqmu<0\5Q{hQ^zPŝ\Fj<𸀩Ğ}Gns|݊&7Q KYx̂)f1?tstϫVi%C}1KpUu۰q7N:>?O}EȈr :'֜> `??$B>JKRr7DhQDWj.Y{?^BagfW}}`#*#)|H>Gy>s,>ďT;†"#B?p"p̪8,[ѱ2ڶdaM'LJG[2:^|5vo!RKH=r'!S6e%dIzmnCLZCdRX Ljm-i*Wn?5Kj^X\ hl!)aBT'd)a ]U4]5wvC#C `iYiܓM %jR”6]7hQֺa6H^uRn*졈TWwQ"c)aj@RK@U]hlBH.>7[*ΉPB;PMTJl.*X=xxR;yi Ѧggm8ZFrb͑mZ\m#'{S)۷8h`9<20ҩiC4&z'oԑ$O*Q D-Hpy-@=w-@`!7/diR⽞kq,PF*SP+VҚutv$y_mᚿIYnjc^PNlyrЉN/YR.D C[ &tof}н¾Y$0pUo L F*K[3tts-294<0_qκ1*pM#qi\NhΌ"; tdhQKl[:-X[U"t \n<\ fn/:rz| d+9#EIV9С&gXODr΢:}J-ދxvL>h"ˍ.gx?ɓص&i=AI؍IRwb .}!&L%ݼ,HRc>Pj\.1e3k|ݿ j#{i%Y[ry7b[lk`ixi~?UU&H;,2C>ec?Ra!(y<HB=C@_^fj} !R )jWo\m2i[rE (1'2TuB.V1Mt@/ɪ]RNjo-q#P Kf 4nUBY^/1*c0IB 7qnKܓۯz[ˆG(䶣 CNn3]?>6?7[~Wŷ9͖Y˲w= DQ1BY.!{&dU[u endstream endobj 1170 0 obj << /Length 1541 /Filter /FlateDecode >> stream xڭMsG-r||I'vIҁdS%;e`alV3MÊo+>~|0 0X ٻ ?`L8檧%͵~gs{qd HU!(nzW7> ŏnkK`i˷r)@6#40tջ/P~͑7t!9wrU]W=~.L -(' k*fh#h.a|TJct{rŅ|Vryne/% <Ƃ߆CLMi0<vx;rr;rw\iBH > stream xZ[o7~8/2 ඉp/!S4(Ne(;4U y\)g87Zg cFBLIr³i~tz(rFX˽}_]| 3 "D(E\l2xgS/F,٣{sn߆ů^FųJ+ KIy~q5Tj3)ɪ,Z'U{5&j^ˇY3o[ btjt#~z5ʂi7h~{˺<0K d)#2q\ubF'H-sfUΓf ?5pfբy??ӜKUI~+XK#Ju8]lnNUY>L 7.x]R$*Y֏|jx>Z֨v@'KF2 h#zN&Ƃ4@2Y$H)9 HNk^/.Ӫ#v/>*đ$O?zdd194%7PMSjaqߝlQ8iޚj1-Yx^ybI@&eo?n'!r3a)!Gzp(+D@*@-dg~wE-jn1Y#d|s(/sLpƂk7r(s.kSǁz}t)c"GG5)Ȝ7_~XI.g +hҩ GťטT,\ $0ѓ*v m |{s'sE#Kבg\h+G4[0W68StX_KG!JUW6AK1_neeYfg=母`ywm4w$uZ6~b~(gIa-UƤ -_;]FʛmPW0LGwO1 Idc3F?N{ңUf'|9KtMrHU;zpz<`hgtN,Ž\4r-ֿ8k6܃)ܺWXEDrV#N~eA\*AY]ϝCBs3P@Xy]AZ 5RՈ+Vתx\L`o$8Cy j<-XgS7f<'ǘ*DkpygžDXI~OvpWml3 䎷ppw_s~ bP{_>+8 NGZrĘŘ.=;3 #-Ֆ=yJ=aN Hznk&ߗ6xKkgM _5N4ŏא}Cwn?Sz'f$a[2S1q&ގ!wX;4Jl !{iatC(-Xk > stream x[[o8~﯈/. ,< X4vIL\Hd@LuǕNdϗWMʌ y.Z\/]CĽu_I{ m$f=ˆɛ |nKYXirbZ6}YΪlJlUm y@]8>uJב]'Vt(u-NOlxⴥ ӮAX0>a`tMH9@UnS;%l4+6١[~5˺:Ӆo `}b@`^;Ny~М%)/b9z *V `-r5Gb3xe<[Ӧzqʳ6ٳvux>氢q,G.o4`3ny$㚙yX~~}Wo?F7ij{=Ѵ?{8h>RG\F7MX-VA |x$%A oUzxW>7yw~=eGYF`F!YtsBrMG)G(`KL$^&24wNH}=+ 3@H,&? gI bK(.Czf,,1@x}'S@y$)A[P, me8>)\cJ&( u2|HLӱDcQFr Հ !{C+*\,څ8WM mu/X]Μ-Q 1 &Ѫuj6"EyZE$gl]8>!@9Dx>V!48,4wLH; 3X4L;'3C곢05+ȥ9K{ĬuG3pyspnŬpw[׫Y׽[tNFwާ)0'@J_Qf6o)'|dQOv_ysc׋Le#p  b%a01m('px| + DF`3L@XRPʣ2 @s/y endstream endobj 1184 0 obj << /Length 1582 /Filter /FlateDecode >> stream xZMo7W,$~ Z@&Auj=9(biIr\71Fb)X.Eμ'JT? ^z_9NjxZ)@H[9+!H_~?~ͳUR@xiX~>"b84d6S Ъj<{/I|6=gm81Eu2x;oo U`m qDTθμQ6~ X{j9:tz<<\7f8f?7fz}Oi$#=[Da2Z"c3_[Oj\'隓uhs2N/Z6H!OTؐ2ލP uJGes X֫ubf>M/XUjb!jo)bekQL;L1 /Tn XOiLKQ9Ũ]3UWh6|Yӕխ*HS\q.W*]_.YF͈BA3Z]n%Wsgd =9[(@[JvbYW62^~sRG~ɾxs =>oKj#xpT:2 K%.6CJb"`TVƻ,Jj exbR?,[2_`o@)`,|(ƀ(ƃu^#وҘMqWvk }"ﲃ=#YPTR 7l]8PTp`D`@K,4A)Ҩx ڄV7$,;*3RMB5 'max.U~ ]mYwUϯˬb ,] mh_(@:T{Nj3Tfʁ, 3 {|mUT43Q"@ⁿT~ ʄ|HiT|- gOwYw4OSR#Iں82u;L1<ΛBm Ɩm_4(ijUljB5szEFJ飴`/tfZ)Y(2^c?G-D)]ؐ@,WPnßZE<%58_1)a KIb+t2_ on>p)JY/!]I5NU(C@h,R:xZ]jz{AkV)&fzq޵j.)NBC}C|7ا ҫi|W%("2":v^e9nhj6^tbRz*4TO6>hwcB&I Y K:RY lImvS`TC^kfjӣJZj"=R*iU)(QkJ%8 Ph}`CJ\TTHR,SRWJ%Mb p}/ޓ endstream endobj 1189 0 obj << /Length 2633 /Filter /FlateDecode >> stream xڽZo6_!^d`-@n](m7w8`٦䦹fHJl9c=$(j84hWo?iP.#$2%dt?ӯ?n|!I"FƯL-P\tEn^1҈A%y4__}F xcD0iVq5T>_zE L?)b4ȗ)5xw=^KOTq5LY6庬6yNܢMUo~ ۰sL*I(^CEMOfP#QTt7znEV4G4_>7v|cÃ+Ët*=6@Jb:0o7 %h*ƫuSV6hlY0WAYymUm˷tj HNJie}ST=\6~OžcB}8LyI'&$Ȣ2}iddr4"NXqGXc PȽ"1Ȃpsrb iACƙL ~OV۰`2\lF.F_.ɝGyM,GO K;mhLtBm/N++shIc|o4Fu$eAE'yXEՙ&W y¢r{;ih?p8p>{cX6;հ!ɜ y;!ѱq ]":p8C9Kq> stream xZ]o[G}ׯݗѐCΐ@P m@ i*A[{a;@Hj-K e\yH5RITzOT MS-=KCFR M Ј4&"Dl5,&Nj H=z:Ǐ!g 9EA %&KM\ /*hI>ȉPzb>z.LתFKв#$TpT$ RܣEV}AZbwIzPu]hy1IJ15 QeFK$[, D+S 4P6$IPs*1 '-4b+4"VJRk(^'H WSbq -f(רqԸ-5)2PցMuЭ >쮜`P6м=j:!ghzb^{X ŨCQ56K`TIh wNB% XX K[Հd2'2z7ȵ:0/?Vh8 ̇so[rqd UKFub]˫o>\X~}uM㗷.]~bmzSK1̈jByz,-_?^_ooWeZ{b<ɜor]&oEdwi".㯿^\]ގ9/,O_Ly<jᷛ'(e+aŷ`x˗W_p|"-_~Mow5ϫlbuy{˄Bn>^_ݬcﾾ= kP6n^$a?xlkMCmv[i<`Hf8X>`˛?`C\ G6Tۓq#;ees|.;?~lRT4{d%iumF;g yX.|}'=AR~N9A\gw R'Ty"-(j\Mv#.kh8CZO]mTy G8r 7,ڶ-RMdeAjئG^A6MRD ^Ă-4#IMٱL/Q>;:H@p`BmV);/ՎWwʬaC`6u>F/ %?s< P뇹n|2r[9\;:GX5GI **6`06͞f- 6v|/ v u$.n)mюj9O̊t툛'ۿLj¹v(Iӄ37D?  endstream endobj 1199 0 obj << /Length 1242 /Filter /FlateDecode >> stream xڭXMSHW8ٵx2=OR{Ȳ$xOJ$ȯXXH1|1~t7 NGF>k(b`v0( fbg&/>+%7;D@[<v҈z' E#\`]\`c_JBfƵ|x`LUǙQhKʍ[:/'S8]//ƿ_4X2#z+y\Wqz͋TP(?C0O:3;ރ/ l?)#''5d|mR-_uwGX$'P:tX3?b?γ.WM8qqjb$IRHAH c L *~Ǖž;xSxMp3>)1j% S^0]d;uKA $/|UVq7UVr:;GjKD]Pz1mjq~ށS2WeW;%U: zű4ƶ9ƈѦgɋ7@'w6 Ȩ74ޘ)b .M $q C,R[v? #צj emzvwLn~DB80:˗ZOmQ*&~:!w:kgWj,w˦KjOffuU,~!Z6}N!D-F1+>&_ a/:]Ϟb-JUqiթ&>;.vDdĤX8xhŦ#8[T]5: ?c,:޽33j%L\I˪b a{`>0emS`@%2(L^&/$φtՎ"J)[!nD$qO&rIΣtJQ(Mi)SLɏkdc`@'΅ؙ(GD.'.uSgM^ Fm"LDmmAΑqChceCe\Nl]ٔL#Rm>NE2wIi|Hgcq/㬎G]iAiɤAv0CB~ĄqbQ-{+u87S endstream endobj 1226 0 obj << /Length 2166 /Filter /FlateDecode >> stream xYrF}Wmp2˾I-++.KԖ(vsm%X33O7l=óg8^RHiEfw3%`b&Dj>ygl5':~,p5#lp<[xՍƿ/42y)N>ͩH:4*ܼFrqoy;'ڤ1ng˴"t*uYnwVpS{[α9> NℚMY ,aB!MX*lea\p=~iDOA0X`|AL՜ 6-Qh>֛r<>O|_Q 0(,>ntHQ6I{mVAA;> ;g8yt*yH5zJaUՈ>g 7[' $>mǤI|]2]Ť z psie_]{m'H`MZ~}m&ri56 ϻP^-hUh֦ bjT Lq;"5$G9F,x-,nX$Ė|^PHtKhk: 7vT4ЛYje: ϜTk6߿^ 0׷xCL@nכX\[k"tK$㡫Xc ,ߕ "/,<˞rTuBk~NAr;ut|_myRSOGv&}_Ū??z/mt1kgq*k?]b+md{49h~4{I endstream endobj 1339 0 obj << /Length 1489 /Filter /FlateDecode >> stream xZ[o6~ϯУ ,)=md@˰P0(ߏhՒۺ]>\sw.O`˫o>WZ`4N_IDmXc_?,VIЪ~0v-|8?>.l gkXc-rvJ&dn93zyVkiO! ոvuw@4b{@rHk8_S0>ņ秫grIsLDDVE侈QO=Ģ7EiFx~oȵ.Y%,NIcgLl 5HEkכv,2w Jqys2|ڼq٨UANlo-w%yƅ2OZBE0GxXdmtnBqEi>/E.dbnό]zB&B^YpˢDpʏf?Lgb͢J<ux8'xC~2囦SOhJ2-LK=tq`;iESE3HQEy%R>~0;h8D9O/Ovb45t7wD|߫ct`IjU1H^z"\l|nXg{Swq\=\HnKPh@%A1%c8f!9LR0Iʭn5vm%<Mw?͚ e *X[^; "0xwvJZ3T]UeL`4Vw[hS%s4vb#};' V2 Ro֙4>'CjӰWlҍV ܔw<2]+í@D7fvV@@KѦۤA:)N㷡جo+^Aһ:xkIQ>mU1 $9;:y~mrTR9)ʷ?—Ϊ`9&tʍƩ]Dj!6 &mXD=9~, "սzj0u̼iQ`Q0iGjcO۞:<틫|wO=Mr- ?agphR#m h&pu,byL1g&~Ě8> / h A*9RыKс sɮ:!Wt;I)m"oupt~uήN> endstream endobj 1195 0 obj << /Type /ObjStm /N 100 /First 994 /Length 2785 /Filter /FlateDecode >> stream xڽ[K ﯨc|)z?$@Ndy1v =j+ɎfQ/;ճ_$2-s4Hע%-I-%p}꩹_56rR?q6 0Ÿ+[ c6) C$Uq"KM*U3@}jRZCHTYF2־[@{IF*II[Y)^'=_7AzKV_x+jbS 8o.\XɔO 6YcxgfN_^O V%3yd xC*ɧHZ([RS#լ/)eSA~JO}!ˢJꢼgXMeg Шޗ@xK,(4d,.@-`A@ 0*[S%4kE=>;F^:|F+iFZ9R l].)P".RJHJwK|&ʇL'Y)C:#L%T7Z`tŨ]`KMn=9|}:B>u)tn@{ofܠbm~|6=zqzq.@qa ,=]-N:^f D{},q:S$ M$kbhXH,YYYYYYYr U'SˈtzUjr :T/S*g`\ >2ElHDLoed}?MDߎċ<%4d<174 cC{{f !" [ CሆRK:43SC.lyOôx pH/II8 <遆DDæƉH+@0@XaWrJ" 0!C`V23Sw%kI)k-pߗIP$Xç]aSYx)_+툐RR*es#!5gYnW5#{) GQՓJge/©mAE^q̂a/d4q.!Ƃ[G_'ahjF OͪڠnIVGlg]S~>3A7̄WAy rJ:zJm^y36gpWk+"ßPͫ6׎Z땛Q U3Pe[qzs 2d8 }!m/NtmɘB l 9\QLp Adȭqb؉+VkDӴLkFr .U(TODØ]X;Yk2K*릣 skfFtM> stream xISH| qH*S`OAmB-$~Z&,k3&E~duuvzRJK% s  (D̺~kq7BXUq5@"fl)]t[#J[#€䬸*7#C|x靧O$XQxV67%shmLGoԟAJ>n5 PҀ@ei^1|"6^MgH[+Why,6氟P~L~rypM?J88O'q._!!~Ҫ‘SQjeok{{T2+/ѐºYGnDgA/& NһEa+7zFўQv%o:j3Zg֪iюR@ad^.x{ۋڥ&*w4t7yv; :W'h6tln5MD]0f*f:/'>oqtH \}n;7[Fv&…ͰX7)nbeӨj!'buqݰd ޼Nb X9MnÈYw=F}96{L =ױNE]Gf#ZgoT25;;:gx; k5B%O!$eJ-6"p,6oe*@#.,$^+f 8C^]?1uՖ++3="8\]ق>klj^\) ٳRW5"PZz]#(9݉NWza*2[/Ҍ1IePr?A~Je j~&aAؔ6y\X[;*IHW(3AQoRb| tӞ$2}(❑# Izߞފ.ڴr0"TWNRYV!1T.G7z(E,ϤD9`\6Ų]R8 )fs z*H V&Akmi yas.|p1=bW endstream endobj 1342 0 obj << /Type /ObjStm /N 100 /First 1020 /Length 2712 /Filter /FlateDecode >> stream xڽ[ˎ\Wpl,@0`[P Y$<Cm-<Ӏa[*R{)H%H)\hոPF˃j\3T+%a%aXC7g~e!ݔdD!g7JJ!N$!Vlrk+H+B¿ꡨN5J@R( PzxdEJP9=zS}0(.Sr!FCs/+uj"m>]2,SS2\\Y,s3F]BKvX1F[òOAO)>? CӃFgN}8}_y~Osw$ć_N߿; 1q &"ă}߆gppz˻G |s?Hh B@B{0a8h>Idtp[]S( <@kƐۈENIF$6. W`q#(y#\"J@2KIuȕXF^hS-Ċ SdG܁THpȶ9`p Kcsf8s`F^rj׆ ([3ޮ@o9Όr )tf, [sKQ权 B_sXSbb#kDBq6|,Fɻ0Fٕ2H5ٛAj\IXs؛YFg,< 7&ZNLKӅ%aJ"8dpHhI$(c8Vrc8RZ N {:FlT2j,d2jK;5>@ec /KC8hсS2%M?<&tJq)E:?4V&h#(nM/$ƱVD5_Id#vjM/) z^}Du2:<(@!G-CY?YU.Gu&1%$"8+¡e]ۊQE9 51;Us˚ʮUq{{15.ύ`ux^,ZP>|緿WsjJݭN䚙eכ_<|<龠A^pLj0pv~QxЕ_9D^~|x=N/~oVK=8 (W/w?0ch28w9>$HNrZҚg{˞q^X"‘͑͑͑͑͑͑#WG\:ruՑ#WGn9rs͑#7Gn;rwݑ#wG;rwÑ#G<y8p㌬)B|}Q|0_T_4_t_88888888888rvّ#gGΎ9;rvő#GvoR&uoR&6p>>>>>>>>>>>z{N9ea+&!ߡ&%Qڈvzh%=Ϲ2>"V1ok;˨ ޱ11#~4rkMNuT DFX;19PC vx!{}%r.^HmIm<+ Ce$6 $:JlCos^?w *%3N*ږD'E F9Ố@%f) )"$v) 4o(mE*ZN`G&3R%O+ $vN32% Rd"A ԁ4^EαAS[$x%%a"EvPDH_(;=sG:8wD5$5r/abagbvp`❜ns/N-f)7?k9=ʺ$'  ]D A% p! uNu MFS d˳ Ȱ۴^Bph.љ8rC6aȼBkv|d:6tz!@yE`kl-?XMІ ^'6Xn5PVLk4*aF7u!A /I읉9@c#?&dWu4uMbkx9(@*OF@`(i/[txr3\~A 0[9qB$ުRhN"TK[۝c&H^sy;HǼɓKyц=%T2\ endstream endobj 1567 0 obj << /Length 1442 /Filter /FlateDecode >> stream xZMs6W( qt]LЎ2==$pʯUGHIIKwl0ֹMGI#Ղ%W&M"QCyqK @#ı䓵8qsul@V|tt(Nx\f(~N A 0L7נyI6 m T+VH}"oT&:(EO?pGkOq,R~U4(Ud2Z1H:Æ8&RA2ʤ?P6$)#$E*ʿB2PM-fZI13=)nJDMQnlTAkg t)* !MJŔ̒Y^#j4Q c/5fUT0KQfcPuܫ3?7{6Xԡ6D32cR괢^y΃:Ew%<RJvH,Ga 5EE( ∧C&o05cR}D#u3 LE:u̫z-2C./5GC,ٲ9ElExtm`ⅸVv.ޑ>Fˣf@Ys)߳Yu'병vp 5YB}|ˬ@-TZ4;zQd+5$MQdE;a:K:TBdMC42Ԙh> stream xڽ[M1pX$mAI,:("0bWQrдah9ݏŪW^!Gb`bEA/&Q1Kʔ}ɅhFg|9F@( u^ gBtsfa⸭l#*0F#[]i>Z8Fx^E`42"3FTac҂k)FVe] Gu(x܅7xrVt+Sqs1r,8 xhSVlu^@/ln.۲ ™:u s`y)l Zk=ѺNj2 (xT[&qR3m}J̡ZFC ,k uG/C}]7ʰpخfqQsq¯5u [v1+Ӗ$ӗ]ٗ]`9ip[k51U6<͖K֗ORZ0a/1pxXXi,G2̂:n`; mc-FZX0=a f.8:bZx@qX{v/o?ݝ^}ǧ?=?i 鏧?CToꌭ״ν)<{VNy/y_U_$aj0&N;r` U,Z `xIܑ/$ o=-aZϕ{H$zˮ$TM~$Hg[H5XX: I D5&=w( Hw%1,Eb-@­.%aF@p˱O8 !It#t] q6_ZZ v2ŽHHXq SgdWC@ AmG Q]#PV{$ƞboj !\'4,/ tG >z{>_GUb:jo504d *+cEE.-"@"46$B.o=סWJ¦EC8L_H#RREǘu"TS"1c;b"0o{5GLUVdqFƄ8@Q32&JeYbj nw@z pIAQ͌hyuoo S (9T|LTב 2AJ ]9"o[wڬnp44gnqqh{*<`;@2! WX`;H[i%HHt`Gfdb(&_DLP 8Pɐޏc"N뾈&uNvZ?ιTq>t-z9N: :_3Ak?—K-zCPN5c ([ҶSʖ83_-!XqT_mcˌJN@PNKd h/>-cM/`DopA^>QNT^{?|%A?>~~}grO{,4t>)W|2G̿^qZ@s`9\/9h9py$H#G"D<y&L3g"D> stream xŕ0y Aja}lR.V=PⰖRȂ}zqnMg0RF>eRJ" H&\ !" &ي<o?}IoïR*|tĨt8>;4d! u݄s,Xu,w_lm'1&MI/>W(z+9(xΈb| SM{H8CGckN#_צ|Hr#-oWw@ DHѭlAnM]# i$ԥP$JNˈpW.ӍiϮ&&&"p`Akj7CTxw^vo6T8?wկTV7yaM1x=25je?+'ptu7UUUV7uyK g7Իo>ֵ5Umjv,G'G*&,|uP^@U?O endstream endobj 1569 0 obj << /Type /ObjStm /N 100 /First 1014 /Length 2430 /Filter /FlateDecode >> stream xڽ[n+xL.VXvP  ۇM , l>8>4 HԨXHHUFKl Oh5%hPjݢs>.wK]㳸FPh<:AU .-JL,Ĭq[+%-Z7 :^ EkzxZTRE3Zh\Gz7pNI>!Ws;|Aj._}!# su Zv{iܳD2s@4YhvOr%^!m&P0zaH9 @4-RKF8 xdLT|.E!VaD}tB :`j~ ȣ_3c49 AJlW@Ȏ1#QIj,:~֮ | 0k+9/s&HOR9y:dYfH8 PL E+L-dB(C| P 搡¦LDlv)bK  $+mBjBC"NT/3M"gax;`[629b)Ui?גVXlfYACg0@W7F+Z X,LGD 19KD@cwlDA ?/ \7.u ;"K Do<ye%|Iɥ] b3;A QRW/*.+i_ò؏aBJ V SP85AtRv|c/ >\ʊ9%0˵LA܇ u.`aRy C`"Tr]0na-}#q!g"Ӄ@npi+E0` umW܁ Ԁ E\ CH&`)ZFfL iO oȰ(׎*3"֙ w%~!5J̋c3fҰJڙd-z+?y8_b׀ز'bZ-GO ^VG_صtoB/Dl /~8Ծ^'#|aeϏRoDΞDlB@( n4L7a?Ħ3ZcqxQ3k/n@O"6|ڿvN/m/"bzM+?3NM+1m'WȋXS*+[8-#O{hl!<ԫI x8ơԥAQgcXgf͆F_>{ٳϞ}g==wk-Mqee6d삎M~9Gɲ+x ?m,87vYe?xse߃~琈]KLlo m~fD(6Y#l N}}]ATLE! E@'PtZ5oo-s/c 3&7Q· vQP2J1{UBU,፹A(1?sd5E{%D" fW W ؐ8J%BvF}p:ǪP-}Ws^HmXx`a2}he^P endstream endobj 1593 0 obj << /Length 171 /Filter /FlateDecode >> stream x31ӳP0P0PеP05Q03VH1*26(Bs<M=\ %E\N @BA,N؃$0z8Q'`& >`& `G${ ?Qr `E endstream endobj 1594 0 obj << /Length 171 /Filter /FlateDecode >> stream x}1 @ a!s51VBVbnY-DM(HgjxD1alT+ Q9O=|1!w)ڠ) B T{@6\% .:Z@ Z|ae_U/b endstream endobj 1595 0 obj << /Length 143 /Filter /FlateDecode >> stream x=1 @wn^Xbhi(m,-q#(|cYj9֌YJUT΢yךTN̖Y ƭx܎b*N7qDoRp, endstream endobj 1596 0 obj << /Length 127 /Filter /FlateDecode >> stream x31ӳP0P0f Ɩ )\\f@ IrW04 s{*r;8+r(D*ry(0` 0~` A9.WO@.{a* endstream endobj 1597 0 obj << /Length 129 /Filter /FlateDecode >> stream x31ӳP0P0S04W05P0PH1*21 (Bds<L=\ %E\N @BA, `Ad"@j&3p? \\\I endstream endobj 1598 0 obj << /Length 103 /Filter /FlateDecode >> stream x31ӳP0P04T04W01R02VH1*26PA3Lr.'~BIQi*S!BA,B?$ r \A(a endstream endobj 1599 0 obj << /Length 228 /Filter /FlateDecode >> stream xuбn@ P#$/|B=P/L'T CteJ2vhԮOSF6QQ$xlllMN ksZgtM s"GI\>(Z4;)})o)喠FlԂkXٰ,eZFJ微FV'q:7y@Ju,_)n A_b҅ Ut1s=H|/w' endstream endobj 1600 0 obj << /Length 254 /Filter /FlateDecode >> stream xڕбN@42/(V$HaRK r-%aYL,$/0;?S5K>ǒ^hquyxmG-W*.LEwoOTlϹbw%1'\|zp"_^D"j|tF}Z;6ޏf6$Z fnݐ}^-~'?pNNr]nQZ]k* iMDE~0gzgJBd:̬L7Zs! endstream endobj 1601 0 obj << /Length 219 /Filter /FlateDecode >> stream x}н @ H!KyZt;:9::(ZpCLrE>%ɋhH)#tyT?D@(rIfRfFی3'zj[Cp\; f[ k} H{wZI Nd;j<WJX2.&,iT !q^P endstream endobj 1602 0 obj << /Length 194 /Filter /FlateDecode >> stream xuб @ H!KyնԩP+AAAQpGNA70i^4(]G 9˅ŊL(9O=l1EN 9A*lTS[lolnګtѩY|guU^emz'g'(Ieގ endstream endobj 1603 0 obj << /Length 200 /Filter /FlateDecode >> stream xڅн 0+ ~`A, vtr'utPt5}4б&O Crɗ3)hX֮*ilEAl&Ws:.{dbB3D]$ p %X3'=íU6}C IB%:+Brm^CseB}]P8qOdz endstream endobj 1604 0 obj << /Length 253 /Filter /FlateDecode >> stream xuнJ@ba;/@λ 8BQ7Q̣RZ,;n<9Gu|Z|XroKz)ssO놊+J*4LEsOwT/NXkj6 C"y`ECt>W Y3]>}vrÞ}ԩ:xAjmMcHo/OvjaOMbSjTt0q;٭'Kjiyq:<贡K~) endstream endobj 1605 0 obj << /Length 186 /Filter /FlateDecode >> stream x}= 0-=B LMѩP+AAAh=Gpt{1b$#CHTا39nR؃Vȃ|Ai@.P+ix< S.ST+066kˉ $Di Qx7~qvy7+DDDCt> stream x31ӳP0PaKS3CB.rAɹ\N\ &\@Q.}O_T.}gC.}hCX.O1TDvBL4 D"?8F0 &> (O'W 1` endstream endobj 1607 0 obj << /Length 168 /Filter /FlateDecode >> stream x31ӳP0P0a3S3CB.C I$r9yr+r{E=}JJS. @-\. ?000+ e8Iv!#!d>B2#dn?`c XYc%e0pzrreT endstream endobj 1608 0 obj << /Length 262 /Filter /FlateDecode >> stream xuAJ@xAN`bP+.U҅"8EBxxq7@|/Ģ.oa7Jh+(*[$'eY1Ƨ|qqFwΏ)xN)%WX 0 A@'X!TW@ F-@\GaL@+?QowI Sji*ՕTj`t ^3@ #=ңuf'^^ endstream endobj 1609 0 obj << /Length 232 /Filter /FlateDecode >> stream xuAJP?dM9/T f!ʅ.]( ]+@"9/Ibd>f_dzt2㘏 S^'Di̮dtGZn8I]ȖT~/ϯWgZm+F EQ$>B>$@Q Y¯"8(: ,:QBM?jlӞokb{tM_+u5 endstream endobj 1610 0 obj << /Length 217 /Filter /FlateDecode >> stream xu1N@P#. l5ɺ&RheaB8 G bc WySWk{][!R:]޼~ȡe.{ywxBQ _>*@H9“2؜!b( b> stream x}бn0n|OPBP:!T*CfeJ;fhծGQx (JXbٟtg4{y]SLK^+}&iƵq`Q=P}.rG?_h %htL(>a%ȽwGk]BrQN &Cv&̍A FȗF7"'1u&<کZ܆dT?s1ݭC&Vo} endstream endobj 1612 0 obj << /Length 235 /Filter /FlateDecode >> stream xu1N0g4$ݭ"-D $(PRh9J҅aXEv15 7KJۖ{K*??_^rEŎ*.1 ÊLE<N$D#&Hg.{`~'~@XdMc0!ƀ#5}̈́ JDFVl؄YBt}l( endstream endobj 1613 0 obj << /Length 262 /Filter /FlateDecode >> stream xu1N@E"4>Xq ,  * ()@ QaK\#Eg xyxԙ.rS/I9,/ݣkoK~<>H:Bn JQ 'PG>&f_S3 H#>%Xh:Y3ICE2%3ЁUmr88va;7;׫g*zɴ'H 8o3.7F>se弖k" endstream endobj 1614 0 obj << /Length 243 /Filter /FlateDecode >> stream xmбN0г2T%R$2 ĀCQYK)S =D6w6 O:}sX]QE5Z%ǕxEH-ihf}M5 =T=c!.bǜU,k/튑u$=?AbΔ20g-h.풓&|cIJӷ܏5k{Z;h> stream xMϱJ1"0>Bt7BBGˣ#\yŒYC_„kJςƵƠoA{]VyfIc/ݝ]Íqh H<YNW͌!#|i~8-v:Q,b#X}n}Hْj`O:Aom"jAk1xp3YvG-m endstream endobj 1616 0 obj << /Length 235 /Filter /FlateDecode >> stream xu=N0\X&G\hVE"T+*D49# '@|{SYO7-մ-3.ư١m--Z.sUwE/oXmϩjG;vd)3v(&_*r) ԗ(G^KoNP=:F#Ȑb0caߨ``u`;}!A%gyY$ქ<K~ endstream endobj 1617 0 obj << /Length 210 /Filter /FlateDecode >> stream xڅ1N048feH-AK|%G2amCEg[|w[>]r-;mzM[.NGxSӜpϟ_{ ۇv}a@ZJhD2Ȅ$2c4dvJuNͨ (p7Rij/M)vAm+uӿ@"S endstream endobj 1618 0 obj << /Length 232 /Filter /FlateDecode >> stream xmαN@ `W"yG8DJS:TD$02ʚY%AC:d) MܜSE-ԬiSTk> stream xU1N1Ei|kBR[ AEQA h.SD;&O͟7+nykzeayH={ɏ#~@~  ,FI# $Hy!p9sP SlQ S]BS3O?9Cz 5I[lIݐ\N+*iD=ktSn'-o endstream endobj 1620 0 obj << /Length 190 /Filter /FlateDecode >> stream x};@%$p.$1q ,ZZhQ8%aaD)e3&SKp4C g0GgԂޠ1mx܎ cncv`3TJyĨJ6$(r&;;/Xy9pED]Kv6}zκOY8ˏywf.'+yWana Oq endstream endobj 1621 0 obj << /Length 286 /Filter /FlateDecode >> stream xuJ@g"0y!SZYZZ(]-rvABs.ovI{F%t\tZSSc/ش\-iYqaqKM%ױ 9UXl订 d ybR.aa cX"`?5̆o,, ߫0Ȅg_RPg)$.z4/@ciJKJʓnyA u%>@+ +0@:ɝs<#Nz3b:%^txۺ endstream endobj 1622 0 obj << /Length 207 /Filter /FlateDecode >> stream x}; @49 SZYZZ(f=Z"xSg7 ?2Aɥ ^H[]McajIj*UTNp>"՘VkQrtaQ d,ɹu|--"1^JBR̉*z&v:N{X5gS\Uo.Nb\ endstream endobj 1623 0 obj << /Length 168 /Filter /FlateDecode >> stream xڕʱ 0+[| LBI Njh}x&A Ifz9mPkcaP,IkSע03:;|L EI+Er$ 4./ @'PE \b<<Iya9PpbpO)T< endstream endobj 1624 0 obj << /Length 210 /Filter /FlateDecode >> stream xڕ; @YRxtJ +P,x4#XZH 6.W 34yP#PKkwFzV[s #cQ':t@>!-| 䪧䟘L=̿;w3'EP+l7jӯi=|:s+b-SJ}e GrQ3|d endstream endobj 1625 0 obj << /Length 221 /Filter /FlateDecode >> stream x}Ͻ 0C>B Zt vtr'utPtS,GB1EAA1$$wKҬ`[43\%4}r`^jijD1w5ޤ l. 0Nߚ`gTj*YO8:uȱqJꂽSyXND!uаڻ7ԗ:1D&/e6 xE3~0)<|] endstream endobj 1626 0 obj << /Length 159 /Filter /FlateDecode >> stream x31ӳP0P0b#S3CB.cS I$r9yr+r{E=}JJS ]  b<]``Q"? ?8 8{0u L?` .WO@.R_^ endstream endobj 1627 0 obj << /Length 177 /Filter /FlateDecode >> stream x}ʱ 0J-}{B(u* ftr'utPt+G#t< pwxb1?p dsԍaw\XL@y B-r@) -=/4mVgu𤆚N-.Ѧt+.Jf{m?FN3w!ct1]a`/B' endstream endobj 1628 0 obj << /Length 190 /Filter /FlateDecode >> stream xm1 P ,jEB`A'qRGE>֣<;B|?Ns42!Mgohu۶՞Lj-)tC*.G'}4!r8FJp-27sX;+YJ>!PDhxհ#qʩe#\Y.D*~ps endstream endobj 1629 0 obj << /Length 217 /Filter /FlateDecode >> stream xe=n0 ^ !Ȕt"YkMG4z0R :]ށ"ħ=,\'7O>i:aAOtL}eÞܖ[V($FFUG"@'C;MBMIU (5[resKMSCЩAgC4jFV"j"kJh+bo endstream endobj 1630 0 obj << /Length 247 /Filter /FlateDecode >> stream xuпN0/`<JUeTD$02G#d|P,'?.n\uۚPk^kozETkToj/ ׯԭ 6~9H$؀BzF{baIu=L1;> stream xu=N0\D&G\eHHE"T+*Ak&\GR> stream x}= 0 kI NEzbIJS$.(qfc.1xIjsq$Uj"ۯ1)Fy#ҜN&"Yy 2$P5sΚʮTz)z@=qQg5椳[o }6 dcq endstream endobj 1633 0 obj << /Length 222 /Filter /FlateDecode >> stream xm=N0_4{2lXҲH@j D (GQr.L(4~sr>p>ܟq q<> stream xuϽ@ ^H.1::htG K6idP@ 5E5^0PጙAKaRݮzNi)أ F8/nO+y\җ1DgiP->Ձan,Oz౽R0ʞ^ endstream endobj 1635 0 obj << /Length 187 /Filter /FlateDecode >> stream xe=@!$p? b"VJ--4ں{4 Fiͼ$)%)]"c0;9߰jP(PlL񺢨v+Pt(> stream xM1 @'49(I F0X]09ZRY73las.O>t%ߓ1y8^(NIHdK*]87 vI%w9PpHZ..XM!/3(ѯz?Gh ź1n_*U JU@h ;0" cd:0&I˔dU~ endstream endobj 1637 0 obj << /Length 204 /Filter /FlateDecode >> stream x]=Q+In$~SHB tˆB9;0f0;0A_r)*kUW*PFgD3gpQH)nQ]Z.VS^-:dmV{9muju*<5MfوݼoϽ=f<\?l@/!g"bf#~vOhr endstream endobj 1638 0 obj << /Length 206 /Filter /FlateDecode >> stream xmͱ0# $'" b"NI4)h< бZ{upФMGlL%%c4g WfY endstream endobj 1639 0 obj << /Length 232 /Filter /FlateDecode >> stream xMαn02 ݒG^:DSD$:u@LЪ:DGˣ=D1>$N}q2QDcMMtR1% '3̶{FܽBيԂ4570ze(mi_,h[i[s?v%| ϛ'a73UVWhvV۩~rk endstream endobj 1640 0 obj << /Length 179 /Filter /FlateDecode >> stream xm; @YL#8'p+U F0XٛQr)$㬈k ?S`O'QD4>&)"fwļD$E3\|=ɗS)bY LTUB3K2Pmr/*qOrZv_Ծ~bnJ\ \T endstream endobj 1641 0 obj << /Length 244 /Filter /FlateDecode >> stream x]N0 @qK?j`Jc N'q@p%~J>a)ODiVkh)Y5a}[mpaxfV;x|ŰÖj?D˃yp̓gYYC;@!&_@b˔?ճGefoT8g~цv@Q6tozazkz4Ut_)ΔQMEјw>7x@ endstream endobj 1642 0 obj << /Length 251 /Filter /FlateDecode >> stream xU=NPrai_{p,9TBpED hc-G\[+ό\]TЕ^ZVַB>,(.tYMY7?kYH~OYA~%_?*Սn9"F>= 3ڌvвb8cw?2gFGD=2;x)fNUSgf91.؝¹jvb4qsItag}@SC$<ؐ rȓew endstream endobj 1646 0 obj << /Length 100 /Filter /FlateDecode >> stream x3337T0P04P02R05T0TH1*21PAsLr.'~9BIQi*S!B4РX.O e\=3 endstream endobj 1651 0 obj << /Length 103 /Filter /FlateDecode >> stream x3532Q0PP0T01V02UH1*2 (A$s<M≠=}JJS ]  b<]` .WO@.E, endstream endobj 1658 0 obj << /Length 105 /Filter /FlateDecode >> stream x31ӳP0P04Q04W01R02VH1*22(Aes<̹≠=}JJS ]  b<]?$`)( endstream endobj 1664 0 obj << /Length 146 /Filter /FlateDecode >> stream x%1 @EqV$Qc N!he!Vji(%Ks)YBJwrn6sZΘ,' Nn&-]?^̞i"fXq^Ĕ%(~ID57T_@=@-6T֑[!6* endstream endobj 1665 0 obj << /Length 197 /Filter /FlateDecode >> stream xڍ `4w/Pj)MPԚ>#46_Gth =(TWC# |=yrϭ3;/ft싳^l,N+=u-',]ƠBR"/ w]OJ Hѐ4MJ0?_9.6վэ-iN͋eVL endstream endobj 1666 0 obj << /Length 196 /Filter /FlateDecode >> stream xڍ= @ GbVbh%GH"/Vef Ʃj?8$C(gbg(X]r;fwPL@ | ~nF <z/@:Mrp\3]8[FihHOҙAHVxuO endstream endobj 1667 0 obj << /Length 197 /Filter /FlateDecode >> stream x=;0DQ m#'1Q.@T@Ip'Xz&p:SN8qjhBq&,d p’r^ %mW|O w=ْ\%NfN‚R8Ԏ;?]Aq !帿;$EC3NMYBvҶ6n* UKe endstream endobj 1668 0 obj << /Length 97 /Filter /FlateDecode >> stream x31ӳP0P02PеP0P03VH1*2 (Bes<̹=\ %E\N @BA,BM?AM 'W (V endstream endobj 1669 0 obj << /Length 194 /Filter /FlateDecode >> stream xE10AH MR.@T@I< )) bex{6G9avὡũ4!H#8%5))z -lH1r-9 "HE H$;5ƚ2 @Ll)a7lI3G+lJ endstream endobj 1670 0 obj << /Length 110 /Filter /FlateDecode >> stream x31ӳP0P0TеP01Q03VH1*22(Bs<L=\ %E\N @BA,BQ? C GG\\\0oy endstream endobj 1671 0 obj << /Length 112 /Filter /FlateDecode >> stream x31ӳP0P0VеP0P03VH1*22 (Bds<L=\ %E\N @BA,B@ C \\\HB endstream endobj 1672 0 obj << /Length 157 /Filter /FlateDecode >> stream x31ӳP0P0UеP01R03VH1*26 (Bds<͸=\ %E\N @BA,B?Q"A=h`;$@F0A8&TT#`xxrK/ endstream endobj 1673 0 obj << /Length 106 /Filter /FlateDecode >> stream x31ӳP0P0UеT01R5RH1*26 (C$s<͸=̹=}JJS ]  b<]L!W51 endstream endobj 1674 0 obj << /Length 180 /Filter /FlateDecode >> stream xڍN; @n!swCM*!Fp A+ RK E;!/^`%mȸ 0Ј2 1> stream x31ӳP0P0V0W01Q0PH1*21PACDr.'~PKW4K)YwQ6T0tQ``a:S$G`1j%r > endstream endobj 1676 0 obj << /Length 142 /Filter /FlateDecode >> stream x31ӳP0P04S54V06R04TH1*24 (s< M=\ %E\N \. ц \. ?aC??@P`4,r endstream endobj 1677 0 obj << /Length 96 /Filter /FlateDecode >> stream x31ӳP0P0@P!Ő H(`\.'O.pU()*Mw pV]zb<]\= endstream endobj 1678 0 obj << /Length 162 /Filter /FlateDecode >> stream x31ӳP0P0UеP01R03VH1*26 (Bds<͸=\ %E\N @BA,<b@N ?8$D D`#2f2X3Iq,63 *@'W yK/ endstream endobj 1679 0 obj << /Length 104 /Filter /FlateDecode >> stream x31ӳP0P0@dbUeh䃹`\.'O.pCC.}0BIQi*SPE!'EA0XA0Փ+ 9-I endstream endobj 1680 0 obj << /Length 157 /Filter /FlateDecode >> stream xڅ0EkHO-DD'㤎]O:2bg'g/18ǂS WqY2˝jCHo mvx=7~ &ĈdDVvUr9+G^‹aUnF;~ZQ:?8 endstream endobj 1681 0 obj << /Length 111 /Filter /FlateDecode >> stream x31ӳP0P0V04W01Q0PH1*21PA#CLr.'~PKW4K)YwQ6T0tQz ?*1pՓ+ JS endstream endobj 1682 0 obj << /Length 102 /Filter /FlateDecode >> stream x31ӳP0PP04W0T02VH1*26PA3Dr.'~BIQi*S!BA,B?ĸ\=E:( endstream endobj 1683 0 obj << /Length 118 /Filter /FlateDecode >> stream x31ӳP0P04P0"sSsCB.#39T*9ɓK?\ȌK(ΥPRTʥ`ȥm``P !\`߀ Apzrr]7 endstream endobj 1684 0 obj << /Length 172 /Filter /FlateDecode >> stream x31ӳP0P0bS3CB.rAɹ\N\ &\@Q.}O_T.}gC.}hCX.O&4Ŀ,`ꀐh2B0 0`@?D0pzrrV endstream endobj 1685 0 obj << /Length 254 /Filter /FlateDecode >> stream xڍ1N0E"49BD.!ҲH@Q V9#Xqabf4ҷoy5w|pw Raͫ~yzH==US53UKnC#[J  K(R( 4]7^/_2 (`\ <Lx\XgA7A:HÝְZjIKj)! "chI(QUJ{շ1Ge/]tG߹< endstream endobj 1686 0 obj << /Length 201 /Filter /FlateDecode >> stream xڕ1 @E'l&GȜMFQVbIx--qFj%.̃^ )LKb> stream x31ӳP0P0bSSsCB.1s<L=\ %E\N \. ц \. P߀ J2~~d|"N`%값 hL F'y,$33oAYՓ+ H06 endstream endobj 1688 0 obj << /Length 198 /Filter /FlateDecode >> stream x}ϱ 0 [|TkI Nj}>JcҘ 4蠄|4;.ˇ)Jq)+di#  3 bnA5o3bDTYk[z^DyÒ1 <§QSHhUsjD0N/QG<T]KDbh@C63K[xGj endstream endobj 1689 0 obj << /Length 230 /Filter /FlateDecode >> stream xڥбJ@/L i +PysQ%o镶={[r\/䶷\C#;"L E(JdG)23!_#2C[{GE{ʐ :Z2 fFb֘9e)QSFO?V2C鎾?9ru endstream endobj 1690 0 obj << /Length 197 /Filter /FlateDecode >> stream x31ӳP0P0bS3CB.C I$r9yr+r{E=}JJS. @-\. 700& @Y4$)&?H L2A :0Y&q RbbH.C _@|A! HC, !݈I endstream endobj 1691 0 obj << /Length 149 /Filter /FlateDecode >> stream x31ӳP0P0bSS3CB.C I$r9yr+r{E=}JJS. @-\. $BփI uD6`D2JOĥj2|$(47Ae\=WD endstream endobj 1692 0 obj << /Length 141 /Filter /FlateDecode >> stream x31ӳP0P0bS3CB.rAɹ\N\ &\@Q.}O_T.}gC.}hCX.O$3``'Lȁ|DAjD  \\\, endstream endobj 1693 0 obj << /Length 230 /Filter /FlateDecode >> stream xڕN0/?BՅv`b@Lб $R_.jKŊ-}oﳻͦTИJr&7R+Ly?ocv~K*^d`dPɑaDZN{8;@Ά:0GdzT 3#'d!Q M4 >15Ȏ×t*ć5 endstream endobj 1694 0 obj << /Length 114 /Filter /FlateDecode >> stream x31ӳP0P0bSS3CB.1s<L=\ %E\N \. ц \. p,~BĄ'W NP endstream endobj 1695 0 obj << /Length 105 /Filter /FlateDecode >> stream x31ӳP0P0bS3CB.c# I$r9yr+q{E=}JJS ]  b<] 0 %\\\6Qg? endstream endobj 1696 0 obj << /Length 163 /Filter /FlateDecode >> stream x31ӳP0P0S5T01V05SH1*26 (Cds<͸=\ %E\N \. ц \. ?3xa(6 Dp`PC=ȓ`{ C쁞r .eb endstream endobj 1697 0 obj << /Length 231 /Filter /FlateDecode >> stream x]ϱn0` n#' v D$:1NClf1t#4Cd?Ka@?>ό/x7e`+/l2 .|w9be;U:.Jp΂Zг j@AR&B n ~x)[yF^}lEƪ# `"P0~? endstream endobj 1698 0 obj << /Length 126 /Filter /FlateDecode >> stream x31ӳP0P0bS3CB.rAɹ\N\ &\@Q.}O_T.}gC.}hCX.O``'!P:'`b\=jo endstream endobj 1699 0 obj << /Length 201 /Filter /FlateDecode >> stream xڭ1 @4 \kP1),J--!9D,,T]S[̃3nQ*9zK5.sWj9!!qSdaV o,cP$nPPBz@Q(>Zll/5.K=&Mإ(o9)[-_m0v`fs8 endstream endobj 1700 0 obj << /Length 199 /Filter /FlateDecode >> stream xe1 0-wӖZtP*AAAQPPRo7iqpT I( 8{~B&6}\9Ol[L,7@g@GEq;>:@8w^@8@X&as!eV^zH4 6Q25> stream x͐=@XL #V &naRK (҂.C l}/N竌BJh&)^PF ] 厹Fq(Eu1 }C$QtQZۂgmJ9Հe 7Fд?oaF k ,|_F&h endstream endobj 1702 0 obj << /Length 182 /Filter /FlateDecode >> stream xڭϱ 0H^{ӐZZ+AAA(}$]8N KM9&xg,\Od+ f.S0~ ,Ђ)qo19/"jB.P;UuDF 'aybhF4j-iMːO*"`a oƅt endstream endobj 1703 0 obj << /Length 217 /Filter /FlateDecode >> stream x1n@Џ(,M#\j%C* *I"Zo+M|k7c܀?WgiG^,#orI^/*J{rϒ._t<.^7!-i<Pqj,Q?vtDQ[ ba~WJ!IdGSI;% endstream endobj 1704 0 obj << /Length 218 /Filter /FlateDecode >> stream xڝн 1 Y|;? N⤎磝"b/Y>Jڤu)&cjiɈZ=qYh>&xޡG*hɘR. eى/".Ҭt ҪwVhO/o2C xBbMn7ݥ| "Ԁ3ï>$$J endstream endobj 1705 0 obj << /Length 250 /Filter /FlateDecode >> stream xu1N@E'rai=1IL,  DѶ. (ig?lncQiں'Tl=yE&lk\FZ,6KNZa| 9|t5iûH Jbz<rd'0 (9qp&8 %?cFi=H^Q #t)g/pxLkDυ3zA endstream endobj 1706 0 obj << /Length 127 /Filter /FlateDecode >> stream x31ӳP0P0bSS3CB.1s<L=\ %E\N \. ц \. D?`OY$$ ;R?$XՓ+ VX endstream endobj 1707 0 obj << /Length 174 /Filter /FlateDecode >> stream x1 @ ) fa n!he!Vjih-GL2 +7&.&RY S2sjOƠZKFe7?/4#ڂJ"nݯ;QO7ZB؈U$fMYD@ ϝf+;|WW endstream endobj 1708 0 obj << /Length 197 /Filter /FlateDecode >> stream x} @\|jU$A:uNձCQWQ /mU%v?,Ŝlriz mgCsb ۓ"[YyAm }$E'}2FZ_V7W?Wei f )XP>V*5yMg9V/zVJAf9'*LCx8 endstream endobj 1709 0 obj << /Length 210 /Filter /FlateDecode >> stream xڍϱj@_pK@{98Sj@-48 -rpnA0f#VX܏]і1ey8%dIL2~Ar<"9hM锳AitJweB# LX6vs`RaF$i4 ;QWytExݭ'{gk~϶,O*$=t %~ endstream endobj 1710 0 obj << /Length 242 /Filter /FlateDecode >> stream xmбn@ P#$/ "L :vhծgO@@$2Dv."PtO h"+4}ih//hMм.tI?hfs ,hRtA אLZ5;: Gk?ޱR/R7ux;xl;3{gߺjmkxN|סuޔΚv:T-tjO;Q d,ŲZ8ݎ[+R endstream endobj 1711 0 obj << /Length 220 /Filter /FlateDecode >> stream xu=N@ _b%79 H" * D[n&"ymafYy.\O:/wa\gVVOK{Ǵý~~|m]=(k}fϋ kEm&fhF hrá +'2ʉ3q4|PY؁0e齳s5\@e'XreSU4Q~MQd endstream endobj 1712 0 obj << /Length 206 /Filter /FlateDecode >> stream xڥϽ 0+->Z+S*AAAѹ}>b$*.bBz:ԥVDJQܣmT;fiTTf3:; :Yc6\;lhkb⍹/N-Z6*p|ZX?4>usn tn N2\KKv endstream endobj 1713 0 obj << /Length 205 /Filter /FlateDecode >> stream xڍn1 ]1%o )$n@S ZYG!i _ϲ=gzp;:٨T6{hh.DmyءQvF0`80cf̱b9)zA}T$"'S|_Q((M I +TPGey?4dѸYz1_ S endstream endobj 1714 0 obj << /Length 220 /Filter /FlateDecode >> stream xڝ; @ )isJE"b=A aS~] endstream endobj 1715 0 obj << /Length 216 /Filter /FlateDecode >> stream xu1N0E*ir ,-D $(VT@Iv(>–)VAaYO??V=ϝz`U6]oX?ݕvⷺ}qE XXͨ̎p[P0LhB M 4ESDiDf( DETHIc %)>/~Œ\r/_})oG endstream endobj 1716 0 obj << /Length 164 /Filter /FlateDecode >> stream x31ӳP0P0bSsCB.c3 I$r9yr+q{E=}JJS ]  b<]300? C=`cf ?F%5Ƅ@.N%\=CSt endstream endobj 1717 0 obj << /Length 275 /Filter /FlateDecode >> stream xڅ=N@ M_(E"T+*AD \%7!H9Ec{BHLid=RI'tT%=VjIM}h=<|ŕԱh UXiSQy :!1{.g t<A9Nt¿ɽ`n [Y'(3@ ~sPoi5E,b6y0ɬ1$V ٺ[Lz #h&;ij$^MR} ^x?m endstream endobj 1718 0 obj << /Length 165 /Filter /FlateDecode >> stream xɱ @ : Y k 7:9utPt>ZpcҘ(@>?1t>C1I0IF*x܂ڡA ʮv@F G` t>'C/fH= b賚'b6l Q"Di endstream endobj 1719 0 obj << /Length 137 /Filter /FlateDecode >> stream x31ӳP0P0bCSsCB.cc I$r9yr+s{E=}JJS ]  b<](B` D00 aDHpzrrȧYA endstream endobj 1720 0 obj << /Length 217 /Filter /FlateDecode >> stream xڭνn0pH' Q" vP+ċekdUGk?>48^iƏ%Ii?1B4,Ⱦr'd Wwc'/kL8TEk%t:u=|?Q ;DN d~U7 S[v0ؼ?bjv? k1N\*7V*=4#S endstream endobj 1721 0 obj << /Length 123 /Filter /FlateDecode >> stream x31ӳP0P0b#S3CB.c3 I$r9yr+q{E=}JJS ]  b<]``? ×0? 'W g endstream endobj 1722 0 obj << /Length 161 /Filter /FlateDecode >> stream x31ӳP0C CB.sD"9ɓK?\ĜK(ʥPRTʥ`ȥm`C}?  Yo`*?!*9=g!@d\= endstream endobj 1723 0 obj << /Length 159 /Filter /FlateDecode >> stream x1 @бa1[ZYZZ(ZoG 2΢]> stream xڍ1@E #0eV$&ZY+h+{4(- 㲘ڼOϛ$ͦ񄇚1'O6MvV6&U~{I7 ֤rkT dR" "/x"o"x Aā, Ң~~5oU9qNȩ9IR 3,hK` endstream endobj 1725 0 obj << /Length 221 /Filter /FlateDecode >> stream xڭбn0bt @Y"QPNt@hycs U.ɺϿm˧ > stream xڭϱJA?lq0= %*#xE@+ I-SD5_,9 ,9nsckc_ťc?f5ySǣZhZ}dl5.dj0r DW@`D$  F]67@Hmtt9OYw억g߹٫e&ڥOM&7ۊ` endstream endobj 1727 0 obj << /Length 172 /Filter /FlateDecode >> stream xڵ1 A i832VºSZYZZ(ZXYz#llXZO7荆d/9C;GtVibs0W,lQ9O=l1!洖}N)!0Z2-ygg"(.0P5tŷAUɲ+Y0\%-nYW endstream endobj 1728 0 obj << /Length 218 /Filter /FlateDecode >> stream xM1J`b`w.~7hXW0VbZ * vnUra!,ǔK-tgQ ->Gy劲p3%WtpK-Ϗ kxzX 33䎅rCF40@:b #LɂY.dČ 曶AȺ lB{,Zxώ`1K{+orSN~o' endstream endobj 1729 0 obj << /Length 160 /Filter /FlateDecode >> stream x31ӳP0P0R5T01P05PH1*26 \.'O.pcs.}0BIQi*Sm` $?` #$`'0   Sd.WO@.] endstream endobj 1730 0 obj << /Length 159 /Filter /FlateDecode >> stream x31ӳP0P0R5T01U0TH1*21 (@es<L=\ %E\N \. ц \. `,dF }H<00g?`G"?\=kqt endstream endobj 1731 0 obj << /Length 174 /Filter /FlateDecode >> stream x31ӳP0P0bScKCB.1s<L=\ %E\N \. ц \. 7P& eJ``$? @cg@%4*PFF2?F2~~F2?N7 H{ r V endstream endobj 1732 0 obj << /Length 195 /Filter /FlateDecode >> stream xuν @ > stream xmν 0C(vAAAѵͣ7Q|AwݤGr6&آt&=>'|z zzBQvi z0b zoU YUX)է-ؽFF'{DžyVJtlH!r&u]Ŋ;7RCSQ񋦠iwH>ʳh endstream endobj 1734 0 obj << /Length 237 /Filter /FlateDecode >> stream xeαN02D%{pҊ.TD$: &73Ea+RősƂ)eTQS9mr|IJҌ.kk* C秗{˫3Q&l [f۲cvӨh+켍 R PPÛLm55wۃQ?ڋ_"|v։&Ԋ*Z IM ]4O`9kb{0D>7k endstream endobj 1735 0 obj << /Length 171 /Filter /FlateDecode >> stream xڍ1 @ aM@ Fp A+ RK EۉG(2E:/u ͧB"IIR9|c#ʅgݺ+Kٕr%:/%!ԕIDeoKhѰj#0#0?Y` ` `]ГnS^yi endstream endobj 1736 0 obj << /Length 218 /Filter /FlateDecode >> stream xڥ1n@E?@#\ ^ c)ʅ*q"QQ8%Ŋ2[$r~y.9R3.#OcE_/T_ܙt_?g~)O)'o6`Pv*;k . , UPC< èzDNe{Υ]ɷ~+| 2%E_Iqhҁ x endstream endobj 1737 0 obj << /Length 143 /Filter /FlateDecode >> stream x31ӳP0PbSsCB.crAɹ\N\ \@Q.}O_T.}gC.}hCX.O@l``z 灸C??P szrrRZ endstream endobj 1738 0 obj << /Length 232 /Filter /FlateDecode >> stream xmN0Kxe' 0Y*E"L vd(~wH`O,+¯.wZt7j='(IB??v7ϭo^x# `0#,yB=:F0A.O= {řs2t 9FtJ:ZTTwHsͪTU!,)b")3t#}wo endstream endobj 1739 0 obj << /Length 239 /Filter /FlateDecode >> stream xMбN@ `G"yv~%-a H0u@LбCQn館?I}LeC-c%H00cRbL5hR"&\/d /N^J+Jx#jC(^ Nw6d`NV?1F3:=0+(-aO"{|ldy endstream endobj 1740 0 obj << /Length 196 /Filter /FlateDecode >> stream xڕ=@%$p."AL0XF;pJ 87[syc Of|F&di\%8])Hلט6?/#)"*C Ė(\ -p- *XJ  pZZYjW ( 0G(Yb_/*:p^ endstream endobj 1741 0 obj << /Length 217 /Filter /FlateDecode >> stream xڭα@4;/@NYYZZ(ښWG#Lq:q5_1xD1 P)> stream xm1N0E'ris v7,eHV ()@&9#L<| Q`ɯ9JrZ\\Q<^ W7(s W+:C-GnB"LdT@.ëGHF316 6P9n\ Pbf4RuYHq_#B}!\0gܜ!TFIAC$yDE}H#A _|o_ endstream endobj 1743 0 obj << /Length 261 /Filter /FlateDecode >> stream xmбJ@ )yŻgp` ,J--m/Zy/0`0h#eg?|%3Yq-SYc/> stream x%; 1F;]]hL!he!Vjih7eIY@5`NKnn;[.>Yʬz8nQuĥ>W#D*L"QCĶ5e" ьwO)B endstream endobj 1749 0 obj << /Length 132 /Filter /FlateDecode >> stream x313T0P0S01T0P05TH1*26 (Bes< =\ %E\N @QhX.O 27??~0?P`G( endstream endobj 1750 0 obj << /Length 192 /Filter /FlateDecode >> stream xڅ1PDPl Ċ1D+ cmq@IA;WL0 v xlagnEt4'g'Ty!n{> stream xڅO; Pl {I*L!he!Vj)h-G,-$q̃T;LNuihuɗV'/2O4Ĭxq7 $$M | ,G\W{F9^ـ"J[|rY"ֱ4nT?pGrjݬc_e*[M* endstream endobj 1752 0 obj << /Length 167 /Filter /FlateDecode >> stream x313T0P0U0Q0T01SH1*26(%s<=\ %E\N \. ц \. L@$AD=$? ?@P&VV̌...SG;&.WO@.n= endstream endobj 1753 0 obj << /Length 162 /Filter /FlateDecode >> stream x] 0->KNZ N⤎>cbMN8>] y GGbO%T2[0YFK&pOdLSAZZFHW 2"L}Tߩoﻭ "Іֺ? endstream endobj 1754 0 obj << /Length 114 /Filter /FlateDecode >> stream x313T0P04W5W01T0PH1*22(Bs<=\ %E\N \. ц \. a`?r 5ez endstream endobj 1755 0 obj << /Length 116 /Filter /FlateDecode >> stream x313T0P0V5W02W0PH1*22 (Bds<=\ %E\N \. ц \. c``pzrrlI endstream endobj 1756 0 obj << /Length 152 /Filter /FlateDecode >> stream x313T0P0U5W0T0PH1*26 (Bds<=\ %E\N \. ц \.  @N5 D؁{! ?8$ &> F0Tta*`gr W: endstream endobj 1757 0 obj << /Length 175 /Filter /FlateDecode >> stream xڵ 0DQXK'2҆  * D h%##6HWYM0p sf؜Tz2{XKf1)Kd*rdGR/RA-%a|ݠЂV$QoeUG+O;a endstream endobj 1758 0 obj << /Length 171 /Filter /FlateDecode >> stream xڵ 0EQ  miCp  (0 i~ϧ{~37 <& ~9JϓJu }s7&xܟnKœ(4^Jq^.JNQr?)F#PQ1H)3R;;J~.؆xC?ZOYb endstream endobj 1759 0 obj << /Length 104 /Filter /FlateDecode >> stream x313T0P0UеP0T5RH1*26 (A$s<≠=}JJS ]  b<]'W * endstream endobj 1760 0 obj << /Length 113 /Filter /FlateDecode >> stream x313T0P04F F )\\@ IrW04 s{*r;8+E]zb<] P\=AQ@ endstream endobj 1761 0 obj << /Length 148 /Filter /FlateDecode >> stream x313T0P04U02R06P05TH1*24(YBs< M=\ %E\N \. ц \. ? 0`77g.`r j'. endstream endobj 1762 0 obj << /Length 171 /Filter /FlateDecode >> stream x313T0P0S0W0P01VH1*26(%s< =\ %E\N @QhX.OXǏ?1 ɁԀԂ2} pzrrxS endstream endobj 1763 0 obj << /Length 116 /Filter /FlateDecode >> stream x313T0P0V0S01T01QH1*26E-ɹ\N\ \@Q.}O_T.}gC.}hCX.O A-4v@ ù\=emH endstream endobj 1764 0 obj << /Length 136 /Filter /FlateDecode >> stream x313T0P04U54R0 R M F0\.'O.pC.}BIQi*S!BA,???PP'W ,5 endstream endobj 1765 0 obj << /Length 99 /Filter /FlateDecode >> stream x313T0P04F )\\@$lIr p{IO_T.}g E!'EA0XAՓ+ ; endstream endobj 1766 0 obj << /Length 157 /Filter /FlateDecode >> stream x313T0P0U5W0T0PH1*26 (Bds<=\ %E\N \. ц \. @#HD؁:Q'@&> f0d82>3 df Dpzrr@: endstream endobj 1767 0 obj << /Length 107 /Filter /FlateDecode >> stream x313T0P04F f )\\@ IrW04 s{*r;8+E]zb<]:\={-= endstream endobj 1768 0 obj << /Length 155 /Filter /FlateDecode >> stream x313T0P04U54R06P06SH1*24 (Xs< M=\ %E\N \. ц \. A# ?0` @.WO@.8 endstream endobj 1769 0 obj << /Length 110 /Filter /FlateDecode >> stream x313T0P0V04S01T06QH1*26 (Z@ds<͹=\ %E\N \. ц \.  \\\A endstream endobj 1770 0 obj << /Length 145 /Filter /FlateDecode >> stream x313T0P04Q0P0T05WH1* !P"ɥr{Ź=}JJS ]  b<],j0a||=CC apzrr/ endstream endobj 1771 0 obj << /Length 103 /Filter /FlateDecode >> stream x313T0P0W04S06W02TH1*2 (B$s<,=L=}JJS ]  b<]0 szrr$~ endstream endobj 1772 0 obj << /Length 117 /Filter /FlateDecode >> stream x313T0PT02W06U05RH1*22 ()Lr.'~8PKLz*r;8+r(D*ry(01l;cNJ l r \+ endstream endobj 1773 0 obj << /Length 168 /Filter /FlateDecode >> stream x313T0P0bCSCCB.cs I$r9yr+s{E=}JJS|hCX.Ov;: PNF01`u@Qf f2J~ 񀿁;'W Ǟs endstream endobj 1774 0 obj << /Length 251 /Filter /FlateDecode >> stream xڅJA'\!Ls ޱƅ+,J--;y4B[O"hWf,4s n,͡c%:IRc{l3yz|c;9?Tj fDTP&E{h+9G2D~>/BGE$E7~ }KvmV:$,H@%j}W}azH O#bA=b2~|0 endstream endobj 1775 0 obj << /Length 239 /Filter /FlateDecode >> stream xڍ1N0Dg"o|$Q6ZZHPQ *!p!eU8i=opZ-uC玝|H?Я\~4wJ3޻MÍ?ε/2"P<> ufA@5ã`cO4s1d1gʮɧ:eP~Kٜ-˺QvOh9X܅H$% RM Zlmb dr)}A!> stream xڍ1 @EGR2'pa!F0Xr!E8 I 33;MR(oSJb:xEk%GU/hvd-Lkg4fAs \102w{(` UO\+rBZt%p#'*=J@ ҿϫFa;Whn I endstream endobj 1777 0 obj << /Length 184 /Filter /FlateDecode >> stream xm=` .߁1D'㤎]ċ8p n #~$(}L> stream x}0K:#pO`i1NI4 Kd0FMj\ijx@½%\PPGL2P[2;|=7P~K<Ls 9y|9#l K#vӜ_[ZCN _CF,a8[NXTQ endstream endobj 1779 0 obj << /Length 218 /Filter /FlateDecode >> stream xڝ1N@4QY AT (Ar 3AzWJ_kN|y9H/vI'Zun8-)\ؙBwoVWg)6r}Gݚ3J~ ZTMa.)- o̤/`tR27V֯ifhh`+-RN]dvg9 endstream endobj 1780 0 obj << /Length 183 /Filter /FlateDecode >> stream x313T0P0bCSCCB.c I$r9yr+[p{E=}JJS|hCX.OD|?b0 AD}&> f0H0b!On%rv?s?>  `szrrǁG endstream endobj 1781 0 obj << /Length 147 /Filter /FlateDecode >> stream x313T0P0b#SCCB.c HrW0r{*r;8+. ц \.    `|$lthvb)،6 Q .WO@.̌r endstream endobj 1782 0 obj << /Length 145 /Filter /FlateDecode >> stream x313T0P0bCSCCB.c I$r9yr+[p{E=}JJS|hCX.OH" $`@CLmQD !( ,x endstream endobj 1783 0 obj << /Length 227 /Filter /FlateDecode >> stream xڍ=N@\4PY AT(PR$ގk 7eUI"Q|{;5袥aC]8> stream x313T0P0b#SCCB.c HrW0r{*r;8+. ц \. ?c4 N%'W  endstream endobj 1785 0 obj << /Length 108 /Filter /FlateDecode >> stream x313T0P0bc SCCB.crAɹ\N\ \@Q.}O_T.}g E!P E >Փ+ HX~ endstream endobj 1786 0 obj << /Length 156 /Filter /FlateDecode >> stream x313T0P0U5T0҆ )\\&@A "ɥ`l¥U()*Mw pV0wQ6T0tQ``HX`'$@DD?`AH?` @OjhPՓ+ UX endstream endobj 1787 0 obj << /Length 218 /Filter /FlateDecode >> stream xE=n@E.,MvNm M,#EPR%)SB9QPr.]lȢOLt&c&FRf1K~|U.k9s endstream endobj 1788 0 obj << /Length 123 /Filter /FlateDecode >> stream x313T0P0bCSCCB.cs I$r9yr+s{E=}JJS|hCX.OLŘN|? ?*f endstream endobj 1789 0 obj << /Length 177 /Filter /FlateDecode >> stream x313T0P0b#SCCB.c HrW0r{*r;8+. ц \.  B`W${1y 01h͇q|Fa  l?`!'W , endstream endobj 1790 0 obj << /Length 194 /Filter /FlateDecode >> stream xU-@%&c 迨 P$u[GEev K1h8&nL؃-;CFXA_>pi ?!&+R"c(ɉ(N+ƵGSroW\"Ϡ+tIߣmśh5| dXB]/qs| endstream endobj 1791 0 obj << /Length 170 /Filter /FlateDecode >> stream xŐ1 @ERxt)R-n!he!VB9EqW7seϨxAƘxң3U5ݮr 쀾"h `,T'uID x/H 9 Zpqol endstream endobj 1792 0 obj << /Length 174 /Filter /FlateDecode >> stream x313T0P0bSCCB.cs I$r9yr+s{E=}JJS|hCX.O0"370`H؃@`?#^^Q`Cƃ-Y  f $700 F"b\\\wN endstream endobj 1793 0 obj << /Length 209 /Filter /FlateDecode >> stream x1n0/ʀ! &HYj کC @9j1CNjKޠ{iˊs.y^,V\.x_ЉۜWH[KEԯ|9_do\g ƃHLd pLi'Ai ?NI i&tZ0^gȅX{cY701<5  endstream endobj 1794 0 obj << /Length 197 /Filter /FlateDecode >> stream xڕС0jrf{::"#a e0XvtmCOh)T^ aLiOvG ֤FscT,r0ʖSiNfEN`Y9Q3pqNN3O0n ZJ4&}5ty+A -ؼ+ԀW2>z endstream endobj 1795 0 obj << /Length 236 /Filter /FlateDecode >> stream xu1N@ E"a|$H" * DH$*\!G2HQwmT 娔DJsՠg?x#Um<>r\Iq+wn˜24wC0MLNLtA 9a=tC68yF̛aO2/a<&E>oxv endstream endobj 1796 0 obj << /Length 124 /Filter /FlateDecode >> stream x313T0P0b#SCCB.c HrW0r{*r;8+. ц \. @†H0 z(QՓ+ +T endstream endobj 1797 0 obj << /Length 167 /Filter /FlateDecode >> stream x1@G(LtYY +D ,ZZhq@IaGhf'_Ϭgɂ#}SqblF.b27+e=Z3bÏB&.ْ`9:Rs)U*H]J^w¤%HRQC/~*hGo8 endstream endobj 1798 0 obj << /Length 189 /Filter /FlateDecode >> stream xe;@!$p,1q ,ZZh.F5\5o2s? q98^}G|9^0vV2#kgdfAYL{NELi iww?>, ʐ ] xBi LHʛ1VL0JRaVuZ-Vi endstream endobj 1799 0 obj << /Length 197 /Filter /FlateDecode >> stream xڍϯ P#)>tœ &5m.b_CYN wzto,NvE69Wh .-rZeD/@sL@56Mo%n} :}v%$@FTiXz[V!zyM-+_X=Ey>J3CN.{K endstream endobj 1800 0 obj << /Length 226 /Filter /FlateDecode >> stream xE1n@б\ M<'m JHqT)"*L(iRZt)GLᏱEW23ɢ}ɟ\YV>>xUs&Ւg9pzy^Jz-NS={kg`g?EJEAJ>.dt &JI0r熻qM 5.M_f[݆{GZ>_?WKq{ endstream endobj 1801 0 obj << /Length 191 /Filter /FlateDecode >> stream xm= @ x Ղ?` A+ RK E[)S,;h%Xfh< }:ex\T:8^pVQ>EmqF;)C}FE$ sXBט^Hȃ@?|bezYETZ_q-`R!a~K<.Kj/\ endstream endobj 1802 0 obj << /Length 187 /Filter /FlateDecode >> stream xڝ= @g"#Xraˀ!N;GYg!BR@[]/w%ܔ|q&?,Lƹ+x"ҡ@yRx -0遍~*?umֽr!0e] EӐ`%Ж*sz endstream endobj 1803 0 obj << /Length 182 /Filter /FlateDecode >> stream xڍ1 @EIk9 n!he!Vjihh%GL2Φօ}g?ofǜlS>'t#k5?;2{Zd܆L]rBC\"iJzD=[5/jLAOQ~ߏ@B_Zh4J5Ϋ^RMuZ9uEJ endstream endobj 1804 0 obj << /Length 193 /Filter /FlateDecode >> stream xڕα@ .<} L &`qRG;[pqᾤ 5)+H+9s<^&|XLפ*L,r0S⺡MNMC $z11wx!"><Zi&N?>cH RaH'c ˁ:ѴmO, YK endstream endobj 1805 0 obj << /Length 201 /Filter /FlateDecode >> stream xmPE4K BBrmM>}}V́;ܹiԥS=T'u9&a+NFF⻥OK+ VZ[( f#2;܃J>PDCv@Z }•cC 7'* 4u.7mp b2rcZI_ endstream endobj 1806 0 obj << /Length 154 /Filter /FlateDecode >> stream x313T0P0asSCCB.c1s<=\ %E\N @BA,@Az H?*;&p4Aka[~ `1.WO@.^ endstream endobj 1807 0 obj << /Length 253 /Filter /FlateDecode >> stream x}J@#E`}!k.p` A+ RK E#U(y[,gǰzqꜟJz`;볟 Z.(wk~x|ws%{/xv4lnfxYDdItSn\#7@efd=`El6X4jB*`f}E_h0bj1SL̀,x>v*!*:MƢ:?-y%ۧF@-7> endstream endobj 1808 0 obj << /Length 161 /Filter /FlateDecode >> stream x313T0P0bcSCCB.1s<L =\ %E\N @B4Pe,B @d ?  B~oAd $?HzI8'W z endstream endobj 1809 0 obj << /Length 132 /Filter /FlateDecode >> stream x313T0P0bcKS#CB.cC I$r9yr+r{E=}JJS. @-\.  @x@@?C1;}pA|.WO@.O) endstream endobj 1810 0 obj << /Length 169 /Filter /FlateDecode >> stream x͏= @_#d.͟ B Fp !VbnxK q\`eW񊉣~2c!GOj .mO1dXV|-M -X endstream endobj 1811 0 obj << /Length 198 /Filter /FlateDecode >> stream xڝ;@%$p.H)L0VjiVW(x[_~0E_cƃ=2b4gA ΄Sp)-8lsQy endstream endobj 1812 0 obj << /Length 115 /Filter /FlateDecode >> stream x313T0P0b ebUel䃹 \.'O.pc.}(BIQi*Sm`Pz<7,{\W endstream endobj 1813 0 obj << /Length 171 /Filter /FlateDecode >> stream xڽ= @[&G\@7!Q1#X^,7[n8ȃW3r9Al&]'-\,cx܎` s0 n ==Cbq1 SeKvI'mr/)T8R`5zf endstream endobj 1814 0 obj << /Length 155 /Filter /FlateDecode >> stream x313T0P0bcc3CB.1s<L =\ %E\N @QhX.O$$PD2`$ȃ@H&?:7 q.WO@.ll endstream endobj 1815 0 obj << /Length 183 /Filter /FlateDecode >> stream x}=@XLvNBLH0XF[٣Q8ab^2}KJ)*%Kw4 +@@)juE]VQzB[_P :9o.A@9(dq%7@'a/=ߵG.^Tyh p A!\\[>P: endstream endobj 1816 0 obj << /Length 200 /Filter /FlateDecode >> stream xڥ= @g fI"SZYZZ(ښͣ[.(wS|7q4HRYs_8 LWCNv?$#(%p:lHj&5pGٌs V,S*7;(&A]t, -GT@8=F> $_ȥF<5ޯ endstream endobj 1817 0 obj << /Length 211 /Filter /FlateDecode >> stream xڭ= @ 4 وVVb&7J{ Lig Z 6_B޼q;QH1.#ܡ$ )ѯO-3 # ƒcM?n0O$!Wɾb|31P_6rilxz+=Տ>jO=]quBVŴ~[)D\|kse8'vG endstream endobj 1818 0 obj << /Length 158 /Filter /FlateDecode >> stream xڭ1 @ПJuj!Fp A+ RKAEh9JAqc![̃I`4-ØԈmjw쎜{Vky\Y\/|9êe_Hx+5C8#$RC\B"xo<Iw endstream endobj 1819 0 obj << /Length 185 /Filter /FlateDecode >> stream xM1 @4!s7q5@T0XErr,,2ԎgDM&rv=pr^ًYMyaoY!RrGB7 }KD#"eZSW!("PB Ca}96A=> stream x313T0P0bc 3CB.cS I$r9yr+r{E=}JJS ]  b<] @AH2`h AA~[@ Lx:B endstream endobj 1821 0 obj << /Length 148 /Filter /FlateDecode >> stream x313T0P0bcc3CB.1s<L =\ %E\N @QhX.O` $0()D? d=H2cģd> endstream endobj 1822 0 obj << /Length 186 /Filter /FlateDecode >> stream x5= 0W:oN`B`A'qRGE7^̭ ء4ؔ? ,&Q@>0[}pb*Q)QzܟvI>>yG:J^]S |-,ZHZX:^<r[C准qzb&gaQ$L endstream endobj 1823 0 obj << /Length 174 /Filter /FlateDecode >> stream x313T0P0bcc3CB.1s<L =\ %E\N @QhX.O `?aC00~ @2?Dv`N2~+ߎ #ȏߏ`` ?G#g``?A6 H@RՓ+ ɝm endstream endobj 1824 0 obj << /Length 202 /Filter /FlateDecode >> stream xE; PEoH!LUBBBN!۲t @!L@,a̻{ې lfOÄܒZrɌOp>ܘW!kJ/LnRQ;H(+p{h/ O.ok> 44W&F&R$}xY& endstream endobj 1825 0 obj << /Length 237 /Filter /FlateDecode >> stream xEαj@ dz)CB=ҩCɔdnvj:t&=$%p!:d-"zX!ZnhyxDQd}LKႲ)ֳ[{vȭ+OPy5 @U-G[;z[*lB;v\ɼHer;SHR Z88 ~Ka{ endstream endobj 1826 0 obj << /Length 176 /Filter /FlateDecode >> stream x}1 P S2Y<9*BV N⤎G(Ϥc|?!?'S3>gt#͔+^wr~ÏB.9#W!H"Px+"B I / >i`$f_$hj(D{{-ӎ~b endstream endobj 1827 0 obj << /Length 203 /Filter /FlateDecode >> stream xڝ= @_L#8MLRL!he!Vjih'({!q-6߲`}t!'<8 91 ũ piNfqJf)c2ot=̜w{@^m W÷x: dTLdO_'X`*w]!WҢqz9KU" }}d endstream endobj 1828 0 obj << /Length 141 /Filter /FlateDecode >> stream x313T0Pac S#CB.# I$r9yr+Yp{E=}JJS ]  b<] X큸7001;j?0FJ endstream endobj 1829 0 obj << /Length 222 /Filter /FlateDecode >> stream xe1N1E*i| .-V Ab $(UAݣ(>B,?kWEwk.i;O%/$=iI^>$nF6x0ڄʬ ͎X⌾T~fGvlgOȠ<|HTGǂ+ˇD5WTL3*=2,<8h endstream endobj 1830 0 obj << /Length 226 /Filter /FlateDecode >> stream xEнN0 J^ @ZHHCL @>ZlDZTe}9W|Qps}ů}PYkP|N#5[ Sj~??ScNzDDFM&4=:4WL hLVښQ5A1;,wKi sęǐ dw;-y"ͧ\ۼ>[z3Vc4 endstream endobj 1831 0 obj << /Length 181 /Filter /FlateDecode >> stream xڕ=@!$p. b&ZY+h pJLh$%^5Y (xTHN)74 U[QcL uMĄB9ƛG3a(if M( /#`cV2OZ˿Z;5t endstream endobj 1832 0 obj << /Length 207 /Filter /FlateDecode >> stream xڥ= @4{t&)!BBB,xxqFE惝}ov)ZRGk;Sʱڬ)Nюe6aܠOi(Zb>$\Cǹ.5Tº)7 P \)'ߘ'-,e$9ґ i `AY ֚ G9-c endstream endobj 1833 0 obj << /Length 241 /Filter /FlateDecode >> stream xm1N0E"4 @TE"Th+)S ͓=3uE5w|pWs/ 5gFGn{n5j+UknS=6@! `dHp糢0g0p \ύF<'"DMbLz[Zj6]*7DE??(jALP5ˠGԡ(OY*G@BR栛 5pI endstream endobj 1834 0 obj << /Length 183 /Filter /FlateDecode >> stream xڕͽ 0+- h NB`A'qRGE(}zWEq _~3#)';#I~C"cQ8|Q iT5t] '`010%p1 iBt*Rt 2;nB)4_T+~Ѭ.:\M endstream endobj 1835 0 obj << /Length 213 /Filter /FlateDecode >> stream x}O @`qM>!zI 0XɧSW؈p w3s3Y:'sÄ1P{~s8Ӵ$4'tcot=w {* (D`D:y#jAԠBQSQ]9h@9׆mƠ3/"-PIoәn ժ?|R3{6nR}Zn endstream endobj 1836 0 obj << /Length 245 /Filter /FlateDecode >> stream xm1N@ Ema|HBbE"Tj`&GkH 4أnv+4rVISJ{!Orݢ~9^ꖋknR*.PI^((`)3Sژ1+-:%8p'?, \%ᔀ^ÊH"4)MP9%7Hi/! GdL!n&{| JMc_u|_!r endstream endobj 1842 0 obj << /Length 111 /Filter /FlateDecode >> stream x340Գ0Q0P04W01P0U05PH1*23aRɹ\N\ f\@q.}O_T.}gC.}hCX.OPeĀk\g endstream endobj 1848 0 obj << /Length1 1497 /Length2 6406 /Length3 0 /Length 7421 /Filter /FlateDecode >> stream xڍwT[5ҤTQHzKQ$${"TQ;RTބ/D`y`q `~2vv 'c710$B? h(!XQ ?||"`0 D!N0+D@1d H+fc#Ӓ '&&r;@YB-#-aPBpJb(qqhi{g@NP+EmOi@2v- ۠:CP, ) vitPPoo=" bit@A0 t5X=auA1H? C,p_Cr?a,05.Y atp"ah%]Ak@:#ZYVeX=E 0ǧP5?Df"B#bi e什q5x(5 '!s@,)? ^`X ':Z^q/>?fD]j1HSMCXO.w^~/<>'UCX#._9; ;6'](? -q_|gr"H)!0NO1BTcՂZ:U 'i^>A X7(\VaXK߲^ Gb`W /n,q&7r_XCqC<H@h+7VP_$ F.-$FrB w0c`~_(5i!ۿAaoVDž_[>Eqֿn(jI6>o>ct]$L>|;gJT2H(VS6kՖw<̜TR*ˢjb=vi$EsD[Nam2V6w?9s)4kUk1}]6Z, ޼$$I;dYs9\woU0u'-@,DrkYN*4V/gm7LX9Dl1Shٹ+VA,qۙf{ ׉ӧIj?tsӊ:+YY::nE"Ւ]:׺_NLQM5V>tbymD376-sⷪڐ$p=F[ 'cfdpA7U\+YT#1&NIԏ|ϾgnH! 4'^\!:8DոLW4K5ٟ{SɂnA7@ۤ!MLonҹ|k]xt[{?g}F2U(J7 d:.AǴyޯJaFSH(rv<^5yꋻ-t(ueSgł-Yյulk L@GQzrr{w R ˵32]wA4zTlUA~~;:i**m-uϻc *ZAcUЙkZ԰ G8 `0a,05Lkq$0īAb݃j?(ųx~i?Y 8e3U9{Vُ'-OV"]>ٕ}OrɭLĵ qC)hW1K=$ 1Tur7u'k5RZt\?^Q9p>}N+sCL ]ˬ+অ'Hz@Ȟ)]3:; iޗP? :!pAܟg(m{lg+61MhI=#MTWckJl&*A㛱^cb_ W/0;rxH/JƏ|gLns黨yU6 a4m/dN hŢ'ulx'ބSTVn^ߺM-[J-%;#" ~?#͟CBnC;I[uyvVkFRenmc^+ZjF:eh?+ZFi/4y)kUn?b$|iW+xYMxjtf\RvF̠JW -W Ev Qvh*oK{S @3[u "go?"jb,}6QaE8jxs1=CRApkG ^_N\BQ kB7f>qx0f =`}bw*pdǞ8oG.sDk)%TONB%|GW)"S7!pz73>o3>{PTk-|B4 Kki'e.*S*}6cD>h^j=vMcjNa {vgTx2YS}r+B"xI7*Y*xkM%-]V(I://3c!7>K6LȦzE5_T*5n^p1[6K} F!&pB„lkbג"Q+Ϟoל`L+lrbj|eV7>]03kF{Rƕ; /DTl"1SK]ѽq-^8fMG-X=d ,:P9+%-G*B7/C}Ӿj2;$} L&9_x_}oϠQЗ2-mTvq\՜5[%n|X4 jw5ߓoieww>&H"|ӵP~ FROkG#F;9fܝ^GkcZR)T3ĒI`Gfx2 눔6SNbD Yyg]9uPTA̋ %X`zD¹()QmW[<;|ďeΩ= T{j?r M ^U4UϞ[FG'nӦK9M[Sj2C(ăhS?gҘ>Q:Z`LK E?a'e{)2hXxhя< xq G^g(݉Fa0]U߇Z"tyv%b!⎄t]=5gϳ>z{l%5[ouX7w֜,KnTK}mA'u+2Jw~!nߙڍ>P':U}BHLy/~PFQ˻/q$/gW[% 3k*էiϻ᥊ =*[dI 3t` ނKZ%g5^"[̺sKBjgn"hG`[{Eڂ0wwz'ɻ Rȯ`5D+I[tnq:~\TN&dJT7uM\\`)uG'|HGl9Pγ'\߼4$z6\X$N~bQT&@˲"ѫǑ㭗 ZA=(Ja a-#'˱*°/8- ڏ2'qm~0;ԕܽn3T=i?*dsYgeoYvt5B.˛Lxֳaw7˔\0Fc%6a/.@|J&?3qh5F>Tȋ'8Zl(!sKvTN$ 7FI j1xMv*g>u% 7 yo&%n!Uw7**sFc@RGm}YᕳR $>"/EEIj'e^RVM6S]Ĺ276P ߬y4jr+?xL﷝[>Y}D )ד?ڪRYI/G;g¼g@p4ℾ<_GAj]E>9 2 m u\\b]P<|@]g#Bk\3u+0w7l&iT7:yq 2(iFOokq? hN,jZIk\N*{"0仾\6k$23\K#z'zUP᫋^\ɤ:d/_t?pz7aR gݜQ٢B0w{M&Xky5hޱ|W/S:{tkPmfPsc\?^$v׭q^>PmZ7K5[ f&R6yUtulf1rf=1 8k⣰*kѱAX̵F].}p@.M{'jo؂"\ƃ]RMDW΍,m3Mn9&g+O7[cJª(^F΅rs1M%gOm3ͤcVAcM~ίM(L@B'!LL^dn xN['zYi(wY<z@_FOAK5ċ^:S;2Q1?e&ph={|勢6ʽٿ_]f{7~؇#|eX{:1?F@F7p$RPk$4=PUemw ዙ""giRO9] )d,- ׾Wu{Xr~uŶIb^`U8ty x< Nq֑/ɤ exZ]lj`=lFhrboo?N~hMDhޣ5~EuRDELMtO GU/ʁ+|(YFBt*_ƘHƉ?J]zҡj ,.Xu6Xٯ^5$ϣ{-Qt4%z~Lqp4> (]j/?c ~*d})\rG#+niZ.Ԉ_٫$ nU"c>bzg3PFHR-_sXᛞ G7w>ќ7֥F"5f4_Cif8L:9791f(yWT^XCEٞ@YY*ueK|kB/H$moW m/Ļg(ޏ*`N'-zHQ4}zMl8?`PR`|eHG~̴ 5WI'&"֤?ڮ-}9^v%FM} nKFS4rMD5k$7~x,?Ym endstream endobj 1850 0 obj << /Length1 1478 /Length2 6403 /Length3 0 /Length 7390 /Filter /FlateDecode >> stream xڍtT>H( R3tww30 /!ҭ04ҡtҠt|ck}ߚ~sγgVc~E'D GRe]# B&P &0 =8(#!`S0~8@  @bR q)  J@JTP'@ xs(#PW昿nGHRRW8@ :]09 #?Rp˸PR>>>`7OEE 7 0@L` #Q>`$`PGw ƚ:}wo>@J'g"(W0A.g( W@`OG0{0W`!!#~Rs˪p'e$Y  q\>#|6PON^pDS "7AD@0: Loe1 g H#{C($(? @'# q‰C1GB}V@@߿V6y9!0ꯠ!o))!|"@()2q"i ?eG&]- B5PRS, 5/엙1ݠ0?z0]!Vro& E _TB (Gj21@xB>+~Lkˆ-LJ#_&fry*sĄD`$Gi2f' af KA8 `H`LJi bQ#e c? uyy F_/ q$G8J? o WnW)Iv! 4 l?"͸5#cm]SocXˬ`֯E:jҢq8DN։吴Y+ySŪiƊ.VO]&a +c^z<9KBlu<YKlhoDkbϳ}s %wbWϲX'uh+n_. asxLq;kYf2!e߈@X55_6ūAśZxSZXZ(4g{8S ⻡f-ccwc?TpaS}oX~0XxAB2dL&3XHz-mt2cuo>'|kau۷)4$v}9xVϛ%| dD@cL'XdbuAHm/W4Se, }Z֦%W4SJ0Wb Z7y;k3 kDASKSԠߍn2h =}Egg5`a}aN9ﰜSbG$i0dkYm8{^X1x30Ƃ{ȟ޴mv?U=Jwx=+J_I'[*+i^qw_z %ub9Qղٍdj lٺ/{_CIa5C; Y /C/ޝ)C9=`ު!bDCB/N= 5;/.Wnվf~?oeD⵻A+Y&SdbdgRI/vjxr2vR{\$5P/j4V-vΈt~˷dX7>da+l/NWoηJo],kz|2JRZ=LY>kbSoaZ! civX0;iېp㱁xO(l.Rf-޳­ϑjXH3l"8D|(a$kB滔>s][l)?S|e3 }fm=,Ԅf?~VpdkViaN^[<(u| Y~crX1HZ{SĄ'jD ~6#oJ_$dzO7jbԞ=&[8)V][E?v>1 шȡF`~Q%=T4U&ܘa}RL4~T`ǘȯ09v.A>Ae{@ o2z.MXebjE[U_7lIB']7g/JxͲ#R{;9z=bqf:ATf4>|Dz\4(.UpuTQkJR꫐󇒚ߓ3p?_RNPzrG֖v{Z37[- 7v̐1qO)nhEk .]i`by3te:/E^˧c}::n? Vu2S]~~Uh+X[QՎ{I>pb1"-={CwRAncD^/m3AC1=]&==$t7^'=3Ƌai>;hSsSzv4D:%@ź1רصaKLCi߻OXYnopԢ >_d0!C}m7,fVۄ2OqDͷsդoqqQBc+ [54FțHm+LҮ][+d4.68שԸ&L3ck7 #WJ=Ē$R6z'8lM~}ueE>V]ok|iV`,ERuwT-1Mk# ^3rc$ihF& wM{V2q "~,}Q}-A´0̇lυ2ǨԢӃuѮ$2:$bmue@kUA:cUƔ1R!1m» {$BVj&/2g028nMӅ\B5? u+#bZʮY">?74Eax켌i#yG# mY%cQȓw,w.&_Vl; g+|ߜlP%/GR"K- e #9i/4 F?`[]dh0槟3/4^5/SDsut̞ѾS0o-g޶\1T+mRjYt;&Ui9]W '+wb;#{|UqPv_h6.~/V IRwu:4P4lתjs^&\?u?F,RnѕPKJ Hħ>ÑGj؀ϣ}_O*F!|=]/b:t9M9hN64c'˅i^qKGcJnhT [Q5fB<b]iIM3A9]쁱Â5c{,m_^s[D.7[*\xcܒPrDC3_U/q_j;v4?Ī7|<l佷X=p7m0e_}2)wb\;ǦZ+-iChg@fi/snNN0cl'2*_ wtGrc M.FRF83T7.Ney,Ay RpJR9l0Grԥ +Vv4I@opw:-e.ҝgρʥX{օX6&ǝCZUFe> stream xڍT6t*ҋH H{o"`!H{G^wJo "Es}+k%33{f3 +>5 xyM}S ?__A X .H(. y@(&Ps8PD /!ErZ4yj8I*ptڡDv:B\` BA;A0> < $ rD"\l8ܡ(; qqX~ 9BK 0""6(w `P0D­!.}U _@Pogpt=p[ h+i$B"_5 n"ZS@{9\8 U! QUcBP!~1aa! x~m`M5x;!62 >P rP.^k(B!6z9Za8濏OCEGENO!o10? DD>p@t};e?3 B pWO7W7#%W79Ba,uE@C]M5YU= p[yxCJPK5ᆿ CtH?z[o # 0$@5z%[>^8vk \~,'nk;@з N_7)fA0 @ C@'q>_w)슖~ ݊h wE PP't~a}u5SL0;Kٿ j=sY]\j5 B}zm<,̺z0Eg$d|9 *9( Şe}FkHJ28]gff ӗ"oڑOĶcRd:Tlv6KS&%ԀS.fW/'r4gfi_|IaU k5@JAXN6%#}FsQT|b>E鳨8y$Lk9aӠIrZVrU,-&%yOm4~h G1PLǚowo5 $3RFUBtXrdLdc봴+K<c1$5 duT'0iz0B^^yc GhQzvD4ȷo/֩][&%:~p<(Eq O1||O]R1 +P/b,[YM5|@#DMʜ[sNtgM}jyAEeOҩvqf 3uh'e,fQf9ܥ˪X`֤ϦZx9pO=.b#w uTklGJ{æ|;ncFr.f5XseTC>^aV{=87ΰHSf[z)k:Hč鳬L /d/nZ#j- l %*\`%Lf;t̂LnJwZ7iwHvCυoU}o&ȘE"4k.9hKR^La _.P9`~L"w2̄sr021`񉥁-rLҀlb zg:js|ovfҿM9W"f#C?@V MXNl. >f_S=<~RBn·;6/3>J| q-N~.%* nNJ<+`4}Zʧ XY-72*I7?ڐzH{`ʅ%ڑ huZmՈ,tvtNn;ir>i}/QP$ywmQ́Г,N%IV2 f9&d^%KY^59K;Fup`ZCMGh3]tj lr@-:wJ37|j7jv9>OZ̰c^^8`Dlž;"&?<]m"/bsbkn8fFc]@Cfuk7ݴ֙} wr뀹T"Wq4MXP..ZpɱܕPff/}4b (JN7_S?5$yS-G<$gKNOeBj>,4ʮ$6oCګGTr0 =#y :\ Bv wϡԌ*@N(sX~kڲ.#ihݻ^뢽=; o= ңRhlhϼkN%Ӳj&׍zדS`MuR}4U?&mw X5ajLA,Az8i".gwJ#ɥ( :G>":\TK鶗-XkD3$}G āhL(L.9qtDXHv5Q7D`"s{;̅b[J,6@}iWD3!1CŏNNJ\e?RݾhOZEw&l*vLKs /h0`GQtų%)ZCos}R7QĜ3g}r8$6|xN͔Ak"YWZ"M hY8q|@'ӏ{ 30 mیFl9\N>Znš_d۳uQTG',79tA[>M#wGەUqmnl+[wm搙}EnlbSuLZʄcǀyH^e4KTcL-W"P"VAq[oawLVmAwL-iy(')o~ڍi,6 7-f"/,Aővqݪ7[܉` ǹ/<w 7Ŝ,1t[?\a/P*ES<޼.PDJ-KzVaOR4V!ۙʔCyVke{C)[)<0\e(F[өya],Ŷ+ox4Kid,FKvc/Gە`Jyld 0W kiVK|N_$8+b[^Oɒwu?9G{yIF>= tX?&(J;y4Y`Ul ==UVѱyUkֈ:`'o@0as{K[ʊi5֫/,|n}}ZGMK&tpU%ݪ=p[8U3Ԝ\Uy`~&nL#q~l0i*7 ËLcxuT%s w;Xdž+o%M"\ վsDIyJVp-[c jCɺTO{ .o==:I`AH0]$m}>bhpdެ8OJtkܿ)FC-/^Yؐ_j{^]w2y`l\rrsa7fiRX l?~ѷrw "5Ȁ7% x9B. qIXbBS"ٞWuDH\2#E[鶺aO* \^̓012֞ s$|][Ϭj,5{zw+|}৚YiHLqp2Ga%=%$2剀)v13kg>_>,*d&]u^M[ѺɁ}; `bG&M:Rcpۣ۪JҝęX\}Cp/Y2m)s6AJ{ $ ~Қ@X!? J=fj&n 70d)mxׁꪀMOIt촻HZ_vӜk_Rvh/v ߌbR#.3.E BHāb:/JS#ϏHJd+38ûvEwQc8>\1~r7kDd@xe]k5+g9ZY r W`R_ dX?u㯶QpbpPFNn/G>~S|wb0|<{U=,ot/5)=Rom/dVj\a#z 5^6Iϕfi\fCZ2 ψ}ǔnO{o J_[q1Uz|ev?X6y+OڡΨG>&Vܦ(mlv$PlтDVЭv7 Jz[n^ _Y=8θe9?ł 9L X< 4[:\Yi2\:BD;yH #yG$$|\6וØk̩'{)/kZ_[LIJnЎiҞ> +%?L]v,[UKvRXDSuSO8\4 dpe:!l^ &ºQ'kݬ |Nz} J\ R!BݳUȢ'~~] }K{_cs s ]\ֽ܈J-# 2IM*9=5p| ZYF~`ا $ͯ~=h7ڃL.gfFcv$E&R~z(+P]TH˔H["2!ykZ0QTW*B>+1}rMUejE*~q8GZO;-enX.> v~㫠fk0,}r;F5]7|9vڧYX5X;W nTqR6</}Wt2_$YIN{(S赮Rb}W< ԎE7V6}]=)b`V B$ y$.RcUFxSV=ePW!} O5*1q6:h0.#T @glA fjz`\!XG3T$˓hmyTfyi0سڙ?ːZsy Ԙz<^MD5YyW' `&y/oi{pHm[L"R2)멅48=HǐY(3[O݇b3/~;WBeu>v'(K3q+UD %X;M&opBu],]S'ys"_SDm*qoB;Ċ?n|Hm6^l܄Oݷ|wA>ߪ߬q`fDYJC\wX3DӅkA)U[a|~*# FCk_2viԉ*7U֏ZMb6BB҉w{%Bgg{MҸuebȳ9ml篛\jZCBA~46oM*]oc $ *&˘ZGRbU6Efm튫mqۭo36a_¿ALDm<ݟt1qG":B3r:бL@Q8UsYz1E&5ܤ}UuiBCFY ;%h :cGUb4xG7[fiKm2tm?$2)3>\=nx.SE谁ga>|ɰ6-l:g{*B$d12Q»V-uDcoqVhy#)_x7w3A3ǎK%BA 5N|N&++BRFU";I a2Q]o4,ے)ZDϰk N͒ q x҃qٓF/"fıfڔB&rɋ{賢$41k~}G42* jRu7˪:(Nbl$8&UQ] E՛INtiڂܩIÜm|CblunwD*@T d$^'C{@¢݁b̉s+Yy7s^3 endstream endobj 1854 0 obj << /Length1 1608 /Length2 2582 /Length3 0 /Length 3368 /Filter /FlateDecode >> stream xڭTyY~KOS@ KHm@m-E*_x/H( $x D ʊ#%' ""?{=1D’ C,7rd")/Ot2+3A" R(|uDoMqހhAcG|&B[C{<ۼQ6f85βFTqקJjQ䲩Qo>iDiZow0F; ӱ1h4Dێ 8)8 >i)=C'uhj^}NVh\r]N检iƸuIr[bR Y{GeGq8[`=8=w]Jk~U!T7+_z~@eO&]]klmin]`=qeV0dA[*m)a#Iـ5.i?AǔU'3罾.!cנ\W܏R( ̆?Y2qn*JD5ss9H6\dxmwߝټ-2&47%b<ʋuZBdUSR%'/8ݾiڽ-b LjL)p^y/>1䙸J{=;u?k6$2}*DvasJ@i(6ml ״2k(ߒBgCX>W]^/?O܍)5\a!{/ "Ă9DP̦pntʫL%C.cj;c5' vVO[̬XͶEY{ f>P5!B0:ooX cOD3=lX&Ү!1FnXh!2{9!HǍxi&4p[V ln/הEw O:v(oy?js`9DrWcnqک{n[SrkG7`Nfn|zِ1Hr|}}>H2y}XиGViUeZc |M.Jjw=)p\ʚ3yYI^ٿ3|-%9nj+IXn~9mr{5Lj/ڰɳliN'ʙqp*P+#JTwEh6]Qs_8Y\ݠ{K˭ֆ4QEc_ΐwQUhH.se*_0孰󊖦g o_Y:VaN %%4=7%Ap[ ƥo:wƲ@ZVWe]צ{J~gROvWefZxwdrHSGe+| g/T%o}uBS:uMl>QY }=>tpK_M8\'oy\vg/LlM3ᎲFbּ]/w[jT߉b:**]R..Ԩv (}0ca|0f܂ORq{O B/t_7ϼLSXovheNLT5p<èd a-^Wmҙ)|߉<z\QES )DbPf@}@ JHPz:qΩ 7=O`3`B7-7/Vo{tI0qrN oWk.Kǐ~ǎUrUI%jYĤmpͧe"#R2nʝh%%d%\M'cS/Ijm~Md1|3\KT!qF9gXoz>HӔV[ғds76??6,e&_$=( L:%'Gנ&cO.K5&LbӊE\JQ=~BŹk?-Rr}tIBǸd3|NjD-<}2@Lwa#&T׸Ń[N n#5V;:#v?阧_N#F^*WTnyj`mKJ endstream endobj 1856 0 obj << /Length1 1144 /Length2 3231 /Length3 0 /Length 3977 /Filter /FlateDecode >> stream xuSyt,I0 nEa: "$Oc]/,U9X00EC(Dأd"6D;! }Ŵ +N>pY%`':mծ75vgaK<mܪ` I鮞"LWCd+&' +n&=Nq#|$ر WWH݈bg92ê庴On:m=*' ;n&I|S' V~~Hua8`G/esjQ4z% -/('[9v~JPlr-睢:!Ȥd7a:cp5YQAƹsN^j5i-{/Ug9-x.yJ1+W< ܪYka>d߶F't+$ S0>dBtdJl';vaԗ =e1Ryc،w[ 0ҮƷE泃Ik N.6\p.CE9oHҕdTt^T^L#:BP\Bw]mZ擣omxJN6x#HajV! q~.X.h@O~\*+gx#sg& gTzn:(#B0^nZg2!G6yH 簀i?Tpe&hz )QkItgyT_?)k٤ޕchϷo+e/doUK/Np=+Ѫߙ-tEǸ>,:w9tjX@We]Գ,RO\m?-+𵑎Ѧ~ߛ_ځ^=I"m~}l{JAy~ygĎ]>r̄~uT)sGeMlrMgaA`{z^ҳB^ӽ{>;NX7gT@FDJ'f32餟TX kVIKTA5 󭛡SBBðp)3ЃNgF/(ToUT\3@k./pKR"[4+=x@Xvt̀8Y %'X&pGվ+6%+ł2{&, A䠻PuqϚGg*w:9_Gͧ~RUaٷ,cE"٬1cpɵ,z#)֡+tgM=ĂZ^vЖg6l-:jTUƲ_yBOgj2sWiIe9{XفdS% S|'oȍLnO GC7H/"Uܙx&M/8rad?`|}Rg~X,ʨ֓mq R;aXS $7@w΋"_X`299_lQ|9_&?rp>WrRPMbru<'YY폶w&RɵntKөcQ鋙#nIxMM=?$,"1IW,}ԿڧzLɮmfi^Muj׈ufhBf!ǥ8k>DǗ'8 vSċENcC۟>EPh\1&R/K/[fv\}>o T021l0WZa_oc@ S|2@eG7tz99夆ֆ J 1| ݂Ux%*"9^_C q幮%O.M޼R9|"LU3}O/Min7Z(;s-jQ:]H VtItWg c&*x}-/0N~0.{a@6K |I)RZz%h&CWc{m:cd#%RnKup2{US8_(@LW n;, Ԛ^ *N.:N kW?Z]lxy>gv}Z/"&z fGfl A?Y pO/ V29[56"[=, 1Hh~^jP~ŭ .7?xXoss֊Жd'p\)d8sz{솯%%Xo{ZAFD %e0q[%EQɅ7[ 1,T G2FM?SBA"56qnzV%w =(PF!Dy<,;>|t ;s_hɸMUauکgsOyTb4CU$:\k&]\6ʵ2o?-j(<ɲl35olo6zKS5x]j sZ/G.nN)}!ޠz)ǘM 'Pk6/m:4=?7,\rl`02zrB^tP'@V˞\D5?覵Q endstream endobj 1858 0 obj << /Length1 1177 /Length2 1734 /Length3 0 /Length 2472 /Filter /FlateDecode >> stream xmS{7!kK EQmA#'UqmykR3>)o<Qۛ䢌TO~)7:-olz1xl߮augNfCUuxҁ=C%l^_\͠KveAʣKu]F ׵[ 4 ¼çlwb\7p*r~Us++iU/!Y ;]q# "#LSvؽYkd5=]έy2NPH9Qu쭩~λS ]9CPsfmui\ Vn~">tjmyE0mB&~`~{@΍;~%ӋĉzgF_&~5&k*ZדjQ[76U:3B*bѣ/?aŘоug/HC%-1J-{ bvidtsL@b"q8OÏ˴{y*)S>f}/f{kGyo[6 -%W:3Yn\JR@gw({z Wʍv\d_vos`ml+P賛 |Od[]#;hHͳ|;;ʞݩuj' 8֙@+Uti<{r׍pJ?6_TUnlY_?өjֈ0ʨaƛ+=@?p~wLnzp`6Pe0žoKn+5;뉨%u+A5Bm\Cy:9Hemu-W|ҹoNiv\6גuݭCލ MBSt>?Mykpkul|ptȻC z@~;J^%nxHI>GSL=y|3;2՛1?~> stream xڭTy\E [, -a AD%d&d$I!*UT\ R(V *􉊂(M`[|Ls1M] A!@ S0  p)*Q\qE ԍE + 6,hFH8kVLd_줣-Kqy1a\p \~|= 0?Qa Bp8}8iB3EX@lGaL PH,!@y"Hi "I0\@zI$ !G0Q<>IpY4!a -(14$JT8 1KL&0IC$D'B!ICrKNYxBaLfA$E T\:^(GhvH}3 2} A"gSA>Oyq2$/Wo QW91ݽٍF'.*ub hß{ QrMYap9iS,s^etGo޲=/; ^x0l 277šzvgjg=E_zSW>]1n81b聆3LB YHach.:m 5~שA 7'oȨ$PP݅t@uPl[dmByS̨'6=)cx>]'":"EWo|=Yxh`n)n J$asO㵑A2e6֏m!N5XԒP0UꀽVu OX]X\s{ 82'5]n:a9cdzDr=X׻نEP/TWZƨ1rcr^ޔIQS)E>#/7Y@:α5%;{Z7u([ IeABMG2W^G;?oBUnyK1OMfם"{|&f`sPy[mSdî\֕?g.jp5Wo֮ ㇓گ*͝~`b^>I]x5B\eFEfk%G?UmU-GlW !=a {o#6PzAC0 MՆuB겫9Z]|@-*PmyGnz(䎍nǵᢣW>+y!sYFiٯuc[%eDh)XQzfR6R(.sˉ0o "^רY=YwcDYWGIݺAZu!.$kƹg-"/*痮2~}}R3icKQ?bcд/\י٤?\ =ڝI q:4?1Oۺz~w}njtjM>X?J y~gFYAF{B4ԫoḅT~w]1g+*,{Kㆤ$nQe^y)N흔5% [_jU,i.=״oyRRի ewTjp+[ bKK<+]'肷\tr 2orݩ>X[0UuWhhw7,m endstream endobj 1862 0 obj << /Length1 1626 /Length2 15378 /Length3 0 /Length 16220 /Filter /FlateDecode >> stream xڭct_%vNl۶]1OضUSUaN*vvoKp텹ZsPj0Y8ALl̬e3w7u'e'>E&% ௝ Jh qr4:@ $`CH89{XYZ:t i'`n6V@{'g#/uY6@ VFY tTm6@G7 `ܘbLn@si@/s?.F37 `j;N"7/[UUR2 @CI1uK:w>9ߑ9ZF7i/ `ijw^k9Z]muHLlŧimcn\v-+R<6qW%iz;?[Qr_`ŝLlܼ&Nw/!>nVCYj7+ۿ<)Gs'Fdhw_uv<4GX[v2j-g wh,-w Wc2tKpǞ/xUDOA7PE0Ũ9\'7޴Q wW' ,Ggoh-`%gԩ'O4c#}Lq@&/<`Zzk]Ju[9,C u_ҵC %Nd\ڇɪ_[APGs<\,Vѧ`LP ^I>B\鳥Mf\ofهSp~K(l՛qT3/ՂpR-W~F~W,[7 Y#z/B7%n׌w쑼m~dwf}+p;˽U-֧J(>pe ҨW)!j'd5)z> .>/FB;_N> uX̯$?eу^8Ul1 74C݅rzFTb@.s -*pĹ1Gv~܁T-A=p}њD_gpDE}md9.፶}z7 $.>J[H3h,h?<n0Âξ[":M t:<}1lO:h?:[8A7e|5sOe۲ hÏ*h~f黫{VϢ+nKke8*x_:iMi5ڃZ,(A>1 >_Ha񓀢 yezn U),%xn]ݝ`('VN|ÁeWJҔ qrQՍ?0ɴW& i+шgDq.yXy3L7N2ՕWVSQީwNQv%mU[: 6ak~R@AKZJƍY"Mb||zSCv~'^׋O׈LOGZ$:ĜorFɎZ#`i 50rnE\h#UĜ8֘Բu+z - -"N;la}9`"ɏn7b`?>_M 62e#].49GdU\ Qh\Jݡ9@lr;>FhX~vR9}㑺r ÷ߨOI߱.rwHeǚw 4@ΟȭiXC88 %O2K˱4=]lڠ0c%}mِju<6oRoky x7edt % 6K>.%!h'%FLޣQkT=+ඛ6ˌU, \K"?^n&Dܲi1UE-Uٌ՘8v/&>L3U_h%} ہE>cx۵F{ͽj; 3!lu=WTKx} Uz㔙yn̈cԸ!y}܂R`{IxȫzjWUhbtgN !ч{~ofr1$1.\DR JԝV1M NGPVY=q6 XdE!ePz7%[_;?YH_k: MWKiECnXwR1_M(X2+<[C c1Q+ BVgǹ'5ǰ+xodmC9S'޲1|n|v'c{&rGHy{:16Nٰljvɩ:W)"51{'I= 0+X@(GFQ+J;su-Y SN-ƷliWUא/p2ݍkh8y|)Mbށq0V6qkP=5c` EJÑGϑDN;~c*g1\E qqʰV.zGO)R»"ќ#&8P4f# ?.VYeT2Z̞gj=S vT_2Hk'WddnT ^0BWsv1P~S<4q7-n>e)bcLr!Z]HE$I@N3/j.6KlWf|TzD6 IJ}?Wtq CכJ;]a"^ucVìЌD]ИsxyEC6707kQ8mS43ԓnP"MM¥ Gwpb횼Rzǝi|EqQS^%.D(̬0j|9՘\]ߕ ȳom(zePrtxbqo-IN3Qf;yEhڸ\#_c]Ȗ%Kߍim!wz=-:ba`l{+ >X_e9s-|~;⬺j]p;96R{j+%պ:aOI}? c.IYUB2թm3b9z!]^ZisUoWΉ̠K@%]tV]6sA%\VitGz4}d54gUTq2/G"(,Kx8P>K.8~ߏr*n_ߤH1F$`m# x4z҉KL&M8 PΛ l.q{:bЕa̢ kTNKE=bqPo i܌hClDpA^t$C_賴AGߺbR3^f!Sd#.!ݷMB7~R?7FZ[+,$M5ԆSgYP]!x FAOWf?`^|T J]W'>rd^& v10zsz > ?`"IgK|dSn]8%#Hi`2Mt d!eCEr?ԠmZ}(fʘH`!{ؓܓ^k&Ӏ450O卤\g\Tu9,]=hl-eaiV3b6WT|! VALhpAK_G+ 3~>O!ii}+#nr@v|T?YRsCr1"!IzT3#P&y3ϕBAvݮs0zNgRyATqTO7KϼM1=S\Yoh/Y٫6'Q]^<ɪw˛"}i@$#&љĸ6Pj3VP}`Ć&;ҙNd)8<[wR;SGGHRlW:|U ]21MfAqmi}Yt$O0UG,$ȋmgfj\?]D+j)+=sT? 3\Ĵ2/(< aXeYVwO/rHL-1)&u83?Z+֬rJWw{[V.X|ּ P:D=dB0Xădo[[L S5Qx2IRxŕc8 R=[zY[h!Ro2A&YZE@#.)рYbCDZ2<.q(i cpi \" @TΏ1eO` t{+dHB,s%E?otkQ}詋ˮ|_k'+,+@`7ם-y% !:lfgUaY: 0`=KY6;T}oժb:]*ZҚ%RޅJy6ʪ^tnIk2\7(9/|Q"@-rN 4eO?l -%q0Zo*;Oښ$՝rx?Xdg('V"hi (·W0e'[&;7<ؘj )\ u'ZAAdKdGIT:-{laUa]ħgh}O\ǧo42`KiU?a 36yn=7k <iovk#{!h#O Vg: 9#Ԗ(HDryܔKGֹ [[}Oep.E 멜l@QJmxHw5kCuCcn7w&WF+9 P=ڸnm[lw !?˜uN VIxM N,x>ᩉ]Ⱥ- Kh>F3>hirtg:U$*sn(#QӜlob3 ZGܔrKm1+8fy0d)فvTl_KXib>`J M[モ>Dw8|@S3йE]"]lc:1&5±d*ִ9y3)m>T\l,wl0,}&81VxyDoP}M" d8 |$oIţ5o#M!3Cx̓c|x٘ٵB`&Q !Mc39%Tb,7"+dDR³ԩ-;[ ][dUdWv^"l}čjT77Ɇ# 5VU1 y;s9%*Ro'8En#`Ro'^8mV=ԗuf/1IK X{B P<5*Dsf,M T|JEl2=</'eXH| :ej`]Y]q&Z-ь:ͬJ*ij`Zmq5޳'E*!C^H UDæ8h?QfxLڽy$2Źv'ff+a5,ԖwiC<QCD;K]9vհY }6Y6G8o9|\|4lp+.MXP\1ĦK1R63ߐlq+0X _)}'R<.$25R)ݣ)vz)TP圍n>Md,LuB*(>}0k/H:ݞ(U0>1iydݍ3XFmF.|TcID^j|=|p9 b! h, 8=-tU~|6ڛNN_7St&עIhȝdlAU?=6rk{d >P^vY&$MjÁ}LcD9* Du_taISBِkY21))i.k*6'Vz_g_1hB@ܾqmj?X(+|}̼bn *`oݻ,G :h9:)Ǜ Æ[G=~')#_o PVr.3N V,CɔqǗTU@1M/%NkUӱQqk?Hx/F_&\п@n)ɛoU%~Țqb- {PjufM u}F) Ɔ}T> ~d&/)сؙ7VF(3 Y5XDɵ.C'/Eq5g(Ns9[3Mv1rsqOٸz Ծ v<.=B~gHV QIJ3} Mꬕ>):|^(M;5#d=+}f]C3R04糄`\hFR\EMe_x;<nj{Xn.}wojPɢMW⛑eݓQvC1:6z%C9Ԅ.؞[# <0)ODnm!P1WO}m&|Gj` 2r#zkj?q_mHj> Bŕ0 `wIr #Zh?S6JI̬igx0?\r\d믶kqQX{բ"̕ܙ g75d ]B`s[yU|L,;LIo,) $x>s=#aL3@+:n|A~[M'A~$hԋ%̅osa}=> 1b4&]H68xJ9P y ?$\ @Y| g0wb(+p;2x 5}FQO.ODH0X/OxciWrCN+1`vIV^\90ezh-֪f;/E|?9=O\B2;Ek~vJe{ KK^4(Dž@_¤/c]LZ&5NY9}a`XtA-C8"*!&V7?!jDa3ܒ һDܒa'xtRW#y!jr~$6b3 Ħdo<\@43Y).Gs!e1/ Y.-<\ِL BYȶtA x5.%?<6lvn %x 8^2;X6I_:p WIWyUJ,}X3(Lh:#Iza3ۘϕˆUP0Ƣ2xp pϥDB[`zAٚ&T>&>$؊EAlkS3cD&y3?l]twբ7Xz~p_r{.J5R<x;W4k}s}^f3%i]Z'2hviӑ/;-qeӷn}?joVHmi吴-jB! b w>]*\*ѼAy9 Oal$y?n!QLjmXٝPBxڴ:*GXjm7eƾٶR*jOsA/WXcN<#j/* 7*WC!n/8kS9ň Rk0+}wUX {$DB9_OU;S rPBM/Ѳ' n 8K@wk#_b-qkN9yzB82^t~h , UKiJzGV""?{Ld.3=+b,[ŖO3WQ-$014f4,z͚uFέ* fGPBFZ.6Szc?fN[d`ǥ\}, ^)*4Lp`zWV =n݇֡Uy;@~p.Ol3+V'ZqPܝY/1*:5fh|:a]~gtKjZYpc>}6"(ʧcX(6aw[iIhR&4&U-KY:[f|̰ YWRH.%Kea~W74,3+?1 5!)8&N}]St{.&۔%>,N({w΀w-e꼹:~^W}CE@c"PQt-KЉP:4տбX۴U~6Maz~L۞ܵu{7 tzh8t6=6Y`HoqҎ m@mr[: OZ#]2cMxs!\ z 9nL⭲/jsZmm?BI#/!pzY.g41S[e44>')F=}gcrJ]3XqQŘmOk!w9>[sQC/3)G6LohO0{p6/R9+r =hh\QUؽ؛u.'a^n 7ȴW[,\`>-uQ>H`1R&U[?1_EU(]ڻ7vC5ߟ7@$Gx OٰI<8 ~879wkz?eOd'rOt wU^f"&r ^fW% fJ $hX/#0 65t* v@7{!MbAZv:G T,f{VٝI:{FF"~@B, DcqYG.ߓLIhջ+sDq= UhW5"=zF FNq%>O²\pۓMd-똂~pPoqS@ gr0Ωt 4JN?x̑IqI PCD'g {uщ'C >(O yy}$9 l6w^F$ކg  ,#FG̸doEI=έ qdu_#PhԾ*@mF$a "x*f/ Pì;/\/b,}9RG+Y&hW x)i6MŊ8NXCWd\%f4czVqF.s }^xj&0^DYU7EN|^!Ŏ /-9nQ 趂Yy̪Ǩw+jՅ[)=2;XVĜ2]#TzxGaM%*+J 3N𫾫hJ=)) :k<CaΘ.]a t.[wɂg=F/bDHK؃ x.W "n_{e~ZcqV; k4/F2LN rW,L;aFY' >"t4tݵ/ДzFK9]f;-!7 ^BKˠ)=+7G+d[i !y$ q^ݤ)g8ig-_D<uKh@(XZ G5Ơ^wq!!7:_XnpZp;Te(CR:%Z&ӢǗ^:iڻny):7'sbRG hZډ-=AYlQHԺbn/?fyʾ^%XFGQ4e_U$ql`NNgS5 xn?JJ{ a 6<v"4$-p\96ZgU9h/jE^V0Mny9ƞWP`Se:KNv1:g0 Ftf1]29N_QvP0=')ǔBRU)Xs7 ET!p.Kq0if fΦ=tL'\fx8Fұ1> stream xڬsto&v*mFIŶmwlIf's:?3Z7kY(HDL ,̼E+;7U;EyU௜Bhj`/n h@S++ lea PբO?&tP}p:8]B_;WK SR֑QPK)j@gc[)@h;8l}:؛YS _,1hj i tGEp:Y}X,]`eojfOJᯅ__0eWSg+GWߨ.Vfn/_ZWc+{+X&@f@pZ;]\;Y'_9XmXX4uY7w0[n:wDM `4cRtp@2 B -fkhlwc=Y4?c;+[;߶[B+I+O%o%װ7:ZrXN8ڛ $dut7 _UonyFT ``f{& / <+:[y_ ?jlow_V= 4[_q0 t6>X֤^RXSe^<|q K{8֏eK՗,$#(Bݢ; f2(C<׊Z߆d<ܝRQ5(}"bsz $s/ tD7MoFiA/>;L>yz9:w9pOKgzFe|d RӦUFLΒKtYx$^2">$IxBlV]֠{E|E oMOQ ߟKٺfҚ(*:f($ W 5r#Qj=Wfge9wgֱ=y~U`Kj^]hAܧ`{ō@޲k&捑ɧK5hӛ!(d4{<,W 4#\V0N=Uiɤn*NѴhν>l;Fabg bH=8!l6l#K;7h ;xMh70*͂ 5d=Dn->:?27gݡr6,KLlLk @է{TZd+<=m~?L:)b|jȪGpءy6h<{8b<)(ZyQđDh=אCFYC(hPP"~pnbhiž#ua!8`M+xRb4P(a/X:w*w~(~qWA#՟a ͈U`?pjBvq`Ȗ[\ŧ\M]3jH pelOc8_R2nFZ,ˤJv(+*iqghKr8kX5X87;?__=γ[Ai]0Y66ƣ p־sq&gsfFK9 #YL\jUr,4O^|z;.? sBQԚs1,H>5kM%~y[зv$ZR- JZ^ HR j _黳,#t nq1i6aJAlpr #mË>xIZ~H0lY.)JM=%yZd ˵V{>^GLh±Y:_oDZFRb{bn1j@;P[G6oh_INoZti-´9='QK, П;j]qed3x:8*ozB@iM^LS|rTw0;g%7`7烫XRƂGYɲ]'rhrȣJIY@u;Ӹ J̳aWPf=׼ŽXLg7ogmxR I>!.gFԖE.h@_=RЭR"v/yt.`1D%D3O]pOInep@%OK:=jĊ=QmZn{r7So y fIg]3.^ y"5وn?>RR#^:E Mŋ) 8+DQib-A<Q_ n8&Ba#W ױh[Z^b%ޫs=Bh ƥx 8Nˎ0dv="6U)evh5_/bMAr.^Sh~iM4dvrWmIB+$-;:XZy-6EzSI?m>9 gʼnRCxXYňy񯄺 CZmڝŢŰX"! AǟPT=#yyl朸~ЬQYƚfs%F# gYk ~m/,Ygpu޵Kz)'=- p^3\vf%PdFBEE4AZ w/}p|1k `M:ӒGZY$PzivlF'*MI뢗Ck a5PmmWBX|ԛE޻$v!Dx{xq%VKh)M9+=zZ.SL,-,2c՛!xϳԮl4z%Zwm\c /%rb!mMN_Wk*8H$,>+oPo=~nD.odȞcYj/qp 6!J4P "KR\̧D_A E:$q조 FsԜk?״9tuJ Uli`z=j#=5?3#mg Kꓶ;{2P- /lb_l)x\*BJcRM=m=g}Jե^m} B1DrOQvS,VnD5?)B GUJ 4Fw{b#= Ku?"@ &b^?^QBY8t ==oļJn9 /C"tGDjR3&%)"O ȚR$a mYъ}pbIăcDЯ8Jq/]r~^9Ot?hBȑYFT4ơ`_I1%a ٕth; 7 q:{2"UthĿ)r"v얬RRno/v_[;W*ہk8K; t}!4Bַ$qzZ%6j'DȀ)DF҉oi'  }*u~Ag8ōoݒn_ܳ-'ǔYjn͢-Ӯ MHc1?k6"1v LrByI nTË>gniW] `uڔf$F(X鮬@&p#IH}eԧR`#\ЧKW.=^*z0=ܭp-f7ebHn8GRs䚣GU0+EDdqMe0;Cq$@6ɨT}qczfZR.P8)^,^bean\, Ÿ2 lO,BHUD<9X*uJmmx~H0-p@lY+o?>0Rut L]5{[Ye%H؃@?h\{"|$]! F{_@~C5o5Xщϩf)>h:M24LkC?O'ߝ~2K/$-iҖ0olj iwtcb|-Y5gfQНAl !~;TOU+!?thnjNf<,+6>i_ַ "sNB ).ArZPct,~~-4R/ѥ4;9maeKP[dpD08nГB5u1 %-tynRF9H&J|U\)gvi4ĿSEN^hѨGÚD%Oݣ@EvMh xu2^5}갏іz\Y>^j#>#5dOTRSy>1#AtRh<0em=66QJ+,هLT|.g&! vBB ԥ>qbwE"XO8E,A?ґP; fzlAH4u"w35aK"\<@΋A8hfU{m 񝟑V-ULlr|ﴼs |埂kVKaEn(9g~k'q A=c[Z!$tH~AmR\l:cHLf~n(+3[pNiK~"O4w>^OPs" 7hS@ '–K/:OA$Рhuebܖ,*!^U}='``O]8#?4}܌~z ].w(RM8GLl&l3[ýr4)C ?Wws1_ipH#$EIcE"g,/3D:Wdj582Q #{.CH680j(Ǻom9#G.$pʅGƱB.߲\:=&IG񾜰 y F+_*rcI0Q) ҂)&u?ϑ>4FuA/hbHU)"tkKyex ݧj8ouzXy mty)q'Pʟ9]}|\.aAT0%~"rVxLn.+FBTHmnr } TG;N>~yamgo{^9\ŏVSAEȣ:o~1W/FEru<]p)AzDOsXM5yǩ!X2gC6_B|~Fv߶P/Uw?Y9Iw\2/!ux[nGFD.@)<QJ*wK ¥<_seT <˴NR+pE |oLVf%7a+c/< `߯ Qߥ'1oS (K1']0M{-i- R=p {Xe"~97`tgrNıݗR~#N-}t4G9Oi~'S?\%7hᴼilkV]T>m4rAsưicXN=ug%L :# 1 !t%֍i{E$o>~w'*? =qpFk Dl>A'UCd@`I Yőxeh ֏Dš$%*7] Gω<.ikfGk?k>&X)濶RvK3m@bqeaC7'ʝ~+{UK Gj37;uȑMO=!+ 'k9J;+Z9ΩR+Amo nٔ~Z*Jf"%8&mM(u汦4uA֦'>%)q9ޘީά#ϊmdٗz_K":5qk Ih4tA;Ckzgoq; !ͮ%ӱLyWZ l'sv !tC%Ks ꖽr<'ԝ+WepW:Z)IӆN`QW>j9+j*'pv󢊸rS<5O,1i ׇ)uYBF|hHe1JK2R i.m١QiQl) wDh6w*:L=D>PkV:ISC? L?٬,=BR5h3KcU gX!Xf7ǽ,P̋M8U.r,*tI~g)&B,uRd; G(}^^2c\!sN1 u]4Bس{rz;!XkA&cc9cvX\DMB*-VI_*Ҟ.%&NdԄI ~m0k\,TD3:7Top` LsPS4FZ92Z ?? swzpB^+T4֧FvDF} xɟ0;3/ ꊊD*l_;aHfߨ}vJJ?=|[o5zM٪I^#R6e6PRM.E j=c}Ë-gIAvo,3^< fi Oѩ>|L8TU֞8o˛3kz'O f4J I73 CrSbjv4|(I #o9O[櫏l7*,6^cȉjj P~tyzNreT}83#ɱ: W;b6n ^bU S=6Q-O tIy͘'5)(U~6\XM aKb9N*0He1R.f'gʭB`A]!c0nr2wl¤_ ~f)k{%op ZÞsط-QI4Ua&uuxSz$monZ]h_P05chTqYǖ=ڪh0ܿih^Oӯ3ĩ><'=i; -jk|'u,k1r{q=T JV#/7FKȨ .!^SCX3NH"[<_y9j G}nNo#6lIl٬簳%8rehDq R޺"%[*DuWUL {rJc<*4j㵈R%KCtkRvBUF'xRZ,) Q wVsߥqe wV%߭c[ڮw lj<=Qx r I{#>2q[^.瑇v 1hl`LDxjr4kAJw)8] vM>f8fwl^肕S A26PنEibA\ߩCtR_jADg?Y_Wm,xy3{tP DZR͖^NG ~uQ*K4c`@~6zO)apkRdEo"%qDďvCy` 7̹[:QL\ACp1m ͣ:6gcKm^vk1s5)lbJĎQl#qhDH|fe ZN+n ,$fgYP;#ŠW^2dG `'Ix:^x*͛!<5AMang'c~ gM ! W]s@vj0M?Y_'%օ`m3+7leج{-w6̥ xZ YGcgk'^#M\^&YjQ>lT)-}&%l U/9L!aU.e=eBB0nf@We+r(yFc@F"!!FDRf2|U3:WSPuz@c b߲hx6yX4_Jp',();$+wY&i!Jf de铭NܫArF4YtGQZ뮇`c9;vRxUkdXe=umXKpXŇKǦuN2TŖ۞قš;CF~tR,YҿgrH$6h )p$@v;A'A%,sv\L!E 'Gn \#d:dJS~3;i)_9;$~'g~LtGNÍ/a~) /qґ6X;2jIx7Ù0$MK}9V V}rY2)/ /ٯXɺK7U# QMn@vrL5,G ShYajmF>6/YP{J}[)pu {|[ 6Rf4e2끷նLOd~?[7ђ-&/xĢ?*I$u~v5 \u2} Uhg ۀTh M4[yS]k3guTOV\VeFj'$8u0%x5>At&D7(N1(:qs|_!ӯssKR X :l 1DS ro-"޴2_JO5@UV Z#%ϘnƢ0[aT v,1AGyw2tydO3b8WfA mN[R` $|«M:u{SQ]\VhǪ8Ws LiM,=OxZ`XHNbG6"&*:oHnbW w.vmfV};8 =R+s[aTubMa۵!}iR.=Z1f JxVYx,]NtKb2t<0GHr׮Cd)L//{!~btv0w_5&YzEe[6ŲbNxdDʼn@~ Dx߹Ɏ{\6J B-~J G>6^iք ֳ{yqk"jSK_|#OOj9(o%ʫϊ ҳra, M|"zX k)wx&:Lݤ V^XUHGܗWH&WwnQwMEKؒ_IN,LxrOc˹?443^ƸbN8u[.g0L:@[A6Q!^ &ܲJE+)sRAHT WxNzBR1fvfM>I&pOf2y e\SS[]");#l1 ,%_(qtSTt(_AV9R܈l 4Y.O"ͤaRd8rb3A@1 mSa`cuC x/GN7aw@3]{&泣ܵĨ(З ^sJ{l[P9;k+dA3'eJ)XS>4-LiDv>n2ަ$!,5{ "soOalQ1v=hzie+{~OFDv*S]|jcvu&M2O6!B8a:Xni#tt ܩc8`'%vvObA-â HLyqsO6CHm8W@ȑ   W+Һ/`m;¾3;t2mTh|dxO˵sHFYh6Y׽~A{Gbk_զ'yRK2,\D*s͉=ZW:DonrBm .[EB"XBH6 WH ޺ .=r':tgiH+Z]4 Yu9e+3D+UĪa"ógN G);qs} ~z/'zD _«xHIIVPGy |3#c؁V$HcK-)E:lmHYP*סs#s kL BKi}Xi7j2?8C6Y:0$Ȅz`(þOƾ1xQ2$ _`GΕZ.Us\rֻlLl{k?প.Y`sv zܣb347NID[+޸vwCv lj՘T( #ߺVlD51{N"x>E!ghq=E'B 欽O܇)Մ|Aℂ4w!SD/< 7$w<܌iGcM_On%U#9M] L HԖP>W"9 K/neOh0s+8J$ tl7UqM6mUrja{,a!Kj%4 'i .\A:Ic#~35"\w) 5E,%~.n/t \bCI2yQk~WAh?8詹hm5#뢸4V(ZO ΰ]uC!OXM(N!LbrVӌ‡-~As,~$7t(\2A$Ÿ?-ƾZ .`T` 8N";:k}k5s_fG(!I$ՃAz&7[$D< ZLbc}nU:tl)O!"XMjd:m5xrs$wuNyViu] Zy%A$%ʶ S$@^ˆet|+g}+5$Q_vȬÝ:Gzbv)~n)Z*n;[H7$0CzHiz+fIH"#)'ѥL(y`ayZNfT~՗[$b؍kZ鬏-S8Fq7N.VPC/jui)kH4R[`&Qz6˫|ωR u]U=T6qH)u1bdBB1oM@a4K >vZ :) !IVo9v/Wf9gl?1_QyNS(FݷFCߢ=g4I>8ܜȟafN\h?{}r= BvC5n@W1sne ͆]U[\03LB?=)u u\x2NmD&:ѯ1)L_t|͖ X}MfOy6qk[ISr&ݒ~ihg[xcsTMpVFlcf%FWi@(tڏ9t)H Pc3)U'ݾ̱4N8h~&dh3\;y,x˭ƀtrb]k) mlH5P &]jEoo=> &9CUXZ2˚qSTQLP(]@o$y0z`&o+-uv .je0/3C ѣgqQ/;дDb:JC9ާr3IZ::ZE%UWS<=kK,0^}glrc]B>t{C:yK@ot>0vaGoe̩)mv")6Wi֚st*AR{EaP f̀ ̷1^\[M{^} UfbgN[C#)53m!TY*\lԵ(*)2NiB:*kT|'#%DǗtWIt2ÐmA6-A77naX3g2yiiIъl!(B遃ᨌ:`ptN %: 5 oY=B4/C>NdgɬͱngBcͷKs:xԬ||1q۞xAsq픵{iY~-^u o%5# `r8Ʃ] lmSHUp@Pu2KpK(ockMn?kg`+8/դS=gYZ.lp(QX82OCW bk&* {nQ0͐dLYHіWF _`.˳w{wYvٚ$(8àvzL1aIWg=oy:h)o_6f24x Ӛˆu3Xl۷FbkrG"0}8&)qw62y60#]sEҤߘT⦙4 }ԣcdfAZX`Fw t6Y |H;hn:W(iC2HOC[i)Y١2>,V4&VeN44z´F8 eW)xR%8DOk xIt%aZȹnz*=vJXfCo8"]oD]v< 3a8xwzoăZ($DdsV6 (lp%2OOA.C YV{kW4;,%ZNWB; ΅aWU8 ,0a-s+LDl+u:֮A%iԖyAo@<=T Q&{D=>1 >\Йm<Hngl $zu-z 埧@buz&Ϗ3aH c@w;_1ja(qBh mGZ4rO[ɹs}k"/-B8x 㙥|M{ w#_f!KO^CP®7EJIQa90]ʍ R#k xtL4M 9~AF ˗Ϭ0]6_#ԎeR#>W?K(aѳ\MЦ&ꍟԻ(ww xDVSMݸ|"? _]IA$1)kKu[Gέ΃3 O?} \ ׻|;l6ͥ?lXxxeZH)ˡa:#JI.ya~Gj/Vt?Hɫ\OːZ@ދ _ߥ"RZGdWnN{hU\DV=NG2]R3[Sgvdc 8u{ӊ㪼v >'2CYs~V͙ː_,П|X= 'S(B//?oJz N~C! `Κ;*J @ƨԠ{|EIrh,>DkpV~/m \$g "+O4 Boܹ|v'&ӻ|bЦ&p*XAю0җ[U!J]*`O kLE@H 4єWeq O2lgT~HV;Y'iAFm_9(/쟝x_3Rpg94`2tr*c wetcmG©h>-3ȫPNI[Vf0n$2R %!ڦ1!gIF|GQx.6@ޕXBk] ֈ74y?gk,&!X`,obf9\ M3uoP`~5?m!|31J $>vƏt0r8a<ۣ JIEe&&5GO$*.UZ|Nkɒ?X=㥅RgN9Vf~xwkCظ<RX֒Y-Ո寽SLb<c8 LO" ,܊2.1YkH⮍@ 51qˠ@ySJPr?jqQu$˭1F,B=aGv=̂ ;(G"|B2wCXɸfVBb5 z#:)9HNgoZieat4sR\%&c/0 ,\WJ!)l)X!_$IkmitL1jҩͽq[)Q+:v^=0?,i%fX00٘YuN*0gjX 1…ojs# ⭰6I:FGHA-cd,2 Հ^ߗ3mv9HG/FF)Οxa8E-kpåhne q乯1{;zDۡ3K}(+Z<NJ̤*gH9\imzR{RY&M PcT(p eQ< z)%WƟV n0vf|;ߊz^.Ik"౟Gaƿ̷Hlx[c?"D,/_40,vw`rk ~fr}55VfA \ĸ[`ÍQA-TO ݴP 9D4IBѶVj-_ugΏm*bÏ-MXz٦fk'?0r*@̫N۽#ҲAYctAcŐpU%c]C3!E y)Z-!}U> l0j20g5řX_Rj}V䤣QԤOcM7PۿNLMt[d=RAJURӑƎ?D7hp.BZc yC3hLDZi9)ZyD0|}敱ԇ5Xiq˫6`>!٦ݩfFg!bScvX8_d7+ 2W:7M+JJ#C,J24 hũx.)^߿fA w:{㪱N̤''v@c}Py[I'FG{L[1f$LЙ8z1v-(/l&tD%&Vīw˜>b;IYn?J,0){݀1IZl[;0U3-Jf\s] 6T+`C=e&ʯ%e^H/2<1K9\PfBŨt3j=1Úf 9Z-$눛+]HAj+Wb?ݻ[d$`˯#Aт34+ѝ3u2Udnx؍NcaH-e!<:ts[SؾhMB9V#l_2LO[HVjR,?[: E&o)`9ޮ9§! FY_)n2?r9 2݇,|K`gZE Hs7 P=`BsƎ.۪0ɰ- (> stream xڭct%l&;v:mvvl۶;8۶m۶59͟cﺪkMJ(D#`lkqaȚ[:;*ZrH(M% 1RR!4R\EQ?- hnj h:P 8&V@\LV :mB mnqRLlV>lmi͑/#h42t3Q掎6N`ncdlO&*_/oVyadfOnG0䯧?- Ku20q8ݜe;Y_e8;ۘg/_n?oY+_^s'G - ߜFNs3/6&ۍs:EX&0tNSTA[j=_Ed  15i?17X[UO ;_hXhYm6w5w˛;L ^޿*6@+s_u lfndi,6:uAUU%)öߩpRvg&5[uJP Iad>GFf"bϳ@?>y/4"6F̑_`#gk?z@feֈ+"5#ͩ3{p\Xl0خN ϯҶ75lL*~}c_`Ê+xMLѓ񳍍 N>L-j^z \^`g\AQ;$dKɣѯXvzӳOd#C]7=8TYI 0}O >!^]؜a]=Q>mRmjV7nH؉,!Bñh}ٷI!nh{%ZQ\?BwWxlyRIޫ)w R`Y^{BR%>I+\j.7tlyhڨ :U7VmR yg{b4 j.u}_kIo7akp|f_J@ZF1lη!9HSCwJjPOT^/ҳ%zvw7 2nQ:krͿ4pdG{?B5"$Š-& yqU֝;j#ds+=XX-)ɒ ]ω.c⛓!o:uEbz 2EfX3LPa"M1֐=]x+!LjCG&+nJNU0`'.0߃[9 @Ɠ7js$(ɓIauUH`ϦfbbH׸MS'ɐ5!>HQL3cYN5Nj7W(5fN]du󃜘 4WaLU2Y_Ox9p2[Ϩ I.oa)Xk2)P[V6!k_h,)?x.fXVGMeWWp,P=e Yc?K?_],{qΒ'Ɯ}^]!f?0RIS+saN(LQchFz_G߁&LSԤPm7Fe6{O7oN =M)i'?q2Rj96)Wv-xO^Lvf hӺ*8 lٽ:/3ϣI!<|1h߬4d3pxp5},<,ڂn\"M^S4Q -Qf&Qyk~vZ)c+B7kͣ񥋬fuB3f~Ujωefja LGSv2^_A%ۀiSy\`7R|=[8ir_WMOOaUV"S0pA:Gcn'Q׌4Lu5,_ΐ"+U7'J(?ky#UpǘDLGE6*C#lQTp]$KɷۜIo $qxg ^ؒ0kpRvo&\0jz@d`)3V3zN&-C/u9^0 y HtDb1#|MviZ24J#Zf„ؽ5.YpQ {F6#lwwhyAK9U-֗o|)-X'5<(-ynHm̟[;ҌI<0S(%hBlSL%SIL:/cD6ȑRxѓB#/x~ aȳf#ЭPsVTPlC=o^bGt́j~䟼FJgm\p )ݎƋ_9F)tb2JMĀj[,&`M\?l<# XyDkb_Ӟػ$;p)؍/K&exptY0IP#JQFtA yNC8tɰ (GOF5+]?(ߊw)IqX`LxbI{~)* T=M_o!\w `JY44V_۔k٤mԆr>#>\a9;w/vے: '2Kν؍@(^';AolY~I:?4.삀Cc&_c2'V ݄线 7IxQl ْ[G=C@]F~~l1 %]$[ qb ϲ IxGATZokRҺ4lZ5;%sNX>4Y+[w{:x?u?.U+WR!~F6ia,T<>bFo76R \7Z nA+WBRD|H҆^tig!ݥhqss%0hq&fcQh*LȠg1 Tč-fW+/߭"i6p$UdQ\_/P=Se#=<b\"02j*C! *oG\KRNU=`ΊF]Ʃ"ȕzG&~@WG=X1Oj'ok<6sSR_ :ew"V;l$-lĪ,tڸ`8Y#I˚YLUsݘGJ3O H1Qi@ڀ7 /yLZeMdq 2PL5< slؔ44Bj<- \ʀVx+]Gu k)nq3z0+ y>𰫁E ym$F5gz0Åv?ub;i8^ᵨvVb(?4>Vcʿu-9B[ЂYCjQU|4jA0h:,EWn/PuHbzOIH'~ ]w?mΔ!ڑ3<{#FI+_kAl+f3GMvGC&ΘDoz* %ajM' #+7&L=]򇣧$h$)&(܈ yVd}'dKRL1QMOVs ߓ6X$M 3ĵ(Lbn3+Y!ɓ5}G%~W1tiD# p) EF="YgK)#(,0fLLcp(~6nu>[ |8NR!bצ "]7z~Zd\xl1]ekI_3Q\wU(zBdlv `3=e HehE6ajX_f#%-& )!K0ڥ0UIGc ʭ :ϣHVQehr hTl|G]H!HNP :U]H7# `$X |퐌F+dqC)ɤӯxPZE v~HQ咙?2WXE]3rhH *J! Z5(;Ŕ+9(Rle'0\/oa^3'a<Ǔ劦ggQ8\NP\ԁe4j.A`|g|fJxJARyZD{SٚEJq^4v\i:s'wBw5:zs98(ifntb֞zs-)bxK\ ƎGJk?eVV̖tT112Zz(NȚd* U1H!l:F7v՗ظۻ2fF:¦\ v V3RSҋ>G|Z,;]^P$G`F&QIسbe+^`"85fBAˆtFNr)IѸGYR;}f{a`2-4ZF ] AwUӢLS4n'^D-rKReI=8WP| ?n]ۀfb 5ƒQR Si? FϣVbSǮM <Pα ewhhP^>A-""|YC֬N()mmɉdU?'/`:>B}O]uDR=lQz [za&?/ɃiP2D7g]l[.?m[k߄yʝr<}fkգ&3jxn a23>/vJ64$=oX^lls3Bo"bgYJ!U5iR}^> xnq^*^ę:ZRsetY*UdtbB0u] 7(X B XszU% 2z̷c6ӚQPqʯz,$e:P9Һ̸ ( ʻ^93vu&~6ygT$[zF{.l*U XsOt|"_z33-BI%T!+ULIhw( >ޗ ?~~Hj]َe0_'gXȨidjd8ݿ(\讛q$0قJQ] 7a2ghٔ FAT۳H7PP5AqcV3x6#w$LLx^PMe t-c:E32~Tύv㼀TmU=0)\$`uP8+tc"vVa1{o)NIu9[f,+T'{MQTS«RH|{Bmin#{()~iVBډ :hGg89tz kwnR2v7+<+|zlur ޞ6gȔT &a9m ;랓M]p0?J׈hn*˱ذxs8EwF!%'cjl YEZ~xwQ& 9b&9>s@X:& L"- 7E%`.%3|4L-%\NeΣ!c^@-5.RT&'Z雇JlPSsV0{zlZ%}$3hO,ŗƬeCk.c/uM:41i \l:b"х48^争6ŝlz%}&?OCC *_\s$|dX&=^KZ̮r/RcSJ.n$*ׄjoȾ_XɌ "o_ SU4"NZOO^;@#~+N@e ;?x~#Q6 ;qVC"(b3 iGR ])Z̐xbp-Š- <~R0ou'RˌB:JrIYթlONn yT藇f/[@}ဳ FaÈ8|NP4fuW9`XG? /mxeVix~s *q1h:S7M!s26[(> s cC y/ŨJh {:gLǸ*{|A oykq_4Ef޻d74w_)q5q:"}]\ڡ3V<ĔC'F~tdž97LEm3uD#,ӘoN%WePE\~4e&1 "RaCX: 5`/ו Ǘ&m[]St ܚڮ==9J-U><zUvcCtu^XirhUu9SnFF~x4nW>)5]7ԟOtH)NG<뫽ՒPV5Sqqm8%I矝p-ij!,]Js C ӅjVTT|l䱋CnQ_:¥ë mڛJXw,a$qKWIQp]݈rmn@J qA$Sw \bMw@L wcgm/Rxhx ^UEB, k,c{;~@jf18g;UX|R3 X#7]n;o+z"@̀vjO^ܾH& tL2_ЃiSggHed~q~ DDfE#@T vΧ4< 2Ø*VCd+Q>a}.R"2\D -iI'%Y.p IJP$Xw',T'I@,&M]5l#{};IS#2Jmy'xELF9AQ1Y5&VS t PԟH]]} qPDx1$Djh #(Il BE KׇJ> m G4Aʖ!'#F Zi|i{E[GZhhQ Lp|yuu-?C ^.˰LNu0Ie`_HWݔAK9i^]fZ{n!wzmTr9flt*u?eG$ $ ߢ޵لU Z`X .oҏ>޹T%&eR$.N8>HIYʰ \)nEi]$Tw#D7 Ni]9X[ K:䰃2^9ZQ)ZN2 BJȷ%dv ]vR.ߺk ITS;4A<v,`/p2UCݬє`Nw.}HЫݿ(JБrܬYbϳ&܊qD7ya 9. .7I{K)n7zEiԿčj6d}BjUp_ ;gL3Qt^ ҒXw,GŰ5UP|ASA*ά:*X!dr > ygE B.<<~J&o`/ HLg~6OEhYC]pg 0|FCWW/}%+pi/rq=9Ō 'G/.PX4HuY$[55x "Wɷ~GI.y0@nY͹P};2@''ɵsS׳eMj4繕i7]c) ٟ#WwP58ۯ % j%ŽG_Р kt?r6bE;8m_| EZ/T 84)2^GK %a(ŃhwV'H`AW^ksLe|ם>Z"L%]y YUPegrz|"}741Ҩ.%v`p /wj%aaIv+Vsw Cfz&v)&,H>b-TīglQ% h"0ؾMS+{/mS!H3Ђh`'n{%ejw#E F~5ħ~r^_sʶU&zFd&FAFZ0J=:koKBkgnlAoDk> !V%,51&<`01 $N]ۆFvnAȀ=K6'`3h :{C/1w )mq°[b1_YB"[uTd_'+كOGڰQCirֻ`9F̨i'E0%8Rl:o; `. F3ͽuK E𬭃j|rfCH?0nѭ'T 2t߻]5c aÌ}~iS/r /-v"wa񉶬Yc]婞Dž? ~7J%prpd!'6[(0 tȀWUW+8\M&x-ڔ[GQA%^h鹂ɥZt栫J4*jThD oUxh1' /;q/k{]sOQ/hHNjIO1")7׹N(!Ba\EY8[Fh[7}2_ J iR0phD¶.ٱ\'׆ #{qV,+S&{l}i <%-+ug]օys4oy%)9A\>cNfShS \ NP.^s ֓]xp tr әƯ >e,N8|("@O3D?k),Odw?}9^kP>j1E72Uv*ӏC %D$dOCX(eX1Y5/jɳʦdHkk:⌬/ξ| _C"3r+M 8f4s^$Ն1AK gߠ@о$2,C 3qlnB2/黤GIm#tޮ8 7^Tʟe2?[GkJtow;;5ȥ T m~7˙h yCǦY[F:*B|x~;Ö~}Tb7pF B?5~Oh%~O H7<=Ӯ|SɑŐ|X)Ղ*Gy +b-IOˍJ%2eZSV~KlwxG{cVm͓ xM7TCg`بZbH*ry0B!HD>8пwpԥLrTki{DOK W]3*` |et>#ǁ]^ݓ'׷f(H0j_Bkڒ&25Q}'Zￒ"P1.2s(IɑZkU#l{ "kpWk[V8>kh(KAgHvjN:aBŔ']q'}%5E%sZݜၢ?`%0^i t*1s7TڿP:*eI< kQpT'4~.ʷ{k֋F/E@"Lwi.l`&PiJ>\ȶ# CAvq Sz|>)+QR~Ș.5 ݜ W @ь"gϠ5l]ͅ$_Eۑ  AԁJʯ]P }aŲh. ت&qs]|$+InDhvu_HEu A˱~i߻n5E0"# AA?ys˒2x q b;㠽?ڧ; ]2F|ߓ?娘1! ޛ2Is08% B`nL߇>QoNe - _qɨwcm$ոHOL{NzcMi@~[.#G`IO T"ϏR+]PɅb2LܕcEs_6{! αA.x Jd %Aymѣ&݆*/+9J ?m P>Q:-T->Y7\6`.Y8.&/-≅H]eJ;~t xfwV3C;69CPxv+Ȕn-B}Vui# :Z4+VM;+wrx1HJINT $a t,֯PHvw-Ŕ eBxi1g*<=e`]wVR쵐t\:7GVd.Dls ΅į@,F%$x&aPLBe{1zjDPrH1a= 2VSp1^T !-iquXSѳzta~rO ,@b])ժOtek2 Xn{ne֧2*ao]9\)ܦ塏-qL_-Vq$W~>+;}sf'vK.h9n@-i>= LL{HƁw HfUtdĵoB5eD|3'u{uLRN =6T0Ѥ}~5M |$~+p7v΀b+k8 ;v<茶&eQu+sTx!ɾ"%1v<7>lt9&IVB~\J#?bc:٢q9OÚ vCRlr-MV/LduqUASz 5=yh_)K7*pNU-pl_)VMw6M\y4z*$iL9Bs:!./;ex24UqٌfeLddWbMkR'Ĵ`xƻB?+ Y["c6u)>ep80`HηTi1Ka2 bp4qت|Ϊ|됖#YeB"rA^-t_UFF]KpzxۉPڍ,1h~dQ@56:^XxnR>{(7p>eu#ƛ$QhXZ0\R2Mc${crj9-y;ֹr`̗ 絾L31ð+L2PX`œCA-%o?j8*~֢e,eƮ- sz꥖QhЎL==vu/SHNiXl{Q3Bj:~ΐw"Qg(`Ţ9IV^1!7Y e0Uʼy3[f{+u4eD=CȠHl,^!6@ 6fzG&!.yuV_ZZU*ą%{Q}OQ'hɧP⠢{Sx#CۈV2VPBdJͷX!I_+$WR_fi31)7;+ = { oqfC/'6#B"+:vT@蠁 C!t~7$|t:ʀn!$̽+Ov̕wW@enMh(a$i1E,7ތ : KWy' `B(Dj>/";FaЮHNk܃Lhe k}=[~ 'F ,iV @pԁ~#H~Ww~iJצ!.ZW66j!m7>7^Mv72(AoJلNc6;! (rxcCU8$\# z闻̼=~FEHdpڹJevj> stream xmTMo0Wx$ ! 8l[jWHL7IPV=M̼ su;Uٛ=w]yil;<[[j<=?׾+v`&ߴț<^*;~&Q>MS >_P{=s@dkx;`VY`s4JaQܡn.Uu9\Y6><ٴ.Z.4>Dӗ}~r:-d0VWk,8yLһʮӮђ[*mLr?q 5F8@=@)& 8Rx uD\j2HV0CzL] bctI g$`htы0\F0s jd< I6zg W qȐ+#k .bsrbmXK7ǵH7Gnb>&jؐu1VljOu$՟qWS/%1{\xB!K(hHTЖ枃Jρϯv=k2UKς_:~$/ ~E+7ˢ/ l(/} -+ZXukoԝE?ZKq endstream endobj 1869 0 obj << /Length 739 /Filter /FlateDecode >> stream xmUMo0WxvHUdCmU^!1H#x?gx]OTm$|͜s_Iss :L;<Sz==׾f`*_`ɫڟk3'iѴ}=M;7rfnj-eSӵOLg~8 )ok A8 $`I\3`Af<Z]! xNky"7 _㓧q H`nḱRONH=CpB:# =%888QA~!*zƜАT?!~> tw8y*sύ }nFE>7*QύR>7G];~<6OIyktg>O:yұϓN|I/|yIg>O:y҅ϓ.}2 L> stream xmUMo:W5?$R. d9M eCkmCp;;w~>|3E_?O]5߶w]Occ]=~?}Oyh9%?۹׬B|Ɯ>);vw%g43>\ 6 EJ78 1{~`W(-;]%=xe_,b+-O;q\L}UI--=BKE1p[! Mߊyu>.N5K)Wb٬8i[_uʕMzQ)V(Txޢjy!Z2P="Zd0\ÃGR\).2*Шa!U,H`+j.5Nα@VK-x%3%AYӀzΚ>kP#5m0Woþj.ZT$X/)n)#Wo(oRZ $Kp4Z-b\1ܰJ P"GXQi/8k^Zq:Zs9dB )sL-7xJ`aɽ)f$1 dъcCZC<73JgznHȰYɚTa,_-O87}KԴܗLloK+gJ.GZyVc48Wt]:P~`rZq.n1] S/Pu7Ue:?&?!d&1yHn5)yғBx#1ޞ]Go׏M?X endstream endobj 1871 0 obj << /Length 700 /Filter /FlateDecode >> stream xmTn0+Jb'$8B 8l[jWHL$Q;o.Z ̼7/o~:W{xPCWQb6;J^ǩv'-[~Gݾߣ#i6ڿRV_n84]֚̽e[sYͮi P[ L:?=v8|`4nh7u{QE sU5Y7{C]_?{B^QSu; 3jV՞d;&xD\20-0b# !ڇ\)&q)% 1ON"ۂ%480`rH%Dd#C K .%"l %RQ NLHI($ux-LJ@J!^H :ggM597F7FN|[{}&Ff*pdk_ΜN0VG9ʱwDK4X=CaCɁg2)4X(rb0/s4lƵ.b]ʌ[r> stream xmTn0CƆ@LE"jD;oƤjgy_xN{qV'wC&]\]]u>t\qxں7ŦmN7isƬ'k~G]?ߓ` 4;RV_n86]{̭֚u[sfߴ L:?v>4|`0nhWu}QE KU=5Yw߇l?N6jwwv Z/բ,ko{&PaffIq XMJ0LfhrdĥP> stream xmTn@Cx ^"#&W R ە7iSFyo.{a;M[ݱ;w}puUtjWowa読;|SltCɛz;nʽ4%<i$>57JN.n86]{̭֚u[ҏӫ(hߴ5g( L:?yv>ixgm7~д/"$(,v{F~{Tk#zv~Wa׾`R-r睉y?&xYF\20/0b# !ڇ\)&q)% 1ϹN"ۂ%481`rH%Dd#C k Ю%"l %RQ F'b=:S:,Rx( y]eѱԁ_[WS3+!Z af> stream xmVnH+AMyثL,R~(r]]n7W~c7߽p}z\[{%8OeWϝ\'}oe<]8m|kq7,r[|UJ;P)ڮ:U8 *&~(Ia7~x;~z. OM~?/,x72 .OC+B89 :u m#)u:#@,B: 6f{b\_> stream xmTn0CƆ@LE"j.RC~8iZ)Ayo7?nkNy$냛G׎ծU[7|SlfM[kwʽ5g x=i6;RV׵_n85]֚̽u[OsE͡i P{ LՑ @4=tb/yVvL MnݞArjwf4P׏ީFT]Nrî}sBZ2pmmR?\rs<, X#.KIɌCH'hjmJIQ09da"2rG~\5hגQv]`n @v)(A'b}qHI($ux-JBJ!^I :ggM597F7FN}Y{}&Ff.pdk_ ΜN0VG9ʱwDK4X=CaCɁg2)4X(rb0/s4lƵǮb]ˌ[r> stream xmTn0CƆ@LE"h.RC~8iZ)Ayo7?^$ŝPIs77EW]}==硫nTشxGɛz?{k۝=` 4vN߷u8NM>(s&`ywS0jzQshz+&TuS~Hxqq`P<+ OC톦}SWUn}@`T;P3qtj}w*5UWSܰo\ze \[3. 9ff ؤdF@!i @F\ ` H sn4ȶ` $(Ng 2R0zd9#Cb.k(@.0[Czr aà8SuX$Q:\CAfpGR~m%^!N%$h&՚R #ƿp'XϾ>AI }3Nh25gNE'bkkؿs %|V !3?fc91ӊ9|u 6ZcWCab d1׮eF-9Ag깐3Z=I= 6-7p?)pegT> stream xmTn0CƆ@LE"j.RC~8M])A̼7W?^$PIsWWEW]}~{SCWmݨMi7mv9I+ڴg{ҏÄ~F )P ǦkZn;@1zz5= 7m=x Fgu P}?i]X<;k C톦}UYoO} A`TS7~wpjmS!詺]]ꂅK(ew&97\=̒5⒁yAa>:M1ȈK,x΍t,@F*&" C,zdWXPv-hakH/]d"btv"gg?|2JB^G5kdwt,uVT Jb9;kBX!00a0bw3W M";\88̿9Earʱs ށ?c>+q p~PrL  hi˜c>:q-+01~k2#Ϡ3\OLqRυ>¹M \)s9O \Y!O>\\/Au*[ӺkzT%C0t endstream endobj 1592 0 obj << /Type /ObjStm /N 100 /First 1012 /Length 5431 /Filter /FlateDecode >> stream x\Y[7~_nU7 hK-.0rlk**ms׫R9+H~<-igI%ZA$&cFg uư`F,*!(3X'sR!20+ZRмƪVc1˔sL1*:Hz =;=XhG|A NB"NCK8]K, % fV{y\^^t`5,#X (I4Pz<_xU_Jb晴ht-2 *,!(4]%PAJQ2CAPd XAmr堚]JZ&9hv 4YiȀj6#T ;Pց4l]֠A R): J -0Pcs+FFנ(AIǃkPIEd[PX!"}Hh@$ PU&uΓeR=HREUmi@ [/,i@A,X#"MhWQXy"iH](lz1 ]c ىV!ЪXNƐJ| zl:7V~ g GCC?יyo g7R|&\GR" ş/c0rijIl?fttSOF{#΄$A{Jܽ;TS00HZb$ zt"&zr irLS1pw¿]/'iR,,,yTL`I>ckZg{?}l?Πf'ߏj1|DB~r&<ȁ`T}cfcq`^wsCZВ^A0SJRJ{(4Le4hZeaȅFIaV+B-Xb P;BOR|H|(|h||X|8|x||` 5$֐XCb 5$֐XCb 5$PXC:G8oژRpS Ȓ"J*`=SKa*3MA?K  ՞։;,N=W8_.' -d/' -d,Dⶼ# ;]: Bg }j5($ңdM"C[WBr_ Gy8s(~ii_ p?v/h+vz7}7yGߛͶHĭ[i?xӰa`5l)❀kjz(gLkJR@vwZuK~ P]  \r3A^tK0tK;(sWXO*}iɅ\vv:6谣'|-V_Kut#7|IWg ]'nX-C:lљ훓]ɂ9Y}; V!}q:YwW1{gKG DžлqB8Qn({7NT:KȍS%Ʃ(TOSL._L._LHP,US@UV"TB'DB޽\JGޥ]J^ޥ]JsGIR]JsG!;qdCEP>$QlCEsG!; e߹E#R>$QƤ}HpH! *p e(V W,S\S`(&SEm z_1=cᱠ7WAo:Bsҽ1̢;hIcǻ_אC ~WL`=74K|hh aph) ̀0 x';x~５CoTwOv7ȈItw.u]»PW!w.BB]I]J+PEc;*twϻA?_|{('}=~χC?zC|衟=~>χ0~q/_@8~qb衟~޺yk;˙A?_|Hz A@0 b @0 bbDžAz\<{D J\d{\@06W9?vŏ]Q¶;~]:^MW%No7)@/)^]OoC xûAw7sfacD)Pl/L j_z5Z}F Ը,D1$7nf\O?M#{oN,Gǧw򓰥<ոOH*@%F6YzOs#{G={/nvg@׀ݱ'!{z{v)=__5N1~?sd6 @qKܞovm5=|gϾ9_fǧl_vpC8nbm=zhOcab0GCQsث=*<>>}2́ `fᄆƚ;c?99]~`yc`˯O| XY^/S=?)3>r&19%>.c'gꨉ>|5]\ +bk&&lضbn6F~Ɉ :b7~o{>הeܱ#UD2TW2dY4H2du[e6P FǏn<7~7ՏoHR'栨UX64;དྷ6y[$Bc,sc7lfr^t>ff K2p/6b$$ё#d'i}gA^'I 7ixvn;6Ĺ/}ʉ^y<;J 5a ޻ :,d4 ޯ6S`-4i7XjpG=}Hudd{a$I: ,iadM>7N @x@ar BynSig*U':E3RNEt}'&R3rI`81#㿂)h~S23ifubY 0rgYN=[v1441_ľe˗YTxޮ|Ϛ=X /ǰ|v,P`.3 > stream xڅ[Y%q~_Qj YmZc5 +[?_dSU\ܮ{DV02d?i$? PPJRCICu(n`m.NKQ Y)Wa>eWlBU̻L\&!;9D}5ı (N҇?B/D?v> SӟV0Vm[k+Ux[0jySF4s'='q>y-jH.p.r-"(|PS/_{}?|~w Xs &.󜞬2/.oZEln4Dλȣ»"7ɻ]t}~.oJOVjy!oM6IBvy'~>OSx$$ij4"Gܥ3 ڿt.x},ð;ZѐwM_iE3A\=dOa׊?j`-c Ұob[f-->&[w:T-OzmͿ>}{bJן>ԾI!o >9y}$ %2At>/gl!Huz܇*/;UL'lpAjeeZnIh!o\`} e>.ˀVJ joąHh>S/\Vs&V4W\IuDy>%щJҐf4oq.4e?eBxaA+fa;@:MWaZ5uy8NcH$.l7W?G` 2[ mZss5kT)1'VNyXRj.aϠ&5בb\ JRִ-B\%JT-/6-Bk%-Pd|KԖIv)iK8)6(ZsTk "QT"'y-&S[Tb[Ȓ#~Ao:&wCP+9(5URIs,*T)KZ;{;l~B:Ҭϋ쬄6WhDB4 zs8RF%Y28|dJ)ڽs7dQfIYɭŏat5Q9kj0](1U3_MΗ w SڍQXUli)sG O1{Wo  eO͵HCE Y.tĘ !0j+|sL즌R#PI#`-JoLRxE[%\%9;MDPPs;Q9-5VN:)YE!T2JZhjx ~+fM\YZ "?NruE""F_9HqBˌpjuD !"B tQKJV.y%m=~P)HsWѡ=*nXXYZJ MT\}HM3?7W'NmE-A/]@/\#J*Uր:d(u^UEl#Y=-^Ar  U^ D\&T Kj:d "A KoS7RsBgqr*eR^yV2nZku$,_ɈY˥Hh,E+|s9guOK +-.wN4e-!F[t];#A^N{ݼ#r.SYSJ&phzZrw/fٸ6" ?P IBsx(in'&{p>!yi &P\kS=Lkqol\1HAcRE-(/dqe?ukFWÐ7K}#F.r&l\&mNdt!ke닜&SJ&>0 L"^˔j~H{}?ϲqSQˏKq*u& ZZlSY60wڹҙVKI=I^fkAlaPh5q#]k{࠿6+|BSR{wHS9bmjrk![yOKQZ;R(}H_gIJ%-z-rSbdw?.C(]P|yv*{*2TK].&^S4WJp6=MGiyVGp*BXOEwǷ/]Jx?]O`i~ re|? Kt X<`5GA#qdA)5yPʩ˞RQ䇐P:K+zNA=I,8L~zIZ^ÒcyP 0 x.{ q8ʽ3twf?gi>lQx=Z?f_ߝH$;ԛhHWu+h*\7<^HuԣY8H=ju3zW3$II\H3^쳤+ 7u1hʛLPMH,$K m&Q)t6El-7HEl$I$˾g&&{ uqJ.l@j\E؛G6t 5>n[-&vƒmbt0pK=9w3a#u ukd}2IRf]+ 2ۨjP&9$7URr9G$e~`̲8CDyԩM\:bL\C`> V׽`4sGq$͔/&[/$~2&닱9+2ܫRMuڴyurEW'4_/|M{`+_o|!R{>&7~LZLI/ؔgX"  I#~.تbDɽgp/ 6+J6$q#r&IlI`Kyb{A <z&%ޕ7ID&It%wO\v.̸S;;֞p .82̔o[3稳-|bWϬ6:w endstream endobj 1974 0 obj << /Producer (pdfTeX-1.40.25) /Author(\376\377\000G\000r\000e\000g\000\040\000G\000a\000m\000b\000l\000e\000\040\000;\000\040\000W\000e\000r\000n\000e\000r\000\040\000N\000i\000c\000k\000e\000l\000\040\000;\000\040\000E\000a\000m\000o\000n\000n\000\040\000O\000'\000B\000r\000i\000e\000n)/Title(\376\377\000A\000N\000U\000P\000Q)/Subject()/Creator(\376\377\000L\000a\000T\000e\000X\000\040\000w\000i\000t\000h\000\040\000h\000y\000p\000e\000r\000r\000e\000f\000\040\000p\000a\000c\000k\000a\000g\000e\000\040\000/\000\040\000G\000A\000P\000D\000o\000c)/Keywords() /CreationDate (D:19700101000000Z) /ModDate (D:19700101000000Z) /Trapped /False /PTEX.Fullbanner (This is pdfTeX, Version 3.141592653-2.6-1.40.25 (TeX Live 2023/Debian) kpathsea version 6.3.5) >> endobj 1957 0 obj << /Type /ObjStm /N 17 /First 158 /Length 637 /Filter /FlateDecode >> stream xڅ[o@+"efwG*v Ch*RT}3{nx;|LFY'5N8|/@*5A7U8C)p &l/T$-8TzׇaS II:=0臵dq|X^˙g!"Dҋl{z̫[Ҳ(U˵kiG!< ?獌i%9:-ɵ(uUfS{{!V1n #G=u=f0aôG#\7Kb&F`$LOi)b&Mdڇ( Wa %d!d!d!4`t sj*LTF0F0F0FΘROݹ?~?Gp|D_c~y'|\nZ==tݸǥ]ӎ_n_|k}+z̓. endstream endobj 1975 0 obj << /Type /XRef /Index [0 1976] /Size 1976 /W [1 3 1] /Root 1973 0 R /Info 1974 0 R /ID [ ] /Length 4782 /Filter /FlateDecode >> stream x%y|uHiΦmN6Mm=M&MڤV˂.\* Uptx낣_."r\.ׇ|o738:ǽ]8QTfmmMAb6Yڦi[lvJf@|TC f a)mU0 hL[9ˡ62fKAJ崍ҦNLbfVҶ6ݽ~մVĬjڶѦVm)uIkyP:nsm6@#mzJ`-m98k:hm6=롅qV m~6-Fh6C%yi;amKhf袭6J^H pS]';v!mCIf>ښi;NE {hmٽ12mf`Fڎ3{FhH4mibvӶc̎8m#eL6I$,MuM0;=gЦQ/gCO/,*)>A74K癪>lk&*1NႶX Fڻ \Fd7"i#D#`DyiV16"jA?D>mh1N٠hHN4;NWя$ٍpz6mkD:bq yPD"h8ш8F'"4%"9 CqZn-4HX`V NbjYȃ|X:Bdz]YeOtl_:@)o@[0pVu*`mz(7hN?cv^{=v4zښ`-f- `#l-`"6hMgl`g6A;u/ݬ z}v `zsAn|SaF L18-!8 c0^Ȑ#S0 afa&ibi #5p^! _H4Kti]-BuSSC`e!EIbHBޙR d ^HB.BrnAB.!BRE ҠZC"'􂀘z WHBnF<ܪd-$k!Y THBn(54]yV fa7Pk)3 *$R! O8)ˁX§>ԧ>Q)ϥ_m]ȆO6|S}Do_o}պہ0'/>9 Ř_'>gȧ>5IO>c`s'$PsĘKu 0Uaܘ_Е?D1<]0 @,|bDk>o̻/z$1ˍ;=K[B&)\ H 0($+! HHDB"P' MJ[0$tD$  HPȐ$$! 9HAB"Pߤ޸Z$ HEBsJ;vK'E?HB1"!4 =1v )IHIBG1%% HJȐ&/н$ )IOB|3D0($D !<'S~IHB@ )s7u*Yȃ|(∮ 2Vu(2( XVQʸFwP 5P k`-vh4%Y3h@Oo6M+?n.[aOӽ{۸igӻ~A8 {>lC0 p&`ƌ{Gn; c0pf8X 4rͺ?BLD%3"&1IDL%}`.%H1 CLb"čPnǦuU@b$19A\!&z1INL"h2tW$& 1a C?GCLbSӸLfd#& 1a@L-}1]0@6bMS՘zf(EǸ~MBbbST?1ՏjL!snF|1 1)|Lc Q)wQ*Q2 ခ PI:[&|Z !mRmJ,"X%ԤO*ŜU&.(UPaRk X UP k`I~RW:Gz7?=Zѥ oΤ>KKڡŤk<&0.Х-?_7ԥwz9_hzL<] vԍ/=`ԙb]ܰIݝ6=ȃQ t޴;`ܤ~]w-}Lu4I6 4w7> NI HIƤ3:BLꥇ-Ñd d( 4A  O@|b C%!% *@JA?Q )APڀrAo^P"9v޲ P@Q4 T5wkPЀ"tZ13DQ PЀ wWo0T0 Pen"Pb0B Ґ,A>,( `9C BCJX `5TA5@-`-fX- `#A;t@'ll Z6zzr6CI= }vn{a~Aa8#p(1#0pL00'`NURxK-RxK-RxK-RxK-RxK-RxK-RxK-RxK-RxK-RxK-RxK-RxK-RxK-U]6 DXaI斚[jn斚[jn斚[jn斚[jn斚[jn斚[jnVkͤui&L/u[o[o[o D Bp[PK;^,{753 }Mp _%'+7§~(y¥g q._S N§9kEisv}~#&|sW/>)\M-|&*r'|rۄ۟p_qX;oRo-ۿrQ;VnJ{rȑӴ?c9/w|[!'xx=x/k~#RNUC,}(""0E '?r"??"/D~A%o|گXXbۓ k4]!sߞ/ח /utۄ^^^ҙ^kÉx'9_3[ۜ;]9Ȍ#;#2)麙Lr2y/ 3K$f 6ʄZay!r;B rd23+>&TV^!fVˡed4 3uZP}B_=?I$zYs.w!!Ir'57KכL:b2-:j2?SL檋tjm&s6j7^שypuNG6ҝ){ +?$|kep# Mfȍ>qV}j@_'5A=4@#4ZXͰZ@ M(u ̳v@7@/kV;A_ {@߱; 4pF }08;Jo&c/[: EWf9R^E:^6:bt 7,"X&˞%C endstream endobj startxref 445837 %%EOF anupq-3.3.3/doc/chap6_mj.html0000644000175100017510000011172115111342310015366 0ustar runnerrunner GAP (ANUPQ) - Chapter 6: ANUPQ Options
Goto Chapter: Top 1 2 3 4 5 6 7 A Bib Ind
 [Top of Book]  [Contents]   [Previous Chapter]   [Next Chapter] 

6 ANUPQ Options
 6.1 Overview

  6.1-1 AllANUPQoptions
  6.1-2 ANUPQoptions
 6.2 Detailed descriptions of ANUPQ Options

6 ANUPQ Options

6.1 Overview

In this chapter we describe in detail all the options used by functions of the ANUPQ package. Note that by options we mean GAP options that are passed to functions after the arguments and separated from the arguments by a colon as described in Chapter Reference: Function Calls in the Reference Manual. The user is strongly advised to read Section Hints and Warnings regarding the use of Options.

6.1-1 AllANUPQoptions
‣ AllANUPQoptions( )( function )

lists all the GAP options defined for functions of the ANUPQ package:

gap> AllANUPQoptions();
[ "AllDescendants", "BasicAlgorithm", "Bounds", "CapableDescendants", 
  "ClassBound", "CustomiseOutput", "Exponent", "Filename", "GroupName", 
  "Identities", "Metabelian", "NumberOfSolubleAutomorphisms", "OrderBound", 
  "OutputLevel", "PcgsAutomorphisms", "PqWorkspace", "Prime", 
  "PrintAutomorphisms", "PrintPermutations", "QueueFactor", 
  "RankInitialSegmentSubgroups", "RedoPcp", "RelativeOrders", "Relators", 
  "SetupFile", "SpaceEfficient", "StandardPresentationFile", "StepSize", 
  "SubList", "TreeDepth", "pQuotient" ]

The following global variable gives a partial breakdown of where the above options are used.

6.1-2 ANUPQoptions
‣ ANUPQoptions( global variable )

is a record of lists of names of admissible ANUPQ options, such that each field is either the name of a key ANUPQ function or other (for a miscellaneous list of functions) and the corresponding value is the list of option names that are admissible for the function (or miscellaneous list of functions).

Also, from within a GAP session, you may use GAP's help browser (see Chapter Reference: The Help System in the GAP Reference Manual); to find out about any particular ANUPQ option, simply type: ?option option, where option is one of the options listed above without any quotes, e.g.

gap> ?option Prime

will display the sections in this manual that describe the Prime option. In fact the first 4 are for the functions that have Prime as an option and the last actually describes the option. So follow up by choosing

gap> ?5

This is also the pattern for other options (the last section of the list always describes the option; the other sections are the functions with which the option may be used).

In the section following we describe in detail all ANUPQ options. To continue onto the next section on-line using GAP's help browser, type:

gap> ?>

6.2 Detailed descriptions of ANUPQ Options

Prime := p

Specifies that the \(p\)-quotient for the prime p should be computed.

ClassBound := n

Specifies that the \(p\)-quotient to be computed has lower exponent-\(p\) class at most n. If this option is omitted a default of 63 (which is the maximum possible for the pq program) is taken, except for PqDescendants (see PqDescendants (4.4-1)) and in a special case of PqPCover (see PqPCover (4.1-3)). Let F be the argument (or start group of the process in the interactive case) for the function; then for PqDescendants the default is PClassPGroup(F) + 1, and for the special case of PqPCover the default is PClassPGroup(F).

pQuotient := Q

This option is only available for the standard presentation functions. It specifies that a \(p\)-quotient of the group argument of the function or group of the process is the pc p-group Q, where Q is of class less than the provided (or default) value of ClassBound. If pQuotient is provided, then the option Prime if also provided, is ignored; the prime p is discovered by computing PrimePGroup(Q).

Exponent := n

Specifies that the \(p\)-quotient to be computed has exponent n. For an interactive process, Exponent defaults to a previously supplied value for the process. Otherwise (and non-interactively), the default is 0, which means that no exponent law is enforced.

Relators := rels

Specifies that the relators sent to the pq program should be rels instead of the relators of the argument group F (or start group in the interactive case) of the calling function; rels should be a list of strings in the string representations of the generators of F, and F must be an fp group (even if the calling function accepts a pc group). This option provides a way of giving relators to the pq program, without having them pre-expanded by GAP, which can sometimes effect a performance loss of the order of 100 (see Section The Relators Option).

Notes

  1. The pq program does not use / to indicate multiplication by an inverse and uses square brackets to represent (left normed) commutators. Also, even though the pq program accepts relations, all elements of rels must be in relator form, i.e. a relation of form w1 = w2 must be written as w1*(w2)^-1 and then put in a pair of double-quotes to make it a string. See the example below.

  2. To ensure there are no syntax errors in rels, each relator is parsed for validity via PqParseWord (see PqParseWord (3.4-3)). If they are ok, a message to say so is Info-ed at InfoANUPQ level 2.

Metabelian

Specifies that the largest metabelian \(p\)-quotient subject to any other conditions specified by other options be constructed. By default this restriction is not enforced.

GroupName := name

Specifies that the pq program should refer to the group by the name name (a string). If GroupName is not set and the group has been assigned a name via SetName (see Reference: Name) it is set as the name the pq program should use. Otherwise, the generic name "[grp]" is set as a default.

Identities := funcs

Specifies that the pc presentation should satisfy the laws defined by each function in the list funcs. This option may be called by Pq, PqEpimorphism, or PqPCover (see Pq (4.1-1)). Each function in the list funcs must return a word in its arguments (there may be any number of arguments). Let identity be one such function in funcs. Then as each lower exponent p-class quotient is formed, instances \(\textit{identity}(\textit{w1}, \dots, \textit{wn})\) are added as relators to the pc presentation, where \(\textit{w1}, \dots, \textit{wn}\) are words in the pc generators of the quotient. At each class the class and number of pc generators is Info-ed at InfoANUPQ level 1, the number of instances is Info-ed at InfoANUPQ level 2, and the instances that are evaluated are Info-ed at InfoANUPQ level 3. As usual timing information is Info-ed at InfoANUPQ level 2; and details of the processing of each instance from the pq program (which is often quite voluminous) is Info-ed at InfoANUPQ level 3. Try the examples "B2-4-Id" and "11gp-3-Engel-Id" which demonstrate the usage of the Identities option; these are run using PqExample (see PqExample (3.4-4)). Take note of Note 1. below in relation to the example "B2-4-Id"; the companion example "B2-4" generates the same group using the Exponent option. These examples are discussed at length in Section The Identities Option and PqEvaluateIdentities Function.

Notes

  1. Setting the InfoANUPQ level to 3 or more when setting the Identities option may slow down the computation considerably, by overloading GAP with io operations.

  2. The Identities option is implemented at the GAP level. An identity that is just an exponent law should be specified using the Exponent option (see option Exponent), which is implemented at the C level and is highly optimised and so is much more efficient.

  3. The number of instances of each identity tends to grow combinatorially with the class. So care should be exercised in using the Identities option, by including other restrictions, e.g. by using the ClassBound option (see option ClassBound).

OutputLevel := n

Specifies the level of verbosity of the information output by the ANU pq program when computing a pc presentation; n must be an integer in the range 0 to 3. OutputLevel := 0 displays at most one line of output and is the default; OutputLevel := 1 displays (usually) slightly more output and OutputLevels of 2 and 3 are two levels of verbose output. To see these messages from the pq program, the InfoANUPQ level must be set to at least 1 (see InfoANUPQ (3.3-1)). See Section Hints and Warnings regarding the use of Options for an example of how OutputLevel can be used as a troubleshooting tool.

RedoPcp

Specifies that the current pc presentation (for an interactive process) stored by the pq program be scrapped and clears the current values stored for the options Prime, ClassBound, Exponent and Metabelian and also clears the pQuotient, pQepi and pCover fields of the data record of the process.

SetupFile := filename

Non-interactively, this option directs that pq should not be called and that an input file with name filename (a string), containing the commands necessary for the ANU pq standalone, be constructed. The commands written to filename are also Info-ed behind a ToPQ> prompt at InfoANUPQ level 4 (see InfoANUPQ (3.3-1)). Except in the case following, the calling function returns true. If the calling function is the non-interactive version of one of Pq, PqPCover or PqEpimorphism and the group provided as argument is trivial given with an empty set of generators, then no setup file is written and fail is returned (the pq program cannot do anything useful with such a group). Interactively, SetupFile is ignored.

Note: Since commands emitted to the pq program may depend on knowing what the current state is, to form a setup file some close enough guesses may sometimes be necessary; when this occurs a warning is Info-ed at InfoANUPQ or InfoWarning level 1. To determine whether the close enough guesses give an accurate setup file, it is necessary to run the command without the SetupFile option, after either setting the InfoANUPQ level to at least 4 (the setup file script can then be compared with the ToPQ> commands that are Info-ed) or setting a pq command log file by using ToPQLog (see ToPQLog (3.4-7)).

PqWorkspace := workspace

Non-interactively, this option sets the memory used by the pq program. It sets the maximum number of integer-sized elements to allocate in its main storage array. By default, the pq program sets this figure to 10000000. Interactively, PqWorkspace is ignored; the memory used in this case may be set by giving PqStart a second argument (see PqStart (5.1-1)).

PcgsAutomorphisms
PcgsAutomorphisms := false

Let G be the group associated with the calling function (or associated interactive process). Passing the option PcgsAutomorphisms without a value (or equivalently setting it to true), specifies that a polycyclic generating sequence for the automorphism group (which must be soluble) of G, be computed and passed to the pq program. This increases the efficiency of the computation; it also prevents the pq from calling GAP for orbit-stabilizer calculations. By default, PcgsAutomorphisms is set to the value returned by IsSolvable( AutomorphismGroup( G ) ), and uses the package AutPGrp to compute AutomorphismGroup( G ) if it is installed. This flag is set to true or false in the background according to the above criterion by the function PqDescendants (see PqDescendants (4.4-1) and PqDescendants (5.3-6)).

Note: If PcgsAutomorphisms is used when the automorphism group of G is insoluble, an error message occurs.

OrderBound := n

Specifies that only descendants of size at most \(p^{\textit{n}}\), where n is a non-negative integer, be generated. Note that you cannot set both OrderBound and StepSize.

StepSize := n
StepSize := list

For a positive integer n, StepSize specifies that only those immediate descendants which are a factor \(p^{\textit{n}}\) bigger than their parent group be generated.

For a list list of positive integers such that the sum of the length of list and the exponent-\(p\) class of G is equal to the class bound defined by the option ClassBound, StepSize specifies that the integers of list are the step sizes for each additional class.

RankInitialSegmentSubgroups := n

Sets the rank of the initial segment subgroup chosen to be n. By default, this has value 0.

SpaceEfficient

Specifies that the pq program performs certain calculations of \(p\)-group generation more slowly but with greater space efficiency. This flag is frequently necessary for groups of large Frattini quotient rank. The space saving occurs because only one permutation is stored at any one time. This option is only available if the PcgsAutomorphisms flag is set to true (see option PcgsAutomorphisms). For an interactive process, SpaceEfficient defaults to a previously supplied value for the process. Otherwise (and non-interactively), SpaceEfficient is by default false.

CapableDescendants

By default, all (i.e. capable and terminal) descendants are computed. If this flag is set, only capable descendants are computed. Setting this option is equivalent to setting AllDescendants := false (see option AllDescendants), except if both CapableDescendants and AllDescendants are passed, AllDescendants is essentially ignored.

AllDescendants := false

By default, all descendants are constructed. If this flag is set to false, only capable descendants are computed. Passing AllDescendants without a value (which is equivalent to setting it to true) is superfluous. This option is provided only for backward compatibility with the GAP 3 version of the ANUPQ package, where by default AllDescendants was set to false (rather than true). It is preferable to use CapableDescendants (see option CapableDescendants).

TreeDepth := class

Specifies that the descendants tree developed by PqDescendantsTreeCoclassOne (see PqDescendantsTreeCoclassOne (A.4-1)) should be extended to class class, where class is a positive integer.

SubList := sub

Suppose that L is the list of descendants generated, then for a list sub of integers this option causes PqDescendants to return Sublist( L, sub ). If an integer n is supplied, PqDescendants returns L[n].

NumberOfSolubleAutomorphisms := n

Specifies that the number of soluble automorphisms of the automorphism group supplied by PqPGSupplyAutomorphisms (see PqPGSupplyAutomorphisms (5.9-1)) in a \(p\)-group generation calculation is n. By default, n is taken to be \(0\); n must be a non-negative integer. If \(\textit{n} \ge 0\) then a value for the option RelativeOrders (see 6.2) must also be supplied.

RelativeOrders := list

Specifies the relative orders of each soluble automorphism of the automorphism group supplied by PqPGSupplyAutomorphisms (see PqPGSupplyAutomorphisms (5.9-1)) in a \(p\)-group generation calculation. The list list must consist of n positive integers, where n is the value of the option NumberOfSolubleAutomorphisms (see 6.2). By default list is empty.

BasicAlgorithm

Specifies that an algorithm that the pq program calls its default algorithm be used for \(p\)-group generation. By default this algorithm is not used. If this option is supplied the settings of options RankInitialSegmentSubgroups, AllDescendants, Exponent and Metabelian are ignored.

CustomiseOutput := rec

Specifies that fine tuning of the output is desired. The record rec should have any subset (or all) of the the following fields:

perm := list

where list is a list of booleans which determine whether the permutation group output for the automorphism group should contain: the degree, the extended automorphisms, the automorphism matrices, and the permutations, respectively.

orbit := list

where list is a list of booleans which determine whether the orbit output of the action of the automorphism group should contain: a summary, and a complete listing of orbits, respectively. (It's possible to have both a summary and a complete listing.)

group := list

where list is a list of booleans which determine whether the group output should contain: the standard matrix of each allowable subgroup, the presentation of reduced \(p\)-covering groups, the presentation of immediate descendants, the nuclear rank of descendants, and the \(p\)-multiplicator rank of descendants, respectively.

autgroup := list

where list is a list of booleans which determine whether the automorphism group output should contain: the commutator matrix, the automorphism group description of descendants, and the automorphism group order of descendants, respectively.

trace := val

where val is a boolean which if true specifies algorithm trace data is desired. By default, one does not get algorithm trace data.

Not providing a field (or mis-spelling it!), specifies that the default output is desired. As a convenience, 1 is also accepted as true, and any value that is neither 1 nor true is taken as false. Also for each list above, an unbound list entry is taken as false. Thus, for example

CustomiseOutput := rec(group := [,,1], autgroup := [,1])

specifies for the group output that only the presentation of immediate descendants is desired, for the automorphism group output only the automorphism group description of descendants should be printed, that there should be no algorithm trace data, and that the default output should be provided for the permutation group and orbit output.

StandardPresentationFile := filename

Specifies that the file to which the standard presentation is written has name filename. If the first character of the string filename is not /, filename is assumed to be the path of a writable file relative to the directory in which GAP was started. If this option is omitted it is written to the file with the name generated by the command Filename( ANUPQData.tmpdir, "SPres" );, i.e. the file with name "SPres" in the temporary directory in which the pq program executes.

QueueFactor := n

Specifies a queue factor of n, where n must be a positive integer. This option may be used with PqNextClass (see PqNextClass (5.6-4)).

The queue factor is used when the pq program uses automorphisms to close a set of elements of the \(p\)-multiplicator under their action.

The algorithm used is a spinning algorithm: it starts with a set of vectors in echelonized form (elements of the \(p\)-multiplicator) and closes the span of these vectors under the action of the automorphisms. For this each automorphism is applied to each vector and it is checked if the result is contained in the span computed so far. If not, the span becomes bigger and the vector is put into a queue and the automorphisms are applied to this vector at a later stage. The process terminates when the automorphisms have been applied to all vectors and no new vectors have been produced.

For each new vector it is decided, if its processing should be delayed. If the vector contains too many non-zero entries, it is put into a second queue. The elements in this queue are processed only when there are no elements in the first queue left.

The queue factor is a percentage figure. A vector is put into the second queue if the percentage of its non-zero entries exceeds the queue factor.

Bounds := list

Specifies a lower and upper bound on the indices of a list, where list is a pair of positive non-decreasing integers. See PqDisplayStructure (5.7-23) and PqDisplayAutomorphisms (5.7-24) where this option may be used.

PrintAutomorphisms := list

Specifies that automorphism matrices be printed.

PrintPermutations := list

Specifies that permutations of the subgroups be printed.

Filename := string

Specifies that an output or input file to be written to or read from by the pq program should have the name string.

 [Top of Book]  [Contents]   [Previous Chapter]   [Next Chapter] 
Goto Chapter: Top 1 2 3 4 5 6 7 A Bib Ind

generated by GAPDoc2HTML

anupq-3.3.3/doc/chap5.txt0000644000175100017510000034031615111342310014556 0ustar runnerrunner 5 Interactive ANUPQ functions Here we describe the interactive functions defined by the ANUPQ package, i.e. the functions that manipulate and initiate interactive ANUPQ processes. These are functions that extract information via a dialogue with a running pq process (process used in the UNIX sense). Occasionally, a user needs the next step; the functions provided in this chapter make use of data from previous steps retained by the pq program, thus allowing the user to interact with the pq program like one can when one uses the pq program as a stand-alone (see guide.dvi in the standalone-doc directory). An interactive ANUPQ process is initiated by PqStart and terminated via PqQuit; these functions are described in ection 'Starting and Stopping Interactive ANUPQ Processes'. Each interactive ANUPQ function that manipulates an already started interactive ANUPQ process, has a form where the first argument is the integer i returned by the initiating PqStart command, and a second form with one argument fewer (where the integer i is discovered by a default mechanism, namely by determining the least integer i for which there is a currently active interactive ANUPQ process). We will thus commonly say that for the ith (or default) interactive ANUPQ process a certain function performs a given action. In each case, it is an error if i is not the index of an active interactive process, or there are no current active interactive processes. Notes: The global method of passing options (via PushOptions), should not be used with any of the interactive functions. In fact, the OptionsStack should be empty at the time any of the interactive functions is called. On quitting GAP, PqQuitAll(); is executed, which terminates all active interactive ANUPQ processes. If GAP is killed without quitting, before all interactive ANUPQ processes are terminated, zombie processes (still living child processes whose parents have died), may result. Since zombie processes do consume resources, in such an event, the responsible computer user should seek out and terminate those zombie processes (e.g. on Linux: ps xw | grep pq gives you information on the pq processes corresponding to any interactive ANUPQ processes started in a GAP session; you can then do kill N for each number N appearing in the first column of this output). 5.1 Starting and Stopping Interactive ANUPQ Processes 5.1-1 PqStart PqStart( G, workspace: options )  function PqStart( G: options )  function PqStart( workspace: options )  function PqStart( : options )  function activate an iostream for an interactive ANUPQ process (i.e. PqStart starts up a pq process and opens a GAP iostream to talk to that process) and returns an integer i that can be used to identify that process. The argument G should be an fp group or pc group that the user intends to manipulate using interactive ANUPQ functions. If the function is called without specifying G, a group can be read in by using the function PqRestorePcPresentation (see PqRestorePcPresentation (5.6-3)). If PqStart is given an integer argument workspace, then the pq program is started up with a workspace (an integer array) of size workspace (i.e. 4 × workspace bytes in a 32-bit environment); otherwise, the pq program sets a default workspace of 10000000. The only options currently recognised by PqStart are Prime, Exponent and Relators (see Chapter 'ANUPQ Options' for detailed descriptions of these options) and if provided they are essentially global for the interactive ANUPQ process, except that any interactive function interacting with the process and passing new values for these options will over-ride the global values. 5.1-2 PqQuit PqQuit( i )  function PqQuit( )  function closes the stream of the ith or default interactive ANUPQ process and unbinds its ANUPQData.io record. Note: It can happen that the pq process, and hence the GAP iostream assigned to communicate with it, can die, e.g. by the user typing a Ctrl-C while the pq process is engaged in a long calculation. IsPqProcessAlive (see IsPqProcessAlive (5.2-3)) is provided to check the status of the GAP iostream (and hence the status of the pq process it was communicating with). 5.1-3 PqQuitAll PqQuitAll( )  function is provided as a convenience, to terminate all active interactive ANUPQ processes with a single command. It is equivalent to executing PqQuit(i) for all active interactive ANUPQ processes i (see PqQuit (5.1-2)). 5.2 Interactive ANUPQ Process Utility Functions 5.2-1 PqProcessIndex PqProcessIndex( i )  function PqProcessIndex( )  function With argument i, which must be a positive integer, PqProcessIndex returns i if it corresponds to an active interactive process, or raises an error. With no arguments it returns the default active interactive process or returns fail and emits a warning message to Info at InfoANUPQ or InfoWarning level 1. Note: Essentially, an interactive ANUPQ process i is active if ANUPQData.io[i] is bound (i.e. we still have some data telling us about it). Also see PqStart (5.1-1). 5.2-2 PqProcessIndices PqProcessIndices( )  function returns the list of integer indices of all active interactive ANUPQ processes (see PqProcessIndex (5.2-1) for the meaning of active). 5.2-3 IsPqProcessAlive IsPqProcessAlive( i )  function IsPqProcessAlive( )  function return true if the GAP iostream of the ith (or default) interactive ANUPQ process started by PqStart is alive (i.e. can still be written to), or false, otherwise. (See the notes for PqStart (5.1-1) and PqQuit (5.1-2).) If the user does not yet have a gap> prompt then usually the pq program is still away doing something and an ANUPQ interface function is still waiting for a reply. Typing a Ctrl-C (i.e. holding down the Ctrl key and typing c) will stop the waiting and send GAP into a break-loop, from which one has no option but to quit;. The typing of Ctrl-C, in such a circumstance, usually causes the stream of the interactive ANUPQ process to die; to check this we provide IsPqProcessAlive (see IsPqProcessAlive). The GAP iostream of an interactive ANUPQ process will also die if the pq program has a segmentation fault. We do hope that this never happens to you, but if it does and the failure is reproducible, then it's a bug and we'd like to know about it. Please read the README that comes with the ANUPQ package to find out what to include in a bug report and who to email it to. 5.3 Interactive Versions of Non-interactive ANUPQ Functions 5.3-1 Pq Pq( i: options )  function Pq( : options )  function return, for the fp or pc group (let us call it F), of the ith or default interactive ANUPQ process, the p-quotient of F specified by options, as a pc group; F must previously have been given (as first argument) to PqStart to start the interactive ANUPQ process (see PqStart (5.1-1)) or restored from file using the function PqRestorePcPresentation (see PqRestorePcPresentation (5.6-3)). Following the colon options is a selection of the options listed for the non-interactive Pq function (see Pq (4.1-1)), separated by commas like record components (see Section Reference: Function Call With Options in the GAP Reference Manual), except that the options SetupFile or PqWorkspace are ignored by the interactive Pq, and RedoPcp is an option only recognised by the interactive Pq i.e. the following options are recognised by the interactive Pq function:  Prime := p  ClassBound := n  Exponent := n  Relators := rels  Metabelian  Identities := funcs  GroupName := name  OutputLevel := n  RedoPcp Detailed descriptions of the above options may be found in Chapter 'ANUPQ Options'. As a minimum the Pq function must have a value for the Prime option, though Prime need not be passed again in the case it has previously been provided, e.g. to PqStart (see PqStart (5.1-1)) when starting the interactive process. The behaviour of the interactive Pq function depends on the current state of the pc presentation stored by the pq program: 1 If no pc presentation has yet been computed (the case immediately after the PqStart call initiating the process) then the quotient group of the input group of the process of largest lower exponent-p class bounded by the value of the ClassBound option (see 6.2) is returned. 2 If the current pc presentation of the process was determined by a previous call to Pq or PqEpimorphism, and the current call has a larger value ClassBound then the class is extended as much as is possible and the quotient group of the input group of the process of the new lower exponent-p class is returned. 3 If the current pc presentation of the process was determined by a previous call to PqPCover then a consistent pc presentation of a quotient for the current class is determined before proceeding as in 2. 4 If the RedoPcp option is supplied the current pc presentation is scrapped, all options must be re-supplied (in particular, Prime must be supplied) and then the Pq function proceeds as in 1. See Section 'Attributes and a Property for fp and pc p-groups' for the attributes and property NuclearRank, MultiplicatorRank and IsCapable which may be applied to the group returned by Pq. The following is one of the examples for the non-interactive Pq redone with the interactive version. Also, we set the option OutputLevel to 1 (see 6.2), in order to see the orders of the quotients of all the classes determined, and we set the InfoANUPQ level to 2 (see InfoANUPQ (3.3-1)), so that we catch the timing information.  Example  gap> F := FreeGroup("a", "b");; a := F.1;; b := F.2;; gap> G := F / [a^4, b^4];  gap> PqStart(G); 1 gap> SetInfoLevel(InfoANUPQ, 2); #To see timing information gap> Pq(: Prime := 2, ClassBound := 3, OutputLevel := 1 ); #I Lower exponent-2 central series for [grp] #I Group: [grp] to lower exponent-2 central class 1 has order 2^2 #I Group: [grp] to lower exponent-2 central class 2 has order 2^5 #I Group: [grp] to lower exponent-2 central class 3 has order 2^8 #I Computation of presentation took 0.00 seconds   5.3-2 PqEpimorphism PqEpimorphism( i: options )  function PqEpimorphism( : options )  function return, for the fp or pc group (let us call it F), of the ith or default interactive ANUPQ process, an epimorphism from F onto the p-quotient of F specified by options; F must previously have been given (as first argument) to PqStart to start the interactive ANUPQ process (see PqStart (5.1-1)). Since the underlying interactions with the pq program effected by the interactive PqEpimorphism are identical to those effected by the interactive Pq, everything said regarding the requirements and behaviour of the interactive Pq function (see Pq (5.3-1)) is also the case for the interactive PqEpimorphism. Note: See Section 'Attributes and a Property for fp and pc p-groups' for the attributes and property NuclearRank, MultiplicatorRank and IsCapable which may be applied to the image group of the epimorphism returned by PqEpimorphism. 5.3-3 PqPCover PqPCover( i: options )  function PqPCover( : options )  function return, for the fp or pc group of the ith or default interactive ANUPQ process, the p-covering group of the p-quotient Pq(i : options) or Pq(: options), modulo the following: 1 If no pc presentation has yet been computed (the case immediately after the PqStart call initiating the process) and the group F of the process is already a p-group, in the sense that HasIsPGroup(F) and IsPGroup(F) is true, then Prime defaults to PrimePGroup(F), if not supplied and HasPrimePGroup(F) = true; and ClassBound defaults to PClassPGroup(F) if HasPClassPGroup(F) = true if not supplied, or to the usual default of 63, otherwise. 2 If a pc presentation has been computed and none of options is RedoPcp or if no pc presentation has yet been computed but 1. does not apply then PqPCover(i : options); is equivalent to:   Pq(i : options); PqPCover(i);  3 If the RedoPcp option is supplied the current pc presentation is scrapped, and PqPCover proceeds as in 1. or 2. but without the RedoPcp option. 5.3-4 PqStandardPresentation PqStandardPresentation( [i]: options )  function StandardPresentation( [i]: options )  function return, for the ith or default interactive ANUPQ process, the p-quotient of the group F of the process, specified by options, as an fp group which has a standard presentation. Here options is a selection of the options from the following list (see Chapter 'ANUPQ Options' for detailed descriptions); this list is the same as for the non-interactive version of PqStandardPresentation except for the omission of options SetupFile and PqWorkspace (see PqStandardPresentation (4.2-1)).  Prime := p  pQuotient := Q  ClassBound := n  Exponent := n  Metabelian  GroupName := name  OutputLevel := n  StandardPresentationFile := filename Unless F is a pc p-group, or the option Prime has been passed to a previous interactive function for the process to compute a p-quotient for F, the user must supply either the option Prime or the option pQuotient (if both Prime and pQuotient are supplied, the prime p is determined by applying PrimePGroup (see PrimePGroup (Reference: PrimePGroup) in the Reference Manual) to the value of pQuotient). Taking one of the examples for the non-interactive version of StandardPresentation (see StandardPresentation (4.2-1)) that required two separate calls to the pq program, we now show how it can be done by setting up a dialogue with just the one pq process, using the interactive version of StandardPresentation:  Example  gap> F4 := FreeGroup( "a", "b", "c", "d" );; gap> a := F4.1;; b := F4.2;; c := F4.3;; d := F4.4;; gap> G4 := F4 / [ b^4, b^2 / Comm(Comm (b, a), a), d^16, >  a^16 / (c * d), b^8 / (d * c^4) ];  gap> SetInfoLevel(InfoANUPQ, 1); #Only essential Info please gap> procId := PqStart(G4);; #Start a new interactive process for a new group gap> K := Pq( procId : Prime := 2, ClassBound := 1 );  gap> StandardPresentation( procId : pQuotient := K, ClassBound := 14 );   Notes In contrast to the function Pq (see Pq (4.1-1)) which returns a pc group, PqStandardPresentation or StandardPresentation returns an fp group. This is because the output is mainly used for isomorphism testing for which an fp group is enough. However, the presentation is a polycyclic presentation and if you need to do any further computation with this group (e.g. to find the order) you can use the function PcGroupFpGroup (see PcGroupFpGroup (Reference: PcGroupFpGroup) in the GAP Reference Manual) to form a pc group. If the user does not supply a p-quotient Q via the pQuotient option, and the prime p is either supplied, stored, or F is a pc p-group, then a p-quotient Q is computed. (The value of the prime p is stored if passed initially to PqStart or to a subsequent interactive process.) Note that a stored value for pQuotient (from a prior call to Pq) does not have precedence over a value for the prime p. If the user does supply a p-quotient Q via the pQuotient option, the package AutPGrp is called to compute the automorphism group of Q; an error will occur that asks the user to install the package AutPGrp if the automorphism group cannot be computed. If any of the interactive functions PqStandardPresentation, StandardPresentation, EpimorphismPqStandardPresentation or EpimorphismStandardPresentation has been called previously for an interactive process, a subsequent call to any of these functions for the same process returns the previously computed value. Note that all these functions compute both an epimorphism and an fp group and store the results in the SPepi and SP fields of the data record associated with the process. See the example for the interactive EpimorphismStandardPresentation (EpimorphismStandardPresentation (5.3-5)). The attributes and property NuclearRank, MultiplicatorRank and IsCapable are set for the group returned by PqStandardPresentation or StandardPresentation (see Section 'Attributes and a Property for fp and pc p-groups'). 5.3-5 EpimorphismPqStandardPresentation EpimorphismPqStandardPresentation( [i]: options )  function EpimorphismStandardPresentation( [i]: options )  method Each of the above functions accepts the same arguments and options as the interactive form of StandardPresentation (see StandardPresentation (5.3-4)) and returns an epimorphism from the fp or pc group F of the ith or default interactive ANUPQ process onto the finitely presented group given by a standard presentation, i.e. if S is the standard presentation computed for the p-quotient of F by StandardPresentation then EpimorphismStandardPresentation returns the epimorphism from F to the group with presentation S. The group F must have been given (as first argument) to PqStart to start the interactive ANUPQ process (see PqStart (5.1-1)). Taking our earlier non-interactive example (see EpimorphismPqStandardPresentation (4.2-2)) and modifying it a little, we illustrate, as for the interactive StandardPresentation (see StandardPresentation (5.3-4)), how something that required two separate calls to the pq program can now be achieved with a dialogue with just one pq process. Also, observe that calls to one of the standard presentation functions (as mentioned in the notes of StandardPresentation (5.3-4)) computes and stores both an fp group with a standard presentation and an epimorphism; subsequent calls to a standard presentation function for the same process simply return the appropriate stored value.  Example  gap> F := FreeGroup(6, "F");; gap> x := F.1;; y := F.2;; z := F.3;; w := F.4;; a := F.5;; b := F.6;; gap> R := [x^3 / w, y^3 / w * a^2 * b^2, w^3 / b, >  Comm (y, x) / z, Comm (z, x), Comm (z, y) / a, z^3 ]; [ F1^3*F4^-1, F2^3*F4^-1*F5^2*F6^2, F4^3*F6^-1, F2^-1*F1^-1*F2*F1*F3^-1,   F3^-1*F1^-1*F3*F1, F3^-1*F2^-1*F3*F2*F5^-1, F3^3 ] gap> Q := F / R;  gap> procId := PqStart( Q );; gap> G := Pq( procId : Prime := 3, ClassBound := 3 );  gap> lev := InfoLevel(InfoANUPQ);; # Save current InfoANUPQ level gap> SetInfoLevel(InfoANUPQ, 2); # To see computation times gap> # It is not necessary to pass the `Prime' option to gap> # `EpimorphismStandardPresentation' since it was previously gap> # passed to `Pq': gap> phi := EpimorphismStandardPresentation( 3 : ClassBound := 3 ); #I Class 1 3-quotient and its 3-covering group computed in 0.00 seconds #I Order of GL subgroup is 48 #I No. of soluble autos is 0 #I dim U = 1 dim N = 3 dim M = 3 #I nice stabilizer with perm rep #I Computing standard presentation for class 2 took 0.00 seconds #I Computing standard presentation for class 3 took 0.01 seconds [ F1, F2, F3, F4, F5, F6 ] -> [ f1*f2^2*f3*f4^2*f5^2, f1*f2*f3*f5, f3^2,   f4*f6^2, f5, f6 ] gap> # Image of phi should be isomorphic to G ... gap> # let's check the order is correct: gap> Size( Image(phi) ); 729 gap> # `StandardPresentation' and `EpimorphismStandardPresentation' gap> # behave like attributes, so no computation is done when gap> # either is called again for the same process ... gap> StandardPresentation( 3 : ClassBound := 3 );  gap> # No timing data was Info-ed since no computation was done gap> SetInfoLevel(InfoANUPQ, lev); # Restore previous InfoANUPQ level  A very similar (essential details are the same) example to the above may be executed live, by typing: PqExample( "EpimorphismStandardPresentation-i" );. Note: The notes for PqStandardPresentation or StandardPresentation (see PqStandardPresentation (5.3-4)) apply also to EpimorphismPqStandardPresentation or EpimorphismStandardPresentation except that their return value is an epimorphism onto an fp group, i.e. one should interpret the phrase returns an fp group as returns an epimorphism onto an fp group etc. 5.3-6 PqDescendants PqDescendants( i: options )  function PqDescendants( : options )  function return for the pc group G of the ith or default interactive ANUPQ process, which must be of prime power order with a confluent pc presentation (see IsConfluent (Reference: IsConfluent for pc groups) in the GAP Reference Manual), a list of proper descendants (pc groups) of G. The group G is usually given as first argument to PqStart when starting the interactive ANUPQ process (see PqStart (5.1-1)). Alternatively, one may initiate the process with an fp group, use Pq interactively (see Pq (5.3-1)) to create a pc group and use PqSetPQuotientToGroup (see PqSetPQuotientToGroup (5.3-7)), which involves no computation, to set the pc group returned by Pq as the group of the process. Note that repeating a call to PqDescendants for the same interactive ANUPQ process simply returns the list of descendants originally calculated; a warning is emitted at InfoANUPQ level 1 reminding you of this should you do this. After the colon, options a selection of the options listed for the non-interactive PqDescendants function (see PqDescendants (4.4-1)), should be given, separated by commas like record components (see Section Reference: Function Call With Options in the GAP Reference Manual), except that the options SetupFile or PqWorkspace are ignored by the interactive PqDescendants, i.e. the following options are recognised by the interactive PqDescendants function:  ClassBound := n  Relators := rels  OrderBound := n  StepSize := n, StepSize := list  RankInitialSegmentSubgroups := n  SpaceEfficient  CapableDescendants  AllDescendants := false  Exponent := n  Metabelian  GroupName := name  SubList := sub  BasicAlgorithm  CustomiseOutput := rec Notes: The function PqDescendants uses the automorphism group of G which it computes via the package AutPGrp if the automorphism group of G is not already present. If AutPGrp is not installed an error may be raised. If the automorphism group of G is insoluble the pq program will call GAP together with the AutPGrp package for certain orbit-stabilizer calculations. The attributes and property NuclearRank, MultiplicatorRank and IsCapable are set for each group of the list returned by PqDescendants (see Section 'Attributes and a Property for fp and pc p-groups'). Let us now repeat the examples previously given for the non-interactive PqDescendants, but this time with the interactive version of PqDescendants:  Example  gap> F := FreeGroup( "a", "b" );; a := F.1;; b := F.2;; gap> G := PcGroupFpGroup( F / [ a^2, b^2, Comm(b, a) ] );  gap> procId := PqStart(G);; gap> des := PqDescendants( procId : OrderBound := 6, ClassBound := 5 );; gap> Length(des); 83 gap> List(des, Size); [ 8, 8, 8, 16, 16, 16, 32, 16, 16, 16, 16, 16, 32, 32, 64, 64, 32, 32, 32,   32, 32, 32, 32, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 32, 32, 32, 32,   64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 32, 32, 32, 32, 32, 64, 64, 64,   64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64,   64, 64, 64, 64, 64, 64, 64 ] gap> List(des, d -> Length( PCentralSeries( d, 2 ) ) - 1 ); [ 2, 2, 2, 2, 2, 2, 2, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,   3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 4,   4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,   4, 4, 4, 5, 5, 5, 5, 5 ]  In the second example we compute all capable descendants of order 27 of the elementary abelian group of order 9.  Example  gap> F := FreeGroup( 2, "g" );; gap> G := PcGroupFpGroup( F / [ F.1^3, F.2^3, Comm(F.1, F.2) ] );  gap> procId := PqStart(G);; gap> des := PqDescendants( procId : OrderBound := 3, ClassBound := 2, >  CapableDescendants ); [ ,   ] gap> List(des, d -> Length( PCentralSeries( d, 3 ) ) - 1 ); [ 2, 2 ] gap> # For comparison let us now compute all proper descendants gap> # (using the non-interactive Pq function) gap> PqDescendants( G : OrderBound := 3, ClassBound := 2); [ ,   ,   ]  In the third example, we compute all proper capable descendants of the elementary abelian group of order 5^2 which have exponent-5 class at most 3, exponent 5, and are metabelian.  Example  gap> F := FreeGroup( 2, "g" );; gap> G := PcGroupFpGroup( F / [ F.1^5, F.2^5, Comm(F.2, F.1) ] );  gap> procId := PqStart(G);; gap> des := PqDescendants( procId : Metabelian, ClassBound := 3, >  Exponent := 5, CapableDescendants ); [ ,   ,   ] gap> List(des, d -> Length( PCentralSeries( d, 5 ) ) - 1 ); [ 2, 3, 3 ] gap> List(des, d -> Length( DerivedSeries( d ) ) ); [ 3, 3, 3 ] gap> List(des, d -> Maximum( List( d, Order ) ) ); [ 5, 5, 5 ]  5.3-7 PqSetPQuotientToGroup PqSetPQuotientToGroup( i )  function PqSetPQuotientToGroup( )  function for the ith or default interactive ANUPQ process, set the p-quotient previously computed by the interactive Pq function (see Pq (5.3-1)) to be the group of the process. This function is supplied to enable the computation of descendants of a p-quotient that is already known to the pq program, via the interactive PqDescendants function (see PqDescendants (5.3-6)), thus avoiding the need to re-submit it and have the pq program recompute it. Note: See the function PqPGSetDescendantToPcp (PqPGSetDescendantToPcp (5.9-4)) for a mechanism to make (the p-cover of) a particular descendants the current group of the process. The following example of the usage of PqSetPQuotientToGroup, which is essentially equivalent to what is obtained by running PqExample("PqDescendants-1-i");, redoes the first example of PqDescendants (5.3-6) (which computes the descendants of the Klein four group).  Example  gap> F := FreeGroup( "a", "b" );  gap> procId := PqStart( F : Prime := 2 );; gap> Pq( procId : ClassBound := 1 );  gap> PqSetPQuotientToGroup( procId ); gap> des := PqDescendants( procId : OrderBound := 6, ClassBound := 5 );; gap> Length(des); 83 gap> List(des, Size); [ 8, 8, 8, 16, 16, 16, 32, 16, 16, 16, 16, 16, 32, 32, 64, 64, 32, 32, 32,   32, 32, 32, 32, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 32, 32, 32, 32,   64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 32, 32, 32, 32, 32, 64, 64, 64,   64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64,   64, 64, 64, 64, 64, 64, 64 ] gap> List(des, d -> Length( PCentralSeries( d, 2 ) ) - 1 ); [ 2, 2, 2, 2, 2, 2, 2, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,   3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 4,   4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,   4, 4, 4, 5, 5, 5, 5, 5 ]  5.4 Low-level Interactive ANUPQ functions based on menu items of the pq program The pq program has 5 menus, the details of which the reader will not normally need to know, but if she wishes to know the details they may be found in the standalone manual: guide.dvi. Both guide.dvi and the pq program refer to the items of these 5 menus as options, which do not correspond in any way to the options used by any of the GAP functions that interface with the pq program. Warning: The commands provided in this section are intended to provide something like the interactive functionality one has when running the standalone, from within GAP. The pq standalone (in particular, its advanced menus) assumes some expertise of the user; doing the wrong thing can cause the program to crash. While a number of safeguards have been provided in the GAP interface to the pq program, these are not foolproof, and the user should exercise care and ensure pre-requisites of the various commands are met. 5.5 General commands The following commands either use a menu item from whatever menu is current for the pq program, or have general application and are not associated with just one menu item of the pq program. 5.5-1 PqNrPcGenerators PqNrPcGenerators( i )  function PqNrPcGenerators( )  function for the ith or default interactive ANUPQ process, return the number of pc generators of the lower exponent p-class quotient of the group currently determined by the process. This also applies if the pc presentation is not consistent. 5.5-2 PqFactoredOrder PqFactoredOrder( i )  function PqFactoredOrder( )  function for the ith or default interactive ANUPQ process, return an integer pair [p, n] where p is a prime and n is the number of pc generators (see PqNrPcGenerators (5.5-1)) in the pc presentation of the quotient group currently determined by the process. If this presentation is consistent, then p^n is the order of the quotient group. Otherwise (if tails have been added but the necessary consistency checks, relation collections, exponent law checks and redundant generator eliminations have not yet been done), p^n is an upper bound for the order of the group. 5.5-3 PqOrder PqOrder( i )  function PqOrder( )  function for the ith or default interactive ANUPQ process, return p^n where [p, n] is the pair as returned by PqFactoredOrder (see PqFactoredOrder (5.5-2)). 5.5-4 PqPClass PqPClass( i )  function PqPClass( )  function for the ith or default interactive ANUPQ process, return the lower exponent p-class of the quotient group currently determined by the process. 5.5-5 PqWeight PqWeight( i, j )  function PqWeight( j )  function for the ith or default interactive ANUPQ process, return the weight of the jth pc generator of the lower exponent p-class quotient of the group currently determined by the process, or fail if there is no such numbered pc generator. 5.5-6 PqCurrentGroup PqCurrentGroup( i )  function PqCurrentGroup( )  function for the ith or default interactive ANUPQ process, return the group whose pc presentation is determined by the process as a GAP pc group (either a lower exponent p-class quotient of the start group or the p-cover of such a quotient). Notes: See Section 'Attributes and a Property for fp and pc p-groups' for the attributes and property NuclearRank, MultiplicatorRank and IsCapable which may be applied to the group returned by PqCurrentGroup. 5.5-7 PqDisplayPcPresentation PqDisplayPcPresentation( i: [OutputLevel := lev] )  function PqDisplayPcPresentation( : [OutputLevel := lev] )  function for the ith or default interactive ANUPQ process, direct the pq program to display the pc presentation of the lower exponent p-class quotient of the group currently determined by the process. Except if the last command communicating with the pq program was a p-group generation command (for which there is only a verbose output level), to set the amount of information this command displays you may wish to call PqSetOutputLevel first (see PqSetOutputLevel (5.5-8)), or equivalently pass the option OutputLevel (see 6.2). Note: For those familiar with the pq program, PqDisplayPcPresentation performs menu item 4 of the current menu of the pq program. 5.5-8 PqSetOutputLevel PqSetOutputLevel( i, lev )  function PqSetOutputLevel( lev )  function for the ith or default interactive ANUPQ process, direct the pq program to set the output level of the pq program to lev. Note: For those familiar with the pq program, PqSetOutputLevel performs menu item 5 of the main (or advanced) p-Quotient menu, or the Standard Presentation menu. 5.5-9 PqEvaluateIdentities PqEvaluateIdentities( i: [Identities := funcs] )  function PqEvaluateIdentities( : [Identities := funcs] )  function for the ith or default interactive ANUPQ process, invoke the evaluation of identities defined by the Identities option, and eliminate any redundant pc generators formed. Since a previous value of Identities is saved in the data record of the process, it is unnecessary to pass the Identities if set previously. Note: This function is mainly implemented at the GAP level. It does not correspond to a menu item of the pq program. 5.6 Commands from the Main p-Quotient menu 5.6-1 PqPcPresentation PqPcPresentation( i: options )  function PqPcPresentation( : options )  function for the ith or default interactive ANUPQ process, direct the pq program to compute the pc presentation of the quotient (determined by options) of the group of the process, which for process i is stored as ANUPQData.io[i].group. The possible options are the same as for the interactive Pq (see Pq (5.3-1)) function, except for RedoPcp (which, in any case, would be superfluous), namely: Prime, ClassBound, Exponent, Relators, GroupName, Metabelian, Identities and OutputLevel (see Chapter 'ANUPQ Options' for a detailed description for these options). The option Prime is required unless already provided to PqStart. Notes The pc presentation is held by the pq program. In contrast to Pq (see Pq (5.3-1)), no GAP pc group is returned; see PqCurrentGroup (PqCurrentGroup (5.5-6)) if you need the corresponding GAP pc group. PqPcPresentation(i: options); is roughly equivalent to the following sequence of low-level commands:  PqPcPresentation(i: opts); #class 1 call for c in [2 .. class] do  PqNextClass(i); od;  where opts is options except with the ClassBound option set to 1, and class is either the maximum class of a p-quotient of the group of the process or the user-supplied value of the option ClassBound (whichever is smaller). If the Identities option has been set, both the first PqPcPresentation class 1 call and the PqNextClass calls invoke PqEvaluateIdentities(i); as their final step. For those familiar with the pq program, PqPcPresentation performs menu item 1 of the main p-Quotient menu. 5.6-2 PqSavePcPresentation PqSavePcPresentation( i, filename )  function PqSavePcPresentation( filename )  function for the ith or default interactive ANUPQ process, direct the pq program to save the pc presentation previously computed for the quotient of the group of that process to the file with name filename. If the first character of the string filename is not /, filename is assumed to be the path of a writable file relative to the directory in which GAP was started. A saved file may be restored by PqRestorePcPresentation (see PqRestorePcPresentation (5.6-3)). Note: For those familiar with the pq program, PqSavePcPresentation performs menu item 2 of the main p-Quotient menu. 5.6-3 PqRestorePcPresentation PqRestorePcPresentation( i, filename )  function PqRestorePcPresentation( filename )  function for the ith or default interactive ANUPQ process, direct the pq program to restore the pc presentation previously saved to filename, by PqSavePcPresentation (see PqSavePcPresentation (5.6-2)). If the first character of the string filename is not /, filename is assumed to be the path of a readable file relative to the directory in which GAP was started. Note: For those familiar with the pq program, PqRestorePcPresentation performs menu item 3 of the main p-Quotient menu. 5.6-4 PqNextClass PqNextClass( i: [QueueFactor] )  function PqNextClass( : [QueueFactor] )  function for the ith or default interactive ANUPQ process, direct the pq program to calculate the next class of ANUPQData.io[i].group. PqNextClass accepts the option QueueFactor (see also 6.2) which should be a positive integer if automorphisms have been previously supplied. If the pq program requires a queue factor and none is supplied via the option QueueFactor a default of 15 is taken. Notes The single command: PqNextClass(i); is equivalent to executing  PqComputePCover(i); PqCollectDefiningRelations(i); PqDoExponentChecks(i); PqEliminateRedundantGenerators(i);  If the Identities option is set the PqEliminateRedundantGenerators(i); step is essentially replaced by PqEvaluateIdentities(i); (which invokes its own elimination of redundant generators). For those familiar with the pq program, PqNextClass performs menu item 6 of the main p-Quotient menu. 5.6-5 PqComputePCover PqComputePCover( i )  function PqComputePCover( )  function for the ith or default interactive ANUPQ processi, directi, the pq program to compute the p-covering group of ANUPQData.io[i].group. In contrast to the function PqPCover (see PqPCover (4.1-3)), this function does not return a GAP pc group. Notes The single command: PqComputePCover(i); is equivalent to executing  PqSetupTablesForNextClass(i); PqTails(i, 0); PqDoConsistencyChecks(i, 0, 0); PqEliminateRedundantGenerators(i);  For those familiar with the pq program, PqComputePCover performs menu item 7 of the main p-Quotient menu. 5.7 Commands from the Advanced p-Quotient menu 5.7-1 PqCollect PqCollect( i, word )  function PqCollect( word )  function for the ith or default interactive ANUPQ process, instruct the pq program to do a collection on word, a word in the current pc generators (the form of word required is described below). PqCollect returns the resulting word of the collection as a list of generator number, exponent pairs (the same form as the second allowed input form of word; see below). The argument word may be input in either of the following ways: 1 word may be a string, where the ith pc generator is represented by xi, e.g. "x3*x2^2*x1". This way is quite versatile as parentheses and left-normed commutators -- using square brackets, in the same way as PqGAPRelators (see PqGAPRelators (3.4-2)) -- are permitted; word is checked for correct syntax via PqParseWord (see PqParseWord (3.4-3)). 2 Otherwise, word must be a list of generator number, exponent pairs of integers, i.e.  each pair represents a syllable so that [ [3, 1], [2, 2], [1, 1] ] represents the same word as that of the example given for the first allowed form of word. Note: For those familiar with the pq program, PqCollect performs menu item 1 of the Advanced p-Quotient menu. 5.7-2 PqSolveEquation PqSolveEquation( i, a, b )  function PqSolveEquation( a, b )  function for the ith or default interactive ANUPQ process, direct the pq program to solve a * x = b for x, where a and b are words in the pc generators. For the representation of these words see the description of the function PqCollect (PqCollect (5.7-1)). Note: For those familiar with the pq program, PqSolveEquation performs menu item 2 of the Advanced p-Quotient menu. 5.7-3 PqCommutator PqCommutator( i, words, pow )  function PqCommutator( words, pow )  function for the ith or default interactive ANUPQ process, instruct the pq program to compute the left normed commutator of the list words of words in the current pc generators raised to the integer power pow, and return the resulting word as a list of generator number, exponent pairs. The form required for each word of words is the same as that required for the word argument of PqCollect (see PqCollect (5.7-1)). The form of the output word is also the same as for PqCollect. Note: For those familiar with the pq program, PqCommutator performs menu item 3 of the Advanced p-Quotient menu. 5.7-4 PqSetupTablesForNextClass PqSetupTablesForNextClass( i )  function PqSetupTablesForNextClass( )  function for the ith or default interactive ANUPQ process, direct the pq program to set up tables for the next class. As as side-effect, after PqSetupTablesForNextClass(i) the value returned by PqPClass(i) will be one more than it was previously. Note: For those familiar with the pq program, PqSetupTablesForNextClass performs menu item 6 of the Advanced p-Quotient menu. 5.7-5 PqTails PqTails( i, weight )  function PqTails( weight )  function for the ith or default interactive ANUPQ process, direct the pq program to compute and add tails of weight weight if weight is in the integer range [2 .. PqPClass(i)] (assuming i is the number of the process, even in the default case) or for all weights if weight = 0. If weight is non-zero, then tails that introduce new generators for only weight weight are computed and added, and in this case and if weight < PqPClass(i), it is assumed that the tails that introduce new generators for each weight from PqPClass(i) down to weight weight + 1 have already been added. You may wish to call PqSetMetabelian (see PqSetMetabelian (5.7-16)) prior to calling PqTails. Notes For its use in the context of finding the next class see PqNextClass (5.6-4); in particular, a call to PqSetupTablesForNextClass (see PqSetupTablesForNextClass (5.7-4)) needs to have been made prior to calling PqTails. The single command: PqTails(i, weight); is equivalent to  PqComputeTails(i, weight); PqAddTails(i, weight);  For those familiar with the pq program, PqTails uses menu item 7 of the Advanced p-Quotient menu. 5.7-6 PqComputeTails PqComputeTails( i, weight )  function PqComputeTails( weight )  function for the ith or default interactive ANUPQ process, direct the pq program to compute tails of weight weight if weight is in the integer range [2 .. PqPClass(i)] (assuming i is the number of the process, even in the default case) or for all weights if weight = 0. See PqTails (PqTails (5.7-5)) for more details. Note: For those familiar with the pq program, PqComputeTails uses menu item 7 of the Advanced p-Quotient menu. 5.7-7 PqAddTails PqAddTails( i, weight )  function PqAddTails( weight )  function for the ith or default interactive ANUPQ process, direct the pq program to add the tails of weight weight, previously computed by PqComputeTails (see PqComputeTails (5.7-6)), if weight is in the integer range [2 .. PqPClass(i)] (assuming i is the number of the process, even in the default case) or for all weights if weight = 0. See PqTails (PqTails (5.7-5)) for more details. Note: For those familiar with the pq program, PqAddTails uses menu item 7 of the Advanced p-Quotient menu. 5.7-8 PqDoConsistencyChecks PqDoConsistencyChecks( i, weight, type )  function PqDoConsistencyChecks( weight, type )  function for the ith or default interactive ANUPQ process, do consistency checks for weight weight if weight is in the integer range [3 .. PqPClass(i)] (assuming i is the number of the process) or for all weights if weight = 0, and for type type if type is in the range [1, 2, 3] (see below) or for all types if type = 0. (For its use in the context of finding the next class see PqNextClass (5.6-4).) The type of a consistency check is defined as follows. PqDoConsistencyChecks(i, weight, type) for weight in [3 .. PqPClass(i)] and the given value of type invokes the equivalent of the following PqDoConsistencyCheck calls (see PqDoConsistencyCheck (5.7-17)): type = 1: PqDoConsistencyCheck(i, a, a, a) checks 2 * PqWeight(i, a) + 1 = weight, for pc generators of index a. type = 2: PqDoConsistencyCheck(i, b, b, a) checks for pc generators of indices b, a satisfyingx both b > a and PqWeight(i, b) + PqWeight(i, a) + 1 = weight. type = 3: PqDoConsistencyCheck(i, c, b, a) checks for pc generators of indices c, b, a satisfying c > b > a and the sum of the weights of these generators equals weight. Notes PqWeight(i, j) returns the weight of the jth pc generator, for process i (see PqWeight (5.5-5)). It is assumed that tails for the given weight (or weights) have already been added (see PqTails (5.7-5)). For those familiar with the pq program, PqDoConsistencyChecks performs menu item 8 of the Advanced p-Quotient menu. 5.7-9 PqCollectDefiningRelations PqCollectDefiningRelations( i )  function PqCollectDefiningRelations( )  function for the ith or default interactive ANUPQ process, direct the pq program to collect the images of the defining relations of the original fp group of the process, with respect to the current pc presentation, in the context of finding the next class (see PqNextClass (5.6-4)). If the tails operation is not complete then the relations may be evaluated incorrectly. Note: For those familiar with the pq program, PqCollectDefiningRelations performs menu item 9 of the Advanced p-Quotient menu. 5.7-10 PqCollectWordInDefiningGenerators PqCollectWordInDefiningGenerators( i, word )  function PqCollectWordInDefiningGenerators( word )  function for the ith or default interactive ANUPQ process, take a user-defined word word in the defining generators of the original presentation of the fp or pc group of the process. Each generator is mapped into the current pc presentation, and the resulting word is collected with respect to the current pc presentation. The result of the collection is returned as a list of generator number, exponent pairs. The word argument may be input in either of the two ways described for PqCollect (see PqCollect (5.7-1)). Note: For those familiar with the pq program, PqCollectDefiningGenerators performs menu item 23 of the Advanced p-Quotient menu. 5.7-11 PqCommutatorDefiningGenerators PqCommutatorDefiningGenerators( i, words, pow )  function PqCommutatorDefiningGenerators( words, pow )  function for the ith or default interactive ANUPQ process, take a list words of user-defined words in the defining generators of the original presentation of the fp or pc group of the process, and an integer power pow. Each generator is mapped into the current pc presentation. The list words is interpreted as a left-normed commutator which is then raised to pow and collected with respect to the current pc presentation. The result of the collection is returned as a list of generator number, exponent pairs. Note For those familiar with the pq program, PqCommutatorDefiningGenerators performs menu item 24 of the Advanced p-Quotient menu. 5.7-12 PqDoExponentChecks PqDoExponentChecks( i: [Bounds := list] )  function PqDoExponentChecks( : [Bounds := list] )  function for the ith or default interactive ANUPQ process, direct the pq program to do exponent checks for weights (inclusively) between the bounds of Bounds or for all weights if Bounds is not given. The value list of Bounds (assuming the interactive process is numbered i) should be a list of two integers low, high satisfying 1 ≤ low ≤ high ≤ PqPClass(i) (see PqPClass (5.5-4)). If no exponent law has been specified, no exponent checks are performed. Note: For those familiar with the pq program, PqDoExponentChecks performs menu item 10 of the Advanced p-Quotient menu. 5.7-13 PqEliminateRedundantGenerators PqEliminateRedundantGenerators( i )  function PqEliminateRedundantGenerators( )  function for the ith or default interactive ANUPQ process, direct the pq program to eliminate redundant generators of the current p-quotient. Note: For those familiar with the pq program, PqEliminateRedundantGenerators performs menu item 11 of the Advanced p-Quotient menu. 5.7-14 PqRevertToPreviousClass PqRevertToPreviousClass( i )  function PqRevertToPreviousClass( )  function for the ith or default interactive ANUPQ process, direct the pq program to abandon the current class and revert to the previous class. Note: For those familiar with the pq program, PqRevertToPreviousClass performs menu item 12 of the Advanced p-Quotient menu. 5.7-15 PqSetMaximalOccurrences PqSetMaximalOccurrences( i, noccur )  function PqSetMaximalOccurrences( noccur )  function for the ith or default interactive ANUPQ process, direct the pq program to set maximal occurrences of the weight 1 generators in the definitions of pcp generators of the group of the process. This can be used to avoid the definition of generators of which one knows for theoretical reasons that they would be eliminated later on. The argument noccur must be a list of non-negative integers of length the number of weight 1 generators (i.e. the rank of the class 1 p-quotient of the group of the process). An entry of 0 for a particular generator indicates that there is no limit on the number of occurrences for the generator. Note: For those familiar with the pq program, PqSetMaximalOccurrences performs menu item 13 of the Advanced p-Quotient menu. 5.7-16 PqSetMetabelian PqSetMetabelian( i )  function PqSetMetabelian( )  function for the ith or default interactive ANUPQ process, direct the pq program to enforce metabelian-ness. Note: For those familiar with the pq program, PqSetMetabelian performs menu item 14 of the Advanced p-Quotient menu. 5.7-17 PqDoConsistencyCheck PqDoConsistencyCheck( i, c, b, a )  function PqDoConsistencyCheck( c, b, a )  function PqJacobi( i, c, b, a )  function PqJacobi( c, b, a )  function for the ith or default interactive ANUPQ process, direct the pq program to do the consistency check for the pc generators with indices c, b, a which should be non-increasing positive integers, i.e. c ≥ b ≥ a. There are 3 types of consistency checks: \begin{array}{rclrl} (a^n)a &=& a(a^n) && {\rm (Type\ 1)} \\ (b^n)a &=& b^{(n-1)}(ba), b(a^n) = (ba)a^{(n-1)} && {\rm (Type\ 2)} \\ c(ba) &=& (cb)a && {\rm (Type\ 3)} \\ \end{array}  The reason some people talk about Jacobi relations instead of consistency checks becomes clear when one looks at the consistency check of type 3: \begin{array}{rcl} c(ba) &=& a c[c,a] b[b,a] = acb [c,a][c,a,b][b,a] = \dots \\ (cb)a &=& b c[c,b] a = a b[b,a] c[c,a] [c,b][c,b,a] \\ &=& abc [b,a] [b,a,c] [c,a] [c,b] [c,b,a] = \dots \\ \end{array}  Each collection would normally carry on further. But one can see already that no other commutators of weight 3 will occur. After all terms of weight one and weight two have been moved to the left we end up with: \begin{array}{rcl} & &abc [b,a] [c,a] [c,b] [c,a,b] \dots \\ &=&abc [b,a] [c,a] [c,b] [c,b,a] [b,a,c] \dots \\ \end{array}  Modulo terms of weight 4 this is equivalent to [c,a,b] [b,c,a] [a,b,c] = 1  which is the Jacobi identity. See also PqDoConsistencyChecks (PqDoConsistencyChecks (5.7-8)). Note: For those familiar with the pq program, PqDoConsistencyCheck and PqJacobi perform menu item 15 of the Advanced p-Quotient menu. 5.7-18 PqCompact PqCompact( i )  function PqCompact( )  function for the ith or default interactive ANUPQ process, direct the pq program to do a compaction of its work space. This function is safe to perform only at certain points in time. Note: For those familiar with the pq program, PqCompact performs menu item 16 of the Advanced p-Quotient menu. 5.7-19 PqEchelonise PqEchelonise( i )  function PqEchelonise( )  function for the ith or default interactive ANUPQ process, direct the pq program to echelonise the word most recently collected by PqCollect or PqCommutator against the relations of the current pc presentation, and return the number of the generator made redundant or fail if no generator was made redundant. A call to PqCollect (see PqCollect (5.7-1)) or PqCommutator (see PqCommutator (5.7-3)) needs to be performed prior to using this command. Note: For those familiar with the pq program, PqEchelonise performs menu item 17 of the Advanced p-Quotient menu. 5.7-20 PqSupplyAutomorphisms PqSupplyAutomorphisms( i, mlist )  function PqSupplyAutomorphisms( mlist )  function for the ith or default interactive ANUPQ process, supply the automorphism data provided by the list mlist of matrices with non-negative integer coefficients. Each matrix in mlist describes one automorphism in the following way.  The rows of each matrix correspond to the pc generators of weight one.  Each row is the exponent vector of the image of the corresponding weight one generator under the respective automorphism. Note: For those familiar with the pq program, PqSupplyAutomorphisms uses menu item 18 of the Advanced p-Quotient menu. 5.7-21 PqExtendAutomorphisms PqExtendAutomorphisms( i )  function PqExtendAutomorphisms( )  function for the ith or default interactive ANUPQ process, direct the pq program to extend automorphisms of the p-quotient of the previous class to the p-quotient of the present class. Note: For those familiar with the pq program, PqExtendAutomorphisms uses menu item 18 of the Advanced p-Quotient menu. 5.7-22 PqApplyAutomorphisms PqApplyAutomorphisms( i, qfac )  function PqApplyAutomorphisms( qfac )  function for the ith or default interactive ANUPQ process, direct the pq program to apply automorphisms; qfac is the queue factor e.g. 15. Note: For those familiar with the pq program, PqCloseRelations performs menu item 19 of the Advanced p-Quotient menu. 5.7-23 PqDisplayStructure PqDisplayStructure( i: [Bounds := list] )  function PqDisplayStructure( : [Bounds := list] )  function for the ith or default interactive ANUPQ process, direct the pq program to display the structure for the pcp generators numbered (inclusively) between the bounds of Bounds or for all generators if Bounds is not given. The value list of Bounds (assuming the interactive process is numbered i) should be a list of two integers low, high satisfying 1 ≤ low ≤ high ≤ PqNrPcGenerators(i) (see PqNrPcGenerators (5.5-1)). PqDisplayStructure also accepts the option OutputLevel (see 6.2). Explanation of output New generators are defined as commutators of previous generators and generators of class 1 or as p-th powers of generators that have themselves been defined as p-th powers. A generator is never defined as p-th power of a commutator. Therefore, there are two cases: all the numbers on the righthand side are either the same or they differ. Below, gi refers to the ith defining generator.  If the righthand side numbers are all the same, then the generator is a p-th power (of a p-th power of a p-th power, etc.). The number of repeated digits say how often a p-th power has to be taken. In the following example, the generator number 31 is the eleventh power of generator 17 which in turn is an eleventh power and so on: \begintt #I 31 is defined on 17^11 = 1 1 1 1 1 \endtt So generator 31 is obtained by taking the eleventh power of generator 1 five times.  If the numbers are not all the same, the generator is defined by a commutator. If the first two generator numbers differ, the generator is defined as a left-normed commutator of the weight one generators, e.g. \begintt #I 19 is defined on [11, 1] = 2 1 1 1 1 \endtt Here, generator 19 is defined as the commutator of generator 11 and generator 1 which is the same as the left-normed commutator [x2, x1, x1, x1, x1]. One can check this by tracing back the definition of generator 11 until one gets to a generator of class 1.  If the first two generator numbers are identical, then the left most component of the left-normed commutator is a p-th power, e.g. \begintt #I 25 is defined on [14, 1] = 1 1 2 1 1 \endtt In this example, generator 25 is defined as commutator of generator 14 and generator 1. The left-normed commutator is  [(x1^{11})^{11}, x2, x1, x1]  Again, this can be verified by tracing back the definitions. Note: For those familiar with the pq program, PqDisplayStructure performs menu item 20 of the Advanced p-Quotient menu. 5.7-24 PqDisplayAutomorphisms PqDisplayAutomorphisms( i: [Bounds := list] )  function PqDisplayAutomorphisms( : [Bounds := list] )  function for the ith or default interactive ANUPQ process, direct the pq program to display the automorphism actions on the pcp generators numbered (inclusively) between the bounds of Bounds or for all generators if Bounds is not given. The value list of Bounds (assuming the interactive process is numbered i) should be a list of two integers low, high satisfying 1 ≤ low ≤ high ≤ PqNrPcGenerators(i) (see PqNrPcGenerators (5.5-1)). PqDisplayStructure also accepts the option OutputLevel (see 6.2). Note: For those familiar with the pq program, PqDisplayAutomorphisms performs menu item 21 of the Advanced p-Quotient menu. 5.7-25 PqWritePcPresentation PqWritePcPresentation( i, filename )  function PqWritePcPresentation( filename )  function for the ith or default interactive ANUPQ process, direct the pq program to write a pc presentation of a previously-computed quotient of the group of that process, to the file with name filename. Here the group of a process is the one given as first argument when PqStart was called to initiate that process (for process i the group is stored as ANUPQData.io[i].group). If the first character of the string filename is not /, filename is assumed to be the path of a writable file relative to the directory in which GAP was started. If a pc presentation has not been previously computed by the pq program, then pq is called to compute it first, effectively invoking PqPcPresentation (see PqPcPresentation (5.6-1)). Note: For those familiar with the pq program, PqPcWritePresentation performs menu item 25 of the Advanced p-Quotient menu. 5.8 Commands from the Standard Presentation menu 5.8-1 PqSPComputePcpAndPCover PqSPComputePcpAndPCover( i: options )  function PqSPComputePcpAndPCover( : options )  function for the ith or default interactive ANUPQ process, directs the pq program to compute for the group of that process a pc presentation up to the p-quotient of maximum class or the value of the option ClassBound and the p-cover of that quotient, and sets up tabular information required for computation of a standard presentation. Here the group of a process is the one given as first argument when PqStart was called to initiate that process (for process i the group is stored as ANUPQData.io[i].group). The possible options are Prime, ClassBound, Relators, Exponent, Metabelian and OutputLevel (see Chapter 'ANUPQ Options' for detailed descriptions of these options). The option Prime is normally determined via PrimePGroup, and so is not required unless the group doesn't know it's a p-group and HasPrimePGroup returns false. Note: For those familiar with the pq program, PqSPComputePcpAndPCover performs option 1 of the Standard Presentation menu. 5.8-2 PqSPStandardPresentation PqSPStandardPresentation( i[, mlist]: [options] )  function PqSPStandardPresentation( [mlist]: [options] )  function for the ith or default interactive ANUPQ process, inputs data given by options to compute a standard presentation for the group of that process. If argument mlist is given it is assumed to be the automorphism group data required. Otherwise it is assumed that a call to either Pq (see Pq (5.3-1)) or PqEpimorphism (see PqEpimorphism (5.3-2)) has generated a p-quotient and that GAP can compute its automorphism group from which the necessary automorphism group data can be derived. The group of the process is the one given as first argument when PqStart was called to initiate the process (for process i the group is stored as ANUPQData.io[i].group and the p-quotient if existent is stored as ANUPQData.io[i].pQuotient). If mlist is not given and a p-quotient of the group has not been previously computed a class 1 p-quotient is computed. PqSPStandardPresentation accepts three options, all optional:  ClassBound := n  PcgsAutomorphisms  StandardPresentationFile := filename If ClassBound is omitted it defaults to 63. Detailed descriptions of the above options may be found in Chapter 'ANUPQ Options'. Note: For those familiar with the pq program, PqSPPcPresentation performs menu item 2 of the Standard Presentation menu. 5.8-3 PqSPSavePresentation PqSPSavePresentation( i, filename )  function PqSPSavePresentation( filename )  function for the ith or default interactive ANUPQ process, directs the pq program to save the standard presentation previously computed for the group of that process to the file with name filename, where the group of a process is the one given as first argument when PqStart was called to initiate that process. If the first character of the string filename is not /, filename is assumed to be the path of a writable file relative to the directory in which GAP was started. Note: For those familiar with the pq program, PqSPSavePresentation performs menu item 3 of the Standard Presentation menu. 5.8-4 PqSPCompareTwoFilePresentations PqSPCompareTwoFilePresentations( i, f1, f2 )  function PqSPCompareTwoFilePresentations( f1, f2 )  function for the ith or default interactive ANUPQ process, direct the pq program to compare the presentations in the files with names f1 and f2 and returns true if they are identical and false otherwise. For each of the strings f1 and f2, if the first character is not a / then it is assumed to be the path of a readable file relative to the directory in which GAP was started. Notes The presentations in files f1 and f2 must have been generated by the pq program but they do not need to be standard presentations. If If the presentations in files f1 and f2 have been generated by PqSPStandardPresentation (see PqSPStandardPresentation (5.8-2)) then a false response from PqSPCompareTwoFilePresentations says the groups defined by those presentations are not isomorphic. For those familiar with the pq program, PqSPCompareTwoFilePresentations performs menu item 6 of the Standard Presentation menu. 5.8-5 PqSPIsomorphism PqSPIsomorphism( i )  function PqSPIsomorphism( )  function for the ith or default interactive ANUPQ process, direct the pq program to compute the isomorphism mapping from the p-group of the process to its standard presentation. This function provides a description only; for a GAP object, use EpimorphismStandardPresentation (see EpimorphismStandardPresentation (5.3-5)). Note: For those familiar with the pq program, PqSPIsomorphism performs menu item 8 of the Standard Presentation menu. 5.9 Commands from the Main p-Group Generation menu Note that the p-group generation commands can only be applied once the pq program has produced a pc presentation of some quotient group of the group of the process. 5.9-1 PqPGSupplyAutomorphisms PqPGSupplyAutomorphisms( i[, mlist]: options )  function PqPGSupplyAutomorphisms( [mlist]: options )  function for the ith or default interactive ANUPQ process, supply the pq program with the automorphism group data needed for the current quotient of the group of that process (for process i the group is stored as ANUPQData.io[i].group). For a description of the format of mlist see PqSupplyAutomorphisms (5.7-20). The options possible are NumberOfSolubleAutomorphisms and RelativeOrders. (Detailed descriptions of these options may be found in Chapter 'ANUPQ Options'.) If mlist is omitted, the automorphism data is determined from the group of the process which must have been a p-group in pc presentation. Note: For those familiar with the pq program, PqPGSupplyAutomorphisms performs menu item 1 of the main p-Group Generation menu. 5.9-2 PqPGExtendAutomorphisms PqPGExtendAutomorphisms( i )  function PqPGExtendAutomorphisms( )  function for the ith or default interactive ANUPQ process, direct the pq program to compute the extensions of the automorphisms of the p-quotient of the previous class to the p-quotient of the current class. You may wish to set the InfoLevel of InfoANUPQ to 2 (or more) in order to see the output from the pq program (see InfoANUPQ (3.3-1)). Note: For those familiar with the pq program, PqPGExtendAutomorphisms performs menu item 2 of the main or advanced p-Group Generation menu. 5.9-3 PqPGConstructDescendants PqPGConstructDescendants( i: options )  function PqPGConstructDescendants( : options )  function for the ith or default interactive ANUPQ process, direct the pq program to construct descendants prescribed by options, and return the number of descendants constructed (compare function PqDescendants (4.4-1) which returns the list of descendants). The options possible are ClassBound, OrderBound, StepSize, PcgsAutomorphisms, RankInitialSegmentSubgroups, SpaceEfficient, CapableDescendants, AllDescendants, Exponent, Metabelian, BasicAlgorithm, CustomiseOutput. (Detailed descriptions of these options may be found in Chapter 'ANUPQ Options'.) PqPGConstructDescendants requires that the pq program has previously computed a pc presentation and a p-cover for a p-quotient of some class of the group of the process. Note: For those familiar with the pq program, PqPGConstructDescendants performs menu item 5 of the main p-Group Generation menu. 5.9-4 PqPGSetDescendantToPcp PqPGSetDescendantToPcp( i, cls, n )  function PqPGSetDescendantToPcp( cls, n )  function PqPGSetDescendantToPcp( i: [Filename := name] )  function PqPGSetDescendantToPcp( : [Filename := name] )  function PqPGRestoreDescendantFromFile( i, cls, n )  function PqPGRestoreDescendantFromFile( cls, n )  function PqPGRestoreDescendantFromFile( i: [Filename := name] )  function PqPGRestoreDescendantFromFile( : [Filename := name] )  function for the ith or default interactive ANUPQ process, direct the pq program to restore group n of class cls from a temporary file, where cls and n are positive integers, or the group stored in name. PqPGSetDescendantToPcp and PqPGRestoreDescendantFromFile are synonyms; they make sense only after a prior call to construct descendants by say PqPGConstructDescendants (see PqPGConstructDescendants (5.9-3)) or the interactive PqDescendants (see PqDescendants (5.3-6)). In the Filename option forms, the option defaults to the last filename in which a presentation was stored by the pq program. Notes Since the PqPGSetDescendantToPcp and PqPGRestoreDescendantFromFile are intended to be used in calculation of further descendants the pq program computes the p-cover of the restored descendant. Hence, PqCurrentGroup used immediately after one of these commands returns the p-cover of the restored descendant rather than the descendant itself. For those familiar with the pq program, PqPGSetDescendantToPcp and PqPGRestoreDescendantFromFile perform menu item 3 of the main or advanced p-Group Generation menu. 5.10 Commands from the Advanced p-Group Generation menu The functions below perform the component algorithms of PqPGConstructDescendants (see PqPGConstructDescendants (5.9-3)). You can get some idea of their usage by trying PqExample("Nott-APG-Rel-i");. You can get some idea of the breakdown of PqPGConstructDescendants into these functions by comparing the previous output with PqExample("Nott-PG-Rel-i");. These functions are intended for use only by experts; please contact the authors of the package if you genuinely have a need for them and need any amplified descriptions. 5.10-1 PqAPGDegree PqAPGDegree( i, step, rank: [Exponent := n] )  function PqAPGDegree( step, rank: [Exponent := n] )  function for the ith or default interactive ANUPQ process, direct the pq program to invoke menu item 6 of the Advanced p-Group Generation menu. Here the step-size step and the rank rank are positive integers and are the arguments required by the pq program. See 6.2 for the one recognised option Exponent. 5.10-2 PqAPGPermutations PqAPGPermutations( i: options )  function PqAPGPermutations( : options )  function for the ith or default interactive ANUPQ process, direct the pq program to perform menu item 7 of the Advanced p-Group Generation menu. Here the options options recognised are PcgsAutomorphisms, SpaceEfficient, PrintAutomorphisms and PrintPermutations (see Chapter 'ANUPQ Options' for details). 5.10-3 PqAPGOrbits PqAPGOrbits( i: options )  function PqAPGOrbits( : options )  function for the ith or default interactive ANUPQ process, direct the pq to perform menu item 8 of the Advanced p-Group Generation menu. Here the options options recognised are PcgsAutomorphisms, SpaceEfficient and CustomiseOutput (see Chapter 'ANUPQ Options' for details). For the CustomiseOutput option only the setting of the orbit is recognised (all other fields if set are ignored). 5.10-4 PqAPGOrbitRepresentatives PqAPGOrbitRepresentatives( i: options )  function PqAPGOrbitRepresentatives( : options )  function for the ith or default interactive ANUPQ process, direct the pq to perform item 9 of the Advanced p-Group Generation menu. The options options may be any selection of the following: PcgsAutomorphisms, SpaceEfficient, Exponent, Metabelian, CapableDescendants (or AllDescendants), CustomiseOutput (where only the group and autgroup fields are recognised) and Filename (see Chapter 'ANUPQ Options' for details). If Filename is omitted the reduced p-cover is written to the file "redPCover" in the temporary directory whose name is stored in ANUPQData.tmpdir. 5.10-5 PqAPGSingleStage PqAPGSingleStage( i: options )  function PqAPGSingleStage( : options )  function for the ith or default interactive ANUPQ process, direct the pq to perform option 5 of the Advanced p-Group Generation menu. The possible options are StepSize, PcgsAutomorphisms, RankInitialSegmentSubgroups, SpaceEfficient, CapableDescendants, AllDescendants, Exponent, Metabelian, BasicAlgorithm and CustomiseOutput. (Detailed descriptions of these options may be found in Chapter 'ANUPQ Options'.) 5.11 Primitive Interactive ANUPQ Process Read/Write Functions For those familiar with using the pq program as a standalone we provide primitive read/write tools to communicate directly with an interactive ANUPQ process, started via PqStart. For the most part, it is up to the user to translate the output strings from pq program into a form useful in GAP. 5.11-1 PqRead PqRead( i )  function PqRead( )  function read a complete line of ANUPQ output, from the ith or default interactive ANUPQ process, if there is output to be read and returns fail otherwise. When successful, the line is returned as a string complete with trailing newline, colon, or question-mark character. Please note that it is possible to be too quick (i.e. the return can be fail purely because the output from ANUPQ is not there yet), but if PqRead finds any output at all, it waits for a complete line. PqRead also writes the line read via Info at InfoANUPQ level 2. It doesn't try to distinguish banner and menu output from other output of the pq program. 5.11-2 PqReadAll PqReadAll( i )  function PqReadAll( )  function read and return as many complete lines of ANUPQ output, from the ith or default interactive ANUPQ process, as there are to be read, at the time of the call, as a list of strings with any trailing newlines removed and returns the empty list otherwise. PqReadAll also writes each line read via Info at InfoANUPQ level 2. It doesn't try to distinguish banner and menu output from other output of the pq program. Whenever PqReadAll finds only a partial line, it waits for the complete line, thus increasing the probability that it has captured all the output to be had from ANUPQ. 5.11-3 PqReadUntil PqReadUntil( i, IsMyLine )  function PqReadUntil( IsMyLine )  function PqReadUntil( i, IsMyLine, Modify )  function PqReadUntil( IsMyLine, Modify )  function read complete lines of ANUPQ output, from the ith or default interactive ANUPQ process, chomps them (i.e. removes any trailing newline character), emits them to Info at InfoANUPQ level 2 (without trying to distinguish banner and menu output from other output of the pq program), and applies the function Modify (where Modify is just the identity map/function for the first two forms) until a chomped line line for which IsMyLine( Modify(line) ) is true. PqReadUntil returns the list of Modify-ed chomped lines read. Notes: When provided by the user, Modify should be a function that accepts a single string argument. IsMyLine should be a function that is able to accept the output of Modify (or take a single string argument when Modify is not provided) and should return a boolean. If IsMyLine( Modify(line) ) is never true, PqReadUntil will wait indefinitely. 5.11-4 PqWrite PqWrite( i, string )  function PqWrite( string )  function write string to the ith or default interactive ANUPQ process; string must be in exactly the form the ANUPQ standalone expects. The command is echoed via Info at InfoANUPQ level 3 (with a ToPQ>  prompt); i.e. do SetInfoLevel(InfoANUPQ, 3); to see what is transmitted to the pq program. PqWrite returns true if successful in writing to the stream of the interactive ANUPQ process, and fail otherwise. Note: If PqWrite returns fail it means that the ANUPQ process has died. anupq-3.3.3/doc/manual.mst0000644000175100017510000000046415111342310015014 0ustar runnerrunnerpreamble "" postamble "\n" group_skip "\n" headings_flag 1 heading_prefix "\\letter " numhead_positive "{}" symhead_positive "{}" item_0 "\n " item_1 "\n \\sub " item_01 "\n \\sub " item_x1 ", " item_2 "\n \\subsub " item_12 "\n \\subsub " item_x2 ", " page_compositor "--" line_max 1000 anupq-3.3.3/doc/chap7_mj.html0000644000175100017510000003666715111342310015406 0ustar runnerrunner GAP (ANUPQ) - Chapter 7: Installing the ANUPQ Package
Goto Chapter: Top 1 2 3 4 5 6 7 A Bib Ind
 [Top of Book]  [Contents]   [Previous Chapter]   [Next Chapter] 

7 Installing the ANUPQ Package
 7.1 Testing your ANUPQ installation
 7.2 Running the pq program as a standalone

7 Installing the ANUPQ Package

The ANU pq program is written in C and the package can be installed under UNIX and in environments similar to UNIX. In particular it is known to work on Linux and Mac OS X, and also on Windows equipped with cygwin.

The current version of the ANUPQ package requires GAP 4.9, and version 1.2 of the AutPGrp package. However, we recommend using at least GAP 4.6 and AutPGrp 1.5.

To install the ANUPQ package, move the file anupq-XXX.tar.gz for some version number XXX into the pkg directory in which you plan to install ANUPQ. Usually, this will be the directory pkg in the hierarchy of your version of GAP; it is however also possible to keep an additional pkg directory in your private directories. The only essential difference with installing ANUPQ in a pkg directory different to the GAP home directory is that one must start GAP with the -l switch (see Section Reference: Command Line Options), e.g. if your private pkg directory is a subdirectory of mygap in your home directory you might type:

gap -l ";myhomedir/mygap"

where myhomedir is the path to your home directory, which may be replaced by a tilde. The empty path before the semicolon is filled in by the default path of the GAP home directory.

Then, in your chosen pkg directory, unpack anupq-XXX.tar.gz by

tar xf anupq-<XXX>.tar.gz

Change to the newly created anupq directory. Now you need to call configure. If you installed ANUPQ into the main pkg directory, call

./configure

If you installed ANUPQ in another directory than the usual 'pkg' subdirectory, instead call

./configure --with-gaproot=<path>

where path is the path to the GAP home directory. (You can also call

./configure --help

for further options.)

What this does is look for a file sysinfo.gap in the root directory of GAP in order to determine an architecture name for the subdirectory of bin in which to put the compiled pq binary. This only makes sense if GAP was compiled for the same architecture that pq will be. If you have a shared file system mounted across different architectures, then you should run configure and make for ANUPQ for each architecture immediately after compiling GAP on the same architecture.

If you had to install the package in your own directory but wish to use the system GAP then you will need to find out what path is. To do this, start up GAP and find out what GAP's root path is from finding the value of the variable GAPInfo.RootPaths, e.g.

gap> GAPInfo.RootPaths;
[ "/usr/local/lib/gap4r4/" ]

would tell you to use /usr/local/lib/gap4r4 for path.

The configure command will fetch the architecture type for which GAP has been compiled last and create a Makefile. You can now simply call

make

to compile the binary and to install it in the appropriate place.

The path of GAP (see Note below) used by the pq binary (the value GAP is set to in the make command) may be over-ridden by setting the environment variable ANUPQ_GAP_EXEC. These values are only of interest when the pq program is run as a standalone; however, the testPq script assumes you have set one of these correctly (see Section Testing your ANUPQ installation). When the pq program is started from GAP communication occurs via an iostream, so that the pq binary does not actually need to know a valid path for GAP is this case.

Note. By path of GAP we mean the path of the command used to invoke GAP (which should be a script, e.g. the gap.sh script generated in the bin directory for the version of GAP when GAP was compiled). The usual strategy is to copy the gap.sh script to a standard location, e.g. /usr/local/bin/gap. It is a mistake to copy the GAP executable gap (in a directory with name of form bin/compile-platform) to the standard location, since direct invocation of the executable results in GAP starting without being able to find its own library (a fatal error).

7.1 Testing your ANUPQ installation

Now it is time to test the installation. After doing configure and make you will have a testPq script. The script assumes that, if the environment variable ANUPQ_GAP_EXEC is set, it is a correct path for GAP, or otherwise that the make call that compiled the pq program set GAP to a correct path for GAP (see Section Running the pq program as a standalone for more details). To run the tests, just type:

./testPq

Some of the tests the script runs take a while. Please be patient. The script checks that you not only have a correct GAP (at least version 4.4) installation that includes the AutPGrp package, but that the ANUPQ package and its pq binary interact correctly. You should see something like the following output:

Made dir: /tmp/testPq
Testing installation of ANUPQ Package (version 3.1)
 
The first two tests check that the pq C program compiled ok.
Testing the pq binary ... OK.
Testing the pq binary's stack size ... OK.
The pq C program compiled ok! We test it's the right one below.
 
The next tests check that you have the right version of GAP
for the ANUPQ package and that GAP is finding
the right versions of the ANUPQ and AutPGrp packages.
 
Checking GAP ...
 pq binary made with GAP set to: /usr/local/bin/gap
 Starting GAP to determine version and package availability ...
  GAP version (4.6.5) ... OK.
  GAP found ANUPQ package (version 3.1) ... good.
  GAP found pq binary (version 1.9) ... good.
  GAP found AutPGrp package (version 1.5) ... good.
 GAP is OK.
 
Checking the link between the pq binary and GAP ... OK.
Testing the standard presentation part of the pq binary ... OK.
Doing p-group generation (final GAP/ANUPQ) test ... OK.
Tests complete.
Removed dir: /tmp/testPq
Enjoy using your functional ANUPQ package!

7.2 Running the pq program as a standalone

When the pq program is run as a standalone it sometimes needs to call GAP to compute stabilisers of subgroups; in doing so, it first checks the value of the environment variable ANUPQ_GAP_EXEC, and uses that, if set, or otherwise the value of GAP it was compiled with, as the path for GAP. If you ran testPq (see Section Testing your ANUPQ installation) and you got both GAP is OK and the link between the pq binary and GAP is OK, you should be fine. Otherwise heed the recommendations of the error messages you get and run the testPq until all tests are passed.

It is especially important that the GAP, whose path you gave, should know where to find the ANUPQ and AutPGrp packages. To ensure this the path should be to a shell script that invokes GAP. If you needed to install the needed packages in your own directory (because, say, you are not a system administrator) then you should create your own shell script that runs GAP with a correct setting of the -l option and set the path used by the pq binary to the path of that script. To create the script that runs GAP it is easiest to copy the system one and edit it, e.g. start by executing the following UNIX commands (skip the second step if you already have a bin directory; you@unix> is your UNIX prompt):

you@unix> cd
you@unix> mkdir bin
you@unix> cd bin
you@unix> which gap
/usr/local/bin/gap
you@unix> cp /usr/local/bin/gap mygap
you@unix> chmod +x mygap

At the second-last step use the path of GAP returned by which gap. Now hopefully you will have a copy of the script that runs the system GAP in mygap. Now use your favourite editor to edit the -l part of the last line of mygap which should initially look something like:

exec $GAP_DIR/bin/$GAP_PRG -m $GAP_MEM -o 970m -l $GAP_DIR $*

so that it becomes (the tilde is a UNIX abbreviation for your home directory):

exec $GAP_DIR/bin/$GAP_PRG -m $GAP_MEM -o 970m -l "$GAP_DIR;~/gapstuff" $*

assuming that your personal GAP pkg directory is a subdirectory of gapstuff in your home directory. Finally, to let the pq program know where GAP is and also know where your pkg directory is that contains ANUPQ, set the environment variable ANUPQ_GAP_EXEC to the complete (i.e. absolute) path of your mygap script (do not use the tilde abbreviation).

 [Top of Book]  [Contents]   [Previous Chapter]   [Next Chapter] 
Goto Chapter: Top 1 2 3 4 5 6 7 A Bib Ind

generated by GAPDoc2HTML

anupq-3.3.3/doc/chapA.txt0000644000175100017510000013000715111342310014564 0ustar runnerrunner A Examples There are a large number of examples provided with the ANUPQ package. These may be executed or displayed via the function PqExample (see PqExample (3.4-4)). Each example resides in a file of the same name in the directory examples. Most of the examples are translations to GAP of examples provided for the pq standalone by Eamonn O'Brien; the standalone examples are found in directories standalone/examples (p-quotient and p-group generation examples) and standalone/isom (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 live is always indicated near -- usually immediately after -- the text example). The format of the (PqExample) examples is such that they can be read by the standard Read function of GAP, but certain features and comments are interpreted by the function PqExample to do somewhat more than Read does. In particular, any function without a -i, -ni or .g suffix has both a non-interactive and interactive form; in these cases, the default form is the non-interactive form, and giving PqStart as second argument generates the interactive form. Running PqExample without an argument or with a non-existent example Infos the available examples and some hints on usage:  Example  gap> PqExample(); #I PqExample Index (Table of Contents) #I ----------------------------------- #I This table of possible examples is displayed when calling `PqExample' #I with no arguments, or with the argument: "index" (meant in the sense #I of ``list''), or with a non-existent example name. #I  #I Examples that have a name ending in `-ni' are non-interactive only. #I Examples that have a name ending in `-i' are interactive only. #I Examples with names ending in `.g' also have only one form. Other #I examples have both a non-interactive and an interactive form; call #I `PqExample' with 2nd argument `PqStart' to get the interactive form #I of the example. The substring `PG' in an example name indicates a #I p-Group Generation example, `SP' indicates a Standard Presentation #I example, `Rel' indicates it uses the `Relators' option, and `Id' #I indicates it uses the `Identities' option. #I  #I The following ANUPQ examples are available: #I  #I p-Quotient examples: #I general: #I "Pq" "Pq-ni" "PqEpimorphism"  #I "PqPCover" "PqSupplementInnerAutomorphisms" #I 2-groups: #I "2gp-Rel" "2gp-Rel-i" "2gp-a-Rel-i" #I "B2-4" "B2-4-Id" "B2-8-i" #I "B4-4-i" "B4-4-a-i" "B5-4.g" #I 3-groups: #I "3gp-Rel-i" "3gp-a-Rel" "3gp-a-Rel-i" #I "3gp-a-x-Rel-i" "3gp-maxoccur-Rel-i" #I 5-groups: #I "5gp-Rel-i" "5gp-a-Rel-i" "5gp-b-Rel-i" #I "5gp-c-Rel-i" "5gp-metabelian-Rel-i" "5gp-maxoccur-Rel-i" #I "F2-5-i" "B2-5-i" "R2-5-i" #I "R2-5-x-i" "B5-5-Engel3-Id" #I 7-groups: #I "7gp-Rel-i" #I 11-groups: #I "11gp-i" "11gp-Rel-i" "11gp-a-Rel-i" #I "11gp-3-Engel-Id" "11gp-3-Engel-Id-i" #I  #I p-Group Generation examples: #I general: #I "PqDescendants-1" "PqDescendants-2" "PqDescendants-3" #I "PqDescendants-1-i" #I 2-groups: #I "2gp-PG-i" "2gp-PG-2-i" "2gp-PG-3-i" #I "2gp-PG-4-i" "2gp-PG-e4-i" #I "PqDescendantsTreeCoclassOne-16-i" #I 3-groups: #I "3gp-PG-i" "3gp-PG-4-i" "3gp-PG-x-i" #I "3gp-PG-x-1-i" "PqDescendants-treetraverse-i" #I "PqDescendantsTreeCoclassOne-9-i" #I 5-groups: #I "5gp-PG-i" "Nott-PG-Rel-i" "Nott-APG-Rel-i" #I "PqDescendantsTreeCoclassOne-25-i" #I 7,11-groups: #I "7gp-PG-i" "11gp-PG-i" #I  #I Standard Presentation examples: #I general: #I "StandardPresentation" "StandardPresentation-i" #I "EpimorphismStandardPresentation" #I "EpimorphismStandardPresentation-i" "IsIsomorphicPGroup-ni" #I 2-groups: #I "2gp-SP-Rel-i" "2gp-SP-1-Rel-i" "2gp-SP-2-Rel-i" #I "2gp-SP-3-Rel-i" "2gp-SP-4-Rel-i" "2gp-SP-d-Rel-i" #I "gp-256-SP-Rel-i" "B2-4-SP-i" "G2-SP-Rel-i" #I 3-groups: #I "3gp-SP-Rel-i" "3gp-SP-1-Rel-i" "3gp-SP-2-Rel-i" #I "3gp-SP-3-Rel-i" "3gp-SP-4-Rel-i" "G3-SP-Rel-i" #I 5-groups: #I "5gp-SP-Rel-i" "5gp-SP-a-Rel-i" "5gp-SP-b-Rel-i" #I "5gp-SP-big-Rel-i" "5gp-SP-d-Rel-i" "G5-SP-Rel-i" #I "G5-SP-a-Rel-i" "Nott-SP-Rel-i" #I 7-groups: #I "7gp-SP-Rel-i" "7gp-SP-a-Rel-i" "7gp-SP-b-Rel-i" #I 11-groups: #I "11gp-SP-a-i" "11gp-SP-a-Rel-i" "11gp-SP-a-Rel-1-i" #I "11gp-SP-b-i" "11gp-SP-b-Rel-i" "11gp-SP-c-Rel-i" #I  #I Notes #I ----- #I 1. The example (first) argument of `PqExample' is a string; each #I example above is in double quotes to remind you to include them. #I 2. Some examples accept options. To find out whether a particular #I example accepts options, display it first (by including `Display' #I as last argument) which will also indicate how `PqExample' #I interprets the options, e.g. `PqExample("11gp-SP-a-i", Display);'. #I 3. Try `SetInfoLevel(InfoANUPQ, );' for some in [2 .. 4] #I before calling PqExample, to see what's going on behind the scenes. #I   If on your terminal you are unable to scroll back, an alternative to typing PqExample(); to see the displayed examples is to use on-line help, i.e.  you may type:  Example  gap> ?anupq:examples  which will display this appendix in a GAP session. If you are not fussed about the order in which the examples are organised, AllPqExamples(); lists the available examples relatively compactly (see AllPqExamples (3.4-5)). In the remainder of this appendix we will discuss particular aspects related to the Relators (see 6.2) and Identities (see 6.2) options, and the construction of the Burnside group B(5, 4). A.1 The Relators Option The Relators option was included because computations involving words containing commutators that are pre-expanded by GAP before being passed to the pq program may run considerably more slowly, than the same computations being run with GAP pre-expansions avoided. The following examples demonstrate a case where the performance hit due to pre-expansion of commutators by GAP is a factor of order 100 (in order to see timing information from the pq program, we set the InfoANUPQ level to 2). Firstly, we run the example that allows pre-expansion of commutators (the function PqLeftNormComm is provided by the ANUPQ package; see PqLeftNormComm (3.4-1)). Note that since the two commutators of this example are very long (taking more than an page to print), we have edited the output at this point.  Example  gap> SetInfoLevel(InfoANUPQ, 2); #to see timing information gap> PqExample("11gp-i"); #I #Example: "11gp-i" . . . based on: examples/11gp #I F, a, b, c, R, procId are local to `PqExample' gap> F := FreeGroup("a", "b", "c"); a := F.1; b := F.2; c := F.3;  a b c gap> R := [PqLeftNormComm([b, a, a, b, c])^11,  >  PqLeftNormComm([a, b, b, a, b, c])^11, (a * b)^11];; gap> procId := PqStart(F/R : Prime := 11);; gap> PqPcPresentation(procId : ClassBound := 7,  >  OutputLevel := 1); #I Lower exponent-11 central series for [grp] #I Group: [grp] to lower exponent-11 central class 1 has order 11^3 #I Group: [grp] to lower exponent-11 central class 2 has order 11^8 #I Group: [grp] to lower exponent-11 central class 3 has order 11^19 #I Group: [grp] to lower exponent-11 central class 4 has order 11^42 #I Group: [grp] to lower exponent-11 central class 5 has order 11^98 #I Group: [grp] to lower exponent-11 central class 6 has order 11^228 #I Group: [grp] to lower exponent-11 central class 7 has order 11^563 #I Computation of presentation took 27.04 seconds gap> PqSavePcPresentation(procId, ANUPQData.outfile); #I Variables used in `PqExample' are saved in `ANUPQData.example.vars'.  Now we do the same calculation using the Relators option. In this way, the commutators are passed directly as strings to the pq program, so that GAP does not see them and pre-expand them.  Example  gap> PqExample("11gp-Rel-i"); #I #Example: "11gp-Rel-i" . . . based on: examples/11gp #I #(equivalent to "11gp-i" example but uses `Relators' option) #I F, rels, procId are local to `PqExample' gap> F := FreeGroup("a", "b", "c");  gap> rels := ["[b, a, a, b, c]^11", "[a, b, b, a, b, c]^11", "(a * b)^11"]; [ "[b, a, a, b, c]^11", "[a, b, b, a, b, c]^11", "(a * b)^11" ] gap> procId := PqStart(F : Prime := 11, Relators := rels);; gap> PqPcPresentation(procId : ClassBound := 7,  >  OutputLevel := 1); #I Relators parsed ok. #I Lower exponent-11 central series for [grp] #I Group: [grp] to lower exponent-11 central class 1 has order 11^3 #I Group: [grp] to lower exponent-11 central class 2 has order 11^8 #I Group: [grp] to lower exponent-11 central class 3 has order 11^19 #I Group: [grp] to lower exponent-11 central class 4 has order 11^42 #I Group: [grp] to lower exponent-11 central class 5 has order 11^98 #I Group: [grp] to lower exponent-11 central class 6 has order 11^228 #I Group: [grp] to lower exponent-11 central class 7 has order 11^563 #I Computation of presentation took 0.27 seconds gap> PqSavePcPresentation(procId, ANUPQData.outfile); #I Variables used in `PqExample' are saved in `ANUPQData.example.vars'.  A.2 The Identities Option and PqEvaluateIdentities Function Please pay heed to the warnings given for the Identities option (see 6.2); it is written mainly at the GAP level and is not particularly optimised. The Identities option allows one to compute p-quotients that satisfy an identity. A trivial example better done using the Exponent option, but which nevertheless demonstrates the usage of the Identities option, is as follows:  Example  gap> SetInfoLevel(InfoANUPQ, 1); gap> PqExample("B2-4-Id"); #I #Example: "B2-4-Id" . . . alternative way to generate B(2, 4) #I #Generates B(2, 4) by using the `Identities' option #I #... this is not as efficient as using `Exponent' but #I #demonstrates the usage of the `Identities' option. #I F, f, procId are local to `PqExample' gap> F := FreeGroup("a", "b");  gap> # All words w in the pc generators of B(2, 4) satisfy f(w) = 1  gap> f := w -> w^4; function( w ) ... end gap> Pq( F : Prime := 2, Identities := [ f ] ); #I Class 1 with 2 generators. #I Class 2 with 5 generators. #I Class 3 with 7 generators. #I Class 4 with 10 generators. #I Class 5 with 12 generators. #I Class 5 with 12 generators.  #I Variables used in `PqExample' are saved in `ANUPQData.example.vars'. gap> time;  1400  Note that the time statement gives the time in milliseconds spent by GAP in executing the PqExample("B2-4-Id"); command (i.e. everything up to the Info-ing of the variables used), but over 90% of that time is spent in the final Pq statement. The time spent by the pq program, which is negligible anyway (you can check this by running the example while the InfoANUPQ level is set to 2), is not counted by time. Since the identity used in the above construction of B(2, 4) is just an exponent law, the right way to compute it is via the Exponent option (see 6.2), which is implemented at the C level and is highly optimised. Consequently, the Exponent option is significantly faster, generally by several orders of magnitude:  Example  gap> SetInfoLevel(InfoANUPQ, 2); # to see time spent by the `pq' program gap> PqExample("B2-4"); #I #Example: "B2-4" . . . the ``right'' way to generate B(2, 4) #I #Generates B(2, 4) by using the `Exponent' option #I F, procId are local to `PqExample' gap> F := FreeGroup("a", "b");  gap> Pq( F : Prime := 2, Exponent := 4 ); #I Computation of presentation took 0.00 seconds  #I Variables used in `PqExample' are saved in `ANUPQData.example.vars'. gap> time; # time spent by GAP in executing `PqExample("B2-4");'  50  The following example uses the Identities option to compute a 3-Engel group for the prime 11. As is the case for the example "B2-4-Id", the example has both a non-interactive and an interactive form; below, we demonstrate the interactive form.  Example  gap> SetInfoLevel(InfoANUPQ, 1); # reset InfoANUPQ to default level gap> PqExample("11gp-3-Engel-Id", PqStart); #I #Example: "11gp-3-Engel-Id" . . . 3-Engel group for prime 11 #I #Non-trivial example of using the `Identities' option #I F, a, b, G, f, procId, Q are local to `PqExample' gap> F := FreeGroup("a", "b"); a := F.1; b := F.2;  a b gap> G := F/[ a^11, b^11 ];  gap> # All word pairs u, v in the pc generators of the 11-quotient Q of G  gap> # must satisfy the Engel identity: [u, v, v, v] = 1. gap> f := function(u, v) return PqLeftNormComm( [u, v, v, v] ); end; function( u, v ) ... end gap> procId := PqStart( G );; gap> Q := Pq( procId : Prime := 11, Identities := [ f ] ); #I Class 1 with 2 generators. #I Class 2 with 3 generators. #I Class 3 with 5 generators. #I Class 3 with 5 generators.  gap> # We do a ``sample'' check that pairs of elements of Q do satisfy gap> # the given identity: gap> f( Random(Q), Random(Q) );  of ... gap> f( Q.1, Q.2 );  of ... #I Variables used in `PqExample' are saved in `ANUPQData.example.vars'.  The (interactive) call to Pq above is essentially equivalent to a call to PqPcPresentation with the same arguments and options followed by a call to PqCurrentGroup. Moreover, the call to PqPcPresentation (as described in PqPcPresentation (5.6-1)) is equivalent to a class 1 call to PqPcPresentation followed by the requisite number of calls to PqNextClass, and with the Identities option set, both PqPcPresentation and PqNextClass quietly perform the equivalent of a PqEvaluateIdentities call. In the following example we break down the Pq call into its low-level equivalents, and set and unset the Identities option to show where PqEvaluateIdentities fits into this scheme.  Example  gap> PqExample("11gp-3-Engel-Id-i"); #I #Example: "11gp-3-Engel-Id-i" . . . 3-Engel grp for prime 11 #I #Variation of "11gp-3-Engel-Id" broken down into its lower-level component #I #command parts. #I F, a, b, G, f, procId, Q are local to `PqExample' gap> F := FreeGroup("a", "b"); a := F.1; b := F.2;  a b gap> G := F/[ a^11, b^11 ];  gap> # All word pairs u, v in the pc generators of the 11-quotient Q of G  gap> # must satisfy the Engel identity: [u, v, v, v] = 1. gap> f := function(u, v) return PqLeftNormComm( [u, v, v, v] ); end; function( u, v ) ... end gap> procId := PqStart( G : Prime := 11 );; gap> PqPcPresentation( procId : ClassBound := 1); gap> PqEvaluateIdentities( procId : Identities := [f] ); #I Class 1 with 2 generators. gap> for c in [2 .. 4] do >  PqNextClass( procId : Identities := [] ); #reset `Identities' option >  PqEvaluateIdentities( procId : Identities := [f] ); >  od; #I Class 2 with 3 generators. #I Class 3 with 5 generators. #I Class 3 with 5 generators. gap> Q := PqCurrentGroup( procId );  gap> # We do a ``sample'' check that pairs of elements of Q do satisfy gap> # the given identity: gap> f( Random(Q), Random(Q) );  of ... gap> f( Q.1, Q.2 );  of ... #I Variables used in `PqExample' are saved in `ANUPQData.example.vars'.  A.3 A Large Example An example demonstrating how a large computation can be organised with the ANUPQ package is the computation of the Burnside group B(5, 4), the largest group of exponent 4 generated by 5 elements. It has order 2^2728 and lower exponent-p central class 13. The example "B5-4.g" computes B(5, 4); it is based on a pq standalone input file written by M. F. Newman. 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 GAP. Please note that the construction uses the knowledge gained by Newman and O'Brien in their initial construction of B(5, 4), in particular, insight into the commutator structure of the group and the knowledge of the p-central class and the order of B(5, 4). Therefore, the construction cannot be used to prove that B(5, 4) 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 examples/B5-4.g.  Example  procId := PqStart( FreeGroup(5) : Exponent := 4, Prime := 2 ); Pq( procId : ClassBound := 2 ); PqSupplyAutomorphisms( procId,  [  [ [ 1, 1, 0, 0, 0], # first automorphism  [ 0, 1, 0, 0, 0],  [ 0, 0, 1, 0, 0],  [ 0, 0, 0, 1, 0],  [ 0, 0, 0, 0, 1] ],   [ [ 0, 0, 0, 0, 1], # second automorphism  [ 1, 0, 0, 0, 0],  [ 0, 1, 0, 0, 0],  [ 0, 0, 1, 0, 0],  [ 0, 0, 0, 1, 0] ]  ] );;  Relations :=  [ [], ## class 1  [], ## class 2  [], ## class 3  [], ## class 4  [], ## class 5  [], ## class 6  ## class 7   [ [ "x2","x1","x1","x3","x4","x4","x4" ] ],  ## class 8  [ [ "x2","x1","x1","x3","x4","x5","x5","x5" ] ],  ## class 9  [ [ "x2","x1","x1","x3","x4","x4","x5","x5","x5" ],  [ "x2","x1","x1","x2","x3","x4","x5","x5","x5" ],  [ "x2","x1","x1","x3","x3","x4","x5","x5","x5" ] ],  ## class 10  [ [ "x2","x1","x1","x2","x3","x3","x4","x5","x5","x5" ],  [ "x2","x1","x1","x3","x3","x4","x4","x5","x5","x5" ] ],  ## class 11  [ [ "x2","x1","x1","x2","x3","x3","x4","x4","x5","x5","x5" ],  [ "x2","x1","x1","x2","x3","x1","x3","x4","x2","x4","x3" ] ],  ## class 12  [ [ "x2","x1","x1","x2","x3","x1","x3","x4","x2","x5","x5","x5" ],  [ "x2","x1","x1","x3","x2","x4","x3","x5","x4","x5","x5","x5" ] ],  ## class 13  [ [ "x2","x1","x1","x2","x3","x1","x3","x4","x2","x4","x5","x5","x5"   ] ] ];  for class in [ 3 .. 13 ] do  Print( "Computing class ", class, "\n" );  PqSetupTablesForNextClass( procId );   for w in [ class, class-1 .. 7 ] do   PqAddTails( procId, w );   PqDisplayPcPresentation( procId );   if Relations[ w ] <> [] then  # recalculate automorphisms  PqExtendAutomorphisms( procId );   for r in Relations[ w ] do  Print( "Collecting ", r, "\n" );  PqCommutator( procId, r, 1 );  PqEchelonise( procId );  PqApplyAutomorphisms( procId, 15 ); #queue factor = 15  od;   PqEliminateRedundantGenerators( procId );  fi;   PqComputeTails( procId, w );  od;  PqDisplayPcPresentation( procId );   smallclass := Minimum( class, 6 );  for w in [ smallclass, smallclass-1 .. 2 ] do  PqTails( procId, w );  od;  # recalculate automorphisms  PqExtendAutomorphisms( procId );  PqCollect( procId, "x5^4" );  PqEchelonise( procId );  PqApplyAutomorphisms( procId, 15 ); #queue factor = 15  PqEliminateRedundantGenerators( procId );  PqDisplayPcPresentation( procId ); od;  A.4 Developing descendants trees 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 p-group generation machinery of the package. We start with the elementary abelian 3-group of rank 2. From within GAP, run the example "PqDescendants-treetraverse-i" via PqExample (see PqExample (3.4-4)).  Example  gap> G := ElementaryAbelianGroup( 9 );  gap> procId := PqStart( G );; gap> # gap> # Below, we use the option StepSize in order to construct descendants gap> # of coclass 1. This is equivalent to setting the StepSize to 1 in gap> # each descendant calculation. gap> # gap> # The elementary abelian group of order 9 has 3 descendants of gap> # 3-class 2 and 3-coclass 1, as the result of the next command gap> # shows.  gap> # gap> PqDescendants( procId : StepSize := 1 ); [ ,   ,   ] gap> # gap> # Now we will compute the descendants of coclass 1 for each of the gap> # groups above. Then we will compute the descendants of coclass 1 gap> # of each descendant and so on. Note that the pq program keeps gap> # one file for each class at a time. For example, the descendants gap> # calculation for the second group of class 2 overwrites the gap> # descendant file obtained from the first group of class 2. gap> # Hence, we have to traverse the descendants tree in depth first gap> # order. gap> # gap> PqPGSetDescendantToPcp( procId, 2, 1 ); gap> PqPGExtendAutomorphisms( procId ); gap> PqPGConstructDescendants( procId : StepSize := 1 ); 2 gap> PqPGSetDescendantToPcp( procId, 3, 1 ); gap> PqPGExtendAutomorphisms( procId ); gap> PqPGConstructDescendants( procId : StepSize := 1 ); 2 gap> PqPGSetDescendantToPcp( procId, 4, 1 ); gap> PqPGExtendAutomorphisms( procId ); gap> PqPGConstructDescendants( procId : StepSize := 1 ); 2 gap> # gap> # At this point we stop traversing the ``left most'' branch of the gap> # descendants tree and move upwards. gap> # gap> PqPGSetDescendantToPcp( procId, 4, 2 ); gap> PqPGExtendAutomorphisms( procId ); gap> PqPGConstructDescendants( procId : StepSize := 1 ); #I group restored from file is incapable 0 gap> PqPGSetDescendantToPcp( procId, 3, 2 ); gap> PqPGExtendAutomorphisms( procId ); gap> PqPGConstructDescendants( procId : StepSize := 1 ); #I group restored from file is incapable 0 gap> #  gap> # The computations above indicate that the descendants subtree under gap> # the first descendant of the elementary abelian group of order 9 gap> # will have only one path of infinite length. gap> # gap> PqPGSetDescendantToPcp( procId, 2, 2 ); gap> PqPGExtendAutomorphisms( procId ); gap> PqPGConstructDescendants( procId : StepSize := 1 ); 4 gap> # gap> # We get four descendants here, three of which will turn out to be gap> # incapable, i.e., they have no descendants and are terminal nodes gap> # in the descendants tree. gap> # gap> PqPGSetDescendantToPcp( procId, 2, 3 ); gap> PqPGExtendAutomorphisms( procId ); gap> PqPGConstructDescendants( procId : StepSize := 1 ); #I group restored from file is incapable 0 gap> # gap> # The third descendant of class three is incapable. Let us return gap> # to the second descendant of class 2. gap> # gap> PqPGSetDescendantToPcp( procId, 2, 2 ); gap> PqPGExtendAutomorphisms( procId ); gap> PqPGConstructDescendants( procId : StepSize := 1 ); 4 gap> PqPGSetDescendantToPcp( procId, 3, 1 ); gap> PqPGExtendAutomorphisms( procId ); gap> PqPGConstructDescendants( procId : StepSize := 1 ); #I group restored from file is incapable 0 gap> PqPGSetDescendantToPcp( procId, 3, 2 ); gap> PqPGExtendAutomorphisms( procId ); gap> PqPGConstructDescendants( procId : StepSize := 1 ); #I group restored from file is incapable 0 gap> # gap> # We skip the third descendant for the moment ...  gap> # gap> PqPGSetDescendantToPcp( procId, 3, 4 ); gap> PqPGExtendAutomorphisms( procId ); gap> PqPGConstructDescendants( procId : StepSize := 1 ); #I group restored from file is incapable 0 gap> # gap> # ... and look at it now. gap> # gap> PqPGSetDescendantToPcp( procId, 3, 3 ); gap> PqPGExtendAutomorphisms( procId ); gap> PqPGConstructDescendants( procId : StepSize := 1 ); 6 gap> # gap> # In this branch of the descendant tree we get 6 descendants of class gap> # three. Of those 5 will turn out to be incapable and one will have gap> # 7 descendants. gap> # gap> PqPGSetDescendantToPcp( procId, 4, 1 ); gap> PqPGExtendAutomorphisms( procId ); gap> PqPGConstructDescendants( procId : StepSize := 1 ); #I group restored from file is incapable 0 gap> PqPGSetDescendantToPcp( procId, 4, 2 ); gap> PqPGExtendAutomorphisms( procId ); gap> PqPGConstructDescendants( procId : StepSize := 1 ); 7 gap> PqPGSetDescendantToPcp( procId, 4, 3 ); gap> PqPGExtendAutomorphisms( procId ); gap> PqPGConstructDescendants( procId : StepSize := 1 ); #I group restored from file is incapable 0  To automate the above procedure to some extent we provide: A.4-1 PqDescendantsTreeCoclassOne PqDescendantsTreeCoclassOne( i )  function PqDescendantsTreeCoclassOne( )  function for the ith or default interactive ANUPQ process, generate a descendant tree for the group of the process (which must be a pc p-group) consisting of descendants of p-coclass 1 and extending to the class determined by the option TreeDepth (or 6 if the option is omitted). In an XGAP session, a graphical representation of the descendants tree appears in a separate window. Subsequent calls to PqDescendantsTreeCoclassOne for the same process may be used to extend the descendant tree from the last descendant computed that itself has more than one descendant. PqDescendantsTreeCoclassOne also accepts the options CapableDescendants (or AllDescendants) and any options accepted by the interactive PqDescendants function (see PqDescendants (5.3-6)). Notes 1 PqDescendantsTreeCoclassOne first calls PqDescendants. If PqDescendants has already been called for the process, the previous value computed is used and a warning is Info-ed at InfoANUPQ level 1. 2 As each descendant is processed its unique label defined by the pq program and number of descendants is Info-ed at InfoANUPQ level 1. 3 PqDescendantsTreeCoclassOne is an experimental function that is included to demonstrate the sort of things that are possible with the p-group generation machinery. Ignoring the extra functionality provided in an XGAP session, PqDescendantsTreeCoclassOne, with one argument that is the index of an interactive ANUPQ process, is approximately equivalent to:  PqDescendantsTreeCoclassOne := function( procId )  local des, i;   des := PqDescendants( procId : StepSize := 1 );  RecurseDescendants( procId, 2, Length(des) ); end;  where RecurseDescendants is (approximately) defined as follows:  RecurseDescendants := function( procId, class, n )  local i, nr;   if class > ValueOption("TreeDepth") then return; fi;   for i in [1..n] do  PqPGSetDescendantToPcp( procId, class, i );  PqPGExtendAutomorphisms( procId );  nr := PqPGConstructDescendants( procId : StepSize := 1 );  Print( "Number of descendants of group ", i,  " at class ", class, ": ", nr, "\n" );  RecurseDescendants( procId, class+1, nr );  od;  return; end;  The following examples (executed via PqExample; see PqExample (3.4-4)), demonstrate the use of PqDescendantsTreeCoclassOne: "PqDescendantsTreeCoclassOne-9-i" approximately does example "PqDescendants-treetraverse-i" again using PqDescendantsTreeCoclassOne; "PqDescendantsTreeCoclassOne-16-i" uses the option CapableDescendants; and "PqDescendantsTreeCoclassOne-25-i" calculates all descendants by omitting the CapableDescendants option. The numbers 9, 16 and 25 respectively, indicate the order of the elementary abelian group to which PqDescendantsTreeCoclassOne is applied for these examples. anupq-3.3.3/doc/ANUPQ.bib0000644000175100017510000001412715111342310014355 0ustar runnerrunner@incollection {HN80, AUTHOR = {Havas, George and Newman, M. F.}, TITLE = {Application of computers to questions like those of {B}urnside}, BOOKTITLE = {Burnside groups ({P}roc. {W}orkshop, {U}niv. {B}ielefeld, {B}ielefeld, 1977)}, SERIES = {Lecture Notes in Math.}, VOLUME = {806}, PAGES = {211--230}, PUBLISHER = {Springer}, ADDRESS = {Berlin}, YEAR = {1980}, MRCLASS = {20-04 (20F50)}, MRNUMBER = {586047 (82d:20002)}, MRREVIEWER = {Colin M. Campbell}, DOI = {10.1007/BFb0091271}, URL = {https://doi.org/10.1007/BFb0091271}, } @article {NO96, AUTHOR = {Newman, M. F. and O'Brien, E. A.}, TITLE = {Application of computers to questions like those of {B}urnside. {II}}, JOURNAL = {Internat. J. Algebra Comput.}, FJOURNAL = {International Journal of Algebra and Computation}, VOLUME = {6}, YEAR = {1996}, NUMBER = {5}, PAGES = {593--605}, ISSN = {0218-1967}, MRCLASS = {20-04 (20D15 20F05)}, MRNUMBER = {1419133 (97k:20002)}, MRREVIEWER = {Colin M. Campbell}, DOI = {10.1142/S0218196796000337}, URL = {https://doi.org/10.1142/S0218196796000337}, } @article {NNN98, AUTHOR = {Newman, M. F. and Nickel, Werner and Niemeyer, Alice C.}, TITLE = {Descriptions of groups of prime-power order}, JOURNAL = {J. Symbolic Comput.}, FJOURNAL = {Journal of Symbolic Computation}, VOLUME = {25}, YEAR = {1998}, NUMBER = {5}, PAGES = {665--682}, ISSN = {0747-7171}, MRCLASS = {20F05 (68Q40)}, MRNUMBER = {1617995 (99f:20054)}, MRREVIEWER = {Michael C. Slattery}, DOI = {10.1006/jsco.1997.0193}, URL = {https://doi.org/10.1006/jsco.1997.0193}, } @article {LGS90, AUTHOR = {Leedham-Green, C. R. and Soicher, L. H.}, TITLE = {Collection from the left and other strategies}, NOTE = {Computational group theory, Part 1}, JOURNAL = {J. Symbolic Comput.}, FJOURNAL = {Journal of Symbolic Computation}, VOLUME = {9}, YEAR = {1990}, NUMBER = {5-6}, PAGES = {665--675}, ISSN = {0747-7171}, MRCLASS = {20D10 (68Q25)}, MRNUMBER = {1075430 (92b:20021)}, MRREVIEWER = {M. Greendlinger}, DOI = {10.1016/S0747-7171(08)80081-8}, URL = {https://doi.org/10.1016/S0747-7171(08)80081-8}, } @incollection {New77, AUTHOR = {Newman, M. F.}, TITLE = {Determination of groups of prime-power order}, BOOKTITLE = {Group theory ({P}roc. {M}iniconf., {A}ustralian {N}at. {U}niv., {C}anberra, 1975)}, PAGES = {73--84. Lecture Notes in Math., Vol. 573}, PUBLISHER = {Springer}, ADDRESS = {Berlin}, YEAR = {1977}, MRCLASS = {20D15}, MRNUMBER = {0453862 (56 \#12115)}, MRREVIEWER = {Bruce W. King}, } @article {OBr90, AUTHOR = {O'Brien, E. A.}, TITLE = {The {$p$}-group generation algorithm}, NOTE = {Computational group theory, Part 1}, JOURNAL = {J. Symbolic Comput.}, FJOURNAL = {Journal of Symbolic Computation}, VOLUME = {9}, YEAR = {1990}, NUMBER = {5-6}, PAGES = {677--698}, ISSN = {0747-7171}, MRCLASS = {20D15}, MRNUMBER = {1075431 (91j:20050)}, DOI = {10.1016/S0747-7171(08)80082-X}, URL = {https://doi.org/10.1016/S0747-7171(08)80082-X}, } @article {OBr94, AUTHOR = {O'Brien, E. A.}, TITLE = {Isomorphism testing for {$p$}-groups}, JOURNAL = {J. Symbolic Comput.}, FJOURNAL = {Journal of Symbolic Computation}, VOLUME = {17}, YEAR = {1994}, NUMBER = {2}, PAGES = {131, 133--147}, ISSN = {0747-7171}, MRCLASS = {20D15 (20D45 20F28)}, MRNUMBER = {1283739 (95f:20040b)}, MRREVIEWER = {Richard Davitt}, DOI = {10.1006/jsco.1994.1007}, URL = {https://doi.org/10.1006/jsco.1994.1007}, } @incollection {OBr95, AUTHOR = {O'Brien, E. A.}, TITLE = {Computing automorphism groups of {$p$}-groups}, BOOKTITLE = {Computational algebra and number theory ({S}ydney, 1992)}, SERIES = {Math. Appl.}, VOLUME = {325}, PAGES = {83--90}, PUBLISHER = {Kluwer Acad. Publ.}, ADDRESS = {Dordrecht}, YEAR = {1995}, MRCLASS = {20D15 (20D45)}, MRNUMBER = {1344923 (96g:20024)}, MRREVIEWER = {Wolfgang Lempken}, } @book {Sims94, AUTHOR = {Sims, Charles C.}, TITLE = {Computation with finitely presented groups}, SERIES = {Encyclopedia of Mathematics and its Applications}, VOLUME = {48}, PUBLISHER = {Cambridge University Press}, ADDRESS = {Cambridge}, YEAR = {1994}, PAGES = {xiii+604}, ISBN = {0-521-43213-8}, MRCLASS = {20F05 (20-02 68Q40 68Q42)}, MRNUMBER = {1267733 (95f:20053)}, MRREVIEWER = {Friedrich Otto}, DOI = {10.1017/CBO9780511574702}, URL = {https://doi.org/10.1017/CBO9780511574702}, } @incollection {VL84, AUTHOR = {Vaughan-Lee, M. R.}, TITLE = {An aspect of the nilpotent quotient algorithm}, BOOKTITLE = {Computational group theory ({D}urham, 1982)}, PAGES = {75--83}, PUBLISHER = {Academic Press}, ADDRESS = {London}, YEAR = {1984}, MRCLASS = {20F05 (20-04 20D15 68Q40)}, MRNUMBER = {760652 (86b:20040)}, MRREVIEWER = {M. F. Newman}, } @article {VL90a, AUTHOR = {Vaughan-Lee, M. R.}, TITLE = {Collection from the left}, NOTE = {Computational group theory, Part 1}, JOURNAL = {J. Symbolic Comput.}, FJOURNAL = {Journal of Symbolic Computation}, VOLUME = {9}, YEAR = {1990}, NUMBER = {5-6}, PAGES = {725--733}, ISSN = {0747-7171}, MRCLASS = {20F12 (20-04 20D15 20F18)}, MRNUMBER = {1075434 (92c:20065)}, MRREVIEWER = {M. Greendlinger}, DOI = {10.1016/S0747-7171(08)80085-5}, URL = {https://doi.org/10.1016/S0747-7171(08)80085-5}, } @book {VL90b, AUTHOR = {Vaughan-Lee, Michael}, TITLE = {The restricted {B}urnside problem}, SERIES = {London Mathematical Society Monographs. New Series}, VOLUME = {5}, NOTE = {Oxford Science Publications}, PUBLISHER = {The Clarendon Press Oxford University Press}, ADDRESS = {New York}, YEAR = {1990}, PAGES = {xiv+209}, ISBN = {0-19-853573-2}, MRCLASS = {20-02 (20F12 20F40 20F45 20F50)}, MRNUMBER = {1057610 (92c:20001)}, MRREVIEWER = {Norman Blackburn}, } anupq-3.3.3/doc/chapInd.html0000644000175100017510000007502315111342310015251 0ustar runnerrunner GAP (ANUPQ) - Index
Goto Chapter: Top 1 2 3 4 5 6 7 A Bib Ind
 [Top of Book]  [Contents]   [Previous Chapter] 

Index

AllANUPQoptions 6.1-1
allowable subgroup 2.1-4
AllPqExamples 3.4-5
ANUPQ 1.1
ANUPQ_GAP_EXEC, environment variable 7. 7.1 7.2
ANUPQData 3.2-1
ANUPQDirectoryTemporary 3.2-2
ANUPQoptions 6.1-2
ANUPQWarnOfOtherOptions 3.6-1
automorphisms, of p-groups 4.2 5.3-3
B(5,4) A.3
banner 3.1
bug reports 1.3
capable 2.1-4
class 2.1-2
collection 2.1-1
compaction 2.3
confluent 2.1-1
confluent rewriting system 2.1-1
consistency conditions 2.1-1
consistent 2.1-1
definition, of generator 2.2-1
descendant 2.1-4
echelonised matrix 2.3
Engel identity 2.1-5
EpimorphismPqStandardPresentation 4.2-2
    interactive 5.3-5
EpimorphismStandardPresentation 4.2-2
    interactive 5.3-5
exponent check 2.2-3
exponent law 2.1-5
exponent-p central series 2.1-2
extended automorphism 2.1-4
GrepPqExamples 3.4-6
identical relation 2.1-5
immediate descendant 2.1-4
InfoANUPQ 3.3-1
interruption 5.2-3
IsCapable 3.5-1
IsIsomorphicPGroup 4.3-1
isomorphism testing 2.3
IsPqIsomorphicPGroup 4.3-1
IsPqProcessAlive 5.2-3
    for default process 5.2-3
label of standard matrix 2.3
labelled pcp 2.2-1
law 2.1-5
menu item, of pq program 3.6
metabelian law 2.1-5
multiplicator rank 2.1-3
MultiplicatorRank 3.5-1
NuclearRank 3.5-1
nucleus 2.1-4 2.1-4
option, of pq program is a menu item 3.6
option AllDescendants 4.4-1 5.3-6 6.2
option BasicAlgorithm 4.4-1 5.3-6 6.2
option Bounds 6.2
option CapableDescendants 4.4-1 5.3-6 6.2
option ClassBound 4.1-1 4.2-1 4.4-1 5.3-1 5.3-4 5.3-6 5.8-2 6.2
option CustomiseOutput 4.4-1 5.3-6 6.2
option Exponent 4.1-1 4.2-1 4.4-1 5.3-1 5.3-4 5.3-6 6.2
option Filename 6.2
option GroupName 4.1-1 4.2-1 4.4-1 5.3-1 5.3-4 5.3-6 6.2
option Identities 4.1-1 5.3-1 6.2
    example of usage 4.1-1
option Metabelian 4.1-1 4.2-1 4.4-1 5.3-1 5.3-4 5.3-6 6.2
option NumberOfSolubleAutomorphisms 6.2
option OrderBound 4.4-1 5.3-6 6.2
option OutputLevel 4.1-1 4.2-1 5.3-1 5.3-4 6.2
option PcgsAutomorphisms 5.8-2 6.2
option pQuotient 4.2-1 5.3-4 6.2
option PqWorkspace 4.1-1 4.2-1 4.4-1 6.2
option Prime 4.1-1 4.2-1 5.3-1 5.3-4 6.2
option PrintAutomorphisms 6.2
option PrintPermutations 6.2
option QueueFactor 5.6-4 6.2
option RankInitialSegmentSubgroups 4.4-1 5.3-6 6.2
option RedoPcp 5.3-1 6.2
option RelativeOrders 6.2
option Relators 4.1-1 4.4-1 5.3-1 5.3-6 6.2
    example of usage 4.1-1
option SetupFile 4.1-1 4.2-1 4.4-1 6.2
option SpaceEfficient 4.4-1 5.3-6 6.2
option StandardPresentationFile 4.2-1 5.3-4 5.8-2 6.2
option StepSize 4.4-1 5.3-6 6.2
option SubList 4.4-1 5.3-6 6.2
option TreeDepth 6.2
orbits 2.3
p-class 2.1-2
p-cover 2.1-3
p-covering group 2.1-3
p-group generation 2.3
p-multiplicator 2.1-3
p-multiplicator rank 2.1-3
pc generators 2.1-1
pc presentation 2.1-1
pcp 2.1-1
permutations 2.1-4
power-commutator presentation 2.1-1
Pq 4.1-1
    interactive 5.3-1
    interactive, for default process 5.3-1
PqAddTails 5.7-7
    for default process 5.7-7
PqAPGDegree 5.10-1
    for default process 5.10-1
PqAPGOrbitRepresentatives 5.10-4
    for default process 5.10-4
PqAPGOrbits 5.10-3
    for default process 5.10-3
PqAPGPermutations 5.10-2
    for default process 5.10-2
PqAPGSingleStage 5.10-5
    for default process 5.10-5
PqApplyAutomorphisms 5.7-22
    for default process 5.7-22
PqCollect 5.7-1
    for default process 5.7-1
PqCollectDefiningRelations 5.7-9
    for default process 5.7-9
PqCollectWordInDefiningGenerators 5.7-10
    for default process 5.7-10
PqCommutator 5.7-3
    for default process 5.7-3
PqCommutatorDefiningGenerators 5.7-11
    for default process 5.7-11
PqCompact 5.7-18
    for default process 5.7-18
PqComputePCover 5.6-5
    for default process 5.6-5
PqComputeTails 5.7-6
    for default process 5.7-6
PqCurrentGroup 5.5-6
    for default process 5.5-6
PqDescendants 4.4-1
    interactive 5.3-6
    interactive, for default process 5.3-6
PqDescendantsTreeCoclassOne A.4-1
    for default process A.4-1
PqDisplayAutomorphisms 5.7-24
    for default process 5.7-24
PqDisplayPcPresentation 5.5-7
    for default process 5.5-7
PqDisplayStructure 5.7-23
    for default process 5.7-23
PqDoConsistencyCheck 5.7-17
    for default process 5.7-17
PqDoConsistencyChecks 5.7-8
    for default process 5.7-8
PqDoExponentChecks 5.7-12
    for default process 5.7-12
PqEchelonise 5.7-19
    for default process 5.7-19
PqEliminateRedundantGenerators 5.7-13
    for default process 5.7-13
PqEpimorphism 4.1-2
    interactive 5.3-2
    interactive, for default process 5.3-2
PqEvaluateIdentities 5.5-9
    for default process 5.5-9
PqExample 3.4-4
    no arguments 3.4-4
    with filename 3.4-4
PqExtendAutomorphisms 5.7-21
    for default process 5.7-21
PqFactoredOrder 5.5-2
    for default process 5.5-2
PqGAPRelators 3.4-2
PqJacobi 5.7-17
    for default process 5.7-17
PqLeftNormComm 3.4-1
PqList 4.4-3
PqNextClass 5.6-4
    for default process 5.6-4
PqNrPcGenerators 5.5-1
    for default process 5.5-1
PqOrder 5.5-3
    for default process 5.5-3
PqParseWord 3.4-3
PqPClass 5.5-4
    for default process 5.5-4
PqPCover 4.1-3
    interactive 5.3-3
    interactive, for default process 5.3-3
PqPcPresentation 5.6-1
    for default process 5.6-1
PqPGConstructDescendants 5.9-3
    for default process 5.9-3
PqPGExtendAutomorphisms 5.9-2
    for default process 5.9-2
PqPGRestoreDescendantFromFile 5.9-4
    for default process 5.9-4
    with class 5.9-4
    with class, for default process 5.9-4
PqPGSetDescendantToPcp 5.9-4
    for default process 5.9-4
    with class 5.9-4
    with class, for default process 5.9-4
PqPGSupplyAutomorphisms 5.9-1
    for default process 5.9-1
PqProcessIndex 5.2-1
    for default process 5.2-1
PqProcessIndices 5.2-2
PqQuit 5.1-2
    for default process 5.1-2
PqQuitAll 5.1-3
PqRead 5.11-1
    for default process 5.11-1
PqReadAll 5.11-2
    for default process 5.11-2
PqReadUntil 5.11-3
    for default process 5.11-3
    with modify map 5.11-3
    with modify map, for default process 5.11-3
PqRestorePcPresentation 5.6-3
    for default process 5.6-3
PqRevertToPreviousClass 5.7-14
    for default process 5.7-14
PqSavePcPresentation 5.6-2
    for default process 5.6-2
PqSetMaximalOccurrences 5.7-15
    for default process 5.7-15
PqSetMetabelian 5.7-16
    for default process 5.7-16
PqSetOutputLevel 5.5-8
    for default process 5.5-8
PqSetPQuotientToGroup 5.3-7
    for default process 5.3-7
PqSetupTablesForNextClass 5.7-4
    for default process 5.7-4
PqSolveEquation 5.7-2
    for default process 5.7-2
PqSPCompareTwoFilePresentations 5.8-4
    for default process 5.8-4
PqSPComputePcpAndPCover 5.8-1
    for default process 5.8-1
PqSPIsomorphism 5.8-5
    for default process 5.8-5
PqSPSavePresentation 5.8-3
    for default process 5.8-3
PqSPStandardPresentation 5.8-2
    for default process 5.8-2
PqStandardPresentation 4.2-1
    interactive 5.3-4
PqStart 5.1-1
    with group 5.1-1
    with group and workspace size 5.1-1
    with workspace size 5.1-1
PqSupplementInnerAutomorphisms 4.4-2
PqSupplyAutomorphisms 5.7-20
    for default process 5.7-20
PqTails 5.7-5
    for default process 5.7-5
PqWeight 5.5-5
    for default process 5.5-5
PqWrite 5.11-4
    for default process 5.11-4
PqWritePcPresentation 5.7-25
    for default process 5.7-25
SavePqList 4.4-4
standard presentation 2.3
StandardPresentation 4.2-1
    interactive 5.3-4
tails 2.2-1
terminal 2.1-4
ToPQLog 3.4-7
troubleshooting tips 3.6
weight function 2.1-2
weighted pcp 2.1-2

 [Top of Book]  [Contents]   [Previous Chapter] 
Goto Chapter: Top 1 2 3 4 5 6 7 A Bib Ind

generated by GAPDoc2HTML

anupq-3.3.3/doc/manual.js0000644000175100017510000001011315111342310014615 0ustar runnerrunner/* manual.js Frank Lübeck */ /* This file contains a few javascript functions which allow to switch between display styles for GAPDoc HTML manuals. If javascript is switched off in a browser or this file in not available in a manual directory, this is no problem. Users just cannot switch between several styles and don't see the corresponding button. A style with name mystyle can be added by providing two files (or only one of them). mystyle.js: Additional javascript code for the style, it is read in the HTML pages after this current file. The additional code may adjust the preprocessing function jscontent() with is called onload of a file. This is done by appending functions to jscontentfuncs (jscontentfuncs.push(newfunc);). Make sure, that your style is still usable without javascript. mystyle.css: CSS configuration, read after manual.css (so it can just reconfigure a few details, or overwrite everything). Then adjust chooser.html such that users can switch on and off mystyle. A user can change the preferred style permanently by using the [Style] link and choosing one. Or one can append '?GAPDocStyle=mystyle' to the URL when loading any file of the manual (so the style can be configured in the GAP user preferences). */ /* generic helper function */ function deleteCookie(nam) { document.cookie = nam+"=;Path=/;expires=Thu, 01 Jan 1970 00:00:00 GMT"; } /* read a value from a "nam1=val1;nam2=val2;..." string (e.g., the search part of an URL or a cookie */ function valueString(str,nam) { var cs = str.split(";"); for (var i=0; i < cs.length; i++) { var pos = cs[i].search(nam+"="); if (pos > -1) { pos = cs[i].indexOf("="); return cs[i].slice(pos+1); } } return 0; } /* when a non-default style is chosen via URL or a cookie, then the cookie is reset and the styles .js and .css files are read */ function overwriteStyle() { /* style in URL? */ var style = valueString(window.location.search, "GAPDocStyle"); /* otherwise check cookie */ if (style == 0) style = valueString(document.cookie, "GAPDocStyle"); if (style == 0) return; if (style == "default") deleteCookie("GAPDocStyle"); else { /* ok, we set the cookie for path "/" */ var path = "/"; /* or better like this ??? var here = window.location.pathname.split("/"); for (var i=0; i+3 < here.length; i++) path = path+"/"+here[i]; */ document.cookie = "GAPDocStyle="+style+";Path="+path; /* split into names of style files */ var stlist = style.split(","); /* read style's css and js files */ for (var i=0; i < stlist.length; i++) { document.writeln(''); document.writeln(''); } } } /* this adds a "[Style]" link next to the MathJax switcher */ function addStyleLink() { var line = document.getElementById("mathjaxlink"); var el = document.createElement("a"); var oncl = document.createAttribute("href"); var back = window.location.protocol+"//" if (window.location.protocol == "http:" || window.location.protocol == "https:") { back = back+window.location.host; if (window.location.port != "") { back = back+":"+window.location.port; } } back = back+window.location.pathname; oncl.nodeValue = "chooser.html?BACK="+back; el.setAttributeNode(oncl); var cont = document.createTextNode(" [Style]"); el.appendChild(cont); line.appendChild(el); } var jscontentfuncs = new Array(); jscontentfuncs.push(addStyleLink); /* the default jscontent() only adds the [Style] link to the page */ function jscontent () { for (var i=0; i < jscontentfuncs.length; i++) jscontentfuncs[i](); } anupq-3.3.3/doc/manual.css0000644000175100017510000001575415111342310015011 0ustar runnerrunner/* manual.css Frank Lübeck */ /* This is the default CSS style sheet for GAPDoc HTML manuals. */ /* basic settings, fonts, sizes, colors, ... */ body { position: relative; background: #ffffff; color: #000000; width: 70%; margin: 0pt; padding: 15pt; font-family: Helvetica,Verdana,Arial,sans-serif; text-align: justify; } /* no side toc on title page, bib and index */ body.chap0 { width: 95%; } body.chapBib { width: 95%; } body.chapInd { width: 95%; } h1 { font-size: 200%; } h2 { font-size: 160%; } h3 { font-size: 160%; } h4 { font-size: 130%; } h5 { font-size: 100%; } p.foot { font-size: 60%; font-style: normal; } a:link { color: #00008e; text-decoration: none; } a:visited { color: #00008e; text-decoration: none; } a:active { color: #000000; text-decoration: none; } a:hover { background: #eeeeee; } pre { font-family: "Courier New",Courier,monospace; font-size: 100%; color:#111111; } tt,code { font-family: "Courier New",Courier,monospace; font-size: 110%; color: #000000; } var { } /* general alignment classes */ .pcenter { text-align: center; } .pleft { text-align: left; } .pright { text-align: right; } /* layout for the definitions of functions, variables, ... */ div.func { background: #e0e0e0; margin: 0pt 0pt; } /* general and special table settings */ table { border-collapse: collapse; margin-left: auto; margin-right: auto; } td, th { border-style: none; } table.func { padding: 0pt 1ex; margin-left: 1ex; margin-right: 1ex; background: transparent; /* line-height: 1.1; */ width: 100%; } table.func td.tdright { padding-right: 2ex; } /* Example elements (for old converted manuals, now in div+pre */ table.example { background: #efefef; border-style: none; border-width: 0pt; padding: 0px; width: 100% } table.example td { border-style: none; border-width: 0pt; padding: 0ex 1ex; } /* becomes ... */ div.example { background: #efefef; padding: 0ex 1ex; /* overflow-x: auto; */ overflow: auto; } /* Links to chapters in all files at top and bottom. */ /* If there are too many chapters then use 'display: none' here. */ div.chlinktop { background: #dddddd; border-style: solid; border-width: thin; margin: 2px; text-align: center; } div.chlinktop a { margin: 3px; } div.chlinktop a:hover { background: #ffffff; } div.chlinkbot { background: #dddddd; border-style: solid; border-width: thin; margin: 2px; text-align: center; /* width: 100%; */ } div.chlinkbot a { margin: 3px; } span.chlink1 { } /* and this is for the "Top", "Prev", "Next" links */ div.chlinkprevnexttop { background: #dddddd; border-style: solid; border-width: thin; text-align: center; margin: 2px; } div.chlinkprevnexttop a:hover { background: #ffffff; } div.chlinkprevnextbot { background: #dddddd; border-style: solid; border-width: thin; text-align: center; margin: 2px; } div.chlinkprevnextbot a:hover { background: #ffffff; } /* table of contents, initially don't display subsections */ div.ContSSBlock { display: none; } div.ContSSBlock br { display: none; } /* format in separate lines */ span.tocline { display: block; width: 100%; } div.ContSSBlock a { display: block; } /* this is for the main table of contents */ div.ContChap { } div.ContChap div.ContSect:hover div.ContSSBlock { display: block; position: absolute; background: #eeeeee; border-style: solid; border-width: 1px 4px 4px 1px; border-color: #666666; padding-left: 0.5ex; color: #000000; left: 20%; width: 40%; z-index: 10000; } div.ContSSBlock a:hover { background: #ffffff; } /* and here for the side menu of contents in the chapter files */ div.ChapSects { } div.ChapSects a:hover { background: #eeeeee; } div.ChapSects a:hover { display: block; width: 100%; background: #eeeeee; color: #000000; } div.ChapSects div.ContSect:hover div.ContSSBlock { display: block; position: fixed; background: #eeeeee; border-style: solid; border-width: 1px 2px 2px 1px; border-color: #666666; padding-left: 0ex; padding-right: 0.5ex; color: #000000; left: 54%; width: 25%; z-index: 10000; } div.ChapSects div.ContSect:hover div.ContSSBlock a { display: block; margin-left: 3px; } div.ChapSects div.ContSect:hover div.ContSSBlock a:hover { display: block; background: #ffffff; } div.ContSect { text-align: left; margin-left: 1em; } div.ChapSects { position: fixed; left: 75%; font-size: 90%; overflow: auto; top: 10px; bottom: 0px; } /* Table elements */ table.GAPDocTable { border-collapse: collapse; border-style: none; border-color: black; } table.GAPDocTable td, table.GAPDocTable th { padding: 3pt; border-width: thin; border-style: solid; border-color: #555555; } caption.GAPDocTable { caption-side: bottom; width: 70%; margin-top: 1em; margin-left: auto; margin-right: auto; } td.tdleft { text-align: left; } table.GAPDocTablenoborder { border-collapse: collapse; border-style: none; border-color: black; } table.GAPDocTablenoborder td, table.GAPDocTable th { padding: 3pt; border-width: 0pt; border-style: solid; border-color: #555555; } caption.GAPDocTablenoborder { caption-side: bottom; width: 70%; margin-top: 1em; margin-left: auto; margin-right: auto; } td.tdleft { text-align: left; } td.tdright { text-align: right; } td.tdcenter { text-align: center; } /* Colors and fonts can be overwritten for some types of elements. */ /* Verb elements */ pre.normal { color: #000000; } /* Func-like elements and Ref to Func-like */ code.func { color: #000000; } /* K elements */ code.keyw { color: #770000; } /* F elements */ code.file { color: #8e4510; } /* C elements */ code.code { } /* Item elements */ code.i { } /* Button elements */ strong.button { } /* Headings */ span.Heading { } /* Arg elements */ var.Arg { color: #006600; } /* Example elements, is in tables, see above */ div.Example { } /* Package elements */ strong.pkg { } /* URL-like elements */ span.URL { } /* Mark elements */ strong.Mark { } /* Ref elements */ b.Ref { } span.Ref { } /* this contains the contents page */ div.contents { } /* this contains the index page */ div.index { } /* ignore some text for non-css layout */ span.nocss { display: none; } /* colors for ColorPrompt like examples */ span.GAPprompt { color: #000097; font-weight: normal; } span.GAPbrkprompt { color: #970000; font-weight: normal; } span.GAPinput { color: #970000; } /* Bib entries */ p.BibEntry { } span.BibKey { color: #005522; } span.BibKeyLink { } b.BibAuthor { } i.BibTitle { } i.BibBookTitle { } span.BibEditor { } span.BibJournal { } span.BibType { } span.BibPublisher { } span.BibSchool { } span.BibEdition { } span.BibVolume { } span.BibSeries { } span.BibNumber { } span.BibPages { } span.BibOrganization { } span.BibAddress { } span.BibYear { } span.BibPublisher { } span.BibNote { } span.BibHowpublished { } anupq-3.3.3/doc/non-interact.xml0000644000175100017510000010321415111342310016132 0ustar runnerrunner Non-interactive ANUPQ functions Here we describe all the non-interactive functions of the &ANUPQ; package; i.e. one-shot functions that invoke the pq program in such a way that once &GAP; has got what it needs, the pq program is allowed to exit. It is expected that most of the time users will only need these functions. The functions interface with three of the four algorithms (see Chapter ) provided by the ANU pq C program, and are mainly grouped according to the algorithm of the pq program they relate to.

In Section , we describe the functions that give access to the p-quotient algorithm.

Section  describe functions that give access to the standard presentation algorithm.

Section  describe functions that implement an isomorphism test for p-groups using the standard presentation algorithm.

In Section , we describe functions that give access to the p-group generation algorithm.

To use any of the functions one must have at some stage previously typed: LoadPackage("anupq"); ]]> (the response of which we have omitted; see ).

It is strongly recommended that the user try the examples provided. To save typing there is a PqExample equivalent for each manual example. We also suggest that to start with you may find the examples more instructive if you set the InfoANUPQ level to 2 (see ).

Computing p-Quotients returns for the fp or pc group F, the p-quotient of F specified by options, as a pc group. Following the colon, options is a selection of the options from the following list, separated by commas like record components (see Section  in the &GAP; Reference Manual). As a minimum the user must supply a value for the Prime option. Below we list the options recognised by Pq (see Chapter  for detailed descriptions). Prime := poption Prime ClassBound := noption ClassBound Exponent := noption Exponent Relators := relsoption Relators Metabelianoption Metabelian Identities := funcsoption Identities GroupName := nameoption GroupName OutputLevel := noption OutputLevel SetupFile := filenameoption SetupFile PqWorkspace := workspaceoption PqWorkspace Notes: Pq may also be called with no arguments or one integer argument, in which case it is being used interactively (see ); the same options may be used, except that SetupFile and PqWorkspace are ignored by the interactive Pq function.

See Section  for the attributes and property NuclearRank, MultiplicatorRank and IsCapable which may be applied to the group returned by Pq.

See also PqEpimorphism ().

We now give a few examples of the use of Pq. Except for the addition of a few comments and the non-suppression of output (by not using duplicated semicolons) the next 3 examples may be run by typing: PqExample( "Pq" ); (see ). LoadPackage("anupq");; # does nothing if ANUPQ is already loaded gap> # First we get a p-quotient of a free group of rank 2 gap> F := FreeGroup("a", "b");; a := F.1;; b := F.2;; gap> Pq( F : Prime := 2, ClassBound := 3 ); gap> # Now let us get a p-quotient of an fp group gap> G := F / [a^4, b^4]; gap> Pq( G : Prime := 2, ClassBound := 3 ); gap> # Now let's get a different p-quotient of the same group gap> Pq( G : Prime := 2, ClassBound := 3, Exponent := 4 ); gap> # Now we'll get a p-quotient of another fp group gap> # which we will redo using the `Relators' option gap> R := [ a^25, Comm(Comm(b, a), a), b^5 ]; [ a^25, a^-1*b^-1*a*b*a^-1*b^-1*a^-1*b*a^2, b^5 ] gap> H := F / R; gap> Pq( H : Prime := 5, ClassBound := 5, Metabelian ); ]]> option Relators Now we redo the last example to show how one may use the Relators option. Observe that Comm(Comm(b, a), a) is a left normed commutator which must be written in square bracket notation for the pq program and embedded in a pair of double quotes. The function PqGAPRelators (see ) can be used to translate a list of strings prepared for the Relators option into &GAP; format. Below we use it. Observe that the value of R is the same as before. F := FreeGroup("a", "b");; gap> # `F' was defined for `Relators'. We use the same strings that GAP uses gap> # for printing the free group generators. It is *not* necessary to gap> # predefine: a := F.1; etc. (as it was above). gap> rels := [ "a^25", "[b, a, a]", "b^5" ]; [ "a^25", "[b, a, a]", "b^5" ] gap> R := PqGAPRelators(F, rels); [ a^25, a^-1*b^-1*a*b*a^-1*b^-1*a^-1*b*a^2, b^5 ] gap> H := F / R; gap> Pq( H : Prime := 5, ClassBound := 5, Metabelian, > Relators := rels ); ]]> In fact, above we could have just passed F (rather than H), i.e. we could have done: F := FreeGroup("a", "b");; gap> rels := [ "a^25", "[b, a, a]", "b^5" ]; [ "a^25", "[b, a, a]", "b^5" ] gap> Pq( F : Prime := 5, ClassBound := 5, Metabelian, > Relators := rels ); ]]> The non-interactive Pq function also allows the options to be passed in two other ways; these alternatives have been included for those familiar with the &GAP; 3 version of the &ANUPQ; package; the preferred method of passing options is the one already described. Firstly, they may be passed in a record as a second argument; note that any boolean options must be set explicitly e.g. Pq( H, rec( Prime := 5, ClassBound := 5, Metabelian := true ) ); ]]> It is also possible to pass them as extra arguments, where each option name appears as a string followed immediately by its value (if not a boolean option) e.g. Pq( H, "Prime", 5, "ClassBound", 5, "Metabelian" ); ]]> The preceding two examples can be run from &GAP; via PqExample( "Pq-ni" ); (see ).

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

option Identities The following example illustrates the use of the option Identities. We compute the largest finite Burnside group of exponent 5 that also satisfies the 3-Engel identity. Each identity is defined by a function whose arguments correspond to the variables of the identity. The return value of each of those functions is the identity evaluated on the arguments of the function. F := FreeGroup(2); gap> Burnside5 := x->x^5; function( x ) ... end gap> Engel3 := function( x,y ) return PqLeftNormComm( [x,y,y,y] ); end; function( x, y ) ... end gap> Pq( F : Prime := 5, Identities := [ Burnside5, Engel3 ] ); #I Class 1 with 2 generators. #I Class 2 with 3 generators. #I Class 3 with 5 generators. #I Class 3 with 5 generators. ]]> The above example can be run from &GAP; via PqExample( "B5-5-Engel3-Id" ); (see ). returns for the fp or pc group F an epimorphism from F onto the p-quotient of F specified by options; the possible options options and required option ("Prime") are as for Pq (see ). PqEpimorphism only differs from Pq in what it outputs; everything about what must/may be passed as input to PqEpimorphism is the same as for Pq. The same alternative methods of passing options to the non-interactive Pq function are available to the non-interactive version of PqEpimorphism.

Notes: PqEpimorphism may also be called with no arguments or one integer argument, in which case it is being used interactively (see ), and the options SetupFile and PqWorkspace are ignored by the interactive PqEpimorphism function.

See Section  for the attributes and property NuclearRank, MultiplicatorRank and IsCapable which may be applied to the image group of the epimorphism returned by PqEpimorphism. F := FreeGroup (2, "F"); gap> phi := PqEpimorphism( F : Prime := 5, ClassBound := 2 ); [ F1, F2 ] -> [ f1, f2 ] gap> Image( phi ); ]]> Typing: PqExample( "PqEpimorphism" ); runs the above example in &GAP; (see ). returns for the fp or pc group F, the p-covering group of the p-quotient of F specified by options, as a pc group, i.e. the p-covering group of the p-quotient Pq( F : options ). Thus the options that PqPCover accepts are exactly those expected for Pq (and hence as a minimum the user must supply a value for the Prime option; see  for more details), except in the following special case.

If F is already a p-group, in the sense that IsPGroup(F) is true, then Prime defaults to PrimePGroup(F), if not supplied and HasPrimePGroup(F) = true; and ClassBound defaults to PClassPGroup(F) if HasPClassPGroup(F) = true if not supplied, or to the usual default of 63, otherwise. The same alternative methods of passing options to the non-interactive Pq function are available to the non-interactive version of PqPCover.

We now give a few examples of the use of PqPCover. These examples are just a subset of the ones we gave for Pq (see ), except that in each instance the command Pq has been replaced with PqPCover. Essentially the same examples may be run by typing: PqExample( "PqPCover" ); (see ). F := FreeGroup("a", "b");; a := F.1;; b := F.2;; gap> PqPCover( F : Prime := 2, ClassBound := 3 ); gap> gap> # Now let's get a p-cover of a p-quotient of an fp group gap> G := F / [a^4, b^4]; gap> PqPCover( G : Prime := 2, ClassBound := 3 ); gap> gap> # Now let's get a p-cover of a different p-quotient of the same group gap> PqPCover( G : Prime := 2, ClassBound := 3, Exponent := 4 ); gap> gap> # Now we'll get a p-cover of a p-quotient of another fp group gap> # which we will redo using the `Relators' option gap> R := [ a^25, Comm(Comm(b, a), a), b^5 ]; [ a^25, a^-1*b^-1*a*b*a^-1*b^-1*a^-1*b*a^2, b^5 ] gap> H := F / R; gap> PqPCover( H : Prime := 5, ClassBound := 5, Metabelian ); gap> gap> # Now we redo the previous example using the `Relators' option gap> F := FreeGroup("a", "b");; gap> rels := [ "a^25", "[b, a, a]", "b^5" ]; [ "a^25", "[b, a, a]", "b^5" ] gap> PqPCover( F : Prime := 5, ClassBound := 5, Metabelian, > Relators := rels ); ]]>

Computing Standard Presentations automorphismsof p-groups return the p-quotient specified by options of the fp or pc p-group F, as an fp group which has a standard presentation. Here options is a selection of the options from the following list (see Chapter  for detailed descriptions). Section  gives some important hints and warnings regarding option usage, and Section  in the &GAP; Reference Manual describes their record-like syntax. Prime := poption Prime pQuotient := Qoption pQuotient ClassBound := noption ClassBound Exponent := noption Exponent Metabelianoption Metabelian GroupName := nameoption GroupName OutputLevel := noption OutputLevel StandardPresentationFile := filenameoption StandardPresentationFile SetupFile := filenameoption SetupFile PqWorkspace := workspaceoption PqWorkspace Unless F is a pc p-group, the user must supply either the option Prime or the option pQuotient (if both Prime and pQuotient are supplied, the prime p is determined by applying PrimePGroup (see  in the Reference Manual) to the value of pQuotient).

The options for PqStandardPresentation may also be passed in the two other alternative ways described for Pq (see ). StandardPresentation does not provide these alternative ways of passing options.

Notes: In contrast to the function Pq (see ) which returns a pc group, PqStandardPresentation or StandardPresentation returns an fp group. This is because the output is mainly used for isomorphism testing for which an fp group is enough. However, the presentation is a polycyclic presentation and if you need to do any further computation with this group (e.g. to find the order) you can use the function PcGroupFpGroup (see  in the &GAP; Reference Manual) to form a pc group.

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

The attributes and property NuclearRank, MultiplicatorRank and IsCapable are set for the group returned by PqStandardPresentation or StandardPresentation (see Section ).

We illustrate the method with the following examples. F := FreeGroup( "a", "b" );; a := F.1;; b := F.2;; gap> G := F / [a^25, Comm(Comm(b, a), a), b^5]; gap> S := StandardPresentation( G : Prime := 5, ClassBound := 10 ); gap> IsPcGroup( S ); false gap> # if we need to compute with S we should convert it to a pc group gap> Spc := PcGroupFpGroup( S ); gap> gap> H := F / [ a^625, Comm(Comm(Comm(Comm(b, a), a), a), a)/Comm(b, a)^5, > Comm(Comm(b, a), b), b^625 ];; gap> StandardPresentation( H : Prime := 5, ClassBound := 15, Metabelian ); gap> gap> F4 := FreeGroup( "a", "b", "c", "d" );; gap> a := F4.1;; b := F4.2;; c := F4.3;; d := F4.4;; gap> G4 := F4 / [ b^4, b^2 / Comm(Comm (b, a), a), d^16, > a^16 / (c * d), b^8 / (d * c^4) ]; gap> K := Pq( G4 : Prime := 2, ClassBound := 1 ); gap> StandardPresentation( G4 : pQuotient := K, ClassBound := 14 ); ]]> Typing: PqExample( "StandardPresentation" ); runs the above example in &GAP; (see ). Each of the above functions accepts the same arguments and options as the function StandardPresentation (see ) and returns an epimorphism from the fp or pc group F onto the finitely presented group given by a standard presentation, i.e. if S is the standard presentation computed for the p-quotient of F by StandardPresentation then EpimorphismStandardPresentation returns the epimorphism from F to the group with presentation S.

Note: The attributes and property NuclearRank, MultiplicatorRank and IsCapable are set for the image group of the epimorphism returned by EpimorphismPqStandardPresentation or EpimorphismStandardPresentation (see Section ).

We illustrate the function with the following example. F := FreeGroup(6, "F"); gap> # For printing GAP uses the symbols F1, ... for the generators of F gap> x := F.1;; y := F.2;; z := F.3;; w := F.4;; a := F.5;; b := F.6;; gap> R := [x^3 / w, y^3 / w * a^2 * b^2, w^3 / b, > Comm (y, x) / z, Comm (z, x), Comm (z, y) / a, z^3 ];; gap> Q := F / R; gap> # For printing GAP also uses the symbols F1, ... for the generators of Q gap> # (the same as used for F) ... but the gen'rs of Q and F are different: gap> GeneratorsOfGroup(F) = GeneratorsOfGroup(Q); false gap> G := Pq( Q : Prime := 3, ClassBound := 3 ); gap> phi := EpimorphismStandardPresentation( Q : Prime := 3, > ClassBound := 3 ); [ F1, F2, F3, F4, F5, F6 ] -> [ f1*f2^2*f3*f4^2*f5^2, f1*f2*f3*f5, f3^2, f4*f6^2, f5, f6 ] gap> Source(phi); # This is the group Q (GAP uses F1, ... for gen'r symbols) gap> Range(phi); # This is the group G (GAP uses f1, ... for gen'r symbols) gap> AssignGeneratorVariables(G); #I Assigned the global variables [ f1, f2, f3, f4, f5, f6 ] gap> # Just to see that the images of [F1, ..., F6] do generate G gap> Group([ f1*f2^2*f3, f1*f2*f3*f4*f5^2*f6^2, f3^2, f4, f5, f6 ]) = G; true gap> Size( Image(phi) ); 729 ]]> Typing: PqExample( "EpimorphismStandardPresentation" ); runs the above example in &GAP; (see ). Note that AssignGeneratorVariables (see ) has only been available since &GAP; 4.3.

Testing p-Groups for Isomorphism each return true if G is isomorphic to H, where both G and H must be pc groups of prime power order. These functions compute and compare in &GAP; the fp groups given by standard presentations for G and H (see ). G := Group( (1,2,3,4), (1,3) ); Group([ (1,2,3,4), (1,3) ]) gap> P1 := Image( IsomorphismPcGroup( G ) ); Group([ f1, f2, f3 ]) gap> P2 := ElementaryAbelianGroup( 8 ); gap> IsIsomorphicPGroup( P1, P2 ); false gap> P3 := QuaternionGroup( 8 ); gap> IsIsomorphicPGroup( P1, P3 ); false gap> P4 := DihedralGroup( 8 ); gap> IsIsomorphicPGroup( P1, P4 ); true ]]> Typing: PqExample( "IsIsomorphicPGroup" ); runs the above example in &GAP; (see ).
Computing Descendants of a p-Group returns, for the pc group G which must be of prime power order with a confluent pc presentation (see  in the &GAP; Reference Manual), a list of proper descendants (pc groups) of G. Following the colon options a selection of the options listed below should be given, separated by commas like record components (see Section  in the &GAP; Reference Manual). See Chapter  for detailed descriptions of the options.

The automorphism group of each descendant D is also computed via a call to the AutomorphismGroupPGroup function of the &AutPGrp; package. ClassBound := noption ClassBound Relators := relsoption Relators OrderBound := noption OrderBound StepSize := n, StepSize := list option StepSize RankInitialSegmentSubgroups := noption RankInitialSegmentSubgroups SpaceEfficientoption SpaceEfficient CapableDescendantsoption CapableDescendants AllDescendants := falseoption AllDescendants Exponent := noption Exponent Metabelianoption Metabelian GroupName := nameoption GroupName SubList := suboption SubList BasicAlgorithmoption BasicAlgorithm CustomiseOutput := recoption CustomiseOutput SetupFile := filenameoption SetupFile PqWorkspace := workspaceoption PqWorkspace Notes: The function PqDescendants uses the automorphism group of G which it computes via the package &AutPGrp;. If this package is not installed an error may be raised. If the automorphism group of G is insoluble, the pq program will call &GAP; together with the &AutPGrp; package for certain orbit-stabilizer calculations. (So, in any case, one should ensure the &AutPGrp; package is installed.)

The attributes and property NuclearRank, MultiplicatorRank and IsCapable are set for each group of the list returned by PqDescendants (see Section ).

The options options for PqDescendants may be passed in an alternative manner to that already described, namely you can pass PqDescendants a record as an argument, which contains as entries some (or all) of the above mentioned. Those parameters which do not occur in the record are set to their default values.

Note that you cannot set both OrderBound and StepSize.

In the first example we compute all proper descendants of the Klein four group which have exponent-2 class at most 5 and order at most 2^6. F := FreeGroup( "a", "b" );; a := F.1;; b := F.2;; gap> G := PcGroupFpGroup( F / [ a^2, b^2, Comm(b, a) ] ); gap> des := PqDescendants( G : OrderBound := 6, ClassBound := 5 );; gap> Length(des); 83 gap> List(des, Size); [ 8, 8, 8, 16, 16, 16, 32, 16, 16, 16, 16, 16, 32, 32, 64, 64, 32, 32, 32, 32, 32, 32, 32, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 32, 32, 32, 32, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 32, 32, 32, 32, 32, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64 ] gap> List(des, d -> Length( PCentralSeries( d, 2 ) ) - 1 ); [ 2, 2, 2, 2, 2, 2, 2, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 5, 5, 5, 5, 5 ] ]]> Below, we compute all capable descendants of order 27 of the elementary abelian group of order 9. F := FreeGroup( 2, "g" ); gap> G := PcGroupFpGroup( F / [ F.1^3, F.2^3, Comm(F.1, F.2) ] ); gap> des := PqDescendants( G : OrderBound := 3, ClassBound := 2, > CapableDescendants ); [ , ] gap> List(des, d -> Length( PCentralSeries( d, 3 ) ) - 1 ); [ 2, 2 ] gap> # For comparison let us now compute all proper descendants gap> PqDescendants( G : OrderBound := 3, ClassBound := 2); [ , , ] ]]> In the third example, we compute all proper capable descendants of the elementary abelian group of order 5^2 which have exponent-5 class at most 3, exponent 5, and are metabelian. F := FreeGroup( 2, "g" );; gap> G := PcGroupFpGroup( F / [ F.1^5, F.2^5, Comm(F.2, F.1) ] ); gap> des := PqDescendants( G : Metabelian, ClassBound := 3, > Exponent := 5, CapableDescendants ); [ , , ] gap> List(des, d -> Length( PCentralSeries( d, 5 ) ) - 1 ); [ 2, 3, 3 ] gap> List(des, d -> Length( DerivedSeries( d ) ) ); [ 3, 3, 3 ] gap> List(des, d -> Maximum( List( d, Order ) ) ); [ 5, 5, 5 ] ]]> The examples "PqDescendants-1", "PqDescendants-2" and "PqDescendants-3" (in order) are essentially the same as the above three examples (see ). returns a generating set for a supplement to the inner automorphisms of D, in the form of a record with fields agAutos, agOrder and glAutos, as provided by the pq program. One should be very careful in using these automorphisms for a descendant calculation.

Note: In principle there must be a way to use those automorphisms in order to compute descendants but there does not seem to be a way to hand back these automorphisms properly to the pq program. Q := Pq( FreeGroup(2) : Prime := 3, ClassBound := 1 ); gap> des := PqDescendants( Q : StepSize := 1 ); [ , , ] gap> S := PqSupplementInnerAutomorphisms( des[3] ); rec( agAutos := [ ], agOrder := [ 3, 2, 2, 2 ], glAutos := [ Pcgs([ f1, f2, f3 ]) -> [ f1*f2^2, f2, f3 ], Pcgs([ f1, f2, f3 ]) -> [ f1^2, f2, f3^2 ], Pcgs([ f1, f2, f3 ]) -> [ f1^2, f2, f3^2 ] ] ) gap> A := AutomorphismGroupPGroup( des[3] ); rec( agAutos := [ Pcgs([ f1, f2, f3 ]) -> [ f1^2, f2, f3^2 ], Pcgs([ f1, f2, f3 ]) -> [ f1*f2^2, f2, f3 ], Pcgs([ f1, f2, f3 ]) -> [ f1*f3, f2, f3 ], Pcgs([ f1, f2, f3 ]) -> [ f1, f2*f3, f3 ] ], agOrder := [ 2, 3, 3, 3 ], glAutos := [ ], glOper := [ ], glOrder := 1, group := , one := IdentityMapping( ), size := 54 ) ]]> Typing: PqExample( "PqSupplementInnerAutomorphisms" ); runs the above example in &GAP; (see ).

Note that by also including PqStart as a second argument to PqExample one can see how it is possible, with the aid of PqSetPQuotientToGroup (see ), to do the equivalent computations with the interactive versions of Pq and PqDescendants and a single pq process (recall pq is the name of the external C program). reads a file with name filename (a string) and returns the list L of pc groups (or with option SubList a sublist of L or a single pc group in L) defined in that file. If the option SubList is passed and has the value sub, then it has the same meaning as for PqDescendants, i.e. if sub is an integer then PqList returns L[sub]; otherwise, if sub is a list of integers PqList returns Sublist(L, sub ).

Both PqList and SavePqList (see ) can be used to save and restore a list of descendants (see ). writes a list of descendants list to a file with name filename (a string).

SavePqList and PqList (see ) can be used to save and restore, respectively, the results of PqDescendants (see ).

anupq-3.3.3/doc/chap2.txt0000644000175100017510000004501515111342310014551 0ustar runnerrunner 2 Mathematical Background and Terminology In this chapter we will give a brief description of the mathematical notions used in the algorithms implemented in the ANU pq program that are made accessible from GAP through this package. For proofs and details we will point to relevant places in the published literature. Also we will try to give some explanation of terminology that may help to use the low-level interactive functions described in Section 'Low-level Interactive ANUPQ functions based on menu items of the pq program'. However, users who intend to use these functions are strongly advised to acquire a thorough understanding of the algorithms from the quoted literature. There is little or no checking done in these functions and naive use may result in incorrect results. 2.1 Basic notions Throughout this manual, by p-group we always mean finite p-group. 2.1-1 pc Presentations and Consistency For details, see e.g. [NNN98]. Every finite p-group G has a presentation of the form: \{a_1,\dots,a_n \mid a_i^p = v_{ii}, 1 \le i \le n, [a_k, a_j] = v_{jk}, 1 \le j < k \le n \}.  where v_jk is a word in the elements a_k+1,dots,a_n for 1 ≤ j ≤ k ≤ n. This is called a power-commutator presentation (or pc presentation or pcp) of G, generators from such a presentation will be referred to as pc generators. In terms of such pc generators every element of G can be written in a normal form a_1^e_1dots a_n^e_n with 0 ≤ e_i < p. Moreover any given product of the generators can be brought into such a normal form using the defining relations in the above presentation as rewrite rules. Any such process is called collection. For the discussion of various collection methods see [LS90] and [Vau90b]. Every p-group of order p^n has such a pcp on n generators and conversely every such presentation defines a p-group. However a p-group defined by a pcp on n generators can be of smaller order p^m with m d one relation, having this generator as its right hand side, is marked as definition of this generator. As described in [NNN98], a weighted labelled pcp of a p-group can be obtained stepping down its p-central series. So let us assume that a weighted labelled pcp of G_i is given. A straightforward way of of writing down a (not necessarily consistent) pcp for its p-cover is to add generators, one for each relation which is not a definition, and modify the right hand side of each such relation by multiplying it on the right by one of the new generators -- a different generator for each such relation. Further relations are then added to make the new generators central and of order p. This procedure is called adding tails. A more formal description of it is again given in [NNN98]. It is important to realise that the new generators will generate an elementary abelian group, that is, in additive notation, a vector space over the field of p elements. As said, the pcp of the p-cover obtained in this way need not be consistent. Since the pcp of G_i was consistent, applying the consistency conditions to the pcp of the p-cover, in case the presentation obtained for p-cover is not consistent, will produce a set of equations between the new generators, that, written additively, are linear equations over the field of p elements and can hence be used to remove redundant generators until a consistent pcp is obtained. In reality, to follow this straightforward procedure would be forbiddingly inefficient except for very small examples. There are many ways of a priori reducing the number of new generators to be introduced, using e.g. the weights attached to the generators, and the main part of [NNN98] is devoted to a detailed discussion with proofs of these possibilities. 2.2-2 Imposing the Relations of the fp Group In order to obtain G/P_i+1(G) from the pcp of the p-cover of G_i = G/P_i(G), the defining relations from the original presentation of G must be imposed. Since G_i is a homomorphic image of G, these relations again yield relations between the new generators in the presentation of the p-cover of G_i. 2.2-3 Imposing Laws While we have so far only considered the computation of the factor groups of a given fp group by the groups of its descending p-central series, the p-quotient algorithm allows a very important variant of this idea: laws can be prescribed that should be fulfilled by the p-factor groups computed by the algorithm. The key observation here is the fact that at each step down the descending p-central series it suffices to impose these laws only for a finite number of words. Again for efficiency of the method it is crucial to keep the number of such words small, and much of [NO96] and the literature quoted in this paper is devoted to this problem. In this form, starting with a free group and imposing an exponent law (also referred to as an exponent check) the pq program has, in fact, found its most noted application in the determination of (restricted) Burnside groups (as reported in e.g. [HN80], [NO96] and [Vau90a]). Via a GAP program using the local interactive functions of the pq program made available through this interface also arbitrary laws can be imposed via the option Identities (see 6.2). 2.3 The p-group generation Algorithm, Standard Presentation, Isomorphism Testing For details, see [New77] and [O'B90]. The p-group generation algorithm determines the immediate descendants of a given p-group G up to isomorphism. From what has been explained in Section 'Basic notions', it is clear that this amounts to the construction of the p-cover, the extension of the automorphisms of G to the p-cover and the determination of representatives of the orbits of the action of these automorphisms on the set of supplements of the nucleus in the p-multiplicator. The main practical problem here is the determination of these representatives. [O'B90] describes methods for this and the pq program allows choices according to whether space or time limitations must be met. As well as the descendants of G, the pq program determines their automorphism groups from that of G (see [O'B95]), which is important for an iteration of the process; this has been used by Eamonn O'Brien, e.g. in the classification of the 2-groups that are now also part of the Small Groups library available through GAP. A variant of the p-group generation algorithm is also used to define a standard presentation of a given p-group. This is done by constructing an isomorphic copy of the given group through a chain of descendants and at each step making a choice of a particular representative for the respective orbit of capable groups. In a fairly delicate process, subgroups of the p-multiplicator are represented by echelonised matrices and a first among the labels for standard matrices is chosen (this is described in detail in [O'B94]). Finally, the standard presentation provides a way of testing if two given p-groups are isomorphic: the standard presentations of the groups are computed, for practical purposes compacted and the results compared for being identical, i.e. the groups are isomorphic if and only if their standard presentations are identical. anupq-3.3.3/doc/chap1.html0000644000175100017510000002617715111342310014705 0ustar runnerrunner GAP (ANUPQ) - Chapter 1: Introduction
Goto Chapter: Top 1 2 3 4 5 6 7 A Bib Ind
 [Top of Book]  [Contents]   [Previous Chapter]   [Next Chapter] 

1 Introduction
 1.1 Overview
 1.2 How to read this manual
 1.3 Authors and Acknowledgements

1 Introduction

1.1 Overview

The GAP 4 package ANUPQ provides an interface to the ANU pq C program written by Eamonn O'Brien, making the functionality of the C program available to GAP. Henceforth, we shall refer to the ANUPQ package when referring to the GAP interface, and to the ANU pq program or just pq when referring to that C program.

The pq program consists of implementations of the following algorithms:

  1. A p-quotient algorithm to compute pc-presentations for p-factor groups of finitely presented groups.

  2. A p-group generation algorithm to generate pc presentations of groups of prime power order.

  3. A standard presentation algorithm used to compute a canonical pc-presentation of a p-group.

  4. An algorithm which can be used to compute the automorphism group of a p-group.

    This part of the pq program is not accessible through the ANUPQ package. Instead, users are advised to consider the GAP 4 package AutPGrp by Bettina Eick and Eamonn O'Brien, which implements a better algorithm in GAP for the computation of automorphism groups of p-groups.

The current version of the ANUPQ package requires GAP 4.5, and version 1.5 of the AutPGrp package. All code that made the package compatible with earlier versions of GAP has been removed. If you must use an older GAP version and cannot upgrade, then you may try using an older ANUPQ version. However, you should not use versions of the ANUPQ package older than 2.2, since they are known to have bugs.

1.2 How to read this manual

It is not expected that readers of this manual will read it in a linear fashion from cover to cover; some sections contain material that is far too technical to be absorbed on a first reading.

Firstly, installers of the ANUPQ package will need to read Chapter Installing the ANUPQ Package, if they have not already gleaned these details from the README file.

Once the ANUPQ package is installed, users of the ANUPQ package will benefit most by first reading Chapter Mathematical Background and Terminology, which gives a brief description of the background and terminology used (this chapter also cites a number of references for further reading), and the introduction of Chapter Infrastructure (skip the remainder of the chapter on a first reading).

Then the user/reader should pursue Chapter Non-interactive ANUPQ functions in detail, delving into Chapter ANUPQ Options as necessary for the options of the functions that are described. The user will become best acquainted with the ANUPQ package by trying the examples. This chapter describes the non-interactive functions of the ANUPQ package, i.e. one-shot functions that invoke the pq program in such a way that once GAP has got what it needs, the pq is allowed to exit. It is expected that most of the time, users will only need these functions.

Advanced users will want to explore Chapter Interactive ANUPQ functions which describes all the interactive functions of the ANUPQ package; these are functions that extract information via a dialogue with a running pq process. Occasionally, a user needs the next step; the functions provided in this chapter make use of data from previous steps retained by the pq program, thus allowing the user to interact with the pq program like one can when one uses the pq program as a stand-alone (see guide.dvi in the standalone-doc directory).

After having read Chapters Non-interactive ANUPQ functions and Interactive ANUPQ functions, cross-references will have taken the reader into Chapter ANUPQ Options; by this stage, the reader need only read the introduction of Chapter ANUPQ Options.

After the reader has developed some facility with the ANUPQ package, she should explore the examples described in Appendix Examples.

If you run into trouble using the ANUPQ functions, some troubleshooting hints are given in Section Hints and Warnings regarding the use of Options. If the troubleshooting hints don't help, Section Authors and Acknowledgements below, gives contact details for the authors of the components of the ANUPQ package.

1.3 Authors and Acknowledgements

The C implementation of the ANU pq standalone was developed by Eamonn O'Brien.

An interactive interface using iostreams was developed with the assistance of Werner Nickel by Greg Gamble.

The GAP 4 version of this package was adapted from the GAP 3 version by Werner Nickel.

A new co-maintainer, Max Horn, joined the team in November, 2011.

The authors would like to thank Joachim Neubüser for his careful proof-reading and advice, and for formulating Chapter Mathematical Background and Terminology.

We would also like to thank Bettina Eick who by her testing and provision of examples helped us to eliminate a number of bugs and who provided a number of valuable suggestions for extensions of the package beyond the GAP 3 capabilities.

If you find a bug, the last section of ANUPQ's README describes the information we need and where to send us a bug report; please take the time to read this (i.e. help us to help you).

 [Top of Book]  [Contents]   [Previous Chapter]   [Next Chapter] 
Goto Chapter: Top 1 2 3 4 5 6 7 A Bib Ind

generated by GAPDoc2HTML

anupq-3.3.3/doc/chap7.txt0000644000175100017510000002720415111342310014556 0ustar runnerrunner 7 Installing the ANUPQ Package The ANU pq program is written in C and the package can be installed under UNIX and in environments similar to UNIX. In particular it is known to work on Linux and Mac OS X, and also on Windows equipped with cygwin. The current version of the ANUPQ package requires GAP 4.9, and version 1.2 of the AutPGrp package. However, we recommend using at least GAP 4.6 and AutPGrp 1.5. To install the ANUPQ package, move the file anupq-XXX.tar.gz for some version number XXX into the pkg directory in which you plan to install ANUPQ. Usually, this will be the directory pkg in the hierarchy of your version of GAP; it is however also possible to keep an additional pkg directory in your private directories. The only essential difference with installing ANUPQ in a pkg directory different to the GAP home directory is that one must start GAP with the -l switch (see Section Reference: Command Line Options), e.g. if your private pkg directory is a subdirectory of mygap in your home directory you might type:  gap -l ";myhomedir/mygap"  where myhomedir is the path to your home directory, which may be replaced by a tilde. The empty path before the semicolon is filled in by the default path of the GAP home directory. Then, in your chosen pkg directory, unpack anupq-XXX.tar.gz by  tar xf anupq-.tar.gz  Change to the newly created anupq directory. Now you need to call configure. If you installed ANUPQ into the main pkg directory, call  ./configure  If you installed ANUPQ in another directory than the usual 'pkg' subdirectory, instead call  ./configure --with-gaproot=  where path is the path to the GAP home directory. (You can also call  ./configure --help  for further options.) What this does is look for a file sysinfo.gap in the root directory of GAP in order to determine an architecture name for the subdirectory of bin in which to put the compiled pq binary. This only makes sense if GAP was compiled for the same architecture that pq will be. If you have a shared file system mounted across different architectures, then you should run configure and make for ANUPQ for each architecture immediately after compiling GAP on the same architecture. If you had to install the package in your own directory but wish to use the system GAP then you will need to find out what path is. To do this, start up GAP and find out what GAP's root path is from finding the value of the variable GAPInfo.RootPaths, e.g.  Example  gap> GAPInfo.RootPaths; [ "/usr/local/lib/gap4r4/" ]  would tell you to use /usr/local/lib/gap4r4 for path. The configure command will fetch the architecture type for which GAP has been compiled last and create a Makefile. You can now simply call  make  to compile the binary and to install it in the appropriate place. The path of GAP (see Note below) used by the pq binary (the value GAP is set to in the make command) may be over-ridden by setting the environment variable ANUPQ_GAP_EXEC. These values are only of interest when the pq program is run as a standalone; however, the testPq script assumes you have set one of these correctly (see Section 'Testing your ANUPQ installation'). When the pq program is started from GAP communication occurs via an iostream, so that the pq binary does not actually need to know a valid path for GAP is this case. Note. By path of GAP we mean the path of the command used to invoke GAP (which should be a script, e.g. the gap.sh script generated in the bin directory for the version of GAP when GAP was compiled). The usual strategy is to copy the gap.sh script to a standard location, e.g. /usr/local/bin/gap. It is a mistake to copy the GAP executable gap (in a directory with name of form bin/compile-platform) to the standard location, since direct invocation of the executable results in GAP starting without being able to find its own library (a fatal error). 7.1 Testing your ANUPQ installation Now it is time to test the installation. After doing configure and make you will have a testPq script. The script assumes that, if the environment variable ANUPQ_GAP_EXEC is set, it is a correct path for GAP, or otherwise that the make call that compiled the pq program set GAP to a correct path for GAP (see Section 'Running the pq program as a standalone' for more details). To run the tests, just type:  ./testPq  Some of the tests the script runs take a while. Please be patient. The script checks that you not only have a correct GAP (at least version 4.4) installation that includes the AutPGrp package, but that the ANUPQ package and its pq binary interact correctly. You should see something like the following output:  Example  Made dir: /tmp/testPq Testing installation of ANUPQ Package (version 3.1)   The first two tests check that the pq C program compiled ok. Testing the pq binary ... OK. Testing the pq binary's stack size ... OK. The pq C program compiled ok! We test it's the right one below.   The next tests check that you have the right version of GAP for the ANUPQ package and that GAP is finding the right versions of the ANUPQ and AutPGrp packages.   Checking GAP ...  pq binary made with GAP set to: /usr/local/bin/gap  Starting GAP to determine version and package availability ...  GAP version (4.6.5) ... OK.  GAP found ANUPQ package (version 3.1) ... good.  GAP found pq binary (version 1.9) ... good.  GAP found AutPGrp package (version 1.5) ... good.  GAP is OK.   Checking the link between the pq binary and GAP ... OK. Testing the standard presentation part of the pq binary ... OK. Doing p-group generation (final GAP/ANUPQ) test ... OK. Tests complete. Removed dir: /tmp/testPq Enjoy using your functional ANUPQ package!  7.2 Running the pq program as a standalone When the pq program is run as a standalone it sometimes needs to call GAP to compute stabilisers of subgroups; in doing so, it first checks the value of the environment variable ANUPQ_GAP_EXEC, and uses that, if set, or otherwise the value of GAP it was compiled with, as the path for GAP. If you ran testPq (see Section 'Testing your ANUPQ installation') and you got both GAP is OK and the link between the pq binary and GAP is OK, you should be fine. Otherwise heed the recommendations of the error messages you get and run the testPq until all tests are passed. It is especially important that the GAP, whose path you gave, should know where to find the ANUPQ and AutPGrp packages. To ensure this the path should be to a shell script that invokes GAP. If you needed to install the needed packages in your own directory (because, say, you are not a system administrator) then you should create your own shell script that runs GAP with a correct setting of the -l option and set the path used by the pq binary to the path of that script. To create the script that runs GAP it is easiest to copy the system one and edit it, e.g. start by executing the following UNIX commands (skip the second step if you already have a bin directory; you@unix> is your UNIX prompt):  you@unix> cd you@unix> mkdir bin you@unix> cd bin you@unix> which gap /usr/local/bin/gap you@unix> cp /usr/local/bin/gap mygap you@unix> chmod +x mygap  At the second-last step use the path of GAP returned by which gap. Now hopefully you will have a copy of the script that runs the system GAP in mygap. Now use your favourite editor to edit the -l part of the last line of mygap which should initially look something like:  exec $GAP_DIR/bin/$GAP_PRG -m $GAP_MEM -o 970m -l $GAP_DIR $*  so that it becomes (the tilde is a UNIX abbreviation for your home directory):  exec $GAP_DIR/bin/$GAP_PRG -m $GAP_MEM -o 970m -l "$GAP_DIR;~/gapstuff" $*  assuming that your personal GAP pkg directory is a subdirectory of gapstuff in your home directory. Finally, to let the pq program know where GAP is and also know where your pkg directory is that contains ANUPQ, set the environment variable ANUPQ_GAP_EXEC to the complete (i.e. absolute) path of your mygap script (do not use the tilde abbreviation). anupq-3.3.3/doc/chap6.html0000644000175100017510000011126115111342310014677 0ustar runnerrunner GAP (ANUPQ) - Chapter 6: ANUPQ Options
Goto Chapter: Top 1 2 3 4 5 6 7 A Bib Ind
 [Top of Book]  [Contents]   [Previous Chapter]   [Next Chapter] 

6 ANUPQ Options
 6.1 Overview

  6.1-1 AllANUPQoptions
  6.1-2 ANUPQoptions
 6.2 Detailed descriptions of ANUPQ Options

6 ANUPQ Options

6.1 Overview

In this chapter we describe in detail all the options used by functions of the ANUPQ package. Note that by options we mean GAP options that are passed to functions after the arguments and separated from the arguments by a colon as described in Chapter Reference: Function Calls in the Reference Manual. The user is strongly advised to read Section Hints and Warnings regarding the use of Options.

6.1-1 AllANUPQoptions
‣ AllANUPQoptions( )( function )

lists all the GAP options defined for functions of the ANUPQ package:

gap> AllANUPQoptions();
[ "AllDescendants", "BasicAlgorithm", "Bounds", "CapableDescendants", 
  "ClassBound", "CustomiseOutput", "Exponent", "Filename", "GroupName", 
  "Identities", "Metabelian", "NumberOfSolubleAutomorphisms", "OrderBound", 
  "OutputLevel", "PcgsAutomorphisms", "PqWorkspace", "Prime", 
  "PrintAutomorphisms", "PrintPermutations", "QueueFactor", 
  "RankInitialSegmentSubgroups", "RedoPcp", "RelativeOrders", "Relators", 
  "SetupFile", "SpaceEfficient", "StandardPresentationFile", "StepSize", 
  "SubList", "TreeDepth", "pQuotient" ]

The following global variable gives a partial breakdown of where the above options are used.

6.1-2 ANUPQoptions
‣ ANUPQoptions( global variable )

is a record of lists of names of admissible ANUPQ options, such that each field is either the name of a key ANUPQ function or other (for a miscellaneous list of functions) and the corresponding value is the list of option names that are admissible for the function (or miscellaneous list of functions).

Also, from within a GAP session, you may use GAP's help browser (see Chapter Reference: The Help System in the GAP Reference Manual); to find out about any particular ANUPQ option, simply type: ?option option, where option is one of the options listed above without any quotes, e.g.

gap> ?option Prime

will display the sections in this manual that describe the Prime option. In fact the first 4 are for the functions that have Prime as an option and the last actually describes the option. So follow up by choosing

gap> ?5

This is also the pattern for other options (the last section of the list always describes the option; the other sections are the functions with which the option may be used).

In the section following we describe in detail all ANUPQ options. To continue onto the next section on-line using GAP's help browser, type:

gap> ?>

6.2 Detailed descriptions of ANUPQ Options

Prime := p

Specifies that the p-quotient for the prime p should be computed.

ClassBound := n

Specifies that the p-quotient to be computed has lower exponent-p class at most n. If this option is omitted a default of 63 (which is the maximum possible for the pq program) is taken, except for PqDescendants (see PqDescendants (4.4-1)) and in a special case of PqPCover (see PqPCover (4.1-3)). Let F be the argument (or start group of the process in the interactive case) for the function; then for PqDescendants the default is PClassPGroup(F) + 1, and for the special case of PqPCover the default is PClassPGroup(F).

pQuotient := Q

This option is only available for the standard presentation functions. It specifies that a p-quotient of the group argument of the function or group of the process is the pc p-group Q, where Q is of class less than the provided (or default) value of ClassBound. If pQuotient is provided, then the option Prime if also provided, is ignored; the prime p is discovered by computing PrimePGroup(Q).

Exponent := n

Specifies that the p-quotient to be computed has exponent n. For an interactive process, Exponent defaults to a previously supplied value for the process. Otherwise (and non-interactively), the default is 0, which means that no exponent law is enforced.

Relators := rels

Specifies that the relators sent to the pq program should be rels instead of the relators of the argument group F (or start group in the interactive case) of the calling function; rels should be a list of strings in the string representations of the generators of F, and F must be an fp group (even if the calling function accepts a pc group). This option provides a way of giving relators to the pq program, without having them pre-expanded by GAP, which can sometimes effect a performance loss of the order of 100 (see Section The Relators Option).

Notes

  1. The pq program does not use / to indicate multiplication by an inverse and uses square brackets to represent (left normed) commutators. Also, even though the pq program accepts relations, all elements of rels must be in relator form, i.e. a relation of form w1 = w2 must be written as w1*(w2)^-1 and then put in a pair of double-quotes to make it a string. See the example below.

  2. To ensure there are no syntax errors in rels, each relator is parsed for validity via PqParseWord (see PqParseWord (3.4-3)). If they are ok, a message to say so is Info-ed at InfoANUPQ level 2.

Metabelian

Specifies that the largest metabelian p-quotient subject to any other conditions specified by other options be constructed. By default this restriction is not enforced.

GroupName := name

Specifies that the pq program should refer to the group by the name name (a string). If GroupName is not set and the group has been assigned a name via SetName (see Reference: Name) it is set as the name the pq program should use. Otherwise, the generic name "[grp]" is set as a default.

Identities := funcs

Specifies that the pc presentation should satisfy the laws defined by each function in the list funcs. This option may be called by Pq, PqEpimorphism, or PqPCover (see Pq (4.1-1)). Each function in the list funcs must return a word in its arguments (there may be any number of arguments). Let identity be one such function in funcs. Then as each lower exponent p-class quotient is formed, instances identity(w1, dots, wn) are added as relators to the pc presentation, where w1, dots, wn are words in the pc generators of the quotient. At each class the class and number of pc generators is Info-ed at InfoANUPQ level 1, the number of instances is Info-ed at InfoANUPQ level 2, and the instances that are evaluated are Info-ed at InfoANUPQ level 3. As usual timing information is Info-ed at InfoANUPQ level 2; and details of the processing of each instance from the pq program (which is often quite voluminous) is Info-ed at InfoANUPQ level 3. Try the examples "B2-4-Id" and "11gp-3-Engel-Id" which demonstrate the usage of the Identities option; these are run using PqExample (see PqExample (3.4-4)). Take note of Note 1. below in relation to the example "B2-4-Id"; the companion example "B2-4" generates the same group using the Exponent option. These examples are discussed at length in Section The Identities Option and PqEvaluateIdentities Function.

Notes

  1. Setting the InfoANUPQ level to 3 or more when setting the Identities option may slow down the computation considerably, by overloading GAP with io operations.

  2. The Identities option is implemented at the GAP level. An identity that is just an exponent law should be specified using the Exponent option (see option Exponent), which is implemented at the C level and is highly optimised and so is much more efficient.

  3. The number of instances of each identity tends to grow combinatorially with the class. So care should be exercised in using the Identities option, by including other restrictions, e.g. by using the ClassBound option (see option ClassBound).

OutputLevel := n

Specifies the level of verbosity of the information output by the ANU pq program when computing a pc presentation; n must be an integer in the range 0 to 3. OutputLevel := 0 displays at most one line of output and is the default; OutputLevel := 1 displays (usually) slightly more output and OutputLevels of 2 and 3 are two levels of verbose output. To see these messages from the pq program, the InfoANUPQ level must be set to at least 1 (see InfoANUPQ (3.3-1)). See Section Hints and Warnings regarding the use of Options for an example of how OutputLevel can be used as a troubleshooting tool.

RedoPcp

Specifies that the current pc presentation (for an interactive process) stored by the pq program be scrapped and clears the current values stored for the options Prime, ClassBound, Exponent and Metabelian and also clears the pQuotient, pQepi and pCover fields of the data record of the process.

SetupFile := filename

Non-interactively, this option directs that pq should not be called and that an input file with name filename (a string), containing the commands necessary for the ANU pq standalone, be constructed. The commands written to filename are also Info-ed behind a ToPQ> prompt at InfoANUPQ level 4 (see InfoANUPQ (3.3-1)). Except in the case following, the calling function returns true. If the calling function is the non-interactive version of one of Pq, PqPCover or PqEpimorphism and the group provided as argument is trivial given with an empty set of generators, then no setup file is written and fail is returned (the pq program cannot do anything useful with such a group). Interactively, SetupFile is ignored.

Note: Since commands emitted to the pq program may depend on knowing what the current state is, to form a setup file some close enough guesses may sometimes be necessary; when this occurs a warning is Info-ed at InfoANUPQ or InfoWarning level 1. To determine whether the close enough guesses give an accurate setup file, it is necessary to run the command without the SetupFile option, after either setting the InfoANUPQ level to at least 4 (the setup file script can then be compared with the ToPQ> commands that are Info-ed) or setting a pq command log file by using ToPQLog (see ToPQLog (3.4-7)).

PqWorkspace := workspace

Non-interactively, this option sets the memory used by the pq program. It sets the maximum number of integer-sized elements to allocate in its main storage array. By default, the pq program sets this figure to 10000000. Interactively, PqWorkspace is ignored; the memory used in this case may be set by giving PqStart a second argument (see PqStart (5.1-1)).

PcgsAutomorphisms
PcgsAutomorphisms := false

Let G be the group associated with the calling function (or associated interactive process). Passing the option PcgsAutomorphisms without a value (or equivalently setting it to true), specifies that a polycyclic generating sequence for the automorphism group (which must be soluble) of G, be computed and passed to the pq program. This increases the efficiency of the computation; it also prevents the pq from calling GAP for orbit-stabilizer calculations. By default, PcgsAutomorphisms is set to the value returned by IsSolvable( AutomorphismGroup( G ) ), and uses the package AutPGrp to compute AutomorphismGroup( G ) if it is installed. This flag is set to true or false in the background according to the above criterion by the function PqDescendants (see PqDescendants (4.4-1) and PqDescendants (5.3-6)).

Note: If PcgsAutomorphisms is used when the automorphism group of G is insoluble, an error message occurs.

OrderBound := n

Specifies that only descendants of size at most p^n, where n is a non-negative integer, be generated. Note that you cannot set both OrderBound and StepSize.

StepSize := n
StepSize := list

For a positive integer n, StepSize specifies that only those immediate descendants which are a factor p^n bigger than their parent group be generated.

For a list list of positive integers such that the sum of the length of list and the exponent-p class of G is equal to the class bound defined by the option ClassBound, StepSize specifies that the integers of list are the step sizes for each additional class.

RankInitialSegmentSubgroups := n

Sets the rank of the initial segment subgroup chosen to be n. By default, this has value 0.

SpaceEfficient

Specifies that the pq program performs certain calculations of p-group generation more slowly but with greater space efficiency. This flag is frequently necessary for groups of large Frattini quotient rank. The space saving occurs because only one permutation is stored at any one time. This option is only available if the PcgsAutomorphisms flag is set to true (see option PcgsAutomorphisms). For an interactive process, SpaceEfficient defaults to a previously supplied value for the process. Otherwise (and non-interactively), SpaceEfficient is by default false.

CapableDescendants

By default, all (i.e. capable and terminal) descendants are computed. If this flag is set, only capable descendants are computed. Setting this option is equivalent to setting AllDescendants := false (see option AllDescendants), except if both CapableDescendants and AllDescendants are passed, AllDescendants is essentially ignored.

AllDescendants := false

By default, all descendants are constructed. If this flag is set to false, only capable descendants are computed. Passing AllDescendants without a value (which is equivalent to setting it to true) is superfluous. This option is provided only for backward compatibility with the GAP 3 version of the ANUPQ package, where by default AllDescendants was set to false (rather than true). It is preferable to use CapableDescendants (see option CapableDescendants).

TreeDepth := class

Specifies that the descendants tree developed by PqDescendantsTreeCoclassOne (see PqDescendantsTreeCoclassOne (A.4-1)) should be extended to class class, where class is a positive integer.

SubList := sub

Suppose that L is the list of descendants generated, then for a list sub of integers this option causes PqDescendants to return Sublist( L, sub ). If an integer n is supplied, PqDescendants returns L[n].

NumberOfSolubleAutomorphisms := n

Specifies that the number of soluble automorphisms of the automorphism group supplied by PqPGSupplyAutomorphisms (see PqPGSupplyAutomorphisms (5.9-1)) in a p-group generation calculation is n. By default, n is taken to be 0; n must be a non-negative integer. If n ≥ 0 then a value for the option RelativeOrders (see 6.2) must also be supplied.

RelativeOrders := list

Specifies the relative orders of each soluble automorphism of the automorphism group supplied by PqPGSupplyAutomorphisms (see PqPGSupplyAutomorphisms (5.9-1)) in a p-group generation calculation. The list list must consist of n positive integers, where n is the value of the option NumberOfSolubleAutomorphisms (see 6.2). By default list is empty.

BasicAlgorithm

Specifies that an algorithm that the pq program calls its default algorithm be used for p-group generation. By default this algorithm is not used. If this option is supplied the settings of options RankInitialSegmentSubgroups, AllDescendants, Exponent and Metabelian are ignored.

CustomiseOutput := rec

Specifies that fine tuning of the output is desired. The record rec should have any subset (or all) of the the following fields:

perm := list

where list is a list of booleans which determine whether the permutation group output for the automorphism group should contain: the degree, the extended automorphisms, the automorphism matrices, and the permutations, respectively.

orbit := list

where list is a list of booleans which determine whether the orbit output of the action of the automorphism group should contain: a summary, and a complete listing of orbits, respectively. (It's possible to have both a summary and a complete listing.)

group := list

where list is a list of booleans which determine whether the group output should contain: the standard matrix of each allowable subgroup, the presentation of reduced p-covering groups, the presentation of immediate descendants, the nuclear rank of descendants, and the p-multiplicator rank of descendants, respectively.

autgroup := list

where list is a list of booleans which determine whether the automorphism group output should contain: the commutator matrix, the automorphism group description of descendants, and the automorphism group order of descendants, respectively.

trace := val

where val is a boolean which if true specifies algorithm trace data is desired. By default, one does not get algorithm trace data.

Not providing a field (or mis-spelling it!), specifies that the default output is desired. As a convenience, 1 is also accepted as true, and any value that is neither 1 nor true is taken as false. Also for each list above, an unbound list entry is taken as false. Thus, for example

CustomiseOutput := rec(group := [,,1], autgroup := [,1])

specifies for the group output that only the presentation of immediate descendants is desired, for the automorphism group output only the automorphism group description of descendants should be printed, that there should be no algorithm trace data, and that the default output should be provided for the permutation group and orbit output.

StandardPresentationFile := filename

Specifies that the file to which the standard presentation is written has name filename. If the first character of the string filename is not /, filename is assumed to be the path of a writable file relative to the directory in which GAP was started. If this option is omitted it is written to the file with the name generated by the command Filename( ANUPQData.tmpdir, "SPres" );, i.e. the file with name "SPres" in the temporary directory in which the pq program executes.

QueueFactor := n

Specifies a queue factor of n, where n must be a positive integer. This option may be used with PqNextClass (see PqNextClass (5.6-4)).

The queue factor is used when the pq program uses automorphisms to close a set of elements of the p-multiplicator under their action.

The algorithm used is a spinning algorithm: it starts with a set of vectors in echelonized form (elements of the p-multiplicator) and closes the span of these vectors under the action of the automorphisms. For this each automorphism is applied to each vector and it is checked if the result is contained in the span computed so far. If not, the span becomes bigger and the vector is put into a queue and the automorphisms are applied to this vector at a later stage. The process terminates when the automorphisms have been applied to all vectors and no new vectors have been produced.

For each new vector it is decided, if its processing should be delayed. If the vector contains too many non-zero entries, it is put into a second queue. The elements in this queue are processed only when there are no elements in the first queue left.

The queue factor is a percentage figure. A vector is put into the second queue if the percentage of its non-zero entries exceeds the queue factor.

Bounds := list

Specifies a lower and upper bound on the indices of a list, where list is a pair of positive non-decreasing integers. See PqDisplayStructure (5.7-23) and PqDisplayAutomorphisms (5.7-24) where this option may be used.

PrintAutomorphisms := list

Specifies that automorphism matrices be printed.

PrintPermutations := list

Specifies that permutations of the subgroups be printed.

Filename := string

Specifies that an output or input file to be written to or read from by the pq program should have the name string.

 [Top of Book]  [Contents]   [Previous Chapter]   [Next Chapter] 
Goto Chapter: Top 1 2 3 4 5 6 7 A Bib Ind

generated by GAPDoc2HTML

anupq-3.3.3/doc/chapBib_mj.html0000644000175100017510000002322515111342310015716 0ustar runnerrunner GAP (ANUPQ) - References
Goto Chapter: Top 1 2 3 4 5 6 7 A Bib Ind
 [Top of Book]  [Contents]   [Previous Chapter]   [Next Chapter] 

References

[HN80] Havas, G. and Newman, M. F., Application of computers to questions like those of Burnside, in Burnside groups (Proc. Workshop, Univ. Bielefeld, Bielefeld, 1977), Springer, Lecture Notes in Math., 806, Berlin (1980), 211--230.

[LS90] Leedham-Green, C. R. and Soicher, L. H., Collection from the left and other strategies, J. Symbolic Comput., 9 (5-6) (1990), 665--675
(Computational group theory, Part 1).

[New77] Newman, M. F., Determination of groups of prime-power order, in Group theory (Proc. Miniconf., Australian Nat. Univ., Canberra, 1975), Springer, Berlin (1977), 73--84. Lecture Notes in Math., Vol. 573.

[NNN98] Newman, M. F., Nickel, W. and Niemeyer, A. C., Descriptions of groups of prime-power order, J. Symbolic Comput., 25 (5) (1998), 665--682.

[NO96] Newman, M. F. and O'Brien, E. A., Application of computers to questions like those of Burnside. II, Internat. J. Algebra Comput., 6 (5) (1996), 593--605.

[O'B90] O'Brien, E. A., The \(p\)-group generation algorithm, J. Symbolic Comput., 9 (5-6) (1990), 677--698
(Computational group theory, Part 1).

[O'B94] O'Brien, E. A., Isomorphism testing for \(p\)-groups, J. Symbolic Comput., 17 (2) (1994), 131, 133--147.

[O'B95] O'Brien, E. A., Computing automorphism groups of \(p\)-groups, in Computational algebra and number theory (Sydney, 1992), Kluwer Acad. Publ., Math. Appl., 325, Dordrecht (1995), 83--90.

[Sim94] Sims, C. C., Computation with finitely presented groups, Cambridge University Press, Encyclopedia of Mathematics and its Applications, 48, Cambridge (1994), xiii+604 pages.

[Vau84] Vaughan-Lee, M. R., An aspect of the nilpotent quotient algorithm, in Computational group theory (Durham, 1982), Academic Press, London (1984), 75--83.

[Vau90a] Vaughan-Lee, M., The restricted Burnside problem, The Clarendon Press Oxford University Press, London Mathematical Society Monographs. New Series, 5, New York (1990), xiv+209 pages
(Oxford Science Publications).

[Vau90b] Vaughan-Lee, M. R., Collection from the left, J. Symbolic Comput., 9 (5-6) (1990), 725--733
(Computational group theory, Part 1).

 [Top of Book]  [Contents]   [Previous Chapter]   [Next Chapter] 
Goto Chapter: Top 1 2 3 4 5 6 7 A Bib Ind

generated by GAPDoc2HTML

anupq-3.3.3/doc/chap3_mj.html0000644000175100017510000015533015111342310015367 0ustar runnerrunner GAP (ANUPQ) - Chapter 3: Infrastructure
Goto Chapter: Top 1 2 3 4 5 6 7 A Bib Ind
 [Top of Book]  [Contents]   [Previous Chapter]   [Next Chapter] 

3 Infrastructure
 3.1 Loading the ANUPQ Package
 3.2 The ANUPQData Record

  3.2-1 ANUPQData
  3.2-2 ANUPQDirectoryTemporary
 3.3 Setting the Verbosity of ANUPQ via Info and InfoANUPQ

  3.3-1 InfoANUPQ
 3.4 Utility Functions

  3.4-1 PqLeftNormComm
  3.4-2 PqGAPRelators
  3.4-3 PqParseWord
  3.4-4 PqExample
  3.4-5 AllPqExamples
  3.4-6 GrepPqExamples
  3.4-7 ToPQLog
 3.5 Attributes and a Property for fp and pc p-groups

  3.5-1 NuclearRank
 3.6 Hints and Warnings regarding the use of Options

  3.6-1 ANUPQWarnOfOtherOptions

3 Infrastructure

Most of the details in this chapter are of a technical nature; the user need only skim over this chapter on a first reading. Mostly, it is enough to know that

  • you must do a LoadPackage("anupq"); before you can expect to use a command defined by the ANUPQ package (details are in Section Loading the ANUPQ Package);

  • partial results of ANUPQ commands and some other data are stored in the ANUPQData global variable (details are in Section The ANUPQData Record);

  • doing SetInfoLevel(InfoANUPQ, n); for n greater than the default value 1 will give progressively more information of what is going on behind the scenes (details are in Section Setting the Verbosity of ANUPQ via Info and InfoANUPQ);

  • in Section Utility Functions we describe some utility functions and functions that run examples from the collection of examples of this package;

  • in Section Attributes and a Property for fp and pc p-groups we describe the attributes and property NuclearRank, MultiplicatorRank and IsCapable; and

  • in Section Hints and Warnings regarding the use of Options we describe some troubleshooting strategies. Also this section explains the utility of setting ANUPQWarnOfOtherOptions := true; (particularly for novice users) for detecting misspelt options and diagnosing other option usage problems.

3.1 Loading the ANUPQ Package

To use the ANUPQ package, as with any GAP package, it must be requested explicitly. This is done by calling

gap> LoadPackage( "anupq" );
---------------------------------------------------------------------------
Loading ANUPQ 3.3.3 (ANU p-Quotient)
by Greg Gamble (GAP code, Greg.Gamble@uwa.edu.au),
   Werner Nickel (GAP code), and
   Eamonn O'Brien (C code, https://www.math.auckland.ac.nz/~obrien).
maintained by:
   Max Horn (https://www.quendi.de/math).
uses ANU pq binary (C code program) version: 1.9
Homepage: https://gap-packages.github.io/anupq/
Report issues at https://github.com/gap-packages/anupq/issues
---------------------------------------------------------------------------
true

Note that since the ANUPQ package uses the AutomorphimGroupPGroup function of the AutPGrp package and, in any case, often needs other AutPGrp functions when computing descendants, the user must ensure that the AutPGrp package is also installed, at least version 1.5. If the AutPGrp package is not installed, the ANUPQ package will fail to load.

Also, if GAP cannot find a working pq binary, the call to LoadPackage will return fail.

If you want to load the ANUPQ package by default, you can put the LoadPackage command into your gap.ini file (see Section Reference: The gap.ini and gaprc files in the GAP Reference Manual). By the way, the novice user of the ANUPQ package should probably also append the line

ANUPQWarnOfOtherOptions := true;

to their gap.ini file, somewhere after the LoadPackage( "anupq" ); command (see ANUPQWarnOfOtherOptions (3.6-1)).

3.2 The ANUPQData Record

This section contains fairly technical details which may be skipped on an initial reading.

3.2-1 ANUPQData
‣ ANUPQData( global variable )

is a GAP record in which the essential data for an ANUPQ session within GAP is stored; its fields are:

binary

the path of the pq binary;

tmpdir

the path of the temporary directory used by the pq binary and GAP (i.e. the directory in which all the pq's temporary files are created) (also see ANUPQDirectoryTemporary (3.2-2) below);

outfile

the full path of the default pq output file;

SPimages

the full path of the file GAP_library to which the pq program writes its Standard Presentation images;

version

the version of the current pq binary;

ni

a data record used by non-interactive functions (see below and Chapter Non-interactive ANUPQ functions);

io

list of data records for PqStart (see below and PqStart (5.1-1)) processes;

topqlogfile

name of file logged to by ToPQLog (see ToPQLog (3.4-7)); and

logstream

stream of file logged to by ToPQLog (see ToPQLog (3.4-7)).

Each time an interactive ANUPQ process is initiated via PqStart (see PqStart (5.1-1)), an identifying number ioIndex is generated for the interactive process and a record ANUPQData.io[ioIndex] with some or all of the fields listed below is created. Whenever a non-interactive function is called (see Chapter Non-interactive ANUPQ functions), the record ANUPQData.ni is updated with fields that, if bound, have exactly the same purpose as for a ANUPQData.io[ioIndex] record.

stream

the IOStream opened for interactive ANUPQ process ioIndex or non-interactive ANUPQ function;

group

the group given as first argument to PqStart, Pq, PqEpimorphism, PqDescendants or PqStandardPresentation (or any synonymous methods);

haspcp

is bound and set to true when a pc presentation is first set inside the pq program (e.g. by PqPcPresentation or PqRestorePcPresentation or a higher order function like Pq, PqEpimorphism, PqPCover, PqDescendants or PqStandardPresentation that does a PqPcPresentation operation, but not PqStart which only starts up an interactive ANUPQ process);

gens

a list of the generators of the group group as strings (the same as those passed to the pq program);

rels

a list of the relators of the group group as strings (the same as those passed to the pq program);

name

the name of the group whose pc presentation is defined by a call to the pq program (according to the pq program -- unless you have used the GroupName option (see e.g. Pq (4.1-1)) or applied the function SetName (see SetName (Reference: Name)) to the group, the generic name "[grp]" is set as a default);

gpnum

if not a null string, the number (i.e. the unique label assigned by the pq program) of the last descendant processed;

class

the largest lower exponent-\(p\) central class of a quotient group of the group (usually group) found by a call to the pq program;

forder

the factored order of the quotient group of largest lower exponent-\(p\) central class found for the group (usually group) by a call to the pq program (this factored order is given as a list [p,n], indicating an order of \(p^n\));

pcoverclass

the lower exponent-\(p\) central class of the \(p\)-covering group of a \(p\)-quotient of the group (usually group) found by a call to the pq program;

workspace

the workspace set for the pq process (either given as a second argument to PqStart, or set by default to 10000000);

menu

the current menu of the pq process (the pq program is managed by various menus, the details of which the user shouldn't normally need to know about -- the menu field remembers which menu the pq process is currently in);

outfname

is the file to which pq output is directed, which is always ANUPQData.outfile, except when option SetupFile is used with a non-interactive function, in which case outfname is set to "PQ_OUTPUT";

pQuotient

is set to the value returned by Pq (see Pq (4.1-1)) (the field pQepi is also set at the same time);

pQepi

is set to the value returned by PqEpimorphism (see PqEpimorphism (4.1-2)) (the field pQuotient is also set at the same time);

pCover

is set to the value returned by PqPCover (see PqPCover (4.1-3));

SP

is set to the value returned by PqStandardPresentation or StandardPresentation (see PqStandardPresentation (5.3-4)) when called interactively, for process i (the field SPepi is also set at the same time);

SPepi

is set to the value returned by EpimorphismPqStandardPresentation or EpimorphismStandardPresentation (see EpimorphismPqStandardPresentation (5.3-5)) when called interactively, for process i (the field SP is also set at the same time);

descendants

is set to the value returned by PqDescendants (see PqDescendants (4.4-1));

treepos

if set by a call to PqDescendantsTreeCoclassOne (see PqDescendantsTreeCoclassOne (A.4-1)), it contains a record with fields class, node and ndes being the information that determines the last descendant with a non-zero number of descendants processed;

xgapsheet

if set by a call to PqDescendantsTreeCoclassOne (see PqDescendantsTreeCoclassOne (A.4-1)) during an XGAP session, it contains the XGAP Sheet on which the descendants tree is displayed; and

nextX

if set by a call to PqDescendantsTreeCoclassOne (see PqDescendantsTreeCoclassOne (A.4-1)) during an XGAP session, it contains a list of integers, the ith entry of which is the x-coordinate of the next node (representing a descendant) for the ith class.

3.2-2 ANUPQDirectoryTemporary
‣ ANUPQDirectoryTemporary( dir )( function )

calls the UNIX command mkdir to create dir, which must be a string, and if successful a directory object for dir is both assigned to ANUPQData.tmpdir and returned. The field ANUPQData.outfile is also set to be a file in ANUPQData.tmpdir, and on exit from GAP dir is removed. Most users will never need this command; by default, GAP typically chooses a random subdirectory of /tmp for ANUPQData.tmpdir which may occasionally have limits on what may be written there. ANUPQDirectoryTemporary permits the user to choose a directory (object) where one is not so limited.

3.3 Setting the Verbosity of ANUPQ via Info and InfoANUPQ

3.3-1 InfoANUPQ
‣ InfoANUPQ( info class )

The input to and the output from the pq program is, by default, not displayed. However the user may choose to see some, or all, of this input/output. This is done via the Info mechanism (see Section Reference: Info Functions in the GAP Reference Manual). For this purpose, there is the InfoClass InfoANUPQ. If the InfoLevel of InfoANUPQ is high enough each line of pq input/output is directed to a call to Info and will be displayed for the user to see. By default, the InfoLevel of InfoANUPQ is 1, and it is recommended that you leave it at this level, or higher. Messages that the user should presumably want to see and output from the pq program influenced by the value of the option OutputLevel (see the options listed in Section Pq (4.1-1)), other than timing and memory usage are directed to Info at InfoANUPQ level 1.

To turn off all InfoANUPQ messaging, set the InfoANUPQ level to 0.

There are five other user-intended InfoANUPQ levels: 2, 3, 4, 5 and 6.

gap> SetInfoLevel(InfoANUPQ, 2);

enables the display of most timing and memory usage data from the pq program, and also the number of identity instances when the Identities option is used. (Some timing and memory usage data, particularly when profuse in quantity, is Info-ed at InfoANUPQ level 3 instead.) Note that the the GAP functions time and Runtime (see Runtime (Reference: Runtime) in the GAP Reference Manual) count the time spent by GAP and not the time spent by the (external) pq program.

gap> SetInfoLevel(InfoANUPQ, 3);

enables the display of output of the nature of the first two InfoANUPQ that was not directly invoked by the user (e.g. some commands require GAP to discover something about the current state known to the pq program). The identity instances processed under the Identities option are also displayed at this level. In some cases, the pq program produces a lot of output despite the fact that the OutputLevel (see 6.2) is unset or is set to 0; such output is also Info-ed at InfoANUPQ level 3.

gap> SetInfoLevel(InfoANUPQ, 4);

enables the display of all the commands directed to the pq program, behind a ToPQ> prompt (so that you can distinguish it from the output from the pq program). See Section Hints and Warnings regarding the use of Options for an example of how this can be a useful troubleshooting tool.

gap> SetInfoLevel(InfoANUPQ, 5);

enables the display of the pq program's prompts for input. Finally,

gap> SetInfoLevel(InfoANUPQ, 6);

enables the display of all other output from the pq program, namely the banner and menus. However, the timing data printed when the pq program exits can never be observed.

3.4 Utility Functions

3.4-1 PqLeftNormComm
‣ PqLeftNormComm( elts )( function )

returns for a list of elements of some group (e.g. elts may be a list of words in the generators of a free or fp group) the left normed commutator of elts, e.g. if w1, w2, w3 are such elements then PqLeftNormComm( [w1, w2, w3] ); is equivalent to Comm( Comm( w1, w2 ), w3 );.

Note: elts must contain at least two elements.

3.4-2 PqGAPRelators
‣ PqGAPRelators( group, rels )( function )

returns a list of words that GAP understands, given a list rels of strings in the string representations of the generators of the fp group group prepared as a list of relators for the pq program.

Note: The pq program does not use / to indicate multiplication by an inverse and uses square brackets to represent (left normed) commutators. Also, even though the pq program accepts relations, all elements of rels must be in relator form, i.e. a relation of form w1 = w2 must be written as w1*(w2)^-1.

Here is an example:

gap> F := FreeGroup("a", "b");
<free group on the generators [ a, b ]>
gap> PqGAPRelators(F, [ "a*b^2", "[a,b]^2*a", "[a,b,a,b]^a" ]);
[ a*b^2, (a^-1*b^-1*a*b)^2*a, 
  a^-2*b^-1*a^-1*b*(a*b^-1)^2*a^-1*b*a^-1*b^-1*(a*b)^2*a ]

3.4-3 PqParseWord
‣ PqParseWord( word, n )( function )

parses a word, a string representing a word in the pc generators x1,...,xn, through GAP. This function is provided as a rough-and-ready check of word for syntax errors. A syntax error will cause the entering of a break-loop, in which the error message may or may not be meaningful (depending on whether the syntax error gets caught at the GAP or kernel level).

Note: The reason the generators must be x1,...,xn is that these are the pc generator names used by the pq program (as distinct from the generator names for the group provided by the user to a function like Pq that invokes the pq program).

3.4-4 PqExample
‣ PqExample( )( function )
‣ PqExample( example[, PqStart][, Display] )( function )
‣ PqExample( example[, PqStart][, filename] )( function )

With no arguments, or with single argument "index", or a string example that is not the name of a file in the examples directory, an index of available examples is displayed.

With just the one argument example that is the name of a file in the examples directory, the example contained in that file is executed in its simplest form. Some examples accept options which you may use to modify some of the options used in the commands of the example. To find out which options an example accepts, use one of the mechanisms for displaying the example described below.

Some examples have both non-interactive and interactive forms; those that are non-interactive only have a name ending in -ni; those that are interactive only have a name ending in -i; examples with names ending in .g also have only one form; all other examples have both non-interactive and interactive forms and for these giving PqStart as second argument invokes PqStart initially and makes the appropriate adjustments so that the example is executed or displayed using interactive functions.

If PqExample is called with last (second or third) argument Display then the example is displayed without being executed. If the last argument is a non-empty string filename then the example is also displayed without being executed but is also written to a file with that name. Passing an empty string as last argument has the same effect as passing Display.

Note: The variables used in PqExample are local to the running of PqExample, so there's no danger of having some of your variables over-written. However, they are not completely lost either. They are saved to a record ANUPQData.examples.vars, i.e. if F is a variable used in the example then you will be able to access it after PqExample has finished as ANUPQData.examples.vars.F.

3.4-5 AllPqExamples
‣ AllPqExamples( )( function )

returns a list of all currently available examples in default UNIX-listing (i.e. alphabetic) order.

3.4-6 GrepPqExamples
‣ GrepPqExamples( string )( function )

runs the UNIX command grep string over the ANUPQ examples and returns the list of examples for which there is a match. The actual matches are Info-ed at InfoANUPQ level 2.

3.4-7 ToPQLog
‣ ToPQLog( [filename] )( function )

With string argument filename, ToPQLog opens the file with name filename for logging; all commands written to the pq binary (that are Info-ed behind a ToPQ> prompt at InfoANUPQ level 4) are then also written to that file (but without prompts). With no argument, ToPQLog stops logging to whatever file was being logged to. If a file was already being logged to, that file is closed and the file with name filename is opened for logging.

3.5 Attributes and a Property for fp and pc p-groups

3.5-1 NuclearRank
‣ NuclearRank( G )( attribute )
‣ MultiplicatorRank( G )( attribute )
‣ IsCapable( G )( property )

return the nuclear rank of G, \(p\)-multiplicator rank of G, and whether G is capable (i.e. true if it is, or false if it is not), respectively.

These attributes and property are set automatically if G is one of the following:

  • an fp group returned by PqStandardPresentation or StandardPresentation (see PqStandardPresentation (4.2-1));

  • the image (fp group) of the epimorphism returned by an EpimorphismPqStandardPresentation or EpimorphismStandardPresentation call (see EpimorphismPqStandardPresentation (4.2-2)); or

  • one of the pc groups of the list of descendants returned by PqDescendants (see PqDescendants (4.4-1)).

If G is an fp group or a pc \(p\)-group and not one of the above and the attribute or property has not otherwise been set for G, then PqStandardPresentation is called to set all three of NuclearRank, MultiplicatorRank and IsCapable, before returning the value of the attribute or property actually called. Such a group G must know in advance that it is a \(p\)-group; this is the case for the groups returned by the functions Pq and PqPCover, and the image group of the epimorphism returned by PqEpimorphism. Otherwise, if you know the group to be a \(p\)-group, then this can be set by typing

SetIsPGroup( G, true );

or by invoking IsPGroup( G ). Note that for an fp group G, the latter may result in a coset enumeration which might not terminate in a reasonable time.

Note: For G such that HasNuclearRank(G) = true, IsCapable(G) is equivalent to (the truth or falsity of) NuclearRank( G ) = 0.

3.6 Hints and Warnings regarding the use of Options

On a first reading we recommend you skip this section and come back to it if and when you run into trouble.

Note: By options we refer to GAP options. The pq program also uses the term option; to distinguish the two usages of option, in this manual we use the term menu item to refer to what the pq program refers to as an option.

Options are passed to the ANUPQ interface functions in either of the two usual mechanisms provided by GAP, namely:

  • options may be set globally using the function PushOptions (see Chapter Reference: Options Stack in the GAP Reference Manual); or

  • options may be appended to the argument list of any function call, separated by a colon from the argument list (see Chapter Reference: Function Calls in the GAP Reference Manual), in which case they are then passed on recursively to any subsequent inner function call, which may in turn have options of their own.

Particularly, when one is using the interactive functions of Chapter Interactive ANUPQ functions, one should, in general, avoid using the global method of passing options. In fact, it is recommended that prior to calling PqStart the OptionsStack be empty. The essential problem with setting options globally using the function PushOptions is that options pushed onto OptionsStack, in this way, (generally) remain there until an explicit PopOptions() call is made.

In contrast, options passed in the usual way behind a colon following a function's arguments (see Reference: Function Call With Options in the GAP Reference Manual) are local, and disappear from OptionsStack after the function has executed successfully. If the function does not execute successfully, i.e. it runs into error and the user quits the resulting break loop (see Section Reference: Break Loops in the Reference Manual) rather than attempting to repair the problem and typing return; then, unless the error at the kernel level, the OptionsStack is reset. If an error is detected inside the kernel (hopefully, this should occur only rarely, if at all) then the options of that function will not be cleared from OptionsStack; in such cases:

gap> ResetOptionsStack();
#I  Options stack is already empty

is usually necessary (see Chapter ResetOptionsStack (Reference: ResetOptionsStack) in the GAP Reference Manual), which recursively calls PopOptions() until OptionsStack is empty, or as in the above case warns you that the OptionsStack is already empty.

Note that a function, that is passed options after the colon, will also see any global options or any options passed down recursively from functions calling that function, unless those options are over-ridden by options passed via the function. Also, note that duplication of option names for different programs may lead to misinterpretations, and mis-spelled options will not be seen.

The non-interactive functions of Chapter Non-interactive ANUPQ functions that have Pq somewhere in their name provide an alternative method of passing options as additional arguments. This has the advantages that options can be abbreviated and mis-spelled options will be trapped.

3.6-1 ANUPQWarnOfOtherOptions
‣ ANUPQWarnOfOtherOptions( global variable )

is a global variable that is by default false. If it is set to true then any function provided by the ANUPQ function that recognises at least one option, will warn you of other options, i.e. options that the function does not recognise. These warnings are emitted at InfoWarning or InfoANUPQ level 1. This is useful for detecting mis-spelled options. Here is an example using the function Pq (first described in Chapter Non-interactive ANUPQ functions):

gap> SetInfoLevel(InfoANUPQ, 1);        # Set InfoANUPQ to default level
gap> ANUPQWarnOfOtherOptions := true;;
gap> # The following makes entry into break loops very ``quiet'' ...
gap> OnBreak := function() Where(0); end;;
gap> F := FreeGroup( "a", "b" );
<free group on the generators [ a, b ]>
gap> Pq( F : Prime := 2, Classbound := 1 );
#I  ANUPQ Warning: Options: [ "Classbound" ] ignored
#I  (invalid for generic function: `Pq').
user interrupt at
moreOfline := ReadLine( iostream );
Entering break read-eval-print loop ...
you can 'quit;' to quit to outer loop, or
you can 'return;' to continue

Here we mistyped ClassBound as Classbound, and after seeing the Info-ed warning that Classbound was ignored, we typed a control-C (that's the user interrupt at message) which took us into a break loop. Since the Pq command was not able to finish, the options Prime and Classbound, in particular, will still be on the OptionsStack:

brk> OptionsStack;
[ rec( Prime := 2, Classbound := 1 ), 
  rec( Prime := 2, Classbound := 1, PqEpiOrPCover := "pQuotient" ) ]

The option PqEpiOrPCover is a behind-the-scenes option that need not concern the user. On quitting the break-loop the OptionsStack is reset and a warning telling you this is emitted:

brk> quit; # to get back to the `gap>' prompt
#I  Options stack has been reset

Above, we altered OnBreak (see OnBreak (Reference: OnBreak) in the Reference manual) to reduce the back-tracing on entry into a break loop. We now restore OnBreak to its usual value.

gap> OnBreak := Where;;

Notes

In cases where functions recursively call others with options (e.g. when using PqExample with options), setting ANUPQWarnOfOtherOptions := true may give rise to spurious other option detections.

It is recommended that the novice user set ANUPQWarnOfOtherOptions to true in their gap.ini file (see Section Loading the ANUPQ Package).

Other Troubleshooting Strategies

There are some other strategies which may have helped us to see our error above. The function Pq recognises the option OutputLevel (see 6.2); if this option is set to at least 1, the pq program provides information on each class quotient as it is generated:

gap> ANUPQWarnOfOtherOptions := false;; # Set back to normal
gap> F := FreeGroup( "a", "b" );;
gap> Pq( F : Prime := 2, Classbound := 1, OutputLevel := 1 ); 
#I  Lower exponent-2 central series for [grp]
#I  Group: [grp] to lower exponent-2 central class 1 has order 2^2
#I  Group: [grp] to lower exponent-2 central class 2 has order 2^5
#I  Group: [grp] to lower exponent-2 central class 3 has order 2^10
#I  Group: [grp] to lower exponent-2 central class 4 has order 2^18
#I  Group: [grp] to lower exponent-2 central class 5 has order 2^32
#I  Group: [grp] to lower exponent-2 central class 6 has order 2^55
#I  Group: [grp] to lower exponent-2 central class 7 has order 2^96
#I  Group: [grp] to lower exponent-2 central class 8 has order 2^167
#I  Group: [grp] to lower exponent-2 central class 9 has order 2^294
#I  Group: [grp] to lower exponent-2 central class 10 has order 2^520
#I  Group: [grp] to lower exponent-2 central class 11 has order 2^932
#I  Group: [grp] to lower exponent-2 central class 12 has order 2^1679
[... output truncated ...]

After seeing the information for the class 2 quotient we may have got the idea that the Classbound option was not recognised and may have realised that this was due to a mis-spelling. The above will ordinarily cause the available space to be exhausted, necessitating user-intervention by typing control-C and quit; (to escape the break loop); otherwise Pq terminates when the class reaches 63 (the default value of ClassBound).

If you have some familiarity with keyword command input to the pq binary, then setting the level of InfoANUPQ to 4 would also have indicated a problem:

gap> ResetOptionsStack(); # Necessary, if a break-loop was entered above
gap> SetInfoLevel(InfoANUPQ, 4);
gap> Pq( F : Prime := 2, Classbound := 1 );
#I  ToPQ> 7  #to (Main) p-Quotient Menu
#I  ToPQ> 1  #define group
#I  ToPQ> name [grp]
#I  ToPQ> prime 2
#I  ToPQ> class 63
#I  ToPQ> exponent 0
#I  ToPQ> output 0
#I  ToPQ> generators { a,b }
#I  ToPQ> relators   {  };
[... output truncated ...]

Here the line #I ToPQ> class 63 indicates that a directive to set the classbound to 63 was sent to the pq program.

 [Top of Book]  [Contents]   [Previous Chapter]   [Next Chapter] 
Goto Chapter: Top 1 2 3 4 5 6 7 A Bib Ind

generated by GAPDoc2HTML

anupq-3.3.3/doc/chap4.html0000644000175100017510000016246615111342310014712 0ustar runnerrunner GAP (ANUPQ) - Chapter 4: Non-interactive ANUPQ functions
Goto Chapter: Top 1 2 3 4 5 6 7 A Bib Ind
 [Top of Book]  [Contents]   [Previous Chapter]   [Next Chapter] 

4 Non-interactive ANUPQ functions
 4.1 Computing p-Quotients

  4.1-1 Pq
  4.1-2 PqEpimorphism
  4.1-3 PqPCover
 4.2 Computing Standard Presentations

  4.2-1 PqStandardPresentation
  4.2-2 EpimorphismPqStandardPresentation
 4.3 Testing p-Groups for Isomorphism

  4.3-1 IsPqIsomorphicPGroup
 4.4 Computing Descendants of a p-Group

  4.4-1 PqDescendants
  4.4-2 PqSupplementInnerAutomorphisms
  4.4-3 PqList
  4.4-4 SavePqList

4 Non-interactive ANUPQ functions

Here we describe all the non-interactive functions of the ANUPQ package; i.e. one-shot functions that invoke the pq program in such a way that once GAP has got what it needs, the pq program is allowed to exit. It is expected that most of the time users will only need these functions. The functions interface with three of the four algorithms (see Chapter Introduction) provided by the ANU pq C program, and are mainly grouped according to the algorithm of the pq program they relate to.

In Section Computing p-Quotients, we describe the functions that give access to the p-quotient algorithm.

Section Computing Standard Presentations describe functions that give access to the standard presentation algorithm.

Section Testing p-Groups for Isomorphism describe functions that implement an isomorphism test for p-groups using the standard presentation algorithm.

In Section Computing Descendants of a p-Group, we describe functions that give access to the p-group generation algorithm.

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

gap> LoadPackage("anupq");

(the response of which we have omitted; see Loading the ANUPQ Package).

It is strongly recommended that the user try the examples provided. To save typing there is a PqExample equivalent for each manual example. We also suggest that to start with you may find the examples more instructive if you set the InfoANUPQ level to 2 (see InfoANUPQ (3.3-1)).

4.1 Computing p-Quotients

4.1-1 Pq
‣ Pq( F: options )( function )

returns for the fp or pc group F, the p-quotient of F specified by options, as a pc group. Following the colon, options is a selection of the options from the following list, separated by commas like record components (see Section Reference: Function Call With Options in the GAP Reference Manual). As a minimum the user must supply a value for the Prime option. Below we list the options recognised by Pq (see Chapter ANUPQ Options for detailed descriptions).

  • Prime := p

  • ClassBound := n

  • Exponent := n

  • Relators := rels

  • Metabelian

  • Identities := funcs

  • GroupName := name

  • OutputLevel := n

  • SetupFile := filename

  • PqWorkspace := workspace

Notes: Pq may also be called with no arguments or one integer argument, in which case it is being used interactively (see Pq (5.3-1)); the same options may be used, except that SetupFile and PqWorkspace are ignored by the interactive Pq function.

See Section Attributes and a Property for fp and pc p-groups for the attributes and property NuclearRank, MultiplicatorRank and IsCapable which may be applied to the group returned by Pq.

See also PqEpimorphism (PqEpimorphism (4.1-2)).

We now give a few examples of the use of Pq. Except for the addition of a few comments and the non-suppression of output (by not using duplicated semicolons) the next 3 examples may be run by typing: PqExample( "Pq" ); (see PqExample (3.4-4)).

gap> LoadPackage("anupq");; # does nothing if ANUPQ is already loaded
gap> # First we get a p-quotient of a free group of rank 2
gap> F := FreeGroup("a", "b");; a := F.1;; b := F.2;;
gap> Pq( F : Prime := 2, ClassBound := 3 ); 
<pc group of size 1024 with 10 generators>
gap> # Now let us get a p-quotient of an fp group
gap> G := F / [a^4, b^4];
<fp group on the generators [ a, b ]>
gap> Pq( G : Prime := 2, ClassBound := 3 ); 
<pc group of size 256 with 8 generators>
gap> # Now let's get a different p-quotient of the same group
gap> Pq( G : Prime := 2, ClassBound := 3, Exponent := 4 ); 
<pc group of size 128 with 7 generators>
gap> # Now we'll get a p-quotient of another fp group
gap> # which we will redo using the `Relators' option
gap> R := [ a^25, Comm(Comm(b, a), a), b^5 ];
[ a^25, a^-1*b^-1*a*b*a^-1*b^-1*a^-1*b*a^2, b^5 ]
gap> H := F / R;
<fp group on the generators [ a, b ]>
gap> Pq( H : Prime := 5, ClassBound := 5, Metabelian );
<pc group of size 78125 with 7 generators>

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

gap> F := FreeGroup("a", "b");;
gap> # `F' was defined for `Relators'. We use the same strings that GAP uses
gap> # for printing the free group generators. It is *not* necessary to
gap> # predefine: a := F.1; etc. (as it was above).
gap> rels := [ "a^25", "[b, a, a]", "b^5" ];
[ "a^25", "[b, a, a]", "b^5" ]
gap> R := PqGAPRelators(F, rels);
[ a^25, a^-1*b^-1*a*b*a^-1*b^-1*a^-1*b*a^2, b^5 ]
gap> H := F / R;
<fp group on the generators [ a, b ]>
gap> Pq( H : Prime := 5, ClassBound := 5, Metabelian, 
>            Relators := rels );
<pc group of size 78125 with 7 generators>

In fact, above we could have just passed F (rather than H), i.e. we could have done:

gap> F := FreeGroup("a", "b");;
gap> rels := [ "a^25", "[b, a, a]", "b^5" ];
[ "a^25", "[b, a, a]", "b^5" ]
gap> Pq( F : Prime := 5, ClassBound := 5, Metabelian, 
>            Relators := rels );
<pc group of size 78125 with 7 generators>

The non-interactive Pq function also allows the options to be passed in two other ways; these alternatives have been included for those familiar with the GAP 3 version of the ANUPQ package; the preferred method of passing options is the one already described. Firstly, they may be passed in a record as a second argument; note that any boolean options must be set explicitly e.g.

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

It is also possible to pass them as extra arguments, where each option name appears as a string followed immediately by its value (if not a boolean option) e.g.

gap> Pq( H, "Prime", 5, "ClassBound", 5, "Metabelian" );
<pc group of size 78125 with 7 generators>

The preceding two examples can be run from GAP via PqExample( "Pq-ni" ); (see PqExample (3.4-4)).

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

The following example illustrates the use of the option Identities. We compute the largest finite Burnside group of exponent 5 that also satisfies the 3-Engel identity. Each identity is defined by a function whose arguments correspond to the variables of the identity. The return value of each of those functions is the identity evaluated on the arguments of the function.

gap> F := FreeGroup(2);
<free group on the generators [ f1, f2 ]>
gap> Burnside5 := x->x^5;
function( x ) ... end
gap> Engel3 := function( x,y ) return PqLeftNormComm( [x,y,y,y] ); end;
function( x, y ) ... end
gap> Pq( F : Prime := 5, Identities := [ Burnside5, Engel3 ] );
#I  Class 1 with 2 generators.
#I  Class 2 with 3 generators.
#I  Class 3 with 5 generators.
#I  Class 3 with 5 generators.
<pc group of size 3125 with 5 generators>

The above example can be run from GAP via PqExample( "B5-5-Engel3-Id" ); (see PqExample (3.4-4)).

4.1-2 PqEpimorphism
‣ PqEpimorphism( F: options )( function )

returns for the fp or pc group F an epimorphism from F onto the p-quotient of F specified by options; the possible options options and required option ("Prime") are as for Pq (see Pq (4.1-1)). PqEpimorphism only differs from Pq in what it outputs; everything about what must/may be passed as input to PqEpimorphism is the same as for Pq. The same alternative methods of passing options to the non-interactive Pq function are available to the non-interactive version of PqEpimorphism.

Notes: PqEpimorphism may also be called with no arguments or one integer argument, in which case it is being used interactively (see PqEpimorphism (5.3-2)), and the options SetupFile and PqWorkspace are ignored by the interactive PqEpimorphism function.

See Section Attributes and a Property for fp and pc p-groups for the attributes and property NuclearRank, MultiplicatorRank and IsCapable which may be applied to the image group of the epimorphism returned by PqEpimorphism.

gap> F := FreeGroup (2, "F");
<free group on the generators [ F1, F2 ]>
gap> phi := PqEpimorphism( F : Prime := 5, ClassBound := 2 );
[ F1, F2 ] -> [ f1, f2 ]
gap> Image( phi );
<pc group of size 3125 with 5 generators>

Typing: PqExample( "PqEpimorphism" ); runs the above example in GAP (see PqExample (3.4-4)).

4.1-3 PqPCover
‣ PqPCover( F: options )( function )

returns for the fp or pc group F, the p-covering group of the p-quotient of F specified by options, as a pc group, i.e. the p-covering group of the p-quotient Pq( F : options ). Thus the options that PqPCover accepts are exactly those expected for Pq (and hence as a minimum the user must supply a value for the Prime option; see Pq (4.1-1) for more details), except in the following special case.

If F is already a p-group, in the sense that IsPGroup(F) is true, then

Prime

defaults to PrimePGroup(F), if not supplied and HasPrimePGroup(F) = true; and

ClassBound

defaults to PClassPGroup(F) if HasPClassPGroup(F) = true if not supplied, or to the usual default of 63, otherwise.

The same alternative methods of passing options to the non-interactive Pq function are available to the non-interactive version of PqPCover.

We now give a few examples of the use of PqPCover. These examples are just a subset of the ones we gave for Pq (see Pq (4.1-1)), except that in each instance the command Pq has been replaced with PqPCover. Essentially the same examples may be run by typing: PqExample( "PqPCover" ); (see PqExample (3.4-4)).

gap> F := FreeGroup("a", "b");; a := F.1;; b := F.2;;
gap> PqPCover( F : Prime := 2, ClassBound := 3 );
<pc group of size 262144 with 18 generators>
gap> 
gap> # Now let's get a p-cover of a p-quotient of an fp group
gap> G := F / [a^4, b^4];
<fp group on the generators [ a, b ]>
gap> PqPCover( G : Prime := 2, ClassBound := 3 );
<pc group of size 16384 with 14 generators>
gap> 
gap> # Now let's get a p-cover of a different p-quotient of the same group
gap> PqPCover( G : Prime := 2, ClassBound := 3, Exponent := 4 );
<pc group of size 8192 with 13 generators>
gap> 
gap> # Now we'll get a p-cover of a p-quotient of another fp group
gap> # which we will redo using the `Relators' option
gap> R := [ a^25, Comm(Comm(b, a), a), b^5 ];
[ a^25, a^-1*b^-1*a*b*a^-1*b^-1*a^-1*b*a^2, b^5 ]
gap> H := F / R;
<fp group on the generators [ a, b ]>
gap> PqPCover( H : Prime := 5, ClassBound := 5, Metabelian );
<pc group of size 48828125 with 11 generators>
gap> 
gap> # Now we redo the previous example using the `Relators' option
gap> F := FreeGroup("a", "b");;
gap> rels := [ "a^25", "[b, a, a]", "b^5" ];
[ "a^25", "[b, a, a]", "b^5" ]
gap> PqPCover( F : Prime := 5, ClassBound := 5, Metabelian, 
>                  Relators := rels );
<pc group of size 48828125 with 11 generators>

4.2 Computing Standard Presentations

4.2-1 PqStandardPresentation
‣ PqStandardPresentation( F: options )( function )
‣ StandardPresentation( F: options )( method )

return the p-quotient specified by options of the fp or pc p-group F, as an fp group which has a standard presentation. Here options is a selection of the options from the following list (see Chapter ANUPQ Options for detailed descriptions). Section Hints and Warnings regarding the use of Options gives some important hints and warnings regarding option usage, and Section Reference: Function Call With Options in the GAP Reference Manual describes their record-like syntax.

  • Prime := p

  • pQuotient := Q

  • ClassBound := n

  • Exponent := n

  • Metabelian

  • GroupName := name

  • OutputLevel := n

  • StandardPresentationFile := filename

  • SetupFile := filename

  • PqWorkspace := workspace

Unless F is a pc p-group, the user must supply either the option Prime or the option pQuotient (if both Prime and pQuotient are supplied, the prime p is determined by applying PrimePGroup (see PrimePGroup (Reference: PrimePGroup) in the Reference Manual) to the value of pQuotient).

The options for PqStandardPresentation may also be passed in the two other alternative ways described for Pq (see Pq (4.1-1)). StandardPresentation does not provide these alternative ways of passing options.

Notes: In contrast to the function Pq (see Pq (4.1-1)) which returns a pc group, PqStandardPresentation or StandardPresentation returns an fp group. This is because the output is mainly used for isomorphism testing for which an fp group is enough. However, the presentation is a polycyclic presentation and if you need to do any further computation with this group (e.g. to find the order) you can use the function PcGroupFpGroup (see PcGroupFpGroup (Reference: PcGroupFpGroup) in the GAP Reference Manual) to form a pc group.

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

The attributes and property NuclearRank, MultiplicatorRank and IsCapable are set for the group returned by PqStandardPresentation or StandardPresentation (see Section Attributes and a Property for fp and pc p-groups).

We illustrate the method with the following examples.

gap> F := FreeGroup( "a", "b" );; a := F.1;; b := F.2;;
gap> G := F / [a^25, Comm(Comm(b, a), a), b^5];
<fp group on the generators [ a, b ]>
gap> S := StandardPresentation( G : Prime := 5, ClassBound := 10 );
<fp group on the generators [ f1, f2, f3, f4, f5, f6, f7, f8, f9, f10, f11, 
  f12, f13, f14, f15, f16, f17, f18, f19, f20, f21, f22, f23, f24, f25, f26 ]>
gap> IsPcGroup( S );
false
gap> # if we need to compute with S we should convert it to a pc group
gap> Spc := PcGroupFpGroup( S );
<pc group of size 1490116119384765625 with 26 generators>
gap> 
gap> H := F / [ a^625, Comm(Comm(Comm(Comm(b, a), a), a), a)/Comm(b, a)^5,
>               Comm(Comm(b, a), b), b^625 ];;
gap> StandardPresentation( H : Prime := 5, ClassBound := 15, Metabelian );
<fp group on the generators [ f1, f2, f3, f4, f5, f6, f7, f8, f9, f10, f11, 
  f12, f13, f14, f15, f16, f17, f18, f19, f20 ]>
gap> 
gap> F4 := FreeGroup( "a", "b", "c", "d" );;
gap> a := F4.1;; b := F4.2;; c := F4.3;; d := F4.4;;
gap> G4 := F4 / [ b^4, b^2 / Comm(Comm (b, a), a), d^16,
>                 a^16 / (c * d), b^8 / (d * c^4) ];
<fp group on the generators [ a, b, c, d ]>
gap> K := Pq( G4 : Prime := 2, ClassBound := 1 );
<pc group of size 4 with 2 generators>
gap> StandardPresentation( G4 : pQuotient := K, ClassBound := 14 );
<fp group with 53 generators>

Typing: PqExample( "StandardPresentation" ); runs the above example in GAP (see PqExample (3.4-4)).

4.2-2 EpimorphismPqStandardPresentation
‣ EpimorphismPqStandardPresentation( F: options )( function )
‣ EpimorphismStandardPresentation( F: options )( method )

Each of the above functions accepts the same arguments and options as the function StandardPresentation (see StandardPresentation (4.2-1)) and returns an epimorphism from the fp or pc group F onto the finitely presented group given by a standard presentation, i.e. if S is the standard presentation computed for the p-quotient of F by StandardPresentation then EpimorphismStandardPresentation returns the epimorphism from F to the group with presentation S.

Note: The attributes and property NuclearRank, MultiplicatorRank and IsCapable are set for the image group of the epimorphism returned by EpimorphismPqStandardPresentation or EpimorphismStandardPresentation (see Section Attributes and a Property for fp and pc p-groups).

We illustrate the function with the following example.

gap> F := FreeGroup(6, "F");
<free group on the generators [ F1, F2, F3, F4, F5, F6 ]>
gap> # For printing GAP uses the symbols F1, ... for the generators of F
gap> x := F.1;; y := F.2;; z := F.3;; w := F.4;; a := F.5;; b := F.6;;
gap> R := [x^3 / w, y^3 / w * a^2 * b^2, w^3 / b,
>          Comm (y, x) / z, Comm (z, x), Comm (z, y) / a, z^3 ];;
gap> Q := F / R;
<fp group on the generators [ F1, F2, F3, F4, F5, F6 ]>
gap> # For printing GAP also uses the symbols F1, ... for the generators of Q
gap> # (the same as used for F) ... but the gen'rs of Q and F are different:
gap> GeneratorsOfGroup(F) = GeneratorsOfGroup(Q);
false
gap> G := Pq( Q : Prime := 3, ClassBound := 3 );
<pc group of size 729 with 6 generators>
gap> phi := EpimorphismStandardPresentation( Q : Prime := 3,
>                                                ClassBound := 3 );
[ F1, F2, F3, F4, F5, F6 ] -> [ f1*f2^2*f3*f4^2*f5^2, f1*f2*f3*f5, f3^2, 
  f4*f6^2, f5, f6 ]
gap> Source(phi); # This is the group Q (GAP uses F1, ... for gen'r symbols)
<fp group of size infinity on the generators [ F1, F2, F3, F4, F5, F6 ]>
gap> Range(phi);  # This is the group G (GAP uses f1, ... for gen'r symbols)
<fp group on the generators [ f1, f2, f3, f4, f5, f6 ]>
gap> AssignGeneratorVariables(G);
#I  Assigned the global variables [ f1, f2, f3, f4, f5, f6 ]
gap> # Just to see that the images of [F1, ..., F6] do generate G
gap> Group([ f1*f2^2*f3, f1*f2*f3*f4*f5^2*f6^2, f3^2, f4, f5, f6 ]) = G;
true
gap> Size( Image(phi) );
729

Typing: PqExample( "EpimorphismStandardPresentation" ); runs the above example in GAP (see PqExample (3.4-4)). Note that AssignGeneratorVariables (see AssignGeneratorVariables (Reference: AssignGeneratorVariables)) has only been available since GAP 4.3.

4.3 Testing p-Groups for Isomorphism

4.3-1 IsPqIsomorphicPGroup
‣ IsPqIsomorphicPGroup( G, H )( function )
‣ IsIsomorphicPGroup( G, H )( method )

each return true if G is isomorphic to H, where both G and H must be pc groups of prime power order. These functions compute and compare in GAP the fp groups given by standard presentations for G and H (see StandardPresentation (4.2-1)).

gap> G := Group( (1,2,3,4), (1,3) );
Group([ (1,2,3,4), (1,3) ])
gap> P1 := Image( IsomorphismPcGroup( G ) );
Group([ f1, f2, f3 ])
gap> P2 := ElementaryAbelianGroup( 8 );
<pc group of size 8 with 3 generators>
gap> IsIsomorphicPGroup( P1, P2 );
false
gap> P3 := QuaternionGroup( 8 );
<pc group of size 8 with 3 generators>
gap> IsIsomorphicPGroup( P1, P3 );
false
gap> P4 := DihedralGroup( 8 );
<pc group of size 8 with 3 generators>
gap> IsIsomorphicPGroup( P1, P4 );
true

Typing: PqExample( "IsIsomorphicPGroup" ); runs the above example in GAP (see PqExample (3.4-4)).

4.4 Computing Descendants of a p-Group

4.4-1 PqDescendants
‣ PqDescendants( G: options )( function )

returns, for the pc group G which must be of prime power order with a confluent pc presentation (see IsConfluent (Reference: IsConfluent for pc groups) in the GAP Reference Manual), a list of proper descendants (pc groups) of G. Following the colon options a selection of the options listed below should be given, separated by commas like record components (see Section Reference: Function Call With Options in the GAP Reference Manual). See Chapter ANUPQ Options for detailed descriptions of the options.

The automorphism group of each descendant D is also computed via a call to the AutomorphismGroupPGroup function of the AutPGrp package.

  • ClassBound := n

  • Relators := rels

  • OrderBound := n

  • StepSize := n, StepSize := list

  • RankInitialSegmentSubgroups := n

  • SpaceEfficient

  • CapableDescendants

  • AllDescendants := false

  • Exponent := n

  • Metabelian

  • GroupName := name

  • SubList := sub

  • BasicAlgorithm

  • CustomiseOutput := rec

  • SetupFile := filename

  • PqWorkspace := workspace

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

The attributes and property NuclearRank, MultiplicatorRank and IsCapable are set for each group of the list returned by PqDescendants (see Section Attributes and a Property for fp and pc p-groups).

The options options for PqDescendants may be passed in an alternative manner to that already described, namely you can pass PqDescendants a record as an argument, which contains as entries some (or all) of the above mentioned. Those parameters which do not occur in the record are set to their default values.

Note that you cannot set both OrderBound and StepSize.

In the first example we compute all proper descendants of the Klein four group which have exponent-2 class at most 5 and order at most 2^6.

gap> F := FreeGroup( "a", "b" );; a := F.1;; b := F.2;;
gap> G := PcGroupFpGroup( F / [ a^2, b^2, Comm(b, a) ] );
<pc group of size 4 with 2 generators>
gap> des := PqDescendants( G : OrderBound := 6, ClassBound := 5 );;
gap> Length(des);
83
gap> List(des, Size); 
[ 8, 8, 8, 16, 16, 16, 32, 16, 16, 16, 16, 16, 32, 32, 64, 64, 32, 32, 32, 
  32, 32, 32, 32, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 32, 32, 32, 32, 
  64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 32, 32, 32, 32, 32, 64, 64, 64, 
  64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 
  64, 64, 64, 64, 64, 64, 64 ]
gap> List(des, d -> Length( PCentralSeries( d, 2 ) ) - 1 );
[ 2, 2, 2, 2, 2, 2, 2, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 
  3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 4, 
  4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 
  4, 4, 4, 5, 5, 5, 5, 5 ]

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

gap> F := FreeGroup( 2, "g" );
<free group on the generators [ g1, g2 ]>
gap> G := PcGroupFpGroup( F / [ F.1^3, F.2^3, Comm(F.1, F.2) ] );
<pc group of size 9 with 2 generators>
gap> des := PqDescendants( G : OrderBound := 3, ClassBound := 2,
>                              CapableDescendants );
[ <pc group of size 27 with 3 generators>, 
  <pc group of size 27 with 3 generators> ]
gap> List(des, d -> Length( PCentralSeries( d, 3 ) ) - 1 );
[ 2, 2 ]
gap> # For comparison let us now compute all proper descendants
gap> PqDescendants( G : OrderBound := 3, ClassBound := 2);
[ <pc group of size 27 with 3 generators>, 
  <pc group of size 27 with 3 generators>, 
  <pc group of size 27 with 3 generators> ]

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

gap> F := FreeGroup( 2, "g" );;
gap> G := PcGroupFpGroup( F / [ F.1^5, F.2^5, Comm(F.2, F.1) ] );
<pc group of size 25 with 2 generators>
gap> des := PqDescendants( G : Metabelian, ClassBound := 3,
>                              Exponent := 5, CapableDescendants );
[ <pc group of size 125 with 3 generators>, 
  <pc group of size 625 with 4 generators>, 
  <pc group of size 3125 with 5 generators> ]
gap> List(des, d -> Length( PCentralSeries( d, 5 ) ) - 1 );
[ 2, 3, 3 ]
gap> List(des, d -> Length( DerivedSeries( d ) ) );
[ 3, 3, 3 ]
gap> List(des, d -> Maximum( List( d, Order ) ) );
[ 5, 5, 5 ]

The examples "PqDescendants-1", "PqDescendants-2" and "PqDescendants-3" (in order) are essentially the same as the above three examples (see PqExample (3.4-4)).

4.4-2 PqSupplementInnerAutomorphisms
‣ PqSupplementInnerAutomorphisms( D )( function )

returns a generating set for a supplement to the inner automorphisms of D, in the form of a record with fields agAutos, agOrder and glAutos, as provided by the pq program. One should be very careful in using these automorphisms for a descendant calculation.

Note: In principle there must be a way to use those automorphisms in order to compute descendants but there does not seem to be a way to hand back these automorphisms properly to the pq program.

gap> Q := Pq( FreeGroup(2) : Prime := 3, ClassBound := 1 );
<pc group of size 9 with 2 generators>
gap> des := PqDescendants( Q : StepSize := 1 );
[ <pc group of size 27 with 3 generators>, 
  <pc group of size 27 with 3 generators>, 
  <pc group of size 27 with 3 generators> ]
gap> S := PqSupplementInnerAutomorphisms( des[3] );
rec( agAutos := [  ], agOrder := [ 3, 2, 2, 2 ], 
  glAutos := [ Pcgs([ f1, f2, f3 ]) -> [ f1*f2^2, f2, f3 ], 
      Pcgs([ f1, f2, f3 ]) -> [ f1^2, f2, f3^2 ], 
      Pcgs([ f1, f2, f3 ]) -> [ f1^2, f2, f3^2 ] ] )
gap> A := AutomorphismGroupPGroup( des[3] );
rec( 
  agAutos := [ Pcgs([ f1, f2, f3 ]) -> [ f1^2, f2, f3^2 ], 
      Pcgs([ f1, f2, f3 ]) -> [ f1*f2^2, f2, f3 ], 
      Pcgs([ f1, f2, f3 ]) -> [ f1*f3, f2, f3 ], 
      Pcgs([ f1, f2, f3 ]) -> [ f1, f2*f3, f3 ] ], agOrder := [ 2, 3, 3, 3 ], 
  glAutos := [  ], glOper := [  ], glOrder := 1, 
  group := <pc group of size 27 with 3 generators>, 
  one := IdentityMapping( <pc group of size 27 with 3 generators> ), 
  size := 54 )

Typing: PqExample( "PqSupplementInnerAutomorphisms" ); runs the above example in GAP (see PqExample (3.4-4)).

Note that by also including PqStart as a second argument to PqExample one can see how it is possible, with the aid of PqSetPQuotientToGroup (see PqSetPQuotientToGroup (5.3-7)), to do the equivalent computations with the interactive versions of Pq and PqDescendants and a single pq process (recall pq is the name of the external C program).

4.4-3 PqList
‣ PqList( filename: [SubList := sub] )( function )

reads a file with name filename (a string) and returns the list L of pc groups (or with option SubList a sublist of L or a single pc group in L) defined in that file. If the option SubList is passed and has the value sub, then it has the same meaning as for PqDescendants, i.e. if sub is an integer then PqList returns L[sub]; otherwise, if sub is a list of integers PqList returns Sublist(L, sub ).

Both PqList and SavePqList (see SavePqList (4.4-4)) can be used to save and restore a list of descendants (see PqDescendants (4.4-1)).

4.4-4 SavePqList
‣ SavePqList( filename, list )( function )

writes a list of descendants list to a file with name filename (a string).

SavePqList and PqList (see PqList (4.4-3)) can be used to save and restore, respectively, the results of PqDescendants (see PqDescendants (4.4-1)).

 [Top of Book]  [Contents]   [Previous Chapter]   [Next Chapter] 
Goto Chapter: Top 1 2 3 4 5 6 7 A Bib Ind

generated by GAPDoc2HTML

anupq-3.3.3/doc/interact.xml0000644000175100017510000027546715111342310015366 0ustar runnerrunner Interactive ANUPQ functions Here we describe the interactive functions defined by the &ANUPQ; package, i.e. the functions that manipulate and initiate interactive &ANUPQ; processes. These are functions that extract information via a dialogue with a running pq process (process used in the UNIX sense). Occasionally, a user needs the next step; the functions provided in this chapter make use of data from previous steps retained by the pq program, thus allowing the user to interact with the pq program like one can when one uses the pq program as a stand-alone (see guide.dvi in the standalone-doc directory).

An interactive &ANUPQ; process is initiated by PqStart and terminated via PqQuit; these functions are described in ection .

Each interactive &ANUPQ; function that manipulates an already started interactive &ANUPQ; process, has a form where the first argument is the integer i returned by the initiating PqStart command, and a second form with one argument fewer (where the integer i is discovered by a default mechanism, namely by determining the least integer i for which there is a currently active interactive &ANUPQ; process). We will thus commonly say that for the ith (or default) interactive &ANUPQ; process a certain function performs a given action. In each case, it is an error if i is not the index of an active interactive process, or there are no current active interactive processes.

Notes: The global method of passing options (via PushOptions), should not be used with any of the interactive functions. In fact, the OptionsStack should be empty at the time any of the interactive functions is called.

On quitting &GAP;, PqQuitAll(); is executed, which terminates all active interactive &ANUPQ; processes. If &GAP; is killed without quitting, before all interactive &ANUPQ; processes are terminated, zombie processes (still living child processes whose parents have died), may result. Since zombie processes do consume resources, in such an event, the responsible computer user should seek out and terminate those zombie processes (e.g. on Linux: ps xw | grep pq gives you information on the pq processes corresponding to any interactive &ANUPQ; processes started in a &GAP; session; you can then do kill N for each number N appearing in the first column of this output).

Starting and Stopping Interactive ANUPQ Processes activate an iostream for an interactive &ANUPQ; process (i.e. PqStart starts up a pq process and opens a &GAP; iostream to talk to that process) and returns an integer i that can be used to identify that process. The argument G should be an fp group or pc group that the user intends to manipulate using interactive &ANUPQ; functions. If the function is called without specifying G, a group can be read in by using the function PqRestorePcPresentation (see ). If PqStart is given an integer argument workspace, then the pq program is started up with a workspace (an integer array) of size workspace (i.e. 4 \times workspace bytes in a 32-bit environment); otherwise, the pq program sets a default workspace of 10000000.

The only options currently recognised by PqStart are Prime, Exponent and Relators (see Chapter  for detailed descriptions of these options) and if provided they are essentially global for the interactive &ANUPQ; process, except that any interactive function interacting with the process and passing new values for these options will over-ride the global values. closes the stream of the ith or default interactive &ANUPQ; process and unbinds its ANUPQData.io record.

Note: It can happen that the pq process, and hence the &GAP; iostream assigned to communicate with it, can die, e.g. by the user typing a Ctrl-C while the pq process is engaged in a long calculation. IsPqProcessAlive (see ) is provided to check the status of the &GAP; iostream (and hence the status of the pq process it was communicating with). is provided as a convenience, to terminate all active interactive &ANUPQ; processes with a single command. It is equivalent to executing PqQuit(i) for all active interactive &ANUPQ; processes i (see ).

Interactive ANUPQ Process Utility Functions With argument i, which must be a positive integer, PqProcessIndex returns i if it corresponds to an active interactive process, or raises an error. With no arguments it returns the default active interactive process or returns fail and emits a warning message to Info at InfoANUPQ or InfoWarning level 1.

Note: Essentially, an interactive &ANUPQ; process i is active if ANUPQData.io[i] is bound (i.e. we still have some data telling us about it). Also see . returns the list of integer indices of all active interactive &ANUPQ; processes (see  for the meaning of active). return true if the &GAP; iostream of the ith (or default) interactive &ANUPQ; process started by PqStart is alive (i.e. can still be written to), or false, otherwise. (See the notes for  and .)

interruption If the user does not yet have a gap> prompt then usually the pq program is still away doing something and an &ANUPQ; interface function is still waiting for a reply. Typing a Ctrl-C (i.e. holding down the Ctrl key and typing c) will stop the waiting and send &GAP; into a break-loop, from which one has no option but to quit;. The typing of Ctrl-C, in such a circumstance, usually causes the stream of the interactive &ANUPQ; process to die; to check this we provide IsPqProcessAlive (see ).

The &GAP; iostream of an interactive &ANUPQ; process will also die if the pq program has a segmentation fault. We do hope that this never happens to you, but if it does and the failure is reproducible, then it's a bug and we'd like to know about it. Please read the README that comes with the &ANUPQ; package to find out what to include in a bug report and who to email it to.

Interactive Versions of Non-interactive ANUPQ Functions return, for the fp or pc group (let us call it F), of the ith or default interactive &ANUPQ; process, the p-quotient of F specified by options, as a pc group; F must previously have been given (as first argument) to PqStart to start the interactive &ANUPQ; process (see ) or restored from file using the function PqRestorePcPresentation (see ). Following the colon options is a selection of the options listed for the non-interactive Pq function (see ), separated by commas like record components (see Section  in the &GAP; Reference Manual), except that the options SetupFile or PqWorkspace are ignored by the interactive Pq, and RedoPcp is an option only recognised by the interactive Pq i.e. the following options are recognised by the interactive Pq function: Prime := poption Prime ClassBound := noption ClassBound Exponent := noption Exponent Relators := relsoption Relators Metabelianoption Metabelian Identities := funcsoption Identities GroupName := nameoption GroupName OutputLevel := noption OutputLevel RedoPcpoption RedoPcp Detailed descriptions of the above options may be found in Chapter .

As a minimum the Pq function must have a value for the Prime option, though Prime need not be passed again in the case it has previously been provided, e.g. to PqStart (see ) when starting the interactive process.

The behaviour of the interactive Pq function depends on the current state of the pc presentation stored by the pq program: If no pc presentation has yet been computed (the case immediately after the PqStart call initiating the process) then the quotient group of the input group of the process of largest lower exponent-p class bounded by the value of the ClassBound option (see ) is returned. If the current pc presentation of the process was determined by a previous call to Pq or PqEpimorphism, and the current call has a larger value ClassBound then the class is extended as much as is possible and the quotient group of the input group of the process of the new lower exponent-p class is returned. If the current pc presentation of the process was determined by a previous call to PqPCover then a consistent pc presentation of a quotient for the current class is determined before proceeding as in 2. If the RedoPcp option is supplied the current pc presentation is scrapped, all options must be re-supplied (in particular, Prime must be supplied) and then the Pq function proceeds as in 1. See Section  for the attributes and property NuclearRank, MultiplicatorRank and IsCapable which may be applied to the group returned by Pq.

The following is one of the examples for the non-interactive Pq redone with the interactive version. Also, we set the option OutputLevel to 1 (see ), in order to see the orders of the quotients of all the classes determined, and we set the InfoANUPQ level to 2 (see ), so that we catch the timing information. F := FreeGroup("a", "b");; a := F.1;; b := F.2;; gap> G := F / [a^4, b^4]; gap> PqStart(G); 1 gap> SetInfoLevel(InfoANUPQ, 2); #To see timing information gap> Pq(: Prime := 2, ClassBound := 3, OutputLevel := 1 ); #I Lower exponent-2 central series for [grp] #I Group: [grp] to lower exponent-2 central class 1 has order 2^2 #I Group: [grp] to lower exponent-2 central class 2 has order 2^5 #I Group: [grp] to lower exponent-2 central class 3 has order 2^8 #I Computation of presentation took 0.00 seconds ]]> return, for the fp or pc group (let us call it F), of the ith or default interactive &ANUPQ; process, an epimorphism from F onto the p-quotient of F specified by options; F must previously have been given (as first argument) to PqStart to start the interactive &ANUPQ; process (see ). Since the underlying interactions with the pq program effected by the interactive PqEpimorphism are identical to those effected by the interactive Pq, everything said regarding the requirements and behaviour of the interactive Pq function (see ) is also the case for the interactive PqEpimorphism.

Note: See Section  for the attributes and property NuclearRank, MultiplicatorRank and IsCapable which may be applied to the image group of the epimorphism returned by PqEpimorphism. return, for the fp or pc group of the ith or default interactive &ANUPQ; process, the p-covering group of the p-quotient Pq(i : options) or Pq(: options), modulo the following: If no pc presentation has yet been computed (the case immediately after the PqStart call initiating the process) and the group F of the process is already a p-group, in the sense that HasIsPGroup(F) and IsPGroup(F) is true, then Prime defaults to PrimePGroup(F), if not supplied and HasPrimePGroup(F) = true; and ClassBound defaults to PClassPGroup(F) if HasPClassPGroup(F) = true if not supplied, or to the usual default of 63, otherwise. If a pc presentation has been computed and none of options is RedoPcp or if no pc presentation has yet been computed but 1. does not apply then PqPCover(i : options); is equivalent to:

If the RedoPcp option is supplied the current pc presentation is scrapped, and PqPCover proceeds as in 1. or 2. but without the RedoPcp option. automorphismsof p-groups return, for the ith or default interactive &ANUPQ; process, the p-quotient of the group F of the process, specified by options, as an fp group which has a standard presentation. Here options is a selection of the options from the following list (see Chapter  for detailed descriptions); this list is the same as for the non-interactive version of PqStandardPresentation except for the omission of options SetupFile and PqWorkspace (see ). Prime := poption Prime pQuotient := Qoption pQuotient ClassBound := noption ClassBound Exponent := noption Exponent Metabelianoption Metabelian GroupName := nameoption GroupName OutputLevel := noption OutputLevel StandardPresentationFile := filenameoption StandardPresentationFile Unless F is a pc p-group, or the option Prime has been passed to a previous interactive function for the process to compute a p-quotient for F, the user must supply either the option Prime or the option pQuotient (if both Prime and pQuotient are supplied, the prime p is determined by applying PrimePGroup (see  in the Reference Manual) to the value of pQuotient).

Taking one of the examples for the non-interactive version of StandardPresentation (see ) that required two separate calls to the pq program, we now show how it can be done by setting up a dialogue with just the one pq process, using the interactive version of StandardPresentation: F4 := FreeGroup( "a", "b", "c", "d" );; gap> a := F4.1;; b := F4.2;; c := F4.3;; d := F4.4;; gap> G4 := F4 / [ b^4, b^2 / Comm(Comm (b, a), a), d^16, > a^16 / (c * d), b^8 / (d * c^4) ]; gap> SetInfoLevel(InfoANUPQ, 1); #Only essential Info please gap> procId := PqStart(G4);; #Start a new interactive process for a new group gap> K := Pq( procId : Prime := 2, ClassBound := 1 ); gap> StandardPresentation( procId : pQuotient := K, ClassBound := 14 ); ]]> Notes

In contrast to the function Pq (see ) which returns a pc group, PqStandardPresentation or StandardPresentation returns an fp group. This is because the output is mainly used for isomorphism testing for which an fp group is enough. However, the presentation is a polycyclic presentation and if you need to do any further computation with this group (e.g. to find the order) you can use the function PcGroupFpGroup (see  in the &GAP; Reference Manual) to form a pc group.

If the user does not supply a p-quotient Q via the pQuotient option, and the prime p is either supplied, stored, or F is a pc p-group, then a p-quotient Q is computed. (The value of the prime p is stored if passed initially to PqStart or to a subsequent interactive process.) Note that a stored value for pQuotient (from a prior call to Pq) does not have precedence over a value for the prime p. If the user does supply a p-quotient Q via the pQuotient option, the package &AutPGrp; is called to compute the automorphism group of Q; an error will occur that asks the user to install the package &AutPGrp; if the automorphism group cannot be computed.

If any of the interactive functions PqStandardPresentation, StandardPresentation, EpimorphismPqStandardPresentation or EpimorphismStandardPresentation has been called previously for an interactive process, a subsequent call to any of these functions for the same process returns the previously computed value. Note that all these functions compute both an epimorphism and an fp group and store the results in the SPepi and SP fields of the data record associated with the process. See the example for the interactive EpimorphismStandardPresentation ().

The attributes and property NuclearRank, MultiplicatorRank and IsCapable are set for the group returned by PqStandardPresentation or StandardPresentation (see Section ). Each of the above functions accepts the same arguments and options as the interactive form of StandardPresentation (see ) and returns an epimorphism from the fp or pc group F of the ith or default interactive &ANUPQ; process onto the finitely presented group given by a standard presentation, i.e. if S is the standard presentation computed for the p-quotient of F by StandardPresentation then EpimorphismStandardPresentation returns the epimorphism from F to the group with presentation S. The group F must have been given (as first argument) to PqStart to start the interactive &ANUPQ; process (see ).

Taking our earlier non-interactive example (see ) and modifying it a little, we illustrate, as for the interactive StandardPresentation (see ), how something that required two separate calls to the pq program can now be achieved with a dialogue with just one pq process. Also, observe that calls to one of the standard presentation functions (as mentioned in the notes of ) computes and stores both an fp group with a standard presentation and an epimorphism; subsequent calls to a standard presentation function for the same process simply return the appropriate stored value. F := FreeGroup(6, "F");; gap> x := F.1;; y := F.2;; z := F.3;; w := F.4;; a := F.5;; b := F.6;; gap> R := [x^3 / w, y^3 / w * a^2 * b^2, w^3 / b, > Comm (y, x) / z, Comm (z, x), Comm (z, y) / a, z^3 ]; [ F1^3*F4^-1, F2^3*F4^-1*F5^2*F6^2, F4^3*F6^-1, F2^-1*F1^-1*F2*F1*F3^-1, F3^-1*F1^-1*F3*F1, F3^-1*F2^-1*F3*F2*F5^-1, F3^3 ] gap> Q := F / R; gap> procId := PqStart( Q );; gap> G := Pq( procId : Prime := 3, ClassBound := 3 ); gap> lev := InfoLevel(InfoANUPQ);; # Save current InfoANUPQ level gap> SetInfoLevel(InfoANUPQ, 2); # To see computation times gap> # It is not necessary to pass the `Prime' option to gap> # `EpimorphismStandardPresentation' since it was previously gap> # passed to `Pq': gap> phi := EpimorphismStandardPresentation( 3 : ClassBound := 3 ); #I Class 1 3-quotient and its 3-covering group computed in 0.00 seconds #I Order of GL subgroup is 48 #I No. of soluble autos is 0 #I dim U = 1 dim N = 3 dim M = 3 #I nice stabilizer with perm rep #I Computing standard presentation for class 2 took 0.00 seconds #I Computing standard presentation for class 3 took 0.01 seconds [ F1, F2, F3, F4, F5, F6 ] -> [ f1*f2^2*f3*f4^2*f5^2, f1*f2*f3*f5, f3^2, f4*f6^2, f5, f6 ] gap> # Image of phi should be isomorphic to G ... gap> # let's check the order is correct: gap> Size( Image(phi) ); 729 gap> # `StandardPresentation' and `EpimorphismStandardPresentation' gap> # behave like attributes, so no computation is done when gap> # either is called again for the same process ... gap> StandardPresentation( 3 : ClassBound := 3 ); gap> # No timing data was Info-ed since no computation was done gap> SetInfoLevel(InfoANUPQ, lev); # Restore previous InfoANUPQ level ]]> A very similar (essential details are the same) example to the above may be executed live, by typing: PqExample( "EpimorphismStandardPresentation-i" );.

Note: The notes for PqStandardPresentation or StandardPresentation (see ) apply also to EpimorphismPqStandardPresentation or EpimorphismStandardPresentation except that their return value is an epimorphism onto an fp group, i.e. one should interpret the phrase returns an fp group as returns an epimorphism onto an fp group etc. return for the pc group G of the ith or default interactive &ANUPQ; process, which must be of prime power order with a confluent pc presentation (see  in the &GAP; Reference Manual), a list of proper descendants (pc groups) of G. The group G is usually given as first argument to PqStart when starting the interactive &ANUPQ; process (see ). Alternatively, one may initiate the process with an fp group, use Pq interactively (see ) to create a pc group and use PqSetPQuotientToGroup (see ), which involves no computation, to set the pc group returned by Pq as the group of the process. Note that repeating a call to PqDescendants for the same interactive &ANUPQ; process simply returns the list of descendants originally calculated; a warning is emitted at InfoANUPQ level 1 reminding you of this should you do this.

After the colon, options a selection of the options listed for the non-interactive PqDescendants function (see ), should be given, separated by commas like record components (see Section  in the &GAP; Reference Manual), except that the options SetupFile or PqWorkspace are ignored by the interactive PqDescendants, i.e. the following options are recognised by the interactive PqDescendants function: ClassBound := noption ClassBound Relators := relsoption Relators OrderBound := noption OrderBound StepSize := n, StepSize := list option StepSize RankInitialSegmentSubgroups := noption RankInitialSegmentSubgroups SpaceEfficientoption SpaceEfficient CapableDescendantsoption CapableDescendants AllDescendants := falseoption AllDescendants Exponent := noption Exponent Metabelianoption Metabelian GroupName := nameoption GroupName SubList := suboption SubList BasicAlgorithmoption BasicAlgorithm CustomiseOutput := recoption CustomiseOutput Notes: The function PqDescendants uses the automorphism group of G which it computes via the package &AutPGrp; if the automorphism group of G is not already present. If &AutPGrp; is not installed an error may be raised. If the automorphism group of G is insoluble the pq program will call &GAP; together with the &AutPGrp; package for certain orbit-stabilizer calculations.

The attributes and property NuclearRank, MultiplicatorRank and IsCapable are set for each group of the list returned by PqDescendants (see Section ).

Let us now repeat the examples previously given for the non-interactive PqDescendants, but this time with the interactive version of PqDescendants: F := FreeGroup( "a", "b" );; a := F.1;; b := F.2;; gap> G := PcGroupFpGroup( F / [ a^2, b^2, Comm(b, a) ] ); gap> procId := PqStart(G);; gap> des := PqDescendants( procId : OrderBound := 6, ClassBound := 5 );; gap> Length(des); 83 gap> List(des, Size); [ 8, 8, 8, 16, 16, 16, 32, 16, 16, 16, 16, 16, 32, 32, 64, 64, 32, 32, 32, 32, 32, 32, 32, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 32, 32, 32, 32, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 32, 32, 32, 32, 32, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64 ] gap> List(des, d -> Length( PCentralSeries( d, 2 ) ) - 1 ); [ 2, 2, 2, 2, 2, 2, 2, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 5, 5, 5, 5, 5 ] ]]> In the second example we compute all capable descendants of order 27 of the elementary abelian group of order 9. F := FreeGroup( 2, "g" );; gap> G := PcGroupFpGroup( F / [ F.1^3, F.2^3, Comm(F.1, F.2) ] ); gap> procId := PqStart(G);; gap> des := PqDescendants( procId : OrderBound := 3, ClassBound := 2, > CapableDescendants ); [ , ] gap> List(des, d -> Length( PCentralSeries( d, 3 ) ) - 1 ); [ 2, 2 ] gap> # For comparison let us now compute all proper descendants gap> # (using the non-interactive Pq function) gap> PqDescendants( G : OrderBound := 3, ClassBound := 2); [ , , ] ]]> In the third example, we compute all proper capable descendants of the elementary abelian group of order 5^2 which have exponent-5 class at most 3, exponent 5, and are metabelian. F := FreeGroup( 2, "g" );; gap> G := PcGroupFpGroup( F / [ F.1^5, F.2^5, Comm(F.2, F.1) ] ); gap> procId := PqStart(G);; gap> des := PqDescendants( procId : Metabelian, ClassBound := 3, > Exponent := 5, CapableDescendants ); [ , , ] gap> List(des, d -> Length( PCentralSeries( d, 5 ) ) - 1 ); [ 2, 3, 3 ] gap> List(des, d -> Length( DerivedSeries( d ) ) ); [ 3, 3, 3 ] gap> List(des, d -> Maximum( List( d, Order ) ) ); [ 5, 5, 5 ] ]]> for the ith or default interactive &ANUPQ; process, set the p-quotient previously computed by the interactive Pq function (see ) to be the group of the process. This function is supplied to enable the computation of descendants of a p-quotient that is already known to the pq program, via the interactive PqDescendants function (see ), thus avoiding the need to re-submit it and have the pq program recompute it.

Note: See the function PqPGSetDescendantToPcp () for a mechanism to make (the p-cover of) a particular descendants the current group of the process.

The following example of the usage of PqSetPQuotientToGroup, which is essentially equivalent to what is obtained by running PqExample("PqDescendants-1-i");, redoes the first example of (which computes the descendants of the Klein four group). F := FreeGroup( "a", "b" ); gap> procId := PqStart( F : Prime := 2 );; gap> Pq( procId : ClassBound := 1 ); gap> PqSetPQuotientToGroup( procId ); gap> des := PqDescendants( procId : OrderBound := 6, ClassBound := 5 );; gap> Length(des); 83 gap> List(des, Size); [ 8, 8, 8, 16, 16, 16, 32, 16, 16, 16, 16, 16, 32, 32, 64, 64, 32, 32, 32, 32, 32, 32, 32, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 32, 32, 32, 32, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 32, 32, 32, 32, 32, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64 ] gap> List(des, d -> Length( PCentralSeries( d, 2 ) ) - 1 ); [ 2, 2, 2, 2, 2, 2, 2, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 5, 5, 5, 5, 5 ] ]]>

Low-level Interactive ANUPQ functions based on menu items of the pq program The pq program has 5 menus, the details of which the reader will not normally need to know, but if she wishes to know the details they may be found in the standalone manual: guide.dvi. Both guide.dvi and the pq program refer to the items of these 5 menus as options, which do not correspond in any way to the options used by any of the &GAP; functions that interface with the pq program.

Warning: The commands provided in this section are intended to provide something like the interactive functionality one has when running the standalone, from within &GAP;. The pq standalone (in particular, its advanced menus) assumes some expertise of the user; doing the wrong thing can cause the program to crash. While a number of safeguards have been provided in the &GAP; interface to the pq program, these are not foolproof, and the user should exercise care and ensure pre-requisites of the various commands are met.

General commands The following commands either use a menu item from whatever menu is current for the pq program, or have general application and are not associated with just one menu item of the pq program. for the ith or default interactive &ANUPQ; process, return the number of pc generators of the lower exponent p-class quotient of the group currently determined by the process. This also applies if the pc presentation is not consistent. for the ith or default interactive &ANUPQ; process, return an integer pair [p, n] where p is a prime and n is the number of pc generators (see ) in the pc presentation of the quotient group currently determined by the process. If this presentation is consistent, then p^n is the order of the quotient group. Otherwise (if tails have been added but the necessary consistency checks, relation collections, exponent law checks and redundant generator eliminations have not yet been done), p^n is an upper bound for the order of the group. for the ith or default interactive &ANUPQ; process, return p^n where [p, n] is the pair as returned by PqFactoredOrder (see ). for the ith or default interactive &ANUPQ; process, return the lower exponent p-class of the quotient group currently determined by the process. for the ith or default interactive &ANUPQ; process, return the weight of the jth pc generator of the lower exponent p-class quotient of the group currently determined by the process, or fail if there is no such numbered pc generator. for the ith or default interactive &ANUPQ; process, return the group whose pc presentation is determined by the process as a &GAP; pc group (either a lower exponent p-class quotient of the start group or the p-cover of such a quotient).

Notes: See Section  for the attributes and property NuclearRank, MultiplicatorRank and IsCapable which may be applied to the group returned by PqCurrentGroup. for the ith or default interactive &ANUPQ; process, direct the pq program to display the pc presentation of the lower exponent p-class quotient of the group currently determined by the process.

Except if the last command communicating with the pq program was a p-group generation command (for which there is only a verbose output level), to set the amount of information this command displays you may wish to call PqSetOutputLevel first (see ), or equivalently pass the option OutputLevel (see ).

Note: For those familiar with the pq program, PqDisplayPcPresentation performs menu item 4 of the current menu of the pq program. for the ith or default interactive &ANUPQ; process, direct the pq program to set the output level of the pq program to lev.

Note: For those familiar with the pq program, PqSetOutputLevel performs menu item 5 of the main (or advanced) p-Quotient menu, or the Standard Presentation menu. for the ith or default interactive &ANUPQ; process, invoke the evaluation of identities defined by the Identities option, and eliminate any redundant pc generators formed. Since a previous value of Identities is saved in the data record of the process, it is unnecessary to pass the Identities if set previously.

Note: This function is mainly implemented at the &GAP; level. It does not correspond to a menu item of the pq program.

Commands from the Main p-Quotient menu for the ith or default interactive &ANUPQ; process, direct the pq program to compute the pc presentation of the quotient (determined by options) of the group of the process, which for process i is stored as ANUPQData.io[i].group.

The possible options are the same as for the interactive Pq (see ) function, except for RedoPcp (which, in any case, would be superfluous), namely: Prime, ClassBound, Exponent, Relators, GroupName, Metabelian, Identities and OutputLevel (see Chapter  for a detailed description for these options). The option Prime is required unless already provided to PqStart.

Notes

The pc presentation is held by the pq program. In contrast to Pq (see ), no &GAP; pc group is returned; see PqCurrentGroup () if you need the corresponding &GAP; pc group.

PqPcPresentation(i: options); is roughly equivalent to the following sequence of low-level commands:

where opts is options except with the ClassBound option set to 1, and class is either the maximum class of a p-quotient of the group of the process or the user-supplied value of the option ClassBound (whichever is smaller). If the Identities option has been set, both the first PqPcPresentation class 1 call and the PqNextClass calls invoke PqEvaluateIdentities(i); as their final step.

For those familiar with the pq program, PqPcPresentation performs menu item 1 of the main p-Quotient menu. for the ith or default interactive &ANUPQ; process, direct the pq program to save the pc presentation previously computed for the quotient of the group of that process to the file with name filename. If the first character of the string filename is not /, filename is assumed to be the path of a writable file relative to the directory in which &GAP; was started. A saved file may be restored by PqRestorePcPresentation (see ).

Note: For those familiar with the pq program, PqSavePcPresentation performs menu item 2 of the main p-Quotient menu. for the ith or default interactive &ANUPQ; process, direct the pq program to restore the pc presentation previously saved to filename, by PqSavePcPresentation (see ). If the first character of the string filename is not /, filename is assumed to be the path of a readable file relative to the directory in which &GAP; was started.

Note: For those familiar with the pq program, PqRestorePcPresentation performs menu item 3 of the main p-Quotient menu. for the ith or default interactive &ANUPQ; process, direct the pq program to calculate the next class of ANUPQData.io[i].group.

option QueueFactor PqNextClass accepts the option QueueFactor (see also ) which should be a positive integer if automorphisms have been previously supplied. If the pq program requires a queue factor and none is supplied via the option QueueFactor a default of 15 is taken.

Notes

The single command: PqNextClass(i); is equivalent to executing

If the Identities option is set the PqEliminateRedundantGenerators(i); step is essentially replaced by PqEvaluateIdentities(i); (which invokes its own elimination of redundant generators).

For those familiar with the pq program, PqNextClass performs menu item 6 of the main p-Quotient menu. for the ith or default interactive &ANUPQ; processi, directi, the pq program to compute the p-covering group of ANUPQData.io[i].group. In contrast to the function PqPCover (see ), this function does not return a &GAP; pc group.

Notes

The single command: PqComputePCover(i); is equivalent to executing

For those familiar with the pq program, PqComputePCover performs menu item 7 of the main p-Quotient menu.
Commands from the Advanced p-Quotient menu for the ith or default interactive &ANUPQ; process, instruct the pq program to do a collection on word, a word in the current pc generators (the form of word required is described below). PqCollect returns the resulting word of the collection as a list of generator number, exponent pairs (the same form as the second allowed input form of word; see below).

The argument word may be input in either of the following ways: word may be a string, where the ith pc generator is represented by xi, e.g. "x3*x2^2*x1". This way is quite versatile as parentheses and left-normed commutators -- using square brackets, in the same way as PqGAPRelators (see ) -- are permitted; word is checked for correct syntax via PqParseWord (see ). Otherwise, word must be a list of generator number, exponent pairs of integers, i.e.  each pair represents a syllable so that [ [3, 1], [2, 2], [1, 1] ] represents the same word as that of the example given for the first allowed form of word. Note: For those familiar with the pq program, PqCollect performs menu item 1 of the Advanced p-Quotient menu. for the ith or default interactive &ANUPQ; process, direct the pq program to solve a * x = b for x, where a and b are words in the pc generators. For the representation of these words see the description of the function PqCollect ().

Note: For those familiar with the pq program, PqSolveEquation performs menu item 2 of the Advanced p-Quotient menu. for the ith or default interactive &ANUPQ; process, instruct the pq program to compute the left normed commutator of the list words of words in the current pc generators raised to the integer power pow, and return the resulting word as a list of generator number, exponent pairs. The form required for each word of words is the same as that required for the word argument of PqCollect (see ). The form of the output word is also the same as for PqCollect.

Note: For those familiar with the pq program, PqCommutator performs menu item 3 of the Advanced p-Quotient menu. for the ith or default interactive &ANUPQ; process, direct the pq program to set up tables for the next class. As as side-effect, after PqSetupTablesForNextClass(i) the value returned by PqPClass(i) will be one more than it was previously.

Note: For those familiar with the pq program, PqSetupTablesForNextClass performs menu item 6 of the Advanced p-Quotient menu. for the ith or default interactive &ANUPQ; process, direct the pq program to compute and add tails of weight weight if weight is in the integer range [2 .. PqPClass(i)] (assuming i is the number of the process, even in the default case) or for all weights if weight = 0.

If weight is non-zero, then tails that introduce new generators for only weight weight are computed and added, and in this case and if weight < PqPClass(i), it is assumed that the tails that introduce new generators for each weight from PqPClass(i) down to weight weight + 1 have already been added. You may wish to call PqSetMetabelian (see ) prior to calling PqTails.

Notes

For its use in the context of finding the next class see ; in particular, a call to PqSetupTablesForNextClass (see ) needs to have been made prior to calling PqTails.

The single command: PqTails(i, weight); is equivalent to

For those familiar with the pq program, PqTails uses menu item 7 of the Advanced p-Quotient menu. for the ith or default interactive &ANUPQ; process, direct the pq program to compute tails of weight weight if weight is in the integer range [2 .. PqPClass(i)] (assuming i is the number of the process, even in the default case) or for all weights if weight = 0. See PqTails () for more details.

Note: For those familiar with the pq program, PqComputeTails uses menu item 7 of the Advanced p-Quotient menu. for the ith or default interactive &ANUPQ; process, direct the pq program to add the tails of weight weight, previously computed by PqComputeTails (see ), if weight is in the integer range [2 .. PqPClass(i)] (assuming i is the number of the process, even in the default case) or for all weights if weight = 0. See PqTails () for more details.

Note: For those familiar with the pq program, PqAddTails uses menu item 7 of the Advanced p-Quotient menu. for the ith or default interactive &ANUPQ; process, do consistency checks for weight weight if weight is in the integer range [3 .. PqPClass(i)] (assuming i is the number of the process) or for all weights if weight = 0, and for type type if type is in the range [1, 2, 3] (see below) or for all types if type = 0. (For its use in the context of finding the next class see .)

The type of a consistency check is defined as follows. PqDoConsistencyChecks(i, weight, type) for weight in [3 .. PqPClass(i)] and the given value of type invokes the equivalent of the following PqDoConsistencyCheck calls (see ): type = 1: PqDoConsistencyCheck(i, a, a, a) checks 2 * PqWeight(i, a) + 1 = weight, for pc generators of index a. type = 2: PqDoConsistencyCheck(i, b, b, a) checks for pc generators of indices b, a satisfyingx both b > a and PqWeight(i, b) + PqWeight(i, a) + 1 = weight. type = 3: PqDoConsistencyCheck(i, c, b, a) checks for pc generators of indices c, b, a satisfying c > b > a and the sum of the weights of these generators equals weight. Notes

PqWeight(i, j) returns the weight of the jth pc generator, for process i (see ).

It is assumed that tails for the given weight (or weights) have already been added (see ).

For those familiar with the pq program, PqDoConsistencyChecks performs menu item 8 of the Advanced p-Quotient menu. for the ith or default interactive &ANUPQ; process, direct the pq program to collect the images of the defining relations of the original fp group of the process, with respect to the current pc presentation, in the context of finding the next class (see ). If the tails operation is not complete then the relations may be evaluated incorrectly.

Note: For those familiar with the pq program, PqCollectDefiningRelations performs menu item 9 of the Advanced p-Quotient menu. for the ith or default interactive &ANUPQ; process, take a user-defined word word in the defining generators of the original presentation of the fp or pc group of the process. Each generator is mapped into the current pc presentation, and the resulting word is collected with respect to the current pc presentation. The result of the collection is returned as a list of generator number, exponent pairs.

The word argument may be input in either of the two ways described for PqCollect (see ).

Note: For those familiar with the pq program, PqCollectDefiningGenerators performs menu item 23 of the Advanced p-Quotient menu. for the ith or default interactive &ANUPQ; process, take a list words of user-defined words in the defining generators of the original presentation of the fp or pc group of the process, and an integer power pow. Each generator is mapped into the current pc presentation. The list words is interpreted as a left-normed commutator which is then raised to pow and collected with respect to the current pc presentation. The result of the collection is returned as a list of generator number, exponent pairs.

Note For those familiar with the pq program, PqCommutatorDefiningGenerators performs menu item 24 of the Advanced p-Quotient menu. for the ith or default interactive &ANUPQ; process, direct the pq program to do exponent checks for weights (inclusively) between the bounds of Bounds or for all weights if Bounds is not given. The value list of Bounds (assuming the interactive process is numbered i) should be a list of two integers low, high satisfying 1 \le low \le high \le PqPClass(i) (see ). If no exponent law has been specified, no exponent checks are performed.

Note: For those familiar with the pq program, PqDoExponentChecks performs menu item 10 of the Advanced p-Quotient menu. for the ith or default interactive &ANUPQ; process, direct the pq program to eliminate redundant generators of the current p-quotient.

Note: For those familiar with the pq program, PqEliminateRedundantGenerators performs menu item 11 of the Advanced p-Quotient menu. for the ith or default interactive &ANUPQ; process, direct the pq program to abandon the current class and revert to the previous class.

Note: For those familiar with the pq program, PqRevertToPreviousClass performs menu item 12 of the Advanced p-Quotient menu. for the ith or default interactive &ANUPQ; process, direct the pq program to set maximal occurrences of the weight 1 generators in the definitions of pcp generators of the group of the process. This can be used to avoid the definition of generators of which one knows for theoretical reasons that they would be eliminated later on.

The argument noccur must be a list of non-negative integers of length the number of weight 1 generators (i.e. the rank of the class 1 p-quotient of the group of the process). An entry of 0 for a particular generator indicates that there is no limit on the number of occurrences for the generator.

Note: For those familiar with the pq program, PqSetMaximalOccurrences performs menu item 13 of the Advanced p-Quotient menu. for the ith or default interactive &ANUPQ; process, direct the pq program to enforce metabelian-ness.

Note: For those familiar with the pq program, PqSetMetabelian performs menu item 14 of the Advanced p-Quotient menu. for the ith or default interactive &ANUPQ; process, direct the pq program to do the consistency check for the pc generators with indices c, b, a which should be non-increasing positive integers, i.e. c \ge b \ge a.

There are 3 types of consistency checks: \begin{array}{rclrl} (a^n)a &=& a(a^n) && {\rm (Type\ 1)} \\ (b^n)a &=& b^{(n-1)}(ba), b(a^n) = (ba)a^{(n-1)} && {\rm (Type\ 2)} \\ c(ba) &=& (cb)a && {\rm (Type\ 3)} \\ \end{array} The reason some people talk about Jacobi relations instead of consistency checks becomes clear when one looks at the consistency check of type 3: \begin{array}{rcl} c(ba) &=& a c[c,a] b[b,a] = acb [c,a][c,a,b][b,a] = \dots \\ (cb)a &=& b c[c,b] a = a b[b,a] c[c,a] [c,b][c,b,a] \\ &=& abc [b,a] [b,a,c] [c,a] [c,b] [c,b,a] = \dots \\ \end{array} Each collection would normally carry on further. But one can see already that no other commutators of weight 3 will occur. After all terms of weight one and weight two have been moved to the left we end up with: \begin{array}{rcl} & &abc [b,a] [c,a] [c,b] [c,a,b] \dots \\ &=&abc [b,a] [c,a] [c,b] [c,b,a] [b,a,c] \dots \\ \end{array} Modulo terms of weight 4 this is equivalent to [c,a,b] [b,c,a] [a,b,c] = 1 which is the Jacobi identity.

See also PqDoConsistencyChecks ().

Note: For those familiar with the pq program, PqDoConsistencyCheck and PqJacobi perform menu item 15 of the Advanced p-Quotient menu. for the ith or default interactive &ANUPQ; process, direct the pq program to do a compaction of its work space. This function is safe to perform only at certain points in time.

Note: For those familiar with the pq program, PqCompact performs menu item 16 of the Advanced p-Quotient menu. for the ith or default interactive &ANUPQ; process, direct the pq program to echelonise the word most recently collected by PqCollect or PqCommutator against the relations of the current pc presentation, and return the number of the generator made redundant or fail if no generator was made redundant. A call to PqCollect (see ) or PqCommutator (see ) needs to be performed prior to using this command.

Note: For those familiar with the pq program, PqEchelonise performs menu item 17 of the Advanced p-Quotient menu. for the ith or default interactive &ANUPQ; process, supply the automorphism data provided by the list mlist of matrices with non-negative integer coefficients. Each matrix in mlist describes one automorphism in the following way. The rows of each matrix correspond to the pc generators of weight one. Each row is the exponent vector of the image of the corresponding weight one generator under the respective automorphism. Note: For those familiar with the pq program, PqSupplyAutomorphisms uses menu item 18 of the Advanced p-Quotient menu. for the ith or default interactive &ANUPQ; process, direct the pq program to extend automorphisms of the p-quotient of the previous class to the p-quotient of the present class.

Note: For those familiar with the pq program, PqExtendAutomorphisms uses menu item 18 of the Advanced p-Quotient menu. for the ith or default interactive &ANUPQ; process, direct the pq program to apply automorphisms; qfac is the queue factor e.g. 15.

Note: For those familiar with the pq program, PqCloseRelations performs menu item 19 of the Advanced p-Quotient menu. for the ith or default interactive &ANUPQ; process, direct the pq program to display the structure for the pcp generators numbered (inclusively) between the bounds of Bounds or for all generators if Bounds is not given. The value list of Bounds (assuming the interactive process is numbered i) should be a list of two integers low, high satisfying 1 \le low \le high \le PqNrPcGenerators(i) (see ). PqDisplayStructure also accepts the option OutputLevel (see ).

Explanation of output

New generators are defined as commutators of previous generators and generators of class 1 or as p-th powers of generators that have themselves been defined as p-th powers. A generator is never defined as p-th power of a commutator.

Therefore, there are two cases: all the numbers on the righthand side are either the same or they differ. Below, gi refers to the ith defining generator. If the righthand side numbers are all the same, then the generator is a p-th power (of a p-th power of a p-th power, etc.). The number of repeated digits say how often a p-th power has to be taken.

In the following example, the generator number 31 is the eleventh power of generator 17 which in turn is an eleventh power and so on:

\begintt #I 31 is defined on 17^11 = 1 1 1 1 1 \endtt So generator 31 is obtained by taking the eleventh power of generator 1 five times. If the numbers are not all the same, the generator is defined by a commutator. If the first two generator numbers differ, the generator is defined as a left-normed commutator of the weight one generators, e.g.

\begintt #I 19 is defined on [11, 1] = 2 1 1 1 1 \endtt Here, generator 19 is defined as the commutator of generator 11 and generator 1 which is the same as the left-normed commutator [x2, x1, x1, x1, x1]. One can check this by tracing back the definition of generator 11 until one gets to a generator of class 1. If the first two generator numbers are identical, then the left most component of the left-normed commutator is a p-th power, e.g.

\begintt #I 25 is defined on [14, 1] = 1 1 2 1 1 \endtt

In this example, generator 25 is defined as commutator of generator 14 and generator 1. The left-normed commutator is [(x1^{11})^{11}, x2, x1, x1] Again, this can be verified by tracing back the definitions. Note: For those familiar with the pq program, PqDisplayStructure performs menu item 20 of the Advanced p-Quotient menu. for the ith or default interactive &ANUPQ; process, direct the pq program to display the automorphism actions on the pcp generators numbered (inclusively) between the bounds of Bounds or for all generators if Bounds is not given. The value list of Bounds (assuming the interactive process is numbered i) should be a list of two integers low, high satisfying 1 \le low \le high \le PqNrPcGenerators(i) (see ). PqDisplayStructure also accepts the option OutputLevel (see ).

Note: For those familiar with the pq program, PqDisplayAutomorphisms performs menu item 21 of the Advanced p-Quotient menu. for the ith or default interactive &ANUPQ; process, direct the pq program to write a pc presentation of a previously-computed quotient of the group of that process, to the file with name filename. Here the group of a process is the one given as first argument when PqStart was called to initiate that process (for process i the group is stored as ANUPQData.io[i].group). If the first character of the string filename is not /, filename is assumed to be the path of a writable file relative to the directory in which &GAP; was started. If a pc presentation has not been previously computed by the pq program, then pq is called to compute it first, effectively invoking PqPcPresentation (see ).

Note: For those familiar with the pq program, PqPcWritePresentation performs menu item 25 of the Advanced p-Quotient menu.

Commands from the Standard Presentation menu for the ith or default interactive &ANUPQ; process, directs the pq program to compute for the group of that process a pc presentation up to the p-quotient of maximum class or the value of the option ClassBound and the p-cover of that quotient, and sets up tabular information required for computation of a standard presentation. Here the group of a process is the one given as first argument when PqStart was called to initiate that process (for process i the group is stored as ANUPQData.io[i].group).

The possible options are Prime, ClassBound, Relators, Exponent, Metabelian and OutputLevel (see Chapter  for detailed descriptions of these options). The option Prime is normally determined via PrimePGroup, and so is not required unless the group doesn't know it's a p-group and HasPrimePGroup returns false.

Note: For those familiar with the pq program, PqSPComputePcpAndPCover performs option 1 of the Standard Presentation menu. for the ith or default interactive &ANUPQ; process, inputs data given by options to compute a standard presentation for the group of that process. If argument mlist is given it is assumed to be the automorphism group data required. Otherwise it is assumed that a call to either Pq (see ) or PqEpimorphism (see ) has generated a p-quotient and that &GAP; can compute its automorphism group from which the necessary automorphism group data can be derived. The group of the process is the one given as first argument when PqStart was called to initiate the process (for process i the group is stored as ANUPQData.io[i].group and the p-quotient if existent is stored as ANUPQData.io[i].pQuotient). If mlist is not given and a p-quotient of the group has not been previously computed a class 1 p-quotient is computed.

PqSPStandardPresentation accepts three options, all optional: ClassBound := noption ClassBound PcgsAutomorphismsoption PcgsAutomorphisms StandardPresentationFile := filenameoption StandardPresentationFile If ClassBound is omitted it defaults to 63.

Detailed descriptions of the above options may be found in Chapter .

Note: For those familiar with the pq program, PqSPPcPresentation performs menu item 2 of the Standard Presentation menu. for the ith or default interactive &ANUPQ; process, directs the pq program to save the standard presentation previously computed for the group of that process to the file with name filename, where the group of a process is the one given as first argument when PqStart was called to initiate that process. If the first character of the string filename is not /, filename is assumed to be the path of a writable file relative to the directory in which &GAP; was started.

Note: For those familiar with the pq program, PqSPSavePresentation performs menu item 3 of the Standard Presentation menu. for the ith or default interactive &ANUPQ; process, direct the pq program to compare the presentations in the files with names f1 and f2 and returns true if they are identical and false otherwise. For each of the strings f1 and f2, if the first character is not a / then it is assumed to be the path of a readable file relative to the directory in which &GAP; was started.

Notes

The presentations in files f1 and f2 must have been generated by the pq program but they do not need to be standard presentations. If If the presentations in files f1 and f2 have been generated by PqSPStandardPresentation (see ) then a false response from PqSPCompareTwoFilePresentations says the groups defined by those presentations are not isomorphic.

For those familiar with the pq program, PqSPCompareTwoFilePresentations performs menu item 6 of the Standard Presentation menu. for the ith or default interactive &ANUPQ; process, direct the pq program to compute the isomorphism mapping from the p-group of the process to its standard presentation. This function provides a description only; for a &GAP; object, use EpimorphismStandardPresentation (see ).

Note: For those familiar with the pq program, PqSPIsomorphism performs menu item 8 of the Standard Presentation menu.

Commands from the Main p-Group Generation menu Note that the p-group generation commands can only be applied once the pq program has produced a pc presentation of some quotient group of the group of the process. for the ith or default interactive &ANUPQ; process, supply the pq program with the automorphism group data needed for the current quotient of the group of that process (for process i the group is stored as ANUPQData.io[i].group). For a description of the format of mlist see . The options possible are NumberOfSolubleAutomorphisms and RelativeOrders. (Detailed descriptions of these options may be found in Chapter .)

If mlist is omitted, the automorphism data is determined from the group of the process which must have been a p-group in pc presentation.

Note: For those familiar with the pq program, PqPGSupplyAutomorphisms performs menu item 1 of the main p-Group Generation menu. for the ith or default interactive &ANUPQ; process, direct the pq program to compute the extensions of the automorphisms of the p-quotient of the previous class to the p-quotient of the current class. You may wish to set the InfoLevel of InfoANUPQ to 2 (or more) in order to see the output from the pq program (see ).

Note: For those familiar with the pq program, PqPGExtendAutomorphisms performs menu item 2 of the main or advanced p-Group Generation menu. for the ith or default interactive &ANUPQ; process, direct the pq program to construct descendants prescribed by options, and return the number of descendants constructed (compare function  which returns the list of descendants). The options possible are ClassBound, OrderBound, StepSize, PcgsAutomorphisms, RankInitialSegmentSubgroups, SpaceEfficient, CapableDescendants, AllDescendants, Exponent, Metabelian, BasicAlgorithm, CustomiseOutput. (Detailed descriptions of these options may be found in Chapter .)

PqPGConstructDescendants requires that the pq program has previously computed a pc presentation and a p-cover for a p-quotient of some class of the group of the process.

Note: For those familiar with the pq program, PqPGConstructDescendants performs menu item 5 of the main p-Group Generation menu. for the ith or default interactive &ANUPQ; process, direct the pq program to restore group n of class cls from a temporary file, where cls and n are positive integers, or the group stored in name. PqPGSetDescendantToPcp and PqPGRestoreDescendantFromFile are synonyms; they make sense only after a prior call to construct descendants by say PqPGConstructDescendants (see ) or the interactive PqDescendants (see ). In the Filename option forms, the option defaults to the last filename in which a presentation was stored by the pq program.

Notes

Since the PqPGSetDescendantToPcp and PqPGRestoreDescendantFromFile are intended to be used in calculation of further descendants the pq program computes the p-cover of the restored descendant. Hence, PqCurrentGroup used immediately after one of these commands returns the p-cover of the restored descendant rather than the descendant itself.

For those familiar with the pq program, PqPGSetDescendantToPcp and PqPGRestoreDescendantFromFile perform menu item 3 of the main or advanced p-Group Generation menu.

Commands from the Advanced p-Group Generation menu The functions below perform the component algorithms of PqPGConstructDescendants (see ). You can get some idea of their usage by trying PqExample("Nott-APG-Rel-i");. You can get some idea of the breakdown of PqPGConstructDescendants into these functions by comparing the previous output with PqExample("Nott-PG-Rel-i");.

These functions are intended for use only by experts; please contact the authors of the package if you genuinely have a need for them and need any amplified descriptions. for the ith or default interactive &ANUPQ; process, direct the pq program to invoke menu item 6 of the Advanced p-Group Generation menu. Here the step-size step and the rank rank are positive integers and are the arguments required by the pq program. See  for the one recognised option Exponent. for the ith or default interactive &ANUPQ; process, direct the pq program to perform menu item 7 of the Advanced p-Group Generation menu. Here the options options recognised are PcgsAutomorphisms, SpaceEfficient, PrintAutomorphisms and PrintPermutations (see Chapter  for details). for the ith or default interactive &ANUPQ; process, direct the pq to perform menu item 8 of the Advanced p-Group Generation menu.

Here the options options recognised are PcgsAutomorphisms, SpaceEfficient and CustomiseOutput (see Chapter  for details). For the CustomiseOutput option only the setting of the orbit is recognised (all other fields if set are ignored). for the ith or default interactive &ANUPQ; process, direct the pq to perform item 9 of the Advanced p-Group Generation menu.

The options options may be any selection of the following: PcgsAutomorphisms, SpaceEfficient, Exponent, Metabelian, CapableDescendants (or AllDescendants), CustomiseOutput (where only the group and autgroup fields are recognised) and Filename (see Chapter  for details). If Filename is omitted the reduced p-cover is written to the file "redPCover" in the temporary directory whose name is stored in ANUPQData.tmpdir. for the ith or default interactive &ANUPQ; process, direct the pq to perform option 5 of the Advanced p-Group Generation menu.

The possible options are StepSize, PcgsAutomorphisms, RankInitialSegmentSubgroups, SpaceEfficient, CapableDescendants, AllDescendants, Exponent, Metabelian, BasicAlgorithm and CustomiseOutput. (Detailed descriptions of these options may be found in Chapter .)

Primitive Interactive ANUPQ Process Read/Write Functions For those familiar with using the pq program as a standalone we provide primitive read/write tools to communicate directly with an interactive &ANUPQ; process, started via PqStart. For the most part, it is up to the user to translate the output strings from pq program into a form useful in &GAP;. read a complete line of &ANUPQ; output, from the ith or default interactive &ANUPQ; process, if there is output to be read and returns fail otherwise. When successful, the line is returned as a string complete with trailing newline, colon, or question-mark character. Please note that it is possible to be too quick (i.e. the return can be fail purely because the output from &ANUPQ; is not there yet), but if PqRead finds any output at all, it waits for a complete line. PqRead also writes the line read via Info at InfoANUPQ level 2. It doesn't try to distinguish banner and menu output from other output of the pq program. read and return as many complete lines of &ANUPQ; output, from the ith or default interactive &ANUPQ; process, as there are to be read, at the time of the call, as a list of strings with any trailing newlines removed and returns the empty list otherwise. PqReadAll also writes each line read via Info at InfoANUPQ level 2. It doesn't try to distinguish banner and menu output from other output of the pq program. Whenever PqReadAll finds only a partial line, it waits for the complete line, thus increasing the probability that it has captured all the output to be had from &ANUPQ;. read complete lines of &ANUPQ; output, from the ith or default interactive &ANUPQ; process, chomps them (i.e. removes any trailing newline character), emits them to Info at InfoANUPQ level 2 (without trying to distinguish banner and menu output from other output of the pq program), and applies the function Modify (where Modify is just the identity map/function for the first two forms) until a chomped line line for which IsMyLine( Modify(line) ) is true. PqReadUntil returns the list of Modify-ed chomped lines read.

Notes: When provided by the user, Modify should be a function that accepts a single string argument.

IsMyLine should be a function that is able to accept the output of Modify (or take a single string argument when Modify is not provided) and should return a boolean.

If IsMyLine( Modify(line) ) is never true, PqReadUntil will wait indefinitely. write string to the ith or default interactive &ANUPQ; process; string must be in exactly the form the &ANUPQ; standalone expects. The command is echoed via Info at InfoANUPQ level 3 (with a ToPQ> prompt); i.e. do SetInfoLevel(InfoANUPQ, 3); to see what is transmitted to the pq program. PqWrite returns true if successful in writing to the stream of the interactive &ANUPQ; process, and fail otherwise.

Note: If PqWrite returns fail it means that the &ANUPQ; process has died.

anupq-3.3.3/doc/chap5.html0000644000175100017510000053010015111342310014673 0ustar runnerrunner GAP (ANUPQ) - Chapter 5: Interactive ANUPQ functions
Goto Chapter: Top 1 2 3 4 5 6 7 A Bib Ind
 [Top of Book]  [Contents]   [Previous Chapter]   [Next Chapter] 

5 Interactive ANUPQ functions
 5.1 Starting and Stopping Interactive ANUPQ Processes

  5.1-1 PqStart
  5.1-2 PqQuit
  5.1-3 PqQuitAll
 5.2 Interactive ANUPQ Process Utility Functions

  5.2-1 PqProcessIndex
  5.2-2 PqProcessIndices
  5.2-3 IsPqProcessAlive
 5.3 Interactive Versions of Non-interactive ANUPQ Functions

  5.3-1 Pq
  5.3-2 PqEpimorphism
  5.3-3 PqPCover
  5.3-4 PqStandardPresentation
  5.3-5 EpimorphismPqStandardPresentation
  5.3-6 PqDescendants
  5.3-7 PqSetPQuotientToGroup
 5.4 Low-level Interactive ANUPQ functions based on menu items of the pq program
 5.5 General commands

  5.5-1 PqNrPcGenerators
  5.5-2 PqFactoredOrder
  5.5-3 PqOrder
  5.5-4 PqPClass
  5.5-5 PqWeight
  5.5-6 PqCurrentGroup
  5.5-7 PqDisplayPcPresentation
  5.5-8 PqSetOutputLevel
  5.5-9 PqEvaluateIdentities
 5.6 Commands from the Main p-Quotient menu

  5.6-1 PqPcPresentation
  5.6-2 PqSavePcPresentation
  5.6-3 PqRestorePcPresentation
  5.6-4 PqNextClass
  5.6-5 PqComputePCover
 5.7 Commands from the Advanced p-Quotient menu

  5.7-1 PqCollect
  5.7-2 PqSolveEquation
  5.7-3 PqCommutator
  5.7-4 PqSetupTablesForNextClass
  5.7-5 PqTails
  5.7-6 PqComputeTails
  5.7-7 PqAddTails
  5.7-8 PqDoConsistencyChecks
  5.7-9 PqCollectDefiningRelations
  5.7-10 PqCollectWordInDefiningGenerators
  5.7-11 PqCommutatorDefiningGenerators
  5.7-12 PqDoExponentChecks
  5.7-13 PqEliminateRedundantGenerators
  5.7-14 PqRevertToPreviousClass
  5.7-15 PqSetMaximalOccurrences
  5.7-16 PqSetMetabelian
  5.7-17 PqDoConsistencyCheck
  5.7-18 PqCompact
  5.7-19 PqEchelonise
  5.7-20 PqSupplyAutomorphisms
  5.7-21 PqExtendAutomorphisms
  5.7-22 PqApplyAutomorphisms
  5.7-23 PqDisplayStructure
  5.7-24 PqDisplayAutomorphisms
  5.7-25 PqWritePcPresentation
 5.8 Commands from the Standard Presentation menu

  5.8-1 PqSPComputePcpAndPCover
  5.8-2 PqSPStandardPresentation
  5.8-3 PqSPSavePresentation
  5.8-4 PqSPCompareTwoFilePresentations
  5.8-5 PqSPIsomorphism
 5.9 Commands from the Main p-Group Generation menu

  5.9-1 PqPGSupplyAutomorphisms
  5.9-2 PqPGExtendAutomorphisms
  5.9-3 PqPGConstructDescendants
  5.9-4 PqPGSetDescendantToPcp
 5.10 Commands from the Advanced p-Group Generation menu

  5.10-1 PqAPGDegree
  5.10-2 PqAPGPermutations
  5.10-3 PqAPGOrbits
  5.10-4 PqAPGOrbitRepresentatives
  5.10-5 PqAPGSingleStage
 5.11 Primitive Interactive ANUPQ Process Read/Write Functions

  5.11-1 PqRead
  5.11-2 PqReadAll
  5.11-3 PqReadUntil
  5.11-4 PqWrite

5 Interactive ANUPQ functions

Here we describe the interactive functions defined by the ANUPQ package, i.e. the functions that manipulate and initiate interactive ANUPQ processes. These are functions that extract information via a dialogue with a running pq process (process used in the UNIX sense). Occasionally, a user needs the next step; the functions provided in this chapter make use of data from previous steps retained by the pq program, thus allowing the user to interact with the pq program like one can when one uses the pq program as a stand-alone (see guide.dvi in the standalone-doc directory).

An interactive ANUPQ process is initiated by PqStart and terminated via PqQuit; these functions are described in ection Starting and Stopping Interactive ANUPQ Processes.

Each interactive ANUPQ function that manipulates an already started interactive ANUPQ process, has a form where the first argument is the integer i returned by the initiating PqStart command, and a second form with one argument fewer (where the integer i is discovered by a default mechanism, namely by determining the least integer i for which there is a currently active interactive ANUPQ process). We will thus commonly say that for the ith (or default) interactive ANUPQ process a certain function performs a given action. In each case, it is an error if i is not the index of an active interactive process, or there are no current active interactive processes.

Notes: The global method of passing options (via PushOptions), should not be used with any of the interactive functions. In fact, the OptionsStack should be empty at the time any of the interactive functions is called.

On quitting GAP, PqQuitAll(); is executed, which terminates all active interactive ANUPQ processes. If GAP is killed without quitting, before all interactive ANUPQ processes are terminated, zombie processes (still living child processes whose parents have died), may result. Since zombie processes do consume resources, in such an event, the responsible computer user should seek out and terminate those zombie processes (e.g. on Linux: ps xw | grep pq gives you information on the pq processes corresponding to any interactive ANUPQ processes started in a GAP session; you can then do kill N for each number N appearing in the first column of this output).

5.1 Starting and Stopping Interactive ANUPQ Processes

5.1-1 PqStart
‣ PqStart( G, workspace: options )( function )
‣ PqStart( G: options )( function )
‣ PqStart( workspace: options )( function )
‣ PqStart( : options )( function )

activate an iostream for an interactive ANUPQ process (i.e. PqStart starts up a pq process and opens a GAP iostream to talk to that process) and returns an integer i that can be used to identify that process. The argument G should be an fp group or pc group that the user intends to manipulate using interactive ANUPQ functions. If the function is called without specifying G, a group can be read in by using the function PqRestorePcPresentation (see PqRestorePcPresentation (5.6-3)). If PqStart is given an integer argument workspace, then the pq program is started up with a workspace (an integer array) of size workspace (i.e. 4 × workspace bytes in a 32-bit environment); otherwise, the pq program sets a default workspace of 10000000.

The only options currently recognised by PqStart are Prime, Exponent and Relators (see Chapter ANUPQ Options for detailed descriptions of these options) and if provided they are essentially global for the interactive ANUPQ process, except that any interactive function interacting with the process and passing new values for these options will over-ride the global values.

5.1-2 PqQuit
‣ PqQuit( i )( function )
‣ PqQuit( )( function )

closes the stream of the ith or default interactive ANUPQ process and unbinds its ANUPQData.io record.

Note: It can happen that the pq process, and hence the GAP iostream assigned to communicate with it, can die, e.g. by the user typing a Ctrl-C while the pq process is engaged in a long calculation. IsPqProcessAlive (see IsPqProcessAlive (5.2-3)) is provided to check the status of the GAP iostream (and hence the status of the pq process it was communicating with).

5.1-3 PqQuitAll
‣ PqQuitAll( )( function )

is provided as a convenience, to terminate all active interactive ANUPQ processes with a single command. It is equivalent to executing PqQuit(i) for all active interactive ANUPQ processes i (see PqQuit (5.1-2)).

5.2 Interactive ANUPQ Process Utility Functions

5.2-1 PqProcessIndex
‣ PqProcessIndex( i )( function )
‣ PqProcessIndex( )( function )

With argument i, which must be a positive integer, PqProcessIndex returns i if it corresponds to an active interactive process, or raises an error. With no arguments it returns the default active interactive process or returns fail and emits a warning message to Info at InfoANUPQ or InfoWarning level 1.

Note: Essentially, an interactive ANUPQ process i is active if ANUPQData.io[i] is bound (i.e. we still have some data telling us about it). Also see PqStart (5.1-1).

5.2-2 PqProcessIndices
‣ PqProcessIndices( )( function )

returns the list of integer indices of all active interactive ANUPQ processes (see PqProcessIndex (5.2-1) for the meaning of active).

5.2-3 IsPqProcessAlive
‣ IsPqProcessAlive( i )( function )
‣ IsPqProcessAlive( )( function )

return true if the GAP iostream of the ith (or default) interactive ANUPQ process started by PqStart is alive (i.e. can still be written to), or false, otherwise. (See the notes for PqStart (5.1-1) and PqQuit (5.1-2).)

If the user does not yet have a gap> prompt then usually the pq program is still away doing something and an ANUPQ interface function is still waiting for a reply. Typing a Ctrl-C (i.e. holding down the Ctrl key and typing c) will stop the waiting and send GAP into a break-loop, from which one has no option but to quit;. The typing of Ctrl-C, in such a circumstance, usually causes the stream of the interactive ANUPQ process to die; to check this we provide IsPqProcessAlive (see IsPqProcessAlive).

The GAP iostream of an interactive ANUPQ process will also die if the pq program has a segmentation fault. We do hope that this never happens to you, but if it does and the failure is reproducible, then it's a bug and we'd like to know about it. Please read the README that comes with the ANUPQ package to find out what to include in a bug report and who to email it to.

5.3 Interactive Versions of Non-interactive ANUPQ Functions

5.3-1 Pq
‣ Pq( i: options )( function )
‣ Pq( : options )( function )

return, for the fp or pc group (let us call it F), of the ith or default interactive ANUPQ process, the p-quotient of F specified by options, as a pc group; F must previously have been given (as first argument) to PqStart to start the interactive ANUPQ process (see PqStart (5.1-1)) or restored from file using the function PqRestorePcPresentation (see PqRestorePcPresentation (5.6-3)). Following the colon options is a selection of the options listed for the non-interactive Pq function (see Pq (4.1-1)), separated by commas like record components (see Section Reference: Function Call With Options in the GAP Reference Manual), except that the options SetupFile or PqWorkspace are ignored by the interactive Pq, and RedoPcp is an option only recognised by the interactive Pq i.e. the following options are recognised by the interactive Pq function:

  • Prime := p

  • ClassBound := n

  • Exponent := n

  • Relators := rels

  • Metabelian

  • Identities := funcs

  • GroupName := name

  • OutputLevel := n

  • RedoPcp

Detailed descriptions of the above options may be found in Chapter ANUPQ Options.

As a minimum the Pq function must have a value for the Prime option, though Prime need not be passed again in the case it has previously been provided, e.g. to PqStart (see PqStart (5.1-1)) when starting the interactive process.

The behaviour of the interactive Pq function depends on the current state of the pc presentation stored by the pq program:

  1. If no pc presentation has yet been computed (the case immediately after the PqStart call initiating the process) then the quotient group of the input group of the process of largest lower exponent-p class bounded by the value of the ClassBound option (see 6.2) is returned.

  2. If the current pc presentation of the process was determined by a previous call to Pq or PqEpimorphism, and the current call has a larger value ClassBound then the class is extended as much as is possible and the quotient group of the input group of the process of the new lower exponent-p class is returned.

  3. If the current pc presentation of the process was determined by a previous call to PqPCover then a consistent pc presentation of a quotient for the current class is determined before proceeding as in 2.

  4. If the RedoPcp option is supplied the current pc presentation is scrapped, all options must be re-supplied (in particular, Prime must be supplied) and then the Pq function proceeds as in 1.

See Section Attributes and a Property for fp and pc p-groups for the attributes and property NuclearRank, MultiplicatorRank and IsCapable which may be applied to the group returned by Pq.

The following is one of the examples for the non-interactive Pq redone with the interactive version. Also, we set the option OutputLevel to 1 (see 6.2), in order to see the orders of the quotients of all the classes determined, and we set the InfoANUPQ level to 2 (see InfoANUPQ (3.3-1)), so that we catch the timing information.

gap> F := FreeGroup("a", "b");; a := F.1;; b := F.2;;
gap> G := F / [a^4, b^4];
<fp group on the generators [ a, b ]>
gap> PqStart(G);
1
gap> SetInfoLevel(InfoANUPQ, 2); #To see timing information
gap> Pq(: Prime := 2, ClassBound := 3, OutputLevel := 1 );
#I  Lower exponent-2 central series for [grp]
#I  Group: [grp] to lower exponent-2 central class 1 has order 2^2
#I  Group: [grp] to lower exponent-2 central class 2 has order 2^5
#I  Group: [grp] to lower exponent-2 central class 3 has order 2^8
#I  Computation of presentation took 0.00 seconds
<pc group of size 256 with 8 generators>

5.3-2 PqEpimorphism
‣ PqEpimorphism( i: options )( function )
‣ PqEpimorphism( : options )( function )

return, for the fp or pc group (let us call it F), of the ith or default interactive ANUPQ process, an epimorphism from F onto the p-quotient of F specified by options; F must previously have been given (as first argument) to PqStart to start the interactive ANUPQ process (see PqStart (5.1-1)). Since the underlying interactions with the pq program effected by the interactive PqEpimorphism are identical to those effected by the interactive Pq, everything said regarding the requirements and behaviour of the interactive Pq function (see Pq (5.3-1)) is also the case for the interactive PqEpimorphism.

Note: See Section Attributes and a Property for fp and pc p-groups for the attributes and property NuclearRank, MultiplicatorRank and IsCapable which may be applied to the image group of the epimorphism returned by PqEpimorphism.

5.3-3 PqPCover
‣ PqPCover( i: options )( function )
‣ PqPCover( : options )( function )

return, for the fp or pc group of the ith or default interactive ANUPQ process, the p-covering group of the p-quotient Pq(i : options) or Pq(: options), modulo the following:

  1. If no pc presentation has yet been computed (the case immediately after the PqStart call initiating the process) and the group F of the process is already a p-group, in the sense that HasIsPGroup(F) and IsPGroup(F) is true, then

    Prime

    defaults to PrimePGroup(F), if not supplied and HasPrimePGroup(F) = true; and

    ClassBound

    defaults to PClassPGroup(F) if HasPClassPGroup(F) = true if not supplied, or to the usual default of 63, otherwise.

  2. If a pc presentation has been computed and none of options is RedoPcp or if no pc presentation has yet been computed but 1. does not apply then PqPCover(i : options); is equivalent to:

    Pq(i : options);
PqPCover(i);

  3. If the RedoPcp option is supplied the current pc presentation is scrapped, and PqPCover proceeds as in 1. or 2. but without the RedoPcp option.

5.3-4 PqStandardPresentation
‣ PqStandardPresentation( [i]: options )( function )
‣ StandardPresentation( [i]: options )( function )

return, for the ith or default interactive ANUPQ process, the p-quotient of the group F of the process, specified by options, as an fp group which has a standard presentation. Here options is a selection of the options from the following list (see Chapter ANUPQ Options for detailed descriptions); this list is the same as for the non-interactive version of PqStandardPresentation except for the omission of options SetupFile and PqWorkspace (see PqStandardPresentation (4.2-1)).

  • Prime := p

  • pQuotient := Q

  • ClassBound := n

  • Exponent := n

  • Metabelian

  • GroupName := name

  • OutputLevel := n

  • StandardPresentationFile := filename

Unless F is a pc p-group, or the option Prime has been passed to a previous interactive function for the process to compute a p-quotient for F, the user must supply either the option Prime or the option pQuotient (if both Prime and pQuotient are supplied, the prime p is determined by applying PrimePGroup (see PrimePGroup (Reference: PrimePGroup) in the Reference Manual) to the value of pQuotient).

Taking one of the examples for the non-interactive version of StandardPresentation (see StandardPresentation (4.2-1)) that required two separate calls to the pq program, we now show how it can be done by setting up a dialogue with just the one pq process, using the interactive version of StandardPresentation:

gap> F4 := FreeGroup( "a", "b", "c", "d" );;
gap> a := F4.1;; b := F4.2;; c := F4.3;; d := F4.4;;
gap> G4 := F4 / [ b^4, b^2 / Comm(Comm (b, a), a), d^16,
>                 a^16 / (c * d), b^8 / (d * c^4) ];
<fp group on the generators [ a, b, c, d ]>
gap> SetInfoLevel(InfoANUPQ, 1); #Only essential Info please
gap> procId := PqStart(G4);; #Start a new interactive process for a new group
gap> K := Pq( procId : Prime := 2, ClassBound := 1 );
<pc group of size 4 with 2 generators>
gap> StandardPresentation( procId : pQuotient := K, ClassBound := 14 );
<fp group with 53 generators>

Notes

In contrast to the function Pq (see Pq (4.1-1)) which returns a pc group, PqStandardPresentation or StandardPresentation returns an fp group. This is because the output is mainly used for isomorphism testing for which an fp group is enough. However, the presentation is a polycyclic presentation and if you need to do any further computation with this group (e.g. to find the order) you can use the function PcGroupFpGroup (see PcGroupFpGroup (Reference: PcGroupFpGroup) in the GAP Reference Manual) to form a pc group.

If the user does not supply a p-quotient Q via the pQuotient option, and the prime p is either supplied, stored, or F is a pc p-group, then a p-quotient Q is computed. (The value of the prime p is stored if passed initially to PqStart or to a subsequent interactive process.) Note that a stored value for pQuotient (from a prior call to Pq) does not have precedence over a value for the prime p. If the user does supply a p-quotient Q via the pQuotient option, the package AutPGrp is called to compute the automorphism group of Q; an error will occur that asks the user to install the package AutPGrp if the automorphism group cannot be computed.

If any of the interactive functions PqStandardPresentation, StandardPresentation, EpimorphismPqStandardPresentation or EpimorphismStandardPresentation has been called previously for an interactive process, a subsequent call to any of these functions for the same process returns the previously computed value. Note that all these functions compute both an epimorphism and an fp group and store the results in the SPepi and SP fields of the data record associated with the process. See the example for the interactive EpimorphismStandardPresentation (EpimorphismStandardPresentation (5.3-5)).

The attributes and property NuclearRank, MultiplicatorRank and IsCapable are set for the group returned by PqStandardPresentation or StandardPresentation (see Section Attributes and a Property for fp and pc p-groups).

5.3-5 EpimorphismPqStandardPresentation
‣ EpimorphismPqStandardPresentation( [i]: options )( function )
‣ EpimorphismStandardPresentation( [i]: options )( method )

Each of the above functions accepts the same arguments and options as the interactive form of StandardPresentation (see StandardPresentation (5.3-4)) and returns an epimorphism from the fp or pc group F of the ith or default interactive ANUPQ process onto the finitely presented group given by a standard presentation, i.e. if S is the standard presentation computed for the p-quotient of F by StandardPresentation then EpimorphismStandardPresentation returns the epimorphism from F to the group with presentation S. The group F must have been given (as first argument) to PqStart to start the interactive ANUPQ process (see PqStart (5.1-1)).

Taking our earlier non-interactive example (see EpimorphismPqStandardPresentation (4.2-2)) and modifying it a little, we illustrate, as for the interactive StandardPresentation (see StandardPresentation (5.3-4)), how something that required two separate calls to the pq program can now be achieved with a dialogue with just one pq process. Also, observe that calls to one of the standard presentation functions (as mentioned in the notes of StandardPresentation (5.3-4)) computes and stores both an fp group with a standard presentation and an epimorphism; subsequent calls to a standard presentation function for the same process simply return the appropriate stored value.

gap> F := FreeGroup(6, "F");;
gap> x := F.1;; y := F.2;; z := F.3;; w := F.4;; a := F.5;; b := F.6;;
gap> R := [x^3 / w, y^3 / w * a^2 * b^2, w^3 / b,
>          Comm (y, x) / z, Comm (z, x), Comm (z, y) / a, z^3 ];
[ F1^3*F4^-1, F2^3*F4^-1*F5^2*F6^2, F4^3*F6^-1, F2^-1*F1^-1*F2*F1*F3^-1, 
  F3^-1*F1^-1*F3*F1, F3^-1*F2^-1*F3*F2*F5^-1, F3^3 ]
gap> Q := F / R;
<fp group on the generators [ F1, F2, F3, F4, F5, F6 ]>
gap> procId := PqStart( Q );;
gap> G := Pq( procId : Prime := 3, ClassBound := 3 );
<pc group of size 729 with 6 generators>
gap> lev := InfoLevel(InfoANUPQ);; # Save current InfoANUPQ level
gap> SetInfoLevel(InfoANUPQ, 2); # To see computation times
gap> # It is not necessary to pass the `Prime' option to
gap> # `EpimorphismStandardPresentation' since it was previously
gap> # passed to `Pq':
gap> phi := EpimorphismStandardPresentation( 3 : ClassBound := 3 );
#I  Class 1 3-quotient and its 3-covering group computed in 0.00 seconds
#I  Order of GL subgroup is 48
#I  No. of soluble autos is 0
#I    dim U = 1  dim N = 3  dim M = 3
#I    nice stabilizer with perm rep
#I  Computing standard presentation for class 2 took 0.00 seconds
#I  Computing standard presentation for class 3 took 0.01 seconds
[ F1, F2, F3, F4, F5, F6 ] -> [ f1*f2^2*f3*f4^2*f5^2, f1*f2*f3*f5, f3^2, 
  f4*f6^2, f5, f6 ]
gap> # Image of phi should be isomorphic to G ...
gap> # let's check the order is correct:
gap> Size( Image(phi) );
729
gap> # `StandardPresentation' and `EpimorphismStandardPresentation'
gap> # behave like attributes, so no computation is done when
gap> # either is called again for the same process ...
gap> StandardPresentation( 3 : ClassBound := 3 );
<fp group of size 729 on the generators [ f1, f2, f3, f4, f5, f6 ]>
gap> # No timing data was Info-ed since no computation was done
gap> SetInfoLevel(InfoANUPQ, lev); # Restore previous InfoANUPQ level

A very similar (essential details are the same) example to the above may be executed live, by typing: PqExample( "EpimorphismStandardPresentation-i" );.

Note: The notes for PqStandardPresentation or StandardPresentation (see PqStandardPresentation (5.3-4)) apply also to EpimorphismPqStandardPresentation or EpimorphismStandardPresentation except that their return value is an epimorphism onto an fp group, i.e. one should interpret the phrase returns an fp group as returns an epimorphism onto an fp group etc.

5.3-6 PqDescendants
‣ PqDescendants( i: options )( function )
‣ PqDescendants( : options )( function )

return for the pc group G of the ith or default interactive ANUPQ process, which must be of prime power order with a confluent pc presentation (see IsConfluent (Reference: IsConfluent for pc groups) in the GAP Reference Manual), a list of proper descendants (pc groups) of G. The group G is usually given as first argument to PqStart when starting the interactive ANUPQ process (see PqStart (5.1-1)). Alternatively, one may initiate the process with an fp group, use Pq interactively (see Pq (5.3-1)) to create a pc group and use PqSetPQuotientToGroup (see PqSetPQuotientToGroup (5.3-7)), which involves no computation, to set the pc group returned by Pq as the group of the process. Note that repeating a call to PqDescendants for the same interactive ANUPQ process simply returns the list of descendants originally calculated; a warning is emitted at InfoANUPQ level 1 reminding you of this should you do this.

After the colon, options a selection of the options listed for the non-interactive PqDescendants function (see PqDescendants (4.4-1)), should be given, separated by commas like record components (see Section Reference: Function Call With Options in the GAP Reference Manual), except that the options SetupFile or PqWorkspace are ignored by the interactive PqDescendants, i.e. the following options are recognised by the interactive PqDescendants function:

  • ClassBound := n

  • Relators := rels

  • OrderBound := n

  • StepSize := n, StepSize := list

  • RankInitialSegmentSubgroups := n

  • SpaceEfficient

  • CapableDescendants

  • AllDescendants := false

  • Exponent := n

  • Metabelian

  • GroupName := name

  • SubList := sub

  • BasicAlgorithm

  • CustomiseOutput := rec

Notes: The function PqDescendants uses the automorphism group of G which it computes via the package AutPGrp if the automorphism group of G is not already present. If AutPGrp is not installed an error may be raised. If the automorphism group of G is insoluble the pq program will call GAP together with the AutPGrp package for certain orbit-stabilizer calculations.

The attributes and property NuclearRank, MultiplicatorRank and IsCapable are set for each group of the list returned by PqDescendants (see Section Attributes and a Property for fp and pc p-groups).

Let us now repeat the examples previously given for the non-interactive PqDescendants, but this time with the interactive version of PqDescendants:

gap> F := FreeGroup( "a", "b" );; a := F.1;; b := F.2;;
gap> G := PcGroupFpGroup( F / [ a^2, b^2, Comm(b, a) ] );
<pc group of size 4 with 2 generators>
gap> procId := PqStart(G);;
gap> des := PqDescendants( procId : OrderBound := 6, ClassBound := 5 );;
gap> Length(des);
83
gap> List(des, Size);
[ 8, 8, 8, 16, 16, 16, 32, 16, 16, 16, 16, 16, 32, 32, 64, 64, 32, 32, 32, 
  32, 32, 32, 32, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 32, 32, 32, 32, 
  64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 32, 32, 32, 32, 32, 64, 64, 64, 
  64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 
  64, 64, 64, 64, 64, 64, 64 ]
gap> List(des, d -> Length( PCentralSeries( d, 2 ) ) - 1 );
[ 2, 2, 2, 2, 2, 2, 2, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 
  3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 4, 
  4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 
  4, 4, 4, 5, 5, 5, 5, 5 ]

In the second example we compute all capable descendants of order 27 of the elementary abelian group of order 9.

gap> F := FreeGroup( 2, "g" );;
gap> G := PcGroupFpGroup( F / [ F.1^3, F.2^3, Comm(F.1, F.2) ] );
<pc group of size 9 with 2 generators>
gap> procId := PqStart(G);;
gap> des := PqDescendants( procId : OrderBound := 3, ClassBound := 2,
>                              CapableDescendants );
[ <pc group of size 27 with 3 generators>, 
  <pc group of size 27 with 3 generators> ]
gap> List(des, d -> Length( PCentralSeries( d, 3 ) ) - 1 );
[ 2, 2 ]
gap> # For comparison let us now compute all proper descendants
gap> # (using the non-interactive Pq function)
gap> PqDescendants( G : OrderBound := 3, ClassBound := 2);
[ <pc group of size 27 with 3 generators>, 
  <pc group of size 27 with 3 generators>, 
  <pc group of size 27 with 3 generators> ]

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

gap> F := FreeGroup( 2, "g" );;
gap> G := PcGroupFpGroup( F / [ F.1^5, F.2^5, Comm(F.2, F.1) ] );
<pc group of size 25 with 2 generators>
gap> procId := PqStart(G);;
gap> des := PqDescendants( procId : Metabelian, ClassBound := 3,
>                              Exponent := 5, CapableDescendants );
[ <pc group of size 125 with 3 generators>, 
  <pc group of size 625 with 4 generators>, 
  <pc group of size 3125 with 5 generators> ]
gap> List(des, d -> Length( PCentralSeries( d, 5 ) ) - 1 );
[ 2, 3, 3 ]
gap> List(des, d -> Length( DerivedSeries( d ) ) );
[ 3, 3, 3 ]
gap> List(des, d -> Maximum( List( d, Order ) ) );
[ 5, 5, 5 ]

5.3-7 PqSetPQuotientToGroup
‣ PqSetPQuotientToGroup( i )( function )
‣ PqSetPQuotientToGroup( )( function )

for the ith or default interactive ANUPQ process, set the p-quotient previously computed by the interactive Pq function (see Pq (5.3-1)) to be the group of the process. This function is supplied to enable the computation of descendants of a p-quotient that is already known to the pq program, via the interactive PqDescendants function (see PqDescendants (5.3-6)), thus avoiding the need to re-submit it and have the pq program recompute it.

Note: See the function PqPGSetDescendantToPcp (PqPGSetDescendantToPcp (5.9-4)) for a mechanism to make (the p-cover of) a particular descendants the current group of the process.

The following example of the usage of PqSetPQuotientToGroup, which is essentially equivalent to what is obtained by running PqExample("PqDescendants-1-i");, redoes the first example of PqDescendants (5.3-6) (which computes the descendants of the Klein four group).

gap> F := FreeGroup( "a", "b" );
<free group on the generators [ a, b ]>
gap> procId := PqStart( F : Prime := 2 );;
gap> Pq( procId : ClassBound := 1 );
<pc group of size 4 with 2 generators>
gap> PqSetPQuotientToGroup( procId );
gap> des := PqDescendants( procId : OrderBound := 6, ClassBound := 5 );;
gap> Length(des);
83
gap> List(des, Size);
[ 8, 8, 8, 16, 16, 16, 32, 16, 16, 16, 16, 16, 32, 32, 64, 64, 32, 32, 32, 
  32, 32, 32, 32, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 32, 32, 32, 32, 
  64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 32, 32, 32, 32, 32, 64, 64, 64, 
  64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 
  64, 64, 64, 64, 64, 64, 64 ]
gap> List(des, d -> Length( PCentralSeries( d, 2 ) ) - 1 );
[ 2, 2, 2, 2, 2, 2, 2, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 
  3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 4, 
  4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 
  4, 4, 4, 5, 5, 5, 5, 5 ]

5.4 Low-level Interactive ANUPQ functions based on menu items of the pq program

The pq program has 5 menus, the details of which the reader will not normally need to know, but if she wishes to know the details they may be found in the standalone manual: guide.dvi. Both guide.dvi and the pq program refer to the items of these 5 menus as options, which do not correspond in any way to the options used by any of the GAP functions that interface with the pq program.

Warning: The commands provided in this section are intended to provide something like the interactive functionality one has when running the standalone, from within GAP. The pq standalone (in particular, its advanced menus) assumes some expertise of the user; doing the wrong thing can cause the program to crash. While a number of safeguards have been provided in the GAP interface to the pq program, these are not foolproof, and the user should exercise care and ensure pre-requisites of the various commands are met.

5.5 General commands

The following commands either use a menu item from whatever menu is current for the pq program, or have general application and are not associated with just one menu item of the pq program.

5.5-1 PqNrPcGenerators
‣ PqNrPcGenerators( i )( function )
‣ PqNrPcGenerators( )( function )

for the ith or default interactive ANUPQ process, return the number of pc generators of the lower exponent p-class quotient of the group currently determined by the process. This also applies if the pc presentation is not consistent.

5.5-2 PqFactoredOrder
‣ PqFactoredOrder( i )( function )
‣ PqFactoredOrder( )( function )

for the ith or default interactive ANUPQ process, return an integer pair [p, n] where p is a prime and n is the number of pc generators (see PqNrPcGenerators (5.5-1)) in the pc presentation of the quotient group currently determined by the process. If this presentation is consistent, then p^n is the order of the quotient group. Otherwise (if tails have been added but the necessary consistency checks, relation collections, exponent law checks and redundant generator eliminations have not yet been done), p^n is an upper bound for the order of the group.

5.5-3 PqOrder
‣ PqOrder( i )( function )
‣ PqOrder( )( function )

for the ith or default interactive ANUPQ process, return p^n where [p, n] is the pair as returned by PqFactoredOrder (see PqFactoredOrder (5.5-2)).

5.5-4 PqPClass
‣ PqPClass( i )( function )
‣ PqPClass( )( function )

for the ith or default interactive ANUPQ process, return the lower exponent p-class of the quotient group currently determined by the process.

5.5-5 PqWeight
‣ PqWeight( i, j )( function )
‣ PqWeight( j )( function )

for the ith or default interactive ANUPQ process, return the weight of the jth pc generator of the lower exponent p-class quotient of the group currently determined by the process, or fail if there is no such numbered pc generator.

5.5-6 PqCurrentGroup
‣ PqCurrentGroup( i )( function )
‣ PqCurrentGroup( )( function )

for the ith or default interactive ANUPQ process, return the group whose pc presentation is determined by the process as a GAP pc group (either a lower exponent p-class quotient of the start group or the p-cover of such a quotient).

Notes: See Section Attributes and a Property for fp and pc p-groups for the attributes and property NuclearRank, MultiplicatorRank and IsCapable which may be applied to the group returned by PqCurrentGroup.

5.5-7 PqDisplayPcPresentation
‣ PqDisplayPcPresentation( i: [OutputLevel := lev] )( function )
‣ PqDisplayPcPresentation( : [OutputLevel := lev] )( function )

for the ith or default interactive ANUPQ process, direct the pq program to display the pc presentation of the lower exponent p-class quotient of the group currently determined by the process.

Except if the last command communicating with the pq program was a p-group generation command (for which there is only a verbose output level), to set the amount of information this command displays you may wish to call PqSetOutputLevel first (see PqSetOutputLevel (5.5-8)), or equivalently pass the option OutputLevel (see 6.2).

Note: For those familiar with the pq program, PqDisplayPcPresentation performs menu item 4 of the current menu of the pq program.

5.5-8 PqSetOutputLevel
‣ PqSetOutputLevel( i, lev )( function )
‣ PqSetOutputLevel( lev )( function )

for the ith or default interactive ANUPQ process, direct the pq program to set the output level of the pq program to lev.

Note: For those familiar with the pq program, PqSetOutputLevel performs menu item 5 of the main (or advanced) p-Quotient menu, or the Standard Presentation menu.

5.5-9 PqEvaluateIdentities
‣ PqEvaluateIdentities( i: [Identities := funcs] )( function )
‣ PqEvaluateIdentities( : [Identities := funcs] )( function )

for the ith or default interactive ANUPQ process, invoke the evaluation of identities defined by the Identities option, and eliminate any redundant pc generators formed. Since a previous value of Identities is saved in the data record of the process, it is unnecessary to pass the Identities if set previously.

Note: This function is mainly implemented at the GAP level. It does not correspond to a menu item of the pq program.

5.6 Commands from the Main p-Quotient menu

5.6-1 PqPcPresentation
‣ PqPcPresentation( i: options )( function )
‣ PqPcPresentation( : options )( function )

for the ith or default interactive ANUPQ process, direct the pq program to compute the pc presentation of the quotient (determined by options) of the group of the process, which for process i is stored as ANUPQData.io[i].group.

The possible options are the same as for the interactive Pq (see Pq (5.3-1)) function, except for RedoPcp (which, in any case, would be superfluous), namely: Prime, ClassBound, Exponent, Relators, GroupName, Metabelian, Identities and OutputLevel (see Chapter ANUPQ Options for a detailed description for these options). The option Prime is required unless already provided to PqStart.

Notes

The pc presentation is held by the pq program. In contrast to Pq (see Pq (5.3-1)), no GAP pc group is returned; see PqCurrentGroup (PqCurrentGroup (5.5-6)) if you need the corresponding GAP pc group.

PqPcPresentation(i: options); is roughly equivalent to the following sequence of low-level commands:

PqPcPresentation(i: opts); #class 1 call
for c in [2 .. class] do
    PqNextClass(i);
od;

where opts is options except with the ClassBound option set to 1, and class is either the maximum class of a p-quotient of the group of the process or the user-supplied value of the option ClassBound (whichever is smaller). If the Identities option has been set, both the first PqPcPresentation class 1 call and the PqNextClass calls invoke PqEvaluateIdentities(i); as their final step.

For those familiar with the pq program, PqPcPresentation performs menu item 1 of the main p-Quotient menu.

5.6-2 PqSavePcPresentation
‣ PqSavePcPresentation( i, filename )( function )
‣ PqSavePcPresentation( filename )( function )

for the ith or default interactive ANUPQ process, direct the pq program to save the pc presentation previously computed for the quotient of the group of that process to the file with name filename. If the first character of the string filename is not /, filename is assumed to be the path of a writable file relative to the directory in which GAP was started. A saved file may be restored by PqRestorePcPresentation (see PqRestorePcPresentation (5.6-3)).

Note: For those familiar with the pq program, PqSavePcPresentation performs menu item 2 of the main p-Quotient menu.

5.6-3 PqRestorePcPresentation
‣ PqRestorePcPresentation( i, filename )( function )
‣ PqRestorePcPresentation( filename )( function )

for the ith or default interactive ANUPQ process, direct the pq program to restore the pc presentation previously saved to filename, by PqSavePcPresentation (see PqSavePcPresentation (5.6-2)). If the first character of the string filename is not /, filename is assumed to be the path of a readable file relative to the directory in which GAP was started.

Note: For those familiar with the pq program, PqRestorePcPresentation performs menu item 3 of the main p-Quotient menu.

5.6-4 PqNextClass
‣ PqNextClass( i: [QueueFactor] )( function )
‣ PqNextClass( : [QueueFactor] )( function )

for the ith or default interactive ANUPQ process, direct the pq program to calculate the next class of ANUPQData.io[i].group.

PqNextClass accepts the option QueueFactor (see also 6.2) which should be a positive integer if automorphisms have been previously supplied. If the pq program requires a queue factor and none is supplied via the option QueueFactor a default of 15 is taken.

Notes

The single command: PqNextClass(i); is equivalent to executing

PqComputePCover(i);
PqCollectDefiningRelations(i);
PqDoExponentChecks(i);
PqEliminateRedundantGenerators(i);

If the Identities option is set the PqEliminateRedundantGenerators(i); step is essentially replaced by PqEvaluateIdentities(i); (which invokes its own elimination of redundant generators).

For those familiar with the pq program, PqNextClass performs menu item 6 of the main p-Quotient menu.

5.6-5 PqComputePCover
‣ PqComputePCover( i )( function )
‣ PqComputePCover( )( function )

for the ith or default interactive ANUPQ processi, directi, the pq program to compute the p-covering group of ANUPQData.io[i].group. In contrast to the function PqPCover (see PqPCover (4.1-3)), this function does not return a GAP pc group.

Notes

The single command: PqComputePCover(i); is equivalent to executing

PqSetupTablesForNextClass(i);
PqTails(i, 0);
PqDoConsistencyChecks(i, 0, 0);
PqEliminateRedundantGenerators(i);

For those familiar with the pq program, PqComputePCover performs menu item 7 of the main p-Quotient menu.

5.7 Commands from the Advanced p-Quotient menu

5.7-1 PqCollect
‣ PqCollect( i, word )( function )
‣ PqCollect( word )( function )

for the ith or default interactive ANUPQ process, instruct the pq program to do a collection on word, a word in the current pc generators (the form of word required is described below). PqCollect returns the resulting word of the collection as a list of generator number, exponent pairs (the same form as the second allowed input form of word; see below).

The argument word may be input in either of the following ways:

  1. word may be a string, where the ith pc generator is represented by xi, e.g. "x3*x2^2*x1". This way is quite versatile as parentheses and left-normed commutators -- using square brackets, in the same way as PqGAPRelators (see PqGAPRelators (3.4-2)) -- are permitted; word is checked for correct syntax via PqParseWord (see PqParseWord (3.4-3)).

  2. Otherwise, word must be a list of generator number, exponent pairs of integers, i.e.  each pair represents a syllable so that [ [3, 1], [2, 2], [1, 1] ] represents the same word as that of the example given for the first allowed form of word.

Note: For those familiar with the pq program, PqCollect performs menu item 1 of the Advanced p-Quotient menu.

5.7-2 PqSolveEquation
‣ PqSolveEquation( i, a, b )( function )
‣ PqSolveEquation( a, b )( function )

for the ith or default interactive ANUPQ process, direct the pq program to solve a * x = b for x, where a and b are words in the pc generators. For the representation of these words see the description of the function PqCollect (PqCollect (5.7-1)).

Note: For those familiar with the pq program, PqSolveEquation performs menu item 2 of the Advanced p-Quotient menu.

5.7-3 PqCommutator
‣ PqCommutator( i, words, pow )( function )
‣ PqCommutator( words, pow )( function )

for the ith or default interactive ANUPQ process, instruct the pq program to compute the left normed commutator of the list words of words in the current pc generators raised to the integer power pow, and return the resulting word as a list of generator number, exponent pairs. The form required for each word of words is the same as that required for the word argument of PqCollect (see PqCollect (5.7-1)). The form of the output word is also the same as for PqCollect.

Note: For those familiar with the pq program, PqCommutator performs menu item 3 of the Advanced p-Quotient menu.

5.7-4 PqSetupTablesForNextClass
‣ PqSetupTablesForNextClass( i )( function )
‣ PqSetupTablesForNextClass( )( function )

for the ith or default interactive ANUPQ process, direct the pq program to set up tables for the next class. As as side-effect, after PqSetupTablesForNextClass(i) the value returned by PqPClass(i) will be one more than it was previously.

Note: For those familiar with the pq program, PqSetupTablesForNextClass performs menu item 6 of the Advanced p-Quotient menu.

5.7-5 PqTails
‣ PqTails( i, weight )( function )
‣ PqTails( weight )( function )

for the ith or default interactive ANUPQ process, direct the pq program to compute and add tails of weight weight if weight is in the integer range [2 .. PqPClass(i)] (assuming i is the number of the process, even in the default case) or for all weights if weight = 0.

If weight is non-zero, then tails that introduce new generators for only weight weight are computed and added, and in this case and if weight < PqPClass(i), it is assumed that the tails that introduce new generators for each weight from PqPClass(i) down to weight weight + 1 have already been added. You may wish to call PqSetMetabelian (see PqSetMetabelian (5.7-16)) prior to calling PqTails.

Notes

For its use in the context of finding the next class see PqNextClass (5.6-4); in particular, a call to PqSetupTablesForNextClass (see PqSetupTablesForNextClass (5.7-4)) needs to have been made prior to calling PqTails.

The single command: PqTails(i, weight); is equivalent to

PqComputeTails(i, weight);
PqAddTails(i, weight);

For those familiar with the pq program, PqTails uses menu item 7 of the Advanced p-Quotient menu.

5.7-6 PqComputeTails
‣ PqComputeTails( i, weight )( function )
‣ PqComputeTails( weight )( function )

for the ith or default interactive ANUPQ process, direct the pq program to compute tails of weight weight if weight is in the integer range [2 .. PqPClass(i)] (assuming i is the number of the process, even in the default case) or for all weights if weight = 0. See PqTails (PqTails (5.7-5)) for more details.

Note: For those familiar with the pq program, PqComputeTails uses menu item 7 of the Advanced p-Quotient menu.

5.7-7 PqAddTails
‣ PqAddTails( i, weight )( function )
‣ PqAddTails( weight )( function )

for the ith or default interactive ANUPQ process, direct the pq program to add the tails of weight weight, previously computed by PqComputeTails (see PqComputeTails (5.7-6)), if weight is in the integer range [2 .. PqPClass(i)] (assuming i is the number of the process, even in the default case) or for all weights if weight = 0. See PqTails (PqTails (5.7-5)) for more details.

Note: For those familiar with the pq program, PqAddTails uses menu item 7 of the Advanced p-Quotient menu.

5.7-8 PqDoConsistencyChecks
‣ PqDoConsistencyChecks( i, weight, type )( function )
‣ PqDoConsistencyChecks( weight, type )( function )

for the ith or default interactive ANUPQ process, do consistency checks for weight weight if weight is in the integer range [3 .. PqPClass(i)] (assuming i is the number of the process) or for all weights if weight = 0, and for type type if type is in the range [1, 2, 3] (see below) or for all types if type = 0. (For its use in the context of finding the next class see PqNextClass (5.6-4).)

The type of a consistency check is defined as follows. PqDoConsistencyChecks(i, weight, type) for weight in [3 .. PqPClass(i)] and the given value of type invokes the equivalent of the following PqDoConsistencyCheck calls (see PqDoConsistencyCheck (5.7-17)):

type = 1:

PqDoConsistencyCheck(i, a, a, a) checks 2 * PqWeight(i, a) + 1 = weight, for pc generators of index a.

type = 2:

PqDoConsistencyCheck(i, b, b, a) checks for pc generators of indices b, a satisfyingx both b > a and PqWeight(i, b) + PqWeight(i, a) + 1 = weight.

type = 3:

PqDoConsistencyCheck(i, c, b, a) checks for pc generators of indices c, b, a satisfying c > b > a and the sum of the weights of these generators equals weight.

Notes

PqWeight(i, j) returns the weight of the jth pc generator, for process i (see PqWeight (5.5-5)).

It is assumed that tails for the given weight (or weights) have already been added (see PqTails (5.7-5)).

For those familiar with the pq program, PqDoConsistencyChecks performs menu item 8 of the Advanced p-Quotient menu.

5.7-9 PqCollectDefiningRelations
‣ PqCollectDefiningRelations( i )( function )
‣ PqCollectDefiningRelations( )( function )

for the ith or default interactive ANUPQ process, direct the pq program to collect the images of the defining relations of the original fp group of the process, with respect to the current pc presentation, in the context of finding the next class (see PqNextClass (5.6-4)). If the tails operation is not complete then the relations may be evaluated incorrectly.

Note: For those familiar with the pq program, PqCollectDefiningRelations performs menu item 9 of the Advanced p-Quotient menu.

5.7-10 PqCollectWordInDefiningGenerators
‣ PqCollectWordInDefiningGenerators( i, word )( function )
‣ PqCollectWordInDefiningGenerators( word )( function )

for the ith or default interactive ANUPQ process, take a user-defined word word in the defining generators of the original presentation of the fp or pc group of the process. Each generator is mapped into the current pc presentation, and the resulting word is collected with respect to the current pc presentation. The result of the collection is returned as a list of generator number, exponent pairs.

The word argument may be input in either of the two ways described for PqCollect (see PqCollect (5.7-1)).

Note: For those familiar with the pq program, PqCollectDefiningGenerators performs menu item 23 of the Advanced p-Quotient menu.

5.7-11 PqCommutatorDefiningGenerators
‣ PqCommutatorDefiningGenerators( i, words, pow )( function )
‣ PqCommutatorDefiningGenerators( words, pow )( function )

for the ith or default interactive ANUPQ process, take a list words of user-defined words in the defining generators of the original presentation of the fp or pc group of the process, and an integer power pow. Each generator is mapped into the current pc presentation. The list words is interpreted as a left-normed commutator which is then raised to pow and collected with respect to the current pc presentation. The result of the collection is returned as a list of generator number, exponent pairs.

Note For those familiar with the pq program, PqCommutatorDefiningGenerators performs menu item 24 of the Advanced p-Quotient menu.

5.7-12 PqDoExponentChecks
‣ PqDoExponentChecks( i: [Bounds := list] )( function )
‣ PqDoExponentChecks( : [Bounds := list] )( function )

for the ith or default interactive ANUPQ process, direct the pq program to do exponent checks for weights (inclusively) between the bounds of Bounds or for all weights if Bounds is not given. The value list of Bounds (assuming the interactive process is numbered i) should be a list of two integers low, high satisfying 1 ≤ low ≤ high ≤ PqPClass(i) (see PqPClass (5.5-4)). If no exponent law has been specified, no exponent checks are performed.

Note: For those familiar with the pq program, PqDoExponentChecks performs menu item 10 of the Advanced p-Quotient menu.

5.7-13 PqEliminateRedundantGenerators
‣ PqEliminateRedundantGenerators( i )( function )
‣ PqEliminateRedundantGenerators( )( function )

for the ith or default interactive ANUPQ process, direct the pq program to eliminate redundant generators of the current p-quotient.

Note: For those familiar with the pq program, PqEliminateRedundantGenerators performs menu item 11 of the Advanced p-Quotient menu.

5.7-14 PqRevertToPreviousClass
‣ PqRevertToPreviousClass( i )( function )
‣ PqRevertToPreviousClass( )( function )

for the ith or default interactive ANUPQ process, direct the pq program to abandon the current class and revert to the previous class.

Note: For those familiar with the pq program, PqRevertToPreviousClass performs menu item 12 of the Advanced p-Quotient menu.

5.7-15 PqSetMaximalOccurrences
‣ PqSetMaximalOccurrences( i, noccur )( function )
‣ PqSetMaximalOccurrences( noccur )( function )

for the ith or default interactive ANUPQ process, direct the pq program to set maximal occurrences of the weight 1 generators in the definitions of pcp generators of the group of the process. This can be used to avoid the definition of generators of which one knows for theoretical reasons that they would be eliminated later on.

The argument noccur must be a list of non-negative integers of length the number of weight 1 generators (i.e. the rank of the class 1 p-quotient of the group of the process). An entry of 0 for a particular generator indicates that there is no limit on the number of occurrences for the generator.

Note: For those familiar with the pq program, PqSetMaximalOccurrences performs menu item 13 of the Advanced p-Quotient menu.

5.7-16 PqSetMetabelian
‣ PqSetMetabelian( i )( function )
‣ PqSetMetabelian( )( function )

for the ith or default interactive ANUPQ process, direct the pq program to enforce metabelian-ness.

Note: For those familiar with the pq program, PqSetMetabelian performs menu item 14 of the Advanced p-Quotient menu.

5.7-17 PqDoConsistencyCheck
‣ PqDoConsistencyCheck( i, c, b, a )( function )
‣ PqDoConsistencyCheck( c, b, a )( function )
‣ PqJacobi( i, c, b, a )( function )
‣ PqJacobi( c, b, a )( function )

for the ith or default interactive ANUPQ process, direct the pq program to do the consistency check for the pc generators with indices c, b, a which should be non-increasing positive integers, i.e. c ≥ b ≥ a.

There are 3 types of consistency checks:

\begin{array}{rclrl} (a^n)a &=& a(a^n) && {\rm (Type\ 1)} \\ (b^n)a &=& b^{(n-1)}(ba), b(a^n) = (ba)a^{(n-1)} && {\rm (Type\ 2)} \\ c(ba) &=& (cb)a && {\rm (Type\ 3)} \\ \end{array}

The reason some people talk about Jacobi relations instead of consistency checks becomes clear when one looks at the consistency check of type 3:

\begin{array}{rcl} c(ba) &=& a c[c,a] b[b,a] = acb [c,a][c,a,b][b,a] = \dots \\ (cb)a &=& b c[c,b] a = a b[b,a] c[c,a] [c,b][c,b,a] \\ &=& abc [b,a] [b,a,c] [c,a] [c,b] [c,b,a] = \dots \\ \end{array}

Each collection would normally carry on further. But one can see already that no other commutators of weight 3 will occur. After all terms of weight one and weight two have been moved to the left we end up with:

\begin{array}{rcl} & &abc [b,a] [c,a] [c,b] [c,a,b] \dots \\ &=&abc [b,a] [c,a] [c,b] [c,b,a] [b,a,c] \dots \\ \end{array}

Modulo terms of weight 4 this is equivalent to

[c,a,b] [b,c,a] [a,b,c] = 1

which is the Jacobi identity.

See also PqDoConsistencyChecks (PqDoConsistencyChecks (5.7-8)).

Note: For those familiar with the pq program, PqDoConsistencyCheck and PqJacobi perform menu item 15 of the Advanced p-Quotient menu.

5.7-18 PqCompact
‣ PqCompact( i )( function )
‣ PqCompact( )( function )

for the ith or default interactive ANUPQ process, direct the pq program to do a compaction of its work space. This function is safe to perform only at certain points in time.

Note: For those familiar with the pq program, PqCompact performs menu item 16 of the Advanced p-Quotient menu.

5.7-19 PqEchelonise
‣ PqEchelonise( i )( function )
‣ PqEchelonise( )( function )

for the ith or default interactive ANUPQ process, direct the pq program to echelonise the word most recently collected by PqCollect or PqCommutator against the relations of the current pc presentation, and return the number of the generator made redundant or fail if no generator was made redundant. A call to PqCollect (see PqCollect (5.7-1)) or PqCommutator (see PqCommutator (5.7-3)) needs to be performed prior to using this command.

Note: For those familiar with the pq program, PqEchelonise performs menu item 17 of the Advanced p-Quotient menu.

5.7-20 PqSupplyAutomorphisms
‣ PqSupplyAutomorphisms( i, mlist )( function )
‣ PqSupplyAutomorphisms( mlist )( function )

for the ith or default interactive ANUPQ process, supply the automorphism data provided by the list mlist of matrices with non-negative integer coefficients. Each matrix in mlist describes one automorphism in the following way.

  • The rows of each matrix correspond to the pc generators of weight one.

  • Each row is the exponent vector of the image of the corresponding weight one generator under the respective automorphism.

Note: For those familiar with the pq program, PqSupplyAutomorphisms uses menu item 18 of the Advanced p-Quotient menu.

5.7-21 PqExtendAutomorphisms
‣ PqExtendAutomorphisms( i )( function )
‣ PqExtendAutomorphisms( )( function )

for the ith or default interactive ANUPQ process, direct the pq program to extend automorphisms of the p-quotient of the previous class to the p-quotient of the present class.

Note: For those familiar with the pq program, PqExtendAutomorphisms uses menu item 18 of the Advanced p-Quotient menu.

5.7-22 PqApplyAutomorphisms
‣ PqApplyAutomorphisms( i, qfac )( function )
‣ PqApplyAutomorphisms( qfac )( function )

for the ith or default interactive ANUPQ process, direct the pq program to apply automorphisms; qfac is the queue factor e.g. 15.

Note: For those familiar with the pq program, PqCloseRelations performs menu item 19 of the Advanced p-Quotient menu.

5.7-23 PqDisplayStructure
‣ PqDisplayStructure( i: [Bounds := list] )( function )
‣ PqDisplayStructure( : [Bounds := list] )( function )

for the ith or default interactive ANUPQ process, direct the pq program to display the structure for the pcp generators numbered (inclusively) between the bounds of Bounds or for all generators if Bounds is not given. The value list of Bounds (assuming the interactive process is numbered i) should be a list of two integers low, high satisfying 1 ≤ low ≤ high ≤ PqNrPcGenerators(i) (see PqNrPcGenerators (5.5-1)). PqDisplayStructure also accepts the option OutputLevel (see 6.2).

Explanation of output

New generators are defined as commutators of previous generators and generators of class 1 or as p-th powers of generators that have themselves been defined as p-th powers. A generator is never defined as p-th power of a commutator.

Therefore, there are two cases: all the numbers on the righthand side are either the same or they differ. Below, gi refers to the ith defining generator.

  • If the righthand side numbers are all the same, then the generator is a p-th power (of a p-th power of a p-th power, etc.). The number of repeated digits say how often a p-th power has to be taken.

    In the following example, the generator number 31 is the eleventh power of generator 17 which in turn is an eleventh power and so on:

    \begintt #I 31 is defined on 17^11 = 1 1 1 1 1 \endtt So generator 31 is obtained by taking the eleventh power of generator 1 five times.

  • If the numbers are not all the same, the generator is defined by a commutator. If the first two generator numbers differ, the generator is defined as a left-normed commutator of the weight one generators, e.g.

    \begintt #I 19 is defined on [11, 1] = 2 1 1 1 1 \endtt Here, generator 19 is defined as the commutator of generator 11 and generator 1 which is the same as the left-normed commutator [x2, x1, x1, x1, x1]. One can check this by tracing back the definition of generator 11 until one gets to a generator of class 1.

  • If the first two generator numbers are identical, then the left most component of the left-normed commutator is a p-th power, e.g.

    \begintt #I 25 is defined on [14, 1] = 1 1 2 1 1 \endtt

    In this example, generator 25 is defined as commutator of generator 14 and generator 1. The left-normed commutator is

    [(x1^{11})^{11}, x2, x1, x1]

    Again, this can be verified by tracing back the definitions.

Note: For those familiar with the pq program, PqDisplayStructure performs menu item 20 of the Advanced p-Quotient menu.

5.7-24 PqDisplayAutomorphisms
‣ PqDisplayAutomorphisms( i: [Bounds := list] )( function )
‣ PqDisplayAutomorphisms( : [Bounds := list] )( function )

for the ith or default interactive ANUPQ process, direct the pq program to display the automorphism actions on the pcp generators numbered (inclusively) between the bounds of Bounds or for all generators if Bounds is not given. The value list of Bounds (assuming the interactive process is numbered i) should be a list of two integers low, high satisfying 1 ≤ low ≤ high ≤ PqNrPcGenerators(i) (see PqNrPcGenerators (5.5-1)). PqDisplayStructure also accepts the option OutputLevel (see 6.2).

Note: For those familiar with the pq program, PqDisplayAutomorphisms performs menu item 21 of the Advanced p-Quotient menu.

5.7-25 PqWritePcPresentation
‣ PqWritePcPresentation( i, filename )( function )
‣ PqWritePcPresentation( filename )( function )

for the ith or default interactive ANUPQ process, direct the pq program to write a pc presentation of a previously-computed quotient of the group of that process, to the file with name filename. Here the group of a process is the one given as first argument when PqStart was called to initiate that process (for process i the group is stored as ANUPQData.io[i].group). If the first character of the string filename is not /, filename is assumed to be the path of a writable file relative to the directory in which GAP was started. If a pc presentation has not been previously computed by the pq program, then pq is called to compute it first, effectively invoking PqPcPresentation (see PqPcPresentation (5.6-1)).

Note: For those familiar with the pq program, PqPcWritePresentation performs menu item 25 of the Advanced p-Quotient menu.

5.8 Commands from the Standard Presentation menu

5.8-1 PqSPComputePcpAndPCover
‣ PqSPComputePcpAndPCover( i: options )( function )
‣ PqSPComputePcpAndPCover( : options )( function )

for the ith or default interactive ANUPQ process, directs the pq program to compute for the group of that process a pc presentation up to the p-quotient of maximum class or the value of the option ClassBound and the p-cover of that quotient, and sets up tabular information required for computation of a standard presentation. Here the group of a process is the one given as first argument when PqStart was called to initiate that process (for process i the group is stored as ANUPQData.io[i].group).

The possible options are Prime, ClassBound, Relators, Exponent, Metabelian and OutputLevel (see Chapter ANUPQ Options for detailed descriptions of these options). The option Prime is normally determined via PrimePGroup, and so is not required unless the group doesn't know it's a p-group and HasPrimePGroup returns false.

Note: For those familiar with the pq program, PqSPComputePcpAndPCover performs option 1 of the Standard Presentation menu.

5.8-2 PqSPStandardPresentation
‣ PqSPStandardPresentation( i[, mlist]: [options] )( function )
‣ PqSPStandardPresentation( [mlist]: [options] )( function )

for the ith or default interactive ANUPQ process, inputs data given by options to compute a standard presentation for the group of that process. If argument mlist is given it is assumed to be the automorphism group data required. Otherwise it is assumed that a call to either Pq (see Pq (5.3-1)) or PqEpimorphism (see PqEpimorphism (5.3-2)) has generated a p-quotient and that GAP can compute its automorphism group from which the necessary automorphism group data can be derived. The group of the process is the one given as first argument when PqStart was called to initiate the process (for process i the group is stored as ANUPQData.io[i].group and the p-quotient if existent is stored as ANUPQData.io[i].pQuotient). If mlist is not given and a p-quotient of the group has not been previously computed a class 1 p-quotient is computed.

PqSPStandardPresentation accepts three options, all optional:

  • ClassBound := n

  • PcgsAutomorphisms

  • StandardPresentationFile := filename

If ClassBound is omitted it defaults to 63.

Detailed descriptions of the above options may be found in Chapter ANUPQ Options.

Note: For those familiar with the pq program, PqSPPcPresentation performs menu item 2 of the Standard Presentation menu.

5.8-3 PqSPSavePresentation
‣ PqSPSavePresentation( i, filename )( function )
‣ PqSPSavePresentation( filename )( function )

for the ith or default interactive ANUPQ process, directs the pq program to save the standard presentation previously computed for the group of that process to the file with name filename, where the group of a process is the one given as first argument when PqStart was called to initiate that process. If the first character of the string filename is not /, filename is assumed to be the path of a writable file relative to the directory in which GAP was started.

Note: For those familiar with the pq program, PqSPSavePresentation performs menu item 3 of the Standard Presentation menu.

5.8-4 PqSPCompareTwoFilePresentations
‣ PqSPCompareTwoFilePresentations( i, f1, f2 )( function )
‣ PqSPCompareTwoFilePresentations( f1, f2 )( function )

for the ith or default interactive ANUPQ process, direct the pq program to compare the presentations in the files with names f1 and f2 and returns true if they are identical and false otherwise. For each of the strings f1 and f2, if the first character is not a / then it is assumed to be the path of a readable file relative to the directory in which GAP was started.

Notes

The presentations in files f1 and f2 must have been generated by the pq program but they do not need to be standard presentations. If If the presentations in files f1 and f2 have been generated by PqSPStandardPresentation (see PqSPStandardPresentation (5.8-2)) then a false response from PqSPCompareTwoFilePresentations says the groups defined by those presentations are not isomorphic.

For those familiar with the pq program, PqSPCompareTwoFilePresentations performs menu item 6 of the Standard Presentation menu.

5.8-5 PqSPIsomorphism
‣ PqSPIsomorphism( i )( function )
‣ PqSPIsomorphism( )( function )

for the ith or default interactive ANUPQ process, direct the pq program to compute the isomorphism mapping from the p-group of the process to its standard presentation. This function provides a description only; for a GAP object, use EpimorphismStandardPresentation (see EpimorphismStandardPresentation (5.3-5)).

Note: For those familiar with the pq program, PqSPIsomorphism performs menu item 8 of the Standard Presentation menu.

5.9 Commands from the Main p-Group Generation menu

Note that the p-group generation commands can only be applied once the pq program has produced a pc presentation of some quotient group of the group of the process.

5.9-1 PqPGSupplyAutomorphisms
‣ PqPGSupplyAutomorphisms( i[, mlist]: options )( function )
‣ PqPGSupplyAutomorphisms( [mlist]: options )( function )

for the ith or default interactive ANUPQ process, supply the pq program with the automorphism group data needed for the current quotient of the group of that process (for process i the group is stored as ANUPQData.io[i].group). For a description of the format of mlist see PqSupplyAutomorphisms (5.7-20). The options possible are NumberOfSolubleAutomorphisms and RelativeOrders. (Detailed descriptions of these options may be found in Chapter ANUPQ Options.)

If mlist is omitted, the automorphism data is determined from the group of the process which must have been a p-group in pc presentation.

Note: For those familiar with the pq program, PqPGSupplyAutomorphisms performs menu item 1 of the main p-Group Generation menu.

5.9-2 PqPGExtendAutomorphisms
‣ PqPGExtendAutomorphisms( i )( function )
‣ PqPGExtendAutomorphisms( )( function )

for the ith or default interactive ANUPQ process, direct the pq program to compute the extensions of the automorphisms of the p-quotient of the previous class to the p-quotient of the current class. You may wish to set the InfoLevel of InfoANUPQ to 2 (or more) in order to see the output from the pq program (see InfoANUPQ (3.3-1)).

Note: For those familiar with the pq program, PqPGExtendAutomorphisms performs menu item 2 of the main or advanced p-Group Generation menu.

5.9-3 PqPGConstructDescendants
‣ PqPGConstructDescendants( i: options )( function )
‣ PqPGConstructDescendants( : options )( function )

for the ith or default interactive ANUPQ process, direct the pq program to construct descendants prescribed by options, and return the number of descendants constructed (compare function PqDescendants (4.4-1) which returns the list of descendants). The options possible are ClassBound, OrderBound, StepSize, PcgsAutomorphisms, RankInitialSegmentSubgroups, SpaceEfficient, CapableDescendants, AllDescendants, Exponent, Metabelian, BasicAlgorithm, CustomiseOutput. (Detailed descriptions of these options may be found in Chapter ANUPQ Options.)

PqPGConstructDescendants requires that the pq program has previously computed a pc presentation and a p-cover for a p-quotient of some class of the group of the process.

Note: For those familiar with the pq program, PqPGConstructDescendants performs menu item 5 of the main p-Group Generation menu.

5.9-4 PqPGSetDescendantToPcp
‣ PqPGSetDescendantToPcp( i, cls, n )( function )
‣ PqPGSetDescendantToPcp( cls, n )( function )
‣ PqPGSetDescendantToPcp( i: [Filename := name] )( function )
‣ PqPGSetDescendantToPcp( : [Filename := name] )( function )
‣ PqPGRestoreDescendantFromFile( i, cls, n )( function )
‣ PqPGRestoreDescendantFromFile( cls, n )( function )
‣ PqPGRestoreDescendantFromFile( i: [Filename := name] )( function )
‣ PqPGRestoreDescendantFromFile( : [Filename := name] )( function )

for the ith or default interactive ANUPQ process, direct the pq program to restore group n of class cls from a temporary file, where cls and n are positive integers, or the group stored in name. PqPGSetDescendantToPcp and PqPGRestoreDescendantFromFile are synonyms; they make sense only after a prior call to construct descendants by say PqPGConstructDescendants (see PqPGConstructDescendants (5.9-3)) or the interactive PqDescendants (see PqDescendants (5.3-6)). In the Filename option forms, the option defaults to the last filename in which a presentation was stored by the pq program.

Notes

Since the PqPGSetDescendantToPcp and PqPGRestoreDescendantFromFile are intended to be used in calculation of further descendants the pq program computes the p-cover of the restored descendant. Hence, PqCurrentGroup used immediately after one of these commands returns the p-cover of the restored descendant rather than the descendant itself.

For those familiar with the pq program, PqPGSetDescendantToPcp and PqPGRestoreDescendantFromFile perform menu item 3 of the main or advanced p-Group Generation menu.

5.10 Commands from the Advanced p-Group Generation menu

The functions below perform the component algorithms of PqPGConstructDescendants (see PqPGConstructDescendants (5.9-3)). You can get some idea of their usage by trying PqExample("Nott-APG-Rel-i");. You can get some idea of the breakdown of PqPGConstructDescendants into these functions by comparing the previous output with PqExample("Nott-PG-Rel-i");.

These functions are intended for use only by experts; please contact the authors of the package if you genuinely have a need for them and need any amplified descriptions.

5.10-1 PqAPGDegree
‣ PqAPGDegree( i, step, rank: [Exponent := n] )( function )
‣ PqAPGDegree( step, rank: [Exponent := n] )( function )

for the ith or default interactive ANUPQ process, direct the pq program to invoke menu item 6 of the Advanced p-Group Generation menu. Here the step-size step and the rank rank are positive integers and are the arguments required by the pq program. See 6.2 for the one recognised option Exponent.

5.10-2 PqAPGPermutations
‣ PqAPGPermutations( i: options )( function )
‣ PqAPGPermutations( : options )( function )

for the ith or default interactive ANUPQ process, direct the pq program to perform menu item 7 of the Advanced p-Group Generation menu. Here the options options recognised are PcgsAutomorphisms, SpaceEfficient, PrintAutomorphisms and PrintPermutations (see Chapter ANUPQ Options for details).

5.10-3 PqAPGOrbits
‣ PqAPGOrbits( i: options )( function )
‣ PqAPGOrbits( : options )( function )

for the ith or default interactive ANUPQ process, direct the pq to perform menu item 8 of the Advanced p-Group Generation menu.

Here the options options recognised are PcgsAutomorphisms, SpaceEfficient and CustomiseOutput (see Chapter ANUPQ Options for details). For the CustomiseOutput option only the setting of the orbit is recognised (all other fields if set are ignored).

5.10-4 PqAPGOrbitRepresentatives
‣ PqAPGOrbitRepresentatives( i: options )( function )
‣ PqAPGOrbitRepresentatives( : options )( function )

for the ith or default interactive ANUPQ process, direct the pq to perform item 9 of the Advanced p-Group Generation menu.

The options options may be any selection of the following: PcgsAutomorphisms, SpaceEfficient, Exponent, Metabelian, CapableDescendants (or AllDescendants), CustomiseOutput (where only the group and autgroup fields are recognised) and Filename (see Chapter ANUPQ Options for details). If Filename is omitted the reduced p-cover is written to the file "redPCover" in the temporary directory whose name is stored in ANUPQData.tmpdir.

5.10-5 PqAPGSingleStage
‣ PqAPGSingleStage( i: options )( function )
‣ PqAPGSingleStage( : options )( function )

for the ith or default interactive ANUPQ process, direct the pq to perform option 5 of the Advanced p-Group Generation menu.

The possible options are StepSize, PcgsAutomorphisms, RankInitialSegmentSubgroups, SpaceEfficient, CapableDescendants, AllDescendants, Exponent, Metabelian, BasicAlgorithm and CustomiseOutput. (Detailed descriptions of these options may be found in Chapter ANUPQ Options.)

5.11 Primitive Interactive ANUPQ Process Read/Write Functions

For those familiar with using the pq program as a standalone we provide primitive read/write tools to communicate directly with an interactive ANUPQ process, started via PqStart. For the most part, it is up to the user to translate the output strings from pq program into a form useful in GAP.

5.11-1 PqRead
‣ PqRead( i )( function )
‣ PqRead( )( function )

read a complete line of ANUPQ output, from the ith or default interactive ANUPQ process, if there is output to be read and returns fail otherwise. When successful, the line is returned as a string complete with trailing newline, colon, or question-mark character. Please note that it is possible to be too quick (i.e. the return can be fail purely because the output from ANUPQ is not there yet), but if PqRead finds any output at all, it waits for a complete line. PqRead also writes the line read via Info at InfoANUPQ level 2. It doesn't try to distinguish banner and menu output from other output of the pq program.

5.11-2 PqReadAll
‣ PqReadAll( i )( function )
‣ PqReadAll( )( function )

read and return as many complete lines of ANUPQ output, from the ith or default interactive ANUPQ process, as there are to be read, at the time of the call, as a list of strings with any trailing newlines removed and returns the empty list otherwise. PqReadAll also writes each line read via Info at InfoANUPQ level 2. It doesn't try to distinguish banner and menu output from other output of the pq program. Whenever PqReadAll finds only a partial line, it waits for the complete line, thus increasing the probability that it has captured all the output to be had from ANUPQ.

5.11-3 PqReadUntil
‣ PqReadUntil( i, IsMyLine )( function )
‣ PqReadUntil( IsMyLine )( function )
‣ PqReadUntil( i, IsMyLine, Modify )( function )
‣ PqReadUntil( IsMyLine, Modify )( function )

read complete lines of ANUPQ output, from the ith or default interactive ANUPQ process, chomps them (i.e. removes any trailing newline character), emits them to Info at InfoANUPQ level 2 (without trying to distinguish banner and menu output from other output of the pq program), and applies the function Modify (where Modify is just the identity map/function for the first two forms) until a chomped line line for which IsMyLine( Modify(line) ) is true. PqReadUntil returns the list of Modify-ed chomped lines read.

Notes: When provided by the user, Modify should be a function that accepts a single string argument.

IsMyLine should be a function that is able to accept the output of Modify (or take a single string argument when Modify is not provided) and should return a boolean.

If IsMyLine( Modify(line) ) is never true, PqReadUntil will wait indefinitely.

5.11-4 PqWrite
‣ PqWrite( i, string )( function )
‣ PqWrite( string )( function )

write string to the ith or default interactive ANUPQ process; string must be in exactly the form the ANUPQ standalone expects. The command is echoed via Info at InfoANUPQ level 3 (with a ToPQ> prompt); i.e. do SetInfoLevel(InfoANUPQ, 3); to see what is transmitted to the pq program. PqWrite returns true if successful in writing to the stream of the interactive ANUPQ process, and fail otherwise.

Note: If PqWrite returns fail it means that the ANUPQ process has died.

 [Top of Book]  [Contents]   [Previous Chapter]   [Next Chapter] 
Goto Chapter: Top 1 2 3 4 5 6 7 A Bib Ind

generated by GAPDoc2HTML

anupq-3.3.3/doc/intro.xml0000644000175100017510000001574515111342310014677 0ustar runnerrunner Introduction
Overview ANUPQ The &GAP; 4 package &ANUPQ; provides an interface to the ANU pq C program written by Eamonn O'Brien, making the functionality of the C program available to &GAP;. Henceforth, we shall refer to the &ANUPQ; package when referring to the &GAP; interface, and to the ANU pq program or just pq when referring to that C program.

The pq program consists of implementations of the following algorithms:

A p-quotient algorithm to compute pc-presentations for p-factor groups of finitely presented groups.

A p-group generation algorithm to generate pc presentations of groups of prime power order.

A standard presentation algorithm used to compute a canonical pc-presentation of a p-group.

An algorithm which can be used to compute the automorphism group of a p-group.

This part of the pq program is not accessible through the &ANUPQ; package. Instead, users are advised to consider the &GAP; 4 package &AutPGrp; by Bettina Eick and Eamonn O'Brien, which implements a better algorithm in &GAP; for the computation of automorphism groups of p-groups. The current version of the &ANUPQ; package requires &GAP; 4.5, and version 1.5 of the &AutPGrp; package. All code that made the package compatible with earlier versions of &GAP; has been removed. If you must use an older &GAP; version and cannot upgrade, then you may try using an older &ANUPQ; version. However, you should not use versions of the &ANUPQ; package older than 2.2, since they are known to have bugs.

How to read this manual It is not expected that readers of this manual will read it in a linear fashion from cover to cover; some sections contain material that is far too technical to be absorbed on a first reading.

Firstly, installers of the &ANUPQ; package will need to read Chapter , if they have not already gleaned these details from the README file.

Once the &ANUPQ; package is installed, users of the &ANUPQ; package will benefit most by first reading Chapter , which gives a brief description of the background and terminology used (this chapter also cites a number of references for further reading), and the introduction of Chapter  (skip the remainder of the chapter on a first reading).

Then the user/reader should pursue Chapter  in detail, delving into Chapter  as necessary for the options of the functions that are described. The user will become best acquainted with the &ANUPQ; package by trying the examples. This chapter describes the non-interactive functions of the &ANUPQ; package, i.e. one-shot functions that invoke the pq program in such a way that once &GAP; has got what it needs, the pq is allowed to exit. It is expected that most of the time, users will only need these functions.

Advanced users will want to explore Chapter  which describes all the interactive functions of the &ANUPQ; package; these are functions that extract information via a dialogue with a running pq process. Occasionally, a user needs the next step; the functions provided in this chapter make use of data from previous steps retained by the pq program, thus allowing the user to interact with the pq program like one can when one uses the pq program as a stand-alone (see guide.dvi in the standalone-doc directory).

After having read Chapters  and , cross-references will have taken the reader into Chapter ; by this stage, the reader need only read the introduction of Chapter .

After the reader has developed some facility with the &ANUPQ; package, she should explore the examples described in Appendix .

If you run into trouble using the &ANUPQ; functions, some troubleshooting hints are given in Section . If the troubleshooting hints don't help, Section  below, gives contact details for the authors of the components of the &ANUPQ; package.

Authors and Acknowledgements The C implementation of the ANU pq standalone was developed by Eamonn O'Brien.

An interactive interface using iostreams was developed with the assistance of Werner Nickel by Greg Gamble.

The &GAP; 4 version of this package was adapted from the &GAP; 3 version by Werner Nickel.

A new co-maintainer, Max Horn, joined the team in November, 2011.

The authors would like to thank Joachim Neubüser for his careful proof-reading and advice, and for formulating Chapter .

We would also like to thank Bettina Eick who by her testing and provision of examples helped us to eliminate a number of bugs and who provided a number of valuable suggestions for extensions of the package beyond the &GAP; 3 capabilities.

bug reports If you find a bug, the last section of &ANUPQ;'s README describes the information we need and where to send us a bug report; please take the time to read this (i.e. help us to help you).

anupq-3.3.3/doc/chap3.txt0000644000175100017510000011756415111342310014563 0ustar runnerrunner 3 Infrastructure Most of the details in this chapter are of a technical nature; the user need only skim over this chapter on a first reading. Mostly, it is enough to know that  you must do a LoadPackage("anupq"); before you can expect to use a command defined by the ANUPQ package (details are in Section 'Loading the ANUPQ Package');  partial results of ANUPQ commands and some other data are stored in the ANUPQData global variable (details are in Section 'The ANUPQData Record');  doing SetInfoLevel(InfoANUPQ, n); for n greater than the default value 1 will give progressively more information of what is going on behind the scenes (details are in Section 'Setting the Verbosity of ANUPQ via Info and InfoANUPQ');  in Section 'Utility Functions' we describe some utility functions and functions that run examples from the collection of examples of this package;  in Section 'Attributes and a Property for fp and pc p-groups' we describe the attributes and property NuclearRank, MultiplicatorRank and IsCapable; and  in Section 'Hints and Warnings regarding the use of Options' we describe some troubleshooting strategies. Also this section explains the utility of setting ANUPQWarnOfOtherOptions := true; (particularly for novice users) for detecting misspelt options and diagnosing other option usage problems. 3.1 Loading the ANUPQ Package To use the ANUPQ package, as with any GAP package, it must be requested explicitly. This is done by calling  Example  gap> LoadPackage( "anupq" ); --------------------------------------------------------------------------- Loading ANUPQ 3.3.3 (ANU p-Quotient) by Greg Gamble (GAP code, Greg.Gamble@uwa.edu.au),  Werner Nickel (GAP code), and  Eamonn O'Brien (C code, https://www.math.auckland.ac.nz/~obrien). maintained by:  Max Horn (https://www.quendi.de/math). uses ANU pq binary (C code program) version: 1.9 Homepage: https://gap-packages.github.io/anupq/ Report issues at https://github.com/gap-packages/anupq/issues --------------------------------------------------------------------------- true  Note that since the ANUPQ package uses the AutomorphimGroupPGroup function of the AutPGrp package and, in any case, often needs other AutPGrp functions when computing descendants, the user must ensure that the AutPGrp package is also installed, at least version 1.5. If the AutPGrp package is not installed, the ANUPQ package will fail to load. Also, if GAP cannot find a working pq binary, the call to LoadPackage will return fail. If you want to load the ANUPQ package by default, you can put the LoadPackage command into your gap.ini file (see Section Reference: The gap.ini and gaprc files in the GAP Reference Manual). By the way, the novice user of the ANUPQ package should probably also append the line  Example  ANUPQWarnOfOtherOptions := true;  to their gap.ini file, somewhere after the LoadPackage( "anupq" ); command (see ANUPQWarnOfOtherOptions (3.6-1)). 3.2 The ANUPQData Record This section contains fairly technical details which may be skipped on an initial reading. 3.2-1 ANUPQData ANUPQData  global variable is a GAP record in which the essential data for an ANUPQ session within GAP is stored; its fields are: binary the path of the pq binary; tmpdir the path of the temporary directory used by the pq binary and GAP (i.e. the directory in which all the pq's temporary files are created) (also see ANUPQDirectoryTemporary (3.2-2) below); outfile the full path of the default pq output file; SPimages the full path of the file GAP_library to which the pq program writes its Standard Presentation images; version the version of the current pq binary; ni a data record used by non-interactive functions (see below and Chapter 'Non-interactive ANUPQ functions'); io list of data records for PqStart (see below and PqStart (5.1-1)) processes; topqlogfile name of file logged to by ToPQLog (see ToPQLog (3.4-7)); and logstream stream of file logged to by ToPQLog (see ToPQLog (3.4-7)). Each time an interactive ANUPQ process is initiated via PqStart (see PqStart (5.1-1)), an identifying number ioIndex is generated for the interactive process and a record ANUPQData.io[ioIndex] with some or all of the fields listed below is created. Whenever a non-interactive function is called (see Chapter 'Non-interactive ANUPQ functions'), the record ANUPQData.ni is updated with fields that, if bound, have exactly the same purpose as for a ANUPQData.io[ioIndex] record. stream the IOStream opened for interactive ANUPQ process ioIndex or non-interactive ANUPQ function; group the group given as first argument to PqStart, Pq, PqEpimorphism, PqDescendants or PqStandardPresentation (or any synonymous methods); haspcp is bound and set to true when a pc presentation is first set inside the pq program (e.g. by PqPcPresentation or PqRestorePcPresentation or a higher order function like Pq, PqEpimorphism, PqPCover, PqDescendants or PqStandardPresentation that does a PqPcPresentation operation, but not PqStart which only starts up an interactive ANUPQ process); gens a list of the generators of the group group as strings (the same as those passed to the pq program); rels a list of the relators of the group group as strings (the same as those passed to the pq program); name the name of the group whose pc presentation is defined by a call to the pq program (according to the pq program -- unless you have used the GroupName option (see e.g. Pq (4.1-1)) or applied the function SetName (see SetName (Reference: Name)) to the group, the generic name "[grp]" is set as a default); gpnum if not a null string, the number (i.e. the unique label assigned by the pq program) of the last descendant processed; class the largest lower exponent-p central class of a quotient group of the group (usually group) found by a call to the pq program; forder the factored order of the quotient group of largest lower exponent-p central class found for the group (usually group) by a call to the pq program (this factored order is given as a list [p,n], indicating an order of p^n); pcoverclass the lower exponent-p central class of the p-covering group of a p-quotient of the group (usually group) found by a call to the pq program; workspace the workspace set for the pq process (either given as a second argument to PqStart, or set by default to 10000000); menu the current menu of the pq process (the pq program is managed by various menus, the details of which the user shouldn't normally need to know about -- the menu field remembers which menu the pq process is currently in); outfname is the file to which pq output is directed, which is always ANUPQData.outfile, except when option SetupFile is used with a non-interactive function, in which case outfname is set to "PQ_OUTPUT"; pQuotient is set to the value returned by Pq (see Pq (4.1-1)) (the field pQepi is also set at the same time); pQepi is set to the value returned by PqEpimorphism (see PqEpimorphism (4.1-2)) (the field pQuotient is also set at the same time); pCover is set to the value returned by PqPCover (see PqPCover (4.1-3)); SP is set to the value returned by PqStandardPresentation or StandardPresentation (see PqStandardPresentation (5.3-4)) when called interactively, for process i (the field SPepi is also set at the same time); SPepi is set to the value returned by EpimorphismPqStandardPresentation or EpimorphismStandardPresentation (see EpimorphismPqStandardPresentation (5.3-5)) when called interactively, for process i (the field SP is also set at the same time); descendants is set to the value returned by PqDescendants (see PqDescendants (4.4-1)); treepos if set by a call to PqDescendantsTreeCoclassOne (see PqDescendantsTreeCoclassOne (A.4-1)), it contains a record with fields class, node and ndes being the information that determines the last descendant with a non-zero number of descendants processed; xgapsheet if set by a call to PqDescendantsTreeCoclassOne (see PqDescendantsTreeCoclassOne (A.4-1)) during an XGAP session, it contains the XGAP Sheet on which the descendants tree is displayed; and nextX if set by a call to PqDescendantsTreeCoclassOne (see PqDescendantsTreeCoclassOne (A.4-1)) during an XGAP session, it contains a list of integers, the ith entry of which is the x-coordinate of the next node (representing a descendant) for the ith class. 3.2-2 ANUPQDirectoryTemporary ANUPQDirectoryTemporary( dir )  function calls the UNIX command mkdir to create dir, which must be a string, and if successful a directory object for dir is both assigned to ANUPQData.tmpdir and returned. The field ANUPQData.outfile is also set to be a file in ANUPQData.tmpdir, and on exit from GAP dir is removed. Most users will never need this command; by default, GAP typically chooses a random subdirectory of /tmp for ANUPQData.tmpdir which may occasionally have limits on what may be written there. ANUPQDirectoryTemporary permits the user to choose a directory (object) where one is not so limited. 3.3 Setting the Verbosity of ANUPQ via Info and InfoANUPQ 3.3-1 InfoANUPQ InfoANUPQ  info class The input to and the output from the pq program is, by default, not displayed. However the user may choose to see some, or all, of this input/output. This is done via the Info mechanism (see Section Reference: Info Functions in the GAP Reference Manual). For this purpose, there is the InfoClass InfoANUPQ. If the InfoLevel of InfoANUPQ is high enough each line of pq input/output is directed to a call to Info and will be displayed for the user to see. By default, the InfoLevel of InfoANUPQ is 1, and it is recommended that you leave it at this level, or higher. Messages that the user should presumably want to see and output from the pq program influenced by the value of the option OutputLevel (see the options listed in Section Pq (4.1-1)), other than timing and memory usage are directed to Info at InfoANUPQ level 1. To turn off all InfoANUPQ messaging, set the InfoANUPQ level to 0. There are five other user-intended InfoANUPQ levels: 2, 3, 4, 5 and 6.  Example  gap> SetInfoLevel(InfoANUPQ, 2);  enables the display of most timing and memory usage data from the pq program, and also the number of identity instances when the Identities option is used. (Some timing and memory usage data, particularly when profuse in quantity, is Info-ed at InfoANUPQ level 3 instead.) Note that the the GAP functions time and Runtime (see Runtime (Reference: Runtime) in the GAP Reference Manual) count the time spent by GAP and not the time spent by the (external) pq program.  Example  gap> SetInfoLevel(InfoANUPQ, 3);  enables the display of output of the nature of the first two InfoANUPQ that was not directly invoked by the user (e.g. some commands require GAP to discover something about the current state known to the pq program). The identity instances processed under the Identities option are also displayed at this level. In some cases, the pq program produces a lot of output despite the fact that the OutputLevel (see 6.2) is unset or is set to 0; such output is also Info-ed at InfoANUPQ level 3.  Example  gap> SetInfoLevel(InfoANUPQ, 4);  enables the display of all the commands directed to the pq program, behind a ToPQ>  prompt (so that you can distinguish it from the output from the pq program). See Section 'Hints and Warnings regarding the use of Options' for an example of how this can be a useful troubleshooting tool.  Example  gap> SetInfoLevel(InfoANUPQ, 5);  enables the display of the pq program's prompts for input. Finally,  Example  gap> SetInfoLevel(InfoANUPQ, 6);  enables the display of all other output from the pq program, namely the banner and menus. However, the timing data printed when the pq program exits can never be observed. 3.4 Utility Functions 3.4-1 PqLeftNormComm PqLeftNormComm( elts )  function returns for a list of elements of some group (e.g. elts may be a list of words in the generators of a free or fp group) the left normed commutator of elts, e.g. if w1, w2, w3 are such elements then PqLeftNormComm( [w1, w2, w3] ); is equivalent to Comm( Comm( w1, w2 ), w3 );. Note: elts must contain at least two elements. 3.4-2 PqGAPRelators PqGAPRelators( group, rels )  function returns a list of words that GAP understands, given a list rels of strings in the string representations of the generators of the fp group group prepared as a list of relators for the pq program. Note: The pq program does not use / to indicate multiplication by an inverse and uses square brackets to represent (left normed) commutators. Also, even though the pq program accepts relations, all elements of rels must be in relator form, i.e. a relation of form w1 = w2 must be written as w1*(w2)^-1. Here is an example:  Example  gap> F := FreeGroup("a", "b");  gap> PqGAPRelators(F, [ "a*b^2", "[a,b]^2*a", "[a,b,a,b]^a" ]); [ a*b^2, (a^-1*b^-1*a*b)^2*a,   a^-2*b^-1*a^-1*b*(a*b^-1)^2*a^-1*b*a^-1*b^-1*(a*b)^2*a ]  3.4-3 PqParseWord PqParseWord( word, n )  function parses a word, a string representing a word in the pc generators x1,...,xn, through GAP. This function is provided as a rough-and-ready check of word for syntax errors. A syntax error will cause the entering of a break-loop, in which the error message may or may not be meaningful (depending on whether the syntax error gets caught at the GAP or kernel level). Note: The reason the generators must be x1,...,xn is that these are the pc generator names used by the pq program (as distinct from the generator names for the group provided by the user to a function like Pq that invokes the pq program). 3.4-4 PqExample PqExample( )  function PqExample( example[, PqStart][, Display] )  function PqExample( example[, PqStart][, filename] )  function With no arguments, or with single argument "index", or a string example that is not the name of a file in the examples directory, an index of available examples is displayed. With just the one argument example that is the name of a file in the examples directory, the example contained in that file is executed in its simplest form. Some examples accept options which you may use to modify some of the options used in the commands of the example. To find out which options an example accepts, use one of the mechanisms for displaying the example described below. Some examples have both non-interactive and interactive forms; those that are non-interactive only have a name ending in -ni; those that are interactive only have a name ending in -i; examples with names ending in .g also have only one form; all other examples have both non-interactive and interactive forms and for these giving PqStart as second argument invokes PqStart initially and makes the appropriate adjustments so that the example is executed or displayed using interactive functions. If PqExample is called with last (second or third) argument Display then the example is displayed without being executed. If the last argument is a non-empty string filename then the example is also displayed without being executed but is also written to a file with that name. Passing an empty string as last argument has the same effect as passing Display. Note: The variables used in PqExample are local to the running of PqExample, so there's no danger of having some of your variables over-written. However, they are not completely lost either. They are saved to a record ANUPQData.examples.vars, i.e. if F is a variable used in the example then you will be able to access it after PqExample has finished as ANUPQData.examples.vars.F. 3.4-5 AllPqExamples AllPqExamples( )  function returns a list of all currently available examples in default UNIX-listing (i.e. alphabetic) order. 3.4-6 GrepPqExamples GrepPqExamples( string )  function runs the UNIX command grep string over the ANUPQ examples and returns the list of examples for which there is a match. The actual matches are Info-ed at InfoANUPQ level 2. 3.4-7 ToPQLog ToPQLog( [filename] )  function With string argument filename, ToPQLog opens the file with name filename for logging; all commands written to the pq binary (that are Info-ed behind a ToPQ>  prompt at InfoANUPQ level 4) are then also written to that file (but without prompts). With no argument, ToPQLog stops logging to whatever file was being logged to. If a file was already being logged to, that file is closed and the file with name filename is opened for logging. 3.5 Attributes and a Property for fp and pc p-groups 3.5-1 NuclearRank NuclearRank( G )  attribute MultiplicatorRank( G )  attribute IsCapable( G )  property return the nuclear rank of G, p-multiplicator rank of G, and whether G is capable (i.e. true if it is, or false if it is not), respectively. These attributes and property are set automatically if G is one of the following:  an fp group returned by PqStandardPresentation or StandardPresentation (see PqStandardPresentation (4.2-1));  the image (fp group) of the epimorphism returned by an EpimorphismPqStandardPresentation or EpimorphismStandardPresentation call (see EpimorphismPqStandardPresentation (4.2-2)); or  one of the pc groups of the list of descendants returned by PqDescendants (see PqDescendants (4.4-1)). If G is an fp group or a pc p-group and not one of the above and the attribute or property has not otherwise been set for G, then PqStandardPresentation is called to set all three of NuclearRank, MultiplicatorRank and IsCapable, before returning the value of the attribute or property actually called. Such a group G must know in advance that it is a p-group; this is the case for the groups returned by the functions Pq and PqPCover, and the image group of the epimorphism returned by PqEpimorphism. Otherwise, if you know the group to be a p-group, then this can be set by typing  SetIsPGroup( G, true );  or by invoking IsPGroup( G ). Note that for an fp group G, the latter may result in a coset enumeration which might not terminate in a reasonable time. Note: For G such that HasNuclearRank(G) = true, IsCapable(G) is equivalent to (the truth or falsity of) NuclearRank( G ) = 0. 3.6 Hints and Warnings regarding the use of Options On a first reading we recommend you skip this section and come back to it if and when you run into trouble. Note: By options we refer to GAP options. The pq program also uses the term option; to distinguish the two usages of option, in this manual we use the term menu item to refer to what the pq program refers to as an option. Options are passed to the ANUPQ interface functions in either of the two usual mechanisms provided by GAP, namely:  options may be set globally using the function PushOptions (see Chapter Reference: Options Stack in the GAP Reference Manual); or  options may be appended to the argument list of any function call, separated by a colon from the argument list (see Chapter Reference: Function Calls in the GAP Reference Manual), in which case they are then passed on recursively to any subsequent inner function call, which may in turn have options of their own. Particularly, when one is using the interactive functions of Chapter 'Interactive ANUPQ functions', one should, in general, avoid using the global method of passing options. In fact, it is recommended that prior to calling PqStart the OptionsStack be empty. The essential problem with setting options globally using the function PushOptions is that options pushed onto OptionsStack, in this way, (generally) remain there until an explicit PopOptions() call is made. In contrast, options passed in the usual way behind a colon following a function's arguments (see Reference: Function Call With Options in the GAP Reference Manual) are local, and disappear from OptionsStack after the function has executed successfully. If the function does not execute successfully, i.e. it runs into error and the user quits the resulting break loop (see Section Reference: Break Loops in the Reference Manual) rather than attempting to repair the problem and typing return; then, unless the error at the kernel level, the OptionsStack is reset. If an error is detected inside the kernel (hopefully, this should occur only rarely, if at all) then the options of that function will not be cleared from OptionsStack; in such cases:  Example  gap> ResetOptionsStack(); #I Options stack is already empty  is usually necessary (see Chapter ResetOptionsStack (Reference: ResetOptionsStack) in the GAP Reference Manual), which recursively calls PopOptions() until OptionsStack is empty, or as in the above case warns you that the OptionsStack is already empty. Note that a function, that is passed options after the colon, will also see any global options or any options passed down recursively from functions calling that function, unless those options are over-ridden by options passed via the function. Also, note that duplication of option names for different programs may lead to misinterpretations, and mis-spelled options will not be seen. The non-interactive functions of Chapter 'Non-interactive ANUPQ functions' that have Pq somewhere in their name provide an alternative method of passing options as additional arguments. This has the advantages that options can be abbreviated and mis-spelled options will be trapped. 3.6-1 ANUPQWarnOfOtherOptions ANUPQWarnOfOtherOptions  global variable is a global variable that is by default false. If it is set to true then any function provided by the ANUPQ function that recognises at least one option, will warn you of other options, i.e. options that the function does not recognise. These warnings are emitted at InfoWarning or InfoANUPQ level 1. This is useful for detecting mis-spelled options. Here is an example using the function Pq (first described in Chapter 'Non-interactive ANUPQ functions'):  Example  gap> SetInfoLevel(InfoANUPQ, 1); # Set InfoANUPQ to default level gap> ANUPQWarnOfOtherOptions := true;; gap> # The following makes entry into break loops very ``quiet'' ... gap> OnBreak := function() Where(0); end;; gap> F := FreeGroup( "a", "b" );  gap> Pq( F : Prime := 2, Classbound := 1 ); #I ANUPQ Warning: Options: [ "Classbound" ] ignored #I (invalid for generic function: `Pq'). user interrupt at moreOfline := ReadLine( iostream ); Entering break read-eval-print loop ... you can 'quit;' to quit to outer loop, or you can 'return;' to continue  Here we mistyped ClassBound as Classbound, and after seeing the Info-ed warning that Classbound was ignored, we typed a control-C (that's the user interrupt at message) which took us into a break loop. Since the Pq command was not able to finish, the options Prime and Classbound, in particular, will still be on the OptionsStack:  Example  brk> OptionsStack; [ rec( Prime := 2, Classbound := 1 ),   rec( Prime := 2, Classbound := 1, PqEpiOrPCover := "pQuotient" ) ]  The option PqEpiOrPCover is a behind-the-scenes option that need not concern the user. On quitting the break-loop the OptionsStack is reset and a warning telling you this is emitted:  Example  brk> quit; # to get back to the `gap>' prompt #I Options stack has been reset  Above, we altered OnBreak (see OnBreak (Reference: OnBreak) in the Reference manual) to reduce the back-tracing on entry into a break loop. We now restore OnBreak to its usual value.  Example  gap> OnBreak := Where;;  Notes In cases where functions recursively call others with options (e.g. when using PqExample with options), setting ANUPQWarnOfOtherOptions := true may give rise to spurious other option detections. It is recommended that the novice user set ANUPQWarnOfOtherOptions to true in their gap.ini file (see Section 'Loading the ANUPQ Package'). Other Troubleshooting Strategies There are some other strategies which may have helped us to see our error above. The function Pq recognises the option OutputLevel (see 6.2); if this option is set to at least 1, the pq program provides information on each class quotient as it is generated:  Example  gap> ANUPQWarnOfOtherOptions := false;; # Set back to normal gap> F := FreeGroup( "a", "b" );; gap> Pq( F : Prime := 2, Classbound := 1, OutputLevel := 1 );  #I Lower exponent-2 central series for [grp] #I Group: [grp] to lower exponent-2 central class 1 has order 2^2 #I Group: [grp] to lower exponent-2 central class 2 has order 2^5 #I Group: [grp] to lower exponent-2 central class 3 has order 2^10 #I Group: [grp] to lower exponent-2 central class 4 has order 2^18 #I Group: [grp] to lower exponent-2 central class 5 has order 2^32 #I Group: [grp] to lower exponent-2 central class 6 has order 2^55 #I Group: [grp] to lower exponent-2 central class 7 has order 2^96 #I Group: [grp] to lower exponent-2 central class 8 has order 2^167 #I Group: [grp] to lower exponent-2 central class 9 has order 2^294 #I Group: [grp] to lower exponent-2 central class 10 has order 2^520 #I Group: [grp] to lower exponent-2 central class 11 has order 2^932 #I Group: [grp] to lower exponent-2 central class 12 has order 2^1679 [... output truncated ...]  After seeing the information for the class 2 quotient we may have got the idea that the Classbound option was not recognised and may have realised that this was due to a mis-spelling. The above will ordinarily cause the available space to be exhausted, necessitating user-intervention by typing control-C and quit; (to escape the break loop); otherwise Pq terminates when the class reaches 63 (the default value of ClassBound). If you have some familiarity with keyword command input to the pq binary, then setting the level of InfoANUPQ to 4 would also have indicated a problem:  Example  gap> ResetOptionsStack(); # Necessary, if a break-loop was entered above gap> SetInfoLevel(InfoANUPQ, 4); gap> Pq( F : Prime := 2, Classbound := 1 ); #I ToPQ> 7 #to (Main) p-Quotient Menu #I ToPQ> 1 #define group #I ToPQ> name [grp] #I ToPQ> prime 2 #I ToPQ> class 63 #I ToPQ> exponent 0 #I ToPQ> output 0 #I ToPQ> generators { a,b } #I ToPQ> relators { }; [... output truncated ...]  Here the line #I ToPQ> class 63 indicates that a directive to set the classbound to 63 was sent to the pq program. anupq-3.3.3/doc/chap7.html0000644000175100017510000003631115111342310014702 0ustar runnerrunner GAP (ANUPQ) - Chapter 7: Installing the ANUPQ Package
Goto Chapter: Top 1 2 3 4 5 6 7 A Bib Ind
 [Top of Book]  [Contents]   [Previous Chapter]   [Next Chapter] 

7 Installing the ANUPQ Package
 7.1 Testing your ANUPQ installation
 7.2 Running the pq program as a standalone

7 Installing the ANUPQ Package

The ANU pq program is written in C and the package can be installed under UNIX and in environments similar to UNIX. In particular it is known to work on Linux and Mac OS X, and also on Windows equipped with cygwin.

The current version of the ANUPQ package requires GAP 4.9, and version 1.2 of the AutPGrp package. However, we recommend using at least GAP 4.6 and AutPGrp 1.5.

To install the ANUPQ package, move the file anupq-XXX.tar.gz for some version number XXX into the pkg directory in which you plan to install ANUPQ. Usually, this will be the directory pkg in the hierarchy of your version of GAP; it is however also possible to keep an additional pkg directory in your private directories. The only essential difference with installing ANUPQ in a pkg directory different to the GAP home directory is that one must start GAP with the -l switch (see Section Reference: Command Line Options), e.g. if your private pkg directory is a subdirectory of mygap in your home directory you might type:

gap -l ";myhomedir/mygap"

where myhomedir is the path to your home directory, which may be replaced by a tilde. The empty path before the semicolon is filled in by the default path of the GAP home directory.

Then, in your chosen pkg directory, unpack anupq-XXX.tar.gz by

tar xf anupq-<XXX>.tar.gz

Change to the newly created anupq directory. Now you need to call configure. If you installed ANUPQ into the main pkg directory, call

./configure

If you installed ANUPQ in another directory than the usual 'pkg' subdirectory, instead call

./configure --with-gaproot=<path>

where path is the path to the GAP home directory. (You can also call

./configure --help

for further options.)

What this does is look for a file sysinfo.gap in the root directory of GAP in order to determine an architecture name for the subdirectory of bin in which to put the compiled pq binary. This only makes sense if GAP was compiled for the same architecture that pq will be. If you have a shared file system mounted across different architectures, then you should run configure and make for ANUPQ for each architecture immediately after compiling GAP on the same architecture.

If you had to install the package in your own directory but wish to use the system GAP then you will need to find out what path is. To do this, start up GAP and find out what GAP's root path is from finding the value of the variable GAPInfo.RootPaths, e.g.

gap> GAPInfo.RootPaths;
[ "/usr/local/lib/gap4r4/" ]

would tell you to use /usr/local/lib/gap4r4 for path.

The configure command will fetch the architecture type for which GAP has been compiled last and create a Makefile. You can now simply call

make

to compile the binary and to install it in the appropriate place.

The path of GAP (see Note below) used by the pq binary (the value GAP is set to in the make command) may be over-ridden by setting the environment variable ANUPQ_GAP_EXEC. These values are only of interest when the pq program is run as a standalone; however, the testPq script assumes you have set one of these correctly (see Section Testing your ANUPQ installation). When the pq program is started from GAP communication occurs via an iostream, so that the pq binary does not actually need to know a valid path for GAP is this case.

Note. By path of GAP we mean the path of the command used to invoke GAP (which should be a script, e.g. the gap.sh script generated in the bin directory for the version of GAP when GAP was compiled). The usual strategy is to copy the gap.sh script to a standard location, e.g. /usr/local/bin/gap. It is a mistake to copy the GAP executable gap (in a directory with name of form bin/compile-platform) to the standard location, since direct invocation of the executable results in GAP starting without being able to find its own library (a fatal error).

7.1 Testing your ANUPQ installation

Now it is time to test the installation. After doing configure and make you will have a testPq script. The script assumes that, if the environment variable ANUPQ_GAP_EXEC is set, it is a correct path for GAP, or otherwise that the make call that compiled the pq program set GAP to a correct path for GAP (see Section Running the pq program as a standalone for more details). To run the tests, just type:

./testPq

Some of the tests the script runs take a while. Please be patient. The script checks that you not only have a correct GAP (at least version 4.4) installation that includes the AutPGrp package, but that the ANUPQ package and its pq binary interact correctly. You should see something like the following output:

Made dir: /tmp/testPq
Testing installation of ANUPQ Package (version 3.1)
 
The first two tests check that the pq C program compiled ok.
Testing the pq binary ... OK.
Testing the pq binary's stack size ... OK.
The pq C program compiled ok! We test it's the right one below.
 
The next tests check that you have the right version of GAP
for the ANUPQ package and that GAP is finding
the right versions of the ANUPQ and AutPGrp packages.
 
Checking GAP ...
 pq binary made with GAP set to: /usr/local/bin/gap
 Starting GAP to determine version and package availability ...
  GAP version (4.6.5) ... OK.
  GAP found ANUPQ package (version 3.1) ... good.
  GAP found pq binary (version 1.9) ... good.
  GAP found AutPGrp package (version 1.5) ... good.
 GAP is OK.
 
Checking the link between the pq binary and GAP ... OK.
Testing the standard presentation part of the pq binary ... OK.
Doing p-group generation (final GAP/ANUPQ) test ... OK.
Tests complete.
Removed dir: /tmp/testPq
Enjoy using your functional ANUPQ package!

7.2 Running the pq program as a standalone

When the pq program is run as a standalone it sometimes needs to call GAP to compute stabilisers of subgroups; in doing so, it first checks the value of the environment variable ANUPQ_GAP_EXEC, and uses that, if set, or otherwise the value of GAP it was compiled with, as the path for GAP. If you ran testPq (see Section Testing your ANUPQ installation) and you got both GAP is OK and the link between the pq binary and GAP is OK, you should be fine. Otherwise heed the recommendations of the error messages you get and run the testPq until all tests are passed.

It is especially important that the GAP, whose path you gave, should know where to find the ANUPQ and AutPGrp packages. To ensure this the path should be to a shell script that invokes GAP. If you needed to install the needed packages in your own directory (because, say, you are not a system administrator) then you should create your own shell script that runs GAP with a correct setting of the -l option and set the path used by the pq binary to the path of that script. To create the script that runs GAP it is easiest to copy the system one and edit it, e.g. start by executing the following UNIX commands (skip the second step if you already have a bin directory; you@unix> is your UNIX prompt):

you@unix> cd
you@unix> mkdir bin
you@unix> cd bin
you@unix> which gap
/usr/local/bin/gap
you@unix> cp /usr/local/bin/gap mygap
you@unix> chmod +x mygap

At the second-last step use the path of GAP returned by which gap. Now hopefully you will have a copy of the script that runs the system GAP in mygap. Now use your favourite editor to edit the -l part of the last line of mygap which should initially look something like:

exec $GAP_DIR/bin/$GAP_PRG -m $GAP_MEM -o 970m -l $GAP_DIR $*

so that it becomes (the tilde is a UNIX abbreviation for your home directory):

exec $GAP_DIR/bin/$GAP_PRG -m $GAP_MEM -o 970m -l "$GAP_DIR;~/gapstuff" $*

assuming that your personal GAP pkg directory is a subdirectory of gapstuff in your home directory. Finally, to let the pq program know where GAP is and also know where your pkg directory is that contains ANUPQ, set the environment variable ANUPQ_GAP_EXEC to the complete (i.e. absolute) path of your mygap script (do not use the tilde abbreviation).

 [Top of Book]  [Contents]   [Previous Chapter]   [Next Chapter] 
Goto Chapter: Top 1 2 3 4 5 6 7 A Bib Ind

generated by GAPDoc2HTML

anupq-3.3.3/doc/options.xml0000644000175100017510000006445515111342310015241 0ustar runnerrunner ANUPQ Options
Overview In this chapter we describe in detail all the options used by functions of the &ANUPQ; package. Note that by options we mean &GAP; options that are passed to functions after the arguments and separated from the arguments by a colon as described in Chapter  in the Reference Manual. The user is strongly advised to read Section . lists all the &GAP; options defined for functions of the &ANUPQ; package: AllANUPQoptions(); [ "AllDescendants", "BasicAlgorithm", "Bounds", "CapableDescendants", "ClassBound", "CustomiseOutput", "Exponent", "Filename", "GroupName", "Identities", "Metabelian", "NumberOfSolubleAutomorphisms", "OrderBound", "OutputLevel", "PcgsAutomorphisms", "PqWorkspace", "Prime", "PrintAutomorphisms", "PrintPermutations", "QueueFactor", "RankInitialSegmentSubgroups", "RedoPcp", "RelativeOrders", "Relators", "SetupFile", "SpaceEfficient", "StandardPresentationFile", "StepSize", "SubList", "TreeDepth", "pQuotient" ] ]]> The following global variable gives a partial breakdown of where the above options are used. is a record of lists of names of admissible &ANUPQ; options, such that each field is either the name of a key &ANUPQ; function or other (for a miscellaneous list of functions) and the corresponding value is the list of option names that are admissible for the function (or miscellaneous list of functions).

Also, from within a &GAP; session, you may use &GAP;'s help browser (see Chapter  in the &GAP; Reference Manual); to find out about any particular &ANUPQ; option, simply type: ?option option, where option is one of the options listed above without any quotes, e.g. ?option Prime ]]> will display the sections in this manual that describe the Prime option. In fact the first 4 are for the functions that have Prime as an option and the last actually describes the option. So follow up by choosing ?5 ]]> This is also the pattern for other options (the last section of the list always describes the option; the other sections are the functions with which the option may be used).

In the section following we describe in detail all &ANUPQ; options. To continue onto the next section on-line using &GAP;'s help browser, type: ?> ]]>

Detailed descriptions of ANUPQ Options Prime := p Specifies that the p-quotient for the prime p should be computed. ClassBound := n Specifies that the p-quotient to be computed has lower exponent-p class at most n. If this option is omitted a default of 63 (which is the maximum possible for the pq program) is taken, except for PqDescendants (see ) and in a special case of PqPCover (see ). Let F be the argument (or start group of the process in the interactive case) for the function; then for PqDescendants the default is PClassPGroup(F) + 1, and for the special case of PqPCover the default is PClassPGroup(F). pQuotient := Q This option is only available for the standard presentation functions. It specifies that a p-quotient of the group argument of the function or group of the process is the pc p-group Q, where Q is of class less than the provided (or default) value of ClassBound. If pQuotient is provided, then the option Prime if also provided, is ignored; the prime p is discovered by computing PrimePGroup(Q). Exponent := n Specifies that the p-quotient to be computed has exponent n. For an interactive process, Exponent defaults to a previously supplied value for the process. Otherwise (and non-interactively), the default is 0, which means that no exponent law is enforced. Relators := rels Specifies that the relators sent to the pq program should be rels instead of the relators of the argument group F (or start group in the interactive case) of the calling function; rels should be a list of strings in the string representations of the generators of F, and F must be an fp group (even if the calling function accepts a pc group). This option provides a way of giving relators to the pq program, without having them pre-expanded by &GAP;, which can sometimes effect a performance loss of the order of 100 (see Section ).

Notes The pq program does not use / to indicate multiplication by an inverse and uses square brackets to represent (left normed) commutators. Also, even though the pq program accepts relations, all elements of rels must be in relator form, i.e. a relation of form w1 = w2 must be written as w1*(w2)^-1 and then put in a pair of double-quotes to make it a string. See the example below. To ensure there are no syntax errors in rels, each relator is parsed for validity via PqParseWord (see ). If they are ok, a message to say so is Info-ed at InfoANUPQ level 2. Metabelian Specifies that the largest metabelian p-quotient subject to any other conditions specified by other options be constructed. By default this restriction is not enforced. GroupName := name Specifies that the pq program should refer to the group by the name name (a string). If GroupName is not set and the group has been assigned a name via SetName (see ) it is set as the name the pq program should use. Otherwise, the generic name "[grp]" is set as a default. Identities := funcs Specifies that the pc presentation should satisfy the laws defined by each function in the list funcs. This option may be called by Pq, PqEpimorphism, or PqPCover (see ). Each function in the list funcs must return a word in its arguments (there may be any number of arguments). Let identity be one such function in funcs. Then as each lower exponent p-class quotient is formed, instances identity(w1, \dots, wn) are added as relators to the pc presentation, where w1, \dots, wn are words in the pc generators of the quotient. At each class the class and number of pc generators is Info-ed at InfoANUPQ level 1, the number of instances is Info-ed at InfoANUPQ level 2, and the instances that are evaluated are Info-ed at InfoANUPQ level 3. As usual timing information is Info-ed at InfoANUPQ level 2; and details of the processing of each instance from the pq program (which is often quite voluminous) is Info-ed at InfoANUPQ level 3. Try the examples "B2-4-Id" and "11gp-3-Engel-Id" which demonstrate the usage of the Identities option; these are run using PqExample (see ). Take note of Note 1. below in relation to the example "B2-4-Id"; the companion example "B2-4" generates the same group using the Exponent option. These examples are discussed at length in Section .

Notes Setting the InfoANUPQ level to 3 or more when setting the Identities option may slow down the computation considerably, by overloading &GAP; with io operations. The Identities option is implemented at the &GAP; level. An identity that is just an exponent law should be specified using the Exponent option (see ), which is implemented at the C level and is highly optimised and so is much more efficient. The number of instances of each identity tends to grow combinatorially with the class. So care should be exercised in using the Identities option, by including other restrictions, e.g. by using the ClassBound option (see ). OutputLevel := n Specifies the level of verbosity of the information output by the ANU pq program when computing a pc presentation; n must be an integer in the range 0 to 3. OutputLevel := 0 displays at most one line of output and is the default; OutputLevel := 1 displays (usually) slightly more output and OutputLevels of 2 and 3 are two levels of verbose output. To see these messages from the pq program, the InfoANUPQ level must be set to at least 1 (see ). See Section  for an example of how OutputLevel can be used as a troubleshooting tool. RedoPcp Specifies that the current pc presentation (for an interactive process) stored by the pq program be scrapped and clears the current values stored for the options Prime, ClassBound, Exponent and Metabelian and also clears the pQuotient, pQepi and pCover fields of the data record of the process. SetupFile := filename Non-interactively, this option directs that pq should not be called and that an input file with name filename (a string), containing the commands necessary for the ANU pq standalone, be constructed. The commands written to filename are also Info-ed behind a ToPQ> prompt at InfoANUPQ level 4 (see ). Except in the case following, the calling function returns true. If the calling function is the non-interactive version of one of Pq, PqPCover or PqEpimorphism and the group provided as argument is trivial given with an empty set of generators, then no setup file is written and fail is returned (the pq program cannot do anything useful with such a group). Interactively, SetupFile is ignored.

Note: Since commands emitted to the pq program may depend on knowing what the current state is, to form a setup file some close enough guesses may sometimes be necessary; when this occurs a warning is Info-ed at InfoANUPQ or InfoWarning level 1. To determine whether the close enough guesses give an accurate setup file, it is necessary to run the command without the SetupFile option, after either setting the InfoANUPQ level to at least 4 (the setup file script can then be compared with the ToPQ> commands that are Info-ed) or setting a pq command log file by using ToPQLog (see ). PqWorkspace := workspace Non-interactively, this option sets the memory used by the pq program. It sets the maximum number of integer-sized elements to allocate in its main storage array. By default, the pq program sets this figure to 10000000. Interactively, PqWorkspace is ignored; the memory used in this case may be set by giving PqStart a second argument (see ). PcgsAutomorphisms PcgsAutomorphisms := false Let G be the group associated with the calling function (or associated interactive process). Passing the option PcgsAutomorphisms without a value (or equivalently setting it to true), specifies that a polycyclic generating sequence for the automorphism group (which must be soluble) of G, be computed and passed to the pq program. This increases the efficiency of the computation; it also prevents the pq from calling &GAP; for orbit-stabilizer calculations. By default, PcgsAutomorphisms is set to the value returned by IsSolvable( AutomorphismGroup( G ) ), and uses the package &AutPGrp; to compute AutomorphismGroup( G ) if it is installed. This flag is set to true or false in the background according to the above criterion by the function PqDescendants (see  and ).

Note: If PcgsAutomorphisms is used when the automorphism group of G is insoluble, an error message occurs. OrderBound := n Specifies that only descendants of size at most p^{n}, where n is a non-negative integer, be generated. Note that you cannot set both OrderBound and StepSize. StepSize := n StepSize := list For a positive integer n, StepSize specifies that only those immediate descendants which are a factor p^{n} bigger than their parent group be generated.

For a list list of positive integers such that the sum of the length of list and the exponent-p class of G is equal to the class bound defined by the option ClassBound, StepSize specifies that the integers of list are the step sizes for each additional class. RankInitialSegmentSubgroups := n Sets the rank of the initial segment subgroup chosen to be n. By default, this has value 0. SpaceEfficient Specifies that the pq program performs certain calculations of p-group generation more slowly but with greater space efficiency. This flag is frequently necessary for groups of large Frattini quotient rank. The space saving occurs because only one permutation is stored at any one time. This option is only available if the PcgsAutomorphisms flag is set to true (see ). For an interactive process, SpaceEfficient defaults to a previously supplied value for the process. Otherwise (and non-interactively), SpaceEfficient is by default false. CapableDescendants By default, all (i.e. capable and terminal) descendants are computed. If this flag is set, only capable descendants are computed. Setting this option is equivalent to setting AllDescendants := false (see ), except if both CapableDescendants and AllDescendants are passed, AllDescendants is essentially ignored. AllDescendants := false By default, all descendants are constructed. If this flag is set to false, only capable descendants are computed. Passing AllDescendants without a value (which is equivalent to setting it to true) is superfluous. This option is provided only for backward compatibility with the &GAP; 3 version of the &ANUPQ; package, where by default AllDescendants was set to false (rather than true). It is preferable to use CapableDescendants (see ). TreeDepth := class Specifies that the descendants tree developed by PqDescendantsTreeCoclassOne (see ) should be extended to class class, where class is a positive integer. SubList := sub Suppose that L is the list of descendants generated, then for a list sub of integers this option causes PqDescendants to return Sublist( L, sub ). If an integer n is supplied, PqDescendants returns L[n]. NumberOfSolubleAutomorphisms := n Specifies that the number of soluble automorphisms of the automorphism group supplied by PqPGSupplyAutomorphisms (see ) in a p-group generation calculation is n. By default, n is taken to be 0; n must be a non-negative integer. If n \ge 0 then a value for the option RelativeOrders (see ) must also be supplied. RelativeOrders := list Specifies the relative orders of each soluble automorphism of the automorphism group supplied by PqPGSupplyAutomorphisms (see ) in a p-group generation calculation. The list list must consist of n positive integers, where n is the value of the option NumberOfSolubleAutomorphisms (see ). By default list is empty. BasicAlgorithm Specifies that an algorithm that the pq program calls its default algorithm be used for p-group generation. By default this algorithm is not used. If this option is supplied the settings of options RankInitialSegmentSubgroups, AllDescendants, Exponent and Metabelian are ignored. CustomiseOutput := rec Specifies that fine tuning of the output is desired. The record rec should have any subset (or all) of the the following fields: perm := list where list is a list of booleans which determine whether the permutation group output for the automorphism group should contain: the degree, the extended automorphisms, the automorphism matrices, and the permutations, respectively. orbit := list where list is a list of booleans which determine whether the orbit output of the action of the automorphism group should contain: a summary, and a complete listing of orbits, respectively. (It's possible to have both a summary and a complete listing.) group := list where list is a list of booleans which determine whether the group output should contain: the standard matrix of each allowable subgroup, the presentation of reduced p-covering groups, the presentation of immediate descendants, the nuclear rank of descendants, and the p-multiplicator rank of descendants, respectively. autgroup := list where list is a list of booleans which determine whether the automorphism group output should contain: the commutator matrix, the automorphism group description of descendants, and the automorphism group order of descendants, respectively. trace := val where val is a boolean which if true specifies algorithm trace data is desired. By default, one does not get algorithm trace data. Not providing a field (or mis-spelling it!), specifies that the default output is desired. As a convenience, 1 is also accepted as true, and any value that is neither 1 nor true is taken as false. Also for each list above, an unbound list entry is taken as false. Thus, for example specifies for the group output that only the presentation of immediate descendants is desired, for the automorphism group output only the automorphism group description of descendants should be printed, that there should be no algorithm trace data, and that the default output should be provided for the permutation group and orbit output. StandardPresentationFile := filename Specifies that the file to which the standard presentation is written has name filename. If the first character of the string filename is not /, filename is assumed to be the path of a writable file relative to the directory in which &GAP; was started. If this option is omitted it is written to the file with the name generated by the command Filename( ANUPQData.tmpdir, "SPres" );, i.e. the file with name "SPres" in the temporary directory in which the pq program executes. QueueFactor := n Specifies a queue factor of n, where n must be a positive integer. This option may be used with PqNextClass (see ).

The queue factor is used when the pq program uses automorphisms to close a set of elements of the p-multiplicator under their action.

The algorithm used is a spinning algorithm: it starts with a set of vectors in echelonized form (elements of the p-multiplicator) and closes the span of these vectors under the action of the automorphisms. For this each automorphism is applied to each vector and it is checked if the result is contained in the span computed so far. If not, the span becomes bigger and the vector is put into a queue and the automorphisms are applied to this vector at a later stage. The process terminates when the automorphisms have been applied to all vectors and no new vectors have been produced.

For each new vector it is decided, if its processing should be delayed. If the vector contains too many non-zero entries, it is put into a second queue. The elements in this queue are processed only when there are no elements in the first queue left.

The queue factor is a percentage figure. A vector is put into the second queue if the percentage of its non-zero entries exceeds the queue factor. Bounds := list Specifies a lower and upper bound on the indices of a list, where list is a pair of positive non-decreasing integers. See  and  where this option may be used. PrintAutomorphisms := list Specifies that automorphism matrices be printed. PrintPermutations := list Specifies that permutations of the subgroups be printed. Filename := string Specifies that an output or input file to be written to or read from by the pq program should have the name string.

anupq-3.3.3/doc/toggless.js0000644000175100017510000000420515111342310015174 0ustar runnerrunner/* toggless.js Frank Lübeck */ /* this file contains two functions: mergeSideTOCHooks: this changes div.ContSect elements to the class ContSectClosed and includes a hook to toggle between ContSectClosed and ContSectOpen. openclosetoc: this function does the toggling, the rest is done by CSS */ closedTOCMarker = "▶ "; openTOCMarker = "▼ "; noTOCMarker = " "; /* merge hooks into side toc for opening/closing subsections with openclosetoc */ function mergeSideTOCHooks() { var hlist = document.getElementsByTagName("div"); for (var i = 0; i < hlist.length; i++) { if (hlist[i].className == "ContSect") { var chlds = hlist[i].childNodes; var el = document.createElement("span"); var oncl = document.createAttribute("class"); oncl.nodeValue = "toctoggle"; el.setAttributeNode(oncl); var cont; if (chlds.length > 2) { var oncl = document.createAttribute("onclick"); oncl.nodeValue = "openclosetoc(event)"; el.setAttributeNode(oncl); cont = document.createTextNode(closedTOCMarker); } else { cont = document.createTextNode(noTOCMarker); } el.appendChild(cont); hlist[i].firstChild.insertBefore(el, hlist[i].firstChild.firstChild); hlist[i].className = "ContSectClosed"; } } } function openclosetoc (event) { /* first two steps to make it work in most browsers */ var evt=window.event || event; if (!evt.target) evt.target=evt.srcElement; var markClosed = document.createTextNode(closedTOCMarker); var markOpen = document.createTextNode(openTOCMarker); var par = evt.target.parentNode.parentNode; if (par.className == "ContSectOpen") { par.className = "ContSectClosed"; evt.target.replaceChild(markClosed, evt.target.firstChild); } else if (par.className == "ContSectClosed") { par.className = "ContSectOpen"; evt.target.replaceChild(markOpen, evt.target.firstChild); } } /* adjust jscontent which is called onload */ jscontentfuncs.push(mergeSideTOCHooks); anupq-3.3.3/doc/manual.six0000644000175100017510000015265215111342310015023 0ustar runnerrunner#SIXFORMAT GapDocGAP HELPBOOKINFOSIXTMP := rec( encoding := "UTF-8", bookname := "ANUPQ", entries := [ [ "Title page", "0.0", [ 0, 0, 0 ], 1, 1, "title page", "X7D2C85EC87DD46E5" ], [ "Copyright", "0.0-1", [ 0, 0, 1 ], 36, 2, "copyright", "X81488B807F2A1CF1" ], [ "Table of Contents", "0.0-2", [ 0, 0, 2 ], 48, 3, "table of contents", "X8537FEB07AF2BEC8" ], [ "\033[1X\033[33X\033[0;-2YIntroduction\033[133X\033[101X", "1", [ 1, 0, 0 ], 1, 5, "introduction", "X7DFB63A97E67C0A1" ], [ "\033[1X\033[33X\033[0;-2YOverview\033[133X\033[101X", "1.1", [ 1, 1, 0 ], 4, 5, "overview", "X8389AD927B74BA4A" ], [ "\033[1X\033[33X\033[0;-2YHow to read this manual\033[133X\033[101X", "1.2", [ 1, 2, 0 ], 40, 5, "how to read this manual", "X8416D2657E7831A1" ], [ "\033[1X\033[33X\033[0;-2YAuthors and Acknowledgements\033[133X\033[101X", "1.3", [ 1, 3, 0 ], 90, 6, "authors and acknowledgements", "X79D2480A7810A7CC" ], [ "\033[1X\033[33X\033[0;-2YMathematical Background and Terminology\033[133X\\ 033[101X", "2", [ 2, 0, 0 ], 1, 7, "mathematical background and terminology", "X7E7F3B617F42EF03" ], [ "\033[1X\033[33X\033[0;-2YBasic notions\033[133X\033[101X", "2.1", [ 2, 1, 0 ], 16, 7, "basic notions", "X79A052C47C92AF09" ], [ "\033[1X\033[33X\033[0;-2Ypc Presentations and Consistency\033[133X\033[101\ X", "2.1-1", [ 2, 1, 1 ], 21, 7, "pc presentations and consistency", "X7BD675838609D547" ], [ "\033[1X\033[33X\033[0;-2YExponent-\033[22Xp\033[122X\033[101X\027\033[1X\\ 027 Central Series and Weighted pc Presentations\033[133X\033[101X", "2.1-2", [ 2, 1, 2 ], 74, 8, "exponent-p central series and weighted pc presentations", "X7944DB037F2277A6" ], [ "\033[1X\033[33X\033[0;-2Y\033[22Xp\033[122X\033[101X\027\033[1X\027-Cover,\ \033[22Xp\033[122X\033[101X\027\033[1X\027-Multiplicator\033[133X\033[101X", "2.1-3", [ 2, 1, 3 ], 107, 8, "p-cover p-multiplicator", "X7C43ACA37D391EBD" ], [ "\033[1X\033[33X\033[0;-2YDescendants, Capable, Terminal, Nucleus\033[133X\\ 033[101X", "2.1-4", [ 2, 1, 4 ], 120, 8, "descendants capable terminal nucleus", "X801A27A08462AFAB" ], [ "\033[1X\033[33X\033[0;-2YLaws\033[133X\033[101X", "2.1-5", [ 2, 1, 5 ], 155, 9, "laws", "X81FBE7ED79EFF5EF" ], [ "\033[1X\033[33X\033[0;-2YThe p-quotient Algorithm\033[133X\033[101X", "2.2", [ 2, 2, 0 ], 165, 9, "the p-quotient algorithm", "X7C8CE96D80FC3614" ], [ "\033[1X\033[33X\033[0;-2YFinding the \033[22Xp\033[122X\033[101X\027\033[1\ X\027-cover\033[133X\033[101X", "2.2-1", [ 2, 2, 1 ], 187, 9, "finding the p-cover", "X791EB6F77899CB3D" ], [ "\033[1X\033[33X\033[0;-2YImposing the Relations of the fp Group\033[133X\\ 033[101X", "2.2-2", [ 2, 2, 2 ], 227, 10, "imposing the relations of the fp group", "X804CF5C97F7BB880" ], [ "\033[1X\033[33X\033[0;-2YImposing Laws\033[133X\033[101X", "2.2-3", [ 2, 2, 3 ], 235, 10, "imposing laws", "X7F1A8CCD84462775" ], [ "\033[1X\033[33X\033[0;-2YThe p-group generation Algorithm, Standard Presen\ tation, Isomorphism Testing\033[133X\033[101X", "2.3", [ 2, 3, 0 ], 257, 10, "the p-group generation algorithm standard presentation isomorphism test\ ing", "X807FB2EC85E6648D" ], [ "\033[1X\033[33X\033[0;-2YInfrastructure\033[133X\033[101X", "3", [ 3, 0, 0 ], 1, 12, "infrastructure", "X7917EFDF7AC06F04" ], [ "\033[1X\033[33X\033[0;-2YLoading the ANUPQ Package\033[133X\033[101X", "3.1", [ 3, 1, 0 ], 35, 12, "loading the anupq package", "X833D58248067E13B" ], [ "\033[1X\033[33X\033[0;-2YThe ANUPQData Record\033[133X\033[101X", "3.2", [ 3, 2, 0 ], 78, 13, "the anupqdata record", "X83DE155A79C38DBE" ], [ "\033[1X\033[33X\033[0;-2YSetting the Verbosity of ANUPQ via Info and InfoA\ NUPQ\033[133X\033[101X", "3.3", [ 3, 3, 0 ], 256, 16, "setting the verbosity of anupq via info and infoanupq", "X83E5C7CF7D8739DF" ], [ "\033[1X\033[33X\033[0;-2YUtility Functions\033[133X\033[101X", "3.4", [ 3, 4, 0 ], 327, 17, "utility functions", "X810FFB1C8035C8BE" ], [ "\033[1X\033[33X\033[0;-2YAttributes and a Property for fp and pc p-groups\\ 033[133X\033[101X", "3.5", [ 3, 5, 0 ], 443, 19, "attributes and a property for fp and pc p-groups", "X818175EF85CAA807" ], [ "\033[1X\033[33X\033[0;-2YHints and Warnings regarding the use of Options\\ 033[133X\033[101X", "3.6", [ 3, 6, 0 ], 489, 20, "hints and warnings regarding the use of options", "X7BA20FA07B166B37" ] , [ "\033[1X\033[33X\033[0;-2YNon-interactive ANUPQ functions\033[133X\033[101X\ ", "4", [ 4, 0, 0 ], 1, 24, "non-interactive anupq functions", "X7C51F26D839279FF" ], [ "\033[1X\033[33X\033[0;-2YComputing p-Quotients\033[133X\033[101X", "4.1", [ 4, 1, 0 ], 37, 24, "computing p-quotients", "X80406BD47EB186E9" ], [ "\033[1X\033[33X\033[0;-2YComputing Standard Presentations\033[133X\033[101\ X", "4.2", [ 4, 2, 0 ], 297, 29, "computing standard presentations", "X7F05F8DC79733A8E" ], [ "\033[1X\033[33X\033[0;-2YTesting p-Groups for Isomorphism\033[133X\033[101\ X", "4.3", [ 4, 3, 0 ], 454, 31, "testing p-groups for isomorphism", "X8030FAE586423615" ], [ "\033[1X\033[33X\033[0;-2YComputing Descendants of a p-Group\033[133X\033[1\ 01X", "4.4", [ 4, 4, 0 ], 489, 32, "computing descendants of a p-group", "X8450C72580D91245" ], [ "\033[1X\033[33X\033[0;-2YInteractive ANUPQ functions\033[133X\033[101X", "5", [ 5, 0, 0 ], 1, 36, "interactive anupq functions", "X842C13C27B941744" ], [ "\033[1X\033[33X\033[0;-2YStarting and Stopping Interactive ANUPQ Processes\ \033[133X\033[101X", "5.1", [ 5, 1, 0 ], 42, 36, "starting and stopping interactive anupq processes", "X7935CDAD7936CA0A" ], [ "\033[1X\033[33X\033[0;-2YInteractive ANUPQ Process Utility Functions\033[1\ 33X\033[101X", "5.2", [ 5, 2, 0 ], 93, 37, "interactive anupq process utility functions", "X7EE8000A800CEE2D" ], [ "\033[1X\033[33X\033[0;-2YInteractive Versions of Non-interactive ANUPQ Fun\ ctions\033[133X\033[101X", "5.3", [ 5, 3, 0 ], 141, 38, "interactive versions of non-interactive anupq functions", "X823D2BBF7C4515D4" ], [ "\033[1X\033[33X\033[0;-2YLow-level Interactive ANUPQ functions based on me\ nu items of the pq program\033[133X\033[101X", "5.4", [ 5, 4, 0 ], 635, 47, "low-level interactive anupq functions based on menu items of the pq pro\ gram", "X857F050C832A1FE4" ], [ "\033[1X\033[33X\033[0;-2YGeneral commands\033[133X\033[101X", "5.5", [ 5, 5, 0 ], 655, 47, "general commands", "X868B10557D470CF6" ], [ "\033[1X\033[33X\033[0;-2YCommands from the Main \033[22Xp\033[122X\033[101\ X\027\033[1X\027-Quotient menu\033[133X\033[101X", "5.6", [ 5, 6, 0 ], 770, 49, "commands from the main p-quotient menu", "X7BDD5B278719C630" ], [ "\033[1X\033[33X\033[0;-2YCommands from the Advanced \033[22Xp\033[122X\\ 033[101X\027\033[1X\027-Quotient menu\033[133X\033[101X", "5.7", [ 5, 7, 0 ], 901, 51, "commands from the advanced p-quotient menu", "X7D27BE937B1DE16E" ], [ "\033[1X\033[33X\033[0;-2YCommands from the Standard Presentation menu\033[\ 133X\033[101X", "5.8", [ 5, 8, 0 ], 1415, 60, "commands from the standard presentation menu", "X7B94EDA385FDD904" ], [ "\033[1X\033[33X\033[0;-2YCommands from the Main \033[22Xp\033[122X\033[10\ 1X\027\033[1X\027-Group Generation menu\033[133X\033[101X", "5.9", [ 5, 9, 0 ], 1527, 62, "commands from the main p-group generation menu", "X8490031B7AA7F237" ], [ "\033[1X\033[33X\033[0;-2YCommands from the Advanced \033[22Xp\033[122X\\ 033[101X\027\033[1X\027-Group Generation menu\033[133X\033[101X", "5.10", [ 5, 10, 0 ], 1621, 63, "commands from the advanced p-group generation menu", "X7E8FBC2D83C43481" ], [ "\033[1X\033[33X\033[0;-2YPrimitive Interactive ANUPQ Process Read/Write Fu\ nctions\033[133X\033[101X", "5.11", [ 5, 11, 0 ], 1698, 65, "primitive interactive anupq process read/write functions", "X84A92E8087762DEE" ], [ "\033[1X\033[33X\033[0;-2YANUPQ Options\033[133X\033[101X", "6", [ 6, 0, 0 ], 1, 67, "anupq options", "X7B0946E97E7EB359" ], [ "\033[1X\033[33X\033[0;-2YOverview\033[133X\033[101X", "6.1", [ 6, 1, 0 ], 4, 67, "overview", "X8389AD927B74BA4A" ], [ "\033[1X\033[33X\033[0;-2YDetailed descriptions of ANUPQ Options\033[133X\\ 033[101X", "6.2", [ 6, 2, 0 ], 73, 68, "detailed descriptions of anupq options", "X87EE6DD67C9996A3" ], [ "\033[1X\033[33X\033[0;-2YInstalling the ANUPQ Package\033[133X\033[101X", "7", [ 7, 0, 0 ], 1, 75, "installing the anupq package", "X7FB487238298CF42" ], [ "\033[1X\033[33X\033[0;-2YTesting your ANUPQ installation\033[133X\033[101X\ ", "7.1", [ 7, 1, 0 ], 105, 76, "testing your anupq installation", "X854577C8800DC7C2" ], [ "\033[1X\033[33X\033[0;-2YRunning the pq program as a standalone\033[133X\\ 033[101X", "7.2", [ 7, 2, 0 ], 155, 77, "running the pq program as a standalone", "X82906B5184C61063" ], [ "\033[1X\033[33X\033[0;-2YExamples\033[133X\033[101X", "a", [ "A", 0, 0 ], 1, 79, "examples", "X7A489A5D79DA9E5C" ], [ "\033[1X\033[33X\033[0;-2YThe Relators Option\033[133X\033[101X", "a.1", [ "A", 1, 0 ], 137, 81, "the relators option", "X80676E317BF4DF13" ], [ "\033[1X\033[33X\033[0;-2YThe Identities Option and PqEvaluateIdentities Fu\ nction\033[133X\033[101X", "a.2", [ "A", 2, 0 ], 212, 83, "the identities option and pqevaluateidentities function", "X80B2AA7084C57F5D" ], [ "\033[1X\033[33X\033[0;-2YA Large Example\033[133X\033[101X", "a.3", [ "A", 3, 0 ], 362, 85, "a large example", "X7A997D1A8532A84B" ], [ "\033[1X\033[33X\033[0;-2YDeveloping descendants trees\033[133X\033[101X", "a.4", [ "A", 4, 0 ], 469, 87, "developing descendants trees", "X7FB6DA8D7BB90D8C" ], [ "Bibliography", "bib", [ "Bib", 0, 0 ], 1, 92, "bibliography", "X7A6F98FD85F02BFE" ], [ "References", "bib", [ "Bib", 0, 0 ], 1, 92, "references", "X7A6F98FD85F02BFE" ], [ "Index", "ind", [ "Ind", 0, 0 ], 1, 93, "index", "X83A0356F839C696F" ], [ "ANUPQ", "1.1", [ 1, 1, 0 ], 4, 5, "anupq", "X8389AD927B74BA4A" ], [ "bug reports", "1.3", [ 1, 3, 0 ], 90, 6, "bug reports", "X79D2480A7810A7CC" ], [ "power-commutator presentation", "2.1-1", [ 2, 1, 1 ], 21, 7, "power-commutator presentation", "X7BD675838609D547" ], [ "pc presentation", "2.1-1", [ 2, 1, 1 ], 21, 7, "pc presentation", "X7BD675838609D547" ], [ "pcp", "2.1-1", [ 2, 1, 1 ], 21, 7, "pcp", "X7BD675838609D547" ], [ "pc generators", "2.1-1", [ 2, 1, 1 ], 21, 7, "pc generators", "X7BD675838609D547" ], [ "collection", "2.1-1", [ 2, 1, 1 ], 21, 7, "collection", "X7BD675838609D547" ], [ "consistent", "2.1-1", [ 2, 1, 1 ], 21, 7, "consistent", "X7BD675838609D547" ], [ "confluent rewriting system", "2.1-1", [ 2, 1, 1 ], 21, 7, "confluent rewriting system", "X7BD675838609D547" ], [ "confluent", "2.1-1", [ 2, 1, 1 ], 21, 7, "confluent", "X7BD675838609D547" ], [ "consistency conditions", "2.1-1", [ 2, 1, 1 ], 21, 7, "consistency conditions", "X7BD675838609D547" ], [ "exponent-p central series", "2.1-2", [ 2, 1, 2 ], 74, 8, "exponent-p central series", "X7944DB037F2277A6" ], [ "class", "2.1-2", [ 2, 1, 2 ], 74, 8, "class", "X7944DB037F2277A6" ], [ "p-class", "2.1-2", [ 2, 1, 2 ], 74, 8, "p-class", "X7944DB037F2277A6" ], [ "weight function", "2.1-2", [ 2, 1, 2 ], 74, 8, "weight function", "X7944DB037F2277A6" ], [ "weighted pcp", "2.1-2", [ 2, 1, 2 ], 74, 8, "weighted pcp", "X7944DB037F2277A6" ], [ "p-covering group", "2.1-3", [ 2, 1, 3 ], 107, 8, "p-covering group", "X7C43ACA37D391EBD" ], [ "p-cover", "2.1-3", [ 2, 1, 3 ], 107, 8, "p-cover", "X7C43ACA37D391EBD" ], [ "p-multiplicator", "2.1-3", [ 2, 1, 3 ], 107, 8, "p-multiplicator", "X7C43ACA37D391EBD" ], [ "p-multiplicator rank", "2.1-3", [ 2, 1, 3 ], 107, 8, "p-multiplicator rank", "X7C43ACA37D391EBD" ], [ "multiplicator rank", "2.1-3", [ 2, 1, 3 ], 107, 8, "multiplicator rank", "X7C43ACA37D391EBD" ], [ "descendant", "2.1-4", [ 2, 1, 4 ], 120, 8, "descendant", "X801A27A08462AFAB" ], [ "immediate descendant", "2.1-4", [ 2, 1, 4 ], 120, 8, "immediate descendant", "X801A27A08462AFAB" ], [ "nucleus", "2.1-4", [ 2, 1, 4 ], 120, 8, "nucleus", "X801A27A08462AFAB" ], [ "capable", "2.1-4", [ 2, 1, 4 ], 120, 8, "capable", "X801A27A08462AFAB" ], [ "terminal", "2.1-4", [ 2, 1, 4 ], 120, 8, "terminal", "X801A27A08462AFAB" ], [ "nucleus", "2.1-4", [ 2, 1, 4 ], 120, 8, "nucleus", "X801A27A08462AFAB" ], [ "allowable subgroup", "2.1-4", [ 2, 1, 4 ], 120, 8, "allowable subgroup", "X801A27A08462AFAB" ], [ "extended automorphism", "2.1-4", [ 2, 1, 4 ], 120, 8, "extended automorphism", "X801A27A08462AFAB" ], [ "permutations", "2.1-4", [ 2, 1, 4 ], 120, 8, "permutations", "X801A27A08462AFAB" ], [ "law", "2.1-5", [ 2, 1, 5 ], 155, 9, "law", "X81FBE7ED79EFF5EF" ], [ "identical relation", "2.1-5", [ 2, 1, 5 ], 155, 9, "identical relation", "X81FBE7ED79EFF5EF" ], [ "exponent law", "2.1-5", [ 2, 1, 5 ], 155, 9, "exponent law", "X81FBE7ED79EFF5EF" ], [ "metabelian law", "2.1-5", [ 2, 1, 5 ], 155, 9, "metabelian law", "X81FBE7ED79EFF5EF" ], [ "Engel identity", "2.1-5", [ 2, 1, 5 ], 155, 9, "engel identity", "X81FBE7ED79EFF5EF" ], [ "labelled pcp", "2.2-1", [ 2, 2, 1 ], 187, 9, "labelled pcp", "X791EB6F77899CB3D" ], [ "definition of generator", "2.2-1", [ 2, 2, 1 ], 187, 9, "definition of generator", "X791EB6F77899CB3D" ], [ "tails", "2.2-1", [ 2, 2, 1 ], 187, 9, "tails", "X791EB6F77899CB3D" ], [ "exponent check", "2.2-3", [ 2, 2, 3 ], 235, 10, "exponent check", "X7F1A8CCD84462775" ], [ "p-group generation", "2.3", [ 2, 3, 0 ], 257, 10, "p-group generation", "X807FB2EC85E6648D" ], [ "orbits", "2.3", [ 2, 3, 0 ], 257, 10, "orbits", "X807FB2EC85E6648D" ], [ "standard presentation", "2.3", [ 2, 3, 0 ], 257, 10, "standard presentation", "X807FB2EC85E6648D" ], [ "echelonised matrix", "2.3", [ 2, 3, 0 ], 257, 10, "echelonised matrix", "X807FB2EC85E6648D" ], [ "label of standard matrix", "2.3", [ 2, 3, 0 ], 257, 10, "label of standard matrix", "X807FB2EC85E6648D" ], [ "isomorphism testing", "2.3", [ 2, 3, 0 ], 257, 10, "isomorphism testing", "X807FB2EC85E6648D" ], [ "compaction", "2.3", [ 2, 3, 0 ], 257, 10, "compaction", "X807FB2EC85E6648D" ], [ "banner", "3.1", [ 3, 1, 0 ], 35, 12, "banner", "X833D58248067E13B" ], [ "\033[2XANUPQData\033[102X", "3.2-1", [ 3, 2, 1 ], 84, 13, "anupqdata", "X7B90E89782BDA6D7" ], [ "\033[2XANUPQDirectoryTemporary\033[102X", "3.2-2", [ 3, 2, 2 ], 243, 16, "anupqdirectorytemporary", "X7FBB2F457E4BD6AB" ], [ "\033[2XInfoANUPQ\033[102X", "3.3-1", [ 3, 3, 1 ], 259, 16, "infoanupq", "X7CBC9B458497BFF1" ], [ "\033[2XPqLeftNormComm\033[102X", "3.4-1", [ 3, 4, 1 ], 330, 17, "pqleftnormcomm", "X8771393B7F53F534" ], [ "\033[2XPqGAPRelators\033[102X", "3.4-2", [ 3, 4, 2 ], 341, 17, "pqgaprelators", "X7A567432879510A6" ], [ "\033[2XPqParseWord\033[102X", "3.4-3", [ 3, 4, 3 ], 364, 18, "pqparseword", "X7F3C5D1C7EC36EAE" ], [ "\033[2XPqExample\033[102X no arguments", "3.4-4", [ 3, 4, 4 ], 379, 18, "pqexample no arguments", "X7BB0EB607F337265" ], [ "\033[2XPqExample\033[102X", "3.4-4", [ 3, 4, 4 ], 379, 18, "pqexample", "X7BB0EB607F337265" ], [ "\033[2XPqExample\033[102X with filename", "3.4-4", [ 3, 4, 4 ], 379, 18, "pqexample with filename", "X7BB0EB607F337265" ], [ "\033[2XAllPqExamples\033[102X", "3.4-5", [ 3, 4, 5 ], 417, 19, "allpqexamples", "X823C93FC7B87F5BC" ], [ "\033[2XGrepPqExamples\033[102X", "3.4-6", [ 3, 4, 6 ], 424, 19, "greppqexamples", "X7E3E4B047DC2E323" ], [ "\033[2XToPQLog\033[102X", "3.4-7", [ 3, 4, 7 ], 432, 19, "topqlog", "X8104B2BA872EFCCB" ], [ "\033[2XNuclearRank\033[102X", "3.5-1", [ 3, 5, 1 ], 446, 19, "nuclearrank", "X87DC922A78EB0DD6" ], [ "\033[2XMultiplicatorRank\033[102X", "3.5-1", [ 3, 5, 1 ], 446, 19, "multiplicatorrank", "X87DC922A78EB0DD6" ], [ "\033[2XIsCapable\033[102X", "3.5-1", [ 3, 5, 1 ], 446, 19, "iscapable", "X87DC922A78EB0DD6" ], [ "menu item of pq program", "3.6", [ 3, 6, 0 ], 489, 20, "menu item of pq program", "X7BA20FA07B166B37" ], [ "option of pq program is a menu item", "3.6", [ 3, 6, 0 ], 489, 20, "option of pq program is a menu item", "X7BA20FA07B166B37" ], [ "troubleshooting tips", "3.6", [ 3, 6, 0 ], 489, 20, "troubleshooting tips", "X7BA20FA07B166B37" ], [ "\033[2XANUPQWarnOfOtherOptions\033[102X", "3.6-1", [ 3, 6, 1 ], 553, 21, "anupqwarnofotheroptions", "X81F4AAE084C34B4B" ], [ "\033[2XPq\033[102X", "4.1-1", [ 4, 1, 1 ], 40, 24, "pq", "X86DD32D5803CF2C8" ], [ "option Prime", "4.1-1", [ 4, 1, 1 ], 40, 24, "option prime", "X86DD32D5803CF2C8" ], [ "option ClassBound", "4.1-1", [ 4, 1, 1 ], 40, 24, "option classbound", "X86DD32D5803CF2C8" ], [ "option Exponent", "4.1-1", [ 4, 1, 1 ], 40, 24, "option exponent", "X86DD32D5803CF2C8" ], [ "option Relators", "4.1-1", [ 4, 1, 1 ], 40, 24, "option relators", "X86DD32D5803CF2C8" ], [ "option Metabelian", "4.1-1", [ 4, 1, 1 ], 40, 24, "option metabelian", "X86DD32D5803CF2C8" ], [ "option Identities", "4.1-1", [ 4, 1, 1 ], 40, 24, "option identities", "X86DD32D5803CF2C8" ], [ "option GroupName", "4.1-1", [ 4, 1, 1 ], 40, 24, "option groupname", "X86DD32D5803CF2C8" ], [ "option OutputLevel", "4.1-1", [ 4, 1, 1 ], 40, 24, "option outputlevel", "X86DD32D5803CF2C8" ], [ "option SetupFile", "4.1-1", [ 4, 1, 1 ], 40, 24, "option setupfile", "X86DD32D5803CF2C8" ], [ "option PqWorkspace", "4.1-1", [ 4, 1, 1 ], 40, 24, "option pqworkspace", "X86DD32D5803CF2C8" ], [ "option Relators example of usage", "4.1-1", [ 4, 1, 1 ], 40, 24, "option relators example of usage", "X86DD32D5803CF2C8" ], [ "option Identities example of usage", "4.1-1", [ 4, 1, 1 ], 40, 24, "option identities example of usage", "X86DD32D5803CF2C8" ], [ "\033[2XPqEpimorphism\033[102X", "4.1-2", [ 4, 1, 2 ], 200, 27, "pqepimorphism", "X7ADE5DDB87B99CC0" ], [ "\033[2XPqPCover\033[102X", "4.1-3", [ 4, 1, 3 ], 234, 27, "pqpcover", "X81C3CE1E850DA252" ], [ "automorphisms of \033[22Xp\033[122X-groups", "4.2", [ 4, 2, 0 ], 297, 29, "automorphisms of p-groups", "X7F05F8DC79733A8E" ], [ "\033[2XPqStandardPresentation\033[102X", "4.2-1", [ 4, 2, 1 ], 300, 29, "pqstandardpresentation", "X86C9575D7CB65FBB" ], [ "\033[2XStandardPresentation\033[102X", "4.2-1", [ 4, 2, 1 ], 300, 29, "standardpresentation", "X86C9575D7CB65FBB" ], [ "option Prime", "4.2-1", [ 4, 2, 1 ], 300, 29, "option prime", "X86C9575D7CB65FBB" ], [ "option pQuotient", "4.2-1", [ 4, 2, 1 ], 300, 29, "option pquotient", "X86C9575D7CB65FBB" ], [ "option ClassBound", "4.2-1", [ 4, 2, 1 ], 300, 29, "option classbound", "X86C9575D7CB65FBB" ], [ "option Exponent", "4.2-1", [ 4, 2, 1 ], 300, 29, "option exponent", "X86C9575D7CB65FBB" ], [ "option Metabelian", "4.2-1", [ 4, 2, 1 ], 300, 29, "option metabelian", "X86C9575D7CB65FBB" ], [ "option GroupName", "4.2-1", [ 4, 2, 1 ], 300, 29, "option groupname", "X86C9575D7CB65FBB" ], [ "option OutputLevel", "4.2-1", [ 4, 2, 1 ], 300, 29, "option outputlevel", "X86C9575D7CB65FBB" ], [ "option StandardPresentationFile", "4.2-1", [ 4, 2, 1 ], 300, 29, "option standardpresentationfile", "X86C9575D7CB65FBB" ], [ "option SetupFile", "4.2-1", [ 4, 2, 1 ], 300, 29, "option setupfile", "X86C9575D7CB65FBB" ], [ "option PqWorkspace", "4.2-1", [ 4, 2, 1 ], 300, 29, "option pqworkspace", "X86C9575D7CB65FBB" ], [ "\033[2XEpimorphismPqStandardPresentation\033[102X", "4.2-2", [ 4, 2, 2 ], 397, 30, "epimorphismpqstandardpresentation", "X828C06D083C0D089" ], [ "\033[2XEpimorphismStandardPresentation\033[102X", "4.2-2", [ 4, 2, 2 ], 397, 30, "epimorphismstandardpresentation", "X828C06D083C0D089" ], [ "\033[2XIsPqIsomorphicPGroup\033[102X", "4.3-1", [ 4, 3, 1 ], 457, 31, "ispqisomorphicpgroup", "X854389FC780BB178" ], [ "\033[2XIsIsomorphicPGroup\033[102X", "4.3-1", [ 4, 3, 1 ], 457, 31, "isisomorphicpgroup", "X854389FC780BB178" ], [ "\033[2XPqDescendants\033[102X", "4.4-1", [ 4, 4, 1 ], 492, 32, "pqdescendants", "X80985CC479CD9FA3" ], [ "option ClassBound", "4.4-1", [ 4, 4, 1 ], 492, 32, "option classbound", "X80985CC479CD9FA3" ], [ "option Relators", "4.4-1", [ 4, 4, 1 ], 492, 32, "option relators", "X80985CC479CD9FA3" ], [ "option OrderBound", "4.4-1", [ 4, 4, 1 ], 492, 32, "option orderbound", "X80985CC479CD9FA3" ], [ "option StepSize", "4.4-1", [ 4, 4, 1 ], 492, 32, "option stepsize", "X80985CC479CD9FA3" ], [ "option RankInitialSegmentSubgroups", "4.4-1", [ 4, 4, 1 ], 492, 32, "option rankinitialsegmentsubgroups", "X80985CC479CD9FA3" ], [ "option SpaceEfficient", "4.4-1", [ 4, 4, 1 ], 492, 32, "option spaceefficient", "X80985CC479CD9FA3" ], [ "option CapableDescendants", "4.4-1", [ 4, 4, 1 ], 492, 32, "option capabledescendants", "X80985CC479CD9FA3" ], [ "option AllDescendants", "4.4-1", [ 4, 4, 1 ], 492, 32, "option alldescendants", "X80985CC479CD9FA3" ], [ "option Exponent", "4.4-1", [ 4, 4, 1 ], 492, 32, "option exponent", "X80985CC479CD9FA3" ], [ "option Metabelian", "4.4-1", [ 4, 4, 1 ], 492, 32, "option metabelian", "X80985CC479CD9FA3" ], [ "option GroupName", "4.4-1", [ 4, 4, 1 ], 492, 32, "option groupname", "X80985CC479CD9FA3" ], [ "option SubList", "4.4-1", [ 4, 4, 1 ], 492, 32, "option sublist", "X80985CC479CD9FA3" ], [ "option BasicAlgorithm", "4.4-1", [ 4, 4, 1 ], 492, 32, "option basicalgorithm", "X80985CC479CD9FA3" ], [ "option CustomiseOutput", "4.4-1", [ 4, 4, 1 ], 492, 32, "option customiseoutput", "X80985CC479CD9FA3" ], [ "option SetupFile", "4.4-1", [ 4, 4, 1 ], 492, 32, "option setupfile", "X80985CC479CD9FA3" ], [ "option PqWorkspace", "4.4-1", [ 4, 4, 1 ], 492, 32, "option pqworkspace", "X80985CC479CD9FA3" ], [ "\033[2XPqSupplementInnerAutomorphisms\033[102X", "4.4-2", [ 4, 4, 2 ], 627, 34, "pqsupplementinnerautomorphisms", "X8364566A80A8C24B" ], [ "\033[2XPqList\033[102X", "4.4-3", [ 4, 4, 3 ], 673, 35, "pqlist", "X79AD54E987FCACBA" ], [ "\033[2XSavePqList\033[102X", "4.4-4", [ 4, 4, 4 ], 687, 35, "savepqlist", "X85ADB9E6870EC3D1" ], [ "\033[2XPqStart\033[102X with group and workspace size", "5.1-1", [ 5, 1, 1 ], 45, 36, "pqstart with group and workspace size", "X83B2EC237F37623C" ], [ "\033[2XPqStart\033[102X with group", "5.1-1", [ 5, 1, 1 ], 45, 36, "pqstart with group", "X83B2EC237F37623C" ], [ "\033[2XPqStart\033[102X with workspace size", "5.1-1", [ 5, 1, 1 ], 45, 36, "pqstart with workspace size", "X83B2EC237F37623C" ], [ "\033[2XPqStart\033[102X", "5.1-1", [ 5, 1, 1 ], 45, 36, "pqstart", "X83B2EC237F37623C" ], [ "\033[2XPqQuit\033[102X", "5.1-2", [ 5, 1, 2 ], 71, 37, "pqquit", "X79DB761185BAB9C8" ], [ "\033[2XPqQuit\033[102X for default process", "5.1-2", [ 5, 1, 2 ], 71, 37, "pqquit for default process", "X79DB761185BAB9C8" ], [ "\033[2XPqQuitAll\033[102X", "5.1-3", [ 5, 1, 3 ], 85, 37, "pqquitall", "X7FF8F2657B1B008E" ], [ "\033[2XPqProcessIndex\033[102X", "5.2-1", [ 5, 2, 1 ], 96, 37, "pqprocessindex", "X8558B20A80B999AE" ], [ "\033[2XPqProcessIndex\033[102X for default process", "5.2-1", [ 5, 2, 1 ], 96, 37, "pqprocessindex for default process", "X8558B20A80B999AE" ], [ "\033[2XPqProcessIndices\033[102X", "5.2-2", [ 5, 2, 2 ], 111, 38, "pqprocessindices", "X7E4A56D67C865291" ], [ "\033[2XIsPqProcessAlive\033[102X", "5.2-3", [ 5, 2, 3 ], 118, 38, "ispqprocessalive", "X7C103DF78435AEC7" ], [ "\033[2XIsPqProcessAlive\033[102X for default process", "5.2-3", [ 5, 2, 3 ], 118, 38, "ispqprocessalive for default process", "X7C103DF78435AEC7" ], [ "interruption", "5.2-3", [ 5, 2, 3 ], 118, 38, "interruption", "X7C103DF78435AEC7" ], [ "\033[2XPq\033[102X interactive", "5.3-1", [ 5, 3, 1 ], 144, 38, "pq interactive", "X85408C4C790439E7" ], [ "\033[2XPq\033[102X interactive, for default process", "5.3-1", [ 5, 3, 1 ], 144, 38, "pq interactive for default process", "X85408C4C790439E7" ], [ "option Prime", "5.3-1", [ 5, 3, 1 ], 144, 38, "option prime", "X85408C4C790439E7" ], [ "option ClassBound", "5.3-1", [ 5, 3, 1 ], 144, 38, "option classbound", "X85408C4C790439E7" ], [ "option Exponent", "5.3-1", [ 5, 3, 1 ], 144, 38, "option exponent", "X85408C4C790439E7" ], [ "option Relators", "5.3-1", [ 5, 3, 1 ], 144, 38, "option relators", "X85408C4C790439E7" ], [ "option Metabelian", "5.3-1", [ 5, 3, 1 ], 144, 38, "option metabelian", "X85408C4C790439E7" ], [ "option Identities", "5.3-1", [ 5, 3, 1 ], 144, 38, "option identities", "X85408C4C790439E7" ], [ "option GroupName", "5.3-1", [ 5, 3, 1 ], 144, 38, "option groupname", "X85408C4C790439E7" ], [ "option OutputLevel", "5.3-1", [ 5, 3, 1 ], 144, 38, "option outputlevel", "X85408C4C790439E7" ], [ "option RedoPcp", "5.3-1", [ 5, 3, 1 ], 144, 38, "option redopcp", "X85408C4C790439E7" ], [ "\033[2XPqEpimorphism\033[102X interactive", "5.3-2", [ 5, 3, 2 ], 236, 40, "pqepimorphism interactive", "X839E6F578227A8EA" ], [ "\033[2XPqEpimorphism\033[102X interactive, for default process", "5.3-2", [ 5, 3, 2 ], 236, 40, "pqepimorphism interactive for default process", "X839E6F578227A8EA" ], [ "\033[2XPqPCover\033[102X interactive", "5.3-3", [ 5, 3, 3 ], 256, 40, "pqpcover interactive", "X7AA64A2F8509A39A" ], [ "\033[2XPqPCover\033[102X interactive, for default process", "5.3-3", [ 5, 3, 3 ], 256, 40, "pqpcover interactive for default process", "X7AA64A2F8509A39A" ], [ "automorphisms of \033[22Xp\033[122X-groups", "5.3-3", [ 5, 3, 3 ], 256, 40, "automorphisms of p-groups", "X7AA64A2F8509A39A" ], [ "\033[2XPqStandardPresentation\033[102X interactive", "5.3-4", [ 5, 3, 4 ], 291, 41, "pqstandardpresentation interactive", "X805F32618005C087" ], [ "\033[2XStandardPresentation\033[102X interactive", "5.3-4", [ 5, 3, 4 ], 291, 41, "standardpresentation interactive", "X805F32618005C087" ], [ "option Prime", "5.3-4", [ 5, 3, 4 ], 291, 41, "option prime", "X805F32618005C087" ], [ "option pQuotient", "5.3-4", [ 5, 3, 4 ], 291, 41, "option pquotient", "X805F32618005C087" ], [ "option ClassBound", "5.3-4", [ 5, 3, 4 ], 291, 41, "option classbound", "X805F32618005C087" ], [ "option Exponent", "5.3-4", [ 5, 3, 4 ], 291, 41, "option exponent", "X805F32618005C087" ], [ "option Metabelian", "5.3-4", [ 5, 3, 4 ], 291, 41, "option metabelian", "X805F32618005C087" ], [ "option GroupName", "5.3-4", [ 5, 3, 4 ], 291, 41, "option groupname", "X805F32618005C087" ], [ "option OutputLevel", "5.3-4", [ 5, 3, 4 ], 291, 41, "option outputlevel", "X805F32618005C087" ], [ "option StandardPresentationFile", "5.3-4", [ 5, 3, 4 ], 291, 41, "option standardpresentationfile", "X805F32618005C087" ], [ "\033[2XEpimorphismPqStandardPresentation\033[102X interactive", "5.3-5", [ 5, 3, 5 ], 381, 42, "epimorphismpqstandardpresentation interactive", "X791392977B2D692D" ], [ "\033[2XEpimorphismStandardPresentation\033[102X interactive", "5.3-5", [ 5, 3, 5 ], 381, 42, "epimorphismstandardpresentation interactive", "X791392977B2D692D" ], [ "\033[2XPqDescendants\033[102X interactive", "5.3-6", [ 5, 3, 6 ], 457, 43, "pqdescendants interactive", "X795817217C53AB89" ], [ "\033[2XPqDescendants\033[102X interactive, for default process", "5.3-6", [ 5, 3, 6 ], 457, 43, "pqdescendants interactive for default process", "X795817217C53AB89" ], [ "option ClassBound", "5.3-6", [ 5, 3, 6 ], 457, 43, "option classbound", "X795817217C53AB89" ], [ "option Relators", "5.3-6", [ 5, 3, 6 ], 457, 43, "option relators", "X795817217C53AB89" ], [ "option OrderBound", "5.3-6", [ 5, 3, 6 ], 457, 43, "option orderbound", "X795817217C53AB89" ], [ "option StepSize", "5.3-6", [ 5, 3, 6 ], 457, 43, "option stepsize", "X795817217C53AB89" ], [ "option RankInitialSegmentSubgroups", "5.3-6", [ 5, 3, 6 ], 457, 43, "option rankinitialsegmentsubgroups", "X795817217C53AB89" ], [ "option SpaceEfficient", "5.3-6", [ 5, 3, 6 ], 457, 43, "option spaceefficient", "X795817217C53AB89" ], [ "option CapableDescendants", "5.3-6", [ 5, 3, 6 ], 457, 43, "option capabledescendants", "X795817217C53AB89" ], [ "option AllDescendants", "5.3-6", [ 5, 3, 6 ], 457, 43, "option alldescendants", "X795817217C53AB89" ], [ "option Exponent", "5.3-6", [ 5, 3, 6 ], 457, 43, "option exponent", "X795817217C53AB89" ], [ "option Metabelian", "5.3-6", [ 5, 3, 6 ], 457, 43, "option metabelian", "X795817217C53AB89" ], [ "option GroupName", "5.3-6", [ 5, 3, 6 ], 457, 43, "option groupname", "X795817217C53AB89" ], [ "option SubList", "5.3-6", [ 5, 3, 6 ], 457, 43, "option sublist", "X795817217C53AB89" ], [ "option BasicAlgorithm", "5.3-6", [ 5, 3, 6 ], 457, 43, "option basicalgorithm", "X795817217C53AB89" ], [ "option CustomiseOutput", "5.3-6", [ 5, 3, 6 ], 457, 43, "option customiseoutput", "X795817217C53AB89" ], [ "\033[2XPqSetPQuotientToGroup\033[102X", "5.3-7", [ 5, 3, 7 ], 590, 46, "pqsetpquotienttogroup", "X80CCF6D379E5A3B4" ], [ "\033[2XPqSetPQuotientToGroup\033[102X for default process", "5.3-7", [ 5, 3, 7 ], 590, 46, "pqsetpquotienttogroup for default process", "X80CCF6D379E5A3B4" ], [ "\033[2XPqNrPcGenerators\033[102X", "5.5-1", [ 5, 5, 1 ], 662, 47, "pqnrpcgenerators", "X7DE2F6C686C672DD" ], [ "\033[2XPqNrPcGenerators\033[102X for default process", "5.5-1", [ 5, 5, 1 ], 662, 47, "pqnrpcgenerators for default process", "X7DE2F6C686C672DD" ], [ "\033[2XPqFactoredOrder\033[102X", "5.5-2", [ 5, 5, 2 ], 672, 47, "pqfactoredorder", "X87FF98867E8FFB3C" ], [ "\033[2XPqFactoredOrder\033[102X for default process", "5.5-2", [ 5, 5, 2 ], 672, 47, "pqfactoredorder for default process", "X87FF98867E8FFB3C" ], [ "\033[2XPqOrder\033[102X", "5.5-3", [ 5, 5, 3 ], 686, 47, "pqorder", "X7B4FC9E380001A71" ], [ "\033[2XPqOrder\033[102X for default process", "5.5-3", [ 5, 5, 3 ], 686, 47, "pqorder for default process", "X7B4FC9E380001A71" ], [ "\033[2XPqPClass\033[102X", "5.5-4", [ 5, 5, 4 ], 694, 48, "pqpclass", "X87C7F7EB7C10DC4B" ], [ "\033[2XPqPClass\033[102X for default process", "5.5-4", [ 5, 5, 4 ], 694, 48, "pqpclass for default process", "X87C7F7EB7C10DC4B" ], [ "\033[2XPqWeight\033[102X", "5.5-5", [ 5, 5, 5 ], 702, 48, "pqweight", "X7EA3B6917908C20A" ], [ "\033[2XPqWeight\033[102X for default process", "5.5-5", [ 5, 5, 5 ], 702, 48, "pqweight for default process", "X7EA3B6917908C20A" ], [ "\033[2XPqCurrentGroup\033[102X", "5.5-6", [ 5, 5, 6 ], 712, 48, "pqcurrentgroup", "X79862B83817E20E1" ], [ "\033[2XPqCurrentGroup\033[102X for default process", "5.5-6", [ 5, 5, 6 ], 712, 48, "pqcurrentgroup for default process", "X79862B83817E20E1" ], [ "\033[2XPqDisplayPcPresentation\033[102X", "5.5-7", [ 5, 5, 7 ], 726, 48, "pqdisplaypcpresentation", "X805A50687D82B9EC" ], [ "\033[2XPqDisplayPcPresentation\033[102X for default process", "5.5-7", [ 5, 5, 7 ], 726, 48, "pqdisplaypcpresentation for default process", "X805A50687D82B9EC" ], [ "\033[2XPqSetOutputLevel\033[102X", "5.5-8", [ 5, 5, 8 ], 744, 48, "pqsetoutputlevel", "X80410979854280E1" ], [ "\033[2XPqSetOutputLevel\033[102X for default process", "5.5-8", [ 5, 5, 8 ], 744, 48, "pqsetoutputlevel for default process", "X80410979854280E1" ], [ "\033[2XPqEvaluateIdentities\033[102X", "5.5-9", [ 5, 5, 9 ], 756, 49, "pqevaluateidentities", "X7B8C72B37AE667F7" ], [ "\033[2XPqEvaluateIdentities\033[102X for default process", "5.5-9", [ 5, 5, 9 ], 756, 49, "pqevaluateidentities for default process", "X7B8C72B37AE667F7" ], [ "\033[2XPqPcPresentation\033[102X", "5.6-1", [ 5, 6, 1 ], 773, 49, "pqpcpresentation", "X7BF135DD84A781EB" ], [ "\033[2XPqPcPresentation\033[102X for default process", "5.6-1", [ 5, 6, 1 ], 773, 49, "pqpcpresentation for default process", "X7BF135DD84A781EB" ], [ "\033[2XPqSavePcPresentation\033[102X", "5.6-2", [ 5, 6, 2 ], 816, 50, "pqsavepcpresentation", "X7D947CEA82C44898" ], [ "\033[2XPqSavePcPresentation\033[102X for default process", "5.6-2", [ 5, 6, 2 ], 816, 50, "pqsavepcpresentation for default process", "X7D947CEA82C44898" ], [ "\033[2XPqRestorePcPresentation\033[102X", "5.6-3", [ 5, 6, 3 ], 832, 50, "pqrestorepcpresentation", "X7FD001C0798EF219" ], [ "\033[2XPqRestorePcPresentation\033[102X for default process", "5.6-3", [ 5, 6, 3 ], 832, 50, "pqrestorepcpresentation for default process", "X7FD001C0798EF219" ], [ "\033[2XPqNextClass\033[102X", "5.6-4", [ 5, 6, 4 ], 846, 50, "pqnextclass", "X832F69597C095A27" ], [ "\033[2XPqNextClass\033[102X for default process", "5.6-4", [ 5, 6, 4 ], 846, 50, "pqnextclass for default process", "X832F69597C095A27" ], [ "option QueueFactor", "5.6-4", [ 5, 6, 4 ], 846, 50, "option queuefactor", "X832F69597C095A27" ], [ "\033[2XPqComputePCover\033[102X", "5.6-5", [ 5, 6, 5 ], 877, 51, "pqcomputepcover", "X7CF9DF7A84D387CB" ], [ "\033[2XPqComputePCover\033[102X for default process", "5.6-5", [ 5, 6, 5 ], 877, 51, "pqcomputepcover for default process", "X7CF9DF7A84D387CB" ], [ "\033[2XPqCollect\033[102X", "5.7-1", [ 5, 7, 1 ], 904, 51, "pqcollect", "X8633356078CA4115" ], [ "\033[2XPqCollect\033[102X for default process", "5.7-1", [ 5, 7, 1 ], 904, 51, "pqcollect for default process", "X8633356078CA4115" ], [ "\033[2XPqSolveEquation\033[102X", "5.7-2", [ 5, 7, 2 ], 931, 52, "pqsolveequation", "X86CCB77281FDC0FC" ], [ "\033[2XPqSolveEquation\033[102X for default process", "5.7-2", [ 5, 7, 2 ], 931, 52, "pqsolveequation for default process", "X86CCB77281FDC0FC" ], [ "\033[2XPqCommutator\033[102X", "5.7-3", [ 5, 7, 3 ], 944, 52, "pqcommutator", "X789B120B7E2F3017" ], [ "\033[2XPqCommutator\033[102X for default process", "5.7-3", [ 5, 7, 3 ], 944, 52, "pqcommutator for default process", "X789B120B7E2F3017" ], [ "\033[2XPqSetupTablesForNextClass\033[102X", "5.7-4", [ 5, 7, 4 ], 960, 52, "pqsetuptablesfornextclass", "X7A61A15E78F52743" ], [ "\033[2XPqSetupTablesForNextClass\033[102X for default process", "5.7-4", [ 5, 7, 4 ], 960, 52, "pqsetuptablesfornextclass for default process", "X7A61A15E78F52743" ], [ "\033[2XPqTails\033[102X", "5.7-5", [ 5, 7, 5 ], 973, 52, "pqtails", "X84F7DD8582B368D3" ], [ "\033[2XPqTails\033[102X for default process", "5.7-5", [ 5, 7, 5 ], 973, 52, "pqtails for default process", "X84F7DD8582B368D3" ], [ "\033[2XPqComputeTails\033[102X", "5.7-6", [ 5, 7, 6 ], 1007, 53, "pqcomputetails", "X8389F6437ED634B8" ], [ "\033[2XPqComputeTails\033[102X for default process", "5.7-6", [ 5, 7, 6 ], 1007, 53, "pqcomputetails for default process", "X8389F6437ED634B8" ], [ "\033[2XPqAddTails\033[102X", "5.7-7", [ 5, 7, 7 ], 1021, 53, "pqaddtails", "X83CD6D888372DFB8" ], [ "\033[2XPqAddTails\033[102X for default process", "5.7-7", [ 5, 7, 7 ], 1021, 53, "pqaddtails for default process", "X83CD6D888372DFB8" ], [ "\033[2XPqDoConsistencyChecks\033[102X", "5.7-8", [ 5, 7, 8 ], 1036, 53, "pqdoconsistencychecks", "X82AA8FAE85826BB9" ], [ "\033[2XPqDoConsistencyChecks\033[102X for default process", "5.7-8", [ 5, 7, 8 ], 1036, 53, "pqdoconsistencychecks for default process", "X82AA8FAE85826BB9" ], [ "\033[2XPqCollectDefiningRelations\033[102X", "5.7-9", [ 5, 7, 9 ], 1078, 54, "pqcollectdefiningrelations", "X7A01EE0382689928" ], [ "\033[2XPqCollectDefiningRelations\033[102X for default process", "5.7-9", [ 5, 7, 9 ], 1078, 54, "pqcollectdefiningrelations for default process", "X7A01EE0382689928" ], [ "\033[2XPqCollectWordInDefiningGenerators\033[102X", "5.7-10", [ 5, 7, 10 ], 1092, 54, "pqcollectwordindefininggenerators", "X7C2B4C1E7BEB19D5" ], [ "\033[2XPqCollectWordInDefiningGenerators\033[102X for default process", "5.7-10", [ 5, 7, 10 ], 1092, 54, "pqcollectwordindefininggenerators for default process", "X7C2B4C1E7BEB19D5" ], [ "\033[2XPqCommutatorDefiningGenerators\033[102X", "5.7-11", [ 5, 7, 11 ], 1110, 55, "pqcommutatordefininggenerators", "X7DB05AA587D7A052" ], [ "\033[2XPqCommutatorDefiningGenerators\033[102X for default process", "5.7-11", [ 5, 7, 11 ], 1110, 55, "pqcommutatordefininggenerators for default process", "X7DB05AA587D7A052" ], [ "\033[2XPqDoExponentChecks\033[102X", "5.7-12", [ 5, 7, 12 ], 1126, 55, "pqdoexponentchecks", "X80E563A97EDE083E" ], [ "\033[2XPqDoExponentChecks\033[102X for default process", "5.7-12", [ 5, 7, 12 ], 1126, 55, "pqdoexponentchecks for default process", "X80E563A97EDE083E" ], [ "\033[2XPqEliminateRedundantGenerators\033[102X", "5.7-13", [ 5, 7, 13 ], 1141, 55, "pqeliminateredundantgenerators", "X7BBAB2787B305516" ], [ "\033[2XPqEliminateRedundantGenerators\033[102X for default process", "5.7-13", [ 5, 7, 13 ], 1141, 55, "pqeliminateredundantgenerators for default process", "X7BBAB2787B305516" ], [ "\033[2XPqRevertToPreviousClass\033[102X", "5.7-14", [ 5, 7, 14 ], 1152, 55, "pqreverttopreviousclass", "X783E53B5853F45E6" ], [ "\033[2XPqRevertToPreviousClass\033[102X for default process", "5.7-14", [ 5, 7, 14 ], 1152, 55, "pqreverttopreviousclass for default process", "X783E53B5853F45E6" ], [ "\033[2XPqSetMaximalOccurrences\033[102X", "5.7-15", [ 5, 7, 15 ], 1163, 56, "pqsetmaximaloccurrences", "X8265A6DB81CD24DB" ], [ "\033[2XPqSetMaximalOccurrences\033[102X for default process", "5.7-15", [ 5, 7, 15 ], 1163, 56, "pqsetmaximaloccurrences for default process", "X8265A6DB81CD24DB" ], [ "\033[2XPqSetMetabelian\033[102X", "5.7-16", [ 5, 7, 16 ], 1183, 56, "pqsetmetabelian", "X87A35ABB7E11595E" ], [ "\033[2XPqSetMetabelian\033[102X for default process", "5.7-16", [ 5, 7, 16 ], 1183, 56, "pqsetmetabelian for default process", "X87A35ABB7E11595E" ], [ "\033[2XPqDoConsistencyCheck\033[102X", "5.7-17", [ 5, 7, 17 ], 1194, 56, "pqdoconsistencycheck", "X7C7D17F878AA1BAA" ], [ "\033[2XPqDoConsistencyCheck\033[102X for default process", "5.7-17", [ 5, 7, 17 ], 1194, 56, "pqdoconsistencycheck for default process", "X7C7D17F878AA1BAA" ], [ "\033[2XPqJacobi\033[102X", "5.7-17", [ 5, 7, 17 ], 1194, 56, "pqjacobi", "X7C7D17F878AA1BAA" ], [ "\033[2XPqJacobi\033[102X for default process", "5.7-17", [ 5, 7, 17 ], 1194, 56, "pqjacobi for default process", "X7C7D17F878AA1BAA" ], [ "\033[2XPqCompact\033[102X", "5.7-18", [ 5, 7, 18 ], 1248, 57, "pqcompact", "X843953F48319FDE1" ], [ "\033[2XPqCompact\033[102X for default process", "5.7-18", [ 5, 7, 18 ], 1248, 57, "pqcompact for default process", "X843953F48319FDE1" ], [ "\033[2XPqEchelonise\033[102X", "5.7-19", [ 5, 7, 19 ], 1260, 57, "pqechelonise", "X80344EEC78A09ACF" ], [ "\033[2XPqEchelonise\033[102X for default process", "5.7-19", [ 5, 7, 19 ], 1260, 57, "pqechelonise for default process", "X80344EEC78A09ACF" ], [ "\033[2XPqSupplyAutomorphisms\033[102X", "5.7-20", [ 5, 7, 20 ], 1276, 57, "pqsupplyautomorphisms", "X852947327FC39DDF" ], [ "\033[2XPqSupplyAutomorphisms\033[102X for default process", "5.7-20", [ 5, 7, 20 ], 1276, 57, "pqsupplyautomorphisms for default process", "X852947327FC39DDF" ], [ "\033[2XPqExtendAutomorphisms\033[102X", "5.7-21", [ 5, 7, 21 ], 1294, 58, "pqextendautomorphisms", "X7B919B537C042DAD" ], [ "\033[2XPqExtendAutomorphisms\033[102X for default process", "5.7-21", [ 5, 7, 21 ], 1294, 58, "pqextendautomorphisms for default process", "X7B919B537C042DAD" ], [ "\033[2XPqApplyAutomorphisms\033[102X", "5.7-22", [ 5, 7, 22 ], 1306, 58, "pqapplyautomorphisms", "X7CFD54657DE4BD39" ], [ "\033[2XPqApplyAutomorphisms\033[102X for default process", "5.7-22", [ 5, 7, 22 ], 1306, 58, "pqapplyautomorphisms for default process", "X7CFD54657DE4BD39" ], [ "\033[2XPqDisplayStructure\033[102X", "5.7-23", [ 5, 7, 23 ], 1317, 58, "pqdisplaystructure", "X81A3D5BF87A34934" ], [ "\033[2XPqDisplayStructure\033[102X for default process", "5.7-23", [ 5, 7, 23 ], 1317, 58, "pqdisplaystructure for default process", "X81A3D5BF87A34934" ], [ "\033[2XPqDisplayAutomorphisms\033[102X", "5.7-24", [ 5, 7, 24 ], 1380, 59, "pqdisplayautomorphisms", "X853834B478C4EEE2" ], [ "\033[2XPqDisplayAutomorphisms\033[102X for default process", "5.7-24", [ 5, 7, 24 ], 1380, 59, "pqdisplayautomorphisms for default process", "X853834B478C4EEE2" ], [ "\033[2XPqWritePcPresentation\033[102X", "5.7-25", [ 5, 7, 25 ], 1396, 59, "pqwritepcpresentation", "X80687A138626EB2D" ], [ "\033[2XPqWritePcPresentation\033[102X for default process", "5.7-25", [ 5, 7, 25 ], 1396, 59, "pqwritepcpresentation for default process", "X80687A138626EB2D" ], [ "\033[2XPqSPComputePcpAndPCover\033[102X", "5.8-1", [ 5, 8, 1 ], 1418, 60, "pqspcomputepcpandpcover", "X78D1963D85C71B7B" ], [ "\033[2XPqSPComputePcpAndPCover\033[102X for default process", "5.8-1", [ 5, 8, 1 ], 1418, 60, "pqspcomputepcpandpcover for default process", "X78D1963D85C71B7B" ], [ "\033[2XPqSPStandardPresentation\033[102X", "5.8-2", [ 5, 8, 2 ], 1440, 60, "pqspstandardpresentation", "X876F30187E89E467" ], [ "\033[2XPqSPStandardPresentation\033[102X for default process", "5.8-2", [ 5, 8, 2 ], 1440, 60, "pqspstandardpresentation for default process", "X876F30187E89E467" ], [ "option ClassBound", "5.8-2", [ 5, 8, 2 ], 1440, 60, "option classbound", "X876F30187E89E467" ], [ "option PcgsAutomorphisms", "5.8-2", [ 5, 8, 2 ], 1440, 60, "option pcgsautomorphisms", "X876F30187E89E467" ], [ "option StandardPresentationFile", "5.8-2", [ 5, 8, 2 ], 1440, 60, "option standardpresentationfile", "X876F30187E89E467" ], [ "\033[2XPqSPSavePresentation\033[102X", "5.8-3", [ 5, 8, 3 ], 1474, 61, "pqspsavepresentation", "X7E1B2B088322F48A" ], [ "\033[2XPqSPSavePresentation\033[102X for default process", "5.8-3", [ 5, 8, 3 ], 1474, 61, "pqspsavepresentation for default process", "X7E1B2B088322F48A" ], [ "\033[2XPqSPCompareTwoFilePresentations\033[102X", "5.8-4", [ 5, 8, 4 ], 1490, 61, "pqspcomparetwofilepresentations", "X81D2F9FF7C241D1E" ], [ "\033[2XPqSPCompareTwoFilePresentations\033[102X for default process", "5.8-4", [ 5, 8, 4 ], 1490, 61, "pqspcomparetwofilepresentations for default process", "X81D2F9FF7C241D1E" ], [ "\033[2XPqSPIsomorphism\033[102X", "5.8-5", [ 5, 8, 5 ], 1513, 61, "pqspisomorphism", "X7D1277E584590ECE" ], [ "\033[2XPqSPIsomorphism\033[102X for default process", "5.8-5", [ 5, 8, 5 ], 1513, 61, "pqspisomorphism for default process", "X7D1277E584590ECE" ], [ "\033[2XPqPGSupplyAutomorphisms\033[102X", "5.9-1", [ 5, 9, 1 ], 1534, 62, "pqpgsupplyautomorphisms", "X794A8D667A9D725A" ], [ "\033[2XPqPGSupplyAutomorphisms\033[102X for default process", "5.9-1", [ 5, 9, 1 ], 1534, 62, "pqpgsupplyautomorphisms for default process", "X794A8D667A9D725A" ], [ "\033[2XPqPGExtendAutomorphisms\033[102X", "5.9-2", [ 5, 9, 2 ], 1553, 62, "pqpgextendautomorphisms", "X87F251077C65B6DD" ], [ "\033[2XPqPGExtendAutomorphisms\033[102X for default process", "5.9-2", [ 5, 9, 2 ], 1553, 62, "pqpgextendautomorphisms for default process", "X87F251077C65B6DD" ], [ "\033[2XPqPGConstructDescendants\033[102X", "5.9-3", [ 5, 9, 3 ], 1567, 62, "pqpgconstructdescendants", "X82FD51A27D269E43" ], [ "\033[2XPqPGConstructDescendants\033[102X for default process", "5.9-3", [ 5, 9, 3 ], 1567, 62, "pqpgconstructdescendants for default process", "X82FD51A27D269E43" ], [ "\033[2XPqPGSetDescendantToPcp\033[102X with class", "5.9-4", [ 5, 9, 4 ], 1588, 63, "pqpgsetdescendanttopcp with class", "X7E9D511385D48A98" ], [ "\033[2XPqPGSetDescendantToPcp\033[102X with class, for default process", "5.9-4", [ 5, 9, 4 ], 1588, 63, "pqpgsetdescendanttopcp with class for default process", "X7E9D511385D48A98" ], [ "\033[2XPqPGSetDescendantToPcp\033[102X", "5.9-4", [ 5, 9, 4 ], 1588, 63, "pqpgsetdescendanttopcp", "X7E9D511385D48A98" ], [ "\033[2XPqPGSetDescendantToPcp\033[102X for default process", "5.9-4", [ 5, 9, 4 ], 1588, 63, "pqpgsetdescendanttopcp for default process", "X7E9D511385D48A98" ], [ "\033[2XPqPGRestoreDescendantFromFile\033[102X with class", "5.9-4", [ 5, 9, 4 ], 1588, 63, "pqpgrestoredescendantfromfile with class", "X7E9D511385D48A98" ], [ "\033[2XPqPGRestoreDescendantFromFile\033[102X with class, for default proc\ ess", "5.9-4", [ 5, 9, 4 ], 1588, 63, "pqpgrestoredescendantfromfile with class for default process", "X7E9D511385D48A98" ], [ "\033[2XPqPGRestoreDescendantFromFile\033[102X", "5.9-4", [ 5, 9, 4 ], 1588, 63, "pqpgrestoredescendantfromfile", "X7E9D511385D48A98" ], [ "\033[2XPqPGRestoreDescendantFromFile\033[102X for default process", "5.9-4", [ 5, 9, 4 ], 1588, 63, "pqpgrestoredescendantfromfile for default process", "X7E9D511385D48A98" ], [ "\033[2XPqAPGDegree\033[102X", "5.10-1", [ 5, 10, 1 ], 1634, 64, "pqapgdegree", "X7E539E4B78A6CE8D" ], [ "\033[2XPqAPGDegree\033[102X for default process", "5.10-1", [ 5, 10, 1 ], 1634, 64, "pqapgdegree for default process", "X7E539E4B78A6CE8D" ], [ "\033[2XPqAPGPermutations\033[102X", "5.10-2", [ 5, 10, 2 ], 1644, 64, "pqapgpermutations", "X7F1182A77AB7650C" ], [ "\033[2XPqAPGPermutations\033[102X for default process", "5.10-2", [ 5, 10, 2 ], 1644, 64, "pqapgpermutations for default process", "X7F1182A77AB7650C" ], [ "\033[2XPqAPGOrbits\033[102X", "5.10-3", [ 5, 10, 3 ], 1655, 64, "pqapgorbits", "X7DD9E7507AA888CC" ], [ "\033[2XPqAPGOrbits\033[102X for default process", "5.10-3", [ 5, 10, 3 ], 1655, 64, "pqapgorbits for default process", "X7DD9E7507AA888CC" ], [ "\033[2XPqAPGOrbitRepresentatives\033[102X", "5.10-4", [ 5, 10, 4 ], 1668, 64, "pqapgorbitrepresentatives", "X795A756C78BE5923" ], [ "\033[2XPqAPGOrbitRepresentatives\033[102X for default process", "5.10-4", [ 5, 10, 4 ], 1668, 64, "pqapgorbitrepresentatives for default process", "X795A756C78BE5923" ], [ "\033[2XPqAPGSingleStage\033[102X", "5.10-5", [ 5, 10, 5 ], 1684, 64, "pqapgsinglestage", "X7E5D6D5782FE190E" ], [ "\033[2XPqAPGSingleStage\033[102X for default process", "5.10-5", [ 5, 10, 5 ], 1684, 64, "pqapgsinglestage for default process", "X7E5D6D5782FE190E" ], [ "\033[2XPqRead\033[102X", "5.11-1", [ 5, 11, 1 ], 1706, 65, "pqread", "X8464AF7E83A523C1" ], [ "\033[2XPqRead\033[102X for default process", "5.11-1", [ 5, 11, 1 ], 1706, 65, "pqread for default process", "X8464AF7E83A523C1" ], [ "\033[2XPqReadAll\033[102X", "5.11-2", [ 5, 11, 2 ], 1721, 65, "pqreadall", "X7ADD82207D049A87" ], [ "\033[2XPqReadAll\033[102X for default process", "5.11-2", [ 5, 11, 2 ], 1721, 65, "pqreadall for default process", "X7ADD82207D049A87" ], [ "\033[2XPqReadUntil\033[102X", "5.11-3", [ 5, 11, 3 ], 1735, 65, "pqreaduntil", "X7EBF3C3681671879" ], [ "\033[2XPqReadUntil\033[102X for default process", "5.11-3", [ 5, 11, 3 ], 1735, 65, "pqreaduntil for default process", "X7EBF3C3681671879" ], [ "\033[2XPqReadUntil\033[102X with modify map", "5.11-3", [ 5, 11, 3 ], 1735, 65, "pqreaduntil with modify map", "X7EBF3C3681671879" ], [ "\033[2XPqReadUntil\033[102X with modify map, for default process", "5.11-3", [ 5, 11, 3 ], 1735, 65, "pqreaduntil with modify map for default process", "X7EBF3C3681671879" ] , [ "\033[2XPqWrite\033[102X", "5.11-4", [ 5, 11, 4 ], 1760, 66, "pqwrite", "X83CBE77F78057E21" ], [ "\033[2XPqWrite\033[102X for default process", "5.11-4", [ 5, 11, 4 ], 1760, 66, "pqwrite for default process", "X83CBE77F78057E21" ], [ "\033[2XAllANUPQoptions\033[102X", "6.1-1", [ 6, 1, 1 ], 14, 67, "allanupqoptions", "X7846E25D8065D78F" ], [ "\033[2XANUPQoptions\033[102X", "6.1-2", [ 6, 1, 2 ], 35, 67, "anupqoptions", "X82D560C77D195089" ], [ "option Prime", "6.2", [ 6, 2, 0 ], 73, 68, "option prime", "X87EE6DD67C9996A3" ], [ "option ClassBound", "6.2", [ 6, 2, 0 ], 73, 68, "option classbound", "X87EE6DD67C9996A3" ], [ "option pQuotient", "6.2", [ 6, 2, 0 ], 73, 68, "option pquotient", "X87EE6DD67C9996A3" ], [ "option Exponent", "6.2", [ 6, 2, 0 ], 73, 68, "option exponent", "X87EE6DD67C9996A3" ], [ "option Relators", "6.2", [ 6, 2, 0 ], 73, 68, "option relators", "X87EE6DD67C9996A3" ], [ "option Metabelian", "6.2", [ 6, 2, 0 ], 73, 68, "option metabelian", "X87EE6DD67C9996A3" ], [ "option GroupName", "6.2", [ 6, 2, 0 ], 73, 68, "option groupname", "X87EE6DD67C9996A3" ], [ "option Identities", "6.2", [ 6, 2, 0 ], 73, 68, "option identities", "X87EE6DD67C9996A3" ], [ "option OutputLevel", "6.2", [ 6, 2, 0 ], 73, 68, "option outputlevel", "X87EE6DD67C9996A3" ], [ "option RedoPcp", "6.2", [ 6, 2, 0 ], 73, 68, "option redopcp", "X87EE6DD67C9996A3" ], [ "option SetupFile", "6.2", [ 6, 2, 0 ], 73, 68, "option setupfile", "X87EE6DD67C9996A3" ], [ "option PqWorkspace", "6.2", [ 6, 2, 0 ], 73, 68, "option pqworkspace", "X87EE6DD67C9996A3" ], [ "option PcgsAutomorphisms", "6.2", [ 6, 2, 0 ], 73, 68, "option pcgsautomorphisms", "X87EE6DD67C9996A3" ], [ "option OrderBound", "6.2", [ 6, 2, 0 ], 73, 68, "option orderbound", "X87EE6DD67C9996A3" ], [ "option StepSize", "6.2", [ 6, 2, 0 ], 73, 68, "option stepsize", "X87EE6DD67C9996A3" ], [ "option RankInitialSegmentSubgroups", "6.2", [ 6, 2, 0 ], 73, 68, "option rankinitialsegmentsubgroups", "X87EE6DD67C9996A3" ], [ "option SpaceEfficient", "6.2", [ 6, 2, 0 ], 73, 68, "option spaceefficient", "X87EE6DD67C9996A3" ], [ "option CapableDescendants", "6.2", [ 6, 2, 0 ], 73, 68, "option capabledescendants", "X87EE6DD67C9996A3" ], [ "option AllDescendants", "6.2", [ 6, 2, 0 ], 73, 68, "option alldescendants", "X87EE6DD67C9996A3" ], [ "option TreeDepth", "6.2", [ 6, 2, 0 ], 73, 68, "option treedepth", "X87EE6DD67C9996A3" ], [ "option SubList", "6.2", [ 6, 2, 0 ], 73, 68, "option sublist", "X87EE6DD67C9996A3" ], [ "option NumberOfSolubleAutomorphisms", "6.2", [ 6, 2, 0 ], 73, 68, "option numberofsolubleautomorphisms", "X87EE6DD67C9996A3" ], [ "option RelativeOrders", "6.2", [ 6, 2, 0 ], 73, 68, "option relativeorders", "X87EE6DD67C9996A3" ], [ "option BasicAlgorithm", "6.2", [ 6, 2, 0 ], 73, 68, "option basicalgorithm", "X87EE6DD67C9996A3" ], [ "option CustomiseOutput", "6.2", [ 6, 2, 0 ], 73, 68, "option customiseoutput", "X87EE6DD67C9996A3" ], [ "option StandardPresentationFile", "6.2", [ 6, 2, 0 ], 73, 68, "option standardpresentationfile", "X87EE6DD67C9996A3" ], [ "option QueueFactor", "6.2", [ 6, 2, 0 ], 73, 68, "option queuefactor", "X87EE6DD67C9996A3" ], [ "option Bounds", "6.2", [ 6, 2, 0 ], 73, 68, "option bounds", "X87EE6DD67C9996A3" ], [ "option PrintAutomorphisms", "6.2", [ 6, 2, 0 ], 73, 68, "option printautomorphisms", "X87EE6DD67C9996A3" ], [ "option PrintPermutations", "6.2", [ 6, 2, 0 ], 73, 68, "option printpermutations", "X87EE6DD67C9996A3" ], [ "option Filename", "6.2", [ 6, 2, 0 ], 73, 68, "option filename", "X87EE6DD67C9996A3" ], [ "\033[10XANUPQ_GAP_EXEC\033[110X environment variable", "7.0", [ 7, 0, 0 ], 1, 75, "anupq_gap_exec environment variable", "X7FB487238298CF42" ], [ "\033[10XANUPQ_GAP_EXEC\033[110X environment variable", "7.1", [ 7, 1, 0 ], 105, 76, "anupq_gap_exec environment variable", "X854577C8800DC7C2" ], [ "\033[10XANUPQ_GAP_EXEC\033[110X environment variable", "7.2", [ 7, 2, 0 ], 155, 77, "anupq_gap_exec environment variable", "X82906B5184C61063" ], [ "\033[22XB(5,4)\033[122X", "a.3", [ "A", 3, 0 ], 362, 85, "b 5 4", "X7A997D1A8532A84B" ], [ "\033[2XPqDescendantsTreeCoclassOne\033[102X", "a.4-1", [ "A", 4, 1 ], 606, 90, "pqdescendantstreecoclassone", "X805E6B418193CF2D" ], [ "\033[2XPqDescendantsTreeCoclassOne\033[102X for default process", "a.4-1", [ "A", 4, 1 ], 606, 90, "pqdescendantstreecoclassone for default process", "X805E6B418193CF2D" ] ] ); anupq-3.3.3/doc/title.xml0000644000175100017510000000216115111342310014651 0ustar runnerrunner &ANUPQ; ANU p-Quotient &VERSION; &ANUPQ; is maintained by mailto:mhorn@rptu.de. For support requests, please use https://github.com/gap-packages/anupq/issues. Greg Gamble
 Greg.Gamble@uwa.edu.au Werner Nickel
 Eamonn O'Brien
 obrien@math.auckland.ac.nz https://www.math.auckland.ac.nz/~obrien &RELEASEDATE; ©right; 2001-2016 by Greg Gamble

©right; 2001-2005 by Werner Nickel

©right; 1995-2001 by Eamon O'Brien

The &GAP; package &ANUPQ; is licensed under the https://opensource.org/licenses/artistic-license-2.0. anupq-3.3.3/doc/chap2.html0000644000175100017510000006753715111342310014713 0ustar runnerrunner GAP (ANUPQ) - Chapter 2: Mathematical Background and Terminology

Goto Chapter: Top 1 2 3 4 5 6 7 A Bib Ind
 [Top of Book]  [Contents]   [Previous Chapter]   [Next Chapter] 

2 Mathematical Background and Terminology
 2.1 Basic notions

  2.1-1 pc Presentations and Consistency
  2.1-2 Exponent-p Central Series and Weighted pc Presentations
  2.1-3 p-Cover, p-Multiplicator
  2.1-4 Descendants, Capable, Terminal, Nucleus
  2.1-5 Laws
 2.2 The p-quotient Algorithm

  2.2-1 Finding the p-cover
  2.2-2 Imposing the Relations of the fp Group
  2.2-3 Imposing Laws
 2.3 The p-group generation Algorithm, Standard Presentation, Isomorphism Testing

2 Mathematical Background and Terminology

In this chapter we will give a brief description of the mathematical notions used in the algorithms implemented in the ANU pq program that are made accessible from GAP through this package. For proofs and details we will point to relevant places in the published literature. Also we will try to give some explanation of terminology that may help to use the low-level interactive functions described in Section Low-level Interactive ANUPQ functions based on menu items of the pq program. However, users who intend to use these functions are strongly advised to acquire a thorough understanding of the algorithms from the quoted literature. There is little or no checking done in these functions and naive use may result in incorrect results.

2.1 Basic notions

Throughout this manual, by p-group we always mean finite p-group.

2.1-1 pc Presentations and Consistency

For details, see e.g. [NNN98].

Every finite p-group G has a presentation of the form:

\{a_1,\dots,a_n \mid a_i^p = v_{ii}, 1 \le i \le n, [a_k, a_j] = v_{jk}, 1 \le j < k \le n \}.

where v_jk is a word in the elements a_k+1,dots,a_n for 1 ≤ j ≤ k ≤ n.

This is called a power-commutator presentation (or pc presentation or pcp) of G, generators from such a presentation will be referred to as pc generators. In terms of such pc generators every element of G can be written in a normal form a_1^e_1dots a_n^e_n with 0 ≤ e_i < p. Moreover any given product of the generators can be brought into such a normal form using the defining relations in the above presentation as rewrite rules. Any such process is called collection. For the discussion of various collection methods see [LS90] and [Vau90b].

Every p-group of order p^n has such a pcp on n generators and conversely every such presentation defines a p-group. However a p-group defined by a pcp on n generators can be of smaller order p^m with m<n. A pcp on n generators that does in fact define a p-group of order p^n is called consistent in this manual, in line with most of the literature on the algorithms occurring here. A consistent pcp determines a confluent rewriting system (see IsConfluent (Reference: IsConfluent) of the GAP Reference Manual) for the group it defines and for this reason often (in particular in the GAP Reference Manual) such a pcp presentation is also called confluent.

Consistency of a pcp is tantamount to the fact that for any given word in the generators any two collections will yield the same normal form.

Consistency of a pcp can be checked by a finite set of consistency conditions, demanding that collection of the left hand side and of the right hand side of certain equations, starting with subproducts indicated by bracketing, will result in the same normal form. There are 3 types of such equations (that will be referred to in the manual):

\begin{array}{rclrl} (a^n)a &=& a(a^n) &&{\rm (Type 1)} \\ (b^n)a &=& b^{(n-1)}(ba), b(a^n) = (ba)a^{(n-1)} &&{\rm (Type 2)} \\ c(ba) &=& (cb)a &&{\rm (Type 3)} \\ \end{array}

See [Vau84] for a description of a sufficient set of consistency conditions in the context of the p-quotient algorithm.

2.1-2 Exponent-p Central Series and Weighted pc Presentations

For details, see [NNN98].

The (descending or lower) (exponent-)p-central series of an arbitrary group G is defined by

P_0(G) := G, P_i(G) := [G, P_{i-1}(G)] P_{i-1}(G)^p.

For a p-group G this series terminates with the trivial group. G has p-class c if c is the smallest integer such that P_c(G) is the trivial group. In this manual, as well as in much of the literature about the pq- and related algorithms, the p-class is often referred to simply by class.

Let the p-group G have a consistent pcp as above. Then the subgroups

\langle1\rangle < {\langle}a_n\rangle < {\langle}a_n, a_{n-1}\rangle < \dots < {\langle}a_n,\dots,a_i\rangle < \dots < G

form a central series of G. If this refines the p-central series, we can define the weight function w for the pc generators by w(a_i) = k, if a_i is contained in P_k-1(G) but not in P_k(G).

The pair of such a weight function and a pcp allowing it, is called a weighted pcp.

2.1-3 p-Cover, p-Multiplicator

For details, see [NNN98].

Let d be the minimal number of generators of the p-group G of p-class c. Then G is isomorphic to a factor group F/R of a free group F of rank d. We denote [F, R] R^p by R^*. It can be proved (see e.g. [O'B90]) that the isomorphism type of G^* := F/R^* depends only on G. G^* is called the p-covering group or p-cover of G, and R/R^* the p-multiplicator of G. The p-multiplicator is, of course, an elementary abelian p-group; its minimal number of generators is called the (p-)multiplicator rank.

2.1-4 Descendants, Capable, Terminal, Nucleus

For details, see [New77] and [O'B90].

Let again G be a p-group of p-class c and d the minimal number of generators of G. A p-group H is a descendant of G if the minimal number of generators of H is d and H/P_c(H) is isomorphic to G. A descendant H of G is a proper descendant if it has p-class at least c+1. A descendant H of G is an immediate descendant if it has p-class c+1. G is called capable if it has immediate descendants; otherwise it is terminal.

Let G^* = F/R^* again be the p-cover of G. Then the group P_c(G^*) is called the nucleus of G. Note that P_c(G^*) is contained in the p-multiplicator R/R^*.

It is proved (e.g. in [O'B90]) that the immediate descendants of G are obtained as factor groups of the p-cover by (proper) supplements of the nucleus in the (elementary abelian) p-multiplicator. These are also called allowable.

It is further proved there that every automorphism α of F/R extends to an automorphism α^* of the p-cover F/R^* and that the restriction of α^* to the multiplicator R/R^* is uniquely determined by α. Each extended automorphism α^* induces a permutation of the allowable subgroups. Thus the extended automorphisms determine a group P of permutations on the set A of allowable subgroups (The group P of permutations will appear in the description of some interactive functions). Choosing a representative S from each orbit of P on A, the set of factor groups F/S contains each (isomorphism type of) immediate descendant of G exactly once. For each immediate descendant, the procedure of computing the p-cover, extending the automorphisms and computing the orbits on allowable subgroups can be repeated. Iteration of this procedure can in principle be used to determine all descendants of a p-group.

2.1-5 Laws

Let l(x_1, dots, x_n) be a word in the free generators x_1, dots, x_n of a free group of rank n. Then l(x_1, dots, x_n) = 1 is called a law or identical relation in a group G if l(g_1, dots, g_n) = 1 for any choice of elements g_1, dots, g_n in G. In particular, x^e = 1 is called an exponent law, [[x,y],[u,v]] = 1 the metabelian law, and [dots [[x_1,x_2],x_2],dots, x_2] = 1 an Engel identity.

2.2 The p-quotient Algorithm

For details, see [HN80], [NO96] and [Vau84]. Other descriptions of the algorithm are given in [Sim94].

The pq algorithm successively determines the factor groups of the groups of the p-central series of a finitely presented (fp) group G. If a bound b for the p-class is given, the algorithm will determine those factor groups up to at most p-class b. If the p-central series terminates with a subgroup P_k(G) with k < b, the algorithm will stop with that group. If no such bound is given, it will try to find the biggest such factor group.

G/P_1(G) is the largest elementary abelian p-factor group of G and this can be found from the relation matrix of G using matrix diagonalisation modulo p. So it suffices to explain how G/P_i+1(G) is found from G and G/P_i(G) for some i ≥ 1.

This is done, in principle, in two steps: first the p-cover of G_i := G/P_i(G) is determined (which depends only on G_i, not on G) and then G/P_i+1(G) as a factor group of this p-cover.

2.2-1 Finding the p-cover

A very detailed description of the first step is given in [NNN98], from which we just extract some passages in order to point to some terms occurring in this manual.

Let H be a p-group and p^d(b) be the order of H/P_b(H). So d := d(1) is the minimal number of generators of H. A weighted pcp of H will be called labelled if for each generator a_k, k > d one relation, having this generator as its right hand side, is marked as definition of this generator.

As described in [NNN98], a weighted labelled pcp of a p-group can be obtained stepping down its p-central series.

So let us assume that a weighted labelled pcp of G_i is given. A straightforward way of of writing down a (not necessarily consistent) pcp for its p-cover is to add generators, one for each relation which is not a definition, and modify the right hand side of each such relation by multiplying it on the right by one of the new generators -- a different generator for each such relation. Further relations are then added to make the new generators central and of order p. This procedure is called adding tails. A more formal description of it is again given in [NNN98].

It is important to realise that the new generators will generate an elementary abelian group, that is, in additive notation, a vector space over the field of p elements. As said, the pcp of the p-cover obtained in this way need not be consistent. Since the pcp of G_i was consistent, applying the consistency conditions to the pcp of the p-cover, in case the presentation obtained for p-cover is not consistent, will produce a set of equations between the new generators, that, written additively, are linear equations over the field of p elements and can hence be used to remove redundant generators until a consistent pcp is obtained.

In reality, to follow this straightforward procedure would be forbiddingly inefficient except for very small examples. There are many ways of a priori reducing the number of new generators to be introduced, using e.g. the weights attached to the generators, and the main part of [NNN98] is devoted to a detailed discussion with proofs of these possibilities.

2.2-2 Imposing the Relations of the fp Group

In order to obtain G/P_i+1(G) from the pcp of the p-cover of G_i = G/P_i(G), the defining relations from the original presentation of G must be imposed. Since G_i is a homomorphic image of G, these relations again yield relations between the new generators in the presentation of the p-cover of G_i.

2.2-3 Imposing Laws

While we have so far only considered the computation of the factor groups of a given fp group by the groups of its descending p-central series, the p-quotient algorithm allows a very important variant of this idea: laws can be prescribed that should be fulfilled by the p-factor groups computed by the algorithm. The key observation here is the fact that at each step down the descending p-central series it suffices to impose these laws only for a finite number of words. Again for efficiency of the method it is crucial to keep the number of such words small, and much of [NO96] and the literature quoted in this paper is devoted to this problem.

In this form, starting with a free group and imposing an exponent law (also referred to as an exponent check) the pq program has, in fact, found its most noted application in the determination of (restricted) Burnside groups (as reported in e.g. [HN80], [NO96] and [Vau90a]).

Via a GAP program using the local interactive functions of the pq program made available through this interface also arbitrary laws can be imposed via the option Identities (see 6.2).

2.3 The p-group generation Algorithm, Standard Presentation, Isomorphism Testing

For details, see [New77] and [O'B90].

The p-group generation algorithm determines the immediate descendants of a given p-group G up to isomorphism. From what has been explained in Section Basic notions, it is clear that this amounts to the construction of the p-cover, the extension of the automorphisms of G to the p-cover and the determination of representatives of the orbits of the action of these automorphisms on the set of supplements of the nucleus in the p-multiplicator.

The main practical problem here is the determination of these representatives. [O'B90] describes methods for this and the pq program allows choices according to whether space or time limitations must be met.

As well as the descendants of G, the pq program determines their automorphism groups from that of G (see [O'B95]), which is important for an iteration of the process; this has been used by Eamonn O'Brien, e.g. in the classification of the 2-groups that are now also part of the Small Groups library available through GAP.

A variant of the p-group generation algorithm is also used to define a standard presentation of a given p-group. This is done by constructing an isomorphic copy of the given group through a chain of descendants and at each step making a choice of a particular representative for the respective orbit of capable groups. In a fairly delicate process, subgroups of the p-multiplicator are represented by echelonised matrices and a first among the labels for standard matrices is chosen (this is described in detail in [O'B94]).

Finally, the standard presentation provides a way of testing if two given p-groups are isomorphic: the standard presentations of the groups are computed, for practical purposes compacted and the results compared for being identical, i.e. the groups are isomorphic if and only if their standard presentations are identical.

 [Top of Book]  [Contents]   [Previous Chapter]   [Next Chapter] 
Goto Chapter: Top 1 2 3 4 5 6 7 A Bib Ind

generated by GAPDoc2HTML

anupq-3.3.3/doc/chap5_mj.html0000644000175100017510000053212715111342310015374 0ustar runnerrunner GAP (ANUPQ) - Chapter 5: Interactive ANUPQ functions
Goto Chapter: Top 1 2 3 4 5 6 7 A Bib Ind
 [Top of Book]  [Contents]   [Previous Chapter]   [Next Chapter] 

5 Interactive ANUPQ functions
 5.1 Starting and Stopping Interactive ANUPQ Processes

  5.1-1 PqStart
  5.1-2 PqQuit
  5.1-3 PqQuitAll
 5.2 Interactive ANUPQ Process Utility Functions

  5.2-1 PqProcessIndex
  5.2-2 PqProcessIndices
  5.2-3 IsPqProcessAlive
 5.3 Interactive Versions of Non-interactive ANUPQ Functions

  5.3-1 Pq
  5.3-2 PqEpimorphism
  5.3-3 PqPCover
  5.3-4 PqStandardPresentation
  5.3-5 EpimorphismPqStandardPresentation
  5.3-6 PqDescendants
  5.3-7 PqSetPQuotientToGroup
 5.4 Low-level Interactive ANUPQ functions based on menu items of the pq program
 5.5 General commands

  5.5-1 PqNrPcGenerators
  5.5-2 PqFactoredOrder
  5.5-3 PqOrder
  5.5-4 PqPClass
  5.5-5 PqWeight
  5.5-6 PqCurrentGroup
  5.5-7 PqDisplayPcPresentation
  5.5-8 PqSetOutputLevel
  5.5-9 PqEvaluateIdentities
 5.6 Commands from the Main \(p\)-Quotient menu

  5.6-1 PqPcPresentation
  5.6-2 PqSavePcPresentation
  5.6-3 PqRestorePcPresentation
  5.6-4 PqNextClass
  5.6-5 PqComputePCover
 5.7 Commands from the Advanced \(p\)-Quotient menu

  5.7-1 PqCollect
  5.7-2 PqSolveEquation
  5.7-3 PqCommutator
  5.7-4 PqSetupTablesForNextClass
  5.7-5 PqTails
  5.7-6 PqComputeTails
  5.7-7 PqAddTails
  5.7-8 PqDoConsistencyChecks
  5.7-9 PqCollectDefiningRelations
  5.7-10 PqCollectWordInDefiningGenerators
  5.7-11 PqCommutatorDefiningGenerators
  5.7-12 PqDoExponentChecks
  5.7-13 PqEliminateRedundantGenerators
  5.7-14 PqRevertToPreviousClass
  5.7-15 PqSetMaximalOccurrences
  5.7-16 PqSetMetabelian
  5.7-17 PqDoConsistencyCheck
  5.7-18 PqCompact
  5.7-19 PqEchelonise
  5.7-20 PqSupplyAutomorphisms
  5.7-21 PqExtendAutomorphisms
  5.7-22 PqApplyAutomorphisms
  5.7-23 PqDisplayStructure
  5.7-24 PqDisplayAutomorphisms
  5.7-25 PqWritePcPresentation
 5.8 Commands from the Standard Presentation menu

  5.8-1 PqSPComputePcpAndPCover
  5.8-2 PqSPStandardPresentation
  5.8-3 PqSPSavePresentation
  5.8-4 PqSPCompareTwoFilePresentations
  5.8-5 PqSPIsomorphism
 5.9 Commands from the Main \(p\)-Group Generation menu

  5.9-1 PqPGSupplyAutomorphisms
  5.9-2 PqPGExtendAutomorphisms
  5.9-3 PqPGConstructDescendants
  5.9-4 PqPGSetDescendantToPcp
 5.10 Commands from the Advanced \(p\)-Group Generation menu

  5.10-1 PqAPGDegree
  5.10-2 PqAPGPermutations
  5.10-3 PqAPGOrbits
  5.10-4 PqAPGOrbitRepresentatives
  5.10-5 PqAPGSingleStage
 5.11 Primitive Interactive ANUPQ Process Read/Write Functions

  5.11-1 PqRead
  5.11-2 PqReadAll
  5.11-3 PqReadUntil
  5.11-4 PqWrite

5 Interactive ANUPQ functions

Here we describe the interactive functions defined by the ANUPQ package, i.e. the functions that manipulate and initiate interactive ANUPQ processes. These are functions that extract information via a dialogue with a running pq process (process used in the UNIX sense). Occasionally, a user needs the next step; the functions provided in this chapter make use of data from previous steps retained by the pq program, thus allowing the user to interact with the pq program like one can when one uses the pq program as a stand-alone (see guide.dvi in the standalone-doc directory).

An interactive ANUPQ process is initiated by PqStart and terminated via PqQuit; these functions are described in ection Starting and Stopping Interactive ANUPQ Processes.

Each interactive ANUPQ function that manipulates an already started interactive ANUPQ process, has a form where the first argument is the integer i returned by the initiating PqStart command, and a second form with one argument fewer (where the integer i is discovered by a default mechanism, namely by determining the least integer i for which there is a currently active interactive ANUPQ process). We will thus commonly say that for the ith (or default) interactive ANUPQ process a certain function performs a given action. In each case, it is an error if i is not the index of an active interactive process, or there are no current active interactive processes.

Notes: The global method of passing options (via PushOptions), should not be used with any of the interactive functions. In fact, the OptionsStack should be empty at the time any of the interactive functions is called.

On quitting GAP, PqQuitAll(); is executed, which terminates all active interactive ANUPQ processes. If GAP is killed without quitting, before all interactive ANUPQ processes are terminated, zombie processes (still living child processes whose parents have died), may result. Since zombie processes do consume resources, in such an event, the responsible computer user should seek out and terminate those zombie processes (e.g. on Linux: ps xw | grep pq gives you information on the pq processes corresponding to any interactive ANUPQ processes started in a GAP session; you can then do kill N for each number N appearing in the first column of this output).

5.1 Starting and Stopping Interactive ANUPQ Processes

5.1-1 PqStart
‣ PqStart( G, workspace: options )( function )
‣ PqStart( G: options )( function )
‣ PqStart( workspace: options )( function )
‣ PqStart( : options )( function )

activate an iostream for an interactive ANUPQ process (i.e. PqStart starts up a pq process and opens a GAP iostream to talk to that process) and returns an integer i that can be used to identify that process. The argument G should be an fp group or pc group that the user intends to manipulate using interactive ANUPQ functions. If the function is called without specifying G, a group can be read in by using the function PqRestorePcPresentation (see PqRestorePcPresentation (5.6-3)). If PqStart is given an integer argument workspace, then the pq program is started up with a workspace (an integer array) of size workspace (i.e. \(4 \times \textit{workspace}\) bytes in a 32-bit environment); otherwise, the pq program sets a default workspace of \(10000000\).

The only options currently recognised by PqStart are Prime, Exponent and Relators (see Chapter ANUPQ Options for detailed descriptions of these options) and if provided they are essentially global for the interactive ANUPQ process, except that any interactive function interacting with the process and passing new values for these options will over-ride the global values.

5.1-2 PqQuit
‣ PqQuit( i )( function )
‣ PqQuit( )( function )

closes the stream of the ith or default interactive ANUPQ process and unbinds its ANUPQData.io record.

Note: It can happen that the pq process, and hence the GAP iostream assigned to communicate with it, can die, e.g. by the user typing a Ctrl-C while the pq process is engaged in a long calculation. IsPqProcessAlive (see IsPqProcessAlive (5.2-3)) is provided to check the status of the GAP iostream (and hence the status of the pq process it was communicating with).

5.1-3 PqQuitAll
‣ PqQuitAll( )( function )

is provided as a convenience, to terminate all active interactive ANUPQ processes with a single command. It is equivalent to executing PqQuit(i) for all active interactive ANUPQ processes i (see PqQuit (5.1-2)).

5.2 Interactive ANUPQ Process Utility Functions

5.2-1 PqProcessIndex
‣ PqProcessIndex( i )( function )
‣ PqProcessIndex( )( function )

With argument i, which must be a positive integer, PqProcessIndex returns i if it corresponds to an active interactive process, or raises an error. With no arguments it returns the default active interactive process or returns fail and emits a warning message to Info at InfoANUPQ or InfoWarning level 1.

Note: Essentially, an interactive ANUPQ process i is active if ANUPQData.io[i] is bound (i.e. we still have some data telling us about it). Also see PqStart (5.1-1).

5.2-2 PqProcessIndices
‣ PqProcessIndices( )( function )

returns the list of integer indices of all active interactive ANUPQ processes (see PqProcessIndex (5.2-1) for the meaning of active).

5.2-3 IsPqProcessAlive
‣ IsPqProcessAlive( i )( function )
‣ IsPqProcessAlive( )( function )

return true if the GAP iostream of the ith (or default) interactive ANUPQ process started by PqStart is alive (i.e. can still be written to), or false, otherwise. (See the notes for PqStart (5.1-1) and PqQuit (5.1-2).)

If the user does not yet have a gap> prompt then usually the pq program is still away doing something and an ANUPQ interface function is still waiting for a reply. Typing a Ctrl-C (i.e. holding down the Ctrl key and typing c) will stop the waiting and send GAP into a break-loop, from which one has no option but to quit;. The typing of Ctrl-C, in such a circumstance, usually causes the stream of the interactive ANUPQ process to die; to check this we provide IsPqProcessAlive (see IsPqProcessAlive).

The GAP iostream of an interactive ANUPQ process will also die if the pq program has a segmentation fault. We do hope that this never happens to you, but if it does and the failure is reproducible, then it's a bug and we'd like to know about it. Please read the README that comes with the ANUPQ package to find out what to include in a bug report and who to email it to.

5.3 Interactive Versions of Non-interactive ANUPQ Functions

5.3-1 Pq
‣ Pq( i: options )( function )
‣ Pq( : options )( function )

return, for the fp or pc group (let us call it F), of the ith or default interactive ANUPQ process, the \(p\)-quotient of F specified by options, as a pc group; F must previously have been given (as first argument) to PqStart to start the interactive ANUPQ process (see PqStart (5.1-1)) or restored from file using the function PqRestorePcPresentation (see PqRestorePcPresentation (5.6-3)). Following the colon options is a selection of the options listed for the non-interactive Pq function (see Pq (4.1-1)), separated by commas like record components (see Section Reference: Function Call With Options in the GAP Reference Manual), except that the options SetupFile or PqWorkspace are ignored by the interactive Pq, and RedoPcp is an option only recognised by the interactive Pq i.e. the following options are recognised by the interactive Pq function:

  • Prime := p

  • ClassBound := n

  • Exponent := n

  • Relators := rels

  • Metabelian

  • Identities := funcs

  • GroupName := name

  • OutputLevel := n

  • RedoPcp

Detailed descriptions of the above options may be found in Chapter ANUPQ Options.

As a minimum the Pq function must have a value for the Prime option, though Prime need not be passed again in the case it has previously been provided, e.g. to PqStart (see PqStart (5.1-1)) when starting the interactive process.

The behaviour of the interactive Pq function depends on the current state of the pc presentation stored by the pq program:

  1. If no pc presentation has yet been computed (the case immediately after the PqStart call initiating the process) then the quotient group of the input group of the process of largest lower exponent-p class bounded by the value of the ClassBound option (see 6.2) is returned.

  2. If the current pc presentation of the process was determined by a previous call to Pq or PqEpimorphism, and the current call has a larger value ClassBound then the class is extended as much as is possible and the quotient group of the input group of the process of the new lower exponent-p class is returned.

  3. If the current pc presentation of the process was determined by a previous call to PqPCover then a consistent pc presentation of a quotient for the current class is determined before proceeding as in 2.

  4. If the RedoPcp option is supplied the current pc presentation is scrapped, all options must be re-supplied (in particular, Prime must be supplied) and then the Pq function proceeds as in 1.

See Section Attributes and a Property for fp and pc p-groups for the attributes and property NuclearRank, MultiplicatorRank and IsCapable which may be applied to the group returned by Pq.

The following is one of the examples for the non-interactive Pq redone with the interactive version. Also, we set the option OutputLevel to 1 (see 6.2), in order to see the orders of the quotients of all the classes determined, and we set the InfoANUPQ level to 2 (see InfoANUPQ (3.3-1)), so that we catch the timing information.

gap> F := FreeGroup("a", "b");; a := F.1;; b := F.2;;
gap> G := F / [a^4, b^4];
<fp group on the generators [ a, b ]>
gap> PqStart(G);
1
gap> SetInfoLevel(InfoANUPQ, 2); #To see timing information
gap> Pq(: Prime := 2, ClassBound := 3, OutputLevel := 1 );
#I  Lower exponent-2 central series for [grp]
#I  Group: [grp] to lower exponent-2 central class 1 has order 2^2
#I  Group: [grp] to lower exponent-2 central class 2 has order 2^5
#I  Group: [grp] to lower exponent-2 central class 3 has order 2^8
#I  Computation of presentation took 0.00 seconds
<pc group of size 256 with 8 generators>

5.3-2 PqEpimorphism
‣ PqEpimorphism( i: options )( function )
‣ PqEpimorphism( : options )( function )

return, for the fp or pc group (let us call it F), of the ith or default interactive ANUPQ process, an epimorphism from F onto the \(p\)-quotient of F specified by options; F must previously have been given (as first argument) to PqStart to start the interactive ANUPQ process (see PqStart (5.1-1)). Since the underlying interactions with the pq program effected by the interactive PqEpimorphism are identical to those effected by the interactive Pq, everything said regarding the requirements and behaviour of the interactive Pq function (see Pq (5.3-1)) is also the case for the interactive PqEpimorphism.

Note: See Section Attributes and a Property for fp and pc p-groups for the attributes and property NuclearRank, MultiplicatorRank and IsCapable which may be applied to the image group of the epimorphism returned by PqEpimorphism.

5.3-3 PqPCover
‣ PqPCover( i: options )( function )
‣ PqPCover( : options )( function )

return, for the fp or pc group of the ith or default interactive ANUPQ process, the \(p\)-covering group of the \(p\)-quotient Pq(i : options) or Pq(: options), modulo the following:

  1. If no pc presentation has yet been computed (the case immediately after the PqStart call initiating the process) and the group F of the process is already a \(p\)-group, in the sense that HasIsPGroup(F) and IsPGroup(F) is true, then

    Prime

    defaults to PrimePGroup(F), if not supplied and HasPrimePGroup(F) = true; and

    ClassBound

    defaults to PClassPGroup(F) if HasPClassPGroup(F) = true if not supplied, or to the usual default of 63, otherwise.

  2. If a pc presentation has been computed and none of options is RedoPcp or if no pc presentation has yet been computed but 1. does not apply then PqPCover(i : options); is equivalent to:

    Pq(i : options);
PqPCover(i);

  3. If the RedoPcp option is supplied the current pc presentation is scrapped, and PqPCover proceeds as in 1. or 2. but without the RedoPcp option.

5.3-4 PqStandardPresentation
‣ PqStandardPresentation( [i]: options )( function )
‣ StandardPresentation( [i]: options )( function )

return, for the ith or default interactive ANUPQ process, the p-quotient of the group F of the process, specified by options, as an fp group which has a standard presentation. Here options is a selection of the options from the following list (see Chapter ANUPQ Options for detailed descriptions); this list is the same as for the non-interactive version of PqStandardPresentation except for the omission of options SetupFile and PqWorkspace (see PqStandardPresentation (4.2-1)).

  • Prime := p

  • pQuotient := Q

  • ClassBound := n

  • Exponent := n

  • Metabelian

  • GroupName := name

  • OutputLevel := n

  • StandardPresentationFile := filename

Unless F is a pc p-group, or the option Prime has been passed to a previous interactive function for the process to compute a p-quotient for F, the user must supply either the option Prime or the option pQuotient (if both Prime and pQuotient are supplied, the prime p is determined by applying PrimePGroup (see PrimePGroup (Reference: PrimePGroup) in the Reference Manual) to the value of pQuotient).

Taking one of the examples for the non-interactive version of StandardPresentation (see StandardPresentation (4.2-1)) that required two separate calls to the pq program, we now show how it can be done by setting up a dialogue with just the one pq process, using the interactive version of StandardPresentation:

gap> F4 := FreeGroup( "a", "b", "c", "d" );;
gap> a := F4.1;; b := F4.2;; c := F4.3;; d := F4.4;;
gap> G4 := F4 / [ b^4, b^2 / Comm(Comm (b, a), a), d^16,
>                 a^16 / (c * d), b^8 / (d * c^4) ];
<fp group on the generators [ a, b, c, d ]>
gap> SetInfoLevel(InfoANUPQ, 1); #Only essential Info please
gap> procId := PqStart(G4);; #Start a new interactive process for a new group
gap> K := Pq( procId : Prime := 2, ClassBound := 1 );
<pc group of size 4 with 2 generators>
gap> StandardPresentation( procId : pQuotient := K, ClassBound := 14 );
<fp group with 53 generators>

Notes

In contrast to the function Pq (see Pq (4.1-1)) which returns a pc group, PqStandardPresentation or StandardPresentation returns an fp group. This is because the output is mainly used for isomorphism testing for which an fp group is enough. However, the presentation is a polycyclic presentation and if you need to do any further computation with this group (e.g. to find the order) you can use the function PcGroupFpGroup (see PcGroupFpGroup (Reference: PcGroupFpGroup) in the GAP Reference Manual) to form a pc group.

If the user does not supply a p-quotient Q via the pQuotient option, and the prime p is either supplied, stored, or F is a pc p-group, then a p-quotient Q is computed. (The value of the prime p is stored if passed initially to PqStart or to a subsequent interactive process.) Note that a stored value for pQuotient (from a prior call to Pq) does not have precedence over a value for the prime p. If the user does supply a p-quotient Q via the pQuotient option, the package AutPGrp is called to compute the automorphism group of Q; an error will occur that asks the user to install the package AutPGrp if the automorphism group cannot be computed.

If any of the interactive functions PqStandardPresentation, StandardPresentation, EpimorphismPqStandardPresentation or EpimorphismStandardPresentation has been called previously for an interactive process, a subsequent call to any of these functions for the same process returns the previously computed value. Note that all these functions compute both an epimorphism and an fp group and store the results in the SPepi and SP fields of the data record associated with the process. See the example for the interactive EpimorphismStandardPresentation (EpimorphismStandardPresentation (5.3-5)).

The attributes and property NuclearRank, MultiplicatorRank and IsCapable are set for the group returned by PqStandardPresentation or StandardPresentation (see Section Attributes and a Property for fp and pc p-groups).

5.3-5 EpimorphismPqStandardPresentation
‣ EpimorphismPqStandardPresentation( [i]: options )( function )
‣ EpimorphismStandardPresentation( [i]: options )( method )

Each of the above functions accepts the same arguments and options as the interactive form of StandardPresentation (see StandardPresentation (5.3-4)) and returns an epimorphism from the fp or pc group F of the ith or default interactive ANUPQ process onto the finitely presented group given by a standard presentation, i.e. if S is the standard presentation computed for the \(p\)-quotient of F by StandardPresentation then EpimorphismStandardPresentation returns the epimorphism from F to the group with presentation S. The group F must have been given (as first argument) to PqStart to start the interactive ANUPQ process (see PqStart (5.1-1)).

Taking our earlier non-interactive example (see EpimorphismPqStandardPresentation (4.2-2)) and modifying it a little, we illustrate, as for the interactive StandardPresentation (see StandardPresentation (5.3-4)), how something that required two separate calls to the pq program can now be achieved with a dialogue with just one pq process. Also, observe that calls to one of the standard presentation functions (as mentioned in the notes of StandardPresentation (5.3-4)) computes and stores both an fp group with a standard presentation and an epimorphism; subsequent calls to a standard presentation function for the same process simply return the appropriate stored value.

gap> F := FreeGroup(6, "F");;
gap> x := F.1;; y := F.2;; z := F.3;; w := F.4;; a := F.5;; b := F.6;;
gap> R := [x^3 / w, y^3 / w * a^2 * b^2, w^3 / b,
>          Comm (y, x) / z, Comm (z, x), Comm (z, y) / a, z^3 ];
[ F1^3*F4^-1, F2^3*F4^-1*F5^2*F6^2, F4^3*F6^-1, F2^-1*F1^-1*F2*F1*F3^-1, 
  F3^-1*F1^-1*F3*F1, F3^-1*F2^-1*F3*F2*F5^-1, F3^3 ]
gap> Q := F / R;
<fp group on the generators [ F1, F2, F3, F4, F5, F6 ]>
gap> procId := PqStart( Q );;
gap> G := Pq( procId : Prime := 3, ClassBound := 3 );
<pc group of size 729 with 6 generators>
gap> lev := InfoLevel(InfoANUPQ);; # Save current InfoANUPQ level
gap> SetInfoLevel(InfoANUPQ, 2); # To see computation times
gap> # It is not necessary to pass the `Prime' option to
gap> # `EpimorphismStandardPresentation' since it was previously
gap> # passed to `Pq':
gap> phi := EpimorphismStandardPresentation( 3 : ClassBound := 3 );
#I  Class 1 3-quotient and its 3-covering group computed in 0.00 seconds
#I  Order of GL subgroup is 48
#I  No. of soluble autos is 0
#I    dim U = 1  dim N = 3  dim M = 3
#I    nice stabilizer with perm rep
#I  Computing standard presentation for class 2 took 0.00 seconds
#I  Computing standard presentation for class 3 took 0.01 seconds
[ F1, F2, F3, F4, F5, F6 ] -> [ f1*f2^2*f3*f4^2*f5^2, f1*f2*f3*f5, f3^2, 
  f4*f6^2, f5, f6 ]
gap> # Image of phi should be isomorphic to G ...
gap> # let's check the order is correct:
gap> Size( Image(phi) );
729
gap> # `StandardPresentation' and `EpimorphismStandardPresentation'
gap> # behave like attributes, so no computation is done when
gap> # either is called again for the same process ...
gap> StandardPresentation( 3 : ClassBound := 3 );
<fp group of size 729 on the generators [ f1, f2, f3, f4, f5, f6 ]>
gap> # No timing data was Info-ed since no computation was done
gap> SetInfoLevel(InfoANUPQ, lev); # Restore previous InfoANUPQ level

A very similar (essential details are the same) example to the above may be executed live, by typing: PqExample( "EpimorphismStandardPresentation-i" );.

Note: The notes for PqStandardPresentation or StandardPresentation (see PqStandardPresentation (5.3-4)) apply also to EpimorphismPqStandardPresentation or EpimorphismStandardPresentation except that their return value is an epimorphism onto an fp group, i.e. one should interpret the phrase returns an fp group as returns an epimorphism onto an fp group etc.

5.3-6 PqDescendants
‣ PqDescendants( i: options )( function )
‣ PqDescendants( : options )( function )

return for the pc group G of the ith or default interactive ANUPQ process, which must be of prime power order with a confluent pc presentation (see IsConfluent (Reference: IsConfluent for pc groups) in the GAP Reference Manual), a list of proper descendants (pc groups) of G. The group G is usually given as first argument to PqStart when starting the interactive ANUPQ process (see PqStart (5.1-1)). Alternatively, one may initiate the process with an fp group, use Pq interactively (see Pq (5.3-1)) to create a pc group and use PqSetPQuotientToGroup (see PqSetPQuotientToGroup (5.3-7)), which involves no computation, to set the pc group returned by Pq as the group of the process. Note that repeating a call to PqDescendants for the same interactive ANUPQ process simply returns the list of descendants originally calculated; a warning is emitted at InfoANUPQ level 1 reminding you of this should you do this.

After the colon, options a selection of the options listed for the non-interactive PqDescendants function (see PqDescendants (4.4-1)), should be given, separated by commas like record components (see Section Reference: Function Call With Options in the GAP Reference Manual), except that the options SetupFile or PqWorkspace are ignored by the interactive PqDescendants, i.e. the following options are recognised by the interactive PqDescendants function:

  • ClassBound := n

  • Relators := rels

  • OrderBound := n

  • StepSize := n, StepSize := list

  • RankInitialSegmentSubgroups := n

  • SpaceEfficient

  • CapableDescendants

  • AllDescendants := false

  • Exponent := n

  • Metabelian

  • GroupName := name

  • SubList := sub

  • BasicAlgorithm

  • CustomiseOutput := rec

Notes: The function PqDescendants uses the automorphism group of G which it computes via the package AutPGrp if the automorphism group of G is not already present. If AutPGrp is not installed an error may be raised. If the automorphism group of G is insoluble the pq program will call GAP together with the AutPGrp package for certain orbit-stabilizer calculations.

The attributes and property NuclearRank, MultiplicatorRank and IsCapable are set for each group of the list returned by PqDescendants (see Section Attributes and a Property for fp and pc p-groups).

Let us now repeat the examples previously given for the non-interactive PqDescendants, but this time with the interactive version of PqDescendants:

gap> F := FreeGroup( "a", "b" );; a := F.1;; b := F.2;;
gap> G := PcGroupFpGroup( F / [ a^2, b^2, Comm(b, a) ] );
<pc group of size 4 with 2 generators>
gap> procId := PqStart(G);;
gap> des := PqDescendants( procId : OrderBound := 6, ClassBound := 5 );;
gap> Length(des);
83
gap> List(des, Size);
[ 8, 8, 8, 16, 16, 16, 32, 16, 16, 16, 16, 16, 32, 32, 64, 64, 32, 32, 32, 
  32, 32, 32, 32, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 32, 32, 32, 32, 
  64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 32, 32, 32, 32, 32, 64, 64, 64, 
  64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 
  64, 64, 64, 64, 64, 64, 64 ]
gap> List(des, d -> Length( PCentralSeries( d, 2 ) ) - 1 );
[ 2, 2, 2, 2, 2, 2, 2, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 
  3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 4, 
  4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 
  4, 4, 4, 5, 5, 5, 5, 5 ]

In the second example we compute all capable descendants of order 27 of the elementary abelian group of order 9.

gap> F := FreeGroup( 2, "g" );;
gap> G := PcGroupFpGroup( F / [ F.1^3, F.2^3, Comm(F.1, F.2) ] );
<pc group of size 9 with 2 generators>
gap> procId := PqStart(G);;
gap> des := PqDescendants( procId : OrderBound := 3, ClassBound := 2,
>                              CapableDescendants );
[ <pc group of size 27 with 3 generators>, 
  <pc group of size 27 with 3 generators> ]
gap> List(des, d -> Length( PCentralSeries( d, 3 ) ) - 1 );
[ 2, 2 ]
gap> # For comparison let us now compute all proper descendants
gap> # (using the non-interactive Pq function)
gap> PqDescendants( G : OrderBound := 3, ClassBound := 2);
[ <pc group of size 27 with 3 generators>, 
  <pc group of size 27 with 3 generators>, 
  <pc group of size 27 with 3 generators> ]

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

gap> F := FreeGroup( 2, "g" );;
gap> G := PcGroupFpGroup( F / [ F.1^5, F.2^5, Comm(F.2, F.1) ] );
<pc group of size 25 with 2 generators>
gap> procId := PqStart(G);;
gap> des := PqDescendants( procId : Metabelian, ClassBound := 3,
>                              Exponent := 5, CapableDescendants );
[ <pc group of size 125 with 3 generators>, 
  <pc group of size 625 with 4 generators>, 
  <pc group of size 3125 with 5 generators> ]
gap> List(des, d -> Length( PCentralSeries( d, 5 ) ) - 1 );
[ 2, 3, 3 ]
gap> List(des, d -> Length( DerivedSeries( d ) ) );
[ 3, 3, 3 ]
gap> List(des, d -> Maximum( List( d, Order ) ) );
[ 5, 5, 5 ]

5.3-7 PqSetPQuotientToGroup
‣ PqSetPQuotientToGroup( i )( function )
‣ PqSetPQuotientToGroup( )( function )

for the ith or default interactive ANUPQ process, set the \(p\)-quotient previously computed by the interactive Pq function (see Pq (5.3-1)) to be the group of the process. This function is supplied to enable the computation of descendants of a \(p\)-quotient that is already known to the pq program, via the interactive PqDescendants function (see PqDescendants (5.3-6)), thus avoiding the need to re-submit it and have the pq program recompute it.

Note: See the function PqPGSetDescendantToPcp (PqPGSetDescendantToPcp (5.9-4)) for a mechanism to make (the \(p\)-cover of) a particular descendants the current group of the process.

The following example of the usage of PqSetPQuotientToGroup, which is essentially equivalent to what is obtained by running PqExample("PqDescendants-1-i");, redoes the first example of PqDescendants (5.3-6) (which computes the descendants of the Klein four group).

gap> F := FreeGroup( "a", "b" );
<free group on the generators [ a, b ]>
gap> procId := PqStart( F : Prime := 2 );;
gap> Pq( procId : ClassBound := 1 );
<pc group of size 4 with 2 generators>
gap> PqSetPQuotientToGroup( procId );
gap> des := PqDescendants( procId : OrderBound := 6, ClassBound := 5 );;
gap> Length(des);
83
gap> List(des, Size);
[ 8, 8, 8, 16, 16, 16, 32, 16, 16, 16, 16, 16, 32, 32, 64, 64, 32, 32, 32, 
  32, 32, 32, 32, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 32, 32, 32, 32, 
  64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 32, 32, 32, 32, 32, 64, 64, 64, 
  64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 
  64, 64, 64, 64, 64, 64, 64 ]
gap> List(des, d -> Length( PCentralSeries( d, 2 ) ) - 1 );
[ 2, 2, 2, 2, 2, 2, 2, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 
  3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 4, 
  4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 
  4, 4, 4, 5, 5, 5, 5, 5 ]

5.4 Low-level Interactive ANUPQ functions based on menu items of the pq program

The pq program has 5 menus, the details of which the reader will not normally need to know, but if she wishes to know the details they may be found in the standalone manual: guide.dvi. Both guide.dvi and the pq program refer to the items of these 5 menus as options, which do not correspond in any way to the options used by any of the GAP functions that interface with the pq program.

Warning: The commands provided in this section are intended to provide something like the interactive functionality one has when running the standalone, from within GAP. The pq standalone (in particular, its advanced menus) assumes some expertise of the user; doing the wrong thing can cause the program to crash. While a number of safeguards have been provided in the GAP interface to the pq program, these are not foolproof, and the user should exercise care and ensure pre-requisites of the various commands are met.

5.5 General commands

The following commands either use a menu item from whatever menu is current for the pq program, or have general application and are not associated with just one menu item of the pq program.

5.5-1 PqNrPcGenerators
‣ PqNrPcGenerators( i )( function )
‣ PqNrPcGenerators( )( function )

for the ith or default interactive ANUPQ process, return the number of pc generators of the lower exponent \(p\)-class quotient of the group currently determined by the process. This also applies if the pc presentation is not consistent.

5.5-2 PqFactoredOrder
‣ PqFactoredOrder( i )( function )
‣ PqFactoredOrder( )( function )

for the ith or default interactive ANUPQ process, return an integer pair [p, n] where p is a prime and n is the number of pc generators (see PqNrPcGenerators (5.5-1)) in the pc presentation of the quotient group currently determined by the process. If this presentation is consistent, then \(p^n\) is the order of the quotient group. Otherwise (if tails have been added but the necessary consistency checks, relation collections, exponent law checks and redundant generator eliminations have not yet been done), \(p^n\) is an upper bound for the order of the group.

5.5-3 PqOrder
‣ PqOrder( i )( function )
‣ PqOrder( )( function )

for the ith or default interactive ANUPQ process, return \(p^n\) where [p, n] is the pair as returned by PqFactoredOrder (see PqFactoredOrder (5.5-2)).

5.5-4 PqPClass
‣ PqPClass( i )( function )
‣ PqPClass( )( function )

for the ith or default interactive ANUPQ process, return the lower exponent \(p\)-class of the quotient group currently determined by the process.

5.5-5 PqWeight
‣ PqWeight( i, j )( function )
‣ PqWeight( j )( function )

for the ith or default interactive ANUPQ process, return the weight of the jth pc generator of the lower exponent \(p\)-class quotient of the group currently determined by the process, or fail if there is no such numbered pc generator.

5.5-6 PqCurrentGroup
‣ PqCurrentGroup( i )( function )
‣ PqCurrentGroup( )( function )

for the ith or default interactive ANUPQ process, return the group whose pc presentation is determined by the process as a GAP pc group (either a lower exponent \(p\)-class quotient of the start group or the \(p\)-cover of such a quotient).

Notes: See Section Attributes and a Property for fp and pc p-groups for the attributes and property NuclearRank, MultiplicatorRank and IsCapable which may be applied to the group returned by PqCurrentGroup.

5.5-7 PqDisplayPcPresentation
‣ PqDisplayPcPresentation( i: [OutputLevel := lev] )( function )
‣ PqDisplayPcPresentation( : [OutputLevel := lev] )( function )

for the ith or default interactive ANUPQ process, direct the pq program to display the pc presentation of the lower exponent \(p\)-class quotient of the group currently determined by the process.

Except if the last command communicating with the pq program was a \(p\)-group generation command (for which there is only a verbose output level), to set the amount of information this command displays you may wish to call PqSetOutputLevel first (see PqSetOutputLevel (5.5-8)), or equivalently pass the option OutputLevel (see 6.2).

Note: For those familiar with the pq program, PqDisplayPcPresentation performs menu item 4 of the current menu of the pq program.

5.5-8 PqSetOutputLevel
‣ PqSetOutputLevel( i, lev )( function )
‣ PqSetOutputLevel( lev )( function )

for the ith or default interactive ANUPQ process, direct the pq program to set the output level of the pq program to lev.

Note: For those familiar with the pq program, PqSetOutputLevel performs menu item 5 of the main (or advanced) \(p\)-Quotient menu, or the Standard Presentation menu.

5.5-9 PqEvaluateIdentities
‣ PqEvaluateIdentities( i: [Identities := funcs] )( function )
‣ PqEvaluateIdentities( : [Identities := funcs] )( function )

for the ith or default interactive ANUPQ process, invoke the evaluation of identities defined by the Identities option, and eliminate any redundant pc generators formed. Since a previous value of Identities is saved in the data record of the process, it is unnecessary to pass the Identities if set previously.

Note: This function is mainly implemented at the GAP level. It does not correspond to a menu item of the pq program.

5.6 Commands from the Main \(p\)-Quotient menu

5.6-1 PqPcPresentation
‣ PqPcPresentation( i: options )( function )
‣ PqPcPresentation( : options )( function )

for the ith or default interactive ANUPQ process, direct the pq program to compute the pc presentation of the quotient (determined by options) of the group of the process, which for process i is stored as ANUPQData.io[i].group.

The possible options are the same as for the interactive Pq (see Pq (5.3-1)) function, except for RedoPcp (which, in any case, would be superfluous), namely: Prime, ClassBound, Exponent, Relators, GroupName, Metabelian, Identities and OutputLevel (see Chapter ANUPQ Options for a detailed description for these options). The option Prime is required unless already provided to PqStart.

Notes

The pc presentation is held by the pq program. In contrast to Pq (see Pq (5.3-1)), no GAP pc group is returned; see PqCurrentGroup (PqCurrentGroup (5.5-6)) if you need the corresponding GAP pc group.

PqPcPresentation(i: options); is roughly equivalent to the following sequence of low-level commands:

PqPcPresentation(i: opts); #class 1 call
for c in [2 .. class] do
    PqNextClass(i);
od;

where opts is options except with the ClassBound option set to 1, and class is either the maximum class of a p-quotient of the group of the process or the user-supplied value of the option ClassBound (whichever is smaller). If the Identities option has been set, both the first PqPcPresentation class 1 call and the PqNextClass calls invoke PqEvaluateIdentities(i); as their final step.

For those familiar with the pq program, PqPcPresentation performs menu item 1 of the main \(p\)-Quotient menu.

5.6-2 PqSavePcPresentation
‣ PqSavePcPresentation( i, filename )( function )
‣ PqSavePcPresentation( filename )( function )

for the ith or default interactive ANUPQ process, direct the pq program to save the pc presentation previously computed for the quotient of the group of that process to the file with name filename. If the first character of the string filename is not /, filename is assumed to be the path of a writable file relative to the directory in which GAP was started. A saved file may be restored by PqRestorePcPresentation (see PqRestorePcPresentation (5.6-3)).

Note: For those familiar with the pq program, PqSavePcPresentation performs menu item 2 of the main \(p\)-Quotient menu.

5.6-3 PqRestorePcPresentation
‣ PqRestorePcPresentation( i, filename )( function )
‣ PqRestorePcPresentation( filename )( function )

for the ith or default interactive ANUPQ process, direct the pq program to restore the pc presentation previously saved to filename, by PqSavePcPresentation (see PqSavePcPresentation (5.6-2)). If the first character of the string filename is not /, filename is assumed to be the path of a readable file relative to the directory in which GAP was started.

Note: For those familiar with the pq program, PqRestorePcPresentation performs menu item 3 of the main \(p\)-Quotient menu.

5.6-4 PqNextClass
‣ PqNextClass( i: [QueueFactor] )( function )
‣ PqNextClass( : [QueueFactor] )( function )

for the ith or default interactive ANUPQ process, direct the pq program to calculate the next class of ANUPQData.io[i].group.

PqNextClass accepts the option QueueFactor (see also 6.2) which should be a positive integer if automorphisms have been previously supplied. If the pq program requires a queue factor and none is supplied via the option QueueFactor a default of 15 is taken.

Notes

The single command: PqNextClass(i); is equivalent to executing

PqComputePCover(i);
PqCollectDefiningRelations(i);
PqDoExponentChecks(i);
PqEliminateRedundantGenerators(i);

If the Identities option is set the PqEliminateRedundantGenerators(i); step is essentially replaced by PqEvaluateIdentities(i); (which invokes its own elimination of redundant generators).

For those familiar with the pq program, PqNextClass performs menu item 6 of the main \(p\)-Quotient menu.

5.6-5 PqComputePCover
‣ PqComputePCover( i )( function )
‣ PqComputePCover( )( function )

for the ith or default interactive ANUPQ processi, directi, the pq program to compute the \(p\)-covering group of ANUPQData.io[i].group. In contrast to the function PqPCover (see PqPCover (4.1-3)), this function does not return a GAP pc group.

Notes

The single command: PqComputePCover(i); is equivalent to executing

PqSetupTablesForNextClass(i);
PqTails(i, 0);
PqDoConsistencyChecks(i, 0, 0);
PqEliminateRedundantGenerators(i);

For those familiar with the pq program, PqComputePCover performs menu item 7 of the main \(p\)-Quotient menu.

5.7 Commands from the Advanced \(p\)-Quotient menu

5.7-1 PqCollect
‣ PqCollect( i, word )( function )
‣ PqCollect( word )( function )

for the ith or default interactive ANUPQ process, instruct the pq program to do a collection on word, a word in the current pc generators (the form of word required is described below). PqCollect returns the resulting word of the collection as a list of generator number, exponent pairs (the same form as the second allowed input form of word; see below).

The argument word may be input in either of the following ways:

  1. word may be a string, where the ith pc generator is represented by xi, e.g. "x3*x2^2*x1". This way is quite versatile as parentheses and left-normed commutators -- using square brackets, in the same way as PqGAPRelators (see PqGAPRelators (3.4-2)) -- are permitted; word is checked for correct syntax via PqParseWord (see PqParseWord (3.4-3)).

  2. Otherwise, word must be a list of generator number, exponent pairs of integers, i.e.  each pair represents a syllable so that [ [3, 1], [2, 2], [1, 1] ] represents the same word as that of the example given for the first allowed form of word.

Note: For those familiar with the pq program, PqCollect performs menu item 1 of the Advanced \(p\)-Quotient menu.

5.7-2 PqSolveEquation
‣ PqSolveEquation( i, a, b )( function )
‣ PqSolveEquation( a, b )( function )

for the ith or default interactive ANUPQ process, direct the pq program to solve \(\textit{a} * \textit{x} = \textit{b}\) for x, where a and b are words in the pc generators. For the representation of these words see the description of the function PqCollect (PqCollect (5.7-1)).

Note: For those familiar with the pq program, PqSolveEquation performs menu item 2 of the Advanced \(p\)-Quotient menu.

5.7-3 PqCommutator
‣ PqCommutator( i, words, pow )( function )
‣ PqCommutator( words, pow )( function )

for the ith or default interactive ANUPQ process, instruct the pq program to compute the left normed commutator of the list words of words in the current pc generators raised to the integer power pow, and return the resulting word as a list of generator number, exponent pairs. The form required for each word of words is the same as that required for the word argument of PqCollect (see PqCollect (5.7-1)). The form of the output word is also the same as for PqCollect.

Note: For those familiar with the pq program, PqCommutator performs menu item 3 of the Advanced \(p\)-Quotient menu.

5.7-4 PqSetupTablesForNextClass
‣ PqSetupTablesForNextClass( i )( function )
‣ PqSetupTablesForNextClass( )( function )

for the ith or default interactive ANUPQ process, direct the pq program to set up tables for the next class. As as side-effect, after PqSetupTablesForNextClass(i) the value returned by PqPClass(i) will be one more than it was previously.

Note: For those familiar with the pq program, PqSetupTablesForNextClass performs menu item 6 of the Advanced \(p\)-Quotient menu.

5.7-5 PqTails
‣ PqTails( i, weight )( function )
‣ PqTails( weight )( function )

for the ith or default interactive ANUPQ process, direct the pq program to compute and add tails of weight weight if weight is in the integer range [2 .. PqPClass(i)] (assuming i is the number of the process, even in the default case) or for all weights if weight = 0.

If weight is non-zero, then tails that introduce new generators for only weight weight are computed and added, and in this case and if weight < PqPClass(i), it is assumed that the tails that introduce new generators for each weight from PqPClass(i) down to weight weight + 1 have already been added. You may wish to call PqSetMetabelian (see PqSetMetabelian (5.7-16)) prior to calling PqTails.

Notes

For its use in the context of finding the next class see PqNextClass (5.6-4); in particular, a call to PqSetupTablesForNextClass (see PqSetupTablesForNextClass (5.7-4)) needs to have been made prior to calling PqTails.

The single command: PqTails(i, weight); is equivalent to

PqComputeTails(i, weight);
PqAddTails(i, weight);

For those familiar with the pq program, PqTails uses menu item 7 of the Advanced \(p\)-Quotient menu.

5.7-6 PqComputeTails
‣ PqComputeTails( i, weight )( function )
‣ PqComputeTails( weight )( function )

for the ith or default interactive ANUPQ process, direct the pq program to compute tails of weight weight if weight is in the integer range [2 .. PqPClass(i)] (assuming i is the number of the process, even in the default case) or for all weights if weight = 0. See PqTails (PqTails (5.7-5)) for more details.

Note: For those familiar with the pq program, PqComputeTails uses menu item 7 of the Advanced \(p\)-Quotient menu.

5.7-7 PqAddTails
‣ PqAddTails( i, weight )( function )
‣ PqAddTails( weight )( function )

for the ith or default interactive ANUPQ process, direct the pq program to add the tails of weight weight, previously computed by PqComputeTails (see PqComputeTails (5.7-6)), if weight is in the integer range [2 .. PqPClass(i)] (assuming i is the number of the process, even in the default case) or for all weights if weight = 0. See PqTails (PqTails (5.7-5)) for more details.

Note: For those familiar with the pq program, PqAddTails uses menu item 7 of the Advanced \(p\)-Quotient menu.

5.7-8 PqDoConsistencyChecks
‣ PqDoConsistencyChecks( i, weight, type )( function )
‣ PqDoConsistencyChecks( weight, type )( function )

for the ith or default interactive ANUPQ process, do consistency checks for weight weight if weight is in the integer range [3 .. PqPClass(i)] (assuming i is the number of the process) or for all weights if weight = 0, and for type type if type is in the range [1, 2, 3] (see below) or for all types if type = 0. (For its use in the context of finding the next class see PqNextClass (5.6-4).)

The type of a consistency check is defined as follows. PqDoConsistencyChecks(i, weight, type) for weight in [3 .. PqPClass(i)] and the given value of type invokes the equivalent of the following PqDoConsistencyCheck calls (see PqDoConsistencyCheck (5.7-17)):

type = 1:

PqDoConsistencyCheck(i, a, a, a) checks 2 * PqWeight(i, a) + 1 = weight, for pc generators of index a.

type = 2:

PqDoConsistencyCheck(i, b, b, a) checks for pc generators of indices b, a satisfyingx both b > a and PqWeight(i, b) + PqWeight(i, a) + 1 = weight.

type = 3:

PqDoConsistencyCheck(i, c, b, a) checks for pc generators of indices c, b, a satisfying c > b > a and the sum of the weights of these generators equals weight.

Notes

PqWeight(i, j) returns the weight of the jth pc generator, for process i (see PqWeight (5.5-5)).

It is assumed that tails for the given weight (or weights) have already been added (see PqTails (5.7-5)).

For those familiar with the pq program, PqDoConsistencyChecks performs menu item 8 of the Advanced \(p\)-Quotient menu.

5.7-9 PqCollectDefiningRelations
‣ PqCollectDefiningRelations( i )( function )
‣ PqCollectDefiningRelations( )( function )

for the ith or default interactive ANUPQ process, direct the pq program to collect the images of the defining relations of the original fp group of the process, with respect to the current pc presentation, in the context of finding the next class (see PqNextClass (5.6-4)). If the tails operation is not complete then the relations may be evaluated incorrectly.

Note: For those familiar with the pq program, PqCollectDefiningRelations performs menu item 9 of the Advanced \(p\)-Quotient menu.

5.7-10 PqCollectWordInDefiningGenerators
‣ PqCollectWordInDefiningGenerators( i, word )( function )
‣ PqCollectWordInDefiningGenerators( word )( function )

for the ith or default interactive ANUPQ process, take a user-defined word word in the defining generators of the original presentation of the fp or pc group of the process. Each generator is mapped into the current pc presentation, and the resulting word is collected with respect to the current pc presentation. The result of the collection is returned as a list of generator number, exponent pairs.

The word argument may be input in either of the two ways described for PqCollect (see PqCollect (5.7-1)).

Note: For those familiar with the pq program, PqCollectDefiningGenerators performs menu item 23 of the Advanced \(p\)-Quotient menu.

5.7-11 PqCommutatorDefiningGenerators
‣ PqCommutatorDefiningGenerators( i, words, pow )( function )
‣ PqCommutatorDefiningGenerators( words, pow )( function )

for the ith or default interactive ANUPQ process, take a list words of user-defined words in the defining generators of the original presentation of the fp or pc group of the process, and an integer power pow. Each generator is mapped into the current pc presentation. The list words is interpreted as a left-normed commutator which is then raised to pow and collected with respect to the current pc presentation. The result of the collection is returned as a list of generator number, exponent pairs.

Note For those familiar with the pq program, PqCommutatorDefiningGenerators performs menu item 24 of the Advanced \(p\)-Quotient menu.

5.7-12 PqDoExponentChecks
‣ PqDoExponentChecks( i: [Bounds := list] )( function )
‣ PqDoExponentChecks( : [Bounds := list] )( function )

for the ith or default interactive ANUPQ process, direct the pq program to do exponent checks for weights (inclusively) between the bounds of Bounds or for all weights if Bounds is not given. The value list of Bounds (assuming the interactive process is numbered i) should be a list of two integers low, high satisfying \(1 \le \textit{low} \le \textit{high} \le \) PqPClass(i) (see PqPClass (5.5-4)). If no exponent law has been specified, no exponent checks are performed.

Note: For those familiar with the pq program, PqDoExponentChecks performs menu item 10 of the Advanced \(p\)-Quotient menu.

5.7-13 PqEliminateRedundantGenerators
‣ PqEliminateRedundantGenerators( i )( function )
‣ PqEliminateRedundantGenerators( )( function )

for the ith or default interactive ANUPQ process, direct the pq program to eliminate redundant generators of the current \(p\)-quotient.

Note: For those familiar with the pq program, PqEliminateRedundantGenerators performs menu item 11 of the Advanced \(p\)-Quotient menu.

5.7-14 PqRevertToPreviousClass
‣ PqRevertToPreviousClass( i )( function )
‣ PqRevertToPreviousClass( )( function )

for the ith or default interactive ANUPQ process, direct the pq program to abandon the current class and revert to the previous class.

Note: For those familiar with the pq program, PqRevertToPreviousClass performs menu item 12 of the Advanced \(p\)-Quotient menu.

5.7-15 PqSetMaximalOccurrences
‣ PqSetMaximalOccurrences( i, noccur )( function )
‣ PqSetMaximalOccurrences( noccur )( function )

for the ith or default interactive ANUPQ process, direct the pq program to set maximal occurrences of the weight 1 generators in the definitions of pcp generators of the group of the process. This can be used to avoid the definition of generators of which one knows for theoretical reasons that they would be eliminated later on.

The argument noccur must be a list of non-negative integers of length the number of weight 1 generators (i.e. the rank of the class 1 \(p\)-quotient of the group of the process). An entry of 0 for a particular generator indicates that there is no limit on the number of occurrences for the generator.

Note: For those familiar with the pq program, PqSetMaximalOccurrences performs menu item 13 of the Advanced \(p\)-Quotient menu.

5.7-16 PqSetMetabelian
‣ PqSetMetabelian( i )( function )
‣ PqSetMetabelian( )( function )

for the ith or default interactive ANUPQ process, direct the pq program to enforce metabelian-ness.

Note: For those familiar with the pq program, PqSetMetabelian performs menu item 14 of the Advanced \(p\)-Quotient menu.

5.7-17 PqDoConsistencyCheck
‣ PqDoConsistencyCheck( i, c, b, a )( function )
‣ PqDoConsistencyCheck( c, b, a )( function )
‣ PqJacobi( i, c, b, a )( function )
‣ PqJacobi( c, b, a )( function )

for the ith or default interactive ANUPQ process, direct the pq program to do the consistency check for the pc generators with indices c, b, a which should be non-increasing positive integers, i.e. \(\textit{c} \ge \textit{b} \ge \textit{a}\).

There are 3 types of consistency checks:

\[ \begin{array}{rclrl} (a^n)a &=& a(a^n) && {\rm (Type\ 1)} \\ (b^n)a &=& b^{(n-1)}(ba), b(a^n) = (ba)a^{(n-1)} && {\rm (Type\ 2)} \\ c(ba) &=& (cb)a && {\rm (Type\ 3)} \\ \end{array} \]

The reason some people talk about Jacobi relations instead of consistency checks becomes clear when one looks at the consistency check of type 3:

\[ \begin{array}{rcl} c(ba) &=& a c[c,a] b[b,a] = acb [c,a][c,a,b][b,a] = \dots \\ (cb)a &=& b c[c,b] a = a b[b,a] c[c,a] [c,b][c,b,a] \\ &=& abc [b,a] [b,a,c] [c,a] [c,b] [c,b,a] = \dots \\ \end{array} \]

Each collection would normally carry on further. But one can see already that no other commutators of weight 3 will occur. After all terms of weight one and weight two have been moved to the left we end up with:

\[ \begin{array}{rcl} & &abc [b,a] [c,a] [c,b] [c,a,b] \dots \\ &=&abc [b,a] [c,a] [c,b] [c,b,a] [b,a,c] \dots \\ \end{array} \]

Modulo terms of weight 4 this is equivalent to

\[ [c,a,b] [b,c,a] [a,b,c] = 1 \]

which is the Jacobi identity.

See also PqDoConsistencyChecks (PqDoConsistencyChecks (5.7-8)).

Note: For those familiar with the pq program, PqDoConsistencyCheck and PqJacobi perform menu item 15 of the Advanced \(p\)-Quotient menu.

5.7-18 PqCompact
‣ PqCompact( i )( function )
‣ PqCompact( )( function )

for the ith or default interactive ANUPQ process, direct the pq program to do a compaction of its work space. This function is safe to perform only at certain points in time.

Note: For those familiar with the pq program, PqCompact performs menu item 16 of the Advanced \(p\)-Quotient menu.

5.7-19 PqEchelonise
‣ PqEchelonise( i )( function )
‣ PqEchelonise( )( function )

for the ith or default interactive ANUPQ process, direct the pq program to echelonise the word most recently collected by PqCollect or PqCommutator against the relations of the current pc presentation, and return the number of the generator made redundant or fail if no generator was made redundant. A call to PqCollect (see PqCollect (5.7-1)) or PqCommutator (see PqCommutator (5.7-3)) needs to be performed prior to using this command.

Note: For those familiar with the pq program, PqEchelonise performs menu item 17 of the Advanced \(p\)-Quotient menu.

5.7-20 PqSupplyAutomorphisms
‣ PqSupplyAutomorphisms( i, mlist )( function )
‣ PqSupplyAutomorphisms( mlist )( function )

for the ith or default interactive ANUPQ process, supply the automorphism data provided by the list mlist of matrices with non-negative integer coefficients. Each matrix in mlist describes one automorphism in the following way.

  • The rows of each matrix correspond to the pc generators of weight one.

  • Each row is the exponent vector of the image of the corresponding weight one generator under the respective automorphism.

Note: For those familiar with the pq program, PqSupplyAutomorphisms uses menu item 18 of the Advanced \(p\)-Quotient menu.

5.7-21 PqExtendAutomorphisms
‣ PqExtendAutomorphisms( i )( function )
‣ PqExtendAutomorphisms( )( function )

for the ith or default interactive ANUPQ process, direct the pq program to extend automorphisms of the \(p\)-quotient of the previous class to the \(p\)-quotient of the present class.

Note: For those familiar with the pq program, PqExtendAutomorphisms uses menu item 18 of the Advanced \(p\)-Quotient menu.

5.7-22 PqApplyAutomorphisms
‣ PqApplyAutomorphisms( i, qfac )( function )
‣ PqApplyAutomorphisms( qfac )( function )

for the ith or default interactive ANUPQ process, direct the pq program to apply automorphisms; qfac is the queue factor e.g. 15.

Note: For those familiar with the pq program, PqCloseRelations performs menu item 19 of the Advanced \(p\)-Quotient menu.

5.7-23 PqDisplayStructure
‣ PqDisplayStructure( i: [Bounds := list] )( function )
‣ PqDisplayStructure( : [Bounds := list] )( function )

for the ith or default interactive ANUPQ process, direct the pq program to display the structure for the pcp generators numbered (inclusively) between the bounds of Bounds or for all generators if Bounds is not given. The value list of Bounds (assuming the interactive process is numbered i) should be a list of two integers low, high satisfying \(1 \le \textit{low} \le \textit{high} \le \) PqNrPcGenerators(i) (see PqNrPcGenerators (5.5-1)). PqDisplayStructure also accepts the option OutputLevel (see 6.2).

Explanation of output

New generators are defined as commutators of previous generators and generators of class 1 or as \(p\)-th powers of generators that have themselves been defined as \(p\)-th powers. A generator is never defined as \(p\)-th power of a commutator.

Therefore, there are two cases: all the numbers on the righthand side are either the same or they differ. Below, gi refers to the ith defining generator.

  • If the righthand side numbers are all the same, then the generator is a \(p\)-th power (of a \(p\)-th power of a \(p\)-th power, etc.). The number of repeated digits say how often a \(p\)-th power has to be taken.

    In the following example, the generator number 31 is the eleventh power of generator 17 which in turn is an eleventh power and so on:

    \begintt #I 31 is defined on 17^11 = 1 1 1 1 1 \endtt So generator 31 is obtained by taking the eleventh power of generator 1 five times.

  • If the numbers are not all the same, the generator is defined by a commutator. If the first two generator numbers differ, the generator is defined as a left-normed commutator of the weight one generators, e.g.

    \begintt #I 19 is defined on [11, 1] = 2 1 1 1 1 \endtt Here, generator 19 is defined as the commutator of generator 11 and generator 1 which is the same as the left-normed commutator [x2, x1, x1, x1, x1]. One can check this by tracing back the definition of generator 11 until one gets to a generator of class 1.

  • If the first two generator numbers are identical, then the left most component of the left-normed commutator is a \(p\)-th power, e.g.

    \begintt #I 25 is defined on [14, 1] = 1 1 2 1 1 \endtt

    In this example, generator 25 is defined as commutator of generator 14 and generator 1. The left-normed commutator is

    \[ [(x1^{11})^{11}, x2, x1, x1] \]

    Again, this can be verified by tracing back the definitions.

Note: For those familiar with the pq program, PqDisplayStructure performs menu item 20 of the Advanced \(p\)-Quotient menu.

5.7-24 PqDisplayAutomorphisms
‣ PqDisplayAutomorphisms( i: [Bounds := list] )( function )
‣ PqDisplayAutomorphisms( : [Bounds := list] )( function )

for the ith or default interactive ANUPQ process, direct the pq program to display the automorphism actions on the pcp generators numbered (inclusively) between the bounds of Bounds or for all generators if Bounds is not given. The value list of Bounds (assuming the interactive process is numbered i) should be a list of two integers low, high satisfying \(1 \le \textit{low} \le \textit{high} \le \) PqNrPcGenerators(i) (see PqNrPcGenerators (5.5-1)). PqDisplayStructure also accepts the option OutputLevel (see 6.2).

Note: For those familiar with the pq program, PqDisplayAutomorphisms performs menu item 21 of the Advanced \(p\)-Quotient menu.

5.7-25 PqWritePcPresentation
‣ PqWritePcPresentation( i, filename )( function )
‣ PqWritePcPresentation( filename )( function )

for the ith or default interactive ANUPQ process, direct the pq program to write a pc presentation of a previously-computed quotient of the group of that process, to the file with name filename. Here the group of a process is the one given as first argument when PqStart was called to initiate that process (for process i the group is stored as ANUPQData.io[i].group). If the first character of the string filename is not /, filename is assumed to be the path of a writable file relative to the directory in which GAP was started. If a pc presentation has not been previously computed by the pq program, then pq is called to compute it first, effectively invoking PqPcPresentation (see PqPcPresentation (5.6-1)).

Note: For those familiar with the pq program, PqPcWritePresentation performs menu item 25 of the Advanced \(p\)-Quotient menu.

5.8 Commands from the Standard Presentation menu

5.8-1 PqSPComputePcpAndPCover
‣ PqSPComputePcpAndPCover( i: options )( function )
‣ PqSPComputePcpAndPCover( : options )( function )

for the ith or default interactive ANUPQ process, directs the pq program to compute for the group of that process a pc presentation up to the \(p\)-quotient of maximum class or the value of the option ClassBound and the \(p\)-cover of that quotient, and sets up tabular information required for computation of a standard presentation. Here the group of a process is the one given as first argument when PqStart was called to initiate that process (for process i the group is stored as ANUPQData.io[i].group).

The possible options are Prime, ClassBound, Relators, Exponent, Metabelian and OutputLevel (see Chapter ANUPQ Options for detailed descriptions of these options). The option Prime is normally determined via PrimePGroup, and so is not required unless the group doesn't know it's a \(p\)-group and HasPrimePGroup returns false.

Note: For those familiar with the pq program, PqSPComputePcpAndPCover performs option 1 of the Standard Presentation menu.

5.8-2 PqSPStandardPresentation
‣ PqSPStandardPresentation( i[, mlist]: [options] )( function )
‣ PqSPStandardPresentation( [mlist]: [options] )( function )

for the ith or default interactive ANUPQ process, inputs data given by options to compute a standard presentation for the group of that process. If argument mlist is given it is assumed to be the automorphism group data required. Otherwise it is assumed that a call to either Pq (see Pq (5.3-1)) or PqEpimorphism (see PqEpimorphism (5.3-2)) has generated a \(p\)-quotient and that GAP can compute its automorphism group from which the necessary automorphism group data can be derived. The group of the process is the one given as first argument when PqStart was called to initiate the process (for process i the group is stored as ANUPQData.io[i].group and the \(p\)-quotient if existent is stored as ANUPQData.io[i].pQuotient). If mlist is not given and a \(p\)-quotient of the group has not been previously computed a class 1 \(p\)-quotient is computed.

PqSPStandardPresentation accepts three options, all optional:

  • ClassBound := n

  • PcgsAutomorphisms

  • StandardPresentationFile := filename

If ClassBound is omitted it defaults to 63.

Detailed descriptions of the above options may be found in Chapter ANUPQ Options.

Note: For those familiar with the pq program, PqSPPcPresentation performs menu item 2 of the Standard Presentation menu.

5.8-3 PqSPSavePresentation
‣ PqSPSavePresentation( i, filename )( function )
‣ PqSPSavePresentation( filename )( function )

for the ith or default interactive ANUPQ process, directs the pq program to save the standard presentation previously computed for the group of that process to the file with name filename, where the group of a process is the one given as first argument when PqStart was called to initiate that process. If the first character of the string filename is not /, filename is assumed to be the path of a writable file relative to the directory in which GAP was started.

Note: For those familiar with the pq program, PqSPSavePresentation performs menu item 3 of the Standard Presentation menu.

5.8-4 PqSPCompareTwoFilePresentations
‣ PqSPCompareTwoFilePresentations( i, f1, f2 )( function )
‣ PqSPCompareTwoFilePresentations( f1, f2 )( function )

for the ith or default interactive ANUPQ process, direct the pq program to compare the presentations in the files with names f1 and f2 and returns true if they are identical and false otherwise. For each of the strings f1 and f2, if the first character is not a / then it is assumed to be the path of a readable file relative to the directory in which GAP was started.

Notes

The presentations in files f1 and f2 must have been generated by the pq program but they do not need to be standard presentations. If If the presentations in files f1 and f2 have been generated by PqSPStandardPresentation (see PqSPStandardPresentation (5.8-2)) then a false response from PqSPCompareTwoFilePresentations says the groups defined by those presentations are not isomorphic.

For those familiar with the pq program, PqSPCompareTwoFilePresentations performs menu item 6 of the Standard Presentation menu.

5.8-5 PqSPIsomorphism
‣ PqSPIsomorphism( i )( function )
‣ PqSPIsomorphism( )( function )

for the ith or default interactive ANUPQ process, direct the pq program to compute the isomorphism mapping from the \(p\)-group of the process to its standard presentation. This function provides a description only; for a GAP object, use EpimorphismStandardPresentation (see EpimorphismStandardPresentation (5.3-5)).

Note: For those familiar with the pq program, PqSPIsomorphism performs menu item 8 of the Standard Presentation menu.

5.9 Commands from the Main \(p\)-Group Generation menu

Note that the \(p\)-group generation commands can only be applied once the pq program has produced a pc presentation of some quotient group of the group of the process.

5.9-1 PqPGSupplyAutomorphisms
‣ PqPGSupplyAutomorphisms( i[, mlist]: options )( function )
‣ PqPGSupplyAutomorphisms( [mlist]: options )( function )

for the ith or default interactive ANUPQ process, supply the pq program with the automorphism group data needed for the current quotient of the group of that process (for process i the group is stored as ANUPQData.io[i].group). For a description of the format of mlist see PqSupplyAutomorphisms (5.7-20). The options possible are NumberOfSolubleAutomorphisms and RelativeOrders. (Detailed descriptions of these options may be found in Chapter ANUPQ Options.)

If mlist is omitted, the automorphism data is determined from the group of the process which must have been a \(p\)-group in pc presentation.

Note: For those familiar with the pq program, PqPGSupplyAutomorphisms performs menu item 1 of the main \(p\)-Group Generation menu.

5.9-2 PqPGExtendAutomorphisms
‣ PqPGExtendAutomorphisms( i )( function )
‣ PqPGExtendAutomorphisms( )( function )

for the ith or default interactive ANUPQ process, direct the pq program to compute the extensions of the automorphisms of the \(p\)-quotient of the previous class to the \(p\)-quotient of the current class. You may wish to set the InfoLevel of InfoANUPQ to 2 (or more) in order to see the output from the pq program (see InfoANUPQ (3.3-1)).

Note: For those familiar with the pq program, PqPGExtendAutomorphisms performs menu item 2 of the main or advanced \(p\)-Group Generation menu.

5.9-3 PqPGConstructDescendants
‣ PqPGConstructDescendants( i: options )( function )
‣ PqPGConstructDescendants( : options )( function )

for the ith or default interactive ANUPQ process, direct the pq program to construct descendants prescribed by options, and return the number of descendants constructed (compare function PqDescendants (4.4-1) which returns the list of descendants). The options possible are ClassBound, OrderBound, StepSize, PcgsAutomorphisms, RankInitialSegmentSubgroups, SpaceEfficient, CapableDescendants, AllDescendants, Exponent, Metabelian, BasicAlgorithm, CustomiseOutput. (Detailed descriptions of these options may be found in Chapter ANUPQ Options.)

PqPGConstructDescendants requires that the pq program has previously computed a pc presentation and a \(p\)-cover for a \(p\)-quotient of some class of the group of the process.

Note: For those familiar with the pq program, PqPGConstructDescendants performs menu item 5 of the main \(p\)-Group Generation menu.

5.9-4 PqPGSetDescendantToPcp
‣ PqPGSetDescendantToPcp( i, cls, n )( function )
‣ PqPGSetDescendantToPcp( cls, n )( function )
‣ PqPGSetDescendantToPcp( i: [Filename := name] )( function )
‣ PqPGSetDescendantToPcp( : [Filename := name] )( function )
‣ PqPGRestoreDescendantFromFile( i, cls, n )( function )
‣ PqPGRestoreDescendantFromFile( cls, n )( function )
‣ PqPGRestoreDescendantFromFile( i: [Filename := name] )( function )
‣ PqPGRestoreDescendantFromFile( : [Filename := name] )( function )

for the ith or default interactive ANUPQ process, direct the pq program to restore group n of class cls from a temporary file, where cls and n are positive integers, or the group stored in name. PqPGSetDescendantToPcp and PqPGRestoreDescendantFromFile are synonyms; they make sense only after a prior call to construct descendants by say PqPGConstructDescendants (see PqPGConstructDescendants (5.9-3)) or the interactive PqDescendants (see PqDescendants (5.3-6)). In the Filename option forms, the option defaults to the last filename in which a presentation was stored by the pq program.

Notes

Since the PqPGSetDescendantToPcp and PqPGRestoreDescendantFromFile are intended to be used in calculation of further descendants the pq program computes the \(p\)-cover of the restored descendant. Hence, PqCurrentGroup used immediately after one of these commands returns the \(p\)-cover of the restored descendant rather than the descendant itself.

For those familiar with the pq program, PqPGSetDescendantToPcp and PqPGRestoreDescendantFromFile perform menu item 3 of the main or advanced \(p\)-Group Generation menu.

5.10 Commands from the Advanced \(p\)-Group Generation menu

The functions below perform the component algorithms of PqPGConstructDescendants (see PqPGConstructDescendants (5.9-3)). You can get some idea of their usage by trying PqExample("Nott-APG-Rel-i");. You can get some idea of the breakdown of PqPGConstructDescendants into these functions by comparing the previous output with PqExample("Nott-PG-Rel-i");.

These functions are intended for use only by experts; please contact the authors of the package if you genuinely have a need for them and need any amplified descriptions.

5.10-1 PqAPGDegree
‣ PqAPGDegree( i, step, rank: [Exponent := n] )( function )
‣ PqAPGDegree( step, rank: [Exponent := n] )( function )

for the ith or default interactive ANUPQ process, direct the pq program to invoke menu item 6 of the Advanced \(p\)-Group Generation menu. Here the step-size step and the rank rank are positive integers and are the arguments required by the pq program. See 6.2 for the one recognised option Exponent.

5.10-2 PqAPGPermutations
‣ PqAPGPermutations( i: options )( function )
‣ PqAPGPermutations( : options )( function )

for the ith or default interactive ANUPQ process, direct the pq program to perform menu item 7 of the Advanced \(p\)-Group Generation menu. Here the options options recognised are PcgsAutomorphisms, SpaceEfficient, PrintAutomorphisms and PrintPermutations (see Chapter ANUPQ Options for details).

5.10-3 PqAPGOrbits
‣ PqAPGOrbits( i: options )( function )
‣ PqAPGOrbits( : options )( function )

for the ith or default interactive ANUPQ process, direct the pq to perform menu item 8 of the Advanced \(p\)-Group Generation menu.

Here the options options recognised are PcgsAutomorphisms, SpaceEfficient and CustomiseOutput (see Chapter ANUPQ Options for details). For the CustomiseOutput option only the setting of the orbit is recognised (all other fields if set are ignored).

5.10-4 PqAPGOrbitRepresentatives
‣ PqAPGOrbitRepresentatives( i: options )( function )
‣ PqAPGOrbitRepresentatives( : options )( function )

for the ith or default interactive ANUPQ process, direct the pq to perform item 9 of the Advanced \(p\)-Group Generation menu.

The options options may be any selection of the following: PcgsAutomorphisms, SpaceEfficient, Exponent, Metabelian, CapableDescendants (or AllDescendants), CustomiseOutput (where only the group and autgroup fields are recognised) and Filename (see Chapter ANUPQ Options for details). If Filename is omitted the reduced \(p\)-cover is written to the file "redPCover" in the temporary directory whose name is stored in ANUPQData.tmpdir.

5.10-5 PqAPGSingleStage
‣ PqAPGSingleStage( i: options )( function )
‣ PqAPGSingleStage( : options )( function )

for the ith or default interactive ANUPQ process, direct the pq to perform option 5 of the Advanced \(p\)-Group Generation menu.

The possible options are StepSize, PcgsAutomorphisms, RankInitialSegmentSubgroups, SpaceEfficient, CapableDescendants, AllDescendants, Exponent, Metabelian, BasicAlgorithm and CustomiseOutput. (Detailed descriptions of these options may be found in Chapter ANUPQ Options.)

5.11 Primitive Interactive ANUPQ Process Read/Write Functions

For those familiar with using the pq program as a standalone we provide primitive read/write tools to communicate directly with an interactive ANUPQ process, started via PqStart. For the most part, it is up to the user to translate the output strings from pq program into a form useful in GAP.

5.11-1 PqRead
‣ PqRead( i )( function )
‣ PqRead( )( function )

read a complete line of ANUPQ output, from the ith or default interactive ANUPQ process, if there is output to be read and returns fail otherwise. When successful, the line is returned as a string complete with trailing newline, colon, or question-mark character. Please note that it is possible to be too quick (i.e. the return can be fail purely because the output from ANUPQ is not there yet), but if PqRead finds any output at all, it waits for a complete line. PqRead also writes the line read via Info at InfoANUPQ level 2. It doesn't try to distinguish banner and menu output from other output of the pq program.

5.11-2 PqReadAll
‣ PqReadAll( i )( function )
‣ PqReadAll( )( function )

read and return as many complete lines of ANUPQ output, from the ith or default interactive ANUPQ process, as there are to be read, at the time of the call, as a list of strings with any trailing newlines removed and returns the empty list otherwise. PqReadAll also writes each line read via Info at InfoANUPQ level 2. It doesn't try to distinguish banner and menu output from other output of the pq program. Whenever PqReadAll finds only a partial line, it waits for the complete line, thus increasing the probability that it has captured all the output to be had from ANUPQ.

5.11-3 PqReadUntil
‣ PqReadUntil( i, IsMyLine )( function )
‣ PqReadUntil( IsMyLine )( function )
‣ PqReadUntil( i, IsMyLine, Modify )( function )
‣ PqReadUntil( IsMyLine, Modify )( function )

read complete lines of ANUPQ output, from the ith or default interactive ANUPQ process, chomps them (i.e. removes any trailing newline character), emits them to Info at InfoANUPQ level 2 (without trying to distinguish banner and menu output from other output of the pq program), and applies the function Modify (where Modify is just the identity map/function for the first two forms) until a chomped line line for which IsMyLine( Modify(line) ) is true. PqReadUntil returns the list of Modify-ed chomped lines read.

Notes: When provided by the user, Modify should be a function that accepts a single string argument.

IsMyLine should be a function that is able to accept the output of Modify (or take a single string argument when Modify is not provided) and should return a boolean.

If IsMyLine( Modify(line) ) is never true, PqReadUntil will wait indefinitely.

5.11-4 PqWrite
‣ PqWrite( i, string )( function )
‣ PqWrite( string )( function )

write string to the ith or default interactive ANUPQ process; string must be in exactly the form the ANUPQ standalone expects. The command is echoed via Info at InfoANUPQ level 3 (with a ToPQ> prompt); i.e. do SetInfoLevel(InfoANUPQ, 3); to see what is transmitted to the pq program. PqWrite returns true if successful in writing to the stream of the interactive ANUPQ process, and fail otherwise.

Note: If PqWrite returns fail it means that the ANUPQ process has died.

 [Top of Book]  [Contents]   [Previous Chapter]   [Next Chapter] 
Goto Chapter: Top 1 2 3 4 5 6 7 A Bib Ind

generated by GAPDoc2HTML

anupq-3.3.3/doc/_entities.xml0000644000175100017510000000027215111342310015514 0ustar runnerrunner AutPGrp'> ANUPQ'> anupq-3.3.3/doc/toggless.css0000644000175100017510000000167215111342310015355 0ustar runnerrunner/* toggless.css Frank Lübeck */ /* Using javascript we change all div.ContSect to div.ContSectOpen or div.ContSectClosed. This way the config for div.ContSect in manual.css is no longer relevant. Here we add the CSS for the new elements. */ /* This layout is based on an idea by Burkhard Höfling. */ div.ContSectClosed { text-align: left; margin-left: 1em; } div.ContSectOpen { text-align: left; margin-left: 1em; } div.ContSectOpen div.ContSSBlock { display: block; text-align: left; margin-left: 1em; } div.ContSectOpen div.ContSSBlock a { display: block; width: 100%; margin-left: 1em; } span.tocline a:hover { display: inline; background: #eeeeee; } span.ContSS a:hover { display: inline; background: #eeeeee; } span.toctoggle { font-size: 80%; display: inline-block; width: 1.2em; } span.toctoggle:hover { background-color: #aaaaaa; } anupq-3.3.3/doc/chap4_mj.html0000644000175100017510000016343315111342310015373 0ustar runnerrunner GAP (ANUPQ) - Chapter 4: Non-interactive ANUPQ functions
Goto Chapter: Top 1 2 3 4 5 6 7 A Bib Ind
 [Top of Book]  [Contents]   [Previous Chapter]   [Next Chapter] 

4 Non-interactive ANUPQ functions
 4.1 Computing p-Quotients

  4.1-1 Pq
  4.1-2 PqEpimorphism
  4.1-3 PqPCover
 4.2 Computing Standard Presentations

  4.2-1 PqStandardPresentation
  4.2-2 EpimorphismPqStandardPresentation
 4.3 Testing p-Groups for Isomorphism

  4.3-1 IsPqIsomorphicPGroup
 4.4 Computing Descendants of a p-Group

  4.4-1 PqDescendants
  4.4-2 PqSupplementInnerAutomorphisms
  4.4-3 PqList
  4.4-4 SavePqList

4 Non-interactive ANUPQ functions

Here we describe all the non-interactive functions of the ANUPQ package; i.e. one-shot functions that invoke the pq program in such a way that once GAP has got what it needs, the pq program is allowed to exit. It is expected that most of the time users will only need these functions. The functions interface with three of the four algorithms (see Chapter Introduction) provided by the ANU pq C program, and are mainly grouped according to the algorithm of the pq program they relate to.

In Section Computing p-Quotients, we describe the functions that give access to the \(p\)-quotient algorithm.

Section Computing Standard Presentations describe functions that give access to the standard presentation algorithm.

Section Testing p-Groups for Isomorphism describe functions that implement an isomorphism test for \(p\)-groups using the standard presentation algorithm.

In Section Computing Descendants of a p-Group, we describe functions that give access to the \(p\)-group generation algorithm.

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

gap> LoadPackage("anupq");

(the response of which we have omitted; see Loading the ANUPQ Package).

It is strongly recommended that the user try the examples provided. To save typing there is a PqExample equivalent for each manual example. We also suggest that to start with you may find the examples more instructive if you set the InfoANUPQ level to 2 (see InfoANUPQ (3.3-1)).

4.1 Computing p-Quotients

4.1-1 Pq
‣ Pq( F: options )( function )

returns for the fp or pc group F, the \(p\)-quotient of F specified by options, as a pc group. Following the colon, options is a selection of the options from the following list, separated by commas like record components (see Section Reference: Function Call With Options in the GAP Reference Manual). As a minimum the user must supply a value for the Prime option. Below we list the options recognised by Pq (see Chapter ANUPQ Options for detailed descriptions).

  • Prime := p

  • ClassBound := n

  • Exponent := n

  • Relators := rels

  • Metabelian

  • Identities := funcs

  • GroupName := name

  • OutputLevel := n

  • SetupFile := filename

  • PqWorkspace := workspace

Notes: Pq may also be called with no arguments or one integer argument, in which case it is being used interactively (see Pq (5.3-1)); the same options may be used, except that SetupFile and PqWorkspace are ignored by the interactive Pq function.

See Section Attributes and a Property for fp and pc p-groups for the attributes and property NuclearRank, MultiplicatorRank and IsCapable which may be applied to the group returned by Pq.

See also PqEpimorphism (PqEpimorphism (4.1-2)).

We now give a few examples of the use of Pq. Except for the addition of a few comments and the non-suppression of output (by not using duplicated semicolons) the next 3 examples may be run by typing: PqExample( "Pq" ); (see PqExample (3.4-4)).

gap> LoadPackage("anupq");; # does nothing if ANUPQ is already loaded
gap> # First we get a p-quotient of a free group of rank 2
gap> F := FreeGroup("a", "b");; a := F.1;; b := F.2;;
gap> Pq( F : Prime := 2, ClassBound := 3 ); 
<pc group of size 1024 with 10 generators>
gap> # Now let us get a p-quotient of an fp group
gap> G := F / [a^4, b^4];
<fp group on the generators [ a, b ]>
gap> Pq( G : Prime := 2, ClassBound := 3 ); 
<pc group of size 256 with 8 generators>
gap> # Now let's get a different p-quotient of the same group
gap> Pq( G : Prime := 2, ClassBound := 3, Exponent := 4 ); 
<pc group of size 128 with 7 generators>
gap> # Now we'll get a p-quotient of another fp group
gap> # which we will redo using the `Relators' option
gap> R := [ a^25, Comm(Comm(b, a), a), b^5 ];
[ a^25, a^-1*b^-1*a*b*a^-1*b^-1*a^-1*b*a^2, b^5 ]
gap> H := F / R;
<fp group on the generators [ a, b ]>
gap> Pq( H : Prime := 5, ClassBound := 5, Metabelian );
<pc group of size 78125 with 7 generators>

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

gap> F := FreeGroup("a", "b");;
gap> # `F' was defined for `Relators'. We use the same strings that GAP uses
gap> # for printing the free group generators. It is *not* necessary to
gap> # predefine: a := F.1; etc. (as it was above).
gap> rels := [ "a^25", "[b, a, a]", "b^5" ];
[ "a^25", "[b, a, a]", "b^5" ]
gap> R := PqGAPRelators(F, rels);
[ a^25, a^-1*b^-1*a*b*a^-1*b^-1*a^-1*b*a^2, b^5 ]
gap> H := F / R;
<fp group on the generators [ a, b ]>
gap> Pq( H : Prime := 5, ClassBound := 5, Metabelian, 
>            Relators := rels );
<pc group of size 78125 with 7 generators>

In fact, above we could have just passed F (rather than H), i.e. we could have done:

gap> F := FreeGroup("a", "b");;
gap> rels := [ "a^25", "[b, a, a]", "b^5" ];
[ "a^25", "[b, a, a]", "b^5" ]
gap> Pq( F : Prime := 5, ClassBound := 5, Metabelian, 
>            Relators := rels );
<pc group of size 78125 with 7 generators>

The non-interactive Pq function also allows the options to be passed in two other ways; these alternatives have been included for those familiar with the GAP 3 version of the ANUPQ package; the preferred method of passing options is the one already described. Firstly, they may be passed in a record as a second argument; note that any boolean options must be set explicitly e.g.

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

It is also possible to pass them as extra arguments, where each option name appears as a string followed immediately by its value (if not a boolean option) e.g.

gap> Pq( H, "Prime", 5, "ClassBound", 5, "Metabelian" );
<pc group of size 78125 with 7 generators>

The preceding two examples can be run from GAP via PqExample( "Pq-ni" ); (see PqExample (3.4-4)).

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

The following example illustrates the use of the option Identities. We compute the largest finite Burnside group of exponent \(5\) that also satisfies the \(3\)-Engel identity. Each identity is defined by a function whose arguments correspond to the variables of the identity. The return value of each of those functions is the identity evaluated on the arguments of the function.

gap> F := FreeGroup(2);
<free group on the generators [ f1, f2 ]>
gap> Burnside5 := x->x^5;
function( x ) ... end
gap> Engel3 := function( x,y ) return PqLeftNormComm( [x,y,y,y] ); end;
function( x, y ) ... end
gap> Pq( F : Prime := 5, Identities := [ Burnside5, Engel3 ] );
#I  Class 1 with 2 generators.
#I  Class 2 with 3 generators.
#I  Class 3 with 5 generators.
#I  Class 3 with 5 generators.
<pc group of size 3125 with 5 generators>

The above example can be run from GAP via PqExample( "B5-5-Engel3-Id" ); (see PqExample (3.4-4)).

4.1-2 PqEpimorphism
‣ PqEpimorphism( F: options )( function )

returns for the fp or pc group F an epimorphism from F onto the \(p\)-quotient of F specified by options; the possible options options and required option ("Prime") are as for Pq (see Pq (4.1-1)). PqEpimorphism only differs from Pq in what it outputs; everything about what must/may be passed as input to PqEpimorphism is the same as for Pq. The same alternative methods of passing options to the non-interactive Pq function are available to the non-interactive version of PqEpimorphism.

Notes: PqEpimorphism may also be called with no arguments or one integer argument, in which case it is being used interactively (see PqEpimorphism (5.3-2)), and the options SetupFile and PqWorkspace are ignored by the interactive PqEpimorphism function.

See Section Attributes and a Property for fp and pc p-groups for the attributes and property NuclearRank, MultiplicatorRank and IsCapable which may be applied to the image group of the epimorphism returned by PqEpimorphism.

gap> F := FreeGroup (2, "F");
<free group on the generators [ F1, F2 ]>
gap> phi := PqEpimorphism( F : Prime := 5, ClassBound := 2 );
[ F1, F2 ] -> [ f1, f2 ]
gap> Image( phi );
<pc group of size 3125 with 5 generators>

Typing: PqExample( "PqEpimorphism" ); runs the above example in GAP (see PqExample (3.4-4)).

4.1-3 PqPCover
‣ PqPCover( F: options )( function )

returns for the fp or pc group F, the \(p\)-covering group of the \(p\)-quotient of F specified by options, as a pc group, i.e. the \(p\)-covering group of the \(p\)-quotient Pq( F : options ). Thus the options that PqPCover accepts are exactly those expected for Pq (and hence as a minimum the user must supply a value for the Prime option; see Pq (4.1-1) for more details), except in the following special case.

If F is already a \(p\)-group, in the sense that IsPGroup(F) is true, then

Prime

defaults to PrimePGroup(F), if not supplied and HasPrimePGroup(F) = true; and

ClassBound

defaults to PClassPGroup(F) if HasPClassPGroup(F) = true if not supplied, or to the usual default of 63, otherwise.

The same alternative methods of passing options to the non-interactive Pq function are available to the non-interactive version of PqPCover.

We now give a few examples of the use of PqPCover. These examples are just a subset of the ones we gave for Pq (see Pq (4.1-1)), except that in each instance the command Pq has been replaced with PqPCover. Essentially the same examples may be run by typing: PqExample( "PqPCover" ); (see PqExample (3.4-4)).

gap> F := FreeGroup("a", "b");; a := F.1;; b := F.2;;
gap> PqPCover( F : Prime := 2, ClassBound := 3 );
<pc group of size 262144 with 18 generators>
gap> 
gap> # Now let's get a p-cover of a p-quotient of an fp group
gap> G := F / [a^4, b^4];
<fp group on the generators [ a, b ]>
gap> PqPCover( G : Prime := 2, ClassBound := 3 );
<pc group of size 16384 with 14 generators>
gap> 
gap> # Now let's get a p-cover of a different p-quotient of the same group
gap> PqPCover( G : Prime := 2, ClassBound := 3, Exponent := 4 );
<pc group of size 8192 with 13 generators>
gap> 
gap> # Now we'll get a p-cover of a p-quotient of another fp group
gap> # which we will redo using the `Relators' option
gap> R := [ a^25, Comm(Comm(b, a), a), b^5 ];
[ a^25, a^-1*b^-1*a*b*a^-1*b^-1*a^-1*b*a^2, b^5 ]
gap> H := F / R;
<fp group on the generators [ a, b ]>
gap> PqPCover( H : Prime := 5, ClassBound := 5, Metabelian );
<pc group of size 48828125 with 11 generators>
gap> 
gap> # Now we redo the previous example using the `Relators' option
gap> F := FreeGroup("a", "b");;
gap> rels := [ "a^25", "[b, a, a]", "b^5" ];
[ "a^25", "[b, a, a]", "b^5" ]
gap> PqPCover( F : Prime := 5, ClassBound := 5, Metabelian, 
>                  Relators := rels );
<pc group of size 48828125 with 11 generators>

4.2 Computing Standard Presentations

4.2-1 PqStandardPresentation
‣ PqStandardPresentation( F: options )( function )
‣ StandardPresentation( F: options )( method )

return the p-quotient specified by options of the fp or pc \(p\)-group F, as an fp group which has a standard presentation. Here options is a selection of the options from the following list (see Chapter ANUPQ Options for detailed descriptions). Section Hints and Warnings regarding the use of Options gives some important hints and warnings regarding option usage, and Section Reference: Function Call With Options in the GAP Reference Manual describes their record-like syntax.

  • Prime := p

  • pQuotient := Q

  • ClassBound := n

  • Exponent := n

  • Metabelian

  • GroupName := name

  • OutputLevel := n

  • StandardPresentationFile := filename

  • SetupFile := filename

  • PqWorkspace := workspace

Unless F is a pc p-group, the user must supply either the option Prime or the option pQuotient (if both Prime and pQuotient are supplied, the prime p is determined by applying PrimePGroup (see PrimePGroup (Reference: PrimePGroup) in the Reference Manual) to the value of pQuotient).

The options for PqStandardPresentation may also be passed in the two other alternative ways described for Pq (see Pq (4.1-1)). StandardPresentation does not provide these alternative ways of passing options.

Notes: In contrast to the function Pq (see Pq (4.1-1)) which returns a pc group, PqStandardPresentation or StandardPresentation returns an fp group. This is because the output is mainly used for isomorphism testing for which an fp group is enough. However, the presentation is a polycyclic presentation and if you need to do any further computation with this group (e.g. to find the order) you can use the function PcGroupFpGroup (see PcGroupFpGroup (Reference: PcGroupFpGroup) in the GAP Reference Manual) to form a pc group.

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

The attributes and property NuclearRank, MultiplicatorRank and IsCapable are set for the group returned by PqStandardPresentation or StandardPresentation (see Section Attributes and a Property for fp and pc p-groups).

We illustrate the method with the following examples.

gap> F := FreeGroup( "a", "b" );; a := F.1;; b := F.2;;
gap> G := F / [a^25, Comm(Comm(b, a), a), b^5];
<fp group on the generators [ a, b ]>
gap> S := StandardPresentation( G : Prime := 5, ClassBound := 10 );
<fp group on the generators [ f1, f2, f3, f4, f5, f6, f7, f8, f9, f10, f11, 
  f12, f13, f14, f15, f16, f17, f18, f19, f20, f21, f22, f23, f24, f25, f26 ]>
gap> IsPcGroup( S );
false
gap> # if we need to compute with S we should convert it to a pc group
gap> Spc := PcGroupFpGroup( S );
<pc group of size 1490116119384765625 with 26 generators>
gap> 
gap> H := F / [ a^625, Comm(Comm(Comm(Comm(b, a), a), a), a)/Comm(b, a)^5,
>               Comm(Comm(b, a), b), b^625 ];;
gap> StandardPresentation( H : Prime := 5, ClassBound := 15, Metabelian );
<fp group on the generators [ f1, f2, f3, f4, f5, f6, f7, f8, f9, f10, f11, 
  f12, f13, f14, f15, f16, f17, f18, f19, f20 ]>
gap> 
gap> F4 := FreeGroup( "a", "b", "c", "d" );;
gap> a := F4.1;; b := F4.2;; c := F4.3;; d := F4.4;;
gap> G4 := F4 / [ b^4, b^2 / Comm(Comm (b, a), a), d^16,
>                 a^16 / (c * d), b^8 / (d * c^4) ];
<fp group on the generators [ a, b, c, d ]>
gap> K := Pq( G4 : Prime := 2, ClassBound := 1 );
<pc group of size 4 with 2 generators>
gap> StandardPresentation( G4 : pQuotient := K, ClassBound := 14 );
<fp group with 53 generators>

Typing: PqExample( "StandardPresentation" ); runs the above example in GAP (see PqExample (3.4-4)).

4.2-2 EpimorphismPqStandardPresentation
‣ EpimorphismPqStandardPresentation( F: options )( function )
‣ EpimorphismStandardPresentation( F: options )( method )

Each of the above functions accepts the same arguments and options as the function StandardPresentation (see StandardPresentation (4.2-1)) and returns an epimorphism from the fp or pc group F onto the finitely presented group given by a standard presentation, i.e. if S is the standard presentation computed for the \(p\)-quotient of F by StandardPresentation then EpimorphismStandardPresentation returns the epimorphism from F to the group with presentation S.

Note: The attributes and property NuclearRank, MultiplicatorRank and IsCapable are set for the image group of the epimorphism returned by EpimorphismPqStandardPresentation or EpimorphismStandardPresentation (see Section Attributes and a Property for fp and pc p-groups).

We illustrate the function with the following example.

gap> F := FreeGroup(6, "F");
<free group on the generators [ F1, F2, F3, F4, F5, F6 ]>
gap> # For printing GAP uses the symbols F1, ... for the generators of F
gap> x := F.1;; y := F.2;; z := F.3;; w := F.4;; a := F.5;; b := F.6;;
gap> R := [x^3 / w, y^3 / w * a^2 * b^2, w^3 / b,
>          Comm (y, x) / z, Comm (z, x), Comm (z, y) / a, z^3 ];;
gap> Q := F / R;
<fp group on the generators [ F1, F2, F3, F4, F5, F6 ]>
gap> # For printing GAP also uses the symbols F1, ... for the generators of Q
gap> # (the same as used for F) ... but the gen'rs of Q and F are different:
gap> GeneratorsOfGroup(F) = GeneratorsOfGroup(Q);
false
gap> G := Pq( Q : Prime := 3, ClassBound := 3 );
<pc group of size 729 with 6 generators>
gap> phi := EpimorphismStandardPresentation( Q : Prime := 3,
>                                                ClassBound := 3 );
[ F1, F2, F3, F4, F5, F6 ] -> [ f1*f2^2*f3*f4^2*f5^2, f1*f2*f3*f5, f3^2, 
  f4*f6^2, f5, f6 ]
gap> Source(phi); # This is the group Q (GAP uses F1, ... for gen'r symbols)
<fp group of size infinity on the generators [ F1, F2, F3, F4, F5, F6 ]>
gap> Range(phi);  # This is the group G (GAP uses f1, ... for gen'r symbols)
<fp group on the generators [ f1, f2, f3, f4, f5, f6 ]>
gap> AssignGeneratorVariables(G);
#I  Assigned the global variables [ f1, f2, f3, f4, f5, f6 ]
gap> # Just to see that the images of [F1, ..., F6] do generate G
gap> Group([ f1*f2^2*f3, f1*f2*f3*f4*f5^2*f6^2, f3^2, f4, f5, f6 ]) = G;
true
gap> Size( Image(phi) );
729

Typing: PqExample( "EpimorphismStandardPresentation" ); runs the above example in GAP (see PqExample (3.4-4)). Note that AssignGeneratorVariables (see AssignGeneratorVariables (Reference: AssignGeneratorVariables)) has only been available since GAP 4.3.

4.3 Testing p-Groups for Isomorphism

4.3-1 IsPqIsomorphicPGroup
‣ IsPqIsomorphicPGroup( G, H )( function )
‣ IsIsomorphicPGroup( G, H )( method )

each return true if G is isomorphic to H, where both G and H must be pc groups of prime power order. These functions compute and compare in GAP the fp groups given by standard presentations for G and H (see StandardPresentation (4.2-1)).

gap> G := Group( (1,2,3,4), (1,3) );
Group([ (1,2,3,4), (1,3) ])
gap> P1 := Image( IsomorphismPcGroup( G ) );
Group([ f1, f2, f3 ])
gap> P2 := ElementaryAbelianGroup( 8 );
<pc group of size 8 with 3 generators>
gap> IsIsomorphicPGroup( P1, P2 );
false
gap> P3 := QuaternionGroup( 8 );
<pc group of size 8 with 3 generators>
gap> IsIsomorphicPGroup( P1, P3 );
false
gap> P4 := DihedralGroup( 8 );
<pc group of size 8 with 3 generators>
gap> IsIsomorphicPGroup( P1, P4 );
true

Typing: PqExample( "IsIsomorphicPGroup" ); runs the above example in GAP (see PqExample (3.4-4)).

4.4 Computing Descendants of a p-Group

4.4-1 PqDescendants
‣ PqDescendants( G: options )( function )

returns, for the pc group G which must be of prime power order with a confluent pc presentation (see IsConfluent (Reference: IsConfluent for pc groups) in the GAP Reference Manual), a list of proper descendants (pc groups) of G. Following the colon options a selection of the options listed below should be given, separated by commas like record components (see Section Reference: Function Call With Options in the GAP Reference Manual). See Chapter ANUPQ Options for detailed descriptions of the options.

The automorphism group of each descendant D is also computed via a call to the AutomorphismGroupPGroup function of the AutPGrp package.

  • ClassBound := n

  • Relators := rels

  • OrderBound := n

  • StepSize := n, StepSize := list

  • RankInitialSegmentSubgroups := n

  • SpaceEfficient

  • CapableDescendants

  • AllDescendants := false

  • Exponent := n

  • Metabelian

  • GroupName := name

  • SubList := sub

  • BasicAlgorithm

  • CustomiseOutput := rec

  • SetupFile := filename

  • PqWorkspace := workspace

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

The attributes and property NuclearRank, MultiplicatorRank and IsCapable are set for each group of the list returned by PqDescendants (see Section Attributes and a Property for fp and pc p-groups).

The options options for PqDescendants may be passed in an alternative manner to that already described, namely you can pass PqDescendants a record as an argument, which contains as entries some (or all) of the above mentioned. Those parameters which do not occur in the record are set to their default values.

Note that you cannot set both OrderBound and StepSize.

In the first example we compute all proper descendants of the Klein four group which have exponent-2 class at most 5 and order at most \(2^6\).

gap> F := FreeGroup( "a", "b" );; a := F.1;; b := F.2;;
gap> G := PcGroupFpGroup( F / [ a^2, b^2, Comm(b, a) ] );
<pc group of size 4 with 2 generators>
gap> des := PqDescendants( G : OrderBound := 6, ClassBound := 5 );;
gap> Length(des);
83
gap> List(des, Size); 
[ 8, 8, 8, 16, 16, 16, 32, 16, 16, 16, 16, 16, 32, 32, 64, 64, 32, 32, 32, 
  32, 32, 32, 32, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 32, 32, 32, 32, 
  64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 32, 32, 32, 32, 32, 64, 64, 64, 
  64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 
  64, 64, 64, 64, 64, 64, 64 ]
gap> List(des, d -> Length( PCentralSeries( d, 2 ) ) - 1 );
[ 2, 2, 2, 2, 2, 2, 2, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 
  3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 4, 
  4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 
  4, 4, 4, 5, 5, 5, 5, 5 ]

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

gap> F := FreeGroup( 2, "g" );
<free group on the generators [ g1, g2 ]>
gap> G := PcGroupFpGroup( F / [ F.1^3, F.2^3, Comm(F.1, F.2) ] );
<pc group of size 9 with 2 generators>
gap> des := PqDescendants( G : OrderBound := 3, ClassBound := 2,
>                              CapableDescendants );
[ <pc group of size 27 with 3 generators>, 
  <pc group of size 27 with 3 generators> ]
gap> List(des, d -> Length( PCentralSeries( d, 3 ) ) - 1 );
[ 2, 2 ]
gap> # For comparison let us now compute all proper descendants
gap> PqDescendants( G : OrderBound := 3, ClassBound := 2);
[ <pc group of size 27 with 3 generators>, 
  <pc group of size 27 with 3 generators>, 
  <pc group of size 27 with 3 generators> ]

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

gap> F := FreeGroup( 2, "g" );;
gap> G := PcGroupFpGroup( F / [ F.1^5, F.2^5, Comm(F.2, F.1) ] );
<pc group of size 25 with 2 generators>
gap> des := PqDescendants( G : Metabelian, ClassBound := 3,
>                              Exponent := 5, CapableDescendants );
[ <pc group of size 125 with 3 generators>, 
  <pc group of size 625 with 4 generators>, 
  <pc group of size 3125 with 5 generators> ]
gap> List(des, d -> Length( PCentralSeries( d, 5 ) ) - 1 );
[ 2, 3, 3 ]
gap> List(des, d -> Length( DerivedSeries( d ) ) );
[ 3, 3, 3 ]
gap> List(des, d -> Maximum( List( d, Order ) ) );
[ 5, 5, 5 ]

The examples "PqDescendants-1", "PqDescendants-2" and "PqDescendants-3" (in order) are essentially the same as the above three examples (see PqExample (3.4-4)).

4.4-2 PqSupplementInnerAutomorphisms
‣ PqSupplementInnerAutomorphisms( D )( function )

returns a generating set for a supplement to the inner automorphisms of D, in the form of a record with fields agAutos, agOrder and glAutos, as provided by the pq program. One should be very careful in using these automorphisms for a descendant calculation.

Note: In principle there must be a way to use those automorphisms in order to compute descendants but there does not seem to be a way to hand back these automorphisms properly to the pq program.

gap> Q := Pq( FreeGroup(2) : Prime := 3, ClassBound := 1 );
<pc group of size 9 with 2 generators>
gap> des := PqDescendants( Q : StepSize := 1 );
[ <pc group of size 27 with 3 generators>, 
  <pc group of size 27 with 3 generators>, 
  <pc group of size 27 with 3 generators> ]
gap> S := PqSupplementInnerAutomorphisms( des[3] );
rec( agAutos := [  ], agOrder := [ 3, 2, 2, 2 ], 
  glAutos := [ Pcgs([ f1, f2, f3 ]) -> [ f1*f2^2, f2, f3 ], 
      Pcgs([ f1, f2, f3 ]) -> [ f1^2, f2, f3^2 ], 
      Pcgs([ f1, f2, f3 ]) -> [ f1^2, f2, f3^2 ] ] )
gap> A := AutomorphismGroupPGroup( des[3] );
rec( 
  agAutos := [ Pcgs([ f1, f2, f3 ]) -> [ f1^2, f2, f3^2 ], 
      Pcgs([ f1, f2, f3 ]) -> [ f1*f2^2, f2, f3 ], 
      Pcgs([ f1, f2, f3 ]) -> [ f1*f3, f2, f3 ], 
      Pcgs([ f1, f2, f3 ]) -> [ f1, f2*f3, f3 ] ], agOrder := [ 2, 3, 3, 3 ], 
  glAutos := [  ], glOper := [  ], glOrder := 1, 
  group := <pc group of size 27 with 3 generators>, 
  one := IdentityMapping( <pc group of size 27 with 3 generators> ), 
  size := 54 )

Typing: PqExample( "PqSupplementInnerAutomorphisms" ); runs the above example in GAP (see PqExample (3.4-4)).

Note that by also including PqStart as a second argument to PqExample one can see how it is possible, with the aid of PqSetPQuotientToGroup (see PqSetPQuotientToGroup (5.3-7)), to do the equivalent computations with the interactive versions of Pq and PqDescendants and a single pq process (recall pq is the name of the external C program).

4.4-3 PqList
‣ PqList( filename: [SubList := sub] )( function )

reads a file with name filename (a string) and returns the list L of pc groups (or with option SubList a sublist of L or a single pc group in L) defined in that file. If the option SubList is passed and has the value sub, then it has the same meaning as for PqDescendants, i.e. if sub is an integer then PqList returns L[sub]; otherwise, if sub is a list of integers PqList returns Sublist(L, sub ).

Both PqList and SavePqList (see SavePqList (4.4-4)) can be used to save and restore a list of descendants (see PqDescendants (4.4-1)).

4.4-4 SavePqList
‣ SavePqList( filename, list )( function )

writes a list of descendants list to a file with name filename (a string).

SavePqList and PqList (see PqList (4.4-3)) can be used to save and restore, respectively, the results of PqDescendants (see PqDescendants (4.4-1)).

 [Top of Book]  [Contents]   [Previous Chapter]   [Next Chapter] 
Goto Chapter: Top 1 2 3 4 5 6 7 A Bib Ind

generated by GAPDoc2HTML

anupq-3.3.3/doc/chapInd.txt0000644000175100017510000002210115111342310015111 0ustar runnerrunner Index AllANUPQoptions 6.1-1 allowable subgroup 2.1-4 AllPqExamples 3.4-5 ANUPQ 1.1 ANUPQ_GAP_EXEC, environment variable 7.0 7.1 7.2 ANUPQData 3.2-1 ANUPQDirectoryTemporary 3.2-2 ANUPQoptions 6.1-2 ANUPQWarnOfOtherOptions 3.6-1 automorphisms, of p-groups 4.2 5.3-3 B(5,4) A.3 banner 3.1 bug reports 1.3 capable 2.1-4 class 2.1-2 collection 2.1-1 compaction 2.3 confluent 2.1-1 confluent rewriting system 2.1-1 consistency conditions 2.1-1 consistent 2.1-1 definition, of generator 2.2-1 descendant 2.1-4 echelonised matrix 2.3 Engel identity 2.1-5 EpimorphismPqStandardPresentation 4.2-2 interactive 5.3-5 EpimorphismStandardPresentation 4.2-2 interactive 5.3-5 exponent check 2.2-3 exponent law 2.1-5 exponent-p central series 2.1-2 extended automorphism 2.1-4 GrepPqExamples 3.4-6 identical relation 2.1-5 immediate descendant 2.1-4 InfoANUPQ 3.3-1 interruption 5.2-3 IsCapable 3.5-1 IsIsomorphicPGroup 4.3-1 isomorphism testing 2.3 IsPqIsomorphicPGroup 4.3-1 IsPqProcessAlive 5.2-3 for default process 5.2-3 label of standard matrix 2.3 labelled pcp 2.2-1 law 2.1-5 menu item, of pq program 3.6 metabelian law 2.1-5 multiplicator rank 2.1-3 MultiplicatorRank 3.5-1 NuclearRank 3.5-1 nucleus 2.1-4 2.1-4 option, of pq program is a menu item 3.6 option AllDescendants 4.4-1 5.3-6 6.2 option BasicAlgorithm 4.4-1 5.3-6 6.2 option Bounds 6.2 option CapableDescendants 4.4-1 5.3-6 6.2 option ClassBound 4.1-1 4.2-1 4.4-1 5.3-1 5.3-4 5.3-6 5.8-2 6.2 option CustomiseOutput 4.4-1 5.3-6 6.2 option Exponent 4.1-1 4.2-1 4.4-1 5.3-1 5.3-4 5.3-6 6.2 option Filename 6.2 option GroupName 4.1-1 4.2-1 4.4-1 5.3-1 5.3-4 5.3-6 6.2 option Identities 4.1-1 5.3-1 6.2 example of usage 4.1-1 option Metabelian 4.1-1 4.2-1 4.4-1 5.3-1 5.3-4 5.3-6 6.2 option NumberOfSolubleAutomorphisms 6.2 option OrderBound 4.4-1 5.3-6 6.2 option OutputLevel 4.1-1 4.2-1 5.3-1 5.3-4 6.2 option PcgsAutomorphisms 5.8-2 6.2 option pQuotient 4.2-1 5.3-4 6.2 option PqWorkspace 4.1-1 4.2-1 4.4-1 6.2 option Prime 4.1-1 4.2-1 5.3-1 5.3-4 6.2 option PrintAutomorphisms 6.2 option PrintPermutations 6.2 option QueueFactor 5.6-4 6.2 option RankInitialSegmentSubgroups 4.4-1 5.3-6 6.2 option RedoPcp 5.3-1 6.2 option RelativeOrders 6.2 option Relators 4.1-1 4.4-1 5.3-1 5.3-6 6.2 example of usage 4.1-1 option SetupFile 4.1-1 4.2-1 4.4-1 6.2 option SpaceEfficient 4.4-1 5.3-6 6.2 option StandardPresentationFile 4.2-1 5.3-4 5.8-2 6.2 option StepSize 4.4-1 5.3-6 6.2 option SubList 4.4-1 5.3-6 6.2 option TreeDepth 6.2 orbits 2.3 p-class 2.1-2 p-cover 2.1-3 p-covering group 2.1-3 p-group generation 2.3 p-multiplicator 2.1-3 p-multiplicator rank 2.1-3 pc generators 2.1-1 pc presentation 2.1-1 pcp 2.1-1 permutations 2.1-4 power-commutator presentation 2.1-1 Pq 4.1-1 interactive 5.3-1 interactive, for default process 5.3-1 PqAddTails 5.7-7 for default process 5.7-7 PqAPGDegree 5.10-1 for default process 5.10-1 PqAPGOrbitRepresentatives 5.10-4 for default process 5.10-4 PqAPGOrbits 5.10-3 for default process 5.10-3 PqAPGPermutations 5.10-2 for default process 5.10-2 PqAPGSingleStage 5.10-5 for default process 5.10-5 PqApplyAutomorphisms 5.7-22 for default process 5.7-22 PqCollect 5.7-1 for default process 5.7-1 PqCollectDefiningRelations 5.7-9 for default process 5.7-9 PqCollectWordInDefiningGenerators 5.7-10 for default process 5.7-10 PqCommutator 5.7-3 for default process 5.7-3 PqCommutatorDefiningGenerators 5.7-11 for default process 5.7-11 PqCompact 5.7-18 for default process 5.7-18 PqComputePCover 5.6-5 for default process 5.6-5 PqComputeTails 5.7-6 for default process 5.7-6 PqCurrentGroup 5.5-6 for default process 5.5-6 PqDescendants 4.4-1 interactive 5.3-6 interactive, for default process 5.3-6 PqDescendantsTreeCoclassOne A.4-1 for default process A.4-1 PqDisplayAutomorphisms 5.7-24 for default process 5.7-24 PqDisplayPcPresentation 5.5-7 for default process 5.5-7 PqDisplayStructure 5.7-23 for default process 5.7-23 PqDoConsistencyCheck 5.7-17 for default process 5.7-17 PqDoConsistencyChecks 5.7-8 for default process 5.7-8 PqDoExponentChecks 5.7-12 for default process 5.7-12 PqEchelonise 5.7-19 for default process 5.7-19 PqEliminateRedundantGenerators 5.7-13 for default process 5.7-13 PqEpimorphism 4.1-2 interactive 5.3-2 interactive, for default process 5.3-2 PqEvaluateIdentities 5.5-9 for default process 5.5-9 PqExample 3.4-4 no arguments 3.4-4 with filename 3.4-4 PqExtendAutomorphisms 5.7-21 for default process 5.7-21 PqFactoredOrder 5.5-2 for default process 5.5-2 PqGAPRelators 3.4-2 PqJacobi 5.7-17 for default process 5.7-17 PqLeftNormComm 3.4-1 PqList 4.4-3 PqNextClass 5.6-4 for default process 5.6-4 PqNrPcGenerators 5.5-1 for default process 5.5-1 PqOrder 5.5-3 for default process 5.5-3 PqParseWord 3.4-3 PqPClass 5.5-4 for default process 5.5-4 PqPCover 4.1-3 interactive 5.3-3 interactive, for default process 5.3-3 PqPcPresentation 5.6-1 for default process 5.6-1 PqPGConstructDescendants 5.9-3 for default process 5.9-3 PqPGExtendAutomorphisms 5.9-2 for default process 5.9-2 PqPGRestoreDescendantFromFile 5.9-4 for default process 5.9-4 with class 5.9-4 with class, for default process 5.9-4 PqPGSetDescendantToPcp 5.9-4 for default process 5.9-4 with class 5.9-4 with class, for default process 5.9-4 PqPGSupplyAutomorphisms 5.9-1 for default process 5.9-1 PqProcessIndex 5.2-1 for default process 5.2-1 PqProcessIndices 5.2-2 PqQuit 5.1-2 for default process 5.1-2 PqQuitAll 5.1-3 PqRead 5.11-1 for default process 5.11-1 PqReadAll 5.11-2 for default process 5.11-2 PqReadUntil 5.11-3 for default process 5.11-3 with modify map 5.11-3 with modify map, for default process 5.11-3 PqRestorePcPresentation 5.6-3 for default process 5.6-3 PqRevertToPreviousClass 5.7-14 for default process 5.7-14 PqSavePcPresentation 5.6-2 for default process 5.6-2 PqSetMaximalOccurrences 5.7-15 for default process 5.7-15 PqSetMetabelian 5.7-16 for default process 5.7-16 PqSetOutputLevel 5.5-8 for default process 5.5-8 PqSetPQuotientToGroup 5.3-7 for default process 5.3-7 PqSetupTablesForNextClass 5.7-4 for default process 5.7-4 PqSolveEquation 5.7-2 for default process 5.7-2 PqSPCompareTwoFilePresentations 5.8-4 for default process 5.8-4 PqSPComputePcpAndPCover 5.8-1 for default process 5.8-1 PqSPIsomorphism 5.8-5 for default process 5.8-5 PqSPSavePresentation 5.8-3 for default process 5.8-3 PqSPStandardPresentation 5.8-2 for default process 5.8-2 PqStandardPresentation 4.2-1 interactive 5.3-4 PqStart 5.1-1 with group 5.1-1 with group and workspace size 5.1-1 with workspace size 5.1-1 PqSupplementInnerAutomorphisms 4.4-2 PqSupplyAutomorphisms 5.7-20 for default process 5.7-20 PqTails 5.7-5 for default process 5.7-5 PqWeight 5.5-5 for default process 5.5-5 PqWrite 5.11-4 for default process 5.11-4 PqWritePcPresentation 5.7-25 for default process 5.7-25 SavePqList 4.4-4 standard presentation 2.3 StandardPresentation 4.2-1 interactive 5.3-4 tails 2.2-1 terminal 2.1-4 ToPQLog 3.4-7 troubleshooting tips 3.6 weight function 2.1-2 weighted pcp 2.1-2 ------------------------------------------------------- anupq-3.3.3/doc/ANUPQ.xml0000644000175100017510000000107215111342310014414 0ustar runnerrunner ] > <#Include SYSTEM "title.xml"> <#Include SYSTEM "intro.xml"> <#Include SYSTEM "basics.xml"> <#Include SYSTEM "infra.xml"> <#Include SYSTEM "non-interact.xml"> <#Include SYSTEM "interact.xml"> <#Include SYSTEM "options.xml"> <#Include SYSTEM "install.xml"> <#Include SYSTEM "examples.xml"> anupq-3.3.3/read.g0000644000175100017510000000160115111342310013322 0ustar runnerrunner############################################################################# ## #W read.g ANUPQ package Werner Nickel #W Greg Gamble ## ############################################################################# ## #R Read the install files. ## ReadPackage( "anupq", "lib/anupqhead.gi" ); ReadPackage( "anupq", "lib/anupqprop.gi" ); ReadPackage( "anupq", "lib/anupq.gi" ); ReadPackage( "anupq", "lib/anupga.gi" ); ReadPackage( "anupq", "lib/anusp.gi" ); ReadPackage( "anupq", "lib/anupqopt.gi" ); ReadPackage( "anupq", "lib/anupqios.gi" ); ReadPackage( "anupq", "lib/anupqi.gi" ); ReadPackage( "anupq", "lib/anupqid.gi" ); ReadPackage( "anupq", "lib/anustab.gi" ); ReadPackage( "anupq", "lib/anupqxdesc.gi" ); #E read.g . . . . . . . . . . . . . . . . . . . . . . . . . . . . ends here anupq-3.3.3/examples/0000755000175100017510000000000015111342310014057 5ustar runnerrunneranupq-3.3.3/examples/F2-5-i0000644000175100017510000000076015111342310014644 0ustar runnerrunner#Example: "F2-5-i" . . . based on: examples/F2-5 #Construction of 5-quotient of a 2-generator free group #vars: F, procId; #options: OutputLevel F := FreeGroup("a", "b"); procId := PqStart(F : Prime := 5);; #comment: set a different print level by supplying PqPcPresentation(procId : ClassBound := 6, #sub for <1> if set and ok OutputLevel := 1);; PqNextClass(procId);; #class 7 PqNextClass(procId);; #class 8 PqNextClass(procId);; #class 9 anupq-3.3.3/examples/3gp-PG-4-i0000644000175100017510000000161715111342310015373 0ustar runnerrunner#Example: "3gp-PG-4-i" . . . based on: examples/pga_4-3.com #All descendants of C3 x C3 x C3 x C3 #vars: F, procId; #options: OutputLevel F := FreeGroup("a", "b", "c", "d"); procId := PqStart(F : Prime := 3);; #comment: set a different print level by supplying PqPcPresentation(procId : ClassBound := 1, #sub for <1> if set and ok OutputLevel := 1);; PqComputePCover(procId);; PqPGSupplyAutomorphisms(procId, [ [[2,0,0,0], [0,1,0,0], [0,0,1,0], [0,0,0,1]], [[2,0,0,1], [2,0,0,0], [0,2,0,0], [0,0,2,0]] ]);; PqPGConstructDescendants(procId : ClassBound := 2, OrderBound := 5);; anupq-3.3.3/examples/3gp-a-x-Rel-i0000644000175100017510000000245115111342310016126 0ustar runnerrunner#Example: "3gp-a-x-Rel-i" . . . based on: examples/3gpA #(exponent 9 group with 2 generators of order 3, extended) #vars: F, rels, procId; #options: OutputLevel1, OutputLevel2, OutputLevel3, OutputFile F := FreeGroup("a", "b"); rels := ["a^3", "b^3"]; procId := PqStart(F : Prime := 3, Exponent := 9, Relators := rels);; #comment: set a different print level by supplying PqPcPresentation(procId : ClassBound := 4, #sub for <1> if set and ok OutputLevel := 1);; #comment: set a different print level by supplying #sub for <2> if set and ok PqDisplayPcPresentation(procId : OutputLevel := 2);; PqNextClass(procId);; #comment: set a different print level by supplying #sub for <1> if set and ok PqSetOutputLevel(procId, 1);; PqSetupTablesForNextClass(procId);; PqTails(procId, 0);; PqDoConsistencyChecks(procId, 0, 0);; PqCollectDefiningRelations(procId);; PqDoExponentChecks(procId);; PqEliminateRedundantGenerators(procId);; #sub for <2> if set and ok PqDisplayPcPresentation(procId : OutputLevel := 2);; #comment: save the presentation to a different file by supplying #sub for if set and ok PqSavePcPresentation(procId, ANUPQData.outfile);; anupq-3.3.3/examples/2gp-SP-4-Rel-i0000644000175100017510000000230215111342310016116 0ustar runnerrunner#Example: "2gp-SP-4-Rel-i" . . . based on: isom/isom_example.com #vars: F, rels, procId; #options: OutputLevel, ClassBound, StandardPresentationFile F := FreeGroup("a", "b"); rels := ["a^4", "b^2*[b, a, a]^-1", "b * (a^2 * b^-1 * a^2)^-1" ]; procId := PqStart(F : Prime := 2, Relators := rels);; #comment: set a different print level by supplying #add for if set and ok #PqSetOutputLevel(procId, value);; PqSPComputePcpAndPCover(procId : ClassBound := 2);; #comment: set a different `ClassBound' by supplying #comment: also save the presentation to a file by supplying PqSPStandardPresentation(procId, [ [[1,0,0,1], [0,1,0,0]], [[1,0,0,0], [0,1,0,1]], [[1,1,1,0], [0,1,1,1]] ] : # options #add for if set and ok # StandardPresentationFile := value, #sub for <10> if set ClassBound := 10, PcgsAutomorphisms);; anupq-3.3.3/examples/11gp-3-Engel-Id-i0000644000175100017510000000161115111342310016521 0ustar runnerrunner#Example: "11gp-3-Engel-Id-i" . . . 3-Engel grp for prime 11 #Variation of "11gp-3-Engel-Id" broken down into its lower-level component #command parts. #vars: F, a, b, G, f, procId, Q; #options: F := FreeGroup("a", "b"); a := F.1; b := F.2; G := F/[ a^11, b^11 ]; ## All word pairs u, v in the pc generators of the 11-quotient Q of G ## must satisfy the Engel identity: [u, v, v, v] = 1. f := function(u, v) return PqLeftNormComm( [u, v, v, v] ); end; procId := PqStart( G : Prime := 11 );; PqPcPresentation( procId : ClassBound := 1);; PqEvaluateIdentities( procId : Identities := [f] );; for c in [2 .. 4] do PqNextClass( procId : Identities := [] ); #reset `Identities' option PqEvaluateIdentities( procId : Identities := [f] ); od; Q := PqCurrentGroup( procId ); ## We do a ``sample'' check that pairs of elements of Q do satisfy ## the given identity: f( Random(Q), Random(Q) ); f( Q.1, Q.2 ); anupq-3.3.3/examples/B4-4-a-i0000644000175100017510000000201215111342310015047 0ustar runnerrunner#Example: "B4-4-a-i" . . . based on: examples/B4-4A #Construction of B(4,4) #vars: F, procId, class; #options: OutputLevel, OutputFile F := FreeGroup("a", "b", "c", "d"); procId := PqStart(F : Prime := 2, Exponent := 4);; #comment: set a different print level by supplying PqPcPresentation(procId : ClassBound := 6, #sub for <1> if set and ok OutputLevel := 1);; PqSupplyAutomorphisms(procId, [ [[0,0,0,1], [1,0,0,0], [0,1,0,0], [0,0,1,0]], [[1,1,0,0], [0,1,0,0], [0,0,1,0], [0,0,0,1]] ]);; for class in [7 .. 11] do PqNextClass(procId : QueueFactor := 20); od; #comment: save the presentation to a different file by supplying #sub for if set and ok PqSavePcPresentation(procId, ANUPQData.outfile);; anupq-3.3.3/examples/B5-5-Engel3-Id0000644000175100017510000000074715111342310016067 0ustar runnerrunner#Example: "B5-5-Engel3-Id" . . . Burnside group satisfying 2 identities #Generates largest Burnside group of exponent 5 that also satisfies #a 3-Engel identity. Demonstrates the usage of the `Identities' option. #vars: F, Burnside5, Engel3, procId; #options: F := FreeGroup(2); Burnside5 := x->x^5; Engel3 := function( x,y ) return PqLeftNormComm( [x,y,y,y] ); end; #alt: do #procId := PqStart( F ); #alt: sub for Pq( F : Prime := 5, Identities := [ Burnside5, Engel3 ] ); anupq-3.3.3/examples/B2-40000644000175100017510000000041015111342310014401 0ustar runnerrunner#Example: "B2-4" . . . the ``right'' way to generate B(2, 4) #Generates B(2, 4) by using the `Exponent' option #vars: F, procId; #options: F := FreeGroup("a", "b"); #alt: do #procId := PqStart( F ); #alt: sub for Pq( F : Prime := 2, Exponent := 4 ); anupq-3.3.3/examples/5gp-metabelian-Rel0000644000175100017510000000102215111342310017307 0ustar runnerrunner#Example: "5gp-metabelian-Rel" . . . based on: examples/metabelian #Construction of a metabelian 5-quotient #vars: F, procId, rels; #options: OutputLevel F := FreeGroup("a", "b"); rels := [ "a^625", "b^625", "[b, a, b]", "[b, a, a, a, a] * [b, a]^-5" ]; #alt: do #procId := PqStart( F ); #comment: set a different print level by supplying #alt: sub for Pq( F : Prime := 5, ClassBound := 20, Metabelian, Relators := rels, #sub for <1> if set and ok OutputLevel := 1 ); anupq-3.3.3/examples/5gp-metabelian-Rel-i0000644000175100017510000000142215111342310017541 0ustar runnerrunner#Example: "5gp-metabelian-Rel-i" . . . based on: examples/metabelian #Demonstrates usage of `PqSetMetabelian'. #vars: F, rels, procId, class; #options: OutputLevel, OutputFile F := FreeGroup("a", "b"); rels := ["a^625", "b^625", "[b, a, b]", "[b, a, a, a, a] * [b, a]^-5"]; procId := PqStart(F : Prime := 5, Relators := rels);; #comment: set a different print level by supplying PqPcPresentation(procId : ClassBound := 1, #sub for <1> if set and ok OutputLevel := 1);; PqSetMetabelian(procId); for class in [2 .. 14] do PqNextClass(procId); od; #comment: save the presentation to a different file by supplying #sub for if set and ok PqSavePcPresentation(procId, ANUPQData.outfile);; anupq-3.3.3/examples/PqDescendants-20000644000175100017510000000121515111342310016674 0ustar runnerrunner#Example: "PqDescendants-2" . . . based on manual example #(demonstrates `PqDescendants' usage) #We compute all capable descendants of order 27 #of an elementary abelian group of order 9. #vars: F, procId, G, A, des; #options: F := FreeGroup( 2, "g" ); G := PcGroupFpGroup( F / [ F.1^3, F.2^3, Comm(F.1, F.2) ] ); #alt: do #procId := PqStart( G ); #alt: sub for des := PqDescendants( G : OrderBound := 3, ClassBound := 2, CapableDescendants ); List(des, d -> Length( PCentralSeries( d, 3 ) ) - 1 ); ## For comparison let us now compute all proper descendants PqDescendants( G : OrderBound := 3, ClassBound := 2); anupq-3.3.3/examples/G3-SP-Rel-i0000644000175100017510000000244415111342310015545 0ustar runnerrunner#Example: "G3-SP-Rel-i" . . . based on: isom/G_3.com #vars: F, rels, procId; #options: OutputLevel, ClassBound, StandardPresentationFile F := FreeGroup("x", "y"); rels := ["(x * y * x)^3"]; procId := PqStart(F : Prime := 3, Relators := rels);; #comment: set a different print level by supplying #add for if set and ok #PqSetOutputLevel(procId, value);; PqSPComputePcpAndPCover(procId : ClassBound := 1);; #comment: set a different `ClassBound' by supplying #comment: also save the presentation to a file by supplying PqSPStandardPresentation(procId, [ [[2,0], [0,2]], [[0,2], [1,0]], [[1,2], [2,2]], [[1,0], [2,1]], [[2,0], [0,1]] ] : # options #add for if set and ok # StandardPresentationFile := value, #sub for <5> if set ClassBound := 5, PcgsAutomorphisms);; anupq-3.3.3/examples/2gp-SP-d-Rel-i0000644000175100017510000000222115111342310016176 0ustar runnerrunner#Example: "2gp-SP-d-Rel-i" . . . based on: isom/red1.com #vars: F, rels, procId; #options: OutputLevel, ClassBound, StandardPresentationFile F := FreeGroup("a", "b", "c", "d"); rels := ["b^4", "b^2 * [b, a, a]^-1", "d^16", "a^16 * (c * d)^-1", "b^8 * (d * c^4)^-1", "b * (a^2 * b^-1 * a^2)^-1"]; procId := PqStart(F : Prime := 2, Relators := rels);; #comment: set a different print level by supplying #add for if set and ok #PqSetOutputLevel(procId, value);; PqSPComputePcpAndPCover(procId : ClassBound := 1);; #comment: set a different `ClassBound' by supplying #comment: also save the presentation to a file by supplying PqSPStandardPresentation(procId, [ [[0,1], [1,1]], [[0,1], [1,0]] ] : # options #add for if set and ok # StandardPresentationFile := value, #sub for <10> if set ClassBound := 10, PcgsAutomorphisms);; anupq-3.3.3/examples/5gp-a-Rel-i0000644000175100017510000000207315111342310015663 0ustar runnerrunner#Example: "5gp-a-Rel-i" . . . based on: examples/5gpA #vars: F, rels, procId; #options: OutputLevel, OutputFile F := FreeGroup("a", "b"); rels := ["a^5", "b^5", "(a * b)^5", "(a * b^2)^5", "(a * b^-2)^5", "(a * b^-1)^5", "(a^2 * b)^5", "(a^2 * b^2)^5", "(a^2 * b^-2)^5", "(a^2 * b^-1)^5", "(a * b * a^-1 * b^2)^5", "(a * b * a^2 * b^-1)^5", "(a * b * a^2 * b^2)^5", "(a * b * a * b^-1)^5", "(a * b * a^-1 * b)^5", "(a * b * a^-1 * b^-1)^5"]; procId := PqStart(F : Prime := 5, Relators := rels);; #comment: also set a different print level by supplying PqPcPresentation(procId : ClassBound := 5, #sub for <1> if set and ok OutputLevel := 1);; PqNextClass(procId);; #class 6 PqNextClass(procId);; #class 7 PqNextClass(procId);; #class 8 PqNextClass(procId);; #class 9 PqNextClass(procId);; #class 10 #comment: save the presentation to a different file by supplying #sub for if set and ok PqSavePcPresentation(procId, ANUPQData.outfile);; anupq-3.3.3/examples/5gp-SP-b-Rel-i0000644000175100017510000000314115111342310016201 0ustar runnerrunner#Example: "5gp-SP-b-Rel-i" . . . based on: isom/5gp_b #vars: F, rels, procId; #options: OutputLevel, ClassBound, StandardPresentationFile F := FreeGroup("a", "b"); rels := ["a^25", "[b, a, a]", "[b, a, a, a, a, a, b]", "[b, a, b, b, b, b]", "b^5 * [b, a, a]^-1"]; procId := PqStart(F : Prime := 5, Relators := rels);; #comment: set a different print level by supplying #add for if set and ok #PqSetOutputLevel(procId, value);; PqSPComputePcpAndPCover(procId : ClassBound := 2);; #comment: set a different `ClassBound' by supplying #comment: also save the presentation to a file by supplying PqSPStandardPresentation(procId, [ [[1,0,0,1], [0,1,0,0]], [[1,0,0,0], [0,1,0,1]], [[1,3,0,0], [0,1,0,0]], [[1,3,0,0], [0,4,0,0]], [[1,2,0,0], [0,3,0,0]], [[4,0,0,0], [0,1,0,0]], [[3,0,0,0], [0,1,0,0]] ] : # options #add for if set and ok # StandardPresentationFile := value, #sub for <27> if set ClassBound := 27, PcgsAutomorphisms);; anupq-3.3.3/examples/2gp-SP-Rel-i0000644000175100017510000000207015111342310015757 0ustar runnerrunner#Example: "2gp-SP-Rel-i" . . . based on: isom/2gp #vars: F, rels, procId; #options: OutputLevel, ClassBound, StandardPresentationFile F := FreeGroup("a", "b"); rels := ["a^4", "b^4", "[b, a, a]" ]; procId := PqStart(F : Prime := 2, Relators := rels);; #comment: set a different print level by supplying #add for if set and ok #PqSetOutputLevel(procId, value);; PqSPComputePcpAndPCover(procId : ClassBound := 1, OutputLevel := 3);; #comment: set a different `ClassBound' by supplying #comment: also save the presentation to a file by supplying PqSPStandardPresentation(procId, [ [[0,1], [1,1]], [[0,1], [1,0]] ] : # options #add for if set and ok # StandardPresentationFile := value, #sub for <10> if set ClassBound := 10, PcgsAutomorphisms);; anupq-3.3.3/examples/G5-SP-Rel-i0000644000175100017510000000306415111342310015546 0ustar runnerrunner#Example: "G5-SP-Rel-i" . . . based on: isom/G_5.com #vars: F, rels, procId; #options: OutputLevel, ClassBound, StandardPresentationFile F := FreeGroup("a", "b"); rels := ["[a, b, b, b]", "[b, a, b, b, b]", "[a, b, a]", "b^5"]; procId := PqStart(F : Prime := 5, Relators := rels);; #comment: set a different print level by supplying #add for if set and ok #PqSetOutputLevel(procId, value);; PqSPComputePcpAndPCover(procId : ClassBound := 2);; #comment: set a different `ClassBound' by supplying #comment: also save the presentation to a file by supplying PqSPStandardPresentation(procId, [ [[1,0,0,1], [0,1,0,0]], [[1,0,0,0], [0,1,0,1]], [[1,3,0,0], [0,1,0,0]], [[1,3,0,0], [0,4,0,0]], [[1,2,0,0], [0,3,0,0]], [[4,0,0,0], [0,1,0,0]], [[3,0,0,0], [0,1,0,0]] ] : # options #add for if set and ok # StandardPresentationFile := value, #sub for <10> if set ClassBound := 10, PcgsAutomorphisms);; anupq-3.3.3/examples/11gp-a-Rel-i0000644000175100017510000000140015111342310015731 0ustar runnerrunner#Example: "11gp-a-Rel-i" . . . based on: examples/11gpA #vars: F, rels, procId; #options: OutputLevel, ClassBound, OutputFile F := FreeGroup("a", "b"); rels := ["[b, a, a, b, b]^11", "[a, b, b, a, b, b]^11", "(a * b)^11"]; procId := PqStart(F : Prime := 11, Relators := rels);; #comment: set a different `ClassBound' by supplying #comment: also set a different print level by supplying #sub for <8> if set and ok PqPcPresentation(procId : ClassBound := 8, #sub for <1> if set and ok OutputLevel := 1);; #comment: save the presentation to a different file by supplying #sub for if set and ok PqSavePcPresentation(procId, ANUPQData.outfile);; anupq-3.3.3/examples/3gp-maxoccur-Rel-i0000644000175100017510000000136615111342310017266 0ustar runnerrunner#Example: "3gp-maxoccur-Rel-i" . . . based on: examples/maxoccur #Demonstrates usage of `PqSetMaximalOccurrences'. #vars: F, rels, procId, class; #options: OutputLevel, OutputFile F := FreeGroup("a", "b"); rels := ["a^3", "b^3"]; procId := PqStart(F : Prime := 3, Relators := rels);; #comment: set a different print level by supplying PqPcPresentation(procId : ClassBound := 1, #sub for <1> if set and ok OutputLevel := 1);; PqSetMaximalOccurrences(procId, [6, 4]);; for class in [2 .. 9] do PqNextClass(procId); od; #comment: save the presentation to a different file by supplying #sub for if set and ok PqSavePcPresentation(procId, ANUPQData.outfile);; anupq-3.3.3/examples/5gp-PG-i0000644000175100017510000000135315111342310015231 0ustar runnerrunner#Example: "5gp-PG-i" . . . based on: examples/pga_5gp #Descendants of C5 x C5 #vars: F, procId; #options: OutputLevel F := FreeGroup("a", "b"); procId := PqStart(F : Prime := 5);; #comment: set a different print level by supplying PqPcPresentation(procId : ClassBound := 1, #sub for <1> if set and ok OutputLevel := 1);; PqComputePCover(procId);; PqPGSupplyAutomorphisms(procId, [ [[2,0], [0,1]], [[4,1], [4,0]] ]);; PqPGConstructDescendants(procId : ClassBound := 2, StepSize := 2, RankInitialSegmentSubgroups := 4);; anupq-3.3.3/examples/gp-256-SP-Rel-i0000644000175100017510000000222215111342310016206 0ustar runnerrunner#Example: "gp-256-SP-Rel-i" . . . based on: isom/gp_256 #vars: F, rels, procId; #options: OutputLevel, ClassBound, StandardPresentationFile F := FreeGroup("a", "b"); rels := ["a^4 * [b, a, a, a, a, a]^-1", "b * a^2 * b^-1 * a^-2 * [b, a, a, a, a, a]^-1", "b^2 * [b, a, a, a, a, a]^-1" ]; procId := PqStart(F : Prime := 2, Relators := rels);; #comment: set a different print level by supplying #add for if set and ok #PqSetOutputLevel(procId, value);; PqSPComputePcpAndPCover(procId : ClassBound := 1);; #comment: set a different `ClassBound' by supplying #comment: also save the presentation to a file by supplying PqSPStandardPresentation(procId, [ [[0,1], [1,1]], [[0,1], [1,0]] ] : # options #add for if set and ok # StandardPresentationFile := value, #sub for <8> if set ClassBound := 8, PcgsAutomorphisms);; anupq-3.3.3/examples/R2-5-x-i0000644000175100017510000000146315111342310015126 0ustar runnerrunner#Example: "R2-5-x-i" . . . based on: GrpFP_2_pQuotient7 #Construction of R(2,5) extended to see how many #words starting with the first pc generator squared #need to be considered when doing the exponent law checks #vars: F, procId; #options: OutputLevel1, OutputLevel2, OutputFile F := FreeGroup("a", "b"); procId := PqStart(F : Prime := 5, Exponent := 5);; #comment: set a different print level by supplying PqPcPresentation(procId : ClassBound := 6, #sub for <1> if set and ok OutputLevel := 1);; PqSetupTablesForNextClass(procId);; PqTails(procId, 0);; PqDoConsistencyChecks(procId, 0, 0);; #comment: set a different print level by supplying #sub for <3> if set and ok PqSetOutputLevel(procId, 3);; PqDoExponentChecks(procId);; anupq-3.3.3/examples/5gp-SP-d-Rel-i0000644000175100017510000000313315111342310016204 0ustar runnerrunner#Example: "5gp-SP-d-Rel-i" . . . based on: isom/5gp_d #vars: F, rels, procId; #options: OutputLevel, ClassBound, StandardPresentationFile F := FreeGroup("a", "b"); rels := ["a^25", "[b, a, a, a, b]", "[b, a, b, b, b]", "[b, a, b, a]", "b^5 * [a, b, a]^-1"]; procId := PqStart(F : Prime := 5, Relators := rels);; #comment: set a different print level by supplying #add for if set and ok #PqSetOutputLevel(procId, value);; PqSPComputePcpAndPCover(procId : ClassBound := 2);; #comment: set a different `ClassBound' by supplying #comment: also save the presentation to a file by supplying PqSPStandardPresentation(procId, [ [[1,0,0,1], [0,1,0,0]], [[1,0,0,0], [0,1,0,1]], [[1,3,0,0], [0,1,0,0]], [[1,3,0,0], [0,4,0,0]], [[1,2,0,0], [0,3,0,0]], [[4,0,0,0], [0,1,0,0]], [[3,0,0,0], [0,1,0,0]] ] : # options #add for if set and ok # StandardPresentationFile := value, #sub for <20> if set ClassBound := 20, PcgsAutomorphisms);; anupq-3.3.3/examples/R2-5-i0000644000175100017510000000147515111342310014664 0ustar runnerrunner#Example: "R2-5-i" . . . based on: examples/R2-5 #Construction of R(2,5) #vars: F, procId, class; #options: OutputLevel, OutputFile F := FreeGroup("a", "b"); procId := PqStart(F : Prime := 5, Exponent := 5);; #comment: set a different print level by supplying PqPcPresentation(procId : ClassBound := 1, #sub for <1> if set and ok OutputLevel := 1);; PqSupplyAutomorphisms(procId, [ [[2,0], [0,1]], [[4,1], [4,0]] ]);; for class in [2 .. 13] do PqNextClass(procId : QueueFactor := 20); od; #comment: save the presentation to a different file by supplying #sub for if set and ok PqSavePcPresentation(procId, ANUPQData.outfile);; anupq-3.3.3/examples/11gp-PG-i0000644000175100017510000000164315111342310015310 0ustar runnerrunner#Example: "11gp-PG-i" . . . based on: examples/pga_11gp #Descendants of C11 x C11 x C11 #vars: F, procId; #options: OutputLevel F := FreeGroup("a", "b", "c"); procId := PqStart(F : Prime := 11);; #comment: set a different print level by supplying PqPcPresentation(procId : ClassBound := 1, #sub for <1> if set and ok OutputLevel := 1);; PqComputePCover(procId);; PqPGSupplyAutomorphisms(procId, [ [[ 2, 0, 0], [ 0, 1, 0], [ 0, 0, 1]], [[10, 0, 1], [10, 0, 0], [ 0,10, 0]] ]);; PqPGConstructDescendants(procId : ClassBound := 2, CapableDescendants, StepSize := 1, RankInitialSegmentSubgroups := 3);; anupq-3.3.3/examples/2gp-PG-e4-i0000644000175100017510000000135615111342310015537 0ustar runnerrunner#Example: "2gp-PG-e4-i" . . . based on: examples/pga_exp4 #All 2-generator exponent 4 2-groups #vars: F, procId; #options: OutputLevel F := FreeGroup("a", "b"); procId := PqStart(F : Prime := 2);; #comment: set a different print level by supplying PqPcPresentation(procId : ClassBound := 1, #sub for <1> if set and ok OutputLevel := 1);; PqComputePCover(procId);; PqPGSupplyAutomorphisms(procId, [ [[0,1], [1,1]], [[0,1], [1,0]] ]);; PqPGConstructDescendants(procId : ClassBound := 12, PcgsAutomorphisms, Exponent := 4);; anupq-3.3.3/examples/3gp-SP-4-Rel-i0000644000175100017510000000254715111342310016132 0ustar runnerrunner#Example: "3gp-SP-4-Rel-i" . . . based on: isom/3gp.test #vars: F, rels, procId; #options: OutputLevel, ClassBound, StandardPresentationFile F := FreeGroup("a", "b"); rels := ["(b * [b, a] * [b, a, b])^3", "([b, a] * [b, a, b]^2)^3", "[b, a, a]"]; procId := PqStart(F : Prime := 3, Relators := rels);; #comment: set a different print level by supplying #add for if set and ok #PqSetOutputLevel(procId, value);; PqSPComputePcpAndPCover(procId : ClassBound := 1);; #comment: set a different `ClassBound' by supplying #comment: also save the presentation to a file by supplying PqSPStandardPresentation(procId, [ [[2,0], [0,2]], [[0,2], [1,0]], [[1,2], [2,2]], [[1,0], [2,1]], [[2,0], [0,1]] ] : # options #add for if set and ok # StandardPresentationFile := value, #sub for <7> if set ClassBound := 7, PcgsAutomorphisms);; anupq-3.3.3/examples/7gp-Rel-i0000644000175100017510000000137215111342310015450 0ustar runnerrunner#Example: "7gp-Rel-i" . . . based on: examples/7gp #vars: F, rels, procId; #options: OutputLevel, ClassBound, OutputFile F := FreeGroup("a", "b"); rels := ["[b, a, a, b, b]^49", "(a * b * b * a * b * a)^49", "b^7"]; procId := PqStart(F : Prime := 7, Relators := rels);; #comment: set a different `ClassBound' by supplying #comment: also set a different print level by supplying #sub for <10> if set and ok PqPcPresentation(procId : ClassBound := 10, #sub for <1> if set and ok OutputLevel := 1);; #comment: save the presentation to a different file by supplying #sub for if set and ok PqSavePcPresentation(procId, ANUPQData.outfile);; anupq-3.3.3/examples/Nott-SP-Rel-i0000644000175100017510000000267315111342310016224 0ustar runnerrunner#Example: "Nott-SP-Rel-i" . . . based on: isom/nott.com #vars: F, rels, procId; #options: OutputLevel, ClassBound, StandardPresentationFile F := FreeGroup("a", "b"); rels := ["a^5", "b^5", "[b, a, b]"]; procId := PqStart(F : Prime := 5, Relators := rels);; #comment: set a different print level by supplying #add for if set and ok #PqSetOutputLevel(procId, value);; PqSPComputePcpAndPCover(procId : ClassBound := 3);; #comment: set a different `ClassBound' by supplying #comment: also save the presentation to a file by supplying PqSPStandardPresentation(procId, [ [[1,0,0,0], [0,1,0,1]], [[1,1,0,0], [0,1,0,0]], [[1,0,0,0], [0,4,0,0]], [[1,0,0,0], [0,2,0,0]], [[4,0,0,0], [0,1,0,0]], [[2,0,0,0], [0,1,0,0]] ] : # options #add for if set and ok # StandardPresentationFile := value, #sub for <10> if set ClassBound := 10, PcgsAutomorphisms);; anupq-3.3.3/examples/Pq-ni0000644000175100017510000000110015111342310014756 0ustar runnerrunner#Example: "Pq-ni" . . . based on manual example illustrating `Pq' usage #(demonstrates the alternative ways of passing options non-interactively) #vars: F, a, b, R, H, rels; #options: F := FreeGroup("a", "b"); a := F.1; b := F.2; rels := [ "a^25", "[b, a, a]", "b^5" ]; R := PqGAPRelators(F, rels); H := F / R; ## This demonstrates how the options may be passed as a record argument Pq( H, rec( Prime := 5, ClassBound := 5, Metabelian := true ) ); ## This demonstrates how the options may be passed as additional arguments Pq( H, "Prime", 5, "ClassBound", 5, "Metabelian" ); anupq-3.3.3/examples/B2-5-i0000644000175100017510000000130215111342310014631 0ustar runnerrunner#Example: "B2-5-i" . . . based on: examples/B2-5 #Construction of B(2,5) #vars: F, procId; #options: OutputLevel, ClassBound, OutputFile F := FreeGroup("a", "b"); procId := PqStart(F : Prime := 5, Exponent := 5);; #comment: set a different `ClassBound' by supplying #comment: also set a different print level by supplying #sub for <15> if set and ok PqPcPresentation(procId : ClassBound := 15, #sub for <1> if set and ok OutputLevel := 1);; #comment: save the presentation to a different file by supplying #sub for if set and ok PqSavePcPresentation(procId, ANUPQData.outfile);; anupq-3.3.3/examples/EpimorphismStandardPresentation-i0000644000175100017510000000245515111342310022607 0ustar runnerrunner#Example: "EpimorphismStandardPresentation-i" . . based on manual example #(demonstrates interactive `EpimorphismStandardPresentation' usage) #vars: F, x, y, z, w, a, b, R, Q, procId, G, phi, lev; #options: F := FreeGroup(6, "F"); ## For printing GAP uses the symbols F1, ... for the generators of F x := F.1; y := F.2; z := F.3; w := F.4; a := F.5; b := F.6; R := [x^3 / w, y^3 / w * a^2 * b^2, w^3 / b, Comm (y, x) / z, Comm (z, x), Comm (z, y) / a, z^3 ]; Q := F / R; procId := PqStart( Q );; G := Pq( procId : Prime := 3, ClassBound := 3 ); lev := InfoLevel(InfoANUPQ); # Save current InfoANUPQ level SetInfoLevel(InfoANUPQ, 2);; # To see computation time data ## It is not necessary to pass the `Prime' option to ## `EpimorphismStandardPresentation' since it was previously ## passed to `Pq': phi := EpimorphismStandardPresentation( procId : ClassBound := 3 ); ## Image of phi should be isomorphic to G ... ## let's check the order is correct: Size( Image(phi) ); ## `StandardPresentation' and `EpimorphismStandardPresentation' ## behave like attributes, so no computation is done when ## either is called again for the same process ... StandardPresentation( procId : ClassBound := 3 ); ## No timing data was Info-ed since no computation was done SetInfoLevel(InfoANUPQ, lev);; # Restore previous InfoANUPQ level anupq-3.3.3/examples/3gp-Rel-i0000644000175100017510000000143615111342310015445 0ustar runnerrunner#Example: "3gp-Rel-i" . . . based on: examples/3gp #vars: F, rels, procId; #options: OutputLevel, ClassBound, OutputFile F := FreeGroup("a", "b", "c", "d"); rels := ["(b * c^-1 * d)^-3", "(c * d^-1)^3", "[b, a] * c", "[c, a]", "[c, b] * d"]; procId := PqStart(F : Prime := 3, Relators := rels);; #comment: set a different `ClassBound' by supplying #comment: also set a different print level by supplying #sub for <19> if set and ok PqPcPresentation(procId : ClassBound := 19, #sub for <1> if set and ok OutputLevel := 1);; #comment: save the presentation to a different file by supplying #sub for if set and ok PqSavePcPresentation(procId, ANUPQData.outfile);; anupq-3.3.3/examples/11gp-SP-c-Rel-i0000644000175100017510000000510615111342310016262 0ustar runnerrunner#Example: "11gp-SP-c-Rel-i" . . . based on: isom/11gp_c.com #vars: F, rels, procId; #options: OutputLevel, ClassBound, StandardPresentationFile F := FreeGroup("a", "b", "c"); rels := ["a^11", "b^11", "c^11", "[b, a, a, a, b]", "[c, a]", "[c, b]", "[b, a, b]"]; procId := PqStart(F : Prime := 11, Relators := rels);; #comment: set a different print level by supplying #add for if set and ok #PqSetOutputLevel(procId, value);; PqSPComputePcpAndPCover(procId : ClassBound := 3);; #comment: set a different `ClassBound' by supplying #comment: also save the presentation to a file by supplying PqSPStandardPresentation(procId, [ [[1,0,0,0,0], [0,1,0,0,1], [0,0,1,0,0]], [[1,0,0,0,0], [0,1,0,0,0], [0,0,1,0,1]], [[1,0,9,0,0], [0,1,0,0,0], [0,0,1,0,0]], [[1,7,8,0,0], [0,1,0,0,0], [0,0,1,0,0]], [[10,0,0,0,0], [0,1,0,0,0], [0,0,1,0,0]], [[2,0,0,0,0], [0,1,0,0,0], [0,0,1,0,0]], [[1,0,8,0,0], [0,1,3,0,0], [0,0,1,0,0]], [[1,0,9,0,0], [0,1,0,0,0], [0,0,3,0,0]], [[1,0,2,0,0], [0,1,0,0,0], [0,0,10,0,0]], [[1,9,10,0,0], [0,3,7,0,0], [0,0,6,0,0]], [[1,5,9,0,0], [0,7,4,0,0], [0,0,10,0,0]]] : # options #add for if set and ok # StandardPresentationFile := value, #sub for <8> if set ClassBound := 8,#for 9 perm.deg.>2^31, pq dies PcgsAutomorphisms);; anupq-3.3.3/examples/11gp-SP-a-i0000644000175100017510000000315515111342310015542 0ustar runnerrunner#Example: "11gp-SP-a-i" . . . based on: isom/11gp_a.com #vars: F, a, b, R, procId; #options: OutputLevel, ClassBound, StandardPresentationFile F := FreeGroup("a", "b"); a := F.1; b := F.2; R := [a^11, b^11/PqLeftNormComm([b, a, a])^2, PqLeftNormComm([b, a, b, b, b, b])];; procId := PqStart(F/R : Prime := 11);; #comment: set a different print level by supplying #sub for <0> if set and ok PqSetOutputLevel(procId, 0);; PqSPComputePcpAndPCover(procId : ClassBound := 3);; #comment: set a different `ClassBound' by supplying #comment: also save the presentation to a file by supplying PqSPStandardPresentation(procId, [ [[1,0,0,0,1], [0,1,0,0,0]], [[1,0,0,0,0], [0,1,0,1,0]], [[1,0,0,0,0], [0,1,0,0,1]], [[1,0,0,0,0], [3,1,0,0,0]], [[1,0,0,0,0], [9,3,0,0,0]], [[1,0,0,0,0], [6,6,0,0,0]], [[10,0,0,0,0], [2,1,0,0,0]] ] : # options #add for if set and ok # StandardPresentationFile := value, #sub for <19> if set ClassBound := 19, PcgsAutomorphisms);; anupq-3.3.3/examples/5gp-SP-a-Rel-i0000644000175100017510000000306015111342310016200 0ustar runnerrunner#Example: "5gp-SP-a-Rel-i" . . . based on: isom/5gp_a #vars: F, rels, procId; #options: OutputLevel, ClassBound, StandardPresentationFile F := FreeGroup("a", "b"); rels := ["a^25", "[b, a, a]", "[b, a, b, b, b, b]", "b^5"]; procId := PqStart(F : Prime := 5, Relators := rels);; #comment: set a different print level by supplying #add for if set and ok #PqSetOutputLevel(procId, value);; PqSPComputePcpAndPCover(procId : ClassBound := 2);; #comment: set a different `ClassBound' by supplying #comment: also save the presentation to a file by supplying PqSPStandardPresentation(procId, [ [[1,0,0,1], [0,1,0,0]], [[1,0,0,0], [0,1,0,1]], [[1,3,0,0], [0,1,0,0]], [[1,3,0,0], [0,4,0,0]], [[1,2,0,0], [0,3,0,0]], [[4,0,0,0], [0,1,0,0]], [[3,0,0,0], [0,1,0,0]] ] : # options #add for if set and ok # StandardPresentationFile := value, #sub for <27> if set ClassBound := 27, PcgsAutomorphisms);; anupq-3.3.3/examples/PqDescendants-10000644000175100017510000000070015111342310016671 0ustar runnerrunner#Example: "PqDescendants-1" . . . based on manual example #(demonstrates `PqDescendants' usage) #vars: F, a, b, procId, G, des; #options: F := FreeGroup( "a", "b" ); a := F.1; b := F.2; G := PcGroupFpGroup( F / [ a^2, b^2, Comm(b, a) ] ); #alt: do #procId := PqStart( G ); #alt: sub for des := PqDescendants( G : OrderBound := 6, ClassBound := 5 ); Length(des); List(des, Size); List(des, d -> Length( PCentralSeries( d, 2 ) ) - 1 ); anupq-3.3.3/examples/7gp-SP-a-Rel-i0000644000175100017510000000276715111342310016217 0ustar runnerrunner#Example: "7gp-SP-a-Rel-i" . . . based on: isom/7gp_a #vars: F, rels, procId; #options: OutputLevel, ClassBound, StandardPresentationFile F := FreeGroup("a", "b"); rels := ["b^7", "a^7 * [b, a, b]^-1", "(a * b * [b, a, b] )^7", "[b, a, a, a, a, b, a]"]; procId := PqStart(F : Prime := 7, Relators := rels);; #comment: set a different print level by supplying #add for if set and ok #PqSetOutputLevel(procId, value);; PqSPComputePcpAndPCover(procId : ClassBound := 3);; #comment: set a different `ClassBound' by supplying #comment: also save the presentation to a file by supplying PqSPStandardPresentation(procId, [ [[1,0,0,0], [0,1,0,1]], [[1,3,0,0], [0,1,0,0]], [[6,0,0,0], [0,1,0,0]], [[3,0,0,0], [0,1,0,0]], [[1,2,0,0], [0,1,0,0]], [[1,4,0,0], [0,4,0,0]] ] : # options #add for if set and ok # StandardPresentationFile := value, #sub for <20> if set ClassBound := 20, PcgsAutomorphisms);; anupq-3.3.3/examples/7gp-SP-b-Rel-i0000644000175100017510000000304115111342310016202 0ustar runnerrunner#Example: "7gp-SP-b-Rel-i" . . . based on: isom/7gp_b #vars: F, rels, procId; #options: OutputLevel, ClassBound, StandardPresentationFile F := FreeGroup("a", "b"); rels := ["b^7 * [b, a, a]^-1", "[b, a, b]"]; procId := PqStart(F : Prime := 7, Relators := rels);; #comment: set a different print level by supplying #add for if set and ok #PqSetOutputLevel(procId, value);; PqSPComputePcpAndPCover(procId : ClassBound := 2);; #comment: set a different `ClassBound' by supplying #comment: also save the presentation to a file by supplying PqSPStandardPresentation(procId, [ [[1,0,0,1], [0,1,0,0]], [[1,0,0,0], [0,1,0,1]], [[1,3,0,0], [0,1,0,0]], [[6,0,0,0], [0,1,0,0]], [[3,0,0,0], [0,1,0,0]], [[1,2,0,0], [0,6,0,0]], [[1,4,0,0], [0,4,0,0]] ] : # options #add for if set and ok # StandardPresentationFile := value, #sub for <40> if set ClassBound := 40, PcgsAutomorphisms);; anupq-3.3.3/examples/11gp-SP-b-Rel-i0000644000175100017510000000514015111342310016257 0ustar runnerrunner#Example: "11gp-SP-b-Rel-i" . . . based on: isom/11gp_b.com #(equivalent to "11gp-SP-b-i" but uses the `Relators' option) #vars: F, rels, procId; #options: OutputLevel, ClassBound, StandardPresentationFile F := FreeGroup("a", "b", "c"); rels := ["a^11", "b^11", "c^11", "[b, a, a, a, b, a]", "[c, a]", "[c, b]", "[b, a, b]"]; procId := PqStart(F : Prime := 11, Relators := rels);; #comment: set a different print level by supplying #sub for <0> if set and ok PqSetOutputLevel(procId, 0);; PqSPComputePcpAndPCover(procId : ClassBound := 3);; #comment: set a different `ClassBound' by supplying #comment: also save the presentation to a file by supplying PqSPStandardPresentation(procId, [ [[1,0,0,0,0], [0,1,0,0,1], [0,0,1,0,0]], [[1,0,0,0,0], [0,1,0,0,0], [0,0,1,0,1]], [[1,0,9,0,0], [0,1,0,0,0], [0,0,1,0,0]], [[1,7,8,0,0], [0,1,0,0,0], [0,0,1,0,0]], [[10,0,0,0,0], [0,1,0,0,0], [0,0,1,0,0]], [[2,0,0,0,0], [0,1,0,0,0], [0,0,1,0,0]], [[1,0,8,0,0], [0,1,3,0,0], [0,0,1,0,0]], [[1,0,9,0,0], [0,1,0,0,0], [0,0,3,0,0]], [[1,0,2,0,0], [0,1,0,0,0], [0,0,10,0,0]], [[1,9,10,0,0], [0,3,7,0,0], [0,0,6,0,0]], [[1,5,9,0,0], [0,7,4,0,0], [0,0,10,0,0]]] : # options #add for if set and ok # StandardPresentationFile := value, #sub for <8> if set ClassBound := 8, PcgsAutomorphisms);; anupq-3.3.3/examples/B2-8-i0000644000175100017510000000130215111342310014634 0ustar runnerrunner#Example: "B2-8-i" . . . based on: examples/B2-8 #Construction of B(2,8) #vars: F, procId; #options: OutputLevel, ClassBound, OutputFile F := FreeGroup("a", "b"); procId := PqStart(F : Prime := 2, Exponent := 8);; #comment: set a different `ClassBound' by supplying #comment: also set a different print level by supplying #sub for <10> if set and ok PqPcPresentation(procId : ClassBound := 10, #sub for <1> if set and ok OutputLevel := 1);; #comment: save the presentation to a different file by supplying #sub for if set and ok PqSavePcPresentation(procId, ANUPQData.outfile);; anupq-3.3.3/examples/index0000644000175100017510000000761315111342310015120 0ustar runnerrunner PqExample Index (Table of Contents) ----------------------------------- This table of possible examples is displayed when calling `PqExample' with no arguments, or with the argument: "index" (meant in the sense of ``list''), or with a non-existent example name. Examples that have a name ending in `-ni' are non-interactive only. Examples that have a name ending in `-i' are interactive only. Examples with names ending in `.g' also have only one form. Other examples have both a non-interactive and an interactive form; call `PqExample' with 2nd argument `PqStart' to get the interactive form of the example. The substring `PG' in an example name indicates a p-Group Generation example, `SP' indicates a Standard Presentation example, `Rel' indicates it uses the `Relators' option, and `Id' indicates it uses the `Identities' option. The following ANUPQ examples are available: p-Quotient examples: general: "Pq" "Pq-ni" "PqEpimorphism" "PqPCover" "PqSupplementInnerAutomorphisms" 2-groups: "2gp-Rel" "2gp-Rel-i" "2gp-a-Rel-i" "B2-4" "B2-4-Id" "B2-8-i" "B4-4-i" "B4-4-a-i" "B5-4.g" 3-groups: "3gp-Rel-i" "3gp-a-Rel" "3gp-a-Rel-i" "3gp-a-x-Rel-i" "3gp-maxoccur-Rel-i" 5-groups: "5gp-Rel-i" "5gp-a-Rel-i" "5gp-b-Rel-i" "5gp-c-Rel-i" "5gp-metabelian-Rel-i" "5gp-maxoccur-Rel-i" "F2-5-i" "B2-5-i" "R2-5-i" "R2-5-x-i" "B5-5-Engel3-Id" 7-groups: "7gp-Rel-i" 11-groups: "11gp-i" "11gp-Rel-i" "11gp-a-Rel-i" "11gp-3-Engel-Id" "11gp-3-Engel-Id-i" p-Group Generation examples: general: "PqDescendants-1" "PqDescendants-2" "PqDescendants-3" "PqDescendants-1-i" 2-groups: "2gp-PG-i" "2gp-PG-2-i" "2gp-PG-3-i" "2gp-PG-4-i" "2gp-PG-e4-i" "PqDescendantsTreeCoclassOne-16-i" 3-groups: "3gp-PG-i" "3gp-PG-4-i" "3gp-PG-x-i" "3gp-PG-x-1-i" "PqDescendants-treetraverse-i" "PqDescendantsTreeCoclassOne-9-i" 5-groups: "5gp-PG-i" "Nott-PG-Rel-i" "Nott-APG-Rel-i" "PqDescendantsTreeCoclassOne-25-i" 7,11-groups: "7gp-PG-i" "11gp-PG-i" Standard Presentation examples: general: "StandardPresentation" "StandardPresentation-i" "EpimorphismStandardPresentation" "EpimorphismStandardPresentation-i" "IsIsomorphicPGroup-ni" 2-groups: "2gp-SP-Rel-i" "2gp-SP-1-Rel-i" "2gp-SP-2-Rel-i" "2gp-SP-3-Rel-i" "2gp-SP-4-Rel-i" "2gp-SP-d-Rel-i" "gp-256-SP-Rel-i" "B2-4-SP-i" "G2-SP-Rel-i" 3-groups: "3gp-SP-Rel-i" "3gp-SP-1-Rel-i" "3gp-SP-2-Rel-i" "3gp-SP-3-Rel-i" "3gp-SP-4-Rel-i" "G3-SP-Rel-i" 5-groups: "5gp-SP-Rel-i" "5gp-SP-a-Rel-i" "5gp-SP-b-Rel-i" "5gp-SP-big-Rel-i" "5gp-SP-d-Rel-i" "G5-SP-Rel-i" "G5-SP-a-Rel-i" "Nott-SP-Rel-i" 7-groups: "7gp-SP-Rel-i" "7gp-SP-a-Rel-i" "7gp-SP-b-Rel-i" 11-groups: "11gp-SP-a-i" "11gp-SP-a-Rel-i" "11gp-SP-a-Rel-1-i" "11gp-SP-b-i" "11gp-SP-b-Rel-i" "11gp-SP-c-Rel-i" Notes ----- 1. The example (first) argument of `PqExample' is a string; each example above is in double quotes to remind you to include them. 2. Some examples accept options. To find out whether a particular example accepts options, display it first (by including `Display' as last argument) which will also indicate how `PqExample' interprets the options, e.g. `PqExample("11gp-SP-a-i", Display);'. 3. Try `SetInfoLevel(InfoANUPQ, );' for some in [2 .. 4] before calling PqExample, to see what's going on behind the scenes. anupq-3.3.3/examples/5gp-Rel-i0000644000175100017510000000135715111342310015451 0ustar runnerrunner#Example: "5gp-Rel-i" . . . based on: examples/5gp #vars: F, rels, procId; #options: OutputLevel, ClassBound, OutputFile F := FreeGroup("a", "b", "c"); rels := ["a^25 * c", "[a, b] * c^-4", "[a, c]^25"]; procId := PqStart(F : Prime := 5, Relators := rels);; #comment: set a different `ClassBound' by supplying #comment: also set a different print level by supplying #sub for <27> if set and ok PqPcPresentation(procId : ClassBound := 27, #sub for <1> if set and ok OutputLevel := 1);; #comment: save the presentation to a different file by supplying #sub for if set and ok PqSavePcPresentation(procId, ANUPQData.outfile);; anupq-3.3.3/examples/PqPCover0000644000175100017510000000235515111342310015506 0ustar runnerrunner#Example: "PqPCover" . . . based on `PqPCover' manual example #vars: F, a, b, procId1, procId2, procId3, procId4, G, R, H, rels; #options: F := FreeGroup("a", "b"); a := F.1; b := F.2; #alt: do #procId1 := PqStart( F ); #alt: sub for PqPCover( F : Prime := 2, ClassBound := 3 ); ## Now let's get a p-cover of a p-quotient of an fp group G := F / [a^4, b^4]; #alt: do #procId2 := PqStart( G ); #alt: sub for PqPCover( G : Prime := 2, ClassBound := 3 ); ## Now let's get a p-cover of a different p-quotient of the same group #alt: sub for PqPCover( G : Prime := 2, ClassBound := 3, #alt: do # RedoPcp, Exponent := 4 ); ## Now we'll get a p-cover of a p-quotient of another fp group ## which we will redo using the `Relators' option R := [ a^25, Comm(Comm(b, a), a), b^5 ]; H := F / R; #alt: do #procId3 := PqStart( H ); #alt: sub for PqPCover( H : Prime := 5, ClassBound := 5, Metabelian ); ## Now we redo the previous example using the `Relators' option F := FreeGroup("a", "b"); rels := [ "a^25", "[b, a, a]", "b^5" ]; #alt: do #procId4 := PqStart( F ); #alt: sub for PqPCover( F : Prime := 5, ClassBound := 5, Metabelian, Relators := rels ); anupq-3.3.3/examples/2gp-SP-1-Rel-i0000644000175100017510000000210615111342310016115 0ustar runnerrunner#Example: "2gp-SP-1-Rel-i" . . . based on: isom/2gp.exam #vars: F, rels, procId; #options: OutputLevel, ClassBound, StandardPresentationFile F := FreeGroup("a", "b"); rels := ["a^4", "b^2*[b, a, b]^-1", "b*(a^2 * b^-1 * a^2)^-1" ]; procId := PqStart(F : Prime := 2, Relators := rels);; #comment: set a different print level by supplying #add for if set and ok #PqSetOutputLevel(procId, value);; PqSPComputePcpAndPCover(procId : ClassBound := 1);; #comment: set a different `ClassBound' by supplying #comment: also save the presentation to a file by supplying PqSPStandardPresentation(procId, [ [[1,0], [1,1]], [[0,1], [1,0]] ] : # options #add for if set and ok # StandardPresentationFile := value, #sub for <7> if set ClassBound := 7, PcgsAutomorphisms);; anupq-3.3.3/examples/3gp-SP-2-Rel-i0000644000175100017510000000246415111342310016126 0ustar runnerrunner#Example: "3gp-SP-2-Rel-i" . . . based on: isom/3gp.ex2 #vars: F, rels, procId; #options: OutputLevel, ClassBound, StandardPresentationFile F := FreeGroup("x", "y"); rels := ["(x * y * x)^3", "[y, x, x]"]; procId := PqStart(F : Prime := 3, Relators := rels);; #comment: set a different print level by supplying #add for if set and ok #PqSetOutputLevel(procId, value);; PqSPComputePcpAndPCover(procId : ClassBound := 1);; #comment: set a different `ClassBound' by supplying #comment: also save the presentation to a file by supplying PqSPStandardPresentation(procId, [ [[2,0], [0,2]], [[0,2], [1,0]], [[1,2], [2,2]], [[1,0], [2,1]], [[2,0], [0,1]] ] : # options #add for if set and ok # StandardPresentationFile := value, #sub for <9> if set ClassBound := 9, PcgsAutomorphisms);; anupq-3.3.3/examples/3gp-SP-1-Rel-i0000644000175100017510000000246615111342310016127 0ustar runnerrunner#Example: "3gp-SP-1-Rel-i" . . . based on: isom/3gp.ex1 #vars: F, rels, procId; #options: OutputLevel, ClassBound, StandardPresentationFile F := FreeGroup("x", "y"); rels := ["(x * y * x)^3", "[x, y, y]"]; procId := PqStart(F : Prime := 3, Relators := rels);; #comment: set a different print level by supplying #add for if set and ok #PqSetOutputLevel(procId, value);; PqSPComputePcpAndPCover(procId : ClassBound := 1);; #comment: set a different `ClassBound' by supplying #comment: also save the presentation to a file by supplying PqSPStandardPresentation(procId, [ [[2,0], [0,2]], [[0,2], [1,0]], [[1,2], [2,2]], [[1,0], [2,1]], [[2,0], [0,1]] ] : # options #add for if set and ok # StandardPresentationFile := value, #sub for <10> if set ClassBound := 10, PcgsAutomorphisms);; anupq-3.3.3/examples/3gp-PG-x-i0000644000175100017510000000414115111342310015472 0ustar runnerrunner#Example: "3gp-PG-x-i" . . . based on example from Werner #Iterated descendants example #vars: F, procId; #options: OutputLevel F := FreeGroup("a", "b"); procId := PqStart(F : Prime := 3);; #comment: set a different print level by supplying PqPcPresentation(procId : ClassBound := 1, #sub for <1> if set and ok OutputLevel := 1);; PqComputePCover(procId);; PqPGSupplyAutomorphisms(procId, [ [[1,1], [0,1]], [[0,1], [1,0]] ]);; PqPGExtendAutomorphisms(procId);; PqPGConstructDescendants(procId : ClassBound := 2, CapableDescendants, BasicAlgorithm); PqPGSetDescendantToPcp(procId, 2, 5); PqPGExtendAutomorphisms(procId);; PqPGConstructDescendants(procId : ClassBound := 3, CapableDescendants, BasicAlgorithm); PqPGSetDescendantToPcp(procId, 3, 2); PqPGExtendAutomorphisms(procId);; PqPGConstructDescendants(procId : ClassBound := 4, CapableDescendants, BasicAlgorithm); PqPGSetDescendantToPcp(procId, 4, 2); PqPGExtendAutomorphisms(procId);; PqPGConstructDescendants(procId : ClassBound := 5, CapableDescendants, BasicAlgorithm); PqPGSetDescendantToPcp(procId, 5, 1); PqPGExtendAutomorphisms(procId);; PqPGConstructDescendants(procId : ClassBound := 6, CapableDescendants, BasicAlgorithm); PqPGSetDescendantToPcp(procId, 6, 1); PqPGExtendAutomorphisms(procId);; PqPGConstructDescendants(procId : ClassBound := 7, CapableDescendants, BasicAlgorithm); PqPGSetDescendantToPcp(procId, 7, 1); PqPGExtendAutomorphisms(procId);; PqPGConstructDescendants(procId : ClassBound := 8, CapableDescendants, BasicAlgorithm); anupq-3.3.3/examples/5gp-SP-big-Rel-i0000644000175100017510000000204115111342310016517 0ustar runnerrunner#Example: "5gp-SP-big-Rel-i" . . . based on: isom/large_5gp #vars: F, rels, procId; #options: OutputLevel, ClassBound, StandardPresentationFile F := FreeGroup("a", "b", "c", "d"); rels := ["a * b^d", "c * d^a", "[c, a, a]", "[c, b, b, a]"]; procId := PqStart(F : Prime := 5, Relators := rels);; #comment: set a different print level by supplying #add for if set and ok #PqSetOutputLevel(procId, value);; PqSPComputePcpAndPCover(procId : ClassBound := 1);; #comment: set a different `ClassBound' by supplying #comment: also save the presentation to a file by supplying PqSPStandardPresentation(procId, [ [[4,1], [4,0]], [[2,0], [0,1]] ] : # options #add for if set and ok # StandardPresentationFile := value, #sub for <5> if set ClassBound := 5);; anupq-3.3.3/examples/5gp-b-Rel-i0000644000175100017510000000106415111342310015663 0ustar runnerrunner#Example: "5gp-b-Rel-i" . . . based on: examples/5gpB #vars: F, rels, procId; #options: OutputLevel, ClassBound F := FreeGroup("x", "y", "z", "w"); rels := ["x^25 * (x^z)^-1", "[x, y] * z^-1", "[x, z]"]; procId := PqStart(F : Prime := 5, Relators := rels);; #comment: set a different `ClassBound' by supplying #comment: also set a different print level by supplying #sub for <5> if set and ok PqPcPresentation(procId : ClassBound := 5, #sub for <1> if set and ok OutputLevel := 1);; anupq-3.3.3/examples/3gp-PG-i0000644000175100017510000000216015111342310015224 0ustar runnerrunner#Example: "3gp-PG-i" . . . based on: examples/pga_3gp #All groups with lower exponent-3 series of shape 2-2-3-1 #vars: F, procId; #options: OutputLevel F := FreeGroup("a", "b"); procId := PqStart(F : Prime := 3);; #comment: set a different print level by supplying PqPcPresentation(procId : ClassBound := 1, #sub for <1> if set and ok OutputLevel := 1);; PqComputePCover(procId);; PqPGSupplyAutomorphisms(procId, [ [[2,0], [0,2]], [[0,2], [1,0]], [[1,2], [2,2]], [[1,0], [2,1]], [[2,0], [0,1]] ]);; PqPGConstructDescendants(procId : ClassBound := 4, CapableDescendants, StepSize := [2, 3, 1], PcgsAutomorphisms, BasicAlgorithm);; anupq-3.3.3/examples/2gp-Rel-i0000644000175100017510000000133315111342310015440 0ustar runnerrunner#Example: "2gp-Rel-i" . . . based on: examples/2gp #vars: F, rels, procId; #options: OutputLevel, ClassBound, OutputFile F := FreeGroup("a", "b"); rels := ["[b, a, a]", "(a * b * a)^4"]; procId := PqStart(F : Prime := 2, Relators := rels);; #comment: set a different `ClassBound' by supplying #comment: also set a different print level by supplying #sub for <6> if set and ok PqPcPresentation(procId : ClassBound := 6, #sub for <1> if set and ok OutputLevel := 1);; #comment: save the presentation to a different file by supplying #sub for if set and ok PqSavePcPresentation(procId, ANUPQData.outfile);; anupq-3.3.3/examples/2gp-a-Rel-i0000644000175100017510000000111515111342310015654 0ustar runnerrunner#Example: "2gp-a-Rel-i" . . . based on: examples/keyword_2gp #vars: F, rels, procId; #options: OutputLevel, ClassBound F := FreeGroup(3, "x"); rels := ["x1^x2 * x3", "[x2, x1, x1]", "[x2 * [x2, x1] * x1^2, x1 * x2 ]"]; procId := PqStart(F : Prime := 2, Relators := rels);; #comment: set a different `ClassBound' by supplying #comment: also set a different print level by supplying #sub for <3> if set and ok PqPcPresentation(procId : ClassBound := 3, #sub for <1> if set and ok OutputLevel := 1);; anupq-3.3.3/examples/EpimorphismStandardPresentation0000644000175100017510000000240315111342310022352 0ustar runnerrunner#Example: "EpimorphismStandardPresentation" . . . based on manual example #(demonstrates `EpimorphismStandardPresentation' usage) #vars: F, x, y, z, w, a, b, R, Q, procId, G, f1, f2, f3, f4, f5, f6, phi; #options: F := FreeGroup(6, "F"); ## For printing GAP uses the symbols F1, ... for the generators of F x := F.1; y := F.2; z := F.3; w := F.4; a := F.5; b := F.6; R := [x^3 / w, y^3 / w * a^2 * b^2, w^3 / b, Comm (y, x) / z, Comm (z, x), Comm (z, y) / a, z^3 ]; Q := F / R; ## For printing GAP also uses the symbols F1, ... for the generators of Q ## (the same as used for F) ... but the gen'rs of Q and F are different: GeneratorsOfGroup(F) = GeneratorsOfGroup(Q); #alt: do #procId := PqStart( Q ); #alt: sub for G := Pq( Q : Prime := 3, ClassBound := 3 ); #alt: sub for phi := EpimorphismStandardPresentation( Q : Prime := 3, ClassBound := 3 ); Source(phi); # This is the group Q (GAP uses F1, ... for gen'r symbols) Range(phi); # This is the group G (GAP uses f1, ... for gen'r symbols) AssignGeneratorVariables(G);; # so f1, ... are now variables ## Just to see that the images of [F1, ..., F6] do generate G Group([ f1*f2^2*f3, f1*f2*f3*f4*f5^2*f6^2, f3^2, f4, f5, f6 ]) = G; Size( Image(phi) ); anupq-3.3.3/examples/5gp-c-Rel-i0000644000175100017510000000113715111342310015665 0ustar runnerrunner#Example: "5gp-c-Rel-i" . . . based on: examples/keyword_5gp #vars: F, rels, procId; #options: OutputLevel, ClassBound F := FreeGroup("a", "b", "c", "d"); rels := ["[a, b, b, c]", "(a * b * c^d * a)^25", "(a * b)^25 * [a, c, c, d]^-2"]; procId := PqStart(F : Prime := 5, Relators := rels);; #comment: set a different `ClassBound' by supplying #comment: also set a different print level by supplying #sub for <2> if set and ok PqPcPresentation(procId : ClassBound := 2, #sub for <1> if set and ok OutputLevel := 1);; anupq-3.3.3/examples/3gp-SP-3-Rel-i0000644000175100017510000000246515111342310016130 0ustar runnerrunner#Example: "3gp-SP-3-Rel-i" . . . based on: isom/3gp.exam #vars: F, rels, procId; #options: OutputLevel, ClassBound, StandardPresentationFile F := FreeGroup("x", "y"); rels := ["(x * y * x)^3", "[x, y, x]"]; procId := PqStart(F : Prime := 3, Relators := rels);; #comment: set a different print level by supplying #add for if set and ok #PqSetOutputLevel(procId, value);; PqSPComputePcpAndPCover(procId : ClassBound := 1);; #comment: set a different `ClassBound' by supplying #comment: also save the presentation to a file by supplying PqSPStandardPresentation(procId, [ [[2,0], [0,2]], [[0,2], [1,0]], [[1,2], [2,2]], [[1,0], [2,1]], [[2,0], [0,1]] ] : # options #add for if set and ok # StandardPresentationFile := value, #sub for <6> if set ClassBound := 6, PcgsAutomorphisms);; anupq-3.3.3/examples/2gp-SP-2-Rel-i0000644000175100017510000000227615111342310016126 0ustar runnerrunner#Example: "2gp-SP-2-Rel-i" . . . based on: isom/2gp.com #vars: F, rels, procId; #options: OutputLevel, ClassBound, StandardPresentationFile F := FreeGroup("a", "b"); rels := ["a^4", "b^2*[b, a, b]^-1" ]; procId := PqStart(F : Prime := 2, Relators := rels);; #comment: set a different print level by supplying #add for if set and ok #PqSetOutputLevel(procId, value);; PqSPComputePcpAndPCover(procId : ClassBound := 2);; #comment: set a different `ClassBound' by supplying #comment: also save the presentation to a file by supplying PqSPStandardPresentation(procId, [ [[1,0,0,1], [0,1,0,0]], [[1,0,0,0], [0,1,0,1]], [[1,1,1,0], [0,1,1,1]] ] : # options #add for if set and ok # StandardPresentationFile := value, #sub for <10> if set ClassBound := 10, PcgsAutomorphisms);; PqDisplayPcPresentation(procId);; anupq-3.3.3/examples/11gp-SP-a-Rel-i0000644000175100017510000000321215111342310016254 0ustar runnerrunner#Example: "11gp-SP-a-Rel-i" . . . based on: isom/11gp_a.com #(equivalent to "11gp-SP-a-i" but uses the `Relators' option) #vars: F, rels, procId; #options: OutputLevel, ClassBound, StandardPresentationFile F := FreeGroup("a", "b"); rels := ["a^11", "b^11*[b, a, a]^-2", "[b, a, b, b, b, b]"]; procId := PqStart(F : Prime := 11, Relators := rels);; #comment: set a different print level by supplying #sub for <0> if set and ok PqSetOutputLevel(procId, 0);; PqSPComputePcpAndPCover(procId : ClassBound := 3);; #comment: set a different `ClassBound' by supplying #comment: also save the presentation to a file by supplying PqSPStandardPresentation(procId, [ [[1,0,0,0,1], [0,1,0,0,0]], [[1,0,0,0,0], [0,1,0,1,0]], [[1,0,0,0,0], [0,1,0,0,1]], [[1,0,0,0,0], [3,1,0,0,0]], [[1,0,0,0,0], [9,3,0,0,0]], [[1,0,0,0,0], [6,6,0,0,0]], [[10,0,0,0,0], [2,1,0,0,0]] ] : # options #add for if set and ok # StandardPresentationFile := value, #sub for <19> if set ClassBound := 19, PcgsAutomorphisms);; anupq-3.3.3/examples/B4-4-i0000644000175100017510000000132115111342310014633 0ustar runnerrunner#Example: "B4-4-i" . . . based on: examples/B4-4 #Construction of B(4,4) #vars: F, procId, class; #options: OutputLevel, ClassBound, OutputFile F := FreeGroup("a", "b", "c", "d"); procId := PqStart(F : Prime := 2, Exponent := 4);; #comment: set a different `ClassBound' by supplying #comment: also set a different print level by supplying #sub for <6> if set and ok PqPcPresentation(procId : ClassBound := 6, #sub for <1> if set and ok OutputLevel := 1);; #comment: save the presentation to a different file by supplying #sub for if set and ok PqSavePcPresentation(procId, ANUPQData.outfile);; anupq-3.3.3/examples/B2-4-Id0000644000175100017510000000071615111342310014744 0ustar runnerrunner#Example: "B2-4-Id" . . . alternative way to generate B(2, 4) #Generates B(2, 4) by using the `Identities' option #... this is not as efficient as using `Exponent' but #demonstrates the usage of the `Identities' option. #vars: F, f, procId; #options: F := FreeGroup("a", "b"); ## All words w in the pc generators of B(2, 4) satisfy f(w) = 1 f := w -> w^4; #alt: do #procId := PqStart( F ); #alt: sub for Pq( F : Prime := 2, Identities := [ f ] ); anupq-3.3.3/examples/11gp-Rel-i0000644000175100017510000000147715111342310015531 0ustar runnerrunner#Example: "11gp-Rel-i" . . . based on: examples/11gp #(equivalent to "11gp-i" example but uses `Relators' option) #vars: F, rels, procId; #options: OutputLevel, ClassBound, OutputFile F := FreeGroup("a", "b", "c"); rels := ["[b, a, a, b, c]^11", "[a, b, b, a, b, c]^11", "(a * b)^11"]; procId := PqStart(F : Prime := 11, Relators := rels);; #comment: set a different `ClassBound' by supplying #comment: also set a different print level by supplying #sub for <7> if set and ok PqPcPresentation(procId : ClassBound := 7, #sub for <1> if set and ok OutputLevel := 1);; #comment: save the presentation to a different file by supplying #sub for if set and ok PqSavePcPresentation(procId, ANUPQData.outfile);; anupq-3.3.3/examples/5gp-maxoccur-Rel-i0000644000175100017510000000143115111342310017261 0ustar runnerrunner#Example: "5gp-maxoccur-Rel-i" . . . based on: GrpFP_2_pQuotient6 #Demonstrates usage of `PqSetMaximalOccurrences'. #vars: F, rels, procId, class; #options: OutputLevel, OutputFile F := FreeGroup("a", "b"); rels := ["a^5", "b^5"]; procId := PqStart(F : Prime := 5, Relators := rels);; #comment: set a different print level by supplying PqPcPresentation(procId : ClassBound := 1, #sub for <1> if set and ok OutputLevel := 1);; PqSetMaximalOccurrences(procId, [3, 2]);; for class in [2 .. 6] do PqNextClass(procId); od; PqDisplayPcPresentation(procId);; #comment: save the presentation to a different file by supplying #sub for if set and ok PqSavePcPresentation(procId, ANUPQData.outfile);; anupq-3.3.3/examples/PqDescendantsTreeCoclassOne-25-i0000644000175100017510000000063015111342310022001 0ustar runnerrunner#Example: "PqDescendantsTreeCoclassOne-25-i" . based on manual example #(demonstrates usage of `PqDescendantsTreeCoclassOne', by generating # all descendants of the elementary abelian group of order 25 of # 5-coclass 1 up to 5-class 15. Most effective in XGAP.) #vars: G, procId; #options: G := ElementaryAbelianGroup( 25 ); procId := PqStart( G );; PqDescendantsTreeCoclassOne( procId : TreeDepth := 15 );; anupq-3.3.3/examples/3gp-a-Rel-i0000644000175100017510000000142015111342310015654 0ustar runnerrunner#Example: "3gp-a-Rel-i" . . . based on: examples/3gpA #(exponent 9 group with 2 generators of order 3) #vars: F, rels, procId; #options: OutputLevel, ClassBound, OutputFile F := FreeGroup("a", "b"); rels := ["a^3", "b^3"]; procId := PqStart(F : Prime := 3, Exponent := 9, Relators := rels);; #comment: set a different `ClassBound' by supplying #comment: also set a different print level by supplying #sub for <12> if set and ok PqPcPresentation(procId : ClassBound := 12, #sub for <1> if set and ok OutputLevel := 1);; #comment: save the presentation to a different file by supplying #sub for if set and ok PqSavePcPresentation(procId, ANUPQData.outfile);; anupq-3.3.3/examples/PqDescendants-1-i0000644000175100017510000000065315111342310017126 0ustar runnerrunner#Example: "PqDescendants-1-i" . . . based on manual example #(demonstrates `PqSetPQuotientToGroup' usage) #vars: F, procId, G, des; #options: F := FreeGroup( "a", "b" ); procId := PqStart( F : Prime := 2 );; Pq( procId : ClassBound := 1 ); PqSetPQuotientToGroup( procId );; des := PqDescendants( procId : OrderBound := 6, ClassBound := 5 ); Length(des); List(des, Size); List(des, d -> Length( PCentralSeries( d, 2 ) ) - 1 ); anupq-3.3.3/examples/B2-4-SP-i0000644000175100017510000000207415111342310015157 0ustar runnerrunner#Example: "B2-4-SP-i" . . . based on: isom/B2-4.com #Computes standard presentation for B(2,4) #vars: F, a, b, procId; #options: OutputLevel, ClassBound, StandardPresentationFile F := FreeGroup("a", "b"); a := F.1; b := F.2; procId := PqStart(F : Prime := 2, Exponent := 4);; #comment: set a different print level by supplying #add for if set and ok #PqSetOutputLevel(procId, value);; PqSPComputePcpAndPCover(procId : ClassBound := 1);; #comment: set a different `ClassBound' by supplying #comment: also save the presentation to a file by supplying PqSPStandardPresentation(procId, [ [[0,1], [1,1]], [[0,1], [1,0]] ] : # options #add for if set and ok # StandardPresentationFile := value, #sub for <6> if set ClassBound := 6, PcgsAutomorphisms);; anupq-3.3.3/examples/Nott-PG-Rel-i0000644000175100017510000000275715111342310016213 0ustar runnerrunner#Example: "Nott-PG-Rel-i" . . . based on: examples/pga_nott #Start point for Nottingham group #vars: F, rels, procId; #options: OutputLevel, OutputFile F := FreeGroup("a", "b"); rels := ["a^5", "b^5", "[b, a, b]"]; procId := PqStart(F : Prime := 5, Relators := rels);; #comment: set a different print level by supplying PqPcPresentation(procId : ClassBound := 3, #sub for <1> if set and ok OutputLevel := 1);; PqComputePCover(procId);; #comment: save the presentation to a different file by supplying #sub for if set and ok PqSavePcPresentation(procId, ANUPQData.outfile);; PqPGSupplyAutomorphisms(procId, [ [[1,0,0,0], [0,1,0,1]], [[1,1,0,0], [0,1,0,1]], [[1,0,0,0], [0,4,0,0]], [[1,0,0,0], [0,2,0,0]], [[4,0,0,0], [0,1,0,0]], [[2,0,0,0], [0,1,0,0]] ]);; PqPGConstructDescendants(procId : ClassBound := 4, CapableDescendants, StepSize := 1, PcgsAutomorphisms, RankInitialSegmentSubgroups := 4);; anupq-3.3.3/examples/5gp-SP-Rel-i0000644000175100017510000000304615111342310015766 0ustar runnerrunner#Example: "5gp-SP-Rel-i" . . . based on: isom/5gp #vars: F, rels, procId; #options: OutputLevel, ClassBound, StandardPresentationFile F := FreeGroup("a", "b"); rels := ["a^25", "[b, a, a, a]", "b^5*[b, a, a]^-1"]; procId := PqStart(F : Prime := 5, Relators := rels);; #comment: set a different print level by supplying #add for if set and ok #PqSetOutputLevel(procId, value);; PqSPComputePcpAndPCover(procId : ClassBound := 2);; #comment: set a different `ClassBound' by supplying #comment: also save the presentation to a file by supplying PqSPStandardPresentation(procId, [ [[1,0,0,1], [0,1,0,0]], [[1,0,0,0], [0,1,0,1]], [[1,3,0,0], [0,1,0,0]], [[1,3,0,0], [0,4,0,0]], [[1,2,0,0], [0,3,0,0]], [[4,0,0,0], [0,1,0,0]], [[3,0,0,0], [0,1,0,0]] ] : # options #add for if set and ok # StandardPresentationFile := value, #sub for <10> if set ClassBound := 10, PcgsAutomorphisms);; anupq-3.3.3/examples/2gp-Rel0000644000175100017510000000073015111342310015212 0ustar runnerrunner#Example: "2gp-Rel" . . . based on: examples/2gp #Construction of largest quotient of class 6 of a 2-group #vars: F, procId, rels; #options: OutputLevel F := FreeGroup("a", "b"); rels := [ "[b, a, a]", "(a * b * a)^4"]; #alt: do #procId := PqStart( F ); #comment: set a different print level by supplying #alt: sub for Pq( F : Prime := 2, ClassBound := 6, Relators := rels, #sub for <1> if set and ok OutputLevel := 1 ); anupq-3.3.3/examples/Nott-APG-Rel-i0000644000175100017510000000363315111342310016306 0ustar runnerrunner#Example: "Nott-APG-Rel-i" . . . based on: examples/pga_interactive #Start point for Nottingham group #Interactive construction of 40 5-groups of order 5^7 #vars: F, rels, procId; #options: OutputLevel, OutputFile F := FreeGroup("a", "b"); rels := ["a^5", "b^5", "[b, a, b]"]; procId := PqStart(F : Prime := 5, Relators := rels);; #comment: set a different print level by supplying PqPcPresentation(procId : ClassBound := 3, #sub for <1> if set and ok OutputLevel := 1);; PqComputePCover(procId);; #comment: save the presentation to a different file by supplying #sub for if set and ok PqSavePcPresentation(procId, ANUPQData.outfile);; PqPGSupplyAutomorphisms(procId, [ [[1,0,0,0], [0,1,0,1]], [[1,1,0,0], [0,1,0,1]], [[1,0,0,0], [0,4,0,0]], [[1,0,0,0], [0,2,0,0]], [[4,0,0,0], [0,1,0,0]], [[2,0,0,0], [0,1,0,0]] ]);; PqPGConstructDescendants(procId : ClassBound := 4, CapableDescendants, StepSize := 1, PcgsAutomorphisms, RankInitialSegmentSubgroups := 4); PqPGSetDescendantToPcp(procId, 4, 1);; PqAPGDegree(procId, 2, 3); PqAPGPermutations(procId);; PqAPGOrbits(procId : CustomiseOutput := rec(orbit := [1])); PqAPGOrbitRepresentatives(procId);; PqPGSetDescendantToPcp(procId);; PqDisplayPcPresentation(procId);; PqAPGSingleStage(procId : StepSize:=2, BasicAlgorithm, CustomiseOutput := rec());; anupq-3.3.3/examples/G2-SP-Rel-i0000644000175100017510000000211015111342310015532 0ustar runnerrunner#Example: "G2-SP-Rel-i" . . . based on: isom/G_2.com #vars: F, rels, procId; #options: OutputLevel, ClassBound, StandardPresentationFile F := FreeGroup("a", "b"); rels := ["b^4", "b^2 * [b, a, a]^-1", "b * (a^2 * b^-1 * a^2)^-1" ]; procId := PqStart(F : Prime := 2, Relators := rels);; #comment: set a different print level by supplying #add for if set and ok #PqSetOutputLevel(procId, value);; PqSPComputePcpAndPCover(procId : ClassBound := 1);; #comment: set a different `ClassBound' by supplying #comment: also save the presentation to a file by supplying PqSPStandardPresentation(procId, [ [[0,1], [1,1]], [[0,1], [1,0]] ] : # options #add for if set and ok # StandardPresentationFile := value, #sub for <12> if set ClassBound := 12, PcgsAutomorphisms);; anupq-3.3.3/examples/Pq0000644000175100017510000000323515111342310014365 0ustar runnerrunner#Example: "Pq" . . . based on manual example illustrating `Pq' usage #vars: F, a, b, procId1, procId2, procId3, procId4, G, R, H, rels; #options: F := FreeGroup("a", "b"); a := F.1; b := F.2; #alt: do #procId1 := PqStart( F ); #alt: sub for Pq( F : Prime := 2, ClassBound := 3 ); ## Now let us get a p-quotient of an fp group G := F / [a^4, b^4]; #alt: do #procId2 := PqStart( G ); #alt: sub for Pq( G : Prime := 2, ClassBound := 3 ); ## Now let's get a different p-quotient of the same group #alt: sub for Pq( G : Prime := 2, ClassBound := 3, #alt: do # RedoPcp, Exponent := 4 ); ## Now we'll get a p-quotient of another fp group ## which we will redo using the `Relators' option R := [ a^25, Comm(Comm(b, a), a), b^5 ]; H := F / R; #alt: do #procId3 := PqStart( H ); #alt: sub for Pq( H : Prime := 5, ClassBound := 5, Metabelian ); ## Now we redo the previous example using the `Relators' option F := FreeGroup("a", "b"); ## `F' was defined for `Relators'. We use the same strings that GAP uses ## for printing the free group generators. It is *not* necessary to ## predefine: a := F.1; etc. (as it was above). rels := [ "a^25", "[b, a, a]", "b^5" ]; R := PqGAPRelators(F, rels); H := F / R; #alt: sub for Pq( H : Prime := 5, ClassBound := 5, Metabelian, #alt: do # RedoPcp, Relators := rels ); ## Above we could have just passed `F' (rather than `H'): F := FreeGroup("a", "b"); rels := [ "a^25", "[b, a, a]", "b^5" ]; #alt: do #procId4 := PqStart( F ); #alt: sub for Pq( F : Prime := 5, ClassBound := 5, Metabelian, Relators := rels ); anupq-3.3.3/examples/3gp-SP-Rel-i0000644000175100017510000000245715111342310015771 0ustar runnerrunner#Example: "3gp-SP-Rel-i" . . . based on: isom/3gp #vars: F, rels, procId; #options: OutputLevel, ClassBound, StandardPresentationFile F := FreeGroup("x", "y"); rels := ["[x, y, y, y]", "[x, y, x]"]; procId := PqStart(F : Prime := 3, Relators := rels);; #comment: set a different print level by supplying #add for if set and ok #PqSetOutputLevel(procId, value);; PqSPComputePcpAndPCover(procId : ClassBound := 1);; #comment: set a different `ClassBound' by supplying #comment: also save the presentation to a file by supplying PqSPStandardPresentation(procId, [ [[2,0], [0,2]], [[0,2], [1,0]], [[1,2], [2,2]], [[1,0], [2,1]], [[2,0], [0,1]] ] : # options #add for if set and ok # StandardPresentationFile := value, #sub for <10> if set ClassBound := 10, PcgsAutomorphisms);; anupq-3.3.3/examples/IsIsomorphicPGroup-ni0000644000175100017510000000061315111342310020153 0ustar runnerrunner#Example: "IsIsomorphicPGroup-ni" . . . based on manual example #(demonstrates `IsIsomorphicPGroup' usage) #vars: G, P1, P2, P3, P4; #options: G := Group( (1,2,3,4), (1,3) ); P1 := Image( IsomorphismPcGroup( G ) ); P2 := ElementaryAbelianGroup( 8 ); IsIsomorphicPGroup( P1, P2 ); P3 := QuaternionGroup( 8 ); IsIsomorphicPGroup( P1, P3 ); P4 := DihedralGroup( 8 ); IsIsomorphicPGroup( P1, P4 ); anupq-3.3.3/examples/PqDescendants-treetraverse-i0000644000175100017510000000762415111342310021506 0ustar runnerrunner#Example: "PqDescendants-treetraverse-i" . . . based on manual example #(demonstrates how one may use the p-group generation machinery to # traverse a descendants tree, by exploring the 3-groups of rank 2 # and 3-coclass 1 up to 3-class 5.) #vars: G, procId; #options: G := ElementaryAbelianGroup( 9 ); procId := PqStart( G );; ## ## Below, we use the option StepSize in order to construct descendants ## of coclass 1. This is equivalent to setting the StepSize to 1 in ## each descendant calculation. ## ## The elementary abelian group of order 9 has 3 descendants of ## 3-class 2 and 3-coclass 1, as the result of the next command ## shows. ## PqDescendants( procId : StepSize := 1 ); ## ## Now we will compute the descendants of coclass 1 for each of the ## groups above. Then we will compute the descendants of coclass 1 ## of each descendant and so on. Note that the pq program keeps ## one file for each class at a time. For example, the descendants ## calculation for the second group of class 2 overwrites the ## descendant file obtained from the first group of class 2. ## Hence, we have to traverse the descendants tree in depth first ## order. ## PqPGSetDescendantToPcp( procId, 2, 1 );; PqPGExtendAutomorphisms( procId );; PqPGConstructDescendants( procId : StepSize := 1 ); PqPGSetDescendantToPcp( procId, 3, 1 );; PqPGExtendAutomorphisms( procId );; PqPGConstructDescendants( procId : StepSize := 1 ); PqPGSetDescendantToPcp( procId, 4, 1 );; PqPGExtendAutomorphisms( procId );; PqPGConstructDescendants( procId : StepSize := 1 ); ## ## At this point we stop traversing the ``left most'' branch of the ## descendants tree and move upwards. ## PqPGSetDescendantToPcp( procId, 4, 2 );; PqPGExtendAutomorphisms( procId );; PqPGConstructDescendants( procId : StepSize := 1 ); PqPGSetDescendantToPcp( procId, 3, 2 );; PqPGExtendAutomorphisms( procId );; PqPGConstructDescendants( procId : StepSize := 1 ); ## ## The computations above indicate that the descendants subtree under ## the first descendant of the elementary abelian group of order 9 ## will have only one path of infinite length. ## PqPGSetDescendantToPcp( procId, 2, 2 );; PqPGExtendAutomorphisms( procId );; PqPGConstructDescendants( procId : StepSize := 1 ); ## ## We get four descendants here, three of which will turn out to be ## incapable, i.e., they have no descendants and are terminal nodes ## in the descendants tree. ## PqPGSetDescendantToPcp( procId, 2, 3 );; PqPGExtendAutomorphisms( procId );; PqPGConstructDescendants( procId : StepSize := 1 ); ## ## The third descendant of class three is incapable. Let us return ## to the second descendant of class 2. ## PqPGSetDescendantToPcp( procId, 2, 2 );; PqPGExtendAutomorphisms( procId );; PqPGConstructDescendants( procId : StepSize := 1 ); PqPGSetDescendantToPcp( procId, 3, 1 );; PqPGExtendAutomorphisms( procId );; PqPGConstructDescendants( procId : StepSize := 1 ); PqPGSetDescendantToPcp( procId, 3, 2 );; PqPGExtendAutomorphisms( procId );; PqPGConstructDescendants( procId : StepSize := 1 ); ## ## We skip the third descendant for the moment ... ## PqPGSetDescendantToPcp( procId, 3, 4 );; PqPGExtendAutomorphisms( procId );; PqPGConstructDescendants( procId : StepSize := 1 ); ## ## ... and look at it now. ## PqPGSetDescendantToPcp( procId, 3, 3 );; PqPGExtendAutomorphisms( procId );; PqPGConstructDescendants( procId : StepSize := 1 ); ## ## In this branch of the descendant tree we get 6 descendants of class ## three. Of those 5 will turn out to be incapable and one will have ## 7 descendants. ## PqPGSetDescendantToPcp( procId, 4, 1 );; PqPGExtendAutomorphisms( procId );; PqPGConstructDescendants( procId : StepSize := 1 ); PqPGSetDescendantToPcp( procId, 4, 2 );; PqPGExtendAutomorphisms( procId );; PqPGConstructDescendants( procId : StepSize := 1 ); PqPGSetDescendantToPcp( procId, 4, 3 );; PqPGExtendAutomorphisms( procId );; PqPGConstructDescendants( procId : StepSize := 1 ); anupq-3.3.3/examples/7gp-PG-i0000644000175100017510000000133515111342310015233 0ustar runnerrunner#Example: "7gp-PG-i" . . . based on: examples/pga_7gp #Descendants of C7 x C7 #vars: F, procId; #options: OutputLevel F := FreeGroup("a", "b"); procId := PqStart(F : Prime := 7);; #comment: set a different print level by supplying PqPcPresentation(procId : ClassBound := 1, #sub for <1> if set and ok OutputLevel := 1);; PqComputePCover(procId);; PqPGSupplyAutomorphisms(procId, [ [[3,0], [0,1]], [[6,1], [6,0]] ]);; PqPGConstructDescendants(procId : ClassBound := 2, CapableDescendants, StepSize := 1);; anupq-3.3.3/examples/2gp-PG-i0000644000175100017510000000144415111342310015227 0ustar runnerrunner#Example: "2gp-PG-i" . . . based on: examples/pga_2gp #All descendants of C2 x C2 up to order 2^8 #vars: F, procId; #options: OutputLevel F := FreeGroup("a", "b"); procId := PqStart(F : Prime := 2);; #comment: set a different print level by supplying PqPcPresentation(procId : ClassBound := 1, #sub for <1> if set and ok OutputLevel := 1);; PqComputePCover(procId);; PqPGSupplyAutomorphisms(procId, [ [[0,1], [1,1]], [[0,1], [1,0]] ]);; PqPGConstructDescendants(procId : ClassBound := 7, OrderBound := 8, PcgsAutomorphisms, BasicAlgorithm);; anupq-3.3.3/examples/7gp-SP-Rel-i0000644000175100017510000000312015111342310015761 0ustar runnerrunner#Example: "7gp-SP-Rel-i" . . . based on: isom/7gp.com #vars: F, rels, procId; #options: OutputLevel, ClassBound, StandardPresentationFile F := FreeGroup("a", "b"); rels := ["a^7", "b^7 * [b, a, a]^-1", "[b, a, b, b, b, b, b]"]; procId := PqStart(F : Prime := 7, Relators := rels);; #comment: set a different print level by supplying #add for if set and ok #PqSetOutputLevel(procId, value);; PqSPComputePcpAndPCover(procId : ClassBound := 3);; #comment: set a different `ClassBound' by supplying #comment: also save the presentation to a file by supplying PqSPStandardPresentation(procId, [ [[1,0,0,0,1], [0,1,0,0,0]], [[1,0,0,0,0], [0,1,0,0,1]], [[1,0,0,0,0], [0,1,0,0,1]], [[1,0,0,0,0], [6,1,0,0,0]], [[6,0,0,0,0], [2,1,0,0,0]], [[6,0,0,0,0], [0,6,0,0,0]], [[6,0,0,0,0], [4,5,0,0,0]] ] : # options #add for if set and ok # StandardPresentationFile := value, #sub for <10> if set ClassBound := 10, PcgsAutomorphisms);; anupq-3.3.3/examples/2gp-PG-2-i0000644000175100017510000000155015111342310015364 0ustar runnerrunner#Example: "2gp-PG-2-i" . . . based on: examples/pga_example #All class 3 descendants of C2 x C2 with extensive output #vars: F, procId; #options: OutputLevel F := FreeGroup("a", "b"); procId := PqStart(F : Prime := 2);; #comment: set a different print level by supplying PqPcPresentation(procId : ClassBound := 1, #sub for <1> if set and ok OutputLevel := 1);; PqComputePCover(procId);; PqPGSupplyAutomorphisms(procId, [ [[0,1], [1,1]], [[0,1], [1,0]] ]);; PqPGConstructDescendants(procId : ClassBound := 3, PcgsAutomorphisms, CustomiseOutput := rec(group := [,,1], autgroup := [,1]));; anupq-3.3.3/examples/PqDescendantsTreeCoclassOne-9-i0000644000175100017510000000062515111342310021727 0ustar runnerrunner#Example: "PqDescendantsTreeCoclassOne-9-i" . based on manual example #(demonstrates how one may use `PqDescendantsTreeCoclassOne' to # develop a descendants tree, by generating the 3-groups of rank 2 # and 3-coclass 1 up to 3-class 5. Most effective in XGAP.) #vars: G, procId; #options: G := ElementaryAbelianGroup( 9 ); procId := PqStart( G );; PqDescendantsTreeCoclassOne( procId : TreeDepth := 5 );; anupq-3.3.3/examples/PqEpimorphism0000644000175100017510000000040715111342310016600 0ustar runnerrunner#Example: "PqEpimorphism" . . . based on `PqEpimorphism' manual example #vars: F, procId, phi; #options: F := FreeGroup (2, "F"); #alt: do #procId := PqStart( F ); #alt: sub for phi := PqEpimorphism( F : Prime := 5, ClassBound := 2 ); Image( phi ); anupq-3.3.3/examples/11gp-SP-a-Rel-1-i0000644000175100017510000000311515111342310016414 0ustar runnerrunner#Example: "11gp-SP-a-Rel-1-i" . . . based on: isom/11gp_a.com #(like "11gp-SP-a-Rel-i" but the initial input presentation # is only to class 1). #vars: F, rels, procId; #options: OutputLevel, ClassBound, StandardPresentationFile F := FreeGroup("a", "b"); rels := ["a^11", "b^11*[b, a, a]^-2", "[b, a, b, b, b, b]"]; procId := PqStart(F : Prime := 11, Relators := rels);; #comment: set a different print level by supplying #sub for <0> if set and ok PqSetOutputLevel(procId, 0);; PqSPComputePcpAndPCover(procId : ClassBound := 1);; #comment: set a different `ClassBound' by supplying #comment: also save the presentation to a file by supplying PqSPStandardPresentation(procId, [ [[1,0], [0,1]], [[1,0], [0,1]], [[1,0], [0,1]], [[1,0], [3,1]], [[1,0], [9,3]], [[1,0], [6,6]], [[10,0], [2,1]] ] : # options #add for if set and ok # StandardPresentationFile := value, #sub for <19> if set ClassBound := 19, PcgsAutomorphisms);; anupq-3.3.3/examples/B2-50000644000175100017510000000066715111342310014420 0ustar runnerrunner#Example: "B2-5" . . . based on: examples/B2-5 #Construction of B(2,5) #i.e. largest finite 2-generator group of exponent 5 #vars: F, procId; #options: OutputLevel F := FreeGroup("a", "b"); #alt: do #procId := PqStart( F ); #comment: set a different print level by supplying #alt: sub for Pq( F : Prime := 5, ClassBound := 14, Exponent := 5, #sub for <1> if set and ok OutputLevel := 1 ); anupq-3.3.3/examples/G5-SP-a-Rel-i0000644000175100017510000000304415111342310015762 0ustar runnerrunner#Example: "G5-SP-a-Rel-i" . . . based on: isom/G_5A.com #vars: F, rels, procId; #options: OutputLevel, ClassBound, StandardPresentationFile F := FreeGroup("a", "b"); rels := ["[a, b, b, a]", "[a, b, a]", "b^5"]; procId := PqStart(F : Prime := 5, Relators := rels);; #comment: set a different print level by supplying #add for if set and ok #PqSetOutputLevel(procId, value);; PqSPComputePcpAndPCover(procId : ClassBound := 2);; #comment: set a different `ClassBound' by supplying #comment: also save the presentation to a file by supplying PqSPStandardPresentation(procId, [ [[1,0,0,1], [0,1,0,0]], [[1,0,0,0], [0,1,0,1]], [[1,3,0,0], [0,1,0,0]], [[1,3,0,0], [0,4,0,0]], [[1,2,0,0], [0,3,0,0]], [[4,0,0,0], [0,1,0,0]], [[3,0,0,0], [0,1,0,0]] ] : # options #add for if set and ok # StandardPresentationFile := value, #sub for <10> if set ClassBound := 10, PcgsAutomorphisms);; anupq-3.3.3/examples/11gp-i0000644000175100017510000000146115111342310015002 0ustar runnerrunner#Example: "11gp-i" . . . based on: examples/11gp #vars: F, a, b, c, R, procId; #options: OutputLevel, ClassBound, OutputFile F := FreeGroup("a", "b", "c"); a := F.1; b := F.2; c := F.3; R := [PqLeftNormComm([b, a, a, b, c])^11, PqLeftNormComm([a, b, b, a, b, c])^11, (a * b)^11];; procId := PqStart(F/R : Prime := 11);; #comment: set a different `ClassBound' by supplying #comment: also set a different print level by supplying #sub for <7> if set and ok PqPcPresentation(procId : ClassBound := 7, #sub for <1> if set and ok OutputLevel := 1);; #comment: save the presentation to a different file by supplying #sub for if set and ok PqSavePcPresentation(procId, ANUPQData.outfile);; anupq-3.3.3/examples/2gp-SP-3-Rel-i0000644000175100017510000000227315111342310016124 0ustar runnerrunner#Example: "2gp-SP-3-Rel-i" . . . based on: isom/example.com #vars: F, rels, procId; #options: OutputLevel, ClassBound, StandardPresentationFile F := FreeGroup("a", "b"); rels := ["a^4", "b^2*[b, a, b]^-1", "b * (a^2 * b^-1 * a^2)^-1" ]; procId := PqStart(F : Prime := 2, Relators := rels);; #comment: set a different print level by supplying #add for if set and ok #PqSetOutputLevel(procId, value);; PqSPComputePcpAndPCover(procId : ClassBound := 2);; #comment: set a different `ClassBound' by supplying #comment: also save the presentation to a file by supplying PqSPStandardPresentation(procId, [ [[1,0,0,1], [0,1,0,0]], [[1,0,0,0], [0,1,0,1]], [[1,1,1,0], [0,1,1,1]] ] : # options #add for if set and ok # StandardPresentationFile := value, #sub for <9> if set ClassBound := 9, PcgsAutomorphisms);; anupq-3.3.3/examples/3gp-PG-x-1-i0000644000175100017510000000130115111342310015623 0ustar runnerrunner#Example: "3gp-PG-x-i" . . . based on example from Werner #A `by hand' descendants example #vars: F, procId; #options: OutputLevel F := FreeGroup("a", "b"); procId := PqStart(F : Prime := 3);; #comment: set a different print level by supplying Pq(procId : ClassBound := 1, #sub for <1> if set and ok OutputLevel := 1);; PqPCover(procId);; PqPGSupplyAutomorphisms(procId, [ [[1,1], [0,1]], [[0,1], [1,0]] ]);; PqPGExtendAutomorphisms(procId);; PqPGConstructDescendants(procId : ClassBound := 3, BasicAlgorithm); anupq-3.3.3/examples/PqDescendants-30000644000175100017510000000124415111342310016677 0ustar runnerrunner#Example: "PqDescendants-3" . . . based on manual example #(demonstrates `PqDescendants' usage) #We compute all capable descendants of order 25 which have #exponent-5 class at most 3, exponent 5 and are metabelian. #vars: F, procId, G, des; #options: F := FreeGroup( 2, "g" ); G := PcGroupFpGroup( F / [ F.1^5, F.2^5, Comm(F.2, F.1) ] ); #alt: do #procId := PqStart( G ); #alt: sub for des := PqDescendants( G : Metabelian, ClassBound := 3, Exponent := 5, CapableDescendants ); List(des, d -> Length( PCentralSeries( d, 5 ) ) - 1 ); List(des, d -> Length( DerivedSeries( d ) ) ); List(des, d -> Maximum( List( Elements(d), Order ) ) ); anupq-3.3.3/examples/PqDescendantsTreeCoclassOne-16-i0000644000175100017510000000072315111342310022004 0ustar runnerrunner#Example: "PqDescendantsTreeCoclassOne-16-i" . based on manual example #(demonstrates usage of `PqDescendantsTreeCoclassOne', by generating # all descendants of the elementary abelian group of order 16 of # 2-coclass 1 up to 2-class 15. Most effective in XGAP.) #vars: G, procId; #options: G := ElementaryAbelianGroup( 16 ); procId := PqStart( G );; PqDescendantsTreeCoclassOne( procId : TreeDepth := 15, CapableDescendants );; anupq-3.3.3/examples/B5-4.g0000644000175100017510000001461215111342310014642 0ustar runnerrunner########################################################################### ## #W B5-4.g ANUPQ Example Werner Nickel ## ## This file contains code to rebuild the Burnside group B(5,4). This is ## the largest group of exponent 4 generated by 5 elements. It has order ## 2^2728 and p-central class 13. The code is based on an input file ## by M.F.Newman for the pq standalone to construct B(5,4). ## ## The construction here uses the knowledge gained by Newman & O'Brien in ## their initial construction of B(5,4), in particular insight into the ## commutator structure of the group and the knowledge of the p-central ## class and the order of B(5,4). Therefore, the construction here cannot ## be used to prove that B(5,4) has the order and class mentioned above. It ## is merely a reconstruction of the group. ## ## Detailed information can be obtained from the references given in the ## following excerpt from Math Reviews. In particular, for the use of the ## left-normed commutators in the construction the monograph by Vaughan-Lee ## cited below should be consulted. ## ## 97k:20002 20-04 (20D15 20F05) ## Newman, M. F.; O'Brien, E. A. ## Application of computers to questions like those of Burnside II ## Internat. J. Algebra Comput. 6 (1996), no. 5, 593--605. ## ## The paper describes improvements to the ANU $p$-quotient algorithm ## made since the time of the earlier survey on the program (the ## Canberra nilpotent quotient program) (see Part I [G. Havas and ## M. F. Newman, in Burnside groups (Proc. Workshop, Univ. Bielefeld, ## Bielefeld, 1977), 211--230, Lecture Notes in Math., 806, Springer, ## Berlin, 1980; MR 82d:20002], and also the two monographs by ## M. Vaughan-Lee [The restricted Burnside problem, Second edition, ## Oxford Univ. Press, New York, 1993; MR 98b:20047], and C. C. Sims ## [Computation with finitely presented groups, Cambridge Univ. Press, ## Cambridge, 1994; MR 95f:20053]). One main area of change since the ## earlier survey is the use of the collection from the left [see, for ## example, C. R. Leedham-Green and L. H. Soicher, J. Symbolic Comput. 9 ## (1990), no. 5-6, 665--675; MR 92b:20021; M. Vaughan-Lee, J. Symbolic ## Comput. 9 (1990), no. 5-6, 725--733; MR 92c:20065]. ## ## From the solution to the restricted Burnside problem by ## E. I. Zelmanov [Mat. Sb. 182 (1991), no. 4, 568--592; MR 93a:20063], ## the basic Burnside question is that of determining the order of ## $R(d,e)$, the largest finite $d$-generator group of exponent $e$. New ## advances in the algorithm (in particular the use of some of the ## automorphisms of the Burnside groups) are described and the ## restricted Burnside groups $R(5,4)$ and $R(3,5)$ are shown to have ## orders $2^{2728}$ and $5^{2882}$, respectively. ## ## Reviewed by Colin M. Campbell ## #Example: "B5-4.g" . . . by Werner Nickel #. . . . . . . . . . . . and based on a pq input file by M.F.Newman #(constructs the Burnside group B(5,4), which is the largest group of # exponent 4 generated by 5 elements; it has order 2^2728 and p-central # class 13) #Note: It is a construction only and makes use of specialised knowledge #gained by Newman & O'Brien in their investigations of B(5,4). #vars: procId, Relations, class, w, smallclass; #options: OutputFile LoadPackage( "anupq" ); ##You might like to try setting: `SetInfoLevel( InfoANUPQ, 3 );' procId := PqStart( FreeGroup(5) : Exponent := 4, Prime := 2 );; Pq( procId : ClassBound := 2 ); PqSupplyAutomorphisms( procId, [ [ [ 1, 1, 0, 0, 0], #1st automorphism [ 0, 1, 0, 0, 0], [ 0, 0, 1, 0, 0], [ 0, 0, 0, 1, 0], [ 0, 0, 0, 0, 1] ], [ [ 0, 0, 0, 0, 1], #2nd automorphism [ 1, 0, 0, 0, 0], [ 0, 1, 0, 0, 0], [ 0, 0, 1, 0, 0], [ 0, 0, 0, 1, 0] ] ] );; Relations := [ [], ## class 1 [], ## class 2 [], ## class 3 [], ## class 4 [], ## class 5 [], ## class 6 ## class 7 [ [ "x2","x1","x1","x3","x4","x4","x4" ] ], ## class 8 [ [ "x2","x1","x1","x3","x4","x5","x5","x5" ] ], ## class 9 [ [ "x2","x1","x1","x3","x4","x4","x5","x5","x5" ], [ "x2","x1","x1","x2","x3","x4","x5","x5","x5" ], [ "x2","x1","x1","x3","x3","x4","x5","x5","x5" ] ], ## class 10 [ [ "x2","x1","x1","x2","x3","x3","x4","x5","x5","x5" ], [ "x2","x1","x1","x3","x3","x4","x4","x5","x5","x5" ] ], ## class 11 [ [ "x2","x1","x1","x2","x3","x3","x4","x4","x5","x5","x5" ], [ "x2","x1","x1","x2","x3","x1","x3","x4","x2","x4","x3" ] ], ## class 12 [ [ "x2","x1","x1","x2","x3","x1","x3","x4","x2","x5","x5","x5" ], [ "x2","x1","x1","x3","x2","x4","x3","x5","x4","x5","x5","x5" ] ], ## class 13 [ [ "x2","x1","x1","x2","x3","x1","x3","x4","x2","x4","x5","x5","x5" ] ] ]; for class in [ 3 .. 13 ] do Print( "Computing class ", class, "\n" ); PqSetupTablesForNextClass( procId ); for w in [ class, class-1 .. 7 ] do PqAddTails( procId, w ); PqDisplayPcPresentation( procId ); if Relations[ w ] <> [] then # recalculate automorphisms PqExtendAutomorphisms( procId ); for r in Relations[ w ] do Print( "Collecting ", r, "\n" ); PqCommutator( procId, r, 1 ); PqEchelonise( procId ); PqApplyAutomorphisms( procId, 15 ); #queue factor = 15 od; PqEliminateRedundantGenerators( procId ); fi; PqComputeTails( procId, w ); od; PqDisplayPcPresentation( procId ); smallclass := Minimum( class, 6 ); for w in [ smallclass, smallclass-1 .. 2 ] do PqTails( procId, w ); od; # recalculate automorphisms PqExtendAutomorphisms( procId ); PqCollect( procId, "x5^4" ); PqEchelonise( procId ); PqApplyAutomorphisms( procId, 15 ); #queue factor = 15 PqEliminateRedundantGenerators( procId ); PqDisplayPcPresentation( procId ); od; #comment: save the presentation to a different file by supplying #sub for <"/tmp/B54"> if set and ok PqWritePcPresentation( procId, "/tmp/B54" );; PqQuit( procId );; anupq-3.3.3/examples/README0000644000175100017510000001451315111342310014743 0ustar runnerrunnerHere we describe the format of the examples. Firstly, each file *can* be read using `Read', but `PqExample' does a little more (by echoing to the screen) and requires the following: 0. Blank lines are ok, but must consist of only a new-line (and no other white-space. 1. The file can start with any number of commented out lines followed by a line of form: #Example . . . where is the name of the file in a pair of double-quotes and should say something like `based on ...'. This line can be followed by any number of commented out lines followed by: #vars: ; where is a comma (and/or blank) separated list of variables used in the example. Missing one will cause the possible over-writing of a user variable. This line should be no longer than 72 characters. A number of examples have a stating `based on /...' where is `examples' or `isom' which are sub-directories of the `standalone' directory. 2. The next line must be of form: #options: (like 1. except should contain a list of the options of the example that the user can provide, to change the behaviour of the example). 3. Any statement for which GAP does not produce output should terminate with a double-;. `PqExample' tries to emulate a user typing the commands and when executing a line of input displays all the output a user would normally see. A double-; tells `PqExample' not to try to get output from the command on executing it. All statements terminating with a double-; are displayed with a single ;. 4. Comments that you want the user to see should appear after a double-#. On execution/printing of the example the user only sees one #. All other lines beginning with # are special: 5. A line of form: #comment: set a different ... by supplying <...> is ignored when the example is executed but Info-ed at `InfoANUPQ' level 1 when printed as: #I In the next command, you may set a different ... by #I supplying to `PqExample' the option: `...' where the ... is anything in each case but every other word should be something that makes sense in a similarly substituted sentence. The word `supplying' and a pair of angle brackets (<>) enclosing an option *must* be present. 6. A line of form: #sub <