Memorization: The only information we must memorize in this step is which edges have wrong orientation.

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

There is of course the super-flip (all twelve edges), but this is not too useful unless we have 10 or more bad edges.

Once we know how to determine the orientation, edge orientation is the easiest step.. We can simply tale two incorectly oriented edges at a time and flip them, which automatically corects the orientation. To fix a given orientation, we set up the edges to be oriented first into one of the above configurations. Then, we apply an algorithm to correct these edges, and reverse the set-up move to finish. For example, to orient edges 8 and 12, we can do F'DB2 to set up, 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 setup moves when fixing orientation. Of the algorithms above, only the first algorithm is necessary. We can always fix two edges at a time. The others should only be used when the set-up move is relatively easy.

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 is used to deal with such situation. A=(R'D'RD)x2 is the basic move that rotates corner 2 ccw and leaves all other pieces on the U layer untouched. We first do this move to twist corner 2. Then, do U2 to bring corner 4 to spot 2, and now do the inverse of the basic move: A'=(D'R'DR)x2. This twists this piece cw while leaving all other pieces on U affected, and also repairs the damage done to the bottom two layers by the basic move. Performing U2 gets everything back to original position, and we have successfully oriented two corners. With appropriate number of U turns, this commutator can to twist any one corner on U cw and another on U ccw. If corners of different layer need to be solved, a set-up move is required to place them in the same layer. There is no restriction on this set-up moves.

The fact that A has an order or 3 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 corners of the U layer.

Memorization: There is a system for representing orientation using 0, 1, and 2, but there is no need to use this. Rather, visually memorize to which direction the U/D sticker of each corner points.

Resolution: Solve a pair of cw and ccw corners or three corners of the same orientation each time. This must usually be repeated several times to correct all orientation.

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.

Permutation is the placement of the pieces. Our goal is to move all pieces to their correct spot while preserving orientation, which should already be solved. This part is also divided into corners and edges; however, permutation parity can occur, which would require one to transpose a pair of edges and a pair of corners. The same principal of set-up moves apply here, but with restrictions added to preserve orientation.

In the following explanation, remember that "corner 1" refers the corner in spot 1, not the corner that should be in spot 1.

The permutation method explained here is know as the cycle method, and is used for corners as well as edges. This step is the difference between cycle method and piece-by-piece method (which is a misleading name, as Stefan Pochmann points out). By solving along the cycle, this method reduces the thinking needed to fix permutation. Every permutation can be decomposed into several independent cycles, permutations in which pieces must moved in a cycle. For example, cycle (123) means corner 1 belongs to spot 2, 2 to 3, and 3 to 1. A cycle of length one means that the piece is already in place and need not be memorized. This decomposition of permutation into cycles can quite easily be achieved through the following algorithm:

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.

Experiment with this using random scrambles. Notice that any number that is not written down could have been chosen to start a new cycle in step 1. However, always starting with the lowest possible number keeps the memorization simple; less thinking means faster times. In official attempts, writing down or reading anything is not permitted. However, using a piece of paper to write down the needed information for each step is a good practice when first working with cycles.

Memorization: The end result should look something like (164237)(58) for corners. Edges will have a maximum of 12 elements. This is the only information we must memorize for permutation.

Resolution: To solve a cycle, we reduce its length 2 at a time (or k-1 at a time if k-cycles are used) until it is length 1 or 2. Each cycle of length 3 and also each pair of cycles of length 2 can then be solved. Cycles can be solved with an algorithm in any order. The following reduction rule is useful here.

Cycle Reduction Rule: A cycle of length 3 or longer, when the 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 to the kth numbers.) In particular, cycles of length 3 are reduced to cycles of length 1, which can then be discarded from memory.

If we have (abcde) and apply (abc), the end result is (ade). I leave it to the reader to figure out why this works. This is essentially what we must do in our mind as we solve the permutation. The two numbers deleted correspond to the corners solved by that particular cycle. Because pieces are deleted from memory when they are solved, when all information is gone, we know that our solve is complete.

There's the theory. So how do we exactly go about solving these cycles of length 3 and 2? We discuss the algorithms used for corners and edges in the following sections.

In the case of corner permutation, the set-up move must be within (UDF2B2R2L2) group, meaning no 90 degree turns for R, L, F, or B faces. This limitation ensures that orientation is preserved.

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 algorithm, combined with proper set-up moves, can solve any cycle of three corners. If all three corners are in U layer, applying the algorithm is easy. Set-up moves come into play when corners of different layer need to be cycled. In general, we set up the desired pieces into U layer. The entire procedure goes as follows:

1. Corners are set up without disturbing orientation so that they are all in U or all in D face.
2. Corners are permuted using either of the two algorithms
3. The inverse of the set-up move in step 1 (inverse means start from end and change cw to ccw).

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

Double transpotition 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. I suggest that you experiment with these on your own.

Cycles of length 2 can only be solved in pairs (double transposition). The same method and limitation of set-up moves apply here. The algorithms I recommend to be memorized are:

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

Example: Suppose we have (24)(36). One method would be to set up with L2D'L2 and use the first algorithm. Doing D to set up into the last algorithm reduces the need to think about which corners are to be swapped.

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.

Edge permutation is the hardest part of blindfold cubing because there are twelve edges to place (more than corners). However, the theory is the same as corners. We are still using 3-cycles (not that we can't use 2 or 4 or 5) to resolve the cycles in the same manner. The only difference is that the set-up move now must be within (UDFBR2L2) group, or no single turns on L and R. We have more freedom in how to set-up than we did for corners, but this also means that we must make sure to remember our set-up moves. For example, we can often use either B'R2 or R2B' to set up. One of the most frustrating thing would be to, after cycling whatever pieces we intened to permute, we forget which move we started with. It is useful to make rules for ourselves on which moves to do first. The most obvious would be to set-up in order of the cycle or to do U/D first, R/L next, and finally F/B.

a. Cycles of length 3

As with corners, it is useful to know 3-cycles of both directions:

A 3-cycle can be performed on U, F, D, and B faces without disturbing orientation. To do these on L and R layers, the follwing move must be used.

EP(4 12 7): ERE'R2ERE'

I wouldn't recommend using this, however, as just a few easy setup moves can bring all pieces to non-L,R layers.

Example:

Here, Z permutation and cross permutation are the most basic and useful.

Z permutation can only be used on U, F, D, and B layers, but Cross permutation can be done on any layer without disturbing the orientation. For Z-permutation, we can use this alg for pieces on R layer: z'FRUR'U'F'-F'L'U'LUFz (which again is not too useful).

Example:

50% of solves will have permutation parity. Generally such parity is reduced to 2 corners and 2 edges to be swapped. Any of the PLL algorithms that have this effect can be used with set-up moves.

Example: For example, if you have CP:(17) and EP:(15),

R2U2FU-FRU'R'URUR2F'RURU'R'-U'F'U2R2

The first part sets up the pieces on U, the second is T-permutation, and finally the third is the inverse of the set-up. Alternatively, you could have done D' to set up on F face, since diagonal swap of corners do not disturb orientation, but this is much harder to notice (and I would not do it).

Permutation parity does not have be solved at the very end. If we realize that we have a parity half way into the permutation, we can correct the parity at an easier time. If the two pieces to be swapped are part of a cycle, remember to erase the second in the cycle from memory. It is also possible, although not necessary, to find out the parity from the permutation of either corners or edges (corners are shorter, so usually easier). Parity is even (no parity fix is necessary) if and only if the number of cycles of even length is even. If you do not find permutation parity easy, one way would be to perform U at the beginning of the solve if parity exists. However, permutation must be memorized for the configuration of the cube after this U, which can be quite confusing. As Richard Carr points out, it is also possible to adjust the cycles so that you end up with 4 corners and 4 edges to be cycled on U, which can then be solved by U at the end of the solve.

I have gone through every stage of a blindfold solving. Hopefully, this is enough to clarify what to memorize and how to deal with each of the four stages.

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 reasons to use 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 in which direction the U/D sticker of each corner points.

This concludes the memorization.

Resolution

Orientation must be solved completely before permutation. However, it does not 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 (UDFBR2L2) group.
Parity Fix (if necessary): Use set-up moves and an appropriate PLL algorithm to fix the parity.

As I have written before, this is only one possible approach, one variation on the cycle method. For example, cubers using Stefan Pochmann's method solve orientation and permutation simultaneously.

Here's a walk-through of the method described above using a scramble generated by JNetCube.

Scramble: F D2 R2 D' B2 L F' B R' L U' F2 D B2 L' U2 L F' B' R' L' D2 R' L2 F'

1. Memorization
CP: (1 2 8 6)(4 5 7)
EP: (1 2 5)(3 8 9 6 11 7)(4 12 10)
EO: 1 3 4 7 9 11
CO: (345 cw)(678 cw)

2. Corner Orientation
(345 cw): F2-z'(U'RUR'U'RUR'L)x3Lz-F2
(678 cw): x2U'-z'(U'RUR'U'RUR'L)x3Lz-Ux2

3. Edge Orientation
1 3 4 7: U2R'-M'UM'UM'UM'UMUMUMUMU-RU2
9 11: x2-M'UM'UM'U2MUMUMU2-x2

4: Corner Permutation
(1 2 8): B2-RB'RF2R'BRF2R2-B2
(4 5 7): DR2DF2U2-L'BL'F2LB'L'F2L2-U2F2D'R2D'
(1 6) Parity left

5. Edge Permutation
(1 2 5): U2F-R2UFB'R2F'BUR2-F'U2
(3 8 9): U2x-R2UFB'R2F'BUR2-x'U2
(3 6 11): x'U2-R2UFB'R2F'BUR2-U2x
(3 7) Parity left
(4 12 10): D'F2B2-R2UFB'R2F'BUR2-B2F2D

6. Parity
First, fix the corners and switch two additional edges:
UR2U-(T-perm ex. RUR'U'R'FR2U'R'U'RUR'F'-U'R2U'
This leaves us with a double transposition.
(2 4)(3 7): U2B-RLU2R'L'F'B'U2FB-B'U2

If you have any requests, please send me the scramble you want me to solve. I'll write it up if I have the time.

Created by Shotaro "Macky" Makisumi

Last updated: 2005/06/14