Conjugacy classes of the 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.

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.

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.

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.

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

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

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?

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.

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

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.

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 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?)

(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',RL',FB'> = <U2,R2,F2,UD',RL',FB',D2,L2,B2>, GAP gives 768 conjugacy classes.

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.

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.