# For those who uses commutators



## campos20 (Mar 20, 2017)

Hi

I'm learning commutators just now (switching from OP to corners). I already know how it works: setup, change, undo, undo or A, B, A', B'. I was having problems figuring out which sticker should go first and where. I came up with a system that helps in that. I discussed it with some (specialist) people here and it looks like a new system, although I'm not sure. Just wanna share, anyway.

I was trying to figure out how to change stickers, having in mind just the letters for the commutator.

In commutators, there's a sticker that goes both in the setup and the change layer. We can call it *Base Sticker*.

Using speffz, suppose we want to do the commutator ABU, in which A is the buffer (A-BU). We can use L2 as change and D R2 D' as setup. In that case, U would be the *base sticker*, since it belongs to both setup and change. The buffer and base sticker are different. When that happens, we must follow the order of the commutator A-BU, which means that we have to do the letter B go to the buffer first. To do so, we do D R2 D (which puts the B in DFR) and then do L2 (which puts the letter B in the buffer spot first), then undo undo.

Now, let's consider the commutator A-VU. Change can be L2 and setup U R2 U'. Base sticker is A and now base sticker and buffer are equal. When that happens, we must follow the inverse order or the commutator (A, UV), which means that U must reach the buffer first, which can be accomplished by doing L2. Then U R2 U', undo undo.

Conclusion:
When the base sticker and buffer are different, same order.
When the base sticker and buffer are equal, inverse order.

*More examples
*
# 1
Commutator: C-PL
Buffer: C
Change: D
Setup: R U R'
Base sticker: P
Situation: buffer and base are different, same order.
Execution: R U R' (change buffer and P) then D.

# 2
Commutator: A-HB
Buffer: A
Change: U'
Setup: L' D' L
Base sticker: A
Situation: buffer and base are equal, inverse order (BH).
Execution: U' (change buffer and B) then L' D' L.

Of course, there's no need to discuss conjugates, since it turns general commutators into pure commutators, then everything above applies.


----------



## lucarubik (Mar 20, 2017)

thats kind of confusing, once you know what's your base location you shouldnt be needing to think if thats the buffer or not, whatever floats your boat tho, i used to think it this way: wich sticker goes over what you call base location alright its this one let me just insert it/ interchange it real quick, then i would interchange/ insert the other


----------



## campos20 (Mar 22, 2017)

The buffer is the reference when you are blindsolving. I was just throwing the idea, as in a brainstorm. Please clarify you way of thinking, perhaps it can help others.


----------



## newtonbase (Mar 22, 2017)

The way I learnt it was to do whichever move solves the base spot first.


----------



## lucarubik (Mar 22, 2017)

if you mean the way of thinking of cycle directions newtonbase was way more short and clear than me
if you mean the way of thinking where and what to post that's insultingly ridiculous
i came up with your same idea when i was learning comms, i tossed it after making enough cycles backwards, i wish someone told me


Spoiler: this



The way I learnt it was to do whichever move solves the base spot first.


 If it helps you or anyone that reads it f****** great, I cant be more constructivley respectfull


----------



## campos20 (Mar 22, 2017)

lucarubik said:


> if you mean the way of thinking of cycle directions newtonbase was way more short and clear than me
> if you mean the way of thinking where and what to post that's insultingly ridiculous
> i came up with your same idea when i was learning comms, i tossed it after making enough cycles backwards, i wish someone told me
> 
> ...



I'm afraid we're getting lost somewhere with the English idiom. I never intended to offend you in any way.



newtonbase said:


> The way I learnt it was to do whichever move solves the base spot first.


It makes sense! Just tried it in several cases and it looks correct. I see no point in changing the systems right now, but thanks for sharing! I just thought of something. If we have to move the base for a conjugate, wouldn't this "solve base first" be a littler harder?


----------



## lucarubik (Mar 23, 2017)

campos20 said:


> It makes sense! Just tried it in several cases and it looks correct. I see no point in changing the systems right now, but thanks for sharing! I just thought of something. If we have to move the base for a conjugate, wouldn't this "solve base first" be a littler harder?


i do find it problematic for this case (after 7 years knowing comms) U r' U' M2 U R U' M2 U M' U', so yeah it gets harder sometimes if the set up involves a couple of stickers
in the end it is a matter of practice


----------



## leeo (Mar 25, 2017)

from Buffer I track two cubie stickers which I call Target and Secondary. Target is simply the cubie sticker that would be read at Buffer's position, and Secondary is the next BLD reading or the cubie sticker that would be read at Target's position. In 3-op, applying the correct sequence usually places Target and Secondary with Buffer then receiving the cubie sticker that would be read at Secondary's position.

The algorithms in my repertoire I classify by playing them into a solved cube and reading them BLD-solve style. For instance for the speffz letter system the sequence M U R' U' M' U R U' or in conjugate form [ M, U R' U' ] when played into a solved cube BLD-solve reads as (AST_#), where S_ is the speffz system letter of the Secondary it solves, and where T_ is the speffz system letter of the Target it solves (and also literally _S and _T for this example case).

For extending the reach of an algorithm with setup moves here is an example. With (AST_) in my algorithm set repertoire, a preferred buffer of UB or A_, and a BLD reading of (ABO_): I think BO_ "setup S_" BS_ ( D move changes O_ to position S_), followed by BS_ "setup T_" TS_ ( R move changes B_ to position T_ ). Now I apply (AST_) from my repitoire and then undo the setups in memorization order, ST_ "restore B_" BT_ "restore O_" BO_. Now B_ and O_ are placed and the buffer (A_ in this example) holds the next item to place.

I also find it helpful to have Target in the same general vicinity (usually solid-diagonally opposite Buffer) and avoid learning direct inverses, such as (AST_) and (ATS_) unless I'm prepared to relentlessly practice distinguishing them. The only exceptions I have found to be useful are the A-perms and the Top-only corner three cycles (#_AIN) and (#_ANI), L' U R U' L U R' U' and U R U' L' U R' U' L


----------

