Blindfolded Corner Orientation

Lucas's Corner Orientation Page
December 21, 2006

Of those who use 3-cycles, most will recognize the mess of corner orientation (CO). Even Shotaro Makisumi, in his BLD record post at speedcubing.com claims that "bad CO is bad news for me." I was also stumbling along it, until I decided on the following technique. It reduces CO memorization to three looks, resulting in up to three letters, and up to two numbers:

Parity: O - nothing; F - front; R - right

Top and bottom layers (each)

O-nothing	S-Sune
A-Anti-Sune	D-Double-Sune
T-Triple-Sune	H-Headlights
C-Chameleon	Pi-π

Basically, each layer is memorized separately as a COLL case, but perfomed by only affecting corners. Most of them are easiest to do via the standard commutator-per-piece technique. It is possible to memorize each as the OLL case along with the PLL that restores the piece positions (often a three-cycle), or as a special alg (the Headlight and Chameleon can each be done as a combination of a Sune and Anti-Sune). For example, I use a faster double-OLL for the pi than orienting all four corners with eight moves each.
No matter how, each one is given a name and a single-letter (monosyllabic) abbreviation that is used to memorize it, most often based on a similar OLL. Each CO also has a standard position on the U-face. If it is not the standard position, I memorize either 1, 2, or 3 after the letter to denote how many U-turns are added from the standard position.
Below are all my single-layer algs in standard position. The shortened notation represents R'DRD'R'DRD' by [F] and DR'D'RDR'D'R by [R], depending on what sticker of the URF cubie the commutator portion orients to the top face.

Algorithm	Execution
S, Sune	(R'DRD')x2 U (R'DRD')x2 U (R'DRD')x2 U2' [F] U [F] U [F] U2'
A, Anti-Sune	(DR'D'R)x2 U (DR'D'R)x2 U (DR'D'R)x2 U2' [R] U [R] U [R] U2'
D, Double-Sune	(DR'D'R)x2 U' (R'DRD')x2 U' (DR'D'R)x2 U' (R'DRD')x2 U' [R] U' [F] U' [R] U' [F] U'
T, Triple-Sune	U' (R'DRD')x2 U2 (DR'D'R)x2 U' U' [F] U2 [R] U'
H, Headlights	(R'DRD')x2 U' (DR'D'R)x2 U [F] U' [R] U
C, Chameleon	U' (R'DRD')x2 U (DR'D'R)x2 U' [F] U [R]
[Jan 2] P, Pi (Better version I invented January 1st, '07)	B' (r' U' R U) M' (R' U' R U) (r' U' R U) M' (R' U' R U) B
P, Pi	F R U R' U' S R U R' U' S' R U R' U' S R U R' U' f'
P, Pi (Half +commutator; note that it orients the opposite way from the other pi's)	F (R U R' U') (R U R' U') F' (R U R' U') r (R' U R U' r')
Pi, Pi (normal commutator style)	(DR'D'R)x2 U' (DR'D'R)x2 U' (R'DRD')x2 U' (R'DRD')x2 U' [R] U' [R] U' [F] U' [F] U'

Obviously, the top and bottom layer will not always be independently orientable. We first need to put them in such a position, two out of three times. Anytime in speedcubing we have an expected step that may or may not occur, but that needs to be taken care of to proceed regularly, we call it a parity, thus I denote it so. So, I orient the FLU and FLD cubies using either a headlight or chameleon alg on the left face (or do nothing). I remember them, respectively, as F and R, like the sub-commutators on the top face, by the effect of the first commutator portion on the UFR cubie.

Algorithm	Execution
F (Headlights)	(U'R UR')x2 L' (RU'R'U)x2 L
R (Chameleon)	(RU'R'U)x2 L' (U'R UR')x2 L

Implementation

In practice, I simply remember the parity first, then use only the three other cubies in the top layer to memorize the top CO alg. On top of that, I remember a number for how many U-twists are added to standard position. Then, I always turn the cube the same way (twice in the direction of the F face, z2), recognize and memorize (using the three bottom layer cubies not affected by the parity) the bottom CO, and turn the cube back. Since the possible parities are F and R (and O), and the alg names are S, A, D, T, H, C, and Pi (and O), corner orientation is in the following form:

(O/F/R) - (O/S/A/D/T/H/C/Pi) [0,1,2,3] - (O/S/A/D/T/H/C/Pi) [0,1,2,3]

F-S2-T1 (F parity; Sune with URF, UFL and ULB twisted counter-clockwise, Triple-Sune with DLF clockwise ad DRB counter-clockwise)
R-Pi3-S2
O-C2-D1
F-T-D1 = F-T0-D1
F-A3-S = F-A3-S0
O-Pi1-C = O-Pi1-C0
F-A-H = F-A0-H0
F-O-T2 = F-O0-T2
F-H2[-O] = F-H2-O0
O-O-O = O-O0-O0 (e.g. solved cube)

I have created a page of thirteen examples where I show how exactly I use this system; I think it should resolve anything still ambiguous or confusing.

I have a long list of comments on this method; some might answer your questions:

All names and denotations are completely arbitrary; thus:
Any of the CO's can be given any name and abbreviation; call the triple sune "Q" or "Splash" if you want. Pi could just be "P," but I consder π a greek letter. One syllable works well. I picked "chameleon" because the white/yellow stickers face apart.
[0,] 1, 2, and 3 don't need to be used; " ' " (prime) instead of "3" works just as well.
In fact, you can use any standard position for any alg (for example, you might rotate that standard position of the Anti-Sune by a half turn, to be consistent with "inverse of the regular Sune"), but if you want to do well, the standard positions should be reasonable and consistent.
You don't have to use my algs; for example, you can memorize OLL+PLL instead, but that's more to confuse and hard to line up visually with what you recognized and memorized.
You can also do the parity differently, perhaps on URF and DFR. If this can elimiate a layer, and doesn't take too long to figure out on-the-fly, I do it.
Always undo the setup as its inverse, even if it's U2. And if you go back an forth, wiggle over the same area of cubes. This causes less trouble, and gets you used to not assuming too many things when it's not necessary (like on the Megaminx).
You can memorize O's or not, as long as you don't get confused on what you did and didn't memorize; I generally always remember a U-face O, and ignore a parity or bottom-layer O.
My Pi does odd things; you can experiment with alternates. For example, you can do the first S slice turn along with the initial F, turn the next S', S, and S' into S, S', and S respectively, and turn the f' into F'. Also, S and S' can be replaced with anything that two-cycles the UR edge away and back (like S2 and S2'/S2, or S' and S) but leaves everything in the commutator in place.
[Jan 2] I'm considering using the pi double parity: B (r' U' R U) M' (R' U' R U) (r' U' R U) M' (R' U' R U) B'
Notice that the Double-Sune only has two orientations; it is either D0 or D1.
Don't confuse the F and R parities, or D, with face turns (or S with a slice turn)
In my examples, I orient all yellow and white to either the U or D face; I hold red in front and yellow on top for my BLD solves. Don't get confused if you use a different standard orientation (like Macky, who even uses a different color scheme).
Note that, basically, for this orientation system, white = yellow.
Even though I caution against it, you can always do the algs on any face; the corners still need to be oriented into the same directions. In example 6, I do a Pi on the front face.
Be careful if attempting:If you do an F sub-commutator followed by an R csub-commutator, you can leave out the D at the the end of the former and the D' at the end of the latter. I do this in examples 4, 6, 7, and 13. When I do this in actual solves, I actually begin to twist the face, and leave it slightly tilted.
It's easier to do the commutator-based algs with the R face tilting up, as in the applets where I demonstrate them.
I figured this out from a video: You can do the sub-commutators with the U and R faces to orient the bottom without extra cube rotation, possibly eliminating even setup moves. I do this in all my example solves, except for 11 and 12, where I avoid bottom CO.
Avoiding CO on a layer is good. If there is only one misoriented corner on a layer, I bring it to UFR or ULF before the parity, and place it back after. That leaves the layer completely oriented, with only two extra twists. In case the corner is UBL, as in examples 11 and 12, you can leave it there and do L2' and L2 in the parity instead of L' and L. Don't do this to turn a CO into a simpler one, though; only use it to completely solve a layer.
You can do it the other way around to avoid a tiny bit extra, but I always fix UFR first in a parity.
Don't do ultra-crazy setups for avoiding an alg. On example 11, doing "D F" or "U L" would bring all misoriented corners to the U layer, but you shouldn't waste the time to figure out which CO it is and risk doing it incorrectly.
If you find yourself partially through the wrong sub-commutator, do it once more right after you finish; don't panic.
If the bottom CO is a half-twist from standard position (like S2 or H2), you can rotate the cube twice along the x-axis (x2, cube rtation in the same direction as R) and perhaps avoid setup. Be careful (again)!
I would recommend only doing a cube rotation for a Pi on the bottom.
On a 2x2x2, use combinations of Sunes for algs, with a U2 at the end if the CO is comprised of an odd number of Sunes. The pi can be chopped in half so that it rotates every corner in the other direction instead. I might write a 2x2x2 page someday.
So, the real point of this is to provide a fast system for corner orientation; it's not intended to be optimal or fantastic, just fast and efficient (for memorization and execution). I hope you find it useful; tell me if you do, or if you have a comment on something.

Go BLD!