This chapter serves as an introduction and showcases some highlights of the package WPE.
The package WPE (Wreath Product Elements) provides methods to work with elements of finite groups which are wreath products. It contributes to
It allows access to a representation of wreath products, which we refer to as the generic representation, that is more intuitive to the User when working with wreath products of groups. Access is as straight-forward as using the provided command IsomorphismWreathProduct on a wreath product created by the native GAP command WreathProduct, see 1.2 for an example.
Additionally, this representation may have computational benefits over other representations. Note, that just by loading the package WPE and without any additional setup, all optimizations are applied to computations in wreath products created by the native GAP command WreathProduct, by exploiting the generic representation under the hood when appropiate. See 1.3 for a highlight showcase of such computational problems.
In particular, this package provides efficient methods for finding conjugating elements, conjugacy classes, and centralizers in wreath products. The implementations are based on an accompanying publication [BNRW22], that generalizes results from [Spe32] and [Ore42] on monomial groups, wreath products whose top group is the full symmetric group.
For example, the computation of all \(886\,640\) conjugacy classses of elements of the wreath product \(W = \textrm{M}_{22} \wr \textrm{A}_9\) takes about 12 seconds with WPE. With native GAP this computation is not feasible.
gap> LoadPackage("WPE");; gap> K := MathieuGroup(22);; gap> H := AlternatingGroup(9);; gap> G := WreathProduct(K, H);; gap> C := ConjugacyClasses(G);; gap> Size(C); 886640
One of the two main goals of the package is to provide the User with tools to conduct intuitive research in wreath products of groups on the computer.
In this section we present an example session which demonstrates how we can access the generic representation of a wreath product. As noted in the introduction, no additional setup is required if one wants to benefit from the optimizations for computations in wreath products (see 1.3 for examples on this).
First we construct the wreath product \(G = \textrm{Alt}(5) \wr \textrm{Sym}(7)\) (see 2.1). For this we use the native GAP command WreathProduct (Reference: WreathProduct). The resulting group is embedded into a symmetric group on \(5 \cdot 7 = 35\) points via the imprimitive action of the wreath product. The size of the group is
\[ \vert G \vert = \vert\textrm{Alt}(5)\vert^7 \cdot \vert\textrm{Sym}(7)\vert = 60^7 \cdot 5\,040 = 14\,108\,774\,400\,000\,000\;. \]
gap> K := AlternatingGroup(5);; gap> H := SymmetricGroup(7);; gap> G := WreathProduct(K, H); <permutation group of size 14108774400000000 with 4 generators>
Now we construct an isomorphism to a wreath product given in generic representation that is provided in WPE. For this, we need to load the package WPE.
gap> LoadPackage("WPE");; gap> iso := IsomorphismWreathProduct(G);; gap> W := Image(iso); <group of size 14108774400000000 with 4 generators>
Let us compare how GAP displays elements of \(G\) and \(W\) respectively. Elements of \(G\) are represented as permutations. In this representation it is hard to identify the base and top components of this element (see 2.1).
gap> g := (1,13,3,14,4,12,2,15,5,11) > (6,31,21,7,35,25,9,33,23,8,34,24,10,32,22) > (18,19,20);; gap> g in G; true
Elements of \(W\) however are represented as generic wreath product elements (see 2.1). This allows us to read off the base and top component of the element easily by either printing or displaying the element. Otherwise, by default the element is viewed in compressed form (see 4.4). This printing behaviour is similar to the behaviour of matrices in GAP.
gap> w := g ^ iso; < wreath product element with 7 base components > gap> Print(w); [ (1,3,4,2,5), (2,5)(3,4), (), (3,4,5), (1,2)(4,5), (), (), (1,3)(2,7,5) ] gap> Display(w); 1 2 3 4 5 6 7 top ( (1,3,4,2,5), (2,5)(3,4), (), (3,4,5), (1,2)(4,5), (), (); (1,3)(2,7,5) )
Furthermore, we can display and access each component easily with the provided commands.
gap> BaseComponentOfWreathProductElement(w, 2); (2,5)(3,4) gap> TopComponentOfWreathProductElement(w); (1,3)(2,7,5)
This component-wise representation is often exactly the one that we encounter in research on wreath products. Thus having it available on the computer greatly sharpens our intuition. We can make very non-trivial statements by looking at the components of such an element, and for the case of the element \(w\) even without a computer.
Let us start off with an easy observation. Just by looking at the top component of \(w\), i.e. \((1,3)(2,7,5)\), we can see that the smallest power of \(w\) that lies in the base group of \(W\) has exponent \(6\), since it has to be equal to the order of the top component.
gap> m := Order(w); 30 gap> First( [1 .. m], k -> IsOne(TopComponentOfWreathProductElement(w ^ k)) ); 6 gap> Display(w ^ 6); 1 2 3 4 5 6 7 top ( (1,2,3,5,4), (1,4,5,2,3), (1,2,3,5,4), (), (1,3,2,5,4), (), (1,3,2,5,4); () )
Now let us be more advanced. Just by looking at the element \(w\), we can deduce structural information on the conjugacy class \(w^W\). All elements conjugate to \(w\) in \(W = K \wr H\) must have at least one trivial base component, since the territory of \(w\) (see 2.2) contains exactly six elements, whereas the top group acts on seven points.
gap> Length(Territory(w)); 6 gap> NrMovedPoints(H); 7
On the other hand, all such elements must have at least three non-trivial base components, since the wreath cycle decomposition of \(w\) (see 2.2) contains exactly three wreath cycles with non-trivial yades (see 2.3).
gap> Number(WreathCycleDecomposition(w), c -> not IsOne(Yade(c))); 3
Moreover, for each integer \(k\) with \(3 \leq k \leq 6\) there exists at least one conjugate element with exactly \(k\) non-trivial base components.
One of the two main goals of the package is to empower the User to carry out efficient computations in wreath products of groups on the computer.
In this section we present a highlight showcase of computational problems that benefit from the generic representation. As noted in the introduction, no additional setup is required if one wants to benefit from the optimizations for computations in wreath products. We simply create the wreath products via the native GAP command WreathProduct (Reference: WreathProduct), and the generic representation provided by WPE is used under the hood whenever appropiate.
We only give a summary of some computational problems that now become approachable on the computer, and include examples for such computations in Chapter 3 containing extensive GAP sessions that can be followed like a tutorial.
In the following let \(G = K \wr H\) be a wreath product of finite groups, where \(H \leq \textrm{Sym}(m)\). Further let \(x, y \in P = K \wr \textrm{Sym}(m)\) be elements of the parent wreath product \(P\) which is given in the same representation as \(G\).
Solve the conjugacy problem for \(x\) and \(y\) over \(G\), i.e. decide whether there exists \(c \in G\) with \(x^c = y\) and if it does, explicitly compute such a conjugating element \(c\).
Enumerate representatives of all conjugacy classes of elements of \(G\), i.e. return elements \(g_1, \dots, g_\ell\) such that \(g_1^G, \dots, g_\ell^G\) are the conjugacy classes of \(G\).
Compute the centralizer of \(x\) in \(G\), i.e. compute a generating set of \(C_G(x)\).
Compute the cycle index polynomial of \(G\) either for the imprimitive action or the product action.
generated by GAPDoc2HTML