# K4LL 2-Gen Algorithms

#### Christopher Mowla

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:
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...
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.

Last edited:

#### vcuber13

##### Member
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

##### Member
Derivation:
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'
That looks quite complicated. I just look at it as (Rw U') [R', U' r' U] (U Rw')

#### Christopher Mowla

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.

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

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

#### cuBerBruce

##### Member
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

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!

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.

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).

Last edited:

#### Christopher Mowla

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).

#### Christopher Mowla

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

##### Member
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).

##### Member
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).

#### Stefan

##### Member
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

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

#### Christopher Mowla

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:
=>
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?

Last edited:

#### vcuber13

##### Member
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.