# Thread: New method for megaminx last layer (2-look)

1. ## New method for megaminx last layer (2-look)

Been working on some megaminx stuff. Mostly a proposed LL system, which I haven’t learned yet, but I intend to learn it and use it, and which I have put a lot of thought into. It provides a feasible 2-look system for LL (sort of). First, I would like to propose a new notation for megaminx, which can easily define any twist. Spoiler tags will make this post shorter, and easier to find things.

Notation:
Spoiler:
I use the notation for the LL algs, and while most of them use the generally agreed on (I think) notation, I use my extended notation for some of them. As far as I know, I can use U, F, R, L, D and B without much confusion, but I will clarify first. Sit the puzzle down on a table, and have one of the faces adjacent to the top face facing towards you. The top face is U, the one facing you is F. The two faces which are adjacent to both of these are R and L, and the right and left sides respectively. The face adjacent to F and R which isn’t U is D, and the one adjacent to U and R which isn’t F is B. No pair of these are opposite faces, so call the face opposite a face X, X#. Then, since the scrambling notation R+ and D- etc would not be consistent since it doesn’t follow the R or D faces, I cannot use + and – for turning all but the opposite face. So, I propose C (clockwise) and A (anticlockwise) for this, even though nobody uses antislice moves in megaminx notation afaik, which would use a small ‘a’, I will use a capital A to avoid any potential confusion. Then, D+ would be U#C, D—is U#AA, and R+ does not transfer exactly as it requires an edge to be in the top left of the puzzle, which is not the orientation I use. It would probably translate as DC or L#C by rotating the puzzle by 36’ around the vertical axis.

For whole puzzle rotations, I use ~ before the face turn it would follow. For example, rotating the puzzle along the vertical axis as in a U2’ turn would be ~U2’. The standard way of applying 3x3 notation to minx would label this as y2’.

I don’t what could be used for when the puzzle is rotated for scrambling notation, but to be honest, it probably isn’t necessary. One system is enough to describe a sequence of moves, and nobody holds the puzzle in one exact orientation while executing anyway.

So now for the LL system, although it is actually more for last 2 faces, but I think of it as being for LL. First, solve all but two adjacent faces. Then, go Petrus style, and orient edges while solving one of those faces, minus the pieces which are in the other face, and one corner/edge slot (like an F2L slot). Solve the pair in such a way that you end up with at least 2 adjacent corners on the last face oriented. This can be done intuitively, I recommend just messing around with stuff until you can do this, the same way you would with blockbuilding. You have a fair bit of freedom to do this, but if you are struggling, I developed a backup system which you can use. I’ve not learned this yet and didn’t spend long on it, but it will do as it is only a backup, I don’t recommend relying on it (though it may be useful sometimes). Actually, you can do any way of solving up to LL plus one slot which leaves you with remaining edges oriented, but that’s how I solve it.

Slot + 2 adjacent oriented corners in LL:
Spoiler:
This is mostly done with looking at two corners. Cases are listed by the corner two places anticlockwise of the corner to be solved into the slot (btw, pair up the corner and edge in the U face first), then the one just anticlockwise of this. Orientation is ‘o’ for oriented, + for twisted clockwise, - for anticlockwise. For two cases I couldn’t find a good solution, so you need to look at the corner one place anticlockwise of the corner to be solved, though they have the same solution actually which makes this less awkward. For the AUF, place the pair so it can be solved with R U’ R’.

oo L’ U2’ R U R’ U2 L
+o o (U) R U’ R’ U2 R U2 R’ + (U) R U2’ R’ - R U’ R’
-o o (U) R U’ R’ U2 R U2 R’ + (U) R U2’ R’ - R U’ R’
o+ R U2 R’ U2’ R U’ R’
++ (U) R U’ R’ U2 R U’ R’ U’ R U2 R’
-+ R’ F R F’ R U’ R’ U2’ F’ U2’ F
o- R U2 R’ U’ R U’ R’ U R U2’ R’
+- (U2) R U’ R’ U’ R U’ R’
-- (U2) R U2’ R’ U R U2’ R’

So, we have LL with edges oriented and two adjacent corners oriented, without too much effort. We now have to solve CO (with only 6 unsolved cases), EP, and CP. Instead of doing this is 3 steps (which is fairly easy, and essentially how I used to solve except I didn’t control corner orientation), it is now feasible to do it in 2, by splitting up the EP step.

First step: solve CO, and influence EP. You want to end up with (at least) two edges from non-adjacent faces to be solved relative to each other. This gives either the EP case which can be solved with R2 U2’ R2’ U’ R2 U2’ R2’ (by far the easiest and fastest EPLL, up to mirrors/inverses of this depending on your preference), or EP skip.
Second step: You now have a subset of PLL, which is feasible 1-look. You either have CPLL (which any serious megaminx solver should know already, 15 cases, 9 without mirrors/inverses), or horseface PLLs (60 cases on the site, I haven’t yet looked into how it reduces but it’s less than 30 non-isomorphic cases anyway). This step is documented already, so I won’t cover it here. Until you learn the PLL subset, you can 2-look this using the fastest EPLL for megaminx, which is easier to recognise than normal since you would usually have more possible EPLL cases to distinguish it from, then CPLL (or just CPLL for EPLL skip).

The first step is split up into the OCLL cases. There may be a lot of cases to recognise (6*20=120), but the system is easy enough to follow, and you don’t need many algs, as each one solves multiple cases.

Recognise uses certain pair of edges each time, which are from non-adjacent faces. Edge positions are numbers from 1-5 (given later for each case individually). Note the number of the first edge, then the number of the edge which goes 2 places clockwise of it (eg. UR then UL). Look up the row of the first number, and the column of the second, to get the number of an alg. Then look up the alg from the given list. For each case I have tried to give the best algorithm which will solve it. However, if you decide you don’t like one of the algs I’ve given (they are numbered in order of how good I think they are, although I didn’t spend too much time on fine tuning the list. High numbers mean a less preferable alg) you can switch which edges you use to recognise. I recommend using the second edge you normally use as the first edge, and the appropriate other edge as the new second edge. Following from earlier, if you started with UR->UL, switch to UL-UB. This might also provide an advantage other than a better alg, obviously at the expense of longer recognition time: you know which EPLL case you will have. Why? Well, you are switching to a better alg, which will not solve the first 2 edges you looked at, or it would be the given alg for that case, so you have the 3-cycle case. Sometimes, this may well be better than using the algorithm I’ve listed in the table.

If you get good enough, you can check alternative pair of edges as you start to solve this step, which can give you an indication of which EPLL you will get (or you can just try tracking pieces). You can also recognise using multiple pairs of edges if you like: check several pairs and solve the best case you see. With practice, it might even be reasonably quick to check all 5 pairs, especially since the second edge in each pair is the first edge in the next pair, and the first edge should be the easiest edge to spot (I have a blue LL colour, and my first edge is blue/white). This will eliminate the need for some of the less good algs here, although I’m not sure how many it will eliminate.

AUF matches how you solve the first listed alg, edge numbers are listed by case. 0 is used to fill out the table for the diagonal entries (you can’t have 2 edges in the same place).

OCLL with EPLL control:
Spoiler:

Sune: all 3 need twisted CW
Spoiler:

1 is at UF, and work round anticlockwise (in the direction of the flipped corners).

1 R U R' U R U2' R'
2 L U' R' U L' U' R
3 (U') R' U2 R U2 R' U R
4 (U') R2' U' R U2' R U R' U R' U R2
5 (U2) R U2' R' U2' R U R' U' R U' R'
6 (U2) R' U2' R U R' U R B' R' U2' R U R' U R B

0 6 1 2 3
1 0 3 5 2
2 4 0 1 5
5 2 4 0 1
4 1 2 3 0

Antisune: all 3 need twisted CCW
Spoiler:

Numbering is equivalent to sune, just mirror it.

1 R' U' R U' R' U2 R
2 R' U L U' R U L'
3 (U) R U2' R' U2' R U' R'
4 (U) R2 U R' U2 R' U' R U' R U' R2'
5 (U2') R' U2 R U2 R' U' R U R' U R
6 (U2') R U2 R' U' R U' R' F R U2 R' U' R U' R' F'

0 1 2 5 4
6 0 4 2 1
1 3 0 4 2
2 5 1 0 3
3 2 5 1 0

Headlights: 2 adjacent corners need twisted, U face stickers of these lie on one face.
Spoiler:

The edge between flipped corners is 1, the rest are labelled CW from there.

1 R U R' U R U R' U2' R U' R'
2 R' U' R U' R' U' R U2 R' U R
3 (U2') R2' D' R U2 R' D R U2' R
4 (U2) L F2 (R U R' U') F2' L'
5 R2 U R2' F#A U' R' U R' U' R2 U F#C R2 U' R2'
6 L' U' L R U2' R' U' R U2' R' L' U L

0 6 3 1 2
1 0 2 3 5
2 1 0 4 3
3 2 5 0 1
5 3 1 2 0

Chameleon: like headlights, but twisted the other way.
Spoiler:

1 ~R' R U R' D R U' R' D'
2 (U) R U R U2 R' U' R U' R' U' R'
3 (U') R U R2' F R F' R U' R' F' U F
4 (U') ~R' R' F' R2 U' R' U R' F R U F' U'
5 (U') R U2 R' U' R' U2 R2 U2 R' U2' R' U2' R
6 R U2 R' U' R U' R' U' R U R' U R U2' R'

0 6 1 2 3
4 0 3 1 2
3 2 0 5 1
1 3 2 0 4
2 1 4 3 0

Bowtie: name doesn’t transfer so well from 3x3. Non-adjacent corners twisted, U face stickers lie on adjacent faces.
Spoiler:

Edge 1 is not adjacent to either twisted corner, then go CW.

1 F R' F' L F R F' L'
2 (U2') R U R' U2 R U' R' U' R U' R'
3 (U) R U2' R2' U2' R2 U' R2' U2' R
4 L F2 U R U' R' F2' L'
5 F R U R' U R U2' R' F'
6 L F2 R2' D R D' R F2' L'
7 R2 U' R2' U2 R U2 R' U R U2 R' U2' R2 U R2'

0 2 1 6 5
5 0 4 1 2
2 6 0 5 1
1 5 2 0 7
3 1 5 2 0

Wide bowtie: can’t think of a better name. Like bowtie, but twisted other way.
Spoiler:

Numbered as in bowtie.

1 R U2' R' U' R U2' R'
2 R' U2 R U R' U2 R
3 ~R' D R U R' D' R U' R'
4 (U') L F R U R' U' R U' R' U F' L'
5 (U') L' U2' R U R' U2 L R U2 R'
6 (U2) D# R2' D' R U' R' D R U' R U R' U R D#'
7 (U2) L' U' L U' L' R U R' U2 R U2 R' U2' L

0 5 2 7 1
2 0 1 3 6
6 4 0 1 3
1 7 6 0 2
4 1 7 5 0

For an example: you get the chameleon case. First edge (blue white for me) is between the two twisted corners, second (blue yellow) is 3 places clockwise of this. Then, our recognition is 1,4. The number in the first row and fourth column is 2. Alg 2 is listed as R U R U2 R' U' R U' R' U' R'. We also have the AUF (U), which means to AUF correctly you need to place the twisted corners where the first alg would solve them, which is UFL and UFR. So, place them there, do a U turn, then do R U R U2 R' U' R U' R' U' R'. The two edges you recognised with should now be solved relative to each other, and all corners are oriented.

So, that’s my (sort of) 2LLL system for megaminx. I’ve sometimes been thinking of it as lolLL, so maybe you can call it that. Anyone think this is a good system? Any improvements you can think of? I hope to get some feedback, although I’ve already been working on this for a while and I think I’ve improved it as much as I can. Also feel free to point out mistakes as this is a long post and I will probably have made at least one, or better algs for any of the cases. Now, I just need to learn the damn thing along with all the other cube stuff on my to-do list, in between work and university.

I am well aware that my recognition can be seen as excessive. Why not just pick one edge position for each case, and learn all the different pairs of edges you need to recognise? Then, you only have 4 cases. Actually, that is how I suggest you learn to start with. That is, pick the best row for each case, and learn it. 6*4=24 cases to learn to get the same effect. Then, you can start learning the rest of the table, starting with the easy cases (go through the algs in order of speed, and learn what they all solve), to end up with more efficient solutions on average. Also, this version of recognition could be useful later if anyone extends this system, which leads me to the next point.

Alternative method (not documented) is to solve corner orientation and edge permutation in one go. Recognition would be similar to the beginner system, except with two edges to look at. Pick a certain edge position, and look for the edge which would be solved 2 placed CW of it, then the edge which would be solved 2 places CW of that one. You would need to learn to recognise which ones to look for, which are in order: UR, UL, UB, UF, UD#. This is actually pretty easy to do. There are only 12 cases for each OCLL case to learn, which is 12*6=72 cases all in. This is certainly feasible to learn. The main reason I didn’t go straight to this system is because it took long enough to find enough algs for this system, since I did it by hand. I did try and download a megaminx LL solver, but it didn’t run for me, and I didn’t get any reply after contacting the site. It would probably be necessary to generate all the required algs in a reasonable amount of time.

Actually, wouldn't it be fun if this was another surprise challenge thread? Now, go do gigaminx OH . Not really, but it would be fun to see the reactions.

2. "OCLL with EPLL control"

I have been looking for someone to make this!!!

3. God that is a strange way of solving. I can't see myself learning the algs for it and to stop using OLl/PLL normally. I don't think this would be a faster method but it is nice to see radical methods for megaminx being made.

4. Originally Posted by Odder
"OCLL with EPLL control"

I have been looking for someone to make this!!!
Glad I could help . You think the method is alright the way it is or is there any changes you want? If you like I can give you algs for all OCLL cases for the easier system I reckon you should start with (which I learned fairly quickly already for the 6 OCLL cases, just need to get fast now), which is 4*16=64 cases all in. I'm a little busy so it may take a few days to sort out, but it's no bother really. I won't be finishing the full system for those other cases though, or at least not any time soon since I have no plans to learn them.

5. Originally Posted by bobthegiraffemonkey
Glad I could help . You think the method is alright the way it is or is there any changes you want? If you like I can give you algs for all OCLL cases for the easier system I reckon you should start with (which I learned fairly quickly already for the 6 OCLL cases, just need to get fast now), which is 4*16=64 cases all in. I'm a little busy so it may take a few days to sort out, but it's no bother really. I won't be finishing the full system for those other cases though, or at least not any time soon since I have no plans to learn them.
actually I only read "OCLL with EPLL control", so I cannot give any feedback on the method at all I'm by the way using CO, PLL(EP+CP)

6. Originally Posted by Odder
actually I only read "OCLL with EPLL control", so I cannot give any feedback on the method at all I'm by the way using CO, PLL(EP+CP)
I see. That's what I used to do, with EP then CP, but the most obvious progression is 1-look PLL and I really didn't want to do that. Too many cases and recognition would be pretty difficult, and no better alternative had been documented that I know of, so I made my own alternative.

#### Posting Permissions

• You may not post new threads
• You may not post replies
• You may not post attachments
• You may not edit your posts
•