Welcome To Our Shell

Mister Spy & Souheyl Bypass Shell

  
  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 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.)
  
    Example  
    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).)
  
    Example  
    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).
  
    Example  
    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).)
  
    Example  
    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.
  
    Example  
    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.
  
    Example  
    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.)
  
    Example  
    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.25-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).
  
  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.
  
  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.
  
    Example  
    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,  say.  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.
  
    Example  
    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, say. 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 is the full automorphism group of another group H, this
  group is given as AutomorphismDomain (40.7-3) value of G.
  
    Example  
    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,3,4), (1,3)(2,4), (2,4) ])
  
  
  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.
  
    Example  
    gap> InnerAutomorphismsAutomorphismGroup(au);
    <group with 2 generators>
  
  
  40.7-6 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.
  
    Example  
    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,  say  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)).
  
    Example  
    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  groups  G  and  H,  this  function  returns representatives of all
  homomorphisms G to H up to H-conjugacy.
  
    Example  
    gap> AllHomomorphismClasses(SymmetricGroup(4),SymmetricGroup(3)); 
    [ [ (1,2,3), (2,4) ] -> [ (), () ],
      [ (1,2,3), (2,4) ] -> [ (), (1,2) ],
      [ (1,2,3), (2,4) ] -> [ (1,2,3), (1,2) ] ]
  
  
  40.9-3 AllHomomorphisms
  
  AllHomomorphisms( G, H )  function
  AllEndomorphisms( G )  function
  AllAutomorphisms( G )  function
  
  For  two  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.
  
    Example  
    gap> AllHomomorphisms(SymmetricGroup(3),SymmetricGroup(3));
    [ [ (1,2,3), (1,2) ] -> [ (), () ], 
      [ (1,2,3), (1,2) ] -> [ (), (1,2) ], 
      [ (1,2,3), (1,2) ] -> [ (), (2,3) ], 
      [ (1,2,3), (1,2) ] -> [ (), (1,3) ], 
      [ (1,2,3), (1,2) ] -> [ (1,2,3), (1,2) ], 
      [ (1,2,3), (1,2) ] -> [ (1,2,3), (2,3) ], 
      [ (1,2,3), (1,2) ] -> [ (1,3,2), (1,2) ], 
      [ (1,2,3), (1,2) ] -> [ (1,2,3), (1,3) ], 
      [ (1,2,3), (1,2) ] -> [ (1,3,2), (1,3) ], 
      [ (1,2,3), (1,2) ] -> [ (1,3,2), (2,3) ] ]
  
  
  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).
  
    Example  
    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);
    [ [ (1,2,3,4), (1,3,4) ] -> [ (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).
  
    Example  
    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) ] ]
  
  
  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 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.