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

Discussion in 'Puzzle Theory' started by Christopher Mowla, Aug 2, 2010.

Welcome to the Speedsolving.com. You are currently viewing our boards as a guest which gives you limited access to join discussions and access our other features. By joining our free community of over 30,000 people, you will have access to post topics, communicate privately with other members (PM), respond to polls, upload content and access many other special features. Registration is fast, simple and absolutely free so please, join our community today!

If you have any problems with the registration process or your account login, please contact us and we'll help you get started. We look forward to seeing you on the forums!

Already a member? Login to stop seeing this message.
  1. Christopher Mowla

    Christopher Mowla Premium Member

    828
    2
    Sep 17, 2009
    New Orleans, LA
    YouTube:
    4EverTrying
    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.

    The Standard Algorithm
    r2 B2 U2 l U2 r' U2 r U2 F2 r F2 l' B2 r2

    Derivation
    Part I
    Part II

    Lucasparity
    r U2 r U2 r' U2 r U2 l' U2 l x U2 r' U2 x' r' U2 r'

    Derivation
    Part I
    Part II

    Another algorithm which consists of all U2 face turns
    r U2 r U2 r' U2 r U2 l' U2 r U2 r' U2 l r2 U2 r'

    Derivation
    Part I
    Part II

    Please watch the videos before reading this spoiler:
    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).

    The Holy Grail

    From now on, I will abbreviate BQTM with just q, and BHTM with h.
    (Also note that BHTM is commonly called btm. So h = BHTM = btm).

    On the 4X4X4: 19q/18h
    z d' m D l' u' 2R' u l u' l'2 b' 2R' b r' R' 2U y' m' u x2 z'

    On the 5X5X5: 19q/18h
    z d' 3m D 3l' u' 2R' u 3l u' 3l'2 b' 2R' b r' R' 2-3u y' 3m' u x2 z'

    On the inner-orbit of the 6X6X6: 20q/19h
    z 3d' 4m D 3l' 3u' 3R' 3u 3l 3u' 3l'2 2R' 3b' 3R' 3b 3r' R' 2-3u y' 4m' 3u x2 z'

    On the outer-orbit of the 6X6X6: 19q/19h
    z 3d' 4m D 3l' 3u' 2R' 3u 3l 3u' 3l'2 3R' 3b' 2R' 3b 3r' R' 2-3u y' 4m' 3u x2 z'
    =
    z 3d' 4m D 3l' 3u' 2R' 3u 3l 3u' 4l 3l 3b' 2R' 3b 3r' R' 2-3u y' 4m' 3u x2 z'

    On the inner-orbit of the 7X7X7: 20q/19h
    3d' 5m D 4l' 3u' 3R' 3u 4l 3u' 4l'2 2R' 3b' 3R' 3b 3r' R' 2-4u y' 5m' 3u x2 z'

    On the outer-orbit of the 7X7X7: 19q/19h
    z 3d' 5m D 4l' 3u' 2R' 3u 4l 3u' 4l'2 3R' 3b' 2R' 3b 3r' R' 2-4u y' 5m' 3u x2 z'
    =
    z 3d' 5m D 4l' 3u' 2R' 3u 4l 3u' 5l 4l 3b' 2R' 3b 3r' R' 2-4u y' 5m' 3u x2 z'

    I point out in the latter portion in the video that its average between quarter and half turns is also less than all other algorithms which currently exist.

    Here is a link to the following formula in Wolfram|Alpha (the simplified formula shown near the end of the video)

    $$\frac{\left\lfloor \frac{n}{2} \right\rfloor }{2-2^{\left\lfloor \frac{n}{2} \right\rfloor }}+19.5$$

    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][​IMG][/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.
    [​IMG]
    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).

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




    The Third Portion

    [​IMG]

    This represents all other cases:
    [​IMG][​IMG] [​IMG][​IMG], 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, [​IMG] ,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:

    $$\left( \begin{matrix}
    N \\
    N \\
    \end{matrix} \right)+\left( \begin{matrix}
    N \\
    N-1 \\
    \end{matrix} \right)+\left( \begin{matrix}
    N \\
    N-2 \\
    \end{matrix} \right)+\cdot \cdot \cdot +\left( \begin{matrix}
    N \\
    N-\left( N-1 \right) \\
    \end{matrix} \right)$$

    $$=\left( \begin{matrix}
    N \\
    N \\
    \end{matrix} \right)+\left( \begin{matrix}
    N \\
    N-1 \\
    \end{matrix} \right)+\left( \begin{matrix}
    N \\
    N-2 \\
    \end{matrix} \right)+\cdot \cdot \cdot +\left( \begin{matrix}
    N \\
    1 \\
    \end{matrix} \right)$$

    $$=\sum\limits_{k=0}^{N-1}{\left( \begin{matrix}
    N \\
    N-k \\
    \end{matrix} \right)}$$ $$=\sum\limits_{k=0}^{\left\lfloor \frac{n-2}{2} \right\rfloor -1}{\left( \begin{matrix}
    \left\lfloor \frac{n-2}{2} \right\rfloor \\
    \left\lfloor \frac{n-2}{2} \right\rfloor -k \\
    \end{matrix} \right)}$$

    For example, the 10X10X10 has 4 inner-layer orbits.

    $$\left( \begin{matrix}
    N \\
    N \\
    \end{matrix} \right)$$ or $$\left( \begin{matrix}
    4\\
    4 \\
    \end{matrix} \right)$$ represents the case
    [​IMG]
    because we have 4 orbits taking all 4 at once.


    $$\left( \begin{matrix}
    N \\
    N-1 \\
    \end{matrix} \right)$$ or $$\left( \begin{matrix}
    4\\
    3\\
    \end{matrix} \right)$$ represents the cases:
    [​IMG][​IMG][​IMG] , etc.
    because we have 4 orbits taking 3 at once.



    $$\left( \begin{matrix}
    N \\
    N-2 \\
    \end{matrix} \right)$$ or $$\left( \begin{matrix}
    4 \\
    2 \\
    \end{matrix} \right)$$ represents the cases:
    [​IMG][​IMG][​IMG],etc.
    because we have 4 orbits taking 2 at once.

    and finally,


    $$\left( \begin{matrix}
    N \\
    N-3 \\
    \end{matrix} \right)=\left( \begin{matrix}
    N \\
    N-\left( N-1 \right) \\
    \end{matrix} \right)=\left( \begin{matrix}
    4 \\
    4-\left( 4-1 \right) \\
    \end{matrix} \right)=\left( \begin{matrix}
    4 \\
    1 \\
    \end{matrix} \right)$$ represents the cases
    [​IMG][​IMG][​IMG],etc.
    because we have 4 orbits, taking only one at a time.​



    Now, note that this series can majorly simplify:

    [​IMG]


    PROOF
    [​IMG]
    So our formula simplifies to:
    [​IMG]
    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.

    $$\underset{n\to \infty }{\mathop{\lim }}\,\frac{\frac{n}{2}}{2-2^{\frac{n}{2}}}+19.5=19.5$$

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

    My 23q/16h "cmowlaparity" obviously has an average of 19.5, but the Holy Grail beats it slightly.
    x' r2 U2 l' U2 r U2 l x U2 x' U r U' F2 U r' U r2 x
     
    Last edited: Jun 9, 2011
  2. salamee

    salamee Member

    28
    0
    Jun 3, 2010
    Germany
    WCA:
    2010HAAS01
    Thanks for making those, now I finally understand how the Parity Algorithm works. It always bothered me to apply it blindly but not to know what it actually does.
     
  3. Christopher Mowla

    Christopher Mowla Premium Member

    828
    2
    Sep 17, 2009
    New Orleans, LA
    YouTube:
    4EverTrying
    Techniques for Symmetrical 2-Cycle and DP Algorithms in the Conventional Move Set

    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.;)

    __________________________________
    1) The commutator U2 l U2 r' U2 r U2 l'.
    In commutator notation, [U2, l U2 r']. This algorithm is useful because it swaps 3 1X3 blocks (for big cube sizes in general, 3 1X(N-1) blocks) within M and it's optimal for the move set <U2, F2, D2, B2, l, l', l2, r, r', r2>.

    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 moves can 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).

    An algorithm with all U2 rotations for the case:
    [​IMG]
    r' U2 r' U2 (r' l) U2 r' U2 r U2 l' U2 r2 (14)
    or speed-form:
    Rw' U2 Rw' U2 x' U2 Rw' U2 Rw U2 Lw' U2 Rw2 (12)
    (For odd cubes, include the M slice in the first and last half turn moves.)
    1) Start with the commutator:
    U2 l U2 r' U2 r U2 l'

    2) Add set-up moves to move all 3 1X(N-1) blocks into the same (right) slice.
    U2
    r'
    U2 l U2 r' U2 r U2 l'
    r
    U2


    3) Add the quarter turn (it's really trivial)
    U2
    r'
    U2 l U2 r' U2 r U2 l'
    r
    U2
    r


    4) Add one set-up move to position the two oppositely swapped edges on the opposite side of the cube from one of the center blocks:

    U2
    U2
    r'
    U2 l U2 r' U2 r U2 l'
    r
    U2
    r
    U2


    5) Finish off with an obvious set-up move:
    r'
    U2
    U2
    r'
    U2 l U2 r' U2 r U2 l'
    r
    U2
    r
    U2
    r

    In condensed notation:
    (r' U2)
    (U2 r')
    [U2, l U2 r']
    (r U2)
    r
    (U2 r)

    =r2 U2 l U2 r' U2 r U2 (l' r) U2 r U2 r

    6) Inverse
    r' U2 r' U2 (r' l) U2 r' U2 r U2 l' U2 r2


    An algorithm with all U2 rotations for the case:
    [​IMG]
    r U2 r' U2 r' U2 l U2 r' U2 r U2 (l' r) U2 r2 U2 r' (18)
    1) Start with the commutator:
    U2 l U2 r' U2 r U2 l'

    2) Add set-up moves to move all 3 1X(N-1) blocks into the same (right) slice.
    U2
    r'
    U2 l U2 r' U2 r U2 l'
    r
    U2


    3) Add the quarter turn (it's really trivial)
    U2
    r'
    U2 l U2 r' U2 r U2 l'
    r
    U2
    r


    4) Add set-up moves to have two 1X(N-1) blocks in the following manner:
    U2
    r'
    U2
    r'
    U2 l U2 r' U2 r U2 l'
    r
    U2
    r
    r
    U2


    5) Apply the last set-up move to make a pure algorithm:
    r
    U2
    r'
    U2
    r'
    U2 l U2 r' U2 r U2 l'
    r
    U2
    r
    r
    U2
    r'

    In condensed notation,
    (r U2 r')
    (U2 r')
    [U2, l U2 r']
    (r U2)
    r
    (r U2 r')

    =r U2 r' U2 r' U2 l U2 r' U2 r U2 (l' r) U2 r2 U2 r'
    __________________________________
    Finding Algorithms By Hand Fast and Easy: Shifting

    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.

    For example, one shift of the base for the algorithm last derived is:
    U2
    U2
    r'
    U2 l U2 r' U2 r U2 l'
    r
    U2
    r
    U2
    =
    r'
    U2 l U2 r' U2 r U2 l'
    r
    U2
    r U2

    Which has the same effect if we move the U2 to the end.

    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.

    For example, taking the previous algorithm and shifting until the l move is the first one:
    l U2 r' U2 r U2 l'
    r
    U2
    r
    U2 r' U2


    If we now shift the l move, there is no effect on the cube.
    U2 r' U2 r U2 l'
    r
    U2
    r
    U2 r' U2 l


    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.

    [​IMG]
    r U2 r U2 F2 r F2 l' U2 l U2 r2 (12)
    1) Starting with Lucasparity's base (from the my derivation video):
    F2
    l'
    U2
    U2 l U2 r' U2 r U2 l'
    U2
    l
    F2
    r'
    =F2 U2 r' U2 r U2 l' U2 l F2 r'

    2) Shifting the first 4 (half turn) moves,
    r U2 l' U2 l F2 r'
    F2 U2 r' U2

    3) Adding a set-up move:
    r
    r U2 l' U2 l F2 r'
    F2 U2 r' U2
    r'
    =r2 U2 l' U2 l F2 r' F2 U2 r' U2 r'

    4) Taking the inverse:
    r U2 r U2 F2 r F2 l' U2 l U2 r2

    Algorithm with all U2s for opposite wing edge swap (revisited?):
    I recommend you watch the my video on the pure edge flip algorithm that consists of all U2 face rotations.
    [​IMG]
    r U2 r U2 (l' r) U2 r U2 r' U2 l U2 r2 (14)
    or speed form:
    Rw U2 Rw U2 x U2 Rw U2 Rw' U2 Lw U2 Rw2 (12)
    On odd cubes, include the M slice in the first and last half turn moves.
    1) Start with the commutator U2 l U2 r' U2 r U2 l'
    (In commutator notation, [U2, l U2 r'])

    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


    3) Apply U2 as a set-up move, indeed we can bring the third block above the other two into slice r.
    U2
    r'
    U2 l U2 r' U2 r U2 l'
    r
    U2


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

    U2
    r'
    U2 l U2 r' U2 r U2 l'
    r
    U2
    r


    5) Now we write on one line:
    U2 r' U2 l U2 r' U2 r U2 l' r U2 r

    6) Shift the first 6 (half turn) moves (meaning, "move" the first six moves from the beginning of the algorithm to the end):
    U2 r U2 l' r U2 r
    U2 r' U2 l U2 r'


    7) Apply the last set-up move:
    r
    U2 r U2 l' r U2 r
    U2 r' U2 l U2 r'
    r'
    =r U2 r U2 l' r U2 r U2 r' U2 l U2 r2

    Observation:
    This algorithm resembles the other algorithm I derived in this post:
    r' U2 r' U2 (r' l) U2 r' U2 r U2 l' U2 r2
    doesn't it?
    This is probably just a coincidence.

    Building from this, recall the diagonal edge swap case was almost identical to the opposite edge swap. Hence for the opposite edge swap algorithm derived in this spoiler, the corresponding diagonal algorithm is:
    r' U2 r U2 r U2 l' U2 r U2 r' U2 (l r') U2 r2 U2 r
    (Just inverting all slice turns in the previous diagonal edge swap algorithm).


    Double-Parity 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.

    1) Taking the standard pure edge flip algorithm:
    r2 B2 U2 l U2 r' U2 r U2 F2 r F2 l' B2 r2

    2) Removing set-up moves:
    U2 l U2 r' U2 r U2 F2 r F2 l'

    3) Shifting once:
    l U2 r' U2 r U2 F2 r F2 l'
    U2


    4) If we add in r2 now, this leaves just two 1X4 blocks (in general, 1XN blocks) unsolved in r.
    l U2 r' U2 r U2 F2 r F2 l'
    U2
    r2


    5) Now if we add set-up moves, we have a pure double-parity:
    l2 B2
    l U2 r' U2 r U2 F2 r F2 l'
    U2 r2
    B2 l2


    Don't like it in F? No problem. Let's just remove the set-up moves and shift twice more (with this r2 in the algorithm) to get a better set-up:
    r' U2 r U2 F2 r F2 l'
    U2 r2
    l U2


    6) Now we can add set-up moves to make it a pure algorithm:
    r2
    B2
    r' U2 r U2 F2 r F2 l'
    U2 r2
    l U2
    B2
    r2


    In summary: If you add a r2 (or l2, depending on the set-up) to a non-pure opposite wing edge swap shifted base of the form:
    l U2 r' U2 r U2 F2 r F2 l'
    U2


    , 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.
     
    Last edited: Aug 5, 2010
  4. riffz

    riffz Member

    2,068
    0
    Oct 3, 2008
    Toronto (Canada)
    WCA:
    2009HOLT01
    YouTube:
    riffz
    I just watched the derivation for the standard alg. Your visual aids were really helpful. Thanks.
     
  5. cmhardw

    cmhardw Premium Member

    4,089
    10
    Apr 5, 2006
    Atlanta, Georgia
    WCA:
    2003HARD01
    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
     
  6. Christopher Mowla

    Christopher Mowla Premium Member

    828
    2
    Sep 17, 2009
    New Orleans, LA
    YouTube:
    4EverTrying
    You're welcome. I was hoping those illustrations made sense for everyone.

    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.
     
  7. Christopher Mowla

    Christopher Mowla Premium Member

    828
    2
    Sep 17, 2009
    New Orleans, LA
    YouTube:
    4EverTrying
    cmowlaparity Derivation and K4 2-Cycle Algorithms

    [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).

    cmowlaparity
    x' Rw2 U2 Lw' U2 r U2 Rw U2 x' U r U' F2 U r' U Rw2 x (Even Cubes)
    x' Rw2 U2 (Lw' M') U2 r U2 Rw U2 x' U r U' F2 U r' U Rw2 x (Odd Cubes)

    And, of course, if the remaining single slice turns are converted to wide, we have the result of speed forms of OLL parity algorithms:
    x' Rw2 U2 Lw' U2 Rw U2 Rw U2 x' U Rw U' F2 U Rw' U Rw2 x (Even Cubes)
    x' Rw2 U2 (Lw' M') U2 Rw U2 Rw U2 x' U Rw U' F2 U Rw' U Rw2 x (Odd Cubes)

    Derivation
    Part 1
    Part 2

    For convenience, I also provide a typed derivation for it as well.
    [1] Start with the commutator to swap 3 1X(N-1) blocks in M.
    B2 U' r' U B2 U' r U
    To 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
    l

    This 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


    [4] Next, we add in the quarter turn to create the interior J-Perm.
    U2 l'
    B2 U' r' U B2 U' r U
    l U2
    r'


    [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.

    [6] Add the set-up moves r2 U2 to what we have to make a pure algorithm:
    r2 U2
    l U2 r'
    U2 l' B2 U' r' U B2 U' r U
    U2 r2
    =r2 U2 l U2 r' U2 l' B2 U' r' U B2 U' r U U2 r2
    =r2 U2 l U2 r' U2 l' B2 U' r' U B2 U' r U' r2 (see back bottom edge)

    [7] Rotating about y2,
    l2 U2 r U2 l' U2 r' F2 U' l' U F2 U' l U' l2

    [8] Taking the mirror,
    r2 U2 l' U2 r U2 l F2 U r U' F2 U r' U r2

    [9] Adding in a preliminary x cube rotation,
    x' r2 U2 l' U2 r U2 l F2 U r U' F2 U r' U r2 x

    [10] Converting maximum moves to wide without affecting its purity, (done by experimentation)
    x' Rw2 U2 Lw' U2 r U2 Lw F2 U r U' F2 U r' U Rw2 x

    [11] Adding in an interior x cube rotation for easier execution,
    x' Rw2 U2 Lw' U2 r U2 Lw x U2 x' U r U' F2 U r' U Rw2 x

    [12] Converting (Lw x) to Rw,
    x' Rw2 U2 Lw' U2 r U2 Rw U2 x' U r U' F2 U r' U Rw2 x

    DONE

    Note: For odd cubes, either the second or third wide turn must include the M slice. For example, on the 5X5X5, this algorithm could either be:
    x' Rw2 U2 (Lw' M') U2 r U2 Rw U2 x' U r U' F2 U r' U Rw2 x
    or
    x' Rw2 U2 Lw' U2 r U2 (Rw M') U2 x' U r U' F2 U r' U Rw2 x

    K4 Method 2-Cycle Parity Algorithms

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

    Case 1:
    [​IMG]
    l'2 U Lw U2 r' U2 Rw' U2 x U' r' U x' U2 x U' (l' r) l' (21q/15h)
    Derivation
    [1] Start with cmowlaparity's base:
    l U2 r'
    U2 l' B2 U' r' U B2 U' r U


    [2] Move the last move to the front of the algorithm (shift backwards once),
    U
    l U2 r'
    U2 l' B2 U' r' U B2 U' r


    [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


    [4] By experimentation, some moves can be converted to wide turns and not affecting the purity of the algorithm.
    l'2
    U Lw U2 r' U2 Lw' B2 U' r' U B2 U' r
    l'2

    [5] Now, adding in an internal cube rotation for easier execution,
    l'2 U Lw U2 r' U2 Lw' x' U2 x U' r' U B2 U' r l'2

    [6] Merging the (Lw' x') to Rw',
    =l'2 U Lw U2 r' U2 Rw' U2 x U' r' U B2 U' r l'2

    [7] Adding in another internal cube rotation,
    l'2 U Lw U2 r' U2 Rw' U2 x U' r' U x' U2 x U' r l'2

    [8] And this can be rewritten as:
    l'2 U Lw U2 r' U2 Rw' U2 x U' r' U x' U2 x U' (l' r) l'

    DONE.

    Case 2:
    [​IMG]
    l'2 U' Lw U2 r' U2 Rw' U2 x U r' U' x' U2 x U (l' r) l' (21q/15h)
    Note: The set-up move l'2 can be made wide turns for this case.

    Derivation
    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.;)

    Case 3:
    [​IMG]
    l' r' U Lw U2 r' U2 Rw' U2 x U' r' U x' U2 x U' (r' l) r' (21q/16h)

    Derivation
    Building off of the algorithm for case 1, if we just omit the outer set-up moves l'2, then we have again:
    U Lw U2 r' U2 Rw' U2 x U' r' U x' U2 x U' r

    Instead of swapping the two 1X(N-2) center blocks in the front face with the set-up move l'2, we can instead swap the two center blocks in the top face, doing the set-up moves l' r':

    l' r'
    U Lw U2 r' U2 Rw' U2 x U' r' U x' U2 x U' r
    r l


    This can be rewritten as:
    l' r' U Lw U2 r' U2 Rw' U2 x U' r' U x' U2 x U' (l r') r'

    DONE

    NOTE:
    The reflection for this case is needed to handle a "4th" case:
    [​IMG]
    r l U' Rw' U2 l U2 Lw U2 x U l U' x' U2 x U (r' l) l (21q/16h)

    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.

    Case 1:
    [​IMG]
    F2 U Lw2 U2 l' U2 r U2 l' F2 U r U' F2 U r' U Lw2 U' F2 (29q/20h)
    Derivation
    [1] If we start with the single slice version of cmowlaparity,
    x' r2 U2 l' U2 r U2 l x U2 x' U r U' F2 U r' U r2 x

    [2] We invert the l move (in bold)
    x' r2 U2 l' U2 r U2 l' x U2 x' U r U' F2 U r' U r2 x

    [3] Add the set-up moves:

    x' D2 F
    x' r2 U2 l' U2 r U2 l' x U2 x' U r U' F2 U r' U r2 x
    F' D2 x


    [4] Optimizing
    =
    x2
    B2 D
    r2 U2 l' U2 r U2 l' x U2 x' U r U' F2 U r' U r2
    D' B2
    x2

    =
    F2 U
    x2
    r2 U2 l' U2 r U2 l' x U2 x' U r U' F2 U r' U r2
    x2
    U' F2

    The first and last r2 moves can be converted to wide in cmowlaparity, and it is still pure. It turns out that the same is true here, even with the adjustments we made to make what we have so far.:D

    F2 U
    x2
    Rw2 U2 l' U2 r U2 l' x U2 x' U r U' F2 U r' U Rw2
    x2
    U' F2

    Thus we can get rid of the x2 cube rotations
    Since (x2 Rw2)=Lw2

    F2 U
    Lw2 U2 l' U2 r U2 l' x U2 x' U r U' F2 U r' U Lw2
    U' F2

    Writing on one line,
    F2 U Lw2 U2 l' U2 r U2 l' x U2 x' U r U' F2 U r' U Lw2 U' F2

    The x cube rotation can be taken out if we like:
    F2 U Lw2 U2 l' U2 r U2 l' F2 U r U' F2 U r' U Lw2 U' F2 (29q/20h)

    DONE
    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.:)

    Case 2:
    [​IMG]
    b2 D' l'2 U l U2 r' U2 l B2 U' r' U B2 U' r l'2 D b2 (27q/19h)
    Derivation
    [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


    [2] Now, adding the set-up moves:
    b2 D'
    l'2 U l U2 r' U2 l B2 U' r' U B2 U' r l'2
    D b2

    [3] Writing on one line,
    b2 D' l'2 U l U2 r' U2 l B2 U' r' U B2 U' r l'2 D b2

    DONE
    You can optimize it anyway you like. I have no particular suggestions.

    Case 3:
    [​IMG]
    f2 D l2 U' l U2 r' U2 l B2 U r' U' B2 U r l2 D' f2 (27q/19h)
    Derivation
    [1] If we now apply the same idea to "case 2" of the 2-cycle algorithms, that is, inverting the same l move, we have:
    l2 U' l U2 r' U2 l B2 U r' U' B2 U r l2


    [2] Add the set-up moves:
    f2 D
    l2 U' l U2 r' U2 l B2 U r' U' B2 U r l2
    D' f2

    [3] Writing one one line,
    f2 D l2 U' l U2 r' U2 l B2 U r' U' B2 U r l2 D' f2

    DONE
    You can optimize it anyway you like. I have no particular suggestions.
     
  8. reThinking the Cube

    reThinking the Cube Member

    294
    0
    Dec 11, 2009
    Very, very, nice work. Processing..........
     
  9. Kirjava

    Kirjava Colourful

    6,129
    3
    Mar 26, 2006
    WCA:
    2006BARL01
    YouTube:
    snkenjoi
    This is amazing.
     
  10. Christopher Mowla

    Christopher Mowla Premium Member

    828
    2
    Sep 17, 2009
    New Orleans, LA
    YouTube:
    4EverTrying
    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.

    Beginner
    Part 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.

    Intermediate
    Part 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.



    Advanced
    Part 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.
    My favorite 23q
    On even cubes:
    Rw U L F' U l' Dw Uw Rw2 Dw' l' Dw Rw2 Dw' l Uw' U' F L' U' Rw'
    =
    Rw U L F' U
    (l')
    Uw Dw
    Rw2 Dw' l' Dw Rw2 Dw' l Dw
    Dw' Uw'
    U' F L' U' Rw'


    For odd cubes, just include the central slice for all of the bold moves above. That is,
    3r U L F' U 2L' 2d 2u 3r2 2d' 2L' 2d 3r2 2d' 2L 2u' U' F L' U' 3r'

    Notes about the algorithm

    • Like the HG algorithm, this algorithm makes a cross about the front center face (on a supercube).
    • It uses the commutator Rw2 Dw' l' Dw Rw2 Dw' l Dw to make the "slidden j-perm" and the set-up moves Rw U L F' U to make an edge flip from that "slidden j-perm".
    My favorite 22q

    On even cubes:
    y Lw' Uw2 x' D' U' l' Uw Dw Rw2 Dw' l' Dw Rw2 Dw' l U d' Rw2 Bw z2
    =
    r' d2 F' B'
    x'
    (l')
    Uw Dw
    Rw2 Dw' l' Dw Rw2 Dw' l Dw
    Dw' Uw'
    x
    B F d2 r


    For odd cubes, just include the central slice for all of the bold moves above. That is
    y 3l' 3u2 x' D' U' 2L' 2u 2d 3r2 2d' 2L' 2d 3r2 2d' 2L U 2-3d' 2r2 2b z2

    Note
    Also, @Cride5, looking at the algorithm above, take note of the last portion (where the move cancellation occurred (shown in brackets below).
    y Lw' Uw2 x' D' U' l' Uw Dw Rw2 Dw' l' Dw Rw2 Dw' l [U d'] Rw2 Bw z2
    This algorithm demonstrates ATM (Axial Turn Metric), from your thread.

    Notes about the algorithm

    • This algorithm swaps all same-color center pieces within the top face in a different fashion than standard speedsolving algorithms.
    • It uses the same commutator as the previous algorithm, but it uses the set-up moves Lw' Uw2 x' D' U' to make the "slidden j-perm" an edge flip algorithm. Hence, the move cancellation from 23q to 22q.
    A Neat 23q
    Take note of the portion in brackets.

    On Odd cubes:
    z x 3r 3u2 x' 4u U y' 2R' 2u 2d 3l'2 2u' 2R' 2u 3l'2 2u' 2R [4u' 3u' U'] x' 3u2 2r' z

    =
    2D 2L'2 4b B
    y2 x'
    (2L')
    2d 2u
    3r2 2d' 2L' 2d 3r2 2d' 2L 2d
    2d' 2u'
    x y2
    B' 4b' 2L'2 2D'


    For even cubes, the bold moves above contain one less layer on the inside than its odd cube counter-part (e.g. 7x7x7 vs 6x6x6, 5x5x5 vs 4x4x4, etc.).

    For example, on the 4x4x4: (watch the applet execute the bracketed portion!)
    z x 2r 2u2 x' 3u U y' 2R' 2u 2d 2l'2 2u' 2R' 2u 2l'2 2u' 2R [3u' 2u' U'] x' 2u2 2r' z

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

    Even Cubes:
    2r' 2L' 2u 2r' 2u' 2L 2u y 2l 2d 2R' 2d' 2l' y' 2r 2u' 2r
    Odd cubes:
    3r' 2L' 3u 2r' 3u' 2L 3u y 3l 2d 2R' 2d' 3l' y' 2r 3u' 3r

    Derivation

    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:

    My favorite 12h Algorithm:
    On Even Cubes:
    x' 2r2 3d 2R U' L'2 U 2R' 3d 2R U2 F2 2r2 x y2

    On Odd Cubes:
    x' 2r2 4d 2R U' L'2 U 2R' 4d 2R U2 F2 3r2 x y2

    Derivation
    [1] Start off with a commutator to cycle three wings:
    U' F2 U 2B U' F2 U 2B'

    [2]Add one set-up move to bring all wings into the 2R slice:
    U'
    U' F2 U 2B U' F2 U 2B'
    U

    [3] Add quarter turn
    U'
    U' F2 U 2B U' F2 U 2B'
    U
    (2R)

    [4] Shift:
    U 2B U' F2 U 2B'
    U
    (2R)
    U' U' F2

    [5] Add one set-up move:
    2R2
    U 2B U' F2 U 2B'
    U
    (2R)
    U' U' F2
    2R2

    [6] Merging the U' U' as U2, converting the outer-most set-up move to wide (for easier execution), and inserting y cube rotations,
    2r2
    U y'
    2R U' L'2 U 2R'
    U y' (2R)
    U2 F2
    3r2

    [7] Merge the two U y' as 4d,
    2r2
    4d
    2R U' L'2 U 2R'
    4d (2R)
    U2 F2
    3r2

    [8] Finally, adding cube rotations:
    x'
    2r2
    4d
    2R U' L'2 U 2R'
    4d (2R)
    U2 F2
    3r2
    x y2

    Note that we can make a 12h double parity algorithm by inverting the quarter turn.
    On Even Cubes:
    x' 2r2 3d 2R U' L'2 U 2R' 3d 2R' U2 F2 2r2 x y2
    On Odd Cubes:
    x' 2r2 4d 2R U' L'2 U 2R' 4d 2R' U2 F2 3r2 x y2
    If you don't know why we can do this, see the end of my second post in this thread on "Double Parity".

    Optimal Edge Flip Algorithms that Discolor the Centers & Scramble the Outer Layers
    (Not useful for anything except cube theory).


    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.

    On Even Cubes:
    x' 2r2 3d 2R U' L'2 U 2R' 3d 2R F2 2r2 x y2

    On Odd Cubes:
    x' 2r2 4d 2R U' L'2 U 2R' 4d 2R F2 3r2 x y2

    We can achieve a 15q/11h doubleparity by inverting the extra quarter turn, as we did before.

    Possible Optimal Algorithm for the Single Edge Flip 4-cycle (Double-Parity): 13q/11h
    (Performed the same on both odd and even cubes)

    2L' B' 2U B' D2 B 2U' B' 2L D2 2L'

    Derivation
    [1] Start out with the commutator:
    B 2U B' D2 B 2U' B' D2
    [2] Add set-up moves to bring all pieces into the 2L slice:
    B2
    B 2U B' D2 B 2U' B' D2
    B2

    [3] Add a quarter turn:
    B2
    B 2U B' D2 B 2U' B' D2
    B2
    (2L')

    [4] Shift backwards:
    B2
    (2L')
    B2
    B 2U B' D2 B 2U' B' D2

    [5] Add the following piece to make a non-symmetrical double-parity algorithm
    B2
    (2L')
    B2
    B 2U B' D2 B 2U' B' D2
    D2 2L D2 2L'

    [6] Cancel moves:
    B2 (2L') B' 2U B' D2 B 2U' B' 2L D2 2L'
    [7] Delete the first half turn move, as we don't need it for inner-layer manipulation:
    2L' B' 2U B' D2 B 2U' B' 2L D2 2L'
    A 21q Algorithm Which Permutes the Centers like Common Algorithms
    (Even Cubes Only)
    If we take the 15q algorithm we had before:
    2r' 2L' 2u 2r' 2u' 2L 2u y 2l 2d 2R' 2d' 2l' y' 2r 2u' 2r
    and add set-up moves to it, we have it:

    2b' R' 2U
    2r' 2L' 2u 2r' 2u' 2L 2u y 2l 2d 2R' 2d' 2l' y' 2r 2u' 2r
    2U' R 2b
    =
    2b' R' 2U 2r' 2L' 2u 2r' 2u' 2L 2u y 2l 2d 2R' 2d' 2l' y' 2r 2u' 2r 2U' R 2b

    To translate to other even cube sizes besides the 4x4x4, keep all of the moves which are not bold the same proportion. The bold moves indicate which orbits need to be affected.

    For example, on the inner orbit of the 6x6x6,
    3b' R' 2-3u 3r' 2L' 3u 3r' 3u' 2L 3u y 3l 3d 2R' 3d' 3l' y' 3r 3u' 3r 2-3u' R 3b

    Here is a “3-gen”/4-gen algorithm which does not touch the front-bottom-left (n/2)x(n/2)x(n/2) block:

    2b' R' 2U 2r' 2R' 2u 2b' 2u' 2R 2u 2r 2b 2R' 2b' 2r' 2b 2u' 2r 2U' R 2b

    Comparing it to the previous 21q, they are nearly the same, but this path allows using less slices.

    Just as with translating the other algorithm to higher order even cubes, the bold moves are the orbit which needs to be affected, while the rest of the moves are kept proportional.

    For example, on the outer-orbit of the 6x6x6,
    3b' R' 2-3u 3r' 2R' 3u 3b' 3u' 2R 3u 3r 3b 2R' 3b' 3r' 3b 3u' 3r 2-3u' R 3b

    Derivation
    (I am going to use WCA notation).

    Start with the commutator:
    Bw Uw' r' Uw Bw' Uw' r Uw

    Add set-up moves and quarter turn,
    Uw' Lw'
    Bw Uw' r' Uw Bw' Uw' r Uw
    Lw Uw
    r'

    Shift:
    r' Uw Bw' Uw' r Uw
    Lw Uw
    r'
    Uw' Lw'
    Bw Uw'

    Add one set-up move to make 15q center discoloring algorithm,
    Rw'
    r' Uw Bw' Uw' r Uw
    Lw Uw
    r'
    Uw' Lw'
    Bw Uw'
    Rw

    Add set-up moves to not discolor the centers,
    Bw' R' u
    Rw'
    r' Uw Bw' Uw' r Uw
    Lw Uw
    r'
    Uw' Lw'
    Bw Uw'
    Rw
    u' R Bw
    =
    Bw' R' u Rw'
    r' Uw Bw' Uw' r Uw Lw Uw r' Uw' Lw' Bw Uw'
    Rw u' R Bw

    Since this algorithm only applies to even cubes completely, we can make a "3-gen"/5-gen in <B, R, U>,
    =
    Bw' R' u Rw'
    r' Uw Bw' Uw' r Uw (Rw x') Uw r' Uw' (Rw' x) Bw Uw'
    Rw u' R Bw

    =
    Bw' R' u Rw'
    r' Uw Bw' Uw' r Uw Rw Bw r' Bw' Rw' Bw Uw'
    Rw u' R Bw
    =
    Bw' R' u Rw' r' Uw Bw' Uw' r Uw Rw Bw r' Bw' Rw' Bw Uw' Rw u' R Bw
    (All we need to do is to covert to SiGN notation to achieve the algorithm we wished to derive).
    By: Christopher Mowla
    Date: February 5, 2011.
     
    Last edited: Feb 27, 2012
  11. Kirjava

    Kirjava Colourful

    6,129
    3
    Mar 26, 2006
    WCA:
    2006BARL01
    YouTube:
    snkenjoi
    I think this is faster; l2 U Lw U2 r' U2 Rw' U2 F r' F' U2 F r F2 l2

    Also, do you have an alternatives for l' r' U Lw U2 r' U2 Rw' U2 x U' r' U x' U2 x U' (r' l) r' ?

    That alg is hard to tweak for speed, the rest are fine.

    I got into learning 4x4x4 algs recently. Let me know if you find any adjacent 4cycles, too.
     
    Last edited by a moderator: Jan 8, 2012
  12. Christopher Mowla

    Christopher Mowla Premium Member

    828
    2
    Sep 17, 2009
    New Orleans, LA
    YouTube:
    4EverTrying
    Adjacent Double Parity Algorithms

    I know this is off topic from the main focus of this thread (2-cycles), but...
    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?).

    For example, Kirjava's algorithm of choice for opposite composite edge double parity is:
    r2 B2 r' U2 r' U2 B2 r' B2 r B2 r' B2 r2 B2 (15 btm)
    (This algorithm can be found on his ELL Page).

    To affect two adjacent edges, we merely need to memorize the opposite algorithm and then conjugate it (add setup moves) to make the left or right composite edge affected along with the front or back composite edge. For example,
    R B
    r2 B2 r' U2 r' U2 B2 r' B2 r B2 r' B2 r2 B2
    B' R'
    = R B r2 B2 r' U2 r' U2 B2 r' B2 r B2 r' B2 r2 B R' (18 btm)
    My Algorithms
    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).

    Algorithms which do not discolor the centers

    [1] 27q/20 btm Algorithm for all Big Cube Sizes:r2 F L F U2 l F2 D2 r D2 l' F r' F U2 F' r L' F' r2

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

    [2] 26-27q/19-20 btm Algorithm for all Big Cube Sizes, in general.
    = r2 F' R' F' U2 l F2 D2 r D2 l' F' r' F' U2 F Rw F r2 (19 btm)

    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.

    For example, on the inner orbit of wings for the 7x7x7, (click the link if you don't know SiGN Notation)
    3R2 F' R' F' U2 3L F2 D2 3R D2 3L' F' 3R' F' U2 F (R 3R) F 3R2

    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.

    Derivation
    1) Start with the commutator:
    F r' F' U2 F r F' U2

    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)


    3) Writing on one line,
    = F2 l' F r' F' U2 F r F' U2 l F2 r

    4) Add a piece to involve two more wings, but keep the same amount of centers (2) involved:
    F2 l' F r' F' U2 F r F' U2 l F2 r
    r' D2 r D2

    5) Add another piece (Don't worry, there will actually be a lot of move cancellations).
    F2 l' F r' F' U2 F r F' U2 l F2 r
    r' D2 r D2
    l' F2 l F2

    = F2 l' F r' F' U2 F r F' U2 l F2 r r' D2 r D2 l' F2 l F2

    6) Shift, (this shouldn't be new to anyone who has kept up with this thread)
    F' U2 l F2 r r' D2 r D2 l' F2 l F2
    F2 l' F r' F' U2 F 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.

    R'
    F' U2 l F2 r r' D2 r D2 l' F2 l F2 F2 l' F r' F' U2 F r
    R

    8) Add the remaining setup moves to make visually pure:
    r2 F'
    R'
    F' U2 l F2 r r' D2 r D2 l' F2 l F2 F2 l' F r' F' U2 F r
    R
    F r2

    9) Cancel/merge moves
    = r2 F' R' F' U2 l F2 D2 r D2 l' F' r' F' U2 F Rw F r2 (19 btm)

    *To apply to all size cubes, take note of the form presented previously in this post.

    For the 20 btm algorithm,
    7) Invert the F quarter turn moves (we in effect use the commutator F' r' F U2 F' r F U2 instead of F r' F' U2 F r F' U2). I used this trick before in this thread when I was deriving all of my K4 adjacent 2-cycle algorithms.
    F U2 l F2 r r' D2 r D2 l' F2 l F2
    F2 l' F' r' F U2 F' r

    8) Add the set-up moves to complete:
    r2 F L
    F U2 l F2 r r' D2 r D2 l' F2 l F2
    F2 l' F' r' F U2 F' r
    L' F' r2

    9) Cancel moves to get:
    r2 F L F U2 l F2 D2 r D2 l' F r' F U2 F' r L' F' r2 (20 btm)
    This algorithm is applied exactly like this to all big cubes.

    Non-Visually Pure (Causes Center Discoloration)
    Rw F' Rw' F' U2 F r F' U2 r F Rw r' F Rw' (17,15 on big cubes. 16,14 on the 4x4x4 and 5x5x5)
    On the 7x7x7,
    3r F' 3r' F' U2 F 3R F' U2 3R F 3r 3R' F 3r'

    Derivation
    Do steps 1-3 of the derivation for the visually pure algorithms above to start with::
    F2 l' F r' F' U2 F r F' U2 l F2 r

    4) Add the piece:
    F2 l' F r' F' U2 F r F' U2 l F2 r
    r' F2 r F2

    5) Shift, (again, this should be nothing new to those who have been keeping up with this thread).
    F' U2 F r F' U2 l F2 r
    r' F2 r F2
    F2 l' F r'

    6) Add the following 3 setup moves
    Lw D' Lw'
    F' U2 F r F' U2 l F2 r
    r' F2 r F2
    F2 l' F r'
    Lw D Lw'

    7) Cancel moves to have:
    Lw D' Lw' F' U2 F r F' U2 r F r' Lw D Lw'

    8) Merge the (r' Lw) as R x'
    Lw D' Lw' F' U2 F r F' U2 r F R x' D Lw' (14 btm)

    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'

    In addition, here is a 13 btm non-center preserving adjacent double parity algorithm which is faster.
    r2 U Rw' U R U r' U' R' U' Rw U' r2 = [r2 U Rw' U R U: r']
     
    Last edited: Feb 27, 2012
  13. Christopher Mowla

    Christopher Mowla Premium Member

    828
    2
    Sep 17, 2009
    New Orleans, LA
    YouTube:
    4EverTrying
    The Holy Grail of Edge Flip Algorithm's Base By Cube Explorer 5.00

    I have just found a 3x3x3 set-up for Cube Explorer to produce the "Holy Grail" base for the 4x4x4 cube.

    If you have watched Part II of my HG Alg Derivation series, you would see that the "Holy Grail" algorithm has the following structure.

    In WCA Notation

    Dw' M D Set-up
    Lw' Uw' r' Uw Lw Uw' Lw2 Bw' r' Bw (Lw' r) Lw' Uw Base
    D' M' Dw Reverse of Set-up

    Here is a screenshot of Cube Explorer
    [​IMG]
    The 3x3x3 set-up for Cube Explorer shown in the image above is F' U' B' U F2 U' F L' B' L F' B U F'.

    As you can see, clicking the green arrow, the optimal solution is
    U' F2 B' L' B L F2 U F' U' B U F (15q, 13 htm)

    To translate it properly to the 4x4x4, the moves are converted as follows:
    Uw' Fw2 b' Lw' b Lw Fw2 Uw Fw' Uw' b Uw Fw

    Rotate about y,
    Uw' Lw2 r' Bw' r Bw Lw2 Uw Lw' Uw' r Uw Lw

    Inverse
    Lw' Uw' r' Uw Lw Uw' Lw2 Bw' r' Bw r Lw2 Uw

    = Lw' Uw' r' Uw Lw Uw' Lw2 Bw' r' Bw (Lw' r) Lw' Uw *


    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:

    L' U' R' U' R U L' U' L U R' U' L' U L2 R

    When translated to the 4x4x4 correctly (and I couldn't get this to translate to any other cube size...except for higher order bandaged even cubes), it is the following:
    Lw' u' Rw' u' Rw u Lw' u' Lw u Rw' u' Lw' u Lw2 Rw

    Merging the last two wider turns as a x cube rotation and shifting that x cube rotation backwards (moving to the front of the algorithm,

    x Lw' u' Rw' u' Rw u Lw' u' Lw u Rw' u' Lw' u Lw'

    Now we have a set-up we can conjugate with two instead of three moves:
    Dw' M
    Lw' x u' Rw' u' Rw u Lw' u' Lw u Rw' u' Lw' u Lw'
    M' Dw


    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:

    F-D-F+U-D-R-U+R+D+F-D+F+L-U+L+
    =>
    Fw'
    M
    Fw' Dw' Fw u' Dw' Rw' u Rw Dw Fw' Dw Fw Lw' u Lw
    M'
    Fw


    and

    R-L-B+R+U-D-R-U+R+D+R-B-R+U+L+
    =>
    Fw'
    M
    Rw' Lw' Bw Rw u' Dw' Rw' u Rw Dw Rw' Bw' Rw u Lw
    M'
    Fw


    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.

    Discussion anyone?


    EDIT:
    cuBerBruce was kind enough to run Tomas Rokicki's solver for the HG base setup. From the results, we have a third algorithm:
    Rw Bw' r' Lw Dw' r Dw Lw' Bw Rw' Lw' Uw' r Uw Lw

    I said "third" but I actually forgot to show how the setup for Cube Explorer translates to the 4x4x4. First of all, it is better to execute if we rotate it about the y axis to: L' U' R' U L2 U' L B' R' B L' R U L'
    => Lw' Uw' r' Uw Lw2 Uw' Lw Bw' r' Bw Lw' r Uw Lw'.
     
    Last edited: Apr 13, 2011
  14. Christopher Mowla

    Christopher Mowla Premium Member

    828
    2
    Sep 17, 2009
    New Orleans, LA
    YouTube:
    4EverTrying
    Adjacent Double Parity Algorithms (Revisited)

    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
    L U' l Rw U Rw z


    = [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).

    i.e.,
    F U2 l F2 r r' D2 r D2 l' F2 l F2
    F2 l' F' r' F U2 F' r


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

    U2
    r U2 r' U2
    U2


    [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

    U2
    r U2 r' U2
    U2
    l2 D2


    but let's instead do r2 U2

    U2
    r U2 r' U2
    U2
    r2 U2


    [4] Now we can add the quarter turn, r.

    (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.)

    U2
    r U2 r' U2
    U2
    r2 U2
    r


    [5] Now undo r2 U2 with U2 r2
    U2
    r U2 r' U2
    U2
    r2 U2
    r
    U2 r2


    Because we were careful, the only two center blocks unsolved are the ones seen discolored. In addition, we have 4 wing edges now out of place.

    [6] With a little trial and error, it is best if we have the U face rotated +90 degrees. In order to do this, instead of applying a set up move U', we can just:

    a) Split the first move (U2) into U U
    U U
    r U2 r' U2
    U2
    r2 U2
    r
    U2 r2


    b) Shift one of them to the end of the algorithm.
    U
    r U2 r' U2
    U2
    r2 U2
    r
    U2 r2
    U


    [7] Let's simplify this base.
    = U r U2 r U2 r U2 r2 U

    [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 U
    L


    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


    d) Fourthly, we add in Rw' to pair up the second dedge.
    Rw' l' U L'
    U r U2 r U2 r U2 r2 U
    L U' l Rw


    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


    f) Second to last, we add in the obvious move, Rw', to swap same-color 1x2 center blocks with each other.
    Rw' U' Rw' l' U L'
    U r U2 r U2 r U2 r2 U
    L U' l Rw U Rw


    g) Lastly, the adjacent dedge swap ended up in slice L. Hence, let's do z' to move it in U.

    => [z' Rw' U' Rw' l' U L' :U r U2 r U2 r U2 r2 U]

    (Note: The Rw' turns need not be wide turns, but they don't hurt anything either.)

    DONE
    With a similar method, I have made adjacent 4-cycles for the other cases:

    Case 1
    [​IMG]
    Lw' U2 M'2 U' x r' U2 r' U2 r2 U2 r' U2 x' U M'2 U2 Lw

    = [Lw' U2 M'2 U' x: r' U2 r' U2 r2 U2 r' U2] (25q, 16 btm)

    Case 2
    [​IMG]
    Lw' U2 M'2 U x' l' U2 l' U2 l2 U2 l' U2 x U' M'2 U2 Lw

    = [Lw' U2 M'2 U x': l' U2 l' U2 l2 U2 l' U2] (25q, 16 btm)

    Just take their inverses to get the other two cases.
    Also, if anyone wants a derivation for those, let me know. But again, I did use the same general method as the derivation in this post.


    EDIT:
    Speaking of this method and 4-cycles,

    Here is a derivation of the famous beginner parity fix: r U2 r U2 r U2 r U2 r

    Derivation
    [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.

    Lw F2 (r) F2 Lw'

    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

    Lw F2 r F2 Lw' r'

    This is indeed a commutator: [Lw F2, r]

    [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.

    Hence, we add Lw' B2

    Lw F2 r F2 Lw' r'
    Lw' B2


    [4] Do the quarter turn, r and reverse the set up,

    Lw F2 r F2 Lw' r'
    Lw' B2 r B2 Lw

    we have it!

    [5] Modifying the algorithm now, on the 4x4x4, we can add x cube rotations to make all face turns U2.

    Lw x U2 r U2 Lw' r' x'
    Lw' x' U2 r U2 Lw x


    Grouping wide turns with x cube rotations,

    (Lw x) U2 r U2 (Lw' x') r'
    (Lw' x') U2 r U2 (Lw x)


    =
    Rw U2 r U2 Rw' r'
    Rw' U2 r U2 Rw


    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


    = r U2 r U2 r U2 r U2 r
    DONE

    So one of the closest "cousins" to the famous r U2 r U2 r U2 r U2 r is shockingly:

    Lw F2 D2 r D2 F2 Lw' r'
    Lw' U2 r U2 Lw

    Looking at this algorithm in a few steps,
    Lw F2 D2 r D2 F2 Lw'

    Is the same first step as the other algorithm, just we added in an extra set up move D2 to bring the green center block into slice r as well.

    The r' is the completion of the commutator [Lw F2 D2, r]

    and the last portion is set up moves + quarter turn
    Lw F2 D2 r D2 F2 Lw' r'
    Lw' U2 r U2 Lw


    =>
    (Lw x) U2 F2 r F2 U2 (Lw' x)' r'
    Lw' U2 r U2 Lw

    =
    Rw U2 F2 r F2 U2 Rw' r'
    Lw' U2 r U2 Lw

    Omitting the wide turns (because they were just set up moves involving the inner layers only),
    = r U2 F2 r F2 U2 r' r' l' U2 r U2 l
    = r U2 F2 r F2 U2 r2 l U2 r' U2 l'

    This algorithm is a 4-cycle (obviously) and it only affects two centers just like the previous algorithm. The front (green) face is now discolored because we involved it in the quarter turn with D2.

    Anyway, from this, we have a much more convenient algorithm to make a common visually pure 4-cycle case:
    Rw U2
    r U2 F2 r F2 U2 r2 l' U2 r U2 l
    (16)
    U2 Rw'

    It's definitely not optimal, but I just wanted to show you a slight modification of the original alg with justification.:)
     
    Last edited: Jun 8, 2011
  15. Christopher Mowla

    Christopher Mowla Premium Member

    828
    2
    Sep 17, 2009
    New Orleans, LA
    YouTube:
    4EverTrying
    x' r' U R U r' U' R' U' B2 r' B2 l U2 l' U2 r2 x (21, 16)

    At the cost of one extra quarter turn and half turn, this can be optimized to:
    x' r' U R U r' U' R' U' (Rw' l) U2 r' U2 Rw U2 l' U2 r2 x (22, 17)
    (To apply on odd cubes, include the central slice with the two bold moves.)

    Here's another algorithm for that case. It's longer, but it might be just as fast on the 4x4x4.
    x' r' U R U r' U' R' U' (l r') U2 r' U2 r U2 l' U2 r2 x (23, 19)

    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.

    Here's another algorithm for that case:
    Rw' U R U r' U' R' U' (Rw' l) U2 r' U2 r U2 l' U2 Rw2(22, 17)
     
    Last edited: Feb 29, 2012
  16. Christopher Mowla

    Christopher Mowla Premium Member

    828
    2
    Sep 17, 2009
    New Orleans, LA
    YouTube:
    4EverTrying
    Adjacent Double Parity (Revisited #2) AND Another 23q Visual Pure Dedge Flip Alg

    I have lowered it to 24q.

    [​IMG]

    Here's the algorithm on the 4x4x4, (24q, 20 btm)

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

    For example, on the inner orbit of the 6x6x6 (in SiGN Notation),
    x' 2-3l U' R U' 3R U R' U 3R' F' 3R' U2 3R D2 3R D2 3R' U2 F 2-4l' x

    Derivation
    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.

    Hence,
    [1] Let's start out instead with: r U' R U' r U R' U r' = [r U' R U': r].

    [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'


    [3] Add r' U2 r to restore the top center and pair up one of the 3 unpaired dedges.
    r U' R U' r U R' U r'
    F'
    r' U2 r


    [4] Add D2 r D2 r' to restore the last two centers and pair up the last two unpaired dedges.
    r U' R U' r U R' U r'
    F'
    r' U2 r
    D2 r D2 r'


    [5] Add U2 F to restore the cube as much as possible.
    r U' R U' r U R' U r'
    F'
    r' U2 r
    D2 r D2 r'
    U2 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'

    [7] Now we conjugate with L', and both the first two moves and last two will merge as one move each.
    L'
    Rw U' R U' r U R' U r'
    F'
    r' U2 r
    D2 r D2 r'
    U2 F
    R'
    L


    [8] Optimizing,
    a) Merging the moves and writing the algorithm on one line,
    l x U' R U' r U R' U r' F' r' U2 r D2 r D2 r' U2 F M' x'
    b) Conjugating with x2,
    l x' U' R U' r U R' U r' F' r' U2 r D2 r D2 r' U2 F M' x
    c) We can interchange the first two letters to have the exact form of the algorithm to be derived.
    x' l U' R U' r U R' U r' F' r' U2 r D2 r D2 r' U2 F M' x

    DONE

    Another 23q Visually Pure Single Dedge Flip algorithm.
    Rw2 F2 r' U2 r U2 F r U' R U' r U R' U r' F Rw2 (23, 18)

    Derivation
    From the same start (steps 1-3) as the previous algorithm,

    [1-3] We have:
    r U' R U' r U R' U r'
    F'
    r' U2 r

    [4] Restore the cube's outer layers by adding U2 F.
    r U' R U' r U R' U r'
    F'
    r' U2 r
    U2 F


    [5] Shift,
    r' U2 r
    U2 F
    r U' R U' r U R' U r'
    F'


    [6] Conjugate with Rw2 F2
    Rw2 F2
    r' U2 r
    U2 F
    r U' R U' r U R' U r'
    F'
    F2 Rw2

    [7] And F' F2 = F
    => Rw2 F2 r' U2 r U2 F r U' R U' r U R' U r' F Rw2

    DONE
    This algorithm is an interesting find because I could never before create a 23q single slice turn based algorithm other than using the commutator F' r' F U2 F' r F U2

    Lastly, note that I used a similar start to make the algorithms in my previous post. That is, using the idea of splitting U2s into two pieces by inserting R slices between them.
     
    Last edited: Jun 11, 2011
  17. Christopher Mowla

    Christopher Mowla Premium Member

    828
    2
    Sep 17, 2009
    New Orleans, LA
    YouTube:
    4EverTrying
    15 btm 2-cycle for the 4x4x4!

    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!

    Anyway, here's the algorithm translation for the 4x4x4.
    z' Fw' l' Uw2 r Uw' r' Uw2 Bw2 Uw' r' Uw Bw2 Uw l Fw z (19q, 15 btm)
    = [z' Fw' l' Uw': [Bw2 Uw': [Uw Bw2 Uw': [r, Uw'] ] r' ] ]

    Derivation
    1) Start with the commutator

    r Uw' r' Uw

    2) Conjugate to bring most affected pieces into slice r.

    Uw Bw2 Uw'
    r Uw' r' Uw
    Uw Bw2 Uw'


    3) Do the quarter turn r'.

    Uw Bw2 Uw'
    r Uw' r' Uw
    Uw Bw2 Uw'
    (r')


    4) Shift the first two half turns

    Uw'
    r Uw' r' Uw
    Uw Bw2 Uw'
    r'
    Uw Bw2


    5) Conjugate

    z' Fw' l' Uw'
    Uw'
    r Uw' r' Uw
    Uw Bw2 Uw'
    r'
    Uw Bw2
    Uw l Fw z


    6) Merge quarter turns to half turns

    z' Fw' l'
    Uw2
    r Uw' r'
    Uw2
    Bw2 Uw'
    r'
    Uw Bw2
    Uw l Fw z
    = z' Fw' l' Uw2 r Uw' r' Uw2 Bw2 Uw' r' Uw Bw2 Uw l Fw z
    = [z' Fw' l' Uw': Uw' r Uw' r' Uw2 Bw2 Uw' r' Uw Bw2]

    By the derivation, the algorithm can also be written as:
    z' Fw' l' Uw'
    Bw2 Uw'
    Uw Bw2 Uw'
    r Uw' r' Uw
    Uw Bw2 Uw'
    r'
    Uw Bw2
    Uw l Fw z
    =[z' Fw' l' Uw': [Bw2 Uw': [Uw Bw2 Uw': [r, Uw'] ] r' ] ]
    Translating to the 6x6x6 and All Other Even Cubes (20q, 17 btm)
    1) Rewrite in SiGN notation, and convert double layer turns to triple layer turns.

    z' 3f' 2L' 3u2 2R 3u' 2R' 3u2 3b2 3u' 2R' 3u 3b2 3u 2L 3f z

    2) Split the first 3u2 turn to 3u 3u.

    z' 3f' 2L' 3u2 2R 3u' 2R' 3u 3u 3b2 3u' 2R' 3u 3b2 3u 2L 3f z

    3) Rewrite as

    z' 3f' 2L' 3u2 2R

    3u' 2R' 3u


    3u 3b2 3u' 2R' 3u 3b2 3u 2L 3f z


    4) It's easier to see what we need to do if we take the inverse.

    z' 3f' 2L' 3u' 3b2 3u' 2R 3u 3b2 3u'

    3u' 2R 3u


    2R' 3u2 2L 3f z


    5) If you execute the first piece on a solved 6x6x6 and then slowly just do 3u' 2R 3u (using the link above), you'll see why we have an oblique in the wrong place. The interior conjugate is 3R.

    z' 3f' 2L' 3u' 3b2 3u' 2R 3u 3b2 3u'
    3R
    3u' 2R 3u
    3R'
    2R' 3u2 2L 3f z


    6) So we can take the inverse of this to beg the original form for the 4x4x4

    z' 3f' 2L' 3u2 2R
    3R
    3u' 2R' 3u
    3R'
    3u 3b2 3u' 2R' 3u 3b2 3u 2L 3f z


    7) Note that 2R and 3R represent all inner layer slices on the right side of an nxnxn cube and merge to 2-3r (hence we cancel a move for all cases).

    z' 3f' 2L' 3u2 2-3r 3u' 2R' 3u (3R') 3u 3b2 3u' 2R' 3u 3b2 3u 2L 3f z

    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:

    z' 3f' 2L' 3u'
    3b2 3u'
    3u 3b2
    3u' 2R
    3R
    3u' 2R' 3u
    3R'
    3u 3b2 3u'
    2R'
    3u 3b2
    3u 2L 3f z
    = [z' 3f' 2L' 3u' : [3b2 3u': [3u 3b2 3u': 2R [3R: 3u' 2R' 3u ] ] (2R') ] ]

    More compactly,
    = [z' 3f' 2L' 3u' 3b2 3u': [3u 3b2 3u': 2R [3R: 3u' 2R' 3u ] ] (2R') ]
    (The 3R conjugate represents all slices containing wings that DO NOT need to be affected).

    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.)
     
  18. mrCage

    mrCage Member

    654
    0
    Jun 17, 2006
    Why not just use R B - [l' U2]2 F2 l' F2 r u2 r' U2 l2 - B' R' for case 3. Utilizing the "holy grail of 2-cycle" ...

    Per

    Cmowla, could you summarise all parity/double parity algorithms you have discovered/derived for 4x4x4 ... in standard notation with no x, y or z? Diagrams would be most welcome.

    Links to Garron's or Randelshofer's applet would be supercool.

    Thanks for all your work :)

    Per
     
    Last edited by a moderator: Jan 8, 2012
  19. Christopher Mowla

    Christopher Mowla Premium Member

    828
    2
    Sep 17, 2009
    New Orleans, LA
    YouTube:
    4EverTrying
    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.
     
    Last edited: Sep 12, 2011

Share This Page