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

Simplification

Subsections

Reducing Generating Sets

Subgroups of finitely presented groups constructed in certain ways may be created with a generating set containing redundant generators. The most important case in which this situation may occur is a subgroup of the domain of a homomorphism f of groups, defined as the preimage under f of some given subgroup of the codomain of f. In this case, the generating set of the preimage will contain generators of the kernel of f and is likely to be not minimal.

Since reducing the generating set may be expensive and is not necessary in all situations, a reduction is not done automatically. Instead, Magma provides a function for reducing generating sets of finitely presented groups.

ReduceGenerators(G) : GrpFP -> GrpFP, Map
Given a finitely presented group G, attempt to construct a presentation H on fewer generators. H is returned as a subgroup of G (which of course is equal to G), so that element coerce is possible. The isomorphism from G to H is returned as second return value.

If a presentation for G is known, this function attempts to simplify this presentation (cf. section Tietze Transformations). Otherwise, it tries to rewrite G with respect to a suitable supergroup to obtain a presentation on fewer generators.

For a sample application of this function, see Example H70E73.

Tietze Transformations

Given a finitely presented group G, the user can attempt to simplify its presentation using Tietze transformations and substring searching. The choice of simplification strategy can either be left to Magma or selected by the user.

The strategy employed by the function Simplify can be controlled using the following set of parameters.

var Preserve: [RngIntElt] Default: []

This parameter can be used to indicate that certain generators of G should not be eliminated (default: no restrictions). Preserve is assigned a sequence of integers in the range [1, ..., n], where n is the number of generators of G, containing the numbers of those generators of G which should be preserved. See Example H70E70 for a sample application.

var Iterations: RngIntElt Default: 10000

This parameter sets the maximal number of iterations of the main elimination / simplification cycle which will be performed.

var EliminationLimit: RngIntElt Default: 100

This parameter sets the maximal number of generators which may be eliminated in each elimination phase.

var LengthLimit: RngIntElt Default: ∞

If LengthLimit is set to n, any eliminations which would make the total length of the relators grow beyond n will not be performed (default: no limit).

var ExpandLimit: RngIntElt Default: 150

If ExpandLimit is set to n, the total length of the relators is not permitted to grow by more than a factor of n% in any elimination phase (default: 150%). If this limit is reached, the elimination phase is aborted.

var GeneratorsLimit: RngIntElt Default: 0

Any eliminations which would reduce the number of generators below the value of GeneratorsLimit will not be performed (default: 0).

var SaveLimit: RngIntElt Default: 10

If SaveLimit is set to n, any simplification phase is repeated, if the reduction in the total length of the relators achieved during this phase exceeds n% (default: 10%).

var SearchSimultaneous: RngIntElt Default: 20

This parameter sets the number of relators processed simultaneously in a simplification phase.

var Print: RngIntElt Default: 0

This parameter controls the volume of printing. By default its value is that returned by GetVerbose("Tietze"), which is 0 unless it has been changed through use of SetVerbose.

Simplify(G: parameters) : GrpFP -> GrpFP, Map
Given a finitely presented group G, attempt to simplify the presentation of G by repeatedly eliminating generators and subsequently shortening relators by substitution of substrings that correspond to the left or right hand side of a relation. The order in which transformations are applied is determined by a set of heuristics. The transformation process terminates when no more eliminations of generators and no more length reducing substring replacements are possible.

A new group K isomorphic to G is returned which is (hopefully) defined by a simpler presentation than G. K is returned as a subgroup of G. The isomorphism f:G -> K is returned as second return value.

The simplification process can be controlled by a set of parameters described below.


Example GrpFP_1_Simplify1 (H70E68)

Consider the Fibonacci group $F(8)$.
> F<x1, x2, x3, x4, x5, x6, x7, x8> := FreeGroup(8);
> F8<x1, x2, x3, x4, x5, x6, x7, x8> := 
>     quo< F | x1*x2=x3, x2*x3=x4, x3*x4=x5, x4*x5=x6,
>              x5*x6=x7, x6*x7=x8, x7*x8=x1, x8*x1=x2>;
We use the function Simplify in order to obtain a presentation of F(8) on two generators.

> H<[y]>, f := Simplify(F8);
> H;
Finitely presented group H on 2 generators
Generators as words in group F8
    y[1] = x3
    y[2] = x4
Relations
    y[2] * y[1]^-2 * y[2] * y[1]^-1 * y[2]^2 * y[1] * y[2]^2 * 
       y[1]^-1 = Id(H)
    y[1] * y[2] * y[1] * y[2]^2 * y[1] * y[2] * y[1]^2 * y[2]^-1 
       * y[1] = Id(H)
The isomorphism f can be used to express the old generators in terms of the new ones.

> f;
Mapping from: GrpFP: F8 to GrpFP: H
> f(x1);
y[1]^2 * y[2]^-1

SimplifyLength(G: parameters) : GrpFP -> GrpFP, Map
Given a finitely presented group G, attempt to eliminate generators and shorten relators by locating substrings that correspond to the left or right hand side of a relation. The order in which transformations are applied is determined by a set of heuristics. As opposed to the function Simplify, this function terminates the transformation process when the total length of the presentation starts to increase with the elimination of further generators.

A new group K isomorphic to G is returned which is (hopefully) defined by a simpler presentation than G. K is returned as a subgroup of G. The isomorphism f:G -> K is returned as second return value. This function accepts the same set of parameters as the function Simplify.

TietzeProcess(G: parameters) : GrpFP -> Process(Tietze)
Create a Tietze process that takes the presentation for the fp-group G as its starting point. This process may now be manipulated by various procedures that will be described below.

     Preserve: [RngIntElt]               Default: []

     Iterations: RngIntElt               Default: 10000

     EliminationLimit: RngIntElt         Default: 100

     LengthLimit: RngIntElt              Default: ∞

     ExpandLimit: RngIntElt              Default: 150

     GeneratorsLimit: RngIntElt          Default: 0

     SaveLimit: RngIntElt                Default: 10

     SearchSimultaneous: RngIntElt       Default: 20

     Print: RngIntElt                    Default: 0

These parameters define the defaults used for the Tietze operations. Each of the various procedures described below allows some or all of these control parameters to be overridden.

For the meanings of the parameters, see the description under Simplify above.

ShowOptions(~P : parameters) : GrpFPTietzeProc ->
Display the defaults associated with the Tietze process P. The current status of all the control parameters may be viewed by using this function.
SetOptions(~P : parameters) : GrpFPTietzeProc ->
Change the defaults associated with the Tietze process P. All of the control parameters may be overridden permanently by using this function.
Simplify(~P : parameters) : GrpFPTietzeProc ->
SimplifyPresentation(~P : parameters) : GrpFPTietzeProc ->
Use the default strategy to simplify the presentation as much as possible. The transformation process is terminated when no more eliminations of generators and no more length reducing substring replacements are possible. All the control parameters may be overridden for this function.
SimplifyLength(~P : parameters) : GrpFPTietzeProc ->
Use the default strategy to simplify the presentation as much as possible. The transformation process is terminated when the total length of the presentation starts to increase with the elimination of further generators. All the control parameters may be overridden for this function.
Eliminate(~P: parameters) : GrpFPTietzeProc ->
EliminateGenerators(~P: parameters) : GrpFPTietzeProc ->
Eliminate generators in the presentation defined by the Tietze process P under the control of the parameters. First any relators of length one are used to eliminate trivial generators. Then, if there are any non-involutory relators of length two, the generator with the higher number is eliminated. Of the control parameters, only EliminationLimit, ExpandLimit, GeneratorsLimit and LengthLimit may be overridden by this function.

     Relator: RngIntElt                  Default: 0

If n > 0, try to eliminate a generator using the n-th relator. If no generator is specified by the parameter Generator below, then the generator which is eliminated will be the one occurring once in the relator that produced the smallest total relator length.

     Generator: RngIntElt                Default: 0

If n > 0, try to eliminate the n-th generator. If no relation is specified by the parameter Relator above, then the shortest relator in which the n-th generator occurs exactly once (if any) is used.

Search(~P: parameters) : GrpFPTietzeProc ->
Simplifies the presentation by repeatedly searching for common substrings in pairs of relators where the length of the substring is greater than half the length of the shorter relator and making the corresponding transformations. Relators of length 1 or 2 are also used to generate simplifications. The control parameters SaveLimit and SearchSimultaneous can be overridden.
SearchEqual(~P: parameters) : GrpFPTietzeProc ->
Modifies the presentation by repeatedly searching for common substrings in pairs of relators where the length of the substring is exactly half the length of the shorter relator and making the corresponding transformations. The control parameter SearchSimultaneous can be overridden.
Group(P) : GrpFPTietzeProc -> GrpFP, Map
Extract the group G defined by the current presentation associated with the Tietze process P, together with the isomorphism between the original group and G. G is returned as a subgroup of the original group underlying P.
NumberOfGenerators(P) : GrpFPTietzeProc -> RngIntElt
Ngens(P) : GrpFPTietzeProc -> RngIntElt
The number of generators for the presentation currently stored by the Tietze process P.
NumberOfRelations(P) : GrpFPTietzeProc -> RngIntElt
Nrels(P) : GrpFPTietzeProc -> RngIntElt
The number of relations in the presentation currently stored by the Tietze process P.
PresentationLength(P) : GrpFPTietzeProc -> RngIntElt
The sum of the lengths of the relators in the presentation currently stored by the Tietze process P.

Example GrpFP_1_F276 (H70E69)

The Fibonacci group F(n) is generated by { x1, ..., xn } with defining relations xixi + 1 = xi + 2, i ∈{ 1, ..., n }, where the subscripts are taken modulo n. Consider the Fibonacci group F(7), which is defined in terms of the presentation
     <x_1,x_2,x_3,x_4,x_5,x_6,x_7 | x_1x_2=x_3, x_2x_3=x_4, x_3x_4=x_5,
         x_4x_5=x_6, x_5x_6=x_7, x_6x_7=x_1, x_7x_1=x_2>.
The following code will produce a 2-generator, 2-relator presentation for F(7):

> F<x1, x2, x3, x4, x5, x6, x7> := FreeGroup(7);
> F7<x1, x2, x3, x4, x5, x6, x7> := 
>    quo< F | x1*x2=x3, x2*x3=x4, x3*x4=x5, x4*x5=x6,
>             x5*x6=x7, x6*x7=x1, x7*x1=x2 >;
> P := TietzeProcess(F7);
> for i := 7 to 3 by -1 do
>    Eliminate(~P: Generator := i);
> end for;
> Search(~P);
> H<x, y>, f := Group(P);
> H;
Finitely presented group H on 2 generators
Generators as words in group F7
    x = x1
    y = x2
Relations
    x^-1 * y^-1 * x^-1 * y^-2 * x^-1 * y * x^-1 * y * x^-1 = Id(H)
    x * y^3 * x^-1 * y * x^-1 * y^2 * x * y * x * y^-1 = Id(H)
The resulting presentation is <a, b | a - 1b - 1a - 1b - 2a - 1ba - 1ba - 1, ab3a - 1ba - 1b2abab - 1>.

We can use the isomorphism f returned by the function Group to express arbitrary words in the original generators of F(7) in terms of the new generators x and y:

> f;
Mapping from: GrpFP: F7 to GrpFP: H
> f(x7);
x * y^2 * x * y^2 * x * y * x * y^2 * x * y
Alternatively, a similar effect may be obtained using the Simplify function:

> F<x1, x2, x3, x4, x5, x6, x7> := FreeGroup(7);
> F7<x1, x2, x3, x4, x5, x6, x7> := 
>    quo< F | x1*x2=x3, x2*x3=x4, x3*x4=x5, x4*x5=x6,
>       x5*x6=x7, x6*x7=x1, x7*x1=x2>;
> H<x, y>, f := Simplify(F7: Iterations := 5);
> H;
Finitely presented group H on 2 generators
Generators as words in group F7
    x = x2
    y = x3
Relations
    x * y^-1 * x * y^2 * x * y * x^2 * y^-1 = Id(H)
    y * x * y^2 * x^-1 * y * x^-2 * y * x^-2 = Id(H)
Again, we can use the isomorphism f returned by the function Simplify to express arbitrary words in the original generators of F(7) in terms of the new generators x and y:

> f;
Mapping from: GrpFP: F7 to GrpFP: H
> f(x7);
y * x * y * x * y^2 * x * y

Example GrpFP_1_ReduceGeneratingSet (H70E70)

In a situation where some proper subset S of the original generating set of a finitely group G is sufficient to generate G, the function Simplify can also be used to rewrite words in the original generators in terms of the elements of S. Consider again one of the Fibonacci groups, say F(8).

> F<x1, x2, x3, x4, x5, x6, x7, x8> := FreeGroup(8);
> F8<x1, x2, x3, x4, x5, x6, x7, x8> := 
>     quo< F | x1*x2=x3, x2*x3=x4, x3*x4=x5, x4*x5=x6,
>        x5*x6=x7, x6*x7=x8, x7*x8=x1, x8*x1=x2>;
Obviously, F(8) is generated by x1 and x2. We utilise the function Simplify to obtain a presentation H of F(8) on x1 and x2, using the parameter Preserve to indicate that x1 and x2 -- i.e. the first and the second generator -- are to be retained in the new presentation. We also compute the isomorphism f:F(8) -> H.

> H<x, y>, f := Simplify(F8: Preserve := [1,2]);
Mapping elements of F(8) to H using the map f basically means to rewrite these elements in terms of the generators x = x1 and y = x2. Since H is returned as a subgroup of F(8), the resulting words can be coerced from H back into F(8), yielding words explicitly in x1 and x2.

> F8 ! f(x5*x6);
x1 * x2^2 * x1 * x2 * x1^2 * x2^-1 * x1 * x2^-1

Example GrpFP_1_F29 (H70E71)

The finiteness of the last of the Fibonacci groups, F(9), was settled in 1988 by M.F. Newman using the following result:

Theorem. Let G be a group with a finite presentation on b generators and r relations, and suppose p is an odd prime. Let d denote the rank of the elementary abelian group G1 = [G, G]Gp and let e denote the rank of G2 = [G1, G]Gp. If r - b < d2/2 - d/2 - d - e or r - b ≤d2/2 - d/2 - d - e + (e + d/2 - d2/4)d/2, then G has arbitrary large quotients of p-power order.

We present a proof that F(9) is infinite using this result.

> Left := func< b, r | r - b >;
> Right := func< d, e | d^2 div 2 - d div 2 - d - e + 
>                       (e + d div 2 - d^2 div 4)*(d div 2) >;
> 
> 
> F< x1,x2,x3,x4,x5,x6,x7,x8,x9 > := 
>  	Group< x1, x2, x3, x4, x5, x6, x7, x8, x9 | 
>              x1*x2=x3, x2*x3=x4, x3*x4=x5, x4*x5=x6, x5*x6=x7, 
>              x6*x7=x8, x7*x8=x9, x8*x9=x1, x9*x1=x2 >;
>
> F;
Finitely presented group F on 9 generators
Relations
       x1 * x2 = x3
       x2 * x3 = x4
       x3 * x4 = x5
       x4 * x5 = x6
       x5 * x6 = x7
       x6 * x7 = x8
       x7 * x8 = x9
       x8 * x9 = x1
       x9 * x1 = x2

> AbelianQuotientInvariants(F);
[ 2, 38 ]
Thus the nilpotent quotient of F is divisible by 2 and 19. We examine the 2- and 19-quotients of F.

> Q1 := pQuotient(F, 2, 0: Print := 1);
Class limit set to 127.

Lower exponent-2 central series for F

Group: F to lower exponent-2 central class 1 has order 2^2

Group: F to lower exponent-2 central class 2 has order 2^3

Group completed. Lower exponent-2 central class = 2, Order = 2^3
> Q2 := pQuotient(F, 19, 0: Print := 1);
Class limit set to 127.

Lower exponent-19 central series for F

Group: F to lower exponent-19 central class 1 has order 19^1

Group completed. Lower exponent-19 central class = 1, Order = 19^1
Thus, the nilpotent residual of F has index 152. We try to locate this subgroup. We first take a 2-generator presentation for F.

> G := Simplify(F);
> G;
Finitely presented group G on 2 generators
Generators as words in group F
   G.1 = x4
   G.2 = x5
Relations
   G.2 * G.1 * G.2 * G.1 * G.2^2 * G.1 * G.2^2 * G.1^-1 * G.2 * G.1^-2 * G.2 *
      G.1^-2 = Id(G)
   G.1 * G.2^2 * G.1 * G.2 * G.1^2 * G.2^-1 * G.1^2 * G.2^-1 * G.1 * G.2^-1 * 
      G.1^2 * G.2^-1 * G.1 * G.2^-1 = Id(G)
> H := ncl< G | (G.1, G.2) >;
> H;
Finitely presented group H
Index in group G is 76 = 2^2 * 19
Subgroup of group G defined by coset table
We haven't got the full nilpotent residual yet, so we try again.

> H := ncl< G | (G.1*G.1, G.2) >;
> H;
Finitely presented group H
Index in group G is 152 = 2^3 * 19
Subgroup of group G defined by coset table
Now, we have it.

> AbelianQuotientInvariants(H);
[ 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5 ]
The nilpotent residual H has a 5-quotient. We construct a presentation for H and then calculate d and e for its 5-quotient.

> K := Rewrite(G, H: Simplify := false);
> KP := pQuotientProcess(K, 5, 1);
> d := FactoredOrder(ExtractGroup(KP))[1][2];
> NextClass(~KP);
> e := FactoredOrder(ExtractGroup(KP))[1][2] - d;
> "D = ", d, "e = ", e;
d =  18 e =  81
> "Right hand side = ", Right(d, e);
Right hand side =  135
> "Left hand side = ", Left(Ngens(K), #Relations(K));
Left hand side =  151
Since Left is greater than Right, this presentation for H doesn't work. Thus we start eliminating generators.

> K := Simplify(K: Iterations := 1);
> "Left hand side = ", Left(Ngens(K), #Relations(K));
Left hand side =  136
> K := Simplify(K: Iterations := 1);
> "Left hand side = ", Left(Ngens(K), #Relations(K));
Left hand side =  123
Got it! By Newman's theorem, H has an infinite 5-quotient and so F must be infinite.

Example GrpFP_1_L372 (H70E72)

In this example, we consider a -- quite unpleasant -- presentation for some group G. In fact, it is a presentation for the group PSL(3,7):2, but we assume that we do not know this and want to compute the order of the finitely presented group G using coset enumeration.

We note in passing that the strategy outlined in this example is, together with other approaches, applied by the function Order.

> F<a,b,c> := FreeGroup(3);
> rels := [ a^4, b^2, (a,b)^3, (a*b)^8, ((a*b)^2*(a^-1*b)^3)^2, 
>  c^2, (c*a*c*a^2)^2, (c*a)^3*(c*a^-1)^3,
>  c*a*b*c*a^-1*b*a^-1*c*a*b*c*a^2*a*b*a^-1,
>  c*a*b*c*b*a*c*a*c*a^-1*b*c*b*a^-1*c*a^-1,
>  c*a*b*a^-1*c*a*b*a^-1*c*a*b*a^-1*c*a*b*a^-1,
>  c*b*a^2*b*c*b*c*a^2*c*b*c*b*a^2*b,
>  c*a^2*c*b*a*c*b*a*c*b*a*c*a^-1*c*a*b*a^-1,
>  c*a^-1*b*a*c*a^-1*b*a*c*b*a*b*a^2*b*a^-1*b,
>  c*a*b*a^-1*b*c*b*a^-1*b*c*a^-1*b*a*b*a*c*b*c*b,
>  c*a*c*b*a*b*c*a*c*b*a*b*c*a*c*b*a*b,
>  c*b*a^-1*b*c*a^-1*c*a^-1*b*a*b*c*b*c*a^2*b*a*b*a^-1,
>  c*b*a^-1*b*a*b*c*b*a^-1*b*a*b*c*b*a^-1*b*a*b,
>  c*a^2*b*a^-1*b*c*b*c*b*a^-1*b*a*c*b*a^2*b*a^-1*b
> ];
> G<a,b,c> := quo< F | rels >;
As it happens, trying to determine the order of G by enumerating the cosets of the trivial subgroup is quite hard. -- Even the predefined enumeration strategy "Hard" (cf. ToddCoxeter and CosetEnumerationProcess) does not give a finite result.


> time ToddCoxeter(G, sub<G|> : Strategy := "Hard"); 0 Time: 199.620
Of course we could try to increase the workspace for the coset enumeration, but we decide to be more clever. Trying random words in the generators of G, we easily find some subgroup S of G with pretty small index in G.

> S := sub< G | b, c*a*c*b*a*b >;
> time Index(G, S);
114
Time: 0.120
We now have to compute the order of S. In order to be able to do this using coset enumeration, we have to construct a presentation for S by rewriting S w.r.t. G.

> time R := Rewrite(G, S : Simplify := false);
Time: 0.030
However, the presentation obtained by Reidemeister-Schreier rewriting without any simplification is not suitable for coset enumeration: it contains too many generators and its total length is quite high.

> NumberOfGenerators(R);
133
> PresentationLength(R);
14384
An enumeration with the predefined enumeration strategy "Hard" does not produce a finite result. (Note that in consideration of the high total relator length, we select a coset table based enumeration style; cf. CosetEnumerationProcess in Chapter FINITELY PRESENTED GROUPS: ADVANCED.)

> time ToddCoxeter(R, sub<R|> : Strategy := "Hard", Style := "C");
0
Time: 4.330
On the other hand, simplifying the presentation by reducing the number of generators as much as possible is not a good idea either, since the total relator length grows massively.

> time Rs := Simplify(R);
Time: 43.900
> NumberOfGenerators(Rs);
3
> PresentationLength(Rs);
797701
Again, an enumeration with the predefined enumeration strategy "Hard" does not produce a finite result.


> time ToddCoxeter(Rs, sub<Rs|> : Strategy := "Hard", Style := "C"); 0 Time: 22015.849
The best strategy is, to simplify the presentation obtained from the Reidemeister-Schreier procedure by eliminating generators until the total length of the relators starts to grow.

> time Rsl := SimplifyLength(R);
Time: 0.330
> NumberOfGenerators(Rsl);
48
> PresentationLength(Rsl);
7152
A coset enumeration for this presentation produces a finite result in a reasonable amount of time.

> time ToddCoxeter(Rsl, sub<Rsl|> : Strategy := "Hard", Style := "C");
32928
Time: 289.410
This finally proves that G is finite and has order 32928 * 114 = 3753792.
 [Next][Prev] [Right] [Left] [Up] [Index] [Root]

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