For the last 5 edges from F2L minus 1 slot, there are 69 cases (not counting the solved case) when reduced by pre-AUF, post-AUF, and mirrors. I've learned optimal algs for each case, so I can solve any of the 1920 edge configurations within 2 moves of optimal. Of course, this often leads to bad L5C cases, so other approaches generally must be tried as well.
@cuBerBruce I'd be interested in seeing the list itself
@Cubenovice Thanks for the feedback for the tutorial - I'll be sure to include those points. I'm in full time work, so it may take time for me to put it together, but I'll get there eventually
The distribution for the optimal configuration of each case is:
Code:
moves count
3 3
4 1
5 4
6 12
7 29
8 10
9 10
Note that this is the distribution of the best configurations for each case, and pre-AUF and post-AUF may add 2 moves for a particular configuration within a case.
I divide the cases up by permutation. I assume the last layer is U and the slot is FR. If the slot edge is solved or flipped in place, I have just an LL case except the DRF corner does not need to be preserved (and FR may be flipped). In this case, either the LL edges are in the proper order or a single swap can put them in the proper order. If an adjacent swap is needed, I put the two edges to be swapped at UL an UB. If two opposite edges need to be swapped, either pair will work, but I may have to choose a particular pair to match one of my orientation cases. I may also need to mirror in order to match one of my orientation cases.
If the slot has a last layer edge, I rotate the cube if needed so the U sticker will be on the front face (at FL or FR). If I need to have it at FL, I have a mirror case. Putting it another way, a last layer edge in the slot is always considered to be oriented correctly! I then pre-AUF so that the FR (or FL) cubie is in the front (at UF or FU). The other 3 edges in the U layer are then permuted in one of 6 possible ways with respect to the UF cubie if we imagine the UF cubie to be in its correct place.
For an LL edge in the slot, there are always have 8 orientation cases for each of the six permutation cases. If the edge slot is in its correct place (possibly flipped), there are 5 orientation cases if the LL edges are permuted correctly (excluding solved case), 6 for opposite swap, and 10 for adjacent swap.
It's easier for me to simply supply the ACube output file. This file contains all the optimal algs, not just the ones I learned, and many sub-optimal ones as well. One problem is that it omits the post-AUF move so you have to figure out what post-AUF is needed to match the canonical case. Also, the order is somewhat random. I inserted into a .zip file for compression.
EDIT2:
Here are the actual algs I memorized, along with the cases they solve. A colon separates the case from the alg. The permutations are given in cubie cycle notation, and the unparenthesized part indicates the misoriented edge positions.
() UB UL: U R U' B U B' U R' U2
() UR UL: R U' B U2 B' U R' U2
() UL FR: F' U' F U' R U R' U
() UF UR UB UL: R B2 U2 R B R' U2 B2 R' U
() UR UB UL FR: R B U B' U R' F' U' F U'
(UF FR): R U R' U R U R' U2
(UF FR) UF UR: F' L' U L F R U R' U'
(UF FR) UF UB: R U R' U2 F' U F U
(UF FR) UF UL: U2 F' U F R B U B' R' U
(UF FR) UR UB: R B2 L' B' L B' U' R' U2
(UF FR) UR UL: R B U B' U2 R' U2
(UF FR) UB UL: R U R' U2 R' F R F' U2
(UF FR) UF UR UB UL: R B U2 B2 R B R2 U'
(UF FR)(UR UB): R U R' U' R U' R' U
(UF FR)(UR UB) UF UR: U R U' R' U2 F' U2 F
(UF FR)(UR UB) UF UB: U' R B U B' R'
(UF FR)(UR UB) UF UL: U R U R' U' F' U' F U2
(UF FR)(UR UB) UR UB: U R B U2 B' R' U'
(UF FR)(UR UB) UR UL: U F2 B D' L D F2 B'
(UF FR)(UR UB) UB UL: F2 B D' L' D B' F2 U'
(UF FR)(UR UB) UF UR UB UL: U' F' L2 B L B' U L F
(UR UL): R' F R U2 L F L' U2 F' U2
(UR UL) UR UL: F' U F R U R' F' U2 F U
(UR UL) UB UL: R U R' F' L' U' L F U'
(UR UL) UL FR: R B U B' R' U' F' U F
(UR UL) UF UR UB UL: F R' F' R2 U2 R2 F R F' U'
(UR UL) UR UB UL FR: U2 F R' F' R2 B U B' R' U2
(UF FR) (UR UL): U R U2 R' U'
(UF FR) (UR UL) UF UR: U R U' R' U F' U' F U2
(UF FR) (UR UL) UF UB: F U R' U' F' U R U
(UF FR) (UR UL) UF UL: U' F' U' L' U2 L F
(UF FR) (UR UL) UR UB: R U' B U B' U' R' U'
(UF FR) (UR UL) UR UL: U' F U R U' R2 F' R U
(UF FR) (UR UL) UB UL: U R U B U' B' U R'
(UF FR) (UR UL) UF UR UB UL: B' R U2 F B' R' F' R' B2 U'
(UB UL): U2 R U2 R' U' R U' R' U
(UB UL) UF UR: F' L' U2 L U2 F U'
(UB UL) UR UB: U R' U' F' U F R
(UB UL) UR UL: R' F' U' F U R U'
(UB UL) UB UL: U B' R' B' R' B R' B' R2 B2 U'
(UB UL) UL FR: F' U' F U R U' R'
(UB UL) UR FR: F' U F R U2 R' U2
(UB UL) UF UR UB UL: R B U' L U2 L' B' U' R' U'
(UB UL) UR UB UL FR: L' R2 D B D' L R' U R' U'
(UB UL) UF UR UL FR: F' L' U L2 F' L' F2 U2
(UF FR)(UB UL): U2 R U' R' U R U R' U
(UF FR)(UB UL) UF UR: U R U' R' U' F' U F U2
(UF FR)(UB UL) UF UB: U2 R U' R' U2 F' U F
(UF FR)(UB UL) UF UL: U' F' L' U L F
(UF FR)(UB UL) UR UB: B' R2 U' R U R2 B U
(UF FR)(UB UL) UR UL: U' B' R2 U' R' U R2 B
(UF FR)(UB UL) UB UL: U2 F R' F' R2 U R' U
(UF FR)(UB UL) UF UR UB UL: U R U2 B U' B2 R B R2
(UF FR)(UR UB UL): U2 R U R'
(UF FR)(UR UB UL) UF UR: U2 R U2 R' U F' U' F U'
(UF FR)(UR UB UL) UF UB: U2 R U' R' U F' U2 F U'
(UF FR)(UR UB UL) UF UL: F' L F' L' F2 U'
(UF FR)(UR UB UL) UR UB: R U B U' B' U' R' U2
(UF FR)(UR UB UL) UR UL: U2 R B U B' U R' U'
(UF FR)(UR UB UL) UB UL: U2 R B U2 B' U R' U2
(UF FR)(UR UB UL) UF UR UB UL: U2 R B L U L' U B' R' U'
(UF FR)(UR UL UB): R U' R' U2
(UF FR)(UR UL UB) UF UR: F R' F' R U
(UF FR)(UR UL UB) UF UB: R U R' U F' U2 F U
(UF FR)(UR UL UB) UF UL: R U2 R' U F' U F U
(UF FR)(UR UL UB) UR UB: U R U' B U' B' R' U2
(UF FR)(UR UL UB) UR UL: U2 R U' B U2 B' R' U2
(UF FR)(UR UL UB) UB UL: U2 R U B U B' U' R'
(UF FR)(UR UL UB) UF UR UB UL: U2 R U' R2 F R F2 U' F U'
@Cubenovice Thanks for the feedback for the tutorial - I'll be sure to include those points. I'm in full time work, so it may take time for me to put it together, but I'll get there eventually
Did you actually memorize all these algs or study their generic functionality (for lack of better wording)?
I really like FMC but I do not like studying algs
I've been meaning to study all the short LL algs (as once supplied by Irontwig) for ages but I just can't be motivated to start.
But perhaps some more fail solves at this weekends Spols open can sole the motivation issue
Did you actually memorize all these algs or study their generic functionality (for lack of better wording)?
I really like FMC but I do not like studying algs
Basically, just memorized them. I used a phonetic system similar to what Morley Davidson used for memorizing ZBLS and ZBLL. I note some other simplifications could be used, such as reducing the number of cases by inverses, conjugating to another case (sometimes is still optimal), "solving" to a simpler case (such as with the some keyhole cases). You probably don't really have to memorize the keyhole case algs, just know which ones keyhole does optimally. I was somewhat surprised at how few cases keyhole solves optimally.
I'm a CFOP user who wants to get into some FMC. I use some block building but always end up with having to do F2L, OLL and PLL scince I don't know how I would do it otherwise. Any ideas where I should start??
I cannot check your solution right now but some pointers:
Write your solution without cube rotations: you have got R' z2 L' in there which is actually an R2 move
Cube rotations "hide" cancellations. In competition the judge will count your R' z2 L' as two moves.
You obviously know commutators, now try to insert the corners cycles into the earlier part of your solution.
After 31 HTM you have 2 cycles left, you can expect to cancel 4-5 moves, giveing a final result of 42-43.
For insertions: apply stickers 1-2-3-4-5 to the remaining corners and go trough your solution to see where you can solve these corners.
There's a lot of posts in this thread on insertions, and plenty of other places where you can get all the details, you just gotta do some sifting
But, here's the basic conceptual overview (I find this is always the trickiest part to really get my head around anyway). A commutator is useful because it only affects a very specific set of pieces. And corner 3-cycles are simple, have a reasonably low move count and the likelihood of a 3-cycle being solvable in the optimal minimum moves is fairly high (whereas the optimal edge cases are unlikely to show up).
And here's where that adds up interestingly. When you apply a corner 3-cycle, the cube is untouched aside from the corners. So lets say you achieve a skeleton where three corners are left unsolved. Now, go back a random number of moves, apply a random 3-cycle to those three corners and then redo your skeleton moves. What happened? Your skeleton is exactly the same, because the commutator you applied has no effect on the pieces that make up your skeleton.
Now, if you were to follow those corners (by applying stickers) you could apply a commutator that would cycle the corners in a way that had the cube solved when you redo the last moves of the skeleton.
The repercussions are great for us FMCers because we can go to ANY point in the skeleton and apply the correct commutator (an insertion), and we solve the corners we need. If we explore all the possiblities, there's a very good chance that we will find an optimal case where the starting or ending move will be on the same face as their adjacent skeleton move, giving us a cancelation, or multiple.
Just throwing out a guess I'd say that on average insertions save about three and a half moves, anyone else have a guess or run the numbers on this?
Insertions aren't saving anything, you add moves with it (-;
But OK, compared to a 3-cycle at the end (average 8.8 moves) it saves about 1 move for each 7 moves in your frame. So on average longer frames cancels more moves and shorter frames less.
