solvethecube.co.uk

Contents

• Intro
• Tips
• Description of different methods
• Stefan Pochmann's Method - The edges
  • 1. Shooting a piece to UL
  • 2. Shooting a piece to RF
  • 3. Shooting a piece to LU
  • 4. Solving a cycle
  • 5. Breaking into a new cycle
  • 6. How to flip edges
  • 7. Faster setup moves
  • 8. How to memorise the edges
• Stefan Pochmann's Method - The Corners
• Example solve
• Ideas for speeding up

Intro

This tutorial will explain a method for solving Rubik's Cube blindfolded. The method described in this page is not invented by me, it was invented by Stefan Pochmann. Even though Stefan has his own page that explains his (old) blindfold method (you can find it here), I had a lot of people asking me questions about this method, and requests to write my own tutorial for it. So, here it is! I hope that this makes sense. If you want to use this tutorial, you have a lot of reading to do. But I can asure you that once you can solve the Cube with your eyes closed, you will know that is was well worh it ;).

The method described in this page is designed to be used for when the time of memorisation/inspection/planning + solving counts. It can be used for other types of blindfold cubing, where only the solving time counts, but most people would use a different approach in that case.

If you want to use this tutorial, you should be a pretty advanced cuber, I'd say. You are expected to know the basic cubing lingo, and you are expected to be able to perform some algorithms (especially T and J permutations) with reasonable speed and fluency... and without looking, of course! I also higly recommend some knowlegde about commutators. This method is not directly based on commutators, but some knowlegde about cycles could come in handy here.

I tried to make this page applet-free. For most algorithms, there is a link that will show you the applet.

Tips

Description of different methods

For completeness, I want to show you the different approaches people use for blindfold methods. In general, blindfold methods use algorithms that effect only few pieces at a time. This way you don't have to keep track of all the pieces when you execute an algorithm. There are different systems to do this though, and I think you should know about them. Here are links to the pages that describe the different methods:

First of all, I should point out that there is a difference between methods for memorising the cube state, and methods for actually solving the cube blindfolded. This tutorial is mostly about actually solving method. I will also tell you how I memorise the cube state, which is closely related to how I solve it. I will no briefly describe how other blindfold methods work. Like in normal cubing, there are different approaches. In normal cubing, some people start with a cross, and some people dont. In blindfold cubing, some people start by orienting all the pieces, and some people don't.

I started blindfold cubing using Richard Carr's Blindfold cubing document. Richard first orients all the pieces, and then he permutes them. There is a way to define orientation of both corners and edges, even if the pieces are not in their correct positions (I will not explain this here). By first solving the orientation, you can forget about it during the permutation phase; you only have to obey some 'rules' that will preserve the orientation. Richard Carr had a somewhat complex way of dealing with permutation: All of the pieces where assigned a number. For example: 1 = UFR, 2 = UFL, 3 = UBL, 4 = UBR, etc. On a scrambled cube, he would look at position 1, and remember where that pieces needs to go. Then, he'd look at position 2, and remember where that piece needs to go. For the corners, you would end up with 8 digits, like 81256734. The permutation of the corners is 'coded' in those 8 digits. Memorising the permutation this way is, in my opinion, not very practical, because solving the permutation requires quite some thinking, and mentally updating where the pieces are.

After a while of using this method, I found a better way to deal with the permutation. Usually people will call this the 'cycle' method. A lot of cubers use this. First, you orient all the pieces. Then, the permutations are memorized in a different way. You can look at position 1, and remember where that piece needs to go. Let's say this piece has to go to position 5. Now, you don't look at position 2, but you have to look at position 5, and see where that piece has to go. You will have to repeat this until you come back to position 1. Now, you found a string of numbers, for example (1578), which means:

After finding this 4-cycle, there are probably other pieces out of place. You will have to memorise them in the same way, probably starting with 2 (Unless that piece is solved already). Notice that when you memorize this way, you don't really memorize which piece is where. You are not really interesed in which piece is in position 1, you only care about where that piece needs to go! Using this way of memorising, it is much easier to solve the permutation.

After about 2 years without blindfold cubing very much (basically I only did it at competitions, and I was very slow), I found a completely different method. It's a very clever method. It might not be the fastest method, but it is very simple and effective... I don't think this method in it's 'pure form' will be the fastest blindfold method, but I think the basic idea this method is using is very promising. I therefore think it's a very good method to start with for a beginner in blindfold cubing.

Stefan Pochmann's Method - The edges

With this method, you will solve individual stickers, rather than pieces! This is the essential difference between the 'traditional' methods I described, and this method.

Important: In this tutorial, I will often talk about RF and FR stickers (or other) positions, rather than the RF piece. If this confuses you: the RF sticker is the sticker on the R face on the RF piece. The FR sticker is the F sticker on the same RF piece. This is key for explaining how the method works!

This sections contains 8 subsections that will show you how to solve the edges blindfolded. In blindfold cubing, most people hold the cube in the same orientation every time. I use yellow as U-face colour, and orange as a F-face colour. The applets will have the same orientation.

1. Shooting a piece to UL

[shoot to UL] R U R' U' R' F R2 U' R' U' R U R' F'

Look at the algorithm in the applet. The piece in UR position has to move to UL. Hopefully, you recognise this pattern as the famous T-Permutation. It swaps the URF and URB corners, and it swaps the UL and UR edges. In this context though, I'd like to describe this algorithms as 'shooting a piece to UL'. This means the sticker at UR is moved to UL and the sticker at RU is moved to LU. The algorithms also swaps two corners, but since we are dealing with the edges here, we will ignore the corners for now. The piece at UL will end up in UR. This piece, in this tutorial it's the yellow-blue edge, we call the 'buffer' piece. The UR position is called the 'buffer position'. We use this position to 'shoot' from every time we solve an edge. I know this sounds cryptical, but just keep on reading, you'll get the idea. ;)

2. Shooting a piece to RF

Here is another applet. The piece int the buffer position is blue-orange. We want to 'shoot' this piece to RF; RF is the 'target'. In this situation the URF and URB corners need to be swapped also. Since this pattern has the exact same cycle type as the T-Permutation (it involves swapping two corners and two edges), we can use the T-Permutation do solve this. The thing is, we have to find some setup moves to bring the involved pieces in the correct positions. In order to do that, we have to move the piece currently in the RF position to UL (the other pieces are already in place); in other words, we have to setup the target at UL.

Now, notice that there are two ways to bring the RF edge piece to UL. We can do either d' L' or d2 L. However, when we do d2 L, our target will end up at LU. So the correct way to start is d' L', since this will bring the target to UL. The algorithm thus becomes: d' L' - R U R' U' R' F R2 U' R' U' R U R' F' - L d. The last two moves undo the setup moves.

Another way of thinking about this is: Notice that the UR sticker is blue (whereas the RU sticker is orange). This blue UR sticker has to end up at RF, where we currently see a yellow sticker. Therefore, we have to bring the current RF sticker to UL, so we can swap it with the RU sticker.

Notice what would have happened if we started with d2 L:

d2 L - R U R' U' R' F R2 U' R' U' R U R' F' - L d2.

You see?! The UR sticker and the FR sticker are swapped, making the blue sticker end up in the orange face! The piece ends up in the correct position, but in the wrong orientation.

3. Shooting a piece to LU

Look at the applet below:

What do we need to do here? We want to shoot the UR sticker to LU. Again, as in the previous example, this pattern involves swapping two corners and two edges, so we can use the T-Permutation again. The currect UR sticker is green, and we want to swap it with the current LU sticker. LU is the 'target'. To solve this using the T-Permutation, we have to find setup moves, to bring the target to UL. That's fairly easy: L d' L. So to shoot to LU, the algorithm is:

[shoot to LU] L d' L - R U R' U' R' F R2 U' R' U' R U R' F' - L' d L'.

Compare this with shooting to UL in the first example. I hope it slowly becomes clear how this method deals with 'orientation' issues. Basically, in this example, we swapped the UR and LU stickers, whereas in the first example, we swapped UR with UL.

4. Solving a cycle

So far, I only explained how to solve indivudual stickers/pieces, without involving any memorization. Now, let's look at a more difficult example. Take a solved cube, and do D2 R' U' B' R' U B U R U B' D2. Your cube should look like this now:

The idea about solving a cycle is that we shoot the piece in the buffer position to it's correct position every time. This will then bring a new piece in the buffer position. Then we solve the new piece by shooting it to it's correct position. Repeating this process will eventually solve the cycle of pieces.

In this example, 5 edge pieces need to be cycled. Imagine we want to solve this 5 cycle of pieces blindfolded. We are going to memorize the cycle here, just like one would do with the 'traditional' cycle methods, but here we memorise the cycle of stickers.

We start our memorisation at the buffer position, the UR sticker. It's yellow, so our first target is somewhere on the U face. We can specify where the target is by looking at the second color of the UR piece, the RU sticker. It's green, which corresponds to the L face. So our our first target is UL.

Now we want to figure out what our second target will be, without actually solving the first target (we want to memorise the whole cycle before solving it blindfolded). After swapping UL with UR, we can see that the new sticker at UR will be green. Therefore, our second target will be somewhere on the L face. We can also see that the new sticker at RU will be red, which corresponds to the B face. So our our second target is LB.

This looks like you have to do quite some thinking during memorization, but really, it's not that hard. The way I describe finding the next target here is pretty long. In reality, when I memorise, the thaught process looks a lot more like this:

We can even write this down shorter: UL LB DF FR. This means that we want to shoot to UL, LB, DF an FR in that order. (You don't want to memorize this literly as UL LB DF FR! There are better ways to memorize. I'll tell you more about this later). To solve, we start by shooting the UR piece to UL. This will bring a new piece in the buffer position. The new piece has to go to LB. To solve, we shoot the new piece to LB. This will bring a new piece in the buffer position. The new piece has to go to DF... If we go on like this, our solution will look like this:

	[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.

5. Breaking into a new cycle

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:

	[shoot to UB]	R2 U' R2 - R U R' U' R' F R2 U' R' U' R U R' F' - R2 U R2
	[shoot to FL]	L' - R U R' U' R' F R2 U' R' U' R U R' F' - L
	[shoot to RD]	D' F L' F' - R U R' U' R' F R2 U' R' U' R U R' F' - F L F' D
	[shoot to LF]	d' L - R U R' U' R' F R2 U' R' U' R U R' F' - L' d

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.

6. How to flip edges

Sometimes, when you solved all the cycles, you will end up with 2 flipped (or an even number of edges). Look at the example in the below:

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.

7. Faster setup moves

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.

Here is a table, that shows you how to shoot to every position:

8. How to memorise the edges

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.

Stefan Pochmann's Method - The Corners

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:

Example solve

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

Ideas for speeding up

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):

A	B	C

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 ;).

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!