Erdős–Rényi: Watch the Giant Component Appear

Introduction

Take a hundred isolated dots. Start drawing lines between randomly chosen pairs. At first you get a few small clusters — tiny islands in a sea of disconnection. Then, almost without warning, the islands merge into a single giant component that spans almost the entire graph. One more edge and nothing dramatic happens. The transition has already fired.

This is the Erdős–Rényi phase transition, first described precisely by Paul Erdős and Alfréd Rényi in their landmark 1960 paper On the Evolution of Random Graphs. They studied a simple model — G(n, p) — where you have n nodes and each possible edge exists independently with probability p. As p grows from 0 to 1, the graph goes through a sharp change at exactly p = 1/n.

The result is one of the most beautiful in all of combinatorics: not a gradual blending but a genuine phase transition, mathematically analogous to water freezing into ice. Below the threshold the largest component has size $O(\log n)$ . Cross it and a component of size $O(n)$ erupts — and it happens over a vanishingly narrow window of p.

Watch the Giant Component Appear

The demo below builds a G(n, p) graph in real time. Each node pair gets an edge independently with probability p. Drag the slider slowly from left to right and watch what happens near p = 1/n ≈ 0.05 (for n = 20).

<div class="controls">
  <label for="prob-slider">
    Edge probability <strong id="prob-val">p = 0.00</strong>
    <span class="threshold-tag" id="threshold-tag"></span>
  </label>
  <input type="range" id="prob-slider" min="0" max="100" value="0" step="1">
  <div class="stats" id="stats">Nodes: 20 &nbsp;|&nbsp; Edges: 0 &nbsp;|&nbsp; Largest component: 1</div>
</div>
<canvas id="graph-canvas" width="480" height="300"></canvas>
<div class="btns">
  <button id="btn-rebuild" type="button">Resample graph</button>
  <button id="btn-reset" type="button" class="ghost">Reset to p = 0</button>
</div>

* { box-sizing: border-box; }
body { font-family: system-ui, sans-serif; color: #222; margin: 0; padding: 14px; }
.controls { margin-bottom: .5rem; }
label { font-size: .9rem; display: block; margin-bottom: .3rem; color: #444; }
label strong { color: #1d3557; font-size: 1rem; }
.threshold-tag { display: inline-block; margin-left: .4rem; font-size: .78rem;
                 padding: .1rem .4rem; border-radius: 4px; font-weight: 600;
                 background: #e8eef3; color: #1d3557; vertical-align: middle; }
.threshold-tag.below { background: #f0f4ff; color: #455aa0; }
.threshold-tag.at    { background: #fff7e0; color: #9a6800; }
.threshold-tag.above { background: #e8f7ee; color: #0a7d33; }
input[type=range] { width: 100%; accent-color: #1d3557; cursor: pointer; }
.stats { font-size: .82rem; color: #555; margin-top: .3rem; }
canvas { display: block; border: 1px solid #cdd9e3; border-radius: 8px;
         background: #f8fafc; width: 100%; max-width: 480px; }
.btns { display: flex; gap: .5rem; flex-wrap: wrap; margin-top: .6rem; }
button { font: 600 14px system-ui; padding: .4rem .85rem; border: 1px solid #1d3557;
         background: #1d3557; color: #fff; border-radius: 8px; cursor: pointer; }
button.ghost { background: #fff; color: #1d3557; }

const fmt = (s, v) => s.replace(/%(\w+)%/g, (_, k) => String(v[k] ?? ''));
// Erdős–Rényi G(n,p) demo.
// Each pair of the N nodes is connected independently with probability p.
// We find connected components via union-find and colour nodes by component.
// The slider maps [0,100] → p in [0,1].  Threshold is at p = 1/N.

const N = 20;
const canvas = document.getElementById('graph-canvas');
const ctx = canvas.getContext('2d');
const W = canvas.width, H = canvas.height;
const slider = document.getElementById('prob-slider');
const probVal = document.getElementById('prob-val');
const thresholdTag = document.getElementById('threshold-tag');
const statsEl = document.getElementById('stats');

// Fixed node positions (deterministic layout – circle)
const nodes = [];
for (let i = 0; i < N; i++) {
  const angle = (2 * Math.PI * i) / N - Math.PI / 2;
  nodes.push({ x: W / 2 + (W * 0.4) * Math.cos(angle),
               y: H / 2 + (H * 0.42) * Math.sin(angle) });
}

// Union-Find
function makeUF(n) {
  const p = Array.from({ length: n }, (_, i) => i);
  const r = new Array(n).fill(0);
  function find(x) { while (p[x] !== x) { p[x] = p[p[x]]; x = p[x]; } return x; }
  function union(a, b) { a = find(a); b = find(b); if (a === b) return; if (r[a] < r[b]) [a,b]=[b,a]; p[b]=a; if(r[a]===r[b]) r[a]++; }
  return { find, union, p };
}

// Color palette for components (up to 10 distinct, then gray)
const PALETTE = ['#e63946','#457b9d','#2a9d8f','#e9c46a','#f4a261',
                 '#6a4c93','#1d3557','#3a86ff','#fb5607','#06d6a0'];

let currentEdges = [];
let currentComp = [];

function buildGraph(p) {
  const uf = makeUF(N);
  const edges = [];
  for (let i = 0; i < N; i++) {
    for (let j = i + 1; j < N; j++) {
      if (Math.random() < p) { edges.push([i, j]); uf.union(i, j); }
    }
  }
  // Assign component ids
  const rootMap = {};
  let nextId = 0;
  const comp = nodes.map((_, i) => {
    const r = uf.find(i);
    if (!(r in rootMap)) rootMap[r] = nextId++;
    return rootMap[r];
  });
  // Component sizes
  const size = {};
  comp.forEach(c => { size[c] = (size[c] || 0) + 1; });
  const maxSize = Math.max(...Object.values(size));
  // Find the giant component id (largest)
  const giant = parseInt(Object.entries(size).sort((a,b) => b[1]-a[1])[0][0]);
  return { edges, comp, size, maxSize, giant };
}

function draw(p) {
  const { edges, comp, size, maxSize, giant } = buildGraph(p);
  currentEdges = edges;
  currentComp = comp;

  ctx.clearRect(0, 0, W, H);

  // Draw edges
  edges.forEach(([i, j]) => {
    const ci = comp[i];
    const isGiantEdge = ci === giant && maxSize > 1;
    ctx.beginPath();
    ctx.moveTo(nodes[i].x, nodes[i].y);
    ctx.lineTo(nodes[j].x, nodes[j].y);
    ctx.strokeStyle = isGiantEdge ? 'rgba(70,130,80,0.45)' : 'rgba(150,170,190,0.5)';
    ctx.lineWidth = isGiantEdge ? 1.8 : 1;
    ctx.stroke();
  });

  // Draw nodes
  nodes.forEach((node, i) => {
    const c = comp[i];
    const isGiant = c === giant && maxSize > 1;
    const color = isGiant ? '#0a7d33' : (size[c] > 1 ? PALETTE[c % PALETTE.length] : '#b0bec5');
    ctx.beginPath();
    ctx.arc(node.x, node.y, isGiant ? 7 : 5, 0, 2 * Math.PI);
    ctx.fillStyle = color;
    ctx.fill();
    ctx.strokeStyle = isGiant ? '#07602a' : 'rgba(0,0,0,0.15)';
    ctx.lineWidth = 1;
    ctx.stroke();
  });

  // Stats
  statsEl.innerHTML = fmt('Nodes: %N% &nbsp;|&nbsp; Edges: %length% &nbsp;|&nbsp; Largest component: <strong>%maxSize%</strong> nodes', { N: N, length: edges.length, maxSize: maxSize });

  // Threshold label
  const threshold = 1 / N;
  let tag = '', cls = '';
  if (p < threshold * 0.85) { tag = 'below threshold'; cls = 'below'; }
  else if (p <= threshold * 1.15) { tag = '≈ threshold 1/n'; cls = 'at'; }
  else { tag = 'above threshold'; cls = 'above'; }
  thresholdTag.textContent = tag;
  thresholdTag.className = 'threshold-tag ' + cls;
}

function update() {
  const p = parseInt(slider.value) / 100;
  probVal.textContent = 'p = ' + p.toFixed(2);
  draw(p);
}

slider.addEventListener('input', update);
document.getElementById('btn-rebuild').addEventListener('click', update);
document.getElementById('btn-reset').addEventListener('click', () => {
  slider.value = 0;
  update();
});

update();

// Node-side verification (run with node to check threshold math)
// At p=1/N=0.05 (N=20), expected edges = C(20,2)*0.05 = 190*0.05 = 9.5
// Giant component expected size ~ 2*eps*N for p=(1+eps)/N
// For p=0.1=(1+1)/N with N=20: eps=1, expected giant ~ 2*1*0.8*20 ≈ (by formula) beta*N
// where beta satisfies beta + e^(-2*beta) = 1 -> beta ≈ 0.797 -> giant ≈ 15.9 nodes
console.log(fmt('Erdős–Rényi demo loaded. N=%N%, threshold p=%v%', { N: N, v: (1/N).toFixed(4) }));

<div class="controls">
  <label for="prob-slider">
    Edge probability <strong id="prob-val">p = 0.00</strong>
    <span class="threshold-tag" id="threshold-tag"></span>
  </label>
  <input type="range" id="prob-slider" min="0" max="100" value="0" step="1">
  <div class="stats" id="stats">Nodes: 20 &nbsp;|&nbsp; Edges: 0 &nbsp;|&nbsp; Largest component: 1</div>
</div>
<canvas id="graph-canvas" width="480" height="300"></canvas>
<div class="btns">
  <button id="btn-rebuild" type="button">Resample graph</button>
  <button id="btn-reset" type="button" class="ghost">Reset to p = 0</button>
</div>

* { box-sizing: border-box; }
body { font-family: system-ui, sans-serif; color: #222; margin: 0; padding: 14px; }
.controls { margin-bottom: .5rem; }
label { font-size: .9rem; display: block; margin-bottom: .3rem; color: #444; }
label strong { color: #1d3557; font-size: 1rem; }
.threshold-tag { display: inline-block; margin-left: .4rem; font-size: .78rem;
                 padding: .1rem .4rem; border-radius: 4px; font-weight: 600;
                 background: #e8eef3; color: #1d3557; vertical-align: middle; }
.threshold-tag.below { background: #f0f4ff; color: #455aa0; }
.threshold-tag.at    { background: #fff7e0; color: #9a6800; }
.threshold-tag.above { background: #e8f7ee; color: #0a7d33; }
input[type=range] { width: 100%; accent-color: #1d3557; cursor: pointer; }
.stats { font-size: .82rem; color: #555; margin-top: .3rem; }
canvas { display: block; border: 1px solid #cdd9e3; border-radius: 8px;
         background: #f8fafc; width: 100%; max-width: 480px; }
.btns { display: flex; gap: .5rem; flex-wrap: wrap; margin-top: .6rem; }
button { font: 600 14px system-ui; padding: .4rem .85rem; border: 1px solid #1d3557;
         background: #1d3557; color: #fff; border-radius: 8px; cursor: pointer; }
button.ghost { background: #fff; color: #1d3557; }

const fmt = (s, v) => s.replace(/%(\w+)%/g, (_, k) => String(v[k] ?? ''));
// Erdős–Rényi G(n,p) demo.
// Each pair of the N nodes is connected independently with probability p.
// We find connected components via union-find and colour nodes by component.
// The slider maps [0,100] → p in [0,1].  Threshold is at p = 1/N.

const N = 20;
const canvas = document.getElementById('graph-canvas');
const ctx = canvas.getContext('2d');
const W = canvas.width, H = canvas.height;
const slider = document.getElementById('prob-slider');
const probVal = document.getElementById('prob-val');
const thresholdTag = document.getElementById('threshold-tag');
const statsEl = document.getElementById('stats');

// Fixed node positions (deterministic layout – circle)
const nodes = [];
for (let i = 0; i < N; i++) {
  const angle = (2 * Math.PI * i) / N - Math.PI / 2;
  nodes.push({ x: W / 2 + (W * 0.4) * Math.cos(angle),
               y: H / 2 + (H * 0.42) * Math.sin(angle) });
}

// Union-Find
function makeUF(n) {
  const p = Array.from({ length: n }, (_, i) => i);
  const r = new Array(n).fill(0);
  function find(x) { while (p[x] !== x) { p[x] = p[p[x]]; x = p[x]; } return x; }
  function union(a, b) { a = find(a); b = find(b); if (a === b) return; if (r[a] < r[b]) [a,b]=[b,a]; p[b]=a; if(r[a]===r[b]) r[a]++; }
  return { find, union, p };
}

// Color palette for components (up to 10 distinct, then gray)
const PALETTE = ['#e63946','#457b9d','#2a9d8f','#e9c46a','#f4a261',
                 '#6a4c93','#1d3557','#3a86ff','#fb5607','#06d6a0'];

let currentEdges = [];
let currentComp = [];

function buildGraph(p) {
  const uf = makeUF(N);
  const edges = [];
  for (let i = 0; i < N; i++) {
    for (let j = i + 1; j < N; j++) {
      if (Math.random() < p) { edges.push([i, j]); uf.union(i, j); }
    }
  }
  // Assign component ids
  const rootMap = {};
  let nextId = 0;
  const comp = nodes.map((_, i) => {
    const r = uf.find(i);
    if (!(r in rootMap)) rootMap[r] = nextId++;
    return rootMap[r];
  });
  // Component sizes
  const size = {};
  comp.forEach(c => { size[c] = (size[c] || 0) + 1; });
  const maxSize = Math.max(...Object.values(size));
  // Find the giant component id (largest)
  const giant = parseInt(Object.entries(size).sort((a,b) => b[1]-a[1])[0][0]);
  return { edges, comp, size, maxSize, giant };
}

function draw(p) {
  const { edges, comp, size, maxSize, giant } = buildGraph(p);
  currentEdges = edges;
  currentComp = comp;

  ctx.clearRect(0, 0, W, H);

  // Draw edges
  edges.forEach(([i, j]) => {
    const ci = comp[i];
    const isGiantEdge = ci === giant && maxSize > 1;
    ctx.beginPath();
    ctx.moveTo(nodes[i].x, nodes[i].y);
    ctx.lineTo(nodes[j].x, nodes[j].y);
    ctx.strokeStyle = isGiantEdge ? 'rgba(70,130,80,0.45)' : 'rgba(150,170,190,0.5)';
    ctx.lineWidth = isGiantEdge ? 1.8 : 1;
    ctx.stroke();
  });

  // Draw nodes
  nodes.forEach((node, i) => {
    const c = comp[i];
    const isGiant = c === giant && maxSize > 1;
    const color = isGiant ? '#0a7d33' : (size[c] > 1 ? PALETTE[c % PALETTE.length] : '#b0bec5');
    ctx.beginPath();
    ctx.arc(node.x, node.y, isGiant ? 7 : 5, 0, 2 * Math.PI);
    ctx.fillStyle = color;
    ctx.fill();
    ctx.strokeStyle = isGiant ? '#07602a' : 'rgba(0,0,0,0.15)';
    ctx.lineWidth = 1;
    ctx.stroke();
  });

  // Stats
  statsEl.innerHTML = fmt('Nodes: %N% &nbsp;|&nbsp; Edges: %length% &nbsp;|&nbsp; Largest component: <strong>%maxSize%</strong> nodes', { N: N, length: edges.length, maxSize: maxSize });

  // Threshold label
  const threshold = 1 / N;
  let tag = '', cls = '';
  if (p < threshold * 0.85) { tag = 'below threshold'; cls = 'below'; }
  else if (p <= threshold * 1.15) { tag = '≈ threshold 1/n'; cls = 'at'; }
  else { tag = 'above threshold'; cls = 'above'; }
  thresholdTag.textContent = tag;
  thresholdTag.className = 'threshold-tag ' + cls;
}

function update() {
  const p = parseInt(slider.value) / 100;
  probVal.textContent = 'p = ' + p.toFixed(2);
  draw(p);
}

slider.addEventListener('input', update);
document.getElementById('btn-rebuild').addEventListener('click', update);
document.getElementById('btn-reset').addEventListener('click', () => {
  slider.value = 0;
  update();
});

update();

// Node-side verification (run with node to check threshold math)
// At p=1/N=0.05 (N=20), expected edges = C(20,2)*0.05 = 190*0.05 = 9.5
// Giant component expected size ~ 2*eps*N for p=(1+eps)/N
// For p=0.1=(1+1)/N with N=20: eps=1, expected giant ~ 2*1*0.8*20 ≈ (by formula) beta*N
// where beta satisfies beta + e^(-2*beta) = 1 -> beta ≈ 0.797 -> giant ≈ 15.9 nodes
console.log(fmt('Erdős–Rényi demo loaded. N=%N%, threshold p=%v%', { N: N, v: (1/N).toFixed(4) }));

Result

Console

Notice the asymmetry. Below the threshold the graph is a collection of small, mostly isolated pieces — the largest component stays small. Cross the threshold and a single component suddenly dominates, swallowing most nodes in one leap. The slider moves continuously; the graph changes abruptly. That abruptness is the mathematical signature of a phase transition.

The Real Complexity

The Erdős–Rényi result is proven — this is settled mathematics, not a conjecture. The key facts, established in the original 1960 paper and refined over subsequent decades:

Below the threshold (p < 1/n): with high probability the largest connected component has $O(\log *n*)$ nodes. The graph is a forest of small trees.
At the threshold (p = 1/n): a component of size $\Theta(n^{2/3})$ appears — the "double jump." The graph teeters on the edge.
Above the threshold (p > 1/n): a giant component containing a constant fraction of all nodes appears with high probability, and it is unique. Every other component has $O(\log *n*)$ nodes.
The window is sharp: if p = $(1 + \varepsilon)/n$ for any fixed $\varepsilon > 0$ , the giant component contains approximately $2\varepsilon$ fraction of the nodes. The transition is not gradual — it is a genuine discontinuity in the derivative of the order parameter as $n \to \infty$ .

This is analogous to percolation theory in physics, where a material suddenly conducts electricity when enough random bonds are present. The Erdős–Rényi model is the pure combinatorial version of the same phenomenon.

The proof technique uses branching processes: the component containing a given node grows like a Galton–Watson tree. Below 1/n the branching factor is less than 1 and the tree dies out quickly. Above 1/n the branching factor exceeds 1 and there is a positive probability of infinite survival — which, in a finite graph, translates to a giant component. For related threshold phenomena in constraint problems, see P vs NP and random SAT.

Where It Matters

The phase transition is not merely mathematical decoration — it appears whenever you ask "does a large random system suddenly acquire global structure?":

Epidemics: in the SIR model, an infection spreads to a giant fraction of the population only when the reproduction number $R_0$ crosses 1. This is the Erdős–Rényi threshold in disguise — the "contact graph" of infections undergoes the same transition.
Internet and social networks: real networks are not purely random, but the giant-component threshold still governs when a network becomes robustly connected — and when removing random nodes (failures) will fragment it.
Percolation and materials: bond percolation on a lattice is a geometric cousin of the G(n,p) model. The threshold determines when a material transitions from insulator to conductor.
Distributed systems: many consensus and gossip protocols rely on random communication graphs. The Erdős–Rényi threshold tells engineers how many random contacts each node needs before information reaches everyone.
Random SAT: the satisfiability phase transition — where random SAT formulas flip from almost-surely satisfiable to almost-surely unsatisfiable — is governed by the same mathematics.

Understanding this transition means understanding emergence: the moment when many independent local choices suddenly produce a global property no single choice could create alone.

Conclusion

Erdős and Rényi gave us more than a theorem about graphs — they gave us a language for sudden change. Below 1/n the world is dust. Above it, order erupts. The transition is provably sharp, provably universal, and provably tied to some of the deepest phenomena in science.

The next time you hear about a disease reaching epidemic proportions, a social movement going viral, or a distributed network suddenly becoming reliable, you are watching the same mathematics. The giant component does not grow gradually — it snaps into existence, and Erdős and Rényi told us exactly where and why.

For more threshold phenomena in computation, explore P vs NP — where problems flip from tractable to intractable — or percolation, the geometric twin of this very story.

Comments

Loading comments...

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

Cookies & privacy

Erdős–Rényi Random Graphs

When random connections suddenly create a giant whole