# Conjugacy classes of the cube

I was reading the following :

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

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

## Comment viewing options

### 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 Sn be given for some fixed value of n. Then x, y in Sn are conjugate if and only if they have the same cycle structure. And remember that for x and y to be conjugate in Sn means that there must exist some z in Sn such that z-1xz=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)-1x(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 Sn be given for some fixed value of n and let G be a subgroup of Sn. 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 Sn and that they are are also conjugate in Sn. 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 Sn such that z-1xz=y. However, such a z in Sn 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.

### "false theorem" with the screwdriver cube

I use a "false theorem" with the screwdriver cube instead of S_n. This is because it is relatively easy to understand how a conjugacy class looks when extended to the screwdriver cube. Each class can be described by bags/multisets of pairs of cycle lenghts and cycle orientations. The orientation of a cycle is what happens to its cubies when applying it until all cubies are back home. I.e. superflip is

{(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.
For larger numbers of orientation, it is hard to really understand the situation. You can look at the code how parity sensitivity is being determined (I better understood things when writing the code), but there have been no tests for more than 3 orientations thus far.

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

Is it possible for GAP to give the number of even and odd classes? so that we have :

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 is incorrect, and my post below is incorrect as well. The correct formula is

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

Thanks for the correction. I am however having a hard time understanding this parity sensitive concept. For example for this:

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

2 1 is odd and hence not parity sensitive since there are no odd parity sensitive positions. 1 1 1 is not sensitive to any conjugation, let alone that it matters which parity a conjugation has. So it must be 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"

I finished my procedure and have some numbers that correspond to the GAP numbers, but I wish to have more checks actually. Maybe, the number of conjugacy classes for [U,R,F] can be computed with GAP. That would check the E_ps and O_ps computation in combination with nori > 1. Currently, the only GAP value that checks E_ps and O_ps is the positional cube with 850 classes. The value I have for 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

Now that we know that the number of conjugacy classes of the cube is 81120, do we know how many elements are in each conjugacy class?

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

### Extension of procedure

The procedure only counted classes, so I adapted it. Now it describes each conjugacy class by way of five properties
1. 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.
2. 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).
3. 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).
4. 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.
5. The size of conjugacy class.
Since the speed of the procedure has decreased considerably after extension, I have maintained the old version.

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.
Only for 6 corners, the index of a conjugacy class may be 2. A corner conjugacy class and an edge conjugacy class combine to one conjugacy class from which the order is the least common multiple and the size is the product, except when both the corner and edge conjugacy class are parity sensitive, in which case there are two conjugacy classes from which the order is the least common multiple and the size is 1/2 times the product. You can switch between both conjugacy classes by conjugating by any two-swap (which is a screwdriver cube position).

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

### Fabulous

This is absolutely fabulous! Thank you very much. I will study your procedure to understand it better, if I do understand it I will port it to a c++ program.

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

I have ported the procedure to C. In addition, I changed the names of many of the variables to clarify what they are used for. The program reads npos and nori from the command line, outputs [E,O,E_ps,O_ps] to stderr and writes the list of conjugacy classes in C source format to stdout.

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

I do not know, another question is what the smallest depth but one is. Corner tri-swap can be done in 12 face turns, I think. Would that be the smallest depth but one in FTM? Instead of porting my procedure, you can also implement what I wrote in my post ""false theorem" with the screwdriver cube" above. About switching between the two conjugacy classes of a parity sensitive corner and edge class, I said that you can switch between both conjugacy classes by conjugating by any two-swap, but this is not entirely true:
• 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

Thank you very much. Now that both this cube and the full cube match, I think I can publish my procedure. Unfortunately, not everybody has Maple. Maybe, the procedure can be ported to Perl, but I do not know anything of Perl.

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.
Notice that triple parity sensitive combinations are counted four times: one time in the regular sum and three times in parity sensitive sums. This is correct: the parity of the conjugacy can be adapted to the corners, after which both the edges and the centers add a factor 2.

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

I write Perl, I actually wrote some permutation stuff in it recently.
What exactly do you want to compute and how do you compute it ?
Why is Perl your target programming language ?

### Amazing discovery

When I tried to check the values

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?

Hmmm, that is interesting! Do you know the mathematical truth behind your discovery?

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

### No, but O_ps = 0 is trivial

No, I cannot find why E = O + E_ps. But O_ps = 0 is trivial:

Let p be an odd position and gpg' a conjugate. Then (gp)p(gp)' is the same conjugate. QED.

### gpg' =(gp)p(gp)'

Sorry but I am not following. Isn't it true that gpg' =(gp)p(gp)' is true regardless if p is odd or not?

### Indeed gpg' =(gp)p(gp)',

Indeed gpg' =(gp)p(gp)' is always true, but the parity of (gp) is not always different from that of g.

### E = O + E_ps proof

You might want to take a look here:

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

Partitions with odd part only are the parity-sensitive conjugacy classes when nori = 1. So looking at them does not solve the whole problem. But it seems a good idea to start somewhere.

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

GAP gives 1216 as the number of conjugacy classes for <U,D,F2,B2,R2,L2>.

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

The problem is of course that with three types of cubies, you can choose the parity for the conjugation for two of the three types instead of just one. Here are the corrected calculations:

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.
This way, the number of flipped slices is always even. Since the flip of an even number of slices is central, we can just factor it out. Similarly, the number of conjugacy classes of the regular cube module superflip is simply half of that of the regular cube.

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,

Where I said [U2,D2,R2,L2,F2,B2,slices] for the normal representation of my favorite subgroup, I meant [U2,D2,R2,L2,F2,B2,UD',RL',FB'], so sorry. The wrong group is a factor 4 larger due to 4 views of the cube. About the group [U2,R2,F2,slices], it has 4! edge positions for each slice and 4! corner positions for the tetra with URF. Next, there are 3! center positions and 2^2 center flips. Divide by a factor 2 for parity and multiply by 4 sliceflip positions to obtain

(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

768 is a nice number. I would like to understand why it is 768.

```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

I did some calculations with Maple. With a screwdriver, I count 810 corner classes and 1165 edge classes, thus totaling 810 * 1165 = 943650 classes for the screwdriver cube. The regular cube is harder because of the corner and edge orientations that add up to zero.

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

I am sorry if you have already stated what you mean by screwdriver cube. What beast is this?

### Screwdriver cube

First turn one face an eighth turn. Next take a screwdriver and push it between one edge of the face you just turned 1/8 and another edge.
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.