New Corner Orientation Method. Serious Speed Method.

[Tim Major]

This is not a joke thread. My idea, while learning WV, was to make a method almost exactly the same as ZB. There are some Major differences though, instead of orienting the edges during Zbf2l, to be the ll face's colour (let's use yellow), you orient the corners.

Lets talk about the movecount for this. It is a bit different to WV, because WV preserves the edges in their current positions. This requires more moves. WV algs are still fairly short, but this will make them much shorter.

It's not just WV though, because you need the other cases as well, whereas this would just be the R U' R' and L' U L cases, or in other words, cases with a pair already made. This is similar in moves to ZBf2l *I think*.

Then the LL. This is where it is superior to ZBLL. The LL requires far fewer algorithms. This is because their are 7 ZBLL OLLs, with their variations to learn, plus PLL, to account for OLL skips, whereas only 3 cases in this to have variations for plus PLL. This will help time for recognition as well.

Another good thing, is it is very easy to recognise the various cases. I cannot explain this, but get out your cube, and you will see how easily recognisable these cases are, compared to ZBLL cases.


Any thoughts? Or smart people with input? Plus, I don't know how to work out how many cases there would be, so could someone with seriously good cubing knowledge please say *cough*cmhardwick*cough*

I'm not dumb, however, I don't want to put a figure to each of these cases that are wrong, as then people will not take this seriously.

I name this the COM method, for Corner Orientation Method (CO would end up with COLL ), as I can't say my real name here

Please take this method seriously, and any flaws you see, and I will stand corrected. This is a way of ZB, with way fewer algorithms, and a much more awesome way of recognition. So if you thought of learning ZB, learn this instead.

Edit:
Breakdown of method.
1. Any method you want up until putting in the final f2l pair.
2. COMf2l. Orienting corners while solving pair.
3. COMLL. Finishing cube.

Edit 2:
Example solve soon to come.
Edit 3: Blah makes me sad.

 

[Hyprul 9-ty2]

Your name is Matt

 

[Faz]

So, you do WV without worrying about the edges.

Then you do something like like ELL, but with oriented corners, and not permuted?

Well there are 29? ELL's, and that would make the total number of algorithms 29 x 6 cp cases which would be 174 algs. Plus regular PLL's would make it 195 algs.

Pretty neat idea, recog would be ok if you are good at ELL recognition.

Also, some algs would be cut out, because of the cases where only the edges are flipped.

 

[4Chan]

Here's an example solve.

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

Cross: L' F' u2 L U B2 u2

F2L-one pair: U2 R U' R2 U R L U2 L' U' R U' R' U L' U2 L2 F' L' F Y'

COMF2L: U' R U2 L' U' L U2 R'

COMLL: L F U F U' L' U2 R' F' R F' U' F2

I'm fast with Cube Explorer.

 

[Tim Major]

So, you do WV without worrying about the edges.

Then you do something like like ELL, but with oriented corners, and not permuted?

Well there are 29? ELL's, and that would make the total number of algorithms 29 x 6 cp cases which would be 174 algs. Plus regular PLL's would make it 195 algs.

Pretty neat idea, recog would be ok if you are good at ELL recognition.

Also, some algs would be cut out, because of the cases where only the edges are flipped.

Yeah, and I'll do an example solve later, to compare it to Fridrich (with my crappy f2l) to show difference between this, Fridrich, and ZB. I'll do example solves with those methods, using cube explorer of course for algs, and then ask someone good at petrus to do the petrus part of the solve. I'll have the same f2l with the Fridrich, ZB, and COM solve. I think this would be around the same as ZB, but after a few example solves, I'll have that cleared out.

 

[qqwref]

I think doing F2L + CO is going to be a lot more algs than F2L + EO. The last layer has only 8 EOs (counting AUF as separate) but 27 COs. F2L + EO (ZBF2L) is already a ton of algs, and it looks like this would be at least twice that, which means it'll probably end up really hard to recognize and deal with. So the LL idea might work well but you are going to be ending up solving last slot with pair edge -> WV -> COMLL, which is still 3 steps, and it probably won't be much faster than normal solving, I could be wrong, but I really think the F2L step is gonna kill you here.

PS: Dudes, this is just a LS+LL method, right? Just use LS+LL scrambles from qqtimer, and then go compare the various methods with that.

 

[Tim Major]

PS: Dudes, this is just a LS+LL method, right? Just use LS+LL scrambles from qqtimer, and then go compare the various methods with that.

Thanks. That'll save alot of time.

And about the rest. I'll try to think of something. Maybe the people who made ZB already thought of this, and already realised this. However, there must be a way around it. Somehow...

 

[4Chan]

I know that this is going to take a ridiculous amount to time to generate the algorithms.

Manyyyyy hours if you use cube explorer.
Good luck, if you're going to do this, it's going to take a while.
Making algs is slowww work. (x

 

[Tim Major]

I know that this is going to take a ridiculous amount to time to generate the algorithms.

Manyyyyy hours if you use cube explorer.
Good luck, if you're going to do this, it's going to take a while.
Making algs is slowww work. (x

I'm a-gonna learn OLL first. Then WV. Then R U R' WV. Then start generate algs. In the mean time, I have to learn square-1 algs, 4x4 parity algs, and 2x2 algs. Plus maybe pyra algs, for a thread I posted a while ago.

 

[Faz]

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

x2 y R' D' r' U r L u' R

U' L' U' L U' L' U L
U' R' U' R F R' F' R
L U2 L' U L U L'
COMF2L: y R U' R' U2 R U R2 F R F' U R U' R' U R U2 R' (made up)
COMLL: U2 y F B U2 R U2 R' U2 F' B D L2 D' B2 U

I can't really use cube explorer's optimal algorithm search, so it gives me a 14 move algorithms for COMLL

 

[Faz]

Oh, I see, you aren't doing WV. Well, if you don't use WV it will be alot of algorithms.

 

[Tim Major]

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

x2 y R' D' r' U r L u' R

U' L' U' L U' L' U L
U' R' U' R F R' F' R
L U2 L' U L U L'
COMF2L: y R U' R' U2 R U R2 F R F' U R U' R' U R U2 R' (made up)
COMLL: U2 y F B U2 R U2 R' U2 F' B D L2 D' B2 U

I can't really use cube explorer's optimal algorithm search, so it gives me a 14 move algorithms for COMLL

That could be shortened a lot.
So that isn't optimal? If not, it would only be a few moves less. So this method had potential, considering the cross and first 3 slots, are 31 moves, which isn't the best, although it wasn't the best scramble for that cross's f2l. I think a much more accurate way would be using QQ's suggestion, of LS+LL, for the 3 different methods.

I just tried using Cube Solver to find that, and it gave me B2 D2 U2 B2 F2 D2 U2 F2. LOL!

 

[4Chan]

I just figured out a system for recognition.

In ZBLL, with Dan/Jason system, it's super easy.
You could adapt the system for this method as well, but you'd track pieces in lieu of stickers.
You would only have to look at 2 pieces to know the permutation.
You just have to look at orientation afterwards.

Just like how ZBLL looks at the COLL case, and then the 2 stickers on FU and RU to instantly know the case.

Like, UR moves to UB and UF is correct is enough to know the LL case.
Because they're unique to each case in the subset.
As long as you identify the corner perm case first.

 

[Faz]

Well, all in all, it's interesting, but the movecount doesn't seem to be that different from fridrich, and with the massively high number of algs, and tricky recognition, and non fingertricky algs, I don't think anyone will want to learn all of the algorithms.

It's ok, but I doubt it will ever be faster than fridrich.

 

[blah]

I might have made some major mistake somewhere, so if someone finds it, please feel free to correct me, but for now...

Each of these 6 LS cases have 8 different COMLS cases that follow, thanks to an amazing technique called AUF:

The other 36 LS cases have 27 COMLS cases each.

That's 6*8+36*27 = 1020 COMLS cases. If you can really learn this many algs, you might as well go for 1LLL. Seriously.

And 1020 is just COMLS - we're not even at COMLL yet.

----------

The only reason this idea has never been mentioned is because most people who have come up with it have probably got these figures themselves. I had this idea about a year ago, which is exactly what qqwref said.

 

[4Chan]

I can't seem to think clearly about COMLL.
Due to... circumstances... my thinking isnt what it used to be.

Blah, can you make an estimation?

 

[Tim Major]

Wow, thanks blah. Maybe it would be better to just use the 27 WV, and 26 (I think) R U R' algs.

LL still looks good though.

 

[blah]

Well, all in all, it's interesting, but the movecount doesn't seem to be that different from fridrich, and with the massively high number of algs, and tricky recognition, and non fingertricky algs, I don't think anyone will want to learn all of the algorithms.

It's ok, but I doubt it will ever be faster than fridrich.

Okay, but why would the movecount be so bad. That solution you had, didn't have the best f2l, so I think it would be better to just use the LS+LL. I don't understand why it would have such a large movecount. Using algs that can affect edges, but hmmm. It seems much better than ZB, but I hadn't tested it too much. I'll have to download cube explorer, and do some LS+LL tonight. I don't understand why the movecount for COMf2l would be so high. The only problem is that COMf2l is a slight bit harder to recognise than ZBf2l, but the LL would be far easier.

I'll do 5 example LS+LL tonight.

Edit: Wow, thanks blah. Maybe it would be better to just use the 27 WV, and 26 (I think) R U R' algs.

LL still looks good though.

Dude you still don't get it. Read my thread. Seriously.

LS + OLL + PLL = 3 steps = 119 algs
LS setup + WV + COMLL = 3 steps = more than 300 algs + harder recognition = what's the point?

See it now?

 

[blah]

I can't seem to think clearly about COMLL.
Due to... circumstances... my thinking isnt what it used to be.

Blah, can you make an estimation?

Are you stoned?

Not considering symmetries but considering AUF-reduction, 4*3*2*8*6/4 = 288 cases. My guess is that even with symmetry-reduction, it'll still be well over 200.

 

[aronpm]

Or you could solve the last slot and the last layer all in one algorithm.