# [Help Thread]The "Square-1 Help / Alg Sharing" thread

#### Sam N

##### Member
Just idly doing some thinking solves - for easy cubeshapes (<= 3 twists), I can generally trace cubeshape + obl in around 30 seconds. Because of this, I think that CS+OBL is actually something doable in inspection, given quite a bit of time investment. My thoughts here are that one can (similar to Ty's suggestion on using something like Mike's sq1 bld cubeshape idea) fairly easily learn how to track what pieces go where for cubeshape - this is even "easier" than a fullblown version, since learning all the <=4 twist cases is only something like 30 total cases, and tracking a single slice or two should be easy enough to go with [given my above experiments]. Since you only need to care about OBL, you end up ignoring a lot of information that would otherwise be necessary for CSP.

Given this, I think a reasonable 2.5/3-look Square-1 method is CS+OBL -> PBL (CPP -> EP). I think this is good, because in my experience, the OBL -> CP transition is inherently worse than the EO -> CP transition, so the generally-cited downside of "extra time of inspection" for CPP is actually minimized a good deal. Plus, since you have to slow down anyway for the PBL recognition, like with CPP before, you get the easy benefit of having immediate use for any PBLs you _do_ learn - like learning COLLs when you already predict the CPLL after doing your normal OLL alg.

As confirmation of a previous point, full PBL does indeed take thousands of algs, 'tho only a small number of thousands - since there are 43 PLL cases with mirrors/inverses excluding the solved case, there are 44^2 - 1 = 1935 total PBLs. If you can guarantee that it's even parity, then it drops down by half, to 967, but that's still a bunch - somewhere between full ZBLL and full 1LLL, as a point of comparison (mirrors/inverses are generally much easier to learn on 3x3, because they flow better; Square-1 doesn't have similar luxuries, a lot of the time).

However, I think that CSP will become a much more attractive method given more research into it, and I hope that someone can figure out a good way to do that sub-12. I think CSP+OBL -> PBL is basically only an FMC technique at this point, and will remain so for at least a couple years, but I hope I'm proven wrong. Being able to 2-look a solve definitely feels pretty awesome, from experience
CSP is a very solid method. Given unlimited inspection I've been able to get sub 12 averages with it. The main issue is getting inspection down from personal experience. I'm not a great blind solver so that might attribute to this, but it seems possible to get it under 15 seconds. I feel that in the future someone will be able to get it down and use it in a competition and be quite successful with it. I know Bobthegirraffemonkey has been able to do this in competition before.

Last edited:

#### Hssandwich

##### Member
I'll agree that there are definitely mirrors (I wouldn't use that particular case, since they really solve the same PBL [like, I wouldn't consider R' U R' U' R' U' R' U R U R2 a different case from R2 U R U R' U' R' U' R' U R', since they're both the same U perm] - I'd compare things like / -3,0 / 3,3 / 0,-3 / with 1,-1 / -3,0 / 3,3 / 0,-3 / -1,1), but in general, there are much fewer mirrors because of the fixed orientation that Square-1 forces.
Oh yeah, I didn't really think before posting that example I forgot what the alg did.

#### not_kevin

##### Member
CSP is a very solid method. Given unlimited inspection I've been able to get sub 12 averages with it. The main issue is getting inspection down from personal experience. I'm not a great blind solver so that might attribute to this, but it seems possible to get it under 15 seconds. I feel that in the future someone will be able to get it down and use it in a competition and be quite successful with it. I know Bobthegirraffemonkey has been able to do this in competition before.
Sorry, I wasn't clear in my post - I'm in no way doubting the power of CSP. Of all of the places parity is dealt with, it's clear (at least, in my head) that CSP is by far the best place to do it. However, I'm still skeptical in its consistent sub-15 ability in inspection, especially since the biggest payoff, I imagine, would be to guarantee all bad cubeshapes to have no parity (eg, if it's a cubeshape skip, I'd probably just use my 15 seconds to get OBL + figure parity, and solve parity during CPP, rather than doing 6 twists just to deal with parity, and then have relatively little info on how to continue the solve). Plus, I'm imagining that CSP crowds out the ability to really use anything else in inspection, since simply tracing the cycles, without thinking about what that does to the solve other than parity, likely takes a good chunk of time.

To clarify, then, I think there are 2 strong/doable/etc. 3-look Square-1 methods: CSP -> OBL -> PBL and CS+OBL -> CPP -> EP. Of these two, I think the latter is easier, and (very vitally, I think) is easier to transition into a 2-look method - based on my musings above, I think combining CPP with EP into full PBL is easier than combining CSP with OBL recognition. But again, I hope I'm proven wrong, because as I said before, CSP is by far the most interesting and high-potential still-in-development method, to me, even more than PBL (sorry Lid). I'd love to see a day where people can actually realistically 2-look solves in competition, unlike my current ~0.3% ability to do that (a cubeshape case I can predict to OBL, an OBL case I know [aka, not one of the 4 opp/opp cases I don't know], a PBL I know [I know about 10% or so]).

Oh yeah, I didn't really think before posting that example I forgot what the alg did.
Don't worry - you made your point

#### bobthegiraffemonkey

##### Member
However, I'm still skeptical in its consistent sub-15 ability in inspection
Timed some inspection just to see how well it would go, 11.88 AO12:
1. 10.04
2. 12.89
3. 13.38
4. 12.10
5. (DNF(11.83))
6. 12.74
7. 11.48
8. 12.67
9. (8.78)
10. 11.59
11. 9.34
12. 12.56

Cubeshape wasn't always particularly fast because I suck at some cases, the DNF is when I messed up parity from rushing too much, and obviously it will take a little longer to do in official solves. However, I can definitely do this faster with more practice, so overall I'm convinced it can be done. Whether you can recognise anything else at the some time I don't know for certain - because I've never tried looking for anything else in inspection, but I'd guess at least CO prediction would be doable.

#### not_kevin

##### Member
Timed some inspection just to see how well it would go, 11.88 AO12:
1. 10.04
2. 12.89
3. 13.38
4. 12.10
5. (DNF(11.83))
6. 12.74
7. 11.48
8. 12.67
9. (8.78)
10. 11.59
11. 9.34
12. 12.56

Cubeshape wasn't always particularly fast because I suck at some cases, the DNF is when I messed up parity from rushing too much, and obviously it will take a little longer to do in official solves. However, I can definitely do this faster with more practice, so overall I'm convinced it can be done. Whether you can recognise anything else at the some time I don't know for certain - because I've never tried looking for anything else in inspection, but I'd guess at least CO prediction would be doable.
Hm, okay - that convinces me a lot more in its potential. My intuition at the time said that it would take a lot of work to get consistently sub-15, so that's cool. I think a safe point would be to be consistently sub-10 at home, to safely do this at comps without a bunch of +2s (certainly at this level, a +2 is worse than just doing parity). I'll try to find some time to really dig into your resources, and see if I can start speaking from experience on CSP soon

#### blade740

##### Mack Daddy
Im not saying that you track the permutation: I'm saying you use a system like Mike Hughey's sq1 bld system so that you know where the pieces end up after cubeshape. It seems like you read it as you learn algs for all the cs+OBL cases, but what I'm saying is that you learn 2 algs for every cubeshape case (1 for parity and 1 for no parity) and then you figure out how each of those algs effects the rest of the pieces. Then, once you get to your solve, you would inspect to see if you have parity, figure out which of your 2 cubeshape algs you're gonna use, and then recall how that alg affects you're pieces so that you can know the OBL case.
I understood what you're getting at... I simply think this is incredibly difficult for a method which saves no moves at all (compared to regular old CSP -> OBL, that is). Even then, I'm not convinced that's it's even possible to "trace" the permutation through one of 180 cubeshape algs and actually know what the OBL case will be before you see it. All in 15 seconds. And then parity on top of that? I'm still not 100% sure that CSP in and of itself is really feasible, what you suggest is not possible IMO.

As for the discussion about mirrors: there are two different ways to mirror Sq1 algs:

Mirrors along the Y axis (U/D mirrors) are very easy, I do them on the fly all the time no problem. You just take each ordered pair, reverse the order, and invert each number (so (2,-1) becomes (1,-2), etc). If you know your algs by muscle memory, this can be done without even thinking about it.

Mirrors along the X/Z axis (F/B and L/R mirrors) are much more difficult to do during a solve. Basically what you need to do is reverse the order of every other pair. So for example:

/ 3,0 / 1,0 / 0,-3 / -1,0 / -3,0 / 1,0 / 0,3 / becomes
/ 0,3 / 1,0 / -3,0 / -1,0 / 0,-3 / 1,0 / 3,0 /

This is easy enough to do "on paper", but much more difficult, in my experience, to do on the fly.

#### TMarshall

##### Member
I understood what you're getting at... I simply think this is incredibly difficult for a method which saves no moves at all (compared to regular old CSP -> OBL, that is). Even then, I'm not convinced that's it's even possible to "trace" the permutation through one of 180 cubeshape algs and actually know what the OBL case will be before you see it. All in 15 seconds.
Bindedsa can recognize 8 pieces for zbll consistently under 2 seconds. Obviously, as you add another 8 pieces, it becomes much more difficult. However, you have 15 seconds. I can figure out how I'm gonna do my cubeshape in 3 seconds for the worst cases. That still leaves you with 10 seconds to figure it out (I'm taking out about 2 seconds for putting the cube down and starting the timer). There is no doubt in my mind that you can figure out where 16 pieces will end up in 10 seconds with a bit of practice.

And then parity on top of that?
Obviously this is where it starts to get iffy. However, practically any cubing "barrier" that people have set before has been broken. While I think it would take someone incredibly committed, I do think that this is possible to do in under 15 seconds. However, neither of us have any sound evidence for our sides, so we really can't prove it one way or another.

I'm still not 100% sure that CSP in and of itself is really feasible
Just two posts ahead of you, a person proved that they could do parity+cs in under 15 seconds.

#### Sam N

##### Member
Sorry, I wasn't clear in my post - I'm in no way doubting the power of CSP. Of all of the places parity is dealt with, it's clear (at least, in my head) that CSP is by far the best place to do it. However, I'm still skeptical in its consistent sub-15 ability in inspection, especially since the biggest payoff, I imagine, would be to guarantee all bad cubeshapes to have no parity (eg, if it's a cubeshape skip, I'd probably just use my 15 seconds to get OBL + figure parity, and solve parity during CPP, rather than doing 6 twists just to deal with parity, and then have relatively little info on how to continue the solve). Plus, I'm imagining that CSP crowds out the ability to really use anything else in inspection, since simply tracing the cycles, without thinking about what that does to the solve other than parity, likely takes a good chunk of time.

To clarify, then, I think there are 2 strong/doable/etc. 3-look Square-1 methods: CSP -> OBL -> PBL and CS+OBL -> CPP -> EP. Of these two, I think the latter is easier, and (very vitally, I think) is easier to transition into a 2-look method - based on my musings above, I think combining CPP with EP into full PBL is easier than combining CSP with OBL recognition. But again, I hope I'm proven wrong, because as I said before, CSP is by far the most interesting and high-potential still-in-development method, to me, even more than PBL (sorry Lid). I'd love to see a day where people can actually realistically 2-look solves in competition, unlike my current ~0.3% ability to do that (a cubeshape case I can predict to OBL, an OBL case I know [aka, not one of the 4 opp/opp cases I don't know], a PBL I know [I know about 10% or so]).

Don't worry - you made your point
I didn't think you were doubting it at all. I was just agreeing with your point that CSP has a lot of potential. I feel it's one of the next milestone in square-1.

Hm, okay - that convinces me a lot more in its potential. My intuition at the time said that it would take a lot of work to get consistently sub-15, so that's cool. I think a safe point would be to be consistently sub-10 at home, to safely do this at comps without a bunch of +2s (certainly at this level, a +2 is worse than just doing parity). I'll try to find some time to really dig into your resources, and see if I can start speaking from experience on CSP soon
When it comes to a +2, i find that it would be pretty hard to actually do that. If you're nearing the 15 second mark and you are not close to finishing your inspection for CSP, you can always just bail and solve it normally. I feel that CSP is pretty great in that sense.

#### not_kevin

##### Member
I understood what you're getting at... I simply think this is incredibly difficult for a method which saves no moves at all (compared to regular old CSP -> OBL, that is). Even then, I'm not convinced that's it's even possible to "trace" the permutation through one of 180 cubeshape algs and actually know what the OBL case will be before you see it. All in 15 seconds. And then parity on top of that? I'm still not 100% sure that CSP in and of itself is really feasible, what you suggest is not possible IMO.

As for the discussion about mirrors: there are two different ways to mirror Sq1 algs:

Mirrors along the Y axis (U/D mirrors) are very easy, I do them on the fly all the time no problem. You just take each ordered pair, reverse the order, and invert each number (so (2,-1) becomes (1,-2), etc). If you know your algs by muscle memory, this can be done without even thinking about it.

Mirrors along the X/Z axis (F/B and L/R mirrors) are much more difficult to do during a solve. Basically what you need to do is reverse the order of every other pair. So for example:

/ 3,0 / 1,0 / 0,-3 / -1,0 / -3,0 / 1,0 / 0,3 / becomes
/ 0,3 / 1,0 / -3,0 / -1,0 / 0,-3 / 1,0 / 3,0 /

This is easy enough to do "on paper", but much more difficult, in my experience, to do on the fly.
Oh, that makes sense. But yeah, difficult to do on-the-fly (and I admit I'm pretty bad at doing U/D mirrors on the fly - too much muscle memory, and way too much preference to U-layer turns).

As a side note, I really like the inverse of the second alg you posted (bar-on-back ccwU): -1,0 / -3,0 / -1,0 / 0,3 / 1,0 / 3,0 / -1,0 / 0,-3. Not sure if it's faster than double J/J, but it might be for me

When it comes to a +2, i find that it would be pretty hard to actually do that. If you're nearing the 15 second mark and you are not close to finishing your inspection for CSP, you can always just bail and solve it normally. I feel that CSP is pretty great in that sense.
Mm, that is a good point I didn't consider. I think it still doesn't "beat" CS+OBL, 'tho, since it has the same "failure case" - if you can't figure out the OBL in time, then just do the CS as usual - and any partial info you have could be used. For some easy cubeshapes, I'm currently doing CS+CO in inspection, essentially.

EDIT: it doesn't "beat" CS+OBL in terms of inspection advantage, not in terms of actual solve benefit. I do think that CSP has more of an effect on the solve than CS+OBL.

Last edited:

#### guysensei1

##### Member
Is there a better opposite parity alg than
/ (3,3) / (-1,0) / (2,-4) / (4,-2) / (0,-2) / (-4,2) / (1,-5) / (3,0) / (3,3) / ?

If not, how fast has it been done? Any help for fingertricks?

Unrelated, but what became of cubeshape+parity?

EDIT: and when learning cubeshape cases, do you guys explicitly have to learn the 'upside down' version of the algs too, or is it intuitive from there?

Last edited:

#### not_kevin

##### Member
Is there a better opposite parity alg than
/ (3,3) / (-1,0) / (2,-4) / (4,-2) / (0,-2) / (-4,2) / (1,-5) / (3,0) / (3,3) / ?

If not, how fast has it been done? Any help for fingertricks?

Unrelated, but what became of cubeshape+parity?

EDIT: and when learning cubeshape cases, do you guys explicitly have to learn the 'upside down' version of the algs too, or is it intuitive from there?
I find / 3,3 / 1,0 / -2,-2 / 2,0 / 2,2 / 0,-2 / -1,-1 / 0,3 / -3,-3 / 0,2 / -2,-2 / -1,0 much better than that This is an alg that's particularly nice if you do "Western" turning, where you alternate clockwise/counterclockwise for the slices (like doing R2 R2' R2 R2', rather than the Polish R2 always).

bobthegiraffemonkey and Raptor56 are the two most involved in still pursuing the method; it's the next thing on my list, but I haven't gotten around to it. In my (and I think most Sq-1 theory-crafter's) opinion, it's the method with the highest potential that's somewhat accessible (unlike, for example, 1-looking a solve after doing cubeshape), but it's also the least-proven, and the hardest to get into because of the very different recognition things that start coming into play. bobthegiraffemonkey's demonstrated that it is doable, 'tho, and so I think some more time will give some fruitful results

For cubeshape, I didn't learn anything in particular - most of the time, it's easy to mirror the logic of the algs in your head (since cubeshape cases, like crosses or fb cases, flow into each other). If you run into a case that's giving you trouble, feel free to throw it here

#### bobthegiraffemonkey

##### Member
Not sure if this is what people were looking for, hopefully this helps someone. If anyone has any specific requests about this, let me know, might be next weekend before I manage to record more though.

Example solve for PCS (CS+P if you prefer), I hope this helps. Scramble (in terms of the pieces):

Reference scheme:
yr,yo,yg,yb / wr,wo,wg,wb

Edges:
yb,wg,yg,wb / wo,wr,yr,yo
4 7 3 8 / 6 5 1 2

Corners:
yb,wo,yr,wg / yg,yo,wb,wr
4 6 1 7 / 3 2 8 5

Trace edge cycles:
@1 = 4
@4 = 8 [1]
@8 = 2 [0]
@2 = 7 [1]
@7 = 1 [0] end cycle
Cycle break, piece 3 solved, next unsolved piece is 5
@5 = 6
@6 = 5 [1] end cycle

Trace corner cycles:
@1 = 4
@4 = 7 [0]
@7 = 8 [1]
@8 = 5 [0]
@5 = 3 [1]
@3 = 1 [0] end cycle
Cycle break, next unsolved piece is 2
@2 = 6
@6 = 2 [1] end cycle

Answer: 1 = odd parity. Since default (3 mover) for scallop/scallop switches parity, do default solution to get even parity after cubeshape.

Last edited by a moderator:

#### Sam N

##### Member
Great video bobthegiraffemonkey! In terms of quality, the sound and visuals are great. I think this will help lower the barrier to entry as this should help clear up a lot of initial confusion. Honestly, this is the hardest part. The algs are quite simple, and you can learn them the same way you do kite scallop in a way, just for parity.

#### TMarshall

##### Member
Not sure if this is what people were looking for, hopefully this helps someone. If anyone has any specific requests about this, let me know, might be next weekend before I manage to record more though.

https://www.youtube.com/watch?v=QxXT5Ucp2HY&feature=youtu.be

Example solve for PCS (CS+P if you prefer), I hope this helps. Scramble (in terms of the pieces):

Reference scheme:
yr,yo,yg,yb / wr,wo,wg,wb

Edges:
yb,wg,yg,wb / wo,wr,yr,yo
4 7 3 8 / 6 5 1 2

Corners:
yb,wo,yr,wg / yg,yo,wb,wr
4 6 1 7 / 3 2 8 5

Trace edge cycles:
@1 = 4
@4 = 8 [1]
@8 = 2 [0]
@2 = 7 [1]
@7 = 1 [0] end cycle
Cycle break, piece 3 solved, next unsolved piece is 5
@5 = 6
@6 = 5 [1] end cycle

Trace corner cycles:
@1 = 4
@4 = 7 [0]
@7 = 8 [1]
@8 = 5 [0]
@5 = 3 [1]
@3 = 1 [0] end cycle
Cycle break, next unsolved piece is 2
@2 = 6
@6 = 2 [1] end cycle

Answer: 1 = odd parity. Since default (3 mover) for scallop/scallop switches parity, do default solution to get even parity after cubeshape.
I only watched the video once so I may have missed this, but what is your "solved" state for the other cubeshape cases? Do you have one memorized for every other case? Sorry if this makes no sense, I can try to clarify if you need it. Also the quality of the video and audio is way better, which makes it way easier to learn from.

#### bobthegiraffemonkey

##### Member
I only watched the video once so I may have missed this, but what is your "solved" state for the other cubeshape cases? Do you have one memorized for every other case? Sorry if this makes no sense, I can try to clarify if you need it. Also the quality of the video and audio is way better, which makes it way easier to learn from.
I've updated my sig so that it links to a pastebin with my sq-1 stuff, that includes the solved states (I prefer 'reference scheme') for other shapes. Doesn't matter though, you don't have to use the same ones as me, that part of the system is entirely personal preference so just pick something intuitive (it may affect what alg is even parity and which is odd, but it's not really going to affect how difficult the system is to learn and anyone learning this should be taking their own notes to learn from anyway).

Maybe a couple of other examples will help:
square/barrel
Code:
ecececec/cceeccee
11223344/56567878

cceeccee/ecececec
12123434/55667788
(these don't have standard names)
Code:
eeccccc/cececeeee
1212345/637485678

cececeeee/eeccccc
637485678/1212345
Note that in the second case, there's 5 corners on one layer and 3 on the other, so I need to be consistent about which of these I start on, otherwise I can just start on the top layer without affecting anything like I did for square/barrel. When you have 8 edges on one layer you can take either approach for the corners, I choose to always have the first two corners together and the last 6 on the other layer. Actually, for the 5/3 corner cases I just need to be consistent with the corners, but I find it helpful to be consistent with edges too for recognition reasons.

#### not_kevin

##### Member
Not sure if this is what people were looking for, hopefully this helps someone. If anyone has any specific requests about this, let me know, might be next weekend before I manage to record more though.

https://www.youtube.com/watch?v=QxXT5Ucp2HY&feature=youtu.be

Example solve for PCS (CS+P if you prefer), I hope this helps. Scramble (in terms of the pieces):

Reference scheme:
yr,yo,yg,yb / wr,wo,wg,wb

Edges:
yb,wg,yg,wb / wo,wr,yr,yo
4 7 3 8 / 6 5 1 2

Corners:
yb,wo,yr,wg / yg,yo,wb,wr
4 6 1 7 / 3 2 8 5

Trace edge cycles:
@1 = 4
@4 = 8 [1]
@8 = 2 [0]
@2 = 7 [1]
@7 = 1 [0] end cycle
Cycle break, piece 3 solved, next unsolved piece is 5
@5 = 6
@6 = 5 [1] end cycle

Trace corner cycles:
@1 = 4
@4 = 7 [0]
@7 = 8 [1]
@8 = 5 [0]
@5 = 3 [1]
@3 = 1 [0] end cycle
Cycle break, next unsolved piece is 2
@2 = 6
@6 = 2 [1] end cycle

Answer: 1 = odd parity. Since default (3 mover) for scallop/scallop switches parity, do default solution to get even parity after cubeshape.
Thanks a bunch - this was really helpful in laying the basic groundwork for the method, and the video quality is much much better It seems ('tho I do have some follow-up questions after I learn the method more fully) that it won't play too nicely with OBL recognition/prediction, unfortunately :< But I'm very new to both, so there's still hope.

EDIT: Okay, read through your response - I understand the setup for each shape now, and how the whole thing is applied. I'll try to first start using this method (by figuring out which parity my normal algs are) before figuring out if there's a clean way to combine OBL prediction into it - still looks not super promising, but maybe there are some clever ways to make it okay.

Last edited:

#### bobthegiraffemonkey

##### Member
I have the same question here, too - do you have individual solved states for each layer (eg, "this is how I do it for scallop, for fist, for shield, etc.") or for each cubeshape (eg, "this is how I do it for scallop/scallop, shield/shield, etc.")? It seems that it's the former, but I admit that I haven't watched/read your previous work yet - apologies for sounding like a noob.
Just to clarify, it's a per layer thing (e.g. scallop is scallop, and isn't affected by what the other layer is).

Also, thanks to everyone for saying video quality is good, genuinely surprised since I don't have a clue about that sort of thing, I'm putting it down to sheer luck!

#### willtri4

##### Member
What are some easy EP algs? I know W/adj, adj/adj, opp/opp, all Uperm/solved cases, Zperm, Hperm, O/opp, and parity ofc.
Adj/opp, U/U, adj-O, and O. Slightly less easy: W/W, opp, U/adj. There's probably something I'm forgetting.

#### not_kevin

##### Member
Adj/opp, U/U, adj-O, and O. Slightly less easy: W/W, opp, U/adj. There's probably something I'm forgetting.
I'm a fan of the O/O cases for learning - I'm not particularly fast with them, but the <M2, U, D> algs are very intuitive (basically, O/opp cancelled into a Z perm).