• Welcome to SpeedSolving.com — the world’s largest puzzle community!

    You’re currently browsing as a guest, which means you have limited access to discussions, resources, member profiles, and community features.

    Join 50,000+ cubers and puzzle enthusiasts from around the world to ask questions, share solves, improve faster, and be part of the community.

    Registration is free, fast, and easy — create your account today.

    Already a member? Log in here to hide this message and start participating.

FMC: My recommended approach for recognizing all 12 HTR corner subsets

ottozing

Platinum Member
Joined
Aug 13, 2011
Messages
3,303
Location
Canberra, Australia
WCA
2012MCNE01
YouTube
Visit Channel
With all of my previous threads on DR and HTR, I've recommended that people learn the corner cases (from unsolved to solved) and to use those as a way of structuring your general HTR solutions. While this is personally how I learned HTR, I don't believe this method is the best way to go as a beginner for a few reasons:

1. HTR subsets are more important than direct corner case solutions, and the two don't always correlate. A good example of this is U R2 U' R2 U2 F2 D' F2 D U2. This case would be 4qt using the basic corner case solution structure, but corners can be brought to HTR using 2qt via R2 U2 F2 U' L2 D
2. The amount of direct corner cases, while not insanely high by modern standards, is still a lot higher than it needs to be given the fact that there's only 12 corner HTR subsets. As such, learning all of the direct corner cases, while useful, really isn't so necessary.

For these reasons, I've devised a simpler version of Rodney Kinney's Hyper Parity Maze which reduces the case count to 12 (I believe his method makes it seem like there's 35 cases but I could be wrong). The recognition methods I'll be recommending will be a mix of tradition Hyper Parity, recognizing specific easy corner cases to avoid time consuming brute forcing, and a little bit of brute forcing in scenarios where I feel it's fast enough to justify not learning a bunch of corner cases as a way to skip brute forcing.

Notes on recognition:

Many of these cases will use BLD tracing & NISS tracing, and all cases will look at number of misoriented corners.

BLD tracing is essentially the same as 3BLD where you count the number of cycles. Odd cycles will always correspond to an odd number of qt (1 3 or 5), and even will always correspond to even (0 2 or 4). Using half turns to solve a bunch of corners could be useful as a beginner if you struggle to trace a lot of corners quickly.

NISS tracing will come up for many of the 4CXE cases, and what we'll be doing is seeing whether a set of 4 corners (the 4 that are currently oriented, or the 4 that are misoriented, doesn't matter which set) look like 1qt or 2qt when traced to their target location. Examples of 1qt lookalike are corners that trace all to the U layer, UBL/UBR and DFL/DFR, UBR/UFL and DFL/DBR etc. Examples of 2qt lookalike corners are UFR/UFL and DFR/DBR, or 3 in the U layer and one in the D layer. If you find this step difficult, you could always just NISS after finding a DR to see what the corners look like on the other side of the scramble without NISS tracing, but I do believe this is pushing it in terms of wasting time during a 1h attempt.

Number of misoriented corners is fairly simple. You either have 0 (equivalent to 8 since U D' is just a slice move that can be rewritten later), 2 (equal to 6 for the same reason, something like U R2 U R2 U), or 4 (U for 1q lookalike, or U R2 U for 2q lookalike).

Cases:

0CXE (or 8CXE)


This will either be 0qt, 3qt, or 4qt. For this set I recommend just recognizing the corner case and seeing if the corners can be solved with half turns or not. If they can't, it's either 3 or 4qt which can be determined either with a BLD trace, or by seeing if the corners naturally reduce to either a 2 cycle of corners or a 3 cycle of corners. I personally think it's better to skip BLD tracing for this set since the brute forcing really isn't that time consuming as there's so few cases in this set.

For 0qt corners you'll often have to do 2qt to get to HTR due to edges being missing. U R2 L2 D and U R2 F2 R2 U are useful triggers to know. Otherwise this set is fairly straight forward: Do any qt to give yourself 1qt 4C4E, then solve the 4C4E case somehow.

For 3qt, the general structure is something like U R2 U2 F2 U R2 U2 F2 U which is quite bad. In order to do the first qt correctly and not accidentally give yourself 4qt, make sure you corners look like either a Yperm, a pseudo Yperm (do R2 then Yperm to set up), or two sets of slashes (do Yperm F2 U2 R2 to set up). If it doesn't look like one of these 3 cases before doing a qt, you'll give yourself 4qt.

For 4qt the general structure is U R2 U R2 U2 F2 U R2 U which is still kind of bad, but in practice this set is a little nicer than 3qt 0CXE. It doesn't actually matter what the corners look like before doing a quarter turn, but to do the case optimally the direction of the first turn matters (unlike the previous case where the direction doesn't matter but the corner case does). Here I think the easiest method is to remember two key cases. If you have something that looks like triple sledge (do U (R' F R F')3 U' to set up), make sure the first qt brings the missing corners from U/D away from each other (in this case that would be U' followed by any side turn then any U/D quarter turn). Alternatively, if you do an F2 after the previous set up moves, you'll have a slightly different case which resembles a JJ PBL on 2x2 but in a pseudo formation. Here the direction of the first move is dictated by which move brings the bars away from each other. In this case you would want to do a U to achieve that.

4CXE

This set ranges from 1-4qt if it's 1qt lookalike corners, or 2-5qt if it's 2qt lookalike corners. For all of these cases I'm going to recommend BLD+NISS tracing since it's very hard to cohesively cover all of these cases by learning corner case solutions. There will still be a handful of cases where I either recommend a tiny bit of brute forcing or learning some specific corner cases, but the core recognition will be BLD and NISS tracing.

1q lookalike on both sides + odd trace = 1qt corners. If you have 4C4E you can try solving the case directly, otherwise you can regress to a good 2qt subset and solve that case or solve the corners to HTR and do one of the edge only triggers from before.

2q lookalike on both sides + even trace = 2qt corners. U R2 U, U R2 F2 U, and U R2 F2 B2 D are good triggers to know & attempt to set up to. You have to be careful with how you do the first quarter turn as you can accidentally give yourself fake HTR. If something like U R2 U fails, bring 3 misoriented corners to the same face, do a U2, and then solve the case from there.

1q lookalike on both sides + even trace = 2qt corners. U R2 U2 F2 U is a good trigger to know for this case, and the general structure is to bring the misoriented corners to a slashes formation, do any quarter turn, and try to solve the 4C4E case.

1q/2q lookalike mismatch + odd trace = 3qt corners. Depending on the side of the scramble you're on, this will either follow a U R2 U R2 U2 F2 U structure, or a U R2 U2 F2 U R2 U structure. On the side of the scramble that looks like 2qt, do any set up to 1q look a like and you'll have the U R2 U2 F2 U style of 2qt. Make sure when setting up the 1qt lookalike corners you do the first move in such a way that your corners are 3 moves from being oriented instead of 2. On the side of the scramble that looks like 1qt, you have to be a bit careful with how you set up the corners before transforming the 1qt lookalike to 2qt lookalike. Understanding 4qt 0CXE and 4qt 4CXE will give you all of the relevant fake HTR fixes since there's a few clever ways you can get out of doing a qt of regression depending on where your corners initially are. It's worthwhile to also know a handful of corner cases that tell you whether or not you're ready to do a qt of progress. If your corners look like the JJ PBL, 4 adjacent bars (R2 U R2 U2 F2 to set up), or barslash with one matching bar and one opposite bar (R2 U R2 U' R2 U2 F2 to set up), you know you're good to go.

1q/2q lookalike mismatch + even trace = 4qt corners. This case follows a similar structure to 4qt 0CXE & also has a 2nd path which works on the side of the scramble that looks like 1qt. The side of the scramble that looks like 2qt is pretty easy and starts the same way 3qt 4CXE does. The only difference is that after doing your first move to reduce to 1qt lookalike & setting the corners up to be 3 moves from oriented, you insert a half turn while maintaining this 3 moves from oriented state, and then by adding a quarter turn you give yourself U R2 U style 2qt. On the side of the scramble that looks like 1qt, the easier (but worse) path is to simply give yourself 3qt 0CXE and then solve that case. The better path is to set the corners up such that they look like they're ready to be solved like a U R2 U2 F2 U case, do a quarter turn in any direction, and then deal with the 3qt 4CXE case looking for the same 3 corners cases mentioned previously.

2q lookalike on both sides + odd trace = 5qt corners. Since there's no such thing as a 6qt case, you can either turn this case into 1qt lookalike for 4qt 4CXE, or into 2CXE (or 6CXE) to give yourself 4qt 2CXE. The latter is a bit better generally speaking, but obviously 5qt corners is quite bad and something you'll almost always discard.

2CXE (or 6CXE)

For this set, we won't be using any NISS tracing and will instead use a mix of BLD tracing and brute force. This set ranges from 3-5qt, so if you get an even trace you know for certain that it's 4qt 2CXE. If you get an odd trace, I recommend brute force testing to see if it's 3 or 5 qt.

For odd trace 2CXE, set up the 2 misoriented corners such that they're on opposing layers and try doing U followed by 4 more moves to orient all of the corners. If that fails to produce HTR corners, undo those 5 total moves and try U' instead of U. If that also fails, you have 5qt 2CXE. If one of them works however, you have 3qt 2CXE.

For 3qt 2CXE the general structure is U R2 U R2 U, and it's good to know U R2 U R2 U and D L2 U R2 U as triggers. Note that for this subset you can do any number of half turns before the first quarter turn. You just have to make sure you do the quarter turn in the correct direction & have the 2 misoriented corners on opposing layers.

For 4qt 2CXE, you have 2 possible paths you can take, though again one path is much, much better than the other. The ideal path is to put the two misoriented corners on the same layer & then do a quarter turn to give yourself 3qt 2CXE, leading to a U R2 U' R2 U R2 U structure. This is another case where you have to be careful before doing the first quarter turn since you can accidentally give yourself 5qt 2CXE, and here I once again recommend learning a handful of corner cases to use as visual cues that indicate it's safe to do a quarter turn. The bars+slashes with one matching and one opposite bar from before is one of the cues. Another one is the R2 U R2 U' R2 corner case (or the R2 F2 R2 equivalent). You could also have "commutator" corners that look like R' F' R B2 R' F R B2 (or the R2 F2 R2 equivalent). Lastly, you could have 3 opposite bars and one matching bar stacked on top of each other (R2 U R2 U' R2 U R2 U to set up, also has an R2 F2 R2 equivalent).

As for the alternative path, you can sometimes conveniently set up 3qt 4CXE if you have a certain corner case as a cue. I really don't think this path is even worth knowing, but for completeness sake, the setup moves for the corner case cues are as follows:

F2 U2 R2 U R2 U' R2
(R' F R F')3
Tperm R2 U2 F2 (note the side stickers don't look like the H/Pi OLL's)
Yperm R2 U R2

For 5qt 2CXE, again you can either set up to 4qt 2CXE or 4qt 4CXE. The better path is 2CXE, but again you'll almost always discard a DR with this case.
 
Thank you for sharing all your stuff!

I have been doing (almost) 100% HTR since September last year, and I started right away by learning the maze. There are 34 cases, but the way I see it they are actually 17 (ignoring parity) and you need to learn at least one odd path and one even path for each one. I am now in the process of improving my knowledge of the maze by learning all paths and how to set up each case to follow any given path. I think this is the way to go, but I am not as good at HTR as you (yet ;) )

Do you think the method you suggest here is better than just learning the maze? If so, how? Right now if someone asked me how to learn HTR, I'd tell them to learn how to recognize each maze case (not hard, except for a couple of tricky ones) and memorize how many quarter turns each case requires.
 
Thank you for sharing all your stuff!

I have been doing (almost) 100% HTR since September last year, and I started right away by learning the maze. There are 34 cases, but the way I see it they are actually 17 (ignoring parity) and you need to learn at least one odd path and one even path for each one. I am now in the process of improving my knowledge of the maze by learning all paths and how to set up each case to follow any given path. I think this is the way to go, but I am not as good at HTR as you (yet ;) )

Do you think the method you suggest here is better than just learning the maze? If so, how? Right now if someone asked me how to learn HTR, I'd tell them to learn how to recognize each maze case (not hard, except for a couple of tricky ones) and memorize how many quarter turns each case requires.
Glad to hear you appreciate my findings and work!

Before commenting on your approach, I'd need to know more about how you're personally interpreting and categorizing the 17 cases as I'm most familiar with traditional corner case recognition + what I've proposed here (the way I personally see it, HTR subsets could be either 12 cases or 14, but I'm not sure how it's possible to arrive at 17 cases)

As for what I'd recommend to people, I think for the time being it's somewhat personal preference since resources still aren't the best and even among the top solvers there seems to be quite a bit of differences in how we all recognize stuff. I do think that what I'm proposing ITT is the easiest since it's the smallest number of cases (12) while only requiring minimal advanced recognition techniques (namely NISS tracing and BLD tracing)

~~~

On a similar note: I've recently discovered & been made aware of some improvements to my method. I don't feel like rewriting the entire OP so I'm just going to list the main changes in bullet point form on this post!

1. Instead of BLD tracing for odd/even cycles or using some Cale tracing style system which should be possible (akin to Sq1 CSP), I think that if you're a relative beginner or just someone who cbf BLD tracing, you can determine the parity state of your DR by simply counting the number of qt in the scramble + DR solution. You could always start your attempts by writing out whether or not the scramble is odd or even and then use your DR solution afterwards to determine the parity state of your DR. This to me feels like a very sensible approach which further reduces barrier to entry!

2. For cases where I'm recommending either brute forcing or recognizing certain special corner cases, it's possible to eliminate the need for both using specialized NISS tracing systems depending on the case. Here's the current list for what I recommend with regards to NISS tracing that hasn't yet been covered by OP

0CXE 3qt - NISS trace the U layer corners and see if they become a 1q lookalike or 2q lookalike pattern. If they become 1, you're safe to do a qt, otherwise insert 1-2 half turns and try again (1 is always possible)

0CXE 4qt - NISS trace UFR+UFL and DFR+DBR (top front and bottom right) and see if they become 1q or 2q. If the become 2q, the correct first qt is U', if not, the correct first qt is U

4CXE 2qt (U R2 U style) - If you want to skip brute force checking, set your corners up such that they're 3 moves from becoming oriented and NISS trace two misoriented corners from one layer and two oriented from the other. If they trace to 1q, you're good to go, otherwise you'll need to set the oriented/misoriented corners into a 3-1 split and do the U2 fix. This is the only case where I personally feel brute forcing is probably just faster than bothering with NISS trace stuff as it isn't too many moves

4CXE 3qt (on the side of the scramble that looks like 1q) - If you want to skip brute force checking, set your corners up such that they're ready to be transformed to 2q lookalike and NISS trace the same set as 4CXE 2qt U R2 U style. If they become 2q, you're good to go, otherwise you'll need to do some sort of half turn manipulation beforehand

2CXE 3qt/5qt - Instead of brute force checking to see whether or not you have 3q or 5q, you can set the 2 misoriented corners onto different DR layers like you're preparing for a U R2 U R2 U finish. NISS trace 3 oriented corners on one of these layers + the misoriented corner from the other layer, 1q = 5q and 2q = 3q. It's possible to also use a similar NISS trace system to 4CXE 2qt U R2 U style to know which way to do the first qt if it's 3qt, but similar to before I think brute forcing is likely good enough if not strictly better

2CXE 4qt - For the optimal path (U R2 U' R2 U R2 U style), if you want to make sure your first qt gives 3q instead of 5q, when your corners are set up for a 1qt transformation to a difference 2XCE (aka both in same layer), NISS trace any 2 adjacent corners on the completely oriented layer, and any 2 diagonal corners on the layer containing both misoriented corners. 2q = first qt will work, 1q = you need to insert a half turn beforehand
 
Before commenting on your approach, I'd need to know more about how you're personally interpreting and categorizing the 17 cases as I'm most familiar with traditional corner case recognition + what I've proposed here (the way I personally see it, HTR subsets could be either 12 cases or 14, but I'm not sure how it's possible to arrive at 17 cases)

"My approach" is just the maze :) You said "I believe his method makes it seem like there's 35 cases but I could be wrong"; they are 34. I believe it offers some advantage over your classification, namely once you know the maze you exactly which other cases you can reach with setup moves + 1qt. The paths you can take do not depend on parity, so rather than counting that as part of the recognition I take it as an indicator of whether I need to pick an odd or an even path, hence the 17.

On the other hand, the maze classification is not invariant under switching, meaning you can have a different maze case on normal and on inverse (but yours is invariant, unless I misunderstood?).

For the recognition, I find the maze system to quite simple (UD pattern + side CO), except for a few special cases. I think you know them, but I guess it is useful for anyone else reading to share the recognition system here (I find the table in Rodney's document a bit too terse):
  • For the 1qt CO / UD "solved" case, you have to check if the 4 misoriented corners have the same UD color (sub-case A, can be 1 or 2 qt) or not (sub-case B, minimum 2 qt). This is very easy, but it is one extra step in the recognition.
  • For the 2qt CO / UD "bars" case, there are 3 cases. If all misoriented corners have the same UD color, you are in sub-case B (3/4 qt). If not, you have to check if setting up the CO case to a UR2U trigger is compatible with bars (sub-case A, 2/3 qt) or not (sub-case C, 4/5 qt).
  • For the 3qt CO / UD "bar/slash" case, you put the misoriented corners on the same layer and form the "bar/slash" UD pattern (rather than the 3+1 pattern). If the UD pattern bar and the bar formed by the misoriented corners are parallel, you are in sub-case A (3/4 qt), otherwise you are in sub-case B (4/5 qt).
 
Back
Top