# 25.44 SolvableQuotient

`SolvableQuotient( G, primes )`

Let G be a finitely presented group and primes a list of primes. `SolvableQuotient` tries to compute the largest finite solvable quotient Q of G, such that the prime decomposition of the order the derived subgroup Q^prime of Q only involves primes occuring in the list primes. The quotient Q is returned as finitely presented group. You can use `AgGroupFpGroup` (see AgGroupFpGroup) to convert the finitely presented group into a polycyclic one.

Note that the commutator factor group of G must be finite.

```    gap> f := FreeGroup( "a", "b", "c", "d" );;
gap> f4 := f / [ f.1^2, f.2^2, f.3^2, f.4^2, f.1*f.2*f.1*f.2*f.1*f.2,
>      f.2*f.3*f.2*f.3*f.2*f.3*f.2*f.3, f.3*f.4*f.3*f.4*f.3*f.4,
>      f.1^-1*f.3^-1*f.1*f.3, f.1^-1*f.4^-1*f.1*f.4,
>      f.2^-1*f.4^-1*f.2*f.4 ];
Group( a, b, c, d )
gap> InfoSQ1 := Ignore;;
gap> g := SolvableQuotient( f4, [3] );
Group( e1, e2, m3, m4 )
gap> Size(AgGroupFpGroup(g));
36
gap> g := SolvableQuotient( f4, [2] );
Group( e1, e2 )
gap> Size(AgGroupFpGroup(g));
4
gap> g := SolvableQuotient( f4, [2,3] );
Group( e1, e2, m3, m4, m5, m6, m7, m8, m9 )
gap> Size(AgGroupFpGroup(g));
1152 ```

Note that the order in which the primes occur in primes is important. If primes is the list [2,3] then in each step `SolvableQuotient` first tries a module over GF(2) and only if this fails a module over GF(3). Whereas if primes is the list [3,2] the function first tries to find a downward extension by a module over GF(3) before considering modules over GF(2).

`SolvableQuotient( G, n )`

Let G be a finitely presented group. `SolvableQuotient` attempts to compute a finite solvable quotient of G of order n.

Note that n must be divisible by the order of the commutator factor group of G, otherwise the function terminates with an error message telling you the order of the commutator factor group.

Note that a warning is printed if there does not exist a solvable quotient of order n. In this case the largest solvable quotient whose order divides n is returned.

Providing the order n or a multiple of the order makes the algorithm run much faster than providing only the primes which should be tested, because it can restrict the dimensions of modules it has to investigate. Thus if the order or a small enough multiple of it is known, `SolvableQuotient` should be called in this way to obtain a power conjugate presentation for the group.

```    gap> f := FreeGroup( "a", "b", "c", "d" );;
gap> f4 := f / [ f.1^2, f.2^2, f.3^2, f.4^2, f.1*f.2*f.1*f.2*f.1*f.2,
>       f.2*f.3*f.2*f.3*f.2*f.3*f.2*f.3, f.3*f.4*f.3*f.4*f.3*f.4,
>       f.1^-1*f.3^-1*f.1*f.3, f.1^-1*f.4^-1*f.1*f.4,
>       f.2^-1*f.4^-1*f.2*f.4 ];;
gap> g := SolvableQuotient( f4, 12 );
Group( e1, e2, m3 )
gap> Size(AgGroupFpGroup(g));
12
gap> g := SolvableQuotient( f4, 24 );
#W  largest quotient has order 2^2*3
Group( e1, e2, m3 )
gap> g := SolvableQuotient( f4, 2 );
Error, commutator factor group is of size 2^2 ```

`SolvableQuotient( G, l )`

If something is already known about the structure of the finite soluble quotient to be constructed then `SolvableQuotient` can be aided in its construction.

l must be a list of lists each of which is a list of integers occurring in pairs p, n.

`SolvableQuotient` first constructs the commutator factor group of G, it then tries to extend this group by modules over GF(p) of dimension at most n where p is a prime occurring in the first list of l. If n is zero no bound on the dimension of the module is imposed. For example, if l is [ [2,0,3,4], [5,0,2,0] ] then `SolvableQuotient` will try to extend the commutator factor group by a module over GF(2). If no such module exists all modules over GF(3) of dimension at most 4 are tested. If neither a GF(2) nor a GF(3) module extend `SolvableQuotient` terminates. Otherwise the algorithm tries to extend this new factor group with a GF(5) and then a GF(2) module.

Note that it is possible to influence the construction even more precisely by using the functions `InitSQ`, `ModulesSQ`, and `NextModuleSQ`. These functions allow you to interactively select the modules. See InitSQ, ModulesSQ, and NextModuleSQ for details.

Note that the ordering inside the lists of l is important. If l is the list [[2,0,3,0]] then `SolvableQuotient` will first try a module over GF(2) and attempt to construct an extension by a module over GF(3) only if the GF(2) extension fails, whereas in the case that l is the list [[3,0,2,0]] the function first attempts to extend with modules over GF(3) and then with modules over GF(2).

```    gap> f := FreeGroup( "a", "b", "c", "d" );;
gap> f4 := f / [ f.1^2, f.2^2, f.3^2, f.4^2, f.1*f.2*f.1*f.2*f.1*f.2,
>       f.2*f.3*f.2*f.3*f.2*f.3*f.2*f.3, f.3*f.4*f.3*f.4*f.3*f.4,
>       f.1^-1*f.3^-1*f.1*f.3, f.1^-1*f.4^-1*f.1*f.4,
>       f.2^-1*f.4^-1*f.2*f.4 ];;
gap> g := SolvableQuotient( f4, [[5,0],[2,0,3,0]] );
Group( e1, e2 )
gap> Size(AgGroupFpGroup(g));
4
gap> g := SolvableQuotient( f4, [[3,0],[2,0]] );
Group( e1, e2, m3, m4, m5, m6, m7, m8, m9 )
gap> Size(AgGroupFpGroup(g));
1152 ```

GAP 3.4.4
April 1997