The New Method / Substep / Concept Idea Thread

efattah

Member
LMCF LSE is much more complicated than Roux LSE and one of the reason is exactly as people mentioned, that you have cases where the L/R colors are misaligned; doing L2 or R2 means that you can still technically do Roux LSE but if you do a quarter turn on L or R the color recognition becomes basically impossible; this is why LMCF LSE works very differently than Roux LSE so that it doesn't depend on the L-R colors being equal or opposite. In LMCF if you have the case where the remaining unsolved edges are the M-slice plus UL+UR, then you must convert the cube to a case where one of UL or UR contains either of the UL or UR edges in any permutation or orientation, then you solve UL+UR+orient midges in one step.

In 'bad' LMCF LSE cases, both UL and UR contain edges from the M-Slice. In this case it takes typically a 3-move U-M-U style combo to push a random UL/UR edge from the M-slice into any of their UL/UR slots in any orientation/permutation, then use one of the LMCF algorithms to finish. In this fashion the system is invariant of the L/R color alignment. Of course LMCF LSE also allows for the even more weird situation where the unsolved edges are UR+FR+Midges or UL+FL+Midges.

dudefaceguy

Member
I made a flowchart of my current method for solving corners. It's basically the two-look Petrus corner method (permute then orient) but solving in one look 40% of the time using a 3-cycle commutator. I use it for Roux and 4x4.

Sue Doenim

Member
Thanks for that LMCF rant we needed......
(we don't care, these people would appreciate it LMCF thread)
That's rather rude. He just gave you a whole bunch of feedback on your method, and you dismissed it as a bunch of self promotion (Which he deserves, by the way. The amount of work he's put into that method is staggering.)

WoowyBaby

Member
I made a flowchart of my current method for solving corners. It's basically the two-look Petrus corner method (permute then orient) but solving in one look 40% of the time using a 3-cycle commutator. I use it for Roux and 4x4.

Cool, I couldn’t say I’ve seen and idea like this! Flowcharts are very useful btw! I kinda want to play around with it, but I might need help on what ‘Eve’ is or how to do a pure twist commutator... :/

Last edited:

dudefaceguy

Member
Cool, I couldn’t say I’ve seen and idea like this! Flowcharts are very useful btw! I kinda want to play around with it, but I might need help on what ‘Eve’ is or how to do a pure twist commutator... :/

Eve is one of Lars Petrus's algorithms demonstrated here: https://lar5.com/cube/yE.html
I perform it as: R U2 L' U R' U' L R U2 R'
I actually find it very intuitive and fun to perform.

I don't know if there are other corner twist commutators, but the one I use is, for example, U[R D R' D' R D R']. I'm sure you know a shorter algorithm for this case.

Petrus uses double Sune for two twisted corners, which is the same number of moves as a corner twist commutator. I'm faster with the commutator though.

I like using Petrus corners for Roux because it's a two-look method that uses only 3 algorithms, all of which are very intuituve and easy to execute. I actually discovered Niklas on my own while using Heise, and used it for months before realizing that it was a famous algorithm.

I don't see much point in orienting first and then permuting for Roux corners - this seems like a carryover from CFOP. If you're solving the whole last layer, orient/permute makes sense, but permute/orient can solve corners in two looks with fewer cases to recognize. You can also force second-look skips pretty often if you understand what the algorithms are doing. Since I never learned beginners method or CFOP, Petrus corners seem like a good choice for Roux.

Fun fact: Lars Petrus's Allan algorithm, which is used to solve edges after corners are solved, is just a conjugate of the 4-move commutator that is usually used to solve the last 3 edges in Roux.

MethodNeutral

Member
When I first joined the forum I thought up this method (which should've been in this thread anyway) by adding CP to the beginning of ZZ. It wasn't really that effective because CP was done after EO and sometimes certain pieces would get stuck which made for awkward slice turns (I talked about this in the thread I linked).

Applying the initial CP step to Roux could be achievable though. The steps would be like this:

1. Place DL corners and DR corners. The pairs can be swapped as long as they're on their respective sides.
2. Permute corners (max 5 moves HTM, only 2 algs)
3. Sort left block pieces stuck in right block position
4. Solve left block using <L, M, U>
5. Solve right block using <R, M, U>
6. CMLL with only 7 algs (because CP was done earlier. 1/27 chance of skip)
7. LSE

The linked post talks about how steps 1&2 work. Step 3 is greatly simplified because of tricks like u L u' or D M D'. The rest is fairly standard, you lost some efficiency because you can't do F moves during first block but this is a 7 alg speedsolving method. Also, putting CP first means it can often be done in inspection, I've had some lucky solves already where I can cancel into the CP alg. I'm not sure if having 2-gen CMLL all the time is preferable for Roux since I use ZZ but let me know. I also considered the possibility of learning how to orient edges while doing 2-gen CMLL, but I think this has too many algs to be useful.

PapaSmurf

Member
Briggs 2 is basically a better version of what you're suggesting. You could also do ZBRoux but with CP.

White KB

One idea I have is a "mixed-up" method called RouxFOP, or more accurately RouxMOP.
It's a mix of Roux and CFOP, and you could do it if you're trying to get into either, or if you just want to use the method itself.
1. Solving blocks, like in Roux.
2. Solving remaining cross edges (and centers, as the case may be) using "M" slice, (hence the 'M" in RouxMOP) using a set of algs
3. Solving OLL
4. Solving PLL

An advanced way of doing this would be combining Steps 2 & 3, in "OLLy Cross" (I'm still working on the name)
Does this sound like a good method?

Thom S.

Member
Does this sound like a good method?
No, but it sounds like the most commonly proposed method there is

dudefaceguy

Member
One idea I have is a "mixed-up" method called RouxFOP, or more accurately RouxMOP.
It's a mix of Roux and CFOP, and you could do it if you're trying to get into either, or if you just want to use the method itself.
1. Solving blocks, like in Roux.
2. Solving remaining cross edges (and centers, as the case may be) using "M" slice, (hence the 'M" in RouxMOP) using a set of algs
3. Solving OLL
4. Solving PLL

An advanced way of doing this would be combining Steps 2 & 3, in "OLLy Cross" (I'm still working on the name)
Does this sound like a good method?
I use a roux mop when I spill delicious buttery sauces.

PapaSmurf

Member
One idea I have is a "mixed-up" method called RouxFOP, or more accurately RouxMOP.
It's a mix of Roux and CFOP, and you could do it if you're trying to get into either, or if you just want to use the method itself.
1. Solving blocks, like in Roux.
2. Solving remaining cross edges (and centers, as the case may be) using "M" slice, (hence the 'M" in RouxMOP) using a set of algs
3. Solving OLL
4. Solving PLL

An advanced way of doing this would be combining Steps 2 & 3, in "OLLy Cross" (I'm still working on the name)
Does this sound like a good method?
This is literally the most common method proposed, and it's a bad one. It is more moves and more time, so it's not good. We've all thought of this at one time or another though. The best version of this method (which is actually good) is ZBRoux, but it has 0 advantage over normal roux for 12 times the number of algs. Keep on thinking of ideas though!

efattah

Member
This is literally the most common method proposed, and it's a bad one. It is more moves and more time, so it's not good. We've all thought of this at one time or another though. The best version of this method (which is actually good) is ZBRoux, but it has 0 advantage over normal roux for 12 times the number of algs. Keep on thinking of ideas though!

After F2B, ordinary Roux has:
1. CMLL
2. Orient Edges
3. Solve UL+UR
4. Permute Midges
(4 steps)
in the advanced case of EOLR, the last three steps would be: CMLL + EOLR + Permute Midges (3 steps)
After F2B, ZBRoux does:
1. EO-DF-DB
2. ZBLL

So ZBRoux uses 2 steps, instead of either 3 or 4 for Roux. Since ZBLL recognition is nearly eliminated by identifying the ZBLL case during EO-DF-DB, you can't argue that large algorithm set recognition would make it slower than Roux. In fact, both steps of ZBRoux (EO-DF-DB and ZBLL) are fully algorithmic for maximum TPS. In basic roux, there is some degree of intuitive solving in LSE.
For these reasons I still believe ZBRoux does have an advantage over regular Roux, but (1) the advantage is fairly small for a large increase in memorization & drills, and (2) ZBRoux is fairly prone to errors and unreliability, as stalling on a ZBLL case ruins the whole solve, which is not likely to happen in regular Roux.
Still, with sufficient drills, I think ZBRoux has the advantage. Has anyone done a movecount comparison for Roux vs. ZBRoux?

WoowyBaby

Member
@efattah I agree that ZBRoux is pretty decent, unlike doing Roux Blocks then OLL and PLL xD
As for movecounts, I think it’s around:
11 CMLL
9 EOLR
6 Permute M
= 26?
10 EO-DFDB
15 ZBLL
= 25?
Know that ZBLL will be way longer (atleast 3-4 moves) than CMLL on average, and EO-DFDB will be just a bit longer than EOLR.

My numbers are probably off, so pls don’t kill me, if someone wants to find the true value they can test it with real solves (if you know ZBLL...)

Also another point for ZBRoux is that there’s less pause before execution compared to ZBLL in ZZ, because you can see your COLL case while doing EO-DFDB because M moves don’t mess up corners, so you can focus on your edges (If you track your epll during eo-dfdb, it is possible to have no pause before zbll).

Last edited:

PapaSmurf

Member
They actually have exactly the same movecount, and breaking LSE into 3 steps is kinda wrong, because it's completely pauseless. It's more like 3 half looks. Instead, think of it like this: CMLL is about 0.9 seconds and LSE is about 1.5. EODFDB is about 0.8 seconds, ZBLL is about 1.6. And no, I'm not picking arbitrary numbers, I'm using realistic ones. EODFDB is just over half of LSE (EOLR but a bit more), and ZBLL is CMLL plus 4c pretty much. If you get rid of all ZBLL recog time, I think it's pretty realistic to have an average execution time of a set of 493 algs to be 1.6. So ZBRoux is exactly the same as standard roux, just with a lot more practice required.

Thom S.

Member
Has anyone done a movecount comparison for Roux vs. ZB
Shiv3r made a Post some time ago (even in this Thread, I think) about having 300 Solves each with Jabari's ZBLLs and EOLR+(His own?)CMLLs and coming to the Conclusion that ZBroux uses 0.3 moves more on average

Imam Alam

Member
bismillaahir raHmaanir raHeem

Code:
Lars Petrus said:

The basic problem with the layer method is big, and obvious once you realize it.
When you have completed the first layer, you can do nothing without breaking it up.
So you break it, do something useful, then restore it.
Break it, do something, restore it.
Again and again.
In a good solution you do something useful all the time.
The first layer is in the way of the solution, not a part of it!

(https://lar5.com/cube/)

.
.

New Method Proposal

Method Name: 2GB (2-Generator Blockbuilding)

Similar to: RUP/PRUM/RUPM method by Tsung-Yen Wu, also Heise

.
.

Method Overview

Proposer: Imam Tanvin Alam
Proposed: 15th May, 2019
Variants: Lossless Solving Method (once a block is built, it is never broken, not even momentarily)
No. Steps: 2 major though lots of flexibility, depends on variant
No. Algs: 1~4 semi-intuitive commutator type 2-gen triggers, avg 6 HTM/STM (~5 additional semi-intuitive 2-gen algs for advanced)
Avg Moves: ~48-61 HTM/STM (depending on variant)
Purpose: Experimental (Speedsolving, Fewest Moves, One-Handed Solving possible)

Pros and Cons: no LL algs, blockbuilding until solved
this is a method that reduces the 3x3x3 cube to a 2-gen state (through blockbuilding), then proceeds to solve the rest as 2-gen (again, through blockbuilding)

the main difference between this method and all other blockbuilding methods (except Heise) is that this method utilizes blockbuilding techniques all the way through
Petrus, Roux and other blockbuilding methods (except Heise) resort to LL algorithms at one point or another

but this method (2GB) uses intuitive blockbuilding techniques throughout the solve, from start to finish

the main difference between this method and all other 2-gen methods is that this method is less dependent on predetermined/memorized Last Layer algorithms
Petrus uses OLL & PLL, or least Sune/Niklas, etc.

ZZ uses OCELL & CPLL, or TSLE & TTLL, or other LL algs

more recent 2GR methods (like Teoidus 2GR, Noah NCPB/NCPB 2.0, ZZ C2GR, Briggs/LEOR/YruRU) use 2GLL, or ZBLL, or other LL algs

but with this method (2GB) it is possible to solve the cube without using any LL algorithms

another unique feature of this method is that the cube may be solved in a "lossless" manner with it, i.e. once a block is built, it is never broken (not even momentarily) until the entire cube is solved
most methods frequently break what is built in previous steps (at least for a few moves) to make progress, e.g. the CFOP cross is broken every time an F2L pair is inserted

as for blockbuilding methods, even Petrus (momentarily) breaks previously built blocks to solve EO, and even Heise breaks previously built blocks while solving the last few corners with commutators

but this method (2GB) can be implemented in such a way that it does not require previously built blocks to be broken at any point in the solve

.
.

General Structure

1. Blockbuild to 2-Gen
2. Blockbuild as 2-Gen

do EO, do CP, and build a 3x2x2 block (in any order)

this is pretty straightforward, and knowledge of other methods would be useful during this step

build a Petrus style 3x2x2 block at LD, and perform EO and CP at the very beginning of the solve, or while blockbuilding, or immediately after the 3x2x2 block is completed

EO and CP may be done separately, i.e. it is acceptable to do EO at the beginning and CP after the entire 3x2x2 block, or CP after a 3x1x1 block and EO after a 3x2x1 block, or in any other sequence

the sequence of performing the 3 substeps (block, CP, EO) is quite flexible, the only thing that matters is that all 3 substeps are done after this step

only using <R, U> moves, build 4 corner-edge pairs, and adjust CO, then permute last 2 layers

first, build 4 corner-edge pairs, and do CO L4C while building the 3rd pair

(example 4 pairs are LFU-FU, LBU-BU, DFR-FR and DBR-BR, but there are other options available)

(while building the 3rd pair, make sure L3C have the same orientation when permuted correctly)

then permute all pieces (4 pairs, 3 edges, 2 corners)

(the final substep is to solve the R and U layers, by permuting the 4 pairs along with L2C and L3E)

.
.

Algorithms List

for the 4 algorithms, the average alg length is 6.00 HTM
(7 + 7 + 5 + 5 = 24 HTM; 24/4 = 6.00 HTM)

all of these are semi-intuitive commutator type 2-gen algs
trigger 1 (CO): 7 HTM
R U R2 (U') R2 U R = [R U: R2][R': U]

trigger 2 (3rd edge): 7 HTM
R (U2 R2 U2 R2 U2) R = [R: [U2 R2 U2, z' y2]]

trigger 3 (3rd pair): 5 HTM
R (U2 R2 U2) R = [R: [U2, R2]]

trigger 4 (permute all): 5 HTM
R U (R2) U' R' = [R U: R2]

note that trigger 1 is actually an extension of trigger 4 (permute the pairs with trigger 4, then put the DBR-BR pair back to its original location), and that trigger 3 is actually a truncated version of trigger 2

i.e. these 4 algs may be considered to be only 2 algs (trigger 1 for corners/pairs permutation, and trigger 2 for edges permutation)

going further, it may be possible to make the entire second step (Blockbuild as 2-Gen) more intuitive by thinking of it as simply "moving the blocks around" (for details, see "Alternative Algs & Recognition" in "Advanced CO" under "Improvements & Alternatives")
depending on how many corners are oriented on the U layer, the algorithm (trigger 1 and inverse) needs to be applied 1~2 times (avg 1.63 times)
(0*1 + 1*4 + 1*4 + 2*2 + 2*4 + 2*4 + 2*4 + 2*4 = 44 times; 44/27 = 1.63 times)

the flowchart diagram below shows the cases and an easy scheme for recognition

an easier recognition scheme would be to only use the simplified diagram on the right, where the algorithm (trigger 1) is used exclusively, without any inverse or mirror, however this results in higher move count, since the alg would need to be applied 1~3 times (avg 2.00 times)
(0*1 + 1*4 + 2*4 + 3*2 + 3*4 + 2*4 + 2*4 + 2*4 = 54 times; 54/27 = 2.00 times)

trigger 1 replaces RD edge with RU edge, which is sometimes helpful for the next substep (capture the 3rd pair edge)

using only trigger 1 and its mirror (and setup moves), the following algorithms may be constructed:

so, the basic alg (trigger 1) and its mirror gives us a CO alg set of 2 algs (avg 11.77 HTM)
(0*1 + 7*4 + 7*4 + 15*2 + 13*4 + 15*4 + 15*4 + 15*4 = 318 HTM; 318/27 = 11.77 HTM)

to swap two pairs, use this commutator:

Code:
X  Y  (X2) Y' X'

where
X = R/R'/U/U'
Y = U/U'/R/R'

this simple 5-move 2-gen commutator is essentially its own mirror
X = do a 90 degree turn of any one layer (e.g. R/R'/U/U') to bring one pair at the intersection of the two layers

Y = do a 90 degree turn of the other layer (U/U'/R/R') to remove one pair from the intersection, and at the same time bring another pair at the intersection

X2 = now swap two pairs on the first layer with a 180 degree turn (R2/U2)

Y' = place the swapped pair on the second layer with a 90 degree turn backwards (U'/U/R'/R)

X' = put all 4 pairs back to parallel positions with a backwards 90 degree turn of the first layer (R'/R/U'/U)

notice that this commutator affects 2 pairs, 2 opposite edges, and 2 adjacent corners
this commutator does the following:

1. swaps two opposite edges on one layer (they are located in parallel with the pairs, on the layer that gets turned for the first move of the commutator)

2. swaps and twists two adjacent corners at the intersection of the two layers

3. swaps two opposite pairs, one from each layer (the first move of the commutator takes the corners at the intersection either towards F layer or towards B layer, and the two pairs on that side get swapped)

there are 4 possible versions of this commutator
the 4 versions are as below:

Code:
a. R  U  (R2) U' R'   B layer pairs swapped, R layer edges swapped, R-U intersection corners swapped and twisted

b. U' R' (U2) R  U    B layer pairs swapped, U layer edges swapped, R-U intersection corners swapped and twisted

c. R' U' (R2) U  R    F layer pairs swapped, R layer edges swapped, R-U intersection corners swapped and twisted

d. U  R  (U2) R' U'   F layer pairs swapped, U layer edges swapped, R-U intersection corners swapped and twisted

different versions, or combination of them, need to be applied for different situations
let us suppose the cube is in the "2:2" situation (LBU-BU & DBR-BR pairs swapped, URF-URB corners swapped and twisted, RU-RD edges swapped)

so the first move of the commutator should be of the R layer (not U layer), since the swapped edges are on that layer

also, the first move should be a clockwise turn R (not R'), since this move connects one swapped corner (at URF) with a pair (at LBU-BU), resulting in a 3x1x1 block at UB

(notice that U' also connects the corner at URF with the pair at DBR-BR, but we are not choosing U' since the U layer does not have a swapped edge pair)
(R2 is not allowed for the first move, because then the next move U/U2/U' would break a pair)

for the second move, the only available option is to turn the U layer (not the R layer), since R layer was turned immediately before this move

the second move should be a clockwise turn U (not U'/U2), since this move connects the newly built 3x1x1 block with the 2 edges (at FR-RB), resulting in a 3x2x1 block on the R layer
(U'/U2 are not allowed for the second move, otherwise the next move R/R2/R' would break a pair)

for the third move, which must be an R* (R/R2/R') turn, the only available option is an R2, to connect the other swapped corner (at DRB) with a pair (at LFU-FU), resulting in a 3x1x1 block at UF

the fourth move must be a U' turn, resulting in a 3x3x1 block on the R layer

and finally, the fifth move must be a R' turn, thus solving the cube

therefore, the chosen version of the commutator becomes: R U (R2) U' R'

applying this commutator 1~2 times is enough, or 3 times in rare situations (e.g. swapped edges at LU-RD)
2 pairs are swapped, 2 corners are swapped, 2 edges are swapped

if the 2 edges are on the same layer (i.e. RU-UL or DR-RU), then apply the commutator once, as described above

if the 2 edges are not on the same layer (i.e. UL-RD), then 3 commutators are required: simply do any version of the commutator once to turn it into one of the other cases described below
EP 3-cycle is required (DR>RU>UL or LU>UR>RD)

in other words, two 2-swaps are needed (e.g. DR>RU>UL could be solved by first swapping RU-UL with one commutator, and then swapping DR-RU with another commutator)

so the commutator needs to be applied twice, and they must be different versions, one version starting with one layer (e.g. U layer) and the other version starting with the other layer (R layer)
(same version would only affect the same two edges twice)

but the pairs (and the corners) are already solved, that means the same 2 pairs need to be involved in both versions of the commutator, so that they get swapped with one commutator and then get swapped back with the other

so the second commutator needs to start with the opposite rotational direction (e.g. if the first commutator starts with anticlockwise U', then the second commutator must start with clockwise R, and not with anticlockwise R')
all 4 pairs are swapped

that means the commutator needs to be applied twice, once to swap the F layer pairs, and again to swap the B layer pairs

and they must be different versions of the commutator, since they need to affect different pairs

but L2C and L3E are already solved, so both versions of the commutator must start with turns of the same layer (e.g. both first and second commutators may start with R layer), so that the two edges on that layer get swapped and then swapped back to their original locations

because the two versions need to affect two different sets of pairs, and they must start with the same layer, the second commutator has to start with the opposite rotational direction (e.g. if the first commutator starts with anticlockwise U', then the second commutator must start with clockwise U)
all 4 pairs are swapped

so the commutator needs to be applied twice, once to swap the F layer pairs, and again to swap the B layer pairs

but L2C is already solved, that means they need to be swapped twice to be solved again

also, all 3 edges need to be cycled (DR>RU>UL or LU>UR>RD), so two 2-swaps are needed (e.g. DR>RU>UL could be solved by first swapping RU-UL with the first commutator, and then swapping DR-RU with the second commutator)

so the two commutators need to be different versions, one version starting with one layer (e.g. U layer) and the other version starting with the other layer (R layer)
(same version would only affect the same two edges twice)

because the two commutators need to affect two different sets of pairs, and they must start with different layers, the second commutator must start with the same rotational direction (e.g. if the first commutator starts with anticlockwise U', then the second commutator must start with anticlockwise R', and not with clockwise R)

.
.

Fundamental Techniques

there are many other ways of achieving this, some of them are outlined below:

- build a 3x2x2 block

- perform EO (Petrus style)

- perform CP with D' R (U) R' D or L U' (R') U L'
- perform EO (ZZ/Thistlethwaite style), optional EOLine at DF-DB (ZZ style) or at LF-LB (SSC style)

- perform CP (HSC/Morozov/Benek style), optional 3x1x1 block at LD

- expand to a 3x2x2 block
- build a 3x2x2 block

- perform EO & CP together
- build a 2x2x2 block at LDB

- perform EO & CP together

- expand to a 3x2x2 block
- build a 2x2x2 block at LDB

- perform CP

- expand to a 3x2x2 block

- perform EO (Petrus style)
- perform CP while building a 3x2x1 block

- expand to a 3x2x2 block while performing EO
- perform EO while building a 2x1x1 block at LD

- perform CP while extending to a 3x1x1 block

- expand to a 3x2x2 block
- perform CP while building a 3x1x1 block

- extend to a 3x2x1 block

- perform EO (Roux style)

- expand to a 3x2x2 block
- build a 2x2x1 block

- perform CP while extending to a 3x2x1 block

- perform EO (Roux style)

- expand to a 3x2x2 block
the 4 pairs can be chosen in many ways, but note that 2 of these pairs need to be "towards" pairs and the other 2 need to be "away" pairs, as shown below:

whether a pair is considered a "towards" pair or an "away" pair depends on how they fit into the intersection of the R & U layers, as shown above

for ease of understanding, the most symmetric version has been chosen here, since it is the easiest in terms of blockbuilding and recognition (more options are discussed in "Alternative Pairs" under "Improvements & Alternatives")

that means for the 1st pair we have 2 choices (yellow or green), the 2nd pair must be the remaining RD pair (green or yellow), then for the 3rd pair we have 2 choices (cyan or magenta), and the 4th pair must be the remaining U layer pair (magenta or cyan)
for the 1st pair, simply connect the target corner with its corresponding edge with <R, U> moves
this is similar to 3rd/4th F2L pair in CFOP/ZZ/Petrus, but easier, since the cross piece at RD does not matter and the R layer is free to move

then build the 2nd pair with <R, U> moves, while preserving the 1st pair
once again, this is similar to 3rd/4th F2L pair in CFOP/ZZ/Petrus, but easier, since the cross piece at RD does not matter

the only difference with last time is that this time the 1st pair needs to be preserved
the 3rd pair is harder than the other pairs, mainly because CO must be done along with this pair

using <R, U> moves, place the 1st & 2nd pairs at RD locations
(the 2 corners should be adjacent to each other, but the 2 pairs should be parallel to each other, not perpendicular)

now the U layer is free to move

inspect the orientation of the 4 corners on the free layer
these 4 corners are: 2 target corners for the 3rd pair and 4th pair, and the last 2 corners that do not form any blocks until the final substep

perform CO L4C with trigger 1 and its mirror

place the chosen 3rd pair edge at RD location (i.e. between the 1st and 2nd pairs) with trigger 2 or its mirror

now build the 3rd pair with trigger 3 or its mirror, while preserving the first 2 pairs
the 4th pair is quite straight forward: simply build the pair with <R, U> moves (trigger 3 or its mirror in particular), while preserving the first 3 pairs

now on to the last substep (permuting the last 2 layers):

using <R, U> moves, place any 2 pairs at RD locations and the other 2 pairs at UL locations (permutation of the pairs does not matter), each couple of pairs should be parallel to each other
achieving this state is quite easy, requiring only 1~2 turns

if one layer (e.g. U layer) has 3 pairs, move the 2 parallel pairs out of the intersection of the two layers with U* (U/U') if needed

this would also put the other 2 pairs in parallel on the other layer (R layer), simply do a single turn R* (R/R') to place all 4 pairs at RD and UL locations

now inspect the permutation of all pieces on R and U layers

there are 9 pieces to consider: 4 corner-edge pairs, 3 edges, 2 corners

at this point, L2C can only be in 1 of 2 states (either solved, or swapped and twisted) & L3E can only be in 1 of 2 states (either solved, or requiring an EP 3-cycle/2-swap), so recognition is very easy
4 situations possible, excluding the solved state

- two opposite pairs are solved (on F/B layer) and the other two opposite pairs are swapped (on B/F layer)
- L2C is swapped and twisted
- any 2 edges are swapped (UL-UR or RU-RD or LU-RD)
- all 4 pairs are solved
- L2C is solved
- EP 3-cycle is required (DR>RU>UL or LU>UR>RD)
- all 4 pairs are swapped
- L2C is solved
- L3E is solved
- all 4 pairs are swapped
- L2C is solved
- EP 3-cycle is required (DR>RU>UL or LU>UR>RD)

(if L3E is solved but L2C is not solved, then a mistake was made in a previous substep)

finally, permute the 4 pairs with <R, U> moves (trigger 4 and its mirrors in particular) until the entire cube is solved

.
.

Example Solve

qqTimer Scramble (generated on 15th May, 2019):

U' R' U2 R U2 R U2 R' U R' U R' U' R2 U2 R2 U2 R' U' R U2 R2 U' R U
live solve 34 HTM/STM, reconstruction 30 HTM/STM:

R' U2 R' U2 R U' R2 U' (R' R') U' R2 U R2 (U' R' R U2) R2 U2 R2 U2 R U2 R U2 R2 U2 R' U R' U R U'

Code:
R' U2 // 1st pair
R' U2 R // 2nd pair
U' R2 U' R' // permute to RD
R' U' R2 U R2 U' R' // (partial) CO
R U2 R2 U2 R2 U2 R // capture 3rd edge
U2 // setup
R U2 R2 U2 // 3rd pair
R' U R' U // 4th pair
R U' // permute everything (skip)
to see a simulation of the solve, paste the scramble and the solution here:

https://alg.cubing.net/

paste the scramble under "setup" and the solution or the explanation under "moves"
- optimal 1st step is 18 ~ 27 moves, so it is humanly possible within 30 moves with practice
calculation 1: optimal 3x2x2 block is 8~9 moves, optimal CP+EO is 10~15 moves
references:
https://presleygit.github.io/ru_eng.html

calculation 2: optimal EOline is 6~7 moves (6.127 QTM), optimal 3x2x1 block is 9~10 moves (9.69 QTM), CP is 8~10 moves (QTM)
references:
https://web.archive.org/web/20080612111837/http://www.speedcubing.com.pl/nooks_zz.htm
https://web.archive.org/web/20120923050702/http://qblog.be/2010/04/zzf2l-move-count-analysis-part-2/
https://presleygit.github.io/ru_eng.html

- optimal 2nd step is 20 moves or less
optimal <R, U> 2-gen solve is 20 moves max, and ~16 moves avg
reference:
http://forum.cubeman.org/text/fullcube.txt

- so if the 2nd step can be consistently done in 30~40 moves, then total move count is within acceptable range (<70 moves)

- this solve had a skip, which is not unusual, almost every solve ends up having one or two small substep skips (and more familiarity and knowledge about the method usually means higher chances of a skip)

- this solve utilizes some advanced techniques such as Advanced CO and advanced EP (see "Improvements & Alternatives")

.
.

Improvements & Alternatives

sometimes CO L4C does not need to be completed, simply orienting the target corner for the 3rd pair and making sure that the L3C have the same orientation as one another is enough

in other words, there is no need for the L3C to always "look" oriented after this CO substep, rather they need to be oriented correctly only when they are permuted to their correct locations later on

i.e. there are 3 acceptable situations when all corners are permuted correctly:

a. target corner is oriented, all 3 of 3 remaining corners are also oriented correctly
b. target corner is oriented, all 3 of 3 remaining corners are twisted clockwise
c. target corner is oriented, all 3 of 3 remaining corners are twisted anticlockwise

again, this means that the corners would not always "look" oriented during the solve, even after CO substep is done (see example solve)

note that with this approach, there is a 1/3 probability of a CO skip, and for the rest of the cases applying the CO alg just once is enough, i.e. the CO is only applied avg 0.66 times per solve, and CO step movecount goes down to avg 7.00 HTM per solve
there are 4 ways to permute the first 2 pairs while influencing CO L4C

i.e. there are 4 ways to move the 2 pairs from RD locations to UL locations, or vice versa:

Code:
a. R U2 R2 U' -- U R2 U2 R'

b. R' U2 R2 U -- U' R2 U2 R

c. R U R' U R' U' -- U R U' R U' R'

d. R' U' R U' R U -- U' R' U R' U R

each of the above options twist 2 adjacent corners in opposite directions

Code:
                                                effects
clockwise anticlockwise

a   R U2 R2 U'       =   [R U2, z' y2]         URF   URB

a'  U R2 U2 R'       =   [U R2, z' y2]         URB   URF

b   R' U2 R2 U       =   [R' U2, z' y2]        URF   URB

b'  U' R2 U2 R       =   [U' R2, z' y2]        URB   URF

c   R U R' U R' U'   =   [[R: U], z' y2]       ULF   URF

c'  U R U' R U' R'   =   [[U: R], z' y2]       URB   DRB

d   R' U' R U' R U   =   [[R': U'], z' y2]     URB   ULB

d'  U' R' U R' U R   =   [[U': R'], z' y2]     DRF   URF

any 2 adjacent corners can be chosen to be twisted, simply by rotating the free layer immediately before permuting the 2 pairs

only knowing and using options (a) and (b) is usually enough: they are shorter, more symmetric, and they only affect the 2 corners at the intersection of R and U layers

with the 1st and 2nd pairs at RD locations, do either (a) or (b) to move the 2 pairs to UL locations while twisting the 2 corners at the intersection

then do a single R* (R/R2/R') move (this replaces 1 or 2 corners at the intersection)

then do either (a') or (b') to move the 2 pairs to RD locations while twisting the 2 corners at the intersection

there are 8 possible combinations, as given below:

Code:
R U2 R2 U' (R) U' R2 U2 R   <=>   R U2 R2 U' (R') U' R2 U2 R

R U2 R2 U' (R) U R2 U2 R'   <=>   R U2 R2 U' (R') U R2 U2 R'

R' U2 R2 U (R) U' R2 U2 R   <=>   R' U2 R2 U (R') U' R2 U2 R

R' U2 R2 U (R) U R2 U2 R'   <=>   R' U2 R2 U (R') U R2 U2 R'

each pair of algs use the same move sequence, except for a single move right in the middle

this is a set of 9 HTM CO algs that are easy to understand, remember, and apply

note that these algs replace the RD edge with UR edge, just like the basic alg (trigger 1) does

below is an alternative flowchart diagram showing an easy scheme for recognition:

although recognition would be different for this alg set, the advantage of knowing this would be to eliminate the need to practice mirror cases and simply remember to choose a single move R* (R/R2/R')
combining a 4 move long sequence with a 6 move long sequence results in another set of CO algs

a special subset of this set is when several moves get canceled out:

Code:
(R U2 R2 U') (U R U' R U' R')   =>   (R U2 R') U' (R U' R')

(R' U2 R2 U) (U' R' U R' U R)   =>   (R' U2 R) U (R' U R)

(R U R' U R' U') (U R2 U2 R')   =>   (R U R') U (R U2 R')

(R' U' R U' R U) (U' R2 U2 R)   =>   (R' U' R) U' (R' U2 R)

this results in 7 HTM CO algs known as sune/antisune etc

note that these algs preserve the RD edge unlike the basic alg (trigger 1), so this alg set could be used as an alternative to trigger 1 when a suitable target edge is already at the RD location
once again, combining a 4 move long sequence with a 6 move long sequence results in another set of CO algs

another special subset of this set is when the RD edge is replaced with UL edge:

Code:
(R' U' R U' R U) (U R2 U2 R')   =>   R' U' R U' R U2 R2 U2 R'
(R U R' U R' U') (U' R2 U2 R)   =>   R U R' U R' U2 R2 U2 R

this is a set of 9 HTM CO algs that influences EP L3E in a different way
the basic alg (trigger 1) and its mirror gives us a CO alg set of 2 algs (avg 11.77 HTM)

this could be extended so that each of the 7 possible CO cases are considered individually:

the above is an optimal 2-Gen OCLL alg set (disregarding RD edge) consisting of 7 algs 7~15 HTM each (avg 10.30 HTM)
(0*1 + 7*4 + 7*4 + 11*2 + 9*4 + 13*4 + 13*4 + 15*4 = 278 HTM; 278/27 = 10.30 HTM)

this is only ~1.5 HTM shorter on average, however this may have other benefits such as more control over edge permutation

knowing some (or all) of the above techniques should enable better control over CO L4C, and thus result in lower move count and higher solving speed
sometimes there are obvious shortcuts towards the end, e.g. 1 or 2 ready-made pairs are already there, although they are not the same pairs as planned

in these cases it is a good idea to utilize those pairs

so once this extended approach is adopted, there are quite a few added options

for ease of recognition, the 3rd and 4th pairs should have 2 colors in common, as shown below:

so for the 1st pair we have 2 choices (yellow or green), the 2nd pair must be the remaining RD pair (green or yellow), then for the 3rd pair we have 4 choices as shown below (cyan or magenta), and the 4th pair must be the remaining U layer pair (magenta or cyan)

of course, choosing one the other 3 options would require a single U* (U/U2/U') move at the very end of the solve (not to mention slightly harder recognition)

with this approach, there are 8 options for the 3rd pair after CO, with 4 corners and 4 edges to choose from, and any one of these 4 edges can be chosen (for the 3rd pair) at this point

out of the 5 remaining edges, there are 4 target edges (i.e. all available edges are suitable, except for the edge this a D sticker), so there is a 4 out of 5 probability that a suitable edge is already at RD location and trigger 2 would not be required
another easy option is to start with UFR-FR and UBR-BR pairs as 1st and 2nd pairs (CO may be done in terms of opposite faces U and D):

simply do R2 after CO and proceed with 3rd and 4th pairs
another option is to start building LFU-FU and LBU-BU pairs as 1st and 2nd pairs (CO may be done in terms of R face instead of U face):

to make recognition easy, the cube may be rotated (z x2) after building the 1st and 2nd pairs
we can go one step further and consider 3rd and 4th pairs that are not parallel to each other (see the 4 cases below):

obviously edge permutation and pair permutation approach would need to be revised if these pairs are allowed (either by making it more intuitive or by learning algorithms for more cases)
tangent pairs on the U layer essentially means there are two diagonally opposite corners (instead of two adjacent corners) that are not part of any block yet, and there are two adjacent edges (instead of two opposite edges) that are not part of any block yet

the 3rd and 4th pairs can still be built with the basic algs (algs 1 ~ 4)

if no shortcut is taken (i.e. not using any moves other than <R, U> and not breaking any of the 4 pairs), then the way to permute the last 3 edges is to do the following:

1. do a U* (U/U2/U') move so that one of the two pairs is in the intersection, and the edge with the D layer sticker is next to it (i.e. either at UF location or at UB location)

2. if the pair at intersection is a "towards" pair (i.e. it is at URF location) then do R' U' R U R U R U' R' and if the pair at intersection is an "away" pair (i.e. it is at URB location) then do R U R' U' R' U' R' U R

of course recognition would be quite difficult for this approach

start with the basic pairs, then experiment with inverted pairs and parallel 3rd-4th pairs, and try starting with the UL pairs, and leave tangent pairs on the R layer for later

there are even more advanced options available (the 4 pairs may be chosen in 63 unique ways), but the options shown above are the ones that are relatively easier to master
this is related to "Alternative Pairs"

in fact these 2 ideas (Advanced EP and Alternative Pairs) may be considered as one and the same (the only difference is whether we allow ourselves to break the 1st and 2nd pairs for a couple of moves or not)

there are situations where it might be a good idea to break the 1st and 2nd pairs momentarily

(e.g. the 4th pair is not made yet, but all corners are solved, and only 3 or 4 edges need to be cycled)

full advantage should be taken of these situations
if CO L4C is fully (not partially) done after the 1st and 2nd pairs, the corners are essentially solved, all that is left is EP L5E

1 of those 5 edges has a D sticker, rest of them have U stickers

possible cases:

a. any 2 opposite U layer edges are solved (i. e. two 3x1x1 blocks are formed on the U layer) - edges 3 cycle needed, simply do M' U2 M (U*) after setup moves and cube rotations

b. any 2 opposite U layer edges are swapped on U layer - with a single U* (U/U2/U') move place them at UF-UB locations, then swap them using trigger 2 (now we have situation a)

c. any 2 adjacent U layer edges are solved - edges 3 cycle needed, do M' U2 M (U*) after setup moves and cube rotations

d. D layer edge is solved - any EPLL alg may be used (Z-perm, H-perm, U-perm)

e. 4-cycle or 5-cycle required - solve with commutators, or with trigger 2 (look at the edge at RD location, bring its correct location at RU location with a single U* (U/U2/U') move, apply trigger 2; repeat as many times as necessary until case a/b/c/d is achieved)
move count may be reduced by focusing on lookahead and merging of successive substeps

e.g.

- be comfortable with achieving CP and EO in many different ways before, while, or after building the 3x2x2 block and its subset blocks

- try making the 1st and 2nd pairs simultaneously

- influence CO L4C while permuting the 1st and 2nd pairs to RD locations, or at least force an easy case

- anticipate the CO case and bypass CO when possible, and go straight to the 3rd pair

- utilize different ways of doing CO to capture a suitable edge between the RD pairs (hint: some edges give better results than others)

- try making the 3rd and 4th pairs simultaneously

- start permuting all pieces while building the 4th pair, or at least force an easy case

.
.

Variants & Optimization

"Lossless" simply means that once a block is built, it is never broken, not even momentarily, until the entire cube is solved
- EO (ZZ/Thistlethwaite style)

- line (D line or L line)

- CP using <R, U, L, D> (HSC/Morozov/Benek style)

- 3x2x2 block (E edges with <E> move, M edges <M> move)

- 2 pairs (RD pairs)

- CO L4C

- 2 pairs (UL pairs)

- permute all (EP, others)
- CP (HSC/Morozov/Benek style)

- 3x2x1 block (S edge with <S> move, E edges with <E> move)

- EO (Roux style)

- 3x2x2 block (M edges with <M> move)

- 2 pairs (RD pairs)

- CO L4C

- 2 pairs (UL pairs)

- permute all (EP, others)
- EO & 2x1x1 (Teoidus 2GR Style)

- CP & 3x1x1 (Teoidus 2GR Style)

- 3x2x1 block (E edges with <E> move)

- 3x2x2 block (M edges with <M> move)

- 2 pairs (RD pairs)

- CO L4C

- 2 pairs (UL pairs)

- permute all (EP, others)
- EO (ZZ/Thistlethwaite style)

- CP using <R, U, L, D> (HSC/Morozov/Benek style)

- 3x2x1 block (S edge with <S> move, E edges with <E> move)

- 3x2x2 block (M edges with <M> move)

- 2 pairs (RD pairs)

- CO L4C

- 2 pairs (UL pairs)

- permute all (EP, others)
- 3x2x2 block (Petrus style)

- EO (Petrus style)

- 2 pairs (RD pairs)

- CO L4C

- CP (place the 2 pairs at RD and place the swapped corners at the intersection, then do L U' R' U L', then do U' R to send the 2 pairs back to RD)

- 2 pairs (UL pairs)

- permute all (EP, others)

.
.

Why This Method

solving as fast as possible is not my goal, nor winning competitions, rather my main goal is to solve the 3x3x3 cube with more understanding, and rely less on rote memorization (also solving in fun, novel and elegant ways in the meantime)

I prefer methods that require some intuitiveness (or simplified versions of the popular methods), they should be aesthetically pleasing, and should have significantly different step(s) compared to more popular methods

I like my methods to have relatively few (<10) algs with relatively low (<70) move count STM/HTM, the algs should be easy to understand and easy to implement, so shorter and simpler algorithms are preferred (and ergonomic if possible, preferably 2-gen)

rationale behind proposing this method (and similar methods by other proposers):

.
.

Code:
Ryan Heise said:

Once we have managed to join pieces together to form blocks, we then treat those blocks as single units.
We move them around like they are one piece, and we try not to break them up.

(https://www.ryanheise.com/cube/block_units.html)

subHaanakallaahumma wa biHamdika ashhadu an laa ilaaha illaa anta astaghfiruka wa atoobu ilaika

Last edited:

efattah

Member
Shiv3r made a Post some time ago (even in this Thread, I think) about having 300 Solves each with Jabari's ZBLLs and EOLR+(His own?)CMLLs and coming to the Conclusion that ZBroux uses 0.3 moves more on average

This may be true, but it neglects the critical factor of what 'gen' those moves are. The MU finish of Roux has a really nice aspect that it is ultra-stable and extremely consistent, fingertrick errors happen very rarely, so reliability is a huge plus, but TPS on MU is poor. ZBRoux uses MU for EO-DF-DB and various different gen algs for the last layer, but if you look at the movecounts listed above, ZBRoux has fewer MU moves (around 10) vs. 15 for regular Roux.
To give a real world example, LMCF can finish (sometimes) with pure-MU L6E if UL/UR are the last unsolved edges, but in the case where UR+FR are unsolved, the LSE algs are RrUM instead of MU, and although it takes 0.5 extra moves to resolve that case (on average), TPS is significantly higher.

In the case of Roux vs. ZBRoux, the two methods are so close I don't think any technical analysis can 'resolve' which is better, it would ultimately take a group of people each devoted to their respected version and many years, to see which comes ahead.

WoowyBaby

Member
New FMC Method,
Woowy’s Thistlewaite Reduction

1. EO + CP + HTO 2x2x3
2. 2-Gen HTO Redux
3. Half-Turn-Only Finish

Example Solve-
Scr: B2 D2 U2 L' B2 R' B2 L' F2 D2 L' R' U F' D' U' R F2 U F2
L’ U’ R2 F’ U’ B2 L2 R’ D U2 L’ U L // Step 1 (ew 13 moves)
R’ U’ R2 U R’ U2 R2 U’ R U R U R U' R' U' R2 U’ // Step 2 (lol a U-Perm)
Rw2 R2 U2 Rw2 R2 U2 B2 U2 B2 // Step 3

This example solve is just meant to show you what the steps do. This is more of a proof of concept of Half-Turn-Only/Thustlewaite Reduction, and NOT an example of efficiency, as I didn’t try the same way as I would in a FMC attempt.

To explain 2-Gen HTO Redux a little more, it includes orienting six corners, positioning two corners, and placing seven edges into their correct slices.
- Also, 2-Gen HTO Redux doesn’t have to be 2-gen, obviously if you see a super easy solution that has L or D moves in it then of course use that, but remember, moves that aren’t RU can mess up EO, or even more problematic, CP. The second step doesn’t need you to keep track as many things as with the whole of HTO Reduction, which makes finding solutions so much faster, which is important in FMC (1 hour limit).

Why Half-Turn-Only Reduction instead of just Kociemba Phase 1?
- Half-Turn-Only state is easy to find an optimal or near-optimal solution, unlike Kociemba Phase 2.
On average HTO is 9 HTM away, while Phase 2 is much more, and it’s almost impossible to get optimal or near-optimal results for Kociemba Phase 2.
In the example solve above, it was blinding-ly easy to see an efficient solution (9 HTM). If I tried the scramble more, I could solve the other steps differently to influence/cause the HTO step to be very short, perhaps well under 9.

That’s about it for right now, what are your thoughts on this?

Last edited:

PapaSmurf

Member
Seems good, but I have no idea how it works, so a bitt more info would be great to allow me and others to test it out!