# Well known algs as commutators and conjugates

#### Filipe Teixeira

##### Member
So I'm curious to see well known algs as commutators and conjugates, as for instance F2L, OLL and PLLs

Last edited:
• abunickabhi

#### Christopher Mowla

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.)?

#### charlh_bld

##### Member
T perm = [l, F R' F'] [F R U' R': U']
A perm = [l', [U, R' D2 R]]
U perm = [M2 U': [M, U2]]

• Filipe Teixeira

#### Filipe Teixeira

##### Member
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.)?

like this:

T perm = [l, F R' F'] [F R U' R', U']
A perm = [l', [U, R' D2 R]]
U perm = [M2 U': [M, U2]]

cases and the commutator/conjugate notation of the solution

#### Christopher Mowla

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]

Last edited:
• dudefaceguy

#### Filipe Teixeira

##### Member
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.

#### Christopher Mowla

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.

Last edited:
• • y235 and dudefaceguy

#### xyzzy

##### Member
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].

• dudefaceguy and Filipe Teixeira

#### Bruce MacKenzie

##### Member
Here are three methods for manipulating the Up layer using conjugation. They're not optimal but they're easy to remember.

Three corner cycle

F D' F'
U
F D F'
U
F D' F'
U2
F D F'

Three corner cycle with corner twist

F D' F'
U
R' D' R
U
R' D R
U2
F D F'

Edge-corner three cycle

L' F L
U
L' F' L
U
L' F L
U2
L' F' L

There are analogous transforms for the edges. Here's the Three Edge Cycle maneuver.

R L' F L R'
U
R L' F' L R'
U
R L' F L R'
U2
R L' F' L R'

Or if you like, using middle slice turns.

MR' D MR
U
MR' D' MR
U
MR' D MR
U2
MR' D' MR

Last edited:
• dudefaceguy and Filipe Teixeira

#### Christopher Mowla

I recently have been participating in this thread which is about finding a short 2 edge flip single commutator sequence for the 3x3x3.

I'm just letting you all know that, despite it's not as easy to understand as a piece-isolating commutator, all 36 move optimal adjacent two edge flip algorithms (found with Cube Explorer) can be expressed as a commutator in a similar way to how Sune OLL can be (expanding the commutator and cancelling moves leaves the sequence that we know).

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.

In this recent Twistypuzzles forum thread, someone asked what can we do with only four face turns. In this post, I mentioned that the algorithm R B' R F R F' R2 B2 L' B L B R' B (which is move optimal) can be used to do a U2 or D2 turn.

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.

Last edited:
• Filipe Teixeira

#### Filipe Teixeira

##### Member
I found that Uperm and Aperm can be solved on the bottom with insertions

Aperm
Uperm

duh

Last edited: