top of page

Cubeshape Parity

  • Why you should learn CSP

We all love parity. One reason we love it so much is that it increases our solves' move count. This is a technique that can be used to solve parity and Cubeshape in one go, while not having to worry about preserving any previously solved stuff, therefore reducing the move count significantly along with parity's charm (also, you can't change parity on a square-1 without going out of Cubeshape, so if you solve parity later in the solve, you'll have to go out of Cubeshape, switch parity while preserving stuff, and come back to Cubeshape). I don't know why you would want to do that, though. Parity is awesome. /s

All credit for this great method goes to Matthew Sheerin (A.K.A. BobTheGiraffeMonkey).

Oh, and you should know how to trace cycles (the thing that's done in blindsolving) to be able to use this method. I recommend Noah's tutorial on 3x3 blindsolving. You don't need to learn the full thing, only how to trace cycle. I might add in the cycle tracing part later if I get time, but right now I have no intention of doing so when such great tutorials are already there.

For that, you have to understand parity first. Parity simply refers to whether a number is odd or even. How does that relate to cubing?

Let's look at a 3x3 first. You can solve any 3x3 scramble using only 2-swaps, solving each piece one by one, just like you'd do in a blind solve. If you count how many 2-swaps it takes you to solve a certain scramble, you get a number (if it wasn't obvious). Check the number's parity i.e. whether it is odd or even. That is the parity that the scramble is said to have. Turns out, a 3x3 will always have even parity, since any 3x3 scramble can only be solved using an even number of 2-swaps. Also turns out, square-1 can have odd parity too, which is much more of a pain than even parity is. Oh, and when we say a scramble doesn't have parity, we just mean that it has even parity, or good parity, instead of odd parity, or bad parity. Have a look at this unnecessarily long (23 mins) and nub production quality video to understand parity if this unnecessarily long and nub production quality paragraph didn't help.

 

So, to avoid parity, you just need to find out what parity the scramble has, and solve the Cubeshape in a way which solves the parity too, thus dividing CSP into 2 parts: Recognition and Execution.

  • How it works
  • Recognizing Parity : Concept

This part is pretty obvious once you've understood parity. Since parity can be figured out just from the number of 2-swaps required, so just trace cycles from the scramble to solved state and the number of targets will tell you whether you have odd parity or even parity.

 

Except, not. Long-term viewers of square-1s will know that the square-1 has edges and corners, which are different in size but move on the same tracks, and can replace each other. And distinguishable pieces in indistinguishable positions are quite the cause of anguish. If you want an example, try any out-of-cubeshape scramble for yourself and see if you can trace cycles to the solved state from there. You'll notice corners cycling into 2 edges and edges cycling into half a corner and all kinds weird stuff which will not let you trace to the solved state. In fact, a scramble out of cubeshape doesn't have odd or even parity, since it cannot be solved using 2-swaps, and parity is the parity of the number of 2-swaps required to solve a scramble. And that means that you need an alternate definition for parity in square-1. Let's make it, the parity of a scramble is the parity the sqaure-1 will have if you solve the cubeshape using your normal algorithm for that shape. What does the normal algorithm mean? Well, as mentioned previously, you'll have to have 2 algorithms to solve each shape, one would be the 'parity preserving' alg and one will be the 'parity switching' alg. You'll simply use the former if the scramble doesn't have parity and the latter if it does. However, these terms aren't really that good because the parity of a scramble not in cubeshape is not defined, and therefore I'll be referring to the 2 algs as the normal alg and the alternate alg. Note that normal doesn't refer to parity preserving and alternate doesn't refer to parity switching, just that you'll have 2 algs for each shape, and simply consider one of them to be parity preserving and one to be parity switching. Basically, you'll be making your own convention for what alg is what. For example, my normal alg could be your alternate alg and vice versa. Now read that definition of parity again and it should make sense.

 

So using that definition, if your scramble doesn't have parity, that means that it won't give parity if the scramble is solved using your normal algorithm, and so you just use your normal algorithm. If the scramble does have parity, you use the alternate algorithm. Obviously, this means that the normal algorithm and the alternate algorithm that you pick will have to give opposite parities. You can't pick the 2 algorithms such that they both give the same parity, because then you won't have the tool to manipulate parity. So you'll need 2 algs, both of which give opposite parities. You might be thinking how one person can have can exchange his normal and alternate alg and still not get parity. That's because then, his definition of parity will also change exactly so that he encounters no parity. Therefore you can choose whichever alg you want as your normal alg and whichever for your alternate alg, as long as both give opposite parities (and solve that cubeshape obviously). The list of algorithms will also be there in the execution part of this tutorial which you can refer to if you are not able to find different parity alg for your alternate alg for a certain shape.

 

So you can't trace cycles to the solved state. What do you do then? You trace cycles to a state to which you can trace cycles and for which you already know the parity (by tracing cycles to a state, I mean, of course, that you pretend that that state is the solved state and see how many 2-swaps it takes to get to that shape. You trace each piece to where it would be in that pretend solved state instead of the actual solved state). This intermediate state will have to be the same cubeshape as the scramble. Otherwise, you won't be able to trace to it. Does that mean you'll have a different intermediate state for each cubeshape and each AUF of each cubeshape? Yeppers. Will you have to memorise them all? Nope. Read the next few paragraphs and you'll get it.
 

The intermediate state is called the reference scheme. There is no reference scheme set for each shape that you'll have to keep, and there is no best set of reference schemes. In short, you can make your own reference scheme for each shape. No rules, anything random, anything at all. I'll explain how you can make your own reference schemes in a bit, along with other reference scheme details. For now, let's focus on how it works. So how this works is that you will already have this reference scheme's parity memorised, and will trace to this reference scheme from the scramble you get within inspection. And yeah, your reference scheme can have odd parity since it will be completely random. Then you combine these 2 pieces of data to figure out if the scramble has parity or not. For example, there are 2 possibilities for the number of targets you trace from a scramble to its reference scheme: either it will be even, or it will be odd. If it is even, then that means that the scramble has the same parity as the reference scheme and if it is odd, then that means that it has the opposite parity of the reference scheme. So if the no of cycles you traced is odd and your reference scheme has odd parity too, the scramble has the opposite parity of the reference scheme, i.e., even parity. If you analyse all 4 possible cases, you'll see that they can be arranged in a truth table like thing as is given below.

 

The first column tells you the number of cycles you trace to your reference scheme and the first row tells you what parity your reference scheme has.

If you're on a mobile, it might appear in the form of categories. The 2 main categories will be the 2 options for the parity of the reference scheme and the even and odd inside the 2 main categories will refer to the no of cycles you trace to the reference scheme.

As you can see, the parity of the scramble is just the number of cycles traced to the reference scheme + the parity of the reference scheme. Even+even = odd+odd = even and even+odd = odd+even = odd.

 

So,

S=R+T

where S is the parity of the scramble, R is the parity of the reference scheme and T is the number of cycles you trace to the reference scheme. Now, if the S is even, you use your normal algorithm, since S being even means that you won't get parity if you used your normal algorithm, and you use your alternate algorithm if S is odd. This implies,

S=A

which in turn implies,

A=R+T

where A represents the algorithm you use to solve the cubeshape, the normal algorithm being represented by even and alternate algorithm being represented by odd. Again, note that the normal algorithm isn't being represented by even because it is intrinsically parity-preserving. It is being represented by even because our definition of parity for a square-1 scramble makes it the parity preserving scramble.

This is the equation you will be using every time you use CSP, though you might think in variations of this. The way I think is that the parity of the reference scheme and the number of cycles traced should be equal. If they are, I use the normal alg, otherwise, the alternate alg. This is what the table above showed, and can also be seen in the equation.

Whichever way you think about it, you should be comfortable with that and it should be almost instantaneous (practice can help with that), because you will be aiming to do the tracing and parity deduction within the 15 seconds of inspection.

​

That's it for the concept of how you figure out the parity of a scramble. Everything that follows is about how to apply this concept. If you didn't understand anything from this, do not proceed and read from wherever you stopped understanding again. Read as many times as it takes you to understand it, because without it, whatever comes after this would either be useless, won't make sense, or both.

​

So here we go with making reference schemes.

  • Recognizing Parity : Reference Schemes

So you've gotta make random reference schemes, one for each shape, and even for all possible AUFs of each shape, since you can't trace cycles from a scallop to another scallop rotated by a U or something, much like you can't trace cycle from it to the solved state.

 

/* From here, you can make a choice. Either learn recognition the way Tommy and Rowe do it, or the way Matthew and I do it. Tommy and Rowe have basically just tweaked some of the reference schemes so that all of their reference schemes have even/no parity. Matthew and I maintain the same pattern across all reference schemes and just remember the parity of each reference scheme. Either way, the work required should be roughly the same to learn it since in one method you learn odd or even for each shape and in the other method you learn tweaked or not tweaked for each shape. I prefer the method without tweaked schemes because I can jump into tracing as soon as I pick up the square-1 without worrying about what's on the D-layer until I get a piece which belongs there and can think about parity after I've done the tracing and am about to start the timer whereas, from what I understand, with the other method you need to think about the tweaked or not tweaked stuff before you start tracing and since the reference scheme you trace to might be different from usual, tracing might be a bit slower. I have not tried this so this is just speculation. You can find their guide here. */

​

Imagine you have a set of rules. You just apply this set of rules on whatever cubeshape you get and it "generates" the reference for that shape. That way you don't have to memorize 42 million reference schemes and instead just memorize that set of rules, which you use to "generate" your reference scheme at the beginning of the inspection itself. This is exactly what you'll be doing.

​

Now you need to know the variable R (the parity of the reference scheme) and you might be wondering how you could possibly know that if you generate the reference scheme in the inspection itself. It's pretty simple, the set of rules will always generate the same reference scheme for a shape every time. It will not be random, like for scallop-scallop, the reference scheme generated has to be same every time you apply your set of rules on it. That means you could just generate it once while practicing and memorize the parity of the reference scheme you generate during practice. Since the reference scheme for that shape would be the same regardless of whether it was generated in practice or in inspection, the parity of the reference scheme for that shape will still be the same. This is pretty obvious, but still I felt that this might need clarification. If this paragraph makes no sense because of how I have worded this, you can ignore this because this will be clarified in the following examples of my reference schemes.

​

So here are my rules for generating reference schemes. You can copy these, or make changes to whatever you feel will not suit you.

​

1.  Each piece on the square-1 has a number associated with it, much like how, in BLD, each sticker on the cube has a letter associated with it (in square-1, you don't need to number each sticker because each piece only has one possible orientation). The numbers associated with each piece for me, are-

1 - White-Orange​

2- Yellow-Orange

3- White-Red

4- Yellow-Red

5- White-Green

6- Yellow-Green

7- White-Blue

8- Yellow-Blue​

Note that most people prefer to group together all the whites and all the yellows. Pick whatever suits you.

This applies to both corners and edges. instead of just edges. How it applies to edges should be obvious, but how it applies to corners​ might be a bit hard to see because a corner has 3 colors.

You only need to look at 2 colors to uniquely identify a corner. I look at the top color (white/yellow one) and the color on the left when looking at the corner from the top.

Before we start, here's the link to Matthew Sheerin's (the guy who created this method)

tutorial on this, in case you want to refer to that too: http://pastebin.com/Xh3vSQFp

I will recognize this corner as Yellow-Red, or the 4th corner according to my list, since yellow is the top color and red is the color on the left (or the CCW side of the corner. You could choose to look at either the CW side or the CCW side depending on which you are comfortable with, it doesn't changing anything about the recognition or the execution.

​

Now that each piece has a number, we need to assign a number to each position on every shape in order to be able to have a reference scheme (because we need to know which position each piece has to be associated with), and that's what the further rules are about.

​

From here on out, whenever I mention "shape", I'm referring to the shape of only one layer. For the shape of both layers together will be referred to as "Cubeshape".

​

2.  The first edge position for a shape on top is the leftmost (CCW-est) edge in the biggest group of edges of that shape. The sequence goes clockwise from there, numbering each edge position as 2nd, 3rd, 4th, ...., n where n is the number of edges the shape has. Here are a couple of examples.

For shapes on bottom, I start with the CW-est edge in the biggest group of edges and go counter clockwise from there, so for the bottom layer my numbering of these shapes will be mirrored.

You don't necessarily need to change the order on the bottom layer. I did that because I found it better that way. You can go in the same direction on both layers if that's what you are comfortable with.

​

Similarly, I go clockwise for corners on top and counter clockwise on bottom. My rule for starting point of corners is the corner right after the biggest group of edges.

​

For shapes which have more than one biggest group of edges (eye, barrel, shield, the pointy one with 2 groups of 3 edges) I have specific starting points decided. In barrel and eye (and also the shape which has 3 separated-by-corners-pairs-of-edges), I can pick whichever of the 2 groups and parity won't be affected (try explaining this one on your own, you should be able to do it using what you've already read about parity). In the other 2, I have the starting points pre decided. For square, I have the relative starting points of corners and edges fixed (starting point for edges comes right after whatever starting point I choose for corners).

​

Now that we have a number assigned for each position and each piece, we simply combine the 2 to get the reference scheme and that's what we trace to.

​

The last step to get set up to do CSP in an actual solve is finding the parity of your reference scheme for each shape. To find the parity of, say, your reference scheme for scallop-scallop, first set up to scallop-scallop then trace the number of targets to your reference scheme. This tells you the variable T (recall the equations I used to explain the concept). Now solve the cubeshape using your normal algorithm. See if you get parity. If you do, the scramble had odd parity, if not, even parity. Either way, you now have the value of S, the parity of the scramble. We can now use the equation

 

S=R+T

or

R=S+T

(we just care for odd or even, so adding and subtracting give the same result)

​

This tells you the parity of the shape's reference scheme.

​

​

 

That's all for the explanation for now. Now that you can find the parity of a scramble, all you need is 2 algorithms per cubeshape. For the algorithms, you can take a look at either Matthew's doc or Tommy and Rowe's sheet. Which algorithm you use as your normal alg and which one you use as your alternate alg is totally up to you obviously. The said resources would simply give you 2 algs per cubeshape which give different parities.

​

If you have any doubts regarding any of this stuff, feel free to mail me at lakshaymd @ gmail.com (without the spaces of course, they're just to protect my ID from spam machines :v).

​

​

bottom of page