Introduction to the Voter Model

Introduction

Imagine a grid of people, each holding one of two opinions — call them blue and red. Every second, each person looks at one random neighbor and copies that neighbor's opinion exactly. Nobody argues, nobody reasons; they just imitate. What happens?

This is the voter model, introduced independently by Clifford and Sudbury (1973) and by Holley and Liggett (1975). Despite its absurd simplicity, it captures something real: opinions spread not because they are correct, but because they are nearby.

The model is a Markov chain — the future depends only on the current state, not on history. And it has exactly two absorbing states: all-blue or all-red. Once every node agrees, the process is stuck forever. The deep question is not whether consensus arrives, but how fast, and which opinion wins.

Try It

Below is a grid of nodes, each colored blue or red at random. Click Step to advance one full synchronous round — every node simultaneously copies one random neighbor — or click Run to animate the process until one color wins.

<!-- Grid of nodes; each step every node copies a random neighbor's opinion (blue or red) -->
<div class="controls">
  <span id="status" class="status">Ready — step or run to start.</span>
  <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>
</div>
<canvas id="canvas" width="360" height="280" aria-label="Voter model grid"></canvas>
<div class="legend">
  <span class="dot blue"></span><span>Blue opinion</span>
  <span class="dot red"></span><span>Red opinion</span>
</div>

/* Voter-model demo styles */
* { box-sizing: border-box; }
body { font-family: system-ui, sans-serif; margin: 0; color: #222; }
.controls { display: flex; align-items: center; gap: .6rem; flex-wrap: wrap; margin-bottom: .5rem; }
.status { font-size: .9rem; font-weight: 600; flex: 1; min-width: 8rem; }
.btns { display: flex; gap: .4rem; }
button { font: 600 13px system-ui, sans-serif; padding: .4rem .85rem; border: 1px solid #1d3557;
         background: #1d3557; color: #fff; border-radius: 8px; cursor: pointer; }
button.ghost { background: #fff; color: #1d3557; }
button:disabled { opacity: .45; cursor: default; }
canvas { display: block; border-radius: 8px; border: 1px solid #cdd9e3; width: 100%; max-width: 360px; }
.legend { display: flex; align-items: center; gap: .5rem; font-size: .82rem; margin-top: .4rem; color: #555; }
.dot { display: inline-block; width: 10px; height: 10px; border-radius: 50%; margin-right: .25rem; }
.dot.blue { background: #3a7bd5; }
.dot.red { background: #e63946; }

/* Voter model — synchronous update, canvas rendering */
const i18nFmt = (s, v) => s.replace(/%(\w+)%/g, (_, k) => String(v[k] ?? ''));

/* Grid dimensions and constants */
const ROWS = 20, COLS = 28;
const CELL = 13; /* pixels per cell */
const BLUE = 0, RED = 1;
const COLOR = ['#3a7bd5', '#e63946'];

let grid = [];
let animId = null;
let running = false;
let stepCount = 0;

/* Initialize grid with 50% blue / 50% red at random */
function initGrid() {
  grid = [];
  for (let r = 0; r < ROWS; r++) {
    grid.push([]);
    for (let c = 0; c < COLS; c++) {
      grid[r].push(Math.random() < 0.5 ? BLUE : RED);
    }
  }
  stepCount = 0;
}

/* Draw the current grid state to the canvas */
function draw() {
  const canvas = document.getElementById('canvas');
  const ctx = canvas.getContext('2d');
  ctx.clearRect(0, 0, canvas.width, canvas.height);
  for (let r = 0; r < ROWS; r++) {
    for (let c = 0; c < COLS; c++) {
      ctx.fillStyle = COLOR[grid[r][c]];
      ctx.fillRect(c * CELL + 1, r * CELL + 1, CELL - 1, CELL - 1);
    }
  }
}

/* Return the 4-neighborhood (up, down, left, right) of cell (r,c) */
function neighbors(r, c) {
  const out = [];
  if (r > 0) out.push([r - 1, c]);
  if (r < ROWS - 1) out.push([r + 1, c]);
  if (c > 0) out.push([r, c - 1]);
  if (c < COLS - 1) out.push([r, c + 1]);
  return out;
}

/* Return the winning opinion (BLUE or RED) if all cells agree, else -1 */
function checkConsensus() {
  const first = grid[0][0];
  for (let r = 0; r < ROWS; r++)
    for (let c = 0; c < COLS; c++)
      if (grid[r][c] !== first) return -1;
  return first;
}

/* Advance one synchronous voter-model round */
function step() {
  /* Every node simultaneously copies a random neighbor */
  const next = grid.map(row => row.slice());
  for (let r = 0; r < ROWS; r++) {
    for (let c = 0; c < COLS; c++) {
      const nb = neighbors(r, c);
      const [nr, nc] = nb[Math.floor(Math.random() * nb.length)];
      next[r][c] = grid[nr][nc];
    }
  }
  grid = next;
  stepCount++;
}

function countBlue() {
  let b = 0;
  for (let r = 0; r < ROWS; r++)
    for (let c = 0; c < COLS; c++)
      if (grid[r][c] === BLUE) b++;
  return b;
}

function setStatus(text, cls) {
  const el = document.getElementById('status');
  el.textContent = text;
  el.className = 'status ' + (cls || '');
}

function updateButtons(isDone) {
  document.getElementById('btn-step').disabled = isDone || running;
  document.getElementById('btn-run').disabled = isDone;
  document.getElementById('btn-run').textContent = running ? 'Pause' : 'Run';
}

function onStep() {
  step();
  draw();
  const winner = checkConsensus();
  const pct = Math.round(countBlue() * 100 / (ROWS * COLS));
  if (winner !== -1) {
    const winColor = winner === BLUE ? 'Blue' : 'Red';
    setStatus(i18nFmt('Consensus reached! %color% wins after %steps% steps.', { color: winColor, steps: stepCount }), 'done');
    stopRun();
    updateButtons(true);
  } else {
    setStatus(i18nFmt('Step %steps% — %pct% % blue', { steps: stepCount, pct: pct }), '');
    updateButtons(false);
  }
}

function startRun() {
  running = true;
  updateButtons(false);
  function tick() {
    onStep();
    const winner = checkConsensus();
    if (winner === -1 && running) animId = requestAnimationFrame(tick);
  }
  animId = requestAnimationFrame(tick);
}

function stopRun() {
  running = false;
  if (animId) { cancelAnimationFrame(animId); animId = null; }
}

function onRun() {
  if (running) { stopRun(); updateButtons(false); return; }
  startRun();
}

function onReset() {
  stopRun();
  initGrid();
  draw();
  setStatus('Ready — step or run to start.', '');
  updateButtons(false);
}

document.getElementById('btn-step').addEventListener('click', onStep);
document.getElementById('btn-run').addEventListener('click', onRun);
document.getElementById('btn-reset').addEventListener('click', onReset);

/* Bootstrap */
initGrid();
draw();
setStatus('Ready — step or run to start.', '');
updateButtons(false);

<!-- Grid of nodes; each step every node copies a random neighbor's opinion (blue or red) -->
<div class="controls">
  <span id="status" class="status">Ready — step or run to start.</span>
  <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>
</div>
<canvas id="canvas" width="360" height="280" aria-label="Voter model grid"></canvas>
<div class="legend">
  <span class="dot blue"></span><span>Blue opinion</span>
  <span class="dot red"></span><span>Red opinion</span>
</div>

/* Voter-model demo styles */
* { box-sizing: border-box; }
body { font-family: system-ui, sans-serif; margin: 0; color: #222; }
.controls { display: flex; align-items: center; gap: .6rem; flex-wrap: wrap; margin-bottom: .5rem; }
.status { font-size: .9rem; font-weight: 600; flex: 1; min-width: 8rem; }
.btns { display: flex; gap: .4rem; }
button { font: 600 13px system-ui, sans-serif; padding: .4rem .85rem; border: 1px solid #1d3557;
         background: #1d3557; color: #fff; border-radius: 8px; cursor: pointer; }
button.ghost { background: #fff; color: #1d3557; }
button:disabled { opacity: .45; cursor: default; }
canvas { display: block; border-radius: 8px; border: 1px solid #cdd9e3; width: 100%; max-width: 360px; }
.legend { display: flex; align-items: center; gap: .5rem; font-size: .82rem; margin-top: .4rem; color: #555; }
.dot { display: inline-block; width: 10px; height: 10px; border-radius: 50%; margin-right: .25rem; }
.dot.blue { background: #3a7bd5; }
.dot.red { background: #e63946; }

/* Voter model — synchronous update, canvas rendering */
const i18nFmt = (s, v) => s.replace(/%(\w+)%/g, (_, k) => String(v[k] ?? ''));

/* Grid dimensions and constants */
const ROWS = 20, COLS = 28;
const CELL = 13; /* pixels per cell */
const BLUE = 0, RED = 1;
const COLOR = ['#3a7bd5', '#e63946'];

let grid = [];
let animId = null;
let running = false;
let stepCount = 0;

/* Initialize grid with 50% blue / 50% red at random */
function initGrid() {
  grid = [];
  for (let r = 0; r < ROWS; r++) {
    grid.push([]);
    for (let c = 0; c < COLS; c++) {
      grid[r].push(Math.random() < 0.5 ? BLUE : RED);
    }
  }
  stepCount = 0;
}

/* Draw the current grid state to the canvas */
function draw() {
  const canvas = document.getElementById('canvas');
  const ctx = canvas.getContext('2d');
  ctx.clearRect(0, 0, canvas.width, canvas.height);
  for (let r = 0; r < ROWS; r++) {
    for (let c = 0; c < COLS; c++) {
      ctx.fillStyle = COLOR[grid[r][c]];
      ctx.fillRect(c * CELL + 1, r * CELL + 1, CELL - 1, CELL - 1);
    }
  }
}

/* Return the 4-neighborhood (up, down, left, right) of cell (r,c) */
function neighbors(r, c) {
  const out = [];
  if (r > 0) out.push([r - 1, c]);
  if (r < ROWS - 1) out.push([r + 1, c]);
  if (c > 0) out.push([r, c - 1]);
  if (c < COLS - 1) out.push([r, c + 1]);
  return out;
}

/* Return the winning opinion (BLUE or RED) if all cells agree, else -1 */
function checkConsensus() {
  const first = grid[0][0];
  for (let r = 0; r < ROWS; r++)
    for (let c = 0; c < COLS; c++)
      if (grid[r][c] !== first) return -1;
  return first;
}

/* Advance one synchronous voter-model round */
function step() {
  /* Every node simultaneously copies a random neighbor */
  const next = grid.map(row => row.slice());
  for (let r = 0; r < ROWS; r++) {
    for (let c = 0; c < COLS; c++) {
      const nb = neighbors(r, c);
      const [nr, nc] = nb[Math.floor(Math.random() * nb.length)];
      next[r][c] = grid[nr][nc];
    }
  }
  grid = next;
  stepCount++;
}

function countBlue() {
  let b = 0;
  for (let r = 0; r < ROWS; r++)
    for (let c = 0; c < COLS; c++)
      if (grid[r][c] === BLUE) b++;
  return b;
}

function setStatus(text, cls) {
  const el = document.getElementById('status');
  el.textContent = text;
  el.className = 'status ' + (cls || '');
}

function updateButtons(isDone) {
  document.getElementById('btn-step').disabled = isDone || running;
  document.getElementById('btn-run').disabled = isDone;
  document.getElementById('btn-run').textContent = running ? 'Pause' : 'Run';
}

function onStep() {
  step();
  draw();
  const winner = checkConsensus();
  const pct = Math.round(countBlue() * 100 / (ROWS * COLS));
  if (winner !== -1) {
    const winColor = winner === BLUE ? 'Blue' : 'Red';
    setStatus(i18nFmt('Consensus reached! %color% wins after %steps% steps.', { color: winColor, steps: stepCount }), 'done');
    stopRun();
    updateButtons(true);
  } else {
    setStatus(i18nFmt('Step %steps% — %pct% % blue', { steps: stepCount, pct: pct }), '');
    updateButtons(false);
  }
}

function startRun() {
  running = true;
  updateButtons(false);
  function tick() {
    onStep();
    const winner = checkConsensus();
    if (winner === -1 && running) animId = requestAnimationFrame(tick);
  }
  animId = requestAnimationFrame(tick);
}

function stopRun() {
  running = false;
  if (animId) { cancelAnimationFrame(animId); animId = null; }
}

function onRun() {
  if (running) { stopRun(); updateButtons(false); return; }
  startRun();
}

function onReset() {
  stopRun();
  initGrid();
  draw();
  setStatus('Ready — step or run to start.', '');
  updateButtons(false);
}

document.getElementById('btn-step').addEventListener('click', onStep);
document.getElementById('btn-run').addEventListener('click', onRun);
document.getElementById('btn-reset').addEventListener('click', onReset);

/* Bootstrap */
initGrid();
draw();
setStatus('Ready — step or run to start.', '');
updateButtons(false);

Result

Console

Notice how small clusters form and grow. Isolated nodes surrounded by the opposite color get quickly overrun; large blobs persist longer. The fraction of blue nodes is a martingale — its expected value stays constant over time — so whichever color holds the majority at the start has a proportional advantage in winning the race.

The Math of Consensus

The voter model sits at the crossroads of probability theory and statistical physics. Here is what the theory says:

Absorbing states. On any finite graph, both all-blue and all-red are absorbing. The model is guaranteed to reach one of them — there is no periodic orbit or other trap.
Martingale property. The fraction $p$ of blue nodes is a martingale: $\mathbb{E}[p_{t+1} \mid p_t] = p_t$ . This means the probability that blue wins is exactly the initial fraction $p_0$ of blue nodes. Starting with 60 % blue gives blue a 60 % chance of total victory.
Consensus time on grids. On a one-dimensional ring of $n$ nodes the expected time to consensus scales as $\Theta(n^2)$ . On a two-dimensional $\sqrt{n} \times \sqrt{n}$ grid it scales as $\Theta(n \log n)$ . In three or more dimensions the model reaches consensus in $\Theta(n)$ steps on average — the higher the dimension, the shorter the path.
Mean-field limit. On a complete graph (everyone connected to everyone), the consensus time is $\Theta(n \log n)$ , and this regime is called the mean-field approximation — a reference model for more complex networks like the random graphs studied in network science.
Dual process. There is an elegant duality: run time backwards and the voter model becomes a system of coalescing random walks. Two walkers starting at different nodes merge when they meet. The system reaches consensus exactly when all $n$ walkers have coalesced into one — a beautiful connection to the theory of random walks.

Where It Matters

The voter model is more than a thought experiment. The same copying dynamics appear across science:

Social influence and echo chambers. Real social networks are not grids, but the coarsening dynamic — small clusters of agreement growing until they absorb neighbors — matches observed polarization patterns in online social media.
Population genetics (genetic drift). Replace opinion with allele. In a finite population, a neutral allele that does not help or hurt its carrier drifts to fixation or extinction by the same martingale logic. The probability that a single new mutant eventually takes over is $1/n$ , exactly the voter-model formula.
The Ising model connection. The voter model is the zero-temperature limit of the Ising model from statistical physics — the limit where thermal noise vanishes and only neighbor-copying remains. Studying the voter model sheds light on phase transitions in magnetic materials.
Language change. Linguists model how dialects spread through communities using voter-model-style dynamics, where speakers unconsciously adapt to those around them rather than making deliberate choices.

Understanding the voter model means understanding a fundamental mode of spreading: not persuasion, not optimization — just imitation.

Conclusion

The voter model strips opinion dynamics down to one rule — copy a random neighbor — and still produces a rich landscape of behavior. Consensus always arrives on finite networks, but how fast depends on geometry: low dimensions are slow, high dimensions are fast, and the winner is decided by a pure coin flip weighted by the initial majority.

The model's real lesson is about information and imitation. No individual reasons about global truth; each just mirrors a neighbor. Yet from that microscopic rule emerges macroscopic agreement — a fact as relevant to social networks and genetic drift as it is to random walks and the Ising model. Simple rules, it turns out, can decide elections.

Comments

Loading comments...

https://www.kipuhub.com/en/article/voter-model-consensus/Content licensed under CC BY-NC 4.0.

Cookies & privacy

The Voter Model

When copying a random neighbor decides an election