• 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.

    Registration is fast, simple and absolutely free so please, join our community of 35,000+ people from around the world today!

    If you are already a member, simply login to hide this message and begin participating in the community!
Joined
Feb 17, 2019
Messages
57
Likes
50
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.
 
Joined
Jan 4, 2017
Messages
39
Likes
2
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.
 
Joined
Oct 3, 2017
Messages
186
Likes
63
Location
3141 Rubik's Cube Ave., Somewhere on E_rth
WCA
2019BRUC01
YouTube
WhoCube
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?
 
Joined
Feb 17, 2019
Messages
57
Likes
50
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.
 
Joined
Jan 4, 2018
Messages
377
Likes
270
WCA
2016TUDO02
YouTube
PapaSmurf Cubes
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!
 
Joined
Feb 14, 2016
Messages
515
Likes
422
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?
 
Joined
May 27, 2018
Messages
350
Likes
230
Location
United States
WCA
2018ISOM02
YouTube
https://www.youtube.com/channel/UCzgIKWl
@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:
Joined
Jan 4, 2018
Messages
377
Likes
270
WCA
2016TUDO02
YouTube
PapaSmurf Cubes
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.
 
Joined
Apr 2, 2019
Messages
8
Likes
6
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: 2~4 semi-intuitive commutator type 2-gen algs, 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, and ZZ C2GR) use 2GLL

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


cube.PNG

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

(see fundamental techniques for more information)
only using <R, U> moves, build 4 corner-edge pairs, then permute last 2 layers

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

(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 when permuted correctly)

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

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

(preserve all 4 pairs while permuting the last 2 layers)

(see fundamental techniques for more information)

.
.

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
alg 1 (CO): 7 HTM
R U R2 (U') R2 U R

alg 2 (3rd edge): 7 HTM
R (U2 R2 U2 R2 U2) R

alg 3 (3rd pair): 5 HTM
R (U2 R2 U2) R

alg 4 (permute all): 5 HTM
R U (R2) U' R'

note that alg 1 is actually an extension of alg 4, and that alg 3 is actually a truncated version of alg 2

i.e. these 4 algs may be considered to be only 2 algs (alg 1 for corners/pairs permutation, and alg 2 for edges permutation)
depending on how many corners are oriented on the U layer, the algorithm (alg 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

CO.png

an easier recognition scheme would be to only use the simplified diagram on the right, where the algorithm (alg 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)

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

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

CO BASIC.png

so, the basic alg (alg 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)

(see "Advanced CO" under "Improvements & Alternatives" for more information on CO)
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 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)
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
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

for beginners:

after making Petrus style 3x2x2 block and Petrus style EO, inspect CP

if CP is required, put the two swapped corners at RUF-RUB (intersection) and do D' R (U) R' D or L U' (R') U L'

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

- 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
- perform CP (HSC/Morozov/Benek style), optional 3x1x1 block at LD

- expand to a 3x2x2 block

- perform EO (Petrus style)
- build a 3x2x2 block

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

- perform EO & CP together

- expand to a 3x2x2 block
- 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 3x2x1 block

- expand to a 3x2x2 block while performing EO
- 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 1 of 23 ways

pairs selection.png

this is because out of the four pairs, 2 need to be "towards" pairs and the other 2 need to be "away" pairs, as shown below:

towards away.png

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, since it is the easiest in terms of blockbuilding and recognition

2GB first.PNG

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, 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, 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 alg 1 and its mirror
after CO, there are 8 options for the 3rd pair, with 4 corners and 4 edges to choose from, and any one of these 4 edges can be chosen at this point

place the chosen 3rd pair edge at RD location (i.e. between the 1st and 2nd pairs) with alg 2 or its mirror
out of the 5 remaining edges, there are 4 target edges (i.e. all available edges are suitable, except for the RD edge), so there is a 4 out of 5 probability that a suitable edge is already at RD location and alg 2 would not be required

now build the 3rd pair with alg 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 (alg 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 (alg 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://www.speedsolving.com/threads/optimal-2x2x3-humanly-possible.13578/
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

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'       URF   URB

a'  U R2 U2 R'       URB   URF

b   R' U2 R2 U       URF   URB

b'  U' R2 U2 R       URB   URF

c   R U R' U R' U'   ULF   URF

c'  U R U' R U' R'   URB   DRB

d   R' U' R U' R U   URB   ULB

d'  U' R' U R' U R   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 (alg 1) does

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

CO ALT RECOG.png



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 (alg 1), so this alg set could be used as an alternative to alg 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 set of 9 HTM CO algs that influences EP L3E in a different way
the basic alg (alg 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:

CO ADVANCED.PNG

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 these pairs

so once this extended approach is adopted, there are quite a few added options for the 3rd pair

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

pairs choices.png

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

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)
this is related to unexpected pairs

in fact these 2 ideas (advanced EP and unexpected 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 layer sticker, rest of them have U layer 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 alg 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)

e. 4-cycle or 5-cycle required - solve with commutators, or with alg 2 (look at the edge at RD location, bring its correct location at RU location with a single U* (U/U2/U') move, apply alg 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 (possible at all?)

- 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 (S edge with <S> move, 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 (<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):

https://www.speedsolving.com/forum/...ubstep-concept-idea-thread.40975/post-1315558

.
.

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:
Joined
Feb 14, 2016
Messages
515
Likes
422
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.
 
Joined
May 27, 2018
Messages
350
Likes
230
Location
United States
WCA
2018ISOM02
YouTube
https://www.youtube.com/channel/UCzgIKWl
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:
Joined
May 27, 2018
Messages
350
Likes
230
Location
United States
WCA
2018ISOM02
YouTube
https://www.youtube.com/channel/UCzgIKWl
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!
Really? I thought I explained enough, but ok here’s more:
- The goal of the first two steps is to reduce to a half-turn-only state.
- This method breaks it down into two evenly manageable steps as nicely as possible.
- The first step solves EO and CP and a 2x2x3 block on the left that looks like HTO state. Basically a real EOCP2x2x3 but the block just has to be in HTO instead of solved.
- This causes the second step to be simple enough that you can focus on everything remaining, and 2-gen also makes it more simple (of course you can use other moves to be more efficient but then you’d have to worry about solving/preserving more things).
- In order for half-turn-only to be possible, the edges have to be in their correct slices (MES) and the corners have to be in a specific way (hard to explain). What I mean is if you’ve ever grabbed a 2x2 then you realized even though a diagonal swap has opposite colors on every side, it’s not possible to solve half-turn-only, so to figure out what opposite colors corner states are allowed, do half turns on a 2x2.
- This means that during step 2, you make sure that two corners (just do DRF and DRB) and in the correct position and the other four will always fall into place because CP was “solved” during step 1.
- The point of this method is to make something new never done before that I know has potential in FMC, so if you don’t understand this it’s just because you’ve never seen anything like it.
- I’ll do some FMC example solves of this soon (today? no promises tho) to hopefully show what needs to be shown.
 
Last edited:
Joined
May 27, 2018
Messages
350
Likes
230
Location
United States
WCA
2018ISOM02
YouTube
https://www.youtube.com/channel/UCzgIKWl
TL;DR My last 3 posts on this thread aren't worth much

Woowy's Thistlewaite Reduction FMC Example Solve
Scr: U F' B' U L2 U2 F' D L2 F2 R D2 B2 D2 R F2 L' F2 L B2
(z2 y')
F2 U2 F' D' L2 // EO HTO2x2x2
F2 U' R2 L' U L // ->2x2x3 CP [STEP 1 DONE]
R U2 R U R U'
R2 U' R U2 R' U2
.....
.....
nope

I've concluded that Woowy's Thistlewaite Reduction is not all that great. By doing some testing, I've seen the best way to get yo Half-Turn-Only is most likely Kociemba Phase 1 -> Reduce to HTO. For right now this method should probably be forgotten.

Next method I'm trying to make is a reliable way to do Kociemba Phase 2 efficiently- I want to improve how we do FMC!
 
Joined
May 27, 2018
Messages
350
Likes
230
Location
United States
WCA
2018ISOM02
YouTube
https://www.youtube.com/channel/UCzgIKWl
Speaking of Kociemba, how can I learn to do conjugates reliably? You were talking about them as useful for CO in Kociemba but I still don’t really understand how to make a setup move so that it will twist certain corners. Is it more of a trial and error thing, or what? I’m confused.
I actually don’t use whatever you’re talking about very often because it would add around 7 moves to my Phase 1 solution which is a lot, so really don’t worry about it.
But a similar idea, where you do a setup move to twist 4 corners and move 4 edges is a lot more useful.
- Doing a quarter R move twists 4 corners just like how a quarter F move flips 4 edges.
Example here-
Scr: D2 B2 R2 F' R2 D2 B' D2 F' L' D B2 D F' L2 B R' U'
(z')
U L2 F' U F2 B' // Phase 1 except 4Edges4Corners
L2 F2 D R' // Setup to Single Move, Phase 1 Finish

Sorry if I went off-topic there... so how can you learn to do conjugates reliably? I don't know honestly I'm sorry...


Also I have an idea of how to reliably think about Kociemba Phase 2, but I need to test it before I post, so stay tuned or whatever!
Edit: HTO Reduction might be it...
 
Last edited:
Top