# Message #4129

From: Andrew Farkas <ajfarkas12@gmail.com>

Subject: Notation and turn metrics for the 2x2x2x2

Date: Thu, 13 Sep 2018 17:19:13 -0400

Hey everyone!

I’ve been working on the random-state scrambler/solver and discussing

things with Marc over the past few days, and I’ve come up with some things

that I think are worth sharing.

Notation

I’ve yet to see a proper compendium of notation for the 2^4, so here’s my

proposal for moves in the horizontal orientation:

- A face *R*, *L*, *I*, or *O*, followed by one of the following:
- Any letter *r*, *l*, *u*, *d*, *f*, *b*, *x*, *y*, *z* (plus an

optional *‘* or *2*).

- A pair of square brackets containing any sequence of 3D moves

<https://www.speedsolving.com/wiki/index.php/Notation> that are valid

on a 2x2x2.

- Most of the time, of course, these moves should be 0-mod-4.

- Most of the time, of course, these moves should be 0-mod-4.
- The moves *U2*, *D2*, *F2*, and *B2*.

- A pair of square brackets containing any sequence of 3D moves
- The full puzzle rotations *x*, *x’*, *x2*, *y2*, and *z2*.
- The stacking moves *M*, *M’*, *M2*, *E*, and *S*.

- *M* moves the right endcap over to the left of the puzzle; *M’* does

the opposite, and *M2* swaps the left and right halves of the puzzle. - *E* swaps the top and bottom halves of the puzzle.
- *S* swaps the front and back halves of the puzzle.

- *M* moves the right endcap over to the left of the puzzle; *M’* does
- *z clam* and *z’ clam*.

- *z clam* is a *z* rotation followed by a clamshell move.
- *z’ clam* is a *z’* rotation followed by a clamshell move.
- *z clam* and *z’ clam* are inverses.

- *z clam* is a *z* rotation followed by a clamshell move.
- Parentheses can be used for grouping, and numbers can follow

parentheses to repeat a sequence. - Commutator notation

<https://www.speedsolving.com/wiki/index.php/Commutators_and_Conjugates>

is allowed when useful.

The use of lowercase letters in moves like *Rr* may be controversial; if

they are deemed confusing, *R[R]* could be encouraged instead.

Here’s an equivalent of Melinda’s original gyro sequence in this notation:

*M E z’ clam (x z’ clam)2 *

I’ll briefly digress to discuss a WCA-inspired

<https://www.worldcubeassociation.org/regulations/#4d1> "standard

orientation" that Marc and I have been using. WCA regulations state that

white face should be on top (Y axis) and the green face should be on the

front (Z axis). On a standard NxNxN, this will result in the red face on

the right (X axis). If the X, Y, and Z axes are aligned in this manner on

the 2^4, here is the result:

[image: image.png]

Metric

As for counting numbers of moves, I’d like to propose the "snap" metric.

Each separation and reattachment of pieces is a single move. This can be

very dependent on how a move is executed, but I think it makes the most

sense for the purpose of solving and speedsolving.

A single move like *Iy* could be executed in three snaps as *M Ry M’* or in

just two snaps by rearranging the right and left endcaps around the *I* layer.

A sequence like *x’ Rz Lz’ M2* may seem like a lot of moves, but it can be

executed in one snap. (The *x’* is actually zero snaps, regardless of

context.) The sequence *z’ clam* is two snaps, while the equivalent *Rx2 U2

(R[x2 y’] Ly)* is three snaps. *Ix* can be executed as three snaps with *M

Rx M’*, two snaps with *Rr Ll’ x’*, or one snap by holding the endcaps with

one hand and rotating the *I* layer with the other. (In an actual solve,

the two-snap method is probably fastest.) While *Rr* is pretty clearly one

snap, *Ru* could be executed in two snaps (by separating the left and right

halves, performing *Ru*, and then reattaching them) or one snap (by

removing the four pieces of *Ru* directly, rotating them, and replacing

them).

I’d love to hear all your opinions on these things! - Andy

–

"Machines take me by surprise with great frequency." - Alan Turing