Notation Based Reference System

This system allows for referencing any piece or group of pieces anywhere on the cube. It doesn't require learning any new notation; you simply use the notation that you already know for denoting turns. The system can be used for describing in a simple way which pieces are already solved or are to be solved in a method, the state that a puzzle is in, and may even have computer applications. It can also be used on big cubes and any other puzzle that has an established notation. I first discussed this group referencing system on speedsolving.com in 2010, here.

In our standard notation we have outer turns, slice turns, and wide turns. Using this notation we can travel from outer to inner or inner to outer to reference any block or single piece. The reference is the intersection of the combination of layers in which the piece or group of pieces lies. To reference a 2x2x2 that is built around the DFR corner for example, it would be referenced as dfr. That block is within the bottom two layers, which is a wide turn d. It is also within the two front layers and the two right side layers, wide f and wide r respectively. To use another example, take the DFR corner + FR edge pair. That would be referenced as dFR because the pair is within the d layers and also on the outer layers F and R. The very center of the cube would be MES because that is the intersection of the three slices.

I also propose that the standard reference in the community follow a clockwise direction. U and D can remain the starting letter for corner pieces. But the sticker order should move clockwise around each corner. URF, UFL, ULB, UBR, DFR, DLF, DBL, and DRB are the primary references for each corner piece. Then for sticker references, stickers on a corner would also move clockwise around the corner - URF, RFU, and FUR are the U, R, and F stickers of the URF corner. For edges, U and D can also remain the starting letter for whole pieces (UFM, URS, DFM...). For edges in the E layer, F and B will be the priority (FRE, BRE...). Then for referencing individual edge stickers, the sticker order will determine the sticker being referenced (UFM being the U sticker and FUM being the F sticker).

Stickers can also be referenced. The order of the group of letters indicates the stickers that are being referenced, with the first letter being the targeted sticker or stickers. For example, URF is the U layer sticker on that corner and FUR is the F layer sticker. urf is the group of four stickers on the U layer within that 2x2x2 block and fur is the four stickers on the front layer.

You will notice that the correct reference for the intersection of two layers, such as UF, is a 1x1x3 block and not a single edge. The correct reference for an edge is the intersection of three layers, UFM for example. However, some or many may not want to change to the technically correct edge reference because the standard for many years has been to reference an edge using just two layers. Although it is simpler to change to the correct references of UF and UFM for the 1x1x3 and the edge within it, context will be necessary or another possibility is to say "UF" for the 1x1x3 block that is at that intersection and say "UF edge" for the specific edge. Side thought: The community using just two layers to reference an edge likely comes from the fact that David Singmaster didn't include a simple slice notation outside of appending an "s" to an outer layer. In addition, for many years outer layer turns took prominence in popular methods such as Layer By Layer and CFOP. This focus on outer turns means that the slice turns were simply left out, or the idea of a three layer reference possibly even not considered.

The default form of the notation is to reference blocks using the intersection of the layers that are involved. However, even more types of blocks can be referenced if other set notation is considered. Such as unions, symmetric difference, and so on. For example, with the default being the intersection, dM (or d ∩ M) is the line in the middle of the two bottom layers. But if we take the symmetric difference, or d ∪ M, that would reference the two Roux blocks (F2B).

The system can also be used to reference pieces or groups of pieces that are in locations other than the solved position. The existing turn notation is again used here. This time by using the x, y, and z rotations. The piece or group is referenced then followed by the rotation that it would take to be placed in its current position. This can be viewed as passing the block or piece into the rotation. The order is x->y->z, but can also be used in a different order and, if it is, the notation can be shorter in some cases. This expands the standard to be U/D->F/B->R/L->M/E/S->x/y/z. Below are example images.

Cube states such as EO, CO, and domino reduction can also be represented. These states are notated by using functions such as C() and E() and also by referencing a piece or group of pieces. When a function is used, first the piece type is placed inside the parentheses and after that, inside of brackets are parameters for applying orientation and or permutation. For notating states of pieces, first the pieces are referenced, optional curly braces are used to define the pieces that are allowed within the initially referenced pieces, then, in the same way as in the functions, orientation and permutation parameters are used inside of brackets.

• () = Used for functions and when orienting pieces. In a function, within () are the involved pieces. When () is used with orientation, an x, y, or z rotation is used to specify the type of orientation.

• [] = Within these brackets are either O for orientation or P for permutation. The brackets come after the group of pieces on which operations are being performed.

  • UFR[O] orients the UFR corner. UFR[O, P] both orients and permutes the UFR corner.

  • Rotations after the O can be used to specify the type of orientation.

    • Corners:

      • [O(x)] orients corners to face L/R. Corner orientation doesn't change when an x rotation is performed.

      • [O(y)] orients corners to face U/D. Corner orientation doesn't change when a y rotation is performed.

      • [O(z)] orients corners to face F/B. Corner orientation doesn't change when a z rotation is performed.

    • Edges:

      • [O(x)] Orients edges so that orientation doesn't change when an x rotation is performed.

      • [O(y)] Orients edges so that orientation doesn't change when a y rotation is performed.

      • [O(z)] Orients edges so that orientation doesn't change when a z rotation is performed.

• {} = Describes the pieces of which a group of pieces can consist. The group of pieces comes before the {} and the pieces inside are what can fill the group of pieces.

  • U{U, D} is the U layer consisting of pieces from only the U or D layers.

• * = When used after a rotation, this notates that any rotation in that direction applies.

• | = Used with blocks or rotations to provide the meaning "or".

  • Example: (UFL|UFR) means the UFL corner or the UFR corner.

• When no piece or group of pieces is referenced before the O orientation or P permutation, all pieces of the puzzle are involved in the operations.

  • E([O(z)]) orients all edges of the puzzle.

• > = Used for transitioning between steps in a method.

  • dbl > dbR > E()[O(x)] > :y > dR > U[] describes the separate steps of the Petrus method.

• + = Used for adding steps, blocks, or properties.

  • Example: dL + dR = Roux F2B

• - = Used for subtracting steps, blocks, or properties.

  • Example: d - dFR = F2L-1

  • Example: C(U[-O]) = misorients the U layer corners into an undefined orientation.

• The system has functions for referencing specific piece types and also for applying specific operations. Special functions can be defined to shorten notation.

  • C(): References the corners of the puzzle.

  • E(): References the edges of the puzzle.

  • X(): References the centers of the puzzle.

  • Pi(): An example defined function for orienting four corners into the standard Pi orientation.

  • U-OLL(): Similar to the Pi() function, this function orients four corners into the standard U orientation. In this case U-OLL is used instead of just U to distinguish from referencing the U layer.

Putting everything together, there are two main structures. One for when referencing just corners, edges, or centers as piece types. And another for when referencing a specific piece or group of pieces.

• For corners/edges/centers, a function is called for that piece type and inside that function are the pieces to which operations will be applied. Immediately following the function are the operations to be used. These are held within [] brackets. Inside of the brackets are either O for orientation or P for permutation. Orientation can have () to specify the type of orientation. This can be x, y, or z. For 

• Corners/Edges/Centers: C()[O, P]

• In this case, a corner function is used at the start, all corners are referenced using the . symbol, and the corners are oriented and permuted within [].

• For a specific piece or group of pieces, the pieces are first referenced. Immediately following that are optional {} braces. Inside of these braces are the pieces of which the initially referenced pieces can consist. After that are the same [] that are used in the corners/edges/centers structure above. It consists of either O or P.

  • Pieces: U{U, D}[O(y)]

  • In this case, first the U layer pieces are referenced. Then within the {} the U and D layers are included to show that the initially referenced U layer can consist of a mix of U and D layer pieces. After this, within the [], O(y) is used to orient the corners of the U layer to face the U layer center.