Sq-1 cubeshape parity (CSP)

Square-1: Cubeshape parity (CSP) v2.0
=====================================

I'm bobthegiraffemonkey, and this is my written guide to being cool. As far as I know I'm the first to seriously attempt and develop this, and finally there's some fast people learning it and putting it to good use. Some people are making their own resources for it now too, which I'll provide links to.

The important thing here is to understand what's happening for each case and to know what affects parity and what doesn't. Experiment with cases, it will probably help a lot. After that, it should be easy to adapt this to your own style if you dislike any choices I made (or the other resources), and make your own notes, but the information I've gathered and put here should be helpful.

Relevant videos:
Example solve: https://www.youtube.com/watch?v=QxXT5Ucp2HY
Tutorial: Coming soon (will be much better than my old terrible ones, I promise)
Discussion on reference schemes and making your own notes/learning: (coming soon)
My demo AO5: https://www.youtube.com/watch?v=Z2byFKJvwio
Actual fast person: https://www.youtube.com/watch?v=vdjD0mhWBOk


Other resoures
--------------
Some of these may require some prior knowledge of how CSP works, but they will definitely be useful for some people. It's weird for me seeing a different way of thinking about the two algs for certain cases which avoids some things I thought were necessary, but its nice to see other people understanding the basic concepts and adapting the rest of the method to their own style. If you don't like some of the ways I did things, maybe you'll find that you like their way instead. If there's any resource I've missed that you think should be here, let me know.

Tutorial (Lakshay)
http://sqfunnub.wixsite.com/42pnpls/csp-guide
Very similar to my style for CSP, not yet complete as I'm typing but some people might prefer his way of explaining stuff.

Different reference schemes/algs (Rowe/Tommy)
https://docs.google.com/spreadsheets/d/1QEx3dcOZE5KTRwu80gEd6y1xqKrbC0MZ8GMUtZv0kns/edit#gid=0
Their choice of reference schemes and algs. I don't like their approach personally, but it's personal preference. This won't make sense unless you're familiar with the basics of CSP, but they chose a different style for reference schemes, and made it so that there's an even alg and an odd alg for every case. There are tradeoffs between their approach and mine, but they both seems to work just as well in practice.

Tutorial & Youtube playlist (currently in progress, Learn CSP with Brandon Lin)
https://esqu1.github.io/cubing/csp.html
https://www.youtube.com/playlist?list=PLIO0D-fz-pRyBr3rnNX4eG_Hy13tsTdlA
Seems to be using the same approach as Rowe and Tommy. He shows what the reference scheme looks like, both algs, and example solves. If that's how you feel like learning the cases, then you should find it very helpful.


How the hell does that even work
--------------------------------
So, you have a scrambled square-1. You get it to cubeshape, solve some stuff, realise you have parity, do a long parity alg to preserve the stuff you've solved already, then finish solving stuff. Wouldn't it be better to get to cubeshape with parity already taken care of, so you don't need a long detour to fix it, and don't have to worry about recognising it? If you said 'no', go away. I don't like you, and you don't belong here. This is a guide for people who want to be cool and solve parity the efficient and advanced way. You'll need to understand the idea of parity in general, and know how to trace cycles like in a blindfolded solve (but you don't need to be able to memo or solve cycles). If not, go look up tutorials for them, they already exist so I'm not going to explain it.

The idea is this. For every shape that isn't cubeshape, there isn't a single, well-defined way of saying whether parity is even or odd. (Some) people used to think that parity + cubeshape needs to be able to track pieces through to cubeshape, then trace the cycles. No, that's a lot more difficult than it needs to be. For every shape, choose where the solved positions of pieces should be (in a sensible and consistent way), then you can trace the cycles against that to get an answer of even/odd parity. Once you have that, you need a system for turning that answer into a sequence of moves to get you to cubeshape with even parity. You could, as others have, learn an even parity alg and an odd parity alg for every shape, but I use something a little different (it's pretty much the same idea, with a different way of thinking about it). For every shape, I have a default alg and an alternative alg, with the aim of having the default algs be as consistent as possible with each other. Then, it should be easy to know which alg is default and which is alternative, making recall for which alg to use simpler. As well as this, I need to remember which of the two preserves parity, and which one switches it. This seems like a lot more effort, but it isn't really. The 'extra' info is really easy to learn, especially when broken down into sets, and I think it's a much safer system.


Aligning stuff
--------------
For some cases, there's two ways of aligning the layers to get to the same shape - they will be mirrors of each other, and importantly, they affect parity differently. This doesn't have anything to do with figuring out what parity you have in a scramble, but rather how you solve the case depending on what the parity is. Here is my approach, it turns out it's not the only approach, check out the other resources available for details.

You can split the corners of a cube into 2 sets that closely resemble tetrahedra (that's how I think of it anyway because geometry says so, that's why the mastermorphix works, you don't need to see it this way so long as you understand how to apply it). This fact can be used to tell the difference between two ways of lining up the layers, which are mirrors of each other. The 8 locations (4+4) are next to where the middle layer is split. I will include a setup to barrels with edge pairs in the appropriate locations (this has no effect on solving the barrels case itself, it just has the right shape to serve as a reference).

Default alignment (with setup to place edge pairs to each position)
UFR UBL DFL DBR
/-3-3/2-1

Alternative alignment
UFL UBR DFR DBL
/-3-3/-21

Take the following example, setup with /-3/4-1/04/ (ecececeee/cceeccc). If you have a spare sq-1 or two, setup the default barrels reference above and maybe the alternative one too. Note how the edge pair on the case is the same place as an edge pair from the default barrels. Thinking about how sq-1 works, doing any combination of 6,6 and /6,6/ moves doesn't really affect anything, and in this case doing these only serves to make the edge pair match with different edge pairs on the default barrel - which is exactly why using that as a reference makes sense. Invert the setup to get a default alg for solving that case.

Now, after the setup do 2,2. It kinda looks the same, but the shape looks mirrored left/right. Now, the edge pair doesn't match the edge pairs on the default barrels, but rather one on the alternative barrels. From here, solve cubeshape with /4/4-1/0-3/ and you should find that parity has been switched. Now you can clearly see that there can be more than one way to solve a case that might look the same at first glance, but they affect parity differently, and this lets you tell them apart.

This is useful as a reference for many cases, including for things which aren't edge pairs, such as the [ece] block on D after the following setup: /-3/-2-1/2/.


Stuff
-----

Sometimes, there are pairs of cases which are mirrors of each other. I always manage to treat both cases the same way so I don't have to care which one I have. The one 'exception' is the 4 cases at the end, where both layers are different and each have a pair of mirrors, this is really split into 2 pairs of 2 mirror cases, they just look very similar. I don't like them. Bah. Yeah, technically something like fist/fist has the same problem, but it seems a little easier as they're the same shape so you can compare them with each other.

As for notation, I never understood why there's commas between the U and D moves. You can remove them and everything is still unambiguous, so I'm not writing them. Also, if the bottom layer turn is 0, I'm generally not writing it either. So /3/ = /(3,0)/.

Remember:
a cycle with an even number of pieces is an  odd permutation (and will have an  odd number of targets when traced BLD style)
a cycle with an  odd number of pieces is an even permutation (and will have an even number of targets when traced BLD style)


Tracing cycles + example
------------------------

Take my choice of piece ordering, numbered 1-8 in the obvious way,
YR YO YG YB WR WO WG WB,
which applies to edges and corners (taking the sticker CW of the W/Y sticker for corners), and the star/8 edges case. We go though the layers in a clockwise direction, starting with the 8-edge layer, and number the postions for corners and edges 1-8 in the expected way, and the solved position for each piece is considered to be the location of the same number. Here's one way of writing out what that looks like, where I keep everything separate:

reference scheme:
  cceeeeeeee/cccccc
e ..12345678/......
c 12......../345678

Scramble = 13/33/-45/06/33/01/-3-3/-2-1/42/0-2
  cceeeeeeee/cccccc
e ..31674258/......
c 58......../241376

I trace edges then corners, using the position numbering above, where a new buffer is in brackets if a cycle gets solved (I recommend using floating buffer to trace: it means fewer targets and it's not too difficult)

       edges corners
pieces 36245 75(2)86
count  12345 67   89
parity 10101 01   01

The (2) for the corner pieces is when the buffer YR(B) was solved and so switched to a new one, and the corner in position 2 is the first unsolved piece remaining. Some people prefer to count out the number of targets in inspection (1,2,3,...), I just think in terms of parity (1,0,1,...) which I pronounce (one,oh,one,...) because it's less effort than actual counting (even though that's really easy, it's still extra thinking!) and they both have only one syllable.

The count at the last target was then 9 or 1, depending on how you choose to think about it, thus we traced odd parity. The case (which will be covered later of course) has a 0 next to it, so the default solution will preserve parity and therefore give odd parity if we did that here - not surprising since we did a 6-cycle (which is an odd permutation) after getting to the case! Do a 6-cycle in either direction on D before solving in the obvious way going through scallops -> barrels -> kites -> done.


Now, what affects parity?

No effect:
1) Order of pieces as they are placed in the reference scheme. You want the red pieces before orange? Whatever. Rearrange this however you want, if you do the same for edges and corners (highly recommended), it has no effect.

2)
Using the CCW sticker on corners. Makes no difference, just pick one of CW/CCW and stick to it.


Possible effect:
1) Order of pieces in reference scheme. Say we had instead

  cceeeeeeee
e ..12345678
c 21........

because you want the corners the other way round. These differ by a 2-cycle relative to each other (solving to my scheme would have the YR and YO corners switched according to this new scheme, which is clearly an odd parity).

It might not make a difference though. For example, if you have a barrel case you can start with either pair of edges and either pair of corners, independently of each other. This is because changing from one to the other involved switching a pair of pieces, which is 2 swaps and thus an even permutation. I do this in solves without even thinking about it, it's really easy. If you have a layer with 3 corners, you can start on any of them and I'm pretty sure I use that in solves too for some cases, but I don't do it for 5 corner layers even though it still works.

2) Solving a case differently by default. Clearly, my default alg might switch parity and you prefer a different alg which preserves it, or vice versa).

3) 2 edges in one layer, 6 in the other. The edges don't matter. The edges and corners for all other cases don't matter - trace whichever layer you like first.

cceeeeeeee/cccccc
12        /345678

cceeeeeeee/cccccc
78        /123456

There's an example, those two choices above work the same way. But, for those 2/6 cases, switching the layers causes the corner parity you trace to switch too. I chose to start with the layer with 2 edges every time, you might prefer to start on the layer with 6 edges.



Shape names
-----------
'e' is an edge, 'c' is a corner (duh), and they run CW round a face. The pieces are listed in the order in which the reference scheme places the pieces, unless there is a capital letter, then start from there for that piece type (only one case I think, cecccEc). Names have been changed to be less stupid (hopefully).

4 edges
ecececec - square
ceceecec - kite
cceeccee - barrel
eeceeccc - shield
cccceeee - scallop
ecceeecc - muffin
cececeec - 112 fist [L]
ceececec - 211 fist [R]
eceeeccc - 13 paw [L]
eeececcc - 31 paw [R]

2 edges
eeccccc - U
ccccece - L
cecccEc - T

6 edges
cececeeee - 114
eeeeeeccc - 6
eeeceeecc - 33
ceecceeee - 042
eeceeeecc - 024
cecceeeee - 051
eceeeeecc - 015
eeceeecec - 123
ceececeee - 132
ceeceecee - 222

0 edges
cccccc - star

8 edges
eeeeeeeecc - 8
eeeeeeecec - 71
eeeeeeceec - 62
eeeeeceeec - 53
eeeeceeeec - 44


Example reference schemes
-------------------------
Here are some setups to cases with my reference scheme (thanks to sq1optim solver).

(4 edges per layer, start on top layer)

cccceeee/cccceeee
4/5/-3-3/21/0-4/02/-4/2/-24/6-2

ecececec/ecececec
4/3/-3-3/03/6

ceceecec/cececeec
0-1/-51/5/03/0-4/0-5/02/4/0-3/2/5/-33/

cececeec/ceceecec
/03/0-4/0-5/02/4/0-3/2/-43/-54/-12/-3-3


(8 edges on one layer, start on that one)
eeeeeeeecc/cccccc
0-4/-5/-3-3/-1/-2/4/-4/0-2/2/-2-4/-20

eeeeeeecec/cccccc
02/-33/-3/1/03/-4/-5/-3-5/0-2/-1/-4/30


(2 edges on one layer, start on that one)
eeccccc/cececeeee
-5/0-1/03/21/04/-2-3/52/-2/-2-2/02

eecccccce/ececeee
-2-3/-1/3/13/0-3/0-1/4/04/-42/3/2/-20


The cases
---------
All notes below assume my system of recognition and default algs. I'm hoping this serves as a good text guide to learning the system, and it's what I use when I haven't solved much for a while and forget stuff. Cases in a subset which have been covered previously are cross-referenced. If I say that a case switches or preserves, I'm talking about the effect the default alg has on parity, which is listed for each case anyway as per the format below. Other resources group cases differently, probably in a more sensible way since I put them in this order before I'd even learned cubeshape. No, seriously, I wasn't a squanner until I started learning this stuff, which meant I could do CSP for some shapes before knowing any good CS alg for others. Maybe I'll reorganise it one day ...

Format:
[case] [0 if default alg preserves parity, 1 if it switches parity]
[setup (invert for default)] - [alternative]
[notes]

subsets: stars, pairs, 0/1/2/7 movers, doublers, 3 movers, ULT (6/2 edges), square+kite, barrel, scallop, shield, muffin, fist/paw



Stars - [5]
-----------
These cases are easy to learn, and I think they're a good set to start with to begin to understand the ideas. You can change the parity on all of these by doing a 2 or -2 turn of the star face (or a 6 turn, maybe for corner control?), though it isn't necessarily the only way to affect parity. For me, 44 and 62 switch parity and the others preserve.

8 0
/-3-3/-2-1/42/ - 02/-4-2/21/33/
Be careful about where the front is. If you do 60 after the setup here it pretty much looks the same, so no difference right? Wrong. It's the same effect as 06, which clearly changes parity. Bear that in mind for the other cases below.

71 0
1-1/03/21/3-2/32/2/ - 02/-2/-3-2/-32/-2-1/0-3/
[cece]: One half of a layer, by how the layer gets separated when you perform the twist, in this case it's the right half of the top layer. That's just how I chose to execute, for this case it doesn't actually matter. How you align for the next slice does, as you have two choices: one involved turning both layers, one only turns one layer. By choosing [cece] I can turn one layer and be consistent with the default solution for L/6 (not yet explained). It wouldn't be consistent, but we get the same result if we solve with
1/2/32/...

62 1
/0-3/4-1/42/ - 02/-4-2/-41/03/
A simple case.

53 0
1-1/03/21/3-2/12/4/ - 02/-4/-1-2/-32/-2-1/0-3/
Not consistent with paw/scallop which we get after the first twist, but it's simpler and means that you can't accidentally screw up parity after the first twist. Going to SC/RC works just the same.

44 1
/-3-3/01/-2-2/ - 02/22/0-1/33/
Putting [eecee] for the 4/4 layer is default, nice and symmetrical. Do a 2 or -2 turn on this layer instead to get [eeeec] or [ceeee], which gives an equally optimal solution and they both work as an alternative alg. Can be useful for advanced solvers for this case to control stuff, also useful for other cases passing through this one. Be sure to mess around with this one so you get what's happening, it's good practice for getting your head around parity control. Try doing the setup, followed by 4/. Work out what you think should happen when you finish cubeshape, then check that you're correct.


Edges paired [10]
-----------------
Missing 3 cases since they're already covered. A larger but still fairly easy set to learn, some interesting stuff too, which is why it's here. shield/shield and barrel/(not barrel) preserve parity, the others switch by default.

barrels 1
/-3-3/ - 21/-22/2-2/-2-1/33/
Simple case, go to your preferred case with [ccc] on each layer to switch parity.

shields 0
/-3-3/0-1/ - -42/4-2/01/33/
[ccc] on each layer, which is one of the few intuitive ways to affect parity.

scallops 1
/-3-3/21/ - -22/2-2/-2-1/33/
[ccc] again.

barrel/shield 0
/33/1/2-2/2/ - 2/2/2-2/1/-3-3/
Notice the L shape of edge pairs on the left, and that the two ends of the L shape match the default alignment. I solve this by making the L (or mirror to get different parity), then essentially moving an edge pair to get shields. Alternatively, try doing -2/20 and -2/-20 after the setup and solving from there, and notice that this is also an option for solving the case. Then, pick your favourite solution, I guess.

barrel/scallop 0
/-3-3/0-1/4/ - /42/4-2/01/33/
Easy case.

shield/scallop 1
/-3-3/0-1/-22/02/ - 6/02/04/1/-3-3/
See BR/SD for details, Try doing 2/-1/... or 4/1/... after the setup, there's also 2-2/... which might give something you prefer. Go nuts.

U/2+4 1
042
/33/1/-22/ - 22/-2/12/-3-3/
024
/-3-3/-2-1/-2/ - 22/-22/1/-3-3/
I prefer to align the edge pair on the layer with 6 edges, which lets me know where to align the other layer so that I get 2 identical 4-edge layers with the first twist. This way, I can treat both these mirror cases as the same, as I've said I would do.

U/222 1
/-3-3/0-1/2/ - -22/02/0-1/33/
L shape of edge pairs on the left here, upside down as it happens, but the important thing is the ends lie on the correct tetrahedron. Mirror this to switch parity.

U/6 1
/-3-3/-2-1/4/ - 22/04/-2-1/33/
Align the lone pair of edges as required then create a group of 4 edges on each layer. Easy.

star/8 0 [stars]
star/62 1 [stars]
star/44 1 [stars]


<=2 move & antipode (0127) [4]
------------------------------
Remaining short cases of 2 twists optimal or fewer, also antipode which is 7 twists but it's 2-gen so actually not too bad. Solved and antipode preserve parity, the other two cases here switch.

cube 0
(0,0) (owlface!) (<,<)	/-3/4-1/2-2/-22/-41/3/ (^v^) [sorry]
This is either the shortest case or the longest. Your choice of short parity alg (7 moves is optimal), no need to preserve anything, but this is pretty much the best I think. Simon Crawdaunt agreed. I originally planned to trace this like it was a 3BLD if I ever got it in a scramble, but now I would trace it like I would for square/other_shape since that's what I've practiced on sq-1. For this, and a few other cases, it has been suggested to do parity-CP instead for bad parity, so that's worth considering.

kites 1
/ - -3/4-1/2-2/-22/-41/3/
Nothing happening here.

nice fists 1
/-3/ - 4-1/2-2/-22/-41/3/
Nothing here either.

kite/square 0
/3/1/-2/2/-2/1/ - 0-1/1/-2/2/-2/1/3
Speaks for itself really, just do the front/back mirror to get the alternative. Be careful when you have kite on bottom, you need to align the square the 'wrong way' round, you should understand if you think about it and have a go.

barrels 1 [pairs]


doublers [5]
------------
The rest of the cases where both layers are the same. Why not. The first 3 cases preserve parity, the last pair switch because they refer to a previous case which switches.

muffins 0
/-3-3/2/ - /01/-22/2-2/12/-3-3/
It's too close to cubeshape for anything fancy, not too difficult.

same fists 0
112
1-1/-3/-1/2/-2/2/ - 2-2/4/-2/2/-1/-3
211
/3/1/-2/2/-2/ - -22/-4/2/-2/1/3/
Put a [ceec] on the bottom right for default, top left for alternative, then align the other layer so you get a kite. You get a shield on top, with a 2-gen finish.

same paws 1
13
/-3-3/0-1/22/-1/ - /-1/22/12/-3-3/
31
/-3-3/-2-1/22/-1/ - /-1/22/0-1/33/
Get to the star/44 case, then pretend you had traced for the star/44 case instead of this. Not the only option of course, but what I suggest.

squares 0 [0127]
kites 1 [0127]
barrels 1 [pairs]
shields 0 [pairs]
scallops 1 [pairs]


3 movers [5]
------------
3 moves optimal cases not yet covered, so fairly short. Shield/square switches parity, so does scallop/kite which is notable for so many other cases being solved through it.

square/shield 1
/3/1/ - /0-4/-22/-22/4-1/0-3/
Not much to say about this, just pick your preferred case with a [ccc] on each layer.

square/muffin 0
/-3/-2/ - /6-1/2-2/-22/-41/3/
See above.

barrel/kite 0
/3/3/ - /42/2-2/-22/-41/3/
Same idea.

scallop/kite 1
/-3/-2-1/ - 2/2-2/2/-2-1/-3/
You can do the same as the above cases, but this is shorter (and optimal).

nice paws 0
/-3/4-1/ - 2-2/-22/-41/3/
This should be obvious by now.

shields 0 [pairs]
scallops 1 [pairs]


U [6]
-----
Remaining cases which have 2 paired edges in one layer. All preserve parity by default.

114 0
/-3/4-1/04/ - 22/4/4-1/0-3/
Just align it the right way. I found it helpful to note the relative position of the edge pair and the middle corner of the 3 in the other layer.

33 0
/-3/-2-1/03/-2/ - -4/-2/03/-2-1/-3/
Note the L shape of edge pairs on right, even though on the bottom they're triplets with one edge on the left. Try doing /-2/..., it gives the same result but it's not as nice I think.

1+5 0
051
/-3/-2-1/2-3/ - 04/-4/32/-2-1/0-3/
015
/-3/-2-1/-23/ - -4/4/-2-3/21/3/
Seems to be the best way to deal with bad parity as optimal requires an extra twist, basically you get to kite/scallop in 2 twists instead of 1. Align the 1+5 layer the same way every time, go straight to KT/SC for no parity, put the U edge pair in the wrong half so that it won't pair up with the 4 edges in the other layer after the first twist, and doesn't form a [ceec] block.

1+2+3 0
123
/-3-3/0-1/22/-1/2/ - /-2/-1/22/12/-3-3/
132
/-3-3/-2-1/22/-1/-2/ - /2/-1/22/0-1/33/
or
123
/3/1/-2-1/0-2/ - -2/-22/4/21/3/
132
/-3/-2-1/4/2-2/ - -2/-2/2/0-1/-3/
I like to think that the 123 cases are all weird. First two lines are easy but suboptimal. Here, you get to star/44, but instead of following that case, you turn CW for default and CCW for alternative. This should make sense if you recall what I wrote for that case. Optimal ... is weird. Align the 123 layer so that the edge pair will get cut in half, then half the layer will be [cece] or [ecec]. Look at the [ece] block of that half-layer, and pretend it's a full half-layer - align the edge pair from the U layer relative to that block. If you get to L/123, go to shield/square. It's confusing to describe, but set up the cases and try to follow it and it will hopefully make sense. Or do the 6-movers, which are much simpler.

6 [pairs]
2+4 [pairs]
222 [pairs]


L [10]
------
Going through all the 6/2 cases for some reason, here are the L cases. The 123 cases (the weird ones, remember?) switch parity, and so does 222, that weird round triangle thing.

114 0
/-3/-2-1/2/ - 2-2/2/-2-1/-3/
Yup.

6 0
/-3/-2-1/-23/23/ - 4-2/32/-23/21/3/
or
/-3/4-1/04/-12/ - 42/2-1/04/-41/03/
Even though it's 5 twists, you can't affect parity after the first twist. It's helpful to know what cases are 'safe' like this. An alternative is given, align L as usual and always do ±2±1 after the first twist.

33 0
/-3/4-1/2/ - -2-2/2/4-1/-3/
Just keep scrolling, just keep scrolling, scrolling, scrolling ...

2+4 0
042
/-3/4-1/04/-14/ - /3-2/4/4-1/0-3/
024
/-3/4-1/04/3-2/ - /-14/4/4-1/0-3/
There's two ways to align for the first twist that will take you to the same shape. It doesn't matter which one you do in terms of parity.

1+5 0
051
/-3/-2-1/4/ - 2/2/4/-41/3/
015
/-3/-2-1/-4/ - 0-2/-2/0-4/4-1/0-3/
You need 1 extra move for bad parity, this seems to be the best option: after the first twist move the layer with the edge pair instead of the usual aligning, which saves on thinking time.

1+2+3 1
123
1-1/3/-41/4/-22/ - -2-2/-2-1/1/3/
132
/3/1/-2-1/ - -2-2/-22/4/-41/3/
You have the easier option of going to U/114 every time and deciding parity there, this can save a move though. Align the edge of the L on one layer, then ignore the [eecee] block on the other layer and you have the same L shape remaining there: align this on the opposite side. For example, for the L/132 setup, this is the right side (top layer) and left side (bottom layer) respectively. If you get to U/114, don't align as usual, instead you turn both layers by 2 in the same direction (so 2,-2 or -2,2).

222 1
/-3/4-1/2/-1/03/ - 0-2/03/-1/2/4-1/-3/
/c
Align it correctly at the start. After 2 twists, you get to another case where you have to worry about which way you align, in this case do the shortest possible turn (which leaves the L where it is), then you don't have to think about aligning stuff in the middle of the solution.


T [10]
------
Last batch of 2/6 edge cases. 123 cases switch parity again using the default alg, this time the 114 case default also switches.

114 1
1-1/3/21/-4/-32/ - 0-2/-32/-4/21/3/
Simple case.

6 0
/-3-3/-2-1/42/-3/ - /-3/42/12/-3-3/
Easy, after the first twist, turn CW for default, CCW otherwise.

33 0
/-3-3/-2-1/-2/-21/ - 2/-21/-2/12/-3-3/
Aling at the star so that one pair of edges is in the same half as the [ecce] on the other layer, using the standard aligning rules. After 1 twist you get to U/2+4, and if you get to one of those when solving another case, scallops is the default solution.

2+4 0
042
/-3/-2-1/2-3/04/ - -4/32/-2-1/0-3/-11
024
/-3/-2-1/23/ - -4/4/2-3/21/3/
Align the isolated corner (the one between the edge groups) in the usual way, on the opposite side from the [ecce].

1+5 0
051
/-3-3/-2-1/02/5/ - /-14/4/1/-3-3/
015
/-3-3/-2-1/-2/0-5/ - /-41/0-4/0-1/33/
After the first twist, default is scallops, as with T/33.

1+2+3 1
123
/-3/4-1/2/5-2/ - /5/2/4-1/-3/
132
/-3/4-1/2/5/ - /5-2/2/1/-4/3/
You can tell where the L is going to be after the first twist and lookahead easily to where you need to align it. The other layer needs to be turned 5 or -5 accordingly.

222 0
/3/1/-2/2/03/ - /03/2/-2/1/3/
I suggest having a [eecee] block on the right, then most of the solution is 2-gen, even if it means 2-gen on bottom.


Square [6]
----------
Remaining cases with a square. All of these switch parity. This is pretty much how cases are organised from here. Except I'm changing it a little for square and kite, for reasons which should become clear.

barrel 1
/-3-3/0-1/22/1/-2-2/ - /22/1/-2-2/-1-2/-3-3/
You can affect parity on the first twist, but I suggest aligning the same way every time here according to the edge pairs, then following the star/44 solution.

scallop 1
/-3/-2-1/2/2/ - -21/2/2/-2-1/-3/
Align the L correctly at the start when it's still part of the square face, which is the same alignment as the edge block for the SC, then turn the 114 layer as required. Alternatively, you can go to L/1+5 with the same alignment at the start, but the solution isn't quite as nice.

fists 1; after kite
paws  1; after kite

cube 0 [0127]
kite 0 [0127]
shield 1 [3]
muffin 0 [3]


Kite (6)
--------
Unusual order here as stated, it helps to group some cases together here differently. Kite/shield stands out for me as a long-ish 2-gen case involved in even longer 2-gen cases, and it switches parity. The other 5 cases correspond to remaining barrel cases in the next set, of these: fists are the only ones which switch parity for kite and the only ones which preserve for barrel.

shield 1
/3/1/-2/2/ - 06/2/-2/1/3/
2-gen stuff.

muffin 0
/-3-3/-2-1/-2/02/-2-1/ - /2-1/02/-2/-2-1/33/
Pair up the edges. Then, there's only one sensible way to turn the shield layer, turn the barrel CW for default and CCW for alternative, then scallops as usual for going through U/2+4.

fists 1; after cross-ref
paws  0; after cross-ref

square 0 [0127]
kites 1 [0127]
barrel 0 [3]
scallop 1 [3]


[square|kite]/[fist|paw]
square/paws 1
13
/-3/-2-1/-2/01/ - /2-3/-2/-2-1/-3/
31
/-3/-2-1/2/-1/ - /3-2/2/-2-1/-3/
kite/paws 0
13
/-3/-2-1/2/3/ - /-1-2/2/-2-1/-3/
31
/-3/-2-1/2/-1-2/ - /3/2/-2-1/-3/

square/fists 1
112
/-3/-2-1/2/3/-4/ - /4/-1-2/2/-2-1/-3/
211
/-3/-2-1/2/-1-2/4/ - /-4/3/2/-2-1/-3/
kite/fists 1
112
/-3/-2-1/-2/01/2/ - /-2/2-3/-2/-2-1/-3/
211
/-3/-2-1/2/-1/-2/ - /2/3-2/2/-2-1/-3/

kite/fists 1 (alternative)
112
/-3/4-1/2/-1-2/2/ - /-2/-1/2/4-1/-3/
211
/-3/4-1/2/-1/-2/ - /2/-1-2/2/4-1/-3/
One big happy family of cases here. You're aiming for L/114. Paw cases are one twist away, fist cases go to paw cases from the other shape (e.g. square/fist -> kite/paw). Parity control is determined by the paw cases, that is, if you start with kite/paw or get there after one twist, the instructions are the same. For kite/paw align the L as per the usual rules, for square/paw the default is to not move the L and the alternative changes how it is aligned. Simple, right?


barrel [5]
----------
Barrel cases. As mentioned, parity is the opposite of the kite cases (fists preserve, others switch).

muffin 1
/3/1/-2/2/-23/ - 1/-34/02/0-2/01/03/
Figure out in advance where the kite has to be, then 2-gen finish.

fists 0
112
/-3-3/-2-1/-2/01/2/ - /-2/21/-4/0-1/33/
211
/-3-3/-2-1/2/-1/-2/ - /2/-1-2/4/1/-3-3/
Split up the edge pair on the fist, with the L edges joining up with an edge pair from the barrel. Then, scallops is default, and the easiest choice.

paws 1
13
/-3/-2-1/03/-2/0-1/ - /-41/-2/03/-2-1/-3/
31
/-3/-2-1/03/-2/-41/ - /0-1/-2/03/-2-1/-3/
or
13
/-3/-2-1/-23/-21/ - /-2-1/4/-2-3/21/3/
31
/-3/-2-1/-2-3/04/-2-1/ - /-21/3-2/-2-1/03/-11
6-movers, or optimal solutions which can save a move. Easy option: the first move doesn't change how the edge pair is aligned, so it's easy to look ahead to see if you will need to move it or not. For the other option, I don't actually suggest the same 6-mover as before, for recognition reasons. After the first twist, it's ±2±1. The ±1 depends on which mirror you have, the ±2 depends on parity: CW for default.

square 1 [square]
kite 0 [3]
barrels 1 [pairs]
shield 0 [pairs]
scallop 0 [pairs]


scallop [5]
-----------
In these last 4 sets, scallops and muffins (the food things) mean parity switches by default, the rest preserve. What? Don't look at me like that, it works. These 5 then switch parity by default.

muffin 1
/-3/-2-1/23/2/ - 41/02/23/21/3/
Align the group of 4 edges, have the group of 3 edges at the same end of the slice (in terms of front/back), with the [ecce] block on the same side as the group of 4 edges. Another way to control parity uses the same idea of essentially moving the edge pair on the muffin to form a kite, but you align the [ecce] as follows: bottom-right (equivalently top-left in this case) for default, then you just have to make sure the group of 4 edges is is the opposite half (right/left). For example, a default solution after the setup is 01/02/..., or -21/02/..., so a little bit more freedom for the first twist. You can refer to the alignment of the [ccee] or [eecc] edge group on the muffin instead to determine default, note that default then preserves parity though, but whoever heard of a scallop muffin anyway?

fists 1
112
/-3/-2-1/-23/0-3/ - 2-2/2-3/-23/-2-1/-3/
211
/-3/-2-1/2-3/3/ - -22/3-2/2-3/-2-1/-3/
[ceec] on the fist layer for default, and either [ccee] or [eecc] for the alternative, depending on the mirror.

paws 1
13
/-3/4-1/04/-1-4/ - /-3/04/4-1/-3/
31
/-3/4-1/04/-3/ - /-1-4/04/4-1/-3/
Only one way to do the first twist, and align as usual after that. You can, of course, use the fact that there's a [ccc] block on each layer, but that costs an extra move.

square 1 [square]
kite 1 [3]
barrel 0 [pairs]
shield 1 [pairs]
scallops 1 [pairs]


shield [5]
----------
As explained, the one with the muffin switches, the rest preserve.

muffin 1
/-3/-2-1/03/ - -2/-4/-2/03/-2-1/-3/
Weird one here. To swap parity, put an edge pair from the muffin into a layer by itself, then put it back the other way so you get back to shield/muffin. For the 4-mover you can go to kite/barrel instead.

fists 0
112
/-3/4-1/2/-1/ - /-1-2/2/4-1/-3/
211
/-3/4-1/2/-1-2/ - /-1/2/4-1/-3/
Not too bad, you should be able to see where to align after the first twist.

paws 0
13
/-3/-2-1/-23/01/ - 0-2/2/-1/-32/-2-1/0-3/
31
/-3/-2-1/2-3/-1/ - 02/0-2/1/-23/21/3/
There's only one 5-mover for good parity. Bad parity takes an extra move and has a few choices, but this is probably the best one.

square 1 [3]
kite 1 [kite]
barrel 0 [pairs]
shields 0 [pairs]
scallop 1 [pairs]


muffin [4]
----------
Blueberry please. Oh, right, they switch parity. I've said that already, pay attention. What do you mean, choc chip is better? Get out.

fists 1
112
/-3/4-1/2/-1/-4/ - /4/-1-2/2/4-1/-3/
211
/-3/4-1/2/-1-2/-4/ - /4/-1/2/4-1/-3/
Make a [ceec] block on the fist, combine with an edge pair from the other layer (doesn't matter which) to make a shield case.

paws 1
13
/-3-3/01/4/-2-1/ - /0-1/2/-1-2/-3-3/
31
/-3-3/-2-1/2/-1/ - /-1-2/4/1/-3-3/
The groups of 3 edges should overlap as much as possible, then scallops for default. Try /-3-3/01/4/-2-1/, 6-1/1-2/... for a different option, or make use of all possibilities for a nicer turns at the start, on average.

square 0 [square]
kite 0 [kite]
barrel 1 [barrel]
shield 1 [shield]
scallop 1 [scallop]


fist/paw [4]
------------
Damn chirality. You need to decide which set of mirrors you have. These preserve by default, and suck because they're the only cases where you can't ignore the handedness of the shapes. Learn these last.

LL/RR 0
112/13
/0-3/0-1/0-2/ - -2-2/04/-4/-41/03/
211/31
/0-3/4-1/0-4/4/ - -2-2/-2/-1/-3/

LR/RL 0
112/31
/-3/4-1/04/-4-2/ - /0-2/04/4-1/-3/
211/13
/-3/4-1/04/0-2/ - /-4-2/04/4-1/-3/

If they have the same handedness (for how I've chosen to label them), you look at an ece group in each layer. Have these on opposite sides (right/left) and align both of them as dictated by parity. If you get to U/114, move the U edge group and keep it on the same half of the layer. If you have the time to work it out in inspection, there's 3 different 4-move solutions if you get the good parity: shield/square, muffin/square, kite/barrel.

If the layers have opposite handedness, go to L/33 and align there as usual. You can of course go to U/114 for all cases, but this saves a twist when possible and is maybe less confusing (you need to follow different rules at U/114 depending on which set of mirrors you have, eugh).


Fun facts
---------
Wondering about the case distribution for extra moves needed for bad parity? Wonder no more!

0 62
1 18    scallops, shields, nice paws, shield/paw [4/5]
		barrel/scallop, U/1+5, L/1+5, barrel paw, T/2+4, L/123, bad fist/paw [7/13]
2  2    kite/scallop, shield/muffin
3  6    square/shield, square/muffin, kite/barrel, barrels, muffins, nice fists
4  0
5  1    kites
6  0
7  1    cube

I split up the 1 move extra cases into nice ones with [ccc] in each layer, and 'awkward' ones. 4 nice cases, 5 counting mirrors, and 7 bad ones, 13 counting mirrors.

That's an average of 52/90 (≈0.578) extra twists to solve parity, not bad!

The diameter of the shape space (most number of twists to get from one thing to another) without parity is 7, and the only pair of cases that far apart is square/square and kite/square. Including parity, the diameter is still 7. Turns out, that for the four cases of square/square and kite/square (both parities for each), it takes 7 twists to get from any one of those 4 to any of the other 3.

Including parity, and considering star cases to not have two distinct states because you can change parity without doing any twists, the largest set of cases where you can get from any one to any other in a single twist is 5: scallops (both parities), U/6 (both parities), and star/8. There are several such sets of 4 cases when ignoring parity.

The average number of twists to get from one state to another when considering parity is 3.088.
The average number of twists to get from a given state (chosen uniformly at random) to square/square (with a specified parity) is 4.914, which is worse than any other state!
It only takes an average of 2.463 twists to get to U/411 instead, which is the minimum, shape mod idea anyone?


More facts to come (maybe).


Good luck,
Matt

P.S. PCS is a much better acronym than CSP because of power crouch stabs in TLoZ OoT & MM, damn you all for putting the wrong one into common usage. At least it isn't the worst cube nomenclature, like PLL names or something.