yeah I know that but when do we do it?

If you mean that A is the 1-move interchange and B is the 3-move insertion, then you want to do B first in the cases where it solves a piece in the cycle.

Take DF -> FU -> RF for example. The commutator used to solve this case would be [M', U' R U], because M' will bring the piece at DF to its solved position. If you did U' R U first, then it would bring the piece at RF to FU, when it should be going to DF.

For the other direction, DF -> RF -> FU, the commutator is [U' R U, M']. You would do U' R U first this time, because you want to bring the piece at RF to FU.

Hopefully that helps... It's one of the things about commutators that's difficult to explain, but once you get it you just GET IT. (At least that's what happened for me.)

I usually do them when I don't want an extra set-up move.

The setup move would cancel with the other part of the commutator anyway. It's just an ugly way to write an 8-mover as a 10-mover:

DF -> RF -> FU

You could retain the form [A, B] (where A is 1 move and B is 3) by doing the setup move U', giving U' [R, U M' U'] U. But this of course is the exact same algorithm as [U' R U, M'] once you cancel the setup moves.
 
Last edited:
I use OP for corner and usually I solve it in 40-50 seconds

Now I want to learn an advanced method

Turbo (I know alredy all algoritms) or I have to became to study commutator?

A good way to move from turbo to commutators is to just make sure that you understand how to construct all of the turbo cases intuitively with commutators. At this point you'll be well on your way to expanding to all cases.
 
Im using M2 for edges with pure visual memo.

Im having a trouble with UF/DB target while i execute the cycle, is the UF/DB target odd or not.

If it happen, i count the cycle from the first target which take very much time.

What must i do?

You should memo in pairs or groups of 4 pieces and count from the start of these groups.
So you are breaking you memo into small parts and you can count from the start of theses small groups instead of the start of the memo

Not sure if this is good for visual. You might want to try letters
 
I've tried letter before, but im not good with it...

I also tried to memo a group of 4 pieces, but it doesnt work too..

For example :
DR-RF-BU-RU
FU-RB-LD-LU
LF-DB-BL

i will memo the cycle like this
DR-RF
BU-RU-FU
RB
LD-LU-LF
DB-BL

see? My memo style break the group, and often make me confuse about the target at M layer...
 
My 3x3 averages are sub 20. Does that make me capable of doing sub 2 or even sub 1-30 bld solves? If so, how fast should my memo be and how fast should my execution(solve in bld) be???

I realize Chris already answered this nicely, but I just wanted to mention that I have yet to get a sub-20 average 10/12 at home (although I've gotten close a few times), and I have managed sub-1 BLD; my best in competition is 1:04.34. My memo is about 25 seconds; my execution is about 35 seconds. If you're averaging about 20 seconds, you need to be a little faster at memo than you are at execution to be sub-1.

Mats Bergsten probably averages about 1:30 on 3x3x3 BLD, and he averages about 40 seconds on 3x3x3 speedsolve. So you're way faster than you need to be in order to be sub-1:30 BLD!
 
How did people solve big cubes bld before the M2 method was invented?

Dror Vomberg told me that he would use setups into a handful of useful, and fast to execute, commutator cases. He did this for both centers and wings. For corners he did his usual 3x3 stuff (which I want to say was 3OP?).

I know a guy who solves 4x4 pairing the edges and then as a 3x3

I solved my very first 4x4x4 BLD solve (actually the 4x4x4 supercube) this way. To permute edges I used the pure version of the OLL parity alg followed by rotating the U layer center 180 degrees. This swaps UFr and UFl and does nothing else to the cube. For centers I used setups to place all 3 centers on the same layer and did an A9 A-perm style commutator to move them (I didn't understand how commutators worked yet). Including memo the solve time was a little over four and a half hours.
 
Last edited:
Is this correct? I figured it out myself so I'm not that sure.

In Pure Commutators, if the 1st and 2nd piece of the cycle are the interchange pieces, then we execute in the order of BAB'A'. If the 1st and 3rd piece or 2nd and 3rd piece of the cycle are the interchange pieces, we do ABA'B'?

oh, BTW, for me A is the 3 move insertion and B is the interchange move.
 
Is this correct? I figured it out myself so I'm not that sure.

In Pure Commutators, if the 1st and 2nd piece of the cycle are the interchange pieces, then we execute in the order of BAB'A'. If the 1st and 3rd piece or 2nd and 3rd piece of the cycle are the interchange pieces, we do ABA'B'?

oh, BTW, for me A is the 3 move insertion and B is the interchange move.

Hello, I answered this question in the PM you sent me. However, I suppose I will post it here as well just for the sake of helping others as well (of course that's assuming I wasn't stupid and didn't mess anything up, heh).

Me said:
Hello!

I am not 100% sure that I understand your question. I get the idea, but instead of trying to answer it I'll just try to give a quick overview. If it doesn't answer your question, don't hesitate to ask again. Really.

I'll be explaining this for corners. If you need help with edges, please say so. Sorry if this is long winded or doesn't answer your question.

For corners I use a ULB buffer. Let's consider the cycle ULB -> URF -> BLD (lol it says BLD). This is a pure 8 mover (which is what I'm assuming you're talking about). The way I see it, our interchange will be U2 which will interchange ULB and URF. Our insertion will be R' D2 R. So:
Code:

A = R' D2 R
B = U2

The way I determine if A or B comes first is like this (pay attention, it's kind of confusing. I came up with this myself, so if it doesn't make sense to you I understand perfectly). I realize that this three cycle of corners is a four step cycle. Although we WRITE the cycle like
Code:

ULB -> URF -> BLD

what is actually being cycled is:
Code:

ULB -> URF -> BLD -> ULB

You'll notice that BLD indeed finishes off the cycle back in the ULB position. Keep that in mind. Back to how I determine A or B. I look at my A.
Code:

A = R' D2 R

I notice that this insertion inserts BLD into URF. Now, if we were to do A first in our commutator, our cycle would tell us that BLD cycles into ULB. So, let's take a look at our cycle.
Code:

ULB -> URF -> BLD -> ULB

As you can see, BLD does not cycle into URF. It cycles into ULB. That tells be that B has to come first. So, our commutator will take the form of:
Code:

B A B' A'
when
A = R' D2 R
B = U2

Now, what if our cycle was
Code:

ULB -> BLD -> URF -> ULB

In this situation I would again look at A:
Code:

A = R' D2 R

A does the same thing it did last cycle (duh, heh). Only this time, we notice that BLD is indeed supposed to cycle into URF. So we know that the interchange comes first. Our commutator will look like:
Code:

A B A' B'
when
A = R' D2 R
B = U2

Eventually, after much practice, you won't need to follow this to figure out which comes first. It eventually just becomes second nature, kind of like CFOP's F2L step. Sorry if this was a lot of information that you didn't actually need. Again, if you need more help or are confused just ask.
 
What are some various methods for solving megaminx bld?

I know for lettering, a side is a letter which makes it easy in two ways: you can make the corners and edges have different lettering schemes (as in MA might be a corner but MB might be an edge). This prevents any screw ups (I often mess up on this xD) with transition.

But for _solving_... I know there is the basic Old pochman variant. There is also the set up to a single used commutator (for instance, M BFL2 M' U2 M BFL2' M U2' for edges and any basic one for corners). What other methods are there?
 
What are some various methods for solving megaminx bld?

I really hope to write up my method sometime soon, but I haven't gotten to it yet. I switched recently to orient-permute, and I LOVE it. It means more moves while solving, but it makes memorization much more manageable, and thinking during solving less complicated overall. I tend to complicate it somewhat by trying to set up solving 2 pieces at a time often while permuting, but that part isn't necessary - you can do it Pochmann style (one piece at a time) if you want, and then there's almost no thinking involved.

The basic concept is that you assign an orbit of stickers as being "oriented", and then you determine for edges the set of pieces that need flipping, and for corners the set of pieces that need to go clockwise or counterclockwise. (Actually, for corners, I memorize either pairs or triplets, depending on what I hit first.) So you orient all the pieces so they match up with the stickers you've chosen as properly oriented, and then you know what all the orientations of all the pieces are, and so you permute them. To permute, I just use a couple of basic commutators, knowing that once my pieces have been oriented, those permutations will completely solve the piece.

Some nice things about this: For corners, I can memorize using just 20 letters. For edges, I need 30, which I don't have, so after Y I just use numbers 0, 1, 2, 3, 4. I combine two pieces into one image, as I do with most of my blindsolving. I have 4 sets of memorization: edges to flip, permutation of edges, corners to twist, and permutation of corners. Both sets of orientation are relatively easy, and the corner permutation is easiest of all. Unfortunately, the edge permutation takes a ton of time; it's probably half of my memorization time, and certainly more than half of my solving time.

Edge permutation is still ugly no matter how I do it. But since I switched to this method, memorization is no longer painful, and I can actually relax and have fun with megaminx BLD now, which I couldn't do before.

This week I got what I believe is my new PB at megaminx BLD: 26:47.43 [13:50 memorization]!
 
Oh! Nice!

I dont believe that I would want to make extra pairs for 0,1,2,3,4... How do you do it exactly? Are they completely seperate peg words? or do you do it by quantity? (obviously with 0, that would be hard :P)

But also, out of curiousity, what algorithm do you use for edge orientation?
 
I dont believe that I would want to make extra pairs for 0,1,2,3,4... How do you do it exactly? Are they completely seperate peg words? or do you do it by quantity? (obviously with 0, that would be hard :P)
Since I don't take megaminx BLD all that seriously, I haven't bothered to actually make pairs for them. For some of them it's obvious (R2-D2 for "R2", for instance - I love when I get that one!), but when I don't have something occur to me immediately, I usually use my one-letter image for the letter, and then add a quantity. I even sometimes do that for zero, which is a little bizarre, but sometimes it sticks. It's not very solid, but for one megaminx BLD solve a week, I'm satisfied with it. I'm sure if I came up with solid images for them all, it would get a little easier.

Order on the quantity can be interesting. Lately I've been making it so, if the number comes first, I'll do a quantity of the single-letter image. But if the number comes second in the pair, I'll just have the single letter image, and then apply the quantity to the next image in my memorization. That's been working pretty well, actually.

But also, out of curiousity, what algorithm do you use for edge orientation?
I hate megaminx notation - that's part of why I haven't written it up yet. I guess you could notate it like this: R' F' U L' U' L F R L F U' R U R' F' L'. (I hope I have that right - I don't have a puzzle to check it on.)

I bet there's a good 4-flipper out there that would be nice to know, but I don't know one. I just set them up two at a time and use this.
 
Last edited:
Back
Top