Step 7; ELL

I will outline the general approach I use in this step along with some algorithms that I use. You can learn these algorithms like any other, but it would be a waste of your time - they're all pretty similar and you should be able to derive your own to do different things from the first few you learn. The algorithms are listed to provide you with hopefully nicer alternatives if you find bad ones, to show you various tricks you can employ to manipulate edges and to show you how to do cases you may not have worked out youself. Study them, but don't learn them.

If you read this page and get completely lost, this entire step can be completed with only two algorithms (the first 3-cycle and any of the 2-cycles), however - this won't be very quick at all.

As with F3L, algorithms that work on the 3x3x3 apply here aswell. It might be worth learning full 3x3x3 ELL, since it sure comes in handy when you have accidentally paired edges.

I use a general method that allows me to complete this step in no more than 3 algorithms each time. I sometimes deviate from this system and go freestyle if I see an obviously nicer solution. I used to use a purely freestyle system, solving 2 or more edges each time - but this led to too much thinking and not enough time solving. With a set system, you know each step and what to do each time without having to think about it, and you can automatically execute.

The general idea is; solve an edge pair with the first algorithm (this means pairing it and inserting it to the correct slot), solve another edge pair with the second algorithm (opposite or adjacent), and solve the last two edge groups in a single algorithm. There are only 24 different configurations for the last two edges and it's really worth learning how to solve each of them. Most of the 24 configurations are algorithms you will likely already know, you'll just need to learn things like the 4-cycles.

I've listed a set of algorithms that will help you understand how solving the first and second edges should be accomplished, after that I have listed general purpose algorithms for you to deploy at any stage in this step. Some are simply listed for completeness, as you can sometimes solve a 2x2-cycle faster by using 2 3-cycles. Not every case will be documented, but you should be able to solve cases that are not with the tricks shown in documented cases.

There's a document created by Christopher Mowla here that lists all the 3-cycles and how they're related.

Of course, I haven't listed every case. Discovery is half the fun! If you find a case you can't seem to solve, drop me an email or hop on IRC and I'll help you out.

The following algorithms are written in commutator or conjugate notation. With this notation, [X,Y] translates to XYX'Y', and [X:Y] translates to XYX'.

NOTE: [A:B] [C:B'] = A B A' C B' C' = [C: [C' A, B]]

If you would like to view the algorithms presented without commutator notation, please click here.

First/Second Edge Tricks;
[r': [r l, R' U' R U]] [l': [r l, R U R' U']]
[F' R u2 R' F, U] [B2 l2: [M2, R' U' R U]]
[F' R d2 R' F, U] [B2 r2: [M2, R' U' R U]]
y [F2 r2: [M2, D R2 D']] y [F2 l2: [M2, D R2 D']]
y [r': [r l, F R' F']] y [l: [r' l', F R' F']]
y [r': [r l, R' U' R U]] y [F2 l2: [M2, F' R' F]]
y [l: [l' r', R' U' R U]] y [F2 r2: [M2, F' R' F]]
3 Cycles;
[R U R' U', r] [r, R U R' U']
[L' U' L U, l'] [l', L' U' L U]
[R U R' U', l'] [l', R U R' U']
[R' U' R U, l] [l, R' U' R U]
[F2: [l2, F' R' F]]
[R2: [U2, r' D' r]]
[x D2: [r2, U R' U']]
[F2: [F' R' F, l2]]
[R2: [r' D' r, U2]]
[x D2: [U R' U', r2]]
[F2: [r2, F' R' F]]
[R2: [U2, l D' l']]
[F2: [F' R' F, r2]]
[R2: [l D' l', U2]]
[x2 F2: [U' R2 U, r2]]
[r': [U', l' D2 l]]
y [F': [R' u' R, U2]]
[x2 F2: [r2, U' R2 U]]
[r': [l' D2 l, U']]
y [F': [U2, R' u' R]]
[F2: [r2, R2 U R2 U']]
[l: [r D2 r', U']]
y [F: [L u L', U2]]
[F2: [R2 U R2 U', r2]]
[l: [U', r D2 r']]
y [F: [U2, L u L']]
[l, U' R U x U R2 U']
[U2: [r, U2 l' U2 l U2]]
[l': [U2, r' D2 r]]
[U' R U x U R2 U', l]
[U2: [U2 l' U2 l U2, r]]
[l': [r' D2 r, U2]]
[U' R U x U R2 U', r']
[U2: [U2 r U2 r' U2, l']]
[r: [l D2 l', U2]]
[r', U' R U x U R2 U']
[U2: [l', U2 r U2 r' U2]]
[r: [U2, l D2 l']]
[Rw2 U2: [U R2 U', r']]
[Rw' U2: [U R U', r2]]
[r2: [U, l D2 l']]
[Rw2 U2: [r', U R2 U']]
[Rw' U2: [r2, U R U']]
[r2: [l D2 l', U]]
[Lw2 U2: [l, U' L2 U]]
[Lw U2: [l2, U' L' U]]
[l2: [r' D2 r, U']]
[Lw2 U2: [U' L2 U, l]]
[Lw U2: [U' L' U, l2]]
[l2: [U', r' D2 r]]
[Lw2: [r' D2 r, U]] [Lw2: [U, r' D2 r]]
[Rw2: [l D2 l', U']] [Rw2: [U', l D2 l']]
2x2 Cycles;
(Rw2 B2 Rw2' U)2
[l r D2 l' r', U]
(Rw2' F2 Rw2 U')2
[r' l' D2 l r, U]
[r' U' l' D2 l U r, U2] [l U' r D2 r' U l', U2]
r2 U2 r2 Uw2 r2 u2
[Rw2 Fw2 U2: r2]
[Uw2 Rw2 U2: r2]
[Lw F' R' F Lw': r2 U2 r2 Uw2 r2 u2]
[l2 D' R2 D: U2 l2 Uw2 l2 u2 l2]
[Lw2 D' R2 D: Fw2 U2 l2 U2 Fw2]
R' U2 R2 U R' U' R' U2 (RM') U R U' (R'M) M'UM'UM'U2MUMUMU2
(M'U)4 (UM')4
[b: [l r D2 l' r', U]]
[b: [R L u2 R' L', U]]
l' R U2 R2 U' R U R U2 (R'M) U' R' U Rw
[f': [l' r' D2 l r, U]]
[f': [R' L' u2 R L, U]]
l R' U2 R2 U R' U' R' U2 (RM') U R U' Rw'
[f': [r' U' l' D2 l U r, U2]] [b: [l U' r D2 r' U l', U2]]
[Bw B r': [l r D2 l' r', U]] [Bw B r': [l U' r D2 r' U l', U2]]
[S' y2: [F' R u2 R' F, U]]
[S' U': [F' R u2 R' F, U']]
[F' R u2 R' F, U] [F' R d2 R' F, U]
2 Cycles;
rU2rU2xU2rU2l'x'U2lU2r2 l'U2l'U2xU2l'U2rx'U2r'U2l2
r'U2xlU2l'U2x'r2U2rU2r'U2F2r2F2 rU2r'U2r'U2lU2r'U2rU2F2r2F2l'
4 Cycles;
r2B2r'U2r'U2B2r'B2rB2r'B2r2B2 l2F2l'U2l'U2F2l'F2lF2l'F2l2F2
rU2r2U2r'U2rU2r'U2r2U2r r'U2r2U2rU2r'U2rU2r2U2r'
rU2l'U2rU2rU2r'U2rU2r2U2lr'U2r' rU2rl'U2r2U2r'U2rU2r'U2r'U2lU2r'