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

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

    If you are already a member, simply login to hide this message and begin participating in the community!
Joined
Feb 23, 2019
Messages
391
Location
The FitnessGram Pacer Test is a multi stage...
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

Member
Joined
Feb 17, 2019
Messages
57
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

Member
Joined
Apr 2, 2019
Messages
8
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)
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) 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) 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


steps.png

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') 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 alg 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 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 2 oriented U/D edges at RF-RB and solve L6E as usual 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 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'

trigger 2 (CO). R2 U2 R*

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

trigger 4 (EO). M' U M*

trigger 5 (EP). U M2 U*

trigger 6 (EP). U2 M2 U2 (M2)

trigger 7 (EP). M' U2 M U2

trigger 8 (EP). R2 U2 R2 U2 R2 U2
advanced alg set (requires modification by adding 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 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

stairs.png

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

recog - preferred.PNG

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

recog - wrong.PNG

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

morozov new.png

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

trigger.PNG

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 + 7*4 + 3*4 + 3*4 = 139; 139/27 = 5.15 HTM)
benek.png

(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 a pair in LD

only doing cube rotations place the fourth corner and its counterpart on the B layer 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 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

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. 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, permutation does not matter)
- solve 2 corners in LD (correct pieces, correct orientation, correct permutation)
- 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
- solve (orient then permute) L6E with <M, U> moves
- solve 2 corners in LD (correct pieces, correct orientation, correct permutation)
- 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 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

.
.

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 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, full or partial CO, CP, EO, EP (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, use the option that is easier to execute

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 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 (<20) algs with relatively low (<70) move count STM/HTM, the algs should be easy to understand and easy to implement, so shorter and simpler algorithms are preferred (and ergonomic if possible, preferably 2-gen)

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

https://www.speedsolving.com/forum/threads/the-new-method-substep-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
 
Last edited:

Sue Doenim

Member
Joined
Nov 9, 2016
Messages
446
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.
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*


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/threads/the-new-method-substep-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

Member
Joined
Apr 2, 2019
Messages
8
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
 
Last edited:

FakeMMAP

Member
Joined
Feb 15, 2016
Messages
167
Location
Milan (MI), Italy
WCA
2014MAUR06
YouTube
The Physicist Cuber
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'
 

WoowyBaby

Member
Joined
May 27, 2018
Messages
362
Location
United States
WCA
2018ISOM02
YouTube
https://www.youtube.com/channel/UCzgIKWl
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!
 

WoowyBaby

Member
Joined
May 27, 2018
Messages
362
Location
United States
WCA
2018ISOM02
YouTube
https://www.youtube.com/channel/UCzgIKWl
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-
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?
 
Last edited:

FakeMMAP

Member
Joined
Feb 15, 2016
Messages
167
Location
Milan (MI), Italy
WCA
2014MAUR06
YouTube
The Physicist Cuber
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

Member
Joined
Jan 4, 2018
Messages
428
WCA
2016TUDO02
YouTube
PapaSmurf Cubes
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.
 
Joined
Feb 23, 2019
Messages
391
Location
The FitnessGram Pacer Test is a multi stage...
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.
 
Last edited:

dudefaceguy

Member
Joined
Feb 17, 2019
Messages
57
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.
 
Joined
Feb 23, 2019
Messages
391
Location
The FitnessGram Pacer Test is a multi stage...
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
 

Solvador Cubi

Member
Joined
May 4, 2016
Messages
164
Location
USA

WoowyBaby

Member
Joined
May 27, 2018
Messages
362
Location
United States
WCA
2018ISOM02
YouTube
https://www.youtube.com/channel/UCzgIKWl
hey again @WoowyBaby ...

In your Kociemba-themed method... do you know if the probability for parity to occur is 50% ?
Do you know of some ways to influence the E-layer edge placement to avoid parity?

Also, I decided to start with your plan and develop it for my own tastes... :)
https://www.speedsolving.com/forum/threads/which-method-should-i-learn-in-2019.72833/

Now I need to practice it to see if I can achieve decent (for me) times!


thanks again,
-= Solvador Cubi
About parity, you can influence it during E-layer by making it have an even # of swaps, but it’s hard to do this and see where the specific edges end up, especially if you're speedsolving.
Getting fast is kind of hard with that method, but a lot easier if you use my other Kociemba-ish method below then...

Basically that weird Isom’s Kociemba is... sort of obsolete.
I’ve made a MUCH better Kociemba-themed method here- 2OP Method

-It has way better lookahead due to 2x2x2.
-It has way better ergonomics due to fast alg sets. (TSLE/TTLL)
-It’s easier to learn/understand, no difficult concepts, not much learning curve so you can be good at it fast.
-Similar average movecount, perhaps even lower, useful for FMC too, I got a 30 mover with zero effort.
-Just better.

Glad you like my ideas Solvador!
 
Last edited:

WoowyBaby

Member
Joined
May 27, 2018
Messages
362
Location
United States
WCA
2018ISOM02
YouTube
https://www.youtube.com/channel/UCzgIKWl
Idk if this belongs here, but here's a method that averages 34 moves-
Scramble: B2 L2 B2 R' U2 R' F2 U2 R F2 D' U' F' R' U2 B L2 B
U D2 L' U B2 D // Dual Squares (6)
U' F2 U' F' M' U2 F // Dual Pairs (7)
R' y' R U R2 U R2 U2 R' U y r // CMLL (10)
u2 M u2 U M U' M2 // LSE (7)
30 moves

Scramble: R D U F2 U B2 F2 U F2 R2 F2 U2 F R' U F' L D2 B F
D2 R' B U' R B L2 B // Dual Squares (8)
U' F U2 R' F R U F2 // Dual Pairs (8)
y R U2 R D R' U2 R D' R2 y' // CMLL (9)
M U M2 U' M U' M' U2 M U' // LSE (10)
35 moves

Scramble: R D' F2 L' F2 L D2 R F2 D2 L R2 F U' F2 D' F D2 B'
U L2 D2 F2 L D F D // Dual Squares (8)
L' U' R L2 D' R2 F L' // Dual Pairs (8)
F U' R' F' L F2 D' R F2 L' // CMLL (10)
F2 M2 U M U2 M2 U' M' U2 F2 // LSE (10)
36 moves

Scramble: F' B2 L D B2 R2 B U F U2 R2 U2 R' F2 R' D2 R2 F2 L B2 R2
y2 F D2 R' F' R' U L2 B // Dual Squares (8)
U2 M' F2 U' F' M U2 F2 // Dual Pairs (8)
F' L F L' U2 L' U2 L // CMLL (8)
U2 F2 U M' U' F2 U M2 U' M' U' // LSE (11)
35 moves

Scramble: F2 R2 B2 D' U F2 D' L2 R2 D L B' D F' U2 R D2 B' R F'
L2 B' D2 B2 L D2 // Dual Squares (6)
U F2 U' x U2 M U' M2 U x' // Dual Pairs (8)
R2 F2 R' U' R F2 R' U R' // CMLL (9)
U2 M U' F2 U' M' U' M U2 F2 U' // LSE (11)
34 moves
Since I don't care much for this method, I won't write a long post with lots of info or anything.

Edit: pls ignore this method, it’s not worth your time, and 34 moves is misleading.
 
Last edited:
Top