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 off]

49 Group Products
49.1 Direct Products
49.1-1 DirectProduct
49.2 Semidirect Products
49.2-1 SemidirectProduct
49.3 Subdirect Products
49.3-1 SubdirectProduct
49.3-2 SubdirectProducts
49.4 Wreath Products
49.4-1 WreathProduct
49.4-2 WreathProductImprimitiveAction
49.4-3 WreathProductProductAction
49.4-4 KuKGenerators
49.4-5 ListWreathProductElement
49.4-6 WreathProductElementList
49.5 Free Products
49.5-1 FreeProduct
49.6 Embeddings and Projections for Group Products
49.6-1 Embedding
49.6-2 Projection

### 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.

    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 \(\alpha\) from \(G\) into the automorphism group of \(N\) is the cartesian product \(G \times N\) with the multiplication \((g, n) \cdot (h, m) = (gh, n^{{h^\alpha}}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.

    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.

    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 \(\varphi\colon G \rightarrow A\) and \(\psi\colon H \rightarrow A\) (for a common group \(A\)) is the subgroup of the direct product \(G \times H\) consisting of the elements \((g,h)\) for which \(g^{\varphi} = h^{\psi}\). 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.)

    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 \(\textit{G}^n\) with the group \(P\) which acts on \(\textit{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 = \langle (1,2,3) \rangle\) and \(P = \langle (1,3,5) \rangle\) result in isomorphic wreath products. (If fixed points are desired the wreath product \(G \wr T\) has to be formed with a transitive overgroup \(T\) of \(P\) and then the pre-image of \(P\) under the projection \(G \wr T \rightarrow 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 \leq i \leq 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 \(\textit{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.

    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 \cdot 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.

    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.

    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 \textit{alpha}) \wr (\textit{G} \textit{beta})\). (This is the Krasner-Kaloujnine embedding theorem.)

    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 \wr H\) and \(H\) acts as a finite permutation group of degree \(m\). We can identify the element x with a tuple \((f_1, \ldots, f_m; h)\), where \(f_i \in K\) is the \(i\)-th base component of x and \(h \in H\) is the top component of x.

`ListWreathProductElement` returns a list \([f_1, \ldots, f_m, h]\) containing the components of x or `fail` if x cannot be decomposed in the wreath product.

If omitted, 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 \leq \mathop{Sym}(l)\), this ensures that \(x \in \mathop{Sym}(l) \wr \mathop{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 \leq \mathop{GL}(n,q)\), this ensures that \(x \in \mathop{GL}(n,q) \wr \mathop{Sym}(m)\).

##### 49.4-6 WreathProductElementList

`‣ WreathProductElementList`( G, list ) | ( function )

`‣ WreathProductElementListNC`( G, list ) | ( operation )

Let list be equal to \([f_1, \ldots, f_m, h]\) and G be a wreath product where \(G = K \wr H\), \(H\) acts as a finite permutation group of degree \(m\), \(f_i \in K\) and \(h \in H\).

`WreathProductElementList` returns the element \(x \in G\) identified by the tuple \((f_1, \ldots, f_m; h)\).

#### 49.5 Free Products

Let \(G\) and \(H\) be groups with presentations \(\langle X \mid R \rangle\) and \(\langle Y \mid S \rangle\), respectively. Then the free product \(G*H\) is the group with presentation \(\langle X \cup Y \mid R \cup S \rangle\). 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.

    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.

[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