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

Homomorphisms

For a general description of homomorphisms, we refer to Chapter MAPPINGS. This section describes some special aspects of homomorphisms the domain of which is a finitely presented group.

Subsections

General Remarks

The kernel of a homomorphism with a domain of type GrpFP can be computed using the function Kernel, if the codomain is of one of the types GrpGPC, GrpPC (cf. Chapter FINITE SOLUBLE GROUPS), GrpAb (cf. Chapter ABELIAN GROUPS), GrpPerm (cf. Chapter PERMUTATION GROUPS), GrpMat (cf. Chapter MATRIX GROUPS OVER GENERAL RINGS), ModAlg or ModGrp (cf. Chapter MODULES OVER AN ALGEBRA), if the image is finite and its order sufficiently small. In this case, a regular permutation representation of the image is constructed and the kernel is created as a subgroup of the domain, defined by a coset table.

The kernel may also be computable, if the codomain is of the type GrpFP, the image is sufficiently small and a presentation for the image is known.

If the kernel of a map can be computed successfully, forming preimages of substructures is possible. An attempt to compute the kernel of a map will be made automatically, if the preimage of a substructure of the codomain is to be computed.

Note, that trying to compute the kernel may be very time and memory consuming; use this feature with care.

Construction of Homomorphisms

hom< P -> G | S > : Struct , Struct -> Map
Returns the homomorphism from the fp-group P to the group G defined by the assignment S. S can be the one of the following:
(i)
A list, sequence or indexed set containing the images of the n generators P.1, ..., P.n of P. Here, the i-th element of S is interpreted as the image of P.i, i.e. the order of the elements in S is important.
(ii)
A list, sequence, enumerated set or indexed set, containing n tuples <xi, yi> or arrow pairs xi - > yi, where xi is a generator of P and yi∈G (i=1, ..., n) and the set {x1, ..., xn} is the full set of generators of P. In this case, yi is assigned as the image of xi, hence the order of the elements in S is not important.

Note, that it is currently not possible to define a homomorphism by assigning images to the elements of an arbitrary generating set of P. It is the user's responsibility to ensure that the arguments passed to the hom-constructor actually yield a well-defined homomorphism. For certain codomain categories, this may be checked using the function IsSatisfied described below.
IsSatisfied(U, E) : { RelElt }, [ GrpElt ] -> BoolElt
IsSatisfied(U, E) : { GrpFPElt }, [ GrpElt ] -> BoolElt
IsSatisfied(U, E) : [ RelElt ], [ GrpElt ] -> BoolElt
IsSatisfied(U, E) : [ GrpFPElt ], [ GrpElt ] -> BoolElt
U is a set or sequence of either words belonging to an n-generator fp-group H or relations over H. E is a sequence of n elements [e1, ..., en] belonging to a group G for which both, multiplication and comparison of elements are possible. Using the mapping H.i -> ei (i = 1, ..., n), we evaluate the relations given by U. If U is a set or sequence of relations, the left and right hand sides of each relation are evaluated and compared for equality. Otherwise, each word in U is evaluated and compared to the identity. If all relations are satisfied, IsSatisfied returns the Boolean value true. On the other hand, if any relation is not satisfied, IsSatisfied returns the value false.

This function may be used to verify the correctness of the definition of a homomorphism from an fp-group to a group in a category for which both, multiplication and comparison of elements are possible.

Accessing Homomorphisms

w @ f : GrpFPElt, Map -> GrpElt
f(w) : Map, GrpFPElt -> GrpElt
Given a homomorphism whose domain is an fp-group G and an element w of G, return the image of w under f as an element of the codomain of f.
H @ f : GrpFP, Map -> Grp
f(H) : Map, GrpFP -> Grp
Given a homomorphism whose domain is an fp-group G and a subgroup H of G, return the image of H under f as a subgroup of the codomain of f.

Some maps do not support images of subgroups.

g @@ f : GrpElt, Map -> GrpFPElt
Given a homomorphism whose domain is an fp-group G and an element g of the image of f, return the preimage of g under f as an element of G.

Some maps do not support inverse images.

H @@ f : Grp, Map -> GrpFP
Given a homomorphism whose domain is an fp-group G and a subgroup H of the image of f, return the preimage of H under f as a subgroup of G.

Some maps do not support inverse images. The inverse image of a subgroup of the codomain can only be computed if the kernel of the homomorphism can be computed, i.e. if the kernel has moderate index in the domain.

Domain(f) : Map -> Grp
The domain of the homomorphism f.
Codomain(f) : Map -> Grp
The codomain of the homomorphism f.
Image(f) : Map -> Grp
The image or range of the homomorphism f as a subgroup of the codomain of f.

Some maps do not support this function.

Kernel(f) : Map -> Grp
The kernel of the homomorphism f as a (normal) subgroup of the domain of f, represented by a coset table.

Some maps do not support this function. The kernel of a homomorphism can only be computed, if it has moderate index in the domain.


Example GrpFP_1_Homomorphism (H70E17)

For arbitrary n>0, the symmetric group of degree n + 1 is an epimorphic image

of the braid group on n generators. In this example, we exhibit this relationship for n=4.

We start with creating the braid group B on 5 strings, i.e. 4 Artin generators.

> B := BraidGroup(GrpFP, 5);
> B;
Finitely presented group B on 4 generators
Relations
    B.1 * B.2 * B.1 = B.2 * B.1 * B.2
    B.1 * B.3 = B.3 * B.1
    B.1 * B.4 = B.4 * B.1
    B.2 * B.3 * B.2 = B.3 * B.2 * B.3
    B.2 * B.4 = B.4 * B.2
    B.3 * B.4 * B.3 = B.4 * B.3 * B.4
In the symmetric group of degree 5, we define 4 transpositions which will be the images of the generators of B.

> S := SymmetricGroup(5);
> imgs := [ S!(1,2), S!(2,3), S!(3,4), S!(4,5) ];
In order to verify that this assignment actually gives rise to a well defined homomorphism, we check whether the potential images satisfy the defining relations of B.

> rels := Relations(B);
> rels;
[ B.1 * B.2 * B.1 = B.2 * B.1 * B.2, B.1 * B.3 = B.3 * B.1,
  B.1 * B.4 = B.4 * B.1, B.2 * B.3 * B.2 = B.3 * B.2 * B.3,
  B.2 * B.4 = B.4 * B.2, B.3 * B.4 * B.3 = B.4 * B.3 * B.4 ]
> IsSatisfied(rels, imgs);
true
They do. So we can define the homomorphism from B to S.

> f := hom< B->S | imgs >;
We see that f is surjective, i.e. S is an epimorphic image of B as claimed above.

> f(B) eq S;
true
We now check the kernel of f.

> Kernel(f);
Finitely presented group
Index in group B is 120 = 2^3 * 3 * 5
Subgroup of group B defined by coset table
Using the function GeneratingWords described later, we can obtain a set of generators of ker(f) as a subgroup of B.

> GeneratingWords(B, Kernel(f));
{ B.2^-2, (B.1 * B.2 * B.3^-1 * B.2^-1 * B.1^-1)^2, B.1^-2,
  (B.3 * B.4^-1 * B.3^-1)^2, (B.2 * B.3^-1 * B.2^-1)^2,
  (B.2 * B.3 * B.4^-1 * B.3^-1 * B.2^-1)^2, B.4^-2,
  (B.1 * B.2^-1 * B.1^-1)^2, B.3^-2,
  (B.1 * B.2 * B.3 * B.4^-1 * B.3^-1 * B.2^-1 * B.1^-1)^2 }
It is easy to see that all generators of ker(f) are conjugates of words of the form gpm2, where g is a generator of B. We check this, using the normal closure constructor ncl described later.

> Kernel(f) eq ncl< B | B.1^2, B.2^2, B.3^2, B.4^2 >;
true
Thus, the braid relations together with the relations B.12, B.22, B.32, B.42 are a set of defining relations for S.

Computing Homomorphisms to Finite Groups

This section describes functions for computing representatives of the classes of homomorphisms from a finitely presented group F to a finite group G modulo a group A of automorphisms of G.

Homomorphisms(F, G, A : parameters) : GrpFP, GrpPerm, GrpPerm -> [ HomGrp ]
Homomorphisms(F, G : parameters) : GrpFP, GrpPerm -> [ HomGrp ]
Given a finitely presented group F and two permutation groups G and A with G triangleleft A, return a sequence containing representatives of the classes of homomorphisms from F to G modulo automorphisms of G induced by elements of A. (That is, two homomorphisms f1, f2 : F -> G are considered equivalent if there exists an element a∈A such that f1(x) = f2(x)a for all x∈F.) The call Homomorphisms(F, G) is equivalent to Homomorphisms(F, G, G).

The function uses a backtrack algorithm testing certain conjugates of representatives of the A-classes in G as possible images of the generators of F.

The following parameters are available for this function.

     Surjective: BoolElt                 Default: true

If this parameter is set to true (default), only epimorphisms are considered.

     Limit: RngIntElt                    Default: 0  (no limit)

If this parameter is set to n, the function terminates after n classes of homomorphisms satisfying the specified conditions have been found. A value of 0 (default) means no limit.

     TimeLimit: RngIntElt                Default: 0  (no limit)

A limit in seconds for the amount of time spent in the backtrack search for homomorphisms. The time spent in initial coset enumerations is not counted towards this limit. A value of 0 (default) means no limit.

     CosetEnumeration: BoolElt           Default: true

If this parameter is set to true (default), a number of short coset enumerations are performed for each generator of F in order to check whether some A-classes in G can be ruled out as possible images for this generator. If a class can be ruled out, the complexity of the backtrack search may be reduced significantly.

In situations where it seems unlikely that classes can be ruled out as possible generator images, experienced users may wish to turn this feature off in order to save the time spent on the coset enumerations.

     CacheCosetAction: BoolElt           Default: true

The value of this parameter indicates whether the actions of A on the cosets of the centralisers of representatives of the A-classes in G are cached during the backtrack search.

Setting this parameter to true (default) results in faster computations and is recommended for normal applications. When computing homomorphisms to large groups with many conjugate classes, this parameter can be set to false in order to reduce memory requirements at the expense of increased computing time.


Example GrpFP_1_Homomorphisms1 (H70E18)

Consider the finitely presented group F := < a, b, c | ac - 1bc - 1aba - 1b, abab - 1c2b - 1, a2b - 1(ca)4cb - 1>.

> F := Group< a,b,c | a*c^-1*b*c^-1*a*b*a^-1*b,
>                     a*b*a*b^-1*c^2*b^-1,
>                     a^2*b^-1*c*a*c*a*c*a*c*a*c*b^-1 >;
We use the function Homomorphisms to prove that F maps onto A5.

> G := Alt(5);
> homs := Homomorphisms(F, G : Limit := 1);
> #homs gt 0;
true

Homomorphisms(F, G, A : parameters) : GrpFP, GrpPC, GrpPC -> [ HomGrp ]
Homomorphisms(F, G : parameters) : GrpFP, GrpPC -> [ HomGrp ]
Given a finitely presented group F and two finite polycyclic groups G and A with G triangleleft A, return a sequence containing representatives of the classes of homomorphisms from F to G modulo automorphisms of G induced by elements of A. (That is, two homomorphisms f1, f2 : F -> G are considered equivalent if there exists an element a∈A such that f1(x) = f2(x)a for all x∈F.) The call Homomorphisms(F, G) is equivalent to Homomorphisms(F, G, G).

The following parameters are available for this function.

     Surjective: BoolElt                 Default: true

If this parameter is set to true (default), only epimorphisms are considered.

     Limit: RngIntElt                    Default: 0  (no limit)

If this parameter is set to n, the function terminates after n classes of homomorphisms satisfying the specified conditions have been found. A value of 0 (default) means no limit.

Computing Homomorphisms to Permutation Groups Interactively

A process version of the algorithm used by Homomorphisms is available for computing homomorphisms one at a time. The functions relevant for this interactive version are described in this section.

HomomorphismsProcess(F, G, A : parameters) : GrpFP, GrpPerm, GrpPerm -> GrpFPHomsProc
HomomorphismsProcess(F, G : parameters) : GrpFP, GrpPerm -> GrpFPHomsProc
Given a finitely presented group F and two permutation groups G and A with G triangleleft A, return a process P for computing representatives of the classes of homomorphisms from F to G modulo automorphisms of G induced by elements of A. (That is, two homomorphisms f1, f2 : F -> G are considered equivalent if there exists an element a∈A such that f1(x) = f2(x)a for all x∈F.) HomomorphismsProcess(F, G) is equivalent to HomomorphismsProcess(F, G, G).

After constructing the process, the search for homomorphisms is started and runs until the first homomorphism is found, the time limit is reached (in which case P is marked as invalid) or the search is completed without finding a homomorphism (in which case P is marked as empty).

The parameters have the same meaning as for the function Homomorphisms.

     Surjective: BoolElt                 Default: true

     Limit: RngIntElt                    Default: 0  (no limit)

     TimeLimit: RngIntElt                Default: 0  (no limit)

     CosetEnumeration: BoolElt           Default: true

     CacheCosetAction: BoolElt           Default: true

Setting a time limit for a process P limits the total amount of time spent in the backtrack search for homomorphisms during the construction of P and in subsequent calls to NextElement and Complete. The time spent in initial coset enumerations is not counted towards this limit.

If the time limit or the limit on the number of homomorphisms set for a process P is reached, P becomes invalid. Calling NextElement or Complete for an invalid process or for a process which is empty, that is, which has found all possible classes of homomorphisms, will cause a runtime error. The functions IsValid and IsEmpty can be used to check whether a process is valid or empty, respectively. The use of these functions is recommended to avoid runtime errors in loops or user written functions.

NextElement(~P) : GrpFPHomsProc ->
Given a valid and non-empty process P, continue the backtrack search until a new class of homomorphisms is found. If the search completes without a new representative being found, P is marked as empty. If a limit set for P is reached, P is marked as invalid.
Complete(~P) : GrpFPHomsProc ->
Given a valid and non-empty process P, continue the search for homomorphisms until all classes of homomorphisms have been found or a limit set for P is reached. If the search for homomorphisms completes, P is marked as empty. If a limit set for P is reached, P is marked as invalid.
IsEmpty(P) : GrpFPHomsProc -> BoolElt
Returns whether P is empty, that is, whether all possible classes of homomorphisms have been found.
IsValid(P) : GrpFPHomsProc -> BoolElt
Returns false if a limit set for P has been reached and true otherwise. Note that the return value of IsValid is not related to whether or not P currently defines a homomorphism.
DefinesHomomorphism(P) : GrpFPHomsProc -> BoolElt
Returns whether P currently defines a homomorphism which can be extracted using the function Homomorphism.
Homomorphism(P) : GrpFPHomsProc -> HomGrp
Given a process P which defines a homomorphism, return this homomorphism, that is, the homomorphism most recently found by P. If P does not define a homomorphism, a runtime error will result. The function DefinesHomomorphism can be used to test whether a call to Homomorphism is legal for a process.
# P : GrpFPHomsProc -> RngIntElt
Return the number of homomorphisms that have been found by the process P.
Homomorphisms(P) : GrpFPHomsProc -> [ HomGrp ]
Return a sequence containing all homomorphisms that have been found by the process P. Note that the sequence will only contain a complete set of representatives of the classes of homomorphisms if P is empty, that is, if the backtrack search for P has been completed.

Example GrpFP_1_Homomorphisms2 (H70E19)

Consider the braid group B on 4 strings.

We show how the interactive computation of homomorphisms can be used to determine a homomorphism f: B -> PSL(2, 16) whose image is a maximal subgroup of PSL(2, 16).

Note how the functions IsValid, IsEmpty and DefinesHomomorphism are used to avoid runtime errors in the while loop.

> B := BraidGroup(GrpFP, 4);
> G := PSL(2,16);
> P := HomomorphismsProcess(B, G : Surjective := false,
>                                  TimeLimit := 10);
> while not IsEmpty(P) do
>    if DefinesHomomorphism(P) then
>       f := Homomorphism(P);
>       img := Image(f);
>       if IsMaximal(G,img) then
>          print "found image which is maximal subgroup";
>          break;
>       end if;
>    end if;
>    if IsValid(P) then
>       NextElement(~P);
>     else
>       print "Limit has been reached";
>       break;
>    end if;
> end while;
found image which is maximal subgroup
> 
> f;
Homomorphism of GrpFP: B into GrpPerm: G, induced by
  B.1 |--> (1, 4, 3, 6, 12)(2, 11, 9, 16, 7)(5, 17, 8, 15, 13)
  B.2 |--> (1, 4, 2, 10, 16)(3, 11, 9, 12, 14)(5, 15, 8, 13, 17)
  B.3 |--> (1, 4, 3, 6, 12)(2, 11, 9, 16, 7)(5, 17, 8, 15, 13)

Example GrpFP_1_Homomorphisms2-2 (H70E20)

This example sketches how the interactive version of the homomorphism algorithm could be used as part of a function trying to prove that a group is infinite.

Note again how the functions IsValid, IsEmpty and DefinesHomomorphism are used to avoid runtime errors.

> function MyIsInfinite(F)
> 
>  // ...
> 
>  // quotient approach: check whether an obviously infinite
>  //    normal subgroup can be found in reasonable time.
>  S := [ Alt(5), PSL(2,7), PSL(2,9), PSL(2,11) ];
>  for G in S do
>     P := HomomorphismsProcess(F, G : Surjective := false,
>                                      TimeLimit := 5);
>     while IsValid(P) and not IsEmpty(P) do
>       if DefinesHomomorphism(P) then
>          f := Homomorphism(P);
>          if 0 in AQInvariants(Kernel(f)) then
>             print "found infinite normal subgroup";
>             print "Hence group is infinite";
>             return true;
>          end if;
>       end if;
>       if IsValid(P) then
>          NextElement(~P);
>       end if;
>    end while;
>  end for;
>  print "quotient approach failed; trying other strategies";
> 
>  // ...
> 
> end function;
We try the code fragment on the group < a, b | ab - 1a - 1ba - 1b - 1abb, ab - 1a - 1baaba - 1b - 1ab - 1a - 1baba - 1b - 1 >.

> F := Group< a,b |
>    a*b^-1*a^-1*b*a^-1*b^-1*a*b*b,
>    a*b^-1*a^-1*b*a*a*b*a^-1*b^-1*a*b^-1*a^-1*b*a*b*a^-1*b^-1 >;
> MyIsInfinite(F);
found infinite normal subgroup
Hence group is infinite
true

Finding Homomorphisms onto Simple Groups

We describe utilities for finding homomorphisms onto simple groups. As in the previous example, this may be useful when the presentation defines a perfect group. The methods used are similar to the example, with a list of simple groups to try, and using the function Homomorphisms.

The list of simple groups supplied in V2.10 contains all non-abelian simple groups with order ≤109. Such a list is dominated by PSL(2, q)'s with q odd. In this implementation these PSL(2, q)'s are treated as an infinite family rather than stored individually, and so continue beyond the above limit.

SimpleQuotients(F, deg1, deg2, ord1, ord2: parameters) : GrpFP, RngIntElt, RngIntElt, RngIntElt, RngIntElt -> List
SimpleQuotients(F, ord1, ord2: parameters) : GrpFP, RngIntElt, RngIntElt -> List
SimpleQuotients(F, ord2: parameters) : GrpFP, RngIntElt -> List
    Family: Any                         Default: "All"
    Limit: RngIntElt                    Default: 1
    HomLimit: RngIntElt                 Default: 0
Uses Homomorphisms to find epimorphisms from F onto simple groups in a fixed list. The arguments deg1 and deg2 are respectively lower and upper bounds for the degree of the image group. If the degree arguments are not present then bounds of 5 and 107 are used. The arguments ord1 and ord2 are respectively lower and upper bounds for the orders of the image group. (Setting ord2 low enough is particularly important if a quick search is wanted.) If ord1 is not given then it defaults to 1.

The return value is a list of sequences of epimorphisms found. Each sequence contains epimorphisms onto one simple group. The parameter Limit limits the number of successful searches to be carried out by Homomorphisms. The default value is 1, so by default the search terminates with the first simple group found to be a homomorphic image of F.

The parameter HomLimit limits the number of homomorphisms that will be searched for by any particular call to Homomorphisms. It defaults to zero, so that all homomorphisms for any group found will be returned.

The parameter Family selects sublists of the main list to search. Possible values of this parameter are "All", "PSL", "PSL2", "Mathieu", "Alt", "PSp", "PSU", "Other", and "notPSL2"; sets of these strings are also allowed, which searches on the union of the appropriate sublists.

SimpleQuotientProcess(F, deg1, deg2, ord1, ord2: parameters) : GrpFP, RngIntElt, RngIntElt, RngIntElt, RngIntElt -> Rec
    Family: Any                         Default: "All"
Produce a record that defines a process for searching for simple quotients of F as SimpleQuotients does. Calling this function sets up the record and conducts the initial search until a quotient is found. Continuing the search for another quotient is done by calling NextSimpleQuotient. Extracting the epimorphisms found is achieved using SimpleEpimorphisms, and testing if the process has expired is the task of IsEmptySimpleQuotientProcess.
NextSimpleQuotient(~P) : Rec ->
When P is a record returned by SimpleQuotientProcess, advance the search to the next simple group which is a homomorphic image of the finitely presented group. Does nothing if the process has expired.
IsEmptySimpleQuotientProcess(P) : Rec -> BoolElt
When P is a record returned by SimpleQuotientProcess, test whether or not P has expired.
SimpleEpimorphisms(P) : Rec -> SeqEnum, Tup
When P is a record returned by SimpleQuotientProcess, extract the most recently found epimorphisms onto a simple group, plus a tuple describing the image group. This is a valid operation when IsEmptySimpleQuotientProcess returns false.

Example GrpFP_1_SimpleQuotients (H70E21)

We take a perfect finitely presented group and search for simple quotients.

> F := Group<a,b,c|a^13,b^3,c^2,a = b*c>;
> IsPerfect(F);
true
> L := SimpleQuotients(F,1, 100, 2, 10^5:Limit := 2);
> #L;
2
> for x in L do CompositionFactors(Image(x[1])); end for;
    G
    |  A(1, 13)               = L(2, 13)
    1
    G
    |  A(2, 3)                = L(3, 3)
    1
> L[2,1];
Homomorphism of GrpFP: F into GrpPerm: $, Degree 13, Order 
2^4 * 3^3 * 13 induced by
F.1 |--> (1, 10, 4, 5, 11, 8, 3, 6, 7, 12, 9, 13, 2)
F.2 |--> (2, 10, 4)(3, 6, 7)(5, 11, 13)(8, 12, 9)
F.3 |--> (1, 10)(2, 5)(3, 12)(8, 13)
> #L[2];
2
We've found L(2,13) and L(3,3) as images, with 2 inequivalent homomorphisms onto the second. We'll try a process looking through a smaller family.

> P := SimpleQuotientProcess(F,1, 100, 2, 10^6:Family:="PSU");  
> IsEmptySimpleQuotientProcess(P);
false
> eps, info := SimpleEpimorphisms(P);
> info;
<65, 62400, PSU(3, 4)>
We've found PSU(3,4) of order 62400 and degree 65 as an image. We continue with this process.

> NextSimpleQuotient(~P);
> IsEmptySimpleQuotientProcess(P);
true
No, there are no more within the limits given.

The ( L)2-Quotient Algorithm

Given a finitely presented group G on two generators, the ( L)2-quotient algorithm of Plesken and Fabianska [PF09] computes all quotients of G which are isomorphic to some ( PSL)(2, q) = ( L)2(q), simultaneously for any prime power q. It can handle the case of infinitely many quotients, and also works for very large prime powers.

Note that, at the moment, the algorithm does not return images onto the groups ( PSL)(2, 2), ( PSL)(2, 3), and ( PSL)(2, 4) = ( PSL)(2, 5).

L2Quotients(G) : GrpFP -> SeqEnum[RngMPol]
This is the main method. It takes as parameter a finitely presented group on two generators, and returns a list of prime ideals of Z[x1, x2, x12]. These prime ideals contain all information about the ( L)2-quotients.
L2Type(P) : RngMPol-> MonStgElt
For a prime ideal P in Z[x1, x2, x12], this method returns a string describing the ( L)2-type which the ideal encodes. The possible types are "reducible", "dihedral", "Alt(4)", "Sym(4)", "Alt(5)", "infinite (characteristic zero)", "infinite (characteristic p)", "PGL(2, q)", and "PSL(2, q)". Note that for prime ideals which are returned by L2Quotients or L2Ideals, only the last four types can occur; the other types are eliminated in these methods.
L2Generators(P) : RngMPol -> GrpMat
Given a maximal ideal M in Z[x1, x2, x12], compute two matrices with entries in Z[x1, x2, x12]/M corresponding to M.
L2Ideals(I) : RngMPol -> SeqEnum[RngMPol]
Given an ideal I in Z[x1, x2, x12], compute the minimal associated primes of I which give rise to ( L)2-quotients. This is mainly used for ideals returned by L2Quotients which encode infinitely many ( L)2 images.

Example GrpFP_1_ModularFinite (H70E22)

The first few examples are taken from Conder, Havas and Newman [CHN11].

> Gamma< x, y > := Group< x, y | x^2, y^3 >;
> u := x*y; v := x*y^-1;
> G := quo< Gamma | u^10*v^2*u*v*u*v^2 >;
> quot := L2Quotients(G); quot;
[
Ideal of Polynomial ring of rank 3 over Integer Ring
Order: Lexicographical
Variables: x1, x2, x12
Inhomogeneous, Dimension 0
Groebner basis:
[
    x1,
    x2 + 1,
    x12^2 + 4*x12 + 2,
    5
]
]

L2Quotients returns only one ideal, so there is only one ( L)2 quotient. We can use L2Type to check what group this is.

> L2Type(quot[1]);
PSL( 2, 5^2 )

Finally, L2Generators returns matrices in ( SL)(2, 25) which map onto generators in ( PSL)(2, 25).

> L2Generators(quot[1]);
MatrixGroup(2, GF(5^2))
Generators:
    [     3 $.1^21]
    [     0      2]

    [     0      4]
    [     1      4]
Mapping from: MatrixGroup(2, GF(5^2)) to GL(2, ext<GF(5) | Polynomial(GF(5), 
\[3, 3, 1])>)

There are other quotients of the modular group with only finitely many ( L)2 quotients:

> G := quo< Gamma | u^3*v*u^3*v*u^3*v^2*u*v^2 >;
> quot := L2Quotients(G);
> [L2Type(P) : P in quot];
[ PGL( 2, 13 ) ]
>
> G := quo< Gamma | u^3*v*u^3*v^2*u*v^3*u*v^2 >;
> quot := L2Quotients(G);
> [L2Type(P) : P in quot];
[]
This tells us that the first group has only one ( L)2 quotient, isomorphic to ( PGL)(2, 13), and the second group has no ( L)2 quotients at all.

Example GrpFP_1_CoxeterFinite (H70E23)

Next, we look at Coxeter presentations of the form

(l, m | n, k) = < x, y | xl, ym, (xy)n, (x^( - 1)y)k >

and

(l, m, n; q) = < x, y | xl, ym, (xy)n, [x, y]k >

for various values of l, m, n, k, q.

> G := Group< x,y | x^8, y^9, (x*y)^5, (x^-1*y)^7 >;                            
> [L2Type(P) : P in L2Quotients(G)];
[ PSL( 2, 71 ), PSL( 2, 71 ), PSL( 2, 71 ), PSL( 2, 2521 ), PSL( 2, 239 ), 
PSL( 2, 449 ), PSL( 2, 3876207679 ), PSL( 2, 1009 ), PSL( 2, 29113631 ), 
PSL( 2, 41 ), PSL( 2, 3056201 ) ]

The group ( PSL)(2, 71) occurs three times. This means that there are three essentially different epimorphisms of G onto ( PSL)(2, 71), i.e., there is no automorphism of ( PSL)(2, 71) which transforms one epimorphism into another.

Here is another example, this time for the other family.

> G := Group< x, y | x^4, y^3, (x*y)^5, (x,y)^6 >;
> [L2Type(P) : P in L2Quotients(G)];
[ PSL( 2, 79 ), PSL( 2, 3^2 ), PSL( 2, 5^2 ) ]

There are three groups in the second family for which it is not known whether they are finite or infinite (Havas & Holt (2010) [HH10]). They are (3, 4, 9; 2), (3, 4, 11; 2), and (3, 5, 6; 2). Each of them has only one ( L)2 image.

> G := Group< x, y | x^3, y^4, (x*y)^9, (x,y)^2 >;
> [L2Type(P) : P in L2Quotients(G)];
[ PSL( 2, 89 ) ]
> G := Group< x, y | x^3, y^4, (x*y)^11, (x,y)^2 >;
> [L2Type(P) : P in L2Quotients(G)];               
[ PSL( 2, 769 ) ]
> G := Group< x, y | x^3, y^5, (x*y)^6, (x,y)^2 >; 
> [L2Type(P) : P in L2Quotients(G)];              
[ PSL( 2, 61 ) ]

The algorithm currently only works for finitely presented groups on two generators. However, it is sometimes possible to reduce the number of generators for finitely presented groups on more than two generators.

The following examples are taken from Cavicchioli, O'Brien and Spaggiari [COS08], with code supplied by Eamonn O'Brien.

> CHR := function (X)
>    n := X[1]; m := X[2]; k := X[3];
>    F := FreeGroup (n);
>    R := [];
>    for i in [1..n] do
>       a := i + m;
>       if a gt n then repeat a := a - n; until a le n; end if;
>       b := i + k;
>       if b gt n then repeat b := b - n; until b le n; end if;
>       Append (~R, F.i * F.a = F.b);
>    end for;
>    Q := quo < F | R >;
>    return Q;
> end function;
> G := CHR([9, 1, 3]); G;
Finitely presented group G on 9 generators
Relations
    G.1 * G.2 = G.4
    G.2 * G.3 = G.5
    G.3 * G.4 = G.6
    G.4 * G.5 = G.7
    G.5 * G.6 = G.8
    G.6 * G.7 = G.9
    G.7 * G.8 = G.1
    G.8 * G.9 = G.2
    G.9 * G.1 = G.3
> H := ReduceGenerators(G); H;
Finitely presented group H on 2 generators
Generators as words in group G
    H.1 = G.2
    H.2 = G.5
Relations
    H.2^-2 * H.1^-2 * H.2^-1 * H.1^2 * H.2 * H.1 * H.2^-1 * H.1 = Id(H)
    H.2^-1 * H.1^-1 * H.2^-2 * H.1^-1 * H.2^-1 * H.1 * H.2^-2 * H.1^-1 * H.2 
    * H.1^-1 = Id(H)
> L2Quotients(H);
[
    Ideal of Polynomial ring of rank 3 over Integer Ring
    Order: Lexicographical
    Variables: x1, x2, x12
    Inhomogeneous, Dimension 0
    Groebner basis:
    [
        x1 + x12,
        x2 + x12,
        x12^3 + x12 + 1,
        2
    ]
]
> [L2Type(Q) : Q in $1];
[ PSL( 2, 2^3 ) ]
> 
> G := CHR([9, 1, 4]); 
> H := ReduceGenerators(G); H;
Finitely presented group H on 2 generators
Generators as words in group G
    H.1 = G.1
    H.2 = G.5
Relations
    H.2 * H.1 * H.2^-1 * H.1 * H.2^-2 * H.1^2 * H.2^2 * H.1^-1 * H.2 = Id(H)
    H.1^-1 * H.2 * H.1^-1 * H.2^2 * H.1^-1 * H.2^3 * H.1^-1 * H.2 * H.1^-1 * H.2^2 
    * H.1^-1 * H.2 * H.1^-1 = Id(H)
> [L2Type(Q) : Q in L2Quotients(H)];
[]

Example GrpFP_1_Infinite (H70E24)

The algorithm also handles the case in which there are infinitely many L2 quotients. This is the case if one of the prime ideals returned by L2Quotients is not maximal. They can be handled theoretically to get a precise list of all images. The functions in Magma can be used to get information for a specified ideal containing the prime ideal.

We start again with a quotient of the modular group.

> Gamma< x, y > := Group< x, y | x^2, y^3 >;
> u := x*y; v := x*y^-1;
> G := quo< Gamma | u^5*v*u*v*u*v^5*u*v*u*v >;
> quot := L2Quotients(G);
> [L2Type(P) : P in quot];
[ infinite (characteristic zero) ]
This means that there are infinitely many ( L)2 quotients of G (which already proves that G is infinite). Let's look at the prime ideal.

> P := quot[1]; P;
Ideal of Polynomial ring of rank 3 over Integer Ring
Order: Lexicographical
Variables: x1, x2, x12
Inhomogeneous, Dimension 0
Groebner basis:
[
    x1,
    x2 + 1,
    x12^8 - 5*x12^6 + 6*x12^4 - 1
]
The residue class ring of P is a finite algebraic extension S of Z, and the algorithm found a homomorphism of G into ( PSL)(2, S). Since S has epimorphisms onto finite fields in every characteristic, this gives homomorphisms of G into ( PSL)(2, pk) for every prime p and suitable k. To check what images there are in characteristic p, we construct the ideal I = < p > + P. This is no longer prime in general. We can use L2Ideals to compute the associated primes of I; this method also removes all ideals which don't give rise to epimorphisms.

> R := Generic(P);
> I := ideal< R | 2 > + P;
> quot := L2Ideals(I);
> [L2Type(Q) : Q in quot];
[ PSL( 2, 2^4 ) ]
So G has one quotient isomorphic to ( PSL)(2, 16), and we can construct images of the generators of G.

> L2Generators(quot[1]);
MatrixGroup(2, GF(2^4))
Generators:
    [     1  $.1^6]
    [     0      1]

    [     0      1]
    [     1      1]
Mapping from: MatrixGroup(2, GF(2^4)) to GL(2, ext<GF(2) | Polynomial(GF(2), 
\[1, 0, 0, 1, 1])>)
We can check the images in various other characteristics:

> for p in PrimesInInterval(3, 19) do
>     [L2Type(Q) : Q in L2Ideals(ideal< R | p > + P)];
> end for;
[ PGL( 2, 3^4 ) ]
[ PGL( 2, 5^2 ) ]
[ PSL( 2, 7^2 ), PSL( 2, 7^2 ), PGL( 2, 7^2 ) ]
[ PGL( 2, 11 ), PGL( 2, 11 ), PGL( 2, 11^2 ) ]
[ PSL( 2, 13^2 ), PSL( 2, 13^2 ), PSL( 2, 13^2 ), PSL( 2, 13^2 ) ]
[ PSL( 2, 17^4 ), PSL( 2, 17^4 ) ]
[ PSL( 2, 19 ), PSL( 2, 19 ), PSL( 2, 19^2 ), PSL( 2, 19^2 ), PGL( 2, 19 ) ]

There is virtually no limit on the size of the prime:

> p := RandomPrime(200);
> p;
307941320171307176726971038693755343299358400663182805777637
> I := ideal< R | p > + P;
> [L2Type(Q) : Q in L2Ideals(I)];
[ PGL( 2, 307941320171307176726971038693755343299358400663182805777637^2 ),
PGL( 2, 307941320171307176726971038693755343299358400663182805777637^2 ) ]
> p := NextPrime(p);
> I := ideal< R | p > + P;
> quot := L2Ideals(I);
> [L2Type(Q) : Q in quot];
[ PSL( 2, 307941320171307176726971038693755343299358400663182805777879 ),
PSL( 2, 307941320171307176726971038693755343299358400663182805777879 ), 
PSL( 2, 307941320171307176726971038693755343299358400663182805777879^2 ),
PSL( 2, 307941320171307176726971038693755343299358400663182805777879^2 ),
PGL( 2, 307941320171307176726971038693755343299358400663182805777879 ) ]
> L2Generators(quot[1]);                                                         
MatrixGroup(2, GF(307941320171307176726971038693755343299358400663182805777879))
Generators:
    [0 1]
    [307941320171307176726971038693755343299358400663182805777878 0]

    [260117736370596621578446660105615721012604377822664417621373 
        39170644893202404516985879121051845196952956796906799404293]
    [124461947209331225807153039245860372991649922432590162143941 
        47823583800710555148524378588139622286754022840518388156505]
Mapping from: MatrixGroup(2, GF(3079413201713071767269710386937553432993584006631\
82805777879)) to GL(2, GF(307941320171307176726971038693755343299358400\
663182805777879, 1))

Example GrpFP_1_InfinitePositiveChar (H70E25)

In the previous example, the group had infinitely many ( L)2 quotients, finitely many in every characteristic. The next example presents a group which has infinitely many ( L)2r quotients, but only in a single characteristic.

> G := Group< x, y | x*y*x^-1*y*x*y^4*x^-1*y^-4 >;      
> quot := L2Quotients(G);
> [L2Type(Q) : Q in quot];
[ infinite (characteristic 41) ]
> P := quot[1]; P;
Ideal of Polynomial ring of rank 3 over Integer Ring
Order: Lexicographical
Variables: x1, x2, x12
Inhomogeneous, Dimension >0
Groebner basis:
[
    x1 + 30*x2*x12,
    x2^2 + 22,
    41
]
The residue class ring of P is S = F412[x12], and the algorithm found a homomorphism into ( PSL)(2, S). Since S has epimorphisms onto every finite extension of F412, this gives homomorphisms of G into ( PSL)(2, 41^(2 * k)) for every k.

We specialize x12 to different elements of extensions of F412. For example, for different specializations in F412 we get an image onto ( PGL)(2, 41) or ( PSL)(2, 412):

> R< x1, x2, x12 > := Generic(P);
> 
> I := ideal< R | x12 - 1 > + P;
> [L2Type(Q) : Q in L2Ideals(I)];
[ PGL( 2, 41 ) ]
> 
> I := ideal< R | x12 - (x2 + 1) > + P;
> [L2Type(Q) : Q in L2Ideals(I)];
[ PSL( 2, 41^2 ) ]
We can check the images for a random specialization:

> pol := &+[Random([0..40])*x12^i : i in [0..30]]; pol;
19*x12^30 + x12^29 + 16*x12^28 + 14*x12^27 + 38*x12^26 + 27*x12^25 + 20*x12^24 + 
    31*x12^23 + 15*x12^22 + 22*x12^21 + 32*x12^20 + 26*x12^19 + 26*x12^18 + 
    18*x12^17 + 16*x12^16 + 29*x12^15 + 18*x12^14 + 11*x12^13 + 3*x12^12 + 
    11*x12^11 + 36*x12^10 + 13*x12^9 + 15*x12^8 + 33*x12^7 + 30*x12^6 + 8*x12^5 + 
    12*x12^4 + 40*x12^3 + 12*x12^2 + 25*x12 + 8;
> I := ideal< R | pol > + P;
> [L2Type(Q) : Q in L2Ideals(I)];                 
[ PGL( 2, 41 ), PGL( 2, 41 ), PGL( 2, 41 ), PSL( 2, 41^2 ), PSL( 2, 41^2 ), 
PSL( 2, 41^2 ), PSL( 2, 41^2 ), PSL( 2, 41^14 ), PSL( 2, 41^14 ), 
PGL( 2, 41^9 ) ]
And again, this works for very large fields:

> pol := IrreduciblePolynomial(GF(41), 301);
> pol;
$.1^301 + $.1^2 + 6*$.1 + 30
> I := ideal< R | x12^301 + x12^2 + 6*x12 + 30 > + P;
> [L2Type(Q) : Q in L2Ideals(I)];
[ PGL( 2, 41^301 ) ]

Infinite L2 quotients

This section contains functions that use the L2-quotient algorithm of Plesken and Fabianska ([PF09]) to establish the existence or not of an infinite quotient of a finitely-presented group in PSL2(K) for K a field of characteristic zero. The algorithm is often used to find surjective quotients over finite fields but as a test for non-finiteness it is easier to work directly in characteristic zero. We make some comments on the relation to finite fields below.

The algorithm first constructs an affine scheme X over Q from the "trace ideal" of the group G, for which the algebraic points over a field K are in 1-1 correspondence with equivalence classes of representations of G into SL2(K). If g1, ..., gn are the generators of G, then the affine coordinates of X correspond to the trace under the representation of various products of the Gi. For example, when n=2, X lies in 3-dimensional affine space and the coordinates correspond to the traces of g1, g2 and g1g2. The ideal is actually generated by polynomials with coefficients in Z so X is naturally defined as a scheme over Spec(Z), whose reduction mod p just gives the scheme corresponding to characteristic p representations of G for p > 2.

Homomorphisms into PSL2 rather than SL2 are dealt with by considering a number of X schemes for a particular G. Each one represents the homomorphisms from the free cover of G to SL2 that takes each word in the set of relations defining G to either I or -I. Each of the 2r choices of sign for the r defining relations gives an X (by the same procedure) and the totality cover all possibilities for maps to PSL2.

The set of points of X corresponding to geometrically reducible, dihedral A4, S4 or A5 images in PSL2 is a closed subscheme Y. In fact the first two possibilities give closed subschemes with equations defined over Z and the last three give a dimension zero scheme over Q. The overall equations defining Y reduce mod p to those defining the corresponding subscheme in characteristic p for almost all primes p. The explicit equations defing Y are determined by the algorithm as explained for n = 2 or 3 in the above reference or in more detail in Fabianska's MSc thesis ([Fab09]). Let U be the open complement of Y in X.

There are two possibilities.

1
A U is non-empty, so an algebraic point gives φ: G -> PSL2(K), K a number field, with infinite image, so G is infinite. Further, for all but finitely many primes p, φcan be reduced mod v for any place v of characteristic p AND the reduction φv corresponds to a point in the analogue of U over the finite field. Thus the reductions give surjections of G onto a PSL2(k) [or maybe a PGL2(k)] for finite fields of any characteristic outside of a finite set.

2
All Us are empty. Here, all the homomorphisms of G into PSL2(K) in characteristic zero have geometrically reducible, dihedral, A4, S4 or A5 images and the same holds for K a field of characteristic p for all p outside of a finite set of primes. G may or may not be infinite.

NB: In case 2), there may still be images of G which ARE infinite, but lie in a Cartan or Borel subgroup, so are geometrically reducible, or lie in the normaliser of a Cartan and have an infinite dihedral image. These infinite reducible/dihedral possibilities are not currently checked for.
HasInfinitePSL2Quotient(G) :: GrpFP -> BoolElt, SeqEnum
    signs: SeqEnum                      Default: 0
    full: BoolElt                       Default: false
    SetVerbose("IsInfGrp", n):          Maximum: 1
Function to return whether the two-generator finitely-presented group G has an infinite quotient lying in a PSL2(K) with K a field of characteristic 0 as described above.

For the convenience of the user, we have provided some parameters to output more detailed information coming from the analysis of the X representation schemes as well as to control which sign variations are considered.

Let ws be the sequence of words giving the defining relations of G (if a defining relation is of the form w = v where v is not the identity word, then the corresponding word is w * v - 1). Let ws = [w1, .., wr].

As described in the introduction, for each of the 2r combinations of signs attached to the wi - let s be one - the program will consider the scheme X of homomorphisms of G into PSL2 such that, when lifted to a homomorphism of the two-generator free cover F of G into SL2, wi maps to si * I.

In some cases, the user may realise that there is no point in considering certain choices of signs. For example, if g12 is a relation in ws, g12 |-> I in SL2(K) means that g1 |-> 1 in PSL2(K), so the PSL2(K) image would be (maybe infinitely) cyclic, and it is a waste of time to consider this possibility. Similarly, if g1r, r odd, is a relation then ,without loss of generality, in a PSL2 to SL2 lift, g1r |-> I, which could be specified.

The parameter signs allows the user to specify a restricted set of sign options to analyse. signs should be an 0, 1, - 1 or a sequence of length #ws of such integers. A single value is converted into the sequence containing that value #ws times. An entry e of 1 or -1 in position i means that the function will only consider sign sequences s with s[i] = e, ie homomorphisms where wi map to eI in the lift to SL2. If e = 0, then there is no condition at place i of the sign sequences considered. The default value for signs is the single value 0.

For each representation space X (corresponding to an allowable choice of signs s), after removing positive dimensional components of Y corresponding to geometrically reducible or dihedral type representations, there is often a zero-dimensional subscheme left. The existence of an infinite (non-cyclic or dihedral) image homomorphism to PSL2 then comes down to examining the finite set of closed points remaining and finding one that is not geometrically reducible, dihedral, A4, S4 or A5 type. Clearly, once one such is found the procedure can stop. However, it might be of interest for the user to see the types of ALL of the representations corresponding to closed points if the zero-dimensional analysis stage is performed.

If parameter full is set to true (the default is false), the program will continue analysing all of the representations in the 0-dimensional locus, even after one corresponding to an infinite image is found. Furthermore a sequence of (signs,types) pairs is also returned which gives, for each sign combination s of maps considered, the sequence of types corresponding to the 0-dimensional locus (or empty if we don't reduce to dimension 0). These types are given as strings: "infinite", "reducible", "dihedral", "A4", "S4", and "A5".

Setting the verbose flag IsInfGrp to true or 1 gives output of information on the various stages as the function progresses, including the analysis of dimension zero loci.


Example GrpFP_1_fp-gps:inf-psl2-quot (H70E26)

We look at two examples of quotients of the two-generator free group with relations g12, g23 and one further word. The first is infinite, the second is not. As noted above, we may as well specify that g12 maps to -I and g23 to I in SL2 and this can be done with the signs parameter.

> F := FreeGroup(2);
> rel := (F.1 * F.2 * F.1 * F.2 * F.1 * F.2 * F.1 * F.2 * F.1 * F.2 *
>   F.1 * F.2 * F.1 * F.2 * F.1 * F.2^-1 * F.1 * F.2 * F.1 * F.2^-1)^2;
> G := quo<F | [F.1^2 ,F.2^3, rel]>;
> HasInfinitePSL2Quotient(G : full := true);
true
[ [*
    [ 1, 1, 1 ],
    []
*], [*
    [ 1, 1, -1 ],
    []
*], [*
    [ 1, -1, 1 ],
    []
*], [*
    [ 1, -1, -1 ],
    []
*], [*
    [ -1, 1, 1 ],
    [ A4, A4 ]
*], [*
    [ -1, 1, -1 ],
    [ A5, A5, infinite ]
*], [*
    [ -1, -1, 1 ],
    [ A4, A4 ]
*], [*
    [ -1, -1, -1 ],
    [ A5, A5, infinite ]
*] ]

Now try it with the sign restriction.

> HasInfinitePSL2Quotient(G : full := true, signs := [-1,1,0]);
true
[ [*
    [ -1, 1, 1 ],
    [ A4, A4 ]
*], [*
    [ -1, 1, -1 ],
    [ A5, A5, infinite ]
*] ]

The second example is just A5.

> G := quo<F | [F.1^2 ,F.2^3, (F.1*F.2)^5]>;
> HasInfinitePSL2Quotient(G);
false
> HasInfinitePSL2Quotient(G : full := true, signs := [-1,1,0]);
false
[ [*
    [ -1, 1, 1 ],
    [ A5 ]
*], [*
    [ -1, 1, -1 ],
    [ A5 ]
*] ]

Searching for Isomorphisms

This section describes a function for searching for isomorphisms between two finitely presented groups.

SearchForIsomorphism(F, G, m : parameters) : GrpFP, GrpFP, RngIntElt -> BoolElt, HomGrp, HomGrp
Attempt to find an isomorphism from the finitely presented group F to the finitely presented group G. The search will be restricted to those homomorphisms for which the sum of the word-lengths of the images of the generators of F in G is at most m.

If an isomorphism φis found, then the values true, φ, φ^ - 1 are returned. Otherwise, the values false, _, _ are returned; of course, that does not necessarily mean that the groups are not isomorphic.

An error will result if any of the generators of F turn out to be trivial.

By setting the verbose flag "IsoSearch" to 1, information about the progress of the search will be printed.

The parameters available for the function SearchForIsomorphism are:

     All: BoolElt                        Default: false

If All is false (default), then the function halts and returns as soon as a single isomorphism is found. If All is true, then the search continues through all possible images that satisfy the image length condition, and a list of pairs < φ, φ^ - 1 > for all isomorphisms φ:F to G found is returned as the second return value.

     IsomsOnly: BoolElt                  Default: true

If IsomsOnly is set to false, then all homomorphisms F to G will be returned if All is true, and the first nontrivial homomorphism found will be returned if All is false.

     MaxRels: RngIntElt                  Default: 250*m

The value of the MaxRelations parameter used in runs of RWSGroup. It is hard to find a sensible default, because if the value is unnecessarily large then time can be wasted unnecessarily. This may need to be increased if the function is used with finite groups, for example (although it is usually much more efficient to use permutation or matrix representations when testing isomorphism of finite groups).

     CycConjTest: BoolElt                Default: true

When CycConjTest is true and All is false, then images of the first generator which have a cyclic conjugate that comes earlier in the lexicographical order are rejected, because there would be a conjugate isomorphism in which the image was the cyclic conjugate. This nearly always results in faster run-times, but occasionally it can happen that the conjugate isomorphism has a larger sum of lengths of generator images, which is clearly bad. So the user has the option of not rejecting such images.


Example GrpFP_1_SearchForIso1 (H70E27)

John Hillman asked whether the following two groups are isomorphic.

> G1<s,t,u> := Group <s,t,u | s*u*s^-1=u^-1, t^2=u^2, t*s^2*t^-1=s^-2,
>                             u*(s*t)^2=(s*t)^2*u >;
> G2<x,y,z> := Group<x,y,z | x*y^2*x^-1=y^-2, y*x^2*y^-1=x^-2, x^2=z^2*(x*y)^2,
>                            y^2=(z^-1*x)^2, z*(x*y)^2=(x*y)^2*z >;
> isiso, f1, f2 := SearchForIsomorphism(G1,G2,7);
> isiso;
true
> f1;
Homomorphism of GrpFP: G1 into GrpFP: G2 induced by
    s |--> x * z^-1
    t |--> y * z
    u |--> x * y^-1 * z
> f2;
Homomorphism of GrpFP: G2 into GrpFP: G1 induced by
    x |--> s^2 * u * t^-1
    y |--> s^-1 * u^-1
    z |--> s * u * t^-1
The search for an isomorphism succeeeded and returns the isomorphisms explicitly.

Example GrpFP_1_SearchForIso2 (H70E28)

Walter Neumann asked whether the next two groups are isomorphic.

> G1<x,y,z> := Group< x,y,z | x^2*y^5, x^14*z^23, (x^2,y), (x^2,z), x*y*z>;
> G2<a,b> := Group<a,b | a*b^16*a*b^-7, a^4*b^7*a^-1*b^7>;
It is a good idea to minimize the number of generators of G1 - since there is clearly a redundant generator here.

> G1s := Simplify(G1);
> Ngens(G1s);
2
> G1!G1s.1, G1!G1s.2;
x z
Now a direct call SearchForIsomorphism(G1, G2, 15) will succeed, but will take many hours, and also use a lot of memory.

In contrast to G1, it can sometimes help to introduce a new generator in G2 if there are common substrings in relators.

> G2b<a,b,c> := Group< a,b,c | a*b^16*a*b^-7, a^4*b^7*a^-1*b^7, c=b^7>;
> isiso, f1, f2 := SearchForIsomorphism(G1s,G2b,4);
> isiso;
true
> f1;
Homomorphism of GrpFP: G1s into GrpFP: G2b induced by
    G1s.1 |--> a * c^-1
    G1s.2 |--> c
> f2;
Homomorphism of GrpFP: G2b into GrpFP: G1s induced by
    a |--> G1s.1 * G1s.2
    b |--> G1s.1^6 * G1s.2^10
    c |--> G1s.2

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

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