The edges
The idea of this method is to solve 2 edges at once with a small amount of setup moves - an algorithm - then undo the setup moves.
For an example solve check at the bottom of this page. I will only use the examples to have UR/RU and UL/LU as my targets. I'm sure that if you understand this all you will be able to set the edges up on different positions and calculate the cycle from that place. And yes it are still the same algorithms then. I think you can learn the most when you just follow examples and get an idea of how the method works.
If you would put 3 edges on one face of the cube there would be 8 different cases in which you can do that. For those 8 you need to learn the algorithms, which are given a bit further. Because it doesn't matter what the orientation of the pieces is (since you will solve that by choosing the right algorithm), the setup moves are quite easy, short and most importantly: fast.
If you take UF as your buffer and only would shoot to UR/RU and LU/LU the possible cycles are:
UF->UL->UR also known as a normal 3 cycle
UF->UR->UL also known as a normal 3 cycle
-----------------------------------------
UF->LU->RU an ELL algo
UF->RU->LU an ELL algo
----------------------
UF->UL->RU
UF->UR->LU
----------
UF->LU->UR
UF->RU->UL
----------
The algorithms
You probably know some of these, or you already know a differetn algorithm for that case. Of course it doesn't matter which algorithm you use as long as it does the same as the ones stated here.M2U'MU2M'U'M2 - UF->UL->UR |
M2UMU2M'UM2 - UF->UR->UL |
MUM'U2MUM' - UF->LU->RU |
MU'M'U2MU'M' - UF->RU->LU |
U L'U'LUM'U'L'Ul U' - UF->UL->RU |
U' RUR'U'M'URU'r' U - UF->UR->LU |
U' rUR'U'MURU'R' U - UF->LU->UR |
U l'U'LUMU'L'UL U' - UF->RU->UL |
Example solve
Now it is very possible you still don't really know how to use the method. Therefore this example solve should do the trick.Scramble: B F' D U2 F2 U' R' F U2 F2 L' U2 B' D' U2 F2 D' U2 L' B F' L2 D2 B2 L'
Or if you like all corners to be solved already: L R U2 R' F D' U L' F L' B2 D2 F2 L' F D2 U2 F (18f)
Before solving, lets analyze the memo first, you can remember it in any way you like of course. I put them down in pairs here:
[UF->] BL->RD, ->RB->DF, ->FR->LF, ->UB->BD, ->DL->LU, and remember that UR has to be flipped. Of course this would mean that UF has to be flipped too
BL->RD:
Straight forward setup with LR2, following the pieces you will see that target 1 is now at UL and target 2 at RU (not UR!), this leads to the algorithm that does: UF->UL->RU which is: U L'U'LUM'U'L'Ul U', note that the U moves can also be replaced by a cube rotation if you like.
In short: BL->RD: LR2 - U L'U'LUM'U'L'Ul U' - R2L'
RB->DF:
setup is slightly longer and more complicated now, though of course still pretty easy: R'D'L2. Target one edges up at RU and target 2 goes to UL so the algorithm is this time: UF->RU->UL which is: U l'U'LUMU'L'UL U'.
In short: RB->DF: R'D'L2 - U l'U'LUMU'L'UL U' - L2DR
FR->LF:
this is an interesting case, setup moves could be RL' but for advanced use of this method you COULD do: xy2 algo y2x', it's only a bit hard to find out which algorithm you could use. So I'll give 2 possible ways of solving this:
RL', target 1 goes to UR, target 2 goes to LU, which gives: UF->UR->LU: U' RUR'U'M'URU'r' U
In short: FR->LF: RL' - U' RUR'U'M'URU'r' U - LR'
The advance way: xy2 you'll see that we will temporarily have to change the buffer position which is now at FU, still I want to shoot from UF so everything changes, after looking good you'll see that we have now: UF->LU->UR which is: U' rUR'U'MURU'R' U
In short: xy2 U' rUR'U'MURU'R' U y2x'
UB->BD:
there are numerous setups here, a difficult way would be to do D'R2y and try to figure out the cycle then which is hard cause you have to follow the cycle from a different position now. Easier is to do BR'L. Target 1 goes to LU and target 2 to UR so we have: UF->LU->UR which is: U' rUR'U'MURU'R' U.
In short: UB->BD: BR'L - U' rUR'U'MURU'R' U - L'RB'
DL->LU: setup move for this is ridiculously easy: b', target one goes to LU and target 2 goes to UR so we have: UF->LU->UR again: U' rUR'U'MURU'R' U
In short: DL->LU: b' - U' rUR'U'MURU'R' U - b
Now we have to flip UR and UF which I use an ELL for:
R'U2R2UR'U'R'U2LFRF'L' and DONE!
I think this example solve really shows everything you could possibly encounter (without the parity which I will discuss at the Other Stuff part. I hope you understand the method a bit better. If you liked it why not go on to the corner section?