Welcome to the Speedsolving.com, home of the web's largest puzzle community! You are currently viewing our forum as a guest which gives you limited access to join discussions and access our other features.

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... :/

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.

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.

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?

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?

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!

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?

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

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.

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

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

.
.

Method Overview

Spoiler: General Information

Proposer: Imam Tanvin Alam
Proposed: 15th May, 2019
No. Steps: 2 major
No. Algs: 0
Avg Moves: (unknown)
Purpose: Experimental

Pros and Cons: no algs, only blockbuilding

Spoiler: Main Theme

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

Spoiler

Petrus, Roux and other blockbuilding methods (except Heise) resort to 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 algorithms

Spoiler

Petrus uses OLL & PLL, or least Sune/Bruno, etc.

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

more recent 2GR methods (like Teoidus 2GR and ZZ C2GR) use 2GLL

but this method (2GB) requires no LL algorithms

in short, this is more of an intuitive blockbuilding approach to solving the cube

.
.

General Structure

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

Spoiler: Short Description

1. Reduce to 2-Gen
do EO, do CP, and build a 3x2x2 block (in any sequence)

2. Solve as 2-Gen
build 4 corner-edge pairs, then permute last 2 layers

Spoiler: Longer Description

1. Reduce to 2-Gen
- do EO & CP (at the very beginning, or while blockbuilding)
- build a 3x2x2 block while preserving EO & CP

2. Solve as 2-Gen
- build 4 corner-edge pairs LFU-FU, LBU-BU, DFR-FR, DBR-BR
(while building the 3rd pair, make sure L3C have the same orientation afterwards)
- permute the 4 pairs, along with L2C and L3E

Spoiler: How To

Spoiler: 1. Reduce to 2-Gen

Spoiler: 2GB Style

- perform EO (ZZ/Thistlethwaite style), optional EOLine at DF-DB (ZZ style) or at LF-LB (SSC style)

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

- expand to a 3x2x2 block

Spoiler: Wu RUPM Style

- build a 3x2x2 block

- perform EO & CP together

Spoiler: Wu PRUM Style

- build a 2x2x2 block at LDB

- perform EO & CP together

- expand to a 3x2x2 block

Spoiler: Teoidus 2GR Style

- perform EO while building a 2x1x1 block at LD

- perform CP while extending to a 3x1x1 block

- expand to a 3x2x2 block

Spoiler: ZZ C2GR Style

- perform CP while building a 3x2x1 block

- expand to a 3x2x2 block while performing EO

Spoiler: Briggs Style

- perform CP while building a 3x1x1 block

- extend to a 3x2x1 block

- perform EO (Roux style)

- expand to a 3x2x2 block

Spoiler: Briggs2 Style

- build a 2x2x1 block

- perform CP while extending to a 3x2x1 block

- perform EO (Roux style)

- expand to a 3x2x2 block

Spoiler: 2. Solve as 2-Gen

- only using <R, U> moves, build 4 corner-edge pairs
(recommended 4 pairs are LFU-FU, LBU-BU, DFR-FR and DBR-BR, but there are other options available)
(preserve all previously built pairs while building each new pair)
(while building the 3rd pair, make sure L3C have the same orientation afterwards)

- only using <R, U> moves, permute all pieces (4 pairs, 3 edges, 2 corners)

see fundamental techniques for further details

.
.

Fundamental Techniques

Spoiler: Blockbuild 4 Pairs

Spoiler: 1st Pair

build any one of the 4 pairs (LFU-FU, LBU-BU, DFR-FR, DBR-BR)

simply connect one of the 4 corners to its corresponding edge with <R, U> moves

this is similar to 3rd/4th F2L pair in CFOP, but easier, since the cross piece at RD does not matter and the R layer is free to move

Spoiler: 2nd Pair

any of the other 3 pairs can be built next

Spoiler: For Beginners

an easier option is to choose the 2nd pair to have 2 colors in common with the 1st pair, i.e. build 2 pairs from the same layer first

build the 2nd pair with <R, U> moves, while preserving the 1st pair

Spoiler: 3rd Pair & CO

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 either at RD locations or at UL locations

Spoiler

(the 2 corners should be adjacent to each other, but the 2 pairs should be parallel to each other)

now one layer (either U layer or R layer) is free to move

inspect the orientation of the 4 corners on the free layer

if it is possible to choose one of the remaining 2 target corners so that the other 3 corners on the free layer has the same orientation to one another after building the 3rd pair, then choose that corner for the 3rd pair (otherwise permute 1st & 2nd pairs differently, and inspect again)

Spoiler: For Beginners

if this substep seems too hard, then an easier option would be doing CO L4C, and then building the 3rd pair while preserving CO with 180 degree turns, i.e. with either <R2, U> or <U2, R> moves

Spoiler: Permuting Differently

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 influence orientation of the remaining corners in different ways

now build the 3rd pair with <R, U> moves, while preserving the first 2 pairs

Spoiler

after building the 3rd pair, CO L3C can be preserved simply by preserving the 3 pairs, so there is no need for the L3C to always look oriented after this substep

Spoiler: 4th pair

this one is quite straight forward

simply build the 4th pair with <R, U> moves, while preserving the first 3 pairs

Spoiler: Permute 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

Spoiler: How To

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

Spoiler: Possible Situations

4 situations possible, excluding the solved state

Spoiler: 2:2

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

Spoiler: 4:0

- all 4 pairs are solved
- L2C is solved
- EP 3-cycle is required (DR>RU>UL or LU>UR>RD)

Spoiler: 0:4, EP done

- all 4 pairs are swapped
- L2C is solved
- L3E is solved

Spoiler: 0:4, EP required

- 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 until the entire cube is solved

Spoiler: How To

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

Spoiler: How the Commutator Works

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

Spoiler: What This Commutator Does

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

Spoiler: Versions of the 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

Spoiler: Which Version to Choose

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 clock-wise 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)

Spoiler

(R2 is not allowed for the first move, because 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 clock-wise 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

Spoiler

(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 an R* (R/R2/R') turn, the only available option is an R2, to connect the other swapped corner (at LRB) 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)

Spoiler: Which Combination to Use

Spoiler: For 2:2

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 to turn it into one of the other cases described below

Spoiler: For 4:0

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)

Spoiler

(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 start with anticlockwise U', then the second commutator must start with clock-wise R, and not with anticlock-wise R')

Spoiler: For 0:4 (EP Done)

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 start with anticlockwise U', then the second commutator must start with clock-wise U)

Spoiler: For 0:4 (EP Required)

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)

Spoiler

(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 start with anticlockwise U', then the second commutator must start with anticlockwise R', and not with clock-wise R)

.
.

Why This Method

Spoiler

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 (<20) 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):

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.