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

Soluble Quotients

Subsections

Introduction

This section presents a short overview towards the theory of the soluble quotient algorithm, the functions designed for computing soluble quotients and the functions designed for dealing with soluble quotient processes.

Construction

For a finite group G, the property of being soluble means that the derived series G = G(0) > G(1) > ... > G(n) terminates with G(n) = < 1 >. Each section G(i)/G(i + 1) is a finite abelian group, hence it can be identified with a Z G/G(i)-module M, where the action of G/G(i) on M is given by the conjugation action on G(i)/G(i + 1).

From module theory we see that there exists a series M = M(0) > M(1) > ... > M(ri), where each section is an irreducible GF(p) G/G((i))-module for some prime p. Using these series we obtain a refinement G = G(0) > G(1) > ... > G(n) = < 1 > of the commutator series with the properties:

The series is normal,
Each section G(i)/G(i + 1) is elementary abelian of prime power order, and is irreducible as a G/G(i)-module.
If G = H(0) > H(1) > ... > H(t) = < 1 > is another series with these properties, then n = t and there exists a permutation π∈Sn such that G(i)/G(i + 1) is isomorphic to H(iπ)/H(iπ+ 1) (as GF(p) modules).

Note: A PC-presentation defined by a further refinement of this series leads to a "conditioned" presentation. The converse is not always true, because the irreducibility of the sections is not required for a conditioned presentation.

The soluble quotient algorithm uses these series to construct soluble groups. Starting with the trivial group G/G(0), it successively chooses irreducible G/G(i) modules Mi and extensions ζi ∈H2(G/G(i), Mi) which give rise to exact sequences 1 -> Mi -> G/G(i + 1)=G/G(i).Mi -> G/G(i) -> 1. To describe the algorithmic approach, we consider the following situation. Let G be a finite soluble group, M a normal elementary abelian subgroup of G such that M is a H=G/M irreducible module. (The action of H on M is identified with the conjugation action of G/M on the subgroup M.) Then the relations of the group G have the shape gipi=wimi ( resp.) gjgi=wijmij, mi, mij∈M where wi, wij are the canonical representatives of H in G. Then bar(gipi)=bar(wi) resp. bar(gj)^(bar(gi)) =bar(wij) is a PC-presentation of H and the set of images ((gipi - 1, gi) -> mi, (gj, gi) |-> mij) determines a unique element of the cocycle space C2(H, M).

According to the p-group situation, we call the system t= (mi, mij), the tail defining G = H.Mt as an extension of M by H.

Not every choice of a system t = (mi, mij) defines an extension. To make sure that t corresponds to an element s of C2(G, M) it must satisfy a certain equation system, the so-called consistency equations (see Vaughan-Lee). These are linear homogeneous equations in M, so the solution space can be determined.

For the construction of soluble quotients we also have to find the epimorphism varepsilon: F mapsur G. The existence of the epimorphism is obviously a restriction of the possible images G, and it can be checked simultaneously with constructing G. Let G be an extension G = H.M, where M is a H-module and H is a known soluble quotient δ: F mapsur H. Then δis uniquely determined by the images δ(fi)=hi, 1≤i ≤r, where {f1, ..., fr} is a generating set of F. We want to find a lift varepsilon of δ, i.e. varepsilon (f)=δ(f) ( mod) M for all f ∈F. This means that varepsilon(fi)=hi xi for all i≤r, where xi ∈M are to be determined. Since varepsilon will be a homomorphism, we require varepsilon(rj(f1, ..., fr))=1G for the defining relations rj of F. This leads to a linear equation system for the variables (x1, ..., xr)∈Mr. We solve this equation system together with the consistency equations, hence we find a subspace S of Mr x H2(H, M) of those extensions for which the epimorphism δhas a lift. Let us call an element of S an extended tail.

Let K be the minimal splitting field of M, i.e. the character field of the unique character of H which corresponds to M. Then M is obviously a KH-module and S is also a K-space. The space S has a K-subspace SS of split extensions, i.e. the projection of SS into H2(H, M) is only the trivial element. For any element t ∈S/SS the corresponding map varepsilont: F -> H.Mt is necessarily surjective, hence defines a soluble quotient. Let s1, s2 be two elements of S/SS and let varepsiloni: F mapsur H.Msi =: Gi denote the corresponding soluble quotients. If s1 and s2 are K-linear dependent, the groups G1 and G2 will be isomorphic. Unfortunately, the converse is not true, even K-linear independent elements may lead to isomorphic groups. Nevertheless, if s1 and s2 are independent, the kernels of the epimorphisms will be different, hence one can iterate the lifting to varepsilon1, 2: F mapsur (G1).Ms2 = (H.Ms1).Ms2 = H.(M direct-sum M)s1.s2. (The last equality can be read as a definition of s1.s2 in the righthand side term.)

The dimension a=dimK(S/SS) is therefore characterised as the maximal multiplicity a = max {z ∈Z^ + | exists varepsilon:F mapsur H, Mz }. SS itself also has a K-subspace SC, for which the map varepsilons: F -> H.Ms, s∈SC is not surjective. The K-dimension b=dimK(SS/SC) is again characterised as the maximal multiplicity b=max{z∈Z^ + | exists varepsilon:F mapsur H, Mz }. Moreover, after taking a maximal extension varepsilon:F mapsur H.Mb, M never has to be considered for split extensions again.

Calculating the Relevant Primes

A crucial step in finding finite soluble quotients varepsilon: F mapsur G is the calculation of the relevant primes, i.e. the prime divisors of |G|. This is the most time consuming part of the algorithm, so it is crucial to apply it as efficiently as possible, and any other information about possible prime divisors is very helpful. We do not explain this calculation in detail. However, to use the functions and options provided by Magma in a correct manner, we outline the idea of the calculation.

Let varepsilon:F mapsur G be a finite soluble quotient and let N denote the kernel of varepsilon. If a module M allows an extension bar(varepsilon):F mapsur G.M, then M must be a constituent of N/Nprime, and the relevant primes are the prime divisors of N/Nprime. Again N/Nprime can be viewed as an F/N- module, hence an H-module. Therefore it is a direct sum N/Nprime isomorphic to Mp1 direct-sum Mp2 direct-sum ... direct-sum Zd, where the Mpi are finite modules of order a power of the prime pi. Let p not divide |H|. Then by Zassenhaus the extension H.Mp must split. We consider an irreducible module M in the head of Mp, i.e. there is an H-epimorphism Mp mapsur M. Then there is a valid soluble quotient varepsilon: F mapsur H.M and the extension H.M splits.

Now there exists an irreducible Z H- module L such that M is a GF(p)-modular constituent of L/pL. Moreover, Δ: H -> GL(L) is the corresponding representation of H and any Δ-module will have this property.

Now using the theory of space groups, one can construct homomorphisms varepsilon1: F mapsur H.L and varepsilon2: H.L mapsur H.M such that the composition is surjective. Hence p can be detected in Δ. Let PΔ denote the set of primes obtained from Δ. To find these primes, we have to know a set D of representatives of the irreducible rational representations of F/N, hence of H. The set of prime divisors of K/Kprime is a subset of P= bigcupΔ∈D PΔ ∪{p | p ( prime ), p | |G|}. We want to point out the following:

Usually the set of primes dividing |K/Kprime| is a proper subset of P, because the primes dividing |G| may or may not divide |K/Kprime|.

Conversely, if p does not divide |G|, then there certainly exists a module M in characteristic p such that there is a soluble quotient F mapsur G.M, and the extension splits.

The algorithm can also recognise infinite abelian sections. This means that already varepsilon1: F mapsur H.L is surjective. All primes are relevant and no maximal finite soluble quotient exists.

Let φ:F mapsur H be a lift of varepsilon:F mapsur G, i.e. G is a quotient of H: φ:H mapsur G. If the relevant primes of G are known, these are also relevant primes of H, and only those representations Δof H must be considered for which kerφnot⊂kerΔis valid.

The Functions

Magma provides two different ways to calculate finite soluble quotients: a main function for the whole calculation, and a process which gives control over each individual step.

Let F be a finitely presented group.

SolubleQuotient(F, n : parameters): GrpFP, RngIntElt -> GrpPC, Map, SeqEnum, MonStgElt
SolvableQuotient(F, n : parameters): GrpFP, RngIntElt -> GrpPC, Map, SeqEnum, MonStgElt
SolubleQuotient(F : parameters): GrpFP, RngIntElt -> GrpPC, Map, SeqEnum, MonStgElt
SolvableQuotient(F : parameters): GrpFP, RngIntElt -> GrpPC, Map, SeqEnum, MonStgElt
SolubleQuotient(F, P : parameters): GrpFP, Set -> GrpPC, Map, SeqEnum, MonStgElt
SolvableQuotient(F, P : parameters): GrpFP, Set -> GrpPC, Map, SeqEnum, MonStgElt
Find a soluble quotient varepsilon: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.

The returned values are the group G and the epimorphism varepsilon: F mapsur G. The third returned value is a sequence describing the series and modules by which G has been constructed.

The fourth value is a string which explain the reason for termination. The following list gives the termination conditions. The algorithm terminates normally if:

1.
A quotient of the given order has been constructed.
2.
A maximal quotient (with respect to the conditions given on the order) has been constructed.

The algorithm will be aborted and returns a warning if:
3.
A bound on the length of a series or subseries has been hit.
4.
A limit on the size of the quotient or a section has been hit.
5.
The algorithm detects a free abelian section.

With the following options one can define abort conditions corresponding to the third and fourth item. The idea of all these conditions is to control the occurrence of infinite soluble quotients.

     SeriesLength: RngIntElt             Default: 0

Limits the length of the chief series to r. For sag-series it is the nilpotent length of the series, for derived series it is the derived length. The default value of zero means no limit.

If the algorithm hits the limit, it gives a warning message and returns the last soluble quotient.

     SubseriesLength: RngIntElt          Default: 0

Limits the length of a series in a section. If the sag-series is used, it is the length of the lower descending series. For the derived series, the limit is applied to the exponent of an element of a section with maximal prime power order. For example, if the limit is set to 3, the limit would be hit by a section of type C8, but not by C23 and not even by C42.

     vapour QuotientSize: RngIntElt      Default: 0

If the value n is bigger than zero, the algorithm returns if a quotient of order bigger or equal to n has been found. A warning message will be printed.

     vapour SectionSize: RngIntElt       Default: 0

If the value s is bigger than zero, the algorithm returns if the order of a section is bigger than or equal to s. A warning message will be printed.

Note: Since an additive bound on a group order is not as meaningful as a multiplicative bound, the latter options are only useful as break conditions when the quotient gets too big for further calculations. The return quotient which hits such a bound is somewhat randomly chosen, since only a change in the order of checking modules may lead to other quotients.

With the following options the strategy of the algorithm and some subalgorithms can be chosen.

     vapour MSQ_Series: MonStgElt        Default: "sag"

Determines the series which is used for the construction of soluble groups.

The default value is "sag", since it is usually the most efficient choice. Of course, there is a value "derived", exhibiting the derived series.

Another choice is "lowercentral", choosing the lower central series. This restricts the algorithm to finite nilpotent quotients. The choice "pcentral" only exhibits p-groups as quotients.

The nilpotent resp. p-quotient algorithms are usually more efficient, so these options may only be useful to obtain additional information needed for a SQ-process.

     MSQ_PrimeSearchModus: RngIntElt     Default: 3

Defines at what status of the algorithm the relevant prime search is called.

The possible choices reflect the different intentions of constructing a soluble quotient; for the general situation, (i.e. finding a finite soluble quotient without any information about relevant primes and check its maximality) this option makes only little difference in runtime behaviour.

0:
No calculation of relevant primes. This is the default value, if the second argument does not request a prime calculation, e.g. if the order of the quotient or its relevant primes are known.
1:
The relevant primes will be calculated after the soluble quotient algorithm (with the given input) terminates normally. Possibly new relevant primes are returned in a message. If, for example, the second argument is a set S (so no limit on the exponent) and no new relevant primes have been found, the maximality of the soluble quotient is proved.
2:
As 1, but continues the algorithm when finding new relevant primes.
3:
Perform the relevant prime calculation after a "main" step in the series, i.e. after completing a nilpotent section in a sag-series resp. a commutator section for the derived series. This is the default value, if prime calculation is required by the second argument. It is a good choice if one wants to construct large finite quotients quickly.

Note: This option can cause problems in case of a sag-series when infinite soluble quotients exist. For finite quotients, it seems to be the best choice.
4:
Perform the relevant prime calculation after calculating an elementary abelian layer. This option is preferable, if the sag-series is used and an infinite soluble quotient is possible.
5:
Perform the relevant prime calculation after each successful lift of a quotient. This option is preferable when infinite sections shall be detected as soon as possible (with respect to the chosen series).

     MSQ_ModulCalcModus: RngIntElt       Default: 0

In the construction of soluble quotients using a sag-series one can restrict the number of modules by using tensor products and skew symmetric products. This can improve the performance in the case of big soluble quotients, for small quotients the overhead may invalidate the improvement. For other series this option has no meaning. The possible values are:

0:
Do not apply this technique (default).
1:
Fast version, just apply those parts which can be calculated quickly.
2:
Full version, this is only recommended for "big" soluble quotients, i.e. quotients with long descending series in nilpotent sections.

     MSQ_CollectorModus: RngIntElt       Default: 2

Defines the setup modus for the symbolic collector, i.e. the ratio of precalculation to dynamic setup:

0:
Full precalculation, preferable for small soluble groups.
1:
Partial precalculation (test version).
2:
Dynamic setup (default).

The function also provides a general print option determining the amount of timings status information during the function call. Additionally there are some verbose flags which determine the amount of information given about various subalgorithms. If both a general print value and a verbose flag are given, the verbose flag has higher preference.

     Print: RngIntElt                    Default: 0

Determines what timing information and status messages are given during the calculation (0 = no printing, 5 = maximal information).

     SetVerbose("MSQ_Messages", n):      Maximum: 2

If set to 1, the sizes of new soluble quotients are printed.

     SetVerbose("MSQ_PrimeSearch", n):   Maximum: 15

Bitflag for print levels during the calculation of relevant primes:

1:
Timings and statistics about the calculation of rational representations.
2:
Timings for transforming rational into integral representations.
4:
Timing for finding the relevant primes.
8:
Printing of new relevant primes.

     SetVerbose("MSQ_RepsCheck", n):     Maximum: 3

1:
Timing for checking extensions of modules.
2:
Statistics about the modules to be checked.

     SetVerbose("MSQ_RepsCalc", n):      Maximum: 3

1:
Timing information about the module calculation.
2:
Statistics about the module calculation.

     SetVerbose("MSQ_Collector", n):     Maximum: 1

If set to 1, the timing for the setup of the symbolic collector is printed.

     SetVerbose("MSQ_TraceFunc", n):     Maximum: 2

Give messages about the main function calls (1) resp. most function calls (2) in the Magma language during the algorithm.

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

Version: V2.19 of Mon Dec 17 14:40:36 EST 2012