elrog
Veteran
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.
Here are some example solves.
- Scrambles for this section were generated using qqtimer.
Algorithms for each step can be found here.
Here's an explanation of how to solve the cube using less algorithms for beginners to the method.
You can find out what the acronyms stand for here.
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.
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.
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.
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.
Example solve 1:
Example solve 2:
Example solve 3:
Example solve 4:
Example solve 5:
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
(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
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
(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
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
// D-Block
// 2EE
// D-Pair
// EELS
// LEEP
// Orientation of Corners
// PLL+C
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
// D-Block
// 2EE
// D-Pair
// EELS
// LEEP
// O5C
// PLL+C
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
// D-Block
// 2EE
// D-Pair
// EELS
// LEEP
// O5C
// PLL+C
Algorithms for each step can be found here.
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.
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.
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.
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.
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.
Case 1:
Case 2:
Case 3:
Case 4:
Case 5:
Case 6:
Case 7:
Case 8:
Case 9:
Case 10:
Case 11:
Case 12:
Case 13:
Case 14:
Case 15:
Case 16:
Case 17:
Case 18:
Case 19:
Case 20:
Case 21:
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: Case 2:
Case 3:
Case 4:
Case 5:
Case 6:
Case 7:
Case 8:
Case 9:
Case 10:
Case 11:
Case 12:
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: Case 2:
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.
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: Case 2: Case 3: Case 4: Case 5: Case 6: Case 7: Case 8: Case 9: Case 10:
Case 1: Case 2: Case 3: Case 4: Case 5: Case 6: Case 7: Case 8: Case 9: Case 10:
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: Case 2: Case 3: Case 4: Case 5: Case 6: Case 7: Case 8:
Please note that you will know 3 (or 4 if you know the mirror case) of these if you know ELS.
Case 1: Case 2: Case 3: Case 4: Case 5: Case 6: Case 7: Case 8:
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: Case 2: Case 3: Case 4: Case 5: Case 6:
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: Case 2: Case 3: Case 4: Case 5: Case 6:
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.
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: Case 2: Case 3:
Case 4:
Case 5:
Case 6:
Case 7:
Case 8:
Case 9:
Case 10:
Case 11:
Case 12:
Case 13:
Case 14:
Case 15:
Case 16:
Case 17:
Case 18:
Case 19:
Case 20:
Case 21:
Case 22:
Case 23:
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: Case 2: Case 3:
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.
Case 1:
Case 2:
Case 3:
Case 4:
Case 5:
Case 6:
Case 7:
Case 8:
Case 9:
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: Case 2: Case 3: Case 4: Case 5:
Case 6:
Case 7:
Case 8:
Case 9:
Case 10:
Case 11:
Case 12:
Case 13:
Case 14:
Case 15:
(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:
Case 17:
Case 18:
Case 19:
Case 20:
Case 21:
Case 22:
Case 23:
Case 24:
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: Case 2: Case 3: Case 4: Case 5:
(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
Here's an explanation of how to solve the cube using less algorithms for beginners to the method.
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.
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.
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.
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.
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.
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.
