# Advanced Square-1 Methods/Theory



## DavidWoner (May 23, 2009)

Edit: this is a work in progress, I failed and hit submit thread before I meant to. Bear with me.

So a few months back I started solving the square-1. Unlike the cubic twisty puzzles, I became very interested in the theory behind this puzzle. However, as I tried to learn/discover as much as I could, I soon found that the theory behind this puzzle remains vastly unexplored (or at least very hard to find). Quite luckily I had some very valuable resources available to me in the forms of some very experienced sq1 solvers like Andrew Nelson, Tomas Kristiansson, and Dan Cohen. Through talks with them and some good old-fashioned experimentation I was able to learn quite a bit, and I would like to share it here.

Some things I will talk about:

1. Beyond Vandenbergh: a few modifications of the Vandenbergh method that are undeveloped or rarely used. (You LBL people are on your own)

2. Turning Styles: I've noticed almost every solver uses one of 3 distinct turning styles, and I'd like to explain them and give examples. I know its not technically theory, but I think its very interesting and didn't want to make another thread.

3. Parity: An explanation of what parity is, how it works on the square-1, and why the parity algorithms work.


*1. Beyond Vandenbergh*
1.1 Parity CP
Parity CP is method where parity is determined along with corner permutation (instead of during EP), and then parity and corner permutation are solved at the same time. The main advantage of this method is that it only requires 8 additional CP algs, while eliminating the 50 parity EPs. Andrew Nelson is the only person known to use this, and I'd say he's been rather successful with it. His explanation and the algs he generated can be found here.

1.2 EOCP
EOCP does exactly what it sounds like- orients edges and permutes corners at the same time.
1.2.a Precursor
The idea that serves as a sort of precursor to this and eventually led to me thinking of this method is looking ahead to CP. A lot of good sq1 solvers do this, and I recently switched all of my EO algs to ones the preserve CP in order to make this easier. The algs themselves are actually faster than the ones I was using before, and having the extra lookahead helps a lot. But this got me thinking "If certain EO algs switch corners, and other don't, then certainly you should be able to solve EO and CP at the same time."

1.2.b EOCP
Now that I had this idea I had to determine whether or not it was actually practical. However there are lot of possible cases:

6*6 CP in each layer *6 orientation cases = 216 cases

However I soon realized that every case except for adjacent-adjacent can either be reduced to a single edge swap or solve EO with a simple M2 ((1,0)/(-1,-1)/). So with and M2 preface you would only need to learn 72 algs plus the 8 regular CPs.

1.2.c The Algs
Unfortunately most of the algs for this do not exist. A few of them do, in the form of the various EO algs floating around the internet, but the rest would need to be generated. The problem is that Jaap's solver has no was to ignore stickers, so to find the best algs 72 cases* 100 EPs = 7200 cases would have to be tested. Someone proposed writing a program that would determine and generate the inputs for these cases, but I have no idea how to do that. If an experienced programmer who is familiar with Jaap's Solver thinks they can help it would be much appreciated.


*2. Turning Style*
The only person who really falls outside these 3 groups his Kazuhito Iimura. His turning style is unique and rather difficult to emulate, so I won't really go into it here.
2.1 Beginner Style
This is characterized by lots of wrist turning of the D layer, and turning the U and D layers separately. Most notably / moves are always sliced clockwise with a lot of wrist movement. Most people will begin to properly fingertrick the U and D layers as they get faster, but the wristy / can stay with them well into the low 20 averages. I'm not going to bother finding an example, youtube is filled with videos of this. Chances are very good that you do this now or did so in the past.

2.2 Polish Style
This style is not exclusive to Polish square-1 solvers, but it originated from and is extremely popular there. The U and D layers are fingertricked normally, but whats notable is the / turn. All turns are still clockwise, but the wrist isn't used at all (it often doesn't move at all!) Rather, its turned with some combination of the thumb, ring, and pinky fingers that I have yet to fully figure out. The advantage of this is that there is very little regrip time, the right hand stays in its place allowing you to turn the U/D layers without a delay. Some good examples are Grzegorz Prusak and Piotr Padlewski of Poland and Lee-Seung Woo of Korea. 

2.3 Western Style
This is most common among Americans and some western Europeans. It is characterized by alternating clockwise and counterclockwise / turns, with varying sets of U/D fingertricks based on whether a cw or ccw / turn has just occurred. There is zero regrip time when you are alternating, which means some algs can be very fast. However, regrips are sometimes forced, like when a clockwise / is followed by (4,0) or something similar. In cases like these its common for only clockwise / turns to be used, but they can still be quite fast. Some good examples of this style are Dan Cohen, Stephanie Chow, all of my CPs, and Dan's Adj Parity.

*3. Parity*
3.1 What parity is
(most of what I'm about to say is rather incorrect, I should have known better than to talk about parity on 4x4) Parity occurs when there is an odd number of total swaps on the puzzle. Most people are familiar with parity as it occurs in the reduction method on 4x4. Oll parity is simply 2 edges that need to be swapped, and occurs when there has been an odd number of slice moves perform on the cube, hence the name parity. 

3.2 Parity on Square-1
Parity on square-1 is the same thing- an odd number of swaps. However, the way it occurs is different from on cubic puzzles. You may have noticed that solving parity is the only step that _requires_ you to leave cubeshape. This is because while in cubeshape, the square-1 more or less follows the laws of the 3x3 (i.e. no single swaps allowed!) However, when not in cubeshape, there is a lot more freedom and "The Laws of The Cube" do not apply (because its not a cube any more). I'll show you an example using one of the simpler parity algorithms, one of Andrews parity CPs:

/(3,3)/(1,2)/(4,-2)*/*(-4,2)/(-1,-2)/(-3,-3)/

The bolded red / is where the parity of the puzzle is changed, lets evaluate why. The first thing you may notice is that the shape of the puzzle does not change. This is usually a very good indicator of the point where parity changes. Now if you look closely, you can see that you are actually swapping three corners in the U layer with 3 corners in the D layer- which is three(an odd number!) of 2-swaps. More specifically you are swapping UFR-DBR, UR-DR, UBR-DFR. Then you solve cubeshape by undoing the setup moves you performed earlier. Once its back in cubeshape we can clearly see the results: 1 diagonal corner swap in the U layer and 2 diagonal corner swaps in the D layer- 3 swaps! Almost every parity algorithm generally follows ABA', where A leaves cubeshape, B changes parity without changing cubeshape, and A' solves cubeshape again. Sometimes orientation is disturbed, so I guess you could say they follow ABA'C, where C solves orientation if needed. Here are a few more examples, broken down into their components:

Opp-H: /(-3,-3)/(3,0)/(-3,-3)/(2,0)/( -4,2)/(4,-2)/(1,0)/(-3,-3)/
A: /(-3,-3)/(3,0)/(-3,-3)/(2,0)/( -4,2)
B: /
A': (4,-2)/(1,0)/(-3,-3)/

You probably noticed that A and A' are not inverses of one another. This is because we have taken the alg from earlier, and inserted and Nperm into A. As a result, some moves have been cancelled and A is inherently different from A' (it would be counter-productive to insert the same N perm back into A')

Here is another example, where B is face turns instead of a / move:

ccw O: /(3,3)/(1,0)/(-2,-2)/(2,0)/(2,2)/(-1,0)/(-3,-3)/(0,2)/(-2,-2)/

A: /(3,3)/(1,0)/(-2,-2)/
B: (2,0)
A': /(2,2)/(-1,0)/(-3,-3)/
C: (0,2)/(-2,-2)/

In this case, B is a clockwise 6-cycle, which is 5 swaps(think of BLD solving with Classic Pochmann, solving a 6 cycle uses 5 swaps) When back in cubeshape, you can see that 5 swaps have been performed: cw O (3 swaps) and H perm (2 swaps) resulting in a ccw O perm.

This was the first parity algorithm I learned, and I used it almost exclusively for a very long time. I noticed that this alg followed the ABA' formula and decided that the (2,0) in the middle of the alg had to be the secret behind parity. On a whim, I decided to do (-2,0) instead and discovered my very own clockwise O-perm without having to mirror the whole alg! (note that C changes to (1,0)/(2,2)/) At the time, I had no idea why it worked, but at least I figured out _how_ parity algorithms seemed to work. When I brought this up with Tomas, he pointed out that an odd number of swaps was wholly possible while out of cubeshape, and the final piece fell into place.

I am still not sure how some algs like adjacent parity work, I think there is an insertion somewhere that cancels with B. I'll look into it some more later.


----------



## Neutrals01 (May 23, 2009)

nice guide...the methods looks interesting...but the method I use don have relation with lars vandenbergh's...so I am not used to the concept flow of methods related to lars vandenbergh's...

I thought of a method before...now I am still searching algs for the method...only 5 parity algs needed...most cases have easy recognition and the method makes it such that can look ahead at many parts..total of 43 cases needed included the parity cases(only need to learn 41 algs because 2 of them can be done intuitively)...and many parts can be done intuitively so no need algs for them.. the advantage of this method is able to look ahead and also only have to learn 5 long algos(parity cases), other algs are short ones.. this method is for ppl that don like to remember lots of algs and prefer to do it more intuitively..(I think it can go down to 20 secs on avg...but I won't post this method up till I make sure it works well first, now still on experiment..)....

the fingertricks part..I think I am categorized as beginner style....I can't seems to get used to other methods of turning..

I avg around 32~35 now..played about 1 and a half month so far..


----------



## dougbenham (May 24, 2009)

Vault312 said:


> Posts: 1,337


Nice post count..



Valut312 said:


> 3. Parity: An explanation of what parity is, how it works on the square-1, and why the parity algorithms work.


Please write this! I am very curious on this subject.


----------



## blade740 (May 24, 2009)

Vault312 said:


> 2.1 Beginner Style
> This is characterized by lots of wrist turning of the D layer, and turning the U and D layers separately. Most notably / moves are always sliced clockwise with a lot of wrist movement. Most people will begin to properly fingertrick the U and D layers as they get faster, but the wristy / can stay with them well into the low 20 averages. I'm not going to bother finding an example, youtube is filled with videos of this. Chances are very good that you do this now or did so in the past.



Lars Vandenbergh solves with this style (or he did last I saw). 

Also, another thing I notice a lot is ALL turns being done with the right hand. The left hand pretty much stays right where it's at and the right hand does all the work.


----------



## Gabriel (May 24, 2009)

Isn't better to do CO + EO in one step and afterthat CP with the parity?

I think wrist movement mustn't be necessarily from amateurs, a good example is Kazhuito, yes, you've said his style is unique, but there are some down-layer's movements which aren't fast with the finger, I do finger D-face with turns of 1,2,3 (Vandenbergh's notation), but 4,5 and 6 I must perform them with a wrist turn.


----------



## qqwref (May 24, 2009)

I don't think CO+EO can be done completely in one step algorithmically, but if you build half of the D layer intuitively (this is quick, a few moves at most) it should be very possible to do the rest with an algorithm. After the half of D there are (I think) 2+2+2+16+12+2+12+10 = 58 non-solved algorithms. So actually it's pretty doable. Then CP+parity and EP would be a cinch.


----------



## prażeodym (May 24, 2009)

I think one of the best method is Lars + about 50 bonus EP.With this method you can solve edge without repring or doing /6,6/ before Ep."Polish style" I like it


----------



## Pedro (May 24, 2009)

> http://www.youtube.com/watch?v=knyoKSk0k2Q&feature=channel_page



WTF was that 11.16 solve?! The cube shape was done using just D layer moves, it seems 

if I make a video, can you tell me which style I use?
I'm averaging sub-30 normally, best RA is 23.93, but I still get some high-30 or even 40 times...I think I may be able to turn "better" and improve...


----------



## DavidWoner (May 24, 2009)

prażeodym said:


> I think one of the best method is Lars + about 50 bonus EP.With this method you can solve edge without repring or doing /6,6/ before Ep."Polish style" I like it



By Lars method + 50 do you mean all of the algorithms on his site plus the 50 mirrors?



Pedro said:


> > http://www.youtube.com/watch?v=knyoKSk0k2Q&feature=channel_page
> 
> 
> 
> ...



Yes there are quite a few 2-gen cubeshapes(there would have to be, otherwise bandaged sq1 would be impossible!), one of the better known ones is Opp-fists. The shape in the vid is passed through while solving opp-fists.
That one is /(0,-4)/(0,-1)/(0,-3)/


Ok, I am going to start writing the parity explanation now.

Edit: Done, let me know if things need to be clarified.


----------



## dougbenham (May 24, 2009)

Excellent parity explanation. Thanks 

and where can i find "Andrews parity CPs"? Does he have a website?


----------



## DavidWoner (May 24, 2009)

dougbenham said:


> Excellent parity explanation. Thanks
> 
> and where can i find "Andrews parity CPs"? Does he have a website?



I linked to them in the explanation.


----------



## Stefan (May 24, 2009)

The parity coverage doesn't exactly impress me.



Vault312 said:


> Oll parity is simply 2 edges that need to be swapped, and occurs when there has been an odd number of slice moves perform on the cube, hence the name parity.


Actually parity refers to the permutation of all pieces (of the same kind, in the same orbit, whatever you want to call it). So not just when you're left with two to swap. And it also doesn't refer to a number of moves. There is that direct connection between 4x4 edge permutation parity and the number of inner slice moves, but such a connection doesn't need to exist and the parity refers to the pieces, not the moves. And parity isn't just there when something is odd. When it's not odd, it's even. It's still there. It's not on or off. It's just cubers abusing the word, using it in a very reduced way.

You do say it the right way elsewhere, but you do link to that mathematical definition inside the sentence with the reduced version, so I felt like pointing that out.



Vault312 said:


> solving parity is the only step that _requires_ you to leave cubeshape. This is because while in cubeshape, the square-1 more or less follows the laws of the 3x3 (i.e. no single two-swaps allowed!)


Why not explain why? It's simple. Staying in cube shape (or rather double-square shape) through a / turn means doing four swaps (two edge swaps, two corner swaps) which is even. That's why the parity doesn't change. Done.



Vault312 said:


> /(3,3)/(1,2)/(4,-2)*/*(-4,2)/(-1,-2)/(-3,-3)/
> 
> The bolded red / is where the parity of the puzzle is changed


I disagree. When you do that /, the puzzle is far from cube shape. How do you even define parity there? How do you define parity for non-cube shapes?

I'd say the alg as a whole changes parity, thanks to the three swaps done with that /, in turn made possible with the proper setup. That / is indeed the whole idea behind the alg, but it doesn't by itself change the parity (unless you give me a reasonable definition of parity for non-cube shapes).



Vault312 said:


> Almost every parity algorithm generally follows ABA', where A leaves cubeshape, B changes parity without changing cubeshape, and A' solves cubeshape again.


Only "almost" every? I'd say every. Because you start and end with A=A'=/.

Also, you say A leaves cubeshape, so B starts out of cubeshape and I don't understand what you mean when you say B doesn't change cubeshape.



Vault312 said:


> You probably noticed that A and A' are not inverses of one another.


Then why do you call them A and A'? That's very misleading.



Vault312 said:


> B is a clockwise 6-cycle, which is 5 swaps


Wrong, it *can* be done with five swaps. I can also do it with let's say 7 or 41.

Finally: In your examples, B is always a single turn that represents an odd number of swaps. I'm quite certain there are parity-changing algs that don't contain any such turn.


----------



## qqwref (May 24, 2009)

StefanPochmann said:


> Vault312 said:
> 
> 
> > /(3,3)/(1,2)/(4,-2)*/*(-4,2)/(-1,-2)/(-3,-3)/
> ...



This is a very good point. I don't think there really is any reasonable way to define parity in cubeshape, except by maintaining a dictionary of specific optimal solutions for each cubeshape and then saying a shape has parity if the dictionary solution ends up with parity in cubeshape. That doesn't give us a way to easily tell when a turn 'creates' parity, though.

The way I would say ABA' works is that, since B does not change the cubeshape, you can express it as some cycles of the cubeshape pieces. In the short parity algorithm here, B does three corner 2-cycles, and the rest of the alg is to set up that algorithm so that it affects cubeshape only. While in a different shape the concept of parity is effectively meaningless, so we can only really create a useful parity algorithm by setting up the three 2-swaps so that they occur in cubeshape. 

Interestingly a lot of parity algorithms do seem to follow the ABA' formula (where B is a very short intuitive sequence which does not affect cubeshape, but does an odd permutation of the pieces), or else are a modification of some ABA' algorithm with a short algorithm or modification inserted at the beginning or end. There are also parity algorithms which do not follow this format, and seem to just do random moves that end up at cubeshape again... I don't claim to understand how those work.


----------



## DavidWoner (May 24, 2009)

StefanPochmann said:


> The parity coverage doesn't exactly impress me.
> 
> 
> Actually parity refers to the permutation of all pieces (of the same kind, in the same orbit, whatever you want to call it). So not just when you're left with two to swap. And it also doesn't refer to a number of moves. There is that direct connection between 4x4 edge permutation parity and the number of inner slice moves, but such a connection doesn't need to exist and the parity refers to the pieces, not the moves. And parity isn't just there when something is odd. When it's not odd, it's even. It's still there. It's not on or off. It's just cubers abusing the word, using it in a very reduced way.
> ...



Yeah I think I made the wrong decision to talk about parity on 4x4, knowing that I don't have a full understanding of it. Sorry.



StefanPochmann said:


> Vault312 said:
> 
> 
> > solving parity is the only step that _requires_ you to leave cubeshape. This is because while in cubeshape, the square-1 more or less follows the laws of the 3x3 (i.e. no single two-swaps allowed!)
> ...



Didn't think of that, its painfully obvious to me now though.



StefanPochmann said:


> Vault312 said:
> 
> 
> > /(3,3)/(1,2)/(4,-2)*/*(-4,2)/(-1,-2)/(-3,-3)/
> ...



Sometimes I am rather poor at articulating my thoughts in a manner that is clear to others. I think you knew what I was trying to say, even though I said it incorrectly. Explanations have never been a strong point of mine.



StefanPochmann said:


> Vault312 said:
> 
> 
> > B is a clockwise 6-cycle, which is 5 swaps
> ...



I fail to see how it is wrong. Perhaps we have differing definitions of "is." I would also say that is it 7 and 41 swaps as well.



StefanPochmann said:


> Finally: In your examples, B is always a single turn that represents an odd number of swaps. I'm quite certain there are parity-changing algs that don't contain any such turn.



Yes I am aware of this, and acknowledge that when I mention adjacent parity at the end. I think some parity algs may be short ones with with other algs inserted to change the final permutation. If the insertion somehow cancelled with B then it would be rather hard to find.


----------



## Stefan (May 25, 2009)

Vault312 said:


> I think you knew what I was trying to say, even though I said it incorrectly.


The statement with B not changing cubeshape is still unclear, and qqwref even used it the same way. Do you guys mean "puzzleshape" (so that the inverse of A can then return the puzzle to cubeshape)?



Vault312 said:


> StefanPochmann said:
> 
> 
> > Vault312 said:
> ...


Well, it's a 6-cycle, that's what it is. It isn't five swaps and it isn't seven swaps. It's in a way *equivalent* to certain five swaps and to certain seven swaps. Somewhat similar to a Ferrari not _being_ $50000, but maybe _being worth_ $50000. And maybe being worth $70000 to some.



Vault312 said:


> I think some parity algs may be short ones with with other algs inserted to change the final permutation. If the insertion somehow cancelled with B then it would be rather hard to find.


I think that's still not quite what I mean. I'm thinking of something fundamentally different from the setup-changeParity-undoSetup. Something like "leave cube shape one way, wander around, return to cube shape a completely unrelated way". Like instead of leaving the house's front door, doing some magic there, and returning through the front door, instead of that think of leaving the front door and returning through the *back* door and somehow get the magic done on your trip around the house.


----------



## Stefan (May 25, 2009)

Another way to put it:

Let me show you how to do an H perm on the 3x3x3. If you look at it closely, you see that the corners need to stay the same relative to each other, and the edges need to stay the same relative to each other as well. It's just that these two rings of four pieces need to be rotated relative to each other by 180 degrees. How do I do this? Easy as ABA'.

A = *M2 U2 M2*. This setup reverses the order of the edges.

B = *U*. This rotates the corners clockwise by 90 degrees, and the edges *counterclockwise* by 90 degrees (thanks to A), for a total of 180 degrees rotation of the two rings relative to each other.

A' = *M2 U2 M2*. Simply undoing the setup.

But... while this is one way to do the H perm, I think you'll agree that not every H perm has the form ABA'. You can do it very different ways. For example by randomly rescrambling the cube and starting the solve all over, hoping that this time you'll get a PLL that you know how to solve.

So you're describing *one* technique to come up or break down certain Square-1 parity algs, but probably not all.


----------



## qqwref (May 25, 2009)

StefanPochmann said:


> Vault312 said:
> 
> 
> > I think you knew what I was trying to say, even though I said it incorrectly.
> ...



Yeah. All parity algs need to start and end in cubeshape because that's the only way parity makes sense, and the easiest way to think of doing that is the ABA' format, which also seems to lead to the shortest possible parity algs. I don't think every parity alg can be written this way, but I wouldn't be surprised if most optimal or near-optimal parity algs can be thought of as C ABA' D (for non-parity algs C and D that maintain cubeshape).

As with your H-perm example, the reason we have to do this stuff for Square-1 is that it is a bandaged puzzle with pieces of different sizes, so there is no way to do parity directly - you have to go into a different shape. With a 3x3 it's pretty easy to do a 2-2-swap (M2 U2 M2 U2) which you can then set up into an H-perm, but to make a parity alg on Square-1 the only quick way to affect parity is to do a single move (with an odd permutation effect) while in a shape that permits that. So we have to set it up somehow in order to create intuitive parity algs (in the sense that you can understand what's going on), and possibly in order to create efficient ones too.



StefanPochmann said:


> It's in a way *equivalent* to certain five swaps and to certain seven swaps.



I'm pretty sure that is what he meant by "is".



StefanPochmann said:


> I think that's still not quite what I mean. I'm thinking of something fundamentally different from the setup-changeParity-undoSetup. Something like "leave cube shape one way, wander around, return to cube shape a completely unrelated way". Like instead of leaving the house's front door, doing some magic there, and returning through the front door, instead of that think of leaving the front door and returning through the *back* door and somehow get the magic done on your trip around the house.



Clearly there exist parity algs of this form, similar to 3x3 PLL algs that are the inverse of a move that starts at that PLL, scrambles, and re-solves. But, again, I have a hunch that the optimal alg for any specific in-cubeshape position with odd parity will be something of the form ABA' (perhaps with non-parity-affecting algs on one or both sides).


Can we have some more discussion about the EO+CO idea >_>


----------



## DavidWoner (May 25, 2009)

StefanPochmann said:


> Vault312 said:
> 
> 
> > I think you knew what I was trying to say, even though I said it incorrectly.
> ...



Yes puzzleshape would be a better word. I've gotten into the habit of saying cubeshape instead of "cubeshape case," or rather, the moves need to return the puzzle to cubeshape(describing the current shape of the puzzle).

And I see what you mean now about 6 cycle.

I knew thats what you meant are ABA' not working for all algs, and I would have to agree. I was being a bit stubborn earlier but now I've eaten and am in a much better mood. There is some sort of ABC where A leaves cubeshape, B cycles an odd number and changes cubeshape (not necessarily one move), C solves cubeshape and any orientation errors. In this case B will be rather tricky to discern given how hard it can be to track cycles over multiple changes in puzzleshape, but I'll continue playing around with it.

Edit: And I agree with Michael about every parity _case_ following ABA' with inserted C and D, not every _alg_ though. 

I would also like to add that you are rather good at making analogies.


----------



## DavidWoner (May 25, 2009)

Here, look at the algorithm for W perm:

(0,-1) / (1,-2) / (-4,0) / (0,3) / (1,0) / (3,-2) / (-4,0) / (-4,0) / (-2,2) / (-1,0) / (0,-3) / (-3,0)

First running through it I couldn't find any obvious ABA' format. Then I discovered a cancellation (like what I mentioned earlier) that makes it fit.

Let's break it down.

(0,-1) / (1,-2) / (-4,0) is an orientation (and permutation) fix, just put at the beginning


/ (0,3) / (1,0) / (2,-2) is a setup that leaves cubeshape

note that I broke (3,-2) into (2,-2)(1,0) with no /. These are the types of cancellations I am talking about.

(1,0)/ (-4,0) / (-4,0) / I believe this is B in this case. Here is its effect on the pieces:

I have lettered the corners A-G, starting with A at UBL and going clockwise around the U layer, and E-G going from front to back on the D layer. It performs the cycle:

A->F->D->C->E->G->B->A (equivalent to 6 swaps, doesn't affect parity)

And the 4 U-layer edges are all rotated counter-clockwise (O-perm, equivalent to 3 swaps, creates parity when puzzle is restored to cubeshape)

Note that as I have written it, B does not affect the shape.

(-2,2) / (-1,0) / (0,-3) / restores cubeshape.


I think this is the simplest example that has both a hidden cancellation and a B that is multiple moves.


----------



## qqwref (May 25, 2009)

Interesting. That's a very complicated explanation, but it makes sense.


----------



## deadalnix (May 25, 2009)

I think he's right with his red / and parity. We can think about permutation and parity on a non cube shape (but it's non trivial ).

Anyway, I think you should add some stuff about back to cube to be more complete.


----------



## blade740 (May 25, 2009)

Parity exists in non-cube states, obviously. It's defined the same as in cube shape, except that it's more difficult to define what "odd" and "even" parity are. (Or, restated, "whether or not there is parity"). A change in parity is the same no matter what shape the puzzle is.


----------



## Stefan (May 26, 2009)

I can't check the new example with the longer B, but from the description it's clear and that's indeed interesting and enlightening.

And yeah ok, I retract my earlier statement that that red / doesn't change the parity. Well, it *is* undefined unless you have a definition of parity in non-cube shapes, but I guess it would be the case with *every* such definition (except strange ones I don't want to get into now), so it's ok to say it in general without giving a specific definition.

To define permutation/parity for all shapes, not just cube shape, simply define a "correct permutation" for each shape. So for each shape and each piece, where the piece shall "belong" in that shape. Of course for cube shape you should define that all pieces belong where they make the puzzle solved. But for all other shapes, it can be completely random and unrelated to the definitions of other shapes.

After you have done this, parity of any given state is simply determined by comparing the given permutation with that of the defined "correct" permutation for the given shape.


----------



## prażeodym (May 26, 2009)

Vault312 said:


> prażeodym said:
> 
> 
> > I think one of the best method is Lars + about 50 bonus EP.With this method you can solve edge without repring or doing /6,6/ before Ep."Polish style" I like it
> ...


its 49 bonus algs.there aren't mirror in one of layer, for example if you have U perm in Up layer and H perm in down layer you have alg in the Lars page but if you have Hperm in Up and Uperm in down you must flip cube or go /6,6/.
// sorry , My English is bad


----------



## jazzthief81 (May 26, 2009)

Vault312 said:


> 1.1 Parity CP
> Parity CP is method where parity is determined along with corner permutation (instead of during EP), and then parity and corner permutation are solved at the same time. The main advantage of this method is that it only requires 8 additional CP algs, while eliminating the 50 parity EPs. Andrew Nelson is the only person known to use this, and I'd say he's been rather successful with it. His explanation and the algs he generated can be found here.


Very good idea, although I have to say that some of those algorithms look rather nasty compared to the regular CP algorithms which have nothing but 90 degree turns in them and are a lot shorter.

Some simple arithmetic reveals:
Normal CP takes [4.6|9.2] moves on average
Full EP takes [9.1|21.5] moves on average.
This adds up to [13.7|30.7] moves on average for those two steps combined.

Parity CP takes [6.6|14.8] moves on average
"Even parity" EP takes [7.3|18.2] moves on average
This adds up to [13.9|33.0] moves on average for those two steps combined.

So that's only a couple of extra moves and you have to learn only 8 parity CP cases instead of 25 odd parity EP cases (or 50 cases if you also learn them upside down). Not bad at all!

I'm a bit worried about recognition though.


----------



## blade740 (May 26, 2009)

Yeah, recognition is the part that turns most people off the method. I always did the classic "optimal" parity alg that messes up CP so I've always recognized before solving it. This method sort of evolved out of that. 

Also, sure the algorithms are nasty. But so are odd parity EPs. By learning 8 nasty algs, I skip the 50 nastiest.


----------



## deadalnix (May 26, 2009)

Or the recognition, here the way I do :
If you have an existing PLL on a 3x3x3 and a non existion, then go parity CP.

If you have two existing PLL or two non existing PLL, go standard CP.

You need to look 3 side to do this. I have worked a lot on 4x4x4 PLL, so I used to see this. But it's quite difficult at the bigining.

EDIT: And I don't want to learn 50 alg for edges permutations  With this I need 9 to solve this in two easy steps (including trivial cases).


----------



## jazzthief81 (May 26, 2009)

Vault312 said:


> 1.2 EOCP
> EOCP does exactly what it sounds like- orients edges and permutes corners at the same time.


I think this is the only point in the method where it makes sense to combine 2 successive steps. Solving other things as you make the cube shape seems very difficult and the EP step at the end already has enough cases as it is.

You could combine corner separation and edge separation in one step, but I'm not a big believer since corner separation is really only half a step that takes 3 twists at the very worst. I feel it's going to save you a couple of moves for learning many more cases and making recognition much more complex. I'm still curious to know the exact number of cases and their optimal solutions so I might look into this later.

Now as for EOCP, I've generated all states for Jaap's solver that have the corners already _oriented_ (I'll use that term since it's so commonly used ). For most of the 216 EOCP cases you have to generate 576 EPs though and not 100 EPs (this is true for the case where the corners are completely solved). I started running it on Saturday and it's now halfway. I've uploaded the input files and the script to run the solver in case you want to find them yourself:
http://www.cubezone.be/eocp.zip

Here are some nice algorithms for the case with 2 adjacent wrong edges in each layer (UF, UR, DF and DR):
(0,-4)/(0,-3)/(1,1)/(0,3)/(-1,3) (swaps no corners)
(0,4)/(0,-3)/(3,3)/(-2,1)/(-1,3) (swaps UBR-UBL and DFL-DBL)
(0,-1)/(3,3)/(-3,0)/(3,0)/(-2,-2)/(-1,0) (swaps UBR-UBL and DFR-DBR)
(1,0)/(3,0)/(-3,0)/(-1,-1)/(0,-3)/(0,3)/(0,1) (swaps UBR-UBL and DBR-DBL)
(4,0)/(3,0)/(2,2)/(3,0)/(3,-5) (swaps UFR-UBR and DBR-DBL)


----------



## cuBerBruce (May 26, 2009)

Start with a solved Square-1 and do: /(3,3)/(-1,0)/(2,2)/

This generates a star shape on the top layer. Let's say we define this position as having even parity for this shape. Now do (1,0). Now what parity do you have? 

(Arguably you can say the parity doesn't matter anyway, since it's not a twistable position.)


----------



## qqwref (May 26, 2009)

You can't do (1,0), because that's not a legitimate move. Asking what parity that is would be the same as doing a 45-degree turn on a 3x3 and asking what parity you have. The position simply isn't valid, so the question makes no sense


----------



## jazzthief81 (May 26, 2009)

cuBerBruce said:


> Start with a solved Square-1 and do: /(3,3)/(-1,0)/(2,2)/
> 
> This generates a star shape on the top layer. Let's say we define this position as having even parity for this shape. Now do (1,0). Now what parity do you have?



Easy peasy! 

What if you would do (0.5,0) instead? Now we're talking...


----------



## Dene (May 26, 2009)

deadalnix said:


> Or the recognition, here the way I do :
> If you have an existing PLL on a 3x3x3 and a non existion, then go parity CP.
> 
> If you have two existing PLL or two non existing PLL, go standard CP.
> ...



I think this is the only way to do it  . You just have to look at each layer and determine whether you have a PLL or not. My guess is that Tim Sun is the best at recognising this. I'm sure Andrew is a close second, but I'm just going to assume that because Tim is beast at so many puzzles, his recognition would be better than Andrew's.


----------



## cuBerBruce (May 26, 2009)

jazzthief81 said:


> cuBerBruce said:
> 
> 
> > Start with a solved Square-1 and do: /(3,3)/(-1,0)/(2,2)/
> ...



Easy? But you didn't give an answer.

I am wondering if it is sufficient to define the parity for a single position for each shape category (such as shield-right fist), and to be able to derive the parity for each twistable position that can be reached by only rotating top and bottom layers. My example shows this doesn't work if you want to include non-twistable positions (even if you restrict yourself to only multiples of 30-degree turns, of course).


----------



## DavidWoner (May 26, 2009)

StefanPochmann said:


> And yeah ok, I retract my earlier statement that that red / doesn't change the parity. Well, it *is* undefined unless you have a definition of parity in non-cube shapes, but I guess it would be the case with *every* such definition (except strange ones I don't want to get into now), so it's ok to say it in general without giving a specific definition.
> 
> To define permutation/parity for all shapes, not just cube shape, simply define a "correct permutation" for each shape. So for each shape and each piece, where the piece shall "belong" in that shape. Of course for cube shape you should define that all pieces belong where they make the puzzle solved. But for all other shapes, it can be completely random and unrelated to the definitions of other shapes.
> 
> After you have done this, parity of any given state is simply determined by comparing the given permutation with that of the defined "correct" permutation for the given shape.



Yes, thats what I had to do here. I just decided that my initial position would be "correct," then I labeled all the pieces and traced the effect of the B algorithm and determined whether or not the parity relative to the "correct" position had changed. However I'm not sure how to do this if shape changes, but I will continue my efforts to break down algorithms.



prażeodym said:


> its 49 bonus algs.there aren't mirror in one of layer, for example if you have U perm in Up layer and H perm in down layer you have alg in the Lars page but if you have Hperm in Up and Uperm in down you must flip cube or go /6,6/.
> // sorry , My English is bad



Oh sorry, I meant to say 49.



jazzthief81 said:


> Vault312 said:
> 
> 
> > 1.2 EOCP
> ...



Yeah I agree 1 look orientation just isn't practical. In my opinion, CO is just too simple to bother complicating. However you can do things like adjust by (-1,-1) during CO in order to orient some edges along with it, but I think that should be the end of it.

Thanks for taking the initiative with EOCP. If I can get the internet to work on my old desktop I'll set it up and start running it. I think my laptop gets turned on and off too much to run something extensive like that. Nice catch with there being 576 EP states, I forgot that while there is 100 cases they won't always have the correct A(U/D)F which will increase the number of states. 

I prefer (1,0)/(-3,0)/(-1,-1)/(4,1)/(-1,0) for the case that swaps no corners, but thats just me.

another adj-swap
(4,0)/(-4,0)/(-3,0)/(3,0)/(-3,0)/(3,0)/(-5,0)/(4,0) (diag swap on top, swaps right corners on D)

For single swap (UR DR) I know of:

(1,3)/(3,0)/(3,0)/(-1,-1)/(-2,1)/(-3,0)/(-1,-3) (no swap)
(1,0)/(0,-3)/(0,-3)/(-1,-1)/(4,-5)/(-3,0)/(-1,0) (BRU BLU, BRD BLD)
(1,3)/(3,0)/(3,0)/(-1,-1)/(1,4)/(3,0)/(5,3) (back corners on U, right corners on D

I'm sure more of these can be found just by playing around, or they are algs that people already use.

Whoa I also just noticed I haven't even mentioned bandaged square-1 (2gen), when I made a page about it months ago. Here it is: http://www.dtwoner.110mb.com/index.php?p=1_3_Bandaged-Sq-1


----------



## DavidWoner (May 27, 2009)

Oh I forgot to mention that Tomas and I decided the current standard for square-1 images (like on Lars' page) is a bit confusing for the bottom layer. Since D layer algs are recognized from the top we thought it would make more sense for the images to be viewed from the top as well. Also using arrows is a bit ambiguous for things like W and U perms, so we opted for images like this one:



I hope you aren't offended Lars.


----------



## qqwref (May 27, 2009)

cuBerBruce said:


> I am wondering if it is sufficient to define the parity for a single position for each shape category (such as shield-right fist)



Of course it is not, because this approach does not even work when you are in cubeshape! If the pieces are not sorted into their proper layers, you cannot just look at one layer and say "this is parity" and then look at the other layer and say "this is not parity". You need to look at them both and count cycles or whatever.


----------



## blade740 (May 27, 2009)

I think I know what he means. If you define a "solved" position for each non-cube shape, you can count cycles to find out the parity of every position in that shape. I'd suggest using (one of) the optimal paths to a solved position.


----------



## cuBerBruce (May 27, 2009)

qqwref said:


> cuBerBruce said:
> 
> 
> > I am wondering if it is sufficient to define the parity for a single position for each shape category (such as shield-right fist)
> ...



Well, of course you misunderstood what I meant. What I meant was that if you had the puzzle in a certain shape category and you define the particular position that you have to be a given parity, then can you still define the parity for all twistable ("legitimate" in qqwref's terminology) positions that are reachable just by rotating the top and bottom layer? This is a more basic issue than the question of being able to attempting to define a parity for all twistable positions of the same shape category based upon a single position within that shape category (when you are also allowed to exchange pieces between layers).

And counting cycles generally doesn't work when you have a layer that is rotated from the reference position. (But I think there may be a way of counting "swaps" that will work.)


----------



## qqwref (May 27, 2009)

Oh, well yeah, I proposed that on the second page, and I think someone else also did (Stefan?)


qqwref (post 13) said:


> I don't think there really is any reasonable way to define parity in cubeshape, except by maintaining a dictionary of specific optimal solutions for each cubeshape and then saying a shape has parity if the dictionary solution ends up with parity in cubeshape.



So my approach was, if you have a given shape, to solve it using a pre-decided optimal solution and say the original position had parity if the cubeshape position that you get has parity. But, however you like to define parity in non-cube shapes, you will need to write down 90 different things (which is hardly a natural definition), and then you have the problem that a turn (when not in cubeshape) can almost unpredictably either toggle parity or not.


----------



## cuBerBruce (May 27, 2009)

qqwref said:


> Oh, well yeah, I proposed that on the second page, and I think someone else also did (Stefan?)



Well, yours and Stefan's explanations were at least fuzzy with respect to dealing with non-cubeshape positions differing only in how the U and D layers are rotated. Do you count them as distinct shapes? Well, you need to count them as distinct shapes as far as possibly needing to do a specific turn of each layer so that the top and bottom layer shapes are properly aligned for the special alg to bring you to cubeshape.

Now it appears that if a layer shape has no rotational symmetries, then it should be obvious, in that parity determination method, on how to rotate the layer prior to performing the cubeshape alg. If a layer shape has rotational symmetries, but every symmetric rotation of the layer corresponds to an even permutation, then again, it shouldn't matter which position you pick out of the ones that are symmetric to the reference position's "orientation."

However if a layer has rotational symmetries corresponding to an odd permutation, then you need to be careful. However, it appears to me there are only two such layer shapes: CCCCCC and CEEEECEEEE. The first one (commonly called "star" shape) should not need to be rotated at all. The other one, CEEEECEEEE, will have two different "orientations" corresponding to the reference position, and they will differ in parity. Therefore, care must be used in how you rotate a CEEEECEEEE layer, prior to performing the alg for getting to cubeshape.

My "swap" counting idea is to allow swapping two edges, swapping two corners, or "swapping" a corner and an edge that are adjacent to each other. I am not clear if this actually works, but it seems that this could greatly simplify the procedure of determining parity if it works, as instead of many shapes, you would simply have to consider 6C/2C8E, 5C2E/3C6E, and 4C4E/4C4E cases.


----------



## Stefan (May 27, 2009)

cuBerBruce said:


> Well, yours and Stefan's explanations were at least fuzzy with respect to dealing with non-cubeshape positions differing only in how the U and D layers are rotated. *Do you count them as distinct shapes?*


Well... if they're distinct, then yes. If they're not, then no. Note I didn't speak about your shape "categories", I spoke about shapes, and I didn't speak of layer shapes but about puzzle shapes.

The only thing I see possibly missing/fuzzy in my definitions is the middle layer. So ok, choose one of the two middle layer pieces to use as reference.


----------



## Stefan (May 27, 2009)

cuBerBruce said:


> My "swap" counting idea is to allow swapping two edges, swapping two corners, or "swapping" a corner and an edge that are adjacent to each other. I am not clear if this actually works,


If I understand your idea correctly, I think it doesn't work. Look at the attached picture. As shown, you can get from the topleft state to the topright both with an odd or an even number of swaps of adjacent pieces.


----------



## deadalnix (May 27, 2009)

I have an idea to explan it, whatever is the definition of parity on non cube shape (But supposing it exist and have some standard parity property).

/(3,3)/(1,2)/(4,-2) is a move séquence with a given parity modification. (-4,2)/(-1,-2)/(-3,-3)/ is the reverse, so it have the same impact on parity. If the parity at the begining and the end of /(3,3)/(1,2)/(4,-2)/(-4,2)/(-1,-2)/(-3,-3)/ is different, so the parity after /(3,3)/(1,2)/(4,-2) and before (-4,2)/(-1,-2)/(-3,-3)/ must be different. We can deduce thet the / is the parity modificator.


----------



## qqwref (May 27, 2009)

Ah, very interesting catch, Stefan. I was trying to think of an example where that idea failed but I couldn't.


----------



## cuBerBruce (May 27, 2009)

Yes, my "swap" counting idea doesn't work as stated. Thanks for the counter-example, Stefan.

However, I think it fails because of allowing a swap to leave a corner straddling the front divider. Let's suppose you have no piece straddling the front divider (doesn't qqwref insist you can't allow that anyway?). Then you can list the pieces clockwise around the top layer starting from the front divider. Then continue listing the pieces on the bottom layer clockwise starting from the front divider. We now have a Square-1 position described as a permutation of 16 objects (pieces). Since the arrangement of pieces are now considered to be an actual permutation of 16 objects, parity should now be well-defined for any arrangement satisfying the above description. Right? And that is even a superset of positions qqwref would want to allow us to have the puzzle in.

I note under this definition of parity, (1,0) from the solved state would be odd parity although we haven't changed the puzzle out of square-square shape. But that's OK since it's not (literally) *cubeshape*. If we rotate the top layer to bring the puzzle back to *cubeshape*, we will have even parity again.


----------



## Stefan (May 27, 2009)

cuBerBruce said:


> Since the arrangement of pieces are now considered to be an actual permutation of 16 objects,


Well, it does give you a sequence of 16 objects, but I'd say to call it a permutation you also have to define their "correct" order (*). So that you can compare a given order with the correct order to determine the permutation. Any order will work as "correct order", and distinct shapes can use different "correct orders", though it might be nicer to have the same for all, and have it the order you get by reading your way from the solved puzzle.

(*) At least in order to determine parity. I just checked Wikipedia and the "group theory" definition comes closer to what I have in mind, speaking about a "bijection" rather than just a "sequence" as the "combinatorics" definition does. Btw, I find it interesting that neither the Wikipedia's nor Mathworld's article about "permutation" contains the word "parity". Edit 4: Well, Wikipedia does have a full article about Parity of a permutation. Which ... aha! ... says:

_"If any total ordering of X is fixed, the parity (oddness or evenness) of a permutation σ of X can be defined as ..."_

That's what I'm talkin' about...



cuBerBruce said:


> parity should now be well-defined for any arrangement satisfying the above description. Right?


Agree. Once you have properly defined permutation, parity comes for free.


----------



## cuBerBruce (May 27, 2009)

StefanPochmann said:


> cuBerBruce said:
> 
> 
> > Since the arrangement of pieces are now considered to be an actual permutation of 16 objects,
> ...



Well, of course I meant that the "correct" order (as you describe) would be the sequence you would get for the solved state of the puzzle. The thing is that you don't even have to care about shapes when using this definition of parity.(*) So naturally you don't have to specifically define a "correct" arrangement for each shape. What's even-parity for each shape is determined automatically. When determining parity by counting swaps, you can swap a corner with an edge if you want to, since you are only caring about the "ordering of pieces" rather than actual locations of pieces. I think this makes a lot more sense than rather arbitrarily assigning a separate parity convention for each shape.

(*) OK, you care about shapes when you're concerned about knowing what parity you'll get when going from some initial state to cubeshape. In this case, you have to know what parity effect the alg (for getting from the initial shape to cubeshape) has, or always choose even-parity algs for that purpose, for whatever piece-ordering method you use to define parity. You'll also want to rotate the top and bottom to set up the standard shape for the shape category before calculating the parity (assuming you want to use shape categories instead of hundreds of different puzzle shapes.) Well, actually, if you have 9 pieces in one layer, and 7 pieces in the other layer, you can't change parity (at least with this definition) simply by rotating the top or bottom layer.


----------



## qqwref (May 28, 2009)

cuBerBruce said:


> I note under this definition of parity, (1,0) from the solved state would be odd parity although we haven't changed the puzzle out of square-square shape. But that's OK since it's not (literally) *cubeshape*. If we rotate the top layer to bring the puzzle back to *cubeshape*, we will have even parity again.



If this result pops out of your definition of parity, then your definition is not a good one. In actual square-1 solving parity is a tricky case which must be resolved with an algorithm, not just something you can fix with a (1,0). So, you might have defined *one* way to think about parity on a Square-1, but your definition certainly does not mesh with the way solvers think about parity as it relates to a position in cubeshape, so it's not useful at all.


----------



## cuBerBruce (May 28, 2009)

qqwref said:


> cuBerBruce said:
> 
> 
> > I note under this definition of parity, (1,0) from the solved state would be odd parity although we haven't changed the puzzle out of square-square shape. But that's OK since it's not (literally) *cubeshape*. If we rotate the top layer to bring the puzzle back to *cubeshape*, we will have even parity again.
> ...



No, the point is if you go from one cubeshape to another cubeshape without a complicated algorithm, even with my parity scheme, parity is not changed. The problem I think is that you are thinking of any square-square shape as cubeshape.

To deal with your objections that my parity scheme does not treat parity the way solvers think about parity, you can choose a representative shape for each shape category (barrel-barrel, mushroom-kite, etc.). This can be done by defining an orientation for each layer's shape with respect to the front divider. Then, instead of using the actual position the puzzle is in for the purpose of calculating parity, you rotate the top and bottom layers (if needed) to get each layer's shape to be the same as the defined representive shape for that shape category. For example, for square-square shapes, you use cubeshape as the representative. For other shape categories you can pick one. But there is one layer shape where a 180-degree rotation of the layer is guaranteed to change parity (besides "star" shape that similarly has a guaranteed parity changes for certain rotations, but never requires to be rotated for purposes of matching a representative shape), so you have to treat such a case specially.

When you make this adaptation to my parity scheme, I believe it amounts to practically the same thing as your scheme. The differences I see are that in my scheme, you can calculate parity directly from the position without caring about the shape once you've aligned the layers to match the representative for the shape category; whereas with your scheme you must either perform your alg to get to cubeshape, and then check parity, or you have to check the parity against a dictionary of reference positions for each shape. (Using shape category representatives again reduces the number of algs or dictionary size.) Second, with my scheme the parity for any position matching the representative shape has its parity determined automatically without the need for defining any alg to reach cubeshape. With your scheme, you define an alg that gets the representative to cubeshape, and then define parity so that the parity of the representative is the same as the cubeshape position reached.

I haven't taken time to fully verify my scheme works as I believe it does, so if you can prove me wrong, then I welcome you to show me where I'm wrong.


----------



## qqwref (May 28, 2009)

cuBerBruce said:


> No, the point is if you go from one cubeshape to another cubeshape without a complicated algorithm, even with my parity scheme, parity is not changed. The problem I think is that you are thinking of any square-square shape as cubeshape.



That's not a "problem", that is just how we talk about parity when we solve Square-1. And any square-square shape IS cubeshape... often when solving Square-1 one or both of the two layers are misaligned a bit, but it is always square/square between algorithms. The reason your definition does not work is because nobody thinks that they are flipping parity when they misalign one layer of a Square-1 by 30 degrees. If your theory implies that this suddenly becomes odd parity, you've clearly gone in the wrong direction, because even without analyzing your theory in detail you have already found a contradiction (to the hypothesis that it models the actual way parity works on a square-1).

Remember that the original question was to tell us how Square-1 parity algs work, intuitively. If it takes quite a bit of work to tell if even a given position is odd parity - or if a given turn toggles parity - then the somewhat-arbitrary definition of parity that we have is clearly not going to help answer these questions. It is easy to simply declare which positions are odd parity but it is somewhat harder to make a definition which can help us understand parity algs.

In my opinion your approach is similar to the idea of trying to define a 3x3 corner orientation scheme other than the standard "U or D color on top or bottom" scheme. For instance maybe a piece in UFR is correct when the U/D sticker is on U, but the piece in UFL is correct when the L/R sticker is on L. Perhaps you can get such a scheme is mathematically consistent, but there is no point in using such an approach, because you are distancing yourself from the actual act of solving the puzzle. If your approach is not consistent with how we use the concept in real life, you cannot use it for real-world problems (such as "is this corner oriented?" or "do I have odd parity?") without making things much more complicated than they ought to be. A good way of defining parity, orientation, or anything else should be simple enough that you can quickly show every detail to a newcomer, and provide a concise argument for "why does this happen"-type questions.


----------



## cuBerBruce (May 28, 2009)

qqwref said:


> cuBerBruce said:
> 
> 
> > No, the point is if you go from one cubeshape to another cubeshape without a complicated algorithm, even with my parity scheme, parity is not changed. The problem I think is that you are thinking of any square-square shape as cubeshape.
> ...



Well the phrase "cube shape" means in the shape of a cube. If you perform (1,0) on a solved Square-1, it is no longer literally in the shape of a cube. Maybe that's why you write "cubeshape" as one word - to emphasize you mean something different than what "cube shape" (literally) means. I'll plan to avoid using "cubeshape" as one word in the future if I don't mean what you consider that to mean.

Let's look at square-square shapes. Each square layer, using 30-degree increments, has twelve possible positions with respect to the fixed middle layer piece. Four of these are non-twistable positions, so we'll disregard these immediately. This leaves 8 positions. Four of the remaining positions have the correct alignment with the fixed middle layer piece. The other four do not. I will call these correct positions and incorrect positions, respectively. If both layers are in the correct positions, then we can clearly determine the parity of the position by swapping edges with edges and corners with corners until we reach the solved state. We also see that if we rotate either layer a multiple of 90 degrees, we not only preserve the "correct" shape but we do not change the parity.

Now let's see what happens when we rotate a layer to an incorrect position. The edges in that layer now occupy a position formerly occupied by half a corner. We quickly see that we can not determine the parity of this position by swapping edges with edges and corners with corners. If we try to swap a corner with an edge, we have a problem because the corner doesn't fit in the space where the edge was. So we have a problem deciding what the parity of this position is.

So what do we do? Well, we think about the puzzle a little and first realize the puzzle can not be in the solved state if either square is in the incorrect position. We realize that we can get both squares in the correct position simply by rotating them until each of them is in one of the correct positions. Regardless of which of these possibilities we choose, we know that the resulting parity will be same. So what does this tell us about the parity of our present position? *Nothing.* But we do know that if we rotate the squares into correct positions (so that it has the possibility of being the solved state), the resulting parity is unambiguous. So in our usual concept of Square-1 parity if we are have a square-square shape, then we can pretend that the squares are in correct position, because we know we have to do that anyway to get the puzzle solved, and we can actually calculate the parity of that position. We have not proven that all square-square positions reached by simple rotating of layers *must* have the same parity. We have simply shown that we can *disregard* the actual parity of certain square-square positions (that we have a problem calculating the parity for anyway) because the actual parity for those positions _don't really matter anyway._

Now why not simply _define_ the parity of square-square shape positions to be the same regardless of how they are rotated? Well, we already know that there are cases where rotating a layer unambiguously _changes_ parity. That can happen with the star layer shape, for instance. So definitely we can not say _in general_ that we can rotate a layer and not change parity. I don't believe you can prove that rotating a square _must_ preserve parity, and I would also argue that I believe it is perfectly _valid_ to consider rotating one square layer into or out of "correct" position to always change parity.

Now I have attempted to explain parity in the Square-1 puzzle _based upon the definition of the parity of a permutation._ You seem to have "fudged up" a definition for Square-1 parity to fit your understanding of Square-1 parity. I believe your approach either is avoiding defining what the actual parity for (1,0) from the solved state position, or is simply defining it in a way that is not derived from the mathematical definition for the parity of a permutation. My approach defines a parity for that position based upon the mathematical definition of the parity of a permutation. As I have argued above, for explaining the usual Square-1 parity concept, neither my approach nor your approach _depends_ upon knowing what the parity for the (1,0) position actually is. Square-1 speedsolvers _care_ what the parity is when the squares are properly aligned, not what the parity is when the squares are not properly aligned. They don't need to actually align them to see what the parity will be when they are aligned.

I believe my approach, being based upon the actual definition of parity of a permutation, provides a more sound basis for extending the concept of determining parity for arbitrary shape positions. OK, my approach really has two parity concepts, a concept for calculating a specific position's "actual" parity, and secondly a way of relating that to how a speedsolver thinks about parity. I think my approach is able to provide a mathematically basis for explaining _why_ your approach works.


----------



## qqwref (May 28, 2009)

cuBerBruce said:


> Now I have attempted to explain parity in the Square-1 puzzle _based upon the definition of the parity of a permutation._ You seem to have "fudged up" a definition for Square-1 parity to fit your understanding of Square-1 parity. I believe your approach either is avoiding defining what the actual parity for (1,0) from the solved state position, or is simply defining it in a way that is not derived from the mathematical definition for the parity of a permutation. My approach defines a parity for that position based upon the mathematical definition of the parity of a permutation. As I have argued above, for explaining the usual Square-1 parity concept, neither my approach nor your approach _depends_ upon knowing what the parity for the (1,0) position actually is. Square-1 speedsolvers _care_ what the parity is when the squares are properly aligned, not what the parity is when the squares are not properly aligned. They don't need to actually align them to see what the parity will be when they are aligned.


I don't think you understand how this puzzle is solved at all. I also take offense to the fact that you are saying we have "'fudged up' a definition for Square-1 parity". It is not like Square-1 solvers have all gone "we are too dumb to understand parity so let's make a totally messed-up version for fun". We use a _different_ definition of parity than the one you seem to have made up on the spot and then revised every few posts while still insisting that you are correct.

Here's the way it works: parity is typically thought of as a situation that cannot easily be resolved. When I say "easily resolved" I am referring to the fact that a great deal of square-square positions can be reached without ever leaving square-square. In fact, believe it or not, *every square-square position that does not have "odd parity" (by our definition) can be reached without ever leaving square-square*, and odd parity cannot be fixed this way. (I can prove this, if you want.) Do you get it now? Our definition of parity was designed to show us which positions are nicely behaved, and can be reached by simple, short, intuitive move sequences. Hence if we do a (1,0) on a solved Square-1 it is still a non-parity position - we have not avoided defining this, but rather we have not bothered to explicitly say it because we thought it was obvious. Even if our definition might not be a mathematical definition of parity from the standpoint of a scrambled Square-1, we refer to it as a parity because from the standpoint of square-square it is _always an odd permutation of pieces_. Again I will repeat that our definition works and yet is different than yours. We _cannot_ learn anything about how to solve the difficult (odd parity) positions if we use a definition which says that we can create parity merely by doing a (1,0). I think you are repeatedly and stubbornly missing the fact that the problem we are trying to solve is not to merely _create a definition of parity_ - because it is a trivial matter to arbitrarily say "this is parity" - but to _create a definition of parity that helps us understand how to fix the difficult square-square positions_.

If you want to talk strict mathematical parity, let's first recall that the Square-1 is actually a bandaged puzzle, and that the real puzzle (often referred to as a Square-2 by twistypuzzles members) has 12 equally sized pieces on each layer. But the fact that we can do this means that _switching two corners (and only two corners) does not affect parity_. Similarly, switching two edges DOES affect parity. But what does this mean? Let's take a Square-1 and do (3,0). That does a 4-cycle of corners and a 4-cycle of edges on top. If you look at this as a permutation, you have created parity. Clearly this definition is as useless as yours. But it is mathematically sound! It is obvious that being mathematically sound is not the only criterion here.

Again: the problem we are trying to solve is not to merely _create a definition of parity_, but to _create a definition of parity that helps us understand how to fix the difficult square-square positions_.


----------



## Stefan (May 28, 2009)

Long (really long, guys!) story short:

Bruce is talking about a definition useful for talking about permutation/parity for all shapes, so that we can talk about them in non-square-square shapes. I do find it useful for the original discussion I started and that led here.

Michael is more concerned about the actual speedsolving and permutation/parity for the square-square shape. His parity definition for non-square-square shapes works just as well.

I think you're both right, just have different objectives. No need to fight and drown us in words. Now please hug.


----------



## DavidWoner (May 28, 2009)

And yet we are no closer to defining parity for non-square-square shapes. Bruce said in too many words what Stefan and I said in the beginning: To determine parity in non-square-square shapes you first need to assign a non-parity permutation to use as a reference. I had already put this into action with my analysis of W-perm before Bruce had even made his first post! I showed that the B algorithm changed the parity of the puzzle _with reference to the initial permutation._ I did _exactly_ what Bruce has suggested- I defined a non-parity permutation for a given puzzle shape, and determining changes in parity was easy after that.

If I am missing something and there is a difference between what I did and what Bruce is describing, then please point it out to me.


----------



## Stefan (May 28, 2009)

Vault312 said:


> And yet we are no closer to defining parity for non-square-square shapes.


You say that because we already have three functioning definitions so we can't get any closer, right?


----------



## DavidWoner (May 29, 2009)

StefanPochmann said:


> Vault312 said:
> 
> 
> > And yet we are no closer to defining parity for non-square-square shapes.
> ...



I don't quite get what you mean. My quoted statement explicitly says nothing of the sort, and it implies the exact opposite.


----------



## cuBerBruce (May 29, 2009)

Vault312 said:


> And yet we are no closer to defining parity for non-square-square shapes. Bruce said in too many words what Stefan and I said in the beginning: To determine parity in non-square-square shapes you first need to assign a non-parity permutation to use as a reference. I had already put this into action with my analysis of W-perm before Bruce had even made his first post! I showed that the B algorithm changed the parity of the puzzle _with reference to the initial permutation._ I did _exactly_ what Bruce has suggested- I defined a non-parity permutation for a given puzzle shape, and determining changes in parity was easy after that.
> 
> If I am missing something and there is a difference between what I did and what Bruce is describing, then please point it out to me.



Yes, the obvious sort of way to fix parity is to set up a position from which you can make a move that an odd permutation where it's clear that it's an odd permutation because it only swaps edges with edges, and corners with corners (and undo the setup). But my idea that I've been discussing of late is a method that would seem to allow you to directly calculate a parity effect for _any_ Square-1 move, not simply moves (or move sequences) that only swap like pieces. As qqwref points out, this doesn't match up exactly with the usual concept of Square-1 parity. At this point, this concept needs some further exploration.

(I had started working on a response to qqwref's post, but in light of other comments made, I may decide to simply PM my comments.)


----------



## Stefan (May 29, 2009)

Vault312 said:


> StefanPochmann said:
> 
> 
> > Vault312 said:
> ...


If you're already at the goal, not getting closer isn't so bad. So our statements are compatible, not opposite.

We already have three definitions: mine, Michael's and Bruce's. Did you miss them?


----------



## deadalnix (May 29, 2009)

Ok, let's start another point of the first post : the finger tricks.

I have a simple question : most of the cuber take the little part on the middle layer on the left (all of them ?). I use the big part on the left and find it much more easy to turn like this. I feel alone with this technique. Why everybody choose the little part on left ?


----------



## blade740 (May 30, 2009)

I hold the square-1 so that the seam is roughly straight forward ahead of me, rather than diagonal. See picture:







The position of my left index finger is MUCH more comfortable with the small slice on the left than on the right, my grip is tighter, and it's easier to fingertrick both U and D slices with the left hand.


----------



## deadalnix (May 30, 2009)

I see chat you mean. But do you think this is an objective observation ? 5I mean, it's a real question, not a rhétorical one). I feel quite insecure with my thumb on the little part, he's too big


----------



## qqwref (May 30, 2009)

I'm going to agree with blade740 here - my fingers are longer than my thumb, so when I hold the Square-1 it is nice to have a longer part for my fingers so they don't get in the way of a / turn. Otherwise the grip just feels uncomfortable.


----------



## blade740 (May 31, 2009)

deadalnix said:


> I see chat you mean. But do you think this is an objective observation ? 5I mean, it's a real question, not a rhétorical one). I feel quite insecure with my thumb on the little part, he's too big


Sure, I think it's an objective observation. I did a solve both ways and the other way requires me to hold the puzzle with more of an angle to my left hand. My thumb is a badass who stands wherever the hell he wants.


----------



## jazzthief81 (Jun 2, 2009)

To follow up on the edge orientation + corner permutation idea: I've finally worked out all cases with Jaap's solver and filtered them out. This text file lists for each case the 10 shortest solutions:
http://www.cubezone.be/square1eocp.txt

I used the letters O (no permutation), U, D, B, F, R and L to denote the permutation of the top and bottom corners. I used 0, 1, 3, 4, I and L to denote the "misoriented" edges in the top and bottom layer (should be clear what it means).

On average this would take [5.5|14.1] moves compared to normal EO ([4|9.9] moves) + normal CP ([4.6|9.2] moves).


----------



## deadalnix (Jun 2, 2009)

It look's scary  I think the numbers of case should be reduced to get more effiscient and more per case optimised. With edge permutation, a limit is reached I think.

Is theure any publication with finger friendly back to cube for all cases ?


----------



## mrCage (Jun 3, 2009)

You can use conjugation to define parity of any shape you like.

A B A'

A takes you into cube shape. (one or many turns)
B performs some parity algorithm within cube shape
A' inverse/rverse of A - takes you back to the original shape

Note that the parity algorithm B can not possibly make A' impossible, only similar pieces are interchanged.

Per


----------



## Stefan (Jun 3, 2009)

Per, I can always do that ABA' like you describe, so are you saying there's always (odd) parity?


----------



## DavidWoner (Jun 4, 2009)

jazzthief81 said:


> To follow up on the edge orientation + corner permutation idea: I've finally worked out all cases with Jaap's solver and filtered them out. This text file lists for each case the 10 shortest solutions:
> http://www.cubezone.be/square1eocp.txt
> 
> I used the letters O (no permutation), U, D, B, F, R and L to denote the permutation of the top and bottom corners. I used 0, 1, 3, 4, I and L to denote the "misoriented" edges in the top and bottom layer (should be clear what it means).
> ...



Thanks Lars that's fantastic! I'll start trying them out and hopefully find the best alg or two for each case over the next week or so, starting with 11 and LL. If I'm not too bored with it I'll even generate images for you.


----------



## chowmein (Jun 4, 2009)

the different turn styles are very intriguing! i'm tempted to try the polish way, but i don't think my cube is loose enough to permit such smooth / turns...


----------



## jazzthief81 (Jun 4, 2009)

chowmein said:


> the different turn styles are very intriguing! i'm tempted to try the polish way, but i don't think my cube is loose enough to permit such smooth / turns...



You have a style of your own, Stephanie. It looks like you're untangling your arms and in the process you magically solve the puzzle as well.


----------



## trying-to-speedcube... (Jun 15, 2009)

StefanPochmann said:


> Per, I can always do that ABA' like you describe, so are you saying there's always parity?


And how do you define parity? After I do a random scramble, I don't know if I have parity or not. Of course, I can do that ABA', but that changes the parity. You never know if it makes odd even, or vice versa.


----------



## joshuachan1995 (Jun 21, 2009)

sorry for inappropriately (since this is about theVanderbergh method)bumping on this thread but I was wondering if this idea was feasible

To begin with..I am using Jason Baum's LBL method albeit I perform Corner Permutation which means I do not have to execute full PLL for the LL instead i am left with edge permutations only.

On to the idea... I could determine parity while executing Step 3B of Jason's method which is solving the last 2 or 1 edge(s) on the bottom layer http://jmbaum.110mb.com/square1pages/step3b.htm

Most of the algos listed on that page is already in its pure form, affecting no other edges and corners in the whole puzzle. With that, if there was parity during step 3b, could I execute step3b along with correcting the top layer

I would go about generating algos if this idea doesnt sound that stupid. Btw, I would really appreciate if anyone had systems or ideas to improvethe LBL method


----------



## blade740 (Jun 21, 2009)

With 2 or 4 edges in the wrong layers, parity would be a bit difficult to determine. You'd have to count the cycles of pieces to see if you had it or not.


----------



## joshuachan1995 (Jun 22, 2009)

Identifying parity isn't really actually much of a hassle. Two edges on the bottom layer are already solved. Using a single alg from step3b will solve the last two... 

Take for example the top layer is orange and the bottom is red.
Since most of the algos provided by Jason Baum is already pure
I can easily determine where the red edges on the bottom will end up on the top layer, thus I can see whether there is a presence of parity

This algorithm here from Jason's website 

(1,0)/(0,-3)/(-1,-4)/(1,1)/(0,3)/(0,3)/(-1,0) 

actually has this effect
*(UR-DR)(UB-UF)*

If I identify parity on the LL, this algo comes in handy to prevent the parity from occurring,


Alternatively, if there is no parity I will use the pure form algo from Jaap's website being

(0,-3)/(0,3)/(1,0)/(2,-2)/(4,0)/(4,0)/(-4,4)/(0,1)/(0,3)/(-3,-1)/(1,-2)/(-1,0)

which has this effect
*UF-DF*

so yea i dunno if its possible to generate algos for this.


----------

