# Navi Speedsolving Method



## elrog (May 20, 2014)

I finally got some free time again now that it is summer. The first thing on my to do list (cubing wise) was to finish finding the algorithms for this method. Now that this is done, I have reposted this from the The New Method / Substep / Concept Idea Thread. The method is named after the fairy in the Zelda games. Enjoy!

My "theory" behind this method is to exploit the small algorithm sets the same way that OCLL/PLL is so much better than ZBLL. This method utilizes a total of 86 (21 mirrors) algorithms including algorithms used throughout the F2L. A few of the algorithms can be done intuitively. The largest single algorithm set is 33 (9+24) algorithms, so recall shouldn't be a problem. You can learn subsets of the algorithms and still be able to solve the cube, which helps people learn the method. I'd say this method is not the easiest method to learn, but its not too difficult. With practice, the first step and possibly the second can be planned out during inspection.

Here is a step by step description of the method.
- Pictures that go along with the explanations were created using VisualCube.


Spoiler: The Method



*Step 1:* D-Block






Solve a 1x2x3 block on the D face and position it so that the R slice is free. This could also be done on the left side with the U-layer free. If you use the left side, your first two layers would be the left 2 layers.

*Step 2:* 2EE





Solve two adjacent E-layer edges using U, Uw, R, and possibly E moves and position them to create a 2x2x3 block or a pseudo 2x2x3. You may also influence the next step by orienting the last D-layer edge, or matching it with one of its corners. You may do this influencing during step one if you see the chance.

*Step 3:* D-Pair





Solve the missing D-layer edge and one of the missing D-layer corners. Keep in mind that you will want to have the still unsolved corner slot in the FRD position for orientation and permutation algorithms. Assuming you don't favor doing the BRD corner first, which you should, you have a 25% chance of having to do a y rotation to get the unsolved corner in the FRD position. Don't go out of your way too much to avoid a rotation though, because F moves are arguably worse. You can also try to avoid bad E-layer edge positions.

*Step 4:* EELS





Keyhole one of the missing E-layer edges in using ELS to orient top layer edges. You count the last E-layer edge as good or bad depending on the one in its place or depending on if you have an even/odd number of bad/good edges. This step uses 21 algs (8 mirrors). Some of these can be done intuitively.

You may run into some situations that you cannot simply do an ELS algorithm. This is either because both E-layer edges are oriented incorrectly in their correct position, or the 2 unsolved E-layer edges are in each others correct positions. If you run into the first case, just orient as many of the edges as you can while solving one of the E-layer edges and use one of 3 (1 of this will be your ELS algorithm for that case) algorithms in step 5 that deal with this situation. If you end up with the second case, you can simply move one of the edges into the top layer and influence the ELS case you'll get afterwards, or you can use an algorithm for that specific case which is included in the Extra algorithms listed with the ELS algorithms.

*Step 5:* LEEP





Keyhole in the last E-layer edge and phase the U-layer edges (make opposite edges opposite of each other). This step takes 9 (3 mirrors) algorithms. 6 are used when the edge is in the top layer, 1 is used when the last E-edge is solved, and the 3 mentioned in step 4 also must be counted (Remember that one of these will be your ELS alg for that case). All of these can be done intuitively except for the 3 mentioned in step 4.

*Step 6:* O5C





Orient the last 5 corners. This step can be recognized by the orientation of the top 4 corners (looking at the bottom corner isn't necessary), but there are some cases where you have to look at the left or back side of the cube. If you do look at the corner in the slot only for these cases, looking at the left or back side is never necessary. This step takes 23 algs. 7 are OCLLs and it takes 8 more algs and their mirrors.

*Step 7:* PLL+C





Place the D layer corner and permute the top layer. This takes 33 algorithms. 9 are PLLs (2 mirrors), and 24 (6 mirrors.) are without the last D corner in place.

--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------

I chose to build the F2L this way because it saves moves, yet still sustains good look ahead and a decent move-set. You may build the F2L minus one slot with edges oriented any way you want, but this is what I think the most efficient way is for speed (balancing move count with TPS). You can solve the 1x2x3 block on the left to do an easier x rotation instead of a y rotation after step 3, but the transition to the last layer requires rotation(s) unless you learn the algorithms from this angle.

With all other speedsolving methods I know of, cubers learn extra algorithms to help out in certain cases. I have generated what I believe are the most useful extra algorithms to learn. With this method, it would be recommended, but not necessary, to learn 17 (4 mirrors) extra algorithms. 8 (1 mirror) of these algorithms orient the top layer edges while phasing just in case you end up with your edges already solved in the E layer. You should already know 3 of the 8 if you know ELS. 6 (there are 12 cases, but 6 of them are not worth it) of the algorithms orient the edges while swapping one of the E layer edges to the other remaining E slot. Note that you may end up with the last E-layer edge being placed misoriented, but you should already know algorithms for this from step 5. The last 6 (3 mirrors) algorithms place the last E edge while phasing and preserving the orientation of the comers in case they end up oriented.

Pros - Low average movecount for a speedsolving method. No large algorithm sets. Can be broken down easily making it suitable for beginners to learn.
Cons - Uses F moves in the F2L. Occasionally requires a rotation.



Here are some example solves.
- Scrambles for this section were generated using qqtimer.


Spoiler: Example Solves



Example solve 1:


Spoiler



Scramble: L2 U2 R2 U2 F' D2 F L2 B' F D F2 L' B2 D2 U' L' D F'

(y) D2' L2' F2' u2 B' // D-Block
U R u' R' u2 // 2EE
R' U R' U' R U' R // D-Pair
u R U2 R' u' // EELS
F' U2 F // LEEP
(u U x) R' U R D' R' U' R D (x')// O5C
(U2) (R U' R' U) R U' R2' F2 R2 U' R' U' R U R' F2 (U2)// PLL+C


 Example solve 2:


Spoiler



Scramble: U2 F2 U2 B L2 U2 B' L2 B L2 F' U L R B2 U' B2 U' B2 L2

(y) F2 B' D L' F L' // D-Block
R U R u' R U2 R' u2 // 2EE
U R2 U R2 // D-Pair
R' F R F' u // EELS
F' U F u2 // LEEP
R' U L U' R U L' // O5C
(U' y') R U R2' U R U' R2 U' R' F R2 U R2' U' F' (U')// PLL+C


 Example solve 3:


Spoiler



Scramble: L D' R L2 D R2 L B D B D2 F R2 D2 B2 U2 B R2 B' L2

// D-Block
// 2EE
// D-Pair
// EELS
// LEEP
// Orientation of Corners
// PLL+C


 Example solve 4:


Spoiler



Scramble: L2 F2 U2 R2 F' L2 B' D2 B R2 F R U B' D' L B' R' U' L2 B2

// D-Block
// 2EE
// D-Pair
// EELS
// LEEP
// O5C
// PLL+C


 Example solve 5:


Spoiler



Scramble: F2 R2 D2 L2 D' L2 D' B2 U B2 U2 R B2 R2 D' F L2 D U2 L2

// D-Block
// 2EE
// D-Pair
// EELS
// LEEP
// O5C
// PLL+C






Algorithms for each step can be found here.


Spoiler: Algorithms



Normally people would use that have something like (y R' U R) instead of (F' U F) if they were a CFOP solver, but you can't effectively do (y) rotations with this method because you have a corner unsolved in the bottom that needs to stay in a certain position. So don't learn the algorithms that way. This doesn't matter for the last step though, because you'll solve the cube anyway.

Here are the 21 (8 mirrors) ELS algorithms along with 12 extra algorithms for cases with the E layer edges placed in the slot where the other E layer edge goes.
- I got pictures for each ELS case from Lucas Garron's MGLS-ELS Algs page.
- I created images for the Extra algorithms in this section using VisualCube.


Spoiler: ELS Algorithms + Extras






Spoiler: ELS Algorithms



Case 1:


Spoiler: Er








F U R U' R' F'
F R' F' R U R U' R'
U' M' U' M U2 M' U' M


 Case 2:


Spoiler: Tree








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


 Case 3:


Spoiler: Dot








R U2' R2 F R F' U2' R' F R F'
(y) r U r' U2 r U2 R' U2 R U' r'


 Case 4:


Spoiler: Yi








(U') R U R' F R' F' R
R U' R' F' U2 F


 Case 5:


Spoiler: San








l' U R U2' r' U' L F
(U) R' F R F' U' R' F R F'


 Case 6:


Spoiler: Right Fang








(U') F' U' F


 Case 7:


Spoiler: Left Graw








F R' F' R


 Case 8:


Spoiler: Left Dmr








(U') l U F U' l'


 Case 9:


Spoiler: Right Sling








(U) R' F R F2' U' F


 Case 10:


Spoiler: Left Karp








(U') F R' F' R2 U' R'


 Case 11:


Spoiler: Right Shren








(U) F' L' U' L U' F


 Case 12:


Spoiler: Right Eko








R' F R F' R U2 R2' F R F'
U2 R' F R F2' U2 F


 Case 13:


Spoiler: Left Link








r U r' U2 M' U M


 Case 14:


Spoiler: Left Fang








(U') R U R'


 Case 15:


Spoiler: Right Graw








l' U l F'


 Case 16:


Spoiler: Right Dmr








(U) F' L' U' L F


 Case 17:


Spoiler: Left Sling








R U' R2' F R F'


 Case 18:


Spoiler: Right Karp








R U R2' F R F'


 Case 19:


Spoiler: Left Shren








(U') l U F U' F L'


 Case 20:


Spoiler: Left Eko








R U2' R2' F R F'


 Case 21:


Spoiler: Right Link








(U2) R' F R F' U2 R' F R F'








Spoiler: Extras: NK



I did not show which edge is the other E-Layer edge because it's permutation doesn't matter while its orientation does. 

I have not been able to find good algorithms for cases 2, 3, 6, 8, 9, and 12. If I (or anyone else) finds decent algorithms, I will add them. I would recommend that you convert these cases into whatever ELS case works best for you (assuming it is easily reachable from the current state).

Case 1:


Spoiler








R2 U R2' U' R2


 Case 2:


Spoiler










 Case 3:


Spoiler










 Case 4:


Spoiler








(x) R U R2 U' R' (x')


 Case 5:


Spoiler








R' F R F' u R U2 R' u'


 Case 6:


Spoiler










 Case 7:


Spoiler








R U2 R' u R U R' u'


 Case 8:


Spoiler










 Case 9:


Spoiler










 Case 10:


Spoiler








F R' F' R u R U' R' u'


 Case 11:


Spoiler








(U') R U' R' u R' F R F' u'
(U2) R U F R' F' R'


 Case 12:


Spoiler

















Here are the 10 (one algorithm will be an ELS algorithm and 3 are mirrors) algorithms for Step 5 along with 14 other algorithms. 8 of these 14 are used in cases when you end up having the E-layer solved and the other 6 (3 mirrors) algorithms are used for cases when everything ends up being oriented correctly.
- I created pictures for the algorithms in this section using VisualCube.


Spoiler: LEEP + Extras






Spoiler: LEEP



Please note that you only need the get opposite U-layer edges opposite of each other. You do not need to fully solve the U-layer edges. Because of this, opposite colors are counted as the same color.

Case 1:


Spoiler








R' U' R U' R' U2 R


 Case 2:


Spoiler








R U2' R'


 Case 3:


Spoiler








(U) R U R'


 Case 4:


Spoiler








(U') R U' R'


 Case 5:


Spoiler








F' U2 F


 Case 6:


Spoiler








(U') F' U' F


 Case 7:


Spoiler








(U) F' U F


 Case 8:


Spoiler








(U') R' F R F' R U' R'
(U) l U' R U l' U R'


 Case 9:


Spoiler








(U) R U' R' U2 F R' F' R


 Case 10:


Spoiler








(U') R' F R F' U R U2 R'








Spoiler: Extras: EOP and Orph






Spoiler: Solved E-Layer Cases - EOP



The unsolved corner should be in the FRD position.
Please note that you will know 3 (or 4 if you know the mirror case) of these if you know ELS.

Case 1:


Spoiler








F' U L' U2 L U' F
M' U M' U M' U2 M U M U M


 Case 2:


Spoiler








R U2' R2' F R F' U2 R' F R F'
M' U2 M U2 M' U M U2 M' U2 M
(M' U)4 (M U)4


 Case 3:


Spoiler








(U2) M' U M U2 M' U M
(U') R U2' R' U2 R' F R F'
(U') M (U' R U R') M'


 Case 4:


Spoiler








F (U R U' R') F'


 Case 5:


Spoiler








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


 Case 6:


Spoiler








F (R U R' U') F'


 Case 7:


Spoiler








F' (L' U' L U) F


 Case 8:


Spoiler








l U r U r' F U' F2 l'








Spoiler: Fully Oriented Cases - Orph



This is meant to be used for cases when you corners end up being oriented before phasing. These algorithm preserve corner permutation as well as orientation, so this gives you a hint at what your PLL+C algorithm will be.

Please note that you only need the get opposite U-layer edges opposite of each other. You do not need to fully solve the U-layer edges. Because of this, opposite colors are counted as the same color.

Case 1:


Spoiler








R' U' R' U' R2 U R U R


 Case 2:


Spoiler








R' U' R' U' R' U R U R


 Case 3:


Spoiler








R' U' R' U' R U R U R


 Case 4:


Spoiler








(u') R U R U R2 U' R' U' R'


 Case 5:


Spoiler








(u') R U R U R U' R' U' R'


 Case 6:


Spoiler








(u') R U R U R' U' R' U' R'












Here are the 23 (8 mirrors) Orientation algorithms. I found most by hand, so they're not optimal.
- I created pictures for the algorithms in this section using VisualCube.


Spoiler: O5C



The unsolved corner which is not shown should be the FRD corner (excluding OCLL cases of course).

You can influence the permutation algorithm you will end up with by AUFing differently for cases that have symmetry in the U-layers corner orientation. A good example of this would be cases 22 and 23. 

Case 1:


Spoiler: Headlights








(R U R' U')3
(U2) R2 D R' U2 R D' R' U2 R'


 Case 2:


Spoiler: T








(R U2' R' U2)3
(U' x') R U R' D R U' R' D'
r U R' U' r' F R F'


 Case 3:


Spoiler: Bowtie








R' F R B' R' F' R B
R' F R U R U' R' F' R U R'
(U2) R U2 R' U' (R U R' U')2 R U R'
(U) F' r U R' U' r' F R


 Case 4:


Spoiler: H








F (R U R' U')3 F'


 Case 5:


Spoiler: Pi








(R U R' U') R' U2 (R U R') U R2 U2 R'
(U) F U (R U' R' U) R U2 R' U' R U R' F'
(U') (R U R') U2 R U2 R' U R U2 R'


 Case 6:


Spoiler: Sune








R U' L' U R' U' L
l F' L' F l' U' L


 Case 7:


Spoiler: Anti Sune








L' U R U' L U R'
r' F R F' r U R'


 Case 8:


Spoiler: Left Twister








R2 U' L' U R' U' L U R'
R U R' U R U' R' U2 R U R'


 Case 9:


Spoiler: Right Twister








R U' L' U R U' L U R2


 Case 10:


Spoiler: Left Ape








(x) R U' L' U R' U' L U' (x')
R' U2 R2 U2 R U2 R U2 R2 U2 R' U2 R


 Case 11:


Spoiler: Right Ape








(x) (R2 U L2 U')2 (x')
(U2) R U' R' U (R U R' U) R U' R'


 Case 12:


Spoiler: Right Arc








L U' R U L' U' R'
R U R' U2 R U' R' U R U R'


 Case 13:


Spoiler: Left Arc








R U L U' R' U L'
(U') R U' R' U' R U R' U2 R U' R'


 Case 14:


Spoiler: Left Alpha








R U' R' U' R U2 R2 U2 R U R' U R
R2 U2 R2 U' R U R U2 R' U R'


 Case 15:


Spoiler: Right Alpha








R U' R' U2 R U2 R' U' R U2 R'


 Case 16:


Spoiler: Left Star








R U2' R' U R U' R' U' R U' R'


 Case 17:


Spoiler: Right Star








(R U R') U (R U R') U' R U2 R'


 Case 18:


Spoiler: Left Zora








R U2 R' U' R U2 R' U2 R U' R'
F' (L F' L' F)3 F


 Case 19:


Spoiler: Right Zora








l (U' R U R')3 l'
(U') R2 U2 R' U R2 U2 R U' R' U2 R2 U R


 Case 20:


Spoiler: Right R








R' U R2 U R U' R U R U2 R
R' U2 R' U' R' U R' U' R2 U' R


 Case 21:


Spoiler: Left R








F U2 L F' L' U2 R' F' R
(U2) R' F R U2' L F L' U2 F'
(U') R' U2 R U2' F' U2 R' U2 R F
(U) R U2 R' U R U2 R' U2 R U R'


 Case 22:


Spoiler: Left Pinwheel








R U' R' U' R U' R' U R U2 R'


 Case 23:


Spoiler: Right Pinwheel








R U2 R2 U2 (R U R') U R2 U' R'






Here are the 33 (8 mirrors) Permutation Algorithms. 9 (2 mirrors) are PLLs, while the other 24 (6 mirrors) are PLLs plus one corner (PLL+C).
- I created pictures for the algorithms in this section using VisualCube.


Spoiler: Permutation Algorithms






Spoiler: PLL Algorithms



Case 1:


Spoiler: H-Perm








M2' U M2' U2 M2' U M2'
R2 U2 R U2 R2 U2 R2 U2 R U2 R2


 Case 2:


Spoiler: Z-Perm








M2' U M2' U M' U2 M2' U2 M'
(U) M2' U' M2' U' M' U2' M2' U2' M'


 Case 3:


Spoiler: A-Perm:a








(x') R' D R' U2 R D' R' U2 R2 (x)
(U') r U r' U' r' F r2 U' r' U' r U r' F' U


 Case 4:


Spoiler: A-Perm:b








(x) R D' R U2 R' D R U2 R2 (x')
(U') l' U' l U l F' l2 U l U l' U' l F


 Case 5:


Spoiler: E-Perm








(U x') R U' R' D R U R' D' R U R' D R U' R' D' (x)
R2 U R' U' (y) (R U R' U')2 R U R' (y') R U' R2'


 Case 6:


Spoiler: F-Perm








R' U R U' R2 F' U' F U R F R' F' R2 U'
(U2) R' U2 R' d' R' F' R2 U' R' U R' F R U' F


 Case 7:


Spoiler: N-Perm:a








(L U' R U2 L' U R')2 U'
(z) (U R' D R2 U' R D')2 (z')


 Case 8:


Spoiler: N-Perm:b








(R' U L' U2 R U' L)2 U
(z) (D' R U' R2' D R' U)2 (z')


 Case 9:


Spoiler: T-Perm








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








Spoiler: PLL+C Algorithms



The unsolved corner which is not shown should be in the FRD position.

If an algorithm has a (x) or (z) rotation at the beggining, but does not undo the rotation at the end so you can AUF, it is indicating that you perform the AUF from that orientation of the cube.


Case 1:


Spoiler








(U2) F2' (L' U' L U) L F' L2 U L U L' U' L F'
(U2 y) l' L' U' L2 F2' l' F' l F2' L' U l


 Case 2:


Spoiler








(R U R' U R U R' U2')2


 Case 3:


Spoiler








(y')(R' U' R U' R' U' R U2)2


 Case 4:


Spoiler








(R' F R F')3


 Case 5:


Spoiler








(U2 y') R U R2' U R U' R2 U' R' F R2 U R2' U' F'
(U) R2 U R2 U R2 U2' R2 U y' R2 U' R2 U'R2 U2 R2 U'
(U) R2 U R2 U R2 U2 R2 D R2 U' R2 U' R2 U2 R2 D'
(U) R2 U R2 U' R2 D R2 U2 R2 U R2 U' R2 U2 R2 D'


 Case 6:


Spoiler








L U y' R2 U' R2' F' R U R2 U R' U' R2 U' R'
(U) R2 U R2 U' R2 U2 R2 U2 R U L' U2 R U' R' U2 R' L


 Case 7:


Spoiler








(U2 z') R' D2 R U2 R' D2 R U2
(U') R' F' L F R2 F' L' F R'
(U2 x') R2 U L U' R2 U L' U' (x)


 Case 8:


Spoiler








R U2 y' l U l' U l U2' l' U' l U' R' F2 U' (x)
R2' L U' R2 U L' U R' U2 R' U2 R' U' R2 U' R U2 R'
R' U' R' F2 U R U2 F2 U2 R' U' F2 R U R
(U2) R D' R U R' U2 R U2 R' D R2 U' R U R


 Case 9:


Spoiler








(U')(R U' R' U) R U2 R' (U' R U R')


 Case 10:


Spoiler








(U y')(R' U R U') R' U2 R (U R' U' R)


 Case 11:


Spoiler








(U2 x') R2 U2' R' U R' F' R2 U2' L' U' M' R'
(U2)(R' U R U') R U' R U' R U R' L' U R' U' L
(U) L' U R U R2 U' R2 U2 R L U R2 U2 R' U R' U' R'
R' F2 R2 F R' U2 R U2 F' U2 R' U2 R' F2 R


 Case 12:


Spoiler








(U2) R U2' R' U2 R U' R' U2 R2 D R' U2 R D' R2


 Case 13:


Spoiler








(U' z') U2 R' D2 R U2' R' D2 R
(U' x') U L U' R2 U L' U' R2 (x)


 Case 14:


Spoiler








(U)(R U' R' U) R U' R2' F2 R2 U' R' U' R U R' F2
(R' F R F')2 L F' M' U' R U L' r'
(F R' F' R) L F' L' U2 L2 F2' L' F' L F' L2


 Case 15:


Spoiler








(U y') R2 U' R2 U R2 U2' R2 U' R2 U R2
(y')(R' U R' U' R U R) U2 (R' U' R' U R U' R)
R2' F2 U' R L F2' R' L' U F2 R2


 Case 16:


Spoiler








(U') R2 U R2' U' R2 U2' R2' U R2 U' R2'
(R U' R U R' U' R') U2 (R U R U' R' U R')


 Case 17:


Spoiler








R2 U2 (R2 U')3 y L2 U2 (L2 U)3
(U2) M R U L U2 R2' F R U' R U2' R2' (x)
(U' z') U' L U2 L' U' L' U2 R' U' R U' R' U' L2 U' R
(U) L' U R U' L R U' (R' U)3 (R' U' R U)


 Case 18:


Spoiler








R2 D R' U2 R D' R2' U2' R U R' U2' R U2 R'


 Case 19:


Spoiler








(z) U' R2' U R D2 R'U' R D2 R U
(x) R' U2 L U R2 U' L' U R2 U R (x')
(U') L' U2 R U2 L U2 L' U2 R' U2 L
(U') l' U2 R U2' l U2 R' F2 R' F2 R


 Case 20:


Spoiler








(R U R' U') R U L' U (R' U R U') R' U2 L


 Case 21:


Spoiler








L' U' L U' R2 U2' R2' U L' U L U R2 U' R2
(U2 y')(R' U' R U) R' F2 U (R U R' U') R' U' F2 U R2


 Case 22:


Spoiler








(y')(R' U R U)2 R' U' (R U R' U)2 R
(y') R' U R2 U2' R U' R U R' U2 R2 U' R


 Case 23:


Spoiler








R U' R2 U2 R' U R' U' R U2 R2 U R'


 Case 24:


Spoiler








(U2) r R U R2' F2 r F r' F2 R U' r'
(U2) R2 y (R U R' U') R' F R2 U' R' U' R U R' F












Here's an explanation of how to solve the cube using less algorithms for beginners to the method.


Spoiler: Where To Start






Spoiler: Beginners to Speedsolving



This section if not finished yet.

Before you begin learning Navi, you should know the beginners method and know how to keyhole. If your having trouble getting started, here is a blockbuilding tutorial:
Donovan's Roux Tutorial (Part 1/5) Left Block
The video is meant for the Roux method, so he shows you how to build the block on the left side. You need to do it on the bottom, but its pretty much the same thing. You should be able to make it to step 4 from here.

Rather than doing ELS for step 4, your going to do keyholing. Here is a keyholing tutorial:
How to do Keyhole Method for Beginners
Keep in mind that you will keyhole in the last edge and leave the last corner blank, rather than solving the corner and then using an algorithm for the last edge as show in the video.

If you understand the concepts very well, you can try intuitively doing ELS. If you manage to do this, have a look at the Experienced Speedsolvers section and come back here to continue this path if you can't do the Experienced path yet. If that is just to far out of your reach at the moment, just keyhole in the remaining 2 edges.

You should then orient the edges using 3 algorithms that you probably learned in the beginners method. If you did not learn them, learn the first 3 cases listed under "ELS Algorithms" in this post. They are pretty much the same thing as the edge orientation algorithms used in the most common beginners method.

Now, you should phase the edges (get the opposite top layer edges opposite of each other) using the first algorithm listed under "Step 5 Algorithms" in this post.

Now you should learn the 7 OCLL algorithms if you do not know them already. They are the first 7 algorithms listed under "Orientation Algorithms" in this post. If you do know them already, check if they retain the phasing and learn the OCLL algorithms in this post for the cases that don't, if any. Using these 7 algorithms, you should always be able to do one of them and end up with no more than one corner in the top layer misoriented. You will then have one of the two Ape Corner orientation algorithms (or everything might already be oriented), which you can learn from this post. 

You now need to learn any one of the PLL+C algorithms to place the last D layer corner. I used (x) (R' U R U')3 (x'). Now you should learn both of the A-perm and one of the N-perm PLLs to solve the top layer corners. And finally, learn the Z-perm, and H-perm to solve the cube if it is not already.

Learning more algorithms can drastically decrease your times by eliminating the number of times you have to do algorithms. Don't be scared away by the number of algorithms, because learning algorithms is not hard, it just takes time. You should learn algorithms gradually at a consistent pace. If you want to learn more, You should start by learning the rest of the 7 PLLs listed in this post. Following those, you should learn more ELS algorithms or try learning to do ELS intuitively. You should start using ELS to place the last E-layer Edge when you get a case you know so you don't have to orient the edges afterwards. After you learn all of ELS, learn the "Step 5 Algorithms" and start using ELS on the second to last E-layer Edge. These should be followed by the rest of the orientation algorithms and then the rest of the PLL+C algorithms.





Spoiler: Experienced Speedsolvers



You should be able to get to step 4 with no problems. You should be able to do ELS intuitively and just go back to refine cases later, just as you would do for F2L. You should also be able to phase intuitively, as this is very easy. You probably already know OCLL, so you should just do that to create an Ape case, and just learn both of those. You might want to check if your OCLL algorithms disturb the phasing or not, and if they do, learn the OCLL algorithms in this post for those cases. You can then learn a single PLL+C to do to insert the D corner {I began using (x) (R' U R U')3 (X') } and finish the solve with PLL. You may then gradually learn the rest of the Orientation algorithms and PLL+C algorithms, and maybe eventually, the extras.






You can find out what the acronyms stand for here.


Spoiler: Acronyms



*Navi:* The name of the method; didn't you read the title?

*D-Block:* The 1x2x3 block on the D-layer that you build in step 1.

*2EE:* Two E-layer Edges that are placed in step 2.

*D-Pair:* The last D edge paired with a D corner that you place in step 3.

*EELS:* Early ELS (Edge of the Last Slot) which is really no different than ELS except for where it is done in the solve. This is used in step 4.

*LEEP:* Last E edge and phasing which is done in step 5.

*O5C:* Orient the last 5 corners which is done in step 6.

*PLL+C:* PLL (Permute Last Layer) plus a corner as done in step 7.

*NK:* No keyhole. This just describes the situation where this alg set is used. This is what I named it because you can't keyhole an edge in if they are both in the E layer already.

*EOP:* Edge orientation and phasing which is pretty self explanatory.

*Orph:* Orientated phasing. I didn't capitalize the P because I didn't like how it looked .

The ELS algorithms which are left have the edge that is in the slot oriented so that the top color is on the left, and the right is the same thing, just on the right.

The O5C algorithms which are left have the DRF corner with the top color on front, while the right ones have the corner in DRF with the top color on the right.

I named the individual cases mostly at random, so don't ask why it looks like an ape.


 Thanks to Cride5 for creating VisualCube, and to Lucas Garron for creating alg.garron.us and making it *so* easy to use on the forums.

If you find anymore algorithms that are good or better than these, or if one of these doesn't work, please notify me.

I do plan to eventually make algorithms for solving with the first block on the left throughout the solve, and algorithms to orient the corners before phasing in case you prefer to do the Orph cases rather than the standard phasing. You may also just decide to do this when you get a phasing case that an F move shows up.


----------



## Kirjava (May 20, 2014)

Basically, this boils down to the cost of not solving an edge in the F2L adding an extra step to solve.

Cases will deal with less variance, but movecount will worsen.

The state of method development at the moment is such that any sufficiently thought out method of the form of solving groups of permutation and orientation in a variety of ways can perform as well as it's brethren with minor positives and negatives depending on changes, until something more abstract comes out.


----------



## elrog (May 20, 2014)

Kirjava said:


> Basically, this boils down to the cost of not solving an edge in the F2L adding an extra step to solve.
> 
> Cases will deal with less variance, but movecount will worsen.
> 
> The state of method development at the moment is such that any sufficiently thought out method of the form of solving groups of permutation and orientation in a variety of ways can perform as well as it's brethren with minor positives and negatives depending on changes, until something more abstract comes out.



I don't think steps in a method really matter so much because you could break a method up into many steps or just a few depending on how you define them. And I've already pointed out that OCLL/PLL is just more practical than ZBLL despite having another step.

Also, my movecount for the F2L turned out pretty good. The PLL+C algorithms are a little longer though, but as it has been said before, added move in algorithms don't matter as much as added intuitive moves. Check out the first two example solves. I was eager to post and have not gotten around to the rest yet.

Yes, your right. There's no method better than any other as long as both are thought out well, unless something radical is done. I did not make this method thinking it would beat every other method out there. Its just another option.


----------



## Kirjava (May 20, 2014)

elrog said:


> I don't think steps in a method really matter so much because you could break a method up into many steps or just a few depending on how you define them. And I've already pointed out that OCLL/PLL is just more practical than ZBLL despite having another step.



Method steps are quite important because they change look and alg quantity.



elrog said:


> Also, my movecount for the F2L turned out pretty good. The PLL+C algorithms are a little longer though, but as it has been said before, added move in algorithms don't matter as much as added intuitive moves. Check out the first two example solves. I was eager to post and have not gotten around to the rest yet.



Two example solves are a terrible representation of average movecount. Regardless; the movecounts in them are comparatively quite average.



elrog said:


> Yes, your right. There's no method better than any other as long as both are thought out well, unless something radical is done. I did not make this method thinking it would beat every other method out there. Its just another option.



One thing that I should have mentioned is that there's nothing wrong with trying to find a good balance of attributes - especially since people have different preferences.


----------



## elrog (May 20, 2014)

I think the order that a method solves pieces of the cube is important, but how many steps you break it up into is not. One could say that in CFOP the F2L is actually 4 steps because each slot is a new look. But these steps are small and you can influence the next step while doing them. How you define the steps doesn't change the method, so saying I've just added another step, doesn't mean much.

If you'd like to count up how many looks this has compared to other methods and weight the looks by how many pieces they effect, then be my guest.


----------



## stoic (May 20, 2014)

Elrog, just wondering what sort of times you've got with this method, and how that compares to your usual?
Have you learnt enough for it to be representative?


----------



## Kirjava (May 20, 2014)

elrog said:


> I think the order that a method solves pieces of the cube is important, but how many steps you break it up into is not.



You're trying to trivialise a more complicated issue here. 

I was specifically referring to steps with algs and breaking them up into more steps will certainly change a method.

I didn't say you 'just added an extra step', it is far more nuanced.

I explained the tradeoff present in the modification from the norm that you have done, and the overhead caused by the advantages.

I'd appreciate it if you wouldn't just brush off my analysis.


----------



## elrog (May 20, 2014)

@ ellwd
I know I will probably get flak for this, but I have not practiced with the method much yet and I'm not sure if I will anytime soon. I have been busy searching for suitable algorithms the whole time and am moving on to another project now that I'm done. I average under 30 on the 3x3 with a best of 23 using CFOP with 2 look OLL and 1 look PLL. I am not to worried about being fast. I'm only where I am at from doing solves.

@ kirjava
I am aware that my algorithms will be longer on average if I restrict them more (pre-orientating edges and phasing), but I thought that it was worth the trade off for smaller algorithm sets. So far, there has not been any large algorithm set that has proved to be worth it. OLL and perhaps EG are the largest commonly used alg sets out there atm. I am not trying to blow you off, I have just already considered this.


----------



## Kirjava (May 20, 2014)

elrog said:


> I am aware that my algorithms will be longer on average if I restrict them more (pre-orientating edges and phasing), but I thought that it was worth the trade off for smaller algorithm sets. So far, there has not been any large algorithm set that has proved to be worth it. OLL and perhaps EG are the largest commonly used alg sets out there atm. I am not trying to blow you off, I have just already considered this.



This isn't even what I was talking about. The balance and trade off are just things i was commenting on neutrally. 

You can blow me if you really want though.


----------



## Shiv3r (Mar 30, 2016)

who thinks that this should have a speedsolving wiki page?


----------



## shadowslice e (Mar 30, 2016)

Shiv3r said:


> who thinks that this should have a speedsolving wiki page?



You can make one if you want. Don't expect too many people to use it though. I mean, pang has a page and look how many people use that.


----------



## Shiv3r (Mar 31, 2016)

Hey elrog, could you come up with some algorithm sheets for these? I mean, I could, but they would be crappy, and the colors on these don't come up very pretty when printed.
I think this method has potential, so i will try to make some good alg sheets, like a better recognition for LEEP or something. Will you help me?


----------



## 4Chan (Mar 31, 2016)

Whomever bumped this thread, THANK YOU.

You solves EVERY issue that's wrong with ZZ-HW
Instead of putting in the corner and orienting... putting in the edge and orienting the corners is only 27 cases and infinitely better.
The statistics for skips are the same, and the LL step is a 1LLL that's even simpler.


Guys, if you just do
EOLine
F2L-1
Insert edge and orient corners (27 algs, better than WV)
PLL+C

It's a pretty darn good method.


----------



## wir3sandfir3s (Mar 31, 2016)

4Chan said:


> Whomever bumped this thread, THANK YOU.
> 
> You solves EVERY issue that's wrong with ZZ-HW
> Instead of putting in the corner and orienting... putting in the edge and orienting the corners is only 27 cases and infinitely better.
> ...



Nice idea. This might make me actually get good at ZZ or even learn all the Algs for this method...


----------



## Shiv3r (Mar 31, 2016)

this might push Zz over the edge to becoming a sub-8 second method. Of course, this method could also probably reach 8 secs, but whatever.


----------



## Shiv3r (Mar 31, 2016)

How would you do the edge insert and orient corners in one alg? and where is this algset? I WANT IT!!!


----------



## shadowslice e (Mar 31, 2016)

Shiv3r said:


> How would you do the edge insert and orient corners in one alg? and where is this algset? I WANT IT!!!



[wiki]Winter Variation[/wiki] more or less
[wiki]SLS (Shadowslice last slot)[/wiki] would also useful


----------



## Shiv3r (Mar 31, 2016)

shadowslice e said:


> [wiki]Winter Variation[/wiki] more or less
> [wiki]SLS (Shadowslice last slot)[/wiki] would also useful


the problem with SLS is that you kinda destroy the f2l sometimes, right? how many algs?


----------



## Shiv3r (Mar 31, 2016)

yeah that would be good actually...


----------



## shadowslice e (Mar 31, 2016)

Shiv3r said:


> yeah that would be good actually...



I think you would have about 30, maybe slightly more because you don't have a guarenteed pair all the time.


----------



## Shiv3r (Mar 31, 2016)

shadowslice e said:


> I think you would have about 30, maybe slightly more because you don't have a guarenteed pair all the time.



but still doesn't it destroy the f2L? you dont want that...


----------



## shadowslice e (Mar 31, 2016)

Shiv3r said:


> but still doesn't it destroy the f2L? you dont want that...



Well, you could easily gen the algs anyway using cube explorer for the algs that don't destroy F2L


----------



## Cryoo (May 9, 2016)

I just made a example solve for the method with the third scramble : 

L D' R L2 D R2 L B D B D2 F R2 D2 B2 U2 B R2 B' L2

y2// inspection
F U' B2 R' U2 F2 U2 R U' R' D2// D-Block
u' R U R' u2'// 2EE
U' R2' U' R U' R2 D'// D-Pair
// EELS skip
U' F' U2' F// LEEP
R2 U2' R2' U' R U R U2 R' U R'// O5C
U2 z U' R2' U R D2 R' U' R D2 R U M// PLL+C


----------



## crafto22 (May 10, 2016)

Cryoo said:


> I just made a example solve for the method with the third scramble :
> 
> L D' R L2 D R2 L B D B D2 F R2 D2 B2 U2 B R2 B' L2
> 
> ...


Huh, so it seems that this could be like ZZ as oppose to CFOP. Not necessarily extremely efficient, but ergonomic for the most part, and seemingly good general execution. I'll have to check it out. The only thing I don't like is that nasty first step, it's sorta weird.


----------



## Shiv3r (May 10, 2016)

its just roux block.


----------



## crafto22 (May 11, 2016)

Shiv3r said:


> its just roux block.


I know but I don't use Roux specifically because of the block. I know others can easily solve a Roux block in inspection but I'd say as a CFOP user my blockbuilding skills aren't exactly on point. anyway, I have a new idea involving this method, l'll post about it after dinner.


----------

