# BH Resource Center



## byu (May 8, 2009)

I think this might be useful for the several people who are interested in starting the BH method (including myself)

I compiled up as much information as I could find at the moment and put it all together in one place. These pages are very good references that I used:

Speedcubing BH Corners - http://speedcubing.com/chris/bhcorners.html
BH Method Thread - http://www.speedsolving.com/forum/showthread.php?t=11909
BH Method Thread - http://www.speedsolving.com/forum/showthread.php?t=10756
BH Corners Text - http://dbeyer.110mb.com/BHcorners.txt
Viewpoint Shifting - http://www.speedsolving.com/forum/showpost.php?p=117456&postcount=45
Speedcubing BH Edges - http://speedcubing.com/chris/bhedges.html

For a person who is just beginning the BH method, you'll want to figure out how each of the following types of cases actually work.

I've explained them in my own words here, dbeyer has also explained them.

There are 378 algorithms in the BH method for corners, but you shouldn't learn them all. They should be intuitive. Here's the types of cases you can encounter (for BH corners):

*GENERAL BH INFORMATION*
*TERMINOLOGY*
Cubie -- A piece, as a whole, with no specific permutation or orientation there of. Just to make a reference to a location on the cube. Standard U/D first.
URB or DRF for example.

Interchangability -- There are different ranges and degrees of interchangability. Looking at the cubie locations as a whole. A piece is interchangable with every other piece in one turn (htm), except it's polar opposite.
Interchangability on the Layer: This is the broadest form of interchangability. Looking at the cubies as a whole. 
The six cubies interchangeable with the URB;
ULF, DRF, DLB, UFR, UBL, DBR 
NOT the DFL

Interchangable on the Plane-orbit: 
The U plane is the URB, UFR, ULF, UBL.
The F plane is the FRU, FUL, FLD, FDR

Interchangable on the Slice-orbit:
The URB's R-slice-orbit;
URB, BRD, DRF, FRU.
The FUL's U slice-orbit;
FUL, LUB, BUR, RUF

Adjacent Cubies -- To be next interchanged by 1 quarter turn 
URB and FLU for example.
FDR and RDB
Opposite Cubies -- To be interchanged by 1 half turn.
URB and DLB for example.
FRU and FLD
Polar Opposites -- The two cubies with are not interchangable in anyway shape or form with just 1 turn (HTM);
URB and DFL for example.

Oppsosites have interesting characteristics. 
Either the pieces are interchangable on the plane or slice. 
URB and ULF for example on the U plane.
URB and DRF for example on the R slice.

Or the opposites are not interchangable. That means they are twisted opposites.
URB and LFU for example.
URB and FUL perhaps.

Lets move the LFU one quarter turn.
There are 6 quarter turns possible, L, L', F, F', U, U'
U and U' have no effect on the cube state really, both cubies are being moved. Because both are in the U layer.
The other 4 quarter turns possible bring the LFU to another location in the U layer, or to the location of the URB's polar opposite.
Both turns that keep the LFU in the U layer (the URB and the LFU's common layer) make the URB and the LFU interchangable on either the U plane or R slice.
This of course also applied to the URB. You can make 6 moves, U, U', R, R', B, or B'
2 which have no effect,
2 bring the URB into the LFU's plane-orbit or slice-orbit.
2 bring the URB into the LFU's polar opposite.

So determine if two pieces are interchangable opposites, or twisted opposites. 
Here is a nice characteristic for setting up commutators. 
Interchangable opposites, are good to have, because well you've found your part B to the commutator in an 8 move case.
Twisted opposites are good, because you if you have twisted oppsites, and the third piece is interchangeable (adjacent or opposite) with one of the first two, you've found your insertion.
URB and ULF are in a cycle. You could interchange the two with U2.
URB and LFU are in a cycle. You could insert with FR'F' or R'FR

Thanks to dbeyer for submitting the terminology.

*KINDS OF BH CORNER COMMUTATORS*
*Pure* 8 moves
This is just a standard 8-move commutator. In the form ABA'B', A is three moves, and B is one move. It is always ABA'B' or BAB'A' to solve the cube from a pure position.

Example of Pure Commutator:

Do F R B R' F' R B' R' on a solved cube

The case you are looking at right now is UBR->UFR->LFU

This is a standard 8-move commutator. In the format ABA'B' this is what each should do in an 8 move commutator.

A = Put one corner in place (3 moves)
B = Interchange another corner for the corner solved in A to the position that corner A was in (1 move)
A' = Solve the corner brought over by move B (3 moves)
B' = Undo the interchanging move (1 move)

In this case, we want A to put one corner in place. To do this, we do R B R', which solves UFR. So we have

A = R B R'

Next comes B, which moves a new corner (in this case, UFL) into the position where UFR is right now. To do this, we do F. SO we have.

A = R B R'
B = F

After that we have A', which is the inverse of A, which will solve what was UFL before. Now we have:

A = R B R'
B = F
A' = R B' R'

Lastly, and if you're following along this should be extremely obvious, we need to undo B with B', which is just undoing the interchanging move, so F'. We now have.

A = R B R'
B = F
A' = R B' R'
B' = F'

The entire commutator written out is

R B R' F R B' R' F'

That is exactly what you will see if you go to the BH website on speedcubing.com, the case looks like this:

(URB UFR LFU) R B R' F R B' R' F' (8 HTM) Direct Insert

A direct insert is a kind of pure 8-move commutator. This is how you would intuitively find an 8-move commutator without memorizing the algorithm.

*A9* 9 moves
A9's are very similar to Pure commutators, except they have a 1-move setup and undo-setup. The thing that makes this so special is that the 1 move cancels out with the first part of A. In the for SABA'B'S', S and A have a cancellation.

Here is an example of an A9 commutator.

Do B2 D B' U2 B D' B' U2 B' on a solved cube.

The commutator we are looking at is URB->UBL->RUF, which is an A9 commutator. What we are going to look for is 1 move that does two things.

1) Sets up an 8-move commutator.
2) Cancels into the A of the 8-move commutator.

So, in this case, if we do the move B2, it sets up for a pretty simple 8-move commutator. And the A part of the commutator, as we can see, is B' U2 B, which will cancel into the B2. So, if we use the format:

SABA'B'S'

We now have

S = B2
A = B' U2 B

Now we need to find the B. B is pretty simple, it's D, to bring in the next corner. So now we have.

S = B2
A = B' U2 B
B = D

Now, we simply do the inverse of A to put the next corner in place.

S = B2
A = B' U2 B
B = D
A' = B' U2 B

Next, we reverse B.

S = B2
A = B' U2 B
B = D
A' = B' U2 B
B' = D'

And finally we undo the 1 move setup S that we did to start the A9 commutator. This won't cancel like the first time we applied the commutator. So now we have this:

S = B2
A = B' U2 B
B = D
A' = B' U2 B
B' = D'
S' = B2

The entire commutator, without cancellations looks like this:

B2 B' U2 B D B' U2 B D' B2

But of course, B2 B' simplifies to just B, so now we can write it like this:

B U2 B D B' U2 B D' B2

And this is exactly what you will find in the BH corner website on speedcubing.com. The case looks like this:

(URB UBL RUF) B U2 B D B' U2 B D' B2 (9 HTM) A9

*Columns* 11 moves
dbeyer explains column commutators as person preference from cyclic shifts or A9's. I am still researching how cyclic shifts work, but as for columns, I know that if you do one setup move, you'll get an A9 with no cancellations except for the one within the A9, therefore giving you 11 moves.

Here is an example of a Column commutator.

Do R U L2 U R' U' L2 U R U2 R' on a solved cube.

The case you are looking at right now is URB->ULF->DFL.

So, the basics of what we are looking at is a new setup move to setup to an A9 case. This setup move should be 1 move, and we'll call it M. The pattern we are looking at for a Column case is:

MSABA'B'S'M'

The setup move that we're going to use is R, which will set us up for a 9 move commutator. So we have:

M = R

Now, we're going to look for the S, which was part of the A9 case (see above). The mve that we're going to use for this is U. So now we have.

M = R
S = U

The next step is to find the normal 8-move commutator from this position. The A that we're going to use will be U R' U' so now we have.

M = R
S = U
A = U R' U'

Next, we're going to do B, which will bring in a new corner piece into position. This move is L2. So now we have.

M = R
S = U
A = U R' U'
B = L2

Next, of course, we are going to undo all of the moves we did in the order of the pattern shown above (MSABA'B'S'M')

So now we have.

M = R
S = U
A = U R' U'
B = L2
A' = U R U'
B = L2
S = U'
M = R'

The commutator without cancellations looks like this:

R U U R' U' L2 U R U' L2 U' R'

But, the two Us in a row become U2, so the commutator looks like this:

R U2 R' U' L2 U R U' L2 U' R'

Which is exactly what the case looks like in the website:

(URB ULF DFL) R U2 R' U' L2 U R U' L2 U' R' (11 HTM) Columns

*Orthogonals* 10 moves
An orthogonal commutator is basically very similar to an A9, except for the fact that it doesn't have any cancelations like the A9 does.

*Cyclic Shifts* 10 moves
The cyclic shifts is a commutator with a 2 move setup, a 4 move A, and a 1 move B but because the setup and the end of A' can cancel each other out, they finish the commutators while doing the first 2 moves of A' at the end.

Example of a cyclic shift: Do R' F U2 F' R F R' U2 R F' on a solved cube.

The case you are looking at is URB FUL BLU. 

S= F R'
B= U2
A= R F' R' F
B'=U2
A'= F' R F R'
S'=R F' 

That's all the parts of it written out completely. Written out, the commutator looks like this:

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

But of course, the last two moves cancel each other out, so now we have this commutator:

F R' U2 R F' R' F U2 F' R (10 HTM)

Thanks to Rubixcubematt for giving this information on cyclic shifts.

*Per Specials* 12 moves
A per special works like this. This is the commutator:

A = U F2 U' F2 U'
B = R2

Let's look at the A part of the commutator. The two interchangeable corners are URB and DRF, interchangeable by an R2 turn. The lone corner is ULF. We are going to insert ULF into DRF without having any other net affect on the R slice. We will do this in the following way:

View the URB, UR, and UFR block as one block that will not be destroyed at any point of our solving. View the DBR, RB, DR block as a 2x2x1 block that will also never be destroyed, nor moved, during the A part of the commutator. This leaves the FR and DRF block. This block will be destroyed during the A part.

The first part of the A of the commutator is U F2. This brings the 3x1x1 block starting at UR down to DF. It also throws the FR 2x1x1 block up to the FL and ULF. Lastly, it moves the lone corner over to UBL. The next move is U'. This brings the lone corner from UBL over to ULF "decapitating" the FL and UFL block's corner and replacing it with the lone corner. Lastly, we will put the 3x1x1 block which is now in DF back to UR with F2 U'. Notice this has replaced the R layer back together, and has placed the lone corner at DFR. This replacement happened with the "decapitating" U' turn. Now interchange with the B part of the commutator by doing R2. Next we will indo the A part. Bring the UR 3x1x1 block to DF with U F2. This moves the 2x1x1 block that was at FR and DRF to FL and ULF. Now decapitate this block in the other direction with the turn U. Now place the 3x1x1 block, in DF now, back to UR with F2 U'. Lastly, do the second interchange move, R2, to complete the commutator.

Thanks to Chris Hardwick for giving information on Per Specials.

*VISUALIZING COMMUTATORS*
(URB RFD ULF) is very easy and is solved with : L D' L' U2 L D L' U2

My thought process would go like this:
Image in my mental journey for this cycle would be KC or K.C. the intials of a good friend of mine from high school who was an excellent drummer. Seeing him playing drums tells me KC is my cycle.

I can immediately see that ULF is interchangeable with the buffer via a U2, so I mentally label RFD as the "lone corner". I see that I can insert the lone corner into the U layer with L D' L' and not affect anything else in the U layer. Remember that I call the ULF spot the "action spot" (see my tutorial). This is the spot in the interchangeable layer in which I insert the lone piece. Now I see if the lone corner, RFD, really is supposed to go to the action spot ULF, and it does. Ok, so I do the insertion or A part of the commutator and I execute L D' L'. In my mind I picture the 3 corners as dark gray blobs on a light gray cube. I don't care at all about the colors, I only want to see the locations. Now that I have done the insertion move, the A part of the commutator, I do the interchange move. I actually execute U2 to interchange the buffer at URB to ULF.

This last part is very important. I now clear my mind of mentally visualizing *anything* at all. I'll describe what I am actually doing at this step in a minute, but bear with me for one second.

Literally, do not picture anything in your mind. Just know that you have just done the A part of the commutator followed by the B part. Now just blindly and without visualizing it undo the A part with the A' or inverse of the insertion. After that blindly, and without visualizing anything, undo the interchange move with U2.

For every single commutator I execute I am only mentally visualizing the first half of the commutator (either the A then the B, or the B then the A depending on if the commutator is ABA'B' or BAB'A').

Now I mentioned I would tell you what I am actually doing in just a second. What I am actually doing after the first half of the commutator is going back to my mental journey and recalling my next image. If I have a memory delay, then this is advantageous because it gives me a couple seconds head start to recall the piece (remember that I am physically executing the inverse of the two commutator parts at this very second). This works to shorten my delays if I have memory lapses, and also to make for smooth no pause solving when I don't have memory lapses.

Thanks to Chris Hardwick for submitting this information.

*USING POLES TO DETERMINE COMMUTATORS*
Look check this out:
There are 30 cases that are 10 moves.
There are two case types:
18 cyclic shifts
12 orthogonals.

Orthogonal vectors are at a right angle to the plane. You have 3 stickers on a plane.
Here is your perspective of determining if a case is orthogonal. That is to create a right angle. Pretty much your x,y,z axes of a 3-d graph.

Place the cube in one of the "rubik's cube stands" like that comes with a Rubik's Cube fresh out of the box. Pretty, much the tip of one corner is on the table, and the other is pointed upright. These simulate the north and south poles.

Anway, from a bird's eye view overhead, you see 3 faces. Call each of these planes. There are three adjacent corners to the north pole.
Okay, for example: Let the north pole be the UFR.
Now the 3 adjacent cubies are the ULF, URB, and DRF, cubies being cycled. Only 2 combinations of sticker patterns are possible to create a Orthogonal case. The direction of the cycle doesn't matter. It could be URB -> ULF -> DRF or it could be URB -> DRF -> ULF. (These are not orthogonal cases, just cubie cycles).

Since the URB is my buffer. I start with the U sticker of the URB. Now I know the 3 cubies that must be cycled. Now a sticker from each plane must be chosen. One from the U, the F, and the R planes (or their parallel planes).
So one sticker from the U has been chosen, the buffer is in the U plane, URB.
Now, if I was to cycle to the RFD, I must pick the FUL. If I did the FDR, I must choose the LFU.


If the URB is the Buffer:
URB -> (L)FU -> (F)DR; URB -> FDR -> LFU
URB -> (F)UL -> (R)FD; URB -> RFD -> FUL
URB -> (L)FU -> (B)DL; URB -> BDL -> LFU
URB -> (F)UL -> (L)BD; URB -> LBD -> FUL
URB -> (F)DR -> (L)BD; URB -> LBD -> FDR
URB -> (R)FD -> (B)DL; URB -> BDL -> RFD

So if they are all on different planes: Well then you have an orthogonal case!
Its awesome. A simple quarter turn setup, will give you interchangability. Then you can do an 8 move commutator. It's very veratile for the setups. Remember, its always just a quarter move. And afterwards its always just an 8 mover.

Thanks to dbeyer for submitting the information

*ORBITS*
Lets look at an Orbit.

The Controls--
Two adjacent pieces
Turning the F layer
The UFR cubie

Let this piece be AnI to the Buffer.
URB and RUF for example.
Turn F, you have slice-orbit opposites,
Turn F2, you have twisted polar opposites.
Turn F', you have plane-orbit opposites
Turn F4, you have Adjacent non-Interchangable (AnI)

Let this piece be interchangeable on the slice-orbit
URB and FRU
Turn F, you have twisted opposites
Turn F2, you have twisted polar opposites
Turn F', you have twisted opposites
Turn F4, you have Adjacent Slice-Orbit (AsO)

Two adjacent pieces
Let this piece be interchangable on the plane-oribit
URB and UFR
turn F, you have twisted opposites
turn F2, you have parallel polar opposites
turn F', you have twisted opposites.
turn F4, you have Adjacent Plane-orbit (ApO)


The controls--
Two opposite pieces
Turning the F layer
The ULF cubie

Interchangable Opposites
URB and ULF
turn F, you have AnI
turn F2, you have interchangable opposites
turn F', you have twisted polar opposites
turn F4, you have interhchangable opposites

Twisted Opposites - On the Plane (F plane)
URB and FUL
turn F, you have AsO
turn F2, you have twisted opposites
turn F', you have twisted polar opposites
turn F4, you have twisted opposites

Twisted Opposites -- On the Slice (F slice)
URB and LFU
turn F, you have ApO
turn F2, you have twisted opposites
turn F', you have twisted polar opposites
turn F4, you have twisted opposites

Of course if you were to turn the L layer, and use the ULF cubie, you would, wind up with inverted and swapped results of FUL and LFU.
Just look at these trends. Notice the characteristics of the oribits. This will allow you to see the correct setups for orthogonal cases. This will allow you to see the correct insertion for cyclic shifts.
This will allow you to find the correct cancelations on A9s, and Columns cases.

It's a very powerful method. Its not a list of algorithms to memorize. Its a freestyle method, that gives you a vast understanding of the cube's properties. This method goes into muscle memory. And using the techniques described here, you can actually figure out any cycle, and how to solve it by recognizing relationships.

You first recognize two pieces and their locational relationship to one another. What really sets it apart though is the 3rd piece. Just like you could recognize a lot of relationships between corner and edge pairs, but you need to reference the c/e pair to where the solved pair belongs.

Thanks to dbeyer for submitting this information

I'm hoping to expand this resource center with all the information necessary for learning the BH method, since there's a lot of interest in it now. I'm still working on learning it, and I'm going to use this resource center as a reference. Chris, Mike, Daniel, and everyone else who knows a lot about BH, post information below that I haven't already covered in the BH Resource center and I'll add it to this original post. That way people won't have to go digging through lots of threads to find the information they're looking for (like what I'm doing now).


----------



## Rubixcubematt (May 8, 2009)

I think that the cyclic shifts is a commutator with a 2 move setup, a 4 move A, but because the setup and the end of A' can cancel each other out, they finish the commutators while doing the first 2 moves of A' at the end. E.G. do R' F U2 F' R F R' U2 R F' so this is URB FUL BLU. 
so S= F R' B= U2 A= R F' R' F B'=U2 A'= F' R F R' S'=R F' 
But since the last 2 moves of A and the S' can cancel each other out, the commutator becomes F R' U2 R F' R' F U2 F' R (10 HTM)

Hope this helps.


----------



## byu (May 8, 2009)

Sounds about rght, I'll check it with other cyclic shifts to make sure


----------



## dbeyer (May 9, 2009)

He is correct, and it is also can be looked at as taking the commutator itself, and starting at a different point in the alg. 

ABA'B'
A: RF'.R'F
B: U2

By starting at the dot (.), proceeding and wrapping around doing all 10 moves, you have actually done a legitimate algorith. Just like with a sine wave, if you shift to the right or the left, the sine wave curve is still a sine wave, just shifted. As such if you take a reference to the state of the cube at the same point in time, as if there wasn't a horizontal shift, you would get a different result (cycle, or value). The properties of the commutator are still there, yet there are different results with respect to time.


----------



## deadalnix (May 9, 2009)

An explaination of the name convention (that I don't get at all) for simple 8 moves case could help.

Anyway, I have no problem to figure out how to solves these cases, but I can't say if I'm doing a drop and catch, direct intert, toss up or whatever.


----------



## byu (May 9, 2009)

I updated the Resource Center to display the explanation of cyclic shifts, copied pretty much from Rubixcubematt's description of them. I'm still working out Per Specials.


----------



## mazei (May 9, 2009)

How do you know whether its a 8 or 9 or 10 or whatever move commutator. Sorry, I'm just bad at commutators.


----------



## byu (May 9, 2009)

Hehe... I'm just as bad as you are, if not worse. It's basically recognition. If you can see a three move A, then you know it's an 8 move. If you see a setup to a three move A, you have a 9-move (A9) or a 10-move (Orthogonal), depending on cancellations.


----------



## Rubixcubematt (May 9, 2009)

I think i found out the per special case as well, well at least for this case. 

Do L2 U B2 U' B2 U' L2 U B2 U B2 U' this makes it the URB DLB ULF case. 

A= U B2 U' B2 U' B= L2 A' = U B2 U B2 U' B'= L2

so the commutator in full is
U B2 U' B2 U' L2 U B2 U B2 U' L2

BTW, no problem with helping out with the cyclic shifts, its a good thing that your doing creating this thread.


----------



## byu (May 9, 2009)

I'm glad you appreciate it. I had trouble working through posts on BH, and this will hopefully help people who are learning BH.


----------



## cmhardw (May 9, 2009)

I'll explain the Per Specials, because I find them by far the most beautiful corner case - no question.

There are 2 main algorithms in the BH method for Per Special cases. One of them is 12 move commutator, and the other quite honestly is an alg Daniel and I found using ACube. I can't speak for Daniel, but I am still entirely baffled as to how this algorithm works.

I'll explain the commutator:

A = U F2 U' F2 U'
B = R2

Let's look at the A part of the commutator. The two interchangeable corners are URB and DRF, interchangeable by an R2 turn. The lone corner is ULF. We are going to insert ULF into DRF without having any other net effect on the R slice. We will do this in the following way:

View the URB, UR, and UFR block as one block that will not be destroyed at any point of our solving. View the DBR, RB, DR block as a 2x2x1 block that will also never be destroyed, nor moved, during the A part of the commutator. This leaves the FR and DRF block. This block will be destroyed during the A part.

The first part of the A of the commutator is U F2. This brings the 3x1x1 block starting at UR down to DF. It also throws the FR 2x1x1 block up to the FL and ULF. Lastly, it moves the lone corner over to UBL. The next move is U'. This brings the lone corner from UBL over to ULF "decapitating" the FL and UFL block's corner and replacing it with the lone corner. Lastly, we will put the 3x1x1 block which is now in DF back to UR with F2 U'. Notice this has replaced the R layer back together, and has placed the lone corner at DFR. This replacement happened with the "decapitating" U' turn. Now interchange with the B part of the commutator by doing R2. Next we will indo the A part. Bring the UR 3x1x1 block to DF with U F2. This moves the 2x1x1 block that was at FR and DRF to FL and ULF. Now decapitate this block in the other direction with the turn U. Now place the 3x1x1 block, in DF now, back to UR with F2 U'. Lastly, do the second interchange move, R2, to complete the commutator.

Hope this helps to see how the Per Special commutator alg works. My description of the "decapitating" turn is more violent than I really picture it during a solve, but I think it makes it clear what's going on in that part of the step.

Chris


----------



## byu (May 9, 2009)

Thanks Chris, I'll add that to the resource center. I still am having trouble executing commutators blindfolded. I used Ryan Heise's tutorial for how to do commutators, and that makes it REALLY hard to do them blindfolded. Chris, can you walk me through your thought process for a really easy 8-move commutator? Like, if you only know the 2 pieces you shoot to from UBR, what will you think in your head?

EDIT - Oh, and Chris, are you done with the BH edges page yet?


----------



## cmhardw (May 9, 2009)

byu said:


> Thanks Chris, I'll add that to the resource center. I still am having trouble executing commutators blindfolded. I used Ryan Heise's tutorial for how to do commutators, and that makes it REALLY hard to do them blindfolded. Chris, can you walk me through your thought process for a really easy 8-move commutator? Like, if you only know the 2 pieces you shoot to from UBR, what will you think in your head?



(URB RFD ULF) is very easy and is solved with : L D' L' U2 L D L' U2

My thought process would go like this:
Image in my mental journey for this cycle would be KC or K.C. the intials of a good friend of mine from high school who was an excellent drummer. Seeing him playing drums tells me KC is my cycle.

I can immediately see that ULF is interchangeable with the buffer via a U2, so I mentally label RFD as the "lone corner". I see that I can insert the lone corner into the U layer with L D' L' and not affect anything else in the U layer. Remember that I call the ULF spot the "action spot" (see my tutorial). This is the spot in the interchangeable layer in which I insert the lone piece. Now I see if the lone corner, RFD, really is supposed to go to the action spot ULF, and it does. Ok, so I do the insertion or A part of the commutator and I execute L D' L'. In my mind I picture the 3 corners as dark gray blobs on a light gray cube. I don't care at all about the colors, I only want to see the locations. Now that I have done the insertion move, the A part of the commutator, I do the interchange move. I actually execute U2 to interchange the buffer at URB to ULF.

This last part is very important. I now clear my mind of mentally visualizing **anything** at all. I'll describe what I am actually doing at this step in a minute, but bear with me for one second.

Literally, do not picture *anything* in your mind. Just know that you have just done the A part of the commutator followed by the B part. Now just blindly and without visualizing it undo the A part with the A' or inverse of the insertion. After that blindly, and without visualizing anything, undo the interchange move with U2.

For every single commutator I execute I am only mentally visualizing the first half of the commutator (either the A then the B, or the B then the A depending on if the commutator is ABA'B' or BAB'A').

Now I mentioned I would tell you what I am actually doing in just a second. What I am actually doing after the first half of the commutator is going back to my mental journey and recalling my next image. If I have a memory delay, then this is advantageous because it gives me a couple seconds head start to recall the piece (remember that I am physically executing the inverse of the two commutator parts at this very second). This works to shorten my delays if I have memory lapses, and also to make for smooth no pause solving when I don't have memory lapses.

Hope this helps,
Chris


----------



## byu (May 9, 2009)

Wow! I actually understand how to see 8-move commutators in my mind. Thanks Chris! Now a new problem has risen... I can't seem to figure out A9s in my mind or Orthogonals. It's hard to find a one move that sets up two interchangeable pieces.


----------



## dbeyer (May 9, 2009)

Look check this out:
There are 30 cases that are 10 moves.
There are two case types:
18 cyclic shifts
12 orthogonals.

Orthogonal vectors are at a right angle to the plane. You have 3 stickers on a plane.
Here is your perspective of determining if a case is orthogonal. That is to create a right angle. Pretty much your x,y,z axes of a 3-d graph.

Place the cube in one of the "rubik's cube stands" like that comes with a Rubik's Cube fresh out of the box. Pretty, much the tip of one corner is on the table, and the other is pointed upright. These simulate the north and south poles.

Anway, from a bird's eye view overhead, you see 3 faces. Call each of these planes. There are three adjacent corners to the north pole.
Okay, for example: Let the north pole be the UFR.
Now the 3 adjacent cubies are the ULF, URB, and DRF, cubies being cycled. Only 2 combinations of sticker patterns are possible to create a Orthogonal case. The direction of the cycle doesn't matter. It could be URB -> ULF -> DRF or it could be URB -> DRF -> ULF. (These are not orthogonal cases, just cubie cycles).

Since the URB is my buffer. I start with the U sticker of the URB. Now I know the 3 cubies that must be cycled. Now a sticker from each plane must be chosen. One from the U, the F, and the R planes (or their parallel planes).
So one sticker from the U has been chosen, the buffer is in the U plane, URB.
Now, if I was to cycle to the RFD, I must pick the FUL. If I did the FDR, I must choose the LFU.


If the URB is the Buffer:
URB -> (L)FU -> (F)DR; URB -> FDR -> LFU
URB -> (F)UL -> (R)FD; URB -> RFD -> FUL
URB -> (L)FU -> (B)DL; URB -> BDL -> LFU
URB -> (F)UL -> (L)BD; URB -> LBD -> FUL
URB -> (F)DR -> (L)BD; URB -> LBD -> FDR
URB -> (R)FD -> (B)DL; URB -> BDL -> RFD

So if they are all on different planes: Well then you have an orthogonal case!
Its awesome. A simple quarter turn setup, will give you interchangability. Then you can do an 8 move commutator. It's very veratile for the setups. Remember, its always just a quarter move. And afterwards its always just an 8 mover.


----------



## dbeyer (May 9, 2009)

Orthogonals are a very special correlation of three pieces being cycled. All three cubies are adjacent to the same cubie, and hence none are adjacent to another cubie in the cycle. That is to say, the cubies themselves (not the stickers) Are all mutually interchangable by a double turn.
The ULF is interchangable by U2 with the URB.
The ULF is interchangable by L2 with the DLB.
The ULF is interchangable by F2 with the DRF.

(U, L, F)2 <-- See??
Likewise the pattern applied to the URB, finding it's 3 opposite cubies. doing U2, R2, or B2. You will see that they are all mutually opposite and all interchangable.

URB, ULF, DRF, and DLB are opposites. (R/L follow U/D)
DFL, DBR, UFR, and UBL are opposites. (F/B follow U/D)
By choosing URB as the buffer, our focus is the URB subset of opposites.
If anybody was to use another buffer, you should determine which set your buffer is in.
Is it an R/L plane cubie, or a F/B plane cubie does [R/L or F/B] follow U/D?

Now Orthogonals, using this concept of opposite in the R/L plane. You choose 3 cubies. One is of course the buffer. Then you choose one sticker from each plane. And if you've meet all these requirements. You have an orthogonal case.

Lets use the same subset of cubies for our cycles, but lets use a different limiting factor for the sticker selection. The selection of sticker permutation is limited to one set of parallel planes. Since we start with the URB. That's limiting the cycles to the U/D stickers of this subset. That is to say that in this effect, all three cubies are mutually opposite and interchangable.

URB -> ULF -> DRF is a 12 move case. They are all mutually opposite, and all mutually interchangable.

URB -> ULF -> DRF; URB -> DRF -> ULF
URB -> ULF -> DLB; URB -> DLB -> ULF
URB -> DRF -> DLB; URB -> DLB -> DRF


----------



## dbeyer (May 9, 2009)

Here are the other 18 cases that are 10 moves.
These are cyclic shifts. 
Similar to Orthogonals in several respects:
Rather than the other two pieces being mutually opposite to the buffer, the two other pieces in the cycle are mutually adjacent to the buffer. So this cycle is contained to a single layer.
Either the U, R, or B layer, if your buffer is the URB.
As such, these cycles, do not involve the Polar opposite (the DFL)
A sticker from each set of planes must be in the cycle (the U/D, F/B, and L/R).
Cyclic Shifts: One piece, and its two adjacent cubies are being cycled.
Orthogonals: One piece, and its two opposite cubies are being cycled.
--
Cyclic Shifts: One sticker from each set of planes is being cycled
Orthogonals: One sticker from each set of planes is being cycled

When you are determining if a case is a cyclic shift. Determine the middle piece, that is the piece adjacent to both. 
URB -> ULF -> UFR;
UFR is the middle piece.
URB -> UFR -> UBL;
URB is the middle piece.
Now sticker permutation, obviously the opposite cubies are both adjacent to the middle piece.

There are three types of interchangability.
Interchangability on the Plane
Interchangability on the Slice
Interchangability on the Layer
URB and ULF are interchangable on the U plane.
Likewise: URB and UFR are interchangable on the U plane.
URB and DRF are interchangable on the R slice.
Likewise: URB and FRU are interchangeable on the R slice.

The third concept of interchangability is on a layer. You are looking at the piece as a whole. You do not look at sticker permutation. You just make a reference to the cubies, rather than the sticker permutation. 

the URB is on 1 plane, and 2 slices.
Each plane and slice-orbit has 4 pieces on it. Hence, the URB is interchangable with 3 pieces on the U plane, 3 pieces on the R slice, and 3 pieces on the B slice.

Now any cubie is interchangable with respect to the layer with 6 of the 7 other cubies with one turn (HTM). Every cubie but it's polar opposite.
Adjacent cubies are of course interchangable on that layer.
Adjacent cubies can have three characteristics. The first two were described already, interchangability on the plane, or on the slice.
If neither exist, then the cubies are adjacent and non-interchangable.
Here we coined the term AnI (like the anny in Danny).


----------



## dbeyer (May 9, 2009)

So cyclic shifts are contained to three cubies on one layer.
The opposite cubies on the layer are both AnI with respect to the middle cubie. With both cubies being AnI with respect to the middle cubie, you are then creating a cycle with a piece from each plane.

For clarification: When I say each plane, let it be understood -- a plane or its parallel, (speedcubing correlation, a face or its opposite side)


----------



## dbeyer (May 9, 2009)

Here is a quick glossary list:

Cubie -- A piece, as a whole, with no specific permutation or orientation there of. Just to make a reference to a location on the cube. Standard U/D first.
URB or DRF for example.

Interchangability -- There are different ranges and degrees of interchangability. Looking at the cubie locations as a whole. A piece is interchangable with every other piece in one turn (htm), except it's polar opposite.
Interchangability on the Layer: This is the broadest form of interchangability. Looking at the cubies as a whole. 
The six cubies interchangeable with the URB;
ULF, DRF, DLB, UFR, UBL, DBR 
NOT the DFL

Interchangable on the Plane-orbit: 
The U plane is the URB, UFR, ULF, UBL.
The F plane is the FRU, FUL, FLD, FDR

Interchangable on the Slice-orbit:
The URB's R-slice-orbit;
URB, BRD, DRF, FRU.
The FUL's U slice-orbit;
FUL, LUB, BUR, RUF

Adjacent Cubies -- To be next interchanged by 1 quarter turn 
URB and FLU for example.
FDR and RDB
Opposite Cubies -- To be interchanged by 1 half turn.
URB and DLB for example.
FRU and FLD
Polar Opposites -- The two cubies with are not interchangable in anyway shape or form with just 1 turn (HTM);
URB and DFL for example.

Oppsosites have interesting characteristics. 
Either the pieces are interchangable on the plane or slice. 
URB and ULF for example on the U plane.
URB and DRF for example on the R slice.

Or the opposites are not interchangable. That means they are twisted opposites.
URB and LFU for example.
URB and FUL perhaps.

Lets move the LFU one quarter turn.
There are 6 quarter turns possible, L, L', F, F', U, U'
U and U' have no effect on the cube state really, both cubies are being moved. Because both are in the U layer.
The other 4 quarter turns possible bring the LFU to another location in the U layer, or to the location of the URB's polar opposite.
Both turns that keep the LFU in the U layer (the URB and the LFU's common layer) make the URB and the LFU interchangable on either the U plane or R slice.
This of course also applied to the URB. You can make 6 moves, U, U', R, R', B, or B'
2 which have no effect,
2 bring the URB into the LFU's plane-orbit or slice-orbit.
2 bring the URB into the LFU's polar opposite.

So determine if two pieces are interchangable opposites, or twisted opposites. 
Here is a nice characteristic for setting up commutators. 
Interchangable opposites, are good to have, because well you've found your part B to the commutator in an 8 move case.
Twisted opposites are good, because you if you have twisted oppsites, and the third piece is interchangeable (adjacent or opposite) with one of the first two, you've found your insertion.
URB and ULF are in a cycle. You could interchange the two with U2.
URB and LFU are in a cycle. You could insert with FR'F' or R'FR


----------



## DavidWoner (May 9, 2009)

Edit: whoops just saw that chris already explained Per specials, but thankfully it looks like I understood them properly, even if I conveyed the idea poorly. And I agree, once you understand these, its apparent how beautiful they actually are.

lets look at this case:
(URB ULF DRF) U F2 U' F2 U' R2 U F2 U F2 U' R2 (12 HTM) Per Special

(U F2 U' F2 U', R2)

although I think it will make more sense if we look at this way:

[(U F2: U'), R2]

Note that ULF and DRF and interchangeable by F2 (we will call this lowercase a), and DRF and URB are interchangeable by R2 (lowercase b).

Now what we try to do is swap the non-buffer pieces (swap a) without disturbing the R face of the cube. What U F2 does is move the buffer out of the way, and changes swap a from F2 to U'. So you perform swap a, then undo the conjugation. We have now swapped ULF and DRF without disturbing the R face, so we can just exchange pieces with using R2 without any problems. The rest is a simple matter of how commutators work, what with undoing the first half.

I hope this made a bit of sense. If not I will try to clarify a bit more later.


----------



## dbeyer (May 9, 2009)

Adjacent cubies have different classifications of interchangability.
Interchangable on the Slice, the Plane, or Layer, or the lack there of.
All adjacent cubies are interchangable on two layers. URB and UFR are interchangable on the U and R layers.
The URB and URF are interchangeable on the U/R layer and specifically the U plane
The URB and the FUR are interchangable on the U/R layer and specifically R slice
The URB and the RFU are interchangable on the U/R layer, but not on any slice or plane.
Again, this is where the term AnI was coined.
AnI cubies share two layers, their individual unique layers are parallel.
the URB and RFU's parallel layers are the F and B.
A quarter turn on either of the parallel layers will make the AnI pieces interchangeable opposites.
A half turn of either of the parallel layers will make the AnI pieces twisted polar opposites.


----------



## dbeyer (May 9, 2009)

Lets look at an Orbit.

The Controls--
Two adjacent pieces
Turning the F layer
The UFR cubie

Let this piece be AnI to the Buffer.
URB and RUF for example.
Turn F, you have slice-orbit opposites,
Turn F2, you have twisted polar opposites.
Turn F', you have plane-orbit opposites
Turn F4, you have Adjacent non-Interchangable (AnI)

Let this piece be interchangeable on the slice-orbit
URB and FRU
Turn F, you have twisted opposites
Turn F2, you have twisted polar opposites
Turn F', you have twisted opposites
Turn F4, you have Adjacent Slice-Orbit (AsO)

Two adjacent pieces
Let this piece be interchangable on the plane-oribit
URB and UFR
turn F, you have twisted opposites
turn F2, you have parallel polar opposites
turn F', you have twisted opposites.
turn F4, you have Adjacent Plane-orbit (ApO)


The controls--
Two opposite pieces
Turning the F layer
The ULF cubie

Interchangable Opposites
URB and ULF
turn F, you have AnI
turn F2, you have interchangable opposites
turn F', you have twisted polar opposites
turn F4, you have interhchangable opposites

Twisted Opposites - On the Plane (F plane)
URB and FUL
turn F, you have AsO
turn F2, you have twisted opposites
turn F', you have twisted polar opposites
turn F4, you have twisted opposites

Twisted Opposites -- On the Slice (F slice)
URB and LFU
turn F, you have ApO
turn F2, you have twisted opposites
turn F', you have twisted polar opposites
turn F4, you have twisted opposites

Of course if you were to turn the L layer, and use the ULF cubie, you would, wind up with inverted and swapped results of FUL and LFU.
Just look at these trends. Notice the characteristics of the oribits. This will allow you to see the correct setups for orthogonal cases. This will allow you to see the correct insertion for cyclic shifts.
This will allow you to find the correct cancelations on A9s, and Columns cases.

It's a very powerful method. Its not a list of algorithms to memorize. Its a freestyle method, that gives you a vast understanding of the cube's properties. This method goes into muscle memory. And using the techniques described here, you can actually figure out any cycle, and how to solve it by recognizing relationships.

You first recognize two pieces and their locational relationship to one another. What really sets it apart though is the 3rd piece. Just like you could recognize a lot of relationships between corner and edge pairs, but you need to reference the c/e pair to where the solved pair belongs.

Later,
DB


----------



## dbeyer (May 9, 2009)

This is a freestyle method.
You can intuitively solve any cycle of three cubies.
You can optimally solve any cycle of three cubies.
You can determine optimal length of any cycle of three cubies
You can easily invert a permutation of any three cubies

You can limit the demand of thought, by limiting the number of cases by using a buffer.
By using a buffer, you can learn fewer cases and it will go into muscle memory quicker.
Using a buffer, you can correlate and cycle to an images (made of a letter pair).

You can limit parity cases. 
Here is my method of approach.
I create a 2x2x1 block (The URB, UR, and UB pieces). 
The UR and UB need to be switched. The URB must be permuted/switched with whatever the last corner is. This is always the final case of the parity.

Example Solve:
Buffers: UR and URB
Parity: FL and RFD

I solve all other edges and corners with commutators.
Now the URB and RFD need to be switched.
The UR and FL need to be switched.
This takes some extra moves, yes I know, but it's easier to always do a BH alg than to create difficult setups. The ease of the parity fix is reduced to 1 turn (HTM) setup and a very fast 2-cycle.

I cycle the UR -> FL -> UB. This leave now with the FL solved. 
Now the UR and UB need to be switched, as well as the URB and RFD.
Simply then do a setup turn bringing the RFD (or whatever cubie it may be) to the polar opposite of the buffer. This can always be done in one turn. Since six cubies are interchangeable with every piece, the only one that isn't is the polar opposite. This means that the six cubies that are interchangeable with one turn (HTM) with the buffer are also intechangable with its polar opposite. 

So, in this case,
D' y'RU'R'U'RUR'F'RUR'U'R'FRy D
Done. URB and RFD have been switched as have UR and UB. I always cycle cycle the parity edge with the UB, (using one extra commutator) to create the 2x2x1 block so that I can freely use the power of polar opposites and the fast algs that I have access to.

Here they are:

URB -> DFL; L'U'LF2R'DR'D'R2F2 
URB -> LDF; L'ULUL'U'LFL'U'LULF'L'
URB -> FLD; y'RU'R'U'RUR'F'RUR'U'R'FRy


----------



## byu (May 9, 2009)

Wow dbeyer, thanks for all the great information! I'll try to summarize it and put into my own words and add it to the first post.


----------



## byu (May 9, 2009)

All right, I updated the first post with a bit more information about everything. I STILL can't seem to visualize when two pieces are interchangeable though...


----------



## cmhardw (May 10, 2009)

This is an absolute staple of my solving, called "viewpoint shifting". If you are going to have a resource, I would say that I use this once every solve or every other solve. I find this to be a huge help in quickly seeing the interchangeability of the piece.

http://tinyurl.com/r9s92l


----------



## dbeyer (May 10, 2009)

Looking at two pieces. There are three positional references at to the locations between the two cubies.
Adjacent, Opposite, or Polar Opposites.
Each cubie has 3 adjacent cubies, 3 opposite cubies, and 1 polar opposite.
Adjacent cubies are interchanged by a quarter turn.
Opposite cubies are interchanged by a half turn.
Polar Opposite cubies are interchanged by quarter turn and half turn.

Now looking at Adjacent cubies:
AsO, ApO, and AnI.
Opposite cubies:
Interchangable opposites and twisted opposites.
Polar Opposites:
Parallel polar opposites and twisted polar opposites.

Polar Opposites, twisted opposites, and AnIs are all non interchangable. The rest are. In other words. One piece such as the URB is interchangable with 9 other pieces, and the other 12 permuations are not interchangable.

Later,
DB


----------



## byu (May 14, 2009)

So, I decided to look at Chris's BH edges page, and I'm REALLY confused. I'm not going to learn it until I fully understand corners.

The types I've discovered are:

Drop and Catch
SP9
SP7
Toss Up
B9
Direct Insert
Slice-Plane
A9
Half Slice-Plane

And there are also Setups and Wide Setups. Can anyone explain these? I'm still having trouble understanding A9s and Orthogonals.


----------



## dbeyer (May 14, 2009)

A Wide turn setup can actually be viewed in several different ways.
We use the term Wide-turn because you are turning multiple parallel slices, to transform (setup) the case into a more finger friendly algorithm.

The cycle UR -> FD -> LB can be viewed two ways.
A nice setup for this case is M'.
You have now transformed this case into UR -> UF -> LB
Once you have done the setup, you will then proceed with RE'R' U' RER' U and undo the M' setup.

You could also transform UR -> FD -> LB into UF -> LB -> BR
This can be done by doing the setup (r).

r E' R'U'R E R'UR M

Either way you look at the transformation of the case, you will notice that M' and R merge into one move. Your viewpoint of the case could be different than mine. Chris saw it as, doing the setup and the insertion as a single move. I saw it as moving two pieces as the setup. Both are of course right. They are identities, and equivalent. The point is seeing those Wide Turn canceling effects because they are there!


----------



## byu (May 15, 2009)

Some questions:

How would BH apply to big cube centers and wing edges?

Can I use BH edges and corners on big cubes and not mess up centers if they're still scrambled?

Is E in the F or B direction?

Is S in the U or D direction?


----------



## Rubixcubematt (May 15, 2009)

E is in the D direction, S is in the F direction. and yes, the corners can be used on big cubes, because when you do a move, it is then reversed.


----------



## Mike Hughey (May 15, 2009)

byu said:


> How would BH apply to big cube centers and wing edges?


They have a whole set of algorithms for those too. They'll be posted soon, I'm sure. But in the meantime, for X centers, you can actually use the corners algorithms you've already learned, just using slice moves where necessary. With just a little practice, you'll see how to do that. I've already switched to using some of them in my big cube solves, for the bad cases. There are more optimal ones than those in some cases, but the corners algorithms will generally always work for the X centers.

I've found that in general, if I was using one or two setup moves before to solve a set of X centers, I'm almost always at least as well off using the BH corners algorithm instead of my setup move. It's been a real surprise to me how well that works.

QUOTE=byu;179216]Can I use BH edges and corners on big cubes and not mess up centers if they're still scrambled?[/QUOTE]
As long as you use the proper algorithms on Chris's site (check the *'s), you'll be completely safe on big cubes. That was one of Chris and Daniel's big intentions - to make sure the algorithms are center-safe on big cubes.


----------



## CT_Warrior (Jul 22, 2009)

Hmm, I think I may be interested in learning BH corners, since I find R2 to be a bit too inconsistent.

I have a few questions though.

1/ How often would one have to review the method? It seems like there are a lot of rules and commutators.

2/ What's the memo like? In pairs, in triplets? Or is it similar to 3OP?

3/ How many moves does it take to solve the corners on average?

Thanks.


----------



## joey (Jul 22, 2009)

1) Not often, maybe a few of the more esoteric cases. But I think once you get them, it should be pretty much a deep understanding.

2) Pairs, or singles 

3) errr, eerr, err, eerrr errr, errr, reeereeree. eerr. I dunno. I want to say like 30~ as a guess.


----------



## Mike Hughey (Jul 22, 2009)

I did an average of 12 BH corners, in move count:
37, 42 (18T, P), 35, 28 (P), 37 (20T, P), (25 (P)), 42 (18T), 44 (18T), (54 (45T, P)), 38, 35 (P), 25 (P) = *36.3 moves*

P means there was parity; I didn't bother to solve parity if it was there. So add in the moves to solve parity if you consider that part of your move count. The numbers with a "T" in parentheses mean that I had to twist corners in place, and that many moves were required to twist the corners. My bad solve in terms of move count was the one that had 4 corners twisted in place, and just 4 corners to permute - I didn't even do the parity, so it was a single 9-move BH cycle, and then 45 moves to twist all the corners. I hate cases like that.

I still just use the standard old commutator for twisting corners, so it takes me 18 moves to twist two corners. People who have bothered to learn good algorithms for it would do it in significantly fewer moves.


----------



## joey (Jul 22, 2009)

Isn't it 16 moves to twist two like that?


----------



## Mike Hughey (Jul 22, 2009)

joey said:


> Isn't it 16 moves to twist two like that?



It takes me 18. Maybe just because I'm stupid about it, but it's what Macky taught in his old BLD document, which is when I learned it. I always rotate the cube and then do something like (R' U' R U)*2 L (R' U' R U)*2 L'.


----------



## Anthony (Jul 22, 2009)

Mike Hughey said:


> joey said:
> 
> 
> > Isn't it 16 moves to twist two like that?
> ...



I do the same thing, but what's the better way to twist corners? I know some people do sune/u perm and things like that to twist a couple corners at a time, is there an even better way?


----------



## Mike Hughey (Jul 22, 2009)

Anthony said:


> Mike Hughey said:
> 
> 
> > joey said:
> ...



There are a number of people who have learned optimal algorithms for a lot of the common cases.

Or, you could do it like Daniel Beyer does, and perform two optimal commutators to fix them in place with just 16 moves (assuming that's possible for the particular case).


----------



## Anthony (Jul 22, 2009)

Mike Hughey said:


> Anthony said:
> 
> 
> > Mike Hughey said:
> ...



Is there a list of these optimal algorithms for common cases? 

I suck at commutators.


----------



## Mike Hughey (Jul 22, 2009)

Anthony said:


> Mike Hughey said:
> 
> 
> > Anthony said:
> ...


Yeah, they're just standard BH commutators. Daniel figures out which ones to apply on the fly. He talks about it here.


----------



## CT_Warrior (Jul 23, 2009)

Thanks guys. <3
I'll learn it soon!


----------



## dbeyer (Jul 23, 2009)

Note: I use sune cases to twist the buffer and the twisted corner. I bring the buffer and twisted corner to adjacent locations, and do a quick alg. Then I reset. Mind you it only takes 1 move to make them adjacent. Just do the proper sune algorithm afterward.

Optimal Twisty Cases is an undeveloped but probable solution for fixing two non-buffer corners in 16 moves on average.


----------

