# Conjugacy classes of the cube

http://en.wikipedia.org/wiki/Conjugacy_class

and wondered if the number of conjugacy classes of the cube is known?

## Comment viewing options

### "false theorem" with the screwdriver cube

{(1,f),(1,f),(1,f),(1,f),(1,f),(1,f),(1,f),(1,f),(1,f),(1,f),(1,f),(1,f)}

or shortly

{f,f,f,f,f,f,f,f,f,f,f,f}

Next, any three-swap of to cubies within the regular cube has screwdriver class

{(1,1),(1,1),(1,1),(1,1),(1,1),(3,1)}

or shortly

{1,1,1,1,1,3}

and the effect of URU'R' on the corners is
{(1,1),(1,1),(1,1),(1,1),(2,t),(2,t^2)}

or shortly

{1,1,1,1,2t,2t^2}

The screwdriver cube conjugacy class of a regular edge position is contained in the regular cube, but may split up into 2 regular conjugacy classes. This is exactly the case when each cycle has both even length and trivial orientation, e.g. {2,2,4,4}. One can switch between both classes by flipping two consecutive edges in any cycle.

The screwdriver cube conjugacy class of a regular corner position is contained in the regular cube, but may split up into 3 regular conjugacy classes. This is exactly the case when each cycles has both a length that is divisible by 3 and trivial orientation, which is impossible with 8 positions. One can switch between the three classes by twisting two consecutive corners in any cycle (one of which clockwise and the other counter-clockwise).

The above suggests a behavior for general numbers of orientation (assuming the set of orientations is a cyclic group), but this suggested behavior is only valid for primes (in which case the set is automatically cyclic).

If you consider the screwdriver cube for corners and edges simultaneously, then you can see the concept of parity sensitivity as a fix of an incorrect theorem as well. See my post "No, CE*EE + CO*EO is incorrect" below. It can be determined as follows if a conjugacy class is parity sensitive:

- If there are two identical cycles with odd lengths (e.g. (f,f), (7,7) or (3t^2,3t^2), then you can interchange them, which proves that there is no parity sensitivity. Otherwise, if there is no cycle of even length, then there
*is*parity sensitivity. - If there is a cycle with even length and there are 3 orientations (corners), then there is no parity sensitivity,
- If there is a cycle with even length and there are 2 orientations (edges), then there is no parity sensitivity,
*except*(precisely) in case all cycles have both even length and nontrivial flip.

### I tried using GAP to get the

I tried using GAP to get the number of conjugacy classes, but I got an out-of-memory error. I was able to get the number of conjugacy classes of certain subgroups, however.

2x2x2 cube ( < U,F,R > ): 143

3x3x3 corners subgroup: 270

3x3x3 edges subgroup: 599

3x3x3 cubie permutations subgroup: 856

### Even and odd classes

270 = CE + CO

599 = EE + EO

From which we can deduce the number of conjugacy classes for the whole cube as :

CE*EE + CO*EO

Also is it possible for GAP to tell how many elements are in each conjugacy class?

### No, CE*EE + CO*EO is incorrect.

CE*EE + CO*EO + CE_ps*EE_ps + CO_ps*EO_ps

Here, blah_ps are the number of parity sensitive conjugacy classes of some type. This means that conjugating a representant with even positions differs from that with odd positions.

The position DUL2U'L'DF2DR2U2BU'B'U' (14f*) is parity sensitive for both the corners and the edges.

EDIT: Notice that the above position has only cycles of odd length (cycle lengths 1,1,1,5 for the corners and 1,1,5,5 for the edges). This is not necessary for the edges, though. The position L2R2UR2DU'F2L2R2U'RU2F2D'UR2U2F' (18f) is parity sensitive for the edges (cycle lengths 2,2,4,4, the corners are unchanged).

The problem is harder than I though on the start. I try to make a procedure that is parameterized with the number of positions and the number of orientations (thus (8,3) and (12,2) to be used), which computes the four numbers E, O, E_ps and O_ps. The idea is to correct the computations for the screwdriver cube to obtain the values for the regular cube somehow.

### Parity sensitive

npos = 3, nori = 1, [2, 1, 1, 0]

the cycles are :

3

2 1

1 1 1

which one is the parity sensitive one and why?

Thanks

### The 3

The 21 is not parity sensitive since you can permute every pair of "cubies" to the cycle of two, regardless of whether the permutation must be even or odd.

The 3 *is* parity sensitive, because odd permutations as conjugations on the "cubies" will reverse the 3-cycle as opposed to even permutations.

### table for [E, O, E_ps, O_ps] and "rubik 81120"

__is 10788. The value I have for the whole cube is 81120.....yyyyeeeessss, "rubik 81120" gives affirmative hits with google. Now THAT is a convincing check!__

[U,R,F] cube:

npos = 7, nori = 3, [75, 68, 7, 0]

npos = 9, nori = 2, [78, 72, 6, 0]

75*78 + 68*72 + 7*6 + 0*0 = 10788

full cube:

npos = 8, nori = 3, [140, 130, 10, 0]

npos = 12, nori = 2, [308, 291, 17, 0]

140*308 + 130*291 + 10*17 + 0*0 = 81120

positional cube:

npos = 8, nori = 1, [12, 10, 2, 0]

npos = 12, nori = 1, [40, 37, 3, 0]

12*40 + 10*37 + 2*3 + 0*0 = 856

corner cube:

npos = 8, nori = 3, [140, 130, 10, 0]

140 + 130 = 370

edge cube:

npos = 12, nori = 2, [308, 291, 17, 0]

308 + 291 = 599

2x2x2 cube [U,R,F]:

npos = 7, nori = 3, [75, 68, 7, 0]

75 + 68 = 143

I wrote my procedure in Maple, a computer algebra system.

npos = 1, nori = 1, [1, 0, 1, 0] npos = 2, nori = 1, [1, 1, 0, 0] npos = 3, nori = 1, [2, 1, 1, 0] npos = 4, nori = 1, [3, 2, 1, 0] npos = 5, nori = 1, [4, 3, 1, 0] npos = 6, nori = 1, [6, 5, 1, 0] npos = 7, nori = 1, [8, 7, 1, 0] npos = 8, nori = 1, [12, 10, 2, 0] npos = 9, nori = 1, [16, 14, 2, 0] npos = 10, nori = 1, [22, 20, 2, 0] npos = 11, nori = 1, [29, 27, 2, 0] npos = 12, nori = 1, [40, 37, 3, 0] npos = 1, nori = 2, [1, 0, 1, 0] npos = 2, nori = 2, [2, 2, 0, 0] npos = 3, nori = 2, [3, 2, 1, 0] npos = 4, nori = 2, [8, 5, 3, 0] npos = 5, nori = 2, [10, 8, 2, 0] npos = 6, nori = 2, [20, 17, 3, 0] npos = 7, nori = 2, [29, 26, 3, 0] npos = 8, nori = 2, [54, 46, 8, 0] npos = 9, nori = 2, [78, 72, 6, 0] npos = 10, nori = 2, [130, 121, 9, 0] npos = 11, nori = 2, [192, 184, 8, 0] npos = 12, nori = 2, [308, 291, 17, 0] npos = 1, nori = 3, [1, 0, 1, 0] npos = 2, nori = 3, [2, 1, 1, 0] npos = 3, nori = 3, [7, 3, 4, 0] npos = 4, nori = 3, [10, 7, 3, 0] npos = 5, nori = 3, [20, 16, 4, 0] npos = 6, nori = 3, [42, 37, 5, 0] npos = 7, nori = 3, [75, 68, 7, 0] npos = 8, nori = 3, [140, 130, 10, 0] npos = 9, nori = 3, [259, 242, 17, 0] npos = 10, nori = 3, [449, 431, 18, 0] npos = 11, nori = 3, [778, 755, 23, 0] npos = 12, nori = 3, [1335, 1301, 34, 0]The values [1,0,1,0] for npos = 1 are wrong and should be [1,0,0,0]. The problem is that there is no such thing as parity with only one position, thus sensitivity for it does not play a role.

### Depth of a conjugacy class representative

Can we calculate the depth of at least one representative of each class? We might hit some interesting position...

### Extension of procedure

- Description of the conjugacy class extended to the screwdriver cube.

When one allows conjugates to be screwdriver cubes, conjugacy classes stay within the regular cube and can easily be described: see my post ""false theorem" with the screwdriver cube" above. - Index within extended conjugacy class.

A conjugacy class that is extended to the screwdriver cube is sometimes the union of more than one regular conjugacy class (my post ""false theorem" with the screwdriver cube" above describes when this is the case). If the extended conjugacy class is the union of k regular classes, then the indices of these regular classes are 0,1,...,k-1 (my post ""false theorem" with the screwdriver cube" above describes how to get from one regular class to another). - Whether the conjugacy class is parity sensitive.

A conjugacy class is parity sensitive if for any fixed representant, conjugations with even cubes are always different from those with odd cubes. See also my post "No, CE*EE + CO*EO is incorrect" (my post ""false theorem" with the screwdriver cube" above describes when conjugacy classes are parity sensitive). - The order of the conjugacy class.

For each representant of a conjugacy class, the order is the same. This is the order of the conjugacy class. - The size of conjugacy class.

Just as the old version, the new version is plain text and you can easily extract tables therein. The new version contains a table [E, O, E_ps, O_ps] up to 6 orientations only instead of 12, because it is a lot slower than the old one. Next, lists with the 5 properties of each conjugacy class are shown for

- 6 edges,
- 6 corners,
- 8 corners,
- 12 edges.

Whatever you are going to do with the procedure or the tables, good luck.

### Fabulous

I wonder if using the conjugacy classes we can conclude anything about the depth of positions?

For example we know that a position X and X' have the same depth. We also know that X and g'Xg have the same depth where g is one of the 48 symmetries.

We do know that if X and Y belong to the same conjugacy class it does not mean they have the same depth, for example R and F'RF positions are conjugates but one has a depth of 1, the other a depth of 3...

But is there any statement we can say about the depths of a conjugacy class?

### ported to C

Just as the solvers of the cube, the program is some sort of search algorithm. For that reason, it might be interesting to see how the search of both the partitions of npos (which determine the cycle lengths) and the possible orientations (of the cycles) is split up in a while loop that goes forth in the search and another while loop that goes back in the search, with gotos between both while loops to switch between going forth and back. I must admit that I did not think out this searching myself.

### I do not know, another questi

- The cubies you swap must either be both corners or be both edges, ;-)
- The swap must have trivial orientation as a cycle.

### Conjugacy classes of <U,F,R>

I checked the number of conjugacy classes of the 3x3x3 <U,F,R> group with GAP.

gap> URF := Group(U,R,F); <permutation group with 3 generators> gap> Size(URF); 170659735142400 gap> NrConjugacyClasses(URF); 10788

### Thank you -- O_ps is always zero -- other numbers of cjclasses

The procedure uses a for-loop for each position. Unfortunately, the number of positions is dynamically determined by the first parameter. For that reason, the procedure generates a string with code called foo, which is executed. The string with uses a for-loop for each cycle of positions. Unfortunately, the number of cycles, more generally the cycle structure of positions is dynamically determined by the indices of the above for-loops for each position; furthermore the ranges of the for-loops for each cycle depend on the cycle structure. Therefore, the code of foo generates a string with code called bar. Next, the code parse(bar,statement) within foo is a recursive application of Maple's string execution functionality.

Also for larger values of nori, it appears that O_ps is always zero, i.e. no odd parity sensitive position. Anyone a proof?

EDIT: With three or more faces, you can do "everything" except flipping edges in case two opposite faces are both missing. So you can compute the number of conjugacy classes by the above table (and check them with GAP as far as memory resources are sufficient). But let us first recompute the full cube in two different ways.

full cube [U,R,F,slices]:

npos = 7, nori = 3, [75, 68, 7, 0] (corners)

npos = 12, nori = 2, [308, 291, 17, 0] (edges)

npos = 3, nori = 2, [3, 2, 1, 0] (centers)

3*(75*308 + 68*291 + 7*17 + 0*0) = 129021

2*(75*291 + 68*308 + 7*0 + 0*17) = 85538

1*(75*17 + 68*0 + 308*7 + 291*0) = 3431

129021 + 85538 + 3431 = 217990

full cube [U,D,R,F,Rslice,Fslice]:

npos = 8, nori = 3, [140, 130, 10, 0] (corners)

npos = 11, nori = 2, [192, 184, 8, 0] (edges)

npos = 3, nori = 2, [3, 2, 1, 0] (centers)

3*(140*192 + 130*184 + 10*8 + 0*0) = 152640

2*(140*184 + 130*192 + 10*0 + 0*8) = 101440

1*(140*8 + 130*0 + 192*10 + 184*0) = 3040

152640 + 101440 + 3040 = 257120

WTF is going on here? It seems that the number of conjugacy classes is dependent of the representation of the group! Or am I doing something wrong?

The center cube can use some explanation. The three positions are the three axes and axis flip is interchanging opposite centers. So let us describe positions without flip now:

- Even positions without flip: the axes are permuted in an even manner and the centers of U,F,R are within the faces U,F,R,
- Odd positions without flip: the axes are permuted in an odd manner and the centers of U,F,R are within the faces D,B,L.

Let us compute subgroup H now.

subgroup H = [U,D,F2,B2,R2,L2]:

npos = 8, nori = 1, [12, 10, 2, 0] (corners)

npos = 8, nori = 1, [12, 10, 2, 0] (edges U,D)

npos = 4, nori = 1, [3, 2, 1, 0] (edges UDslice)

3*(12*12 + 10*10 + 2*2 + 0*0) = 744

2*(12*10 + 10*12 + 2*0 + 0*2) = 480

1*(12*2 + 10*0 + 12*2 + 10*0) = 48

744 + 480 + 48 = 1272

Can you check this with GAP, Bruce?

### I write Perl, I actually wrot

What exactly do you want to compute and how do you compute it ?

Why is Perl your target programming language ?

### Amazing discovery

npos = 3, nori = 8, [13,6,7,0]

with GAP, I observed the following in the table:

**The number of even parity sensitive conjugacy classes is equal to the number of even conjugacy classes minus the number of odd conjugacy classes!**

Together with the observation that there are no odd parity sensitive conjugacy classes, we can compute parity sensitivity in a very simple manner!

Assume [E,O,E_ps,O_ps] are the values of a coordinate to be checked. Combining your coordinate with

npos = 2, nori = 1, [1,1,0,0]

or not combining it at all gives E+O as the number of conjugacy classes. Combining your coordinate with

npos = 3, nori = 1, [2,1,1,0]

or not combining it at all gives 2E+O+E_ps as the number of conjugacy classes. Next, I searched for other checks by combination, but did not find them, because the O_ps of the checking coordinate is always zero and the E_ps of the checking coordinate is equal to E-O of the checking coordinate. However, if we *assume* that the coordinate to be checked satisfy O_ps=0 and E_ps=E-O as well, then the values E,O,E_ps,O_ps for the coordinate to be checked are determined by the above two checks E+O=... and 2E+O+E_ps=.... Indeed, E+O=19 and 2E+O+E_ps=39 for npos = 3, nori = 6, according to GAP.

### Even conjugacy classes > Odd conjugacy classes?

And why is it that the number of even conjugacy classes is always bigger than the number of odd conjugacy classes?

### E = O + E_ps proof

http://en.wikipedia.org/wiki/Partition_%28number_theory%29#Ferrers_diagram

where it says :

Claim: The number of self-conjugate partitions is the same as the number of partitions with distinct odd parts.

It might give you an idea about the proof of E = O + E_ps.

### E = O + E_ps for odd nori

Call a partition binary if this terms are 1,2,4,8, etc. only. So 1+1+2+2+4 is a binary partition of 10.

**Lemma.** *If n ≥ 2, then the binary partitions distribute equally along both parities, both for cycle count parity and permutation parity.*

**proof.** We distinguish two cases:

- n is odd.

In this case, n must have a term 1. Removing that term, we get a binary partition of n-1, with equal permutation parity and opposite cycle count parity. The result follows by induction. - n is even.

The case n = 2 is trivial, so let n ≥ 4. For partition of n with a term 1, the equal distribution along both parities follows just as for the case that n is odd. For partitions without a term 1, we may assume by induction that for the cycle count parity, there is equal distributions along both parities for partitions of n/2. This gives the desired result for both parities.

Notice that from partitions of n with odd terms only, we can make all partitions of n by repeatedly merging two equal terms. For example, we can make 4+6 by four times merging equal terms in 1+1+1+1+3+3. If we want to count partitions that we can make from 1+1+1+1+3+3 by way of the above merges by permutation parity, then the contribution of 1+1+1+1 is equal to the number of binary partitions of 4 and the contribution of 3+3 is the number of binary partitions of 2.

Since 4 ≥ 2, the partitions we can make 1+1+1+1+3+3 by way of the above merges distribute equally along both parities. The only situation where this is not the case is when we have a partition with distinct odd terms, which does not have terms that can be merged. This proves E = O + E_ps for nori = 1.

For nori = odd, the argument is more or less the same. The terms of the partitions of n are labeled with orientations that add up to zero. If you merge two terms, then they must have matching orientations as well and the orientations add up. Thus in the lemma, not the orientations of the terms t are the same, but the orientations divided by t, which is possible because t is a power of 2 and 2 is a unit of the orientations. Consequently, the orientations add up to a fixed total in the lemma, which does not need to be zero.

EDIT: for the screwdriver cube, E = O + E_ps for all nori. You simply merge equal terms without adding orientations. So in this case, all terms t do have equal orientations in the lemma.

### "H" conjugacy classes

### Again thank you very much -- corrections and more cubes

full cube [U,R,F,slices]:

npos = 7, nori = 3, [75, 68, 7, 0] (corners)

npos = 12, nori = 2, [308, 291, 17, 0] (edges)

npos = 3, nori = 2, [3, 2, 1, 0] (centers)

3*(75*308 + 68*291) = 128664

2*(75*291 + 68*308) = 85538

1*(7*17 + 0*0) = 119

128664 + 85538 + 119 = 214321

full cube [U,D,R,F,RLslice,FBslice]:

npos = 8, nori = 3, [140, 130, 10, 0] (corners)

npos = 11, nori = 2, [192, 184, 8, 0] (edges)

npos = 3, nori = 2, [3, 2, 1, 0] (centers)

3*(140*192 + 130*184) = 152400

2*(140*184 + 130*192) = 101440

1*(10*8 + 0*0) = 80

152400 + 101440 + 80 = 253920

subgroup H = [U,D,F2,B2,R2,L2]:

npos = 8, nori = 1, [12, 10, 2, 0] (corners)

npos = 8, nori = 1, [12, 10, 2, 0] (edges U,D)

npos = 4, nori = 1, [3, 2, 1, 0] (edges UDslice)

3*(12*12 + 10*10) = 732

2*(12*10 + 10*12) = 480

1*(2*2 + 0*0) = 4

732 + 480 + 4 = 1216

full cube times 24 views [faces,slices]:

npos = 8, nori = 3, [140, 130, 10, 0] (corners)

npos = 12, nori = 2, [308, 291, 17, 0] (edges)

npos = 3, nori = 2, [3, 2, 1, 0] (centers)

3*(140*308 + 130*291) = 242850

2*(140*291 + 130*308) = 161560

1*(10*17 + 0*0) = 170

242850 + 161560 + 170 = 404580

slice group [slices]:

cyclic 4 group, [2, 2, 0, 0] (edges any slice)

npos = 3, nori = 2, [3, 2, 1, 0] (centers)

1/2 * (3+2) * (2+2)^3 = 160

three color cube divisor group

[U2,D2,R2,L2,F2,B2,(RU'LU2R'UL')2U]:

npos = 4, nori = 1, [3, 2, 1, 0] (corners any tetra)

npos = 4, nori = 1, [3, 2, 1, 0] (edges any slice)

3^5 + binomial(5,2)*3^3*2^2 + binomial(5,4)*3*2^4 + 1^5 = 1564

The last two will fit into memory, Bruce, as well as the following one:

[U2,R2,F2,slices] (my favorite subgroup):

npos = 4, nori = 1, [3, 2, 1, 0] (corners tetra with URF)

npos = 4, nori = 1, [3, 2, 1, 0] (edges any slice)

npos = 3, nori = 2, [3, 2, 1, 0] (centers)

edgeflip: 4 central elements, thus a factor 4

4 * group above = 4 * 1564 = 6256

Some explanation: the corners of the tetra without URF are completely determined by those of the tetra with URF, so let us forget this tetra. Next, we define that a slice is flipped as follows:

- If the position is even for the centers: the slice is flipped if and only if its edges are flipped with respect to the corners,
- If the position is odd for the centers: the slice is flipped if and only if its edges are
*not*flipped with respect to the corners.

Computing the number of conjugacy classes for the regular representation [U2,D2,R2,L2,F2,B2,slices] of my favorite subgroup is not possible with the above methods, and neither does it have nontrivial centrals. So it would be nice if you compute it with GAP, Bruce.

### GAP ran out of memory when I

GAP ran out of memory when I tried to determine the number of conjugacy classes of the group generated by half-turns of the face layers and quarter-turns of the inner layers.

If inner layers are also restricted to half-turns, then the number of elements is 2654208 and the number of conjugacy classes is 2560.

I also confirmed with GAP that there are 160 conjugacy classes for the slice group and 1564 for the three color cube divisor group. For the <U2,R2,F2,slices> group, however, I get 15925248 elements and 6280 conjugacy classes. If the slices are restricted to half-turns, I get 663552 elements and 1280 conjugacy classes.

(Did you know that GAP is free?)

### Where I said [U2,D2,R2,L2,F2,

(4!)^3 * 4! * 3! * 2^2 / 2 * 4 = 15925248

The argument that the central subgroup can be divided out is incorrect: there are positions in the regular cube that are both conjugate and a superflip apart. However, the central subgroup of [U2,R2,F2,slices] generated by sliceflips is not only central, but also a factor of a decomposition of [U2,R2,F2,slices]. So the sliceflips are not the problem. No, the problem is that the parity of the corners (of the tetra with URF) is not correlated with the other parities (because the ignored tetra has the same parity). So there is just a factor 3 + 2 = 5 for the corners. This gives

4 * 5 * (3^4 + binomial(4,2)*3^2*2^2 + 2^4 + 1) = 6280

### For the group <U2,R2,F2,UD

For the group <U2,R2,F2,UD',RL',FB'> = <U2,R2,F2,UD',RL',FB',D2,L2,B2>, GAP gives 768 conjugacy classes.

### 768 = 2^8*3 -- memory of GAP

I downloaded GAP and found the following on the web page.

Memory issues By default, the ``cygwin'' environment we use limits a program's workspace to 128 MB of memory. To increase this limit, it is necessary to edit the Windows registry. *WARNING:* Editing the registry is the Windows equivalent of open heart surgery. Do not attempt this change if you have no previous experience in doing this. The web page www.cygwin.com/cygwin-ug-net/setup-maxmem.html gives further details. Before changing the entries, you might have to run GAP once first to create the appropriate registry keys. The shell script usemem.bat in the bin directory sets a registry entry /HKEY_LOCAL_MACHINE/Software/Cygnus Solutions/Cygwin/heap_chunk_in_mb to decimal 1024. If you prefer to do the change by hand, open `regedit' and go to the `Cygwin' Key listed above. Then choose `new value' and add `heap_chunk_in_mb'. `Modify' it to contain decimal 1024.EDIT: I computed the following values for the megaminx:

npos = 20, nori = 3: [57043, 56840, 203, 0]

npos = 30, nori = 2: [147558, 147270, 288, 0]

(57043+203)*(147558+288) = 8463592116

I thought about the 4x4x4 and larger cubes, but the interior cubies in the faces make that these cubes are not groups. The same holds for the octagonal cube since some edges have orientations and other do not. You can however divide out some group to obtain the octagonal cube form the regular cube. As we know, that group has eight elements and also eight conjugacy classes.

### Screwdriver cube

The general idea is first to count the number of even and odd classes for both the corners and the edges, and next multiply and add correctly.

The screwdriver corner cube has three times as many classes as the regular corner cube, but the screwdriver edge cube does

*not*have twice as many classes as the regular edge cube.

### Screwdriver cube

After creating enough room between both edges, you can remove the first edge from the cube. Next, you can easily remove the other cubies as well.

Next, scramble the cubies. If you reverse the above procedure, you get a typical screwdriver cube.

## Conjugacy discussion from Singmaster's Rubic Circular

There was an interesting discussion about conjugacy classes in David Singmaster's Cubic Circular series back in the earliest days of cubing. I'm going a little bit by memory here, and many of you all know this stuff much better than me. But here goes anyway.

A key theorem is something like the following. Let S

_{n}be given for some fixed value of n. Then x, y in S_{n}are conjugate if and only if they have the same cycle structure. And remember that for x and y to be conjugate in S_{n}means that there must exist some z in S_{n}such that z^{-1}xz=y. Actually, rather than saying "x and y are conjugate", I think we need to say that y is the conjugate of x by z. And clearly if y is the conjugate of x, then x is the conjugate of y because y=(z^{-1})^{-1}x(z^{-1})=zyz^{-1}. So y is the conjugate of x by z^{-1}, and conjugation is an equivalence relation that gives us conjugacy classes.In practice, the theorem means that you can calculate conjugates by a mechanical process that's so simple you could almost teach it to a six year old. For an example using cycle notation, what is the conjugate of (1,2,4,3) by (1,2,4)? You could go through the full blown calculation of (1,2,4)

^{-1}(1,2,4,3)(1,2,4) and eventually get the right answer. But the very simple minded mechanical process is simply to take the permutation (1,2,4,3) and to replace the 1 by 2, the 2 by 4, and the 4 by 1, viz. (2,4,1,3), and that's the answer.More interesting to me is the following "false theorem". Let S

_{n}be given for some fixed value of n and let G be a subgroup of S_{n}. Then x, y in G are conjugate if and only if they have the same cycle structure. What is interesting is to consider which parts of the "false theorem" are true, which parts are false, and why.What's true is that if x and y are conjugate in G, then they have the same cycle structure. That this part of the "false theorem" is true is a consequence of the fact that if x and y are G then they are also in S

_{n}and that they are are also conjugate in S_{n}. Therefore, the must have the same cycle structure. But the false theorem fails in the other direction. If x and y are in G and have the same cycle structure, then there is a z in S_{n}such that z^{-1}xz=y. However, such a z in S_{n}may not also be in G.I have no idea how GAP calculates the number and sizes of conjugacy classes. I can only speculate that it must use cycle structure in its calculations. But even if that's the way GAP calculates conjugacy classes, it still must take into account the fact that two permutations in G with identical cycle structures nevertheless may not be conjugate.