# BLL 3-Look 25alg



## Dane man (May 30, 2014)

*BLL 3-Look 24alg*

This is a 3-Look LL method designed for efficient solving with few algs to memorize. While this isn't a speedsolving method, and isn't recommended for competitions, it is however good for intermediate cubers who want to improve their times to around if not under 30 seconds (depending of course on the F2L and finger-trick fluency). This was posted in the new methods thread, and having received a few responses, and modifications having been made, I present it here.



Spoiler: The history leading up to this method



I first got a cube when I was 5. I loved it, but couldn’t even solve one side for a while. But I was determined. So I eventually learned to get a side, and I was satisfied. Whenever the cube got mixed, I would use the famous “Rob’s Rubix Repair” from over 12 years ago (found here). That is until I turned 11. I then wanted to know how to solve it myself, and after quite some time and determination, I figured out the basics of F2L, and I found the following method for LL.

*BLL Super-Beginner Method*

This method provided only the necessities for solving the last layer by combining the algorithms in logical ways (no recog, just cog).


Spoiler



-Edges (orient first, then permute)-
Flip the front and left edges (orientation):
M’ U’ M U2 M’ U’ M

Trade the front and right edges (permuting):
U [R U R’ U R U2 R’](bracketed part will be used in corners as well)

-Corners (permute first, then orient)-
Trade the front left, front right, and back left in a clockwise manner (permuting):
R’ U L U’ R U L’ U’

Rotate the front left and back left corners outward from the inside (orienting):
[R U R’ U R U2 R’] + [L’ U’ L U’ L’ U2 L](mirror of the bracketed alg)



Sometimes the method would be anywhere from 2-Look to a frustrating 8-Look, but on average it was 4-5 Look. Though, that served me well for a while (and to this day, I can still get good sub-50 times with it), but it wasn’t enough, having watched Dan Knights solve the cube in 22-ish seconds every time. So I thought harder. And maintaining 3 of the above algorithms, I came up with this:

*BLL 4LLL Method*

This method is the evolution of the first method. By adding a few algorithms to the edges and corners, the method was constrained to 4-Looks or less, with a good chance (5/16) of skipping one or both edge steps, making it 3 step 4/16 of the time, and two step 1/16 the time (already solved to begin). Take a look:

-Edges- (Just enough algs to reduce the edge steps to at most 2 when used wisely)


Spoiler



Front and right edges. (3 algs) 
(_F_ = flip, _S_ = switch(trade), _SF_ = switch-flip)

_F_
R' F R U2 F' U' F' U F2 U2 F'

_S_
U [R U R’ U R U 2 R’](bracketed part will be used in corners as well)

_SF_
F2 R U R2 F R F’ U L F L’ U2 F2

Opposite edges (1 alg)
_SF_
R U' R' F' U F R U R2 F R F'


-Corners (same algs from full BLL)-


Spoiler



Corner Orientation algs:

Based on the orientation of the LL color faces. x means it's correctly oriented. (6 algs)

```
_
|
|   _
```
F U R' U' R2 U' R2 U2 R U2 R U R' F' 


```
_  _

_  _
```
R B' R B R2 F R' F' R F' U2 F U2


```
_
x
_   |
```
R' U L U' R U L' U'


```
_
    x
|   _
```
L U' R' U L' U' R U (Simply a mirror of the above. Also, can be solved by using the above algorithm twice after U')


```
_
    x
_   x
```
R U R' U R U2 R' (then mirror it) L' U' L U' L' U2 L


```
x  |
x  |
```
(The same as above, simply perform a Z' reorientation first. Or if you're talented with the down layer: D R D' R D R2 D' (then mirror) U' R' U R' U' R2 U making 25 algs in total)


```
_
x
|  x
```
L' U' L' U R U' L U R' L (These last two moves can be replaced with a slice move, or the last three with an odd finger-trick)


Corner Permutation algs:

(4 algs)

Three-corner trade clock-wise (the three corners are the two back corners and the front right corner)
(X) R' U R' D2 R U' R' D2 R2 (X’) (or if you don't want to reorient and can do the Front and Back layers well enough: R' F R' B2 R F' R' B2 R2)

Three-corner trade counter-clockwise
(X) R2 D2 R U R' D2 R U' R (X') (literally just backwards of the first one. Without reorientation: R2 B2 R F R' B2 R F' R)

Front to back (and vice-versa)
{U} R2' U R' d' R U R' U' R U R' U' R U R' F U' F2 

Cross (front right trading to back left, and front left trading to back right. Equal to trading all edge pieces to opposite sides.)
L2 R2' U L2 R2' U2 L2 R2' U L2 R2' (I recommend that this be modified with slice moves to: M2 U M2 U2 M2 U M2)


This method proved to quickly bring me sub-40 times consistently, even though I hadn’t yet trained my F2L for optimization. And thanks to the great luck in the skipping department, I got some 35 second times, and sometimes faster. I once even got a 25.5 time using this method.

But still, I wasn’t averaging sub-30. So I went on to learn intuitive F2L, and to create the BLL method presented here.


I was working on the creation of a method a a few years ago, that reduced the LL solve to 3 steps or less, using only 24 algorithms for memorization. Though certain recognition steps might require more time to get used to, they should bring major benefits to cubers trying to get below 30sec.

After developing the method, and memorizing only the few parts of it that I found easiest and most important to apply, I had shaved my time down from 50-55 sec to 35-40sec. That's a good 15 seconds difference with only half of the method in use.

The theory behind the method is that the edge orientation and permutation could be done in one step with very few algs required for memorization (15 in total). The corners are done in two steps, orientation (6 algs (5 excluding reuses of an edge alg)) and permutation (4 algs).

Putting together this method, I was looking at all the possible combinations of LL positions with respect to the edges, then corners, and finding one effective algorithm for each of them. The algorithms I chose for each situation were chosen because of the possible speed achievable with them, and not because of the number of moves (meaning that if an 11 move algorithm's time was able to be reduced effectively enough with the simplest/quickest finger-tricks as opposed to an 8 move algorithm that could not, then the 11 move algorithm was chosen). Any redundant position solves (mirrors, rotations, reversed order of effects, and even cube orientations) have been discarded, requiring that recognition be more specific no matter the LL rotation; also because of this, a quick rotation of the last layer may be required (or removed from the first step) before beginning an edge algorithm, and a cube reorientation might be required before a corner orientation. You can also perform a simple cube reorientation before any algorithm if you feel your finger-tricks will be more optimal with certain sides. I encourage the exploration of possible new finger-tricks (for example U R' L can be done with one swift movement holding the U side by it's edges).

I will put the algorithms here, but I do not yet have a clean way of presenting exactly what they do, which I am working on getting images for and will add in an edit soon. In the meantime, you can experiment to see what each one does.

_A bracketed {U} move at the beginning of some algorithms is left for a more organized understanding of what the algorithm does. These can (and should) be excluded when the orientation of the U layer is appropriate._


Spoiler: Edge algs



(_F_ = flip, _S_ = switch(trade), _SF_ = switch-flip)
Opposite two-edge combos. (8 algs) 
(_front and right edges - back and left edges_)

_F-Ø_
R' F R U2 F' U' F' U F2 U2 F'

_S-Ø_
{U} <apply the first half of the 5th case corner orientation algorithm: R U R' U R U2 R' as seen below>

_SF-Ø_
F2 R U R2 F R F’ U L F L’ U2 F2

_SF-S_
F R U R' U' F2 L' U' L U F

_SF-SF_ (you can choose, I found both to be equally effective)
1 - R' F R F' U2 R' F R F2 U2 F
2 - F R' F' R U2 F R' F' R2 U2 R'

_F-F_
R U B' U' R' U R B2 U B' U' R'

_S-F_
F U2 F' U2 F' L F L'

_SF-F_
{U} L' B L B' U2 B' U R' U R B

_S-S_ (Equal to opposite edges being switched, just rotate once)
R U R' U' R' F R2 U' R' U' R U R' F'

Opposite edge combos (2 algs)
(_front and back edges_)

_F_
F U F' U F U' R U' R' F'

_SF_
R U' R' F' U F R U R2 F R F'

_S_ (see _S-S_ in Opposite two-edge combos)

Merges (5 algs)
(_front and right edges - right and back edges_)

_SF-S_
{U'} R U B U' B' R'

_F-S_
{U} F' U' L' U L F

_S-SF_
R' U' R U R B' R' B

_F-SF_
F' L' U' L U F

_S-F_
{U} B U B' U' B' R B R'





Spoiler: Corner Orientation algs



Based on the orientation of the LL color faces. x means it's correctly oriented. (6 algs (5 excluding reuse))

```
_
|
|   _
```
F U R' U' R2 U' R2 U2 R U2 R U R' F' 


```
_  _

_  _
```
R B' R B R2 F R' F' R F' U2 F

```
_
x
_   |
```
R' U L U' R U L'

```
_
    x
|   _
```
L U' R' U L' U' R (Simply a mirror of the above. Also, can be solved by using the above algorithm twice after doing a U' turn)

```
_
    x
_   x
```
R U R' U R U2 R' (then mirror it) L' U' L U' L' U2 L


```
x  |
x  |
```
(The same as above, simply perform a Z' reorientation first. Or if you're talented with the down layer: D R D' R D R2 D' making 26 algs in total)

```
_
x
|  x
```
L' U' L' U R U' L U R' L (These last two moves can be replaced with a slice move, or the last three with an odd finger-trick)





Spoiler: Corner Permutation algs



(4 algs)

Three-corner trade clock-wise (the three corners are the two back corners and the front right corner)
(X) R' U R' D2 R U' R' D2 R2 (X’) (or if you don't want to reorient and can do the Front and Back layers well enough: R' F R' B2 R F' R' B2 R2)

Three-corner trade counter-clockwise
(X) R2 D2 R U R' D2 R U' R (X') (literally just backwards of the first one. Without reorientation: R2 B2 R F R' B2 R F' R)

Left to right (and vice-versa)
R2' U R' d' R U R' U' R U R' U' R U R' F U' F2 

Cross (front right trading to back left, and front left trading to back right. Equal to trading all edge pieces to opposite sides.)
L2 R2' U L2 R2' U2 L2 R2' U L2 R2' (I recommend that this be modified with slice moves to: M2 U M2 U2 M2 U M2)



This method isn't designed to be a professional/competition solving speed method, but is simply meant to be a method for beginner-intermediate cubers to be able to get almost 30 second times (if not faster) using only a small handful of algorithms. It also isn't designed to be a static orientation method, though it can be adapted to that if your fingers are talented enough, and that does shave many precious seconds off. This method is meant to be adapted to the needs and the skill of the cuber using it, so any use of reorientation, finger-tricks, and solve recognition methods are up to the cuber.

As opposed to other methods I looked at the cases and algorithms required in other combinations. Specifically the following cases:
*-Common method 1*: OLL(avg moves 10)+PLL(avg moves 12) = 57+21 = *78 algorithms (avg moves 22)*.
*-Common method 2*: CLL(avg moves 10)+ELL(avg moves 11) = 42+29 = *71 algorithms (avg moves 21)*. Out of the question for my goal of few algorithms.
*-Common 3step/3-Look method*: 2-Look OLL(avg moves 6+8)+PLL(avg moves 12) = 3+7+21 = *31 algorithms (avg moves 26)*. Good, but still too many algorithms (21) requiring very difficult recognition techniques. The recognition skill required for the final step to be effective serves as an impediment to speed and simplicity of learning and executing the method.
*-This method*: LLEF(avg moves 8)+OCLL-EPP(avg moves 10)+CPLL(avg moves 9) = 15+5+4 = *24 algorithms (avg moves 27)* with only a 6 move difference from CLL+ELL, and there are only 5-10 cases requiring a somewhat tricky recognition stage (the edge "merges").

So at the sacrifice of 6 extra moves (let's say it takes about two seconds to do that, to be modest) and one extra (and simple) recognition pause (lets also say about two seconds), _we're talking about a 4 second difference_ between CLL+ELL and this method. So in terms of simplicity and benefit, this is, theoretically, a very effective method to achieve fast times.

Now, while it's nothing compared to the ZZ and Roux methods (for obvious reasons), it can be adapted to be used with the ZZ F2L (if you're into frankensteining things), and because of the initial edge orientation from ZZ, the LLEF is reduced to 2 algorithms, making 11 algs in total for a 3-Look last layer. In order to maintain the consistency of ZZ in not using the F and B sides, the algorithms can be traded to those of your own making should you so desire. This method, after all, isn't about the algorithms used, but simply the efficient order of operations.

Right now, I'm looking at the possibilities of a 2LLL based on this origin point. There is the obvious L4C step (combining the two corner steps into one) with 84 algs, making a 99 alg 2LLL method. Mixing any steps between edges and corners (ex: Solve edges and Orient Corners, or solve edges and permute corners) requires massive amounts of algorithms due to the possible rotations of each relative to each other (E+CO = 360 algs?, E+CP = 240? unless of course some of the case I'm thinking are nonexistent, which I both doubt and don't have the drive to go and find out). So in looking to create a 2LLL method using Edges First as a base, while it is possible to do, requires at least 99 algs for memorization and becomes an unrealistic 74 alg step up from the 25 algs for 3LLL.

But what if the F2L already oriented the edges?
Well then. We would have an E+CO of 48 algs (8 of which are already known), added to the 4 CP algs, which makes a 52 alg 2LLL with only a 40 alg learning curve. We could also perform an E+CP of 32 algs (6 of which are already memorized), added to 7 Corner orientation algs (between 2-5 of the current algs might need replaced with algs that respect permutation) for a 2LLL of only 39 algs, with a 26 alg learning curve. Compared to OCLL/PLL (28 algs), it could be worth it to just learn OCLL/PLL instead. But at the same time, it's still better than the 44 alg COLL/EPLL.

All in all, these are the possibilities.

Questions? Comments? Critique? Unfunny jokes?


----------



## TheNextFeliks (May 30, 2014)

Okso 2 Look OLL is 6+8 = 14. 
If you don't count solved as a "case" it is 8+9. You're calculations are off. 

I really hate algs that only affect corners for the most part. Most are pretty ugly (though some exceptions).


----------



## Dane man (May 30, 2014)

TheNextFeliks said:


> Okso 2 Look OLL is 6+8 = 14.
> If you don't count solved as a "case" it is 8+9. You're calculations are off.
> 
> I really hate algs that only affect corners for the most part. Most are pretty ugly (though some exceptions).



Thanks for that, I had somehow traded number of algorithms and number of moves, and gotten them both wrong.


----------



## Filipe Teixeira (May 31, 2014)

I like the algorithm for the Pi case as a COLL but for just orienting the corners I suggest R U2 R2 U' R2 U' R2 U2 R or even f R U R' U' f' F R U R' U' F'

I don't know why someone would switch from a 31 algs system with good recognition to a 25 algs system with bad recognition.


----------



## Rocky0701 (May 31, 2014)

filipemtx said:


> I like the algorithm for the Pi case as a COLL but for just orienting the corners I suggest R U2 R2 U' R2 U' R2 U2 R or even f R U R' U' f' F R U R' U' F'
> 
> I don't know why someone would switch from a 31 algs system with good recognition to a 25 algs system with bad recognition.


Or16 for 4LLL which would probably have better recognition and shorter algs. It is always awesome to see new substeps and methods being created however. Great job developing it!


----------



## 10461394944000 (May 31, 2014)

but you don't use any of these algs in standard cfop LL, so instead of needing to learn a few plls to go from 4LLL to 3LLL, you have to learn 3 new sets of algs that probably suck and a new recognition system for the first step

no thanks


----------



## elrog (Jun 1, 2014)

If you learn optimal algorithms it would be a good step up to optimal LLEF and L4C which is good for FMC.


----------



## Dane man (Jun 3, 2014)

I never meant this method to be a replacement. And while the recog for the 21 cases in the classic 3LLL is simpler, it's still 21 cases that are just as difficult if not more so than the 15 cases found here because the 15 cases focus only on the edges while the 21 PLLs focus on all pieces of the last layer. You'd have to learn and get used to both to really compare, but for now the recog seems pretty equal in terms of difficulty.

Thanks Rocky0701. 

I note again that the algs used are not important. It's the method in general and the possibilities of it's use.

As for the transitioning from CFOP 4LLL, that is a valid point that the classic 3LLL is simpler to learn if you use the CFOP 4LLL method (which I never used), but a the same time, the transition from the classic 3LLL to CLL/ELL is a complete replacement of the system. And the situation is the same for this method for _both_ transitions. But we can still consider the effectiveness of this method regardless of what it takes to learn it from different starting methods.

And I like the idea of optimal moves for this method being used in FMC. I'll look into checkin out an optimal move version of the algs. Thanks for the idea.

And I would appreciate it if the analysis here could be purely objective and present logic and reasons, to help develop the possibilities of the method, and not simply "prob sucks", "has bad recog"(without saying why you think so), "i don't want to learn it", etc. The method is presented for learning purposes and hopefully to spark creativity in method development, and not because I think it's the best method ever and should replace what you've got. It's simply another method to consider. No need to attack it. :confused:

Anyone else have cool ideas on this method?


----------



## ryanj92 (Jun 3, 2014)

For the fourth CO algorithm, I'd recommend doing the case from a y2: R U' L' U R' U' L
(U moves generally don't need to be added at the end of algorithms)


----------



## Dane man (Jun 3, 2014)

ryanj92 said:


> (U moves generally don't need to be added at the end of algorithms)


Oh, very true. I overlooked that  Silly me.



ryanj92 said:


> For the fourth CO algorithm, I'd recommend doing the case from a y2: R U' L' U R' U' L


That helps a lot for those of us who mostly do finger-tricks with the right hand.


----------



## goodatthis (Jun 3, 2014)

Honestly, it's a great idea, and it works, and some people may adopt it, but part of the appeal of OLL/PLL, if not CFOP in general, is that it's very modular. From the beginners method, you should know about 4-6 LL algs or so. (L EO, line EO, Sune, AS, U perm, A perm) Then it is usually expanded into 2 Look OLL, which is another 5 algs (I think?), then 2 Look PLL, which is another 3-5 algs, then to One look PLL, it's another 15 algs, since you should know the others, and a lot of them you can learn in groups, like F, T, and J perms, or Ra+Rb, you get the idea. So in the end, to go from 4LLL to 3LLL, you only really need to learn 15 algs. And I just don't see this kind of modularity with your method.

In the end, no one is going to learn your algs as their beginners method, so we'll take that off the table. So basically, to go from beginners method Universal LL to yours, it's 25 algs, since you don't know any beforehand. To go from ULL to 3LLL with OLL/PLL, it's about the same, but there's more stepping stones, and recognition is much easier.

So basically, since this is not meant as a replacement, you wind up using about the same number of algs either way.

But don't take this the wrong way- we need people that come up with these things, because there are people who use it. I'm sure LPEOLL and 2GLL weren't the most popular, but there are still people who use it.


----------



## Dane man (Jun 3, 2014)

goodatthis said:


> So basically, to go from beginners method Universal LL to yours, it's 25 algs, since you don't know any beforehand. To go from ULL to 3LLL with OLL/PLL, it's about the same, but there's more stepping stones, and recognition is much easier.


Strangely, the beginner method for 4LLL that I learned isn't the ULL that we know (CO-CP-EO-EP or 2LOLL-2LPLL), but was instead EP-EO-CO-CP (also another of my homemade methods, maybe I'll post it here as well. An older version I made was CP(algs)-CO(algs) which takes a variable number of looks to solve depending on the scramble), and many of the algorithms in that beginner method have been included in this 3LLL method (14 to be exact), making it only an 11 alg step up from where I began. I didn't really have experience in the speedsolving world to start from (and I kinda take pride in not copying someone else's solution to a puzzle), so I had to make it up as I went (starting with edges then doing corners), and I ended up here.

Maybe I'll post my beginner 4LLL and/or my super-beginner 4 alg last layer with variable looks that I started solving with.

-------------
EDIT: Added to the OP


----------



## Adrian Currier (Jun 3, 2014)

Interesting. If you use ZZ (which sets up the cube to have edges already oriented upon completion of F2L), then you can skip the edge part of your approach. A variant on ZZ uses phasing, which permutes 2 or 4 LL edges. It's meant to reduce 1LLL cases, but I've *proposed* using it to reduce PLL cases to as few as 4 compared to 21 (with 1 alg needed to swap opposite edges in some cases to finish phasing). In the end, it reduces memorization to the following: 1 swap alg (1/2 chance of needing it), 7 OLLs that preserve edges (3 already commonly do), and 4 PLLs (Aa/b, E, H).


----------



## Dane man (Jun 6, 2014)

Adrian Currier said:


> Interesting. If you use ZZ (which sets up the cube to have edges already oriented upon completion of F2L), then you can skip the edge part of your approach. A variant on ZZ uses phasing, which permutes 2 or 4 LL edges. It's meant to reduce 1LLL cases, but I've *proposed* using it to reduce PLL cases to as few as 4 compared to 21 (with 1 alg needed to swap opposite edges in some cases to finish phasing). In the end, it reduces memorization to the following: 1 swap alg (1/2 chance of needing it), 7 OLLs that preserve edges (3 already commonly do), and 4 PLLs (Aa/b, E, H).



I'd like to see a fuller description and algs for that, especially the phasing step of the solve. Sounds like it as potential. 

Though this thread has a method already, and other methods mentioned here should be used for comparison against the first.


----------



## Adrian Currier (Jun 6, 2014)

*phasing explained*



Dane man said:


> I'd like to see a fuller description and algs for that, especially the phasing step of the solve. Sounds like it as potential.
> 
> Though this thread has a method already, and other methods mentioned here should be used for comparison against the first.



Phasing can be applied quite easily (and is relevant to the original post method, I think) and basically consists of setting two opposite edges opposite each other when inserting your last block pair in F2L. But here's a fuller description: http://www.speedsolving.com/forum/showthread.php?14501-Phasing-Explained-(ZZ-b)

P.S. more on my specific method is here: http://www.reddit.com/r/Cubers/comments/268zl2/phasing_and_pll/


----------



## Shiv3r (May 27, 2016)

> But what if the F2L already oriented the edges?
> Well then. We would have an E+CO of 48 algs (8 of which are already known), added to the 4 CP algs, which makes a 52 alg 2LLL with only a 40 alg learning curve. We could also perform an E+CP of 32 algs (6 of which are already memorized), added to 7 Corner orientation algs (between 2-5 of the current algs might need replaced with algs that respect permutation) for a 2LLL of only 39 algs, with a 26 alg learning curve. Compared to OCLL/PLL (28 algs), it could be worth it to just learn OCLL/PLL instead. But at the same time, it's still better than the 44 alg COLL/EPLL.
> 
> All in all, these are the possibilities.
> ...



what would the algorithms be? this would be Awesome to do.


----------



## xyzzy (May 27, 2016)

Shiv3r said:


> what would the algorithms be? this would be Awesome to do.



The first one, E+CO, is also known as OCELL.

The second one, E+CP, ends with pure CO and has an overall higher move count (21.55) than OCLL/PLL (19.13), LLEF/L4C (19.61), OLL/PLL (20.43), and even permute first/pure OLL (20.90). E+CP itself has a few nice algs (e.g. L' R U R' U' L U2 R U2 R' for the R perm case), but it's not sufficiently nice to make up for pure CO being awful.


----------



## Shiv3r (May 27, 2016)

Hey, So based on how I learned F2L, I thought of a way to teach newbs how to solve the cube. Its nice because It can be really fast. My sub-15 friend tried it and first try got 16 seconds. Its just a really easy and algorithm efficient way of solving f2L, and for beginners I'm thinking of teaching them BLL.


----------

