Fixing 4x4x4 orientation parity earlier than usual

flavenstein

Member
Joined
Aug 2, 2012
Messages
2
Most 4x4x4 orientation parity algorithms I've seen are designed to be used once everything is fixed except for the top layer (i.e. these algorithms preserve the first three layers).

So here's what I'm wondering about: Suppose I've fixed the 4x4x4 centers, and I have aligned each edge pair. Is there a (short) algorithm which will change the edge orientation parity with no regard to the placement of the edge pairs? It seems reasonable that most of the 16 or so moves in the standard parity algos come mainly from restoring the first three layers, so I figure it would be shorter if you didn't worry about those layers.

IN OTHER WORDS: If I make the 4x4x4 look like the 3x3x3 (in the usual way), what is the shortest algorithm that will change the cube from the standard 3x3x3 orbit to the 3x3x3 orbit where one edge is flipped? (Feel free to give me a reference or a dirty look if this is standard knowledge and/or trivial)
 
But that algorithm preserves the position of each edge pair. Surely there is a simpler way to change the overall (3x3x3) edge parity if we don't specify that the positions of each edge pair are fixed, right?
 
I understand you question perfectly clear but I have no idea if such an alg exists as of now. I'm really interested if someone has a more concrete answer though. How do people generate algs for cubes other than 3x3 (cube explorer :D)??
 
It would probably be possible to create/find such an algorithm, but I don't understand why/how you would use it. You want to reduce the 4x4 to a 3x3, and then check the OLL parity. Checking this + performing the shorter algorithm will take you more time than just using the normal algorithm after solving F2L.
 
It would probably be possible to create/find such an algorithm, but I don't understand why/how you would use it. You want to reduce the 4x4 to a 3x3, and then check the OLL parity. Checking this + performing the shorter algorithm will take you more time than just using the normal algorithm after solving F2L.

That's true with CFOP, but what about with ZZ?
 
OLL parity takes around 2-2.5 seconds to fix normally (if you practise hard enough and do not lock up). Can someone really find a way to detect and eliminate OLL parity in less than this time? In my opinion, it seems very unlikely at the moment...
 
That's true with CFOP, but what about with ZZ?

Most people don't do reduction-ZZ because of how inspection-intensive ZZ is. It's very difficult to plan an EO line while finishing edge pairing, unlike cross which isn't quite as difficult. Also, you need to count the number of flipped edges manually and then plan an EO line, vs just spotting the 4 cross pieces and inserting them. Doing a cross from no inspection (or whatever minor inspection you can get while finishing edge pairing,) is almost as fast and only a little less efficient than a planned one, unlike EO line which I would guess is much less efficient.
 
Yes there is definitely a simpler algorithm that flavenstein is asking for. Anything odd that manages to preserve the faces will do. My usual is to give a slice a 1/4 turn (which of course is odd) and then fix the faces with commutators (which are always even). This is time consuming but very easy to remember. I'm sure he's right that there's a much shorter and faster method.

I'll take a crack at the (interesting but not actually "speedsolving") problem of trying to figure out the parity at the earliest possible stage. Be warned that I've solved maybe a half dozen 4x4x4s over the last 20 years and so take what I say with a big grain of salt.

The simplest method of early parity correction I can see is related to the slow way I solve the edges on big cubes. I only do the odd cubes, but the principle is the same. The game "looking for Waldo" becomes more and more difficult as you get older. So I find myself spending a lot of time doing edges the usual way. I finally got my 7x7x7 edge time below my face time by doing an orientation and then permutation sequence. That is, I orient the edges before I hook them up together. I use the common method of choosing two sides as an axis and using slices around that axis (without bothering to correct those slice moves until the end).

Since there are 12 edges and only 4 places to mess around with them by slicing, I divide the edges into three classes for fixing their orientation. I use white, yellow(black), and the rest. I put (black) because I use black instead of yellow as it's easier to distinguish.

First I get the black edges into the middle slices all oriented the same way. Once you get them there, (which is intuitive and fast), you permute them with slices and push them all on one side (I like to use black for this). Now I do the same for the other edges. In your case I would do the white edges next (but in fact I save them for last as they are the most visible and are harder to lose track of for me). When you're done with the white edges you'll have a cube with the white and black edges almost done, i.e. both will have corners "OLL" but not "PLL". That's okay, PLLs involve even numbers of cubes moving around and so will not effect parity.

Now line up all the remaining edges in their correct orientation. That is, green/orange, orange/blue, blue/red, red/green are aligned, the opposites orange/green, etc., are not. This is intuitive and faster than actually putting all the edges together. At this time, you still haven't put together the last four edges but their individual cubies are all aligned properly. Each can be put into its correct position (at the expense of messing up the faces) by a slice move.

The advantage of this position is that the edge slices are broken into two subgroups (or four for the 6x6x6 or 7x7x7), that is, you've got the left edges on the left side and the right edges on the right side. So the permutation group that applies to each of these subgroups is just P4, the permutation group of 4 elements. The group that applies to the complete set of them is P4xP4 (or P4xP4xP4xP4 for the 6x6x6 or 7x7x7). And the parity of each P4 is easy to determine by inspection as there are only 24 cases. The P4 parity is similar to how one does prepares for edge OLL in a 2-look OLL. And of course parity multiplies so the only way to get an odd overall parity is by having an odd number of odd parities.

If the result of the computation is that the parity is odd, you'd have to do a fix for it, but now the fix has more freedom than usual. Maybe it would be cheaper than the usual parity fix. And it's at least possible that by starting from a position where two opposite sides OLL crossed, you can make your 3x3x3 algorithms faster. For example, by only using the black side to flip the center edges you could ensure that you began the 3x3x3 stage with the white cross in place.

But really, I think the standard method is going to be a lot faster. This is a lot of baggage to haul around.
 
Haha, Ben, the Holy Grail Alg.! I recently changed the music and shortened the video. (I like it much better now myself).

Most 4x4x4 orientation parity algorithms I've seen are designed to be used once everything is fixed except for the top layer (i.e. these algorithms preserve the first three layers).

IN OTHER WORDS: If I make the 4x4x4 look like the 3x3x3 (in the usual way), what is the shortest algorithm that will change the cube from the standard 3x3x3 orbit to the 3x3x3 orbit where one edge is flipped? (Feel free to give me a reference or a dirty look if this is standard knowledge and/or trivial)
I know exactly what you're talking about. qqwref and I have made a special effort to document these type of algorithms you are referring to (cuBerBruce made the majority of them). See Algorithms Which Don't Preserve F3L (specifically, the shortest solutions in those two lists). I assume when you say "one edge flipped", you are referring to "OLL Parity" not "Double Parity". However, you are referring to either one, then as you will see, there are algorithms there for both types.

It seems reasonable that most of the 16 or so moves in the standard parity algos come mainly from restoring the first three layers, so I figure it would be shorter if you didn't worry about those layers.
Actually, the majority of the algorithms (including all of mine) are not as long as they are because they try to restore the first 3 layers. In fact, when I made the algorithm in the video above, I wasn't even focused on the first 3 layers. I mean, the pieces which I formed before I completed that algorithm were just to not affect more than the inner layers because they would otherwise scramble the entire cube for good. (By the way, I actually didn't understand the structure of any regular parity algorithms until after I made the algorithm--and algorithms like it--in that video...my point being that I learned from my brain--and from blood, sweat, and tears--how a big percentage of common algorithms are constructed from scratch by first constructing an algorithm without even paying attention to the first 3 layers).

It isn't obvious to those who don't understand these algorithms (there are even a few computer algorithms which I still do not fully understand), but a very high percentage of existing algorithms only focus on inducing an odd permutation and solving back the centers.

(If you would like to possibly learn how a lot of these algorithms work, see Methods for Forming Parity Algorithms).


(*)All of the common parity algorithms for the last layer (including the single edge flips) just focus on cycling 8 or fewer wing edge pieces in an odd permutation (and solving back the centers), while the algorithms which do not preserve F3L (in the wiki) aim at cycling more wing edge pieces. If you, say, cycle more than 8 wing edge pieces (more than the M layer can hold), then you are forced to do more outer layer turns than usual to align wing edges outside of M with a few wing edge pieces from M into one inner layer slice to do the extra quarter turn (which induces the odd permutation). Another scenario is when an algorithm cycles pieces in M with those outside of M. With either case, it's impractical (move wise) to restore F3L from the destruction caused by these outer layer turns, which is what the shortest algorithms which don't preserve F3L clearly show.

(**)The only algorithms match your description are those which specifically end (or begin) with 3x3x3 moves (outer layer turns only)--and I mean more than just one move.

To give examples for the statements (*) and (**),

Example 1
Just grabbing the first (17,13) solution from the wiki:

Rw B U2 B' r B2 l B2 r B' D2 B Rw

and solving the corners with the inverse of the outer layer turns throughout the algorithm:
Rw B U2 B' r B2 l B2 r B' D2 B Rw
R' B' D2 B B2 B2 B U2 B' R'


This algorithm in particular clearly doesn't cycle more than 8 wing edges (just 6), but not all of them are in M. This shows that obtaining shorter OLL parity fixes (which don't preserve F3L) means just finding the shortest route to cycle wing edges outside of the M layer with the M layer.

Example 2
Grabbing an equivalent of the (15,15) (OLL parity only) solution (another one of cuBerBruce's amazing algs),
Uw F' B2 R B' Uw u L' R u' L R' Uw d L R' F Uw

and doing the same to it as was done in the previous example,

Uw F' B2 R B' Uw u L' R u' L R' Uw d L R' F Uw
U' F' R L' U' R L' R' L U' B R' B2 F U'





I think I was actually the first to successfully make shorter algorithms (in q turns, that is) with this idea in another thread. See this post for a detailed derivation of one of my first successful algs like this. (That algorithm isn't double parity, so 21q turns was a breakthrough back then, since the minimum used to be 25q...before I showed the algorithm in the video that is (which was 19q) and then cuBerBruce made his 17q and then his 15q.)

The reason I couldn't get fewer than 15 half turns is just because the cycle class of that algorithm is:
a 2 2-cycle and a 4-cycle,
where as cuBerBruce's (17,13) is a 6-cycle. There could possibly be a shorter solution for a 2 2-cycle + 4-cycle, but not as short as (17,13) because cuBerBruce did an in-depth computer search and did not find any non 6-cycles of that length.

EDIT:

And just in case you are wondering what the minimum most likely is for algorithms which destroy the centers, see this post.
 
Last edited:
My usual is to give a slice a 1/4 turn (which of course is odd) and then fix the faces with commutators (which are always even). This is time consuming but very easy to remember. I'm sure he's right that there's a much shorter and faster method.
I recently broke the record for both half turns and quarter turns for the 4-cycle checkboard case.
Observe that it is just a conjugate.
Study how I set up the centers before I did the quarter turn, and I think this might be what you are referring to.

(f2 u' r2 Uw2 S') r (S Uw2 r2 u f2) (17,11)
(Only one commutator is required to make a single edge flip.)
​
 
I recently found another path which could be considered an intuitive (double) parity fix (well, at least to me).

For those who know how many parity algorithms I have found in my time, note that this algorithm does not build on any of the parity algorithms that I found.


I know that this might be a lot of words, but if I were to make a video explanation, I'm sure it wouldn't be longer than a few minutes. You can follow this process and make dozens of parity algorithms.
cmowla said:
...note that this algorithm does not build on any of the parity algorithms that I found.
Okay, I lied, because the first piece is an algorithm I found before, but please be patient with me to explain it along with the second piece.

[1] With any 4x4x4 parity algorithm, it is a given to start out with an inner layer slice turn because OLL parity is referring to wing edges.
Rw'

[2] Four dedges are now unpaired. The closest thing we can do in comparison to just inverting Rw' with Rw is to replace one of these 4 unpaired dedges with a paired dedge from the outside first.
U R' U

Note that we do not do U R' U', but we could also do U' R' U', because besides replacing one of the 4 unpaired dedges from step 1, we want to have two 1x2 center blocks of the same color to be adjacent to each other in slice r (in this case with this alg.garron.us animation, these are white).

The reason we do this is because the second (middle) inner layer slice turn will become the extra quarter turn once the third (last) inner layer slice turn is done: with many 4x4x4 parity algorithms, when two 1x2 center blocks adjacent to each other in the same slice when the extra quarter turn is
applied to that slice, those two centers will be swapped with each other when the algorithm is complete (Here's a simple example). This means that we can preserve one full center by just carefully following this fundamental rule.

[3] Now we are ready to do "the extra inner layer quarter turn". This move should pair back up one of the 4 originally unpaired dedges and unpair a new dedge. So we still have 4 dedges unpaired.
Rw
*It is very important that we don't pair back 2 dedges in this step because if we want to still keep 4 dedges unpaired because we can pair up 4 dedges with the third and final inner layer slice in this first main part of this 17 STM algorithm.

[4] For this step, all we are going to do is perform some outer layer turns to line up the 4 unpaired dedges so that with one more inner layer slice turn, all dedges will be paired up again.

Based on the route taken, U F2 U is sufficient to do this. We can finish off with Rw', since that's the obvious move from this point to pair back all of the dedges.

Note that U F2 U also positioned the two white 1x2 center blocks on opposite sides of the cube so that, with the final inner layer quarter turn slice, they shall be matched up.

[5] So now we have a 9/10 move (depending on how you count moves) double parity algorithm which destroys the colors of 3 centers. Obviously the next step is to fix the centers. If you have ever used the 3 move sequence Rw U2 Rw' to pair up centers (without worrying about dedge pairing), simply observe that those three moves "flip" the top front dedge and unpairs the top back and front bottom dedges (observe that the green-yellow wings are in the same slice and the white-blue wings are in the same slice.)

So, let's use this. The top center is complete, so let's keep it that way. If we observe the formation of the 3 discolored centers, if we want to use Rw U2 Rw' (and move equivalences of that) to fix up the centers, the only two choices we have in our algorithm is to either do the move F2 or D2 first to line up the two green 1x2 blocks (we must solve the next center adjacent to the top center because the move sequence Rw U2 Rw' does not swap center pieces in opposite centers to be able to solve the centers should we instead pair up the bottom center). For a reason you will soon see, F2 is the proper choice for fewer moves.

So let's do F2 and one application of that 3 move sequence.
(Rw' U R' U Rw U F2 U Rw') F2 Rw F2 Rw'

[6] Now only two centers are discolored and two dedges are unpaired (which is actually great).

Although it may not be initially obvious, but the move S2 will give us the same formation which we saw Rw U2 Rw' generate earlier. So we can now finish off the algorithm with that to get...

(Rw' U R' U Rw U F2 U Rw')(F2 Rw F2 Rw' S2 Rw' U2 Rw)

If we would have instead chose to do D2 (instead of the bold F2 move above, in step [5]), then the resulting path would be (Rw' U R' U Rw U F2 U Rw') D2 Lw' F2 Lw S2 x', for which we would need to first do S R2 S' to get the last two centers lined up to finish off.
Here's another 17 STM algorithm, which follows the same process as the algorithm above, and it can be applied to any orbit of any size cube. On the inner orbit of the 7x7x7 in SiGN notation,
 
Back
Top