Methods for Forming 2-Cycle Odd Parity Algorithms for Big Cubes

**AvGalen** · 01-08-2012

Originally Posted by cmhardw

Wow Chris! Thank you so much for this write-up! I have only watched the derivation of the "standard" algorithm, both parts, and it is amazing to have an idea of how this works. I will want to go through the second part a few times to make sure I fully understand your application of setup turns, but this is amazing! I can't wait to go through the rest of the videos for the other parity algs!

Chris

Somebody explaining parity algs to Chris is like somebody explaining how to create life to God!

**cmowla** · 01-25-2012

Originally Posted by mrCage

Very nice algorithm, particularly the 16 btm one, a conjugate!!

I don't know why someone hasn't posted this idea before, but here are 4-cycle conjugates.

4-Cycles for all Even Cubes

Spoiler:

It turns out that "The Holy Grail" Edge Flip Alg. is not optimal for even cubes. I found an algorithm that is 19q/18 btm for all cases on even cubes. Like the conjugates above, at least two + center pieces are discolored at best (it does not work for odd cubes).

Modeled on the 6x6x6,

Inner orbit: [3l e 3d: [3d, 3b' 3R' 3b] [2-3r 3d: 3R'] ] (19,18)
Outer orbit: [3l e 3d: [3d, 3b' 2R' 3b] [2-3r 3d: 2R'] ] (19,18)

We can add one conjugate to this algorithm to make it work on odd cubes, but that gives us a (21,20) solution for odd cubes.
[3l S 5e 3d: [3d, 3b' 3R' 3b] [2-3r 3d: 3R'] ] (21,20)
or giving us an average of 20.5 for odd cubes, which is definitely more than the "Holy Grail" alg's average.

So even cube's minimum average of block quarter turns and block half turns has been lowered to 18.5, while the minimum average for odd cubes remains at $\frac{\left\lfloor \frac{n}{2} \right\rfloor }{2-2^{\left\lfloor \frac{n}{2} \right\rfloor }}+19.5$ .

and therefore the "Holy Grail" is still the only existing algorithm that has an average less than 19.5 for the single edge flip case on all cube sizes, odd and even.

**cmowla** · 02-25-2012

Here are new results I found since my last post (well, most of the 2-gen material I found in the past, but I didn't post it until now).

Non-Symmetrical Wide Turn Based Algorithms Covered in Depth (and more):

2-Gen 2-Cycles:

**Stefan** · 02-25-2012

Originally Posted by cmowla

A Collection of Algorithms.pdf

I sadly don't have the time to read it all, but one thing caught my eye:

Briefest 2-cycle Algorithm that can possibly exist (probably for all move metrics, at least for the 4x4x4 and 5x5x5
cubes): it preserves only the pairing of the edges.
l' F' R2 F2 u' F' l (9, 7)

What about u' R F' U R' F u (7, 7)? It's shorter in several metrics and even preserves the centers.

**aronpm** · 02-25-2012

Originally Posted by Stefan

I sadly don't have the time to read it all, but one thing caught my eye:

What about u' R F' U R' F u (7, 7)? It's shorter in several metrics and even preserves the centers.

l' F' R2 F2 u' F' l can be solved to leave only a 2-cycle, but u' R F' U R' F u can be solved with 3-cycles.

**Stefan** · 02-25-2012

Ah ok, so it does intentionally preserve (or change) more than "only the pairing of the edges". I think it would be good to clarify that there.

**cmowla** · 02-28-2012

Hey everyone,

I have found a very simple representation of the optimal (in btm) non-symmetrical single edge flip algorithms (2-cycle case) which I previously attempted to make "somewhat understandable." I could be wrong, but these representations could be the easiest for humans to picture how these algorithms work (with the deepest understanding). Personally, I'm finally satisfied (maybe you will be now too, if you ever wondered what the easiest way to understand these much as possible without looking at "gibberish").

Frédérick Badie's Algorithm
F2 r2 F2 U2 r U2 r' U2 r2 F2 l F2 l' U2 r (25,15)

Spoiler:

Cube Explorer's Algorithm (Well, one of them I generated with it)
r B2 r' U2 r U2 r2 F2 r' D2 l D2 B2 r2 F2 (25,15)

Spoiler:

Another Optimal (in btm) Non-symmetrical Edge Flip Algorithm
This algorithm has the briefest representation, so I thought I should include it.
This algorithm was probably made several years ago. It's just a cyclic shift, y2 cube rotation, and mirror of the transformation of "Cube Explorer's Alg" previously shown in this post.
r2 U2 r' U2 r U2 B2 r2 B2 r U2 l' B2 l B2 (25,15)

Spoiler:

@Stefan,
When I first looked at Frédérick Badie's Algorithm, I and saw the r2 turns (I learned how to solve big cubes approximately 5 years ago), I actually thought it was similar to your PLL Parity alg, r2 F2 U2 r2 U2 F2 r2, which I now have found to be the best 2 2-cycle to include in the representations of this odd parity algorithm type! Just to let you know.

For those who are not sure why Stefan's PLL Parity algorithm works for these single dedge flip algorithms, you need to see what it does to centers on a supercube.

Also, if you just look at the representations in my document (now attached to the end of my previous post), you will see that the symmetrical algorithms I have derived a couple of years ago also have a brief conjugate such as [r' U2: r] and, of course, a three 1x(n-1) block exchanger. So, if my representations in this post show the easiest way to understand the optimal non-symmetrical single slice turn based algorithms, then the only extra piece (besides conjugates, which are almost always present in the algorithms I have seen in my time) is Stefan's PLL Parity algorithm.

**cmowla** · 08-23-2012

As I have already stated here,

My previous decomposition of Frédérick Badie's algorithm is false because, if you execute the algorithm in wide turns on the 4x4x4 supercube, the R center is rotated 90 degrees anti-clockwise (in the direction of R', not in the direction of R...so the true extra quarter turn must be the move r').

However, the following (new) decomposition uses the move r' as the extra quarter turn.
(See what each line of moves does to understand how this algorithm works).

r' U2 l F2 l' F2 r2 U2 r U2 r' U2 F2 r2 F2
=
r' U2 l F2 l' F2 r U2
U2 r U2 r'
r2 U2 (r') U2 r2
r2 F2 r2 F2
=
U2 r'
r U2 r' U2 l F2 l' F2
r U2
U2 r U2 r'
r2 U2 (r') U2 r2
r2 F2 r2 F2
= [U2 r': [r, U2] [l, F2] ] [U2, r] [r2 U2: (r')] [r2, F2]

With brute force searching done by others for all possible 15 btm solutions (for example, this post), I have eliminated duplicates and found that there are only 10 unique non-symmetrical 15 btm algorithms which flip the UF dedge and affect the top center.

r' U2 l F2 l' F2 r2 U2 r U2 r' U2 F2 r2 F2 (Frédérick Badie)
r' U2 r U2 l' U2 l2 F2 r F2 l' U2 F2 r2 F2
r B2 r' U2 r U2 r2 F2 r' D2 l D2 B2 r2 F2
r B2 r' U2 r U2 l2 B2 r' U2 l U2 F2 l2 F2
r B2 l' B2 l U2 r2 F2 l' F2 r U2 F2 l2 F2

r B2 r' U2 l B2 l2 B2 U2 l U2 l' U2 l2 B2
r B2 r' U2 r D2 r2 U2 F2 l F2 r' D2 r2 B2
r B2 r' U2 r D2 l2 D2 B2 l B2 r' U2 l2 B2
r B2 l' B2 l D2 l2 D2 B2 r D2 l' D2 r2 B2
r' U2 r U2 l' D2 r2 D2 B2 l' D2 r D2 l2 B2

There are actually 40 algorithms if you count mirrors and inverses (and inverses of the mirrors) of each of the 10 unique algorithms, but you can make simple adjustments to obtain those other 30 algorithms.

Since we have the decomposition for Frédérick Badie, we actually have the decomposition for all possible non-symmetrical 15 btm (all are 25q) solutions. In other words, all 15 btm non-symmetrical algorithms for this case are related.

Proof:

The 10 unique algorithms can be broken up into two groups. Each of the two groups contain five algorithms which are directly related via transformations (or mirrors of transformations).

Shifting any algorithm from Group 1 will generate an algorithm from Group 2. After the algorithm is shifted, you just rotate the flipped dedge back to UF and the center affected back into U, and, if necessary, take the mirror so that the first move of the algorithm is r or r'. (In short, if we have the decomposition for at least one algorithm in one of the groups, we can derive the decompositions for all algorithms in the other group by shifting (conjugating) its decomposition until a single dedge is flipped again (which only happens one time when shifting) ).

Group 1:

Group 2:

Examples:

With brute force searching done by others for all possible 15 btm solutions (for example, this post), I have eliminated duplicates and found that there are only 16 unique symmetrical 15 btm algorithms which flip the UF dedge and affect the top center.

There are actually 64 algorithms if you count mirrors and inverses (and inverses of the mirrors) of each of the 16 unique algorithms, but you can make simple adjustments to obtain those other 48 algorithms.

To obtain all 16 symmetrical 15 btm single dedge flip solutions (with the UF dedge flipped and the affected center in U), we just need to know the first algorithms in each group. Taking 7 transformations of the first algorithm in Group 1 and taking 7 transformations of the first algorithm in Group 2 will generate all 16 symmetrical algorithm solutions.

Group 1
r2 B2 U2 l U2 r' U2 r U2 F2 r F2 l' B2 r2 (Old Standard Algorithm)
r2 B2 U2 l U2 l' B2 r B2 U2 r U2 r' B2 r2
r2 F2 D2 r' D2 r F2 l' F2 D2 l' D2 l F2 r2
r2 F2 D2 r' D2 l D2 l' D2 B2 l' B2 r F2 r2
r2 B2 U2 r B2 r' B2 l U2 F2 r F2 l' B2 r2
r2 F2 D2 l' F2 l F2 r' D2 B2 l' B2 r F2 r2
r2 B2 U2 r B2 l' D2 r D2 B2 l U2 r' B2 r2
r2 F2 D2 l' F2 r U2 l' U2 F2 r' D2 l F2 r2

Group 2
r2 B2 U2 l' U2 r U2 r' U2 B2 r' B2 l B2 r2
r2 B2 U2 l' U2 l F2 r' F2 U2 r' U2 r B2 r2
r2 F2 D2 r D2 r' B2 l B2 D2 l D2 l' F2 r2
r2 F2 D2 r D2 l' D2 l D2 F2 l F2 r' F2 r2
r2 B2 U2 r' F2 r F2 l' U2 B2 r' B2 l B2 r2
r2 B2 U2 r' F2 l D2 r' D2 F2 l' U2 r B2 r2
r2 F2 D2 l B2 r' U2 l U2 B2 r D2 l' F2 r2
r2 F2 D2 l B2 l' B2 r D2 F2 l F2 r' F2 r2

All 15 btm symmetrical solutions are related.

Proof:

Thread: Methods for Forming 2-Cycle Odd Parity Algorithms for Big Cubes

Thread Tools

Display

Bookmarks

Bookmarks

Posting Permissions