The New Method / Substep / Concept Idea Thread

Hazel · Apr 3, 2019

xyzzy said:
That must have taken you a whole day… (I've done it once before, but that was when the thread was only 100-ish pages long.)

Anyway, no, there isn't any work being done on "algorithmic" blockbuilding. The biggest obstacle is the sheer alg count; it's just not realistic to learn all of the different cases as separate algs. For example, starting with a 2×2×3 block, the number of cases to build an additional square is 3024; restricting this to the cases where there's already a pair built still has 323 cases. For this reason, blockbuilding outside of inspection is usually done by forming pairs and joining them up (relatively few cases), as opposed to directly solving a whole block at once. (If you have 15 seconds of inspection time, that can make it easier to plan out solutions that are better than just creating pairs separately and joining them.)

I think they may have meant intuitive blockbuilding – like if anybody has really dived into the idea of blockbuilding the F2L-1 state?

ImmolatedMarmoset · Apr 4, 2019

Hey- I’ve been brewing this idea in my head for a little while now. It’s a roux variant in that the first and last steps are very similar. This is probably a pretty bad variant, but I’ve played with it for a little and it seems OK. I don’t have an example solve yet, but I will have one up later today. I’m open to comments, including ones that say: “No you’re stupid this is a dumb idea,” because it probably is. anyway, here’s the method:

1. Make two 2x2x1 blocks like in roux, but without the two corner-edge pairs on the F-face
2. Then you intuitively solve the UFR, UFL and DFL corners. (The easiest way to do this is put in the DFL corner first and then place the two other corners
3. Use an alg to solve the last 3 corners
4. L8E, or last 8 edges. Just insert either UR/UL edges or FR FL edges and then do LSE.

There it is! I’ll have an example solve later; tell me what you think.

dudefaceguy · Apr 4, 2019

ImmolatedMarmoset said:
Hey- I’ve been brewing this idea in my head for a little while now. It’s a roux variant in that the first and last steps are very similar. This is probably a pretty bad variant, but I’ve played with it for a little and it seems OK. I don’t have an example solve yet, but I will have one up later today. I’m open to comments, including ones that say: “No you’re stupid this is a dumb idea,” because it probably is. anyway, here’s the method:

1. Make two 2x2x1 blocks like in roux, but without the two corner-edge pairs on the F-face
2. Then you intuitively solve the UFR, UFL and DFL corners. (The easiest way to do this is put in the DFL corner first and then place the two other corners
3. Use an alg to solve the last 3 corners
4. L8E, or last 8 edges. Just insert either UR/UL edges or FR FL edges and then do LSE.

There it is! I’ll have an example solve later; tell me what you think.

This actually reminds me of the old version of my 4x4 corners method. My goal was to solve the corners using commutators, so I wanted to leave 3 unsolved just as in your method, but I arrived at the result differently. Converting to 3x3, I would solve a 1x2x3 and a 1x2x2 block, then solve any 2 of the last 5 corners to leave 3 corners unsolved (I needed even corner parity for a commutator, but you don't). Then I would solve the last 3 corners and slot in the last edge to make two 1x2x3 blocks and all corners solved.

I suppose the virtue of this method would be to leave the corners in a state that can be solved with fewer algs than full CMLL. However, you can do this more easily by manipulating the corners while solving the last pair of the second block, so that at least one corner is oriented (which can then be solved in one move). You are then in the same situation as your method, but the front edges are already solved.

But maybe I am missing the intended benefit of your idea.

Edit: I also sometimes solve Roux blocks on the 4x4 by making two 1x3x3 blocks and then expanding them into 1x3x4 blocks, rather than solving one full block and then the other. I find the added freedom useful for edge pairing, but I haven't found it to be quite as useful for 3x3.

ImmolatedMarmoset · Apr 4, 2019

Hey, thanks for the reply! In all honesty, I just kind of stumbled on the idea (or something close to it), threw it away for a little while, came back to it, made a few modifications, tested it out, and it is what you see. I guess the purpose of solving the corners after the blocks was kind of because I think it looks cool when you have all of the solve and you look on the R/L face. I just wanted to see where that idea would lead me, and it turned out the result wasn’t horrible, and it saves (maybe) on CMLL algs, so I decided to post it. You’re right about the corner manipulation during SB, that does make more sense, but I almost treat this as a separate method I made just for fun. I’ll still do an example solve of it and post it tonight; I want to see move count, etc., but I really just wanted to see where this would go!

Also, I don’t think I ever said that your 4x4 method is awesome, which it is, so kudos on coming up with that!

dudefaceguy · Apr 4, 2019

ImmolatedMarmoset said:
Hey, thanks for the reply! In all honesty, I just kind of stumbled on the idea (or something close to it), threw it away for a little while, came back to it, made a few modifications, tested it out, and it is what you see. I guess the purpose of solving the corners after the blocks was kind of because I think it looks cool when you have all of the solve and you look on the R/L face. I just wanted to see where that idea would lead me, and it turned out the result wasn’t horrible, and it saves (maybe) on CMLL algs, so I decided to post it. You’re right about the corner manipulation during SB, that does make more sense, but I almost treat this as a separate method I made just for fun. I’ll still do an example solve of it and post it tonight; I want to see move count, etc., but I really just wanted to see where this would go!

Also, I don’t think I ever said that your 4x4 method is awesome, which it is, so kudos on coming up with that!

Hey thanks! I'm down to a PB of 3 minutes 15 seconds, which is still a DNF under competition rules

I checked a CMLL algorithm list, and it looks like having at least one corner oriented will eliminate 10 algorithms. This has got me thinking about what other easy things could be done to cut down on the number of cases while solving the last pair. There are only 12 cases with exactly one corner oriented.

Imam Alam · Apr 6, 2019

bismillaahir raHmaanir raHeem

Code:

Gilles Roux said:

Other cubers may use a similar approach, because there's nothing very special about it.
When I found it, I decided to give it a chance because you can make it very efficient using a limited set of formulae.

(http://grrroux.free.fr/method/Intro.html)

.
.

New Method Proposal

Method Name: HSC (Hollow Stairs & Columns)

Similar to: Morozov & Columns First, SSC & ECE, Belt & Domino Reduction, Thistlethwaite & Kociemba Algorithm

.
.

Method Overview

Proposer: Imam Tanvin Alam
Proposed: 6th April, 2019
Variants: Direct Solve, Corners First, Orient First, Permute First, Reduce First (all variants can be Virtually Rotationless, Direct Solve variants can be Virtually Regripless)
No. Steps: 3 major though lots of flexibility, depends on variant
No. Algs: 8 semi-intuitive 2-gen triggers, 3 ~ 6 HTM/STM each (8, 24, or 72 additional 2-gen algs for advanced)
Avg Moves: ~40-50 STM (depending on variant)
Purpose: Experimental (Speedsolving, Fewest Moves, One-Handed Solving possible)

Pros and Cons: similar to SSC/ECE

in columns first methods, the E slice edges are usually solved early, and those E slice edges get in the way of the corners, hence some algorithms (CLL, CMLL, CxLL, CMSLL etc) are required later on

this method (HSC) bypasses that by hiding two E slice edges out of the way of the corners (Hollow Stairs step)

in corners first methods, the corners are usually solved early, and those corners get in the way of the E slice edges, hence some awkward manipulation (E moves, cube rotations, re-gripping etc) is required later on

this method (HSC) bypasses that by placing those two E slice edges along with the corners (Hollow Columns step)

another unique feature of this method is that the sequence of steps is highly flexible and allows for many alternative ways of achieving the same end result

most other methods have a rigid sequence of steps, e.g. the CFOP F2L pairs are almost always made during the second step, and it is generally unacceptable to make the F2L pairs after OLL (because making F2L pairs after OLL would undo the progress made during OLL step)

even highly flexible methods, including blockbuilding based methods (e.g. Petrus/Roux/Heise), generally do not allow swapping two steps, because these methods are designed in such a way that swapping two steps would be counterproductive

but this method (HSC) can be implemented in such a way that EO, CO and CP steps can be done in any sequence, as long as EP is done at the end

.
.

General Structure

1. Hollow Stairs
2. Hollow Columns
3. End Game

Hollow Stairs = build two (oriented, but not necessarily permuted) "L" shaped blocks in DLF and DLB (meaning Petrus style 2x2x3 block, minus the centers and the S slice edge)

the following 3 substeps may be done in any order (avoiding <F, B> moves if CP and/or EO has already been done):

1. place any oriented corner pair in LD (may be swapped, permutation does not matter), an easier alternative is to start with any 2 oriented corners in LD and do CP later

2. place any 2 oriented E slice edges in LF-LB (permutation does not matter)

3. place the other 2 oriented E slice edges in DF-DB (permutation does not matter)

additionally, center correction may be done during this step (see "Fundamental Techniques" for more information)

another advanced option would be to build one complete stair before the other, although that may require more experience with the method

after Hollow Stairs step, <R, U> moves are still available to be used freely, also <F, B, L, D, S, M, E> moves are ok if edges are yet to be oriented, and <F2, B2, L, D, S, M, E> moves are ok if corners are yet to be permuted

Hollow Columns = place four (oriented, but not necessarily permuted) "I" shaped blocks in LF, LB, RB and RF (meaning CFOP style F2L pairs, plus the LL corners)

1. place any 2 oriented corners in RD with <R, U> moves

2. perform trigger 1 (and setup moves) until the 4 U/D stickers form 2 pairs on L and R faces (double headlight) while still having any 2 oriented corners in RD

3. do M2 to make two columns in UF and UB

4. do setup move U* (U/U') if needed and perform trigger 2

an advanced version of this method would be to solve CO L6C with algorithms

the Sortega alg set by Lucas Garron may be used, although it requires a little modification (see "Algorithms List" below)

after Hollow Columns step, <M, S> moves are still available to be used freely, also <F2, B2, R2, L2, U, E, D> moves are ok until End Game step starts

permute the last 6 corners (before or after the Hollow Stairs and Hollow Columns steps) with <R, U> and <L, U> moves

A. if done before columns placing (Hollow Columns) step: after placing any oriented corner pair in LD (may be swapped, permutation does not matter), CP L6C may be done with <R, U> and <L, U> moves (see "Fundamental Techniques" for more details)

B. if done in-between stairs building (Hollow Stairs) and columns placing (Hollow Columns) steps: swap corners at URF and URB with D R U R' D'

C. if done after columns placing (Hollow Columns) step: CP L6C may be done with <R2, U> and <L2, U> moves mainly using trigger 3 and its mirror (see "Fundamental Techniques" for more details)

orient the edges (before, after, or in-between the Hollow Stairs and Hollow Columns steps) with F/B moves or <M, U> moves

A. if done before stairs building (Hollow Stairs) step: do ZZ/Thistlethwaite style EO of all 12 edges with F* moves (F/F') or B* moves (B/B')

B. if done between stairs building (Hollow Stairs) step and columns placing (Hollow Columns) step: place an oriented U/D layer edge at LD and do Petus style EO L7E with F* moves (F/F') or B* moves (B/B'), or alternatively place 2 oriented U/D layer edges at RF-RB and do Roux style EO L6E with <S, U> moves mainly using trigger 4 (may be re-gripped as <M, U>)

C. if done after columns placing (Hollow Columns) step: EO L8E may be done with <M, U, D> moves mainly using trigger 4 (no need to re-grip)

End Game = finish the solve as a 3x3x2 domino puzzle (meaning only <F2, B2, R2, L2, U, D> moves are allowed)

for the End Game step, <U, E, D, M2, S2> moves are available, and <F2, B2, R2, L2> moves are ok if corners/columns are yet to be permuted, also <M, S> moves are ok under certain conditions

finish the solve with <M, U, D> moves and 180 degree moves such as <R2> mainly using triggers 5 ~ 8

this may be executed in many ways (such as Roux style, columns style, Thistlethwaite style, no regrips/rotations, blockbuilding, pair by pair, slice by slice, no 90 degree turns, or any combination of these)

.
.

Algorithms List

for the 8 triggers, the average alg length is 4.75 HTM, 3.88 STM

(3 + 3 + 5 + 5 + 4 + 6 + 6 + 6 = 38 HTM; 38/8 = 4.75 HTM)
(3 + 3 + 5 + 3 + 3 + 4 + 4 + 6 = 31 STM; 31/8 = 3.88 STM)

trigger 1 (CO). R U* R' = [R: U]

trigger 2 (CO). (U) R2 U2 R* = [U R2, z' y2]

trigger 3 (CP). R2 U R2 U' R2 = [R2 U: R2]

trigger 4 (EO). M' U M* = [M': U]

trigger 5 (EP). U M2 U* = [U: M2]

trigger 6 (EP). U2 M2 U2 (M2) = [U2: M2] or [U2, M2]

trigger 7 (EP). M' U2 M U2 = [M', U2]

trigger 8 (EP). R2 U2 R2 U2 R2 U2 = [R2 U2 R2, z' y2]

advanced alg set (requires modification by adding inverted trigger 2 after each alg):

https://garron.us/cube/sortega/

there are 3 options here (including the solved case): 8 cases if RDF-RDB corners are oriented, 24 cases if only RDB corner is oriented, and 72 cases if none of them are oriented

for this method, modify the Sortega alg set as follows (cancelling/modifying some moves by adding inverted trigger 2 at the end of each Sortega alg):

1. cancel the R move at the end of the existing Sortega alg (by adding R'; getting a cancellation of R move in 7 of 7 cases, 23 of 23 cases, and 71 of 71 cases)

2. if possible, modify/cancel the U* move (U/U'/U2) immediately before that (by adding U2; getting a cancellation of U2 move in ~5 of 7 cases, ~18 of 23 cases, and ~53 of 71 cases)

3. if possible, modify/cancel the R* move (R/R'/R2) immediately before that (by adding R2; getting a cancellation of R2 move in ~2 of 7 cases, ~2 of 23 cases, and ~8 of 71 cases)

4. if possible, modify/cancel the U* move (U/U'/U2) immediately before that (by adding U*; getting a cancellation of U2 move in ~0 of 7 cases, ~2 of 23 cases, and ~8 of 71 cases)

.
.

Fundamental Techniques

centers correction early in the solve may help, as described below:

A. if EO has already been done: centers correction (placing F/B centers in F/B faces) helps with EO preservation and recognition (otherwise R* and U* moves would destroy EO)

B. if EO has not been done yet: although not absolutely necessary, centers correction (placing F/B centers in F/B faces or R/L centers in R/L faces) helps with EO recognition (and possibly to avoid difficult cases and/or parity later on)

there are 3 options while building the stairs: consider no centers, or consider F/B centers, or consider R/L centers

if centers are not considered during stairs building, then centers correction may be required later on in the solve, which would take 0 ~ 3 moves (usually <M, S> moves)

recognition with fixed F/B centers (which results in 2 squares) is easy, requiring either no adjustment after this step, or a single S* move (S/S')

the benefit of this approach is that just 1 move is better than 3 moves, although S slice moves may not be preferable (awkward finger trick or cube rotations in the middle of the solve)

recognition with fixed R/L centers (which results in a continuous string of pieces) is also easy, requiring either no adjustment after this step, or a single M* move (M/M')

the benefit of this approach is that it would require an M slice adjustment rather than S slice adjustment, bypassing a potential need for a cube rotation in the middle of the solve, although subsequent <R, U> moves may destroy EO unless F/B face centers are also adjusted properly

in any of the above 3 cases, the E slice edges must have counter-colors to each other on the F/B faces, and the corner sticker can be of either color

for example, let us consider white/yellow as the U/D colors

during the stairs building (Hollow Stairs) step, the following patterns are ok on the F face (red means red/orange, blue indicates blue/green):

and the following patterns are not correct in terms of EO:

for recognition on the B face, simply mirror the above instructions

the main idea for CO is very similar to ZZ/Thistlethwaite style EO

simply get 4 unoriented corners on one layer, so that all 4 can be oriented with a single 90 degree turn of that layer (R/R'), and so on

(adopted from Morozov method)

use <R, U> moves to find your way through CO cases

with the above flowchart, the following algs may be constructed (using nothing but triggers and setup moves):

case 1. R* U2 R2
case 2. R U R' (U) R U' R'
case 3. R U2 R' (U) R U' R'
case 4. R U R' (U2) R U' R'
case 5. done
case 6. R U R'
case 7. R U R' (U2) R U R'
case 8. R U' R'

so this is just <R, U> spamming, but in a smart way, the algs are still easy and short

for the 8 CO cases (when RD corners are oriented), the average alg length with trigger 1 is 5.15 HTM

(alg length * case probability: 3*1 + 7*4 + 7*4 + 7*4 + 0*2 + 3*4 + 7*4 + 3*4 = 139; 139/27 = 5.15 HTM)

(adopted from Benek method)

use <R, U> and <L, U> moves to find your way through CP cases

using cube rotations (and/or some face turns) place corners in a way so that the 4 corners on the D layer have one color in common, and the 4 corners on the L layer have one color in common (orientation does not matter, any pair can also be swapped)

now look at the 4 corners on the F layer, there are three possible cases as described below:

if all 4 corners on the F layer have one color in common (probability: 1/6), then CP is done, it does not need any correction, simply place any pair in LD

only doing cube rotations place any 2 adjacent oriented corners in LD

if they are not oriented, orient them (after moving to LD position) only using <L, U> moves (<F, B, D, R> moves would destroy CP), but do not swap them

once they are both oriented, they become the unbreakable pair, until the other 6 corners are completely solved

after making the unbreakable pair, manipulate the other 6 corners only using <R, U> moves (<F, B, D, L> moves would destroy CP)

if 3 corners on the F layer have one color in common and the fourth corner has the opposite color (probability: 4/6), then CP is done, it does not need any correction, simply place the different pair in LD

only doing cube rotations place the different corner pair at LD (i.e. at DLF and DLB locations)

if they are not oriented, orient them (after moving to LD position) only using <L, U> moves (<F, B, D, R> moves would destroy CP), but do not swap them

once they are both oriented, they become the unbreakable pair, until the other 6 corners are completely solved

after making the unbreakable pair, manipulate the other 6 corners only using <R, U> moves (<F, B, D, L> moves would destroy CP)

if 2 corners on the F layer have one color in common and the other 2 corners have the opposite color (probability: 1/6), then CP needs correction

only doing 180 degree <x2, y2, z2> cube rotations place any of the 4 pairs in LD

if they are not oriented, orient them (after moving to LD position) only using <L, U> moves (<F, B, D, R> moves would destroy CP), and also swap them

once they are both oriented and swapped, they become the unbreakable pair, until the other 6 corners are completely solved

after making the unbreakable pair, manipulate the other 6 corners only using <R, U> moves (<F, B, D, L> moves would destroy CP)

after CO is done (double headlights with U/D stickers on R and L faces), there are several options for columns placing, as shown below:

Code:

    M2 U*   R2 U2 R*
1 2    3  4       5

1. R2 U2 R* U2 R2 vs no move - pairs up the corners on the U layer in 2 different ways

2. U2 vs no move - inserts edges into the columns in 2 different ways

3. U vs U' move - places the corners on the R layer in 2 different ways

4. D vs D' vs D2 vs no move - pairs up the corners on U and D layers in 4 different ways

5. R vs R' move - places the corners on the R layer in 2 different ways

if CP correction has already been done, then a few (~3-10) moves may be saved by keeping track of the two RD corners (the two corners that have D layer stickers) during CO, and by (fully or partially) solving CP during the Hollow Columns step

the RD corners should be swapped if LD corners are still swapped after CP correction, and all corners are to be solved together (with R2 F2 R2 or something similar) later on in the solve

.
.

Example Solve

qqTimer Scramble (generated on 8th April, 2019):

R2 F D F R D' B2 F U' R B F2 U F' R' F' B' L' F2 D L' B D B R2

live solve 55 HTM (43 STM), reconstruction 52 HTM (40 STM):

z x' M' U M u2 R' U R2 U' R2 U M2 U R2 U2 (R' R2) U R2 U' R2 u M' U M' x2 U2 M' U M' (u U U) M2 (U u2 U2) z2 x M' U2 M U2 z y M' U2 M U2

Code:

// (Hollow Stairs step, planned in inspection)
z x' // corner pair in LD
M' U M // 2 oriented E slice edges in DF-DB
u2 // 2 oriented E slice edges in LF-LB
// (Hollow Stairs done in DLF and DLB)

// (Hollow Columns step begins)
R' U R2 // connect oriented corner pair in UF
U' R2 // place oriented corner pair in RD
U // (trigger 1 skip!) setup
M2 // two columns in UF and UB
U R2 U2 R' // columns placing (trigger 2)
// (Hollow Columns done)

// (CP & EO remaining)
R2 U R2 U' R2 // CP (trigger 3)
u // setup
M' U M' // EO (trigger 4)
x2 U2 // setup
M' U M' // EO (trigger 4)
// (CP & EO done)

// (End Game step begins)
u U // setup
U M2 U // (trigger 5)
u2 U2 z2 x // setup
M' U2 M U2 // EP (trigger 7)
z y // setup
M' U2 M U2 // EP (trigger 7)
// (End Game done)

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"

although there were some cube rotations towards the end, the solve was still finger trick friendly, consisting of <R, U, u, M> moves only

this example solve was done with the basic 8 triggers only (advanced Sortega algs were not used)

this solve had a skip, which is not unusual, almost every solve ends up having one or two small substep skips

this is the Corners First variant (see "Variants List" for other variants)

.
.

Variants

Code:

  type  |      steps     | similar method | HS corners |  # EO  |       features      |    redux
----------------------------------------------------------------------------------------------------
Direct  | HS HC CP EO EP | Columns        |   solved   |    6   | CF               VR | RU        MU
Solve   | HS HC CP EO EP | Columns Pairs  |   solved   |    8   | CF               VR | RU        MU
----------------------------------------------------------------------------------------------------
Corners | HS HC CP EO EP | Morozov CF     |  any 2 OC  |    8   | CF    OF         VR | RU   TA   MU
First   | HS HC EO CP EP | Morozov OF     |  any 2 OC  |    8   | CF    OF         VR | RU   TA   MU
----------------------------------------------------------------------------------------------------
Orient  | EO HS HC CP EP | Thistlethwaite |  any 2 OC  |   12   | CF    OF         VR | RU   TA   MU
First   | HS EO HC CP EP | Thistlethwaite |  any 2 OC  |  6/8   | CF    OF         VR | RU   TA   MU
----------------------------------------------------------------------------------------------------
Permute | CP HS HC EO EP | Benek CF       |   OC pair  |    8   | CF    OF    PF   VR | RU   TA   MU
First   | CP HS EO HC EP | Benek PF       |   OC pair  |  6/8   | CF    OF    PF   VR | RU   TA   MU
----------------------------------------------------------------------------------------------------
Reduce  | CP EO HS HC EP | Benek PF       |   OC pair  |   12   | CF    OF    PF   VR | RU   TA   MU
First   | EO CP HS HC EP | Benek 2GR      |   OC pair  |   12   | CF    OF    PF   VR | RU   TA   MU

HS = build Hollow Stairs

HC = place Hollow Columns

VR = Virtually Rotationless solve possible

TA = Thistlethwaite Algorithm style reduction to <F2, B2, R, L, U, D>, then to <F2, B2, R2, L2, U, D>, then to <F2, B2, L2, R2, U2, D2>

solved = directly solve the 2 corners

any 2 OC = place any 2 Oriented Corners

OC pair = place an Oriented Corner pair (may be swapped)

- solve 2 corners in LD (correct pieces, correct orientation, correct permutation), optionally solve LD edge
- place the 4 E slice edges to form Hollow Stairs (correct pieces, correct orientation, correct permutation)
- make Hollow Columns (now E slice is solved)
- permute last 6 corners
- solve DL-DR (or just DR if DL is already solved)
- solve (orient then permute) L6E with <M, U> moves

- solve 2 corners in LD (correct pieces, correct orientation, correct permutation), optionally solve LD edge
- place the 4 E slice edges to form Hollow Stairs (correct pieces, correct orientation, correct permutation)
- make Hollow Columns (now E slice is solved)
- permute last 6 corners
- solve (orient then permute) L8E (or L7E, if DL edge is already solved) with <M, U, D> moves

- place any 2 oriented corners in LD (correct orientation, but can be of any color, and they do not need to be a pair)
- place the 4 E slice edges to form Hollow Stairs (correct orientation, but permutation does not matter, so any 2 of the 4 edges can be swapped)
- make Hollow Columns (now E slice edges are in E slice)
- permute all 8 corners
- orient L8E with <M, U, D> moves
- permute all 12 edges

- place any 2 oriented corners in LD (correct orientation, but can be of any color, and they do not need to be a pair)
- place the 4 E slice edges to form Hollow Stairs (correct orientation, but permutation does not matter, so any 2 of the 4 edges can be swapped)
- make Hollow Columns (now E slice edges are in E slice)
- orient L8E with <M, U, D> moves
- permute all 8 corners
- permute all 12 edges

- orient all edges with F/B moves (ZZ/Thistlethwaite style)
- place any 2 oriented corners in LD (correct orientation, but can be of any color, and they do not need to be a pair)
- place the 4 E slice edges to form Hollow Stairs (correct orientation, but permutation does not matter, so any 2 of the 4 edges can be swapped)
- make Hollow Columns (now E slice edges are in E slice)
- permute all 8 corners
- permute all 12 edges

- place any 2 oriented corners in LD (correct orientation, but can be of any color, and they do not need to be a pair)
- place the 4 E slice edges to form Hollow Stairs (correct orientation, but permutation does not matter, so any 2 of the 4 edges can be swapped)
- orient L8E by first placing 2 oriented edges in RF-RB and then the last 6 edges with <S, U> moves
- make Hollow Columns (now E slice edges are in E slice)
- permute all 8 corners
- permute all 12 edges

- place an oriented corner pair in LD (correct orientation, must have 2 colors on common, may be swapped, permutation does not matter), so that CP correction for the L6C is done
- place the 4 E slice edges to form Hollow Stairs (correct orientation, but permutation does not matter, so any 2 of the 4 edges can be swapped)
- make Hollow Columns (now E slice edges are in E slice)
- solve all corners (place in correct locations)
- orient L8E with <M, U, D> moves
- permute all 12 edges

- place an oriented corner pair in LD (correct orientation, must have 2 colors on common, may be swapped, permutation does not matter), so that CP correction for the L6C is done
- place the 4 E slice edges to form Hollow Stairs (correct orientation, but permutation does not matter, so any 2 of the 4 edges can be swapped)
- orient L8E by first placing 2 oriented edges in RF-RB and then the last 6 edges with <S, U> moves
- make Hollow Columns (now E slice edges are in E slice)
- solve all corners (place in correct locations)
- permute all 12 edges

- place an oriented corner pair in LD (correct orientation, must have 2 colors on common, may be swapped, permutation does not matter), so that CP correction for the L6C is done
- orient all edges with F/B moves (ZZ/Thistlethwaite style) without breaking the corner pair in LD
- place the 4 E slice edges to form Hollow Stairs (correct orientation, but permutation does not matter, so any 2 of the 4 edges can be swapped)
- make Hollow Columns (now E slice edges are in E slice)
- solve all corners (place in correct locations)
- permute all 12 edges

- orient all edges with F/B moves (ZZ/Thistlethwaite style)
- place an oriented corner pair in LD (correct orientation, must have 2 colors on common, may be swapped, permutation does not matter), so that CP correction for the L6C is done
- place the 4 E slice edges to form Hollow Stairs (correct orientation, but permutation does not matter, so any 2 of the 4 edges can be swapped)
- make Hollow Columns (now E slice edges are in E slice)
- solve all corners (place in correct locations)
- permute all 12 edges

.
.

Improvements & Alternatives

an alternative approach (to Hollow Columns step) would be to orient all 8 corners by first setting up the remaining (unoriented) corners so that they can be oriented with a single R* (R/R2/R') move, or with a trigger such as R U* R' (or its mirror)

if this approach is taken then CO can be done before or after EO, and E slice edges can be placed in the E slice with a trigger such as R* S2 R* or R* E2 R* (if Hollow Stairs step is remaining), or with R2 U2 r* S2 r* (if Hollow Stairs step is already done)

case 7. R' U R
new recognition pattern, but intuitive
this is actually the mirror of case 8

case 4. R U2 R' (U*)
new recognition pattern, but intuitive
alternatively do R' U2 R (U*) keeping the 2 oriented corners on B layer (instead of F layer)

so the alg list becomes:

case 1. R* U2 R2
case 2. R U R' (U) R U' R'
case 3. R U2 R' (U) R U' R'
case 4. R U2 R' (U*)
case 5. done
case 6. R U R'
case 7. R' U R
case 8. R U' R'

with these improvements, the average alg length with trigger 1 for the 8 CO cases (when RD corners are oriented) goes down to 3.96 HTM (was 5.15 HTM under "Fundamental Techniques")

(alg length * case probability: 3*1 + 7*4 + 7*4 + 3*4 + 0*2 + 3*4 + 3*4 + 3*4 = 1; 107/27 = 3.96 HTM)

case 1. D*
no new recognition pattern

in this case columns making (in Hollow Columns step) can be done by doing R2 U2 r* S2 r* or (R2 U2 L* E2 L*) without re-gripping

this does not destroy CO, CP, EO, and offers alternative ways of pairing up the corners

this will be considered as 1 HTM because this saves 5 moves later on in columns making (Hollow Columns) step

so this gives us two alternative ways to make columns when all corners are already oriented:

1. D* (R2 U2 r* S2 r*) U2 R2 D*
2. R* U2 R2 U* M2 U* R2 U2 R*

as mentioned previously, the S2 may be executed as E2 (i.e. as L* E2 L*)

the modified Sortega algs for the first 8 cases, when improved with the above shortcuts, are as below:

case 1. R* U2 R2
case 2. R U2 R' U2 R' (U*)
case 3. R2 U R' U2 R' (U*)
case 4. R U2 R' (U*)
case 5. done
case 6. R U R'
case 7. R' U R
case 8. R U' R'

with these improvements, the average alg length with modified Sortega for 8 CO cases (when RD corners are oriented) goes down to 3.37 HTM (was 5.15 HTM under "Fundamental Techniques")

(alg length * case probability: 3*1 + 5*4 + 5*4 + 3*4 + 0*2 + 3*4 + 3*4 + 3*4 = 1; 91/27 = 3.37 HTM)

this is for CP Case C (2:2), if CP is not corrected at the beginning

if 2 pairs are correctly permuted and the other 2 pairs are incorrectly permuted, bring both correct pairs to the front (one pair at FU and the other at FD), then do:

CP 2 pairs: R2 U R2 (U' D') R2 D R2 = [R2, U][D', R2]

this is basically trigger 3 twice, with cancellation

(R2 U R2 U' R2) (R2 D' R2 D R2) => (R2 U R2 U') (D' R2 D R2)

it is possible to execute the U' and D' moves at the same time with some practice

cancelling moves from trigger 8: try combining trigger 8 earlier in the solve with triggers 3 (during CP step) to cancel R2 moves, or with triggers 5 & 6 (during EP step) to cancel U2 moves and/or R2 moves (by doing r2 moves instead of R2 and M2 moves), or with triggers 6 & 7 (during EP step) to cancel U2 moves

swap RU-LU and FD-BD: U (M2 U2 M2) U* = [U: [M2: U2]]

dot case (or all 4 M slice edges swapped) without E moves: U2 M2 U2 (M') U2 M2 U2 (M*) = [[U2: M2], M']

swap FU-FD and BU-BD without cube rotations and re-grips: (M') U2 M2 U2 (M*) = [M': [U2: M2]]

swap RU and FD: U (M' U2 M U*) = [U: [M': U2]]

swap RU-LU and RD-LD without cube rotations and re-grips: (UD') M2 U2 M2 (UD*) = [U D': [M2: U2]]

special case (apply on a solved cube to see what it does): RL (U M2 U2 M2 U) L'R' = [RL: [U: [M2, U2]]]

EP L8E without cube rotations and re-grips: M2 (UD') M2 (UD') = [D U', M2 z2]

.
.

Optimization

this simply means there is high focus on understanding cube theory (long term memory), and low focus on rote memorization (short term memory), and other aspects such as speed and move count are not optimized

HSC is already low on alg count, so once the concepts and basic theory behind HSC are understood, they go into the long term memory, and forgetting HSC is highly unlikely after that

also there are lots of symmetrical/mirror/inverse cases in HSC, and they are easy to learn/understand, so knowing one case is equivalent to knowing many cases

there are so many tricks and variants for this method, many of them are described in this document, learn them all, also explore and experiment on your own, and don't forget to share your findings with me!

- plan as much as possible during inspection (EO, CP, corner pair, line on left, line at bottom)
- learn and use Sortega modified
- direct solve preferred (even if partial), especially columns
- rotationless solve preferred (even if partial)
- Roux style or SSC style end game (EP) is good

there are so many tricks and variants for this method, many of them are described in this document, learn them all, also explore and experiment on your own, and don't forget to share your findings with me!

one word: Attila

he has developed a very efficient approach for FMC which goes very well with HSC

for starters, both his approach and HSC are very flexible in terms of sequence of steps (corners first, EO first, CO first, domino reduction, sometimes belt or CE pairs etc)

one major theme is trying to solve/orient/position as many edges as possible while solving/orienting/positioning the corners (see examples below)

also, HSC has lots of symmetrical/mirror/inverse cases (choices between U and U' moves, or R and R' moves, for example), so there are lots of opportunities for move cancellation

on top of all that, with HSC, full or partial CO, CP, EO, EP (i.e. pretty much everything) may be done at the same time between Hollow Stairs and Hollow Columns steps

Attila said:
(https://www.speedsolving.com/forum/threads/how-to-solve-a-rubiks-cube-for-mit-graduates.27501/)

I used a very intuitive corner first method, what i try perfecting now , and i used only for FMC.
first time i try a solution for all corners , usually with Ortega method, sometimes with Guimond or other algs,
then i changed this corner-algo, so that a few edges to be solved on two opposite sides, but not much more moves is needed,
then i solved more edges, to be Roux 6E4C position.
then i solved the last 6 edges.
For example: if the corner algo was FDU2R’BF’D2, but this not solve edges, some of the possible variant: Fdu2R’bF’D2 or fDU2R’bf'd2 and more endless variant…I make changes to it,which must be solved edges. This method the corners position still, but a few opposite edges effectívely solvable at one time with corners solve.
Two nice solution with this method: http://fmc.mustcube.net/ , round 328, 329, classic.

Attila said:
(https://www.speedsolving.com/forum/threads/the-3x3x3-example-solve-thread.14345/page-212#post-985210)

scramble: R2 U2 B' F' L2 R2 F' D2 B D B2 F R' B D' F2 R2 D2 R

F B'D' F2 B2 D2 B' U' D' R'
U F2 R' B F' U'
L' B' D U' L
F U2 B D2 B2 F L2 B F

...

here is my explanation:
F B'D' F2 B2 D2 B' U' D' R' orient corners, and 5 edges,
U F2 R' B F' (U) more 1 edge,
(U2) L' B' D U' L more 2 edges, oriented S slice,
F U2 B D2 B2 F L2 B F corners permutation.

...

For better understanding, is needed to write a longer explanation.

Scramble: R2 U2 B' F' L2 R2 F' D2 B D B2 F R' B D' F2 R2 D2 R

First, to find a solution for all corners.
At first sight, i found the following start :
R F' R2 F' orient corners,
R U2 R U2 R' U2 R2 solved all corners with 11 moves.
In the next step I try to make a few corner-edge pairs, ie changed initial step.
R F' R2 F' instead of:
R' B2 F2 R2 B' L2 B'(which gives same corners position, but solved 3 c-e pairs,
L U2 L D2 L' F2 L2 all corners, and 3 edges.
To continue I will use 2 cubes.
The first cube setting: scramble, then R' B2 F2 R2 B' L2 B' L U2 L D2 L' F2 L2
The second cube setting: z' y, (corners set to the same places)
then back to the original scramble both cubes: L2 F2 L D2 L' U2 L' B L2 B R2 F2 B2 R.
Now there is 8 corners and 3 edges same places.
I start again to solve both cubes simultaneously,
attentively looking a chance to solve more edges:
S' solve 4th edge
R' B2 F2 R2 B'
L' l' 5th edge
B'
I write this 10 moves without cube rotations:
F B'D' F2 B2 D2 B' U' D' R', will be the beginning of the solution.
U F2 continuing corners permutation
R' B F' U solve 6th edge
(U2) L' B' D U' L more 2 edges, taking care of the rest edges right orientation
F U2 B D2 B2 F L2 B F permutation ending.
I hope that's understandable,if you have any more questions, I will answer.

one member said:
(https://www.speedsolving.com/forum/threads/the-fmc-thread.13599/page-133#post-1014925)

...I don't understand how did he came up with each substep, for example the "modifying the corner solution to solve some edges" substep.

...

porkynator said:
(https://www.speedsolving.com/forum/threads/the-fmc-thread.13599/page-133#post-1015004)

For that step, I think he adds slice moves (that don't affect corners) to pair up one or more edges to the matching corner; slice moves should preferably cancel 1 or even two moves (in the last case, you are just using a wide move instead of a regular one).

For example, if you have a corner solution like:

U R F2 L'

you can transform it to:

U [E2] R F2 [M'] L'

and without slice moves it becomes:

U' D2 L B2 L'

That's how I understand that step and how I do it, but we should wait for Attila's reply to be sure

...

Attila said:
(https://www.speedsolving.com/forum/threads/the-fmc-thread.13599/page-133#post-1015081)

Here is an example about corner-edge pairing, during solve corners.

Scramble: F2 U2 B2 R U2 B2 U2 F2 U B D R2 U' R' B U2 B L2 F (German Nationals)

F R D’ R2 D orient (5)
F2 L F2 L F2 L all corners (11 moves),
modifying:
F R D’ R2 d, orient but not lose the 1st pair,
F f, 2nd pair,
L f2, not lose the 2nd pair,
L F’ f’, all corners( - 1 move), 3rd and 4th pairs,
2nd modifying:
F R D’ R2 d F f l f2 L F’ f’ (F R D’ R2 U R L U F2 U F’ B’ - L) solve 2 centres,
3rd modifying:
F R D’ r2 U R L U F2 U F’ B’ L (F R D’ L2 D R L D B2 D F’ B’ L) 13 moves, 5 edges.
I always leave an unsolved slice(here: M), and try to solve the edges on two opposite sides, then I try to find the easiest LSE case.

Attila said:
(http://www.speedsolving.com/forum/threads/the-fmc-thread.13599/page-167)

Weekly scramble: U’ B2 R’ F2 U’ B’ R U’ F2 D’ B L2 F2 U2 B D’ U2 B D2 L’

I want to show an advanced trick, how to solve more edges, before corners permutation. I called it this technique "edges-cloning" . I hope that my explanation is useful, those who are interested the CF method.

Solution: L’ U2 D2 L D L D’ B2 U R2 U’ F2 D R2 B2 D’ F’ U D’ L D2 U’ 22 moves (within 90 mins)
First, as usual, solve all corners and some edges( which found easily)
B R orient corners and 2 edges,
B’ D2 F L2 F’ U2 B L2 D2 all corners and 3 edges.
After this, I use a second cube for proceed. Left the first cube, right the second (solved) cube.
Right cube rotate x’ z2 ( same place the corners on both cubes, centres ignore now)
Then , return to the original scramble (left cube): D2 L2 B’ U2 F L2 F’ D2 B R’ B’
Same 11 moves (right cube): D2 L2 B’ U2 F L2 F’ D2 B R’ B’
Now compares both cubes, there are 8 corners and 3 edges on same places.
I start again to solve both cubes simultaneously, and try to insert more edges on left cubes (I named this cloning).

inserted moves on left cube:
L’ @ R 5 edges,
insert at @: E2 ( L’ E2 l ) 7 edges,
orient corners (simultaneuosly both cubes) : B R
B’ D2 F L2 F’ U2 B L2 D2 permute corners ( both cubes),
B’ U’ S’ U F’ B2 L5E. (left cube)
Final solution ( left cube): L’ E2 l B R B’ D2 F L2 F’ U2 B L2 D2 B’ U’ S’ U F’ D2

Attila said:
(http://www.speedsolving.com/forum/threads/the-fmc-thread.13599/page-183)

weekly FMC:
D F B U2 R L' U' B2 L' D' B' L2 F2 R2 U' F L' D2 F2 B'

I found a nice CF continuation for this Roux FB start:

B (B U') Roux FB,
F2 L2 R B orient corners and 6 edges,
R B2 R B2 L2 F2 R' /F' D2 R' L B2 D'/ L B2 domino solution with /inserted LSE/.

Final solution:
B F2 L2 R B R B2 R B2 L2 F2 R' F' D2 R' L B2 D' L B2 U B' 22 moves.

...

Q: What did you do to obtain the domino solution with inserted LSE? Can you please explain it in more detail? Did you force an easy LSE case by trying out different ways to solve the domino? I'm really lost with that...

A: So, after corners orientation, I try out a few different way, which will permute corners:
R' B2 R B2 R' B2 R' maybe this is the shortest permutation, but 3 oriented edges moved to wrong places.
Another way: R B2 R' B2 R B2 R B2 it seems better, but the 6th edge still wrong,
Finally: R B2 R B2(square on R face!) R2 B2 R' B2 R B2 a longer permutation, but 6 edges solved.
For better LSE insertion, I changed this 10-move permutation:
R B2 R B2 L2 F2 R' prepare LSE,
instead of F2, now insert F' D2 R' L B2 D'
then L B2 finish.
The easy LSE case I not forced this time, I was just a bit lucky.

one user said:
(http://www.speedsolving.com/forum/threads/the-fmc-thread.13599/page-209)

do EO Line and put E slice edges in the slice disregarding permutation, orient all corners, and solve as a domino. However, I am having a hard time optimizing domino so here's a solution up to that state if you guys would like to help me out. Thanks!

Scramble: F2 U' R2 U L2 U B2 D F2 L2 D2 F D' R' D2 L U' F' U L2 D

F' R' U B' R' U// EO with domino style belt (6) **solved belt unintentional
R2 L2 D' R' L2 U' D' R D2 R'// Corner Orientation (domino redux) 10/16

...

another user said:
(http://www.speedsolving.com/forum/threads/the-fmc-thread.13599/page-209)

If you switch to the invserse scramble, you can do
(U' L2 D' U' R2 U L2 U R2 U) which leaves 3 corners. I'd ask @Attila for domino advice.

...

Attila said:
(http://www.speedsolving.com/forum/threads/the-fmc-thread.13599/page-209)

So, in my opinion, such a random domino reduction, will not be finished with a few moves.
I tried many random domino scrambles,and the average movecount around 13-14 (optimal with CE). The average human solution is obviously more than that.
That's why we need some trick, that reduces the 2nd phase movecount.
I'll explain in more detail, as I usually solve.

In the next logical order:
1st: solve all corners in 2 phase, orient first, then permute with domino moves
2nd: orient corners and solve a few edges (as much as possible)
3rd: swith to inverse, and permute corners (while caring for the existing ce-pairs)
4th: swith back to normal scramble, with inverted permutation moves
5th: orient corners again (here you can see clearly where the edges are to be moved)
6th: orient the remaining edges with Roux-style LSE algs
7th: solve the 5th and 6 step, without inverted premoves
8th: permute corners on normal (and it will be solved all edges).

Let's look at an example using your actual scramble:
F2 U' R2 U L2 U B2 D F2 L2 D2 F D' R' D2 L U' F' U L2 D

1st: D' R B' U' B U R2 D R2 D' F2
2nd: U F' B R2 B L' D' L orient corners and 4 edges,
3rd: switch to inverse with premoves L' D L B' R2 B' F U'
(F2 D R2 D' L2 U') permute corners,
4th:swith to normal with premoves U L2 D R2 D' F2
5th: U F' B R2 B L' D' L orient corners and 4 edges,
6th: L2 U' D' L B' U2 D2 F R' 2 more edges (exceptionally, the last 2 edges will be solved later)
7th: U F' B R2 B L' D' L-L2 U' D' L B' U2 D2 F R' orient corners and 6 edges,
8th: D2 B2 U2 - F U D' L' - D' B2 D F2 D' L2 D U' domino 2nd phase, with inserted F U D' L' moves.
Final solution: U F' B R2 B L' D' L' U' D' L B' U2 D2 F R' D2 B2 U2 F U D' L' D' B2 D F2 D' L2 D U' 31 moves.

I hope this is useful, if there is any question, I can help, if I can.

...

another user said:
(http://www.speedsolving.com/forum/threads/the-fmc-thread.13599/page-209)

I don't understand the purpose of step 1? You don't seem to use it later on in your solution.

...

Attila said:
(http://www.speedsolving.com/forum/threads/the-fmc-thread.13599/page-210)

1st step : D' R B' U' B orient corners
2nd step: instead of D' R B' U' B, I do d M' D2 r B' U' B /U F' B R2 B L' D' L without rotations/ 4 edges solved,
3rd step: instead of ( F2 D R2 D' R2 U') , I do (F2 D R2 D' L2 U') save ce-pairs.

there are so many tricks and variants for this method, many of them are described in this document, learn them all, also explore and experiment on your own, and don't forget to share your findings with me!

even without optimization, HSC mostly uses <R, U, M> moves, so transition to one handed solving is easy

- better do CP/EO at the beginning, so that the rest of the solve is entirely 2-gen
- may need table abuse for M slice moves
- in many cases, there is an option between R and R', U and U', M and M' moves, try to use the option that gives some advantage (easier case afterwards, easier lookahead, easier to execute etc)

there are so many tricks and variants for this method, many of them are described in this document, learn them all, also explore and experiment on your own, and don't forget to share your findings with me!

this is simply a 3x3x3 cube minus one slice (the E slice)

so, knowledge of HSC is very easily transferable to solving this cuboid, since HSC essentially reduces the 3x3x3 cube to this state

this is simply a 3x3x3 cube minus two slices (the M and S slices, or the S and E slices)

knowledge of HSC is very easily transferable to solving this cuboid, no orientation required, simply permute the corners, and then permute the edges

again, this is simply a 3x3x3 cube minus all three slices (the M, S and E slices)

knowledge of HSC is very easily transferable to solving this cuboid, simply solve the corners (CO then CP, or CP then CO)

bigger (odd and even) cubes may be solved with HSC in a similarly semi-intuitive way as the 3x3x3 cube

simply learn the additional steps from Morozov method (after Hollow Columns, solve RL edges, then remaining edges, finally centers)

another option is reducing the big cube down to a 3x3x3 cube (using any big cube reduction method), then solving with HSC

there are so many tricks and variants for this method, many of them are described in this document, learn them all, also explore and experiment on your own, and don't forget to share your findings with me!

.
.

Why This Method

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

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

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

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

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

.
.

Code:

Ryan Heise said:

Because all algorithms are short and simple,
someone who tries this method can say they solved the cube and understood how they did it!

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

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

Sue Doenim · Apr 7, 2019

ImmolatedMarmoset said:
Hey- I’ve been brewing this idea in my head for a little while now. It’s a roux variant in that the first and last steps are very similar. This is probably a pretty bad variant, but I’ve played with it for a little and it seems OK. I don’t have an example solve yet, but I will have one up later today. I’m open to comments, including ones that say: “No you’re stupid this is a dumb idea,” because it probably is. anyway, here’s the method:

1. Make two 2x2x1 blocks like in roux, but without the two corner-edge pairs on the F-face
2. Then you intuitively solve the UFR, UFL and DFL corners. (The easiest way to do this is put in the DFL corner first and then place the two other corners
3. Use an alg to solve the last 3 corners
4. L8E, or last 8 edges. Just insert either UR/UL edges or FR FL edges and then do LSE.

There it is! I’ll have an example solve later; tell me what you think.

This reminds me a lot of the BOPE method proposed a while ago, but your version has a different way of dealing with the corners.

Imam Alam said:
bismillaahir raHmaanir raHeem

New Method Proposal

Method Name: HSC (Hollow Squares & Columns)

Similar To: Morozov & Columns first, SSC & ECE, Belt & Domino Reduction, Thistlethwaite & Kociemba Algorithm

.
.

Method Overview

Proposer: Imam Tanvin Alam

Proposed: 2019
Alt Names: Hollow
Variants: Virtually Rotationless, Direct Solve, Corners First, Orient First, Permute Corners First
No. Steps: 3 major though lots of flexibility, depends on variant
No. Algs: ~8 semi-intuitive 2-gen mini-algs, 3 ~ 6 STM (~13 algs 2-gen for intermediate, ~77 algs 2-gen for advanced)
Avg Moves: (unknown)
Purpose: Experimental

Pros and Cons: similar to SSC/ECE

.
.

General Structure

1. Hollow Squares (2.2x2)
2. Hollow Columns (CO + E slice)
3. End Game (solve domino)

View attachment 10178

the following 4 steps may be done in any order (avoiding <F, B> if CP and/or EO has already been done):

1. get any oriented corner pair in LD (may be swapped, permutation does not matter), an easier alternative is to start with any 2 oriented corners in LD and do CP later

2. get any 2 oriented E slice edges in LF-LB (permutation does not matter)

3. get the other 2 oriented E slice edges in DF-DB (permutation does not matter)

4. make sure F/B centers are on F/B faces (may be swapped, permutation does not matter)

1. get any 2 oriented corners in RD with <R, U>

2. perform alg 1 (and AUF) until the 4 U/D stickers form 2 pairs on L and R faces (double headlight) while still having any 2 oriented corners in RD

3. do M2 to make two columns in UF and UB

4. AUF (U*) and perform alg 2

an advanced version of this method would be to solve CO L6C with algorithms

this requires a larger alg set (7 cases if RD corners are oriented, and 71 cases if not)

the Sortega alg set by Lucas Garron may be used (see alg list below), although it requires a little modification as follows:

cancel the R move at the end of the existing alg, modify/cancel the U* move (U/U'/U2) immediately before that (by adding U2; getting a cancellation of U2 move in 5 of 7 cases and 47 of 71 cases), and maybe modify/cancel the R* move immediately before that (by adding R2; getting a cancellation of R2 move in 1 of 7 cases and 4 of 71 cases), and so on

if not done before columns placing (Hollow Columns) step: CP L6C may be done with <R, U> and <L, U> mainly using alg 3

A. if done before blockbuilding (Hollow Squares) step: do EO of all 12 edges with F* or B*

B. if done between blockbuilding (Hollow Squares) step and columns placing (Hollow Columns) step: place 2 oriented U/D edges at RF-RB and solve L6E as usual with <S, U> mainly using alg 4 (may be re-gripped as <M, U>)

C. if done after columns placing (Hollow Columns) step: EO L8E may be done with <M, U, D> (no need to re-grip)

finish the solve with <M, U, D, R2> mainly using algs 5 ~ 8

this may be executed in many ways (such as Roux style, columns style, Thistlethwaite style, slice by slice, block building, no 90 degree turns, or any combination of these)

.
.

Algorithms List

alg 1 (CO). R U* R' (Ui)

alg 2 (CO). R2 U2 R*

advanced alg set:

https://garron.us/cube/sortega/

alg 3 (CP). R2 U' R2 U R2

alg 4 (EO). M' U M*

alg 5 (EP). U M2 U*

alg 6 (EP). U2 M2 U2 (M2)

alg 7 (EP). M' U2 M U2

alg 8 (EP). R2 U2 R2 U2 R2 U2

.
.

Variants List

Code:

| | | | | | steps | variant - similar method | summary | HS corners | # EO | features | redux -------------------------------------------------------------------------------------------------------------------- HS HC CP EO EP | HSC DS - Columns Pairs | CS EO EP | any 2 OC | 8 | CF | RU MU -------------------------------------------------------------------------------------------------------------------- HS HC CP EO EP | HSC CF - Morozov CF | CO CP EO EP | any 2 OC | 8 | CF OF | RU TA MU HS HC EO CP EP | HSC OF (C) - Morozov OF | CO EO CP EP | any 2 OC | 8 | CF OF | RU TA MU -------------------------------------------------------------------------------------------------------------------- HS EO HC CP EP | HSC OF (E) - Thistlethwaite | EO CO CP EP | any 2 OC | 8 | CF OF | RU TA MU -------------------------------------------------------------------------------------------------------------------- CP HS HC EO EP | HSC PF (C) - Benek CF | CP CO EO EP | OC pair | 8 | CF OF PF | RU TA MU CP HS EO HC EP | HSC PF (E) - Benek PF | CP EO CO EP | OC pair | 8 | CF OF PF | RU TA MU -------------------------------------------------------------------------------------------------------------------- EO CP HS HC EP | HSC PF (2GR) - Benek 2GR | EO CP CO EP | OC pair | 12 | CF OF PF | RU TA MU | | | | | |

HS = blockbuild Hollow Squares (2.2x2)

HC = place Hollow Columns (CO + E slice)

DS = Direct Solve

TA = Thistlethwaite Algorithm style reduction to <F2, B2, R, L, U, D>, then to <F2, B2, R2, L2, U, D>, then to <F2, B2, L2, R2, U2, D2>

any 2 OC = any 2 Oriented Corners

OC pair = Oriented Corner pair (may be swapped, permutation does not matter)

.
.

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

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

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

What is the focus of the method? Is it designed for use with FMC or for speed? And can you provide an example solve, just to help clarify the steps?

Imam Alam · Apr 8, 2019

What is the focus of the method? Is it designed for use with FMC or for speed? And can you provide an example solve, just to help clarify the steps?

FMC or speed? still experimenting with it, cannot say anything definite yet

edit: example solve and other relevant info added to the original proposal

FakeMMAP · Apr 9, 2019

here is my new concept: influencing LSLL during third pair

in particular I have generated algorithms for edge orientation when the last 2 slots are opposite

PapaSmurf · Apr 9, 2019

Or just do ZZ and have eosolved in all slots for rotationless <R,U,U2,U',L,D> F2L and ZBLL with little to no effort.

FakeMMAP · Apr 9, 2019

here is my new concept: influencing LSLL during third pair

in particular I have generated algorithms for edge orientation when inserting the LB pair when the last 2 slots are opposite, which I called EOLB.

so the method could go as follows:

-cross+diagonal pairs however the hell you want to do them
-EOLB
-LSLL with oriented edges (very developed)

EOLB is when the edge that belongs in BL is oriented, otherwise the set is called Flipped EOLB

these sets are further divided based on the orientation of the edge situated in RF: EOLB+ when it's oriented (and you can do VHLS algorithms) and EOLB- (and similar for flipped EOLB+ and -)

the names given to the cases follow a convention similar to VLS: the flipped edges in U, apart from the edge that goes in BL) are notated (so UF- is the case where UF and RF edges are unoriented), 0 is the case where all non-BL-belonging edges in the U layer are unoriented and ALL notates the case where all non-BL-belonging edges in the U layer are oriented

I've copied all optimal algs generated from cube explorer in the following spoilers. execute EOLB algs with third pair in UL-ULB and execute flipped EOLB algs with pair in UL-ULF

ALL+: U L U' L'
UB+: L' B L B'
UR+: U B' R' U' R B
UF+: [U L F U' F' L' or U2 B2 R B R' B]
URUF+: [U L2 F' L' F U' L' or U2 L U' F U' F' L' or U2 B L' B' L2 U2 L' or F' U2 L U2 F' L' F2
L' B L2 U L' U' B']
UBUF+: L' B L2 U L' U' B'
UBUR+: [U F B2 D' R' D F' B2 or U F' L U' L2 U2 L F or U B2 D' F R' F' D B2 or U' B D F' L F D' B' or R2 L' B L B2 R' B R' or R2 L' B2 L B R' B R' or R2 L' B' R' B' L B2 R' or L F' U2 F L2 B L B' or L' U' B U L2 U' L' B' or B' U2 F R' F' U2 R B]
0+: [R L' B L U2 B' R' or F' L' U2 B L F B']

ALL-: [U F' L U' L' F or U L F' U' F L' or F' U L U' L' F ]
UB-: [U F' L U' L' U2 F or U L U' L' F' U2 F or U2 L U2 L' F' U2 F or F' U L U' L' U2 F or F' U2 L U2 L' U2 F or F' L' B L B' U2 F or L F' U2 F' L F2 L2 or L' B L F' B' U2 F ]
UR-: F' U F L U' L'
UF-: [U F' U L U2 L' F or U F' L U' L' U' F or U L U' L' F' U' F or U L2 F' L' U' F L' or U2 F' U L U L' F or U2 L U' F' U' F L' or L F L F' L' F' L']
URUF-: [U F2 L F U' L' F or U F' L U' F' L' F2]
UBUF-: [U F' U' F L' B L B' or U F' U' L' B L F B' or R' F R F' L' B L B' or F2 L' B L2 F L' F B' or F' U2 L U2 L2 U2 L F or F' L' U' B L B' U' F oppure F' L' B L' F' L2 F2 B' or L' B L U' F' U F B' or L' B L B' U F' U' F or L' B L B' U2 F' U2 F or L' B L B' U' F' U F or L' B L B' R' F R F' or L' B L' D F D' L2 B']
UBUR-: [R L' B L U' B' R' or F' L' U' B L F B' or F' L' B L B' U F or L' B L F' B' U F ]
0-: [U F2 L F U' L' U2 F or R L' B L2 U2 L' B' R' or F' U L U' L2 U2 L F or F' L' U' B L B' U2 F or L F' R' F' R U2 F L']

ALL+: B' U B
UF+: U B L' B' L
UR+: L F U F' L'
UB+: B' R' U R B
UBUR+: R2 B' R' U B R' or B2 R B U R' B or B2 R B R' U B
UBUF+: U B L' B2 U' B U L or U2 R2 B' R2 U' R B R' or F' L' U L B' U F B or L U2 F U R' F' R L' or B L U L' U' B2 U2 B or B' U B U2 F R' F' R or B' U B2 U L U' L' B' or B' R' U2 R B L U' L'
URUF+: R B' U B2 U B' R' or R' L2 D F D' R L2 or L2 D R' F R D' L2
0+: L F U R' F' R L'

ALL-: U B' R2 B' R2 B2 or B' U F' B U F
UF-: L2 D F D' L2 (note: execute as L2 Uw L Uw' L2)
UR-: B' U2 F' U' F B
UB-: U' L2 D F' D' L2 (note: execute as U' L2 Uw L' Uw' L2) or B2 R2 B R2 U B or B' U F' B U2 F
UBUR-: L U2 L D F D' L2 (note: execute as L U2 L Uw L Uw' L2) or L F U2 F2 U' F L' or L F' U F2 U F' L'
UBUF-: L2 F' L' U2 F U L'
URUF-: L U L D F D' L2 (note: execute as L U L Uw L Uw' L2) or L2 F' L' U F U L'
0-: R2 B' R' U B2 U B' R'

FakeMMAP · Apr 9, 2019

PapaSmurf said:
Or just do ZZ and have eosolved in all slots for rotationless <R,U,U2,U',L,D> F2L and ZBLL with little to no effort.

ye, but that wouldn't be a new idea, would it?

WoowyBaby · Apr 9, 2019

FakeMMAP said:
here is my new concept: influencing LSLL during third pair

in particular I have generated algorithms for edge orientation when inserting the LB pair when the last 2 slots are opposite, which I called EOLB.

so the method could go as follows:

-cross+diagonal pairs however the hell you want to do them
-EOLB
-LSLL with oriented edges (very developed)

EOLB is when the edge that belongs in BL is oriented, otherwise the set is called Flipped EOLB

these sets are further divided based on the orientation of the edge situated in RF: EOLB+ when it's oriented (and you can do VHLS algorithms) and EOLB- (and similar for flipped EOLB+ and -)

the names given to the cases follow a convention similar to VLS: the flipped edges in U, apart from the edge that goes in BL) are notated (so UF- is the case where UF and RF edges are unoriented), 0 is the case where all non-BL-belonging edges in the U layer are unoriented and ALL notates the case where all non-BL-belonging edges in the U layer are oriented

I've copied all optimal algs generated from cube explorer in the following spoilers. execute EOLB algs with third pair in UL-ULB and execute flipped EOLB algs with pair in UL-ULF

ALL+: U L U' L'
UB+: L' B L B'
UR+: U B' R' U' R B
UF+: [U L F U' F' L' or U2 B2 R B R' B]
URUF+: [U L2 F' L' F U' L' or U2 L U' F U' F' L' or U2 B L' B' L2 U2 L' or F' U2 L U2 F' L' F2
L' B L2 U L' U' B']
UBUF+: L' B L2 U L' U' B'
UBUR+: [U F B2 D' R' D F' B2 or U F' L U' L2 U2 L F or U B2 D' F R' F' D B2 or U' B D F' L F D' B' or R2 L' B L B2 R' B R' or R2 L' B2 L B R' B R' or R2 L' B' R' B' L B2 R' or L F' U2 F L2 B L B' or L' U' B U L2 U' L' B' or B' U2 F R' F' U2 R B]
0+: [R L' B L U2 B' R' or F' L' U2 B L F B']

ALL-: [U F' L U' L' F or U L F' U' F L' or F' U L U' L' F ]
UB-: [U F' L U' L' U2 F or U L U' L' F' U2 F or U2 L U2 L' F' U2 F or F' U L U' L' U2 F or F' U2 L U2 L' U2 F or F' L' B L B' U2 F or L F' U2 F' L F2 L2 or L' B L F' B' U2 F ]
UR-: F' U F L U' L'
UF-: [U F' U L U2 L' F or U F' L U' L' U' F or U L U' L' F' U' F or U L2 F' L' U' F L' or U2 F' U L U L' F or U2 L U' F' U' F L' or L F L F' L' F' L']
URUF-: [U F2 L F U' L' F or U F' L U' F' L' F2]
UBUF-: [U F' U' F L' B L B' or U F' U' L' B L F B' or R' F R F' L' B L B' or F2 L' B L2 F L' F B' or F' U2 L U2 L2 U2 L F or F' L' U' B L B' U' F oppure F' L' B L' F' L2 F2 B' or L' B L U' F' U F B' or L' B L B' U F' U' F or L' B L B' U2 F' U2 F or L' B L B' U' F' U F or L' B L B' R' F R F' or L' B L' D F D' L2 B']
UBUR-: [R L' B L U' B' R' or F' L' U' B L F B' or F' L' B L B' U F or L' B L F' B' U F ]
0-: [U F2 L F U' L' U2 F or R L' B L2 U2 L' B' R' or F' U L U' L2 U2 L F or F' L' U' B L B' U2 F or L F' R' F' R U2 F L']

ALL+: B' U B
UF+: U B L' B' L
UR+: L F U F' L'
UB+: B' R' U R B
UBUR+: R2 B' R' U B R' or B2 R B U R' B or B2 R B R' U B
UBUF+: U B L' B2 U' B U L or U2 R2 B' R2 U' R B R' or F' L' U L B' U F B or L U2 F U R' F' R L' or B L U L' U' B2 U2 B or B' U B U2 F R' F' R or B' U B2 U L U' L' B' or B' R' U2 R B L U' L'
URUF+: R B' U B2 U B' R' or R' L2 D F D' R L2 or L2 D R' F R D' L2
0+: L F U R' F' R L'

ALL-: U B' R2 B' R2 B2 or B' U F' B U F
UF-: L2 D F D' L2 (note: execute as L2 Uw L Uw' L2)
UR-: B' U2 F' U' F B
UB-: U' L2 D F' D' L2 (note: execute as U' L2 Uw L' Uw' L2) or B2 R2 B R2 U B or B' U F' B U2 F
UBUR-: L U2 L D F D' L2 (note: execute as L U2 L Uw L Uw' L2) or L F U2 F2 U' F L' or L F' U F2 U F' L'
UBUF-: L2 F' L' U2 F U L'
URUF-: L U L D F D' L2 (note: execute as L U L Uw L Uw' L2) or L2 F' L' U F U L'
0-: R2 B' R' U B2 U B' R'

Interesting idea. Definently not practical for speedsolves though, because you have to force diag slots and algs have actually terrible ergonomics because it’s in the back left.

Though don’t worry, you only have to do one simple thing to turn this idea from bad to good. Just change one thing.
Have the slot be at FL instead of BL.
This improves literally everything!
In fact, if the algs are decent I actually might use this idea!

Deleted member 36445 · Apr 9, 2019

example solves plz

WoowyBaby · Apr 10, 2019

New Substep Idea: 123LS (short for 1x2x3 last slot)

This can be used when your last slot has an oriented area on top, and you do an algorithm to solve your OLL and your entire pair in one short 2-gen algorithm. There are two phases to this method-
Phase 1- Create a 1x2x3 area on top of oriented/yellow pieces. Permutation doesn't matter. Very intuitive and easy to get good at.
Phase 2- Solve the orientation of the remaining yellow pieces whilst solving your F2L pair. It does not have to be paired up. 65 algorithms.
Just note that the Phase 2 algorithms are not developed so they are not as good as they can be.

This method should not be used every time, like if Phase 1 is difficult, just do F2L instead.

Example Solves-

Scramble: U2 L U F2 U' F' L' F2 L2 U F2 R2 D' B2 D R2
F' U2 F R U' R' // 123LS Phase 1
y U' R' L' U2 R U R' U R L // 123LS Phase 2

Scramble: U R U' R B L' B L D2 L2 D' L2 D' B2 R2 U
R U R' // 123LS Phase 1
d R2 U L U' R2 U L' U R' U R // 123LS Phase 2

Scramble: F2 L2 D B2 L2 F2 U B2 L R' B U B' U L' R'
U' R U R' // 123LS Phase 1
F2 U' R' F2 R U2 F R U' R' F // 123LS Phase 2

Scramble: U2 L2 U R L2 U' R' U B2 R2 D R2 F2 B2 U F2 U'
R U2 R' // 123LS Phase 1
L' U2 R U R' U2 L // 123LS Phase 2

Scramble: F' U2 F U2 F' U2 F U2 F' U F U' R U R' U2
R U2 R' U2 R U R' // 123LS Phase 1
d R U R U R U' R' U' R' // 123LS Phase 2

Corner In Slot:
A1- R2 D R' U2 R D' R' U2 R'
A2- r U R' U' r' F R F'
B1- L' R U R' U' L R U2 R' U' R U R'
B2- R U' R' U R U2 R' L' U R U' R' L
C1- R U' R' U' R U R' U2 R U' R'
C2- y' R' U R U R' U' R U2 R' U R
Corner On Top:
1a- y R' D R U' R' D' R
1b- R' D' R U' R' D R
2a- R U' R' U' R U2 R'
2b- y' R' U R U R' U2 R
3a- y' R' U2 R U' R' U2 R U' R' U2 R
3b- R U2 R' U R U2 R' U R U2 R'
4a- L U' R U L' U' R'
4b- y' L' U R' U' L U R
5a- R U R' U' R U' R' U R U' R'
5b- y' R' U' R U R' U R U' R' U R
1O- R2 U2 R2 U' R2 U' R2
2O- y' R' U2 R U R' U2 R U R' U2 R
3O- y' R' U' R U R' U' R U' R' U R
4O- R U R' U' R U R' U R U' R'
5O- U R U2 R' U' R U2 R' U' R U2 R'

Corner In Slot:
A1-
A2-
B1-
B2-
C1-
C2-
Pure 2-flip-
Corner On Top:
1a-
1b-
2a-
2b-
3a-
3b-
4a-
4b-
5a-
5b-
1O-
2O-
3O-
4O-
5O-

Corner In Slot:
A1-
A2-
B1-
B2-
C1-
C2-
Insert edge-
Corner On Top:
1a-
1b-
2a-
2b-
3a-
3b-
4a-
4b-
5a-
5b-
1O-
2O-
3O-
4O-
5O-

Thoughts about this method?

FakeMMAP · Apr 10, 2019

WoowyBaby said:
Interesting idea. Definently not practical for speedsolves though, because you have to force diag slots and algs have actually terrible ergonomics because it’s in the back left.

Though don’t worry, you only have to do one simple thing to turn this idea from bad to good. Just change one thing.
Have the slot be at FL instead of BL.
This improves literally everything!
In fact, if the algs are decent I actually might use this idea!

ye, I was actually thinking about genning EOFL and EOBR algs, though tbh this whole idea isn't (completely), but someone asked me to gen EOBL algs for some reason

PapaSmurf · Apr 10, 2019

FakeMMAP said:
ye, but that wouldn't be a new idea, would it?

But it's more practical and better. And more efficient. And yours isn't an entirely new idea. I've heard a lot of people say about eo in third slot, wv in fourth then pll or something along those lines. In terms of Lookahead, you're having to focus on a lot of pieces at once outside of inspection, and it's harder to look into fourth slot. Instead, do all of the difficult recog in inspection and have better F2L ergonomics. Or do it in last slot with ZB, or do it in LL with OLL/PLL. It's a fun idea, but not practical to be quite honest. This applies to whatever slot you do it with.

ImmolatedMarmoset · Apr 10, 2019

dudefaceguy said:
Hey thanks! I'm down to a PB of 3 minutes 15 seconds, which is still a DNF under competition rules

I checked a CMLL algorithm list, and it looks like having at least one corner oriented will eliminate 10 algorithms. This has got me thinking about what other easy things could be done to cut down on the number of cases while solving the last pair. There are only 12 cases with exactly one corner oriented.

Sorry I never got the chance to properly reply. That’s an interesting idea, but I think its major downfall is that building second block would be fairly limited because you’d have to find a way to get at least one corner oriented. Having only one corner oriented is even more so.

Having said that, I thought it might be interesting to integrate the HD Method for 2x2 into a 3x3 roux variant. You would make first block, a 1x2x2 block, and then do LOLS, and then do MNLC (Marmoset-Neuro Last Corners), which corresponds to NLL for the 2x2 but only using algs that don’t affect bottom edges. I’d have to generate some algs for that. The last step would be L7E, in which you solve EO and the FR edge with an alg, and then do L/R and 4c like roux. What do you think? It’s an improvement I think.

Overview:
Left block (as in roux)
Right block (1x2x2, not 1x2x3 like in roux)
LOLS (Lewis orientation of the last slot, these are 16 easy algs that orient all of the corners)
MNLC (Marmoset-Neuro Last Corners, which solve the last 5 corners without disrupting any other part of the solve)
L7E (Last 7 edges, insert FR edge and do EO at the same time, then do 4b and 4c of roux. This step adds a lot of validity to the subset L6EP, where one does 4b and 4c in one step)

Overall it’s quite similar to that other method Sue Doenim mentioned but far fewer algorithms and the L7E step is really cool.

dudefaceguy · Apr 10, 2019

ImmolatedMarmoset said:
Sorry I never got the chance to properly reply. That’s an interesting idea, but I think its major downfall is that building second block would be fairly limited because you’d have to find a way to get at least one corner oriented. Having only one corner oriented is even more so. Having said that, I thought it might be interesting to integrate the HD Method for 2x2 into a 3x3 roux variant. You would make first block, a 1x2x2 block, and then do LOLS, and then do MNLC (Marmoset-Neuro Last Corners), which corresponds to NLL for the 2x2 but only using algs that don’t affect bottom edges. I’d have to generate some algs for that. The last step would be L7E, in which you solve EO and the FL edge with an alg, and then do L/R and 4c like roux. What do you think? It’s an improvement I think.

HD method is way outside of my very limited knowledge, as is anything that does corner orientation then permutation. So I can't really comment on that aspect unfortunately. I tend to choose methods based on fun, so if it's fun I say go for it!

I was thinking, it should be possible to create a "method generator" that arbitrarily combines a list of steps to get to a solved cube. It would be fun to solve according to whatever crazy method it spit out.

I've had success so far with ensuring that at least one corner is oriented when I complete the second block, since this just involves choosing between different insertion methods for the last pair. I think you are right that it would be too difficult to ensure that exactly one corner is oriented.

ImmolatedMarmoset · Apr 10, 2019

dudefaceguy said:
HD method is way outside of my very limited knowledge, as is anything that does corner orientation then permutation. So I can't really comment on that aspect unfortunately. I tend to choose methods based on fun, so if it's fun I say go for it!

I was thinking, it should be possible to create a "method generator" that arbitrarily combines a list of steps to get to a solved cube. It would be fun to solve according to whatever crazy method it spit out.

I've had success so far with ensuring that at least one corner is oriented when I complete the second block, since this just involves choosing between different insertion methods for the last pair. I think you are right that it would be too difficult to ensure that exactly one corner is oriented.

This is already being developed!
This thing

The New Method / Substep / Concept Idea Thread

Super Moderator

Member

Member

Member

Member

Member

Member

Member

Member

Member

Member

Member

Member

Deleted member 36445

Guest

Member

Member

Member

Member

Member

Member

Similar threads