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 FP GROUPS - ADVANCED FEATURES.
The maximal abelian quotient G/G^prime of the group G as GrpAb (cf. Chapter ABELIAN GROUPS). The natural epimorphism pi:G -> G/G^prime is returned as second value.
The maximal p-elementary abelian quotient Q of the group G as GrpAb (cf. Chapter ABELIAN GROUPS). The natural epimorphism pi:G -> Q is returned as second value.
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.
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.
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.
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.
Given the finitely presented group G, return the torsion-free rank of the derived quotient group of G.
> 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 > ); 1We 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.
> 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); 1We see that the maximal 2-elementary abelian quotient of H has order 2^1.
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 p^n, Frattini rank d, and that its generators are a_1, ..., a_n. Then the power-conjugate presentation constructed has the following additional structure. The set {a_1, ..., a_d} is a generating set for G. For each a_k in {a_(d + 1), ..., a_n}, there is at least one relation whose right hand side is a_k. One of these relations is taken as the definition of a_k. (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 FP GROUPS - ADVANCED FEATURES.
The parameters available for the function pQuotient are:
var Exponent: RngIntElt Default: 0
If Exponent := m, enforce the exponent law, x^m = 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: 1000000
The amount of space requested for the p-quotient computation.
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 homomorphism pi from F to G and a sequence listing definitions of pc-generators.There exist a number of parameters for controlling the behaviour of this function, which are described below.
> 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
> 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
> 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
> 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
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 lower central series G_0, G_1, ... of a group G can be defined inductively as G_0 = G, G_i = [G_(i - 1), G]. G is said to have nilpotency class c if c is the smallest non-zero integer such that G_c = 1. If N is a normal subgroup of G and G/N is nilpotent, then N contains G_i for some non-negative integer i. G has infinite nilpotent quotients if and only if G/G_1 (the maximal abelian quotient of G) is infinite and a prime p divides a finite cyclic factor of a nilpotent quotient if and only if p divides a cyclic factor of G/G_1. The i-th (i > 1) factor G_(i - 1)/G_i of the lower central series is generated by the elements [g, h]G_i, where g runs through a set of representatives of G/G_1 and h runs through a set of representatives of G_(i - 2)/G_(i - 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 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 g_1, ..., g_k of the quotient Q to be left n-Engel elements. That is, they satisfy [x, ..., x, g_i] = 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 [g_i, 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: false
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 Metabelian: BoolElt Default: false
Enforce the identities x^8 and [[x_1, x_2, x_3], [x_4, x_5, x_6]] on the nilpotent quotient.
This function returns the class c nilpotent quotient of G as a group in category GrpGPC, together with the epimorphism pi from G onto this quotient. Using the parameters described below, the user can enforce certain conditions on the quotient found.
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
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.
< 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); 6Next 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.)
> N2<[y]>, pi2 := NilpotentQuotient(G, 0 : Metabelian := true);
> NilpotencyClass(N2);
5
> f := hom< N1->N2 | [ pi1(g)->pi2(g) : g in Generators(G) ] >;
> PCGenerators(Kernel(f), N1);
{@ x[1]^8, x[2]^8, x[3]^8, x[4]^8, x[5]^8, x[6]^4, x[7]^4 * x[19]
* x[23], x[8]^4, x[9]^4, x[10]^4, x[11]^4, x[12]^4, x[13]^4,
x[14]^2, x[15]^2 * x[19] * x[23], x[17]^2 * x[19] * x[23], x[18]
* x[20], x[24], x[25], x[26], x[27], x[28], x[29], x[30], x[31]
@}
We finally 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<[z]>, pi3 := NilpotentQuotient(G, 0 : Engel := 4);
> NilpotencyClass(N3);
4
> 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] @}
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 FP GROUPS - ADVANCED FEATURES.
Let G be a finitely presented group. The function constructs the largest finite soluble quotient of G.
> 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
Find a soluble quotient G and the epimorphism pi: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 FP GROUPS - ADVANCED FEATURES. Other more specialised functions for computing soluble quotients and some examples can be found there as well.
> 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); 165888Note that 165888 = 2^(11) ⋅3^4. 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); 165888Hence 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