GAP (ANUPQ) - Chapter 5: Interactive ANUPQ functions

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

[MathJax on]

5 Interactive ANUPQ functions
5.1 Starting and Stopping Interactive ANUPQ Processes
5.1-1 PqStart
5.1-2 PqQuit
5.1-3 PqQuitAll
5.2 Interactive ANUPQ Process Utility Functions
5.2-1 PqProcessIndex
5.2-2 PqProcessIndices
5.2-3 IsPqProcessAlive
5.3 Interactive Versions of Non-interactive ANUPQ Functions
5.3-1 Pq
5.3-2 PqEpimorphism
5.3-3 PqPCover
5.3-4 PqStandardPresentation
5.3-5 EpimorphismPqStandardPresentation
5.3-6 PqDescendants
5.3-7 PqSetPQuotientToGroup
5.4 Low-level Interactive ANUPQ functions based on menu items of the pq program
5.5 General commands
5.5-1 PqNrPcGenerators
5.5-2 PqFactoredOrder
5.5-3 PqOrder
5.5-4 PqPClass
5.5-5 PqWeight
5.5-6 PqCurrentGroup
5.5-7 PqDisplayPcPresentation
5.5-8 PqSetOutputLevel
5.5-9 PqEvaluateIdentities
5.6 Commands from the Main p-Quotient menu
5.6-1 PqPcPresentation
5.6-2 PqSavePcPresentation
5.6-3 PqRestorePcPresentation
5.6-4 PqNextClass
5.6-5 PqComputePCover
5.7 Commands from the Advanced p-Quotient menu
5.7-1 PqCollect
5.7-2 PqSolveEquation
5.7-3 PqCommutator
5.7-4 PqSetupTablesForNextClass
5.7-5 PqTails
5.7-6 PqComputeTails
5.7-7 PqAddTails
5.7-8 PqDoConsistencyChecks
5.7-9 PqCollectDefiningRelations
5.7-10 PqCollectWordInDefiningGenerators
5.7-11 PqCommutatorDefiningGenerators
5.7-12 PqDoExponentChecks
5.7-13 PqEliminateRedundantGenerators
5.7-14 PqRevertToPreviousClass
5.7-15 PqSetMaximalOccurrences
5.7-16 PqSetMetabelian
5.7-17 PqDoConsistencyCheck
5.7-18 PqCompact
5.7-19 PqEchelonise
5.7-20 PqSupplyAutomorphisms
5.7-21 PqExtendAutomorphisms
5.7-22 PqApplyAutomorphisms
5.7-23 PqDisplayStructure
5.7-24 PqDisplayAutomorphisms
5.7-25 PqWritePcPresentation
5.8 Commands from the Standard Presentation menu
5.8-1 PqSPComputePcpAndPCover
5.8-2 PqSPStandardPresentation
5.8-3 PqSPSavePresentation
5.8-4 PqSPCompareTwoFilePresentations
5.8-5 PqSPIsomorphism
5.9 Commands from the Main p-Group Generation menu
5.9-1 PqPGSupplyAutomorphisms
5.9-2 PqPGExtendAutomorphisms
5.9-3 PqPGConstructDescendants
5.9-4 PqPGSetDescendantToPcp
5.10 Commands from the Advanced p-Group Generation menu
5.10-1 PqAPGDegree
5.10-2 PqAPGPermutations
5.10-3 PqAPGOrbits
5.10-4 PqAPGOrbitRepresentatives
5.10-5 PqAPGSingleStage
5.11 Primitive Interactive ANUPQ Process Read/Write Functions
5.11-1 PqRead
5.11-2 PqReadAll
5.11-3 PqReadUntil
5.11-4 PqWrite

### 5 Interactive ANUPQ functions

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

An interactive ANUPQ process is initiated by `PqStart` and terminated via `PqQuit`; these functions are described in ection Starting and Stopping Interactive ANUPQ Processes.

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

Notes: The global method of passing options (via `PushOptions`), should not be used with any of the interactive functions. In fact, the `OptionsStack` should be empty at the time any of the interactive functions is called.

On `quit`ting GAP, `PqQuitAll();` is executed, which terminates all active interactive ANUPQ processes. If GAP is killed without `quit`ting, before all interactive ANUPQ processes are terminated, zombie processes (still living child processes whose parents have died), may result. Since zombie processes do consume resources, in such an event, the responsible computer user should seek out and terminate those zombie processes (e.g. on Linux: `ps xw | grep pq` gives you information on the `pq` processes corresponding to any interactive ANUPQ processes started in a GAP session; you can then do `kill N` for each number N appearing in the first column of this output).

#### 5.1 Starting and Stopping Interactive ANUPQ Processes

##### 5.1-1 PqStart

`‣ PqStart`( G, workspace: options ) | ( function )

`‣ PqStart`( G: options ) | ( function )

`‣ PqStart`( workspace: options ) | ( function )

`‣ PqStart`( : options ) | ( function )

activate an iostream for an interactive ANUPQ process (i.e. `PqStart` starts up a `pq` process and opens a GAP iostream to "talk" to that process) and returns an integer i that can be used to identify that process. The argument G should be an fp group or pc group that the user intends to manipulate using interactive ANUPQ functions. If the function is called without specifying G, a group can be read in by using the function `PqRestorePcPresentation` (see `PqRestorePcPresentation` (5.6-3)). If `PqStart` is given an integer argument workspace, then the `pq` program is started up with a workspace (an integer array) of size workspace (i.e. 4 × workspace bytes in a 32-bit environment); otherwise, the `pq` program sets a default workspace of 10000000.

The only options currently recognised by `PqStart` are `Prime`, `Exponent` and `Relators` (see Chapter ANUPQ Options for detailed descriptions of these options) and if provided they are essentially global for the interactive ANUPQ process, except that any interactive function interacting with the process and passing new values for these options will over-ride the global values.

##### 5.1-2 PqQuit

`‣ PqQuit`( i ) | ( function )

`‣ PqQuit`( ) | ( function )

closes the stream of the ith or default interactive ANUPQ process and unbinds its `ANUPQData.io` record.

Note: It can happen that the `pq` process, and hence the GAP iostream assigned to communicate with it, can die, e.g. by the user typing a `Ctrl-C` while the `pq` process is engaged in a long calculation. `IsPqProcessAlive` (see `IsPqProcessAlive` (5.2-3)) is provided to check the status of the GAP iostream (and hence the status of the `pq` process it was communicating with).

##### 5.1-3 PqQuitAll

`‣ PqQuitAll`( ) | ( function )

is provided as a convenience, to terminate all active interactive ANUPQ processes with a single command. It is equivalent to executing `PqQuit(i)` for all active interactive ANUPQ processes i (see `PqQuit` (5.1-2)).

#### 5.2 Interactive ANUPQ Process Utility Functions

##### 5.2-1 PqProcessIndex

`‣ PqProcessIndex`( i ) | ( function )

`‣ PqProcessIndex`( ) | ( function )

With argument i, which must be a positive integer, `PqProcessIndex` returns i if it corresponds to an active interactive process, or raises an error. With no arguments it returns the default active interactive process or returns `fail` and emits a warning message to `Info` at `InfoANUPQ` or `InfoWarning` level 1.

Note: Essentially, an interactive ANUPQ process i is "active" if `ANUPQData.io[i]` is bound (i.e. we still have some data telling us about it). Also see `PqStart` (5.1-1).

##### 5.2-2 PqProcessIndices

`‣ PqProcessIndices`( ) | ( function )

returns the list of integer indices of all active interactive ANUPQ processes (see `PqProcessIndex` (5.2-1) for the meaning of "active").

##### 5.2-3 IsPqProcessAlive

`‣ IsPqProcessAlive`( i ) | ( function )

`‣ IsPqProcessAlive`( ) | ( function )

return `true` if the GAP iostream of the ith (or default) interactive ANUPQ process started by `PqStart` is alive (i.e. can still be written to), or `false`, otherwise. (See the notes for `PqStart` (5.1-1) and `PqQuit` (5.1-2).)

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

The GAP iostream of an interactive ANUPQ process will also die if the `pq` program has a segmentation fault. We do hope that this never happens to you, but if it does and the failure is reproducible, then it's a bug and we'd like to know about it. Please read the `README` that comes with the ANUPQ package to find out what to include in a bug report and who to email it to.

#### 5.3 Interactive Versions of Non-interactive ANUPQ Functions

##### 5.3-1 Pq

`‣ Pq`( i: options ) | ( function )

`‣ Pq`( : options ) | ( function )

return, for the fp or pc group (let us call it F), of the ith or default interactive ANUPQ process, the p-quotient of F specified by options, as a pc group; F must previously have been given (as first argument) to `PqStart` to start the interactive ANUPQ process (see `PqStart` (5.1-1)) or restored from file using the function `PqRestorePcPresentation` (see `PqRestorePcPresentation` (5.6-3)). Following the colon options is a selection of the options listed for the non-interactive `Pq` function (see `Pq` (4.1-1)), separated by commas like record components (see Section Reference: Function Call With Options in the GAP Reference Manual), except that the options `SetupFile` or `PqWorkspace` are ignored by the interactive `Pq`, and `RedoPcp` is an option only recognised by the interactive `Pq` i.e. the following options are recognised by the interactive `Pq` function:

- `Prime := p`

- `ClassBound := n`

- `Exponent := n`

- `Relators := rels`

- `Metabelian`

- `Identities := funcs`

- `GroupName := name`

- `OutputLevel := n`

- `RedoPcp`

Detailed descriptions of the above options may be found in Chapter ANUPQ Options.

As a minimum the `Pq` function must have a value for the `Prime` option, though `Prime` need not be passed again in the case it has previously been provided, e.g. to `PqStart` (see `PqStart` (5.1-1)) when starting the interactive process.

The behaviour of the interactive `Pq` function depends on the current state of the pc presentation stored by the `pq` program:

1. If no pc presentation has yet been computed (the case immediately after the `PqStart` call initiating the process) then the quotient group of the input group of the process of largest lower exponent-p class bounded by the value of the `ClassBound` option (see 6.2) is returned.

2. If the current pc presentation of the process was determined by a previous call to `Pq` or `PqEpimorphism`, and the current call has a larger value `ClassBound` then the class is extended as much as is possible and the quotient group of the input group of the process of the new lower exponent-p class is returned.

3. If the current pc presentation of the process was determined by a previous call to `PqPCover` then a consistent pc presentation of a quotient for the current class is determined before proceeding as in 2.

4. If the `RedoPcp` option is supplied the current pc presentation is scrapped, all options must be re-supplied (in particular, `Prime` must be supplied) and then the `Pq` function proceeds as in 1.

See Section Attributes and a Property for fp and pc p-groups for the attributes and property `NuclearRank`, `MultiplicatorRank` and `IsCapable` which may be applied to the group returned by `Pq`.

The following is one of the examples for the non-interactive `Pq` redone with the interactive version. Also, we set the option `OutputLevel` to 1 (see 6.2), in order to see the orders of the quotients of all the classes determined, and we set the `InfoANUPQ` level to 2 (see `InfoANUPQ` (3.3-1)), so that we catch the timing information.

    gap> F := FreeGroup("a", "b");; a := F.1;; b := F.2;;
    gap> G := F / [a^4, b^4];
    <fp group on the generators [ a, b ]>
    gap> PqStart(G);
    1
    gap> SetInfoLevel(InfoANUPQ, 2); #To see timing information
    gap> Pq(: Prime := 2, ClassBound := 3, OutputLevel := 1 );
    #I  Lower exponent-2 central series for [grp]
    #I  Group: [grp] to lower exponent-2 central class 1 has order 2^2
    #I  Group: [grp] to lower exponent-2 central class 2 has order 2^5
    #I  Group: [grp] to lower exponent-2 central class 3 has order 2^8
    #I  Computation of presentation took 0.00 seconds
    <pc group of size 256 with 8 generators>

##### 5.3-2 PqEpimorphism

`‣ PqEpimorphism`( i: options ) | ( function )

`‣ PqEpimorphism`( : options ) | ( function )

return, for the fp or pc group (let us call it F), of the ith or default interactive ANUPQ process, an epimorphism from F onto the p-quotient of F specified by options; F must previously have been given (as first argument) to `PqStart` to start the interactive ANUPQ process (see `PqStart` (5.1-1)). Since the underlying interactions with the `pq` program effected by the interactive `PqEpimorphism` are identical to those effected by the interactive `Pq`, everything said regarding the requirements and behaviour of the interactive `Pq` function (see `Pq` (5.3-1)) is also the case for the interactive `PqEpimorphism`.

Note: See Section Attributes and a Property for fp and pc p-groups for the attributes and property `NuclearRank`, `MultiplicatorRank` and `IsCapable` which may be applied to the image group of the epimorphism returned by `PqEpimorphism`.

##### 5.3-3 PqPCover

`‣ PqPCover`( i: options ) | ( function )

`‣ PqPCover`( : options ) | ( function )

return, for the fp or pc group of the ith or default interactive ANUPQ process, the p-covering group of the p-quotient `Pq(i : options)` or `Pq(: options)`, modulo the following:

1. If no pc presentation has yet been computed (the case immediately after the `PqStart` call initiating the process) and the group F of the process is already a p-group, in the sense that `HasIsPGroup(F) and IsPGroup(F)` is `true`, then

   `Prime`

     defaults to `PrimePGroup(F)`, if not supplied and `HasPrimePGroup(F) = true`; and

   `ClassBound`

     defaults to `PClassPGroup(F)` if `HasPClassPGroup(F) = true` if not supplied, or to the usual default of 63, otherwise.

2. If a pc presentation has been computed and none of options is `RedoPcp` or if no pc presentation has yet been computed but 1. does not apply then `PqPCover(i : options);` is equivalent to:

       Pq(i : options);
       PqPCover(i);

3. If the `RedoPcp` option is supplied the current pc presentation is scrapped, and `PqPCover` proceeds as in 1. or 2. but without the `RedoPcp` option.

##### 5.3-4 PqStandardPresentation

`‣ PqStandardPresentation`( [i]: options ) | ( function )

`‣ StandardPresentation`( [i]: options ) | ( function )

return, for the ith or default interactive ANUPQ process, the p-quotient of the group F of the process, specified by options, as an fp group which has a standard presentation. Here options is a selection of the options from the following list (see Chapter ANUPQ Options for detailed descriptions); this list is the same as for the non-interactive version of `PqStandardPresentation` except for the omission of options `SetupFile` and `PqWorkspace` (see `PqStandardPresentation` (4.2-1)).

- `Prime := p`

- `pQuotient := Q`

- `ClassBound := n`

- `Exponent := n`

- `Metabelian`

- `GroupName := name`

- `OutputLevel := n`

- `StandardPresentationFile := filename`

Unless F is a pc p-group, or the option `Prime` has been passed to a previous interactive function for the process to compute a p-quotient for F, the user must supply either the option `Prime` or the option `pQuotient` (if both `Prime` and `pQuotient` are supplied, the prime p is determined by applying `PrimePGroup` (see `PrimePGroup` (Reference: PrimePGroup) in the Reference Manual) to the value of `pQuotient`).

Taking one of the examples for the non-interactive version of `StandardPresentation` (see `StandardPresentation` (4.2-1)) that required two separate calls to the `pq` program, we now show how it can be done by setting up a dialogue with just the one `pq` process, using the interactive version of `StandardPresentation`:

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

Notes

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

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

If any of the interactive functions `PqStandardPresentation`, `StandardPresentation`, `EpimorphismPqStandardPresentation` or `EpimorphismStandardPresentation` has been called previously for an interactive process, a subsequent call to any of these functions for the same process returns the previously computed value. Note that all these functions compute both an epimorphism and an fp group and store the results in the `SPepi` and `SP` fields of the data record associated with the process. See the example for the interactive `EpimorphismStandardPresentation` (`EpimorphismStandardPresentation` (5.3-5)).

The attributes and property `NuclearRank`, `MultiplicatorRank` and `IsCapable` are set for the group returned by `PqStandardPresentation` or `StandardPresentation` (see Section Attributes and a Property for fp and pc p-groups).

##### 5.3-5 EpimorphismPqStandardPresentation

`‣ EpimorphismPqStandardPresentation`( [i]: options ) | ( function )

`‣ EpimorphismStandardPresentation`( [i]: options ) | ( method )

Each of the above functions accepts the same arguments and options as the interactive form of `StandardPresentation` (see `StandardPresentation` (5.3-4)) and returns an epimorphism from the fp or pc group F of the ith or default interactive ANUPQ process onto the finitely presented group given by a standard presentation, i.e. if S is the standard presentation computed for the p-quotient of F by `StandardPresentation` then `EpimorphismStandardPresentation` returns the epimorphism from F to the group with presentation S. The group F must have been given (as first argument) to `PqStart` to start the interactive ANUPQ process (see `PqStart` (5.1-1)).

Taking our earlier non-interactive example (see `EpimorphismPqStandardPresentation` (4.2-2)) and modifying it a little, we illustrate, as for the interactive `StandardPresentation` (see `StandardPresentation` (5.3-4)), how something that required two separate calls to the `pq` program can now be achieved with a dialogue with just one `pq` process. Also, observe that calls to one of the standard presentation functions (as mentioned in the notes of `StandardPresentation` (5.3-4)) computes and stores both an fp group with a standard presentation and an epimorphism; subsequent calls to a standard presentation function for the same process simply return the appropriate stored value.

    gap> F := FreeGroup(6, "F");;
    gap> x := F.1;; y := F.2;; z := F.3;; w := F.4;; a := F.5;; b := F.6;;
    gap> R := [x^3 / w, y^3 / w * a^2 * b^2, w^3 / b,
    >          Comm (y, x) / z, Comm (z, x), Comm (z, y) / a, z^3 ];
    [ F1^3*F4^-1, F2^3*F4^-1*F5^2*F6^2, F4^3*F6^-1, F2^-1*F1^-1*F2*F1*F3^-1,
      F3^-1*F1^-1*F3*F1, F3^-1*F2^-1*F3*F2*F5^-1, F3^3 ]
    gap> Q := F / R;
    <fp group on the generators [ F1, F2, F3, F4, F5, F6 ]>
    gap> PqStart( Q );
    3
    gap> G := Pq( 3 : Prime := 3, ClassBound := 3 );
    <pc group of size 729 with 6 generators>
    gap> lev := InfoLevel(InfoANUPQ);; # Save current InfoANUPQ level
    gap> SetInfoLevel(InfoANUPQ, 2); # To see computation times
    gap> # It is not necessary to pass the `Prime' option to
    gap> # `EpimorphismStandardPresentation' since it was previously
    gap> # passed to `Pq':
    gap> phi := EpimorphismStandardPresentation( 3 : ClassBound := 3 );
    #I  Class 1 3-quotient and its 3-covering group computed in 0.00 seconds
    #I  Order of GL subgroup is 48
    #I  No. of soluble autos is 0
    #I    dim U = 1  dim N = 3  dim M = 3
    #I    nice stabilizer with perm rep
    #I  Computing standard presentation for class 2 took 0.00 seconds
    #I  Computing standard presentation for class 3 took 0.01 seconds
    [ F1, F2, F3, F4, F5, F6 ] -> [ f1*f2^2*f3*f4^2*f5^2, f1*f2*f3*f5, f3^2,
      f4*f6^2, f5, f6 ]
    gap> # Image of phi should be isomorphic to G ...
    gap> # let's check the order is correct:
    gap> Size( Image(phi) );
    729
    gap> # `StandardPresentation' and `EpimorphismStandardPresentation'
    gap> # behave like attributes, so no computation is done when
    gap> # either is called again for the same process ...
    gap> StandardPresentation( 3 : ClassBound := 3 );
    <fp group of size 729 on the generators [ f1, f2, f3, f4, f5, f6 ]>
    gap> # No timing data was Info-ed since no computation was done
    gap> SetInfoLevel(InfoANUPQ, lev); # Restore previous InfoANUPQ level

A very similar (essential details are the same) example to the above may be executed live, by typing: `PqExample( "EpimorphismStandardPresentation-i" );`.

Note: The notes for `PqStandardPresentation` or `StandardPresentation` (see `PqStandardPresentation` (5.3-4)) apply also to `EpimorphismPqStandardPresentation` or `EpimorphismStandardPresentation` except that their return value is an epimorphism onto an fp group, i.e. one should interpret the phrase "returns an fp group" as "returns an epimorphism onto an fp group" etc.

##### 5.3-6 PqDescendants

`‣ PqDescendants`( i: options ) | ( function )

`‣ PqDescendants`( : options ) | ( function )

return for the pc group G of the ith or default interactive ANUPQ process, which must be of prime power order with a confluent pc presentation (see `IsConfluent` (Reference: IsConfluent for pc groups) in the GAP Reference Manual), a list of descendants (pc groups) of G. The group G is usually given as first argument to `PqStart` when starting the interactive ANUPQ process (see `PqStart` (5.1-1)). Alternatively, one may initiate the process with an fp group, use `Pq` interactively (see `Pq` (5.3-1)) to create a pc group and use `PqSetPQuotientToGroup` (see `PqSetPQuotientToGroup` (5.3-7)), which involves no computation, to set the pc group returned by `Pq` as the group of the process. Note that repeating a call to `PqDescendants` for the same interactive ANUPQ process simply returns the list of descendants originally calculated; a warning is emitted at `InfoANUPQ` level 1 reminding you of this should you do this.

After the colon, options a selection of the options listed for the non-interactive `PqDescendants` function (see `PqDescendants` (4.4-1)), should be given, separated by commas like record components (see Section Reference: Function Call With Options in the GAP Reference Manual), except that the options `SetupFile` or `PqWorkspace` are ignored by the interactive `PqDescendants`, i.e. the following options are recognised by the interactive `PqDescendants` function:

- `ClassBound := n`

- `Relators := rels`

- `OrderBound := n`

- `StepSize := n`, `StepSize := list`

- `RankInitialSegmentSubgroups := n`

- `SpaceEfficient`

- `CapableDescendants`

- `AllDescendants := false`

- `Exponent := n`

- `Metabelian`

- `GroupName := name`

- `SubList := sub`

- `BasicAlgorithm`

- `CustomiseOutput := rec`

Notes: The function `PqDescendants` uses the automorphism group of G which it computes via the package AutPGrp if the automorphism group of G is not already present. If AutPGrp is not installed an error may be raised. If the automorphism group of G is insoluble the `pq` program will call GAP together with the AutPGrp package for certain orbit-stabilizer calculations.

The attributes and property `NuclearRank`, `MultiplicatorRank` and `IsCapable` are set for each group of the list returned by `PqDescendants` (see Section Attributes and a Property for fp and pc p-groups).

Let us now repeat the examples previously given for the non-interactive `PqDescendants`, but this time with the interactive version of `PqDescendants`:

    gap> F := FreeGroup( "a", "b" );; a := F.1;; b := F.2;;
    gap> G := PcGroupFpGroup( F / [ a^2, b^2, Comm(b, a) ] );
    <pc group of size 4 with 2 generators>
    gap> PqStart(G); #This will now be the 4th interactive process running
    4
    gap> des := PqDescendants( 4 : OrderBound := 6, ClassBound := 5 );;
    gap> Length(des);
    83
    gap> List(des, Size);
    [ 8, 8, 8, 16, 16, 16, 32, 16, 16, 16, 16, 16, 32, 32, 64, 64, 32, 32, 32,
      32, 32, 32, 32, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 32, 32, 32, 32,
      64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 32, 32, 32, 32, 32, 64, 64, 64,
      64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64,
      64, 64, 64, 64, 64, 64, 64 ]
    gap> List(des, d -> Length( PCentralSeries( d, 2 ) ) - 1 );
    [ 2, 2, 2, 2, 2, 2, 2, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
      3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 4,
      4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
      4, 4, 4, 5, 5, 5, 5, 5 ]

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

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

In the third example, we compute all capable descendants of the elementary abelian group of order 5^2 which have exponent-5 class at most 3, exponent 5, and are metabelian.

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

##### 5.3-7 PqSetPQuotientToGroup

`‣ PqSetPQuotientToGroup`( i ) | ( function )

`‣ PqSetPQuotientToGroup`( ) | ( function )

for the ith or default interactive ANUPQ process, set the p-quotient previously computed by the interactive `Pq` function (see `Pq` (5.3-1)) to be the group of the process. This function is supplied to enable the computation of descendants of a p-quotient that is already known to the `pq` program, via the interactive `PqDescendants` function (see `PqDescendants` (5.3-6)), thus avoiding the need to re-submit it and have the `pq` program recompute it.

Note: See the function `PqPGSetDescendantToPcp` (`PqPGSetDescendantToPcp` (5.9-4)) for a mechanism to make (the p-cover of) a particular descendants the current group of the process.

The following example of the usage of `PqSetPQuotientToGroup`, which is essentially equivalent to what is obtained by running `PqExample("PqDescendants-1-i");`, redoes the first example of `PqDescendants` (5.3-6) (which computes the descendants of the Klein four group).

    gap> F := FreeGroup( "a", "b" );
    <free group on the generators [ a, b ]>
    gap> procId := PqStart( F : Prime := 2 );
    7
    gap> Pq( procId : ClassBound := 1 );
    <pc group of size 4 with 2 generators>
    gap> PqSetPQuotientToGroup( procId );
    gap> des := PqDescendants( procId : OrderBound := 6, ClassBound := 5 );;
    gap> Length(des);
    83
    gap> List(des, Size);
    [ 8, 8, 8, 16, 16, 16, 32, 16, 16, 16, 16, 16, 32, 32, 64, 64, 32, 32, 32,
      32, 32, 32, 32, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 32, 32, 32, 32,
      64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 32, 32, 32, 32, 32, 64, 64, 64,
      64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64,
      64, 64, 64, 64, 64, 64, 64 ]
    gap> List(des, d -> Length( PCentralSeries( d, 2 ) ) - 1 );
    [ 2, 2, 2, 2, 2, 2, 2, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
      3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 4,
      4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
      4, 4, 4, 5, 5, 5, 5, 5 ]

#### 5.4 Low-level Interactive ANUPQ functions based on menu items of the pq program

The `pq` program has 5 menus, the details of which the reader will not normally need to know, but if she wishes to know the details they may be found in the standalone manual: `guide.dvi`. Both `guide.dvi` and the `pq` program refer to the items of these 5 menus as "options", which do not correspond in any way to the options used by any of the GAP functions that interface with the `pq` program.

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

#### 5.5 General commands

The following commands either use a menu item from whatever menu is "current" for the `pq` program, or have general application and are not associated with just one menu item of the `pq` program.

##### 5.5-1 PqNrPcGenerators

`‣ PqNrPcGenerators`( i ) | ( function )

`‣ PqNrPcGenerators`( ) | ( function )

for the ith or default interactive ANUPQ process, return the number of pc generators of the lower exponent p-class quotient of the group currently determined by the process. This also applies if the pc presentation is not consistent.

##### 5.5-2 PqFactoredOrder

`‣ PqFactoredOrder`( i ) | ( function )

`‣ PqFactoredOrder`( ) | ( function )

for the ith or default interactive ANUPQ process, return an integer pair `[p, n]` where p is a prime and n is the number of pc generators (see `PqNrPcGenerators` (5.5-1)) in the pc presentation of the quotient group currently determined by the process. If this presentation is consistent, then p^n is the order of the quotient group. Otherwise (if tails have been added but the necessary consistency checks, relation collections, exponent law checks and redundant generator eliminations have not yet been done), p^n is an upper bound for the order of the group.

##### 5.5-3 PqOrder

`‣ PqOrder`( i ) | ( function )

`‣ PqOrder`( ) | ( function )

for the ith or default interactive ANUPQ process, return p^n where `[p, n]` is the pair as returned by `PqFactoredOrder` (see `PqFactoredOrder` (5.5-2)).

##### 5.5-4 PqPClass

`‣ PqPClass`( i ) | ( function )

`‣ PqPClass`( ) | ( function )

for the ith or default interactive ANUPQ process, return the lower exponent p-class of the quotient group currently determined by the process.

##### 5.5-5 PqWeight

`‣ PqWeight`( i, j ) | ( function )

`‣ PqWeight`( j ) | ( function )

for the ith or default interactive ANUPQ process, return the weight of the jth pc generator of the lower exponent p-class quotient of the group currently determined by the process, or `fail` if there is no such numbered pc generator.

##### 5.5-6 PqCurrentGroup

`‣ PqCurrentGroup`( i ) | ( function )

`‣ PqCurrentGroup`( ) | ( function )

for the ith or default interactive ANUPQ process, return the group whose pc presentation is determined by the process as a GAP pc group (either a lower exponent p-class quotient of the start group or the p-cover of such a quotient).

Notes: See Section Attributes and a Property for fp and pc p-groups for the attributes and property `NuclearRank`, `MultiplicatorRank` and `IsCapable` which may be applied to the group returned by `PqCurrentGroup`.

##### 5.5-7 PqDisplayPcPresentation

`‣ PqDisplayPcPresentation`( i: [OutputLevel := lev] ) | ( function )

`‣ PqDisplayPcPresentation`( : [OutputLevel := lev] ) | ( function )

for the ith or default interactive ANUPQ process, direct the `pq` program to display the pc presentation of the lower exponent p-class quotient of the group currently determined by the process.

Except if the last command communicating with the `pq` program was a p-group generation command (for which there is only a verbose output level), to set the amount of information this command displays you may wish to call `PqSetOutputLevel` first (see `PqSetOutputLevel` (5.5-8)), or equivalently pass the option `OutputLevel` (see 6.2).

Note: For those familiar with the `pq` program, `PqDisplayPcPresentation` performs menu item 4 of the current menu of the `pq` program.

##### 5.5-8 PqSetOutputLevel

`‣ PqSetOutputLevel`( i, lev ) | ( function )

`‣ PqSetOutputLevel`( lev ) | ( function )

for the ith or default interactive ANUPQ process, direct the `pq` program to set the output level of the `pq` program to lev.

Note: For those familiar with the `pq` program, `PqSetOutputLevel` performs menu item 5 of the main (or advanced) p-Quotient menu, or the Standard Presentation menu.

##### 5.5-9 PqEvaluateIdentities

`‣ PqEvaluateIdentities`( i: [Identities := funcs] ) | ( function )

`‣ PqEvaluateIdentities`( : [Identities := funcs] ) | ( function )

for the ith or default interactive ANUPQ process, invoke the evaluation of identities defined by the `Identities` option, and eliminate any redundant pc generators formed. Since a previous value of `Identities` is saved in the data record of the process, it is unnecessary to pass the `Identities` if set previously.

Note: This function is mainly implemented at the GAP level. It does not correspond to a menu item of the `pq` program.

#### 5.6 Commands from the Main p-Quotient menu

##### 5.6-1 PqPcPresentation

`‣ PqPcPresentation`( i: options ) | ( function )

`‣ PqPcPresentation`( : options ) | ( function )

for the ith or default interactive ANUPQ process, direct the `pq` program to compute the pc presentation of the quotient (determined by options) of the group of the process, which for process i is stored as `ANUPQData.io[i].group`.

The possible options are the same as for the interactive `Pq` (see `Pq` (5.3-1)) function, except for `RedoPcp` (which, in any case, would be superfluous), namely: `Prime`, `ClassBound`, `Exponent`, `Relators`, `GroupName`, `Metabelian`, `Identities` and `OutputLevel` (see Chapter ANUPQ Options for a detailed description for these options). The option `Prime` is required unless already provided to `PqStart`.

Notes

The pc presentation is held by the `pq` program. In contrast to `Pq` (see `Pq` (5.3-1)), no GAP pc group is returned; see `PqCurrentGroup` (`PqCurrentGroup` (5.5-6)) if you need the corresponding GAP pc group.

`PqPcPresentation(i: options);` is roughly equivalent to the following sequence of low-level commands:

    PqPcPresentation(i: opts); #class 1 call
    for c in [2 .. class] do
        PqNextClass(i);
    od;

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

For those familiar with the `pq` program, `PqPcPresentation` performs menu item 1 of the main p-Quotient menu.

##### 5.6-2 PqSavePcPresentation

`‣ PqSavePcPresentation`( i, filename ) | ( function )

`‣ PqSavePcPresentation`( filename ) | ( function )

for the ith or default interactive ANUPQ process, direct the `pq` program to save the pc presentation previously computed for the quotient of the group of that process to the file with name filename. If the first character of the string filename is not `/`, filename is assumed to be the path of a writable file relative to the directory in which GAP was started. A saved file may be restored by `PqRestorePcPresentation` (see `PqRestorePcPresentation` (5.6-3)).

Note: For those familiar with the `pq` program, `PqSavePcPresentation` performs menu item 2 of the main p-Quotient menu.

##### 5.6-3 PqRestorePcPresentation

`‣ PqRestorePcPresentation`( i, filename ) | ( function )

`‣ PqRestorePcPresentation`( filename ) | ( function )

for the ith or default interactive ANUPQ process, direct the `pq` program to restore the pc presentation previously saved to filename, by `PqSavePcPresentation` (see `PqSavePcPresentation` (5.6-2)). If the first character of the string filename is not `/`, filename is assumed to be the path of a readable file relative to the directory in which GAP was started.

Note: For those familiar with the `pq` program, `PqRestorePcPresentation` performs menu item 3 of the main p-Quotient menu.

##### 5.6-4 PqNextClass

`‣ PqNextClass`( i: [QueueFactor] ) | ( function )

`‣ PqNextClass`( : [QueueFactor] ) | ( function )

for the ith or default interactive ANUPQ process, direct the `pq` program to calculate the next class of `ANUPQData.io[i].group`.

`PqNextClass` accepts the option `QueueFactor` (see also 6.2) which should be a positive integer if automorphisms have been previously supplied. If the `pq` program requires a queue factor and none is supplied via the option `QueueFactor` a default of 15 is taken.

Notes

The single command: `PqNextClass(i);` is equivalent to executing

    PqComputePCover(i);
    PqCollectDefiningRelations(i);
    PqDoExponentChecks(i);
    PqEliminateRedundantGenerators(i);

If the `Identities` option is set the `PqEliminateRedundantGenerators(i);` step is essentially replaced by `PqEvaluateIdentities(i);` (which invokes its own elimination of redundant generators).

For those familiar with the `pq` program, `PqNextClass` performs menu item 6 of the main p-Quotient menu.

##### 5.6-5 PqComputePCover

`‣ PqComputePCover`( i ) | ( function )

`‣ PqComputePCover`( ) | ( function )

for the ith or default interactive ANUPQ processi, directi, the `pq` program to compute the p-covering group of `ANUPQData.io[i].group`. In contrast to the function `PqPCover` (see `PqPCover` (4.1-3)), this function does not return a GAP pc group.

Notes

The single command: `PqComputePCover(i);` is equivalent to executing

    PqSetupTablesForNextClass(i);
    PqTails(i, 0);
    PqDoConsistencyChecks(i, 0, 0);
    PqEliminateRedundantGenerators(i);

For those familiar with the `pq` program, `PqComputePCover` performs menu item 7 of the main p-Quotient menu.

#### 5.7 Commands from the Advanced p-Quotient menu

##### 5.7-1 PqCollect

`‣ PqCollect`( i, word ) | ( function )

`‣ PqCollect`( word ) | ( function )

for the ith or default interactive ANUPQ process, instruct the `pq` program to do a collection on word, a word in the current pc generators (the form of word required is described below). `PqCollect` returns the resulting word of the collection as a list of generator number, exponent pairs (the same form as the second allowed input form of word; see below).

The argument word may be input in either of the following ways:

1. word may be a string, where the ith pc generator is represented by `xi`, e.g. `"x3*x2^2*x1"`. This way is quite versatile as parentheses and left-normed commutators -- using square brackets, in the same way as `PqGAPRelators` (see `PqGAPRelators` (3.4-2)) -- are permitted; word is checked for correct syntax via `PqParseWord` (see `PqParseWord` (3.4-3)).

2. Otherwise, word must be a list of generator number, exponent pairs of integers, i.e. each pair represents a "syllable" so that `[ [3, 1], [2, 2], [1, 1] ]` represents the same word as that of the example given for the first allowed form of word.

Note: For those familiar with the `pq` program, `PqCollect` performs menu item 1 of the Advanced p-Quotient menu.

##### 5.7-2 PqSolveEquation

`‣ PqSolveEquation`( i, a, b ) | ( function )

`‣ PqSolveEquation`( a, b ) | ( function )

for the ith or default interactive ANUPQ process, direct the `pq` program to solve a * x = b for x, where a and b are words in the pc generators. For the representation of these words see the description of the function `PqCollect` (`PqCollect` (5.7-1)).

Note: For those familiar with the `pq` program, `PqSolveEquation` performs menu item 2 of the Advanced p-Quotient menu.

##### 5.7-3 PqCommutator

`‣ PqCommutator`( i, words, pow ) | ( function )

`‣ PqCommutator`( words, pow ) | ( function )

for the ith or default interactive ANUPQ process, instruct the `pq` program to compute the left normed commutator of the list words of words in the current pc generators raised to the integer power pow, and return the resulting word as a list of generator number, exponent pairs. The form required for each word of words is the same as that required for the word argument of `PqCollect` (see `PqCollect` (5.7-1)). The form of the output word is also the same as for `PqCollect`.

Note: For those familiar with the `pq` program, `PqCommutator` performs menu item 3 of the Advanced p-Quotient menu.

##### 5.7-4 PqSetupTablesForNextClass

`‣ PqSetupTablesForNextClass`( i ) | ( function )

`‣ PqSetupTablesForNextClass`( ) | ( function )

for the ith or default interactive ANUPQ process, direct the `pq` program to set up tables for the next class. As as side-effect, after `PqSetupTablesForNextClass(i)` the value returned by `PqPClass(i)` will be one more than it was previously.

Note: For those familiar with the `pq` program, `PqSetupTablesForNextClass` performs menu item 6 of the Advanced p-Quotient menu.

##### 5.7-5 PqTails

`‣ PqTails`( i, weight ) | ( function )

`‣ PqTails`( weight ) | ( function )

for the ith or default interactive ANUPQ process, direct the `pq` program to compute and add tails of weight weight if weight is in the integer range `[2 .. PqPClass(i)]` (assuming i is the number of the process, even in the default case) or for all weights if `weight = 0`.

If weight is non-zero, then tails that introduce new generators for only weight weight are computed and added, and in this case and if `weight < PqPClass(i)`, it is assumed that the tails that introduce new generators for each weight from `PqPClass(i)` down to weight `weight + 1` have already been added. You may wish to call `PqSetMetabelian` (see `PqSetMetabelian` (5.7-16)) prior to calling `PqTails`.

Notes

For its use in the context of finding the next class see `PqNextClass` (5.6-4); in particular, a call to `PqSetupTablesForNextClass` (see `PqSetupTablesForNextClass` (5.7-4)) needs to have been made prior to calling `PqTails`.

The single command: `PqTails(i, weight);` is equivalent to

    PqComputeTails(i, weight);
    PqAddTails(i, weight);

For those familiar with the `pq` program, `PqTails` uses menu item 7 of the Advanced p-Quotient menu.

##### 5.7-6 PqComputeTails

`‣ PqComputeTails`( i, weight ) | ( function )

`‣ PqComputeTails`( weight ) | ( function )

for the ith or default interactive ANUPQ process, direct the `pq` program to compute tails of weight weight if weight is in the integer range `[2 .. PqPClass(i)]` (assuming i is the number of the process, even in the default case) or for all weights if `weight = 0`. See `PqTails` (`PqTails` (5.7-5)) for more details.

Note: For those familiar with the `pq` program, `PqComputeTails` uses menu item 7 of the Advanced p-Quotient menu.

##### 5.7-7 PqAddTails

`‣ PqAddTails`( i, weight ) | ( function )

`‣ PqAddTails`( weight ) | ( function )

for the ith or default interactive ANUPQ process, direct the `pq` program to add the tails of weight weight, previously computed by `PqComputeTails` (see `PqComputeTails` (5.7-6)), if weight is in the integer range `[2 .. PqPClass(i)]` (assuming i is the number of the process, even in the default case) or for all weights if `weight = 0`. See `PqTails` (`PqTails` (5.7-5)) for more details.

Note: For those familiar with the `pq` program, `PqAddTails` uses menu item 7 of the Advanced p-Quotient menu.

##### 5.7-8 PqDoConsistencyChecks

`‣ PqDoConsistencyChecks`( i, weight, type ) | ( function )

`‣ PqDoConsistencyChecks`( weight, type ) | ( function )

for the ith or default interactive ANUPQ process, do consistency checks for weight weight if weight is in the integer range `[3 .. PqPClass(i)]` (assuming i is the number of the process) or for all weights if `weight = 0`, and for type type if type is in the range `[1, 2, 3]` (see below) or for all types if `type = 0`. (For its use in the context of finding the next class see `PqNextClass` (5.6-4).)

The type of a consistency check is defined as follows. `PqDoConsistencyChecks(i, weight, type)` for weight in `[3 .. PqPClass(i)]` and the given value of type invokes the equivalent of the following `PqDoConsistencyCheck` calls (see `PqDoConsistencyCheck` (5.7-17)):

`type = 1`:

  `PqDoConsistencyCheck(i, a, a, a)` checks `2 * PqWeight(i, a) + 1 = weight`, for pc generators of index a.

`type = 2`:

  `PqDoConsistencyCheck(i, b, b, a)` checks for pc generators of indices b, a satisfyingx both `b > a` and `PqWeight(i, b) + PqWeight(i, a) + 1 = weight`.

`type = 3`:

  `PqDoConsistencyCheck(i, c, b, a)` checks for pc generators of indices c, b, a satisfying `c > b > a` and the sum of the weights of these generators equals weight.

Notes

`PqWeight(i, j)` returns the weight of the jth pc generator, for process i (see `PqWeight` (5.5-5)).

It is assumed that tails for the given weight (or weights) have already been added (see `PqTails` (5.7-5)).

For those familiar with the `pq` program, `PqDoConsistencyChecks` performs menu item 8 of the Advanced p-Quotient menu.

##### 5.7-9 PqCollectDefiningRelations

`‣ PqCollectDefiningRelations`( i ) | ( function )

`‣ PqCollectDefiningRelations`( ) | ( function )

for the ith or default interactive ANUPQ process, direct the `pq` program to collect the images of the defining relations of the original fp group of the process, with respect to the current pc presentation, in the context of finding the next class (see `PqNextClass` (5.6-4)). If the tails operation is not complete then the relations may be evaluated incorrectly.

Note: For those familiar with the `pq` program, `PqCollectDefiningRelations` performs menu item 9 of the Advanced p-Quotient menu.

##### 5.7-10 PqCollectWordInDefiningGenerators

`‣ PqCollectWordInDefiningGenerators`( i, word ) | ( function )

`‣ PqCollectWordInDefiningGenerators`( word ) | ( function )

for the ith or default interactive ANUPQ process, take a user-defined word word in the defining generators of the original presentation of the fp or pc group of the process. Each generator is mapped into the current pc presentation, and the resulting word is collected with respect to the current pc presentation. The result of the collection is returned as a list of generator number, exponent pairs.

The word argument may be input in either of the two ways described for `PqCollect` (see `PqCollect` (5.7-1)).

Note: For those familiar with the `pq` program, `PqCollectDefiningGenerators` performs menu item 23 of the Advanced p-Quotient menu.

##### 5.7-11 PqCommutatorDefiningGenerators

`‣ PqCommutatorDefiningGenerators`( i, words, pow ) | ( function )

`‣ PqCommutatorDefiningGenerators`( words, pow ) | ( function )

for the ith or default interactive ANUPQ process, take a list words of user-defined words in the defining generators of the original presentation of the fp or pc group of the process, and an integer power pow. Each generator is mapped into the current pc presentation. The list words is interpreted as a left-normed commutator which is then raised to pow and collected with respect to the current pc presentation. The result of the collection is returned as a list of generator number, exponent pairs.

Note For those familiar with the `pq` program, `PqCommutatorDefiningGenerators` performs menu item 24 of the Advanced p-Quotient menu.

##### 5.7-12 PqDoExponentChecks

`‣ PqDoExponentChecks`( i: [Bounds := list] ) | ( function )

`‣ PqDoExponentChecks`( : [Bounds := list] ) | ( function )

for the ith or default interactive ANUPQ process, direct the `pq` program to do exponent checks for weights (inclusively) between the bounds of `Bounds` or for all weights if `Bounds` is not given. The value list of `Bounds` (assuming the interactive process is numbered i) should be a list of two integers low, high satisfying 1 le low le high le `PqPClass(i)` (see `PqPClass` (5.5-4)). If no exponent law has been specified, no exponent checks are performed.

Note: For those familiar with the `pq` program, `PqDoExponentChecks` performs menu item 10 of the Advanced p-Quotient menu.

##### 5.7-13 PqEliminateRedundantGenerators

`‣ PqEliminateRedundantGenerators`( i ) | ( function )

`‣ PqEliminateRedundantGenerators`( ) | ( function )

for the ith or default interactive ANUPQ process, direct the `pq` program to eliminate redundant generators of the current p-quotient.

Note: For those familiar with the `pq` program, `PqEliminateRedundantGenerators` performs menu item 11 of the Advanced p-Quotient menu.

##### 5.7-14 PqRevertToPreviousClass

`‣ PqRevertToPreviousClass`( i ) | ( function )

`‣ PqRevertToPreviousClass`( ) | ( function )

for the ith or default interactive ANUPQ process, direct the `pq` program to abandon the current class and revert to the previous class.

Note: For those familiar with the `pq` program, `PqRevertToPreviousClass` performs menu item 12 of the Advanced p-Quotient menu.

##### 5.7-15 PqSetMaximalOccurrences

`‣ PqSetMaximalOccurrences`( i, noccur ) | ( function )

`‣ PqSetMaximalOccurrences`( noccur ) | ( function )

for the ith or default interactive ANUPQ process, direct the `pq` program to set maximal occurrences of the weight 1 generators in the definitions of pcp generators of the group of the process. This can be used to avoid the definition of generators of which one knows for theoretical reasons that they would be eliminated later on.

The argument noccur must be a list of non-negative integers of length the number of weight 1 generators (i.e. the rank of the class 1 p-quotient of the group of the process). An entry of `0` for a particular generator indicates that there is no limit on the number of occurrences for the generator.

Note: For those familiar with the `pq` program, `PqSetMaximalOccurrences` performs menu item 13 of the Advanced p-Quotient menu.

##### 5.7-16 PqSetMetabelian

`‣ PqSetMetabelian`( i ) | ( function )

`‣ PqSetMetabelian`( ) | ( function )

for the ith or default interactive ANUPQ process, direct the `pq` program to enforce metabelian-ness.

Note: For those familiar with the `pq` program, `PqSetMetabelian` performs menu item 14 of the Advanced p-Quotient menu.

##### 5.7-17 PqDoConsistencyCheck

`‣ PqDoConsistencyCheck`( i, c, b, a ) | ( function )

`‣ PqDoConsistencyCheck`( c, b, a ) | ( function )

`‣ PqJacobi`( i, c, b, a ) | ( function )

`‣ PqJacobi`( c, b, a ) | ( function )

for the ith or default interactive ANUPQ process, direct the `pq` program to do the consistency check for the pc generators with indices c, b, a which should be non-increasing positive integers, i.e. c ge b ge a.

There are 3 types of consistency checks:

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

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

\begin{array}{rcl} c(ba) &=& a c[c,a] b[b,a] = acb [c,a][c,a,b][b,a] = \dots \\ (cb)a &=& b c[c,b] a = a b[b,a] c[c,a] [c,b][c,b,a] \\ &=& abc [b,a] [b,a,c] [c,a] [c,b] [c,b,a] = \dots \\ \end{array}

Each collection would normally carry on further. But one can see already that no other commutators of weight 3 will occur. After all terms of weight one and weight two have been moved to the left we end up with:

\begin{array}{rcl} & &abc [b,a] [c,a] [c,b] [c,a,b] \dots \\ &=&abc [b,a] [c,a] [c,b] [c,b,a] [b,a,c] \dots \\ \end{array}

Modulo terms of weight 4 this is equivalent to

[c,a,b] [b,c,a] [a,b,c] = 1

which is the Jacobi identity.

See also `PqDoConsistencyChecks` (`PqDoConsistencyChecks` (5.7-8)).

Note: For those familiar with the `pq` program, `PqDoConsistencyCheck` and `PqJacobi` perform menu item 15 of the Advanced p-Quotient menu.

##### 5.7-18 PqCompact

`‣ PqCompact`( i ) | ( function )

`‣ PqCompact`( ) | ( function )

for the ith or default interactive ANUPQ process, direct the `pq` program to do a compaction of its work space. This function is safe to perform only at certain points in time.

Note: For those familiar with the `pq` program, `PqCompact` performs menu item 16 of the Advanced p-Quotient menu.

##### 5.7-19 PqEchelonise

`‣ PqEchelonise`( i ) | ( function )

`‣ PqEchelonise`( ) | ( function )

for the ith or default interactive ANUPQ process, direct the `pq` program to echelonise the word most recently collected by `PqCollect` or `PqCommutator` against the relations of the current pc presentation, and return the number of the generator made redundant or `fail` if no generator was made redundant. A call to `PqCollect` (see `PqCollect` (5.7-1)) or `PqCommutator` (see `PqCommutator` (5.7-3)) needs to be performed prior to using this command.

Note: For those familiar with the `pq` program, `PqEchelonise` performs menu item 17 of the Advanced p-Quotient menu.

##### 5.7-20 PqSupplyAutomorphisms

`‣ PqSupplyAutomorphisms`( i, mlist ) | ( function )

`‣ PqSupplyAutomorphisms`( mlist ) | ( function )

for the ith or default interactive ANUPQ process, supply the automorphism data provided by the list mlist of matrices with non-negative integer coefficients. Each matrix in mlist describes one automorphism in the following way.

- The rows of each matrix correspond to the pc generators of weight one.

- Each row is the exponent vector of the image of the corresponding weight one generator under the respective automorphism.

Note: For those familiar with the `pq` program, `PqSupplyAutomorphisms` uses menu item 18 of the Advanced p-Quotient menu.

##### 5.7-21 PqExtendAutomorphisms

`‣ PqExtendAutomorphisms`( i ) | ( function )

`‣ PqExtendAutomorphisms`( ) | ( function )

for the ith or default interactive ANUPQ process, direct the `pq` program to extend automorphisms of the p-quotient of the previous class to the p-quotient of the present class.

Note: For those familiar with the `pq` program, `PqExtendAutomorphisms` uses menu item 18 of the Advanced p-Quotient menu.

##### 5.7-22 PqApplyAutomorphisms

`‣ PqApplyAutomorphisms`( i, qfac ) | ( function )

`‣ PqApplyAutomorphisms`( qfac ) | ( function )

for the ith or default interactive ANUPQ process, direct the `pq` program to apply automorphisms; qfac is the queue factor e.g. `15`.

Note: For those familiar with the `pq` program, `PqCloseRelations` performs menu item 19 of the Advanced p-Quotient menu.

##### 5.7-23 PqDisplayStructure

`‣ PqDisplayStructure`( i: [Bounds := list] ) | ( function )

`‣ PqDisplayStructure`( : [Bounds := list] ) | ( function )

for the ith or default interactive ANUPQ process, direct the `pq` program to display the structure for the pcp generators numbered (inclusively) between the bounds of `Bounds` or for all generators if `Bounds` is not given. The value list of `Bounds` (assuming the interactive process is numbered i) should be a list of two integers low, high satisfying 1 le low le high le `PqNrPcGenerators(i)` (see `PqNrPcGenerators` (5.5-1)). `PqDisplayStructure` also accepts the option `OutputLevel` (see 6.2).

Explanation of output

New generators are defined as commutators of previous generators and generators of class 1 or as p-th powers of generators that have themselves been defined as p-th powers. A generator is never defined as p-th power of a commutator.

Therefore, there are two cases: all the numbers on the righthand side are either the same or they differ. Below, `gi` refers to the ith defining generator.

- If the righthand side numbers are all the same, then the generator is a p-th power (of a p-th power of a p-th power, etc.). The number of repeated digits say how often a p-th power has to be taken.

  In the following example, the generator number 31 is the eleventh power of generator 17 which in turn is an eleventh power and so on:

  \begintt #I 31 is defined on 17^11 = 1 1 1 1 1 \endtt So generator 31 is obtained by taking the eleventh power of generator 1 five times.

- If the numbers are not all the same, the generator is defined by a commutator. If the first two generator numbers differ, the generator is defined as a left-normed commutator of the weight one generators, e.g.

  \begintt #I 19 is defined on [11, 1] = 2 1 1 1 1 \endtt Here, generator 19 is defined as the commutator of generator 11 and generator 1 which is the same as the left-normed commutator `[x2, x1, x1, x1, x1]`. One can check this by tracing back the definition of generator 11 until one gets to a generator of class 1.

- If the first two generator numbers are identical, then the left most component of the left-normed commutator is a p-th power, e.g.

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

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

  [(x1^{11})^{11}, x2, x1, x1]

  Again, this can be verified by tracing back the definitions.

Note: For those familiar with the `pq` program, `PqDisplayStructure` performs menu item 20 of the Advanced p-Quotient menu.

##### 5.7-24 PqDisplayAutomorphisms

`‣ PqDisplayAutomorphisms`( i: [Bounds := list] ) | ( function )

`‣ PqDisplayAutomorphisms`( : [Bounds := list] ) | ( function )

for the ith or default interactive ANUPQ process, direct the `pq` program to display the automorphism actions on the pcp generators numbered (inclusively) between the bounds of `Bounds` or for all generators if `Bounds` is not given. The value list of `Bounds` (assuming the interactive process is numbered i) should be a list of two integers low, high satisfying 1 le low le high le `PqNrPcGenerators(i)` (see `PqNrPcGenerators` (5.5-1)). `PqDisplayStructure` also accepts the option `OutputLevel` (see 6.2).

Note: For those familiar with the `pq` program, `PqDisplayAutomorphisms` performs menu item 21 of the Advanced p-Quotient menu.

##### 5.7-25 PqWritePcPresentation

`‣ PqWritePcPresentation`( i, filename ) | ( function )

`‣ PqWritePcPresentation`( filename ) | ( function )

for the ith or default interactive ANUPQ process, direct the `pq` program to write a pc presentation of a previously-computed quotient of the group of that process, to the file with name filename. Here the group of a process is the one given as first argument when `PqStart` was called to initiate that process (for process i the group is stored as `ANUPQData.io[i].group`). If the first character of the string filename is not `/`, filename is assumed to be the path of a writable file relative to the directory in which GAP was started. If a pc presentation has not been previously computed by the `pq` program, then `pq` is called to compute it first, effectively invoking `PqPcPresentation` (see `PqPcPresentation` (5.6-1)).

Note: For those familiar with the `pq` program, `PqPcWritePresentation` performs menu item 25 of the Advanced p-Quotient menu.

#### 5.8 Commands from the Standard Presentation menu

##### 5.8-1 PqSPComputePcpAndPCover

`‣ PqSPComputePcpAndPCover`( i: options ) | ( function )

`‣ PqSPComputePcpAndPCover`( : options ) | ( function )

for the ith or default interactive ANUPQ process, directs the `pq` program to compute for the group of that process a pc presentation up to the p-quotient of maximum class or the value of the option `ClassBound` and the p-cover of that quotient, and sets up tabular information required for computation of a standard presentation. Here the group of a process is the one given as first argument when `PqStart` was called to initiate that process (for process i the group is stored as `ANUPQData.io[i].group`).

The possible options are `Prime`, `ClassBound`, `Relators`, `Exponent`, `Metabelian` and `OutputLevel` (see Chapter ANUPQ Options for detailed descriptions of these options). The option `Prime` is normally determined via `PrimePGroup`, and so is not required unless the group doesn't know it's a p-group and `HasPrimePGroup` returns `false`.

Note: For those familiar with the `pq` program, `PqSPComputePcpAndPCover` performs option 1 of the Standard Presentation menu.

##### 5.8-2 PqSPStandardPresentation

`‣ PqSPStandardPresentation`( i[, mlist]: [options] ) | ( function )

`‣ PqSPStandardPresentation`( [mlist]: [options] ) | ( function )

for the ith or default interactive ANUPQ process, inputs data given by options to compute a standard presentation for the group of that process. If argument mlist is given it is assumed to be the automorphism group data required. Otherwise it is assumed that a call to either `Pq` (see `Pq` (5.3-1)) or `PqEpimorphism` (see `PqEpimorphism` (5.3-2)) has generated a p-quotient and that GAP can compute its automorphism group from which the necessary automorphism group data can be derived. The group of the process is the one given as first argument when `PqStart` was called to initiate the process (for process i the group is stored as `ANUPQData.io[i].group` and the p-quotient if existent is stored as `ANUPQData.io[i].pQuotient`). If mlist is not given and a p-quotient of the group has not been previously computed a class 1 p-quotient is computed.

`PqSPStandardPresentation` accepts three options, all optional:

- `ClassBound := n`

- `PcgsAutomorphisms`

- `StandardPresentationFile := filename`

If `ClassBound` is omitted it defaults to 63.

Detailed descriptions of the above options may be found in Chapter ANUPQ Options.

Note: For those familiar with the `pq` program, `PqSPPcPresentation` performs menu item 2 of the Standard Presentation menu.

##### 5.8-3 PqSPSavePresentation

`‣ PqSPSavePresentation`( i, filename ) | ( function )

`‣ PqSPSavePresentation`( filename ) | ( function )

for the ith or default interactive ANUPQ process, directs the `pq` program to save the standard presentation previously computed for the group of that process to the file with name filename, where the group of a process is the one given as first argument when `PqStart` was called to initiate that process. If the first character of the string filename is not `/`, filename is assumed to be the path of a writable file relative to the directory in which GAP was started.

Note: For those familiar with the `pq` program, `PqSPSavePresentation` performs menu item 3 of the Standard Presentation menu.

##### 5.8-4 PqSPCompareTwoFilePresentations

`‣ PqSPCompareTwoFilePresentations`( i, f1, f2 ) | ( function )

`‣ PqSPCompareTwoFilePresentations`( f1, f2 ) | ( function )

for the ith or default interactive ANUPQ process, direct the `pq` program to compare the presentations in the files with names f1 and f2 and returns `true` if they are identical and `false` otherwise. For each of the strings f1 and f2, if the first character is not a `/` then it is assumed to be the path of a readable file relative to the directory in which GAP was started.

Notes

The presentations in files f1 and f2 must have been generated by the `pq` program but they do not need to be standard presentations. If If the presentations in files f1 and f2 have been generated by `PqSPStandardPresentation` (see `PqSPStandardPresentation` (5.8-2)) then a `false` response from `PqSPCompareTwoFilePresentations` says the groups defined by those presentations are not isomorphic.

For those familiar with the `pq` program, `PqSPCompareTwoFilePresentations` performs menu item 6 of the Standard Presentation menu.

##### 5.8-5 PqSPIsomorphism

`‣ PqSPIsomorphism`( i ) | ( function )

`‣ PqSPIsomorphism`( ) | ( function )

for the ith or default interactive ANUPQ process, direct the `pq` program to compute the isomorphism mapping from the p-group of the process to its standard presentation. This function provides a description only; for a GAP object, use `EpimorphismStandardPresentation` (see `EpimorphismStandardPresentation` (5.3-5)).

Note: For those familiar with the `pq` program, `PqSPIsomorphism` performs menu item 8 of the Standard Presentation menu.

#### 5.9 Commands from the Main p-Group Generation menu

Note that the p-group generation commands can only be applied once the `pq` program has produced a pc presentation of some quotient group of the "group of the process".

##### 5.9-1 PqPGSupplyAutomorphisms

`‣ PqPGSupplyAutomorphisms`( i[, mlist]: options ) | ( function )

`‣ PqPGSupplyAutomorphisms`( [mlist]: options ) | ( function )

for the ith or default interactive ANUPQ process, supply the `pq` program with the automorphism group data needed for the current quotient of the group of that process (for process i the group is stored as `ANUPQData.io[i].group`). For a description of the format of mlist see `PqSupplyAutomorphisms` (5.7-20). The options possible are `NumberOfSolubleAutomorphisms` and `RelativeOrders`. (Detailed descriptions of these options may be found in Chapter ANUPQ Options.)

If mlist is omitted, the automorphism data is determined from the group of the process which must have been a p-group in pc presentation.

Note: For those familiar with the `pq` program, `PqPGSupplyAutomorphisms` performs menu item 1 of the main p-Group Generation menu.

##### 5.9-2 PqPGExtendAutomorphisms

`‣ PqPGExtendAutomorphisms`( i ) | ( function )

`‣ PqPGExtendAutomorphisms`( ) | ( function )

for the ith or default interactive ANUPQ process, direct the `pq` program to compute the extensions of the automorphisms of the p-quotient of the previous class to the p-quotient of the current class. You may wish to set the `InfoLevel` of `InfoANUPQ` to 2 (or more) in order to see the output from the `pq` program (see `InfoANUPQ` (3.3-1)).

Note: For those familiar with the `pq` program, `PqPGExtendAutomorphisms` performs menu item 2 of the main or advanced p-Group Generation menu.

##### 5.9-3 PqPGConstructDescendants

`‣ PqPGConstructDescendants`( i: options ) | ( function )

`‣ PqPGConstructDescendants`( : options ) | ( function )

for the ith or default interactive ANUPQ process, direct the `pq` program to construct descendants prescribed by options, and return the number of descendants constructed (compare function `PqDescendants` (4.4-1) which returns the list of descendants). The options possible are `ClassBound`, `OrderBound`, `StepSize`, `PcgsAutomorphisms`, `RankInitialSegmentSubgroups`, `SpaceEfficient`, `CapableDescendants`, `AllDescendants`, `Exponent`, `Metabelian`, `BasicAlgorithm`, `CustomiseOutput`. (Detailed descriptions of these options may be found in Chapter ANUPQ Options.)

`PqPGConstructDescendants` requires that the `pq` program has previously computed a pc presentation and a p-cover for a p-quotient of some class of the group of the process.

Note: For those familiar with the `pq` program, `PqPGConstructDescendants` performs menu item 5 of the main p-Group Generation menu.

##### 5.9-4 PqPGSetDescendantToPcp

`‣ PqPGSetDescendantToPcp`( i, cls, n ) | ( function )

`‣ PqPGSetDescendantToPcp`( cls, n ) | ( function )

`‣ PqPGSetDescendantToPcp`( i: [Filename := name] ) | ( function )

`‣ PqPGSetDescendantToPcp`( : [Filename := name] ) | ( function )

`‣ PqPGRestoreDescendantFromFile`( i, cls, n ) | ( function )

`‣ PqPGRestoreDescendantFromFile`( cls, n ) | ( function )

`‣ PqPGRestoreDescendantFromFile`( i: [Filename := name] ) | ( function )

`‣ PqPGRestoreDescendantFromFile`( : [Filename := name] ) | ( function )

for the ith or default interactive ANUPQ process, direct the `pq` program to restore group n of class cls from a temporary file, where cls and n are positive integers, or the group stored in name. `PqPGSetDescendantToPcp` and `PqPGRestoreDescendantFromFile` are synonyms; they make sense only after a prior call to construct descendants by say `PqPGConstructDescendants` (see `PqPGConstructDescendants` (5.9-3)) or the interactive `PqDescendants` (see `PqDescendants` (5.3-6)). In the `Filename` option forms, the option defaults to the last filename in which a presentation was stored by the `pq` program.

Notes

Since the `PqPGSetDescendantToPcp` and `PqPGRestoreDescendantFromFile` are intended to be used in calculation of further descendants the `pq` program computes the p-cover of the restored descendant. Hence, `PqCurrentGroup` used immediately after one of these commands returns the p-cover of the restored descendant rather than the descendant itself.

For those familiar with the `pq` program, `PqPGSetDescendantToPcp` and `PqPGRestoreDescendantFromFile` perform menu item 3 of the main or advanced p-Group Generation menu.

#### 5.10 Commands from the Advanced p-Group Generation menu

The functions below perform the component algorithms of `PqPGConstructDescendants` (see `PqPGConstructDescendants` (5.9-3)). You can get some idea of their usage by trying `PqExample("Nott-APG-Rel-i");`. You can get some idea of the breakdown of `PqPGConstructDescendants` into these functions by comparing the previous output with `PqExample("Nott-PG-Rel-i");`.

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

##### 5.10-1 PqAPGDegree

`‣ PqAPGDegree`( i, step, rank: [Exponent := n] ) | ( function )

`‣ PqAPGDegree`( step, rank: [Exponent := n] ) | ( function )

for the ith or default interactive ANUPQ process, direct the `pq` program to invoke menu item 6 of the Advanced p-Group Generation menu. Here the step-size step and the rank rank are positive integers and are the arguments required by the `pq` program. See 6.2 for the one recognised option `Exponent`.

##### 5.10-2 PqAPGPermutations

`‣ PqAPGPermutations`( i: options ) | ( function )

`‣ PqAPGPermutations`( : options ) | ( function )

for the ith or default interactive ANUPQ process, direct the `pq` program to perform menu item 7 of the Advanced p-Group Generation menu. Here the options options recognised are `PcgsAutomorphisms`, `SpaceEfficient`, `PrintAutomorphisms` and `PrintPermutations` (see Chapter ANUPQ Options for details).

##### 5.10-3 PqAPGOrbits

`‣ PqAPGOrbits`( i: options ) | ( function )

`‣ PqAPGOrbits`( : options ) | ( function )

for the ith or default interactive ANUPQ process, direct the `pq` to perform menu item 8 of the Advanced p-Group Generation menu.

Here the options options recognised are `PcgsAutomorphisms`, `SpaceEfficient` and `CustomiseOutput` (see Chapter ANUPQ Options for details). For the `CustomiseOutput` option only the setting of the `orbit` is recognised (all other fields if set are ignored).

##### 5.10-4 PqAPGOrbitRepresentatives

`‣ PqAPGOrbitRepresentatives`( i: options ) | ( function )

`‣ PqAPGOrbitRepresentatives`( : options ) | ( function )

for the ith or default interactive ANUPQ process, direct the `pq` to perform item 9 of the Advanced p-Group Generation menu.

The options options may be any selection of the following: `PcgsAutomorphisms`, `SpaceEfficient`, `Exponent`, `Metabelian`, `CapableDescendants` (or `AllDescendants`), `CustomiseOutput` (where only the `group` and `autgroup` fields are recognised) and `Filename` (see Chapter ANUPQ Options for details). If `Filename` is omitted the reduced p-cover is written to the file `"redPCover"` in the temporary directory whose name is stored in `ANUPQData.tmpdir`.

##### 5.10-5 PqAPGSingleStage

`‣ PqAPGSingleStage`( i: options ) | ( function )

`‣ PqAPGSingleStage`( : options ) | ( function )

for the ith or default interactive ANUPQ process, direct the `pq` to perform option 5 of the Advanced p-Group Generation menu.

The possible options are `StepSize`, `PcgsAutomorphisms`, `RankInitialSegmentSubgroups`, `SpaceEfficient`, `CapableDescendants`, `AllDescendants`, `Exponent`, `Metabelian`, `BasicAlgorithm` and `CustomiseOutput`. (Detailed descriptions of these options may be found in Chapter ANUPQ Options.)

#### 5.11 Primitive Interactive ANUPQ Process Read/Write Functions

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

##### 5.11-1 PqRead

`‣ PqRead`( i ) | ( function )

`‣ PqRead`( ) | ( function )

read a complete line of ANUPQ output, from the ith or default interactive ANUPQ process, if there is output to be read and returns `fail` otherwise. When successful, the line is returned as a string complete with trailing newline, colon, or question-mark character. Please note that it is possible to be "too quick" (i.e. the return can be `fail` purely because the output from ANUPQ is not there yet), but if `PqRead` finds any output at all, it waits for a complete line. `PqRead` also writes the line read via `Info` at `InfoANUPQ` level 2. It doesn't try to distinguish banner and menu output from other output of the `pq` program.

##### 5.11-2 PqReadAll

`‣ PqReadAll`( i ) | ( function )

`‣ PqReadAll`( ) | ( function )

read and return as many complete lines of ANUPQ output, from the ith or default interactive ANUPQ process, as there are to be read, at the time of the call, as a list of strings with any trailing newlines removed and returns the empty list otherwise. `PqReadAll` also writes each line read via `Info` at `InfoANUPQ` level 2. It doesn't try to distinguish banner and menu output from other output of the `pq` program. Whenever `PqReadAll` finds only a partial line, it waits for the complete line, thus increasing the probability that it has captured all the output to be had from ANUPQ.

##### 5.11-3 PqReadUntil

`‣ PqReadUntil`( i, IsMyLine ) | ( function )

`‣ PqReadUntil`( IsMyLine ) | ( function )

`‣ PqReadUntil`( i, IsMyLine, Modify ) | ( function )

`‣ PqReadUntil`( IsMyLine, Modify ) | ( function )

read complete lines of ANUPQ output, from the ith or default interactive ANUPQ process, "chomps" them (i.e. removes any trailing newline character), emits them to `Info` at `InfoANUPQ` level 2 (without trying to distinguish banner and menu output from other output of the `pq` program), and applies the function Modify (where Modify is just the identity map/function for the first two forms) until a "chomped" line line for which `IsMyLine( Modify(line) )` is true. `PqReadUntil` returns the list of Modify-ed "chomped" lines read.

Notes: When provided by the user, Modify should be a function that accepts a single string argument.

IsMyLine should be a function that is able to accept the output of Modify (or take a single string argument when Modify is not provided) and should return a boolean.

If `IsMyLine( Modify(line) )` is never true, `PqReadUntil` will wait indefinitely.

##### 5.11-4 PqWrite

`‣ PqWrite`( i, string ) | ( function )

`‣ PqWrite`( string ) | ( function )

write string to the ith or default interactive ANUPQ process; string must be in exactly the form the ANUPQ standalone expects. The command is echoed via `Info` at `InfoANUPQ` level 3 (with a "`ToPQ>` " prompt); i.e. do `SetInfoLevel(InfoANUPQ, 3);` to see what is transmitted to the `pq` program. `PqWrite` returns `true` if successful in writing to the stream of the interactive ANUPQ process, and `fail` otherwise.

Note: If `PqWrite` returns `fail` it means that the ANUPQ process has died.

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

generated by GAPDoc2HTML