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