Transformation

Transformation is the application of a conjugate with the intent to change one case into another. It takes advantage of the orientation or misorientation of corners, edges, and centers to allow for setup moves to transform the current case. A setup move is performed, the algorithm for the new case is completed, then the setup move is undone. This technique has been used to reduce the number of cases in algorithm sets, reduce the number of moves, and to avoid cases with difficult to perform algorithms. Transformation can be applied to corners, edges, centers, and even groups of pieces such as pairs.

History

Conjugation has been used to solve puzzles since the beginning. Setups were performed to isolate or position pieces to more desirable positions. Pseudo blocks had also been used in some methods, such as the Roux method and Heise, as a way to reduce the number of moves. Some had further noticed that, for some cases, a turn of a layer could be performed and the case now looks similar to another case they already have a good algorithm for. That has been one method for finding algorithms. In PLL, for example, this has been applied to avoid undesirable cases. It wasn't until 2012 that full case lists were completed and the benefits shown.

In 2010, James Straughan discovered this principle during development of the NMLL last layer method. A corner edge pair can be aligned and an R or L turn will change the last layer to a different case. This is an example of pair transformation.

In 2012, James Straughan completed a relationship table that shows the alternate case that each last layer corner case transforms into after an R or L turn or an x rotation[1]. This was later applied to 2x2 to create the A2 method[2]. There, the name "transformation" was proposed. The same year, transformation was applied to ZBLL, OLLCP, and CLL+1 to reduce the number of cases[3], ELL for edge transformation, and LSE for center transformation to develop what is now known as EOLR to optimize the move count[4]. It was then realized that transformation would be a new, separate concept and term in puzzle solving terminology.

In 2015, Chris Tran proposed CTLS[5], a method for solving the last slot and last layer. When there is a corner edge pair on the U layer, transformation is a technique used to help solve the cases.

In 2017, Joseph Briggs proposed 42, a 3x3 method. The third step of this method solves the last five corners using Conjugated CMLL. An oriented corner on the U layer is positioned on R and an R turn is performed. There is now a pseudo CMLL case. After CMLL is completed, the FR edge is solved and the U and R layers are transformed back to their normal state. This idea was later extended to BTR which was essentially a recreation of Straughan's original Transformation concept. The two were found to be the same in 2020.

Usage and Examples

A2

Example 1:

• Scramble: R2 F2 R U R U2 F2 R' U'
• Face: y' x' U' R'
• EG: U R' U2 R' U2 R' U' R2

Example 2:

• Scramble: U' F2 U' F2 U R F2 R'
• Face: y x2 U' R2
• EG: R' F U2 R2 F R'

NMLL/ZBLL

• Scramble: x R2 D2 R U2 R' D2 R U2 R x'

If an R turn is performed after the scramble, the case changes to look like the image on the left below. The image on the right shows what the case normally looks like.

The application to ZBLL and other LL methods with a large number of cases has the benefit of reducing the number of algorithms to learn.

LSE

Example 1:

• Scramble: M2 U2 M U M U2 M' U' M U M2 U2 M2 U M2 U' M' U M' U2 M' U' M
• Orient: M2 U' M'
• L/R: U M U2 M
• M Slice: U u2 M' u2
• In this solution, the orientation step uses the center and edge orientation, as well as the location of the L/R edges, to shorten the moves required.

The normal solution for this case would have been slightly longer:

• Orient: M' U M' U M U M (Seven moves versus the three moves above)
• L/R: U' M' U2 M'
• M Slice: U M2 U2

Example 2 (Six Misoriented Edges):

• Scramble: M U' M U' M' U' M U2 M U' M'
• Orient: M' U M' U M
• L/R: U M' U2 M'
• M Slice: U M

The normal solution for this case is:

• Orient: M' U M' U2 M' U M U M' U M' / R U' r' U' M' U r U r'
• L/R: U' M U2 M
• M Slice: U' M2 U2 M' U2 M'

Instead of performing one of the standard long sequences for orienting six edges, the orientation step can be completed in only five turns. The case can be transformed by first recognizing the location of the L/R edges.

Taking advantage of the orientation of the centers and edges, the orientation case can be transformed into one that has a shorter solution. The setup here is the initial move to change the center/edge orientation. The setup undo would be re-orienting the centers at the end, but is always cancelled out because the last move of LSE already is to align the M layer. This application to LSE is an example of center transformation.

42

• Scramble: R2 B2 D2 B2 R2 U F2 U' R2 D L2 R' F D2 R U B F2 R' F
• 1x2x3: z2 x' U2 R2 U' x F R U' F2
• 1x2x2 + oriented U corner: r U' R' U r U2 M U R2 U R
• CMLL: U F R U R' U' R U R' U' F'
• FR + Orient LSE: U2 M' U M' U R'
• Finish LSE: M2 U M U2 M' U' M U2 M2

After the 1x2x2 in the second block, any oriented U layer corner is inserted instead of a pair. The corners are then solved using Conjugated CMLL. After that, the edges are oriented while solving the remaining second block edge. The use of Conjugated CMLL reduces the number of moves in the method.

OLLCP

• Scramble: F' U' L' U L F L' U2 L U L' U L
• Solution: M' U' - F R U R' U' F' - U2 M

The M' U' setup takes into account the way that the F R U R' U' F' algorithm affects the edges and the corners. Then the U layer is adjusted so that the M setup can be undone. The benefit is to reduce the number of algorithms to learn. This is an example of edge transformation.

CLL+1

• Scramble: B L U' L' B' R' U2 L' U' L2 D F2 D' L' R
• Solution: M' - R' U2 l U' R U L' U R' U r - U2 M

CLL+1 is a last layer method to solve the corners plus one edge. In this case, the UL edge is solved. This is accomplished by using an M' setup and some turns in the normal R' U2 L U' R U L' U R' U R algorithm are changed to wide turns. This is another large algorithm set which can be reduced using this technique.