Quellcodebibliothek Statistik Leitseite products/Sources/formale Sprachen/GAP/pkg/anupq/doc/   (Algebra von RWTH Aachen Version 4.15.1©)  Datei vom 28.7.2025 mit Größe 173 kB image not shown  

Impressum chap5_mj.html

  Sprache: HTML
 

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


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

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

<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en">
<head>
<script type="text/javascript"
  src="https://cdn.jsdelivr.net/npm/mathjax@2/MathJax.js?config=TeX-AMS-MML_HTMLorMML">
</script>
<title>GAP (ANUPQ) - Chapter 5: Interactive ANUPQ functions</title>
<meta http-equiv="content-type" content="text/html; charset=UTF-8" />
<meta name="generator" content="GAPDoc2HTML" />
<link rel="stylesheet" type="text/css" href="manual.css" />
<script src="manual.js" type="text/javascript"></script>
<script type="text/javascript">overwriteStyle();</script>
</head>
<body class="chap5"  onload="jscontent()">


<div class="chlinktop"><span class="chlink1">Goto Chapter: </span><a href="chap0_mj.html">Top</a>  <a href="chap1_mj.html">1</a>  <a href="chap2_mj.html">2</a>  <a href="chap3_mj.html">3</a>  <a href="chap4_mj.html">4</a>  <a href="chap5_mj.html">5</a>  <a href="chap6_mj.html">6</a>  <a href="chap7_mj.html">7</a>  <a href="chapA_mj.html">A</a>  <a href="chapBib_mj.html">Bib</a>  <a href="chapInd_mj.html">Ind</a>  </div>

<div class="chlinkprevnexttop"> <a href="chap0_mj.html">[Top of Book]</a>   <a href="chap0_mj.html#contents">[Contents]</a>    <a href="chap4_mj.html">[Previous Chapter]</a>    <a href="chap6_mj.html">[Next Chapter]</a>   </div>

<p id="mathjaxlink" class="pcenter"><a href="chap5.html">[MathJax off]</a></p>
<p><a id="X842C13C27B941744" name="X842C13C27B941744"></a></p>
<div class="ChapSects"><a href="chap5_mj.html#X842C13C27B941744">5 <span class="Heading">Interactive ANUPQ functions</span></a>
<div class="ContSect"><span class="tocline"><span class="nocss"> </span><a href="chap5_mj.html#X7935CDAD7936CA0A">5.1 <span class="Heading">Starting and Stopping Interactive ANUPQ Processes</span></a>
</span>
<div class="ContSSBlock">
<span class="ContSS"><br /><span class="nocss">  </span><a href="chap5_mj.html#X83B2EC237F37623C">5.1-1 PqStart</a></span>
<span class="ContSS"><br /><span class="nocss">  </span><a href="chap5_mj.html#X79DB761185BAB9C8">5.1-2 PqQuit</a></span>
<span class="ContSS"><br /><span class="nocss">  </span><a href="chap5_mj.html#X7FF8F2657B1B008E">5.1-3 PqQuitAll</a></span>
</div></div>
<div class="ContSect"><span class="tocline"><span class="nocss"> </span><a href="chap5_mj.html#X7EE8000A800CEE2D">5.2 <span class="Heading">Interactive ANUPQ Process Utility Functions</span></a>
</span>
<div class="ContSSBlock">
<span class="ContSS"><br /><span class="nocss">  </span><a href="chap5_mj.html#X8558B20A80B999AE">5.2-1 PqProcessIndex</a></span>
<span class="ContSS"><br /><span class="nocss">  </span><a href="chap5_mj.html#X7E4A56D67C865291">5.2-2 PqProcessIndices</a></span>
<span class="ContSS"><br /><span class="nocss">  </span><a href="chap5_mj.html#X7C103DF78435AEC7">5.2-3 IsPqProcessAlive</a></span>
</div></div>
<div class="ContSect"><span class="tocline"><span class="nocss"> </span><a href="chap5_mj.html#X823D2BBF7C4515D4">5.3 <span class="Heading">Interactive Versions of Non-interactive ANUPQ Functions</span></a>
</span>
<div class="ContSSBlock">
<span class="ContSS"><br /><span class="nocss">  </span><a href="chap5_mj.html#X85408C4C790439E7">5.3-1 Pq</a></span>
<span class="ContSS"><br /><span class="nocss">  </span><a href="chap5_mj.html#X839E6F578227A8EA">5.3-2 PqEpimorphism</a></span>
<span class="ContSS"><br /><span class="nocss">  </span><a href="chap5_mj.html#X7AA64A2F8509A39A">5.3-3 PqPCover</a></span>
<span class="ContSS"><br /><span class="nocss">  </span><a href="chap5_mj.html#X805F32618005C087">5.3-4 PqStandardPresentation</a></span>
<span class="ContSS"><br /><span class="nocss">  </span><a href="chap5_mj.html#X791392977B2D692D">5.3-5 EpimorphismPqStandardPresentation</a></span>
<span class="ContSS"><br /><span class="nocss">  </span><a href="chap5_mj.html#X795817217C53AB89">5.3-6 PqDescendants</a></span>
<span class="ContSS"><br /><span class="nocss">  </span><a href="chap5_mj.html#X80CCF6D379E5A3B4">5.3-7 PqSetPQuotientToGroup</a></span>
</div></div>
<div class="ContSect"><span class="tocline"><span class="nocss"> </span><a href="chap5_mj.html#X857F050C832A1FE4">5.4 <span class="Heading">Low-level Interactive ANUPQ functions based omenu items of the
pq program</span></a>
</span>
</div>
<div class="ContSect"><span class="tocline"><span class="nocss"> </span><a href="chap5_mj.html#X868B10557D470CF6">5.5 <span class="Heading">General commands</span></a>
</span>
<div class="ContSSBlock">
<span class="ContSS"><br /><span class="nocss">  </span><a href="chap5_mj.html#X7DE2F6C686C672DD">5.5-1 PqNrPcGenerators</a></span>
<span class="ContSS"><br /><span class="nocss">  </span><a href="chap5_mj.html#X87FF98867E8FFB3C">5.5-2 PqFactoredOrder</a></span>
<span class="ContSS"><br /><span class="nocss">  </span><a href="chap5_mj.html#X7B4FC9E380001A71">5.5-3 PqOrder</a></span>
<span class="ContSS"><br /><span class="nocss">  </span><a href="chap5_mj.html#X87C7F7EB7C10DC4B">5.5-4 PqPClass</a></span>
<span class="ContSS"><br /><span class="nocss">  </span><a href="chap5_mj.html#X7EA3B6917908C20A">5.5-5 PqWeight</a></span>
<span class="ContSS"><br /><span class="nocss">  </span><a href="chap5_mj.html#X79862B83817E20E1">5.5-6 PqCurrentGroup</a></span>
<span class="ContSS"><br /><span class="nocss">  </span><a href="chap5_mj.html#X805A50687D82B9EC">5.5-7 PqDisplayPcPresentation</a></span>
<span class="ContSS"><br /><span class="nocss">  </span><a href="chap5_mj.html#X80410979854280E1">5.5-8 PqSetOutputLevel</a></span>
<span class="ContSS"><br /><span class="nocss">  </span><a href="chap5_mj.html#X7B8C72B37AE667F7">5.5-9 PqEvaluateIdentities</a></span>
</div></div>
<div class="ContSect"><span class="tocline"><span class="nocss"> </span><a href="chap5_mj.html#X7BDD5B278719C630">5.6 <span class="Heading">Commands from the Main <span class="SimpleMath">\(p\)</span>-Quotient menu</span></a>
</span>
<div class="ContSSBlock">
<span class="ContSS"><br /><span class="nocss">  </span><a href="chap5_mj.html#X7BF135DD84A781EB">5.6-1 PqPcPresentation</a></span>
<span class="ContSS"><br /><span class="nocss">  </span><a href="chap5_mj.html#X7D947CEA82C44898">5.6-2 PqSavePcPresentation</a></span>
<span class="ContSS"><br /><span class="nocss">  </span><a href="chap5_mj.html#X7FD001C0798EF219">5.6-3 PqRestorePcPresentation</a></span>
<span class="ContSS"><br /><span class="nocss">  </span><a href="chap5_mj.html#X832F69597C095A27">5.6-4 PqNextClass</a></span>
<span class="ContSS"><br /><span class="nocss">  </span><a href="chap5_mj.html#X7CF9DF7A84D387CB">5.6-5 PqComputePCover</a></span>
</div></div>
<div class="ContSect"><span class="tocline"><span class="nocss"> </span><a href="chap5_mj.html#X7D27BE937B1DE16E">5.7 <span class="Heading">Commands from the Advanced <span class="SimpleMath">\(p\)</span>-Quotient menu</span></a>
</span>
<div class="ContSSBlock">
<span class="ContSS"><br /><span class="nocss">  </span><a href="chap5_mj.html#X8633356078CA4115">5.7-1 PqCollect</a></span>
<span class="ContSS"><br /><span class="nocss">  </span><a href="chap5_mj.html#X86CCB77281FDC0FC">5.7-2 PqSolveEquation</a></span>
<span class="ContSS"><br /><span class="nocss">  </span><a href="chap5_mj.html#X789B120B7E2F3017">5.7-3 PqCommutator</a></span>
<span class="ContSS"><br /><span class="nocss">  </span><a href="chap5_mj.html#X7A61A15E78F52743">5.7-4 PqSetupTablesForNextClass</a></span>
<span class="ContSS"><br /><span class="nocss">  </span><a href="chap5_mj.html#X84F7DD8582B368D3">5.7-5 PqTails</a></span>
<span class="ContSS"><br /><span class="nocss">  </span><a href="chap5_mj.html#X8389F6437ED634B8">5.7-6 PqComputeTails</a></span>
<span class="ContSS"><br /><span class="nocss">  </span><a href="chap5_mj.html#X83CD6D888372DFB8">5.7-7 PqAddTails</a></span>
<span class="ContSS"><br /><span class="nocss">  </span><a href="chap5_mj.html#X82AA8FAE85826BB9">5.7-8 PqDoConsistencyChecks</a></span>
<span class="ContSS"><br /><span class="nocss">  </span><a href="chap5_mj.html#X7A01EE0382689928">5.7-9 PqCollectDefiningRelations</a></span>
<span class="ContSS"><br /><span class="nocss">  </span><a href="chap5_mj.html#X7C2B4C1E7BEB19D5">5.7-10 PqCollectWordInDefiningGenerators</a></span>
<span class="ContSS"><br /><span class="nocss">  </span><a href="chap5_mj.html#X7DB05AA587D7A052">5.7-11 PqCommutatorDefiningGenerators</a></span>
<span class="ContSS"><br /><span class="nocss">  </span><a href="chap5_mj.html#X80E563A97EDE083E">5.7-12 PqDoExponentChecks</a></span>
<span class="ContSS"><br /><span class="nocss">  </span><a href="chap5_mj.html#X7BBAB2787B305516">5.7-13 PqEliminateRedundantGenerators</a></span>
<span class="ContSS"><br /><span class="nocss">  </span><a href="chap5_mj.html#X783E53B5853F45E6">5.7-14 PqRevertToPreviousClass</a></span>
<span class="ContSS"><br /><span class="nocss">  </span><a href="chap5_mj.html#X8265A6DB81CD24DB">5.7-15 PqSetMaximalOccurrences</a></span>
<span class="ContSS"><br /><span class="nocss">  </span><a href="chap5_mj.html#X87A35ABB7E11595E">5.7-16 PqSetMetabelian</a></span>
<span class="ContSS"><br /><span class="nocss">  </span><a href="chap5_mj.html#X7C7D17F878AA1BAA">5.7-17 PqDoConsistencyCheck</a></span>
<span class="ContSS"><br /><span class="nocss">  </span><a href="chap5_mj.html#X843953F48319FDE1">5.7-18 PqCompact</a></span>
<span class="ContSS"><br /><span class="nocss">  </span><a href="chap5_mj.html#X80344EEC78A09ACF">5.7-19 PqEchelonise</a></span>
<span class="ContSS"><br /><span class="nocss">  </span><a href="chap5_mj.html#X852947327FC39DDF">5.7-20 PqSupplyAutomorphisms</a></span>
<span class="ContSS"><br /><span class="nocss">  </span><a href="chap5_mj.html#X7B919B537C042DAD">5.7-21 PqExtendAutomorphisms</a></span>
<span class="ContSS"><br /><span class="nocss">  </span><a href="chap5_mj.html#X7CFD54657DE4BD39">5.7-22 PqApplyAutomorphisms</a></span>
<span class="ContSS"><br /><span class="nocss">  </span><a href="chap5_mj.html#X81A3D5BF87A34934">5.7-23 PqDisplayStructure</a></span>
<span class="ContSS"><br /><span class="nocss">  </span><a href="chap5_mj.html#X853834B478C4EEE2">5.7-24 PqDisplayAutomorphisms</a></span>
<span class="ContSS"><br /><span class="nocss">  </span><a href="chap5_mj.html#X80687A138626EB2D">5.7-25 PqWritePcPresentation</a></span>
</div></div>
<div class="ContSect"><span class="tocline"><span class="nocss"> </span><a href="chap5_mj.html#X7B94EDA385FDD904">5.8 <span class="Heading">Commands from the Standard Presentation menu</span></a>
</span>
<div class="ContSSBlock">
<span class="ContSS"><br /><span class="nocss">  </span><a href="chap5_mj.html#X78D1963D85C71B7B">5.8-1 PqSPComputePcpAndPCover</a></span>
<span class="ContSS"><br /><span class="nocss">  </span><a href="chap5_mj.html#X876F30187E89E467">5.8-2 PqSPStandardPresentation</a></span>
<span class="ContSS"><br /><span class="nocss">  </span><a href="chap5_mj.html#X7E1B2B088322F48A">5.8-3 PqSPSavePresentation</a></span>
<span class="ContSS"><br /><span class="nocss">  </span><a href="chap5_mj.html#X81D2F9FF7C241D1E">5.8-4 PqSPCompareTwoFilePresentations</a></span>
<span class="ContSS"><br /><span class="nocss">  </span><a href="chap5_mj.html#X7D1277E584590ECE">5.8-5 PqSPIsomorphism</a></span>
</div></div>
<div class="ContSect"><span class="tocline"><span class="nocss"> </span><a href="chap5_mj.html#X8490031B7AA7F237">5.9 <span class="Heading">Commands from the Main <span class="SimpleMath">\(p\)</span>-Group Generation menu</span></a>
</span>
<div class="ContSSBlock">
<span class="ContSS"><br /><span class="nocss">  </span><a href="chap5_mj.html#X794A8D667A9D725A">5.9-1 PqPGSupplyAutomorphisms</a></span>
<span class="ContSS"><br /><span class="nocss">  </span><a href="chap5_mj.html#X87F251077C65B6DD">5.9-2 PqPGExtendAutomorphisms</a></span>
<span class="ContSS"><br /><span class="nocss">  </span><a href="chap5_mj.html#X82FD51A27D269E43">5.9-3 PqPGConstructDescendants</a></span>
<span class="ContSS"><br /><span class="nocss">  </span><a href="chap5_mj.html#X7E9D511385D48A98">5.9-4 PqPGSetDescendantToPcp</a></span>
</div></div>
<div class="ContSect"><span class="tocline"><span class="nocss"> </span><a href="chap5_mj.html#X7E8FBC2D83C43481">5.10 <span class="Heading">Commands from the Advanced <span class="SimpleMath">\(p\)</span>-Group Generation menu</span></a>
</span>
<div class="ContSSBlock">
<span class="ContSS"><br /><span class="nocss">  </span><a href="chap5_mj.html#X7E539E4B78A6CE8D">5.10-1 PqAPGDegree</a></span>
<span class="ContSS"><br /><span class="nocss">  </span><a href="chap5_mj.html#X7F1182A77AB7650C">5.10-2 PqAPGPermutations</a></span>
<span class="ContSS"><br /><span class="nocss">  </span><a href="chap5_mj.html#X7DD9E7507AA888CC">5.10-3 PqAPGOrbits</a></span>
<span class="ContSS"><br /><span class="nocss">  </span><a href="chap5_mj.html#X795A756C78BE5923">5.10-4 PqAPGOrbitRepresentatives</a></span>
<span class="ContSS"><br /><span class="nocss">  </span><a href="chap5_mj.html#X7E5D6D5782FE190E">5.10-5 PqAPGSingleStage</a></span>
</div></div>
<div class="ContSect"><span class="tocline"><span class="nocss"> </span><a href="chap5_mj.html#X84A92E8087762DEE">5.11 <span class="Heading">Primitive Interactive ANUPQ Process Read/Write Functions</span></a>
</span>
<div class="ContSSBlock">
<span class="ContSS"><br /><span class="nocss">  </span><a href="chap5_mj.html#X8464AF7E83A523C1">5.11-1 PqRead</a></span>
<span class="ContSS"><br /><span class="nocss">  </span><a href="chap5_mj.html#X7ADD82207D049A87">5.11-2 PqReadAll</a></span>
<span class="ContSS"><br /><span class="nocss">  </span><a href="chap5_mj.html#X7EBF3C3681671879">5.11-3 PqReadUntil</a></span>
<span class="ContSS"><br /><span class="nocss">  </span><a href="chap5_mj.html#X83CBE77F78057E21">5.11-4 PqWrite</a></span>
</div></div>
</div>

<h3>5 <span class="Heading">Interactive ANUPQ functions</span></h3>

<p>Here we describe the interactive functions defined by the <strong class="pkg">ANUPQ</strong> package, i.e. the functions that manipulate and initiate interactive <strong class="pkg">ANUPQ</strong> processes. These are functions that extract information via a dialogue with a running <code class="code">pq</code> process (process used in the UNIX sense). Occasionally, a user needs the <q>next step</q>; the functions provided in this chapter make use of data from previous steps retained by the <code class="code">pq</code> program, thus allowing the user to interact with the <code class="code">pq</code> program like one can when one uses the <code class="code">pq</code> program as a stand-alone (see <code class="code">guide.dvi</code> in the <code class="code">standalone-doc</code> directory).</p>

<p>An interactive <strong class="pkg">ANUPQ</strong> process is initiated by <code class="code">PqStart</code> and terminated via <code class="code">PqQuit</code>; these functions are described in ection <a href="chap5_mj.html#X7935CDAD7936CA0A"><span class="RefLink"><span class="Heading">Starting and Stopping Interactive ANUPQ Processes</span></span></a>.</p>

<p>Each interactive <strong class="pkg">ANUPQ</strong> function that manipulates an already started interactive <strong class="pkg">ANUPQ</strong> process, has a form where the first argument is the integer <var class="Arg">i</var> returned by the initiating <code class="code">PqStart</codecommand, and a second form with one argument fewer (where the integer <var class="Arg">i</var> is discovered by a default mechanism, namely by determining the least integer <var class="Arg">i</var> for which there is a currently active interactive <strong class="pkg">ANUPQ</strong> process). We will thus commonly say that <q>for the <var class="Arg">i</var>th (or default) interactive <strong class="pkg">ANUPQ</strong> process</q> a certain function performs a given action. In each case, it is an error if <var class="Arg">i</var> is not the index of an active interactive process, or there are no current active interactive processes.</p>

<p><em>Notes</em>: The global method of passing options (via <code class="code">PushOptions</code>), should not be used with any of the interactive functions. In fact, the <code class="code">OptionsStack</code> should be empty at the time any of the interactive functions is called.</p>

<p>On <code class="keyw">quit</code>ting <strong class="pkg">GAP</strong>, <code class="code">PqQuitAll();</code> is executed, which terminates all active interactive <strong class="pkg">ANUPQ</strong> processes. If <strong class="pkg">GAP</strong> is killed without <code class="keyw">quit</code>ting, before all interactive <strong class="pkg">ANUPQ</strong> processes are terminated, <em>zombie</em> processes (still living <em>child</em> processes whose <em>parents</em> 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: <code class="code">ps xw | grep pq</code> gives you information on the <code class="code">pq</code> processes corresponding to any interactive <strong class="pkg">ANUPQ</strong> processes started in a <strong class="pkg">GAP</strong> session; you can then do <code class="code">kill <var class="Arg">N</var></code> for each number <var class="Arg">N</var> appearing in the first column of this output).</p>

<p><a id="X7935CDAD7936CA0A" name="X7935CDAD7936CA0A"></a></p>

<h4>5.1 <span class="Heading">Starting and Stopping Interactive ANUPQ Processes</span></h4>

<p><a id="X83B2EC237F37623C" name="X83B2EC237F37623C"></a></p>

<h5>5.1-1 PqStart</h5>

<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ PqStart</code>( <var class="Arg">G</var>, <var class="Arg">workspace:</var> <var class="Arg">options</var> )</td><td class="tdright">( function )</td></tr></table></div>
<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ PqStart</code>( <var class="Arg">G:</var> <var class="Arg">options</var> )</td><td class="tdright">( function )</td></tr></table></div>
<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ PqStart</code>( <var class="Arg">workspace:</var> <var class="Arg">options</var> )</td><td class="tdright">( function )</td></tr></table></div>
<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ PqStart</code>( <var class="Arg">:</var> <var class="Arg">options</var> )</td><td class="tdright">( function )</td></tr></table></div>
<p>activate an iostream for an interactive <strong class="pkg">ANUPQ</strong> process (i.e. <code class="code">PqStart</code> starts up a <code class="code">pq</code> process and opens a <strong class="pkg">GAP</strong> iostream to <q>talk</q> to that process) and returns an integer <var class="Arg">i</var> that can be used to identify that process. The argument <var class="Arg">G</var> should be an <em>fp group</em> or <em>pc group</em> that the user intends to manipulate using interactive <strong class="pkg">ANUPQ</strong> functions. If the function is called without specifying <var class="Arg">G</var>, a group can be read in by using the function <code class="code">PqRestorePcPresentation</code> (see <code class="func">PqRestorePcPresentation</code> (<a href="chap5_mj.html#X7FD001C0798EF219"><span class="RefLink">5.6-3</span></a>)). If <code class="code">PqStart</code> is given an integer argument <var class="Arg">workspace</var>, then the <code class="code">pq</code> program is started up with a workspace (an integer array) of size <var class="Arg">workspace</var> (i.e. <span class="SimpleMath">\(4 \times \textit{workspace}\)</span> bytes in a 32-bit environment); otherwise, the <code class="code">pq</code> program sets a default workspace of <span class="SimpleMath">\(10000000\)</span>.</p>

<p>The only <var class="Arg">options</var> currently recognised by <code class="code">PqStart</code> are <code class="code">Prime</code>, <code class="code">Exponent</code> and <code class="code">Relators</code> (see Chapter <a href="chap6_mj.html#X7B0946E97E7EB359"><span class="RefLink"><span class="Heading">ANUPQ Options</span></span></a> for detailed descriptions of these options) and if provided they are essentially global for the interactive <strong class="pkg">ANUPQ</strong> process, except that any interactive function interacting with the process and passing new values for these options will over-ride the global values.</p>

<p><a id="X79DB761185BAB9C8" name="X79DB761185BAB9C8"></a></p>

<h5>5.1-2 PqQuit</h5>

<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ PqQuit</code>( <var class="Arg">i</var> )</td><td class="tdright">( function )</td></tr></table></div>
<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ PqQuit</code>(  )</td><td class="tdright">( function )</td></tr></table></div>
<p>closes the stream of the <var class="Arg">i</var>th or default interactive <strong class="pkg">ANUPQ</strong> process and unbinds its <code class="code">ANUPQData.io</code> record.</p>

<p><em>Note:</em> It can happen that the <code class="code">pq</code> process, and hence the <strong class="pkg">GAP</strong> iostream assigned to communicate with it, can die, e.g. by the user typing a <code class="code">Ctrl-C</code> while the <code class="code">pq</code> process is engaged in a long calculation. <code class="code">IsPqProcessAlive</code> (see <code class="func">IsPqProcessAlive</code> (<a href="chap5_mj.html#X7C103DF78435AEC7"><span class="RefLink">5.2-3</span></a>)) is provided to check the status of the <strong class="pkg">GAP</strong> iostream (and hence the status of the <code class="code">pq</code> process it was communicating with).</p>

<p><a id="X7FF8F2657B1B008E" name="X7FF8F2657B1B008E"></a></p>

<h5>5.1-3 PqQuitAll</h5>

<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ PqQuitAll</code>(  )</td><td class="tdright">( function )</td></tr></table></div>
<p>is provided as a convenience, to terminate all active interactive <strong class="pkg">ANUPQ</strong> processes with a single command. It is equivalent to executing <code class="code">PqQuit(<var class="Arg">i</var>)</code> for all active interactive <strong class="pkg">ANUPQ</strong> processes <var class="Arg">i</var> (see <code class="func">PqQuit</code> (<a href="chap5_mj.html#X79DB761185BAB9C8"><span class="RefLink">5.1-2</span></a>)).</p>

<p><a id="X7EE8000A800CEE2D" name="X7EE8000A800CEE2D"></a></p>

<h4>5.2 <span class="Heading">Interactive ANUPQ Process Utility Functions</span></h4>

<p><a id="X8558B20A80B999AE" name="X8558B20A80B999AE"></a></p>

<h5>5.2-1 PqProcessIndex</h5>

<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ PqProcessIndex</code>( <var class="Arg">i</var> )</td><td class="tdright">( function )</td></tr></table></div>
<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ PqProcessIndex</code>(  )</td><td class="tdright">( function )</td></tr></table></div>
<p>With argument <var class="Arg">i</var>, which must be a positive integer, <code class="code">PqProcessIndex</code> returns <var class="Arg">i</var> if it corresponds to an active interactive process, or raises an error. With no arguments it returns the default active interactive process or returns <code class="keyw">fail</code> and emits a warning message to <code class="code">Info</code> at <code class="code">InfoANUPQ</code> or <code class="code">InfoWarning</code> level 1.</p>

<p><em>Note:</em> Essentially, an interactive <strong class="pkg">ANUPQ</strong> process <var class="Arg">i</var> is <q>active</q> if <code class="code">ANUPQData.io[<var class="Arg">i</var>]</code> is bound (i.e. we still have some data telling us about it). Also see <code class="func">PqStart</code(<a href="chap5_mj.html#X83B2EC237F37623C"><span class="RefLink">5.1-1</span></a>).</p>

<p><a id="X7E4A56D67C865291" name="X7E4A56D67C865291"></a></p>

<h5>5.2-2 PqProcessIndices</h5>

<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ PqProcessIndices</code>(  )</td><td class="tdright">( function )</td></tr></table></div>
<p>returns the list of integer indices of all active interactive <strong class="pkg">ANUPQ</strong> processes (see <code class="func">PqProcessIndex</code> (<a href="chap5_mj.html#X8558B20A80B999AE"><span class="RefLink">5.2-1</span></a>) for the meaning of <q>active</q>).</p>

<p><a id="X7C103DF78435AEC7" name="X7C103DF78435AEC7"></a></p>

<h5>5.2-3 IsPqProcessAlive</h5>

<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ IsPqProcessAlive</code>( <var class="Arg">i</var> )</td><td class="tdright">( function )</td></tr></table></div>
<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ IsPqProcessAlive</code>(  )</td><td class="tdright">( function )</td></tr></table></div>
<p>return <code class="keyw">true</code> if the <strong class="pkg">GAP</strong> iostream of the <var class="Arg">i</var>th (or default) interactive <strong class="pkg">ANUPQ</strong> process started by <code class="code">PqStart</code> is alive (i.e. can still be written to), or <code class="keyw">false</code>, otherwise. (See the notes for <code class="func">PqStart</code> (<a href="chap5_mj.html#X83B2EC237F37623C"><span class="RefLink">5.1-1</span></a>) and <code class="func">PqQuit</code> (<a href="chap5_mj.html#X79DB761185BAB9C8"><span class="RefLink">5.1-2</span></a>).)</p>

<p>If the user does not yet have a <code class="code">gap></code> prompt then usually the <code class="code">pq</code> program is still away doing something and an <strong class="pkg">ANUPQ</strong> interface function is still waiting for a reply. Typing a <code class="code">Ctrl-C</code> (i.e. holding down the <code class="code">Ctrl</code> key and typing <code class="code">c</code>) will stop the waiting and send <strong class="pkg">GAP</strong> into a <code class="code">break</code>-loop, from which one has no option but to <code class="code">quit;</code>. The typing of <code class="code">Ctrl-C</code>, in such a circumstance, usually causes the stream of the interactive <strong class="pkg">ANUPQ</strong> process to die; to check this we provide <code class="code">IsPqProcessAlive</code> (see <code class="func">IsPqProcessAlive</code>).</p>

<p>The <strong class="pkg">GAP</strong> iostream of an interactive <strong class="pkg">ANUPQ</strong> process will also die if the <code class="code">pq</code> 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 <code class="code">README</code> that comes with the <strong class="pkg">ANUPQ</strong> package to find out what to include in a bug report and who to email it to.</p>

<p><a id="X823D2BBF7C4515D4" name="X823D2BBF7C4515D4"></a></p>

<h4>5.3 <span class="Heading">Interactive Versions of Non-interactive ANUPQ Functions</span></h4>

<p><a id="X85408C4C790439E7" name="X85408C4C790439E7"></a></p>

<h5>5.3-1 Pq</h5>

<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ Pq</code>( <var class="Arg">i:</var> <var class="Arg">options</var> )</td><td class="tdright">( function )</td></tr></table></div>
<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ Pq</code>( <var class="Arg">:</var> <var class="Arg">options</var> )</td><td class="tdright">( function )</td></tr></table></div>
<p>return, for the fp or pc group (let us call it <var class="Arg">F</var>), of the <var class="Arg">i</var>th or default interactive <strong class="pkg">ANUPQ</strong> process, the <span class="SimpleMath">\(p\)</span>-quotient of <var class="Arg">F</var> specified by <var class="Arg">options</var>, as a pc group; <var class="Arg">F</var> must previously have been given (as first argument) to <code class="code">PqStart</code> to start the interactive <strong class="pkg">ANUPQ</strong> process (see <code class="func">PqStart</code> (<a href="chap5_mj.html#X83B2EC237F37623C"><span class="RefLink">5.1-1</span></a>)) or restored from file using the function <code class="code">PqRestorePcPresentation</code> (see <code class="func">PqRestorePcPresentation</code> (<a href="chap5_mj.html#X7FD001C0798EF219"><span class="RefLink">5.6-3</span></a>)). Following the colon <var class="Arg">options</var> is a selection of the options listed for the non-interactive <code class="code">Pq</code> function (see <code class="func">Pq</code> (<a href="chap4_mj.html#X86DD32D5803CF2C8"><span class="RefLink">4.1-1</span></a>)), separated by commas like record components (see Section <a href="../../../doc/ref/chap4_mj.html#X867D54987EF86D1D"><span class="RefLink">Reference: Function Call With Options</span></a> in the <strong class="pkg">GAP</strong> Reference Manual), except that the options <code class="code">SetupFile</code> or <code class="code">PqWorkspace</code> are ignored by the interactive <code class="code">Pq</code>, and <code class="code">RedoPcp</code> is an option only recognised by the interactive <code class="code">Pq</code> i.e. the following options are recognised by the interactive <code class="code">Pq</code> function:</p>


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

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

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

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

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

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

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

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

</li>
<li><p><code class="code">RedoPcp</code></p>

</li>
</ul>
<p>Detailed descriptions of the above options may be found in Chapter <a href="chap6_mj.html#X7B0946E97E7EB359"><span class="RefLink"><span class="Heading">ANUPQ Options</span></span></a>.</p>

<p>As a minimum the <code class="code">Pq</code> function <em>must</em> have a value for the <code class="code">Prime</codeoption, though <code class="code">Prime</code> need not be passed again in the case it has previously been provided, e.g. to <code class="code">PqStart</code> (see <code class="func">PqStart</code> (<a href="chap5_mj.html#X83B2EC237F37623C"><span class="RefLink">5.1-1</span></a>)) when starting the interactive process.</p>

<p>The behaviour of the interactive <code class="code">Pq</code> function depends on the current state of the pc presentation stored by the <code class="code">pq</code> program:</p>

<ol>
<li><p>If no pc presentation has yet been computed (the case immediately after the <code class="code">PqStart</code> call initiating the process) then the quotient group of the input group of the process of largest lower exponent-<var class="Arg">p</var> class bounded by the value of the <code class="code">ClassBound</codeoption (see <a href="chap6_mj.html#X87EE6DD67C9996A3"><span class="RefLink">6.2</span></a>) is returned.</p>

</li>
<li><p>If the current pc presentation of the process was determined by a previous call to <code class="code">Pq</code> or <code class="code">PqEpimorphism</code>, and the current call has a larger value <code class="code">ClassBound</code> 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-<var class="Arg">p</var> class is returned.</p>

</li>
<li><p>If the current pc presentation of the process was determined by a previous call to <code class="code">PqPCover</code> then a consistent pc presentation of a quotient for the current class is determined before proceeding as in 2.</p>

</li>
<li><p>If the <code class="code">RedoPcp</codeoption is supplied the current pc presentation is scrapped, all options must be re-supplied (in particular, <code class="code">Prime</code> <em>must</em> be supplied) and then the <code class="code">Pq</code> function proceeds as in 1.</p>

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

<p>The following is one of the examples for the non-interactive <code class="code">Pq</code> redone with the interactive version. Also, we set the option <code class="code">OutputLevel</code> to 1 (see <a href="chap6_mj.html#X87EE6DD67C9996A3"><span class="RefLink">6.2</span></a>), in order to see the orders of the quotients of all the classes determined, and we set the <code class="code">InfoANUPQ</code> level to 2 (see <code class="func">InfoANUPQ</code> (<a href="chap3_mj.html#X7CBC9B458497BFF1"><span class="RefLink">3.3-1</span></a>)), so that we catch the timing information.</p>


<div class="example"><pre>
<span class="GAPprompt">gap></span> <span class="GAPinput">F := FreeGroup("a""b");; a := F.1;; b := F.2;;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">G := F / [a^4, b^4];</span>
<fp group on the generators [ a, b ]>
<span class="GAPprompt">gap></span> <span class="GAPinput">PqStart(G);</span>
1
<span class="GAPprompt">gap></span> <span class="GAPinput">SetInfoLevel(InfoANUPQ, 2); #To see timing information</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">Pq(: Prime := 2, ClassBound := 3, OutputLevel := 1 );</span>
#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>
</pre></div>

<p><a id="X839E6F578227A8EA" name="X839E6F578227A8EA"></a></p>

<h5>5.3-2 PqEpimorphism</h5>

<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ PqEpimorphism</code>( <var class="Arg">i:</var> <var class="Arg">options</var> )</td><td class="tdright">( function )</td></tr></table></div>
<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ PqEpimorphism</code>( <var class="Arg">:</var> <var class="Arg">options</var> )</td><td class="tdright">( function )</td></tr></table></div>
<p>return, for the fp or pc group (let us call it <var class="Arg">F</var>), of the <var class="Arg">i</var>th or default interactive <strong class="pkg">ANUPQ</strong> process, an epimorphism from <var class="Arg">F</var> onto the <span class="SimpleMath">\(p\)</span>-quotient of <var class="Arg">F</var> specified by <var class="Arg">options</var>; <var class="Arg">F</var> must previously have been given (as first argument) to <code class="code">PqStart</code> to start the interactive <strong class="pkg">ANUPQ</strong> process (see <code class="func">PqStart</code> (<a href="chap5_mj.html#X83B2EC237F37623C"><span class="RefLink">5.1-1</span></a>)). Since the underlying interactions with the <code class="code">pq</code> program effected by the interactive <code class="code">PqEpimorphism</code> are identical to those effected by the interactive <code class="code">Pq</code>, everything said regarding the requirements and behaviour of the interactive <code class="code">Pq</code> function (see <code class="func">Pq</code> (<a href="chap5_mj.html#X85408C4C790439E7"><span class="RefLink">5.3-1</span></a>)) is also the case for the interactive <code class="code">PqEpimorphism</code>.</p>

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

<p><a id="X7AA64A2F8509A39A" name="X7AA64A2F8509A39A"></a></p>

<h5>5.3-3 PqPCover</h5>

<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ PqPCover</code>( <var class="Arg">i:</var> <var class="Arg">options</var> )</td><td class="tdright">( function )</td></tr></table></div>
<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ PqPCover</code>( <var class="Arg">:</var> <var class="Arg">options</var> )</td><td class="tdright">( function )</td></tr></table></div>
<p>return, for the fp or pc group of the <var class="Arg">i</var>th or default interactive <strong class="pkg">ANUPQ</strong> process, the <span class="SimpleMath">\(p\)</span>-covering group of the <span class="SimpleMath">\(p\)</span>-quotient <code class="code">Pq(<var class="Arg">i</var> : <var class="Arg">options</var>)</code> or <code class="code">Pq(: <var class="Arg">options</var>)</code>, modulo the following:</p>

<ol>
<li><p>If no pc presentation has yet been computed (the case immediately after the <code class="code">PqStart</code> call initiating the process) and the group <var class="Arg">F</var> of the process is already a <span class="SimpleMath">\(p\)</span>-group, in the sense that <code class="code">HasIsPGroup(<var class="Arg">F</var>) and IsPGroup(<var class="Arg">F</var>)</code> is <code class="keyw">true</code>, then</p>


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

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

</dd>
</dl>
</li>
<li><p>If a pc presentation has been computed and none of <var class="Arg">options</var> is <code class="code">RedoPcp</code> or if no pc presentation has yet been computed but 1. does not apply then <code class="code">PqPCover(<var class="Arg">i</var> : <var class="Arg">options</var>);</code> is equivalent to:</p>


<div class="example"><pre>
Pq(i : options);
PqPCover(i);
</pre></div>

</li>
<li><p>If the <code class="code">RedoPcp</codeoption is supplied the current pc presentation is scrapped, and <code class="code">PqPCover</code> proceeds as in 1. or 2. but without the <code class="code">RedoPcp</codeoption.</p>

</li>
</ol>
<p><a id="X805F32618005C087" name="X805F32618005C087"></a></p>

<h5>5.3-4 PqStandardPresentation</h5>

<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ PqStandardPresentation</code>( [<var class="Arg">i</var>]<var class="Arg">:</var> <var class="Arg">options</var> )</td><td class="tdright">( function )</td></tr></table></div>
<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ StandardPresentation</code>( [<var class="Arg">i</var>]<var class="Arg">:</var> <var class="Arg">options</var> )</td><td class="tdright">( function )</td></tr></table></div>
<p>return, for the <var class="Arg">i</var>th or default interactive <strong class="pkg">ANUPQ</strong> process, the <var class="Arg">p</var>-quotient of the group <var class="Arg">F</var> of the process, specified by <var class="Arg">options</var>, as an <em>fp group</em> which has a standard presentation. Here <var class="Arg">options</var> is a selection of the options from the following list (see Chapter <a href="chap6_mj.html#X7B0946E97E7EB359"><span class="RefLink"><span class="Heading">ANUPQ Options</span></span></a> for detailed descriptions); this list is the same as for the non-interactive version of <code class="code">PqStandardPresentation</code> except for the omission of options <code class="code">SetupFile</code> and <code class="code">PqWorkspace</code> (see <code class="func">PqStandardPresentation</code> (<a href="chap4_mj.html#X86C9575D7CB65FBB"><span class="RefLink">4.2-1</span></a>)).</p>


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

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

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

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

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

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

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

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

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

<p>Taking one of the examples for the non-interactive version of <code class="code">StandardPresentation</code> (see <code class="func">StandardPresentation</code> (<a href="chap4_mj.html#X86C9575D7CB65FBB"><span class="RefLink">4.2-1</span></a>)) that required two separate calls to the <code class="code">pq</code> program, we now show how it can be done by setting up a dialogue with just the one <code class="code">pq</code> process, using the interactive version of <code class="code">StandardPresentation</code>:</p>


<div class="example"><pre>
<span class="GAPprompt">gap></span> <span class="GAPinput">F4 := FreeGroup( "a""b""c""d" );;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">a := F4.1;; b := F4.2;; c := F4.3;; d := F4.4;;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">G4 := F4 / [ b^4, b^2 / Comm(Comm (b, a), a), d^16,</span>
<span class="GAPprompt">></span> <span class="GAPinput">                a^16 / (c * d), b^8 / (d * c^4) ];</span>
<fp group on the generators [ a, b, c, d ]>
<span class="GAPprompt">gap></span> <span class="GAPinput">SetInfoLevel(InfoANUPQ, 1); #Only essential Info please</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">PqStart(G4); #Start a new interactive process for a new group</span>
2
<span class="GAPprompt">gap></span> <span class="GAPinput">K := Pq( 2 : Prime := 2, ClassBound := 1 ); #`pq' process no. is 2</span>
<pc group of size 4 with 2 generators>
<span class="GAPprompt">gap></span> <span class="GAPinput">StandardPresentation( 2 : pQuotient := K, ClassBound := 14 );</span>
<fp group with 53 generators>
</pre></div>

<p><em>Notes</em></p>

<p>In contrast to the function <code class="code">Pq</code> (see <code class="func">Pq</code> (<a href="chap4_mj.html#X86DD32D5803CF2C8"><span class="RefLink">4.1-1</span></a>)) which returns a pc group, <code class="code">PqStandardPresentation</code> or <code class="code">StandardPresentation</code> returns an fp group. This is because the output is mainly used for isomorphism testing for which an fp group is enough. However, the presentation is a polycyclic presentation and if you need to do any further computation with this group (e.g. to find the order) you can use the function <code class="code">PcGroupFpGroup</code> (see <code class="func">PcGroupFpGroup</code> (<a href="../../../doc/ref/chap46_mj.html#X84C10D1F7CB5274F"><span class="RefLink">Reference: PcGroupFpGroup</span></a>) in the <strong class="pkg">GAP</strong> Reference Manual) to form a pc group.</p>

<p>If the user does not supply a <var class="Arg">p</var>-quotient <var class="Arg">Q</var> via the <code class="code">pQuotient</codeoption, and the prime <var class="Arg">p</var> is either supplied, stored, or <var class="Arg">F</var> is a pc <var class="Arg">p</var>-group, then a <var class="Arg">p</var>-quotient <var class="Arg">Q</var> is computed. (The value of the prime <var class="Arg">p</var> is stored if passed initially to <code class="code">PqStart</code> or to a subsequent interactive process.) Note that a stored value for <code class="code">pQuotient</code> (from a prior call to <code class="code">Pq</code>) does <em>not</em> have precedence over a value for the prime <var class="Arg">p</var>. If the user does supply a <var class="Arg">p</var>-quotient <var class="Arg">Q</var> via the <code class="code">pQuotient</codeoption, the package <strong class="pkg">AutPGrp</strong> is called to compute the automorphism group of <var class="Arg">Q</var>; an error will occur that asks the user to install the package <strong class="pkg">AutPGrp</strong> if the automorphism group cannot be computed.</p>

<p>If any of the interactive functions <code class="code">PqStandardPresentation</code>, <code class="code">StandardPresentation</code>, <code class="code">EpimorphismPqStandardPresentation</code> or <code class="code">EpimorphismStandardPresentation</code> 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 <code class="code">SPepi</code> and <code class="code">SP</code> fields of the data record associated with the process. See the example for the interactive <code class="code">EpimorphismStandardPresentation</code> (<code class="func">EpimorphismStandardPresentation</code> (<a href="chap5_mj.html#X791392977B2D692D"><span class="RefLink">5.3-5</span></a>)).</p>

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

<p><a id="X791392977B2D692D" name="X791392977B2D692D"></a></p>

<h5>5.3-5 EpimorphismPqStandardPresentation</h5>

<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ EpimorphismPqStandardPresentation</code>( [<var class="Arg">i</var>]<var class="Arg">:</var> <var class="Arg">options</var> )</td><td class="tdright">( function )</td></tr></table></div>
<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ EpimorphismStandardPresentation</code>( [<var class="Arg">i</var>]<var class="Arg">:</var> <var class="Arg">options</var> )</td><td class="tdright">( method )</td></tr></table></div>
<p>Each of the above functions accepts the same arguments and options as the interactive form of <code class="code">StandardPresentation</code> (see <code class="func">StandardPresentation</code> (<a href="chap5_mj.html#X805F32618005C087"><span class="RefLink">5.3-4</span></a>)) and returns an epimorphism from the fp or pc group <var class="Arg">F</var> of the <var class="Arg">i</var>th or default interactive <strong class="pkg">ANUPQ</strong> process onto the finitely presented group given by a standard presentation, i.e. if <var class="Arg">S</var> is the standard presentation computed for the <span class="SimpleMath">\(p\)</span>-quotient of <var class="Arg">F</var> by <code class="code">StandardPresentation</code> then <code class="code">EpimorphismStandardPresentation</code> returns the epimorphism from <var class="Arg">F</var> to the group with presentation <var class="Arg">S</var>. The group <var class="Arg">F</var> must have been given (as first argument) to <code class="code">PqStart</code> to start the interactive <strong class="pkg">ANUPQ</strong> process (see <code class="func">PqStart</code> (<a href="chap5_mj.html#X83B2EC237F37623C"><span class="RefLink">5.1-1</span></a>)).</p>

<p>Taking our earlier non-interactive example (see <code class="func">EpimorphismPqStandardPresentation</code> (<a href="chap4_mj.html#X828C06D083C0D089"><span class="RefLink">4.2-2</span></a>)) and modifying it a little, we illustrate, as for the interactive <code class="code">StandardPresentation</code> (see <code class="func">StandardPresentation</code> (<a href="chap5_mj.html#X805F32618005C087"><span class="RefLink">5.3-4</span></a>)), how something that required two separate calls to the <code class="code">pq</code> program can now be achieved with a dialogue with just one <code class="code">pq</code> process. Also, observe that calls to one of the standard presentation functions (as mentioned in the notes of <code class="func">StandardPresentation</code> (<a href="chap5_mj.html#X805F32618005C087"><span class="RefLink">5.3-4</span></a>)) 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.</p>


<div class="example"><pre>
<span class="GAPprompt">gap></span> <span class="GAPinput">F := FreeGroup(6, "F");;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">x := F.1;; y := F.2;; z := F.3;; w := F.4;; a := F.5;; b := F.6;;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">R := [x^3 / w, y^3 / w * a^2 * b^2, w^3 / b,</span>
<span class="GAPprompt">></span> <span class="GAPinput">         Comm (y, x) / z, Comm (z, x), Comm (z, y) / a, z^3 ];</span>
[ 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 ]
<span class="GAPprompt">gap></span> <span class="GAPinput">Q := F / R;</span>
<fp group on the generators [ F1, F2, F3, F4, F5, F6 ]>
<span class="GAPprompt">gap></span> <span class="GAPinput">PqStart( Q );</span>
3
<span class="GAPprompt">gap></span> <span class="GAPinput">G := Pq( 3 : Prime := 3, ClassBound := 3 );</span>
<pc group of size 729 with 6 generators>
<span class="GAPprompt">gap></span> <span class="GAPinput">lev := InfoLevel(InfoANUPQ);; # Save current InfoANUPQ level</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">SetInfoLevel(InfoANUPQ, 2); # To see computation times</span>
<span class="GAPprompt">gap></span> <span class="GAPinput"># It is not necessary to pass the `Prime' option to</span>
<span class="GAPprompt">gap></span> <span class="GAPinput"># `EpimorphismStandardPresentation' since it was previously</span>
<span class="GAPprompt">gap></span> <span class="GAPinput"># passed to `Pq':</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">phi := EpimorphismStandardPresentation( 3 : ClassBound := 3 );</span>
#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 ]
<span class="GAPprompt">gap></span> <span class="GAPinput"># Image of phi should be isomorphic to G ...</span>
<span class="GAPprompt">gap></span> <span class="GAPinput"># let's check the order is correct:</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">Size( Image(phi) );</span>
729
<span class="GAPprompt">gap></span> <span class="GAPinput"># `StandardPresentation' and `EpimorphismStandardPresentation'</span>
<span class="GAPprompt">gap></span> <span class="GAPinput"># behave like attributes, so no computation is done when</span>
<span class="GAPprompt">gap></span> <span class="GAPinput"># either is called again for the same process ...</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">StandardPresentation( 3 : ClassBound := 3 );</span>
<fp group of size 729 on the generators [ f1, f2, f3, f4, f5, f6 ]>
<span class="GAPprompt">gap></span> <span class="GAPinput"># No timing data was Info-ed since no computation was done</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">SetInfoLevel(InfoANUPQ, lev); # Restore previous InfoANUPQ level</span>
</pre></div>

<p>A very similar (essential details are the same) example to the above may be executed live, by typing: <code class="code">PqExample( "EpimorphismStandardPresentation-i" );</code>.</p>

<p><em>Note:</em> The notes for <code class="code">PqStandardPresentation</code> or <code class="code">StandardPresentation</code> (see <code class="func">PqStandardPresentation</code> (<a href="chap5_mj.html#X805F32618005C087"><span class="RefLink">5.3-4</span></a>)) apply also to <code class="code">EpimorphismPqStandardPresentation</code> or <code class="code">EpimorphismStandardPresentation</code> except that their return value is an <em>epimorphism onto</em> an fp group, i.e. one should interpret the phrase <q>returns an fp group</q> as <q>returns an epimorphism onto an fp group</q> etc.</p>

<p><a id="X795817217C53AB89" name="X795817217C53AB89"></a></p>

<h5>5.3-6 PqDescendants</h5>

<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ PqDescendants</code>( <var class="Arg">i:</var> <var class="Arg">options</var> )</td><td class="tdright">( function )</td></tr></table></div>
<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ PqDescendants</code>( <var class="Arg">:</var> <var class="Arg">options</var> )</td><td class="tdright">( function )</td></tr></table></div>
<p>return for the pc group <var class="Arg">G</var> of the <var class="Arg">i</var>th or default interactive <strong class="pkg">ANUPQ</strong> process, which must be of prime power order with a confluent pc presentation (see <code class="func">IsConfluent</code> (<a href="../../../doc/ref/chap46_mj.html#X7DF4835F79667099"><span class="RefLink">Reference: IsConfluent for pc groups</span></a>) in the <strong class="pkg">GAP</strong> Reference Manual), a list of descendants (pc groups) of <var class="Arg">G</var>. The group <var class="Arg">G</var> is usually given as first argument to <code class="code">PqStart</code> when starting the interactive <strong class="pkg">ANUPQ</strong> process (see <code class="func">PqStart</code> (<a href="chap5_mj.html#X83B2EC237F37623C"><span class="RefLink">5.1-1</span></a>)). Alternatively, one may initiate the process with an fp group, use <code class="code">Pq</code> interactively (see <code class="func">Pq</code> (<a href="chap5_mj.html#X85408C4C790439E7"><span class="RefLink">5.3-1</span></a>)) to create a pc group and use <code class="code">PqSetPQuotientToGroup</code> (see <code class="func">PqSetPQuotientToGroup</code> (<a href="chap5_mj.html#X80CCF6D379E5A3B4"><span class="RefLink">5.3-7</span></a>)), which involves <em>no</em> computation, to set the pc group returned by <code class="code">Pq</code> as the group of the process. Note that repeating a call to <code class="code">PqDescendants</code> for the same interactive <strong class="pkg">ANUPQ</strong> process simply returns the list of descendants originally calculated; a warning is emitted at <code class="code">InfoANUPQ</code> level 1 reminding you of this should you do this.</p>

<p>After the colon, <var class="Arg">options</var> a selection of the options listed for the non-interactive <code class="code">PqDescendants</code> function (see <code class="func">PqDescendants</code> (<a href="chap4_mj.html#X80985CC479CD9FA3"><span class="RefLink">4.4-1</span></a>)), should be given, separated by commas like record components (see Section <a href="../../../doc/ref/chap4_mj.html#X867D54987EF86D1D"><span class="RefLink">Reference: Function Call With Options</span></a> in the <strong class="pkg">GAP</strong> Reference Manual), except that the options <code class="code">SetupFile</code> or <code class="code">PqWorkspace</code> are ignored by the interactive <code class="code">PqDescendants</code>, i.e. the following options are recognised by the interactive <code class="code">PqDescendants</code> function:</p>


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

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

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

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

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

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

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

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

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

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

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

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

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

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

</li>
</ul>
<p><em>Notes:</em> The function <code class="code">PqDescendants</code> uses the automorphism group of <var class="Arg">G</var> which it computes via the package <strong class="pkg">AutPGrp</strongif the automorphism group of <var class="Arg">G</var> is not already present. If <strong class="pkg">AutPGrp</strong> is not installed an error may be raised. If the automorphism group of <var class="Arg">G</var> is insoluble the <code class="code">pq</code> program will call <strong class="pkg">GAP</strong> together with the <strong class="pkg">AutPGrp</strong> package for certain orbit-stabilizer calculations.</p>

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

<p>Let us now repeat the examples previously given for the non-interactive <code class="code">PqDescendants</code>, but this time with the interactive version of <code class="code">PqDescendants</code>:</p>


<div class="example"><pre>
<span class="GAPprompt">gap></span> <span class="GAPinput">F := FreeGroup( "a""b" );; a := F.1;; b := F.2;;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">G := PcGroupFpGroup( F / [ a^2, b^2, Comm(b, a) ] );</span>
<pc group of size 4 with 2 generators>
<span class="GAPprompt">gap></span> <span class="GAPinput">PqStart(G); #This will now be the 4th interactive process running</span>
4
<span class="GAPprompt">gap></span> <span class="GAPinput">des := PqDescendants( 4 : OrderBound := 6, ClassBound := 5 );;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">Length(des);</span>
83
<span class="GAPprompt">gap></span> <span class="GAPinput">List(des, Size);</span>
[ 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 ]
<span class="GAPprompt">gap></span> <span class="GAPinput">List(des, d -> Length( PCentralSeries( d, 2 ) ) - 1 );</span>
[ 2, 2, 2, 2, 2, 2, 2, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 
  3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 4, 
  4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 
  4, 4, 4, 5, 5, 5, 5, 5 ]
</pre></div>

<p>In the second example we compute all capable descendants of order 27 of the elementary abelian group of order 9.</p>


<div class="example"><pre>
<span class="GAPprompt">gap></span> <span class="GAPinput">F := FreeGroup( 2, "g" );;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">G := PcGroupFpGroup( F / [ F.1^3, F.2^3, Comm(F.1, F.2) ] );</span>
<pc group of size 9 with 2 generators>
<span class="GAPprompt">gap></span> <span class="GAPinput">PqStart(G); #This will now be the 5th interactive process running</span>
5
<span class="GAPprompt">gap></span> <span class="GAPinput">des := PqDescendants( 5 : OrderBound := 3, ClassBound := 2,</span>
<span class="GAPprompt">></span> <span class="GAPinput">                             CapableDescendants );</span>
[ <pc group of size 27 with 3 generators>, 
  <pc group of size 27 with 3 generators> ]
<span class="GAPprompt">gap></span> <span class="GAPinput">List(des, d -> Length( PCentralSeries( d, 3 ) ) - 1 );</span>
[ 2, 2 ]
<span class="GAPprompt">gap></span> <span class="GAPinput"># For comparison let us now compute all descendants</span>
<span class="GAPprompt">gap></span> <span class="GAPinput"># (using the non-interactive Pq function)</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">PqDescendants( G : OrderBound := 3, ClassBound := 2);</span>
[ <pc group of size 27 with 3 generators>, 
  <pc group of size 27 with 3 generators>, 
  <pc group of size 27 with 3 generators> ]
</pre></div>

<p>In the third example, we compute all capable descendants of the elementary abelian group of order <span class="SimpleMath">\(5^2\)</span> which have exponent-<span class="SimpleMath">\(5\)</span> class at most <span class="SimpleMath">\(3\)</span>, exponent <span class="SimpleMath">\(5\)</span>, and are metabelian.</p>


<div class="example"><pre>
<span class="GAPprompt">gap></span> <span class="GAPinput">F := FreeGroup( 2, "g" );;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">G := PcGroupFpGroup( F / [ F.1^5, F.2^5, Comm(F.2, F.1) ] );</span>
<pc group of size 25 with 2 generators>
<span class="GAPprompt">gap></span> <span class="GAPinput">PqStart(G); #This will now be the 6th interactive process running</span>
6
<span class="GAPprompt">gap></span> <span class="GAPinput">des := PqDescendants( 6 : Metabelian, ClassBound := 3,</span>
<span class="GAPprompt">></span> <span class="GAPinput">                             Exponent := 5, CapableDescendants );</span>
[ <pc group of size 125 with 3 generators>, 
  <pc group of size 625 with 4 generators>, 
  <pc group of size 3125 with 5 generators> ]
<span class="GAPprompt">gap></span> <span class="GAPinput">List(des, d -> Length( PCentralSeries( d, 5 ) ) - 1 );</span>
[ 2, 3, 3 ]
<span class="GAPprompt">gap></span> <span class="GAPinput">List(des, d -> Length( DerivedSeries( d ) ) );</span>
[ 3, 3, 3 ]
<span class="GAPprompt">gap></span> <span class="GAPinput">List(des, d -> Maximum( List( d, Order ) ) );</span>
[ 5, 5, 5 ]
</pre></div>

<p><a id="X80CCF6D379E5A3B4" name="X80CCF6D379E5A3B4"></a></p>

<h5>5.3-7 PqSetPQuotientToGroup</h5>

<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ PqSetPQuotientToGroup</code>( <var class="Arg">i</var> )</td><td class="tdright">( function )</td></tr></table></div>
<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ PqSetPQuotientToGroup</code>(  )</td><td class="tdright">( function )</td></tr></table></div>
<p>for the <var class="Arg">i</var>th or default interactive <strong class="pkg">ANUPQ</strong> process, set the <span class="SimpleMath">\(p\)</span>-quotient previously computed by the interactive <code class="code">Pq</code> function (see <code class="func">Pq</code> (<a href="chap5_mj.html#X85408C4C790439E7"><span class="RefLink">5.3-1</span></a>)) to be the group of the process. This function is supplied to enable the computation of descendants of a <span class="SimpleMath">\(p\)</span>-quotient that is already known to the <code class="code">pq</code> program, via the interactive <code class="code">PqDescendants</code> function (see <code class="func">PqDescendants</code> (<a href="chap5_mj.html#X795817217C53AB89"><span class="RefLink">5.3-6</span></a>)), thus avoiding the need to re-submit it and have the <code class="code">pq</code> program recompute it.</p>

<p><em>Note:</em> See the function <code class="code">PqPGSetDescendantToPcp</code> (<code class="func">PqPGSetDescendantToPcp</code> (<a href="chap5_mj.html#X7E9D511385D48A98"><span class="RefLink">5.9-4</span></a>)) for a mechanism to make (the <span class="SimpleMath">\(p\)</span>-cover of) a particular descendants the current group of the process.</p>

<p>The following example of the usage of <code class="code">PqSetPQuotientToGroup</code>, which is essentially equivalent to what is obtained by running <code class="code">PqExample("PqDescendants-1-i");</code>, redoes the first example of <code class="func">PqDescendants</code> (<a href="chap5_mj.html#X795817217C53AB89"><span class="RefLink">5.3-6</span></a>) (which computes the descendants of the Klein four group).</p>


<div class="example"><pre>
<span class="GAPprompt">gap></span> <span class="GAPinput">F := FreeGroup( "a""b" );</span>
<free group on the generators [ a, b ]>
<span class="GAPprompt">gap></span> <span class="GAPinput">procId := PqStart( F : Prime := 2 );</span>
7
<span class="GAPprompt">gap></span> <span class="GAPinput">Pq( procId : ClassBound := 1 );</span>
<pc group of size 4 with 2 generators>
<span class="GAPprompt">gap></span> <span class="GAPinput">PqSetPQuotientToGroup( procId );</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">des := PqDescendants( procId : OrderBound := 6, ClassBound := 5 );;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">Length(des);</span>
83
<span class="GAPprompt">gap></span> <span class="GAPinput">List(des, Size);</span>
[ 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 ]
<span class="GAPprompt">gap></span> <span class="GAPinput">List(des, d -> Length( PCentralSeries( d, 2 ) ) - 1 );</span>
[ 2, 2, 2, 2, 2, 2, 2, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 
  3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 4, 
  4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 
  4, 4, 4, 5, 5, 5, 5, 5 ]
</pre></div>

<p><a id="X857F050C832A1FE4" name="X857F050C832A1FE4"></a></p>

<h4>5.4 <span class="Heading">Low-level Interactive ANUPQ functions based on menu items of the
pq program</span></h4>

<p>The <code class="code">pq</code> 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: <code class="code">guide.dvi</code>. Both <code class="code">guide.dvi</code> and the <code class="code">pq</code> program refer to the items of these 5 menus as <q>options</q>, which do <em>not</em> correspond in any way to the options used by any of the <strong class="pkg">GAP</strong> functions that interface with the <code class="code">pq</code> program.</p>

<p><em>Warning:</em> The commands provided in this section are intended to provide something like the interactive functionality one has when running the standalone, from within <strong class="pkg">GAP</strong>. The <code class="code">pq</code> standalone (in particular, its <q>advanced</q> menus) assumes some expertise of the user; doing the <q>wrong</q> thing can cause the program to crash. While a number of safeguards have been provided in the <strong class="pkg">GAP</strong> interface to the <code class="code">pq</code> program, these are <em>not</em> foolproof, and the user should exercise care and ensure pre-requisites of the various commands are met.</p>

<p><a id="X868B10557D470CF6" name="X868B10557D470CF6"></a></p>

<h4>5.5 <span class="Heading">General commands</span></h4>

<p>The following commands either use a menu item from whatever menu is <q>current</q> for the <code class="code">pq</code> program, or have general application and are not associated with just one menu item of the <code class="code">pq</code> program.</p>

<p><a id="X7DE2F6C686C672DD" name="X7DE2F6C686C672DD"></a></p>

<h5>5.5-1 PqNrPcGenerators</h5>

<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ PqNrPcGenerators</code>( <var class="Arg">i</var> )</td><td class="tdright">( function )</td></tr></table></div>
<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ PqNrPcGenerators</code>(  )</td><td class="tdright">( function )</td></tr></table></div>
<p>for the <var class="Arg">i</var>th or default interactive <strong class="pkg">ANUPQ</strong> process, return the number of pc generators of the lower exponent <span class="SimpleMath">\(p\)</span>-class quotient of the group currently determined by the process. This also applies if the pc presentation is not consistent.</p>

<p><a id="X87FF98867E8FFB3C" name="X87FF98867E8FFB3C"></a></p>

<h5>5.5-2 PqFactoredOrder</h5>

<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ PqFactoredOrder</code>( <var class="Arg">i</var> )</td><td class="tdright">( function )</td></tr></table></div>
<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ PqFactoredOrder</code>(  )</td><td class="tdright">( function )</td></tr></table></div>
<p>for the <var class="Arg">i</var>th or default interactive <strong class="pkg">ANUPQ</strong> process, return an integer pair <code class="code">[<var class="Arg">p</var>, <var class="Arg">n</var>]</code> where <var class="Arg">p</var> is a prime and <var class="Arg">n</var> is the number of pc generators (see <code class="func">PqNrPcGenerators</code> (<a href="chap5_mj.html#X7DE2F6C686C672DD"><span class="RefLink">5.5-1</span></a>)) in the pc presentation of the quotient group currently determined by the process. If this presentation is consistent, then <span class="SimpleMath">\(p^n\)</span> 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), <span class="SimpleMath">\(p^n\)</span> is an upper bound for the order of the group.</p>

<p><a id="X7B4FC9E380001A71" name="X7B4FC9E380001A71"></a></p>

<h5>5.5-3 PqOrder</h5>

<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ PqOrder</code>( <var class="Arg">i</var> )</td><td class="tdright">( function )</td></tr></table></div>
<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ PqOrder</code>(  )</td><td class="tdright">( function )</td></tr></table></div>
<p>for the <var class="Arg">i</var>th or default interactive <strong class="pkg">ANUPQ</strong> process, return <span class="SimpleMath">\(p^n\)</span> where <code class="code">[<var class="Arg">p</var>, <var class="Arg">n</var>]</code> is the pair as returned by <code class="code">PqFactoredOrder</code> (see <code class="func">PqFactoredOrder</code> (<a href="chap5_mj.html#X87FF98867E8FFB3C"><span class="RefLink">5.5-2</span></a>)).</p>

<p><a id="X87C7F7EB7C10DC4B" name="X87C7F7EB7C10DC4B"></a></p>

<h5>5.5-4 PqPClass</h5>

<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ PqPClass</code>( <var class="Arg">i</var> )</td><td class="tdright">( function )</td></tr></table></div>
<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ PqPClass</code>(  )</td><td class="tdright">( function )</td></tr></table></div>
<p>for the <var class="Arg">i</var>th or default interactive <strong class="pkg">ANUPQ</strong> process, return the lower exponent <span class="SimpleMath">\(p\)</span>-class of the quotient group currently determined by the process.</p>

<p><a id="X7EA3B6917908C20A" name="X7EA3B6917908C20A"></a></p>

<h5>5.5-5 PqWeight</h5>

<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ PqWeight</code>( <var class="Arg">i</var>, <var class="Arg">j</var> )</td><td class="tdright">( function )</td></tr></table></div>
<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ PqWeight</code>( <var class="Arg">j</var> )</td><td class="tdright">( function )</td></tr></table></div>
<p>for the <var class="Arg">i</var>th or default interactive <strong class="pkg">ANUPQ</strong> process, return the weight of the <var class="Arg">j</var>th pc generator of the lower exponent <span class="SimpleMath">\(p\)</span>-class quotient of the group currently determined by the process, or <code class="keyw">fail</code> if there is no such numbered pc generator.</p>

<p><a id="X79862B83817E20E1" name="X79862B83817E20E1"></a></p>

<h5>5.5-6 PqCurrentGroup</h5>

<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ PqCurrentGroup</code>( <var class="Arg">i</var> )</td><td class="tdright">( function )</td></tr></table></div>
<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ PqCurrentGroup</code>(  )</td><td class="tdright">( function )</td></tr></table></div>
<p>for the <var class="Arg">i</var>th or default interactive <strong class="pkg">ANUPQ</strong> process, return the group whose pc presentation is determined by the process as a <strong class="pkg">GAP</strong> pc group (either a lower exponent <span class="SimpleMath">\(p\)</span>-class quotient of the start group or the <span class="SimpleMath">\(p\)</span>-cover of such a quotient).</p>

<p><em>Notes:</em> See Section <a href="chap3_mj.html#X818175EF85CAA807"><span class="RefLink"><span class="Heading">Attributes and a Property for fp and pc p-groups</span></span></a> for the attributes and property <code class="code">NuclearRank</code>, <code class="code">MultiplicatorRank</code> and <code class="code">IsCapable</code> which may be applied to the group returned by <code class="code">PqCurrentGroup</code>.</p>

<p><a id="X805A50687D82B9EC" name="X805A50687D82B9EC"></a></p>

<h5>5.5-7 PqDisplayPcPresentation</h5>

<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ PqDisplayPcPresentation</code>( <var class="Arg">i:</var> [<var class="Arg">OutputLevel</var> <var class="Arg">:=</var> <var class="Arg">lev</var>] )</td><td class="tdright">( function )</td></tr></table></div>
<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ PqDisplayPcPresentation</code>( <var class="Arg">:</var> [<var class="Arg">OutputLevel</var> <var class="Arg">:=</var> <var class="Arg">lev</var>] )</td><td class="tdright">( function )</td></tr></table></div>
<p>for the <var class="Arg">i</var>th or default interactive <strong class="pkg">ANUPQ</strong> process, direct the <code class="code">pq</code> program to display the pc presentation of the lower exponent <span class="SimpleMath">\(p\)</span>-class quotient of the group currently determined by the process.</p>

<p>Except if the last command communicating with the <code class="code">pq</code> program was a <span class="SimpleMath">\(p\)</span>-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 <code class="code">PqSetOutputLevel</code> first (see <code class="func">PqSetOutputLevel</code> (<a href="chap5_mj.html#X80410979854280E1"><span class="RefLink">5.5-8</span></a>)), or equivalently pass the option <code class="code">OutputLevel</code> (see <a href="chap6_mj.html#X87EE6DD67C9996A3"><span class="RefLink">6.2</span></a>).</p>

<p><em>Note:</em> For those familiar with the <code class="code">pq</code> program, <code class="code">PqDisplayPcPresentation</code> performs menu item 4 of the current menu of the <code class="code">pq</code> program.</p>

<p><a id="X80410979854280E1" name="X80410979854280E1"></a></p>

<h5>5.5-8 PqSetOutputLevel</h5>

<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ PqSetOutputLevel</code>( <var class="Arg">i</var>, <var class="Arg">lev</var> )</td><td class="tdright">( function )</td></tr></table></div>
<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ PqSetOutputLevel</code>( <var class="Arg">lev</var> )</td><td class="tdright">( function )</td></tr></table></div>
<p>for the <var class="Arg">i</var>th or default interactive <strong class="pkg">ANUPQ</strong> process, direct the <code class="code">pq</code> program to set the output level of the <code class="code">pq</code> program to <var class="Arg">lev</var>.</p>

<p><em>Note:</em> For those familiar with the <code class="code">pq</code> program, <code class="code">PqSetOutputLevel</code> performs menu item 5 of the main (or advanced) <span class="SimpleMath">\(p\)</span>-Quotient menu, or the Standard Presentation menu.</p>

<p><a id="X7B8C72B37AE667F7" name="X7B8C72B37AE667F7"></a></p>

<h5>5.5-9 PqEvaluateIdentities</h5>

<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ PqEvaluateIdentities</code>( <var class="Arg">i:</var> [<var class="Arg">Identities</var> <var class="Arg">:=</var> <var class="Arg">funcs</var>] )</td><td class="tdright">( function )</td></tr></table></div>
<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ PqEvaluateIdentities</code>( <var class="Arg">:</var> [<var class="Arg">Identities</var> <var class="Arg">:=</var> <var class="Arg">funcs</var>] )</td><td class="tdright">( function )</td></tr></table></div>
<p>for the <var class="Arg">i</var>th or default interactive <strong class="pkg">ANUPQ</strong> process, invoke the evaluation of identities defined by the <code class="code">Identities</codeoption, and eliminate any redundant pc generators formed. Since a previous value of <code class="code">Identities</code> is saved in the data record of the process, it is unnecessary to pass the <code class="code">Identities</code> if set previously.</p>

<p><em>Note:</em> This function is mainly implemented at the <strong class="pkg">GAP</strong> level. It does not correspond to a menu item of the <code class="code">pq</code> program.</p>

<p><a id="X7BDD5B278719C630" name="X7BDD5B278719C630"></a></p>

<h4>5.6 <span class="Heading">Commands from the Main <span class="SimpleMath">\(p\)</span>-Quotient menu</span></h4>

<p><a id="X7BF135DD84A781EB" name="X7BF135DD84A781EB"></a></p>

<h5>5.6-1 PqPcPresentation</h5>

<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ PqPcPresentation</code>( <var class="Arg">i:</var> <var class="Arg">options</var> )</td><td class="tdright">( function )</td></tr></table></div>
<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ PqPcPresentation</code>( <var class="Arg">:</var> <var class="Arg">options</var> )</td><td class="tdright">( function )</td></tr></table></div>
<p>for the <var class="Arg">i</var>th or default interactive <strong class="pkg">ANUPQ</strong> process, direct the <code class="code">pq</code> program to compute the pc presentation of the quotient (determined by <var class="Arg">options</var>) of the group of the process, which for process <var class="Arg">i</var> is stored as <code class="code">ANUPQData.io[<var class="Arg">i</var>].group</code>.</p>

<p>The possible <var class="Arg">options</var> are the same as for the interactive <code class="code">Pq</code> (see <code class="func">Pq</code> (<a href="chap5_mj.html#X85408C4C790439E7"><span class="RefLink">5.3-1</span></a>)) function, except for <code class="code">RedoPcp</code> (which, in any case, would be superfluous), namely: <code class="code">Prime</code>, <code class="code">ClassBound</code>, <code class="code">Exponent</code>, <code class="code">Relators</code>, <code class="code">GroupName</code>, <code class="code">Metabelian</code>, <code class="code">Identities</code> and <code class="code">OutputLevel</code> (see Chapter <a href="chap6_mj.html#X7B0946E97E7EB359"><span class="RefLink"><span class="Heading">ANUPQ Options</span></span></a> for a detailed description for these options). The option <code class="code">Prime</code> is required unless already provided to <code class="code">PqStart</code>.</p>

<p><em>Notes</em></p>

<p>The pc presentation is held by the <code class="code">pq</code> program. In contrast to <code class="code">Pq</code> (see <code class="func">Pq</code> (<a href="chap5_mj.html#X85408C4C790439E7"><span class="RefLink">5.3-1</span></a>)), no <strong class="pkg">GAP</strong> pc group is returned; see <code class="code">PqCurrentGroup</code> (<code class="func">PqCurrentGroup</code> (<a href="chap5_mj.html#X79862B83817E20E1"><span class="RefLink">5.5-6</span></a>)) if you need the corresponding <strong class="pkg">GAP</strong> pc group.</p>

<p><code class="code">PqPcPresentation(<var class="Arg">i</var>: <var class="Arg">options</var>);</code> is roughly equivalent to the following sequence of low-level commands:</p>


<div class="example"><pre>
PqPcPresentation(i: opts); #class 1 call
for c in [2 .. class] do
    PqNextClass(i);
od;
</pre></div>

<p>where <var class="Arg">opts</var> is <var class="Arg">options</var> except with the <code class="code">ClassBound</codeoption set to 1, and <var class="Arg">class</var> is either the maximum class of a <var class="Arg">p</var>-quotient of the group of the process or the user-supplied value of the option <code class="code">ClassBound</code> (whichever is smaller). If the <code class="code">Identities</codeoption has been set, both the first <code class="code">PqPcPresentation</code> class 1 call and the <code class="code">PqNextClass</code> calls invoke <code class="code">PqEvaluateIdentities(<var class="Arg">i</var>);</code> as their final step.</p>

<p>For those familiar with the <code class="code">pq</code> program, <code class="code">PqPcPresentation</code> performs menu item 1 of the main <span class="SimpleMath">\(p\)</span>-Quotient menu.</p>

<p><a id="X7D947CEA82C44898" name="X7D947CEA82C44898"></a></p>

<h5>5.6-2 PqSavePcPresentation</h5>

<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ PqSavePcPresentation</code>( <var class="Arg">i</var>, <var class="Arg">filename</var> )</td><td class="tdright">( function )</td></tr></table></div>
<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ PqSavePcPresentation</code>( <var class="Arg">filename</var> )</td><td class="tdright">( function )</td></tr></table></div>
<p>for the <var class="Arg">i</var>th or default interactive <strong class="pkg">ANUPQ</strong> process, direct the <code class="code">pq</code> program to save the pc presentation previously computed for the quotient of the group of that process to the file with name <var class="Arg">filename</var>. If the first character of the string <var class="Arg">filename</var> is not <code class="code">/</code>, <var class="Arg">filename</var> is assumed to be the path of a writable file relative to the directory in which <strong class="pkg">GAP</strong> was started. A saved file may be restored by <code class="code">PqRestorePcPresentation</code> (see <code class="func">PqRestorePcPresentation</code> (<a href="chap5_mj.html#X7FD001C0798EF219"><span class="RefLink">5.6-3</span></a>)).</p>

<p><em>Note:</em> For those familiar with the <code class="code">pq</code> program, <code class="code">PqSavePcPresentation</code> performs menu item 2 of the main <span class="SimpleMath">\(p\)</span>-Quotient menu.</p>

<p><a id="X7FD001C0798EF219" name="X7FD001C0798EF219"></a></p>

<h5>5.6-3 PqRestorePcPresentation</h5>

<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ PqRestorePcPresentation</code>( <var class="Arg">i</var>, <var class="Arg">filename</var> )</td><td class="tdright">( function )</td></tr></table></div>
<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ PqRestorePcPresentation</code>( <var class="Arg">filename</var> )</td><td class="tdright">( function )</td></tr></table></div>
<p>for the <var class="Arg">i</var>th or default interactive <strong class="pkg">ANUPQ</strong> process, direct the <code class="code">pq</code> program to restore the pc presentation previously saved to <var class="Arg">filename</var>, by <code class="code">PqSavePcPresentation</code> (see <code class="func">PqSavePcPresentation</code> (<a href="chap5_mj.html#X7D947CEA82C44898"><span class="RefLink">5.6-2</span></a>)). If the first character of the string <var class="Arg">filename</var> is not <code class="code">/</code>, <var class="Arg">filename</var> is assumed to be the path of a readable file relative to the directory in which <strong class="pkg">GAP</strong> was started.</p>

<p><em>Note:</em> For those familiar with the <code class="code">pq</code> program, <code class="code">PqRestorePcPresentation</code> performs menu item 3 of the main <span class="SimpleMath">\(p\)</span>-Quotient menu.</p>

<p><a id="X832F69597C095A27" name="X832F69597C095A27"></a></p>

<h5>5.6-4 PqNextClass</h5>

<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ PqNextClass</code>( <var class="Arg">i:</var> [<var class="Arg">QueueFactor</var>] )</td><td class="tdright">( function )</td></tr></table></div>
<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ PqNextClass</code>( <var class="Arg">:</var> [<var class="Arg">QueueFactor</var>] )</td><td class="tdright">( function )</td></tr></table></div>
<p>for the <var class="Arg">i</var>th or default interactive <strong class="pkg">ANUPQ</strong> process, direct the <code class="code">pq</code> program to calculate the next class of <code class="code">ANUPQData.io[<var class="Arg">i</var>].group</code>.</p>

<p><code class="code">PqNextClass</code> accepts the option <code class="code">QueueFactor</code> (see also <a href="chap6_mj.html#X87EE6DD67C9996A3"><span class="RefLink">6.2</span></a>) which should be a positive integer if automorphisms have been previously supplied. If the <code class="code">pq</code> program requires a queue factor and none is supplied via the option <code class="code">QueueFactor</code> a default of 15 is taken.</p>

<p><em>Notes</em></p>

<p>The single command: <code class="code">PqNextClass(<var class="Arg">i</var>);</code> is equivalent to executing</p>


<div class="example"><pre>
PqComputePCover(i);
PqCollectDefiningRelations(i);
PqDoExponentChecks(i);
PqEliminateRedundantGenerators(i);
</pre></div>

<p>If the <code class="code">Identities</codeoption is set the <code class="code">PqEliminateRedundantGenerators(<var class="Arg">i</var>);</code> step is essentially replaced by <code class="code">PqEvaluateIdentities(<var class="Arg">i</var>);</code> (which invokes its own elimination of redundant generators).</p>

<p>For those familiar with the <code class="code">pq</code> program, <code class="code">PqNextClass</code> performs menu item 6 of the main <span class="SimpleMath">\(p\)</span>-Quotient menu.</p>

<p><a id="X7CF9DF7A84D387CB" name="X7CF9DF7A84D387CB"></a></p>

<h5>5.6-5 PqComputePCover</h5>

<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ PqComputePCover</code>( <var class="Arg">i</var> )</td><td class="tdright">( function )</td></tr></table></div>
<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ PqComputePCover</code>(  )</td><td class="tdright">( function )</td></tr></table></div>
<p>for the <var class="Arg">i</var>th or default interactive <strong class="pkg">ANUPQ</strong> processi, directi, the <code class="code">pq</code> program to compute the <span class="SimpleMath">\(p\)</span>-covering group of <code class="code">ANUPQData.io[<var class="Arg">i</var>].group</code>. In contrast to the function <code class="code">PqPCover</code> (see <code class="func">PqPCover</code> (<a href="chap4_mj.html#X81C3CE1E850DA252"><span class="RefLink">4.1-3</span></a>)), this function does not return a <strong class="pkg">GAP</strong> pc group.</p>

<p><em>Notes</em></p>

<p>The single command: <code class="code">PqComputePCover(<var class="Arg">i</var>);</code> is equivalent to executing</p>


<div class="example"><pre>
PqSetupTablesForNextClass(i);
PqTails(i, 0);
PqDoConsistencyChecks(i, 0, 0);
PqEliminateRedundantGenerators(i);
</pre></div>

<p>For those familiar with the <code class="code">pq</code> program, <code class="code">PqComputePCover</code> performs menu item 7 of the main <span class="SimpleMath">\(p\)</span>-Quotient menu.</p>

<p><a id="X7D27BE937B1DE16E" name="X7D27BE937B1DE16E"></a></p>

<h4>5.7 <span class="Heading">Commands from the Advanced <span class="SimpleMath">\(p\)</span>-Quotient menu</span></h4>

<p><a id="X8633356078CA4115" name="X8633356078CA4115"></a></p>

<h5>5.7-1 PqCollect</h5>

<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ PqCollect</code>( <var class="Arg">i</var>, <var class="Arg">word</var> )</td><td class="tdright">( function )</td></tr></table></div>
<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ PqCollect</code>( <var class="Arg">word</var> )</td><td class="tdright">( function )</td></tr></table></div>
<p>for the <var class="Arg">i</var>th or default interactive <strong class="pkg">ANUPQ</strong> process, instruct the <code class="code">pq</code> program to do a collection on <var class="Arg">word</var>, a word in the current pc generators (the form of <var class="Arg">word</var> required is described below). <code class="code">PqCollect</code> 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 <var class="Arg">word</var>; see below).</p>

<p>The argument <var class="Arg">word</var> may be input in either of the following ways:</p>

<ol>
<li><p><var class="Arg">word</var> may be a string, where the <var class="Arg">i</var>th pc generator is represented by <code class="code">x<var class="Arg">i</var></code>, e.g. <code class="code">"x3*x2^2*x1"</code>. This way is quite versatile as parentheses and left-normed commutators -- using square brackets, in the same way as <code class="code">PqGAPRelators</code> (see <code class="func">PqGAPRelators</code> (<a href="chap3_mj.html#X7A567432879510A6"><span class="RefLink">3.4-2</span></a>)) -- are permitted; <var class="Arg">word</var> is checked for correct syntax via <code class="code">PqParseWord</code> (see <code class="func">PqParseWord</code> (<a href="chap3_mj.html#X7F3C5D1C7EC36EAE"><span class="RefLink">3.4-3</span></a>)).</p>

</li>
<li><p>Otherwise, <var class="Arg">word</var> must be a list of generator number, exponent pairs of integers, i.e.  each pair represents a <q>syllable</q> so that <code class="code">[ [3, 1], [2, 2], [1, 1] ]</code> represents the same word as that of the example given for the first allowed form of <var class="Arg">word</var>.</p>

</li>
</ol>
<p><em>Note:</em> For those familiar with the <code class="code">pq</code> program, <code class="code">PqCollect</code> performs menu item 1 of the Advanced <span class="SimpleMath">\(p\)</span>-Quotient menu.</p>

<p><a id="X86CCB77281FDC0FC" name="X86CCB77281FDC0FC"></a></p>

<h5>5.7-2 PqSolveEquation</h5>

<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ PqSolveEquation</code>( <var class="Arg">i</var>, <var class="Arg">a</var>, <var class="Arg">b</var> )</td><td class="tdright">( function )</td></tr></table></div>
<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ PqSolveEquation</code>( <var class="Arg">a</var>, <var class="Arg">b</var> )</td><td class="tdright">( function )</td></tr></table></div>
<p>for the <var class="Arg">i</var>th or default interactive <strong class="pkg">ANUPQ</strong> process, direct the <code class="code">pq</code> program to solve <span class="SimpleMath">\(\textit{a} * \textit{x} = \textit{b}\)</span> for <var class="Arg">x</var>, where <var class="Arg">a</var> and <var class="Arg">b</var> are words in the pc generators. For the representation of these words see the description of the function <code class="code">PqCollect</code> (<code class="func">PqCollect</code> (<a href="chap5_mj.html#X8633356078CA4115"><span class="RefLink">5.7-1</span></a>)).</p>

<p><em>Note:</em> For those familiar with the <code class="code">pq</code> program, <code class="code">PqSolveEquation</code> performs menu item 2 of the Advanced <span class="SimpleMath">\(p\)</span>-Quotient menu.</p>

<p><a id="X789B120B7E2F3017" name="X789B120B7E2F3017"></a></p>

<h5>5.7-3 PqCommutator</h5>

<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ PqCommutator</code>( <var class="Arg">i</var>, <var class="Arg">words</var>, <var class="Arg">pow</var)</td><td class="tdright">( function )</td></tr></table></div>
<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ PqCommutator</code>( <var class="Arg">words</var>, <var class="Arg">pow</var> )</td><td class="tdright">( function )</td></tr></table></div>
<p>for the <var class="Arg">i</var>th or default interactive <strong class="pkg">ANUPQ</strong> process, instruct the <code class="code">pq</code> program to compute the left normed commutator of the list <var class="Arg">words</var> of words in the current pc generators raised to the integer power <var class="Arg">pow</var>, and return the resulting word as a list of generator number, exponent pairs. The form required for each word of <var class="Arg">words</var> is the same as that required for the <var class="Arg">word</var> argument of <code class="code">PqCollect</code> (see <code class="func">PqCollect</code> (<a href="chap5_mj.html#X8633356078CA4115"><span class="RefLink">5.7-1</span></a>)). The form of the output word is also the same as for <code class="code">PqCollect</code>.</p>

<p><em>Note:</em> For those familiar with the <code class="code">pq</code> program, <code class="code">PqCommutator</code> performs menu item 3 of the Advanced <span class="SimpleMath">\(p\)</span>-Quotient menu.</p>

<p><a id="X7A61A15E78F52743" name="X7A61A15E78F52743"></a></p>

<h5>5.7-4 PqSetupTablesForNextClass</h5>

<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ PqSetupTablesForNextClass</code>( <var class="Arg">i</var> )</td><td class="tdright">( function )</td></tr></table></div>
<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ PqSetupTablesForNextClass</code>(  )</td><td class="tdright">( function )</td></tr></table></div>
<p>for the <var class="Arg">i</var>th or default interactive <strong class="pkg">ANUPQ</strong> process, direct the <code class="code">pq</code> program to set up tables for the next class. As as side-effect, after <code class="code">PqSetupTablesForNextClass(<var class="Arg">i</var>)</code> the value returned by <code class="code">PqPClass(<var class="Arg">i</var>)</code> will be one more than it was previously.</p>

<p><em>Note:</em> For those familiar with the <code class="code">pq</code> program, <code class="code">PqSetupTablesForNextClass</code> performs menu item 6 of the Advanced <span class="SimpleMath">\(p\)</span>-Quotient menu.</p>

<p><a id="X84F7DD8582B368D3" name="X84F7DD8582B368D3"></a></p>

<h5>5.7-5 PqTails</h5>

<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ PqTails</code>( <var class="Arg">i</var>, <var class="Arg">weight</var> )</td><td class="tdright">( function )</td></tr></table></div>
<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ PqTails</code>( <var class="Arg">weight</var> )</td><td class="tdright">( function )</td></tr></table></div>
<p>for the <var class="Arg">i</var>th or default interactive <strong class="pkg">ANUPQ</strong> process, direct the <code class="code">pq</code> program to compute and add tails of weight <var class="Arg">weight</var> if <var class="Arg">weight</var> is in the integer range <code class="code">[2 .. PqPClass(<var class="Arg">i</var>)]</code> (assuming <var class="Arg">i</var> is the number of the process, even in the default case) or for all weights if <code class="code"><var class="Arg">weight</var> = 0</code>.</p>

<p>If <var class="Arg">weight</var> is non-zero, then tails that introduce new generators for only weight <var class="Arg">weight</var> are computed and added, and in this case and if <code class="code"><var class="Arg">weight</var> < PqPClass(<var class="Arg">i</var>)</code>, it is assumed that the tails that introduce new generators for each weight from <code class="code">PqPClass(<var class="Arg">i</var>)</code> down to weight <code class="code"><var class="Arg">weight</var> + 1</code> have already been added. You may wish to call <code class="code">PqSetMetabelian</code> (see <code class="func">PqSetMetabelian</code> (<a href="chap5_mj.html#X87A35ABB7E11595E"><span class="RefLink">5.7-16</span></a>)) prior to calling <code class="code">PqTails</code>.</p>

<p><em>Notes</em></p>

<p>For its use in the context of finding the next class see <code class="func">PqNextClass</code> (<a href="chap5_mj.html#X832F69597C095A27"><span class="RefLink">5.6-4</span></a>); in particular, a call to <code class="code">PqSetupTablesForNextClass</code> (see <code class="func">PqSetupTablesForNextClass</code> (<a href="chap5_mj.html#X7A61A15E78F52743"><span class="RefLink">5.7-4</span></a>)) needs to have been made prior to calling <code class="code">PqTails</code>.</p>

<p>The single command: <code class="code">PqTails(<var class="Arg">i</var>, <var class="Arg">weight</var>);</code> is equivalent to</p>


<div class="example"><pre>
PqComputeTails(i, weight);
PqAddTails(i, weight);
</pre></div>

<p>For those familiar with the <code class="code">pq</code> program, <code class="code">PqTails</code> uses menu item 7 of the Advanced <span class="SimpleMath">\(p\)</span>-Quotient menu.</p>

<p><a id="X8389F6437ED634B8" name="X8389F6437ED634B8"></a></p>

<h5>5.7-6 PqComputeTails</h5>

<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ PqComputeTails</code>( <var class="Arg">i</var>, <var class="Arg">weight</var> )</td><td class="tdright">( function )</td></tr></table></div>
<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ PqComputeTails</code>( <var class="Arg">weight</var> )</td><td class="tdright">( function )</td></tr></table></div>
<p>for the <var class="Arg">i</var>th or default interactive <strong class="pkg">ANUPQ</strong> process, direct the <code class="code">pq</code> program to compute tails of weight <var class="Arg">weight</var> if <var class="Arg">weight</var> is in the integer range <code class="code">[2 .. PqPClass(<var class="Arg">i</var>)]</code> (assuming <var class="Arg">i</var> is the number of the process, even in the default case) or for all weights if <code class="code"><var class="Arg">weight</var> = 0</code>. See <code class="code">PqTails</code> (<code class="func">PqTails</code> (<a href="chap5_mj.html#X84F7DD8582B368D3"><span class="RefLink">5.7-5</span></a>)) for more details.</p>

<p><em>Note:</em> For those familiar with the <code class="code">pq</code> program, <code class="code">PqComputeTails</code> uses menu item 7 of the Advanced <span class="SimpleMath">\(p\)</span>-Quotient menu.</p>

<p><a id="X83CD6D888372DFB8" name="X83CD6D888372DFB8"></a></p>

<h5>5.7-7 PqAddTails</h5>

<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ PqAddTails</code>( <var class="Arg">i</var>, <var class="Arg">weight</var> )</td><td class="tdright">( function )</td></tr></table></div>
<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ PqAddTails</code>( <var class="Arg">weight</var> )</td><td class="tdright">( function )</td></tr></table></div>
<p>for the <var class="Arg">i</var>th or default interactive <strong class="pkg">ANUPQ</strong> process, direct the <code class="code">pq</code> program to add the tails of weight <var class="Arg">weight</var>, previously computed by <code class="code">PqComputeTails</code> (see <code class="func">PqComputeTails</code> (<a href="chap5_mj.html#X8389F6437ED634B8"><span class="RefLink">5.7-6</span></a>)), if <var class="Arg">weight</var> is in the integer range <code class="code">[2 .. PqPClass(<var class="Arg">i</var>)]</code> (assuming <var class="Arg">i</var> is the number of the process, even in the default case) or for all weights if <code class="code"><var class="Arg">weight</var> = 0</code>. See <code class="code">PqTails</code> (<code class="func">PqTails</code> (<a href="chap5_mj.html#X84F7DD8582B368D3"><span class="RefLink">5.7-5</span></a>)) for more details.</p>

<p><em>Note:</em> For those familiar with the <code class="code">pq</code> program, <code class="code">PqAddTails</code> uses menu item 7 of the Advanced <span class="SimpleMath">\(p\)</span>-Quotient menu.</p>

<p><a id="X82AA8FAE85826BB9" name="X82AA8FAE85826BB9"></a></p>

<h5>5.7-8 PqDoConsistencyChecks</h5>

<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ PqDoConsistencyChecks</code>( <var class="Arg">i</var>, <var class="Arg">weight</var>, <var class="Arg">type</var> )</td><td class="tdright">( function )</td></tr></table></div>
<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ PqDoConsistencyChecks</code>( <var class="Arg">weight</var>, <var class="Arg">type</var> )</td><td class="tdright">( function )</td></tr></table></div>
<p>for the <var class="Arg">i</var>th or default interactive <strong class="pkg">ANUPQ</strong> process, do consistency checks for weight <var class="Arg">weight</var> if <var class="Arg">weight</var> is in the integer range <code class="code">[3 .. PqPClass(<var class="Arg">i</var>)]</code> (assuming <var class="Arg">i</var> is the number of the process) or for all weights if <code class="code"><var class="Arg">weight</var> = 0</code>, and for type <var class="Arg">type</var> if <var class="Arg">type</var> is in the range <code class="code">[1, 2, 3]</code> (see below) or for all types if <code class="code"><var class="Arg">type</var> = 0</code>. (For its use in the context of finding the next class see <code class="func">PqNextClass</code> (<a href="chap5_mj.html#X832F69597C095A27"><span class="RefLink">5.6-4</span></a>).)</p>

<p>The <em>type</em> of a consistency check is defined as follows. <code class="code">PqDoConsistencyChecks(<var class="Arg">i</var>, <var class="Arg">weight</var>, <var class="Arg">type</var>)</code> for <var class="Arg">weight</var> in <code class="code">[3 .. PqPClass(<var class="Arg">i</var>)]</code> and the given value of <var class="Arg">type</var> invokes the equivalent of the following <code class="code">PqDoConsistencyCheck</code> calls (see <code class="func">PqDoConsistencyCheck</code> (<a href="chap5_mj.html#X7C7D17F878AA1BAA"><span class="RefLink">5.7-17</span></a>)):</p>


<dl>
<dt><strong class="Mark"><code class="code"><var class="Arg">type</var> = 1</code>:</strong></dt>
<dd><p><code class="code">PqDoConsistencyCheck(<var class="Arg">i</var>, <var class="Arg">a</var>, <var class="Arg">a</var>, <var class="Arg">a</var>)</code> checks <code class="code">2 * PqWeight(<var class="Arg">i</var>, <var class="Arg">a</var>) + 1 = <var class="Arg">weight</var></code>, for pc generators of index <var class="Arg">a</var>.</p>

</dd>
<dt><strong class="Mark"><code class="code"><var class="Arg">type</var> = 2</code>:</strong></dt>
<dd><p><code class="code">PqDoConsistencyCheck(<var class="Arg">i</var>, <var class="Arg">b</var>, <var class="Arg">b</var>, <var class="Arg">a</var>)</code> checks for pc generators of indices <var class="Arg">b</var>, <var class="Arg">a</var> satisfyingx both <code class="code"><var class="Arg">b</var> > <var class="Arg">a</var></code> and <code class="code">PqWeight(<var class="Arg">i</var>, <var class="Arg">b</var>) + PqWeight(<var class="Arg">i</var>, <var class="Arg">a</var>) + 1 = <var class="Arg">weight</var></code>.</p>

</dd>
<dt><strong class="Mark"><code class="code"><var class="Arg">type</var> = 3</code>:</strong></dt>
<dd><p><code class="code">PqDoConsistencyCheck(<var class="Arg">i</var>, <var class="Arg">c</var>, <var class="Arg">b</var>, <var class="Arg">a</var>)</code> checks for pc generators of indices <var class="Arg">c</var>, <var class="Arg">b</var>, <var class="Arg">a</var> satisfying <code class="code"><var class="Arg">c</var> > <var class="Arg">b</var> > <var class="Arg">a</var></code> and the sum of the weights of these generators equals <var class="Arg">weight</var>.</p>

</dd>
</dl>
<p><em>Notes</em></p>

<p><code class="code">PqWeight(<var class="Arg">i</var>, <var class="Arg">j</var>)</code> returns the weight of the <var class="Arg">j</var>th pc generator, for process <var class="Arg">i</var> (see <code class="func">PqWeight</code> (<a href="chap5_mj.html#X7EA3B6917908C20A"><span class="RefLink">5.5-5</span></a>)).</p>

<p>It is assumed that tails for the given weight (or weights) have already been added (see <code class="func">PqTails</code> (<a href="chap5_mj.html#X84F7DD8582B368D3"><span class="RefLink">5.7-5</span></a>)).</p>

<p>For those familiar with the <code class="code">pq</code> program, <code class="code">PqDoConsistencyChecks</code> performs menu item 8 of the Advanced <span class="SimpleMath">\(p\)</span>-Quotient menu.</p>

<p><a id="X7A01EE0382689928" name="X7A01EE0382689928"></a></p>

<h5>5.7-9 PqCollectDefiningRelations</h5>

<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ PqCollectDefiningRelations</code>( <var class="Arg">i</var> )</td><td class="tdright">( function )</td></tr></table></div>
<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ PqCollectDefiningRelations</code>(  )</td><td class="tdright">( function )</td></tr></table></div>
<p>for the <var class="Arg">i</var>th or default interactive <strong class="pkg">ANUPQ</strong> process, direct the <code class="code">pq</code> 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 <code class="func">PqNextClass</code> (<a href="chap5_mj.html#X832F69597C095A27"><span class="RefLink">5.6-4</span></a>)). If the tails operation is not complete then the relations may be evaluated incorrectly.</p>

<p><em>Note:</em> For those familiar with the <code class="code">pq</code> program, <code class="code">PqCollectDefiningRelations</code> performs menu item 9 of the Advanced <span class="SimpleMath">\(p\)</span>-Quotient menu.</p>

<p><a id="X7C2B4C1E7BEB19D5" name="X7C2B4C1E7BEB19D5"></a></p>

<h5>5.7-10 PqCollectWordInDefiningGenerators</h5>

<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ PqCollectWordInDefiningGenerators</code>( <var class="Arg">i</var>, <var class="Arg">word</var> )</td><td class="tdright">( function )</td></tr></table></div>
<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ PqCollectWordInDefiningGenerators</code>( <var class="Arg">word</var> )</td><td class="tdright">( function )</td></tr></table></div>
<p>for the <var class="Arg">i</var>th or default interactive <strong class="pkg">ANUPQ</strong> process, take a user-defined word <var class="Arg">word</var> 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.</p>

<p>The <var class="Arg">word</var> argument may be input in either of the two ways described for <code class="code">PqCollect</code> (see <code class="func">PqCollect</code> (<a href="chap5_mj.html#X8633356078CA4115"><span class="RefLink">5.7-1</span></a>)).</p>

<p><em>Note:</em> For those familiar with the <code class="code">pq</code> program, <code class="code">PqCollectDefiningGenerators</code> performs menu item 23 of the Advanced <span class="SimpleMath">\(p\)</span>-Quotient menu.</p>

<p><a id="X7DB05AA587D7A052" name="X7DB05AA587D7A052"></a></p>

<h5>5.7-11 PqCommutatorDefiningGenerators</h5>

<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ PqCommutatorDefiningGenerators</code>( <var class="Arg">i</var>, <var class="Arg">words</var>, <var class="Arg">pow</var> )</td><td class="tdright">( function )</td></tr></table></div>
<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ PqCommutatorDefiningGenerators</code>( <var class="Arg">words</var>, <var class="Arg">pow</var> )</td><td class="tdright">( function )</td></tr></table></div>
<p>for the <var class="Arg">i</var>th or default interactive <strong class="pkg">ANUPQ</strong> process, take a list <var class="Arg">words</var> 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 <var class="Arg">pow</var>. Each generator is mapped into the current pc presentation. The list <var class="Arg">words</var> is interpreted as a left-normed commutator which is then raised to <var class="Arg">pow</var> and collected with respect to the current pc presentation. The result of the collection is returned as a list of generator number, exponent pairs.</p>

<p><em>Note</em> For those familiar with the <code class="code">pq</code> program, <code class="code">PqCommutatorDefiningGenerators</code> performs menu item 24 of the Advanced <span class="SimpleMath">\(p\)</span>-Quotient menu.</p>

<p><a id="X80E563A97EDE083E" name="X80E563A97EDE083E"></a></p>

<h5>5.7-12 PqDoExponentChecks</h5>

<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ PqDoExponentChecks</code>( <var class="Arg">i:</var> [<var class="Arg">Bounds</var> <var class="Arg">:=</var> <var class="Arg">list</var>] )</td><td class="tdright">( function )</td></tr></table></div>
<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ PqDoExponentChecks</code>( <var class="Arg">:</var> [<var class="Arg">Bounds</var> <var class="Arg">:=</var> <var class="Arg">list</var>] )</td><td class="tdright">( function )</td></tr></table></div>
<p>for the <var class="Arg">i</var>th or default interactive <strong class="pkg">ANUPQ</strong> process, direct the <code class="code">pq</code> program to do exponent checks for weights (inclusively) between the bounds of <code class="code">Bounds</code> or for all weights if <code class="code">Bounds</code> is not given. The value <var class="Arg">list</var> of <code class="code">Bounds</code> (assuming the interactive process is numbered <var class="Arg">i</var>) should be a list of two integers <var class="Arg">low</var>, <var class="Arg">high</var> satisfying <span class="SimpleMath">\(1 \le \textit{low} \le \textit{high} \le \)</span> <code class="code">PqPClass(<var class="Arg">i</var>)</code> (see <code class="func">PqPClass</code> (<a href="chap5_mj.html#X87C7F7EB7C10DC4B"><span class="RefLink">5.5-4</span></a>)). If no exponent law has been specified, no exponent checks are performed.</p>

<p><em>Note:</em> For those familiar with the <code class="code">pq</code> program, <code class="code">PqDoExponentChecks</code> performs menu item 10 of the Advanced <span class="SimpleMath">\(p\)</span>-Quotient menu.</p>

<p><a id="X7BBAB2787B305516" name="X7BBAB2787B305516"></a></p>

<h5>5.7-13 PqEliminateRedundantGenerators</h5>

<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ PqEliminateRedundantGenerators</code>( <var class="Arg">i</var> )</td><td class="tdright">( function )</td></tr></table></div>
<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ PqEliminateRedundantGenerators</code>(  )</td><td class="tdright">( function )</td></tr></table></div>
<p>for the <var class="Arg">i</var>th or default interactive <strong class="pkg">ANUPQ</strong> process, direct the <code class="code">pq</code> program to eliminate redundant generators of the current <span class="SimpleMath">\(p\)</span>-quotient.</p>

<p><em>Note:</em> For those familiar with the <code class="code">pq</code> program, <code class="code">PqEliminateRedundantGenerators</code> performs menu item 11 of the Advanced <span class="SimpleMath">\(p\)</span>-Quotient menu.</p>

<p><a id="X783E53B5853F45E6" name="X783E53B5853F45E6"></a></p>

<h5>5.7-14 PqRevertToPreviousClass</h5>

<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ PqRevertToPreviousClass</code>( <var class="Arg">i</var> )</td><td class="tdright">( function )</td></tr></table></div>
<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ PqRevertToPreviousClass</code>(  )</td><td class="tdright">( function )</td></tr></table></div>
<p>for the <var class="Arg">i</var>th or default interactive <strong class="pkg">ANUPQ</strong> process, direct the <code class="code">pq</code> program to abandon the current class and revert to the previous class.</p>

<p><em>Note:</em> For those familiar with the <code class="code">pq</code> program, <code class="code">PqRevertToPreviousClass</code> performs menu item 12 of the Advanced <span class="SimpleMath">\(p\)</span>-Quotient menu.</p>

<p><a id="X8265A6DB81CD24DB" name="X8265A6DB81CD24DB"></a></p>

<h5>5.7-15 PqSetMaximalOccurrences</h5>

<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ PqSetMaximalOccurrences</code>( <var class="Arg">i</var>, <var class="Arg">noccur</var> )</td><td class="tdright">( function )</td></tr></table></div>
<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ PqSetMaximalOccurrences</code>( <var class="Arg">noccur</var> )</td><td class="tdright">( function )</td></tr></table></div>
<p>for the <var class="Arg">i</var>th or default interactive <strong class="pkg">ANUPQ</strong> process, direct the <code class="code">pq</code> 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.</p>

<p>The argument <var class="Arg">noccur</var> must be a list of non-negative integers of length the number of weight 1 generators (i.e. the rank of the class 1 <span class="SimpleMath">\(p\)</span>-quotient of the group of the process). An entry of <code class="code">0</code> for a particular generator indicates that there is no limit on the number of occurrences for the generator.</p>

<p><em>Note:</em> For those familiar with the <code class="code">pq</code> program, <code class="code">PqSetMaximalOccurrences</code> performs menu item 13 of the Advanced <span class="SimpleMath">\(p\)</span>-Quotient menu.</p>

<p><a id="X87A35ABB7E11595E" name="X87A35ABB7E11595E"></a></p>

<h5>5.7-16 PqSetMetabelian</h5>

<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ PqSetMetabelian</code>( <var class="Arg">i</var> )</td><td class="tdright">( function )</td></tr></table></div>
<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ PqSetMetabelian</code>(  )</td><td class="tdright">( function )</td></tr></table></div>
<p>for the <var class="Arg">i</var>th or default interactive <strong class="pkg">ANUPQ</strong> process, direct the <code class="code">pq</code> program to enforce metabelian-ness.</p>

<p><em>Note:</em> For those familiar with the <code class="code">pq</code> program, <code class="code">PqSetMetabelian</code> performs menu item 14 of the Advanced <span class="SimpleMath">\(p\)</span>-Quotient menu.</p>

<p><a id="X7C7D17F878AA1BAA" name="X7C7D17F878AA1BAA"></a></p>

<h5>5.7-17 PqDoConsistencyCheck</h5>

<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ PqDoConsistencyCheck</code>( <var class="Arg">i</var>, <var class="Arg">c</var>, <var class="Arg">b</var>, <var class="Arg">a</var> )</td><td class="tdright">( function )</td></tr></table></div>
<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ PqDoConsistencyCheck</code>( <var class="Arg">c</var>, <var class="Arg">b</var>, <var class="Arg">a</var> )</td><td class="tdright">( function )</td></tr></table></div>
<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ PqJacobi</code>( <var class="Arg">i</var>, <var class="Arg">c</var>, <var class="Arg">b</var>, <var class="Arg">a</var> )</td><td class="tdright">( function )</td></tr></table></div>
<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ PqJacobi</code>( <var class="Arg">c</var>, <var class="Arg">b</var>, <var class="Arg">a</var> )</td><td class="tdright">( function )</td></tr></table></div>
<p>for the <var class="Arg">i</var>th or default interactive <strong class="pkg">ANUPQ</strong> process, direct the <code class="code">pq</code> program to do the consistency check for the pc generators with indices <var class="Arg">c</var>, <var class="Arg">b</var>, <var class="Arg">a</var> which should be non-increasing positive integers, i.e. <span class="SimpleMath">\(\textit{c} \ge \textit{b} \ge \textit{a}\)</span>.</p>

<p>There are 3 types of consistency checks:</p>

<p class="center">\[
\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}
\]</p>

<p>The reason some people talk about Jacobi relations instead of consistency checks becomes clear when one looks at the consistency check of type 3:</p>

<p class="center">\[
\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}
\]</p>

<p>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:</p>

<p class="center">\[
\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}
\]</p>

<p>Modulo terms of weight 4 this is equivalent to</p>

<p class="center">\[
[c,a,b] [b,c,a] [a,b,c] = 1
\]</p>

<p>which is the Jacobi identity.</p>

<p>See also <code class="code">PqDoConsistencyChecks</code> (<code class="func">PqDoConsistencyChecks</code> (<a href="chap5_mj.html#X82AA8FAE85826BB9"><span class="RefLink">5.7-8</span></a>)).</p>

<p><em>Note:</em> For those familiar with the <code class="code">pq</code> program, <code class="code">PqDoConsistencyCheck</code> and <code class="code">PqJacobi</code> perform menu item 15 of the Advanced <span class="SimpleMath">\(p\)</span>-Quotient menu.</p>

<p><a id="X843953F48319FDE1" name="X843953F48319FDE1"></a></p>

<h5>5.7-18 PqCompact</h5>

<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ PqCompact</code>( <var class="Arg">i</var> )</td><td class="tdright">( function )</td></tr></table></div>
<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ PqCompact</code>(  )</td><td class="tdright">( function )</td></tr></table></div>
<p>for the <var class="Arg">i</var>th or default interactive <strong class="pkg">ANUPQ</strong> process, direct the <code class="code">pq</code> program to do a compaction of its work space. This function is safe to perform only at certain points in time.</p>

<p><em>Note:</em> For those familiar with the <code class="code">pq</code> program, <code class="code">PqCompact</code> performs menu item 16 of the Advanced <span class="SimpleMath">\(p\)</span>-Quotient menu.</p>

<p><a id="X80344EEC78A09ACF" name="X80344EEC78A09ACF"></a></p>

<h5>5.7-19 PqEchelonise</h5>

<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ PqEchelonise</code>( <var class="Arg">i</var> )</td><td class="tdright">( function )</td></tr></table></div>
<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ PqEchelonise</code>(  )</td><td class="tdright">( function )</td></tr></table></div>
<p>for the <var class="Arg">i</var>th or default interactive <strong class="pkg">ANUPQ</strong> process, direct the <code class="code">pq</code> program to echelonise the word most recently collected by <code class="code">PqCollect</code> or <code class="code">PqCommutator</code> against the relations of the current pc presentation, and return the number of the generator made redundant or <code class="keyw">fail</code> if no generator was made redundant. A call to <code class="code">PqCollect</code> (see <code class="func">PqCollect</code> (<a href="chap5_mj.html#X8633356078CA4115"><span class="RefLink">5.7-1</span></a>)) or <code class="code">PqCommutator</code> (see <code class="func">PqCommutator</code> (<a href="chap5_mj.html#X789B120B7E2F3017"><span class="RefLink">5.7-3</span></a>)) needs to be performed prior to using this command.</p>

<p><em>Note:</em> For those familiar with the <code class="code">pq</code> program, <code class="code">PqEchelonise</code> performs menu item 17 of the Advanced <span class="SimpleMath">\(p\)</span>-Quotient menu.</p>

<p><a id="X852947327FC39DDF" name="X852947327FC39DDF"></a></p>

<h5>5.7-20 PqSupplyAutomorphisms</h5>

<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ PqSupplyAutomorphisms</code>( <var class="Arg">i</var>, <var class="Arg">mlist</var> )</td><td class="tdright">( function )</td></tr></table></div>
<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ PqSupplyAutomorphisms</code>( <var class="Arg">mlist</var> )</td><td class="tdright">( function )</td></tr></table></div>
<p>for the <var class="Arg">i</var>th or default interactive <strong class="pkg">ANUPQ</strong> process, supply the automorphism data provided by the list <var class="Arg">mlist</var> of matrices with non-negative integer coefficients. Each matrix in <var class="Arg">mlist</var> describes one automorphism in the following way.</p>


<ul>
<li><p>The rows of each matrix correspond to the pc generators of weight one.</p>

</li>
<li><p>Each row is the exponent vector of the image of the corresponding weight one generator under the respective automorphism.</p>

</li>
</ul>
<p><em>Note:</em> For those familiar with the <code class="code">pq</code> program, <code class="code">PqSupplyAutomorphisms</code> uses menu item 18 of the Advanced <span class="SimpleMath">\(p\)</span>-Quotient menu.</p>

<p><a id="X7B919B537C042DAD" name="X7B919B537C042DAD"></a></p>

<h5>5.7-21 PqExtendAutomorphisms</h5>

<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ PqExtendAutomorphisms</code>( <var class="Arg">i</var> )</td><td class="tdright">( function )</td></tr></table></div>
<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ PqExtendAutomorphisms</code>(  )</td><td class="tdright">( function )</td></tr></table></div>
<p>for the <var class="Arg">i</var>th or default interactive <strong class="pkg">ANUPQ</strong> process, direct the <code class="code">pq</code> program to extend automorphisms of the <span class="SimpleMath">\(p\)</span>-quotient of the previous class to the <span class="SimpleMath">\(p\)</span>-quotient of the present class.</p>

<p><em>Note:</em> For those familiar with the <code class="code">pq</code> program, <code class="code">PqExtendAutomorphisms</code> uses menu item 18 of the Advanced <span class="SimpleMath">\(p\)</span>-Quotient menu.</p>

<p><a id="X7CFD54657DE4BD39" name="X7CFD54657DE4BD39"></a></p>

<h5>5.7-22 PqApplyAutomorphisms</h5>

<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ PqApplyAutomorphisms</code>( <var class="Arg">i</var>, <var class="Arg">qfac</var> )</td><td class="tdright">( function )</td></tr></table></div>
<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ PqApplyAutomorphisms</code>( <var class="Arg">qfac</var> )</td><td class="tdright">( function )</td></tr></table></div>
<p>for the <var class="Arg">i</var>th or default interactive <strong class="pkg">ANUPQ</strong> process, direct the <code class="code">pq</code> program to apply automorphisms; <var class="Arg">qfac</var> is the queue factor e.g. <code class="code">15</code>.</p>

<p><em>Note:</em> For those familiar with the <code class="code">pq</code> program, <code class="code">PqCloseRelations</code> performs menu item 19 of the Advanced <span class="SimpleMath">\(p\)</span>-Quotient menu.</p>

<p><a id="X81A3D5BF87A34934" name="X81A3D5BF87A34934"></a></p>

<h5>5.7-23 PqDisplayStructure</h5>

<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ PqDisplayStructure</code>( <var class="Arg">i:</var> [<var class="Arg">Bounds</var> <var class="Arg">:=</var> <var class="Arg">list</var>] )</td><td class="tdright">( function )</td></tr></table></div>
<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ PqDisplayStructure</code>( <var class="Arg">:</var> [<var class="Arg">Bounds</var> <var class="Arg">:=</var> <var class="Arg">list</var>] )</td><td class="tdright">( function )</td></tr></table></div>
<p>for the <var class="Arg">i</var>th or default interactive <strong class="pkg">ANUPQ</strong> process, direct the <code class="code">pq</code> program to display the structure for the pcp generators numbered (inclusively) between the bounds of <code class="code">Bounds</code> or for all generators if <code class="code">Bounds</code> is not given. The value <var class="Arg">list</var> of <code class="code">Bounds</code> (assuming the interactive process is numbered <var class="Arg">i</var>) should be a list of two integers <var class="Arg">low</var>, <var class="Arg">high</var> satisfying <span class="SimpleMath">\(1 \le \textit{low} \le \textit{high} \le \)</span> <code class="code">PqNrPcGenerators(<var class="Arg">i</var>)</code> (see <code class="func">PqNrPcGenerators</code> (<a href="chap5_mj.html#X7DE2F6C686C672DD"><span class="RefLink">5.5-1</span></a>)). <code class="code">PqDisplayStructure</code> also accepts the option <code class="code">OutputLevel</code> (see <a href="chap6_mj.html#X87EE6DD67C9996A3"><span class="RefLink">6.2</span></a>).</p>

<p><em>Explanation of output</em></p>

<p>New generators are defined as commutators of previous generators and generators of class 1 or as <span class="SimpleMath">\(p\)</span>-th powers of generators that have themselves been defined as <span class="SimpleMath">\(p\)</span>-th powers. A generator is never defined as <span class="SimpleMath">\(p\)</span>-th power of a commutator.</p>

<p>Therefore, there are two cases: all the numbers on the righthand side are either the same or they differ. Below, <code class="code">g<var class="Arg">i</var></code> refers to the <var class="Arg">i</var>th defining generator.</p>


<ul>
<li><p>If the righthand side numbers are all the same, then the generator is a <span class="SimpleMath">\(p\)</span>-th power (of a <span class="SimpleMath">\(p\)</span>-th power of a <span class="SimpleMath">\(p\)</span>-th power, etc.). The number of repeated digits say how often a <span class="SimpleMath">\(p\)</span>-th power has to be taken.</p>

<p>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:</p>

<p>\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.</p>

</li>
<li><p>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.</p>

<p>\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 <code class="code">[x2, x1, x1, x1, x1]</code>. One can check this by tracing back the definition of generator 11 until one gets to a generator of class 1.</p>

</li>
<li><p>If the first two generator numbers are identical, then the left most component of the left-normed commutator is a <span class="SimpleMath">\(p\)</span>-th power, e.g.</p>

<p>\begintt #I 25 is defined on [14, 1] = 1 1 2 1 1 \endtt</p>

<p>In this example, generator 25 is defined as commutator of generator 14 and generator 1. The left-normed commutator is</p>

<p class="center">\[
[(x1^{11})^{11}, x2, x1, x1]
\]</p>

<p>Again, this can be verified by tracing back the definitions.</p>

</li>
</ul>
<p><em>Note:</em> For those familiar with the <code class="code">pq</code> program, <code class="code">PqDisplayStructure</code> performs menu item 20 of the Advanced <span class="SimpleMath">\(p\)</span>-Quotient menu.</p>

<p><a id="X853834B478C4EEE2" name="X853834B478C4EEE2"></a></p>

<h5>5.7-24 PqDisplayAutomorphisms</h5>

<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ PqDisplayAutomorphisms</code>( <var class="Arg">i:</var> [<var class="Arg">Bounds</var> <var class="Arg">:=</var> <var class="Arg">list</var>] )</td><td class="tdright">( function )</td></tr></table></div>
<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ PqDisplayAutomorphisms</code>( <var class="Arg">:</var> [<var class="Arg">Bounds</var> <var class="Arg">:=</var> <var class="Arg">list</var>] )</td><td class="tdright">( function )</td></tr></table></div>
<p>for the <var class="Arg">i</var>th or default interactive <strong class="pkg">ANUPQ</strong> process, direct the <code class="code">pq</code> program to display the automorphism actions on the pcp generators numbered (inclusively) between the bounds of <code class="code">Bounds</code> or for all generators if <code class="code">Bounds</code> is not given. The value <var class="Arg">list</var> of <code class="code">Bounds</code> (assuming the interactive process is numbered <var class="Arg">i</var>) should be a list of two integers <var class="Arg">low</var>, <var class="Arg">high</var> satisfying <span class="SimpleMath">\(1 \le \textit{low} \le \textit{high} \le \)</span> <code class="code">PqNrPcGenerators(<var class="Arg">i</var>)</code> (see <code class="func">PqNrPcGenerators</code> (<a href="chap5_mj.html#X7DE2F6C686C672DD"><span class="RefLink">5.5-1</span></a>)). <code class="code">PqDisplayStructure</code> also accepts the option <code class="code">OutputLevel</code> (see <a href="chap6_mj.html#X87EE6DD67C9996A3"><span class="RefLink">6.2</span></a>).</p>

<p><em>Note:</em> For those familiar with the <code class="code">pq</code> program, <code class="code">PqDisplayAutomorphisms</code> performs menu item 21 of the Advanced <span class="SimpleMath">\(p\)</span>-Quotient menu.</p>

<p><a id="X80687A138626EB2D" name="X80687A138626EB2D"></a></p>

<h5>5.7-25 PqWritePcPresentation</h5>

<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ PqWritePcPresentation</code>( <var class="Arg">i</var>, <var class="Arg">filename</var> )</td><td class="tdright">( function )</td></tr></table></div>
<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ PqWritePcPresentation</code>( <var class="Arg">filename</var> )</td><td class="tdright">( function )</td></tr></table></div>
<p>for the <var class="Arg">i</var>th or default interactive <strong class="pkg">ANUPQ</strong> process, direct the <code class="code">pq</code> program to write a pc presentation of a previously-computed quotient of the group of that process, to the file with name <var class="Arg">filename</var>. Here the group of a process is the one given as first argument when <code class="code">PqStart</code> was called to initiate that process (for process <var class="Arg">i</var> the group is stored as <code class="code">ANUPQData.io[<var class="Arg">i</var>].group</code>). If the first character of the string <var class="Arg">filename</var> is not <code class="code">/</code>, <var class="Arg">filename</var> is assumed to be the path of a writable file relative to the directory in which <strong class="pkg">GAP</strong> was started. If a pc presentation has not been previously computed by the <code class="code">pq</code> program, then <code class="code">pq</code> is called to compute it first, effectively invoking <code class="code">PqPcPresentation</code> (see <code class="func">PqPcPresentation</code> (<a href="chap5_mj.html#X7BF135DD84A781EB"><span class="RefLink">5.6-1</span></a>)).</p>

<p><em>Note:</em> For those familiar with the <code class="code">pq</code> program, <code class="code">PqPcWritePresentation</code> performs menu item 25 of the Advanced <span class="SimpleMath">\(p\)</span>-Quotient menu.</p>

<p><a id="X7B94EDA385FDD904" name="X7B94EDA385FDD904"></a></p>

<h4>5.8 <span class="Heading">Commands from the Standard Presentation menu</span></h4>

<p><a id="X78D1963D85C71B7B" name="X78D1963D85C71B7B"></a></p>

<h5>5.8-1 PqSPComputePcpAndPCover</h5>

<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ PqSPComputePcpAndPCover</code>( <var class="Arg">i:</var> <var class="Arg">options</var> )</td><td class="tdright">( function )</td></tr></table></div>
<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ PqSPComputePcpAndPCover</code>( <var class="Arg">:</var> <var class="Arg">options</var> )</td><td class="tdright">( function )</td></tr></table></div>
<p>for the <var class="Arg">i</var>th or default interactive <strong class="pkg">ANUPQ</strong> process, directs the <code class="code">pq</code> program to compute for the group of that process a pc presentation up to the <span class="SimpleMath">\(p\)</span>-quotient of maximum class or the value of the option <code class="code">ClassBound</code> and the <span class="SimpleMath">\(p\)</span>-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 <code class="code">PqStart</code> was called to initiate that process (for process <var class="Arg">i</var> the group is stored as <code class="code">ANUPQData.io[<var class="Arg">i</var>].group</code>).</p>

<p>The possible <var class="Arg">options</var> are <code class="code">Prime</code>, <code class="code">ClassBound</code>, <code class="code">Relators</code>, <code class="code">Exponent</code>, <code class="code">Metabelian</code> and <code class="code">OutputLevel</code> (see Chapter <a href="chap6_mj.html#X7B0946E97E7EB359"><span class="RefLink"><span class="Heading">ANUPQ Options</span></span></a> for detailed descriptions of these options). The option <code class="code">Prime</code> is normally determined via <code class="code">PrimePGroup</code>, and so is not required unless the group doesn't know it's a <span class="SimpleMath">\(p\)</span>-group and <code class="code">HasPrimePGroup</code> returns <code class="keyw">false</code>.</p>

<p><em>Note:</em> For those familiar with the <code class="code">pq</code> program, <code class="code">PqSPComputePcpAndPCover</code> performs option 1 of the Standard Presentation menu.</p>

<p><a id="X876F30187E89E467" name="X876F30187E89E467"></a></p>

<h5>5.8-2 PqSPStandardPresentation</h5>

<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ PqSPStandardPresentation</code>( <var class="Arg">i</var>[, <var class="Arg">mlist</var>]<var class="Arg">:</var> [<var class="Arg">options</var>] )</td><td class="tdright">( function )</td></tr></table></div>
<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ PqSPStandardPresentation</code>( [<var class="Arg">mlist</var>]<var class="Arg">:</var> [<var class="Arg">options</var>] )</td><td class="tdright">( function )</td></tr></table></div>
<p>for the <var class="Arg">i</var>th or default interactive <strong class="pkg">ANUPQ</strong> process, inputs data given by <var class="Arg">options</var> to compute a standard presentation for the group of that process. If argument <var class="Arg">mlist</var> is given it is assumed to be the automorphism group data required. Otherwise it is assumed that a call to either <code class="code">Pq</code> (see <code class="func">Pq</code> (<a href="chap5_mj.html#X85408C4C790439E7"><span class="RefLink">5.3-1</span></a>)) or <code class="code">PqEpimorphism</code> (see <code class="func">PqEpimorphism</code> (<a href="chap5_mj.html#X839E6F578227A8EA"><span class="RefLink">5.3-2</span></a>)) has generated a <span class="SimpleMath">\(p\)</span>-quotient and that <strong class="pkg">GAP</strong> 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 <code class="code">PqStart</code> was called to initiate the process (for process <var class="Arg">i</var> the group is stored as <code class="code">ANUPQData.io[<var class="Arg">i</var>].group</code> and the <span class="SimpleMath">\(p\)</span>-quotient if existent is stored as <code class="code">ANUPQData.io[<var class="Arg">i</var>].pQuotient</code>). If <var class="Arg">mlist</var> is not given and a <span class="SimpleMath">\(p\)</span>-quotient of the group has not been previously computed a class 1 <span class="SimpleMath">\(p\)</span>-quotient is computed.</p>

<p><code class="code">PqSPStandardPresentation</code> accepts three options, all optional:</p>


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

</li>
<li><p><code class="code">PcgsAutomorphisms</code></p>

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

</li>
</ul>
<p>If <code class="code">ClassBound</code> is omitted it defaults to 63.</p>

<p>Detailed descriptions of the above options may be found in Chapter <a href="chap6_mj.html#X7B0946E97E7EB359"><span class="RefLink"><span class="Heading">ANUPQ Options</span></span></a>.</p>

<p><em>Note:</em> For those familiar with the <code class="code">pq</code> program, <code class="code">PqSPPcPresentation</code> performs menu item 2 of the Standard Presentation menu.</p>

<p><a id="X7E1B2B088322F48A" name="X7E1B2B088322F48A"></a></p>

<h5>5.8-3 PqSPSavePresentation</h5>

<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ PqSPSavePresentation</code>( <var class="Arg">i</var>, <var class="Arg">filename</var> )</td><td class="tdright">( function )</td></tr></table></div>
<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ PqSPSavePresentation</code>( <var class="Arg">filename</var> )</td><td class="tdright">( function )</td></tr></table></div>
<p>for the <var class="Arg">i</var>th or default interactive <strong class="pkg">ANUPQ</strong> process, directs the <code class="code">pq</code> program to save the standard presentation previously computed for the group of that process to the file with name <var class="Arg">filename</var>, where the group of a process is the one given as first argument when <code class="code">PqStart</codewas called to initiate that process. If the first character of the string <var class="Arg">filename</var> is not <code class="code">/</code>, <var class="Arg">filename</var> is assumed to be the path of a writable file relative to the directory in which <strong class="pkg">GAP</strong> was started.</p>

<p><em>Note:</em> For those familiar with the <code class="code">pq</code> program, <code class="code">PqSPSavePresentation</code> performs menu item 3 of the Standard Presentation menu.</p>

<p><a id="X81D2F9FF7C241D1E" name="X81D2F9FF7C241D1E"></a></p>

<h5>5.8-4 PqSPCompareTwoFilePresentations</h5>

<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ PqSPCompareTwoFilePresentations</code>( <var class="Arg">i</var>, <var class="Arg">f1</var>, <var class="Arg">f2</var> )</td><td class="tdright">( function )</td></tr></table></div>
<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ PqSPCompareTwoFilePresentations</code>( <var class="Arg">f1</var>, <var class="Arg">f2</var> )</td><td class="tdright">( function )</td></tr></table></div>
<p>for the <var class="Arg">i</var>th or default interactive <strong class="pkg">ANUPQ</strong> process, direct the <code class="code">pq</code> program to compare the presentations in the files with names <var class="Arg">f1</var> and <var class="Arg">f2</var> and returns <code class="keyw">true</code> if they are identical and <code class="keyw">false</code> otherwise. For each of the strings <var class="Arg">f1</var> and <var class="Arg">f2</var>, if the first character is not a <code class="code">/</code> then it is assumed to be the path of a readable file relative to the directory in which <strong class="pkg">GAP</strong> was started.</p>

<p><em>Notes</em></p>

<p>The presentations in files <var class="Arg">f1</var> and <var class="Arg">f2</var> must have been generated by the <code class="code">pq</code> program but they do <em>not</em> need to be <em>standard</empresentations. If If the presentations in files <var class="Arg">f1</var> and <var class="Arg">f2</var> <em>have</em> been generated by <code class="code">PqSPStandardPresentation</code> (see <code class="func">PqSPStandardPresentation</code> (<a href="chap5_mj.html#X876F30187E89E467"><span class="RefLink">5.8-2</span></a>)) then a <code class="keyw">false</code> response from <code class="code">PqSPCompareTwoFilePresentations</code> says the groups defined by those presentations are <em>not</em> isomorphic.</p>

<p>For those familiar with the <code class="code">pq</code> program, <code class="code">PqSPCompareTwoFilePresentations</code> performs menu item 6 of the Standard Presentation menu.</p>

<p><a id="X7D1277E584590ECE" name="X7D1277E584590ECE"></a></p>

<h5>5.8-5 PqSPIsomorphism</h5>

<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ PqSPIsomorphism</code>( <var class="Arg">i</var> )</td><td class="tdright">( function )</td></tr></table></div>
<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ PqSPIsomorphism</code>(  )</td><td class="tdright">( function )</td></tr></table></div>
<p>for the <var class="Arg">i</var>th or default interactive <strong class="pkg">ANUPQ</strong> process, direct the <code class="code">pq</code> program to compute the isomorphism mapping from the <span class="SimpleMath">\(p\)</span>-group of the process to its standard presentation. This function provides a description only; for a <strong class="pkg">GAP</strongobject, use <code class="code">EpimorphismStandardPresentation</code> (see <code class="func">EpimorphismStandardPresentation</code> (<a href="chap5_mj.html#X791392977B2D692D"><span class="RefLink">5.3-5</span></a>)).</p>

<p><em>Note:</em> For those familiar with the <code class="code">pq</code> program, <code class="code">PqSPIsomorphism</code> performs menu item 8 of the Standard Presentation menu.</p>

<p><a id="X8490031B7AA7F237" name="X8490031B7AA7F237"></a></p>

<h4>5.9 <span class="Heading">Commands from the Main <span class="SimpleMath">\(p\)</span>-Group Generation menu</span></h4>

<p>Note that the <span class="SimpleMath">\(p\)</span>-group generation commands can only be applied once the <code class="code">pq</code> program has produced a pc presentation of some quotient group of the <q>group of the process</q>.</p>

<p><a id="X794A8D667A9D725A" name="X794A8D667A9D725A"></a></p>

<h5>5.9-1 PqPGSupplyAutomorphisms</h5>

<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ PqPGSupplyAutomorphisms</code>( <var class="Arg">i</var>[, <var class="Arg">mlist</var>]<var class="Arg">:</var> <var class="Arg">options</var> )</td><td class="tdright">( function )</td></tr></table></div>
<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ PqPGSupplyAutomorphisms</code>( [<var class="Arg">mlist</var>]<var class="Arg">:</var> <var class="Arg">options</var> )</td><td class="tdright">( function )</td></tr></table></div>
<p>for the <var class="Arg">i</var>th or default interactive <strong class="pkg">ANUPQ</strong> process, supply the <code class="code">pq</code> program with the automorphism group data needed for the current quotient of the group of that process (for process <var class="Arg">i</var> the group is stored as <code class="code">ANUPQData.io[<var class="Arg">i</var>].group</code>). For a description of the format of <var class="Arg">mlist</var> see <code class="func">PqSupplyAutomorphisms</code> (<a href="chap5_mj.html#X852947327FC39DDF"><span class="RefLink">5.7-20</span></a>). The options possible are <code class="code">NumberOfSolubleAutomorphisms</code> and <code class="code">RelativeOrders</code>. (Detailed descriptions of these options may be found in Chapter <a href="chap6_mj.html#X7B0946E97E7EB359"><span class="RefLink"><span class="Heading">ANUPQ Options</span></span></a>.)</p>

<p>If <var class="Arg">mlist</var> is omitted, the automorphism data is determined from the group of the process which must have been a <span class="SimpleMath">\(p\)</span>-group in pc presentation.</p>

<p><em>Note:</em> For those familiar with the <code class="code">pq</code> program, <code class="code">PqPGSupplyAutomorphisms</code> performs menu item 1 of the main <span class="SimpleMath">\(p\)</span>-Group Generation menu.</p>

<p><a id="X87F251077C65B6DD" name="X87F251077C65B6DD"></a></p>

<h5>5.9-2 PqPGExtendAutomorphisms</h5>

<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ PqPGExtendAutomorphisms</code>( <var class="Arg">i</var> )</td><td class="tdright">( function )</td></tr></table></div>
<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ PqPGExtendAutomorphisms</code>(  )</td><td class="tdright">( function )</td></tr></table></div>
<p>for the <var class="Arg">i</var>th or default interactive <strong class="pkg">ANUPQ</strong> process, direct the <code class="code">pq</code> program to compute the extensions of the automorphisms of the <span class="SimpleMath">\(p\)</span>-quotient of the previous class to the <span class="SimpleMath">\(p\)</span>-quotient of the current class. You may wish to set the <code class="code">InfoLevel</code> of <code class="code">InfoANUPQ</code> to 2 (or more) in order to see the output from the <code class="code">pq</code> program (see <code class="func">InfoANUPQ</code> (<a href="chap3_mj.html#X7CBC9B458497BFF1"><span class="RefLink">3.3-1</span></a>)).</p>

<p><em>Note:</em> For those familiar with the <code class="code">pq</code> program, <code class="code">PqPGExtendAutomorphisms</code> performs menu item 2 of the main or advanced <span class="SimpleMath">\(p\)</span>-Group Generation menu.</p>

<p><a id="X82FD51A27D269E43" name="X82FD51A27D269E43"></a></p>

<h5>5.9-3 PqPGConstructDescendants</h5>

<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ PqPGConstructDescendants</code>( <var class="Arg">i:</var> <var class="Arg">options</var> )</td><td class="tdright">( function )</td></tr></table></div>
<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ PqPGConstructDescendants</code>( <var class="Arg">:</var> <var class="Arg">options</var> )</td><td class="tdright">( function )</td></tr></table></div>
<p>for the <var class="Arg">i</var>th or default interactive <strong class="pkg">ANUPQ</strong> process, direct the <code class="code">pq</code> program to construct descendants prescribed by <var class="Arg">options</var>, and return the number of descendants constructed (compare function <code class="func">PqDescendants</code> (<a href="chap4_mj.html#X80985CC479CD9FA3"><span class="RefLink">4.4-1</span></a>) which returns the list of descendants). The options possible are <code class="code">ClassBound</code>, <code class="code">OrderBound</code>, <code class="code">StepSize</code>, <code class="code">PcgsAutomorphisms</code>, <code class="code">RankInitialSegmentSubgroups</code>, <code class="code">SpaceEfficient</code>, <code class="code">CapableDescendants</code>, <code class="code">AllDescendants</code>, <code class="code">Exponent</code>, <code class="code">Metabelian</code>, <code class="code">BasicAlgorithm</code>, <code class="code">CustomiseOutput</code>. (Detailed descriptions of these options may be found in Chapter <a href="chap6_mj.html#X7B0946E97E7EB359"><span class="RefLink"><span class="Heading">ANUPQ Options</span></span></a>.)</p>

<p><code class="code">PqPGConstructDescendants</code> requires that the <code class="code">pq</code> program has previously computed a pc presentation and a <span class="SimpleMath">\(p\)</span>-cover for a <span class="SimpleMath">\(p\)</span>-quotient of some class of the group of the process.</p>

<p><em>Note:</em> For those familiar with the <code class="code">pq</code> program, <code class="code">PqPGConstructDescendants</code> performs menu item 5 of the main <span class="SimpleMath">\(p\)</span>-Group Generation menu.</p>

<p><a id="X7E9D511385D48A98" name="X7E9D511385D48A98"></a></p>

<h5>5.9-4 PqPGSetDescendantToPcp</h5>

<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ PqPGSetDescendantToPcp</code>( <var class="Arg">i</var>, <var class="Arg">cls</var>, <var class="Arg">n</var> )</td><td class="tdright">( function )</td></tr></table></div>
<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ PqPGSetDescendantToPcp</code>( <var class="Arg">cls</var>, <var class="Arg">n</var> )</td><td class="tdright">( function )</td></tr></table></div>
<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ PqPGSetDescendantToPcp</code>( <var class="Arg">i:</var> [<var class="Arg">Filename</var> <var class="Arg">:=</var> <var class="Arg">name</var>] )</td><td class="tdright">( function )</td></tr></table></div>
<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ PqPGSetDescendantToPcp</code>( <var class="Arg">:</var> [<var class="Arg">Filename</var> <var class="Arg">:=</var> <var class="Arg">name</var>] )</td><td class="tdright">( function )</td></tr></table></div>
<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ PqPGRestoreDescendantFromFile</code>( <var class="Arg">i</var>, <var class="Arg">cls</var>, <var class="Arg">n</var> )</td><td class="tdright">( function )</td></tr></table></div>
<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ PqPGRestoreDescendantFromFile</code>( <var class="Arg">cls</var>, <var class="Arg">n</var> )</td><td class="tdright">( function )</td></tr></table></div>
<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ PqPGRestoreDescendantFromFile</code>( <var class="Arg">i:</var> [<var class="Arg">Filename</var> <var class="Arg">:=</var> <var class="Arg">name</var>] )</td><td class="tdright">( function )</td></tr></table></div>
<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ PqPGRestoreDescendantFromFile</code>( <var class="Arg">:</var> [<var class="Arg">Filename</var> <var class="Arg">:=</var> <var class="Arg">name</var>] )</td><td class="tdright">( function )</td></tr></table></div>
<p>for the <var class="Arg">i</var>th or default interactive <strong class="pkg">ANUPQ</strong> process, direct the <code class="code">pq</code> program to restore group <var class="Arg">n</var> of class <var class="Arg">cls</var> from a temporary file, where <var class="Arg">cls</var> and <var class="Arg">n</var> are positive integers, or the group stored in <var class="Arg">name</var>. <code class="code">PqPGSetDescendantToPcp</code> and <code class="code">PqPGRestoreDescendantFromFile</code> are synonyms; they make sense only after a prior call to construct descendants by say <code class="code">PqPGConstructDescendants</code> (see <code class="func">PqPGConstructDescendants</code> (<a href="chap5_mj.html#X82FD51A27D269E43"><span class="RefLink">5.9-3</span></a>)) or the interactive <code class="code">PqDescendants</code> (see <code class="func">PqDescendants</code> (<a href="chap5_mj.html#X795817217C53AB89"><span class="RefLink">5.3-6</span></a>)). In the <code class="code">Filename</codeoption forms, the option defaults to the last filename in which a presentation was stored by the <code class="code">pq</code> program.</p>

<p><em>Notes</em></p>

<p>Since the <code class="code">PqPGSetDescendantToPcp</code> and <code class="code">PqPGRestoreDescendantFromFile</code> are intended to be used in calculation of further descendants the <code class="code">pq</code> program computes the <span class="SimpleMath">\(p\)</span>-cover of the restored descendant. Hence, <code class="code">PqCurrentGroup</code> used immediately after one of these commands returns the <span class="SimpleMath">\(p\)</span>-cover of the restored descendant rather than the descendant itself.</p>

<p>For those familiar with the <code class="code">pq</code> program, <code class="code">PqPGSetDescendantToPcp</code> and <code class="code">PqPGRestoreDescendantFromFile</code> perform menu item 3 of the main or advanced <span class="SimpleMath">\(p\)</span>-Group Generation menu.</p>

<p><a id="X7E8FBC2D83C43481" name="X7E8FBC2D83C43481"></a></p>

<h4>5.10 <span class="Heading">Commands from the Advanced <span class="SimpleMath">\(p\)</span>-Group Generation menu</span></h4>

<p>The functions below perform the component algorithms of <code class="code">PqPGConstructDescendants</code> (see <code class="func">PqPGConstructDescendants</code> (<a href="chap5_mj.html#X82FD51A27D269E43"><span class="RefLink">5.9-3</span></a>)). You can get some idea of their usage by trying <code class="code">PqExample("Nott-APG-Rel-i");</code>. You can get some idea of the breakdown of <code class="code">PqPGConstructDescendants</code> into these functions by comparing the previous output with <code class="code">PqExample("Nott-PG-Rel-i");</code>.</p>

<p>These functions are intended for use only by <q>experts</q>; please contact the authors of the package if you genuinely have a need for them and need any amplified descriptions.</p>

<p><a id="X7E539E4B78A6CE8D" name="X7E539E4B78A6CE8D"></a></p>

<h5>5.10-1 PqAPGDegree</h5>

<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ PqAPGDegree</code>( <var class="Arg">i</var>, <var class="Arg">step</var>, <var class="Arg">rank:</var[<var class="Arg">Exponent</var> <var class="Arg">:=</var> <var class="Arg">n</var>] )</td><td class="tdright">( function )</td></tr></table></div>
<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ PqAPGDegree</code>( <var class="Arg">step</var>, <var class="Arg">rank:</var> [<var class="Arg">Exponent</var> <var class="Arg">:=</var> <var class="Arg">n</var>] )</td><td class="tdright">( function )</td></tr></table></div>
<p>for the <var class="Arg">i</var>th or default interactive <strong class="pkg">ANUPQ</strong> process, direct the <code class="code">pq</code> program to invoke menu item 6 of the Advanced <span class="SimpleMath">\(p\)</span>-Group Generation menu. Here the step-size <var class="Arg">step</var> and the rank <var class="Arg">rank</var> are positive integers and are the arguments required by the <code class="code">pq</code> program. See <a href="chap6_mj.html#X87EE6DD67C9996A3"><span class="RefLink">6.2</span></a> for the one recognised option <code class="code">Exponent</code>.</p>

<p><a id="X7F1182A77AB7650C" name="X7F1182A77AB7650C"></a></p>

<h5>5.10-2 PqAPGPermutations</h5>

<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ PqAPGPermutations</code>( <var class="Arg">i:</var> <var class="Arg">options</var> )</td><td class="tdright">( function )</td></tr></table></div>
<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ PqAPGPermutations</code>( <var class="Arg">:</var> <var class="Arg">options</var> )</td><td class="tdright">( function )</td></tr></table></div>
<p>for the <var class="Arg">i</var>th or default interactive <strong class="pkg">ANUPQ</strong> process, direct the <code class="code">pq</code> program to perform menu item 7 of the Advanced <span class="SimpleMath">\(p\)</span>-Group Generation menu. Here the options <var class="Arg">options</var> recognised are <code class="code">PcgsAutomorphisms</code>, <code class="code">SpaceEfficient</code>, <code class="code">PrintAutomorphisms</code> and <code class="code">PrintPermutations</code> (see Chapter <a href="chap6_mj.html#X7B0946E97E7EB359"><span class="RefLink"><span class="Heading">ANUPQ Options</span></span></a> for details).</p>

<p><a id="X7DD9E7507AA888CC" name="X7DD9E7507AA888CC"></a></p>

<h5>5.10-3 PqAPGOrbits</h5>

<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ PqAPGOrbits</code>( <var class="Arg">i:</var> <var class="Arg">options</var> )</td><td class="tdright">( function )</td></tr></table></div>
<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ PqAPGOrbits</code>( <var class="Arg">:</var> <var class="Arg">options</var> )</td><td class="tdright">( function )</td></tr></table></div>
<p>for the <var class="Arg">i</var>th or default interactive <strong class="pkg">ANUPQ</strong> process, direct the <code class="code">pq</code> to perform menu item 8 of the Advanced <span class="SimpleMath">\(p\)</span>-Group Generation menu.</p>

<p>Here the options <var class="Arg">options</var> recognised are <code class="code">PcgsAutomorphisms</code>, <code class="code">SpaceEfficient</code> and <code class="code">CustomiseOutput</code> (see Chapter <a href="chap6_mj.html#X7B0946E97E7EB359"><span class="RefLink"><span class="Heading">ANUPQ Options</span></span></a> for details). For the <code class="code">CustomiseOutput</codeoption only the setting of the <code class="code">orbit</code> is recognised (all other fields if set are ignored).</p>

<p><a id="X795A756C78BE5923" name="X795A756C78BE5923"></a></p>

<h5>5.10-4 PqAPGOrbitRepresentatives</h5>

<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ PqAPGOrbitRepresentatives</code>( <var class="Arg">i:</var> <var class="Arg">options</var> )</td><td class="tdright">( function )</td></tr></table></div>
<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ PqAPGOrbitRepresentatives</code>( <var class="Arg">:</var> <var class="Arg">options</var> )</td><td class="tdright">( function )</td></tr></table></div>
<p>for the <var class="Arg">i</var>th or default interactive <strong class="pkg">ANUPQ</strong> process, direct the <code class="code">pq</code> to perform item 9 of the Advanced <span class="SimpleMath">\(p\)</span>-Group Generation menu.</p>

<p>The options <var class="Arg">options</var> may be any selection of the following: <code class="code">PcgsAutomorphisms</code>, <code class="code">SpaceEfficient</code>, <code class="code">Exponent</code>, <code class="code">Metabelian</code>, <code class="code">CapableDescendants</code> (or <code class="code">AllDescendants</code>), <code class="code">CustomiseOutput</code> (where only the <code class="code">group</code> and <code class="code">autgroup</code> fields are recognised) and <code class="code">Filename</code> (see Chapter <a href="chap6_mj.html#X7B0946E97E7EB359"><span class="RefLink"><span class="Heading">ANUPQ Options</span></span></a> for details). If <code class="code">Filename</code> is omitted the reduced <span class="SimpleMath">\(p\)</span>-cover is written to the file <code class="code">"redPCover"</code> in the temporary directory whose name is stored in <code class="code">ANUPQData.tmpdir</code>.</p>

<p><a id="X7E5D6D5782FE190E" name="X7E5D6D5782FE190E"></a></p>

<h5>5.10-5 PqAPGSingleStage</h5>

<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ PqAPGSingleStage</code>( <var class="Arg">i:</var> <var class="Arg">options</var> )</td><td class="tdright">( function )</td></tr></table></div>
<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ PqAPGSingleStage</code>( <var class="Arg">:</var> <var class="Arg">options</var> )</td><td class="tdright">( function )</td></tr></table></div>
<p>for the <var class="Arg">i</var>th or default interactive <strong class="pkg">ANUPQ</strong> process, direct the <code class="code">pq</code> to perform option 5 of the Advanced <span class="SimpleMath">\(p\)</span>-Group Generation menu.</p>

<p>The possible options are <code class="code">StepSize</code>, <code class="code">PcgsAutomorphisms</code>, <code class="code">RankInitialSegmentSubgroups</code>, <code class="code">SpaceEfficient</code>, <code class="code">CapableDescendants</code>, <code class="code">AllDescendants</code>, <code class="code">Exponent</code>, <code class="code">Metabelian</code>, <code class="code">BasicAlgorithm</code> and <code class="code">CustomiseOutput</code>. (Detailed descriptions of these options may be found in Chapter <a href="chap6_mj.html#X7B0946E97E7EB359"><span class="RefLink"><span class="Heading">ANUPQ Options</span></span></a>.)</p>

<p><a id="X84A92E8087762DEE" name="X84A92E8087762DEE"></a></p>

<h4>5.11 <span class="Heading">Primitive Interactive ANUPQ Process Read/Write Functions</span></h4>

<p>For those familiar with using the <code class="code">pq</code> program as a standalone we provide primitive read/write tools to communicate directly with an interactive <strong class="pkg">ANUPQ</strong> process, started via <code class="code">PqStart</code>. For the most part, it is up to the user to translate the output strings from <code class="code">pq</code> program into a form useful in <strong class="pkg">GAP</strong>.</p>

<p><a id="X8464AF7E83A523C1" name="X8464AF7E83A523C1"></a></p>

<h5>5.11-1 PqRead</h5>

<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ PqRead</code>( <var class="Arg">i</var> )</td><td class="tdright">( function )</td></tr></table></div>
<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ PqRead</code>(  )</td><td class="tdright">( function )</td></tr></table></div>
<p>read a complete line of <strong class="pkg">ANUPQ</strongoutput, from the <var class="Arg">i</var>th or default interactive <strong class="pkg">ANUPQ</strong> process, if there is output to be read and returns <code class="keyw">fail</code> 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 <q>too quick</q> (i.e. the return can be <code class="keyw">fail</code> purely because the output from <strong class="pkg">ANUPQ</strong> is not there yet), but if <code class="code">PqRead</code> finds any output at all, it waits for a complete line. <code class="code">PqRead</code> also writes the line read via <code class="code">Info</code> at <code class="code">InfoANUPQ</code> level 2. It doesn't try to distinguish banner and menu output from other output of the <code class="code">pq</code> program.</p>

<p><a id="X7ADD82207D049A87" name="X7ADD82207D049A87"></a></p>

<h5>5.11-2 PqReadAll</h5>

<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ PqReadAll</code>( <var class="Arg">i</var> )</td><td class="tdright">( function )</td></tr></table></div>
<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ PqReadAll</code>(  )</td><td class="tdright">( function )</td></tr></table></div>
<p>read and return as many <em>complete</em> lines of <strong class="pkg">ANUPQ</strongoutput, from the <var class="Arg">i</var>th or default interactive <strong class="pkg">ANUPQ</strong> process, as there are to be read, <em>at the time of the call</em>, as a list of strings with any trailing newlines removed and returns the empty list otherwise. <code class="code">PqReadAll</code> also writes each line read via <code class="code">Info</code> at <code class="code">InfoANUPQ</code> level 2. It doesn't try to distinguish banner and menu output from other output of the <code class="code">pq</code> program. Whenever <code class="code">PqReadAll</code> 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 <strong class="pkg">ANUPQ</strong>.</p>

<p><a id="X7EBF3C3681671879" name="X7EBF3C3681671879"></a></p>

<h5>5.11-3 PqReadUntil</h5>

<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ PqReadUntil</code>( <var class="Arg">i</var>, <var class="Arg">IsMyLine</var> )</td><td class="tdright">( function )</td></tr></table></div>
<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ PqReadUntil</code>( <var class="Arg">IsMyLine</var> )</td><td class="tdright">( function )</td></tr></table></div>
<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ PqReadUntil</code>( <var class="Arg">i</var>, <var class="Arg">IsMyLine</var>, <var class="Arg">Modify</var> )</td><td class="tdright">( function )</td></tr></table></div>
<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ PqReadUntil</code>( <var class="Arg">IsMyLine</var>, <var class="Arg">Modify</var> )</td><td class="tdright">( function )</td></tr></table></div>
<p>read complete lines of <strong class="pkg">ANUPQ</strongoutput, from the <var class="Arg">i</var>th or default interactive <strong class="pkg">ANUPQ</strong> process, <q>chomps</q> them (i.e. removes any trailing newline character), emits them to <code class="code">Info</code> at <code class="code">InfoANUPQ</code> level 2 (without trying to distinguish banner and menu output from otheoutput of the <code class="code">pq</code> program), and applies the function <var class="Arg">Modify</var> (where <var class="Arg">Modify</var> is just the identity map/function for the first two forms) until a <q>chomped</q> line <var class="Arg">line</var> for which <code class="code"><var class="Arg">IsMyLine</var>( <var class="Arg">Modify</var>(<var class="Arg">line</var>) )</code> is true. <code class="code">PqReadUntil</code> returns the list of <var class="Arg">Modify</var>-ed <q>chomped</q> lines read.</p>

<p><em>Notes:</em> When provided by the user, <var class="Arg">Modify</var> should be a function that accepts a single string argument.</p>

<p><var class="Arg">IsMyLine</var> should be a function that is able to accept the output of <var class="Arg">Modify</var> (or take a single string argument when <var class="Arg">Modify</var> is not provided) and should return a boolean.</p>

<p>If <code class="code"><var class="Arg">IsMyLine</var>( <var class="Arg">Modify</var>(<var class="Arg">line</var>) )</code> is never true, <code class="code">PqReadUntil</code> will wait indefinitely.</p>

<p><a id="X83CBE77F78057E21" name="X83CBE77F78057E21"></a></p>

<h5>5.11-4 PqWrite</h5>

<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ PqWrite</code>( <var class="Arg">i</var>, <var class="Arg">string</var> )</td><td class="tdright">( function )</td></tr></table></div>
<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ PqWrite</code>( <var class="Arg">string</var> )</td><td class="tdright">( function )</td></tr></table></div>
<p>write <var class="Arg">string</var> to the <var class="Arg">i</var>th or default interactive <strong class="pkg">ANUPQ</strong> process; <var class="Arg">string</var> must be in exactly the form the <strong class="pkg">ANUPQ</strong> standalone expects. The command is echoed via <code class="code">Info</code> at <code class="code">InfoANUPQ</code> level 3 (with a <q><code class="code">ToPQ> </code></q> prompt); i.e. do <code class="code">SetInfoLevel(InfoANUPQ, 3);</code> to see what is transmitted to the <code class="code">pq</code> program. <code class="code">PqWrite</code> returns <code class="keyw">true</code> if successful in writing to the stream of the interactive <strong class="pkg">ANUPQ</strong> process, and <code class="keyw">fail</code> otherwise.</p>

<p><em>Note:</em> If <code class="code">PqWrite</code> returns <code class="keyw">fail</code> it means that the <strong class="pkg">ANUPQ</strong> process has died.</p>


<div class="chlinkprevnextbot"> <a href="chap0_mj.html">[Top of Book]</a>   <a href="chap0_mj.html#contents">[Contents]</a>    <a href="chap4_mj.html">[Previous Chapter]</a>    <a href="chap6_mj.html">[Next Chapter]</a>   </div>


<div class="chlinkbot"><span class="chlink1">Goto Chapter: </span><a href="chap0_mj.html">Top</a>  <a href="chap1_mj.html">1</a>  <a href="chap2_mj.html">2</a>  <a href="chap3_mj.html">3</a>  <a href="chap4_mj.html">4</a>  <a href="chap5_mj.html">5</a>  <a href="chap6_mj.html">6</a>  <a href="chap7_mj.html">7</a>  <a href="chapA_mj.html">A</a>  <a href="chapBib_mj.html">Bib</a>  <a href="chapInd_mj.html">Ind</a>  </div>

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

Messung V0.5 in Prozent
C=100 H=100 G=100

¤ Dauer der Verarbeitung: 0.131 Sekunden  (vorverarbeitet am  2026-04-28) ¤

*© Formatika GbR, Deutschland






Wurzel

Suchen

Beweissystem der NASA

Beweissystem Isabelle

NIST Cobol Testsuite

Cephes Mathematical Library

Wiener Entwicklungsmethode

Haftungshinweis

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

Bemerkung:

Die farbliche Syntaxdarstellung und die Messung sind noch experimentell.