WANTED: New Dedge Flip Algorithm!

(Rr) U2 (Rr) U2 (Rr)2 U2 (Rr) F2 x' (Ll) U2 (Ll)' U2 (Rr)' U2 (Rr) U2 B2 D2
would be the complete alg. That's 29 BQTM after the fix.
It's cool that you found it be hand, but it's slower and longer than algs that are already available.

reThinker,

I apologize for causing a lot of irrelevant posts in your thread. Everyone thought that I was trying to make the alg, which I posted for you, the next official (and most commonly used) parity algorithm.

I don't ever recall making that statement, but people just don't give up repeating what everyone else has already said in multiple ways.:fp

Over and out....

The thing is... there are already better algs than the one you posted. Wether they mess up F2L or not.

Which also messes up 2 slots etc.

First: x' r' U2 l U2 r' U2 l U2 x l' U2 x U2 l' U2 r U2 B2

It's shorter than yours by all reasonable counts, it's faster and nicer to execute, and the last two turns are less awkward.

Second:
cmowla accused me of using a computer to find a parity alg, so I decided to find an OLL parity alg by hand. I thought of it in the shower, and even did all my work on paper until the final algorithm:

First, you start with this J-perm, which comes from a basic insertion.
R2 u' R2 u R2
> R2 d u' R2 u' R2 u R2 d' R2 u R2 u'

This can be written as R2 F2 u' F2 u F2 u' R2 u R2 u'

I'm skipping over a bit of work, but eventually I found a four-move setup: [u L2 d R2: R2 F2 u' F2 u F2 u' R2 u R2 u']

Expand that out, and you get a nice cancellation (I was looking for a setup that would do this):
u L2 d F2 u' F2 u F2 u' R2 u R2 u' R2 d' L2 u'

Rotate that by a z-turn:
r U2 l F2 r' F2 r F2 r' D2 r D2 r' D2 l' U2 l'

It took me a while to do that alg on a cube correctly. but once I did, I realized it would flow nicely if I added some rotations/changed some turns. When you resolve that, you get:
r U2 r U2 r' U2 r U2 l' U2 r U2 r' U2 x' r' U2 r'

I wrote this out on my sheet, counted its length, tried it one more time on a real cube, and realized something: that alg is the inverse of lucasparity.

I wasn't expecting that, but I'm not really surprised.
So there, cmowla:

I could have found my 25q/17b OLL parity by hand.

I just happened to find it by computer first, independently.
Please do not chastise me for using a computer anymore; it's simply my tool of choice.

In this thread, there has been plenty of misunderstanding, yelling at each other, and no real progress that's good for the community. I'm also tired of pretending to be egotistical about my algs.

I am closing this thread temporarily. It will be back open in less than 24 hours (if not, someone remind me).

EDIT: Back open. Please be nice.

reThinker,

I have now made an algorithm which is very close to your description

reThinking the Cube said:

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?

Click to expand...

, though, again, it is not briefer in moves than typical OLL algorithms. It is a double parity algorithm that leaves the front-right F2L slot open as well as the U-layer. The only other thing is that it does not preserve the back bottom edge.

I did not form this algorithm merely from just adding more unneccessary moves to a brief pure double parity algorithm. Instead, this algorithm depends on messing up the front-right F2L slot. In my opinion, I believe this is the type of algorithm you have been inquiring about.

Here it is: it is 30q. (Note that the first 25 moves generate a non-pure/3X3X3 scrambled form double parity fix, and the last 5 moves restore most of the cube).

r U2 r' U2 r U2 x' U2 r' U2 x r U' x U R' U' F2 l' U2 l U2 F2 R x'
(you cannot use double-layer turns: execute it exactly as shown)

Note: I am not broadcasting this algorithm to be the best algorithm for speedsolving. It is just the closest algorithm yet to reThinker's description. If you don't like its length, style, or result, please do not complain. This is for reThinker. I do not want to fight anymore in this thread or anywhere else.

And, for briefness, I have found a pure 21q double parity algorithm:

r U2 r' U2 l U2 x' l' U2 r U2 y M2 y' x' l' U2 l

And, I have also found a relatively fast pure double parity (probably not the fastest, but it is not the worst) 23q alg:

r U2 r' U2 x' r U2 r' U2 x2 r U2 x l U2 l' U2 B2

Note: If the last 4 moves are subtracted off, this algorithm is 19q: the briefest (according to Lucas Garron) algorithm to change a 4X4X4 with parity into a 3X3X3 (well, at least to get rid of the OLL parity). My briefest pure edge flip for the 4X4X4 is also 19q.

All of these algorithms, again, I have found by hand with logical reasoning (though, I admit, the alg for rethinker was very hard to make).

And, based on how I found my 19q double parity algorithms, I personally cannot see yet how an algorithm that matches your description can possibly be less moves than 19 BQTM. (Do I have an opinion yet?)

And although what I am about to show you is counter-productive, it is less moves than the alg I just gave you.

I found a 19q pure double parity algorithm which affects all 4 composite edges about M:

r U2 r' U2 x2 r' U2 r U2 x r' U2 r U2 r' x

To match your description, I can just add the following 6 moves:

L M' F
r U2 r' U2 x2 r' U2 r U2 x r' U2 r U2 r' x
F' M L'

Which yields a 25q.

I could also add, instead,
M2 U
r U2 r' U2 r' D2 r D2 r' B2 r B2 r'
U' M2

to make the alg just affect all 4 composite edges in U....another 25q.

But this in itself is not efficient, for I can just do my 21q pure double parity alg...

Hence, based off of this post and the post above (which contains an algorithm that depends on messing up the F2L slot), it can be reasoned (well, at least in my head) that an algorithm that fits your description can't possibly be less moves than, say, a pure 21q pure double parity alg (and definitely not less than my pure 19 BQTM pure edge flip alg). However, for your interest of such an algorithm that depends on the F2L slot, I think you will appreciate the alg I gave in the post above (although it affects one more piece than your request).

Although my "proof" at the beginning of this thread did not seem to be convincing, I think the algorithms can tell a story of their own.

cmowla said:

reThinker, I have now made an algorithm which is very close to your description, though, again, it is not briefer in moves than typical OLL algorithms.

Click to expand...

Dude... are you ever going to understand that being briefer/faster is what he wants and that you're thus not just not "very close" to what he wants but in fact not close at all? Like I said before: You're going the wrong direction.

r U2 r' U2 r U2 x' U2 r' U2 x r U' x U R' U' F2 l' U2 l U2 F2 R x' does not work.
http://alg.garron.us/?alg=r_U2_r-_U...x- &cube=4x4x4&notation=WCA&animtype=solve

r U2 r' U2 r' D2 r D2 r' B2 r B2 r' is an interesting alg.
http://alg.garron.us/?alg=D2_r_U2_r-_U2_x2_r-_U2_r_U2_x_r-_U2_r_U2_r-_U2_ &cube=4x4x4

The x2 rotation is a bit awkward, but other than that, this alg is pretty good.

It does work, flips one edge, but screwing up 1 F2L slot and a cross piece

Hyprul 9-ty2 said:

It does work, flips one edge, but screwing up 1 F2L slot and a cross piece

Click to expand...

It flips an edge, but it messes up a cross edge in addition to the F2L slot. He could add U2 M U2 M' to fit reThinker's request for an unpure dedge flip that messes up one F2L slot. That is the alg reThinker is asking for, but it's not what he really wants, because it is longer than the pure algs.

StefanPochmann said:

cmowla said:

though, again, it is not briefer in moves

Click to expand...

Dude... are you ever going to understand that being briefer/faster is what he wants and that you're thus not just not "very close" to what he wants but in fact not close at all? Like I said before: You're going the wrong direction.

Click to expand...

I completely understand that, Stephan. Notice that I bolded "not briefer in moves". And I vividly described that the nature of the alg is very close (not exactly) to reThinker's description, not the length! I specifically made that clear.

And, I am not 100% sure whether reThinker's length standard is 25q or 20q. Even if it is 25q (which means I must achieve 24q or less), it will be nearly impossible to obtain without being counter-productive, that is. If his standard is to be below the briefest pure edge flip or a pure 21q double parity alg...it is impossible, because an algorithm that depends on using the F2L slot is not going to be shorter. This alg he wants is an alg which is not supposed to be counter-productive (adding preliminary and ending moves to an already existing alg), and it must depend on destroying a F2L slot (which is exactly what the alg I gave does...it is not counter-productive in any way due to how I started it). I understand my 21q pure double parity alg, and I must say that it is extremely efficient. I do not see an inefficient path in it. It breaks the odd permutation and restores the centers and all edges very efficiently, not to mention managing to keep the cube together.

The important thing to note about what I just said, "not to mention managing to keep the cube together", that is NOT the focus of the alg. The focus of the alg is to restore the centers and edges as soon as possible. It just happens that the cube is held together. And it is by this knowledge that suggests to me that, if reThinker wants an alg which is less moves, he really wants an alg that is not realistic. And also, I must mention that algorithms which DO NOT preserve the centers entirely are possible to achieve the edge flip in as little as 17q (I have two of those), but NOT to PRESERVE the centers as well.

And as far as my 20q pure edge flip is concerned, it will definitely be counter-productive or even obviously longer to mess up a F2L slot, too. In that algorithm, I might be able to manage to mess up one F2L slot during the alg itself, but that would obviously not be efficient as if I leave the pure edge flip alone, assuming that there are no move cancellations (which I know there is not).

And as far as going in the "wrong direction" or in the "right direction", I don't think the "right direction" is possible (that is my sincere opinion...just read what I have previously written in this post and see if it makes sense to you).

cmowla said:

StefanPochmann said:

cmowla said:

though, again, it is not briefer in moves

Click to expand...

Dude... are you ever going to understand that being briefer/faster is what he wants and that you're thus not just not "very close" to what he wants but in fact not close at all? Like I said before: You're going the wrong direction.

Click to expand...

I completely understand that, Stephan, Notice that I bolded "not briefer in moves". And I vividly described that the nature of the alg is very close (not exactly) to reThinker's description, not the length! I specifically made that clear.

Click to expand...

fanwuq said:

Hyprul 9-ty2 said:

It does work, flips one edge, but screwing up 1 F2L slot and a cross piece

Click to expand...

It flips an edge, but it messes up a cross edge in addition to the F2L slot. He could add U2 M U2 M' to fit reThinker's request for an unpure dedge flip that messes up one F2L slot. That is the alg reThinker is asking for, but it's not what he really wants, because it is longer than the pure algs.

Click to expand...

I believe I made that very clear. I even gave pictures. And, I said, not that you neccessarily had a problem with this, but I also wrote right beneath the alg that you cannot use double layer turns...perform exactly as shown.

Well... he *allows* you to destroy an F2L slot, he does *not* require it. He's probably not going to care at all if you show him an alg that does destroy an F2L slot but that's longer than what he already knows.

cmowla said:

If his standard is to be below the briefest pure edge flip or a pure 21q double parity alg...it is impossible, because an algorithm that depends on using the F2L slot is not going to be shorter.

Click to expand...

Proof?

StefanPochmann said:

Well... he *allows* you to destroy an F2L slot, he does *not* require it. He's probably not going to care at all if you show him an alg that does destroy an F2L slot but that's longer than what he already knows.

Click to expand...

Well, I didn't consider that beforehand...I don't think it is really relevant to reThinker's original request.

StefanPochmann said:

cmowla said:

If his standard is to be below the briefest pure edge flip or a pure 21q double parity alg...it is impossible, because an algorithm that depends on using the F2L slot is not going to be shorter.

Click to expand...

Proof?

Click to expand...

Ok.
As far as the conventional method goes, which involves shuffling pieces within M (and yields the optimal alg to reduce a 4X4X4 parity to a 3X3X3), the minimum amout of moves to restore the centers and edges having induced an odd permutation is 19q (if you don't believe me, use computers, study the algs I have given or ask Lucas Garron). And, since I was asked to prove that an algorithm less than 20 BQTM and since the optimal algorithm to restore both centers and edges and induce an odd permutation is 19q, then 19q is the only option we have.

Thus, suppose we were to find a 19q algorithm which depends on an F2L slot.

According to the algorithm which I have posted for reThinker, let's first study the first portion of it (15q), before the F2L slot was used:
r U2 r' U2 r U2 x' U2 r' U2 x r

Execute it on a solved cube and study the front-top and front-bottom edges.


Notice that the winged edges are directly opposite to their equivalent in each composite edge, respectively.

In order to complete the centers and edges in the least amount of moves from this point is to do the second portion of my alg:
U' x U R' U' F2 l' U2 l (WCA Notation)
(and it would be a lot worse if the yellow and red center 1X2 blocks were not diagonal to each other to begin with).

If the winged edges were not directly across from each other, but instead diagonally opposite, then messing up the F2L slot is NOT necessary to restore the centers and edges in the least amount of moves (in fact using a F2L slot it would add even more moves than necessary).

Now, the first portion of the alg was 15q, and the second portion was 10q. This is well over 19q already. Then, the third (and final) portion of my alg was geared to restoring the cube as best as possible (which was 5q).

In short, if the alg "depends" on messing up a F2L slot, the portion prior to using that F2L slot must be very similar to how the "first portion" of my alg sets up the cube.

Lastly, one would not do outer-layer turns before doing any inner-layer slices because that would be counter-productive (and would definitely not yield a 19q, even if it turned out to be less moves than my 30q). That's why I have been demostrating the use of the F2L slot after an almost complete (most of the centers are restored, and it only takes one more step to restore the rest of them as well as pair up the remaining un-paired edges) setup/"first portion".



The "first portion" this alg must set up the same situation as my algs first portion does, except that the back bottom edge is preserved too



and, so long as it is an odd number of inner-layer turns. In addition, it also much be in less moves (at most 9q, so that 9q+10q=19q...and I am even neglecting the definite cube restoration moves which make up the "third portion" of my alg: U2 F2 R x').

In general, to induce an odd number of inner-layer turns that is a reasonable start for any parity alg, it is a minimum of 3 inner-layer slices. And, the "first portion" of my alg is the next option up, 5 inner-layer slices. And also keep in mind that 19q algorithms have the next step up, 7 inner-layer slices. So, there is no room for "an intruder", such as the use of an F2L slot, that can qualify to be 19q--19q as in, the entire algorithms length, not just focusing on fixes back the centers and edges as well as making sure of an odd number of inner-layer slice turns...and using a F2L slot.

Hence, a 19q algorithm which legitimately utilizes a F2L slot, in addition the the U layer (while preserving the centers and all other dedges), cannot be 19q.

fanwuq said:

...but it's not what he really wants, because it is longer than the pure algs.

Click to expand...

And did my "proof" at the beginning not say so? This isn't supprising to me at all. And I didn't have this alg handy when I wrote that "proof" back then. I just found it yesterday.

And as you will see from my previous post, my second "proof", that pure edge flip algs are actually pretty optimal (hence, supports my first proof, yet again).

cmowla said:

If you're going to use Lucas's site, I am not sure which notation to use for these algs. Just do the regular notation (the one on Chris Hardwick's 4X4X4 solution page on speedcubing.com).
http://www.speedcubing.com/chris/4-presolution.html

Click to expand...

You can choose which notation to use on Lucas's site. The first alg does not completely fulfill reThinker's request because it messes up an additional dedge at DB.
What you meant to post was r U2 r' U2 r U2 x' U2 r' U2 x r U' x U R' U' F2 l' U2 l B' U2 F2 B U R U'. That completely restores the triple-extended-cross.
The 2nd alg was actually pretty cool. I simply showed a variation that uses wide rather than slice turns and restores the rest of the cube.

I agree with your logic (for the most part), but you didn't really need to prove a "proof" when it isn't a true proof. Providing that alg does not advance the proof. You made many interesting statements, but I have not seen any proofs.

reThinker wants "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"
What you want to prove/disprove is that the pure flip is the shortest OLL parity fixer that restores all centers, pairs up all edges, and keeps a triple-extended-cross intact.

I cannot prove it, but I have a general idea of what a proof should look like.
1. r fixes the parity, but centers and edges (UF, UD, FD, BD) need to be restored.
2. prove/disprove that the most efficient way to restore the centers and edges requires all turns outside of M slice to be half turns. An F2L edge cannot be destroyed without doing a quarter turn outside of M slice.

Intuitively, we can see that r U2 l F2 l' restores one center while changing the parity without destroying additional edge pairs. Show that using at least one quarter turn outside of M slice could not accomplish the same effect in less turns.
This is easy to see intuitively, but I don't have sufficient knowledge to setup a rigorous proof.
Your alg itself proves nothing unless it proves by contradiction that it is shorter than what was thought to be possible. You can't say "pretty optimal"; it is either optimal or not. And that requires a real proof.

Check this out!

DoubleTrouble™ - (r U2 r' U2 r' D2 r D2) x' (r' U2 r U2 r' U2) 2s2

http://alg.garron.us/?alg=r_U2_r'_U2_r'_D2_r_D2_x'_r'_U2_r_U2_r'_U2_2s2_%0A%0A%0A&cube=4x4x4

Note:the 2s2 is SiGN notation for S2, means the same as (y' M2), and of course r = (Rr) or (Rw)

StefanPochmann said:

What you have here is not a 4-cyle but two 2-cycles.

Click to expand...

Many think a x cycle are x pieces.

cmowla said:

Lucas Garron said:

P.S.: r U2 r U2 r U2 is not annoying. It's quite fast, compared to full regrips. It's the reason world record holders use my alg.

Click to expand...

I actually do not consider any of your "algs" your own. The computer computed it, all you did was set it up. Thus, it is not really your alg, but the computer's algorithm.

That's why I actually try to find algs by hand (and I have been very successful with pure algorithms so far, in beating the computers in moves), so that I can really claim that they are my algorithms. This is puzzle theory, is it not?

And I am not failing, the alg you posted (though 2 less moves than mine, is very poor to execute and I think reThinker would think of performing my alg much more than that one).

Click to expand...

F2 Lw2 F2 U2 Lw' U2 Lw U2 Lw2 F2 Rw' F2 Lw U2 Lw'

And I did not use a computer to find it!!

(the mirror alg is probably better for most of you, I use L)

----
Do you know what you are doing or do you just go by chance, test some tuns until you find something that works?

Or do you know how to solve parity using a commutator? (I do).