The normal distribution

The video below shows an example of a Galton board or a Quincunx board, which demonstrates how the normal distribution arises from the sum of many independent random variables.

This video demonstrates a device known as a Galton Board (also called a quincunx or bean machine). It is a desktop probability machine that visualizes abstract statistical concepts.

Here is a breakdown of what is happening:

• The Setup: The device contains thousands of tiny steel beads. When the board is flipped, the beads flow through a funnel at the top and cascade down through rows of pegs arranged in a hexagonal pattern.
• The “Random Walk”: As each bead hits a peg, it has a roughly 50/50 chance of bouncing to the left or to the right. This happens repeatedly as the bead falls through multiple rows of pegs.
• The Result: While the path of any single bead is random and unpredictable, the result of thousands of beads falling is mathematically predictable. To end up in the bins on the far left or far right, a bead would have to bounce in the same direction almost every single time (e.g., Left-Left-Left-Left), which is statistically rare. It is much more likely for a bead to bounce left and right roughly an equal number of times, causing it to land in the center bins.
• The Bell Curve: As the beads accumulate at the bottom, they form a shape known as the Normal Distribution (or Bell Curve).

This machine, invented by Sir Francis Galton in the 19th century, is a perfect physical demonstration of the Central Limit Theorem. It shows how the sum of many independent random variables (the left/right bounces) tends to produce a normal distribution, regardless of the original distribution of the variables.

Simulating a Galton board

Use the interactive simulation below to experiment with the Central Limit Theorem and the concept of Drift.

• Number of balls: Controls the sample size. This demonstrates the Law of Large Numbers: as the number of trials increases, the empirical distribution converges to the theoretical distribution (the red curve).
• Bias: Represents the probability of a “right” move versus a “left” move at each peg.
  • 50% Bias: Represents a standard random walk where \(p=0.5\). The distribution centers in the middle.
  • > 50% Bias: Analogous to an asset with a positive expected return (positive drift). The distribution shifts right.
  • < 50% Bias: Analogous to a negative drift. The distribution shifts left.

Matter = require("https://cdn.jsdelivr.net/npm/[email protected]/build/matter.min.js");

viewof ballCount = Inputs.range([100, 800], { 
  step: 50, 
  value: 600, 
  label: "Number of balls" 
});

viewof biasPct = Inputs.range([45, 55], { 
  step: 1, 
  value: 50, 
  label: "Bias (0% = all left, 100% = all right)" 
});

viewof rerun = {
  const btn = html`<button style="
    background: #2f71d5;
    color: white;
    border: none;
    border-radius: 10px;
    padding: 0.55rem 1.3rem;
    font-weight: 600;
    cursor: pointer;
  ">Drop balls</button>`;

  // Keep Observable-style reactive semantics by updating the value on each click.
  let clicks = 0;
  btn.value = clicks;
  btn.addEventListener("click", () => {
    btn.value = ++clicks;
    btn.dispatchEvent(new Event("input", { bubbles: true }));
  });

  return btn;
};

galtonBoard = {
  // Referencing these values makes the simulation reactive to slider updates or button clicks.
  const runId = rerun;
  const bias = biasPct / 100;

  const container = html`<div style="
    width: min(100%, 480px);
    aspect-ratio: 5 / 6;
    height: auto;
    min-height: 320px;
    margin: 0 auto;
    background: #f8fafc;
    border: 1px solid #e5e7eb;
    border-radius: 12px;
    box-shadow: 0 12px 28px rgba(15, 23, 42, 0.12);
    overflow: hidden;
  "></div>`;

  // Do not start dropping until the button is pressed.
  if (!runId) {
    container.style.display = "flex";
    container.style.alignItems = "center";
    container.style.justifyContent = "center";
    container.style.color = "#1f2937";
    container.style.fontWeight = "600";
    container.textContent = "Press “Drop balls” to start the simulation.";
    return container;
  }

  const cleanup = setupGaltonBoard(container, { ballCount, bias });
  invalidation.then(() => cleanup());
  return container;
}

setupGaltonBoard = (container, { ballCount, bias }) => {
  const {
    Engine,
    Render,
    Runner,
    Composite,
    Bodies,
    Events,
  } = Matter;

  const WIDTH = 1000;
  const HEIGHT = 1200;
  const WALL_THICKNESS = 20;
  const PEG_ROWS = 21;
  const PEG_START_Y = 100;
  const PEG_SPACING_Y = 32;
  const PEG_SPACING_X = 35;
  const PEG_RADIUS = 3;
  const BALL_RADIUS = 4.5;
  const lastPegY = PEG_START_Y + (PEG_ROWS - 1) * PEG_SPACING_Y;
  const BIN_HEIGHT = HEIGHT - lastPegY;
  const DIVIDER_WIDTH = 4;

  container.innerHTML = "";

  const engine = Engine.create({
    enableSleeping: true,
    positionIterations: 15,
    velocityIterations: 15,
  });

  engine.gravity.x = (bias - 0.5) * 1.5;
  engine.gravity.y = 1;

  const render = Render.create({
    element: container,
    engine,
    options: {
      width: WIDTH,
      height: HEIGHT,
      wireframes: false,
      background: "#f3f4f6",
      pixelRatio: window.devicePixelRatio,
      showSleeping: false,
    },
  });

  // Make the canvas responsive to the container.
  render.canvas.style.width = "100%";
  render.canvas.style.height = "100%";

  const runner = Runner.create();
  const world = engine.world;
  const staticBodies = [];

  // Walls
  staticBodies.push(
    Bodies.rectangle(WIDTH / 2, HEIGHT + 50, WIDTH + 200, 100, {
      isStatic: true,
      render: { fillStyle: "#374151" },
    }),
    Bodies.rectangle(0 - WALL_THICKNESS / 2, HEIGHT / 2, WALL_THICKNESS, HEIGHT, {
      isStatic: true,
      render: { fillStyle: "#374151" },
    }),
    Bodies.rectangle(WIDTH + WALL_THICKNESS / 2, HEIGHT / 2, WALL_THICKNESS, HEIGHT, {
      isStatic: true,
      render: { fillStyle: "#374151" },
    })
  );

  // Funnel
  staticBodies.push(
    Bodies.rectangle(WIDTH / 2 - 60, 50, 120, 10, {
      isStatic: true,
      angle: Math.PI / 3,
      render: { fillStyle: "#4b5563" },
    }),
    Bodies.rectangle(WIDTH / 2 + 60, 50, 120, 10, {
      isStatic: true,
      angle: -Math.PI / 3,
      render: { fillStyle: "#4b5563" },
    })
  );

  // Pegs
  for (let row = 0; row < PEG_ROWS; row++) {
    const y = PEG_START_Y + row * PEG_SPACING_Y;
    const itemsInRow = row + 3;
    const halfWidth = ((itemsInRow - 1) * PEG_SPACING_X) / 2;
    const startX = WIDTH / 2 - halfWidth;

    for (let j = 0; j < itemsInRow; j++) {
      const x = startX + j * PEG_SPACING_X;
      staticBodies.push(
        Bodies.circle(x, y, PEG_RADIUS, {
          isStatic: true,
          render: { fillStyle: "#374151" },
          restitution: 0.5,
          friction: 0,
        })
      );
    }
  }

  // Bin dividers
  const lastRowItems = PEG_ROWS - 1 + 3;
  const lastRowHalfWidth = ((lastRowItems - 1) * PEG_SPACING_X) / 2;
  const lastRowStartX = WIDTH / 2 - lastRowHalfWidth;
  const binCenters = Array.from({ length: lastRowItems - 1 }, (_, i) => (
    lastRowStartX + PEG_SPACING_X * (i + 0.5)
  ));

  for (let j = 0; j < lastRowItems; j++) {
    const x = lastRowStartX + j * PEG_SPACING_X;
    const isEdge = j === 0 || j === lastRowItems - 1;
    const dividerHeight = isEdge ? HEIGHT - PEG_START_Y : BIN_HEIGHT;
    const dividerWidth = isEdge ? 24 : DIVIDER_WIDTH;
    staticBodies.push(
      Bodies.rectangle(x, HEIGHT - dividerHeight / 2, dividerWidth, dividerHeight, {
        isStatic: true,
        render: { fillStyle: "#374151" },
        friction: 0.1,
        restitution: 0.1,
      })
    );
  }

  Composite.add(world, staticBodies);

  Render.run(render);
  Runner.run(runner, engine);

  // Pre-compute a normal curve to overlay on the bins so users can compare the shape.
  const trials = PEG_ROWS;
  const p = 0.5; // Keep the reference curve unbiased regardless of slider bias.
  const mean = trials * p;
  const stdDev = Math.sqrt(trials * p * (1 - p));
  const erf = (x) => {
    const sign = Math.sign(x);
    const a1 = 0.254829592;
    const a2 = -0.284496736;
    const a3 = 1.421413741;
    const a4 = -1.453152027;
    const a5 = 1.061405429;
    const pVal = 0.3275911;
    const absX = Math.abs(x);
    const t = 1 / (1 + pVal * absX);
    const y = 1 - (((((a5 * t + a4) * t + a3) * t + a2) * t + a1) * t) * Math.exp(-absX * absX);
    return sign * y;
  };
  const normalCdf = (x) => 0.5 * (1 + erf((x - mean) / (stdDev * Math.SQRT2)));
  const binProbabilities = binCenters.map((_, i) => {
    const left = i - 0.5;
    const right = i + 0.5;
    return Math.max(0, normalCdf(right) - normalCdf(left));
  });
  const baseY = HEIGHT - 8;
  const maxCurveHeight = BIN_HEIGHT - 30;
  const expectedCounts = binProbabilities.map((prob) => prob * ballCount);
  const maxExpectedCount = Math.max(...expectedCounts, 1);
  const basePixelsPerBall = 1.5;
  const pixelsPerBall = Math.min(basePixelsPerBall, maxCurveHeight / maxExpectedCount);
  const normalCurvePoints = binCenters.map((x, i) => {
    const scaled = expectedCounts[i] * pixelsPerBall;
    return { x, y: baseY - scaled };
  });

  const drawNormalCurve = () => {
    const ctx = render.context;
    ctx.save();
    const gradient = ctx.createLinearGradient(0, baseY - maxCurveHeight, 0, baseY);
    gradient.addColorStop(0, "rgba(220, 38, 38, 0.85)");
    gradient.addColorStop(1, "rgba(220, 38, 38, 0.25)");
    ctx.strokeStyle = gradient;
    ctx.lineWidth = 4;
    ctx.beginPath();
    normalCurvePoints.forEach(({ x, y }, index) => {
      if (index === 0) {
        ctx.moveTo(x, y);
      } else {
        ctx.lineTo(x, y);
      }
    });
    ctx.stroke();
    ctx.restore();
  };

  Events.on(render, "afterRender", drawNormalCurve);

  let ballsCreated = 0;
  const interval = setInterval(() => {
    if (ballsCreated >= ballCount) {
      clearInterval(interval);
      return;
    }

    const randomOffset = (Math.random() - 0.5) * 10;
    const ball = Bodies.circle(WIDTH / 2 + randomOffset, -20, BALL_RADIUS, {
      restitution: 0.5,
      friction: 0.001,
      frictionAir: 0.04,
      sleepThreshold: 30,
      density: 0.04,
      render: { fillStyle: "#3b82f6" },
    });

    Composite.add(engine.world, ball);
    ballsCreated += 1;
  }, 40);

  return () => {
    clearInterval(interval);
    Render.stop(render);
    Runner.stop(runner);
    Events.off(render, "afterRender", drawNormalCurve);
    Composite.clear(world, false, true);
    Engine.clear(engine);
    if (render.canvas) render.canvas.remove();
  };
};

Visualizing the normal density

Below you can find a plot of two density functions from a Normal distribution. The blue curve shows the standard Normal(0, 1), while the red curve lets you adjust the mean and standard deviation to see how the shape shifts.

The relationship between a general normal variable \(X\) and the standard normal variable \(Z\) is given by the Z-score formula: \[ Z = \frac{X - \mu}{\sigma} \] This standardization allows us to compare different normal distributions and is fundamental for calculations like Value-at-Risk (VaR).

Change those parameters using the sliders below and see how this affects the density function (area in red).

For more on the Normal distribution refer to:

• Normal Distribution – from Wolfram MathWorld
  
• Probability density function - Wikipedia

The normal density for \(X \sim \mathcal{N}(\mu, \sigma^2)\) is

\[ f_X(x) = \frac{1}{\sigma \sqrt{2\pi}}\exp\left(-\frac{(x-\mu)^2}{2\sigma^2}\right). \]

Financial Context: Returns vs. Prices

In finance, we often assume that the log-returns of an asset are normally distributed: \[ \ln(S_t/S_{t-1}) \sim \mathcal{N}(\mu, \sigma^2) \] This implies that the asset prices themselves follow a Log-Normal Distribution.

• Limited Liability: While returns can be negative, asset prices cannot be negative. This is a key reason we model prices as Log-Normal (domain \(0\) to \(\infty\)) rather than Normal (domain \(-\infty\) to \(\infty\)).

The Cumulative Distribution Function (CDF) of the standard normal distribution, often denoted as \(N(x)\) or \(\Phi(x)\), represents the probability that a variable takes a value less than or equal to \(x\) (the area under the curve to the left). This plays a critical role in the Black-Scholes-Merton option pricing model (specifically in the \(N(d_1)\) and \(N(d_2)\) terms).

Critique: Real-world financial data often deviates from normality:

• “Fat Tails” (Excess Kurtosis): Extreme events (crashes or booms) happen more frequently than predicted.
• Skewness: Markets often exhibit asymmetry (e.g., equity markets frequently have negative skewness, implying higher crash risk).

Plot = require("@observablehq/plot")
viewof mean = Inputs.range([-2, 2], { step: 0.1, label: "Mean", value: 0 })
viewof sd = Inputs.range([0.1, 5], { step: 0.1, label: "Standard deviation", value: 1 })

normalDensities = {
  // Expand the x-range as sd grows so wide curves aren’t clipped.
  const span = Math.max(6, 5 * sd);          // cover at least ±5σ of the wider dist
  const start = Math.min(-span, mean - span);
  const end = Math.max(span, mean + span);
  const steps = 1201;
  const step = (end - start) / (steps - 1);
  const x = Array.from({ length: steps }, (_, i) => start + i * step);

  // Error function approximation for CDF
  const erf = (x) => {
    const sign = Math.sign(x);
    const a1 = 0.254829592;
    const a2 = -0.284496736;
    const a3 = 1.421413741;
    const a4 = -1.453152027;
    const a5 = 1.061405429;
    const pVal = 0.3275911;
    const absX = Math.abs(x);
    const t = 1 / (1 + pVal * absX);
    const y = 1 - (((((a5 * t + a4) * t + a3) * t + a2) * t + a1) * t) * Math.exp(-absX * absX);
    return sign * y;
  };

  // PDF
  function dnorm(x, mu = 0, sigma = 1) {
    return (1 / (sigma * Math.sqrt(2 * Math.PI))) *
           Math.exp(-0.5 * Math.pow((x - mu) / sigma, 2));
  }

  // CDF
  function pnorm(x, mu = 0, sigma = 1) {
    return 0.5 * (1 + erf((x - mu) / (sigma * Math.SQRT2)));
  }

  // Calculate y values for both distributions
  return x.map((xi) => ({
    x: xi,
    pdf_std: dnorm(xi),
    pdf_param: dnorm(xi, mean, sd),
    cdf_std: pnorm(xi),
    cdf_param: pnorm(xi, mean, sd)
  }));
}

(() => {
  const sigma = [1, 2, 3];
  const sigmaColors = { 1: "#0ea5e9", 2: "#f59e0b", 3: "#8b5cf6" };
  const sigmaProb = { 1: "68.3%", 2: "95.5%", 3: "99.7%" };
  const xMax = normalDensities[normalDensities.length - 1].x;
  const verticalMarkers = [
    { x: mean, label: "Mean (μ)" },
    { x: mean - sd, label: "-1σ", k: 1 },
    { x: mean + sd, label: "+1σ", k: 1 },
    { x: mean - 2 * sd, label: "-2σ", k: 2 },
    { x: mean + 2 * sd, label: "+2σ", k: 2 },
    { x: mean - 3 * sd, label: "-3σ", k: 3 },
    { x: mean + 3 * sd, label: "+3σ", k: 3 },
  ];

  const sigmaLinesPdf = sigma.map((k) => ({
    k,
    xLeft: mean - k * sd,
    xRight: mean + k * sd,
    y: (1 / (sd * Math.sqrt(2 * Math.PI))) * Math.exp(-0.5 * k * k),
  }));

  const sigmaLineSegments = sigmaLinesPdf.flatMap((d) => ([
    { k: d.k, x: d.xLeft, y: d.y },
    { k: d.k, x: d.xRight, y: d.y },
  ]));

  return Plot.plot({
    caption: "Normal Density Function (PDF)",
    height: 320,
    x: { label: "" },
    y: { label: "Density" },
    marks: [
      Plot.ruleY([0]),
      Plot.ruleX(verticalMarkers, { x: "x", title: "label", stroke: (d) => d.k ? sigmaColors[d.k] : "#94a3b8", strokeOpacity: (d) => d.k ? 0.8 : 0.45, strokeDasharray: (d) => d.k ? "6,3" : "4,4", strokeWidth: (d) => d.k ? 1.5 : 1, tip: true }),
      Plot.line(sigmaLineSegments, { x: "x", y: "y", stroke: (d) => sigmaColors[d.k], strokeOpacity: 0.8, strokeDasharray: "5,4", sort: "x", strokeWidth: 1.4, z: "k" }),
      Plot.text(sigmaLinesPdf, { x: mean, y: "y", text: (d) => `±${d.k}σ (${sigmaProb[d.k]})`, dy: -6, textAnchor: "middle", fill: (d) => sigmaColors[d.k], fontSize: 11, fontWeight: 600 }),
      Plot.areaY(normalDensities, { x: "x", y: "pdf_std", fill: "steelblue", fillOpacity: 0.2 }),
      Plot.areaY(normalDensities, { x: "x", y: "pdf_param", fill: "crimson", fillOpacity: 0.2 })
    ],
  });
})()

(() => {
  const sigma = [1, 2, 3];
  const sigmaColors = { 1: "#0ea5e9", 2: "#f59e0b", 3: "#8b5cf6" };
  const sigmaProb = { 1: "68.3%", 2: "95.5%", 3: "99.7%" };
  const verticalMarkers = [
    { x: mean, label: "Mean (μ)" },
    { x: mean - sd, label: "-1σ", k: 1 },
    { x: mean + sd, label: "+1σ", k: 1 },
    { x: mean - 2 * sd, label: "-2σ", k: 2 },
    { x: mean + 2 * sd, label: "+2σ", k: 2 },
    { x: mean - 3 * sd, label: "-3σ", k: 3 },
    { x: mean + 3 * sd, label: "+3σ", k: 3 },
  ];
  const erfLocal = (x) => {
    const sign = Math.sign(x);
    const a1 = 0.254829592;
    const a2 = -0.284496736;
    const a3 = 1.421413741;
    const a4 = -1.453152027;
    const a5 = 1.061405429;
    const pVal = 0.3275911;
    const absX = Math.abs(x);
    const t = 1 / (1 + pVal * absX);
    const y = 1 - (((((a5 * t + a4) * t + a3) * t + a2) * t + a1) * t) * Math.exp(-absX * absX);
    return sign * y;
  };
  const cdfGuides = sigma.map((k) => ({
    k,
    xLeft: mean - k * sd,
    xRight: mean + k * sd,
    y: 0.5 * (1 + erfLocal(k / Math.SQRT2)),
  }));
  const cdfLineSegments = cdfGuides.flatMap((d) => ([
    { k: d.k, x: d.xLeft, y: d.y },
    { k: d.k, x: d.xRight, y: d.y },
  ]));

  return Plot.plot({
    caption: "Cumulative Distribution Function (CDF)",
    height: 320,
    x: { label: "" },
    y: { label: "Probability", domain: [0, 1] },
    marks: [
      Plot.ruleY([0]),
      Plot.ruleY([1], { strokeOpacity: 0.1 }),
      Plot.ruleX(verticalMarkers, { x: "x", title: "label", stroke: (d) => d.k ? sigmaColors[d.k] : "#94a3b8", strokeOpacity: (d) => d.k ? 0.8 : 0.45, strokeDasharray: (d) => d.k ? "6,3" : "4,4", strokeWidth: (d) => d.k ? 1.5 : 1, tip: true }),
      Plot.line(cdfLineSegments, { x: "x", y: "y", stroke: (d) => sigmaColors[d.k], strokeOpacity: 0.8, strokeDasharray: "5,4", sort: "x", strokeWidth: 1.4, z: "k" }),
      Plot.text(cdfGuides, { x: mean, y: "y", text: (d) => `±${d.k}σ (${sigmaProb[d.k]})`, dy: -6, textAnchor: "middle", fill: (d) => sigmaColors[d.k], fontSize: 11, fontWeight: 600 }),
      Plot.areaY(normalDensities, { x: "x", y: "cdf_std", fill: "steelblue", fillOpacity: 0.16 }),
      Plot.areaY(normalDensities, { x: "x", y: "cdf_param", fill: "crimson", fillOpacity: 0.16 }),
      Plot.lineY(normalDensities, { x: "x", y: "cdf_std", stroke: "steelblue", strokeWidth: 2.4, strokeDasharray: "6,4", strokeOpacity: 0.9, title: "Standard Normal CDF" }),
      Plot.lineY(normalDensities, { x: "x", y: "cdf_param", stroke: "crimson", strokeWidth: 2.4, strokeOpacity: 0.9, title: "Parameterized CDF" })
    ],
  });
})()