========== Introduction ==========
In cubing, the term "metric" means a system for counting moves. The most famous and common one by far is OBTM (outer block turn metric, also known as HTM, half turn metric) as it is the wca's official metric for NxNxN puzzles. Other famous metrics include QTM (quarter turn metric), ETM (execution turn metric) and STM (slice turn metric). Today, I'll be describing a new metric I created for fun and proposing the challenge of finding the shortest algorithm for each PLL case for this metric.
========== The Metric ==========
I have called my metric "letter count metric". Just as the name suggests, we simply count the number of letters in the algorithm, including rotations. The twist that actually makes this metric interesting is that I am allowing the usage of revertion, repetition, commutation and conjugation in the algorithms (basically I'm allowing what cubing.alg.net allows).
Reversion, marked with a ' sign reverses what is inside. For example: (R U)' = U' R'
Repetition repeats what is inside the specified number times. For example: (R U)4 = R U R U R U
Conjugation allows to do "setup moves", such that [A: B] = A B A'. Example: [U R: F] = U R F R' U'. This is called a conjugate, and uses the : symbol.
A commutator of A and B, wrotten down as [A, B] using a comma, does each sub-algorithm and then reverses each one, such that [A, B] = A B A' B'. Example: [R, U] = R U R' U'
Theese can also be nested. For example, in the blindfolded solving world it is common to have conjugates of commutators in the form of [A: [B, C]] = A B C B' C' A'. Please take some time to reread this and research more about them of any of this was confusing, as this notation will be abused a lot in this post.
========== Basic triggers ==========
Now that we know the rules, let's start with the trivial things before doing the end goal. Triggers are common short sequences of moves that appear in lots of algorithms, making the process of algorithm learning much easier and faster (example: R U R' U'). Most of theese triggers can be written down nicely using the described above notation. Here are some useful examples:
R U R' U' (Sexy) = [R, U]
R' F R F' (sledge) = [R', F]
R U R' (pair) = [R: U]
R U R' U' R' F R F' (sexy sledge) = [Lw, [F: R']]
R U R' U R U2 R' (sune) = [[R: U]: [U, R]]
Rw U R' U R U2 Rw' (fat sune) = [Rw U: [R', U]]
R U' L' U R' U' L U (niklas) = [R, [U': L']]
A special of theese I'd like to note specifically is the sexy sledge. Because it is very fingertrick friendly and does specifically a cycle of 3 corners and a cycle of 3 edges, it is used in a lot of PLL algorithms.
========== The PLL Algorithms ==========
Altho I have not ran any kind of computer search to garantee that any of theese is actually optimal, I have reached a good result for each one of them (note, I'll be considering mirrors and inverses the same case for the porpous of the challenge). Here's the list of the algorithms in alphabetical I came up with alongside the letter count for each and a short description on why/how they.
A perm: [R2: [[R: F], B2]] // 4 letters, standard algorithm, simple 3-corner commutator
E perm: [[F D' R: D2], U2] // [OUTDATED] 5 letters, swap corners on the right, U2, undo the swap
E perm: [[(R2 D)15: D2], U2] // 4 letters, same logic but more efficient
F perm: [R' U': [F' R U, R'][[R: U']: U']] // [OUTDATED] 9 letters, standard algorithm, likely optimisable as it is the only algorithm over 7 letters
F perm: [R', U][R2: [F', U'][R, F]] // 7 letters, fmc algorithm, reason to work unknown to me
G perm: [F2 R2: [[D': L2], Rw2]] // 5 letters, moddified J perm
H perm: [[M2: U2]: U] // [OUTDATED] 3 letters, switch pair of edges, move the other pair over, switch the other pair
H perm: (M2 U)6 // 2 letters, I knew the existence of this alg before but for some reason I didn't remember it while I was first writting this
J perm: [R2: [[D: B2], Fw2] // 4 letters, conjugate to block commutator, FMC auf-skipping algorithm
N perm: [[F' R2 U: R2]: U2] // [OUTDATED] 5 letters, switch 4 pieces in the back, U2, switch the new pieces in on the back
N perm: [[(R2 D')3: B2]: U2] // 4 letters, same logic but more efficient
R perm: [R', U2][[R': F]:[U: R']]R // 7 letters, standard algorithm, reason to work unknown to me
T perm: [[F, Lw]: [R2: [[D: B2], Fw2]] U'] // 7 letters, conjugate to J perm
U perm: [M2 U': [M, U2]] // 4 letters, one of the standard algorithms, conjugate to edge slice and layer commutator
V perm: [R': [U: R'][[B': R']:[B, U']]] // 7 letters, standard algorithm, reason to work unknown to me
Y perm: (F2 U)3 U2 [[R': U']: F2] // 6 letters, FMC algorithm, reason to work unknown to me
Z perm: [M2 U: [F2, M2]] // 4 letters, setup to layer and slice double edge swap (U2 M2 U2 M2 in a different angle)
Altho I stole some of this algorithms rather than inventing them, I still had the work to manually compress their normal letter notation into the compact notation.
========== Conclusion ==========
I had the idea of doing this because of JPerm's "can every PLL be done with 1 J perm" video. I started thinking if every PLL could be done with a conjugate into a single U move (spoiler alert, not all them can), started playing arround in alg.cubing.net and realised that the letter count metric challenge could be fun. You may notice that some of the algorithms in my list are conjugates into a single move, as a subproduct of this.
I also want to note that I have actually managed to tie many of my algorithms, for example using [R, U][L', U'] for U perm, but tieing doesn't really help and I didn't want to have to explain all the tied algorithms when one algorithm was enough.
Please feel free to tell me if you find any algorithm with less letters than those that I used in my list and I'll feature that in the list with the credits.
If you still have any questions about how the metric or the notation works, feel free to ask me about that
Enjoy the challenge
In cubing, the term "metric" means a system for counting moves. The most famous and common one by far is OBTM (outer block turn metric, also known as HTM, half turn metric) as it is the wca's official metric for NxNxN puzzles. Other famous metrics include QTM (quarter turn metric), ETM (execution turn metric) and STM (slice turn metric). Today, I'll be describing a new metric I created for fun and proposing the challenge of finding the shortest algorithm for each PLL case for this metric.
========== The Metric ==========
I have called my metric "letter count metric". Just as the name suggests, we simply count the number of letters in the algorithm, including rotations. The twist that actually makes this metric interesting is that I am allowing the usage of revertion, repetition, commutation and conjugation in the algorithms (basically I'm allowing what cubing.alg.net allows).
Reversion, marked with a ' sign reverses what is inside. For example: (R U)' = U' R'
Repetition repeats what is inside the specified number times. For example: (R U)4 = R U R U R U
Conjugation allows to do "setup moves", such that [A: B] = A B A'. Example: [U R: F] = U R F R' U'. This is called a conjugate, and uses the : symbol.
A commutator of A and B, wrotten down as [A, B] using a comma, does each sub-algorithm and then reverses each one, such that [A, B] = A B A' B'. Example: [R, U] = R U R' U'
Theese can also be nested. For example, in the blindfolded solving world it is common to have conjugates of commutators in the form of [A: [B, C]] = A B C B' C' A'. Please take some time to reread this and research more about them of any of this was confusing, as this notation will be abused a lot in this post.
========== Basic triggers ==========
Now that we know the rules, let's start with the trivial things before doing the end goal. Triggers are common short sequences of moves that appear in lots of algorithms, making the process of algorithm learning much easier and faster (example: R U R' U'). Most of theese triggers can be written down nicely using the described above notation. Here are some useful examples:
R U R' U' (Sexy) = [R, U]
R' F R F' (sledge) = [R', F]
R U R' (pair) = [R: U]
R U R' U' R' F R F' (sexy sledge) = [Lw, [F: R']]
R U R' U R U2 R' (sune) = [[R: U]: [U, R]]
Rw U R' U R U2 Rw' (fat sune) = [Rw U: [R', U]]
R U' L' U R' U' L U (niklas) = [R, [U': L']]
A special of theese I'd like to note specifically is the sexy sledge. Because it is very fingertrick friendly and does specifically a cycle of 3 corners and a cycle of 3 edges, it is used in a lot of PLL algorithms.
========== The PLL Algorithms ==========
Altho I have not ran any kind of computer search to garantee that any of theese is actually optimal, I have reached a good result for each one of them (note, I'll be considering mirrors and inverses the same case for the porpous of the challenge). Here's the list of the algorithms in alphabetical I came up with alongside the letter count for each and a short description on why/how they.
A perm: [R2: [[R: F], B2]] // 4 letters, standard algorithm, simple 3-corner commutator
E perm: [[F D' R: D2], U2] // [OUTDATED] 5 letters, swap corners on the right, U2, undo the swap
E perm: [[(R2 D)15: D2], U2] // 4 letters, same logic but more efficient
F perm: [R' U': [F' R U, R'][[R: U']: U']] // [OUTDATED] 9 letters, standard algorithm, likely optimisable as it is the only algorithm over 7 letters
F perm: [R', U][R2: [F', U'][R, F]] // 7 letters, fmc algorithm, reason to work unknown to me
G perm: [F2 R2: [[D': L2], Rw2]] // 5 letters, moddified J perm
H perm: [[M2: U2]: U] // [OUTDATED] 3 letters, switch pair of edges, move the other pair over, switch the other pair
H perm: (M2 U)6 // 2 letters, I knew the existence of this alg before but for some reason I didn't remember it while I was first writting this
J perm: [R2: [[D: B2], Fw2] // 4 letters, conjugate to block commutator, FMC auf-skipping algorithm
N perm: [[F' R2 U: R2]: U2] // [OUTDATED] 5 letters, switch 4 pieces in the back, U2, switch the new pieces in on the back
N perm: [[(R2 D')3: B2]: U2] // 4 letters, same logic but more efficient
R perm: [R', U2][[R': F]:[U: R']]R // 7 letters, standard algorithm, reason to work unknown to me
T perm: [[F, Lw]: [R2: [[D: B2], Fw2]] U'] // 7 letters, conjugate to J perm
U perm: [M2 U': [M, U2]] // 4 letters, one of the standard algorithms, conjugate to edge slice and layer commutator
V perm: [R': [U: R'][[B': R']:[B, U']]] // 7 letters, standard algorithm, reason to work unknown to me
Y perm: (F2 U)3 U2 [[R': U']: F2] // 6 letters, FMC algorithm, reason to work unknown to me
Z perm: [M2 U: [F2, M2]] // 4 letters, setup to layer and slice double edge swap (U2 M2 U2 M2 in a different angle)
Altho I stole some of this algorithms rather than inventing them, I still had the work to manually compress their normal letter notation into the compact notation.
========== Conclusion ==========
I had the idea of doing this because of JPerm's "can every PLL be done with 1 J perm" video. I started thinking if every PLL could be done with a conjugate into a single U move (spoiler alert, not all them can), started playing arround in alg.cubing.net and realised that the letter count metric challenge could be fun. You may notice that some of the algorithms in my list are conjugates into a single move, as a subproduct of this.
I also want to note that I have actually managed to tie many of my algorithms, for example using [R, U][L', U'] for U perm, but tieing doesn't really help and I didn't want to have to explain all the tied algorithms when one algorithm was enough.
Please feel free to tell me if you find any algorithm with less letters than those that I used in my list and I'll feature that in the list with the credits.
If you still have any questions about how the metric or the notation works, feel free to ask me about that
Enjoy the challenge
Last edited:
