I realize this is bumping a very old thread, but years ago I would have put this observation here.
I made an interesting mistake in a 5BLD solve today. I executed two adjacent images in the wrong order.
So, for example, I had the cycle:
(A BC DE FG)
And the next two commutators I executed were:
(A DE BC)
I realized this mistake before executing the third image, and was able to undo what I had done and execute again in the proper order.
During this same solve I also had a recall delay of one centers image. I moved on past that image and used my “pick-up” cycling approach of adding one final cycle at the end with floating buffer to account for the image that I purposefully skipped earlier, once I was later able to recall it.
Well, this got me thinking that there must be a pickup cycling approach for swapping two images.
Mapping it out made it clear that there is an approach to use that does not involve backtracking the incorrect execution.
Start with a scramble memo of:
(A BC DE FG)
Execute, incorrectly, (A DE BC)
The scrambled state itself would start out looking like:
BCDEFGA
Note that solving this state has memo: (A BC DE FG)
So from the starting state above, I execute (A DE) and end up with a scrambled state of:
FCDBEGA
Now execute, still incorrectly to the original memo, (A BC)
The scrambled state becomes:
DFCBEGA
To solve this state I would memo:
(A DB FG)
And this shows already our pickup cycle would be: (A DB)
Now go back to the original memo of:
(A BC DE FG)
If I execute with the images BC and DE swapped, I don’t have to undo those two cycles, then redo them in the proper order. After completing the second incorrect cycle, I can fix my error by executing: (A DB) which is the first letter from the second image followed by the first letter from the first image.
Executing this one pickup cycle is equivalent to undoing the two cycles and then redoing them again in the correct order!
The way to remember this is to orient yourself around the “correct” memo order.
If I know that I executed:
(A DE BC) when I actually was supposed to do (A BC DE) then I can complete the incorrect execution of (A DE BC) and follow by:
([Buffer] -> [First letter of 2nd image in correct memo order] -> [First letter of 1st image in correct memo order])
Note also that you can anchor off your “wrong” memo and pickup cycle with:
([Buffer] -> [First letter of 1st image in “wrong” memo order] -> [First letter of 2nd image in “wrong” memo order])
And now I can save myself three cycles by doing one pickup cycle to fix the mistake rather than four cycles to fix the mistake.
I’m fairly out of the loop on current BLD theory, so this may already be a well known trick used. If so, I’m happy to also discover it as a technique to use! If this is new, hopefully it will help someone!
