# Improvements for M2/R2



## Stefan (Oct 23, 2007)

Try this scramble: U' R' U M' U' R U M

Usually I'd solve it like this:
U2 M' U2 M'
U R' U' M2 U R U'
x M' U M' U M' U2 M U M U M U2 x'

Of course the inverse of the scramble is the much better way, directly solving the next two edges with a simple short commutator. I intend to use this for the "ugly" targets FU and BD (or UF and DB, depends on your view), as they're just M or M' away from the buffer, turning these ugly cases into quite good ones.

The second improvement idea is to first solve the edges with M2 as usual, and in case of parity, immediately fix the parity (i.e. solve the M slice) together with solving the first corner. If the corner target is in the left slice, use an L turn as setup move and then one out of three algs (one for each possible corner orientation). If the corner target is in the right slice, one out of 7 or 9 algs (depends on whether you allow the UBR corner to be misoriented, like I do so far) and no setup turns.


----------



## tim (Oct 23, 2007)

Thanks, Stefan for posting this. You showed me this commutator at the German Nationals, but unfortunately i was too tired to understand, what you are saying . And at home i couldn't figure out this easy commutator on my own...


----------



## Stefan (Oct 24, 2007)

I just looked at Erik's page to see how people who solve the M slice edge with correct orientation might solve it:

F E RUR' E' RU'R' F' M2
x' RU'R'U M2 U'RUR' x


----------



## masterofthebass (Oct 24, 2007)

I like putting the pieces in the correct orientation the first time. It's a little slower for me, but it saves me the time of flipping edges. My execution needs work (~30 secs), but o well, 2:30 isn't a horrible time.


----------



## Joël (Oct 24, 2007)

Hey Stefan,

That is a good solution indeed. Especially for the so called ugly target. Basically, you just switch to an M'/M method temporarely .

It's funny how DF is your buffer, while mine if FD btw... I found out about this last weekend. I remember we had the same thing for the corners (with your old corner method and the pseudo Y perm), where I just LBU as buffer .

- Joël


----------



## Marcell (Oct 24, 2007)

Wow, Stefan, both of these two ideas are great. Although the first one makes the memorisation a bit harder... But I guess once you get used to it, it gives a much nicer and faster solution for those "ugly" edges.

I hope you will develope these improvements and describe them on your website.


----------



## Lucas Garron (Oct 25, 2007)

StefanPochmann said:


> I just looked at Erik's page to see how people who solve the M slice edge with correct orientation might solve it:
> 
> F E RUR' E' RU'R' F' M2
> x' RU'R'U M2 U'RUR' x



Was going to post this earlier...
Anyhow, I'm planning to use that, but on 4x4x4 I go for safety not efficiency, so for this I'd do:
(URU')M2'(UR'U')M(URU')M(UR'U')M2' (uRu')M2'(uR'u')
The first part is an intuitive swapping.
The second part is a nice 3-move setup I found for RB (I don't like lU'R'U). Mirror works for LB, and u'Lu & uRu' work just as well

I decided that orienting resolved through setup is useless. I will either switch EO to F2/B2 restriction or (more likely) use M2 with tricks. I'm practicing M2 now.
Looks like we'll have a BLD revolution before the next Worlds...

By the way, I did 7 solves before getting ready for my MIT interview on Monday. 2 DNF's, the rest averaged to 1:35 (best was a 1:21...  )


----------



## Joël (Oct 27, 2007)

I also found another small improvement that I'd like to mention. I found that I don't really like to shoot to BL (I use FD as buffer btw, not DF), because I have to do x' and 4 setup moves. However, I DO like shooting to BU. Suppose the next two targets are BL and RF. I can use a setup move B', than just solve the first target with M2:

[Setup] B'
[Shoot to BL] M2
[Shoot to RF] URU' M2 UR' U'
[Undo setup] B

This shows once again how close to a 3 cycle method M2 really is. 

Btw, should I put 'shoot to BL' or 'shoot to BU'? hmmmz..


----------



## Joël (Oct 28, 2007)

I was thinking about this other nasty case... Shooting from buffer (in my case FD) to BU, which involves flipping both the edges. 

A possible way to deal with this is to setup the second next target at RD (or LD, and do a similar alg). Then do the algorithm:

y M' U M D M' U' M D' y'

This solves the next two targets.


----------



## masterofthebass (Oct 28, 2007)

Stefan posted this in another M2 thread.


StefanPochmann said:


> masterofthebass said:
> 
> 
> > I still have one more to learn (stupid UB).
> ...



It only solves UB but it does work pretty well. I like the idea of being able to do a 3-cycle though.


----------



## Joël (Oct 28, 2007)

masterofthebass said:


> Stefan posted this in another M2 thread.
> 
> 
> StefanPochmann said:
> ...



Yes, that is the one I use. The thing is though, it's 15 moves to solve 1 edge, whereas the suggestion I did solve 2 pieces in 8 moves, that's about 4 times more efficient .


----------



## jerjero (Nov 5, 2007)

can M2 edges be combined with 3 cycle corner permutations?


----------



## Marcell (Nov 5, 2007)

Of course. If parity occurs you can do M2 U2 M' U2 M and you'll have UB and UF swapped, so figuring out what pll to use is also very easy.


----------



## AvGalen (Nov 5, 2007)

Yes, but fixing parity would be different.

Too late. Our coffee machine is slow


----------



## masterofthebass (Nov 5, 2007)

You could also do U' F2 U M2 U' F2 U to switch UB and UR, which I do because I uses old Pochmann Corners (Y perm). I was never able to understand 3 cycle cornes, so my suggestion may be a little biased.


----------



## jerjero (Nov 7, 2007)

how will u clean messed up orientations for M2? sometimes my UB, UF, DB AND DF are misoriented how should i know if its oriented.. because when i inspect the cube it is correctly oriented but after i finished the edge cycle those targets are misoriented how will i aid this up?


----------



## Lucas Garron (Dec 7, 2007)

A while ago, I figured out a nice way to shoot FU and DB ( I never liked Erik's algs  )

FU: D [M' , U R2 U'] D' M2'
DB: M2' D [U R2 U' , M'] D'

The best part: These work for r2 on 4x4x4 BLD! 
[M => r]

Beats UR'U' r2 URU' r' UR'U' r' URU' r2 and so...


----------



## philkt731 (Dec 7, 2007)

Lucas Garron said:


> A while ago, I figured out a nice way to shoot FU and DB ( I never liked Erik's algs  )
> 
> FU: D [U R2 U' , M'] D' M2'
> DB: M2' D [M' , U R2 U'] D'
> ...


sorry but what do the brackets and the comma mean...?


----------



## philkt731 (Dec 7, 2007)

Joël said:


> masterofthebass said:
> 
> 
> > Stefan posted this in another M2 thread.
> ...


 yes but that doesn't include setup moves, which are surprisinlgy (or not) short (averages to 1.65 setup moves per edge): 0 or 1 or 2 for all edges on R or L (if you include using LD as another buffer spot) by using S and R/L and then 3 or 4 moves for M layer edges. I love this idea although it would take me a while to get used to it


----------



## Kenneth (Dec 7, 2007)

bla bla bla =)

Or: "I just realised I was wrong"


----------



## Johannes91 (Dec 7, 2007)

[X, Y] = X Y X' Y'

[U R2 U', M'] = U R2 U' M' U R2 U' M
[M', U R2 U'] = M' U R2 U' M U R2 U'

(This forum software is pretty good at messing up formatting.)


----------



## AvGalen (Dec 7, 2007)

I still don't understand.

What does the bracket mean?
What does the comma mean?


----------



## Stefan (Dec 7, 2007)

Arnaud, you're kidding, right? Or did someone crack your account? Or did you take Erik's pot? But just in case you're serious, yourself, and sober: Brackets and comma are the notational frame, and when Johannes provided the definition of the notation, X and Y weren't cube rotations but variables that can represent any algs. Aren't you good at fewest moves? Aren't commutators somewhat a requirement to be good at that?


----------



## masterofthebass (Dec 7, 2007)

Hmm... I just realized that these algorithms are messed up. If your buffer is the FD piece, then you have to perform an x' z2 before doing the algorithm. That's the only way that I could get these to work.


----------



## Lucas Garron (Dec 7, 2007)

masterofthebass said:


> Hmm... I just realized that these algorithms are messed up. If you're buffer is the FD piece, then you have to perform an x' z2 before doing the algorithm. That's the only way that I could get these to work.



Did I seriously make that mistake? I was being so careful...
I'll fix it, but if you know comms they should be easy enought to understand...

We need a 4x4x4 simulator that uses normal notation...
[Note to self: Implement that via PHP]


----------



## AvGalen (Dec 8, 2007)

StefanPochmann said:


> Arnaud, you're kidding, right? Or did someone crack your account? Or did you take Erik's pot? But just in case you're serious, yourself, and sober: Brackets and comma are the notational frame, and when Johannes provided the definition of the notation, X and Y weren't cube rotations but variables that can represent any algs. Aren't you good at fewest moves? Aren't commutators somewhat a requirement to be good at that?


 
OK, now I understand. It were just unclear examples because:
[X, Y] = X Y X' Y'

[U R2 U', M'] = U R2 U' M' U R2 U' M (not clear if the second U R2 U' is X or X')
[M', U R2 U'] = M' U R2 U' M U R2 U' (not clear if the second U R2 U' is Y or Y')

So let's make the example more clear:
[X, Y] = X Y X' Y'
[R U F, L D B] = (R U F) (L D B) (F' U' R') (B' D' L')

Just for the record: No pot was involved now or before. I don't know anything about the combination of Erik and Pot. I am good at Fewest Moves. It is completely unneccessary to know about commutators to be good at Fewest Moves. (but it doesn't hurt if you know how to use them either). I am good at Fewest Moves because I can find good beginnings and because I can avoid bad endings.


----------



## philkt731 (Dec 12, 2007)

Yeah I got the same thing as dan for Lucas' algos
so
D [U R2 U' , M'] D' M2'
M2' D [M' , U R2 U'] D'


should be:
B [F L2 F', M] B' M2
M2 B [M, F L2 F'] B' 
or
B' [F' R2 F, M] B M2
M2 B' [M, F' R2 F] B

I don't know about these, I think I'll stick with my variation of Erik's


----------



## Lucas Garron (Dec 12, 2007)

philkt731 said:


> Yeah I got the same thing as dan for Lucas' algos
> so
> D [U R2 U' , M'] D' M2'
> M2' D [M' , U R2 U'] D'
> ...


They could be. But they shouldn't be. The only reason I added half turns was to avoid a setup on B or F (and E/d in the comm, and maybe because it felt clearer to shoot the bufffer or "anti-buffer" with a modified M2 that blends better with the method). Didn't anyone think to see what the comm was doing and switch the two halves?

Anyhow, I corrected the algs in my post a while ago...


----------



## philkt731 (Dec 12, 2007)

oh! I didn't see you fixed them! Thank you, those are nice, I think I'll probably use them now.


----------



## mrCage (Dec 13, 2007)

masterofthebass said:


> Stefan posted this in another M2 thread.
> 
> 
> StefanPochmann said:
> ...



Hmm, (B' U R' B U') M2 (U B' R U' B) does the same. Am i using illegal generators here ?? :-?

- Per


----------



## philkt731 (Dec 19, 2007)

To go along with Joel's idea, we can do the same for FU and BD (using DF as buffer). for FU set up the next edge at DR (or DL) and do y' M' U' M D M' U M D' and for BD setup the next at DR (or DL) and to y' R2 M' U M D M' U' M D' R2


----------



## macky (Jan 3, 2008)

Interesting thread.

I don't like having to shoot to FU or RD to deal with bad targets. That actually requires thinking! Since I've been experimenting with a lettering scheme, I've found it natural in M2 to associate each letter, not each position, to an algorithm.

To make things easy, I'll use DF as the buffer in this post. I'll write (s) to represent the move in M2 that brings s, which can be any sticker in R/L layer, to UF, and (s)' for the inverse of (s). For example, (FR)=URU'. We can then handle the bad targets as follows:

(Next two stickers memorized: solution) 
FU s: M2 (s) M (s)' M
s FU: M' (s) M' (s)' M2
BD s: M2 (s) M' (s)' M'
s BD M (s) M (s)' M2

For example, to do (DF BD FR), use the third line: M2 (FR) M' (FR)' M', or M2-URU'-M'-UR'U'-M'. This way, we don't have to think at all where to shoot. For example, BD=X and FR=G in my current lettering scheme, so that cycle is XG. I've already associated G with URU', so I just substitute that into (FR); I don't even think about where G actually is.

This combined with normal M2 methods allow us to solve two stickers, exactly one of which is in the M slice, very easily and actually pretty efficiently. I know, for example, that Stefan's way for FU is faster, but the difference is only an M2.

With these tricks, it looks like we're heading in the direction of systematic 3-cycling, i.e. picking one sticker as the buffer and learning the solution to each of the 22*20=440 possible 3-cycles of stickers starting with the buffer. I think using DF or FR as the buffer makes all these cases actually pretty easy to organize. Plus, that way, you can start incorporating some of these cases into M2.

There are 6*16*2=192 cases involving exactly one sticker in the M slice, which we already covered. In addition, there are 3P2*2*2=24 cases where both stickers are in the M slice. It's probably not too bad to just memorize these cases. Can anyone think of a way to deal with the remaining 16*14=224 cases that's efficient and easy to learn?

Of course, we could split this into special cases. For example, if there is exactly one sticker in U layer, do an appropriate number of U turns to reduce to either UB or FU. That might require "too much" thinking, though.

-macky


----------



## Lucas Garron (Jan 3, 2008)

Hmm, I'm likng freestyle.
The greatest thing would be to use M2 and freestyle the M-slice pieces (easy), but unfortunately DF is a bad freestyle buffer...

Hmm, maybe I wanna actually try M' instead of M2, shooting to BU with Uf as a buffer? Since we're obviously heading toward getting used to it as 440 cases, we might as well go for slightly fewer moves...

Anyhow, I really gotta publish my freestyle comms with j'ey and Rowe...

And Macky: Don't memo the M-slice cases, it's easy to check whether two adjacent ones are exchangable (otherwise, do a double twist) and then Setup into a comm... The only exceptionsare M'U2MU2 type...


----------



## macky (Jan 3, 2008)

> Since we're obviously heading toward getting used to it as 440 cases, we might as well go for slightly fewer moves...


LOL Can't we strike some balance between efficiency and ease of memorization? Anyway, by the time we're done, we'll have blindfold cubing completely Fridrich-ized. Making blindfold cubing not very fun is so much fun.



> And Macky: Don't memo the M-slice cases, it's easy to check whether two adjacent ones are exchangable (otherwise, do a double twist) and then Setup into a comm...


Yeah, I figured, but that would require me to convert from letters to positions and actually think a bit. I don't yet know how if that's a problem in practice yet. I guess you don't need to worry about this as much since you memorize visually.



> but unfortunately DF is a bad freestyle buffer...


Could you give me an example of a good freestyle buffer?

Oh, I wasn't aware that you three were working together on this. I look forward to reading that.


----------



## Lucas Garron (Jan 3, 2008)

macky said:


> > Since we're obviously heading toward getting used to it as 440 cases, we might as well go for slightly fewer moves...
> 
> 
> LOL Can't we strike some balance between efficiency and ease of memorization? Anyway, by the time we're done, we'll have blindfold cubing completely Fridrich-ized. Making blindfold cubing not very fun is so much fun.


Fine, I'll do MGBLD instead. 
And corneres will still be hard.



macky said:


> > And Macky: Don't memo the M-slice cases, it's easy to check whether two adjacent ones are exchangable (otherwise, do a double twist) and then Setup into a comm...
> 
> 
> Yeah, I figured, but that would require me to convert from letters to positions and actually think a bit. I don't yet know how if that's a problem in practice yet. I guess you don't need to worry about this as much since you memorize visually.


I inted to adopt letter/word memo. But there must be a nice way to generally comm these.
(What if you hit an M slice pair with M2 off? Like: DB (DR UF) (BU LF). Execute separately? Convert?)



macky said:


> > but unfortunately DF is a bad freestyle buffer...
> 
> 
> Could you give me an example of a good freestyle buffer?


UF. I use it. Rowe uses it. (And Mátyás? He probably does ultra-free freestyle...)
Joey uses UR because it goes with old Pochmann, possibly allowing recourse to T-perms for bad cases. Erik uses UF_[corrected from UR]_ forTuRBo (a "restricted freestyle 3-cycle" [vs. M2 as basically 2-cycle]).



macky said:


> Oh, I wasn't aware that you three were working together on this. I look forward to reading that.


We're not, really. But I've discussed with both that we should post some algs and comms. I will, at least, and Joey's making a table (also for corners).

Anyhow, the best would be to use both. But DF is the best buffer compromise, and I really don't like that... I'm going to experiment with M' and see how it turns out. I just want fast times 

By the way, you're not also up applying for Caltech, are you?


----------



## joey (Jan 3, 2008)

Lucas Garron said:


> macky said:
> 
> 
> > > but unfortunately DF is a bad freestyle buffer...
> ...



I think Mátyás also uses UR like me, he probably saw me using it an decided to switch 

TuRBo actually uses UF as a buffer aswell.

I have actually been thinking about using UR -> UF -> UL -> UB, all as buffers. It does reduce the number of cycles needed, but I will have to see what the thinking time is like, since I would need to be good at seting up pieces with all 4 buffers.


----------



## Stefan (Jun 21, 2008)

I found another improvement for M2 and r2. Well, it reduces the number of moves, but it makes it less braindead. You be the judge.

Scramble:
(U R U' M2 U R' U')
(L U' L' U M2 U' L U L')

Usually you'd do the inverse of that to solve the two edges. But notice the four setup moves for the UL edge. It would be so much nicer to just set it up with a U turn, but argh, the setup moves must not change the M slice except for the UB edge. So this doesn't work:

U M2 U'
(U R U' M2 U R' U')

However, if you integrate the other edge, it's no problem:

U M2 (U R U' M2 U R' U') U'

So you can bring the first target to UB with one or two moves, "solve" it with an M2 move, then solve the second target before you undo the setup moves of the first. If the setup moves of the first target don't move the second target, the latter can even use the normal M2 algorithm, like in the above example.

This has many easy variations:

L* U M2 (otherTarget) U' L*
L* U (otherTarget) M2 U' L*
L* B' M2 (otherTarget) B L*
L* B' (otherTarget) M2 B L*
(and the same with R instead of L.

It can be particularly helpful for r2 I think, including the l-slice edges. For example, shoot to DBl and then to FRd like this:

B2 r2 (U R U' r2 U R' U') B2

Oh and while I'm at it, here's a new R2 alg for target FLD which I like much better than my old one (will try to improve others and then update my website):
(U' L' U x' U L U') R2 (U L' U' x U' L U)


----------



## joey (Jun 22, 2008)

Stefan: Joel VN has actually talked about this somewhere on the forum before. I can't remember where it is right now, maybe I'll have a little digg. I have also been messing around with this doing this during my M2 'solves'. (I say 'solves' since I only mess around with the method, and don't use it for BLD)

edit: hehe, it was on the first page of this thread! http://www.speedsolving.com/showpost.php?p=18578&postcount=8


----------



## Stefan (Jun 22, 2008)

Gah, me and my bad memory. You know, when both you and Chris recently mentioned how the three of us talked about 2gen blindsolving in Budapest, I was like "We did?!?". Happens more and more often. I'll reread this thread.


----------



## joey (Jun 22, 2008)

You're getting old Stefan, no wonder you don't do BLD anymore!

edit: Stefan, do you remember saying you would buy me a v-cube for my birthday?


----------



## Lucas Garron (Jun 22, 2008)

At Stefan's stuff:

The inverse, too, if the second piece has the nice setup?
Also, how's UF for a flipped easy setup?

And this could make FU (and BD) comms more thoughtless:
DF > FU > FL : U' L' U ( D [M', U R2 U'] D' ) U' L U


----------



## Stefan (Jun 23, 2008)

joey said:


> edit: Stefan, do you remember saying you would buy me a v-cube for my birthday?



What? Do I even know you?



joey said:


> You're getting old Stefan, no wonder you don't do BLD anymore!



Hey! I might not have attempted it the last 8.5 months, but last night I did it twice! Once with success, and it only took seven minutes! Booyaa!


----------



## Stefan (Jun 24, 2008)

The second time was btw one quarter turn off (in the middle of the solve) and took six minutes. Today I did another solve, success in five minutes. At this rate of improvement, I just need four more attempts to be world class.


----------



## joey (Jun 24, 2008)

Go Stefan!
Are you using M2/R2?


----------



## Stefan (Jun 25, 2008)

Yes, the dumbed down version (meaning now I solve FU/BU/BD/BRU/RUB with longer algs so I don't have to orient them later).


----------



## KJiptner (Jun 26, 2008)

StefanPochmann said:


> Yes, the dumbed down version (meaning now I solve FU/BU/BD/BRU/RUB with longer algs so I don't have to orient them later).



Would you mind sharing your algs with us? I mean for M2 there are quite some algs for the bad edges around. But I have never seen any for the two bad R2 cases.


----------



## boiiwonder (Jun 27, 2008)

StefanPochmann said:


> Hey! I might not have attempted it the last 8.5 months, but last night I did it twice! Once with success, and it only took seven minutes! Booyaa!



Lol 

Why havent you attempted it for so long?


----------



## Inusagi (Jun 27, 2008)

I can't get it. Could you give me an example with an official scramble?


----------



## joey (Jun 27, 2008)

There are two examples on his website.
Stefan-pochmann.info


----------



## Inusagi (Jun 27, 2008)

I understand hes method, but not these improvements. I can't find an explanation of his improvements on hes site...


----------



## AvGalen (Jun 27, 2008)

StefanPochmann said:


> joey said:
> 
> 
> > edit: Stefan, do you remember saying you would buy me a v-cube for my birthday?
> ...


Yes, you know him. The three of us have met last monday like we do every week. We even let you win a couple of games to make you feel better. That is when you realized you wanted to give both of us some nice presents like those V-Cubes and some other stuff that we will discuss again because I really don't need another flying pony.

We don't mind that your memory is getting worse. It makes you more fun to be with. Now if only you could remember that you should quit smoking....


----------



## Swordsman Kirby (Jun 27, 2008)

Inusagi said:


> I understand hes method, but not these improvements. I can't find an explanation of his improvements on hes site...



They're all on this thread.


----------



## Inusagi (Jun 27, 2008)

Ok. But I still got a question. How would you solve the cube with that method, if it's scrambled like this: 
U2 M' U2 M M' U' M' U' M' U2 M U' M U' M U2


----------



## ShadenSmith (Jun 27, 2008)

Inusagi said:


> Ok. But I still got a question. How would you solve the cube with that method, if it's scrambled like this:
> U2 M' U2 M M' U' M' U' M' U2 M U' M U' M U2



The scramble can be simplified to this (and probably further):

U2 M' U M' U' M' U2 M U' M U' M U2


----------



## MistArts (Jun 27, 2008)

ShadenSmith said:


> Inusagi said:
> 
> 
> > Ok. But I still got a question. How would you solve the cube with that method, if it's scrambled like this:
> ...



U2 F2 U F B' R' F2 R F' B U (11f*)


----------



## Mike Hughey (Jun 27, 2008)

Inusagi said:


> Ok. But I still got a question. How would you solve the cube with that method, if it's scrambled like this:
> U2 M' U2 M M' U' M' U' M' U2 M U' M U' M U2



For what it's worth, here's how I solve that one in a normal BLD solve: an 8 move commutator with a setup move:

B' U' R' U M' U' R U M B (or B' [U' R' U, M'] B)


----------



## Swordsman Kirby (Jun 27, 2008)

Inusagi said:


> Ok. But I still got a question. How would you solve the cube with that method, if it's scrambled like this:
> U2 M' U2 M M' U' M' U' M' U2 M U' M U' M U2



In M2, it would look like this.

M2 M2 F R U R' E R U' R' E' F'

But there's the obvious cancellation.


----------



## Stefan (Jun 27, 2008)

KJiptner said:


> Would you mind sharing your algs with us? I mean for M2 there are quite some algs for the bad edges around. But I have never seen any for the two bad R2 cases.



For the two bad R2 cases I pretty much use the algs I used to use for orienting, just changed by an R2 move.

The algs I've switched to:
FU: D M U R2 U' M' U R2 U' D' M2
BD: M2 B' U' R' U M' U' R U M B
BU: U R' U' l U' R U M2 U' R' U l' U R U'
BRU: (R' U R2' U' R2 U' R' U) (R U R' U') (R2 U' R2 U R2')
RUB: (R U R2' U' R2 U' R' U) (R U R' U') (R2 U' R2 U)

Oh and last night I did my next attempt, success in four minutes (actually went from 5:04 to 3:57). So the one-minute-improvement-per-attempt continues. Are you scared yet?


----------



## Mike Hughey (Jun 27, 2008)

Wow - just 3 more solves to world record territory. You should just stop practicing now; at your next competition, the third solve should do the trick. Sorry, Rafal - looks like you're toast.


----------



## blah (Jun 28, 2008)

What happens at the competition after the next? He'll create his own negative time BLD solving competition (c.f. Macky's), and win it.



Swordsman Kirby said:


> But there's the obvious cancellation.


For r2 I don't do the cancellations, I'd really just do r2 twice, even if it sounds _and_ looks stupid. Reason: Can't think ahead. Reason for that reason: I'll forget whatever I was doing. Reason for that reason for that reason: My concentration sucks.


----------



## deadalnix (Jun 29, 2008)

Nice BU, I adopt !

For FU I use this one for a long time. But I use it only if FU is the last edge to solve or if another M edge follows. In other cases, I have a simple technique :

1/ Do M2
2/ Do the set-up for the next piece
3/ Do M
4/ Do the reverse of the set-up
5/ Do M

And you solve the two piece in one time 

The same scheme can be applied for BD :

1/ Do M2
2/ Do the set up for the next piece
3/ Do M'
4/ Do reverse set-up
5/ Do M'

And for UB :
1/ Do U2M2
2/ Do the set-up for the next piece. Theyre is trap here : UR and UL slot are swapped !
3/ Do M
4/ Do reverse set-up
5/ Do MU2


----------



## Inusagi (Jun 29, 2008)

I liked thee third one. Anyway, what do you do if the next piece is in the M slice? What is the set-up moves for that one?


----------



## Simboubou (Jun 29, 2008)

I also found this with Acube :

UF2U'MUF2U'M' and UF2U'M'UF2U'M


----------



## deadalnix (Jun 29, 2008)

If the third piece is in the M slice, I use the alg given by stefan few post ago (is it correct ?).

Another tip to avoid x regrip during set-ups (for the case they need) :
1/ do M'
2/ Place the piece in the UF slot using only RU or LU.
3/ do M

Use this one only for the x cases.


----------



## tim (Jul 17, 2008)

StefanPochmann said:


> KJiptner said:
> 
> 
> > Would you mind sharing your algs with us? I mean for M2 there are quite some algs for the bad edges around. But I have never seen any for the two bad R2 cases.
> ...



The FU alg is wrong. M and M' have to be switched:
FU: D M' U R2 U' M U R2 U' D' M2

It took me more than 5 minutes to figure that out, but at least i understand the alg now .


----------



## tim (Jul 29, 2008)

These are my R2 algs for BRU and RUB:

RUB: F U' L2 U F' R2 F U' L2 U F'
BRU: x2 F U' L2 U F' R2 F U' L2 U F' x2


----------



## blah (Jul 30, 2008)

I've read through the entire thread and I've found similar ideas to this but not the exact same idea, so I'm posting it anyway:

Edit: I use DF as my buffer so do the necessary changes in your head if you're using FD (or any other buffer for that matter).

Whenever you hit an M-slice sticker, just do a 3-cycle. Here's how: skip whatever M-slice sticker you hit, and move on to the next non-M-slice sticker, set that up to UB as usual and do one of the following algorithms (they're actually just commutators with setups and move cancellations and stuff, but "considering" them algorithms makes the method more braindead)

UF: U2 M' U2 M
FU: y' U' M U' R2 U M' U' R2 U2 y (I've tried many, and though this one has a cube rotation, it's the most finger-friendly one for me, tell me if you've got a better one)
DB: M' u2 M' u2
BD: U2 F2 U M' U' F2 U M U

(I'm pretty sure almost everyone is doing the UF and DB one already.)

There are 2 ways to do this. The first is the "normal" way to do it, i.e. whenever you hit an M-slice sticker, just do one of the algorithms, if the M-slice is "bad", use the "other" algorithm (UF/DB, FU/BD), nothing special. The second one goes like this: memorize in pairs, you'll need a bit of thinking ahead, and if an M-slice sticker falls on the "first part" of your pair, do one of the algorithms as usual, if an M-slice stickers falls on the "second part" of your pair, then do the inverse algorithms, so you never ever need to do "the other algorithm".

So to deal with cases when the M slice is "bad", you can "learn more algorithms (the inverses)" or remember to do the "opposite" stickers, neither is better than the other imo, you be the judge.

It's better than some of the previously suggested ideas because it eliminates the need to come up with a commutator on the fly, making it more braindead. You're just doing your usual stuff, while skipping M-slice stickers in the process, and doing slightly different "algorithms" rather than the usual M2. Any comments on this? Thanks.

Edit: Oh, and if you've got 2 M-slice stickers in a row, I'm pretty sure there are algs somewhere else in this thread, I forgot to add them, I'll add them later once I've compiled all the cases (less than 10?).


----------



## blah (Aug 1, 2008)

Okay I've found algorithms for all the cases with 2 M-slice edges in a row to shoot to. 24 of them in total, including inverses. And I've decided to just use 4-move 3-cycle algorithms for these cases, regardless of orientation, and flip them later, because most of the algorithms are too similar and can cause confusion very easily, plus most of them are not even finger-friendly.

I've decided that it's simply not worth learning 24 different algorithms to handle all these cases (at least the edge-flipper algorithms (omega snaps?) are more finger friendly).

So my latest M2 modification involves using 3-cycles _every time_ I encounter an M-slice edge. Since it takes as many moves to solve 1 piece as it does for 2 pieces, why not solve 2 pieces with a 4-move 3-cycle?


----------



## Mike Hughey (Aug 1, 2008)

I have the same problem with your new approach which I had with Stefan's original approach. I struggle too much with dealing with the pieces that need to flip. I don't know why, but I just can't seem to handle it with enough reliability. Somehow I just need to solve them and forget about them. Having to flip them later just ruins it for me.

I wish I could get over it, because it seems like it makes a lot of sense. And your approach especially. I'm tempted to try your method for a bit, but I still think I'll have the same problem I had with Stefan's original approach - the flipped edges will confuse me too much and slow me down and reduce my accuracy. Maybe this sort of method only works for really smart people. 

I do like your M2 approach conceptually - it seems very nice.


----------



## blah (Aug 1, 2008)

You're wrong. Either it works for all people, or all people are smart. Either way, you're wrong 

Here's how I keep track of the bad M-slice edges: my feet. Actually, foot  Because I originally intended to use the other foot to track the good/bad-ness of the M-slice, but umm, I didn't use this in the end because firstly, I looked retarded (or rather, my feet did), and secondly, there was too much "action" going on under the table that it became more of a distraction than a memory aid.

So with my left foot, this is what I do: when the UF piece is bad, I raise my toes and keep the rest of my foot on the ground; when the DB piece is bad, I raise my heel, so my foot gets into a tiptoe position; when the UB piece is bad, I shake my entire leg, violently. Since shaking my leg and raising certain parts of it are two mutually exclusive actions, I only have one "combo" to worry about, that is, if DB and UF are bad, for this I raise my entire foot so it's "floating" in the air. Over time, you'll learn to translate these actions directly into algorithms, rather than positions of bad pieces.

If you think this is too complex p) create your own system with your feet, it's worth a try, and it's good, at least for me 

Edit: And don't worry, I have the exact same problem as you do, I just insist on this flip-everything-at-the-end approach because I believe it's gonna be beneficial in the long run. Ever so often, after I hit the spacebar and before I take off the blindfold I go "Oh crap!" because I realized my leg was still shaking, but I'm still practicing and I'm trying to make it a habit to remember to flip them at the end of every solve, so yeah.


----------



## Mike Hughey (Aug 1, 2008)

I think I would definitely need to modify the system, since I always stand when doing 3x3x3 BLD. Also, I currently use my stance to tell me whether or not there are other edges that were already in the proper place but flipped (before I started doing this my accuracy was WAY too bad because I would forget to flip edges that were in the proper place but flipped) - wide stance is no flipping needed, narrow stance is flipping needed.

But I guess it should be possible to come up with some sort of variation that would account for all of this.

My current method of using commutators to solve anything with a "bad edge" seems simple in comparison at the moment to me. But I think it might be giving it a try, since I'm sure I slow down on the commutators, typically.


----------



## blah (Aug 1, 2008)

Just came up with another solution for 2 M-slice stickers in a row! Though it does require a lotta thinkahead. Alternatively (in fact, this is the most logical way to do it since no one thinks ahead _that_ far), make a mental note while memorizing the stickers.

Solution: Think ahead far enough to see 2 M-slice stickers coming, and separate them on purpose. E.g. Say this is your cycle, A B C M N D E, where M and N are M-slice edges, you shoot to A, then shoot to B, then 3-cycle buffer-C-M, then 3-cycle buffer-N-D, then shoot to E. The downside of this is when you get a cycle like this: A B M N C D, you've gotta cycle to the "opposite" stickers of M and N.

As for cases when there are 3 in a row, well, how unlucky can you be?  That solve is doomed to suck anyway, so you might as well solve 'em one by one  Or you can do 4-move 3-cycles for two of 'em and shoot to the third one, this solution seems more logical.


----------



## blah (Aug 1, 2008)

Oh I just thought of something that I've been doing for quite a while but haven't seen anybody post about it here yet, so I'm double posting, yeah.

To avoid "ugly" M-slice cases, when I break into a new cycle, I don't go for easy cases (e.g. UB), I go for "good" M-slice stickers, i.e. if I haven't encountered some of the M-slice edges in my first cycle, I locate them and start my new cycle from there. Would you rather break into a new cycle with an easy case (e.g. UB), just to find out later that you've got an ugly case? Or would you rather spend 2 more seconds looking for unsolved M-slice edges and break into your new cycle with a few more setup moves? I'd pick the latter. With this approach I only encounter ugly cases about once in every 3 solves, really (or is this because I haven't solved much yet? ).

Edit: I realized something. The first suggestion (break into a new cycle from an easy spot) can give you faster singles. The second suggestion (break into a new cycle from a good M-slice sticker) gives you faster averages. So for competition, the first approach is better actually  Analogy: for 4x4x4 edge pairing, 6-pair is definitely gonna give you faster singles in the event that you don't have awkward cases, because it takes less moves as a whole; on the other hand, 2-pair is gonna give you faster averages because you don't encounter awkward cases at all, even though it takes slightly more moves than 6-pair. Is this a valid analogy?


----------



## tim (Aug 12, 2008)

R2 algorithm for BDR i use (found with ACube):

y R U' R D2 R' U R D2 R2 F2 y'

I very often lost grip on Stefan's alg ((R U R' D r2 U') (R U r2' U') (D' R)). I even dropped the cube twice in a row while executing his alg.


----------



## blah (Aug 12, 2008)

Doesn't that alg just look A perm-ish?


----------



## joey (Aug 12, 2008)

It is an Aperm


----------



## blah (Aug 12, 2008)

Yeah, I realized too  Didn't have a cube with me when I first saw the post and made that comment, but I just tried it, so yeah.


----------



## Stefan (Aug 12, 2008)

At a recent party I did a demo solve under tough circumstances and when I got to the BDR (or FUR?) target, I was afraid I'd screw up the alg so I chose to do the "normal" PLL A-perm alg, too. So yeah, those are alternatives. When success is less important, I do use the other R2 algs, though.


----------



## Kenneth (Aug 12, 2008)

StefanPochmann said:


> Try this scramble: U' R' U M' U' R U M



I used it for ELL since the 80's but starting from doing x'

Note that it is flexible, you can change the R/R' with R2's and the same for the M/M' -> M2 giving 4 combinations, factor that with the mirror and inverses and it is a total of 16 algs.



Edit: I just noted that Stefans alg is not the same as min, It is U' R U M' U' R' U M but they both work.

This also gives 24 diffrent combos (dunno if all are uniqe, have not checked)


----------



## fanwuq (Aug 29, 2008)

I use D2F2UM'U'F2D2U'M'U

For BD. Anyone else use it?

Also, I considering new pochmann corner method, but I don't know about doing R2. I want to set up using mostly RU moves, but I could care less about the actual *2. What would be the * ? Perhaps L2 or U2? I'm considering one of these. Which buffer?


----------



## Freddy88 (Nov 13, 2008)

Hi Guys, how are you?
I'm working on some improvements for M2... I've adopted an idea of Maky who suggest to use three cycle for the nasty cases where two M edges follow. In his guide he uses commutators. I do instead do that with M.

As you can see with x or x' cube rotations you just need to memo 8-10 algs... wich is not that easy 'cause they are all plenty of M moves. But is not also that hard...most of them are quite short.

Any way the problem is that I would like to find better, more finger friendly algs for UF DB, UB BD and DB UF (shooting form FD) do you know some R based commutator who works for that three cases....that would be great!

Have a nice evaning!

Federico Soldati



UF  DB	(U' M2) (R U' R' U) M U') (R U R') (M U)
BU  DB	x (U' M2) (R U' R' U) M U') (R U R') (M U)x '
UF ® BU	x' (U' M2) (R U' R' U) M U') (R U R') (M U)x

DB  UF	U'M'RU'R'UM'U'RUR'M2U
DB  BU	x U'M'RU'R'UM'U'RUR'M2Ux'
BU  UF	x' U'M'RU'R'UM'U'RUR'M2Ux

BD  UF (U M' U' M) U2 (M U M' U)
DB  UB	x (U M' U' M) U2 (M U M' U) x'
UB  FU	x' (U M' U' M) U2 (M U M' U) x

UF  BD (U' M U' M') U2 (M' U M U')
UB  DB	x (U' M U' M') U2 (M' U M U') x'
FU ® UB	x' (U' M U' M') U2 (M' U M U') x

UB  UF (U M U M) U2 (M' U M' U')
DB  FU	x' (U M U M) U2 (M' U M' U') x

UF  UB (U M U' M) U2 (M' U' M' U')
FU  DB	x (U M U' M) U2 (M' U' M' U') x'

BU  FU (M' U2 M U2)
BD  FU	x (M' U2 M U2) x'

FU ® BU (U2 M' U2 M)
FU  BD	x (U2 M' U2 M) x'

UB  BD	(U' M U M') U2 (M' U' M U')
BD  UB	(U M' U M) U2 (M U' M' U)
BD  BU	(M U2 M U2) M2
BU  BD	M2 (U2 M' U2 M')


----------



## KJiptner (Nov 13, 2008)

Thanks Frederico, I will definitely memorize that stuff  Nice you've joined the forum


----------



## macky (Nov 17, 2008)

Hey Frederico, let me reply to you here. This definitely goes along with my letter-pair-directly-to-alg philosophy. (For people who haven't seen it, here.)

For the cases you mentioned, you could always do something like

UF DB: U'l'x [U'R'U, M] x'LU or r'Ur' [URU', M] rU'r

Eliminating all thinking is the way to go.

[edit] I guess the freestyle people disagree with this. =)


----------



## Lucas Garron (Nov 17, 2008)

macky said:


> [edit] I guess the freestyle people disagree with this. =)


Yeah. Which only, like, includes the WR-holder.


----------



## joey (Nov 17, 2008)

Nah, us freestylers are braindead too.


----------



## deadalnix (Nov 17, 2008)

Why don't you use DR'UR'U'M'URU'r'R2D' ?


----------



## Freddy88 (Nov 18, 2008)

Yeah....I'm still searching good algs for UF->DB (shooting from FD), 

For the moment I've decided to change BD-> UB and inverse with the following:

UB  BD U2 (D M' D M') U2 (M' D M' D) 
BD  UB (D' M D' M) U2 (M D' M D') U2

Looks good eh? 

Have a great day.....and come on, propose!


----------



## deadalnix (Nov 18, 2008)

UF -> DB can be done like xDM'R'UR'U'Rr'URU'RD'x'


----------



## Freddy88 (Nov 18, 2008)

yeah....but I want a non-cube turns alg.....cause the moves are gonna be the x turns of that algs...


----------



## deadalnix (Nov 19, 2008)

You can set up by M' if you want to turn the cube !


----------



## Freddy88 (Nov 19, 2008)

Yeah...I don't know if it is better to do a X or X' cube rotation ora a M or M' move...I think I would prefer the hole cube rotation...anyway what I meant is that If I find a simple UF -> DB alg I then can use it wor the following algs too with just a cube rotation (or M/ M' move):

BU -> DB x A x '
UF -> BU x' A x

Because of that I'm searching a good alg (short and fast) for that case. The problem is that there are few cube solver programs with works with M slice turn also. Maybe Stefan or Somebody with good knowlege of Acube could give it a try and find the best solution for that case...including M slice turns....

Regards, 

Federico


----------



## Freddy88 (Nov 20, 2008)

Hi Guys, I'm back again.....
So, I've worked out the missing solution...now my algs looks like that:

UF  DB (U' M2) (R U' R' U) (M U') (R U r' U)
BU  DB x (U' M2) (R U' R' U) (M U') (R U r' U) x '
UF ® BU	x' (U' M2) (R U' R' U) (M U') (R U r' U) x

DB  UF (U' r U' R' U) (M' U') (R U R') (M2 U) 
DB  BU	x (U' r U' R' U) (M' U') (R U R') (M2 U) x'
BU  UF	x' (U' r U' R' U) (M' U') (R U R') (M2 U) x

BD  UF (U M' U' M) U2 (M U M' U)
DB  UB	x (U M' U' M) U2 (M U M' U) x'
UB  FU	x' (U M' U' M) U2 (M U M' U) x

UF  BD (U' M U' M') U2 (M' U M U')
UB  DB	x (U' M U' M') U2 (M' U M U') x'
FU ® UB	x' (U' M U' M') U2 (M' U M U') x

UB  UF (U M U M) U2 (M' U M' U')
DB  FU	x' (U M U M) U2 (M' U M' U') x

UF  UB (U M U' M) U2 (M' U' M' U')
FU  DB	x (U M U' M) U2 (M' U' M' U') x'

BU  FU (M' U2 M U2)
BD  FU	x (M' U2 M U2) x'

FU ® BU (U2 M' U2 M)
FU  BD	x (U2 M' U2 M) x'

UB  BD	U2 (D M' D M') U2 (M' D M' D) 
BD  UB	(D' M D' M) U2 (M D' M D') U2
BD  BU	(M U2 M U2) M2
BU  BD	M2 (U2 M' U2 M')

And of course:

UB s	U2 M2 (s) M (s)' M U2 Switch RU and LU
s UB	U2 M' (s) M' (s)' M2 U2	

UF s	M2 (s) M (s)' M
s UF	M' (s) M' (s)' M2
s FU	(s) M2 (s)' M U2 M U2 

DB s	M2 (s) M' (s)' M'
s DB	M (s) M (s)' M2
s BD	(s) M2 (s)' U2 M' U2 M' 

The two main algs for UF-> DB and Inverse seems quite long but are actually pretty fast... 

I also had another Idea...that could be useful for somebody who whants to keep algs memorisation at the minimum:

For UF-> DB (and Inverse) you could also do "F2 then Alg of UF-> BD and thatn F2 again....

That means that the actual memorization of algs, would become of..about five? If you don'consider the really easy 4 moves one... of course.

I hope that can be useful for you...I don't know if that is gonna be faster than Maky's commutators way...I think so though.....

Have a grat Day!

Federico


----------



## Freddy88 (Nov 20, 2008)

Ah, and remember that Instead fo X rotation you can also do M or M'....
What do you think it's better?

Regards,

Federico


----------



## deadalnix (Nov 20, 2008)

It seems great ! I will adopt these algs.


----------



## Jgig1991 (Nov 26, 2008)

Thank you for posting this Stefan.


----------



## Freddy88 (Dec 3, 2008)

Hi everybody,

so what follow is the last change I did to my special M layer algs...the algs to be learnt are now only 4, yes, just 4!

I still have difficulties during the UB or UF and DB couples with non M layer edges.....like UB RU or LU UB......that seems to be quite time expensive at the moment....some suggestions?

Regards,

Federico

Ah, that's the list:

UF  DB	F2 (U M' U' M) U2 (M U M' U) F2
BU  DB	M' F2 A F2 M
UF ® BU	M F2 A F2 M'

DB  UF	F2 (U' M U' M') U2 (M' U M U') F2
DB  BU	M' F2 A F2 M
BU  UF	M F2 A F2 M'

BD  UF	(U M' U' M) U2 (M U M' U)
DB  UB	M' A M
UB  FU	M A M'

UF  BD	(U' M U' M') U2 (M' U M U')
UB  DB	M' A M
FU ® UB	M A M'

UB  UF	(U M U M) U2 (M' U M' U')
DB  FU M A M'
BD  UB	M2 A M 2

UF  UB	(U M U' M) U2 (M' U' M' U')
FU  DB	M' A M
UB  BD	M2 A M2

BU  FU	(M' U2 M U2)
BD  FU	M' A M

FU ® BU	(U2 M' U2 M)
FU  BD	M' A M

BD  BU	(M U2 M U2) M2
BU  BD	M2 (U2 M' U2 M')


A stands for the first alg of the triple or couple...I did it with colors.....


----------



## martijn_cube (Dec 21, 2008)

These are the two algs i have for BU (buffer DF) when using M2.
But i still don't really like them, i'm currently trying to use the first one.
But is there someone who has a better one?

1) (UR'U') l (U'RU) M2 (U'R'U) l' (URU')

2) (F’ D) R’ (F D’) M2 (D F’) R (D’ F)


----------



## Ville Seppänen (Dec 21, 2008)

(U'M')*3 U'M (U'M')*4 (I like MU )


----------



## martijn_cube (Dec 21, 2008)

wow, thats a really nice one. alot faster then my other two. I like M'U' too.


----------



## DonQuixote (Dec 21, 2008)

BU: (0292718) 1-1- (7281019)

Kind Regards
Martin


----------



## martijn_cube (Dec 21, 2008)

DonQuixote said:


> BU: (0292718) 1-1- (7281019)
> 
> Kind Regards
> Martin



What do you mean with that? i do not know what those numbers mean.


----------



## tim (Dec 22, 2008)

martijn_cube said:


> DonQuixote said:
> 
> 
> > BU: (0292718) 1-1- (7281019)
> ...



I guess he used this notation.


----------



## blah (Dec 22, 2008)

Can someone translate what the purpose of this alternative notation is?


----------



## tim (Dec 22, 2008)

Thomas says, that it's easier to memorize digits (5 1728 1728 6) than letters (FRUR'U'RUR'U'F'). And he also claims that it's easier to spot inversed and mirrored algorithms with his number notation.


----------



## Stefan (Dec 22, 2008)

Just in case you want to discuss that or other alternative notations further, please continue here:
http://www.speedsolving.com/forum/showthread.php?t=8092


----------



## deadalnix (Dec 28, 2008)

It don't give us the alg in « standard » notation


----------



## Freddy88 (Jan 21, 2009)

Hi everybody, how are you?
Until now I always used M2/Old Pochmann. Now I would like to learn R2, but I have a couple of questions:

1) Is there any updated list of R2 Algs, that somebody would agree to share? 
I would be very happy, 'cause I've heard there have been lots of improvements in the algs and it seems that Stefan has not updated his tutorial. For example I supposte that there are now R2 algs for orienting immediatly the R corners. Stefan, if you read this post, I would appreciate a lot If you could share with me the algs you are using now.

2) Is it better R2, L2 or U2? I've heard there are many ways of dooing it...

3) Is it struggling to solve corners before edges? Because I would like to use short term memory for the corners....do I need special parity algs in that way?

Thank you in advance for your precious help, 

Best Regards, 

Federico


----------



## Stefan (Jan 21, 2009)

With the exception of FDL, I'm still using exactly the algs on my page. I'm no fast solver, though. Then again, I don't know of many R2 users.

Corners before edges is somewhat unnatural. The side effect of solving the edges are only in the M slice. No corners are affected, so after solving the edges the corners are where they were in the beginning. This is not the case the other way around, as solving corners does affect edges. Though in the end that's just a problem in case of parity. If there's parity and you solve corners first, I think you can apply my parity fix after solving corners and then solve the edges, though you'd have to start edges not like usual but as if you had already solved one edge, i.e., with the edge solving side effect already in place.


----------



## Freddy88 (Jan 21, 2009)

Hi Stefan, thank's for reply. 

Mmm...it doesn't look that nice to solve corner first...
I would be very happy if someone could tell me a solution....'cause I would like to short memorize the corners, as they are few...

Stefan, what do you think of L2 instead of R2? Wich method has more R moves, wich is what I'm looking for....

Regards,

Federico


----------



## Ellis (Feb 16, 2009)

Here's something I've been messing around with the last few days. I'm probably not the first to use it, but I haven't seen it mentioned. It's a quicker way to cycle similarly oriented edges that are on opposite L and R layers. Of course you don't need to use it all the time, but if you recognize an easy case early on it can save some time. 

The algorithm I use for UL-UR is (U M' U2 M U), the inverse will of course cycle the opposite way, UR-UL (U' M' U2 M U'). My buffer is DF. If you get these specific cases you'll be saving 13 moves (best scenario), but with setup moves they can also be applied to any edges oriented like that. So if I get BL-FR for example, I do: L R (U M' U2 M U) R' L'. This shows that the maximum number of moves for similar R/L edges is 9, that is if neither of the stickers to be cycled are R/L colors. 

That same case with normal M2 would look like this: (U' L U M2 U' L' U U R U' M2 U R' U'), which is 14 moves with the cancellation. Even with the improved setup moves as shown by joel and stefan it would be 11 moves (L U M2 U R U' M2 U R' U' U' L').

The same idea applies when you have two edges on opposite layers with both R/L stickers stickers to cycle. For that, I use (M U' M U2 M' U' M') which cycles LU-RU, and its inverse (M U M U2 M' U M'). With a maximum of 2 setup moves this means that the most moves for a pair of edges like this is 11. This can be used even in the nasty cases when the improved setup moves wont apply. Example: RB-LB, we can't cancel any setup moves in this case because doing B will move the LB edge. So for both regular M2 and M2 with improved setup moves, the total moves here is 18. It becomes 11 if you use the above algorithm: R' L (M U M U2 M' U M') L' R

Edit- That wasn't the best example of what I was trying to say at the time. Because of the cancellations, it's faster to do it as: x' (U M U2 M' U) x

If you really wanted to, you could use these algorithms for similar edges on the same layer. An example is RU-RF, which the setup would be (U2 R). I don't know if I really care to use something like that though, I think I'd rather keep it to opposite layers for now. Maybe I'll change my mind with more practice. 

anyway, sorry if this is too far off of the M2 topic or if it's already been discussed... it seems like this is something that might be used in another edge method (maybe it is in one that I haven't learned), but I will definitely be using these two algorithms and their inverses in my M2 solves.


----------



## martijn_cube (Feb 16, 2009)

Ellis said:


> The algorithm I use for UL-UR is (U M' U2 M U), the inverse will of course cycle the opposite way, UR-UL (U' M' U2 M U'). My buffer is DF. If you get these specific cases you'll be saving 13 moves (best scenario), but with setup moves they can also be applied to any edges oriented like that. So if I get BL-FR for example, I do: L R (U M' U2 M U) R' L'. This shows that the maximum number of moves for similar R/L edges is 9, that is if neither of the stickers to be cycled are R/L colors.
> 
> .



Sounds like TuRBo with DF as buffer. could be nice. the Algs seem to be shorter. Turbo is with UF as buffer, and then cycle UR/ UL.


----------



## Ellis (Feb 16, 2009)

martijn_cube said:


> Sounds like TuRBo with DF as buffer. could be nice. the Algs seem to be shorter. Turbo is with UF as buffer, and then cycle UR/ UL.



Makes sense. I've never really looked too much into TuRBo... I knew that the buffer wasn't the same but that's about it. I have this feeling that people who use M2 won't really want to do this because it's so different, but I think it can come in handy in a lot of situations.


----------



## fanwuq (Feb 16, 2009)

Ellis said:


> Here's something I've been messing around with the last few days. I'm probably not the first to use it, but I haven't seen it mentioned. It's a quicker way to cycle similarly oriented edges that are on opposite L and R layers. Of course you don't need to use it all the time, but if you recognize an easy case early on it can save some time.
> 
> The algorithm I use for UL-UR is (U M' U2 M U), the inverse will of course cycle the opposite way, UR-UL (U' M' U2 M U'). My buffer is DF. If you get these specific cases you'll be saving 13 moves (best scenario), but with setup moves they can also be applied to any edges oriented like that. So if I get BL-FR for example, I do: L R (U M' U2 M U) R' L'. This shows that the maximum number of moves for similar R/L edges is 9, that is if neither of the stickers to be cycled are R/L colors.
> 
> ...



Wow!
Great idea! U M' U2 M U is a very useful alg. It is actually a very good replacement for the U perm in 3OP. Use DF as your buffer, setup the other 2 pieces across each other on the U layer and use this along with U2 M' U2 M and similar 4 or 5 move algs.
As Martijn mentioned, finding a few more algs can work as TuRBo as well.


----------



## Simboubou (Apr 13, 2009)

Up ! 

Has anyone founded a nice way to deal with BUL/DBL/UFL/FDR corners ? Those are so slow to solve...


----------



## Ellis (Apr 26, 2009)

I hope no ones brought this up yet- I've been thinking about a different way to solve BU pairs recently (DF buffer). Just use the improved setup moves stated earlier in this thread (ie disregarding the M-slice) and then have the next position you shoot to be wherever you displaced BU to. It works both ways depending on when you do the M2 that fixes the other edge. 


Examples:

*UR - BU:* U' M2 (B L' B' M2 B L B') U
*BU - LB:* B' (U R' U' M2 U R U') M2 B

Works for all pairs containing BU (+ one non m-slice edge) provided that you are displacing BU when setting up the other edge. Do M2 for the other edge before or after fixing the BU sticker depending on if BU is first or second in the pair.


----------



## deadalnix (May 20, 2009)

Hi,

I work on some improvement in M2 for many mounth now. Just see the dates of my firsts posts on this topic to get an idea.

I've made so many modifications that I think we can consider my method as a new one. You can solve edge by 2 with it and with a maximum of 11 STM move for 2 edges. I haven't made the calculation including probability for an average, but I'm pretty sure it's under 10 STM. The only slice turn you need is M. The number of moves and regrips is reduced compared to M2.

As some of you have noticed, BH seems to be great and I wonder if a kind of « super M2 » method could interest some of you ?

I'm not a native english speaker, so making the explaination in english is a big task for me, so I want to be sure that some of you are intersted.


----------



## ManuK (May 21, 2009)

I am interested..


----------



## fanwuq (May 21, 2009)

deadalnix said:


> Hi,
> 
> I work on some improvement in M2 for many mounth now. Just see the dates of my firsts posts on this topic to get an idea.
> 
> ...



I'm very interested if it's not too much to learn and relatively braindead when solving (easier than TuRBo?).


----------



## Stefan (May 21, 2009)

deadalnix said:


> I'm not a native english speaker, so making the explaination in english is a big task for me, so I want to be sure that some of you are intersted.


I'm interested as well. I'd suggest you just briefly outline the method and give an example solve. If we need more details to understand it, we can ask.

Is it applicable to the 4x4 as well? Like a better r2 method?


----------



## deadalnix (May 21, 2009)

OK, I will explain the outline.

I have splitted the stickers into 6 groups : Uf Uo Rf Ro Lf Lo.

The DB edge (so both stickers) is a special case. I will not explain it in the outline.

The first letter is a face. The second letter is f for face or o for orbit.

A face sticker is a sticker on a face, for exemple UR is an Uf sticker.
An orbit sticker is an sticker from an edge in the face, but which is not on the face. For exemple UR is an Ro sticker.

To make ot short, an Xf sticker is XY and an Xo sticker is YX.

Excepted DB edge, all stickers are in the 6 groups. Some are in 2 groups, as UR. In this cas, you can consider the group you want to solve the piece.

Then, knowing the group of the two sticker you want solve, you can apply a basic pattern. Instead of thinking set-up, you will think into adapting a pattern.

The number of cases could seems important (6*6 groups) but in fact, Rx and Lx groups are similar.

Most of the cases are close to M2 method (M2 is the start of my work).

I use FD buffer, so notation could be reversed if you use DF.

Let's see some exemples :

For two Rf stickers. I will call J and K the standards M2 setups and j and k the simplified set-up (set up destroying the M slice). {JK} means cancellation moves.

The pattern is jM2{J'K}M2k' . This is very close to M2. With RF RB for example, the solution is :
RU'M2UR2U'M2UR

With two Ro stickers, the setup will put the sticker in UF. The pattern is jM'{J'K}Mk' . This is also in the M2 spirit, but not as close as before. With FR BR, the solution is :
RUM'U'R2UMU'R

But for some cases, the solution isn't in the M2 spirit. For exemple, Rf Lo . In this case, you turn the cube using z' . The L sticker should be in FD or BD using D or D' as set-up. Then you can shoot your buffer intu the U face using R and the other using M. Then pattern is M'U'RUMU'R'{U'} and his F/B symmetry. (Lo Rf use the reverse pattern, obviously)

For FL RB, the solution is :
z'U2M'U'RUMU'R'U'z

You have here the basic idea. Obviously, I have a pattern for each case. You can easily made the transition between M2 and this method using a kind of 2-cycle M2 like explained into macky tutorial and then, adding patterns one after another.

This method can be applied on big cube edges (for 5x5x5). I haven't thought too much about r2 improvement, because I use BH for big cube edges and wings. I think BH is a great method, and I learning it for corners (and I use it for a long time for big cubes). But I find BH for edges not finger friendly at all, so I begin some reflection and now the results are here 

But I think some improvements into r2 can be found in this method. The recognition of the case if very easy on edges, but will be more difficult on wings. uRF is a Ro wing and dRF is an Rf wing. But it looks possible.

EDIT: I have posted an example solve into a french forum : http://www.francocube.com/forum/post93907.html#p93907 I'm currently writting the french version of the tutorial, which is close to the end.


----------



## fanwuq (May 25, 2009)

deadalnix said:


> For LF RB, the solution is :
> z'U2M'U'RUMU'R'U'z



Wouldn't that be FL RB?
I would do
L'U'M'FR2F'MFR2F'UL
It's a bit less efficient, but easier to think about.
LF RB would be
L'UM2UR'U'M2URU2'L


----------



## deadalnix (May 25, 2009)

Right !

For LF RB I do (Which is a Lf Rf case) :

z'M2URU'M2UR'U'z

All the Lx Rx case are solved on side. I find this way more finger friendly. But I also mention your solution (L'UM2UR'U'M2URU2'L) in my tutorial (work in progress, not published yet) for an easy transition between M2 and my method.



fanwuq said:


> It's a bit less efficient, but easier to think about.



It's why I've worked on a case <=> pattern association. It allow you to know which pattern to use very easily, and most of the patterns are very efiscient.


----------



## fanwuq (May 25, 2009)

deadalnix said:


> Right !
> 
> For LF RB I do (Which is a Lf Rf case) :
> 
> ...



I see it now. You are starting the cycle from LF so that it acts like the buffer. Then you set up the edge on R so that it become interchangeable to LF. M turn to shoot LF to R edge, then replace with FD (real buffer). This is getting really similar to BH!
I don't like to think too much during my BLD solves, so I would still probably do L'UM2UR'U'M2URU2'L in the real situation.
Edit: Then I will read about your case <=> pattern association.


----------



## Haru (May 27, 2009)

Here is my method.
Most cases of shooting to BU (buffer is DF) can be avoided with no algorithm.

Unless UB is already solved, I locate DF sticker on UB (if it can be done easily) and consider UB piece as "buffer piece".
In the case where I located DF sticker on UB, I do M2 to exchange DF piece on UB and UB piece in the buffer after all cycles are solved.
(In odd parity case, this last M2 cancels with the first turn of the parity fix algorithm of M2/R2 method.)

More specifically,

1. If DF sticker lies on UB at the beginning, I consider UB as solved.
2. If DF sticker is in the buffer and UB is not solved yet, I shoot the DF sticker to UB. 
3. If BU sticker is in the buffer and DF sticker does not lie on bad M-slice positions (BU, FU and BD), I break into a new cycle from DF sticker.


Example of the third case
Scramble: F' U R S R' S' U' F

shoot to RF: B' R2 B M2 B' R2 B
(The UB piece is considered as "buffer piece" to avoid shooting to BU.)
shoot to BR: U R' U' M2 U R U'
(break into a new cycle from DF sticker)
shoot to UB: M2 (shoot DF sticker to UB to "solve" UB)
shoot to RD: B' R' B M2 B' R B
shoot to RB: R' B' R B M2 B' R' B R
exchange DF and UB: M2


Example of the second case
Scramble: F M F2 M' F R' D M' D2 M D R

shoot to UB: M2 (shoot DF sticker to UB)
shoot to FR: U R U' M2 U R' U' (break into a new cycle)
shoot to DL: U' L2 U M2 U' L2 U
shoot to LF: B L2 B' M2 B L2 B'
shoot to RF: B' R2 B M2 B' R2 B
exchange DF and UB: M2


----------



## fanwuq (May 28, 2009)

deadalnix,

How would you handle cases like FD to UL to UR?
Would you start with something like an R turn then continue, or something different?

For example:
FD to UL to UR
RU'M'U'R'UMU'RU2R'

FD to UL to RU
RU'M'FR2F'MFR2F'UR'

FD to LU to RU
UM'U2MU

What are you planning to do for the BD edge? Setting up to BD with B or D turns work. Maybe an M2 setup to make it FU?


----------



## deadalnix (May 28, 2009)

You can set-up using M and then use an MU2M'U2 like alg (or twice if you want to be big cube safe).

The french version of the tuto is almost finish and I hope i will end the translation during next week.


----------



## nguyenhoangtuan (May 29, 2009)

hi stefan i'm vietnamese.I want to learn M2 R2 but i don't understand some menthod and arg of M layer.I applied but it was unsuccessful.Can you help me?


----------



## deadalnix (Jun 3, 2009)

Unfortunaly, I get sick and so I'm a little late on the planed release date.

But, the french tutorial is now finish, and have juste to be checked and correctd to be released. The translation is comming soon.


----------



## CT_Warrior (Jul 27, 2009)

I think I thought of an improvement for DBL. How about doing an L' move to turn it into a FDL case then undoing it with L?
L for UFL.
Possibly L2 for BLU.

I guess it depends on how fast you do the algs. I personally do FDL faster. x_x
Also, are there any alternative algs for FDL?

EDIT: I think you can apply this to R layer as long as the two corners you're shooting for aren't both in the R or U layer.
FRU into LFU via U turn setup, undo at the end of the pair, and etc.

EDIT2: Some patterns are really good! Example, this pair: UBL FRU, turns into U UBR LFU U'.
I'm sure there are some bad cases, but I don't think it'll be too hard to learn to recognize it with some preparation.

For URF cases, using U' will improve all the cases except for ULF/LUF/FLU and maybe ULB which turns into the not so good UFL.

I'm thinking of the same idea for BDR/DBR/RDB at the moment. RDB would be done with B in the same way as URF.
Maybe a RUR' or RU'R' trigger might be better in some cases.


----------



## Marcell (Jul 27, 2009)

1. Of course, you could use only three algs along with L* setup moves for all the corners on the L layer depending on their orientation (actually, a lot of the original R2 algs do this). If you can do the setup, the FDL alg and the setup back than the DBL alg, you should do that.

2. Don't know, if you don't like Stefan's alg, you can use ACube to find one that you like better, or try the appropriate BH alg with R2 at the end (U2 R2 U2 R D2 R' U2 R D2 R U2 R2 or it's inverse) or at the beginning (R2 U L' U F2 U' L U L' F2 L U2 or it's inverse).

3. Surely there are some nice patterns, but I think usually you'd lose more time thinking what's going where than when you just do the plain algs as fast as you can.


----------



## CT_Warrior (Jul 27, 2009)

Hmm, I'll try those algorithms soon enough, but some of them are pretty easy and save a good amount of time.

If you have URF and one of the two bottom left corners, then there's not much to think about.

For the ones that you have to think about, if you had say.. URF and LBU, you could memo it as URF and FLU and take the hint that you have to setup U' and U either by a slight mental note or whatever else you can think of. 

I find it hard to think while solving, but it's not so bad during memo.


----------



## martijn_cube (Aug 18, 2009)

deadalnix said:


> Unfortunaly, I get sick and so I'm a little late on the planed release date.
> 
> But, the french tutorial is now finish, and have juste to be checked and correctd to be released. The translation is comming soon.



How far are you with the translation? Or do you have a link to the french version, if there are a couple example solve then any language will help.


----------



## martijn_cube (Aug 22, 2009)

i tried to do an 'deadalnix' solve. am i doing this the right way?

Test solve 1: L' B D2 B R2 L2 D' B' D2 U L2 R2 F' L' B L B' U R F2 U2 D2 R2 D2 F

- *(R’U’) M2 (L’BLB’) M2 (BL’B’L) (UR) * OR (FR2F’) M’ (ULU’) M ( UL’U’) (FR2F’) 
- *(U2) M’ (UL’U’) M (ULU)*
- *(U’) M’ (U’RU) M (U’R’U2)* OR (L’B’) M2 (B’R2B) M2 (B’R2B2L) 
- *(R’B) M2 (U’L2U) M2 (U’L2U) (B’R)* OR (U’R2U) M’ (F’L’F) M (F’LF) (U’R2U)
- *(B2) M2 (R’URU’) M2 (UR’U’R) B2*
- *(U2) M2 (U’L2U) M2 (U’L2U’)*

It solves the edges, so it works, but is it how it's supposed to be?

Test solve 2: With the difference between this and normal M2.
I just counted every move as 1 move.

```
F2L'U2B2U2L2F'R'UF2D2L'DUB'F'L'RU2B2L2D'R'DB'

‘Deadalnix’:

-  (U2) M2 (U’L’U) M2 (U’LU’)  			        -  (9)
-  (U’LU) M2 (U’L’U) M2			                -  (8)	
-  (U’) M’ (R’F R F’) M (FR’F’R) (U)		        -  (12)
-  (R’U2) M’ (R’FRF’) M (FR’F’R) (U2R)		        -  (14)
-  (B) M2 (B’R’B) M2 (B’R)				-  (8)
- (R’URU’) M2 (UR’U’R)     				-  (9)
[B]Fix: (U’F2U) M2 (U’F2U)			   	        -  (7)
Flip:  (M’U’M’U’M’U’M’)U2(M’U’M’U’M’U’M’)	        -  (14)[/B]
Total: 60/[B]81[/B]


M2:

- U2 M' U2 M'  /  U' L' U M2 U' L U			-  (11)
- U' L U M2 U' L' U  /  M2			        -  (8)
-  x' U L' U' M2 U L U' x  /   U R U' M2 U R' U'        -  (14)
-  U'M')*3 U'M (U'M')*4  /  R' U R U' M2 U R' U' R	-  (25)
-  l U' R' U M2 U' R U l'  /   x' U' R' U M2 U' R U x	-  (16)
-  R' U R U' M2 U R' U' R			        -  (9)
[B]Fix:  (U’F2U) M2 (U’F2U)			        -  (7)
Flip: (M’U’M’U’M’U’M’)U2(M’U’M’U’M’U’M’)	        -  (14)[/B]

Total: 83/[B]104[/B]
```


----------



## martijn_cube (Aug 25, 2009)

Does anybody know a good one for. DF -> BU -> UF?


----------



## Ellis (Aug 25, 2009)

martijn_cube said:


> Does anybody know a good one for. DF -> BU -> UF?



I haven't had a chance to read deadalnix's posts, but did you try frederico's yet? x' (U M' U' M) U2 (M U M' U) x


----------



## martijn_cube (Aug 25, 2009)

Ellis said:


> martijn_cube said:
> 
> 
> > Does anybody know a good one for. DF -> BU -> UF?
> ...



Thanks. i hadn't seen it before. it's pretty nice.


----------



## deadalnix (Aug 27, 2009)

Nice, I use this one :

DMU'R2'UM'U'R2'UD'


----------



## deadalnix (Aug 27, 2009)

martijn_cube said:


> Test solve 1: L' B D2 B R2 L2 D' B' D2 U L2 R2 F' L' B L B' U R F2 U2 D2 R2 D2 F



On this solve, here is the way :

z'URU'MUR'U'M'z

U2M'UL'U'MULU

U'M'U'RUMU'R'U2

U'R2UM'U'R2UM - break into new cycle

M2UL2U'MUL2U'M

RU'R'UM'U'RUr'


----------



## martijn_cube (Aug 27, 2009)

Thanks. now i can study it a bit more. And hopefully understand it better.

U'MU'RUM'U'R'U2

U'R2UMU'R2UM'

I think that with these two the M moves are supposed to be the other way around. first M' and then M. But i didn't really test your version, so maybe i'm wrong.
So with some move i got it right and with some i did a much longer one.


----------



## deadalnix (Aug 27, 2009)

Yes, you are right. I have made a mistake.

My post is edited.


----------



## martijn_cube (Aug 29, 2009)

What would your solution be for : DF --> DB --> FL?
The thing i can now think of is: B2 M2 (U'L'U) M2 (U'LU) B2, but i'm not sure if this is the right way? It is a bit shorter than normal M2, but maybe not faster.


----------



## Mike Hughey (Aug 29, 2009)

martijn_cube said:


> What would your solution be for : DF --> DB --> FL?
> The thing i can now think of is: B2 M2 (U'L'U) M2 (U'LU) B2, but i'm not sure if this is the right way? It is a bit shorter than normal M2, but maybe not faster.



That's exactly how I do it; I've been doing it that way for months. But you're right, it might not really be faster. It helps me because I'm slow at everything, so reducing number of moves almost always helps for me.


----------



## trying-to-speedcube... (Aug 29, 2009)

Well, it's not really anything like M2, but if you don't think it's fast enough, I'd just do (y) D2 R' E' R D2 R' E R (y')


----------



## Mike Hughey (Aug 29, 2009)

trying-to-speedcube... said:


> Well, it's not really anything like M2, but if you don't think it's fast enough, I'd just do (y) D2 R' E' R D2 R' E R (y')



Yeah, BH would probably be best for me, but I found that a variant of what deadalnix is doing worked really easily for me without too much extra work. I need to switch to full BH someday, I think. I suspect it will be fastest for me.


----------



## deadalnix (Aug 29, 2009)

martijn_cube said:


> What would your solution be for : DF --> DB --> FL?
> The thing i can now think of is: B2 M2 (U'L'U) M2 (U'LU) B2, but i'm not sure if this is the right way? It is a bit shorter than normal M2, but maybe not faster.



L'UMU2MU2M2U'L



Mike Hughey said:


> Yeah, BH would probably be best for me, but I found that a variant of what deadalnix is doing worked really easily for me without too much extra work. I need to switch to full BH someday, I think. I suspect it will be fastest for me.



I Think that my solution have these advantages on BH :
1/ This is more finger friendly.
2/ This require less thinking.

BH need less moves.

Anyway, I think BH is really great on corners and center/wings on big cubes. But the edges is the bad side of BH in my opinion. Theres many different types of commutator for edges. With my method, you have edge grouped in category, and with the category of the two edges, you can know the pattern you have to use.

I'm not so fast at blind, I'm more a cube theoretician. And I'm probably not the most objective guy on this subject, but I think my method is at least as good as BH for edge, maybe better.


----------



## martijn_cube (Aug 30, 2009)

deadalnix said:


> martijn_cube said:
> 
> 
> > What would your solution be for : DF --> DB --> FL?
> ...



Wow that's a nice one. just a combination of the two M2's but alot easier


----------



## Mike Hughey (Aug 30, 2009)

deadalnix said:


> I Think that my solution have these advantages on BH :
> 1/ This is more finger friendly.
> 2/ This require less thinking.
> 
> ...



I've been using something pretty close to your method for edges for the past few months. I agree it's pretty good. But I'm slow at M2, so that keeps it from being really super good for me. It's finger friendly, but my fingers are slow and awkward.

As for BH requiring less thinking, not true if you've really got it down. BH should require zero thinking. If not, you haven't really learned it yet. But there's no reason why you can't use pseudo-BH where you replace certain minimum move algorithms with maximum speed algorithms. And of course your method can also require zero thinking, so I guess ideally they're the same on thinking.

Mainly I want to get where I've got everything memorized so there's no thinking. Your method requires little thinking, but there's still some involved, the way I do it. (And I also do it sub-optimally.) I guess I'm probably going to compare your "algorithms" for each pair with the standard BH algorithms, and see which one is best and memorize it for each case.


----------



## martijn_cube (Aug 30, 2009)

I have another strange one during my practice solves. But i cant really come up with a solution.
DF-> FU -> BD. 
But i red somewhere that BD was something special?
Maybe like this: B M’ (FR2F’) M (FR2F’) B’
Sorry for posting these questions again. I should just wait for you to complete your tutorial. But it's just a very cool method. especially when your used to M2. But indeed i don't understand all the cases.


----------



## trying-to-speedcube... (Aug 30, 2009)

x F E R U R' E' R U' R' F' x'

It's the normal M2 alg for BD or FU.


----------



## deadalnix (Aug 30, 2009)

U'RMUR'U'MURU'(M2R)U


----------



## martijn_cube (Aug 30, 2009)

trying-to-speedcube... said:


> x F E R U R' E' R U' R' F' x'
> 
> It's the normal M2 alg for BD or FU.



wow, nice.



deadalnix said:


> U'RMUR'U'MURU'(M2R)U



Alg isn't working. I think a wrong turn somewere. The last R should be R'. but then FU and BD are flipped. So your alg is for FD -> FU -> BD i think.


----------



## Marcell (Aug 25, 2010)

Hi guys! No matter how much I liked R2 (it is absolutely braindead, also supercube-safe, and it goes well with M2), I was still looking for ways to improve it - mainly to get rid of the long and uncomfortable algs for the R-layer corners thus making the method more effective. I came up with some ideas, collected the neccessary algorithms for them and named the whole stuff R2+. I learned the algs, used R2+ in competition and won. I decided that I was satisfied so I wrote a description about it. You can read it at http://kerulo.uw.hu/rubik/R2+.html. Let me know what you think!


----------



## cmhardw (Aug 25, 2010)

Wow Marcell, that is very neat! I wonder what Stefan will think of R2+, I hope he sees this!

Chris


----------



## MarcusStuhr (Aug 27, 2010)

Wow, impressive stuff... do you guys find that M2/R2 fits well with memory mnemonic systems (more easily than other methods?)


----------



## deadalnix (Aug 31, 2010)

I just read abour R2+ . This is really interesting, but I think that the alg set have to be reworked. Many of them are really finger hostile.

The method itself look very promizing. However, I do prefer BH on corners because of the small number of cummutator types (as opposite to edges).


----------



## Sakarie (Sep 1, 2010)

Marcell:

I haven't read the whole page (since I'm not interested in using it over BH), so I don't really understand the notation. Well, doesn't really matter, cause I can still do the algorithms, and compare to what I would (want to) use. 

You say you learnt the algs, so you learnt an algorithms for every case, not "inventing" commutators? That would make it possible for you to learn non-optimal algorithms, suited better for speed right?

I went through the algorithms in the first block, to see if I could find anything faster than what you've written. Decide for yourself what you like the best, but I think "mine" is faster. OBS, I don't use all of these myself, since it's easier to find move-optimal than speed-optimal. But I wish I did.

My list:
FRU +	z L' U2 L D' L' U2 L D z'
FRU -	D' R' D R U2 R' D' R D U2
FRU 0	x U L2 U' R' UL2U' R x' (The same)
UFR +	L2 U' R2 U' L2 U R2 U' L2 U2 L2
UFR -	z' R2 D' R'U2R D R'U2R' z (The same)
UFR 0	z'x R2 D R U2 R' D' R U2 R x'z
RUF +	x' D' R U' R' D R U R' x
RUF -	x' U' D' R U R' D R U' R' U x
RUF 0	R' D'R U2 R'DR U2 (The same)

Your list:
FRU +	z' R'D2R U' R'D2R U z
FRU -	z R2U' L2U R2U' L2U z'
FRU 0	x UL2U' R' UL2U' R x'
UFR +	LD'L F2 L'DLD' F2 D L2
(FR'F'R)3 U2 (FR'F'R)3 U2
UFR -	z' R2 D' R'U2R D R'U2R' z
UFR 0	D R2 F'LF R2 F'L'F D'
RUF +	z'x' RU2R' D RU2R' D' xz
RUF -	x R'D2R U R'D2R U x'
RUF 0	R'D'R U2 R'DR U2


----------



## Marcell (Sep 1, 2010)

@Chris: the fact that you commented positively on my post actually made me jump up and shout out loud.

@Marcus: I don't know, but I'd say it's more likely the cuber and not the solving method that defines what memo system would be optimal.

@deadelnix: I forgot to write "suggest better algs" at the end of the page. I corrected that now.

@Sakarie: I learned algs for case types rather than individual cases, thus reducing the number of algs to learn and making it possible to really know them by heart and execute them without thinking rather than inventing them on the fly. This algs are usually two moves longer than the optimal algs (setup and resetup).
Also, thanks a lot for your list. I will update my page when I have some time.


----------



## riffz (Sep 2, 2010)

Here's what I use. Some are the same as yours or Sakarie's. I don't use R2, but I use all these algs for corners anyway.

FRU +: x R U' L U R' U' L' U x'
FRU -: z R2 U' L2 U R2 U' L2 U z'
FRU 0: R2 U' L' U R' U' L U R'

UFR +: R' F' R2 F R U2 R' F' R2 F R U2
UFR -: z' R2 D' R' U2 R D R' U2 R' z
UFR 0: D x R2 U' L U R2 U' L' U x D'

RUF +	: x' D' R U' R' D R U l'
RUF -: l' D2 R U R' D2 R U' x'
RUF 0: R' D' R U2 R' D R U2


----------



## Gavin (Sep 2, 2010)

Marcell said:


> Hi guys! No matter how much I liked R2 (it is absolutely braindead, also supercube-safe, and it goes well with M2), I was still looking for ways to improve it - mainly to get rid of the long and uncomfortable algs for the R-layer corners thus making the method more effective. I came up with some ideas, collected the neccessary algorithms for them and named the whole stuff R2+. I learned the algs, used R2+ in competition and won. I decided that I was satisfied so I wrote a description about it. You can read it at http://kerulo.uw.hu/rubik/R2+.html. Let me know what you think!



R2+ is too many algs for my taste, but you're 12-15 sec execution with it is impressive.


----------



## Sakarie (Sep 2, 2010)

riffz said:


> Here's what I use. Some are the same as yours or Sakarie's. I don't use R2, but I use all these algs for corners anyway.
> *
> FRU +: x R U' L U R' U' L' U x'*
> That one is perfect. Don't understand that I didn't see it.​FRU -: z R2 U' L2 U R2 U' L2 U z'
> ...



What method are you using? This modified commutator-method?


----------



## riffz (Sep 3, 2010)

Sakarie said:


> riffz said:
> 
> 
> > Here's what I use. Some are the same as yours or Sakarie's. I don't use R2, but I use all these algs for corners anyway.
> ...



I have a list that I have compiled of, IMO speed optimal corner algs. Pretty much all speed optimized corner algs are still comms, just not move optimal. I'm still working through it and changing algs, because it seems every time I go through it I notice a comm I like better than the one I chose before. I'll publish it when I'm satisfied with it.


----------



## Sakarie (Sep 3, 2010)

riffz said:


> I have a list that I have compiled of, IMO speed optimal corner algs. Pretty much all speed optimized corner algs are still comms, just not move optimal. I'm still working through it and changing algs, because it seems every time I go through it I notice a comm I like better than the one I chose before. I'll publish it when I'm satisfied with it.


 Oh, it will be a pleasure to see when you're done. Unfortunately I use URB as buffer, so I can't really use it 100%.


----------



## deadalnix (Sep 6, 2010)

Maybe you could produce a draft version. We always are smarter together (and yes, it looks like a shitty gimmick for an advertisement).


----------



## riffz (Sep 6, 2010)

deadalnix said:


> Maybe you could produce a draft version. We always are smarter together (and yes, it looks like a shitty gimmick for an advertisement).



Yes, I suppose you're right. I'll upload it today or tomorrow, since I'm at my gf's currently.


----------



## Michal Robaczyk (Sep 23, 2010)

Hi,

I have few questions regarding this topic and I'd like to explain some my thoughts about M2/R2.

Well, I was using typical-basic version of M2/R2 (with no improvements). My buffers are FD and FDR. Now, after reading this topic, I'm gonna improve my method, especially the ugly cases.

And, here is the question:
What is better: to learn all 24 cases for M-slice edges (what Freddy88 wrote here: http://www.speedsolving.com/forum/s...ents-for-M2-R2&p=107654&viewfull=1#post107654 ), or learn only 2 of them (UF<->DB) + learn to avoid the UB sticker (what Haru has explained here: http://www.speedsolving.com/forum/s...ents-for-M2-R2&p=184171&viewfull=1#post184171 ) ?

Basically the cons of the second version is that you have to combine with the edges during memorisation; and I wanna the memo is nice and clean, just no-thinking edge-by-edge as they are on the cube.





StefanPochmann said:


> Corners before edges is somewhat unnatural. The side effect of solving the edges are only in the M slice. No corners are affected, so after solving the edges the corners are where they were in the beginning. This is not the case the other way around, as solving corners does affect edges. Though in the end that's just a problem in case of parity. If there's parity and you solve corners first, I think you can apply my parity fix after solving corners and then solve the edges, though you'd have to start edges not like usual but as if you had already solved one edge, i.e., with the edge solving side effect already in place.


 
I'm solving corners before edges (using my short memory), and my solution in case of parity is that after solving all corners i do R2 move (so that edges are on their places and FDR is swapped with BRU). After solving all edges I undo the R2 move and then I execute the M2R2 parity alg.


I'd like to mention other one thing I didn't see in the topic (and some ppl might not know that).
When there are some stupid edges, that means they are on their places but disoriented after scramle, you can avoid ugly cases of M-slice.
Instead of a ugly cycle: FD->UB->UF and then orienting FD and a stupid edge, you can do nice algs for BU and FU, then orient UB and the stupid edge.
An example:
Scramble: R2 B2 R2 U' L2 B F2 R B' D' L2 B' R' B
Normal, ugly solve:
(UB) - (U R’ U’ l U’ R U) M2 (U’ R’ U l’ U R U’) (thx for this great alg btw)
(UF) - M2’ D (UR2U’ M’ UR2U’ M) D’
orient DF and UR

Solve with the trick I've mentioned:
(BU) - M2
(FU) - M U2 M U2
orient UB and UR.




macky said:


> Interesting thread.
> 
> I don't like having to shoot to FU or RD to deal with bad targets. That actually requires thinking! Since I've been experimenting with a lettering scheme, I've found it natural in M2 to associate each letter, not each position, to an algorithm.
> 
> ...


 
This idea rox! I'm gonna use it. Same as Macky, I have binded letters with adequate moves, and I less thinking is faster imo.


Sth regarding R2 for corners:
My algs for ugly-URB cases are:
U' L U L' U' L U R2 U' L' U L U' L' U
U' L' U L U' L' U R2 U' L U L' U' L U
I think they are pretty fast.

And do you know any other tricks to improve R2?
R2+ is nice and fast, but there is lot to learn though.


Cya


----------



## Stefan (Sep 23, 2010)

Michal Robaczyk said:


> My algs for ugly-URB cases are:
> U' L U L' U' L U R2 U' L' U L U' L' U
> U' L' U L U' L' U R2 U' L U L' U' L U


Gosh I'm stupid...
Will use these from now on, thanks.

Btw, for the ugly L corners I now use these:
*BUL:* y (R U R2 U' R') F2 (R U R2 U' R') y'
*DBL:* (U' L2 U L' U' L U) R2 (U' L' U L U' L2' U)
*FDL:* (U' L' U L' U' L U) R2 (U' L' U L U' L U)
*UFL:* (L U' L' U L' U' L U) R2 (U' L' U L U' L U L')

Hmm... especially with these being so L-turn-heavy and even the nice cases having more L turns than R turns... maybe the L2 method would be better...

I see there are many nice ideas in this thread, some I haven't really tried much before as my main problem has always been slow memorization due to lack of practice. I'm currently working on memorization, hope I'll be fast soon and then I'm looking forward to check out all those improvements.


----------



## Simboubou (Oct 7, 2010)

R+ seems cool, but doesn't it come down to TuRBo ?


----------



## Marcell (Oct 7, 2010)

Michal Robaczyk said:


> Hi,
> 
> And, here is the question:
> What is better: to learn all 24 cases for M-slice edges (what Freddy88 wrote here: http://www.speedsolving.com/forum/s...ents-for-M2-R2&p=107654&viewfull=1#post107654 ), or learn only 2 of them (UF<->DB) + learn to avoid the UB sticker (what Haru has explained here: http://www.speedsolving.com/forum/s...ents-for-M2-R2&p=184171&viewfull=1#post184171 ) ?



I would advise you to learn those 24 cases (I know I did), it's worth it. But not neccessarily from that list.



Simboubou said:


> R+ seems cool, but doesn't it come down to TuRBo ?


 
No.
TuRBo: set up next two corners, then choose one out of 18 algs depending on their orientation.
R2+: set up third corner of the cycle using L*, then choose one out of 54 algs defined by the second corner and the orientation of the third one. (In the RL and LR parts.)

TuRBo: lot more thinking.
R2+: lot more algs.


----------



## Michal Robaczyk (Oct 8, 2010)

Marcell said:


> I would advise you to learn those 24 cases (I know I did), it's worth it. But not neccessarily from that list.


 
What algs do you propose? 


Btw I found some nice algs for odd parity cases (in M2/R2):
These two are already on Stefan's web:
L2 y’ R’ U’ M’ U’ L U r2 F R U’ F R U x’ y’
r2 y’ R’ U’ M’ U’ L U r2 F R U’ F R U x y

Other cases:
r2 U’ R U l’ U2 R U’ M U M’ U’ R’ U2 l R U’ R2 U

r2 y’ R F’ U F R U R2 F R F’ R U’ R2 y
L2 y’ R F’ U F R U R2 F R F’ R U’ R2 y x2


----------



## Marcell (Oct 8, 2010)

Michal Robaczyk said:


> What algs do you propose?



These are the algs I use:
http://kerulo.uw.hu/rubik/M-slice.html


----------



## mark49152 (Oct 26, 2015)

Marcell said:


> These are the algs I use:
> http://kerulo.uw.hu/rubik/M-slice.html



This is a thread worth bumping. Does anyone know where I can find these algs? The link is dead.


----------



## Lid (Oct 26, 2015)

Try this document: https://docs.google.com/spreadsheets/d/11p37_js6wB0LmzPEQvKG9XqBrH8IC_piFdbejmvUH-c/pub?gid=8


----------



## mark49152 (Oct 27, 2015)

Lid said:


> Try this document: https://docs.google.com/spreadsheets/d/11p37_js6wB0LmzPEQvKG9XqBrH8IC_piFdbejmvUH-c/pub?gid=8


Great, thanks.


----------

