<Chapter Label="ANUPQ Options">
<Heading>ANUPQ Options</Heading>

<Section>
<Heading>Overview</Heading>

In this chapter we describe in detail all the options used by functions
of the &ANUPQ; package. Note that by <Q>options</Q> we mean &GAP; options
that are passed to functions after the arguments and separated from the
arguments by a colon as described in Chapter&nbsp;<Ref BookName="ref" Label="Function Calls" Style="Text"/> in the
Reference Manual. The user is strongly advised to read Section&nbsp;<Ref Sect="Hints and Warnings regarding the use of Options" Style="Text"/>.

<ManSection>
<Func Name="AllANUPQoptions" Arg=""/>
<Description>
lists all the &GAP; options defined for functions of the &ANUPQ;
package:

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

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

<ManSection>
<Var Name="ANUPQoptions"/>
<Description>
is a record of lists of names of admissible &ANUPQ; options, such that
each field is either the name of a <Q>key</Q> &ANUPQ; function or <C>other</C>
(for a miscellaneous list of functions) and the corresponding value is
the list of option names that are admissible for the function (or
miscellaneous list of functions).
<P/>

Also, from within a &GAP; session, you may use &GAP;'s help browser
(see Chapter&nbsp;<Ref BookName="ref" Label="The Help System" Style="Text"/> in the &GAP; Reference Manual); to
find out about any particular &ANUPQ; option, simply type: <Q><C>?option
<A>option</A></C></Q>, where <A>option</A> is one of the options listed above without
any quotes, e.g.

<Log><![CDATA[
gap> ?option Prime
]]></Log>

will display the sections in this manual that describe the <C>Prime</C>
option. In fact the first 4 are for the functions that have <C>Prime</C> as an
option and the last actually describes the option. So follow up by
choosing
<!-- FIXME: check whether this is still correct -->

<Log><![CDATA[
gap> ?5
]]></Log>

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

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

<Log><![CDATA[
gap> ?>
]]></Log>

</Description>
</ManSection>

</Section>

<Section Label="Detailed descriptions of ANUPQ Options">
<Heading>Detailed descriptions of ANUPQ Options</Heading>

<List>

<Mark><C>Prime := <A>p</A></C>
<Label Name="option Prime"/><Index>option Prime</Index></Mark>
<Item>
Specifies that the <M>p</M>-quotient for the prime <A>p</A> should be computed.
</Item>

<Mark><C>ClassBound := <A>n</A></C>
<Label Name="option ClassBound"/><Index>option ClassBound</Index></Mark>
<Item>
Specifies that the <M>p</M>-quotient to be computed has lower exponent-<M>p</M>
class at most <A>n</A>. If this option is omitted a default of 63 (which is
the maximum possible for the <C>pq</C> program) is taken, except for
<C>PqDescendants</C> (see&nbsp;<Ref Func="PqDescendants" Style="Text"/>) and in a special case of <C>PqPCover</C>
(see&nbsp;<Ref Func="PqPCover" Style="Text"/>). Let <A>F</A> be the argument (or start group of the process
in the interactive case) for the function; then for <C>PqDescendants</C> the
default is <C>PClassPGroup(<A>F</A>) + 1</C>, and for the special case of
<C>PqPCover</C> the default is <C>PClassPGroup(<A>F</A>)</C>.
</Item>

<Mark><C>pQuotient := <A>Q</A></C>
<Label Name="option pQuotient"/><Index>option pQuotient</Index></Mark>
<Item>
This option is only available for the standard presentation functions. It
specifies that a <M>p</M>-quotient of the group argument of the function or
group of the process is the pc <A>p</A>-group <A>Q</A>, where <A>Q</A> is of class
<E>less than</E> the provided (or default) value of <C>ClassBound</C>. If
<C>pQuotient</C> is provided, then the option <C>Prime</C> if also provided, is
ignored; the prime <A>p</A> is discovered by computing <C>PrimePGroup(<A>Q</A>)</C>.
</Item>

<Mark><C>Exponent := <A>n</A></C>
<Label Name="option Exponent"/><Index>option Exponent</Index></Mark>
<Item>
Specifies that the <M>p</M>-quotient to be computed has exponent <A>n</A>. For an
interactive process, <C>Exponent</C> defaults to a previously supplied value
for the process. Otherwise (and non-interactively), the default is 0,
which means that no exponent law is enforced.
</Item>

<Mark><C>Relators := <A>rels</A></C>
<Label Name="option Relators"/><Index>option Relators</Index></Mark>
<Item>
Specifies that the relators sent to the <C>pq</C> program should be <A>rels</A>
instead of the relators of the argument group <A>F</A> (or start group in the
interactive case) of the calling function; <A>rels</A> should be a list of
<E>strings</E> in the string representations of the generators of <A>F</A>, and <A>F</A>
must be an <E>fp group</E> (even if the calling function accepts a pc group).
This option provides a way of giving relators to the <C>pq</C> program,
without having them pre-expanded by &GAP;, which can sometimes effect a
performance loss of the order of 100 (see Section&nbsp;<Ref Sect="The Relators Option" Style="Text"/>).
<P/>

<E>Notes</E>
<Enum>
    <Item>
    The <C>pq</C> program does not use <C>/</C> to indicate multiplication by an
    inverse and uses square brackets to represent (left normed) commutators.
    Also, even though the <C>pq</C> program accepts relations, all elements of
    <A>rels</A> <E>must</E> be in relator form, i.e.&nbsp;a relation of form <C><A>w1</A> = <A>w2</A></C>
    must be written as <C><A>w1</A>*(<A>w2</A>)^-1</C> and then put in a pair of
    double-quotes to make it a string. See the example below.
    </Item>
    <Item>
    To ensure there are no syntax errors in <A>rels</A>, each relator is parsed
    for validity via <C>PqParseWord</C> (see&nbsp;<Ref Func="PqParseWord" Style="Text"/>). If they are ok, a
    message to say so is <C>Info</C>-ed at <C>InfoANUPQ</C> level 2.
    </Item>
</Enum>
</Item>

<Mark><C>Metabelian</C>
<Label Name="option Metabelian"/><Index>option Metabelian</Index></Mark>
<Item>
Specifies that the largest metabelian <M>p</M>-quotient subject to any other
conditions specified by other options be constructed. By default this
restriction is not enforced.
</Item>

<Mark><C>GroupName := <A>name</A></C>
<Label Name="option GroupName"/><Index>option GroupName</Index></Mark>
<Item>
Specifies that the <C>pq</C> program should refer to the group by the name
<A>name</A> (a string). If <C>GroupName</C> is not set and the group has been
assigned a name via <C>SetName</C> (see&nbsp;<Ref BookName="ref" Label="SetName" Style="Text"/>) it is set as the name
the <C>pq</C> program should use. Otherwise, the <Q>generic</Q> name <C>"[grp]"</C>
is set as a default.
</Item>

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

<E>Notes</E>
<Enum>
    <Item>
    Setting the <C>InfoANUPQ</C> level to 3 or more when setting the <C>Identities</C>
    option may slow down the computation considerably, by overloading &GAP;
    with io operations.
    </Item>
    <Item>
    The <C>Identities</C> option is implemented at the &GAP; level. An identity
    that is just an exponent law should be specified using the <C>Exponent</C>
    option (see&nbsp;<Ref InfoClass="option Exponent" Style="Text"/>), which is implemented at the C level and
    is highly optimised and so is much more efficient.
    </Item>
    <Item>
    The number of instances of each identity tends to grow
    combinatorially with the class. So <E>care</E> should be exercised in using
    the <C>Identities</C> option, by including other restrictions, e.g.&nbsp;by
    using the <C>ClassBound</C> option (see&nbsp;<Ref InfoClass="option ClassBound" Style="Text"/>).
    </Item>
</Enum>
</Item>


<Mark><C>OutputLevel := <A>n</A></C>
<Label Name="option OutputLevel"/><Index>option OutputLevel</Index></Mark>
<Item>
Specifies the level of <Q>verbosity</Q> of the information output by the ANU
<C>pq</C> program when computing a pc presentation; <A>n</A> must be an integer in
the range 0 to 3. <C>OutputLevel := 0</C> displays at most one line of output
and is the default; <C>OutputLevel := 1</C> displays (usually) slightly more
output and <C>OutputLevel</C>s of 2 and 3 are two levels of verbose output. To
see these messages from the <C>pq</C> program, the <C>InfoANUPQ</C> level must be
set to at least 1 (see&nbsp;<Ref Func="InfoANUPQ" Style="Text"/>). See
Section&nbsp;<Ref Sect="Hints and Warnings regarding the use of Options" Style="Text"/>
for an example of how <C>OutputLevel</C> can be used as a troubleshooting tool.
</Item>

<Mark><C>RedoPcp</C>
<Label Name="option RedoPcp"/><Index>option RedoPcp</Index></Mark>
<Item>
Specifies that the current pc presentation (for an interactive process)
stored by the <C>pq</C> program be scrapped and clears the current values
stored for the options <C>Prime</C>, <C>ClassBound</C>, <C>Exponent</C> and <C>Metabelian</C>
and also clears the <C>pQuotient</C>, <C>pQepi</C> and <C>pCover</C> fields of the data
record of the process.
</Item>

<Mark><C>SetupFile := <A>filename</A></C>
<Label Name="option SetupFile"/><Index>option SetupFile</Index></Mark>
<Item>
Non-interactively, this option directs that <C>pq</C> should not be called and
that an input file with name <A>filename</A> (a string), containing the
commands necessary for the ANU <C>pq</C> standalone, be constructed. The
commands written to <A>filename</A> are also <C>Info</C>-ed behind a <Q><C>ToPQ> </C></Q>
prompt at <C>InfoANUPQ</C> level 4 (see&nbsp;<Ref Func="InfoANUPQ" Style="Text"/>). Except in the case
following, the calling function returns <K>true</K>. If the calling function
is the non-interactive version of one of <C>Pq</C>, <C>PqPCover</C> or
<C>PqEpimorphism</C> and the group provided as argument is trivial given with
an empty set of generators, then no setup file is written and <K>fail</K> is
returned (the <C>pq</C> program cannot do anything useful with such a group).
Interactively, <C>SetupFile</C> is ignored.
<P/>

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

<Mark><C>PqWorkspace := <A>workspace</A></C>
<Label Name="option PqWorkspace"/><Index>option PqWorkspace</Index></Mark>
<Item>
Non-interactively, this option sets the memory used by the <C>pq</C> program.
It sets the maximum number of integer-sized elements to allocate in its
main storage array. By default, the <C>pq</C> program sets this figure to
10000000. Interactively, <C>PqWorkspace</C> is ignored; the memory used in
this case may be set by giving <C>PqStart</C> a second argument
(see&nbsp;<Ref Func="PqStart" Style="Text"/>).
</Item>

<Mark><C>PcgsAutomorphisms</C>
<Label Name="option PcgsAutomorphisms"/><Index>option PcgsAutomorphisms</Index></Mark>
<Item></Item>

<Mark><C>PcgsAutomorphisms := false</C>
<!--<Label Name="option PcgsAutomorphisms"/><Index>option PcgsAutomorphisms</Index>-->
</Mark>
<Item>
Let <A>G</A> be the group associated with the calling function (or associated
interactive process). Passing the option <C>PcgsAutomorphisms</C> without a
value (or equivalently setting it to <K>true</K>), specifies that a polycyclic
generating sequence for the automorphism group (which must be <E>soluble</E>)
of <A>G</A>, be computed and passed to the <C>pq</C> program. This increases the
efficiency of the computation; it also prevents the <C>pq</C> from calling
&GAP; for orbit-stabilizer calculations. By default, <C>PcgsAutomorphisms</C>
is set to the value returned by <C>IsSolvable( AutomorphismGroup( <A>G</A> ) )</C>,
and uses the package &AutPGrp; to compute <C>AutomorphismGroup( <A>G</A> )</C> if
it is installed. This flag is set to <K>true</K> or <K>false</K> in the background
according to the above criterion by the function <C>PqDescendants</C>
(see&nbsp;<Ref Func="PqDescendants" Style="Text"/> and&nbsp;<Ref Func="PqDescendants" Label="interactive" Style="Text"/>).
<P/>

<E>Note:</E>
If <C>PcgsAutomorphisms</C> is used when the automorphism group of <A>G</A> is
insoluble, an error message occurs.
</Item>

<Mark><C>OrderBound := <A>n</A></C>
<Label Name="option OrderBound"/><Index>option OrderBound</Index></Mark>
<Item>
Specifies that only descendants of size at most <M>p^<A>n</A></M>, where <A>n</A> is a
non-negative integer, be generated. Note that you cannot set both
<C>OrderBound</C> and <C>StepSize</C>.
</Item>

<Mark><C>StepSize := <A>n</A></C>
<Label Name="option StepSize"/><Index>option StepSize</Index></Mark>
<Item></Item>

<Mark><C>StepSize := <A>list</A></C>
<!--<Label Name="option StepSize"/><Index>option StepSize</Index>-->
</Mark>
<Item>
For a positive integer <A>n</A>, <C>StepSize</C> specifies that only those
immediate descendants which are a factor <M>p^<A>n</A></M> bigger than their parent
group be generated.
<P/>

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

<Mark><C>RankInitialSegmentSubgroups := <A>n</A></C>
<Label Name="option RankInitialSegmentSubgroups"/><Index>option RankInitialSegmentSubgroups</Index></Mark>
<Item>
Sets the rank of the initial segment subgroup chosen to be <A>n</A>. By
default, this has value 0.
</Item>

<Mark><C>SpaceEfficient</C>
<Label Name="option SpaceEfficient"/><Index>option SpaceEfficient</Index></Mark>
<Item>
Specifies that the <C>pq</C> program performs certain calculations of <M>p</M>-group
generation more slowly but with greater space efficiency. This flag is
frequently necessary for groups of large Frattini quotient rank. The
space saving occurs because only one permutation is stored at any one
time. This option is only available if the <C>PcgsAutomorphisms</C> flag is
set to <K>true</K> (see&nbsp;<Ref InfoClass="option PcgsAutomorphisms" Style="Text"/>). For an interactive
process, <C>SpaceEfficient</C> defaults to a previously supplied value for the
process. Otherwise (and non-interactively), <C>SpaceEfficient</C> is by
default <K>false</K>.
</Item>

<Mark><C>CapableDescendants</C>
<Label Name="option CapableDescendants"/><Index>option CapableDescendants</Index></Mark>
<Item>
By default, <E>all</E> (i.e.&nbsp;capable and terminal) descendants are computed.
If this flag is set, only capable descendants are computed. Setting this
option is equivalent to setting <C>AllDescendants := false</C> (see&nbsp;<Ref InfoClass="option AllDescendants" Style="Text"/>), except if both <C>CapableDescendants</C> and
<C>AllDescendants</C> are passed, <C>AllDescendants</C> is essentially ignored.
</Item>

<Mark><C>AllDescendants := false</C>
<Label Name="option AllDescendants"/><Index>option AllDescendants</Index></Mark>
<Item>
By default, <E>all</E> descendants are constructed. If this flag is set to
<K>false</K>, only capable descendants are computed. Passing <C>AllDescendants</C>
without a value (which is equivalent to setting it to <K>true</K>) is
superfluous. This option is provided only for backward compatibility with
the &GAP; 3 version of the &ANUPQ; package, where by default
<C>AllDescendants</C> was set to <K>false</K> (rather than <K>true</K>). It is
preferable to use <C>CapableDescendants</C> (see&nbsp;<Ref InfoClass="option CapableDescendants" Style="Text"/>).
</Item>

<Mark><C>TreeDepth := <A>class</A></C>
<Label Name="option TreeDepth"/><Index>option TreeDepth</Index></Mark>
<Item>
Specifies that the descendants tree developed by
<C>PqDescendantsTreeCoclassOne</C> (see&nbsp;<Ref Func="PqDescendantsTreeCoclassOne" Style="Text"/>) should
be extended to class <A>class</A>, where <A>class</A> is a positive integer.
</Item>

<Mark><C>SubList := <A>sub</A></C>
<Label Name="option SubList"/><Index>option SubList</Index></Mark>
<Item>
Suppose that <A>L</A> is the list of descendants generated, then for a list
<A>sub</A> of integers this option causes <C>PqDescendants</C> to return <C>Sublist(
<A>L</A>, <A>sub</A> )</C>. If an integer <A>n</A> is supplied, <C>PqDescendants</C> returns
<C><A>L</A>[<A>n</A>]</C>.
</Item>

<Mark><C>NumberOfSolubleAutomorphisms := <A>n</A></C>
<Label Name="option NumberOfSolubleAutomorphisms"/><Index>option NumberOfSolubleAutomorphisms</Index></Mark>
<Item>
Specifies that the number of soluble automorphisms of the automorphism
group supplied by <C>PqPGSupplyAutomorphisms</C>
(see&nbsp;<Ref Func="PqPGSupplyAutomorphisms" Style="Text"/>) in a <M>p</M>-group generation calculation is
<A>n</A>. By default, <A>n</A> is taken to be <M>0</M>; <A>n</A> must be a non-negative
integer. If <M><A>n</A> \ge 0</M> then a value for the option <C>RelativeOrders</C>
(see&nbsp;<Ref Label="option RelativeOrders" Style="Text"/>) must also be supplied.
</Item>

<Mark><C>RelativeOrders := <A>list</A></C>
<Label Name="option RelativeOrders"/><Index>option RelativeOrders</Index></Mark>
<Item>
Specifies the relative orders of each soluble automorphism of the
automorphism group supplied by <C>PqPGSupplyAutomorphisms</C>
(see&nbsp;<Ref Func="PqPGSupplyAutomorphisms" Style="Text"/>) in a <M>p</M>-group generation calculation.
The list <A>list</A> must consist of <A>n</A> positive integers, where <A>n</A> is the
value of the option <C>NumberOfSolubleAutomorphisms</C> (see&nbsp;<Ref Label="option NumberOfSolubleAutomorphisms" Style="Text"/>). By default <A>list</A> is empty.
</Item>

<Mark><C>BasicAlgorithm</C>
<Label Name="option BasicAlgorithm"/><Index>option BasicAlgorithm</Index></Mark>
<Item>
Specifies that an algorithm that the <C>pq</C> program calls its <Q>default</Q>
algorithm be used for <M>p</M>-group generation. By default this algorithm is
<E>not</E> used. If this option is supplied the settings of options
<C>RankInitialSegmentSubgroups</C>, <C>AllDescendants</C>, <C>Exponent</C> and
<C>Metabelian</C> are ignored.
</Item>

<Mark><C>CustomiseOutput := <A>rec</A></C>
<Label Name="option CustomiseOutput"/><Index>option CustomiseOutput</Index></Mark>
<Item>
Specifies that fine tuning of the output is desired. The record <A>rec</A>
should have any subset (or all) of the the following fields:
<List>
    <Mark><C>perm := <A>list</A></C></Mark>
    <Item>
    where <A>list</A> is a list of booleans which determine whether the
    permutation group output for the automorphism group should contain: the
    degree, the extended automorphisms, the automorphism matrices, and the
    permutations, respectively.
    </Item>
    <Mark><C>orbit := <A>list</A></C></Mark>
    <Item>
    where <A>list</A> is a list of booleans which determine whether the orbit
    output of the action of the automorphism group should contain: a summary,
    and a complete listing of orbits, respectively. (It's possible to have
    <E>both</E> a summary and a complete listing.)
    </Item>
    <Mark><C>group := <A>list</A></C></Mark>
    <Item>
    where <A>list</A> is a list of booleans which determine whether the group
    output should contain: the standard matrix of each allowable subgroup,
    the presentation of reduced <M>p</M>-covering groups, the presentation of
    immediate descendants, the nuclear rank of descendants, and the
    <M>p</M>-multiplicator rank of descendants, respectively.
    </Item>
    <Mark><C>autgroup := <A>list</A></C></Mark>
    <Item>
    where <A>list</A> is a list of booleans which determine whether the
    automorphism group output should contain: the commutator matrix, the
    automorphism group description of descendants, and the automorphism group
    order of descendants, respectively.
    </Item>
    <Mark><C>trace := <A>val</A></C></Mark>
    <Item>
    where <A>val</A> is a boolean which if <K>true</K> specifies algorithm trace data
    is desired. By default, one does not get algorithm trace data.
    </Item>
</List>

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

<Log><![CDATA[
CustomiseOutput := rec(group := [,,1], autgroup := [,1])
]]></Log>

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

<Mark><C>StandardPresentationFile := <A>filename</A></C>
<Label Name="option StandardPresentationFile"/><Index>option StandardPresentationFile</Index></Mark>
<Item>
Specifies that the file to which the standard presentation is written has
name <A>filename</A>. If the first character of the string <A>filename</A> is not
<C>/</C>, <A>filename</A> is assumed to be the path of a writable file relative to
the directory in which &GAP; was started. If this option is omitted it
is written to the file with the name generated by the command <C>Filename(
ANUPQData.tmpdir, "SPres" );</C>, i.e.&nbsp;the file with name <C>"SPres"</C> in the
temporary directory in which the <C>pq</C> program executes.
</Item>

<Mark><C>QueueFactor := <A>n</A></C>
<Label Name="option QueueFactor"/><Index>option QueueFactor</Index></Mark>
<Item>
Specifies a queue factor of <A>n</A>, where <A>n</A> must be a positive integer.
This option may be used with <C>PqNextClass</C> (see&nbsp;<Ref Func="PqNextClass" Style="Text"/>).
<P/>

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

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

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

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

<Mark><C>Bounds := <A>list</A></C>
<Label Name="option Bounds"/><Index>option Bounds</Index></Mark>
<Item>
Specifies a lower and upper bound on the indices of a list, where <A>list</A>
is a pair of positive non-decreasing integers. See&nbsp;<Ref Func="PqDisplayStructure" Style="Text"/>
and&nbsp;<Ref Func="PqDisplayAutomorphisms" Style="Text"/> where this option may be used.
</Item>

<Mark><C>PrintAutomorphisms := <A>list</A></C>
<Label Name="option PrintAutomorphisms"/><Index>option PrintAutomorphisms</Index></Mark>
<Item>
Specifies that automorphism matrices be printed.
</Item>

<Mark><C>PrintPermutations := <A>list</A></C>
<Label Name="option PrintPermutations"/><Index>option PrintPermutations</Index></Mark>
<Item>
Specifies that permutations of the subgroups be printed.
</Item>

<Mark><C>Filename := <A>string</A></C>
<Label Name="option Filename"/><Index>option Filename</Index></Mark>
<Item>
Specifies that an output or input file to be written to or read from by
the <C>pq</C> program should have the name <A>string</A>.
</Item>
</List>

</Section>
</Chapter>

