Difference between revisions of "K4"

From Speedsolving.com Wiki
m
m
Line 105: Line 105:
 
''Approach III''
 
''Approach III''
  
It is possible to derive all twenty-eight algorithms from one commutator, but doing so will not yield efficient algorithms for all cases.  However, if a cuber chooses to do so, it is a great practice for becoming familiar with commutators and preliminary moves.  For example, in the "Commutators" portion of Thom Barlow's guide, he shows the following image:
+
It is possible to derive all twenty-eight algorithms from one commutator, but doing so will not yield efficient algorithms for all cases (some cases will require many set-up moves which makes the algorithm length much longer than if using another commutator to begin with).  However, if a cuber chooses to do so, it is a great practice for becoming familiar with commutators and preliminary moves.  For example, in the "Commutators" portion of Thom Barlow's guide, he shows the following image:
  
 
[[image:Commutator_Example.png]]
 
[[image:Commutator_Example.png]]

Revision as of 23:33, 19 February 2010

The K4 Method was created by Thom Barlow. His guide can be found here [1].


Brief Summary of the Method

After two opposite centers are solved, this method takes advantage of the remaining four middle centers to pair up three cross-edges of the same color without the inconvenience of destroying and fixing back previously solved centers as is edge pairing in reduction. Two adjacent corners are solved between these three cross-edges to form a 1x3x4 block about one of the initially solved centers. Then the four middle centers are carefully solved without destroying the 1x3x4 block (this can be done as efficiently as solving the middle centers in reduction, according to Thom Barlow in "Step 3" of his guide). Next, the last two corners of the first layer are inserted as well as inserting the last cross-edge (which may either be inserted one winged-edge at a time or by first pairing up the dedge and then inserting it). (Here is a link to java applets demonstrating possible scenarios of completing the last cross-edge [2]). Now the first layer is complete along with all six centers. The remaining dedges in the first three layers are directly solved using various commutators (they all can really be solved with one commutator, but knowing more commutators enables the cuber to solve them with speed). Solving the last layer is broken into two-three steps:

1) Solve the corners with COLL or other preferred 3x3x3 corner solving methods.

2) Use commutators to place the unsolved winged edges in their solved positions.

3) Perform an odd permutation algorithm to the cube if (odd) parity exists ("permutation/even parity" usually does not occur due to the fact that the last-layer dedges are not "paired up" but rather directly solved piece by piece).


Difficulties of the K4 Method

One of the biggest challenges of this method is to master solving the last layer. One can easily solve the last-layer corners using COLL or regular 3x3x3 corner solving methods, but solving the last-layer dedges requires commutators. Thom Barlow covers this portion of the method in "Step 7" of his guide. He has provided an algorithm for each of the twenty-eight possible 3-cycle cases, that is, when not counting rotations about the y-axis (each of these cases has the same probability of occurrence as the rest in a given solve). In addition, Thom Barlow provides a few (odd) parity algorithms and 2 2-cycle algorithms (one of which is commonly known as "permutation parity") in his guide as well.

With twenty-eight different possible cases just for 3-cycles, solving the last layer can be overwhelming. Member cmowla has made a table of all twenty-eight 3-cycle cases for the last layer, each accompanied by Thom Barlow's algorithm for that specific case.


File:Table of 3-cycles (first half).PNG File:Table of 3-cycles (second half).PNG


Reducing the Number of 3-Cycle Algorithms to Learn for the Last Layer

Memorizing twenty-eight distinct 3-cycle algorithms is not a prerequisite for being able to solve the last-layer dedges with confidence.


Approach I

Referring to the table presented above, notice that the table above is composed of 14 different algorithms and their inverses. One can narrow down the number of algorithms to 7, recognizing that there are minor differences between the first and second groups of 7. So it appears that, by Thom Barlow's approach, the cuber is to memorize 7 algorithms and do alterations of them to tackle the other 21 cases.


Approach II

Apart from memorizing 7 algorithms and having to do the inverse of them, etc, a second approach is to divide the twenty-eight cases into six groups. Each group has an algorithm and its reflection (which may be easier to recognize rather than the inverse as in the first approach). Next, one can derive "weird cases" from "common cases" by adding preliminary moves to the "common case" so that the pieces involved in the new cycle are in the positions of the original "common cycle" (and if this can be done with only one move, then it makes the "weird cases" resemble common ones, making solving the last layer intuitive and much simpler than attempting to memorize twenty-eight distinct algorithms). The 6 groups are listed below (by cmowla).


File:Case A.PNG

Algorithm [A]

L B y' z r U' R' U r' U' R F' z' y (by cmowla)

Algorithm [A Reflection]

R' B' y z' r U L U' r' U L' F z y' (by cmowla)


File:Case B.PNG

Algorithm [B]

L B y' z l' U' R' U l U' R F' z' y (by cmowla)

Algorithm [B Reflection]

R' B' y z' l' U L U' l U L' F z y' (by cmowla)

File:Case C.PNG

Algorithm [C]

x' l' U L' U' l U L U' x

Algorithm [C Reflection]

x' r U' R U r' U' R' U x

File:Case D.PNG

Algorithm [D]

x' r U L' U' r' U L U' x

Algorithm [D Reflection]

x' l' U' R U l U' R' U x

File:Case E.PNG

Algorithm [E]

l' y' L2 U r U' L2 U r' U' y l (by cmowla)

Algorithm [E Reflection]

r y' L2 U l' U' L2 U l U' y r' (by cmowla)

File:Case F.PNG

Algorithm [F]

l' D r U' L'2 U r' U' L'2 U D' l

Algorithm [F Reflection]

r D' l' U R2 U' l U R2 U' D r'


Approach III

It is possible to derive all twenty-eight algorithms from one commutator, but doing so will not yield efficient algorithms for all cases (some cases will require many set-up moves which makes the algorithm length much longer than if using another commutator to begin with). However, if a cuber chooses to do so, it is a great practice for becoming familiar with commutators and preliminary moves. For example, in the "Commutators" portion of Thom Barlow's guide, he shows the following image:

File:Commutator Example.png


Adding the preliminary moves to the algorithm in the "Case D" group which itself has the preliminary move f to "Algorithm [D]", yields the result of this image.

f2 D y2 x'

f x' l' U' R U l U' R' U x f '

x y2 D' f2

Note: This is not the shortest algorithm to do this (the shortest is at most two quarter turns less): it is only a demonstration using an algorithm previously presented in the second approach.


Additional Information

For theory on why there are exactly 28 3-cycle cases, visit this page [3]. (In that thread, there is also discussion on the number of cases for higher order cycles as well, such as 4-cycles, 6-cycles, 8-cycles, etc., and multiples of lower cycles, such as 2 2-cycles).


External Links

Scramble 01.jpg This page is a DNF (incomplete).
Please help by expanding it.
There may be suggestions on its talk page.