Example GrpFP_SolubleQuotient2 (H80E74)

> G<x, y> := FPGroup< 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 >; 

> time Q := SolubleQuotient(G); 
Time: 116.920
> Order(Q); 
165888

> time Q := SolubleQuotient(G, {2, 3});
Time: 39.400

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

> Order(G);
165888

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

Soluble Quotient Advanced

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⁽⁰⁾ > G⁽¹⁾ > ... > G⁽ⁿ⁾ terminates with G⁽ⁿ⁾ = < 1 >. Each section G⁽ⁱ⁾/G^{(i + 1)} is a finite abelian group, hence it can be identified with a Z G/G⁽ⁱ⁾-module M, where the action of G/G⁽ⁱ⁾ on M is given by the conjugation action on G⁽ⁱ⁾/G^{(i + 1)}.

From module theory we see that there exists a series M = M⁽⁰⁾ > M⁽¹⁾ > ... > M^(r_i), 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₍₀₎ > G₍₁₎ > ... > 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₍₀₎ > H₍₁₎ > ... > H_(t) = < 1 > is another series with these properties, then n = t and there exists a permutation π ∈S_n such that G_(i)/G_{(i + 1)} is isomorphic to H_(iπ)/H_{(iπ + 1)} (as GF(p) modules).

The soluble quotient algorithm uses these series to construct soluble groups. Starting with the trivial group G/G₍₀₎, it successively chooses irreducible G/G_(i) modules M_i and extensions ζ_i ∈H²(G/G_(i), M_i) which give rise to exact sequences 1 -> M_i -> G/G_{(i + 1)}=G/G_(i).M_i -> 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 g_i^p_i=w_im_i (resp.) g_j^g_i=w_ijm_ij, m_i, m_ij∈M where w_i, w_ij are the canonical representatives of H in G. Then bar(g_i^p_i)=bar(w_i) resp. bar(g_j)^(bar(g_i)) =bar(w_ij) is a PC-presentation of H and the set of images ((g_i^{p_i - 1}, g_i) -> m_i, (g_j, g_i) |-> m_ij) determines a unique element of the cocycle space C²(H, M).

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

Not every choice of a system t = (m_i, m_ij) defines an extension. To make sure that t corresponds to an element s of C²(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 ε: 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 δ(f_i)=h_i, 1≤i ≤r, where {f₁, ..., f_r} is a generating set of F. We want to find a lift ε of δ, i.e. ε (f)=δ(f) (mod) M for all f ∈F. This means that ε(f_i)=h_i x_i for all i≤r, where x_i ∈M are to be determined. Since ε will be a homomorphism, we require ε(r_j(f₁, ..., f_r))=1_G for the defining relations r_j of F. This leads to a linear equation system for the variables (x₁, ..., x_r)∈M^r. We solve this equation system together with the consistency equations, hence we find a subspace S of M^r x H²(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 S_S of split extensions, i.e. the projection of S_S into H²(H, M) is only the trivial element. For any element t ∈S/S_S the corresponding map ε_t: F -> H.M_t is necessarily surjective, hence defines a soluble quotient. Let s₁, s₂ be two elements of S/S_S and let ε_i: F mapsur H.M_si =: G_i denote the corresponding soluble quotients. If s₁ and s₂ are K-linear dependent, the groups G₁ and G₂ will be isomorphic. Unfortunately, the converse is not true, even K-linear independent elements may lead to isomorphic groups. Nevertheless, if s₁ and s₂ are independent, the kernels of the epimorphisms will be different, hence one can iterate the lifting to ε_{1, 2}: F mapsur (G₁).M_s2 = (H.M_s1).M_s2 = H.(M direct-sum M)_s1.s2. (The last equality can be read as a definition of s₁.s₂ in the righthand side term.)

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

Calculating the Relevant Primes

A crucial step in finding finite soluble quotients ε: 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 ε:F mapsur G be a finite soluble quotient and let N denote the kernel of ε. If a module M allows an extension bar(ε):F mapsur G.M, then M must be a constituent of N/N^prime, and the relevant primes are the prime divisors of N/N^prime. Again N/N^prime can be viewed as an F/N- module, hence an H-module. Therefore it is a direct sum N/N^prime isomorphic to M_p1 direct-sum M_p2 direct-sum ... direct-sum Z^d, where the M_pi are finite modules of order a power of the prime p_i. Let p not divide |H|. Then by Zassenhaus the extension H.M_p must split. We consider an irreducible module M in the head of M_p, i.e. there is an H-epimorphism M_p mapsur M. Then there is a valid soluble quotient ε: 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 ε₁: F mapsur H.L and ε₂: 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/K^prime 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/K^prime| is a proper subset of P, because the primes dividing |G| may or may not divide |K/K^prime|.

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 ε₁: 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 ε: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 Intrinsics

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 ε:F mapsur G with a specified order. The argument n must be a nonnegative integer and 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. The set P may have a zero as an 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 ε: 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 C₈, but not by C₂³ and not even by C₄².

     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.

Simple Group Quotients

We describe intrinsics for finding homomorphisms of an fp-group G onto simple groups. This may be useful when the presentation for G defines a perfect group. The algorithm maintains a list of simple groups to try and the function Homomorphisms is used to run through the list looking for a homomorphism onto G.

The list of simple groups supplied in versions beginning with V2.25 contain all non-abelian simple groups with order ≤10¹⁰. Such a list is dominated by PSL(2, q)'s with q odd. In this implementation these PSL(2, q)'s are treated as an infinite family rather than stored individually, and so continue beyond the above limit.

SimpleQuotients(F, deg1, deg2, ord1, ord2: parameters) : GrpFP, RngIntElt, RngIntElt, RngIntElt, RngIntElt -> List

SimpleQuotients(F, ord1, ord2: parameters) : GrpFP, RngIntElt, RngIntElt -> List

SimpleQuotients(F, ord2: parameters) : GrpFP, RngIntElt -> List

    Family: Any                         Default: "All"

    Limit: RngIntElt                    Default: 1

    HomLimit: RngIntElt                 Default: 0

Uses Homomorphisms to find epimorphisms from F onto simple groups in a fixed list. The arguments deg1 and deg2 are respectively lower and upper bounds for the degree of the image group. If the degree arguments are not present then bounds of 5 and 10⁷ are used. The arguments ord1 and ord2 are respectively lower and upper bounds for the orders of the image group. (Setting ord2 low enough is particularly important if a quick search is wanted.) If ord1 is not given then it defaults to 1.

The return value is a list of sequences of epimorphisms found. Each sequence contains epimorphisms onto one simple group. The parameter Limit limits the number of successful searches to be carried out by Homomorphisms. The default value is 1, so by default the search terminates with the first simple group found to be a homomorphic image of F.

The parameter HomLimit limits the number of homomorphisms that will be searched for by any particular call to Homomorphisms. It defaults to zero, so that all homomorphisms for any group found will be returned.

The parameter Family selects sublists of the main list to search. Possible values of this parameter are "All", "PSL", "PSL2", "Mathieu", "Alt", "PSp", "PSU", "Other", and "notPSL2"; sets of these strings are also allowed, which searches on the union of the appropriate sublists.

SimpleQuotientProcess(F, deg1, deg2, ord1, ord2: parameters) : GrpFP, RngIntElt, RngIntElt, RngIntElt, RngIntElt -> Rec

    Family: Any                         Default: "All"

Produce a record that defines a process for searching for simple quotients of F as SimpleQuotients does. Calling this function sets up the record and conducts the initial search until a quotient is found. Continuing the search for another quotient is done by calling NextSimpleQuotient. Extracting the epimorphisms found is achieved using SimpleEpimorphisms, and testing if the process has expired is the task of IsEmptySimpleQuotientProcess.

NextSimpleQuotient(~P) : Rec ->

When P is a record returned by SimpleQuotientProcess, advance the search to the next simple group which is a homomorphic image of the finitely presented group. Does nothing if the process has expired.

IsEmptySimpleQuotientProcess(P) : Rec -> BoolElt

When P is a record returned by SimpleQuotientProcess, test whether or not P has expired.

SimpleEpimorphisms(P) : Rec -> SeqEnum, Tup

When P is a record returned by SimpleQuotientProcess, extract the most recently found epimorphisms onto a simple group, plus a tuple describing the image group. This is a valid operation when IsEmptySimpleQuotientProcess returns false.

> F := FPGroup<a,b,c|a^13,b^3,c^2,a = b*c>;
> IsPerfect(F);
true
> L := SimpleQuotients(F,1, 100, 2, 10^5:Limit := 2);
> #L;
2
> for x in L do CompositionFactors(Image(x[1])); end for;
    G
    |  A(1, 13)               = L(2, 13)
    1
    G
    |  A(2, 3)                = L(3, 3)
    1
> L[2,1];
Homomorphism of GrpFP: F into GrpPerm: $, Degree 13, Order 
2^4 * 3^3 * 13 induced by
F.1 |--> (1, 10, 4, 5, 11, 8, 3, 6, 7, 12, 9, 13, 2)
F.2 |--> (2, 10, 4)(3, 6, 7)(5, 11, 13)(8, 12, 9)
F.3 |--> (1, 10)(2, 5)(3, 12)(8, 13)
> #L[2];
2

> P := SimpleQuotientProcess(F,1, 100, 2, 10^6:Family:="PSU");  
> IsEmptySimpleQuotientProcess(P);
false
> eps, info := SimpleEpimorphisms(P);
> info;
<65, 62400, PSU(3, 4)>

> NextSimpleQuotient(~P);
> IsEmptySimpleQuotientProcess(P);
true

> G := FPGroup< a,b | a^2, b^3, (a*b)^7, (a,b)^11 >;
> L2Quotients(G);
[
    L_2(43)
]
> H := FPGroup< a,b,c | a^3, b^7, c^19, (a*b)^2, (a*c)^2, (b*c)^2, (a*b*c)^2 >;
> L2Quotients(H);
[
    L_2(113)
]

> G := FPGroup< a,b | a^2, b^3, (a*b)^16, (a,b)^11 >;
> L2Quotients(G);
[
    PGL(2,23),
    PGL(2,23),
    PGL(2,463)
]

> G := FPGroup< a,b,c | a^3, b^7, (a*b)^2, (a*c)^2, (b*c)^2, (a*b*c)^2 >;      
> L2Quotients(G);                      
[
    L_2(infty^6)
]
> H := FPGroup< a,b,c | a^3, (a,c) = (c,a^-1), a*b*a = b*a*b, 
>                      a*b*a*c^-1 = c*a*b*a >;
> L2Quotients(H);
[
    L_2(3^infty)
]
> K := FPGroup< a,b | a^3*b^3 >;
> L2Quotients(K);
[
    L_2(infty^infty)
]

> H := FPGroup< a,b,c | a^3, b^7, c^19, (a*b)^2, (a*c)^2, (b*c)^2, (a*b*c)^2 >;
> quot := L2Quotients(H); quot;
[
    L_2(113)
]
> H, A := GetMatrices(quot[1]);
> H;
MatrixGroup(2, GF(113))
Generators:
    [  0   1]
    [112 112]

    [  0  85]
    [109  24]

    [102 104]
    [ 63  72]
> A;
[
    [  0   1]
    [112 112],

    [  0  85]
    [109  24],

    [102 104]
    [ 63  72]
]

> Gamma< x, y > := FPGroup< x, y | x^2, y^3 >;
> u := x*y; v := x*y^-1;
> G := quo< Gamma | u^10*v^2*u*v*u*v^2 >;
> quot := L2Quotients(G); quot;
[
    L_2(5^2)
]
> H, A := GetMatrices(quot[1]);
> H;
MatrixGroup(2, GF(5^2))
Generators:
    [        2 4*$.1 + 2]
    [        0         3]

    [0 4]
    [1 4]

> G := quo< Gamma | u^3*v*u^3*v*u^3*v^2*u*v^2 >;
> quot := L2Quotients(G);
> quot;
[
    PGL(2,13)
]
> G := quo< Gamma | u^3*v*u^3*v^2*u*v^3*u*v^2 >;
> quot := L2Quotients(G);
> quot;  
[]

> G := FPGroup< x,y | x^8, y^9, (x*y)^5, (x^-1*y)^7 >;                            
> quot := L2Quotients(G);
> quot;  
[
    L_2(71),
    L_2(71),
    L_2(71),
    L_2(2521),
    L_2(41),
    L_2(3056201),
    L_2(239),
    L_2(449),
    L_2(3876207679),
    L_2(1009),
    L_2(29113631)
]

> G := FPGroup< x, y | x^4, y^3, (x*y)^5, (x,y)^6 >;
> L2Quotients(G);
[
    L_2(79),
    L_2(3^2),
    L_2(5^2)
]

> G := FPGroup< x, y | x^3, y^4, (x*y)^9, (x,y)^2 >;
> L2Quotients(G);                                   
[
    L_2(89)
]
> G := FPGroup< x, y | x^3, y^4, (x*y)^11, (x,y)^2 >;
> L2Quotients(G);                                   
[
    L_2(769)
]
> G := FPGroup< x, y | x^3, y^5, (x*y)^6, (x,y)^2 >; 
> L2Quotients(G);                                   
[
    L_2(61)
]

> M := Matrix([[1,2,3,3],[2,1,4,5],[3,4,1,6],[3,5,6,1]]);
> L2Quotients(M);
[
    L_2(4391),
    L_2(71)
]

> G< a,b,c > := FPGroup< a,b,c | a^16, b^4, c^2, (a*b)^8, (a,b)^4 >;
> time quot := L2Quotients(G : ExactOrders := [< a, 16 >, < b, 4 >,
>    < c, 2 >, < a*b ,8 >, < (a,b), 4 >]);
Time: 1.530

> G := FPGroup< a,b | a^2, b^3, (a*b)^7 >;
> quot := L2Quotients(G); quot;
[
    L_2(infty^3)
]
> Q := quot[1];
> SpecifyCharacteristic(Q, 7);  
[
    L_2(7)
]
> SpecifyCharacteristic(Q, 11);
[
    L_2(11^3)
]
> SpecifyCharacteristic(Q, 13);
[
    L_2(13),
    L_2(13),
    L_2(13)
]

> G<a,b> := FPGroup< a,b | a^2, b^3, (a*b)^7 >;
> quot := L2Quotients(G); quot;
[
    L_2(infty^3)
]
> Q := quot[1];
> AddGroupRelations(Q, [(a*b*a*b^-1*a*b)^12]);
[
    L_2(13),
    L_2(7)
]

> H< a,b,c > := FPGroup< a,b,c | a^3, (a,c) = (c,a^-1), a*b*a = b*a*b, 
>    a*b*a*c^-1 = c*a*b*a >;
> quot := L2Quotients(H); quot;
[
    L_2(3^infty)
]
> Q := quot[1];
> AddGroupRelations(Q, [((b^2*c^3)^2*a)^5]);
[
    L_2(3^2),
    L_2(3^4)
]

> H< a,b,c > := FPGroup< a,b,c | a^3, (a,c) = (c,a^-1), a*b*a = b*a*b, 
>   a*b*a*c^-1 = c*a*b*a >;
> quot := L2Quotients(H); quot;
[
    L_2(3^infty)
]
> Q := quot[1];
> Q`Ideal;
Ideal of Graded Polynomial ring of rank 7 over Integer Ring
Order: Grevlex with weights [3, 2, 2, 2, 1, 1, 1]
Variables: x123, x23, x13, x12, x3, x2, x1
Variable weights: [3, 2, 2, 2, 1, 1, 1]
Inhomogeneous, Dimension >0
Groebner basis:
[
    x123^2 + 2*x123*x3 + 1,
    x23 + 2*x3,
    x13 + 2*x3,
    x12 + 2,
    x2 + 1,
    x1 + 1,
    3
]
> R< x123, x23, x13, x12, x3, x2, x1 > := Generic(Q`Ideal);
> AddRingRelations(Q, [x3^(3^4) - x3]);
[
    L_2(3^2),
    L_2(3^4),
    L_2(3^4),
    L_2(3^4),
    L_2(3^4),
    L_2(3^4),
    L_2(3^4),
    PGL(2,3^2),
    PGL(2,3^2),
    L_2(3^4),
    L_2(3^8),
    L_2(3^8),
    L_2(3^8),
    L_2(3^8),
    L_2(3^8),
    L_2(3^4)
]

    Signs: SeqEnum                      Default: 0

    Full: BoolElt                       Default: false

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

> F := FreeGroup(2);
> rel := (F.1 * F.2 * F.1 * F.2 * F.1 * F.2 * F.1 * F.2 * F.1 * F.2 *
>   F.1 * F.2 * F.1 * F.2 * F.1 * F.2^-1 * F.1 * F.2 * F.1 * F.2^-1)^2;
> G := quo<F | [F.1^2 ,F.2^3, rel]>;
> HasInfinitePSL2Quotient(G : Full := true);
true
[ [*
    [ 1, 1, 1 ],
    []
*], [*
    [ 1, 1, -1 ],
    []
*], [*
    [ 1, -1, 1 ],
    []
*], [*
    [ 1, -1, -1 ],
    []
*], [*
    [ -1, 1, 1 ],
    [ A4, A4 ]
*], [*
    [ -1, 1, -1 ],
    [ A5, A5, infinite ]
*], [*
    [ -1, -1, 1 ],
    [ A4, A4 ]
*], [*
    [ -1, -1, -1 ],
    [ A5, A5, infinite ]
*] ]

> HasInfinitePSL2Quotient(G : Full := true, Signs := [-1,1,0]);
true
[ [*
    [ -1, 1, 1 ],
    [ A4, A4 ]
*], [*
    [ -1, 1, -1 ],
    [ A5, A5, infinite ]
*] ]

> G := quo<F | [F.1^2 ,F.2^3, (F.1*F.2)^5]>;
> HasInfinitePSL2Quotient(G);
false
> HasInfinitePSL2Quotient(G : Full := true, Signs := [-1,1,0]);
false
[ [*
    [ -1, 1, 1 ],
    [ A5 ]
*], [*
    [ -1, 1, -1 ],
    [ A5 ]
*] ]

> G := FPGroup< a,b | a^2, b^3, (a*b)^11, (a,b)^11 >;
> L3Quotients(G);
[
    U_3(43)
]
> H := FPGroup< a,b | a^2, b^3, (a*b)^11, (a,b)^28  >;
> Q := L3Quotients(H); Q;
[
    U_3(43),
    U_3(14057)
] 

> M := GetMatrices(Q[1]); M;
MatrixGroup(3, GF(43^2))
Generators:
  [ $.1^756  $.1^202       38]
  [ $.1^960 $.1^1243  $.1^934]
  [ $.1^192  $.1^192 $.1^1529]

  [ $.1^379 $.1^1759  $.1^503]
  [$.1^1326  $.1^804  $.1^374]
  [$.1^1214  $.1^524  $.1^612]

> G := FPGroup< a,b | a^2, b^3, (a*b)^18, (a,b)^16  >;
> L3Quotients(G); 
[
    PGU(3, 71),
    U_3(1889),
    PGU(3, 17),
    PGU(3, 17),
    PGU(3, 17),
    PGL(3, 19)
]

> G := FPGroup< a, b | a^2, b^3, (a*b)^9 >;
> QG := L3Quotients(G); QG;
[
    L_3(infty^18)
]
> H := FPGroup< a, b | a^2, b^3, (a,b)^5, (a, b*a*b*a*b)^3 >;
> L3Quotients(H);
[
    L_3(2^infty)
]
> K := FPGroup< a, b | a^2, b^3 >;
> L3Quotients(K);
[
    L_3(infty^(inft ^2))
]

> SpecifyCharacteristic(QG[1], 37);
[
  PGL(3, 37),
  PGL(3, 37),
  PGL(3, 37)
]
> X := SpecifyCharacteristic(QG[1], 2); X;
[
  PGU(3, 2^3)
]
> M := GetMatrices(X[1]);
> M:Minimal;
MatrixGroup(3, GF(2^18))
> LMGChiefFactors(M);
  G
  |  Cyclic(3)
  *
  |  2A(2, 8)                   = U(3, 8)
  *
  |  Cyclic(3)
  1

> H< a, b > := FPGroup< a, b | a^2, b^3, (a,b)^5, (a, b*a*b*a*b)^3 >;
> quot := L3Quotients(H); quot;
[
    L_3(2^infty)
]
> Q := quot[1];
> AddGroupRelations(Q, [(a*b)^(2*3*5*7)]);      
[
    PGL(3, 2^2),
    U_3(2^2)
]

> Q := quot[1];
> Q`Ideal;
Ideal of Graded Polynomial ring of rank 10 over Integer Ring
Order: Grevlex with weights [8, 2, 2, 2, 2, 4, 4, 4, 4, 1]
Variables: xcom, x1, xm1, x2, xm2, x12, xm12, xm21, xm2m1, zeta
Variable weights: [8, 2, 2, 2, 2, 4, 4, 4, 4, 1]
Inhomogeneous, Dimension >0
Groebner basis:
[
    xcom + zeta + 1,
    xm12*xm2m1 + zeta,
    x12 + xm12,
    xm21 + xm2m1,
    x1 + 1,
    xm1 + 1,
    x2,
    xm2,
    zeta^2 + zeta + 1,
    2
]
> R< xcom, x1, xm1, x2, xm2, x12, xm12, xm21, xm2m1, zeta > := Generic(Q`Ideal);
> AddRingRelations(Q, [x12^5 + xm21^2 + 1]);
[
    L_3(2^8),
    L_3(2^6)
]