# 4x4 parity: never need to do 2 algs!

#### bobthegiraffemonkey

##### Member
Hey all, I've improved the last parity idea I had, I don't think I'll find a better way to deal with parity than this so I've decided to make a thread.

For a long time I've messed around with ideas for parity, especially for not needing to do more than one parity alg in a solve, and I think I've finally found a really good solution. Having already made a notable contribution to parity on square-1 (cubeshape parity is now starting to get somewhere, Rowe in particular is really fast with it, but I digress), let's see if I can (finally) do the same with 4x4!

This is mostly concerned with having (at least) OLL parity.

Here's some relevant parts of the description:
description said:
Steps:
1) F2L with edge flipped and U-layer corner (with U sticker on D)
2) OLL
3a) recognise "PLL" using opposite edges (either green/blue or red/orange for me, it would help to track these during OLL)
3b) PLL/TTLL to solve up to parity case
4) OLL parity or double parity to finish

My preferred (kinda weird) parity algs:
OP: F' l' U2 l' U2 l U2 l' U2 r U2' l' U2 l U2' (r' l2') U2 l F
DP: z' (F2 x) l2' U2 l U2 l' U2 l U2' (B2 x2') r U2 r U2' (r' l') U2 z

Yes, it does mean learning a new method of PLL recognition, but I expect that it's worth the effort, as it should also make things like predicting PLL during OLL much easier. Being able to always do a 2-gen alg for step 3b is pretty cool, and with EO control the entire LL up to parity can be 2-gen (or pseudo 2-gen at least, which is still awesome), with no awkward PLL parity recognition.

Gyroninja's ZZ-CT algs for reference: http://gyroninja.net/zzct/zzct.html#about

TTLL tricks not yet fully documented, but I'll provide these when I have them. It's fairly easy to document though, do the DP alg then try different TTLL algs from different angles and note down the results.
Good things:
-Do at most one parity alg in a solve
-No need to recognise PLL parity until the very end, at which point it's really easy
-***For the "PLL"/TTLL step, EVERYTHING can be done 2-gen*** (or pseudo-2-gen: y' alg y, or D alg D')
-Recognising the edge permutation of LL cases using opposite edges seems pretty good in general, for 3x3 PLL (better lookahead probably), 4x4 PLL (for when you don't have OLL parity) and ZBLL (all of the above).
-As with pretty much all the methods I post, this is (in my own totally not-biased opinion) really cool and fun

-Need to learn a new way to recognise PLL which is difficult if you've spent a lot of time practicing a different system like 2-side recognition (I assume, maybe someone already does it this way?)
-Pretty much need to be really good at seeing EO during F2L so that you know whether you have OLL parity by the time you get to last slot, but that's seems useful in general anyway

I think it's really cool and awesome, and I'll be using it once I spend some time learning the recognition for it (I'm busy with other stuff so that might take a while).

Discuss!

P.S. At this time Gyroninja's site, which is what I bookmarked for TTLL algs, seems to be down. I don't know any other resource for this currently and I've PM'd him about it.

#### DGCubes

##### Member
Very cool idea. Might have to learn to do this.

P.S. At this time Gyroninja's site, which is what I bookmarked for TTLL algs, seems to be down. I don't know any other resource for this currently and I've PM'd him about it.
You can just use the cached version, here.