In this section we present an example session which demonstrates
how we can create wreath products elements by specifying its components. <P/>
In the following we will work with the wreath product <M>G = \textrm{Alt}(5) \wr \textrm{Sym}(4)</M>. <P/>
<Example><![CDATA[
gap> LoadPackage("WPE");;
gap> K := AlternatingGroup(5);;
gap> H := SymmetricGroup(4);;
gap> G := WreathProduct(K, H);
<permutation group of size 311040000 with 10 generators>
]]></Example>
The resulting group <M>G</M> is embedded into a symmetric group on <M>5 \cdot 4 = 20</M> points
via the imprimitive action of the wreath product.
The size of the group is
<Display Mode="M">
\vert G \vert = \vert\textrm{Alt}(5)\vert^4 \cdot \vert\textrm{Sym}(4)\vert = 60^4 \cdot 24 = 311\,040\,000\;.
</Display><P/>
Suppose we would like to input the wreath product element
<Display Mode="M">
g = (\; (1,5,2,4,3),\, (1,3,5,2,4),\, (1,5,3,4,2),\, (1,4,5);\; (1,3)(2,4) \;)
</Display>
as an element of <M>G</M>.
The method <C>WreathProductElementList</C> is the preferred way to create
a wreath product element by specifying its components.
Note that we first specify the four base components and at the end the top component as the last entry. <P/>
<Example><![CDATA[
gap> gList := [ (1,5,2,4,3), (1,3,5,2,4), (1,5,3,4,2), (1,4,5), (1,3)(2,4) ];;
gap> g := WreathProductElementList(G, gList);
(1,15,3,11,5,12)(2,14)(4,13)(6,18,8,20)(7,19,10,17)(9,16)
gap> g in G;
true
]]></Example>
On the other hand, the method <C>ListWreathProductElement</C> can be used
to get a list containing the components of a wreath product element. <P/>
<Example><![CDATA[
gap> ListWreathProductElement(G, g);
[ (1,5,2,4,3), (1,3,5,2,4), (1,5,3,4,2), (1,4,5), (1,3)(2,4) ]
gap> last = gList;
true
]]></Example>
The package author has implemented the methods
<Ref BookName="Reference" Func="ListWreathProductElement"/> and
<Ref BookName="Reference" Func="WreathProductElementList"/>
in &GAP; in order to translate between list representations
of wreath product elements and other representations.
The naming conventions are the same as for <C>ListPerm</C> and <C>PermList</C>. <P/>
Moreover, all functions that work for <C>IsWreathProductElement</C>
can also be used on these list representations.
However, it is not checked if the list indeed represents a wreath product element. <P/>
<Example><![CDATA[
gap> Territory(gList);
[ 1, 2, 3, 4 ]
]]></Example>
If the wreath product element is "sparse",
i.e. has only a few non-trivial components,
it might be easier to create it by embedding its non-trivial components
into <M>G</M> directly and multiplying them.
Note however, that <C>WreathProductElementList</C> might be faster as it avoids group multiplications. <P/>
<Example><![CDATA[
gap> h := (1,2,3) ^ Embedding(G,2)
> * (1,5,2,4,3) ^ Embedding(G,4)
> * (1,2,4) ^ Embedding(G, 5);
(1,6,17,4,9,19,3,8,16,5,10,20,2,7,18)
gap> hList := ListWreathProductElement(G, h);
[ (), (1,2,3), (), (1,5,2,4,3), (1,2,4) ]
gap> IsWreathCycle(hList);
true
]]></Example>
</Section>
<Section Label="Tutorial Display Wreath Product Elements">
<Heading>Displaying Wreath Product Elements</Heading>
In this section we present an example session which demonstrates
how we can display wreath product elements in an intuitive way.
Wreath product elements are viewed, printed and displayed (see
section <Ref BookName="Reference" Sect="View and Print"/> for the distinctions between these
operations) as generic wreath product elements (see section <Ref Sect="Wreath Product"/>). <P/>
Suppose we are given some element <M>g</M> in the wreath product
<M>G = \textrm{Alt}(5) \wr \textrm{Sym}(4)</M>,
and would like to view its components in a nice way. <P/>
<Example><![CDATA[
gap> LoadPackage("WPE");;
gap> K := AlternatingGroup(5);;
gap> H := SymmetricGroup(4);;
gap> G := WreathProduct(K, H);;
gap> iso := IsomorphismWreathProduct(G);;
gap> W := Image(iso);;
gap> g := (1,15,8,20)(2,14,7,19,5,12,6,18,3,11,10,17)(4,13,9,16);;
gap> g in G;
true
]]></Example>
First we translate the element <M>g</M> into a generic wreath product element <M>w</M>.
&GAP; uses <C>ViewObj</C> to print <M>w</M> in a compressed form. <P/>
<Example><![CDATA[
gap> w := g ^ iso;
< wreath product element with 4 base components >
]]></Example>
If we want to print this element in a "machine-readable" way,
we could use one of the following methods. <P/>
<Example><![CDATA[
gap> Print(w);
[ (1,5,2,4,3), (1,3,5,2,4), (1,5,3,4,2), (1,4,5), (1,3,2,4) ]
gap> L := ListWreathProductElement(W, w);
[ (1,5,2,4,3), (1,3,5,2,4), (1,5,3,4,2), (1,4,5), (1,3,2,4) ]
gap> L = ListWreathProductElement(G, g);
true
]]></Example>
Usually, we want to display this element in a nice format instead,
which is "human-readable" and allows us to quickly distinguish components. <P/>
<Example><![CDATA[
gap> Display(w);
1 2 3 4 top
( (1,5,2,4,3), (1,3,5,2,4), (1,5,3,4,2), (1,4,5); (1,3,2,4) )
]]></Example>
There are many display options available for adjusting the display behaviour
for wreath product elements to your liking (see <Ref Label="Display Functions"/>).
For example, we might want to display the element vertically.
We can do this for a single call to the `Display` command without
changing the global display options like this: <P/>
<Example><![CDATA[
gap> Display(w, rec(horizontal := false));
1: (1,5,2,4,3)
2: (1,3,5,2,4)
3: (1,5,3,4,2)
4: (1,4,5)
top: (1,3,2,4)
gap> Display(w);
1 2 3 4 top
( (1,5,2,4,3), (1,3,5,2,4), (1,5,3,4,2), (1,4,5); (1,3,2,4) )
]]></Example>
We can also change the global display options via the following command.
<Example><![CDATA[
gap> SetDisplayOptionsForWreathProductElements(rec(horizontal := false));
gap> Display(w);
1: (1,5,2,4,3)
2: (1,3,5,2,4)
3: (1,5,3,4,2)
4: (1,4,5)
top: (1,3,2,4)
]]></Example>
All changes to the global behaviour can be reverted to the default behaviour via the following command.
<Example><![CDATA[
gap> ResetDisplayOptionsForWreathProductElements();
gap> Display(w);
1 2 3 4 top
( (1,5,2,4,3), (1,3,5,2,4), (1,5,3,4,2), (1,4,5); (1,3,2,4) )
]]></Example>
But sometimes, it is sufficient to just look at some components
of a wreath product element. We can directly use the list representation
to access the components on a low-level or we can use high-level
functions on wreath product elements instead.
<Example><![CDATA[
gap> a := BaseComponentOfWreathProductElement(w, 3);
(1,5,3,4,2)
gap> a = L[3];
true
gap> b := TopComponentOfWreathProductElement(w);
(1,3,2,4)
gap> b = L[5];
true
]]></Example>
<P/>
</Section>
<Section Label="Tutorial Efficient Computing">
<Heading>Computing in Wreath Products</Heading>
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 <Ref BookName="Reference" Oper="WreathProduct"/>,
and the generic representation is used under the hood whenever appropiate. <P/>
We include in the following sections examples for each computational problem listed in <Ref Sect="Intro Computations"/>.
For all such examples we fix the following wreath product.
<Example><![CDATA[
gap> LoadPackage("WPE");;
gap> K := Group([ (1,2,3,4,5), (1,2,4,3) ]);; # F(5)
gap> H := Group([ (1,2,3,4,5,6), (2,6)(3,5) ]);; # D(12)
gap> G := WreathProduct(K, H);
<permutation group of size 768000000 with 4 generators>
gap> P := WreathProduct(K, SymmetricGroup(NrMovedPoints(H)));
<permutation group of size 46080000000 with 4 generators>
gap> IsSubgroup(P, G);
true
gap> iso := IsomorphismWreathProduct(P);;
]]></Example>
Moreover, we fix the following elements of the parent wreath product <M>P</M>.
We choose them in such a way, that they do not lie in the smaller wreath product <M>G</M> for demonstration purposes only.
<Example><![CDATA[
gap> x := (1,23,12,6,4,24,13,9,5,21,15,10,2,25,14,7)(3,22,11,8)(16,30,20,28)(17,27,19,26)(18,29);;
gap> y := (1,12,26,8,3,14,28,7,2,13,27,10,5,11,30,6)(4,15,29,9)(16,23,20,22)(17,24,19,21)(18,25);;
gap> Display(x ^ iso);
1 2 3 4 5 6 top
( (1,3,2,5), (1,4,5,2), (1,3,4,2), (1,5,3,4), (1,5,4,3,2), (1,2,4,3); (1,5,3,2)(4,6) )
gap> Display(y ^ iso);
1 2 3 4 5 6 top
( (1,2,3,4,5), (), (1,5,4,3,2), (1,3,5,2,4), (1,2)(3,5), (1,3,2,5); (1,3,6,2)(4,5) )
gap> x in P and y in P;
true
gap> not x in G and not y in G;
true
]]></Example>
</Section>
<Section>
<Heading>Conjugacy Problem</Heading>
We now demonstrate how to solve the conjugacy problem for <M>x</M> and <M>y</M> over <M>G</M>,
i.e. decide whether there exists <M>c \in G</M> with <M>x^c = y</M>
and if it does, explicitly compute such a conjugating element <M>c</M>. <P/>
We continue the &GAP; session from Section <Ref Sect="Tutorial Efficient Computing"/>. <P/>
To check in &GAP; whether two elements are conjugate in a group we use native &GAP; command <Ref BookName="Reference" Func="RepresentativeAction"/>.
<Example><![CDATA[
gap> RepresentativeAction(G, x, y);
fail
]]></Example>
The output <C>fail</C> indicates, that <M>x</M> and <M>y</M> are not conjugate over <M>G</M>.
But are <M>x</M> and <M>y</M> conjugate in the parent wreath product?
<Example><![CDATA[
gap> c := RepresentativeAction(P, x, y);
(2,5)(3,4)(6,8,9,7)(11,29,25)(12,26,21,13,28,22,15,27,24,14,30,23)
gap> Display(c^iso);
1 2 3 4 5 6 top
( (2,5)(3,4), (1,3,4,2), (1,4,5,2), (), (1,3,2,5), (2,4,5,3); (3,6,5) )
gap> x ^ c = y;
true
]]></Example>
We see, that indeed these elements are conjugate over the larger wreath product <M>P</M> by the conjugating element <M>c \in P</M>.
</Section>
<Section>
<Heading>Conjugacy Classes</Heading>
Enumerate representatives of all conjugacy classes of elements of <M>G</M>,
i.e. return elements <M>g_1, \dots, g_\ell</M> such that <M>g_1^G, \dots, g_\ell^G</M>
are the conjugacy classes of <M>G</M>. <P/>
We continue the &GAP; session from Section <Ref Sect="Tutorial Efficient Computing"/>.
In particular recall the definition of the isomorphism <C>iso</C>.<P/>
To compute in &GAP; the conjugacy classes of elements of a group we use <Ref BookName="Reference" Attr="ConjugacyClasses"/>.
<Example><![CDATA[
gap> CC := ConjugacyClasses(G);;
gap> Length(CC);
1960
]]></Example>
We see that there are <M>1\,960</M> many conjugacy classes of elements of <M>G</M>.
Let us look at a single conjugacy class.
<Example><![CDATA[
gap> A := CC[1617];
(2,4,5,3)(6,26)(7,29,9,30,10,28,8,27)(11,21)(12,22)(13,23)(14,24)(15,25)^G
]]></Example>
We can compute additional information about a conjugacy class on the go.
For example, we can ask &GAP; for the number of elements in this class.
<Example><![CDATA[
gap> Size(A);
60000
]]></Example>
To access the representative of this class, we do the following.
<Example><![CDATA[
gap> a := Representative(A);
(2,4,5,3)(6,26)(7,29,9,30,10,28,8,27)(11,21)(12,22)(13,23)(14,24)(15,25)
gap> Display(a ^ iso);
1 2 3 4 5 6 top
( (2,4,5,3), (2,4,5,3), (), (), (), (); (2,6)(3,5) )
]]></Example>
Representatives are always given in a sparse format,
e.g. all cycles in the wreath cycle decomposition of <M>a</M> are sparse (see <Ref Sect="Sparse Wreath Cycle"/>).
</Section>
<Section>
<Heading>Centralizer</Heading>
Compute the centralizer of <M>x</M> in <M>G</M>,
i.e. compute a generating set of <M>C_G(x)</M>. <P/>
We continue the &GAP; session from <Ref Sect="Tutorial Efficient Computing"/>.
In particular recall the definition of the isomorphism <C>iso</C>.<P/>
To compute in &GAP; the centralizer of an element in a group we use <Ref BookName="Reference" Oper="Centralizer"/>.
<Example><![CDATA[
gap> C := Centralizer(G, x);
Group([ (16,20)(17,19)(26,27)(28,30), (16,19,20,17)(26,28,27,30),
(1,4,5,2)(6,9,10,7)(12,13,15,14)(21,25,23,24) ])
]]></Example>
We can compute additional information about the centralizer on the go.
For example, we can ask &GAP; for the number of elements in <M>G</M> that centralize <M>x</M>.
<Example><![CDATA[
gap> Size(C);
16
]]></Example>
The generators of a centralizer are always given in a sparse format,
e.g. all cycles in the wreath cycle decomposition of a generator <M>g</M> are sparse (see <Ref Sect="Sparse Wreath Cycle"/>).
<Example><![CDATA[
gap> for g in GeneratorsOfGroup(C) do
> Display(g ^ iso);
> od;
1 2 3 4 5 6 top
( (), (), (), (1,5)(2,4), (), (1,2)(3,5); () )
<Section>
<Heading>Cycle Index Polynomial</Heading>
Compute the cycle index polynomial of <M>G</M> either for the imprimitive action or the product action.
We do not continue the &GAP; session from <Ref Sect="Tutorial Efficient Computing"/> since the wreath product is too large
to make sense of the cycle index polynomial just by looking at it. Instead we use the following wreath product.
To compute in &GAP; the cycle index of a a group we use <Ref BookName="Reference" Oper="CycleIndex"/>.
Note that by default, the wreath product is given in imprimitive action.
<Example><![CDATA[
gap> c_impr := CycleIndex(G_impr);
1/72*x_1^6+1/12*x_1^4*x_2+1/18*x_1^3*x_3+1/8*x_1^2*x_2^2+1/6*x_1*x_2*x_3
+1/12*x_2^3+1/4*x_2*x_4+1/18*x_3^2+1/6*x_6
]]></Example>
For example, the second monomial <C>1/12*x_1^4*x_2</C> tells us
that there are exactly <M>\frac{72}{12} = 6</M> elements with cycle type <M>(4, 1)</M>,
i.e. elements that have four fixed points and one <M>2</M>-cycle.
If one wants to access these monomials on the computer, one needs to use <Ref BookName="Reference" Func="ExtRepPolynomialRatFun"/>.
<Example><![CDATA[
gap> Display(ExtRepPolynomialRatFun(c_impr));
[ [ 6, 1 ], 1/6, [ 3, 2 ], 1/18, [ 2, 1, 4, 1 ], 1/4, [ 2, 3 ], 1/12,
[ 1, 1, 2, 1, 3, 1 ], 1/6, [ 1, 2, 2, 2 ], 1/8, [ 1, 3, 3, 1 ], 1/18,
[ 1, 4, 2, 1 ], 1/12, [ 1, 6 ], 1/72 ]
]]></Example>
The way how to read this representation is roughly the following.
The list consists of alternating entries,
the first one encoding the monomial and the second one the corresponding coefficient,
for example consider <C>[ 1, 4, 2, 1 ], 1/12</C>.
The coefficient is <C>1/12</C> and the monomial is encoded by <C>[ 1, 4, 2, 1 ]</C>.
The encoding of the monomial again consists of alternating entries,
the first one encoding the indeterminant and the second one its exponent.
For example <C>[ 1, 4, 2, 1 ]</C> translates to <C>x_1^4 * x_2^1</C>.
For more details, see <Ref BookName="Reference" Sect="The Defining Attributes of Rational Functions"/>. <P/>
If we want to consider the wreath product given in product action,
we need to use the command <Ref BookName="Reference" Oper="WreathProductProductAction"/>
<Example><![CDATA[
gap> G_prod := WreathProductProductAction(K, H);;
gap> NrMovedPoints(G_prod);
9
gap> c_prod := CycleIndex(G_prod);
1/72*x_1^9+1/6*x_1^3*x_2^3+1/8*x_1*x_2^4+1/4*x_1*x_4^2+1/9*x_3^3+1/3*x_3*x_6
]]></Example>
However, we do not need to create the wreath product in order to compute the cycle index of the group.
Thus the package provides the functions <Ref Func="CycleIndexWreathProductImprimitiveAction"/> and
<Ref Func="CycleIndexWreathProductProductAction"/> to compute the cycle index directly from the components <M>K</M> and <M>H</M>
without writing down a representation of <M>K \wr H</M>.
Die Informationen auf dieser Webseite wurden
nach bestem Wissen sorgfältig zusammengestellt. Es wird jedoch weder Vollständigkeit, noch Richtigkeit,
noch Qualität der bereit gestellten Informationen zugesichert.
Bemerkung:
Die farbliche Syntaxdarstellung ist noch experimentell.
