Thread starter
#1

This is an in-progress tutorial for BH.

BH Tutorial

by Brian Yu

Version 1.5

Consists of both written tutorial and video

This tutorial is meant to allow you to solve corners without memorizing 378 algorithms, one for each case. It will allow you to solve all of the cases, not only correctly, but also optimally.

In BH, algorithms take the form of a commutator. A commutator takes the form

ABA'B'

For example, if we had R U R' as A, and D as B, the commutator would be.

R U R' D R U' R' D'

Which is 8 moves. 8 moves is the standard 'pure' commutator length. There are many different kinds of commutators in BH. The ones that are needed for BH corners are:

Pure (8 moves)

A9 (9 moves)

Orthogonal (10 moves)

Cyclic Shift (10 moves)

Columns (11 moves)

Per Special (12 moves)

In this tutorial, I will go through each one of these commutators, and how to solve it. I HIGHLY recommend that you go through in order of this tutorial, and not skip around, because I will be introducing terminology as I go along.

PART 2 - PURE COMMUTATORS

The Pure Commutator is 8 moves, as you probably saw from the first section. I am going to use URB as buffer for this tutorial, but many other people also use UBL, and really you could potentially use any buffer.

The first term I am going to teach you is the term 'interchangeable'. If two stickers are interchangeable, that means that in one turn (R, D2, L', etc.) one can be moved to another. For example, UFR and URB are interchangeable with a U' move. However... FRU and URB are NOT interchangeable, because U' doesn't interchange them (FRU goes to RBU instead of URB).

So, in a Pure commutator, the first thing we are going to look for is two pieces that are interchangeable. Not only that, but those two pieces NEED TO BE on a different layer as the third one. For example, given this cycle:

(URB FRU LFU)

We see that LFU and FRU are interchangeable with U', and URB and FRU are interchangeable with R'. Which one is correct? Well, LFU and FRU are on the same layer as URB (U). However, URB and FRU are on different layers than LFU (R and L). So URB and FRU, with the interchange move R', is the correct interchange.

So, the interchange move will be the B of our commutator (ABA'B'). Using the same cycle as above, (URB FRU LFU), we are going to find out the A.

A needs to do the following: Insert the non-interchaging piece into one of the interchanging pieces without messing up the rest of the interchanging layer. Using (URB FRU LFU), we see that LFU can be inserted into FRU using F' L' F. Remember, that LFU must go to the FRU, exactly. It cannot go to RUF or UFR, otherwise the commutator has been messed up. You can see that with F' L' F, the LFU corner goes to FRU without the interchanging layer being messed up other than at FRU.

Now, we have the two parts, F' L' F and R'. But, we need to go back to the commutator.

(URB FRU LFU)

We look at the non-interchanging piece, LFU. Where does it need to go. It seems as if it just ends there, but it actually is a "cycle" so it loops back. LFU needs to go to URB. So, by doing F' L' F, we are actually inserting LFU into FRU, when it needs to go to URB.

So, we are actually doing an inverse pure commutator, instead of ABA'B', we are doing BAB'A'.

So, the first thing to do is to bring URB to FRU, so that we can insert it.

B = R'

Next, we have to insert the LFU to FRU, which right now holds the URB piece.

B = R'

A = F' L' F

Then, of course, we reverse the moves with B'A'.

B = R'

A = F' L' F

B' = R

A' = F' L F

So, the entire commutator that does the cycle (URB FRU LFU) is...

R' F' L' F R F' L F

Now, if the cycle had been done the other way around, as in, (URB LFU FRU), then we look at LFU, the non-interchanging one and say "where does this belong". It belongs to FRU. So this means we do F' L' F immediately.

So (URB LFU FRU) would be

F' L' F R' F' L F R

Which is the inverse of the first one I showed you. Commutators work just like that. I'll give you another example.

(URB LFU LUB)

The first thing that you should note, although it doesn't matter when you are really solving it, is that this case has more than one optimal solution.

There are two possible interchanges, URB and LUB, or LFU and LUB. I'm going to use URB and LUB, but the other one works too. So, for URB and LUB, the interchange move is B.

The A needs to send LFU to LUB without messing up the rest of the B layer. To do this, we do U' F' U.

Finally, we need to figure out whether we do ABA'B' or BAB'A'.

To do this, we look at the non-interchanging piece (LFU). It needs to go to LUB, which is what A does. So we do ABA'B'. If LFU had to go to URB, we need to do the B move first, therefore making a BAB'A'.

So the commutator is:

U' F' U B U' F U B'

Shortened down, here are the steps that you need to follow for a pure commutator:

1. Determine the interchanging pieces and the interchanging move (B).

2. Determine the A section, which inserts the non-interchanging piece.

3. Determine whether it is ABA'B' or BAB'A'

4. Execute

Follow these exercises to practice.

EXERCISE A. Earlier in this section, we worked on the commutator (URB LFU LUB) with the interchange move of B. Do this commutator again, but use L as the interchange.

EXERCISE B. Execute the commutator (URB FRU FUL)

EXERCISE C. Execute the commutator (URB FLD RFD)

The A9 is just an extension to a pure commutator. These, in my opinion, are fairly difficult to get optimal, since it really requires a lot of thinking.

An A9 can be used when you have two interchangeable pieces, but either there's a piece already in that layer, or there is no 3-move insertion (A) part.

The way it works is this. We have a setup to an 8-move commutator and then undo the setup. So, we then have:

SABA'B'S'

But, you're probably thinking, that would mean that it's 10 moves (1 for S, 1 for S', and then the 8 for the standard commutator). Isn't an A9 nine moves?

In fact, it is nine moves, because either S and A or B' and S' will cancel out one move (For example, R' and R2 become R). So, in an A9, you do this.

1. Find the possible setups

2. Find the one that cancels

3. Execute

So, let's take a really simple example, the A-Permutation that most speedcubers know:

R2 B2 R F R' B2 R F R

The A-Permutation is actually, believe it or not, an A9 commutator. Let's break this apart.

First, given an A-Permutation, there are several possible setups. L2 works, so does R2. Let's just take those. With L2, UFR and DFL are interchangeable with F2. Insertion would be R B R'. The commutator would then be.

L2 F2 R B R' F2 R B' R' L2

Although this works, it is NOT optimal, at 10 moves. Now look at if we do R2.

If we do R2, then UBL and DBR are interchangeable with B2. We can do an insertion with R F R' (inserting DRF to DBR).

So we now have.

R2 B2 R F R' B2 R F' R' R2

Now, look at what I mean about the cancellation. The last two moves, R' and R2, cancel out to become R.

So the entire commutator, at 9 moves is:

R2 B2 R F R' B2 R F' R

Congratulations. You've just derived the A-Permutation.

Now for a look at a different A9.

(URB FRU DRF)

URB and DRF are interchangeable, but there is no easy way to insert FRU. So, we're going to have to look for a setup. If we use the setup L, we'd have:

L F L F' R2 F L' F' R2 L'

This works, but once again, it's not optimal. We need to find a canceling setup.

After a little more looking, we see that U2 does the trick.

S = U2

Because then, we use a BAB'A' commutator, B being F2.

S = U2

B = F2

Then, we can use U B U' to insert.

S = U2

B = F2

A = U B U'

Now, the commutator is

U2 F2 U B U' F2 U B' U' U2

Of course, the last two moves cancel.

U2 F2 U B U' F2 U B' U

Now you have an A9.

Now, these examples both have cancellations at the end. I'm going to show you an example now with the cancellation in the beginning.

(URB BLU FRU)

So, the setup move in this case would be L2.

The insertion in this case is L B2 L'.

The interchanging move is F2.

So the algorithm we have is:

L2 L B2 L' F2 L B2 L' F2 L2

However, the first two moves cancel, and become:

L' B2 L' F2 L B2 L' F2 L2

A9s can be difficult to find cancellations for, but with practice, you'll find them faster.

EXERCISE A. Solve (URB FLD BDL)

EXERCISE B. Solve (URB DBR LUB)

EXERCISE C. Solve (URB RFD FRU)

So, now I have to introduce a little more terminology. The term I am going to use is AnI. AnI means Adjacent Non-Interchangeable. For example, RUF and URB are AnI, because the pieces are interchangeable, but not the stickers.

The next term I am going to use is an opposite. An opposite is a piece that cannot be moved to another piece in a quarter turn. For example, FRU and URB are not opposites, since a quarter turn will interchange the pieces themselves (not the stickers). However, ULF and URB are opposites. Every corner has 4 opposites.

URB, our buffer, has the following opposites: ULF, DLB, DRF, DFL. DFL

So now, on to the Orthogonal cases. To recognize an Orthogonal case, you will see URB (buffer) and two of its opposites, all of which are AnI. So, first, let's do some practice to determine an Orthogonal. In these tests, both parts must return yes in order for it to be an orthogonal.

(URB FRU UBL)

Are they opposites? - No, neither of the two pieces are opposite to URB.

Are they AnI? - No, an R' move can interchange URB and FRU.

Conclusion: Not an Orthogonal (This is a Pure)

(URB ULF DRF)

Are they opposites? - Yes, they are all opposites of URB.

Are they AnI? - No, they are in fact ALL interchangeable with one another, in other words, they are "mutually interchangeable"

Conclusion: Not an Orthogonal (This is a Per Special)

(URB FDR LFU)

Are they opposites? - Yes, all of these pieces are opposites.

Are they AnI? - Yes, all of them are not interchangeable.

Conclusion: This is an Orthogonal

(URB BLU DBR)

Are they opposites? - No, none of them are opposites of URB.

Are they AnI? - Yes, there are all AnI.

Conclusion: Not an Orthogonal (This is a Cyclic Shift)

So, now you should be able to recognize an Orthogonal. Once you can recognize one, they are VERY easy to execute. There is one setup move, then an 8-move commutator, then undo setup. Pretty much ANY QUARTER TURN will set up for an 8-move commutator from an orthogonal. The format is the same as the A9:

SABA'B'S'

Except, there is no cancellation.

For example, given the cycle (URB FDR LFU), which we tested earlier and we figured out IS an Orthogonal. Any quarter turn will give us an 8-mover. For example, let's randomly just choose U'.

We now see an interchange with F. An insertion can also be done with R' B2 R. So, we have.

U' R' B2 R F R' B2 R F' U

Which is 10 moves. Using the same cycle, let's randomly choose another quarter turn, L.

We now see an interchange with D'. A insertion can be done with F U2 F'. So, the commutator is:

L D' F U2 F' D F U2 F' L'

As you can see, any quarter turn will give you an 8 move commutator.

EXERCISE A. Find a minimum of 3 optimal solutions for (URB BDL LFU)

EXERCISE B. Find a minimum of 3 optimal solutions for (URB RFD FUL)

EXERCISE C. Find a minimum of 3 optimal solutions for (URB LBD FDR)

Cyclic Shifts are, by far, the strangest commutator, my favorite type of commutator, and the most fingertrick friendly commutator in all of BH.

Cyclic Shifts take the form of two commutators in a row. We have:

ABA' CBC'

Notice that B is the same throughout.

The first step to cyclic shifts is to recognize them. The way to recognize a Cyclic Shift is if they are all AnI and all on the same layer (if you use URB as buffer, always the U, R, or B layer).

So, for example.

(URB LBD BLU) is a cyclic shift because they are all AnI to each other, and all on the same layer (the B layer).

Now, to execute. Given a simple Cyclic Shift, (URB FUL BLU), we are going to find the "middle" piece. In this case, the middle piece is BLU, since it is between URB and FUL.

The next step is to figure out where the middle piece needs to go, which is URB.

Before we move on, I want you to try something.

Do F R' on a solved cube, and LOOK AT THE EDGES ON THE U LAYER. Memorize what colors they are, and where they are. Now, undo the moves, and do R' F, and LOOK AT THE EDGES ON THE U LAYER. They are the SAME edges. This is an important concept in a Cyclic Shift.

So, for the fist part ABA'.

We're going to bring URB to FRU, so that we can do a U2 to swap it with BLU. However, in order to preserve the edges, we have to do a F first (keep reading to figure out why). So we have F R' for the A. U2 for the B, and the R F' for the A'.

So we have:

F R' U2 R F'

as the first part of the cyclic shift. Now, for the second part, we need to do a U2 on the FUL which needs to go to FRU. So we do an F. But again, to preserve edges, we have to do an R' first. So the second part is.

R' F U2 F' R

If you apply both together, you will see that the corners swap and the edges are preserved.

F R' U2 R F' R' F U2 F' R

These can be fairly difficult to understand at first, but they will eventually become easier.

EXERCISE A. Execute (URB BDL DBR) optimally

EXERCISE B. Execute (URB BLU LBD) optimally

EXERCISE C. Execute (URB BLU FUL) optimally

With Column cases (there are 12 of them), you have a freedom of choice between two options.

1. You do a 1 move setup, and then an A9, then undo the setup. (1+9+1 = 11)

2. You do a 1 move setup, and then a Cyclic Shift, then undo the setup, with a cancellation (1+10+1-1 = 11)

I prefer the cyclic shift, because it's faster for me, since finding a cancellation in an A9 is harder than finding a cancellation in a Column.

I will give one example

(URB LDF RUF)

So, let's do it with the 1 move then A9. U2 B2 allows a D2 interchange, so U2 will be the first part of the Column, the setup to the A9.

So U2 B2 D2, then the insertion is B U2 B'.

Now we have U2 B2 D2 B U2 B' D2 B U2 B' B2 U2.

Which then cancels to:

U2 B2 D2 B U2 B' D2 B U2 B U2

However, the same case can be done with a cyclic shift.

(URB LDF RUF)

L' sets up for a cyclic shift on the U-layer, so we'll go with that. The first part of the cyclic shift is L' B, so we have:

L' L' B U2 B' L B L' U2 L B' L

which cancels to:

L2 B U2 B' L B L' U2 L B' L

Note how both of these algorithms solve the SAME case optimally.

EXERCISE A. Solve (URB LDF RUF) using both an A9 and a Cyclic Shift

EXERCISE B. Solve (URB DFL ULF) using both an A9 and a Cyclic Shift

EXERCISE C. Solve (URB DFL DBR) using both an A9 and a Cyclic Shift

Per Specials work like this.

As for recognition, all corners are mutually interchangeable, meaning any one corner is interchangeable with the other two.

Per Specials follow this format:

ABA'B'

A is 5 moves, which brings a corner (1) to another corner's spot (2) without messing up the rest of Corner 2's layer. Then, do a move to switch the other corner (3) and corner 2. Then undo A and B.

This can normally be done by hiding a 3x1x1 block for all but the corner you want to replace (corner 2), doing a move to bring it over to where corner 1 can be inserted, and then applying a move to replace that, followed by restoring the 3x1x1. You probably didn't understand that, so I'll give an example.

In (URB ULF DBL), we want to bring DBL to URB. To do this, we do R' U2 first, to bring URB to BLU, a quartern turn interchange from DBL (the interchange is L). Then do L, followed by a U2 to bring it back to the right side of the cube. Finally, we do an R turn to restore the rest of the U layer. So, the A part of the commutator is:

R' U2 L U2 R

Then, B becomes U2, since it swaps URB with ULF. The final commutator looks like this:

R' U2 L U2 R U2 R' U2 L' U2 R U2

EXAMPLE A. Execute (URB ULF DRF)

EXAMPLE B. Execute (URB DRF ULF)

EXAMPLE C. Execute (URB DRF DLB)

-------------------------------

Just a question, how would you rate my written tutorials (all of them in general, not just this one) on a scale from 1-10. I'm considering doing something (not telling yet) but I need your opinions first.

BH Tutorial

by Brian Yu

Version 1.5

Consists of both written tutorial and video

**SECTION 1. CORNERS****PART 1 - INTRODUCTION**This tutorial is meant to allow you to solve corners without memorizing 378 algorithms, one for each case. It will allow you to solve all of the cases, not only correctly, but also optimally.

In BH, algorithms take the form of a commutator. A commutator takes the form

ABA'B'

For example, if we had R U R' as A, and D as B, the commutator would be.

R U R' D R U' R' D'

Which is 8 moves. 8 moves is the standard 'pure' commutator length. There are many different kinds of commutators in BH. The ones that are needed for BH corners are:

Pure (8 moves)

A9 (9 moves)

Orthogonal (10 moves)

Cyclic Shift (10 moves)

Columns (11 moves)

Per Special (12 moves)

In this tutorial, I will go through each one of these commutators, and how to solve it. I HIGHLY recommend that you go through in order of this tutorial, and not skip around, because I will be introducing terminology as I go along.

PART 2 - PURE COMMUTATORS

The Pure Commutator is 8 moves, as you probably saw from the first section. I am going to use URB as buffer for this tutorial, but many other people also use UBL, and really you could potentially use any buffer.

The first term I am going to teach you is the term 'interchangeable'. If two stickers are interchangeable, that means that in one turn (R, D2, L', etc.) one can be moved to another. For example, UFR and URB are interchangeable with a U' move. However... FRU and URB are NOT interchangeable, because U' doesn't interchange them (FRU goes to RBU instead of URB).

So, in a Pure commutator, the first thing we are going to look for is two pieces that are interchangeable. Not only that, but those two pieces NEED TO BE on a different layer as the third one. For example, given this cycle:

(URB FRU LFU)

We see that LFU and FRU are interchangeable with U', and URB and FRU are interchangeable with R'. Which one is correct? Well, LFU and FRU are on the same layer as URB (U). However, URB and FRU are on different layers than LFU (R and L). So URB and FRU, with the interchange move R', is the correct interchange.

So, the interchange move will be the B of our commutator (ABA'B'). Using the same cycle as above, (URB FRU LFU), we are going to find out the A.

A needs to do the following: Insert the non-interchaging piece into one of the interchanging pieces without messing up the rest of the interchanging layer. Using (URB FRU LFU), we see that LFU can be inserted into FRU using F' L' F. Remember, that LFU must go to the FRU, exactly. It cannot go to RUF or UFR, otherwise the commutator has been messed up. You can see that with F' L' F, the LFU corner goes to FRU without the interchanging layer being messed up other than at FRU.

Now, we have the two parts, F' L' F and R'. But, we need to go back to the commutator.

(URB FRU LFU)

We look at the non-interchanging piece, LFU. Where does it need to go. It seems as if it just ends there, but it actually is a "cycle" so it loops back. LFU needs to go to URB. So, by doing F' L' F, we are actually inserting LFU into FRU, when it needs to go to URB.

So, we are actually doing an inverse pure commutator, instead of ABA'B', we are doing BAB'A'.

So, the first thing to do is to bring URB to FRU, so that we can insert it.

B = R'

Next, we have to insert the LFU to FRU, which right now holds the URB piece.

B = R'

A = F' L' F

Then, of course, we reverse the moves with B'A'.

B = R'

A = F' L' F

B' = R

A' = F' L F

So, the entire commutator that does the cycle (URB FRU LFU) is...

R' F' L' F R F' L F

Now, if the cycle had been done the other way around, as in, (URB LFU FRU), then we look at LFU, the non-interchanging one and say "where does this belong". It belongs to FRU. So this means we do F' L' F immediately.

So (URB LFU FRU) would be

F' L' F R' F' L F R

Which is the inverse of the first one I showed you. Commutators work just like that. I'll give you another example.

(URB LFU LUB)

The first thing that you should note, although it doesn't matter when you are really solving it, is that this case has more than one optimal solution.

There are two possible interchanges, URB and LUB, or LFU and LUB. I'm going to use URB and LUB, but the other one works too. So, for URB and LUB, the interchange move is B.

The A needs to send LFU to LUB without messing up the rest of the B layer. To do this, we do U' F' U.

Finally, we need to figure out whether we do ABA'B' or BAB'A'.

To do this, we look at the non-interchanging piece (LFU). It needs to go to LUB, which is what A does. So we do ABA'B'. If LFU had to go to URB, we need to do the B move first, therefore making a BAB'A'.

So the commutator is:

U' F' U B U' F U B'

Shortened down, here are the steps that you need to follow for a pure commutator:

1. Determine the interchanging pieces and the interchanging move (B).

2. Determine the A section, which inserts the non-interchanging piece.

3. Determine whether it is ABA'B' or BAB'A'

4. Execute

Follow these exercises to practice.

EXERCISE A. Earlier in this section, we worked on the commutator (URB LFU LUB) with the interchange move of B. Do this commutator again, but use L as the interchange.

EXERCISE B. Execute the commutator (URB FRU FUL)

EXERCISE C. Execute the commutator (URB FLD RFD)

**PART 3 - A9s**The A9 is just an extension to a pure commutator. These, in my opinion, are fairly difficult to get optimal, since it really requires a lot of thinking.

An A9 can be used when you have two interchangeable pieces, but either there's a piece already in that layer, or there is no 3-move insertion (A) part.

The way it works is this. We have a setup to an 8-move commutator and then undo the setup. So, we then have:

SABA'B'S'

But, you're probably thinking, that would mean that it's 10 moves (1 for S, 1 for S', and then the 8 for the standard commutator). Isn't an A9 nine moves?

In fact, it is nine moves, because either S and A or B' and S' will cancel out one move (For example, R' and R2 become R). So, in an A9, you do this.

1. Find the possible setups

2. Find the one that cancels

3. Execute

So, let's take a really simple example, the A-Permutation that most speedcubers know:

R2 B2 R F R' B2 R F R

The A-Permutation is actually, believe it or not, an A9 commutator. Let's break this apart.

First, given an A-Permutation, there are several possible setups. L2 works, so does R2. Let's just take those. With L2, UFR and DFL are interchangeable with F2. Insertion would be R B R'. The commutator would then be.

L2 F2 R B R' F2 R B' R' L2

Although this works, it is NOT optimal, at 10 moves. Now look at if we do R2.

If we do R2, then UBL and DBR are interchangeable with B2. We can do an insertion with R F R' (inserting DRF to DBR).

So we now have.

R2 B2 R F R' B2 R F' R' R2

Now, look at what I mean about the cancellation. The last two moves, R' and R2, cancel out to become R.

So the entire commutator, at 9 moves is:

R2 B2 R F R' B2 R F' R

Congratulations. You've just derived the A-Permutation.

Now for a look at a different A9.

(URB FRU DRF)

URB and DRF are interchangeable, but there is no easy way to insert FRU. So, we're going to have to look for a setup. If we use the setup L, we'd have:

L F L F' R2 F L' F' R2 L'

This works, but once again, it's not optimal. We need to find a canceling setup.

After a little more looking, we see that U2 does the trick.

S = U2

Because then, we use a BAB'A' commutator, B being F2.

S = U2

B = F2

Then, we can use U B U' to insert.

S = U2

B = F2

A = U B U'

Now, the commutator is

U2 F2 U B U' F2 U B' U' U2

Of course, the last two moves cancel.

U2 F2 U B U' F2 U B' U

Now you have an A9.

Now, these examples both have cancellations at the end. I'm going to show you an example now with the cancellation in the beginning.

(URB BLU FRU)

So, the setup move in this case would be L2.

The insertion in this case is L B2 L'.

The interchanging move is F2.

So the algorithm we have is:

L2 L B2 L' F2 L B2 L' F2 L2

However, the first two moves cancel, and become:

L' B2 L' F2 L B2 L' F2 L2

A9s can be difficult to find cancellations for, but with practice, you'll find them faster.

EXERCISE A. Solve (URB FLD BDL)

EXERCISE B. Solve (URB DBR LUB)

EXERCISE C. Solve (URB RFD FRU)

**PART 4 - ORTHOGONALS**So, now I have to introduce a little more terminology. The term I am going to use is AnI. AnI means Adjacent Non-Interchangeable. For example, RUF and URB are AnI, because the pieces are interchangeable, but not the stickers.

The next term I am going to use is an opposite. An opposite is a piece that cannot be moved to another piece in a quarter turn. For example, FRU and URB are not opposites, since a quarter turn will interchange the pieces themselves (not the stickers). However, ULF and URB are opposites. Every corner has 4 opposites.

URB, our buffer, has the following opposites: ULF, DLB, DRF, DFL. DFL

So now, on to the Orthogonal cases. To recognize an Orthogonal case, you will see URB (buffer) and two of its opposites, all of which are AnI. So, first, let's do some practice to determine an Orthogonal. In these tests, both parts must return yes in order for it to be an orthogonal.

(URB FRU UBL)

Are they opposites? - No, neither of the two pieces are opposite to URB.

Are they AnI? - No, an R' move can interchange URB and FRU.

Conclusion: Not an Orthogonal (This is a Pure)

(URB ULF DRF)

Are they opposites? - Yes, they are all opposites of URB.

Are they AnI? - No, they are in fact ALL interchangeable with one another, in other words, they are "mutually interchangeable"

Conclusion: Not an Orthogonal (This is a Per Special)

(URB FDR LFU)

Are they opposites? - Yes, all of these pieces are opposites.

Are they AnI? - Yes, all of them are not interchangeable.

Conclusion: This is an Orthogonal

(URB BLU DBR)

Are they opposites? - No, none of them are opposites of URB.

Are they AnI? - Yes, there are all AnI.

Conclusion: Not an Orthogonal (This is a Cyclic Shift)

So, now you should be able to recognize an Orthogonal. Once you can recognize one, they are VERY easy to execute. There is one setup move, then an 8-move commutator, then undo setup. Pretty much ANY QUARTER TURN will set up for an 8-move commutator from an orthogonal. The format is the same as the A9:

SABA'B'S'

Except, there is no cancellation.

For example, given the cycle (URB FDR LFU), which we tested earlier and we figured out IS an Orthogonal. Any quarter turn will give us an 8-mover. For example, let's randomly just choose U'.

We now see an interchange with F. An insertion can also be done with R' B2 R. So, we have.

U' R' B2 R F R' B2 R F' U

Which is 10 moves. Using the same cycle, let's randomly choose another quarter turn, L.

We now see an interchange with D'. A insertion can be done with F U2 F'. So, the commutator is:

L D' F U2 F' D F U2 F' L'

As you can see, any quarter turn will give you an 8 move commutator.

EXERCISE A. Find a minimum of 3 optimal solutions for (URB BDL LFU)

EXERCISE B. Find a minimum of 3 optimal solutions for (URB RFD FUL)

EXERCISE C. Find a minimum of 3 optimal solutions for (URB LBD FDR)

**PART 5 - CYCLIC SHIFTS**Cyclic Shifts are, by far, the strangest commutator, my favorite type of commutator, and the most fingertrick friendly commutator in all of BH.

Cyclic Shifts take the form of two commutators in a row. We have:

ABA' CBC'

Notice that B is the same throughout.

The first step to cyclic shifts is to recognize them. The way to recognize a Cyclic Shift is if they are all AnI and all on the same layer (if you use URB as buffer, always the U, R, or B layer).

So, for example.

(URB LBD BLU) is a cyclic shift because they are all AnI to each other, and all on the same layer (the B layer).

Now, to execute. Given a simple Cyclic Shift, (URB FUL BLU), we are going to find the "middle" piece. In this case, the middle piece is BLU, since it is between URB and FUL.

The next step is to figure out where the middle piece needs to go, which is URB.

Before we move on, I want you to try something.

Do F R' on a solved cube, and LOOK AT THE EDGES ON THE U LAYER. Memorize what colors they are, and where they are. Now, undo the moves, and do R' F, and LOOK AT THE EDGES ON THE U LAYER. They are the SAME edges. This is an important concept in a Cyclic Shift.

So, for the fist part ABA'.

We're going to bring URB to FRU, so that we can do a U2 to swap it with BLU. However, in order to preserve the edges, we have to do a F first (keep reading to figure out why). So we have F R' for the A. U2 for the B, and the R F' for the A'.

So we have:

F R' U2 R F'

as the first part of the cyclic shift. Now, for the second part, we need to do a U2 on the FUL which needs to go to FRU. So we do an F. But again, to preserve edges, we have to do an R' first. So the second part is.

R' F U2 F' R

If you apply both together, you will see that the corners swap and the edges are preserved.

F R' U2 R F' R' F U2 F' R

These can be fairly difficult to understand at first, but they will eventually become easier.

EXERCISE A. Execute (URB BDL DBR) optimally

EXERCISE B. Execute (URB BLU LBD) optimally

EXERCISE C. Execute (URB BLU FUL) optimally

**PART 6 - COLUMNS**With Column cases (there are 12 of them), you have a freedom of choice between two options.

1. You do a 1 move setup, and then an A9, then undo the setup. (1+9+1 = 11)

2. You do a 1 move setup, and then a Cyclic Shift, then undo the setup, with a cancellation (1+10+1-1 = 11)

I prefer the cyclic shift, because it's faster for me, since finding a cancellation in an A9 is harder than finding a cancellation in a Column.

I will give one example

(URB LDF RUF)

So, let's do it with the 1 move then A9. U2 B2 allows a D2 interchange, so U2 will be the first part of the Column, the setup to the A9.

So U2 B2 D2, then the insertion is B U2 B'.

Now we have U2 B2 D2 B U2 B' D2 B U2 B' B2 U2.

Which then cancels to:

U2 B2 D2 B U2 B' D2 B U2 B U2

However, the same case can be done with a cyclic shift.

(URB LDF RUF)

L' sets up for a cyclic shift on the U-layer, so we'll go with that. The first part of the cyclic shift is L' B, so we have:

L' L' B U2 B' L B L' U2 L B' L

which cancels to:

L2 B U2 B' L B L' U2 L B' L

Note how both of these algorithms solve the SAME case optimally.

EXERCISE A. Solve (URB LDF RUF) using both an A9 and a Cyclic Shift

EXERCISE B. Solve (URB DFL ULF) using both an A9 and a Cyclic Shift

EXERCISE C. Solve (URB DFL DBR) using both an A9 and a Cyclic Shift

**PART 7: PER SPECIALS**Per Specials work like this.

As for recognition, all corners are mutually interchangeable, meaning any one corner is interchangeable with the other two.

Per Specials follow this format:

ABA'B'

A is 5 moves, which brings a corner (1) to another corner's spot (2) without messing up the rest of Corner 2's layer. Then, do a move to switch the other corner (3) and corner 2. Then undo A and B.

This can normally be done by hiding a 3x1x1 block for all but the corner you want to replace (corner 2), doing a move to bring it over to where corner 1 can be inserted, and then applying a move to replace that, followed by restoring the 3x1x1. You probably didn't understand that, so I'll give an example.

In (URB ULF DBL), we want to bring DBL to URB. To do this, we do R' U2 first, to bring URB to BLU, a quartern turn interchange from DBL (the interchange is L). Then do L, followed by a U2 to bring it back to the right side of the cube. Finally, we do an R turn to restore the rest of the U layer. So, the A part of the commutator is:

R' U2 L U2 R

Then, B becomes U2, since it swaps URB with ULF. The final commutator looks like this:

R' U2 L U2 R U2 R' U2 L' U2 R U2

EXAMPLE A. Execute (URB ULF DRF)

EXAMPLE B. Execute (URB DRF ULF)

EXAMPLE C. Execute (URB DRF DLB)

-------------------------------

Just a question, how would you rate my written tutorials (all of them in general, not just this one) on a scale from 1-10. I'm considering doing something (not telling yet) but I need your opinions first.

Last edited by a moderator: Apr 7, 2016