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

Construction of an FP-Group

An fp-group is normally constructed either by giving a presentation in terms of generators and relations or it is defined to be a subgroup or quotient group of an existing fp-group. However, fp-groups may be also created from finite permutation and matrix groups. Finally, Magma has separate types for a number of families of fp-groups that satisfy a condition such as being polycyclic. Again functions are provided to convert a member of one of these families into a general fp-group.

Subsections

The Quotient Group Constructor

A group with non-trivial relations is constructed as a quotient of an existing group, usually a free group. For convenience, the necessary free group may be constructed in-line.

quo< F | R > : GrpFP, List -> GrpFP, Hom(Grp)
Given an fp-group F, and a set of relations R in the generators of F, construct the quotient G of F by the normal subgroup of F defined by R. The group G is defined by means of a presentation which consists of the relations for F (if any), together with the additional relations defined by the list R.

The expression defining F may be either simply the name of a previously constructed group, or an expression defining an fp-group.

If R is a list then each term of the list is either a word, a relation, a relation list or a subgroup of F.

A word is interpreted as a relator.

A relation consists of a pair of words, separated by `='. (See above.)

A relation list consists of a list of words, where each pair of adjacent words is separated by `=': w1 = w2 = ... = wr. This is interpreted as the set of relations w1 = wr, ..., wr - 1 = wr. Note that the relation list construct is only meaningful in the context of the quo-constructor.

A subgroup H appearing in the list R contributes its generators to the relation set for G, i.e. each generator of H is interpreted as a relator for G.

The group F may be referred to by the special symbol $ in any word appearing to the right of the `|' symbol in the quo-constructor. Also, in the context of the quo-constructor, the identity element (empty word) may be represented by the digit 1.

The function returns:

(a)
The quotient group G;
(b)
The natural homomorphism φ: F -> G.

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.
G / H : GrpFP, GrpFP -> GrpFP
Given a subgroup H of the group G, construct the quotient of G by the normal closure N of H. The quotient is formed by taking the presentation for G and including the generating words of H as additional relators.

Example GrpFP_1_Symmetric1 (H70E5)

The symmetric group of degree 4 may be represented as a two generator group with presentation < a, b | a2, b3, (ab)4 >. Giving the relations as a list of relators, the presentation would be specified as:

>  F<a, b> := FreeGroup(2);
>  G<x, y>, phi := quo< F | a^2, b^3, (a*b)^4 >;
Alternatively, giving the relations as a relations list, the presentation would be specified as:

>  F<a, b> := FreeGroup(2);
>  G<x, y>, phi :=  quo< F | a^2 = b^3 = (a*b)^4 = 1>;
Finally, giving the relations in the form of a set of relations, this presentation would be specified as:

>  F<a, b> := FreeGroup(2);
>  rels := { a^2, b^3, (a*b)^4 };
>  G<x, y>, phi :=  quo< F | rels >;

Example GrpFP_1_Symmetric2 (H70E6)

A group may be defined using the quo-constructor without first assigning a free group. The $ symbol is used to reference the group whose quotient is being formed.

> S4<x, y> := quo< FreeGroup(2) | $.1^2, $.2^3, ($.1*$.2)^4 >;
> S4;
Finitely presented group S4 on 2 generators
Relations
      x^2 = Id(S4)
      y^3 = Id(S4)
      (x * y)^4 = Id(S4)

Example GrpFP_1_Modular (H70E7)

We illustrate the use of the quo-constructor in defining the quotient of a group other than a free group.

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

The FP-Group Constructor

For convenience, a constructor is provided which allows the user to define an fp-group in a single step.

Group< X | R > : List(Var), List(GrpFPRel) -> GrpFP, Hom(Grp)
Given a list X of variables x1, ..., xr, and a list of relations R over these generators, first construct the free group F on the generators x1, ..., xr and then construct the quotient of F corresponding to the normal subgroup of F defined by the relations R.

The syntax for the relations R is the same as for the quo-constructor. The function returns:

(a)
The quotient group G;
(b)
The natural homomorphism φ: F -> G.

Example GrpFP_1_Tetrahedral (H70E8)

We illustrate the Group-constructor by defining the binary tetrahedral group in terms of the presentation < r, s | r3 = s3 = (rs)2 >:

> G<r, s> := Group< r, s | r^3 = s^3 = (r*s)^2 >;

Example GrpFP_1_ThreeInvols (H70E9)

Again, using the Group-constructor, the group < r, s, t | r2, s2, t2, rst = str = trs > would be specified as:

> G<r, s, t> := Group<r, s, t | r^2, s^2, t^2, r*s*t = s*t*r = t*r*s>;

Example GrpFP_1_Coxeter (H70E10)

In our final example we illustrate the use of functions to represent parametrised families of groups. In the notation of Coxeter, the symbol (l, m | n, k) denotes the family of groups having presentation < a, b | al, bm, (a * b)n, (a * b - 1)k >.

> Glmnk := func< l, m, n, k | Group< a, b | a^l, b^m, (a*b)^n, (a*b^-1)^k > >;
> G<a, b> := Glmnk(3, 3, 4, 4);
> G;
Finitely presented group G on 2 generators
Relations
      a^3 = Id(G)
      b^3 = Id(G)
      (a * b)^4 = Id(G)
      (a * b^-1)^4 = Id(G)
> Order(G);
168
> G<a, b> := Glmnk(2, 3, 4, 5);
> G;
Finitely presented group G on 2 generators
Relations
    a^2 = Id(G)
    b^3 = Id(G)
    (a * b)^4 = Id(G)
    (a * b^-1)^5 = Id(G)
> Order(G);
1
Thus (2, 3 | 4, 5 ) is the trivial group.

Construction from a Finite Permutation or Matrix Group

FPGroup(G) : GrpPerm -> GrpFP, Hom(Grp)
FPGroup(G) : GrpMat -> GrpFP, Hom(Grp)
Given a finite group G in category GrpPerm or GrpMat, this function returns a finitely presented group F, isomorphic to G, together with the isomorphism φ: F -> G. The generators of F correspond to the generators of G, so this function can be used to obtain a set of defining relations for the given generating set of G.

It should be noted that this function is only practical for groups of order at most a few million. In the case of much larger permutation groups, an isomorphic fp-group can be constructed using the function FPGroupStrong.

FPGroupStrong(G) : GrpPerm -> GrpFP, Hom(Grp)
PGroupStrong(G) : GrpMat -> GrpFP, Hom(Grp)
Given a finite group G in category GrpPerm or GrpMat, this function returns a finitely presented group F, isomorphic to G, together with the isomorphism φ:F -> G. The generators of F correspond to a set of strong generators of G. If no strong generating set is known for G, one will be constructed.

For a detailed description of this function, in particular for a list of available parameters, we refer to Chapter PERMUTATION GROUPS and Chapter MATRIX GROUPS OVER GENERAL RINGS, respectively.

FPGroupStrong(G, N) : GrpPerm, GrpPerm -> GrpFP, Hom(Grp)
Given a permutation group G and a normal subgroup N of G, this function returns a finitely presented group F, isomorphic to G/N, together with a homomorphism φ:G -> F.

For a detailed description of this function, we refer to Chapter PERMUTATION GROUPS.


Example GrpFP_1_FPGroup1 (H70E11)

We start with defining the alternating group G simeq A5 as a permutation group.

> G := AlternatingGroup(5);
> G;
Permutation group G acting on a set of cardinality 5
Order = 60 = 2^2 * 3 * 5
    (3, 4, 5)
    (1, 2, 3)
Now we create an fp-group F isomorphic to G, using the function FPGroup. The presentation is constructed by computing a set of defining relations for the generators of G, i.e. the generators of the returned fp-group correspond to the generators of G. This defines a homomorphism from F to G, which the function FPGroup returns as second return value.

> F<x,y>, f := FPGroup(G);
> F;
Finitely presented group F on 2 generators
Relations
    x^3 = Id(F)
    y^3 = Id(F)
    (x^-1 * y * x * y)^2 = Id(F)
    (x * y^-1 * x * y)^2 = Id(F)
> f;
Mapping from: GrpFP: F to GrpPerm: G
> f(x);
(3, 4, 5)
> f(y);
(1, 2, 3)
Using the function FPGroupStrong, we now create another fp-group Fs, isomorphic to G, whose generators correspond to a set of strong generators of G.

> Fs<[z]>, fs := FPGroupStrong(G);
> Fs;
Finitely presented group Fs on 3 generators
Relations
    z[1]^-3 = Id(Fs)
    (z[1]^-1 * z[3]^-1)^2 = Id(Fs)
    z[3]^-3 = Id(Fs)
    z[1]^-1 * z[2]^-1 * z[1] * z[3]^-1 * z[2] = Id(Fs)
    z[2]^-3 = Id(Fs)
    (z[3]^-1 * z[2]^-1)^2 = Id(Fs)
> fs;
Mapping from: GrpFP: Fs to GrpPerm: G
Applying the isomorphism fs, we have a look at the strong generating set constructed for G.

> [ fs(z[i]) : i in [1..#z] ];
[
    (3, 4, 5),
    (1, 2, 3),
    (2, 3, 4)
]

Construction of the Standard Presentation for a Coxeter Group

There is a special Magma category GrpPermCox, a subcategory of GrpPerm, for finite Coxeter groups. Here, we describe a function to create from a Coxeter group W a finitely presented group F, isomorphic to W, which is given by the standard Coxeter group presentation. We refer to Chapter COXETER GROUPS.

CoxeterGroup(GrpFP, W) : Cat, GrpFPCox -> GrpFP, Map
CoxeterGroup(GrpFP, W) : Cat, GrpPermCox -> GrpFP, Map
Given a finite Coxeter group W in the category GrpFPCox or GrpPermCox, construct a finitely presented group F isomorphic to W, given by a standard Coxeter presentation. The isomorphism from W to F is returned as second return value. The first argument to this function must be the category GrpFP.

     Local: BoolElt                      Default: false
If the parameter Local is set to true, F is the appropriate subgroup of the FP version of the overgroup of W.

Example GrpFP_1_FPCoxeterGroups (H70E12)

We construct a Coxeter group W of Cartan type C5 and create an isomorphic fp-group F. We can use the isomorphism from W to F to map words in the generators of F to permutation group elements and vice versa.

> W := CoxeterGroup("C5");
> F<[s]>, h := CoxeterGroup(GrpFP, W);
> F;
Finitely presented group F on 5 generators
Relations
    s[3]^2 = Id(F)
    s[2] * s[4] = s[4] * s[2]
    s[1]^2 = Id(F)
    s[1] * s[2] * s[1] = s[2] * s[1] * s[2]
    s[2] * s[5] = s[5] * s[2]
    s[4]^2 = Id(F)
    s[1] * s[3] = s[3] * s[1]
    s[3] * s[4] * s[3] = s[4] * s[3] * s[4]
    s[2]^2 = Id(F)
    s[1] * s[4] = s[4] * s[1]
    s[5]^2 = Id(F)
    (s[4] * s[5])^2 = (s[5] * s[4])^2
    s[3] * s[5] = s[5] * s[3]
    s[1] * s[5] = s[5] * s[1]
    s[2] * s[3] * s[2] = s[3] * s[2] * s[3]
> h;
Mapping from: GrpCox: W to GrpFP: F given by a rule
> h(W.1*W.2);
s[1] * s[2]
> (s[1]*s[2]*s[3]*s[4]) @@ h;      
(1, 39, 4, 3, 2)(5, 13, 19, 23, 25)(6, 36, 35, 8, 7)(9, 16, 21, 
    24, 17)(10, 33, 32, 31, 11)(12, 18, 22, 15, 20)(14, 29, 28, 
    27, 26)(30, 38, 44, 48, 50)(34, 41, 46, 49, 42)(37, 43, 47, 
    40, 45)

Conversion from a Special Form of FP-Group

Groups that satisfy certain properties, such as being abelian or polycyclic, are known to possess presentations with respect to which the word problem is soluble. Specialised categories have been constructed in Magma for several of these, e.g. the categories GrpGPC, GrpPC and GrpAb. The functions described in this section allow a group created in one of the special presentation categories to be recast as an fp-group.

FPGroup(G) : GrpPC -> GrpFP, Hom(Grp)
FPGroup(G) : GrpGPC -> GrpFP, Hom(Grp)
FPGroup(G) : GrpAb -> GrpFP, Hom(Grp)
Given a group G, defined either by a polycyclic group presentation (types GrpPC and GrpGPC) or an abelian group presentation (type GrpAb), return a group H isomorphic to G, together with the isomorphism φ:G -> H. The generators for H will correspond to the generators of G. The effect of this function is to convert a presentation in a special form into a general fp-group presentation.

Example GrpFP_1_FPGroup2 (H70E13)

We illustrate the cast from special forms of fp-groups to the category GrpFP by converting a polycyclic group.

> G := DihedralGroup(GrpGPC, 0);
> G;
GrpGPC : G of infinite order on 2 PC-generators
PC-Relations:
    G.1^2 = Id(G), 
    G.2^G.1 = G.-2
> F := FPGroup(G);
> F;
Finitely presented group F on 2 generators
Relations
    F.1^2 = Id(F)
    F.2^F.1 = F.2^-1
    F.1^-1 * F.2^-1 * F.1 = F.2

Construction of a Standard Group

A number of functions are provided which construct presentations for various standard groups.

AbelianGroup(GrpFP, [n1,...,nr]): Cat, [ RngIntElt ] -> GrpFP
Construct the abelian group defined by the sequence [n1, ..., nr] of non-negative integers as an fp-group. The function returns the direct product of cyclic groups Cn1 x Cn2 x ... x Cnr, where C0 is interpreted as an infinite cyclic group.
AlternatingGroup(GrpFP, n) : Cat, RngIntElt -> GrpFP
Alt(GrpFP, n) : Cat, RngIntElt -> GrpFP
Construct the alternating group of degree n as an fp-group, where the generators correspond to the permutations (3, 4, ... , n) and (1, 2, 3), for n odd, or (1, 2)(3, 4, ..., n) and (1, 2, 3), for n even.
BraidGroup(GrpFP, n) : Cat, RngIntElt -> GrpFP
Construct the braid group on n strings (n - 1 Artin generators) as an fp-group.
CoxeterGroup(GrpFP, t) : Cat, MonStgElt -> GrpFP
Construct the Coxeter group of Cartan type t as a finitely presented group, given by the standard Coxeter presentation. The Cartan type t is passed to this function as a string; we refer to Chapter ROOT DATA for details.

CyclicGroup(GrpFP, n) : Cat, RngIntElt -> GrpFP
Construct the cyclic group of order n as an fp-group.
DihedralGroup(GrpFP, n) : Cat, RngIntElt -> GrpFP
For n > 2, return the dihedral group of order 2n as an fp-group. For n=0, return the infinite dihedral group as an fp-group.
ExtraSpecialGroup(GrpFP, p, n : parameters) : Cat, RngIntElt, RngIntElt -> GrpFP
Given a small prime p and a small positive integer n, construct an extra-special group G of order p2n + 1 in the category GrpFP. The isomorphism type of G can be selected using the parameter Type.

     Type: MonStgElt                     Default: "+"
Possible values for this parameter are "+" (default) and "-".

If Type is set to "+", the function returns for p = 2 the central product of n copies of the dihedral group of order 8, and for p > 2 it returns the unique extra-special group of order p2n + 1 and exponent p.

If Type is set to "-", the function returns for p = 2 the central product of a quaternion group of order 8 and n - 1 copies of the dihedral group of order 8, and for p > 2 it returns the unique extra-special group of order p2n + 1 and exponent p2.

SymmetricGroup(GrpFP, n) : Cat, RngIntElt -> GrpFP
Sym(GrpFP, n) : Cat, RngIntElt -> GrpFP
Construct the symmetric group of degree n as an fp-group, where the generators correspond to the permutations (1, 2, ..., n) and (1, 2).

Example GrpFP_1_StandardGroups (H70E14)

We create the symmetric group Sym(8) as an fp-group:

> S8 := SymmetricGroup(GrpFP, 8);
> S8;
Finitely presented group S8 on 2 generators
Relations
      S8.1^8 = Id(S8)
      S8.2^2 = Id(S8)
      (S8.1 * S8.2)^7 = Id(S8)
      (S8.1^-1 * S8.2 * S8.1 * S8.2)^3 = Id(S8)
      (S8.2 * S8.1^-2 * S8.2 * S8.1^2)^2 = Id(S8)
      (S8.2 * S8.1^-3 * S8.2 * S8.1^3)^2 = Id(S8)
      (S8.2 * S8.1^-4 * S8.2 * S8.1^4)^2 = Id(S8)

We create the Coxeter group of Cartan type F4 as an fp-group:

> F := CoxeterGroup(GrpFP, "F4");
> F;
Finitely presented group F on 4 generators
Relations
    (F.2 * F.3)^2 = (F.3 * F.2)^2
    F.1^2 = Id(F)
    F.1 * F.3 = F.3 * F.1
    F.2 * F.4 = F.4 * F.2
    F.1 * F.2 * F.1 = F.2 * F.1 * F.2
    F.2^2 = Id(F)
    F.3^2 = Id(F)
    F.3 * F.4 * F.3 = F.4 * F.3 * F.4
    F.4^2 = Id(F)
    F.1 * F.4 = F.4 * F.1

Construction of Extensions

Darstellungsgruppe(G) : GrpFP -> GrpFP
Given an fp-group G, construct a maximal central extension tilde G of G. The group tilde G is created as an fp-group.
DirectProduct(G, H) : GrpFP, GrpFP -> GrpFP
Given two fp-groups G and H, construct the direct product of G and H.
DirectProduct(Q) : [ GrpFP ] -> GrpFP
Given a sequence Q of r fp-groups, construct the direct product Q[1] x ... x Q[r].
FreeProduct(G, H) : GrpFP, GrpFP -> GrpFP
Given two fp-groups G and H, construct the free product of G and H.
FreeProduct(Q) : [ GrpFP ] -> GrpFP
Given a sequence Q of r fp-groups, construct the free product of the groups Q[1], ..., Q[r].

Example GrpFP_1_ControlExtn (H70E15)

We construct a maximal central extension of the following group of order 36.

> G<x1, x2> := Group<x1, x2 | x1^4,(x1*x2^-1)^2,x2^4,(x1*x2)^3>;
> G;

Finitely presented group G on 2 generators
Relations
       x1^4 = Id(G)
       (x1 * x2^-1)^2 = Id(G)
       x2^4 = Id(G)
       (x1 * x2)^3 = Id(G)

> D := Darstellungsgruppe(G);
> D;

Finitely presented group D on 4 generators
Relations
       D.1^4 * D.3^-1 * D.4^2 = Id(D)
       D.1 * D.2^-1 * D.1 * D.2^-1 * D.4 = Id(D)
       D.2^4 = Id(D)
       D.1 * D.2 * D.1 * D.2 * D.1 * D.2 * D.4 = Id(D)
       (D.1, D.3) = Id(D)
       (D.2, D.3) = Id(D)
       (D.1, D.4) = Id(D)
       (D.2, D.4) = Id(D)
       (D.3, D.4) = Id(D)

> Index(D, sub< D | >);
108
Thus, a maximal central extension of G has order 108

Example GrpFP_1_DirectProduct (H70E16)

We create the direct product of the alternating group of degree 5 and the cyclic group of order 2.

> A5 := Group<a, b | a^2, b^3, (a*b)^5 >;
> Z2 := quo< FreeGroup(1) | $.1^2 >;
> G := DirectProduct(A5, Z2);
> G;

Finitely presented group G on 3 generators
Relations
      G.1^2 = Id(G)
      G.2^3 = Id(G)
      (G.1 * G.2)^5 = Id(G)
      G.3^2 = Id(G)
      G.1 * G.3 = G.3 * G.1
      G.2 * G.3 = G.3 * G.2

Accessing the Defining Generators and Relations

The functions in this group provide access to basic information stored for a finitely-presented group G.

G . i : GrpFP, RngIntElt -> GrpFPElt
The i-th defining generator for G. A negative subscript indicates that the inverse of the generator is to be created. G.0 is Identity(G), the empty word in G.
Generators(G) : GrpFP -> { GrpFPElt }
A set containing the generators for the group G.
NumberOfGenerators(G) : GrpFP -> RngIntElt
Ngens(G) : GrpFP -> RngIntElt
The number of generators for the group G.
PresentationLength(G) : GrpFP -> RngIntElt
The total length of the relators for G.
Relations(G) : GrpFP -> [ GrpFPRel ]
A sequence containing the defining relations for G.
 [Next][Prev] [Right] [Left] [Up] [Index] [Root]

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