Nautilus L5E

Solve a 1x2x3 at dL. This means the block that is completely within the left layer of the cube. This step has been proven to be fast and efficient. There are many strategies that can be used and the best one depends on the scramble.

Build the 2x2x2 at the back right (dbr). There are a lot of possible strategies that can be used to build the 2x2x2. The recommended strategy is to first build the right side 1x2x2 then add the DB edge. This is likely the easiest and most efficient single strategy. The efficiency of this was confirmed by Melkor after inputting several strategies into the HARCS program. It had the lowest movecount.

Using the recommended strategy of building the right side 1x2x2 then adding the DB edge has a few great points.

• You can easily build the right side 1x2x2 with a lot of freedom.

• There are two edges to choose from to add a pair two. Or two pairs available to add the final edge to.

• If you track or solve the DR edge during the FB step of Nautilus then you only have to solve a single pair.

• Solving the DB edge after the 1x2x2 is very automatic. There aren't many places that this edge can be and it only has two orientations. Moving this edge around its correct centers is very easy using M U R r moves.

• You can influence the DB edge while building the 1x2x2.

A strategy that is a very close second in movecount is to first add the DR edge then build the square on the back (dBr). Once users are used to the primary recommended strategy they can start to incorporate other strategies such as that one. Check out the Blockbuilding Examples page for different ways of solving the 2x2x2.

After Step 1 and Step 2, it forms the primary shape of the method called the Shell. Other ways can be used to build the shell. However, the recommended strategy is to solve a 1x2x3 then a 2x2x2 because it leads naturally into the blockbuilding style and other steps contained within the method.

Add the dFR pair. After the shell is formed, add the pair containing the DFR corner and FR edge. This step is easy to accomplish using the available rRUM moveset. F moves can also be useful in some situations. This step is completely intuitive but can also be performed using algorithms for the best solutions every time.

It is possible to combine steps 2 and 3 using more advanced blockbuilding. It is currently recommended to always solve the 2x2x2 then add the final pair. However, with some practice, using other strategies depending on the scramble could lead to lower overall movecounts. Below are a few of the possible ways of combining the two steps.

• Add DB edge then build dR 1x2x3.

• Build dR 1x2x3 then add DB edge.

• Build right side 1x2x2 and influence DB edge while solving final right side pair.

• Build right side 1x2x2 and influence final right side pair pieces while solving the DB edge.

• Build either the dfR or dBr 1x2x2 then build and add the other dfR or dBr 1x2x2.

Solve the four corners that are on the U layer. Because this step ignores the U layer edges and the DF edge, the algorithms are ergonomic and have a low move-count. 

NCLL and NCOLL Algorithms

In step 3, the pair can be inserted without caring about the orientation of the DFR corner. This shortens the number of moves required for the dFR pair. Then in the next step the final four corners can be solved using a variant called TNCLL (or Naughty-Ness) proposed by community member Silky.

TNCLL Algorithms

The final step is to solve the last five edges. The advanced goal is to solve all in one algorithm. On the way to learning these, the first step can be to orient the five edges then permute using L5EP.

L5E Algorithms

If you are just starting with Nautilus, below is the recommended progression towards the full L5E variant:

Beginner:

1. Build the shell shape as usual. This means the 1x2x3 on the left and the 2x2x2 in the back at dbr.

2. Add the front right F2L pair. This is the DFR corner and FR edge.

3. Orient the U layer corners using one of seven algorithms.

4. Permute the U layer corners using one of two algorithms.

5. Orient the five remaining edges. This has five algorithms.

6. Permute the five remaining edges. This step is called L5EP and contains 16 algorithms. If you don't yet know all 16 and come across a case that you don't yet know in a solve, you can insert the DF edge first. This is done by moving the DF edge above the DF edge slot and doing M' U2 M. Then you can use EPLL to finish. EPLL are the first four algorithms in the L5EP tab in the beginner algorithms document below.

All beginner algorithms are provided below:

View Beginner Algorithms

Intermediate: Once you are comfortable with the above beginner steps, you can learn additional algorithms to speed up your solves.

1. Build the shell shape as usual.

2. Add the front right F2L pair.

3. Orient and permute the U layer corners using a single algorithm. This means learning the 42 NCLL algorithms that are provided in the NCLL section above.

4. Get the last five edges to the arrow state. The arrow state is when there are three misoriented edges on the U layer and the edge at DF is misoriented. The arrow state is always the last EO state that occurs before all edges are oriented using M' U M or M' U' M.

5. Learn all L5E algorithms that have the EO arrow state. There are 60 cases. This allows you to maintain a great move-count while also learning actual L5E algorithms that you will use in full L5E.

View Arrow L5E Algorithms

Advanced:

1. Learn how to build the 2x2x2 + dFR pair in various ways. After the first 1x2x3, you can blockbuild in many ways as described on the "Blockbuilding Examples" page. 2x2x2 at dbr then the dFR pair is an easy way to solve, but using other strategies depending on the scramble will really improve your efficiency.

2. Continue using the 42 NCLL algorithms.

3. Learn full L5E.

This progression plan was developed in cooperation with Silky and other Nautilus community members. The arrow L5E algorithm idea for intermediate use was proposed by trangium.

The recommended future of this variant is to use a mix of pseudo techniques and other optional blockbuilding.

• The edge at DB can be any of the four M-slice edges. This doesn't affect recognition for L5E because the user will know what edge is supposed to be placed at DF and will be looking ahead to find the L/R edges.

• The right side 1x2x3 can be any of the four possible right side 1x2x3s. Recognizing the corner case when you have non-matching blocks is easily done using ATCRM.

• The blocks can be built with flipped or swapped pairs or pieces then corrected during NCLL. This is similar to ACMLL.

• Influence or solve pieces during step 1. The DB edge or other pieces can be influenced or solved during the first block.

• Use alternate NCLL algorithms that influence the last five edges.

• Instead of the dFR pair being solved, the DFr pair can be solved during step 2. This means the DF edge and DFR corner. The final step of L5E would then be the U layer edges and the FR edge.

Overall the big idea in the L5E variant, if looking at it from the perspective of Nautilus compared to Roux, is to get the DB edge solved early and in as few moves as possible. Versus having a longer final step of LSE or solving the DB edge during LSE and ending with L5E. If the DB edge is solved during LSE using M and U moves it requires 3-4 moves on average including AUFs. Nautilus provides a number of benefits over solving SB, CMLL, then ending with LSE.

• Most of the solve is either algorithm based or automatic. If using the right side 1x2x2 then DB edge strategy for the 2x2x2, all the way from solving the DB edge to the final step can be solved using algorithms. That's 2/3 of the solve.

• The solve ends with a one look, one algorithm L5E. This makes for an algorithmic finish for which the user can apply algorithms that have been generated to be speed optimal and have been practiced by the user to be executed as quickly as possible. This is versus LSE which is two mostly intuitive steps when EOLR is used.

• It is much easier to develop strategies for influencing edge orientation during NCLL. In Roux there are six unsolved edges and an unhinged M slice. This means that it is difficult to develop a complete system or set of algorithms to alter the LSE edge orientation in positive ways.

• Nautilus ends with a definitive two steps. This opens the door for an easier application of future advancements. Whether that's simple edge influencing or something more.

• The M slice permutation step of LSE, while overall a short step, has a couple of issues. The first is the dots case which requires either a not so ergonomic execution or a frustratingly long sequence of moves. The second is that the 3-cycles can be difficult to predict during EOLR. So recognition methods have been developed and still aren't perfect. With L5E neither of these problems exist.

• The last pair before NCLL can be more easily solved using algorithms, or is at least fewer cases, compared to the last pair of SB. Giving the last pair of Nautilus the algorithm treatment, as well as having fewer cases than the LP of SB, provides a TPS advantage.

• L5E is fewer moves on average compared to LSE. It is around 11.5 moves including pre and post-AUF. Roux users that have learned EOLR require 13-14 moves to complete LSE. Even if someone learned full EOLRb (which is the EOLR variant which solves UL+UR along with EO), it still wouldn't achieve the 11.5 average of L5E.

• L5E is 245 cases. EOLRb is around the same or more. So to end the solve with LSE and achieve a move-count that still doesn't match L5E, the LSE user would be required to learn just as many cases and still have to deal with the M slice permutation afterward.

• The CMLL algorithms in Roux almost always don't affect the DB edge. In a typical CMLL document, there are usually only one or two algorithms which alter the DB edge slot. This means that there is no loss of algorithm quality in NCLL.

• Non-matching blocks can be used with easy recognition throughout the entire solve. L5E recognition pairs well with non-matching blocks. With LSE, non-matching blocks make edge orientation recognition difficult. There are tracking techniques to help with this, but it adds a lot to the mental capacity which might better be used for other things in Roux.

It is inevitable that there will be comparisons with Roux. The methods have similarities. Some may oversimplify it and say that the second step is "just SB with the DB edge solved". But this doesn't consider the fact that users will very rarely solve SB then add the DB edge. The primary strategy is to solve the dbr 2x2x2 first then add the front pair. Other strategies that don't involve first building a second 1x2x3 are also long term goals for users. An additional major point is that the blockbuilding in the second step of Nautilus is very different from the blockbuilding in Roux. It involves 3D blockbuilding. This means that more than one center is included. Nautilus is the first method to have the proposal of 3D blockbuilding after FB. Roux only does 2D blockbuilding (SB). The community may want to call it a Roux variant. Especially if it starts trending toward a realization or belief that L5E could be great for Roux. However, considering the points presented here, claiming Nautilus as a variant wouldn't make perfect sense. It also means that the name of the method would be at least slightly different from Roux and credited to the proposer. So we may as well put it under the Nautilus system no matter the name.