[Next][Prev] [Right] [Left] [Up] [Index] [Root]

Abelian, Nilpotent and Soluble Quotient

Subsections

Abelian Quotient

The functions in this section compute information about the abelian quotient of an fp-group G. Some functions may require the computation of a coset table. Experienced users can control the behaviour of an implicit coset enumeration with a set of global parameters. These global parameters can be changed using the function SetGlobalTCParameters. For a detailed description of the available parameters and their meanings, we refer to Chapter FINITELY PRESENTED GROUPS: ADVANCED.

The functions returning the abelian quotient or the abelian quotient invariants report an error if the abelian quotient cannot be computed, for example, because the relation matrix is too large. To avoid problems in user written programs or loops, the functions HasComputableAbelianQuotient and HasInfiniteComputableAbelianQuotient can be used.

AbelianQuotient(G) : GrpFP -> GrpAb, Map
The maximal abelian quotient G/Gprime of the group G as GrpAb (cf. Chapter ABELIAN GROUPS). The natural epimorphism π:G -> G/Gprime is returned as second value.
ElementaryAbelianQuotient(G, p) : GrpFP, RngIntElt -> GrpAb, Map
The maximal p-elementary abelian quotient Q of the group G as GrpAb (cf. Chapter ABELIAN GROUPS). The natural epimorphism π:G -> Q is returned as second value.
AbelianQuotientInvariants(G) : GrpFP -> [ RngIntElt ]
AQInvariants(G) : GrpFP -> [ RngIntElt ]
Given a finitely presented group G, this function computes the elementary divisors of the derived quotient group G/G', by constructing the relation matrix for G and transforming it into Smith normal form. The algorithm used is an algorithm of Havas which does the reduction entirely over the ring of integers Z using clever heuristics to minimize the growth of coefficients.

The divisors are returned as a sequence of integers.

AbelianQuotientInvariants(H) : GrpFP -> [ RngIntElt ]
AQInvariants(H) : GrpFP -> [ RngIntElt ]
AbelianQuotientInvariants(G, T) : GrpFP, Map -> [ RngIntElt ]
AQInvariants(G, T) : GrpFP, Map -> [ RngIntElt ]
Given a subgroup H of the finitely presented group G, this function computes the elementary divisors of the derived quotient group of H. (The coset table T may be used to define H.) This is done by abelianising the Reidemeister-Schreier presentation for H and then proceeding as above. The divisors are returned as a sequence of integers.
AbelianQuotientInvariants(G, n) : GrpFP, RngIntElt -> [ RngIntElt ]
AQInvariants(G, n) : GrpFP, RngIntElt -> [ RngIntElt ]
Given a finitely presented group G, this function computes the elementary divisors of the quotient group G/N, where N is the normal subgroup of G generated by the derived group G' together with all n-th powers of elements of G. The algorithm constructs the relation matrix corresponding to the presentation of G and computes its Smith normal form over the ring Z/nZ. The calculation is particularly efficient when n is a small prime. The divisors are returned as a sequence of integers.
AbelianQuotientInvariants(H, n) : GrpFP, RngIntElt -> [ RngIntElt ]
AQInvariants(H, n) : GrpFP, RngIntElt -> [ RngIntElt ]
AbelianQuotientInvariants(G, T, n) : GrpFP, Map, RngIntElt -> [ RngIntElt ]
AQInvariants(G, T, n) : GrpFP, Map, RngIntElt -> [ RngIntElt ]
Given a subgroup H of the finitely presented group G, this function computes the elementary divisors of the quotient group H/N, where N is the normal subgroup of H generated by H' together with all n-th powers of elements of H. (The coset table T may be used to define H.) This is done by abelianising the Reidemeister-Schreier presentation for H and then proceeding as above. The divisors are returned as a sequence of integers.
HasComputableAbelianQuotient(G) : GrpFP -> BoolElt, GrpAb, Map
Given an fp-group G, this function tests whether the abelian quotient of G can be computed. If so, it returns the value true, the abelian quotient A of G and the natural epimorphism π:G -> A. If the abelian quotient of G cannot be computed, the value false is returned.

This function is especially useful to avoid runtime errors in user written loops or functions.

HasInfiniteComputableAbelianQuotient(G) : GrpFP -> BoolElt, GrpAb, Map
Given an fp-group G, this function tests whether the abelian quotient of G can be computed and is infinite. If so, it returns the value true, the abelian quotient A of G and the natural epimorphism π:G -> A. If the abelian quotient of G cannot be computed or if it is finite, the value false is returned.

The function first checks the modular abelian invariants for a set of small primes. If for one of these primes, the modular abelian quotient is trivial, A must be finite and the function returns without actually computing the abelian quotient. If one is interested only in infinite quotients, this heuristics may save time.

IsPerfect(G) : GrpFP -> BoolElt
Given an fp-group G, this function tries to decide whether G is perfect by checking whether the abelian quotient of G is trivial.
TorsionFreeRank(G) : GrpFP -> RngIntElt
Given the finitely presented group G, return the torsion-free rank of the derived quotient group of G.

Example GrpFP_1_F27 (H70E29)

The Fibonacci group F(7) has the following 2-generator presentation: <a, b | a2b - 2a - 1b - 2(a - 1b - 1)2, abab2abab - 1(ab2)2>. We proceed to investigate the structure of this group.

> F<a, b> := FreeGroup(2);
> F7<a, b> := quo< F |  a^2*b^-2*a^-1*b^-2*(a^-1*b^-1)^2,
>        a*b*a*b^2*a*b*a*b^-1*(a*b^2)^2 >;
> F7;
Finitely presented group F7 on 2 generators
Relations
       a^2 * b^-2 * a^-1 * b^-2 * a^-1 * b^-1 * a^-1 * b^-1 =Id(F7)
       a * b * a * b^2 * a * b * a * b^-1 * a * b^2 * a * b^2 = Id()7
We begin by determining the structure of the maximal abelian quotient of F(7).

> AbelianQuotientInvariants(F7);
[ 29 ]
The maximal abelian quotient of F(7) is cyclic of order 29. At this point there is no obvious way to proceed, so we attempt to determine the index of some subgroups.

> Index( F7, sub< F7 | a > );
1
We are in luck: F(7) is generated by a and so must be cyclic. This fact coupled with the knowledge that its abelian quotient has order 29 tells us that the group is cyclic of order 29.

Example GrpFP_1_modular-abelian-quotient (H70E30)

The group G = (8, 7 | 2, 3) is defined by the presentation < a, b | a8, b7, (ab)2, (a - 1b)3 >. We consider the subgroup H of G, generated by the words a2 and a - 1b:

> G<a, b> := Group<a, b| a^8, b^7, (a * b)^2, (a^-1 * b)^3>;
> H<x, y> := sub< G | a^2, a^-1 * b >;
The fastest way to determine the order of the maximal 2-elementary abelian quotient of H is to use the function AbelianQuotientInvariants:

> #AbelianQuotientInvariants(H,2);  
1
We see that the maximal 2-elementary abelian quotient of H has order 21.

p-Quotient

Let F be a finitely presented group, p a prime and c a positive integer. A p-quotient algorithm constructs a consistent power-conjugate presentation for the largest p-quotient of F having lower exponent-p class at most c. The p-quotient algorithm used by Magma is part of the ANU p-Quotient program. For details of the algorithm, see [NO96]. In Magma the result is returned as a group of type GrpPC (cf. Chapter FINITE SOLUBLE GROUPS).

Assume that the p-quotient has order pn, Frattini rank d, and that its generators are a1, ..., an. Then the power-conjugate presentation constructed has the following additional structure. The set {a1, ..., ad} is a generating set for G. For each ak in {ad + 1, ..., an}, there is at least one relation whose right hand side is ak. One of these relations is taken as the definition of ak. (The list of definitions is also returned by pQuotient.) The power-conjugate generators also have a weight associated with them: a generator is assigned a weight corresponding to the stage at which it is added and this weight is extended to all normal words in a natural way.

The p-quotient function and its associated commands allows the user to construct a power-conjugate presentation (pcp) for a p-group. Note that there is also a process version of the p-quotient algorithm, which gives the user complete control over its execution. For a description, we refer to Chapter FINITELY PRESENTED GROUPS: ADVANCED.

The Construction of a p-Quotient

The parameters available for the function pQuotient are:

var Exponent: RngIntElt Default: 0 If Exponent := m, enforce the exponent law, xm = 1, on the group.

var Metabelian: BoolElt Default: false If Metabelian := true, then a consistent pcp is constructed for the largest metabelian p-quotient of F having lower exponent-p class at most c.

var Print: RngIntElt Default: 0 This parameter controls the volume of printing. By default its value is that returned by GetVerbose("pQuotient"), which is 0 unless it has been changed through use of SetVerbose. The effect is the following:

Print := 0: No output.

Print := 1: Report order of p-quotient at each class.

Print := 2: Report statistics and redundancy information about tails, consistency, collection of relations and exponent enforcement components of calculation.

Print := 3: Report in detail on the construction of each class.

Note that the presentation displayed is a power-commutator presentation (since this is the version stored by the p-quotient).

var Workspace: RngIntElt Default: 5000000 The amount of space requested for the p-quotient computation.

pQuotient(F, p, c: parameters) : GrpFP, RngIntElt, RngIntElt -> GrpPC, Map, SeqEnum , BoolElt
Given an fp-group F, a prime p and a positive integer c, construct a pcp for the largest p-quotient G of F having lower exponent-p class at most c. If c is given as 0, then the limit 127 is placed on the class. The function also returns the natural homomorphism πfrom F to G, a sequence S describing the definitions of the pc-generators of G and a flag indicating whether G is the maximal p-quotient of F.

The k-th element of S is a sequence of two integers, describing the definition of the k-th pc-generator G.k of G as follows.

-
If S[k] = [0, r], then G.k is defined via the image of F.r under π.

-
If S[k] = [r, 0], then G.k is defined via the power relation for G.r.

-
If S[k] = [r, s], then G.k is defined via the conjugate relation involving G.rG.s.

There exist a number of parameters for controlling the behaviour of this function, which are described below.

Example GrpFP_1_pQuotient1 (H70E31)

We construct the largest 2-quotient of class 6 for a two-generator, two-relator group.

> F<a,b> := FreeGroup(2);
> G := quo< F | (b, a, a) = 1, (a * b * a)^4 = 1 >;
> Q, fQ := pQuotient(G, 2, 6);
> Order(Q);
524288
> fQ;
Mapping from: GrpFP: G to GrpPC: Q

Example GrpFP_1_pQuotient2 (H70E32)

We construct the largest 3-quotient of class 6 for a two-generator group of exponent 9.

> F<a,b> := FreeGroup(2);
> G := quo< F | a^3 = b^3 = 1 >;
> q := pQuotient(G, 3, 6: Print := 1, Exponent := 9);
Lower exponent-3 central series for G
Group: G to lower exponent-3 central class 1 has order 3^2
Group: G to lower exponent-3 central class 2 has order 3^3
Group: G to lower exponent-3 central class 3 has order 3^5
Group: G to lower exponent-3 central class 4 has order 3^7
Group: G to lower exponent-3 central class 5 has order 3^9
Group: G to lower exponent-3 central class 6 has order 3^11

Example GrpFP_1_pQuotient3 (H70E33)

We use the metabelian parameter to construct a metabelian 5-quotient of the group < a, b | a625 = b625 = 1, (b, a, b) = 1, (b, a, a, a, a) = (b, a)5>.

> F<a, b> := FreeGroup(2);
> G := quo< F | a^625 = b^625 = 1, (b, a, b) = 1,
>           (b, a, a, a, a) = (b, a)^5 >;
> q := pQuotient(G, 5, 20: Print := 1, Metabelian := true);
Lower exponent-5 central series for G
Group: G to lower exponent-5 central class 1 has order 5^2
Group: G to lower exponent-5 central class 2 has order 5^5
Group: G to lower exponent-5 central class 3 has order 5^8
Group: G to lower exponent-5 central class 4 has order 5^11
Group: G to lower exponent-5 central class 5 has order 5^12
Group: G to lower exponent-5 central class 6 has order 5^13
Group: G to lower exponent-5 central class 7 has order 5^14
Group: G to lower exponent-5 central class 8 has order 5^15
Group: G to lower exponent-5 central class 9 has order 5^16
Group: G to lower exponent-5 central class 10 has order 5^17
Group: G to lower exponent-5 central class 11 has order 5^18
Group: G to lower exponent-5 central class 12 has order 5^19
Group: G to lower exponent-5 central class 13 has order 5^20
Group completed. Lower exponent-5 central class = 13, order = 5^20

Example GrpFP_1_pQuotient4 (H70E34)

In the final example, we construct the largest finite 2-generator group having exponent 5.

> F := FreeGroup(2);
> q := pQuotient (F, 5, 14: Print := 1, Exponent := 5);
Lower exponent-5 central series for F
Group: F to lower exponent-5 central class 1 has order 5^2
Group: F to lower exponent-5 central class 2 has order 5^3
Group: F to lower exponent-5 central class 3 has order 5^5
Group: F to lower exponent-5 central class 4 has order 5^8
Group: F to lower exponent-5 central class 5 has order 5^10
Group: F to lower exponent-5 central class 6 has order 5^14
Group: F to lower exponent-5 central class 7 has order 5^18
Group: F to lower exponent-5 central class 8 has order 5^22
Group: F to lower exponent-5 central class 9 has order 5^28
Group: F to lower exponent-5 central class 10 has order 5^31
Group: F to lower exponent-5 central class 11 has order 5^33
Group: F to lower exponent-5 central class 12 has order 5^34
Group completed. Lower exponent-5 central class = 12, order = 5^34

Nilpotent Quotient

A nilpotent quotient algorithm constructs, from a finite presentation of a group, a polycyclic presentation of a nilpotent quotient of the finitely presented group. The nilpotent quotient algorithm used by Magma is the Australian National University Nilpotent Quotient program, as described in [Nic96]. The version included in Magma is Version 2.2 of January 2007.

The lower central series G0, G1, ... of a group G can be defined inductively as G0 = G, Gi = [G_(i - 1), G]. G is said to have nilpotency class c if c is the smallest non-zero integer such that Gc = 1. If N is a normal subgroup of G and G/N is nilpotent, then N contains Gi for some non-negative integer i. G has infinite nilpotent quotients if and only if G/G1 (the maximal abelian quotient of G) is infinite and a prime p divides a finite factor of a nilpotent quotient if and only if p divides a cyclic factor of G/G1. The i-th (i > 1) factor Gi - 1/Gi of the lower central series is generated by the elements [g, h]Gi, where g runs through a set of representatives of G/G1 and h runs through a set of representatives of Gi - 2/Gi - 1.

Any finitely generated nilpotent group is polycyclic and, therefore, has a subnormal series with cyclic factors. Such a subnormal series can be used to represent the group in terms of a polycyclic presentation. The ANU NQ computes successively the factor groups modulo the terms of the lower central series. Each factor group is represented by a special form of polycyclic presentation, a nilpotent presentation, that makes use of the nilpotent structure of the factor group.

The algorithm has highly efficient code for enforcing the n-Engel identity in nilpotent groups. When appropriate parameters are set, the algorithm computes the largest n-Engel quotient of G/Gc.

More generally, the algorithm has code for enforcing arbitrary identical relations. You can even enforce relations which combine generators of G with "free variables". (Werner Nickel calls these "identical generators".) For instance, the relation (a,x) = 1, where a is a group generator and x is a free variable, will force the construction of quotients where the image of a is central.

Mike Vaughan-Lee offers advice on when to use the nilpotent quotient algorithm. If you know nothing about the finitely presented group, it is probably a good idea to look at the abelian quotient first. If the abelian quotient is trivial then all nilpotent quotients will be trivial. Similarly, if the abelian quotient is cyclic, then all nilpotent quotients will be cyclic. Less trivially, if the abelian quotient is finite then all nilpotent quotients will be finite and so will be the direct product of finite p-groups. Moreover, the relevant primes p will all occur in the abelian quotient. Usually it will be more effective to use the p-quotient algorithm to study the direct factors. However, if you want to study 3-Engel quotients (say), then you are better using the nilpotent quotient even when the abelian quotient is finite.

The parameters available for the function NilpotentQuotient are:

var NumberOfEngelGenerators: RngIntElt Default: 1 Setting this parameter to k forces the first k generators to be left or right Engel elements, provided one (or both) of the parameters LeftEngel or RightEngel is positive. Otherwise it is ignored.

var LeftEngel: RngIntElt Default: 0

Setting this parameter to n forces the first k generators g1, ..., gk of the quotient Q to be left n-Engel elements. That is, they satisfy [x, ..., x, gi] = 1 (x appearing n times) for all x in Q. The value of k is determined by the parameter NumberOfEngelGenerators.

var RightEngel: RngIntElt Default: 0

This is the same as for LeftEngel, but here the generators are right n-Engel elements, so [gi, x, ..., x] = 1.

var Engel: RngIntElt Default: 0

Setting this parameter to n enforces the nth Engel law on the quotient Q. That is, [x, y, ..., y]=1 (y appearing n times) for all x, y in Q.

var SemigroupOnly: BoolElt Default: true

This option causes the program to check only semigroup words in the generating set of the nilpotent quotient when an Engel condition is enforced. If none of the Engel parameters are set, then it is ignored.

var SemigroupFirst: BoolElt Default: false

This option causes the program to check semigroup words in the generating set of the quotient first and then all other words, when an Engel condition is enforced. If SemigroupOnly is set, or no Engel condition is enforced, then it is ignored.

var ReverseOrder: BoolElt Default: false

In checking Engel identities, instances are processed in order of increasing weight. This flag reverses the order.

var ReverseEngel: BoolElt Default: false

This flag changes the Engel conditions from the first k generators, to the last k generators.

var CheckFewInstances: BoolElt Default: false

This option stops checking the Engel law at each class if all the checks of a certain weight did not yield any non-trivial instances of the law.

var Nickel: BoolElt Default: false

Enforce the identities x8 and [[x1, x2, x3], [x4, x5, x6]] on the nilpotent quotient.

var NumberOfFreeVariables: RngIntElt Default: 0

If this parameter is set to n > 0 then the last n variables of the group are treated as variables rather than generators of the group. In any relation they are treated as standing for all group elements, enabling the user to enforce identical relations on the quotient being computed. The value of n must be less than the number of generators of the input group. When this facility is used, the domain of the epimorphism returned is the subgroup of G generated by the (first) non-free generators.

var PrintResult: BoolElt Default: false

If set to true, this parameter switches on the printing of results given by the stand alone version of NQ.

NilpotentQuotient(G, c: parameters) : GrpFP, RngIntElt -> GrpGPC, Map
This function returns the class c nilpotent quotient of G as a group in category GrpGPC, together with the epimorphism πfrom G onto this quotient. When c is set to zero, the function attempts to compute the maximal nilpotent quotient of G. Using the parameters described below, the user can enforce certain conditions on the quotient found.

Example GrpFP_1_NilpotentQuotient0 (H70E35)

Here is a finitely presented group. The abelian quotient is infinite, so we look at the class 2 nilpotent quotient.

> G := Group<x,y,z|(x*y*z^-1)^2, (x^-1*y^2*z)^2, (x*y^-2*x^-1)^2 >;
> AbelianQuotient(G);
Abelian Group isomorphic to Z/2 + Z/2 + Z
Defined on 3 generators
Relations:
  2*$.1 = 0
  2*$.2 = 0
> N := NilpotentQuotient(G,2); N;
GrpGPC : N of infinite order on 6 PC-generators
PC-Relations:
  N.1^2 = N.3^2 * N.5,
  N.2^2 = N.4 * N.6,
  N.4^2 = Id(N),
  N.5^2 = Id(N),
  N.6^2 = Id(N),
  N.2^N.1 = N.2 * N.4,
  N.3^N.1 = N.3 * N.5,
  N.3^N.2 = N.3 * N.6

Example GrpFP_1_NilpotentQuotient1 (H70E36)

The free nilpotent group of rank r and class e is defined as F / γe + 1(F), where F is a free group of rank r and γe + 1(F) denotes the (e + 1) st term of the lower central series of F.

We construct the free nilpotent group N of rank 2 and class 3 as quotient of the free group F of rank 2 and the natural epimorphism from F onto N.

> F<a,b> := FreeGroup(2);
> N<[x]>, pi := NilpotentQuotient(F, 3);
> N;
GrpGPC : N of infinite order on 5 PC-generators
PC-Relations:
    x[2]^x[1] = x[2] * x[3], 
    x[2]^(x[1]^-1) = x[2] * x[3]^-1 * x[4], 
    x[3]^x[1] = x[3] * x[4], 
    x[3]^(x[1]^-1) = x[3] * x[4]^-1, 
    x[3]^x[2] = x[3] * x[5], 
    x[3]^(x[2]^-1) = x[3] * x[5]^-1
Using the function NilpotencyClass, we check the nilpotency class of the quotient.

> NilpotencyClass(N);
3

Example GrpFP_1_NilpotentQuotient2 (H70E37)

The Baumslag-Solitar groups BS(p, q) = < <a, b| abpa - 1 = bq > form a fascinating class of 1-relator groups. We compute the nilpotent of class 4 quotient of two of them, and print out the resulting presentations, and the structure of the generators.

> G<a,b> := Group<a,b|a*b*a^-1=b^4>;
> N,f := NilpotentQuotient(G,4);
> N;
GrpGPC : N of infinite order on 5 PC-generators
PC-Relations:
  N.2^3 = N.3^2 * N.4^2 * N.5,
  N.3^3 = N.4^2 * N.5^2,
  N.4^3 = N.5^2,
  N.5^3 = Id(N),
  N.2^N.1 = N.2 * N.3,
  N.2^(N.1^-1) = N.2 * N.3^2 * N.4^2 * N.5,
  N.3^N.1 = N.3 * N.4,
  N.3^(N.1^-1) = N.3 * N.4^2 * N.5^2,
  N.4^N.1 = N.4 * N.5,
  N.4^(N.1^-1) = N.4 * N.5^2
> for i := 1 to Ngens(N) do
> N.i @@ f;
> end for;
a
b
(b, a)
(b, a, a)
(b, a, a, a)
> G<a,b> := Group<a,b|a*b^2*a^-1=b^4>;
> N,f := NilpotentQuotient(G,4);
> N;
GrpGPC : N of infinite order on 8 PC-generators
PC-Relations:
  N.2^2 = Id(N),
  N.3^2 = N.5 * N.8,
  N.4^2 = N.7,
  N.5^2 = N.8,
  N.6^2 = Id(N),
  N.7^2 = Id(N),
  N.8^2 = Id(N),
  N.2^N.1 = N.2 * N.3,
  N.2^(N.1^-1) = N.2 * N.3 * N.4 * N.5 * N.6,
  N.3^N.1 = N.3 * N.4,
  N.3^(N.1^-1) = N.3 * N.4 * N.6 * N.7,
  N.3^N.2 = N.3 * N.5,
  N.4^N.1 = N.4 * N.6,
  N.4^(N.1^-1) = N.4 * N.6,
  N.4^N.2 = N.4 * N.7,
  N.5^N.1 = N.5 * N.7,
  N.5^(N.1^-1) = N.5 * N.7,
  N.5^N.2 = N.5 * N.8
> for i := 1 to Ngens(N) do
> N.i @@ f;
> end for;
a
b
(b, a)
(b, a, a)
(b, a, b)
(b, a, a, a)
(b, a, b, a)
(b, a, b, b)

SetVerbose("NilpotentQuotient", n) : MonStgElt, RngIntElt ->
Turn on and off the printing of information as the nilpotent quotient algorithm proceeds. n may be set to any of 0, 1, 2 or 3. Setting n to be 0 turns printing off, while successively higher values for n print more and more information as the algorithm progresses. The default value of n is 0.

Example GrpFP_1_NilpotentQuotient3 (H70E38)

We compute the maximal nilpotent quotient N1 of the group G given by the following presentation

< a, b, c, d, e | (b, a), (c, a), (d, a)=(c, b), (e, a)=(d, b), (e, b)=(d, c), (e, c), (e, d) >.

> F<a,b,c,d,e> := FreeGroup(5);
> G<a,b,c,d,e> :=
>          quo<F | (b,a), (c,a),
>          (d,a)=(c,b), (e,a)=(d,b), (e,b)=(d,c),
>          (e,c), (e,d)>;
> N1<[x]>, pi1 := NilpotentQuotient(G, 0);
Using the function NilpotencyClass, we check the nilpotency class of the quotient. It turns out to have nilpotency class 6.

> NilpotencyClass(N1);
6
Next we compute a metabelian quotient N2 of G, construct the natural epimorphism from N1 onto N2 and check its kernel. (The functions applied to the nilpotent quotients are described in Chapter POLYCYCLIC GROUPS.) To get a metabelian quotient we adjoin 4 variables and a relation to the presentation of G and use the "free variables" facility.

> M := Group<w,x,y,z|((w,x),(y,z))>; // metabelian identity
> D := FreeProduct(G,M); // adjoin to G
> N2, pi2 := NilpotentQuotient(D, 0: NumberOfFreeVariables := 4); 
> NilpotencyClass(N2);
4
> DerivedLength(N2);
2
> f := hom< N1->N2 | [ pi1(G.i)->pi2(D.i) : i in [1..Ngens(G)] ] >; 
> PCGenerators(Kernel(f), N1);
{@ x[14], x[15] * x[17], x[16], x[17]^2, x[18], x[19], x[20],
x[21], x[22], x[23], x[24], x[25], x[26], x[27], x[28], x[29],
x[30], x[31] @}
We compute a quotient N3 of G satisfying the 4 th Engel law, construct the natural epimorphism from N1 onto N3 and again check the kernel. (The functions applied to the nilpotent quotients are described in Chapter POLYCYCLIC GROUPS.)

> N3, pi3 := NilpotentQuotient(G, 0 : Engel := 4);
> NilpotencyClass(N3);
4
> DerivedLength(N3);
3
> h := hom< N1->N3 | [ pi1(g)->pi3(g) : g in Generators(G) ] >; 
> PCGenerators(Kernel(h), N1);
{@ x[19], x[20], x[21], x[22], x[23], x[24], x[25], x[26], x[27],
x[28], x[29], x[30], x[31] @}

Soluble Quotient

A soluble quotient algorithm computes a consistent power-conjugate presentation of the largest finite soluble quotient of a finitely presented group, subject to certain algorithmic and user supplied restrictions. In this section we describe only the simplest use of such an algorithm within Magma. For more information the user is referred to Chapter FINITELY PRESENTED GROUPS: ADVANCED.

SolvableQuotient(G : parameters): GrpFP, RngIntElt -> GrpPC, Map, SeqEnum, MonStgElt
SolubleQuotient(G : parameters): GrpFP, RngIntElt -> GrpPC, Map, SeqEnum, MonStgElt
Let G be a finitely presented group. The function constructs the largest finite soluble quotient of G.

Example GrpFP_1_SolubleQuotient1 (H70E39)

We compute the soluble quotient of the group < a, b | a2, b4, ab - 1ab(abab - 1)5ab2ab - 2 >.

> G<a,b> := Group< a, b | a^2, b^4,
>                     a*b^-1*a*b*(a*b*a*b^-1)^5*a*b^2*a*b^-2 >; 
> Q := SolubleQuotient(G);
> Q;
GrpPC : Q of order 1920 = 2^7 * 3 * 5
PC-Relations:
    Q.1^2 = Q.4, 
    Q.2^2 = Id(Q), 
    Q.3^2 = Q.6, 
    Q.4^2 = Id(Q), 
    Q.5^2 = Q.7, 
    Q.6^2 = Id(Q), 
    Q.7^2 = Id(Q), 
    Q.8^3 = Id(Q), 
    Q.9^5 = Id(Q), 
    Q.2^Q.1 = Q.2 * Q.3, 
    Q.3^Q.1 = Q.3 * Q.5, 
    Q.3^Q.2 = Q.3 * Q.6, 
    Q.4^Q.2 = Q.4 * Q.5 * Q.6 * Q.7, 
    Q.4^Q.3 = Q.4 * Q.6 * Q.7, 
    Q.5^Q.1 = Q.5 * Q.6, 
    Q.5^Q.2 = Q.5 * Q.7, 
    Q.5^Q.4 = Q.5 * Q.7, 
    Q.6^Q.1 = Q.6 * Q.7, 
    Q.8^Q.1 = Q.8^2, 
    Q.8^Q.2 = Q.8^2, 
    Q.9^Q.1 = Q.9^3, 
    Q.9^Q.2 = Q.9^4, 
    Q.9^Q.4 = Q.9^4

SolvableQuotient(F, n : parameters): GrpFP, RngIntElt -> GrpPC, Map, SeqEnum, MonStgElt
SolubleQuotient(F, n : parameters): GrpFP, RngIntElt -> GrpPC, Map, SeqEnum, MonStgElt
SolvableQuotient(F, P : parameters): GrpFP, Set -> GrpPC, Map, SeqEnum, MonStgElt
SolubleQuotient(F, P : parameters): GrpFP, Set -> GrpPC, Map, SeqEnum, MonStgElt
Find a soluble quotient G and the epimorphism π:F mapsur G with a specified order. n must be a nonnegative integer. P must be a set of primes.

The three forms reflect possible information about the order of an expected soluble quotient. In the first form the order of G is given by n, if n is greater than zero. If n equals zero, nothing about the order is known and the relevant primes will be calculated completely.

The second form, with no n argument, is equivalent to the first with n = 0. This is a standard argument, and usually it is the most efficient way to calculate soluble quotients.

Note that, if n>0 is not the order of the maximal finite soluble quotient, it may happen that no group of order n can be found, since an epimorphic image of size n may not be exhibited by the chosen series.

In the third form a set P of relevant primes is given. The algorithm calculates the biggest quotient such that the order has prime divisors only in P. P may have a zero as element, this is just for consistency reasons. It is equivalent to the first form with n equal zero.

For a description of the algorithm used and of the set of parameters available for this function, see Chapter FINITELY PRESENTED GROUPS: ADVANCED. Other more specialised functions for computing soluble quotients and some examples can be found there as well.


Example GrpFP_1_SolubleQuotient2 (H70E40)

Consider the group G defined by the presentation < x, y | x3, y8, [x, y4], x - 1yx - 1y - 1xyxy - 1, (xy - 2)2(x - 1y - 2)2(xy2)2(x - 1y2)2, (x - 1y - 2)6(x - 1y2)6 >.

> G<x, y> := Group< x, y | 
>     x^3, y^8, (x,y^4), x^-1*y*x^-1*y^-1*x*y*x*y^-1,
>     (x*y^-2)^2*(x^-1*y^-2)^2*(x*y^2)^2*(x^-1*y^2)^2, 
>     (x^-1*y^-2)^6*(x^-1*y^2)^6 >; 
We apply the soluble quotient algorithm to G and compute the order of the soluble quotient Q.

> time Q := SolubleQuotient(G); 
Time: 116.920
> Order(Q); 
165888
Note that 165888 = 211 .34. If we knew the possible primes in advance the soluble quotient can be computed much more quickly by using this knowledge.

> time Q := SolubleQuotient(G, {2, 3});
Time: 39.400
Note that this reduces the execution time by a factor of almost three.

We now assume that G is finite and try to compute its order by means of the Todd-Coxeter algorithm.

> Order(G);
165888
Hence the group is finite and soluble and G is isomorphic to Q. We may use the tools for finite soluble groups to investigate the structure of G. For example we can easily find the number of involutions in G.

> cls := ConjugacyClasses(Q);
> &+ [ cl[2] : cl in cls | cl[1] eq 2 ];
511

 [Next][Prev] [Right] [Left] [Up] [Index] [Root]

Version: V2.19 of Wed Apr 24 15:09:57 EST 2013