# K4



## Kirjava (Mar 4, 2010)

*OMG ITS HERE*

So I've been working on this on and off for a few weeks now.

Basically, this is the third revision of the site. I've learnt a lot of neat tricks since I made the last one, and picked up some nice techniques. I looked at the old site a while back and just decided to completely redo it from scratch.

I tried to provide extensive details about what I do when solving, but it's quite hard to describe accuratly. I threw out all the waffle and documented all the quirks I found while I made this fun journey. The ELL page is particularly extensive.

I also (hopefully) addressed the interface issues people were having (Pochmann), and decked it out in sexy black.

So here are the fruits of my labour. Enjoy.


----------



## Cyrus C. (Mar 4, 2010)

This makes me want to learn K4, & since Redux + Petrus doesn't work very well, I think I'm gonna switch.


----------



## Truncator (Mar 4, 2010)

Now I can finally learn ELL. Thanks a bunch


----------



## Cyrus C. (Mar 4, 2010)

On step 6 you say solve them with CLL, wouldn't this destroy some of the F3L? Or was it just a typo?


----------



## Escher (Mar 4, 2010)

Cyrus C. said:


> On step 6 you say solve them with CLL, wouldn't this destroy some of the F3L? Or was it just a typo?



CLL = Corners of the Last Layer 

He didn't mean '2x2 CLL'.


----------



## Cyrus C. (Mar 4, 2010)

Escher said:


> Cyrus C. said:
> 
> 
> > On step 6 you say solve them with CLL, wouldn't this destroy some of the F3L? Or was it just a typo?
> ...



Ah.


----------



## waffle=ijm (Mar 4, 2010)

OMGPICTURES


----------



## ~Phoenix Death~ (Mar 4, 2010)

Nice well put. Got more algs to learn


----------



## Parity (Mar 4, 2010)

Man not a video.


----------



## dannyz0r (Mar 4, 2010)

Parity said:


> Man not a video.



Wow you really are lazy as hell.


----------



## Parity (Mar 4, 2010)

dannyz0r said:


> Parity said:
> 
> 
> > Man not a video.
> ...



Nope just the way I learn.


----------



## DavidWoner (Mar 4, 2010)

I know its basically the same thing but underneath lrD2l'r'UlrD2l'r'U' could you also add Rw2' F2 Rw2 U' Rw2 F2 Rw2 U' and the (Rw2 B2 Rw2 U)*2 alg for the mirror? Plz?


----------



## reThinking the Cube (Mar 4, 2010)

DavidWoner said:


> I know its basically the same thing but underneath lrD2l'r'UlrD2l'r'U' could you also add Rw2' F2 Rw2 U' Rw2 F2 Rw2 U' and the (Rw2 B2 Rw2 U)*2 alg for the mirror? Plz?



Yeah, I like those algs (much) better too. +1 to add. SiGN notation is the future. Use it today.

.


----------



## deepSubDiver (Mar 4, 2010)

Amazing! I will definitely have a deeper look into K4


----------



## chris410 (Mar 4, 2010)

Thank you for sharing, I will study this once I begin learning the 4x4.


----------



## Crystl (Mar 4, 2010)

it's really helpful, thanks a lot.


----------



## Kirjava (Mar 4, 2010)

~Phoenix Death~ said:


> Nice well put. Got more algs to learn




Read the description, they're not there to be learnt.



Parity said:


> Man not a video.




I put in the effort to create this and all you can do is complain that there isn't a video. If you can't read, I don't think you should be allowed to solve a cube.



DavidWoner said:


> I know its basically the same thing but underneath lrD2l'r'UlrD2l'r'U' could you also add Rw2' F2 Rw2 U' Rw2 F2 Rw2 U' and the (Rw2 B2 Rw2 U)*2 alg for the mirror? Plz?




Added. It's awesome, thanks. If anyone else has better algs for other cases, please let me know.

Thanks for all the positive feedback guys, it makes doing stuff like this worth it when I know people benefit from it.


----------



## joey (Mar 4, 2010)

Is this a joke method? Like OrtegaZB etc? Seems like it..


----------



## Escher (Mar 4, 2010)

I think I'll learn this 
I am seriously bored of reduction (and I suck at it).


----------



## rachmaninovian (Mar 5, 2010)

Escher said:


> I think I'll learn this
> I am seriously bored of reduction (and I suck at it).


yay join the direct solving club xD


----------



## Kirjava (Mar 6, 2010)

So uh, I added some speed-optimised algs for step 7. I'm still working on finding more to improve execution.


----------



## Diniz (Mar 6, 2010)

Really nice Kirjava, I am very interested in this method! Do you know the average number of moves of your method?


----------



## Cyrus C. (Mar 7, 2010)

Would you recommend, if during F3L you had an edge that could be solved by R2 U2 R2 U2 R2 doing that, or solving a different edge.

EDIT: I just noticed, why isn't this in How to/Guides?


----------



## ~Phoenix Death~ (Mar 9, 2010)

ELL. Painful.


----------



## Kirjava (Mar 9, 2010)

Diniz said:


> Really nice Kirjava, I am very interested in this method! Do you know the average number of moves of your method?




Not a clue. I might put some example solves up at some point.



Cyrus C. said:


> Would you recommend, if during F3L you had an edge that could be solved by R2 U2 R2 U2 R2 doing that, or solving a different edge.
> 
> EDIT: I just noticed, why isn't this in How to/Guides?




It depends on the situation really, but if it's only solving one edge I just wouldn't.

I asked for it to be moved.



~Phoenix Death~ said:


> ELL. Painful.




What are you having trouble with? It shouldn't be hard if you know how to create commutators, and if not, get used to comms first.


----------



## Googlrr (Mar 10, 2010)

I like the new site. I very much like the pictures, I found them most useful when learning F3L. Just working on my CLL now and I'll tackle ELL some other day. Nice work.


----------



## ~Phoenix Death~ (Mar 10, 2010)

How do I develop my own commutators? Sorry for noob question.


----------



## Googlrr (Mar 12, 2010)

~Phoenix Death~ said:


> How do I develop my own commutators? Sorry for noob question.



I found this link
infinitely useful when learning commutators. Badmephisto also has a tutorial on commutators which is nice, and then there's Ryan Heise's tutorial on it. The first link contains 4x4 examples, which is really nice. I've been reading these over the past few days and just playing around trying to swap random edges on the 4x4.

Edit:

I'd also like to mention that learning this commutator: [F' R u2 R' F, U] has been very useful. I started off just doing it and seeing the outcome, and then went on and watch it's effect on the cube. The first part (X) switches the UFr edge and the URf edge (and swaps orientation). The U puts 2 new edges in there, and then the X' swaps them again. This was the easiest one for me to follow with.


----------



## Kirjava (Mar 12, 2010)

Googlrr; You're doing it right.

~Phoenix Death~; See above.


----------



## Googlrr (Mar 13, 2010)

Okay, so I'm having trouble with one case here. Everything is solved except for 1 dedge, which is in it's place but oriented incorrectly. I see on the site that I could do this with r'U2xlU2l'U2x'r2U2rU2r'U2F2r2F2, but I was hoping to be able to use a commutator to figure this one out. I can't really see an easy/short way to do it, so I'll probably take the alg approach, but the way I see it, it /should/ be doable with a commutator? Any halp? I've pretty much got 3-cycles and 2x2's figured out, but this one eludes me.


----------



## Kirjava (Mar 13, 2010)

Googlrr said:


> Okay, so I'm having trouble with one case here. Everything is solved except for 1 dedge, which is in it's place but oriented incorrectly. I see on the site that I could do this with r'U2xlU2l'U2x'r2U2rU2r'U2F2r2F2, but I was hoping to be able to use a commutator to figure this one out. I can't really see an easy/short way to do it, so I'll probably take the alg approach, but the way I see it, it /should/ be doable with a commutator? Any halp? I've pretty much got 3-cycles and 2x2's figured out, but this one eludes me.




This 2 cycle permutation is caused by an uneven number of inner slice turns. To solve it it with commutators, you can do an r move and it'll turn into a 5-cycle. You'll have to solve the centres too though.

Probably better to stick with the alg, but that should help you understand it.


----------



## buelercuber (Mar 13, 2010)

hey i got this method pretty well, but when you do the last F3L slot and the CLL, some of the edges are still messed up. i might be missing a step but its a col method


----------



## buelercuber (Mar 13, 2010)

buelercuber said:


> hey i got this method pretty well, but when you do the last F3L slot and the CLL, some of the edges are still messed up. i might be missing a step but its a col method



never mind,,, wow that ELL looks so confusing


----------



## Kirjava (Apr 14, 2010)

Worst LL evar


----------



## miniGOINGS (May 2, 2010)

Kirjava, what do you (and other K4 users I guess) average in terms of movecount (STM)? Average movecount for FB? F3L? LL?

Also, I used to just blindly apply algorithms for the last layer, but now I'm actually watching where the pieces go, and how they move, and I think I'm getting a hold of it. Should I be going for 3 looks for the last layer edges?


----------



## joey (May 2, 2010)

If you learn enough, 3 look ELL is the maximum.


----------



## miniGOINGS (May 2, 2010)

joey said:


> If you learn enough, 3 look ELL is the maximum.



Ok, I understand that. But should I be going for 3LELL right now, or should 4/5/6 be OK for a while?


----------



## joey (May 3, 2010)

I think 5 is easy and should keep you going.

But eventually yes, you should be down to 3, and you can just keep learning the algs from the page and you will drop your looks as you learn.


----------



## miniGOINGS (May 3, 2010)

Thanks. 

I'm starting to like 4x4.


----------



## Kirjava (May 3, 2010)

4/5 look is fine until you start to get fast, don't see why you'd need to take 6 with even the most basic set of algs.

Too lazy to do averages for movecount, always have been. If I ever get round to it I'll post them here.


----------



## Kenneth (May 4, 2010)

Kirjava said:


> Worst LL evar




If I had that case I would probably start with the greens using : (x') U2 l2 U' L' U M2 U' L U r2 U2 (x)
Then the order in my method is locked so I have to do the blues after that : (y x') R U r U L' U' r' l' U L U' l U' R' (x)
Then it is the easiest parity case left for red and orange : (y) R' Lw2 U2 r' U2 l U2 l' U2 (x) U2 l' U2 Lw'

To setup that LL you can use:

Commutator : Lw' r' D2 r U2 r' D2 r U2 Lw
Checker parity: (y) r' U2 r2 U2 r U2 r' U2 r U2 r2 U2 r'
End it with a Z-PLL : M2 U' M E2 M E2 U' M2


----------



## Kirjava (Jul 28, 2010)

Did an example solve for someone

4x4 Scramble #1324: r d' U L R2 f2 u2 U2 l D' d F' r D f2 F U R r' U2 l D' U2 f' r D2 L2 l F' b r2 f l2 d2 b' l2 d2 U2 D l

13:54:00 <+Kirjava> first two centres
13:54:02 <+Kirjava> y'F2xRw'URw2ULw'ULw'U'LwyB'Uw2URwU2Rw'z
13:55:34 <+Kirjava> 1x3x4 block
13:55:36 <+Kirjava> xL'URwFRF'U2R'URU'R'ULUlU'L2U'Rw'Ux
13:58:52 <+Kirjava> last four centres
13:58:53 <+Kirjava> U' 3R2U2Rw'URw2l'U'RwU' 3R2URw2U2Rw2l'U'RwUlU'Rw'U2RwU'Rw'
13:59:12 <+Kirjava> 3R = (l'Rw)
13:59:46 <+Kirjava> finish off the first layer
13:59:48 <+Kirjava> U2R'URw'U'R2URwRU2z'
14:07:04 <+Kirjava> UR'Ur'U'RUrU'LwU'R'ULw'U'RU 3RU'L'U 3R'U'L2UrU'L'Ur'LU'Rw'UL'U'RwRU'rUR'U'r'U'RU'Lw'UR'U'Lw
14:07:08 <+Kirjava> F3L ^
14:07:20 <+Kirjava> CLL is just
14:07:51 <+Kirjava> U2R'U'RU 3LU'R'Ux
14:08:11 <+Kirjava> watch this
14:08:11 <+Kirjava> hehe
14:08:15 <+Kirjava> two look ELL I think
14:08:54 <+Kirjava> r'U'l'D2lUrU2r'U'l'D2lUrU2
14:08:56 <+Kirjava> then
14:09:34 <+Kirjava> Rw2U'lD2l'UlD2 3RRw


----------



## ~Phoenix Death~ (Aug 7, 2010)

Alright Kirjivy. I'm starting to understand the LL a bit more now. Be glad!


----------



## oll+phase+sync (Oct 4, 2010)

Not sure if it's already mentioned somehwhere but does this lastlayer system give me the oportunity to avoid the so called "parity cases". 

asked that I already know parity cases can't be avoided, but can I do something usefull while fixing parity?

When do you fix it? While doing the last 4 cubies?


----------



## masterofthebass (Oct 4, 2010)

oll+phase+sync said:


> Not sure if it's already mentioned somehwhere but does this lastlayer system give me the oportunity to avoid the so called "parity cases".
> 
> asked that I already know parity cases can't be avoided, but can I do something usefull while fixing parity?
> 
> When do you fix it? While doing the last 4 cubies?


 
exactly right. Parity in this method is not an extra step, it just is a different case for the last 2 edges.


----------



## Kirjava (Jun 14, 2011)

Thanks to qqwref for rewriting all the LL algs in commutator notation. Hopefully it'll force people learning to actually understand what they're doing, which is important. ^_^

Also dan made a video tutorial for ELL some time ago that I should link here.


----------



## Georgeanderre (Jun 14, 2011)

for some reason Chrome cant open it *cries*
will try Firefox... or Safari... nope nothing, not even my new iMac will open it =(


----------



## Christopher Mowla (Jun 14, 2011)

Kirjava said:


> Thanks to qqwref for rewriting all the LL algs in commutator notation. Hopefully it'll force people learning to actually understand what they're doing, which is important. ^_^


Hey Kirjava, do you want me to give you a very condensed outline for all (well, most if I can't break down some) of the odd permutation algorithms? That is, involving commutator notation, quarter turn, and conjugates?


----------



## Kirjava (Jun 14, 2011)

Georgeanderre said:


> for some reason Chrome cant open it *cries*
> will try Firefox... or Safari... nope nothing, not even my new iMac will open it =(



It's just HTML, nothing fancy - should be no reason why it doesn't work.



cmowla said:


> Hey Kirjava, do you want me to give you a very condensed outline for all (well, most if I can't break down some) of the odd permutation algorithms? That is, involving commutator notation, quarter turn, and conjugates?


 
Uh, possibly. It would have to be quite succinct to fit in the space provided.

Maybe that is better suited to another page. That's really more theory than you'd need to know as the parity algs are the ones you *don't* need to understand when you're learning.


----------



## Georgeanderre (Jun 14, 2011)

Kirjava said:


> It's just HTML, nothing fancy - should be no reason why it doesn't work.


 
snk.digibase.ca/k4/
gives me this page: Oops! Google Chrome could not connect to ... etc
i get the same with every browser i have tried, about 7



Spoiler


----------



## Kirjava (Jun 14, 2011)

Maybe your DNS is ****ed. Try switching to OpenDNS and see if it fixes it.


----------



## Georgeanderre (Jun 14, 2011)

Kirjava said:


> Maybe your DNS is ****ed. Try switching to OpenDNS and see if it fixes it.


 
now I can see the first page... but nothing else
only text, no links

this is the only webpage ive ever had problems viewing, even the old one took ages to load and then had to be loaded again and again until it worked.
this one just wont load at all


----------



## Georgeanderre (Jun 14, 2011)

found the problem, chrome is changing the link address from snk to skn for some stupid reason...


----------



## Kirjava (Jun 30, 2011)

Might do a better one of these if it helps people.


----------



## bwronski (Jul 1, 2011)

Are all of those comm's? or algs? or a mix of both


----------



## Christopher Mowla (Jul 11, 2011)

@Kirjava,

I have a few questions regarding solving the last layer wings.

First of all, I counted 54 cases on your ELL page, excluding the first section on "First/Second Edge Tricks," which may also include algorithms from the other 54 (I haven't compared the two to know).

[1] I recall that you said that you can solve any LL case in 3 algorithms, right?
[2] If [1] is true, are all of the algorithms on your ELL page sufficient to do this? I mean what IS there, not any algs for cases not on there which are mirrors, inverses, etc.
[3] If [2] is not true, then what's the minimum number of algorithms one needs to know to solve all LL cases in 3 or less algorithms?

The reason I ask is because I am currently putting together an alternate approach which requires the solver to know algorithms for 55 cases (55 algorithms total). That includes mirrors and inverses.

The Process:
[1] If one dedge is completely solved, skip this step. Otherwise, one dedge can be solved with one of 29 2 2-cycle algorithms (out of the 58 possible 2 2-cycle cases for the last layer).
[2] OLL. There are a total of 13 OLL cases (including mirros) when restricted to 3 unsolved dedges. Of those 13 OLLs, 11 of them can be done with 2 2-cycle algorithms from the selection of 29 used in step 1. The two new algorithms to be learned are to orient one dedge (a 3-cycle is probably best for this) and orient 3 dedges (a 3 2-cycle is probably best for this).
[3] PLL. There are a total of 32 PLL cases (including mirrors and inverses) when restricted to 3 unsolved dedges. Of those 32 PLLs, 8 of them can be solved with 8 of the 29 2 2-cycles used in step 1.

Hence,
Step 1 requires 29 algs
Step 2 requires 2 additional algorithms
Step 3 requires 24 additional algorithms

For a grand total of 55 algorithms. Again, that includes mirrors and inverses.

Another way to look at this is that
PLL (Step 2) requires 32 algorithms (including mirrors, inverses, etc.)
OLL (Step 3) requires 13 algorithms (including mirros, inverses, etc.)
and Step 1 therefore requires 10 additional 2 2-cycle algorithms to what can already be used in PLL and OLL.

Of those 55 algorithms, only 4 + 12 + 1 = 17 algorithms need to be odd permutations.
4 for the oriented 2-cycle cases, 12 for the oriented 1 2-cycle and 1 3-cycle cases, and 1 for the 3 dedge flip restricted to affecting the wings in those 3 dedges only.

I have algorithms for most of these cases, but I'll be trying to find the rest, as well as find faster ones for some of the longer ones that I have.

EDIT:
Well I guess only 16 odd permutation algorithms are required, as the 1 for the 3 dedge flip can be a specific 1 4-cycle and 1 2-cycle alg and possibly another cycle composition that I cannot think of right now. However, I think 3 2-cycle algorithms are more efficient anyway.


----------



## masterofthebass (Jul 12, 2011)

cmowla said:


> @Kirjava,
> 
> I have a few questions regarding solving the last layer wings.
> 
> ...


 
Kirjava's "algorithms" are hardly algs. I'd say I learned 2-3 algs (l2e parity cases) and can solve ELL in 3 looks or less. Its all intuitive, except for parity cases.


----------



## Christopher Mowla (Jul 12, 2011)

masterofthebass said:


> Kirjava's "algorithms" are hardly algs. I'd say I learned 2-3 algs (l2e parity cases) and can solve ELL in 3 looks or less. It's all intuitive, except for parity cases.


Regardless of how the 54 cases can be handled, they are still algorithms. I'm not talking about "intuition" or conjugation of other algs. In fact, many of the algorithms I have found for the 55 cases I mentioned can be handled much easier than conjugation (if that's what you mean by intuition).

Also, which 2-3 algs did you memorize that you can manage to solve all 8 wings for all 8! cases with 3 algs or less? I'm curious. I am not familiar with the "l2e parity cases" phrase to know what you are talking about. I mean, which cycle types do you use?

The total number of absolutely distinct algorithms required to handle all 55 cases is significantly reduced if we take into account inverses, mirrors, and minor modifications of other algorithms. I can't say exactly by how much as of yet (I haven't finished finding all 55 algs yet), but probably between about 1/4 and 1/3 of 55.


----------



## masterofthebass (Jul 12, 2011)

My point was that no one really has "learned" the ELL algorithms. Thom just put those up so he wouldn't have to explain commutators, but in reality, they aren't a set number of algorithms. It would be similar to comparing OLL algorithms to intuitive f2l. Your method probably requires a learned set vs. a group of intuitive commutators.


As for the algs I learned, they include (by colloquial names) OLL parity, Double Parity, opp 2cycle, PLL parity, and the 2 checkerboard 4cycles (named from bigcubes.com 5x5). I actually didn't need to learn any of these for ELL specifically, as I had known of them previously from 5x5 solving.


----------



## vcuber13 (Jul 12, 2011)

the l2e (technically l4e) parity cases are the cases when everything is solved minus 2 dedges and has a 2 or 4 cycle.
edit: the 2 or 4 cycles on kirjavas page are the l2e parity cases


----------



## Christopher Mowla (Jul 12, 2011)

masterofthebass said:


> My point was that no one really has "learned" the ELL algorithms. Thom just put those up so he wouldn't have to explain commutators, but in reality, they aren't a set number of algorithms. It would be similar to comparing OLL algorithms to intuitive f2l. Your method probably requires a learned set vs. a group of intuitive commutators.


I don't know exactly what I am dealing with yet, but when I finish the complete set of algs, I will post the document in this thread and comment on it.



masterofthebass said:


> As for the algs I learned, they include (by colloquial names) OLL parity, Double Parity, opp 2cycle, PLL parity, and the 2 checkerboard 4cycles (named from bigcubes.com 5x5). I actually didn't need to learn any of these for ELL specifically, as I had known of them previously from 5x5 solving.


You also conjugate each of those cases (except for the single dedge OLL Parity of course) to affect adjacent dedges too, right? Just asking so that I can see how this works.

EDIT:
Also, did you forget to mention 3x3x3 algs such as U-Perms (or other dedge preserving 2 3-cycles) or H or Z perms (or other dedge preserving 4 2-cycles)? I know it's not efficient to pair up the dedges first, but, if they happen to be paired up already it would be. The reason I ask is because you claim to be able to handle all 8! cases with just a maximum of 3 algs, using just the list of algorithms above. I just want to make sure I understand your method. Another reason I mention that is because two of the 32 PLLs are U-Perms, and obviously 4 of the 2 2-cycle algs are PLL parity or regular two dedge flips.


----------



## vcuber13 (Jul 12, 2011)

idk about dan but i would just do RUR'U' alg URU'R'


----------



## Christopher Mowla (Jul 12, 2011)

I have completed the document. (It's attached at the bottom of this post).

Just to illustrate this approach, here is one route we can take using the algorithms provided in my document for Kirjava's previously mentioned case:





*2 2-Cycle to solve the UF Dedge*
[r2 U2 F' M' U': r2] (11)
y
*2 2-Cycle Used for an OLL*
[y' R' F': [l2 U' F2 U': l2]] (13)
y
*A 1 3-cycle and 1 2-cycle Algorithm for an Odd Permutation PLL*
M2 U' x' r2 U2 F2 r' F2 U2 Rw2 U2 r U2 Rw2 x U2 r U' M2 y2 (17)

Here's a link to this solution.
​ I have put bookmarks in the PDF for convenience.

Comments:
 Also, I was one algorithm off. There's a total of 56 needed algorithms with this approach. The extra one was the mirror of the single dedge flip OLL. I needed to put it because any cycle besides a 2-cycle can mess up either side of the dedge. In order to not mess up the single solved dedge prior to OLL by accident, I had to include the mirror so that we have a choice of which side of the dedge we mess up.

As I estimated before, the total number of absolutely different algorithms needed to generate all 56 cases was a little more than 1/4 of the total, being 14-16 (depending on how you feel about what I mention on the last page of the document).

The majority of the algorithms in the document were created by me, so if anyone has questions regarding them, feel free to ask.

Lastly, I made the cube and permutation images in the document as the 5x5x5 cube so that it would be easier to see.

* EDIT:*
I just realized that this method requires more than 56 algorithms. If a wing is in the correct composite edge but is on the wrong side then, if no wings are solved even half way, the method has a problem.

We need 66 algorithms to be able to handle all 8! cases in 3 algorithms or less using this method.


Spoiler



If no wings are even half way solved, then there are two cases to consider:
1) Not all composite edges have one wing which corresponds to their two colors on the wrong side.
2) All composite edges have one wing which corresponds to their two colors on the wrong side.

For case 1, if we so happen to have the composite edge that has one correct wing in the composite edge, but on the wrong side, we can simply choose another dedge to solve that isn't like that. No additional algorithms are required for this case.

For case 2, there are a total of 32 cases which are not possible to solve in 3 algorithms or less using the method, unless more algorithms are added.
If we let A = r' U2 r2 U2 r U2 r' U2 r U2 r2 U2 r' and A = r U2 r l' U2 r2 U2 r' U2 r U2 r' U2 r' U2 l U2 r' into the formulas A y A y', A y A' y', A' y A y', and A' y' A' y', we obtain 16 of them.

Similarly,
If we let A = Lw' U2 M'2 U x' l' U2 l' U2 l2 U2 l' U2 x U' M'2 U2 Lw and A = Lw' U2 M'2 U' x r' U2 r' U2 r2 U2 r' U2 x' U M'2 U2 Lw into the formulas A y2 A y2, A y2 A' y2, A' y2 A y2, and A' y2 A' y2, we obtain the other 16 cases.

Hence, it looks like we need to add all 12 3-cycles which are contained in two composite edges to be able to tackle all 8! cases in 3 algorithms or less. I already have two of them for the "single dedge flip" OLL cases, and thus we need to add 10 algorithms to our list for a total of *66 algorithms*.


I have edited the document again (hopefully the last time).


----------



## vcuber13 (Jul 12, 2011)

why didnt you solve another dedge with the second alg?


----------



## masterofthebass (Jul 12, 2011)

cmowla said:


> You also conjugate each of those cases (except for the single dedge OLL Parity of course) to affect adjacent dedges too, right? Just asking so that I can see how this works.
> 
> EDIT:
> Also, did you forget to mention 3x3x3 algs such as U-Perms (or other dedge preserving 2 3-cycles) or H or Z perms (or other dedge preserving 4 2-cycles)? I know it's not efficient to pair up the dedges first, but, if they happen to be paired up already it would be. The reason I ask is because you claim to be able to handle all 8! cases with just a maximum of 3 algs, using just the list of algorithms above. I just want to make sure I understand your method. Another reason I mention that is because two of the 32 PLLs are U-Perms, and obviously 4 of the 2 2-cycle algs are PLL parity or regular two dedge flips.


 
Yes, when I solve ELL, I usually leave 2 adj edges to be solved. Depending on the case, I can either do a RB or RUR'U' conjugation to give me one of the cases I mentioned. 

I did forget to mention Uperms, but they can be seen as a fairly intuitive 3x3 ELL if you would like. Obviously with my knowledge from other puzzles, using EPLLs helps with the amount of looks, but I am still absolutely sure that it only takes 3 algorithms to solve ELL, even if you follow Thom and I's outline for solving.



vcuber13 said:


> why didnt you solve another dedge with the second alg?


 
that's not the method he's proposing.


----------



## Christopher Mowla (Jul 21, 2011)

*F(n-1)L*

I have been interested in solving a dedge (or one orbit of the composite edge, when referring to the nxnxn) in one algorithm instead of two.

I know that for the 4x4x4, if F2L algorithms are used, this isn't necessary. However, on larger cubes, if we can solve both wings in each orbit of the F(n-1)L composite edges in one algorithm, the move count during the F(n-1) phase will certainly be less and, if one has fast algorithms and a determination to learn a bunch of algorithms, be faster as well.

I was wondering which cases are the "worst" for solving a dedge in one algorithm, as far as btm move count is concerned. (What's the upperbound?)

*Note: I am talking about big cube sizes in general, not just the 4x4x4!*

First off, if I didn't miss any, there are 211 cases with respect to one, say, the FR F(n-1) slot. Of those, there are 107 cases, excluding mirrors.

As everyone knows, if we want to place two wings correctly into an F(n-1) slot, there are three different categories of where those two wings may be.
1) Both wings are in the U-Layer
2) Both wings are in the E-Layer
3) One wing is in the U-Layer and the other is in the E-Layer.

I have found _many_ algorithms (most of them being 2 2-cycles, but also some 2 3-cycles too) to prove the upperbound of 13 btm for any given case. 13 btm being the total move count, including U, U', or U2 premoves, etc.

Here are my results:
​


Spoiler








In detail,​












The only cases which may require 13 btm (again, for all size cubes) is the following: RF'Ulr'U'FR'UF'l'rF.


Maybe some people are wondering, but yes, I have been creating a document about this. I'm almost finished, as it includes all case images and corresponding algorithms.

The case images are different than Kirjava's. I did use visualcube as well, but I used the transparent setting and then modified it in Paint to my liking.

This is the url I used to generate the initial image.

This is the image I ended with.




​ 
I have actually made the cases images transparent, as to accompany any color background to ultimately change the color of the cube. My document has a black background (not good for printing, but good to have on the computer) and all case images inside have a transparent fill. For example, here is the case image for the only case which I cannot handle in less than 13 btm (on all size cubes).



​



EDIT:
Now I have proven that only one case requires 13 btm for all cube sizes. I have updated my results.​


----------



## Christopher Mowla (Jul 26, 2011)

I have finally finished the document for F3L.

Just in case people haven't read my previous post a day or so after I originally posted it, now only one case might require 13 btm. 

As I was finishing the document, I noticed that I had the wrong algorithms for some cases, and for others, I lowered the move count. My final data is also in the document (not much different than what was in the previous post, but the overall algorithm length average is less now).

To save ink (whether printing in color or black and white), I have made all case images lighter.
F3L_Light

But for those who like the colors of the case images on Kirjava's web-pages,
F3L_Dark

I originally began making this document just for my curiosity for what the upper bound is for solving a dedge in one algorithm. However, this might have potential to be put into practice. Although there are 211 cases (or 99 not including mirrors, inverses, or cube rotations), I show rigorously at the end of the document that only 14 base algorithms are needed to generate all 211 cases. Using those 14 base algorithms make solutions that are no more than 12 btm, except for the single case which is 13 btm. I have more details on this as well as how I classify each case.


Lastly, I stated in my previous post that I couldn't get less than 15 btm for one 2 2-cycle case for the last layer. A few days later, I tried again and got a 13 btm: [r2 U F' R F' U: r2]. I have added that algorithm to the document and have updated the averages presented on the first page.


----------



## Kirjava (Aug 6, 2011)

cmowla said:


> @Kirjava,
> 
> I have a few questions regarding solving the last layer wings.
> 
> ...



1- ELL. Yap.
2- No idea. Maybe?
3- No idea. 

The 'algs' listed there are just examples. I don't advise anyone to just learn them all. I think some first/second edge stuff is required for 3 looks.



cmowla said:


> The reason I ask is because I am currently putting together an alternate approach which requires the solver to know algorithms for 55 cases (55 algorithms total). That includes mirrors and inverses.



What kind of algs, comms? Do I already know most of them?



cmowla said:


> The Process:
> [1] If one dedge is completely solved, skip this step. Otherwise, one dedge can be solved with one of 29 2 2-cycle algorithms (out of the 58 possible 2 2-cycle cases for the last layer).
> [2] OLL. There are a total of 13 OLL cases (including mirros) when restricted to 3 unsolved dedges. Of those 13 OLLs, 11 of them can be done with 2 2-cycle algorithms from the selection of 29 used in step 1. The two new algorithms to be learned are to orient one dedge (a 3-cycle is probably best for this) and orient 3 dedges (a 3 2-cycle is probably best for this).
> [3] PLL. There are a total of 32 PLL cases (including mirrors and inverses) when restricted to 3 unsolved dedges. Of those 32 PLLs, 8 of them can be solved with 8 of the 29 2 2-cycles used in step 1.
> ...



Ok, that's cool. You should post the method as algs so people can look and see if they like it. 

Recognition sounds fine but the algs don't sound very fast.



cmowla said:


> Regardless of how the 54 cases can be handled, they are still algorithms. I'm not talking about "intuition" or conjugation of other algs. In fact, many of the algorithms I have found for the 55 cases I mentioned can be handled much easier than conjugation (if that's what you mean by intuition).



Are they fast?



cmowla said:


> Also, which 2-3 algs did you memorize that you can manage to solve all 8 wings for all 8! cases with 3 algs or less? I'm curious.



Not sure this is possible.



cmowla said:


> The total number of absolutely distinct algorithms required to handle all 55 cases is significantly reduced if we take into account inverses, mirrors, and minor modifications of other algorithms. I can't say exactly by how much as of yet (I haven't finished finding all 55 algs yet), but probably between about 1/4 and 1/3 of 55.



Inverses/mirrors seems to be taken for granted on 4x4x4 with these types of methods 



cmowla said:


> I don't know exactly what I am dealing with yet, but when I finish the complete set of algs, I will post the document in this thread and comment on it.
> 
> You also conjugate each of those cases (except for the single dedge OLL Parity of course) to affect adjacent dedges too, right? Just asking so that I can see how this works.
> 
> ...



Nah, the algs listed are just examples. I didn't forget to mention 3x3x3 algs, this is taken from the site - "algorithms that work on the 3x3x3 apply here aswell". I just listed some of the stuff I know to give people a starting point.



cmowla said:


> I have completed the document. (It's attached at the bottom of this post).
> 
> Just to illustrate this approach, here is one route we can take using the algorithms provided in my document for Kirjava's previously mentioned case:
> 
> ...



I have to say that recog looks like it could be fast. However, the algs don't seem like they would be that fast in practise. Like, lots of PLL algs suck.



cmowla said:


> I have been interested in solving a dedge (or one orbit of the composite edge, when referring to the nxnxn) in one algorithm instead of two.



Hehe. Solving multiple edges during F3L has been considered and tried over and over and over. The issue is (if you can call it that) that the lookahead and 'algorithms' for the current F3L technique is /so/ good it's very hard to beat. There's no point recognising and working out the alg solve two edges in one when you can execute two fast comms with no pauses faster. (Of course, I'd love you to prove me wrong)



cmowla said:


> I know that for the 4x4x4, if F2L algorithms are used, this isn't necessary. However, on larger cubes, if we can solve both wings in each orbit of the F(n-1)L composite edges in one algorithm, the move count during the F(n-1) phase will certainly be less and, if one has fast algorithms and a determination to learn a bunch of algorithms, be faster as well.



The cool thing about n>5 cubes is that during FN-1L there are often oppertunities to solve three or more edges at a time already with a few tricks. With smart edge group selection, you can even force these cases.



cmowla said:


> I was wondering which cases are the "worst" for solving a dedge in one algorithm, as far as btm move count is concerned. (What's the upperbound?)
> 
> *Note: I am talking about big cube sizes in general, not just the 4x4x4!*



No idea.



cmowla said:


> First off, if I didn't miss any, there are 211 cases with respect to one, say, the FR F(n-1) slot. Of those, there are 107 cases, excluding mirrors.



This seems... unfriendly as a speedsolving approach.



cmowla said:


> As everyone knows, if we want to place two wings correctly into an F(n-1) slot, there are three different categories of where those two wings may be.
> 1) Both wings are in the U-Layer
> 2) Both wings are in the E-Layer
> 3) One wing is in the U-Layer and the other is in the E-Layer.
> ...



Honestly, I don't really care about gods alg or upper bounds. Don't let me stop you from doing this though - your work is useful for method development.



cmowla said:


> Here are my results:​*insert graphs and *****



cool



cmowla said:


> I have finally finished the document for F3L.
> 
> Just in case people haven't read my previous post a day or so after I originally posted it, now only one case might require 13 btm.
> 
> ...


 
Your download links are broken.

Either way, maybe I'll learn this one day, maybe not. I still doubt that it could be useful for speedsolving.

Lastly, it's exhausting replying to all this. Can you condense your posts a little in future? Maybe you can come on IRC, I'm more talkative there.


----------



## Christopher Mowla (Aug 6, 2011)

Kirjava said:


> Lastly, it's exhausting replying to all this. Can you condense your posts a little in future?


Sorry. I try very hard to not write so much, but the large amount of text just reflects how much I have to share (honestly). I always try to be as concise as I can. Even then, there is at least 2 times as much that I can also mention, but I don't.



Kirjava said:


> Your download links are broken.


I just clicked them and it worked. It's weird, but after a few seconds, the download links appear. For some reason, you have to wait longer for the dark color version than the light color version. So try again, and let me know if you can access them after waiting a little longer.




Kirjava said:


> What kind of algs, comms? Do I already know most of them?
> ...
> Recognition sounds fine but the algs don't sound very fast.
> ...
> ...


See the document attached to this post (if you haven't already by now). As you will see, most of the 2 2-cycles are just conjugations of r2 (or l2). I have cleverly made all twelve 1 2-cycle and 1 3-cycle algorithms (on page 14 of the document) from one base alg, so I believe I at least took care of the ugliest PLL cases. I have recently edited the document again because I realized that 66 algs are needed, not 56. But the new algs I just added are 3-cycles which you already know.

And, the algorithms I placed in that document aren't the fastest for all of the cases presented. For the 2 2-cycle algs, I tried to focus on using only 8 base algorithms to handle all 29 cases.

Since for the largest group of 2 2-cycles I used the alg [l2 U' F2 U': l2](9), if you don't find that very fast, here are two alternatives:
[Lw2 F2 U L2 U: l2] (11)
[Rw2 F2 L U' L' U': r2](13)
(You can alter these in the same manner that I did with the 9 mover and still get algs for all cases in that group).

Also, note that the other case formed from these algorithms by inverting the single quarter turn faces of U has a fast form for the 9 mover [Lw2 U F2 U: l2](9).

With the exception of most 13 btm and all 15 btm algs that cancel to 11 btm and 13 btm, respectively, due to (L R') and (L' R), I believe I have exhaustively searched all possible algorithms of length (7-13 btm) of the form [A:B] generated by <L,R,U,F,l2,r2,Rw2,Lw2>, and I have to say that the algorithms I have provided in the document for the 2 2-cycles are unique. I grabbed all solutions that begin and end with wide turns, if they had single inner layer turns as equivalents. Hence, they are as good as they get for speed. (This holds true for probably most of the F3L algs too, as many algs in the text document below were used for them).

In fact, I have attached a text document which shows 2,472 algs.
View attachment 2_2-Cycles.txt

If you're overwhelmed, don't worry. I had to sort out the algorithms to be able to use them for F3L. (Sadly I ended up not using most, and I had already found most of the ones I used before I did this exhaustive search).
View attachment Algs_Sorted.pdf
Note that for the group of 2,416 algorithms, I only bothered to sort most of the algorithms that began with either r2 or Rw2 and that conjugated r2 (only 1/4 of 2,416). I also eliminated petty equivalents for the 7 and 9 btm move algs.

All in all, many of the algorithms give the same result on the cube, whether they are mirrors, or if they affect pieces in different faces. In addition, a big chunk of the algorithms cannot be used for F3L or ELL, as they affect wings on opposite faces or in positions which require additional conjugation to be useful (more moves).



Kirjava said:


> There's no point recognizing and working out the alg solve two edges in one when you can execute two fast comms with no pauses faster. (Of course, I'd love you to prove me wrong)


I agree with you for a portion of the cases. However, cases that require 9-10 moves are definitely more debatable. Probably if both wings are in the U-Layer, it's not worth memorizing (for speed purposes, but definitely for move count), but if both wings are in the E-Layer or one wing is in the U-Layer and the other is in the E-Layer, it definitely becomes more tempting (to me at least).

For example, here are a few of the cases that I highly doubt can be handled faster with two algs.
Case 16-6
[z'Lw2U'F2U':l2]
Case 9-15
[z'Rw2U'F2U':r2]
Case 11-8
[x:U'l'r'UR'U'lrUR]
Case 4-13
[x':R2U'l2rUR'U'l2r'UR']
etc.



Kirjava said:


> This seems... unfriendly as a speedsolving approach.


Maybe so, but I mention in the document that 14 base algs are used to form algs for all 211 cases. (Note also that the number of cases we really can say are distinct is 99.) For the cases in the U-Layer and cases in the U-Layer and E-Layer, only 1/4 of the algs need to be memorized because we use the trivial U, U' and U2 conjugations which still keep the move count <=12 btm.

EDIT:
And if you don't count cases which can be achieved with trivial conjugations of U, U' and U2 as well as reflections, inverses and cube rotations, there are 39 distinct algs. (And of course these algs are interrelated as well due to my statement about the fact that 14 base algs are used to make all 211 cases).


----------



## Guilherme Barro (Aug 8, 2011)

I want to lern but,is too hard.


----------



## Christopher Mowla (Jan 11, 2012)

cmowla said:


> I put together a document showing my current best (briefest mainly, but some are okay for execution speed) collection of algorithms for all 58 K4LL 2 2-cycles. I probably explain more than anyone wants to know on the first page. I know that it's possible that I did not arrange the cases the way most prefer, but I tried my best...



I just deleted that post ^ because I updated the document. I went here and looked at the first 82 "seed algorithms" listed (12 moves max) and found briefer algorithms for 14 of the 58 cases.

Here's the updated document:

View attachment 2 2-cycles.pdf​ 
I credited this source as "AF" (Algorithm Finder) followed by :S_ _. . The number following the S is the seed algorithm number (the seed algorithms first listed on that page I just provided a link for).

Note that several algorithms that existed prior to generation date of these "seed algorithms" can be made from these seed algorithms, but I did not credit that source for algorithms which I definitely knew existed before. If someone has created one of the algorithms I credited to AF's seeds (prior to December 14, 2011), let me know.

I found multiple solution's from AF for the cases I added algorithms from it to, but many of the solutions were similar (even though 82 seed algorithms are listed, I can definitely say that more than half were closely related), and I chose the best solutions with speed in mind. However, some cases from AF didn't have fast solutions.

*All cases now have pure solutions.*

In addition, all cases can be handled in 15 btm or less! Here is the btm move distribution (of the shortest algorithms for all size cubes) in the collection provided in my document.
7 (1)
9 (4)
11 (10)
12 (6)
13 (23)
14 (8)
15 (6)

Average: 12.52 btm/case.​


----------



## MalusDB (May 26, 2012)

Sorry for bumping an old thread, but I've followed the link in Kir's OP and its to a dead site pretty much, just ads and stuff. Does anybody know of a new site where Kir has the same info from this site? Was gonna PM him but thought this would suffice, plus this way other people can see. Also since this link is the one in the wiki, it probably should be ammended (assuming I'm not just being a complete tosser and doing something wrong here).


----------



## MostEd (May 26, 2012)

http://snk.digibase.ca/k4/index.htm


----------



## MalusDB (May 26, 2012)

MostEd said:


> http://snk.digibase.ca/k4/index.htm


Does that link work for you? Thats the one I tried a few times, from different sources and most of them didnt work, with one of them eventually bringing me to a domain that is clearly not kirs page.


----------



## MaeLSTRoM (May 26, 2012)

MalusDB said:


> Does that link work for you? Thats the one I tried a few times, from different sources and most of them didnt work, with one of them eventually bringing me to a domain that is clearly not kirs page.


 
That is the right link. here's a link to one of the subpages incase its just being odd. http://snk.digibase.ca/k4/1.htm


----------



## MostEd (May 26, 2012)

Ofcourse the link works, its the only link i know of.


----------



## Georgeanderre (May 26, 2012)

MalusDB said:


> Does that link work for you? Thats the one I tried a few times, from different sources and most of them didnt work, with one of them eventually bringing me to a domain that is clearly not kirs page.


 

That link can be a bit 'iffy' for me, 8/10 days it works fine and loads instantly, the other 2/10 days it either won't load at all or takes forever to open and is just a black page... this used to annoy me a lot but since I printed the pages off I just refer to my notes if I forget anything or need to top up on something


----------



## Dav (Dec 31, 2020)

Hey!
You've now talked very much about LL, but what about F3L?
I haven't thougt about it in detail, but I think what I would do is more efficient - EDIT: No, it is not, I were just too stupid too read the whole document.
My idea is solving F3L with a kind of keyhole technique.
Because of some reason the explanation isn't displayed the right way here, so I put it into the text file.

Keep in mind that this explanation isn't there to learn it by heart, but only to understand the idea.
Also, this is just an _idea_ and I don't say it's perfect in any way. You may also use only parts of it.

Sorry if my explanation is a bit hard to understand, it isn't easy to explain it without being able to show the cube, and I'm still learning english in school.

EDIT: As I just said, DON'T USE THIS! I don't want to delete this, because there is a reply to this, but don't use this method!


----------



## Christopher Mowla (Dec 31, 2020)

Dav said:


> Hey!
> You've now talked very much about LL, but what about F3L?
> I haven't thougt about it in detail, but I think what I would do is more efficient (_would _because until now I'm still stuck with Yau).
> My idea is solving F3L with a kind of keyhole technique.
> ...


You didn't see my post? (That when you solve both wings in a F3L slot simultaneously (with the same alg -- which would never need to be more than 12 moves (with the exception of one case's alg which is 13 moves.)

(If you're waiting for Thom (Kirjava) to reply, he did make a special section for handling one wing edge at a time (and two at a time if they are both in the E-layer) on his method's website.)

And how many moves would your keyhole approach complete one wing at a time if they are done individually (which seems to be what you're approach is). Because it only takes 7 to 8 moves to solve one if the wing is in the U layer (just a modification of Niklas).


----------



## Dav (Jan 1, 2021)

Oh, I'm really sorry, I didn't see your post.
I just looked at this link and didn't read everything, because it first looked similar to what I did when I figured out a LBL method myself.
I won't delete the comment but edit it, so it's safe that nobody uses that.
Thanks for showing me the right way.
Sorry for that, Dav


----------

