Introduction

In 1713, the mathematician Nicolas Bernoulli wrote a letter containing a simple game. A casino flips a fair coin repeatedly until it lands heads. If heads appears on the first flip, you win $2. On the second flip, $4. On the third, $8 — and so on: the prize doubles every time tails appears. Your payoff if heads comes on flip n is 2n2^{n} dollars.

The puzzle: how much would you pay to play?

Classical probability says the fair price equals the expected value — the average payoff over infinitely many games. Let's compute it: there's a ½ chance of winning $2, a ¼ chance of winning $4, a ⅛ chance of winning $8, and so on.

Expected value=12×2+14×4+18×8+⋯=1+1+1+⋯=∞\text{Expected value} = \tfrac{1}{2}\times 2 + \tfrac{1}{4}\times 4 + \tfrac{1}{8}\times 8 + \cdots = 1 + 1 + 1 + \cdots = \infty

Every term contributes exactly $1, and there are infinitely many terms. The expected value is infinite. Classical theory says a rational player should pay any finite amount to enter.

Yet ask real people — economists, mathematicians, anyone — and they'll offer a few dollars at most. This gap between theory and intuition is the St. Petersburg Paradox, and resolving it took two centuries and reshaped how we model rational decision-making.

Try It

Click Run games to simulate rounds of the St. Petersburg game. Each round flips a fair coin until heads, then records the payoff 2n2^{n}. Watch what the typical payout really looks like.

<div class="controls">
  <label>Games per run:
    <select id="numGames">
      <option value="100">100</option>
      <option value="500" selected>500</option>
      <option value="2000">2,000</option>
      <option value="10000">10,000</option>
    </select>
  </label>
  <button id="runBtn" type="button">Run games</button>
  <button id="resetBtn" type="button" class="ghost">Reset</button>
</div>
<div class="stats" id="stats"></div>
<div class="chart-wrap">
  <canvas id="chart" width="540" height="220"></canvas>
</div>
<div class="legend">
  <span class="dot dot-bar"></span> Fraction of games ending on flip n &nbsp;
  <span class="dot dot-avg"></span> Running average payout
</div>

* { box-sizing: border-box; }
body { font-family: system-ui, sans-serif; color: #222; margin: 0; padding: 14px; }
.controls { display: flex; align-items: center; gap: .6rem; flex-wrap: wrap; margin-bottom: .6rem; }
label { font-size: .88rem; color: #444; }
select { font-size: .88rem; padding: .25rem .4rem; border: 1px solid #aaa; border-radius: 6px; background: #fff; }
button { font: 600 13px system-ui; padding: .4rem .85rem; border: 1px solid #1d3557;
         background: #1d3557; color: #fff; border-radius: 8px; cursor: pointer; }
button.ghost { background: #fff; color: #1d3557; }
.stats { font-size: .88rem; min-height: 1.3em; margin-bottom: .4rem; color: #333; }
.stats b { color: #1d3557; }
.chart-wrap { width: 100%; overflow-x: auto; }
canvas { display: block; max-width: 100%; }
.legend { font-size: .78rem; color: #555; margin-top: .35rem; display: flex; align-items: center; gap: .3rem; flex-wrap: wrap; }
.dot { display: inline-block; width: 12px; height: 12px; border-radius: 2px; vertical-align: middle; }
.dot-bar { background: #457b9d; }
.dot-avg { background: #e63946; }

const fmt = (s, v) => s.replace(/%(\w+)%/g, (_, k) => String(v[k] ?? ''));
// St. Petersburg game: flip fair coin until heads; win 2^n where n = flip number.
// Demonstrates that almost all payouts are tiny (2 or 4) but the rare jackpot
// dominates the theoretical expectation, causing the running average to never settle.

function playGame() {
  let n = 1;
  // Each flip: 0.5 chance of heads (stop), 0.5 of tails (continue)
  while (Math.random() >= 0.5) n++;
  return { n, payout: Math.pow(2, n) };
}

let allPayouts = [];
let runningAvgs = [];

function runGames(count) {
  for (let i = 0; i < count; i++) {
    const { n, payout } = playGame();
    allPayouts.push({ n, payout });
    const prev = runningAvgs.length ? runningAvgs[runningAvgs.length - 1] : 0;
    const total = allPayouts.length;
    runningAvgs.push(prev + (payout - prev) / total);
  }
}

function computeStats() {
  if (!allPayouts.length) return null;
  const payouts = allPayouts.map(g => g.payout);
  const total = payouts.length;
  const mean = runningAvgs[runningAvgs.length - 1];
  const median = [...payouts].sort((a,b)=>a-b)[Math.floor(total/2)];
  const max = Math.max(...payouts);
  const maxN = allPayouts.reduce((a,g) => g.payout > a.payout ? g : a).n;
  return { total, mean, median, max, maxN };
}

function buildFreqMap() {
  const freq = {};
  for (const { n } of allPayouts) freq[n] = (freq[n] || 0) + 1;
  return freq;
}

function drawChart() {
  const canvas = document.getElementById('chart');
  const ctx = canvas.getContext('2d');
  const W = canvas.offsetWidth || 540;
  canvas.width = W;
  const H = 220;
  canvas.height = H;
  ctx.clearRect(0, 0, W, H);

  const total = allPayouts.length;
  if (!total) {
    ctx.fillStyle = '#aaa';
    ctx.font = '13px system-ui';
    ctx.textAlign = 'center';
    ctx.fillText('Click "Run games" to start', W / 2, H / 2);
    return;
  }

  const freq = buildFreqMap();
  const maxFlip = Math.max(15, ...Object.keys(freq).map(Number));
  const SHOW = Math.min(maxFlip, 20);

  // Bar chart: fraction of games ending on each flip n=1..SHOW
  const barPad = { l: 48, r: 16, t: 16, b: 36 };
  const barH = H - barPad.t - barPad.b;
  const barW = W - barPad.l - barPad.r;
  const maxFrac = Math.max(...Array.from({length: SHOW}, (_, i) => (freq[i+1]||0)/total));

  // Y axis label
  ctx.fillStyle = '#555'; ctx.font = '10px system-ui'; ctx.textAlign = 'right';
  for (let t = 0; t <= 4; t++) {
    const frac = maxFrac * t / 4;
    const y = barPad.t + barH - (barH * t / 4);
    ctx.fillText((frac * 100).toFixed(1) + '%', barPad.l - 4, y + 3);
    ctx.strokeStyle = '#e0e0e0'; ctx.lineWidth = 0.5;
    ctx.beginPath(); ctx.moveTo(barPad.l, y); ctx.lineTo(barPad.l + barW, y); ctx.stroke();
  }

  const bw = barW / SHOW;
  for (let i = 0; i < SHOW; i++) {
    const n = i + 1;
    const frac = (freq[n] || 0) / total;
    const bh = maxFrac ? (frac / maxFrac) * barH : 0;
    const x = barPad.l + i * bw;
    const y = barPad.t + barH - bh;
    ctx.fillStyle = '#457b9d';
    ctx.fillRect(x + 1, y, bw - 2, bh);

    // X tick labels
    if (n === 1 || n % 5 === 0) {
      ctx.fillStyle = '#666'; ctx.font = '10px system-ui'; ctx.textAlign = 'center';
      ctx.fillText('n=' + n, x + bw / 2, barPad.t + barH + 14);
    }
  }

  // Running average line (right y-axis in log scale for visual)
  // We draw the running average as a thin red line over the last SHOW*? points, normalized
  if (runningAvgs.length > 1) {
    const pts = runningAvgs;
    const maxAvg = Math.max(...pts);
    const minAvg = Math.min(...pts);
    const range = maxAvg - minAvg || 1;

    ctx.strokeStyle = '#e63946'; ctx.lineWidth = 1.5;
    ctx.beginPath();
    for (let i = 0; i < pts.length; i++) {
      const x = barPad.l + (i / (pts.length - 1)) * barW;
      const y = barPad.t + barH - ((pts[i] - minAvg) / range) * barH;
      i === 0 ? ctx.moveTo(x, y) : ctx.lineTo(x, y);
    }
    ctx.stroke();

    // Label current average
    const lastAvg = pts[pts.length - 1];
    ctx.fillStyle = '#e63946'; ctx.font = 'bold 10px system-ui'; ctx.textAlign = 'left';
    ctx.fillText(fmt('avg $%lastAvg%', { lastAvg: lastAvg.toFixed(2) }), barPad.l + barW - 70, barPad.t + 12);
  }

  // Axes
  ctx.strokeStyle = '#999'; ctx.lineWidth = 1;
  ctx.beginPath(); ctx.moveTo(barPad.l, barPad.t); ctx.lineTo(barPad.l, barPad.t + barH); ctx.lineTo(barPad.l + barW, barPad.t + barH); ctx.stroke();
}

function updateStats() {
  const s = computeStats();
  const el = document.getElementById('stats');
  if (!s) { el.textContent = ''; return; }
  el.innerHTML =
    fmt('<b>%total% games</b> — running avg: <b>$%mean%</b> &nbsp;|&nbsp; median: <b>$%median%</b> &nbsp;|&nbsp; best: <b>$%max%</b> (flip %maxN%)', { total: s.total.toLocaleString(), mean: s.mean.toFixed(2), median: s.median, max: s.max.toLocaleString(), maxN: s.maxN });
}

document.getElementById('runBtn').addEventListener('click', () => {
  const count = parseInt(document.getElementById('numGames').value, 10);
  runGames(count);
  updateStats();
  drawChart();
});
document.getElementById('resetBtn').addEventListener('click', () => {
  allPayouts = []; runningAvgs = [];
  document.getElementById('stats').textContent = '';
  drawChart();
});

// Initial empty chart
drawChart();

// Verify core logic in a deterministic way (seeded-like assertions):
// playGame must return n>=1 and payout = 2^n
// (verified below — comment kept for auditability)
// let g = playGame(); console.assert(g.payout === Math.pow(2, g.n), 'payout=2^n');
Result
Console

Notice the pattern: most games end quickly (heads on flip 1 or 2), paying just $2 or $4. The rare jackpot — 10 or 20 tails in a row — happens almost never in any finite run, even though it dominates the mathematical expectation. The running average can spike dramatically after a lucky game, then drift back down. Infinite expected value doesn't mean you'll ever get rich — it just means the average never settles.

Why the Math Breaks

The paradox is open in its original form: there is no single universally accepted price that classical expected-value theory assigns to the game. It exposed a genuine gap in 18th-century probability, and the fixes proposed over 300 years each illuminate a different truth about rationality.

Daniel Bernoulli's fix (1738): His cousin Nicolas posed the puzzle; Daniel solved it. Instead of maximizing expected money, people maximize expected utility — and utility grows logarithmically with wealth. Doubling your money from $1,000 feels less good than doubling from $1. Under log utility, the St. Petersburg game has finite expected utility, and the willingness-to-pay works out to a modest sum (around $10–$25 depending on wealth). This paper founded expected utility theory, the backbone of modern economics and decision science.

Bounded utility (20th century): If utility is bounded — there's some maximum satisfaction money can buy — then any weighted sum of utilities is finite, resolving the paradox. The debate over whether human utility truly is bounded remains live in behavioral economics.

Kelly's criterion (1956): Bell Labs scientist John L. Kelly Jr. showed that a gambler maximizing the logarithm of wealth — the Kelly bettor — achieves the best long-run growth rate. Kelly betting naturally assigns a finite, reasonable price to St. Petersburg games, and it links Bernoulli's intuition to information theory. Kelly's fraction also explains why even a positive-expected-value bet is worth nothing if it can wipe out your bankroll.

The ergodicity fix (Ole Peters, 2011): A more recent argument notes that expected value averages over a population of parallel universes, but a real player lives through time sequentially. The time-average growth rate — what actually matters for a single player over a long life — is finite and small. This reframes the paradox not as a quirk of utility but as a confusion between ensemble averages and time averages, connecting it to Nash equilibrium and the foundations of game theory.

None of these fixes makes the paradox "wrong" — each reveals a different facet of why raw expected value is insufficient for modeling real decisions under risk.

Where It Matters

Three centuries of grappling with a coin-flip game produced ideas that now power real systems:

  • Portfolio theory and the Kelly criterion: Professional gamblers and quantitative traders use Kelly betting to size positions. The criterion maximizes long-run wealth growth and is derived directly from the log-utility insight Bernoulli used to fix the paradox. It tells you how much to bet, not just whether to bet.
  • Insurance and risk aversion: Insurance markets exist because people pay more than the expected loss to avoid ruin. That makes no sense under expected-value theory, but is perfectly rational under concave (log-like) utility. The St. Petersburg Paradox was the first formal statement of this idea.
  • Behavioral economics and prospect theory: Kahneman and Tversky's Prospect Theory (1979 Nobel Prize, 2002) generalizes Bernoulli's utility approach: people weigh losses more than equal gains (loss aversion) and distort small probabilities upward. The paradox motivated this entire research program.
  • Algorithmic trading and tail risk: Markets occasionally produce St.-Petersburg-style tail events — huge but rare payoffs (or losses). Strategies that look profitable in expectation can be ruinous in practice if they rely on jackpots that a finite trading career will almost never see. Kelly sizing and log-utility accounting avoid this trap.
  • Ergodicity economics: Ole Peters' framework, applied to climate policy and pandemic response, argues that population-average statistics can mislead individual agents navigating sequential risk. The St. Petersburg Paradox is its motivating example.

Conclusion

The St. Petersburg Paradox is unresolved in the deepest sense: there is no consensus on the single "correct" price for the game, and different resolutions — log utility, bounded utility, Kelly betting, ergodicity — each capture something true and something incomplete.

What the paradox has settled, conclusively, is that expected value alone is not enough to model rational choice under risk. Every serious framework for decision-making under uncertainty — expected utility theory, prospect theory, Kelly sizing, ergodicity economics — owes its existence to the 1713 letter in which Nicolas Bernoulli asked: how much would you pay?

The answer, it turns out, depends on who you are, how rich you are, and how long you plan to keep playing. That's not a failure of mathematics — it's a precise and profound statement about the nature of risk.

Share this article

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

Comments

Loading comments...

https://www.kipuhub.com/en/article/st-petersburg-paradox/Content licensed under CC BY-NC 4.0.