Search

Welcome to the Speedsolving.com, home of the web's largest puzzle community! You are currently viewing our forum as a guest which gives you limited access to join discussions and access our other features.

Go to page

Premium Member

The title is a little general, but it should be, as I have a lot to share about forming several types of 2-cycle inner-layer odd permutation algorithms.

To begin, why not start with the "Pure Edge Flip" (my favorite, obviously).

I would first like to show you how to derive common OLL parity algorithms by hand. To do this, I have taken the time to make tutorial videos for three popular algorithms. Each of the three algorithm's derivations are two videos long.

Note: I recommend you to watch the derivation on the Standard Algorithm first before you watch the other videos.

Notice that all three algorithms are derived from the same commutator. Each algorithm is very related in structure. Only a few minor internal adjustments differentiates Lucasparity and the other algorithm from the standard algorithm.

In addition, I have chosen to release...

​

God's Algorithm?

For my main method for pure edge flip algorithms, I have made a video on the best/briefest algorithm I have ever found in block quarter turns (BQTM) that works for all cube sizes (Very few low move count algorithms work for all cube sizes).

Just substitute an integer greater than or equal to 4 for n to obtain the average for a cube of size n.​

Formula Derivation

In order to explain it, I will explain the original form of the formula:

[FONT=&quot]

[/FONT]​

[FONT=&quot]The First Portion[/FONT]
\( 18.5\left( 1 \right) \)​

This represents the case when any big cube size has a 2-wing edge swap between every orbit in the same composite edge. For example, any even cube size reduced to a 4x4x4 form, and any odd cube size reduced to a 5x5x5 form.

This case is 19q/18h thus the average is 18.5.​

The Second Portion
\( 19.0\left( \left\lfloor \frac{n-2}{2} \right\rfloor -1 \right) \)
This represents the number of cases where there are consecutive orbits which have odd parity in the same composite edge, starting from the corner and working its way inward, but excluding when all orbits are involved (previous case).

These cases are all 19q/19h thus the average is 19.0.​

The Third Portion

This represents all other cases:

, etc.

These cases are all (proportionally) 20q/19h thus the average is 19.5.​

It is the total number of cases of odd parity in the orbits of a big cube,

,minus the occurrences of the first two cases.​

Next, we divide everything by the total number of possible cases for odd parity in all inner-layer orbits (that same series) to get the overall average.​

Now, I am going to explain the series.

Let the total number of inner-layer orbits of wing edges in a big cube \( n\ge 4 \) be \( N=\left\lfloor \frac{n-2}{2} \right\rfloor \)

Then, the total number of cases of odd parity between the orbits is the sum of the combinations of the number of orbits involved:

As you can see, there are many more cases for an average of 19.5 than for 18.5 and 19.0.​

But, the overall average still is less than 19.5.

Based on the fact that even and odd cubes have the same number of orbits (e.g. both the 6X6X6 and 7X7X7 have two inner-layer orbits), the floor function can be omitted and we can take the limit as the cube size gets large.

This means, no matter how large n gets, the average will come arbitrarily close to, but it never reaches 19.50. (This is apparent already without calculus, but I thought a "second opinion" would further verify this statement.)

You're very welcome. This thread will be all about that. In addition, later I will begin my proposal about why I believe the "HOLY GRAIL" is optimal. For right now, I will introduce the methods one post at a time.

Now to everyone:

Before I even begin, I want to note that I refer to the term "symmetrical" as an adjective to describe the algorithms derived in this post. In the future, I will go into more detail about this and that of what I like to call non-symmetrical algorithms. For right now, I believe there is enough material in this post.

Now, I trust that before reading this, you have watched all three of my derivation tutorials on pure edge flip algorithms. However, you still may be able to catch on if you have not.

Here are 3 tools you will need to have in order to construct any fast (and relatively brief) pure symmetrical 2-cycle odd parity algorithm that currently exists. You can also derive some of your own that you can be proud of.

2) Knowing how to apply set-up moves to put all 3 1X(N-1) blocks in the same slice (left or right).As seen in all 3 videos, different set-up moves will create different algorithms for an interior-looking J-perm.

3) Knowing how to apply set-up moves to finish off the pure algorithm.As seen in all 3 videos, different outer set-up movescan make a difference in how fast an algorithm can be.
__________________________________

Here are my derivations for other types of parity cases.

For the following two algorithms, I recommend you watch the first and third tutorial videos first (lusasparity derivation is not necessary to watch).

Once you have:
1) A commutator which swaps only three 1X(N-1) blocks within M,
2) Added set-up moves to that commutator in order to bring all three blocks into the same slice, and
3) Applied the quarter turn to put two of them into their solved positions and pull one out, leaving two individual edge cubies and two 1X(N-2) center blocks unsolved,

Then what you have is what I call a base for conventional symmetrical algorithms: an interior-looking J-Perm.

In the three tutorial videos, I added different set-up moves to different bases to obtain the standard pure edge flip algorithm, lucasparity, and another algorithm with all U2 face rotations. In general, a very easy technique can be used (but the most powerful technique there is) to create complicated (but brief algorithms). The technique is what I call shifting (but it may be thought of as rotating).

Shifting is adding a set-up move to an algorithm which is the inverse of the algorithm's first move.

This gives us the ability to keep the same number of moves in a base to transform it into another (and probably more complicated to understand at face value) base which is closer to what we need to construct a particular algorithm. The algorithms resulting from one or more shifts of a base (without adding exterior set-up moves which cancel with either the first or last moves in the base) is what I like to call a shifted base.

How Do Shifts Work?

Using the previous example, staring with:U2
r'
U2 l U2 r' U2 r U2 l'
r
U2
r
If you say in your head, "Boy, I wish I could separate the two 1X2 center blocks from each other without adding moves to the algorithm", shifting is your sanctuary because a shift of the first move will do just that. This should not be surprising because a shift is just a very particular set-up move.

Another important note is that, if the move being shifted is not in contact with any of the other pieces which are currently unsolved, then it has no effect on the cube: it only changes the algorithm structure.

If we did in fact wish to use that cube state, we would have a choice on whether we prefer the l move to be where it is or move to the right of the last U2: either way, that algorithm accomplishes the same task.

For those who have computed algorithms with 3X3X3 solvers, doesn't this one fact eliminate a whole bunch of possible algorithms for parity cases?

Pretty neat, uh? Now I will give some examples putting this powerful technique to work.
__________________________________
Here is the derivation of the standard algorithm for the opp wing edge swap case, using this technique.

Note: I HIGHLY recommend you watch my derivation videos on the standard algorithm and Lucasparity before attempting to follow this, because I start from Lucasparity's base.

2) In order to create an algorithm with all U2s, we need to first move down the two 1X(N-1) blocks in r so that a U2 set-up move can be used to bring the third block into slice r.r'
U2 l U2 r' U2 r U2 l'
r

4) Now we apply a quarter turn to put back two of the 3 currently unsolved 1X(N-1) blocks as well as pulling out the currently solved one. This gives us a net result of two edge cubes and two 1X(N-1) blocks unsolved (which is exactly what we need for 2-cycle odd permutation algorithms).

In my 2-Corner Swap PLL Parity Thread, I mentioned that inserting a r2 next to a l or vice versa can convert pure edge flip algorithms to double-parities. I believe we now have enough tools to see why this is.

, where the two oppositely swapped edges and the two centers are in the same slice, then the least amount of pieces are affected when the extra half turn is applied to induce PLL parity. From there, you are free to either add set-up moves or shift and then add set-up moves. Multiple algorithms can be created from the same base shifted several times.

As you can see, all of the most-common fast symmetrical algorithms can be derived using the same commutator. Not only that, but you can easily make them yourself with pure arithmetic and logic.

If anyone has any questions, don't be shy to ask. I am willing to help.

Premium Member

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!

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!

I am honored to hear this from you! I will derive other algorithms soon as well. I have the derivations, but I need the time to write them out clearly for everyone to understand as well as make some more videos. I will also introduce the method which I formed "The Holy Grail" from.

Premium Member

[FONT=&quot]An[/FONT]other method for 2-Cycle Parity Algorithms is based on a commutator for which not all of its moves are in the conventional move set. Below is a link to a video deriving this commutator as well as deriving "cmowlaparity" pure edge flip algorithm. As mentioned with the derivation videos before, it is a good idea to first watch the derivation of the standard pure edge flip algorithm before watching this one. (The link for this is in the first post of this thread).

[1] Start with the commutator to swap 3 1X(N-1) blocks in M.B2 U' r' U B2 U' r UTo see how I came up with this commutator, please take time to watch the derivation video).

[2] Now, as with conventional algorithms, we need to get all 3 1X(N-1) blocks into the same slice so that we can apply a quarter turn to put back two of those blocks (solve back half of the slice). This will leave us with only two 1X(N-2) center blocks swapped as well as swap two individual edge cubies.

Here, we add the set-up move l'.l'
B2 U' r' U B2 U' r U
lThis will move the 1X(N-1) slot currently affected in the back left portion of the cube to the top left of the cube.

[3] Now, all we need to do is do a set-up move U2 to bring the third 1X(N-1) block affected into the r slice (on top of the other two).U2 l'
B2 U' r' U B2 U' r U
l U2

[5] As with the standard algorithm derivation, our goal is to get a set-up similar to U2 l U2 r' U2 r U2 F2 r F2 l'. Before we do anything, let's write what we have on one line:
U2 l' B2 U' r' U B2 U' r U l U2 r'

Now we move the last three (half turn) moves to the front of the algorithm (a backwards shift of 3h):l U2 r'
U2 l' B2 U' r' U B2 U' r U(I explain why shifts work in the derivation video, for those who are uneasy with this step.)

This gives us essentially the same set-up as the main portion for the standard algorithm without us having to add any moves to what we had originally.

I am going to now derive K4 2-cycle parity algorithms based off of cmowlaparity. These cases involve a swap of wing edges in adjacent composite edges, as opposed to opposite edges as seen with common algorithms I derived in my previous post. These algorithms are a direct solution to these particular parities, as opposed to adding set-up moves to an opposite wing edge swap algorithm such as l' U2 l' U2 F2 l' F2 r U2 r' U2 l'2. In addition, based on my search, the algorithms I will derive for these cases are optimal in half turn moves.

For all three of these cases, I build directly off of cmowlaparity's base. So please watch the derivation video or read and understand steps 1-5 of the written derivation previously provided in this post.

Note: In order to use these algorithms on odd cubes, the M slice needs to be included with either of the wide turns (but not both).

[3] Add the set-up move l'2 to swap the two 1X(N-2) center blocks of the front face with each other. At the same time, the UFl wing edge will be placed in the DBl slot which is currently affected.l'2
U l U2 r' U2 l' B2 U' r' U B2 U' r
l'2

Because B2 U' r' U B2 U' r U and B2 U r' U' B2 U r U' are both commutators which swap three 1X(N-1) blocks on a cube of size N, then it can be justified that if we invert just the individual U turns in case 1's algorithm, we will have the algorithm for case 2!

To verify why this is, we can reconstruct cmowlaparity's base with the commutator B2 U r' U' B2 U r U' instead of B2 U' r' U B2 U' r U. However, I will not cover that because it is just repetition.

Hence, all three K4 2-cycle parity cases can be tackled with essentially the same algorithm. In addition, they are all optimal in half turn moves.

I can tackle all three in less quarter turns using my main method for 2-cycle symmetrical algorithms. I will present this method in my next information post. From that method will come a derivation for the "Holy Grail".

2-Cycle and 3-Cycle Algorithms

Since algorithms for all 3 cases mentioned were derived from essentially the same algorithm, why don't we see if there is any other types of algorithms we can generate from what we have. By doing some minor adjustments, the results are astounding!

Now, there are a lot more cases than the ones I am going to list here, but I will give them case numbers anyway.

The minimum number of half turns to do the 3-cycle alone is 10h, and the minimum number of half turns to do the 2-cycle alone is 16h. Hence, this algorithm does both simultaneously in 6h less than if optimal algorithms were used to do each separately.

[1] If we invert the same l move in the single slice version of the algorithm for "case 1" of the 2-cycle K4 algorithms (before we converted any moves to wide turns), we have:l'2
U l U2 r' U2 l B2 U' r' U B2 U' r
l'2

Premium Member

Derivation of the "Holy Grail of Edge Flip Algorithms" (and Much More)

After many hours of work, I finally made a video series which gives a very thorough explanation of how I found the algorithm (shown in my first post in this thread) and all of the details about it that one could ask for (except on my conjecture why it could be God's Algorithm for this specific case).

Due to the thorough explanation, as well as me trying to introduce this new wide-turn based parity algorithm method, the total video time is stretches to approximately 1 hour and 38 minutes. BUT, note that one needs only to watch Part I and Part II to see the derivation of the Holy Grail (HG) algorithm for the 4x4x4 and 5x5x5 cubes. (See the short description under the link for each of the videos as well as the video descriptions on YouTube for more information on what's in each video).

Here is the video series.

BeginnerPart I (22:15)
This video covers "basic" information necessary to fully understand Part II. In addition, the commutator used in the HG algorithm is thoroughly developed, instead of beginning the derivation with the commutator.

​

IntermediatePart II (31:21)
This video concludes the derivation for the HG algorithm for the 4x4x4 and 5x5x5 cubes.

Part III (17:57)
This video touches on how to translate the HG algorithm to higher order cubes (6x6x6 and greater), gives a "general formula" for the algorithm, and other details.

AdvancedPart IV (26:51)
This video is VERY theoretical in nature, as I explain the theory behind why the translation to larger cubes worked (i.e., interior set-up move insertion theory).
This is a must see for puzzle theorists, as it is definitely a major advancement in algorithm creation, and, obviously, it is the final step to us fully understanding why every move in the HG algorithm works.​

NOTE:
For those who choose not to watch Part I, (I do recommend watching it, though, so that you can get into my head and get a good foundation), take note that I use SiGN notation. If you don't know SiGN notation already, don't worry. I explain from time to time throughout the video series about why moves are represented as they are with SiGN. More importantly, I have made a video on SiGN notation you can watch here: SiGN Notation.

Now, the SiGN notation I use differs slightly from what is currently integrated in Lucas Garron's resource, alg.garron.us. There are only two differences (according to my knowledge):

1) For wide turns on the 4x4x4, I have 2(u,d,f,b,l,r) instead of (u,d,f,b,l,r). I chose to do this because it is more consistent with the general structure of the notation.

2) Although these moves are rarely used in the video series, the way to define the M, E and S slice turns (and block turns of them), is different as well. Michael Gottlieb (qqwref), one of the independent inventors of SiGN notation, and I agreed on this version of SiGN because it defines the M, E and S slices in such a way to not depend on the cube size.

​

The Method of
Wide Turn-Based 2-Cycle Odd Parity Algorithms​

Please make sure you have watched at least Part I and Part II of the derivation before reading what’s below (Part III and Part IV are not necessary to watch to understand the rest of the content in this post).

Edge Flip Algorithms which Do Not Use the Technique of Shifting​

(Minimum: 22q)​

In Part II, I mention 22q and 23q algorithms without really showing them. Here are a few algorithms of this length which were indirectly described in that video:

Note 1: To apply the following algorithms to higher order even and odd cubes, all of the moves are basically the same (no move insertions like in the Holy Grail Algorithm): keep the same proportion of the outer block turns and apply the algorithm to the proper inner slice.

Note 2: I will leave the derivations to you all. These algorithms have the same general structure as common speedsolving parity algorithms. I will provide their outlines, however.

As far as I have been able to find, no algorithms of this form, that is:

Outer set-up moves to make an edge flip
set-up moves to move all blocks into either the r slice or l slice
commutator
Inverse of set-up moves to move all blocks into either the r slice or l slice
(quarter turn)
Inverse of outer set-up moves to make an edge flip

are less than 22q for any size cubes.

Optimal Edge Flip Algorithms that Discolor the Centers
(They can be used in the Cage Method)​

Optimal Algorithm in Quarter Turns (15q)

An algorithm that only permutes 2(n-2) center pieces (many others are much more messy).

Optimal Algorithms in Half Turns (12h)Brief History
According to my knowledge, no one has ever been able to achieve an algorithm to do this which was less than 13h. So, this is a breakthrough for HALF turns!

These algorithms are single slice-based, although they can have all turns except inner-layer slices converted to wide to achieve a similar form to the 15q algorithm presented previously:

Possible Optimal Algorithm for the 2-cycle Single Edge Flip (not double-parity): 15q/11h
We can simply remove the U2 from the previous algorithm (the non-doubleparity version) to achieve this, because the U2 move does not help do anything but restore the outer-layers of the cube.

I am aware that I am stating the obvious for some, but just to get everyone on the same page, I will mention something before I present my algorithms.

Usually, if we have a double parity in two adjacent composite edges, we can just conjugate a double parity algorithm for two opposite composite edges to handle the adjacent case (simple enough, right?).

What I have done is actually made algorithms which do the same task without conjugating an opposite edge double parity algorithm. With the approach that I took, it appears that 19 btm seems to be the minimum so far for the 4x4x4, 5x5x5, and special cases of big cube sizes in general for algorithms (for most cases, it's 20 btm).

I am NOT saying that this is the optimal algorithm OF THIS TYPE for btm (i.e., not doing a R B move conjugate to an opposite edge algorithm), but it might be.

Interestingly enough though, the move count for these unified algorithms and the regular combos seems to be nearly equivalent (and again, based off of the approach that I took).

I have found two different (but very related) algorithms. One of them is 19-20 btm, and the other is 20 btm for all size cubes. In addition, I have found a 14-17 btm algorithm that discolors centers (just to satisfy my curiosity and maybe yours).

If we make the r2 turns wide, then I believe this algorithm might be lower in qtm than any other algorithm and/or algorithm combo that currently exists. Its ftm count is equivalent to the combo presented in the first spoiler (which could be optimal too, being 25 ftm).

To successfully transfer this algorithm to all big cube sizes in general, the algorithm must be recognized as:
r2 F' R' F' U2 l F2 D2 r D2 l' F' r' F' U2 F (R [r]) F r2
, where [r] represents all of the inner-layer right slices (it does not include the central slice on odd cubes) which need to be affected and R represents just moving the outer-most right face.

Hence it is 19 btm for very few of the \( 2^{\left\lfloor \frac{n-2}{2} \right\rfloor }-1 \) amount of possible cases for a cube of size n. (Click HERE to substitute a number for n\( \ge 4 \) to see the total amount of possible cases for a cube of size n\( \ge 4 \)).

Due to the fact that both of these algorithms are basically "cousins", they have the same beginning in their derivations. I will therefore combine them into one spoiler and separate them when it comes time to.

2) Add the following piece to have just two wings and two 1x(n-2) blocks swapped:
As seen with the derivations of most of the 2-cycle algorithms in this thread, we add setup moves to bring all 1x1x(n-1) blocks into the right slice. In addition, we add a quarter turn to solve back two of the 4 wing edge pieces and half of the centers.F2 l' F r' F' U2 F r F' U2 l F2 (r)

*Now this is where we can take two routes: one to the 19-20 btm algorithm or just the 20 btm algorithm.

For the 19-20 btm algorithm,

7) Add the setup move R' so that, when it's inverted at the end of the algorithm, it can merge with the r move there. In addition, this move will also begin to place the affected edges into their final positions.

To apply it to all size cubes, we need to use 4x4x4 wide turn equivalences for the first and last two wide turns, and we should keep Rw r', instead of canceling them to R for the 4x4x4 and 5x5x5.Rw F' Rw' F' U2 F r F' U2 r F Rw r' F Rw'

What Does This Prove?
This doesn't necessarily prove that the HG Algorithm is God's Algorithm for the visually pure edge flip case, but it does put up quite a case.

Maybe some people can play around with this base set-up and generate algorithms from it using another solver to see if more move cancellations can be achieved with the outer set-up moves Dw' M D.

A More "Perfect Set-up"

If you see the effect the base Lw' Uw' r' Uw Lw Uw' Lw2 Bw' r' Bw (Lw' r) Lw' Uw has on the bottom x-center piece, note that it takes 3 set-up moves to make a visually pure algorithm. If that x-center piece was in a different location, perhaps only two set-up moves are required to make a visually pure algorithm.

As I have told cuBerBruce when I showed him, I cannot recollect how I found the set-up for this case (a mixture of Cube Explorer, my algorithm creation method, trial and error, and basic "unscrambling" skills), but it is:

Unlike the HG Algorithm, this visually pure single edge flip algorithm has no move cancellations and remains 19q.

cuBerBruce was kind enough to run Tomas Rokicki's 3x3x3 solver and generate other 15q bases like this one (using that algorithm as the set-up). Not all of them translated to the 4x4x4, but here are two that did:

Both are 19q like the Holy Grail Algorithm, but I could not translate them to other big cube sizes.

My Point
Even though the Holy Grail Base set-up requires one additional set-up move than the "more perfect" set-up, it is not any more moves.

cuBerBruce's work shows that 15q solutions are indeed optimal for "the more perfect set-up", and Cube Explorer gives us a 14q algorithm for the Holy Grail Base set-up, which happens to be the Holy Grail Base itself.

Premium Member

Although I have already posted it in the "A Collection of Algorithms" thread, I thought I would post it here too, accompanied by a full derivation. I made a special effort to post this derivation because, as you will see, I took an entirely different approach than the previous to create the base (and a 2-gen one too!).

= [z' Rw' U' Rw' l' U L': U (r U2)3 r2 U] (25q, 21 btm)
Although this algorithm is 21 btm (3 more btm than the current minimum combo of 18 btm), it has a very low quarter turn move count being 25q (which I think is the current minimum for all combos). In addition, it is significantly easier to execute than my previous algorithms.

Derivation

Just as I had to create a base for the previous adjacent double parity algorithms in the first adjacent double parity algorithms post, the bases had the following two characteristics:

1) There were only 4 wing edges misplaced
2) There were only 2 1x(n-2) center blocks unsolved (on a supercube).

We are going to do a similar set up for this algorithm, but with a completely different approach.

[1] Just as we always start out parity algorithms, we start with a commutator. This time, it's a very brief one: r U2 r' U2

Unlike with 2-cycle algorithms, where our ultimate goal is to make a 3 1x1x(n-1) block swapper, for example: U2 l U2 r' U2 r U2 l', we are going to be dealing with 1x1xn blocks.

[2] Just as we added set up moves to the commutators for cycling 3 1x1x(n-1) blocks ^ to bring all three into the same slice (whether l or r) so that we can do a quarter turn, we are going to do the same thing here. There will only be two 1x1xn blocks (in our case, 1x1x4 blocks, since we are using the 4x4x4) we will focus on.

In order to put back the most pieces with a quarter turn (as well as inducing an odd permutation), we to solve back the 1x1x4 block in the front right portion of the cube. With r U2 r' U2, that block is currently only a complete 1x1x3 block. However,

If we add a U2 conjugate, then we will make that one a complete 1x1x4 block.
(According to the color scheme of the cube applet, this 1x1x4 block will be all white on its front side.)

[3] Next, we now prepare to do a quarter turn. Looking at the 1x1x4 block we completed in step [2], if we imagine pushing it away from us with a move r, then the entire top right 1x1x4 slot will be solved back. However, we SHOULD NOT do that right now. First, it would be smart if we first paste another block to be connected to this 1x1x4 block prior to doing the quarter turn r. The incomplete 1x1x4 block in the top left 1x1x4 slot will be our choice because notice its colors: green and yellow. Now look back at the complete 1x1x4 block we have formed. By doing r, we will solve it back completely. At the same time, if the 1x1x3 portion of the 1x1x4 block in the top left 1x1x4 slot is place UNDER our complete 1x1x4 block prior to adding the quarter turn, then we solve back more than half of slice r.

So how do we get this down to the bottom in the fewest number of moves?
We could very well do l2 D2

(It's really hard to see the original formation of slice r before the set up moves r2 U2 were applied, but we have already seen that the logical quarter turn to do is r instead of r'. But no worries, because, if you ever make the quarter turn go in the opposite direction as it's supposed to, you can simply reverse it.)

[8] From here, we just add in ALOT of set up moves to position the dedges and centers.

a) First we add L' to get the completed dedge off of the top face, which has one of the two unsolved 1x2 center blocks because, if we here to do a slice turn through slice U right now, it would break up that dedge (not to mention break of the center block, which we DO NOT want to do!)L'
U r U2 r U2 r U2 r2 UL

b) Secondly, we add U to get the unsolved 1x2 center block in the top on the opposite side of the cube as the other one (which is in the back face).U L'
U r U2 r U2 r U2 r2 U
L U'

c) Thirdly, we add in l'. Sadly, I can only say that it was by painstaking work which helped me to see that this move was needed. (You can see soon why it helps).l' U L'
U r U2 r U2 r U2 r2 U
L U' l

e) Next, we add in U' to get the second paired dedge out of the M layer so that we can swap same color 1x2 center blocks with each other without breaking it up again. We choose U' over U because we are trying to form an adjacent double parity algorithm. What could be better than just to place it adjacently next to the other paired dedge?U' Rw' l' U L'
U r U2 r U2 r U2 r2 U
L U' l Rw U

[1] We can easily make a 4-cycle that discolors 4 1x(n-2) center blocks by:
a) Doing set up moves to bring one 1xn block onto the slice where the quarter turn will be executed.
b) Do the quarter turn
c) Reverse the set up moves.

Note that the turns of L do not need to be wide, but it helps us visualize.

The advantage to doing Lw F2 first is to have one of the 4 1x2 center blocks to not be discolored (the white 1x2 center block in the top is affected as well, for those who don't have a supercube handy).

[2] However, the white 1x2 center block in the back face on the right side belongs in the top right, as well as the pieces connected to it in the back bottom of slice r. Hence, we are tempted to do r' as to restore it

[3] Since it's a commutator, we know the number of inner layer quarter turns is now even again, and we will have to resume our usual routine of set up moves + quarter turn + reverse of set up.

Studying our commutator, notice that slice r is in "desperate need" of being moved away from us with move r, since the entire front half of slice r is connected.

Before we do this, however, take note of the 1x1x4 block in the top left 1x1x4 block slot. It is primarily yellow. We can put back a lot of pieces if we first do some set up moves to put that 1x1x4 block in the back of what is currently slice r so that, when we do the move r, it is brought to the bottom.

Taking out the outer layer turns of R, (IMPORTANT NOTE: We can do this because the moves that are wide were originally set up moves. As I have said earlier, they were never required, but it helps us visualize).
=r U2 r U2 r' r'
r' U2 r U2 r

and, even though you didn't ask for it, but here is an alg for another case, just modifying the first one:Rw' U R U r' U' R' U' x' U2 r' U2 r U2 l' U2 l Rw x (21, 17)This alg is two btm longer than the optimal (15), but its q moves are the same and is 2 qtm (plain quarter turn moves) less than the 15 btm I have previously posted in this thread.

To apply it to all size cubes in general, take note of the two moves in bold font.
l = all inner-layer slices to the left of the r slice(s) which you use to affect a particular orbit(s).
M' =
all inner-layer slices to the left of the r slice(s) which you use to affect a particular orbit(s).
+
the r slice(s) used to affect a particular orbit(s).

Instead of starting with r U2 r U2 r' = [r U2: r], if we break the U2s into two pieces, then we have a much better chance of creating an adjacent parity algorithm in fewer moves (maybe fewer quarter turns, half turns, or both, depending on what the odd permutation is). How do we do this? We need to place an outer-layer slice move between them.

[2] If you execute this on a 4x4x4 supercube, the 1x2 center block on the right side of the top face is one of the 4 1x2 center blocks unsolved. If we now add F', then we complete a 1x1x3 block.r U' R U' r U R' U r'
F'

[6] Now, if we conjugate with the move L', then we can get a 25q adjacent double parity. However, to squeeze out an extra quarter turn, it would be ideal if we could somehow merge the conjugate with the r (the first turn of the algorithm). To start out, let's convert r to a wide turn. Note that we must invert the extra R with R'.
Rw U' R U' r U R' U r'
F'
r' U2 r
D2 r D2 r'
U2 F
R'

Premium Member

I was shocked today that 16 btm isn't the optimal move count for one of the K4LL 2-cycle cases! However, the algorithm only can be translated to even cubes, and based on where the interior conjugate must be added, it's 17 btm on all other even cube sizes. It's definitely not transferable to odd cubes (just try to convert the algorithm pieces to the 5x5x5 in steps 1-3 in the derivation and you'll see why). Hence, this algorithm is only 15 btm on the 4x4x4 and works on larger even cubes but at a higher move count.

History
I highly doubt an algorithm of this length (in btm) has been achieved before for this case. As I have mentioned already, I was shocked myself. I didn't know my wide turn method could actually beat conventional methods in btm for a case like this!

General formula for even cubes.
The algorithm above is a good representation. Just note that the bold move indicates moving all inner right slices and the parenthesized move means moving all inner layer right slices down which contain wings that DO NOT need to be affected.

Oh, and the entire outline of this algorithm on the 6x6x6 (and all even cubes >= the 6x6x6) is:

As you can see, the interior conjugate in this algorithm, unlike the "Holy Grail" Alg, is not around the quarter turn. Rather, it is nested into the original commutator. (Hence the commutator is no longer present for the general algorithm.)

Yeah, that does work well for btm. In this thread, I was just trying to get less q moves for cases, and the algorithms which are 16 btm that I added are 2q less than that combo. The reason I posted this one is because it has even less btm than even that good combo you mentioned.

You're welcome! I can do that! Now, did you just mean the algorithms that I considered significant enough to represent all others in their respective categories (for example, best move count in any of the 4 metrics, move set, etc.), or all algorithms I have posted everywhere on speedsolving? Also, did you want me to give other algorithms not posted on speedsolving? Do you want me to put the derivations for each or just the algorithm? When you say, "standard notation," do you mean WCA? If so, and you do want translations to cube sizes >= the 6x6x6, with the randomness of some of the algorithms, wouldn't it be better to use SiGN? However, if you meant for me to use WCA for all algorithm translations regardless, I can do that.

About Speedsolving.com

SpeedSolving.com is a community focused on speed-solving puzzles, particularly the Rubik’s cube and alike. Created in 2006, the speedcubing community has grown from just a few to over 35,000 people that make up the community today. Competitions and unofficial meetups are organized all over the world on a weekly basis. The forum now has well over 1,200,000 posts and growing.