Week 2 — Some Math

IAT 461 / 882 · Data Science for Human-Centered Systems · Summer 2026 . Alireza Karduni

Probability

What is probability?

• A formal way to reason about how likely something is to happen
• Built on counting outcomes

Setting up: an experiment

• An experiment is any procedure with a set of possible outcomes
• Example: roll two dice — one red, one blue
• Each face shows a number from 1 to 6

The sample space

All 36 possible outcomes of rolling two dice:

// ─── Shared dice utilities ───────────────────────────────────────────────
// Call diceGrid(highlighted) anywhere in this deck.
// highlighted: array of [red, blue] pairs to highlight, e.g. [[1,6],[2,5]]
// Pass [] for no highlights (show full sample space only)

function diceGrid(A = [], B = [], dimOthers = false, sorted = false) {
  const cellSize = 52;
  const pad = 6;
  const gap = 4;
  const cols = 6, rows = 6;
  const w = cols * (cellSize + gap) + pad * 2;
  const h = rows * (cellSize + gap) + pad * 2;

  const pipPos = {
    1: [[0.5, 0.5]],
    2: [[0.25, 0.25], [0.75, 0.75]],
    3: [[0.25, 0.25], [0.5, 0.5], [0.75, 0.75]],
    4: [[0.25, 0.25], [0.75, 0.25], [0.25, 0.75], [0.75, 0.75]],
    5: [[0.25, 0.25], [0.75, 0.25], [0.5, 0.5], [0.25, 0.75], [0.75, 0.75]],
    6: [[0.25, 0.2], [0.75, 0.2], [0.25, 0.5], [0.75, 0.5], [0.25, 0.8], [0.75, 0.8]]
  };

  function drawDie(parent, x, y, size, face, color = "#222") {
    const r = size * 0.12;
    const pip = size * 0.09;
    const g = parent.append("g").attr("transform", `translate(${x},${y})`);
    g.append("rect")
      .attr("width", size).attr("height", size)
      .attr("rx", r).attr("ry", r)
      .attr("fill", "white")
      .attr("stroke", color)
      .attr("stroke-width", 1.5);
    (pipPos[face] || []).forEach(([px, py]) => {
      g.append("circle")
        .attr("cx", px * size).attr("cy", py * size)
        .attr("r", pip)
        .attr("fill", color);
    });
  }

  const setA = new Set(A.map(([r, b]) => `${r},${b}`));
  const setB = new Set(B.map(([r, b]) => `${r},${b}`));

  // Colors
  const colorAonly  = { bg: "#dbeafe", border: "#3b82f6" }; // blue
  const colorBonly  = { bg: "#fff3e0", border: "#e06c4c" }; // orange
  const colorAandB  = { bg: "#ede9fe", border: "#7c3aed" }; // purple — intersection
  const colorNone   = { bg: "#f8f8f8", border: "#ddd" };

  let outcomes = [];
  for (let red = 1; red <= 6; red++)
    for (let blue = 1; blue <= 6; blue++)
      outcomes.push({ red, blue, key: `${red},${blue}` });

  if (sorted) {
    outcomes.sort((a, b) => {
      const rank = k => setA.has(k) && setB.has(k) ? 0
                      : setA.has(k) || setB.has(k) ? 1 : 2;
      return rank(a.key) - rank(b.key);
    });
  }

  const svg = d3.create("svg")
    .attr("width", w).attr("height", h)
    .style("font-family", "inherit");

  outcomes.forEach(({ red, blue, key }, i) => {
    const col = i % cols;
    const row = Math.floor(i / cols);
    const x = pad + col * (cellSize + gap);
    const y = pad + row * (cellSize + gap);
    const dieSize = (cellSize - 3) / 2;

    const inA = setA.has(key);
    const inB = setB.has(key);
    const inEither = inA || inB;

    const c = inA && inB ? colorAandB
            : inA       ? colorAonly
            : inB       ? colorBonly
            :             colorNone;

    const opacity = dimOthers && !inEither ? 0.25 : 1;

    const cell = svg.append("g").attr("transform", `translate(${x},${y})`);

    cell.append("rect")
      .attr("width", cellSize).attr("height", cellSize)
      .attr("rx", 6)
      .attr("fill", c.bg)
      .attr("stroke", c.border)
      .attr("stroke-width", inEither ? 2 : 1)
      .attr("opacity", opacity);

    const g = cell.append("g").attr("opacity", opacity);
    drawDie(g, 2, 2, dieSize, red, "#c0392b");
    drawDie(g, dieSize + 5, 2, dieSize, blue, "#2980b9");
  });

  return svg.node();
}

diceGrid([])

Each cell = one outcome (red die, blue die) · 36 outcomes total

An event: sum equals 7

An event is any subset of the sample space we care about.

diceGrid([[1,6],[2,5],[3,4],[4,3],[5,2],[6,1]], [],false, false)

An event: sum equals 7

An event is any subset of the sample space we care about.

diceGrid([[1,6],[2,5],[3,4],[4,3],[5,2],[6,1]], [],true, false)

Highlighted outcomes all have red + blue = 7 6 out of 36

Probability of an event

\[P(E) = \frac{\text{outcomes in } E}{\text{total outcomes}} = \frac{6}{36} = \frac{1}{6}\]

• Each outcome is equally likely: \(p = \tfrac{1}{36}\)
• \(P(E)\) is the sum of probabilities of outcomes in \(E\)
• Probabilities always sum to 1 across the full sample space

evenDice = [[2,1],[2,2],[2,3],[2,4],[2,5],[2,6],[4,1],[4,2],[4,3],[4,4],[4,5],[4,6],[6,1],[6,2],[6,3],[6,4],[6,5],[6,6]]

sevenDice = [[1,6],[2,5],[3,4],[4,3],[5,2],[6,1]]

elevenDice = [[5,6],[6,5]]

sevenEleven = [[1,6],[2,5],[3,4],[4,3],[5,2],[6,1],[5,6],[6,5]]

evenAndSevenEleven = [[2,5],[4,3],[6,1],[5,6],[6,5]]

evenOrSevenEleven = [...new Set(evenDice).union(new Set(sevenEleven))]

So what is the probability of getting a dice total of 7 OR 11?

diceGrid(sevenDice,elevenDice, true, false)

So what is the probability of getting a dice total of 7 OR 11?

diceGrid(sevenDice,elevenDice, true,true)

So what is the probability of getting a dice total of 7 OR 11?

diceGrid(sevenEleven,[], true,false)

At least one dice is even?

diceGrid(evenDice, [], true, false)

at leat one is Even OR is a 7 or 11?

diceGrid(evenDice, sevenEleven, true, false)

at leat one is Even AND is a 7 or 11?

diceGrid(evenAndSevenEleven, [], true, false)

At least one dice is even OR is a 7 or 11?

diceGrid(evenOrSevenEleven, [], true, false)

conditional probability

function vennGrid(
  counts = {both: 15, gamesOnly: 20, codingOnly: 10, neither: 5},
  highlight = "all",
  dim = false
) {
  function seededRandom(seed) {
    let s = seed;
    return () => {
      s = (s * 16807 + 0) % 2147483647;
      return (s - 1) / 2147483646;
    };
  }
  const rand = seededRandom(42);

  const total       = counts.both + counts.gamesOnly + counts.codingOnly + counts.neither;
  const totalGames  = counts.both + counts.gamesOnly;
  const totalCoding = counts.both + counts.codingOnly;

  const W = 520, H = 400;
  const cx = W / 2, cy = H / 2 - 10;

  const maxR = 140, minR = 60;
  const rA = minR + (maxR - minR) * (totalGames  / total);
  const rB = minR + (maxR - minR) * (totalCoding / total);

  const overlapFactor = counts.both / total;
  const maxDist = rA + rB - 4;
  const minDist = Math.abs(rA - rB) + 10;
  const dist = maxDist - overlapFactor * (maxDist - minDist) * 2.2;

  const axA = cx - dist / 2;
  const axB = cx + dist / 2;
  const ay  = cy;

  const colors = {
    games:   "#4a90d9",
    coding:  "#e06c4c",
    both:    "#7c3aed",
    neither: "#aaaaaa"
  };

  const active = {
    all:     ["both", "games", "coding", "neither"],
    games:   ["both", "games"],
    coding:  ["both", "coding"],
    both:    ["both"],
    neither: ["neither"],
    union:   ["both", "games", "coding"]
  }[highlight] || ["both", "games", "coding", "neither"];

  const inA = (x, y) => (x - axA) ** 2 + (y - ay) ** 2 <= rA ** 2;
  const inB = (x, y) => (x - axB) ** 2 + (y - ay) ** 2 <= rB ** 2;

  function placeDots(n, condition, maxTries = 3000) {
    const pts = [];
    let tries = 0;
    const p = 10;
    while (pts.length < n && tries < maxTries) {
      tries++;
      const x = p + rand() * (W - p * 2);
      const y = p + rand() * (H - p * 2);
      if (condition(x, y)) pts.push({x, y});
    }
    return pts;
  }

  const dotsBoth    = placeDots(counts.both,       (x, y) =>  inA(x,y) &&  inB(x,y));
  const dotsGames   = placeDots(counts.gamesOnly,  (x, y) =>  inA(x,y) && !inB(x,y));
  const dotsCoding  = placeDots(counts.codingOnly, (x, y) => !inA(x,y) &&  inB(x,y));
  const dotsNeither = placeDots(counts.neither,    (x, y) => !inA(x,y) && !inB(x,y) && x > 10 && x < W-10 && y > 10 && y < H-10);

  const svg = d3.create("svg")
    .attr("width", W)
    .attr("height", H)
    .style("flex-shrink", "0");

  const strokeA = (highlight === "games" || highlight === "both" || highlight === "union" || highlight === "coding")
    ? {color: colors.games, width: 2.5}
    : {color: "#ccc", width: 1.5};

  const strokeB = (highlight === "coding" || highlight === "both" || highlight === "union" || highlight === "games")
    ? {color: colors.coding, width: 2.5}
    : {color: "#ccc", width: 1.5};

  svg.append("circle")
    .attr("cx", axA).attr("cy", ay).attr("r", rA)
    .attr("fill", "#4a90d9").attr("fill-opacity", 0.06)
    .attr("stroke", strokeA.color)
    .attr("stroke-width", strokeA.width);

  svg.append("circle")
    .attr("cx", axB).attr("cy", ay).attr("r", rB)
    .attr("fill", "#e06c4c").attr("fill-opacity", 0.06)
    .attr("stroke", strokeB.color)
    .attr("stroke-width", strokeB.width);

  svg.append("text")
    .attr("x", axA - rA * 0.35).attr("y", ay - rA * 0.75)
    .attr("text-anchor", "middle")
    .attr("font-size", "13px").attr("font-weight", "600")
    .attr("fill", colors.games)
    .attr("opacity", active.includes("games") ? 1 : 0.3)
    .text("Games");

  svg.append("text")
    .attr("x", axB + rB * 0.35).attr("y", ay - rB * 0.75)
    .attr("text-anchor", "middle")
    .attr("font-size", "13px").attr("font-weight", "600")
    .attr("fill", colors.coding)
    .attr("opacity", active.includes("coding") ? 1 : 0.3)
    .text("Coding");

  function drawDots(pts, type) {
    const isActive = active.includes(type);
    pts.forEach(({x, y}) => {
      svg.append("circle")
        .attr("cx", x).attr("cy", y).attr("r", 5)
        .attr("fill", colors[type])
        .attr("opacity", dim && !isActive ? 0.1 : 0.85);
    });
  }

  drawDots(dotsGames,   "games");
  drawDots(dotsCoding,  "coding");
  drawDots(dotsBoth,    "both");
  drawDots(dotsNeither, "neither");

  return svg.node();
}

counts = ({both: 18, gamesOnly: 22, codingOnly: 12, neither: 18})

Meet the department

vennGrid(counts, "all", false)

	Games	No Games	Total
Coding	18	12	30
No Coding	22	18	40
Total	40	30	70

Who likes games?

vennGrid(counts, "games", true)

	Games	No Games	Total
Coding	18	12	30
No Coding	22	18	40
Total	40	30	70

\(P(\text{Games}) = \frac{40}{70} \approx 0.57\)

Who likes coding?

vennGrid(counts, "coding", true)

	Games	No Games	Total
Coding	18	12	30
No Coding	22	18	40
Total	40	30	70

\(P(\text{Coding}) = \frac{30}{70} \approx 0.43\)

Who likes both?

vennGrid(counts, "both", true)

	Games	No Games	Total
Coding	18	12	30
No Coding	22	18	40
Total	40	30	70

\(P(\text{Games} \cap \text{Coding}) = \frac{18}{70} \approx 0.26\)

Conditional probability

We know a student likes coding.

Does that tell us anything about whether they like games?

Limit your view

vennGrid(counts, "coding", true)

	Games	No Games	Total
Coding	18	12	30
No Coding	22	18	40
Total	40	30	70

We only care about the 30 coders.

A smaller world

vennGrid(counts, "coding", true)

Among the 30 coders:

	Games	No Games	Total
Coding	18	12	30

The denominator is no longer 70.
It is 30.

P(Games | Coding)

vennGrid(counts, "both", true)

• Among the 30 coders, 18 also like games.

• \[P(\text{Games} \mid \text{Coding}) = \frac{18}{30} = 0.60\]

• Compare to: \[P(\text{Games}) = \frac{40}{70} \approx 0.57\]

• Knowing someone codes makes them more likely to also game.

The general formula

\[P(A \mid B) = \frac{P(A \cap B)}{P(B)}\]

• \(P(A \cap B)\) — both happen — \(\frac{18}{70}\)
• \(P(B)\) — B alone — \(\frac{30}{70}\)
• The 70s cancel: \(\frac{18/70}{30/70} = \frac{18}{30} = 0.60\)

Does it work the other way?

vennGrid(counts, "games", true)

• Among the 40 gamers, 18 also like coding.

• \[P(\text{Coding} \mid \text{Games}) = \frac{18}{40} = 0.45\]

• Compare to \(P(\text{Coding}) = \frac{30}{70} \approx 0.43\)

• \(P(\text{Games} \mid \text{Coding}) = 0.60\) vs \(P(\text{Coding} \mid \text{Games}) = 0.45\)

Bayes’ Theorem

Alex

Alex spends hours analyzing what makes games work, talks about mechanics and level design, knows what Unity and Unreal are, and has strong opinions about why certain games succeed or fail.

Is Alex more likely to be a game developer or a content creator?

What’s your guess?

Take a moment.

Most people guess game developer.

Let’s check.

How many of each are there?

• About 10 million game developers worldwide
• About 200 million content creators worldwide
• Ratio: roughly 1 to 20

function bayesGrid(step = "prior") {
  const nDev = 10;
  const nCreator = 200;
  const pFitDev = 0.4;
  const pFitCreator = 0.1;
  const devFit = Math.round(nDev * pFitDev);
  const creatorFit = Math.round(nCreator * pFitCreator);

  const cols = 21;
  const devNotFit = nDev - devFit;
  const devCol = [
    ...Array(devNotFit).fill({type:"dev", fits:false}),
    ...Array(devFit).fill({type:"dev", fits:true})
  ];

  const creatorNotFit = nCreator - creatorFit;
  const creatorCols = cols - 1;
  const creatorRows = Math.ceil(nCreator / creatorCols);
  const creatorCells = [
    ...Array(creatorNotFit).fill({type:"creator", fits:false}),
    ...Array(creatorFit).fill({type:"creator", fits:true})
  ];

  const totalRows = Math.max(devCol.length, creatorRows);

  const cellSize = 18;
  const gap = 4;
  const pad = 30;
  const devColW = cellSize + gap;
  const sepGap = 6;

  const W = pad + devColW + sepGap + creatorCols * (cellSize + gap) + pad;
  const H = pad + totalRows * (cellSize + gap) + pad;

  const cDev       = "#7c3aed";
  const cCreator   = "#6b7280";
  const cFitDev    = "#7c3aed";
  const cFitCreator = "#f59e0b";

  const svg = d3.create("svg")
    .attr("width", W)
    .attr("height", H);

  // ── Background regions ─────────────────────────────────
  if (step === "prior_dev" || step === "likelihood_dev" || step === "likelihood_both" || step === "posterior") {
    svg.append("rect")
      .attr("x", pad - 4)
      .attr("y", pad - 4)
      .attr("width", devColW + 8)
      .attr("height", totalRows * (cellSize + gap) + 8)
      .attr("rx", 4)
      .attr("fill", cDev)
      .attr("opacity", 0.08)
      .attr("stroke", cDev)
      .attr("stroke-width", step === "prior_dev" ? 2 : 1)
      .attr("stroke-opacity", 0.4);
  }

  if (step === "likelihood_both" || step === "posterior") {
    const bottomRowY = pad + (totalRows - 1) * (cellSize + gap) - 4;
    svg.append("rect")
      .attr("x", pad + devColW + sepGap - 4)
      .attr("y", bottomRowY)
      .attr("width", creatorCols * (cellSize + gap) + 8)
      .attr("height", cellSize + 10)
      .attr("rx", 4)
      .attr("fill", cFitCreator)
      .attr("opacity", 0.08)
      .attr("stroke", cFitCreator)
      .attr("stroke-width", 1)
      .attr("stroke-opacity", 0.4);
  }

  // ── Draw person icon ───────────────────────────────────
  function drawPerson(parent, x, y, color, opacity) {
    const g = parent.append("g")
      .attr("transform", `translate(${x},${y})`)
      .attr("opacity", opacity);
    g.append("circle")
      .attr("cx", cellSize/2)
      .attr("cy", cellSize * 0.28)
      .attr("r", cellSize * 0.22)
      .attr("fill", color);
    g.append("rect")
      .attr("x", cellSize * 0.18)
      .attr("y", cellSize * 0.52)
      .attr("width", cellSize * 0.64)
      .attr("height", cellSize * 0.42)
      .attr("rx", cellSize * 0.14)
      .attr("fill", color);
  }

  // ── Dev column ─────────────────────────────────────────
  devCol.forEach((p, i) => {
    const x = pad;
    const y = pad + i * (cellSize + gap);

    let fill, opacity;
    if (step === "prior") { fill = cDev; opacity = 1; }
    else if (step === "prior_dev") { fill = cDev; opacity = 1; }
    else if (step === "likelihood_dev") { fill = p.fits ? cFitDev : cDev; opacity = p.fits ? 1 : 0.2; }
    else if (step === "likelihood_creator") { fill = cDev; opacity = 0.12; }
    else if (step === "likelihood_both") { fill = p.fits ? cFitDev : cDev; opacity = p.fits ? 1 : 0.15; }
    else if (step === "posterior") { fill = p.fits ? cFitDev : cDev; opacity = p.fits ? 1 : 0.07; }
    else { fill = cDev; opacity = 1; }

    drawPerson(svg, x, y, fill, opacity);
  });

  // ── Creator area ───────────────────────────────────────
  creatorCells.forEach((p, i) => {
    const col = i % creatorCols;
    const row = Math.floor(i / creatorCols);
    const x = pad + devColW + sepGap + col * (cellSize + gap);
    const y = pad + row * (cellSize + gap);

    let fill, opacity;
    if (step === "prior") { fill = cCreator; opacity = 1; }
    else if (step === "prior_dev") { fill = cCreator; opacity = 0.12; }
    else if (step === "likelihood_dev") { fill = cCreator; opacity = 0.12; }
    else if (step === "likelihood_creator") { fill = p.fits ? cFitCreator : cCreator; opacity = p.fits ? 1 : 0.2; }
    else if (step === "likelihood_both") { fill = p.fits ? cFitCreator : cCreator; opacity = p.fits ? 1 : 0.15; }
    else if (step === "posterior") { fill = p.fits ? cFitCreator : cCreator; opacity = p.fits ? 1 : 0.07; }
    else { fill = cCreator; opacity = 1; }

    drawPerson(svg, x, y, fill, opacity);
  });

  // ── Labels ─────────────────────────────────────────────
  if (step === "prior_dev" || step === "likelihood_dev" || step === "likelihood_both" || step === "posterior") {
    svg.append("text")
      .attr("x", pad + devColW / 2)
      .attr("y", pad - 10)
      .attr("text-anchor", "middle")
      .attr("font-size", "11px")
      .attr("font-weight", "600")
      .attr("fill", cDev)
      .text(nDev);
  }

  if (step === "likelihood_dev") {
    const fitStartY = pad + devNotFit * (cellSize + gap);
    svg.append("text")
      .attr("x", pad - 10)
      .attr("y", fitStartY + (devFit * (cellSize + gap)) / 2 + 4)
      .attr("text-anchor", "end")
      .attr("font-size", "10px")
      .attr("font-weight", "600")
      .attr("fill", cDev)
      .text("40%");
  }

  if (step === "likelihood_creator") {
    const bottomY = pad + totalRows * (cellSize + gap) + 14;
    svg.append("text")
      .attr("x", pad + devColW + sepGap + (creatorCols * (cellSize + gap)) / 2)
      .attr("y", bottomY)
      .attr("text-anchor", "middle")
      .attr("font-size", "11px")
      .attr("font-weight", "600")
      .attr("fill", cFitCreator)
      .text(`${creatorFit} fit (10%)`);
  }

  if (step === "likelihood_both" || step === "posterior") {
    const fitStartY = pad + devNotFit * (cellSize + gap);
    svg.append("text")
      .attr("x", pad - 10)
      .attr("y", fitStartY + (devFit * (cellSize + gap)) / 2 + 4)
      .attr("text-anchor", "end")
      .attr("font-size", "10px")
      .attr("font-weight", "600")
      .attr("fill", cDev)
      .text(devFit);

    const bottomY = pad + totalRows * (cellSize + gap) + 14;
    svg.append("text")
      .attr("x", pad + devColW + sepGap + (creatorCols * (cellSize + gap)) / 2)
      .attr("y", bottomY)
      .attr("text-anchor", "middle")
      .attr("font-size", "11px")
      .attr("font-weight", "600")
      .attr("fill", cFitCreator)
      .text(creatorFit);
  }

  return svg.node();
}

Start with what we know

bayesGrid("prior")

210 people total.

■ 10 game developers (left column)

■ 200 content creators

This is our population.

Step 1: The hypothesis

bayesGrid("prior_dev")

Our hypothesis H:

• Alex is a game developer.

• The prior — how likely is H before we look at the description?

• \[P(H) = \frac{10}{210} \approx 0.048\]

• Less than 5%.

Step 2: The evidence

The description of Alex is our evidence E.

“…analyzes games, talks about mechanics, knows Unity and Unreal…”

Now we ask two questions:

1. If Alex is a dev, how likely is this description?
2. If Alex is not a dev, how likely is this description?

P(E | H) — evidence given the hypothesis is true

bayesGrid("likelihood_dev")

• Among the 10 game developers, how many fit Alex’s description?

• \[P(E \mid H) = 0.40\]

• 4 out of 10 developers talk about mechanics, know Unity, etc. The description fits developers pretty well.

P(E | ¬H) — evidence given the hypothesis is false

bayesGrid("likelihood_creator")

• Among the 200 content creators, how many fit the description?

• \[P(E \mid \neg H) = 0.10\]

• 20 out of 200 content creators also talk about game design, know engines, etc.

• Lower rate — but there are so many more of them.

Both together

bayesGrid("likelihood_both")

Everyone who fits the description:

• ■ 4 game developers
• ■ 20 content creators

24 total match the evidence.

P(H | E) — the answer

bayesGrid("posterior")

Of the 24 who fit the description, how many are actually developers?

• \[P(H \mid E) = \frac{4}{4 + 20} = \frac{4}{24} \approx 0.17\]

• Only 17% chance Alex is a developer.

• Despite the description fitting developers 4x better, the base rate dominates.

Updating beliefs

• We started believing there’s a 5% chance Alex is a dev
• The description fits developers better — 4x more likely
• But after seeing the evidence, we update to 17%
• Our belief went up — but not as much as intuition suggests
• The base rate anchors the answer

The formula

bayesGrid("prior")

\[P(H \mid E) = \frac{P(E \mid H) \cdot P(H)}{P(E)}\]

• \(P(H) = \frac{10}{210}\) — the prior
• \(P(E \mid H) = 0.40\) — the likelihood
• \(P(E) = \frac{24}{210}\) — the evidence
• \(P(H \mid E) = \frac{4}{24} \approx 0.17\) — the posterior

The prior

bayesGrid("prior_dev")

\[P(H \mid E) = \frac{P(E \mid H) \cdot \boxed{P(H)}}{P(E)}\]

\(P(H) = \frac{10}{210} \approx 0.048\)

How likely is Alex a dev before we see any evidence?

Less than 5%.

The likelihood

bayesGrid("likelihood_dev")

\[P(H \mid E) = \frac{\boxed{P(E \mid H)} \cdot P(H)}{P(E)}\]

\(P(E \mid H) = 0.40\)

If Alex is a dev, how likely is this description?

4 out of 10 devs fit.

The evidence given ¬H

bayesGrid("likelihood_creator")

\(P(E \mid \neg H) = 0.10\)

If Alex is not a dev, how likely is this description?

20 out of 200 creators fit.

Lower rate — but so many more of them.

The total evidence

bayesGrid("likelihood_both")

\[P(H \mid E) = \frac{P(E \mid H) \cdot P(H)}{\boxed{P(E)}}\]

\[P(E) = P(E|H) \cdot P(H) + P(E|\neg H) \cdot P(\neg H)\]

\[= 0.40 \times \frac{10}{210} + 0.10 \times \frac{200}{210}\]

\[= \frac{4 + 20}{210} = \frac{24}{210}\]

The posterior

bayesGrid("posterior")

\[\boxed{P(H \mid E)} = \frac{P(E \mid H) \cdot P(H)}{P(E)}\]

\[= \frac{0.40 \times \frac{10}{210}}{\frac{24}{210}} = \frac{4}{24} \approx 0.17\]

Only 17% chance Alex is a dev.

Despite fitting 4x better, the base rate wins.

Probability Distributions

From outcomes to distributions

We’ve been counting individual outcomes.

But often we care about a summary value — like the sum of two dice.

How often does each sum appear?

Every possible sum

diceGrid([[1,1]], [], true, false)

Sum = 2 → only 1 way

\(P(\text{sum} = 2) = \frac{1}{36}\)

Sum = 3

diceGrid([[1,2],[2,1]], [], true, false)

Sum = 3 → 2 ways

\(P(\text{sum} = 3) = \frac{2}{36}\)

Sum = 7

diceGrid([[1,6],[2,5],[3,4],[4,3],[5,2],[6,1]], [], true, false)

Sum = 7 → 6 ways

\(P(\text{sum} = 7) = \frac{6}{36} = \frac{1}{6}\)

The most common sum.

Sum = 12

diceGrid([[6,6]], [], true, false)

Sum = 12 → only 1 way

\(P(\text{sum} = 12) = \frac{1}{36}\)

Just as rare as sum = 2.

Count them all

Sum	2	3	4	5	6	7	8	9	10	11	12
Ways	1	2	3	4	5	6	5	4	3	2	1

What if we plot this?

The probability mass function (PMF)

Plot.plot({
  width: 700,
  height: 340,
  marginLeft: 50,
  marginBottom: 40,
  x: {label: "Sum of two dice", type: "band", domain: ["2","3","4","5","6","7","8","9","10","11","12"]},
  y: {label: "P(X = x)", domain: [0, 0.20]},
  marks: [
    Plot.barY(
      [{sum:"2",p:1/36},{sum:"3",p:2/36},{sum:"4",p:3/36},{sum:"5",p:4/36},
       {sum:"6",p:5/36},{sum:"7",p:6/36},{sum:"8",p:5/36},{sum:"9",p:4/36},
       {sum:"10",p:3/36},{sum:"11",p:2/36},{sum:"12",p:1/36}],
      {x: "sum", y: "p", fill: "#4a90d9", opacity: 0.85}
    ),
    Plot.ruleY([0])
  ]
})

Each bar = probability of exactly that sum · All bars add to 1

How to read a PMF

• Used for discrete variables — values you can list and count
• The x-axis shows each possible value
• The y-axis shows the probability of exactly that value
• The tallest bar is the most likely outcome
• All bars sum to 1

Cumulative distribution (CDF) — discrete

Plot.plot({
  width: 700,
  height: 340,
  marginLeft: 50,
  marginBottom: 40,
  x: {label: "Sum of two dice", type: "band", domain: ["2","3","4","5","6","7","8","9","10","11","12"]},
  y: {label: "P(X ≤ x)", domain: [0, 1.05]},
  marks: [
    Plot.dot(
      [{sum:"2",p:1/36},{sum:"3",p:3/36},{sum:"4",p:6/36},{sum:"5",p:10/36},
       {sum:"6",p:15/36},{sum:"7",p:21/36},{sum:"8",p:26/36},{sum:"9",p:30/36},
       {sum:"10",p:33/36},{sum:"11",p:35/36},{sum:"12",p:1}],
      {x:"sum", y:"p", fill:"#e06c4c", r:5}
    ),
    Plot.line(
      [{sum:"2",p:1/36},{sum:"3",p:3/36},{sum:"4",p:6/36},{sum:"5",p:10/36},
       {sum:"6",p:15/36},{sum:"7",p:21/36},{sum:"8",p:26/36},{sum:"9",p:30/36},
       {sum:"10",p:33/36},{sum:"11",p:35/36},{sum:"12",p:1}],
      {x:"sum", y:"p", stroke:"#e06c4c", strokeWidth:2.5}
    ),
    Plot.ruleY([0])
  ]
})

Each point = probability that the sum is at most x · Always goes up · Ends at 1

How to read a CDF

• The y-axis is \(P(X \leq x)\) — “at most this value”
• The curve always increases
• It ends at 1 — all outcomes are at most the maximum
• Steeper sections = more probability mass there
• Flat sections = no probability mass there

PMF vs CDF — same information

Plot.plot({
  width: 340,
  height: 260,
  marginLeft: 45,
  marginBottom: 35,
  x: {label: "Sum", type: "band", domain: ["2","3","4","5","6","7","8","9","10","11","12"]},
  y: {label: "P(X = x)", domain: [0, 0.20]},
  marks: [
    Plot.barY(
      [{sum:"2",p:1/36},{sum:"3",p:2/36},{sum:"4",p:3/36},{sum:"5",p:4/36},
       {sum:"6",p:5/36},{sum:"7",p:6/36},{sum:"8",p:5/36},{sum:"9",p:4/36},
       {sum:"10",p:3/36},{sum:"11",p:2/36},{sum:"12",p:1/36}],
      {x:"sum", y:"p", fill:"#4a90d9", opacity:0.85}
    ),
    Plot.ruleY([0])
  ]
})

PMF — \(P(X = x)\)

Plot.plot({
  width: 340,
  height: 260,
  marginLeft: 45,
  marginBottom: 35,
  x: {label: "Sum", type: "band", domain: ["2","3","4","5","6","7","8","9","10","11","12"]},
  y: {label: "P(X ≤ x)", domain: [0, 1.05]},
  marks: [
    Plot.dot(
      [{sum:"2",p:1/36},{sum:"3",p:3/36},{sum:"4",p:6/36},{sum:"5",p:10/36},
       {sum:"6",p:15/36},{sum:"7",p:21/36},{sum:"8",p:26/36},{sum:"9",p:30/36},
       {sum:"10",p:33/36},{sum:"11",p:35/36},{sum:"12",p:1}],
      {x:"sum", y:"p", fill:"#e06c4c", r:4}
    ),
    Plot.line(
      [{sum:"2",p:1/36},{sum:"3",p:3/36},{sum:"4",p:6/36},{sum:"5",p:10/36},
       {sum:"6",p:15/36},{sum:"7",p:21/36},{sum:"8",p:26/36},{sum:"9",p:30/36},
       {sum:"10",p:33/36},{sum:"11",p:35/36},{sum:"12",p:1}],
      {x:"sum", y:"p", stroke:"#e06c4c", strokeWidth:2.5}
    ),
    Plot.ruleY([0])
  ]
})

CDF — \(P(X \leq x)\)

You can always convert: \(P(X = k) = C(k) - C(k-1)\)

What about continuous variables?

Dice sums are discrete — you can list every possible value.

But many real-world measurements are continuous:

• Height — 162.3 cm, 175.8 cm, 168.1 cm…
• Weight, temperature, reaction time
• There are infinitely many possible values

We can’t assign probability to each exact value.

Example: heights of students

Imagine measuring the height of every student in the university.

Instead of asking “what’s the probability of being exactly 170.000 cm?”

We ask: “what’s the probability of being between 168 cm and 172 cm?”

From histogram to PDF

{
  // Simulate 2000 heights: mean 170 cm, sd 7 cm
  function seededRandom(seed) {
    let s = seed;
    return () => { s = (s * 16807) % 2147483647; return (s - 1) / 2147483646; };
  }
  const rand = seededRandom(123);
  const heights = Array.from({length: 2000}, () => {
    const u1 = rand(), u2 = rand();
    return 170 + 7 * Math.sqrt(-2*Math.log(u1))*Math.cos(2*Math.PI*u2);
  });

  return Plot.plot({
    width: 420,
    height: 300,
    marginLeft: 45,
    marginBottom: 40,
    x: {label: "Height (cm)", domain: [140, 200]},
    y: {label: "Count"},
    marks: [
      Plot.rectY(heights, Plot.binX({y: "count"}, {x: d => d, thresholds: 30, fill: "#4a90d9", opacity: 0.7})),
      Plot.ruleY([0])
    ]
  });
}

A histogram groups measurements into bins and counts them.

. . .

Normalize so the total area = 1, and it becomes a probability density function (PDF).

. . .

The y-axis is density, not probability.

The probability density function (PDF)

{
  const mu = 170, sigma = 7;
  const data = Array.from({length: 300}, (_, i) => {
    const x = 140 + i * 60 / 299;
    const y = (1 / (sigma * Math.sqrt(2 * Math.PI))) *
              Math.exp(-0.5 * ((x - mu) / sigma) ** 2);
    return {x, y};
  });

  const shaded = data.filter(d => d.x >= 168 && d.x <= 172);

  return Plot.plot({
    width: 700,
    height: 340,
    marginLeft: 50,
    marginBottom: 40,
    x: {label: "Height (cm)", domain: [140, 200]},
    y: {label: "Density"},
    marks: [
      Plot.areaY(shaded, {x: "x", y: "y", fill: "#f59e0b", opacity: 0.4}),
      Plot.line(data, {x: "x", y: "y", stroke: "#4a90d9", strokeWidth: 2.5}),
      Plot.ruleY([0])
    ]
  });
}

The shaded area = P(168 cm ≤ height ≤ 172 cm) · Total area under the curve = 1

PMF vs PDF — key difference

	PMF (discrete)	PDF (continuous)
Y-axis	Probability	Density
Read directly?	Yes — bar height = P(X = x)	No — must compute area
Probability of exact value	Can be > 0	Always 0
How to get probability	Read the bar	Compute the area under the curve
Sums/integrates to	1	1

CDF for continuous variables

{
  const mu = 170, sigma = 7;
  const data = Array.from({length: 300}, (_, i) => {
    const x = 140 + i * 60 / 299;
    // Approximate CDF using error function
    const z = (x - mu) / (sigma * Math.sqrt(2));
    const t = 1 / (1 + 0.3275911 * Math.abs(z));
    const erf = 1 - (0.254829592*t - 0.284496736*t*t + 1.421413741*t*t*t
                     - 1.453152027*t*t*t*t + 1.061405429*t*t*t*t*t) * Math.exp(-z*z);
    const cdf = 0.5 * (1 + (z >= 0 ? erf : -erf));
    return {x, cdf};
  });

  return Plot.plot({
    width: 700,
    height: 340,
    marginLeft: 50,
    marginBottom: 40,
    x: {label: "Height (cm)", domain: [140, 200]},
    y: {label: "P(height ≤ x)", domain: [0, 1.05]},
    marks: [
      Plot.line(data, {x: "x", y: "cdf", stroke: "#e06c4c", strokeWidth: 2.5}),
      Plot.ruleY([0])
    ]
  });
}

Smooth S-curve · Steepest near the mean (170 cm) · P(height ≤ 170) = 0.5

The normal (Gaussian) distribution

{
  const mu = 0, sigma = 1;
  const data = Array.from({length: 200}, (_, i) => {
    const x = -4 + i * 8 / 199;
    const y = (1 / (sigma * Math.sqrt(2 * Math.PI))) *
              Math.exp(-0.5 * ((x - mu) / sigma) ** 2);
    return {x, y};
  });

  const shade1 = data.filter(d => d.x >= -1 && d.x <= 1);
  const shade2 = data.filter(d => d.x >= -2 && d.x <= 2);
  const shade3 = data.filter(d => d.x >= -3 && d.x <= 3);

  return Plot.plot({
    width: 700,
    height: 340,
    marginLeft: 50,
    marginBottom: 40,
    x: {label: "Standard deviations from mean (σ)", domain: [-4, 4]},
    y: {label: "Density", domain: [0, 0.45]},
    marks: [
      Plot.areaY(shade3, {x:"x", y:"y", fill:"#4a90d9", opacity:0.1}),
      Plot.areaY(shade2, {x:"x", y:"y", fill:"#4a90d9", opacity:0.15}),
      Plot.areaY(shade1, {x:"x", y:"y", fill:"#4a90d9", opacity:0.25}),
      Plot.line(data, {x:"x", y:"y", stroke:"#4a90d9", strokeWidth:2.5}),
      Plot.ruleY([0]),
      Plot.ruleX([-1], {stroke:"#7c3aed", strokeWidth:1, strokeDasharray:"4 3"}),
      Plot.ruleX([1], {stroke:"#7c3aed", strokeWidth:1, strokeDasharray:"4 3"}),
      Plot.ruleX([-2], {stroke:"#e06c4c", strokeWidth:1, strokeDasharray:"4 3"}),
      Plot.ruleX([2], {stroke:"#e06c4c", strokeWidth:1, strokeDasharray:"4 3"}),
      Plot.ruleX([-3], {stroke:"#6b7280", strokeWidth:1, strokeDasharray:"4 3"}),
      Plot.ruleX([3], {stroke:"#6b7280", strokeWidth:1, strokeDasharray:"4 3"})
    ]
  });
}

±1σ → 68% · ±2σ → 95% · ±3σ → 99.7%

How to read the bell curve

• Centered at the mean \(\mu\)
• Width controlled by standard deviation \(\sigma\)
• Small \(\sigma\) → tall and narrow → values cluster tightly
• Large \(\sigma\) → short and wide → values spread out
• Most data falls within 2 standard deviations of the mean

Example: heights

\(\mu = 170\) cm, \(\sigma = 7\) cm

• 68% of students are between 163 cm and 177 cm
• 95% are between 156 cm and 184 cm
• 99.7% are between 149 cm and 191 cm
• Someone 2 meters tall? That’s more than 4σ away — very rare

Why this matters

• Many natural measurements are approximately normal
• When you report \(\mu \pm \sigma\), you’re describing this shape
• If your data isn’t bell-shaped, the mean can mislead
• Always plot your distribution before summarizing it

Descriptive Statistics

Summarizing data

We often have too much data to look at individually.

We need numbers that summarize a data set.

Two questions:

• What’s the center?
• How spread out is it?

Example: daily screen time

Imagine we surveyed 30 students about their daily screen time (hours):

screenData = [2.1, 2.5, 3.0, 3.2, 3.4, 3.5, 3.7, 3.8, 4.0, 4.1,
              4.2, 4.3, 4.5, 4.5, 4.7, 4.8, 5.0, 5.1, 5.3, 5.5,
              5.8, 6.0, 6.2, 6.5, 7.0, 7.5, 8.2, 9.0, 11.0, 14.0]

Plot.plot({
  width: 700,
  height: 280,
  marginLeft: 50,
  marginBottom: 40,
  x: {label: "Screen time (hours)", domain: [0, 16]},
  y: {label: "Count"},
  marks: [
    Plot.rectY(screenData, Plot.binX({y: "count"}, {x: d => d, thresholds: 15, fill: "#4a90d9", opacity: 0.7})),
    Plot.ruleY([0])
  ]
})

Notice the long tail on the right — a few heavy users.

The mean

{
  const mean = screenData.reduce((a,b) => a+b, 0) / screenData.length;

  return Plot.plot({
    width: 400,
    height: 240,
    marginLeft: 50,
    marginBottom: 40,
    x: {label: "Screen time (hours)", domain: [0, 16]},
    y: {axis: null, domain: [-0.5, 0.5]},
    marks: [
      Plot.dot(screenData, {x: d => d, y: 0, fill: "#4a90d9", r: 5, opacity: 0.6}),
      Plot.ruleX([mean], {stroke: "#e06c4c", strokeWidth: 3, strokeDasharray: "6 3"}),
      Plot.text([{x: mean}], {x: "x", y: 0.35, text: d => `mean = ${mean.toFixed(1)}`, fill: "#e06c4c", fontSize: 14, fontWeight: "bold"}),
      Plot.ruleY([0])
    ]
  });
}

\[\mu = \frac{1}{n}\sum_{i=1}^n x_i\]

Sum all values, divide by count.

. . .

\(\mu = \frac{156.3}{30} = 5.2\) hours

. . .

But does 5.2 hours feel like the typical student?

The median

{
  const sorted = [...screenData].sort((a,b) => a-b);
  const mean = screenData.reduce((a,b) => a+b, 0) / screenData.length;
  const median = (sorted[14] + sorted[15]) / 2;

  return Plot.plot({
    width: 400,
    height: 240,
    marginLeft: 50,
    marginBottom: 40,
    x: {label: "Screen time (hours)", domain: [0, 16]},
    y: {axis: null, domain: [-0.5, 0.5]},
    marks: [
      Plot.dot(screenData, {x: d => d, y: 0, fill: "#4a90d9", r: 5, opacity: 0.6}),
      Plot.ruleX([mean], {stroke: "#e06c4c", strokeWidth: 2, strokeDasharray: "6 3"}),
      Plot.ruleX([median], {stroke: "#2ecc71", strokeWidth: 3}),
      Plot.text([{x: mean}], {x: "x", y: 0.35, text: d => `mean = ${mean.toFixed(1)}`, fill: "#e06c4c", fontSize: 13, fontWeight: "bold"}),
      Plot.text([{x: median}], {x: "x", y: -0.35, text: d => `median = ${median.toFixed(1)}`, fill: "#2ecc71", fontSize: 13, fontWeight: "bold"}),
      Plot.ruleY([0])
    ]
  });
}

The middle value when data is sorted.

. . .

Median = 4.75 hours

. . .

Half the students are above, half below.

. . .

The mean (5.2) is pulled right by heavy users.

The median is more robust.

What outliers do

viewof outlierVal = Inputs.range([0, 24], {
  value: 14, step: 0.5, label: "Heaviest user (hours)"
})

{
  const data = [...screenData.slice(0, 29), outlierVal];
  const sorted = [...data].sort((a,b) => a-b);
  const mean = data.reduce((a,b) => a+b, 0) / data.length;
  const median = (sorted[14] + sorted[15]) / 2;

  return Plot.plot({
    width: 400,
    height: 200,
    marginLeft: 50,
    marginBottom: 40,
    x: {label: "Screen time (hours)", domain: [0, 25]},
    y: {axis: null, domain: [-0.5, 0.5]},
    marks: [
      Plot.dot(data, {x: d => d, y: 0, fill: "#4a90d9", r: 5, opacity: 0.6}),
      Plot.ruleX([mean], {stroke: "#e06c4c", strokeWidth: 2, strokeDasharray: "6 3"}),
      Plot.ruleX([median], {stroke: "#2ecc71", strokeWidth: 3}),
      Plot.text([{x: mean}], {x: "x", y: 0.35, text: d => `mean = ${mean.toFixed(1)}`, fill: "#e06c4c", fontSize: 13, fontWeight: "bold"}),
      Plot.text([{x: median}], {x: "x", y: -0.35, text: d => `median = ${median.toFixed(1)}`, fill: "#2ecc71", fontSize: 13, fontWeight: "bold"}),
      Plot.ruleY([0])
    ]
  });
}

Drag the slider to change the heaviest user’s screen time.

. . .

The mean chases the outlier.

The median barely moves.

. . .

For skewed data, the median is usually the better summary.

Box plot

{
  const sorted = [...screenData].sort((a,b) => a-b);
  const n = sorted.length;
  const q1 = sorted[Math.floor(n * 0.25)];
  const median = (sorted[14] + sorted[15]) / 2;
  const q3 = sorted[Math.floor(n * 0.75)];
  const iqr = q3 - q1;
  const whiskerLow = sorted.find(d => d >= q1 - 1.5 * iqr);
  const whiskerHigh = [...sorted].reverse().find(d => d <= q3 + 1.5 * iqr);
  const outliers = sorted.filter(d => d < whiskerLow || d > whiskerHigh);

  const W = 260, H = 420;
  const left = 50, right = 120, top = 30, bottom = 40;
  const plotH = H - top - bottom;

  const yScale = (v) => H - bottom - (v - 0) / (16 - 0) * plotH;
  const cx = left + 40;
  const boxW = 50;

  const svg = d3.create("svg").attr("width", W).attr("height", H);

  // Y-axis
  svg.append("line")
    .attr("x1", left).attr("x2", left)
    .attr("y1", top).attr("y2", H - bottom)
    .attr("stroke", "#ccc").attr("stroke-width", 1);

  [0, 2, 4, 6, 8, 10, 12, 14, 16].forEach(v => {
    svg.append("text")
      .attr("x", left - 8).attr("y", yScale(v) + 4)
      .attr("text-anchor", "end").attr("font-size", "11px").attr("fill", "#666")
      .text(v);
    svg.append("line")
      .attr("x1", left - 3).attr("x2", left)
      .attr("y1", yScale(v)).attr("y2", yScale(v))
      .attr("stroke", "#ccc");
  });

  svg.append("text")
    .attr("transform", `rotate(-90)`)
    .attr("x", -(top + plotH / 2)).attr("y", 14)
    .attr("text-anchor", "middle").attr("font-size", "12px").attr("fill", "#666")
    .text("Screen time (hours)");

  // Lower whisker
  svg.append("line")
    .attr("x1", cx).attr("x2", cx)
    .attr("y1", yScale(whiskerLow)).attr("y2", yScale(q1))
    .attr("stroke", "#4a90d9").attr("stroke-width", 1.5);

  // Upper whisker
  svg.append("line")
    .attr("x1", cx).attr("x2", cx)
    .attr("y1", yScale(q3)).attr("y2", yScale(whiskerHigh))
    .attr("stroke", "#4a90d9").attr("stroke-width", 1.5);

  // Whisker caps
  [whiskerLow, whiskerHigh].forEach(v => {
    svg.append("line")
      .attr("x1", cx - boxW * 0.3).attr("x2", cx + boxW * 0.3)
      .attr("y1", yScale(v)).attr("y2", yScale(v))
      .attr("stroke", "#4a90d9").attr("stroke-width", 1.5);
  });

  // Box
  svg.append("rect")
    .attr("x", cx - boxW / 2).attr("y", yScale(q3))
    .attr("width", boxW).attr("height", yScale(q1) - yScale(q3))
    .attr("fill", "#4a90d9").attr("opacity", 0.15)
    .attr("stroke", "#4a90d9").attr("stroke-width", 2)
    .attr("rx", 4);

  // Median line
  svg.append("line")
    .attr("x1", cx - boxW / 2).attr("x2", cx + boxW / 2)
    .attr("y1", yScale(median)).attr("y2", yScale(median))
    .attr("stroke", "#2ecc71").attr("stroke-width", 3);

  // Outliers
  outliers.forEach(v => {
    svg.append("circle")
      .attr("cx", cx).attr("cy", yScale(v))
      .attr("r", 5).attr("fill", "#e06c4c").attr("opacity", 0.8);
  });

  // Labels — right side, connected with lines
  const labelX = cx + boxW / 2 + 12;
  const textX = labelX + 4;

  // Q1
  svg.append("line").attr("x1", cx + boxW/2).attr("x2", labelX).attr("y1", yScale(q1)).attr("y2", yScale(q1)).attr("stroke", "#4a90d9").attr("stroke-width", 0.8);
  svg.append("text").attr("x", textX).attr("y", yScale(q1) + 4).attr("font-size", "11px").attr("fill", "#4a90d9").text(`Q1 = ${q1}`);

  // Median
  svg.append("line").attr("x1", cx + boxW/2).attr("x2", labelX).attr("y1", yScale(median)).attr("y2", yScale(median)).attr("stroke", "#2ecc71").attr("stroke-width", 0.8);
  svg.append("text").attr("x", textX).attr("y", yScale(median) + 4).attr("font-size", "11px").attr("fill", "#2ecc71").attr("font-weight", "bold").text(`Median = ${median}`);

  // Q3
  svg.append("line").attr("x1", cx + boxW/2).attr("x2", labelX).attr("y1", yScale(q3)).attr("y2", yScale(q3)).attr("stroke", "#4a90d9").attr("stroke-width", 0.8);
  svg.append("text").attr("x", textX).attr("y", yScale(q3) + 4).attr("font-size", "11px").attr("fill", "#4a90d9").text(`Q3 = ${q3}`);

  // Whisker low
  svg.append("line").attr("x1", cx + boxW*0.3).attr("x2", labelX).attr("y1", yScale(whiskerLow)).attr("y2", yScale(whiskerLow)).attr("stroke", "#999").attr("stroke-width", 0.8);
  svg.append("text").attr("x", textX).attr("y", yScale(whiskerLow) + 4).attr("font-size", "10px").attr("fill", "#999").text(`Min = ${whiskerLow}`);

  // Whisker high
  svg.append("line").attr("x1", cx + boxW*0.3).attr("x2", labelX).attr("y1", yScale(whiskerHigh)).attr("y2", yScale(whiskerHigh)).attr("stroke", "#999").attr("stroke-width", 0.8);
  svg.append("text").attr("x", textX).attr("y", yScale(whiskerHigh) + 4).attr("font-size", "10px").attr("fill", "#999").text(`Max = ${whiskerHigh}`);

  // Outlier labels
  outliers.forEach(v => {
    svg.append("line").attr("x1", cx + 6).attr("x2", labelX).attr("y1", yScale(v)).attr("y2", yScale(v)).attr("stroke", "#e06c4c").attr("stroke-width", 0.8).attr("stroke-dasharray", "3 2");
    svg.append("text").attr("x", textX).attr("y", yScale(v) + 4).attr("font-size", "10px").attr("fill", "#e06c4c").text(`${v}`);
  });

  return svg.node();
}

A box plot shows five numbers at once:

• Whiskers — range excluding outliers

• Box — middle 50% of data (Q1 to Q3)

• Line — the median

• Dots — outliers beyond 1.5 × IQR

• The IQR (interquartile range) = Q3 - Q1

• This is a robust measure of spread — outliers don’t affect it.

The mode

Plot.plot({
  width: 400,
  height: 240,
  marginLeft: 50,
  marginBottom: 40,
  x: {label: "Screen time (hours)", domain: [0, 16]},
  y: {label: "Count"},
  marks: [
    Plot.rectY(screenData, Plot.binX({y: "count"}, {x: d => d, thresholds: 15, fill: "#4a90d9", opacity: 0.7})),
    Plot.ruleY([0])
  ]
})

The most frequent value.

In our data, 4.5 hours appears twice — technically the mode.

But with continuous data, the mode is rarely useful.

The peak of the histogram is more meaningful than any single repeated value.

Which centrality measure to use?

Measure	Best for	Sensitive to outliers?
Mean	Symmetric data, no outliers	Yes
Median	Skewed data, outliers present	No
Mode	Categorical data	No

When in doubt, report both mean and median — the gap between them tells you about skewness.

Variability: standard deviation

{
  const mean = screenData.reduce((a,b) => a+b, 0) / screenData.length;
  const variance = screenData.reduce((a,x) => a + (x - mean)**2, 0) / (screenData.length - 1);
  const sd = Math.sqrt(variance);

  return Plot.plot({
    width: 400,
    height: 240,
    marginLeft: 50,
    marginBottom: 40,
    x: {label: "Screen time (hours)", domain: [0, 16]},
    y: {axis: null, domain: [-0.5, 0.5]},
    marks: [
      Plot.dot(screenData, {x: d => d, y: 0, fill: "#4a90d9", r: 5, opacity: 0.6}),
      Plot.ruleX([mean], {stroke: "#e06c4c", strokeWidth: 2}),
      Plot.rect([{x1: mean - sd, x2: mean + sd}], {x1: "x1", x2: "x2", y1: -0.3, y2: 0.3, fill: "#e06c4c", opacity: 0.08, stroke: "#e06c4c", strokeWidth: 1, strokeDasharray: "4 3"}),
      Plot.text([{x: mean}], {x: "x", y: 0.45, text: d => "μ", fill: "#e06c4c", fontSize: 14, fontWeight: "bold"}),
      Plot.text([{x: mean + sd}], {x: "x", y: -0.45, text: d => `+1σ = ${(mean+sd).toFixed(1)}`, fill: "#e06c4c", fontSize: 11}),
      Plot.text([{x: mean - sd}], {x: "x", y: -0.45, text: d => `-1σ = ${(mean-sd).toFixed(1)}`, fill: "#e06c4c", fontSize: 11}),
      Plot.ruleY([0])
    ]
  });
}

\[\sigma = \sqrt{\frac{\sum(x_i - \bar{x})^2}{n-1}}\]

• How far, on average, are values from the mean?

• For our data: \(\sigma \approx 2.6\) hours

• The shaded region shows \(\mu \pm 1\sigma\)

Why n - 1?

• Dividing by \(n\) gives the population standard deviation
• Dividing by \(n - 1\) gives the sample standard deviation
• A sample of 1 tells you nothing about spread
• With \(n - 1\), one observation gives \(\sigma = 0/0\) — undefined, as it should be
• For large \(n\), the difference doesn’t matter

Low variance vs high variance

{
  function seededRandom(seed) {
    let s = seed;
    return () => { s = (s * 16807) % 2147483647; return (s - 1) / 2147483646; };
  }
  const rand = seededRandom(42);
  const low = Array.from({length: 200}, () => {
    const u1 = rand(), u2 = rand();
    return 5 + 0.8 * Math.sqrt(-2*Math.log(u1))*Math.cos(2*Math.PI*u2);
  });

  return Plot.plot({
    width: 340,
    height: 220,
    marginLeft: 45,
    marginBottom: 35,
    x: {label: "Hours", domain: [0, 12]},
    y: {label: "Count"},
    marks: [
      Plot.rectY(low, Plot.binX({y: "count"}, {x: d => d, thresholds: 20, fill: "#2ecc71", opacity: 0.7})),
      Plot.ruleY([0])
    ]
  });
}

\(\mu = 5\), \(\sigma = 0.8\)

Everyone is similar.

{
  function seededRandom(seed) {
    let s = seed;
    return () => { s = (s * 16807) % 2147483647; return (s - 1) / 2147483646; };
  }
  const rand = seededRandom(99);
  const high = Array.from({length: 200}, () => {
    const u1 = rand(), u2 = rand();
    return 5 + 3.0 * Math.sqrt(-2*Math.log(u1))*Math.cos(2*Math.PI*u2);
  });

  return Plot.plot({
    width: 340,
    height: 220,
    marginLeft: 45,
    marginBottom: 35,
    x: {label: "Hours", domain: [0, 12]},
    y: {label: "Count"},
    marks: [
      Plot.rectY(high, Plot.binX({y: "count"}, {x: d => d, thresholds: 20, fill: "#e06c4c", opacity: 0.7})),
      Plot.ruleY([0])
    ]
  });
}

\(\mu = 5\), \(\sigma = 3.0\)

Huge variation.

Same mean — completely different distributions. Always report \(\mu \pm \sigma\).

Chebyshev’s inequality

Regardless of the distribution shape:

Within	Guaranteed fraction
\(\pm 1\sigma\)	0% (no guarantee)
\(\pm 2\sigma\)	at least 75%
\(\pm 3\sigma\)	at least 89%

For a normal distribution, the bounds are much tighter: 68%, 95%, 99.7%.

This is why \(\mu \pm \sigma\) is such a powerful summary.

Take-home lesson

• Center: mean (symmetric data) or median (skewed data)
• Spread: standard deviation \(\sigma\)
• Always report both: \(\mu \pm \sigma\)
• Always plot your data — numbers alone can hide the shape
• Beware of outliers — they distort the mean and inflate \(\sigma\)

Correlation

What is correlation?

We say two variables are correlated when knowing one tells you something about the other.

More screen time → more apps installed?

More screen time → lower GPA?

The strength and direction of this relationship is what we want to measure.

Strong positive correlation

{
  function seededRandom(seed) {
    let s = seed;
    return () => { s = (s * 16807) % 2147483647; return (s-1)/2147483646; };
  }
  const rand = seededRandom(11);
  const data = Array.from({length: 40}, () => {
    const x = 2 + rand() * 10;
    const y = x * 1.8 + rand() * 4 - 2;
    return {x, y: Math.max(0, y)};
  });

  return Plot.plot({
    width: 400, height: 280,
    marginLeft: 50, marginBottom: 45,
    x: {label: "Screen time (hours/day)", domain: [0, 14]},
    y: {label: "Apps installed", domain: [0, 30]},
    marks: [
      Plot.dot(data, {x:"x", y:"y", fill:"#4a90d9", r:5, opacity:0.7}),
      Plot.linearRegressionY(data, {x:"x", y:"y", stroke:"#e06c4c", strokeWidth:2}),
      Plot.ruleY([0])
    ]
  });
}

Screen time vs apps installed.

• As one goes up, so does the other
• Points cluster around a rising line
• This is a positive correlation
• \(r \approx +0.85\)

Strong negative correlation

{
  function seededRandom(seed) {
    let s = seed;
    return () => { s = (s * 16807) % 2147483647; return (s-1)/2147483646; };
  }
  const rand = seededRandom(22);
  const data = Array.from({length: 40}, () => {
    const x = 2 + rand() * 10;
    const y = 4.0 - x * 0.2 + rand() * 0.6 - 0.3;
    return {x, y: Math.min(4.0, Math.max(0, y))};
  });

  return Plot.plot({
    width: 400, height: 280,
    marginLeft: 50, marginBottom: 45,
    x: {label: "Screen time (hours/day)", domain: [0, 14]},
    y: {label: "GPA", domain: [0, 4.2]},
    marks: [
      Plot.dot(data, {x:"x", y:"y", fill:"#7c3aed", r:5, opacity:0.7}),
      Plot.linearRegressionY(data, {x:"x", y:"y", stroke:"#e06c4c", strokeWidth:2}),
      Plot.ruleY([0])
    ]
  });
}

Screen time vs GPA.

• As one goes up, the other goes down
• Points cluster around a falling line
• This is a negative correlation
• \(r \approx -0.80\)
• Negative correlations are just as useful for prediction

No correlation

{
  function seededRandom(seed) {
    let s = seed;
    return () => { s = (s * 16807) % 2147483647; return (s-1)/2147483646; };
  }
  const rand = seededRandom(33);
  const data = Array.from({length: 40}, () => {
    const x = 2 + rand() * 10;
    const y = 155 + rand() * 40;
    return {x, y};
  });

  return Plot.plot({
    width: 400, height: 280,
    marginLeft: 50, marginBottom: 45,
    x: {label: "Screen time (hours/day)", domain: [0, 14]},
    y: {label: "Height (cm)", domain: [145, 200]},
    marks: [
      Plot.dot(data, {x:"x", y:"y", fill:"#6b7280", r:5, opacity:0.7}),
      Plot.linearRegressionY(data, {x:"x", y:"y", stroke:"#e06c4c", strokeWidth:2}),
      Plot.ruleY([0])
    ]
  });
}

Screen time vs height.

• No pattern — points are scattered randomly
• The line is nearly flat
• Knowing one tells you nothing about the other
• \(r \approx 0\)

The correlation coefficient

\[r = \frac{\sum(X_i - \bar{X})(Y_i - \bar{Y})}{\sqrt{\sum(X_i-\bar{X})^2}\sqrt{\sum(Y_i-\bar{Y})^2}}\]

{
 //| echo: false
{
  const W = 700, H = 160;
  const svg = d3.create("svg").attr("width", W).attr("height", H);

  const left = 60, right = 60;
  const barY = 90, barH = 20;
  const barW = W - left - right;

  // Gradient bar
  const defs = svg.append("defs");
  const grad = defs.append("linearGradient").attr("id","rGrad").attr("x1","0%").attr("x2","100%");
  grad.append("stop").attr("offset","0%").attr("style","stop-color:#e06c4c");
  grad.append("stop").attr("offset","50%").attr("style","stop-color:#e8e8e8");
  grad.append("stop").attr("offset","100%").attr("style","stop-color:#4a90d9");

  svg.append("rect")
    .attr("x", left).attr("y", barY)
    .attr("width", barW).attr("height", barH)
    .attr("rx", 6).attr("fill", "url(#rGrad)");

  // Tick marks and labels
  const ticks = [
    {r:-1.0, label:"-1"},
    {r:-0.8, label:"-0.8"},
    {r:-0.5, label:"-0.5"},
    {r: 0.0, label:"0"},
    {r: 0.5, label:"0.5"},
    {r: 0.8, label:"0.8"},
    {r: 1.0, label:"1"}
  ];

  ticks.forEach(t => {
    const x = left + (t.r + 1) / 2 * barW;
    svg.append("line")
      .attr("x1",x).attr("x2",x)
      .attr("y1", barY + barH).attr("y2", barY + barH + 6)
      .attr("stroke","#333").attr("stroke-width",1);
    svg.append("text")
      .attr("x",x).attr("y", barY + barH + 20)
      .attr("text-anchor","middle").attr("font-size","12px").attr("fill","#333")
      .text(t.label);
  });

  // Descriptor labels above bar
  const descriptors = [
    {r:-1.0, label:"Perfect\nnegative"},
    {r:-0.7, label:"Strong\nnegative"},
    {r: 0.0, label:"None"},
    {r: 0.7, label:"Strong\npositive"},
    {r: 1.0, label:"Perfect\npositive"}
  ];

  descriptors.forEach(d => {
    const x = left + (d.r + 1) / 2 * barW;
    const lines = d.label.split("\n");
    lines.forEach((line, i) => {
      svg.append("text")
        .attr("x",x).attr("y", barY - 18 + i * 15)
        .attr("text-anchor","middle").attr("font-size","11px").attr("fill","#555")
        .text(line);
    });
    svg.append("line")
      .attr("x1",x).attr("x2",x)
      .attr("y1", barY - 4).attr("y2", barY)
      .attr("stroke","#555").attr("stroke-width",1);
  });

  // Axis label
  svg.append("text")
    .attr("x", W/2).attr("y", barY + barH + 42)
    .attr("text-anchor","middle").attr("font-size","13px").attr("fill","#333").attr("font-weight","600")
    .text("r  (correlation coefficient)");

  return svg.node();
}
}

How much does it explain? r²

{
  const data = Array.from({length: 100}, (_, i) => {
    const r = -1 + i * 2/99;
    return {r, r2: r*r};
  });

  return Plot.plot({
    width: 400, height: 280,
    marginLeft: 50, marginBottom: 45,
    x: {label: "r (correlation coefficient)", domain: [-1, 1]},
    y: {label: "r² (variance explained)", domain: [0, 1.05]},
    marks: [
      Plot.line(data, {x:"r", y:"r2", stroke:"#4a90d9", strokeWidth:2.5}),
      Plot.dot([{r:0.5, r2:0.25}, {r:-0.5, r2:0.25}, {r:0.8, r2:0.64}, {r:0.1, r2:0.01}],
        {x:"r", y:"r2", fill:"#e06c4c", r:6}),
      Plot.text([{r:0.5, r2:0.25, t:"r=0.5 → 25%"}, {r:0.8, r2:0.64, t:"r=0.8 → 64%"}, {r:0.1, r2:0.01, t:"r=0.1 → 1%"}],
        {x:"r", y:"r2", text:"t", dy:-12, fontSize:11, fill:"#e06c4c"}),
      Plot.ruleY([0])
    ]
  });
}

\(r^2\) = fraction of variance in \(Y\) explained by \(X\).

• \(r = 0.8\) → \(r^2 = 0.64\) → explains 64%
• \(r = 0.5\) → \(r^2 = 0.25\) → explains only 25%
• \(r = 0.1\) → \(r^2 = 0.01\) → explains 1%
• Weak correlations have very little predictive power
• \(r\) drops fast — don’t be fooled by moderate values

Correlation ≠ Causation

{
  const months = ["Jan","Feb","Mar","Apr","May","Jun","Jul","Aug","Sep","Oct","Nov","Dec"];
  const iceCream = [20, 22, 35, 50, 75, 110, 140, 135, 90, 55, 30, 18];
  const drownings = [30, 28, 40, 55, 80, 115, 145, 138, 92, 58, 32, 22];

  const data = months.map((m, i) => ({month: m, iceCream: iceCream[i], drownings: drownings[i]}));

  return Plot.plot({
    width: 400, height: 280,
    marginLeft: 55, marginBottom: 45,
    x: {label: "Ice cream sales (units)"},
    y: {label: "Drowning deaths"},
    marks: [
      Plot.dot(data, {x:"iceCream", y:"drownings", fill:"#4a90d9", r:6, opacity:0.8}),
      Plot.text(data, {x:"iceCream", y:"drownings", text:"month", dy:-10, fontSize:9, fill:"#666"}),
      Plot.linearRegressionY(data, {x:"iceCream", y:"drownings", stroke:"#e06c4c", strokeWidth:2}),
      Plot.ruleY([0])
    ]
  });
}

Ice cream sales and drowning deaths are strongly correlated.

• \(r \approx 0.99\)

• Does ice cream cause drowning?

• No — summer causes both.

• Heat → more swimming → more drownings.

• Heat → more ice cream sales.

The hidden cause is called a confound.

Confounds

{
  const W = 300, H = 220;
  const svg = d3.create("svg").attr("width", W).attr("height", H);

  const nodes = [
    {id: "summer", x: 150, y: 40, label: "☀️ Summer", color: "#f59e0b"},
    {id: "ice", x: 50, y: 160, label: "🍦 Ice Cream", color: "#4a90d9"},
    {id: "drown", x: 250, y: 160, label: "💀 Drownings", color: "#e06c4c"}
  ];

  const edges = [
    {x1:150, y1:55, x2:65, y2:148},
    {x1:150, y1:55, x2:235, y2:148},
    {x1:80, y1:165, x2:215, y2:165, dashed:true}
  ];

  edges.forEach(e => {
    svg.append("line")
      .attr("x1",e.x1).attr("y1",e.y1).attr("x2",e.x2).attr("y2",e.y2)
      .attr("stroke", e.dashed ? "#aaa" : "#333")
      .attr("stroke-width", e.dashed ? 1.5 : 2)
      .attr("stroke-dasharray", e.dashed ? "5 3" : null)
      .attr("marker-end", "url(#arrow)");
  });

  svg.append("defs").append("marker")
    .attr("id","arrow").attr("viewBox","0 -5 10 10")
    .attr("refX",8).attr("refY",0)
    .attr("markerWidth",6).attr("markerHeight",6)
    .attr("orient","auto")
    .append("path").attr("d","M0,-5L10,0L0,5").attr("fill","#333");

  nodes.forEach(n => {
    svg.append("rect")
      .attr("x", n.x-55).attr("y", n.y-16)
      .attr("width", 110).attr("height", 32)
      .attr("rx", 8).attr("fill", n.color).attr("opacity", 0.15)
      .attr("stroke", n.color).attr("stroke-width", 1.5);
    svg.append("text")
      .attr("x", n.x).attr("y", n.y+5)
      .attr("text-anchor","middle").attr("font-size","12px").attr("fill", n.color).attr("font-weight","600")
      .text(n.label);
  });

  svg.append("text").attr("x",150).attr("y",172).attr("text-anchor","middle")
    .attr("font-size","10px").attr("fill","#aaa").text("spurious correlation");

  return svg.node();
}

A confound is a hidden variable that causes both observed variables.

• Police presence ↑ → crime rate ↑ — police don’t cause crime, high-crime areas get more police
• Medicine intake ↑ → illness ↑ — medicine doesn’t cause illness, sick people take medicine
• Establishing causation requires a controlled experiment

Pearson vs Spearman

{
  function seededRandom(seed) {
    let s = seed;
    return () => { s = (s * 16807) % 2147483647; return (s-1)/2147483646; };
  }
  const rand = seededRandom(55);

  // Monotonic but non-linear: y = x^3
  const data = Array.from({length: 40}, () => {
    const x = rand() * 2 - 1;
    const y = Math.pow(x, 3) + (rand()-0.5)*0.15;
    return {x, y};
  }).sort((a,b) => a.x - b.x);

  // Pearson r
  const mx = d3.mean(data, d=>d.x), my = d3.mean(data, d=>d.y);
  const num = d3.sum(data, d=>(d.x-mx)*(d.y-my));
  const dx = Math.sqrt(d3.sum(data, d=>(d.x-mx)**2));
  const dy = Math.sqrt(d3.sum(data, d=>(d.y-my)**2));
  const pearson = (num/(dx*dy)).toFixed(2);

  // Spearman: rank-based
  const rankX = [...data].map((d,i) => ({...d, rx: i})).sort((a,b)=>a.y-b.y).map((d,i)=>({...d, ry:i}));
  const mx2 = d3.mean(rankX, d=>d.rx), my2 = d3.mean(rankX, d=>d.ry);
  const num2 = d3.sum(rankX, d=>(d.rx-mx2)*(d.ry-my2));
  const dx2 = Math.sqrt(d3.sum(rankX, d=>(d.rx-mx2)**2));
  const dy2 = Math.sqrt(d3.sum(rankX, d=>(d.ry-my2)**2));
  const spearman = (num2/(dx2*dy2)).toFixed(2);

  return Plot.plot({
    width: 400, height: 280,
    marginLeft: 50, marginBottom: 45,
    x: {label: "X"},
    y: {label: "Y = X³"},
    marks: [
      Plot.dot(data, {x:"x", y:"y", fill:"#4a90d9", r:5, opacity:0.7}),
      Plot.linearRegressionY(data, {x:"x", y:"y", stroke:"#e06c4c", strokeWidth:2, strokeDasharray:"5 3"}),
      Plot.line(data, {x:"x", y:"y", stroke:"#7c3aed", strokeWidth:2}),
      Plot.text([{x:0, y:0.85}], {x:"x",y:"y", text: d => `Pearson r = ${pearson}`, fill:"#e06c4c", fontSize:12, fontWeight:"bold"}),
      Plot.text([{x:0, y:0.72}], {x:"x",y:"y", text: d => `Spearman ρ = ${spearman}`, fill:"#7c3aed", fontSize:12, fontWeight:"bold"}),
      Plot.ruleY([0]), Plot.ruleX([0])
    ]
  });
}

\(y = x^3\) is perfectly monotonic — as x goes up, y always goes up.

• Pearson measures linear fit — misses the curve, gives low \(r\)
• Spearman measures monotonic fit — detects the relationship, gives \(\rho \approx 1\)
• Spearman is also more robust to outliers
• Use Pearson for linear relationships, Spearman when the relationship may be non-linear

Logarithms

What is a logarithm?

\[y = \log_b x \iff b^y = x\]

In plain English: how many times do I multiply \(b\) to get \(x\)?

\[\log_2 8 = 3 \quad \text{because} \quad 2^3 = 8\] \[\log_{10} 1000 = 3 \quad \text{because} \quad 10^3 = 1000\]

• Exponentials grow very fast
• Logarithms grow very slowly
• They are inverses of each other

Three roles in data science

• ① Multiplying probabilities — convert products to sums for numerical stability
• ② Handling ratios — make increases and decreases symmetric
• ③ Normalizing skewed data — stretch the left, compress the right

Role 1: Multiplying probabilities

Imagine a spam filter checking 10 words in an email.

Each word has a small probability of appearing in spam:

\[P(\text{spam}) \propto 0.8 \times 0.3 \times 0.9 \times 0.1 \times \cdots\]

With 100 words: \(0.5^{100} \approx 0.0000000000000000000000000000008\)

Floating point underflow — the computer rounds this to zero.

The log trick

\[\log(p_1 \times p_2 \times \cdots \times p_n) = \log p_1 + \log p_2 + \cdots + \log p_n\]

Instead of multiplying tiny numbers, sum their logarithms.

{
  const probs = [0.8, 0.3, 0.9, 0.1, 0.7, 0.4, 0.6, 0.2, 0.85, 0.15];
  const product = probs.reduce((a,b) => a*b, 1);
  const logSum = probs.reduce((a,b) => a + Math.log(b), 0);

  const W = 700, H = 160;
  const svg = d3.create("svg").attr("width", W).attr("height", H);

  // Left box
  svg.append("rect").attr("x",20).attr("y",20).attr("width",300).attr("height",120).attr("rx",8).attr("fill","#fee2e2").attr("stroke","#e06c4c").attr("stroke-width",1.5);
  svg.append("text").attr("x",170).attr("y",50).attr("text-anchor","middle").attr("font-size","13px").attr("font-weight","bold").attr("fill","#e06c4c").text("Multiply probabilities");
  svg.append("text").attr("x",170).attr("y",80).attr("text-anchor","middle").attr("font-size","12px").attr("fill","#333").text(probs.join(" × "));
  svg.append("text").attr("x",170).attr("y",108).attr("text-anchor","middle").attr("font-size","13px").attr("fill","#e06c4c").attr("font-weight","bold").text(`= ${product.toExponential(2)}`);
  svg.append("text").attr("x",170).attr("y",130).attr("text-anchor","middle").attr("font-size","11px").attr("fill","#e06c4c").text("⚠ underflow risk");

  // Arrow
  svg.append("text").attr("x",360).attr("y",88).attr("text-anchor","middle").attr("font-size","24px").attr("fill","#333").text("→");

  // Right box
  svg.append("rect").attr("x",390).attr("y",20).attr("width",290).attr("height",120).attr("rx",8).attr("fill","#dcfce7").attr("stroke","#2ecc71").attr("stroke-width",1.5);
  svg.append("text").attr("x",535).attr("y",50).attr("text-anchor","middle").attr("font-size","13px").attr("font-weight","bold").attr("fill","#2ecc71").text("Sum log probabilities");
  svg.append("text").attr("x",535).attr("y",78).attr("text-anchor","middle").attr("font-size","11px").attr("fill","#333").text("Σ log(p) = " + probs.map(p => Math.log(p).toFixed(2)).join(" + ").slice(0,40) + "...");
  svg.append("text").attr("x",535).attr("y",105).attr("text-anchor","middle").attr("font-size","13px").attr("fill","#2ecc71").attr("font-weight","bold").text(`= ${logSum.toFixed(4)}`);
  svg.append("text").attr("x",535).attr("y",128).attr("text-anchor","middle").attr("font-size","11px").attr("fill","#2ecc71").text("✓ numerically stable");

  return svg.node();
}

Note: log probabilities are always negative since \(\log(p) < 0\) for \(0 < p < 1\)

Role 2: Ratios are asymmetric

If something doubles: ratio = \(2/1 = 2.0\) → \(+100\%\)

If something halves: ratio = \(1/2 = 0.5\) → \(-50\%\)

A doubling and a halving should cancel out — but the average of 2.0 and 0.5 is 1.25, not 1.

Raw ratios are asymmetric — there’s more room above 1 than below.

Before: plotting raw ratios

{
  function seededRandom(seed) {
    let s = seed;
    return () => { s = (s * 16807) % 2147483647; return (s-1)/2147483646; };
  }
  const rand = seededRandom(42);
  const data = Array.from({length: 30}, (_, i) => {
    const ratio = Math.exp((rand() - 0.4) * 2.5);
    return {i, ratio};
  });

  return Plot.plot({
    width: 400, height: 260,
    marginLeft: 55, marginBottom: 40,
    x: {label: "Observation"},
    y: {label: "Ratio (new/old)", domain: [0, 12]},
    marks: [
      Plot.dot(data, {x:"i", y:"ratio", fill:"#4a90d9", r:5, opacity:0.7}),
      Plot.ruleY([1], {stroke:"#e06c4c", strokeWidth:2, strokeDasharray:"5 3"}),
      Plot.ruleY([0])
    ]
  });
}

The red line = ratio of 1 (no change).

• Points above the line: improvements — lots of space
• Points below the line: decreases — cramped between 0 and 1
• Hard to compare magnitudes above and below
• A ratio of 8 looks dramatic; a ratio of 0.1 looks small but is equally extreme

After: plotting log ratios

{
  function seededRandom(seed) {
    let s = seed;
    return () => { s = (s * 16807) % 2147483647; return (s-1)/2147483646; };
  }
  const rand = seededRandom(42);
  const data = Array.from({length: 30}, (_, i) => {
    const ratio = Math.exp((rand() - 0.4) * 2.5);
    return {i, logRatio: Math.log(ratio)};
  });

  return Plot.plot({
    width: 400, height: 260,
    marginLeft: 55, marginBottom: 40,
    x: {label: "Observation"},
    y: {label: "Log ratio — log(new/old)"},
    marks: [
      Plot.dot(data, {x:"i", y:"logRatio", fill:"#4a90d9", r:5, opacity:0.7}),
      Plot.ruleY([0], {stroke:"#e06c4c", strokeWidth:2, strokeDasharray:"5 3"}),
      Plot.ruleY([0])
    ]
  });
}

Same data — logged.

• \(\log(2) = 0.69\) → doubling
• \(\log(0.5) = -0.69\) → halving
• Symmetric around zero
• Equal space above and below the line
• A doubling and a halving now look equally extreme

Role 3: Skewed distributions

Plot.plot({
  width: 400, height: 260,
  marginLeft: 50, marginBottom: 40,
  x: {label: "Screen time (hours)", domain: [0, 16]},
  y: {label: "Count"},
  marks: [
    Plot.rectY(screenData, Plot.binX({y:"count"}, {x: d => d, thresholds:15, fill:"#4a90d9", opacity:0.7})),
    Plot.ruleY([0])
  ]
})

Our screen time data — skewed right.

• A few heavy users pull the tail out
• Mean is misleading
• Hard to model with standard tools
• Many real-world distributions look like this: income, city sizes, website traffic

After log transform

Plot.plot({
  width: 400, height: 260,
  marginLeft: 50, marginBottom: 40,
  x: {label: "log(Screen time)"},
  y: {label: "Count"},
  marks: [
    Plot.rectY(screenData.map(d => Math.log(d)), Plot.binX({y:"count"}, {x: d => d, thresholds:15, fill:"#2ecc71", opacity:0.7})),
    Plot.ruleY([0])
  ]
})

Same data after \(\log\) transform.

• Distribution is much more symmetric
• Long right tail is compressed
• Easier to model and analyze
• Mean is now more meaningful
• This is called a log-normal distribution

Log scales on axes

{
  const data = Array.from({length: 20}, (_, i) => ({
    x: i + 1,
    y: Math.pow(2, i * 0.5)
  }));

  return Plot.plot({
    width: 400, height: 260,
    marginLeft: 55, marginBottom: 40,
    x: {label: "Time"},
    y: {label: "Value (linear scale)"},
    marks: [
      Plot.line(data, {x:"x", y:"y", stroke:"#4a90d9", strokeWidth:2.5}),
      Plot.dot(data, {x:"x", y:"y", fill:"#4a90d9", r:4}),
      Plot.ruleY([0])
    ]
  });
}

Linear scale — exponential growth looks like a hockey stick

{
  const data = Array.from({length: 20}, (_, i) => ({
    x: i + 1,
    y: Math.pow(2, i * 0.5)
  }));

  return Plot.plot({
    width: 400, height: 260,
    marginLeft: 55, marginBottom: 40,
    x: {label: "Time"},
    y: {label: "Value (log scale)", type: "log"},
    marks: [
      Plot.line(data, {x:"x", y:"y", stroke:"#7c3aed", strokeWidth:2.5}),
      Plot.dot(data, {x:"x", y:"y", fill:"#7c3aed", r:4}),
      Plot.ruleY([1])
    ]
  });
}

Log scale — exponential growth becomes a straight line

When to use a log scale

• Data spans multiple orders of magnitude (0.001 to 1,000,000)
• You expect exponential growth — population, viral spread, compound interest
• Comparing percentage changes rather than absolute changes
• Plotting ratios or probabilities

A straight line on a log scale means constant percentage growth — a very common and important pattern in data.

Take-home

• \(\log\) converts multiplication to addition — numerical stability
• \(\log\) makes ratios symmetric — equal treatment of increases and decreases
• \(\log\) normalizes skewed distributions — pulls in long tails
• \(\log\) axes reveal exponential patterns as straight lines
• When in doubt with right-skewed data — try taking the log