# Message #3378

From: legomany3448@gmail.com

Subject: A layer-by-layer method! (With video tutorial coming sometime)

Date: Fri, 24 Jun 2016 18:22:13 -0700

Yesterday I first solved the 3^4 in 1255 moves using a layer-by-layer method I had come up with somewhat on-the-spot. Since then, I’ve modified a few of the macros to aim more for speed than fewest-move-count. (Though my second solve, using some of those new algorithms, was only 1044 moves.) For the sake of acronyms, I’ll call the two-color pieces "middles," three-color pieces "edges," and four-color pieces "corners." My method has 11 steps:

- MFL (middles of the first layer; also "cross")
- EFL (edges, first layer)
- CFL (corners, first layer)
- F2L-M (completing the middles of the first two layers)
- F2L-E (completing the edges of the first two layers)
- MOLL (middle orientation, last layer)
- MPLL (middle permutation, last layer)
- EOLL (edge orientation, last layer)
- EPLL (edge permutation, last layer)
- COLL (corner orientation, last layer)
- CPLL (corner permutation, last layer)

There are eleven macros used to perform these steps:

(The cross is completely intuitive, as in Friedrich/CFOP for the 3^3.)

- EFL case 1 (4 moves) - An intuitive commutator whose only real advantage is to keep from moving the mouse back and forth between faces that are far apart (when speedsolving).
- EFL case 2 (5 moves) - An intuitive solution to deal with edges on the last layer.
- CFL (10 moves) - Another intuitive commutator with an initial turn to make for a logical start position.
- F2L-M (9 moves) - Simply this 3^3 conjugate for solving the second layer https://alg.cubing.net/?stage=F2L&type=alg&view=playback&alg=%5BR-_U-_R-_U-:R-%5D.
- F2L-E (18 moves) - A conjugate involving F2L-M. It displaces the middle piece, pairs it with a edge, then reinserts the pair.
- MOLL (6 moves) - A 4D version of this 3^3 conjugate https://alg.cubing.net/?stage=OLL&type=alg&view=playback&alg=%5BF:%5BR,U%5D%5D which accomplishes exactly the same task; performed normally it flips (and uselessly permutes) two opposite middles, and when reversed it flips two adjacent middles.
- MPLL (3 moves) - Isolates a middle piece (along with two edges, but that’s unimportant) to allow for easy intuitive commutators to permute the middles of the last layer. (For permuting adjacent middles, rotate the last layer around a corner to avoid the edges colliding and causing issues.)
- EOLL (7 moves) - Isolates an edge piece, flips it, and then returns it (along with two corners, but that’s unimportant). It uses an older version of my EPLL algorithm, which is now twice as long so that it doesn’t affect any corners.
- EPLL (6 moves) - Isolates a single edge pieceo to allow for easy intuitive commutators to permute the edges of the last layer.
- COLL (17 moves) - Quite a long algorithm; simply throws a corner twist inside a commutator of the CPLL algorithm.
- CPLL (8 moves) - Isolates a single corner to allow for easy intuiti– you get the point.

As you can see, none of the algorithms are particularly long or unwieldy, and those that are long as simply conjugates created from another algorithm. The method itself is also not terribly difficult to use once you learn it. I’m not really one to judge though, seeing as I haven’t used any other method yet. :P Here’s an album of images I created showing how to use the macros http://imgur.com/a/oBFk1, and here’s a pastebin of the macros file http://pastebin.com/raw/ULQxSjFn. I hope to upload tutorials and/or example solves using this method to Youtube at some point in the next week, but no promises there. Let me know if any of you have any success with this, and how it compares to Roice’s solution in both ease of learning, ease of use, move count, and speed.