#### mDiPalma

##### Member

- Joined
- Jul 12, 2011

- Messages
- 1,536

**Cardan Reduction**is a novel "LS/LL" approach for methods that preorient edges before the LS (ZZ, Petrus, Heise, CFOP with edge control). It features a relatively low case count and movecount. "LS/LL" is in quotes because the solution is not discretized in that way.

This variant leverages cancellations, statistically common cases, rotational symmetry, inverses, and reflections to efficiently reduce the cube to a commutator/conjugate.

**Cardan Reduction has 3 steps after EOF2L-1 is completed:**

**CR1:: Insert FR edge and create a U-layer 2x1x1 block.**

--------> the U-layer pair has a fairly high likelihood (4/9) of solving itself while the FR edge is inserted

--------> if not, this can take an average of 8 moves to do manually

--------> pairs can be preserved during F2L to drastically reduce this movecount (see examples)

**CR2:: Solve the 2x1x1 pair, all edges, and a corner (72 cases, and their mirrors).**

--------> AUF the 2x1x1 pair so it points over the FR edge

--------> if the pair is a clockwise pair (UR edge and URF corner)

--------------> determine edge permutation (6 possibilities)

--------------> determine destination of UFL corner (12 possibilities)

--------------> apply alg from speadsheet

--------> if the pair is an anticlockwise pair (UF edge and URF corner)

--------------> rotate y (so FR edge is in LF)

--------------> determine edge permutation (6 possibilities)

--------------> determine destination of UFR corner (12 possibilities)

--------------> apply alg that is mirrored from spreadsheet

**CR3:: Solve the remaining 3 corners using a commutator/conjugate.**

1/5 chance FR edge already in place

4/9 chance 0 extra moves

(1/5*4+4/5*3) [number of U corners in U] * 1/3 [oriented] * 10/24 [are part of pair]

3/5 chance putting FR edge in place takes 2 moves with cancellations

4/9 chance 0 extra moves

1/5 chance putting FR edge in place takes 4 moves

4/9 chance 0 extra moves

HARCS gives the remaining cases (5/9) an average movecount of 8.00 (mean of 10).

Let me know if something doesn't seem right.

4/9 chance 0 extra moves

(1/5*4+4/5*3) [number of U corners in U] * 1/3 [oriented] * 10/24 [are part of pair]

3/5 chance putting FR edge in place takes 2 moves with cancellations

4/9 chance 0 extra moves

1/5 chance putting FR edge in place takes 4 moves

4/9 chance 0 extra moves

HARCS gives the remaining cases (5/9) an average movecount of 8.00 (mean of 10).

Code:

```
Movecount Probability
0 4/45 = 8.89%
2 12/45 = 26.67%
4 4/45 = 8.89%
8 5/9 = 55.55%
--------------------------------------
5.33 moves
```

The algs for a Clockwise U-layer 2x1x1 can be found in

The average movecount is 9.07 moves.

You can mirror these algs to solve cases with an Anticlockwise U-layer 2x1x1.

I am currently creating a CR2† algset which places the corner that belongs at DFR instead. This will make recognition a bit easier, I think. It will also force the CR3 step to be a L3C case, which has less variance than a generic commutator.

**this spreadsheet**.The average movecount is 9.07 moves.

You can mirror these algs to solve cases with an Anticlockwise U-layer 2x1x1.

I am currently creating a CR2† algset which places the corner that belongs at DFR instead. This will make recognition a bit easier, I think. It will also force the CR3 step to be a L3C case, which has less variance than a generic commutator.

**Total movecount =**5.33 (

**CR1**) + 0.75 (AUF) + 9.07 (

**CR2**) + 9 (

**CR3**) + 0.75 (AUF) =

**24.90 moves**

**This movecount can drop**

__significantly__if you actively try to preserve pairs while finishing the F2L (see examples).These methods are listed in ascending order of total movecount. You will note something peculiar about Cardan Reduction: it has a disproportionately low algorithm count (144) for its movecount and stepcount, which shrinks to 72 if mirrors are ignored.

For a 3-look variant, it's movecount is actually in the realm of 2-look approaches.

For a 3-look variant, it's movecount is actually in the realm of 2-look approaches.

Code:

```
Method Step 1 Step 2 Step 3 AUFS Total Alg Count
---------------------------------------------------------------------------------------------------------
ZBLL 7.04 14.37 --- 1.5 22.91 493
ZZ-b (alg) 7.77 14.64 --- 2.25 24.66 227
CR 5.33 9.07 9 1.5 24.90 144 (72 w/ M)
CR† 5.33 9.306 9.333 1.5 25.47 144 (72 w/ M)
Speed-Heise 5.573 9.305 9.333 1.5 25.71 72
ZZ-b (int) 10.07 14.64 --- 1.5 26.21 169
CPLS 2.6* 8.22 13.15 2.25 26.22 110
Fish & Chips 7.04 9.083 9.333 1.5 26.96 36
ZZ-CT 10.37 15.21 --- 2.25 27.83 197
WV/SV 4.67 8.74 12.82 2.25 28.48 48
COLL/EPLL 7.04 12.08 7.5 2.25 28.87 46
intuitive** 5.573 6 16.33 1.5 29.40 0
OLL/PLL 7.04 7.93 12.82 2.25 30.04 28
* 2 if cancelled with rb square
** create pair, insert while solving edges, corner commutators
```

It takes less moves than any other 3-look LS/LL method as far as I know.

(except maybe solve all edges, then solve all corners - but that becomes a headache when corners don't nicely line up in commutators.)

It has less algorithms and cases than a variant of this movecount should.

Similarly, it takes less moves than a variant of this alg-count should.

It efficiently leverages cancellations, statistically common cases, TRUE rotational symmetry, inverses, and reflections across the plane passing through UFR DFR & UBL.

It is easy to reduce

It can be extemely useful for FMC, when you can find a lucky

If you know TTLL, I believe you already know algs for the

If you know sunes, U perms, and commutators, you will already know algs for a bunch of the

It can also help you learn and become more comfortable with commutators.

(except maybe solve all edges, then solve all corners - but that becomes a headache when corners don't nicely line up in commutators.)

It has less algorithms and cases than a variant of this movecount should.

Similarly, it takes less moves than a variant of this alg-count should.

It efficiently leverages cancellations, statistically common cases, TRUE rotational symmetry, inverses, and reflections across the plane passing through UFR DFR & UBL.

It is easy to reduce

**further**the movecount of**CR1**by preserving pairs during F2L-1.It can be extemely useful for FMC, when you can find a lucky

**CR1**and are essentially guaranteed to find and insertion for**CR3**which cancels 2~3 moves.If you know TTLL, I believe you already know algs for the

**CR2**cases which have an oriented UFL corner.If you know sunes, U perms, and commutators, you will already know algs for a bunch of the

**CR2**cases.It can also help you learn and become more comfortable with commutators.

Because those take more moves kek.

I believe that only narcissists name things after themselves. This approach is named for Gerolamo Cardano (1501-1576), who was one of the most influential mathematicians and inventors of the 16th century. His work included many mechanical inventions, discoveries in mathematics, and laying the groundwork for modern implementations of probability. Not only does this reduction approach to the "LS/LL" take advantage of Cardano's achievements, but I don't feel this type of discovery is unlike his own accomplishments.

__Here are some "speedsolve" examples with Petrus (click for alg.cubing.net)__:**L' F2 L2 B' R2 U' B2 U' R L2 F D2 B2 L2 D2 R2 D2 B' D2 B'**

R' D2 L U2 L2 B L' F U F2 R F' // eo3x2x2

U R U' R' U R U2 R // eof2l-1

U2 R U2 R' // insert FR edge and create pair in U (CR1)

U2 // AUF pair over FR edge

R2 B U B' U' R2 F' U2 F // solve edges, pair, and corner at UFL (CR2)

U y F R' F' L F R F' L' // commutator (CR3)

R' D2 L U2 L2 B L' F U F2 R F' // eo3x2x2

U R U' R' U R U2 R // eof2l-1

U2 R U2 R' // insert FR edge and create pair in U (CR1)

U2 // AUF pair over FR edge

R2 B U B' U' R2 F' U2 F // solve edges, pair, and corner at UFL (CR2)

U y F R' F' L F R F' L' // commutator (CR3)

In that solve, CR required

**23 moves**to solve "LS/LL". Everything here is pretty typical.

Full solve =

**43 moves**

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

U D F D2 R' U L' F' L2 D // 3x2x2

y U2 M' U' M y' // eo

R' U2 R U2 R' U' R2 // eof2l-1

U R' // insert FR edge and create pair in U (we have 3 to pick from!) (CR1)

U' // AUF pair over FR edge

U' B' R B2 L U L' U' B2 R' B // solve edges, pair, and corner at UFL (CR2)

F D F' U' F D' F' U // commutator (CR3)

U D F D2 R' U L' F' L2 D // 3x2x2

y U2 M' U' M y' // eo

R' U2 R U2 R' U' R2 // eof2l-1

U R' // insert FR edge and create pair in U (we have 3 to pick from!) (CR1)

U' // AUF pair over FR edge

U' B' R B2 L U L' U' B2 R' B // solve edges, pair, and corner at UFL (CR2)

F D F' U' F D' F' U // commutator (CR3)

In that solve, CR required

**22 moves**(21 after cancellations) to solve "LS/LL". We got a 2 move CR1, but a bad CR2 (it's actually not that bad if you rotate).

Full solve =

**42 moves**

**D2 F2 L' F2 D2 B2 R U2 F2 L2 R' F' D2 L D' R U2 L' U' L2 U'**

F U2 F L' D' R F L' B2 // 3x2x2

y M F M' y' // eo

U R' U R U2 R // eof2l-1

U R U2 R' // insert FR edge and create pair in U (CR1)

// skip (CR2)

U2 y' R' U2 R' D' R U2 R' D R2 // commutator (CR3)

F U2 F L' D' R F L' B2 // 3x2x2

y M F M' y' // eo

U R' U R U2 R // eof2l-1

U R U2 R' // insert FR edge and create pair in U (CR1)

// skip (CR2)

U2 y' R' U2 R' D' R U2 R' D R2 // commutator (CR3)

In that solve, CR required

**14 moves**to solve "LS/LL". We actually skipped CR2, which is the least likely step to skip. Honestly, that usually never happens.

Full solve =

**32 moves**

**D2 R2 U2 F' D2 B' F2 R2 F' U2 F' U B L' D' L' B2 F L' B R'**

U' R B' U D' F B D' // 3x2x2

y R' F R M F' M' y' // eo

U2 R2 D R' U' R D' R // eof2l-1

U R' U R // insert FR edge and create pair in U (CR1)

y2 U' // AUF pairs over FR edge

L' U2 F' U' L U L' F U2 L // mirror alg for anticlockwise pair (CR2)

U F2 U' B' U F2 U' B // commutator (CR3)

U' R B' U D' F B D' // 3x2x2

y R' F R M F' M' y' // eo

U2 R2 D R' U' R D' R // eof2l-1

U R' U R // insert FR edge and create pair in U (CR1)

y2 U' // AUF pairs over FR edge

L' U2 F' U' L U L' F U2 L // mirror alg for anticlockwise pair (CR2)

U F2 U' B' U F2 U' B // commutator (CR3)

In that solve, CR required

**23 moves**to solve "LS/LL". We used an anticlockwise pair here so we had to mirror the CR2 alg.

Full solve =

**45 moves**

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

U D' L2 B' D' F' D F L D // 3x2x2

F' U F2 R F' // eo

R U' R2 U2 R U' R' // eof2l-1

U R' U2 R // insert FR edge and create pair in U (CR1)

U' y // AUF pair over FR edge

U R U R' F' U' L' U2 L U F // solve edges, pair, and corner at UFL (CR2)

L F U2 F' D' F U2 F' D L' // commutator (CR3)

U D' L2 B' D' F' D F L D // 3x2x2

F' U F2 R F' // eo

R U' R2 U2 R U' R' // eof2l-1

U R' U2 R // insert FR edge and create pair in U (CR1)

U' y // AUF pair over FR edge

U R U R' F' U' L' U2 L U F // solve edges, pair, and corner at UFL (CR2)

L F U2 F' D' F U2 F' D L' // commutator (CR3)

In that solve, CR required

**26 moves**(24 after cancellations) to solve "LS/LL". We also didn't get an 8 move commutator .

Full solve =

**46 moves**

Let me know what you think of this approach or if anything seems wrong.

And don't forget to nominate this thread for

**best color-coding**, this December.

Last edited: Jul 23, 2017