- Joined
- Jul 12, 2011

- Messages
- 1,532

- Likes
- 315

Thread starter
#1

**tl;dr - efficient 'Fish and Chips' with 27-alg 'Fish' selected from short, ergonomic, well-known algs ... followed by L3C 'Chips' (commutators)**

Hello again. I am back with another EO-solved LL variant that tugs the pareto front lower still, albeit leveraging some cheap commutator tricks. It is called...

As you can tell, [SIMPLE] is a modern version of the 'officially' unpublished LL approach from the Snyder Method.

As such, the first step is to solve the LL edges and one LL corner ('Fish').

The second step is a corner commutator ('Chips').

**The advantages of [SIMPLE] are:**

- Extremely low movecount. It is only 2.2735 moves worse than FULL ZBLL, but it only takes 27 algs (most of which you already know, see "ALGS" below). This confirms the "mathematical advantage" that Snyder constantly brags about on his website.
- Reasonably low alg count. For less algs as OCLL (2nd look of 2-look OLL) & PLL, this variant saves 4.8565 moves.
- High algorithm familiarity. Of the 27 algs, most cubers will only have to learn the effects of 10-12 NEW ones. Many are OLLs/PLLs you should already know.
- Algorithms selected for ergonomics/speed (see "ALGS" if you don't believe me). High frequency of sunes.
- It's cool and good.

**The disadvantages of [SIMPLE] are:**

- It requires EO to be solved before the LL (ZZ/Petrus/CFOP with edge control).
- It takes a shift in mindset to discretize the LL in this way (orienting and permuting pieces at the same time).
- Second step requires a working knowledge of commutators (or just knowledge of the L3C algs).
- You might trip over all the fangirls flocking for your autograph.

**[SIMPLE] is superior to the currently published alg-sets for 'Fish and Chips' by virtue of algcount (9 fewer), movecount (1.7728 fewer), and ergonomics, but it only considers LL cases with oriented edges.**

We don't need 36 algs for this set because some algs solve multiple cases.

Algs were selected to balance coverage, movecount, and ergonomics. Some of the algs are not even optimal.

Here they are arranged in numerical order. Numerical order is assigned in no particular order.

Equal case coverage can be made by replacing some cases with their inverses, if your ergonomic preferences require it. For example, Op-pi can be replaced by it's inverse.

Most ZBLL cases can be reduced to a commutator in many different ways. The shortest way can be found by using this little application:

http://homepages.rpi.edu/~dipalm/simple.html

Algs were selected to balance coverage, movecount, and ergonomics. Some of the algs are not even optimal.

Here they are arranged in numerical order. Numerical order is assigned in no particular order.

Code:

```
# Name Moves STM Edge Effect Should you already know this?
-------------------------------------------------------------------------------------------------------------
1 Sune R U R' U R U2 R' (7) "adj 2-swap" Ya
2 Antisune R U2 R' U' R U' R' (7) "adj 2-swap" Ya
3 Backsune R' U' R U' R' U2 R (7) "adj 2-swap" Ya
4 Backantisune R' U2 R U R' U R (7) "adj 2-swap" Ya
5 R-Niklas R U' L' U R' U' L (7) none Ya
6 L'-Niklas L' U R U' L U R' (7) none Ya
7 Bruno (pi oll) R U2 R2 U' R2 U' R2 U2 R (9) "adj 2-swap" Ya
8 Backbruno R' U2 R2 U R2 U R2 U2 R' (9) "adj 2-swap" Ya
9 Diag1 r U2 R' F R' F' R2 U2 r' (9) "adj 2-swap" Most will
10 Diag2 R U' L' U' L U' F2 D R' D' F2 U' R' (13) "adj 2-swap" Nope
11 Op-T r U' r U2' R' F R U2' r2' F (10) "opp 2-swap" Nope
12 Uperm a M2 U' M U2 M' U' M2 (7) "adj 2-swap" Ya
13 Uperm b M2 U M U2 M' U M2 (7) "adj 2-swap" Ya
14 Hperm M2 U M2 U2 M2 U M2 (7) none Ya
15 Zperm M2 D S2 D' S' M2 S (7) "opp 2-swap" Ya
16 Op-pi F U R U' R' S U R U' R' f' (11) "opp 2-swap" Most will
17 T8 r U R' U' L' U l F' (8) none Ya
18 L8 F R' F' r U R U' r' (8) none Ya
19 Twisty R' F U' F' U' R F U' R' U' R F' (12) none Nope
20 Ice F U' L2 D2 B R2 u R' u R2 (10) "opp 2-swap" Nope
21 Tooroo R U2 R' U2 L' U R U' R' L (9) "adj 2-swap" Nope
22 Rootoo L' R U R' U' L U2 R U2 R' (9) "adj 2-swap" Nope
23 Fruffy F R U R2 F R F' R U' R' F' (11) "adj 2-swap" Nope
24 2manyR2 R' U2 R2 U2 R2 U' R2 U' R2 U R (11) "adj 2-swap" Nope
25 L9 R' U2 R' D' R U2 R' D R2 (9) none Ya
26 MikePence F B' R2 U R2 U' R2 F' U' B (9) "adj 2-swap" Nope
27 ecnePekiM B' U F R2 U R2 U' R2 B F' (9) "adj 2-swap" Nope
```

Most ZBLL cases can be reduced to a commutator in many different ways. The shortest way can be found by using this little application:

http://homepages.rpi.edu/~dipalm/simple.html

The hard part of this method is NOT learning the algs - it's learning what the algs truly do. You may know certain algs as OLLs, but now you must learn how they affect piece permutation.

So, to learn this method, study what each alg above does to the cube for both edges and corners.

Apply them when you think you need to. Use your brain - this is a rubix's cube forum, not /r/abortion.

Here are some other generic tips,

-Remember: you can reduce the candidate algorithms by the current edge case you have.

-Note how many cases are each type of 'Edge Effect'

-Use the EPLLs to slot edges around an oriented LL corner.

-Use Twisty to rotate a corner if edges are solved

-R-Niklas places the FUR sticker into UBR (like an R move)

-L'-Niklas places the FLU sticker into ULB (like an L' move)

-T8 case puts FLU to UBR, use your brain to figure what L8 does (the inverse)

-Only 8.07% of LL states are covered by a single algorithm, the rest can be reduced to L3C in multiple ways. Try using algs that give better L3C.

So, to learn this method, study what each alg above does to the cube for both edges and corners.

Apply them when you think you need to. Use your brain - this is a rubix's cube forum, not /r/abortion.

Here are some other generic tips,

-Remember: you can reduce the candidate algorithms by the current edge case you have.

-Note how many cases are each type of 'Edge Effect'

-Use the EPLLs to slot edges around an oriented LL corner.

-Use Twisty to rotate a corner if edges are solved

-R-Niklas places the FUR sticker into UBR (like an R move)

-L'-Niklas places the FLU sticker into ULB (like an L' move)

-T8 case puts FLU to UBR, use your brain to figure what L8 does (the inverse)

-Only 8.07% of LL states are covered by a single algorithm, the rest can be reduced to L3C in multiple ways. Try using algs that give better L3C.

Code:

```
AUF = 0.7500 stm
'Fish' = 7.3102 stm
'Chips' = 9.3333 stm
AUF = 0.7500 stm
-------------------
LL TOTAL = 18.1435 stm
[LS/LL = 25.1835 stm]
```

You will skip the 'Fish' step of [SIMPLE] 4.78% of the time.

You will skip the 'Chips' step of [SIMPLE] 3.70% of the time.

To put that in perspective, PLL skips happen 1.39% of the time.

36% of the time, the 'Fish' can be done with a sune. (What edge case will this be? Use that to your advantage)

You will skip the 'Chips' step of [SIMPLE] 3.70% of the time.

To put that in perspective, PLL skips happen 1.39% of the time.

36% of the time, the 'Fish' can be done with a sune. (What edge case will this be? Use that to your advantage)

Below are 5 example solves with various methods. Click them for the alg.cubing.net.

U B2 R2 U' F2 L2 D' B2 U2 B2 U R' B D U F2 D' R F2

F' L2 R F B2 U2 R' // 3x2x2

y R' U2 R F' L' U' L U F // eof2l-1

U R U2 R' U R U' R' // f2l

l' U' L U R U' r' F // [SIMPLE] 'Fish' T8

U y F R' F' r U R U' r' // [SIMPLE] 'Chips' commutator

=17 move LL

D B2 U R2 D L2 B2 U2 R2 U2 F2 R' B R U L B2 L2 D R2 U

U B' U R U D L x2 // 3/4 cross

R2 F R' U' R' // finish cross

L U2 L2 U' L2 U' L' // pair 3

R' U' R U R' U R y U2 F R' F' R // pair 4 and eo

R U2 R' U' R U' R' // [SIMPLE] 'Fish' antisune

y2 F R' U2 R F' R' F U2 F' R // [SIMPLE] 'Chips' commutator

=17 move LL

B2 R F' R2 F2 L2 U2 D L' F2 R2 D' L2 U L2 F2 R2 D R2 D

D B2 U F' // eoline

R L' U R L2 U L2 // square

U' R U' R' U' L' // block

R U R' U2 R' U' R2 U R // block

y' R U2 R' U' R U' R' // [SIMPLE] 'Fish' antisune

y R' U L U' D' F2 D R2 U2 L' U R' U2 // [SIMPLE] 'Chips' commutator

=20 move LL

U L2 D' B2 D' B2 U' F2 D B2 F2 L' B' L B2 D2 F' L D2 R2

z2 D' R2 D' B' L2 // 3x2x2

y U M' U M // eo

R U' R' U' R F U F' U R' // modern petrus hax - dont tell tao

R U2 R' U' R U' R' // [SIMPLE] 'Fish' antisune

d R U2 R D R' U2 R D' R2 // [SIMPLE] 'Chips' commutator

=17 move LL

B2 F2 U L2 D L2 F2 U2 L2 B2 U F' U L' F2 R U2 B U2 B U

B' U2 D B2 // 2x2x2

U' L U' L2 U F2 // 3x2x2

f U f' // eo

L U' L' U L2 U L' U' L2 U L2 // f2l

R U R' U R U2 R' // [SIMPLE] 'Fish' sune

U l' U' L U R U' r' F // [SIMPLE] 'Chips' commutator

=16 move LL

There were a lot of sunes for [SIMPLE] 'Fish', but that is how the cookie crumbles in this variant, boy.

**Petrus**U B2 R2 U' F2 L2 D' B2 U2 B2 U R' B D U F2 D' R F2

F' L2 R F B2 U2 R' // 3x2x2

y R' U2 R F' L' U' L U F // eof2l-1

U R U2 R' U R U' R' // f2l

l' U' L U R U' r' F // [SIMPLE] 'Fish' T8

U y F R' F' r U R U' r' // [SIMPLE] 'Chips' commutator

=17 move LL

**Freefop (with edge control):**D B2 U R2 D L2 B2 U2 R2 U2 F2 R' B R U L B2 L2 D R2 U

U B' U R U D L x2 // 3/4 cross

R2 F R' U' R' // finish cross

L U2 L2 U' L2 U' L' // pair 3

R' U' R U R' U R y U2 F R' F' R // pair 4 and eo

R U2 R' U' R U' R' // [SIMPLE] 'Fish' antisune

y2 F R' U2 R F' R' F U2 F' R // [SIMPLE] 'Chips' commutator

=17 move LL

**ZZ:**B2 R F' R2 F2 L2 U2 D L' F2 R2 D' L2 U L2 F2 R2 D R2 D

D B2 U F' // eoline

R L' U R L2 U L2 // square

U' R U' R' U' L' // block

R U R' U2 R' U' R2 U R // block

y' R U2 R' U' R U' R' // [SIMPLE] 'Fish' antisune

y R' U L U' D' F2 D R2 U2 L' U R' U2 // [SIMPLE] 'Chips' commutator

=20 move LL

**Petrus:**U L2 D' B2 D' B2 U' F2 D B2 F2 L' B' L B2 D2 F' L D2 R2

z2 D' R2 D' B' L2 // 3x2x2

y U M' U M // eo

R U' R' U' R F U F' U R' // modern petrus hax - dont tell tao

R U2 R' U' R U' R' // [SIMPLE] 'Fish' antisune

d R U2 R D R' U2 R D' R2 // [SIMPLE] 'Chips' commutator

=17 move LL

**Petrus:**B2 F2 U L2 D L2 F2 U2 L2 B2 U F' U L' F2 R U2 B U2 B U

B' U2 D B2 // 2x2x2

U' L U' L2 U F2 // 3x2x2

f U f' // eo

L U' L' U L2 U L' U' L2 U L2 // f2l

R U R' U R U2 R' // [SIMPLE] 'Fish' sune

U l' U' L U R U' r' F // [SIMPLE] 'Chips' commutator

=16 move LL

There were a lot of sunes for [SIMPLE] 'Fish', but that is how the cookie crumbles in this variant, boy.

It was pointed out that the Zperm alg presented is UNCOMMON AND BAD. It can be executed M2 u' M2 u x' E M2 E' which I think is quite nice.

It turns out that the Zperm alg provides no additional coverage to the other 26 algs. Without it, all 1944 states can be reached in 7.56 moves. Therefore, it only serves to lower the movecount. If a more-common 9-move Zperm is used, the set movecount becomes 7.48 moves. This doesn't significantly affect the results, but I would like to include it for completeness.

It turns out that the Zperm alg provides no additional coverage to the other 26 algs. Without it, all 1944 states can be reached in 7.56 moves. Therefore, it only serves to lower the movecount. If a more-common 9-move Zperm is used, the set movecount becomes 7.48 moves. This doesn't significantly affect the results, but I would like to include it for completeness.

Click here for an application to find a [SIMPLE] 'Fish' solution for a given LL case, if you need it . It should now give all possible solutions with these algs.

The objective of this project was to recreate a low-movecount, low-algcount, ergonomic LL variant that keeps the cube a "puzzle". It is basically the LL approaches created by Snyder/Petrus which I feel are very pure in nature. Their "mathematical advantage" over other variants is undisputable. I think these goals have been met. It also allows people with short attention spans, like myself, to learn all the algs before getting bored.

Let me know what you think.

Last edited: Feb 5, 2019