49 Group Products
  
  This  chapter  describes  the  various  group product constructions that are
  possible in GAP.
  
  At  the  moment  for some of the products methods are available only if both
  factors  are  given  in the same representation or only for certain types of
  groups  such  as  permutation  groups  and pc groups when the product can be
  naturally represented as a group of the same kind.
  
  GAP  does not guarantee that a product of two groups will be in a particular
  representation.  (Exceptions are WreathProductImprimitiveAction (49.4-2) and
  WreathProductProductAction  (49.4-3) which are construction that makes sense
  only for permutation groups, see WreathProduct (49.4-1)).
  
  GAP  however  will try to choose an efficient representation, so products of
  permutation  groups or pc groups often will be represented as a group of the
  same kind again.
  
  Therefore  the only guaranteed way to relate a product to its factors is via
  the embedding and projection homomorphisms, see 49.6.
  
  
  49.1 Direct Products
  
  The  direct  product  of  groups  is  the  cartesian  product  of the groups
  (considered as element sets) with component-wise multiplication.
  
  49.1-1 DirectProduct
  
  DirectProduct( G[, H, ...] )  function
  DirectProductOp( list, expl )  operation
  
  These  functions  construct  the  direct  product  of  the  groups  given as
  arguments. DirectProduct takes an arbitrary positive number of arguments and
  calls  the  operation  DirectProductOp,  which  takes exactly two arguments,
  namely  a  nonempty list list of groups and one of these groups, expl. (This
  somewhat  strange  syntax allows the method selection to choose a reasonable
  method  for  special cases, e.g., if all groups are permutation groups or pc
  groups.)
  
  GAP  will  try to choose an efficient representation for the direct product.
  For  example  the direct product of permutation groups will be a permutation
  group again and the direct product of pc groups will be a pc group.
  
  If the groups are in different representations a generic direct product will
  be  formed  which  may  not be particularly efficient for many calculations.
  Instead  it  may  be worth to convert all factors to a common representation
  first, before forming the product.
  
  For  a direct product P, calling Embedding (32.2-11) with P and n yields the
  homomorphism  embedding the n-th factor into P; calling Projection (32.2-12)
  with P and n yields the projection of P onto the n-th factor, see 49.6.
  
    Example  
    gap> g:=Group((1,2,3),(1,2));;
    gap> d:=DirectProduct(g,g,g);
    Group([ (1,2,3), (1,2), (4,5,6), (4,5), (7,8,9), (7,8) ])
    gap> Size(d);
    216
    gap> e:=Embedding(d,2);
    2nd embedding into Group([ (1,2,3), (1,2), (4,5,6), (4,5), (7,8,9), 
      (7,8) ])
    gap> Image(e,(1,2));
    (4,5)
    gap> Image(Projection(d,2),(1,2,3)(4,5)(8,9));
    (1,2)
    gap> f:=FreeGroup("a","b");;
    gap> g:=f/ParseRelators(f,"a2,b3,(ab)5");
    <fp group on the generators [ a, b ]>
    gap> f2:=FreeGroup("x","y");;
    gap> h:=f2/ParseRelators(f2,"x2,y4,xy=Yx");
    <fp group on the generators [ x, y ]>
    gap> d:=DirectProduct(g,h);
    <fp group on the generators [ a, b, x, y ]>
  
  
  
  49.2 Semidirect Products
  
  The  semidirect  product  of  a  group  N  with  a group G acting on N via a
  homomorphism  α  from  G  into  the automorphism group of N is the cartesian
  product G × N with the multiplication (g, n) ⋅ (h, m) = (gh, n^{h^α}m).
  
  
  49.2-1 SemidirectProduct
  
  SemidirectProduct( G, alpha, N )  operation
  SemidirectProduct( autgp, N )  operation
  
  constructs  the  semidirect product of N with G acting via alpha, which must
  be a homomorphism from G into a group of automorphisms of N.
  
  If  N  is  a  group,  alpha  must  be  a homomorphism from G into a group of
  automorphisms of N.
  
  If N is a full row space over a field F, alpha must be a homomorphism from G
  into  a  matrix group of the right dimension over a subfield of F, or into a
  permutation group (in this case permutation matrices are taken).
  
  In  the  second variant, autgp must be a group of automorphism of N, it is a
  shorthand  for  SemidirectProduct(autgp,IdentityMapping(autgp),N). Note that
  (unless   autgrp  has  been  obtained  by  the  operation  AutomorphismGroup
  (40.7-1))  you  have  to  test IsGroupOfAutomorphisms (40.7-2) for autgrp to
  ensure that GAP knows that autgrp consists of group automorphisms.
  
    Example  
    gap> n:=AbelianGroup(IsPcGroup,[5,5]);
    <pc group of size 25 with 2 generators>
    gap> au:=DerivedSubgroup(AutomorphismGroup(n));;
    gap> Size(au);
    120
    gap> p:=SemidirectProduct(au,n);;
    gap> Size(p);
    3000
    gap> n:=Group((1,2),(3,4));;
    gap> au:=AutomorphismGroup(n);;
    gap> au:=First(AsSet(au),i->Order(i)=3);;
    gap> au:=Group(au);
    <group with 1 generator>
    gap> IsGroupOfAutomorphisms(au);
    true
    gap> SemidirectProduct(au,n);
    <pc group with 3 generators>
    gap> n:=AbelianGroup(IsPcGroup,[2,2]);
    <pc group of size 4 with 2 generators>
    gap> au:=AutomorphismGroup(n);;
    gap> apc:=IsomorphismPcGroup(au);;
    gap> g:=Image(apc);
    Group([ f1, f2 ])
    gap> apci:=InverseGeneralMapping(apc);;
    gap> IsGroupHomomorphism(apci);
    true
    gap> p:=SemidirectProduct(g,apci,n);
    <pc group of size 24 with 4 generators>
    gap> IsomorphismGroups(p,Group((1,2,3,4),(1,2))) <> fail;
    true
    gap> SemidirectProduct(SU(3,3),GF(9)^3);
    <matrix group of size 4408992 with 3 generators>
    gap> SemidirectProduct(Group((1,2,3),(2,3,4)),GF(5)^4);
    <matrix group of size 7500 with 3 generators>
    gap> g:=Group((3,4,5),(1,2,3));;
    gap> mats:=[[[Z(2^2),0*Z(2)],[0*Z(2),Z(2^2)^2]],
    >          [[Z(2)^0,Z(2)^0], [Z(2)^0,0*Z(2)]]];;
    gap> hom:=GroupHomomorphismByImages(g,Group(mats),[g.1,g.2],mats);;
    gap> SemidirectProduct(g,hom,GF(4)^2);
    <matrix group of size 960 with 3 generators>
    gap> SemidirectProduct(g,hom,GF(16)^2);
    <matrix group of size 15360 with 4 generators>
  
  
  For  a  semidirect product P of G with N, calling Embedding (32.2-11) with P
  and  1  yields  the embedding of G, calling Embedding (32.2-11) with P and 2
  yields  the  embedding  of N; calling Projection (32.2-12) with P yields the
  projection of P onto G, see 49.6.
  
    Example  
    gap> Size(Image(Embedding(p,1)));
    6
    gap> Embedding(p,2);
    [ f1, f2 ] -> [ f3, f4 ]
    gap> Projection(p);
    [ f1, f2, f3, f4 ] -> [ f1, f2, <identity> of ..., <identity> of ... ]
  
  
  
  49.3 Subdirect Products
  
  The subdirect product of the groups G and H with respect to the epimorphisms
  φ:  G  → A and ψ: H → A (for a common group A) is the subgroup of the direct
  product  G  ×  H consisting of the elements (g,h) for which g^φ = h^ψ. It is
  the pull-back of the following diagram.
  
                     G
                     | phi
               psi   V
            H  --->  A
  
  49.3-1 SubdirectProduct
  
  SubdirectProduct( G, H, Ghom, Hhom )  function
  
  constructs the subdirect product of G and H with respect to the epimorphisms
  Ghom from G onto a group A and Hhom from H onto the same group A.
  
  For  a subdirect product P, calling Projection (32.2-12) with P and n yields
  the projection on the n-th factor. (In general the factors do not embed into
  a subdirect product.)
  
    Example  
    gap> g:=Group((1,2,3),(1,2));
    Group([ (1,2,3), (1,2) ])
    gap> hom:=GroupHomomorphismByImagesNC(g,g,[(1,2,3),(1,2)],[(),(1,2)]);
    [ (1,2,3), (1,2) ] -> [ (), (1,2) ]
    gap> s:=SubdirectProduct(g,g,hom,hom);
    Group([ (1,2,3), (1,2)(4,5), (4,5,6) ])
    gap> Size(s);
    18
    gap> p:=Projection(s,2);
    2nd projection of Group([ (1,2,3), (1,2)(4,5), (4,5,6) ])
    gap> Image(p,(1,3,2)(4,5,6));
    (1,2,3)
  
  
  49.3-2 SubdirectProducts
  
  SubdirectProducts( G, H )  function
  
  this  function computes all subdirect products of G and H up to conjugacy in
  the  direct  product  of Parent(G) and Parent(H). The subdirect products are
  returned as subgroups of this direct product.
  
  
  49.4 Wreath Products
  
  The  wreath  product  of  a  group  G with a permutation group P acting on n
  points is the semidirect product of the normal subgroup G^n with the group P
  which acts on G^n by permuting the components.
  
  Note  that  GAP always considers the domain of a permutation group to be the
  points  moved  by elements of the group as returned by MovedPoints (42.3-3),
  i.e. it is not possible to have a domain to include fixed points, I.e. P = ⟨
  (1,2,3)  ⟩  and  P  =  ⟨ (1,3,5) ⟩ result in isomorphic wreath products. (If
  fixed  points  are  desired the wreath product G ≀ T has to be formed with a
  transitive overgroup T of P and then the pre-image of P under the projection
  G ≀ T → T has to be taken.)
  
  49.4-1 WreathProduct
  
  WreathProduct( G, H[, hom] )  operation
  StandardWreathProduct( G, H )  operation
  
  WreathProduct constructs the wreath product of the group G with the group H,
  acting as a permutation group.
  
  If  a  third  argument hom is given, it must be a homomorphism from H into a
  permutation  group,  and  the  action  of  this group on its moved points is
  considered.
  
  If only two arguments are given, H must be a permutation group.
  
  StandardWreathProduct  returns  the  wreath  product for the (right regular)
  permutation action of H on its elements.
  
  For a wreath product W of G with a permutation group P of degree n and 1 ≤ i
  ≤  n  calling  Embedding (32.2-11) with W and i yields the embedding of G in
  the i-th component of the direct product of the base group G^n of W. For i =
  n+1,  Embedding  (32.2-11)  yields  the  embedding  of  P  into  W.  Calling
  Projection  (32.2-12)  with W yields the projection onto the acting group P,
  see 49.6.
  
    Example  
    gap> g:=Group((1,2,3),(1,2));
    Group([ (1,2,3), (1,2) ])
    gap> p:=Group((1,2,3));
    Group([ (1,2,3) ])
    gap> w:=WreathProduct(g,p);
    Group([ (1,2,3), (1,2), (4,5,6), (4,5), (7,8,9), (7,8), 
      (1,4,7)(2,5,8)(3,6,9) ])
    gap> Size(w);
    648
    gap> Embedding(w,1);
    1st embedding into Group( [ (1,2,3), (1,2), (4,5,6), (4,5), (7,8,9), 
      (7,8), (1,4,7)(2,5,8)(3,6,9) ] )
    gap> Image(Embedding(w,3));
    Group([ (7,8,9), (7,8) ])
    gap> Image(Embedding(w,4));
    Group([ (1,4,7)(2,5,8)(3,6,9) ])
    gap> Image(Projection(w),(1,4,8,2,6,7,3,5,9));
    (1,2,3)
  
  
  49.4-2 WreathProductImprimitiveAction
  
  WreathProductImprimitiveAction( G, H )  function
  
  For  two  permutation  groups  G  and H, this function constructs the wreath
  product of G and H in the imprimitive action. If G acts on l points and H on
  m  points this action will be on l ⋅ m points, it will be imprimitive with m
  blocks of size l each.
  
  The  operations Embedding (32.2-11) and Projection (32.2-12) operate on this
  product as described for general wreath products.
  
    Example  
    gap> w:=WreathProductImprimitiveAction(g,p);;
    gap> LargestMovedPoint(w);
    9
  
  
  49.4-3 WreathProductProductAction
  
  WreathProductProductAction( G, H )  function
  
  For  two  permutation  groups  G  and H, this function constructs the wreath
  product  in  product  action.  If  G acts on l points and H on m points this
  action will be on l^m points.
  
  The  operations Embedding (32.2-11) and Projection (32.2-12) operate on this
  product as described for general wreath products.
  
    Example  
    gap> w:=WreathProductProductAction(g,p);
    <permutation group of size 648 with 7 generators>
    gap> LargestMovedPoint(w);
    27
  
  
  49.4-4 KuKGenerators
  
  KuKGenerators( G, beta, alpha )  function
  
  If  beta is a homomorphism from G into a transitive permutation group, U the
  full preimage of the point stabilizer and alpha a homomorphism defined on (a
  superset)  of  U,  this  function returns images of the generators of G when
  mapping  to  the  wreath  product  (U  alpha)  ≀  (G  beta).  (This  is  the
  Krasner-Kaloujnine embedding theorem.)
  
    Example  
    gap> g:=Group((1,2,3,4),(1,2));;
    gap> hom:=GroupHomomorphismByImages(g,Group((1,2)),
    > GeneratorsOfGroup(g),[(1,2),(1,2)]);;
    gap> u:=PreImage(hom,Stabilizer(Image(hom),1));
    Group([ (2,3,4), (1,2,4) ])
    gap> hom2:=GroupHomomorphismByImages(u,Group((1,2,3)),
    > GeneratorsOfGroup(u),[ (1,2,3), (1,2,3) ]);;
    gap> KuKGenerators(g,hom,hom2);
    [ (1,4)(2,5)(3,6), (1,6)(2,4)(3,5) ]
  
  
  49.4-5 ListWreathProductElement
  
  ListWreathProductElement( G, x[, testDecomposition] )  function
  ListWreathProductElementNC( G, x, testDecomposition )  operation
  
  Let  x  be  an element of a wreath product G where G = K ≀ H and H acts as a
  finite  permutation  group of degree m. We can identify the element x with a
  tuple  (f_1, ..., f_m; h), where f_i ∈ K is the i-th base component of x and
  h ∈ H is the top component of x.
  
  ListWreathProductElement  returns  a  list [f_1, ..., f_m, h] containing the
  components of x or fail if x cannot be decomposed in the wreath product.
  
  If   ommited,   the   argument   testDecomposition   defaults  to  true.  If
  testDecomposition  is  true, ListWreathProductElement makes additional tests
  to  ensure  that  the computed decomposition of x is correct, i.e. it checks
  that x is an element of the parent wreath product of G:
  
  If K ≤ Sym(l), this ensures that x ∈ Sym(l) ≀ Sym(m) where the parent wreath
  product  is  considered  in the same action as G, i.e. either in imprimitive
  action or product action.
  
  If K ≤ GL(n,q), this ensures that x ∈ GL(n,q) ≀ Sym(m).
  
  49.4-6 WreathProductElementList
  
  WreathProductElementList( G, list )  function
  WreathProductElementListNC( G, list )  operation
  
  Let  list be equal to [f_1, ..., f_m, h] and G be a wreath product where G =
  K ≀ H, H acts as a finite permutation group of degree m, f_i ∈ K and h ∈ H.
  
  WreathProductElementList  returns  the element x ∈ G identified by the tuple
  (f_1, ..., f_m; h).
  
  
  49.5 Free Products
  
  Let  G  and  H  be  groups  with  presentations  ⟨  X  ∣  R ⟩ and ⟨ Y ∣ S ⟩,
  respectively. Then the free product G*H is the group with presentation ⟨ X ∪
  Y  ∣ R ∪ S ⟩. This construction can be generalized to an arbitrary number of
  groups.
  
  
  49.5-1 FreeProduct
  
  FreeProduct( G[, H, ...] )  function
  FreeProduct( list )  function
  
  constructs  a  finitely  presented  group  which  is the free product of the
  groups given as arguments. If the group arguments are not finitely presented
  groups, then IsomorphismFpGroup (47.11-1) must be defined for them.
  
  The operation Embedding (32.2-11) operates on this product.
  
    Example  
    gap> g := DihedralGroup(8);;
    gap> h := CyclicGroup(5);;
    gap> fp := FreeProduct(g,h,h);
    <fp group on the generators [ f1, f2, f3, f4, f5 ]>
    gap> fp := FreeProduct([g,h,h]);
    <fp group on the generators [ f1, f2, f3, f4, f5 ]>
    gap> Embedding(fp,2);
    [ f1 ] -> [ f4 ]
  
  
  
  49.6 Embeddings and Projections for Group Products
  
  The  relation  between  a  group  product  and  its  factors is provided via
  homomorphisms,  the  embeddings  in the product and the projections from the
  product. Depending on the kind of product only some of these are defined.
  
  49.6-1 Embedding
  
  Embedding( P, nr )  operation
  
  returns  the  nr-th  embedding in the group product P. The actual meaning of
  this  embedding  is  described  in  the  manual  section for the appropriate
  product.
  
  49.6-2 Projection
  
  Projection( P, nr )  operation
  
  returns the (nr-th) projection of the group product P. The actual meaning of
  the  projection  returned  is  described  in  the  manual  section  for  the
  appropriate product.