# The New Method / Substep / Concept Idea Thread

#### WoowyBaby

##### Member
Great, Thanks so much! I'm sure all this will help me (and others).

I'll be practicing it, but it will take me some time for me to get good at it, I'm sure.
and I plan to be taking my own notes along the way so I can hopefully make another 1 page reference sheet.

It seems like a nice method because even though there are several steps, they are all fairly simple.
(as well as having a low move count!)

In the PCBL step, I'm checking out the "Diag Top" alg you listed, to see if I like it.
It ends in a nice sexysledge, but I've always used: R U’ L U2 R’ U R L’ U’ L U2 R’ U L’ (14 htm)

I'll also need to find a way to intuitively do CO efficiently without memorizing the 72 cases!

Lastly, I don't know enough about Kociemba and how much your proposed steps are similar,
but if it's different enough, I say.. name the method anything you want!

Diag Alg: People do have their preferences for algorithms and I am aware of Diag Top algs besides Y-perm PLL, so I could provide more than one alg per case and slam it on a sheet maybe here- (link)

CO: For CO, understand exactly what an R / R’ move does, then memorize the cases that are only 3 moves, like R U R’.
Then, memorize all 72 cases. This is not too difficult, as many just do a couple moves to reduce it to a 3 move case, so you can memorize a case like: “ok just a Pi OLL on Top is held in back and is “down-left U backhammer”. Boom, memorized. (R’ U’ R U R’ U2 R is the alg you’re wondering)
Not that on Lucas Garron’s Sortega page, every case ends with R, but it can be replaced with R’ if it’s better ergonomically. Ex: R U’ R’ is better than R U’ R

Edit: Doing a single R move changes it to a different case

Idk really what to say about the CO, I’m not an expert or anything.
It’s like looking at a page of all 160 possible F2L cases and thinking it’s impossible to learn, when really, because it’s a semi-intuitive step, it’s far easier to memorize cases than from an algorithmic step.

Kociemba: Kociemba is not a method persay, it’s a computer algorithm used today and invented by Herbert Kociemba.
It is a 2-phase algorithm-
Phase 1: Reduce cube to R2,L2,F2,B2,U,D, state. In other words, Orient all edges, Place middle(equator) layer pieces somewhere in middle layer, and Orient all corners.
Phase 2: Permute the rest of the cube with the restricted move set. Now it’s solved.
The goal of 2-phase algorithms are to split the solve into 2 parts that take roughly the same amount of computing power and moves.

Doing either phase in one step is far too hard conceptually for humans, so there are different methods to do each phase in multiple steps. In the case of Isom’s Kociemba (such a bad name ew), the first three steps are EO DF, 2-gen CO, and E-layer placement. This achieves phase 1. Next phase: CS,CP, L/R, 4c, solves the rest of the cube.
Other methods that do basically this are Orient first, Human Thistlewaite, and SSC.

Just a side note: I’m actually pretty slow with this method.
Holy this is a huge block of text whoops lol.

Last edited:

#### dudefaceguy

##### Member
I tried the method on a 5x5 again and counted my moves this time. I came up with 208 which I think is not too bad, considering that I made some mistakes, was using an inefficient version of the method, and wasn't particularly efficient in general (33 moves to solve the first 2 centers). This seems to be similar to the move count in a reduction speedsolve. It's slightly less efficient than my 4x4 average, at 2.26 moves per piece solved versus 2.17 for 4x4.

The efficiency surprised me at first, because I was expecting this method to be much worse for 5x5. But it actually makes sense, for two reasons. First, solving corners is more efficient and easier because you can solve middle edges at the same time, just as you do in Heise. Second, you can solve 3/4 of the middle slice before the last step, so you end up with a maximum of only 17 unsolved center pieces, compared with 10 on the 4x4. This is about 18% of the total pieces on the cube, which is the same proportion as on the 4x4. Adding the middle slice actually enables us to solve proportionally more of the center pieces before the last step: 65% on the 5x5 vs about 58% on the 4x4.

I modified the methodfor the 5x5 as follows:

1. Opposite centers

2. 1x3x3 block and 1x3x4 block

3. 3/4 of the middle slice

4. Pair (not solve) the last edge of the second 1x3x4 block

5. Orientation of remaining 5 middle edges (this can be done earlier but it doesn't seem to make much difference)

6. Solve all middle edges and corners exactly as in Heise steps 3-4

7. 3/4 of a wing slice

8. 7 wing edges

9. Commutator to solve last 3 wing edges

10. 3-5 center commutators

I also tried a solve on a virtual 7x7, which requires two wing slices to remain unsolved. I ended up with 38 unsolved center pieces in the last step. So, the method will work for any nxnxn cube, but it just gets progressively less efficient as the cube gets larger because there are proportionally more center pieces versus wing edges. But hey, at least you don't have to learn any parity algorithms!

I actually found the5x5 solve to be extremely fun, since there is so much variation in the different techniques used. I never really paid attention to 5x5 because I don't like reduction solves, but now that I have a direct intuitive method, I'm having a heck of a lot of fun! I might actually enjoy it more than the 4x4 version.

#### WoowyBaby

##### Member
@dudefaceguy Here's some 4x4 example solves with your method-
"1. Solve two opposite centers.
2. Solve a 1x3x3 block and a 1x3x4 block (similar to Roux) on the opposite face.
3a. Solve two more corners such that the last 3 corners are out of place, then solve the last 3 corners using a commutator.
3b. Solve the last edge pair of the 1x3x3 block to extend it to a 1x3x4 block.
4. Extend one of the 1x3x4 blocks into a 2x3x4 block by solving one middle slice excluding the top layer.
5. Use the unsolved slice to solve exactly 7 of the remaining 10 edge pieces.
6. Solve the remaining 3 edge pieces and some center pieces with a commutator.
7. Solve the remaining center pieces with 2 or 3 commutators."

Scramble: D2 L R2 F2 L2 R2 D2 B L2 U2 B' U2 B2 F' U' F2 D2 L2 R' U' R Fw2 Rw2 R' B2 D2 Fw2 F L' B Uw2 F D2 B' Uw L2 Uw2 L' B2 Uw' B Rw Fw B Uw2 U Fw2
x2
R2 f r U2 r' U R' y r U2 r' z // 2 Opposite Centers (10)
R U R2 L U' r' U' F' L2 F // Red 1x3x3 (10)
R2 U' r L F' L D L2 U R' U' r2 R' F R2 F' R' U R2 U' R2 U' R U r' U2 R U R' U' R y D' R U' R' D // Orange 1x3x4 (36)
y U2 R' F2 R F' R' F2 R2 U R' // Corners (10)
U' R l L R2 D' R2 L2 U R' // Remaining Edge (10)
2R U 2R' m' U m' D2 U m' U m D2 2R U' 2L2 U2 m2 U 2L' U2 2L m U2 m' 2R2 U' 2R2 U m U2 m2 U2 m 2R2 U 2R2 U' m' U2 m // Left M slice (40)
U2 2R U2 2R2 U' 2R2' U2 2R U2 2R2 U 2R' r U R' U' 2R' U R U' R' // Solve 7/10 Edges (21)

// Non-Intuitive Near-Impossible L3E Commutator
// Non-Intuitive Near-Impossible Last 12 Centers Commutators
137 STM + ~40-50 for the rest = 180 ish

This method is extremely difficult to solve with, not for beginners whatsoever, requires a very high level understanding of the cube, many parts are too complex to do efficiently.
I spent actually over an hour on the solve, because how complicated it is.
Algorithms are easier to understand than commutators.
I actually know exactly how commutators work, and have lots of experience on 3x3, but I didn't grasp this.
Even in your own video you struggled near the end to solve using your own method.

This is an interesting method, maybe just not for me
Maybe other people will like it though

Last edited:

#### dudefaceguy

##### Member
@dudefaceguy Here's some 4x4 example solves with your method-
"1. Solve two opposite centers.
2. Solve a 1x3x3 block and a 1x3x4 block (similar to Roux) on the opposite face.
3a. Solve two more corners such that the last 3 corners are out of place, then solve the last 3 corners using a commutator.
3b. Solve the last edge pair of the 1x3x3 block to extend it to a 1x3x4 block.
4. Extend one of the 1x3x4 blocks into a 2x3x4 block by solving one middle slice excluding the top layer.
5. Use the unsolved slice to solve exactly 7 of the remaining 10 edge pieces.
6. Solve the remaining 3 edge pieces and some center pieces with a commutator.
7. Solve the remaining center pieces with 2 or 3 commutators."

Scramble: D2 L R2 F2 L2 R2 D2 B L2 U2 B' U2 B2 F' U' F2 D2 L2 R' U' R Fw2 Rw2 R' B2 D2 Fw2 F L' B Uw2 F D2 B' Uw L2 Uw2 L' B2 Uw' B Rw Fw B Uw2 U Fw2
x2
R2 f r U2 r' U R' y r U2 r' z // 2 Opposite Centers (10)
R U R2 L U' r' U' F' L2 F // Red 1x3x3 (10)
R2 U' r L F' L D L2 U R' U' r2 R' F R2 F' R' U R2 U' R2 U' R U r' U2 R U R' U' R y D' R U' R' D // Orange 1x3x4 (36)
y U2 R' F2 R F' R' F2 R2 U R' // Corners (10)
U' R l L R2 D' R2 L2 U R' // Remaining Edge (10)
2R U 2R' m' U m' D2 U m' U m D2 2R U' 2L2 U2 m2 U 2L' U2 2L m U2 m' 2R2 U' 2R2 U m U2 m2 U2 m 2R2 U 2R2 U' m' U2 m // Left M slice (40)
U2 2R U2 2R2 U' 2R2' U2 2R U2 2R2 U 2R' r U R' U' 2R' U R U' R' // Solve 7/10 Edges (21)

// Non-Intuitive Near-Impossible L3E Commutator
// Non-Intuitive Near-Impossible Last 12 Centers Commutators
137 STM + ~40-50 for the rest = 180 ish

This method is extremely difficult to solve with, not for beginners whatsoever, requires a very high level understanding of the cube, many parts are too complex to do efficiently.
I spent actually over an hour on the solve, because how complicated it is.
Algorithms are easier to understand than commutators.
I actually know exactly how commutators work, and have lots of experience on 3x3, but I didn't grasp this.
Even in your own video you struggled near the end to solve using your own method.

This is an interesting method, maybe just not for me
Maybe other people will like it though
Wow, thank you very much for testing out this method! I agree that it is definitely not a beginner-friendly method. The intended audience is very specific and possibly includes only myself. It's not meant to be a generally popular or universal method, but rather to fill a specific niche for weirdos like myself by providing a couple of things that I couldn't find in other methods.

The ideal candidate would be someone like myself, who learns Heise for 3x3 because they really REALLY don't like learning algorithms, and then wants to try larger cubes without learning parity algorithms. It also helps if you really REALLY love commutators and enjoy spending lots of time to work out move-optimal solutions. I will often spend a few minutes on a single commutator, trying to save one or two moves or solve one extra piece. This is not necessary of course, but I really enjoy doing it.

I realize that most people will not be looking for these things when selecting a method. But, I couldn't find a method that satisfied by own weird criteria so I made one. I gave absolutely no regard for things that are very important in speedsolving methods, like minimizing rotations, avoiding slice moves, and other ergonomics. Making a big cube method intended for Heise mains is already restricting the intended audience to like 5 people in the world.

Thank you for linking the solve, because I am not good at following notation. The 3/4 slice step was definitely very difficult for me to figure out at first, but it can be done pretty easily. It looked like you were making bars and then pairing them with edge pieces and inserting them, which I tried to do at first also. I've found it to be a lot more efficient to build the 3/4 slice like this:

1. Place the edge in the top layer on the L or R side, oriented such that the color you want to pair is on the U face.
2. Rotate the slices (mostly just the unsolved slice) to join center pieces with the edge, making a bar that goes from the L to the R face - perpendicular to the slice where it will be inserted. Rotate the U layer 180 degrees to shift the edge piece between the L and R side, depending on where the center pieces are located. The 3 pieces can be joined with only U and r moves, and sometimes l moves if necessary.
3. Once the two center pieces are joined to the edge, rotate U 90 degrees to place the three pieces in the correct slice.

This was not clear in my video - I probably should have spent more time on this step.

As for L3E commutator, the moves will always be exactly the same, or mirrored, if the 3 edges are in the same slice. For example, if the unsolved slice is u and the unsolved edges are in the columns FL, FR, and BR, and the FL edge belongs in the FR column, use [L': [F' U' F, u]]. This, or it's mirror, will solve all cases of L3E in the same slice. I use this in my video. If instead the last edges are in different slices, the commutator can sometimes require an ugly conjugate, but it can be easier to include center pieces.

Thanks again for posting the solve and for linking it!

Last edited:

#### ImmolatedMarmoset

##### Member
I’m sure this has been thought of before, but isn’t there a way to algorithmically combine steps 4b and 4c of roux? It doesn’t seem like there would be a ton of algs. Just want to get input; I couldn’t find this anywhere.

#### PapaSmurf

##### Member
alg.cubing.net

It's all contained in the link.

I’m sure this has been thought of before, but isn’t there a way to algorithmically combine steps 4b and 4c of roux? It doesn’t seem like there would be a ton of algs. Just want to get input; I couldn’t find this anywhere.
Yeah. It's just called L6EP, and is useful in L7E or when you get an eoskip in LSE. Otherwise, just use EOLR.

#### ImmolatedMarmoset

##### Member
alg.cubing.net

It's all contained in the link.

Yeah. It's just called L6EP, and is useful in L7E or when you get an eoskip in LSE. Otherwise, just use EOLR.
Thanks so much!
Do you know where any algs are? I know about EOLR, but I did a quick search on speedsolving wiki and a bit on google, and I couldn’t find anything. I just want to see how many there are and what they’re like.

#### PapaSmurf

##### Member
Here they are un sorted.

There are 96 (including EPLL) and they're all probably very good. I don't know how many are trivial, but they'll be an easy set to learn. Average movecount is around 8.6 iirc.

#### ImmolatedMarmoset

##### Member
Here they are un sorted.

There are 96 (including EPLL) and they're all probably very good. I don't know how many are trivial, but they'll be an easy set to learn. Average movecount is around 8.6 iirc.
Thanks so much! I’m more of a beginner so maybe I’ll look into simpler ways of doing that. Maybe getting l/r edges together in the bottom layer after EO and then apply an alg to solve the whole thing? I might put that into cube explorer because I’m pretty sure no one has tried that out and it shouldn’t be a lot of algs. I’d like to hear your thoughts on a beginner version of L6EP executed that way. In other words, algorithmically (or possibly intuitively) predicting 4c. Would that have any extra algs than just normal 4c or no? I’m a bit confused about that.

Edit: you can skip the 4c step with l/r edges on the bottom together, I randomly found one case while playing around with alg.cubing.net: https://alg.cubing.net/?setup=M2_U2_M2_U2_U_M2&alg=U_M2_U2_M2_U3_M2_U
Don’t know if this is even useful, but the alg I found doesn’t ever go into the 4c roux step.

Last edited:

#### PapaSmurf

##### Member
You'll be better doing EOLR most of the time then L6EP when you get an eo skip, because it's more efficient. And Kian Mansour has a good video here and videos here.

#### Sue Doenim

##### Member
Thanks so much! I’m more of a beginner so maybe I’ll look into simpler ways of doing that. Maybe getting l/r edges together in the bottom layer after EO and then apply an alg to solve the whole thing? I might put that into cube explorer because I’m pretty sure no one has tried that out and it shouldn’t be a lot of algs. I’d like to hear your thoughts on a beginner version of L6EP executed that way. In other words, algorithmically (or possibly intuitively) predicting 4c. Would that have any extra algs than just normal 4c or no? I’m a bit confused about that.

Edit: you can skip the 4c step with l/r edges on the bottom together, I randomly found one case while playing around with alg.cubing.net: https://alg.cubing.net/?setup=M2_U2_M2_U2_U_M2&alg=U_M2_U2_M2_U3_M2_U
Don’t know if this is even useful, but the alg I found doesn’t ever go into the 4c roux step.
In my opinion, 4c starts when LR edges (or FB edges if you're doing EOFB) are on the D layer and EO is solved. That way, you can make the solve better by implementing techniques like dots evasion when applicable. As a Roux solver, I know that as you get more experienced with L6E, it gets easier to predict 4c after EOLR is solved, and I bet that more experienced solvers can take that further and predict it earlier. At any rate, I don't think the bad recognition is worth it, and the speed gain would probably be negligible in cases where it applies.

#### Umar Uzden

##### Member
Hello, guys. I'm new here and just finished reading this thread. Also I checked "List of methods". Is there any actual or work in progress algorithmic method to blockbuild to F2L - 1 slot state?

#### WoowyBaby

##### Member
Hello, guys. I'm new here and just finished reading this thread. Also I checked "List of methods". Is there any actual or work in progress algorithmic method to blockbuild to F2L - 1 slot state?
I don't think blockbuilding could be algorithmic? I'm not quite sure what you are asking...

#### xyzzy

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

#### Umar Uzden

##### Member
That must have taken you a whole day...
It took me way longer - three weeks or so )

I was thinking about lowering case count through restricting order of solve and corner position.
By order I mean, for example, 2x2x2 block in BDL, then square in FDL (FDL corner + FL and DF edges), then BDR square (BDR + BR and DR)
Any corner except BDL can be moved to FUR position by 1 move, so it will reduce cases by 7 times for front square, so there will be 864 cases, and by 6 times for right square leaving 504 cases.
I genned near 100 algs for front square, and average movecount was ~5.4 face turns. For right square movecount will be higher, but I doubt (don't have access for my pc for week or two) that average will be higher than 9 moves.
Also, for first square corner can be oriented and moved to FUR in 2 moves or less, for second square in 3 or less moves, reducing cases by 3 times, but increasing movecount.

#### Imam Alam

##### Member
bismillaahir raHmaanir raHeem

Code:
Gilles Roux said:

Hey Ryan, you could be much faster.
You know what's the problem with you?
You think too much, you'll never be a speedcuber!

... P.S.: I've got the same problem...

([email protected])

.
.

Just sharing a bunch of simple methods and variants for solving the 3x3x3 cube in fun, novel and elegant ways.

I guess this is more of a concept idea post than a new method post.
The main goal is to solve the cube with more understanding, and rely less on rote memorization.

.
.

Methods Overview

This is my collection of "mini-methods" that have only "mini-algs", along with other cubing concepts.

Feel free to add more methods or method variants to this list!
a mini-method is a stand-alone (complete) method that solves the entire 3x3x3 cube. It is not just a sub-step. I am calling it "mini" because it is based on a simple idea, and it is possible to boil it down to one or two core concepts.
a mini-alg (or a trigger) is a very short sequence of moves that is so easy to understand and implement that you may even choose to call it "intuitive".
I don't believe that any method or variant can ever be 100% intuitive, just more intuitive or less intuitive (that, too, varies person to person).

I am simply focusing on the ones that are more intuitive for me.
I don't claim any credit for any of these methods.

Just trying to share and discuss methods invented by others.

My contribution (hopefully) is the way these methods are organized and modified to fulfill the requirements described below.

The methods outlined here would have the following properties:

- solving as fast as possible is not the goal, nor winning competitions (rather the goal of using these methods would be pure fun/enjoyment, or a better understanding of the cube, or both)
Yes, I know, and I am not against speedsolving and competitions (both have their places), just looking for ways to expand the horizon, and to try out new things.

- methods that require some intuitiveness are preferred (simplified versions of the popular methods are also welcome)
No, I am not against memorization and algorithms (both have their places).

In fact, the more you practice intuitively the more it becomes memorized/algorithmic, and vice versa.

We still use algorithms as beginners, in one form or another, but we keep on trying to understand how those algorithms actually work.

- have significantly different step(s) compared to more popular methods, and preferably do not end with LL (last layer) algorithms
Well, I am not against popular methods either.

It is just that popular methods are usually optimized for speedsolving, and here we are focusing more on other factors, such as fun, novelty, challenge, and elegance.

- diverse solving styles, fun new methods to try out (elegant, aesthetically pleasing solutions are a bonus)
Concepts are preferred over memorized algorithm sets, e.g. freedom of movement, symmetry, parity and twist constraints, group theory.

In practice: block building, commutators, generator reduction (domino, 2-gen), EO and CP etc.

- relatively few (<20) algs, learning new algs with every new method is not desired (shorter and ergonomic algs are a bonus)
No, I am not against methods with large alg sets.

I just find a smaller alg set is easier to digest, easier to understand thoroughly in less time, and easier to recall.

- relatively low (<70) move count STM/HTM
Here we are expressing move count in STM (Slice Turn Metric) and HTM (Half Turn Metric), i.e. these methods should not require more than 70 slice turns (or half turns) on average to solve the cube.

That's what I am aiming for.
Feel free to add to my list, your methods don't need to fulfill all of the above conditions, so if you think that you know of a method that goes with the general spirit, just go for it!

.
.

Algorithms Overview

The algs should be easy to understand and easy to implement, i.e. it should be a nice alg set.

Hence shorter and simpler algorithms are preferred.
For the 15 mini-methods and variants I am sharing here, I propose an alg set of 8 triggers or mini-algs (yes, you read that correctly: 8 short algs for 15 methods combined!).

The algorithms included here would have the following properties:

- the alg set is short (<10 algs for one complete method)
I am using 8 algs for 15 methods, none of these methods require more than 8 algs, and there are a couple methods that virtually require 0 algs.

- each alg is short (3 ~ 6 moves HTM and STM)
The 8 triggers I am using have an average length of 4.88 moves HTM (4.00 moves STM), none of them is longer than 6 moves HTM (and 6 moves STM).

- the algs should be easy to understand and recall (the user of the method should know exactly what the algs do to which pieces)
All of the 8 algs I am using can be considered as nice (usually symmetric), so they are even shorter, and easier to understand.

- additionally, the algs should be ergonomic if possible (preferably 2-gen)
All of the 8 algs I am using are 2-gen.

.
.

Methods List
From here onward "methods" stands for "methods and variants".

The mini-methods that I am sharing may be put into the following groups:
When I describe a method with the name of the inventor of that method, I do that only generally, sometimes only taking a method partially and simplifying the rest.

For example, when I describe a method as "Roux" I don't claim that this is exactly how Gilles Roux had proposed it.

So please take the method names with a grain of salt.

[2-Generator Methods]

Method 1. Wu
- 1x1x3: EO (trigger 1 / trigger 2) then CP (trigger 8 / 2GR / others), or CP (trigger 8 / 2GR / others) then EO (trigger 2)

- 2x2x3 (blockbuild)

- 3x3x3 (2-gen, blockbuild): make 4 corner-edge pairs, then permute last 2 layers

Method 2. ZZ
- EOline (trigger 1 / trigger 2)

- F2L (blockbuild), optional CO L4C

- L4C (trigger 1 + mirror / corner 3-cycle + sune), or CP L4C if CO L4C already done (trigger 1 + mirror / corner 3-cycle)

- EP L4E (trigger 1 + mirror + inverse / sune + mirror)

Method 3. Petrus
- 2x2x3 (blockbuild)

- EP L7E (trigger 1 + mirror using F turns)

- F2L (blockbuild), optional CO L4C

- L4C (trigger 1 + mirror / corner 3-cycle + sune), or CP L4C if CO L4C already done (trigger 1 + mirror / corner 3-cycle)

- EP L4E (trigger 1 + mirror + inverse / sune + mirror)

[Edges First Methods]

Method 4. Heise
- F2L-1 (blockbuild, then EO) (w/ or w/o pseudo blocks)

- L5E EP (w/ or w/o EC pairs)

- L5C or L3C (corner 3-cycle)

Method 5. Keyhole
- F2L-1

- EO L5E (trigger 1 + mirror)

- EP L5E (trigger 1 + mirror)

- L5C (trigger 1 + mirror + inverse / corner 3-cycle)

Method 6. Coffer
- F2L-1

- EP L5E (trigger 1 as R U2 R')

- EO L5E (trigger 1 as R U2 R')

- L5C (trigger 1 as R U2 R' + mirror / trigger 1 / corner 3-cycle)

[Corners First Methods]

Method 7. Sandwich
- 8C (trigger 1 + mirror / corner 3-cycle)

- E slice and S slice

- EP L4E (triggers 3 and 4)

- EO L4E (edge flip commutator)

Method 8. Columns
- 8C (trigger 1 + mirror / corner 3-cycle)

- E slice and DL+DR as 3 pairs (trigger 5)

- EO L6E (trigger 2)

- EP L6E as 3 pairs (triggers 3 and 4)

Method 9. Roux
- FB and SB (blockbuild)

- LLC (trigger 1 + mirror / corner 3-cycle)

- EO L6E (trigger 2)

- EP L6E (triggers 3 and 4)

[Orient First Methods]

Method 10. Thistlethwaite
- EO and separate E slice edges (trigger 1 / trigger 2)

- CO (triggers 1 and 7)

- CP (trigger 8)

- EP (triggers 3, 4 and 6)

Method 11. Morozov OF
- CO (triggers 1 and 7)

- separate E slice edges (trigger 5) and EO L8E (trigger 2)

- CP (trigger 8)

- EP (triggers 3, 4 and 6)

Method 12. Morozov CF
- CO (triggers 1 and 7)

- CP (trigger 8)

- separate E slice edges (trigger 5) and EO L8E (trigger 2)

- EP (triggers 3, 4 and 6)

[Permute First Methods]

Method 13. Benek CF
- CP (trigger 8 / 2GR / others)

- CO (triggers 1 and 7)

- separate E slice edges (trigger 5) and EO L8E (trigger 2)

- EP (triggers 3, 4 and 6)

Method 14. Benek PF
- CP (trigger 8 / 2GR / others)

- EO (trigger 2)

- CO (triggers 1 and 7)

- separate E slice edges (trigger 5) and EP (triggers 3, 4 and 6)

Method 15. Benek 2GR
- EO (trigger 1 / trigger 2)

- CP (trigger 8 / 2GR / others)

- CO (triggers 1 and 7)

- separate E slice edges (trigger 5) and EP (triggers 3, 4 and 6)

.
.

Algorithms List
The mini-algs (triggers) for the above methods are:
I don't claim to have generated any of these algs.

I have simply collected, compared and selected the algs to come up with a relatively nice alg set.

Trigger 1. R U* R' (U')
length: 3 HTM or 4 HTM, 3 STM or 4 STM

application: this is the only alg required for method 5 (keyhole), it is also the only alg required for method 6 (coffer) as R U2 R', and it is useful for CO in methods 10 ~ 15 (OF and PF methods)

Trigger 2. M' U M*
length: 5 HTM, 3 STM

application: EO alg in methods 7 ~ 15 (CF, OF and PF methods)

Trigger 3. U2 M2 U2 (M2)
length: 4 HTM or 6 HTM, 3 STM or 4 STM

application: EP alg in methods 7 ~ 15 (CF, OF and PF methods)

Trigger 4. M' U2 M U2
length: 6 HTM, 4 STM

application: EP alg in methods 7 ~ 15 (CF, OF and PF methods)

Instead of using 90 degree M slice turns, we can use R2 U2 R2 F2 R2 U2 R2 F2 (8 HTM, 8 STM), thus making the EP finish in methods 7 ~ 12 (OF and PF methods) purely with 180 degree turns.

In these methods we progressively reduce the cube to be solvable with 180 degree turns, so I find this alternative alg pretty elegant.

Although not a 2-gen alg, it is still quite ergonomic and short, and has some symmetry.

Trigger 5. U M2 U*
length: 4 HTM, 3 STM

may also be applied as R E2 R*

application: EP alg (M slice or E slice) in methods 7 ~ 15 (CF, OF and PF methods)

Trigger 6. R2 U2 R2 U2 R2 U2
length: 6 HTM, 6 STM

application: EP alg in methods 10 ~ 15 (OF and PF methods)

Trigger 7. R2 U2 R*
length: 3 HTM, 3 STM

application: CO alg in methods 10 ~ 15 (OF and PF methods)

source: Morozov method

Trigger 8. R2 U' R2 U R2
length: 5 HTM, 5 STM

application: CP alg in methods 10 ~ 15 (OF and PF methods)

source: Morozov method

.
.

Methods Comparison
Code:
---------------------------------------------------------------------------------------------
type    |             steps            |  #EO  |       features       |       redux
---------------------------------------------------------------------------------------------
| Wu               EO CP BB BB |  12   | BB          OF    PF |                 RU
2G     | ZZ               EO BB CS EP |  12   | BB          OF       |                 RU
| Petrus           BB EO CS EP |   7   | BB                   |                 RU
---------------------------------------------------------------------------------------------
| Heise            BB EO EP CS |   5   | BB                   |
EF     | Keyhole             EO EP CS |   5   |                      |
| Coffer              EP EO CS |   5   |                      |
---------------------------------------------------------------------------------------------
| Sandwich            CS EP EO |   0   |       CF             | MU
CF     | Columns             CS EO EP |   6   |       CF             | MU
| Roux             BB CS EO EP |   6   | BB    CF             | MU
---------------------------------------------------------------------------------------------
| Thistlethwaite   EO CO CP EP |   8   |       CF    OF       |      G1+G2+G3
OF     | Morozov OF       CO EO CP EP |   8   |       CF    OF       | MU   G1+G2+G3   RU
| Morozov CF       CO CP EO EP |   8   |       CF    OF       | MU   G1+G2+G3
---------------------------------------------------------------------------------------------
| Benek CF         CP CO EO EP |  8/11 |       CF    OF    PF |      G1+G2+G3   RU
PF     | Benek PF         CP EO CO EP |  8/11 |       CF    OF    PF |      G1+G2+G3   RU
| Benek 2GR        EO CP CO EP | 11/12 |       CF    OF    PF |      G1+G2+G3   RU
---------------------------------------------------------------------------------------------

- Generally speaking, the earlier methods in the list (methods 1 ~ 6) have more of a blockbuilding/edges first/face turns/direct solve style, and later methods (methods 7 ~ 15) have more of a corners first/columns first/slice turns/reduction style

- Earlier methods in the list (methods 1 ~ 9) solve the corners relatively directly, later methods (methods 10 ~ 15) solve corners more indirectly.

- Number of edges to be oriented during the EO stage gradually decreases and then increases again as we progress through the list.

- Two of these methods (Heise and Wu) virtually require no algorithms

- For methods 7~ 9 and 10 ~ 15, each method builds upon the previous ones, hence they get more and more complex as we progress through the list.

- Generally speaking, methods 10 ~ 15 first reduce the cube to <F2, B2, R, L, U, D>, then to <F2, B2, R2, L2, U, D>, and then to <F2, B2, R2, L2, U2, D2>, before finally solving it with 180 degree turns only.

- Will add more methods to the list, that is when I find them.

.
.

Yup, that's my first post in this forum!
(Been lurking around for a long time...)

.
.

Code:
Tony Fisher said:

Intuitive means you are fully aware of every move you are making and understand what each turn is doing.

... Obviously my interpretation means no solve can be 100% intuitive though I am happy to relax my rules when I feel like it.

(http://twistypuzzles.com/~sandy/forum/viewtopic.php?f=8&t=27543)

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

Last edited:

#### Aerma

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

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

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