#### blah

##### brah

__Note: The contents of this thread have changed a lot over the course of the day because of several miscalculations and a few new ideas that came along the way. If you just want the important stuff in this LL approach, read all the underlined and bolded text in this entire thread__I think I've just had an idea that may very potentially become mainstream in a few months/years

*if it's as impressive as it appears to be*. What do I mean by this? Somehow, I feel that I've missed a point that makes this method as stupid as all the other methods that claim to be able to beat Fridrich, but I can't figure out what that point is, yet. So I'll post it here for someone to find out the flaw

Here's what the method is all about:

**1-Look LL with 108 algorithms**It starts with ZZF2L. There is

*no need for phasing*at the end of F2L. Then you do 1-Look LL. That's all there is to it.

How it works: During LL, 5/6 of the time, you can AUF such that 2 adjacent edges are solved. Why do an extra phasing step?

Simple proof: Let's name the edges 1, 2, 3 and 4 respectively in clockwise order, doesn't matter which edge you start from. Here are all the possible LL edge permutations after F2L:

__1234__,

__12__43,

__1__32

__4__, 1

__34__2, 14

__23__,

**1432***. Need I say more? I'll talk about the 1432 case later on.

So what happens after this? You either get the 1234 case, or 1 of the other 4 cases. If you get the 1234 case, do pure CLL. If you get any of the other 4 cases (I actually just see them as 1 case with 2 adjacent edges solved and the other 2 swapped), do one of the 240 algs.

Actually, there's more. If you don't do LL corner control, you'll end up with 12*9*3 = 324 1LLL cases to memorize. If you do LL corner control with the Winter/Summer Variations to ensure that there's at least 1 corner oriented, you'll end up with 12*20 = 240 1LLL cases to memorize. For the Winter Variation, it's just a matter of choosing between RU'R' and URU2R'. For the Summer Variation, you need to learn 1 more extremely short alg, and choose between that and RUR'.

Oh, and about that 1432 case, you

*can*learn all 167 cases (got this figure from Michal Hordecki) for ZZLL, but I'd just do COLL and EPLL, it only happens 1 in 6 times anyway. And it probably isn't too hard to find a way to detect this at the end of F2L to avoid it once this method gets the recognition and development it needs.

So, anybody found the flaw in this entire proposition yet? If not, I'm gonna start generating algs

Edit: I corrected everything, I originally did a miscalculation and thought only 108 algs were needed. I recalculated and realized that we need 240 algs. But never mind that. This method's still useable, check out the next 2 posts.

Last edited: Jan 20, 2009