Introduction

When a pathogen enters a population, two outcomes compete: the infection burns out on its own, or it ignites into an epidemic. The outcome depends not just on how contagious the disease is, but on the shape of the contact network — who is connected to whom.

For decades, epidemiologists used a simple rule of thumb called the basic reproduction number R0R_0: if on average one infected person spreads the disease to more than one other, the epidemic grows. But R0R_0 hides the network structure entirely, treating every contact as equally likely.

In 2003, researchers showed that the true tipping point is encoded in a single number extracted by linear algebra from the network's adjacency matrix — its leading eigenvalue λ1\lambda_1. Below the spectral threshold, every outbreak fades. Above it, spread can sustain itself indefinitely. The same formula applies to rumor propagation, computer viruses, and the cascading failures studied in network science.

Try It: Cross the Threshold

The network below has a fixed structure. Its spectral radius λ1\lambda_1 is computed from the adjacency matrix. The epidemic threshold for the SIS model is τc=1/λ1\tau_c = 1/\lambda_1.

Drag the infection rate τ\tau slider. Below τc\tau_c every infected node eventually recovers and the disease dies out. Above τc\tau_c the infection finds a stable foothold and persists.

<!-- Main layout — info bar + slider + canvas + controls -->
<div class="info-bar">
  <span>λ₁ (spectral radius): <b id="lambda-val">…</b></span>
  <span>τ_c = 1/λ₁: <b id="tau-c-val">…</b></span>
  <span>τ (infection rate): <b id="tau-display">…</b></span>
</div>
<div class="slider-row">
  <label for="tau-slider">Infection rate τ:</label>
  <input id="tau-slider" type="range" min="0.01" max="1.00" step="0.01" value="0.30">
</div>
<canvas id="net" width="380" height="260"></canvas>
<div id="status-bar" class="status-bar">Adjust τ and step the simulation.</div>
<div class="btns">
  <button id="btn-step" type="button">Step</button>
  <button id="btn-run" type="button">Run</button>
  <button id="btn-reset" type="button" class="ghost">Reset</button>
</div>

/* Base styles — layout, colors, typography */
* { box-sizing: border-box; }
body { font-family: system-ui, sans-serif; margin: 0; color: #222; }
.info-bar { display: flex; flex-wrap: wrap; gap: .6rem 1.4rem; font-size: .88rem;
            background: #eef2f6; border-radius: 8px; padding: .45rem .8rem; margin-bottom: .5rem; }
.info-bar span { white-space: nowrap; }
.slider-row { display: flex; align-items: center; gap: .6rem; margin-bottom: .4rem; font-size: .9rem; }
#tau-slider { flex: 1; accent-color: #1d3557; }
canvas { display: block; background: #f7f9fb; border-radius: 10px;
         border: 1px solid #d1dae3; width: 100%; height: auto; }
.status-bar { font-size: .92rem; font-weight: 600; min-height: 1.4em; margin: .45rem 0; }
.status-bar.above { color: #c92f3c; }
.status-bar.below { color: #0a7d33; }
.btns { display: flex; gap: .5rem; flex-wrap: wrap; }
button { font: 600 14px system-ui; padding: .45rem .9rem; border: 1px solid #1d3557;
         background: #1d3557; color: #fff; border-radius: 8px; cursor: pointer; }
button.ghost { background: #fff; color: #1d3557; }

const i18nFmt = (s, v) => s.replace(/%(\w+)%/g, (_, k) => String(v[k] ?? ''));

/* Node positions (x,y) on a 380×270 canvas; hub node 6 is central */
const NODES = [
  {id:0,x:190,y:40}, {id:1,x:310,y:100}, {id:2,x:340,y:210},
  {id:3,x:210,y:270}, {id:4,x:80,y:220},  {id:5,x:50,y:110},
  {id:6,x:190,y:140}, {id:7,x:130,y:60},  {id:8,x:270,y:60},
  {id:9,x:130,y:190}
];
/* Undirected edges — hub node 6 connects to many others, raising λ₁ */
const EDGES = [
  [0,1],[0,7],[0,8],[1,2],[1,6],[2,3],[2,6],[3,4],[3,9],[4,5],[4,9],[5,7],
  [6,7],[6,8],[6,9],[7,0],[8,1],[9,3]
];
const n = NODES.length;

/* Build adjacency matrix from edge list */
const A = Array.from({length:n}, () => new Array(n).fill(0));
for (const [u,v] of EDGES) { A[u][v]=1; A[v][u]=1; }

/* Power iteration to compute leading eigenvalue λ₁ of adjacency matrix */
function powerIter(mat, dim, steps=80) {
  let v = new Array(dim).fill(1/dim);
  let lam = 0;
  for (let s=0; s<steps; s++) {
    const w = new Array(dim).fill(0);
    for (let i=0; i<dim; i++) for (let j=0; j<dim; j++) w[i] += mat[i][j]*v[j];
    lam = Math.max(...w.map(Math.abs));
    if (lam === 0) break;
    v = w.map(x => x/lam);
  }
  return lam;
}

const lambda1 = powerIter(A, n);
const tauC = 1 / lambda1;

/* SIS state: true = infected, false = susceptible */
let infected = new Array(n).fill(false);
/* Seed one infected node (the hub) to start the simulation */
infected[6] = true;
let running = false;
let animId = null;

const canvas = document.getElementById('net');
const ctx = canvas.getContext('2d');
const W = canvas.width, H = canvas.height;

/* Scale node positions to actual canvas pixel dimensions */
const PX = NODES.map(nd => ({
  x: nd.x * W / 380,
  y: nd.y * H / 270
}));

function getTau() { return parseFloat(document.getElementById('tau-slider').value); }

/* Draw the network — edges first, then nodes colored by infection state */
function draw() {
  ctx.clearRect(0,0,W,H);
  /* Draw undirected edges in light gray */
  ctx.strokeStyle = '#c0ccd8';
  ctx.lineWidth = 1.4;
  for (const [u,v] of EDGES) {
    ctx.beginPath();
    ctx.moveTo(PX[u].x, PX[u].y);
    ctx.lineTo(PX[v].x, PX[v].y);
    ctx.stroke();
  }
  /* Draw nodes: red = infected, blue = susceptible */
  for (let i=0; i<n; i++) {
    const {x,y} = PX[i];
    ctx.beginPath();
    ctx.arc(x, y, 14, 0, 2*Math.PI);
    ctx.fillStyle = infected[i] ? '#e63946' : '#a8d8ea';
    ctx.fill();
    ctx.strokeStyle = infected[i] ? '#9b2230' : '#4a90b8';
    ctx.lineWidth = 1.8;
    ctx.stroke();
  }
}

/* One discrete SIS step — each node heals or spreads independently */
function sisStep() {
  const tau = getTau();
  const next = infected.slice();
  for (let i=0; i<n; i++) {
    if (infected[i]) {
      /* Recovery: infected node heals with fixed probability 0.3 (δ) */
      if (Math.random() < 0.3) next[i] = false;
    } else {
      /* Spread: susceptible node gets exposed by each infected neighbor with prob τ (β) */
      let expose = false;
      for (let j=0; j<n; j++) {
        if (A[i][j] && infected[j] && Math.random() < tau) { expose=true; break; }
      }
      if (expose) next[i] = true;
    }
  }
  infected = next;
}

function updateInfo() {
  const tau = getTau();
  document.getElementById('lambda-val').textContent = lambda1.toFixed(3);
  document.getElementById('tau-c-val').textContent = tauC.toFixed(3);
  document.getElementById('tau-display').textContent = tau.toFixed(2);
  const sb = document.getElementById('status-bar');
  if (tau > tauC) {
    sb.textContent = i18nFmt('τ > τ_c (%tauC%) — above threshold: epidemic can persist!', { tauC: tauC.toFixed(3) });
    sb.className = 'status-bar above';
  } else {
    sb.textContent = i18nFmt('τ ≤ τ_c (%tauC%) — below threshold: infection dies out.', { tauC: tauC.toFixed(3) });
    sb.className = 'status-bar below';
  }
}

function step() { sisStep(); draw(); updateInfo(); }

function toggleRun() {
  running = !running;
  document.getElementById('btn-run').textContent = running ? 'Pause' : 'Run';
  if (running) animate();
  else if (animId) cancelAnimationFrame(animId);
}

let lastT = 0;
function animate(t=0) {
  if (!running) return;
  if (t - lastT > 180) { sisStep(); draw(); lastT = t; }
  animId = requestAnimationFrame(animate);
}

function reset() {
  running = false;
  if (animId) cancelAnimationFrame(animId);
  document.getElementById('btn-run').textContent = 'Run';
  infected = new Array(n).fill(false);
  /* Restart with a single infected hub node */
  infected[6] = true;
  draw(); updateInfo();
}

document.getElementById('tau-slider').addEventListener('input', () => { updateInfo(); });
document.getElementById('btn-step').addEventListener('click', step);
document.getElementById('btn-run').addEventListener('click', toggleRun);
document.getElementById('btn-reset').addEventListener('click', reset);

draw();
updateInfo();
Result
Console

Notice how the transition is sharp: just crossing the eigenvalue threshold switches the network from "safe" to "endemic." The spectral radius is not just a metaphor — it is the exact boundary, provable from the SIS differential equations.

The Spectral Math

Consider the SIS (Susceptible–Infected–Susceptible) model on a network with nn nodes. Each node is either susceptible (S) or infected (I). At each time step:

  • An infected node heals with probability δ\delta.
  • An infected node spreads to each susceptible neighbor with probability β\beta.

The effective spread rate is τ=β/δ\tau = \beta / \delta. The key result (Wang et al., 2003) is:

τc=1λ1\tau_c = \frac{1}{\lambda_1}

where λ1\lambda_1 is the largest eigenvalue of the adjacency matrix AA of the network (also called its spectral radius).

  • If τ<τc\tau < \tau_c: the infection decays exponentially to zero — epidemic-free equilibrium.
  • If τ>τc\tau > \tau_c: a non-zero endemic equilibrium exists and spread persists.

The proof linearizes the SIS equations around the zero-infection state. The Jacobian of that system has eigenvalue τλ1−1\tau \lambda_1 - 1. Stability flips when this eigenvalue crosses zero — exactly at τ=1/λ1\tau = 1/\lambda_1.

Why does the network shape matter? On a random Erdős–Rényi graph with average degree ⟨k⟩\langle k \rangle, the spectral radius is approximately ⟨k2⟩\sqrt{\langle k^2 \rangle}, which grows with degree variance. A hub-heavy scale-free network has enormous λ1\lambda_1, driving τc\tau_c toward zero: any infection, no matter how mild, can spread. On a regular lattice λ1\lambda_1 is moderate and a meaningful threshold exists.

Computing λ1\lambda_1 requires finding the dominant eigenvector of AA — a classical operation in linear algebra solvable in polynomial time by the power iteration method.

Where It Matters

The spectral threshold turns up wherever contagion spreads on a network:

  • Epidemiology: the 2003 result explained why SARS and COVID-19 spread so fast in dense urban contact networks. Vaccination strategies that target high-degree hubs disproportionately reduce λ1\lambda_1 and push τc\tau_c up, halting spread with fewer doses.
  • Cybersecurity: computer viruses and worms propagate on IP-connectivity graphs. Patching the highest-eigenvector-centrality nodes — not just the highest-degree ones — is provably more efficient at raising the threshold.
  • Social influence and misinformation: the same SIS framework models how a rumor or meme can go viral. Platforms can suppress cascade by reducing the spectral radius of their social graph through targeted link removal.
  • Infrastructure resilience: power-grid failure cascades and financial contagion also follow threshold dynamics governed by the leading eigenvalue of their dependency graphs.

The key insight for intervention is always the same: reduce λ1\lambda_1 by targeting nodes or edges that contribute most to the dominant eigenvector, not merely those with the largest raw degree count.

Conclusion

A single number — the spectral radius λ1\lambda_1 of the contact network — decides whether an epidemic ignites or fades away. It is not a rough heuristic: it is the exact algebraic threshold derived from the SIS differential equations.

This means the battle against contagion is, at its mathematical heart, a problem of linear algebra on graphs. Whoever controls the dominant eigenvalue controls the epidemic. Target the hubs that inflate λ1\lambda_1, and even a highly infectious disease can be kept below its tipping point.

The spectral radius connects epidemiology to the broader theory of network science and graph algorithms, and it shows — beautifully — how abstract mathematics governs the spread of everything from viruses to ideas.

Share this article

Pick a channel — or use your device's native share sheet.

Comments

Loading comments...

https://www.kipuhub.com/en/article/epidemic-threshold-spectral/Content licensed under CC BY-NC 4.0.