Welcome to the Speedsolving.com, home of the web's largest puzzle community! You are currently viewing our forum as a guest which gives you limited access to join discussions and access our other features.
For whatever it's worth, I have now determined "all" optimal reduction OLL parity fixes (in block turns). Of course, by this I'm referring to algs that will convert a reduction state with odd OLL parity to a reduction state with even OLL parity.
Very nice piece of work. I have also been wondering about this for quite some time now. I don't know if you will easily be able to modify your program, but my curiousity compells me to ask - What is the optimal reduction OLL parity fix (same as above) with the only difference of allowing up to 4 of the center pieces to be unsolved?
Very nice piece of work. I have also been wondering about this for quite some time now. I don't know if you will easily be able to modify your program, but my curiosity compels me to ask - What is the optimal reduction OLL parity fix (same as above) with the only difference of allowing up to 4 of the center pieces to be unsolved?
Very nice piece of work. I have also been wondering about this for quite some time now. I don't know if you will easily be able to modify your program, but my curiousity compells me to ask - What is the optimal reduction OLL parity fix (same as above) with the only difference of allowing up to 4 of the center pieces to be unsolved?
I modified my program to allow any number of centers to be unsolved, and the result for that is 9 block turns, and also 9 block quarter turns. Allowing up to 4 of the center pieces to be unsolved seems to break the symmetry of the bidirectional search. But I should only have to store positions to a depth of 5 from each end. So I think it's doable. I might also be able to do it using an IDA* search as checking to a depth of 11 would suffice.
I've now found an optimal 4x4x4 OLL parity fix (from a reduction state to a reduction state) in terms of block quarter turns. It's length is 15 block quarter turns.
YES! At long last, I've finally found a memorization method that works for me to at least memorize the 15 move algorithm (r2 B2 U2 l U2 r' U2 r U2 F2 r F2 l' B2 r2). I kept fighting with it and giving up here and there for the past while, but today during a slow period at work, I somehow stumbled upon a way to remember it.
It turned it into a story . With a bit of memorization of specifics.
(r2, B2, U2)
Inner left comes down for a look
(U2)
Inner right follows him down
(U2)
Inner right runs away!
(U2, F2)
Inner right increases the distance!
(F2)
Inner left tries to catch up
(B2, r2)
Aaaand that's how I memorized it. Not sure why it worked, but it'll keep me remembering it until I can whip through it quickly without thinking.
Very nice piece of work. I have also been wondering about this for quite some time now. I don't know if you will easily be able to modify your program, but my curiousity compells me to ask - What is the optimal reduction OLL parity fix (same as above) with the only difference of allowing up to 4 of the center pieces to be unsolved?
I modified my program to allow any number of centers to be unsolved, and the result for that is 9 block turns, and also 9 block quarter turns. Allowing up to 4 of the center pieces to be unsolved seems to break the symmetry of the bidirectional search. But I should only have to store positions to a depth of 5 from each end. So I think it's doable. I might also be able to do it using an IDA* search as checking to a depth of 11 would suffice.
For up to four center pieces permuted to another face, my program had to consider many "solved" states for one of the two search trees in the bidirectional breadth-first search. This limited my program to going out to only depth 3 on that search tree. So my program only considered up to depth 7 in one search tree and 3 in the other for only a depth of 10. The program found no solutions at that depth, so if it was implemented correctly, there are no 10-turn solutions. (My depth-first search also did not find any solutions at depth 10, but it it did not finish searching all possibilities at this depth.) This means that an optimal edge parity fix for preserving edge pairs and permuting at most 4 center pieces to other faces has been narrowed to a range of a lower bound of 11 turns and an upper bound of 12 turns.
My bidirectional breadth-first search for 15q reduction edge parity fixes is over half done, and has only found 4 cases so far - the two cases I mentioned previously, and their inverses.
EDIT: Using a depth-first search, I have now found algs of 11 turns that change the parity of edge pieces while preserving edge pairing and moving only 4 center pieces to another face. So 11 turns appears to be optimal for this particular constraint. Using the other 20 centers as reference, these algs can be considered double parity fixes.
I believe I have now found all 15 BQTM reduction parity fixes for OLL parity and double parity. The sequences below represent all such maneuvers, allowing for:
symmetrical equivalence (conjugating by a symmetry of the cube)
reordering of commuting moves
taking the inverse
converting of sequences through the use of trivial move substitutions and cube rotations (e.g. substituting Dw for Uw and modifying the rest of the maneuver accordingly)
The curly braces indicate a choice of any of the moves listed within.
I note that the last two are mirror-symmetric to their own inverse.
{ Uw, u, d } (lr') R D R' Fw f (ud') l' (u'd) Fw b (u'd) F { Lw, l, r } (OLL parity)
{ Uw, u, d } R' b (ud') d' L' b L u' b2 Uw (l'r) B' { Uw, u, d } (double parity)
{ Uw, u, d } (fb') L B' R u d f' u d L B' R (fb') { Uw, u, d } (double parity)
{ Uw, u, d } (fb') L' F R' u d f' u d L' F R' (fb') { Uw, u, d } (double parity)
I believe I am done my research on odd parity algorithms, but I decided to just look at cuBerBruce's (17,13) oll parity (only) algorithm again, now that I know much more than when I first looked at it. In no time, I decomposed it and created a neat semi-related algorithm from it.
The following two posts are relevant to what I am about to say (in particular, the text which is in bold font).
I have been somewhat curious to find out exactly how many moves (block turns) are actually required to fix OLL parity on the 4x4x4. So I've now done my own analysis, and I have believe I have exhaustively checked up to a depth of 12 block turns, and determined there is no OLL parity fix that preserves pairing of edges and correctly solved centers (but not necessarily for a supercube) up to that depth.
The standard OLL parity fix and double parity fix algs are 15 block turns. That means you can not save more than two moves if you don't care about the effects on corners and don't care about preserving edge permutation (only preserving their being paired).
I have now also found algs of 13 block turns that fix OLL parity as well as double parity (and preserves pairing of edges and solved centers). So these algs are optimal in block turns for these parity cases.
There may be many other optimal algs. Most likely there exist other optimal algs that are better than these examples in terms of ease of execution or how much of the cube is preserved.
Just for the OLL parity (only) algorithm, it's a non-symmetrical 6-cycle algorithm (not my strong point), so I don't know how much I can break it down as of yet (don't count on it). However, here is a different translation of it so that it can successfully be applied to a 5x5x5 as well:
In addition, this translation proves that the parity correction of this algorithm is single slice turned based (I wasn't sure before), as we can now use only single slice turns (but much less is preserved, as far as the bandaged 3x3x3 is concerned). z r B' U2 B r B2 l B2 r B D2 B' r z' y
This really reminds me of the algorithm I finally concluded the "Wanted New Dedge Flip Algorithm" thread with, because it is not a 2-cycle either (it's a 2x2 cycle and a 4-cycle), and it doesn't really depend on the wide turns it has (they only help to preserve more of the puzzle than if it was all single slice turns). l U2 l' F U R U' Lw' D2 r D2 r U2 Rw' U2 Lw F (22,17)...
For the single slice turn version, taking out the cube rotations (they were not really needed anyway: I put them there originally to match cuBerBruce's algorithm). r B' U2 B r B2 l B2 r B D2 B' r (17,13)
it can actually be looked at as a symmetrical algorithm (what I am familiar with the most).
Here's a little "derivation" which I follow pretty closely to make a longer algorithm, (my algorithm is both easier to execute and its preserves more, however).
Derivation
[1] Start with the conjugate of the extra quarter turn (this is what all symmetrical parity algorithms I made or seen have, so cuBerBruce's algorithm has a similar structure to common algorithms, to believe it or not). r B2 l' B2 r'
And this is my algorithm (also OLL parity only). It visually preserves all pieces except for the last layer and an F3L slot on the 4x4x4 (in single slice turns, that is). r' U2 F U2 F' U2 r' U2 r' U2 r' F U2 F' r' (21,15)
Derivation
[1] Start with the conjugate of the extra quarter turn. r U2 r' U2 r'
=
r'
U2 F U2 F' U2 r2
r U2 r' U2 r'
F U2 F' r2
r
=
r'
r2 F U2 F'
F U2 F' r2
U2 F U2 F' U2 r2
r U2 r' U2 r'
F U2 F' r2
r
=
r F U2 F'
F U2 F' r2
U2 F U2 F' U2 r2
r U2 r' U2 r'
F U2 F' r'
=
r F U2 F'
F U2 F' r2 U2 F U2 F' U2 r2
r U2 r' U2 r'
F U2 F' r'
=
r F U2 F'
F U2 F'
r2 U2
F U2 F'
U2 r2
r U2 r' U2 r'
F U2 F' r'
= [r F U2 F': [F U2 F', r2 U2] [r U2: r'] ] (21,15)
= r' U2 F U2 F' U2 r' U2 r' U2 r' F U2 F' r' (21,15)
My alg is obviously 15 btm like optimal 2-cycle algorithms are, but it is 4 quarter turns less, which sacrifices a F3L slot and the U layer (in single slice turns). It's also shorter than my algorithm in the post I wrote (quoted in the first spoiler) which was (22,17), not to mention much cleaner (but my (22,17) is a 4-cycle and a 2 2-cycle of wings, not a 6-cycle of wings like these algorithms. Therefore it might not be good to compare the algorithms too much, because they are entirely different permutations).
You can follow the same process that I did for cuBerBruce's algorithm to find related algorithms (pretty simple process IMO).
EDIT:
I forgot to mention that you can also execute my algorithm with the F moves inverted to affect the right F3L slot instead of the left, however, you cannot convert inner layer turns to wide turns for this version:
If I counted correctly, cuBerBruce listed 237 OLL parity algorithms in this post (including double parity algorithms) which were not in the conventional move set of <U2,F2,D2,B2,l,l',l2,r,r',r2> (which can be found with just about any cube solver that I am aware of).
L-> D' (conventional move set)
L -> L' (conventional move set)
D -> D' (conventional move set)
D -> L' (conventional move set)
E -> F' (conventional move set)
F -> E' (conventional move set)
Therefore, I chose to just analyze the 237.
Excluding inverses and transformations, there were only 8 unique algorithms. I have labeled where each one came from, but you cannot find some of them in cuBerBruce's list exactly as shown because all 8 are transformations which work on all cube sizes. I made sure all 8 are directly transferable to all size cubes (via inner layer slice turn transformations) and that they were listed in an order which shows how each algorithm is related (move wise).
OLL (Only) (17,13)
u B L2 B' u B2 d B2 u B' R2 B u (B -> B')
u B' L2 B u B2 d B2 u B R2 B' u (A -> A')
u B L2 B' u B2 u R2 d B R2 B' u (B -> C')
u B' L2 B u B2 u R2 d B' R2 B u (A -> K')
Double Parity (19,13)
u F2 L2 d F L' U L' u2 B2 u' B2 u2 (G -> J' )
u F2 L2 d F' L D' L u2 B2 u' B2 u2 (H -> I')
u F2 L2 d F L' (U D') L' u2 B2 u' B2 u2 (G -> J')
u F2 L2 d F' L (U D') L u2 B2 u' B2 u2 (H -> I')
Notice that the only difference between the algorithms 1 and 2; algorithms 3 and 4; and algorithms 7 and 8, is that the outer layer quarter turns in one algorithm are inverted in the other.
Speed Optimization
With no exception, all 8 algorithms preserve the most if as many turns are made wide as possible. In addition, I didn't find the inverses of these to preserve more than they do.
OLL Parity (Only) Algorithms
The First Algorithm
None of the three inner layer turns on the inside can be made wide turns, nor can any of them be transformed. Therefore, it will not be a candidate (because it preserves little and is slow).
The Third Algorithm (doesn't preserve that much)
The italicized move can be made wide if the two moves surrounding it are both inner layer turns, but that doesn't preserve much better. Rw U F2 U' Lw F2 r U2 Rw U B2 U' Rw (17,13) (cuBerBruce)
The Fourth Algorithm (doesn't preserve that much)
The italicized move can be wide if the two moves surrounding it are both inner layer turns AND they are (d y) and (u y') instead of (u) and (d), but that doesn't preserve much better. Rw U' F2 U Lw F2 r U2 Rw U' B2 U Rw (17,13) (cuBerBruce)
Double Parity Algorithms
All inner layer turns may be converted to wide turns. Transformations of these double parity algorithms (when all turns are wide) do not improve how much is preserved, and therefore, they should be done for the sole purpose of improving speed.
I have modified each algorithm to what I believe to be the fastest form. I had to add one quarter turn move at the end of the algorithm to preserve more.
(the third and fourth algorithms clearly will not be fast).
Therefore, only 3 algorithms (algorithms not in the conventional move set) from cuBerBruce's post preserve as much as their counterparts (these type of algorithms) and have potential for speedsolving use (in my opinion).
So, it appears that they must be more moves to preserve more, like, for example, the OLL Parity (only) algorithm I made from studying cuBerBruce's OLL Parity (only) algorithm above: r' U2 F U2 F' U2 r' U2 r' U2 r' F U2 F' r' (21,15) (In wide turns, it preserves as much as the second double parity algorithm above, but in single turns, it preserves a corner more).
Last month I was looking at cuBerBruce's (15,15) OLL Parity solutions to see if I could make sense of them. Well, I didn't try for too long to do that, but I was able to make adjustments to the "final product", to get OLL Parity algorithms which do not preserve anything but the pairing of wing edges. This may or may not be interesting to you all (it was to me though, ) but...
Note that these work on the 5x5x5 too for wing edges (just as Bruce's original algs did).
I'm not sure if these are optimal, but I have never seen an OLL Parity (only) alg lower than 15q before (preserving the centers or not), and the lowest I made a double parity like this was my (13,11).
From cuBerBruce's OLL Only (15,15) solution:
Uw M R D R' Fw f E' l' E Fw b E F Lw x2 z'
=Uw M R D R' Bw z f E' l' E Fw b E F Lw x2 z'
=Uw M R D R' Bw f M d' M' Fw b M' F Dw y2
=Uw M R D R' Bw f M d' M' Fw b M' F Uw y
=Uw L' R R F R' Dw u L' R u' L R' Uw d L R' F Uw y
=Uw F' B2 R B' Uw u L' R u' L R' Uw d L R' F Uw
=
(Uw F' B2 R B' U) (u2 L' R u' R' L u2) (U2 D' B F' L Dw)
u2 L' R u' R' L u2 = f' (for permuting the wings)
So substituting f' for (u2 L' R u' R' L u2), we get the (12,12) OLL Parity (only) solution.
For the double parity solution, also substitute F for the "F' B2" in red font.
We simplify omit cube rotations in the middle of the algorithms to achieve the algorithms being "derived."
I was studying cuBerBruce's (15,15) OLL Parity (only) algorithm again, and this time I understood it much better.
As a result, I have made some new dedge preserving parity algorithms which don't preserve F3L or the centers from scratch (but following the structure of cuBerBruce's alg).
I failed to realize that you can exchange the last move (i.e. replace Rw with Lw, Rw' with Lw', and viceversa) to have either a double parity or OLL parity (only). Some algs in the wiki are better to be viewed (or must be viewed) as one or the other. I'll put these and those which I previously put in the wiki like this in an "either or" section.