# WANTED: New Dedge Flip Algorithm!



## reThinking the Cube (Dec 21, 2009)

Is it just me, or do all "pure" OLL dedge flip parity algs for 4x4x4 stink!

Why do these algs have to be pure, or so careful about changing LL when it is easy to discover the parity at an earlier point in the solve? 

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


----------



## Toad (Dec 21, 2009)

Why not just wait until you get to LL to do it...

It'll waste more moves having to setup for this alg so as not to ruin the bits of the cube that are already solved...?


----------



## Swordsman Kirby (Dec 21, 2009)

randomtoad said:


> Why not just wait until you get to LL to do it...
> 
> It'll waste more moves having to setup for this alg so as not to ruin the bits of the cube that are already solved...?



You can see whether or not you need to execute the OLL parity quite easily with only one F2L pair left to do.


----------



## Kirjava (Dec 21, 2009)

Related; find one for Roux - since you can discover the parity as soon as you come to the last six edges.


----------



## Lucas Garron (Dec 21, 2009)

I'm not sure I agree with your title, but:
http://www.speedsolving.com/forum/showpost.php?p=239386&postcount=5

r' U R U (r' U2)3 r2 U R' U' r2 U' R' U r'



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?*


Bolding doesn't really help. 

Anyhow, this doesn't look much easier (read: I don't think algs will be much shorter) than a regular ALL parity, and I find your request description a bit arbitrary.

But I do wonder what is "the" shortest algorithm that gets each orbit of 4x4x4 parity to a solvable 3x3x3 as fast as possible.


----------



## Gurplex2 (Dec 21, 2009)

wtf is a dedge


----------



## SuperNerd (Dec 21, 2009)

Gurplex2 said:


> wtf is a dedge



It's an edge pair. DEDGE = Double EDGE

TREDGE = TRiple EDGE


----------



## Lucas Garron (Dec 21, 2009)

Gurplex2 said:


> wtf is a dedge


Dedge


----------



## V-te (Dec 21, 2009)

Or you can just use K4


----------



## ~Phoenix Death~ (Dec 21, 2009)

V-te said:


> Or you can just use K4



Which is VERY intuitive.


----------



## Christopher Mowla (Dec 21, 2009)

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.

Proof:
There are two main reasons for this:
[1] "Edge flip" algorithms', or even just every pure odd parity algorithm’s, main goal is to preserve the centers: if they don’t preserve the centers, then you might as well use the Cage Method (which as you know is not going to give you a world record: commutators are an inefficient way to solve the centers).
[2] The wing edges need to be separated in the beginning of the algorithm and subsequently at the *end* of the algorithm (which is *slice* turns, not outer-layer turns).

Unlike all other forms of odd parity restricted to the LL, the "one edge flip" is the case which requires the most moves (or at least it is safe to say that, no other form of odd parity will actually require more than the least moves that the one-edge flip can be done in) because the two wing edges are initially in the same composite edge.

The "r2 B2" and "B2 r2" that you see at the beginning and end of common algorithms is to bring the initially front-right wing edge to the back-left, so that the front-left and back-left are directly across from each other (or vice versa, depending on which mirror you do). (Note: there are other ways to move two winged edges besides r2 B2/l2 B2, which are originally in the same composite edge, opposite to one another, in 4 block quarter turn moves, but this is the only way to get them across from each other in 2 block half turn moves).

For example, the best opposite winged edge swap from my understanding (or its mirror) is:

l' U2 l' U2 F2 l' F2 r U2 r' U2 l2

Now, to make this a pure edge flip, it is going to cost us some more moves. We start off with adding "l2 B2" to the beginning and "B2 l2" to the end.

l2 B2
l' U2 l' U2 F2 l' F2 r U2 r' U2 l2
B2 l2

But, we have a problem: the top and bottom centers are discolored slightly.

To fix this problem, all you need to do is add 1 half turn slice in the beginning and the end:

l2 B2 *l2*
l' U2 l' U2 F2 l' F2 r U2 r' U2 l2
*l2* B2 l2

As you probably can see, there are three block quarter turn moves which disappear due to move cancellations, and we are left with a 25 block quarter turn alg/15 block half turn alg:

l2 B2 l U2 l' U2 F2 l' F2 r U2 r' U2 B2 l2

Just as the "base" for the alg above was l' U2 l' U2 F2 l' F2 r U2 r' U2 l2, if you try, you will find that the base of r2 B2 U2 l U2 r' U2 r U2 F2 r F2 l' B2 r2 is:

r2 B2 r2
*r2 U2 l U2 r' U2 r U2 F2 r F2 l' r2*
r2 B2 r2

With all of that said, I just wanted to show you that you must first separate the dedge pieces (some how) in order to swap them.

As you have seen in the two previous examples, *if you separate wing edges at the beginning of an alg, then you’re going to have to reverse it at the end.* You are not going to be able to do the reverse of the slice turns so that all which remains after it are outer layer turns (well, unless you add in a lot of outer layer turns at the end, then maybe you could do this—you can try it, but I will not waste my time).

In short, your fantasy algorithm does not exist. (Here I am assuming that you desire an algorithm which is shorter than a typical edge flip alg because I definitely can say that such an algorithm that you are requesting will definitely not be “prettier” than what you already have access to).

End of Proof

Just as there are rules in integration that cause an infinite number of integrals to not exist, so are there rules for the cube. But in Calculus, we have the alternative to integrate a function (whose anti-derivative cannot be expressed in terms of elementary functions) by expanding the function as an infinite power series and integrating it term-by-term. Similarly, this algorithm can be done by expanding (adding in a lot more outer-layer turns at the end or making the overall length of the algorithm longer), but it will not be pretty (if it can even be done at all). But whether talking about cubing or calculus, the alternative is not very beautiful.

As Lucas Garron mentioned, maybe what you are really hungry for is a pure edge flip algorithm that is the least number of moves. I am assuming he meant block quarter turn moves, because in block half turn moves, we already have the optimal algorithm (15).

For speedcubing purposes, these briefest pure “edge flip” algorithms (in block quarter turn moves) are most likely not going to be necessarily faster to perform than the current algorithms (I perform a few of mine around the same amount of time), even though they might be 5-6 block quarter turn moves less.

If you absolutely hate the “one edge flip”, then use K4 (as V-te said). To make sure you avoid it using that method, first do commutators to make all of the LL yellow. Then do 1 of the 2 possible odd parity algorithms (or their mirrors). Unfortunately, this process often makes the cuber to do more moves than necessary to complete the LL edges.

You might think that the pure "edge flip" algorithms stink, but if you knew how much they accomplish, even though they are bounded by a very large number of constraints (the shorter the algorithm, the more constraints the composer of the algorithm has to overcome), you would develop a hate for the odd number of slice turns you use to solve the centers at the beginning! The "parity errors" therefore can be renamed "human errors" because we do have control to prevent them (but of course for speedcubing, there is no way to detect it in during inspection time—unless you are amazing). Pure odd parity algorithms are our "spare tires", if you will, and there is no "spare tire" which we can put on our car faster than what we already have.


----------



## waffle=ijm (Dec 21, 2009)




----------



## Robert-Y (Dec 21, 2009)

Wow I think I might switch to: OLL, solve parities if there are any, PLL. (Instead of OLL parity if any, OLL, PLL parity if any, PLL.


----------



## deadalnix (Dec 22, 2009)

cmowla said:


> blabla



Is that really a proof ?


----------



## KConny (Dec 22, 2009)

V-te said:


> Or you can just use K4


Do you see that as useful information? Does it solve his problem within the domain he specified?


----------



## ~Phoenix Death~ (Dec 22, 2009)

KConny said:


> V-te said:
> 
> 
> > Or you can just use K4
> ...



Yes. Because I do. K4 helps a lot cause it uses intuitive commutators.


----------



## Hyprul 9-ty2 (Dec 22, 2009)

Robert-Y said:


> Wow I think I might switch to: OLL, solve parities if there are any, PLL. (Instead of OLL parity if any, OLL, PLL parity if any, PLL.


Like what Syuhei does? Any tips on recognition? I tried it once, it took me ages to figure out whether it was just an edge flip or double parity :fp


----------



## ben1996123 (Dec 22, 2009)

SuperNerd said:


> Gurplex2 said:
> 
> 
> > wtf is a dedge
> ...



On a 6x6 what would it be?

Qedge? Quedge? Quadredge?

7x7 is Quidge?


----------



## Christopher Mowla (Dec 22, 2009)

deadalnix said:


> cmowla said:
> 
> 
> > blabla
> ...


 
deadalnix,
For an edge flip algorithm, *the wing edges must be separated in the beginning *because no matter how many outer-layer turns you perform prior to the separation, it will not get you anywhere.

With that said, you must bring back the wing edges some time later. If you don't do it at the end, but some time before that so that all that is left is outer-layer turns *that restore the LL and maybe one F2L slot*, then it is going to take you more outer-layer moves to compensate for the "early wing edge reunion" which should have occurred at the end (symmetrical).

And notice most of all that reThinking the Cube wanted an algorithm that didn't "stink". There is no way you can have one that fits into his description that isn't a whole lot worse than the briefest existent algorithms already.


----------



## reThinking the Cube (Dec 22, 2009)

cmowla said:


> 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).



I really appreciate this expose, and am in agreement with your take on this parity problem, but we appear to have a different understanding as to what this "algorithm" is supposed to be able to do. 

Maybe to clear this up, I should first state what this New dedge flip algorithm is NOT supposed to do. That way we can all be working together here.

1) This algorithm does NOT have to restore the flipped dedge to its original location. I know the edge pieces need to be swapped and then paired back to reform the dedge, but the permutation of this piece can be any dedge position on LL or the yet to be solved dedge for F2L pair. So any of these 5 possible spots to return the dedge to is fine. This allows for more flexibility to find better base edge exchange algorithms that can be used to make the actual dedge flip. 

2) F2L is solved except for the last slot pair, and LL is open. This algorithm then does NOT have to worry about making changes (psuedo 3x3x3) to any of these 10 locations. This should again make it easier to do the flip algorithm since changes are not only allowed here, but also do not have to be restored back again later. Another aspect of this restriction removal is that there are 5 corner pieces that are happy with any orientation, permutation, or parity situation. This is a HUGE advantage in terms of finding good finger friendly algs, as now the single slice moves (i.e r,r',l,l',u,u') can sometimes be coupled with their respective face turns making for example, changing [r u r' u'] into [(Rr) (Uu) (Rr)' (Uu)'] without messing up anything important.

3) This algorithm does NOT even have to flip just one dedge, and in fact can flip any odd number of dedges (1,3,5). If it turns out that there is a shorter pure edge exchange that works on more pieces (not likely, but still possible) then the parity issue would still be solved. In other words, it makes no difference how many we "flip", just as long as it is an odd number of dedges that get the treatment. 

4) This algorithm must NOT unpair any of the dedges, as this would obviously be counterproductive. (Stated for the record).

5) This algorithm must NOT mess up the centers. (again for the record).

Are we seeing eye to eye on this now?



> 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).



You probably see now that it is possible to create a better "unpure" edge flip algorithm that would satisfy the much looser conditions of this problem.



> 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.



This "proof" has some solid logic to it, BUT there is NO constraint for using only "pure" edge flips, or on having to restore the dedge to its original location. I believe that both better single edge swap algs and better dedge parity flips based on them will be found.



> Proof:
> There are two main reasons for this:
> [1] "Edge flip" algorithms', or even just every pure odd parity algorithm’s, main goal is to preserve the centers: if they don’t preserve the centers, then you might as well use the Cage Method (which as you know is not going to give you a world record: commutators are an inefficient way to solve the centers).
> [2] The winged edges need to be separated in the beginning of the algorithm and subsequently at the *end* of the algorithm (which is *slice* turns, not outer-layer turns).
> ...



Very nice expo on the logic used to create these algs. I appreciated that!



> As Lucas Garron mentioned, maybe what you are really hungry for is a pure edge flip algorithm that is the least number of moves. I am assuming he meant block quarter turn moves, because in block half turn moves, we already have the optimal algorithm (15).
> 
> For speedcubing purposes, these briefest pure “edge flip” algorithms (in block quarter turn moves) are most likely not going to be necessarily faster to perform than the current algorithms (I perform a few of mine around the same amount of time), even though they might be 1-2 block quarter turn moves less.



What I want is the dirtiest, nastiest, pure, or unpure, single "edge flip" you can come up with. As long as it satisfies the conditions above - I will be VERY happy. It will not be a problem at all for me to invent the cube rotations, inversions, conjugations, and cancellations to optimize from there. 

reThinker


----------



## waffle=ijm (Dec 22, 2009)

r U2 r U2 r' U2 r U2 l' U2 r U2 r' U2 M r' U2 r'

this is sub-3 able.


----------



## qqwref (Dec 22, 2009)

I don't think your proof is actually a proof. Essentially I am just not convinced that all theoretically possible parity algs which are more optimal than the pure edge flip one can be ruled out. Perhaps explaining exactly how you have covered all cases would be helpful. It is clear that any optimal parity alg which keeps the puzzle reduced would start and end with a slice move, but I don't agree that this means the pure edge flip is the best way to do it.

Also, your post directed at deadalnix was indeed pretty arrogant (e.g. the part where you're like "find the shortest pure edge flip in the world by hand, and then we will talk").


----------



## miniGOINGS (Dec 22, 2009)

Haha, I love my ZZ 4x4 method (should I call it ZedZ? lol) because you NEVER GET OLL PARITY!!!


----------



## Robert-Y (Dec 22, 2009)

Hyprul 9-ty2 said:


> Robert-Y said:
> 
> 
> > Wow I think I might switch to: OLL, solve parities if there are any, PLL. (Instead of OLL parity if any, OLL, PLL parity if any, PLL.
> ...



Well what I would do is imagine in my mind what the PLL would look like if that edge was flipped.

If I can't seem to recognise any PLL case, then that probably means that I have a double parity case. However, if it seems like a PLL case I know, then I probably have just an OLL parity.
.
What I'm really starting to think is that a combination of both systems (depending on the OLL case with parity) is the way forward.

EDIT: Sorry I know I've gone rather off-topic...


----------



## Christopher Mowla (Dec 22, 2009)

reThinking the Cube,
I actually was on the same page you were on. You and I do see eye to eye. And thanks for your appreciation! Well, if you really want me to try to find the "dirtiest" alg that does what you want, I will try. I will not use a computer in my attempts (I refuse to). The reason I first discouraged the idea is because you said the current dedge flip algorithms stink. That to me implied that you prefer the cleanest algorithms possible.

qqwref,
I am glad you agree with me with the slice at the beginning and end of the alg. Maybe it is possible to consider a non-pure algorithm to be the shortest.


----------



## reThinking the Cube (Dec 22, 2009)

Lucas Garron said:


> I'm not sure I agree with your title, but:
> http://www.speedsolving.com/forum/showpost.php?p=239386&postcount=5
> 
> r' U R U (r' U2)3 r2 U R' U' r2 U' R' U r'



Dang it Lucas! Thanks for the nice alg courtesy Grandmaster P, but you are seriously frustrating me when you make r' = (Rr)' = r' . How can you specify a single slice turn on a big cube with this notation method? I never know for sure with your algs to slice or not to slice. Stop it, or, or, or..... I might be revenge driven to post gobs and gobs of mystery algs using a combination of face color names, arrows, and compass headings!

reThinker


----------



## Stefan (Dec 22, 2009)

reThinking the Cube said:


> Lucas Garron said:
> 
> 
> > r' U R U (r' U2)3 r2 U R' U' r2 U' R' U r'
> ...


Click and watch?


----------



## reThinking the Cube (Dec 22, 2009)

StefanPochmann said:


> reThinking the Cube said:
> 
> 
> > Lucas Garron said:
> ...



Yeh, its a good thing that I did, or that earlier post might have contained a few too many 4-letter algorithms. It's actually funny how I tried doing that a couple of times and was getting rather peaved, before I spotted the problem with the notation, and then also watched his applet to confirm my hunch. Lucas knows far too much to not know that (Rr) = r = (Rr) notation is confusing people wherever it is found. 

reThinker


----------



## qqwref (Dec 22, 2009)

Lucas usually uses the SiGN notation, which is not in any way ambiguous or confusing (although you do have to know it is being used to follow it, since it's not the same as the other notation). Unlike the notation you're familiar with, it is actually consistent with the 3x3 notation, in that r is a double-layer turn.

In SiGN, by the way, turns of single slices (on the R face, say) are labeled R, 2R, 3R, ... and turns of multiple slices (on the R face) are labeled R, r, 3r, 4r, .... So if Lucas wanted to use a slice turn in his alg he would write 2R.


----------



## reThinking the Cube (Dec 23, 2009)

cmowla said:


> reThinking the Cube,
> I actually was on the same page you were on. You and I do see eye to eye. And thanks for your appreciation! Well, if you really want me to try to find the "dirtiest" alg that does what you want, I will try. I will not use a computer in my attempts (I refuse to).



Yeh, I _WOULD_ use a computer to help me, but there aren't any programs (yet) that will solve this. Acube and CubeX find some 4x4x4 algs by limiting moves and setup, but not this one. These algorithm(s) are destined to become the new standards for flipping single edgepairs. Naming rights should go to the finder. Maybe even do a trademark funny like Petrus did with Sune™ 

All the best hunting!

reThinker


----------



## esquimalt1 (Dec 23, 2009)

V-te said:


> Or you can just use K4



You still get parity with K4.


----------



## aronpm (Dec 23, 2009)

reThinking the Cube said:


> These algorithm(s) are destined to become the new standards for flipping single edgepairs.


There is no need for a parity algorithm to be used before the last slot. It is pointless. There are a large amount of people with official sub-50 solves. As far as I know, they all use a form of reduction. They don't need a new parity algorithm to get fast. They get fast by practise. A new parity algorithm that messes up your last layer is not a 'new standard.' It is pointless.

Even if somebody wrote up a long list of algorithms to solve OLL on the 4x4x4 in one step (including the cases with 1 and 3 oriented edges), that would not be a new standard. Even if somebody wrote up a long list of algorithms to solve PLL on the 4x4x4 in one step (including odd parity), that would not be a new standard. It would be impressive that they made the algorithms, learnt them, and put them into practise, but it would not be a new standard, and it would not be significantly faster.

Why on Earth are you looking for a 'new standard' parity algorithm?


----------



## reThinking the Cube (Dec 23, 2009)

aronpm said:


> A new parity algorithm that messes up your last layer is not a 'new standard.' It is pointless.




It does NOT mess up the LL since F2L is not even done yet, and that IS the point of this algorithm - which should be faster, quicker, and cheaper than what we have now. 

reThinker


----------



## qqwref (Dec 23, 2009)

You don't get it, reThinker. Even if there is an algorithm that ignores last slot + last layer and is more efficient than any pure edge flip, it's not going to be by much - maybe two or three turns at most. It's not like there's some really awesome 10-move parity alg that, when found, will completely revolutionize bigcube solving. That is, although I'm not convinced by cmowla's proof, I don't think there is likely to be a parity alg that is "faster, quicker, and cheaper than what we have now" - and even if there is, I really don't think it will be by very much.

The thing is, as you can see in the video, the fastest speedcubers perform the already-known alg in under 4 seconds. At best, you're talking an improvement of a fraction of a second, and that's without factoring in how annoying a parity alg that messed with the last slot would be. Not only would recognition get slightly harder, but if you had a solved (or really nice) last slot case as well as parity you'd have to abandon that in order to do your special alg. I'm not saying you should completely stop looking, but don't think your idea is going to substantially change how 4x4 solves are done.


----------



## reThinking the Cube (Dec 23, 2009)

qqwref said:


> That is, although I'm not convinced by cmowla's proof, I don't think there is likely to be a parity alg that is "faster, quicker, and cheaper than what we have now" - and even if there is, I really don't think it will be by very much.




Even if it is just a little faster - then its still gonna be faster.
Even if it is just a little quicker - then its still gonna be quicker.
Even if it is just a little cheaper - then its still gonna be cheaper.

SO IF GIVEN A CHOICE - 
Which one would you prefer?
Which one would most prefer?

Seems to me that it certainly WOULD make a difference.

This new algorithm should also be simpler, and hopefully much easier to learn. Try teaching the 4x4x4 solve to someone not familiar with these parity algs, and then come back and tell me this won't make much of a difference. The existing parity algs are relatively hard for most to learn and master. 




qqwref said:


> I'm not saying you should completely stop looking, but don't think your idea is going to substantially change how 4x4 solves are done.




I did not say that it would substantially change how the whole of 4x4x4 solves are done. My idea here is that this specific parity issue (only one component of the solve) could be dealt with in a new and better way. It would then become standard practice to use that new "way", or technique to fix just this dedge flip parity. 

Why are you being such a Parity Pooper? 

reThinker


----------



## DavidWoner (Dec 23, 2009)

reThinking the Cube said:


> This new algorithm should also be simpler, and hopefully much easier to learn. Try teaching the 4x4x4 solve to someone not familiar with these parity algs, and then come back and tell me this won't make much of a difference. The existing parity algs are relatively hard for most to learn and master.



You are clearly not familiar with Dan Cohen's parity song.


----------



## deadalnix (Dec 23, 2009)

cmowla said:


> deadalnix, if you really understood how brief pure "edge flip" algorithms are formed, you wouldn't be soooo arrogant!



I really understand that. But I see no proof that this is the only way to do it.



cmowla said:


> It can't get any simpler than that. If you want more of a proof, deadalnix, find the *shortest* pure edge flip in the world (in block quarter turn moves) *by hand*, and then we will talk.



You can't prove I'm wrong so I'm right ? That's a very strange way to apply logic.

Anyway, each time you post here, a rabbit dies somewhere on the planet. And as long as you cannont prove me that I'm wrong, I will continue to say that I'm right. See the flawed logic ? You do the same. Arogance have nothing to do with that.

The experience show that you are proabaly right, but you cannot have any proof of that at this moment, so don't call this a proof.


----------



## Christopher Mowla (Dec 23, 2009)

reThinking the cube,
for a start I have utilized the algorithm which you have seen in this thread already:
(Rr)' U R U
[(Rr)' U2] * 3
(Rr)2 U R' U' (Rr)2
U' R' U (Rr)'
I will refer to this as the base.

Here is a *36* Block Quarter turn alg: The base + a 3 edge cycle.

(Rr)' U R U
[(Rr)' U2] * 3
(Rr)2 U R' U' (Rr)2
U' R' U (Rr)'
z'
R' U R' U' R' U' R' U R U R2 z

Here is a *34* Block Quarter turn alg: The base + some moves I previously came up with in one of my threads.
(Rr)' U R U
[(Rr)' U2] * 3
(Rr)2 U R' U' (Rr)2
U' R' U (Rr)'
F' L' U' L F U R2 U R' 

These algs have a lot of moves don't they? And they are more complicated. However, if there exists and alg around 25q that accomplishes both tasks simultaneously, then maybe that alg is less complicated as well (but I doubt it).

These two algs are perfect examples of what my "proof" speaks of. They do satisfy your constraints, but their format and length, as well as overall beauty is poor. Notice that I had to add a lot of outer-layer turns to satisfy your constraints (just as my proof said). The last inner-layer turn (Rr)' by no means occurs at the end here.


----------



## Toad (Dec 23, 2009)

DavidWoner said:


> reThinking the Cube said:
> 
> 
> > This new algorithm should also be simpler, and hopefully much easier to learn. Try teaching the 4x4x4 solve to someone not familiar with these parity algs, and then come back and tell me this won't make much of a difference. The existing parity algs are relatively hard for most to learn and master.
> ...



linky??


----------



## reThinking the Cube (Dec 23, 2009)

DavidWoner said:


> You are clearly not familiar with Dan Cohen's parity song.




OK. I am cyclily stumped. He uses K4 hybrid, and is working towards a Dr. of Music. This is a parity paradoxical to me. Please post your link to this familiar song. 

reThinker


----------



## trying-to-speedcube... (Dec 23, 2009)

@cmowla: Do you know you can also just do an edge 3-cycle in 9 moves?


----------



## reThinking the Cube (Dec 23, 2009)

cmowla ,

OK. Friend. I know (and everyone else knows as well) that you can solve this parity problem using "whatever" 2 edge swap as base).

But you know, and I know (and everyone else may NOT know) that there are better algs to get this done!

You can quote me on this: "pure swap cannot be less moves than unpure swap"!!!!!!!!!!!!!

You can do better, and you know it!

reThinker


----------



## KwS Pall (Dec 23, 2009)

I use for 4x4 double parity fix if I see an oll parity - usually i have 1 look oll (only 8 cases out of 7x are 2 look)

setup corners for non-pure parity fix in order to speed up


----------



## Christopher Mowla (Dec 24, 2009)

trying-to-speedcube... said:


> @cmowla: Do you know you can also just do an edge 3-cycle in 9 moves?


If you are taking about 9 block quarter turn moves, then no. The minimum that I know is 10 bqtm: I just used the standard 12qtm here.



reThinking the Cube said:


> You can quote me on this: "pure swap cannot be less moves than unpure swap"!!!!!!!!!!!!!
> You can do better, and you know it!
> 
> reThinker


I know that these algs I gave were longer than what the optimal alg is, but, as I said, they are for a start. And, just because I have found the briefest pure edge flip in the world doesn't mean that I can find the briefest non-pure edge flip that meets your request.


----------



## Stefan (Dec 24, 2009)

cmowla said:


> I have found the briefest pure edge flip in the world


Proof, please.


----------



## Lucas Garron (Dec 24, 2009)

cmowla said:


> It is very different than the average non-pure edge flip alg


You officially do not have a brain.

By the way, I have a 21bqtm alg that takes a 3x3x3 state "with a flipped edge" (that is, a reduced 3x3x3 on a 4x4x4 with odd edge parity) to solved.


----------



## Stefan (Dec 24, 2009)

Lucas Garron said:


> By the way, I have a 21bqtm alg that takes a can take a 3x3x3 state "with a flipped edge" (that is, a reduced 3x3x3 on a 4x4x4 with odd edge parity) to solved.


Is that true, or are you just acting like him?


----------



## Lucas Garron (Dec 24, 2009)

StefanPochmann said:


> Lucas Garron said:
> 
> 
> > By the way, I have a 21bqtm alg that takes a can take a 3x3x3 state "with a flipped edge" (that is, a reduced 3x3x3 on a 4x4x4 with odd edge parity) to solved.
> ...


It's actually true. Want me to PM it to you?


----------



## qqwref (Dec 24, 2009)

I'd be interested in seeing it.


----------



## Cyrus C. (Dec 24, 2009)

qqwref said:


> I'd be interested in seeing it.



+1, although he might not want to release it incase he writes a book on it.


----------



## PHPJaguar (Dec 24, 2009)

qqwref said:


> I'd be interested in seeing it.


...


----------



## Stefan (Dec 24, 2009)

Nevermind, found it.


----------



## Lucas Garron (Dec 24, 2009)

StefanPochmann said:


> Nevermind, found it.


Nice. Now, can you find one with 21 _outer_ block turns?


----------



## Lucas Garron (Dec 24, 2009)

qqwref said:


> I'd be interested in seeing it.


I'll sell it to you, or anyone, for a $1 no-distribution license. Free for German competitors, though, including Stefan.

PM me for a Paypal account or to make other arrangements.


----------



## Stefan (Dec 24, 2009)

Lucas Garron said:


> Now, can you find one with 21 _outer_ block turns?


Ugh. Maybe. But not now and not since I can get yours for free. PM, please? And hey, consider that qqwref's real name is more German than yours


----------



## Lucas Garron (Dec 24, 2009)

Never mind, got 19q. This one costs $2.

EDIT: Comes with the 21q alg for free.


----------



## reThinking the Cube (Dec 24, 2009)

I can smell smoke! 

The double parity that Jakub mentioned he uses to fix this dedge flip is actually a *4-cycle *of 4x4x4 edges. 

IMO - the main reason that the pure alg approach is running into trouble, is that it is forced to do a very specific 2-cycle that will also place the swapped edge pieces back into the original dedge. By not constraining this to just a 2-cycle (i.e. returning the edge pieces back to opposite sides of the same dedge location) should give an easier way. 

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 dedge pairing would normally be broken by these cycles, but here there is a solution because it is possible to target the piece cycles so that the dedges are reformed into their newly cycled locations.

The double parity is doing just that. By cycling 4 edge pieces (UFl-->UBl-->UFr-->UBr) the edge parity changes, and the dedge pieces also end up swapped as the natural consequence of this 4-cycle of edges. If the alg for this is nicer than the single parity one derived from 2-cycle edges, then the double parity alg should be the one used for fixing single parity as well.

This idea will work for other even cycles of 4x4x4 edges too. For example, the 6-cycle (UFl-->UBl-->URb-->UFr-->UBr-->URf) will fix edge parity, and at the same time move the dedges in a 3-cycle (UF-->UB-->UR). Note that the dedge parity in this case remains unchanged. It makes no difference though for this alg, since in practice, it takes too long to figure out if the dedge (PLL) parity is even or odd at this point in the solve. To just go ahead and change the dedge parity like the double parity does, or leave it the same like this 6-cycle, will end up being correct half of the time either way. 

There are also 5 corners that can move, and do not have to be returned at the end of the alg. I don't even care what the corner parity is yet, since it will usually take longer to determine the corner parity here, than it will take to execute the alg that is used to fix it later on.

Should be no more excuses now. Somebody WILL get this.

reThinker


----------



## Christopher Mowla (Dec 24, 2009)

Lucas Garron said:


> cmowla said:
> 
> 
> > It is very different than the average non-pure edge flip alg
> ...


 
Did you use your brain, or a computer solver?


----------



## Stefan (Dec 24, 2009)

reThinking the Cube said:


> Somebody WILL get this.


What exactly is "this"?


----------



## Lucas Garron (Dec 24, 2009)

Lucas Garron said:


> Never mind, got 19q. This one costs $2.
> 
> EDIT: Comes with the 21q alg for free.



UPDATE:
As a holiday special offer, I will now actually sell anyone the 19 outer block turn algorithm for the price of $1. That's right, for only $1 (and agreeing not to redistribute) you get to see the world's shortest known alg for OLL parity on 4x4x4. What a deal!

And of course, the 21q is still included! What are you waiting for?

Trade for any hand-found 23q pure OLL parity algorithms also accepted.


----------



## masterofthebass (Dec 24, 2009)

reThinking the Cube said:


> DavidWoner said:
> 
> 
> > You are clearly not familiar with Dan Cohen's parity song.
> ...



surprisingly those are both almost correct. 

The song is just a little ditty used to remember the moves of lucasparity, which is very simple. My little brother cubes about two times a year and can remember the OLL parity due to the little song. As for my method, I do a form of reduction that utilizes the 4x4's ability to be flexible, and directly solve a large portion of the cube before fulling reducing it to a 3x3. I still get OLL parity just like any reduction user would, let alone the fact that you can still get the OLL parity case when using K4.


----------



## Christopher Mowla (Dec 24, 2009)

Lucas Garron said:


> Lucas Garron said:
> 
> 
> > Never mind, got 19q. This one costs $2.
> ...


 
I am waiting for you to post your advertisements in the "buy/sell/trade" section. This is not puzzle theory and is unacceptable from a "super moderator".

And, besides, I don't think the person who wrote the cube solver program you're using to find these algs will be very happy with you trying to gain profit!


----------



## reThinking the Cube (Dec 24, 2009)

StefanPochmann said:


> Nevermind, found it.



It is very good to actually have this here -

r' D2 l B2 r' U2 r U2 l' B2 E2 l U2 l' (Pochman)

Nice alg ends up flipping the cube around spatially by relocating all of the pieces like doing a y2, and also a 4-cycle of edges to end up with a pure dbl parity fixer. Really neat use of cold, pure math!

reThinker


----------



## Lucas Garron (Dec 24, 2009)

reThinking the Cube said:


> Really neat idea!


This alg was not anybody's neat idea. Just cold, pure math.


----------



## Christopher Mowla (Dec 24, 2009)

Yes I have seen your posts, and I am not going to say anything: this is supposed to stay theory.


----------



## reThinking the Cube (Dec 24, 2009)

Lucas Garron said:


> Never mind, got 19q. This one costs $2.
> 
> EDIT: Comes with the 21q alg for free.




Did you find that 19q before or after the post you made earlier?



Lucas Garron said:


> r' U R U (r' U2)3 r2 U R' U' r2 U' R' U r'
> 
> 
> reThinker


----------



## reThinking the Cube (Dec 24, 2009)

masterofthebass said:


> The song is just a little ditty used to remember the moves of lucasparity, which is very simple. My little brother cubes about two times a year and can remember the OLL parity due to the little song.




What is the alg for this song version of OLDlucasparity™?


reThinker


----------



## qqwref (Dec 24, 2009)

You know, guys, you don't go "hey, I bet there's a better alg for <case> out there, just WAITING to be found! You guys are smart, I bet you can do it! Won't it be so cool?". You find the alg and then you post it. I mean, sure, I understand that you wish there was a better alg, but a better one isn't known and people aren't gonna make one appear out of thin air just because you think they should be able to. We already know the OLL parity alg is long and if we knew a nice shorter one we'd obviously tell everyone (and use it). This is just not a good way to discover algs. If you have an idea or an alg, tell it, but if you don't have any ideas and you just think there might be a great one we haven't found yet, well, go find it or I don't believe you.


----------



## reThinking the Cube (Dec 24, 2009)

qqwref said:


> This is just not a good way to discover algs



Sorry - previous ways were not getting good results.

Yeh, I am not just sitting around here banging on a pot, and expecting to be fed. Look!, I just cooked up another nice meal of parity stew, and shared it with everyone. Check out my earlier post on even-cycle ideas http://www.speedsolving.com/forum/showthread.php?p=292339#post292339, and give me your take on that, but don't bother trying to dissuade me. I'm on a mission, and I can't be stopped. 

reThinker


----------



## ChrisBird (Dec 24, 2009)

reThinking the Cube said:


> *Yeh, I am not just sitting around here banging on a pot, and expecting to be fed. *reThinker



Really? That's what it seemed like to me.


----------



## CL_Pepsi (Dec 24, 2009)

ChrisBird said:


> reThinking the Cube said:
> 
> 
> > *Yeh, I am not just sitting around here banging on a pot, and expecting to be fed. *reThinker
> ...



+1


----------



## reThinking the Cube (Dec 24, 2009)

Here is a possible speed version of Grandmaster P's earlier alg:

ColdHardMath™ - [(Rr)' D2 (Ll) B2 (Rr)' U2 (Rr) U2 (Ll)' B2 E2 (Ll) U2 (Ll)']

and this speed dedge flip for comparison:

FrederickBadie -[(Rr)' U2 (Ll) F2 (Ll)' F2 (Rr)2 U2 (Rr) U2 (Rr)' U2 F2 (Rr)2 F2] 


reThinker


----------



## reThinking the Cube (Dec 24, 2009)

reThinking the Cube said:


> masterofthebass said:
> 
> 
> > The song is just a little ditty used to remember the moves of lucasparity, which is very simple. My little brother cubes about two times a year and can remember the OLL parity due to the little song.
> ...


----------



## deadalnix (Dec 24, 2009)

I'm interested also to see it. But more than that (it's not a breaking alg anyway) I'm also interested in how you found this alg.


----------



## Christopher Mowla (Dec 24, 2009)

reThinking the Cube said:


> 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.....
> 
> The double parity is doing just that. By cycling 4 edge pieces (UFl-->UBl-->UFr-->UBr) the edge parity changes, and the dedge pieces also end up swapped as the natural consequence of this 4-cycle of edges.


 
No, only even cycles of odd permutations.

For example, here is a 10 cycle that is an even permutation:
R2 D R' M' B L' R B' M B L R' B' R D' R2
and any 3 composite edge cycle on a 4X4X4 is really a 6 cycle of even permutation. We naturally think of it as a 3 cycle, but it is really a 6 cycle (6 pieces are being moved, not just 3).

The most common 4 cycle performed by speedcubers, r2 U2 r2 (Uu)2 r2 u2 is an even permutation cycle as well.


----------



## cuBerBruce (Dec 24, 2009)

cmowla said:


> For example, here is a 10 cycle that is an even permutation:
> 
> and any 3 composite edge cycle on a 4X4X4 is really a 6 cycle of even permutation. We naturally think of it as a 3 cycle, but it is really a 6 cycle (6 pieces are being moved, not just 3).
> 
> The most common 4 cycle performed by speedcubers, r2 U2 r2 (Uu)2 r2 u2 is an even permutation cycle as well.



The permutation produced by r2 U2 r2 (Uu)2 r2 u2 is not a 4-cycle. It consists of two 2-cycles. The permutation produced by R2 D R' M' B L' R B' M B L R' B' R D' R2 is not a 10-cycle, but rather is two 5-cycles.

An even permutation *always* consists of an even number of *even-length* cycles, and an odd permutation *always* consists of an odd number of *even-length* cycles. The number of odd-length cycles does not matter in either case.


----------



## Christopher Mowla (Dec 24, 2009)

cuBerBruce said:


> The permutation produced by r2 U2 r2 (Uu)2 r2 u2 is not a 4-cycle. It consists of two 2-cycles. The permutation produced by R2 D R' M' B L' R B' M B L R' B' R D' R2 is not a 10-cycle, but rather is two 5-cycles.
> 
> An even permutation *always* consists of an even number of *even-length* cycles, and an odd permutation *always* consists of an odd number of *even-length* cycles. The number of odd-length cycles does not matter in either case.


 
The even parity can also be interpreted as 2 3 cycles as well. So your statement is incorrect. A 5 cycle can be made by 1 3 cycle and 1 2 cycle or 2 3 cycles...


----------



## cuBerBruce (Dec 24, 2009)

cmowla said:


> cuBerBruce said:
> 
> 
> > The permutation produced by r2 U2 r2 (Uu)2 r2 u2 is not a 4-cycle. It consists of two 2-cycles. The permutation produced by R2 D R' M' B L' R B' M B L R' B' R D' R2 is not a 10-cycle, but rather is two 5-cycles.
> ...



No, I think you are confusing cycles and permutations. A 5-cycle can not be made by a 3-cycle and a 2-cycle.


----------



## Christopher Mowla (Dec 24, 2009)

What about the other ones I mentioned? The ones that you mentioned before, don't leave those out. I had a feeling you were only going to mention the 5 cycle being composed of 1 3 cycle and 1 2 cyle....


----------



## Stefan (Dec 24, 2009)

cmowla said:


> What about the other ones I mentioned? The ones that you mentioned before, don't leave those out. I had a feeling you were only going to mention the 5 cycle being composed of 1 3 cycle and 1 2 cyle....


Please... learn proper style like Bruce did it: "*a* 3-cycle and *a* 2-cycle". Improves readability a lot. Thank you. And:

- "The even parity can also be interpreted as 2 3 cycles as well"
Huh?

- "A 5 cycle can be made by [...] 2 3 cycles"
And your point is?

Or which ones are you referring to?


----------



## Christopher Mowla (Dec 24, 2009)

cuBerBruce said:


> and an odd permutation *always* consists of an odd number of *even-length* cycles.


That.


----------



## Stefan (Dec 24, 2009)

cmowla said:


> cuBerBruce said:
> 
> 
> > and an odd permutation *always* consists of an odd number of *even-length* cycles.
> ...


Which is correct. What do you want?


----------



## Christopher Mowla (Dec 24, 2009)

Look at post #73. This all leads back to that. (I didn't intend it to be a debate).


----------



## qqwref (Dec 24, 2009)

cmowla: Look up some group theory please before you dig yourself any deeper into this hole. The definition of odd and even permutations are quite well-defined and any inconsistency you find will be in your own logic, not in the permutation concept itself.

reThinking: why are you calling it "OLDlucasparity™"?


----------



## Christopher Mowla (Dec 24, 2009)

qqwref said:


> cmowla: Look up some group theory please before you dig yourself any deeper into this hole. The definition of odd and even permutations are quite well-defined and any inconsistency you find will be in your own logic, not in the permutation concept itself.


 
I know the difference between odd and even permutations. If there are an odd number of inversions, then it is an odd permutation and vice versa.

I even wrote a ti-83 plus program that solves the LL edges on a 4X4X4 (type in the sequence of the pieces and it returns the moves to solve the LL edges--assuming that the corners are solved already, the program finishes solving the cube).


----------



## Stefan (Dec 24, 2009)

cmowla said:


> I know the difference between odd and even permutations. If there are an odd number of inversions, then it is an odd permutation and vice versa.


That's correct, so your problem is somewhere else. My money's currently on your understanding of "cycle".


----------



## Lucas Garron (Dec 24, 2009)

qqwref said:


> reThinking: why are you calling it "OLDlucasparity™"?



Yeah, it's just lucasparity™, and the official definition is in SiGN™:

r U2 x r U2 r U2 r' U2 l U2 r' U2 r U2 r' U2 r'


----------



## Christopher Mowla (Dec 24, 2009)

StefanPochmann said:


> cmowla said:
> 
> 
> > I know the difference between odd and even permutations. If there are an odd number of inversions, then it is an odd permutation and vice versa.
> ...


 
If I am understanding the word "cycle" correctly now, does this mean that all 4 cycles are of odd permutations?

In other words, does "cycle" mean that the only way for the pieces to be swapped is all at once?


----------



## Lucas Garron (Dec 24, 2009)

cmowla said:


> StefanPochmann said:
> 
> 
> > cmowla said:
> ...


Close. They _are_ odd permutations.


----------



## Tim Reynolds (Dec 24, 2009)

cmowla said:


> StefanPochmann said:
> 
> 
> > cmowla said:
> ...



Yes. A 4-cycle must be of the form (a b c d). It cannot be (a b)(c d), or (a)(b c d). Thus any 4-cycle is an odd permutation.


----------



## Stefan (Dec 24, 2009)

cmowla said:


> If I am understanding the word "cycle" correctly now, does this mean that all 4 cycles are of odd permutations?


That's correct.



cmowla said:


> In other words, does "cycle" mean that the only way for the pieces to be swapped is all at once?


You can do it in several steps if you talk about the result. But mainly a cycle is *a* cycle.



cmowla said:


> The most common 4 cycle performed by speedcubers, r2 U2 r2 (Uu)2 r2 u2 is an even permutation cycle as well.


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


----------



## reThinking the Cube (Dec 26, 2009)

Given a 4x4x4 cube with all of the 24 edge pieces paired into their 12 respective dedges. Let's just ignore for now, all of the corners and center pieces. 

#1) Does anyone know of some simple even#(2,4,6,8,.....24)-cycle algs to permute these edge pieces, that will also maintain the dedge pairing? 

#2) Can Acube, or CubeX be used to generate possible algs for this type of problem?

reThinker

EDIT: Can also be any COMBINATION of cycles that permute these edges, as long as the total number of these even cycles is ODD.


----------



## Stefan (Dec 26, 2009)

reThinking the Cube said:


> #1) Does anyone know of some simple even#(2,4,6,8,.....24)-cycle algs to permute these edge pieces, that will also maintain the dedge pairing?


Define "simple".


----------



## reThinking the Cube (Dec 27, 2009)

StefanPochmann said:


> reThinking the Cube said:
> 
> 
> > #1) Does anyone know of some simple even#(2,4,6,8,.....24)-cycle algs to permute these edge pieces, that will also maintain the dedge pairing?
> ...




I guess "simple" is <= 19q. And for the record - that doesn't include "U".


reThinker


----------



## Stefan (Dec 27, 2009)

reThinking the Cube said:


> I guess "simple" is <= 19q.


Then the answer is yes, Lucas knows some.


----------



## reThinking the Cube (Dec 27, 2009)

StefanPochmann said:


> reThinking the Cube said:
> 
> 
> > I guess "simple" is <= 19q.
> ...




YES! I would keep that game face on for as long as it takes to get him to share. You scared the hair off my back when I saw that!

reThinker


----------



## Christopher Mowla (Dec 27, 2009)

Does anyone know what the briefest algorithm known to man is for the diagonal winged edge swap (pure form) in BQTM? (See sketch below).

I just need to know how many BQTM it is, not the algorithm itself or any other move measurements...


----------



## reThinking the Cube (Dec 28, 2009)

cmowla said:


> Does anyone know what the briefest algorithm known to man is for the diagonal winged edge swap (pure form) in BQTM? (See sketch below).
> 
> I just need to know how many BQTM it is, not the algorithm itself or any other move measurements...




The answer is 2.

reThinker


----------



## rachmaninovian (Dec 28, 2009)

cmowla said:


> Does anyone know what the briefest algorithm known to man is for the diagonal winged edge swap (pure form) in BQTM? (See sketch below).
> 
> I just need to know how many BQTM it is, not the algorithm itself or any other move measurements...



me would likey know the answer too.


----------



## reThinking the Cube (Dec 28, 2009)

rachmaninovian said:


> me would likey know the answer too.




I bet you would too. Checked out your sandwhich pages, http://rachmaninovian.webs.com/ This is becoming one of the best (clearest, and most complete) method descriptions for 4x4x4 (5x5x5). The page showing last dedge pair algs was especially interesting, and I saw that you tapped into many of the known good algs for doing those. I have a different method for solving 4x4x4 though, and would like to find better ways to do even-cycle edge perms. Would you likey know the answer for this previous post too? 
http://www.speedsolving.com/forum/showpost.php?p=294116&postcount=90 

reThinker


----------



## reThinking the Cube (Dec 29, 2009)

cmowla said:


> Does anyone know what the briefest algorithm known to man is for the diagonal winged edge swap (pure form) in BQTM? (See sketch below).
> 
> I just need to know how many BQTM it is, not the algorithm itself or any other move measurements...




Why are you asking this here anyway? This edge swap is 1/2 of a PLL parity fix, and is just a NO-OP for fixing OLL (dedge flip) parity. Since the dedges need to stay together, the other edge pieces in your diagram will also have to swap as well. This amounts to two (an EVEN#) of 2-cycles, which will not change the OLL edge parity at all. 

This thread is seeking some NEW and better ways to bring edge parity (OLL dedge flip) back to even. If you want to be helpful, please find some algs that are ODD#'s of even-cycles of edge pieces (that also keep the dedges paired). The pure parity alg is only one way of doing this, and does in fact fit the criterion for this problem, since it IS an odd#(1) of a 2-cycle of edge pieces. The problem with the pure parity alg, is that it has the most constraints (requiring all pieces to be placed exactly), and is therefore the most difficult to achieve. Finding OTHER algs that perform and odd# of even-cycles of edge pieces(while keeping the dedges paired, but not necessarily restoring everything else),will make for some NEW approaches to solving edge parity(OLL,dedge flip). Can you find some of these NEW algs?

reThinker


----------



## rachmaninovian (Dec 29, 2009)

reThinker: thanks =P what is your 4x4 method? you must know even cycles sux LOL


----------



## PHPJaguar (Dec 29, 2009)

Lucas Garron said:


> UPDATE:
> As a holiday special offer, I will now actually sell anyone the 19 outer block turn algorithm for the price of $1. That's right, for only $1 (and agreeing not to redistribute) you get to see the world's shortest known alg for OLL parity on 4x4x4. What a deal!
> 
> And of course, the 21q is still included! What are you waiting for?
> ...



Pay'd.


----------



## Christopher Mowla (Jan 3, 2010)

Ok reThinker, I have found an algorithm which I believe is close to your description.

If the first portion of the alg is only performed, then one has an almost solved 3X3X3 form. If you do the last 2 half turn moves (which I added on to do the dirty work of restoration), then the cube matches your description much more: everything on the cube is preserved except for 6 composite edges. All 5 composite edges', other than the edge being "flipped" itself, orientation will be preserved (*all corners are preserved too*). With just a few more moves than that, this alg can become a pure double parity alg.


Total Moves:​ 

Without final touches: 23 BQTM, 15 BHTM
With final touches: 27 BQTM, 17 BHTM

[main portion]
x r U2 r U2 r2 U2 r F2 x' l U2 l' U2 r' U2 r
[restoration]
B2 D2


Note: the algorithm can be executed using either single slice turns about l and r, or double layer turns, but *I don't recommend using single slices* because you will need to do 3 more half turn moves to restore the cube.

In summary:
27 BQTM, 17 BHTM 
x r U2 r U2 r2 U2 r F2 x' l U2 l' U2 r' U2 r B2 D2 

That's probably the best algorithm (for speed anyway) that I will be able to come up with that is very close to your request.


----------



## Stefan (Jan 3, 2010)

cmowla said:


> The algorithm is a very *clean*, easy-to-execute alg that is *very* close to your description.


Not as clean and not as short as the well-known algorithms. You're going the wrong direction.


----------



## Christopher Mowla (Jan 3, 2010)

StefanPochmann said:


> cmowla said:
> 
> 
> > The algorithm is a very *clean*, easy-to-execute alg that is *very* close to your description.
> ...


 
Well, if you ignore the last 2 half turn moves, it is a 23q. And, on the 4X4X4 and all other even cubes (by which all complimentary slices are turned).


----------



## Stefan (Jan 3, 2010)

cmowla said:


> Well, if you ignore the last 2 half turn moves, it is a 23q.


Similarly, several 19q have been posted.



cmowla said:


> And, on the 4X4X4 and all other even cubes (by which all complimentary slices are turned), this alg is solely an *odd permutation fix *(not double parity).


False.



cmowla said:


> As far as I know, 25q is the shortest non-pure (solely OLL) alg out there.


Poor memory?
http://www.speedsolving.com/forum/showthread.php?p=239862#post239862


----------



## Christopher Mowla (Jan 3, 2010)

StefanPochmann said:


> cmowla said:
> 
> 
> > And, on the 4X4X4 and all other even cubes (by which all complimentary slices are turned), this alg is solely an *odd permutation fix *(not double parity).
> ...


What are you talking about???? It is not a double parity fix on the 4X4X4 or on even cubes!



cmowla said:


> As far as I know, 25q is the shortest non-pure (solely OLL) alg out there.


Poor memory?
http://www.speedsolving.com/forum/showthread.php?p=239862#post239862[/quote]
Those are double parity manipulations, man.

I said, "solely an odd permutation fix", not a double parity fix. If you perform the algorithm like I have it, this should be a problem.


----------



## Christopher Mowla (Jan 3, 2010)

StefanPochmann said:


> cmowla said:
> 
> 
> > And, on the 4X4X4 and all other even cubes (by which all complimentary slices are turned), this alg is solely an *odd permutation fix *(not double parity).
> ...


What are you talking about???? It is not a double parity fix on the 4X4X4 or on even cubes (assuming that you turn all symmetrical slices).



StefanPochmann said:


> cmowla said:
> 
> 
> > As far as I know, 25q is the shortest non-pure (solely OLL) alg out there.
> ...


 
Those are double parity manipulations, man.

I said, "solely an odd permutation fix", not a double parity fix. If you perform the algorithm like I have it, this should *not *be a problem.


----------



## Lucas Garron (Jan 3, 2010)

cmowla, this is a 25q, 16b alg that does exactly the same as yours:

l' D2 l B2 r' U2 l F2 l' B2 D2 r' D2 r (F2 D2)

Without the last two moves, it's 21q, 14b. (Does _that_ contradict you yet?)

However, I know an alg that does this all in even fewer moves, except it even _fully preserves F2L_ when you're done.

I appreciate your effort, and that you're trying to do things by hand, but, plainly, you're failing.

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*.


----------



## masterofthebass (Jan 3, 2010)

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*.



well... its not like I used it FOR my world record


----------



## Christopher Mowla (Jan 3, 2010)

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*.


 
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).


----------



## masterofthebass (Jan 3, 2010)

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*.
> ...




personally, as a decent speedcuber, I can't stand a single one of "your" algorithms. I mean, I find absolutely none of them to be speedsolveable at all.

Also, I don't know what you are smoking because

x (Rr) U2 (Rr) U2 (Rr)2 U2 (Rr) F2 x' (Ll) U2 (Ll)' U2 (Rr)' U2 (Rr) B2 D2

is a double parity fix on any cube. Not only is it horrific to execute, but it requires a fix of the F2L as well, which is absolutely pointless for speedsolving.


----------



## joey (Jan 3, 2010)

Lucas went to the trouble of finding them, wether he used a computer or not, I would still call them his; since he was the first to post them etc.

No-one really cares wether a computer is used or not, I think you need to get over that. I do find it impressive that you're not using a computer.. but I wont use them just becasue of that!

ps your alg is double parity.. I'm confused why you're saying it isn't.


----------



## Christopher Mowla (Jan 3, 2010)

joey said:


> ps your alg is double parity.. I'm confused why you're saying it isn't.


Just look at the picture of the 4X4X4 I posted. There are 4 composite edges (besides the flipped edge) that are affected. Those 4 can be solved back with a 3X3X3 algorithm, not a 2 2cycle exchange of individual winged edge pieces. That's why. On the 5X5X5 (and all other odd cubes), it is double parity, but not on the 4X4X4 on bigger even cubes which you treat like a 4X4X4.


----------



## masterofthebass (Jan 3, 2010)

Also, I don't know why cmowla thinks his alg is the best, as the "standard" double parity alg is 28 BQTM without messing up f2l. And, its 100x better to execute.


----------



## masterofthebass (Jan 3, 2010)

cmowla said:


> joey said:
> 
> 
> > ps your alg is double parity.. I'm confused why you're saying it isn't.
> ...



But you are ignoring the fact that your algorithm switches 2 corners as well, which leaves a PLL parity situation for speedsolving. Also, for speedsolving purposes, you should add the 12 QTM that it would take to fix the f2l that you messed up, making your total algorithm for double parity 39 BQTM.


----------



## joey (Jan 3, 2010)

What dan said basically ^^
I'm not saying give up.. I'm just saying this alg isn't probably going to be used for 4x4 speedsolving.


----------



## Christopher Mowla (Jan 3, 2010)

masterofthebass said:


> x (Rr) U2 (Rr) U2 (Rr)2 U2 (Rr) F2 x' (Ll) U2 (Ll)' U2 (Rr)' U2 (Rr) B2 D2
> 
> is a double parity fix on any cube. Not only is it horrific to execute, but it requires a fix of the F2L as well, which is absolutely pointless for speedsolving.


 
Have you not read the very description of this thread? I wrote this alg to do this *on purpose*. reThinker specially said that one F2L slot should be open for distortion.



joey said:


> What dan said basically ^^
> I'm not saying give up.. I'm just saying this alg isn't probably going to be used for 4x4 speedsolving.


I know. I didn't really claim that it was the best. The reason I posted this alg was mainly for reThinker because he asked me to try my best to find an algorithm that matched his description. That's all. I personally like my pure algs much better than this one, too.


----------



## masterofthebass (Jan 3, 2010)

I don't see how you failing to provide what reThinker asked for is my problem? I'd rather do the alg that preserves f2l and fits reThinker's criteria than the alg that you posted.


----------



## fanwuq (Jan 3, 2010)

(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.


----------



## Christopher Mowla (Jan 3, 2010)

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....


----------



## joey (Jan 3, 2010)

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.


----------



## Lucas Garron (Jan 3, 2010)

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.


----------



## Lucas Garron (Jan 3, 2010)

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.


----------



## Christopher Mowla (Jan 9, 2010)

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?


 
, 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?)


----------



## Christopher Mowla (Jan 9, 2010)

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._


----------



## Stefan (Jan 9, 2010)

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.


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.*


----------



## fanwuq (Jan 9, 2010)

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.


----------



## Hyprul 9-ty2 (Jan 9, 2010)

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


----------



## fanwuq (Jan 9, 2010)

Hyprul 9-ty2 said:


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



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.


----------



## Christopher Mowla (Jan 9, 2010)

StefanPochmann said:


> cmowla said:
> 
> 
> > though, again, it is *not briefer in moves*
> ...


 
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).


----------



## Christopher Mowla (Jan 9, 2010)

cmowla said:


> StefanPochmann said:
> 
> 
> > cmowla said:
> ...


 


fanwuq said:


> Hyprul 9-ty2 said:
> 
> 
> > It does work, flips one edge, but screwing up 1 F2L slot and a cross piece
> ...


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.


----------



## Stefan (Jan 9, 2010)

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.


Proof?


----------



## Christopher Mowla (Jan 9, 2010)

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.


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.
> ...


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".


How an alg that reThinker wants would look like
(if it could exist and be 19q, which is equal to my 19q pure edge flip and the less than the 21q pure double parity algs)​ 
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.


----------



## Christopher Mowla (Jan 9, 2010)

fanwuq said:


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


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).


----------



## fanwuq (Jan 10, 2010)

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


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.


----------



## reThinking the Cube (Jan 10, 2010)

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)


----------



## Kenneth (Jan 10, 2010)

StefanPochmann said:


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



Many think a x cycle are x pieces.


----------



## Kenneth (Jan 10, 2010)

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*.
> ...



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).


----------



## Stefan (Jan 10, 2010)

Kenneth said:


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


Is that supposed to scramble the cube?
=> http://alg.garron.us/


----------



## deadalnix (Jan 10, 2010)

Kenneth said:


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



???????

EDIT : F2 Lw2 F2 U2 Lw' U2 Lw U2 Lw2 F2 Rw' U2 Lw U2 Lw'


----------



## Kenneth (Jan 10, 2010)

deadalnix said:


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



Thank's, don't now what happen there 

I showed Joey in the Swedish #rubik at the Quakenet just a while ago, after he saw my earlier post.

[15:47] <+j`ey> Kenta: parity in a commutator?
[15:48] <Kenta> yes
[15:48] <+j`ey> show it?
[15:48] <SimonWestlund> -7 here
[15:48] <Kenta> with little setup add on
[15:48] <+j`ey> conjugated commutator
[15:48] <+j`ey> (like a A perm!)
[15:48] <Kenta> you can commutate a "J-PLL" in the second layer
[15:49] <+j`ey> hm
[15:49] <+j`ey> can you write it out?
[15:49] <+j`ey> (i know that's how lucasparity is done
[15:49] <Kenta> then it is just a few more turns to get double parity
[15:49] <+j`ey> it's 1C here
[15:49] <Kenta> sure, but it takes some time
[15:51] <Kenta> for "J-PLL" : B2 sets up a triple of two centres and one edge at B side, r slice, edge in D
[15:51] <Kenta> a second triple is from start at the F side l slice, edge in D
[15:52] <Kenta> so you do Dww2 to swap
[15:52] <Kenta> three bottom layers
[15:52] <Kenta> then you shift the triple that nos is on B for one in U using r' U2 r
[15:52] <Kenta> now*
[15:53] <Kenta> then another Dww
[15:53] <Kenta> and restore
[15:54] <Kenta> the whole alg for that will be : B2 Dww2 r' U2 r Dww2 r' U2 r B2 ... done
[15:54] <Kenta> now you got a J in the l slice
[15:54] <Kenta> easy to understand
[15:55] <Kenta> then if you work with diffrent setups and resoration, before, afer or even within the alg you can solve most cases of two swapped edges
[15:56] <Kenta> Double parity is the case that is nearest the turns in the basic commutator so I write that one too..
[15:56] <+j`ey> hm
[15:57] <+j`ey> following so far 
[15:58] <+j`ey> i gotta go now, but i will read back when i get home
[15:58] <Kenta> (x') B2 Dww2 r' U2 r Dww2 r' U2 r B2 (x) l' U2 l' U2 l
[15:59] <+j`ey> but but
[15:59] <Kenta> there it is
[15:59] <+j`ey> nice
[15:59] <Kenta> 
[15:59] <+j`ey> not a pure comm tho 
[15:59] <Kenta> no, it needs a litte more
[15:59] <+j`ey> hm
[16:00] <Kenta> that's the 5 turns in the end
[16:00] <+j`ey> that messed up my centres :S
[16:00] <Kenta> hehe
[16:00] <Kenta> you must hve done wrong ot I wrote it wrong
[16:00] <Kenta> I check it...
[16:01] <+j`ey> it does a 3cycle of centres :S
[16:01] <Kenta> not for me
[16:01] <Kenta> ??
[16:02] <Kenta> it works fine here
[16:02] <Kenta> did you performe the x's
[16:03] <Kenta> Works for me but... I'm a confused person, sometimes I'm sure I did all right but I did not 
[16:04] <Kenta> Anyone else who can test it to check?
[16:05] <KConny> j`ey You will like this: http://www.youtube.com/watch?v=UHH_5EClbAU&feature=related
[16:06] <KConny> An old swedish comedy show.
[16:06] <GunnarKrig> KConny: haha 
[16:06] <+j`ey> 14:07:35 <Swordsman_Kirby> [09:06:21]["T. Sun"] Are you going to school anytime this week?
[16:06] <+j`ey> oops
[16:06] <+j`ey> KConny: can you check this
[16:06] <+j`ey> 14:59:02 < Kenta> (x') B2 Dww2 r' U2 r Dww2 r' U2 r B2 (x) l' U2 l' U2 l
[16:06] <Kenta> wrong channel ^^
[16:07] <KConny> Don't have a cube here. 
[16:07] <+j`ey> O_O
[16:07] <+j`ey> ill use alg.garron.us
[16:07] <KConny> "Vem fan är Selma Lagerlöf"
[16:07] <GunnarKrig> ;D
[16:08] <Kenta> Remember Dww are 3 layers, not 2
[16:08] <KConny> Så jävla grym hon brunetten är.
[16:08] <+j`ey> oh
[16:08] <+j`ey> KConny: i see
[16:08] <+j`ey> erm
[16:08] <Kenta> you can write it diffrenty and use U2 but it is not that pedagogic then
[16:08] <+j`ey> Kenta: i eee
[16:08] <KConny> "Kan de ha varit så att hon hade en del vänner"
[16:08] <GunnarKrig> "Ska inte du komma med en hypotes nu också??"
[16:08] <Kenta> it makes it hardet too see what's happening
[16:09] <KConny> Hahaha
[16:10] <+j`ey> Kenta: it works
[16:10] <GunnarKrig> KConny: jag älskar Herman Lindqvist-parodierna
[16:10] <Kenta> nice 

Why on earth a J in the second layer you may ask... I read at Akimotos page back in 2006 that you need to swap blocks of centres togehter with the edges to make it possible to solve a parity. So I tried a few diffrent commutators that did exactly that and soon found this, that is useful for all cases of two swapped edges from two opposite deges in the last layer (if you use diffrent setups).


----------



## Stefan (Jan 10, 2010)

deadalnix said:


> EDIT : F2 Lw2 F2 U2 Lw' U2 Lw U2 Lw2 F2 Rw' U2 Lw U2 Lw'


Is that supposed to scramble the cube?
=> http://alg.garron.us/


----------



## Kenneth (Jan 10, 2010)

StefanPochmann said:


> deadalnix said:
> 
> 
> > EDIT : F2 Lw2 F2 U2 Lw' U2 Lw U2 Lw2 F2 Rw' U2 Lw U2 Lw'
> ...



Man!, I try again 

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

Tried it three times and it worked fine so I hope it does not scramble your cube anymore


----------



## deadalnix (Jan 10, 2010)

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

Why do you put R move in it ? (I use the reverse one and mirrored to get R insted of L).


----------



## Kenneth (Jan 10, 2010)

deadalnix said:


> F2 Lw2 F2 U2 Lw' U2 Lw U2 Lw2 F2 Lw' U2 Lw U2 Lw'
> 
> Why do you put R move in it ? (I use the reverse one and mirrored to get R insted of L).



Yes yes, you can do it in several ways, that was just the basic turns that are easy to see. For fast execution you will of course do it a bit diffrently, like x - x' between the U and F turns so they all become U2's

This is the forum about why we turn, not how we turn 

Edit: the answer to your question is for real that I don't use it like that, I do direct solving and this is a case in my wery last ELL step so I use it with single slices to preserve corners, your version does not work then.


----------



## Christopher Mowla (Jan 10, 2010)

Kenneth said:


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


I actually think I have been having too much "luck" to be "lucky" anymore. Yes, the first turns in the algs I have given out so far were tests...tests to set up a certain scenario that I wanted. Once I got that scenario, I finished it. (Hence, yes, I definitely know what I am doing). Have you seen my 21q odd permutation break (*not double parity*)? (It is not pure, but it reduces a 4X4X4 with odd parity to a 3X3X3 cube).

r U2 r' U2 r D2 r D2 r' F L' F' U' r' D2 r
If, instead you do it with single r slice turns followed by the following moves: D2 U F L F' , it restores the cube significantly.


In addition I have found several brief pure double parity algs without computers as well as finding, if you having heard the news, a 19 BQTM pure edge flip alg for the 4X4X4. (And, based on how that alg looks, it is more likely, in my opinion, that I win the lottery, than to test some moves to find that one because the entire cube is scrambled immensely during the alg...and then solved back in very few moves--using many different slices).
================================================
reThinker,

I have revised my technique to not mess up the back bottom cross-edge and still keep the move count the same:

I found a *30q* alg that uses the front-left F2L slot and U-layer
z2
r U2 l U2 r'
F R F' U l' F2 l
U B2 l B2 l'
U2 F' R' F D' F2
z2

I have also found a *29q* alg that uses the front-right F2L slot, induces double parity, and leaves the U layer free.
x' r U2 l U2 r' F R F' U x l' U2 l U2 x' E2 x l' U2 l U2 F2 x' U L' x' y2
But adding R U R' U' makes a pure double parity….:fp

This was actually a common occurence when I was trying to find algs that use the U layer and 1 F2L slot.

For example, here is a 27 BQTM regular pure double parity that I stumbled on trying to find an alg that uses the F2L layer and U layer:
r U2 l U2 r' F R F' U l' F2 l F2 E2 y2 l' D2 l U F R' F'

Here's a weird pure double parity:
r U2 l U2 r' F2 l' F2 l F' R F' U l' F2 l B2 l B2 l' F2 U' F R' F

And here is another weird pure double parity fix:
 r U2 l U2 r' F R F' U l' F2 l U B2 l B2 l' U' F2 U' F R' F'

_The 4 algorithms which I have just given above could suggest that double parity algorithms that use a F2L slot are very related to pure double parities, for I used the same method and found several pure double parities (as you have seen). If, in the future, someone comes up with a "proper proof" for this, then, I would say that the alg you really seek is brief pure double parity algs._

Here's another weird pure double parity: (23q)
r U2 r' F2 l' B2 l B2 l' D2 l D2 l' F2 U2

And, as far as me getting lower move algs (less than 29q) that kind of meets your description, here's a *28q* that uses the back two F2L slots and the U layer:
x2 r U2 l U2 r' F R F' U l' F2 l U B2 l B2 l' U' F2 U' R' F' x2

And, for your possible interest, here's a non-pure *19q* double parity. I didn't find it by "chance", as far as the last 12 moves are concerned. The first 7 moves provided a good set-up for a brief double parity...I sensed this and finished it (I was going to finish it at first because it wasn't a case that needed to use a F2L slot--it appears that all 19q double parity algs don't need to use a F2L slot--I finished it for fun).
r U2 r' U2 r' D2 r D2 r' B2 l U2 l'

Edit:
Here is a 21q, edge flip alg. It flips the front-bottom edge, but it does not preseve the front and bottom centers. It could be useful for solving supercubes or using the cage method:
r U2 l' U2 r' x2 l' U2 r' U2 r l U2 l' U2 l x2

_Note: I found all of these algs in the last 2 days (as well as the other ones I have posted recently).

Date: 1/10/10
_


----------



## fanwuq (Jan 10, 2010)

cmowla said:


> I have also found a *29q* alg that uses the front-right F2L slot, induces double parity, and leaves the U layer free.
> x' r U2 l U2 r' F R F' U x l' U2 l U2 x' E2 x l' U2 l U2 F2 x' U L' x' y2
> But adding R U R' U' makes a pure double parity….:fp
> 
> ...


I noticed that you are just inserting F R F' U in the middle of the algs to replace one paired up dedge with another paired up edge that is part of the F2L while flipping another dedge in the M-ring. Then you undo the F R F' U at the end of the alg to restore the cube.
If you take out the quarter moves in the middle of your first alg, it reduces to
x' r U2 l U2 r' x l' U2 l U2 x' E2 x l' U2 l 
So you are not really using the quarter turns to induce parity, you are just using them to convert another parity alg to the dedge flip form. This can be done more efficiently without involving a F2L dedge.

r U2 l' U2 r' x2 l' U2 r' U2 r l U2 l' U2 l x2 looks very cool!
http://alg.garron.us/?alg=r_U2_l-_U...U2_r_l_U2_l-_U2_l_x2
&cube=4x4x4&notation=WCA


----------



## Christopher Mowla (Jan 10, 2010)

fanwuq said:


> I noticed that you are just inserting F R F' U in the middle of the algs to replace one paired up dedge with another paired up edge that is part of the F2L while flipping another dedge in the M-ring. Then you undo the F R F' U at the end of the alg to restore the cube.
> If you take out the quarter moves in the middle of your first alg, it reduces to
> x' r U2 l U2 r' x l' U2 l U2 x' E2 x l' U2 l
> So you are not really using the quarter turns to induce parity, you are just using them to convert another parity alg to the dedge flip form. This can be done more efficiently without involving a F2L dedge.


Well, I understand why you would think so due to the appearance of preliminary moves and reverse of those preliminary moves. However, I *do* use those moves to set up the cube for parity fix. I undo them later to restore the cube back to a reasonable state (and, I was careful what I did after those outer-layer quarter turns, so that, when I reversed them, they worked positively for restoring the cube). And by doing this, I managed to leave one F2L slot unsolved (and the U layer).

As a matter of fact, I used a very similar technique for the 21q non-pure OLL parity alg (not double parity) which I have listed in this thread and in my thread:
r U2 r' U2 r D2 r D2 r' F L' F' U' r' D2 r
_This alg is two 4 cycles and a 2 cycle, thus yielding just an OLL parity fix._

That should definitely proove to you that I *do* use the quarter turns to induce parity. The first moves in the alg above prepare for only an OLL parity fix, while the first moves in the alg for rethinker is for double parity.




fanwuq said:


> r U2 l' U2 r' x2 l' U2 r' U2 r l U2 l' U2 l x2 looks very cool!


Thanks. I am glad you like it.


----------



## reThinking the Cube (Jan 11, 2010)

cmowla said:


> Have you seen my 21q odd permutation break (*not double parity*)? (It is not pure, but it reduces a 4X4X4 with odd parity to a 3X3X3 cube).
> 
> (Rr) U2 (Rr)' U2 (Rr) D2 (Rr) D2 (Rr)' F L' F' U' (Rr)' D2 (Rr)
> If, instead you do it with single r slice turns followed by the following moves: D2 U F L F' , it restores the cube significantly.




Yep. I appreciate the effort, but isn't this more about proving to everyone that _YOU _can actually find/create some algs without using a computer. To _ME _- any algorithm that unsolves what has already been solved is just an ANTI-ALGORITHM. This means anything that unpairs dedges, undoes the cross, tampers with any part of a previously solved F2L pair, or unsolves any of the centers. I am really not seeking algs that do any of that. I don't think that there will be a practical use for these types of anti-algorithms any time soon.



cmowla said:


> _The 4 algorithms which I have just given above could suggest that double parity algorithms that use a F2L slot are very related to pure double parities, for I used the same method and found several pure double parities (as you have seen). If, in the future, someone comes up with a "proper proof" for this, then, I would say that the alg you really seek is brief pure double parity algs._




For right now, here is MY newest and best algorithm for OLL/PLL parity:

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

Notation is SiGN, but "r" can be done as single slice and then U2 2s2 can be taken out. You do the math.

If you _REALLY_ want to provide me with what I really seek, then see if you can find a "better" alg than this.


----------



## reThinking the Cube (Jan 11, 2010)

reThinking the Cube said:


> [For right now, here is MY newest and best algorithm for OLL/PLL parity:
> 
> *DoubleTrouble™ - (r U2 r' U2 r' D2 r D2) x' (r' U2 r U2 r' U2) 2s2 *
> 
> ...




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

Here is the inner slice version:2R U2 2R' U2 2R' D2 2R D2 x' 2R' U2 2R U2 2R' 

Inner slice version: You will see if you look at this carefully, that it is not (as it appears) just a simple 4-cycle dedge commutator, but really is an 8-cycle of edges (odd OLL permutation), that remakes the M-slice dedges as a 4-cycle of dedges (odd PLL permutation).


----------



## rachmaninovian (Jan 11, 2010)

r U2 l' U2 r' x2 l' U2 r' U2 r l U2 l' U2 l x2 indeed is useful for me 

can you possibly find even better cage parities?


----------



## Lucas Garron (Jan 11, 2010)

reThinking the Cube said:


> until somebody can tell me the best way to do linking


1. Click the textarea on the upper right. The whole field should select.
2. Copy.
3. Paste into post.


----------



## reThinking the Cube (Jan 11, 2010)

Lucas Garron said:


> reThinking the Cube said:
> 
> 
> > until somebody can tell me the best way to do linking
> ...



Thanks Lucas. I fixed it. That page is sweet.


----------



## Christopher Mowla (Jan 11, 2010)

reThinking the Cube said:


> If you _REALLY_ want to provide me with what I really seek, then see if you can find a "better" alg than this.
> 
> *DoubleTrouble™ - (r U2 r' U2 r' D2 r D2) x' (r' U2 r U2 r' U2) 2s2 *


 
How about this alg (21q instead of 23q): This is in SiGN notation too (so you can copy and paste to Lucas' site).

 (r U2 r' U2) x' (r U2 r' U2) x2 (r U2 r U2 l') 2s2

It is 21q (as opposed to 23q) only because I don't need to rotate the U Layer Twice at the end (which takes advantage of a "free" LL, just as you like).

It is very similar to yours (however you got it). It just "flips" the back top edge instead of the top-front edge.

I am no expert at memorization or speed, but it appears to me that my alg is easier to memorize and faster to execute than your "DoubleTrouble". I hope you like it (if so, then, none of my research was in vain...I found this 19q double parity fixer in the process of looking for the algs that you thought were ANTI-Algorithms).

I hope you like it...let me know what you think.


----------



## Kenneth (Jan 11, 2010)

cmowla said:


> I actually think I have been having too much "luck" to be "lucky" anymore. Yes, the first turns in the algs I have given out so far were tests...tests to set up a certain scenario that I wanted. Once I got that scenario, I finished it. (Hence, yes, I definitely know what I am doing). Have you seen my 21q odd permutation break (*not double parity*)? (It is not pure, but it reduces a 4X4X4 with odd parity to a 3X3X3 cube).
> 
> (Rr) U2 (Rr)' U2 (Rr) D2 (Rr) D2 (Rr)' F L' F' U' (Rr)' D2 (Rr)
> If, instead you do it with single r slice turns followed by the following moves: D2 U F L F' , it restores the cube significantly.



LOL, who would use something like that??? to me it is a scramble 

And it is not smooth execution eiter... most, not to say all cubers prefer smoothness instead of one or two q-turns lesser. No one need your algs I'm afraid.


----------



## Christopher Mowla (Jan 11, 2010)

Kenneth said:


> LOL, who would use something like that??? to me it is a scramble
> 
> And it is not smooth execution eit[*h]*er... most, not to say all cubers prefer smoothness instead of one or two q-turns lesser. No one need your algs I'm afraid.


What don't you understand about not bringing tension? This is not healthy for the community. I never said that my alg for that case is good for speedsolving. 

This *is* the theory section of this site. Obviously you do not like me because you consistently write in language that is very sarcastic (and I don’t see any reason for you to do so, especially since I made it clear to you before that I don’t want to fight anymore, anywhere). Whether an alg is fast or not, it is still an alg. Just because I didn’t find a fast alg to solely break OLL parity doesn’t mean anything…I found a 21q that is interesting.

Yes it does scramble the cube. I never said it preserved anything (except for the centers and edges). In fact, I think I made it very clear what is does and does not do (maybe you should read my entire post and not just the algorithms I post).

And I think the alg I just posted for reThinker is pretty good for speedsolving...


----------



## reThinking the Cube (Jan 11, 2010)

cmowla said:


> reThinking the Cube said:
> 
> 
> > If you _REALLY_ want to provide me with what I really seek, then see if you can find a "better" alg than this.
> ...




"Just as you _LIKE_"? LL unsolved just provides an added degree of freedom. I would actually prefer less change, but usually that restriction produces longer/messier algs. To be kind towards finding something, YES, I am recommending that you _take advantage _ of LL freedom. But here you just take my alg, reorder it, and then "take advantage" of not having to technically restore LL, by leaving out "U2" at the end, and claim a much better alg. Of course, I could have done the same thing, but then the finished position wouldn't have been as recognizably useful. But to be fair, I have to admit that you "_CAN_" leave out the LL fixing move "U2", and applause........save 2q. Even though it is technically correct, the resultant location of the flipped edge at UB is not practical for me, and would result in an added cube rotation. So the artificial gain of 2q is also mute for that reason. Here is a link to see it, with the finishing move "U2" added.

r U2 r' U2 x' r U2 r' U2 x2 r U2 r U2 l' 2s2 U2 

Here is what it would look like with just inner slice turns:

2R U2 2R' U2 x' 2R U2 2R' U2 x2 2R U2 2R U2 2L' 2s2 U2 

Compare this to:

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

and the inner slice version:2R U2 2R' U2 2R' D2 2R D2 x' 2R' U2 2R U2 2R' 




cmowla said:


> it is very similar to yours (however you got it). It just "flips" the back top edge instead of the top-front edge.



FYI - I came up with it in my head, and no computer was used for this one. I cannot promise the same for some others I might come up with. 



cmowla said:


> I am no expert at memorization or speed, but it appears to me that my alg is easier to memorize and faster to execute than your "DoubleTrouble". I hope you like it (if so, then, none of my research was in vain...I found this 19q double parity fixer in the process of looking for the algs that you thought were ANTI-Algorithms).
> 
> I hope you like it...let me know what you think.



Because it is very similar to DoubleTrouble™, it is IMO - relatively easy to memorize and relatively fast to execute. I do like it, but I personally don't think it is any _EASIER _to memorize, or any _FASTER_ to execute. The beginning is nice, but the extra x2 rotation does not fully compensate for that, and the ending is also not as symmetrical as the original. Placing the flipped dedge at UB would also require (at least for me) some extra cube rotations or face turns. 

Failing to restore LL for no other reason than to gain 2q, shows that you are very resourceful, and want to be proven right at all times, even when YOU think that you are wrong. 

Your research in definitely not in vain, and the DoubleTrouble™ parity alg, proves it.


----------



## Kenneth (Jan 11, 2010)

cmowla said:


> What don't you understand about not bringing tension? This is not healthy for the community. I never said that my alg for that case is good for speedsolving.
> 
> This is the theory section of this site. Obviously you do not like me because you consistently write in language that is very sarcastic (and I don’t see any reason for you to do so, especially since I made it clear to you before that I don’t want to fight anymore, anywhere). Whether an alg is fast or not, it is still an alg. Just because I didn’t find a fast alg to solely break OLL parity doesn’t mean anything…I found a 21q that is interesting.



I'm not trying to be sarcastic at all, I'm just trying to tell you that what you do is not useful to anybody, your work is for nothing and obviously you cannot see it yourself. You don't even prove anything because you cannot go throu all combinations to see if there is a shorter or better alg. The only way to do that is to brute force using computers but that is not possible either because of too many combinations.
....

An alg that fixes parity that scrambles that much is only useful if you look for parity before you start the 3x3x3 part of the solve and that takes eons, much longer than it takes to execute a whole bunch of algs.

Maybe for FMC but that is always counted in half turns...

So, if you find the 14 turn alg, then gratz because that would be a gain. 14 is the optimal alg for the same case of 3x3x3 corners so shorter than that is not possible, cube explorer proves that the brute force way. I will even give you "all" optimal algs so you got something to start from but I don't think you can get any of them (it's the same, just mirrors and inverses) to do the job without messing centres:

Searching depth 14

R2 F2 R F2 U L' U L U' R U R' U' R (14f*) //order 2
R' U R U' R' U L' U' L U' F2 R' F2 R2 (14f*) //order 2
L U' L' U L U' R U R' U F2 L F2 L2 (14f*) //order 2
L2 F2 L' F2 U' R U' R' U L' U' L U L' (14f*) //order 2

Searching depth 15


----------



## Christopher Mowla (Jan 11, 2010)

Kenneth,

What particular case are you saying that can be theoretically done in 14f? Is it pure? If so, is it doubleparity, only OLL parity, or could be either?

reThinker,
Well, you can take out the "x2" rotation and have turns about D, (just like your "DoubleTrouble" has. But if you don't like it,well...


----------



## Kenneth (Jan 11, 2010)

It is only OLL parity, the double looks much the same but is diffrent, like if you add a H-PLL on the 3x3x3 corner case.

It has got more solutions in 14 turns also:

Searching depth 14

U R2 B2 D' L F2 L' D B2 R2 U R' U R (14f*)
U F U F' U F2 L2 D B' R2 B D' L2 F2 (14f*)
U' F' U' F U' F2 R2 D' B L2 B' D R2 F2 (14f*)
U' L2 B2 D R' F2 R D' B2 L2 U' L U' L' (14f*)
R U R' U R2 F2 D L' B2 L D' F2 R2 U (14f*)
R U2 R' U2 F2 L' F' L F' D2 B R' B' D2 (14f*)
R U2 R' U2 D2 B R B' D2 F L' F L F2 (14f*)
F L F' D2 B R' B R B2 U2 L U2 L' D2 (14f*)
F' R' F D2 B' L B' L' B2 U2 R' U2 R D2 (14f*)
D2 R U2 R' U2 F2 L' F' L F' D2 B R' B' (14f*)
D2 F L F' D2 B R' B R B2 U2 L U2 L' (14f*)
D2 F' R' F D2 B' L B' L' B2 U2 R' U2 R (14f*)
D2 L' U2 L U2 F2 R F R' F D2 B' L B (14f*)
L' U2 L U2 F2 R F R' F D2 B' L B D2 (14f*)
L' U2 L U2 D2 B' L' B D2 F' R F' R' F2 (14f*)
L' U' L U' L2 F2 D' R B2 R' D F2 L2 U' (14f*)
B2 R2 D F' L2 F D' R2 B2 U' B U' B' U' (14f*)
B2 R' B' R B' D2 F L' F' U2 D2 L U2 L' (14f*)
B2 L B L' B D2 F' R F U2 D2 R' U2 R (14f*)
B2 L2 D' F R2 F' D L2 B2 U B' U B U (14f*)
Searching depth 15


----------



## Stefan (Jan 11, 2010)

I have completely lost the overview. Could you guys create a page in the wiki listing the lengths of the shortest known algorithms along with one example algorithm each? I see three dimensions:

- Which parity (orientation, permutation, both)
- Which freedom (pure, LL, LL-oneF2Lslot, justKeepCentersAndDedgesIntact)
- Which metric (WCAqtm, WCAhtm, SiGNqtm, SiGNhtm)

These are just my suggestions, particularly the metric names, although I do believe they make it both clear and easy to count/check.


----------



## Christopher Mowla (Jan 11, 2010)

I am sorry to ask again, but I am assuming you mean a 14f pure OLL alg, right?

Thanks for the 3X3X3 algs.


----------



## Kenneth (Jan 11, 2010)

Na, that are the same cases as the big cube paritys, the cases we setup when we look for algs for them using computers but restricting to turns that don't destroy edges on the big ones like the 14 turn algs does. The shortest in that group are 15 turns.

And for 3x3x3 that are not OLL's but ZBLL algs... or it is what I use them for on that cube (but the 15 turn versions I also use for big cubes).

Edit: look at the corners as the where wing edges on a 5x5x5, then it is pretty clear it's the same.


----------



## reThinking the Cube (Jan 13, 2010)

StefanPochmann said:


> I have completely lost the overview. Could you guys create a page in the wiki listing the lengths of the shortest known algorithms along with one example algorithm each? I see three dimensions:
> 
> - Which parity (orientation, permutation, both)
> - Which freedom (pure, LL, LL-oneF2Lslot, justKeepCentersAndDedgesIntact)
> ...




Good suggestions. If I had a little more time, the wiki listing would already be there. It's a to-do that needs to get done. I would like to add though, that my main interest in parity algs, is more practical , and not overly obsessed with the arbitrary metric lengths of the algs. I am much more concerned about how easy they are to learn, and how fast they can be executed. So adding the dimensions (merits) of symmetry, and speed would be useful. The freedom dimensions you gave, should allow for the categorization of algs for use with different solving methods.

Stefan: maybe you (or someone else so qualified) could get it started - setting up the proper format so that the different parity algs can be categorized and compared, and then the rest will follow.


----------



## reThinking the Cube (Jan 15, 2010)

I took DoubleTrouble™ - r U2 r' U2 r' D2 r D2 x' r' U2 r U2 r' U2 2s2 

and reworked it (backwards+rotated) to see if I could make it easier to speed turn. I also wanted to tailor it to my solve method, which prefers the flipped dedge to start out at FR rather than FU.

The result: *DoubleXTrouble™ R2' u' R2 u R2' u' y R2 u R2' u' y2 R2 u' R2' u m2 *

The whole sequence flows really well. Very fast and easy to learn. Though Eastsheen™ cubes are not optimal - sometimes locking/catching up on (u,u') triggers. For cubes like that, the original alg (DoubleTrouble™) works better.

Suggestion: start out grip with left thumb spanning all 6 pieces lower left (DFL-rd), and LH middle/ring holding the 6 pieces on DB, so cube is pinched in the left hand without interfering with (Uu) turns. Right thumb loosely on (uRF-dRF). Turn R2', and use RHmiddle finger at an angle to do the "u'", then R2, followed by using the RH index trigger for the "u", then R2' and RHmiddle "u'". So that is (R2' u' R2 u R2' u'). Do the whole alg like that - with flip-flop triggering. I settled on the [y2] rotation as the best compromise for the last part, but it is ok since the RH thumb can get into position for the last sequence (R2 u' R2' u) and then the "m2" can be done without adding another cube rotation. Maybe an even better way to finish this without the regrip [y2] is: R2' u' R2 u R2' u' y R2 u R2' u' 3r2 d' 3r2' u m2  
For this variation the last "u" is done by pushing with the LHthumb. Smokin'. 

Notation is SiGN.


----------



## reThinking the Cube (Jan 15, 2010)

I was playing around with the starting sequence (r U2 l' U2) which turns even faster for me than (r U2 r' U2). Also (r' B2 l B2) = x' (r' U2 l U2) another fast turner. After some thinkin' , and keeping with the 8-cycle of edges idea, I came up with this:

reParity™ - r U2 l' U2 x' r' U2 l U2 r' U2 l U2 l' U2 y' 2m2 y' 

It's gonna be real hard to improve on this one.

EDIT: reParity™ - "(re)THINKER's (re)VENGE Parity Algorithm."


----------



## deadalnix (Jan 19, 2010)

These trademark signs become ridiculus xD

Can I see regstration paper or are you just kiddies playing grown up persons ?


----------



## masterofthebass (Jan 19, 2010)

If you look, its only the two people who make this thread pointless in the first place. Normal people aren't that stupid.


----------



## blade740 (Jan 19, 2010)

I'd like to point out that Lars Petrus has done that for years:
http://lar5.com/cube/fas6.html


----------



## deadalnix (Jan 19, 2010)

It's not because someone do something the wrong way that everybody has to do the same.

And the trademark is just the « extra » sign that make the speach perfect.


----------



## qqwref (Jan 19, 2010)

I'd like to point out that quite a few of Lars's names have become standard terminology


----------



## reThinking the Cube (Jan 19, 2010)

masterofthebass said:


> If you look, its only the two people who make this thread pointless in the first place. Normal people aren't that stupid.



How is this thread pointless? 

The new (non-pure)parity algs that I have found, and then shared with this forum, IMO - are both easier to learn, and faster to execute than all others. I think it is quite amusing, that the so-called experts, have not picked up on this yet. FYI - I am not cmowla, and neither are you.


----------



## masterofthebass (Jan 19, 2010)

If you haven't noticed, there's plenty of "experts" who have posted in this thread, and they all agree the algs you think are good are crap (myself included. I do have the 4x4 single WR). Nothing in this entire thread has been useful for speedsolving and really only useful for some fewest moves stuff, which for 4x4 is pretty dumb to do anyway since you wouldn't do a solve with OLL parity anyway.


----------



## reThinking the Cube (Jan 19, 2010)

qqwref said:


> I'd like to point out that quite a few of Lars's names have become standard terminology



That's right. I mentioned earlier in this thread, the naming™ by Petrus, and I also suggested giving names like that to any new algs found. Names for algs are awesome! Somebody should start a thread to get some commonly accepted names for more of them.


----------



## DavidWoner (Jan 19, 2010)

masterofthebass said:


> which for 4x4 is pretty dumb to do anyway since you wouldn't do a solve with OLL parity anyway.



And if you did, you would want HTM optimal non-pure algs, not QTM optimal pure ones.


----------



## reThinking the Cube (Jan 19, 2010)

masterofthebass said:


> If you haven't noticed, there's plenty of "experts" who have posted in this thread, and they all agree the algs you think are good are crap (myself included. I do have the 4x4 single WR). Nothing in this entire thread has been useful for speedsolving and really only useful for some fewest moves stuff, which for 4x4 is pretty dumb to do anyway since you wouldn't do a solve with OLL parity anyway.



reParity™ - r U2 l' U2 x' r' U2 l U2 r' U2 l U2 l' U2 y' 2m2 y' 

I don't care about fewest moves. I think you have been getting me confused with someone else. Actually do this alg, (SiGN) and then tell me your opinion.
I want to give you a chance to redeem yourself.


----------



## deadalnix (Jan 19, 2010)

That's perfectly unusable compared to :

r'U2rU2'r'F2r2U2'rU2'r'U2xU2r2U2' or something similar.


----------



## qqwref (Jan 19, 2010)

reThinking the Cube said:


> I think it is quite amusing, that the so-called experts, have not picked up on this yet. FYI - I am not cmowla, and neither are you.



I think it is quite amusing that you feel you are an expert when people who are far faster/smarter than you are not 

That said, a few of the algs from this thread seem to be decent enough to be usable for speedsolves, or at least interesting for fewest moves purposes. So, reThinking and cmowla, don't think you are suddenly gods of the cubing world, but I would like to thank you guys for the new algs.


----------



## fanwuq (Jan 19, 2010)

masterofthebass said:


> Nothing in this entire thread has been useful for speedsolving and really only useful for some fewest moves stuff, which for 4x4 is pretty dumb to do anyway since you wouldn't do a solve with OLL parity anyway.



It's not useful for FMC either. It's an interesting idea to think about, but nothing practical came out of it.



qqwref said:


> That said, a few of the algs from this thread seem to be decent enough to be usable for speedsolves, or at least interesting for fewest moves purposes.



Really? New algs or algs that people have been using for years? I don't see any new algs that are better than existing algs for speed.
The idea of having an OLL parity alg for fewest moves is ridiculous. 
1. Almost nobody does 4x4x4 FMC
2. Even fewer do it linearly and count in QTM. (When you don't do it linearly, you can fix parity much earlier.)



reThinking the Cube said:


> reParity™ - r U2 l' U2 x' r' U2 l U2 r' U2 l U2 l' U2 y' 2m2 y'
> 
> I don't care about fewest moves. I think you have been getting me confused with someone else. Actually do this alg, (SiGN) and then tell me your opinion.
> I want to give you a chance to redeem yourself.



reParity™ is not that good; the y' 2m2 y' really messes up the flow of the alg. I don't see you finding any algs, you simply converted the notation of cmowla's algs to make the algs appear more fingertrick friendly. I don't see why you brand algs that you did not find, but that's another issue.

Your alg is much slower than algs that have existed for years. Nobody's going to stop you from using your algs, but you won't be able to persuade anyone to like your algs.


----------



## masterofthebass (Jan 19, 2010)

reThinking the Cube said:


> reParity™ - r U2 l' U2 x' r' U2 l U2 r' U2 l U2 l' U2 y' 2m2 y'
> 
> I don't care about fewest moves. I think you have been getting me confused with someone else. Actually do this alg, (SiGN) and then tell me your opinion.
> I want to give you a chance to redeem yourself.



that alg is the only half decent thing to come out of this thread, and yet it still isn't good. The 2m2 really kills it, or otherwise it would be a somewhat decent alg.


----------



## reThinking the Cube (Jan 19, 2010)

qqwref said:


> reThinking the Cube said:
> 
> 
> > I think it is quite amusing, that the so-called experts, have not picked up on this yet. FYI - I am not cmowla, and neither are you.
> ...



Tag "so-called" was earned by all those that were passing judgement on algorithms that they hadn't really taken the time to look at. A little tongue in cheek, but Michael - "FAR faster/smarter" is a decent enough to be usable smug assumption, and rather condescending too! 

Thanks appreciated.


----------



## reThinking the Cube (Jan 19, 2010)

masterofthebass said:


> reThinking the Cube said:
> 
> 
> > reParity™ - r U2 l' U2 x' r' U2 l U2 r' U2 l U2 l' U2 y' 2m2 y'
> ...



Maybe you need to work on your technique then 

y' is just incorporated in the U2 move as combo (U and (u'd'D')), then the M2 is right there. Fast&Easy. 

lucasparity™ is sweet, but reParity™ is even faster, and it's more symmetrical, easier to learn, and cleaner on LL change - useful for LL setups.


----------



## reThinking the Cube (Jan 19, 2010)

fanwuq said:


> masterofthebass said:
> 
> 
> > Nothing in this entire thread has been useful for speedsolving and really only useful for some fewest moves stuff, which for 4x4 is pretty dumb to do anyway since you wouldn't do a solve with OLL parity anyway.
> ...



Not what I was interested in either.



qqwref said:


> That said, a few of the algs from this thread seem to be decent enough to be usable for speedsolves, or at least interesting for fewest moves purposes.






fanwuq said:


> Really? New algs or algs that people have been using for years? I don't see any new algs that are better than existing algs for speed.
> The idea of having an OLL parity alg for fewest moves is ridiculous.
> 1. Almost nobody does 4x4x4 FMC
> 2. Even fewer do it linearly and count in QTM. (When you don't do it linearly, you can fix parity much earlier.)



I don't care about fewest moves. That is cmowla's fetish. The main reasons I started this thread, was to get the emphasis AWAY from pure-parity fewest moves. 



reThinking the Cube said:


> reParity™ - r U2 l' U2 x' r' U2 l U2 r' U2 l U2 l' U2 y' 2m2 y'
> 
> I don't care about fewest moves. I think you have been getting me confused with someone else. Actually do this alg, (SiGN) and then tell me your opinion.
> I want to give you a chance to redeem yourself.





fanwuq said:


> reParity™ is not that good; the y' 2m2 y' really messes up the flow of the alg. I don't see you finding any algs, you simply converted the notation of cmowla's algs to make the algs appear more fingertrick friendly. I don't see why you brand algs that you did not find, but that's another issue.



How is it that I converted cmowla alg? Total BS. You should PM him yourself, and when he tells you the truth - that he had nothing to do with any of my algs, then have the decency to edit that accusation out of your post. As far as branding lucasparity™ - I did that to give honor to Lucas. Doesn't he deserve that? Even the spelling with lowercase "l" is his way. Giving good names to algs is a good thing. Taking on the ™ just makes it official.



fanwuq said:


> Your alg is much slower than algs that have existed for years. Nobody's going to stop you from using your algs, but you won't be able to persuade anyone to like your algs.



No its not. It is actually faster than all of them, but you have been practicing the others (for years), and so they only appear to be faster right now. This is getting funny, how hard you guys are trying to deny how nice reParity™ really is. Put aside your ego's and stop being retarded.


----------



## miniGOINGS (Jan 19, 2010)

Triple post alert...

EDIT: Good call.


----------



## Escher (Jan 19, 2010)

miniGOINGS said:


> Triple post alert...



Pointless post alert. 
Triple posting isn't actually a 'shocking crime'.



reThinking the Cube said:


> No its not. It is actually faster than all of them, but you have been practicing the others (for years), and so they only appear to be faster right now. This is getting funny, how hard you guys are trying to deny how nice reParity™ really is. Put aside your ego's and stop being retarded.



No it isn't 'faster' than all of them. Your alg is nice, yes, but it isn't 'the fastest currently known to man' as you seem to be claiming. 
While you have a good point about practice amounts; I don't use/know Lucas' parity despite knowing that it is faster than my current because I'm lazy, and I can still execute his algorithm faster than I can yours. Sorry.


----------



## reThinking the Cube (Jan 19, 2010)

miniGOINGS said:


> Triple post alert...
> 
> EDIT: Good call.



Yeah, they ganged up on me, like a scene from a bad Kung Fu movie, and by the time I could chop one up, two more had posted behind my back. I will try to handle it more Gosu in the future.


----------



## miniGOINGS (Jan 19, 2010)

Haha, I don't have anything wrong with triple posts, just wanted to make sure that you know how to multipost so you don't get flamed in the future.


----------



## fanwuq (Jan 19, 2010)

reThinking the Cube said:


> fanwuq said:
> 
> 
> > reParity™ is not that good; the y' 2m2 y' really messes up the flow of the alg. I don't see you finding any algs, you simply converted the notation of cmowla's algs to make the algs appear more fingertrick friendly. I don't see why you brand algs that you did not find, but that's another issue.
> ...





cmowla said:


> Here's another weird pure double parity: (23q)
> r U2 r' F2 l' B2 l B2 l' D2 l D2 l' F2 U2





reThinking the Cube said:


> I was playing around with the starting sequence (r U2 l' U2) which turns even faster for me than (r U2 r' U2). Also (r' B2 l B2) = x' (r' U2 l U2) another fast turner. After some thinkin' , and keeping with the 8-cycle of edges idea, I came up with this:
> 
> reParity™ - r U2 l' U2 x' r' U2 l U2 r' U2 l U2 l' U2 y' 2m2 y'
> 
> ...



r U2 r' F2 l' B2 l B2 l' D2 l D2 l' F2 U2
r U2 l' U2 x' r' U2 l U2 r' U2 l U2 l' U2 y' 2m2 y' 
They definitely aren't the same alg. 
If you argue otherwise, it's your fault not reading the thread and reinventing the wheel.

By the way, this thread is public, it's not just about what algs you like. We can discuss things about 4x4x4 FMC here if it relates to the topic, whether you like it or not.


----------



## reThinking the Cube (Jan 19, 2010)

Escher said:


> No it isn't 'faster' than all of them. Your alg is nice, yes, but it isn't 'the fastest currently known to man' as you seem to be claiming.
> While you have a good point about practice amounts; I don't use/know Lucas' parity despite knowing that it is faster than my current because I'm lazy, and I can still execute his algorithm faster than I can yours. Sorry.



I _DO_ know lucasparity™. For me it _WAS_ the fastest alg that I had to do dedge "flip" parity. Not anymore. I hope you are you using SiGN notation (r = (Rw), 2m2 = M2) to do the algs. It's not rocket science to be able to compare both algs, and see why reParity™ can be done somewhat faster. Maybe for some people, the turn sequences are not as familiar, but they can and will be done faster once you get used to it. For example (r U2 r' U2), or (r U2 r U2) are easy, but they are not quite as fast as (r U2 l' U2) due to subtle grip issues. The reParity™ alg is nothing but these fast (r' U2, l U2) type sequences "walking" back and forth the whole way. Its even shorter too. And the 2m2 argument can be wiped out by combining the last U2 with the y' to set up for the M2 like you didn't even have to do the cube rotation at all.


----------



## reThinking the Cube (Jan 20, 2010)

fanwuq said:


> r U2 r' F2 l' B2 l B2 l' D2 l D2 l' F2 U2
> r U2 l' U2 x' r' U2 l U2 r' U2 l U2 l' U2 y' 2m2 y'
> They definitely aren't the same alg.
> If you argue otherwise, it's your fault not reading the thread and reinventing the wheel.



 I haven't given up on the thread's idea just yet, and I am working on some other algs that get advantage by having more unsolved pieces. Applicability to FMC is also a possibility. 





fanwuq said:


> By the way, this thread is public, it's not just about what algs you like. We can discuss things about 4x4x4 FMC here if it relates to the topic, whether you like it or not.



I don't have anything at all against FMC. I just didn't think it was fair to set the value of this thread according to how many BQTM moves the algs had in them, or whether that was even a worthwhile pursuit. This over-emphasis (mostly by cmowla, and those that wanted to argue against him) on shortest BQTM alg kept setting up this thread (which is really about getting shorter algs by taking advantage of unsolved pieces) to be viewed in a harsh light. I really just don't have anything bad to say about FMC, whether you like it or not


----------



## joey (Jan 20, 2010)

I want to see how you do (r U2 l' U2), because it isn't faster than (r U2 r' U2) for me.



reThinking the Cube said:


> As far as branding lucasparity™ - I did that to give honor to Lucas. Doesn't he deserve that? Even the spelling with lowercase "l" is his way. Giving good names to algs is a good thing. Taking on the ™ just makes it official.


We have already honoured Lucas by calling it lucasparity, you just added the "tm". Which.. just makes it look weird.


----------



## Christopher Mowla (Jan 20, 2010)

fanwuq said:


> reThinking the Cube said:
> 
> 
> > How is it that I converted cmowla alg? Total BS. You should PM him yourself, and when he tells you the truth - that he had nothing to do with any of my algs, then have the decency to edit that accusation out of your post.
> ...


 
There are 2 possibilities:
1) Rethinker used my alg and modified it slightly to form his alg.
2) He came up with it himself and it happens to be very close to my "weird doubleparity alg".

I appreciate your backup, fanwuq, but he could have found his alg on his own. I can understand your reasoning of why you are convinced his alg is a clone of mine, due to the timing in which he found it (not long after I posted my alg which it resembles) and its appearance, but I personally choose to take his word for it. I wasn't comfortable with reThinker's tone towards me in his personal defense posts, but I will not let that change my decision of believing him.

fanwuq, feel free to believe the way you wish (I appreciate your support very much). All I thought was to post my opinion on it, since he was accused of copying my alg. That's all. Peace.


----------



## reThinking the Cube (Jan 20, 2010)

cmowla said:


> Here's another weird pure double parity: (23q)
> r U2 r' F2 l' B2 l B2 l' D2 l D2 l' F2 U2





reThinking the Cube said:


> I was playing around with the starting sequence (r U2 l' U2) which turns even faster for me than (r U2 r' U2). Also (r' B2 l B2) = x' (r' U2 l U2) another fast turner. After some thinkin' , and keeping with the 8-cycle of edges idea, I came up with this:
> 
> reParity™ - r U2 l' U2 x' r' U2 l U2 r' U2 l U2 l' U2 y' 2m2 y'
> 
> ...





fanwuq said:


> r U2 r' F2 l' B2 l B2 l' D2 l D2 l' F2 U2
> r U2 l' U2 x' r' U2 l U2 r' U2 l U2 l' U2 y' 2m2 y'
> They definitely aren't the same alg.
> If you argue otherwise, it's your fault not reading the thread and reinventing the wheel.


 


cmowla said:


> There are 2 possibilities:
> 1) Rethinker used my alg and modified it slightly to form his alg.
> 2) He came up with it himself and it happens to be very close to my "weird doubleparity alg".
> 
> ...



OMG - I want someone to explain to me how I could have gotten to reParity™ from your "weird doubleparity alg". I will eat my cube raw, and the arm that it is attached to, if it can be shown how those two algorithms are somehow clones of each other. Just doing the alg using inner slices only, should tell you all you need to know. I can't believe fanwuq actually believes this cmowla. I interpreted his post totally different than you did.


----------



## Christopher Mowla (Jan 20, 2010)

reThinking the Cube said:


> I can't believe fanwuq actually believes this cmowla. I interpreted his post totally different than you did.


Well, if he didn't mean what I thought he meant, then, please pardon my misunderstanding. (Even though I thought he said that, I still believed you nonetheless).

Since you asked someone to compare the two algs, here it is:
r U2 r' F2 l' B2 l B2 l' D2 l D2 l' F2 U2 (my alg)
r U2 l' U2 x' r' U2 l U2 r' U2 l U2 l' U2 y' 2m2 y' (your alg)

[Step 1] Taking the first 19q moves of each (the last moves are finishing moves and don't really count because they can easily be done to finish the task).
r U2 r' F2 l' B2 l B2 l' D2 l D2 l' (my alg)
r U2 l' U2 x' r' U2 l U2 r' U2 l U2 l' (your alg)

[Step 2] Getting rid of the cube rotation in your alg:
r U2 r' F2 l' B2 l B2 l' D2 l D2 l' (my alg)
r U2 l' U2 r' B2 l B2 r' B2 l B2 l' (your alg)

[Step 3] It is easy to see that the following bolded moves are identical:
*r U2* r' F2 l' *B2* *l B2* l' D2 *l* D2 *l'* (my alg)
*r U2* l' U2 r' *B2* *l B2* r' B2 *l* B2 *l'* (your alg)

[Step 4]
If I substitute r' for l' into your alg (and vice versa), all of the remaining inner-layer slices correspond exactly.

[Step 5] The following moves, although not the same, are repeated in the same location (and are outer-layer turns 180 degrees)
r U2 r' F2 l' B2 l B2 l' *D2* l *D2* l' (my alg)
r U2 l' U2 r' B2 l B2 r' *B2* l *B2* l' (your alg)

[Step 6] I can't really give a plausible explanation for the remaining moves (bolded), but...
r U2 r' *F2* l' B2 l B2 l' D2 l D2 l' (my alg)
r U2 l' *U2* r' B2 l B2 r' B2 l B2 l' (your alg)

That's about it. They almost have the same form and several of their moves are identical without making any substitutions. And note that I am not looking at what the algs do to the cube, but the algorithms on paper themselves. I know it wouldn't be obvious to do this, but that is the best explanation I can come up with (if he did mean what I thought he did).

Again, I believe you. Don't let this "explanation" make you think I don't. If fanwuq did mean what I thought he meant, he probably viewed the algorithms themselves and briefly did the majority of these steps in his head to see a similarity.

Edit:
The algs are being compared as being WCA notation (sorry I didn't mention it before...I will try not to forget than in the future).


----------



## Lucas Garron (Jan 20, 2010)

reThinking the Cube said:


> OMG - I want someone to explain to me how I could have gotten to reParity™ from your "weird doubleparity alg". I will eat my cube raw, and the arm that it is attached to, if it can be shown how those two algorithms are somehow clones of each other.


Convert your alg to a version without cube rotations or l-turns and ignore the leftover 3x3x3 moves.

Sorry about your arm.

Anyhow, it's just rather presumptuous to come with a new, trademarked alg if it's not even really new. Branding can be okay in certain aspects of cubing, but for your algs it's really not worthwhile.

By the way, I don't want the courtesy of a ™ after "lucasparity". That's what others called it, and that's all I ever want it to be called. And I don't really plan to go around naming my other algs stuff like ®2parity™ or XDiagonalizer or TwinParityAlgs. If an alg is worth talking about enough by name, it will get one (like the Sun, which actually doesn't really get talked about).

Compare it to math. It's not like we have the EuclideanAlgorithm™ or GaussLinearEliminatifier™. If you ever do something cool enough, it gets named after you, like "Green-Tao." Or be cool like Peter Shor. Individual cube algs are not really that important, man.


----------



## Lucas Garron (Jan 20, 2010)

cmowla said:


> r U2 r' *F2* l' B2 l B2 l' D2 l D2 l' (my alg)
> r U2 l' *U2* r' B2 l B2 r' B2 l B2 l' (your alg)


Seriously?
Do these algs on two different cubes (or replay them) side-by-side and see what happens to the pieces.

If that doesn't work, try r U2 r' l F2 l'
An amazing 6-move identity!


----------



## Christopher Mowla (Jan 20, 2010)

Lucas Garron said:


> cmowla said:
> 
> 
> > r U2 r' *F2* l' B2 l B2 l' D2 l D2 l' (my alg)
> ...


 
Oh, doing double-layer turns. Wow. The bolded moves in parenthesis are exactly the same apart from a cube rotation about x. The other bolded moves are obviously the same.

*r U2* *(r' F2)* l' *B2* *l B2* *(l' D2)* *l* D2 *l'* (my alg)
*r U2* *(l' U2)* r' *B2* *l B2* *(r' B2)* *l* B2 *l'* (reThinker's alg) 

They are more related than I thought (as far as doing double-layer turns is concerned--but that is what reThinker uses to do his fix anyway). But still, I believe that reThinker did infact find his alg...I don't know how they came so closely related. Maybe this is good practice for me to take a not-so user-friendly alg (mine) and translate it to a better one (reThinker's), though my alg done with single layer turns is indeed a pure double parity with the UF and DB. Interesting.

Edit:
I didn't try to make my alg accomplish the same thing as reThinkers before, but this is the form (very ugly indeed):
r U2 r' F2 l' B2 l B2 l' D2 l D2 l' D2 2s2 z2
Edit:
Still, I am leaning on my first comparison of single slice turns (in WCA notation). By looking at it that way, the algs are less related (and reThinker has more of a point because he mentioned single slice turn differences to start with). It is amazing what double-layer turns can do, though.


----------



## Faz (Jan 20, 2010)

Yes, just to let you know, not that many people (excluding syuhei) use slices to do parity. Most fast people use wide turns.


----------



## reThinking the Cube (Jan 21, 2010)

Lucas Garron said:


> reThinking the Cube said:
> 
> 
> > OMG - I want someone to explain to me how I could have gotten to reParity™ from your "weird doubleparity alg". I will eat my cube raw, and the arm that it is attached to, if it can be shown how those two algorithms are somehow clones of each other.
> ...



Yeah, that's alright, I only ate part of it, and it should grow back soon enough. It's the perfectly good cube I will be missing! More similar than I had realized, but not a clone. (see post below)

http://www.speedsolving.com/forum/showpost.php?p=309828&postcount=205


----------



## joey (Jan 21, 2010)

reThinking the Cube said:


> Lucas: I shouldn't have to defend myself from cheap shots like this. That goes for the rest of the Mods too. The Mods here don't do any of this put-down stuff to the "inside" clique. It's like there is a hit list (masterofthebass?) for certain out-spoken members (preferably new ones), and once you get on it, ANY post that is critical,demeaning,insulting,attacks the credibility of the member,disputes claims of the member, etc. is a GOOD/ESSENTIAL post for a Mod to make. Maybe you even get paid for doing that? You also back each other up, and go out of your way to make one another look good in the forum, (which is admirable), but this double standard serves to highlight even more the deliberate mistreatment dished out to the rest. Have a group chat, figure out quick who doesn't deserve to be mistreated anymore, and please be a little friendlier! WOW. :confused:


This is hilarious.


----------



## dillonbladez (Jan 21, 2010)

lolll

+1, joey


----------



## Christopher Mowla (Jan 21, 2010)

joey said:


> This is hilarious.


-1

I don't it would be if you were defending yourself. reThinker was making a serious statement, not a joke.


----------



## dillonbladez (Jan 21, 2010)

would you really, honestly, think a mod would do that?


----------



## Hyprul 9-ty2 (Jan 21, 2010)

cmowla said:


> joey said:
> 
> 
> > This is hilarious.
> ...


I _think_ you left out a verb.


----------



## fanwuq (Jan 21, 2010)

cmowla said:


> joey said:
> 
> 
> > This is hilarious.
> ...



Actually, it is hilarious. There are no arguments and insults.

It's just funny that he comes up with a convoluted self-centered argument when everyone can clearly see that the algs are the same. Put both algs in alg.garron.us or any other simulator and play them one move at a time, side by side. Lucas was not being disrespectful at all.

If he made a legit, thoughtful defense, then it's not right to take it as a joke, but that whole post was just full of poor reasoning. Many of his statements were funny in an ironic way.


----------



## masterofthebass (Jan 21, 2010)

first off, none of us get paid for this. This is something we do out of our own time. Second, I will admit that most of my recent posts mainly have an negative tone to them, because I've posted enough that posting something I agree with seems to take too much time. Also, perhaps there's a reason why most of my posts are directed towards new members, but that doesn't mean that I say something because they are new. All my posts are directed towards content, and thats really it.


----------



## DavidWoner (Jan 21, 2010)

fanwuq said:


> Put both algs in alg.garron.us or any other simulator and play them one move at a time, side by side.



Even better IMO


----------



## Dene (Jan 21, 2010)

Actually, Dene is the one with a hitlist, and he is not a mod. Nor are there any newbies on the hitlist because I ignore newbs.


----------



## Jake Gouldon (Jan 21, 2010)

Dene said:


> Actually, Dene is the one with a hitlist, and he is not a mod. Nor are there any newbies on the hitlist because I ignore newbs.



Was I at any point on that hitlist? Just curious.


----------



## V-te (Jan 21, 2010)

Jake Gouldon said:


> Dene said:
> 
> 
> > Actually, Dene is the one with a hitlist, and he is not a mod. Nor are there any newbies on the hitlist because I ignore newbs.
> ...



If you are concerned about it, then yes.


----------



## reThinking the Cube (Jan 21, 2010)

masterofthebass said:


> first off, none of us get paid for this. This is something we do out of our own time. Second, I will admit that most of my recent posts mainly have an negative tone to them, because I've posted enough that posting something I agree with seems to take too much time. Also, perhaps there's a reason why most of my posts are directed towards new members, but that doesn't mean that I say something because they are new. All my posts are directed towards content, and thats really it.



OK, fair enough. You had me really worried though, Dan.


----------



## reThinking the Cube (Jan 21, 2010)

DavidWoner said:


> fanwuq said:
> 
> 
> > Put both algs in alg.garron.us or any other simulator and play them one move at a time, side by side.
> ...



WOW. Ok I have to admit that this is pretty cool. It _IS_ actually mirroring for the core edge perm stuff. I should have spotted this earlier. You did good with this video. Even though the 3x3x3 moves change the ending position. This is quite amazing. I set out to create my alg by first discovering an 8-cycle of edges->[4 Mslice dedges] for the core alg, using SINGLE slice moves only. That 8-cycle idea (along with some others that relate to this)was spawned (by myself) earlier in the thread, and since it wasn't being pursued by anybody else - I decided to find something that could do this myself. I then experimented on making that (I actually had more than one) M-slice 4-cycle of dedges into a useable (OLL) using wide turns instead of single slices. I had a lot of flexibility here, since my original idea was OK with LL and F2L slot change. As it turned out, the best solution was also the cleanest. Finally I worked on transforms for speed and simplicity (whereas cmowla was probably more concerned with BQTM). So I not only started out with a completely different idea, I was also heading for the DBL parity position where the URF-UFL corners are swapped. Whereas cmowla's alg started out (I believed)instead to make a 4-cycle of edges->[2 dedges], and not only that he was trying to get a different DBL parity position "flipping" one and swapping dedges UF<->UB. I don't think his alg actually achieved what he was trying to get originally, and maybe that is why he called it "weird". Note the dedge commutation at the end. Probably wasn't looking to fix with 2s2 since he had something else in mind. Yet, it is mind-boggling to me, to see that both these algs end up dancing to the same tune so to speak, on their way to different weddings. 

r U2 r' F2 l' B2 l B2 l' D2 l D2 l' F2 U2


reParity™ - r U2 l' U2 x' r' U2 l U2 r' U2 l U2 l' U2 y' 2m2 y' 

OK, that being said, the actual turns of the core alg are really not _IDENTICAL_, and how those different turns would be executed is going to be different too, and the ending 3x3x3turns are not the same either, which gives a different position for the resulting (PLL/OLL). Not cloned. It is rather ironic, that if cmowla would have put more emphasis on finding an alg that was easier to use, instead of just getting a really good result in fewest BQTM - he might have actually refined his alg down to the EXACT same alg that I eventually came up with. Yep. He was really close.

EDIT: Does anybody care to know what the expected likelyhood of this symmetry popping up is, with ANY two parity algs within <r,l,U2,B2,D2,F2>? After looking at this for awhile, I am seeing that this symmetry might not be that unusual for these types of parity algs. Really there aren't THAT many ways to logically put those turns together and still get a useful alg. Anybody care to take a stab at the math and logic behind this conundrum?


----------



## miniGOINGS (Jan 21, 2010)

reThinking the Cube said:


> Yep. He was really close.



...or maybe you were really close?


----------



## reThinking the Cube (Jan 21, 2010)

miniGOINGS said:


> reThinking the Cube said:
> 
> 
> > Yep. He was really close.
> ...



Obviously.


----------



## miniGOINGS (Jan 21, 2010)

reThinking the Cube said:


> miniGOINGS said:
> 
> 
> > reThinking the Cube said:
> ...



Or maybe, maybe you're both really close to my alg!


----------



## reThinking the Cube (Jan 21, 2010)

miniGOINGS said:


> reThinking the Cube said:
> 
> 
> > miniGOINGS said:
> ...



Post it. I DOUBLE DAWG DARE U!

I have some lining up too, just waiting for a change of weather.


----------



## reThinking the Cube (Jan 21, 2010)

Lucas Garron said:


> reThinking the Cube said:
> 
> 
> > OMG - I want someone to explain to me how I could have gotten to reParity™ from your "weird doubleparity alg". I will eat my cube raw, and the arm that it is attached to, if it can be shown how those two algorithms are somehow clones of each other.
> ...



lucasparity. Done. Everyone seems to be interpreting my Name™ thing as some sort of vanity obsession. It might appear that way, but that is NOT the case at all. The MAIN REASON for giving names to algs, is because of examples like the one quoted above. So what does this refer to: "cmowla's weird doubleparity alg"? Why not define it first, CmowlaWeirdX2™= (r U2 r' F2 l' B2 l B2 l' D2 l D2 l' F2 U2). Now any use of CmowlaWeirdX2™ makes an unambiguous reference to a specific alg. It's a good thing that "lucasparity" has a name, since you have been credited with MORE than one parity alg. I have seen it stated, "that cool parity algorithm that Lucas came up with". Huh? I know you have given names for your other algs = "Omega" rings a bell. Did you wait around for somebody else to call it that? NO. I give names (labels) to algs so that I can refer to them "by name". Their names are shorter, and less ambiguous than doing it any other way. And preventing ambiguity is the main reason for the ™ after the name. It is not about claiming ownership, or a vain attempt at noteriety. It is simply about giving authenticity to the name/label being used. I feel like I have to put "lucasparity" in quotes now every time I refer to it. Doesn't look as properly naming as lucasparity™, but it's your child, and you can name it whatever you want. I totally understand how you might feel uncomfortable doing it my way, but you see, I AM cool.


----------



## deadalnix (Jan 21, 2010)

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

And if it isn't clear for you, you are proabably making wrong assumptions.

If you cannot express what you are saying with a few brief and clear sentences, then you shouldn't write anythings and think the problem again.

I see 2 people here doing very long and complicated speach. You and cmowla. The experience show that these long speach are mostly going the wrong way.


----------



## reThinking the Cube (Jan 21, 2010)

deadalnix said:


> 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 (Jan 24, 2010)

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



Stefan-Pochman said:


> 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






Lucas Garron said:


> 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 (Jan 24, 2010)

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 (Jan 24, 2010)

reThinking the Cube said:


> 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 (Jan 24, 2010)

Lucas Garron said:


> 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 (Jan 24, 2010)

deadalnix said:


> Lucas Garron said:
> 
> 
> > 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.
> ...


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 (Jun 13, 2010)

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


----------



## mrCage (Jun 13, 2010)

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 (Jun 13, 2010)

mrCage said:


> 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 (Jun 14, 2010)

miniGOINGS said:


> mrCage said:
> 
> 
> > 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 ...
> ...


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

Per


----------



## miniGOINGS (Jun 14, 2010)

mrCage said:


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



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


----------



## Christopher Mowla (Jun 22, 2010)

cmowla said:


> 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 (Jun 27, 2010)

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.



cmowla said:


> 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.



cmowla said:


> 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 (Jun 27, 2010)

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 (Jun 27, 2010)

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 (Jun 27, 2010)

Ron said:


> 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.
> ...


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 (Jul 11, 2010)

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 (Jul 11, 2010)

QCcuber4 said:


> 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 (Jul 11, 2010)

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 (Jul 11, 2010)

QCcuber4 said:


> 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.


----------



## Christopher Mowla (Jul 14, 2010)

cmowla said:


> 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).


----------



## Stefan (Jul 14, 2010)

cmowla said:


> 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'



cmowla said:


> 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 (Jul 14, 2010)

StefanPochmann said:


> cmowla said:
> 
> 
> > to show that 21qs *like this* do not need to scramble the reduced 4X4X4 completely.
> ...





cmowla said:


> *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'



StefanPochmann said:


> cmowla said:
> 
> 
> > It's pretty cool to do a double parity and adjacent PLL parity in 29q though
> ...


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.


----------



## Stefan (Jul 14, 2010)

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...


----------



## Christopher Mowla (Jul 14, 2010)

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 (Jul 18, 2010)

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.



reThinking the Cube said:


> 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.


Spoiler



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.)


----------



## Christopher Mowla (Jul 24, 2010)

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*


Spoiler



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,
r U2 r' U2 r D2 r D2 r'

We 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:


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
=r U2 r' U2 r D2 r D2 Rw' F' R F U l' F2 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


----------



## Christopher Mowla (Aug 7, 2010)

*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

and add the following piece:
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:


reThinking the Cube said:


> 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.)


----------



## Joker (Aug 10, 2010)

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


----------



## Christopher Mowla (Aug 10, 2010)

Joker said:


> 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 (Nov 25, 2015)

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 (Nov 25, 2015)

bonerici said:


> 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!


----------



## bonerici (Nov 25, 2015)

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


----------



## bcube (Dec 25, 2015)

Christopher Mowla said:


> 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 (Dec 27, 2015)

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 (Dec 27, 2015)

unsolved said:


> 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.
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.

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.
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.


----------



## unsolved (Dec 27, 2015)

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.


----------

