Commutators and conjugates
The two patterns behind most algorithms, and how to build your own.
A commutator [A, B] = A B A' B' does A, then B, then undoes A, then undoes B. If A and B overlap in only a few pieces, everything else returns to where it was. That is how a 3-cycle of three corners can leave the rest of the cube untouched.
[R U R', D]
A corner 3-cycle: R U R' moves one top corner to the bottom; D swaps which bottom corner it meets; undoing both moves three corners round. (8 HTM)
Checked by the engine: [R U R', D] → 3 corners moved, 0 edges moved, 0 centers moved
After [R U R', D]: three corners cycled, everything else solved.
Checked by the engine: 3 corners moved, 0 edges moved, 0 centers moved
[R U R', D]
A conjugate [A: B] = A B A' sets pieces up (A), does something to them (B), and puts them back (A'). Algorithms are often conjugates of shorter ones: F (R U R' U') F' is the 'sexy move' conjugated by F, and it orients edges.
[F: R U R' U']
F R U R' U' F': the line OLL, a conjugate of the 'sexy move'. (6 HTM)
Checked by the engine: [F: R U R' U'] → oll-solved
Blindfolded solvers and fewest-moves solvers build commutators on the spot; speedsolvers mostly meet them inside algorithms. Recognising the pattern makes algorithms easier to remember: you learn two short pieces instead of a long string.