# 3BLD : How to solve 2 permuted edges in optimal number of moves (for M2 and BH users)



## Martial (Oct 23, 2012)

Hello guys, I post here my method for solving 2 permuted edges, I have already post it in Blindfold section but I think it would be better to show it in How-to's, because it's a very useful method at a high level due to the number of moves, which can't be smaller.

It would be great if people who are using BH in 3BLD (mainly those who are under 1:15-1:00) would take time to read this tuto, not necessarily in its entirety, but just the principle of the four parts, it would make me happy .



So, here is my method for solving edge 2-cycles with the M2 principle. It's wiser to understand M2 method before to read my tutorial.

I will show you the different kinds of 2-cycles that can be solved with this method. I'm french so I hope my tutorial will be understandable and, of course, I hope it will help the maximum of blinders.

Points out :
- My buffer with edges is FD, and I bring edges to BU target.
- With my method I can solve ALL 2-cycles : with right and left pieces (RU, RB, RD, RF ; LU, LB LD, LF), BU/UB, FU/UF, BD/DB.
- My method is not adapted for cases which flip the edge in buffer slot (like LF RD FL), because it takes less move to solve them with pure M2 or commutators.
- It's an optimal method, which count less moves than with pure M2 or commutators.
- That's not a list of algorithms to learn, but more an intuitive method


*What do I call a 2-cycle ?*

It's an algorithm which switches two pieces (for example LF and RD), with a changing of the cube conformation, as in M2 when you solve one piece : UF go to DB, BD go to UF, and centers are moved out.
In M2, BU is used as a target. M2 move switch BU and FD pieces. In 2-cycles, I'll teach you how to use BU and FD as 2 targets.
2-Cycles can be classified in several groups.


*I/ Cycles with BU/UB*

*1. BU...BU*

In BU case, the cycle is something like BU LF BU.

With M2, the sequence is : *M2 U'L'U M2 U'LU M2* (9 moves)
The idea is to put the LF piece, not in BU as usual, but in FD slot :
*D'LD*
Now with an M2 move, BU and FD are switched (UF and DB are switched to). The de-setup move to apply is now *D'L'D*

The entire sequence is then *D'LD M2 D'L'D* (7 moves)

It's a kind of M2 but with BU piece as a buffer.


*2. UB...UB*

In UB case, you proceed in the same way but you put your sticker in DF (instead of FD) :
UB LF UB : *L' FLF'* (setup) ; *M2* ; *FL'F'L* (de-setup)


*II/ Cycles with L piece + R piece*

Here the goal is to put one piece in FD, the other in BU, apply an M2 move and make de-setups.
In these cases it's important to note that the setup of the first edge will not move the second edge from its position.


*1. L … + R …*

I'll take LF RD LF as example. The stickers on the left an right centers are of the opposite color of the stickers LF and RD. It's pretty easy to recognize how to solve these 2-cycles.

You know that in M2, there are two ways to bring a piece in BU (or UB if your buffer is DF) :
- U' L U ; U'L2U ; U'L'U ; LU'L'U → that's the first type of setup (I'll call it *A*)
- BLB' ; BL2B' ; BL'B' ; L'BLB' → second type of setup (*B*)

In the previous example : LF RD LF, you must see that both pieces can be put in BU with an *A setup*.
First, we will put one edge in FD. The most complicated is the RD piece (4 moves, such as RU to BU). So we will place LF in the bottom (FD) : *D'LD*.
Now the RD sticker can be moved to the top (BU) : *UR2U'*

Then we apply the M2 move, and we make de-setup of the piece in BU : *UR2U'*, and the de-setup of the piece in FD : *D'L'D*.

Whole sequence is : *D'LD UR2U' M2 UR2U' D'L'D* (13 moves)
In pure M2 : *U'L'U M2 U'LU UR2U' M2 UR2U' U'L'U M2 U'LU* (21 moves)
In BH : *z'[U'M2U, R]z U'L'U M2 U'LU* (15 moves)


It's more pleasant to put the piece in BU slot in second because you give the sequence this aspect :
setup the first piece in FD ; solving the second piece in M2 ; de-setup the first piece (from FD).

If you feel more comfortable with the other type of setup (*B*), or if the cycle is something like LU RD LU, you can apply a B setup to both pieces (*FLF' B'R'B M2 B'RB FL'F'*).


*2. L … + … R*

Let's take this 2-cycle : LD DR LD.
Here we can see that one sticker can be put in BU or FD with an A setup, and the other sticker with a B setup. Imagine we focus on LD and DR sticker (the contrary is also possible) :

Bring LD to FD : LD'L'D (A setup)
Bring DR to FD : *F'RF* (B setup) → we choose this one

B setup to the first piece, so A setup to the second : *U'L2U*

*M2*, then finishing for the LD piece : *U'L2U*
Then de-setup the first edge : *F'R'F*

Entire alg : *F'RF U'L2UM2U'L2U F'R'F* (still 13 moves)


*III/ Cycles with 2 R pieces (or 2 L pieces)*

Little more complicated 
The difference is : setup one piece will move the other on the lateral face. These cases come more and more intuitively when you practice them. However, they can be solved in many ways.


*1. R … + R …*

They are easy to recognize : the R stickers of the 2 pieces have the same color as the R face (the same with L face).

RU RF RU : We must see that RU has a bad A setup to BU, but if we put RF in FD with an A setup (*DR'D'*), RU fall in RF. So we can now solve it in M2 : *URU' M2 UR'U*.
And of course don't forget to de-setup the first piece from FD : *DRD'*

So we have : *DR'D URU' M2 UR'U DRD'*
You can also use two B setups, but in order to make it easier, you must place RU in BU first :
*B'RB F'R'F M2 F'RF B'R'B*

An exception with these cycles : RB RF RB
With A setups, you can make *DU*. Now with an *R* move you put one piece in RU an the other in RD.
*U'D'* will finish the setups.
Whole alg : *DURU'D' M2 DUR'U'D'* (11 moves ). Take care of the R rotation, and don't make DU in setup and de-setup ^^.


*2. R … + … R*

Here we use an A and a B setup.
If you've read my tutorial from the top, you'll probably be able to make these. What is important to see is that none R sticker is on R face.

An example : RB UR RB
The first piece (let's take RU) will go in FD with an A setup, because it will allow to the BR piece to go in FR : *DR2D'*
Now a B setup for the second piece : *B'R2B*

Whole sequence : *DR2D' B'R2B M2 B'R2B DR2D'* (13 moves)


*IV Cycles with M pieces*

*1. Cycles with FU*

In these cases, we focus on the FD buffer as a target and FU piece.

Here, a new factor is important to care about : the cube configuration. I'll name them :
- α : M centers are in their right place
- β : M centers are reversed (Front is in Back, Up is in Down)

In this example : FU LB FU
First, we have to put the edge of our 2-cycle in FD (setup) : *D'L'D*

Then if you are in α : *(U2M')2* ; if you are in β : *(MU2)2*

At the end, make the de-setup : *D'LD*

Entire sequence : *D'L'D U2M'U2M' D'LD* (10 moves)


*2. Cycles with UF*

You solve them in the same way, but this time you've to put your sticker in DF instead of FD.

Point out : UF LF UF = FU FL FU
It's you who choose the cycle you want to do (with FU or with UF).


*3. Cycles with BD*

Like with FU, put the sticker in FD (setup)

Permutation :
in α : (MU2)2 
in β : (U2M')2

Then apply the de-setup.


*4. Cycles with DB*

The same way but with a setup which bring the sticker in DF.


*5. Special cases*

Here is a little "alg list" for some special 2-cycles :
- BU FU BU = UB UF UB : α : *(MD2)2* ; β : *(D2M')2* (4 moves)

- BU BD BU = UB UF UB : α : *(D2M')2* ; β : *(MD2)2* (4 moves)

- BU UF BU = UB FU UB : *F'UR'F* (put UB in FD) ; in α : *(U2M')2* / in β : *(MU2)2* ; *F'RU'F* (de-setup) (12 moves)

- BU DB BU = UB BD UB : *F'UR'F* (put UB in FD) ; in α : *(MU2)2* / in β : *(U2M')2* ; *F'RU'F* (de-setup) (12 moves)

- FU BD FU = UF DB UF : α and β : *E2 M' E2 M* (4 moves)

- FU DB FU = UF BD UF : in α : *y' D'M'D R2 D'MD R2 y* (commutator) + *(U2M')2* (12 moves - I didn't found better)
..................................in β : *y' D'M'D R2 D'MD R2 y* + *(U2M')2* (the same alg !)


*Discussion about the method*

* For me the most important point about this method is to quickly recognize each case, because it's the main factor to make this method efficient. 
The first thing to do with a 2-cycle is to see if both pieces can be switched without flipping the piece in your buffer. From here you try to recognize the kind of 2-cycle.


* For the memorization, you just have to remember which pieces you have to switch, and you can solve them in whatever order you want :
For example for an R... + ...R case :
- A setup on the 1st piece, B setup on the 2nd one
- B setup on the 1st piece, A setup on the 2nd one
- Put 1st piece in FD, 2nd one to BU
- Put 2nd piece in FD, 1st one to BU
- One sticker in FD, the other in BU
- One sticker in DF, the other in UB
and so on...


* For BH users, this method is useful only when you have an even number of edges to solve in addition to the 2-cycle. Indeed, if there is an odd number of edges to solve, you just have to make commutators until there is one edge unsolved left + one 2-cycle, then you solve the last edge with one of the 2-cycle, and you make a last commutator to finish.
example : FL UF RD (odd edges) + RB FR RB :

In 3 commutators :
a) FD FL UF : *[UL'U',M']*
b) FD RD RB : *[R',B'MB]*
c) FD FR RB : *z'[M',URU']z*

24 moves, instead of 1 commutator + M2 + 2-cycle :

a) FD FL UF : *[UL'U',M']*
b) FD RD : *UR2U' M2 UR2 U'* (M2 method)
c) RB FR RB : *F'R2F URU'M2UR'U' F'R2F*

8+7+13 = 28 moves


That was my method to solve 2-cycles in optimal way. Thanks for the readers, don't hesitate to give me your opinion about this tuto, if it has bring you something new in your acknowledgment about blindfold cubing


----------

