A 3-Cycle Guide to 3x3x3 Blindfold Cubing

Written and maintained by Shotaro Makisumi. Version 2.44140625 (third version) released on January 1, 2008. The nth version is version (1+1/(2^(n-1)))^(2^(n-1)).

A printer-friendly PDF of the latest version is available here (not up yet). To change the applets' color scheme, enter the colors in the order UDFBLR. E.g. the default setting is bwgyro. American color scheme with U white and F red would be wyrogb. You need to refresh the page to make a second change. List of color codes.

I originally discovered the 3-Cycle method on Olly's Cube Page in December of 2002. This guide aims to provide a more detailed explanation of the same method, with more algorithms provided for faster resolution. I should say, first of all, that I learned blindfold cubing and got my first successful solve in two days at the age of twelve. Blindfold cubing is not hard.

I used this method to achieve a time of 2 minutes 18.58 seconds in an official competition, the world record at the time. At the time of this writing, at least seven of the eleven cubers ever to have broken the two-minute mark in competition (Tyson Mao, Leyan Lo, Masayuki Akimoto, Chris Krueger, Rowe Hessler, Chris Hardwick, Shotaro Makisumi) use this method with only minor differences in algorithms.

I express my gratitude to Stefan Pochmann and Richard Carr for their valuable comments, and to Leyan Lo and Lucas Garron for supplying me with algorithms. I also owe a thousand thanks to my good friend Sunil Pedapudi for reading through the preliminary draft and encouraging me to finish this guide, all during his finals week. Of course, I alone am responsible for any remaining error. My hope is that this guide will be of some use to new blindfold cubers. The basic principles explained here--orientation before permutation, set-up moves, and cycles--can be applied to most other twisty puzzes; solving a new puzzle blindfolded can simply be a matter of finding a few basic algorithms with the help of commutators (see Corner Orientation).

I. Introduction
II. The Method
   A. Orientation
      i. Edge Orientation
      ii. Corner Orientation
   B. Permutation
      i. Cycle Method
      ii. Corner Permutation
         a. Cycles of length 3
         b. Cycles of length 2
      iii. Edge Permutation
         a. Cycles of length 3
         b. Cycles of length 2
      iv. Permutation Parity
III. Summary
IV. Memorization
V. Example Solves
VI. Links

I. Introduction

We start with the absolute basics: firstly, blindfold cubing isn't braille; secondly, when we say blindfold, we do not mean that we never look at the cube. Rather, the solver inspects the puzzle just once without applying any moves to it before solving without any aid of vision or of touch. When most cubers speak of blindfold cubing, they mean the kind in which both the memorization and the resolution are timed. In other words, the timer starts when we start inspecting the cube and ends when we solve it. There exists another category of blindfold cubing called "speed blindfold cubing," practiced most notably by Geir Ugelstad and Bertrand Bertage, in which only the resolution is timed. The method here is designed for the first type of blindfold cubing.

The method I present here is a relatively straightforward variation on a basic approach know as the cycle method. The defining difference from Richard Carr's piece-by-piece method is in the way permutation is resolved: through decomposition of permutation into cycles.

Whatever the method, cycle or piece-by-piece, the approach used in blindfold cubing is significantly different from that in speedcubing. A normal speedcubing method would force the solver to constantly update his memory because of the large number of pieces affected with every turn. We solve this problem by move only very few pieces in a very limited way at each step. We first split the procedure into four nearly independent parts: corner orientation, edge orientation, corner permutation, and edge permutation. Then, each part is separated into even smaller chunks of tasks--cycles, in our case--each of which and nothing else is then handled with a simple algorithm. Limiting the amount of work done at one time helps us to keep track of the state of the puzzle with ease; in fact, easy enough that some can solve a Rubik's Cube blindfolded in less than two minutes including memorization. At the same time, this limitation also means that we only need a handful of algorithms. Perhaps the only tricky part is how to apply them.

I have described below the theory and the method for orientation and then permutation according to the order in which they are solved. For each stage, I first discuss the theory and then present the algorithms used. Memorization is only briefly touched upon. The reason for this organization lies in my belief that the theory used in resolution is the key to understanding the system and the shortest path to mastering the method. Furthermore, memorization can be done in any order and be arranged in different ways. For these reason, I will present the most straightforward method of memorization for each step and leave the techniques to a separate section.

Practice blindfold cubing with your eyes open first, writing down the needed information on a piece of paper. Fast memorization can help only after an accurate understanding of the method is achieved.

Solving a Rubik's Cube blindfolded is not difficult; all we need is a decent short-term memory and the desire and persistence to reach the goal. And so, without further ado, I present:

II. The Method

There are four mostly independent properties of a Rubik's Cube configuration: edge orientation (EO), edge permutation (EP), corner orientation (CO), and corner permutation (CP). 3-Cycle method deals with each step separately, except for a possible permutation parity, which requires us to correct the permutation of two corners and two edges simultaneously. For each cubie (a corner or an edge), we memorize its orientation (flip) and its permutation (where it belongs). Since Rubik's Cube has 20 cubies, we can memorize all the information in a configuration by a string of at most 40 numbers. This number is in fact significantly reduced or eliminated altogether through memorization of visual images rather than numbers. Memorization techniques will be discussed later in its own section.

This particular variation on the cycle method is an orientation first method. Orientation of every piece is first corrected without disturbing the permutation, and then the permutation without disturbing the orientation. Doing orientation first keeps the memorization of orientation quite simple. (An alternative approach is to combine orientation and permutation, which can be accomplished through unrestricted use of set-up moves, as demonstrated by Stefan Pochmann.) Before starting with the method, we need some preparation.

We can now proceed to discuss the method itself.

A. Orientation

Orientation of a cubie is its flip or twist. For each piece, we pre-define a "correct orientation." Our first goal in this method is to correct the orientation of every piece without disturbing the permutation (i.e. flip the pieces in place). Unlike in permutation, edge and corners are completely independent for orientation. We can therefore choose to start with either edges or corners.

i. Edge Orientation

There are twelve edge pieces on a Rubik's Cube. Since each edge has two stickers, it can be twisted in two ways: correct and incorrect orientation. We define "correct" orientation of an edge to be the one that it can reach from the solved state within the (UDF2B2RL) group*, i.e. without quarter turns on F and B faces. The other orientations are "incorrect." From this definition, we can determine the orientation of an edge by (mentally) moving it to its correct position under this restriction. If the facelet colors match with the centers, the edge is correctly oriented. In official attempts we cannot make any moves during memorization.

*The first two versions of this guide were written with the restriction (UDFBR2L2), which most top blindfold cubers used before 2006. Either one will work as long as the set-up moves for edge permutation also follow the same restriction. Using (UDF2B2RL), however, has several advantages.

Here is one way to process this information quickly:

In U/D layer

In the middle layer

Although these rules can be stated more concisely, this best approximates the way many cubers actually go about determining the edge orientation of each piece.

Memorization: The only information we must memorize in this step is which edges are incorrectly oriented.

Resolution: To fix edge orientation, the following algorithms are useful:

The super-flip (all twelve edges) is not particularly useful unless we have ten or more incorrect edges.

Once we know how to determine the orientation, edge orientation is the easiest step. We can simply take two incorectly oriented edges at a time and flip them, which automatically corrects the orientation. To do this, we set up the two edges in question into one of the patterns above, apply the appropriate algorithm, and finally reverse the set-up move. For example, to orient edges 8 and 12, we set them up with F'DB2, orient 1 and 3, and reverse the set-up by B2D'F. This idea of set-up moves is similar to conjugation (at Jaap's Puzzle Page) and appears in each of the four steps of blindfold cubing. Note that there is no restriction on the set-up moves when fixing orientation, either edges or corners.

Since any solvable configuration of the cube has an even number of incorrectly oriented edges, we can correct the edge orientation of any scramble by using just the first algorithm provided above by correcting two edges at a time. The other algorithms often require clever set-up moves.

ii. Corner Orientation

Corner orientation is a bit trickier because there are three possible orientations for each corner: correct, clockwise (cw), and counter-clockwise (ccw). A corner is correctly oriented when its U/D-colored sticker is on U or D.

Correct

Clockwise (cw)

Counter Clockwise (ccw)

Suppose that we want to twist corner 2 ccw and corner 4 cw. A simple commutator involving A=(R'D'RD)x2, which rotates corner 2 ccw and leaves all other U layer pieces unchanged, is used to deal with such situation. We first apply A to twist corner 2. Then, do U2 to bring corner 4 to spot 2, and now perform the inverse of A: A'=(D'R'DR)x2. This twists corner 4 cw while leaving all other pieces on U unaffected and also repairs the damage done to the bottom two layers by A. Performing U2 places everything back to original position, and we have successfully oriented two corners. With appropriate number of U turns, a similar commutator of the form AUxA'U(-x) for x=0, 1, or 2 can to twist any two corners on U, one cw and the other ccw.

If corners in different layers need to be flipped, a set-up move, similar to the one used in edge orientation, is required to place them in the same layer. There is no restriction on this set-up move. For example, to flip corner 2 ccw and 5 cw, we can set up with L2, twist 2 ccw and 4 cw as before, and reverse the set-up with L2.

The fact that A has an order or 3 (i.e. AAA does nothing)can be used to extend this method even further. The following twist three corners ccw: AUAUAU2. In fact, any combination of A, U, and their inverses, with A performed 3n times and U 4m times for integers n and m, will only orient U-layer corners.

Memorization: Although corner orientation can be memorized by assigning {0,1,2} or {0,-,+} to each piece, a much simpler way is to visually memorize in which direction the U/D sticker points for each corner.

Resolution: Solve a pair of cw and ccw corners or three corners of the same orientation each time. This usually needs to be repeated several times to correct all corners. Recall that set-up moves have no restriction.

It is much easier to perform this if you turn the whole cube first with z'. Be sure, however, to perform z after the orientation.

Examples: Below are some common usages of the above algorithm. (ab) means to turn a ccw and b cw, and (abc cw) means turn a, b, and c all cw.

Here are some examples that require set-up moves:
(18): B'-U'AU'A'U2-B
(347 ccw): x'-U'AUAUAU'-x
(257 ccw): L'B'-U'AUAUAU'-BL

Although every corner permutation can be handled quite efficiently as shown using commutators, there are slightly faster non-commutator algorithms for special cases. We recommend that you learn any additional algorithms only after you can complete successful blindfold solves.

B. Permutation

Permutation is the placement of the pieces. Our goal is to move all pieces to their correct spot while preserving the orientation, which should already be solved. Like orientation, permutation is also divided into corners and edges; however, each scramble has a 50% chance of having a permutation parity, in which case we need to transpose a pair of edges and a pair of corners simultaneously. The same principle of set-up moves apply here, but with added restrictions to preserve the orientation.

i. Cycle Method

In the following explanation, remember that "corner 1" refers the corner in spot 1, not the corner that belongs to spot 1.

The permutation method explained here is know as the cycle method and is used for corners as well as edges. This is the defining difference between the 3-cycle method and the so-called piece-by-piece method. It is essential that you completely understand the material in this section; solving along cycles is the single most important thing to understand about this method.

The mathematically inclined readers will recall that every permutation can be decomposed into a product of disjoint cycles uniquely (up to the order of the cycles). Rephrased in a more ordinary language, we can rewrite every configuration of the corners, let's say, into a series of permutations in which pieces must moved in a cycle. For example, the cycle (123) means that corner 1 belongs to spot 2, 2 to 3, and 3 to 1. This decomposition of permutation into cycles can quite easily be achieved using the following:

1. Locate the smallest number that has not been written (the first time this number is 1).
     a. If such number exists, write down "(" and then that number.
     b. If all numbers have been written, stop.
2. Find the last number that was written. Determine to which spot this corner needs to be moved.
     a. If the number of this spot has not been written, write it down and repeat step 2.
     b. If the number of this spot has been written, write ")" to end the cycle. Go to step 1.

Note that a cycle of length one means that the piece is already in place. We may disregard such cycles altogether during memorization.

The best way to see how this works is to experiment using random scrambles. We provide one example for corner permutation.
Scramble (from a solved cube, with your chosen orientation of the cube): R2 F2 D' L2 B2 U' R2 B2 F2 D2 L2 D' B2 U' R' F R' L' U B D R' F D U'
Start a cycle with corner 1: (1
1 belongs to 2: (12
2 belongs to 8: (128
8 belongs to 6: (1286
6 belongs to 1, completing this cycle: (1286)
Start a new cycle with corner 3, the lowest corner not yet used: (1286)(3
3 belongs to 3, completing this cycle. We disregard this cycle: (1286)(3) or (1286)
Start a new cycle with corner 4: (1286)(4
4 belongs to 5: (1286)(45
5 belongs to 7: (1286)(457
7 belongs to 4, completing this cycle: (1286)(457)

Note we can start a new cycle using any corner that does not already belong in a cycle. However, always starting with the corner with the lowest possible number keeps the memorization simple, and less thinking means faster times. Although you must memorize everything in your head in official attempts, writing down the information on paper is a good practice when first working with cycles. Using the same scramble, try the same with the edges; you should get the cycles (1 5 8)(2 6)(4 12 11 7)(9 10).

Memorization: We apply the algorithm above for both corners and edges and memorize the resulting cycles.

Resolution: The 3-cycle method is so called because 3-cycles (cycles of length 3) are used to reduce the cycles. To solve a cycle, we reduce its length 2 at a time until it is of length 1 or 2. After reducing each cycle in this manner, remaining 2-cycles can be solved in pairs (double transposition). 2-cycles can only be solved in pairs. When one 2-cycle remains, we have a permutation parity; in this case we will have one 2-cycle for both corners and edges, and these must be solved together after every other cycle is solved. We use the following reduction rule:

Cycle Reduction Rule: A cycle of length 3 or longer, when its first 3 pieces are cycled, loses the second and the third number. (More generally, a cycle of length k or longer, when the first k pieces are cycled, loses the second through the k^th numbers.) In particular, cycles of length 3 are reduced to cycles of length 1, which can then be discarded from memory.

For example, applying (abc) reduces (abcde) to (ade). I leave it to the reader to figure out why this works. This analysis can be performed as the cuber solves the cube, and since numbers corresponding to solved pieces can be erased from memory, when all the information is gone, we know that our solve is complete.

We illustrate this procedure with the edges of the scramble we used above. We have (1 5 8)(2 6)(4 12 11 7)(9 10).
(1 5 8) solves the first cycle, leaving (2 6)(4 12 11 7)(9 10).
We ignore (2 6) for now because it is a 2-cycle.
(4 12 11) reduces the third cycle, leaving (2 6)(4 7)(9 10).
We ignore (4 7) and (9 10) for now because they are 2-cycles.
Since every cycle has now been reduced to a 2-cycle, we now use double transpositions. Performing (2 6)(4 7), for example, leaves (9 10).
Since one 2-cycle remains, we have a permutation parity (of course, we would have known this earlier had we solved the corners first).

Again, be sure that you completely understand how cycle reduction works. So how do we apply 3-cycles and double transpositions? We discuss the algorithms used in the following sections.

ii. Corner Permutation

For corner permutation, the set-up moves must stay within the (UDF2B2R2L2) group, meaning that it cannot use any quarter turn for the side faces (R, L, F, B). This limitation ensures that corner orientation is preserved.

a. Cycles of length 3

Any single algorithm that cycles 3 corners will work here. For convenience, we will use one that solves (123) and its mirror, which solves (214), both of which can be performed on either U or D face without disturbing orientation.

These algorithms, combined with proper set-up moves, can solve any cycle of three corners. If all three corners are in the same layer from the start, applying the algorithm is easy. Set-up moves come into play when corners of different layers need to be cycled. The entire procedure looks like this:

1. Set up corners within the (UDF2B2R2L2) group so that they are all on U or all on D face.
2. Permute the corners using either of the two algorithms.
3. Reverse the set-up moves.

Example: Suppose we have the cycle (175). The set-up moves R2D'B2 will bring the three pieces to (123). The first algorithm solves this cycle, and finally we reverse the set-up moves with B2DR2.

Double transposition CP(24)(37): (RB'R'B)x3 sometimes comes in handy in cases where set-up moves are otherwise difficult, namely the cases where 2 corners are placed at a diagonal. The hardest 3-cycle of corners involve two corners on a diagonal on one side and the third corner on the other. These can be handled effectively using this double transposition twice, or using the following algorithms:

b. Cycles of length 2

Cycles of length 2 can only be solved in pairs (double transposition). The same method and limitation of set-up moves apply here. The following three can be combined with set-up moves for efficiency:

In particular, the last algorithm, shown to me by Dror Vomberg at WC2003, can be used to avoid long set-up moves in otherwise difficult cases.

Here is one systematic way of dealing with all possible double transposition of corners involving both U and D layers, reached by U/D/x2. Of course, there are many other ways to handle these cases, and they can all be handled with E/X and clever set-up moves without any prior memorization.

If one cycle of length 2 remains at the end, we have a permutation parity. Leave this alone but keep it memorized and go on to the edges. We will solve 2 corners and 2 edges at the end of the solve.

iii. Edge Permutation

For many people, edge permutation is the hardest part of the 3-cycle method because it involves twelve pieces, more than the number of corners. However, the exact same approach used for corners also applies here; we will still use 3-cycles to reduce the cycles one after another. The only difference is that the set-up moves must now stay within the (UDF2B2RL) group, meaning no F/B single turns, to preserve the orientation. We have more freedom in the set-up moves than for corners, but this also means that we have to make sure to remember them correctly. For example, we may be able to use either B'R2 or R2B'. One of the most frustrating mistakes is to, after performing a cycle, forget which move we started with. Rules on which moves to do for set-up first are useful here. For example, whenever possible, do U/D first, F/B next, and finally R/L.

a. Cycles of length 3

As with corners, it is useful to know the 3-cycle in both directions:

These can be performed on U, D, R, and L faces without disturbing the orientation. Another useful 3-cycle, which, although optional, can often save a few moves, is the following and its many variations:

This can be used in any direction and on any side without disturbing the edge orientation. Of course, since every 3-cycle can be solved with either EP(243) or EP(423), we recommend that you learn to use this algorithm only after you are comfortable using the first two, and certainly not before you can complete a solve successfully.

Example: Suppose we want to do EP(356). The most basic solution is to set up the pieces on top with L'UL2, use EP(243), and reverse the set-up moves with L2U'L. More simply, recalling that EP(243) and EP(423) work on R/L faces as well, we can set up with U2 and perform EP(423) on L.

In every 3-cycle, the direction can be determined by just noting where one of the three pieces go. Therefore, during the set-up moves, it is enough to keep track of where the pieces go and where just one piece belongs to.

b. Cycles of length 2

Here, H and Z permutations are the most basic and useful.

Z can only be used on U/D/R/L faces while H works on any face without disturbing the orientation. We also have the following useful algorithms:

These can be applied in any direction and on any face.

Example: Suppose we want to do EP(2 8)(6 12). The most obvious way is to set up with F'B'R2U' and use EP(14)(23). We could also set-up with D'L2F and use EP(14)(23) on F.

iv. Permutation Parity

50% of solves will have a permutation parity, meaning an odd permutation of edges and, consequently, an odd permutation of the corners. Following the procedure thus far, these cases are reduced to 2 corners and 2 edges.

Blindfold cubers have not reached a consensus on how best to deal with the permutation parity. Perhaps the easiest method is to solve the corners using T permutation and the four edges using H permutation:

Alternative, any of the PLL algorithms that swap two corners and two edges can be used together with appropriate set-up moves.

Example: CP(17) EP(18)

Using the first method, we first do CP(17) EP(24) with B2U2-(T permutation)-U2B2, reducing the permutation to EP(18)(24). Now this can be handled by UR-(H permutation)-R'U'. Using a longer set-up move, we can do this using one T-permutation: URU'RU'-(T permutation)-UR'UR'U'. With some insight, we can also see another nice solution: U'-(Y permutation on R)-U. This works because diagonal transposition on any face does not disturb the corner orientation.

Permutation parity does not have to be solved at the very end. If we realize that we have parity half way into solving the permutation, we can correct the parity at an easier time. If the two pieces to be swapped are consecutive in a cycle, remember to modify this by erasing the second piece.

For many people, permutation parity is the hardest part of blindfold cubing, and it is indeed very frustrating to solve everything else successfully and make a mistake at the very last step, on the parity. One way to avoid parities altogether is to determine the parity during inspection from the corners (corners are usually easier since there are fewer pieces). Parity is even (no parity fix necessary) if and only if the number of cycles of even length is even. If there is a parity, we can perform U at the beginning of the solve to change this (a 4-cycle is an odd permutation). Since we cannot make any move during inspection, however, we must rememorize the permutation after an imaginary U.

III. Summary

With the understanding of the above material, we can now walk through a blindfold solve using this method.

Memorization

Memorization of the four parts can be done in any order. Here, we will discuss them in the following order: EP, CP, EO, CO. My reason for using this order is explained in the next section, IV. Memorization.

Edge Permutation: Using the Cycle Decomposition algorithm described in II. B. i. Cycle Method, obtain in cycle notation the permutation of twelve edges. Memorize this.
Corner Permutation: Repeat the above for the eight corners, memorizing the cycles. Be sure to distinguish these from the permutation of edges.
Edge Orientation: Using the method explained in II. A. i. Edge Orientation, determine the orientation of each edge and memorize which edges are incorrectly oriented.
Corner Orientation: Memorize the direction in which the U/D sticker of each corner points.

Resolution

Orientation must be solved completely before permutation. However, it does not matter whether we solve corner orientation or edge orientation first, and same for corner and edge permutation. Parity error may be fixed at any time during permutation. The idea of set-up moves is crucial to understanding how we apply the algorithms.

Corner Orientation: Using set-up moves and a commutator of (R'D'RD)x2 and U, solve one cw and one ccw or three in same orientation. This must usually be repeated several times to correct all orientation. Corners whose orientation is fixed may be erased from memory.
Edge Orientation: Using set-up moves and appropriate edge-orientation algorithms, flip the incorrectly oriented edges. The ones that are flipped may be erased from memory.
Corner Permutation: Following the Cycle Reduction Rule described in II. B. i. Cycle Method, apply algorithms to reduce cycles of length 3 or longer. Solve each pair of cycles of length 2 with the appropriate algorithms. Set-up moves must be within (UDF2B2R2L2) group. In case a single cycle of length 2 is left, move on to edge permutation.
Edge Permutation: Repeat the same procedure for edges. Set-up moves must be within (UDF2B2RL) group.
Parity Fix (if necessary): Use set-up moves and appropriate PLL algorithms.

IV. Memorization (not complete)

For now, read this post. I visually memorize the patterns of the cycles (triangles, Z-like zigzags, parallel lines, etc).

V. Example Solves

Here are two walk-throughs of the method described above using random scrambles generated by JNetCube.

For CO, (ab) means that a is to be turned ccw and b cw.

If you have understood the method correctly, you should now be able to solve a Rubik’s Cube blindfolded. Good luck!

VI. Links

Menu

Cubefreak Home

About Webmaster

Records

Cube Glossary

Speedcubing

Notation

Cross

F2L

OLL

PLL

Misc. Techniques

Speedcubing Tips

Blindfold Cubing

Videos

Others

Links

Contact Me

News Archive

Best viewed in Firefox
Resolution 1024x768
Created by
Shotaro Makisumi

Chatter

© 2007, Shotaro Makisumi