Rubik's cube - blindfolded solving


This site is primarily designed for connoisseurs who want to experience a new challenge with the 3x3x3 Rubik's cube (but also a 2x2x2 Rubik's cube, for instance). Blindfolded solving is meant by that challenge. To be more specific, you have to inspect (and memorize) randomly scrambled cube at first, then you put on some kind of blindfold (a scarf, for example), solve the cube and finally take off a blindfold. You might be thinking: "But that's impossible - more than 43 000 000 000 000 000 000 configurations. How the hell do I find the only correct one - so that the cube would be solved - considering I don't see the puzzle?" I must disappoint you, it is possible after all!

While it is not necessary for a blindfolded solving to be able to solve a cube "traditional way" (using your eyes), it is strongly recommended. Make sure you are familiar with the notation, otherwise it is not worth to read further.

The method (so-called Classic Pochmann, also known as Old Pochmann) which I describe below was invented by a German cuber Stefan Pochmann in 2004. I reached the best time of just a little bit under 3 and a half minutes (including memorization) with this method, but there are also known cases in which the cube was solved in less than 1 minute.

What does a blindfolded solving involve? Above all, a good memory. What is meant by the word "good"? Your cell phone number + national identification number. Really, if you can remember these two data, you are perfectly ready to solve a Rubik's cube while blindfolded. Stefan Pochmann himself is saying: "Anyone can solve the 3x3x3 blindfolded. At least any speedcuber ;-)". I fully agree with his statement.

On this page you will find:

Used terms - glossary

This section includes something like a glossary of terms which will be needed during a solve. It's not a must to understand the terms now, their meaning will be obvious after they appear in the text anyway.

starting position (as known as a buffer) - position from which a cubie moves to the target position, thus being solved
target position - location to which a cubie is moved from a buffer
setup move - adjusting move that must be made in order to place a cubie from the starting position to the target position correctly. It has a cubie orientation meaning
parity problem - state in which it is needed, as a result of an odd number of edge cycles, to permute upper right corners (more about parity problem)
object - memory unit. Each edge should be formed by two unique, mutually non-interchangeable objects. Each corner should be formed by three unique, mutually non-interchangeable objects

That's it. We're going to solve it!

List of needed algorithms

Unlike the intuitive method, for a blindfolded solving you will need some algorithms. The list is written in the table.

Algorithms used for edges
name
algorithm
example of algorithm
meaning
T
R2 U' R2 U R2 U D' R2 U R2 U' R2 D
permutation of edges at the UR and UL positions
J(a)
L U' R' U L' U2' R U' R' U2' R
permutation of edges at the UR and UB positions
J(b)
L' U R U' L U2 R' U R U2 R'
permutation of edges at the UR and UF positions
Algorithms used for solving a parity problem
name
algorithm
example of algorithm
meaning
T
R2 U' R2 U R2 U D' R2 U R2 U' R2 D
permutation of edges at the UR and UL positions, as well as permutation of corners at the URF and URB positions
U
R2 U' R' U' R U R U R U' R
permutation of three edges: UR => UB, UB => UL, UL => UR
Algorithm used for corners
name
algorithm
example of algorithm
meaning
Y
R U' R' U' R U R' F' R U R' U' R' F R
swap of a corner at the ULB position with a corner at the RDF position


A few words regarding the table:

  • in general, only one algorithm (T, J(a) or J(b)) can be used for a successful blindfolded solving. However, I highly suggest to learn all the above ones. By that, you will avoid many troubles, plus the algorithms are easy to learn and there are not many of them
  • if you are wondering why a T algorithm swaps only two edges and no corners - similarly to J(a) or J(b) - then you should know that these algorithms are executed in pairs (otherwise the group theory paragraph wouldn't be applicable). It means that when you execute a T, followed by e.g. a J(b), the corners will remain unchanged. Only some edges will be permuted
  • the corners will be swapped in case of a parity problem, since unlike the previous point, a T algorithm will be executed only once (hence not in pairs)
  • if you use PLL for a classical solving (I don't assume that but it can happen nonetheless), you don't need to learn a single algorithm from the table - you already know all of them

Step by step illustrative examples

The last thing to mention prior to solving itself is a fact that each edge has two possible ways of orientation (each corner has even three of them). They are of great importance in a blindfolded solving, see two following simulators.

starting position of the edge is UR (so we are solving the red-green edge), target position of the edge is RF. Setup moves are d' (the same as D' but for two layers) L'. Inverse setup moves are L d. So in short: setup moves (d' L'), T, inverse setup moves (L d). starting position of the edge is UR (so we are solving the green-red edge), target position of the edge is FR. Setup moves are d2' (the same as D2 but for two layers) L. Inverse setup moves are L' d2. So in short: setup moves (d2' L), T, inverse setup moves (L' d2).

And now, we finally come to the actual solving, which you are all so much excited about. I will try to explain the principle of the whole method, and at the same time I will use the interactive animated cube simulators in order to do so. At this stage, the focus is just on a principle as such, so I'll explain how to memorize all this stuff later. Let's scramble the cube as follows: D L' F L2 F2 L' R2 U2 L2 B' R2 U R2 B' R2 L' D2 U' R2 D' B' D2 F R' B' D' - see a simulator. If you have a different cube color scheme, do not be despaired. The solving process is actually constant. First we will start by solving the edges. Starting position is UR (green-orange edge on a simulator).

Green-orange edge at the UR starting position needs to be moved to the FL position. We will use a setup move L' [move 1], followed by a T [moves 2-14], then we execute an inverse setup move L [move 15].

Now a yellow-orange edge is at the starting position. Its target position is DL, therefore we will make a setup move L2 [move 16], followed by a T [moves 17-29]. Then we execute an inverse setup move, i.e. L2' [move 30].

Next, a red-blue edge is at the starting position and it belongs to the RB position. As the setup moves we will make d L [moves 31-32], followed by a T [moves 33-45] and the inverse setup moves L' d' [moves 46-47].

Blue-white edge goes to the BU position by means of a setup move l [move 48]. The edges are swapped by a J(b) [moves 49-59]. It is followed by an inverse setup move l' [move 60].

Green-white edge belongs to the UF position. No setup move is required, we will just execute a J(b) [moves 61-71].

Green-yellow edge moves to the FD position by means of a setup move l' [move 72], followed by a J(b) [moves 73-83] and an inverse setup move l [move 84].

Blue-orange edge has to go to the BL position. We will achieve it by using a setup move L [move 85], followed by a T [moves 86-98] and an inverse setup move L' [move 99].

LOOK OUT! An edge at the starting position is also at the target position (only oriented incorrectly). What now? Well, what if we tried to solve the remaining 11 edges? First, many of those 11 ones we have already solved and second, a group theory paragraph implies that the twelfth one will be automatically solved too. So let's simply try to swap an edge at the UR position with some "unsolved" one, e.g. at the UL position - that one doesn't require any setup move - by means of a T [moves 100-112]. Now we can continue in solving.

Yellow-red edge needs to be placed at the DR position. We will reach that by the setup moves D2 L2 [moves 113-114], followed by a T [moves 115-127] and the inverse setup moves L2' D2' [moves 128-129].

Green-red edge goes to the FR position with the help of the setup moves d2 L [moves 130-131], followed by a T [moves 132-144] and the inverse setup moves L' d2' [moves 145-146].

White-orange edge goes to the UL position. No setup moves are needed, we will just execute a T [moves 147-159].

Once again, an edge is at the starting and at the same time target position. Well, we have no choice but to swap it with the last unsolved edge, at the DB position to be more precise. The setup moves are D L2 [moves 160-161], followed by a T [moves 162-174] and the inverse setup moves L2' D' [moves 175-176]. Note: clearly, l as a setup move could be also applied, subsequently followed by a J(a) and an inverse setup move l'.

Blue-yellow edge belongs to the BD position. We will get it there by using a setup move l [move 177], followed by a J(a) [moves 178-188] and an inverse setup move l' [move 189].

The edges are solved. However, since an odd number of edge swaps has been used to do that, i.e. the sum of J(a) + J(b) + T = odd number, a side effect occurred on the cube. Two right upper corners has been swapped (deliberately look at the appearance of the right upper corners before the first move and after the 189th move on the previous simulator). This side effect is called a parity problem. If the sum of J(a) + J(b) + T is an even number, a parity problem wouldn't be met. It can be solved as follows:

By executing a T [moves 1-13] we shall simply get the corners back to their initial position (i.e. as they appear on the cube before the first move is made). It, however, also permutes edges at the UR and UL positions. Therefore, we will execute a U [moves 14-24], thus getting a situation in which the edges at the UB and UL positions are mutually swapped.

This can be used in solving of corners because similarly to a T - swap of two edges (UR and UL) and swap of two corners (URF and URB) as a side effect - even for the corners is applied the same principle of swaps. Only this time, edges at the UB and UL positions will be permuted, as well as corners at the ULB and RDF positions.

If you understood an edge solving principle, solving of corners shouldn't be beyond your powers. In fact, the same procedure is being used. However, a recognition of the setup moves can be slightly confusing at the beginning. What's going on...

First off, it is convenient to emphasize that the color of a sticker at the U position is important for a corner at the ULB starting position. Similarly, the color of a sticker at the R position is important for a corner at the RDF position. If it doesn't make sense to you, just look at a Y in the table above. Red color is important for a corner at the ULB position in the table, and similarly white color is important for a corner at the RDF position there. These two colors are being swapped (whole corners are being swapped, of course). If you're still stuck, don't worry - you will get it from the example.

Green-red-yellow corner at the ULB starting position needs to be moved to the FRD position. For this purpose we can use the setup moves D R [moves 1-2], followed by a Y [moves 3-17] and the inverse setup moves R' D' [moves 18-19].

Blue-yellow-red corner is now at the starting position. Its target position is BRD so we will make a setup move D' [move 20], followed by a Y [moves 21-35]. Then we execute an inverse setup move D [move 36].

Now we have a blue-red-white corner at the starting position. It belong to the BRU position. Using the setup moves R' F [moves 37-38] and a Y [moves 39-53] we will swap the corners. The inverse setup moves are F' R [moves 54-55].

White-red-green corner goes to the URF position by means of a setup move F [move 56]. Subsequently a Y [moves 57-71] is made. An inverse setup moves is F' [move 72].

LOOK OUT! A corner at the starting position is simultaneously at the target position (coincidentally with a correct orientation). What now? Well, we already met this situation at the edges, and the solution here is analogical. Let's simply try to solve the remaining 7 corners (some of them are already solved) because a group theory paragraph implies that the eighth one will be automatically solved as well. Hence swap ULB corner with some unsolved one. The easiest setup move is D [move 73], followed by a swap of corners using a Y [moves 74-88]. An inverse setup move is D' [move 89].

Yellow-blue-orange corner goes to the DBL position by means of the setup moves D F' [moves 90-91]. Then a Y [moves 92-106] is executed, followed by the inverse setup moves F D' [moves 107-108].

Green-yellow-orange corner belongs to the FDL position. We will get it there using a setup move D [move 109], followed by a Y [moves 110-124] and an inverse setup move D' [move 125].

The corners are solved, thus the whole cube is solved.

A bit of theory - conjugations

A conjugation (more precisely a conjugated permutation) is a powerful weapon for solving the combinatorial puzzles more or less intuitively. Mathematically it can be described as A B A' and it is being used to influence only a few pieces on the puzzle. Both A and B may comprise some move sequences, an inverse sequence is denoted by an apostrophe. A typical application of conjugations is in blindfolded solving.

Algorithm permuting
3 edges in order:
UR => UB, UB => UL, UL => UR
Example of conjugation application: A = U'F'U'
B = R2U'R'U'RURURU'R
A' = UFU
Algorithm permuting two corners
in order: ULB => RDF, RDF => ULB

(we won't take a side effect,
i.e. a permutation of edges at the
UL and UB positions, into
consideration, since its significance
for a conjugation isn't essential)
Example of conjugation application: A1 = F
B1 = RU'R'U'RUR'F'RUR'U'R'FR
A'1 = F'
A2 = RD'
B2 = RU'R'U'RUR'F'RUR'U'R'FR
A'2 = DR'

How do the conjugations work? Quite simply. Let's explain their principle using the four simulators mentioned above.

On top of them, an algorithm (sequence of successive moves) which permutes three edges is executed. As it was chosen on the ground of less number of moves, this algorithm isn't intuitive. Of course it is possible to use also an intuitive variant.

On the second simulator from the top is shown a situation in which it is needed to permute the edges at positions UR => RF, RF => UF, UF => UR. However, (let's pretend) we can only permute the edges at positions UR => UB, UB => UL, UL => UR. Well, how is that useful? Let's use conjugation properties! If we somehow managed to get the UR, RF and UF edges to the UL, UR and UB positions, we could permute them by means of the algorithm presented on the first simulator. And that's the goal of the second simulator. First part of a conjugation (A) is setting three edges - the UR, RF, and UF ones to the UL, UR and UB positions. Second part of a conjugation (B) is doing a permutation of these three edges. About the third part of a conjugation (A') it can be said that it returns the puzzle to its original state before a conjugation execution, but what's more, the chosen pieces are solved.

On the third simulator from the top is illustrated an algorithm by which two corners - the ULB and RDF ones (plus the UB and UF edges) - can be permuted.

We will use this knowledge on the last simulator, where one can see two conjugations. The ULB corner belongs to the URF position, but (let's pretend) we can swap it only with the RDF corner. Therefore, first part of the first conjugation (A1) places a corner from the URF position to the RFD position in such a way that both UB and UR edges wouldn't be influenced. Mentioned edges are, during a further solving, cyclically swapped with each other and if the UL edge would be swapped with e.g. RB edge in one cycle (as a result of executing a B move between particular cycles), it would lead, as a final consequence, to a scrambling of edges (and at the same time scrambling of corners because the ULB and RDF corners are being permuted on the third simulator from the top (i.e. not the RUB and RDF ones, which we would get after a B move)). Second part of the first conjugation (B1) is doing a swap of the ULB and RDF corners. Third part of the first conjugation (A'1) "aligns" the puzzle to its initial state with the difference that now the original corner at the ULB position is solved (and simultaneously the edges at the UB and UF positions are swapped). Second conjugation on this simulator analogically solves the remaining corners (and edges).

Essentially, the entire process of blindfolded solving of the 3x3x3 Rubik's cube is a beautiful example of conjugation applications.

In order to have the narration complete, there must be a link to the commutators which can be, for example, utilized in a tutorial on how to solve the Rubik's cube. Both conjugations and commutators are widely used for intuitive solving of combinatorial puzzles.

Memory methods

In the introduction a number of combinations for the Rubik's cube, as well as the necessity to remember your mobile phone number + national identification number, has been mentioned. How are these parameters related to each other? Seemingly nowise. Nevertheless, such an enormous number (more than 4.3·1019) can be transformed into a few digits. Count with me.

The centers (center cubies) always maintain the same mutual orientation on a classical 3x3x3 cube, regardless of which layer is being rotated. In other words, centers can not be mutually swapped (moved, permuted). Thus they are fixed, hence solved (since they can't be moved - when scrambling a cube, for instance). Therefore, we don't need to memorize them at all for the purposes of blindfolded solving.

Both edges and corners may be swapped with each other (corners with corners and edges with edges - never a corner with an edge, or an edge with a corner, if you like). All edges and all corners must be memorized somehow. Expressed in the language of numbers, it is that terribly big number because a cube is consisted of corners and edges (let's pretend we memorize them someway) and centers (which we can ignore). If we assign digits to individual edges - there are 12 of them on the cube in total (ok, there are only 10 different digits, so for the two remaining edges we would have to choose another memory unit - but you know what I wanted to say by that) - as well as individual corners (there are 8 of them on a cube in total), as a result we will get a number containing 20 digits (12 + 8). Mobile phone number in international format (+420) contains 12 digits and a national identification number contains 10 digits (in the Czech Republic). 12 + 10 = 22, so even two more digits than we would need for assigning of particular digits in this sum to all edges and corners on a cube.

All in all, if we assign individual digit of a phone number + national identification number to individual edges + corners (centers can be ignored), we will obtain an exact information about where every cubie occurs on a cube.

But how to assign? As the simplest way I find to look at one edge as being two objects (because of two possible edge orientations) and one corner as being three objects (because of three possible corner orientations). The object can be a number, a letter, a picture, a name, a person, an animal - in short, anything. Everyone should choose something easily memorable for him/her. Let the cube is scrambled as follows (see next simulator):

Numbers will be used as objects in this example. So let's denote a white color on edge at the UR position as 1, and a green color as 2. Now move on to an edge at the UF position: let's denote a white color by a number 3, an orange color by a number 4. Description for an edge at the UL position looks like this: white color = 5, red color = 6. If we proceed in this fashion for all edges, the last edge will have numbers 23 and 24. We further know that the starting edge position for both T, J(a) and J(b) is UR. The target position for a white-green edge is UF. However, it is sufficient to memorize a number 3 (and subsequently execute an algorithm which permutes a color (well, a whole edge) from a number 1 to a number 3 - i.e. a J(b)). By doing so, the initial number 3 will move to a number 1, and vice versa [moves 1-11]. Now a white-orange edge is at the UR starting position. Just memorize a number 5 and execute an algorithm, in this case it's a T. By that, white-orange edge will move to a position of a white-red edge, and vice versa [moves 12-24]. Since a white-red edge belongs to the UR position, we don't have to memorize anything for it. Therefore, for the situation illustrated on a simulator it is sufficient to memorize only a couple of digits: 3 5.

The same memorizing principle applies to the corners. Let the cube is scrambled as follows (see next simulator):

Letters will be used to memorize corners in this example. White-green-orange corner: b, c, d for particular colors. White-orange-blue corner: e, f, g and finally a white-red-green corner: h, i, j. For the first swap of corners it is sufficient to memorize b. We will do a setup move F [move 1], followed by a Y [moves 2-16] and an inverse setup move F' [move 17]. For the second swap it is sufficient to memorize a letter e. We will execute the setup moves F R' [moves 18-19], followed by a Y [moves 20-34] and finally the inverse setup moves R F' [moves 35-36]. Memorizing phrase for the situation depicted on a simulator is hence: b e.


What does it all tell us?

  • We don't need to take centers into account at all in a memorizing phase. They only serve as the reference points for edges and corners
  • For edges it is needed to have a list of 22 (11·2) possible objects. Starting position doesn't need to have objects
  • For corners it is needed to have a list of 21 (7·3) possible objects. Starting position doesn't need to have objects
  • For a parity problem it is needed to have 1 object
  • 43 252 003 274 489 856 000 different combinations can be "transformed" into 20 objects (actually cca. 23 ones due to the possibility for cubies to be at the starting and simultaneously target position)

Tips, pieces of advice and recommendation

At last, I would like to add a few more or less important notes.

  • When applying setup moves for the edges, you don't have to "unbuild" the upper-right corners (URF and URB ones to be more specific). Thus I don't recommend to use the F (F') or B (B') moves at all. The same applies to solving of corners by the B (B') or L (L') moves because you don't have to "unbuild" the edges at the UB and UL positions. The reason is obvious: when you don't execute algorithms (i.e. when you don't permute two particular cubies) in pairs, it will lead to a scrambled cube. An exception is a parity problem but we can solve it.
  • The most common error-sources are difficult setup moves. For both edges and corners you shouldn't be using more than two setup moves (+ two inverse setup moves).
  • Although it is possible, on principle, to use only one algorithm to solve both edges and corners, I don't recommend it strictly. The reason is that a number of setup moves will increase.
  • While memorizing, it is advisable to check the orientation of cubies to which no object is linked. If, for instance, you have a cube scrambled so that two edges are placed correctly but oriented incorrectly, it is necessary to treat this case - to memorize it apart. Since the edges are correctly permuted, no object is linking to them. It often happens that after finishing a solve, a cube is solved except for the cubies we didn't treat in a memorizing process.
  • After memorization of edges (corners) is done, I recommend to count a number of objects, i.e. the sum of T, J(a) and J(b) (Y). If the result is an odd number, you will encounter a parity problem. If the result is an even number, you won't meet a parity problem.
  • In this tutorial, a parity problem is always solved after finishing the edges and before solving the corners.
  • To verify non-bindingly the correctness of memorization, use following trick: if a number of memorized objects for edges is odd (hence you will meet a parity problem), a number of memorized objects for corners will be odd, too. If a number of memorized objects for edges is even (hence you won't encounter a parity problem), a number of memorized objects for corners will be even as well.
  • The more interesting form of memorizing you choose, the more easily you will memorize the objects. Consider a composition of letters into words, for instance. Artificially create sentences from the words and remember some sort of story (or just a few words instead of several consecutive letters). Another alternative is to memorize the objects as the target positions themselves. For example, some edge could go to the UL position (instead of UL, we could memorize the word unlucky), subsequent edge could go to the BU position (bull), next edge could be moved to BR (Bender Rodríguez - a character from animated sitcom Futurama, it is sufficient to remember just Bender), etc. Then the story could be something like this: Unlucky bull laughed at Bender, because... A variation may be to memorize the colors occurring on cubies. For example, green-yellow edge can be represented by a banana (first green, then yellow), under a green-orange edge can be imagined an orange (first green, then orange), green-white edge can be approximated by a Christmas tree (green tree covered with white snow). The story could be as follows: the banana and orange are hanging on a Christmas tree... Less reality, more fantasy. There are no limits for it. Numbers suit to someone, however, someone else might prefer direct visual memory. Personally, I use letters for edges and numbers for corners.
  • There are more efficient ways how to orient two or more cubies at once. Nevertheless, additional algorithms are required to be memorized, plus the orientation of cubies can be always solved even without these supplementary algorithms.

World record videos

As a football has FIFA and athletics has IAAF, also the 3x3x3 Rubik's cube has some sort of board that organizes the competitions worldwide. It is WCA - World Cube Association. Thus it can be officially competed in a blindfolded solving of the Rubik's cube, even in several events - not only in a classical 3x3x3 Rubik's cube (newly, since 2014, it is also competed in a format in which competitor's arithmetic mean of all three attempts done in a given round is counted), but in the 4x4x4 Rubik's cube or 5x5x5 Rubik's cube (newly, since 2019, you can also compete in a format in which your arithmetic mean of all three attempts done in a given round is counted), too. Moreover, there is a mind-boggling event of multiple 3x3x3 cubes blindfolded solving.

event: 3x3x3 blindfolded, single solve
name: Max Hilliard (USA)
result: 15.50 s
scramble: available upon request
solution: available upon request
cube brand: MoYu WeiLong GTS
solving method: 3-style
personal opinion on used method: see below
competition: CubingUSA Nationals; 1-4. 8. 2019; USA



event: 3x3x3 blindfolded, average solve
name: Jeff Park (USA)
result: 18.18 s
scrambles: available upon request
solutions: available upon request
cube brand: DaYan TengYun M
solving method: 3-style
personal opinion on used method: see below
competition: OU Winter 2019; 14. 12. 2019; USA



event: 4x4x4 blindfolded, single solve
name: Stanley Chapel (USA)
result: 1:02.51 s
scramble: available upon request
solution: available upon request
cube brand: MoYu AoSu GTS2 M
solving methods: commutators and conjugations
personal opinion on used methods: see below
competition: Michigan Cubing Club Epsilon; 15. 12. 2019; USA



event: 4x4x4 blindfolded, average solve
name: Stanley Chapel (USA)
result: 1:08.76 s
scrambles: available upon request
solutions: available upon request
cube brand: MoYu AoSu GTS2 M
solving methods: commutators and conjugations
personal opinion on used methods: see below
competition: Michigan Cubing Club Epsilon; 15. 12. 2019; USA



event: 5x5x5 blindfolded, single solve
name: Stanley Chapel (USA)
result: 2:21.62 s
scramble: available upon request
solution: available upon request
cube brand: Valk 5 M
solving methods: commutators and conjugations
personal opinion on used methods: see below
competition: Michigan Cubing Club Epsilon; 15. 12. 2019; USA



event: 5x5x5 blindfolded, average solve
name: Stanley Chapel (USA)
result: 2:27.63 s
scrambles: available upon request
solutions: available upon request
cube brand: Valk 5 M
solving methods: commutators and conjugations
personal opinion on used methods: see below
competition: Michigan Cubing Club Epsilon; 15. 12. 2019; USA


The best for the end. Only a few folks in the world can combine speed solving with speed memorizing (time limit of 1 hour), considering you have less than 75 seconds altogether per one 3x3x3 cube. Competitor receives 1 point for each solved cube and loses 1 point for each unsolved one. Overall result is determined by a difference between solved and unsolved cubes. In case of point equality, elapsed time arbitrates.



event: multiple 3x3x3 cubes blindfolded
name: Graham Siggins (USA)
result: 58 points: 59/60 (59:46 minutes)
solving method: 3-style
personal opinion on used method: see below
competition: OSU Blind Weekend; 8-10. 11. 2019; USA


If you find a so-called speedcubing interesting, check out an article about where to buy a Rubik's cube, what cube is the best and how to solve it faster.


Personal opinion on methods used in the world records


3x3x3 Rubik's cube blindfolded:

I have lost myself in trends and terminology regarding a blindfolded solving long time ago. It is therefore possible that my writing won't be only outdated and obsolete, but also completely out of fashion.

From what I have observed, and based on what have been confirmed to me by people who understand a blindfolded solving far more than I do, for speed solving is particularly used a "freestyle". Unfortunately, it is not well-defined term and everyone imagines something different under it. Allegedly it can be comprehended as the use of 3-cycles (commutators). Those may be optimized from two standpoints. We are talking about either move-optimal solve (in that case it is the BH) or speed-optimal commutators, conjugations if you like (in this case it is the 3-style). I find that as a stumbling-block because what is speed-optimal for one doesn't need to be speed-optimal for another one, and vice versa.

At this moment I will act a little bit like a mind-reader and try to guess what methods are most frequently used by the fastest guys. In my opinion, M2, TuRBo or BH are very popular to speedsolve the edges. Classic Pochmann, BH or 3OP (about which I know nothing, so don't take my words too seriously) are suitable to speedsolve the corners.

It is interesting to notice that Zane Carney (former world record holder for multiple cubes blindfolded solving), who uses 3-style of course, solves 1 cube by corners-first and edges-last method, while for multiple cubes he uses reversed order, i.e. edges-first and corners-last approach.

4x4x4 and 5x5x5 Rubik's cubes blindfolded:

With this somewhat extreme kind of solving I have no experience.

According to the experts, a world record for both 4x4x4 and 5x5x5 was set using a 3-style method (speed-optimal commutators, conjugations if you like).

I believe commutators (conjugations, if you like) are always necessary to use in order to solve big cubes (4x4x4 and above) blindfolded. It only depends on whether they will be move-optimal, speed-optimal or absolutely non-optimal :-).



The page was graphically improved by Michael Feather.