• 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.

Big Cube BLD Discussion

Status
Not open for further replies.
Apologies if this has been posted before, but I don't remember this being discussed before.

At the advice of Mike, I have been doing post-mortems on my DNF solves for big cubes BLD. It has led to some surprising discoveries of what I am doing wrong in my solves, and has even led to me completely re-lettering my R face and inner r face pieces to something that works better for me.

The downside to how I was doing my post mortems is that I was just trying to reconcile my memorization with the scramble, and with what I thought I executed. This could often take a lot of time, sometimes as long as an hour to finally reconstruct the error in my solve. Since I don't want to take up to an hour to know what I did wrong, so that I might fix it on the next solve, I took a look at DNF reconstruction from a more theoretical standpoint. This led me to the method I use now, which is much faster.

Please forgive this bastardized notation, if it offends people enough I will try to put it into more mathematically precise notation.

Method to quickly do a post mortem on a DNF solve

Definitions:

Let denote the identity permutation. This is the permutation that has absolutely no effect on the cube (not necessarily in the supercube sense).

Let [X] denote the actual permutation performed on the scrambled cube once you put on the blindfold. More generally this can also denote performing permutation X on the cube, no matter which state it is in. For example [(AB)] would mean to perform the transposition of swapping the pieces in location A and location B on the cube. The current state of the cube does not matter.

[X]' denotes the inverse of permutation X. Specific to this method [X]' is the permutation that will setup a solved cube such that [X] will bring it back to the solved state.

[(scramble)] denotes a permutation that is equivalent to the scrambling algorithm. Usually this will be only applied to the pieces in question, and will not be the actual scrambling algorithm. More on this below. As a side note, the actual permutation memorized is [(scramble)]'

[(DNF)]' denotes the permutation that will solve the state your cube is in after removing the blindfolded and seeing that it is a DNF. Similar to the [(scramble)] permutation this is only applied to the particular piece type being examined. This would be equivalent to the cycles you would memorize in order to solve the DNF state of the cube.

---------------------

In the following notation permutations and cycles are read and performed on the cube from left to right. The following equation is always true.

[(scramble)] [X] = [(DNF)]

If [(DNF)] = then [X] is the correct solution to the scramble.

We now seek to solve for [X]', which is the permutation that will setup a solved cube into a state that can be solved with an equivalent series of cycles to the ones that you actually performed on the cube during your DNF solve.

Apply [(scramble)]' on the left on both sides of the equation.
[(scramble)]' [(scramble)] [X] = [(scramble)]' [(DNF)]
[X] = [(scramble)]' [(DNF)]
[X] = [(scramble)]' [(DNF)]
[X]' = [ [(scramble)]' [(DNF)] ]'
[X]' = [(DNF)]' [(scramble)]

Keep in mind that, if applied to a solved cube, [X]' will setup a state that can be solved using an equivalent permutation to what you actually performed on the cube to bring it to a still unsolved state. You may still have to analyze this equivalent permutation to figure out what you actually executed on the cube.

----------------

Example: Let's say that the scrambling algorithm sets up the cube into a state such that the cycle (ABCDEFGH) will solve the cube. In this case
[(ABCDEFGH)] = [(scramble)]'

This will also be your memorization of the cube, assuming you memorized correctly.

Let's say that after putting on the blindfold and applying your solution that you open your eyes to a DNF cube :( The cycle (EFD) will solve your DNF state.

Now the issue is to know what you did incorrectly during your solve. To do this we will apply [X]' to a solved cube.

[X]' = [(DNF)]' [(scramble)]
[X]' = [(EFD)] [(AHGFEDCB)]

After applying [X]' to the solved cube, it is in such a state that the cycle (ABCFGH) will solve the cube. (ABCFGH) is [X], and is an equivalent permutation to what you performed on the cube during your DNF solve. In this case it is easy to see that during the solve you did not execute the cycle (ADE), perhaps you recalled it but did not execute, etc..

A quick note about actually applying this method. Since your cube will already be in the DNF state after removing the blindfold, write down the cycle that will solve your DNF state. This cycle is [(DNF)]'. Notice that the start of our equivalent permutation to [X]' from the above equation is also [(DNF)]'.

So a way to remember to apply this method is to do the following:

Your cube, after the DNF, is in the state realized after applying [(DNF)] to the solved state.

Starting from [(DNF)] you would apply [ [(DNF)]' ]^2 [(Scramble)] to the cube.
[(DNF)] [ [(DNF)]' ]^2 [(Scramble)]
[(DNF)] [(DNF)]' [(DNF)]' [(Scramble)]
[(DNF)]' [(Scramble)]
[X]'

So basically from your DNF cube, perform the algorithm that solves the DNF state twice. Then perform the cycles you memorized on the cube in reverse. You can also just perform the scrambling algorithm, but keep in mind whether or not you did a reoriented solve as this needs to be taken into account as well.

Chris
 
Last edited:
Chris, great guide! Thanks for posting this, I'll definitely try it later :)

So it works for cycle errors, but can it help for setup move errors, or are they just be considered cycles?
 
Sounds like a good idea, but I'm wondering whether it can be used for centers at all. For instance, if you finish with an orange and a blue center wrong, what are you supposed to do for [(DNF)]'? There are several cycles which would work; will they all give the same result?
 
qqwref said:
Sounds like a good idea, but I'm wondering whether it can be used for centers at all. For instance, if you finish with an orange and a blue center wrong, what are you supposed to do for [(DNF)]'? There are several cycles which would work; will they all give the same result?
Click to expand...

Yes it does still work in this case, I have tried it. The reason is that the first thing executed on the solved cube is [(DNF)]'. Since the centers are indistinct, all possibilities to "swap" those two centers via 3-cycles appear equivalent after execution of the 3 cycle.

--edit--
The more I think about this though, I wonder if this method can be "tricked" into not correctly identifying the error, because the centers are indistinct. I would never shoot to two centers on the same face during a solve, though, so perhaps this is enough to ensure that the method cannot break down when used as described. I will try to think on this more, that's a very good point.
--edit--

Also, you can apply this method to all piece types simultaneously if you have a bad DNF. Your [(DNF)]' would include cycles spanning all piece types that were unsolved, and you would use the actual scrambling algorithm for [(scramble)]. I may also include a short write-up of how, specifically, to handle using this method on a re-oriented 4x4x4 (or 5x5x5) solve. I still find it very useful to reconstruct my solve using this approach even on a re-oriented solve.

@aronpm: I have not yet tried to see what happens when using this method with a setup move error. I'm wondering if the resulting [X] from such solves will have certain characteristics that would identify when the setup move error occurred. I will try to construct a purposeful DNF this way, and see what happens to [X] in that case.

Chris
 
Last edited:
Really cool BLD autopsy method! It's like turning your cube inside out. As far as setup move errors, I think since the "inversion" is based on what you memorized, setup move errors(along with everything affected by those errors) would be smeared across the cube when applying [[(DNF)]']^2, since there is no tie between the two. So if there is a one turn error on a 3x3, 8 pieces are affected, 2 adjacent turns and 13 pieces are affected, etc. Trying to pin down the exact setup move errors from this information sounds hard or impossible, especially on big cubes. But what is there to learn from those errors anyway?
 
Last edited:
qqwref said:
Sounds like a good idea, but I'm wondering whether it can be used for centers at all. For instance, if you finish with an orange and a blue center wrong, what are you supposed to do for [(DNF)]'? There are several cycles which would work; will they all give the same result?
Click to expand...

Michael,

I better understand what you're saying now, and can see that the method does not appear to work for centers.

I just constructed a scramble/DNF solution combo that the method cannot discover.

[(scramble)]' = (A EJ MQ)

This would be the memorization for me of the solve. It is shooting to the 1st location on each of my L,F,B faces, but shooting to the 2nd location on the R face (the 1st location is solved).

I purposefully performed the following DNF solution: (A EI MQ) which shoots to the 1st location on every face.

This leaves me with the following DNF state:
[(DNF)'] = (JM)

I see what you mean now that depending on my choice of 3 cycle for [(DNF)]' I will end up with different pieces cycled afterward. You can't just swap those pieces back (treating [(DNF)]' as a pure transposition) because this means that afterward you apply [(scramble)] and just end up with the scrambled state you originally stated with.

My only thoughts right now are that, looking at the DNF state of (JM) necessary to solve, and reconciling it with the memorization of (A EJ MQ) I would see that in the J location there is still a piece with the same color as the M location that J was supposed to shoot to. Not only that but the piece in the M location has the same color as the face containing the J location. This would seem to suggest that I shot the buffer not to J, but to another location on the same face that was already solved. This took the piece with the same color as the J location and sent it to M, which is why the M location has a piece of that color at the DNF state.

I feel like going back to the drawing board about this and seeing if there is a different method by analyzing the colors of the pieces in the DNF location, and reconciling this with the scramble, to see if you can discover what happened that way.

Also, and here's another thought,

[(scramble)] [X] = [(DNF)] is always true

If we perform [(DNF)] on a solved cube, then the cycle that will solve that position is [(DNF)]'.

Well in the case of this faked scramble we know [(scramble)]' = (A EJ MQ) and [X] = (A EI MQ)

[(scramble)] [X] = [(DNF)]
[(A QM JE)] [(A EI MQ)] performed on a solved 4x4x4 supercube leaves the cycle (M IJ) to solve.

So the [(DNF)]' that we should choose is (M IJ), but so far I see no way to know that this is the one to pick over the other options. Even if I did make the assumption before the scramble that I shot to a piece before J on the R slice, what if the [(DNF)]' was (ML)? This would mean that I would have 3 possible options of pieces before L on the R slice to use in [(DNF)]', and I wouldn't know which to pick.

Michael, do you have an ideas of either how to adapt this method to centers, or to come up with a different method that works for centers?

Chris
 
Last edited:
cmhardw said:
Michael, do you have an ideas of either how to adapt this method to centers, or to come up with a different method that works for centers?
Click to expand...
Mm, I don't think I do. The main problem here is that you can't reliably invert [(DNF)] when it involves centers - there are multiple inversions of the same cycles. And I think this means that several different single mistakes could lead to the same DNF. So there may not be a way to conclusively figure out the error at all.

Here's an interesting idea: imagine using a cube that is somehow marked as a supercube, but which you treat like a normal cube during the solve. You would hand it in solved supercube form to the scrambling table. Perhaps you could use some kind of non-colored markings for the centers, like dots on the URF and DLB corners and then dots on one corner of each center sticker; these dots don't have to be visible during solving (they could be dots of some fluorescent material). Then we still have [X]' = [(DNF)]' [(scramble)], but now [(DNF)]' can be directly calculated (but [(scramble)] needs to be the scrambling algorithm itself) and applied to a solved supercube - hopefully one with a more obvious coloring. So then you could get [X]', which you could then compare with a scrambled cube (or with your memo) to see the differences between the cycle solutions of those two cubes.
 
qqwref said:
Mm, I don't think I do. The main problem here is that you can't reliably invert [(DNF)] when it involves centers - there are multiple inversions of the same cycles. And I think this means that several different single mistakes could lead to the same DNF. So there may not be a way to conclusively figure out the error at all.
Click to expand...

Yes, I agree that this creates an issue for using this method on centers. However, if the DNF state is off by only two "swapped" centers, then you know that there are only 6 possible mistakes you could have made. The [(DNF)]' cycles that you would use must include the two unsolved pieces in the cycle, and must give the appearance of a "two-swap" after performing the 3 cycle. There are only 6 possible cycles that can do this. So I would say that the method will at least narrow down the possible mistakes to 6 options, and would be worth exploring.

When you end up with more than 2 pieces unsolved, you never know if one of these "2-swap" cycles was used or not in the process of creating the DNF state. So for anything more than 2 centers off I would certainly not attempt to use this approach.

qqwref said:
Here's an interesting idea: imagine using a cube that is somehow marked as a supercube, but which you treat like a normal cube during the solve.
Click to expand...

I really like that actually! I may actually practice this way on my supercube when at home. This way I could discover any mistakes in the centers much more easily. I would need to fix up a better cube than my current 4x4x4 supercube so that I could still get decent times on it, but that is a great idea I think! You would just solve the supercube in the regular cube sense as you said. Neat!

Chris
 
qqwref said:
hand it in solved supercube form to the scrambling table [...] these dots don't have to be visible during solving
Click to expand...

Yeah, they have to be not visible. Visible supercube markings are and should remain forbidden.

Btw, "during solving" not just the dots should be invisible :p
 
Stefan said:
Yeah, they have to be not visible. Visible supercube markings are and should remain forbidden.
Click to expand...
I wasn't only referring to competition solves, although I do agree that pieces on a competition cube should not be distinguishable etc. Although I can see why someone would want to precisely mimic a competition setup when they practice, perfectly reliable reconstruction may be more important to some people.

Incidentally, dots are nice because trying to recognize specific centers on purpose would take some conscious effort, so I wouldn't expect anyone to accidentally do it, as opposed to certain other supercube coloring schemes (like yours). You can draw dots with a Sharpie or similar non-permanent marker; if I recall correctly such dots tend to come off rather quickly (within a day) on typical stickers.
 
qqwref said:
I wasn't only referring to competition solves
Click to expand...

Ok... I was just alarmed cause you talked about handing it to the scrambling table. Didn't want any newbs to infer they can mark their cubes like that in competition (on the other hand, newbs probably can't blindsolve a 4x4x4 anyway, super or not).
 
So to bring up a different subject - how fast are you guys at sighted solving using your BLD method? I'm amazed by how long it takes me. My best time for 4x4x4 so far is about 5:30, which is not much faster than my best time BLD. I tried a 5x5x5 sighted with my BLD method today, and saw a bigger difference: 7:38.08. So that's about twice as fast as my typical BLD solve. (I've long believed that 5x5x5 BLD should be not much slower than 4x4x4 BLD if you're perfect at it, so somehow this does not surprise me.) How does everyone else do with this?
 
I just did one solve for each. Both were normal, nonlucky solves.
For 4^3: 4:32.33, about half my average 4BLD time
For 5^3: 7:38.77, about 1/3 of my average 5BLD time.
The difference doesn't surprise me because I make much more pauses during execution for 5BLD than for 4BLD.
 
Status
Not open for further replies.

Similar threads

cmhardw
Big cube BLD - solved centers analysis
Replies
5
Views
3,089
Kit Clement
Kit Clement
I
Big Cube BLD tips
Replies
3
Views
1,409
Cubenovice
Cubenovice
H
  • Poll Poll
Big cube BLD progression
2 3
Replies
47
Views
9,185
HEART
H
Z
Notice to big cube BLD beginners.
Replies
14
Views
4,765
riffz
riffz
B
New idea (I think) for big cube BLD
Replies
16
Views
3,715
deadalnix
deadalnix
Back
Top