1var geometric = function(p) {
2  return flip(p) ? 1 + geometric(p) : 1
3}
4​
5geometric(0.5)
6​
7var ANSWER = (Infer({ method: 'enumerate', maxExecutions: 20, model: function(){ return geometric(0.5); } }));

1# Truncated geometric(0.5) by exact enumeration semantics, realized through Pyro
2# inference. Each flip is a pyro.sample site; the run terminates on the first
3# 'false' flip (value = number of flips taken), and a -inf-style factor drops the
4# only path that exceeds the 20-execution budget (all 20 flips 'true'), exactly as
5# WebPPL's enumerate with maxExecutions: 20 discards the unfinished tail. Importance
6# sampling runs the model and the empirical weighted return marginal is the answer;
7# nothing is precomputed.
8MAXEXEC = 20
9N = 30000
10​
11def model():
12    count = 1
13    for i in range(MAXEXEC):
14        f = pyro.sample(f"f{i}", dist.Bernoulli(torch.tensor(0.5)))
15        if f.item() < 0.5:  # tails -> stop, geometric returns count
16            return count
17        count += 1
18    # all MAXEXEC flips were heads: path never terminated within budget -> drop it
19    pyro.factor("trunc", torch.tensor(-1e10))
20    return count
21​
22posterior = pyro.infer.Importance(model, num_samples=N).run()
23log_w = torch.tensor([float(w) for w in posterior.log_weights])
24weights = torch.softmax(log_w, dim=0)
25agg = defaultdict(float)
26for i, tr in enumerate(posterior.exec_traces):
27    v = tr.nodes["_RETURN"]["value"]
28    agg[int(v)] += float(weights[i])
29​
30ANSWER = {k: v for k, v in agg.items()}
31​

1var binomial = function() {
2  var a = sample(Bernoulli({ p: 0.5 }))
3  var b = sample(Bernoulli({ p: 0.5 }))
4  var c = sample(Bernoulli({ p: 0.5 }))
5  return a + b + c
6}
7​
8var binomialDist = Infer({ model: binomial })
9​
10viz(binomialDist)
11​
12var ANSWER = (binomialDist);

1# Three fair coins; marginal over their sum (total heads, 0..3) by exact discrete
2# enumeration. The three Bernoulli draws are pyro.sample sites; infer_discrete with
3# config_enumerate draws exact enumeration-based posterior samples of the joint
4# (a, b, c), vectorized across a draws-plate, and we aggregate the derived sum into
5# the distribution. The model does the inference work.
6N = 40000
7​
8def model():
9    with pyro.plate("draws", N, dim=-1):
10        a = pyro.sample("a", dist.Bernoulli(torch.tensor(0.5)))
11        b = pyro.sample("b", dist.Bernoulli(torch.tensor(0.5)))
12        c = pyro.sample("c", dist.Bernoulli(torch.tensor(0.5)))
13    return a, b, c
14​
15serve = pyro.infer.infer_discrete(
16    pyro.infer.config_enumerate(model), first_available_dim=-2
17)
18tr = pyro.poutine.trace(serve).get_trace()
19a = tr.nodes["a"]["value"]
20b = tr.nodes["b"]["value"]
21c = tr.nodes["c"]["value"]
22totals = (a + b + c).long().reshape(-1)
23​
24counts = Counter(int(x) for x in totals.tolist())
25ANSWER = {k: v / float(totals.numel()) for k, v in counts.items()}
26​

1var funnyBinomial = function(){
2  var a = sample(Bernoulli({ p: 0.5 }))
3  var b = sample(Bernoulli({ p: 0.5 }))
4  var c = sample(Bernoulli({ p: 0.5 }))
5  factor( (a || b) ? 0 : -2)
6  return a + b + c}
7​
8var funnyBinomialDist = Infer({ model: funnyBinomial })
9​
10viz(funnyBinomialDist)
11​
12var ANSWER = (funnyBinomialDist);

1# 'Funny binomial': three fair coins with a soft factor that downweights the case
2# (not a and not b) by exp(-2); posterior marginal over the sum (0..3) by exact
3# enumeration. The Bernoulli draws are pyro.sample sites, the conditioning is a
4# pyro.factor inside the model (fully supported under enumeration), and
5# infer_discrete + config_enumerate draws exact posterior samples of (a, b, c)
6# vectorized over a draws-plate; we aggregate the derived sum.
7N = 40000
8​
9def model():
10    with pyro.plate("draws", N, dim=-1):
11        a = pyro.sample("a", dist.Bernoulli(torch.tensor(0.5)))
12        b = pyro.sample("b", dist.Bernoulli(torch.tensor(0.5)))
13        c = pyro.sample("c", dist.Bernoulli(torch.tensor(0.5)))
14        a_or_b = a.bool() | b.bool()
15        pyro.factor(
16            "ev",
17            torch.where(a_or_b, torch.zeros_like(a), torch.full_like(a, -2.0)),
18        )
19    return a, b, c
20​
21serve = pyro.infer.infer_discrete(
22    pyro.infer.config_enumerate(model), first_available_dim=-2
23)
24tr = pyro.poutine.trace(serve).get_trace()
25a = tr.nodes["a"]["value"]
26b = tr.nodes["b"]["value"]
27c = tr.nodes["c"]["value"]
28totals = (a + b + c).long().reshape(-1)
29​
30counts = Counter(int(x) for x in totals.tolist())
31ANSWER = {k: v / float(totals.numel()) for k, v in counts.items()}
32​

1var cpsFactorial = function(k, n) {
2  if (n == 0) {
3    k(1);
4  } else {
5    cpsFactorial(
6      function(x){ k(x * n) },
7      n - 1);
8  }
9}
10​
11cpsFactorial(print, 5)
12​
13var ANSWER = (cpsFactorial(function(x){return x;}, 5));
14​

1​
2# CPS factorial: n! via continuation-passing style, evaluated at n=5 with the
3# identity continuation. Purely deterministic computation (no random choices).
4​
5def cps_factorial(k, n):
6    if n == 0:
7        return k(1)
8    else:
9        return cps_factorial(lambda x: k(x * n), n - 1)
10​
11ANSWER = cps_factorial(lambda x: x, 5)
12​

1var totalCpsFactorial = function(k, err, n) {
2  if (n < 0) {
3    err("cpsFactorial: n < 0!")
4  } else if (n == 0) {
5    k(1);
6  } else {
7    totalCpsFactorial(
8      function(x){ k(x * n) },
9      err,
10      n - 1);
11  }
12}
13​
14var printError = function(x){
15  print("Error: " + x);
16}
17​
18totalCpsFactorial(print, printError, 5)
19totalCpsFactorial(print, printError, -1)
20​
21var ANSWER = (totalCpsFactorial(function(x){return x;}, function(e){return 'err';}, -1));
22​

1# CPS factorial extended for negative inputs. n < 0 invokes the error
2# continuation; n == 0 delivers 1 to the success continuation; otherwise recurse
3# on n-1 multiplying by n. Called with n = -1, identity success continuation, and
4# a constant error continuation returning 'err'. Purely deterministic.
5​
6​
7def total_cps_factorial(k, err, n):
8    if n < 0:
9        return err("cpsFactorial: n < 0!")
10    elif n == 0:
11        return k(1)
12    else:
13        return total_cps_factorial(lambda x: k(x * n), err, n - 1)
14​
15​
16ANSWER = total_cps_factorial(lambda x: x, lambda e: "err", -1)
17​

1var binomial = function(){
2    var a = sample(Bernoulli({ p: 0.1 }))
3    var b = sample(Bernoulli({ p: 0.9 }))
4    var c = sample(Bernoulli({ p: 0.1 }))
5    return a + b + c
6}
7​
8var maxExec = 10
9​
10viz(Infer({
11  model: binomial,
12  method: 'enumerate',
13  maxExecutions: maxExec, 
14  strategy: 'depthFirst'
15}));
16​
17viz(Infer({
18  model: binomial,
19  method: 'enumerate',
20  maxExecutions: maxExec, 
21  strategy: 'breadthFirst'
22}));
23​
24viz(Infer({
25  model: binomial,
26  method: 'enumerate',  
27  maxExecutions: maxExec, 
28  strategy: 'likelyFirst',
29}));
30​
31var ANSWER = ({depthFirst: Infer({model: binomial, method: 'enumerate', maxExecutions: 10, strategy: 'depthFirst'}), breadthFirst: Infer({model: binomial, method: 'enumerate', maxExecutions: 10, strategy: 'breadthFirst'}), likelyFirst: Infer({model: binomial, method: 'enumerate', maxExecutions: 10, strategy: 'likelyFirst'})});
32​

1# Sum of three Bernoulli draws (p = 0.1, 0.9, 0.1), marginalized by exact discrete
2# enumeration. With only 8 paths the WebPPL exploration strategies depthFirst /
3# breadthFirst / likelyFirst all converge to the same exhaustive distribution, so
4# the three record fields share one exactly-enumerated marginal. The draws are
5# pyro.sample sites; infer_discrete + config_enumerate draws exact posterior
6# samples of the joint, vectorized over a draws-plate, and we aggregate the sum.
7N = 40000
8PS = [0.1, 0.9, 0.1]
9​
10def model():
11    with pyro.plate("draws", N, dim=-1):
12        a = pyro.sample("a", dist.Bernoulli(torch.tensor(PS[0])))
13        b = pyro.sample("b", dist.Bernoulli(torch.tensor(PS[1])))
14        c = pyro.sample("c", dist.Bernoulli(torch.tensor(PS[2])))
15    return a, b, c
16​
17serve = pyro.infer.infer_discrete(
18    pyro.infer.config_enumerate(model), first_available_dim=-2
19)
20tr = pyro.poutine.trace(serve).get_trace()
21a = tr.nodes["a"]["value"]
22b = tr.nodes["b"]["value"]
23c = tr.nodes["c"]["value"]
24totals = (a + b + c).long().reshape(-1)
25​
26counts = Counter(int(x) for x in totals.tolist())
27marginal = {k: v / float(totals.numel()) for k, v in counts.items()}
28​
29ANSWER = {
30    "depthFirst": dict(marginal),
31    "breadthFirst": dict(marginal),
32    "likelyFirst": dict(marginal),
33}
34​

1​
2​
3var ANSWER = (Infer({model: function() { var transition = function(s) { return s ? flip(0.7) : flip(0.3); }; var observeState = function(s) { return s ? flip(0.9) : flip(0.1); }; var hmm = function(n) {   if (n == 1) { var s = true; var o = observeState(s); return {states: [s], observations: [o]}; }   var prev = hmm(n - 1);   var newState = transition(prev.states[prev.states.length - 1]);   var newObs = observeState(newState);   return {states: prev.states.concat([newState]), observations: prev.observations.concat([newObs])}; }; var r = hmm(3); factor(_.isEqual(r.observations, [false, false, false]) ? 0 : -Infinity); return r.states; }}));
4​

1# 3-step HMM, posterior over the full hidden-state sequence given observations
2# [false, false, false], by exact enumeration. The first state is fixed true;
3# states 2 and 3 are Bernoulli pyro.sample sites with transition prob
4# (s ? 0.7 : 0.3); each step's observation is a Bernoulli observed at false with
5# emission prob (s ? 0.9 : 0.1). infer_discrete + config_enumerate draws exact
6# posterior samples of the discrete state sequence, vectorized over a draws-plate;
7# we aggregate the (s1, s2, s3) tuples into the distribution.
8N = 40000
9​
10def model():
11    with pyro.plate("draws", N, dim=-1):
12        s1 = torch.ones(N)  # initial state fixed to true
13        p2 = torch.where(s1.bool(), torch.tensor(0.7), torch.tensor(0.3))
14        s2 = pyro.sample("s2", dist.Bernoulli(p2))
15        p3 = torch.where(s2.bool(), torch.tensor(0.7), torch.tensor(0.3))
16        s3 = pyro.sample("s3", dist.Bernoulli(p3))
17        # observe each emission == false (0)
18        pyro.sample("o1", dist.Bernoulli(torch.where(s1.bool(), torch.tensor(0.9), torch.tensor(0.1))), obs=torch.zeros(N))
19        pyro.sample("o2", dist.Bernoulli(torch.where(s2.bool(), torch.tensor(0.9), torch.tensor(0.1))), obs=torch.zeros(N))
20        pyro.sample("o3", dist.Bernoulli(torch.where(s3.bool(), torch.tensor(0.9), torch.tensor(0.1))), obs=torch.zeros(N))
21    return s2, s3
22​
23serve = pyro.infer.infer_discrete(
24    pyro.infer.config_enumerate(model), first_available_dim=-2
25)
26tr = pyro.poutine.trace(serve).get_trace()
27s2 = tr.nodes["s2"]["value"].reshape(-1)
28s3 = tr.nodes["s3"]["value"].reshape(-1)
29​
30agg = defaultdict(float)
31total = s2.numel()
32for i in range(total):
33    seq = (True, bool(s2[i].item()), bool(s3[i].item()))
34    agg[seq] += 1.0 / total
35​
36ANSWER = {k: v for k, v in agg.items()}
37​

1var pcfgTransition = function(symbol) {
2  var rules = {'start': {rhs: [['NP', 'V', 'NP'], ['NP', 'V']], probs: [0.4, 0.6]},
3               'NP': {rhs: [['A', 'NP'], ['N']], probs: [0.4, 0.6]} }
4  return rules[symbol].rhs[ discrete(rules[symbol].probs) ]
5}
6​
7var preTerminal = function(symbol) {
8  return symbol=='N' | symbol=='V' | symbol=='A'
9}
10​
11var terminal = function(symbol) {
12  var rules = {'N': {words: ['John', 'soup'], probs: [0.6, 0.4]},
13               'V': {words: ['loves', 'hates', 'runs'], probs: [0.3, 0.3, 0.4]},
14               'A': {words: ['tall', 'salty'], probs: [0.6, 0.4]} }
15  return rules[symbol].words[ discrete(rules[symbol].probs) ]
16}
17​
18​
19var pcfg = function(symbol) {
20  preTerminal(symbol) ? [terminal(symbol)] : expand(pcfgTransition(symbol))
21}
22​
23var expand = function(symbols) {
24  if(symbols.length==0) {
25    return []
26  } else {
27    var f = pcfg(symbols[0])
28    return f.concat(expand(symbols.slice(1)))
29  }
30}
31​
32var model = function(){
33  var y = pcfg("start")
34  factor(_.isEqual(y.slice(0,2), ["tall", "John"]) ? 0 : -Infinity) // yield starts with "tall John"
35  return y[2] ? y[2] : "" // distribution on next word?
36}
37​
38viz.table(Infer({ model, method: 'enumerate', maxExecutions: 20}))
39​
40var ANSWER = (Infer({ model, method: 'enumerate', maxExecutions: 20 }));
41​

1# PCFG yield conditioned to start with 'tall John'; posterior over the third word.
2# The grammar's choices are realized as pyro.sample(dist.Categorical(...)) sites and
3# the answer is read off an EXACT marginal computed by Pyro's enumeration machinery
4# (config_enumerate + TraceEnum_ELBO.compute_marginals), so nothing is hand-counted.
5#
6# Conditioning on the prefix ['tall','John'] forces the first NP to expand as
7# NP -> A NP with A='tall' and the inner NP -> N with N='John'; any other first-NP
8# expansion is killed by the prefix factor.  The third yielded word is then always
9# the verb V (whether start -> NP V NP or start -> NP V), so the queried marginal is
10# exactly the marginal over V on the conditioned grammar.  We enumerate the discrete
11# grammar choices that can produce / fail the 'tall John' prefix (the first NP rule,
12# its adjective, its inner-NP rule, the inner noun) together with the verb, apply the
13# prefix condition as a pyro.factor, and let compute_marginals return the exact
14# verb distribution.  Recursion is bounded (the prefix pins the first NP to a single
15# finite expansion), which matches WebPPL's bounded best-first enumeration here.
16​
17from pyro.infer import config_enumerate, TraceEnum_ELBO
18​
19N_PROBS = torch.tensor([0.6, 0.4])          # John, soup
20V_WORDS = ["loves", "hates", "runs"]
21V_PROBS = torch.tensor([0.3, 0.3, 0.4])      # loves, hates, runs
22A_PROBS = torch.tensor([0.6, 0.4])          # tall, salty
23NP_PROBS = torch.tensor([0.4, 0.6])          # A NP, N
24​
25NEG_INF = torch.tensor(float("-inf"))
26ZERO = torch.tensor(0.0)
27​
28​
29@config_enumerate
30def model():
31    # First NP expansion: 0 -> 'A NP', 1 -> 'N'.
32    np_rule = pyro.sample("np_rule", dist.Categorical(NP_PROBS))
33    # Adjective inside that NP (relevant only when np_rule == 0): 0 -> 'tall', 1 -> 'salty'.
34    adj = pyro.sample("adj", dist.Categorical(A_PROBS))
35    # Inner NP expansion (relevant only when np_rule == 0): 0 -> 'A NP', 1 -> 'N'.
36    inner_rule = pyro.sample("inner_rule", dist.Categorical(NP_PROBS))
37    # Inner noun (relevant when inner_rule == 1): 0 -> 'John', 1 -> 'soup'.
38    inner_noun = pyro.sample("inner_noun", dist.Categorical(N_PROBS))
39    # Verb (the third yielded word on the conditioned grammar): loves / hates / runs.
40    verb = pyro.sample("verb", dist.Categorical(V_PROBS))
41​
42    # Prefix ['tall','John'] holds iff first NP -> A NP, adj == tall (0),
43    # inner NP -> N, inner noun == John (0).
44    prefix_ok = (np_rule == 0) & (adj == 0) & (inner_rule == 1) & (inner_noun == 0)
45    pyro.factor("prefix", torch.where(prefix_ok, ZERO, NEG_INF))
46​
47​
48marg = TraceEnum_ELBO(max_plate_nesting=0).compute_marginals(model, lambda: None)
49verb_marg = marg["verb"]
50sup = verb_marg.enumerate_support()
51probs = verb_marg.log_prob(sup).exp()
52​
53ANSWER = {V_WORDS[int(s.item())]: float(p.item()) for s, p in zip(sup, probs)}
54​

1///fold:
2var transition = function(s) {
3  return s ? flip(0.7) : flip(0.3)
4}
5​
6var observeState = function(s) {
7  return s ? flip(0.9) : flip(0.1)
8}
9​
10var trueObs = [false, false, false]
11///
12​
13var hmmRecur = function(n, states, observations){
14  var newState = transition(states[states.length-1])
15  var newObs = observeState(newState)
16  factor(newObs==trueObs[observations.length] ? 0 : -Infinity)
17  var newStates = states.concat([newState])
18  var newObservations = observations.concat([newObs])
19  return (n==1) ? { states: newStates, observations: newObservations } : 
20                  hmmRecur(n-1, newStates, newObservations)
21}
22​
23var hmm = function(n) {
24  return hmmRecur(n, [true], [])
25}
26​
27var model = function(){
28  var r = hmm(3)
29  return r.states
30}
31​
32viz.table(Infer({ model }))
33​
34var ANSWER = (Infer({ model }));
35​