Goto Chapter: Top 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 Bib Ind
[Top of Book] [Contents] [Previous Chapter] [Next Chapter]

[MathJax on]

40 Group Homomorphisms
40.1 Creating Group Homomorphisms
40.1-1 GroupHomomorphismByImages
40.1-2 GroupHomomorphismByImagesNC
40.1-3 GroupGeneralMappingByImages
40.1-4 GroupHomomorphismByFunction
40.1-5 AsGroupGeneralMappingByImages
40.2 Operations for Group Homomorphisms
40.3 Efficiency of Homomorphisms
40.3-1 Mappings given on generators
40.3-2 Action homomorphisms
40.3-3 Mappings given by functions
40.3-4 Other operations
40.3-5 ImagesSmallestGenerators
40.4 Homomorphism for very large groups
40.5 Nice Monomorphisms
40.5-1 IsHandledByNiceMonomorphism
40.5-2 NiceMonomorphism
40.5-3 NiceObject
40.5-4 IsCanonicalNiceMonomorphism
40.6 Group Automorphisms
40.6-1 ConjugatorIsomorphism
40.6-2 ConjugatorAutomorphism
40.6-3 InnerAutomorphism
40.6-4 IsConjugatorIsomorphism
40.6-5 ConjugatorOfConjugatorIsomorphism
40.7 Groups of Automorphisms
40.7-1 AutomorphismGroup
40.7-2 IsGroupOfAutomorphisms
40.7-3 AutomorphismDomain
40.7-4 IsAutomorphismGroup
40.7-5 InnerAutomorphismsAutomorphismGroup
40.7-6 InnerAutomorphismGroup
40.7-7 InducedAutomorphism
40.8 Calculating with Group Automorphisms
40.8-1 AssignNiceMonomorphismAutomorphismGroup
40.8-2 NiceMonomorphismAutomGroup
40.9 Searching for Homomorphisms
40.9-1 IsomorphismGroups
40.9-2 AllHomomorphismClasses
40.9-3 AllHomomorphisms
40.9-4 GQuotients
40.9-5 IsomorphicSubgroups
40.9-6 MorClassLoop
40.10 Representations for Group Homomorphisms
40.10-1 IsGroupGeneralMappingByImages
40.10-2 MappingGeneratorsImages
40.10-3 IsGroupGeneralMappingByAsGroupGeneralMappingByImages
40.10-4 IsPreimagesByAsGroupGeneralMappingByImages
40.10-5 IsPermGroupGeneralMapping
40.10-6 IsToPermGroupGeneralMappingByImages
40.10-7 IsGroupGeneralMappingByPcgs
40.10-8 IsPcGroupGeneralMappingByImages
40.10-9 IsToPcGroupGeneralMappingByImages
40.10-10 IsFromFpGroupGeneralMappingByImages
40.10-11 IsFromFpGroupStdGensGeneralMappingByImages

### 40 Group Homomorphisms

A group homomorphism is a mapping from one group to another that respects multiplication and inverses. They are implemented as a special class of mappings, so in particular all operations for mappings, such as `Image` (32.4-6), `PreImage` (32.5-6), `PreImagesRepresentative` (32.5-4), `KernelOfMultiplicativeGeneralMapping` (32.9-5), `Source` (32.3-8), `Range` (32.3-7), `IsInjective` (32.3-4) and `IsSurjective` (32.3-5) (see chapter 32, in particular section 32.9) are applicable to them.

Homomorphisms can be used to transfer calculations into isomorphic groups in another representation, for which better algorithms are available. Section 40.5 explains a technique how to enforce this automatically.

Homomorphisms are also used to represent group automorphisms, and section 40.6 explains GAP's facilities to work with automorphism groups.

Section 40.9 explains how to make GAP to search for all homomorphisms between two groups which fulfill certain specifications.

#### 40.1 Creating Group Homomorphisms

The most important way of creating group homomorphisms is to give images for a set of group generators and to extend it to the group generated by them by the homomorphism property.

A second way to create homomorphisms is to give functions that compute image and preimage. (A similar case are homomorphisms that are induced by conjugation. Special constructors for such mappings are described in section 40.6).

The third class are epimorphisms from a group onto its factor group. Such homomorphisms can be constructed by `NaturalHomomorphismByNormalSubgroup` (39.18-1).

The fourth class is homomorphisms in a permutation group that are induced by an action on a set. Such homomorphisms are described in the context of group actions, see chapter 41 and in particular `ActionHomomorphism` (41.7-1).

##### 40.1-1 GroupHomomorphismByImages

`‣ GroupHomomorphismByImages`( G, H[[, gens], imgs] ) | ( function )

`GroupHomomorphismByImages` returns the group homomorphism with source G and range H that is defined by mapping the list gens of generators of G to the list imgs of images in H.

If omitted, the arguments gens and imgs default to the `GeneratorsOfGroup` (39.2-4) value of G and H, respectively. If H is not given the mapping is automatically considered as surjective.

If gens does not generate G or if the mapping of the generators does not extend to a homomorphism (i.e., if mapping the generators describes only a multi-valued mapping) then `fail` is returned.

This test can be quite expensive. If one is certain that the mapping of the generators extends to a homomorphism, one can avoid the checks by calling `GroupHomomorphismByImagesNC` (40.1-2). (There also is the possibility to construct potentially multi-valued mappings with `GroupGeneralMappingByImages` (40.1-3) and to test with `IsMapping` (32.3-3) whether they are indeed homomorphisms.)

##### 40.1-2 GroupHomomorphismByImagesNC

`‣ GroupHomomorphismByImagesNC`( G, H[[, gens], imgs] ) | ( operation )

`GroupHomomorphismByImagesNC` creates a homomorphism as `GroupHomomorphismByImages` (40.1-1) does, however it does not test whether gens generates G and that the mapping of gens to imgs indeed defines a group homomorphism. Because these tests can be expensive it can be substantially faster than `GroupHomomorphismByImages` (40.1-1). Results are unpredictable if the conditions do not hold.

If omitted, the arguments gens and imgs default to the `GeneratorsOfGroup` (39.2-4) value of G and H, respectively.

(For creating a possibly multi-valued mapping from G to H that respects multiplication and inverses, `GroupGeneralMappingByImages` (40.1-3) can be used.)

    gap> gens:=[(1,2,3,4),(1,2)];
    [ (1,2,3,4), (1,2) ]
    gap> g:=Group(gens);
    Group([ (1,2,3,4), (1,2) ])
    gap> h:=Group((1,2,3),(1,2));
    Group([ (1,2,3), (1,2) ])
    gap> hom:=GroupHomomorphismByImages(g,h,gens,[(1,2),(1,3)]);
    [ (1,2,3,4), (1,2) ] -> [ (1,2), (1,3) ]
    gap> Image(hom,(1,4));
    (2,3)
    gap> map:=GroupHomomorphismByImages(g,h,gens,[(1,2,3),(1,2)]);
    fail

##### 40.1-3 GroupGeneralMappingByImages

`‣ GroupGeneralMappingByImages`( G, H, gens, imgs ) | ( operation )

`‣ GroupGeneralMappingByImages`( G, gens, imgs ) | ( operation )

`‣ GroupGeneralMappingByImagesNC`( G, H, gens, imgs ) | ( operation )

`‣ GroupGeneralMappingByImagesNC`( G, gens, imgs ) | ( operation )

returns a general mapping defined by extending the mapping from gens to imgs homomorphically. If the range H is not given the mapping will be made automatically surjective. The NC version does not test whether gens are contained in G or imgs are contained in H. (`GroupHomomorphismByImages` (40.1-1) creates a group general mapping by images and tests whether it is in `IsMapping` (32.3-3).)

    gap> map:=GroupGeneralMappingByImages(g,h,gens,[(1,2,3),(1,2)]);
    [ (1,2,3,4), (1,2) ] -> [ (1,2,3), (1,2) ]
    gap> IsMapping(map);
    false

##### 40.1-4 GroupHomomorphismByFunction

`‣ GroupHomomorphismByFunction`( S, R, fun[, invfun] ) | ( function )

`‣ GroupHomomorphismByFunction`( S, R, fun, false, prefun ) | ( function )

`GroupHomomorphismByFunction` returns a group homomorphism `hom` with source S and range R, such that each element `s` of S is mapped to the element fun`( s )`, where fun is a GAP function.

If the argument invfun is bound then hom is a bijection between S and R, and the preimage of each element `r` of R is given by invfun`( r )`, where invfun is a GAP function.

If five arguments are given and the fourth argument is `false` then the GAP function prefun can be used to compute a single preimage also if `hom` is not bijective.

No test is performed on whether the functions actually give an homomorphism between both groups because this would require testing the full multiplication table.

`GroupHomomorphismByFunction` creates a mapping which lies in `IsSPGeneralMapping` (32.14-1).

    gap> hom:=GroupHomomorphismByFunction(g,h,
    > function(x) if SignPerm(x)=-1 then return (1,2); else return ();fi;end);
    MappingByFunction( Group([ (1,2,3,4), (1,2) ]), Group(
    [ (1,2,3), (1,2) ]), function( x ) ... end )
    gap> ImagesSource(hom);
    Group([ (1,2), (1,2) ])
    gap> Image(hom,(1,2,3,4));
    (1,2)

##### 40.1-5 AsGroupGeneralMappingByImages

`‣ AsGroupGeneralMappingByImages`( map ) | ( attribute )

If map is a mapping from one group to another this attribute returns a group general mapping that which implements the same abstract mapping. (Some operations can be performed more effective in this representation, see also `IsGroupGeneralMappingByAsGroupGeneralMappingByImages` (40.10-3).)

    gap> AsGroupGeneralMappingByImages(hom);
    [ (1,2,3,4), (1,2) ] -> [ (1,2), (1,2) ]

#### 40.2 Operations for Group Homomorphisms

Group homomorphisms are mappings, so all the operations and properties for mappings described in chapter 32 are applicable to them. (However often much better methods, than for general mappings are available.)

Group homomorphisms will map groups to groups by just mapping the set of generators.

`KernelOfMultiplicativeGeneralMapping` (32.9-5) can be used to compute the kernel of a group homomorphism.

    gap> hom:=GroupHomomorphismByImages(g,h,gens,[(1,2),(1,3)]);;
    gap> Kernel(hom);
    Group([ (1,4)(2,3), (1,2)(3,4) ])

Homomorphisms can map between groups in different representations and are also used to get isomorphic groups in a different representation.

    gap> m1:=[[0,-1],[1,0]];;m2:=[[0,-1],[1,1]];;
    gap> sl2z:=Group(m1,m2);; # SL(2,Integers) as matrix group
    gap> F:=FreeGroup(2);;
    gap> psl2z:=F/[F.1^2,F.2^3]; #PSL(2,Z) as FP group
    <fp group on the generators [ f1, f2 ]>
    gap> phom:=GroupHomomorphismByImagesNC(sl2z,psl2z,[m1,m2],
    > GeneratorsOfGroup(psl2z)); # the non NC-version would be expensive
    [ [ [ 0, -1 ], [ 1, 0 ] ], [ [ 0, -1 ], [ 1, 1 ] ] ] -> [ f1, f2 ]
    gap> Kernel(phom); # the diagonal matrices
    Group([ [ [ -1, 0 ], [ 0, -1 ] ], [ [ -1, 0 ], [ 0, -1 ] ] ])
    gap> p1:=(1,2)(3,4);;p2:=(2,4,5);;a5:=Group(p1,p2);;
    gap> ahom:=GroupHomomorphismByImages(psl2z,a5,
    > GeneratorsOfGroup(psl2z),[p1,p2]); # here homomorphism test is cheap.
    [ f1, f2 ] -> [ (1,2)(3,4), (2,4,5) ]
    gap> u:=PreImage(ahom,Group((1,2,3),(1,2)(4,5)));
    Group(<fp, no generators known>)
    gap> Index(psl2z,u);
    10
    gap> isofp:=IsomorphismFpGroup(u);; Image(isofp);
    <fp group of size infinity on the generators [ F1, F2, F3, F4 ]>
    gap> RelatorsOfFpGroup(Image(isofp));
    [ F1^2, F4^2, F3^3 ]
    gap> up:=PreImage(phom,u);;
    gap> List(GeneratorsOfGroup(up),TraceMat);
    [ -2, -2, 0, -4, 1, 0 ]

For an automorphism aut, `Inverse` (31.10-8) returns the inverse automorphism aut^{-1}. However if hom is a bijective homomorphism between different groups, or if hom is injective and considered to be a bijection to its image, the operation `InverseGeneralMapping` (32.2-3) should be used instead. (See `Inverse` (31.10-8) for a further discussion of this problem.)

    gap> iso:=IsomorphismPcGroup(g);
    Pcgs([ (3,4), (2,4,3), (1,4)(2,3), (1,3)(2,4) ]) -> [ f1, f2, f3, f4 ]
    gap> Inverse(iso);
    #I  The mapping must be bijective and have source=range
    #I  You might want to use `InverseGeneralMapping'
    fail
    gap> InverseGeneralMapping(iso);
    [ f1, f2, f3, f4 ] -> Pcgs([ (3,4), (2,4,3), (1,4)(2,3), (1,3)(2,4) ])

#### 40.3 Efficiency of Homomorphisms

GAP permits to create homomorphisms between arbitrary groups. This section considers the efficiency of the implementation and shows ways how to choose suitable representations. For permutation groups (see 43) or Pc groups (see 46) this is normally nothing to worry about, unless the groups get extremely large. For other groups however certain calculations might be expensive and some precaution might be needed to avoid unnecessarily expensive calculations.

In short, it is always worth to tell a mapping that it is a homomorphism (this can be done by calling `SetIsMapping`) (or to create it directly with `GroupHomomorphismByImagesNC` (40.1-2)).

The basic operations required are to compute image and preimage of elements and to test whether a mapping is a homomorphism. Their cost will differ depending on the type of the mapping.

##### 40.3-1 Mappings given on generators

See `GroupHomomorphismByImages` (40.1-1) and `GroupGeneralMappingByImages` (40.1-3).

Computing images requires to express an element of the source as word in the generators. If it cannot be done effectively (this is determined by `KnowsHowToDecompose` (39.26-7) which returns `true` for example for arbitrary permutation groups, for Pc groups or for finitely presented groups with the images of the free generators) the span of the generators has to be computed elementwise which can be very expensive and memory consuming.

Computing preimages adheres to the same rules with swapped rôles of generators and their images.

The test whether a mapping is a homomorphism requires the computation of a presentation for the source and evaluation of its relators in the images of its generators. For larger groups this can be expensive and `GroupHomomorphismByImagesNC` (40.1-2) should be used if the mapping is known to be a homomorphism.

##### 40.3-2 Action homomorphisms

See `ActionHomomorphism` (41.7-1).

The calculation of images is determined by the acting function used and –for large domains– is often dominated by the search for the position of an image in a list of the domain elements. This can be improved by sorting this list if an efficient method for `\<` (31.11-1) to compare elements of the domain is available.

Once the images of a generating set are computed, computing preimages (which is done via `AsGroupGeneralMappingByImages` (40.1-5)) and computing the kernel behaves the same as for a homomorphism created with `GroupHomomorphismByImages` (40.1-1) from a permutation group.

GAP will always assume that the acting function provided implements a proper group action and thus that the mapping is indeed a homomorphism.

##### 40.3-3 Mappings given by functions

See `GroupHomomorphismByFunction` (40.1-4).

Computing images is wholly determined by the function that performs the image calculation. If no function to compute preimages is given, computing preimages requires mapping every element of the source to find an element that maps to the requested image. This is time and memory consuming.

##### 40.3-4 Other operations

To compute the kernel of a homomorphism (unless the mapping is known to be injective) requires the capability to compute a presentation of the image and to evaluate the relators of this presentation in preimages of the presentations generators.

The calculation of the `Image` (32.4-6) (respectively `ImagesSource` (32.4-1)) value requires to map a generating set of the source, testing surjectivity is a comparison for equality with the range.

Testing injectivity is a test for triviality of the kernel.

The comparison of mappings is based on a lexicographic comparison of a sorted element list of the source. For group homomorphisms, this can be simplified, using `ImagesSmallestGenerators` (40.3-5)

##### 40.3-5 ImagesSmallestGenerators

`‣ ImagesSmallestGenerators`( map ) | ( attribute )

returns the list of images of `GeneratorsSmallest(Source(map))`. This list can be used to compare group homomorphisms. (The standard comparison is to compare the image lists on the set of elements of the source. If however x and y have the same images under a and b, certainly all their products have. Therefore it is sufficient to test this on the images of the smallest generators.)

#### 40.4 Homomorphism for very large groups

Some homomorphisms (notably particular actions) transfer known information about the source group (such as a stabilizer chain) to the image group if this is substantially cheaper than to compute the information in the image group anew. In most cases this is no problem and in fact speeds up further calculations notably.

For a huge source group, however this can be time consuming or take a large amount of extra memory for storage. In this case it can be helpful to avoid as much automatism as possible.

The following list of tricks might be useful in such a case. (However you will lose much automatic deduction. So please restrict the use of these to cases where the standard approach does not work.)

- Compute only images (or the `PreImagesRepresentative` (32.5-4)) of group elements. Do not compute the images of (sub)groups or the full preimage of a subgroup.

- Create action homomorphisms as surjective (see `ActionHomomorphism` (41.7-1)), otherwise the range is set to be the full symmetric group. However do not compute `Range` (32.3-7) or `Image` (32.4-6) values, but only the images of a generator set.

- If you suspect an action homomorphism to do too much internally, replace the action function with a function that does the same; i.e. replace `OnPoints` (41.2-1) by `function( p, g ) return p^g; end;`. The action will be the same, but as the action function is not `OnPoints` (41.2-1), the extra processing for special cases is not triggered.

#### 40.5 Nice Monomorphisms

GAP contains very efficient algorithms for some special representations of groups (for example pc groups or permutation groups) while for other representations only slow generic methods are available. In this case it can be worthwhile to do all calculations rather in an isomorphic image of the group, which is in a better representation. The way to achieve this in GAP is via nice monomorphisms.

For this mechanism to work, of course there must be effective methods to evaluate the `NiceMonomorphism` (40.5-2) value on elements and to take preimages under it. As by definition no good algorithms exist for the source group, normally this can only be achieved by using the result of a call to `ActionHomomorphism` (41.7-1) or `GroupHomomorphismByFunction` (40.1-4) (see also section 40.3).

It may happen that one knows a monomorphism `map` that is suitable as a nice monomorphism of a given group `G`, for example if `G` is a matrix group and `map` describes the faithful action of `G` on a small set of vectors. In such a case, one can prescribe this monomorphism via `SetNiceMonomorphism( G, map )` if certain technical requirements are satisfied.

- `G` does not store a nice monomorphism already (i.e., `HasNiceMonomorphism( G )` returns `false`).

- `map` stores that it is injective. This can be achieved by calling `IsInjective( map )` or, if one is sure that `map` is injective and one wants to avoid the overhead of the test, by calling `SetIsInjective( map, true )`. Note that the `IsInjective` call for `map` may compute and store some different nice monomorphism in the source of `map`, which is probably `G`.

- `map` knows that it is a group homomorphism, calling `ImagesSet` (32.4-4) with `map` and a subgroup of `G` returns a group object, and analogously `PreImagesSet` (32.5-5) for an image group returns a group object. For example, mappings constructed with `GeneralMappingByElements` (32.2-1) will not be nice enough to serve as nice monomorphisms.

##### 40.5-1 IsHandledByNiceMonomorphism

`‣ IsHandledByNiceMonomorphism`( obj ) | ( property )

If this property is `true`, high-valued methods that translate all calculations in obj in the image under the `NiceMonomorphism` (40.5-2) value of obj become available for obj.

##### 40.5-2 NiceMonomorphism

`‣ NiceMonomorphism`( obj ) | ( attribute )

is a homomorphism that is defined (at least) on the whole of obj and whose restriction to obj is injective. The concrete morphism (and also the image group) will depend on the representation of obj.

WARNING: The domain of the homomorphism may be larger than obj. To obtain the image of obj under the homomorphism, use `NiceObject` (40.5-3); see there for an example where it matters.

##### 40.5-3 NiceObject

`‣ NiceObject`( obj ) | ( attribute )

The `NiceObject` value of obj is the image of obj under the mapping stored as the value of `NiceMonomorphism` (40.5-2) for obj.

A typical example are finite matrix groups, which use a faithful action on vectors to translate all calculations in a permutation group.

    gap> gl:=GL(3,2);
    SL(3,2)
    gap> IsHandledByNiceMonomorphism(gl);
    true
    gap> NiceObject(gl);
    Group([ (5,7)(6,8), (2,3,5)(4,7,6) ])
    gap> Image(NiceMonomorphism(gl),Z(2)*[[1,0,0],[0,1,1],[1,0,1]]);
    (2,6)(3,4,7,8)

##### 40.5-4 IsCanonicalNiceMonomorphism

`‣ IsCanonicalNiceMonomorphism`( nhom ) | ( property )

A nice monomorphism (see `NiceMonomorphism` (40.5-2) nhom is canonical if the image set will only depend on the set of group elements but not on the generating set and `\<` (31.11-1) comparison of group elements translates through the nice monomorphism. This implies that equal objects will always have equal `NiceObject` (40.5-3) values. In some situations however this condition would be expensive to achieve, therefore it is not guaranteed for every nice monomorphism.

#### 40.6 Group Automorphisms

Group automorphisms are bijective homomorphism from a group onto itself. An important subclass are automorphisms which are induced by conjugation of the group itself or a supergroup.

##### 40.6-1 ConjugatorIsomorphism

`‣ ConjugatorIsomorphism`( G, g ) | ( operation )

Let G be a group, and g an element in the same family as the elements of G. `ConjugatorIsomorphism` returns the isomorphism from G to `G^g` defined by h ↦ h^g for all h ∈ G.

If g normalizes G then `ConjugatorIsomorphism` does the same as `ConjugatorAutomorphismNC` (40.6-2).

##### 40.6-2 ConjugatorAutomorphism

`‣ ConjugatorAutomorphism`( G, g ) | ( function )

`‣ ConjugatorAutomorphismNC`( G, g ) | ( operation )

Let G be a group, and g an element in the same family as the elements of G such that g normalizes G. `ConjugatorAutomorphism` returns the automorphism of G defined by h ↦ h^g for all h ∈ G.

If conjugation by g does not leave G invariant, `ConjugatorAutomorphism` returns `fail`; in this case, the isomorphism from G to `G^g` induced by conjugation with g can be constructed with `ConjugatorIsomorphism` (40.6-1).

`ConjugatorAutomorphismNC` does the same as `ConjugatorAutomorphism`, except that the check is omitted whether g normalizes G and it is assumed that g is chosen to be in G if possible.

##### 40.6-3 InnerAutomorphism

`‣ InnerAutomorphism`( G, g ) | ( function )

`‣ InnerAutomorphismNC`( G, g ) | ( operation )

Let G be a group, and g ∈ G. `InnerAutomorphism` returns the automorphism of G defined by h ↦ h^g for all h ∈ G.

If g is not an element of G, `InnerAutomorphism` returns `fail`; in this case, the isomorphism from G to `G^g` induced by conjugation with g can be constructed with `ConjugatorIsomorphism` (40.6-1) or with `ConjugatorAutomorphism` (40.6-2).

`InnerAutomorphismNC` does the same as `InnerAutomorphism`, except that the check is omitted whether g ∈ G.

##### 40.6-4 IsConjugatorIsomorphism

`‣ IsConjugatorIsomorphism`( hom ) | ( property )

`‣ IsConjugatorAutomorphism`( hom ) | ( property )

`‣ IsInnerAutomorphism`( hom ) | ( property )

Let hom be a group general mapping (see `IsGroupGeneralMapping` (32.9-4)) with source G. `IsConjugatorIsomorphism` returns `true` if hom is induced by conjugation of G by an element g that lies in G or in a group into which G is naturally embedded in the sense described below, and `false` otherwise.

Natural embeddings are dealt with in the case that G is a permutation group (see Chapter 43), a matrix group (see Chapter 44), a finitely presented group (see Chapter 47), or a group given w.r.t. a polycyclic presentation (see Chapter 46). In all other cases, `IsConjugatorIsomorphism` may return `false` if hom is induced by conjugation but is not an inner automorphism.

If `IsConjugatorIsomorphism` returns `true` for hom then an element g that induces hom can be accessed as value of the attribute `ConjugatorOfConjugatorIsomorphism` (40.6-5).

`IsConjugatorAutomorphism` returns `true` if hom is an automorphism (see `IsEndoGeneralMapping` (32.13-3)) that is regarded as a conjugator isomorphism by `IsConjugatorIsomorphism`, and `false` otherwise.

`IsInnerAutomorphism` returns `true` if hom is a conjugator automorphism such that an element g inducing hom can be chosen in G, and `false` otherwise.

##### 40.6-5 ConjugatorOfConjugatorIsomorphism

`‣ ConjugatorOfConjugatorIsomorphism`( hom ) | ( attribute )

For a conjugator isomorphism hom (see `ConjugatorIsomorphism` (40.6-1)), `ConjugatorOfConjugatorIsomorphism` returns an element g such that mapping under hom is induced by conjugation with g.

To avoid problems with `IsInnerAutomorphism` (40.6-4), it is guaranteed that the conjugator is taken from the source of hom if possible.

    gap> hgens:=[(1,2,3),(1,2,4)];;h:=Group(hgens);;
    gap> hom:=GroupHomomorphismByImages(h,h,hgens,[(1,2,3),(2,3,4)]);;
    gap> IsInnerAutomorphism(hom);
    true
    gap> ConjugatorOfConjugatorIsomorphism(hom);
    (1,2,3)
    gap> hom:=GroupHomomorphismByImages(h,h,hgens,[(1,3,2),(1,4,2)]);
    [ (1,2,3), (1,2,4) ] -> [ (1,3,2), (1,4,2) ]
    gap> IsInnerAutomorphism(hom);
    false
    gap> IsConjugatorAutomorphism(hom);
    true
    gap> ConjugatorOfConjugatorIsomorphism(hom);
    (1,2)

#### 40.7 Groups of Automorphisms

Group automorphism can be multiplied and inverted and thus it is possible to form groups of automorphisms.

##### 40.7-1 AutomorphismGroup

`‣ AutomorphismGroup`( G ) | ( attribute )

returns the full automorphism group of the group G. The automorphisms act on G by the caret operator `^`. The automorphism group often stores a `NiceMonomorphism` (40.5-2) value whose image is a permutation group, obtained by the action on a subset of G.

Note that current methods for the calculation of the automorphism group of a group G require G to be a permutation group or a pc group to be efficient. For groups in other representations the calculation is likely very slow.

Also, the AutPGrp package installs enhanced methods for `AutomorphismGroup` for finite p-groups, and the FGA package - for finitely generated subgroups of free groups.

Methods may be installed for `AutomorphismGroup` for other domains, such as e.g. for linear codes in the GUAVA package, loops in the loops package and nilpotent Lie algebras in the Sophus package (see package manuals for their descriptions).

##### 40.7-2 IsGroupOfAutomorphisms

`‣ IsGroupOfAutomorphisms`( G ) | ( property )

indicates whether G consists of automorphisms of another group H. The group H can be obtained from G via the attribute `AutomorphismDomain` (40.7-3).

##### 40.7-3 AutomorphismDomain

`‣ AutomorphismDomain`( G ) | ( attribute )

If G consists of automorphisms of H, this attribute returns H.

##### 40.7-4 IsAutomorphismGroup

`‣ IsAutomorphismGroup`( G ) | ( property )

indicates whether G, which must be `IsGroupOfAutomorphisms` (40.7-2), is the full automorphism group of another group H, this group is given as `AutomorphismDomain` (40.7-3) value of G.

    gap> g:=Group((1,2,3,4),(1,3));
    Group([ (1,2,3,4), (1,3) ])
    gap> au:=AutomorphismGroup(g);
    <group of size 8 with 3 generators>
    gap> GeneratorsOfGroup(au);
    [ Pcgs([ (2,4), (1,2,3,4), (1,3)(2,4) ]) ->
        [ (1,2)(3,4), (1,2,3,4), (1,3)(2,4) ],
      Pcgs([ (2,4), (1,2,3,4), (1,3)(2,4) ]) ->
        [ (1,3), (1,2,3,4), (1,3)(2,4) ],
      Pcgs([ (2,4), (1,2,3,4), (1,3)(2,4) ]) ->
        [ (2,4), (1,4,3,2), (1,3)(2,4) ] ]
    gap> NiceObject(au);
    Group([ (1,2,4,6), (1,4)(2,6), (2,6)(3,5) ])

##### 40.7-5 InnerAutomorphismsAutomorphismGroup

`‣ InnerAutomorphismsAutomorphismGroup`( autgroup ) | ( attribute )

For an automorphism group autgroup of a group this attribute stores the subgroup of inner automorphisms (automorphisms induced by conjugation) of the original group.

    gap> InnerAutomorphismsAutomorphismGroup(au);
    <group with 2 generators>

##### 40.7-6 InnerAutomorphismGroup

`‣ InnerAutomorphismGroup`( G ) | ( attribute )

For a group G this attribute stores the group of inner automorphisms (automorphisms induced by conjugation) of the original group.

    gap> InnerAutomorphismGroup(SymmetricGroup(5));
    <group with 2 generators>

##### 40.7-7 InducedAutomorphism

`‣ InducedAutomorphism`( epi, aut ) | ( function )

Let aut be an automorphism of a group G and epi be a homomorphism from G to a group H such that the kernel of epi is fixed under aut. Let U be the image of epi. This command returns the automorphism of U induced by aut via epi, that is, the automorphism of U which maps g`^epi` to `(`g`^aut)^epi`, for g ∈ G.

    gap> g:=Group((1,2,3,4),(1,2));
    Group([ (1,2,3,4), (1,2) ])
    gap> n:=Subgroup(g,[(1,2)(3,4),(1,3)(2,4)]);
    Group([ (1,2)(3,4), (1,3)(2,4) ])
    gap> epi:=NaturalHomomorphismByNormalSubgroup(g,n);
    [ (1,2,3,4), (1,2) ] -> [ f1*f2, f1 ]
    gap> aut:=InnerAutomorphism(g,(1,2,3));
    ^(1,2,3)
    gap> InducedAutomorphism(epi,aut);
    ^f2

#### 40.8 Calculating with Group Automorphisms

Usually the best way to calculate in a group of automorphisms is to translate all calculations to an isomorphic group in a representation for which better algorithms are available, such as a permutation group. This translation can be done automatically using `NiceMonomorphism` (40.5-2).

Once a group knows to be a group of automorphisms (this can be achieved by testing or setting the property `IsGroupOfAutomorphisms` (40.7-2)), GAP will try itself to find such a nice monomorphism once calculations in the automorphism group are done.

Note that nice homomorphisms inherit down to subgroups, but cannot necessarily be extended from a subgroup to the whole group. Thus when working with a group of automorphisms, it can be beneficial to enforce calculation of the nice monomorphism for the whole group (for example by explicitly calling `Random` (30.7-1) and ignoring the result –it will be stored internally) at the start of the calculation. Otherwise GAP might first calculate a nice monomorphism for the subgroup, only to be forced to calculate a new nice monomorphism for the whole group later on.

If a good domain for a faithful permutation action is known already, a homomorphism for the action on it can be created using `NiceMonomorphismAutomGroup` (40.8-2). It might be stored by `SetNiceMonomorphism` (see `NiceMonomorphism` (40.5-2)).

Another nice way of representing automorphisms as permutations has been described in [Sim97]. It is not yet available in GAP, a description however can be found in section 87.3.

##### 40.8-1 AssignNiceMonomorphismAutomorphismGroup

`‣ AssignNiceMonomorphismAutomorphismGroup`( autgrp, group ) | ( function )

computes a nice monomorphism for autgroup acting on group and stores it as `NiceMonomorphism` (40.5-2) value of autgrp.

If the centre of `AutomorphismDomain` (40.7-3) of autgrp is trivial, the operation will first try to represent all automorphisms by conjugation (in group or in a natural parent of group).

If this fails the operation tries to find a small subset of group on which the action will be faithful.

The operation sets the attribute `NiceMonomorphism` (40.5-2) and does not return a value.

##### 40.8-2 NiceMonomorphismAutomGroup

`‣ NiceMonomorphismAutomGroup`( autgrp, elms, elmsgens ) | ( function )

This function creates a monomorphism for an automorphism group autgrp of a group by permuting the group elements in the list elms. This list must be chosen to yield a faithful representation. elmsgens is a list of generators which are a subset of elms. (They can differ from the group's original generators.) It does not yet assign it as `NiceMonomorphism` (40.5-2) value.

#### 40.9 Searching for Homomorphisms

##### 40.9-1 IsomorphismGroups

`‣ IsomorphismGroups`( G, H ) | ( function )

computes an isomorphism between the groups G and H if they are isomorphic and returns `fail` otherwise.

With the existing methods the amount of time needed grows with the size of a generating system of G. (Thus in particular for p-groups calculations can be slow.) If you do only need to know whether groups are isomorphic, you might want to consider `IdGroup` (smallgrp: IdGroup) or the random isomorphism test (see `RandomIsomorphismTest` (46.10-1)).

    gap> g:=Group((1,2,3,4),(1,3));;
    gap> h:=Group((1,4,6,7)(2,3,5,8), (1,5)(2,6)(3,4)(7,8));;
    gap> IsomorphismGroups(g,h);
    [ (1,2,3,4), (1,3) ] -> [ (1,4,6,7)(2,3,5,8), (1,2)(3,7)(4,8)(5,6) ]
    gap> IsomorphismGroups(g,Group((1,2,3,4),(1,2)));
    fail

##### 40.9-2 AllHomomorphismClasses

`‣ AllHomomorphismClasses`( G, H ) | ( function )

For two finite groups G and H, this function returns representatives of all homomorphisms G to H up to H-conjugacy.

    gap> AllHomomorphismClasses(SymmetricGroup(4),SymmetricGroup(3));
    [ [ (2,4,3), (1,4,2,3) ] -> [ (), () ],
      [ (2,4,3), (1,4,2,3) ] -> [ (), (1,2) ],
      [ (2,4,3), (1,4,2,3) ] -> [ (1,2,3), (1,2) ] ]

##### 40.9-3 AllHomomorphisms

`‣ AllHomomorphisms`( G, H ) | ( function )

`‣ AllEndomorphisms`( G ) | ( function )

`‣ AllAutomorphisms`( G ) | ( function )

For two finite groups G and H, this function returns all homomorphisms G to H. Since this number will grow quickly, `AllHomomorphismClasses` (40.9-2) should be used in most cases. `AllEndomorphisms` returns all homomorphisms from G to itself, `AllAutomorphisms` returns all bijective endomorphisms.

    gap> AllHomomorphisms(SymmetricGroup(3),SymmetricGroup(3));
    [ [ (2,3), (1,2,3) ] -> [ (), () ],
      [ (2,3), (1,2,3) ] -> [ (1,2), () ],
      [ (2,3), (1,2,3) ] -> [ (2,3), () ],
      [ (2,3), (1,2,3) ] -> [ (1,3), () ],
      [ (2,3), (1,2,3) ] -> [ (2,3), (1,2,3) ],
      [ (2,3), (1,2,3) ] -> [ (1,3), (1,2,3) ],
      [ (2,3), (1,2,3) ] -> [ (1,3), (1,3,2) ],
      [ (2,3), (1,2,3) ] -> [ (1,2), (1,2,3) ],
      [ (2,3), (1,2,3) ] -> [ (2,3), (1,3,2) ],
      [ (2,3), (1,2,3) ] -> [ (1,2), (1,3,2) ] ]

##### 40.9-4 GQuotients

`‣ GQuotients`( F, G ) | ( operation )

computes all epimorphisms from F onto G up to automorphisms of G. This classifies all factor groups of F which are isomorphic to G.

With the existing methods the amount of time needed grows with the size of a generating system of G. (Thus in particular for p-groups calculations can be slow.)

If the `findall` option is set to `false`, the algorithm will stop once one homomorphism has been found (this can be faster and might be sufficient if not all homomorphisms are needed).

    gap> g:=Group((1,2,3,4),(1,2));
    Group([ (1,2,3,4), (1,2) ])
    gap> h:=Group((1,2,3),(1,2));
    Group([ (1,2,3), (1,2) ])
    gap> quo:=GQuotients(g,h);
    [ [ (2,4), (1,4,3) ] -> [ (2,3), (1,2,3) ] ]

##### 40.9-5 IsomorphicSubgroups

`‣ IsomorphicSubgroups`( G, H ) | ( operation )

computes all monomorphisms from H into G up to G-conjugacy of the image groups. This classifies all G-classes of subgroups of G which are isomorphic to H.

With the existing methods, the amount of time needed grows with the size of a generating system of G. (Thus in particular for p-groups calculations can be slow.) A main use of `IsomorphicSubgroups` therefore is to find nonsolvable subgroups (which often can be generated by 2 elements).

(To find p-subgroups it is often faster to compute the subgroup lattice of the Sylow subgroup and to use `IdGroup` (smallgrp: IdGroup) to identify the type of the subgroups.)

If the `findall` option is set to `false`, the algorithm will stop once one homomorphism has been found (this can be faster and might be sufficient if not all homomorphisms are needed).

    gap> g:=Group((1,2,3,4),(1,2));
    Group([ (1,2,3,4), (1,2) ])
    gap> h:=Group((3,4),(1,2));;
    gap> emb:=IsomorphicSubgroups(g,h);
    [ [ (3,4), (1,2) ] -> [ (1,2), (3,4) ],
      [ (3,4), (1,2) ] -> [ (1,3)(2,4), (1,2)(3,4) ] ]
    gap> g1:=PSO(-1,8,2);;
    gap> Length(IsomorphicSubgroups(g1,PSL(2,7)));
    3
    gap> Length(IsomorphicSubgroups(g1,PSL(2,7):findall:=false));
    1

##### 40.9-6 MorClassLoop

`‣ MorClassLoop`( range, classes, params, action ) | ( function )

This function loops over element tuples taken from classes and checks these for properties such as generating a given group, or fulfilling relations. This can be used to find small generating sets or all types of Morphisms. The element tuples are used only up to inner automorphisms as all images can be obtained easily from them by conjugation while running through all of them usually would take too long.

range is a group from which these elements are taken. The classes are given in a list classes which is a list of records with the following components.

`classes`

  list of conjugacy classes

`representative`

  One element in the union of these classes

`size`

  The sum of the sizes of these classes

params is a record containing the following optional components.

`gens`

  generators that are to be mapped (for testing morphisms). The length of this list determines the length of element tuples considered.

`from`

  a preimage group (that contains `gens`)

`to`

  image group (which might be smaller than `range`)

`free`

  free generators, a list of the same length than the generators `gens`.

`rels`

  some relations that hold among the generators `gens`. They are given as a list `[ word, order ]` where `word` is a word in the free generators `free`.

`dom`

  a set of elements on which automorphisms act faithfully (used to do element tests in partial automorphism groups).

`aut`

  Subgroup of already known automorphisms.

`condition`

  A function that will be applied to the homomorphism and must return `true` for the homomorphism to be accepted.

action is a number whose bit-representation indicates the requirements which are enforced on the element tuples found, as follows.

1

  homomorphism

2

  injective

4

  surjective

8

  find all (otherwise stops after the first find)

If the search is for homomorphisms, the function returns homomorphisms obtained by mapping the given generators `gens` instead of element tuples.

The Morpheus algorithm used to find homomorphisms is described in [Hul96, Section V.5].

#### 40.10 Representations for Group Homomorphisms

The different representations of group homomorphisms are used to indicate from what type of group to what type of group they map and thus determine which methods are used to compute images and preimages.

The information in this section is mainly relevant for implementing new methods and not for using homomorphisms.

##### 40.10-1 IsGroupGeneralMappingByImages

`‣ IsGroupGeneralMappingByImages`( map ) | ( representation )

Representation for mappings from one group to another that are defined by extending a mapping of group generators homomorphically. Instead of record components, the attribute `MappingGeneratorsImages` (40.10-2) is used to store generators and their images.

##### 40.10-2 MappingGeneratorsImages

`‣ MappingGeneratorsImages`( map ) | ( attribute )

This attribute contains a list of length 2, the first entry being a list of generators of the source of map and the second entry a list of their images. This attribute is used, for example, by `GroupHomomorphismByImages` (40.1-1) to store generators and images.

##### 40.10-3 IsGroupGeneralMappingByAsGroupGeneralMappingByImages

`‣ IsGroupGeneralMappingByAsGroupGeneralMappingByImages`( map ) | ( representation )

Representation for mappings that delegate work on a `GroupHomomorphismByImages` (40.1-1).

##### 40.10-4 IsPreimagesByAsGroupGeneralMappingByImages

`‣ IsPreimagesByAsGroupGeneralMappingByImages`( map ) | ( representation )

Representation for mappings that delegate work for preimages to a mapping created with `GroupHomomorphismByImages` (40.1-1).

##### 40.10-5 IsPermGroupGeneralMapping

`‣ IsPermGroupGeneralMapping`( map ) | ( representation )

`‣ IsPermGroupGeneralMappingByImages`( map ) | ( representation )

`‣ IsPermGroupHomomorphism`( map ) | ( representation )

`‣ IsPermGroupHomomorphismByImages`( map ) | ( representation )

are the representations for mappings that map from a perm group

##### 40.10-6 IsToPermGroupGeneralMappingByImages

`‣ IsToPermGroupGeneralMappingByImages`( map ) | ( representation )

`‣ IsToPermGroupHomomorphismByImages`( map ) | ( representation )

is the representation for mappings that map to a perm group

##### 40.10-7 IsGroupGeneralMappingByPcgs

`‣ IsGroupGeneralMappingByPcgs`( map ) | ( representation )

is the representations for mappings that map a pcgs to images and thus may use exponents to decompose generators.

##### 40.10-8 IsPcGroupGeneralMappingByImages

`‣ IsPcGroupGeneralMappingByImages`( map ) | ( representation )

`‣ IsPcGroupHomomorphismByImages`( map ) | ( representation )

is the representation for mappings from a pc group

##### 40.10-9 IsToPcGroupGeneralMappingByImages

`‣ IsToPcGroupGeneralMappingByImages`( map ) | ( representation )

`‣ IsToPcGroupHomomorphismByImages`( map ) | ( representation )

is the representation for mappings to a pc group

##### 40.10-10 IsFromFpGroupGeneralMappingByImages

`‣ IsFromFpGroupGeneralMappingByImages`( map ) | ( representation )

`‣ IsFromFpGroupHomomorphismByImages`( map ) | ( representation )

is the representation of mappings from an fp group.

##### 40.10-11 IsFromFpGroupStdGensGeneralMappingByImages

`‣ IsFromFpGroupStdGensGeneralMappingByImages`( map ) | ( representation )

`‣ IsFromFpGroupStdGensHomomorphismByImages`( map ) | ( representation )

is the representation of total mappings from an fp group that give images of the standard generators.

[Top of Book] [Contents] [Previous Chapter] [Next Chapter]
Goto Chapter: Top 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 Bib Ind

generated by GAPDoc2HTML