## 2009: 6th period of work

The V-CUBE 6 became available at my local puzzle shop sometime in the spring of 2009, but I didn't notice it until July. I bought the puzzle soon after, then decided to begin a new software effort (the third, counting the Apple II program and RubikHack). This program isrubik3.

This new program uses a meet-in-the-middle search technique to test N positions in O(sqrt(N)) time. The program is able to enumerate all positions of the 2×2×2 in less than a minute, and to solve an arbitrary position of the 2×2×2 in less than 10 milliseconds. It is also quite facile with the 3×3×3 and limited searches on the 4×4×4.

2009 Aug 13 :

### 2×2×2 single-pair swap

To exchange the pieces at UFL and UFR, do one of the following:

R2 F R F' R2 F U' R U F2 (10f) (keeps U sides on U face)

U' F U2 R F' R' F' U2 F' U R (11f) (moves U sides to F face)

U2 R2 U' F' U R2 U' F U' F' (10f) (moves U sides to L and R faces)

All three are self-inverse (repeating the same sequence puts the cube back the way it was). The second sequence represents one of the 2644 states of the 2×2×2 cube that are a maximal distance from solved by the face-turn metric (11 face turns is the most it ever takes to solve the 2×2×2 by "God's algorithm").

### Local Maxima patterns

A "local maximum" is a position from which any move takes you closed to the solved state. For example, the above 11-move pair swap, the one that starts with U'F, is a local maximum because it is one of the 2644 positions that are 11 moves from the start, and as it happens none of these positions is reachable from each other in a single turn — so any turn will take you to a position that is only 10 turns from the solved state.

What comes as a surprise to those unfamiliar with the mathematics of group theory is that there are local maximum patterns only 4 moves from the solved state. From these positions, any move will take you to a position that is only 3 moves from a solved state:

4-turn local maxima

 example variations description R F2 U2 F2 6 two solid faces; 4 faces with 4 colors on each R2 U2 R2 F2 3 two solid faces; 4 faces with 2-color "checkerboard" U2 R2 F2 U2 2 six faces with two "bars"

There are also 8 local maximum positions that are 5 moves from start:

5-turn local maxima

 example variations description F R U2 F R 8 4 different colors on all 6 faces

### 4×4×4 double-pair swap

Two algorithms mentioned above can be combined to make this simple, pure double edge pair swap: (R2F122)2 R2F2 R22F22R22 (9s) (Exchanges the edge-pair at UF with that at DF). (But, see my later improvement on Aug 27th, below).

### Emulation of Small Non-Cube puzzles

I have begun working on the descriptions (on the following pages) of several of the smaller non-cube puzzles, such as the 2×2×3. I used rubik3 to enumerate them and generate optimal algorithms. My overall goal is to unite all the different solution techniques by reusing algorithms from smaller puzzles whenever possible.

2009 Aug 25

I have decided to perform a sticker-swap on my newest (1989) 4×4×4 Rubik's Revenge and one of my 5×5×5 Professor clones. Algorithms exist to rearrange most of the stickers just by turning the puzzle; I used the ones here.

It is interesting to note that the optimal algorithm for swapping two adjacent faces on the 4×4×4 can be found by emulating a 2×3×3 on a 3×3×3. Using the command:

rubik3 -N3 -GUF2f2L2R2 \ -PWWWWWWWWWOOOGGGRRRBBB------------OOOGGGRRRBBBYYYYYYYYY \ -PWWWWWWWWYOOOGRRGGRBBB------------OOOGRRGGRBBBYYWYYYYYY exact

The program gives the solution U2 F2 U' F2 U2 F2 U R2 U F2 U' R2 U R2 U2 (15f). Translating this to a 4×4×4, the algorithm becomes U122 F2 U12' F2 U122 F2 U12 R2 U12 F2 U12' R2 U12 R2 U122 (23s).

2009 Aug 27

My original algorithm for 3×3×3 corner positioning was the one from the Cranston West student:

To cycle (URF → LFD → UFL), use L' RFR'F' L FRF'R' (10f)

Translating this to work on the D layer, it is:

To cycle (FRD → LDB → FDL), use L' RDR'D' L DRD'R' (10f)

But a quicker algorithm that doesn't care about edges on the D layer is:

To cycle (DRF → DLF → DLB), use F'RF' L2 FR'F' L2 F2 (9f)

Translating this for use on the U layer, it is:

To cycle (ULF → URF → URB), use F'LF' R2 FL'F' R2 F2 (9f)

These are also useful for solving the 2×2×2.

### Improved 4×4×4 double-pair swap

For a long time I have been using the algorithm (R2F22)3 R2 (7s) to exchange the edge-pair at UR with that at DR. This algorithm also moves two centers from U to D and vice-versa. The centers can be put back with (F22R22)2 (4s), making (11s) total. As reported earlier, there is a combined algorithm using F12 moves that does it in (9s). However, today I realize that it is better to use F2 moves. This yields the improved algorithm:

F22R2 F22R132 F22R32 (7s) (Exchanges the edge-pair at UF with that at DF).

### Improved 4×4×4 dedge flip

Using rubik3, limiting the moves to those that are possible on a 3×3×4, I found the following algorithm to exchange the pieces at FRD and FRU (also called a "dedge flip" because the two pieces together are a "dedge" or "double edge"): D2'R2D2R2 U2'R2U22 F2D2F2D3 R2F2D22F2 (15s).

2009 Aug 28

Yesterday I found an algorithm for the 4×4×4 to to exchange the edge-pair at UF with that at DF (F22R2 F22R132 F22R32). It is even easier if you change the R13 to R12 and R3 to R2: F22R2 F22R122 F22R22 (7s)

Here is an algorithm for resolving a flipped edge pair from "AndrewG" (on twistypuzzles forum, 20081223) R2' U2R2U2R2' F2R2F2R2' B2R2'B2R2 (13s). It moves four of the edge-pairs around and also flips just one of them. Any of the standard 3×3×3 edge-moving algorithms, plus the 7s UF-DF swap, and the parity will stay fixed.

2009 Aug 29

### Updated Table of Algorithms

This table brings together all the algorithms I have ever learned and used for solving the cube. They are grouped by function in the following order: Corners, then Edges, then Centers; posiioning before orienting; "dirty" algorithms before "pure"; small cubes then larger cubes. I also list a few that I have not actually learned but believe that I should.

This table uses my "Extended Singmaster Notation".

 category cube algorithm length, description, notes pos. Co all L'RFR'F'LFRF'R' (10f) (URF, LFD, UFL+) pos. Co all (R'FRF')3 (12f) (FUR, RDF) (UFL, UBR) ori. Co (dirty) all R'D'RD'R'D2RD2 (8f) (DRF+) (DRB+) (DBL+) (DR, DF, DB) ori. Co all ((R'FRF')3[F][R])3 (36f) (URB+), (URF+), (DFR+) pos. E (dirty) 3+ R'D2RD'R'DRD2R'DR (11f) moves DL to FR and "scrambles" D layer pos. E (dirty) 4 R2F2R2F2'R2 (5s) (ULF, RUF) also flips (RD+), exchanges FR column with BR column, and moves 4 centers pos. E (dirty) 4 (F2RF2'R)4 F2 U2F2U2F2' (25s) (UL, UR, RB, DR, RF+) and moves 6 centers — used as a dedge flip pos. E 3+ (R2F2)3 (6f) (UF, DF) (UR, DR) pos. E 3+ (R'F2RF2)5 (20f) (UR, FL, FR) pos. E 3+ RsFRs'F2RsFRs' (7f) (FU, FR, FL) pos. E 3+ RU'(RU)2RU'R'U'R2 (11f) (UF, UR, UL) pos. E 4 F22R2 F22R122 F22R22 (6s) (UR, DR) pos. E 4 D2'R2D2R2 U2'R2U22 F2D2F2D3 R2F2D22F2 (15s). (FRD, FRU) optimal dedge flip on the 3×3×4 the only long algorithm worth memorizing for 4×4×4 solving pos. E 4 U2' RU'R' U2 RUR' (8s) joins FLU to FRD and joins FRU to UFL ori. E 3+ Rs'D2RsD'Rs'D RsD2 Rs'D2RsD Rs'D'RsD2 (16f) (DF+) (DR+) ori. E 3+ (RsU)2 RsU2 (Rs'U)2 Rs'U2 (12f) (UF+)(UB+) (U++)(D++)(F++)(B++) pos. Ce 4 (F2R2F2'R2)5 (20s) (UF, RB, RF) original 1982 algorithm pos. Ce 4 (F3R232F3'R2)2 (8s) (UF, RB, RF) commutator-based optimization of the 1982 alg. pos. Ce 4 ((R2Uw)2 R2Rw' F2Rw')2 (8s+8w) (FD, RD, FU) easier to learn and to execute quickly pos. Ce 4 (R22F22)2 (4s) (URF, DLF, DRB) (ULF, URB, DRF) usually used as if it swaps the UR pair with DR pos. Ce 4 (R22F22)2 UD' (R22F22)2 U'D (10s) Swaps all 4 U centers with D pos. Ce 5 R232F232 R232F2342 R22F42R22 (12s) Swaps all U centers except the central center with D (two-face target pattern) Added in 2015: ori. Ce 3,5 Rs'Us'RsURs'UsRsU' (8s) (U-)(L+) ori. Ce 3+ U2 F2 L' R D2 B2 F2 D2 R' L F2 D2 (12f) (U++)(D++)(F++)(B++) ori. Ce 3+ B R2 D2 L2 B' F U2 L2 D2 F' (10f) (U++)(R++) ori. Ce 3+ B F U' B' F' U2 F B U' F' B' U2 (12f) (U++)

2009 Aug 30

Using a full search, still without symmetry, rubik3 finds that 10s is the minimum for a pure algorithm to move 2 pairs of centers on the 4×4×4:

R2 D2 L2 B2 L2 D2 R2 F2 (8s) (moves the UF pair to R and the RF pair to U)

This is a great algorithm because it can be executed easily in the following way:

((R2Uw)2 R2Rw' F2Rw')2 (8s+8w)

This moves the FD pair onto R and the RD pair onto F, and is optimised for easy turning by a right-handed cubist.

## Emulating Cuboid Puzzles

Any standard cube can be used to emulate one or more smaller cubes and/or cube-like puzzles with non-cube rectangular dimensions. For example, if you have a 4×4×4 cube and limit your motions to those that turn an outer and inner layer at the same time (R12, F12, etc) you are "emulating" a 2×2×2 cube, and all patterns you get will be identical to patterns on the 2×2×2 (assuming you started with your 4×4×4 cube solved).

Using an odd-number sized cube (which includes the 3×3×3 and 5×5×5) you can emulate smaller puzzles that have an odd number of slices in each dimension. Using an even-number sized cube (like the 4×4×4) you can emulate any equal or smaller size in each dimension. For example, the 4×4×4 can emulate a 2×3×4 puzzle.

These are discussed in order with the smallest numbers at the beginning. For example, the 1×2×2 comes before the 2×2×2, then the 2×2×3. To ensure a specific ordering, each puzzle is named with smallest numbers first, so the 2×2×3 is not called a "2×3×2" or "3x2x2" even though those names really mean the same thing.

## 1×1×N Puzzles

Any 1×1×N puzzle is trivial to "solve" because the individual layers do not affect each other. Some 1×1×2 and 1×1×3 puzzles have been built by avid hobbyists:

MeMyselfAndPi's 1×1×2: watch

Kenneth Brandon's 1×1×3: watch

There is also a widely-distributed "Rubik's Cube L.E.D flashlight keyring" (search Google Images to find examples); I have a couple imprinted with a company logo that I got for free as a conference participant.

## 1×2×2

This size was the smallest "two dimensional" case discussed by Singmaster([1] pp 51-52), who was considering an imaginary flat (two-dimensional) "cube" with individually-reversible rows and columns and either one side (no distinction between front and back) or two.

Here is my 1×1×2, which is simply a Rubik's Ice Cube bandaged with sticky notes:

2×2×2 emulating a 1×2×2

A paper model is easy to build: it is just two pairs of cubes with some thread; the threads are wound around each other a couple times. As you can see in this video, if you turn it far enough in one direction the pieces come back apart.

Solution: The 1×2×2 is a little less trivial than the 1×1×N cases, but still extremely easy to solve. Because there are no fixed centers, the back-left cubie can be assumed to be in the correct position. There are 6 possible combinations and two valid moves: R2 and F2. By repeating these two moves in alternation you go through all 6 combinations. Thus, solving the puzzle takes no more than 5 moves, or 3 if you know which move to start with.

## 1×2×3

Here are two ways to emulate the 1×2×3: Using a normal 3×3×3 cube, cover a center vertical slice with black to "ignore" it, and cover the remainder of the four sides (not the top and bottom) with 3x1 strips. This "bandaging" will prevent you from making an "illegal" move (like a quarter-turn on a horizontal axis followed by trying to turn the vertical axis). To emulate the 1×2×3 without the ignored black regions, you need a 4×4×4. Here are both "bandaged" cubes, in an equivalent scrambled state:

two ways to emulate a 1×2×3

The picture illustrates a few different types of bandaging used to emulate these small puzzles on real cubes. The small cube uses 3→1 bandaging in the vertical axis. The large cube uses 4→1 bandaging in the vertical axis, 4→2+2→2 on the left-right axis, and 4→1+2+1→3 along the front-back axis. Notice in particular that these divisions of 4 all divide at different points, the result is that if you turn anything by 90o, you then cannot turn on another axis. The bandaged 2×2×3 behaves similarly, but see the 3×3×5 discussion for other possibilities.

Notation: Pictured are the U, F and R faces. Listed clockwise from the very back, the six pieces are called LB, RB, R, RF, LF, and L. All turns are 180o and are indicated with the superscript 2 to retain consistency with other puzzles.

The 1×2×3 has six pieces and at any point you have three choices of what to turn. There are two center or "center-edge" pieces and four corner pieces. One of the centers can be assumed to be in the correct position (and therefore, the other one is too). All 4!=24 permutations of the corners are possible, and each corner's orientation is determined by its position. In addition one of the centers can be flipped with respect to the other, giving 24×2 = 48 combinations. No position is more than 6 moves from the start.

Solution: The 1×2×3 is arguably the simplest puzzle that takes any kind of "technique" to solve:

1. If L and R are reversed, turn the whole cube around. If L is now upside down, do L2.

2. Find the piece that belongs at LF. If it is at RF, do F2. If it is at RB, do R2F2. If it is at LB, do B2R2F2.

3. Find the piece that belongs at RF. If it is at RB, do R2. If it is at LB, do B2R2.

4. If the pieces at RB and LB are reversed, do B2.

5. If the piece at R is now upside down, use the single center piece flip algorithm: R2 F2 R2 F2 R2 F2.

Here is a video of someone speedsolving a 1×2×3

## 1×2×7

Here is a video of a 1×2×7.

## 1×2×13

Here is a video of a working 1×2×13 puzzle. Photos are here (and you can even order one if you want). There are 26 pieces, most of them with long "feet" that extend all the way into the interior of the central layer.

## 1×3×3

As of 2009, a well-made commercial version is being sold from Japan, and called the "floppy cube". It is also one of the easiest to emulate with a bandaged 3×3×3:

3×3×3 emulating a 1×3×3

This video shows a 1×3×3 made out of 9 loose cubes with magnets. With practice, a magnetic "cube" can be operated as if it were a true mechanical "cube".

This size was one of the "two dimensional" cases discussed by Singmaster, who pointed out that it was equivalent to using only the turns [ L2, R2, F2, B2 ] on a 3×3×3 cube.

The center cubie and the four edge cubies don't move, just like the centers on a 3×3×3 cube, so we can assume they are already in the proper position (although the edges can flip). Each turn swaps a pair of corners and flips an edge over — so we can get any permutation of the corners, but the parity of the permutation is equal to the parity of the flips of the edges. The orientation of the corners is purely determined by their position — every time a corner moves to an adjacent spot, it flips over, so the corner is "right-side up" if it is in its home position or in the opposite corner, and "upside down" if it is in one of the other two corners. So we get 4!=24 combinations for the corners, times 24 for the orientations of the edges, divided by two for the parity constraint, for 24×16/2=192 total combinations.

No position is more than 8 moves from the solved state, and the average number of moves needed is 4.43. The "all alternating" or "checkerboard" pattern L2R2B2F2 (4f) is the closest local maximum.

Notation: We will assume the cube is being held "flat", so the Up and Down faces are the 3×3 sides.

mrob27 s.11