# WANTED: New Dedge Flip Algorithm!

#### Christopher Mowla

The only dedge flip algorithm I can recall which did need to destroy additional dedges to be briefer (not double parity, only OLL) was the one I showed you before:
r U2 r' U2 r D2 r D2 r' F L' F' U' r' D2 r
That DOES fit the "mess up more, less moves" idea, though definitely messes up too much.
For those who thought the 21q/16h above was interesting, here is another 21q/16h which preserves everything on the cube but the U and F faces:

In WCA notation:
Rw U2 Rw' U2 Rw D2 r D2 l' U L' U' B' l' U2 l x'

Note 1: This algorithm must be performed exactly as shown in order to preserve the most. If all slice turns are wide, then it will scramble the reduced 4X4X4 just as much as the other one. If all slice turns are converted to wide except for the bold r turn, then still a 3X3X3 block is preserved:
Rw U2 Rw' U2 Rw D2 r D2 Lw' U L' U' B' Lw' U2 Lw x'

Note 2: This is not a double parity algorithm. The single slice version is two 2-cycles and a 4-cycle of wing edge pieces, hence giving the overall effect on a 4X4X4 just a single edge flip. (The other algorithm I previously gave out was two 4-cycles and a 2-cycle).
r U2 r' U2 r D2 r D2 l' U L' U' B' l' U2 l
U2 B U L U' M

As a matter of fact, by the cube generated from the algorithm above, it is evident that I used the front-left F2L slot to create a sub-25q algorithm. In addition, the 21q/16h is just the inner-layer workings of this overall 4-cycle+ two 2-cycle algorithm. The rest of the moves are neglected because they do not need to be executed to help break the odd permutation in the inner orbit, nor restore the centers and repair up the dedges.

Note 3:

These algorithms are NOT for odd cubes. Only for the 4X4X4 and larger even cubes which are reduced to 4X4X4s.

Final Note:
It obviously can't be used for speedsolving, but I thought I would share it with everyone to show that 21qs like this do not need to scramble the reduced 4X4X4 completely. It's pretty cool to do a double parity and adjacent PLL parity in 29q though (I am referring to the full algorithm).

Last edited:

#### Stefan

##### Member
to show that 21qs like this do not need to scramble the reduced 4X4X4 completely.
Wasn't that clear already? Here's one Lucas posted last year:
r' B2 r D2 l' F2 r F2 D2 l U2 l' B2 l

That's from the text file linked to here. And here's one of his 19q, doesn't scramble it much, either:
l F2 r' F2 l' D2 r D2 l' D2 l B2 r'

It's pretty cool to do a double parity and adjacent PLL parity in 29q though
Why? Is this 25q for example not cooler (shorter and purer)?
l F2 r' F2 l' D2 r D2 l' D2 l B2 r' B2 D2

#### Christopher Mowla

to show that 21qs like this do not need to scramble the reduced 4X4X4 completely.
Wasn't that clear already? Here's one Lucas posted last year:
r' B2 r D2 l' F2 r F2 D2 l U2 l' B2 l
Note 2: This is not a double parity algorithm. The single slice version is two 2-cycles and a 4-cycle of wing edge pieces, hence giving the overall effect on a 4X4X4 just a single edge flip.
r' B2 r D2 l' F2 r F2 D2 l U2 l' B2 l +B2 U2 B2=double-parity
l F2 r' F2 l' D2 r D2 l' D2 l B2 r' +B2 D2=double-parity

The algorithms you gave are double-parity. I was referring to the case where it was not double-parity, as I have strongly implied in my post, I believe.

Yeah, sure 19q doube-parities can be achieved through the conventional move set. Here is one I made last year:
r D2 r' D2 r F2 r' F2 r B2 l U2 l'

It's pretty cool to do a double parity and adjacent PLL parity in 29q though
Why? Is this 25q for example not cooler (shorter and purer)?
l F2 r' F2 l' D2 r D2 l' D2 l B2 r' B2 D2
I was referring to doing two algorithms which normally take 21+18=39q in 10q less, not just a pure double-parity (look at the DF and FL dedges of the cube that 29q is executing on...yeah there is a pure double-parity in U, but that's not the only effect this algorithm has).
r U2 r' U2 r D2 r D2 l' U L' U' B' l' U2 l
U2 B U L U' M

(Oh, and if anyone is wondering, this is how that algorithm is performed on the 5X5X5).

I apologize, Stefan, if any of the terms I used led you to think I was referring to double-parity. I realized that earlier in this thread, you misunderstood me in the same manner.

When I say "solely OLL", I am saying a 4X4X4 is just a 2-cycle away from being a perfectly reduced 4X4X4, not a 4-cycle away (like double-parity). If there is some terminology that is better for me to use, let me know.

Last edited:

#### Stefan

##### Member
Yeah, it has just become confusing, I've lost track of what's been done. And I'm sloppy, "double parity and adjacent PLL parity" should've made me wonder (as that hints at not being double parity at all). Sorry...

Last edited:

#### Christopher Mowla

It's okay. This whole thread has been confusing, and I know I have caused the confusion. I apologize for bumping up this thread lately, but I couldn't ignore the relevance of the algorithms I found lately that belong no where else but here.

#### Christopher Mowla

Bump once again!

I found another 21q/16h which preserves even more. If one quarter turn move is added to it, it preserves everything but the U layer and a F2L slot.

I want to fix this parity flip as soon as I find it, but these "pure" or "OLL pure" appear to be wasting moves by pointlessly putting pieces into positions that weren't solved yet anyway.

Can anybody PLEASE come up with an all New 4x4x4 dedge flip algorithm that is NOT pure, and can take full advantage of a not yet solved F2L pair and a free LL?reThinker
Here is the algorithm (perform exactly as shown): (22q/17h)
Rw U2 Lw' U2 l D2 l D2 Rw' U' L U F r' U2 r F

If the following moves are added, and this algorithm is performed on the 5X5X5, we see what's really happening:
Rw U2 Lw' U2 l D2 l D2 Rw' U' L U F r' U2 r F
F' U2 F' U' L' U R U2 L U2 R'

There is a 4-cycle (double-parity) between UF and DF, where UF is the edge being "flipped". In addition, there is a 2 2-cycle between UB and FR. Because the first portion of this algorithm is composed of the conventional move set (R2 U2 Lw' U2 l D2 l D2 Rw'), all composite edges affected/un-paired at that point are in M. The rest of the algorithm uses the FR F2L slot to repair up the edges because it's the only composite edge affected that is not in M.

Because of this fact, this algorithm does take advantage of an unsolved U layer and a F2L slot, as well as flip the UF dedge.

Before, I would have compared this algorithm in quarter turns to 25q, but since my recent release of 23q pure edge flip algorithms, this algorithm is just 1 q less, but gets the task done for the given cube size and the fact that it is solely OLL.

If two more turns are made wide, we have Petrus Parity for only fixing OLL parity (not inducing PLL-parity, and hence, significant for it's move count because, if it were double-parity, a pure algorithm is 21q). We can see also which edges this algorithm affects and how.

The l D2 l D2 portion of this algorithm was necessary to have because I had to form a double-parity and protect it while securing a 3-cycle on the opposite side of the cube simultaneously (so that I could pair up those two dedges and their adjacent centers with the second half of the algorithm).

EDIT:
If we make the following adjustments to the algorithm, then we have an algorithm which could be more useful.
Rw U2 Lw' U2 l D2 l D2 Rw' U' L U F r' U2 r F
Omit the last move:
Rw U2 Lw' U2 l D2 l D2 Rw' U' L U F r' U2 r
Take the inverse:
r' U2 r F' U' L' U Rw D2 l' D2 l' U2 Lw U2 Rw'
Take the mirror:
l U2 l' F U R U' Lw' D2 r D2 r U2 Rw' U2 Lw
Add the move F back in:
l U2 l' F U R U' Lw' D2 r D2 r U2 Rw' U2 Lw F
l U2 l' F U R U' Lw' D2 r D2 r U2 Rw' U2 Lw F

It flips the FR dedge while preserving the orientation and permutation of the U-layer cross edges (with respect to each other).

Similarly, another Petrus Parity can be made for the other version of the algorithm.

(Obviously, my previous post contains a 21q algorithm which is Petrus Parity too.)

Last edited:

#### Christopher Mowla

For those interested, I have taken the time to compile a "formal" derivation for this algorithm
Rw U2 Lw' U2 l D2 l D2 Rw' U' L U F r' U2 r F

(This is honestly how I, a human, found this algorithm.)

I hope everyone can learn some big cube theory from this. If anyone has questions, I am very willing to answer them.

Derivation
Starting with the old algorithm I found (which I found in a very similar way to this one),
r U2 r' U2 r D2 r D2 r' F L' F' U' r' D2 r
1) Omitting the second portion,
have a pure 4-cycle double-parity in U. In D, there is a 3-cycle. In addition, there are two 1X2 center blocks swapped in D and F.

Hence, at this point, there is an odd permutation in the cube. If an even number of inner-layer turns are used to pair up the two remaining dedges and centers, then that odd permutation stays. In addition, since we have a 3-cycle to deal with, and we don't want to create a double-parity, then we need to preserve the pure double-parity in U (or at least the odd permutation along with PLL parity), and pair up the edges so that the 3-cycle is not solved with it's corresponding 3-cycle, but with another 3-cycle to pair them up so that the end result will be a 2 2-cycle between two other dedges besides the two dedges which are involved with the double-parity in U. If we did solve back those two dedges perfectly (i.e., using the corresponding 3-cycle), then our net result would be a double-parity in U, as well as 3X3X3 scrambling, which we don't want.

The only choice we have to accomplish this task in the least amount of moves is to involve another dedge on the cube (messing up more to achieve fewer quarter turn moves than pure edge flip algorithms,...well, for this particular move set anyway). Why do we need to involve another dedge? See this spoiler:
What we have
r U2 r' U2 r D2 r D2 r'
Two dedges in U that are involved in a 4-cycle (double parity form)
Two dedges in D that are un-paired.
All 4 dedges in M are used up at this point.
Two 1X2 center blocks messed up in F and D.
What we need to do
Pair up the two dedges in D, "restore" the centers, and induce PLL parity a second time into the cube so that we have:
Double-parity+2 2-cycle
=(PLL parity+OLL parity)+PLL parity
=OLL parity.
What perquisite knowledge do we need to know before we can do this?
The following brief move sequence can be used to accomplish the task at hand, but we first need to set-up our cube to meet the following requirements:

A dedge which is paired needs to be between the two un-paired dedges.
The two wing edges which need to be swapped need to be diagonally opposite to one another.
The two misplaced 1X2 center blocks need to be diagonal to one another.

What we must do.

We need to insert a move sequence which sets up the proper situation to the brief move sequence shown above. Yes both dedges in U are paired up, but using either one of them will not give us a 21q sequence to break 4X4X4 OLL parity, re-pair up all dedges, and restore the centers. (It will require more moves).
For this algorithm, I chose to use the DR dedge. Notice with the moves F' R F U, I placed in in FD between the two un-paired dedges. From there, we finish off with l' F2 l.
Hence,
2) We add the following algorithm piece to the original one:
r U2 r' U2 r D2 r D2 r'
F' R F U l' F2 l

Note that F' R F U are moves to set up the remaining two dedges and 1X2 center blocks in the ideal positions with respect to each other so that they can be paired up with the shortest sequence: l' F2 l. Other outer-layer moves can be used to set up for this situation as well. However, these are the set-up moves used.

3) Next, studying the effect of this algorithm on the cube, notice that if we put the move R' before the second portion just added, the R slice is better preserved.
r U2 r' U2 r D2 r D2 r'
R'
F' R F U l' F'2 l

4) By experimentation, making the first two r moves wide yields a very interesting result:
Rw U2 Rw' U2 r D2 r D2 Rw' F' R F U l' F2 l

If the move U is added, we have it! Only one face and an intersecting 1X4 block are affected.

5) Rotating the algorithm on the cube so that it is the U-layer and the front-right F3L slot are affected instead of the U and F layers,
Lw F2 Lw' F2 l B2 l B2 Lw' U' L U F r' U2 r F

6) Inserting x cube rotations,
Lw x U2 x' Lw' F2 l B2 l B2 Lw' U' L U F r' U2 r F
=
Rw U2 x' Lw' F2 l B2 l B2 Lw' U' L U F r' U2 r F
=
Rw U2 Rw' F2 l B2 l B2 Lw' U' L U F r' U2 r F

7) Inserting x cube rotations again,
Rw U2 Rw' x U2 x' l B2 l B2 Lw' U' L U F r' U2 r F
=
Rw U2 Lw' U2 x' l B2 l B2 Lw' U' L U F r' U2 r F

8) Moving the remaining x cube rotation to the right of l,
Rw U2 Lw' U2 l x' B2 l B2 Lw' U' L U F r' U2 r F

9) Carrying out the x cube rotation to the next three (half turn) moves,
Rw U2 Lw' U2 l D2 l D2 x' Lw' U' L U F r' U2 r F
=
Rw U2 Lw' U2 l D2 l D2 Rw' U' L U F r' U2 r F

DONE

Last edited:

#### Christopher Mowla

A Dedge Preservation 10-Cycle of Wing Edges

Building off of the algorithm in one of my recent posts in this thread:
l U2 l' F U R U' Lw' D2 r D2 r U2 Rw' U2 Lw F

Today I decided to alter the end of the algorithm so F3L was preserved in the end with as little 3X3X3 restoration as possible, just to see what would happen. This is the route I took to do this.

If you cut off the rest of the algorithm after the bold move below:
l U2 l' F U R U' Lw' D2 r D2 r U2 Rw' U2 Lw F

Lw L' U L U' Lw' U2 Lw U F
then we have it.

Merging the Rw' Lw as x',
=l U2 l' F U R U' Lw' D2 r D2 r U2 x' L' U L U' Lw' U2 Lw U F

Converting the x' L' to (Rw' l),
=l U2 l' F U R U' Lw' D2 r D2 r U2 (Rw' l) U L U' Lw' U2 Lw U F

If we reverse all of the outer-layer turns to restore the corners and composite edges into their original slots and apply it to a 5X5X5, we can see that this is indeed a 10-cycle of wing edges. It too is not double-parity:
l U2 l' F U R U' Lw' D2 r D2 r U2 (Rw' l) U L U' Lw' U2 Lw U F
+
F' U' L' U2 L U L' U' R U2 D2 D2 L U R' U' F' U2

Canceling some moves:
l U2 l' F U R U' Lw' D2 r D2 r U2 (Rw' l) U L U' Lw' U2 l
U2 L U L' U' R U2 L U R' U' F' U2

This is the first 10-cycle I have ever seen which preserves the dedges on the 4X4X4.

This reminds me of reThinking the Cube's earlier statement:
In fact, any EVEN cycle (2,4,6,8,10) of the 4x4x4 edge pieces that make up the last 5 unsolved dedges will end up solving the flip parity, as long as the edge piece cycling ends up with paired dedges.
This is from this post.

Of course this 10-cycle isn't useful for speedsolving, but it does give us yet another glimpse into the big cube parity algorithm domain.

The algorithm itself (which is the inner-layer workings of the 10-cycle) l U2 l' F U R U' Lw' D2 r D2 r U2 (Rw' l) U L U' Lw' U2 Lw U F could be used as a 4X4X4 OLL alg. The alternative right now is a double-parity:
y2 (R' M)
(Rr)2 B2 (Rr)' U2 (Rr)' U2 B2 (Rr)' B2 (Rr) B2 (Rr)' B2 (Rr)2 B2
R U R' U (R M')

(From "OLLparity+OLL 1flip.doc" found here.)

Last edited:

#### Joker

##### Member
r U2 x r U2 r U2 r' U2 l U2 r' U2 r U2 r' U2 r'
Thanks to Thrawst

#### Christopher Mowla

r U2 x r U2 r U2 r' U2 l U2 r' U2 r U2 r' U2 r'
Thanks to Thrawst
Thanks for trying to contribute, but that algorithm is commonly known as Lucasparity and has been known for around 2 years. In fact, it was even mentioned earlier in this thread by the original founder, Lucas Garron. I recently made a YouTube tutorial on how to derive it without a computer solver. The link to the videos are in this thread.

Besides, that algorithm is not relevant to this thread at all because it is 25q. This thread was aimed at getting algorithms with fewer quarter turns which do not waste moves to restore the cube back completely (non-pure).

A perfect example algorithm that reThinker wanted to find was like this algorithm shown in the post right before this one:
l U2 l' F U R U' Lw' D2 r D2 r U2 Rw' U2 Lw F (22q)

#### bonerici

##### Member
I'm not a speed cuber just a casual solver. I usually solve by finishing everything except for one of the F3L slots and the last layer then I count up the corners and edges to figure out if I have parity I need to fix. I was looking for exactly what the original poster wanted an algorithm that could scramble the last layer (and for me one of the F3L slots) but to my surprise after reading 25 pages of heated invective and hundreds of algorithms I find that there really is nothing better than the usual edge flip algorithms I already know.

Strange . . . I was trying to follow Mowla's proof on I dunno page 3 or 4 but didn't get too far with it. I mean yeah in one way it makes sense, I have watched all of Mowla's derivation of the pure edge flip algorithms so I understand how it works just seems so odd that there's nothing better for how I solve than to use the regular last layer PLL algorithms. I do like the old last layer PLL edge flip it's pretty easy to memorize and easy to turn, so I guess I'll use it.

Thanks for all the arguments and algorithms on this thread guys, sorry if I'm bringing a dead thread back to life just wanted to say it helped me understand what is going on better. I know there are algorithms posted above that are slightly faster but they are more difficult for me to remember because there is less symmetry.

#### Christopher Mowla

I was looking for exactly what the original poster wanted an algorithm that could scramble the last layer (and for me one of the F3L slots) but to my surprise after reading 25 pages of heated invective and hundreds of algorithms I find that there really is nothing better than the usual edge flip algorithms I already know.
I believe you're in luck.

I did a lot more research since this thread, and I DID find such algorithms by studying some computer algorithms that cuBerBruce produced with a custom computer search he did. There is so much parity algorithm theory that I never made videos about (you can check out the 4x4x4 parity wiki algorithms page to see just how many types of algorithms - most brief and/or most likely move optimal)! I wonder if anyone is interested in me making some more videos?

You can check out the 4x4x4 parity algorithms page to find all of these on it in its designated section, but here are the results:
2R' U2 F' U2 F U2 2R' U2 2R' U2 2R' F' U2 F 2R' (21,15)
2L U2 F' U2 F U2 2L U2 2L U2 2L F' U2 F 2L (21,15)
2R' U R U2 R' U' 2R' U2 2R' U2 2R' U' R U2 R' U 2R' (21,17)
2L' U' R U2 R' U 2L' U2 2L' U2 2L' U R U2 R' U' 2L' (21,17)

In addition, here are a few double parities by Kåre Krig (he used his program k-solve to create them)
r U2 r U2 r U r U2 R' U r U r2 R U r U' r (21,18)
r U2 r U2 r' U' R' r2 U2 2R U' R' U' r U2 2R2 U r2 (24,18)

I take note that I found shorter algorithms, but they do not preserve the colors of the centers, but the first one listed almost does (what a teaser, eh?)!
2R' U' R U' 2R U2 2R U2 2R U' R' U' 2R' (15,13)
2R' U' R U 2R' U2 2R' U2 2R' U R' U' 2R' (15,13)

Lastly, if you wanted a Petrus Parity algorithm, here are the best ones that we have so far:
r' U R' U2 R U' r' U2 r' U2 r' U' R U2 R' U r' (21,17) (Kåre Krig and I found this independently)
r' U' L' U2 L U r' U2 r' U2 r' U L' U2 L U' r' (21,17) (mine)

Again, feel free to check the wiki page (that I mainly have put together) to find short algorithms for cases to so many other types of parity situations on the 4x4x4!

Last edited:

#### bonerici

##### Member
Thanks Christopher. Those are fantastic. I am definitely going to be trying them out.

#### bcube

##### Member
I wonder if anyone is interested in me making some more videos?
Yes. It doesn't need to be about the (derivation of) algorithms, you know

#### unsolved

##### Member
In a very round about way, I'm working on an indirect way to avoid Dedge flips entirely. I've designed a 3-stage program for the 4x4x4 that solves all of the edges (and dedges) first. It solves the corners next, and centers last.

Stage 1 is the most difficult and time consuming phase. I'm still building large hash tables and databases for this stage. When this completes (10 months and counting so far) we'll be able to identify a range of reasonable values for "God's Number" for the dedges-only version of the 4x4x4.

The question remains: Can such a brute force approach always circumvent a dedge flip necessity given ANY random scramble? I believe if handled early enough (and at stage 1 this is as early as you can get) dedge flipping can be avoided.

#### Christopher Mowla

The question remains: Can such a brute force approach always circumvent a dedge flip necessity given ANY random scramble? I believe if handled early enough (and at stage 1 this is as early as you can get) dedge flipping can be avoided.
If you are asking if you can solve the cage optimally if you successfully program stage 1 of your solver to keep the permutation of the wing edge orbit even, then, I'll ask something that Stefan would say: what if you have the dedge flip case itself? (You said ANY scramble, so this is included.)

We of course can solve it in 12 turns since the centers have not been completed, 2R2 U 2R' U' B2 U 2R U 2R' U2 B2 2R2.
[HR][/HR]Less trivially, based on stage 1 of your solver, it could also be that your solver reduces a relatively simple odd permutation of wing edge scramble to a conjugate of the position 2R2 U2 2R U2 2R2, which is an odd permutation just like the dedge flip. I'm pretty sure 5 to 11 moves is shorter than pairing up tredges and then solving like a 3x3x3.

[HR][/HR]So I only can assume that when you mention "dedge flip", you are referring to odd permutations in general, because you cannot be certain (and it's obviously false) that all cage positions can be optimally solved via first pairing all tredges and then solving the 5x5x5 outer faces like a 3x3x3, and thus the dedge flip will most likely not be the type of odd permutation that you have to deal with.

In addition, it might be beneficial to keep the permutation of the wing edges odd so that the last move of stage one is an inner slice quarter turn or the 5 move sequence above. "Preventing parity" is clearly effective for move count when solving a big cube using reduction (and its variations such as Yau, Hoya, etc.); but this isn't always necessarily going to be the case for the Cage Method.
[HR][/HR]Lastly, I will refrain from making any further responses about this in this thread because this is clearly off-topic. If a mod wants to move this post somewhere else (or delete it), then that's fine with me.

Last edited:

#### unsolved

##### Member
The stage-1 portion of my solver doesn't solve the way a human does. It solves all edges simultaneously, searching forward from the unsolved state until it encounters a database position in the hash table with a known path to a completed dedge-solved cube. If more than one solution is encountered at the same depth, it chooses the sequence with the fewest moves remaining to solve the corners, which it can do instantly with all of its pre-computed lookups.