[Next] [Prev] [Right] [Left] [Up] [Index] [Root]
The Construction of Finitely Presented Groups

The Construction of Finitely Presented Groups

Subsections

Construction of a Free Group

FreeGroup(n) : RngIntElt -> GrpFP
Construct the free group F of rank n, where n is a positive integer.

The i-th generator of F may be referenced by the expression F.i, i = 1, ..., n. Note that a special form of the assignment statement is provided which enables the user to assign names to the generators of F. In this form of assignment, the list of generator names is enclosed within angle brackets and appended to the variable name on the left hand side of the assignment statement: F< v_1, ..., v_n > := FreeGroup(n);


Example GrpFP_Free (H16E1)

The statement

> F := FreeGroup(2);
creates the free group of rank 2. Here the generators may be referenced using the standard names, F.1 and F.2.

The statement

> F<x, y> := FreeGroup(2);
defines F to be the free group of rank 2 and assigns the names x and y to the two generators.

Elementary Operators for Words

Suppose G is an fp-group for which generators have already been defined. This subsection defines the elementary operations on words that are derived from the multiplication and inversion operators. The availability of the operators defined here enables the user to construct an element (word) of G in terms of the generators as follows:

The word operations defined here may be applied either to the words of a free group or the words of a group with non-trivial relations. If such an operator is applied to a group possessing non-trivial relations, only free reduction will be applied to the resulting words.
u * v : GrpFPElt, GrpFPElt -> GrpFPElt
Given words u and v belonging to the same fp-group G, return the product of u and v.
u ^ n : GrpFPElt, RngIntElt -> GrpFPElt
The n-th power of the word u, where n is an integer. When invoked with n = (-1), the function computes the inverse of u. When invoked with n = 0, the function returns the identity element.
u ^ v : GrpFPElt, GrpFPElt -> GrpFPElt
Given words u and v belonging to the same fp-group G, return the conjugate v^(-1) * u * v of the word u by the word v.
(u, v) : GrpFPElt, GrpFPElt -> GrpFPElt
Given words u and v belonging to the same fp-group G, return the commutator u^(-1)v^(-1)uv of the words u and v.
(u_1, ..., u_n) : List(GrpFPElt) -> GrpFPElt
Given the n words u_1, ..., u_n belonging to the same fp-group G, return their commutator. Commutators are left-normed, so that they are evaluated from left to right.
G ! [ i_1, ..., i_s ] : GrpFP, [ RngIntElt ] -> GrpFPElt
Given a group G defined on r generators and a sequence [i_1, ..., i_s] of integers lying in the range [ - r, r], excluding 0, construct the word G.|i_1|^(epsilon_1) * G.|i_2|^(epsilon_2) * ... * G.|i_s|^(epsilon_s) where epsilon_j is +1 if i_j is positive, and -1 if i_j is negative.
Identity(G) : GrpFP -> GrpFPElt
Id(G) : GrpFP -> GrpFPElt
G ! 1 : GrpFP, RngIntElt -> GrpFPElt
Construct the identity element (empty word) for the fp-group G.

Creation and Manipulation of Relations

w_1 = w_2 : GrpFPElt, GrpFPElt -> GrpFPRel
Given words w_1 and w_2 over the generators of an fp-group G, create the relation w_1 = w_2. Note that this relation is not automatically added to the existing set of defining relations R for G. It may be added to R, for example, through use of the quo-constructor (see below).
r[1] : GrpFPRel, RngIntElt -> GrpFPElt
LHS(r) : GrpFPRel -> GrpFPElt
Given a relation r over the generators of G, return the left hand side of the relation r. The object returned is a word over the generators of G.
r[2] : GrpFPRel, RngIntElt -> GrpFPElt
RHS(r) : GrpFPRel -> GrpFPElt
Given a relation r over the generators of G, return the right hand side of the relation r. The object returned is a word over the generators of G.
r[1] = w : GrpFPRel, RngIntElt, GrpFPElt -> GrpFPRel
Redefine the left hand side of the relation r to be the word w.
r[2] = w : GrpFPRel, RngIntElt, GrpFPElt -> GrpFPRel
Redefine the right hand side of the relation r to be the word w.
f(r) : Hom(GrpFP), GrpFPRel -> GrpFPRel
Given a homomorphism of the group G for which r is a relation, return the image of r under f.
[Future release] Closure(r, f) : GrpFPRel, Hom(GrpFP) -> { GrpFPRel }
Given a homomorphism of the group G for which r is a relation, construct the complete set of images of r under f.
Parent(r) : GrpFPRel -> GrpFP
Group over which the relation r is taken.
[Future release] Reduce(w, r) : GrpFPElt, GrpFPRel -> GrpFPElt
Simplify the word w as much as possible by replacing every occurrence of the LHS of r in w by its RHS.
[Future release] Reduce(w, S) : GrpFPElt, [ GrpFPRel ] -> GrpFPElt
[Future release] Reduce(w, S) : GrpFPElt, { GrpFPRel } -> GrpFPElt
Simplify the word w as much as possible by replacing every occurrence of the left hand side of some relation r, contained in the set or sequence of relations S, by its right hand side.

Example GrpFP_Relations (H16E2)

We may define a group and a set of relations as follows:

> F<x, y> := FreeGroup(2);
> rels := { x^2 = y^3, (x*y)^4 = Id(F) } ;

To replace one side of a relation, the easiest way is to reassign the relation. So for example, to replace the relation x^2=y^3 by x^2=y^4, we go:

> r := x^2 = y^3;
> r := LHS(r) = y^4;

Construction of a Quotient: Specification of a Presentation

A group with non-trivial relations is constructed as a quotient of an existing group, possibly 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 `=': w_1 = w_2 = ... = w_r. This is interpreted as the set of relations w_1 = w_r, ..., w_(r - 1) = w_r. 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:

Group< X | R > : List(Var), List(GrpFPRel) -> GrpFP, Hom(Grp)
Given a list X of variables x_1, ..., x_r, and a list of relations R over these generators, first construct the free group F on the generators x_1, ..., x_r 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:

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_Symmetric1 (H16E3)

The symmetric group of degree 4 may be represented as a two generator group with presentation < a, b | a^2, b^3, (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_Symmetric2 (H16E4)

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_Tetrahedral (H16E5)

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

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

Example GrpFP_ThreeInvols (H16E6)

Again, using the Group-constructor, the group < r, s, t | r^2, s^2, t^2, 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_Modular (H16E7)

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

Example GrpFP_Coxeter (H16E8)

In our final example we illustrate the use of functions to represent parametrized families of groups. In the notation of Coxeter, the symbol (l, m | n, k) denotes the family of groups having presentation < a, b | a^l, b^m, (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

Modification of a Presentation

AddGenerator(G) : GrpFP -> GrpFP
Given an fp-group G with presentation < X | R >, create a new fp-group with presentation < X union { z } | R >, where z is a symbol not in X.
AddGenerator(G, w) : GrpFP, GrpFPElt -> GrpFP
Given an fp-group G with presentation < X | R >, and given also a word w in the generators X, create a new fp-group having the presentation < X union { z } | R union { z = w } >, where z is a symbol not in X.
AddRelation(G, r) : GrpFP, GrpFPRel -> GrpFP
Given an fp-group G, and a relation r on the generators of G, create a new fp-group whose presentation consists of the relations of G together with the relation r.
AddRelation(G, g) : GrpFP, GrpFPElt -> GrpFP
Given an fp-group G, and an element g of G, create a new fp-group whose presentation consists of the relations of G together with the relation g=( Id(G)).
AddRelation(G, r, i) : GrpFP, GrpFPRel, RngIntElt -> GrpFP
Given an fp-group G, and a relation r on the generators of G, create a new fp-group which has as its presentation the relations of G together with the relation r inserted after the i-th existing relation of G.
AddRelation(G, g, i) : GrpFP, GrpFPElt, RngIntElt -> GrpFP
Given an fp-group G, and an element g of G, create a new fp-group which has as its presentation the relations of G together with the relation g=( Id(G)) inserted after the i-th existing relation of G.
DeleteGenerator(G, x) : GrpFP, GrpFPElt -> GrpFP
Given an fp-group G with presentation < X | R >, and given also an element z in X, create a new fp-group with presentation < X - {z} | R' >, where the relations R' are obtained from R by deleting all relations containing an occurrence of z.
DeleteRelation(G, r) : GrpFP, GrpFPRel -> GrpFP
Given an fp-group G, which includes the relation r amongst its relations, create a new fp-group which has as its presentation the relations of G with relation r omitted.
DeleteRelation(G, g) : GrpFP, GrpFPElt -> GrpFP
Given an fp-group G, which includes the relation g=( Id(G)) amongst its relations, create a new fp-group which has as its presentation the relations of G with this relation omitted.
DeleteRelation(G, i) : GrpFP, RngIntElt -> GrpFP
Given an fp-group G, create a new fp-group which has as its presentation the relations for G with the i-th relation deleted.
ReplaceRelation(G, s, r) : GrpFP, GrpFPRel, GrpFPRel -> GrpFP
ReplaceRelation(G, h, r) : GrpFP, GrpFPElt, GrpFPRel -> GrpFP
ReplaceRelation(G, s, g) : GrpFP, GrpFPRel, GrpFPElt -> GrpFP
ReplaceRelation(G, h, g) : GrpFP, GrpFPElt, GrpFPElt -> GrpFP
Given an fp-group G, which includes the relation s or h=( Id(G)) amongst its relations, create a new fp-group which has as its presentation the relations for G with the relation s replaced by the relation r or g=( Id(G)).
ReplaceRelation(G, i, r) : GrpFP, RngIntElt, GrpFPRel -> GrpFP
Given an fp-group G and a relation r in the generators of G, create a new fp-group which has as its presentation the relations for G with relation number i replaced by the relation r.
ReplaceRelation(G, i, g) : GrpFP, RngIntElt, GrpFPRel -> GrpFP
Given an fp-group G and an element g of G, create a new fp-group which has as its presentation the relations for G with relation number i replaced by the relation g=( Id(G)).

Example GrpFP_Replace (H16E9)

We use the function ReplaceRelation to vary a particular relation in a presentation. The order of the resulting group together with the index of a particular subgroup is determined.

> G<x,y,z,h,k,a> := 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), (a*h)^2 >;
> for i := 0 to 1 do
>     for j := 0 to 1 do
>         for k := 0 to 1 do
>              for l := 0 to 2 do
>                 rel := G.1^i*G.2^j*G.3^k*G.5^l*(G.6*G.4)^2 = Id(G);
>                 K := ReplaceRelation(G, 21, rel);
>                 print Order(K), Index(K, sub< K | K.6, K.4>);
>             end for;
>         end for;
>     end for;
> end for;

<0, 0, 0, 0> 144 24 <0, 0, 0, 1> 144 8 <0, 0, 0, 2> 144 8 <0, 0, 1, 0> 18 3 <0, 0, 1, 1> 18 1 <0, 0, 1, 2> 18 1 <0, 1, 0, 0> 72 3 <0, 1, 0, 1> 72 1 <0, 1, 0, 2> 72 1 <0, 1, 1, 0> 36 6 <0, 1, 1, 1> 36 2 <0, 1, 1, 2> 36 2 <1, 0, 0, 0> 18 3 <1, 0, 0, 1> 18 1 <1, 0, 0, 2> 18 1 <1, 0, 1, 0> 144 6 <1, 0, 1, 1> 144 2 <1, 0, 1, 2> 144 2 <1, 1, 0, 0> 36 6 <1, 1, 0, 1> 36 2 <1, 1, 0, 2> 36 2 <1, 1, 1, 0> 72 12 <1, 1, 1, 1> 72 4 <1, 1, 1, 2> 72 4


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