# The New Method / Substep / Concept Idea Thread

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

#### White KB

##### 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?

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

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
No. Steps: 2 major
No. Algs: 0
Avg Moves: (unknown)
Purpose: Experimental

Pros and Cons: no algs, only blockbuilding
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 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
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

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

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
any of the other 3 pairs can be built next
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
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
(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)
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
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
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
this one is quite straight forward

simply build the 4th pair with <R, U> moves, while preserving the first 3 pairs
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 until the entire cube is solved
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 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)
(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
(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 start with anticlockwise U', then the second commutator must start with clock-wise R, and not with anticlock-wise 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 start with anticlockwise U', then the second commutator must start with clock-wise 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 start with anticlockwise U', then the second commutator must start with anticlockwise R', and not with clock-wise R)

.
.

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

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:

#### WoowyBaby

##### 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!
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: