WANTED: New Dedge Flip Algorithm!

[reThinking the Cube]

You write too much. If you cannot express clearly something, this is usually because this things isn't clear for you.

8-cycle 2R U2 2L' U2 x' 2R' U2 2L U2 2R' U2 2L U2 2L' 2m'

 

[reThinking the Cube]

Stefan's New DedgeFlip http://www.stefan-pochmann.de/spocc/other_stuff/4x4_5x5_algs/?section=FixOrientationParity

Stefan's new DedgeFlip

x' (Uu)' R2' (Uu)' (l2r2R2) (Uu)' L2 (Uu) (l2r2R2)' (Uu)' (l2r2R2) (Uu) L2' (Uu)' L2 (Uu) L2' (Uu) z
Found with ACube, treating the 4x4 like a Domino. I don't know whether the applet can show triple-layer turns, now it's kinda ugly. Think of it like this with U meaning (Uu) and r meaning (l'rR), and all non-U-turns being half turns:
(x' U') (R' U' r U' L U) (r' U' r U) (L' U' L U L' U) z

Special thanks goes to Lucas Garron for http://alg.garron.us, and also his contributions with SiGN notation, which allow for a much clearer way to represent this alg.

So using SiGN notation, StefansNewDedgeFlip = x' u' R2' u' 3r2 u' L2 u 3r2' u' 3r2 u L2' u' L2 u L2' u z

As it turns out, this alg can be traced back to a post made on January 09, 2006 - http://osdir.com/ml/games.rubiks.speedsolving/2006-01/msg00404.html

NOW LET'S HAVE A LITTLE FUN!

z' rotation
z' x' l' U2' l' 3u2 l' D2 l 3u2' l' 3u2 l D2' l' D2 l D2' l

rewrite equivalencies for each 3u2 = (D2 y2)
z' x' l' U2 l' D2 r' D2 r 3u2' r' 3u2 r D2 r' D2 r D2 r y2
z' x' l' U2 l' D2 r' D2 r D2 l' 3u2 l D2 l' D2 l D2 l
z' x' l' U2 l' D2 r' D2 r D2 l' D2 r D2 r' D2 r D2 r y2

z2 rotation, and removing y2 at the end
z x' r' D2 r' U2 l' U2 l U2 r' U2 l U2 l' U2 l U2 l

mirroring r/l
x' l D2 l U2 r U2 r' U2 l U2 r' U2 r U2 r' U2 r'

rewrite equivalencies for each (l D2) = (x r U2 x2)
r U2 l D2 r D2 r' D2 l D2 r' D2 r D2 r' D2 r' x2
r U2' x r U2' r U2' r' U2 l U2' r' U2 r U2' r' U2 r'

SURPRISE! By simple transformation -
StefansNewDedgeFlip is equivalent to another parity alg that was 1st revealed on 05/17/2008 http://www.speedsolving.com/forum/showpost.php?p=52481&postcount=5

Spoiler

Anyhow, dunno how to find a 3-flip alg simply. But I just found r U2' x r U2' r U2' r' U2 l U2' r' U2 r U2' r' U2 r' with ACube...

Yep. It's the same as lucasparity

http://www.youtube.com/watch?v=ghNkoAOH_3A

 

[Christopher Mowla]

x' (Uu)' R2' (Uu)' (l2r2R2) (Uu)' L2 (Uu) (l2r2R2)' (Uu)' (l2r2R2) (Uu) L2' (Uu)' L2 (Uu) L2' (Uu) z
=
mirror of (r U2' x r U2' r U2' r' U2 l U2' r' U2 r U2' r' U2 r' )

Wow. It looks like Stephan and Lucas found this algorithm independently from each other, just as you and I found the same alg (except for last moves) independently from each other.

Excellent observation.

 

[Lucas Garron]

SURPRISE! By simple transformation -
StefansNewDedgeFlip is equivalent to another parity alg...

Nice work.
I always wondered what Stefan's algs was really based on, but I never bothered to look into it (even though I do like the idea of canonicalization, because it helps in enumeration of cube things). A good example of why it's hard to do things like compare and attribute algs. But I'm going to pull a de la Vallée-Poussin and say that no one can really deny that my version is faster and easier to execute in practice.

Anyhow, algs at this level are related in interesting ways. A whole bunch, like lucasparity, are essentially based on the 10-move domino J, just as a whole bunch of algs are based on either of two common J's on 3x3x3.

 

[deadalnix]

But I'm going to pull a de la Vallée-Poussin and say that no one can really deny that my version is faster and easier to execute in practice.

Can you explain what « I'm going to pull a de la Vallée-Poussin » means ? I guess it supposed to be french, but really doesn't mean anything in french.

 

[Lucas Garron]

But I'm going to pull a de la Vallée-Poussin and say that no one can really deny that my version is faster and easier to execute in practice.

Can you explain what « I'm going to pull a de la Vallée-Poussin » means ? I guess it supposed to be french, but really doesn't mean anything in french.

Hmm, I actually can't find any sources on the intirnet, but then again old math material is hard to find.

When de la Vallée Poussin published his proof of the PNT, he actually saw Hadamard's proof before finishing publication, so he added a note: "However, I believe no one will deny that my method has the advantage of simplicity." As Derbyshire goes on to say, "nobody has ever denied it."
Prime Obsession is an awesome book, I note.

 

[Joker]

Well...you may be able to make OLLs specifically for the 4x4?

 

[mrCage]

I believe i (re)invented that terminology (dedge, tredge) back in about 2004. Probably in communication with Frank Morris or Chris Hardwick. One could extend to quedge etc for yet bigger cubes, but then it becomes very confusing. One could talk of UF (etc.) composite edge or something like that ...

Per

 

[miniGOINGS]

I believe i (re)invented that terminology (dedge, tredge) back in about 2004. Probably in communication with Frank Morris or Chris Hardwick. One could extend to quedge etc for yet bigger cubes, but then it becomes very confusing. One could talk of UF (etc.) composite edge or something like that ...

Per

"Edge group" always works for me.

 

[mrCage]

I believe i (re)invented that terminology (dedge, tredge) back in about 2004. Probably in communication with Frank Morris or Chris Hardwick. One could extend to quedge etc for yet bigger cubes, but then it becomes very confusing. One could talk of UF (etc.) composite edge or something like that ...

Per

"Edge group" always works for me.

Edge group sounds similar to edge orbital to me ...

Per

 

[miniGOINGS]

Edge group sounds similar to edge orbital to me ...

Per

Hmm, never noticed that myself! Oh well...

 

[Christopher Mowla]

Your desire for such an algorithm cannot be satisfied. As randomtoad said, it will require more moves than the best odd parity algorithms that exist already. Your best bet is to just do double layer turns with one of the pure algorithms (like everyone already does).

The ideal algorithm, which you are interested in, can be derived from an pure “edge flip” algorithm in which its ending moves are only outer-layer turns, there by making it possible to omit those last moves so that you are not doing worthless 3X3X3 restoration (as long as those moves restore only the last layer and maybe one F2L slot, as you have requested).

There is no "dedge flip" algorithm that exists (which is shorter in length than the pure edge flip algorithms) that satisfies this constraint, nor will there ever be.

Okay reThinker,

This algorithm is not necessarily faster than what you would hope, but I believe you will enjoy its length and its effects on a cube.


Here is a 17h/23q OLL parity (NOT DOUBLE PARITY) algorithm which utilizes the front-right F2L slot and U layer being unsolved, but flips the top-front edge. Here it is:

All algorithms are in SiGN notation. So, those who are not familiar with this notation, just click the links and write down the algorithm in your own notation.

On Even Cubes:
r U2 x' U2 x' U' 2L' U F2 U' 2L U 2R U2 2L' U2 l' x U2 2R'
On Odd Cubes:
r U2 x' U2 x' U' 2L' U F2 U' 2L U 2R U2 2L' U2 3l' x U2 2R'

Okay, so if we add some 3X3X3 turns, we obtain a pure edge flip algorithm:
r U2 x' U2 x' U' 2L' U F2 U' 2L U 2R U2 2L' U2 l' x U2 2R' + U2 R U2 R' = Pure

With a minor adjustment making more single slice turns into wide (which improves this algorithm a lot), we have a pure algorithm.
On Even Cubes:
r U2 x' U2 x' U' 2L' U F2 U' 2L U r U2 2L' U2 l' x U2 r'
On Odd Cubes:
r U2 x' U2 x' U' 2L' U F2 U' 2L U r U2 2L' U2 3l' x U2 r'

And of course, the speed form of this algorithm is achieved if all slice turns are converted to wide (you can do the conjugates to get it in the U-layer, but remember, it's my alg no matter how you change it!).
On the 4X4X4:
r U2 x' U2 x' U' l' U F2 U' l U r U2 l' U2 l' x U2 r'
On the 5X5X5:
r U2 x' U2 x' U' l' U F2 U' l U r U2 l' U2 3l' x U2 r'


I DID NOT use a computer solver to form any of the algorithms I have (or will) release. I have derived them all by hand.

By Christopher Mowla. Date: Jun 22, 2010

 

[reThinking the Cube]

First, I want to say ThanksX10 to Christopher Mowla (cmowla) -
for inspiring on this forum, a wealth of interesting discussion and ideas related to parity, and for creating and sharing some his bigcube parity methods and algs.

Okay reThinker,
This algorithm is not necessarily faster than what you would hope, but I believe you will enjoy its length and its effects on a cube.

Here is a 17h/23q OLL parity (NOT DOUBLE PARITY) algorithm which utilizes the front-right F2L slot and U layer being unsolved, but flips the top-front edge. Here it is - On Even Cubes:
r U2 x' U2 x' U' 2L' U F2 U' 2L U 2R U2 2L' U2 l' x U2 2R'

Ok, I would like to share my thoughts on this recently posted (freeF2L?) parity alg. I put the /?/ in there, because it is not clear how the algorithm actually *utilizes* or takes full advantage of the unsolved front-right F2L slot. At first glance this alg appears to be rather pointless, but cmowla's cool trick that converted it to a pure OLL was very interesting to me, and so I decided to spend some time looking into it.

All notation is SiGN™ (courtesy of Lucas Garron), and I tried to be as concise as possible with this rather challenging post.

Starting with cmowla's alg (freeF2L?):
r U2 x' U2 x' U' 2L' U F2 U' 2L U 2R U2 2L' U2 l' x U2 2R'

In order to better examine this, I first had to take out the internal cube rotations which gives:
r U2 B2 D' 2L' D B2 D' 2L D 2R D2 2L' D2 l' B2 2R' x'

I then spotted the interesting commutator in the middle of the alg (B2 D' 2L' D B2 D' 2L D), and if wide turns were used instead of slices, it would also be a cool (3)(3x2x1 block) commutator: B2 D' l' D B2 D' l D which has the same effect as [B2,r 3f2 r'].

Not only is this block commutator interesting for its effect, but it also uses the single face turns of /D/, and is outside <R,L,U2,D2,F2,B2> (Domino Homomorphism). Seeing stuff like this, further backs up cmowla's claim - "I DID NOT use a computer solver to form any of the algorithms I have (or will) release. I have derived them all by hand."

r U2 B2 D' 2L' D B2 D' 2L D 2R D2 2L' D2 l' B2 2R' x' (17h/23q)
As cmowla has already shown, the trick here - by converting the 2R's to r, will yield a pure OLL parity alg:
r U2 B2 D' 2L' D B2 D' 2L D r D2 2L' D2 l' B2 r' x'

Now that is a very cool way to get a (17h/23q) pure OLL, but I don't think I can make that alg execute as fast, nor is it any simpler than even the old standard parity alg below. (I also realized that cmowla might have proved himself wrong, concerning some earlier assertions, to give me an alg that did otherwise!)

OldStandardOLL = 2R2 B2 2L' B2 2R B2 U2 2R U2 2R' U2 2L U2 B2 2R2

It is interesting to note that OldStandardOLL is based move|move on a hybrid 3x3x3 F-perm [(UL><UR) +non-oriented corner swap (UFR><FUL)] (click on link below to see the effect it has on a 4x4x4 cube)

Fx-perm = R2 B2 L' B2 R B2 U2 R U2 R' U2 L U2 B2 R2

Converting face turns <R,L> to (Domino Homomorphic) single slices <2R,2L> SiGN™ gives:
OldStandardOLL parity = 2R2 B2 2L' B2 2R B2 U2 2R U2 2R' U2 2L U2 B2 2R2

4x4x4 Speedversion making all <R,L> doublewide turns <r,l> SiGN™ gives:
SpdOldStandardOLL = r2 B2 l' B2 r B2 U2 r U2 r' U2 l U2 B2 r2

Please note that performing lucasparity = r U2 x r U2 r U2 r' U2 l U2 r' U2 r U2 r' U2 r' does EXACTLY the same thing on a 4x4x4 as performing SpdOldStandardOLL.

And of course, the speed form of this algorithm is achieved if all slice turns are converted to wide (you can do the conjugates to get it in the U-layer, but remember, it's my alg no matter how you change it!). On the 4X4X4: r U2 x' U2 x' U' l' U F2 U' l U r U2 l' U2 l' x U2 r'

Now going back to the /inner rotation free/ version of cmowla's alg, and converting all slice turns to wide turns gives: SpdCmowlaF2L?parity (17h/23q) = r U2 B2 D' l' D B2 D' l D 2R D2 l' D2 l' B2 r' x'

I noticed that after doing that alg, and adjusting with the cube rotations [x y2], the position would be identical to SpdStandardOLL (15h/25q), which also does the same thing as lucasparity [r U2 x r U2 r U2 r' U2 l U2 r' U2 r U2 r' U2 r' (17h/25q)], which I believe to be faster/easier than any possible transforms of [r U2 (B2 D' l' D B2 D' l D) r D2 l' D2 l' B2 r' x' (17h/23q)], and reParity™ - r U2 l' U2 x',(r' U2 l U2)2, l' U2 y' 2m2 (15h/23q) is even better! So based on those comparisons, I'm not inclined to over-conjugate myself on finger-trick transforms of cmowlaF2L?parity.

Very interesting approach nonetheless, and I enjoyed the challenge of analyzing this.

Thanks again,

 

[Christopher Mowla]

Very nice post reThinker. Nice observations.

Based off of my experience, this is the only possible approach to achieve pure edge flip algorithms for single slice turns which are sub 25q. In fact, according to my belief (which I have evidence to back up), 23q is God's number for the pure edge flip in the single slice turns move restriction. This was not immediately obvious to me, but after a little thought, this was my conclusion. In the near future, I will attempt to prove this by way of contradiction. I am sure it will be a fun discussion! Until then, happy cubing everyone!

EDIT:
The 17h/23q algorithm I posted in this thread does not use the F2L slot it messes up by any means. Pretty useless, but interesting to see (since this scenario was mentioned before). I guess my presentation of the nature of the algorithm was misleading, but the algorithm did technically fit the "without adding unnecessary 3X3X3 restoration moves to make a pure dedge flip algorithm" idea, because I could technically add just 3X3X3 moves to make it a pure edge flip algorithm and the algorithm was less than 25q as well (which was really the point). Edge flip algorithms (that preserve F3L) which flip the edge in the same location it was originally are not using any extra moves (which I think was your original thoughts when you began this thread). Sure some 25q conventional algorithm's last move is U2 (so technically only 23q is required by these algorithms), but I have now presented 23q pure algorithms (so even that isn't really a valid argument anymore either for utilizing the U-layer).

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.

 

[Ron]

Thanks for posting, cmowla.
Very nice find. Still trying to figure out how the last part with the single U moves works. Could something similar also work for the first part?

It is not my fastest edge flip yet, but I will practice it some more.

Have fun,

Ron

 

[Christopher Mowla]

Thanks for posting, cmowla.
Very nice find. Still trying to figure out how the last part with the single U moves works. Could something similar also work for the first part?

It is not my fastest edge flip yet, but I will practice it some more.

Have fun,

Ron

I am glad you are at least giving the algorithm (I am assuming cmowlaparity) a shot! You are most welcome! Sorry for the long delay for giving out sub 25q algorithms. I do have to say though, cmowlaparity is probably the fastest sub 25q there is (in my opinion).

Anyway, although it may appear I formed the alg by starting with a first portion and ending with the individual U moves, it didn't happen that way (I started with the algorithm as a whole and so the beginning portion was not purposely formed for speed, but for optimality).

However, since you like lucasparity (at least, that's what I picked up in my thread), here is a 25q from this method which might at least interest you, if not actually useful for speedsolving: (it could be faster than cmowlaparity for you, but cmowlaparity is faster for me than this one).

On the 4X4X4
Rw U2 Rw2 U2 x' U Rw U' F2 U Rw' U' Lw' U2 Rw U2 Rw' U2 Rw' (25q/18h)
On the 5X5X5
Rw U2 Rw2 U2 x' U Rw U' F2 U Rw' U' (Lw'M') U2 Rw U2 Rw' U2 Rw' (25q/18h)

 

[QCcuber4]

I use this, on LL when i scan for my OLL and notice parity, I don't see why laerning a bunch of algorithms for it can be useful... then again i don't fully understand what you guys are talking about, im not that advanced...

Rw2 B2 U2 Lw U2 Rw' U2 Rw U2 x' U2 Rw U2 Lw' x2 U2 Rw2'

 

[Christopher Mowla]

I use this, on LL when i scan for my OLL and notice parity, I don't see why laerning a bunch of algorithms for it can be useful... then again i don't fully understand what you guys are talking about, im not that advanced...

Rw2 B2 U2 Lw U2 Rw' U2 Rw U2 x' U2 Rw U2 Lw' x2 U2 Rw2'

Oh, that's perfectly understandable. We were just discussing the possibility of faster and possibly shorter OLL parity algorithms, that's all.

 

[QCcuber4]

Like, 1 alg per case? thats pretty insane... and it would mean alot of time trying to learn all... not talking about recognition while solving...?:confused:

 

[joey]

Like, 1 alg per case? thats pretty insane... and it would mean alot of time trying to learn all... not talking about recognition while solving...?:confused:

No, you're really not understanding.

They were just trying to find different ways to do the same thing, not learning lots of new algs, but just one or maybe two.