Bernoulli

A Bernoulli distribution models a single yes/no (two-outcome) event.

Typical real-world meanings:

• “Did it rain today?” (yes/no)

• “Did the user click the link?” (yes/no)

• “Is the item defective?” (yes/no)

In WebPPL, Bernoulli samples are booleans: true / false.

Constructor

Bernoulli({p: ...})

• p: success probability in [0, 1]

• support: {true, false}

Relationship to booleans

Bernoulli is the canonical distribution when your random variable is literally a boolean. That means:

• sample(Bernoulli({p: 0.7})) returns either true or false.

• The exact meaning of “success” is up to you. Often we interpret: - true = success / yes / event happens - false = failure / no / event does not happen

Relationship to flip

flip is shorthand for a Bernoulli draw:

• flip(p) is equivalent to sample(Bernoulli({p: p})).

• flip() uses the default p = 0.5 (a fair coin).

Rule of thumb:

• Use flip when you just want a quick boolean coin flip.

• Use Bernoulli({p: ...}) when you want an explicit distribution object (e.g. to call score or pass it around).

Relationship to Categorical

You can also express the same two-outcome distribution using Categorical by making the outcomes explicit:

sample(Categorical({ps: [p, 1-p], vs: [true, false]}))

This is useful when you want non-boolean outcomes, e.g. ['H','T'] or [1,0], or when you later generalize to more than two outcomes.

Scoring

For Bernoulli:

• d.score(true)  = log(p)

• d.score(false) = log(1 - p)

These are natural logs (base e). If you want the ordinary probability back, use Math.exp(logp).

Gotcha: booleans vs 0/1

Bernoulli returns booleans (true/false).

If you need numeric 0/1 values, either:

• convert explicitly:

  (sample(Bernoulli({p: p})) ? 1 : 0)

• or if you need a vector of 0/1 outcomes, consider MultivariateBernoulli({ps: ...}).

Executable example: basics (sample, score, flip)

var p = 0.7;
var d = Bernoulli({p: p});

var out = {
  p: p,

  // Samples are booleans (true/false)
  samples: repeat(8, function() { return sample(d); }),

  // score returns natural log probs
  logp_true: d.score(true),
  logp_false: d.score(false),

  // flip(p) is shorthand for sampling Bernoulli({p: p})
  flipSamples: repeat(8, function() { return flip(p); })
};

out;

{
  p: 0.7,
  samples: [
    true, true,  true,
    true, false, true,
    true, true
  ],
  logp_true: -0.35667494393873245,
  logp_false: -1.203972804325936,
  flipSamples: [
    false, true,
    false, true,
    true,  false,
    false, false
  ]
}

A real-life example: estimating a biased coin (discrete grid)

Suppose you flipped a coin 10 times and observed the outcomes (true = heads). We want to infer which p values are plausible.

To keep everything finite and exactly enumerable, we put a prior on a discrete grid (e.g. p in {0.1, 0.2, ..., 0.9}) and use Infer({method: 'enumerate'}).

// Real-life story: a biased coin.
// true = heads, false = tails.
var observations = [
  true, true, false, true, true,
  false, true, true, true, false
];

// Discrete grid prior so we can enumerate exactly.
var grid = [0.1,0.2,0.3,0.4,0.5,0.6,0.7,0.8,0.9];
var prior = Categorical({vs: grid}); // uniform over grid (ps omitted)

var model = function() {
  var p = sample(prior);
  map(function(o) {
    observe(Bernoulli({p: p}), o);
  }, observations);
  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 = {
  support: supp,
  probs: probs,
  sum: sum(probs)
};

out;

{
  support: [
    0.9, 0.8, 0.7,
    0.6, 0.5, 0.4,
    0.3, 0.2, 0.1
  ],
  probs: [
    0.0630726246485273,
    0.22123978796752938,
    0.29321985989557897,
    0.2362555743579042,
    0.12877850558581388,
    0.046667767774400876,
    0.009892048584565563,
    0.0008642179217481641,
    0.000009613263930578787
  ],
  sum: 0.9999999999999989
}