## (My) Rubik's Cube Solution

• At the first sight, my (favourite) method to solve the Rubik's cube looks like a mix of (or it was inspired by) Adam's method, Roux method and Salvia's method. It solves the cube in parts, by maneuvering that the previously solved parts would not be disturbed, or would be disturbed only minimally (if unavoidable).

• The method reuses algorithms for permuting (PLLC) and orienting (OLLC) the last layer corners as from the Corners First approach. However, it utilizes the fact that algorithms do not only preserve the first layer corners but also the two particular edges from the first and two from the second layer.
• Hence the method starts by solving those four edges followed by the first layer corners making an incomplete First Two Layers (iF2L). It continues with the second layer corners, followed by the four remaining edges from the left and right layers. It ends up by solving the four middle edges (midges) from the vertical M-slice in a sandwich between the R and L layers.

• The method builds the cube in eight steps as listed below, with a Java simulation showing the whole process in action:
1. Left and right edges in D-layer together with the three adjacent centres
2. Left and right edges in B-layer (together with the centre between them)
3. All four corners in D-layer
4. Positioning U-layer corners (PLLC)
5. Orienting U-layer corners (OLLC)
6. Four remaining edges in R and L layers, left/right pairwise
7. Orienting M-layer edges (OMLE)
8. Positioning M-layer edges (PMLE)

• The solved portions are illustrated upon the 2nd, 3rd (two views), 5th and 6th step. For convenience, first three steps are worked out on the upper half of the cube, and only then we rotate the cube to get it really down into the first two layers:

• First three steps are intuitive, as well as the sixth step.
• A single algorithm (or its inverse) can be applied once or twice to cover all the OLLC cases (and similarly for PLLC, OMLE and PMLE cases) but we have also direct and optimized algs per each case. All together, minimum four algs are enough to be memorized for the whole method.
• Algorithms for PMLE are short and intuitive (IMHO, no need to memorize them). Algs for OMLE are not long either (8 to 11 slice turns) and hopefully they can be also understood intuitively.
• Two algorithms for PLLC are simple and ergonomic: we have more freedom compared to e.g. Beginner's method or other methods leaving the 3rd layer for last, since the incompletness of F2L (DF, DB, FR and FL edges are missing), and since the U-layer edges and corners are not yet oriented.
• For OLLC we share the well known Sune™ algorithm by L. Petrus to twist three by three corners. However, twisting of e.g. two pairs of opposite corners can be done by a direct short alg, since the F2L was not completed before.
• With a look-ahead experience and following the provided 11 (eleven) optimized algs (and their inverses), the cube can be solved in cca 55 face and slice turns. It could be reduced by half a dozen turns if PLLC and OLLC as well as OMLE and PMLE steps would be coupled together (resulting with more cases to be recognized and more algs to be memorized) - however, the challenge of intuitive approach would be completely lost.
• #### Singmaster's notation etc.

• U, D, F, B, R and L layers: Up, Down, Front, Back, Right and Left
• U, D, F, B, R, L turns: clockwise turns of the corresponding layers
• Composition T W means: apply T first, then W
• T . W as a composition with a rhetoric pause in the middle
• T2 := T T
• T' as the inverse of T, e.g. (T W)' = W' T'
• Conjugator <T> W := T W T'
• Commutator [T, W] := T W T' W'
• E.g., (<T> W)' = <T> W' and [T, W]' = [W, T]
• R, M' and L' represent parallel turns of the Right layer, vertical Middle slice and the Left layer
• Together, they rotate the whole cube Front-to-Up
• I'd rather like if M and M' slice turns were defined in the mutually opposite directions (consistent to R-layer turns), but...

#### 1. First two opposite edges

• For (beginner's) convenience during the next two steps, keep the two just solved edges temporarily left, front and back on the equator. Left handed person will keep them on the right, front and back also on the equator.
• The next two edges will be solved as in the upper layer, front and back, and corners in the 3rd step will be also solved in the upper layer. Then we will turn the cube upside-down and around, that the solved four edges and corners form the proclaimed incomplete First Two Layers.

• #### 2. Second two opposite edges

• Two choices: opt between U or D layer for easier front and back edges (turn the cube upside-down if necessary)
• Few cases with look-ahead and parallel solving are demonstrated by Java simulations

#### 3. First four corners

• Two choices: opt between solving corners in the layer with the first two edges solved, or with the second two edges solved
• You may solve the two corners common for both layers, then opt for two easier remaining corners
• Grab the cube by left (right) hand over the solved equator edges
• Use your right (left) hand exclusively for U, D and R (L) turns
• Insert corner by corner from D layer to U layer, it's really ergonomic (and fast)
• U turns are needed here to avoid previously solved equator edges

• For the next two steps turn the cube that previously solved corners go to the bottom. The optimized PLLC and OLLC algorithms (except for Sune™ and Antisune™) utilize the structure of incomplete F2L and require no (solved) edges in the F layer and M slice to take care about.
• Now, the cube should be oriented that the four solved corners go to the bottom layer and that the four solved edges go left and right on the equator, into the first two layers. Whenever it would be necessary for PLLC or OLLC cases and their corresponding algs, turn the U layer around for preparation.

• #### 4. PLLC on iF2L

• Two corners can be always aligned just by U rotations
• Two cases will remain: two adjacent and two diagonal swaps:
• Swapping two adjacent corners: [F', U'] (<R> U) = F' U' F U R U R'
• Repeat/combine for diagonal corners
• Diagonal corners directly: F' U' R' F R F
• Symmetric left-handed algs: F U F' U' L' U' L and F U L F' L' F'

#### 5. OLLC on iF2L

• By Conservation laws, sum of the remaining corner twists must be zero
• Seven cases will remain upon the appropriate U-layer prep turns: three positive twists, three negative, etc.:
• Sune™ alg for three positive twists: T := <R U> [R', U] = R U R' U R U2 R'
• AntiSune™ alg for three negative twists: T' = <F U> [U, R'] = R U2 R' U' R U' R'
• Repeat/combine for the remaining five cases
• Symmetric left-handed algs: L' U' L U' L' U2 L and L' U2 L U L' U L
• Direct algs for remaining five cases:
• <F2 U2> F = F2 U2 F U2 F2
• F U2 F2 U' F2 U F2 U2 F'
• F2 U' F U2 F' U2 F U' F2
• W := F2 R2 D R D' R F' U F'
• W' = F U' F R' D R' D' R2 F2
• Symmetric left-handed algs: F2 U2 F' U2 F2, F' U2 F2 U F2 U' F2 U2 F, F2 U F' U2 F U2 F' U F2, F2 L2 D' L' D L' F U' F and F' U F' L D' L D L2 F2
• Observe how certain algs preserve additional F2L edges and try to save on the prep U turns
• Apply an one-time U-layer alignment to complete the corners

#### 6. (Two) pairs of left/right edges

• Useful trick:
• Consider a and b as the left and right edges to be solved (or vice versa)
• Insert the flipped edge a to the destination of the edge b
• Repeat the maneuver to insert now the edge b (correctly flipped) to its proper destination
• Edge b will eject and roll over the edge a to its own destination

#### 7. OMLE

• By Conservation laws, sum of the edge flips must be even (none, two or four flips)
• Three cases will remain upon the appropriate cube or M-slice prep turns: two adjacent flips, two diagonal and four flips:
• Two adjacent flips: T := [F2, <U> M'] = F2 U M' U' F2 U M U'
• Two diagonal flips: T' = [<U> M', F2] = U M' U' F2 U M U' F2
• Repeat/combine for four flips
• Four flips directly: F M' F2 U2 F M2 F M' F2 U2 F

#### 8. PMLE

• By Conservation laws, number of swaps (remaining swapped pairs of edges) must be even (none or two swaps)
• Four cases will remain upon the appropriate cube or M-slice prep turns: anticlockwise and clockwise 3-cycles, two adjacent and two diagonal swaps:
• Two overlapping swaps form 3-cycles:
• Anticlockwise: T := <F2> M = F2 M F2
• Clockwise: T' or <U2> M' = U2 M' U2
• Repeat/combine for non-overlapping swaps
• Direct algs for non-overlapping swaps:
• Two adjacent swaps: <F2> M2 = F2 M2 F2
• Two diagonal swaps: (<F2> M2)(<U2> M2) = F2 M2 F2 U2 M2 U2

• M turns accumulated through the steps 6 to 8 should be compensated by the final, one-time M-slice alignment.
• Observe that the fourth PMLE case does not require prep turns. To avoid cube rotations or M turns as preps for the first three cases, one can replace F turns in the algs by appropriate U, B or D turns. E.g., <B2> M performs similar clockwise 3-cycling, just leaving a different, fourth, fixed midge.

• #### Closing notes

• Moving the OLLC step before PLLC gains no further optimizations for OLLC
• If OLLC is moved before PLLC, previous iF2L optimizations in PLLC will be lost
• Moving the PMLE step before OMLE cannot gain further optimizations for the already short PMLE algs
• Provided algs were analysed and optimized thanks to J. Jelinek's command-line ACube solver. E.g., inputs: "@? @? @? @? @? @? @? @? @? @? @? @? @ULF @URB @UBL @UFR !!" and "@? @? @? @? @? @? @? @? @? @? @? @? @UBL @URB @UFR @ULF !!" result with the left-handed PLLC algorithms as above.
• Hence, even in the pure Corners first method, two 3rd layer corners cannot be swapped more efficiently. Since these algs are also not invariant on the FL and FR edges, more complicated (and longer) PLLC algs are required when F2L are solved completely before.

• Illustrated by Java animated AnimCube by courtesy of J. Jelinek

• I. Penzar, Aug 13, 2013, ver. 1.03
• Free Hit Counter: