Binomial

A Binomial distribution models the number of successes in \(n\) independent trials, where each trial is a Bernoulli event with success probability \(p\).

Intuition:

One Bernoulli trial answers a yes/no question (true/false).
A Binomial aggregates \(n\) such trials and returns a count in \(\{0, 1, ..., n\}\).

What question does the Binomial answer?

The Binomial distribution answers the following core question:

If each individual in a population independently has a certain feature with probability \(p\) (e.g. “this email gets clicked”, “this part is defective”, “this person tests positive”), then for a random sample of \(n\) individuals, what is the probability that the feature is present in exactly \(k\) of them?

We write this as:

\(X \sim Binomial(n, p)\) and ask for \(P(X = k)\).

Closed form (probability mass function)

For \(k = 0, 1, ..., n\):

\[P(X = k) = {n \choose k} p^k (1-p)^{n-k}\]

where

\[{n \choose k} = \frac{n!}{k!(n-k)!}\]

is the number of ways to choose which :math:`k of the \(n\) trials are successes.

Intuition (why this formula is true)

Think of \(n\) independent Bernoulli trials (success probability p).

Pick one specific sequence of outcomes that has exactly \(k\) successes and \(n-k\) failures, for example:

S S F S F ...

Because the trials are independent:
- the probability of the \(k\) successes is \(p^k\)
- the probability of the \(n-k\) failures is \((1-p)^{n-k}\)
so the probability of this particular sequence is \(p^k (1-p)^{n-k}\).
Now count how many different sequences have exactly \(k\) successes. This is purely combinatorial: you choose which \(k\) positions (out of \(n\)) are successes, so there are \(C(n,k) = {n \choose k}\) such sequences.
These sequences are disjoint events, and each has the same probability \(p^k (1-p)^{n-k}\), so you multiply:

\[P(X = k) = {n \choose k} p^k (1-p)^(n-k).\]

This is why the Binomial is one of the most important distributions: it is the canonical model for counts of “how many successes out of n independent tries?”

Constructor

Binomial({p: ..., n: ...})

p: success probability in [0, 1]
n: number of trials (integer, n >= 1)
support: integers 0..n

Relationship to Bernoulli

A Binomial random variable can be understood as the sum of n Bernoulli trials.

In code, these two ideas align:

One Bernoulli outcome: sample(Bernoulli({p: p})) → boolean
Many trials + counting successes → integer count

Use Binomial when you only care about the total number of successes, not the individual trial outcomes.

Typical use cases

Counting successes in n independent Bernoulli trials (e.g. “how many clicks out of 10 emails?”)
Likelihood for count data via observe(Binomial(...), k) when you observe k successes out of n

Executable example: basics (samples and score)

var d = Binomial({n: 10, p: 0.3});

var out = {
  oneSample: sample(d),
  someSamples: repeat(8, function() { return sample(d); }),

  // score(k) is log P(X = k)
  logp_k4: d.score(4),
  logp_k0: d.score(0),
  logp_k10: d.score(10)
};

out;

{
  oneSample: 4,
  someSamples: [
    3, 3, 2, 3,
    3, 2, 3, 2
  ],
  logp_k4: -1.6088333502186698,
  logp_k0: -3.5667494393873245,
  logp_k10: -12.03972804325936
}

Scoring

d.score(k) is the log probability of observing exactly k successes out of n.

How does `score(k)` relate to the Binomial formula?

Recall the Binomial probability mass function:

\[P(X = k) = {n \choose k} p^k (1-p)^{n-k}\]

WebPPL returns probabilities in log space. For d = Binomial({n: n, p: p}):

d.score(k) equals \(\log P(X = k)\) (natural log)
therefore Math.exp(d.score(k)) equals the ordinary probability \(P(X = k)\)

Equivalently:

\[d.score(k) = \log {n \choose k} + k \log p + (n-k) \log (1-p)\]

This is convenient because very small probabilities remain representable as log values, and you can always convert back with exp when you want human-readable probabilities.

Executable example: converting `score(k)` back to probability

// Convert Binomial log-probabilities (score) back to ordinary probabilities.
// Avoid imperative loops: WebPPL's CPS transform can choke on some JS statements.

var n = 10;
var p = 0.3;
var d = Binomial({n: n, p: p});

// Simple recursive range [a..b]
var range = function(a, b) {
  return (a > b) ? [] : [a].concat(range(a + 1, b));
};

var pmf = function(k) {
  return Math.exp(d.score(k));
};

// A few selected k values:
var ks = [0, 1, 2, 3, 4, 5, 10];

var rows = map(function(k) {
  var logp = d.score(k);
  return {k: k, logp: logp, p: Math.exp(logp)};
}, ks);

// Check that probabilities across *all* k sum to ~1.
var allProbs = map(pmf, range(0, n));
var total = sum(allProbs);

var out = {
  n: n,
  p: p,
  selected: rows,
  sum_over_all_k: total
};

out;

{
  n: 10,
  p: 0.3,
  selected: [
    { k: 0, logp: -3.5667494393873245, p: 0.02824752489999998 },
    { k: 1, logp: -2.111462206780482, p: 0.12106082099999996 },
    { k: 2, logp: -1.4546826703914122, p: 0.23347444049999977 },
    { k: 3, logp: -1.321151277766889, p: 0.2668279319999999 },
    { k: 4, logp: -1.6088333502186698, p: 0.20012094899999994 },
    { k: 5, logp: -2.2738096538119192, p: 0.10291934519999993 },
    { k: 10, logp: -12.03972804325936, p: 0.000005904899999999995 }
  ],
  sum_over_all_k: 0.9999999999999993
}

Beyond \(P(X = k)\): CDF and tail probabilities

In practice you often want cumulative questions such as:

\(P(X ≤ k)\) (“at most k successes”)
\(P(X ≥ k)\) (“at least k successes”)

For a Binomial, these can be computed by summing the point probabilities:

\[P(X \le k) = \sum\limits_{i=0}^{k} P(X=i)\]

\[P(X \ge k) = \sum\limits_{i=k}^{n} P(X=i)\]

In WebPPL you can obtain \(P(X=i)\) as Math.exp(d.score(i)) and then sum over the desired range.

Executable example: CDF and tail probabilities

// Binomial CDF and tail probabilities by summing exp(score(i)).
// Avoid imperative loops.

var n = 10;
var p = 0.3;
var k = 4;

var d = Binomial({n: n, p: p});

var range = function(a, b) {
  return (a > b) ? [] : [a].concat(range(a + 1, b));
};

var pmf = function(i) {
  return Math.exp(d.score(i));
}; var pEq = pmf(k);
var pLe = sum(map(pmf, range(0, k)));
var pGe = sum(map(pmf, range(k, n)));

var pLt = (k > 0) ? sum(map(pmf, range(0, k - 1))) : 0;
var pGt = (k < n) ? sum(map(pmf, range(k + 1, n))) : 0;

var total = sum(map(pmf, range(0, n)));

var out = {
  n: n,
  p: p,
  k: k,

  p_eq_k: pEq,
  p_le_k: pLe,
  p_lt_k: pLt,

  p_ge_k: pGe,
  p_gt_k: pGt,

  sum_all: total,
  check_complements: {
    p_le_k_plus_p_gt_k: pLe + pGt,
    p_lt_k_plus_p_ge_k: pLt + pGe
  }
};

out;

{
  n: 10,
  p: 0.3,
  k: 4,
  p_eq_k: 0.20012094899999994,
  p_le_k: 0.8497316673999994,
  p_lt_k: 0.6496107183999995,
  p_ge_k: 0.3503892815999998,
  p_gt_k: 0.1502683325999999,
  sum_all: 0.9999999999999993,
  check_complements: {
    p_le_k_plus_p_gt_k: 0.9999999999999993,
    p_lt_k_plus_p_ge_k: 0.9999999999999993
  }
}

A real-life example: estimating click-through rate (CTR) on a small grid

Story: you send \(n = 10\) emails and observe \(k = 4\) clicks. Assume clicks are independent with unknown click probability \(p\) (a Bernoulli success rate). We place a discrete prior on a small candidate set for \(p\) and compute the posterior exactly using enumeration.

// Click-through rate example:
// n emails sent, k clicks observed (successes).
var n = 10;
var k = 4;

// Discrete prior grid for p so we can enumerate exactly.
var grid = [0.1, 0.3, 0.5];
var prior = Categorical({vs: grid}); // uniform over the grid

var model = function() {
  var p = sample(prior);
  observe(Binomial({n: n, p: p}), k);
  return p;
};

var posterior = Infer({method: "enumerate", model: model});

// Convert log scores to ordinary probabilities
var supp = posterior.support();
var probs = map(function(v) { return Math.exp(posterior.score(v)); }, supp);

var out = {
  n: n,
  k: k,
  p_grid: grid,
  posterior_support: supp,
  posterior_probs: probs,
  sum: sum(probs)
};

out;

{
  n: 10,
  k: 4,
  p_grid: [ 0.1, 0.3, 0.5 ],
  posterior_support: [ 0.5, 0.3, 0.1 ],
  posterior_probs: [ 0.4925508035024606, 0.48064479928137027, 0.02680439721616908 ],
  sum: 1
}