cmhardw
Premium Member
I haven't seen a whole lot of posts on this other than some scattered ones from Daniel, myself, and others. Hopefully this will help others who are interested in BH edges. For a list of all edge commutators see the BH Edge method website.
-----------------------------------------------------------------------
BH edges commutator types with one example given of each:
4 movers (3x3x3 only):
Half Slice-Plane for 3x3:
These are very neat, and only work on the 3x3x3. You can do a standard Slice-Plane alg on a 5x5x5 or 7x7x7 that is supercube safe, but they don't come up often. The difference between the Slice-Plane and the Half-Slice Plane is that in the Slice-Plane you execute the maneuver twice in succession to make the algorithm supercube safe. In my opinion, a truly superior blindfolded method would be to optimize all 3x3x3 edges cycles using the concept behind the Half Slice-Plane commutators as much as possible. Marcus Stuhr demonstrated a very strong knowledge of how to use these cycles to quickly and efficiently cycle 3x3x3 edges in a few videos he posted a while back.
The concept behind the Half Slice-Plane commutator is that pieces can be interchangeable on a slice, or on the plane of a face. So for example, and I am talking about stickers here and not pieces for the time being. UF is interchangeable with UB on the U plane. What we mean by plane is the 2D plane viewed only as the stickers on the U slice or U layer.
BU is interchangeable with FU on the U slice. Here we need to consider the U layer as a 3D layer consisting of 3D pieces, and the BU and FU stickers interchange in this 3rd dimension.
An example of a Half Slice-Plane commutator is the cycle: UB -> DF ->UF
The commutator is: U2 M' U2 M
The break down is:
A: U2
B: M'
Remember that for BH, A is always the insertion part of the commutator, and B is always the part that swaps or moves the two interchangeable pieces.
Let's look at this commutator. First we notice that UB and UF are interchangeable on the U plane, and UF and DF are interchangeable on the F slice. The first part of the commutator, the U2, inserts the UB sticker to UF on the U plane. Next we bring the stickers at UF and DF into the U slice by doing M'. The U layer is offset by a U2 turn at this point, and we also need to interchange the stickers now at BU and FU. We do both at once with the second U2 turn. The last turn is to return the stickers now at BU and FU to their original locations at UF and DF. This is not strictly an (insert) (interchange) (insert)' (interchange)' style commutator, but rather using the properties of the cube to interchange twice on the U layer. The first time interchanges on the U plane and the second time interchanges on the U slice.
SP7 (7 turn Slice-Plane), SP9 (9 turn Slice-Plane) and other variations of the Slice-Plane concept utilize the same basic idea but not only use the reptition of the Half Slice-Plane idea, but also combine this this with setup turns involving a cancellation.
8 move commutators:
The following are all 8 move commutators, but we give them different names because the concept of the insertion is done differently for the different types.
Toss Up:
This commutator is done by replacing one piece from the interchangeable layer via the concept (move-replace-move back).
An example Toss Up case is UB -> FR - > LF
Commutator: R U R' E R U' R' E'
Break down:
A: R U R'
B: E
UB is the lone edge, and FR can interchange with LF via an E slice turn. We first "toss" the FR edge up into the U layer with the first R turn of the A part of the commutator. Then we replace this piece with the UB edge via the U turn. Now we bring the new edge back to the FR location via R'. Interchange with E, and do the inverse of each part to complete the commutator.
Direct Insert
On the surface these cases appear to be exactly the same as the Toss Ups, and it is almost arbitrary that we have a separate name for them, but there is one distinction that Daniel and I like to make when solving edges. The A part of the commutator is always a 3 move conjugate maneuver (except for the Slice-Plane type) and is executed as J K J' let's say. If the J turn moves one or both of the interchangeable pieces, then the commutator is a Toss Up. If the J turn moves an interchangeable piece and the lone edge, then the algorithm is a Direct Insert.
Example cycle: UB -> RD -> UR
Commutator: R' E' R U R' E R U'
Break down:
A: R' E' R
B: U
The UB and UR pieces are interchangeable via the U layer. The RD piece can directly or actively replace the UR piece via R' E' R. Notice that the J turn of the J K J' format moves both the UR and RD pieces. UR is an interchangeable piece (interchangeable with UB) and the RD piece is the lone edge. This makes this case a direct insert. The rest I think is clear enough by following through with the commutator.
Drop and Catch
This is also an 8 move commutator, and in fact is actually really a Toss Up style algorithm. We name them Drop and Catch because the "Toss" is done what can visually be perceived as "downward" rather than as "upward". There is no difference whatsoever between this type and the Toss Up commutator. The only difference is in the personal, arbitrary perception of how the A part of the commutator affects the pieces involved.
Example cycle: UB -> FD -> UR
Commutator: S D S' U S D' S' U'
Break down:
A: S D S'
B: U
The S turns drops the UR piece to the D layer, then do D S' to bring the FD piece into UR. Follow through with the rest of the commutator from here.
9 move commutators
A9:
Exact same concept as a corner A9 commutator. See Brian's tutorial for further explanation.
B9:
Exact same concept as the A9, except the cancellation of a turn happens with the B part of the commutator instead of the A part of the commutator. Daniel and I proved that no B9 commutator for corners is optimal. Every corner case that can be solved using a B9 concept actually has an optimal 8 turn commutator solution. The proof was done via enumeration and study of all potential B9 cases, and finding the optimal 8 move solution in each case.
Example cycle: UB -> UL -> LB
Commutator: U R E' R' U R E R' U2
Break Down:
A: R E' R'
B: U
P: U
execute as P A B A' B' P'
Notice that UB and UL interchange on the U layer. LB can insert to UR with R E' R'. First do the setup turn to move UB to UR. Then follow through with the drop and catch commutator. Finally undo the setup turn, except the B' and P' part of the commutators combine and cancel to one double turn move.
Wide setup into (insert case name here)
These algorithms are very basic. The concept behind them is that they are 10 move commutators each executed as an 8 move commutator with a 1 move setup. The setup turn does not cancel with either the A or B part of the commutator, but it can be executed simultaneously with either part via turning a double layer on a 3x3x3, or all affected/involved layers on a big cube.
Example cycle: UB - > FL -> RU
Commutator: (WCA big cube notation) Rw' E R U' R' E' R U M'
Break down:
A: R' E R
B: U'
P: M
execute as P A B A' B' P'
Notice that the P setup turn and the J turn of J K J' can combine simply as Rw' in WCA big cube notation. This is the concept behind the "Wide setup into (insert name type here)" commutator.
10 movers
These all consist of setup turns into an 8 move commutator. The idea is simple, do a setup turn, do an 8 move commutator, undo the setup turn. No cancellation of turns is possible. These cases usually have no simpler alternative because Daniel and I optimize the method for all cube sizes. On a 3x3x3 often a PLL alg such as U perm can replace these, or using a setup into a Half Slice-Plane.
Setup into (insert commutator type here):
Exactly as it sounds, and as described directly above.
Example cycle: UB -> LU -> FL
Commutator: x' D M' U L' U' M U L U' D' x
Break Down:
A: U L' U'
B: M'
P: x' D
execute as P B A B' A' P'
U perm cases also fall under this category, but obviously in a Freestyle 3x3 edge method you would just use a U perm. For larger cubes a 10 move algorithm must be used.
-----------------------------------------------------------------------
BH edges commutator types with one example given of each:
4 movers (3x3x3 only):
Half Slice-Plane for 3x3:
These are very neat, and only work on the 3x3x3. You can do a standard Slice-Plane alg on a 5x5x5 or 7x7x7 that is supercube safe, but they don't come up often. The difference between the Slice-Plane and the Half-Slice Plane is that in the Slice-Plane you execute the maneuver twice in succession to make the algorithm supercube safe. In my opinion, a truly superior blindfolded method would be to optimize all 3x3x3 edges cycles using the concept behind the Half Slice-Plane commutators as much as possible. Marcus Stuhr demonstrated a very strong knowledge of how to use these cycles to quickly and efficiently cycle 3x3x3 edges in a few videos he posted a while back.
The concept behind the Half Slice-Plane commutator is that pieces can be interchangeable on a slice, or on the plane of a face. So for example, and I am talking about stickers here and not pieces for the time being. UF is interchangeable with UB on the U plane. What we mean by plane is the 2D plane viewed only as the stickers on the U slice or U layer.
BU is interchangeable with FU on the U slice. Here we need to consider the U layer as a 3D layer consisting of 3D pieces, and the BU and FU stickers interchange in this 3rd dimension.
An example of a Half Slice-Plane commutator is the cycle: UB -> DF ->UF
The commutator is: U2 M' U2 M
The break down is:
A: U2
B: M'
Remember that for BH, A is always the insertion part of the commutator, and B is always the part that swaps or moves the two interchangeable pieces.
Let's look at this commutator. First we notice that UB and UF are interchangeable on the U plane, and UF and DF are interchangeable on the F slice. The first part of the commutator, the U2, inserts the UB sticker to UF on the U plane. Next we bring the stickers at UF and DF into the U slice by doing M'. The U layer is offset by a U2 turn at this point, and we also need to interchange the stickers now at BU and FU. We do both at once with the second U2 turn. The last turn is to return the stickers now at BU and FU to their original locations at UF and DF. This is not strictly an (insert) (interchange) (insert)' (interchange)' style commutator, but rather using the properties of the cube to interchange twice on the U layer. The first time interchanges on the U plane and the second time interchanges on the U slice.
SP7 (7 turn Slice-Plane), SP9 (9 turn Slice-Plane) and other variations of the Slice-Plane concept utilize the same basic idea but not only use the reptition of the Half Slice-Plane idea, but also combine this this with setup turns involving a cancellation.
8 move commutators:
The following are all 8 move commutators, but we give them different names because the concept of the insertion is done differently for the different types.
Toss Up:
This commutator is done by replacing one piece from the interchangeable layer via the concept (move-replace-move back).
An example Toss Up case is UB -> FR - > LF
Commutator: R U R' E R U' R' E'
Break down:
A: R U R'
B: E
UB is the lone edge, and FR can interchange with LF via an E slice turn. We first "toss" the FR edge up into the U layer with the first R turn of the A part of the commutator. Then we replace this piece with the UB edge via the U turn. Now we bring the new edge back to the FR location via R'. Interchange with E, and do the inverse of each part to complete the commutator.
Direct Insert
On the surface these cases appear to be exactly the same as the Toss Ups, and it is almost arbitrary that we have a separate name for them, but there is one distinction that Daniel and I like to make when solving edges. The A part of the commutator is always a 3 move conjugate maneuver (except for the Slice-Plane type) and is executed as J K J' let's say. If the J turn moves one or both of the interchangeable pieces, then the commutator is a Toss Up. If the J turn moves an interchangeable piece and the lone edge, then the algorithm is a Direct Insert.
Example cycle: UB -> RD -> UR
Commutator: R' E' R U R' E R U'
Break down:
A: R' E' R
B: U
The UB and UR pieces are interchangeable via the U layer. The RD piece can directly or actively replace the UR piece via R' E' R. Notice that the J turn of the J K J' format moves both the UR and RD pieces. UR is an interchangeable piece (interchangeable with UB) and the RD piece is the lone edge. This makes this case a direct insert. The rest I think is clear enough by following through with the commutator.
Drop and Catch
This is also an 8 move commutator, and in fact is actually really a Toss Up style algorithm. We name them Drop and Catch because the "Toss" is done what can visually be perceived as "downward" rather than as "upward". There is no difference whatsoever between this type and the Toss Up commutator. The only difference is in the personal, arbitrary perception of how the A part of the commutator affects the pieces involved.
Example cycle: UB -> FD -> UR
Commutator: S D S' U S D' S' U'
Break down:
A: S D S'
B: U
The S turns drops the UR piece to the D layer, then do D S' to bring the FD piece into UR. Follow through with the rest of the commutator from here.
9 move commutators
A9:
Exact same concept as a corner A9 commutator. See Brian's tutorial for further explanation.
B9:
Exact same concept as the A9, except the cancellation of a turn happens with the B part of the commutator instead of the A part of the commutator. Daniel and I proved that no B9 commutator for corners is optimal. Every corner case that can be solved using a B9 concept actually has an optimal 8 turn commutator solution. The proof was done via enumeration and study of all potential B9 cases, and finding the optimal 8 move solution in each case.
Example cycle: UB -> UL -> LB
Commutator: U R E' R' U R E R' U2
Break Down:
A: R E' R'
B: U
P: U
execute as P A B A' B' P'
Notice that UB and UL interchange on the U layer. LB can insert to UR with R E' R'. First do the setup turn to move UB to UR. Then follow through with the drop and catch commutator. Finally undo the setup turn, except the B' and P' part of the commutators combine and cancel to one double turn move.
Wide setup into (insert case name here)
These algorithms are very basic. The concept behind them is that they are 10 move commutators each executed as an 8 move commutator with a 1 move setup. The setup turn does not cancel with either the A or B part of the commutator, but it can be executed simultaneously with either part via turning a double layer on a 3x3x3, or all affected/involved layers on a big cube.
Example cycle: UB - > FL -> RU
Commutator: (WCA big cube notation) Rw' E R U' R' E' R U M'
Break down:
A: R' E R
B: U'
P: M
execute as P A B A' B' P'
Notice that the P setup turn and the J turn of J K J' can combine simply as Rw' in WCA big cube notation. This is the concept behind the "Wide setup into (insert name type here)" commutator.
10 movers
These all consist of setup turns into an 8 move commutator. The idea is simple, do a setup turn, do an 8 move commutator, undo the setup turn. No cancellation of turns is possible. These cases usually have no simpler alternative because Daniel and I optimize the method for all cube sizes. On a 3x3x3 often a PLL alg such as U perm can replace these, or using a setup into a Half Slice-Plane.
Setup into (insert commutator type here):
Exactly as it sounds, and as described directly above.
Example cycle: UB -> LU -> FL
Commutator: x' D M' U L' U' M U L U' D' x
Break Down:
A: U L' U'
B: M'
P: x' D
execute as P B A B' A' P'
U perm cases also fall under this category, but obviously in a Freestyle 3x3 edge method you would just use a U perm. For larger cubes a 10 move algorithm must be used.
Last edited: