# New 4x4 OPA Method (How to avoid OLL parity)



## Anuar (Feb 11, 2021)

If you don't know what OPA is, you should watch this video first. 

Also, watch this from 7:20 to 8:34. I use the same letter scheme and orientation shown in the video. My buffer is I, but you can choose any buffer you want. It's just the place where you begin the first cycle.

One more thing you need to know is how to differentiate between good and bad wings. This is very similar to ZZ edge orientation. The good wings are A B C D J L R T U V W X. The bad wings are E F G H I K M N O P Q S.

With this method, instead of tracing wings to solve them, you want to trace them to the place next to the other wing with the same colors. For example: A goes next to Q, B goes next to M, C goes next to I, and so on.

You also have to take good and bad edges and the location they are going to into consideration. We're going to assign a value for each case, and that value will be added to the parity value for each traced wing. The parity value always starts at 0.
A good wing going to a good location is 1.
A bad wing going to a bad location is 1.
A good wing going to a bad location is 0.
A bad wing going to a good location is 0.

For example: A (good) going to F (bad) is 0; K (bad) going to E (bad) is 1.

There are three special cases that might happen:
1. If there is a solved edge, you check its orientation. If it's a good edge, you don't need to anything. If it's a bad edge, add 1 to the parity value.
2. If you pick up the cube and realize that your buffer is solved in relation to the wing next to it, just rotate the cube to another orientation where the buffer isn't solved.
3. If you finish the first cycle but there are some unsolved edges you didn't trace, that's a cycle break. Choose any of those edges and start a new cycle there. For every cycle break, add 1 to the parity value.

Finally, let's apply that to the solve. In 4x4, the parity doesn't change after you've solved two adjacent centers. If your parity value is even, you must do an odd number of wide moves until two adjacent centers are solved. If your parity value is odd, you must do an even number of wide moves until two adjacent centers are solved. To see techniques to solve the first centers, watch the first video I mentioned. Since most good methods build 2 opposite centers first, you usually have to count the wide moves until you solve the first three centers.



Spoiler: Example 1



Scramble:
U2 L' F2 B R F2 D' R2 D2 B U2 F U2 D2 L2 F' B' U2 F2 R' F Fw2 Uw2 B R' Uw2 R' D2 R2 Uw2 U2 B F' D B' D2 B' Uw B2 Fw Uw D2 Rw Uw' Rw' Uw' F2

The wing on I is S (bad), and it goes to N (bad). Parity value = 1
The wing on N is T (good), and it goes to U (good). Parity value = 2
The wing on U is B (good), and it goes to H (bad). Parity value = 2
The wing on H is P (bad), and it goes to S (bad). Parity value = 3
The wing on S is D (good), and it goes to G (bad). Parity value = 3
The wing on G is X (good), and it goes to M (bad). Parity value = 3
The wing on M is F (bad), and it goes to Q (bad). Parity value = 4
The wing on Q is Q (bad), and it goes to E (bad). Parity value = 5
The wing on E is K (bad), and it goes to O (bad). Parity value = 6
The wing on O is V (good), and it goes to P (bad). Parity value = 6
The wing on P is C (good), and it goes to L (good). Parity value = 7
The wing on L is H (bad), and it goes to I (bad). Parity value = 8
That ends the first cycle, because H is going back to where the cycle begun (I). All edges have been verified, so there's no new cycle.

Parity value = 8, so you must do an odd number of wide moves to solve two adjacent centers. This is one way you could do it (building the opposite centers first):

z y'
F' B2 Rw U Rw B' Rw
y' U' Rw U2 Rw'
z x U D' Rw U' F' Rw





Spoiler: Example 2



Scramble:
R2 U B2 R2 D2 R2 U' B2 R2 F' D' L D' F D2 L' D2 L2 B' Uw2 F L Fw2 B R2 Uw2 B' L B R2 Uw B2 D' R2 L Uw' L Rw Fw Rw' Fw Uw2 D'

In this scramble, my buffer (I) is solved in relation to the wing next to it. I'm going to do a *y* rotation before I start tracing, so that my buffer isn't solved.

There is one solved misoriented edge. Parity value = 1.
The wing on I is T (good), and it goes to O (bad). Parity value = 1
The wing on O is R (good), and it goes to I (bad). Parity value = 1
That ends the first cycle, so a new cycle begins on A. Parity value = 2
The wing on A is K (bad), and it goes to S (bad). Parity value = 3
The wing on S is A (good), and it goes to M (bad). Parity value = 3
The wing on M is L (good), and it goes to R (good). Parity value = 4
The wing on R is D (good), and it goes to X (good). Parity value = 5
The wing on X is C (good), and it goes to J (good). Parity value = 6
The wing on J is W (good), and it goes to L (good). Parity value = 7
The wing on L is P (bad), and it goes to U (good). Parity value = 7
The wing on U is B (good), and it goes to T (good). Parity value = 8
The wing on T is V (good), and it goes to A (good). Parity value = 9
That ends the second cycle. All edges have been verified, so there's no new cycle.

Parity value = 9, so you must do an even number of wide moves to solve two adjacent centers. This is one way you could do it (building the opposite centers first):

F' U2 Lw F Lw
y F2 Rw U Rw'
y' z F' U Rw2 U' Rw U2 Rw'



I've been using this method for about a week, and my inspection is almost sub-15. For me, it's a lot faster than 4BLD tracing. If you have any questions, I'll be happy to answer.


----------



## abunickabhi (Feb 14, 2021)

Interesting way of avoiding OLL parity on the 4x4.

I tried doing it by counting the number of edges, and also did it in official solves.


----------



## arquillian (Jan 9, 2022)

Anuar said:


> If you don't know what OPA is, you should watch this video first.
> 
> Also, watch this from 7:20 to 8:34. I use the same letter scheme and orientation shown in the video. My buffer is I, but you can choose any buffer you want. It's just the place where you begin the first cycle.
> 
> ...


example 1 is wrong - S doesn't go to N, it goes to D (line 1). Also S shows up twice in your tracing without any cycle breaks. This looks promising though, I'll spend some time practicing this.
edit: example 2 is also wrong - you start a cycle at A then you go K -> S -> A. You hit A again but instead of breaking into a new cycle you just continue. Either I'm misunderstanding the method or there's tracing errors here lol


----------



## Anuar (Jan 9, 2022)

arquillian said:


> example 1 is wrong - S doesn't go to N, it goes to D (line 1). Also S shows up twice in your tracing without any cycle breaks. This looks promising though, I'll spend some time practicing this.
> edit: example 2 is also wrong - you start a cycle at A then you go K -> S -> A. You hit A again but instead of breaking into a new cycle you just continue. Either I'm misunderstanding the method or there's tracing errors here lol



I think you didn't understand the method, tracing is correct on both examples. This isn't exactly like BLD tracing, you don't want to trace a piece to the solved position. You want to find the other piece with the same colors and trace the first one next to it. If you do the algs, the result would be a 4x4 with edge pairing solved. I'm going to explain the first "mistake" you mentioned:

The piece on my buffer position is S (the blue-yellow piece). It must go next to the other blue-yellow piece, not to where S should be when the cube is solved. Since that other blue-yellow piece is on uBR, the first one must go to dBR, which is N.

If you have any other questions, feel free to comment here or message me on Facebook!


----------



## Sean Hartman (Jul 9, 2022)

Is there a good way to know what peices you have left when there are cycle breaks with this method? How do you deal with 2 swaps?


----------



## TCCuber (Jul 14, 2022)

Do you have an explanation as to why this method works?

If the scramble is just a solved cube, the count is even, so it wouldn't make sense to have to do an odd number of inner slice moves. I think something's wrong here...

EDIT: I understand why this works now, and all 3x3 states are an exception because of the way you're counting. When tracing normally, we technically add 1 each time because we are mentally performing a wing 2-swap, but we add another 1 if this 2-swap results in a bad dedge. Adding 2 is essentially the same as not doing anything since we're only worried about whether the count is even or odd, so we would normally only add 1 to the count if these 2-swaps result in good dedges. When your target is back at the piece you started tracing from, however, you aren't doing an extra swap, so we only add 1 if the last swap results in a bad dedge. Since you're not accounting for that, the count for each of your cycles will be off by 1, but the fact that you add 1 for each cycle break compensates for each off-by-one "error" after the first cycle. Since there are none of these cycles when all the dedges are already paired, however, there is no off-by-one "error". This doesn't really matter at the end of the day since getting a scramble with all dedges already paired is insanely rare, and you can just account for this fact if a scramble like that ever comes up for you, but I became intrigued once I figured out how this works and thought this explanation might end up being somewhat useful to somebody.


----------



## abunickabhi (Jul 24, 2022)

Nice tracing by stanley to avoid parity!


----------



## LBr (Aug 29, 2022)

I just want to ask you guys;
Is OPA really viable for speedsolving?
Because several people are implementing it in their 4x4 times at higher levels. Here’s a pros and cons list I can think of:

Pros
-The solve itself doesn’t change much as you may only have to change the way you solve it on average
-If I can get as fast with this as regular 4x4 I will slash 1.5 secs off my time as my oll parity takes maybe 3 secs on average
- oll parity is 18 moves long so the average solve could have 8 less moves when taking into account the extra moves you may need to do when starting L2C on odd.
Edges and 3x3 remain the same

Cons (I’ll keep this short)
- inspection hinderence and general pressure (inspection isn’t important on 4x4, but the main worry for me is the time pressure it’ll take for tracing and slight planning in just 15 sec.
- you need to think a lot in the first 2/5 of the solve and that could slow you down, but this could improve with practice
- I don’t do bld at all
-will it really save that much time??

please give some recommendations, as now I have destroyed my 3x3 average I want to maybe look into other events more and enjoy them, as although 4x4 is the best big cube event I’ve always thought we could do better with methods especially when the main one can’t even solve the edges properly


----------



## the_chad (Aug 31, 2022)

Bill Wang just posted this average


----------

