# LCBM (Long-Comeau Belt Method) Guide and Algorithms



## Erzz (Jun 23, 2011)

*Introduction*​
New method! LCBM is a belt method, concieved by Nick Long, aka OMGitsSolved. He contacted me about generating some algorithms to permute both layers and orientate both layers. Not in the same step, of course. Now you're probably thinking "wat, that's like 3768 algorithms!" Well, it would be, but Nick cleverly came up with ways to reduce this number to just 161. Let's get into the method.

*Step 1) Edge Orientation*​The first step is to orientate all the edges. This is the same as ZZ except you don't make a line. Well, you could make a line, but it would have to be somewhere on the E layer, rather than D. Check out some ZZ guides to see how to do this.

*Step 2) Make a Belt*​Solve all the edges on E. You can make the belt on M or S, but it has to end up on E, and you can't rotate or else EO will get messed up. So making it on E is probably the best. This is completely intuitive, similar to the cross.
(You actually can make it on M without messing up the EO.)

*Step 3) Fix Corner Orientation Parity (if any)*​If you have an OLL case on U that you don't recognize, it's because a corner is twisted that shouldn't normally be twisted. See this post from qqwref on how to deal with parity.


Spoiler






qqwref said:


> The idea is this: R2 U' R2 basically replaces DRF with ULF. So what you want to do is replace one corner on D with a differently-oriented one, fixing the corner parity. If you want to rotate a bottom corner clockwise, for instance, you could replace solved with clockwise, or clockwise with counterclockwise, or counterclockwise with solved.
> 
> Another option (if you're willing to have the belt be either solved or an R2 off, which might be worthwhile for corner separation) is to simply do an R2, moving two corners to the bottom layer. I am not sure this can always create a solvable parity case, but it seems to work most of the time, so it's probably still useful (and hey, one move is better than 3 or 7, eh?). I guess, yeah, if you're going to separate later, it wouldn't hurt to leave the belt up to an R2 off - no point wasting moves keeping it that way when you're just going to intuitively mess it up later.






*Step 4) E Preserve Orient Both Layers​*Orientate both U and D layers while preserving the E layer. The U and D layers will get mixed up in this step. Algorithms are below. Since we did EO, there are only 56 (7 are just OLL) cases, rather than 3249.

*Step 5) Separate and Corners of D Layer​*In this step, you solve the corners of the D layer while bringing all pieces to their correct layer. Solving the corners is done intuitively. If you can't figure it out, try R2 (some U move) R2 and see what that does. You can swap the UF and DF edges by using M' U2 M.
If you have just one corner out of place, put that corner in UBR, and put the location it needs to go in DFR, then do 
*R2 U' R2 U' R2 U R2*

*OR* See this post.

*Step 6) E Preserve Permute Both Layers​*Permute both layers. If you don't recognize the PLLs, do M2 U2 M2 to fix parity. (you can also control what PLL you get after fixing parity. I recommend avoiding V perms) Algorithms below. Since we solved the D layer corners, there are only 105 (21 are just PLL) cases, rather than 441.



Here are the algorithms, arranged by which case is on D.
All the cases are the same as in the wiki, except Gs, which have headlights on L. D layer cases should be recognized as if they were on the U layer with an *x2* (not z2)
Average move count for EPPBL seems to be around 17 or 18.
Average move count for EPOCLL seems to be around 9 or 10.

*EPPBL*


Spoiler



H


Spoiler



H: M2 U2 M2 y M2 U2 M2
Ua: D M2 U M' U M2 D' M2 U M U M2
Ub: D M2 U2 M2 D' M2 U M' U2 M U' M2
Z: M2 U' L2 (U D') M2 (U' D) l2 U M2
Aa: L R2 D R' U2 R D' L' R2 D L R U2 L' R' D
Ab: R2 (U' D) R2' (U' D) L2 R2 U' l2 U L2' U' l2 U R2 U2
E: r2' U' R2 U l2 U' L2 U2 L2 R2 (U D') R2 U' l2 U' l2 U L2'
F: R2 (U' D) r2' U' R2 D r2' R2 (U D') l2 U' l2 U R2 U'
Ga: U L2 (U' D) R2 (U D') r2 R2 U' r2 U r2 U' r2 U r2 D'
Gb: R2 U' l2 U l2 U' l2 U l2 L2 (U' D) L2 (U D') l2
Gc: R2 U l2 U' l2 U R2 U' L2 U D' L2 U l2 L2 U l2 L2
Gd: R2 U l2 U' l2 U l2 U' l2 L2 (U D') L2 (U' D') l2
Ja: R2 U' L2 (U D') R2 U' R2 U R2 D' L2 U2 L2 R2 U' L2 R2
Jb: L2 R2 U' M2 U2 L2 U' l2 U R2 U' R2 (U' D) R2 U' L2 
Na: l2 U l2' U' r2 U' r2' U2 l2' U' l2 U' r2 U R2' U L2 l2'
Nb: M2 U R2 U r2 U' l2 U' l2 U2 r2 U' r2 U' l2 U l2
Ra: R2 (U' D) L2 U r2 U' L2 l2 (U' D) r2 U l2 U' R2 U
Rb: R2 (U' D) R2 U' l2 U l2 L2 (U' D) r2 U' l2 U R2 U'
T: R2 U' R2 U' r2 U2 r2 U' D' R2 U' r2 U2 r2 U R2 D
V: U' r2 U' l2 U l2 U R2 U l2 U' L2 U' R2 (U' D) L2 U' l2 U L2 (looong)
Y: R2 U' R2 U L2 U l2 U2 r2 U R2 U L2 U' L2 U'



Ua


Spoiler



H: U M2 D M' D M2 U' M2 D M D M2
Ua: M' (U' D) M2 D2 M' U' M' (U' D) M U'
Ub: L2 (U' D) R2 U M2 U' L2 (U' D) L2
Z: M2 D M' U2 M' (U D') M2 U M2
Aa: U R2 (U' D) r2 R2 U R2 U' r2 (U D') R2 U' l2 U R2 U'
Ab: U' l2 U' l2 U R2 U' r2 U' L2 U r2 U2 L2 U' l2 U'
E: U' L2 U D L2 U l2 U L2 R2 U L2 U' L2 U' D' L2 U'
F: U R2 U' l2 U l2 U' R2 U r2 R2 U' r2 R2 U R2 (U D') R2
Ga: U' L2 U D' L2 U l2 U' R2 U r2 U' L2 U'
Gb: R2 U' L2 U2 l2 U L2 U r2 U' R2 U' D' R2 U2 L2
Gc: R2 U' r2 U r2 R2 (U' D) R2 U' R2 U r2 (U D') r2
Gd: R2 U' l2 U L2 U' r2 U R2 U D' R2 U2
Ja: L2 U r2 U' r2 U l2 U' l2 (U' D) L2 U'
Jb: U' R2 (U' D) r2 U' r2 U l2 U' l2 U l2
Na: L2 U2 L2 U' l2 U'r2 U L2 U L2 U2 D L2 U R2 U'
Nb: U L2 U l2 U' r2 U L2 U r2 U' l2 U' L2 U2 r2 U2
Ra: U L2 (U' D) L2 R2 U R2 U' L2 U r2 U' r2 (U D') L2 U2
Rb: R2 (U' D) r2 U' r2 U L2 U' R2 U L2 R2 (U D') R2 U'
T: U2 L2 U l2 U R2 U' r2 U' L2 U' L2 U R2 U R2
V: R2 U2 D R2 U L2 U' R2 (U D') L2 U l2 U' l2 U R2 U'
Y: L2 U l2 U L2 U2 r2 U' R2 U l2 U' L2 D l2 U'



Ub


Spoiler



H: R2 (U' D) M2 D M' U2 M' U' M2 D2 L2
Ua: L2 (U' D) r2 U M2 U' l2 (U' D) L2
Ub: M' (U' D) M2 U2 M' D M' (U' D) M D
Z: M2 D' M' U2 M' U' D M2 U' M2
Aa: U' r2 U r2 U' L2 U l2 U' r2 U2 r2 U' r2 U' R2 D'
Ab: (U' D) l2 U' l2 U R2 (U' D) l2 U R2 U' L2 l2 (U D') l2
E: U R2 U' D' R2 U' r2 U' R2 L2 U' R2 U R2 U D R2 U
F: U' L2 U r2 U' r2 U L2 U' l2 L2 U l2 L2 U' L2 (U' D) L2
Ga: R2 U l2 U' L2 U l2 U' D' l2 L2 U l2 U' D l2
Gb: R2 U' L2 U2 l2 U L2 U r2 U' R2 U' D' R2 U2 r2
Gc: R2 U' r2 U r2 R2 (U' D) R2 U' R2 U r2 (U D') r2
Gd: R2 U2 L2 U l2 U L2 U' r2 U R2 U D R2 U2 r2 U2
Ja: U L2 (U D') l2 U l2 U' r2 U r2 U' r2
Jb: R2 U' l2 U l2 U' r2 U r2 (U D') R2 U
Na: U R2 U' L2 U2 D' L2 U' L2 U' L2 D R2 U L2 U2 L2
Nb: U' R2 U2 R2 U r2 U R2 D U2 r2 U' r2 U l2 U' L2
Ra: U2 L2 U D' l2 U l2 U' R2 U L2 U' L2 R2 U' D L2 U'
Rb: U R2 U' D L2 R2 U' R2 U L2 U' r2 U r2 (U D') R2
T: R2 U' r2 U' L2 U l2 U R2 U R2 U' L2 U' L2 U2
V: U l2 U2 D L2 U r2 U' R2 (U' D) L2 U R2 U' r2 U R2
Y: R2 U' r2 U' R2 U2 L2 U L2 U' R2 U l2 U' L2 U'



Z


Spoiler



H: M2 D' R2 U D' M2 U' D L2 U M2
Ua: M2 U M' D2 M' U' D M2 D M2
Ub: M2 D' M2 U D' M D2 M U' M2
Z: M2 D' M2 U D M2 U' M2
Aa: U D l2 U' l2 U L2 (U D') L2 U l2 U' l2
Ab: U' l2 U l2 U' L2 (U' D) L2 U' l2 U R2 U'
E: R2 (U' D) l2 U2 L2 U' l2 U' D' L2 U' R2 U2 R2 (U D') R2
F: U L2 U L2 U' l2 U' r2 U L2 U' R2 U r2 U l2 U' l2 L2
Ga: D U2 L2 U' r2 U r2 U' R2 U D L2 l2 U' L2 (U' D) L2
Gb: r2 U L2 U l2 U L2 U2 l2 U' r2 U r2 U D' r2 U
Gc: D R2 U l2 U' l2 U L2 U D l2 L2 U L2 (U D') L2 U
Gd: D' r2 U' L2 U' l2 U' L2 U2 l2 U r2 U' r2 (U' D) r2
Ja: R2 U L2 U' D r2 U l2 U2 L2 U' r2 U' r2 U' r2 U2
Jb: r2 U r2 U D r2 U' r2 U' r2 U' l2 U' R2 U r2 U'
Na: l2 U' l2 U' L2 U' L2 U2 L2 U' l2 U D l2 U' l2 U L2 D' l2
Nb: R2 U l2 U' R2 U' L2 R2 U2 R2 U l2 U' D l2 U l2 U' L2 U'
Ra: D r2 U' R2 U' r2 U r2 U l2 U' l2 U r2 U' R2 U
Rb: r2 U R2 U r2 U' r2 U' l2 U l2 U' r2 U R2 U' D'
T: U R2 (U D') L2 U' L2 R2 U D r2 U' l2 U l2 U' l2
V: l2 U L2 U2 L2 l2 U L2 U' l2 U D l2 U' l2 U r2 U' R2 U
Y: l2 U' l2 U' D' L2 U l2 U' l2 U' D' R2 U' L2 U2 R2 U


See also: This pretty table I made



*EPOCLL*


Spoiler



Sune


Spoiler



Sune: R' U' R' U R U2 D R' D' R
antiSune: R' U' R U2 R (U' D) R2 U R'
H/Double Sune: U' R (U' D) r2 R2 U' r2 U R'
U/Headlights: R' U2 R' U D R2 U2 R' U' R
T/Chameleon: L D' L' U' r2 U2 L' U' L'
L/Bowtie: R D r2 R' U R U2 r2 R'
Pi/Wheel: L U D L' U D2 L' U2 D L'



antiSune


Spoiler



Sune: L U L' U2 L' (U D') L2 U' L
antiSune: L' U L U' L U' D2 L U L'
H/Double Sune: U' L' (U D') l2 L2 U l2 U' L
U/Headlights: U R U' R2' D2 R U2 R U' R'
T/Chameleon: R' (U2 D2) R' D R2 U2 D R
L/Bowtie: L U R U' L U2 L2 U' R'
Pi/Wheel: R U2 L2 U R U D r2' R U R



H / Double Sune


Spoiler



Sune: D R (U D') L2 R2 U' r2 U R'
antiSune: D' L' (U' D) L2 R2 U l2 U' L
H/Double Sune: R2 (U' D) L (U D') L2 l2 (U D') L
U/Headlights: R D R' U D2 l2 U2 R' U' R'
T/Chameleon: L D L' U' D2 r2 U2 L' U' L'
L/Bowtie: L U' L2 R2 U' L' l2 D U2 L
Pi/Wheel: R' U' L2 U R2 (U' D) r2 R' (U' D) R'



U / Headlights


Spoiler



Sune: R U' R2 D L' R2 U R' U' L
antiSune: L' U R U' L l2 U l2 U R'
H/Double Sune: R U R' U2 D R2 U2 R' U' R'
U/Headlights: U2 L' U L' U' r2 U' L U L'
T/Chameleon: R (U' D) R U' R' U2 D' R'
L/Bowtie: D' L' U' L' U2 L U' L
Pi/Wheel: L' U R U2 R' U L R U R'



T / Chameleon


Spoiler



Sune: L U' L' D' L2 U2 L' U' L'
antiSune: R' (U2 D2) R' U R2 U D2 R
H/Double Sune: L U L' U2 D' L2 U2 L' U' L'
U/Headlights: L2 U2 L' U' L U2 L' U' L'
T/Chameleon: R (U2 D2) R' (U2 D2) R'
L/Bowtie: U R U D2 R' U' D2 R'
Pi/Wheel: L' U' L l2 U' l2 U' L' U2 L



L / Bowtie


Spoiler



Sune: R U L2 U2 L' U R' U' L'
antiSune: x2 L U R U' L U2 L2 U' R' (or do all the Us as Ds, and don't rotate)
H/Double Sune: L U L2 U' L U' D2 L U2 L
U/Headlights: U' L' D' L' D2 L D' L
T/Chameleon: D R U2 D R' U2 D' R'
L/Bowtie: L U' D' L U D L'
Pi/Wheel: L' U' L2 U' L' U2 D' L2 U' L'



Pi / Wheel


Spoiler



Sune: L U D L' U2 D L' U D2 L'
antiSune: D R U L2 U D R U2 r2 U' R'
H/Double Sune: R' U L2 U' R2 (U D') L2 R (U' D) R'
U/Headlights: R' U' r2 D2 U' R' U r2 U' R
T/Chameleon: L' U' L2 D2 L U2 D' L U' L
L/Bowtie: D L' U' D' L D R2 U L R2
Pi/Wheel: L U D L' U2 D2 L U D L'


See also: This pretty table I made




Example Solves


Spoiler



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

EO: U2 D2 R y [3/3] (STM)
Belt: D' U2 R' L2 U L [6/9]
Corner parity: L' U2 L' D2 L U2 L [7/16]
EPOBL: x2 L' U2 L2 U L2 U L2 U2 L' [9/25]
Seperation+D Layer Corners: D' L2 U L2 U' R2 U2 R2 y' M' U2 M U' M U2 M' [15/40]
EPPBL: D2 r2 U' l2 U l2 U R2 U l2 U' L2 U' R2 (U' D) L2 U' l2 U L2 (D) [22/62]
(that's the longest EPPBL case)

L' B2 D' L F' R' D U2 B' F2 L' F2 B D L' B2 F2 U' F B2 R' B'

EO: y U D' R2 F [4/4] (3/3 STM)
Belt: U D R D L2 D L' [7/11] (7/10 STM)
Corner Parity: none
EPOBL: U2 x2 R' U L2 U' R2 (U D') L2 R (U' D) R' [13/24] (11/21 STM)
Separation+D Layer Corners: U2 R2 U' R2 L2 U' L2 d' M' U2 M [13/37] (11/32 STM)
PLL Parity: U' M2 U2 M2 [6/43] (4/36 STM)
EPPLL: U' D' l2 U' l2 U' D' L2 U l2 U' l2 U' D' R2 U' L2 U2 R2 U [20/63] (20/56 STM)

B' U F' L' F2 L' D' B U' B2 D2 B2 L2 F' B2 R L' U' D' R2 D B' U L' U' 

EO: D' R' U R F (5/5)
Belt: D' R' D R D L2 D2 L' (8/13)
Corner Parity: U R2 U R2 (4/17)
EPOCLL: x2 U L U' L' D' L2 U2 L' U' L' (10/27)
Seperation+ D Corners: R2 D2 U R2 U' R2 U2 R2 S U2 S' U M' U2 M (15/42)
EPPBL Parity: M2 U2 M2 (3/45)
EPPBL: D' U' L2 U D L2 U l2 U L2 R2 U L2 U' L2 U' D' L2 U' D' (20/65)

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

EO: L' D' F R' B R B' (7/7)
Belt: L F2 B2 (3/10)
Corner Parity: U L2 U2 L2 (4/14)
EPOCLL: U x2 U' L U L' U2 L' (U D') L2 U' L (11/25)
Separation: F2 U F2 D' R2 U' R2 M' U2 M2 U2 M' (d U) M' U2 M (17/42)
PLL Parity: D2 M2 U2 M2 (4/46)
EPPLL: U2 r2 U L2 U l2 U L2 U2 l2 U' r2 U r2 (U D') r2 U D (18/64)

more later.



Have fun.

(Also, this is my 500th post on Speedsolving!)

See also:
A different belt method.
A method that could become a belt method. (Guimond style separation of all layers)


----------



## qqwref (Jun 23, 2011)

The EPOCLL algs are generally pretty nice, actually, but EPPBL looks just awful. So many double turns... It seems like the quarter-turn movecount would be very high.

Also, I don't think your orientation parity algs will always solve the case. Flip URF counterclockwise and DLF clockwise. Now neither of your parity algs will do anything. I have a feeling, though, that you can always navigate to a solvable OLL case using something of the form U^a D^b R2 U^c R2. In this case it would be something like U R2 U' R2, and now you have 2 flipped corners on D and 0 on U.


----------



## Cool Frog (Jun 23, 2011)

Move counts and some example solves would help?
Can't just judge a method before you try it (going to do that later)


----------



## EnterPseudonym (Jun 23, 2011)

Use a lower case "L" so it looks like ICBM, which is obviously way cooler.


----------



## OMGitsSolved (Jun 23, 2011)

Cool Frog said:


> Move counts and some example solves would help?
> Can't just judge a method before you try it (going to do that later)


 
We are going to do that tommorow. We are both tired.


----------



## Zarxrax (Jun 23, 2011)

Seems like a fun method, but trying to recognize cases on U and D simultaneously seems painful.


----------



## uberCuber (Jun 23, 2011)

EnterPseudonym said:


> Use a lower case "L" so it looks like ICBM, which is obviously way cooler.


 
Inter-Continental Ballistic Missile method
Must be fasts :tu


----------



## OMGitsSolved (Jun 23, 2011)

Zarxrax said:


> Seems like a fun method, but trying to recognize cases on U and D simultaneously seems painful.


 
Mirroring EPLL cases upside down isn't that hard. But your right about EPOBL cases. I'm pretty sure with practice it will come easily.


----------



## irontwig (Jun 23, 2011)

Another way to reduce to <U,D,R2,L2,F2,B2>:

http://www.speedsolving.com/forum/s...ing-Discussion&p=556670&viewfull=1#post556670


----------



## Georgeanderre (Jun 23, 2011)

Looks interesting, i will have to try this method sometime, 

although once you have solved the belt, you could orient the corners and solve it like a domino...?
note: ive not tried this and i dont own a domino so i might be completely off the mark...

EDIT: thought about the above, it could potentially mix up the belt pieces... but this is fixed with z or z' and a roux cycle


----------



## Godmil (Jun 23, 2011)

The methods of reducing the cases are pretty good. I've heard lots of people mention PBL on 3x3, but didn't think anyone would come up with a working system (and I never imagined anyone would try OBL  )
So well done for that. It's an impressive bit of work coming up with the whole system.

However..... the complexity of some of the stages and high alg count mean I can't really see anyone adopting it. It certainly doesn't jump out as a method that could be very fast (though I'd be happy to be proven wrong)

One question, I had both layer orientated and they were all sorted except for one corner in each layer... what is the best way of fixing that?


----------



## Cubenovice (Jun 23, 2011)

Nice idea and you have clearly put some effort into this.

But I do not think this method is for me, way to alg-heavy (and with looong algs at that).

I will try your step 3 "parity alg" in my Human Thistlethwaite solves though.
Takes the "thinking" out of turning "new OLL's" into standard OLL's.

Butthis reminds me to start working again on my HTA alg list for the "new" OLL's.
Should be about 10 algs using a Guimond style approach.
Alg restrictions of keeping EO and keeping belt edges in the belt (but may permute in it).


----------



## caseyd (Jun 23, 2011)

I done think you could solve it like a domino, there would probably be some sort of parity (probably just a pll, its wortha shot if you want to try it


----------



## OMGitsSolved (Jun 23, 2011)

caseyd said:


> I done think you could solve it like a domino, there would probably be some sort of parity (probably just a pll, its wortha shot if you want to try it


 
Lol wtf?


----------



## riffz (Jun 23, 2011)

Sounds slow :\


----------



## Owen (Jun 23, 2011)

caseyd said:


> I done think you could solve it like a domino, there would probably be some sort of parity (probably just a pll, its wortha shot if you want to try it


 
Naw, the domino's corner's can't be rotated, the 3x3's can.


----------



## Erzz (Jun 23, 2011)

qqwref said:


> The EPOCLL algs are generally pretty nice, actually, but EPPBL looks just awful. So many double turns... It seems like the quarter-turn movecount would be very high.
> 
> Also, I don't think your orientation parity algs will always solve the case. Flip URF counterclockwise and DLF clockwise. Now neither of your parity algs will do anything. I have a feeling, though, that you can always navigate to a solvable OLL case using something of the form U^a D^b R2 U^c R2. In this case it would be something like U R2 U' R2, and now you have 2 flipped corners on D and 0 on U.


 
He told me to generate the EPPBL as <R2,L2,U,D>. The QTM counts are like 25 or 30. (Snyder metric is most flattering for these algs) That move group lets you just do r2 or l2 to change Ds to Us, and some of the algs turned out quite nicely. (though some are bad, they should still be sub 2 able with practice)
We had a lot of trouble with the corner parity. I'm not sure how you would recognize which moves to do for your way. If you figure something out, let us know.



irontwig said:


> Another way to reduce to <U,D,R2,L2,F2,B2>:
> 
> http://www.speedsolving.com/forum/s...ing-Discussion&p=556670&viewfull=1#post556670



The EO isn't for reducing movetypes, it's for reducing OLL cases.



Godmil said:


> However..... the complexity of some of the stages and high alg count mean I can't really see anyone adopting it. It certainly doesn't jump out as a method that could be very fast (though I'd be happy to be proven wrong)
> 
> One question, I had both layer orientated and they were all sorted except for one corner in each layer... what is the best way of fixing that?



Corner parity and recognizing cases on both sides are really the only complex steps.
You can do some PLL/commutator stuff to swap just the corners if you don't want to mess up your edges. If you don't care about edges, put the corner which is in U to the UBR position, and the spot it needs to go in the DFR position, and do R2 U' R2 U' R2 U R2.



Cubenovice said:


> But I do not think this method is for me, way to alg-heavy (and with looong algs at that).
> 
> I will try your step 3 "parity alg" in my Human Thistlethwaite solves though.
> Takes the "thinking" out of turning "new OLL's" into standard OLL's.


 
The orientation algs are only like 9 or 10 moves.
The parity alg messes up a lot of stuff, not sure what Thistlethwaite solves before parity. See qqwref's post though.


----------



## irontwig (Jun 23, 2011)

Erzz said:


> The EO isn't for reducing movetypes, it's for reducing OLL cases.



How does that matter? The fact still remain that your first 4 steps does reduce the cube to said generators. The only difference is that when doing reduction E might be unsolved, but takes at most two moves. Not that I think that any method based on the same idea(s) has much of a (speed) potential.


----------



## Hodari (Jun 23, 2011)

Godmil said:


> One question, I had both layer orientated and they were all sorted except for one corner in each layer... what is the best way of fixing that?



How about placing one corner in UBR and one in DLF and do L2 A(a) L2 ?

Also, I came up with a somewhat different belt method a few months ago. Not sure if anything in there might be useful or if the 2 methods can be combined in any way to make them more efficient but might be worth a look.


----------



## Erzz (Jun 23, 2011)

irontwig said:


> How does that matter? The fact still remain that your first 4 steps does reduce the cube to said generators. The only difference is that when doing reduction E might be unsolved, but takes at most two moves. Not that I think that any method based on the same idea(s) has much of a (speed) potential.


 
I'll have to go look up Kociemba to understand what you're doing in that solve. It looks hard to recognize though.


----------



## irontwig (Jun 23, 2011)

It isn't; EOa is just orienting one ledge and one redge at the same time, EOb is just LSE. Freestyle finish is probably not the best for speed though.


----------



## NaeosPsy (Jun 23, 2011)

Yah, some stages are too complex. 
Maybe you can do PLL in 2-looks, like, you learn all the cases(and their algs or what) that can be on U or D(if you solve D corners) without separation and then x2 and do normal PLL?


----------



## Erzz (Jun 23, 2011)

irontwig said:


> It isn't; EOa is just orienting one ledge and one redge at the same time, EOb is just LSE. Freestyle finish is probably not the best for speed though.


 
So, like roux, orientating the edges that would be in the blocks if there were blocks, and then LSE?



NaeosPsy said:


> Yah, some stages are too complex.
> Maybe you can do PLL in 2-looks, like, you learn all the cases(and their algs or what) that can be on U or D(if you solve D corners) and then x2 and do another normal PLL?


 
If you're doing it in two looks, no need to solve the D corners. Just PLL on top, x2, PLL on bottom. People say belt methods aren't practical due to high move count and alg count, this method has reasonable move count (like 60-70, I don't know how to calculate) and only 161 algs (29 of which are Fridrich).


Another example solve in OP.


Spoiler



L' B2 D' L F' R' D U2 B' F2 L' F2 B D L' B2 F2 U' F B2 R' B'
EO: y U D' R2 F [4/4] (3/3 STM)
Belt: U D R D L2 D L' [7/11] (7/10 STM)
Corner Parity: none
EPOBL: U2 x2 R' U L2 U' R2 (U D') L2 R (U' D) R' [13/24] (11/21 STM)
Separation+D Layer Corners: U2 R2 U' R2 L2 U' L2 d' M' U2 M [13/37] (11/32 STM)
PLL Parity: U' M2 U2 M2 [6/43] (4/36 STM)
EPPLL: U' D' l2 U' l2 U' D' L2 U l2 U' l2 U' D' R2 U' L2 U2 R2 U [20/63] (20/56 STM)


----------



## OMGitsSolved (Jun 23, 2011)

Actually 51 algs are Fridrich and 42 of them are PLL.



NaeosPsy said:


> Yah, some stages are too complex.
> Maybe you can do PLL in 2-looks, like, you learn all the cases(and their algs or what) that can be on U or D(if you solve D corners) without separation and then x2 and do normal PLL?


 
Actually you could put the D layer corners in place as said and do top layer PLL then do a EPLL.


----------



## Hershey (Jun 23, 2011)

irontwig said:


> Another way to reduce to <U,D,R2,L2,F2,B2>:
> 
> http://www.speedsolving.com/forum/s...ing-Discussion&p=556670&viewfull=1#post556670


 
The Human Kociemba method that Thom Barlow did in one video?


----------



## irontwig (Jun 23, 2011)

Hershey said:


> The Human Kociemba method that Thom Barlow did in one video?


 
No, Thom first solves as a three colour cube (treating opposite colours as the same) and then finishes up.


----------



## OMGitsSolved (Jun 23, 2011)

I think we kinda fixed the corner parity.
Here's a new solve.

B' U F' L' F2 L' D' B U' B2 D2 B2 L2 F' B2 R L' U' D' R2 D B' U L' U' 

EO: D' R' U R F
Belt: D' R' D R D L2 D2 L'
Corner Parity: U R2 U R2
EPOCLL: x2 U L U' L' D' L2 U2 L' U' L'
Seperation+ D Corners: R2 D2 U R2 U' R2 U2 R2 S U2 S' U M' U2 M 
EPPBL Parity: M2 U2 M2
EPPBL: D' U' L2 U D L2 U l2 U L2 R2 U L2 U' L2 U' D' L2 U' D'

Thanks qq.


----------



## Hershey (Jun 23, 2011)

irontwig said:


> No, Thom first solves as a three colour cube (treating opposite colours as the same) and then finishes up.


 
How do you do that?

EDIT: He was doing it roux style...


----------



## qqwref (Jun 23, 2011)

Erzz said:


> We had a lot of trouble with the corner parity. I'm not sure how you would recognize which moves to do for your way. If you figure something out, let us know.


The idea is this: R2 U' R2 basically replaces DRF with ULF. So what you want to do is replace one corner on D with a differently-oriented one, fixing the corner parity. If you want to rotate a bottom corner clockwise, for instance, you could replace solved with clockwise, or clockwise with counterclockwise, or counterclockwise with solved.

Another option (if you're willing to have the belt be either solved or an R2 off, which might be worthwhile for corner separation) is to simply do an R2, moving two corners to the bottom layer. I am not sure this can always create a solvable parity case, but it seems to work most of the time, so it's probably still useful (and hey, one move is better than 3 or 7, eh?). I guess, yeah, if you're going to separate later, it wouldn't hurt to leave the belt up to an R2 off - no point wasting moves keeping it that way when you're just going to intuitively mess it up later.



Erzz said:


> People say belt methods aren't practical due to high move count and alg count, this method has reasonable move count (like 60-70, I don't know how to calculate) and only 161 algs (29 of which are Fridrich).


Er, actually, I'd consider that both high move count and high alg count. 160 algs is a huge number especially if the majority of them are 20 moves long and totally unintuitive.


----------



## Hershey (Jun 23, 2011)

Separating pieces in the U and D layers reminds me of 5x5 centers. And it's so fun!


----------



## mr. giggums (Jun 23, 2011)

OMGitsSolved said:


> I think we kinda fixed the corner parity.
> Here's a new solve.
> 
> B' U F' L' F2 L' D' B U' B2 D2 B2 L2 F' B2 R L' U' D' R2 D B' U L' U'
> ...


 
Instead of bolded above you could do it like this.

Bottom layer(domino style, intuitive):F2 D2 R2 U M2 U' L2 U2 L2 F2 U L2 U D2 B2 R2
PLL: U' (J-Perm) U'

This reduces the algs to 56+21=77 (or just 56 if you know PLL) rather than 56+105=161.


----------



## Erzz (Jun 23, 2011)

qqwref said:


> The idea is this: R2 U' R2 basically replaces DRF with ULF. So what you want to do is replace one corner on D with a differently-oriented one, fixing the corner parity. If you want to rotate a bottom corner clockwise, for instance, you could replace solved with clockwise, or clockwise with counterclockwise, or counterclockwise with solved.
> 
> Another option (if you're willing to have the belt be either solved or an R2 off, which might be worthwhile for corner separation) is to simply do an R2, moving two corners to the bottom layer. I am not sure this can always create a solvable parity case, but it seems to work most of the time, so it's probably still useful (and hey, one move is better than 3 or 7, eh?). I guess, yeah, if you're going to separate later, it wouldn't hurt to leave the belt up to an R2 off - no point wasting moves keeping it that way when you're just going to intuitively mess it up later.
> 
> ...


 
Hm.. I think I get it. I'll quote this in the OP.
It's not unreasonably high though. Only ~10 more than Fridrich, which is the most popular method. Almost the same amount of algs as MLGS, but yeah it is quite a bit. I doubt anyone will ever learn this method. There may be ways to further lower the number of algorithms that hasn't been discovered yet. (you could always just insert the edges in their correct places during separation and do PLL, then there's just ~80 algorithms, but move count is higher by 3-12)

Example solve of what I meant


Spoiler



B' L2 U F D F D U' F' B' D F' U' R2 L' B L2 R D2 L2 F L' U' R' B2
EO: L' D' F R' B R B' (7/7)
Belt: L F2 B2 (3/10)
Corner Parity: U L2 U2 L2 (4/14)
EPOCLL: U x2 U' L U L' U2 L' (U D') L2 U' L (11/25)
Separation: F2 U F2 D' R2 U' R2 U M' U2 M y' M' U2 M2 U2 M' D' M U2 M' D (21/46)
PLL: U' R U R' U' R' F R2 U' R' U' R U R' F' (15/61)


----------



## qqwref (Jun 23, 2011)

Erzz said:


> Hm.. I think I get it. I'll quote this in the OP.
> It's not unreasonably high though. Only ~10 more than Fridrich, which is the most popular method.


Uh, what? Fridrich has 78 algs including inverses and mirrors - this is about twice that. Even if you add F2L (and you shouldn't) you have about 40-50 more. And your PLL+EPLL algs are both harder to execute and harder to remember than all the Fridrich ones.



Erzz said:


> You could always just insert the edges in their correct places during separation and do PLL, then there's just ~80 algorithms, but move count is higher by 3-12


I'm not sure move count is higher at all, actually. I don't see any obvious way to save moves by building the separated first layer with the corners intact but the edges not; if you just build blocks, it's actually pretty efficient, and you can actually do the whole thing in <U,R2,D> and get high TPS out of it. No M'U2M inserts needed.


----------



## uberCuber (Jun 23, 2011)

qqwref said:


> Uh, what? Fridrich has 78 algs including inverses and mirrors - this is about twice that. Even if you add F2L (and you shouldn't) you have about 40-50 more. And your PLL+EPLL algs are both harder to execute and harder to remember than all the Fridrich ones.


 
I think that part of his post was directed at movecount, not alg count


----------



## Erzz (Jun 23, 2011)

qqwref said:


> Uh, what? Fridrich has 78 algs including inverses and mirrors - this is about twice that. Even if you add F2L (and you shouldn't) you have about 40-50 more. And your PLL+EPLL algs are both harder to execute and harder to remember than all the Fridrich ones.





uberCuber said:


> I think that part of his post was directed at movecount, not alg count





qqwref said:


> I'm not sure move count is higher at all, actually. I don't see any obvious way to save moves by building the separated first layer with the corners intact but the edges not; if you just build blocks, it's actually pretty efficient, and you can actually do the whole thing in <U,R2,D> and get high TPS out of it. No M'U2M inserts needed.



I just tried this a couple of times, and it does seem to be <= the way we originally came up with (move count wise). However, either I'm bad at building blocks, or it's really hard to block build this quickly. Maybe it would be fast with practice, I'm not sure yet.


----------



## Athefre (Jun 23, 2011)

The idea in this topic has some appealing steps. It reduces the cube to PLL like so many do (not that it's a bad thing for speed), but I really like the corner orienting. Fewer cases than I expected.

Like has already been discussed many times, the biggest problem with these belt methods is the belt itself. A couple of years ago I was studying these types of orient-all methods, trying to develop a version that removed many of the problems (belt restrictions, number of half-turns, move-count, look-ahead). I eventually arrived at the solution on my site. Half-belt (ZZ), few half-turns, and an average move count of ~45. I've since thought of more variations that are better (better look-ahead), but I lack the web programming knowledge to make attractive pages.


----------



## Hershey (Jun 23, 2011)

Belt method = square-1 on 3x3?


----------



## Erzz (Jun 23, 2011)

Hershey said:


> Belt method = square-1 on 3x3?


 
after orientation


----------



## Kirjava (Jun 23, 2011)

00:35:24 <+Kirjava> TFM, Salvia and Belt fall under a method category that I like to call "bad ideas"


----------



## Erzz (Jun 24, 2011)

Kirjava said:


> 00:35:24 <+Kirjava> TFM, Salvia and Belt fall under a method category that I like to call "bad ideas"


 
 At least I've never used Salvia. I think Belt could have a reasonable move count if we used qqwref's block building idea.


----------



## uberCuber (Jun 24, 2011)

Kirjava said:


> 00:35:24 <+Kirjava> TFM, Salvia and Belt fall under a method category that I like to call "bad ideas"


 
Off topic, curious, what do you think of Tripod?


----------



## Kirjava (Jun 24, 2011)

Sorry, but if you are proposing this as anything other than fun you are deluded about what makes a good speedsolving method.

EDIT:



uberCuber said:


> Off topic, curious, what do you think of Tripod?



Trying to solve the tripod efficiently is fun. And hard.


----------



## OMGitsSolved (Jun 24, 2011)

B2 D B' R' D' F' D' U2 B2 F2 R2 F D' B2 U' F' U2 F' R' U' L U L' U' D'
Quarter turn metric
EO: D F B U B' (5,5)
Belt: R B2 R2 D' L2 D' L (7,12)
EPOCBL: U2 x2 R U' R2' D2 R U2 R U' R' (10,22)
1x2x3 Block: x2 U R2 D' R2 D' U' R2 U2 R2 U' R2 (11,33)
1x1x3 Block: D' R2 U2 R2 U' R2 D (7,40)
PLL: U R' U R U' R2 F' U' F U R x U R' U' R2 (15,55) stupid e perms.

qq, is this what you were talking about? Would this be better? 
I'm liking both of them but the first version does have more algs.
EDIT:

This is how it would've gone done with the original version...
Quarter Turn Metric
EO: D F B U B' (5,5)
Belt: R B2 R2 D' L2 D' L (7,12)
EPOCBL: U2 x2 R U' R2' D2 R U2 R U' R' (10,22) 
Seperation+D Layer Corners: x2 D' U' D' U R2 M' E2 M' (8,30)
EPPBL Parity: M2 U2 M2 D' (4,34)
EPPBL(U PLL Subgroup): U' R U R' F' R U R' U' R' F R2 U' R' U (15,49)

Hm?


----------



## cuBerBruce (Jun 24, 2011)

Erzz said:


> *Step 1) Edge Orientation*​The first step is to orientate all the edges. This is the same as ZZ except you don't make a line. Well, you could make a line, but it would have to be somewhere on the E layer, rather than D. Check out some ZZ guides to see how to do this.
> 
> *Step 2) Make a Belt*​Solve all the edges on E. You can make the belt on M or S, but it has to end up on E, and you can't rotate or else EO will get messed up. So making it on E is probably the best. This is completely intuitive, similar to the cross.



The above is not really correct.

Assuming you orient using the <U,D,L2,R2,F2,B2> EO scheme, then the belt must be on E or M (without making any cube rotations). If the belt is made on M, the cube can be rotated with a z or z' so the belt is on E in the rotated cube. Making the belt on S, and rotating the cube to make the belt on E, would generally mess up EO.

(Of course, making the belt on M instead of E affects what colors you would then use for CO.)

If you did happen to make an EOLine, with the line on D as usual for ZZ, then that line could be used as a start for a belt on M. A z/z' can then be used to make the line (and belt-to-be) on E. Of course, if you try to build an EOLine, you could simply try to build the line on L or R (directly in the E layer to avoid needing a z/z' rotation).


----------



## qqwref (Jun 24, 2011)

OMGitsSolved said:


> B2 D B' R' D' F' D' U2 B2 F2 R2 F D' B2 U' F' U2 F' R' U' L U L' U' D'
> Quarter turn metric
> EO: D F B U B' (5,5)
> Belt: R B2 R2 D' L2 D' L (7,12)
> ...


Yeah, that's the general idea (although you're not counting in quarter-turn metric (if you were it'd be 74 moves, I think) and that's an F perm, not E).

The first example solve in the first post (the one that's listed as 62 moves) is 92 sqtm. That's the big problem with the PLL+EPLL idea, it's just a huge number of quarter turns and thus takes a lot of time to perform, plus you do have to adjust two layers.


----------



## OMGitsSolved (Jun 24, 2011)

qqwref said:


> Yeah, that's the general idea (although you're not counting in quarter-turn metric (if you were it'd be 74 moves, I think) and that's an F perm not an E.


 Oh, silly me I used to mix those up when I learned PLL and it came back to haunt me. And I'm nub at turn metrics.


----------



## Erzz (Jun 24, 2011)

OMGitsSolved said:


> Oh, silly me I used to mix those up when I learned PLL and it came back to haunt me. And I'm nub at turn metrics.


 
QTM = every 90 degree turn is 1, slices are 2 per 90
HTM = every turn of a face is 1 (90 or 180), slices are 2
STM = every turn of a face or slice is 1 (90 or 180)
Snyder Metric = every turn of opposite faces is 1 (90 or 180) ie U D F B R U is 4. U D are opposite, F B are opposite. No one uses this though


----------



## uberCuber (Jun 24, 2011)

SQTM = every 90 degree turn of a face or slice is 1


----------



## qqwref (Jun 24, 2011)

I think Snyder Metric and Axial Turn Metric (ATM) are the same thing, although I could be wrong. A long time ago I used AQTM (axial quarter turn metric) to describe how the Ryan Heise sim functioned.


----------



## OMGitsSolved (Jun 25, 2011)

Updated version

Introduction


New method! LCBM is a belt method, concieved by Nick Long, aka OMGitsSolved. He contacted me about generating some algorithms to permute both layers and orientate both layers. Not in the same step, of course. Now you're probably thinking "wat, that's like 3768 algorithms!" Well, it would be, but Nick cleverly came up with ways to reduce this number to just 161. Let's get into the method.

Step 1) Edge Orientation

The first step is to orientate all the edges. This is the same as ZZ except you don't make a line. Well, you could make a line, but it would have to be somewhere on the E layer, rather than D. Check out some ZZ guides to see how to do this.

Step 2) Make a Belt
Solve all the edges on E. You can make the belt on M or S, but it has to end up on E, and you can't rotate or else EO will get messed up. So making it on E is probably the best. This is completely intuitive, similar to the cross.
(You actually can make it on M without messing up the EO.)

Step 3) Fix Corner Orientation Parity (if any)
If you have an OLL case on U that you don't recognize, it's because a corner is twisted that shouldn't normally be twisted. See this post from qqwref on how to deal with parity.
Spoiler:
Quote Originally Posted by qqwref
The idea is this: R2 U' R2 basically replaces DRF with ULF. So what you want to do is replace one corner on D with a differently-oriented one, fixing the corner parity. If you want to rotate a bottom corner clockwise, for instance, you could replace solved with clockwise, or clockwise with counterclockwise, or counterclockwise with solved.

Another option (if you're willing to have the belt be either solved or an R2 off, which might be worthwhile for corner separation) is to simply do an R2, moving two corners to the bottom layer. I am not sure this can always create a solvable parity case, but it seems to work most of the time, so it's probably still useful (and hey, one move is better than 3 or 7, eh?). I guess, yeah, if you're going to separate later, it wouldn't hurt to leave the belt up to an R2 off - no point wasting moves keeping it that way when you're just going to intuitively mess it up later.


Step 4) E Preserve Orient Both Layers

Orientate both U and D layers while preserving the E layer. The U and D layers will get mixed up in this step. Algorithms are below. Since we did EO, there are only 56 (7 are just OLL) cases, rather than 3249.


Step 5) 1x2x3 Block On Bottom

This is done using only R2, U, and D moves. This can be completed by making a 1x2x2 block on bottom then adding a 1x1x2 block. The belt can be a R2 off at the end.

Step 6) Expand 1x2x3 to 1x3x3

This is done with the same turn mask (R2, U,and D). Simply move the 1x2x3 block to the left of the D layer and the make the 1x1x3 by connecting the corners to the remaining edge. While completing the block make sure you have the belt completely solved. Then align the D layer.

Step 7) PLL
Last step of the Fridrich method and many other methods.
http://www.speedsolving.com/wiki/index.php/Special:AlgDB?mode=view&view=default&puzzle=3&group=PLL

This does decrease the alg count and it may be more efficient.
Leaving the algs with just EPOCBL and PLL. Thanks, qqwref!


----------



## Erzz (Jun 25, 2011)

Example solve of the new way.
B' R' L2 B R B' D F2 U' F D' R D2 F' R' F L2 U2 R' D L2 U B' D' R
STM
EO: D B D' F' D F (6/6)
Belt: L2 D' U R' (4/10)
Corner Parity: R2 U2 R2 (3/13)
EPOCBL: U2 x2 U' L' (U D') l2 L2 U l2 U' L (10/23)
D layer: U' L2 U2 L2 U' M' U2 M2 U2 M' y M' U2 M (13/36)
PLL: U' L' U L' U' L' U' L' U L U L2 (12/48)

Maybe more later.


----------



## OMGitsSolved (Jun 25, 2011)

Erzz said:


> Example solve of the new way.
> B' R' L2 B R B' D F2 U' F D' R D2 F' R' F L2 U2 R' D L2 U B' D' R
> STM
> EO: D B D' F' D F (6/6)
> ...


 
Not exactly the new way but close.


----------



## Erzz (Jun 25, 2011)

OMGitsSolved said:


> Not exactly the new way but close.


 
Combining the blockbuilding steps.


----------



## OMGitsSolved (Jun 27, 2011)

Decided to do at least 5 example solves tonight with qq's idea. I like it a lot.

L F' D L2 U' D B' F' R' U B2 L' B' F2 D U' R U' L F' B2 L D' B2 R

EO: y L B2 L B'
Belt: U D' L' R2 D R'
Corner Parity: R2 (qq's idea; since the next after orientation it doesn't need to be alligned)
EPOCBL: x2 U' L D' L' U' r2 U2 L' U' L'
1x2x3: D R2 D' R2 L2 D' L2 R2 U' R2 B2 U2 B2 R2 (horrible...)
1x1x3: D' U R2 U' R2 U' R2 U R2 D
PLL: R' U2 R U2 R' F R U R' U' R' F' R2 U2

B D R' B' U' R2 D B' L2 F2 R2 F2 B' U' R D' B' D U2 F2 U2 B F' R L2

EO: y L' D2 B
Belt: L' D' R L D R'
Corner Parity: L2 y2
EPOCBL: U' L' U L' U' r2 U' L U L'
1x2x3: D2 U' R2 D' R2 D2 U R2 U2 R2 U R2
1x1x3: D U R2 U' R2 U' R2 U' R2 U' R2 U2 R2
PLL: y2 R U R' F' R U R' U' R' F R2 U' R' U'

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

EO: U L2 B
Belt: D L F2 R2 U R
EPOCBL: U2 x2 U R U R' U2 D R2 U2 R' U' R'
1x2x3: U' R2 D2 R2 D' U F2 U' F2 R2
1x1x3: D U R2 U2 R2 U' R2 U R2 U' R2 U' R2 U' R2
PLL: R2 u' R U' R U R' u R2 y R U' R' U'

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

EO: L' F B L B
Belt: D U L' R U' R
Corner Parity: R2
EPOCBL: x2 U2 R (U' D) R U' R' U2 D' R'
1x2x3: D L2 D L2 D' U' R2
1x1x3: D' U' R2 U R2 D2
PLL: R2 U R U R' U' R' U' R' U R'

D2 F L2 R2 B L' U2 R2 L F2 U' D' R' F U L2 B' L' U2 F2 U B L R F'

EO: y R' B F U' F 
Belt: R D L' D' L'
Corner Parity: L2 U' L2
EPOCBL: x2 U R' (U2 D2) R' U R2 U D2 R
1x2x3: U R2 D' R2 D' R2 D2 U2 R2 U R2
1x1x3: D U' R2 U' R2 U' R2 U' R2 U2 R2 D'
PLL: U' R U R' F' R U R' U' R' F R2 U' R' U2


----------



## Godmil (Jun 27, 2011)

ooh, that new way is actually a lot of fun. I'll never learn the single orientation stage, but I can see myself doing more solves with this method.


----------



## OMGitsSolved (Jun 27, 2011)

lol It's fun doing R2 U R2 U multiple times in a rapid motion? It is to me lol.


----------



## gbcuber (Jun 27, 2011)

OMGitsSolved said:


> Decided to do at least 5 example solves tonight with qq's idea. I like it a lot.
> 
> L F' D L2 U' D B' F' R' U B2 L' B' F2 D U' R U' L F' B2 L D' B2 R
> 
> ...


 
Make a video plz


----------



## OMGitsSolved (Jun 27, 2011)

Georgeanderre said:


> a video of some solves using "the new way"
> filmed and uploaded on june 24th, before it was even mentioned... i had planned to develop this myself but looks like a few people have beaten me to it
> Note: i dont know eoline
> 
> ...


 
You can avoid Belt parity... that's what your supposed to do. But I am happy people are trying it.
And really? You were going to develop this yourself before we posted it? I doubt it.



gbcuber said:


> Make a video plz


 
Of what?
The examples? Okay. George those weren't my examples right? Because I spent awhile doing those.


----------



## OMGitsSolved (Jun 27, 2011)

Georgeanderre said:


> With that said, im not trying to "steal" your method, im simply stating that we have both come up with the same idea...



No, please don't play this game with me. You called it intuitive in your video which it really isn't. My original idea was to place D layer corners then PBL Then qq gave me the D layer blockbuild idea. I really don't think you came up with the same idea. I checked your website, too. I would stop.


----------



## OMGitsSolved (Jun 27, 2011)

Georgeanderre said:


> I called it "intuitive" because it can be
> 
> You cant see the page from my website because its locked for my eyes only, there are 4 method variants on there so i wont make it public willy nilly -.-
> 
> ...



That's not the first version or second version. Stop trying. I really don't want to argue with some who has like 10 spelling mistakes in his spoiler.


----------



## StachuK1992 (Jun 27, 2011)

I ask again: movecount average estimate?


----------



## Erzz (Jun 27, 2011)

StachuK1992 said:


> I ask again: movecount average estimate?


 
Using the blockbuilding method, most of my solves are around 50-55 moves, sub-50 if I think a lot. (But I don't separate it into 1x2x3 - 1x1x3, also no EO line)
Using the EPPBL version, around 60-65.

For the orientation, 9 or 10 moves.
For the EPPBL, 18 moves (like 26 QTM, was told to generate in <L2, R2, U, D>) These are all customizable (can change l2->R2 and L2->r2 and vice versa as long as you switch the Us and Ds) but I don't recommend using them.

Is there someway to calculate what move count should be other than just averaging algs?


----------



## StachuK1992 (Jun 27, 2011)

I usually just do 12 solves and use qqtimer to 'manually input [movecount].'


----------



## OMGitsSolved (Jun 27, 2011)

Stachu, do you think George's idea was the same?


----------



## StachuK1992 (Jun 27, 2011)

I've no idea;
I'm at work without a cube or access to YouTube, but from his little description below the video, he asserts that it is, and if his post is true to what he did in the video, then sure.


----------



## Erzz (Jun 27, 2011)

StachuK1992 said:


> I usually just do 12 solves and use qqtimer to 'manually input [movecount].'


 
Doing this I got 51.08


----------



## Cool Frog (Jun 27, 2011)

This one is fun to solve with
Left block with white and yellow pieces for it (white and yellow block)
Right block (Same as above) 
Opposite layers white and yellow
Belt
Solve like domino, (I do it roux style sometimes get a super easy last 2 rows.


----------

