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.
Block Referencing
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 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 (UF, UR, DF...). For edges in the E layer, F and B will be the priority (FR, BR...). Then for referencing individual edge stickers, the sticker order will determine the sticker being referenced (FU, RF...).
URF
Corner at URF
The same way as corners are currently referenced. A corner is at the intersection of three layers. In this example, the URF corner is at the intersection of the U, F, and R layers.
UFM
Edge between the UFL and URF corners
Edges, just like corners, are at the intersection of three layers. UFM intersects at the U, F, and M layers. Unaware of the intersections, the community previously referenced edges using the two outer layers, leaving out the slice layer.
UF
1x1x3 intersecting at the U and F layers
The intersection of two outer layers is a 1x1x3 block. Previously, the UF in this example would refer to the edge that is between the two corners. However, the accurate reference is that the intersection of the U and F layers is the 1x1x3 block. This is the two corners and the edge between them.
Uf
1x2x3 on the U layer facing the front
Roux block on the left is dL.
Urf
1x2x2 on the U layer facing the R and F layers
urf
2x2x2 around the URF corner
dFR
CE pair at the front right with F2L on the bottom
dM
ZZ line, the two D layer M slice edges plus centers
UMS
U layer center
MES
The very center of the cube
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.
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).
I first discussed this group referencing system on speedsolving.com in 2010, here.
Unsolved / Pseudo
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.
UBM:y2
UBM edge at UFM
UBR:x'
UBR corner at FUR
ULS:z
ULS edge at RUS
Centers can be ignored during a rotation.
UM+US:y2
Cross on U offset by U2
uR:x2
1x2x3 belonging at uR now placed at dR
US:x2y
ZZ-4c example where URS is at DFM and ULS is at DBM
Alternatives
There are a couple of other ways that can be used to reference unsolved or pseudo situations.
Target:Moves One option is to use the required moves to denote where the target is. First the target would be referenced as in the above method then the turns that it would take to position the target in its current position. This should work equally well. However, it doesn't fit as perfectly with the standard of denoting by using the intersection of the notation. It would also require a more in-depth standard for some situations. Which turns to use among the various choices and the order in which to use them would be ambiguous and slightly complicate the system.
Target:Location Another option is to reference the target first then where it currently is. So UBM:y2 in the first image above would be UBM:UFM. This works well for single pieces and some groups, but isn't able to accurately convey some situations. ZZ-4c is one example. For US:x2y, it can't just be US:DM. There would need to be additional notation added to convey which of the URS/ULS edges is at DFM and which is at DBM. This Target:Location method was first suggested by SciKE.
States
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.
C(U)[O(y)]
The U face corners are oriented facing U
E(U)[O(y)]
The U edges are oriented facing U
Pi(U)
U layer corners oriented in the Pi orientation
Pi is a custom function for producing short notation.
E(d)[O(z)]
All edges on d oriented ZZ style
Dl{U, D}[O(y)]
Dl block consisting of pieces from the U and D layers
Used in DR methods.
x2y*:DM+DS
Color neutral U or D cross
d - dFR
F2L-1
y*:(dFR + dM + dS):y*
XCross
The initial y* notates that it can be any of the four d XCrosses. The final y* notates that, after solved, the XCross can be rotated anywhere on d.
E()[O(z)] + dM
EOLine
[O] + E{E}
Domino reduction state
Notation Guide
() = 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.
Credit
The primary block and piece referencing system was developed by Athefre.
The notation in the Unsolved / Pseudo section and the States section was co-developed among Athefre, RedstoneTim, zakimoshi, and trangium. More specifically:
Athefre developed the concept of incorporating imaginary rotations x, y, and z to represent unsolved/pseudo, incorporated the use of functions, and the concept of adding blocks or information from left to right.
RedstoneTim suggested that the system be able to represent unsolved/pseudo. He also built on the rotations idea by placing the rotation to the left of the pieces in the notation to represent color neutrality and states. Overall, RedstoneTim was responsible for much of the development of how the states notation should be structured. This includes the * symbol, braces, brackets, other symbols, and the organization.
zakimoshi suggested that the system have a way to represent states and provided a lot of input on how the system's overall notation should appear.
trangium proposed that the system move from nested functions to separating the involved pieces from the functions.
RedstoneTim and zakimoshi suggested to use an orientation standard and SciKE and zakimoshi had the idea of using a : symbol within the notation.
Images created with VisualCube.