Example GrpPC_Standard (H70E1)

> G := CyclicGroup(GrpPC, 12);

> Order(G);
12
> IsAbelian(G);
true
> IsSimple(G);
false

> G;
GrpPC : G of order 12 = 2^2 * 3
PC-Relations:
    G.1^2 = G.2,
    G.2^2 = G.3,
    G.3^3 = Id(G)

> H := AbelianGroup(GrpPC, [2,2,3]);
> Order(H);
12
> IsCyclic(H);
false

Definition by Presentation

While the standard construction functions are convenient, most groups cannot be defined in that way. Complete flexibility in defining a soluble group can be obtained by directly specifying the group's pc-presentation.

One uses a power-conjugate presentation to define a soluble group by means of the PolycyclicGroup constructor, or the quo constructor for finitely presented groups.

PolycyclicGroup< x₁, ..., x_n | R : parameters > : List(Identifiers), List(GrpFPRel) -> GrpPC, Map

    Check: BoolElt                      Default: true

    ExponentLimit: RngIntElt            Default: 20

    Class: MonStgElt                    Default: 

Construct the soluble group G defined by the power-conjugate presentation < x₁, ..., x_n | R >.

The construct x₁, ..., x_n defines names for the generators of G that are local to the constructor, i.e. they are used when writing down the relations to the right of the bar. However, no assignment of values to these variables is made. If the user wants to refer to the generators by these (or other) names, then the generators assignment construct must be used on the left hand side of an assignment statement.

The construct R denotes a list of pc-relations. Thus, an element of R must be one of:

(a)

A power relation a_j^p_j = w_jj, 1 ≤j ≤n, where w_jj is 1 or a word in generators a_{j + 1}, ..., a_n for j < n, and w_jj = 1 for j = n, and p_j a prime.

(b)

A conjugate relation a_j^a_i = w_ij, 1 ≤i < j ≤n, where w_ij is a word in the generators a_{i + 1}, ..., a_n.

(c)

A power a_j^p_j, 1 ≤j ≤n and p_j a prime, which is treated as the power relation a_j^p_j = Id(F).

(d)

A set of (a) -- (c).

(e)

A sequence of (a) -- (c).

Note the following points:

(i)

A power relation must be present for each generator a_i, i = 1, ..., n;

(ii)

Conjugate relations involving commuting generators (i.e. of the form y^x=y) may be omitted;

(iii)

The words w_ij must be in normal form.

In addition, one can alternatively specify a power-commutator presentation using commutator relations rather than conjugate relations.

(b')

A commutator relation (a_j, a_i) = w_ij, 1 ≤i < j ≤n, where w_ij is a word in the generators a_{i + 1}, ..., a_n.

However, commutators and conjugates cannot be mixed in a single presentation.

A map f from the free group of rank n to G is returned as well.

The parameters Check and ExponentLimit may be used. Check indicates whether or not the presentation is checked for consistency. Setting Check to false will reduce the overheads incurred in constructing the group, but should only be done when the user is sure the given presentation is consistent.

ExponentLimit determines the amount of space that will be used by the group to speed calculations. Given ExponentLimit := e, the group will precompute and store normal words for appropriate products aⁱ * b^j where a and b are generators and i and j are in the range 1 to e.

If the construction of an object in the category GrpPC fails because R is not a valid power-conjugate presentation, an attempt is made to construct a group in the category GrpGPC. This feature can be turned off by setting the parameter Class to "GrpPC"; an invalid power-conjugate presentation then causes a runtime error. Since, by default, the constructor always returns a group in the category GrpPC if possible, this is the only effect of setting the parameter Class to "GrpPC".

quo< GrpPC : F | R : parameters > : GrpFP, List(GrpFPRel) -> GrpPC, Map

    Check: BoolElt                      Default: true

    ExponentLimit: RngIntElt            Default: 20

Given a free group F of rank n with generating set X, and a collection R of pc-relations on X, construct the soluble group G defined by the power-conjugate presentation < X | R >.

The construct R denotes a list of pc-relations. The syntax and semantics for the relations clause is identical to that appearing in the PolycyclicGroup-construct.

This constructor returns a pc-group because the category GrpPC is stated. If no category were stated, it would return an fp-group.

The parameters Check and ExponentLimit may be used as described in the PolycyclicGroup-construct.

The natural homomorphism, F -> G, is also returned.

\  < a, b, c, d, e | a^2 = c, b^2, c^2 = e, d^5, e^2, b^a = b*e, c^a = c, c^b = c,
\       d^a = d^2, d^b = d, d^c = d^4, e^a = e, e^b = e, e^c = e, e^d = e >.

> G<a,b,c,d,e> := PolycyclicGroup<a, b, c, d, e |
>              a^2 = c, b^2, c^2 = e, d^5, e^2,
>              b^a = b*e, d^a = d^2, d^c = d^4 >;

> F<a,b,c,d,e> := FreeGroup(5);
> rels := { a^2 = c, b^2 = Id(F), c^2 = e, d^5 = Id(F), e^2 = Id(F),
>      b^a = b*e, d^a = d^2, d^c = d^4 };
> G<a,b,c,d,e> := quo< GrpPC : F | rels >;

> G;
GrpPC : G of order 80 = 2^4 * 5
PC-Relations:
    a^2 = c,
    b^2 = Id(G),
    c^2 = e,
    d^5 = Id(G),
    e^2 = Id(G),
    b^a = b * e,
    d^a = d^2,
    d^c = d^4
> Order(G);
80
> IsAbelian(G);
false

> F := FreeGroup(2);
> for p in [n: n in [3..10] | IsPrime(n)] do
>   r := [F.1^3=Id(F), F.2^p=Id(F), F.2^F.1=F.2^2];
>   G := quo<GrpPC: F | r: Check:=false>;
>   if IsConsistent(G) then
>     print "For p=",p," the group is consistent.";
>   else
>     print "For p=",p," the group is inconsistent.";
>   end if;
> end for;
For p= 3  the group is inconsistent.
For p= 5  the group is inconsistent.
For p= 7  the group is consistent.