# Sq-1 parity + cubeshape (fully developed)



## bobthegiraffemonkey (Sep 16, 2014)

Hey everyone,

I've finally finished developing this, which is why I've been trying to drum up interest recently. I've started making the information available so people can learn it, I'll be trying to finish making a full tutorial when I have time, but it shouldn't be long before I cover most of the 'nicer cases'. I apologise that I'm better at making this stuff than I am at explaining it.

Quick text summary of the idea:
- Choose a reference scheme for each shape: pick where you want to consider the solved places for pieces to be, which is chosen on a layer basis rather than for each possible combinations of layers.
- Given a scramble, trace BLD style relative to this chosen reference. No need to memorise, you just need to know if there is an even or odd number of targets. Also, I want to emphasise that you DO NOT need to trace pieces through to cubeshape, you just need to look at where the pieces currently are.
- Use this even/odd answer to solve cubeshape in such a way that you have even parity at cubeshape (you can finish the solve without a parity alg). This is easy for many cases, but some are awkward.

Edit: These days I suggest the following resources.








http://pastebin.com/Xh3vSQFp

I feel that this can be done within inspection, with enough practice that the tracing can be done without thinking. As reasoning, it is fewer pieces than a 3BLD, with no piece orientations and no memo, and 3BLD memo can be done sub-10. There will be some time loss with recognising the shapes which is done a part of 3BLD, but that should be minimal. In the rare event of getting square/square in a scramble, just trace 'normally' since that's simple enough.

I have attached an Excel sheet with information. Unfortunately, it is currently full of my own shorthand notation, and many parts have no written explanation as yet. I have explained some of it in my video which discusses the first set of cases, and will explain the rest as I progress through that series. I might try to have written info or clearer notes at some point, but that will take time. If the format doesn't suit, I can probably provide something that will, such as a pdf. Note that I have some useful features in the Excel sheet that would be lost in a pdf.

Tutorial series

Currently covers 25/90 cases:
Cube [1/1]
Star (layer with only corners) [5/6]
Edges paired [10/16]
Optimal 0, 1, 2 & 7 [4/20]
Doublers [5/25]

I'm keeping track of my progress of learning this in my signature (which needs updating probably), I intend to learn the full system. I'll happily answer any questions here, and possibly answer some stuff in a short video if that would be helpful. I hope I can get at least one fast sq-1 solver to learn at least some of this, I can learn this and demonstrate it in competition, but I won't be getting any good times with it .

Edit: text document added, not finished yet but should be helpful. Fixed and re-uploaded Excel sheet, more errors than I care to admit and probably more I haven't found.

Edit 2: Should have fixed the info in the Excel sheet now. Guide is also complete, it doesn't give an in-depth description for every case as it would be quite repetitive, but it should be enough description to understand the full Excel sheet. The rest of the videos going through every case will be added gradually.

Edit 3: Updated the Excel file, all mistakes should be fixed, some cases improved, and I have example setups (via default alg) and alternative algs for every case. Don't try to learn just from these examples, use them as a reference.

Matt


----------



## Hssandwich (Sep 16, 2014)

Gogogo Andrew and learn some! Also, sounds like a good idea, I might learn some of it. (although I average around 55)


----------



## blade740 (Sep 17, 2014)

I am not nearly good enough at BLD to make this work. Someone should, though! I really like the idea. 

I'm not gonna lie, the excel file is half gibberish to me, but I'm trying to decipher it. It would probably make more sense if half of the headings weren't "stuff".


----------



## qqwref (Sep 17, 2014)

You are a crazy man. This is an insane idea and it will require an absolutely epic feat of memorization to learn all the cases + two algs per case + get it up to the point where you can consistently do it well within 15 seconds.

HOWEVER. I think I have an idea for how to make this easier to execute, and also to reduce the amount you have to memorize. Also there's no BLD tracing. It will still be ridiculous but maybe a little less so. I hope I can explain this properly. Here we go:


Spoiler



- Let's take the case cccceeee/cccceeee for simplicity of explanation. For each case, we choose a reference orientation, which means we pick a particular reference point on each layer - it will be the space between some two pieces. In this case I will choose the point in the very middle of the group of corners on each layer. It doesn't have to be that particular one, but the location of the reference points for a given shape should be the same every time.

- When you first see the cube, mentally turn U and D to line up those reference points with the / divider on the front face of the cube. When you are learning you can physically do the AUF/ADF, but it should be easy to do mentally once you get the hang of this. For some cubeshapes there are several ways of doing this; it doesn't matter which reference point you line up with the /, but make sure you stick with the same one throughout this procedure.

- Now that your puzzle is in a set arrangement, you want to calculate whether the pieces are in an odd permutation or an even permutation. How do we do this? The first step is to imagine the puzzle, not as two circles of pieces, but as an ordering of the 8 corners and an ordering of the 8 edges. You do this by going clockwise around U from the reference point, then going clockwise around D from the reference point. In our cubeshape example, the pieces form a cceeeecccceeeecc with each c or e representing some piece on your puzzle. For the corners, for instance, just take those 8 corners in that order, and ignore the edges.

(The hope is that when you are used to this you will be able to "skip" the mental steps of finding a reference point, turning the top and bottom layer, and figuring out the sequences of corners and edges on your puzzle. Basically you should be able to follow the rules and just see the ordering of the corners and the ordering of the edges in your mind.)

- For the next step of even/oddness we will define a canonical ordering of corners and edges. This will be something like: UFL ULB UBR URF DFR DRB DBL DLF and UL UB UR UF DF DR DB DL. This does not change based on the shape so over hundreds of solves you can get extremely used to it. You can give these pieces numbers 1-8 if you wish, and then instantly come up with a number when you see a given piece. I'll do that below.

- So, separately for the corners and edges, you want to compare that ordering of 8 pieces with the canonical ordering to determine if your ordering is an even or odd permutation. There are many ways to do this but one way is to count the number of transpositions. Imagine you want to make your order look like the canonical order, and you can only do it by swapping two pieces at a time. Count the number of times you have to do that. The permutation is even if and only if that count is even.

- Now add your two even/odd counts into a single count (even+even=even, even+odd=odd, odd+odd=even). Don't worry about whether you have parity or not, just worry about whether you have an even position or an odd position. For each shape, you just need two algs - let's call them the even alg and the odd alg - that will bring your puzzle into cube shape without parity.

So when you see a new scramble, here's what you'll do:
1) Figure out where to put your reference points.
2) For corners and edges separately, figure out the order of the pieces and compare that order to the canonical order to figure out if it's even or odd.
3) Add the two even/odds together, and perform the even or odd alg for this cubeshape. Done!



Here's a little example to help.
Scramble: (0,2)/(0,-5)/(0,-3)/(0,5)/(-5,0)/(0,-3)/(-1,0)/(0,4)/(-2,0)/(-2,2)/(4,2)
You'll notice this is the same cubeshape we did before. For the reference points you wanna do a (0,4) in your head. Now we figure out the corner and edge sequences:
- Corners: UFL ULB DFR DLB UFR DRB URB DFL, or in numbers, 1 2 5 7 4 6 3 8. One way to "solve" this is: swap numbers 3 and 5, then 4 and 7, then 5 and 7. That's 3 swaps, so this is odd.
- Edges: DF UL UR UF DB UB DR DL, or in numbers, 5 1 3 4 7 2 6 8. One way to "solve" this is: swap numbers 1 and 5, then 2 and 5, then 7 and 5, then 6 and 7. That's 4 swaps, so this is even.
Add odd and even together, to get odd. When you start your solve, you will do a (0,4) to bring the cube into the reference position, and then do the odd alg for this cubeshape. One possibility is (-2,2)/(2,-2)/(1,2)/(-3,-3)/. Finish the solve normally.

So all we need for each cubeshape is a memorized set of two reference points, and an even alg and an odd alg. For those who want to generate algs, if you set up a position in a given cube shape so that the corner and edge orderings are the same as the canonical ordering, the odd alg should produce parity and the even alg shouldn't.


----------



## bobthegiraffemonkey (Sep 17, 2014)

blade740 said:


> I am not nearly good enough at BLD to make this work. Someone should, though! I really like the idea.
> 
> I'm not gonna lie, the excel file is half gibberish to me, but I'm trying to decipher it. It would probably make more sense if half of the headings weren't "stuff".



Yeah, I know it's half gibberish. Once there's a short written guide and I've made a video for the second set of cases (maybe tomorrow) it will make more sense. I figured the first set was enough for people to get started with, as it's a small set of really easy cases.



qqwref said:


> You are a crazy man. This is an insane idea and it will require an absolutely epic feat of memorization to learn all the cases + two algs per case + get it up to the point where you can consistently do it well within 15 seconds.
> 
> (method idea)



Yes, I probably am. However, I will say that this is much easier to learn than it might seem.

1) I've got some 'rules' which help to standardise any choices about the default way of solving.
2) Many cases (70/90) have the two solutions being very similar, and usually differ in a standard way. The other 20 cases include, for consistency, the 4 cases that are less than 3 moves from optimal, so it's really only 16 'bad' cases (not necessarily that bad).
3) The knowledge of whether the default preserves parity or switches it can often be made easier by learning it for a set at a time. Consider the 'edges paired' cases (which aren't star cases). Shield/shield and barrel/not barrel preserve, and the rest switch. That's 10 cases already . Some sets are a little more awkward, several are very easy.

As for your method, it seems like a harder version of what I already have. Thinking about transpositions seems like a more clumsy version of what BLD tracing does, and fixing the position of each shape isn't necessary, you only need to fix the 'canonical ordering' as you call it, I'd rather just focus on where the layers need to be aligned to on a case/parity basis at the start of execution.


----------



## AvGalen (Sep 17, 2014)

[h=4]Members who have read this thread: 97[/h]

Pedro, 
Kirjava, 
blade740, 
Mike Hughey



I just came here to check that


----------



## qqwref (Sep 18, 2014)

bobthegiraffemonkey said:


> 2) Many cases (70/90) have the two solutions being very similar, and usually differ in a standard way. The other 20 cases include, for consistency, the 4 cases that are less than 3 moves from optimal, so it's really only 16 'bad' cases (not necessarily that bad).


Of course. I'd recommend this too. One of the two algs should be your typical cubeshape alg and the other is often going to be quite similar.



bobthegiraffemonkey said:


> 3) The knowledge of whether the default preserves parity or switches it can often be made easier by learning it for a set at a time. Consider the 'edges paired' cases (which aren't star cases). Shield/shield and barrel/not barrel preserve, and the rest switch. That's 10 cases already . Some sets are a little more awkward, several are very easy.


Ah, but with my idea you don't even have to care about whether the alg preserves parity or not. You just learn the odd and the even algs. If you already know full algorithmic cubeshape, then yeah, while you're learning you might have to keep track of which one is the alg you already use and which is a slightly-new alg. However, I think that once you learn the method, you will save valuable time by being able to do Odd Alg or Even Alg without worrying about whether this is one of the shapes that preserve parity or not. Especially since you see some shapes <1% of the time, having it just be algs ought to make it easier to remember.



bobthegiraffemonkey said:


> As for your method, it seems like a harder version of what I already have. Thinking about transpositions seems like a more clumsy version of what BLD tracing does, and fixing the position of each shape isn't necessary, you only need to fix the 'canonical ordering' as you call it, I'd rather just focus on where the layers need to be aligned to on a case/parity basis at the start of execution.


If my method seems harder, it's entirely possible I didn't explain it well enough, because it should make things easier. You (mentally) align the layers and then just follow the pieces to get your set of corners and set of edges, which you compare to a fixed ordering. No memorizing of an order per shape, no comparing a permutation you can see and a cubeshape-dependent one you are trying to visualize from memory. Tracing is hard enough when you know where the piece goes, but when its location is in one of a hundred things you memorized... that sounds tricky.

As for the transpositions, I was just describing one way of determining the parity of a permutation. As I'm sure you know, there are many ways. You could also trace the cycles BLD style (except using the numbers 1-8), with the parity of the permutation being the same as the parity of (number of cycles) + (number of solved pieces). Or you can add up, for each piece, the bigger pieces that are earlier than it. The point is not the transposition algorithm, but setting an order of looking at the pieces on the puzzle that is the same no matter what shape you have, and to set a "goal" permutation that is also the same every time and can even be used for indexing the pieces.


----------



## bobthegiraffemonkey (Sep 18, 2014)

OP updated with new Excel sheet (fixed some stuff), and text document explaining some notation (not finished yet but it's a good start, also an example at the end). Video for second set might come later today.



qqwref said:


> You just learn the odd and the even algs. If you already know full algorithmic cubeshape, then yeah, while you're learning you might have to keep track of which one is the alg you already use and which is a slightly-new alg.
> 
> ... which you compare to a fixed ordering. No memorizing of an order per shape, no comparing a permutation you can see and a cubeshape-dependent one you are trying to visualize from memory. Tracing is hard enough when you know where the piece goes, but when its location is in one of a hundred things you memorized... that sounds tricky.



Then you have to learn which is the even alg and which the odd alg, and there probably won't be a pattern for which is which between different cases. It's the same problem, just dealt with differently. I think it's easier to have some system for default algs and remember what the default alg does. Either system should work though.

I'm confused by the second part here. What's the difference between a fixed ordering and an order per shape? Sounds like exactly the same thing. I think we're doing almost the same thing here and I didn't explain it well enough. There's no need to visually align the layers in any way, the reference scheme is the same (I think you called this the 'canonical positions'). If I get cccceeee on the top layer, I put the first 4 edges (YR YO YG YB) in those positions (working clockwise) of the reference every time, and the same with the corners; if on the bottom layer it gets the last 4 instead. There is an example at the end of the written guide which might help to explain this. You also mention 'cubeshape-dependent',: I don't think about other shapes at all when I trace, I only consider the current scrambled shape.


----------



## Mike Hughey (Sep 18, 2014)

AvGalen said:


> I just came here to check that



LOLYes. I am a bit fascinated by this; I'm wondering if, with a small addition, I might be able to use my prememorized system for square-1 BLD slightly modified and get this almost for free. But I doubt I'll have time to work that out any time soon.


----------



## bobthegiraffemonkey (Sep 20, 2014)

Edited OP: Excel sheet *should* now be correct, written guide is finished. This should be enough for someone to learn all of this (or any subset of their choosing) combined with the videos covering the first 2 sets of cases. The rest of the tutorial vids will still happen though.


----------

