The theme of Mehta is to solve a greater fraction of the cube using algorithms; and the way to provide room for creativity in algorithmic steps is option-select. Having a structured option-select system like in Mehta-OS means having a choice between two algorithms on each step, where one could alwyas pick the one that is easier to recognise and/or execute. The flowchart on the Home page explains briefly what the four possible paths for Mehta-OS are.

Getting a few abbreviations and definitions out of the way:

The number of cases in each set is given in the flowchart. All Mehta-OS algorithms can be found here.

There are 4 paths in Mehta-OS, named after the unique middle step in each path: Mehta-6CP, Mehta-APDR, Mehta-CDRLL and Mehta-JTLE. The movecount statistics (generated over 60000 X 4 solves using the first algorithm for each case as mentioned in the spreadsheet; hence note these are speed-optimal stats, not move-optimal) for each path are given below:

6CP Path preAUF (6CO) 6CO preAUF (6CP) 6CP preAUF (L5EP) L5EP ABF Total
Average 0.70 8.56 0.73 9.66 0.72 7.22 1.00 28.59
Std. Dev. 0.46 1.86 0.44 2.79 0.45 1.74 0.57 3.88
Median 1 9 1 9 1 7 1 29
Minimum 0 0 0 0 0 0 0 4
Maximum 1 12 1 17 1 9 2 41
APDR Path preAUF (6CO) 6CO preAUF (APDR) APDR preAUF (PLL) PLL ABF Total
Average 0.70 8.56 0.74 7.26 0.69 12.12 1.00 31.07
Std. Dev. 0.46 1.83 0.44 2.24 0.46 3.57 0.58 4.66
Median 1 9 1 7 1 12 1 31
Minimum 0 0 0 0 0 0 0 4
Maximum 1 12 1 13 1 21 2 47
Average 0.70 8.22 0.73 10.31 0.72 7.22 1.00 28.89
Std. Dev. 0.46 1.99 0.44 2.25 0.45 1.74 0.58 3.59
Median 1 9 1 10 1 7 1 29
Minimum 0 0 0 0 0 0 0 4
Maximum 1 13 1 16 1 9 2 41
Average 0.70 8.22 0.74 9.43 0.70 12.10 1.01 32.89
Std. Dev. 0.46 1.99 0.44 2.15 0.46 3.60 0.58 4.71
Median 1 9 1 9 1 12 1 33
Minimum 0 0 0 0 0 0 0 4
Maximum 1 13 1 13 1 21 2 49

Note that these are algorithmic steps, so the efficiency of the simulation is identical to the efficiency of any solver for each simulation. It should be noted that the most efficient of the 4 paths on average is the 6CP path, followed closely by the CDRLL path.

Now consider a solver that always knows which path to pick for every scramble to get the shortest solution. Running a simulation (of 60000 solves) for such a solver gives the best possible average movecount of Mehta-OS finish to be 26.30 STM (standard deviation of 3.34 STM). Compared to ~29 move finish for 6CP and CDRLL paths, having option select in one's arsenal can chop the movecount by upto ~2.5 STM on average (* This would in practice be slightly lower).

More importantly, this simulation shows that the most efficient solutions are achieved using the 6CP path in 45.5% of the solves, using the CDRLL path in 43.8% of the solves, using the APDR path in 18.7% of the solves, and using the JTLE path in 10.4% of the solves (The sum of these numbers is more than 100% due to ties). This reveals that the default path a Mehta-OS user should choose is either the 6CP path or the CDRLL path (where the user is guaranteed the most efficient OS finish ~45% of the time). Either of these should be the first path the user learns, and any other path the user learns would be add-ons for option select, which depending on the judgement of the user would increase their likelihood of getting the most efficient OS finish appropriately.

6CP-vs-CDRLL: Which path should you learn first / as your default path? 6CP is slightly more efficient CDRLL, and APDR (which is accessible as soon as you learn 6CP) is far more valuable than JTLE (which is accessible on learning CDRLL) as an option-select second path. Additionally, the 6CP path combines very well with known alg-sets like TTLL and HKPLL (the oppotunitity to use these comes up once every 10 solves) as well as set-ups to PLLs, which can serve as additional option-select resources for a sufficiently advanced solver. Anti-APDR (thus ending the solve with PLL+corner swap, thus having 22 additional cases) is another viable option to cut down on inefficient APDR cases. However, CDRLL is slightly more efficient than 6CP in QTM, and the recognition and algorithms will be very familiar to people coming from backgrounds in CMLL or COLL; while the 6CP recognition is nowhere close to as well researched (except here). Moreover, it is easier to transition to Mehta-TDR from CDRLL (since DCAL is a subset of TDR; and COLL, which very similar to CDRLL, is a subset of ZBLL). At the end, it is an open debate that could have different answers for different users.

A note on L5EP: Because there are so few L5EP cases, it is advisible to learn L5EP from multiple angles (i.e. the D edge being in DR, DF or DB; all these algorithms are also included in the sheet). This way, if after CDRLL/6CP, the ADF is a D or a D', one could do the ADF before L5EP, giving more time for L5EP recognition, and finally ending with only an AUF instead of an ABF.

While the total number of algorithms required for full Mehta-OS might seem to add up to over 300, not all algorithms need to be learned. Say your default path is DCAL -> CDRLL -> L5EP; the first decision point is whether to do 6CO in place of DCAL so one would be alright memorising only the 6CO algorithms with good recognition and / or execution; the second decision point is at CDRLL or 6CP, so all CDRLL and 6CP would have to be learned but only selected JTLE and APDR algorithms (already marked in the algsheet) should be learned. This allows to use full Mehta-OS to almost the best of its potential without learning all the algorithms.

And finally, choosing to learn only one path (either 6CP or CDRLL) and using only that without any option-select should still give the user a sub-50 movecount on average; which in the right hands could get great results by itself.