#### Roman

##### Member

- Joined
- Jan 10, 2013

- Messages
- 651

- Location
- Saint Petersburg, Russia

- WCA
- 2012STRA02

- YouTube
- Visit Channel

tl; dr: I generated a lot of speed-optimized 3cycles for wings and x-centers, you're welcome to use them.

I was playing around with commutator algs recently when I found this:

Urb->Brd->Rdb: [r', 4Uw' l 4Uw].

Wondering how many other curious things I have never noticed, I decided to write a generator. In this post I will present some interesting results. Here are raw generated lists for x-centers and wings: https://github.com/Roman-/comms/tree/master/oneMovePartA_raw

First notable thing: commutator algs can solve not only 3cycles, but also 5cycles and 2cycle pairs, although they're slightly less intuitive.

2cycle pairs are cool: they're usually [A, B], where A is an 'interchange' move, and B changes just two pieces on the layer A. Examples:

Bdl-Ful & Dfl-Ubl: [l, U2 f2 U2]

LDb-LUf & LBu-LFd: [L, U' D' r2 D U]

BLd-UFl & UBr-URf: [U, F' R' d R F]

Centers 5cycles often have this pattern: whilist 3cycles are usually [A,BCB'], 5cycles are [A,BCB]. Examples:

Urb-Dbr-Bru-Fru-Blu: [r', u' R' u']

Urb-Dlb-Fru-Bur-Dbr: [r, b L' b]

Ul-Dl-Bl-Fl-Br: [l, E R2 E]

Eventually I found two pure algs for Urb->Brd->Rdb:

[r', D' b D] // = [r', 4Uw' l 4Uw]

[b, D r' D']

Unfortunately, these kind of algorithms are impractical. [F' d F, r] is one more example of the comm of this nature, it's pretty interesting how they work though, I didn't know about them before.

Not all 3cycles cases can be solved with pure commutators, so I also tried obtaining a list of all possible 3cycle commutators [A, B] with 3 moves part B and one move part A, with up to 3 setup moves stm. Turned out there are too many of them (~18millions for x-centers, a lot more for t-centers), and they don't even include such good algs as [U' Rw' U [M', U r U']] because (U' Rw' U) is 4 moves stm.

Certainly I have to somehow filter the results to be able to find good algs. But what are the criteria?

Descard slice setups? But then I'll miss cool nine-movers like [l [l d' l', U2]]. Lower number of setups down to 1 or 2? Well, the for UF-UB-DF I haven't found any center-safe alg faster than [U' R' U [M2, U R U']]. Disallow F and B? [Rw' F [l2, U' r U]] is good. Disallow f and b? But [b', r B r'] can be executed fast if you do x' rotation before.

As you see, finding practical algs is more difficult task than it seems, but that's exactly what I'm aimed to do eventually.

My current goal for this project is: for every 3cycle case, output a list of all commutators sorted from fastest (and/or shortest) to the most impractical. For this, I have to come up with a good speed/convinience estimation criteria I mentioned earlier. Then, questions like "what alg would you use for this 3cycle case?" will stop making sense because they're all there sorted and it's not possible to come up with a good alg that's not among the first few lines of the list (unless it has a non-commutator structure).

If you have any ideas for the good algs criteria, please discuss it there. If we succeed to implement it, such algorithms collection will be a tremendous help to anyone looking for a good alg for a specific 3cycle case.

Cheers!

Spoiler: misc tech details about generation

I was playing around with commutator algs recently when I found this:

Urb->Brd->Rdb: [r', 4Uw' l 4Uw].

Wondering how many other curious things I have never noticed, I decided to write a generator. In this post I will present some interesting results. Here are raw generated lists for x-centers and wings: https://github.com/Roman-/comms/tree/master/oneMovePartA_raw

First notable thing: commutator algs can solve not only 3cycles, but also 5cycles and 2cycle pairs, although they're slightly less intuitive.

2cycle pairs are cool: they're usually [A, B], where A is an 'interchange' move, and B changes just two pieces on the layer A. Examples:

Bdl-Ful & Dfl-Ubl: [l, U2 f2 U2]

LDb-LUf & LBu-LFd: [L, U' D' r2 D U]

BLd-UFl & UBr-URf: [U, F' R' d R F]

Centers 5cycles often have this pattern: whilist 3cycles are usually [A,BCB'], 5cycles are [A,BCB]. Examples:

Urb-Dbr-Bru-Fru-Blu: [r', u' R' u']

Urb-Dlb-Fru-Bur-Dbr: [r, b L' b]

Ul-Dl-Bl-Fl-Br: [l, E R2 E]

Eventually I found two pure algs for Urb->Brd->Rdb:

[r', D' b D] // = [r', 4Uw' l 4Uw]

[b, D r' D']

Unfortunately, these kind of algorithms are impractical. [F' d F, r] is one more example of the comm of this nature, it's pretty interesting how they work though, I didn't know about them before.

**Setup moves**Not all 3cycles cases can be solved with pure commutators, so I also tried obtaining a list of all possible 3cycle commutators [A, B] with 3 moves part B and one move part A, with up to 3 setup moves stm. Turned out there are too many of them (~18millions for x-centers, a lot more for t-centers), and they don't even include such good algs as [U' Rw' U [M', U r U']] because (U' Rw' U) is 4 moves stm.

**The practical aspect of it**Certainly I have to somehow filter the results to be able to find good algs. But what are the criteria?

Descard slice setups? But then I'll miss cool nine-movers like [l [l d' l', U2]]. Lower number of setups down to 1 or 2? Well, the for UF-UB-DF I haven't found any center-safe alg faster than [U' R' U [M2, U R U']]. Disallow F and B? [Rw' F [l2, U' r U]] is good. Disallow f and b? But [b', r B r'] can be executed fast if you do x' rotation before.

As you see, finding practical algs is more difficult task than it seems, but that's exactly what I'm aimed to do eventually.

**What's next?**My current goal for this project is: for every 3cycle case, output a list of all commutators sorted from fastest (and/or shortest) to the most impractical. For this, I have to come up with a good speed/convinience estimation criteria I mentioned earlier. Then, questions like "what alg would you use for this 3cycle case?" will stop making sense because they're all there sorted and it's not possible to come up with a good alg that's not among the first few lines of the list (unless it has a non-commutator structure).

If you have any ideas for the good algs criteria, please discuss it there. If we succeed to implement it, such algorithms collection will be a tremendous help to anyone looking for a good alg for a specific 3cycle case.

Cheers!

Obviously I forbidded consecutive moves to be the same layer turns (like l2 l'). But on my first launch, I noticed it generates things like [S', r2 b' S'] which is essentially equal to [S', r2] (this swaps Ur-Dr and Ld-Rd). I realized that [A,BCA] = [A,BC], and, generally,

[A, B C] = [A, B] if A is parallel to C. Indeed,

if A||C, then (C A' C') = (C C' A') = (A'). Hence,

[A, B C] = A BC A' C'B' = A B (C A' C') B' = A B (A') B' = [A, B].

Also, [A, A' B] = A A' B A' B' A = B A' B' A = [B, A']. These are the majority of generated scrambles with [one move, four moves]. Example: Dlb-Rdb-Rbu: [R, R' u' l u] = [u' l u, R'].

[A, B C] = [A, B] if A is parallel to C. Indeed,

if A||C, then (C A' C') = (C C' A') = (A'). Hence,

[A, B C] = A BC A' C'B' = A B (C A' C') B' = A B (A') B' = [A, B].

Also, [A, A' B] = A A' B A' B' A = B A' B' A = [B, A']. These are the majority of generated scrambles with [one move, four moves]. Example: Dlb-Rdb-Rbu: [R, R' u' l u] = [u' l u, R'].

Last edited: Feb 22, 2019