#### JanW

##### Member

**Algorithms**

The basic algs are:

U R U R U R' U' R' U' R' - UF->BR->UR

U R U R U' R' U' R' U' R - UF->BR->DR

U R U R U2 R' U' R' U' R2 - UF->BR->FR

On closer inspection we can see that these could almost be expressed like commutators [U R U R, i], where 'i' is the interchange move that can be either U, U' or U2. The only difference is that the interchange move is undone in the other layer.

[U R U R, U] = U R U R

**U**R' U' R' U'

**R'**

[U R U R, U'] = U R U R

**U'**R' U' R' U'

**R**

[U R U R, U2] = U R U R

**U2**R' U' R' U'

**R2**

Despite this difference, I will still use commutator notation and terminology for them in this post, because that is how I think of them. Just be aware of the difference. When you use them in solving it comes naturally, because you wouldn't follow up a U layer move with another U layer move in a 2-gen alg. I apologize if this causes confusion. If someone has a better suggestion for notation or terminology, let me know.

Before we move on, let's add 3 more algs for some more options:

[R U R U, R]: UF->UR->BR

[R U R U, R']: UF->UL->BR

[R U R U, R2]: UF->UB->BR

(Like the first three algs, the interchange move is again undone in the other layer, so [R U R U, R] = R U R U

**R**U' R' U' R'

**U'**etc.)

**Choosing your alg**

We now have six algs for six different cycles. To know which alg to use, we need to know 2 things: the very first move and the interchange move. The rest follows automatically. To choose the moves, let's look at the structure of these cycles.

There is your buffer (UF) and another target on the opposite outer edge of the R layer (BR). I will call these the fixed targets, because these are part of all cycles. When you do the algs on the right side from UF, you will always need another target in BR. The third target is anywhere on the U layer, or outer edge of the R layer. One of the fixed targets will be moving to the third target. For now, in lack of better terminology, I will call the different layers the single layer and the double layer, where the double layer is the layer that has a fixed target moving to the third target. So for the first three cycles, [U R U R, i], the R layer is the double layer (they all have BR->another target on outer edge of R layer) and U layer is the single layer. The last three cycles, [R U R U, i], the double layer is the U layer (They all have UF->another target on U layer) and R layer is the single layer. Now choosing the first move of your algorithm is simple:

**The fixed target on the single layer moves away from the double layer.**

In the first 3 cycles, UF is the fixed target on the single layer, so we move it away from the R layer with a U move and the alg becomes [U R U R, i]. In the following 3 cycles, RB is the fixed target on the single layer, so we move it away from the U layer with a R move and the alg becomes [R U R U, i]. As we expand in more directions, this rule can always be used to determine the first part of the alg.

Now to pick the interchange move. As we can see, if the fixed target on the double layer is moving 180 degrees (UF->UB or BR->FR), it is a double move, U2 or R2. That is easy enough to remember. For the other 2 options, it is best to think of it visually. If the third target lies between the two fixed targets (UF->UR->BR or UF->BR->UR), the interchange move continues in the same direction as the first move ([

**U**R U R,

**U**] or [

**R**U R U,

**R**]). If the third target is away from the other fixed target (UF->UL->BR or UF->BR->DR), the interchange goes in the opposite direction to the first four moves ([

**U**R U R,

**U'**] or [

**R**U R U,

**R'**]). In practice this means that with the third target between the fixed targets, your alg switches direction after 5 moves, with the third target away from the second fixed target, the alg switches direction after 4 moves (and switches direction again before the final move when you undo the interchange).

**Interchange first cases**

In cases like UF->BR->UB or UF->DR->BR, you have targets that satisfy the above condition (fixed targets in UF and BR, and a third target on U layer or outer edge of R layer), but none of the fixed targets is moving within it's own layer. In these cases you can either think of it as interchange first, or setup moves with cancellation.

In the first example, UF->BR->UB, the setup would be U2 to UF->UB->BR and the full alg would be [U2; R U R U, R2]. As the R2 interchange is undone in the U layer as U2, we get a cancellation with undoing the setup and the alg can be expressed as [U2, R U R U] (performed

**U2**R U R U

**R2**U' R' U' R').

For the second example, UF->DR->BR, we need a R' setup to make it UF->BR->UR and the full alg would be [R'; U R U R, U]. Again, undoing the U interchange in the R layer would be R', while undoing the setup move is R, so we have a cancellation and the alg can be expressed as [R', U R U R] (performed

**R'**U R U R

**U**R' U' R' U').

With the third target between the fixed targets you will never need to perform interchange first, because one of the fixed targets is always moving to the third target.

**Flipping your buffer**

So far we have been dealing with only target on U layer and outer edge of R layer. Next let's look at the case UF->RF->RB. Here the other 2 targets are on the R face, not the outer edge of the R layer. To solve this, we do Lw' or M' setup, and we get UB->FR->BR (flipping the buffer will always flip the targets aimed to on the other 2 pieces as well). This satisfies the condition with UB buffer, a second fixed target on the opposite outer edge of R layer (FR) and a third target also on the outer edge of R layer. Same rules apply, so you start by moving the fixed target on the single layer (UB) away from the double layer with a U' move and since FR is moving 180 degrees the interchange will be a double move, thus the full algorithm to solve the cycle is [Lw'; U' R' U' R', U2] (performed l' U' R' U' R' U2 R U R U R2 l).

Another example, UF->RU->RF. You can do setup Lw' to UB->UR->FR, then same rules apply. FR is the fixed target on the single layer so you start by moving it away from U layer with a R' move. The third target lies between the fixed targets, so the interchange continues in same direction as the first part of the alg. The full algorithm becomes [Lw'; R' U' R' U', R'] (performed l' R' U' R' U' R' U R U R U l).

**Expanding further**

All of this can of course be performed on the left side as well with algs [L U L U, i], [L' U' L' U', i], [U L U L, i] [U' L' U' L', i]. The same rules for how to pick which version of the alg to use apply there as well. Using those and the same possibilities for R side, we have 24 different algs for 24 different 3-cycles. You do not need to learn any of the algs as algs, just learn what the different setups look like on the cube and how to pick the first move of the alg and the interchange based on that. Next step is to figure out how to do setups to these cases. Many setups are very simple, some might be harder to spot at first. But any 3-cycle can be solved with max 2 setup moves. I've been practicing with these for a few weeks and execution of the different algs comes pretty much automatically by now. I don't think at all about which alg to use, just visualize the three targets on the cube and my fingers do the rest of the job based on that. Finding setups is also mostly quite instant, only a few cases still that have me stop and think. Going through all cases systematically and working out setups for them one by one would certainly help there.

**Summary**

1. Setup to a cycle with one fixed target in UF or UB, the other fixed target on the opposite outer edge of L or R layer (BL or BR for UF, FL or FR for UB), and the third piece anywhere on U layer or the outer edge of either L or R layer, depending on where your second fixed target is.

(1.5 If none of the fixed targets is moving within it's own layer, it becomes interchange first, or setup with cancellation.)

2. Start main alg by moving the fixed target on the single layer away from the double layer.

3. Interchange move continues in same direction as first half of the alg if the third target lies between the fixed targets, goes in the other direction if the third target is away from the other fixed target, and is double move is the fixed target on double layer moves 180 degrees.

4. Undo setup.

**Advanced: Setup moves and cancellations**

In many cases the last move of the alg, undoing the interchange, will cancel with the setup moves. To take care of these automatically, you can also think of it like this:

1. Setup to a cycle with UF or UB and 2 other targets anywhere on the outer edge of R layer or L layer. For example UF->FR->DR.

2. Locate the sticker that is supposed to stay on the outer edge of the R layer and where it is supposed to go. In our example this sticker is FR and it is supposed to go to DR.

3. Move this sticker to the other fixed target (opposite to your buffer). In our example we move FR to BR with R2 and get the case UF->BR->UR.

4. Perform the alg for this case

**without undoing the interchange**. In our example we do U R U R U R' U' R' U'.

5. When you don't undo the interchange, the sticker that started in the fixed target of the double layer (in this case BR) will always be back in the same location. Move it from there to the location it is supposed to end up in. In our example we move it from BR to DR with a R move.

So for the example UF->FR->DR, the full execution becomes R2 U R U R U R' U' R' U' R.

**Pros and cons**

Pros:

-Relatively low move count. With 0-2 setup moves and a 10 move alg it should fall somewhere between turbo and pure comms.

-No need to learn any algs at all. Just learn to pick your first move and interchange move based on the pattern.

-Quite fast 2-gen execution

Cons:

-Setups are not always immediately obvious.

-Requires good visualization skills to find the best case to set up to.

-Doing cycles on the left side with L moves is not the most comfortable to execute.

-Seeing how lengthy this explanation became, I realize it might not be quite as simple as it is in my head.

**Examples**

A couple of example solves with cycles of varying complexity to show possible solutions with setup moves. I don't guarantee that these are the best possible solutions for each cycle with this system, it's just the first setups I found when looking at the cases. As earlier in this post, the interchange moves in the commutator notation are to be undone in the other layer.

**Example 1**

Scramble: F' L2 F D2 U2 B R2 F' D2 L2 R2 U2 L' U' F' L' D2 R' U B R (solve in same direction as scramble)

UF->BD->DF (Setup to UF->BR->DR)

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

UF->LF->UB (Setup to UF->FR->UB)

[d; R' U' R' U', R2]

UF->RD->RU (Setup to UB->FR->BR)

[x; U' R' U' R', U2]

UF->BR->DL (Setup to UF->BR->DR)

[D2; U R U R, U']

UF->UL->RF (Setup to UF->UL->BR)

[d; R U R U, R'] (setup and undoing of interchange cancels into y and cube is solved without performing those)

**Example 2**

Mostly more difficult cases, one of those scrambles I don't like to see...

Scramble: U' L2 B2 U R2 D B2 L2 R2 U L2 F2 L' B2 D L' D' L F R F

UF->DF->RD (Setup to UF->DR->BR)

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

UF->LU->RB (Setup to UB->UL->FR)

[r (R); (R') U' R' U', R] (cancellation in parenthesis)

UF->BD->LF (Setup to UB->FR->UL)

[D' x; U, R' U' R' U']

UF->LB->RF (Setup to UF->UL->BR)

[d L'; R U R U, R']

UF->UB->DL (Setup to UF->UB->BL)

[(L); (L') U' L' U', L2] (cancellation in parenthesis)

UF->UR->BU (Setup to UF->UR->BR)

[B'; R U R U, R]

**Conclusion**

Would I recommend this system? Depends. If you are like me and don't like M moves or drilling algs, then it's a good option to turbo or standard comms. The learning curve might be steep, but once you understand the basic principles of how these algs work and can visualize the different cases, I believe it can be quite fast. For other people, these principles can be useful to work out certain algs for a more freestyle approach. Especially those that can be done without setup moves, or just one easy setup, might sometimes be faster than other options available. I wouldn't recommend sticking strictly to this system, 4 move comms for cases like UF->UB->DF are definitely worth learning, and U-perms are always U-perms. Though the 2-gen U-perm is actually using this system with setups. R U' R U R U R U' R' U' R2 does R setup to UF->BR->UL, performs the interchange first variant [U', R U R U], then undoes setup. Studying the U-perm is actually what lead me to discover this system in the first place.

I hope this explanation is at least somewhat clear. If not, ask and I'll try to clarify.