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

Subgroups

Subsections

Specification of a Subgroup

sub< G | L > : GrpFP, List -> GrpFP
Construct the subgroup H of the fp-group G generated by the words specified by the terms of the generator list L = L1, ..., Lr.

A term Li of the generator list may consist of any of the following objects:

(a)
A word;
(b)
A set or sequence of words;
(c)
A sequence of integers representing a word;
(d)
A set or sequence of sequences of integers representing words;
(e)
A subgroup of an fp-group;
(f)
A set or sequence of subgroups.

The collection of words and groups specified by the list must all belong to the group G and H will be constructed as a subgroup of G.

The generators of H consist of the words specified directly by terms Li together with the stored generating words for any groups specified by terms of Li. Repetitions of an element and occurrences of the identity element are removed (unless H is trivial).

If the sub-constructor is invoked with an empty list L, the trivial subgroup will be constructed.

sub< G | f > : GrpFP, Hom(Grp) -> GrpFP
Given a homomorphism f from G onto a transitive subgroup of Sym(n), construct the subgroup of G which affords this permutation representation.
ncl< G | L > : GrpFP, List -> GrpFP
Construct the subgroup N of the fp-group G as the normal closure of the subgroup H generated by the words specified by the terms of the generator list L.

The possible forms of a term of the generator list are the same as for the sub-constructor.

This constructor may be applied even when H has infinite index in G, provided that its normal closure N has finite index. The subgroup N is obtained by computing the coset table of the trivial subgroup in the group defined by the relations of G together with relators corresponding to the words generating H. For a sample application of this function, see Example H70E17.

This function may require the computation of a coset table. Experienced users can control the behaviour of a possibly invoked coset enumeration with a set of global parameters. These global parameters can be changed using the function SetGlobalTCParameters. For a detailed description of the available parameters and their meanings, we refer to Chapter FINITELY PRESENTED GROUPS: ADVANCED.

ncl<G | f> : GrpFP, Hom(Grp) -> GrpFP
Given a homomorphism f from G onto a transitive subgroup of Sym(n), construct the subgroup of G that is the normal closure of the subgroup K of G which affords this permutation representation.
CommutatorSubgroup(G) : GrpFP -> GrpFP
DerivedSubgroup(G) : GrpFP -> GrpFP
DerivedGroup(G) : GrpFP -> GrpFP
Given an fp-group G, try to construct the derived subgroup Gprime of G as finite index subgroup of G. The construction fails if no presentation for G is known or can be constructed, or if the index of Gprime in G is too large or infinite.

This function may require the computation of a coset table. Experienced users can control the behaviour of a possibly invoked coset enumeration with a set of global parameters. These global parameters can be changed using the function SetGlobalTCParameters. For a detailed description of the available parameters and their meanings, we refer to Chapter FINITELY PRESENTED GROUPS: ADVANCED.


Example GrpFP_1_Subgroups1 (H70E41)

The group (8, 7 | 2, 3) is defined by the presentation < a, b | a8, b7, (ab)2, (a - 1b)3 >, and has a subgroup of index 448 generated by the words a2 and a - 1b:

> G<a, b> := Group<a, b| a^8, b^7, (a * b)^2, (a^-1 * b)^3>;
> G;
Finitely presented group G on 2 generators
Relations
     a^8 = Id(G)
       b^7 = Id(G)
       (a * b)^2 = Id(G)
> H<x, y> := sub< G | a^2, a^-1 * b >;
> H;
Finitely presented group H on 2 generators
Generators as words in group G
      x = a^2
      y = a^-1 * b

Example GrpFP_1_Subgroups2 (H70E42)

Given the group G defined by the presentation

< a, b | a8, b7, (ab)2, (a, b)9 >, there is a homomorphism into Sym(9) defined by

   a -> (2, 4)(3, 5)(6, 7)(8, 9),
   b -> (1, 2, 3)(4, 6, 7)(5, 8, 9)
We construct the subgroup H of G that is the preimage of the stabiliser of the point 1 in G.

> G<a, b> := Group< a, b | a^2, b^3, (a*b)^7, (a, b)^9>;
> T := PermutationGroup< 9 | (2, 4)(3, 5)(6, 7)(8, 9),
>    (1, 2, 3)(4, 6, 7)(5, 8, 9) >;
> f := hom< G -> T | a -> T.1, b ->T.2 >;
> H := sub< G | f >;
> H;
Finitely presented group H
Subgroup of group G defined by coset table
> Index(G, H);
9
Using the function GeneratingWords, we obtain a set of generators for H.

> print GeneratingWords(G, H);
      { a, b^-1 * a * b^3 * a * b, b * a * b * a * b * a * b^-1, 
        b^3, b^-1 * a * b * a * b * a * b, b * a * b^3 * a * b^-1 }

Index of a Subgroup: The Todd- Coxeter Algorithm

This section describes the simplest use of coset enumeration techniques in Magma. Magma also provides interactive facilities for coset enumeration. For information on these more advanced uses, the user is referred to Chapter FINITELY PRESENTED GROUPS: ADVANCED.

The Todd-Coxeter implementation installed in Magma is based on the stand alone coset enumeration programme ACE3 developed by George Havas and Colin Ramsay at the University of Queensland. The reader should consult [CDHW73] and [Hav91] for an explanation of the terminology and a general description of the algorithm. A manual for ACE3 as well as the sources of ACE3 can be found online [Ram].

Experienced users can control the Todd-Coxeter procedures invoked by the functions described in this section with a wide range of parameters. For a complete description of these parameters and their meanings we refer to the manual entry for the function CosetEnumerationProcess in Chapter FINITELY PRESENTED GROUPS: ADVANCED. We just mention briefly the most important ones:

CosetLimit : RngIntElt  Default : 0
If CosetLimit is set to n, where n is a positive integer, then the coset table may have at most n rows. In other words, a maximum of n cosets can be defined at any instant during the enumeration. It is ensured in this case, that enough memory is allocated to store the requested number of cosets, regardless of the value of the parameter Workspace.

If CosetLimit is set to 0 (default), the maximal number of active cosets is determined by the size of the coset table (cf. parameter Workspace) and the number of columns of the coset table (i.e. the number of group generators).

Workspace : RngIntElt  Default : 4000000
The number of words allocated for the coset table. Note that if CosetLimit is set, at least as much memory is allocated as is necessary to store the requested number of cosets.

Strategy : MonStgElt
Using this parameter one of several predefined strategies can be selected. (See the manual entry for the function CosetEnumerationProcess in Chapter FINITELY PRESENTED GROUPS: ADVANCED for a complete list.) The most important values of this parameter are:
"Easy": This selects a combination of parameters, which in situations where an overflow is not expected is likely to produce a result more quickly and using less memory than the default strategy. This strategy will fail for more complicated enumerations.
"Hard": This selects a combination of parameters, which is more likely to produce a finite result for difficult coset enumerations than the default strategy. This strategy will use more memory and enumerations usually will take longer.

The strategy employed by the functions Order and FactoredOrder may involve trying to obtain information on certain subgroups of G. Whether or not an attempt is made to construct a presentation for a subgroup arising in the course of the computation by means of Reidemeister-Schreier rewriting, is controlled by three parameters:

var UseRewrite: BoolElt Default: true var MinIndex: RngIntElt Default: 10 var MaxIndex: RngIntElt Default: 1000 If UseRewrite is set to false, attempts to construct presentations for subgroups are not made. Otherwise, MinIndex and MaxIndex specify for subgroups of which index range Reidemeister-Schreier rewriting is done.

The following strategy is used for trying to determine the order of G.

(1)
Check whether G is free. If so, G is either trivial or infinite.
(2)
Check whether the presentation for G is deficient (i.e. whether the number of relations is smaller than the number of generators). If it is, G is infinite.
(3)
Check the subgroups of G with known order. If such a subgroup is known to be infinite or if we can compute its index in G, we're done.
(4)
Try to compute the index of G in a supergroup of known order. (An infinite supergroup in which G has finite index proves G to be infinite.)
(5)
Try to enumerate the cosets of the trivial subgroup in G.
(6)
Check the subgroups of known or easily computable index in G. If we can compute the order of such a subgroup or prove that it is infinite, we're done.
(7)
Try to enumerate the cosets of some subgroups occurring "naturally" in the presentation of G.
(8)
Check the supergroups in which G has known or easily computable index. If we can compute the order of a supergroup or prove that it is infinite, we're done.
(9)
Try to rewrite G w.r.t. some supergroup and to enumerate the cosets of the trivial subgroup using the resulting presentation.

Steps requiring coset enumeration in G or a supergroup of G are skipped, if no relations are known for this group. Steps involving Reidemeister-Schreier rewriting may be skipped according to the values of the parameters mentioned above.

Experienced users can control the behaviour of coset enumerations which may be invoked by the functions Order and FactoredOrder with a wide range of parameters. Both functions -- in addition to the parameters mentioned above -- accept the same parameters as the function CosetEnumerationProcess described in Chapter FINITELY PRESENTED GROUPS: ADVANCED.

ToddCoxeter(G, H: parameters) : GrpFP, GrpFP -> RngIntElt, Map, RngIntElt, RngIntElt
Given a subgroup H of the fp-group G, this function attempts to build up a coset table of H in G using the Todd-Coxeter procedure.

The first return value is the index of H in G (or 0, if the enumeration fails to complete). The other values returned are the coset table map, the maximum number of simultaneously active cosets, and the total number of cosets defined during the enumeration.

Experienced users can control the Todd-Coxeter procedure invoked by this function with a wide range of parameters. This function accepts the same parameters as the function CosetEnumerationProcess described in Chapter FINITELY PRESENTED GROUPS: ADVANCED.

Index(G, H: parameters) : GrpFP, GrpFP -> RngIntElt
FactoredIndex(G, H: parameters) : GrpFP, GrpFP -> [ <RngIntElt, RngIntElt> ]
Given a subgroup H of the fp-group G, these functions attempt to determine the index of H in G by enumerating the cosets of H using the Todd-Coxeter procedure. The index is returned as a positive integer (Index) or as a sequence of factors (FactoredIndex), respectively. If the coset enumeration fails to complete with a closed coset table, Index returns a value of 0, whereas FactoredIndex reports an error. No conclusion can be drawn in this case.

Experienced users can control the Todd-Coxeter procedure invoked by these functions with a wide range of parameters. Both functions accept the same parameters as the function CosetEnumerationProcess described in Chapter FINITELY PRESENTED GROUPS: ADVANCED.


Example GrpFP_1_Index1 (H70E43)

The classical test example for Todd-Coxeter programmes is the enumeration of the 448 cosets of the subgroup H = <a2, a - 1b> in the group G = <a, b | a8, b7, (ab)2, (a - 1b)3>.

> F<x, y> := FreeGroup(2);
> G<a, b> := quo<F | x^8, y^7, (x*y)^2, (x^-1*y)^3>;
> H := sub<G | a^2,a^-1*b>;
> Index(G, H);
448

Order(G: parameters) : GrpFP -> RngIntElt
FactoredOrder(G: parameters) : GrpFP -> [ <RngIntElt, RngIntElt> ]
Given an fp-group G, this function attempts to determine the order of G or to prove that G is infinite. If a finite order can be computed, the function Order returns the order as a positive integer, whereas the function FactoredOrder returns a sequence of prime power factors. The function FactoredOrder reports an error in all other cases, whereas the function Order returns the object Infinity, if G can be shown to be infinite and returns a value of 0 if neither a finite value for the group order nor a proof for the infinity of G can be obtained. No conclusions can be drawn from a return value 0 of Order.

In addition to the parameters controlling possibly invoked coset enumerations, there exist some other parameters controlling the strategy used by the functions Order and FactoredOrder. These parameters are described below.


Example GrpFP_1_Order11 (H70E44)

We use the function Order without any parameters to compute the order of the group G = <a, b | a8, b7, (ab)2, (a - 1b)3>.

> G<x, y> := Group<x,y | x^8, y^7, (x*y)^2, (x^-1*y)^3>;
> G;
Finitely presented group G on 2 generators
Relations
    x^8 = Id(G)
    y^7 = Id(G)
    (x * y)^2 = Id(G)
    (x^-1 * y)^3 = Id(G)
> Order(G);
10752

Example GrpFP_1_HN (H70E45)

The Harada-Norton simple group has the presentation
     < x, a, b, c, d, e, f, g |  
	 x^2, a^2, b^2, c^2, d^2, e^2, f^2, g^2,
          (x,a), (x,g),
	 (bc)^3, (bd)^2, (be)^2, (bf)^2, (bg)^2,
          (cd)^3, (ce)^2, (cf)^2, (cg)^2,
          (de)^3, (df)^2, (dg)^2,
          (ef)^3, (eg)^2,
          (fg)^3,
          (b, xbx),
          (a, edcb), (a,f)dcbdcd, (ag)^5,
          (cdef, xbx), (b, xcdefx), (cdef, xcdefx) >.
The subgroup generated by x, b, c, d, e, f, g has index 1,140,000. We use the parameter CosetLimit to request a sufficiently large coset table. For the enumeration we choose the predefined strategy Hard with the modification of a complete C-style lookahead (Lookahead := 2).

> HN<x, a, b, c, d, e, f, g> := 
>     Group< x, a, b, c, d, e, f, g |
>              x^2, a^2, b^2, c^2, d^2, e^2, f^2, g^2,
>              (x, a), (x, g),
>              (b*c)^3, (b*d)^2, (b*e)^2, (b*f)^2, (b*g)^2,
>              (c*d)^3, (c*e)^2, (c*f)^2, (c*g)^2,
>              (d*e)^3, (d*f)^2, (d*g)^2,
>              (e*f)^3, (e*g)^2,
>              (f*g)^3,
>              (b, x*b*x), 
>              (a, e*d*c*b), (a, f)*d*c*b*d*c*d, (a*g)^5,
>              (c*d*e*f, x*b*x), (b, x*c*d*e*f*x),
>              (c*d*e*f, x*c*d*e*f*x) 
>           >;
> H := sub<HN | x,b,c,d,e,f,g >; 
> idx := Index(HN, H: Print := true, CosetLimit := 1200000,
>                     Strategy := "Hard", Lookahead := 2);
INDEX = 1140000
 (a=1140000 r=1471 h=1168483 n=1168483;
  l=2945 c=201.17;
  m=1142416 t=1470356)
> idx;
1140000


Example GrpFP_1_Family (H70E46)

We use a function representing a parametrised presentation to determine the order of a collection of groups obtained by systematically varying one relation. We select the predefined coset enumeration strategy Easy for the order computations.

> Grp := func< p, q, r, s | 
> 
>   Group<
>     x, y, z, h, k, a | 
>     x^2, y^2, z^2, (x,y), (y,z), (x,z), h^3, k^3, (h,k), 
>     (x,k), (y,k), (z,k), x^h*y, y^h*z, z^h*x, a^2, a*x*a*y,
>     a*y*a*x, (a,z), (a,k), x^p*y^q*z^r*k^s*(a*h)^2 >
>        >;
> [ < <i,j,k,l>, Order(Grp(i,j,k,l) : Strategy := "Easy") >
> : i, j, k in [0..1], l in [0..2] ];
[ <<0, 0, 0, 0>, 144>, <<0, 0, 1, 0>, 18>, <<0, 1, 0, 0>, 72>, 
  <<0, 1, 1, 0>, 36>, <<1, 0, 0, 0>, 18>, <<1, 0, 1, 0>, 144>,
  <<1, 1, 0, 0>, 36>, <<1, 1, 1, 0>, 72>, <<0, 0, 0, 1>, 144>,
  <<0, 0, 1, 1>, 18>, <<0, 1, 0, 1>, 72>, <<0, 1, 1, 1>, 36>,
  <<1, 0, 0, 1>, 18>, <<1, 0, 1, 1>, 144>, <<1, 1, 0, 1>, 36>,
  <<1, 1, 1, 1>, 72>, <<0, 0, 0, 2>, 144>, <<0, 0, 1, 2>, 18>,
  <<0, 1, 0, 2>, 72>, <<0, 1, 1, 2>, 36>, <<1, 0, 0, 2>, 18>,
  <<1, 0, 1, 2>, 144>, <<1,1, 0, 2>, 36>, <<1, 1, 1, 2>, 72> ]

Implicit Invocation of the Todd- Coxeter Algorithm

Several functions working with finitely presented groups at some point require a coset table of a subgroup and may invoke a coset enumeration indirectly, e.g. the function meet or the function Normaliser. The default behaviour for such implicitly called coset enumerations is the same as the one for coset enumerations invoked explicitly, e.g. using the function ToddCoxeter.

If such an implicitly called coset enumeration fails to produce a closed coset table, the calling function may terminate with a runtime error.

Experienced users can control the behaviour of indirectly invoked coset enumerations with a set of global parameters. These global parameters are valid for all implicitly called coset enumerations. For a detailed description of the available parameters and their meanings, we refer to Chapter FINITELY PRESENTED GROUPS: ADVANCED. Note that coset enumerations which are explicitly invoked, e.g. by a call to the function Index, are not affected by this global set of parameters. Parameters for these functions have to be specified in the function call.

SetGlobalTCParameters(: parameters) : ->
This function sets the parameter values used for indirect invocations of the Todd-Coxeter coset enumeration procedure. The parameters accepted and their default values are the same as for the function CosetEnumerationProcess described in Chapter FINITELY PRESENTED GROUPS: ADVANCED.
UnsetGlobalTCParameters() : ->
This function restores the default values for the parameters used for indirect invocations of the Todd-Coxeter coset enumeration procedure. For a description of the meanings of the parameters and their default values, see CosetEnumerationProcess in Chapter FINITELY PRESENTED GROUPS: ADVANCED.

Example GrpFP_1_ImplicitCosetEnumeration (H70E47)

We consider again the Harada-Norton simple group with the presentation

   < x, a, b, c, d, e, f, g |  
        x^2, a^2, b^2, c^2, d^2, e^2, f^2, g^2,
        (x,a), (x,g),
        (bc)^3, (bd)^2, (be)^2, (bf)^2, (bg)^2,
        (cd)^3, (ce)^2, (cf)^2, (cg)^2,
        (de)^3, (df)^2, (dg)^2,
        (ef)^3, (eg)^2,
        (fg)^3,
        (b, xbx),
        (a, edcb), (a,f)dcbdcd, (ag)^5,
        (cdef, xbx), (b, xcdefx), (cdef, xcdefx) >
and the subgroup H generated by x, b, c, d, e, f, g.

> HN<x, a, b, c, d, e, f, g> := 
>     Group< x, a, b, c, d, e, f, g |
>              x^2, a^2, b^2, c^2, d^2, e^2, f^2, g^2,
>              (x, a), (x, g),
>              (b*c)^3, (b*d)^2, (b*e)^2, (b*f)^2, (b*g)^2,
>              (c*d)^3, (c*e)^2, (c*f)^2, (c*g)^2,
>              (d*e)^3, (d*f)^2, (d*g)^2,
>              (e*f)^3, (e*g)^2,
>              (f*g)^3,
>              (b, x*b*x), 
>              (a, e*d*c*b), (a, f)*d*c*b*d*c*d, (a*g)^5,
>              (c*d*e*f, x*b*x), (b, x*c*d*e*f*x),
>              (c*d*e*f, x*c*d*e*f*x) >;
> H := sub<HN | x,b,c,d,e,f,g >; 
H has index 1,140,000 in HN. Using the default settings, the normaliser of H in HN cannot be computed.


> N := Normaliser(HN, H); >> N := Normaliser(HN, H); ^ Runtime error in 'Normaliser': Coset table is not closed
We change the global parameters for implicitly called coset enumerations and try again.

> SetGlobalTCParameters( : Strategy := "Hard");
> N := Normaliser(HN, H);
With these parameters, the computation works. We see that H is self-normalising in HN.

> Index(HN, N);
1140000
> IsSelfNormalising(HN, H);
true

Constructing a Presentation for a Subgroup

Introduction

Let H be a subgroup of finite index in the finitely presented group G. It frequently happens that it is desirable to construct a set of defining relations for H from those of G. Such a presentation can be obtained either on a set of Schreier generators for H or on the given generators of H using the Reidemeister-Schreier rewriting technique [MKS76], if necessary together with extended coset enumeration [AR84], [HKRR84].

We emphasise that if the user wishes only to determine the structure of the maximal abelian quotient of H, then the function AbelianQuotientInvariants should be used. In this case there is no need to first construct a presentation for H using the Rewrite function described below, since AbelianQuotientInvariants employs a special form of the Reidemeister-Schreier rewriting process which abelianises each relator as soon as it is constructed. Thus, compared to the function Rewrite, the function AbelianQuotientInvariants can be applied to subgroups of much larger index.

Rewriting
Rewrite(G, H : parameters) : GrpFP, GrpFP -> GrpFP, Map
Given a finitely presented group G and a subgroup H having finite index in G, return a group R isomorphic to H with a presentation on (some of) the Schreier generators of H in G. The group R will be created as a subgroup of G and defining relations of R on its generators will be available. Note that the generators of R will, in general, not correspond to the generators of H. The isomorphism from H onto R is returned as second return value.

This function may require the computation of a coset table. Experienced users can control the behaviour of a possibly invoked coset enumeration with a set of global parameters. These global parameters can be changed using the function SetGlobalTCParameters. For a detailed description of the available parameters and their meanings, we refer to Chapter FINITELY PRESENTED GROUPS: ADVANCED.

     Simplify: BoolElt                   Default: true

If this Boolean-valued parameter is given the value true, then the resulting presentation for H will be simplified (default). The function Rewrite returns a finitely presented group that is isomorphic to H. If simplification is requested (by setting Simplify := true) then the simplification procedures are invoked (see next section). These procedures perform a sequence of Tietze transformations which typically result in a considerable simplification of the presentation produced by the rewriting process. Alternatively, the user can set Simplify := false and then perform the simplification directly if desired. (See next section). If simplification is not requested as part of Rewrite, a small amount of simplification is performed on the presentation before it is returned.

     EliminationLimit: RngIntElt         Default: 100

     ExpandLimit: RngIntElt              Default: 150

     GeneratorsLimit: RngIntElt          Default: 0

     LengthLimit: RngIntElt              Default: ∞

     SaveLimit: RngIntElt                Default: 10

     SearchSimultaneous: RngIntElt       Default: 20

     Iterations: RngIntElt               Default: 10000

     Print: RngIntElt                    Default: 0

These parameters control the simplification. See the description of Simplify for an explanation of these parameters.

Rewrite(G, ~H : parameters) : GrpFP, GrpFP ->
Given a finitely presented group G and a subgroup H having finite index in G, compute a defining set of relations for H on the existing generators, using extended coset enumeration and Reidemeister-Schreier rewriting, and change the presentation of H accordingly.

If the computation is successful, defining relations for H on its generators will be available at the end; any previously computed relations of H will be discarded. If the computation is unsuccessful, H is not changed. In any case, both the isomorphism type of H and its embedding into G as a subgroup is preserved by this function.

     Simplify: BoolElt                   Default: true

If this parameter is given the value true (default), then an attempt will be made to simplify the constructed set of relations by substring searches, that is, Tietze transformations not changing any generators. The generating set of H is not modified by this process.

Moreover, the extended coset enumeration can be controlled by a wide range of parameters. The function Rewrite -- in addition to the parameter Simplify -- accepts the same parameters as the function CosetEnumerationProcess described in Chapter FINITELY PRESENTED GROUPS: ADVANCED.


Example GrpFP_1_Rewrite (H70E48)

Starting with the group G defined by < x, y | x2, y3, (xy)12, (xy)6(xy - 1)6 >, we construct a subgroup K of index 3 generated by the words x, yxy - 1 and yxy - 1xy - 1xy. We present the subgroup K, compute its abelian quotient structure and then show that the class 30 2-quotient of K has order 262.

> G<x, y> := Group< x, y | x^2, y^3, (x*y)^12, (x*y)^6*(x*y^-1)^6 >;
> G;

Finitely presented group G on 2 generators
Relations
       x^2 = Id(G)
       y^3 = Id(G)
       (x * y)^12 = Id(G)
       x * y * x * y * x * y * x * y * x * y * x * y * x * y^-1 * x * 
          y^-1 * x * y^-1 * x * y^-1 * x * y^-1 * x * y^-1 = Id(G)

> K := sub< G | x, y*x*y^-1, y*x*y^-1*x*y^-1*x*y >;
> K;
Finitely presented group K on 3 generators
Generators as words in group G
       K.1 = x
       K.2 = y * x * y^-1
       K.3 = y * x * y^-1 * x * y^-1 * x * y
> Index(G, K);
3
> T := Rewrite(G, K);
> T;
Finitely presented group T on 3 generators
Generators as words in group G
    T.1 = x
    T.2 = y * x * y^-1
    T.3 = x^y
Relations
    T.1^2 = Id(T)
    T.2^2 = Id(T)
    T.3^2 = Id(T)
    (T.3 * T.2 * T.1 * T.3 * T.2)^2 = Id(T)
    (T.1 * T.3 * T.2 * T.1 * T.3)^2 = Id(T)
    (T.1 * T.2 * T.1 * T.3 * T.2)^2 = Id(T)
> AbelianQuotientInvariants(T);
[ 2, 2, 2 ]

> Q2 := pQuotient(T, 2, 30);
> FactoredOrder(Q2);
[ <2, 62> ]

Example GrpFP_1_Rewrite2 (H70E49)

In this example we illustrate how the function Rewrite can be used to obtain a presentation of a finitely presented group on a different set of generators.

We start with a presentation of L2(7) on two generators x and y.

> F<x,y> := Group< x, y | x^3 = 1, y^3 = 1, (x*y)^4 = 1,
>                         (y*y^x)^2 = y^x*y >;          
The group is also generated by the elements a = (xy)2 and b = y.

> H<a,b> := sub<F | (x*y)^2, y >;
> Index(F,H);
1
At the moment, no defining relations of H isomorphic to F on the generators a and b are known.

> H;
Finitely presented group H on 2 generators
Index in group F is 1
Generators as words in group F
    a = (x * y)^2
    b = y
We apply the function Rewrite to H as a subgroup of F in order to compute defining relations on the generators a and b.

> Rewrite(F, ~H);
> H;
Finitely presented group H on 2 generators
Index in group F is 1
Generators as words in group F
    a = (x * y)^2
    b = y
Relations
    a^2 = Id(H)
    b^3 = Id(H)
    (a * b)^7 = Id(H)
    (a * b^-1 * a * b)^4 = Id(H)
    (b * a * b^-1 * a * b * a)^4 = Id(H)
The last relation turns out to be redundant; a and b are standard generators for L2(7).

> Order(DeleteRelation(H,5)) eq Order(H);
true

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

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