Picking Through Possibilities One Pin at a Time

There’s a moment when you’re working a lock where everything goes wrong at once. You had three pins set—you could feel them sitting on the shear line—and then you shifted the tension wrench a fraction of a millimetre and they all dropped. Back to zero.

Backtracking algorithms know this feeling intimately.

The technique emerged from constraint satisfaction research in the early 1970s, formalized by researchers trying to solve problems that branched into impossible configurations. The eight queens puzzle. Graph colouring. Sudoku, decades before anyone called it that. The insight: instead of checking every possibility exhaustively, explore one path at a time, and the moment you detect a dead end, back up and try a different branch.

A pin tumbler lock works the same way. You apply light rotational tension, then probe each pin in sequence. If you feel binding, you push—either the pin sets, or you’ve hit a spool and your tension was wrong. Overset a pin? You’ve broken the constraint. Release tension, let the pins reset, start again. The physical feedback loop mirrors the algorithmic one: commit tentatively, detect failure early, retreat efficiently.

function pickLock(pins, set = [], tension = 0) {
  if (set.length === pins.length) return set;
  const pin = pins[set.length];
  for (let height of pin.tryHeights) {
    if (height <= pin.shearLine + tension) {
      const result = pickLock(pins, [...set, height], tension + 0.1);
      if (result) return result;
    }
  }
  return null; // backtrack
}

Erlang’s pattern matching makes the backtracking even more explicit—each clause is a commitment, each failure triggers the next attempt:

pick([]) -> solved;
pick([{Pin, Heights} | Rest]) ->
    try_heights(Heights, Pin, Rest).

try_heights([], _, _) -> backtrack;
try_heights([H | Hs], Pin, Rest) ->
    case H =< Pin#pin.shear of
        true -> case pick(Rest) of solved -> solved; _ -> try_heights(Hs, Pin, Rest) end;
        false -> try_heights(Hs, Pin, Rest)
    end.

The elegance of backtracking is that it admits defeat gracefully. No sunk-cost stubbornness—if the current path can’t work, abandon it immediately. My bent hook from yesterday’s practice session could learn something from this. I kept pushing on that fifth pin long after I’d lost pins two through four. The algorithm would’ve let go. I didn’t.

Tomorrow: I try again. The lock hasn’t changed. Maybe I have.