The SSE 4x4 Pyraminx (Superset ENG) is a notation for pyramids with 4 layers, such as the Master Pyraminx.
The English notation is based on the book «Inside Rubik's Cube and Beyond» by Christoph Bandelow.
It was later enhanced for big cubes and other puzzles.
It supports 120° twists of the layers of the pyramid.
A whole pyramid can be rotated along its corner or tip axes.
Permutation and orientation changes of individual pyramid parts can be specified using permutation cycles.
The logical, language-based structure of the SSE notation allows for more complex movements to be represented
more clearly and precisely thanks to the prefix system (T for Tier, M for Mid-layer, C for Cube / Pyramid, etc.).
The prefix makes it clear from the outset what is being moved.
This makes algorithms for multi-layered pyramids more concise and easier to read.
The directional logic is always identical to the outer corner (tip).
The notation also includes the description of permutations.
This allows for the precise description of the movements of individual cycles or the state of the entire puzzle.
It makes SSE a complete notation that can also cover pyramid-theoretical and scientific aspects.
The systematic, consistent syntax is particularly programmer-friendly, making the notation ideal for software
development and computer-aided puzzle analysis.
Contents
Corner twists: R, R'
| Move |
Right |
Up |
Left |
Back |
| ○○○● +120° |
R |
U |
L |
B |
| ○○○● -120° |
R' |
U' |
L' |
B' |
Clockwise 120° twists of the four corners (tips) of the pyramid are described by the capital letters
R, U, L and B (right, up, left, back).
For example, R rotates the right corner in clockwise direction as seen from the right corner (tip).
Counterclockwise twists and rotations are described by appending the inversion operator ' to a move:
R', U', L', ...
In environments, where the ' character can not be used, the character - can be used as
an alternative inversion operator.
Tier twists: TR, TR', ... T3R
| Move |
Right |
Up |
Left |
Back |
| ○○●● +120° |
TR |
TU |
TL |
TB |
| ○○●● -120° |
TR' |
TU' |
TL' |
TB' |
| ○●●● +120° |
T3R |
T3U |
T3L |
T3B |
| ○●●● -120° |
T3R' |
T3U' |
T3L' |
T3B' |
Twists which go two layers deep (tier twists) are described by prepending the letter T to a corner twist:
TR, TU'.
For example, TR rotates the outer two layers in clockwise direction as seen from the right corner (tip).
The depth of the tier can be specified by inserting a number after the letter T.
For example, T3R twists three layers deep in clockwise direction as seen from the right corner (tip).
If the depth is not explicitly specified, the value 2 is assumed:
TL, TB'.
To keep algorithms short, T1R is never used, because it is equivalent to R.
T2R is never used, because it is equivalent to TR.
Numbered layer twists: NR, NR', ... N3R
| Move |
Right |
Up |
Left |
Back |
| ○○●○ +120° |
NR |
NU |
NL |
NB |
| ○○●○ -120° |
NR' |
NU' |
NL' |
NB' |
| ○●○○ +120° |
N3R |
N3U |
N3L |
N3B |
| ○●○○ -120° |
N3R' |
N3U' |
N3L' |
N3B' |
Twists of an individual layer of the pyramid (twist of the n-th layer) are described by prepending the letter N to a corner twist.
The number of the layer can be specified by inserting the number of the layer after the letter N,
for example N3R, N3U'.
Layers are numbered starting from the corner described by the corner twist towards the opposite layer.
The layer at the corner of the pyramid 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 NL, NU'.
To keep scripts 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'
| Move |
Right |
Up |
Left |
Back |
| ○○●○ +120° |
MR |
MU |
ML |
MB |
| ○○●○ -120° |
MR' |
MU' |
ML' |
MB' |
Twists of the layer in the middle (mid-layer twists) are described by prepending the letter M to a corner twist:
MR, MU'.
For example, MR rotates the middle layer in clockwise direction as seen from the right corner (tip).
On pyramids with an even amount of layers, the mid-layers are the ones closer to the corner of the cube.
The number of layers twisted can be specified by inserting a number after the letter M.
For example, M2R twists two layers in the middle in clockwise direction as seen from the right corner.
If the depth is not explicitly specified, the value 1 is assumed,
for example ML, MB2.
To keep algorithms short, M1R is never used, because it is equivalent to MR.
Wide-layer twists: WR, WR'
| Move |
Right |
Up |
Left |
Back |
| ○●●○ +120° |
WR |
WU |
WL |
WB |
| ○●●○ -120° |
WR' |
WU' |
WL' |
WB' |
Twists of all layers except the outer layers (wide-layer twists) can be described by prepending the letter W to a
corner twist: WR, WU'.
Pyramid rotations: CR, CR'
| Move |
Right |
Up |
Left |
Back |
| ●●●● +120° |
CR |
CU |
CL |
CB |
| ●●●● -120° |
CR' |
CU' |
CL' |
CB' |
Rotations of the whole pyramid (pyramid rotations) are described by prepending the letter C to a corner twist.
For example, CR rotates the whole pyramid in clockwise direction as seen from the right corner (tip).
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 pyramids 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'.
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.
Sources
Bandelow, Christoph
Inside Rubik’s Cube and Beyond
120 pp. Birkhäuser Boston, 1982.
ISBN 978-0-8176-3078-2
Download PDF