Learn · the 4×4
Parity, and why it happens
Two positions a 4×4 can reach that a 3×3 never can. Neither is your fault, both have a cure, and the reason they exist is worth five minutes. One extra move creates both of them.
You have built the centres, joined the wings, and solved the puzzle down to its last layer as though it were a 3×3. Then it hands you something impossible: a single edge turned the wrong way round, or two edges that need to change places with everything else already home. You try every last-layer algorithm you know and none of them helps, because none of them can. The position you are looking at cannot occur on a 3×3 at all.
The reason is the move a 3×3 does not have. Turning an inner layer on its own, written 2R, moves four wings round in a single cycle and leaves every corner exactly where it was. Every ordinary face turn moves its wings round in two cycles instead. That difference sounds like bookkeeping and it is the whole of parity: an inner-layer quarter turn makes an odd rearrangement of the wings, and no face turn ever can. Once you have built the centres you have given up inner-layer quarter turns, so if the wings are oddly arranged, nothing in your 3×3 method will ever put them right.
The two things that go wrong are cleanly different, and it is worth seeing why.
A single turned-around edge. On a 3×3 the number of turned-around edges is always even, because flipping one flips another somewhere. On a 4×4 an edge is two wings, and turning that edge around just means its two wings have swapped, which is an odd rearrangement. So one alone is possible here and impossible there.
Two edges that need swapping. On a 3×3 the edges and the corners are locked together: any turn shifts both in step, so if the corners are home the edges cannot be one swap away from home. On a 4×4 an inner-layer turn moves edges without touching a single corner, so the two can drift out of step, and a 3×3 method has no move that would bring them back.
The turned-around edge
This turns up while you are orienting the last layer: a pattern that is not in the book, because one edge is facing the wrong way. Hold the cube so the offending edge is at the front of the top layer, and run this.
2R2 B2 U2 2L U2 2R' U2 2R U2 F2 2R F2 2L' B2 2R2
Fifteen moves, and worth walking through slowly the first time. It turns exactly one edge around and leaves every other piece of the cube where it was: 0 corners moved, 0 centres moved, 2 wings moved , and those two wings are the two halves of the edge you are fixing, trading places. Run it a second time and the cube returns to exactly where it started, so a misplaced attempt costs you nothing but time.
Once the edge is the right way round, carry on with the last layer as normal.
The two edges that will not swap
This one appears at the very end: the cube is finished except for two edges in each other's places. Hold it so those two edges are the front and back of the top layer.
2R2 U2 2R2 Uw2 2R2 Uw2 U2
Seven moves. It swaps those two edges completely, all four wings travel, in their pairs — and leaves the corners and the centres exactly as they were: 0 corners and 0 centres disturbed. Like the other one, it undoes itself if you run it twice.
A note on that algorithm, because you will see it written differently elsewhere. The version usually quoted is the first six moves, 2R2 U2 2R2 Uw2 2R2 Uw2, and on its own it is not a clean swap: it drags 4 corners along with it. Cubers absorb that damage into whatever last-layer algorithm they were about to do anyway, which is efficient and slightly confusing to learn from. Adding a single U2 at the end cancels the corner damage exactly, and what is left does one job only.
Both cases keep the centres intact, which is what makes them usable part-way through the last layer rather than something you have to plan around. And neither is avoidable: about half of all scrambles will hand you one. Faster solvers stop treating it as an interruption.
The coaching pages apply here without change, and the timer will keep your 4×4 times separately from your 3×3 ones.
The 4x4 engine behind these pages is checked against the 3x3 engine on every move the two puzzles share, so a disagreement between them fails the build. Both parity algorithms are then measured rather than trusted: each is applied to a solved cube and every piece is compared with where it belongs, and each is confirmed to undo itself. The animations run on a separate engine written in JavaScript, held to the same answers by the same tests, so the cube a reader watches cannot contradict the cube that did the checking.