Blindfold Cubing Tutorial
|[shoot to UL]||R U R' U' R' F R2 U' R' U' R U R' F'|
|[shoot to LB]||d L' - R U R' U' R' F R2 U' R' U' R U R' F' - L d'|
|[shoot to DF]||
D' L2 - R U R' U' R' F R2 U' R' U' R U R' F' - L2 D
|[shoot to FR]||d2 L - R U R' U' R' F R2 U' R' U' R U R' F' - L' d2|
This applet shows the whole solution
I hope this example illustrates how you can solve a cycle of pieces. I think it's very similar to the cycle methods where you orient the pieces first, only with this method, you memorize and solve the cycles of stickers. Once the UL sticker is solved, the LU sticker is automatically solved too, and so is the orientation of the UL piece.
If you understand the previous example, you will also understand how this works when you have a twelve cycle of edge pieces. However, sometimes, you have more than 1 cycle to solve. In such a case, you will solve the first cycle, and end up with the buffer piece in the buffer position. For an example, do R2 U R D' U F' U' F' D U' R' on a solved cube. Your cube should look like this:
The UR sticker has to go to UB. Then.. What? After shooting to UB, the buffer is in position again! (it's flipped, but we 'ignore' that now) What we do now is: Shoot the buffer to any sticker that is not solved yet. In this case, we have 4 options. We can proceed with LF, FL, DR or RD. I would proceed by shooting at FL, because we only need one setup move for it. So, we temporarely 'store' the buffer in FL, by shooting to FL. After that, we can see that the FL sticker has to move to RD. Then, the RD sticker has to move to LF. Our memorization could look like this: UB LF RD FL. The solving process would be:
This applet shows the whole solution
Shooting to FL will make the buffer piece end up in the buffer position again. Notice how the cycle we broke into starts at FL and ends at LF. Breaking into such a cycle and solving it will flip the buffer piece, as was desired in this case. If the cycle would have started and ended at FL, breaking into the cycle and solving it would not flip the buffer piece. Also, shooting to RD in this example required 4 setup moves. This is painful indeed, but a solution for this is provided later in the document.
If you have made it this far, I assume you already know a good way of using setup moves and an algorithm to flip two edges. However, you can also use Stefan Pochmann's 'pure method', and look at this problem as a 2-cycle of stickers. The cycle starts at UL. The UL sticker has to move to LU. Thus, solving this would be:
[shoot to UL] R U R' U' R' F R2 U' R' U' R U R' F'
[shoot to LU] L d' L - R U R' U' R' F R2 U' R' U' R U R' F' - L' d L'.
There are more efficient ways to flip an edge, but this demonstrates that you can see this as a '2 cycle of stickers' rather than a 'flipped edge'. In order to flip two edges, one can also use M' U M' U M' U M' U2 M' U M' U M' U M', in combination with some setup moves. You can also use different algorithms, possibly a commutator.
So far, we only used the T-Permutation to solve edges. To shoot to UB, I used three setup moves, a T-Permutation, and three more moves to undo the setup moves. However, we can also use different algorithms. Plus, we can use these other algorithms in combination with setup moves. This will make the setup moves a lot easier: All targets can be solved with 2 setup moves at most! The algorithms that I use are listed below. You don't have to memorize the table with the setup moves! If you understand how it works, you can make up the setup moves on the fly.
|T1||[shoot to UL]||R U R' U' R' F R2 U' R' U' R U R' F'|
|T2||[shoot to LU]||x' R2 U' R' U x R' F' U' F R U R' U'|
|J1||[shoot to UF]||R U R' F' R U R' U' R' F R2 U' R' U'|
|J2||[shoot to UB]||R' U2 R U R' U2 L U' R U L'|
Here is a table, that shows you how to shoot to every position:
|Shoot to||Setup moves||Algorithm||Undo setup moves|
|[shoot to UF]||J1|
|[shoot to UL]||T1|
|[shoot to UB]||J2|
|[shoot to FU]||l'||J2||l|
|[shoot to LU]||T2|
|[shoot to BU]||l||J1||l'|
|[shoot to FR]||d2 L||T1||L' d2|
|[shoot to FL]||L'||T1||L|
|[shoot to LF]||L'||T2||L|
|[shoot to LB]||L||T2||L'|
|[shoot to BL]||L||T1||L'|
|[shoot to BR]||d2 L'||T1||L d2|
|[shoot to RB]||d L||T1||L' d'|
|[shoot to RF]||d' L'||T1||L d|
|[shoot to FD]||l'||J1||l|
|[shoot to LD]||L2||T2||L2|
|[shoot to BD]||l||J2||l'|
|[shoot to RD]||D' l'||J1||l D|
|[shoot to DF]||l2||J2||l2|
|[shoot to DL]||L2||T1||L2|
|[shoot to DB]||l2||J1||l2|
|[shoot to DR]||S'||T1||S|
I told you this page really describes the solving proces, but to give you an idea how to memorise the edges, I'll tell you what I do. When memorising, you basically make a list of 'targets' to shoot to, in a very specific order. There are 22 possible targets. I associate every target with a unique letter. When I start memorising, I look at the UR position, and I automatically convert it into a letter. In the example where I solved a cycle, the list of targets was: UL LB DF FR. If I would have that in a real blindfold solve, I would convert this, using my own system, to UROE. In order to remember this, I would try to make words of these letters, or simply repeat the letters and listen to how that sounds.
There are a lot of ways to associate and memorise this list of targets, though. Some people associate the targets with numbers, others associate with objects to make stories. Look on the internet for different ways of memorising. If you need more inspiration, I'll give you these links for free: link, link.
If you understand how to solve the edges, explaning to you how the corners are solved is a piece of cake. The position I shoot from is the LBU position. I shoot it to DFR, with one algorithm. It has one side-effect, it swaps UL and UB edges. Some of you will recognise this as a Y-Permutation without the F and F' at the beginning and the end:
[shooting to DFR] R U' R' U' R U R' F' R U R' U' R' F R
Using this algorithm, we can shoot to other positions. The table below will show you how to do that. Of course, between the 'setup moves' and 'undo setup moves', do the algorithm listed above ;). The same ideas that you learned about solving the edges apply. Look at LBU, and see where that sticker it to go. Go on like that, and create a list of targets (usually about 7, 8 or 9 of them). Sometimes, when the buffer piece comes in the LBU position, you might have to break into a new cycle, just like I showed you when I explaned solving the edges.
When you end up with 2 or more corners in position, but twisted, you can use Stefan's pure method to solve that. (For example, try shooting to URF and then shooting to RFU). But, there are also more efficient ways to twist corners, for example:
- R' U' R U' R' U2 R z U R U' R U R2 U' z'
- R U R' U R U2 (R U2' R' U' R U' R') U2 R' U2
- Or, you can use a commutator twat twists corners.
|Shoot to||Setup moves||Undo setup moves|
|[shoot to URF]||R2 D'||D R2|
|[shoot to RFU]||F||F'|
|[shoot to FUR]||R'||R|
|[shoot to UFL]||F2||F2|
|[shoot to FLU]||F R'||R F'|
|[shoot to LUF]||F' D||D' F|
|[shoot to UBR]||R2||R2|
|[shoot to BRU]||R D'||D R'|
|[shoot to RUB]||R' F||F' R|
|[shoot to DFR]|
|[shoot to FRD]||F' R'||R F|
|[shoot to RDF]||R F||F' R'|
|[shoot to DLF]||D||D'|
|[shoot to LFD]||F'||F|
|[shoot to FDL]||F2 R'||R F2|
|[shoot to DBL]||D2||D2|
|[shoot to BLD]||D F'||F D'|
|[shoot to LDB]||D' R||R' D|
|[shoot to DRB]||D'||D|
|[shoot to RBD]||R2 F||F' R2|
|[shoot to BDR]||R||R'|
I think you are ready to watch a full example solve. This example will show you what to do in case of parity. The so called 'parity problem' occors when you need to shoot to an odd amount of targets to solve the corners. I will not explain the memorization proces in full detail. I will only show you the list of targets. I don't start this list with the buffer piece, since this is not a target. This solve also demonstrates breaking into a new cycle three times. For anyone still having difficulties, I recommend following this example step by step, with a cube in hand. Do the scramble, and follow allong. I replaced the actual algorithms by T1, T2, J1, J2 and 'Corner algorithm', because writing down all the moves looks ugly here.
Scramble: L B U' R2 F' R' L2 B2 L2 D' U2 F' B L' D' L' R' F U B' D U2 B2 U2 F
Target list corners: BDR DFR DBL URF FDL RUB RDF UFL LUF
Target list edges: BL UL UF UB LD UB FL RF DF RD RB BD LF
|[shoot to BDR]||R - Corner algorithm - R'||This brings buffer in position!|
|[shoot to DFR]||Corner algorithm||We break into a new cycle here. I chose DFR, because that does not require extra setup moves.|
|[shoot to DBL]||D2 - Corner algorithm - D2|
|[shoot to URF]||R2 D' - Corner algorithm - D R2|
|[shoot to FDL]||F2 R' - Corner algorithm - R F2|
|[shoot to RUB]||R' F - Corner algorithm - F' R|
|[shoot to RDF]||R F - Corner algorithm - F' R'|
|[shoot to UFL]||F2 - Corner algorithm - F2||Using Stefan's pure method to twist the UFL corner counterclockwise: Step 1/2|
|[shoot to LUF]||F' D - Corner algorithm - D' F||Using Stefan's pure method to twist the UFL corner counterclockwise: Step 2/2|
|[fix parity]||U2 - x' R' U' F' U R' U' x
U R' U' R' U R B R2 - U2
|We swapped the UB and UL edges and odd number of times in order to solve the corners. The edges are not in the positions we memorised. To bring them back, we swap UB and UL with the URF and UBR corners.|
|[shoot to BL]||L T1 L'|
|[shoot to UL]||T1|
|[shoot to UF]||J1||This brings buffer in position!|
|[shoot to UB]||J2||We break into a new cycle here. Choosing for UB is rather arbitrary.|
|[shoot to LD]||L2 T2 L2|
|[shoot to UB]||J2||This brings buffer in position!|
|[shoot to FL]||L' T1 L||We break into a new cycle here. Choosing for FL is rather arbitrary.|
|[shoot to RF]||d' L' T1 L d|
|[shoot to DF]||l2 J2 l2|
|[shoot to RD]||D' l' J1 l D|
|[shoot to RB]||d L T1 L' d'|
|[shoot to BD]||l J2 l'|
|[shoot to FL]||L' T1 L||Because we swapped the URF and UBR corners an odd number of times to solve the edges, these corners are automatically solved now.|
I saved the best part for last. If you read the example solve, you probably noticed that this method uses quite a lot of moves. There are ways to speed up this method, cutting down the number of moves. In the example solve, I encountered a situation that was similar to this (see applet A):
In the example, this was done with a T-Permutation to shoot to UL, and a J-Pemutation to shoot to UF. Most of you will see that this is rather stupid. We might as well use R U' R U R U R U' R' U' R2 instead (see Applet B). This solves two targets, UL and UF, in one algorithm. Now, suppose we want to [Shoot to UL][Shoot to RD]. We can use the same trick here, we only need to setup the second target at UF, by doing D' M' (see applet C).
In fact, shooting to a random combination of two targets (not targets on the same piece) always results in some 3 cycle of edges. If you learn a few 'basic' algorithms for easy three cycles, you can often use these algorithms in combination with setup moves, to solve two targets at once! In the table below, you will find a few of these 3 cycles I find very usefull for this. It's not nessecarry to bring the pieces involved in the three cycles in the same layer. This list is not complete... It goes on and on. You can really use any three cycle of edges that you like. Good luck with finding them ;).
|(setup) first target at||(setup) second target at||Algorithm|
|UL||UF||R U' R U R U R U' R' U' R2|
|UL||BU||M' U M U2 M' U M|
|FD||LD||M' U MD M' U' M D'|
|DR||DF||y M' U2 M D M' U2 M D' y'|
|FL||BR||L' U2 L E2 L' U2 L E2|
|FR||UB||R' U' R' U' R' U R U R U|
So.. What do you think?
It was pretty hard to write a tutorial about this method and to explain it clearly. So if you used this tutorial, please leave a message, to tell me what you think about it. Comments usually lead to adjustments. Please help me to improve the quality of these tutorials!