# Noah's CP-Block Method



## Noahaha (Apr 22, 2012)

Just something I've been toying around with. Probably not very useful.

This is based on Petrus:

Step 1: create a 2x2x2 block with all D-layer corners placed. One of the two adjacent to the block must be oriented. 

Step 2: Identify the corner swap in the U-layer and swap the corners using R U/U'/U2 R'.

Step 3: Place the last 2 edges of the 2x2x3 around the oriented D-layer corner while trying to make sure that you end up with 0 or 4 bad edges. 

Step 3.5: If you ended up with 4 bad edges, use M' U M or M F M' to fix them. If you have 2 bad edges, which is undesirable, use R U R' U' M' U R U' r' or M U M' U2 M U M'.

Step 4: 2-gen F2L

Step 5: 2GLL.


Example solve with commentary:

U2 F' U' L' U2 F2 L2 U B' U F2 U2 F' R2 F L2 B' R2 F (scrambled with white on top and green in front)

CP-Block: (8)
D2 F2 B2 

E2 ; instead of u2 since the blue-red-white corner is already placed.

R' U' B U ; It's a little unfortunate that the white-orange-blue corner is at DFR. Otherwise I would only have needed 2 moves here. For example, if it was at DBR, B R' would have sufficed.

CP: (4)
x' U ; places the UBL and UBR corners, so it is easy to see that UFL and UFR need to be swapped. 

R U' R' ; accomplishes this.

2x2x3: (7)
z' y2 L U2 L' ; places the U F edge. I know that this insertion does not affect EO.

B' ; sets up an F' U' F insertion which flips the edges at RF and UR. I look at the edges at this point and I only see one bad edge at RD. So, I have to bite the bullet and accept 4 bad edges. 

F' U' F

EO: (5)
x' y ; bad edges are at FL, FD, FR and UL
U F2 ; set up 
M F M' ; kind of like arrow case in Roux.

F2L: (15)
y' 
R U R2 U R2 U' R U R' U' R U R' U' R 

2GLL: (14)
U2
R2 U' R U R U R' U2 R U R2 U R2

Total: 53


Conclusion: This might be good for OH sometimes. CP blocks often just happen, or are one or two moves extra. The example solve was probably about average movecount if not a little higher.


----------



## monkeytherat (Apr 22, 2012)

Very cool! This might be useful.


----------



## Rpotts (Apr 22, 2012)

Here's an alg.garron for that example.


----------



## Noahaha (Apr 22, 2012)

Rpotts said:


> Here's an alg.garron for that example.


 
Thanks!


----------



## A Leman (Apr 22, 2012)

It's an interesting idea! the rotations and recognition seem toublesome for speedsolving though.


----------



## Noahaha (Apr 22, 2012)

A Leman said:


> It's an interesting idea! the rotations and recognition seem toublesome for speedsolving though.


 
They're actually my normal rotations lol. Recognition for the CP step can't be any harder than CMLL recognition, so I think the only step that has a real disadvantage is the 2x2x3 expansion. There is some freedom though, as you can place one or both edges before CP as long as you can avoid the nasty 2 edge EO case.


----------



## A Leman (Apr 23, 2012)

I am not that great at OH and would really struggle with the M F M' and z' y2 for OH. Rotations and slices moves are much easier 2H and there would be more freedom. The cp step would need an extension of cmll recognition since the bottom corners are not always oriented correctly for CmLL. 
you COULD use 3-cycles for step three to solve the 2x2x3 and avoid the 2 bad edges.
for 2 bad edges the best i know are RUR'U'M'URU'r' AND MUM' U2 MUM'
I am having trouble understanding this method so please correct me If I am misunderstanding you


----------



## Noahaha (Apr 23, 2012)

A Leman said:


> I am not that great at OH and would really struggle with the M F M' and z' y2 for OH. Rotations and slices moves are much easier 2H and there would be more freedom. The cp step would need an extension of cmll recognition since the bottom corners are not always oriented correctly for CmLL.
> you COULD use 3-cycles for step three to solve the 2x2x3 and avoid the 2 bad edges.
> for 2 bad edges the best i know are RUR'U'M'URU'r' AND MUM' U2 MUM'
> I am having trouble understanding this method so please correct me If I am misunderstanding you


 
M =r' R
M' = r R'

The rotations in the example were really just the ones I thought would demonstrate the method most easily. You can do those moves from other angles in an actual solve. 

Those algorithms you gave don't preserve CP which is the whole point. Normal 2-edge flips during EO like R U R' also don't preserve CP, which is why you either need to force an EO skip or force there to be 4 bad edge where you can do M F M'/ M' U M which does preserve CP. 

Doing 3-cycles for step 3 sort of misses the point. 3 move insertions of the type I did in my example solve do preserve CP, so they are safe. The important part is understanding how they affect EO, so that you can always know you'll get a 0 or 4 bad edge case. So basically the goal is to be able to do EO without affecting CP.

I think you might be confused about the EO step of Petrus, which you can find an explanation of at lar5.com/cube. I think EJ (captaincrash44) has one on YouTube as well.


----------



## A Leman (Apr 23, 2012)

I know what the M is, I just happen to find them difficult OH

It does preserve cp because the RUR'U' is the edge insertion before the interchange move M’ of the edge commutator and is undone with a cancellation in U R U’ r’. 

I understand the Eo step of petrus and also know that the 3 move 2 flip creates corner parity with is why you would need to 3cycle(to flip 2 edges and create parity and then flip one of the already flipped edges with an unflipped edge to fix parity and solve 2 bad edges while maintaining correct cp) 

since you would need to 3 cycle later on(if you had 2 bad edges), you could do it wll making the 2x2x3 and save the trouble later on.


----------



## Noahaha (Apr 23, 2012)

A Leman said:


> I know what the M is, I just happen to find them difficult OH
> 
> It does preserve cp because the RUR'U' is the edge insertion before the interchange move M’ of the edge commutator and is undone with a cancellation in U R U’ r’.
> 
> ...


 
I see. I should probably try algs on a cube before I judge them. That does seem like the best way to deal with 2-flips then. 

Could you do an example solve where you use three cycles to finish the 2x2x3? I'm not sure exactly what you mean, or how you could use that to avoid 2 bad edge scenarios. I think that it would involve too many moves though, especially for OH. You say that a 3-cycle could avoid 2 bad edges, but they can be avoided just as easily by controlling which edges get flipped during your insertions. The one scenario where that would be useful is if you had no bad edges going into the last edge of the 2x2x3, which I think is what you're talking about.

EDIT: added those two 3-cycles for step 3.5 to the original post.


----------



## applemobile (Apr 23, 2012)

Does CP stand for what I think it does?


----------



## A Leman (Apr 23, 2012)

Noahaha said:


> I see. I should probably try algs on a cube before I judge them. That does seem like the best way to deal with 2-flips then.
> 
> Could you do an example solve where you use three cycles to finish the 2x2x3? I'm not sure exactly what you mean, or how you could use that to avoid 2 bad edge scenarios. I think that it would involve too many moves though, especially for OH. You say that a 3-cycle could avoid 2 bad edges, but they can be avoided just as easily by controlling which edges get flipped during your insertions. The one scenario where that would be useful is if you had no bad edges going into the last edge of the 2x2x3, which I think is what you're talking about.
> 
> EDIT: added those two 3-cycles for step 3.5 to the original post.



Here's an example
Scramble
L' D L B' D' L2 U B' F U2 D2 B' R2 B' F' U' B2 L U' B R' D2 B R2 F' 

Inspection x’
ULU’ R’ D2 2x2 block (5)
R2 F2 B’ R B R’ bottom corners and a 2x2x3 edge (11)
U R U R’ U’ F’ U’ F CP (19)
U z’ RU’RURURU’R’U’R2 z (The 2x2x2 block while making the bad edge count 0 instead of 2)(31)
y’ U R U’ R’ U R2 U’ R’ U’ R’ U’ R(F2L)(43) 
U2 (RU2R’) U’ (RUR’) U’ (RU’R’) U2 (2GLL)(56)

This method averages high compared to petrus.Notice that since the block is in the back and I did a z’, the a-perm did affect the EO.The movecount could have been 52 but I used the non-optimal A-perm.


----------



## mariano.aquino (Apr 23, 2012)

This is very similar to what I published on my page, sort of a method I use when I'm bored =) they differ many things, but the main idea is "similar."
You can see a video and reconstruction here:
http://sites.google.com/site/recursoscuberos/f2g
This version is oriented towards optimization of roux method, with the help of BRASS 2x2x2 method, however, in this example I finish the solve with this variant of freeFOP, which I personally find very finger-friendly (after reduction, blocks, f2l, oll and pll are done exclusively using r/R/u/U)


----------



## Noahaha (Apr 23, 2012)

A Leman said:


> Here's an example
> Scramble
> L' D L B' D' L2 U B' F U2 D2 B' R2 B' F' U' B2 L U' B R' D2 B R2 F'
> 
> ...


 

For CP, U R U R' (15) would have sufficed
After which I would complete the solve with:
U2 F U'* B' R' B 21 so I have 4 bad edges which can be fixed with:
F U2 M' U M (26). Do you see how the A-perm is unnecessary? The reason I did the U' with the * is because otherwise you end up with two bad edges. Thats the whole point.


----------



## Kirjava (Apr 23, 2012)

Doesn't placing D corners just to detect CP seem wasteful to you?

Why not do 2x2x3 -> EOCP -> F2L -> 2GLL?


----------



## Noahaha (Apr 23, 2012)

Kirjava said:


> Doesn't placing D corners just to detect CP seem wasteful to you?
> 
> Why not do 2x2x3 -> EOCP -> F2L -> 2GLL?


 
It's definitely wasteful but it can usually just be an extra move or two if you count placing the oriented corner as "useful".

I've tried an EOCP step before, but it was hard to find situations where the CP fit with the EO, which is actually why I switched to this once I figured out that you can complete the 2x2x3 without affecting CP.


----------



## Kirjava (Apr 23, 2012)

Noahaha said:


> It's definitely wasteful but it can usually just be an extra move or two if you count placing the oriented corner as "useful".


 
Movecount is not the only issue, thinking and looking time is more what I was getting at.

Also, completing the 2x2x3 by adding two edges seems silly and inefficient.


----------



## Noahaha (Apr 23, 2012)

Kirjava said:


> Movecount is not the only issue, thinking and looking time is more what I was getting at.
> 
> Also, completing the 2x2x3 by adding two edges seems silly and inefficient.


 
True. It is possible just to do one edge like that and have one be part of the CP-block like in Leman's example. I think it would be worth it if you could get an EO skip every time. Then it becomes:
1. 2x2x3 minus an edge
2. CP
3. Place edge + EO
4. 2GF2L
5. 2GLL

Which looks more efficient to me. Then the question is about whether there's a significant difference between placing the last edge after CP and just finishing the block. The problem is that the way I do it only half of all edge insertions affect EO, so I may need more tricks for step 3 if I want to do EO while only placing one edge.


----------



## Kirjava (Apr 23, 2012)

eh, whatever.

I just really want someone to make a good/simple system for detecting CP after 2x2x3.


----------



## Escher (Apr 23, 2012)

Kirjava said:


> eh, whatever.
> 
> I just really want someone to make a good/simple system for detecting CP after 2x2x3.


 
Permuting 1 corner to UFL/UBL/DBR/DFR makes it really easy to trace the cycle and detect CP, just not that fast. Obviously actually recognising a specific case and solving CP is a different kettle of fish... I'm not sure it can be effectively done for speedsolving methods - if you can't trace _x_ block -> CP in inspection.

It might be possible to do 2x2x2 + CP inspection, if you limit your movegroup while building the block it would be possible to calculate what type of case you'd end up with. I think this would be stupidly difficult to accomplish in <15s however.


----------



## Kirjava (Apr 23, 2012)

Escher said:


> It might be possible to do 2x2x2 + CP inspection, if you limit your movegroup while building the block it would be possible to calculate what type of case you'd end up with. I think this would be stupidly difficult to accomplish in <15s however.


 
CPBLOCK IS THE NEW EOLINE

Edit;

CP+1x2x3
Second block is the same
CLL+EO or LSCLL = not many cases & good algs
PLSE


----------



## Noahaha (Apr 23, 2012)

These might be useful:
(block in back)
URF <> URB: R U R'
URF <> ULF: R U' R'
ULF <> ULB R U2 R'
And obviously:
URB <> ULB: U R U R'
URB <> ULF/URF <> ULB: F R U R'


----------



## mariano.aquino (Apr 23, 2012)

A Leman said:


> Here's an example
> Scramble
> L' D L B' D' L2 U B' F U2 D2 B' R2 B' F' U' B2 L U' B R' D2 B R2 F'
> 
> ...



This it's how I would've done it:

x'y' U2 R2 x' (cp setup)
cp skip
u' R' S r' u' R' U R u2 (left block)
U' r2 U M' U r' (middle block)
U2 R U R2 U' R' (right 2x2x1 block)
U R' U R2 r' U2 R' U R U M' (F2L+EO)
L2 U' L U L U L' U2 L U L2 U L2 (2GLL)
47stm

Or, roux version...

x'y' U2 R2 x' (cp setup)
cp skip
u' R' S r' u' R' U R u2 (left block)
U' r' U' r' U' r' U' R2 U' R' U R U2 r M' U2 r' U' R (right block)
l' U2 L U L' U l (2GCMLL)
M U' M U M U2 M U2 (LSE)
45stm

what do you think?


----------



## A Leman (Apr 23, 2012)

mariano.aquino said:


> This it's how I would've done it:
> 
> x'y' U2 R2 x' (cp setup)
> cp skip
> ...


I was just giving an example of using a cycle to combine the 2x2x3 block and the EO Which I made steps toward in the solve. That solve was just done on the fly to somewhat fit within noahaha's steps,show my EO skip idea, and i reconstructeded it.Your method looks more like a CF method for edges to keep the cp. I still have a lot of doubts about cp first methods because they place a lot of restrictions on the solve and have recognition problems.As for Roux idea, I personally like the freedom roux offers and would freeze up on a restricted roux solve. I feel cp should be forced later on in a solve like kirjava to make better use of inspection.


----------



## Noahaha (Apr 23, 2012)

With enough practice one could plan a CP block with one edge placed next to the oriented corner and be able to seamlessly transition into the 3 moves necessary for CP. Then just apply an algorithm to place the last edge combine with EO, and go 2 gen the rest of the way.


----------



## mariano.aquino (Apr 23, 2012)

A Leman said:


> As for Roux idea, I personally like the freedom roux offers and would freeze up on a restricted roux solve. I feel cp should be forced later on in a solve like kirjava to make better use of inspection.



After doing cp, I find no restrictions at all, besides being restricted to just 7 kcmlls. What are the restrictions you see in doing this cp+left block?


----------



## Noahaha (Apr 23, 2012)

How are people doing the Roux CP-block? Is CP planned in advance, or are you making the block and then doing R U R'? One idea I had, which is probably more of a Petrus/CFOP approach is making the back square of the second block and then doing F' U/U'/U2 F for CP (or the front square and B U/U'/U2 for CP), then filling the last slot. That way you can recognize it the same way as CPLS.


----------



## 5BLD (Apr 23, 2012)

With Roux it's not much of a benefit imo. The no swap cases are some of my worst CMLL cases.

I used to just use CPLS algs, but I only knew Im (which defeats the purpose) at the time. I realised it'd be pointless to learn CPLS because of the above reason. I think the good think about your method lies in the 2GLL finish which is why we do CP.


----------



## A Leman (Apr 23, 2012)

mariano.aquino said:


> After doing cp, I find no restrictions at all, besides being restricted to just 7 kcmlls. What are the restrictions you see in doing this cp+left block?


your solves were good. I just feel that since you had to setup and presrve cp you missed an easy Roux solve like below. It took me most of inspection to plan the first block, but it was worth it.(more than planing an 11 move cp left block). 

What important benifit do you get from using cp control in Roux besides less CMLL?

Scramble
L' D L B' D' L2 U B' F U2 D2 B' R2 B' F' U' B2 L U' B R' D2 B R2 F'

Roux Solve
Inspection y2 z
D’F’B2D2 (4) Block 1
M U’M’ U2 R2 U’ R U2 R2 U R’ (15) Block 2
U2 r2 D’ RU2R’ D RU2R (25) CMLL
UM’UMU’M2U’MU2M’U (36) LSE


----------



## mariano.aquino (Apr 24, 2012)

A Leman said:


> What important benifit do you get from using cp control in Roux besides less CMLL?


 
It could be a way of adding some more complex cases, such as edge orienting cmlls, or other stuff I may be missing right now =)
Still, I don't think it will be something worth learning as a main method, but maybe for cases with easy recognition, same way you would use some COLL, sometimes, in a Fridrich solve.
Maybe a preEO followed by cmll+EP algorithm? 4b, cmll+4a+c?


----------



## AHornbaker (Aug 13, 2013)

Kirjava said:


> eh, whatever.
> 
> I just really want someone to make a good/simple system for detecting CP after 2x2x3.



I came up with a quick system about a week ago, here goes.
1.) After first block, place the two remaining D corners in ULB and DRB. (2 moves max)
2.) Look at URF. Find the other two U corners with the same colors. They will make an "L" shape on either the U, R, or F face. Then, determine whether those two corners are correct or should be swapped. (I'll make some pics to illustrate this)
pics: http://www.quickmeme.com/meme/3vhcw6/
3.) Find case, apply your favorite alg. (First letter stands for face, second letter stands for U corners correct or swapped)

D Corners Correct CP (3 HTM)
*Fc:* (f R' f') or (d R' U' R d') 
*Fs: *Correct CP 
*Rc:* (f R f') or (d R' U R d') 
*Rs:* (R F R F') or (R2 d R' U' R d') 
*Uc:* (U' b' R b) or (d' L' U L d) 
*Us:* (U f R f') or (d R' U2 R d') 

D Corners Swapped CP (3 HTM) 
*Fc:* Correct CP 
*Fs:* (f R' f') or (d R' U' R d') 
*Rc:* (R F R F') or (R2 d R' U' R d') 
*Rs:* (f R f') or (d R' U R d') 
*Uc:* (U f R f') or (d R' U2 R d') 
*Us:* (U' b' R b) or (d' L' U L d)

*Speed-optimized algs. Hooray. <5 moves on average.
**Algs for D correct and D swapped are same, just flipped for each face. Only 5 algs total. I can go into more detail how the algs work and what they swap.
***DISCLAIMER: Don't get butthurt because the algs don't preserve EO. Working on that. Read below.



Kirjava said:


> Doesn't placing D corners just to detect CP seem wasteful to you?
> Why not do 2x2x3 -> EOCP -> F2L -> 2GLL?



I'm working real hard on EOCP and figuring out what makes things tick. Ideally, it would be one-look, and you could solve EO and CP in one step. That's pretty infeasible. Using my CP recognition method, you can determine 1 of 6 cases, then there are about 13 distinguishable EO cases (same with one face turn) for 7 edges as follows:

0 Edges Misoriented (1 case)
2 Edges Misoriented (21 unique cases)
---0 on U
------L shape on F
------Line on F
---1 on U
---2 on U
------L shape 
------Line 
4 Edges Misoriented (35 unique cases)
---1 on U
---2 on U
------L shape
------Line
---3 on U
---4 on U
6 Edges Misoriented (7 unique cases)
---3 on U
---4 on U

This might be a little off, but it's a start. Before I dive in head-first in developing a method, I need to find out the best scheme. 

*My first idea* was to find ~5 algs that solve each CP case (swapping two specific corners) and flip two edges. These algs are like what Noahaha described earlier in the thread (ie. R U R', R U' R', L' U2 L, etc.) Let me introduce a concept. While solving corner PLL, you can use a 3 corner cycle to either solve CP, or keep the CP wrong, then use the 3 corner cycle again to solve corner PLL. Using my CP recognition and using these 5 algs intuitively, EOCP could be solved in this way:
0C/0E - solved EO/CP
2C/0E - Alg to flip 2 edges and keep CP swapped, turns into 2C/2E case
2C/2E - Place edges and 1 of 5 algs to solve CP and EO
2C/4E - Alg to flip two edges while keeping CP swapped, 2C/2E case
2C/6E - Alg to flip two edges and either solve or keep CP swapped, either 2C/4E or 0C/4E case
0C/2E - alg to keep 2 edges flipped (flip one correct and one wrong) and swap CP, 2C/2E case
0C/4E - Alg to flip 2 edges and swap CP, 2C/2E case
0C/6E - Alg to flip 2 edges and swap CP, 2C/4C case

This method would be alright, the only problem is keeping track of the CP case after initial recog. *Then I had another idea.* Place the edges and the corners at the same time. More setup moves, less cases. Ideally, 6 cases for CP and only 4 cases for EO (0,2,4, and 6 edges wrong, placed in specific spots) but this might be unfeasible due to high setup moves. I thought about it more and this would reduce setup to only R and U, making your solve less efficient. Silly, I know. The better idea is here somewhere... (hint- keep reading!) After the block, don't limit your moves to <U,R>, but use all sides to orient edges while you place the corners for CP recog. Much more efficient. The only downfall to this is it would be two looks (one for D corners/EO, then for CP). Let me know which you think is better. Can't wait until I have a good EO/CP system.


----------



## MaikeruKonare (Aug 13, 2013)

I love the F2L with only U and R, it seems very speed efficient.


----------

