[Help Thread] FMC Discussion

[undick]

fmc.mustcube #299 1-hour limit

Scramble : B2 F2 R' L2 U2 R2 L2 D L' U R F2 L D' L' D2 U' B U2 D' B2 U' F D2 F' B2 L R B2 F'

Solution: B R' F2 L F' D F' D2 F2 L2 F U2 D R2 U2 L' F' U' L2 D' B' F L2 B F' D' L2 (27 moves)

Found with NISS

Normal scramble : B R' (1x2x2)

Inverse scramble : U F L U2 R2 D' U2 F' L2 F2 (Pseudo block+3rd F2L)

Normal Scramble : [B R'] F2 L F' D

Inverse Scramble : [U F L U2 R2 D' U2 F' L2 F2] D2 F

Final <--- for inverse scramble
Premove from normal scramble : D' F L' F2 R B'

2x2x3 : U * F L U2 R2 D' U2 F' L2 (9/9)
Leave 3 edges : F2 D2 F (3/12)
Undo Premove : D' F L' F2 R B' (6/18)

I found edges cycle at * with L2 U' D2 M' D2 M U L2 (10 moves). When i check all my solution, the cube is not solved. And i try to remove the edges cycle, then the remaining edges become to U Perm. Is this right? I don't understand about edges cycle. At least, this is my first edges cycle try in a solution. Can you tell me about this?

So, i use U Perm L2 D' B' F L2 B F' D' L2 (9 moves)

Final Solution

Solution from inverse scramble : B R' F2 L F' D F' D2 F2 L2 F U2 D R2 U2 L' F' U' (18/18)
PLL U : L2 D' B' F L2 B F' D' L2 (9/27))

 

[cuBerBruce]

Hello!

This weeks FMC was my first ever and I write this in order to get some feedback. I haven't been cubing for very long and I don't have such a deep understanding as some people here seem to have. I have learnt Petrus, Heisse (just for a few hours) and a 3-cycle method for BLD. I know full PLL, but not full OLL. i say this just to give you an idea of what I can and can't do. If someone has the time to comment on what I did for this week's FMC, I'd be delighted!

Here is the scramble: R' D U B D' L R B' F' U2 B2 F' U' F R B D' B2 U' D2 R D2 B' D B D' R2 L B L2

And my solution:
2x2: F' B' R' D' B' D2 (6/6)
2x2x3: F . U' R F R2 (5/11)
Extend: U' F2 U2 F' L F2 L2 (7/18)
EO: U2 L (2/20)
EP: F U F' U' (4/24)
Corners: R' D R U' R' D' R U (8/32)

Insert at dot : F' D' F U2 F' D F U2 (cancels four, so 8/40 - 4 = 36)

I know basic block building from Petrus, but since I've only used it for speedcubing before, I still find it pretty hard to find optimal solutions, especially after the 2x2x2 is built (and obviously, my 2x2x2 wasn't the best around either). I wasted even more moves on the extension of the block.

The ending seems better and I also tried to find an insertion, which went pretty well, although that might just have been luck.

My biggest problem, I think, is that it takes me ages to do the practical things. I often screw something up and don't remember how to revert, meaning I have to solve the cube and scramble it again, which takes perhaps a minute. I don't know how long it took me to find this solution, but it was probably a couple of hours.

So, any suggestions where I can improve?

Cheers!

Olle Linge
http://www.snigel.nu

Snigel, I also would say that is very nice first FMC attempt.

My suggestion is that when you have a 5-cycle of corners for the ending, to consider using two insertions, rather than just one (at least, if you have the time). I took a look at your skeleton, and found it to be fairly rich in good insertion points for the 5-cycle ending (after your "EP" step).

I found two 8-move insertions with 4 moves cancelling.

The first is the same as the insertion you found. The second is after the nineteenth move and solves (URF, UFL, RUB) of the original 5-cycle. As it turns out, this insertion solves the pieces that remain unsolved by the first insertion! This means your solution could have been reduced to 32 moves using both insertions.

F' B' R' D' B' D F U2 F' D F U R F R2 U' F2 U2 F' L F2 L2 U2 F R' F' L F R U F' U' (32)

I labeled the corners of the 5-cycle this way:
1 = UFL, 2 = RUB, 3 = ULB, 4 = LFD, 5 = URF

The first 3-cycle insertion (the one you used) cycles (2,3,4). The later insertion cycles (5,1,2). Note that the earlier 3-cycle starts with 2, and the later 3-cycle ends with 2. (The cycles must be labeled in "consecutive order" for this to work; you can't rewrite (2,3,4) as (3,4,2). That is, you must write the possible 3-cycles as (1,2,3), (2,3,4), (3,4,5), (4,5,1), and (5,1,2).) Then if you have an insertion for (n,*,*) earlier in the skeleton than another insertion for (*,*,n), the two insertions together will solve the 5-cycle. (Just avoid insertions too close together that the desired cancellations interfere with each other.)

Of course, alternatively you could apply one 3-cycle, and then look at what 3-cycle you have left when you apply the solution including that insertion. Then, look for an insertion for that 3-cycle.

 

[PM 1729]

fmc.mustcube #299 1-hour limit

Final <--- for inverse scramble
Premove from normal scramble : D' F L' F2 R B'

2x2x3 : U * F L U2 R2 D' U2 F' L2 (9/9)
Leave 3 edges : F2 D2 F (3/12)
Undo Premove : D' F L' F2 R B' (6/18)

I found edges cycle at * with L2 U' D2 M' D2 M U L2 (10 moves).

First of all, you shouldn't post solutions before the round has ended.

Anyway, that is an extremely inefficient way of doing that cycle. it can be done as U' M B2 M' B2 U which is M U2 M' U2 conjugate. Most edge insertions can be done using this.

I haven't gone through the entire solve. I'll post a better insertion once the round is over.

 

[Snigel]

Its very good for your first attempt.

The block building does not need to be optimal. Try to explore possibilities which have better continuations.

Learn how premoves work (if you don't already know). It will help you a lot.

Finally ,you should practice to reduce the time you take to find a good solution.

All the best!

Hello!

This weeks FMC was my first ever and I write this in order to get some feedback. I haven't been cubing for very long and I don't have such a deep understanding as some people here seem to have. I have learnt Petrus, Heisse (just for a few hours) and a 3-cycle method for BLD. I know full PLL, but not full OLL. i say this just to give you an idea of what I can and can't do. If someone has the time to comment on what I did for this week's FMC, I'd be delighted!

Here is the scramble: R' D U B D' L R B' F' U2 B2 F' U' F R B D' B2 U' D2 R D2 B' D B D' R2 L B L2

And my solution:
2x2: F' B' R' D' B' D2 (6/6)
2x2x3: F . U' R F R2 (5/11)
Extend: U' F2 U2 F' L F2 L2 (7/18)
EO: U2 L (2/20)
EP: F U F' U' (4/24)
Corners: R' D R U' R' D' R U (8/32)

Insert at dot : F' D' F U2 F' D F U2 (cancels four, so 8/40 - 4 = 36)

I know basic block building from Petrus, but since I've only used it for speedcubing before, I still find it pretty hard to find optimal solutions, especially after the 2x2x2 is built (and obviously, my 2x2x2 wasn't the best around either). I wasted even more moves on the extension of the block.

The ending seems better and I also tried to find an insertion, which went pretty well, although that might just have been luck.

My biggest problem, I think, is that it takes me ages to do the practical things. I often screw something up and don't remember how to revert, meaning I have to solve the cube and scramble it again, which takes perhaps a minute. I don't know how long it took me to find this solution, but it was probably a couple of hours.

So, any suggestions where I can improve?

Cheers!

Olle Linge
http://www.snigel.nu

Snigel, I also would say that is very nice first FMC attempt.

My suggestion is that when you have a 5-cycle of corners for the ending, to consider using two insertions, rather than just one (at least, if you have the time). I took a look at your skeleton, and found it to be fairly rich in good insertion points for the 5-cycle ending (after your "EP" step).

I found two 8-move insertions with 4 moves cancelling.

The first is the same as the insertion you found. The second is after the nineteenth move and solves (URF, UFL, RUB) of the original 5-cycle. As it turns out, this insertion solves the pieces that remain unsolved by the first insertion! This means your solution could have been reduced to 32 moves using both insertions.

F' B' R' D' B' D F U2 F' D F U R F R2 U' F2 U2 F' L F2 L2 U2 F R' F' L F R U F' U' (32)

I labeled the corners of the 5-cycle this way:
1 = UFL, 2 = RUB, 3 = ULB, 4 = LFD, 5 = URF

The first 3-cycle insertion (the one you used) cycles (2,3,4). The later insertion cycles (5,1,2). Note that the earlier 3-cycle starts with 2, and the later 3-cycle ends with 2. (The cycles must be labeled in "consecutive order" for this to work; you can't rewrite (2,3,4) as (3,4,2). That is, you must write the possible 3-cycles as (1,2,3), (2,3,4), (3,4,5), (4,5,1), and (5,1,2).) Then if you have an insertion for (n,*,*) earlier in the skeleton than another insertion for (*,*,n), the two insertions together will solve the 5-cycle. (Just avoid insertions too close together that the desired cancellations interfere with each other.)

Of course, alternatively you could apply one 3-cycle, and then look at what 3-cycle you have left when you apply the solution including that insertion. Then, look for an insertion for that 3-cycle.

First of all, thanks for your encouragement and your advice! I think I understand most of what you're talking about, even though I might not yet be able to apply it. I have a few questions, though!

Premoves: A move done prior to the scramble, which is then corrected at the end of the solve (is this correct?). This, I think, could be applied almost anywhere in the solve, but I've no idea where it's most commonly used.

Corner cycles: Using Heisse or Petrus, I often end up with corner cycles I can't handle. For instance, what do I do if I have them correctly permutated, but incorrectly oriented? I know how to solve that from BLD, but that sequence is like 20 moves long. Or if i have four corners left, of which one is correctly permutated but misoriented and the others are both misplaced and misoriented?

I think there are many cases which can be solved with 8-move cycles that I just don't see or know about. My knowledge about commutators is not good enough to be able to solve any three-corner cycle. Any suggestions for how to improve here?

Insertions: I realise that a 1, 2, 3, 4, 5 cycle can be broken up in many ways, all of which might yield favourable insertions. Right now, my method is just to solve the cube to that state, put tape on the cycled stickers on the corners. Then I go through the solution and try to find positions where a corner cycle would coincide with other parts of the solution and thus cancel moves. Is this good?

I think my major problem here is that I don't know any algos for this and, as I said, my commutator understanding is not good enough. I actually checked for another insertion for the other cycle, but didn't find one!

---

Thanks for your feedback, it made me throw myself into this week's challenge with enthusiasm, rather than giving up, as I must admit I've been close to doing several times!

Olle Linge
http://www.snigel.nu

 

[Kryptonite]

Fascinated by FM

Hey guys, I'm new to the cube community, and am fascinated by FM. I'm still getting the hang of it--my best so far is a 37. I've got a lot to learn, because I've never speed solved, the first method I learned was Human Thistlethwaite and I just figured out commutators about two weeks ago.

As I've been processing all the info in these threads, playing with a cube, and using cube explorer, I've figured out a few things that aren't explicitly said here that I figured might help out. I'm sure a lot of you guys already know this stuff, intuitively or otherwise, but it helped me to write it down, so I might as well share.

-----

Every 8f move corner 3-cycle is a commutator

3 of 8 cases for corner 3-cycles can be solved with an 8f move
1 of 5 cases where no corners are adjacent
3 of 5 cases where exactly two corners are adjacent
1 of 3 cases where one corner is adjacent to both others

By applying corner 3-cycles haphazardly, odds are 2 in 3 that you will end up with a corner twist.

I only just realized that YXY-1X-1 is the inverse of XYX-1Y-1. This previously cut my insertion opportunities in half.

As an example, we can cycle 3 corners with R'DR U R'DR U'
To cycle them the other direction we can do U R'DR U' R'DR
The selector move (the U face) is at the beginning instead of the end.

-----

I really liked blah's summary on 6-move edge 3-cycles:

All 6-move edge 3-cycles:

1. S F2 S' F2
2. F2 S F2 S'
3. Conjugated S F2 S' F2 (read two posts above for explanation)
(S = quarter slice turn; F2 = half face turn)

And I think it can be simplified to a single case. If we position the edge that must move the furthest on the FD and one edge on the UF then these three cases can be expressed as:

L R' (F2 R L' U2)

This allows for 6 cancelation optimizing scenarios:
Start L End U2
Start R' End U2
Start F2 End L
Start F2 End R'
Start L End R'
Start R' End L

-----

Hopefully, only a couple of these result in face-palms, and others are somewhat helpful.

 

[Feryll]

Spoiler

Hey guys, I'm new to the cube community, and am fascinated by FM. I'm still getting the hang of it--my best so far is a 37. I've got a lot to learn, because I've never speed solved, the first method I learned was Human Thistlethwaite and I just figured out commutators about two weeks ago.

As I've been processing all the info in these threads, playing with a cube, and using cube explorer, I've figured out a few things that aren't explicitly said here that I figured might help out. I'm sure a lot of you guys already know this stuff, intuitively or otherwise, but it helped me to write it down, so I might as well share.

-----

Every 8f move corner 3-cycle is a commutator

3 of 8 cases for corner 3-cycles can be solved with an 8f move
1 of 5 cases where no corners are adjacent
3 of 5 cases where exactly two corners are adjacent
1 of 3 cases where one corner is adjacent to both others

By applying corner 3-cycles haphazardly, odds are 2 in 3 that you will end up with a corner twist.

I only just realized that YXY-1X-1 is the inverse of XYX-1Y-1. This previously cut my insertion opportunities in half.

As an example, we can cycle 3 corners with R'DR U R'DR U'
To cycle them the other direction we can do U R'DR U' R'DR
The selector move (the U face) is at the beginning instead of the end.

-----

I really liked blah's summary on 6-move edge 3-cycles:

All 6-move edge 3-cycles:

1. S F2 S' F2
2. F2 S F2 S'
3. Conjugated S F2 S' F2 (read two posts above for explanation)
(S = quarter slice turn; F2 = half face turn)

And I think it can be simplified to a single case. If we position the edge that must move the furthest on the FD and one edge on the UF then these three cases can be expressed as:

L R' (F2 R L' U2)

This allows for 6 cancelation optimizing scenarios:
Start L End U2
Start R' End U2
Start F2 End L
Start F2 End R'
Start L End R'
Start R' End L

-----

Hopefully, only a couple of these result in face-palms, and others are somewhat helpful.

Wow, you show some real initiative I can tell someone's been lurking. Anyone who would facepalm this post would have to be a jerk. You seem to know more about cube theory than a big portion of this community. You'll do just fine here I recommend learning Petrus for the block building (for FMC) and either Roux (If you happen to fall in love with block building) or Fridrich (If you prefer better turning speed [Most speedsolvers use this; not sure if that should be considered a positive or a negative]). Hope your experience here helps your confidence in cubing and in life in general

Spoiler

And the basic stuff everyone learns eventually, that I suspect you already know

1. Use the search function at the top of the page before asking most things, you'll be amazed what has been thought of since 2006 here (Yeah I'm one to talk, I've only been here since last New Year's Eve)

2. Make heavy usage of the one question one answer thread

3. Make lots of jokes, and turn your sarcasm detector on to tell when someone is acting that way

 

[blah]

For optimal solutions to any 3-cycle of corners, there are only
1. 6 unique 8-movers
2. 4 unique 9-movers
3. 2 unique 10-movers
4. one 11-mover
5. one 12-mover

By unique I mean mutually non-isomorphic. Any optimal solution you name will be isomorphic to one of these 14 cases.

 

[Kryptonite]

Haha, lurking would be putting it nicely . I've been using Heise for block building so far, and I'll have to look into Petrus and Roux. How do the three compare for non-linear FM?

Nice break down of the corner 3-cycles blah, from what I can tell, it's gonna be rare that you run into a skeleton that can't get an 8f* insertion, am I right on that?

----

Also, I'm curious what strategies people have for edge 3-cycle insertions. It seems like there are an endless number of cases for these.

If we break down the three edge placements topologically (to avoid isomorphs) we get nine cases:

1. T - T - T
2. T - T - A
3. T - T - F
4. T - A - F
5. T - F - F
6. T - F - O
7. A - A - O
8. A - F - F
9. F - F - F

Where T = Touching (4 cases), two edges that are next to each other. A = Across, two edges on the same layer and opposite (2). F = Far, think of a chess knight's movement here, move to an opposite side, then move left or right (4). O = for opposite, as far as it can be from the other (1). So the three letters in combination describe their locations relative to each other.

(if anyone knows or has suggestions for better notation, or wants clarification, let me know)

Only the A - A - O case can be solved with a 6f*, but the odds of it randomly appearing are 2/55, and the odds it being oriented correctly are 1/4.

Only the T - A - F case can be solved with 8f*, and while it has a decent chance to manifest (12/55), we still run into the 1/4 orientation problem.

By the T - A - F case we have something like 30 possible ways to insert, it seems a bit daunting to look for the best insertion at every move in the skeleton.

So, is the strategy to avoid leaving an edge 3-cycle in the first place? Or does someone know a way to get real mileage out of edge insertions without gobbling up a bunch of time?

 

[blah]

I've just listed the number of unique cases. It says nothing about the distribution. Distribution is here.

 

[Stini]

Haha, lurking would be putting it nicely . I've been using Heise for block building so far, and I'll have to look into Petrus and Roux. How do the three compare for non-linear FM?

Nice break down of the corner 3-cycles blah, from what I can tell, it's gonna be rare that you run into a skeleton that can't get an 8f* insertion, am I right on that?

I have done quite a few insertions and my worst result is finding only an 8-move insertion (no cancellations) so it's indeed quite rare. My average is about 5-6 moves I guess. Also I don't recall having a solution that had no 8-movers in the skeleton. Also it's quite rare that a case of over 8 moves is the best place for insertion (meaning that if you have a 9-mover, but it happens to cancel more moves than the best 8-mover). I know all the optimal corner commutators, but for most people I'd just recommend to look for an insertion only if the case is a 8-mover.

Also, I'm curious what strategies people have for edge 3-cycle insertions. It seems like there are an endless number of cases for these.

If we break down the three edge placements topologically (to avoid isomorphs) we get nine cases:

1. T - T - T
2. T - T - A
3. T - T - F
4. T - A - F
5. T - F - F
6. T - F - O
7. A - A - O
8. A - F - F
9. F - F - F

Where T = Touching (4 cases), two edges that are next to each other. A = Across, two edges on the same layer and opposite (2). F = Far, think of a chess knight's movement here, move to an opposite side, then move left or right (4). O = for opposite, as far as it can be from the other (1). So the three letters in combination describe their locations relative to each other.

(if anyone knows or has suggestions for better notation, or wants clarification, let me know)

Only the A - A - O case can be solved with a 6f*, but the odds of it randomly appearing are 2/55, and the odds it being oriented correctly are 1/4.

Only the T - A - F case can be solved with 8f*, and while it has a decent chance to manifest (12/55), we still run into the 1/4 orientation problem.

By the T - A - F case we have something like 30 possible ways to insert, it seems a bit daunting to look for the best insertion at every move in the skeleton.

So, is the strategy to avoid leaving an edge 3-cycle in the first place? Or does someone know a way to get real mileage out of edge insertions without gobbling up a bunch of time?

That's interesting, I have to admit that I haven't thought much about edge insertions. I can solve them of course, but my reasoning is that the edge insertions usually involve slice turns, which count as two moves in official FMC rules, so the most intuitive commutators to me (supercube safe) are at least 10 moves. Also I personally find it easier to leave just a 3-cycle of corners than edges. Here are all the cases, but the primary goal of the list is to provide supercube safe commutators, so they are not always optimal for 3x3x3.

Usually if I have to make an edge insertion, I try to setup to M' U2 M U2 (or R' U2 R L' B2 L if you like) or use supercube safe commutators that happen to cancel some moves. Also R U R U R' U' R' U' R' U is useful.

I wasn't aware of T-A-F (with the correct orientation of course) being possible to be solved in 8-moves. This certainly makes it more appealing for me to use edge insertions more. For those unaware of this like me, here's the output of ACube for one case (should include all the optimal solutions in HTM):

B2 R2 U' B2 L2 F2 D' L2 (14q, 8f*, 8s)
B2 R2 D' R2 B2 L2 U' L2 (14q, 8f*, 8s)
L2 B2 R2 U' B2 L2 F2 D' (14q, 8f*, 8s)
L2 B2 R2 D' R2 B2 L2 U' (14q, 8f*, 8s)
R2 U' B2 L2 F2 D' L2 B2 (14q, 8f*, 8s)
R2 D' R2 B2 L2 U' L2 B2 (14q, 8f*, 8s)
R2 B2 L2 U' F2 L2 B2 D' (14q, 8f*, 8s)
R2 B2 L2 D' L2 B2 R2 U' (14q, 8f*, 8s)

I don't yet understand these completely, but to me it seems like these are pretty much variations of R2 U' F2 D' and R2 D' L2 U', which solve the 3-cycle ignoring other pieces.

 

[boyscout]

I just remember to post. This is our new Indonesian NR by Juan Juli Andika Chandra. He just got that on Indonesian Championship 2010 last 2 weeks.

Nice solution with a very massive cancellation (more than 10 cancel)!!!
How lucky he is. Nevertheless, 29 moves is really deserve as a NR.



scramble for Indonesian Championship 2010
R U2 L' U2 L D' U2 B U F2 R D2 B' F R' D2 R2 D U2 R2 U2

2x2x2 block = D B D U2 B ( becomes premove for inverse scramble)

inverse scramble = U2 R2 U2 D' R2 D2 R F' B D2 R' F2 U' B' U2 D L' U2 L U2 R'

premove = B' U2 D' B' D'

2x2x2 + 1x2x2 (pseudo block) = L F' L' (Add F to premove so the pseudoblock becomes normal)

premove = F B' U2 D' B' D'

2X2X3 = L F' L' F2 (3/3)
EO = F B' L F' B (5/8)
3rd F2L = D L D L (4/12)
leave 2 edge & 2 corner = F' D F D F' D' F (2/14)
setup = F
permute 2 edge & 2 corner = F2 D F D' F' D R F L' F L F R' F2 D2 (9/23)
undo setup = F B' U2 D' B' D'

L F' L' F' B' L F' B D L D L F' D2 R F L' F L F R' F2 D2 F B' U2 D' B' D' (29)
inverse all to get solution


solution = D B D U2 B F' D2 F2 R F' L' F' L F' R' D2 F L' D' L' D' B' F L' B F L F L' (29)

 

[Kryptonite]

Distribution is here.

Awesome, that settles it. Odds are better than 50% that an 8f* is possible at any random scramble, meaning you'd have to be really unlucky not to find one. This had been my experience so far, and looks like that of Stini as well.

I have done quite a few insertions and my worst result is finding only an 8-move insertion (no cancellations) so it's indeed quite rare.

Aside from the fact that skeleton assembly is not random, 16 moves makes for .0007% chance that a 8f* can't be found.

-----

Great break down of the 4-unique 9-movers aronpm, pictures are always nice .

The most interesting take-away I got from this is that all the 9-movers are conjugated 8f* moves. They are 9f* instead of 10f* because one of the conjugate moves combines for a cancelation. For example, we can look at the inverse Sune to see this.

R' U R' D2 R U' R' D2 R2

The 8f commutator hiding here is: R U R' D2 R U' R' D2
The conjugate is: R' (Y) R
The R' and R at the beginning cancel for 9f*

This allows us to rule out looking for them when doing insertions. We could never get better cancelations, because would be essentially doing the same algorithm!

-----

I have to admit that I haven't thought much about edge insertions. I can solve them of course, but my reasoning is that the edge insertions usually involve slice turns, which count as two moves in official FMC rules, so the most intuitive commutators to me (supercube safe) are at least 10 moves.

I haven't spent much time with big cubes, so I've never bothered to be supercube safe, and I think it's a luxury that can't be afforded in Fewest Moves--besides of course, just avoiding edge insertions, which is certainly valid.

The slice moves actually make edge insertions more appealing, as they are so versatile for cancelations (almost too much so!). The caveat, however, is that the moment you must use a conjugate to set up the edges, you lose a lot of that versatility.

blah originally posted the 8f* edge cycles, and it looks like you got them all for that case (there are three others, inverse, L/R mirror, and inverse L/R mirror). I broke down the 8 algorithms like this:

1. L2 B2 (R2 D' R2 B2 L2 U') (8f*)
2. L2 B2 (R2 U' B2 L2 F2 D') (8f*)
3. R2 B2 L2 D' L2 B2 R2 U' (8f*)
4. R2 B2 L2 U' F2 L2 B2 D' (8f*)

Two is an interesting set, because by moving L2 or B2 L2 to the back, the result is the same from doing so to set number one.

I feel like these four cases could be expressed in less patterns, but I haven't been able to find it myself.

 

[Stini]

The most interesting take-away I got from this is that all the 9-movers are conjugated 8f* moves. They are 9f* instead of 10f* because one of the conjugate moves combines for a cancelation. For example, we can look at the inverse Sune to see this.

R' U R' D2 R U' R' D2 R2

The 8f commutator hiding here is: R U R' D2 R U' R' D2
The conjugate is: R' (Y) R
The R' and R at the beginning cancel for 9f*

This allows us to rule out looking for them when doing insertions. We could never get better cancelations, because would be essentially doing the same algorithm!

That is incorrect, you can only rule out conjugates that don't cancel any moves with the commutator. The cancellation becomes a double turn in this case, which makes the difference. You might for example have an insertion point for R' U R' D2 R U' R' D2 R2 and let's say that next moves in the skeleton would be R2 D2. You can't cancel those moves with other insertion.

But you are right that in general conjugated commutators can be ignored, for example there is a 10-move case (often called the orthogonal case), which is a conjugated 8-mover (U L' B R2 B' L B R2 B' U' is one example). This case can be ignored during insertion.

 

[Mike Hughey]

Awesome, that settles it. Odds are better than 50% that an 8f* is possible at any random scramble, meaning you'd have to be really unlucky not to find one. This had been my experience so far, and looks like that of Stini as well.

I have done quite a few insertions and my worst result is finding only an 8-move insertion (no cancellations) so it's indeed quite rare.

Aside from the fact that skeleton assembly is not random, 16 moves makes for .0007% chance that a 8f* can't be found.

I know I'm probably not as good as you guys at looking for insertions, but I've had a couple where I couldn't find an 8f* anywhere in the whole solution. It seems like if there is one, they exist all over the place - like every other move. But if there's not one, they're not to be found at all. So I suspect your "skeleton assembly is not random" factor is sufficiently important that .0007% is probably overly hopeful. But I'll admit I might be wrong.

 

[Stini]

Awesome, that settles it. Odds are better than 50% that an 8f* is possible at any random scramble, meaning you'd have to be really unlucky not to find one. This had been my experience so far, and looks like that of Stini as well.

I have done quite a few insertions and my worst result is finding only an 8-move insertion (no cancellations) so it's indeed quite rare.

Aside from the fact that skeleton assembly is not random, 16 moves makes for .0007% chance that a 8f* can't be found.

I know I'm probably not as good as you guys at looking for insertions, but I've had a couple where I couldn't find an 8f* anywhere in the whole solution. It seems like if there is one, they exist all over the place - like every other move. But if there's not one, they're not to be found at all. So I suspect your "skeleton assembly is not random" factor is sufficiently important that .0007% is probably overly hopeful. But I'll admit I might be wrong.

I have noticed that as well, and it kind of makes sense, because let's say your insertion at some point in the skeleton is Per's special (12f*), you will have an 11-move case at best in next and the previous step. It takes a while before you get from Per's special to an 8-move case and vice versa.

 

[Mike Hughey]

Awesome, that settles it. Odds are better than 50% that an 8f* is possible at any random scramble, meaning you'd have to be really unlucky not to find one. This had been my experience so far, and looks like that of Stini as well.

I have done quite a few insertions and my worst result is finding only an 8-move insertion (no cancellations) so it's indeed quite rare.

Aside from the fact that skeleton assembly is not random, 16 moves makes for .0007% chance that a 8f* can't be found.

I know I'm probably not as good as you guys at looking for insertions, but I've had a couple where I couldn't find an 8f* anywhere in the whole solution. It seems like if there is one, they exist all over the place - like every other move. But if there's not one, they're not to be found at all. So I suspect your "skeleton assembly is not random" factor is sufficiently important that .0007% is probably overly hopeful. But I'll admit I might be wrong.

I have noticed that as well, and it kind of makes sense, because let's say your insertion at some point in the skeleton is Per's special (12f*), you will have an 11-move case at best in next and the previous step. It takes a while before you get from Per's special to an 8-move case and vice versa.

Good point.

 

[Kryptonite]

you can only rule out conjugates that don't cancel any moves with the commutator. The cancellation becomes a double turn in this case, which makes the difference. You might for example have an insertion point for R' U R' D2 R U' R' D2 R2 and let's say that next moves in the skeleton would be R2 D2. You can't cancel those moves with other insertion.

Hmmm... this may be true in some instances, but I don't think so. If you look at the example you provided, we can break it down like this:

R2 <R U R' D2 R U' R' D2> R2 + R2 D2

Which, after cancelations, looks like:

R' U R' D2 R U' R'

However, since our conjugate is R2, it means that we could do the same 8f* after the skeleton's R2 instead, which looks like this:

R2 + R U R' D2 R U' R' D2 + D2

Which, after cancelations, is identical to the previous instance:

R' U R' D2 R U' R'

-----

This could be unique to the example you provided, and I'm not sure how to prove it for all cases. So while I'm not yet positive either way, my gut tells me 9f*s yield identical results.

Props on the skeleton example being R2 D2 btw, haha.

 

[Stini]

you can only rule out conjugates that don't cancel any moves with the commutator. The cancellation becomes a double turn in this case, which makes the difference. You might for example have an insertion point for R' U R' D2 R U' R' D2 R2 and let's say that next moves in the skeleton would be R2 D2. You can't cancel those moves with other insertion.

Hmmm... this may be true in some instances, but I don't think so. If you look at the example you provided, we can break it down like this:

R2 <R U R' D2 R U' R' D2> R2 + R2 D2

Which, after cancelations, looks like:

R' U R' D2 R U' R'

However, since our conjugate is R2, it means that we could do the same 8f* after the skeleton's R2 instead, which looks like this:

R2 + R U R' D2 R U' R' D2 + D2

Which, after cancelations, is identical to the previous instance:

R' U R' D2 R U' R'

-----

This could be unique to the example you provided, and I'm not sure how to prove it for all cases. So while I'm not yet positive either way, my gut tells me 9f*s yield identical results.

Props on the skeleton example being R2 D2 btw, haha.

I made a mistake by thinking that the conjugate was R' :fp, I didn't have a cube with me when writing my message so let that be my poor excuse.

So the cancellation is in the beginning of the commutator instead, now let's consider that the previous moves in the skeleton were U' R and now we can make insertion R' U R' D2 R U' R' D2 R2. Now doing the commutator a move earlier wouldn't make the same cancellations. Anyway my point is that you should still check for cancellations from that end of the commutator where there is a cancellation with the conjugate.

 

[Kryptonite]

I suspect your "skeleton assembly is not random" factor is sufficiently important that .0007% is probably overly hopeful. But I'll admit I might be wrong.

I have noticed that as well, and it kind of makes sense, because let's say your insertion at some point in the skeleton is Per's special (12f*), you will have an 11-move case at best in next and the previous step. It takes a while before you get from Per's special to an 8-move case and vice versa.

Stini has hit the nail on the head here, and Mike is right that .0007% is overly hopeful. The key element is that going from one state to the next through the skeleton does not generate "independent" scenarios. The .0007% is simply a result that I could calculate. Getting the real likelihood is far beyond my abilities and could probably only be done with random sampling.

If people are really curious what the odds of a 8f* solution are, I could figure it out with enough solves--more than I could do on my own in a reasonable time.

If you are interested, PM me following data on your solves:
1. Length of the skeleton
2. Length of the final solve
3. Number of 8f*s possible within the skeleton
4. Number of 8f*s that cancel 1 move, Number of 8f*s that cancel 2, etc.
5. Your basic solve method (you can keep this basic)

Also you must:
1. Have only a single corner 3-cycle insertion (no 5s or edge cycles too)
2. Be 90% sure you have found all the 8f*s (no need for 100%, just be pretty confident)

That's it. If I get enough data I'll absolutely share everything I learn from it and credit everyone for each solve submitted.

 

[Stini]

I suspect your "skeleton assembly is not random" factor is sufficiently important that .0007% is probably overly hopeful. But I'll admit I might be wrong.

I have noticed that as well, and it kind of makes sense, because let's say your insertion at some point in the skeleton is Per's special (12f*), you will have an 11-move case at best in next and the previous step. It takes a while before you get from Per's special to an 8-move case and vice versa.

Stini has hit the nail on the head here, and Mike is right that .0007% is overly hopeful. The key element is that going from one state to the next through the skeleton does not generate "independent" scenarios. The .0007% is simply a result that I could calculate. Getting the real likelihood is far beyond my abilities and could probably only be done with random sampling.

If I'm not mistaken, this could be considered to be a Markov chain so you could make a transition matrix and calculate the probabilities from there.