Accepting Worse Before Better

The tumbler’s been running for six days now. Coarse grit stage. Through the basement floor I can hear the rocks colliding—random, chaotic, productive in their violence.

In 1983, Kirkpatrick, Gelatt, and Vecchi published a paper that borrowed an idea from metallurgy. When you anneal metal, you heat it until the atoms can move freely, then cool it slowly so they settle into a low-energy crystalline structure. Cool too fast and you trap defects. The insight: optimization works the same way.

Simulated annealing starts hot. At high temperature, the algorithm accepts worse solutions freely—wandering uphill, escaping local minima, refusing to commit. As temperature drops, it grows more conservative. Eventually it freezes into whatever state it’s found.

Here’s the trick: accepting worse answers is the whole point. A greedy algorithm that only moves downhill gets stuck in the first valley it finds. Annealing explores.

def anneal(state, temp: 1000.0, cooling: 0.995, steps: 5000)
  current_energy = yield(state)
  steps.times do
    candidate = state.map { |x| x + rand(-1.0..1.0) }
    candidate_energy = yield(candidate)
    if candidate_energy < current_energy || rand < Math.exp((current_energy - candidate_energy) / temp)
      state, current_energy = candidate, candidate_energy
    end
    temp *= cooling
  end
  state
end

result = anneal([5.0, 5.0]) { |s| s[0]**2 + s[1]**2 }  # finds ~[0,0]

The Math.exp(...) term is the Boltzmann factor—at high temperatures, even bad moves pass. As temp drops toward zero, only improvements survive.

#include <math.h>
#include <stdlib.h>

double anneal(double x, double (*f)(double)) {
    double temp = 1000.0, best = x;
    for (int i = 0; i < 5000; i++) {
        double candidate = x + ((rand() / (double)RAND_MAX) - 0.5) * 2.0;
        double delta = f(candidate) - f(x);
        if (delta < 0 || (rand() / (double)RAND_MAX) < exp(-delta / temp))
            x = candidate;
        if (f(x) < f(best)) best = x;
        temp *= 0.995;
    }
    return best;
}

The C version is tighter but the logic identical: propose a random step, accept it probabilistically based on temperature and improvement.

My barrel contains jasper, agate, some mystery quartz. Right now they’re sharp, pitted, dull. The 60-grit silicon carbide is tearing off edges, making everything temporarily worse—rougher, muddier. That’s the hot phase. Week two will be 120 grit. Then 220. Then polish. Each stage cools the chaos, narrows the acceptable moves, until finally the stones can only get shinier.

Four weeks of controlled randomness. The algorithm and the barrel are doing the same job: accepting damage in service of an optimum you can’t reach by careful steps alone.