The Easiest Method for Beginners

The Easiest^(*) Method for Beginners
^(*) Or maybe the worst...

It's perfectly possible to solve a Rubik's Cube using common intuition and simple rules.
Usually, people can solve one layer by themselves. If you can do it, you (almost) can solve the whole cube.

No mysterious magical sequences required. If you understand how it works, you'll remember it forever.
No need to learn any notation, the animated cubes will show you the basic moves you need.
No mathematical formulae (group theory principles explained here), I'll try to make it intuitive.

This page is not about efficient solving.

If you think this page is not very helpful, you should take a look at Jasmine's beginner page where a more conventional approach is proposed.

Solving the first layer

It seems that everybody can do it using common intuition. It can take some time if it's your first try.
Your cube should now look like this:

Manipulating the first layer

You just built a layer starting from a random state. So, you should not have any problem making transformations of this layer.
Look at the following basic moves. You can do them differently, it doesn't matter.

Rotate a corner	Rotate an edge
Swap two corners	Swap two edges

Do you have problems understanding them? Don't go to the next section before you can master these easy moves (or the ones you found) allowing you to change pieces of the first layer easily.

Rearranging the first layer without disturbing the others

Once a first layer is solved, freedom of movement is reduced, and people can't see what they can do without destroying it. You have to find a way of moving only selected cubies, preserving the state of others (local transformation).

Take the first basic move that rotates a corner for example. What's the problem with it? It destroys the two lower layers of course. Do it backwards, the cube is restored.

Doing a move

Undoing a move

But what happened at the end of the move? Think of it this way:
- Pieces of the first layer have been rearranged.
- Pieces of the two lower layers have been rearranged.
- Pieces of the first layer and pieces of the two lower layers are still separated.
- Undoing the move will independently restore the state of the first layer and the state of the two lower layers.

And now, the cornerstone of this method. Try this:
- Do a move that rearranges pieces of the first layer. Call it X.
- Move the first layer. Call it Y.
- Undo X. Call it X'.
- Undo Y (only a matter of readjusting the first layer). Call it Y'.

Since the two lower layers and their chaos have not been changed by Y, X' can still restore them to their original state!
But the first layer has moved, it won't be restored with X'. The backward transformation will be applied to a different part of it.

We have reached our goal: Making (local) transformations in a layer, without disturbing the others.

Example:
- X is a clockwise corner rotation move.
- Y is a clockwise turn of the first layer.
- X' is a counter-clockwise corner rotation move.
- Y' is a counter-clockwise turn.
Result: Two corners in the first layer have been rotated (different directions).

Thanks to the four basic moves, we can build four interesting local transformations of the first layer.

Basic move (X)	Result of the commutator (X.Y.X'.Y')	Example
Rotate a corner	Rotate two corners
Rotate an edge	Rotate two edges
Swap two corners	Swap three corners
Swap two edges	Swap three edges

Changing pieces belonging to different layers

The pieces on which a local transformation must be applied do not always belong to the same layer. You'll have to bring them to a same layer first with a positioning move:
- Make interesting pieces belong to the first layer. Call it P.
- X.Y.X'.Y'.
- Undo the positioning move. Call it P'.

Example: Permutation of three edges.
- Move the front side and then the right side to bring edges to up-front and up-right (P).
- Apply the three-edge swapping technique (based on X.Y.X'.Y').
- Move the right side and then the front side back to their original positions (P').

That's all you need to solve the 3x3x3 cube.

Solving example on a random cube

Let's solve a cube completely.
I don't detail how the first layer is built, you can do it, even if it takes more moves.

One by one, the edges of the second layer are positioned, using exclusively sequences that swap three edges. Red-green edge is easy, because in the same layer, you can find its destination and another free edge position. Same thing for red-blue and green-orange. It's more difficult for the blue-orange edge. A positioning move brings blue-orange, it's destination position, and another free position to the same layer. This move is undone at the end of the sequence.

Now, the last layer. You'll notice that only the blue-white-red corner is at a correct place, the three others must be swapped. Then, three edges are swapped, because the white-red edge only is where it needs to be. Finally, we have to fix the orientations.

Improvements

Working with slices

All the examples above were based on working with a side of the cube. You can apply the same rules to inner slices as well.
X must be a move that rearranges pieces of a slice, and Y a move of this slice.

Example: Permutation of three edges in a slice.
- Swap up-front and up-back edges (X).
- Move center slice (Y).
- Swap up-front and up-back edges again (X'=X).
- Move center slice back (Y').

Different kinds of pieces

For now, we've only worked with corners or edges, but never both kinds of pieces at the same moment. Why not? It's exactly the same principle. On the example, two corner-edge blocks are removed from the first layer and swapped.

More interesting commutators

In order to make things clear for beginners, I described a technique based on changing things in a single layer. But commutators can be much more powerful.
Try to see how and why they work. Hint: The Y move doesn't compromise any pieces but the ones we need to move.

Swap three corners

Swap three edges

Same random cube, but optimized solving

Now we'll make use of some improvements.

Green-orange and green-red edges can be solved simulaneously with a commutator based on a slice, after an easy positioning.
Then I decided to swap three corners in an efficient way.
Two edges again: Green-white and blue-orange.
Then, the three last edges at a wrong place are moved.
In the end, two misoriented edges are fixed.

Once the first layer is completed, everything is based on an identical strategy: P.X.Y.X'.Y'.P'.

Return to home