Welcome to the Speedsolving.com, home of the web's largest puzzle community! You are currently viewing our forum as a guest which gives you limited access to join discussions and access our other features.

Do you mean that we post a commutator, and when all moves are cancelled, it's a well-known algorithm?

Like the fact that Sune = [R U R2, R U2 R2]? Or are you asking us to find a single commutator solution to the position generated by a well-known algorithm (or the position of a OLL, PLL, etc.)?

Do you mean that we post a commutator, and when all moves are cancelled, it's a well-known algorithm?

like this:

Like the fact that Sune = [R U R2, R U2 R2]? Or are you asking us to find a single commutator solution to the position generated by a well-known algorithm (or the position of a OLL, PLL, etc.)?

Well in 2012, I did write every odd permutation PLL which was in the wiki at the time as a composition of commutators and conjugates. But my work was deleted last year (I guess for the best). However, you can see them it in this revision. This is the original topic I started which I eventually just brought to the PLL wiki page.

(Basically, I removed all cube rotations, wide turns, slice moves, etc., from all algorithms for 2-cycle PLLs in the wiki. I then expressed that face-turn algorithm as a composition of commutators and conjugates.)

Not all of the decompositions are good, but at least we can improve on them.

I doubt any well-known/speedsolving G perm algorithm can be written as a single commutator, but here is a single commutator that I found for the G perm position.
G perm = [F' R' F U2 F' R F, R' U' R L' D L F' D R F]

Cool, I find this very interesting.
I believe people in the 80 used some commutator/conjugate techniques to find most of the OLL and PLL they used. Later on entered the brute force algorithms, and that way of finding algs ended.

I guess since I hit the nail on the head with that large list of decompositions, you will probably love: This post, this post, this post, and this post. Also, this post on Mathematics Stack Exchange.

If you are curious about 4x4x4 parity algorithms (or will be later on), this PDF.

A large portion of the 2GLLs and diag ZBLLs can be solved with a conjugated sexy move (or sledgehammer, which amounts to the same thing).

The easiest example is Sune: R U R' U R U2 R' = [R U R' : [U, R]]. Another one is [r U2 R' : [R', F]] (one of the common diag-L COLL algs; rearranging this a bit gives the x R2 F R F' Ja perm alg that a few people use). Looking outside of ZBLL, we also have [F : [R, U]] and [R' U' : [R', F]], among a few others.

Some algs are conjugated single moves, e.g.
[R U' R2 D' r : U2] (from COLL/ZBLL)
[r' D R2 U R' : U2] (from OLLCP)
[R U' R2 B2 D' r : U2] (an optimal N perm alg)
[r' D B2 R2 U R' : U2] (an optimal 4-flip N perm alg)
[F U' R2 D R' : U2] (from OLLCP/flipped line 1LLL)
[r u' R2 u r' : U2] = [L B' D2 B L' : U2] (optimal corner twist alg)
[r U' M2 U r' : U2] (from ELL)
[R' U2 r U' r' : U2] (from OLL)
[M' U' M U' M' : U2] (from ELL)
[F R U' R' : U'] and inverse (from OLL/OLLCP)

These all use a bunch of moves to shuffle the top layer pieces (messing up F2L along the way), do a U/U2/U' move to permute them, then restore F2L. It's theoretically possible to get algs for most (unfortunately, not all) 1LLL cases this way, although it goes without saying that such algs aren't necessarily good (e.g. that N perm listed above).

Some algs can be decomposed into a simpler alg with inserted commutators, e.g. the RUD R perms: R U2 R D R' U R D' R' U' R' U R U R' = [R U2 : @ [R', U]] with @ = [R D R', U].

In addition, although not completely on topic, some know that we can do the conjugate [R L F2 B2 L' R': D] to simulate the move U on the non-supercube (this alg is in Chris Hardwick's signature, BTW). This in fact is simple proof that we only need to turn 5 faces of the cube to solve it.

The next natural question is, can we also do a U or D turn with just L, R, F, and B turns? Well the answer is NO, but almost!

I found this move optimal conjugate of the quarter turn (which is similar to Chris' Hardwick's) which can be used to do a U2 (or D2) turn: [L R' F' B' R F2 R2 F2 R2 F2 R: F2] or a U or D turn [L R' F' B' R F2 R2 F2 R2 F2 R: F], but it flips all four edges in the U turn, in addition. (I found this by hand. See my derivation in this post.)

I just thought these ideas would be a great addition to this (relatively recent) thread.