Where Simulated Annealing Matters

Introduction

A bar of steel pulled from a furnace is not immediately useful. A blacksmith heats it to a glowing orange, hammers it into shape, and lets it cool slowly. Cool too fast and the metal locks into a brittle crystal. Cool slowly, and the atoms have time to find a low-energy arrangement — strong, ordered, useful.

Simulated annealing borrows this physical process to solve mathematical problems. In 1983, physicists Scott Kirkpatrick, C. D. Gelatt Jr. and Mario Vecchi published a landmark paper in Science showing that optimization problems — finding the shortest route, the lightest circuit layout, the best schedule — can be attacked by mimicking the cooling of molten metal.

The core idea is disarmingly simple. Suppose you are trying to minimize some cost — say, the length of a route through a set of cities. A naive strategy is hill climbing: always take a step that makes things better. The problem is that hill climbing gets stuck. It finds a local minimum — a solution better than all its neighbors — and stops, even though a much better global minimum might lie just over the next hill.

Simulated annealing adds a thermometer. At high temperature, the algorithm is adventurous: it will accept a worse move with high probability, shaking itself free of local traps. As the temperature falls, it becomes more conservative, eventually settling only into genuine improvements. If the cooling is slow enough, the result is a near-optimal solution.

There is no polynomial-time guarantee. Simulated annealing is a metaheuristic — a strategy for attacking NP-hard problems like the Traveling Salesman Problem when exact methods are hopeless. It trades provable optimality for practical speed, and for many real-world problems it delivers excellent solutions in reasonable time.

Watch a Tour Untangle

Below are 20 cities scattered at random. The algorithm starts with a random tour (the red path connecting all cities) and tries to shorten it by simulated annealing. At each step it picks two random edges, considers swapping them (2-opt move), and accepts the swap immediately if it shortens the tour — or with a shrinking probability if it makes the tour longer.

<div class="controls">
  <button id="annealBtn" type="button">Anneal</button>
  <button id="resetBtn" type="button" class="ghost">New cities</button>
  <span class="temp-label">T = <span id="tempVal">—</span></span>
</div>
<canvas id="canvas" width="460" height="300"></canvas>
<div class="stats">
  <span>Tour length: <b id="tourLen">—</b></span>
  <span>Best: <b id="bestLen">—</b></span>
  <span id="statusMsg"></span>
</div>

* { box-sizing: border-box; }
body { font-family: system-ui, sans-serif; margin: 0; color: #222; background: #fff; }
.controls { display: flex; align-items: center; gap: .6rem; flex-wrap: wrap; margin-bottom: .5rem; }
button { font: 600 13px system-ui; padding: .4rem .85rem; border: 1px solid #1d3557;
         background: #1d3557; color: #fff; border-radius: 7px; cursor: pointer; }
button.ghost { background: #fff; color: #1d3557; }
button:disabled { opacity: .45; cursor: default; }
.temp-label { font: 600 13px ui-monospace, monospace; color: #555; margin-left: .3rem; }
canvas { display: block; border: 1px solid #d0d7de; border-radius: 8px; background: #f8fafc;
         max-width: 100%; }
.stats { display: flex; gap: 1.2rem; flex-wrap: wrap; margin-top: .45rem;
         font-size: .88rem; color: #444; }
.stats b { color: #1d3557; }
#statusMsg { font-weight: 600; color: #0a7d33; }

const fmt = (s, v) => s.replace(/%(\w+)%/g, (_, k) => String(v[k] ?? ''));
// Simulated Annealing for TSP (2-opt moves).
// Acceptance: exp(-delta / T). Temperature schedule: geometric T *= alpha each step.
const N_CITIES = 20;
const W = 460, H = 300, PAD = 22;
const canvas = document.getElementById('canvas');
const ctx = canvas.getContext('2d');

let cities = [], tour = [], bestTour = [], bestLen = Infinity;
let animId = null, running = false;

// ── Utilities ──────────────────────────────────────────────────────────────
function dist(a, b) {
  const dx = a[0]-b[0], dy = a[1]-b[1];
  return Math.sqrt(dx*dx + dy*dy);
}
function tourLength(t) {
  let s = 0;
  for (let i = 0; i < t.length; i++) s += dist(cities[t[i]], cities[t[(i+1)%t.length]]);
  return s;
}
function randInt(lo, hi) { return lo + Math.floor(Math.random() * (hi - lo)); }

// ── Initialization ─────────────────────────────────────────────────────────
function initCities() {
  cities = [];
  for (let i = 0; i < N_CITIES; i++)
    cities.push([PAD + Math.random()*(W-2*PAD), PAD + Math.random()*(H-2*PAD)]);
  tour = Array.from({length: N_CITIES}, (_, i) => i);
  // shuffle
  for (let i = tour.length-1; i > 0; i--) {
    const j = randInt(0, i+1);
    [tour[i], tour[j]] = [tour[j], tour[i]];
  }
  bestTour = tour.slice();
  bestLen = tourLength(tour);
}

// ── Drawing ────────────────────────────────────────────────────────────────
function draw(t, temperature) {
  ctx.clearRect(0, 0, W, H);
  // Tour path
  const hot = Math.max(0, Math.min(1, temperature / 500));
  // Gradient red(hot) -> blue(cold)
  const r = Math.round(hot * 200 + (1-hot) * 29);
  const g = Math.round(hot * 40  + (1-hot) * 100);
  const b = Math.round(hot * 40  + (1-hot) * 200);
  ctx.strokeStyle = `rgb(${r},${g},${b})`;
  ctx.lineWidth = 1.6;
  ctx.beginPath();
  ctx.moveTo(cities[t[0]][0], cities[t[0]][1]);
  for (let i = 1; i < t.length; i++) ctx.lineTo(cities[t[i]][0], cities[t[i]][1]);
  ctx.closePath();
  ctx.stroke();
  // City dots
  for (let i = 0; i < cities.length; i++) {
    ctx.beginPath();
    ctx.arc(cities[i][0], cities[i][1], 4, 0, Math.PI*2);
    ctx.fillStyle = '#1d3557';
    ctx.fill();
  }
}

function updateUI(len, T) {
  document.getElementById('tourLen').textContent = len.toFixed(1);
  document.getElementById('bestLen').textContent = bestLen.toFixed(1);
  document.getElementById('tempVal').textContent = T < 0.01 ? T.toExponential(1) : T.toFixed(1);
}

// ── Annealing ──────────────────────────────────────────────────────────────
function anneal() {
  if (running) return;
  running = true;
  document.getElementById('annealBtn').disabled = true;
  document.getElementById('statusMsg').textContent = '';

  let T = 800;       // initial temperature
  const alpha = 0.992; // cooling rate
  const stepsPerFrame = 120;
  let currentLen = tourLength(tour);

  function step() {
    for (let s = 0; s < stepsPerFrame; s++) {
      // 2-opt: pick two distinct indices i < j, reverse segment [i+1..j]
      let i = randInt(0, N_CITIES - 1);
      let j = randInt(i + 1, N_CITIES);
      if (j - i < 2) { T *= alpha; continue; }

      // Delta for reversing tour[i+1..j]
      const a = tour[i], b = tour[(i+1) % N_CITIES];
      const c = tour[j], d = tour[(j+1) % N_CITIES];
      const before = dist(cities[a], cities[b]) + dist(cities[c], cities[d]);
      const after  = dist(cities[a], cities[c]) + dist(cities[b], cities[d]);
      const delta = after - before;

      if (delta < 0 || Math.random() < Math.exp(-delta / T)) {
        // Accept: reverse the segment
        let lo = i + 1, hi = j;
        while (lo < hi) { [tour[lo], tour[hi]] = [tour[hi], tour[lo]]; lo++; hi--; }
        currentLen += delta;
      }
      T *= alpha;
    }

    if (currentLen < bestLen) {
      bestLen = currentLen;
      bestTour = tour.slice();
    }

    draw(tour, T);
    updateUI(currentLen, T);

    if (T > 0.1) {
      animId = requestAnimationFrame(step);
    } else {
      // Show best
      tour = bestTour.slice();
      currentLen = bestLen;
      draw(tour, 0);
      updateUI(currentLen, 0);
      document.getElementById('statusMsg').textContent = '✓ Done — best tour shown';
      document.getElementById('annealBtn').disabled = false;
      running = false;
    }
  }
  animId = requestAnimationFrame(step);
}

function reset() {
  if (animId) { cancelAnimationFrame(animId); animId = null; }
  running = false;
  document.getElementById('annealBtn').disabled = false;
  document.getElementById('statusMsg').textContent = '';
  initCities();
  draw(tour, 800);
  updateUI(tourLength(tour), 800);
}

document.getElementById('annealBtn').addEventListener('click', anneal);
document.getElementById('resetBtn').addEventListener('click', reset);

// Boot
initCities();
draw(tour, 800);
updateUI(tourLength(tour), 800);

// Verify core SA logic (runs in node too)
// assert: accepting a worse move when T is high has probability close to 1
const p_high = Math.exp(-1 / 800);   // delta=1, T=800 → p ≈ 0.9987
const p_low  = Math.exp(-1 / 0.1);   // delta=1, T=0.1  → p ≈ 5e-5
console.assert(p_high > 0.99, fmt('High-T acceptance should be > 0.99, got %p_high%', { p_high: p_high }));
console.assert(p_low  < 0.01, fmt('Low-T acceptance should be < 0.01, got %p_low%', { p_low: p_low }));
console.log(fmt('SA acceptance probabilities: T=800 p=%p_high%, T=0.1 p=%toExponential%', { p_high: p_high.toFixed(4), toExponential: p_low.toExponential(2) }));

<div class="controls">
  <button id="annealBtn" type="button">Anneal</button>
  <button id="resetBtn" type="button" class="ghost">New cities</button>
  <span class="temp-label">T = <span id="tempVal">—</span></span>
</div>
<canvas id="canvas" width="460" height="300"></canvas>
<div class="stats">
  <span>Tour length: <b id="tourLen">—</b></span>
  <span>Best: <b id="bestLen">—</b></span>
  <span id="statusMsg"></span>
</div>

* { box-sizing: border-box; }
body { font-family: system-ui, sans-serif; margin: 0; color: #222; background: #fff; }
.controls { display: flex; align-items: center; gap: .6rem; flex-wrap: wrap; margin-bottom: .5rem; }
button { font: 600 13px system-ui; padding: .4rem .85rem; border: 1px solid #1d3557;
         background: #1d3557; color: #fff; border-radius: 7px; cursor: pointer; }
button.ghost { background: #fff; color: #1d3557; }
button:disabled { opacity: .45; cursor: default; }
.temp-label { font: 600 13px ui-monospace, monospace; color: #555; margin-left: .3rem; }
canvas { display: block; border: 1px solid #d0d7de; border-radius: 8px; background: #f8fafc;
         max-width: 100%; }
.stats { display: flex; gap: 1.2rem; flex-wrap: wrap; margin-top: .45rem;
         font-size: .88rem; color: #444; }
.stats b { color: #1d3557; }
#statusMsg { font-weight: 600; color: #0a7d33; }

const fmt = (s, v) => s.replace(/%(\w+)%/g, (_, k) => String(v[k] ?? ''));
// Simulated Annealing for TSP (2-opt moves).
// Acceptance: exp(-delta / T). Temperature schedule: geometric T *= alpha each step.
const N_CITIES = 20;
const W = 460, H = 300, PAD = 22;
const canvas = document.getElementById('canvas');
const ctx = canvas.getContext('2d');

let cities = [], tour = [], bestTour = [], bestLen = Infinity;
let animId = null, running = false;

// ── Utilities ──────────────────────────────────────────────────────────────
function dist(a, b) {
  const dx = a[0]-b[0], dy = a[1]-b[1];
  return Math.sqrt(dx*dx + dy*dy);
}
function tourLength(t) {
  let s = 0;
  for (let i = 0; i < t.length; i++) s += dist(cities[t[i]], cities[t[(i+1)%t.length]]);
  return s;
}
function randInt(lo, hi) { return lo + Math.floor(Math.random() * (hi - lo)); }

// ── Initialization ─────────────────────────────────────────────────────────
function initCities() {
  cities = [];
  for (let i = 0; i < N_CITIES; i++)
    cities.push([PAD + Math.random()*(W-2*PAD), PAD + Math.random()*(H-2*PAD)]);
  tour = Array.from({length: N_CITIES}, (_, i) => i);
  // shuffle
  for (let i = tour.length-1; i > 0; i--) {
    const j = randInt(0, i+1);
    [tour[i], tour[j]] = [tour[j], tour[i]];
  }
  bestTour = tour.slice();
  bestLen = tourLength(tour);
}

// ── Drawing ────────────────────────────────────────────────────────────────
function draw(t, temperature) {
  ctx.clearRect(0, 0, W, H);
  // Tour path
  const hot = Math.max(0, Math.min(1, temperature / 500));
  // Gradient red(hot) -> blue(cold)
  const r = Math.round(hot * 200 + (1-hot) * 29);
  const g = Math.round(hot * 40  + (1-hot) * 100);
  const b = Math.round(hot * 40  + (1-hot) * 200);
  ctx.strokeStyle = `rgb(${r},${g},${b})`;
  ctx.lineWidth = 1.6;
  ctx.beginPath();
  ctx.moveTo(cities[t[0]][0], cities[t[0]][1]);
  for (let i = 1; i < t.length; i++) ctx.lineTo(cities[t[i]][0], cities[t[i]][1]);
  ctx.closePath();
  ctx.stroke();
  // City dots
  for (let i = 0; i < cities.length; i++) {
    ctx.beginPath();
    ctx.arc(cities[i][0], cities[i][1], 4, 0, Math.PI*2);
    ctx.fillStyle = '#1d3557';
    ctx.fill();
  }
}

function updateUI(len, T) {
  document.getElementById('tourLen').textContent = len.toFixed(1);
  document.getElementById('bestLen').textContent = bestLen.toFixed(1);
  document.getElementById('tempVal').textContent = T < 0.01 ? T.toExponential(1) : T.toFixed(1);
}

// ── Annealing ──────────────────────────────────────────────────────────────
function anneal() {
  if (running) return;
  running = true;
  document.getElementById('annealBtn').disabled = true;
  document.getElementById('statusMsg').textContent = '';

  let T = 800;       // initial temperature
  const alpha = 0.992; // cooling rate
  const stepsPerFrame = 120;
  let currentLen = tourLength(tour);

  function step() {
    for (let s = 0; s < stepsPerFrame; s++) {
      // 2-opt: pick two distinct indices i < j, reverse segment [i+1..j]
      let i = randInt(0, N_CITIES - 1);
      let j = randInt(i + 1, N_CITIES);
      if (j - i < 2) { T *= alpha; continue; }

      // Delta for reversing tour[i+1..j]
      const a = tour[i], b = tour[(i+1) % N_CITIES];
      const c = tour[j], d = tour[(j+1) % N_CITIES];
      const before = dist(cities[a], cities[b]) + dist(cities[c], cities[d]);
      const after  = dist(cities[a], cities[c]) + dist(cities[b], cities[d]);
      const delta = after - before;

      if (delta < 0 || Math.random() < Math.exp(-delta / T)) {
        // Accept: reverse the segment
        let lo = i + 1, hi = j;
        while (lo < hi) { [tour[lo], tour[hi]] = [tour[hi], tour[lo]]; lo++; hi--; }
        currentLen += delta;
      }
      T *= alpha;
    }

    if (currentLen < bestLen) {
      bestLen = currentLen;
      bestTour = tour.slice();
    }

    draw(tour, T);
    updateUI(currentLen, T);

    if (T > 0.1) {
      animId = requestAnimationFrame(step);
    } else {
      // Show best
      tour = bestTour.slice();
      currentLen = bestLen;
      draw(tour, 0);
      updateUI(currentLen, 0);
      document.getElementById('statusMsg').textContent = '✓ Done — best tour shown';
      document.getElementById('annealBtn').disabled = false;
      running = false;
    }
  }
  animId = requestAnimationFrame(step);
}

function reset() {
  if (animId) { cancelAnimationFrame(animId); animId = null; }
  running = false;
  document.getElementById('annealBtn').disabled = false;
  document.getElementById('statusMsg').textContent = '';
  initCities();
  draw(tour, 800);
  updateUI(tourLength(tour), 800);
}

document.getElementById('annealBtn').addEventListener('click', anneal);
document.getElementById('resetBtn').addEventListener('click', reset);

// Boot
initCities();
draw(tour, 800);
updateUI(tourLength(tour), 800);

// Verify core SA logic (runs in node too)
// assert: accepting a worse move when T is high has probability close to 1
const p_high = Math.exp(-1 / 800);   // delta=1, T=800 → p ≈ 0.9987
const p_low  = Math.exp(-1 / 0.1);   // delta=1, T=0.1  → p ≈ 5e-5
console.assert(p_high > 0.99, fmt('High-T acceptance should be > 0.99, got %p_high%', { p_high: p_high }));
console.assert(p_low  < 0.01, fmt('Low-T acceptance should be < 0.01, got %p_low%', { p_low: p_low }));
console.log(fmt('SA acceptance probabilities: T=800 p=%p_high%, T=0.1 p=%toExponential%', { p_high: p_high.toFixed(4), toExponential: p_low.toExponential(2) }));

Result

Console

Watch what happens: at high temperature the tour thrashes wildly, accepting detours that look terrible. As the temperature falls the improvements stabilize, crossing edges untangle, and the final tour is far shorter than the random starting point. Press Anneal again for a different random instance — the algorithm nearly always finds a good solution, but the path it takes differs every time.

The Real Complexity

Simulated annealing is not a magic bullet — understanding what it can and cannot guarantee is essential.

No optimality certificate. Unlike exact algorithms for special cases (Dijkstra for shortest path, the simplex method for LP), simulated annealing gives no proof that its answer is optimal. It is a heuristic.
Convergence in theory requires infinite time. The classical result (Geman & Geman, 1984) says: if you cool at a rate no faster than $T(t) = \frac{C}{\log(1+t)}$ — logarithmically slowly — the algorithm converges in probability to a global optimum. That schedule is so slow it is useless in practice.
In practice, geometric cooling works. Real implementations use $T(t) = T_0 \cdot \alpha^t$ where $\alpha \approx 0.99$ , cutting temperature by 1% each step. This is fast enough to be practical, but the optimality guarantee vanishes.
The underlying problems are NP-hard. Traveling Salesman, graph coloring, VLSI placement — these belong to the class of problems for which no polynomial-time exact algorithm is known. Simulated annealing does not solve NP-hardness; it approximates it under a time budget.
Why it escapes local minima. The acceptance probability for a worse move is $\exp(-\Delta E / T)$ . At high $T$ this is close to 1 — almost any move is accepted. At low $T$ it approaches 0, so only strict improvements are taken. The parameter $T$ is the single knob that controls the explore-exploit tradeoff.

The insight that connects this to statistical physics is deep: the probability distribution over states converges to a Boltzmann distribution at each temperature, and the global optimum is the ground state. Annealing slowly is a physical simulation of finding that ground state.

Where It Matters

Simulated annealing became an immediate sensation after the 1983 paper because it solved a real industrial problem — VLSI chip placement — and beat specialized heuristics of the time. Its influence spread quickly:

Chip design: the placement of millions of transistors and routing of wires on a chip is a giant combinatorial optimization. IBM used simulated annealing in production tools within a year of the original paper.
Logistics and routing: delivery networks, airline scheduling, and warehouse picking are all variants of the Traveling Salesman Problem or its kin. Annealing provides good practical tours within a time budget.
Protein structure prediction: folding an amino-acid sequence into its minimum-energy 3D shape is an NP-hard search over a vast conformation space. SA is one of several heuristics that probe this landscape.
Image reconstruction and machine learning: Boltzmann machines — an early generative neural network — are trained by an annealing-like procedure. The connection between statistical mechanics and learning is not accidental; it runs straight through the Kirkpatrick paper.
Scheduling and timetabling: school timetables, nurse rosters, and exam schedules are all constraint-laden optimization problems where SA finds near-optimal solutions without exhaustive search.

What unites all these applications is the same geometry: a rugged cost landscape with exponentially many local minima, and a need for a good-enough answer in polynomial (or at least finite) time. Simulated annealing navigates that landscape with physics as its compass.

Conclusion

Simulated annealing is a reminder that the best algorithms sometimes come from the strangest places. A furnace, a slow cool-down, and a Boltzmann distribution gave us a general-purpose heuristic that beats naive hill-climbing on almost every hard combinatorial problem.

Its limits are real: there is no polynomial-time guarantee of optimality, and the cooling schedule is an art as much as a science. But in a world where the problems we care about — routing, scheduling, design — are NP-hard and exact solutions are out of reach, "very good in reasonable time" is often exactly what we need.

The next time you order a package that arrives via a cleverly optimized route, or use a chip with a billion transistors placed by automated tools, there is a good chance simulated annealing played a role — patiently cooling the chaos into something close to perfect.

Comments

Loading comments...

https://www.kipuhub.com/en/article/simulated-annealing/Content licensed under CC BY-NC 4.0.

Cookies & privacy

Simulated Annealing

The art of getting worse before getting better