2-gen methods

You could do it like that, but not per se...
Step 1 is solving the FR and BR edges in the correct layer and simultaneously solve two corners in FRD and BRD so that the sticker colours match or are opposite to the face colour.
Step 2 is OCLL
Step 3 is intuitive edge solving

BTW what is HTR?
I see. Pretty cool.
HTR is half turn reduction. In FMC terms, it’s DR on all axes. It’s just a fancy way of saying that the cube is solvable using only half turns.
 
HTR is half turn reduction. In FMC terms, it’s DR on all axes.
Technically, DR on all axes isn't enough to guarantee it's half-turn-solvable. Consider for example an N perm, which definitely can't be solved with only half turns, but is DR on all axes (if you AUF it to be 2c2e).
 
Technically, DR on all axes isn't enough to guarantee it's half-turn-solvable. Consider for example an N perm, which definitely can't be solved with only half turns, but is DR on all axes (if you AUF it to be 2c2e).
True, I stand corrected.

By the way, while we are coming up with methods, another interesting exercise is to find the god’s number for RU-gen scrambles using R and U moves only.

There are 17 move 2GLLs with no more efficient solutions without involving other faces, so that is a lower bound. Simple F2L>2GLL ensures we can solve it in 2+12+12+20 = 46 moves, so that is a nice weak upper bound. Let’s see if we can narrow this further.
Though, it’s a very restricted set, I guess a fairly well written code should run in under a day on a laptop.
square In back -> 1llsll only ~7000 algs
imo it’s the only reason to bother doing a cp method such as Briggs
It’s 1900 algs afaik. Mentioned it in the OP.
 
another interesting exercise is to find the god’s number for RU-gen scrambles using R and U moves only.
It's already known, actually! There's less than 100 million states, so even crummy old computers didn't have too much trouble with that.

Source: http://forum.cubeman.org/text/fullcube.txt
Code:
        Analysis of the 3x3x3 <U, R> group
        ----------------------------------
ML's Conjecture: The < U, R > group is >=20 turns deep in qt metric
                 Now confirmed, Sept 1, 1994

                                          branching
Moves Deep       arrangements (q only)     factor

  0                    1                      --
  1                    4                       4
  2                   10                       2.5
  3                   24                       2.4
  4                   58                       2.416
  5                  140                       2.413
  6                  338                       2.414
  7                  816                       2.414
  8                1,970                       2.414
  9                4,756                       2.414
 10               11,448                       2.407
 11               27,448                       2.401
 12               65,260                       2.378
 13              154,192                       2.363
 14              360,692                       2.339
 15              827,540                       2.294
 16            1,851,345                       2.237
 17            3,968,840                       2.144
 18            7,891,990                       1.988
 19           13,659,821                       1.755
 20           18,471,682                       1.352
 21           16,586,822                       0.898
 22            8,039,455                       0.485
 23            1,511,110                       0.188
 24               47,351                       0.031
 25                   87                       0.002
              ----------
              73,483,200

Moves Deep       arrangements (q+h)     total 
  0                      1                1
  1                      6                7
  2                     18               25
  3                     54               79
  4                    162              241
  5                    486              727
  6                  1,457            2,184
  7                  4,360            6,544
  8                 13,016           19,560
  9                 38,482           58,042
 10                113,094          171,136
 11                328,920          500,056
 12                942,351        1,442,407
 13              2,616,973        4,059,380
 14              6,774,848       10,834,228
 15             15,105,592       25,939,820
 16             24,231,019       50,170,839
 17             19,421,274       69,592,113
 18              3,843,568       73,435,681
 19                 47,465       73,483,146
 20                     54       73,483,200
 
you may want to have a look at the second half of this method

a beginner version of this method would be to simply do CO and then EP



number of algorithms: 1~4, depending on how you count (for me the number of algorithms is 0, since this method is intuitive for me)

inspection: I usually solve the entire cube with this method, so that the 2-gen part is in the middle of a solve, that means I don't have extra inspection time for the 2-gen part of the solve

edit: this was supposed to be the first reply in this thread haha, but it was kept in waiting for moderator approval for some reason
This is legit the coolest method so far!
i was told it was 7k but that might be an upper bound so adding in auf things I can see it being around there, in that case it might make cp methods viable.
Yep, you’re right; it’s 7k. I initially miscalculated.
 
Last edited:
How about this method?

R2 U' R' U2 R2 U2 R2 U R' U' R2 U2 R U R' U' R U2 R' U' R' U R' U2 R

U R U2 R2 U R' //
U' R2 U' R2 //
U R U2 R2 U2 R2 U2 R //
R U R U R' U' R' U' R' //
// 27

R' U2 R U R2 U R2 U2 R2 U2 R U' R' U R2 U R2 U2 R2 U' R2 U R2 U R'

R U2 R2 U' R U' R' //
U R2 U R2 //
U' R U R' U' R' U' R' U //
S' U2 S U2 R U2 //
// 26

R' U R U R U R' U R' U R2 U R' U2 R U R2 U R2 U' R U2 R' U2 R

U2 R U2 R' U2 R //
U' R2 U R2 //
U' R' U2 R U2 R2 U2 R2 U2 R U2 R //
U R' U' R U R U R U' R' U' //
// 33

U' R U' R2 U2 R' U2 R' U2 R2 U2 R2 U R' U2 R' U2 R' U' R U' R' U R2 U2

U' R U R' U R U2 R' //
R U2 R2 U2 R2 U2 R //
U2 R U R' U R2 U2 R2 U2 R2 U R U' R' U' //
// 30 (25 with cancels)

Number of algs: Few
Number of moves: Few
Number of issues: Few
Number of how-cool-it-is: High
 
How about this method?


yes!

this is what I was talking about in my original reply (except for using S moves as you did in one of your example solve)

you may want to have a look at the second half of this method

a beginner version of this method would be to simply do CO and then EP


also, check out this method where I use 2-gen CO, then DR and then HTO reduction (and it has variants where CP and EO are done first/early)
 
Last edited:
How about this method?

R2 U' R' U2 R2 U2 R2 U R' U' R2 U2 R U R' U' R U2 R' U' R' U R' U2 R

U R U2 R2 U R' //
U' R2 U' R2 //
U R U2 R2 U2 R2 U2 R //
R U R U R' U' R' U' R' //
// 27

R' U2 R U R2 U R2 U2 R2 U2 R U' R' U R2 U R2 U2 R2 U' R2 U R2 U R'

R U2 R2 U' R U' R' //
U R2 U R2 //
U' R U R' U' R' U' R' U //
S' U2 S U2 R U2 //
// 26

R' U R U R U R' U R' U R2 U R' U2 R U R2 U R2 U' R U2 R' U2 R

U2 R U2 R' U2 R //
U' R2 U R2 //
U' R' U2 R U2 R2 U2 R2 U2 R U2 R //
U R' U' R U R U R U' R' U' //
// 33

U' R U' R2 U2 R' U2 R' U2 R2 U2 R2 U R' U2 R' U2 R' U' R U' R' U R2 U2

U' R U R' U R U2 R' //
R U2 R2 U2 R2 U2 R //
U2 R U R' U R2 U2 R2 U2 R2 U R U' R' U' //
// 30 (25 with cancels)

Number of algs: Few
Number of moves: Few
Number of issues: Few
Number of how-cool-it-is: High
This is definitely not few algs! XD
RU comms are certainly unintuitive enough to call them algs; especially when I’m considering even 3style as an algorithmic approach.
Really cool method though!
CO>absoluteCP>2-3EPalgs
 
This is definitely not few algs! XD
RU comms are certainly unintuitive enough to call them algs; especially when I’m considering even 3style as an algorithmic approach.
Really cool method though!
CO>absoluteCP>2-3EPalgs

Oh no, there are actually not very many algorithms, I'm serious! (Definitely less than 20 are needed!)
I assume this is why it has "few" issues and not "no" issues.

Well, S' moves are actually incredibly fast OH (for me, about as fast or even faster than a U2 spin), which I think Devagio is trying to make this for(?)
Plus, it's not bad that I go out of the 2-gen moveset for literally 2-3 moves. It's not like there's a rule that says you can't do this, and as I said, S' moves are speedy (try it!). And, the biggest thing is, doing R U R2 U' R' U' R' U2 R U' instead of simply S' U2 S is just kind of stupid lol
--------------------

The method steps, by the way, are:
Step 1: Orient all corners (preferably in a way that orients the most edges on the second axis).
Step 2: Solve all corners (preferably in a way that solves some edges)
Step 3: Use one edge algorithm to reduce down to 3e, or rarely, only if significantly easier, 2e2e.
Step 4: Apply one last sequence to finish that cube!

The number of algorithms for the first two steps is 0. Orienting corners is intuitive and only requires recognizing a few different cases.
Solving the corners from there takes only 4-5 moves on average and is super fast to execute because you know what to do instantly!

The third step sometimes relies on your arsenal of (R, U) 3e edge algorithms, which honestly doesn't have to be very big at all, I would say you can use this method with proficiency knowing a total of less than 15 algorithms. If you choose to use 2e2e algorithms in this third step, this solving/reduction step, then you're in luck! You don't have to memorize any algorithms, because (R, U) 2e2e algs basically don't exist! What I mean by this is that the optimal solution to any given 2e2e in 2-gen is almost always a set-up to R2 U2 R2 U2 R2 U2. Setting up to that simple 6-mover is legitimately, and when I say this I'm being real, all three- intuitive, fast (because the setups are easy to see), and optimal. So that's nice.

The fourth step is much of the same of the third, except here it is a lot less thinking and intuition, which is a drawback to step 3, but it is pretty easy to see where pieces need to go, so it's really only barely a drawback. anyway, in this fourth and final step, you simply just solve the case that you see. It's just like solving OLL or something, you simply look and spam your algorithm. If you only know a couple of 2-gen 3e algs then you may have to do one premove beforehand, but this is both much slower, because more thinking is involved, and a little bit more inefficient movecount wise, so just learn a few more 3e algs (again, not that many) and you'll be much better. You'll just spam your 10 move algorithm to finish.

And just a side note, I believe that no matter what your edge cycles are, you will only ever need to do 2 algorithms of 3e and 2e2e to solve all edges.
For example, if you have 4e2e, swap the 2e and any other 2 edges with a 2e2e to reduce to just 3e remaining. For 5e, two 3e's can be used.
And if you have all 7 edges messed up, which means you sadly didn't solve any of the edges during the corners stage, which you should be trying to do... But if your cycles are 3e2e2e, then it's pretty obvious you can still manage to solve it in 2 algs :)

The average movecount of this method is actually less than doing SQ->F2L->2GLL, so this method is pretty efficient.
Now this is all for now! I might, and probably will, make a little list of some useful 2-gen 3e algs later and edit it in, but for now this is it!
 
Last edited:
Oh no, there are actually not very many algorithms, I'm serious! (Definitely less than 20 are needed!)


Well, S' moves are actually incredibly fast OH (for me, about as fast or even faster than a U2 spin), which I think Devagio is trying to make this for(?)
Plus, it's not bad that I go out of the 2-gen moveset for literally 2-3 moves. It's not like there's a rule that says you can't do this, and as I said, S' moves are speedy (try it!). And, the biggest thing is, doing R U R2 U' R' U' R' U2 R U' instead of simply S' U2 S is just kind of stupid lol
--------------------

The method steps, by the way, are:
Step 1: Orient all corners (preferably in a way that orients the most edges on the second axis (which is just putting e-layer edges in the e-layer)).
Step 2: Solve all corners (preferably in a way that solves the most edges (for example, U2 R2 U R2 instead of R2 U2 R2 U' R2))
Step 3: Use one edge algorithm to reduce down to 3e, or rarely, only if significantly easier, 2e2e.
Step 4: Apply one last sequence to finish that cube!

The number of algorithms for the first two steps is 0. Orienting corners is intuitive and only requires recognizing a few different cases.
Solving the corners from there takes only 4 moves on average and is super fast to execute because you know what to do instantly!

The third step sometimes relies on your arsenal of (R, U) 3e edge algorithms, which honestly doesn't have to be very big at all, I would say you can use this method with proficiency knowing a total of less than 15 algorithms. If you choose to use 2e2e algorithms in this third step, this solving/reduction step, then you're in luck! You don't have to memorize any algorithms, because (R, U) 2e2e algs basically don't exist! What I mean by this is that the optimal solution to any given 2e2e in 2-gen is almost always a set-up to R2 U2 R2 U2 R2 U2. Setting up to that simple 6-mover is legitimately, and when I say this I'm being real, all three- intuitive, fast (because the setups are easy to see), and optimal. So that's nice.

The fourth step is much of the same of the third, except here it is a lot less thinking and intuition, which is a drawback to step 3, but it is pretty easy to see where pieces need to go, so it's really only barely a drawback. anyway, in this fourth and final step, you simply just solve the case that you see. It's just like solving OLL or something, you simply look and spam your algorithm. If you only know a couple of 2-gen 3e algs then you may have to do one premove beforehand, but this is both much slower, because more thinking is involved, and a little bit more inefficient movecount wise, so just learn a few more 3e algs (again, not that many) and you'll be much better. You'll just spam your 10 move algorithm to finish.

And just a side note, I believe that no matter what your edge cycles are, you will only ever need to do 2 algorithms of 3e and 2e2e to solve all edges.
For example, if you have 4e2e, swap the 2e and any other 2 edges with a 2e2e to reduce to just 3e remaining. For 5e, two 3e's can be used.
And if you have all 7 edges messed up, which means you sadly didn't solve any of the edges during the corners stage, which you should be trying to do... But if your cycles are 3e2e2e, then it's pretty obvious you can still manage to solve it in 2 algs :)

The average movecount of this method is actually less than doing SQ->F2L->2GLL, so this method is pretty efficient.
Now this is all for now! I might, and probably will, make a little list of some useful 2-gen 3e algs later and edit it in, but for now this is it!
I disagree at a couple of places tbh; but I wanna wait till you give a list of cases you think is exhaustive to make the method worth it. 7-cycles are the only places where I see you’d require 3 edge algs, and those I believe will be fairly rare, especially because you’ll almost always be able to influence edges really easily during corner solving.
In all, this looks really solid. Awesome!
 
S' moves are speedy (try it!)
There were five 2GLL cases I use S/S' moves for (I replaced two of them with RUL algs recently, but that's still three RUS cases left), so yeah, I already use S moves lol.
 
Step 1: Orient all corners (preferably in a way that orients the most edges on the second axis (which is just putting e-layer edges in the e-layer)).
Step 2: Solve all corners (preferably in a way that solves some edges (for example, U2 R2 U R2 instead of R2 U2 R2 U' R2))
Step 3: Use one edge algorithm to reduce down to 3e, or rarely, only if significantly easier, 2e2e.
Step 4: Apply one last sequence to finish that cube!

Step 1 is solving the FR and BR edges in the correct layer and simultaneously solve two corners in FRD and BRD so that the sticker colours match or are opposite to all the adjacent face colours.
Step 2 is OCLL (this could be done using only Sune)
Step 3 is intuitive edge solving

So you're basically saying what I said, but with more algorithms lol?
 
Back
Top