The SSE 3x3 (Superset ENG) is a notation for cubes with 3 layers, such as the Rubik's Cube.
The notation is based on the English language.
It supports 90° and 180° twists of the layers of the cube.
A whole cube can be rotated along its face axes.
Permutation and orientation changes of individual cube parts can be specified using permutation cycles.
Face twists: R, R', R2
| Move |
Right |
Up |
Front |
Left |
Down |
Back |
| ○○● +90° |
R |
U |
F |
L |
D |
B |
| ○○● -90° |
R' |
U' |
F' |
L' |
D' |
B' |
| ○○● +180° |
R2 |
U2 |
F2 |
L2 |
D2 |
B2 |
Clockwise 90° twists of the six faces of the cube are described by the capital letters
R, U, F, L, D and B (right, up, front, left, down, back).
For example, R rotates the right face in clockwise direction as seen from the right face.
Counterclockwise twists and rotations are described by appending the inversion operator ' to a move:
R', U', F', ...
In environments, where the ' character can not be used, the character - can be used as
an alternative inversion operator.
180° twists and rotations are described by appending the number 2 to a move:
R2, U2, F2, ...
Tier twists: TR, TR', TR2
| Move |
Right |
Up |
Front |
Left |
Down |
Back |
| ○●● +90° |
TR |
TU |
TF |
TL |
TD |
TB |
| ○●● -90° |
TR' |
TU' |
TF' |
TL' |
TD' |
TB' |
| ○●● +180° |
TR2 |
TU2 |
TF2 |
TL2 |
TD2 |
TB2 |
Twists which go two layers deep (tier twists) are described by prepending the letter T to a face twist:
TR, TU', TF2.
For example, TR rotates the outer two layers in clockwise direction as seen from the right face.
Numbered layer twists: NR, NR', NR2
| Move |
Right |
Up |
Front |
Left |
Down |
Back |
| ○●○ +90° |
NR |
NU |
NF |
NL |
ND |
NB |
| ○●○ -90° |
NR' |
NU' |
NF' |
NL' |
ND' |
NB' |
| ○●○ +180° |
NR2 |
NU2 |
NF2 |
NL2 |
ND2 |
NB2 |
Twists of an individual layer of the cube (twist of the n-th layer) are described by prepending the letter N to a face twist.
The number of the layer can be specified by inserting the number of the layer after the letter N, for example
N2R, N2U', N2F2.
Layers are numbered starting from the face described by the face twist towards the opposite layer.
The layer at the face of the cube has number 1, the next layer has number 2, and so on.
If the layer is not explicitly specified, the value 2 is assumed, for example
NR, NU', NF2.
To keep algorithms short, N1R is never used, because it is equivalent to R.
N2R is never used, because it is equivalent to NR.
Mid-layer twists: MR, MR', MR2
| Move |
Right |
Up |
Front |
Left |
Down |
Back |
| ○●○ +90° |
MR |
MU |
MF |
ML |
MD |
MB |
| ○●○ -90° |
MR' |
MU' |
MF' |
ML' |
MD' |
MB' |
| ○●○ +180° |
MR2 |
MU2 |
MF2 |
ML2 |
MD2 |
MB2 |
Twists of the layer in the middle (mid-layer twists) are described by prepending the letter M to a face twist:
MR, MU', MF2.
For example, MR rotates the middle layer in clockwise direction as seen from the right face.
Slice twists: SR, SR', SR2
| Move |
Right |
Up |
Front |
Left |
Down |
Back |
| ●○● +90° |
SR |
SU |
SF |
SL |
SD |
SB |
| ●○● -90° |
SR' |
SU' |
SF' |
SL' |
SD' |
SB' |
| ●○● +180° |
SR2 |
SU2 |
SF2 |
SL2 |
SD2 |
SB2 |
Twists of opposing faces (slice twists) are described by prepending the letter S to a face twist.
For example, SR turns the right face and the opposing left face in clockwise direction as seen from the right face.
Cube rotations: CR, CR', CR2
| Move |
Right |
Up |
Front |
Left |
Down |
Back |
| ●●● +90° |
CR |
CU |
CF |
CL |
CD |
CB |
| ●●● -90° |
CR' |
CU' |
CF' |
CL' |
CD' |
CB' |
| ●●● +180° |
CR2 |
CU2 |
CF2 |
CL2 |
CD2 |
CB2 |
Rotations of the whole cube (cube rotations) are described by prepending the letter C to a face twist.
For example, CR rotates the whole cube in clockwise direction as seen from the right face.
Sequences of moves
Example: R2 L2 U D' F2 B2 U D'
Sequences of moves are specified by appending moves, for example
R2L2UD'F2B2UD'.
To improve readability, whitespace can be used to separate moves:
R2 L2 U D' F2 B2 U D'.
The SSE notation for cubes does not necessarily require whitespace to separate moves,
as there is no other way to divide the individual move tokens.
Note: Since the current version of TWISTER does not yet fully support the SSE notation,
spaces are required between moves!
Seperators
Example: R2 L2 · U D' · F2 B2 · U D'
Sequences of moves can be separated using a · middle dot character.
In environments where this character is not available, the . full stop character can be used.
The following sequences are equivalent:
R2 L2 · U D' · F2 B2 · U D' and
R2 L2 . U D' . F2 B2 . U D'.
Comments
Example: // This is a comment
Single-line comments start with // two forward slashes.
Any text between // and the end of the line is ignored (will not be executed):
// comment.
A single-line comment can be used before a line with a move sequence or
at the end of line with a move sequence.
Grouping and Inversions
Syntax: (A B) = A B
Example: (R U F) = R U F
Inverse: (A B)' = B' A'
Example: (R U F)' = F' U' R'
Sequences of moves can be grouped by enclosing them with parentheses:
(R U F).
An inverse group can be described by appending the inverse operator ' to the closing bracket.
The inverse of a group reverses the entire group squence.
Repetitions
Syntax: (A B)2 = A B A B
Example: (R U F)3 = R U F R U F R U F
Inverse: (A B)2' = B' A' B' A'
Example: (R U F)3' = F' U' R' F' U' R' F' U' R'
Repetitions of type A B A B can be described by enclosing the repetition sequence A B with parentheses
and appending the number of repetitions to the closing bracket:
(A B)2.
An inverse repetition can be described by appending the inverse operator ' to the number of repetitions.
The inverse of a repetition reverses the entire repetition squence.
Conjugations
Syntax: [A: B] = A B A'
Example: [R: U] = R U R'
Inverse: [A: B]' = A B' A'
Example: [R: U]' = R U' R'
Conjugations of type A B A' are described by enclosing the conjugator A and the conjugee B with square brackets
and delimiting conjugator and conjugee by a : colon: [A: B].
A conjugation performs the conjugator and conjugee sequences first, followed by the inverse of the conjugator.
Note that conjugators in twisty puzzle algorithms are also known as setup moves.
An inverse conjugation can be described by appending the inverse operator ' to the closing square bracket.
The inverse of a conjugation reverses the entire conjugation squence.
Commutations
Syntax: [A, B] = A B A' B'
Example: [R, U] = R U R' U'
Inverse: [A, B]' = B A B' A'
Example: [R, U]' = U R U' R'
Commutations of type A B A' B' are described by enclosing the commutator A and the commutee B with square brackets
and delimiting A and B by a , comma: [A, B].
A commutation performs the commutator and commutee sequences first, followed by the inverse of the commutator and commutee.
An inverse commutation can be described by appending the inverse operator ' to the closing square bracket.
The inverse of a commutation reverses the entire commutation squence.