Home > Cube Corner > Blindsolving >

M2/R2 blindcubing methods

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 Targ
Algorithm
L F R' D' R' B D F2 L2 D' R2 D'and the solution is on the et
right. Click on the image to watch the video. 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
(R' U R2 U' R' F' R U R2 U'
RBD
R' F)
ULB L' U' L U R2 U' L' U L
UBR R2
U' L' U L' U' L U R2 U' L' U
FDL
This is an easy solve just to show the core idea. It does not L U' L U
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 UB M2

the edge currently in that place to where it belongs. I use one BU M2
swap algorithm which swaps DF with UB. To swap DF with
another edge, I first bring that edge to UB with setup moves, then FR U R U' M2 U R' U'
apply the swap, then undo the setup moves. DR U R2 U' M2 U R2 U'
BR U R' U' M2 U R U'
Since it's impossible to just swap two pieces and not change UR R' U R U' M2 U R' U' R
anything else on the cube, I do have to have some side effect. My
FL U' L' U M2 U' L U
swap algorithm actually is only an M2 move, so the side effect is DL U' L2 U M2 U' L2 U
a rotation of the M-slice centers and swapping the FU and BD BL U' L U M2 U' L' U
edges, though I just think of solving these two relative to the UL L U' L' U M2 U' L U L'
centers, so they're not really swapped (relative to the centers they
stay where they are). It only matters for choosing the algorithms RU x' U' R U M2 U' R' U x
for these two edges, think of the "target" telling you where the RF x' U' R2 U M2 U' R2 U x
edge belongs *before* the algorithm. So for example if you RD x' U' R' U M2 U' R U x
target FU then *after* the alg the edge will actually end up at RB l U' R' U M2 U' R U l'
BD.
LU x' U L' U' M2 U L U' x
LF x' U L2' U' M2 U L2 U' x
Obviously I called it "M2 method" because of the prominent M2
LD x' U L U' M2 U L' U' x
move. I actually do it as L(l'M') like Joel van Noort once LB r' U L U' M2 U L' U' r
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.
DB M U2 M U2
BD M U2 M U2
For the M-slice edges I use the same algorithm for both
UF U2 M' U2 M'
orientations. I might end up with some flipped M-edges but that's
FU U2 M' U2 M'
not too bad (as you'll see later). The alternative is to use longer
algorithms for half of the cases.

Now the corners, very similar.

Corners Target Algorithm

This is really very much like the edges, only UBR R2

that things are happening in the R-slice BRU U' L' U L U' L' U R2 U' L U L' U' L U
instead of the M-slice. I solve the corner at RUB U' L U L' U' L U R2 U' L' U L U' L' U
DFR by swapping it to UBR with the
"algorithm" R2. The side effect is a rotation BLD U' L U R2 U' L' U
of the R-slice "centers" (which are edge ULB L' U' L U R2 U' L' U L
pieces), and URF and DRB stay where they DLF U' L2 U R2 U' L2 U
were relative to the R-slice centers. FLU R' U L U' R2 U L' U' R

LBU U' L' U R2 U' L U

Targets outside the R-slice (i.e., in the L-
LUF L' U' L' U R2 U' L U L
slice) get swapped with DFR after bringing
LFD L2' U' L' U R2 U' L U L2'
them to UBR with setup moves.
LDB L U' L' U R2 U' L U L'

Targets inside the R-slice have special algs, BUL y R U R2 U' R' F2 R U R2 U' R' y'
and for UBR I simply use R2 for every DBL U' L2 U L' U' L U R2 U' L' U L U' L2 U
orientation so that it'll likely end up FDL U' L' U L' U' L U R2 U' L' U L U' L U
misoriented which I fix at the end (you'll UFL L U' L' U L' U' L U R2 U' L' U L U' L U L'
see it soon). Update: not true anymore, I
now use the given algs for BRU and RUB. RBD (R' U R2 U' R' F' R U R2 U' R' F)
BDR (R U R' D r2 U') (R U r2' U') (D' R)
Of course, feel free to use other algs, DRB (R2 U' R' F') (r U R2' U') (r' F) (R' U)
especially for FUR and BDR you might like
RFU (F' R U R2 U' R' F R U R2' U' R)
A-perm plus R2 better.
URF U' (R F' r U R2 U') (r' F R U R2')
FUR (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 Orient (M' U)*4

done with one, I break into the new edges M' U M' U M' U2 M U M U M U2
one just like with my older (M' U M' U M' U M' U')*2
method, choosing a target with a (U L U' L') (M' U)*4 (L U L' U')
fast algorithm (usually M2 or R2).
Orient (R' U R2' U' R2 U' R' U) (R U R' U') (R2 U' R2 U)
After solving the edges, I might corners (R U R2' U' R2 U' R' U) (R U R' U') (R2 U' R2 U R2)
end up with some M-slice edges (L' U' L U' L' U2 L) (R U R' U R U2 R')
flipped and some non-M-slice (R U2 R' U' R U' R') (L' U2 L U L' U L)
edges flipped because they were
Odd (r2' U' r2) (R' U) (L' U2') (R U' R' U2 R) (L U') (r2' U)
like that at the start of the solve. I
parity
flip them all together, usually with
one of the algs on the right side Combi- (r2 y') (R' U' l' L U' L U) (L' r' U) (l U') (F R U)
after a setup move. Similarly nations (L2 y') (R' U' l' L U' L U) (L' r' U) (l U') (F R U)
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.

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' r2and 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' Scramble: R B2 L' R2 D2 F2 R2 F2 R U2 F U'
D' F R D' F' U R B2 D B' D' F2 D' B' D2 U' R' B2 D' F'

DB: M U2 M U2 DB: M U2 M U2
UB: M2 UB: M2
DL: U' L2 U M2 U' L2 U DL: U' L2 U M2 U' L2 U
UR: R' U R U' M2 U R' U' R RU: x' U' R U M2 U' R' U x
LF: x' U L2' U' M2 U L2 U' x FL: U' L' U M2 U' L U
DB: M U2 M U2 BD: M U2 M U2
BR: U R' U' M2 U R U' BR: U R' U' M2 U R U'
RF: x' U' R2 U M2 U' R2 U x RF: x' U' R2 U M2 U' R2 U x
BU: M2 BU: M2

Orient edges: Orient edges:

L F (M' U M' U M' U2 M U M U M U2) F' L' R F (M' U)*4 F' R'

LUF: L' U' L' U R2 U' L U L LUF: L' U' L' U R2 U' L U L
UBR: R2 UBR: R2
DLF: U' L2 U R2 U' L2 U DLF: U' L2 U R2 U' L2 U
BDR: (R U R' D r2 U') (R U r2' U') (D' R) 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) 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 BRU: U' L' U L U' L' U R2 U' L U L' U' L U
BLD: U' L U R2 U' L' U BLD: U' L U R2 U' L' U
LBU: 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 DBL: U' L2 U L' U' L U R2 U' L' U L U' L2 U

Orient corners and fix parity: Orient corners and fix parity:
(L2 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)

Time of fluent execution: 36 seconds Time of fluent execution: 36 seconds