Hey everyone, I know I’m not a seasonal solver so I apologize if I misuse any terms in the following post.I recently decided to attempt to solve gelatinbrain 3.1.31 and 3.1.33 puzzles, which contain both the normal edge pieces and “anti” edge pieces found in the complex 3x3x3. For me, it was very difficult to figure out commutators for these pieces with normal methods since they behave as though they are deeper-than-origin. However, I recently discovered that there is a unique method to create pure commutators for these pieces, and I thought I’d like to share it.

In my example, I will show the process for creating a pure 3-cycle commutator for the anti-edge pieces.

First, we will need to find another special commutator with unique properties which cycles 3 “normal” edge pieces in which the y parts are deeper-than-origin turns. For example:

**Code:**

R,U,R',U',F',U',F,[d],F',U,F,U,R,U',R',[d']

Notice that the y-parts of the sequence are deeper-than-origin turns.

Now, we’ll apply the x-part of this sequence (sequence 1) to a normal Rubik’s cube (gelatinbrain 3.1.2) and observe its properties:

Attachment:

forum post 1.jpg [ 217.98 KiB | Viewed 547 times ]
Notice that the edge that is isolated by the x-part is in the middle layer, which is important. There is one more thing to note. We will now apply the x-part of the original sequence from the solved state, but with deeper-than-origin turns rather than shallow turns:

Attachment:

**File comment:** [r,u,r',u',f',u',f]
forum post 2.jpg [ 209.99 KiB | Viewed 547 times ]
As you can see, the bottom “shallow” layer of the cube is unchanged, which is also important. Keep all of these properties of the commutator in mind as we move to the next step.

Secondly, we will need to convert the x-part of the original commutator into one which yields the same result, but using only deeper-than-origin turns instead of shallow turns.

This is actually easier than it sounds. We will start by labeling each center piece of the cube with its corresponding letter to the commutator:

Attachment:

forum post 3.jpg [ 222.93 KiB | Viewed 547 times ]
Now, we need to recreate one move at a time, starting with the first one.

In order to have the effect of turning the R center clockwise with a shallow turn, we simply need to turn the opposite side as a deeper-than-origin turn in the same direction. So, the first shallow move R becomes the deeper-than-origin move l:

Attachment:

forum post 4.jpg [ 223.3 KiB | Viewed 547 times ]
Attachment:

forum post 5.jpg [ 224.47 KiB | Viewed 547 times ]
As you can see, both states of the cube are identical; just the orientations of their axis systems are different.

Now, we move on to convert the next move. Remember, the axis system of the cube has changed due to the deeper-than-origin move, and now the U center is not located on the top face anymore, but rather on the front face. Since we must turn the U face clockwise, we must turn the opposite face with a deeper than origin move. So this time, the second move U becomes the deeper-than-origin move b:

Attachment:

forum post 6.jpg [ 224.43 KiB | Viewed 547 times ]
Attachment:

forum post 7.jpg [ 224.32 KiB | Viewed 547 times ]
Once again, both states are identical, but the axis systems are oriented differently.

We then move on to convert the third move, the fourth move, and so on by tracking the positions of the centers until the x-part of the commutator is converted. Once done, the new sequence (sequence 2) is:

**Code:**

[L,B,D',R',U',B',R]

You can plug the x-part of sequence 1 into gelatinbrain 3.1.2 and sequence 2 into gelatinbrain 3.1.31 and verify that both reach the exact same state (ignore the outer edges in 3.1.31). The axis systems are oriented differently, but both cubes are in the same position.

Notice that in this new sequence, while the sides that are being turned have changed, the directions that they are being turned are the same.

Now we need to apply sequence 2 on 3.1.2 and locate the unchanged layer after applying sequence 2. In this case, it is the bottom layer:

Attachment:

forum post 8.jpg [ 218.4 KiB | Viewed 547 times ]
Therefore, the y-part for the final commutator will be a D move; in this case we will make it D2 to make things easier to identify.

Finally, we need to assemble the whole sequence. We have the x-part and the y-part:

**Code:**

[L,B,D',R',U',B',R][D2]

All we need to do is undo the x-part:

[R',B,U,R,D,B',L']

Undo the y-part:

[D2]

And finally, assemble the sequences:

[L,B,D',R',U',B',R][D2][R',B,U,R,D,B',L'][D2]

So, our final commutator is:

**Code:**

L,B,D',R',U',B',R,D'2,R',B,U,R,D,B',L',D'2

Remember those properties in the original commutator that I mentioned earlier? They are actually necessary for the final commutator (sequence 3) to work correctly. Let me show you.

First, I’ll show 2 cubes next to each other:

Attachment:

forum post 9.jpg [ 242.06 KiB | Viewed 547 times ]
The one on the left is shallow cut, and the one on the right is deeper-than-origin cut. Both cubes turn at the same time.

We’ll start by applying the x-part of sequence 3 to both cubes:

Attachment:

forum post 10.jpg [ 242.57 KiB | Viewed 547 times ]
Notice the cube on the left. It is shallow cut, and has one layer (the bottom) which is unaffected due to the property of the original commutator. The reason this was important was because this is the layer that is turned in the y-part of the commutator (the D layer) and since it has not changed, there are no isolated pieces and therefore the whole commutator will have no effect on the shallow-turning cube.

However, take a look at the cube on the right. It is deeper-than-origin cut, and again has one layer (the bottom layer) that is unchanged EXCEPT for one piece, an “anti” edge piece. This is the same ‘edge’ piece we isolated in sequence 1!

The otherwise unchanged layer is the same layer that is turned in the y-part of the commutator (the D layer) and since there is only one isolated piece in that layer, it will effectively create a pure 3-cycle of those pieces on the deeper-than-origin cube, without affecting any other piece types.

Now, we will finish applying the commutator to both cubes:

Attachment:

forum post 11.jpg [ 239.97 KiB | Viewed 547 times ]
As you can see, only the anti-edge pieces have been cycled, and the regular edges are still solved.

This doesn’t just work for 3-cycles. You could also use this technique to orient 2 anti-edge pieces in my example by simply making the first commutator orient 2 edges rather than cycle 3 of them.

I hope you understand the method that I use to create these commutators, and let me know what you think! Thanks guys!