# K4LL 2-Gen Algorithms



## Christopher Mowla (Jul 15, 2010)

Hello again, speedsolving community.

I am aware that Thom Barlow has 2-gen algorithms listed for 3-cycle groups 1 and 6 on his ELL page of his K4 Method guide, but for the rest, he currently doesn't have any posted. (Each group of 3-cycles has four cases. I am numbering the groups in ascending order from which Thom listed them).

I believe many speedsolvers like 2-gen algorithms, so I thought I would share this with you all. Maybe K4 users can adopt a few of these algs or create their own.

I will give one or more algorithms for groups 2-5 and 7. Above each algorithm is one of the four cases which is in the corresponding group, but not necessarily what the algorithm itself does. Why? Mirrors and inverses of my algorithms under each group can be made to handle all cases.


Most of the 2-gen algorithms which will be listed in this post are based off of the following 2-gen algorithm:
Rw U' R' U' r' U R U' r U2 Rw'

*Derivation:*


Spoiler



Take the commutator:
U R U' 
U2 r U2
U R' U'
U2 r' U2

and add the set-up move l'

=l' U R U r U' R' U r' U2 l
Convert the set-up moves to wide:
=>Lw' U R U r U' R' U r' U2 Lw
Add in the proper cube rotation to place in U:
=> x' Lw2' U R U r U' R' U r' U2 Lw2 x
Merge the set-up move and cube rotation
= Rw2' U R U r U' R' U r' U2 Rw2

Rotating about y2 and taking the reflection of that:
Rw U' R' U' r' U R U' r U2 Rw'


Just by experimentation, if you are consistent with moves you invert and use different set-up moves, the algorithms listed below can be made from this algorithm (as I said before).


*For the 2nd group:*





Rw U' R' U' r U R U' r' U2 Rw'
Rw r U R' U r' U' R U r U2 r' Rw'


*For the 3rd group:*




x r U R' U r U' R U r' U2 r' x'


*For the 4th group*




Rw U' R' U' r' U R U' r U2 Rw'


*For the 5th Group: It's not 2-gen, but almost.*




F Rw2 U R' U r U' R U r' U2 Rw2 F'

However...


Spoiler



Here is another commutator with more set-up moves. It generates a 2-gen alg:
Rw U' R U
r' U R' U' r U R U'
U' R' U Rw'
=Rw U' R U r' U R' U' r U R U2 R' U Rw'

Also, from this commutator, an algorithm for the fourth group can be made:
Rw U r' U R' U' r U R U2 Rw' 



*
For the 7th group:*




x Rw2 U R U r U' R' U r' U2 Rw2 x'
etc...

I hope there is at least one algorithm which can improve K4 users solving times. I am sure also, by these example algorithms, you all can come up with your own 2-gen algorithms.


----------



## vcuber13 (Jul 15, 2010)

Its very interesting, although I don't think I quite at the spot where I should learn speed optimized algs intead of the comms


----------



## Stefan (Jul 15, 2010)

cmowla said:


> *Derivation:*
> Take the commutator:
> U R U'
> U2 r U2
> ...



That looks quite complicated. I just look at it as (Rw U') [R', U' r' U] (U Rw')


----------



## Christopher Mowla (Jul 15, 2010)

Thanks Stefan! I am sure Thom won't be shy to use this condensed notation on his page, should he decide to list these algorithms under their corresponding cases. That makes it much simpler, especially since all the algorithms listed are basically the same with some minor adjustment.


----------



## deadalnix (Jul 15, 2010)

Great thread !

We have some proposition for K4 on the french forum here : http://forum.francocube.com/topic5166.html

Not all of them in RU, but most of them really fast.


----------



## blade740 (Jul 15, 2010)

You should make algs in {R 2r 3r U}

2gen algs are nice for speedsolving but those inner r's kill it.


----------



## cuBerBruce (Jul 15, 2010)

Of course, mathematically speaking, none of these algs are 2-gen. The mathematically inclined reader might take it as a challenge to come up with actual 2-gen algs (either <U, Rw> or <U, r> ) for all of these cases.


----------



## Christopher Mowla (Jul 16, 2010)

deadalnix said:


> Great thread !
> We have some proposition for K4 on the french forum here : http://forum.francocube.com/topic5166.html
> Not all of them in RU, but most of them really fast.



I am glad you like it! Tell me what members from there think about my algorithms!




blade740 said:


> You should make algs in {R 2r 3r U}
> 
> 2gen algs are nice for speedsolving but those inner r's kill it.


 I will see what I can do. And of course, if I do find them, I will provide the derivations just as I have for these algorithms.




cuBerBruce said:


> The mathematically inclined reader might take it as a challenge to come up with actual 2-gen algs (either <U, Rw> or <U, r> ) for all of these cases.




That's great! I want others to find good algs too. If anyone does find algorithms that are authentically 2-gen, it would be great if they posted them and the derivations here (well, unless they were found with a computer solver).


----------



## Christopher Mowla (Jul 16, 2010)

*2 2-cycles*

This is a 2 2-cycle algorithm which is much closer to 2-gen <U,r> than the other algorithms.

r' U2 M' r U r' U2 r' U2 r U2 r U M r' U2 r
or
r' U2 M' r U' r' U2 r' U2 r U2 r U' M r' U2 r

The first version of this algorithm is:
r' U2 M' r U
r' U2 r'
U2
r U2 r
U2
U' r' M U2 r
=(r' U2 M' r U) [r' U2 r', U2] (U' r' M U2 r)
and the second is:
=(r' U2 M' r U') [r' U2 r', U2] (U r' M U2 r)

It could be useful.


----------



## vcuber13 (Jul 16, 2010)

Do you use K4?
And how do you go about finding these algs?


----------



## Christopher Mowla (Jul 16, 2010)

Well, I like to first solve two opposite centers, pair up 3 cross edges, solve the remaining 4 centers, and then do the rest K4 style (maybe throw in some F2L if I can when solving F3L).

I found all of these algorithms from attempting to construct 2-gen OLL parity algorithms (which I have failed at, but am glad that I got these results from it).


----------



## vcuber13 (Jul 16, 2010)

So kinda like Fridrich K4 variant, thats what I do.

Whats your average?


----------



## Christopher Mowla (Jul 16, 2010)

Not that good. About 3 minutes (my pb is 2 min 31, although I came very close once to getting about 2 min 10s--but I messed up). I have recently started to learn F2L, so that can easily get better once I get used to them. Also, I just found these 3-cycle "2-gen" algorithms, so that average is not with these algorithms either (but I have nothing to brag about anyway, as you can see).


----------



## vcuber13 (Jul 16, 2010)

With practice it isnt that hard to get sub 2, I average about 1:35 with it and I'm practicing for TOS. Hopefull about a 1:20/1:25 average (1:30 cut off).


----------



## deadalnix (Jul 16, 2010)

cmowla said:


> That's great! I want others to find good algs too. If anyone does find algorithms that are authentically 2-gen, it would be great if they posted them and the derivations here (*well, unless they were found with a computer solver*).



Is it bad ?


----------



## Stefan (Jul 16, 2010)

deadalnix said:


> cmowla said:
> 
> 
> > it would be great if they posted them and the derivations here (*well, unless they were found with a computer solver*).
> ...



Yes, computer algs are a sin! (nah, he probably just referred to the derivations there, when you *can't* provide them for computer algs)


----------



## irontwig (Jul 16, 2010)

Even if it's a computer alg you can still say if it is a conjugated commutator or what not.


----------



## Christopher Mowla (Jul 16, 2010)

@blade740,
I have done some searching, and I have not been successful to find algorithms without single slice layers except for 2 2-cycle cases (and only two of them at that).

The regular PLL parity case:
Rw2 U2 Rw' U2 Rw2 U2 Rw2 U2 Rw' U2 Rw2
And for the case on Thom Barlow's ELL page for which he already has an algorithm which does not require single slice turns. The algorithm I found was based off of the one above (and thus long). Hence, this is the algorithm on the ELL page for it:
(Rw2 B2 Rw2 U)2


However, I have found a faster commutator (I think) for algorithms in groups 3 and 4 of the 3-cycles.

This is the commutator:
R
U' r2 U
R'
U' r2 U

*For Group 3:*
Adding set-up moves:
=>
x' U'
R
U' r2 U
R'
U' r2 U
U x
=x' U' R U' r2 U R' U' r2 U2 x
=(x' U')[R, U' r2 U](U x)

*For Group 4:*
Inverting the R moves in the commutator and adding different preliminary moves:
x' Uw'
R'
U' r2 U
R
U' r2 U
Uw x
= x' Uw' R' U' r2 U R U' r2 U Uw x
=(x' Uw')[R', U' r2 U](Uw x)

I can get sub 4 with both of them just by looking at them without memorizing (though, that shouldn't be very hard to do). Thus, I know you guys probably can get sub 3 or even less, especially for the algorithm for group 3.

What do you guys think?


----------



## vcuber13 (Jul 16, 2010)

Pretty cool, altough I'm still going to use the commutators, I might switch the the "PLL parity" one. Also I got 2.83 oin 3rd try using the group 3 alg.

edit: after a few more tries my best was 2.25.


----------



## Christopher Mowla (Jul 16, 2010)

I am glad you like the algorithm for group 3, but I am not sure why you say you are still going to use commutators: the algorithms I gave are clearly based off of commutators.


EDIT:


StefanPochmann said:


> deadalnix said:
> 
> 
> > cmowla said:
> ...


Yes, Stefan, I was referring to derivations. Sorry, deadalnix, for the confusion with that side note.


----------



## cuBerBruce (Jul 16, 2010)

cmowla said:


> cuBerBruce said:
> 
> 
> > The mathematically inclined reader might take it as a challenge to come up with actual 2-gen algs (either <U, Rw> or <U, r> ) for all of these cases.
> ...



I rather assumed real 2-gen algs would be too long for speedsolving use. Nevertheless, I have used ksolve to generate solutions for <U, r>. The best I found was 15 moves. The <U, Rw> group is much larger than <U, r>, and with essentially, the same branching factor, I expect <U, Rw> solutions to be longer.

I used ksolve to find <U, r> solutions for one member of each of the seven groups. These should be the optimal algs for the specific cases, but not necessarily the best for each group.

First I list the pure versions (no centers permuted).

Group 1: 23 moves for the chosen case
r2 U r' U2 r' U r U r U2 r2 U2 r U2 r U r' U r' U2 r2 U r2
r2 U r' U2 r' U' r U' r U2 r2 U2 r U2 r U' r' U' r' U2 r2 U r2
r2 U' r U2 r' U2 r' U2 r2 U2 r2 U r U r' U2 r' U2 r2 U2 r' U r

Group 2: 24 moves for the chosen case
U' r2 U' r' U r' U r' U2 r U r' U r2 U' r U r U' r U' r' U2 r
r U' r2 U' r' U r' U r' U2 r U r' U r2 U' r U r U' r U' r' U2

Group 3: 22 moves for the chosen case
U r' U r2 U2 r2 U2 r U2 r U2 r' U' r U r U2 r2 U2 r U2 r

Group 4: 22 moves for the chosen case
U2 r' U2 r' U' r U' r2 U2 r2 U2 r' U2 r' U2 r U r' U' r' U2 r2
U2 r2 U2 r U' r U r' U2 r U2 r U2 r2 U2 r2 U' r' U' r U2 r

Group 5: 20 moves for the chosen case
r U2 r2 U2 r U2 r U r' U r' U2 r2 U2 r' U2 r' U r U
r U2 r2 U2 r U2 r U' r' U' r' U2 r2 U2 r' U2 r' U' r U'

Group 6: 22 moves for the chosen case
r U2 r2 U2 r U' r U r' U2 r U2 r U2 r2 U2 r2 U' r' U' r U2

Group 7: 22 moves for the chosen case
r U r' U r2 U2 r2 U2 r U2 r U2 r' U' r U r U2 r2 U2 r U2

Next I list the non-pure versions (same-color centers may be permuted).

Group 1: 19 moves for the chosen case
r U2 r' U r U r U' r' U r' U' r U' r U r' U r'

Group 2: 21 moves for the chosen case
U2 r U r U r' U' r' U' r U r U' r' U r' U r U2 r' U2

Group 3: 17 moves for the chosen case
U' r' U' r U2 r2 U r2 U r' U' r' U' r U' r U
U' r' U' r' U' r U' r U r2 U r2 U2 r' U' r U

Group 4: 19 moves for the chosen case
r2 U r U2 r U' r2 U' r2 U2 r' U2 r' U r U' r' U' r2

Group 5: 20 moves for the chosen case
Pure solutions were not improved.

Group 6: 17 moves for the chosen case for the chosen case
U2 r U' r' U2 r' U r U r U' r2 U' r2 U' r' U2

Group 7: 15 moves
r' U r2 U r2 U r U' r U' r' U2 r' U r


----------



## Christopher Mowla (Jul 17, 2010)

cuBerBruce said:


> I used ksolve to find <U, r> solutions for one member of each of the seven groups. These should be the optimal algs for the specific cases, but not necessarily the best for each group.



Thanks for your time; these algorithms are neat.

In my search for algorithms which do not require single slice turns, I could not find algorithms for 3-cycles. But, I found that 2 3-cycles are probably going to be briefer for <U, Rw>:
(Rw' U Rw U2 Rw' U' Rw U')4

Also, this is one of the 2 2-cycle algorithms listed below:
Rw' U2 Rw' U2 Rw U2 Rw U Rw' U2 Rw' U2 Rw U2 Rw U
=[Rw' U2 Rw' U2 Rw U2 Rw,U](U2)

 http://alg.garron.us/?alg=[r-_U2_r-_U2_r_U2_r,U]_U2&cube=4x4x4And for <U,r>, I have some 2 2-cycle algorithms:
r' U r U2 r U2 r U2 r2 U2 r U2 r U2 r U2 r2 U r
r2 U2 r' U2 r2 U2 r2 U2 r' U2 r2 U2 (I think this has been known for a while).
[r' U2 r' U2 r U2 r,U]


----------



## cuBerBruce (Jul 17, 2010)

cmowla said:


> In my search for algorithms which do not require single slice turns, I could not find algorithms for 3-cycles. But, I found that 2 3-cycles are probably going to be briefer for <U, Rw>:
> (Rw' U Rw U2 Rw' U' Rw U')4



Well, using ksolve, I've found a 20-move 3-cycle in <U, Rw>. Around 25 moves seems more typical.

Rw U Rw' U' Rw U2 Rw U Rw' U Rw U Rw2 U Rw2 U Rw' U2 Rw' U


----------



## Cool Frog (Aug 28, 2012)

Mind = Blown...
some of these are very nice, others are not so...
but that 3 gen 3 cycle... <3

I will play around with this until I get some nice Opposite only 3 cycles (for all the cases) because for me, those are particularly bad.

your diagram for that cycle is also wrong =P


----------

