mDiPalma
Member
- Joined
- Jul 12, 2011
- Messages
- 1,534
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.
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).
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)
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)
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)
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)
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)
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.
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
Let me know if something doesn't seem right.
The algs for a Clockwise U-layer 2x1x1 can be found in 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.
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 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.
(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)
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)
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)
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)
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)
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: