Wetten, dass..? vom 5. November

Update October 20, 2011: Replaced some corner algorithms.

Update 2: I added more examples.

Update 1: I fixed some minor issues and added the history section.

In January 2006, I developed a new method for solving the 3x3 edges blindfolded and briefly described early versions in the blindcubing yahoo group. Since then I have improved the method, adapted it for solving corners (first it was only for edges) and used it in competitions. Sighted, i.e. using the method in regular speedsolving, I average a little under 50 seconds. I'm convinced with memorization and good recall a 40 seconds real average for execution is possible. This page briefly describes the two methods which I call M2 (for edges) and R2 (for corners).

Here's an example solve, the scramble is B' R' B' U' F L' U F2 L F R' D' R' B D F2 L2 D' R2 D' and the solution is on the right. Click on the image to watch the video.
TargetAlgorithm
FR U R U' M2 U R' U'
UL L U' L' U M2 U' L U L'
RB l U' R' U M2 U' R U l'
DB M U2 M U2
LD x' U L U' M2 U L' U' x
RU x' U' R U M2 U' R' U x
UB M2
DR U R2 U' M2 U R2 U'
DB M U2 M U2
FL U' L' U M2 U' L U
BLD U' L U R2 U' L' U
FLU R' U L U' R2 U L' U' R
RBD (R' U R2 U' R' F' R U R2 U' R' F)
ULB L' U' L U R2 U' L' U L
UBR R2
FDL U' L' U L' U' L U R2 U' L' U L U' L U
Video screenshot
This is an easy solve just to show the core idea. It does not include odd parity, breaking into new cycles, and cleaning up misoriented pieces. Though, every once in a while, you might indeed get a solve like this.

The main idea is the same as for my older method, namely solving one piece at a time, with "solving" meaning the whole piece, i.e., I don't separate orienting and permuting. Let me first talk about edges. Notice you should think in terms of stickers. When I say LU, I mean the L part, when I say UL, I mean the U part.

Edges Target Algorithm

To solve one edge at a time, I use place DF as "buffer" and swap the edge currently in that place to where it belongs. I use one swap algorithm which swaps DF with UB. To swap DF with another edge, I first bring that edge to UB with setup moves, then apply the swap, then undo the setup moves.

Since it's impossible to just swap two pieces and not change anything else on the cube, I do have to have some side effect. My swap algorithm actually is only an M2 move, so the side effect is a rotation of the M-slice centers and swapping the FU and BD edges, though I just think of solving these two relative to the centers, so they're not really swapped (relative to the centers they stay where they are). It only matters for choosing the algorithms for these two edges, think of the "target" telling you where the edge belongs *before* the algorithm. So for example if you target FU then *after* the alg the edge will actually end up at BD.

Obviously I called it "M2 method" because of the prominent M2 move. I actually do it as L(l'M') like Joel van Noort once suggested, with my left ring finger pulling the M'. The algorithms (see right side) should be very easy to understand and are very fast, the setup moves don't feel separated.

For the M-slice edges I use the same algorithm for both orientations. I might end up with some flipped M-edges but that's not too bad (as you'll see later). The alternative is to use longer algorithms for half of the cases.

UB
BU
M2
M2
FR
DR
BR
UR
U R U' M2 U R' U'
U R2 U' M2 U R2 U'
U R' U' M2 U R U'
R' U R U' M2 U R' U' R
FL
DL
BL
UL
U' L' U M2 U' L U
U' L2 U M2 U' L2 U
U' L U M2 U' L' U
L U' L' U M2 U' L U L'
RU
RF
RD
RB
x' U' R U M2 U' R' U x
x' U' R2 U M2 U' R2 U x
x' U' R' U M2 U' R U x
l U' R' U M2 U' R U l'
LU
LF
LD
LB
x' U L' U' M2 U L U' x
x' U L2' U' M2 U L2 U' x
x' U L U' M2 U L' U' x
r' U L U' M2 U L' U' r
DB
BD
UF
FU
M U2 M U2
M U2 M U2
U2 M' U2 M'
U2 M' U2 M'

Now the corners, very similar.

Corners Target Algorithm

This is really very much like the edges, only that things are happening in the R-slice instead of the M-slice. I solve the corner at DFR by swapping it to UBR with the "algorithm" R2. The side effect is a rotation of the R-slice "centers" (which are edge pieces), and URF and DRB stay where they were relative to the R-slice centers.

Targets outside the R-slice (i.e., in the L-slice) get swapped with DFR after bringing them to UBR with setup moves.

Targets inside the R-slice have special algs, and for UBR I simply use R2 for every orientation so that it'll likely end up misoriented which I fix at the end (you'll see it soon). Update: not true anymore, I now use the given algs for BRU and RUB.

Of course, feel free to use other algs, especially for FUR and BDR you might like A-perm plus R2 better.

UBR
BRU
RUB
R2
U' L' U L U' L' U R2 U' L U L' U' L U
U' L U L' U' L U R2 U' L' U L U' L' U
BLD
ULB
DLF
FLU
U' L U R2 U' L' U
L' U' L U R2 U' L' U L
U' L2 U R2 U' L2 U
R' U L U' R2 U L' U' R
LBU
LUF
LFD
LDB
U' L' U R2 U' L U
L' U' L' U R2 U' L U L
L2' U' L' U R2 U' L U L2'
L U' L' U R2 U' L U L'
BUL
DBL
FDL
UFL
y R U R2 U' R' F2 R U R2 U' R' y'
U' L2 U L' U' L U R2 U' L' U L U' L2 U
U' L' U L' U' L U R2 U' L' U L U' L U
L U' L' U L' U' L U R2 U' L' U L U' L U L'
RBD
BDR
DRB
(R' U R2 U' R' F' R U R2 U' R' F)
(R U R' D r2 U') (R U r2' U') (D' R)
(R2 U' R' F') (r U R2' U') (r' F) (R' U)
RFU
URF
FUR
(F' R U R2 U' R' F R U R2' U' R)
U' (R F' r U R2 U') (r' F R U R2')
(R2' U' r x) (l2' U L U') (R' U) (L' U' L') (R' U)

Some comments on memorization and why it's especially good for M2/R2 to memorize targets in pairs.

Memorization

I translate pieces to mental images, for example DR and DRB could be Donald Duck, because D=white and R=blue for me. However, for the M2 and R2 methods it's very helpful to memorize in pairs, two targets in a row together. To know which target comes first, I translate the first to a person (e.g., Donald Duck) and the second to an action (e.g., vomiting). So for each color pair, I have both a person and an action.

This is very good for the M2/R2 methods because this automatically takes care of the current state of the centers of the M-slice (during edge solving) or the R-slice (during corner solving), which would otherwise have to be considered for UF/DB/URF/DRB because their "correct" place is relative to the centers which toggle between solved and not solved. Memorizing in pairs takes care of this automatically. One mental item always stands for the same algorithm. So during blindfolded execution, all you need to do is recall the next item and let your fingers apply the corresponding algorithm.

Oh, and memorizing in pairs also lets you determine parity easily, as in case of odd parity you simply end up with a single unpaired item at the end of memorizing the edges.

Now I'll show how I deal with the special cases: odd parity, cleaning up misoriented pieces, dealing with more than one edge or corner cycle.

Special cases Goal Algorithm

If there's another cycle when I'm done with one, I break into the new one just like with my older method, choosing a target with a fast algorithm (usually M2 or R2).

After solving the edges, I might end up with some M-slice edges flipped and some non-M-slice edges flipped because they were like that at the start of the solve. I flip them all together, usually with one of the algs on the right side after a setup move. Similarly corners, though mostly DFR and UBR are misoriented.

In case of odd parity, the M and R crosses need to be rotated back and the parity algorithm does just that.

I'm actually dreaming of having one big clean-up step at the end, fixing misoriented edges and corners and the parity all at once. Until now I know two algorithms combining parity with corner orientation.

Orient
edges
(M' U)*4
M' U M' U M' U2 M U M U M U2
(M' U M' U M' U M' U')*2
(U L U' L') (M' U)*4 (L U L' U')
Orient
corners
(R' U R2' U' R2 U' R' U) (R U R' U') (R2 U' R2 U)
(R U R2' U' R2 U' R' U) (R U R' U') (R2 U' R2 U R2)
(L' U' L U' L' U2 L) (R U R' U R U2 R')
(R U2 R' U' R U' R') (L' U2 L U L' U L)
Odd
parity
(r2' U' r2) (R' U) (L' U2') (R U' R' U2 R) (L U') (r2' U)
Combi-
nations
(r2 y') (R' U' l' L U' L U) (L' r' U) (l U') (F R U)
(L2 y') (R' U' l' L U' L U) (L' r' U) (l U') (F R U)

In case you're interested about the history of this method, how I developed it... keep reading.

History

In 2004 I invented my older method (also see Joel van Noort's blindcubing tutorial), its key idea in my opinion being that it solves one piece at a time (this makes setup moves extremely easy and you can do them unconsciously). Though, some people say its key idea and contribution was that it orients and permutes at the same time, as previous methods did them separately. Anyway, that method certainly influenced M2/R2

However, the actual origin of M2/R2 was a method for the edges of the 4x4 and dates back to December 2005. It caused me to start this thread and I first explained the method in this message. It alternated between R U R' U' (Rr) R' U R U' (Rr)' and its inverse (as a forward and a backward step) as a swap alg to shoot an edge from a buffer position to its goal position (usually with setup moves, of course). That is a 3-cycle of edges, not a swap, but the trick was to not use a fixed buffer position, but alternate between UBr and URf as buffers. The other of the two always was a "helper". Daniel Beyer btw improved this method and also adapted it to 4x4 centers, see Daniel's tutorial.

Then, again for 4x4 edges, I had the idea to use shorter 3-cycles involving two r-edges, U L' U' r U L U' r' and its inverse, with the buffer alternating between DFr and UBr and the helper always being at FUr. It also reduced the setup moves, as they were integrated into the algorithm (the U L' U' part in the example) so I could shoot to many targets with just one or even no extra setup moves.

Still for the 4x4, I switched from r/r' to r2/r2, because the backward alg had to do r'/r instead of r/r'. That confused me, and that's why I went to the consistent r2/r2, so now algs looked like U L' U' r2 U L U' r2 and my buffer and helper positions alternated between DFr and UBr.

Then I realized that the forward algorithm ended with r2, and the backward algorithm started with r2. So I cancelled that. This also had the wonderful side effect of keeping the buffer fixed at DFr and getting rid of the helper position concept. It also introduced the temporarily out of place centers and FUr and BDr edges, but that turned out to be a negligible issue. By now, algs looked like U L' U' r2 U L U'.

Finally, I moved the method to the 3x3, replacing r2 with M2 (and adding new algs for the M-slice targets). In January 2006 I first mentioned and later explained the new method in the blindcubing group. For some reason I don't remember, I first introduced what I later renamed M2P, which is M2 just for permutation, i.e., after edges have been oriented, which makes it even faster because those are the nicer algs. Anyway, interest was small, though at least Joel van Noort picked it up and we talked about it a bit at the next competitions. But I kinda had the feeling that I'd first have to prove it to be fast, so I mostly kept quiet about it.

At first I thought that the same method wouldn't work for corners, as each corner has three possible orientations and there are just two easy ways to bring an L-corner to UBR, from BLD with U' L U and from LBU with U' L' U. Notice that BLD and LBU aren't just an L-turn away from each other, they each represent four L-slice corner stickers/targets (you can see them and their algs grouped in the above corner algs table). However, one fine day I realized that the third orientation isn't plain impossible, but just needs a little longer algs. And then I used ACube to find good algs for the R-slice corners.

In June 2007, I finally decided to make M2/R2 public with a page on my website. At the time of this writing, it has mostly been discussed in this speedcubing group thread. Shortly afterwards, Erik Akkersdijk, who had already learned M2 from Joel, published Erik's blindcubing tutorial, among other things providing his perspective on M2. Ironically, he (or Joel?) also translated M2 to the 4x4, i.e., back to where it had originated from (though he couldn't have known, I think I never told that until now), and described the r2 method for 4x4 edges, but with better handling of the l-slice and r-slice edges than I originally had. Btw, M2 is also very nice for the middle edges of the 5x5. Unlike my older method, which swaps tredges when translated to the 5x5, M2 only swaps the middle edges.

I've been asked for more examples, so here they are (for the suggested scrambles):

Solve 1 (requested here) Solve 2 (requested here)
Scramble: L U L' B' D2 U R' F2 B' D' U B' R2 U' D' F R D' F' U R B2 D B' D'Scramble: R B2 L' R2 D2 F2 R2 F2 R U2 F U' F2 D' B' D2 U' R' B2 D' F'
DB: M U2 M U2
UB: M2
DL: U' L2 U M2 U' L2 U
UR: R' U R U' M2 U R' U' R
LF: x' U L2' U' M2 U L2 U' x
DB: M U2 M U2
BR: U R' U' M2 U R U'
RF: x' U' R2 U M2 U' R2 U x
BU: M2
DB: M U2 M U2
UB: M2
DL: U' L2 U M2 U' L2 U
RU: x' U' R U M2 U' R' U x
FL: U' L' U M2 U' L U
BD: M U2 M U2
BR: U R' U' M2 U R U'
RF: x' U' R2 U M2 U' R2 U x
BU: M2
Orient edges:
L F (M' U M' U M' U2 M U M U M U2) F' L'
Orient edges:
R F (M' U)*4 F' R'
LUF: L' U' L' U R2 U' L U L
UBR: R2
DLF: U' L2 U R2 U' L2 U
BDR: (R U R' D r2 U') (R U r2' U') (D' R)
RBD: (R' U R2 U' R' F' R U R2 U' R' F)
BRU: U' L' U L U' L' U R2 U' L U L' U' L U
BLD: U' L U R2 U' L' U
LBU: U' L' U R2 U' L U
DBL: U' L2 U L' U' L U R2 U' L' U L U' L2 U
LUF: L' U' L' U R2 U' L U L
UBR: R2
DLF: U' L2 U R2 U' L2 U
BDR: (R U R' D r2 U') (R U r2' U') (D' R)
RBD: (R' U R2 U' R' F' R U R2 U' R' F)
BRU: U' L' U L U' L' U R2 U' L U L' U' L U
BLD: U' L U R2 U' L' U
LBU: U' L' U R2 U' L U
DBL: U' L2 U L' U' L U R2 U' L' U L U' L2 U
Orient corners and fix parity:
(L2 y') (R' U' l' L U' L U) (L' r' U) (l U') (F R U)
Orient corners and fix parity:
(L2 y') (R' U' l' L U' L U) (L' r' U) (l U') (F R U)
Time of fluent execution: 36 secondsTime of fluent execution: 36 seconds

Stefan Pochmann
Last modified: October 20 2011, 15:21:42