# Number of cases for 3 Cycles of Wing Edges in Last Layer (K4 Method)



## Christopher Mowla (Feb 5, 2010)

Hello everyone,
I have made a document which shows why there are exactly 28 distinct cases for 3-cycles of winged edges restricted in the last layer of a 4X4X4 or 5X5X5 cube.

I know that many have known that there are 28 cases for a long time now (just as I have known, even before looking at Thom Barlow's webpage), but I wanted to introduce another (interesting) way to verify why there are 28 cases.

In the document, I also include an organized table of all 28 cases which may be useful for those just beginning to learn the K4 method. There are two of these tables: one is with Thom Barlow's algorithms, and the other is a table without any algorithms (for custom algorithms).


----------



## miniGOINGS (Feb 5, 2010)

Thanks, I needed something like this.


----------



## cuBerBruce (Feb 5, 2010)

I look at it this way. There are 8 edges. A 3-cycle involves 3 of them. C(8,3)=8!/(3!*5!)=56.

For each 3 edges, there is a clockwise and a counterclockwise 3-cycle. 2*56= 112.

Since we're considering 3-cycles that are equivalent under a y-axis rotation, we have counted each case 4 times. 112/4=28.


----------



## Lucas Garron (Feb 5, 2010)

Nice. I've always been too scared of all the cases, but it doesn't look that bad after all.


```
Sort[Table[RotateRight[#,x],{x,0,6,2}]][[1]]&/@Permutations[{1,1,1,0,0,0,0,0}]//DeleteDuplicates//Length
```
Returns 14. 

I love canonicalization. What the code above does:

Generate all the possibilities: Permutations[{1,1,1,0,0,0,0,0}]
Canonicalize each one by generating all the symmetries, sorting, and picking the canonically (think "alphabetically") first: Sort[Table[RotateRight[#,x],{x,0,6,2}]][[1]]&
Count the number of unique cases: //DeleteDuplicates//Length


----------



## Christopher Mowla (Feb 5, 2010)

cuBerBruce said:


> I look at it this way. There are 8 edges. A 3-cycle involves 3 of them. C(8,3)=8!/(3!*5!)=56.
> 
> For each 3 edges, there is a clockwise and a counterclockwise 3-cycle. 2*56= 112.
> 
> Since we're considering 3-cycles that are equivalent under a y-axis rotation, we have counted each case 4 times. 112/4=28.


 
Well, that strategy works out for 3-cycles, but not for 4-cycles and 2 2-cycles (and by some thought, probably not for 2 3-cycles, 6-cycles, etc).



*A Document for 4-cycles and 2 2-Cycles*


----------



## Lucas Garron (Feb 5, 2010)

Hmm, I get 58 and 110:















Not so sure about the 110, but I think the 58 is right. Are you sure you counted correctly?


----------



## miniGOINGS (Feb 5, 2010)

Disregarding the permutation of the dedges, is it faster to solve 2 adjacent dedges, or 2 opposite dedges (after the other 2 have been solved)?


----------



## cuBerBruce (Feb 6, 2010)

Lucas Garron said:


> Not so sure about the 120, but I think the 58 is right. Are you sure you counted correctly?



I used GAP to confirm that there are 58 cases for two 2-cycles. I also got 110 cases for 4-cycles. I think this agrees with Lucas. It seems he miscounted his rows.

cmowla, the proper way to write "n-cycle" is with a hyphen. You should say "4-cycles and 2 2-cycles" (or "4-cycles and two 2-cycles") rather than "4 cycles and 2-2 cycles." "4 cycles" (no hyphen) would imply you're talking about 4 separate cycles without any information about the lengths of those cycles. If you're creating a nice document as a resource for the cubing community, it would be nice to have things "spelled" properly.


----------



## miniGOINGS (Feb 6, 2010)

@ cmowla: What I was meaning is, consider the following;

-This is for 4x4 only (as of yet)
-All centers solved
-All dedges in D and E paired and oriented
-All dedges in U not paired

Now, which would be the most practical approach to finish the edge pairing, while making sure all edges are oriented, but disregarding the position of the dedges or corners?


----------



## Lucas Garron (Feb 6, 2010)

Yeah, 120 was a mistake when I typed it into my post. Will edit.

Number of _n_-cycles for 2 through 8:

{8, 28, 110, 336, 848, 1440, 1276}​
Not bad compared to Binomial[8, n]*(n - 1)!/4. The exceptions are not too insane, and it's nice to see that odd cycles have no rotational symmetry.
Estimates: {7, 28, 105, 336, 840, 1440, 1260}

Modding out by reflections:
{6, 14, 61, 168, 440, 720, 662}​
Modding out by reflections and inverses (the number of distinct algs that need to be found to have a solution for every case):
{6, 7, 38, 84, 250, 360, 391}​
Bruce, can you also verify these?

I would totally write some code to solve the general problem for cycle structures, but I've been procrastinating on homework enough by doing this.


----------



## miniGOINGS (Feb 6, 2010)

Yes. Well, you and everyone else, but yes.


----------



## Christopher Mowla (Feb 6, 2010)

Well, it depends on the scramble of the last 4 dedges. Since we are ignoring odd permutations, PLL parity, and are not picky where the winged edges pieces go (just pairing the dedges, not directly solving the dedges like in K4),

1) If there are 2 dedges incomplete,
Execute a 3-cycle that is between those two dedges only.

2) If there are 3 dedges incomplete,
Perform a 3-cycle that is between those 3 dedges.

3) If there are 4 dedges incomplete,
a) Perform a 3 cycle to complete one of the dedges.
b) Go to step 2.

For this scenario, it would be ideal if you knew all *44* two 2-cycle and 4 cycle algorithms which involve all 4 dedges (see the last main chart in my two 2-cycle/4-cycle document. That way, you only need to execute 1 algorithm to pair up all 4 dedges, but you said "practical", so I would go with the first option.


----------



## miniGOINGS (Feb 6, 2010)

So basically, it can be done with at most two 3-cycles? The first to pair at least one dedge, and the second to pair the remaining 2/3?


----------



## cuBerBruce (Feb 6, 2010)

Lucas Garron said:


> Number of _n_-cycles for 2 through 8:
> 
> {8, 28, 110, 336, 848, 1440, 1276}​
> Not bad compared to Binomial[8, n]*(n - 1)!/4. The exceptions are not too insane, and it's nice to see that odd cycles have no rotational symmetry.
> ...



Yes, I got the same results. I also did inverses without reflections, for completeness.

mod rotations only: [ 8, 28, 110, 336, 848, 1440, 1276 ]
modding out by reflections: [ 6, 14, 61, 168, 440, 720, 662 ]
modding out by inverses: [ 8, 14, 58, 168, 436, 720, 662 ]
modding out by reflections and inverses: [ 6, 7, 38, 84, 250, 360, 391 ]


----------



## miniGOINGS (Feb 6, 2010)

cmowla said:


> I guess so. Other people can tell you how they view it. That's basically what it comes down to, when viewing it from my perspective. You can also perform a 2-cycle alg if only two remain incomplete...I guess it's a matter of preference (and it only is because we are not even considering odd permutations).



Ok, thanks. Now I have to find a way to produce optimal speed algs for each case...or just use the ones from K4/KBCM.


----------



## reThinking the Cube (Feb 8, 2010)

Lucas Garron said:


> Nice. I've always been too scared of all the cases, but it doesn't look that bad after all.
> 
> 
> ```
> ...



The more canonicalizing the better!

```
"CODE" tag must be parse failing on the imbedded "["'s ?
```

Nice work to all here, VERY useful diagrams are resulting. Wiki pages would be appropriate for much of this.


----------



## reThinking the Cube (Feb 9, 2010)

cuBerBruce said:


> Lucas Garron said:
> 
> 
> > Number of _n_-cycles for 2 through 8:
> ...



Could you guys do this with added FR composite position (not just the 8 - U layer edges), and going out to 10-cycles? How about identifying those V.I.P. even#-cycle algs (2,4,6,8,10-cycle) that also keep all of the composite edges together?


----------



## deadalnix (Feb 10, 2010)

((rR)2' F (rR)2 U2)2

and

((rR)2' F (rR)2 D2)2

(if i'm right, I have no 4x4x4 to check it and My fingers know it but my brain isn't so sure).


----------



## cuBerBruce (Feb 12, 2010)

reThinking the Cube said:


> Could you guys do this with added FR composite position (not just the 8 - U layer edges), and going out to 10-cycles? How about identifying those V.I.P. even#-cycle algs (2,4,6,8,10-cycle) that also keep all of the composite edges together?



Sorry if it's seemed like a lot of time to do these calculations. With the addition of a couple more edges, the number of permutations increases greatly. So while the calculations for 8 edges took only very few minutes, for 10 edges the calculation time increased to several hours.

I note that with the FR edges added, conjugations by U layer turns is used instead of conjugations by y-axis rotations.

So far, I've finished only the calculations for reducing cases by rotational symmetry. I'll plan to append additional results to the end of this post as I complete them.

For 10 edges, the number of cases for n-cycles for n={2,3,4,...,10} that involve at least 1 of the FR edges are:
{ 5, 32, 210, 1176, 5460, 20160, 55440, 100800, 90720 }

Adding in the previous results for 8 edges, the total numbers are:
{ 13, 60, 320, 1512, 6308, 21600, 56716, 100800, 90720 }

The above numbers include the cases of n-cycles that don't split up any pairs. The number of such cases that include permuting of the FR edges are:
{ 1, 0, 2, 0, 12, 0, 48, 0, 96 }

The total number of these n-cycle cases (whether or not FR edges are permuted) are:
{ 2, 0, 5, 0, 20, 0, 60, 0, 96 }

EDIT 1:
I note that I counted the number of 2-cycle cases that don't split up any edge pairs as 2. Those cases are (1) swapping the element in a U-layer edge pair, and (2) swapping the elements of the FR edge pair. Of course, these two cases could be viewed as the same thing. Generally, I could use cube rotations xy and y'x' to reduce cases that only involve the FR edge pair and 2 adjacent edge pairs in the U layer (assuming we're also allowing conjugation by U-layer moves; otherwise specifically the UF and UR edge pairs ). These symmetries have not been considered in my calculations. So the swapping of the two edges of a pair is counted as 2 cases instead of 1.

Results for counting reflections as the same case.

n-cycles involving at least one of the FR edges (for n=2,3,4,...,10):
{ 3, 16, 105, 588, 2730, 10080, 27720, 50400, 45360 }

total cases (for n=2,3,4,...,10):
{ 9, 30, 166, 756, 3170, 10800, 28382, 50400, 45360 }

n-cycles preserving edge pairing involving at least the FR edge pair:
{ 1, 0, 1, 0, 6, 0, 24, 0, 48 }

n-cycles preserving edge pairing (whether or not FR edges move):
{ 2, 0, 3, 0, 10, 0, 30, 0, 48 }

EDIT 2:

Results counting reflections and inverses as the same case.

n-cycles involving at least one of the FR edges (for n=2,3,4,...,10):
{ 3, 13, 55, 324, 1380, 5160, 13920, 25440, 22800 }

total cases (for n=2,3,4,...,10):
{ 9, 20, 93, 408, 1630, 5520, 14311, 25440, 22800 }

n-cycles preserving edge pairing involving at least the FR edge pair:
{ 1, 0, 1, 0, 5, 0, 14, 0, 30 }

n-cycles preserving edge pairing (whether or not FR edges move):
{ 2, 0, 3, 0, 8, 0, 20, 0, 30 }


----------



## reThinking the Cube (Feb 15, 2010)

cuBerBruce said:


> reThinking the Cube said:
> 
> 
> > Could you guys do this with added FR composite position (not just the 8 - U layer edges), and going out to 10-cycles? How about identifying those V.I.P. even#-cycle algs (2,4,6,8,10-cycle) that also keep all of the composite edges together?
> ...




Thanks Bruce, this is a VERY fine piece of work! 



cmowla said:


> I see great potential in reThinking the Cube's quest for even n-cycle possibilities, assuming that the ultimate goal is to find a scenario which can make room for a OLL parity algorithm which only messes up the last layer and a F2L slot......(snip)
> 
> I suspect that a two 4-cycle/one 2-cycle algorithm can be achieved using the conventional method, not just by the one which I used to find mine. Hence, in order to really see all of the possibilities, we can't just look for all distinct even cycle cases, but also look to odd multiples of 2-cycles, odd multiples of 2-cycles with an even number of double parity 4-cycles, and vice versa.



Good point, and you are right, but we also have to be careful, and not get away from the relevance to LLK4. Bruce's 100% correct answer for n-cycles preserving edge pairing (whether or not FR edges move): { 2, 0, 3, 0, 8, 0, 20, 0, 30 }. So the next step would be to add in the other odd perm cases (multi-cycles) that also keep the composite edges paired. The 8-cycle and 10-cycle cases are exempt from this possibility, but the other even-cycle cases are not.

Lucas: Do you have any ideas for a suitable naming system that could be used to specify (by its name alone) any big-cube edge perm case? Right now, without diagrams, or whole cube representations, it is (and is going to be - once the algs start rolling in) rather hard to communicate what cases are being referred to.


----------



## Lucas Garron (Feb 15, 2010)

reThinking the Cube said:


> Good point, and you are right, but we also have to be careful, and not get away from the relevance to LLK4.


K4LL.



reThinking the Cube said:


> Lucas: Do you have any ideas for a suitable naming system that could be used to specify (by its name alone) any big-cube edge perm case? Right now, without diagrams, or whole cube representations, it is (and is going to be - once the algs start rolling in) rather hard to communicate what cases are being referred to.


What's wrong with writing down the permutation or cycle decomposition?
You can number the edges if you want.

Also, do you mean edges or wings?


----------



## reThinking the Cube (Feb 16, 2010)

Lucas Garron said:


> reThinking the Cube said:
> 
> 
> > Lucas: Do you have any ideas for a suitable naming system that could be used to specify (by its name alone) any big-cube edge perm case? Right now, without diagrams, or whole cube representations, it is (and is going to be - once the algs start rolling in) rather hard to communicate what cases are being referred to.
> ...



Just go ahead and name/label some of the cases in this K4LL diagram you posted earlier. The nomenclature should be able to handle the additional FR edge pieces as well. I will use whatever convention you come up with. 






EDIT: Starting idea for a universal edge perm case naming system. Number the edges 0-9 with UFr = 0, UFl = 1, and going clockwise ending with FRd = 9. Possible syntax - use bracket prefix [cycle1,cycle2,cycle3] to describe the cycles for the case (can be multiple (compound) cycles, clockwise/counterclockwise), and append the permutations for each, seperated by commas. 
Examples for some cases above would be:
1st case - [3]170
2nd case - [3']710
5th case - [3]671
6th case - [3']761
PLL parity case - [2,2]40,15

Option to append "C4" to stand for Cube type = 4x4x4. 1st case would then = C4[3]170. 

Lucas: feedback please?


----------



## cuBerBruce (Feb 17, 2010)

I used the Polya-Burnside lemma to calculate the total number of cases for the last 10 edges (U-layer edges and FR edges), using conjugation by U-layer turns and reflections to reduce the cases. This gave 454096 cases. Without reflections, the number of cases increases to 907424. I also wrote a C++ program to do a brute force verification of these numbers. With my C++ program, I also computed 230612 cases when using inverses as well.

I note that if the idea is to generate optimal algs for each case, then conjugation by U-layer turns should not be used to reduce the cases. As I noted in an earlier post, it is possible to use conjugation by cube rotations (and not just y-axis rotations) to reduce the number of cases. I calculated the resulting number of cases for each set of n-cycles using a C++ program.

I am not completely sure of these results, but the values I got for using cube rotations only is (for n=2,3,...,10):

{ 14, 108, 818, 4800, 22500, 82080, 223036, 403200, 362880 }

For considering reflections as equivalent, the numbers I get reduce to:

{ 9, *54*, *415*, 2400, 11266, 41040, 111542, 201600, 181440 }

For considering reflections and inverses as equivalent, I get:

{ 9, *31*, 220, 1224, 5681, 20616, 55879, 100992, 90816 }

Doing the same for only the edge pair preserving n-cycles, I get (for n=2,4,6,8,10):

considering cube rotations only:

{ 1, 5, 44, 204, 384 }

considering cube rotations and reflections:

{ 1, *3*, 22, 102, 192 }

considering cube rotations, reflections, and inverses:

{ 1, 3, 15, 54, 104 }

EDIT: I implemented my case counting with a different algorithm as a check. As a result, I found a bug in my original code which resulted in a few wrong numbers. I've corrected these numbers in *boldface*. Both algorithms are now in agreement, making me now fairly confident of the results.


----------



## reThinking the Cube (Feb 17, 2010)

cuBerBruce said:


> I used the Polya-Burnside lemma to calculate the total number of cases for the last 10 edges (U-layer edges and FR edges), using conjugation by U-layer turns and reflections to reduce the cases. This gave 454096 cases. Without reflections, the number of cases increases to 907424. I also wrote a C++ program to do a brute force verification of these numbers. With my C++ program, I also computed 230612 cases when using inverses as well.
> 
> I note that if the idea is to generate optimal algs for each case, then conjugation by U-layer turns should not be used to reduce the cases. As I noted in an earlier post, it is possible to use conjugation by cube rotations (and not just y-axis rotations) to reduce the number of cases. I calculated the resulting number of cases for each set of n-cycles using a C++ program.
> 
> ...



Very astute you are, Bruce. Yeah, it is tempting to simply reduce by conjugating the cases, but we should know FIRST which one (of the U-turn conj cases) yields the best alg for the primary case. Of course many of the earlier results - n-cycles preserving edge pairing (whether or not FR edges move):{ 2, 0, 3, 0, 8, 0, 20, 0, 30 } can also be further reduced by 1-2 move conjugations, but that also needs to wait for the same reason. I think the numbers you have above are correct for reducing single even-cycle cases without conjugation. So the next step would be to add in the other odd perm cases (multi-cycles) that also keep the composite edges paired. The 8-cycle and 10-cycle cases are exempt from this possibility, but the other even-cycle cases are not. Would it be possible for you to also include with those?


----------



## cuBerBruce (Feb 17, 2010)

reThinking the Cube said:


> Very astute you are, Bruce. Yeah, it is tempting to simply reduce by conjugating the cases, but we should know FIRST which one (of the U-turn conj cases) yields the best alg for the primary case. Of course many of the earlier results - n-cycles preserving edge pairing (whether or not FR edges move):{ 2, 0, 3, 0, 8, 0, 20, 0, 30 } can also be further reduced by 1-2 move conjugations, but that also needs to wait for the same reason. I think the numbers you have above are correct for reducing single even-cycle cases without conjugation. So the next step would be to add in the other odd perm cases (multi-cycles) that also keep the composite edges paired. The 8-cycle and 10-cycle cases are exempt from this possibility, but the other even-cycle cases are not. Would it be possible for you to also include with those?



I've now analyzed the following cycles structures for odd permutations that preserve edge pairs.

The data for each case is:
{ total permutations, count reduced by cube rotations, count reduced by cube rotations & reflections, count reduced by cube rotations & reflections & inverses }

2-2-2-2-2:
{ 81, 81, 47, 47 }

2-2-2
{ 70, 41, 25, 25 }

2-2-4
{ 180, 153, 78, 42 }

2-2-6
{ 240, 240, 120, 66 }

2-4-4
{ 300, 300, 156, 84 }

EDIT:
In case anyone is interested in the number of cases when reducing by conjugation by U-layer turns instead of by cube rotations, I've generated these, too.

2-2-2-2-2
{ 81, 25, 18, 18 }

2-2-2
{ 70, 19, 14, 14 }

2-2-4
{ 180, 45, 24, 17 }

2-2-6
{ 240, 60, 30, 22 }

2-4-4
{ 300, 80, 43, 28 }


----------



## reThinking the Cube (Feb 23, 2010)

cuBerBruce said:


> reThinking the Cube said:
> 
> 
> > Very astute you are, Bruce. Yeah, it is tempting to simply reduce by conjugating the cases, but we should know FIRST which one (of the U-turn conj cases) yields the best alg for the primary case. Of course many of the earlier results - n-cycles preserving edge pairing (whether or not FR edges move):{ 2, 0, 3, 0, 8, 0, 20, 0, 30 } can also be further reduced by 1-2 move conjugations, but that also needs to wait for the same reason. I think the numbers you have above are correct for reducing single even-cycle cases without conjugation. So the next step would be to add in the other odd perm cases (multi-cycles) that also keep the composite edges paired. The 8-cycle and 10-cycle cases are exempt from this possibility, but the other even-cycle cases are not. Would it be possible for you to also include with those?
> ...



Bruce: Looking good here, but a couple odd ones got left out - [2-3-3], [4-3-3]. 

Any suggestions now, on how to generate all of the edge perm diagrams that would represent these cases, would be much appreciated.

Lucas: your esteemed feedback is urgently requested - for an earlier case naming post in this thread.


----------



## cuBerBruce (Feb 23, 2010)

reThinking the Cube said:


> Bruce: Looking good here, but a couple odd ones got left out - [2-3-3], [4-3-3].




Using cube rotations
{ total permutations, count reduced by cube rotations, count reduced by cube rotations & reflections, count reduced by cube rotations & reflections & inverses }

2-3-3:
{ 160, 136, 68, 35 }

3-3-4:
{ 160, 160, 80, 44 }

Using conjugation by U-layer turns:
{ total permutations, count reduced by conjugation by U-layer turns, count reduced by conjugation by U-layer turns & reflections, count reduced by conjugation by U-layer turns & reflections & inverses }

2-3-3: 
{ 160, 40, 20, 13 }

3-3-4:
{ 160, 40, 20, 15 }

EDIT:


reThinking the Cube said:


> Any suggestions now, on how to generate all of the edge perm diagrams that would represent these cases, would be much appreciated.



I modified my program to generate a list of all the various odd permutation cases preserving edge pairs (distinct with respect to cube rotations) using cycle notation.

See the attachmentment.


----------



## reThinking the Cube (Feb 27, 2010)

cuBerBruce said:


> reThinking the Cube said:
> 
> 
> > Any suggestions now, on how to generate all of the edge perm diagrams that would represent these cases, would be much appreciated.
> ...



Attachment output is great. I am liking that notation a lot more now.

I am most curious about the case [2 2 2] (06) (17) (89), which corresponds by cube rotation z'y' to [2 2 2] (01) (68) (79) on your list. It would be nice to get some algs for that case.


----------



## Christopher Mowla (Jan 23, 2013)

Hey Bruce, can you calculate {total permutations, count reduced by cube rotations} for the nxnxn cube for the set of all products of disjoint 2-cycles in 8 objects, 12 objects, and 24 objects?

For example,

The total unabridged amount of disjoint 2-cycle permutations in *8 objects* is:
1 2–cycle: 28
2 2-cycles: 210
3 2-cycles: 420
4 2-cycles: 105
_I know that you and Lucas have already calculated 58 for the total count reduced by cube rotations for 2 2-cycles and 8 for 2-cycles._

The total unabridged amount of disjoint 2-cycle permutations in *12 objects* is:
1 2–cycle: 66
2 2-cycles: 1485
3 2-cycles: 13860
4 2-cycles: 51975
5 2-cycles: 62370
6 2-cycles: 10395

The total unabridged amount of disjoint 2-cycle permutations in *24 objects* is:
1 2–cycle: 276
2 2-cycles: 31878
3 2-cycles: 2018940
4 2-cycles: 77224455
5 2-cycles: 1853386920
6 2-cycles: 28109701620
7 2-cycles: 265034329560
8 2-cycles: 1490818103775
9 2-cycles: 4638100767300
10 2-cycles: 6957151150950
11 2-cycles: 3794809718700
12 2-cycles: 316234143225


----------



## cuBerBruce (Jan 24, 2013)

cmowla said:


> Hey Bruce, can you calculate {total permutations, count reduced by cube rotations} for the nxnxn cube for the set of all products of disjoint 2-cycles in 8 objects, 12 objects, and 24 objects?



The numbers for the 24 objects case are quite large. The way I normally compute these types of things in GAP would require too much memory, to say nothing about what the runtime might be. It might be possible to use the so-called Burnside lemma to compute them. But the cases for 8 and 12 objects should be no problem. I guess I am to assume you want this for 8 LL edges, 12 dedges or middle edges on odd size cube, and all 24 edges.


----------



## Christopher Mowla (Jan 24, 2013)

Thanks for the quick response. I actually want this for 8 corners, 12 middle edges on odd size cubes, and all big cube parts (wings, and all orbits of centers). I didn't think about it before, but maybe it matters which piece types these are for (maybe there would have to be a calculation for the orbit of X-centers, + centers, oblique centers, and wing edges?). I'm glad you mentioned that. Whatever you can do without too much trouble will be fine (anything is better than nothing...and if for some reason you don't have time to do this, then that's okay as well).


----------



## cuBerBruce (Jan 24, 2013)

For now, I've got numbers for 8 LL wing edges (any 1 orbit):

1 2-cycle: 8 (6)
2 2-cycles: 58 (38)
3 2-cycles: 112 (70)
4 2-cycles: 35 (30)

Numbers in parentheses include reducing by mirroring.

EDIT #1:
For the corners, ignoring orientation, I come up with these numbers.

1 2-cycle: 3 (3)
2 2-cycles: 16 (12)
3 2-cycles: 29 (20)
4 2-cycles: 16 (12)

EDIT #2:
For 12 middle-edge pieces, ignoring orientation, I get these numbers.

1 2-cycle: 5 (4)
2 2-cycles: 77 (47)
3 2-cycles: 626 (338)
4 2-cycles: 2265 (1182)
5 2-cycles: 2711 (1406)
6 2-cycles: 507 (278)


----------



## Christopher Mowla (Jan 24, 2013)

Thanks, Bruce. These numbers are a lot less than the "unabridged" numbers for permutations in general. That's excellent news. If you ever decide to compute the numbers for 24 objects (which might be 4 times as hard as what I initially thought, if you would need to do calculations for 4 different piece types), I will never lose my curiosity to see those numbers. Thanks again.


----------



## cuBerBruce (Jan 25, 2013)

cmowla said:


> Thanks, Bruce. These numbers are a lot less than the "unabridged" numbers for permutations in general. That's excellent news. If you ever decide to compute the numbers for 24 objects (which might be 4 times as hard as what I initially thought, if you would need to do calculations for 4 different piece types), I will never lose my curiosity to see those numbers. Thanks again.



Generally speaking, when you reduce cases by symmetries like this, the number of reduced cases will be roughly the number of unabridged cases (as you call them) divided by the number of symmetries. More specifically, this quotient will be a lower bound. As the number of cases gets larger, the percentage accuracy of this calculation seems to get better and better.

So for the 24-piece orbits, divide the unabridged numbers by 24 (the number of rotational symmetries of a cube) and you should get a number that's pretty close to the true answer.

I note that for corners and middle edges, I have ignored orientation. So UF<=>UB is considered equivalent to UF<=>BU, for example. If you want to treat these as distinct, the number of unabridged cases as well as the number of reduced cases will of course be higher.

I also note that you seem to be considering the centers (in an orbit) as 24 distinct objects, or at least that you are able track precisely how pieces are moved around, even though the standard puzzles may have indistinguishable pieces. (Said another way, we're talking about permutations and cycles, not about the visibly distinct states of the puzzle.)


----------

