ppl-gym

var ANSWER = Infer({method: 'enumerate'}, function () {
  var A = flip()
  factor(A ? Math.log(19) : Math.log(1))
  return A
});

var ANSWER = Infer({method: 'enumerate'}, function () {
  var A = flip()
  factor(A ? Math.log(0.95 / 0.05) : Math.log(0.05 / 0.95))
  return A
});

Infer({method: 'enumerate'}, function () {
  var A = flip()
  factor(A ? Math.log(19) : 0)
  return A
});

var ANSWER = Infer({method: 'enumerate'}, function () {
  var A = flip()
  factor(A ? Math.log(19) : 0)
  return A
});

var ANSWER = Infer({method: 'enumerate'}, function () {
  var A = flip()
  factor(A ? Math.log(19) : 0)
  return A
});

var ANSWER = Infer({method: 'enumerate'}, function () {
  var A = flip()
  factor(A ? Math.log(19) : 0)
  return A
});

var ANSWER = Infer({method: 'enumerate'}, function () {
  var A = flip()
  factor(A ? Math.log(19) : 0)
  return A
});

var ANSWER = Infer({method: 'enumerate'}, function () {
  var A = flip();
  factor(A ? Math.log(19) : 0);
  return A;
});

var ANSWER = Infer({}, function() {
    var a = flip(0.5);
    var b = flip(0.5);
    var c = flip(0.5);
    var numHeads = (a ? 1 : 0) + (b ? 1 : 0) + (c ? 1 : 0);
    factor(numHeads === 2 ? 2 : 0);
    return a;
});

var ANSWER = Infer({}, function() {
    var a = flip(0.5);
    var b = flip(0.5);
    var c = flip(0.5);
    var numHeads = (a ? 1 : 0) + (b ? 1 : 0) + (c ? 1 : 0);
    factor(numHeads === 2 ? 0 : -Infinity);
    return a;
});

var ANSWER = Infer({}, function() {
    var a = flip(0.5);
    var b = flip(0.5);
    var c = flip(0.5);
    var numHeads = (a ? 1 : 0) + (b ? 1 : 0) + (c ? 1 : 0);
    factor(numHeads === 2 ? 1 : 0);
    return a;
});

var ANSWER = Infer({}, function() {
    var a = flip(0.5);
    var b = flip(0.5);
    var c = flip(0.5);
    var numHeads = (a ? 1 : 0) + (b ? 1 : 0) + (c ? 1 : 0);
    factor(numHeads === 2 ? 1 : 0);
    return a;
});

var ANSWER = Infer({}, function() {
    var a = flip(0.5);
    var b = flip(0.5);
    var c = flip(0.5);
    var numHeads = (a ? 1 : 0) + (b ? 1 : 0) + (c ? 1 : 0);
    factor(numHeads === 2 ? 0 : -Infinity);
    return a;
});

var ANSWER = Infer({}, function() {
    var a = flip(0.5);
    var b = flip(0.5);
    var c = flip(0.5);
    var numHeads = (a ? 1 : 0) + (b ? 1 : 0) + (c ? 1 : 0);
    factor(numHeads === 2 ? 0 : -Infinity);
    return a;
});

var ANSWER = Infer({}, function() {
    var a = flip(0.5);
    var b = flip(0.5);
    var c = flip(0.5);
    var numHeads = (a ? 1 : 0) + (b ? 1 : 0) + (c ? 1 : 0);
    factor(numHeads === 2 ? 0 : -Infinity);
    return a;
});

var responder = function(offer) {
  return offer >= 1;
};

var ANSWER = Infer({method: "enumerate"}, function(){
  var offer = uniformDraw([0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10]);
  var accepted = responder(offer);
  var reward = accepted ? (10 - offer) : 0;
  factor(reward);
  return offer;
});

var responder = function(offer) {
  return offer >= 1;
};

var ANSWER = Infer({method: "enumerate"}, function(){
  var offer = randomInteger(11); // 0 to 10
  var accepted = responder(offer);
  var reward = accepted ? (10 - offer) : 0;
  factor(reward);
  return offer;
});

var responder = function(offer) {
  return offer >= 1;
}

var ANSWER = Infer({method: "enumerate"}, function(){
  var offer = uniformDraw([0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10]);
  var accepted = responder(offer);
  var reward = accepted ? (10 - offer) : 0;
  factor(reward);
  return offer;
});

var responder = function(offer) {
  return offer >= 1;
};

var ANSWER = Infer({method: "enumerate"}, function(){
  var offer = randomInteger(11);
  var accepted = responder(offer);
  var reward = accepted ? (10 - offer) : 0;
  factor(reward);
  return offer;
});

var responder = function(offer) {
  return offer >= 1;
};

var ANSWER = Infer({method: "enumerate"}, function() {
  var offer = sample(RandomInteger({n: 11})); // 0 to 10
  var accepted = responder(offer);
  var reward = accepted ? (10 - offer) : 0;
  factor(reward);
  return offer;
});

var responder = function(offer) {
  return offer >= 1;
};

var ANSWER = Infer({method: "enumerate"}, function() {
  var offer = uniformDraw([0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10]);
  var accepted = responder(offer);
  var reward = accepted ? (10 - offer) : 0;
  factor(reward);
  return offer;
});

var responder = function(offer) {
  return offer >= 1;
};

var ANSWER = Infer({method: "enumerate"}, function() {
  var offer = randomInteger(11); // 0 through 10
  var reward = responder(offer) ? (10 - offer) : 0;
  factor(reward);
  return offer;
});

var alpha = 2;

var responder = function(offer, alpha) {
  var p = Math.pow(offer/10, alpha);
  return flip(p);
}

var proposer = function() {
  var offer = uniformDraw([0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10]);
  var accepted = responder(offer, alpha);
  var proposerReward = accepted ? (10 - offer) : 0;
  factor(proposerReward);
  return offer;
}

var ANSWER = Infer({method: "enumerate"}, proposer);

var alpha = 2;

var responder = function(offer, alpha) {
  var p = Math.pow(offer/10, alpha);
  return flip(p);
};

var proposer = function() {
  var offer = randomInteger(11); // 0..10
  var accepted = responder(offer, alpha);
  var proposerReward = accepted ? (10 - offer) : 0;
  factor(proposerReward);
  return offer;
};

var ANSWER = Infer({method: 'enumerate'}, proposer);

var alpha = 2;

var responder = function(offer, alpha) {
  var p = Math.pow(offer/10, alpha);
  return flip(p);
};

var model = function() {
  var offer = uniformDraw([0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10]);
  
  var accepts = responder(offer, alpha);
  
  var proposerReward = accepts ? (10 - offer) : 0;
  
  factor(proposerReward);
  
  return offer;
};

var ANSWER = Infer({method: 'enumerate'}, model);

var alpha = 2;

var responder = function(offer, alpha) {
  var p = Math.pow(offer/10, alpha);
  return flip(p);
};

var model = function() {
  var offer = randomInteger(11); // offers 0..10
  var accepted = responder(offer, alpha);
  var proposerReward = accepted ? (10 - offer) : 0;
  factor(proposerReward); // factor on the proposer's reward
  return offer;
};

var ANSWER = Infer({method: 'enumerate'}, model);

var alpha = 2;

var responder = function(offer, alpha) {
  var p = Math.pow(offer / 10, alpha);
  return flip(p);
};

var model = function() {
  var offer = randomInteger(11); // 0..10
  var accepted = responder(offer, alpha);
  var reward = accepted ? (10 - offer) : 0;
  factor(reward);
  return offer;
};

var ANSWER = Infer({method: 'enumerate'}, model);

var alpha = 2;

var responder = function(offer, alpha) {
  var p = Math.pow(offer / 10, alpha);
  return flip(p);
};

var proposerModel = function() {
  var offer = randomInteger(11); // 0, 1, ..., 10
  var accepted = responder(offer, alpha);
  var reward = accepted ? (10 - offer) : 0;
  factor(reward);
  return offer;
};

var ANSWER = Infer({method: 'enumerate'}, proposerModel);

var alpha = 2;

var responder = function(offer, alpha) {
  var p = Math.pow(offer / 10, alpha);
  return flip(p);
};

var model = function() {
  var offer = randomInteger(11);   // 0, 1, ..., 10
  var accepted = responder(offer, alpha);
  var reward = accepted ? (10 - offer) : 0;
  factor(reward);
  return offer;
};

var ANSWER = Infer({method: 'enumerate'}, model);

Timeout after 60s

var model = function() {
  // Prior over alpha: uniform on [0.5, 5]
  var alpha = uniform(0.5, 5);
  
  // Proposer offers $2
  var offer = 2;
  
  // Probability that responder accepts given alpha
  var acceptProb = Math.pow(offer / 10, alpha);
  
  // Responder rejected the offer
  // So we observe that acceptance did NOT happen
  observe(Bernoulli({p: acceptProb}), 0);
  
  return alpha;
};

var ANSWER = Infer({method: "MCMC", samples: 50000}, model);

var model = function() {
  // Prior over alpha: uniform on [0.5, 5]
  var alpha = uniform(0.5, 5);
  
  // Proposer offers $2
  var offer = 2;
  
  // Responder accepts with probability (offer/10)^alpha
  var acceptProb = Math.pow(offer / 10, alpha);
  
  // Responder rejected, so we observe acceptance = false
  var accepted = flip(acceptProb);
  observe(Bernoulli({p: acceptProb}), false);
  
  return alpha;
};

var ANSWER = Infer({method: 'MCMC', samples: 50000}, model);

Timeout after 60s

var model = function() {
  // Prior: alpha uniformly distributed on [0.5, 5]
  var alpha = uniform(0.5, 5);
  
  // Proposer's offer
  var offer = 2;
  
  // Responder accepts with probability (offer/10)^alpha
  var acceptProb = Math.pow(offer / 10, alpha);
  
  // Observe: responder rejected (Bernoulli outcome 0 = did not accept)
  observe(Bernoulli({p: acceptProb}), 0);
  
  return alpha;
};

var ANSWER = Infer({method: 'MCMC', samples: 50000}, model);

Timeout after 60s

var model = function() {
  // Prior: alpha is uniformly distributed on [0.5, 5]
  var alpha = uniform(0.5, 5);
  
  // Proposer offers $2
  var offer = 2;
  
  // Responder accepts with probability (offer/10)^alpha
  var acceptProb = Math.pow(offer / 10, alpha);
  
  // Observe that responder rejected (0 = reject, 1 = accept)
  observe(Bernoulli({p: acceptProb}), 0);
  
  return alpha;
};

var ANSWER = Infer({method: 'MCMC', samples: 50000}, model);

var model = function() {
  // Sample alpha uniformly from [0.5, 5]
  var alpha = uniform(0.5, 5);
  
  // The offer is $2 out of $10
  var offer = 2;
  var total = 10;
  
  // Probability of acceptance: (offer/total)^alpha
  var pAccept = Math.pow(offer / total, alpha);
  
  // The responder rejected (observe rejection)
  observe(Bernoulli({p: pAccept}), false);
  
  return alpha;
};

var ANSWER = Infer({method: 'MCMC', samples: 50000}, model);

var model = function() {
  // Prior: alpha ~ Uniform(0.5, 5)
  var alpha = uniform(0.5, 5);

  // Acceptance probability given offer of $2 out of $10
  var offer = 2;
  var acceptProb = Math.pow(offer / 10, alpha);

  // The responder rejected (observed = false)
  observe(Bernoulli({ p: acceptProb }), false);

  return alpha;
};

var ANSWER = Infer({ method: 'MCMC', samples: 50000, burn: 5000 }, model);

var model = function() {
  // Prior: alpha ~ Uniform(0.5, 5)
  var alpha = uniform(0.5, 5);

  // Acceptance probability under the responder's rule
  var offer = 2;
  var total = 10;
  var acceptProb = Math.pow(offer / total, alpha);

  // The responder rejected the offer -> observe false
  observe(Bernoulli({p: acceptProb}), false);

  return alpha;
};

var ANSWER = Infer({method: 'MCMC', samples: 50000}, model);

// Stage 1: Infer posterior over alpha given round 1 rejection
var proposer1 = Infer({method: "MCMC", samples: 50000}, function() {
  var alpha = uniform({a: 0.5, b: 5});
  
  // Round 1: offer of $2 was rejected
  var offer1 = 2;
  var acceptProb1 = Math.pow(offer1 / 10, alpha);
  
  // Responder rejected, so we condition on rejection
  factor(Math.log(1 - acceptProb1));
  
  return alpha;
});

// Stage 2: Outer inference over round 2 offers
var ANSWER = Infer({method: "forward", samples: 1000}, function() {
  // Sample alpha from posterior
  var alpha2 = sample(proposer1);
  
  // Inner inference: find best offer for round 2
  var bestOffer = sample(Infer({method: "MCMC", samples: 5000}, function() {
    var offer2 = uniformDraw(_.range(0, 11)); // offers 0..10
    
    // Responder accepts with probability Math.pow(offer2/10, alpha2)
    var acceptProb2 = Math.pow(offer2 / 10, alpha2);
    
    // Expected payoff: if accepted, proposer gets (10 - offer2); if rejected, gets 0
    var reward2 = acceptProb2 * (10 - offer2);
    
    factor(reward2);
    
    return offer2;
  }));
  
  return bestOffer;
});

Timeout after 60s

// Stage 1: Infer posterior over alpha given round 1 rejection
var proposer1 = Infer({method: 'MCMC', samples: 50000}, function() {
  var alpha = uniform(0.5, 5);
  var offer1 = 2;
  var acceptProb = Math.pow(offer1 / 10, alpha);
  observe(Bernoulli({p: acceptProb}), 0); // 0 = rejection
  return alpha;
});

// Stage 2: Outer inference over round 2 offers
var ANSWER = Infer({method: 'forward', samples: 1000}, function() {
  var alpha2 = sample(proposer1);
  
  // Inner inference: find best offer in round 2
  var innerInference = Infer({method: 'MCMC', samples: 5000}, function() {
    var offer2 = randomInteger(11); // offers 0..10
    var acceptProb2 = Math.pow(offer2 / 10, alpha2);
    var accepted = flip(acceptProb2);
    var reward2 = accepted ? (10 - offer2) : 0;
    factor(reward2);
    return offer2;
  });
  
  // Sample one offer from the inner posterior
  var chosenOffer = sample(innerInference);
  return chosenOffer;
});

// Stage 1: Infer posterior over alpha from round 1 rejection
var proposer1 = Infer(
  {method: "MCMC", samples: 50000},
  function() {
    var alpha = uniform({a: 0.5, b: 5});
    
    // Round 1: offer = 2, responder rejected
    var acceptProb1 = Math.pow(2/10, alpha);
    var rejectProb1 = 1 - acceptProb1;
    
    factor(Math.log(rejectProb1));
    
    return alpha;
  }
);

// Helper function for responder
var responder = function(offer, alpha) {
  var acceptProb = Math.pow(offer/10, alpha);
  return flip(acceptProb);
};

// Stage 2: Proposer chooses offer in round 2
var answer = Infer(
  {method: "forward", samples: 1000},
  function() {
    var alpha2 = sample(proposer1);
    
    // Inner Infer: find best offer for this alpha2
    var offer2Dist = Infer(
      {method: "MCMC", samples: 5000},
      function() {
        var offer2 = uniformDraw(_.range(0, 11));
        
        var accepted = responder(offer2, alpha2);
        var reward2 = accepted ? (10 - offer2) : 0;
        
        factor(reward2);
        
        return offer2;
      }
    );
    
    return sample(offer2Dist);
  }
);

var ANSWER = answer;

// Stage 1: Infer posterior over alpha given round 1 rejection
var proposer1 = Infer({method: 'MCMC', samples: 50000}, function() {
  var alpha = uniform(0.5, 5);
  
  // Round 1: offer of $2 was rejected
  var offer1 = 2;
  var acceptProb1 = Math.pow(offer1 / 10, alpha);
  var rejectProb1 = 1 - acceptProb1;
  
  // Observe the rejection
  factor(Math.log(rejectProb1));
  
  return alpha;
});

// Stage 2: Outer forward inference over round 2 offers
var ANSWER = Infer({method: 'forward', samples: 1000}, function() {
  var alpha2 = sample(proposer1);
  
  // Inner MCMC inference to find best offer given alpha2
  var offerPosterior = Infer({method: 'MCMC', samples: 5000}, function() {
    var offer2 = randomInteger(11); // offers 0-10
    
    // Responder's acceptance probability
    var acceptProb2 = Math.pow(offer2 / 10, alpha2);
    
    // Simulate responder's acceptance
    var responderAccepts = flip(acceptProb2);
    
    // Proposer's payoff
    var reward2 = responderAccepts ? (10 - offer2) : 0;
    
    // Factor by reward to bias toward high-payoff offers
    factor(reward2);
    
    return offer2;
  });
  
  // Sample one round-2 offer from the posterior
  var chosenOffer = sample(offerPosterior);
  return chosenOffer;
});

// Responder accepts with probability Math.pow(offer/10, alpha)
var responder = function(offer, alpha) {
  return flip(Math.pow(offer / 10, alpha));
};

// Stage 1: Infer posterior over alpha given round 1 offer of $2 was rejected
var proposer1 = Infer({method: 'MCMC', samples: 50000}, function() {
  var alpha = uniform(0.5, 5);
  var accepted = flip(Math.pow(2 / 10, alpha));
  condition(!accepted);
  return alpha;
});

// Stage 2: Outer Infer samples alpha2 from proposer1, then inner Infer over offers
var ANSWER = Infer({method: 'forward', samples: 1000}, function() {
  var alpha2 = sample(proposer1);
  
  var innerPosterior = Infer({method: 'MCMC', samples: 5000}, function() {
    var offer2 = randomInteger(11); // 0..10
    var accepted = responder(offer2, alpha2);
    var reward2 = accepted ? (10 - offer2) : 0;
    factor(reward2);
    return offer2;
  });
  
  return sample(innerPosterior);
});

var responder = function(offer, alpha) {
  var acceptProb = Math.pow(offer / 10, alpha);
  return flip(acceptProb);
};

var proposer1 = Infer({method: 'MCMC', samples: 50000}, function() {
  var alpha = uniform(0.5, 5);
  var acceptProb = Math.pow(2 / 10, alpha);
  observe(Bernoulli({p: acceptProb}), false);
  return alpha;
});

var ANSWER = Infer({method: 'forward', samples: 1000}, function() {
  var alpha2 = sample(proposer1);

  var innerPosterior = Infer({method: 'MCMC', samples: 5000}, function() {
    var offer2 = randomInteger(11);
    var accepted = responder(offer2, alpha2);
    var reward2 = accepted ? (10 - offer2) : 0;
    factor(reward2);
    return offer2;
  });

  return sample(innerPosterior);
});

// Step 1: Posterior over alpha given that offer=$2 was rejected
var proposer1 = Infer({method: 'MCMC', samples: 50000}, function() {
  var alpha = uniform(0.5, 5);
  var acceptProb = Math.pow(2 / 10, alpha);
  observe(Bernoulli({p: acceptProb}), false);
  return alpha;
});

// Step 2: Outer forward inference over the chosen round-2 offer
var ANSWER = Infer({method: 'forward', samples: 1000}, function() {
  // Draw alpha from updated posterior
  var alpha2 = sample(proposer1);

  // Inner MCMC over offers 0..10, weighted by expected reward
  var innerDist = Infer({method: 'MCMC', samples: 5000}, function() {
    var offer2 = randomInteger(11); // integers 0..10
    var acceptProb2 = Math.pow(offer2 / 10, alpha2);
    var accepted = flip(acceptProb2);
    var reward2 = accepted ? (10 - offer2) : 0;
    factor(reward2);
    return offer2;
  });

  // Sample one round-2 offer from the inner posterior
  return sample(innerDist);
});

Error: Line 40: Did you mean var yearsInJail = ?

var lenient = 6;

var model = function() {
  // The other thief's decision (uniform random)
  var otherRats = flip(0.5);
  
  // The focal thief's decision
  var iRat = flip(0.5);
  
  // Determine years in jail for the focal thief
  var yearsInJail;
  if (iRat && otherRats) {
    // Both confess: both get lenient sentence
    yearsInJail = lenient;
  } else if (iRat && !otherRats) {
    // I confess, other doesn't: I get lenient, other gets 10
    yearsInJail = lenient;
  } else if (!iRat && otherRats) {
    // I don't confess, other does: I get 10, other gets lenient
    yearsInJail = 10;
  } else {
    // Neither confesses: both go free
    yearsInJail = 0;
  }
  
  // Calculate percent years of freedom and apply factor
  var percentYearsFreedom = (10 - yearsInJail) / 10;
  factor(percentYearsFreedom);
  
  return iRat;
};

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

var lenient = 6;

var model = function() {
  // The other thief's decision: flip uniformly
  var otherRats = flip(0.5);
  
  // The focal thief's decision: we want to infer this
  var focalRats = flip(0.5);
  
  // Determine sentences based on decisions
  var focalYears = (function() {
    if (focalRats && otherRats) {
      // Both confess: both get lenient sentence
      return lenient;
    } else if (focalRats && !otherRats) {
      // Focal confesses, other doesn't: focal gets lenient, other gets 10
      return lenient;
    } else if (!focalRats && otherRats) {
      // Focal doesn't confess, other does: focal gets 10, other gets lenient
      return 10;
    } else {
      // Neither confesses: both go free
      return 0;
    }
  })();
  
  // Calculate percent years of freedom and factor it in
  var percentYearsFreedom = (10 - focalYears) / 10;
  factor(percentYearsFreedom);
  
  return focalRats;
};

var ANSWER = Infer({method: 'enumerate'}, model);

Error: Line 38: Did you mean var focalSentence = ?

var model = function() {
  // The other thief flips uniformly to decide whether to rat
  var otherRats = flip(0.5);
  
  // The focal thief's decision (what we want the posterior over)
  var focalRats = flip(0.5);
  
  // Determine the focal thief's sentence based on both decisions
  var focalSentence;
  if (focalRats) {
    // If focal thief confesses, gets lenient sentence
    focalSentence = 6;
  } else {
    // If focal thief doesn't confess
    if (otherRats) {
      // Other thief rats, focal gets the harsh sentence
      focalSentence = 10;
    } else {
      // Neither confesses, both go free
      focalSentence = 0;
    }
  }
  
  // Calculate percent years freedom utility
  var percentYearsFreedom = (10 - focalSentence) / 10;
  
  // Weight by utility
  factor(percentYearsFreedom);
  
  return focalRats;
};

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

var model = function() {
  var focal_rats = flip(0.5);
  var other_rats = flip(0.5);
  
  var years_in_jail = focal_rats ? 6 : (other_rats ? 10 : 0);
  var percentYearsFreedom = (10 - years_in_jail) / 10;
  
  factor(percentYearsFreedom);
  
  return focal_rats;
};

var ANSWER = Infer({method: 'MCMC', samples: 10000}, model);

var model = function() {
  // Focal thief's decision
  var focalRats = flip(0.5);
  
  // Other thief flips uniformly
  var otherRats = flip(0.5);
  
  var lenient = 6;
  
  // Determine years in jail for focal thief
  var years = focalRats ? lenient : (otherRats ? 10 : 0);
  
  // percentYearsFreedom = (10 - years) / 10
  var percentYearsFreedom = (10 - years) / 10;
  
  factor(percentYearsFreedom);
  
  return focalRats ? "rat" : "silent";
};

var ANSWER = Infer({method: 'enumerate'}, model);

var lenient = 6;

var model = function() {
  // Focal thief decides whether to rat (uniform prior)
  var ratDecision = flip(0.5);

  // Other thief flips uniformly to decide whether to rat
  var otherRats = flip(0.5);

  // Compute years in jail for focal thief
  var years = ratDecision
    ? lenient                   // confessed → lenient (6 yrs) regardless of other
    : (otherRats ? 10 : 0);    // didn't confess: 10 if other did, 0 if neither did

  // Score by percentage of freedom (higher is better)
  var percentYearsFreedom = (10 - years) / 10;
  factor(percentYearsFreedom);

  return ratDecision ? "rat" : "stay_silent";
};

var ANSWER = Infer({method: 'enumerate'}, model);

var model = function() {
  var lenient = 6;

  // Focal thief's decision (what we're inferring)
  var focalRats = flip(0.5);

  // Other thief flips uniformly
  var otherRats = flip(0.5);

  // Compute years in jail for the focal thief
  var years = focalRats
    ? lenient                    // confessing always yields lenient sentence
    : (otherRats ? 10 : 0);     // not confessing: 10 if other confesses, 0 if neither does

  // Utility: percentage of years free (out of 10)
  var percentYearsFreedom = (10 - years) / 10;

  factor(percentYearsFreedom);

  return focalRats;
};

var ANSWER = Infer({method: 'enumerate'}, model);

// Define the world
var objects = [
  {shape: "square", color: "blue"},
  {shape: "circle", color: "blue"},
  {shape: "square", color: "green"}
];

var utterances = ['blue', 'green', 'square', 'circle'];

// Truth function
var truth = function(utterance, obj) {
  if (utterance === 'blue') return obj.color === 'blue';
  if (utterance === 'green') return obj.color === 'green';
  if (utterance === 'square') return obj.shape === 'square';
  if (utterance === 'circle') return obj.shape === 'circle';
  return true;
};

// Literal listener
var literalListener = function(utterance) {
  return Infer({model: function() {
    var obj = uniformDraw(objects);
    condition(truth(utterance, obj));
    return obj;
  }});
};

// Speaker
var speaker = function(obj, alpha) {
  return Infer({model: function() {
    var utterance = uniformDraw(utterances);
    var listener = literalListener(utterance);
    factor(alpha * listener.score(obj));
    return utterance;
  }});
};

// Pragmatic listener
var pragmaticListener = function(utterance, alpha) {
  return Infer({model: function() {
    var obj = uniformDraw(objects);
    var sp = speaker(obj, alpha);
    observe(sp, utterance);
    return obj;
  }});
};

// Compute pragmatic listener for 'blue' at different alphas
var alpha_001 = pragmaticListener('blue', 0.01);
var alpha_1 = pragmaticListener('blue', 1);
var alpha_4 = pragmaticListener('blue', 4);
var alpha_10 = pragmaticListener('blue', 10);

var ANSWER = {
  alpha_001: alpha_001,
  alpha_1: alpha_1,
  alpha_4: alpha_4,
  alpha_10: alpha_10
};

// Define the world
var objects = [
  {shape: "square", color: "blue"},
  {shape: "circle", color: "blue"},
  {shape: "square", color: "green"}
];

var utterances = ['blue', 'green', 'square', 'circle'];

// Truth function: utterance is true if it matches the object's attribute
var truth = function(utterance, obj) {
  if (utterance === 'blue' || utterance === 'green') {
    return utterance === obj.color;
  } else if (utterance === 'square' || utterance === 'circle') {
    return utterance === obj.shape;
  }
  return false;
};

// Literal listener: infer over objects given utterance, conditioned on truth
var literalListener = function(utterance) {
  return Infer({method: 'enumerate'}, function() {
    var obj = uniformDraw(objects);
    condition(truth(utterance, obj));
    return obj;
  });
};

// Speaker: choose utterance, factor by how well it communicates the object
var speaker = function(obj, alpha) {
  return Infer({method: 'enumerate'}, function() {
    var utterance = uniformDraw(utterances);
    var listener = literalListener(utterance);
    factor(alpha * listener.score(obj));
    return utterance;
  });
};

// Pragmatic listener: infer over objects given utterance and speaker rationality
var pragmaticListener = function(utterance, alpha) {
  return Infer({method: 'enumerate'}, function() {
    var obj = uniformDraw(objects);
    var speakerDist = speaker(obj, alpha);
    observe(speakerDist, utterance);
    return obj;
  });
};

// Compute pragmatic listener for 'blue' at different alpha values
var result_001 = pragmaticListener('blue', 0.01);
var result_1 = pragmaticListener('blue', 1);
var result_4 = pragmaticListener('blue', 4);
var result_10 = pragmaticListener('blue', 10);

var ANSWER = {
  alpha_001: result_001,
  alpha_1: result_1,
  alpha_4: result_4,
  alpha_10: result_10
};

// Objects in the world
var objects = [
  {shape: "square", color: "blue"},
  {shape: "circle", color: "blue"},
  {shape: "square", color: "green"}
];

// Possible utterances
var utterances = ['blue', 'green', 'square', 'circle'];

// Truth function: utterance is true iff it matches the relevant attribute
var meaning = function(utterance, obj) {
  if (utterance === 'blue' || utterance === 'green') {
    return utterance === obj.color;
  } else if (utterance === 'square' || utterance === 'circle') {
    return utterance === obj.shape;
  }
  return false;
};

// Literal listener: infer objects conditional on utterance being true
var literalListener = function(utterance) {
  return Infer({method: 'enumerate'}, function() {
    var obj = uniformDraw(objects);
    condition(meaning(utterance, obj));
    return obj;
  });
};

// Speaker: choose utterance, factor by how well literal listener would identify obj
var speaker = function(obj, alpha) {
  return Infer({method: 'enumerate'}, function() {
    var utterance = uniformDraw(utterances);
    var ll = literalListener(utterance);
    factor(alpha * ll.score(obj));
    return utterance;
  });
};

// Pragmatic listener: infer objects conditional on speaker having said utterance
var pragmaticListener = function(utterance, alpha) {
  return Infer({method: 'enumerate'}, function() {
    var obj = uniformDraw(objects);
    var s = speaker(obj, alpha);
    factor(s.score(utterance));
    return obj;
  });
};

var ANSWER = {
  alpha_001: pragmaticListener('blue', 0.01),
  alpha_1: pragmaticListener('blue', 1),
  alpha_4: pragmaticListener('blue', 4),
  alpha_10: pragmaticListener('blue', 10)
};

var objects = [
  {shape: "square", color: "blue"},
  {shape: "circle", color: "blue"},
  {shape: "square", color: "green"}
];

var utterances = ['blue', 'green', 'square', 'circle'];

var truth = function(utterance, object) {
  return (utterance === 'blue' && object.color === 'blue') ||
         (utterance === 'green' && object.color === 'green') ||
         (utterance === 'square' && object.shape === 'square') ||
         (utterance === 'circle' && object.shape === 'circle');
};

var meaningPrior = function() {
  return categorical({vs: objects});
};

var literalListener = function(utterance) {
  return Infer({method: 'enumerate'}, function() {
    var obj = meaningPrior();
    condition(truth(utterance, obj));
    return obj;
  });
};

var speaker = function(obj, alpha) {
  return Infer({method: 'enumerate'}, function() {
    var utterance = categorical({vs: utterances});
    var listener = literalListener(utterance);
    factor(alpha * listener.score(obj));
    return utterance;
  });
};

var pragmaticListener = function(utterance, alpha) {
  return Infer({method: 'enumerate'}, function() {
    var obj = meaningPrior();
    var speakerDist = speaker(obj, alpha);
    observe(speakerDist, utterance);
    return obj;
  });
};

var ANSWER = {
  alpha_001: pragmaticListener('blue', 0.01),
  alpha_1: pragmaticListener('blue', 1),
  alpha_4: pragmaticListener('blue', 4),
  alpha_10: pragmaticListener('blue', 10)
};

var objects = [
  {shape: "square", color: "blue"},
  {shape: "circle", color: "blue"},
  {shape: "square", color: "green"}
];

var utterances = ['blue', 'green', 'square', 'circle'];

var meaningPrior = function() {
  return uniformDraw(objects);
};

var truthFn = function(utterance, obj) {
  if (utterance === 'blue' || utterance === 'green') {
    return obj.color === utterance;
  } else if (utterance === 'square' || utterance === 'circle') {
    return obj.shape === utterance;
  } else {
    return true;
  }
};

var literalListener = function(utterance) {
  return Infer({method: 'enumerate'}, function() {
    var obj = meaningPrior();
    condition(truthFn(utterance, obj));
    return obj;
  });
};

var speaker = function(obj, alpha) {
  return Infer({method: 'enumerate'}, function() {
    var utterance = uniformDraw(utterances);
    factor(alpha * literalListener(utterance).score(obj));
    return utterance;
  });
};

var pragmaticListener = function(utterance, alpha) {
  return Infer({method: 'enumerate'}, function() {
    var obj = meaningPrior();
    observe(speaker(obj, alpha), utterance);
    return obj;
  });
};

var ANSWER = {
  alpha_001: pragmaticListener('blue', 0.01),
  alpha_1: pragmaticListener('blue', 1),
  alpha_4: pragmaticListener('blue', 4),
  alpha_10: pragmaticListener('blue', 10)
};

var objects = [
  {shape: "square", color: "blue"},
  {shape: "circle", color: "blue"},
  {shape: "square", color: "green"}
];

var utterances = ['blue', 'green', 'square', 'circle'];

var meaningPrior = function() {
  return uniformDraw(objects);
};

var utterancePrior = function() {
  return uniformDraw(utterances);
};

var meaning = function(utterance, obj) {
  if (utterance === "blue" || utterance === "green") {
    return obj.color === utterance;
  } else if (utterance === "square" || utterance === "circle") {
    return obj.shape === utterance;
  } else {
    return true;
  }
};

var literalListener = function(utterance) {
  return Infer({method: 'enumerate'}, function() {
    var obj = meaningPrior();
    condition(meaning(utterance, obj));
    return obj;
  });
};

var speaker = function(obj, alpha) {
  return Infer({method: 'enumerate'}, function() {
    var utterance = utterancePrior();
    factor(alpha * literalListener(utterance).score(obj));
    return utterance;
  });
};

var pragmaticListener = function(utterance, alpha) {
  return Infer({method: 'enumerate'}, function() {
    var obj = meaningPrior();
    observe(speaker(obj, alpha), utterance);
    return obj;
  });
};

var ANSWER = {
  alpha_001: pragmaticListener('blue', 0.01),
  alpha_1:   pragmaticListener('blue', 1),
  alpha_4:   pragmaticListener('blue', 4),
  alpha_10:  pragmaticListener('blue', 10)
};

var objects = [
  {shape: "square", color: "blue"},
  {shape: "circle", color: "blue"},
  {shape: "square", color: "green"}
];

var utterances = ['blue', 'green', 'square', 'circle'];

var meaningPrior = function() {
  return uniformDraw(objects);
};

var meaning = function(utterance, obj) {
  if (utterance === 'blue' || utterance === 'green') {
    return obj.color === utterance;
  } else if (utterance === 'square' || utterance === 'circle') {
    return obj.shape === utterance;
  } else {
    return true;
  }
};

var literalListener = mem(function(utterance) {
  return Infer({method: 'enumerate'}, function() {
    var obj = meaningPrior();
    condition(meaning(utterance, obj));
    return obj;
  });
});

var speaker = mem(function(obj, alpha) {
  return Infer({method: 'enumerate'}, function() {
    var utterance = uniformDraw(utterances);
    factor(alpha * literalListener(utterance).score(obj));
    return utterance;
  });
});

var pragmaticListener = mem(function(utterance, alpha) {
  return Infer({method: 'enumerate'}, function() {
    var obj = meaningPrior();
    observe(speaker(obj, alpha), utterance);
    return obj;
  });
});

var ANSWER = {
  alpha_001: pragmaticListener('blue', 0.01),
  alpha_1:   pragmaticListener('blue', 1),
  alpha_4:   pragmaticListener('blue', 4),
  alpha_10:  pragmaticListener('blue', 10)
};

// Define the world
var objects = [
  {shape: "square", color: "blue"},
  {shape: "circle", color: "blue"},
  {shape: "square", color: "green"}
];

var meaningPrior = function() {
  uniformDraw(objects);
};

var utterances = ['blue', 'green', 'square', 'circle'];

// Truth function: utterance is true if it matches the object's attribute
var meaning = function(utterance, obj) {
  return (utterance === obj.color) || (utterance === obj.shape);
};

// Level 0: Literal Listener
var literalListener = function(utterance) {
  Infer({method: "enumerate"}, function() {
    var obj = meaningPrior();
    condition(meaning(utterance, obj));
    return obj;
  });
};

// Level 1: Speaker (S1)
var speaker = function(obj) {
  Infer({method: "enumerate"}, function() {
    var utterance = uniformDraw(utterances);
    var alpha = 1;
    factor(alpha * literalListener(utterance).score(obj));
    return utterance;
  });
};

// Level 1: Pragmatic Listener (L1)
var pragmaticListener = function(utterance) {
  Infer({method: "enumerate"}, function() {
    var obj = meaningPrior();
    observe(speaker(obj), utterance);
    return obj;
  });
};

// Level 2: Speaker (S2)
var speaker2 = function(obj) {
  Infer({method: "enumerate"}, function() {
    var utterance = uniformDraw(utterances);
    var alpha = 1;
    factor(alpha * pragmaticListener(utterance).score(obj));
    return utterance;
  });
};

// Level 2: Listener (L2)
var listener3 = function(utterance) {
  Infer({method: "enumerate"}, function() {
    var obj = meaningPrior();
    observe(speaker2(obj), utterance);
    return obj;
  });
};

// Compute L1 and L2 for 'blue'
var L1 = pragmaticListener('blue');
var L2 = listener3('blue');

var ANSWER = {L1: L1, L2: L2};

// Define the world objects
var objects = [
  {shape: "square", color: "blue"},
  {shape: "circle", color: "blue"},
  {shape: "square", color: "green"}
];

// Uniform prior over objects
var meaningPrior = function() {
  return uniformDraw(objects);
};

// Truth function: utterance is true if it matches the object's attribute
var meaning = function(utterance, obj) {
  return (utterance === obj.color) || (utterance === obj.shape);
};

// Level 0: Literal Listener
var literalListener = mem(function(utterance) {
  return Infer({method: 'enumerate'}, function() {
    var obj = meaningPrior();
    condition(meaning(utterance, obj));
    return obj;
  });
});

// Level 1: Speaker (pragmatic)
var alpha = 1;
var speaker = mem(function(obj) {
  return Infer({method: 'enumerate'}, function() {
    var utterance = uniformDraw(['blue', 'green', 'square', 'circle']);
    factor(alpha * literalListener(utterance).score(obj));
    return utterance;
  });
});

// Level 1: Pragmatic Listener (L1)
var pragmaticListener = mem(function(utterance) {
  return Infer({method: 'enumerate'}, function() {
    var obj = meaningPrior();
    observe(speaker(obj), utterance);
    return obj;
  });
});

// Level 2: Speaker2 (pragmatic, reasoning about L1)
var speaker2 = mem(function(obj) {
  return Infer({method: 'enumerate'}, function() {
    var utterance = uniformDraw(['blue', 'green', 'square', 'circle']);
    factor(alpha * pragmaticListener(utterance).score(obj));
    return utterance;
  });
});

// Level 2: Listener3 (L2, reasoning about speaker2)
var listener3 = mem(function(utterance) {
  return Infer({method: 'enumerate'}, function() {
    var obj = meaningPrior();
    observe(speaker2(obj), utterance);
    return obj;
  });
});

// Compute L1 and L2 for utterance 'blue'
var L1 = pragmaticListener('blue');
var L2 = listener3('blue');

var ANSWER = {L1: L1, L2: L2};

var objects = [
  {shape: "square", color: "blue"},
  {shape: "circle", color: "blue"},
  {shape: "square", color: "green"}
];

var utterances = ['blue', 'green', 'square', 'circle'];

var meaning = function(utterance, obj) {
  if (utterance === 'blue') return obj.color === 'blue';
  if (utterance === 'green') return obj.color === 'green';
  if (utterance === 'square') return obj.shape === 'square';
  if (utterance === 'circle') return obj.shape === 'circle';
  return false;
};

var meaningPrior = function() {
  return uniformDraw(objects);
};

var alpha = 1;

// Level 1: Literal Listener
var literalListener = function(utterance) {
  return Infer({method: 'enumerate'}, function() {
    var obj = meaningPrior();
    condition(meaning(utterance, obj));
    return obj;
  });
};

// Level 1: Speaker
var speaker = function(obj) {
  return Infer({method: 'enumerate'}, function() {
    var utterance = uniformDraw(utterances);
    factor(alpha * literalListener(utterance).score(obj));
    return utterance;
  });
};

// Level 1: Pragmatic Listener
var pragmaticListener = function(utterance) {
  return Infer({method: 'enumerate'}, function() {
    var obj = meaningPrior();
    observe(speaker(obj), utterance);
    return obj;
  });
};

// Level 2: Speaker 2
var speaker2 = function(obj) {
  return Infer({method: 'enumerate'}, function() {
    var utterance = uniformDraw(utterances);
    factor(alpha * pragmaticListener(utterance).score(obj));
    return utterance;
  });
};

// Level 2: Listener 3
var listener3 = function(utterance) {
  return Infer({method: 'enumerate'}, function() {
    var obj = meaningPrior();
    observe(speaker2(obj), utterance);
    return obj;
  });
};

var L1 = pragmaticListener('blue');
var L2 = listener3('blue');

var ANSWER = {L1: L1, L2: L2};

var objects = [
  {shape: "square", color: "blue"},
  {shape: "circle", color: "blue"},
  {shape: "square", color: "green"}
];

var utterances = ['blue', 'green', 'square', 'circle'];

var meaningPrior = function() {
  return objects[randomInteger(objects.length)];
};

var meaning = function(utterance, obj) {
  if (utterance === 'blue') return obj.color === 'blue';
  if (utterance === 'green') return obj.color === 'green';
  if (utterance === 'square') return obj.shape === 'square';
  if (utterance === 'circle') return obj.shape === 'circle';
  return false;
};

var alpha = 1;

var literalListener = mem(function(utterance) {
  return Infer({method: 'enumerate'}, function() {
    var obj = meaningPrior();
    condition(meaning(utterance, obj));
    return obj;
  });
});

var speaker = mem(function(obj) {
  return Infer({method: 'enumerate'}, function() {
    var utterance = utterances[randomInteger(utterances.length)];
    factor(alpha * literalListener(utterance).score(obj));
    return utterance;
  });
});

var pragmaticListener = mem(function(utterance) {
  return Infer({method: 'enumerate'}, function() {
    var obj = meaningPrior();
    observe(speaker(obj), utterance);
    return obj;
  });
});

var speaker2 = mem(function(obj) {
  return Infer({method: 'enumerate'}, function() {
    var utterance = utterances[randomInteger(utterances.length)];
    factor(alpha * pragmaticListener(utterance).score(obj));
    return utterance;
  });
});

var listener3 = mem(function(utterance) {
  return Infer({method: 'enumerate'}, function() {
    var obj = meaningPrior();
    observe(speaker2(obj), utterance);
    return obj;
  });
});

var L1 = pragmaticListener('blue');
var L2 = listener3('blue');

var ANSWER = {L1: L1, L2: L2};

var objects = [
  {shape: "square", color: "blue"},
  {shape: "circle", color: "blue"},
  {shape: "square", color: "green"}
];

var utterances = ['blue', 'green', 'square', 'circle'];

var meaning = function(utterance, obj) {
  if (utterance === 'blue' || utterance === 'green') {
    return obj.color === utterance;
  } else {
    return obj.shape === utterance;
  }
};

var meaningPrior = function() {
  return uniformDraw(objects);
};

var alpha = 1;

var literalListener = cache(function(utterance) {
  return Infer({method: 'enumerate'}, function() {
    var obj = meaningPrior();
    condition(meaning(utterance, obj));
    return obj;
  });
});

var speaker = cache(function(obj) {
  return Infer({method: 'enumerate'}, function() {
    var utterance = uniformDraw(utterances);
    factor(alpha * literalListener(utterance).score(obj));
    return utterance;
  });
});

var pragmaticListener = cache(function(utterance) {
  return Infer({method: 'enumerate'}, function() {
    var obj = meaningPrior();
    observe(speaker(obj), utterance);
    return obj;
  });
});

var speaker2 = cache(function(obj) {
  return Infer({method: 'enumerate'}, function() {
    var utterance = uniformDraw(utterances);
    factor(alpha * pragmaticListener(utterance).score(obj));
    return utterance;
  });
});

var listener3 = cache(function(utterance) {
  return Infer({method: 'enumerate'}, function() {
    var obj = meaningPrior();
    observe(speaker2(obj), utterance);
    return obj;
  });
});

var L1 = pragmaticListener('blue');
var L2 = listener3('blue');

var ANSWER = {L1: L1, L2: L2};

var objects = [
  {shape: "square", color: "blue"},
  {shape: "circle", color: "blue"},
  {shape: "square", color: "green"}
];

var utterances = ['blue', 'green', 'square', 'circle'];
var alpha = 1;

var meaning = function(utterance, obj) {
  if (utterance === 'blue' || utterance === 'green') {
    return obj.color === utterance;
  } else {
    return obj.shape === utterance;
  }
};

var meaningPrior = function() {
  return uniformDraw(objects);
};

// Level-1 stack
var literalListener = cache(function(utterance) {
  return Infer({method: 'enumerate'}, function() {
    var obj = meaningPrior();
    condition(meaning(utterance, obj));
    return obj;
  });
});

var speaker = cache(function(obj) {
  return Infer({method: 'enumerate'}, function() {
    var utterance = uniformDraw(utterances);
    factor(alpha * literalListener(utterance).score(obj));
    return utterance;
  });
});

var pragmaticListener = cache(function(utterance) {
  return Infer({method: 'enumerate'}, function() {
    var obj = meaningPrior();
    observe(speaker(obj), utterance);
    return obj;
  });
});

// Level-2 stack
var speaker2 = cache(function(obj) {
  return Infer({method: 'enumerate'}, function() {
    var utterance = uniformDraw(utterances);
    factor(alpha * pragmaticListener(utterance).score(obj));
    return utterance;
  });
});

var listener3 = cache(function(utterance) {
  return Infer({method: 'enumerate'}, function() {
    var obj = meaningPrior();
    observe(speaker2(obj), utterance);
    return obj;
  });
});

var L1 = pragmaticListener('blue');
var L2 = listener3('blue');

var ANSWER = {L1: L1, L2: L2};

var objects = [
  {shape: "square", color: "blue"},
  {shape: "circle", color: "blue"},
  {shape: "square", color: "green"}
];

var utterances = ['blue', 'green', 'square', 'circle'];

var meaning = function(utterance, obj) {
  if (utterance === 'blue' || utterance === 'green') {
    return obj.color === utterance;
  } else {
    return obj.shape === utterance;
  }
};

var meaningPrior = function() {
  return uniformDraw(objects);
};

var alpha = 1;

// Level-1 stack
var literalListener = mem(function(utterance) {
  return Infer({method: 'enumerate'}, function() {
    var obj = meaningPrior();
    condition(meaning(utterance, obj));
    return obj;
  });
});

var speaker = mem(function(obj) {
  return Infer({method: 'enumerate'}, function() {
    var utterance = uniformDraw(utterances);
    factor(alpha * literalListener(utterance).score(obj));
    return utterance;
  });
});

var pragmaticListener = mem(function(utterance) {
  return Infer({method: 'enumerate'}, function() {
    var obj = meaningPrior();
    observe(speaker(obj), utterance);
    return obj;
  });
});

// Level-2 stack
var speaker2 = mem(function(obj) {
  return Infer({method: 'enumerate'}, function() {
    var utterance = uniformDraw(utterances);
    factor(alpha * pragmaticListener(utterance).score(obj));
    return utterance;
  });
});

var listener3 = mem(function(utterance) {
  return Infer({method: 'enumerate'}, function() {
    var obj = meaningPrior();
    observe(speaker2(obj), utterance);
    return obj;
  });
});

var L1 = pragmaticListener('blue');
var L2 = listener3('blue');

var ANSWER = {L1: L1, L2: L2};

var ANSWER = Infer({method:'MCMC', burn:10000, samples: 50000, onlyMAP:false}, function() {
  let vocab = ['dogs', 'cats', 'chase', 'sleep', 'stop'];
  var wordToDistribution = mem(function(word) {
    return dirichletDrift({alpha:ones([vocab.length,1]), concentration:10})
  })
  var transition = function(word) {
    return categorical({ps: wordToDistribution(word), vs: vocab})
  }
  
  var generateSentence = function(word) {
    if (word === 'stop') {
      return []
    } else {
      var nextWord = transition(word)
      return [nextWord].concat(generateSentence(nextWord))
    }
  }
  
  var sentence = ['dogs'].concat(generateSentence('dogs'))
  
  condition(sentence[0] === 'dogs' && sentence[1] === 'chase' && sentence[2] === 'cats')
  
  return transition('chase')
})

var ANSWER = Infer({method:'MCMC', burn:10000, samples: 50000, onlyMAP:false}, function() {
  var vocab = ['dogs', 'cats', 'chase', 'sleep', 'stop'];
  var wordToDistribution = mem(function(word) {
    return dirichletDrift({alpha:ones([vocab.length,1]), concentration:10});
  });
  var transition = function(word) {
    return categorical({ps: wordToDistribution(word), vs: vocab});
  };
  
  var generateSentence = function(word) {
    if (word === 'stop') {
      return [word];
    } else {
      var nextWord = transition(word);
      return [word].concat(generateSentence(nextWord));
    }
  };
  
  var sentence = generateSentence('dogs');
  observe(Categorical({vs: sentence, ps: ones([sentence.length, 1])}), 'cats');
  
  var idx_chase = _.indexOf(sentence, 'chase');
  condition(idx_chase >= 0 && idx_chase < sentence.length - 1);
  
  return transition('chase');
});

var ANSWER = Infer({method:'MCMC', burn:10000, samples: 50000, onlyMAP:false}, function() {
  let vocab = ['dogs', 'cats', 'chase', 'sleep', 'stop'];
  var wordToDistribution = mem(function(word) {
    return dirichletDrift({alpha:ones([vocab.length,1]), concentration:10})
  })
  var transition = function(word) {
    return categorical({ps: wordToDistribution(word), vs: vocab})
  }
  
  var generateSentence = function(word) {
    var nextWord = transition(word);
    if (nextWord === 'stop') {
      return [word];
    } else {
      return [word].concat(generateSentence(nextWord));
    }
  }
  
  // Generate a sentence starting from 'dogs'
  var sentence = generateSentence('dogs');
  
  // Condition on observing the sentence "dogs chase cats"
  condition(_.isEqual(sentence, ['dogs', 'chase', 'cats']));
  
  // Return the posterior distribution over transition('chase')
  return transition('chase');
});

Timeout after 60s

var ANSWER = Infer({method:'MCMC', burn:10000, samples: 50000, onlyMAP:false}, function() {
  var vocab = ['dogs', 'cats', 'chase', 'sleep', 'stop'];
  var wordToDistribution = mem(function(word) {
    return dirichletDrift({alpha: ones([vocab.length,1]), concentration:10})
  });
  var transition = mem(function(word) {
    return categorical({ps: wordToDistribution(word), vs: vocab})
  });
  
  var generateSentence = function(currentWord) {
    var nextWord = transition(currentWord);
    return (nextWord === 'stop') ? [currentWord] : [currentWord].concat(generateSentence(nextWord));
  };
  
  // Generate a sentence starting with 'dogs'
  var sentence = generateSentence('dogs');
  
  // Condition on observing the sequence "dogs" -> "chase" -> "cats"
  condition(sentence[0] === 'dogs' && sentence[1] === 'chase' && sentence[2] === 'cats');
  
  // Return the posterior distribution over what comes after 'chase'
  return transition('chase');
});

var ANSWER = Infer({method:'MCMC', burn:10000, samples: 50000, onlyMAP:false}, function() {
  var vocab = ['dogs', 'cats', 'chase', 'sleep', 'stop'];
  
  var wordToDistribution = mem(function(word) {
    return dirichletDrift({alpha: ones([vocab.length, 1]), concentration: 10});
  });
  
  var transition = function(word) {
    return categorical({ps: wordToDistribution(word), vs: vocab});
  };
  
  var generateSentence = function(currentWord, words) {
    var nextWord = transition(currentWord);
    if (nextWord === 'stop') {
      return words.concat(['stop']);
    } else {
      return generateSentence(nextWord, words.concat([nextWord]));
    }
  };
  
  var sentence = generateSentence('dogs', ['dogs']);
  
  // Condition on observing 'dogs chase cats stop'
  condition(sentence[0] === 'dogs' &&
            sentence[1] === 'chase' &&
            sentence[2] === 'cats' &&
            sentence[3] === 'stop' &&
            sentence.length === 4);
  
  return transition('chase');
});

var ANSWER = Infer({method:'MCMC', burn:10000, samples: 50000, onlyMAP:false}, function() {
  var vocab = ['dogs', 'cats', 'chase', 'sleep', 'stop'];

  var wordToDistribution = mem(function(word) {
    return dirichletDrift({alpha: ones([vocab.length, 1]), concentration: 10});
  });

  var transition = function(word) {
    return categorical({ps: wordToDistribution(word), vs: vocab});
  };

  var generateSentence = function(currentWord, wordsSoFar) {
    var nextWord = transition(currentWord);
    if (nextWord === 'stop') {
      return wordsSoFar.concat(['stop']);
    } else {
      return generateSentence(nextWord, wordsSoFar.concat([nextWord]));
    }
  };

  // Generate a sentence starting from 'dogs'
  var sentence = generateSentence('dogs', ['dogs']);

  // Condition on the observation 'dogs chase cats'
  // The sentence should contain at least ['dogs', 'chase', 'cats', ...]
  condition(sentence[0] === 'dogs');
  condition(sentence[1] === 'chase');
  condition(sentence[2] === 'cats');

  // Return the posterior over transition('chase')
  return transition('chase');
});

var ANSWER = Infer({method:'MCMC', burn:10000, samples:50000, onlyMAP:false}, function() {
  var vocab = ['dogs', 'cats', 'chase', 'sleep', 'stop'];

  var wordToDistribution = mem(function(word) {
    return dirichletDrift({alpha: ones([vocab.length, 1]), concentration: 10});
  });

  var transition = function(word) {
    return categorical({ps: wordToDistribution(word), vs: vocab});
  };

  // Recursive sentence generator: starts from `word`, emits words until 'stop'
  var generateSentence = function(word) {
    if (word === 'stop') {
      return ['stop'];
    } else {
      var next = transition(word);
      return [word].concat(generateSentence(next));
    }
  };

  // Instead of generating and comparing (slow rejection), we soft-condition by
  // observing each bigram transition in the sentence 'dogs chase cats (stop)'.
  // This directly scores the Dirichlet-drawn distributions against the data.
  var observeTransition = function(from, to) {
    observe(Categorical({ps: wordToDistribution(from), vs: vocab}), to);
  };

  // Observed sentence: dogs -> chase -> cats -> stop
  observeTransition('dogs',  'chase');
  observeTransition('chase', 'cats');
  observeTransition('cats',  'stop');

  // Return a sample from the posterior predictive next-word after 'chase'
  return transition('chase');
});

Error: cpsInnerStatement

var comparray = function(arr1, arr2) {
  return JSON.stringify(arr1) === JSON.stringify(arr2);
};

var vocab = ['dogs', 'cats', 'chase', 'sleep', 'stop'];
var vocabSize = vocab.length;

var model = function() {
  // Create transition distributions for each word
  var transitions = {};
  
  for (var i = 0; i < vocabSize; i++) {
    var word = vocab[i];
    transitions[word] = sample(dirichletDrift({alpha: ones([5, 1]), concentration: 10}));
  }
  
  // Also need transition from 'start'
  transitions['start'] = sample(dirichletDrift({alpha: ones([5, 1]), concentration: 10}));
  
  // Function to generate a sentence
  var generateSentence = function() {
    var sentence = [];
    var currentWord = 'start';
    
    while (true) {
      var nextWordDist = transitions[currentWord];
      var nextWord = categorical({ps: nextWordDist, vs: vocab});
      sentence.push(nextWord);
      
      if (nextWord === 'stop') {
        break;
      }
      currentWord = nextWord;
    }
    
    return sentence;
  };
  
  // Observe the first sentence
  var sentence1 = generateSentence();
  observe(comparray(sentence1, ['dogs', 'chase', 'cats', 'stop']), true);
  
  // Generate second sentence starting with 'dogs'
  var sentence2 = [];
  sentence2.push('dogs');
  
  var currentWord = 'dogs';
  var secondWord = categorical({ps: transitions[currentWord], vs: vocab});
  sentence2.push(secondWord);
  
  return secondWord;
};

var ANSWER = Infer({method: 'MCMC', burn: 10000, samples: 50000, onlyMAP: false}, model);

Error: cpsInnerStatement

var comparray = function(arr1, arr2) {
  return JSON.stringify(arr1) === JSON.stringify(arr2);
};

var vocab = ['dogs', 'cats', 'chase', 'sleep', 'stop'];
var observedSentence = ['dogs', 'chase', 'cats', 'stop'];

var model = function() {
  // Draw transition distributions for each word
  var transitionDists = {};
  map(function(word) {
    transitionDists[word] = dirichletDrift({
      alpha: ones([5, 1]),
      concentration: 10
    });
  }, vocab);
  
  // Also need transition distribution from 'start'
  transitionDists['start'] = dirichletDrift({
    alpha: ones([5, 1]),
    concentration: 10
  });
  
  // Function to get next word given previous word
  var transition = function(prevWord) {
    var probs = transitionDists[prevWord];
    var probsArray = [
      T.get(probs, 0),
      T.get(probs, 1),
      T.get(probs, 2),
      T.get(probs, 3),
      T.get(probs, 4)
    ];
    return categorical({vs: vocab, ps: probsArray});
  };
  
  // Generate a sentence
  var generateSentence = function() {
    var sentence = [];
    var prevWord = 'start';
    var done = false;
    var maxSteps = 100;
    var step = 0;
    
    while (!done && step < maxSteps) {
      var nextWord = transition(prevWord);
      sentence.push(nextWord);
      if (nextWord === 'stop') {
        done = true;
      }
      prevWord = nextWord;
      step = step + 1;
    }
    
    return sentence;
  };
  
  // Observe the first sentence
  var sentence1 = generateSentence();
  observe(Categorical({vs: [true, false], ps: [1, 0]}), 
          comparray(sentence1, observedSentence));
  
  // Generate second sentence starting with 'dogs'
  var sentence2 = [];
  sentence2.push('dogs');
  var prevWord = 'dogs';
  var done = false;
  var maxSteps = 100;
  var step = 0;
  
  while (!done && step < maxSteps) {
    var nextWord = transition(prevWord);
    sentence2.push(nextWord);
    if (nextWord === 'stop') {
      done = true;
    }
    prevWord = nextWord;
    step = step + 1;
  }
  
  // Return the second word of the second sentence
  return sentence2[1];
};

var ANSWER = Infer({
  method: 'MCMC',
  burn: 10000,
  samples: 50000,
  onlyMAP: false
}, model);

Error: cpsInnerStatement

var vocabulary = ['dogs', 'cats', 'chase', 'sleep', 'stop'];

var comparray = function(arr1, arr2) {
  return JSON.stringify(arr1) === JSON.stringify(arr2);
};

var model = function() {
  // Draw transition distributions for each word
  var transitions = {};
  
  // Transition from 'start'
  transitions['start'] = dirichletDrift({alpha: ones([5, 1]), concentration: 10});
  
  // Transition from each word in vocabulary
  vocabulary.forEach(function(word) {
    transitions[word] = dirichletDrift({alpha: ones([5, 1]), concentration: 10});
  });
  
  // Function to get next word given previous word
  var transition = function(prevWord) {
    var dist = transitions[prevWord];
    return categorical({ps: dist, vs: vocabulary});
  };
  
  // Function to generate a sentence
  var generateSentence = function() {
    var sentence = [];
    var currentWord = 'start';
    while (true) {
      currentWord = transition(currentWord);
      sentence.push(currentWord);
      if (currentWord === 'stop') {
        break;
      }
    }
    return sentence;
  };
  
  // Observe the sentence
  var observedSentence = ['dogs', 'chase', 'cats', 'stop'];
  var generatedSentence = generateSentence();
  condition(comparray(generatedSentence, observedSentence));
  
  // Generate second word of new sentence starting with 'dogs'
  var secondWord = transition('dogs');
  
  return secondWord;
};

var ANSWER = Infer({method: 'MCMC', burn: 10000, samples: 50000, onlyMAP: false}, model);

var vocab = ['dogs', 'cats', 'chase', 'sleep', 'stop'];
var observedSentence = ['dogs', 'chase', 'cats', 'stop'];

var comparray = function(arr1, arr2) {
  return JSON.stringify(arr1) === JSON.stringify(arr2);
};

var model = function() {
  // Memoized transition distribution for each word
  var transitionProbs = mem(function(word) {
    var alpha = ones([5, 1]);
    return dirichletDrift({alpha: alpha, concentration: 10});
  });
  
  // Observe the sentence by conditioning on each transition
  // 'dogs' comes after 'start'
  observe(Categorical({vs: vocab, ps: transitionProbs('start')}), observedSentence[0]);
  // 'chase' comes after 'dogs'
  observe(Categorical({vs: vocab, ps: transitionProbs('dogs')}), observedSentence[1]);
  // 'cats' comes after 'chase'
  observe(Categorical({vs: vocab, ps: transitionProbs('chase')}), observedSentence[2]);
  // 'stop' comes after 'cats'
  observe(Categorical({vs: vocab, ps: transitionProbs('cats')}), observedSentence[3]);
  
  // In a new sentence, first word is 'dogs', sample the second word
  var secondWord = categorical({vs: vocab, ps: transitionProbs('dogs')});
  
  return secondWord;
};

var ANSWER = Infer({method: 'MCMC', burn: 10000, samples: 50000, onlyMAP: false}, model);

Error: Parameter "vs" missing from Categorical distribution.

var vocab = ['dogs', 'cats', 'chase', 'sleep', 'stop'];
var vocabSize = vocab.length;

var comparray = function(arr1, arr2) {
  return JSON.stringify(arr1) === JSON.stringify(arr2);
};

var indexOf = function(word) {
  return vocab.indexOf(word);
};

var ANSWER = Infer({method: 'MCMC', burn: 10000, samples: 50000, onlyMAP: false}, function() {
  // Each word in vocab has its own transition distribution
  // We also need a transition from 'start'
  // Total: 6 transition distributions (start + 5 vocab words)
  
  // Transition distributions for each "from" token
  // from: start, dogs, cats, chase, sleep, stop
  var allTokens = ['start', 'dogs', 'cats', 'chase', 'sleep', 'stop'];
  
  var transitionDists = mapObject(function(key, val) {
    return dirichletDrift({alpha: ones([vocabSize, 1]), concentration: 10});
  }, {
    'start': 0,
    'dogs': 0,
    'cats': 0,
    'chase': 0,
    'sleep': 0,
    'stop': 0
  });
  
  var transition = function(prevWord) {
    var probs = transitionDists[prevWord];
    return vocab[categorical({ps: probs})];
  };
  
  // Generate a sentence starting from 'start', collect words until 'stop'
  var generateSentence = function(prevWord, acc) {
    var nextWord = transition(prevWord);
    var newAcc = acc.concat([nextWord]);
    if (nextWord === 'stop') {
      return newAcc;
    } else {
      return generateSentence(nextWord, newAcc);
    }
  };
  
  // Observe the sentence ['dogs', 'chase', 'cats', 'stop']
  var observed = ['dogs', 'chase', 'cats', 'stop'];
  var generated = generateSentence('start', []);
  condition(comparray(generated, observed));
  
  // Second sentence: first word is 'dogs', return second word
  var secondWord = transition('dogs');
  return secondWord;
});

Error: Parameter "vs" missing from Categorical distribution.

var vocab = ['dogs', 'cats', 'chase', 'sleep', 'stop'];
var allWords = ['start', 'dogs', 'cats', 'chase', 'sleep', 'stop'];
var n = vocab.length;

var comparray = function(arr1, arr2) {
  return JSON.stringify(arr1) === JSON.stringify(arr2);
};

var model = function() {
  // Draw one transition distribution per source word
  var getTransition = mem(function(word) {
    return dirichletDrift({alpha: ones([n, 1]), concentration: 10});
  });

  // Observed sentence 1: ['dogs', 'chase', 'cats', 'stop']
  // Condition on each bigram transition
  observe(Categorical({ps: getTransition('start'), vs: vocab}), 'dogs');
  observe(Categorical({ps: getTransition('dogs'),  vs: vocab}), 'chase');
  observe(Categorical({ps: getTransition('chase'), vs: vocab}), 'cats');
  observe(Categorical({ps: getTransition('cats'),  vs: vocab}), 'stop');

  // Second sentence: first word is 'dogs'
  // Condition on transition from 'start' yielding 'dogs'
  observe(Categorical({ps: getTransition('start'), vs: vocab}), 'dogs');

  // Sample the second word of the new sentence from transition('dogs')
  var secondWord = vocab[categorical({ps: getTransition('dogs')})];
  return secondWord;
};

var ANSWER = Infer({method: 'MCMC', burn: 10000, samples: 50000, onlyMAP: false}, model);

var vocab = ['dogs', 'cats', 'chase', 'sleep', 'stop'];

var comparray = function(arr1, arr2) {
  return JSON.stringify(arr1) === JSON.stringify(arr2);
};

var model = function() {
  // Each state gets its own transition distribution (memoized = shared within a run)
  var transitionDist = mem(function(word) {
    return dirichletDrift({alpha: ones([5, 1]), concentration: 10});
  });

  var transition = function(prevWord) {
    var probs = transitionDist(prevWord);
    return vocab[discrete(probs)];
  };

  // Generate a sentence from prevWord, accumulating words including 'stop'
  var generateSentence = function(prevWord, acc) {
    var nextWord = transition(prevWord);
    var newAcc = acc.concat([nextWord]);
    return nextWord === 'stop' ? newAcc : generateSentence(nextWord, newAcc);
  };

  // Observe the first sentence: ['dogs', 'chase', 'cats', 'stop']
  var sent1 = generateSentence('start', []);
  condition(comparray(sent1, ['dogs', 'chase', 'cats', 'stop']));

  // Second sentence: condition that first word is 'dogs', return second word
  var sent2 = generateSentence('start', []);
  condition(sent2[0] === 'dogs');

  return sent2[1];
};

var ANSWER = Infer({method: 'MCMC', burn: 10000, samples: 50000, onlyMAP: false}, model);

Error: cpsInnerStatement

var comparray = function(arr1, arr2) {
  return JSON.stringify(arr1) === JSON.stringify(arr2);
};

var vocab = ['dogs', 'cats', 'chase', 'sleep', 'stop'];

var model = function() {
  // Draw transition distributions for each word
  var transitions = {};
  transitions['start'] = sample(dirichletDrift({alpha: ones([5, 1]), concentration: 10}));
  transitions['dogs'] = sample(dirichletDrift({alpha: ones([5, 1]), concentration: 10}));
  transitions['cats'] = sample(dirichletDrift({alpha: ones([5, 1]), concentration: 10}));
  transitions['chase'] = sample(dirichletDrift({alpha: ones([5, 1]), concentration: 10}));
  transitions['sleep'] = sample(dirichletDrift({alpha: ones([5, 1]), concentration: 10}));
  transitions['stop'] = sample(dirichletDrift({alpha: ones([5, 1]), concentration: 10}));
  
  var transition = function(prevWord) {
    return categorical({ps: transitions[prevWord], vs: vocab});
  };
  
  // Generate first sentence
  var sentence1 = [];
  var word = transition('start');
  sentence1.push(word);
  while (word !== 'stop') {
    word = transition(word);
    sentence1.push(word);
  }
  
  // Observe first sentence
  observe(comparray(sentence1, ['dogs', 'chase', 'cats', 'stop']), true);
  
  // Generate second sentence
  var sentence2 = [];
  var word2 = transition('start');
  sentence2.push(word2);
  
  // Observe that second word of sentence2 is 'chase'
  var secondWord = transition(word2);
  sentence2.push(secondWord);
  observe(secondWord === 'chase', true);
  
  // Return the first word of the second sentence
  return word2;
};

var ANSWER = Infer({method: 'MCMC', burn: 10000, samples: 50000, onlyMAP: false}, model);

TypeError: T.toArray is not a function

var comparray = function(arr1, arr2) {
  return JSON.stringify(arr1) === JSON.stringify(arr2);
};

var vocab = ['dogs', 'cats', 'chase', 'sleep', 'stop'];

var model = function() {
  // Draw transition distributions for each word
  var transition = mem(function(word) {
    var alpha = ones([5, 1]);
    var probs = dirichletDrift({alpha: alpha, concentration: 10});
    return probs;
  });

  // Generate a sentence starting from 'start'
  var generateSentence = function(prevWord) {
    var probs = transition(prevWord);
    var nextWord = categorical({vs: vocab, ps: T.toArray(probs)});
    var sentence = [nextWord];
    if (nextWord === 'stop') {
      return sentence;
    } else {
      return sentence.concat(generateSentence(nextWord));
    }
  };

  // Observe the first sentence
  var sentence1 = generateSentence('start');
  observe(Categorical({vs: [true, false], ps: [1, 0]}), 
          comparray(sentence1, ['dogs', 'chase', 'cats', 'stop']));

  // Generate the second sentence
  var sentence2 = generateSentence('start');
  
  // Condition on the second word being 'chase'
  condition(sentence2.length > 1 && sentence2[1] === 'chase');

  // Return the first word of the second sentence
  return sentence2[0];
};

var ANSWER = Infer({method: 'MCMC', burn: 10000, samples: 50000, onlyMAP: false}, model);

Error: cpsInnerStatement

var vocab = ['dogs', 'cats', 'chase', 'sleep', 'stop'];

var comparray = function(arr1, arr2) {
  return JSON.stringify(arr1) === JSON.stringify(arr2);
};

var model = function() {
  // Define transition distributions for each word (including 'start')
  var transitions = {};
  
  // Create transition distributions from dirichletDrift
  var words_and_start = ['start'].concat(vocab);
  for (var i = 0; i < words_and_start.length; i++) {
    var word = words_and_start[i];
    transitions[word] = dirichletDrift({
      alpha: ones([5, 1]),
      concentration: 10
    });
  }
  
  // Function to get next word given previous word
  var transition = function(prevWord) {
    var dist = transitions[prevWord];
    var nextWordIdx = sample(dist);
    return vocab[nextWordIdx];
  };
  
  // Function to generate a sentence
  var generateSentence = function() {
    var sentence = [];
    var currentWord = 'start';
    while (true) {
      var nextWord = transition(currentWord);
      sentence.push(nextWord);
      if (nextWord === 'stop') {
        break;
      }
      currentWord = nextWord;
    }
    return sentence;
  };
  
  // Observe the first sentence
  var sentence1 = generateSentence();
  observe(comparray(sentence1, ['dogs', 'chase', 'cats', 'stop']), true);
  
  // Generate second sentence where second word is 'chase'
  var firstWord = transition('start');
  var secondWord = transition(firstWord);
  observe(secondWord === 'chase', true);
  
  return firstWord;
};

var ANSWER = Infer({method: 'MCMC', burn: 10000, samples: 50000, onlyMAP: false}, model);

Error: Line 39: You tried to assign to a field of transitions, but you can only assign to fields of globalStore

var vocab = ['dogs', 'cats', 'chase', 'sleep', 'stop'];

var comparray = function(arr1, arr2) {
  return JSON.stringify(arr1) === JSON.stringify(arr2);
};

var model = function() {
  // Draw transition distributions for each word
  var transitions = {};
  
  var allWords = ['start'].concat(vocab);
  mapData({data: allWords}, function(word) {
    transitions[word] = dirichletDrift({alpha: ones([5, 1]), concentration: 10});
  });
  
  // Function to get next word given current word
  var nextWord = function(word) {
    var probs = transitions[word];
    return categorical({vs: vocab, ps: probs});
  };
  
  // Generate sentence word by word
  var generateSentenceWords = function(maxLength) {
    var rec = function(currentWord, acc, remaining) {
      if (remaining === 0) {
        return acc;
      }
      var next = nextWord(currentWord);
      var newAcc = acc.concat([next]);
      if (next === 'stop') {
        return newAcc;
      } else {
        return rec(next, newAcc, remaining - 1);
      }
    };
    return rec('start', [], maxLength);
  };
  
  // Observe first sentence ['dogs', 'chase', 'cats', 'stop']
  var sentence1 = generateSentenceWords(20);
  condition(comparray(sentence1, ['dogs', 'chase', 'cats', 'stop']));
  
  // Generate second sentence
  var sentence2 = generateSentenceWords(20);
  // Condition that second word is 'chase'
  condition(sentence2.length >= 2 && sentence2[1] === 'chase');
  
  // Return first word of second sentence
  return sentence2[0];
};

var ANSWER = Infer({method: 'MCMC', burn: 10000, samples: 50000, onlyMAP: false}, model);

Error: Parameter "vs" missing from Categorical distribution.

var vocab = ['dogs', 'cats', 'chase', 'sleep', 'stop'];
var vocabSize = vocab.length;

var comparray = function(arr1, arr2) {
  return JSON.stringify(arr1) === JSON.stringify(arr2);
};

var indexOf = function(word) {
  return vocab.indexOf(word);
};

var model = function() {
  // Each word (plus 'start') has its own transition distribution
  // 'start' + 5 vocab words = 6 transition distributions
  // But 'stop' doesn't need a transition distribution (terminal)
  // We need transitions from: 'start', 'dogs', 'cats', 'chase', 'sleep'
  // (not from 'stop' since we terminate)
  
  var allSources = ['start', 'dogs', 'cats', 'chase', 'sleep'];
  
  // Draw transition distributions for each source word
  var transitionDists = map(function(src) {
    return dirichletDrift({alpha: ones([vocabSize, 1]), concentration: 10});
  }, allSources);
  
  var getTransDist = function(word) {
    var idx = allSources.indexOf(word);
    return transitionDists[idx];
  };
  
  var transition = function(prevWord) {
    var probs = getTransDist(prevWord);
    return vocab[categorical({ps: probs})];
  };
  
  // Generate a sentence starting from 'start'
  var generateSentence = function(prevWord, acc) {
    var nextWord = transition(prevWord);
    var newAcc = acc.concat([nextWord]);
    if (nextWord === 'stop') {
      return newAcc;
    } else {
      return generateSentence(nextWord, newAcc);
    }
  };
  
  // Observe sentence 1: ['dogs', 'chase', 'cats', 'stop']
  var obs1 = ['dogs', 'chase', 'cats', 'stop'];
  var sent1 = generateSentence('start', []);
  observe(Gaussian({mu: 0, sigma: 0.01}), comparray(sent1, obs1) ? 0 : -10);
  
  // Generate second sentence and observe that second word is 'chase'
  var sent2 = generateSentence('start', []);
  // Second word is sent2[1]
  // We need at least 2 words in sent2
  observe(Gaussian({mu: 0, sigma: 0.01}), (sent2.length >= 2 && sent2[1] === 'chase') ? 0 : -10);
  
  // Return the first word of the second sentence
  return sent2[0];
};

var ANSWER = Infer({method: 'MCMC', burn: 10000, samples: 50000, onlyMAP: false}, model);

var vocab = ['dogs', 'cats', 'chase', 'sleep', 'stop'];

var comparray = function(arr1, arr2) {
  return JSON.stringify(arr1) === JSON.stringify(arr2);
};

var model = function() {
  // Each source token gets its own transition distribution over vocab
  var tokens = ['start', 'dogs', 'cats', 'chase', 'sleep', 'stop'];

  var ps = {
    'start': dirichletDrift({alpha: ones([5, 1]), concentration: 10}),
    'dogs':  dirichletDrift({alpha: ones([5, 1]), concentration: 10}),
    'cats':  dirichletDrift({alpha: ones([5, 1]), concentration: 10}),
    'chase': dirichletDrift({alpha: ones([5, 1]), concentration: 10}),
    'sleep': dirichletDrift({alpha: ones([5, 1]), concentration: 10}),
    'stop':  dirichletDrift({alpha: ones([5, 1]), concentration: 10})
  };

  var transition = function(prevWord) {
    return categorical({vs: vocab, ps: ps[prevWord]});
  };

  // ---- Observe sentence 1: ['dogs', 'chase', 'cats', 'stop'] ----
  // start -> dogs -> chase -> cats -> stop
  observe(Categorical({vs: vocab, ps: ps['start']}), 'dogs');
  observe(Categorical({vs: vocab, ps: ps['dogs']}),  'chase');
  observe(Categorical({vs: vocab, ps: ps['chase']}), 'cats');
  observe(Categorical({vs: vocab, ps: ps['cats']}),  'stop');

  // ---- Sentence 2: second word is 'chase' ----
  // Sample the first word, then observe second word = 'chase'
  var word1 = transition('start');
  observe(Categorical({vs: vocab, ps: ps[word1]}), 'chase');

  return word1;
};

var ANSWER = Infer({method: 'MCMC', burn: 10000, samples: 50000, onlyMAP: false}, model);

var vocab = ['dogs', 'cats', 'chase', 'sleep', 'stop'];

var comparray = function(arr1, arr2) {
  return JSON.stringify(arr1) === JSON.stringify(arr2);
};

var model = function() {
  // Each "from" token gets its own memoized transition distribution (Dirichlet drift)
  var transitions = mem(function(word) {
    return dirichletDrift({alpha: ones([5, 1]), concentration: 10});
  });

  // Sample next word from the transition distribution of prevWord
  var transition = function(prevWord) {
    var probs = transitions(prevWord);
    return categorical({vs: vocab, ps: probs});
  };

  // Observe the first sentence: ['dogs', 'chase', 'cats', 'stop']
  // This encodes: start->dogs, dogs->chase, chase->cats, cats->stop
  observe(Categorical({vs: vocab, ps: transitions('start')}), 'dogs');
  observe(Categorical({vs: vocab, ps: transitions('dogs')}),  'chase');
  observe(Categorical({vs: vocab, ps: transitions('chase')}), 'cats');
  observe(Categorical({vs: vocab, ps: transitions('cats')}),  'stop');

  // Second sentence: the second word is 'chase'
  // Sample the first word from the start transition
  var firstWord = transition('start');
  // Observe that the word after firstWord is 'chase'
  observe(Categorical({vs: vocab, ps: transitions(firstWord)}), 'chase');

  return firstWord;
};

var ANSWER = Infer({method: 'MCMC', burn: 10000, samples: 50000, onlyMAP: false}, model);

Error: cpsInnerStatement

var comparray = function(arr1, arr2) {
  return JSON.stringify(arr1) === JSON.stringify(arr2);
};

var vocab = ['dogs', 'cats', 'chase', 'sleep', 'stop'];
var vocabSize = vocab.length;

var model = function() {
  // Create transition distributions for each word
  var transitions = {};
  
  for (var i = 0; i < vocabSize; i++) {
    var word = vocab[i];
    transitions[word] = dirichletDrift({
      alpha: ones([vocabSize, 1]),
      concentration: 10
    });
  }
  
  // Add transition distribution for 'start'
  transitions['start'] = dirichletDrift({
    alpha: ones([vocabSize, 1]),
    concentration: 10
  });
  
  // Function to generate a sentence
  var generateSentence = function() {
    var sentence = [];
    var currentWord = 'start';
    
    while (true) {
      var nextDist = transitions[currentWord];
      var nextWord = categorical({ps: nextDist, vs: vocab});
      sentence.push(nextWord);
      
      if (nextWord === 'stop') {
        break;
      }
      currentWord = nextWord;
    }
    
    return sentence;
  };
  
  // Observe the first sentence
  var sentence1 = generateSentence();
  observe(comparray(sentence1, ['dogs', 'chase', 'cats', 'stop']), true);
  
  // Generate second sentence starting with 'cats'
  var sentence2 = [];
  sentence2.push('cats');
  var currentWord = 'cats';
  
  while (true) {
    var nextDist = transitions[currentWord];
    var nextWord = categorical({ps: nextDist, vs: vocab});
    sentence2.push(nextWord);
    
    if (nextWord === 'stop') {
      break;
    }
    currentWord = nextWord;
  }
  
  // Return the second word of the second sentence
  return sentence2[1];
};

var ANSWER = Infer({method: 'MCMC', burn: 10000, samples: 50000, onlyMAP: false}, model);

Error: cpsInnerStatement

var comparray = function(arr1, arr2) {
  return JSON.stringify(arr1) === JSON.stringify(arr2);
};

var vocab = ['dogs', 'cats', 'chase', 'sleep', 'stop'];
var observedSentence = ['dogs', 'chase', 'cats', 'stop'];

var model = function() {
  // Draw transition distributions for each word
  var transitionDists = {};
  map(function(word) {
    transitionDists[word] = dirichletDrift({
      alpha: ones([5, 1]),
      concentration: 10
    });
  }, vocab);
  
  // Also need transition from 'start'
  transitionDists['start'] = dirichletDrift({
    alpha: ones([5, 1]),
    concentration: 10
  });
  
  // Helper function to get next word given previous word
  var transition = function(prevWord) {
    var probs = transitionDists[prevWord];
    var probsArray = [];
    for (var i = 0; i < 5; i++) {
      probsArray.push(T.get(probs, i));
    }
    return categorical({vs: vocab, ps: probsArray});
  };
  
  // Generate a sentence starting from 'start'
  var generateSentence = function() {
    var sentence = [];
    var current = 'start';
    var maxLen = 100;
    var len = 0;
    
    while (len < maxLen) {
      var next = transition(current);
      sentence.push(next);
      if (next === 'stop') {
        return sentence;
      }
      current = next;
      len = len + 1;
    }
    return sentence;
  };
  
  // Observe the first sentence
  var sentence1 = generateSentence();
  condition(comparray(sentence1, observedSentence));
  
  // Generate second sentence starting with 'cats'
  var current = 'cats';
  var probs = transitionDists[current];
  var probsArray = [];
  for (var i = 0; i < 5; i++) {
    probsArray.push(T.get(probs, i));
  }
  var secondWord = categorical({vs: vocab, ps: probsArray});
  
  return secondWord;
};

var ANSWER = Infer({
  method: 'MCMC',
  burn: 10000,
  samples: 50000,
  onlyMAP: false
}, model);

Error: cpsInnerStatement

var vocab = ['dogs', 'cats', 'chase', 'sleep', 'stop'];

var comparray = function(arr1, arr2) {
  return JSON.stringify(arr1) === JSON.stringify(arr2);
};

var model = function() {
  // Create transition distributions for each word (including 'start')
  var transitions = {};
  var alpha = [1, 1, 1, 1, 1]; // ones([5,1]) equivalent
  
  // Sample transition distribution for 'start'
  transitions['start'] = sample(Dirichlet({alpha: alpha}));
  
  // Sample transition distribution for each vocabulary word
  vocab.forEach(function(word) {
    transitions[word] = sample(Dirichlet({alpha: alpha}));
  });
  
  // Function to generate a sentence
  var generateSentence = function() {
    var words = [];
    var currentWord = 'start';
    
    while (true) {
      var transitionDist = transitions[currentWord];
      var nextWord = sample(Categorical({ps: transitionDist, vs: vocab}));
      words.push(nextWord);
      
      if (nextWord === 'stop') {
        break;
      }
      currentWord = nextWord;
    }
    return words;
  };
  
  // Generate first sentence and condition on observed sentence
  var sentence1 = generateSentence();
  var observedSentence = ['dogs', 'chase', 'cats', 'stop'];
  condition(comparray(sentence1, observedSentence));
  
  // Generate second sentence starting with 'cats'
  var words2 = ['cats'];
  var currentWord = 'cats';
  
  while (true) {
    var transitionDist = transitions[currentWord];
    var nextWord = sample(Categorical({ps: transitionDist, vs: vocab}));
    words2.push(nextWord);
    
    if (nextWord === 'stop') {
      break;
    }
    currentWord = nextWord;
  }
  
  // Return the second word of the new sentence
  return words2[1];
};

var ANSWER = Infer({method: 'MCMC', burn: 10000, samples: 50000, onlyMAP: false}, model);

Error: cpsInnerStatement

var vocab = ['dogs', 'cats', 'chase', 'sleep', 'stop'];

var comparray = function(arr1, arr2) {
  return JSON.stringify(arr1) === JSON.stringify(arr2);
};

var model = function() {
  var transition = mem(function(word) {
    var probs = dirichletDrift({alpha: ones([5,1]), concentration: 10});
    return probs;
  });
  
  var generateSentence = function() {
    var sentence = [];
    var word = 'start';
    var count = 0;
    var maxLength = 20;
    while (count < maxLength) {
      var probs = transition(word);
      var nextWord = sample(Categorical({vs: vocab, ps: probs}));
      sentence.push(nextWord);
      word = nextWord;
      if (nextWord === 'stop') break;
      count += 1;
    }
    return sentence;
  };
  
  var sent1 = generateSentence();
  condition(comparray(sent1, ['dogs', 'chase', 'cats', 'stop']));
  
  var sent2Word2 = sample(Categorical({vs: vocab, ps: transition('cats')}));
  return sent2Word2;
};

var ANSWER = Infer({method: 'MCMC', burn: 10000, samples: 50000, onlyMAP: false}, model);

Error: Parameter "vs" missing from Categorical distribution.

var vocab = ['dogs', 'cats', 'chase', 'sleep', 'stop'];
var vocabSize = vocab.length;

var comparray = function(arr1, arr2) {
  return JSON.stringify(arr1) === JSON.stringify(arr2);
};

var ones5 = ones([5, 1]);

var model = function() {
  // Each word (plus 'start') has its own transition distribution
  // Words: start, dogs, cats, chase, sleep, stop
  // We need transition distributions for: start, dogs, cats, chase, sleep
  // (stop is terminal, no transitions from it needed)
  
  var transitionDists = {
    'start': dirichletDrift({alpha: ones5, concentration: 10}),
    'dogs': dirichletDrift({alpha: ones5, concentration: 10}),
    'cats': dirichletDrift({alpha: ones5, concentration: 10}),
    'chase': dirichletDrift({alpha: ones5, concentration: 10}),
    'sleep': dirichletDrift({alpha: ones5, concentration: 10}),
    'stop': dirichletDrift({alpha: ones5, concentration: 10})
  };
  
  var transition = function(prevWord) {
    var probs = transitionDists[prevWord];
    return vocab[categorical({ps: probs})];
  };
  
  // Generate a sentence starting from 'start'
  var generateSentence = function(prevWord, acc) {
    var nextWord = transition(prevWord);
    var newAcc = acc.concat([nextWord]);
    if (nextWord === 'stop') {
      return newAcc;
    } else {
      return generateSentence(nextWord, newAcc);
    }
  };
  
  // Observe sentence 1: ['dogs', 'chase', 'cats', 'stop']
  var observed = ['dogs', 'chase', 'cats', 'stop'];
  var generated = generateSentence('start', []);
  observe(Gaussian({mu: 0, sigma: 0.01}), comparray(generated, observed) ? 0 : -10);
  
  // Second sentence: first word is 'cats', get second word
  var secondWord = transition('cats');
  
  return secondWord;
};

var ANSWER = Infer({method: 'MCMC', burn: 10000, samples: 50000, onlyMAP: false}, model);

var vocab = ['dogs', 'cats', 'chase', 'sleep', 'stop'];

var comparray = function(arr1, arr2) {
  return JSON.stringify(arr1) === JSON.stringify(arr2);
};

var model = function() {
  // Each word (including 'start') gets its own transition distribution over vocab
  var transStart = dirichletDrift({alpha: ones([5, 1]), concentration: 10});
  var transDogs   = dirichletDrift({alpha: ones([5, 1]), concentration: 10});
  var transCats   = dirichletDrift({alpha: ones([5, 1]), concentration: 10});
  var transChase  = dirichletDrift({alpha: ones([5, 1]), concentration: 10});
  var transSleep  = dirichletDrift({alpha: ones([5, 1]), concentration: 10});
  // 'stop' is a terminal; no outgoing transitions needed

  var transProbs = function(word) {
    if (word === 'start') return transStart;
    if (word === 'dogs')  return transDogs;
    if (word === 'cats')  return transCats;
    if (word === 'chase') return transChase;
    if (word === 'sleep') return transSleep;
  };

  var transition = function(prevWord) {
    return Categorical({ps: transProbs(prevWord), vs: vocab});
  };

  // Observe sentence ['dogs', 'chase', 'cats', 'stop']
  // start -> dogs
  observe(transition('start'), 'dogs');
  // dogs -> chase
  observe(transition('dogs'), 'chase');
  // chase -> cats
  observe(transition('chase'), 'cats');
  // cats -> stop
  observe(transition('cats'), 'stop');

  // Second sentence: first word is 'cats'; return second word
  return sample(transition('cats'));
};

var ANSWER = Infer({method: 'MCMC', burn: 10000, samples: 50000, onlyMAP: false}, model);

var vocab = ['dogs', 'cats', 'chase', 'sleep', 'stop'];

var comparray = function(arr1, arr2) {
  return JSON.stringify(arr1) === JSON.stringify(arr2);
};

var model = function() {
  // Each context word gets its own transition distribution over vocab
  var transitionWeights = mem(function(word) {
    return dirichletDrift({alpha: ones([5, 1]), concentration: 10});
  });

  var transition = function(prevWord) {
    var probs = transitionWeights(prevWord);
    return sample(Categorical({vs: vocab, ps: probs}));
  };

  // Generate a sentence by chaining transitions until 'stop'
  var generateSentence = function(prevWord, acc) {
    var nextWord = transition(prevWord);
    var newAcc = acc.concat([nextWord]);
    return nextWord === 'stop' ? newAcc : generateSentence(nextWord, newAcc);
  };

  // Condition on observed sentence ['dogs', 'chase', 'cats', 'stop']
  var observed = ['dogs', 'chase', 'cats', 'stop'];
  var generated = generateSentence('start', []);
  condition(comparray(generated, observed));

  // New sentence: first word is 'cats'; return the second word
  var secondWord = transition('cats');
  return secondWord;
};

var ANSWER = Infer({method: 'MCMC', burn: 10000, samples: 50000, onlyMAP: false}, model);

// Hidden Markov Model for sentence generation with parts of speech

var posTransitionPrior = function(pos) {
  // Dirichlet-drift priors for transitions from each POS
  var alpha = 1.5; // concentration parameter
  
  if (pos === 'start') {
    return Categorical({ps: [0.7, 0.3], vs: ['N', 'V']});
  } else if (pos === 'N') {
    // From noun, likely to go to verb or stop
    return Categorical({ps: [0.5, 0.4, 0.1], vs: ['V', 'N', 'stop']});
  } else if (pos === 'V') {
    // From verb, likely to go to noun or stop
    return Categorical({ps: [0.5, 0.3, 0.2], vs: ['N', 'V', 'stop']});
  }
};

var wordPrior = function(pos) {
  // Generate words given part of speech
  if (pos === 'N') {
    return Categorical({ps: [0.5, 0.5], vs: ['dogs', 'cats']});
  } else if (pos === 'V') {
    return Categorical({ps: [0.4, 0.4, 0.2], vs: ['chase', 'sleep', 'stop']});
  }
};

var generateSentence = function(currentPos) {
  if (currentPos === 'stop') {
    return [];
  }
  
  // Sample next POS from transition distribution
  var nextPos = sample(posTransitionPrior(currentPos));
  
  if (nextPos === 'stop') {
    return [];
  }
  
  // Sample word given POS
  var word = sample(wordPrior(nextPos));
  
  // Recursively generate rest of sentence
  var restOfSentence = generateSentence(nextPos);
  
  return [word].concat(restOfSentence);
};

var ANSWER = generateSentence('start');

TypeError: Cannot read properties of undefined (reading 'length')

// Hidden Markov Model for sentence generation
// States: parts of speech (start, N, V, stop)
// Observations: words

var words = {
  'N': ['dogs', 'cats', 'mice'],
  'V': ['chase', 'sleep', 'eat']
};

var posStates = ['N', 'V', 'stop'];

// Memoized transition distribution for each POS
var transitionDist = mem(function(pos) {
  var alpha = Vector([1, 1, 1]); // Dirichlet prior for [N, V, stop]
  var probs = dirichlet({alpha: alpha});
  return Categorical({
    vs: posStates,
    ps: [T.get(probs, 0), T.get(probs, 1), T.get(probs, 2)]
  });
});

// Special transition from 'start' state
var startTransitionDist = function() {
  var alpha = Vector([1, 1]); // Dirichlet prior for [N, V]
  var probs = dirichlet({alpha: alpha});
  return Categorical({
    vs: ['N', 'V'],
    ps: [T.get(probs, 0), T.get(probs, 1)]
  });
};

// Memoized word emission distribution for each POS
var emissionDist = mem(function(pos) {
  var wordList = words[pos];
  var n = wordList.length;
  var alpha = Vector(repeat(n, function() { return 1; }));
  var probs = dirichlet({alpha: alpha});
  var probsList = map(function(i) { return T.get(probs, i); }, _.range(0, n));
  return Categorical({
    vs: wordList,
    ps: probsList
  });
});

// Generate a sentence starting from 'start' state
var generateSentence = function(currentPos) {
  if (currentPos === 'stop') {
    return [];
  }
  var nextPos = (currentPos === 'start') ? 
    sample(startTransitionDist()) : 
    sample(transitionDist(currentPos));
  var word = sample(emissionDist(nextPos));
  var restOfSentence = generateSentence(nextPos);
  return [word].concat(restOfSentence);
};

var ANSWER = generateSentence('start');

Error: cpsInnerStatement

var generateSentence = function(startState) {
  // Per-state transition probabilities sampled from Dirichlet distributions
  var transitionProbs = function(state) {
    var nextStates = ['N', 'V', 'stop'];
    
    if (state === 'start') {
      // From start, prefer nouns
      var ps = dirichlet({alpha: [2, 1, 0.5]});
      return {ps: ps, vs: nextStates};
    } else if (state === 'N') {
      // From noun, prefer verb or stop
      var ps = dirichlet({alpha: [0.5, 2, 1]});
      return {ps: ps, vs: nextStates};
    } else if (state === 'V') {
      // From verb, prefer noun or stop
      var ps = dirichlet({alpha: [1.5, 0.5, 1]});
      return {ps: ps, vs: nextStates};
    }
  };
  
  // Emit word given POS
  var emitWord = function(pos) {
    if (pos === 'N') {
      return uniformDraw(['dogs', 'cats']);
    } else if (pos === 'V') {
      return uniformDraw(['chase', 'sleep']);
    }
  };
  
  // Generate sentence as sequence of words
  var state = startState;
  var sentence = [];
  var maxSteps = 50;
  var step = 0;
  
  while (state !== 'stop' && step < maxSteps) {
    var transProbs = transitionProbs(state);
    var nextState = categorical(transProbs);
    
    if (nextState === 'stop') {
      state = 'stop';
    } else {
      sentence.push(emitWord(nextState));
      state = nextState;
    }
    step++;
  }
  
  return sentence.join(' ');
};

var ANSWER = generateSentence('start');

var vocab = {
  'N': ['dogs', 'cats'],
  'V': ['chase', 'sleep', 'stop']
};

// Memoized Dirichlet priors for transition probabilities from each state
var getTransitionProbs = mem(function(state) {
  if (state === 'start') {
    // From start: transition to N or V
    return dirichlet({alpha: Vector([1, 1])});
  } else if (state === 'N') {
    // From N: transition to V or end
    return dirichlet({alpha: Vector([1, 1])});
  } else if (state === 'V') {
    // From V: transition to N or end
    return dirichlet({alpha: Vector([1, 1])});
  }
});

// Memoized Dirichlet priors for emission probabilities for each POS
var getEmissionProbs = mem(function(pos) {
  if (pos === 'N') {
    // Nouns: dogs, cats
    return dirichlet({alpha: Vector([1, 1])});
  } else if (pos === 'V') {
    // Verbs: chase, sleep, stop
    return dirichlet({alpha: Vector([1, 1, 1])});
  }
});

var generateSentence = function(state) {
  if (state === 'end') {
    return [];
  } else if (state === 'start') {
    // Sample next POS state from start
    var probs = getTransitionProbs(state);
    var nextState = sample(Categorical({
      vs: ['N', 'V'],
      ps: [T.get(probs, 0), T.get(probs, 1)]
    }));
    return generateSentence(nextState);
  } else {
    // state is 'N' or 'V' - emit a word
    var emissionProbs = getEmissionProbs(state);
    var words = vocab[state];
    var wordProbs = map(function(i) {
      return T.get(emissionProbs, i);
    }, _.range(0, words.length));
    var word = sample(Categorical({vs: words, ps: wordProbs}));
    
    // Sample next POS state
    var transitionProbs = getTransitionProbs(state);
    var nextStates = (state === 'N') ? ['V', 'end'] : ['N', 'end'];
    var nextStateProbs = map(function(ns) {
      return T.get(transitionProbs, _.indexOf(nextStates, ns));
    }, nextStates);
    var nextState = sample(Categorical({vs: nextStates, ps: nextStateProbs}));
    
    return [word].concat(generateSentence(nextState));
  }
};

var ANSWER = generateSentence('start');

// Hidden Markov Model for sentence generation
// POS tags: 'N' (noun), 'V' (verb), 'stop'
// Words: nouns = ['dogs', 'cats'], verbs = ['chase', 'sleep']

// Dirichlet-drift priors for POS transitions
// From 'start': can go to N or V
// From N: can go to V or stop
// From V: can go to N or stop

var model = function() {
  
  // Per-POS transition distributions using Dirichlet priors
  // start -> {N, V}
  var startTrans = dirichlet(Vector([2, 2]));
  
  // N -> {V, stop}
  var nTrans = dirichlet(Vector([3, 1]));
  
  // V -> {N, stop}
  var vTrans = dirichlet(Vector([2, 2]));
  
  // Word emission distributions
  // N -> {dogs, cats}
  var nEmit = dirichlet(Vector([1, 1]));
  
  // V -> {chase, sleep}
  var vEmit = dirichlet(Vector([1, 1]));
  
  // Transition function: given current POS, sample next POS
  var nextPOS = function(pos) {
    if (pos === 'start') {
      var idx = categorical({ps: startTrans, vs: ['N', 'V']});
      return idx;
    } else if (pos === 'N') {
      var idx = categorical({ps: nTrans, vs: ['V', 'stop']});
      return idx;
    } else if (pos === 'V') {
      var idx = categorical({ps: vTrans, vs: ['N', 'stop']});
      return idx;
    } else {
      return 'stop';
    }
  };
  
  // Emission function: given POS, sample a word
  var emitWord = function(pos) {
    if (pos === 'N') {
      return categorical({ps: nEmit, vs: ['dogs', 'cats']});
    } else if (pos === 'V') {
      return categorical({ps: vEmit, vs: ['chase', 'sleep']});
    } else {
      return null;
    }
  };
  
  // Generate a sentence starting from a given state
  var generateSentence = function(pos) {
    var next = nextPOS(pos);
    if (next === 'stop') {
      return [];
    } else {
      var word = emitWord(next);
      return [word].concat(generateSentence(next));
    }
  };
  
  return generateSentence('start');
};

var ANSWER = model();

// Parts of speech and vocabulary
// POS: 'N' (noun), 'V' (verb), 'stop'
// Words: nouns=['dogs','cats'], verbs=['chase','sleep'], terminal='stop'

// ── Dirichlet-drift priors: sample HMM parameters once per program run ──

// Transition distributions  (from each non-terminal POS)
var transFromStart = dirichlet(Vector([1, 1]));        // → [N, V]
var transFromN     = dirichlet(Vector([1, 1, 2]));     // → [N, V, stop]
var transFromV     = dirichlet(Vector([1, 1, 2]));     // → [N, V, stop]

// Emission distributions (word given POS)
var emitN = dirichlet(Vector([1, 1]));   // dogs, cats
var emitV = dirichlet(Vector([1, 1]));   // chase, sleep

// ── Helpers ──

var nextState = function(state) {
  if (state === 'start') {
    return categorical({ ps: transFromStart, vs: ['N', 'V'] });
  } else if (state === 'N') {
    return categorical({ ps: transFromN, vs: ['N', 'V', 'stop'] });
  } else {  // state === 'V'
    return categorical({ ps: transFromV, vs: ['N', 'V', 'stop'] });
  }
};

var emitWord = function(pos) {
  if (pos === 'N') {
    return categorical({ ps: emitN, vs: ['dogs', 'cats'] });
  } else {  // pos === 'V'
    return categorical({ ps: emitV, vs: ['chase', 'sleep'] });
  }
};

// ── Sentence generator (recursive, depth-limited for safety) ──

var generateSentence = function(state, depth) {
  if (depth > 20) return ['stop'];          // safety cap
  var next = nextState(state);
  if (next === 'stop') return ['stop'];
  var word = emitWord(next);
  return [word].concat(generateSentence(next, depth + 1));
};

var ANSWER = generateSentence('start', 0);

// Memoized per-POS transition probability vectors, sampled from Dirichlet-drift priors
var transitionPs = mem(function(pos) {
  if (pos === 'start') {
    return dirichletDrift({alpha: Vector([1, 1]), concentration: 2});
  } else if (pos === 'N') {
    return dirichletDrift({alpha: Vector([1, 1]), concentration: 2});
  } else if (pos === 'V') {
    return dirichletDrift({alpha: Vector([1, 1]), concentration: 2});
  } else {
    return Vector([1]);
  }
});

// Legal next-POS options for each state
var nextStates = {
  'start': ['N', 'V'],
  'N':     ['V', 'stop'],
  'V':     ['N', 'stop']
};

// Sample next POS given current POS
var transition = function(pos) {
  var states = nextStates[pos];
  var ps = transitionPs(pos);
  return sample(Categorical({vs: states, ps: ps}));
};

// Emit a word given POS (deterministic vocab per POS)
var emitWord = function(pos) {
  if (pos === 'N') {
    return flip(0.5) ? 'dogs' : 'cats';
  } else if (pos === 'V') {
    return flip(0.5) ? 'chase' : 'sleep';
  } else {
    return 'stop';
  }
};

// Recursively generate a sentence from the given POS state
var generateSentence = function(pos) {
  var nextPos = transition(pos);
  if (nextPos === 'stop') {
    return ['stop'];
  } else {
    var word = emitWord(nextPos);
    return [word].concat(generateSentence(nextPos));
  }
};

var ANSWER = generateSentence('start');

Error: cpsInnerStatement

var comparray = function(arr1, arr2) {
  return JSON.stringify(arr1) === JSON.stringify(arr2);
};

var nouns = ['dogs', 'cats'];
var verbs = ['chase', 'sleep'];

var drawWord = function(pos) {
  if (pos === 'N') {
    return uniformDraw(nouns);
  } else if (pos === 'V') {
    return uniformDraw(verbs);
  } else {
    return 'stop';
  }
};

var getTransitionDist = function(pos) {
  return memoize(function(fromPos) {
    var transitions = ['N', 'V', 'stop'];
    var probs = dirichletDrift({alpha: ones([3, 1]), concentration: 10});
    return categorical({vs: transitions, ps: probs});
  })(pos);
};

var generateSentence = function() {
  var sentence = [];
  var pos = 'start';
  
  while (true) {
    var nextPos;
    if (pos === 'start') {
      nextPos = uniformDraw(['N', 'V']);
    } else {
      nextPos = getTransitionDist(pos);
    }
    
    var word = drawWord(nextPos);
    sentence.push(word);
    
    if (word === 'stop') {
      break;
    }
    
    pos = nextPos;
  }
  
  return sentence;
};

var model = function() {
  var sentence1 = generateSentence();
  observe(comparray(sentence1, ['dogs', 'chase', 'cats', 'stop']), true);
  
  var sentence2 = [];
  sentence2.push('cats');
  
  var pos = 'N';
  var nextPos = getTransitionDist(pos);
  var word = drawWord(nextPos);
  sentence2.push(word);
  
  return word;
};

var ANSWER = Infer({method: 'MCMC', burn: 10000, samples: 1000, lag: 10, onlyMAP: false}, model);

TypeError: dist.score is not a function

var comparray = function(arr1, arr2) {
  return JSON.stringify(arr1) === JSON.stringify(arr2);
};

var drawWord = function(pos) {
  if (pos === 'N') {
    return uniformDraw(['dogs', 'cats']);
  } else if (pos === 'V') {
    return uniformDraw(['chase', 'sleep']);
  } else {
    return 'stop';
  }
};

var getTransitionDist = mem(function(pos) {
  var alpha = ones([3, 1]);
  var transitions = dirichletDrift({alpha: alpha, concentration: 10});
  return transitions;
});

var generateSentence = function() {
  var recur = function(currentPos, sentence) {
    var transitionProbs = getTransitionDist(currentPos);
    var nextPos = categorical({
      vs: ['N', 'V', 'stop'],
      ps: [T.get(transitionProbs, 0), T.get(transitionProbs, 1), T.get(transitionProbs, 2)]
    });
    var word = drawWord(nextPos);
    var newSentence = sentence.concat([word]);
    
    if (nextPos === 'stop') {
      return newSentence;
    } else {
      return recur(nextPos, newSentence);
    }
  };
  
  return recur('start', []);
};

var model = function() {
  var sentence1 = generateSentence();
  observe(sentence1, ['dogs', 'chase', 'cats', 'stop']);
  
  var sentence2 = function() {
    var recur = function(currentPos, sentence) {
      var transitionProbs = getTransitionDist(currentPos);
      var nextPos = categorical({
        vs: ['N', 'V', 'stop'],
        ps: [T.get(transitionProbs, 0), T.get(transitionProbs, 1), T.get(transitionProbs, 2)]
      });
      var word = drawWord(nextPos);
      var newSentence = sentence.concat([word]);
      
      if (nextPos === 'stop') {
        return newSentence;
      } else {
        return recur(nextPos, newSentence);
      }
    };
    
    return recur('V', ['cats']);
  };
  
  var sent2 = sentence2();
  return sent2[1];
};

var ANSWER = Infer({
  method: 'MCMC',
  burn: 10000,
  samples: 1000,
  lag: 10,
  onlyMAP: false
}, model);

Error: cpsInnerStatement

var comparray = function(arr1, arr2) {
  return JSON.stringify(arr1) === JSON.stringify(arr2);
};

var drawWord = function(pos) {
  if (pos === 'N') {
    return uniformDraw(['dogs', 'cats']);
  } else if (pos === 'V') {
    return uniformDraw(['chase', 'sleep']);
  } else {
    return 'stop';
  }
};

var transitionDist = memoize(function(fromPOS) {
  var alpha = [1, 1, 1];
  return dirichlet({alpha: alpha});
});

var generateSentence = function() {
  var sentence = [];
  var currentPOS = 'start';
  
  while (true) {
    var transDist = transitionDist(currentPOS);
    var nextPOS = categorical({ps: transDist, vs: ['N', 'V', 'stop']});
    
    var word = drawWord(nextPOS);
    sentence.push(word);
    
    if (nextPOS === 'stop') break;
    currentPOS = nextPOS;
  }
  
  return sentence;
};

var model = function() {
  // Generate and observe the first sentence
  var sentence1 = generateSentence();
  var observed = ['dogs', 'chase', 'cats', 'stop'];
  observe(comparray(sentence1, observed), true);
  
  // Generate a second sentence
  var sentence2 = generateSentence();
  
  // Condition on first word being 'cats'
  condition(sentence2[0] === 'cats');
  
  // Return the second word
  return sentence2[1];
};

var ANSWER = Infer({
  method: 'MCMC',
  burn: 10000,
  samples: 1000,
  lag: 10,
  onlyMAP: false
}, model);

var comparray = function(arr1, arr2) {
  return JSON.stringify(arr1) === JSON.stringify(arr2);
};

// Memoized function to get transition distribution for a state
var getTransitionDist = mem(function(state) {
  var alpha = ones([3, 1]); // For N, V, stop
  var transitions = dirichletDrift({alpha: alpha, concentration: 10});
  return transitions; // Returns a vector of probabilities [p_N, p_V, p_stop]
});

// Draw a word given a POS
var drawWord = function(pos) {
  if (pos === 'N') {
    return uniformDraw(['dogs', 'cats']);
  } else if (pos === 'V') {
    return uniformDraw(['chase', 'sleep']);
  } else {
    return 'stop';
  }
};

// Index to POS mapping
var indexToPos = function(idx) {
  if (idx === 0) return 'N';
  if (idx === 1) return 'V';
  if (idx === 2) return 'stop';
};

// Generate a sentence
var generateSentence = function() {
  var sentence = [];
  
  var step = function(currentPos) {
    // Get transition probabilities
    var transProbs = getTransitionDist(currentPos);
    var idx = sample(Categorical({
      vs: [0, 1, 2],
      ps: [T.get(transProbs, 0), T.get(transProbs, 1), T.get(transProbs, 2)]
    }));
    var nextPos = indexToPos(idx);
    var word = drawWord(nextPos);
    sentence.push(word);
    
    if (nextPos === 'stop') {
      return sentence;
    } else {
      return step(nextPos);
    }
  };
  
  return step('start');
};

// Model
var model = function() {
  // Generate first sentence and condition on observing ['dogs', 'chase', 'cats', 'stop']
  var sent1 = generateSentence();
  condition(comparray(sent1, ['dogs', 'chase', 'cats', 'stop']));
  
  // Generate second sentence and condition on first word being 'cats'
  var sent2 = generateSentence();
  condition(sent2[0] === 'cats');
  
  // Return the second word of the second sentence
  return sent2[1];
};

var ANSWER = Infer({
  method: 'MCMC',
  burn: 10000,
  samples: 1000,
  lag: 10,
  onlyMAP: false
}, model);

Error: sample() expected a distribution but received "{"dims":[3,1],"length":3,"data":{"0":0.11281629838309856,"1":0.692513462395544,"2":0.19467023922135746}}".

var comparray = function(arr1, arr2) {
  return JSON.stringify(arr1) === JSON.stringify(arr2);
};

var posLabels = ['N', 'V', 'stop'];
var posIndex = {N: 0, V: 1, stop: 2};

var nouns = ['dogs', 'cats'];
var verbs = ['chase', 'sleep'];

var drawWord = function(pos) {
  if (pos === 'N') return uniformDraw(nouns);
  if (pos === 'V') return uniformDraw(verbs);
  return 'stop';
};

var wordToPos = function(word) {
  if (nouns.indexOf(word) >= 0) return 'N';
  if (verbs.indexOf(word) >= 0) return 'V';
  return 'stop';
};

var model = function() {
  // Memoized transition distributions for each POS (including 'start')
  var transitionDist = mem(function(pos) {
    return dirichletDrift({alpha: ones([3, 1]), concentration: 10});
  });

  var transition = function(pos) {
    var probs = sample(transitionDist(pos));
    return posLabels[discrete(probs)];
  };

  // Generate a sentence starting from 'start' POS
  var generateSentence = function(currentPos, words) {
    var nextPos = transition(currentPos);
    var word = drawWord(nextPos);
    if (word === 'stop') {
      return words.concat(['stop']);
    } else {
      return generateSentence(nextPos, words.concat([word]));
    }
  };

  // Observe sentence 1: ['dogs', 'chase', 'cats', 'stop']
  var obs1 = ['dogs', 'chase', 'cats', 'stop'];
  
  // Score sentence 1 by conditioning on it
  // We need to factor in the probability of generating this exact sentence
  // Sentence: start -> N(dogs) -> V(chase) -> N(cats) -> stop
  
  // Transition from 'start' to N
  var t1 = transitionDist('start');
  var p1 = sample(t1);
  factor(Math.log(p1.data[posIndex['N']])); // transition to N
  // word 'dogs' from N: prob 1/2
  factor(Math.log(0.5));
  
  // Transition from N to V
  var t2 = transitionDist('N');
  var p2 = sample(t2);
  factor(Math.log(p2.data[posIndex['V']])); // transition to V
  // word 'chase' from V: prob 1/2
  factor(Math.log(0.5));
  
  // Transition from V to N
  var t3 = transitionDist('V');
  var p3 = sample(t3);
  factor(Math.log(p3.data[posIndex['N']])); // transition to N
  // word 'cats' from N: prob 1/2
  factor(Math.log(0.5));
  
  // Transition from N to stop
  var t4 = transitionDist('N');
  // t4 is same as t2 (memoized on 'N'), so p2 is already sampled
  factor(Math.log(p2.data[posIndex['stop']])); // transition to stop
  // word 'stop' from stop: prob 1
  
  // Now generate second sentence, first word is 'cats'
  // First word is 'cats' (N), so transition from 'start' must go to N
  // Use the same transition distributions (memoized)
  
  // Transition from 'start' to N for sentence 2
  factor(Math.log(p1.data[posIndex['N']])); // same dist as sentence 1 start
  // word 'cats' from N: prob 1/2
  factor(Math.log(0.5));
  
  // Now sample the second word
  // Transition from N
  var nextPos2 = posLabels[discrete(p2)]; // p2 is transitionDist('N')
  var secondWord = drawWord(nextPos2);
  
  return secondWord;
};

var ANSWER = Infer({method: 'MCMC', burn: 10000, samples: 1000, lag: 10, onlyMAP: false}, model);

ReferenceError: DirichletDrift is not defined

var comparray = function(arr1, arr2) {
  return JSON.stringify(arr1) === JSON.stringify(arr2);
};

var POStags = ['N', 'V', 'stop'];

var transitionDist = mem(function(pos) {
  return sample(DirichletDrift({alpha: ones([3, 1]), concentration: 10}));
});

var sampleNextPos = function(currentPos) {
  var probs = T.toScalars(transitionDist(currentPos));
  return categorical({ps: probs, vs: POStags});
};

var drawWord = function(pos) {
  if (pos === 'N') return uniformDraw(['dogs', 'cats']);
  if (pos === 'V') return uniformDraw(['chase', 'sleep']);
  return 'stop';
};

var generateSentence = function(currentPos, words) {
  var nextPos = sampleNextPos(currentPos);
  var word = drawWord(nextPos);
  if (nextPos === 'stop') {
    return words.concat(['stop']);
  }
  return generateSentence(nextPos, words.concat([word]));
};

var model = function() {
  // Observe first sentence: ['dogs', 'chase', 'cats', 'stop']
  // This means: start->N(dogs)->V(chase)->N(cats)->stop
  var sent1 = generateSentence('start', []);
  condition(comparray(sent1, ['dogs', 'chase', 'cats', 'stop']));

  // Second sentence: first word is 'cats' (noun => POS = N)
  // Start transition from 'start' must lead to N
  var pos1 = sampleNextPos('start');
  condition(pos1 === 'N');
  var word1 = drawWord(pos1);
  condition(word1 === 'cats');

  // Second word
  var pos2 = sampleNextPos(pos1);
  var word2 = drawWord(pos2);

  return word2;
};

var ANSWER = Infer({method: 'MCMC', burn: 10000, samples: 1000, lag: 10, onlyMAP: false}, model);

var comparray = function(arr1, arr2) {
  return JSON.stringify(arr1) === JSON.stringify(arr2);
};

var posOptions = ['N', 'V', 'stop'];

var transitionDist = mem(function(pos) {
  return dirichletDrift({alpha: ones([3, 1]), concentration: 10});
});

var drawWord = function(pos) {
  if (pos === 'N') {
    return uniformDraw(['dogs', 'cats']);
  } else if (pos === 'V') {
    return uniformDraw(['chase', 'sleep']);
  } else {
    return 'stop';
  }
};

var nextPos = function(pos) {
  var probs = transitionDist(pos);
  return posOptions[discrete(probs)];
};

var generateSentence = function(curPos, acc) {
  var nPos = nextPos(curPos);
  var word = drawWord(nPos);
  if (nPos === 'stop') {
    return acc.concat(['stop']);
  } else {
    return generateSentence(nPos, acc.concat([word]));
  }
};

var model = function() {
  // Observe first sentence
  var sent1 = generateSentence('start', []);
  condition(comparray(sent1, ['dogs', 'chase', 'cats', 'stop']));

  // Second sentence: first word is 'cats'
  var pos1 = nextPos('start');
  condition(pos1 === 'N');
  var w1 = drawWord(pos1);
  condition(w1 === 'cats');

  // Second word of second sentence
  var pos2 = nextPos(pos1);
  var w2 = drawWord(pos2);

  return w2;
};

var ANSWER = Infer({
  method: 'MCMC',
  burn: 10000,
  samples: 1000,
  lag: 10,
  onlyMAP: false
}, model);

var comparray = function(arr1, arr2) {
  return JSON.stringify(arr1) === JSON.stringify(arr2);
};

var posTagList = ['N', 'V', 'D', 'A', 'stop'];

var getTransitionDist = mem(function(pos) {
  return dirichletDrift({alpha: ones([5, 1]), concentration: 10});
});

var drawWord = function(pos) {
  if (pos === 'N') {
    return uniformDraw(['dog', 'cat']);
  } else if (pos === 'V') {
    return uniformDraw(['chases', 'sleeps']);
  } else if (pos === 'D') {
    return uniformDraw(['the', 'a']);
  } else if (pos === 'A') {
    return 'dilligently';
  } else if (pos === 'stop') {
    return 'stop';
  }
};

var generateSentence = function(currentPos) {
  if (currentPos === 'start') {
    var nextPos = categorical({ps: getTransitionDist('start'), vs: posTagList});
    return generateSentence(nextPos);
  } else if (currentPos === 'stop') {
    return ['stop'];
  } else {
    var word = drawWord(currentPos);
    var nextPos = categorical({ps: getTransitionDist(currentPos), vs: posTagList});
    var restSentence = generateSentence(nextPos);
    return [word].concat(restSentence);
  }
};

var model = function() {
  var sentence = generateSentence('start');
  var observedSentence = ['the', 'dog', 'chases', 'a', 'cat', 'stop'];
  factor(comparray(observedSentence, sentence) ? 5 : 0);
  
  var sent1 = generateSentence('start');
  var sent2 = generateSentence('start');
  var sent3 = generateSentence('start');
  var sent4 = generateSentence('start');
  var sent5 = generateSentence('start');
  
  return {sent1: sent1, sent2: sent2, sent3: sent3, sent4: sent4, sent5: sent5};
};

var ANSWER = Infer({method: 'MCMC', burn: 10000, samples: 1000, lag: 10, onlyMAP: true}, model);

var comparray = function(arr1, arr2) {
  return JSON.stringify(arr1) === JSON.stringify(arr2);
};

var nouns = ['dog', 'cat'];
var verbs = ['chases', 'sleeps'];
var determiners = ['the', 'a'];
var adverbs = ['dilligently'];
var tags = ['N', 'V', 'D', 'A', 'stop'];

var drawWord = function(pos) {
  if (pos === 'N') {
    return uniformDraw(nouns);
  } else if (pos === 'V') {
    return uniformDraw(verbs);
  } else if (pos === 'D') {
    return uniformDraw(determiners);
  } else if (pos === 'A') {
    return 'dilligently';
  } else if (pos === 'stop') {
    return 'stop';
  }
};

var transitionDist = mem(function(pos) {
  var alpha = ones([5, 1]);
  var probs = dirichletDrift({alpha: alpha, concentration: 10});
  return Categorical({vs: tags, ps: probs});
});

var generateSentence = function(currentPos) {
  if (currentPos === 'stop') {
    return [];
  }
  
  var nextPos = sample(transitionDist(currentPos));
  var word = drawWord(nextPos);
  
  if (nextPos === 'stop') {
    return ['stop'];
  } else {
    var rest = generateSentence(nextPos);
    return [word].concat(rest);
  }
};

var model = function() {
  var sent1 = generateSentence('start');
  factor(comparray(['the', 'dog', 'chases', 'a', 'cat', 'stop'], sent1) ? 5 : 0);
  
  var sent2 = generateSentence('start');
  var sent3 = generateSentence('start');
  var sent4 = generateSentence('start');
  var sent5 = generateSentence('start');
  
  return {
    sent1: sent1,
    sent2: sent2,
    sent3: sent3,
    sent4: sent4,
    sent5: sent5
  };
};

var ANSWER = Infer({method: 'MCMC', burn: 10000, samples: 1000, lag: 10, onlyMAP: true}, model);

Error: cpsInnerStatement

var comparray = function(arr1, arr2) {
  return JSON.stringify(arr1) === JSON.stringify(arr2);
};

var indexToPos = ['N', 'V', 'D', 'A', 'stop'];

// Memoized transition distribution
var getTransitions = mem(function(currentPos) {
  var transitions = dirichletDrift({
    alpha: [1, 1, 1, 1, 1],
    concentration: 10
  });
  return transitions;
});

// Draw a word given a POS tag
var drawWord = function(pos) {
  if (pos === 'N') {
    return uniformDraw(['dog', 'cat']);
  } else if (pos === 'V') {
    return uniformDraw(['chases', 'sleeps']);
  } else if (pos === 'D') {
    return uniformDraw(['the', 'a']);
  } else if (pos === 'A') {
    return 'dilligently';
  } else if (pos === 'stop') {
    return 'stop';
  }
};

// Generate a sentence
var generateSentence = function(startPos) {
  var sentence = [];
  var currentPos = startPos;
  
  while (true) {
    // Get transition probabilities for current POS
    var transitions = getTransitions(currentPos);
    
    // Sample next POS tag
    var nextPos = categorical({ps: transitions, vs: indexToPos});
    
    // Draw a word for this POS
    var word = drawWord(nextPos);
    sentence.push(word);
    
    // Stop if we've generated the stop token
    if (nextPos === 'stop') {
      break;
    }
    
    currentPos = nextPos;
  }
  
  return sentence;
};

// Define the model
var model = function() {
  var sent1 = generateSentence('start');
  var sent2 = generateSentence('start');
  var sent3 = generateSentence('start');
  var sent4 = generateSentence('start');
  var sent5 = generateSentence('start');
  
  // Soft condition on observed sentence
  factor(comparray(['the', 'dog', 'chases', 'a', 'cat', 'stop'], sent1) * 5);
  
  return {sent1: sent1, sent2: sent2, sent3: sent3, sent4: sent4, sent5: sent5};
};

var ANSWER = Infer({method: 'MCMC', burn: 10000, samples: 1000, lag: 10, onlyMAP: true}, model);

TypeError: T.toArray is not a function

var comparray = function(arr1, arr2) {
  return JSON.stringify(arr1) === JSON.stringify(arr2);
};

// Memoized transition function for each POS tag
// Returns a distribution over [N, V, D, A, stop]
var getTransition = mem(function(pos) {
  return dirichletDrift({alpha: ones([5, 1]), concentration: 10});
});

// Draw a word given a POS tag
var drawWord = function(pos) {
  if (pos === 'N') {
    return uniformDraw(['dog', 'cat']);
  } else if (pos === 'V') {
    return uniformDraw(['chases', 'sleeps']);
  } else if (pos === 'D') {
    return uniformDraw(['the', 'a']);
  } else if (pos === 'A') {
    return 'dilligently';
  } else if (pos === 'stop') {
    return 'stop';
  }
};

// Map indices to POS tags
var indexToPOS = ['N', 'V', 'D', 'A', 'stop'];

// Generate a sentence recursively
var generateSentence = function(state) {
  if (state === 'start') {
    // From start, sample first POS tag
    var transitions = getTransition('start');
    var posIndex = sample(Categorical({vs: _.range(0, 5), ps: T.toArray(transitions)}));
    var pos = indexToPOS[posIndex];
    return generateSentence(pos);
  } else if (state === 'stop') {
    return ['stop'];
  } else {
    // Sample next POS tag
    var transitions = getTransition(state);
    var nextIndex = sample(Categorical({vs: _.range(0, 5), ps: T.toArray(transitions)}));
    var nextPOS = indexToPOS[nextIndex];
    
    // Draw word for current POS
    var word = drawWord(state);
    
    // Recursively generate rest of sentence
    var rest = generateSentence(nextPOS);
    return [word].concat(rest);
  }
};

// Model function
var model = function() {
  // Generate a sentence and softly condition on observed sentence
  var sent = generateSentence('start');
  var observed = ['the', 'dog', 'chases', 'a', 'cat', 'stop'];
  factor(comparray(observed, sent) * 5);
  
  // Sample 5 new sentences
  var sent1 = generateSentence('start');
  var sent2 = generateSentence('start');
  var sent3 = generateSentence('start');
  var sent4 = generateSentence('start');
  var sent5 = generateSentence('start');
  
  return {sent1: sent1, sent2: sent2, sent3: sent3, sent4: sent4, sent5: sent5};
};

var ANSWER = Infer({method: 'MCMC', burn: 10000, samples: 1000, lag: 10, onlyMAP: true}, model);

Error: Parameter "alpha" should be of type "vector (0, Infinity)".

var ones = function(dims) {
  return repeat(dims[0], function() { return 1; });
};

var posOrder = ['start', 'N', 'V', 'D', 'A', 'stop'];
var posIndex = {start: 0, N: 1, V: 2, D: 3, A: 4, stop: 5};

var nounWords = ['dog', 'cat'];
var verbWords = ['chases', 'sleeps'];
var detWords = ['the', 'a'];
var advWords = ['dilligently'];

var getTransition = mem(function(pos) {
  return dirichletDrift({alpha: ones([5, 1]), concentration: 10});
});

var nextPOS = function(pos) {
  var probs = sample(getTransition(pos));
  var tags = ['N', 'V', 'D', 'A', 'stop'];
  return tags[discrete(probs)];
};

var drawWord = function(pos) {
  if (pos === 'N') {
    return uniformDraw(nounWords);
  } else if (pos === 'V') {
    return uniformDraw(verbWords);
  } else if (pos === 'D') {
    return uniformDraw(detWords);
  } else if (pos === 'A') {
    return 'dilligently';
  } else if (pos === 'stop') {
    return 'stop';
  }
};

var generateSentence = function(pos) {
  var next = nextPOS(pos);
  if (next === 'stop') {
    return ['stop'];
  } else {
    var word = drawWord(next);
    return [word].concat(generateSentence(next));
  }
};

var comparray = function(arr1, arr2) {
  return JSON.stringify(arr1) === JSON.stringify(arr2);
};

var ANSWER = Infer({method: 'MCMC', burn: 10000, samples: 1000, lag: 10, onlyMAP: true}, function() {
  factor(comparray(['the', 'dog', 'chases', 'a', 'cat', 'stop'], generateSentence('start')) * 5);
  
  var sent1 = generateSentence('start');
  var sent2 = generateSentence('start');
  var sent3 = generateSentence('start');
  var sent4 = generateSentence('start');
  var sent5 = generateSentence('start');
  
  return {sent1: sent1, sent2: sent2, sent3: sent3, sent4: sent4, sent5: sent5};
});

Error: sample() expected a distribution but received "{"dims":[5,1],"length":5,"data":{"0":0.03199880024831679,"1":0.19642197333240166,"2":0.05521555119618678,"3":0.6723021334704087,"4":0.04406154175268608}}".

var comparray = function(arr1, arr2) {
  return JSON.stringify(arr1) === JSON.stringify(arr2);
};

var posList = ['N', 'V', 'D', 'A', 'stop'];

var getTransition = mem(function(pos) {
  return sample(dirichletDrift({alpha: ones([5, 1]), concentration: 10}));
});

var nextPos = function(pos) {
  var probs = getTransition(pos);
  return categorical({ps: probs, vs: posList});
};

var drawWord = function(pos) {
  if (pos === 'N') return uniformDraw(['dog', 'cat']);
  if (pos === 'V') return uniformDraw(['chases', 'sleeps']);
  if (pos === 'D') return uniformDraw(['the', 'a']);
  if (pos === 'A') return 'dilligently';
  if (pos === 'stop') return 'stop';
};

var generateSentence = function(pos) {
  if (pos === 'stop') return ['stop'];
  var next = nextPos(pos);
  if (pos === 'start') {
    return generateSentence(next);
  } else {
    var word = drawWord(pos);
    return [word].concat(generateSentence(next));
  }
};

var model = function() {
  factor(comparray(['the', 'dog', 'chases', 'a', 'cat', 'stop'],
                   generateSentence('start')) * 5);

  var sent1 = generateSentence('start');
  var sent2 = generateSentence('start');
  var sent3 = generateSentence('start');
  var sent4 = generateSentence('start');
  var sent5 = generateSentence('start');

  return {sent1: sent1, sent2: sent2, sent3: sent3, sent4: sent4, sent5: sent5};
};

var ANSWER = Infer({method: 'MCMC', burn: 10000, samples: 1000, lag: 10, onlyMAP: true}, model);

var comparray = function(arr1, arr2) {
  return JSON.stringify(arr1) === JSON.stringify(arr2);
};

var tags = ['N', 'V', 'D', 'A', 'stop'];

var getTransition = mem(function(pos) {
  return dirichletDrift({alpha: ones([5, 1]), concentration: 10});
});

var nextTag = function(pos) {
  var probs = getTransition(pos);
  var idx = sample(Categorical({vs: _.range(5), ps: probs}));
  return tags[idx];
};

var drawWord = function(pos) {
  return pos === 'N' ? uniformDraw(['dog', 'cat']) :
         pos === 'V' ? uniformDraw(['chases', 'sleeps']) :
         pos === 'D' ? uniformDraw(['the', 'a']) :
         pos === 'A' ? 'dilligently' :
         'stop';
};

var generateSentence = function(pos) {
  var next = nextTag(pos);
  if (next === 'stop') {
    return ['stop'];
  }
  var word = drawWord(next);
  return [word].concat(generateSentence(next));
};

var model = function() {
  factor(comparray(['the', 'dog', 'chases', 'a', 'cat', 'stop'],
                   generateSentence('start')) * 5);

  var sent1 = generateSentence('start');
  var sent2 = generateSentence('start');
  var sent3 = generateSentence('start');
  var sent4 = generateSentence('start');
  var sent5 = generateSentence('start');

  return {
    sent1: sent1,
    sent2: sent2,
    sent3: sent3,
    sent4: sent4,
    sent5: sent5
  };
};

var ANSWER = Infer({method: 'MCMC', burn: 10000, samples: 1000, lag: 10, onlyMAP: true}, model);

Error: cpsInnerStatement

var D = ['the', 'a'];
var N = ['cat', 'dog'];
var V = ['chases', 'sleeps'];
var A = ['diligently'];

var AP = function() {
  return uniformDraw(A);
};

var NP = function() {
  return [uniformDraw(D), uniformDraw(N)];
};

var VP = function() {
  if (flip(0.5)) {
    return [uniformDraw(V), AP()];
  } else {
    return [uniformDraw(V), NP()];
  }
};

var S = function() {
  return [NP(), VP()];
};

var comparray = function(a, b) {
  if (a.length !== b.length) return false;
  for (var i = 0; i < a.length; i++) {
    if (Array.isArray(a[i]) && Array.isArray(b[i])) {
      if (!comparray(a[i], b[i])) return false;
    } else if (a[i] !== b[i]) {
      return false;
    }
  }
  return true;
};

var model = function() {
  var sent1 = S();
  var sent2 = S();
  var sent3 = S();
  var sent4 = S();
  var sent5 = S();
  
  var targetSent = [['the', 'dog'], ['chases', ['a', 'cat']]];
  condition(comparray(sent1, targetSent));
  
  return {sent1: sent1, sent2: sent2, sent3: sent3, sent4: sent4, sent5: sent5};
};

var ANSWER = Infer({method: 'MCMC', samples: 1000, onlyMAP: true}, model);

Timeout after 60s

var D = ['the', 'a'];
var N = ['cat', 'dog'];
var V = ['chases', 'sleeps'];
var A = ['diligently'];

var AP = function() {
  return [uniformDraw(A)];
};

var NP = function() {
  return [uniformDraw(D), uniformDraw(N)];
};

var VP = function() {
  var choice = flip(0.5);
  if (choice) {
    return [uniformDraw(V)].concat(AP());
  } else {
    return [uniformDraw(V)].concat(NP());
  }
};

var S = function() {
  return NP().concat(VP());
};

var comparray = function(a, b) {
  if (!Array.isArray(a) || !Array.isArray(b)) {
    return a === b;
  }
  if (a.length !== b.length) {
    return false;
  }
  return all(function(i) {
    return comparray(a[i], b[i]);
  }, _.range(0, a.length));
};

var model = function() {
  var sent = S();
  var target = [['the', 'dog'], ['chases', ['a', 'cat']]];
  condition(comparray(sent, target));
  return sent;
};

var posterior = Infer({method: 'MCMC', samples: 5000, onlyMAP: true}, model);

var samples = repeat(5, function() {
  return sample(posterior);
});

var ANSWER = {
  sent1: samples[0],
  sent2: samples[1],
  sent3: samples[2],
  sent4: samples[3],
  sent5: samples[4]
};

ReferenceError: comparray is not defined

var D = function() { return uniformDraw(['the', 'a']); };
var N = function() { return uniformDraw(['cat', 'dog']); };
var V = function() { return uniformDraw(['chases', 'sleeps']); };
var A = function() { return 'diligently'; };

var AP = function() { 
  return [A()];
};

var NP = function() { 
  return [D(), N()];
};

var VP = function() { 
  return flip() ? [V(), AP()] : [V(), NP()];
};

var S = function() { 
  return [NP(), VP()];
};

var model = function() {
  var sentence = S();
  var target = [['the', 'dog'], ['chases', ['a', 'cat']]];
  condition(comparray(sentence, target));
  return sentence;
};

var posterior = Infer({method: 'MCMC', samples: 5000, onlyMAP: true}, model);

var sent1 = sample(posterior);
var sent2 = sample(posterior);
var sent3 = sample(posterior);
var sent4 = sample(posterior);
var sent5 = sample(posterior);

var ANSWER = {sent1: sent1, sent2: sent2, sent3: sent3, sent4: sent4, sent5: sent5};

ReferenceError: comparray is not defined

var D = function() { return uniformDraw(['the', 'a']); };
var N = function() { return uniformDraw(['cat', 'dog']); };
var V = function() { return uniformDraw(['chases', 'sleeps']); };
var A = function() { return uniformDraw(['diligently']); };

var AP = function() {
  return A();
};

var NP = function() {
  return [D(), N()];
};

var VP = function() {
  if (flip()) {
    return [V(), AP()];
  } else {
    return [V(), NP()];
  }
};

var S = function() {
  return [NP(), VP()];
};

var model = function() {
  var observedSentence = [['the', 'dog'], ['chases', ['a', 'cat']]];
  var sampledSentence = S();
  condition(comparray(sampledSentence, observedSentence));
  
  var sent1 = S();
  var sent2 = S();
  var sent3 = S();
  var sent4 = S();
  var sent5 = S();
  
  return {sent1: sent1, sent2: sent2, sent3: sent3, sent4: sent4, sent5: sent5};
};

var ANSWER = Infer({method: 'MCMC', samples: 1, onlyMAP: true}, model);

Error: cpsInnerStatement

// Phrase structure grammar

// Helper to compare arrays deeply
var comparray = function(a, b) {
  if (a.length !== b.length) return false;
  var result = true;
  for (var i = 0; i < a.length; i++) {
    if (Array.isArray(a[i]) && Array.isArray(b[i])) {
      if (!comparray(a[i], b[i])) result = false;
    } else {
      if (a[i] !== b[i]) result = false;
    }
  }
  return result;
};

// Grammar rules
var D = function() {
  return uniformDraw(['the', 'a']);
};

var N = function() {
  return uniformDraw(['cat', 'dog']);
};

var V = function() {
  return uniformDraw(['chases', 'sleeps']);
};

var A = function() {
  return 'diligently';
};

var AP = function() {
  return A();
};

var NP = function() {
  return [D(), N()];
};

var VP = function() {
  var choice = flip();
  if (choice) {
    // VP -> [V, AP]
    return [V(), AP()];
  } else {
    // VP -> [V, NP]
    return [V(), NP()];
  }
};

var S = function() {
  return [NP(), VP()];
};

// Target sentence
var target = [['the', 'dog'], ['chases', ['a', 'cat']]];

var model = function() {
  var sentence = S();
  condition(comparray(sentence, target));
  
  // Sample 5 new sentences (unconditioned)
  var sent1 = S();
  var sent2 = S();
  var sent3 = S();
  var sent4 = S();
  var sent5 = S();
  
  return {
    sent1: sent1,
    sent2: sent2,
    sent3: sent3,
    sent4: sent4,
    sent5: sent5
  };
};

var ANSWER = Infer({method: 'MCMC', samples: 1000, onlyMAP: true}, model);

// Deep array comparison
var comparray = function(a, b) {
  if (Array.isArray(a) && Array.isArray(b)) {
    if (a.length !== b.length) return false;
    return all(function(i) { return comparray(a[i], b[i]); }, _.range(a.length));
  }
  return a === b;
};

// Lexical categories
var D = function() { return uniformDraw(['the', 'a']); };
var N = function() { return uniformDraw(['cat', 'dog']); };
var V = function() { return uniformDraw(['chases', 'sleeps']); };
var A = function() { return 'diligently'; };

// Phrase-structure rules
var AP = function() { return A(); };
var NP = function() { return [D(), N()]; };
var VP = function() {
  return flip() ? [V(), AP()] : [V(), NP()];
};
var S = function() { return [NP(), VP()]; };

// Target sentence (parse tree form)
var target = [['the', 'dog'], ['chases', ['a', 'cat']]];

var model = function() {
  // Condition on target being a well-formed sentence
  condition(comparray(S(), target));

  // Sample 5 new sentences from the posterior
  var sent1 = S();
  var sent2 = S();
  var sent3 = S();
  var sent4 = S();
  var sent5 = S();

  return { sent1: sent1, sent2: sent2, sent3: sent3, sent4: sent4, sent5: sent5 };
};

var ANSWER = Infer({ method: 'MCMC', onlyMAP: true, samples: 5000 }, model);

var comparray = function(a, b) {
  if (Array.isArray(a) && Array.isArray(b)) {
    if (a.length !== b.length) return false;
    return _.every(_.range(a.length), function(i) {
      return comparray(a[i], b[i]);
    });
  }
  return a === b;
};

// Lexical rules
var D = function() { return uniformDraw(['the', 'a']); };
var N = function() { return uniformDraw(['cat', 'dog']); };
var V = function() { return uniformDraw(['chases', 'sleeps']); };
var A = function() { return 'diligently'; };

// Phrase structure rules
// AP -> A
var AP = function() { return A(); };

// NP -> [D, N]
var NP = function() { return [D(), N()]; };

// VP -> [V, AP] | [V, NP]
var VP = function() {
  return flip(0.5) ? [V(), AP()] : [V(), NP()];
};

// S -> [NP, VP]
var S = function() { return [NP(), VP()]; };

var target = [['the', 'dog'], ['chases', ['a', 'cat']]];

var model = function() {
  // Condition on the target being a grammatical sentence
  condition(comparray(S(), target));

  // Sample 5 new sentences from the grammar
  var sent1 = S();
  var sent2 = S();
  var sent3 = S();
  var sent4 = S();
  var sent5 = S();

  return {
    sent1: sent1,
    sent2: sent2,
    sent3: sent3,
    sent4: sent4,
    sent5: sent5
  };
};

var ANSWER = Infer({method: 'MCMC', samples: 5000, onlyMAP: true}, model);

var k = 1; var n = 20; var new_n = 5;
var priorDist = Beta({a: 1, b: 1});
var model = function() {
  var p = sample(priorDist);
  observe(Binomial({p: p, n: n}), k);
  var posteriorPredictive = binomial(p, new_n);
  var prior_p = sample(priorDist);
  var priorPredictive = binomial(prior_p, n);
  return {prior: prior_p, priorPredictive, posterior: p, posteriorPredictive};
}
var ANSWER = Infer({method: "MCMC", samples: 2500, lag: 50}, model);

var k = 1; var n = 20; var new_n = 5;
var priorDist = Beta({a: 1, b: 1});
var model = function() {
  var p = sample(priorDist);
  observe(Binomial({p: p, n: n}), k);
  var posteriorPredictive = binomial(p, new_n);
  var prior_p = sample(priorDist);
  var priorPredictive = binomial(prior_p, n);
  return {prior: prior_p, priorPredictive, posterior: p, posteriorPredictive};
};
var ANSWER = Infer({method: "MCMC", samples: 2500, lag: 50}, model);

var k = 1; var n = 20; var new_n = 5;
var priorDist = Beta({a: 1, b: 1});
var model = function() {
  var p = sample(priorDist);
  observe(Binomial({p: p, n: n}), k);
  var posteriorPredictive = binomial(p, new_n);
  var prior_p = sample(priorDist);
  var priorPredictive = binomial(prior_p, n);
  return {prior: prior_p, priorPredictive, posterior: p, posteriorPredictive};
}
var ANSWER = Infer({method: "MCMC", samples: 2500, lag: 50}, model);

var k = 1; 
var n = 20;
var new_n = 5;
var priorDist = Beta({a: 1, b: 1});
var model = function() {
  var p = sample(priorDist);
  observe(Binomial({p: p, n: n}), k);
  var posteriorPredictive = sample(Binomial({p: p, n: new_n}));
  var prior_p = sample(priorDist);
  var priorPredictive = sample(Binomial({p: prior_p, n: n}));
  return {prior: prior_p, priorPredictive, posterior: p, posteriorPredictive};
}
var ANSWER = Infer({method: "MCMC", samples: 2500, lag: 50}, model);

var k = 1;
var n = 20;
var new_n = 5;
var priorDist = Beta({a: 1, b: 1});

var model = function() {
  var p = sample(priorDist);
  observe(Binomial({p: p, n: n}), k);
  var posteriorPredictive = binomial(p, new_n);
  var prior_p = sample(priorDist);
  var priorPredictive = binomial(prior_p, n);
  return {prior: prior_p, priorPredictive: priorPredictive, posterior: p, posteriorPredictive: posteriorPredictive};
};

var ANSWER = Infer({method: "MCMC", samples: 2500, lag: 50}, model);

var k = 1;
var n = 20;
var new_n = 5;

var priorDist = Beta({a: 1, b: 1});

var model = function() {
  var p = sample(priorDist);
  observe(Binomial({p: p, n: n}), k);
  var posteriorPredictive = binomial(p, new_n);
  var prior_p = sample(priorDist);
  var priorPredictive = binomial(prior_p, new_n);
  return {prior: prior_p, priorPredictive, posterior: p, posteriorPredictive};
};

var ANSWER = Infer({method: "MCMC", samples: 2500, lag: 50}, model);

var k = 1;
var n = 20;
var new_n = 5;

var priorDist = Beta({a: 1, b: 1});

var model = function() {
  var p = sample(priorDist);
  observe(Binomial({p: p, n: n}), k);
  var posteriorPredictive = sample(Binomial({p: p, n: new_n}));
  var prior_p = sample(priorDist);
  var priorPredictive = sample(Binomial({p: prior_p, n: n}));
  return {prior: prior_p, priorPredictive: priorPredictive, posterior: p, posteriorPredictive: posteriorPredictive};
};

var ANSWER = Infer({method: "MCMC", samples: 2500, lag: 50}, model);

var model = function() {
  var cancer = flip(0.00001);
  var cold = flip(0.2);
  var other = flip(0.000000001);
  
  var deathFromCancer = cancer && flip(0.9);
  var deathFromCold = cold && flip(0.00006);
  var deathFromOther = other;
  
  var death = deathFromCancer || deathFromCold || deathFromOther;
  
  return {
    cancer: cancer,
    cold: cold,
    death: death
  };
};

var prior = Infer({method: "enumerate"}, function() {
  return model().cancer;
});

var givenDeath = Infer({method: "enumerate"}, function() {
  var m = model();
  condition(m.death);
  return m.cancer;
});

var givenDeathAndCold = Infer({method: "enumerate"}, function() {
  var m = model();
  condition(m.death && m.cold);
  return m.cancer;
});

var givenDeathAndNoCold = Infer({method: "enumerate"}, function() {
  var m = model();
  condition(m.death && !m.cold);
  return m.cancer;
});

var ANSWER = {
  prior: prior,
  death: givenDeath,
  deathAndCold: givenDeathAndCold,
  deathAndNoCold: givenDeathAndNoCold
};

Timeout after 60s

var model = function() {
  var cancer = flip(0.00001);
  var cold = flip(0.2);
  var other = flip(0.000000001);
  
  var deathFromCancer = cancer && flip(0.9);
  var deathFromCold = cold && flip(0.00006);
  var deathFromOther = other;
  
  var death = deathFromCancer || deathFromCold || deathFromOther;
  
  return {
    cancer: cancer,
    cold: cold,
    death: death
  };
};

var prior = Infer({method: 'forward', samples: 100000}, function() {
  return model().cancer;
});

var givenDeath = Infer({method: 'rejection', samples: 100000}, function() {
  var s = model();
  condition(s.death);
  return s.cancer;
});

var givenDeathAndCold = Infer({method: 'rejection', samples: 100000}, function() {
  var s = model();
  condition(s.death && s.cold);
  return s.cancer;
});

var givenDeathAndNoCold = Infer({method: 'rejection', samples: 100000}, function() {
  var s = model();
  condition(s.death && !s.cold);
  return s.cancer;
});

var ANSWER = {
  prior: prior,
  death: givenDeath,
  deathAndCold: givenDeathAndCold,
  deathAndNoCold: givenDeathAndNoCold
};

Error: sample() expected a distribution but received "{"cancer":false,"death":false,"cold":false}".

var model = function() {
  // Prior probabilities
  var cancer = flip(0.00001);
  var cold = flip(0.2);
  
  // Death outcomes from each disease
  var deathFromCancer = cancer && flip(0.9);
  var deathFromCold = cold && flip(0.00006);
  var deathFromOther = flip(0.000000001);
  
  // Overall death
  var death = deathFromCancer || deathFromCold || deathFromOther;
  
  return {cancer: cancer, death: death, cold: cold};
};

// Prior: unconditional marginal over cancer
var prior = Infer({method: 'enumerate'}, function() {
  return sample(model()).cancer;
});

// Given death
var death = Infer({method: 'enumerate'}, function() {
  var s = sample(model());
  condition(s.death);
  return s.cancer;
});

// Given death and cold
var deathAndCold = Infer({method: 'enumerate'}, function() {
  var s = sample(model());
  condition(s.death && s.cold);
  return s.cancer;
});

// Given death and not cold
var deathAndNoCold = Infer({method: 'enumerate'}, function() {
  var s = sample(model());
  condition(s.death && !s.cold);
  return s.cancer;
});

var ANSWER = {
  prior: prior,
  death: death,
  deathAndCold: deathAndCold,
  deathAndNoCold: deathAndNoCold
};

var model = function() {
  var cancer = flip(0.00001);
  var cold = flip(0.2);
  
  // P(death) depends on which disease is present
  // If cancer: 0.9 probability of death
  // Else if cold: 0.00006 probability of death  
  // Else: 0.000000001 probability of death (other causes)
  var pDeath = cancer ? 0.9 : (cold ? 0.00006 : 0.000000001);
  var death = flip(pDeath);
  
  return {cancer: cancer, cold: cold, death: death};
};

var prior = Infer({method: 'enumerate'}, function() {
  return model().cancer;
});

var deathPosterior = Infer({method: 'enumerate'}, function() {
  var result = model();
  condition(result.death);
  return result.cancer;
});

var deathAndColdPosterior = Infer({method: 'enumerate'}, function() {
  var result = model();
  condition(result.death && result.cold);
  return result.cancer;
});

var deathAndNoColdPosterior = Infer({method: 'enumerate'}, function() {
  var result = model();
  condition(result.death && !result.cold);
  return result.cancer;
});

var ANSWER = {
  prior: prior,
  death: deathPosterior,
  deathAndCold: deathAndColdPosterior,
  deathAndNoCold: deathAndNoColdPosterior
};

var model = function() {
  var cancer = flip(0.00001);
  var cold = flip(0.2);
  
  var pDeath = (cancer ? 0.9 : 0) + 
               (cold ? 0.00006 : 0) + 
               0.000000001;
  // Cap at 1
  var pDeathCapped = Math.min(pDeath, 1);
  
  var death = flip(pDeathCapped);
  
  return {cancer: cancer, cold: cold, death: death};
};

var prior = Infer({method: 'enumerate'}, function() {
  var result = model();
  return result.cancer;
});

var death = Infer({method: 'enumerate'}, function() {
  var result = model();
  condition(result.death === true);
  return result.cancer;
});

var deathAndCold = Infer({method: 'enumerate'}, function() {
  var result = model();
  condition(result.death === true && result.cold === true);
  return result.cancer;
});

var deathAndNoCold = Infer({method: 'enumerate'}, function() {
  var result = model();
  condition(result.death === true && result.cold === false);
  return result.cancer;
});

var ANSWER = {
  prior: prior,
  death: death,
  deathAndCold: deathAndCold,
  deathAndNoCold: deathAndNoCold
};

var model = function() {
  var cancer = flip(0.00001);
  var cold   = flip(0.2);
  var deathFromCancer = cancer ? flip(0.9)         : false;
  var deathFromCold   = cold   ? flip(0.00006)     : false;
  var deathFromOther  = flip(0.000000001);
  var death = deathFromCancer || deathFromCold || deathFromOther;
  return { cancer: cancer, cold: cold, death: death };
};

var prior = Infer({ method: 'enumerate' }, function() {
  var r = model();
  return r.cancer;
});

var death = Infer({ method: 'enumerate' }, function() {
  var r = model();
  condition(r.death === true);
  return r.cancer;
});

var deathAndCold = Infer({ method: 'enumerate' }, function() {
  var r = model();
  condition(r.death === true && r.cold === true);
  return r.cancer;
});

var deathAndNoCold = Infer({ method: 'enumerate' }, function() {
  var r = model();
  condition(r.death === true && r.cold === false);
  return r.cancer;
});

var ANSWER = {
  prior:         prior,
  death:         death,
  deathAndCold:  deathAndCold,
  deathAndNoCold: deathAndNoCold
};

var makeModel = function(condFn) {
  return Infer({method: 'enumerate'}, function() {
    var cancer = flip(0.00001);
    var cold   = flip(0.2);

    // Death can arise from any of three independent sources
    var diedOfCancer = cancer ? flip(0.9)         : false;
    var diedOfCold   = cold   ? flip(0.00006)     : false;
    var diedOfOther  = flip(0.000000001);

    var death = diedOfCancer || diedOfCold || diedOfOther;

    condition(condFn(death, cold));

    return cancer;
  });
};

var prior          = makeModel(function(death, cold) { return true; });
var death          = makeModel(function(death, cold) { return death; });
var deathAndCold   = makeModel(function(death, cold) { return death && cold; });
var deathAndNoCold = makeModel(function(death, cold) { return death && !cold; });

var ANSWER = {
  prior:          prior,
  death:          death,
  deathAndCold:   deathAndCold,
  deathAndNoCold: deathAndNoCold
};

var model = function() {
  var cancer = flip(0.00001);
  var cold = flip(0.2);
  var other = flip(0.000000001);
  
  var deathFromCancer = cancer && flip(0.9);
  var deathFromCold = cold && flip(0.00006);
  var deathFromOther = other;
  
  var death = deathFromCancer || deathFromCold || deathFromOther;
  
  return {
    cancer: cancer,
    cold: cold,
    death: death
  };
};

var prior = Infer({method: "enumerate"}, function() {
  var s = model();
  return s.cold;
});

var givenDeath = Infer({method: "enumerate"}, function() {
  var s = model();
  condition(s.death);
  return s.cold;
});

var givenDeathAndCancer = Infer({method: "enumerate"}, function() {
  var s = model();
  condition(s.death && s.cancer);
  return s.cold;
});

var givenDeathAndNoCancer = Infer({method: "enumerate"}, function() {
  var s = model();
  condition(s.death && !s.cancer);
  return s.cold;
});

var ANSWER = {
  prior: prior,
  death: givenDeath,
  deathAndCancer: givenDeathAndCancer,
  deathAndNoCancer: givenDeathAndNoCancer
};

var ANSWER = {
  prior: Infer({method: 'enumerate'}, function() {
    return flip(0.2);
  }),
  
  death: Infer({method: 'enumerate'}, function() {
    var cold = flip(0.2);
    var cancer = flip(0.00001);
    var other = flip(0.000000001);
    
    var deathFromCold = cold && flip(0.00006);
    var deathFromCancer = cancer && flip(0.9);
    var deathFromOther = other;
    
    var died = deathFromCold || deathFromCancer || deathFromOther;
    condition(died);
    
    return cold;
  }),
  
  deathAndCancer: Infer({method: 'enumerate'}, function() {
    var cold = flip(0.2);
    var cancer = flip(0.00001);
    var other = flip(0.000000001);
    
    var deathFromCold = cold && flip(0.00006);
    var deathFromCancer = cancer && flip(0.9);
    var deathFromOther = other;
    
    var died = deathFromCold || deathFromCancer || deathFromOther;
    condition(died && cancer);
    
    return cold;
  }),
  
  deathAndNoCancer: Infer({method: 'enumerate'}, function() {
    var cold = flip(0.2);
    var cancer = flip(0.00001);
    var other = flip(0.000000001);
    
    var deathFromCold = cold && flip(0.00006);
    var deathFromCancer = cancer && flip(0.9);
    var deathFromOther = other;
    
    var died = deathFromCold || deathFromCancer || deathFromOther;
    condition(died && !cancer);
    
    return cold;
  })
};

var model = function() {
  // Prior probabilities of diseases
  var hasCancer = flip(0.00001);
  var hasCold = flip(0.2);
  
  // Probability of death from other causes
  var dieFromOtherCauses = flip(0.000000001);
  
  // Determine if person dies
  var dieFromCancer = hasCancer && flip(0.9);
  var dieFromCold = hasCold && flip(0.00006);
  var dies = dieFromCancer || dieFromCold || dieFromOtherCauses;
  
  return {
    cold: hasCold,
    cancer: hasCancer,
    dies: dies
  };
};

// Prior marginal on cold
var prior = Infer({method: "enumerate"}, function() {
  var state = model();
  return state.cold;
});

// Posterior marginal on cold given death
var death = Infer({method: "enumerate"}, function() {
  var state = model();
  condition(state.dies);
  return state.cold;
});

// Posterior marginal on cold given death and cancer
var deathAndCancer = Infer({method: "enumerate"}, function() {
  var state = model();
  condition(state.dies && state.cancer);
  return state.cold;
});

// Posterior marginal on cold given death and no cancer
var deathAndNoCancer = Infer({method: "enumerate"}, function() {
  var state = model();
  condition(state.dies && !state.cancer);
  return state.cold;
});

var ANSWER = {
  prior: prior,
  death: death,
  deathAndCancer: deathAndCancer,
  deathAndNoCancer: deathAndNoCancer
};

var model = function() {
  var cancer = flip(0.00001);
  var cold = flip(0.2);
  var otherDeath = flip(0.000000001);
  
  // Determine if person dies
  var deathFromCancer = cancer && flip(0.9);
  var deathFromCold = cold && flip(0.00006);
  var death = deathFromCancer || deathFromCold || otherDeath;
  
  return {
    cold: cold,
    cancer: cancer,
    death: death
  };
};

// Prior: unconditional distribution over cold
var prior = Infer({method: 'forward', samples: 100000}, function() {
  return model().cold;
});

// Given death
var deathMarginal = Infer({method: 'forward', samples: 100000}, function() {
  var s = model();
  condition(s.death);
  return s.cold;
});

// Given death && cancer
var deathAndCancer = Infer({method: 'forward', samples: 100000}, function() {
  var s = model();
  condition(s.death && s.cancer);
  return s.cold;
});

// Given death && !cancer
var deathAndNoCancer = Infer({method: 'forward', samples: 100000}, function() {
  var s = model();
  condition(s.death && !s.cancer);
  return s.cold;
});

var ANSWER = {
  prior: prior,
  death: deathMarginal,
  deathAndCancer: deathAndCancer,
  deathAndNoCancer: deathAndNoCancer
};

Timeout after 60s

var model = function() {
  var cancer = flip(0.00001);
  var cold = flip(0.2);
  
  var pDeath = (cancer ? 0.9 : 0) + 
               (cold ? 0.00006 : 0) + 
               0.000000001;
  var clampedPDeath = Math.min(pDeath, 1);
  
  var death = flip(clampedPDeath);
  
  return {cancer: cancer, cold: cold, death: death};
};

var prior = Infer({method: 'forward', samples: 100000}, function() {
  var result = model();
  return result.cold;
});

var death = Infer({method: 'rejection', samples: 10000}, function() {
  var result = model();
  condition(result.death);
  return result.cold;
});

var deathAndCancer = Infer({method: 'rejection', samples: 10000}, function() {
  var result = model();
  condition(result.death && result.cancer);
  return result.cold;
});

var deathAndNoCancer = Infer({method: 'rejection', samples: 10000}, function() {
  var result = model();
  condition(result.death && !result.cancer);
  return result.cold;
});

var ANSWER = {
  prior: prior,
  death: death,
  deathAndCancer: deathAndCancer,
  deathAndNoCancer: deathAndNoCancer
};

var priorDist = Infer({method: 'enumerate'}, function() {
  return flip(0.2);
});

var deathDist = Infer({method: 'enumerate'}, function() {
  var cancer = flip(0.00001);
  var cold   = flip(0.2);

  var deathFromCancer = cancer ? flip(0.9)         : false;
  var deathFromCold   = cold   ? flip(0.00006)     : false;
  var deathFromOther  =          flip(0.000000001);

  var death = deathFromCancer || deathFromCold || deathFromOther;

  condition(death);
  return cold;
});

var deathAndCancerDist = Infer({method: 'enumerate'}, function() {
  var cancer = flip(0.00001);
  var cold   = flip(0.2);

  var deathFromCancer = cancer ? flip(0.9)         : false;
  var deathFromCold   = cold   ? flip(0.00006)     : false;
  var deathFromOther  =          flip(0.000000001);

  var death = deathFromCancer || deathFromCold || deathFromOther;

  condition(death && cancer);
  return cold;
});

var deathAndNoCancerDist = Infer({method: 'enumerate'}, function() {
  var cancer = flip(0.00001);
  var cold   = flip(0.2);

  var deathFromCancer = cancer ? flip(0.9)         : false;
  var deathFromCold   = cold   ? flip(0.00006)     : false;
  var deathFromOther  =          flip(0.000000001);

  var death = deathFromCancer || deathFromCold || deathFromOther;

  condition(death && !cancer);
  return cold;
});

var ANSWER = {
  prior:            priorDist,
  death:            deathDist,
  deathAndCancer:   deathAndCancerDist,
  deathAndNoCancer: deathAndNoCancerDist
};

var baseModel = function(condFn) {
  return Infer({method: 'enumerate'}, function() {
    var cancer        = flip(0.00001);
    var cold          = flip(0.2);
    var deathFromCancer = cancer && flip(0.9);
    var deathFromCold   = cold   && flip(0.00006);
    var deathFromOther  = flip(0.000000001);
    var death = deathFromCancer || deathFromCold || deathFromOther;
    condFn(death, cancer, cold);
    return cold;
  });
};

var prior = Infer({method: 'enumerate'}, function() {
  return flip(0.2);
});

var death = baseModel(function(d, c, cold) {
  condition(d);
});

var deathAndCancer = baseModel(function(d, c, cold) {
  condition(d && c);
});

var deathAndNoCancer = baseModel(function(d, c, cold) {
  condition(d && !c);
});

var ANSWER = {
  prior:            prior,
  death:            death,
  deathAndCancer:   deathAndCancer,
  deathAndNoCancer: deathAndNoCancer
};

var model = function() {
  var coin = flip(0.5);
  return coin;
};

var dist = Infer({method: 'enumerate'}, model);
var ANSWER = Math.exp(dist.score(true));

var ANSWER = 0.5;

var model = function() {
  return flip(0.5);
};

var dist = Infer({method: "enumerate"}, model);
var ANSWER = Math.exp(dist.score(true));

var model = function() {
  return flip(0.5);
};

var dist = Infer({method: 'enumerate'}, model);
var ANSWER = Math.exp(dist.score(true));

var model = function() {
  var coin = flip(0.5);
  return coin;
};

var dist = Infer({method: 'enumerate'}, model);
var ANSWER = Math.exp(dist.score(true));

var model = function() {
  var coin = flip(0.5);
  return coin;
};

var dist = Infer({ method: 'enumerate' }, model);
var ANSWER = Math.exp(dist.score(true));

var ANSWER = 0.5;

var model = function() {
  // Prior: choose a coin uniformly at random
  // true = biased coin (P(heads) = 0.9), false = fair coin (P(heads) = 0.5)
  var biasedCoin = flip(0.5);
  
  // Probability of heads depends on which coin we have
  var pHeads = biasedCoin ? 0.9 : 0.5;
  
  // Flip the coin three times
  var flip1 = flip(pHeads);
  var flip2 = flip(pHeads);
  var flip3 = flip(pHeads);
  
  // Condition on observing heads on first two flips
  condition(flip1 === true);
  condition(flip2 === true);
  
  // Return the third flip
  return flip3;
};

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

var model = function() {
  // Prior: choose which coin (true = biased, false = fair)
  var isBiased = flip(0.5);
  
  // Probability of heads depends on which coin
  var pHeads = isBiased ? 0.9 : 0.5;
  
  // Observe first two flips are heads
  observe(Bernoulli({p: pHeads}), true);
  observe(Bernoulli({p: pHeads}), true);
  
  // Return the third flip
  var thirdFlip = flip(pHeads);
  return thirdFlip;
};

var ANSWER = Infer({method: 'enumerate'}, model);

var model = function() {
  // Sample which coin we have: true = biased (0.9), false = fair (0.5)
  var isBiased = flip(0.5);
  var pHeads = isBiased ? 0.9 : 0.5;
  
  // Flip the coin three times
  var flip1 = flip(pHeads);
  var flip2 = flip(pHeads);
  var flip3 = flip(pHeads);
  
  // Condition on observing heads for the first two flips
  condition(flip1 && flip2);
  
  // Return the third flip
  return flip3;
};

var ANSWER = Infer({method: 'enumerate'}, model);

var model = function() {
  // Choose which coin we have (uniform prior)
  var coinType = flip(0.5) ? 'biased' : 'fair';
  
  // Set probability of heads based on coin type
  var pHeads = (coinType === 'biased') ? 0.9 : 0.5;
  
  // Flip the coin three times
  var flip1 = flip(pHeads);
  var flip2 = flip(pHeads);
  var flip3 = flip(pHeads);
  
  // Condition on observing heads on first two flips
  condition(flip1 === true && flip2 === true);
  
  // Return the third flip as our query
  return flip3;
};

var ANSWER = Infer({method: 'enumerate'}, model);

var model = function() {
  // Choose coin uniformly at random
  var biased = flip(0.5);
  var p = biased ? 0.9 : 0.5;
  
  // Condition on first two flips being heads
  observe(Bernoulli({p: p}), true);
  observe(Bernoulli({p: p}), true);
  
  // Return the third flip
  return flip(p);
};

var ANSWER = Infer({method: 'enumerate'}, model);

var model = function() {
  // Choose a coin uniformly at random
  var isBiased = flip(0.5);
  var p = isBiased ? 0.9 : 0.5;

  // Flip the coin three times
  var flip1 = flip(p);
  var flip2 = flip(p);
  var flip3 = flip(p);

  // Condition on first two flips being heads
  condition(flip1 === true && flip2 === true);

  // Return the third flip
  return flip3;
};

var ANSWER = Infer({method: 'enumerate'}, model);

var model = function() {
  // Choose coin uniformly at random
  var isBiased = flip(0.5);
  var p = isBiased ? 0.9 : 0.5;

  // Flip three times
  var flip1 = flip(p);
  var flip2 = flip(p);
  var flip3 = flip(p);

  // Condition on first two flips being heads
  condition(flip1 === true && flip2 === true);

  // Return the third flip
  return flip3;
};

var ANSWER = Infer({method: 'enumerate'}, model);

var model = function() {
  // Prior: equally likely to get either coin
  var coinType = uniformDraw(['fair', 'biased']);
  
  // Likelihood of heads depends on coin type
  var pHeads = coinType === 'fair' ? 0.5 : 0.9;
  
  // Observe three heads
  observe(Bernoulli({p: pHeads}), true);
  observe(Bernoulli({p: pHeads}), true);
  observe(Bernoulli({p: pHeads}), true);
  
  return coinType;
};

var ANSWER = Infer({method: 'enumerate'}, model);

var model = function() {
  // Prior: uniformly choose between fair and biased coin
  var coinType = flip(0.5) ? 'biased' : 'fair';
  
  // Probability of heads depends on coin type
  var pHeads = coinType === 'biased' ? 0.9 : 0.5;
  
  // Flip the coin three times
  var flip1 = flip(pHeads);
  var flip2 = flip(pHeads);
  var flip3 = flip(pHeads);
  
  // Condition on observing three heads
  condition(flip1 && flip2 && flip3);
  
  return coinType;
};

var ANSWER = Infer({method: 'enumerate'}, model);

Error: sample() expected a distribution but received "false".

var model = function() {
  // Prior: uniformly choose which coin we have
  var coinType = uniformDraw(['fair', 'biased']);
  
  // Set the probability of heads based on coin type
  var p = coinType === 'fair' ? 0.5 : 0.9;
  
  // Flip the coin three times
  var flip1 = flip(p);
  var flip2 = flip(p);
  var flip3 = flip(p);
  
  // Observe that all three flips are heads
  observe(flip1 && flip2 && flip3);
  
  // Return the coin type
  return coinType;
};

var ANSWER = Infer({method: 'enumerate'}, model);

var model = function() {
  // Prior: coin type chosen uniformly at random
  var coinType = flip(0.5) ? 'biased' : 'fair';
  
  // Define probability of heads for each coin type
  var pHeads = coinType === 'biased' ? 0.9 : 0.5;
  
  // Observe three heads
  observe(Bernoulli({p: pHeads}), true);
  observe(Bernoulli({p: pHeads}), true);
  observe(Bernoulli({p: pHeads}), true);
  
  return coinType;
};

var ANSWER = Infer({method: 'enumerate'}, model);

var ANSWER = Infer({method: 'enumerate'}, function() {
  var coin = uniformDraw(['fair', 'biased']);
  var pHeads = coin === 'fair' ? 0.5 : 0.9;
  
  // Observe three heads
  observe(Binomial({p: pHeads, n: 3}), 3);
  
  return coin;
});

var ANSWER = Infer({method: 'enumerate'}, function() {
  var coinType = flip(0.5) ? 'biased' : 'fair';
  var pHeads = coinType === 'biased' ? 0.9 : 0.5;
  
  // Three flips all landed heads
  observe(Binomial({p: pHeads, n: 3}), 3);
  
  return coinType;
});

var model = function() {
  var coinType = flip(0.5) ? 'biased' : 'fair';
  var p = coinType === 'biased' ? 0.9 : 0.5;
  observe(Binomial({p: p, n: 3}), 3);
  return coinType;
};

var ANSWER = Infer({method: 'enumerate'}, model);

var model = function() {
  // Prior: choose a coin uniformly at random
  // true = biased coin (P(heads) = 0.9), false = fair coin (P(heads) = 0.5)
  var biased = flip(0.5);
  
  // Probability of heads depends on which coin
  var pHeads = biased ? 0.9 : 0.5;
  
  // Flip the coin three times
  var flip1 = flip(pHeads);
  var flip2 = flip(pHeads);
  var flip3 = flip(pHeads);
  
  // Condition on first two flips being different
  condition(flip1 !== flip2);
  
  // Return the third flip
  return flip3;
};

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

var model = function() {
  // Prior: choose a coin uniformly at random
  // true = biased coin (P(heads) = 0.9), false = fair coin (P(heads) = 0.5)
  var isBiased = flip(0.5);
  
  // Probability of heads depends on which coin
  var pHeads = isBiased ? 0.9 : 0.5;
  
  // Flip the coin three times
  var flip1 = flip(pHeads);
  var flip2 = flip(pHeads);
  var flip3 = flip(pHeads);
  
  // Condition on the first two flips being different
  condition(flip1 !== flip2);
  
  // Return the third flip
  return flip3;
};

var ANSWER = Infer({method: 'enumerate'}, model);

var model = function() {
  // Choose which coin we have (uniformly at random)
  var isBiased = flip(0.5);
  
  // Set the probability of heads based on coin type
  var pHeads = isBiased ? 0.9 : 0.5;
  
  // Flip the coin three times
  var flip1 = flip(pHeads);
  var flip2 = flip(pHeads);
  var flip3 = flip(pHeads);
  
  // Condition on first two flips being different
  condition(flip1 !== flip2);
  
  return flip3;
};

var ANSWER = Infer({method: 'enumerate'}, model);

var model = function() {
  // Choose which coin we received (true = biased coin, false = fair coin)
  var isBiased = flip(0.5);
  var p = isBiased ? 0.9 : 0.5;
  
  // Flip the coin three times
  var flip1 = flip(p);
  var flip2 = flip(p);
  var flip3 = flip(p);
  
  // Condition on observing that the first two flips were different
  condition(flip1 !== flip2);
  
  // Return the third flip (true = heads, false = tails)
  return flip3;
};

var ANSWER = Infer({method: 'enumerate'}, model);

var model = function() {
  // Choose coin uniformly at random
  var biased = flip(0.5);
  var pHeads = biased ? 0.9 : 0.5;
  
  // First two flips
  var flip1 = flip(pHeads);
  var flip2 = flip(pHeads);
  
  // Condition on first two flips being different
  condition(flip1 !== flip2);
  
  // Third flip
  var flip3 = flip(pHeads);
  
  return flip3;
};

var ANSWER = Infer({method: 'enumerate'}, model);

var model = function() {
  // Choose a coin uniformly at random
  var isBiased = flip(0.5);
  var pHeads = isBiased ? 0.9 : 0.5;

  // First two flips
  var flip1 = flip(pHeads);
  var flip2 = flip(pHeads);

  // Condition: first two flips were different
  condition(flip1 !== flip2);

  // Third flip
  var flip3 = flip(pHeads);

  return flip3;
};

var ANSWER = Infer({method: 'enumerate'}, model);

var model = function() {
  // Choose coin uniformly at random
  var isBiased = flip(0.5);
  var p = isBiased ? 0.9 : 0.5;

  // Flip three times
  var flip1 = flip(p);
  var flip2 = flip(p);
  var flip3 = flip(p);

  // Condition: first two flips were different
  condition(flip1 !== flip2);

  // Return the third flip
  return flip3;
};

var ANSWER = Infer({method: 'enumerate'}, model);

var model_original = function() {
  var lungCancer = flip(0.01);
  var cold = flip(0.2);
  var cough = (cold && flip(0.5)) || (lungCancer && flip(0.3));
  return cough;
};

var model_intervention = function() {
  var lungCancer = true;
  var cold = flip(0.2);
  var cough = (cold && flip(0.5)) || (lungCancer && flip(0.3));
  return cough;
};

var model_conditioning = function() {
  var lungCancer = flip(0.01);
  var cold = flip(0.2);
  var cough = (cold && flip(0.5)) || (lungCancer && flip(0.3));
  condition(lungCancer);
  return cough;
};

var original = Infer({method: "enumerate"}, model_original);
var intervention = Infer({method: "enumerate"}, model_intervention);
var conditioning = Infer({method: "enumerate"}, model_conditioning);

var ANSWER = {
  original: original,
  intervention: intervention,
  conditioning: conditioning
};

var model_original = function() {
  var lungCancer = flip(0.01);
  var cold = flip(0.2);
  var cough = (cold && flip(0.5)) || (lungCancer && flip(0.3));
  return cough;
};

var model_intervention = function() {
  var lungCancer = true;
  var cold = flip(0.2);
  var cough = (cold && flip(0.5)) || (lungCancer && flip(0.3));
  return cough;
};

var model_conditioning = function() {
  var lungCancer = flip(0.01);
  condition(lungCancer);
  var cold = flip(0.2);
  var cough = (cold && flip(0.5)) || (lungCancer && flip(0.3));
  return cough;
};

var original = Infer({method: 'enumerate'}, model_original);
var intervention = Infer({method: 'enumerate'}, model_intervention);
var conditioning = Infer({method: 'enumerate'}, model_conditioning);

var ANSWER = {
  original: original,
  intervention: intervention,
  conditioning: conditioning
};

var original = Infer({
  model: function() {
    var lungCancer = flip(0.01);
    var cold = flip(0.2);
    var cough = (cold && flip(0.5)) || (lungCancer && flip(0.3));
    return cough;
  }
});

var intervention = Infer({
  model: function() {
    var lungCancer = true;  // intervention: set directly
    var cold = flip(0.2);
    var cough = (cold && flip(0.5)) || (lungCancer && flip(0.3));
    return cough;
  }
});

var conditioning = Infer({
  model: function() {
    var lungCancer = flip(0.01);
    var cold = flip(0.2);
    var cough = (cold && flip(0.5)) || (lungCancer && flip(0.3));
    condition(lungCancer);  // conditioning: observe lungCancer is true
    return cough;
  }
});

var ANSWER = {
  original: original,
  intervention: intervention,
  conditioning: conditioning
};

// Original model: unconditional marginal
var originalModel = function() {
  var lungCancer = flip(0.01);
  var cold = flip(0.2);
  var cough = (cold && flip(0.5)) || (lungCancer && flip(0.3));
  return cough;
};

// Intervention: set lungCancer = true directly
var interventionModel = function() {
  var lungCancer = true;
  var cold = flip(0.2);
  var cough = (cold && flip(0.5)) || (lungCancer && flip(0.3));
  return cough;
};

// Conditioning: use condition() to enforce lungCancer = true
var conditioningModel = function() {
  var lungCancer = flip(0.01);
  condition(lungCancer);
  var cold = flip(0.2);
  var cough = (cold && flip(0.5)) || (lungCancer && flip(0.3));
  return cough;
};

var original = Infer({method: 'enumerate'}, originalModel);
var intervention = Infer({method: 'enumerate'}, interventionModel);
var conditioning = Infer({method: 'enumerate'}, conditioningModel);

var ANSWER = {
  original: original,
  intervention: intervention,
  conditioning: conditioning
};

var model_original = function() {
  var lungCancer = flip(0.01);
  var cold = flip(0.2);
  var cough = (cold && flip(0.5)) || (lungCancer && flip(0.3));
  return cough;
};

var model_intervention = function() {
  var lungCancer = true; // intervene: set directly
  var cold = flip(0.2);
  var cough = (cold && flip(0.5)) || (lungCancer && flip(0.3));
  return cough;
};

var model_conditioning = function() {
  var lungCancer = flip(0.01);
  var cold = flip(0.2);
  var cough = (cold && flip(0.5)) || (lungCancer && flip(0.3));
  condition(lungCancer === true);
  return cough;
};

var original = Infer({ method: 'enumerate' }, model_original);
var intervention = Infer({ method: 'enumerate' }, model_intervention);
var conditioning = Infer({ method: 'enumerate' }, model_conditioning);

var ANSWER = {
  original: original,
  intervention: intervention,
  conditioning: conditioning
};

var original = Infer({method: 'enumerate'}, function() {
  var lungCancer = flip(0.01);
  var cold = flip(0.2);
  var cough = (cold && flip(0.5)) || (lungCancer && flip(0.3));
  return cough;
});

var intervention = Infer({method: 'enumerate'}, function() {
  var lungCancer = true; // do(lungCancer = true)
  var cold = flip(0.2);
  var cough = (cold && flip(0.5)) || (lungCancer && flip(0.3));
  return cough;
});

var conditioning = Infer({method: 'enumerate'}, function() {
  var lungCancer = flip(0.01);
  var cold = flip(0.2);
  var cough = (cold && flip(0.5)) || (lungCancer && flip(0.3));
  condition(lungCancer === true); // observe lungCancer = true
  return cough;
});

var ANSWER = {
  original: original,
  intervention: intervention,
  conditioning: conditioning
};

var original = Infer({method: 'enumerate'}, function() {
  var lungCancer = flip(0.01);
  var cold = flip(0.2);
  var cough = (cold && flip(0.5)) || (lungCancer && flip(0.3));
  return cough;
});

var intervention = Infer({method: 'enumerate'}, function() {
  var lungCancer = true; // do(lungCancer = true): set directly, ignore prior
  var cold = flip(0.2);
  var cough = (cold && flip(0.5)) || (lungCancer && flip(0.3));
  return cough;
});

var conditioning = Infer({method: 'enumerate'}, function() {
  var lungCancer = flip(0.01);
  var cold = flip(0.2);
  var cough = (cold && flip(0.5)) || (lungCancer && flip(0.3));
  condition(lungCancer); // observe lungCancer === true
  return cough;
});

var ANSWER = {
  original: original,
  intervention: intervention,
  conditioning: conditioning
};

var model_original = function() {
  var lungCancer = flip(0.01);
  var cold = flip(0.2);
  var cough = (cold && flip(0.5)) || (lungCancer && flip(0.3));
  return lungCancer;
};

var model_intervention = function() {
  var lungCancer = flip(0.01);
  var cold = flip(0.2);
  var cough = true;
  return lungCancer;
};

var model_conditioning = function() {
  var lungCancer = flip(0.01);
  var cold = flip(0.2);
  var cough = (cold && flip(0.5)) || (lungCancer && flip(0.3));
  condition(cough);
  return lungCancer;
};

var ANSWER = {
  original: Infer({method: "enumerate"}, model_original),
  intervention: Infer({method: "enumerate"}, model_intervention),
  conditioning: Infer({method: "enumerate"}, model_conditioning)
};

var ANSWER = {
  original: Infer({method: 'enumerate'}, function() {
    var lungCancer = flip(0.01);
    var cold = flip(0.2);
    var cough = (cold && flip(0.5)) || (lungCancer && flip(0.3));
    return lungCancer;
  }),
  
  intervention: Infer({method: 'enumerate'}, function() {
    var lungCancer = flip(0.01);
    var cold = flip(0.2);
    var cough = true;  // intervene: set cough directly
    return lungCancer;
  }),
  
  conditioning: Infer({method: 'enumerate'}, function() {
    var lungCancer = flip(0.01);
    var cold = flip(0.2);
    var cough = (cold && flip(0.5)) || (lungCancer && flip(0.3));
    condition(cough);  // condition on observing cough = true
    return lungCancer;
  })
};

var original = Infer({method: 'enumerate'}, function() {
  var lungCancer = flip(0.01);
  var cold = flip(0.2);
  var cough = (cold && flip(0.5)) || (lungCancer && flip(0.3));
  return lungCancer;
});

var intervention = Infer({method: 'enumerate'}, function() {
  var lungCancer = flip(0.01);
  var cold = flip(0.2);
  var cough = true;  // Direct intervention: set cough to true
  return lungCancer;
});

var conditioning = Infer({method: 'enumerate'}, function() {
  var lungCancer = flip(0.01);
  var cold = flip(0.2);
  var cough = (cold && flip(0.5)) || (lungCancer && flip(0.3));
  condition(cough);  // Condition on observing cough = true
  return lungCancer;
});

var ANSWER = {
  original: original,
  intervention: intervention,
  conditioning: conditioning
};

var model_original = function() {
  var lungCancer = flip(0.01);
  var cold = flip(0.2);
  var cough = (cold && flip(0.5)) || (lungCancer && flip(0.3));
  return lungCancer;
};

var model_intervention = function() {
  var lungCancer = flip(0.01);
  var cold = flip(0.2);
  var cough = true;
  return lungCancer;
};

var model_conditioning = function() {
  var lungCancer = flip(0.01);
  var cold = flip(0.2);
  var cough = (cold && flip(0.5)) || (lungCancer && flip(0.3));
  condition(cough);
  return lungCancer;
};

var original = Infer({method: 'enumerate'}, model_original);
var intervention = Infer({method: 'enumerate'}, model_intervention);
var conditioning = Infer({method: 'enumerate'}, model_conditioning);

var ANSWER = {
  original: original,
  intervention: intervention,
  conditioning: conditioning
};

var original = Infer({method: 'enumerate'}, function() {
  var lungCancer = flip(0.01);
  var cold = flip(0.2);
  var cough = (cold && flip(0.5)) || (lungCancer && flip(0.3));
  return lungCancer;
});

var intervention = Infer({method: 'enumerate'}, function() {
  var lungCancer = flip(0.01);
  var cold = flip(0.2);
  var cough = true; // intervention: set cough = true directly
  return lungCancer;
});

var conditioning = Infer({method: 'enumerate'}, function() {
  var lungCancer = flip(0.01);
  var cold = flip(0.2);
  var cough = (cold && flip(0.5)) || (lungCancer && flip(0.3));
  condition(cough);
  return lungCancer;
});

var ANSWER = {
  original: original,
  intervention: intervention,
  conditioning: conditioning
};

var original = Infer({method: 'enumerate'}, function() {
  var lungCancer = flip(0.01);
  var cold = flip(0.2);
  var cough = (cold && flip(0.5)) || (lungCancer && flip(0.3));
  return lungCancer;
});

var intervention = Infer({method: 'enumerate'}, function() {
  var lungCancer = flip(0.01);
  var cold = flip(0.2);
  var cough = true; // do(cough = true): cut the causal links, set directly
  return lungCancer;
});

var conditioning = Infer({method: 'enumerate'}, function() {
  var lungCancer = flip(0.01);
  var cold = flip(0.2);
  var cough = (cold && flip(0.5)) || (lungCancer && flip(0.3));
  condition(cough);
  return lungCancer;
});

var ANSWER = {
  original: original,
  intervention: intervention,
  conditioning: conditioning
};

var originalModel = function() {
  var lungCancer = flip(0.01);
  var cold = flip(0.2);
  var cough = (cold && flip(0.5)) || (lungCancer && flip(0.3));
  return lungCancer;
};

var interventionModel = function() {
  var lungCancer = flip(0.01);
  var cold = flip(0.2);
  // do-operator: cough is set directly, severing its causal parents
  var cough = true;
  return lungCancer;
};

var conditioningModel = function() {
  var lungCancer = flip(0.01);
  var cold = flip(0.2);
  var cough = (cold && flip(0.5)) || (lungCancer && flip(0.3));
  condition(cough);
  return lungCancer;
};

var ANSWER = {
  original:      Infer({method: 'enumerate'}, originalModel),
  intervention:  Infer({method: 'enumerate'}, interventionModel),
  conditioning:  Infer({method: 'enumerate'}, conditioningModel)
};

var extendedSmilesModel = function() {
  var nice = mem(function(person) { flip(.7) });
  
  var wantsSmth = function(person) {
    return nice(person) ? flip(.2) : flip(.5);
  };
  
  var smiles = function(person) {
    var isNice = nice(person);
    var wants = wantsSmth(person);
    
    if (isNice && wants) {
      return flip(.8);
    } else if (isNice && !wants) {
      return flip(.8);
    } else if (!isNice && wants) {
      return flip(.8);
    } else {
      return flip(.5);
    }
  };
  
  condition(smiles('alice') && smiles('bob') && smiles('alice'));
  return smiles('alice');
};

var ANSWER = Infer({method: 'enumerate'}, extendedSmilesModel);

var extendedSmilesModel = function() {
  var nice = mem(function(person) { flip(.7) });
  
  var wants = function(person) {
    return nice(person) ? flip(.2) : flip(.5);
  };
  
  var smiles = function(person) {
    var isNice = nice(person);
    var doesWant = wants(person);
    
    if (isNice && doesWant) {
      return flip(.8);
    } else if (isNice && !doesWant) {
      return flip(.8);
    } else if (!isNice && doesWant) {
      return flip(.8);
    } else {
      return flip(.5);
    }
  };
  
  condition(smiles('alice') && smiles('bob') && smiles('alice'));
  return smiles('alice');
};

var ANSWER = Infer({method: 'enumerate'}, extendedSmilesModel);

var extendedSmilesModel = function() {
  var nice = mem(function(person) { flip(.7) });
  
  var wantsSmth = function(person) {
    return nice(person) ? flip(.2) : flip(.5);
  }
  
  var smiles = function(person) {
    var n = nice(person);
    var wants = wantsSmth(person);
    
    if (n && wants) {
      return flip(.8);
    } else if (n && !wants) {
      return flip(.7);
    } else if (!n && wants) {
      return flip(.8);
    } else {
      return flip(.5);
    }
  }
  
  condition(smiles('alice') && smiles('bob') && smiles('alice'));
  return smiles('alice');
}

var ANSWER = Infer({method: 'enumerate'}, extendedSmilesModel);

var extendedSmilesModel = function() {
  var nice = mem(function(person) { flip(.7) });
  
  var wants = mem(function(person) { 
    var isNice = nice(person);
    return isNice ? flip(.2) : flip(.5);
  });
  
  var smiles = function(person) {
    var isNice = nice(person);
    var personWants = wants(person);
    
    // Combine niceness and wanting factors
    // Base: 0.5, +0.3 if nice, +0.3 if wants something
    var smileProb = 0.5 + (isNice ? 0.3 : 0) + (personWants ? 0.3 : 0);
    var cappedProb = Math.min(smileProb, 0.99);
    
    return flip(cappedProb);
  };
  
  condition(smiles('alice') && smiles('bob') && smiles('alice'));
  return smiles('alice');
};

var ANSWER = Infer({method: 'enumerate'}, extendedSmilesModel);

var extendedSmilesModel = function() {
  var nice = mem(function(person) { flip(.7) });
  
  var wantsSomething = function(person) {
    return nice(person) ? flip(.2) : flip(.5);
  };
  
  var smiles = function(person) {
    var wants = wantsSomething(person);
    if (nice(person)) {
      return wants ? flip(.8) : flip(.8);
    } else {
      return wants ? flip(.8) : flip(.5);
    }
  };
  
  condition(smiles('alice') && smiles('bob') && smiles('alice'));
  
  return smiles('alice');
};

var ANSWER = Infer({method: 'enumerate'}, extendedSmilesModel);

var extendedSmilesModel = function() {
  // Niceness is a stable property of a person
  var nice = mem(function(person) { return flip(.7); });

  // Whether someone wants something can vary (not memoized by default call)
  var wantsSomething = function(person) {
    return nice(person) ? flip(.2) : flip(.5);
  };

  // Smile probability depends on both niceness and wanting something.
  // Nice people smile more often regardless of whether they want something.
  // Wanting something increases smiling to 80% (vs 50% otherwise).
  var smiles = function(person) {
    var isNice = nice(person);
    var wants = wantsSomething(person);
    if (isNice && wants)   { return flip(.9); }  // nice + wants: highest
    if (isNice && !wants)  { return flip(.8); }  // nice alone: still high
    if (!isNice && wants)  { return flip(.8); }  // wanting alone: 80%
    return flip(.5);                              // baseline
  };

  condition(smiles('alice') && smiles('bob') && smiles('alice'));

  // Return whether Alice smiles today
  return smiles('alice');
};

var ANSWER = Infer({method: 'enumerate'}, extendedSmilesModel);

var extendedSmilesModel = function() {
  // Niceness is a stable property of a person
  var nice = mem(function(person) { return flip(.7); });

  // Wanting something can vary each time (not memoized)
  var wantsSomething = function(person) {
    return nice(person) ? flip(.2) : flip(.5);
  };

  // Smiling depends on both niceness and wanting something
  // Nice people smile more regardless of wanting, wanting also boosts smiling
  var smiles = function(person) {
    var isNice = nice(person);
    var wants = wantsSomething(person);
    return isNice  && wants  ? flip(.9) :   // nice + wants: both boost smiling
           isNice  && !wants ? flip(.8) :   // nice alone keeps it high
           !isNice && wants  ? flip(.8) :   // wanting alone keeps it high
                               flip(.5);    // neither: baseline
  };

  condition(smiles('alice') && smiles('bob') && smiles('alice'));
  return smiles('alice');
};

var ANSWER = Infer({method: 'enumerate'}, extendedSmilesModel);

Error: sample() expected a distribution but received "true".

var extendedSmilesModel = function() {
  var nice = mem(function(person) { flip(.7) });
  var wantsSomething = function(person) {
    return flip(nice(person) ? .2 : .5);
  }
  var smiles = function(person, wants) {
    return (wants ? flip(.8) : flip(.5))
            || (nice(person) ? flip(.8) : flip(.5));
  }
  
  // Observe Bob not smiling five times this week
  observe(smiles("Bob", wantsSomething("Bob")) === false);
  observe(smiles("Bob", wantsSomething("Bob")) === false);
  observe(smiles("Bob", wantsSomething("Bob")) === false);
  observe(smiles("Bob", wantsSomething("Bob")) === false);
  observe(smiles("Bob", wantsSomething("Bob")) === false);
  
  // Today, Bob wants something or not (fresh sample for today)
  var todayWants = flip(nice("Bob") ? .2 : .5);
  
  // Observe Bob smiling today
  observe(smiles("Bob", todayWants) === true);
  
  return todayWants;
}

var ANSWER = Infer({method: 'enumerate'}, extendedSmilesModel);

Error: All paths explored by Enumerate have probability zero.

var extendedSmilesModel = function() {
  var nice = mem(function(person) { flip(.7) });
  var wantsSomething = function(person) {
    return flip(nice(person) ? .2 : .5);
  }
  var smiles = function(person, wants) {
    return (wants ? flip(.8) : flip(.5))
            || (nice(person) ? flip(.8) : flip(.5));
  }
  
  // Observe Bob not smiling five times
  var bob_nice = nice("Bob");
  repeat(5, function() {
    var bob_wants = wantsSomething("Bob");
    var bob_smiles = smiles("Bob", bob_wants);
    observe(Bernoulli({p: bob_smiles ? 1 : 0}), 0);
  });
  
  // Today: observe Bob smiling and infer if he wants something
  var bob_wants_today = wantsSomething("Bob");
  var bob_smiles_today = smiles("Bob", bob_wants_today);
  observe(Bernoulli({p: bob_smiles_today ? 1 : 0}), 1);
  
  return bob_wants_today;
};

var ANSWER = Infer({method: 'enumerate'}, extendedSmilesModel);

Error: cpsInnerStatement

var extendedSmilesModel = function() {
  var nice = mem(function(person) { flip(.7) });
  var wantsSomething = function(person) {
    return flip(nice(person) ? .2 : .5);
  }
  var smiles = function(person, wants) {
    return (wants ? flip(.8) : flip(.5))
            || (nice(person) ? flip(.8) : flip(.5));
  }
  
  // Condition on 5 days of not smiling
  for (var i = 0; i < 5; i++) {
    var wants = wantsSomething("Bob");
    var didSmile = smiles("Bob", wants);
    condition(!didSmile);
  }
  
  // Today: condition on smiling
  var wantsToday = wantsSomething("Bob");
  var smilesToday = smiles("Bob", wantsToday);
  condition(smilesToday);
  
  return wantsToday;
}

var ANSWER = Infer({method: 'enumerate'}, extendedSmilesModel);

var extendedSmilesModel = function() {
  var nice = mem(function(person) { flip(.7) });
  var wantsSomething = function(person) {
    return flip(nice(person) ? .2 : .5);
  }
  var smiles = function(person, wants) {
    return (wants ? flip(.8) : flip(.5))
            || (nice(person) ? flip(.8) : flip(.5));
  }
  
  // Condition on Bob not smiling 5 times in the past
  repeat(5, function() {
    var wantsThatDay = wantsSomething('Bob');
    var smilesThatDay = smiles('Bob', wantsThatDay);
    condition(!smilesThatDay);
  });
  
  // Today: Bob wants something?
  var todayWants = wantsSomething('Bob');
  var todaySmiles = smiles('Bob', todayWants);
  
  // Condition on Bob smiling today
  condition(todaySmiles);
  
  // Return whether Bob wants something today
  return todayWants;
};

var ANSWER = Infer({method: 'enumerate'}, extendedSmilesModel);

var extendedSmilesModel = function() {
  var nice = mem(function(person) { flip(.7) });
  var wantsSomething = function(person) {
    return flip(nice(person) ? .2 : .5);
  };
  var smiles = function(person, wants) {
    return (wants ? flip(.8) : flip(.5))
            || (nice(person) ? flip(.8) : flip(.5));
  };

  // Condition on Bob not smiling 5 times this week
  var bobNice = nice('bob');
  map(function(i) {
    var wants = wantsSomething('bob');
    condition(!smiles('bob', wants));
  }, [1,2,3,4,5]);

  // Today Bob is smiling - compute posterior that he wants something
  var wantsToday = wantsSomething('bob');
  condition(smiles('bob', wantsToday));

  return wantsToday;
};

var ANSWER = Infer({method: 'enumerate'}, extendedSmilesModel);

var extendedSmilesModel = function() {
  var nice = mem(function(person) { flip(.7) });

  var wantsSomething = function(person) {
    return flip(nice(person) ? .2 : .5);
  };

  var smiles = function(person, wants) {
    return (wants ? flip(.8) : flip(.5))
            || (nice(person) ? flip(.8) : flip(.5));
  };

  // Bob's niceness is stable (memoized).
  // Each past day, "wants" is a fresh sample (not memoized).

  // Day 1 – not smiling
  var w1 = wantsSomething('bob');
  condition(!smiles('bob', w1));

  // Day 2 – not smiling
  var w2 = wantsSomething('bob');
  condition(!smiles('bob', w2));

  // Day 3 – not smiling
  var w3 = wantsSomething('bob');
  condition(!smiles('bob', w3));

  // Day 4 – not smiling
  var w4 = wantsSomething('bob');
  condition(!smiles('bob', w4));

  // Day 5 – not smiling
  var w5 = wantsSomething('bob');
  condition(!smiles('bob', w5));

  // Today – smiling; query whether he wants something
  var wantsToday = wantsSomething('bob');
  condition(smiles('bob', wantsToday));

  return wantsToday;
};

var ANSWER = Infer({method: 'enumerate'}, extendedSmilesModel);

var extendedSmilesModel = function() {
  var nice = mem(function(person) { flip(.7) });
  var wantsSomething = function(person) {
    return flip(nice(person) ? .2 : .5);
  };
  var smiles = function(person, wants) {
    return (wants ? flip(.8) : flip(.5))
            || (nice(person) ? flip(.8) : flip(.5));
  };

  // Condition on Bob NOT smiling on each of the 5 previous days.
  // Each day is independent (wants varies day-to-day; nice is memoized/stable).
  map(function(day) {
    var wantsPast = wantsSomething('bob');
    var smiledPast = smiles('bob', wantsPast);
    condition(!smiledPast);
  }, _.range(5));

  // Today Bob IS smiling — infer whether he wants something.
  var wantsToday = wantsSomething('bob');
  var smiledToday = smiles('bob', wantsToday);
  condition(smiledToday);

  return wantsToday;
};

var ANSWER = Infer({method: 'enumerate'}, extendedSmilesModel);

TypeError: dist.score is not a function

var model = function() {
  var sprinkler = flip(0.5);
  var rain = flip(0.3);
  var lawn_wet = sprinkler || rain;
  
  observe(lawn_wet, true);
  
  return {
    sprinkler: sprinkler,
    rain: rain
  };
};

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

var rain_dist = Infer({method: "enumerate"}, function() {
  var s = sample(posterior);
  return s.rain;
});

var sprinkler_dist = Infer({method: "enumerate"}, function() {
  var s = sample(posterior);
  return s.sprinkler;
});

var ANSWER = {
  rain: rain_dist,
  sprinkler: sprinkler_dist
};

Error: All paths explored by Enumerate have probability zero.

var model = function() {
  var sprinkler = flip(0.5);
  var rain = flip(0.3);
  var lawn_wet = sprinkler || rain;
  
  observe(Bernoulli({p: lawn_wet ? 1 : 0}), 1);
  
  return {sprinkler: sprinkler, rain: rain};
};

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

var rain_marginal = Infer({method: 'enumerate'}, function() {
  var s = sample(posterior);
  return s.rain;
});

var sprinkler_marginal = Infer({method: 'enumerate'}, function() {
  var s = sample(posterior);
  return s.sprinkler;
});

var ANSWER = {
  rain: rain_marginal,
  sprinkler: sprinkler_marginal
};

var model = function() {
  var sprinkler = flip(0.5);
  var rain = flip(0.3);
  var wet = sprinkler || rain;
  
  condition(wet);
  
  return {sprinkler: sprinkler, rain: rain};
};

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

var ANSWER = {
  rain: marginalize(posterior, 'rain'),
  sprinkler: marginalize(posterior, 'sprinkler')
};

var sprinklerDist = Infer({method: 'enumerate'}, function() {
  var sprinkler = flip(0.5);
  var rain = flip(0.3);
  var wet = sprinkler || rain;
  condition(wet);
  return sprinkler;
});

var rainDist = Infer({method: 'enumerate'}, function() {
  var sprinkler = flip(0.5);
  var rain = flip(0.3);
  var wet = sprinkler || rain;
  condition(wet);
  return rain;
});

var ANSWER = {
  sprinkler: sprinklerDist,
  rain: rainDist
};

var model = function() {
  var rain = flip(0.3);
  var sprinkler = flip(0.5);
  var wet = rain || sprinkler;
  condition(wet);
  return { rain: rain, sprinkler: sprinkler };
};

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

var rainDist = marginalize(posterior, function(x) { return x.rain; });
var sprinklerDist = marginalize(posterior, function(x) { return x.sprinkler; });

var ANSWER = { rain: rainDist, sprinkler: sprinklerDist };

var model = function() {
  var rained = flip(0.3);
  var sprinkler = flip(0.5);
  var wet = rained || sprinkler;
  condition(wet);
  return { rain: rained, sprinkler: sprinkler };
};

var result = Infer({ method: 'enumerate' }, model);

var rainDist = marginalize(result, function(x) { return x.rain; });
var sprinklerDist = marginalize(result, function(x) { return x.sprinkler; });

var ANSWER = { rain: rainDist, sprinkler: sprinklerDist };

var model = function() {
  var rained = flip(0.3);
  var sprinkler = flip(0.5);
  var wet = rained || sprinkler;
  condition(wet);
  return { rained: rained, sprinkler: sprinkler };
};

var joint = Infer({ method: 'enumerate' }, model);

var rainDist = Infer({ method: 'enumerate' }, function() {
  var s = sample(joint);
  return s.rained;
});

var sprinklerDist = Infer({ method: 'enumerate' }, function() {
  var s = sample(joint);
  return s.sprinkler;
});

var ANSWER = { rain: rainDist, sprinkler: sprinklerDist };

var model = function() {
  // Prior: it rained this morning with probability 0.3
  var rained = flip(0.3);
  
  // My sprinkler turns on with probability 0.5
  var mySprinkerOn = flip(0.5);
  
  // My lawn is wet if sprinkler is on OR it rained
  var myLawnWet = mySprinkerOn || rained;
  
  // Kelsey's sprinkler turns on with probability 0.5 (independent)
  var kelseySprinkerOn = flip(0.5);
  
  // Kelsey's lawn is wet if her sprinkler is on OR it rained
  var kelseyLawnWet = kelseySprinkerOn || rained;
  
  // Condition on observing both lawns wet
  condition(myLawnWet && kelseyLawnWet);
  
  return rained;
};

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

var model = function() {
  // Prior: it rained this morning with probability 0.3
  var rained = flip(0.3);
  
  // My sprinkler turns on with probability 0.5
  var mySprinkerOn = flip(0.5);
  
  // Kelsey's sprinkler turns on with probability 0.5 (independent)
  var kelseysSprinkerOn = flip(0.5);
  
  // My lawn is wet if sprinkler is on OR it rained
  var myLawnWet = mySprinkerOn || rained;
  
  // Kelsey's lawn is wet if her sprinkler is on OR it rained
  var kelseysLawnWet = kelseysSprinkerOn || rained;
  
  // Observe that both lawns are wet
  condition(myLawnWet && kelseysLawnWet);
  
  return rained;
};

var ANSWER = Infer({method: 'enumerate'}, model);

var model = function() {
  var rain = flip(0.3);
  var sprinkler_mine = flip(0.5);
  var sprinkler_kelsey = flip(0.5);
  
  var my_lawn_wet = sprinkler_mine || rain;
  var kelsey_lawn_wet = sprinkler_kelsey || rain;
  
  condition(my_lawn_wet && kelsey_lawn_wet);
  
  return rain;
};

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

var model = function() {
  var rained = flip(0.3);
  var mySprinkler = flip(0.5);
  var kelsey_sprinkler = flip(0.5);
  
  var my_lawn_wet = mySprinkler || rained;
  var kelsey_lawn_wet = kelsey_sprinkler || rained;
  
  condition(my_lawn_wet && kelsey_lawn_wet);
  
  return rained;
};

var ANSWER = Infer({method: 'enumerate'}, model);

var model = function() {
  var rain = flip(0.3);
  var sprinkler = flip(0.5);
  var kelseySprinkler = flip(0.5);
  
  var myLawnWet = rain || sprinkler;
  var kelseyLawnWet = rain || kelseySprinkler;
  
  condition(myLawnWet && kelseyLawnWet);
  
  return rain;
};

var ANSWER = Infer({method: 'enumerate'}, model);

var model = function() {
  var rain = flip(0.3);
  var sprinkler = flip(0.5);
  var kelseySprinkler = flip(0.5);

  var myLawnWet = rain || sprinkler;
  var kelseyLawnWet = rain || kelseySprinkler;

  condition(myLawnWet && kelseyLawnWet);

  return rain;
};

var ANSWER = Infer({ method: 'enumerate' }, model);

var model = function() {
  var rain = flip(0.3);
  var mySprinkler = flip(0.5);
  var kelseySprinkler = flip(0.5);

  var myLawnWet = rain || mySprinkler;
  var kelseyLawnWet = rain || kelseySprinkler;

  condition(myLawnWet && kelseyLawnWet);

  return rain;
};

var ANSWER = Infer({method: 'enumerate'}, model);

var sprinklerProb = 0.5;
var rainProb = 0.3;

var model = function() {
  var rain = flip(rainProb);
  
  var sprinkler = mem(function(person) {
    return flip(sprinklerProb);
  });
  
  var lawns = ["me", "Kelsey", "Kevin", "Manu", "Josh"];
  
  var lawnWet = function(person) {
    return rain || sprinkler(person);
  };
  
  // Condition on all lawns being wet
  mapData({data: lawns}, function(person) {
    condition(lawnWet(person));
  });
  
  return rain;
};

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

Error: All paths explored by Enumerate have probability zero.

var model = function() {
  // Whether it rained this morning
  var rained = flip(0.3);
  
  // Each person's sprinkler (memoized so each person has independent sprinkler)
  var sprinkler = mem(function(person) {
    return flip(0.5);
  });
  
  // Each person's lawn is wet if sprinkler OR rain
  var lawnWet = function(person) {
    return sprinkler(person) || rained;
  };
  
  // Observe that all five lawns are wet
  var people = ["me", "Kelsey", "Kevin", "Manu", "Josh"];
  mapData({data: people}, function(person) {
    observe(Bernoulli({p: 1.0}), lawnWet(person) ? 1 : 0);
  });
  
  return rained;
};

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

var model = function() {
  // Prior: it rains with probability 0.3
  var rained = flip(0.3);
  
  // Memoized function so each person's sprinkler is independent
  var getSprinkler = mem(function(person) {
    return flip(0.5);
  });
  
  // List of five people
  var people = ["me", "Kelsey", "Kevin", "Manu", "Josh"];
  
  // Observe that all five lawns are wet
  people.forEach(function(person) {
    var sprinklerOn = getSprinkler(person);
    var lawnWet = sprinklerOn || rained;
    condition(lawnWet);
  });
  
  return rained;
};

var ANSWER = Infer({model: model});

var model = function() {
  // Prior: did it rain this morning?
  var rained = flip(0.3);
  
  // Each person's sprinkler (independent, p=0.5)
  // Using mem so each person's sprinkler state is constant within a run
  var sprinkler = mem(function(person) {
    return flip(0.5);
  });
  
  var people = ["me", "Kelsey", "Kevin", "Manu", "Josh"];
  
  // Condition on all lawns being wet
  mapData({data: people}, function(person) {
    var sprinklerOn = sprinkler(person);
    var lawWet = sprinklerOn || rained;
    condition(lawWet);
  });
  
  return rained;
};

var ANSWER = Infer({method: 'enumerate'}, model);

var model = function() {
  var rained = flip(0.3);
  
  var sprinklerOn = mem(function(person) {
    return flip(0.5);
  });
  
  var lawnWet = function(person) {
    return sprinklerOn(person) || rained;
  };
  
  var people = ["me", "Kelsey", "Kevin", "Manu", "Josh"];
  
  map(function(person) {
    condition(lawnWet(person));
  }, people);
  
  return rained;
};

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

var model = function() {
  var rained = flip(0.3);

  var sprinklerOn = mem(function(person) {
    return flip(0.5);
  });

  var isWet = function(person) {
    return sprinklerOn(person) || rained;
  };

  var people = ["me", "Kelsey", "Kevin", "Manu", "Josh"];

  map(function(person) {
    condition(isWet(person));
  }, people);

  return rained;
};

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

var model = function() {
  var rained = flip(0.3);

  var sprinklerOn = mem(function(person) {
    return flip(0.5);
  });

  var lawnWet = function(person) {
    return sprinklerOn(person) || rained;
  };

  var people = ["me", "Kelsey", "Kevin", "Manu", "Josh"];

  map(function(person) {
    condition(lawnWet(person));
  }, people);

  return rained;
};

var ANSWER = Infer({method: 'enumerate'}, model);

var checkVowel = function(letter) { _.includes(['a', 'e', 'i', 'o', 'u'], letter) };
var letterVals = ['g', 'a', 'm', 'e'];
var letterProbs = map(function(letter) { checkVowel(letter) ? 0.45 : 0.05 }, letterVals);
var letters = Categorical({vs: letterVals, ps: letterProbs});

var ANSWER = Infer({method: 'enumerate'}, function() {
  var letter = sample(letters);
  var position = letterVals.indexOf(letter) + 1;
  var winProb = 1 / Math.pow(position, 2);
  condition(flip(winProb));
  return letter;
});

var checkVowel = function(letter) { _.includes(['a', 'e', 'i', 'o', 'u'], letter) };
var letterVals = ['g', 'a', 'm', 'e'];
var letterProbs = map(function(letter) { checkVowel(letter) ? 0.45 : 0.05 }, letterVals);
var letters = Categorical({vs: letterVals, ps: letterProbs});

var ANSWER = Infer({method: 'enumerate'}, function() {
  var letter = sample(letters);
  var position = letterVals.indexOf(letter) + 1;
  var winProb = 1 / Math.pow(position, 2);
  condition(flip(winProb));
  return letter;
});

var checkVowel = function(letter) { _.includes(['a', 'e', 'i', 'o', 'u'], letter) };
var letterVals = ['g', 'a', 'm', 'e'];
var letterProbs = map(function(letter) { checkVowel(letter) ? 0.45 : 0.05 }, letterVals);
var letters = Categorical({vs: letterVals, ps: letterProbs});

var ANSWER = Infer({method: 'enumerate'}, function() {
  var letter = sample(letters);
  var position = letterVals.indexOf(letter) + 1;
  var winProb = 1 / Math.pow(position, 2);
  condition(flip(winProb));
  return letter;
});

var checkVowel = function(letter) { _.includes(['a', 'e', 'i', 'o', 'u'], letter) };
var letterVals = ['g', 'a', 'm', 'e'];
var letterProbs = map(function(letter) { checkVowel(letter) ? 0.45 : 0.05 }, letterVals);
var letters = Categorical({vs: letterVals, ps: letterProbs});

var ANSWER = Infer({method: 'enumerate'}, function() {
  var letter = sample(letters);
  var position = letterVals.indexOf(letter) + 1;
  var winProb = 1 / Math.pow(position, 2);
  condition(flip(winProb));
  return letter;
});

var checkVowel = function(letter) { _.includes(['a', 'e', 'i', 'o', 'u'], letter) };
var letterVals = ['g', 'a', 'm', 'e'];
var letterProbs = map(function(letter) { checkVowel(letter) ? 0.45 : 0.05 }, letterVals);
var letters = Categorical({vs: letterVals, ps: letterProbs});

var ANSWER = Infer({method: 'enumerate'}, function() {
  var letter = sample(letters);
  var position = letterVals.indexOf(letter) + 1;
  var winProb = 1 / Math.pow(position, 2);
  condition(flip(winProb));
  return letter;
});

var checkVowel = function(letter) { _.includes(['a', 'e', 'i', 'o', 'u'], letter) };
var letterVals = ['g', 'a', 'm', 'e'];
var letterProbs = map(function(letter) { checkVowel(letter) ? 0.45 : 0.05 }, letterVals);
var letters = Categorical({vs: letterVals, ps: letterProbs});

var ANSWER = Infer({method: 'enumerate'}, function() {
  var letter = sample(letters);
  var position = letterVals.indexOf(letter) + 1;
  var winProb = 1 / Math.pow(position, 2);
  condition(flip(winProb));
  return letter;
});

var checkVowel = function(letter) { _.includes(['a', 'e', 'i', 'o', 'u'], letter) };
var letterVals = ['g', 'a', 'm', 'e'];
var letterProbs = map(function(letter) { checkVowel(letter) ? 0.45 : 0.05 }, letterVals);
var letters = Categorical({vs: letterVals, ps: letterProbs});

var ANSWER = Infer({method: 'enumerate'}, function() {
  var letter = sample(letters);
  var position = letterVals.indexOf(letter) + 1;
  var winProb = 1 / Math.pow(position, 2);
  condition(flip(winProb));
  return letter;
});

var checkVowel = function(letter) { _.includes(['a', 'e', 'i', 'o', 'u'], letter) };
var letterVals = ['g', 'a', 'm', 'e'];
var letterProbs = map(function(letter) { checkVowel(letter) ? 0.45 : 0.05 }, letterVals);
var letters = Categorical({vs: letterVals, ps: letterProbs});

var ANSWER = Infer({method: 'enumerate'}, function() {
  var letter = sample(letters);
  var position = letterVals.indexOf(letter) + 1;
  var winProb = 1 / Math.pow(position, 2);
  condition(flip(winProb));
  return checkVowel(letter) ? 'vowel' : 'consonant';
});

var checkVowel = function(letter) { _.includes(['a', 'e', 'i', 'o', 'u'], letter) };
var letterVals = ['g', 'a', 'm', 'e'];
var letterProbs = map(function(letter) { checkVowel(letter) ? 0.45 : 0.05 }, letterVals);
var letters = Categorical({vs: letterVals, ps: letterProbs});

var ANSWER = Infer({method: 'enumerate'}, function() {
  var letter = sample(letters);
  var position = letterVals.indexOf(letter) + 1;
  var winProb = 1 / Math.pow(position, 2);
  condition(flip(winProb));
  var isVowel = checkVowel(letter);
  return isVowel ? 'vowel' : 'consonant';
});

var checkVowel = function(letter) { _.includes(['a', 'e', 'i', 'o', 'u'], letter) };
var letterVals = ['g', 'a', 'm', 'e'];
var letterProbs = map(function(letter) { checkVowel(letter) ? 0.45 : 0.05 }, letterVals);
var letters = Categorical({vs: letterVals, ps: letterProbs});

var ANSWER = Infer({method: 'enumerate'}, function() {
  var letter = sample(letters);
  var position = letterVals.indexOf(letter) + 1;
  var winProb = 1 / Math.pow(position, 2);
  condition(sample(Bernoulli({p: winProb})));
  return checkVowel(letter) ? 'vowel' : 'consonant';
});

var checkVowel = function(letter) { _.includes(['a', 'e', 'i', 'o', 'u'], letter) };
var letterVals = ['g', 'a', 'm', 'e'];
var letterProbs = map(function(letter) { checkVowel(letter) ? 0.45 : 0.05 }, letterVals);
var letters = Categorical({vs: letterVals, ps: letterProbs});

var ANSWER = Infer({method: 'enumerate'}, function() {
  var letter = sample(letters);
  var position = letterVals.indexOf(letter) + 1;
  var winProb = 1 / Math.pow(position, 2);
  condition(flip(winProb));
  var isVowel = checkVowel(letter);
  return isVowel ? 'vowel' : 'consonant';
});

var checkVowel = function(letter) { _.includes(['a', 'e', 'i', 'o', 'u'], letter) };
var letterVals = ['g', 'a', 'm', 'e'];
var letterProbs = map(function(letter) { checkVowel(letter) ? 0.45 : 0.05 }, letterVals);
var letters = Categorical({vs: letterVals, ps: letterProbs});

var ANSWER = Infer({method: 'enumerate'}, function() {
  var letter = sample(letters);
  var position = letterVals.indexOf(letter) + 1;
  var winProb = 1 / Math.pow(position, 2);
  condition(flip(winProb));
  return checkVowel(letter) ? 'vowel' : 'consonant';
});

var checkVowel = function(letter) { _.includes(['a', 'e', 'i', 'o', 'u'], letter) };
var letterVals = ['g', 'a', 'm', 'e'];
var letterProbs = map(function(letter) { checkVowel(letter) ? 0.45 : 0.05 }, letterVals);
var letters = Categorical({vs: letterVals, ps: letterProbs});

var ANSWER = Infer({method: 'enumerate'}, function() {
  var letter = sample(letters);
  var position = letterVals.indexOf(letter) + 1;
  var winProb = 1 / Math.pow(position, 2);
  condition(flip(winProb));
  return checkVowel(letter) ? 'vowel' : 'consonant';
});

var checkVowel = function(letter) { _.includes(['a', 'e', 'i', 'o', 'u'], letter); };
var letterVals = ['g', 'a', 'm', 'e'];
var letterProbs = map(function(letter) { checkVowel(letter) ? 0.45 : 0.05 }, letterVals);
var letters = Categorical({vs: letterVals, ps: letterProbs});

var ANSWER = Infer({method: 'enumerate'}, function() {
  var letter = sample(letters);
  var position = _.indexOf(letterVals, letter) + 1;
  var winProb = 1 / Math.pow(position, 2);
  condition(flip(winProb));
  return checkVowel(letter) ? 'vowel' : 'consonant';
});

var p1 = repeat(1000, function() {
  return flip() ? flip(.7) : flip(.1);
});

var p2 = repeat(1000, function() {
  return flip(flip() ? .7 : .1);
});

var p3 = repeat(1000, function() {
  return flip(.4);
});

var ANSWER = {p1: p1, p2: p2, p3: p3};

var p1 = repeat(1000, function() {
  return flip() ? flip(.7) : flip(.1);
});

var p2 = repeat(1000, function() {
  return flip(flip() ? .7 : .1);
});

var p3 = repeat(1000, function() {
  return flip(.4);
});

var ANSWER = {p1: p1, p2: p2, p3: p3};

var p1 = repeat(1000, function() {
  return flip() ? flip(.7) : flip(.1);
});

var p2 = repeat(1000, function() {
  return flip(flip() ? .7 : .1);
});

var p3 = repeat(1000, function() {
  return flip(.4);
});

var ANSWER = {p1: p1, p2: p2, p3: p3};

var p1 = repeat(1000, function() {
  return flip() ? flip(.7) : flip(.1);
});

var p2 = repeat(1000, function() {
  return flip(flip() ? .7 : .1);
});

var p3 = repeat(1000, function() {
  return flip(.4);
});

var ANSWER = {p1: p1, p2: p2, p3: p3};

var p1 = repeat(1000, function() { return flip() ? flip(.7) : flip(.1); });
var p2 = repeat(1000, function() { return flip(flip() ? .7 : .1); });
var p3 = repeat(1000, function() { return flip(.4); });

var ANSWER = {p1: p1, p2: p2, p3: p3};

var p1 = repeat(1000, function() { return flip() ? flip(.7) : flip(.1); });
var p2 = repeat(1000, function() { return flip(flip() ? .7 : .1); });
var p3 = repeat(1000, function() { return flip(.4); });

var ANSWER = {p1: p1, p2: p2, p3: p3};

var p1 = repeat(1000, function() { return flip() ? flip(.7) : flip(.1); });
var p2 = repeat(1000, function() { return flip(flip() ? .7 : .1); });
var p3 = repeat(1000, function() { return flip(.4); });

var ANSWER = {p1: p1, p2: p2, p3: p3};

var ANSWER = flip() && flip(.5) || flip(.2);

var ANSWER = (function() {
  var x = uniform(0, 1);
  return x < 0.4;
})();

var ANSWER = flip(0.5) && flip(0.8);

var ANSWER = flip(.5) && flip(.8);

var ANSWER = (function() {
  // Use a geometric-like construction: sample from a categorical
  // and map to boolean
  // P(true) = 0.4 using: sample uniform [0,1) < 0.4
  // But structurally different: use a mixture via enumeration
  // Let's use: marginalize over a latent variable
  // Pick a random integer 1-5, return true if <= 2 (2/5 = 0.4)
  var n = randomInteger(5); // 0,1,2,3,4 uniformly
  n < 2
})();

var ANSWER = (function() {
  // Use beta/bernoulli or nested structure
  // Structurally: condition on a joint sample
  var model = Infer({method: 'enumerate'}, function() {
    var a = flip(0.8);
    var b = flip(0.5);
    return a && b;
  });
  return sample(model);
})();

// flip(.5) && flip(.8) => P(true) = 0.5 * 0.8 = 0.4
var ANSWER = Infer({method: 'enumerate'}, function() {
  return flip(.5) && flip(.8);
});

var ANSWER = randomInteger(10) < 4;

var foo = mem(function() { return flip(); });
var ANSWER = [foo(), foo(), foo()];

var foo = mem(function() { return flip(); });
var ANSWER = [foo(), foo(), foo()];

var foo = mem(function() { return flip(); });
var ANSWER = [foo(), foo(), foo()];

ReferenceError: ANSWER is not defined

var foo = mem(function() { return flip(); });
[foo(), foo(), foo()];

var foo = mem(function() { return flip(); });
var ANSWER = [foo(), foo(), foo()];

var foo = mem(function() { return flip(); });
var ANSWER = [foo(), foo(), foo()];

var foo = mem(function() { return flip(); });
var ANSWER = [foo(), foo(), foo()];

var foo = mem(function(x) { return flip(); });
var ANSWER = [foo(0), foo(0), foo(1)];

var foo = mem(function(x) { return flip(); });
var ANSWER = [foo(0), foo(0), foo(1)];

var foo = mem(function(arg) { return flip(); });
var ANSWER = [foo(0), foo(0), foo(1)];

var foo = mem(function(x) { return flip(); });
var ANSWER = [foo(0), foo(0), foo(1)];

var foo = mem(function(id) { return flip(); });
var ANSWER = [foo("a"), foo("a"), foo("b")];

var foo = mem(function(id) { return flip(); });
var ANSWER = [foo(1), foo(1), foo(2)];

var foo = mem(function(id) { return flip(); });
var ANSWER = [foo(1), foo(1), foo(2)];

var model = function() {
  var allergies = flip(0.3);
  var cold = flip(0.2);
  var sneeze = cold || allergies;
  var fever = cold;
  return {sneeze: sneeze, fever: fever};
};

var ANSWER = Infer({method: 'forward', samples: 1000}, model);

var model = function() {
  var allergies = flip(0.3);
  var cold = flip(0.2);
  var sneeze = cold || allergies;
  var fever = cold;
  return {sneeze: sneeze, fever: fever};
};

var ANSWER = Infer({method: 'forward', samples: 1000}, model);

var model = function() {
  var allergies = flip(0.3);
  var cold = flip(0.2);
  var sneeze = cold || allergies;
  var fever = cold;
  
  return {sneeze: sneeze, fever: fever};
};

var ANSWER = Infer({method: 'forward', samples: 1000}, model);

var model = function() {
  var allergies = flip(0.3);
  var cold = flip(0.2);
  var sneeze = cold || allergies;
  var fever = cold;
  return {sneeze: sneeze, fever: fever};
};

var ANSWER = Infer({method: 'forward', samples: 1000}, model);

var model = function() {
  var allergies = flip(0.3);
  var cold = flip(0.2);
  var sneeze = cold || allergies;
  var fever = cold;
  return { sneeze: sneeze, fever: fever };
};

var ANSWER = Infer({ method: 'forward', samples: 1000 }, model);

var model = function() {
  var allergies = flip(0.3);
  var cold = flip(0.2);
  var sneeze = cold || allergies;
  var fever = cold;
  return { sneeze: sneeze, fever: fever };
};

var ANSWER = Infer({ method: 'forward', samples: 1000 }, model);

var model = function() {
  var allergies = flip(0.3);
  var cold = flip(0.2);
  var sneeze = cold || allergies;
  var fever = cold;
  return { sneeze: sneeze, fever: fever };
};

var ANSWER = Infer({ method: 'forward', samples: 1000 }, model);

var allergies = mem(function(person) { return flip(.3) })
var cold = mem(function(person) { return flip(.2) })
var fever = function(person) { return cold(person) && flip(.6) }
var sneeze = function(person) { return cold(person) || allergies(person) }

var model = function() {
  return {
    sneeze: sneeze('bob'),
    fever: fever('bob')
  }
}

var ANSWER = Infer({method: 'forward', samples: 1000}, model)

var allergies = mem(function(person) { return flip(.3); });
var cold = mem(function(person) { return flip(.2); });
var sneeze = function(person) { return cold(person) || allergies(person); };
var fever = function(person) { return cold(person) && flip(.6); };

var ANSWER = Infer({method: 'forward', samples: 1000}, function() {
  return {
    sneeze: sneeze('bob'),
    fever: fever('bob')
  };
});

var allergies = mem(function(person) { return flip(.3) });
var cold = mem(function(person) { return flip(.2) });
var sneeze = function(person) { return cold(person) || allergies(person) };
var fever = function(person) { return cold(person) ? flip(.8) : flip(.1) };

var model = function() {
  return {
    sneeze: sneeze('bob'),
    fever: fever('bob')
  };
};

var ANSWER = Infer({method: 'forward', samples: 1000}, model);

var allergies = mem(function(person) { return flip(.3) })
var cold = mem(function(person) { return flip(.2) })
var sneeze = function(person) { return cold(person) || allergies(person) }
var fever = function(person) { return cold(person) && flip(.5) }

var model = function() {
  return {
    sneeze: sneeze('bob'),
    fever: fever('bob')
  }
}

var ANSWER = Infer({method: 'forward', samples: 1000}, model);

var allergies = mem(function(person) { return flip(0.3); });
var cold = mem(function(person) { return flip(0.2); });
var sneeze = function(person) { return cold(person) || allergies(person); };
var fever = function(person) { return cold(person); };

var ANSWER = Infer({method: 'forward', samples: 1000}, function() {
  return {sneeze: sneeze('bob'), fever: fever('bob')};
});

var allergies = mem(function(person) { return flip(0.3); });
var cold      = mem(function(person) { return flip(0.2); });

var sneeze = function(person) {
  return cold(person) || allergies(person);
};

var fever = function(person) {
  return cold(person); // fever only from cold, consistent via mem
};

var model = function() {
  return {
    sneeze: sneeze('bob'),
    fever:  fever('bob')
  };
};

var ANSWER = Infer({ method: 'forward', samples: 1000 }, model);

var allergies = mem(function(person) { return flip(0.3); });
var cold      = mem(function(person) { return flip(0.2); });

var sneeze = function(person) {
  return cold(person) || allergies(person);
};

var fever = function(person) {
  return cold(person);
};

var model = function() {
  return {
    sneeze: sneeze('bob'),
    fever:  fever('bob')
  };
};

var ANSWER = Infer({method: 'forward', samples: 1000}, model);

var makeCoin = function(weight) {
  return function() { return flip(weight) ? 'h' : 't' }
}
var bend = function(coin) {
  return function() {
    return coin() == 'h' ? makeCoin(.7)() : makeCoin(.1)()
  }
}
var fairCoin = makeCoin(.5)
var bentCoin = bend(fairCoin)

var ANSWER = Infer({method: 'forward', samples: 10000}, bentCoin);

var makeCoin = function(weight) {
  return function() { return flip(weight) ? 'h' : 't' }
}
var bend = function(coin) {
  return function() {
    return coin() == 'h' ? makeCoin(.7)() : makeCoin(.1)()
  }
}
var fairCoin = makeCoin(.5)
var bentCoin = bend(fairCoin)

var ANSWER = Infer({method: 'forward', samples: 10000}, bentCoin);

var makeCoin = function(weight) {
  return function() { return flip(weight) ? 'h' : 't' }
}
var bend = function(coin) {
  return function() {
    return coin() == 'h' ? makeCoin(.7)() : makeCoin(.1)()
  }
}
var fairCoin = makeCoin(.5)
var bentCoin = bend(fairCoin)

var ANSWER = Infer({method: 'forward', samples: 10000}, bentCoin);

var makeCoin = function(weight) {
  return function() { return flip(weight) ? 'h' : 't' }
}

var bend = function(coin) {
  return function() {
    return coin() == 'h' ? makeCoin(.7)() : makeCoin(.1)()
  }
}

var fairCoin = makeCoin(.5)
var bentCoin = bend(fairCoin)

var ANSWER = Infer({method: 'forward', samples: 10000}, bentCoin);

var makeCoin = function(weight) {
  return function() { return flip(weight) ? 'h' : 't' }
}
var bend = function(coin) {
  return function() {
    return coin() == 'h' ? makeCoin(.7)() : makeCoin(.1)()
  }
}
var fairCoin = makeCoin(.5)
var bentCoin = bend(fairCoin)

var ANSWER = Infer({method: 'forward', samples: 10000}, bentCoin);

var makeCoin = function(weight) {
  return function() { return flip(weight) ? 'h' : 't' }
}
var bend = function(coin) {
  return function() {
    return coin() == 'h' ? makeCoin(.7)() : makeCoin(.1)()
  }
}
var fairCoin = makeCoin(.5)
var bentCoin = bend(fairCoin)

var ANSWER = Infer({method: 'forward', samples: 10000}, bentCoin);

var makeCoin = function(weight) {
  return function() { return flip(weight) ? 'h' : 't'; }
};

var bend = function(coin) {
  return function() {
    return coin() == 'h' ? makeCoin(.7)() : makeCoin(.1)();
  };
};

var fairCoin = makeCoin(.5);
var bentCoin = bend(fairCoin);

var ANSWER = Infer({method: 'forward', samples: 10000}, bentCoin);

var geometric = function() {
  return flip() ? 0 : 1 + geometric()
}

var ANSWER = Infer({method: 'forward', samples: 10000}, geometric);

var geometric = function() {
  return flip() ? 0 : 1 + geometric()
};

var ANSWER = Infer({method: 'forward', samples: 10000}, geometric);

var geometric = function() {
  return flip() ? 0 : 1 + geometric()
}

var ANSWER = Infer({method: 'forward', samples: 10000}, geometric);

var geometric = function() {
  return flip() ? 0 : 1 + geometric();
};

var ANSWER = Infer({method: 'forward', samples: 10000}, geometric);

var geometric = function() {
  return flip() ? 0 : 1 + geometric();
};

var ANSWER = Infer({method: 'forward', samples: 10000}, geometric);

var geometric = function() {
  return flip() ? 0 : 1 + geometric();
};

var ANSWER = Infer({method: 'forward', samples: 10000}, geometric);

var geometric = function() {
  return flip() ? 0 : 1 + geometric();
};

var ANSWER = Infer({method: 'forward', samples: 10000}, geometric);

var a = flip(0.8);
var b = flip(a ? 0.5 : 0.3);
var ANSWER = [a, b];

var a = flip(0.8);
var b = flip(a ? 0.5 : 0.3);
var ANSWER = [a, b];

var a = flip(0.8);
var b = flip(a ? 0.5 : 0.3);
var ANSWER = [a, b];

var a = flip(0.8);
var b = flip(a ? 0.5 : 0.3);
var ANSWER = [a, b];

var model = function() {
  var a = flip(0.8);
  var b = a ? flip(0.5) : flip(0.3);
  [a, b]
};

var ANSWER = Infer({method: 'enumerate'}, model);

var model = function() {
  var a = flip(0.8);
  var b = a ? flip(0.5) : flip(0.3);
  return [a, b];
};

var ANSWER = Infer({method: 'enumerate'}, model);

var a = flip(0.8);
var b = a ? flip(0.5) : flip(0.3);
var ANSWER = [a, b];

var model = function() {
  var a = flip(0.8);
  var b = flip(a ? 0.5 : 0.3);
  return [a, b];
};

var ANSWER = Infer({method: 'forward', samples: 10000}, model);

var ANSWER = Infer({method: 'forward', samples: 10000}, function() {
  var a = flip(0.8);
  var b = flip(a ? 0.5 : 0.3);
  return [a, b];
});

var ANSWER = Infer({method: 'forward', samples: 10000}, function() {
  var a = flip(0.8);
  var b = flip(a ? 0.5 : 0.3);
  return [a, b];
});

var ANSWER = Infer({method: 'forward', samples: 10000}, function() {
  var a = flip(0.8);
  var b = flip(a ? 0.5 : 0.3);
  return [a, b];
});

var ANSWER = Infer({method: 'forward', samples: 10000}, function() {
  var a = flip(0.8);
  var b = a ? flip(0.5) : flip(0.3);
  return [a, b];
});

var ANSWER = Infer({method: 'forward', samples: 10000}, function() {
  var a = flip(0.8);
  var b = a ? flip(0.5) : flip(0.3);
  return [a, b];
});

var model = function() {
  var a = flip(0.8);
  var b = a ? flip(0.5) : flip(0.3);
  return [a, b];
};

var ANSWER = Infer({method: 'forward', samples: 10000}, model);

Error: Parameter "alpha" should be of type "vector (0, Infinity)".

var colors = ['black', 'blue', 'green', 'orange', 'red'];
var observedData = [{bag: 'bag1', draw: 'blue'},
                    {bag: 'bag1', draw: 'blue'},
                    {bag: 'bag1', draw: 'black'}];

var observed = Infer({method: 'MCMC', samples: 20000}, function() {
  var makeBag = mem(function(bag) {
    var colorProbs = dirichlet(ones([colors.length, 1]));
    return Categorical({vs: colors, ps: colorProbs});
  })
  var obsFn = function(datum) { observe(makeBag(datum.bag), datum.draw); }
  mapData({data: observedData}, obsFn);
  return {bag1: sample(makeBag('bag1'))};
})

var usealpha = Infer({method: 'MCMC', samples: 20000}, function () {
  var makeBag = mem(function(bag) {
    var alpha = [2, 3, 1, 1, 1];
    var colorProbs = dirichlet(alpha);
    return Categorical({vs: colors, ps: colorProbs});
  })
  return {bag1: sample(makeBag('bag1'))};
})

var ANSWER = {observed: observed, usealpha: usealpha};

var colors = ['black', 'blue', 'green', 'orange', 'red'];
var observedData = [{bag: 'bag1', draw: 'blue'},
                    {bag: 'bag1', draw: 'blue'},
                    {bag: 'bag1', draw: 'black'}];

var observed = Infer({method: 'MCMC', samples: 20000}, function() {
  var makeBag = mem(function(bag) {
    var colorProbs = dirichlet(ones([colors.length, 1]));
    return Categorical({vs: colors, ps: colorProbs});
  })
  var obsFn = function(datum) { observe(makeBag(datum.bag), datum.draw); }
  mapData({data: observedData}, obsFn);
  return {bag1: sample(makeBag('bag1'))};
})

var usealpha = Infer({method: 'MCMC', samples: 20000}, function () {
  var makeBag = mem(function(bag) {
    var alpha = Vector([2, 3, 1, 1, 1]);
    var colorProbs = dirichlet(alpha);
    return Categorical({vs: colors, ps: colorProbs});
  })
  return {bag1: sample(makeBag('bag1'))};
})

var ANSWER = {observed: observed, usealpha: usealpha};

Error: Parameter "alpha" should be of type "vector (0, Infinity)".

var colors = ['black', 'blue', 'green', 'orange', 'red'];
var observedData = [{bag: 'bag1', draw: 'blue'},
                    {bag: 'bag1', draw: 'blue'},
                    {bag: 'bag1', draw: 'black'}];

var observed = Infer({method: 'MCMC', samples: 20000}, function() {
  var makeBag = mem(function(bag) {
    var colorProbs = dirichlet(ones([colors.length, 1]));
    return Categorical({vs: colors, ps: colorProbs});
  })
  var obsFn = function(datum) { observe(makeBag(datum.bag), datum.draw); }
  mapData({data: observedData}, obsFn);
  return {bag1: sample(makeBag('bag1'))};
})

var usealpha = Infer({method: 'MCMC', samples: 20000}, function () {
  var makeBag = mem(function(bag) {
    var colorProbs = dirichlet([2, 3, 1, 1, 1]);
    return Categorical({vs: colors, ps: colorProbs});
  })
  return {bag1: sample(makeBag('bag1'))};
})

var ANSWER = {observed, usealpha};

var colors = ['black', 'blue', 'green', 'orange', 'red'];
var observedData = [{bag: 'bag1', draw: 'blue'},
                    {bag: 'bag1', draw: 'blue'},
                    {bag: 'bag1', draw: 'black'}];

var observed = Infer({method: 'MCMC', samples: 20000}, function() {
  var makeBag = mem(function(bag) {
    var colorProbs = dirichlet(ones([colors.length, 1]));
    return Categorical({vs: colors, ps: colorProbs});
  })
  var obsFn = function(datum) { observe(makeBag(datum.bag), datum.draw); }
  mapData({data: observedData}, obsFn);
  return {bag1: sample(makeBag('bag1'))};
})

var usealpha = Infer({method: 'MCMC', samples: 20000}, function () {
  var colorProbs = dirichlet(Vector([2, 3, 1, 1, 1]));
  var sampleColor = sample(Categorical({vs: colors, ps: colorProbs}));
  return {bag1: sampleColor};
})

var ANSWER = {observed: observed, usealpha: usealpha};

var colors = ['black', 'blue', 'green', 'orange', 'red'];
var observedData = [{bag: 'bag1', draw: 'blue'},
                    {bag: 'bag1', draw: 'blue'},
                    {bag: 'bag1', draw: 'black'}];

var observed = Infer({method: 'MCMC', samples: 20000}, function() {
  var makeBag = mem(function(bag) {
    var colorProbs = dirichlet(ones([colors.length, 1]));
    return Categorical({vs: colors, ps: colorProbs});
  });
  var obsFn = function(datum) { observe(makeBag(datum.bag), datum.draw); };
  mapData({data: observedData}, obsFn);
  return {bag1: sample(makeBag('bag1'))};
});

var usealpha = Infer({method: 'MCMC', samples: 20000}, function() {
  // alpha = [2, 3, 1, 1, 1] corresponds to:
  // black=2 (1 prior + 1 observed black),
  // blue=3 (1 prior + 2 observed blue),
  // green=1, orange=1, red=1
  var colorProbs = dirichlet(Vector([2, 3, 1, 1, 1]));
  var bag1 = Categorical({vs: colors, ps: colorProbs});
  return {bag1: sample(bag1)};
});

var ANSWER = {observed: observed, usealpha: usealpha};

var colors = ['black', 'blue', 'green', 'orange', 'red'];
var observedData = [{bag: 'bag1', draw: 'blue'},
                    {bag: 'bag1', draw: 'blue'},
                    {bag: 'bag1', draw: 'black'}];

var observed = Infer({method: 'MCMC', samples: 20000}, function() {
  var makeBag = mem(function(bag) {
    var colorProbs = dirichlet(ones([colors.length, 1]));
    return Categorical({vs: colors, ps: colorProbs});
  });
  var obsFn = function(datum) { observe(makeBag(datum.bag), datum.draw); };
  mapData({data: observedData}, obsFn);
  return {bag1: sample(makeBag('bag1'))};
});

var usealpha = Infer({method: 'MCMC', samples: 20000}, function() {
  // alpha = [1,1,1,1,1] + 1 black + 2 blue = [2, 3, 1, 1, 1]
  // colors order: black, blue, green, orange, red
  var alpha = Vector([2, 3, 1, 1, 1]);
  var makeBag = mem(function(bag) {
    var colorProbs = dirichlet(alpha);
    return Categorical({vs: colors, ps: colorProbs});
  });
  return {bag1: sample(makeBag('bag1'))};
});

var ANSWER = {observed: observed, usealpha: usealpha};

var colors = ['black', 'blue', 'green', 'orange', 'red'];
var observedData = [{bag: 'bag1', draw: 'blue'},
                    {bag: 'bag1', draw: 'blue'},
                    {bag: 'bag1', draw: 'black'}];

var observed = Infer({method: 'MCMC', samples: 20000}, function() {
  var makeBag = mem(function(bag) {
    var colorProbs = dirichlet(ones([colors.length, 1]));
    return Categorical({vs: colors, ps: colorProbs});
  });
  var obsFn = function(datum) { observe(makeBag(datum.bag), datum.draw); };
  mapData({data: observedData}, obsFn);
  return {bag1: sample(makeBag('bag1'))};
});

var usealpha = Infer({method: 'MCMC', samples: 20000}, function() {
  // alpha = [2,3,1,1,1]: black(+1 obs) = 2, blue(+2 obs) = 3, rest = 1
  var colorProbs = dirichlet(Vector([2, 3, 1, 1, 1]));
  var bag1 = Categorical({vs: colors, ps: colorProbs});
  return {bag1: sample(bag1)};
});

var ANSWER = {observed: observed, usealpha: usealpha};

var makeBarrel = function(barrelName) {
  var p = sample(Beta({a: 0.1, b: 0.2}));
  return function barrel(n) {
    return mapN(function(i) {
      return flip(p);
    }, n);
  };
};

var myBarrel = makeBarrel("barrel1");
var model = function() {
  var applesRotten = myBarrel(10);
  return Math.sum(applesRotten);
};

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

var makeBarrel = function(barrelName) {
  var p = sample(Beta({a: 0.1, b: 0.2}));
  var barrel = function(n) {
    return repeat(n, function() {
      return flip(p);
    });
  };
  return barrel;
};

var barrel = makeBarrel("myBarrel");

var ANSWER = Infer({method: 'MCMC', samples: 5000}, function() {
  var apples = barrel(10);
  var rottenCount = sum(apples);
  return rottenCount;
});

ReferenceError: range is not defined

var makeBarrel = function(barrelName) {
  var p = beta({a: 0.1, b: 0.2});
  return function barrel(n) {
    return map(function() {
      return flip(p);
    }, range(n));
  };
};

var ANSWER = Infer({method: 'rejection', samples: 1000}, function() {
  var barrel = makeBarrel("myBarrel");
  return Math.sum(barrel(10));
});

var makeBarrel = function(barrelName) {
  var barrel = function(n) {
    var p = sample(Beta({a: 0.1, b: 0.2}));
    return repeat(n, function() { return flip(p); });
  };
  return barrel;
};

var barrel = makeBarrel("mybarrel");
var ANSWER = Infer({method: 'rejection', samples: 1000}, function() {
  var apples = barrel(10);
  return sum(map(function(isRotten) { return isRotten ? 1 : 0; }, apples));
});

var makeBarrel = function(barrelName) {
  var p = sample(Beta({a: 0.1, b: 0.2}));
  var barrel = function(n) {
    return repeat(n, function() {
      return sample(Bernoulli({p: p}));
    });
  };
  return barrel;
};

var model = function() {
  var barrel = makeBarrel("myBarrel");
  var apples = barrel(10);
  return Math.sum(apples);
};

var ANSWER = Infer({method: 'MCMC', samples: 10000}, model);

var makeBarrel = function(barrelName) {
  var p = sample(Beta({a: 0.1, b: 0.2}));
  var barrel = function(n) {
    return repeat(n, function() {
      return sample(Bernoulli({p: p}));
    });
  };
  return barrel;
};

var model = function() {
  var barrel = makeBarrel("myBarrel");
  var apples = barrel(10);
  return Math.sum(apples);
};

var ANSWER = Infer({method: 'forward', samples: 50000}, model);

var ANSWER = Infer({method: 'forward', samples: 20000}, function() {

  var makeBarrel = mem(function(barrelName) {
    var p = beta(0.1, 0.2);
    var barrel = function(n) {
      return repeat(n, function() { return flip(p); });
    };
    return barrel;
  });

  var barrel = makeBarrel("myBarrel");
  return sum(map(function(x) { return x ? 1 : 0; }, barrel(10)));

});

var makeStore = mem(function(storeName) {
  var hyperparams = flip(0.5) ? {a: 0.1, b: 0.3} : {a: 0.3, b: 0.1};
  var pRotten = beta(hyperparams.a, hyperparams.b);
  
  var makeBarrel = mem(function(barrelName) {
    return function(n) {
      return repeat(n, function() {
        return flip(pRotten);
      });
    };
  });
  
  return makeBarrel;
});

var sameStore = Infer({method: 'forward', samples: 10000}, function() {
  var store = makeStore('store1');
  var barrel1 = store('barrel1')(10);
  var barrel2 = store('barrel2')(10);
  var count1 = sum(barrel1);
  var count2 = sum(barrel2);
  return Math.abs(count1 - count2);
});

var differentStore = Infer({method: 'forward', samples: 10000}, function() {
  var store1 = makeStore('store1');
  var store2 = makeStore('store2');
  var barrel1 = store1('barrel1')(10);
  var barrel2 = store2('barrel1')(10);
  var count1 = sum(barrel1);
  var count2 = sum(barrel2);
  return Math.abs(count1 - count2);
});

var ANSWER = {sameStore: sameStore, differentStore: differentStore};

var makeStore = mem(function(storeName) {
  // Sample Beta hyperparameters for this store
  var hyperparams = flip(0.5) ? {a: 0.1, b: 0.3} : {a: 0.3, b: 0.1};
  
  // Sample pRotten from Beta distribution with these hyperparameters
  var pRotten = beta(hyperparams.a, hyperparams.b);
  
  // Return a function that creates barrels in this store
  return mem(function(barrelName) {
    // Each barrel is an array of n booleans indicating rotten apples
    return function(n) {
      return repeat(n, function() {
        return flip(pRotten);
      });
    };
  });
});

// Distribution for same store comparison
var sameStore = Infer({method: 'forward', samples: 10000}, function() {
  var store = makeStore('store1');
  var barrel1 = store('barrel1')(10);
  var barrel2 = store('barrel2')(10);
  
  var rottenCount1 = sum(barrel1);
  var rottenCount2 = sum(barrel2);
  
  return Math.abs(rottenCount1 - rottenCount2);
});

// Distribution for different store comparison
var differentStore = Infer({method: 'forward', samples: 10000}, function() {
  var store1 = makeStore('store1');
  var store2 = makeStore('store2');
  
  var barrel1 = store1('barrel1')(10);
  var barrel2 = store2('barrel1')(10);
  
  var rottenCount1 = sum(barrel1);
  var rottenCount2 = sum(barrel2);
  
  return Math.abs(rottenCount1 - rottenCount2);
});

var ANSWER = {sameStore: sameStore, differentStore: differentStore};

ReferenceError: range is not defined

// Memoized store factory with hyperparameter selection
var makeStore = mem(function(storeName) {
  // Each store draws hyperparameters from discrete prior
  var hyperparams = flip(0.5) ? 
    {a: 0.1, b: 0.3} :  // mostly fresh
    {a: 0.3, b: 0.1};   // mostly rotten
  
  // Return a memoized barrel-making function for this store
  var makeBarrel = mem(function(barrelName) {
    // Draw pRotten from this store's Beta distribution
    var pRotten = beta(hyperparams.a, hyperparams.b);
    
    // Return function that generates n apples
    return function(n) {
      return map(function() {
        return flip(pRotten);
      }, range(n));
    };
  });
  
  return makeBarrel;
});

// Sample distribution for same store
var sameStore = Infer({method: 'forward', samples: 10000}, function() {
  var store = makeStore('store1');
  var barrel1 = store('barrel1')(10);
  var barrel2 = store('barrel2')(10);
  
  var rottenCount1 = sum(barrel1);
  var rottenCount2 = sum(barrel2);
  
  return Math.abs(rottenCount1 - rottenCount2);
});

// Sample distribution for different stores
var differentStore = Infer({method: 'forward', samples: 10000}, function() {
  var store1 = makeStore('store1');
  var store2 = makeStore('store2');
  
  var barrel1 = store1('barrel1')(10);
  var barrel2 = store2('barrel1')(10);
  
  var rottenCount1 = sum(barrel1);
  var rottenCount2 = sum(barrel2);
  
  return Math.abs(rottenCount1 - rottenCount2);
});

var ANSWER = {sameStore: sameStore, differentStore: differentStore};

var makeStore = mem(function(storeName) {
  // Draw Beta hyperparameters from discrete prior (50/50)
  var hyperparams = flip(0.5) ? {a: 0.1, b: 0.3} : {a: 0.3, b: 0.1};
  
  // Return a memoized barrel function for this store
  var makeBarrel = mem(function(barrelName) {
    // Draw pRotten from the store's Beta distribution
    var pRotten = beta(hyperparams.a, hyperparams.b);
    
    // Return function that generates n apples
    return function(n) {
      return map(function() {
        return flip(pRotten);
      }, _.range(0, n));
    };
  });
  
  return makeBarrel;
});

// Inference: two barrels from the same store
var sameStore = Infer({method: 'forward', samples: 10000}, function() {
  var store = makeStore("store1");
  var barrel1 = store("barrel1")(10);
  var barrel2 = store("barrel2")(10);
  
  var count1 = _.filter(barrel1, function(x) { return x; }).length;
  var count2 = _.filter(barrel2, function(x) { return x; }).length;
  
  return Math.abs(count1 - count2);
});

// Inference: two barrels from different stores
var differentStore = Infer({method: 'forward', samples: 10000}, function() {
  var store1 = makeStore("store_A");
  var store2 = makeStore("store_B");
  
  var barrel1 = store1("barrel1")(10);
  var barrel2 = store2("barrel1")(10);
  
  var count1 = _.filter(barrel1, function(x) { return x; }).length;
  var count2 = _.filter(barrel2, function(x) { return x; }).length;
  
  return Math.abs(count1 - count2);
});

var ANSWER = {sameStore: sameStore, differentStore: differentStore};

var makeStore = mem(function(storeName) {
  var hyperparams = flip(0.5) ? {a: 0.1, b: 0.3} : {a: 0.3, b: 0.1};
  
  var makeBarrel = mem(function(barrelName) {
    var pRotten = beta(hyperparams.a, hyperparams.b);
    
    return function(n) {
      return repeat(n, function() { return flip(pRotten); });
    };
  });
  
  return makeBarrel;
});

var sameStoreDist = Infer({method: 'forward', samples: 10000}, function() {
  var makeBarrel = makeStore('store1');
  var barrel1 = makeBarrel('barrel1');
  var barrel2 = makeBarrel('barrel2');
  var apples1 = barrel1(10);
  var apples2 = barrel2(10);
  var count1 = sum(map(function(x) { return x ? 1 : 0; }, apples1));
  var count2 = sum(map(function(x) { return x ? 1 : 0; }, apples2));
  return Math.abs(count1 - count2);
});

var differentStoreDist = Infer({method: 'forward', samples: 10000}, function() {
  var makeBarrelA = makeStore('storeA');
  var makeBarrelB = makeStore('storeB');
  var barrel1 = makeBarrelA('barrel1');
  var barrel2 = makeBarrelB('barrel2');
  var apples1 = barrel1(10);
  var apples2 = barrel2(10);
  var count1 = sum(map(function(x) { return x ? 1 : 0; }, apples1));
  var count2 = sum(map(function(x) { return x ? 1 : 0; }, apples2));
  return Math.abs(count1 - count2);
});

var ANSWER = {sameStore: sameStoreDist, differentStore: differentStoreDist};

var sameStoreDist = Infer({method: 'forward', samples: 10000}, function() {
  var makeStore = mem(function(storeName) {
    var hyperparams = flip(0.5) ? {a: 0.1, b: 0.3} : {a: 0.3, b: 0.1};

    var makeBarrel = mem(function(barrelName) {
      var pRotten = sample(Beta({a: hyperparams.a, b: hyperparams.b}));
      return function(n) {
        return repeat(n, function() { return sample(Bernoulli({p: pRotten})); });
      };
    });

    return makeBarrel;
  });

  var store      = makeStore('store1');
  var barrel1    = store('barrel1');
  var barrel2    = store('barrel2');
  var apples1    = barrel1(10);
  var apples2    = barrel2(10);
  var count1     = sum(map(function(x) { return x ? 1 : 0; }, apples1));
  var count2     = sum(map(function(x) { return x ? 1 : 0; }, apples2));
  return Math.abs(count1 - count2);
});

var differentStoreDist = Infer({method: 'forward', samples: 10000}, function() {
  var makeStore = mem(function(storeName) {
    var hyperparams = flip(0.5) ? {a: 0.1, b: 0.3} : {a: 0.3, b: 0.1};

    var makeBarrel = mem(function(barrelName) {
      var pRotten = sample(Beta({a: hyperparams.a, b: hyperparams.b}));
      return function(n) {
        return repeat(n, function() { return sample(Bernoulli({p: pRotten})); });
      };
    });

    return makeBarrel;
  });

  var store1     = makeStore('store1');
  var store2     = makeStore('store2');
  var barrel1    = store1('barrel1');
  var barrel2    = store2('barrel2');
  var apples1    = barrel1(10);
  var apples2    = barrel2(10);
  var count1     = sum(map(function(x) { return x ? 1 : 0; }, apples1));
  var count2     = sum(map(function(x) { return x ? 1 : 0; }, apples2));
  return Math.abs(count1 - count2);
});

var ANSWER = {sameStore: sameStoreDist, differentStore: differentStoreDist};

var makeStore = mem(function(storeName) {
  var hyperparams = flip(0.5) ? {a: 0.1, b: 0.3} : {a: 0.3, b: 0.1};

  var makeBarrel = mem(function(barrelName) {
    var pRotten = beta(hyperparams.a, hyperparams.b);
    return function(n) {
      return repeat(n, function() { return flip(pRotten); });
    };
  });

  return makeBarrel;
});

var rottenCount = function(apples) {
  return sum(map(function(x) { return x ? 1 : 0; }, apples));
};

var sameStore = Infer({method: 'forward', samples: 10000}, function() {
  var store = makeStore('storeA');
  var barrel1 = store('barrelA');
  var barrel2 = store('barrelB');
  var count1 = rottenCount(barrel1(10));
  var count2 = rottenCount(barrel2(10));
  return Math.abs(count1 - count2);
});

var differentStore = Infer({method: 'forward', samples: 10000}, function() {
  var store1 = makeStore('store1');
  var store2 = makeStore('store2');
  var barrel1 = store1('barrelA');
  var barrel2 = store2('barrelA');
  var count1 = rottenCount(barrel1(10));
  var count2 = rottenCount(barrel2(10));
  return Math.abs(count1 - count2);
});

var ANSWER = {sameStore: sameStore, differentStore: differentStore};

var makeCity = mem(function(cityName) {
  var cityPrior = beta({a: 0.25, b: 0.25});
  
  var makeStore = mem(function(storeName) {
    var storePrior = cityPrior < 0.5 ? 
      {a: 0.1, b: 0.3} :  // fresh kind
      {a: 0.3, b: 0.1};   // rotten kind
    
    var makeBarrel = mem(function(barrelName) {
      return function(n) {
        var pRotten = beta(storePrior);
        return mapN(function(i) {
          return flip(pRotten);
        }, n);
      };
    });
    
    return makeBarrel;
  });
  
  return makeStore;
});

var C1 = makeCity("C1");
var S1 = C1("S1");
var B1 = S1("B1");

var ANSWER = Infer({method: "forward", samples: 10000}, function() {
  return Math.sum(B1(20));
});

var makeCity = mem(function(cityName) {
  var cityPrior = beta({a: 0.25, b: 0.25});
  
  var makeStore = mem(function(storeName) {
    var isFresh = flip(cityPrior);
    var storePrior = isFresh ? 
      {a: 0.1, b: 0.3} : 
      {a: 0.3, b: 0.1};
    
    var makeBarrel = mem(function(barrelName) {
      var pRotten = beta(storePrior);
      
      var barrel = function(n) {
        return repeat(n, function() {
          return flip(pRotten);
        });
      };
      
      return barrel;
    });
    
    return makeBarrel;
  });
  
  return makeStore;
});

var C1 = makeCity("C1");
var S1 = C1("S1");
var B1 = S1("B1");

var ANSWER = Infer({method: 'forward', samples: 10000}, function() {
  var barrelContents = B1(20);
  return _.sum(map(function(x) { return x ? 1 : 0; }, barrelContents));
});

var makeCity = mem(function(cityName) {
  var cityPrior = beta({a: 0.25, b: 0.25}); // P(store is fresh)
  
  return mem(function(storeName) {
    var isFresh = flip(cityPrior);
    var storePrior = isFresh ? 
      {a: 0.1, b: 0.3} :  // fresh store: low rotten rate
      {a: 0.3, b: 0.1};   // rotten store: high rotten rate
    
    return mem(function(barrelName) {
      return function(n) {
        var pRotten = beta(storePrior);
        return mapN(function(i) {
          return flip(pRotten);
        }, n);
      };
    });
  });
});

var C1 = makeCity('C1');
var S1 = C1('S1');
var B1 = S1('B1');

var countRotten = function(arr) {
  return sum(map(function(x) { return x ? 1 : 0; }, arr));
};

var ANSWER = Infer({method: 'forward', samples: 10000}, function() {
  var barrelSample = B1(20);
  return countRotten(barrelSample);
});

var makeCity = mem(function(cityName) {
  var cityPrior = beta({a: 0.25, b: 0.25});
  
  var makeStore = mem(function(storeName) {
    var isFresh = flip(cityPrior);
    var storePrior = isFresh ? 
      {a: 0.1, b: 0.3} :
      {a: 0.3, b: 0.1};
    
    var makeBarrel = mem(function(barrelId) {
      var pRotten = beta(storePrior);
      return function(n) {
        return map(function() { return flip(pRotten); }, _.range(0, n));
      };
    });
    
    return makeBarrel;
  });
  
  return makeStore;
});

var C1 = makeCity("C1");
var S1 = C1("S1");
var B1 = S1("B1");

var ANSWER = Infer({method: 'forward', samples: 10000}, function() {
  var barrel = B1(20);
  return _.sum(map(function(x) { return x ? 1 : 0; }, barrel));
});

var makeCity = mem(function(cityName) {
  var cityPrior = beta({a: 0.25, b: 0.25});
  
  var makeStore = mem(function(storeName) {
    // cityPrior controls probability that store is 'fresh' kind
    // fresh kind: pRotten ~ Beta(.1, .3)
    // rotten kind: pRotten ~ Beta(.3, .1)
    var isFresh = flip(cityPrior);
    var storePrior = isFresh ? {a: 0.1, b: 0.3} : {a: 0.3, b: 0.1};
    
    var makeBarrel = mem(function(barrelName) {
      var pRotten = beta(storePrior);
      
      var barrel = function(n) {
        return repeat(n, function() { return flip(pRotten); });
      };
      
      return barrel;
    });
    
    return makeBarrel;
  });
  
  return makeStore;
});

var C1 = makeCity("C1");
var S1 = C1("S1");
var B1 = S1("B1");

var ANSWER = Infer({method: 'forward', samples: 10000}, function() {
  return Math.sum(B1(20));
});

var ANSWER = Infer({ method: 'forward', samples: 10000 }, function() {

  var makeCity = mem(function(cityName) {
    // cityPrior: probability that a store in this city is the 'fresh' kind
    var cityPrior = beta({ a: 0.25, b: 0.25 });

    var makeStore = mem(function(storeName) {
      // Use cityPrior to pick store kind
      var isFresh = flip(cityPrior);
      // fresh store: Beta(.1, .3) → low pRotten; rotten store: Beta(.3, .1) → high pRotten
      var storePrior = isFresh ? { a: 0.1, b: 0.3 } : { a: 0.3, b: 0.1 };

      var makeBarrel = mem(function(barrelName) {
        // Each barrel draws its own pRotten from the store's distribution
        var pRotten = beta(storePrior);

        // barrel(n) returns n booleans: true = rotten
        var barrel = function(n) {
          return repeat(n, function() { return flip(pRotten); });
        };

        return barrel;
      });

      return makeBarrel;
    });

    return makeStore;
  });

  // Instantiate city C1, store S1, barrel B1
  var C1 = makeCity('C1');
  var S1 = C1('S1');
  var B1 = S1('B1');

  // Sum of 20 booleans = number of rotten apples in barrel B1
  return Math.sum(B1(20));
});

var makeCity = mem(function(cityName) {
  var cityPrior = beta({a: 0.25, b: 0.25});

  var makeStore = mem(function(storeName) {
    var isFresh = flip(cityPrior);
    var storePrior = isFresh ? {a: 0.1, b: 0.3} : {a: 0.3, b: 0.1};

    var makeBarrel = mem(function(barrelName) {
      var pRotten = beta(storePrior);

      var barrel = mem(function(n) {
        return repeat(n, function() { return flip(pRotten); });
      });

      return barrel;
    });

    return makeBarrel;
  });

  return makeStore;
});

var C1 = makeCity('C1');
var S1 = C1('S1');
var B1 = S1('B1');

var ANSWER = Infer({method: 'forward', samples: 10000}, function() {
  return Math.sum(B1(20));
});

Error: Parameter "b" should be of type "real (0, Infinity)".

// Memoized city-level prior
var cityPrior = mem(function(cityName) {
  return beta({a: 0.25, b: 0.25});
});

// Memoized store-level prior
var storePrior = mem(function(cityName, storeName) {
  var cityRottenness = cityPrior(cityName);
  var isFresh = flip(cityRottenness);
  if (isFresh) {
    return beta({a: 0.1, b: 0.3});
  } else {
    return beta({a: 0.3, b: 0.1});
  }
});

// Memoized barrel sampling
var barrel = mem(function(cityName, storeName, barrelName, n) {
  var pRotten = beta(storePrior(cityName, storeName));
  return repeat(n, function() { return flip(pRotten); });
});

var model = function() {
  // Visit store 1 in city A, observe 7 rotten out of 10
  var barrel1 = barrel("cityA", "store1", "barrel1", 10);
  var rottenCount1 = sum(barrel1);
  observe(Categorical({ps: [1], vs: [rottenCount1]}), 7);
  
  // Visit store 2 in the same city A
  var barrel2 = barrel("cityA", "store2", "barrel2", 10);
  var rottenCount2 = sum(barrel2);
  
  return rottenCount2;
};

var ANSWER = Infer({method: 'MCMC', samples: 5000, lag: 100}, model);

// Memoized city-level prior
var cityPrior = mem(function(cityId) {
  return beta({a: 0.25, b: 0.25});
});

// Memoized store-level prior
var storePrior = mem(function(cityId, storeId) {
  var cityRottennessProb = cityPrior(cityId);
  var isFresh = flip(cityRottennessProb);
  if (isFresh) {
    return beta({a: 0.1, b: 0.3});
  } else {
    return beta({a: 0.3, b: 0.1});
  }
});

// Generate barrel observations
var barrel = function(storeId, pRotten, n) {
  return repeat(n, function() {
    return flip(pRotten);
  });
};

// Model
var model = function() {
  var cityId = "city1";
  var store1Id = "store1";
  var store2Id = "store2";
  
  // Get store priors
  var store1Prior = storePrior(cityId, store1Id);
  var store2Prior = storePrior(cityId, store2Id);
  
  // Observe barrel from store 1: 10 apples, 7 rotten
  var barrel1 = barrel(store1Id, store1Prior, 10);
  var rottenCount1 = sum(barrel1);
  observe(Binomial({p: store1Prior, n: 10}), 7);
  
  // Sample barrel from store 2
  var barrel2 = barrel(store2Id, store2Prior, 10);
  var rottenCount2 = sum(barrel2);
  
  return rottenCount2;
};

var ANSWER = Infer({method: 'MCMC', samples: 5000, lag: 100}, model);

Error: sample() expected a distribution but received "false".

var city = mem(function(cityName) {
  return beta({a: 0.25, b: 0.25});
});

var store = mem(function(cityName, storeName) {
  var cityPrior = city(cityName);
  if (flip(cityPrior)) {
    // Fresh store
    return beta({a: 0.1, b: 0.3});
  } else {
    // Rotten store
    return beta({a: 0.3, b: 0.1});
  }
});

var barrel = mem(function(cityName, storeName, barrelName) {
  var pRotten = store(cityName, storeName);
  var apples = repeat(10, function() { return flip(pRotten); });
  return apples;
});

var model = function() {
  // Observe barrel from store 1 in city 1: 7 rotten out of 10
  var barrel1 = barrel("city1", "store1", "barrel1");
  var numRotten1 = sum(barrel1);
  observe(numRotten1 === 7);
  
  // Query barrel from store 2 in the same city
  var barrel2 = barrel("city1", "store2", "barrel2");
  var numRotten2 = sum(barrel2);
  return numRotten2;
};

var ANSWER = Infer({method: 'MCMC', samples: 5000, lag: 100}, model);

Error: Parameter "b" should be of type "real (0, Infinity)".

var cityPrior = mem(function(cityID) {
  return beta({a: .25, b: .25});
});

var storePrior = mem(function(cityID, storeID) {
  var city_p = cityPrior(cityID);
  var isFresh = flip(city_p);
  if (isFresh) {
    return beta({a: .1, b: .3});
  } else {
    return beta({a: .3, b: .1});
  }
});

var barrel = mem(function(cityID, storeID, barrelID, n) {
  var p_rotten = beta(storePrior(cityID, storeID));
  return repeat(n, function() {
    return flip(p_rotten);
  });
});

var model = function() {
  // Observe barrel from first store in the city
  var barrel1 = barrel("city1", "store1", "barrel1", 10);
  var rotten1 = sum(map(function(x) { return x ? 1 : 0; }, barrel1));
  condition(rotten1 === 7);
  
  // Predict barrel from second (different) store in the same city
  var barrel2 = barrel("city1", "store2", "barrel1", 10);
  var rotten2 = sum(map(function(x) { return x ? 1 : 0; }, barrel2));
  
  return rotten2;
};

var ANSWER = Infer({method: 'MCMC', samples: 5000, lag: 100}, model);

var cityPrior = function() {
  return beta({a: 0.25, b: 0.25});
};

var model = function() {
  // Memoized city-level parameter
  var getCityParam = mem(function(cityId) {
    return cityPrior();
  });

  // Memoized store-level prior
  var getStorePrior = mem(function(cityId, storeId) {
    var cp = getCityParam(cityId);
    var isFresh = flip(cp);
    if (isFresh) {
      return beta({a: 0.1, b: 0.3});
    } else {
      return beta({a: 0.3, b: 0.1});
    }
  });

  // Memoized barrel pRotten
  var getBarrelPRotten = mem(function(cityId, storeId, barrelId) {
    var sp = getStorePrior(cityId, storeId);
    return beta({a: sp * 10, b: (1 - sp) * 10});
  });

  // barrel(n) returns n booleans for a given barrel
  var barrel = function(cityId, storeId, barrelId, n) {
    var pRotten = getBarrelPRotten(cityId, storeId, barrelId);
    return repeat(n, function() { return flip(pRotten); });
  };

  // Observe barrel from store 1 in city 1: 7 rotten out of 10
  var obs = barrel('city1', 'store1', 'barrel1', 10);
  var numRotten1 = sum(map(function(x) { return x ? 1 : 0; }, obs));
  observe(Gaussian({mu: numRotten1, sigma: 0.01}), 7);

  // Second store in same city
  var obs2 = barrel('city1', 'store2', 'barrel1', 10);
  var numRotten2 = sum(map(function(x) { return x ? 1 : 0; }, obs2));

  return numRotten2;
};

var ANSWER = Infer({method: 'MCMC', samples: 5000, lag: 100}, model);

var model = function() {
  // City-level parameter (shared across all stores in this city)
  var cityPrior = beta({a: 0.25, b: 0.25});

  // Store-level: memoized per store ID
  // With prob cityPrior pick "fresh" params, else "rotten" params
  var storeParams = mem(function(storeId) {
    var isFresh = flip(cityPrior);
    return isFresh ? {a: 0.1, b: 0.3} : {a: 0.3, b: 0.1};
  });

  // Barrel-level: memoized per (store, barrel) pair
  // Sample pRotten ~ Beta(storeParams)
  var barrelPRotten = mem(function(storeId, barrelId) {
    return beta(storeParams(storeId));
  });

  // Helper: observe or sample n apples from a given barrel
  var observeBarrel = function(storeId, barrelId, n, nRotten) {
    var p = barrelPRotten(storeId, barrelId);
    observe(Binomial({n: n, p: p}), nRotten);
  };

  var sampleBarrel = function(storeId, barrelId, n) {
    var p = barrelPRotten(storeId, barrelId);
    return binomial({n: n, p: p});
  };

  // Observation: store 1, barrel 0 → 7 of 10 apples are rotten
  observeBarrel('store1', 0, 10, 7);

  // Query: different store (store 2) in the same city, fresh barrel
  return sampleBarrel('store2', 0, 10);
};

var ANSWER = Infer({method: 'MCMC', samples: 5000, lag: 100}, model);

var model = function() {
  // City-level: one city, one cityPrior
  var cityPrior = beta({a: 0.25, b: 0.25});

  // Store-level: memoized by storeId; each store picks a Beta distribution
  var storeDist = mem(function(storeId) {
    return flip(cityPrior)
      ? Beta({a: 0.1, b: 0.3})   // fresh store distribution
      : Beta({a: 0.3, b: 0.1});  // rotten store distribution
  });

  // Barrel-level: pRotten memoized by (storeId, barrelId)
  var barrelPRotten = mem(function(storeId, barrelId) {
    return sample(storeDist(storeId));
  });

  // barrel(storeId, barrelId, n): returns n booleans (true = rotten)
  var barrel = function(storeId, barrelId, n) {
    var p = barrelPRotten(storeId, barrelId);
    return repeat(n, function() { return flip(p); });
  };

  // Observe: store 1, barrel 1 => 7 rotten out of 10
  var p1 = barrelPRotten(1, 1);
  observe(Binomial({p: p1, n: 10}), 7);

  // Predict: different store (store 2) in the same city, sample a 10-apple barrel
  var store2Apples = barrel(2, 1, 10);
  var nRotten = sum(map(function(x) { return x ? 1 : 0; }, store2Apples));
  return nRotten;
};

var ANSWER = Infer({method: 'MCMC', samples: 5000, lag: 100}, model);

var data = [{group: "vowel", word: "abacus", id: 1, rt: 210},
            {group: "vowel", word: "abacus", id: 2, rt: 212},
            {group: "vowel", word: "abacus", id: 3, rt: 209},
            {group: "vowel", word: "aardvark", id: 1, rt: 200},
            {group: "vowel", word: "aardvark", id: 2, rt: 201},
            {group: "vowel", word: "aardvark", id: 3, rt: 198},
            {group: "vowel", word: "ellipse", id: 1, rt: 220},
            {group: "vowel", word: "ellipse", id: 2, rt: 222},
            {group: "vowel", word: "ellipse", id: 3, rt: 219},
            {group: "consonant", word: "proton", id: 1, rt: 190},
            {group: "consonant", word: "proton", id: 2, rt: 191},
            {group: "consonant", word: "proton", id: 3, rt: 189},
            {group: "consonant", word: "folder", id: 1, rt: 180},
            {group: "consonant", word: "folder", id: 2, rt: 182},
            {group: "consonant", word: "folder", id: 3, rt: 178},
            {group: "consonant", word: "fedora", id: 1, rt: 230},
            {group: "consonant", word: "fedora", id: 2, rt: 231},
            {group: "consonant", word: "fedora", id: 3, rt: 228},
            {group: "consonant", word: "fedora", id: 1, rt: 231},
            {group: "consonant", word: "fedora", id: 2, rt: 233},
            {group: "consonant", word: "fedora", id: 3, rt: 230},
            {group: "consonant", word: "fedora", id: 1, rt: 230},
            {group: "consonant", word: "fedora", id: 2, rt: 232},
            {group: "consonant", word: "fedora", id: 3, rt: 228}];

var opts = {method: "MCMC", burn: 10000, lag: 5, samples: 5000};

var ANSWER = Infer(opts, function() {
  var groupMeans = {vowel: gaussian(200, 100),
                    consonant: gaussian(200, 100)};
  
  var wordMean = mem(function(word, group) {
    return gaussian(groupMeans[group], 20);
  });
  
  var obsFn = function(d) {
    observe(Gaussian({mu: wordMean(d.word, d.group), sigma: 10}), d.rt);
  };
  
  mapData({data: data}, obsFn);
  
  return groupMeans['vowel'] - groupMeans['consonant'];
});

var data = [{group: "vowel", word: "abacus", id: 1, rt: 210},
            {group: "vowel", word: "abacus", id: 2, rt: 212},
            {group: "vowel", word: "abacus", id: 3, rt: 209},
            {group: "vowel", word: "aardvark", id: 1, rt: 200},
            {group: "vowel", word: "aardvark", id: 2, rt: 201},
            {group: "vowel", word: "aardvark", id: 3, rt: 198},
            {group: "vowel", word: "ellipse", id: 1, rt: 220},
            {group: "vowel", word: "ellipse", id: 2, rt: 222},
            {group: "vowel", word: "ellipse", id: 3, rt: 219},
            {group: "consonant", word: "proton", id: 1, rt: 190},
            {group: "consonant", word: "proton", id: 2, rt: 191},
            {group: "consonant", word: "proton", id: 3, rt: 189},
            {group: "consonant", word: "folder", id: 1, rt: 180},
            {group: "consonant", word: "folder", id: 2, rt: 182},
            {group: "consonant", word: "folder", id: 3, rt: 178},
            {group: "consonant", word: "fedora", id: 1, rt: 230},
            {group: "consonant", word: "fedora", id: 2, rt: 231},
            {group: "consonant", word: "fedora", id: 3, rt: 228},
            {group: "consonant", word: "fedora", id: 1, rt: 231},
            {group: "consonant", word: "fedora", id: 2, rt: 233},
            {group: "consonant", word: "fedora", id: 3, rt: 230},
            {group: "consonant", word: "fedora", id: 1, rt: 230},
            {group: "consonant", word: "fedora", id: 2, rt: 232},
            {group: "consonant", word: "fedora", id: 3, rt: 228}];

var opts = {method: "MCMC", burn: 10000, lag: 5, samples: 5000};

var ANSWER = Infer(opts, function() {
  var groupMeans = {vowel: gaussian(200, 100),
                    consonant: gaussian(200, 100)};
  
  var wordMean = mem(function(word, group) {
    return gaussian(groupMeans[group], 20);
  });
  
  var obsFn = function(d) {
    observe(Gaussian({mu: wordMean(d.word, d.group), sigma: 10}), d.rt);
  };
  
  mapData({data: data}, obsFn);
  
  return groupMeans['vowel'] - groupMeans['consonant'];
});

Error: Parameter "mu" should be of type "real".

var data = [{group: "vowel", word: "abacus", id: 1, rt: 210},
            {group: "vowel", word: "abacus", id: 2, rt: 212},
            {group: "vowel", word: "abacus", id: 3, rt: 209},
            {group: "vowel", word: "aardvark", id: 1, rt: 200},
            {group: "vowel", word: "aardvark", id: 2, rt: 201},
            {group: "vowel", word: "aardvark", id: 3, rt: 198},
            {group: "vowel", word: "ellipse", id: 1, rt: 220},
            {group: "vowel", word: "ellipse", id: 2, rt: 222},
            {group: "vowel", word: "ellipse", id: 3, rt: 219},
            {group: "consonant", word: "proton", id: 1, rt: 190},
            {group: "consonant", word: "proton", id: 2, rt: 191},
            {group: "consonant", word: "proton", id: 3, rt: 189},
            {group: "consonant", word: "folder", id: 1, rt: 180},
            {group: "consonant", word: "folder", id: 2, rt: 182},
            {group: "consonant", word: "folder", id: 3, rt: 178},
            {group: "consonant", word: "fedora", id: 1, rt: 230},
            {group: "consonant", word: "fedora", id: 2, rt: 231},
            {group: "consonant", word: "fedora", id: 3, rt: 228},
            {group: "consonant", word: "fedora", id: 1, rt: 231},
            {group: "consonant", word: "fedora", id: 2, rt: 233},
            {group: "consonant", word: "fedora", id: 3, rt: 230},
            {group: "consonant", word: "fedora", id: 1, rt: 230},
            {group: "consonant", word: "fedora", id: 2, rt: 232},
            {group: "consonant", word: "fedora", id: 3, rt: 228}];

var opts = {method: "MCMC", burn: 10000, lag: 5, samples: 5000};

var ANSWER = Infer(opts, function() {
  var groupMeans = {
    vowel: Gaussian({mu: 200, sigma: 100}),
    consonant: Gaussian({mu: 200, sigma: 100})
  };
  
  var wordMean = mem(function(word, group) {
    return Gaussian({mu: groupMeans[group], sigma: 20});
  });
  
  var obsFn = function(d) {
    observe(Gaussian({mu: wordMean(d.word, d.group), sigma: 10}), d.rt);
  };
  
  mapData({data: data}, obsFn);
  
  return groupMeans['vowel'] - groupMeans['consonant'];
});

var data = [{group: "vowel", word: "abacus", id: 1, rt: 210},
            {group: "vowel", word: "abacus", id: 2, rt: 212},
            {group: "vowel", word: "abacus", id: 3, rt: 209},
            {group: "vowel", word: "aardvark", id: 1, rt: 200},
            {group: "vowel", word: "aardvark", id: 2, rt: 201},
            {group: "vowel", word: "aardvark", id: 3, rt: 198},
            {group: "vowel", word: "ellipse", id: 1, rt: 220},
            {group: "vowel", word: "ellipse", id: 2, rt: 222},
            {group: "vowel", word: "ellipse", id: 3, rt: 219},
            {group: "consonant", word: "proton", id: 1, rt: 190},
            {group: "consonant", word: "proton", id: 2, rt: 191},
            {group: "consonant", word: "proton", id: 3, rt: 189},
            {group: "consonant", word: "folder", id: 1, rt: 180},
            {group: "consonant", word: "folder", id: 2, rt: 182},
            {group: "consonant", word: "folder", id: 3, rt: 178},
            {group: "consonant", word: "fedora", id: 1, rt: 230},
            {group: "consonant", word: "fedora", id: 2, rt: 231},
            {group: "consonant", word: "fedora", id: 3, rt: 228},
            {group: "consonant", word: "fedora", id: 1, rt: 231},
            {group: "consonant", word: "fedora", id: 2, rt: 233},
            {group: "consonant", word: "fedora", id: 3, rt: 230},
            {group: "consonant", word: "fedora", id: 1, rt: 230},
            {group: "consonant", word: "fedora", id: 2, rt: 232},
            {group: "consonant", word: "fedora", id: 3, rt: 228}];

var opts = {method: "MCMC", burn: 10000, lag: 5, samples: 5000};

var ANSWER = Infer(opts, function() {
  var groupMeans = {vowel: gaussian(200, 100),
                    consonant: gaussian(200, 100)};
  
  var wordMean = mem(function(word, group) {
    return gaussian(groupMeans[group], 20);
  });
  
  var obsFn = function(d) {
    observe(Gaussian({mu: wordMean(d.word, d.group), sigma: 10}), d.rt);
  };
  mapData({data: data}, obsFn);
  return groupMeans['vowel'] - groupMeans['consonant'];
});

var data = [{group: "vowel", word: "abacus", id: 1, rt: 210},
            {group: "vowel", word: "abacus", id: 2, rt: 212},
            {group: "vowel", word: "abacus", id: 3, rt: 209},
            {group: "vowel", word: "aardvark", id: 1, rt: 200},
            {group: "vowel", word: "aardvark", id: 2, rt: 201},
            {group: "vowel", word: "aardvark", id: 3, rt: 198},
            {group: "vowel", word: "ellipse", id: 1, rt: 220},
            {group: "vowel", word: "ellipse", id: 2, rt: 222},
            {group: "vowel", word: "ellipse", id: 3, rt: 219},
            {group: "consonant", word: "proton", id: 1, rt: 190},
            {group: "consonant", word: "proton", id: 2, rt: 191},
            {group: "consonant", word: "proton", id: 3, rt: 189},
            {group: "consonant", word: "folder", id: 1, rt: 180},
            {group: "consonant", word: "folder", id: 2, rt: 182},
            {group: "consonant", word: "folder", id: 3, rt: 178},
            {group: "consonant", word: "fedora", id: 1, rt: 230},
            {group: "consonant", word: "fedora", id: 2, rt: 231},
            {group: "consonant", word: "fedora", id: 3, rt: 228},
            {group: "consonant", word: "fedora", id: 1, rt: 231},
            {group: "consonant", word: "fedora", id: 2, rt: 233},
            {group: "consonant", word: "fedora", id: 3, rt: 230},
            {group: "consonant", word: "fedora", id: 1, rt: 230},
            {group: "consonant", word: "fedora", id: 2, rt: 232},
            {group: "consonant", word: "fedora", id: 3, rt: 228}];

var opts = {method: "MCMC", burn: 10000, lag: 5, samples: 5000};

var ANSWER = Infer(opts, function() {
  var groupMeans = {vowel: gaussian(200, 100),
                    consonant: gaussian(200, 100)};

  var wordMean = mem(function(word, group) {
    return gaussian(groupMeans[group], 20);
  });

  var obsFn = function(d) {
    observe(Gaussian({mu: wordMean(d.word, d.group), sigma: 10}), d.rt);
  };

  mapData({data: data}, obsFn);

  return groupMeans['vowel'] - groupMeans['consonant'];
});

var data = [{group: "vowel", word: "abacus", id: 1, rt: 210},
            {group: "vowel", word: "abacus", id: 2, rt: 212},
            {group: "vowel", word: "abacus", id: 3, rt: 209},
            {group: "vowel", word: "aardvark", id: 1, rt: 200},
            {group: "vowel", word: "aardvark", id: 2, rt: 201},
            {group: "vowel", word: "aardvark", id: 3, rt: 198},
            {group: "vowel", word: "ellipse", id: 1, rt: 220},
            {group: "vowel", word: "ellipse", id: 2, rt: 222},
            {group: "vowel", word: "ellipse", id: 3, rt: 219},
            {group: "consonant", word: "proton", id: 1, rt: 190},
            {group: "consonant", word: "proton", id: 2, rt: 191},
            {group: "consonant", word: "proton", id: 3, rt: 189},
            {group: "consonant", word: "folder", id: 1, rt: 180},
            {group: "consonant", word: "folder", id: 2, rt: 182},
            {group: "consonant", word: "folder", id: 3, rt: 178},
            {group: "consonant", word: "fedora", id: 1, rt: 230},
            {group: "consonant", word: "fedora", id: 2, rt: 231},
            {group: "consonant", word: "fedora", id: 3, rt: 228},
            {group: "consonant", word: "fedora", id: 1, rt: 231},
            {group: "consonant", word: "fedora", id: 2, rt: 233},
            {group: "consonant", word: "fedora", id: 3, rt: 230},
            {group: "consonant", word: "fedora", id: 1, rt: 230},
            {group: "consonant", word: "fedora", id: 2, rt: 232},
            {group: "consonant", word: "fedora", id: 3, rt: 228}];

var opts = {method: "MCMC", burn: 10000, lag: 5, samples: 5000};

var ANSWER = Infer(opts, function() {
  var groupMeans = {vowel: gaussian(200, 100),
                    consonant: gaussian(200, 100)};

  var wordMean = mem(function(word, group) {
    return gaussian(groupMeans[group], 20);
  });

  var obsFn = function(d) {
    observe(Gaussian({mu: wordMean(d.word, d.group), sigma: 10}), d.rt);
  };

  mapData({data: data}, obsFn);

  return groupMeans['vowel'] - groupMeans['consonant'];
});

var data = [{group: "vowel", word: "abacus", id: 1, rt: 210},
            {group: "vowel", word: "abacus", id: 2, rt: 212},
            {group: "vowel", word: "abacus", id: 3, rt: 209},
            {group: "vowel", word: "aardvark", id: 1, rt: 200},
            {group: "vowel", word: "aardvark", id: 2, rt: 201},
            {group: "vowel", word: "aardvark", id: 3, rt: 198},
            {group: "vowel", word: "ellipse", id: 1, rt: 220},
            {group: "vowel", word: "ellipse", id: 2, rt: 222},
            {group: "vowel", word: "ellipse", id: 3, rt: 219},
            {group: "consonant", word: "proton", id: 1, rt: 190},
            {group: "consonant", word: "proton", id: 2, rt: 191},
            {group: "consonant", word: "proton", id: 3, rt: 189},
            {group: "consonant", word: "folder", id: 1, rt: 180},
            {group: "consonant", word: "folder", id: 2, rt: 182},
            {group: "consonant", word: "folder", id: 3, rt: 178},
            {group: "consonant", word: "fedora", id: 1, rt: 230},
            {group: "consonant", word: "fedora", id: 2, rt: 231},
            {group: "consonant", word: "fedora", id: 3, rt: 228},
            {group: "consonant", word: "fedora", id: 1, rt: 231},
            {group: "consonant", word: "fedora", id: 2, rt: 233},
            {group: "consonant", word: "fedora", id: 3, rt: 230},
            {group: "consonant", word: "fedora", id: 1, rt: 230},
            {group: "consonant", word: "fedora", id: 2, rt: 232},
            {group: "consonant", word: "fedora", id: 3, rt: 228}];

var opts = {method: "MCMC", burn: 10000, lag: 5, samples: 5000};

var ANSWER = Infer(opts, function() {
  var groupMeans = {vowel: gaussian(200, 100),
                    consonant: gaussian(200, 100)};

  var wordMean = mem(function(word, group) {
    return gaussian(groupMeans[group], 20);
  });

  var obsFn = function(d) {
    observe(Gaussian({mu: wordMean(d.word, d.group), sigma: 10}), d.rt);
  };

  mapData({data: data}, obsFn);

  return groupMeans['vowel'] - groupMeans['consonant'];
});

var data = [{group: "vowel", word: "abacus", id: 1, rt: 210},
            {group: "vowel", word: "abacus", id: 2, rt: 212},
            {group: "vowel", word: "abacus", id: 3, rt: 209},
            {group: "vowel", word: "aardvark", id: 1, rt: 200},
            {group: "vowel", word: "aardvark", id: 2, rt: 201},
            {group: "vowel", word: "aardvark", id: 3, rt: 198},
            {group: "vowel", word: "ellipse", id: 1, rt: 220},
            {group: "vowel", word: "ellipse", id: 2, rt: 222},
            {group: "vowel", word: "ellipse", id: 3, rt: 219},
            {group: "consonant", word: "proton", id: 1, rt: 190},
            {group: "consonant", word: "proton", id: 2, rt: 191},
            {group: "consonant", word: "proton", id: 3, rt: 189},
            {group: "consonant", word: "folder", id: 1, rt: 180},
            {group: "consonant", word: "folder", id: 2, rt: 182},
            {group: "consonant", word: "folder", id: 3, rt: 178},
            {group: "consonant", word: "fedora", id: 1, rt: 230},
            {group: "consonant", word: "fedora", id: 2, rt: 231},
            {group: "consonant", word: "fedora", id: 3, rt: 228},
            {group: "consonant", word: "fedora", id: 1, rt: 231},
            {group: "consonant", word: "fedora", id: 2, rt: 233},
            {group: "consonant", word: "fedora", id: 3, rt: 230},
            {group: "consonant", word: "fedora", id: 1, rt: 230},
            {group: "consonant", word: "fedora", id: 2, rt: 232},
            {group: "consonant", word: "fedora", id: 3, rt: 228}];

var model = function() {
  // Group means
  var groupMeans = {
    vowel: gaussian(200, 100),
    consonant: gaussian(200, 100)
  };
  
  // Word means (memoized)
  var wordMean = mem(function(word, group) {
    return gaussian(groupMeans[group], 20);
  });
  
  // Participant random effects (memoized)
  var participantMean = mem(function(id) {
    return gaussian(0, 2);
  });
  
  // Likelihood
  mapData({data: data}, function(d) {
    var mu = wordMean(d.word, d.group) + participantMean(d.id);
    observe(Gaussian({mu: mu, sigma: 10}), d.rt);
  });
  
  return {
    diff: groupMeans.vowel - groupMeans.consonant,
    p1: participantMean(1),
    p2: participantMean(2),
    p3: participantMean(3)
  };
};

var ANSWER = Infer({method: 'MCMC', burn: 10000, lag: 5, samples: 5000}, model);

var data = [{group: "vowel", word: "abacus", id: 1, rt: 210},
            {group: "vowel", word: "abacus", id: 2, rt: 212},
            {group: "vowel", word: "abacus", id: 3, rt: 209},
            {group: "vowel", word: "aardvark", id: 1, rt: 200},
            {group: "vowel", word: "aardvark", id: 2, rt: 201},
            {group: "vowel", word: "aardvark", id: 3, rt: 198},
            {group: "vowel", word: "ellipse", id: 1, rt: 220},
            {group: "vowel", word: "ellipse", id: 2, rt: 222},
            {group: "vowel", word: "ellipse", id: 3, rt: 219},
            {group: "consonant", word: "proton", id: 1, rt: 190},
            {group: "consonant", word: "proton", id: 2, rt: 191},
            {group: "consonant", word: "proton", id: 3, rt: 189},
            {group: "consonant", word: "folder", id: 1, rt: 180},
            {group: "consonant", word: "folder", id: 2, rt: 182},
            {group: "consonant", word: "folder", id: 3, rt: 178},
            {group: "consonant", word: "fedora", id: 1, rt: 230},
            {group: "consonant", word: "fedora", id: 2, rt: 231},
            {group: "consonant", word: "fedora", id: 3, rt: 228},
            {group: "consonant", word: "fedora", id: 1, rt: 231},
            {group: "consonant", word: "fedora", id: 2, rt: 233},
            {group: "consonant", word: "fedora", id: 3, rt: 230},
            {group: "consonant", word: "fedora", id: 1, rt: 230},
            {group: "consonant", word: "fedora", id: 2, rt: 232},
            {group: "consonant", word: "fedora", id: 3, rt: 228}];

var model = function() {
  var groupMeans = {
    vowel: gaussian(200, 100),
    consonant: gaussian(200, 100)
  };
  
  var wordMean = mem(function(word, group) {
    return gaussian(groupMeans[group], 20);
  });
  
  var participantMean = mem(function(id) {
    return gaussian(0, 2);
  });
  
  mapData({data: data}, function(d) {
    var mu = wordMean(d.word, d.group) + participantMean(d.id);
    observe(Gaussian({mu: mu, sigma: 10}), d.rt);
  });
  
  return {
    diff: groupMeans.vowel - groupMeans.consonant,
    p1: participantMean(1),
    p2: participantMean(2),
    p3: participantMean(3)
  };
};

var ANSWER = Infer({method: 'MCMC', burn: 10000, lag: 5, samples: 5000}, model);

var data = [{group: "vowel", word: "abacus", id: 1, rt: 210},
            {group: "vowel", word: "abacus", id: 2, rt: 212},
            {group: "vowel", word: "abacus", id: 3, rt: 209},
            {group: "vowel", word: "aardvark", id: 1, rt: 200},
            {group: "vowel", word: "aardvark", id: 2, rt: 201},
            {group: "vowel", word: "aardvark", id: 3, rt: 198},
            {group: "vowel", word: "ellipse", id: 1, rt: 220},
            {group: "vowel", word: "ellipse", id: 2, rt: 222},
            {group: "vowel", word: "ellipse", id: 3, rt: 219},
            {group: "consonant", word: "proton", id: 1, rt: 190},
            {group: "consonant", word: "proton", id: 2, rt: 191},
            {group: "consonant", word: "proton", id: 3, rt: 189},
            {group: "consonant", word: "folder", id: 1, rt: 180},
            {group: "consonant", word: "folder", id: 2, rt: 182},
            {group: "consonant", word: "folder", id: 3, rt: 178},
            {group: "consonant", word: "fedora", id: 1, rt: 230},
            {group: "consonant", word: "fedora", id: 2, rt: 231},
            {group: "consonant", word: "fedora", id: 3, rt: 228},
            {group: "consonant", word: "fedora", id: 1, rt: 231},
            {group: "consonant", word: "fedora", id: 2, rt: 233},
            {group: "consonant", word: "fedora", id: 3, rt: 230},
            {group: "consonant", word: "fedora", id: 1, rt: 230},
            {group: "consonant", word: "fedora", id: 2, rt: 232},
            {group: "consonant", word: "fedora", id: 3, rt: 228}];

var model = function() {
  // Group-level means
  var groupMeans = {
    vowel: gaussian(200, 100),
    consonant: gaussian(200, 100)
  };
  
  // Word-level means (memoized by word and group)
  var wordMean = mem(function(word, group) {
    return gaussian(groupMeans[group], 20);
  });
  
  // Participant-level random effects
  var participantMean = mem(function(id) {
    return gaussian(0, 2);
  });
  
  // Likelihood: observe reading times
  map(function(d) {
    var mu = wordMean(d.word, d.group) + participantMean(d.id);
    observe(Gaussian({mu: mu, sigma: 10}), d.rt);
  }, data);
  
  // Return posterior samples
  return {
    diff: groupMeans['vowel'] - groupMeans['consonant'],
    p1: participantMean(1),
    p2: participantMean(2),
    p3: participantMean(3)
  };
};

var ANSWER = Infer({method: 'MCMC', burn: 10000, lag: 5, samples: 5000}, model);

var data = [{group: "vowel", word: "abacus", id: 1, rt: 210},
            {group: "vowel", word: "abacus", id: 2, rt: 212},
            {group: "vowel", word: "abacus", id: 3, rt: 209},
            {group: "vowel", word: "aardvark", id: 1, rt: 200},
            {group: "vowel", word: "aardvark", id: 2, rt: 201},
            {group: "vowel", word: "aardvark", id: 3, rt: 198},
            {group: "vowel", word: "ellipse", id: 1, rt: 220},
            {group: "vowel", word: "ellipse", id: 2, rt: 222},
            {group: "vowel", word: "ellipse", id: 3, rt: 219},
            {group: "consonant", word: "proton", id: 1, rt: 190},
            {group: "consonant", word: "proton", id: 2, rt: 191},
            {group: "consonant", word: "proton", id: 3, rt: 189},
            {group: "consonant", word: "folder", id: 1, rt: 180},
            {group: "consonant", word: "folder", id: 2, rt: 182},
            {group: "consonant", word: "folder", id: 3, rt: 178},
            {group: "consonant", word: "fedora", id: 1, rt: 230},
            {group: "consonant", word: "fedora", id: 2, rt: 231},
            {group: "consonant", word: "fedora", id: 3, rt: 228},
            {group: "consonant", word: "fedora", id: 1, rt: 231},
            {group: "consonant", word: "fedora", id: 2, rt: 233},
            {group: "consonant", word: "fedora", id: 3, rt: 230},
            {group: "consonant", word: "fedora", id: 1, rt: 230},
            {group: "consonant", word: "fedora", id: 2, rt: 232},
            {group: "consonant", word: "fedora", id: 3, rt: 228}];

var model = function() {
  // Group means drawn from Gaussian(200, 100)
  var groupMeans = {
    vowel: gaussian(200, 100),
    consonant: gaussian(200, 100)
  };
  
  // Word means: Gaussian(groupMean, 20) per word-group pair
  var wordMean = mem(function(word, group) {
    return gaussian(groupMeans[group], 20);
  });
  
  // Participant random effects: Gaussian(0, 2) per participant id
  var participantMean = mem(function(id) {
    return gaussian(0, 2);
  });
  
  // Likelihood: observe reading times
  mapData({data: data}, function(d) {
    var mu = wordMean(d.word, d.group) + participantMean(d.id);
    observe(Gaussian({mu: mu, sigma: 10}), d.rt);
  });
  
  // Return joint posterior of interest
  return {
    diff: groupMeans.vowel - groupMeans.consonant,
    p1: participantMean(1),
    p2: participantMean(2),
    p3: participantMean(3)
  };
};

var ANSWER = Infer({method: 'MCMC', burn: 10000, lag: 5, samples: 5000}, model);

var data = [{group: "vowel", word: "abacus", id: 1, rt: 210},
            {group: "vowel", word: "abacus", id: 2, rt: 212},
            {group: "vowel", word: "abacus", id: 3, rt: 209},
            {group: "vowel", word: "aardvark", id: 1, rt: 200},
            {group: "vowel", word: "aardvark", id: 2, rt: 201},
            {group: "vowel", word: "aardvark", id: 3, rt: 198},
            {group: "vowel", word: "ellipse", id: 1, rt: 220},
            {group: "vowel", word: "ellipse", id: 2, rt: 222},
            {group: "vowel", word: "ellipse", id: 3, rt: 219},
            {group: "consonant", word: "proton", id: 1, rt: 190},
            {group: "consonant", word: "proton", id: 2, rt: 191},
            {group: "consonant", word: "proton", id: 3, rt: 189},
            {group: "consonant", word: "folder", id: 1, rt: 180},
            {group: "consonant", word: "folder", id: 2, rt: 182},
            {group: "consonant", word: "folder", id: 3, rt: 178},
            {group: "consonant", word: "fedora", id: 1, rt: 230},
            {group: "consonant", word: "fedora", id: 2, rt: 231},
            {group: "consonant", word: "fedora", id: 3, rt: 228},
            {group: "consonant", word: "fedora", id: 1, rt: 231},
            {group: "consonant", word: "fedora", id: 2, rt: 233},
            {group: "consonant", word: "fedora", id: 3, rt: 230},
            {group: "consonant", word: "fedora", id: 1, rt: 230},
            {group: "consonant", word: "fedora", id: 2, rt: 232},
            {group: "consonant", word: "fedora", id: 3, rt: 228}];

var model = function() {
  var groupMeans = {
    vowel: gaussian(200, 100),
    consonant: gaussian(200, 100)
  };

  var wordMean = mem(function(word, group) {
    return gaussian(groupMeans[group], 20);
  });

  var participantMean = mem(function(id) {
    return gaussian(0, 2);
  });

  mapData({data: data}, function(d) {
    observe(Gaussian({mu: wordMean(d.word, d.group) + participantMean(d.id), sigma: 10}), d.rt);
  });

  return {
    diff: groupMeans['vowel'] - groupMeans['consonant'],
    p1: participantMean(1),
    p2: participantMean(2),
    p3: participantMean(3)
  };
};

var ANSWER = Infer({method: 'MCMC', burn: 10000, lag: 5, samples: 5000}, model);

var data = [{group: "vowel", word: "abacus", id: 1, rt: 210},
            {group: "vowel", word: "abacus", id: 2, rt: 212},
            {group: "vowel", word: "abacus", id: 3, rt: 209},
            {group: "vowel", word: "aardvark", id: 1, rt: 200},
            {group: "vowel", word: "aardvark", id: 2, rt: 201},
            {group: "vowel", word: "aardvark", id: 3, rt: 198},
            {group: "vowel", word: "ellipse", id: 1, rt: 220},
            {group: "vowel", word: "ellipse", id: 2, rt: 222},
            {group: "vowel", word: "ellipse", id: 3, rt: 219},
            {group: "consonant", word: "proton", id: 1, rt: 190},
            {group: "consonant", word: "proton", id: 2, rt: 191},
            {group: "consonant", word: "proton", id: 3, rt: 189},
            {group: "consonant", word: "folder", id: 1, rt: 180},
            {group: "consonant", word: "folder", id: 2, rt: 182},
            {group: "consonant", word: "folder", id: 3, rt: 178},
            {group: "consonant", word: "fedora", id: 1, rt: 230},
            {group: "consonant", word: "fedora", id: 2, rt: 231},
            {group: "consonant", word: "fedora", id: 3, rt: 228},
            {group: "consonant", word: "fedora", id: 1, rt: 231},
            {group: "consonant", word: "fedora", id: 2, rt: 233},
            {group: "consonant", word: "fedora", id: 3, rt: 230},
            {group: "consonant", word: "fedora", id: 1, rt: 230},
            {group: "consonant", word: "fedora", id: 2, rt: 232},
            {group: "consonant", word: "fedora", id: 3, rt: 228}];

var model = function() {
  var groupMeans = {
    vowel: gaussian(200, 100),
    consonant: gaussian(200, 100)
  };

  var wordMean = mem(function(word, group) {
    return gaussian(groupMeans[group], 20);
  });

  var participantMean = mem(function(id) {
    return gaussian(0, 2);
  });

  mapData({data: data}, function(d) {
    var mu = wordMean(d.word, d.group) + participantMean(d.id);
    observe(Gaussian({mu: mu, sigma: 10}), d.rt);
  });

  var diff = groupMeans['vowel'] - groupMeans['consonant'];
  var p1 = participantMean(1);
  var p2 = participantMean(2);
  var p3 = participantMean(3);

  return {diff: diff, p1: p1, p2: p2, p3: p3};
};

var ANSWER = Infer({method: 'MCMC', burn: 10000, lag: 5, samples: 5000}, model);

var data = [{group: "vowel", word: "abacus", id: 1, rt: 210},
            {group: "vowel", word: "abacus", id: 2, rt: 212},
            {group: "vowel", word: "abacus", id: 3, rt: 209},
            {group: "vowel", word: "aardvark", id: 1, rt: 200},
            {group: "vowel", word: "aardvark", id: 2, rt: 201},
            {group: "vowel", word: "aardvark", id: 3, rt: 198},
            {group: "vowel", word: "ellipse", id: 1, rt: 220},
            {group: "vowel", word: "ellipse", id: 2, rt: 222},
            {group: "vowel", word: "ellipse", id: 3, rt: 219},
            {group: "consonant", word: "proton", id: 1, rt: 190},
            {group: "consonant", word: "proton", id: 2, rt: 191},
            {group: "consonant", word: "proton", id: 3, rt: 189},
            {group: "consonant", word: "folder", id: 1, rt: 180},
            {group: "consonant", word: "folder", id: 2, rt: 182},
            {group: "consonant", word: "folder", id: 3, rt: 178},
            {group: "consonant", word: "fedora", id: 1, rt: 230},
            {group: "consonant", word: "fedora", id: 2, rt: 231},
            {group: "consonant", word: "fedora", id: 3, rt: 228},
            {group: "consonant", word: "fedora", id: 1, rt: 231},
            {group: "consonant", word: "fedora", id: 2, rt: 233},
            {group: "consonant", word: "fedora", id: 3, rt: 230},
            {group: "consonant", word: "fedora", id: 1, rt: 230},
            {group: "consonant", word: "fedora", id: 2, rt: 232},
            {group: "consonant", word: "fedora", id: 3, rt: 228}];

var model = function() {
  var groupMeans = {
    vowel: gaussian(200, 100),
    consonant: gaussian(200, 100)
  };

  var wordMean = mem(function(word, group) {
    return gaussian(groupMeans[group], 20);
  });

  var participantMean = mem(function(id) {
    return gaussian(0, 2);
  });

  mapData({data: data}, function(d) {
    var mu = wordMean(d.word, d.group) + participantMean(d.id);
    observe(Gaussian({mu: mu, sigma: 10}), d.rt);
  });

  var diff = groupMeans['vowel'] - groupMeans['consonant'];
  var p1 = participantMean(1);
  var p2 = participantMean(2);
  var p3 = participantMean(3);

  return {diff: diff, p1: p1, p2: p2, p3: p3};
};

var ANSWER = Infer({method: 'MCMC', burn: 10000, lag: 5, samples: 5000}, model);

var onCurve = function(x, y) {
  var x2 = x*x;
  var term1 = y - Math.pow(x2, 1/3);
  var crossSection = x2 + term1*term1 - 1;
  return Math.abs(crossSection) < 0.01;
};

var xbounds = [-1, 1];
var ybounds = [-1, 1.6];
var xmu = 0.5 * (xbounds[0] + xbounds[1]);
var ymu = 0.5 * (ybounds[0] + ybounds[1]);
var xsigma = 0.5 * (xbounds[1] - xbounds[0]);
var ysigma = 0.5 * (ybounds[1] - ybounds[0]);

var model = function() {
  var x = gaussian(xmu, xsigma);
  var y = gaussian(ymu, ysigma);
  condition(onCurve(x, y));
  return {x: x, y: y};
};

var ANSWER = Infer({method: 'MCMC', samples: 10000, lag: 10}, model);

var onCurve = function(x, y) {
  var x2 = x*x;
  var term1 = y - Math.pow(x2, 1/3);
  var crossSection = x2 + term1*term1 - 1;
  return Math.abs(crossSection) < 0.01;
};

var xbounds = [-1, 1];
var ybounds = [-1, 1.6];
var xmu = 0.5 * (xbounds[0] + xbounds[1]);
var ymu = 0.5 * (ybounds[0] + ybounds[1]);
var xsigma = 0.5 * (xbounds[1] - xbounds[0]);
var ysigma = 0.5 * (ybounds[1] - ybounds[0]);

var model = function() {
  var x = gaussian(xmu, xsigma);
  var y = gaussian(ymu, ysigma);
  condition(onCurve(x, y));
  return {x: x, y: y};
};

var ANSWER = Infer({method: 'MCMC', samples: 10000, lag: 10}, model);

var onCurve = function(x, y) {
  var x2 = x*x;
  var term1 = y - Math.pow(x2, 1/3);
  var crossSection = x2 + term1*term1 - 1;
  return Math.abs(crossSection) < 0.01;
};

var xbounds = [-1, 1];
var ybounds = [-1, 1.6];
var xmu = 0.5 * (xbounds[0] + xbounds[1]);
var ymu = 0.5 * (ybounds[0] + ybounds[1]);
var xsigma = 0.5 * (xbounds[1] - xbounds[0]);
var ysigma = 0.5 * (ybounds[1] - ybounds[0]);

var model = function() {
  var x = gaussian(xmu, xsigma);
  var y = gaussian(ymu, ysigma);
  condition(onCurve(x, y));
  return {x: x, y: y};
};

var ANSWER = Infer({method: 'MCMC', samples: 10000, lag: 10}, model);

var onCurve = function(x, y) {
  var x2 = x*x;
  var term1 = y - Math.pow(x2, 1/3);
  var crossSection = x2 + term1*term1 - 1;
  return Math.abs(crossSection) < 0.01;
};

var xbounds = [-1, 1];
var ybounds = [-1, 1.6];
var xmu = 0.5 * (xbounds[0] + xbounds[1]);
var ymu = 0.5 * (ybounds[0] + ybounds[1]);
var xsigma = 0.5 * (xbounds[1] - xbounds[0]);
var ysigma = 0.5 * (ybounds[1] - ybounds[0]);

var model = function() {
  var x = gaussian(xmu, xsigma);
  var y = gaussian(ymu, ysigma);
  condition(onCurve(x, y));
  return {x: x, y: y};
};

var ANSWER = Infer({method: 'MCMC', samples: 10000, lag: 10}, model);

var onCurve = function(x, y) {
  var x2 = x*x;
  var term1 = y - Math.pow(x2, 1/3);
  var crossSection = x2 + term1*term1 - 1;
  return Math.abs(crossSection) < 0.01;
};
var xbounds = [-1, 1];
var ybounds = [-1, 1.6];
var xmu = 0.5 * (xbounds[0] + xbounds[1]);
var ymu = 0.5 * (ybounds[0] + ybounds[1]);
var xsigma = 0.5 * (xbounds[1] - xbounds[0]);
var ysigma = 0.5 * (ybounds[1] - ybounds[0]);

var model = function() {
  var x = gaussian(xmu, xsigma);
  var y = gaussian(ymu, ysigma);
  condition(onCurve(x, y));
  return {x: x, y: y};
};

var ANSWER = Infer({method: 'MCMC', samples: 10000, lag: 10}, model);

var onCurve = function(x, y) {
  var x2 = x*x;
  var term1 = y - Math.pow(x2, 1/3);
  var crossSection = x2 + term1*term1 - 1;
  return Math.abs(crossSection) < 0.01;
};

var xbounds = [-1, 1];
var ybounds = [-1, 1.6];
var xmu = 0.5 * (xbounds[0] + xbounds[1]);
var ymu = 0.5 * (ybounds[0] + ybounds[1]);
var xsigma = 0.5 * (xbounds[1] - xbounds[0]);
var ysigma = 0.5 * (ybounds[1] - ybounds[0]);

var model = function() {
  var x = gaussian(xmu, xsigma);
  var y = gaussian(ymu, ysigma);
  condition(onCurve(x, y));
  return {x: x, y: y};
};

var ANSWER = Infer({method: 'MCMC', samples: 10000, lag: 10}, model);

var onCurve = function(x, y) {
  var x2 = x * x;
  var term1 = y - Math.pow(x2, 1/3);
  var crossSection = x2 + term1 * term1 - 1;
  return Math.abs(crossSection) < 0.01;
};

var xbounds = [-1, 1];
var ybounds = [-1, 1.6];
var xmu = 0.5 * (xbounds[0] + xbounds[1]);
var ymu = 0.5 * (ybounds[0] + ybounds[1]);
var xsigma = 0.5 * (xbounds[1] - xbounds[0]);
var ysigma = 0.5 * (ybounds[1] - ybounds[0]);

var model = function() {
  var x = gaussian(xmu, xsigma);
  var y = gaussian(ymu, ysigma);
  condition(onCurve(x, y));
  return { x: x, y: y };
};

var ANSWER = Infer({ method: 'MCMC', samples: 10000, lag: 10 }, model);

Error: Parameter "mu" should be of type "tensor".

var onCurve = function(x, y) {
  var x2 = x*x;
  var term1 = y - Math.pow(x2, 1/3);
  var crossSection = x2 + term1*term1 - 1;
  return Math.abs(crossSection) < 0.01;
};

var xbounds = [-1, 1];
var ybounds = [-1, 1.6];
var xmu = 0.5 * (xbounds[0] + xbounds[1]);
var ymu = 0.5 * (ybounds[0] + ybounds[1]);
var xsigma = 0.5 * (xbounds[1] - xbounds[0]);
var ysigma = 0.5 * (ybounds[1] - ybounds[0]);

var model = function() {
  var sample = diagCovGaussian({mu: [xmu, ymu], sigma: [xsigma, ysigma]});
  var x = T.get(sample, 0);
  var y = T.get(sample, 1);
  condition(onCurve(x, y));
  return {x: x, y: y};
};

var ANSWER = Infer({method: 'MCMC', samples: 1000, lag: 100}, model);

var onCurve = function(x, y) {
  var x2 = x*x;
  var term1 = y - Math.pow(x2, 1/3);
  var crossSection = x2 + term1*term1 - 1;
  return Math.abs(crossSection) < 0.01;
};

var xbounds = [-1, 1];
var ybounds = [-1, 1.6];
var xmu = 0.5 * (xbounds[0] + xbounds[1]);
var ymu = 0.5 * (ybounds[0] + ybounds[1]);
var xsigma = 0.5 * (xbounds[1] - xbounds[0]);
var ysigma = 0.5 * (ybounds[1] - ybounds[0]);

var diagCovGaussian = function(mu, sigma) {
  // mu and sigma are 2-element arrays [mu_x, mu_y] and [sigma_x, sigma_y]
  var x = gaussian(mu[0], sigma[0]);
  var y = gaussian(mu[1], sigma[1]);
  return Vector([x, y]);
};

var model = function() {
  var sample = diagCovGaussian([xmu, ymu], [xsigma, ysigma]);
  var x = T.get(sample, 0);
  var y = T.get(sample, 1);
  condition(onCurve(x, y));
  return {x: x, y: y};
};

var ANSWER = Infer({method: 'MCMC', samples: 1000, lag: 100}, model);

Error: Parameter "mu" should be of type "tensor".

var onCurve = function(x, y) {
  var x2 = x*x;
  var term1 = y - Math.pow(x2, 1/3);
  var crossSection = x2 + term1*term1 - 1;
  return Math.abs(crossSection) < 0.01;
};

var xbounds = [-1, 1];
var ybounds = [-1, 1.6];
var xmu = 0.5 * (xbounds[0] + xbounds[1]);
var ymu = 0.5 * (ybounds[0] + ybounds[1]);
var xsigma = 0.5 * (xbounds[1] - xbounds[0]);
var ysigma = 0.5 * (ybounds[1] - ybounds[0]);

var model = function() {
  var point = diagCovGaussian({mu: [xmu, ymu], sigma: [xsigma, ysigma]});
  var x = T.get(point, 0);
  var y = T.get(point, 1);
  
  condition(onCurve(x, y));
  
  return {x: x, y: y};
};

var ANSWER = Infer({method: 'MCMC', samples: 1000, lag: 100}, model);

var onCurve = function(x, y) {
  var x2 = x*x;
  var term1 = y - Math.pow(x2, 1/3);
  var crossSection = x2 + term1*term1 - 1;
  return Math.abs(crossSection) < 0.01;
};

var xbounds = [-1, 1];
var ybounds = [-1, 1.6];
var xmu = 0.5 * (xbounds[0] + xbounds[1]);
var ymu = 0.5 * (ybounds[0] + ybounds[1]);
var xsigma = 0.5 * (xbounds[1] - xbounds[0]);
var ysigma = 0.5 * (ybounds[1] - ybounds[0]);

var model = function() {
  var sample = diagCovGaussian({
    mu: Vector([xmu, ymu]),
    sigma: Vector([xsigma, ysigma])
  });
  
  var x = T.get(sample, 0);
  var y = T.get(sample, 1);
  
  condition(onCurve(x, y));
  
  return {x: x, y: y};
};

var ANSWER = Infer({method: 'MCMC', samples: 1000, lag: 100}, model);

var onCurve = function(x, y) {
  var x2 = x*x;
  var term1 = y - Math.pow(x2, 1/3);
  var crossSection = x2 + term1*term1 - 1;
  return Math.abs(crossSection) < 0.01;
};
var xbounds = [-1, 1];
var ybounds = [-1, 1.6];
var xmu = 0.5 * (xbounds[0] + xbounds[1]);
var ymu = 0.5 * (ybounds[0] + ybounds[1]);
var xsigma = 0.5 * (xbounds[1] - xbounds[0]);
var ysigma = 0.5 * (ybounds[1] - ybounds[0]);

var model = function() {
  var mu = Vector([xmu, ymu]);
  var sigma = Vector([xsigma, ysigma]);
  var sample = sample(DiagCovGaussian({mu: mu, sigma: sigma}));
  var x = T.get(sample, 0);
  var y = T.get(sample, 1);
  condition(onCurve(x, y));
  return {x: x, y: y};
};

var ANSWER = Infer({method: 'MCMC', samples: 1000, lag: 100}, model);

var onCurve = function(x, y) {
  var x2 = x * x;
  var term1 = y - Math.pow(x2, 1/3);
  var crossSection = x2 + term1 * term1 - 1;
  return Math.abs(crossSection) < 0.01;
};

var xbounds = [-1, 1];
var ybounds = [-1, 1.6];
var xmu = 0.5 * (xbounds[0] + xbounds[1]);
var ymu = 0.5 * (ybounds[0] + ybounds[1]);
var xsigma = 0.5 * (xbounds[1] - xbounds[0]);
var ysigma = 0.5 * (ybounds[1] - ybounds[0]);

var model = function() {
  var mu = Vector([xmu, ymu]);
  var sigma = Vector([xsigma, ysigma]);
  var sample = sample(DiagCovGaussian({mu: mu, sigma: sigma}));
  var x = T.get(sample, 0);
  var y = T.get(sample, 1);
  condition(onCurve(x, y));
  return {x: x, y: y};
};

var ANSWER = Infer({method: 'MCMC', samples: 1000, lag: 100}, model);

var onCurve = function(x, y) {
  var x2 = x * x;
  var term1 = y - Math.pow(x2, 1/3);
  var crossSection = x2 + term1 * term1 - 1;
  return Math.abs(crossSection) < 0.01;
};

var xbounds = [-1, 1];
var ybounds = [-1, 1.6];
var xmu = 0.5 * (xbounds[0] + xbounds[1]);
var ymu = 0.5 * (ybounds[0] + ybounds[1]);
var xsigma = 0.5 * (xbounds[1] - xbounds[0]);
var ysigma = 0.5 * (ybounds[1] - ybounds[0]);

var model = function() {
  var mu = Vector([xmu, ymu]);
  var sigma = Vector([xsigma, ysigma]);
  var xy = sample(DiagCovGaussian({mu: mu, sigma: sigma}));
  var x = T.get(xy, 0);
  var y = T.get(xy, 1);
  condition(onCurve(x, y));
  return {x: x, y: y};
};

var ANSWER = Infer({method: 'MCMC', samples: 1000, lag: 100}, model);

var onCurve = function(x, y) {
  var x2 = x*x;
  var term1 = y - Math.pow(x2, 1/3);
  var crossSection = x2 + term1*term1 - 1;
  return Math.abs(crossSection) < 0.01;
};

var xbounds = [-1, 1];
var ybounds = [-1, 1.6];
var xmu = 0.5 * (xbounds[0] + xbounds[1]);
var ymu = 0.5 * (ybounds[0] + ybounds[1]);
var xsigma = 0.5 * (xbounds[1] - xbounds[0]);
var ysigma = 0.5 * (ybounds[1] - ybounds[0]);

var model = function() {
  var x = gaussian(xmu, xsigma);
  var y = gaussian(ymu, ysigma);
  condition(onCurve(x, y));
  return {x: x, y: y};
};

var ANSWER = Infer({method: 'MCMC', samples: 10000, kernel: {HMC: {steps: 10, stepSize: .5}}}, model);

var onCurve = function(x, y) {
  var x2 = x*x;
  var term1 = y - Math.pow(x2, 1/3);
  var crossSection = x2 + term1*term1 - 1;
  return Math.abs(crossSection) < 0.01;
};

var xbounds = [-1, 1];
var ybounds = [-1, 1.6];
var xmu = 0.5 * (xbounds[0] + xbounds[1]);
var ymu = 0.5 * (ybounds[0] + ybounds[1]);
var xsigma = 0.5 * (xbounds[1] - xbounds[0]);
var ysigma = 0.5 * (ybounds[1] - ybounds[0]);

var model = function() {
  var x = gaussian(xmu, xsigma);
  var y = gaussian(ymu, ysigma);
  condition(onCurve(x, y));
  return {x: x, y: y};
};

var ANSWER = Infer({method: 'MCMC', samples: 10000, kernel: {HMC: {steps: 10, stepSize: 0.5}}}, model);

var onCurve = function(x, y) {
  var x2 = x*x;
  var term1 = y - Math.pow(x2, 1/3);
  var crossSection = x2 + term1*term1 - 1;
  return Math.abs(crossSection) < 0.01;
};

var xbounds = [-1, 1];
var ybounds = [-1, 1.6];
var xmu = 0.5 * (xbounds[0] + xbounds[1]);
var ymu = 0.5 * (ybounds[0] + ybounds[1]);
var xsigma = 0.5 * (xbounds[1] - xbounds[0]);
var ysigma = 0.5 * (ybounds[1] - ybounds[0]);

var model = function() {
  var x = gaussian(xmu, xsigma);
  var y = gaussian(ymu, ysigma);
  condition(onCurve(x, y));
  return {x: x, y: y};
};

var ANSWER = Infer({method: 'MCMC', samples: 10000, kernel: {HMC: {steps: 10, stepSize: .5}}}, model);

var onCurve = function(x, y) {
  var x2 = x*x;
  var term1 = y - Math.pow(x2, 1/3);
  var crossSection = x2 + term1*term1 - 1;
  return Math.abs(crossSection) < 0.01;
};

var xbounds = [-1, 1];
var ybounds = [-1, 1.6];
var xmu = 0.5 * (xbounds[0] + xbounds[1]);
var ymu = 0.5 * (ybounds[0] + ybounds[1]);
var xsigma = 0.5 * (xbounds[1] - xbounds[0]);
var ysigma = 0.5 * (ybounds[1] - ybounds[0]);

var model = function() {
  var x = gaussian(xmu, xsigma);
  var y = gaussian(ymu, ysigma);
  condition(onCurve(x, y));
  return {x: x, y: y};
};

var ANSWER = Infer({method: 'MCMC', samples: 10000, kernel: {HMC: {steps: 10, stepSize: 0.5}}}, model);

var onCurve = function(x, y) {
  var x2 = x*x;
  var term1 = y - Math.pow(x2, 1/3);
  var crossSection = x2 + term1*term1 - 1;
  return Math.abs(crossSection) < 0.01;
};
var xbounds = [-1, 1];
var ybounds = [-1, 1.6];
var xmu = 0.5 * (xbounds[0] + xbounds[1]);
var ymu = 0.5 * (ybounds[0] + ybounds[1]);
var xsigma = 0.5 * (xbounds[1] - xbounds[0]);
var ysigma = 0.5 * (ybounds[1] - ybounds[0]);

var model = function() {
  var x = gaussian(xmu, xsigma);
  var y = gaussian(ymu, ysigma);
  condition(onCurve(x, y));
  return {x: x, y: y};
};

var ANSWER = Infer({method: 'MCMC', samples: 10000, kernel: {HMC: {steps: 10, stepSize: .5}}}, model);

var onCurve = function(x, y) {
  var x2 = x*x;
  var term1 = y - Math.pow(x2, 1/3);
  var crossSection = x2 + term1*term1 - 1;
  return Math.abs(crossSection) < 0.01;
};

var xbounds = [-1, 1];
var ybounds = [-1, 1.6];
var xmu = 0.5 * (xbounds[0] + xbounds[1]);
var ymu = 0.5 * (ybounds[0] + ybounds[1]);
var xsigma = 0.5 * (xbounds[1] - xbounds[0]);
var ysigma = 0.5 * (ybounds[1] - ybounds[0]);

var model = function() {
  var x = gaussian(xmu, xsigma);
  var y = gaussian(ymu, ysigma);
  condition(onCurve(x, y));
  return {x: x, y: y};
};

var ANSWER = Infer({method: 'MCMC', samples: 10000, kernel: {HMC: {steps: 10, stepSize: .5}}}, model);

var onCurve = function(x, y) {
  var x2 = x*x;
  var term1 = y - Math.pow(x2, 1/3);
  var crossSection = x2 + term1*term1 - 1;
  return Math.abs(crossSection) < 0.01;
};

var xbounds = [-1, 1];
var ybounds = [-1, 1.6];
var xmu = 0.5 * (xbounds[0] + xbounds[1]);
var ymu = 0.5 * (ybounds[0] + ybounds[1]);
var xsigma = 0.5 * (xbounds[1] - xbounds[0]);
var ysigma = 0.5 * (ybounds[1] - ybounds[0]);

var model = function() {
  var x = gaussian(xmu, xsigma);
  var y = gaussian(ymu, ysigma);
  condition(onCurve(x, y));
  return {x: x, y: y};
};

var ANSWER = Infer({method: 'MCMC', samples: 10000, kernel: {HMC: {steps: 10, stepSize: .5}}}, model);

var interpolate = function(point1, point2, interpolationWeight) {
  return point1 * interpolationWeight + point2 * (1 - interpolationWeight);
};

var model = function() {
  var point1 = -10;
  var point2 = uniform(-100, 100);
  var interpolationWeight = uniform(0, 1);
  var pointInMiddle = interpolate(point1, point2, interpolationWeight);
  
  observe(Gaussian({mu: 0, sigma: 0.1}), pointInMiddle);
  
  return {point2: point2, interpolationWeight: interpolationWeight};
};

var posterior = Infer({method: 'MCMC', samples: 5000, lag: 100}, model);

var ANSWER = {
  point2: marginalize(posterior, 'point2'),
  interpolationWeight: marginalize(posterior, 'interpolationWeight')
};

var interpolate = function(point1, point2, interpolationWeight) {
  return point1 * interpolationWeight + point2 * (1 - interpolationWeight);
};

var model = function() {
  var point1 = -10;
  var point2 = uniform(-100, 100);
  var interpolationWeight = uniform(0, 1);
  var pointInMiddle = interpolate(point1, point2, interpolationWeight);
  
  observe(Gaussian({mu: 0, sigma: 0.1}), pointInMiddle);
  
  return {point2: point2, interpolationWeight: interpolationWeight};
};

var posterior = Infer({method: 'MCMC', samples: 5000, lag: 100}, model);

var ANSWER = {
  point2: marginalize(posterior, function(x) { return x.point2; }),
  interpolationWeight: marginalize(posterior, function(x) { return x.interpolationWeight; })
};

var interpolate = function(point1, point2, interpolationWeight) {
  return point1 * interpolationWeight + point2 * (1 - interpolationWeight);
};

var model = function() {
  var point1 = -10;
  var point2 = uniform(-100, 100);
  var interpolationWeight = uniform(0, 1);
  var pointInMiddle = interpolate(point1, point2, interpolationWeight);
  
  observe(Gaussian({mu: 0, sigma: 0.1}), pointInMiddle);
  
  return {point2: point2, interpolationWeight: interpolationWeight};
};

var posterior = Infer({method: 'MCMC', samples: 5000, lag: 100}, model);

var ANSWER = {
  point2: marginalize(posterior, 'point2'),
  interpolationWeight: marginalize(posterior, 'interpolationWeight')
};

var interpolate = function(point1, point2, interpolationWeight) {
  return point1 * interpolationWeight + point2 * (1 - interpolationWeight);
};

var model = function() {
  var point1 = -10;
  var point2 = uniform(-100, 100);
  var interpolationWeight = uniform(0, 1);
  var pointInMiddle = interpolate(point1, point2, interpolationWeight);
  
  observe(Gaussian({mu: 0, sigma: 0.1}), pointInMiddle);
  
  return {point2: point2, interpolationWeight: interpolationWeight};
};

var posterior = Infer(
  {method: 'MCMC', samples: 5000, lag: 100},
  model
);

var ANSWER = {
  point2: marginalize(posterior, function(x) { return x.point2; }),
  interpolationWeight: marginalize(posterior, function(x) { return x.interpolationWeight; })
};

var interpolate = function(point1, point2, interpolationWeight) {
  return point1 * interpolationWeight + point2 * (1 - interpolationWeight);
};

var model = function() {
  var point1 = -10;
  var point2 = uniform(-100, 100);
  var interpolationWeight = uniform(0, 1);
  var pointInMiddle = interpolate(point1, point2, interpolationWeight);
  observe(Gaussian({mu: 0, sigma: 0.1}), pointInMiddle);
  return {point2: point2, interpolationWeight: interpolationWeight};
};

var posterior = Infer({method: 'MCMC', samples: 5000, lag: 100}, model);

var ANSWER = {
  point2: marginalize(posterior, function(x) { return x.point2; }),
  interpolationWeight: marginalize(posterior, function(x) { return x.interpolationWeight; })
};

var interpolate = function(point1, point2, interpolationWeight) {
  return point1 * interpolationWeight + point2 * (1 - interpolationWeight);
};

var model = function() {
  var point1 = -10;
  var point2 = uniform(-100, 100);
  var interpolationWeight = uniform(0, 1);
  var pointInMiddle = interpolate(point1, point2, interpolationWeight);
  observe(Gaussian({mu: 0, sigma: 0.1}), pointInMiddle);
  return {point2: point2, interpolationWeight: interpolationWeight};
};

var posterior = Infer({method: 'MCMC', samples: 5000, lag: 100}, model);

var ANSWER = {
  point2: marginalize(posterior, function(x) { return x.point2; }),
  interpolationWeight: marginalize(posterior, function(x) { return x.interpolationWeight; })
};

var interpolate = function(point1, point2, interpolationWeight) {
  return point1 * interpolationWeight + point2 * (1 - interpolationWeight);
};

var model = function() {
  var point1 = -10;
  var point2 = uniform(-100, 100);
  var interpolationWeight = uniform(0, 1);
  var pointInMiddle = interpolate(point1, point2, interpolationWeight);
  observe(Gaussian({mu: 0, sigma: 0.1}), pointInMiddle);
  return {point2: point2, interpolationWeight: interpolationWeight};
};

var joint = Infer({method: 'MCMC', samples: 5000, lag: 100}, model);

var ANSWER = {
  point2: marginalize(joint, function(x) { return x.point2; }),
  interpolationWeight: marginalize(joint, function(x) { return x.interpolationWeight; })
};

var interpolate = function(point1, point2, interpolationWeight) {
  return point1 * interpolationWeight + point2 * (1 - interpolationWeight);
};

var model = function() {
  var point1 = -10;
  var point2 = uniform(-100, 100);
  var interpolationWeight = uniform(0, 1);
  var pointInMiddle = interpolate(point1, point2, interpolationWeight);
  
  observe(Gaussian({mu: 0, sigma: 0.1}), pointInMiddle);
  
  return {point2: point2, inter: interpolationWeight};
};

var posterior = Infer(
  {method: 'MCMC', samples: 5000, lag: 100},
  model
);

var ANSWER = posterior;

var interpolate = function(point1, point2, interpolationWeight) {
  return point1 * interpolationWeight + point2 * (1 - interpolationWeight);
};

var model = function() {
  var point1 = -10;
  var point2 = uniform(-100, 100);
  var interpolationWeight = uniform(0, 1);
  var pointInMiddle = interpolate(point1, point2, interpolationWeight);
  
  observe(Gaussian({mu: 0, sigma: 0.1}), pointInMiddle);
  
  return {point2: point2, inter: interpolationWeight};
};

var ANSWER = Infer({method: 'MCMC', samples: 5000, lag: 100}, model);

var interpolate = function(point1, point2, interpolationWeight) {
  return point1 * interpolationWeight + point2 * (1 - interpolationWeight);
};

var model = function() {
  var point1 = -10;
  var point2 = uniform(-100, 100);
  var interpolationWeight = uniform(0, 1);
  var pointInMiddle = interpolate(point1, point2, interpolationWeight);
  
  observe(Gaussian({mu: 0, sigma: 0.1}), pointInMiddle);
  
  return {point2: point2, inter: interpolationWeight};
};

var ANSWER = Infer({method: 'MCMC', samples: 5000, lag: 100}, model);

var interpolate = function(point1, point2, interpolationWeight) {
  return point1 * interpolationWeight + point2 * (1 - interpolationWeight);
};

var model = function() {
  var point1 = -10;
  var point2 = uniform(-100, 100);
  var interpolationWeight = uniform(0, 1);
  var pointInMiddle = interpolate(point1, point2, interpolationWeight);
  
  observe(Gaussian({mu: 0, sigma: 0.1}), pointInMiddle);
  
  return {point2: point2, inter: interpolationWeight};
};

var ANSWER = Infer({method: 'MCMC', samples: 5000, lag: 100}, model);

var interpolate = function(point1, point2, interpolationWeight) {
  return point1 * interpolationWeight + point2 * (1 - interpolationWeight);
};

var model = function() {
  var point1 = -10;
  var point2 = uniform(-100, 100);
  var interpolationWeight = uniform(0, 1);
  var pointInMiddle = interpolate(point1, point2, interpolationWeight);
  observe(Gaussian({mu: 0, sigma: 0.1}), pointInMiddle);
  return {point2: point2, inter: interpolationWeight};
};

var posterior = Infer({method: 'MCMC', samples: 5000, lag: 100}, model);

var ANSWER = marginalize(posterior, function(x) { return {point2: x.point2, inter: x.inter}; });

var interpolate = function(point1, point2, interpolationWeight) {
  return point1 * interpolationWeight + point2 * (1 - interpolationWeight);
};

var model = function() {
  var point1 = -10;
  var point2 = uniform(-100, 100);
  var interpolationWeight = uniform(0, 1);
  var pointInMiddle = interpolate(point1, point2, interpolationWeight);
  observe(Gaussian({mu: 0, sigma: 0.1}), pointInMiddle);
  return {point2: point2, inter: interpolationWeight};
};

var posterior = Infer({method: 'MCMC', samples: 5000, lag: 100}, model);

var ANSWER = marginalize(posterior, function(x) { return {point2: x.point2, inter: x.inter}; });

var interpolate = function(point1, point2, interpolationWeight) {
  return point1 * interpolationWeight + point2 * (1 - interpolationWeight);
};

var model = function() {
  var point1 = -10;
  var point2 = uniform(-100, 100);
  var interpolationWeight = uniform(0, 1);
  var pointInMiddle = interpolate(point1, point2, interpolationWeight);
  observe(Gaussian({mu: 0, sigma: 0.1}), pointInMiddle);
  return {point2: point2, inter: interpolationWeight};
};

var posterior = Infer({method: 'MCMC', samples: 5000, lag: 100}, model);

var ANSWER = marginalize(posterior, function(x) { return {point2: x.point2, inter: x.inter}; });

var interpolate = function(point1, point2, interpolationWeight) {
  return point1 * interpolationWeight + point2 * (1 - interpolationWeight);
};

var model = function() {
  var point1 = -10;
  var point2 = uniform(-100, 100);
  var interpolationWeight = uniform(0, 1);
  var pointInMiddle = interpolate(point1, point2, interpolationWeight);
  
  observe(Gaussian({mu: 0, sigma: 0.1}), pointInMiddle);
  
  return {
    point2: point2,
    interpolationWeight: interpolationWeight,
    pointInMiddle: pointInMiddle
  };
};

var posterior = Infer({
  method: 'MCMC',
  samples: 100,
  lag: 0
}, model);

var pointInMiddleValues = map(function(sample) {
  return sample.pointInMiddle;
}, posterior.samples);

var ANSWER = pointInMiddleValues;

var interpolate = function(point1, point2, interpolationWeight) {
  return point1 * interpolationWeight + point2 * (1 - interpolationWeight);
};

var model = function() {
  var point1 = -10;
  var point2 = uniform(-100, 100);
  var interpolationWeight = uniform(0, 1);
  var pointInMiddle = interpolate(point1, point2, interpolationWeight);
  
  observe(Gaussian({mu: 0, sigma: 0.1}), pointInMiddle);
  
  return {point2: point2, interpolationWeight: interpolationWeight, pointInMiddle: pointInMiddle};
};

var posterior = Infer({method: 'MCMC', samples: 100, lag: 0}, model);

var pointInMiddleValues = map(function(sample) {
  return sample.pointInMiddle;
}, posterior.samples);

var ANSWER = pointInMiddleValues;

var interpolate = function(point1, point2, interpolationWeight) {
  return point1 * interpolationWeight + point2 * (1 - interpolationWeight);
};

var model = function() {
  var point1 = -10;
  var point2 = uniform(-100, 100);
  var interpolationWeight = uniform(0, 1);
  var pointInMiddle = interpolate(point1, point2, interpolationWeight);
  
  observe(Gaussian({mu: 0, sigma: 0.1}), pointInMiddle);
  
  return {pointInMiddle: pointInMiddle};
};

var posterior = Infer({
  method: 'MCMC',
  samples: 100,
  lag: 0
}, model);

var pointInMiddleArray = map(function(sample) { return sample.pointInMiddle; }, posterior.samples);

var ANSWER = pointInMiddleArray;

var interpolate = function(point1, point2, interpolationWeight) {
  return point1 * interpolationWeight + point2 * (1 - interpolationWeight);
};

var posterior = Infer({method: 'MCMC', samples: 100, lag: 0}, function() {
  var point1 = -10;
  var point2 = uniform(-100, 100);
  var interpolationWeight = uniform(0, 1);
  var pointInMiddle = interpolate(point1, point2, interpolationWeight);
  
  observe(Gaussian({mu: 0, sigma: 0.1}), pointInMiddle);
  
  return {point2: point2, interpolationWeight: interpolationWeight, pointInMiddle: pointInMiddle};
});

var pointInMiddleValues = map(function(sample) {
  return sample.pointInMiddle;
}, posterior.samples);

var ANSWER = pointInMiddleValues;

var interpolate = function(point1, point2, interpolationWeight) {
  return point1 * interpolationWeight + point2 * (1 - interpolationWeight);
};

var model = function() {
  var point1 = -10;
  var point2 = uniform(-100, 100);
  var interpolationWeight = uniform(0, 1);
  var pointInMiddle = interpolate(point1, point2, interpolationWeight);
  observe(Gaussian({mu: 0, sigma: 0.1}), pointInMiddle);
  return pointInMiddle;
};

var posterior = Infer({method: 'MCMC', samples: 100, lag: 0}, model);

var ANSWER = map(function(s) { return s.value; }, posterior.samples);

var interpolate = function(point1, point2, interpolationWeight) {
  return point1 * interpolationWeight + point2 * (1 - interpolationWeight);
};

var model = function() {
  var point1 = -10;
  var point2 = uniform(-100, 100);
  var interpolationWeight = uniform(0, 1);
  var pointInMiddle = interpolate(point1, point2, interpolationWeight);
  observe(Gaussian({mu: 0, sigma: 0.1}), pointInMiddle);
  return { pointInMiddle: pointInMiddle };
};

var posterior = Infer({method: 'MCMC', samples: 100, lag: 0}, model);

var ANSWER = map(function(s) { return s.value.pointInMiddle; }, posterior.samples);

var interpolate = function(point1, point2, interpolationWeight) {
  return point1 * interpolationWeight + point2 * (1 - interpolationWeight);
};

var model = function() {
  var point1 = -10;
  var point2 = uniform(-100, 100);
  var interpolationWeight = uniform(0, 1);
  var pointInMiddle = interpolate(point1, point2, interpolationWeight);
  observe(Gaussian({mu: 0, sigma: 0.1}), pointInMiddle);
  return {pointInMiddle: pointInMiddle};
};

var posterior = Infer({method: 'MCMC', samples: 100, lag: 0}, model);

var ANSWER = map(function(s) { return s.value.pointInMiddle; }, posterior.samples);

var interpolate = function(point1, point2, interpolationWeight) {
  return point1 * interpolationWeight + point2 * (1 - interpolationWeight);
};

var model = function() {
  var point1 = -10;
  var point2 = uniform(-100, 100);
  var interpolationWeight = uniform(0, 1);
  var pointInMiddle = interpolate(point1, point2, interpolationWeight);
  
  condition(Math.abs(pointInMiddle) < 0.01);
  
  return {
    point2: point2,
    interpolationWeight: interpolationWeight,
    pointInMiddle: pointInMiddle
  };
};

var ANSWER = Infer({method: 'rejection', samples: 1000}, model);

var interpolate = function(point1, point2, interpolationWeight) {
  return point1 * interpolationWeight + point2 * (1 - interpolationWeight);
};

var model = function() {
  var point1 = -10;
  var point2 = uniform(-100, 100);
  var interpolationWeight = uniform(0, 1);
  var pointInMiddle = interpolate(point1, point2, interpolationWeight);
  
  condition(Math.abs(pointInMiddle) < 0.01);
  
  return {
    point2: point2,
    interpolationWeight: interpolationWeight,
    pointInMiddle: pointInMiddle
  };
};

var ANSWER = Infer({method: 'rejection', samples: 1000}, model);

var interpolate = function(point1, point2, interpolationWeight) {
  return point1 * interpolationWeight + point2 * (1 - interpolationWeight);
};

var model = function() {
  var point1 = -10;
  var point2 = uniform(-100, 100);
  var interpolationWeight = uniform(0, 1);
  var pointInMiddle = interpolate(point1, point2, interpolationWeight);
  
  condition(Math.abs(pointInMiddle) < 0.01);
  
  return {
    point2: point2,
    interpolationWeight: interpolationWeight,
    pointInMiddle: pointInMiddle
  };
};

var ANSWER = Infer({method: 'rejection', samples: 1000}, model);

var interpolate = function(point1, point2, interpolationWeight) {
  return point1 * interpolationWeight + point2 * (1 - interpolationWeight);
};

var model = function() {
  var point1 = -10;
  var point2 = uniform(-100, 100);
  var interpolationWeight = uniform(0, 1);
  var pointInMiddle = interpolate(point1, point2, interpolationWeight);
  
  condition(Math.abs(pointInMiddle) < 0.01);
  
  return {point2: point2, interpolationWeight: interpolationWeight, pointInMiddle: pointInMiddle};
};

var ANSWER = Infer({method: 'rejection', samples: 1000}, model);

var interpolate = function(point1, point2, interpolationWeight) {
  return point1 * interpolationWeight + point2 * (1 - interpolationWeight);
};

var model = function() {
  var point1 = -10;
  var point2 = uniform(-100, 100);
  var interpolationWeight = uniform(0, 1);
  var pointInMiddle = interpolate(point1, point2, interpolationWeight);
  condition(Math.abs(pointInMiddle) < 0.01);
  return { point2: point2, interpolationWeight: interpolationWeight, pointInMiddle: pointInMiddle };
};

var ANSWER = Infer({method: 'rejection', samples: 1000}, model);

var interpolate = function(point1, point2, interpolationWeight) {
  return point1 * interpolationWeight + point2 * (1 - interpolationWeight);
};

var model = function() {
  var point1 = -10;
  var point2 = uniform(-100, 100);
  var interpolationWeight = uniform(0, 1);
  var pointInMiddle = interpolate(point1, point2, interpolationWeight);

  condition(Math.abs(pointInMiddle) < 0.01);

  return { point2: point2, interpolationWeight: interpolationWeight, pointInMiddle: pointInMiddle };
};

var ANSWER = Infer({method: 'rejection', samples: 1000}, model);

var interpolate = function(point1, point2, interpolationWeight) {
  return point1 * interpolationWeight + point2 * (1 - interpolationWeight);
};

var model = function() {
  var point1 = -10;
  var point2 = uniform(-100, 100);
  var interpolationWeight = uniform(0, 1);
  var pointInMiddle = interpolate(point1, point2, interpolationWeight);

  condition(Math.abs(pointInMiddle) < 0.01);

  return { point2: point2, interpolationWeight: interpolationWeight, pointInMiddle: pointInMiddle };
};

var ANSWER = Infer({method: 'rejection', samples: 1000}, model);

var interpolate = function(point1, point2, interpolationWeight) {
  return point1 * interpolationWeight + point2 * (1 - interpolationWeight);
};

var model = function() {
  var point1 = -10;
  var point2 = uniformDrift({a: -100, b: 100, width: 0.1});
  var interpolationWeight = uniform(0, 1);
  var pointInMiddle = interpolate(point1, point2, interpolationWeight);
  
  observe(Gaussian({mu: 0, sigma: 0.1}), pointInMiddle);
  
  return {
    point2: point2,
    interpolationWeight: interpolationWeight,
    pointInMiddle: pointInMiddle
  };
};

var ANSWER = Infer({method: 'MCMC', samples: 500}, model);

var interpolate = function(point1, point2, interpolationWeight) {
  return point1 * interpolationWeight + point2 * (1 - interpolationWeight);
};

var model = function() {
  var point1 = -10;
  var point2 = uniformDrift({a: -100, b: 100, width: 0.1});
  var interpolationWeight = uniform(0, 1);
  var pointInMiddle = interpolate(point1, point2, interpolationWeight);
  
  observe(Gaussian({mu: 0, sigma: 0.1}), pointInMiddle);
  
  return {
    point2: point2,
    interpolationWeight: interpolationWeight,
    pointInMiddle: pointInMiddle
  };
};

var ANSWER = Infer({method: 'MCMC', samples: 500}, model);

var interpolate = function(point1, point2, interpolationWeight) {
  return point1 * interpolationWeight + point2 * (1 - interpolationWeight);
};

var model = function() {
  var point1 = -10;
  var point2 = uniformDrift({a: -100, b: 100, width: 0.1});
  var interpolationWeight = uniform({a: 0, b: 1});
  var pointInMiddle = interpolate(point1, point2, interpolationWeight);
  
  observe(Gaussian({mu: 0, sigma: 0.1}), pointInMiddle);
  
  return {
    point2: point2,
    interpolationWeight: interpolationWeight,
    pointInMiddle: pointInMiddle
  };
};

var ANSWER = Infer({method: 'MCMC', samples: 500}, model);

var interpolate = function(point1, point2, interpolationWeight) {
  return point1 * interpolationWeight + point2 * (1 - interpolationWeight);
};

var model = function() {
  var point1 = -10;
  var point2 = uniformDrift({a: -100, b: 100, width: 0.1});
  var interpolationWeight = uniform(0, 1);
  var pointInMiddle = interpolate(point1, point2, interpolationWeight);
  
  observe(Gaussian({mu: 0, sigma: 0.1}), pointInMiddle);
  
  return {
    point2: point2,
    interpolationWeight: interpolationWeight,
    pointInMiddle: pointInMiddle
  };
};

var ANSWER = Infer({method: 'MCMC', samples: 500}, model);

ReferenceError: UniformDrift is not defined

var uniformDrift = function(params) {
  var a = params.a;
  var b = params.b;
  var width = params.width;
  var current = sample(Uniform({a: a, b: b}));
  return current;
};

var interpolate = function(point1, point2, interpolationWeight) {
  return point1 * interpolationWeight + point2 * (1 - interpolationWeight);
};

var model = function() {
  var point1 = -10;
  var point2 = sample(UniformDrift({a: -100, b: 100, width: 0.1}));
  var interpolationWeight = sample(UniformDrift({a: 0, b: 1, width: 0.1}));
  var pointInMiddle = interpolate(point1, point2, interpolationWeight);
  observe(Gaussian({mu: 0, sigma: 0.1}), pointInMiddle);
  return {point2: point2, interpolationWeight: interpolationWeight, pointInMiddle: pointInMiddle};
};

var ANSWER = Infer({method: 'MCMC', samples: 500}, model);

Error: sample() expected a distribution but received "-99.67316120640561".

var interpolate = function(point1, point2, interpolationWeight) {
  return point1 * interpolationWeight + point2 * (1 - interpolationWeight);
};

var model = function() {
  var point1 = -10;
  var point2 = sample(uniformDrift({a: -100, b: 100, width: 0.1}));
  var interpolationWeight = sample(Uniform({a: 0, b: 1}));
  var pointInMiddle = interpolate(point1, point2, interpolationWeight);
  observe(Gaussian({mu: 0, sigma: 0.1}), pointInMiddle);
  return {point2: point2, interpolationWeight: interpolationWeight, pointInMiddle: pointInMiddle};
};

var ANSWER = Infer({method: 'MCMC', samples: 500}, model);

var interpolate = function(point1, point2, interpolationWeight) {
  return point1 * interpolationWeight + point2 * (1 - interpolationWeight);
};

var model = function() {
  var point1 = -10;
  var point2 = uniformDrift({a: -100, b: 100, width: 0.1});
  var interpolationWeight = uniform(0, 1);
  var pointInMiddle = interpolate(point1, point2, interpolationWeight);
  observe(Gaussian({mu: 0, sigma: 0.1}), pointInMiddle);
  return {point2: point2, interpolationWeight: interpolationWeight, pointInMiddle: pointInMiddle};
};

var ANSWER = Infer({method: 'MCMC', samples: 500}, model);

Error: Parameter "vs" missing from Categorical distribution.

var vocabulary = ['DNA', 'evolution', 'parsing', 'phonology'];
var eta = ones([vocabulary.length, 1]);
var numTopics = 2;
var alpha = ones([numTopics, 1]);

var corpus = [
  ['DNA', 'evolution'],
  ['DNA', 'evolution', 'DNA'],
  ['parsing', 'phonology'],
  ['parsing', 'phonology', 'parsing'],
  ['DNA', 'parsing'],
  ['evolution', 'phonology']
];

var ANSWER = Infer({method: 'MCMC', samples: 200, lag: 50}, function() {
  var topics = repeat(numTopics, function() {
    return T.toScalars(dirichlet({alpha: eta}));
  });
  
  mapData({data: corpus}, function(doc) {
    var docTopicDist = T.toScalars(dirichlet({alpha: alpha}));
    mapData({data: doc}, function(word) {
      var topic = categorical({ps: docTopicDist});
      var wordDist = topics[topic];
      var wordIndex = indexOf(word, vocabulary);
      observe(categorical({ps: wordDist}), wordIndex);
    });
  });
  
  return topics;
});

var vocabulary = ['DNA', 'evolution', 'parsing', 'phonology'];
var eta = ones([vocabulary.length, 1]);
var numTopics = 2;
var alpha = ones([numTopics, 1]);

var corpus = [
  ['DNA', 'evolution'],
  ['DNA', 'evolution', 'DNA'],
  ['parsing', 'phonology'],
  ['parsing', 'phonology', 'parsing'],
  ['DNA', 'parsing'],
  ['evolution', 'phonology']
];

var ANSWER = Infer({method: 'MCMC', samples: 200, lag: 50}, function() {
  var topics = repeat(numTopics, function() {
    return T.toScalars(dirichlet({alpha: eta}));
  });
  
  mapData({data: corpus}, function(doc) {
    var docTopicDist = T.toScalars(dirichlet({alpha: alpha}));
    mapData({data: doc}, function(word) {
      var wordIdx = _.indexOf(vocabulary, word);
      var topic = categorical({vs: _.range(0, numTopics), ps: docTopicDist});
      observe(Categorical({vs: _.range(0, vocabulary.length), ps: topics[topic]}), wordIdx);
    });
  });
  
  return topics;
});

Error: Parameter "vs" missing from Categorical distribution.

var vocabulary = ['DNA', 'evolution', 'parsing', 'phonology'];
var eta = ones([vocabulary.length, 1])
var numTopics = 2
var alpha = ones([numTopics, 1])

var corpus = [
  ['DNA', 'evolution'],
  ['DNA', 'evolution', 'DNA'],
  ['parsing', 'phonology'],
  ['parsing', 'phonology', 'parsing'],
  ['DNA', 'evolution', 'parsing'],
  ['phonology', 'evolution']
];

var ANSWER = Infer({method: 'MCMC', samples: 200, lag: 50}, function() {
  var topics = repeat(numTopics, function() {
    return T.toScalars(dirichlet({alpha: eta}))
  })
  mapData({data: corpus}, function(doc) {
    var docTopicDist = T.toScalars(dirichlet({alpha: alpha}))
    mapData({data: doc}, function(word) {
      var topic = categorical({ps: docTopicDist})
      var wordProbs = topics[topic]
      var wordIndex = vocabulary.indexOf(word)
      observe(categorical({ps: wordProbs}), wordIndex)
    })
  })
  return topics
});

Error: Parameter "vs" missing from Categorical distribution.

var vocabulary = ['DNA', 'evolution', 'parsing', 'phonology'];
var eta = ones([vocabulary.length, 1]);
var numTopics = 2;
var alpha = ones([numTopics, 1]);

var corpus = [
  ['DNA', 'evolution', 'DNA'],
  ['parsing', 'phonology', 'parsing'],
  ['DNA', 'evolution'],
  ['phonology', 'parsing', 'phonology'],
  ['DNA', 'DNA', 'evolution'],
  ['parsing', 'phonology']
];

var ANSWER = Infer({method: 'MCMC', samples: 200, lag: 50}, function() {
  var topics = repeat(numTopics, function() {
    return T.toScalars(dirichlet({alpha: eta}));
  });
  
  mapData({data: corpus}, function(doc) {
    var docTopicDist = T.toScalars(dirichlet({alpha: alpha}));
    mapData({data: doc}, function(word) {
      var topic = categorical({ps: docTopicDist});
      var wordDist = topics[topic];
      observe(Categorical({vs: vocabulary, ps: wordDist}), word);
    });
  });
  
  return topics;
});

var vocabulary = ['DNA', 'evolution', 'parsing', 'phonology'];
var eta = ones([vocabulary.length, 1]);
var numTopics = 2;
var alpha = ones([numTopics, 1]);

var corpus = [
  ['DNA', 'evolution', 'DNA', 'evolution'],
  ['DNA', 'DNA', 'evolution', 'evolution'],
  ['parsing', 'phonology', 'parsing', 'phonology'],
  ['parsing', 'parsing', 'phonology', 'phonology'],
  ['DNA', 'evolution', 'parsing', 'phonology'],
  ['DNA', 'parsing', 'evolution', 'phonology']
];

var ANSWER = Infer({method: 'MCMC', samples: 200, lag: 50}, function() {
  var topics = repeat(numTopics, function() {
    return T.toScalars(dirichlet({alpha: eta}));
  });

  mapData({data: corpus}, function(doc) {
    var topicDist = T.toScalars(dirichlet({alpha: alpha}));

    mapData({data: doc}, function(word) {
      var topicIdx = sample(Discrete({ps: topicDist}));
      var wordDist = topics[topicIdx];
      observe(Discrete({ps: wordDist}), vocabulary.indexOf(word));
    });
  });

  return topics;
});

var vocabulary = ['DNA', 'evolution', 'parsing', 'phonology'];
var eta = ones([vocabulary.length, 1]);
var numTopics = 2;
var alpha = ones([numTopics, 1]);

var corpus = [
  ['DNA', 'evolution', 'DNA', 'evolution'],
  ['DNA', 'DNA', 'evolution', 'evolution'],
  ['parsing', 'phonology', 'parsing', 'phonology'],
  ['parsing', 'parsing', 'phonology', 'phonology'],
  ['DNA', 'evolution', 'parsing', 'phonology'],
  ['phonology', 'phonology', 'evolution', 'DNA']
];

var ANSWER = Infer({method: 'MCMC', samples: 200, lag: 50}, function() {
  // Draw topic distributions over vocabulary
  var topics = repeat(numTopics, function() {
    return T.toScalars(dirichlet({alpha: eta}));
  });

  mapData({data: corpus}, function(doc) {
    // Per-document topic distribution
    var topicDist = T.toScalars(dirichlet({alpha: alpha}));

    mapData({data: doc}, function(word) {
      // Draw a topic for this word
      var topicIndex = sample(Discrete({ps: topicDist}));
      // Observe the word under the chosen topic's distribution
      var wordDist = topics[topicIndex];
      observe(Discrete({ps: wordDist}), vocabulary.indexOf(word));
    });
  });

  return topics;
});

var vocabulary = ['DNA', 'evolution', 'parsing', 'phonology'];
var eta = ones([vocabulary.length, 1]);
var numTopics = 2;
var alpha = ones([numTopics, 1]);

var corpus = [
  ['DNA', 'evolution', 'DNA', 'evolution'],
  ['DNA', 'DNA', 'evolution', 'evolution'],
  ['evolution', 'DNA', 'evolution', 'DNA'],
  ['parsing', 'phonology', 'parsing', 'phonology'],
  ['phonology', 'parsing', 'phonology', 'parsing'],
  ['parsing', 'parsing', 'phonology', 'phonology']
];

var ANSWER = Infer({method: 'MCMC', samples: 200, lag: 50}, function() {
  var topics = repeat(numTopics, function() {
    return T.toScalars(dirichlet({alpha: eta}));
  });

  mapData({data: corpus}, function(doc) {
    var topicDist = T.toScalars(dirichlet({alpha: alpha}));

    mapData({data: doc}, function(word) {
      var topicIdx = sample(Categorical({vs: _.range(numTopics), ps: topicDist}));
      var wordDist = topics[topicIdx];
      observe(Categorical({vs: vocabulary, ps: wordDist}), word);
    });
  });

  return topics;
});

var weightPosterior = function(observedData){
  return Infer({method: 'MCMC', burn:1000, samples: 10000}, function() {
    var isFair = flip(0.9);
    var realWeight = isFair ? 0.5 : (flip(0.7) ? 1.0 : uniform({a:0, b:1}));
    var coin = Bernoulli({p: realWeight});
    var obsFn = function(datum){ observe(coin, datum=='h') };
    mapData({data: observedData}, obsFn);
    return realWeight;
  })
}

var fullDataSet = repeat(50, function() { 'h' });
var observedDataSizes = [0,1,2,4,6,8,10,12,15,20,25,30,40,50];
var ANSWER = map(function(N) { expectation(weightPosterior(fullDataSet.slice(0, N))) }, observedDataSizes);

var weightPosterior = function(observedData){
  return Infer({method: 'MCMC', burn:1000, samples: 10000}, function() {
    var isFair = flip(0.9);
    var realWeight = isFair ? 0.5 : (flip(0.7) ? 0.5 : uniform({a:0, b:1}));
    var coin = Bernoulli({p: realWeight});
    var obsFn = function(datum){ observe(coin, datum=='h') };
    mapData({data: observedData}, obsFn);
    return realWeight;
  })
}

var fullDataSet = repeat(50, function() { 'h' });
var observedDataSizes = [0,1,2,4,6,8,10,12,15,20,25,30,40,50];
var ANSWER = map(function(N) { expectation(weightPosterior(fullDataSet.slice(0, N))) }, observedDataSizes);

Error: Line 32: Did you mean var realWeight = ?

var weightPosterior = function(observedData){
  return Infer({method: 'MCMC', burn:1000, samples: 10000}, function() {
    var isFair = flip(0.9);
    var realWeight;
    if (isFair) {
      realWeight = 0.5;
    } else {
      var isTwoFaced = flip(0.7);
      realWeight = isTwoFaced ? 1 : uniform({a:0, b:1});
    }
    var coin = Bernoulli({p: realWeight});
    var obsFn = function(datum){ observe(coin, datum=='h') };
    mapData({data: observedData}, obsFn);
    return realWeight;
  })
}

var fullDataSet = repeat(50, function() { 'h' }); 
var observedDataSizes = [0,1,2,4,6,8,10,12,15,20,25,30,40,50]; 
var ANSWER = map(function(N) { expectation(weightPosterior(fullDataSet.slice(0, N))) }, observedDataSizes);

var weightPosterior = function(observedData){
  return Infer({method: 'MCMC', burn:1000, samples: 10000}, function() {
    var isFair = flip(0.9);
    var realWeight = isFair ? 0.5 : 
      (flip(0.7) ? (flip(0.5) ? 0 : 1) : uniform({a:0, b:1}));
    var coin = Bernoulli({p: realWeight});
    var obsFn = function(datum){ observe(coin, datum=='h') };
    mapData({data: observedData}, obsFn);
    return realWeight;
  })
}

var fullDataSet = repeat(50, function() { 'h' });
var observedDataSizes = [0,1,2,4,6,8,10,12,15,20,25,30,40,50];
var ANSWER = map(function(N) { expectation(weightPosterior(fullDataSet.slice(0, N))) }, observedDataSizes);

var weightPosterior = function(observedData){
  return Infer({method: 'MCMC', burn:1000, samples: 10000}, function() {
    var isFair = flip(0.9);
    var realWeight = isFair ? 0.5 : (flip(0.7) ? 1.0 : uniform({a:0, b:1}));
    var coin = Bernoulli({p: realWeight});
    var obsFn = function(datum){ observe(coin, datum=='h') };
    mapData({data: observedData}, obsFn);
    return realWeight;
  })
}

var fullDataSet = repeat(50, function() { return 'h' });
var observedDataSizes = [0,1,2,4,6,8,10,12,15,20,25,30,40,50];
var ANSWER = map(function(N) { expectation(weightPosterior(fullDataSet.slice(0, N))) }, observedDataSizes);

Error: Line 32: Did you mean var realWeight = ?

var weightPosterior = function(observedData){
  return Infer({method: 'MCMC', burn:1000, samples: 10000}, function() {
    var isFair = flip(0.9);
    var realWeight;
    if (isFair) {
      realWeight = 0.5;
    } else {
      // Within biased class: two-faced with prob 0.7, uniform otherwise
      var isTwoFaced = flip(0.7);
      if (isTwoFaced) {
        // Two-faced: always heads or always tails
        realWeight = flip(0.5) ? 1 : 0;
      } else {
        realWeight = uniform({a: 0, b: 1});
      }
    }
    var coin = Bernoulli({p: realWeight});
    var obsFn = function(datum){ observe(coin, datum=='h') };
    mapData({data: observedData}, obsFn);
    return realWeight;
  })
}

var fullDataSet = repeat(50, function() { 'h' }); var observedDataSizes = [0,1,2,4,6,8,10,12,15,20,25,30,40,50]; var ANSWER = map(function(N) { expectation(weightPosterior(fullDataSet.slice(0, N))) }, observedDataSizes);

var weightPosterior = function(observedData){
  return Infer({method: 'MCMC', burn:1000, samples: 10000}, function() {
    var isFair = flip(0.9);
    var realWeight = isFair
      ? 0.5
      : (function() {
          var isTwoFaced = flip(0.7);
          return isTwoFaced
            ? (flip(0.5) ? 1 : 0)   // two-faced: always heads or always tails
            : uniform({a: 0, b: 1}); // otherwise uniform on (0,1)
        })();
    var coin = Bernoulli({p: realWeight});
    var obsFn = function(datum){ observe(coin, datum == 'h'); };
    mapData({data: observedData}, obsFn);
    return realWeight;
  });
};

var fullDataSet = repeat(50, function() { return 'h'; });
var observedDataSizes = [0,1,2,4,6,8,10,12,15,20,25,30,40,50];
var ANSWER = map(function(N) { expectation(weightPosterior(fullDataSet.slice(0, N))); }, observedDataSizes);

var pseudoCounts = {a: 10, b: 10};
var weightPosterior = function(observedData){
  return Infer({method: 'MCMC', burn:1000, samples: 1000}, function() {
    var coinWeight = sample(Beta(pseudoCounts));
    var coinDist = Bernoulli({p: coinWeight});
    var obsFn = function(datum){ observe(coinDist, datum=='h') };
    mapData({data: observedData}, obsFn);
    return coinWeight;
  })
}
var fullDataSet = repeat(50, function() { ['h', 't'] }).flat();

var prior = Beta(pseudoCounts);
var post = weightPosterior(fullDataSet);

var ANSWER = {
  prior: prior,
  post: post
};

var pseudoCounts = {a: 10, b: 10};

var weightPosterior = function(observedData){
  return Infer({method: 'MCMC', burn:1000, samples: 1000}, function() {
    var coinWeight = sample(Beta(pseudoCounts));
    var coinDist = Bernoulli({p: coinWeight});
    var obsFn = function(datum){ observe(coinDist, datum=='h') };
    mapData({data: observedData}, obsFn);
    return coinWeight;
  })
};

var fullDataSet = repeat(50, function() { return ['h', 't']; }).flat();

var prior = Beta(pseudoCounts);

var post = weightPosterior(fullDataSet);

var ANSWER = {
  prior: prior,
  post: post
};

var pseudoCounts = {a: 10, b: 10};

var weightPosterior = function(observedData){
  return Infer({method: 'MCMC', burn:1000, samples: 1000}, function() {
    var coinWeight = sample(Beta(pseudoCounts));
    var coinDist = Bernoulli({p: coinWeight});
    var obsFn = function(datum){ observe(coinDist, datum=='h') };
    mapData({data: observedData}, obsFn);
    return coinWeight;
  })
}

var fullDataSet = repeat(50, function() { ['h', 't'] }).flat();

var prior = Infer({method: 'MCMC', burn:1000, samples: 1000}, function() {
  var coinWeight = sample(Beta(pseudoCounts));
  return coinWeight;
});

var post = weightPosterior(fullDataSet);

var ANSWER = {prior: prior, post: post};

var pseudoCounts = {a: 10, b: 10};

var weightPosterior = function(observedData){
  return Infer({method: 'MCMC', burn:1000, samples: 1000}, function() {
    var coinWeight = sample(Beta(pseudoCounts));
    var coinDist = Bernoulli({p: coinWeight});
    var obsFn = function(datum){ observe(coinDist, datum=='h') };
    mapData({data: observedData}, obsFn);
    return coinWeight;
  })
};

var fullDataSet = repeat(50, function() { ['h', 't'] }).flat();

var prior = Beta(pseudoCounts);
var post = weightPosterior(fullDataSet);

var ANSWER = {prior: prior, post: post};

var pseudoCounts = {a: 10, b: 10};

var weightPosterior = function(observedData){
  return Infer({method: 'MCMC', burn:1000, samples: 5000}, function() {
    var coinWeight = sample(Beta(pseudoCounts));
    var coinDist = Bernoulli({p: coinWeight});
    var obsFn = function(datum){ observe(coinDist, datum=='h') };
    mapData({data: observedData}, obsFn);
    return coinWeight;
  })
};

var fullDataSet = repeat(50, function() { return ['h', 't']; }).flat();

var prior = Infer({method: 'forward', samples: 5000}, function() {
  return sample(Beta(pseudoCounts));
});

var post = weightPosterior(fullDataSet);

var ANSWER = {prior: prior, post: post};

var pseudoCounts = {a: 10, b: 10};

var weightPosterior = function(observedData){
  return Infer({method: 'MCMC', burn:1000, samples: 1000}, function() {
    var coinWeight = sample(Beta(pseudoCounts));
    var coinDist = Bernoulli({p: coinWeight});
    var obsFn = function(datum){ observe(coinDist, datum=='h') };
    mapData({data: observedData}, obsFn);
    return coinWeight;
  })
}

var fullDataSet = repeat(50, function() { return ['h', 't']; }).flat();

var prior = Infer({method: 'forward', samples: 1000}, function() {
  return sample(Beta(pseudoCounts));
});

var post = weightPosterior(fullDataSet);

var ANSWER = {prior: prior, post: post};

var pseudoCounts = {a: 10, b: 10};

var weightPosterior = function(observedData) {
  return Infer({method: 'MCMC', burn: 1000, samples: 1000}, function() {
    var coinWeight = sample(Beta(pseudoCounts));
    var coinDist = Bernoulli({p: coinWeight});
    var obsFn = function(datum) { observe(coinDist, datum == 'h'); };
    mapData({data: observedData}, obsFn);
    return coinWeight;
  });
};

var fullDataSet = _.flatten(repeat(50, function() { return ['h', 't']; }));

var prior = Infer({method: 'forward', samples: 1000}, function() {
  return sample(Beta(pseudoCounts));
});

var post = weightPosterior(fullDataSet);

var ANSWER = {prior: prior, post: post};

var pseudoCounts = {a: 10, b: 10};
var weightPosterior = function(observedData){
  return Infer({method: 'MCMC', burn:1000, samples: 1000}, function() {
    var coinWeight = sample(Beta(pseudoCounts));
    var coinDist = Bernoulli({p: coinWeight});
    var obsFn = function(datum){ observe(coinDist, datum=='h') };
    mapData({data: observedData}, obsFn);
    return coinWeight;
  })
}

var fullData = repeat(256, function(){return ['h','t']}).flat();

var dataSizes = [0,2,4,8,16,32,64,128,256,512];

var variances = map(function(size) {
  var observedData = fullData.slice(0, size);
  var posterior = weightPosterior(observedData);
  var mean = expectation(posterior, function(x) { return x; });
  var variance = expectation(posterior, function(x) { return Math.pow(x - mean, 2); });
  return variance;
}, dataSizes);

var ANSWER = variances;

var pseudoCounts = {a: 10, b: 10};
var weightPosterior = function(observedData){
  return Infer({method: 'MCMC', burn:1000, samples: 1000}, function() {
    var coinWeight = sample(Beta(pseudoCounts));
    var coinDist = Bernoulli({p: coinWeight});
    var obsFn = function(datum){ observe(coinDist, datum=='h') };
    mapData({data: observedData}, obsFn);
    return coinWeight;
  })
}

var fullData = _.flatten(repeat(256, function(){return ['h','t']}));
var dataSizes = [0,2,4,8,16,32,64,128,256,512];

var variances = map(function(size) {
  var observedData = size === 0 ? [] : fullData.slice(0, size);
  var posterior = weightPosterior(observedData);
  var mean = expectation(posterior);
  var variance = expectation(posterior, function(x) { 
    return Math.pow(x - mean, 2); 
  });
  return variance;
}, dataSizes);

var ANSWER = variances;

var pseudoCounts = {a: 10, b: 10};

var weightPosterior = function(observedData){
  return Infer({method: 'MCMC', burn:1000, samples: 1000}, function() {
    var coinWeight = sample(Beta(pseudoCounts));
    var coinDist = Bernoulli({p: coinWeight});
    var obsFn = function(datum){ observe(coinDist, datum=='h') };
    mapData({data: observedData}, obsFn);
    return coinWeight;
  })
}

// Generate alternating h,t data
var fullData = repeat(256, function(){['h','t']}).flat();

// Data sizes to test
var dataSizes = [0,2,4,8,16,32,64,128,256,512];

// Compute variance of posterior for each data size
var variances = map(function(size) {
  var data = fullData.slice(0, size);
  var posterior = weightPosterior(data);
  var mean = expectation(posterior);
  var variance = expectation(posterior, function(x) { 
    return Math.pow(x - mean, 2) 
  });
  return variance;
}, dataSizes);

var ANSWER = variances;

var pseudoCounts = {a: 10, b: 10};

var weightPosterior = function(observedData){
  return Infer({method: 'MCMC', burn:1000, samples: 1000}, function() {
    var coinWeight = sample(Beta(pseudoCounts));
    var coinDist = Bernoulli({p: coinWeight});
    var obsFn = function(datum){ observe(coinDist, datum=='h') };
    mapData({data: observedData}, obsFn);
    return coinWeight;
  })
};

// Create the alternating data: ['h','t','h','t',...] repeated 256 times = 512 elements
var fullData = _.flatten(repeat(256, function(){ return ['h','t']; }));

// Data sizes to test
var dataSizes = [0,2,4,8,16,32,64,128,256,512];

// Compute variances for each data size
var variances = map(function(size) {
  var data = size === 0 ? [] : fullData.slice(0, size);
  var posterior = weightPosterior(data);
  var mean = expectation(posterior);
  var variance = expectation(posterior, function(x) { Math.pow(x - mean, 2) });
  return variance;
}, dataSizes);

var ANSWER = variances;

var pseudoCounts = {a: 10, b: 10};

var weightPosterior = function(observedData){
  return Infer({method: 'MCMC', burn:1000, samples: 1000}, function() {
    var coinWeight = sample(Beta(pseudoCounts));
    var coinDist = Bernoulli({p: coinWeight});
    var obsFn = function(datum){ observe(coinDist, datum=='h') };
    mapData({data: observedData}, obsFn);
    return coinWeight;
  })
};

// Create the full alternating dataset of 512 elements
var fullData = repeat(256, function(){ return ['h','t']; });
var flatData = [].concat.apply([], fullData);

var dataSizes = [0, 2, 4, 8, 16, 32, 64, 128, 256, 512];

var variances = map(function(n) {
  var observedData = flatData.slice(0, n);
  var posterior = weightPosterior(observedData);
  var mean = expectation(posterior, function(x){ return x; });
  var variance = expectation(posterior, function(x){ return Math.pow(x - mean, 2); });
  return variance;
}, dataSizes);

var ANSWER = variances;

var pseudoCounts = {a: 10, b: 10};
var weightPosterior = function(observedData){
  return Infer({method: 'MCMC', burn:1000, samples: 1000}, function() {
    var coinWeight = sample(Beta(pseudoCounts));
    var coinDist = Bernoulli({p: coinWeight});
    var obsFn = function(datum){ observe(coinDist, datum=='h') };
    mapData({data: observedData}, obsFn);
    return coinWeight;
  })
};

var fullData = [].concat.apply([], repeat(256, function(){ return ['h','t']; }));

var dataSizes = [0, 2, 4, 8, 16, 32, 64, 128, 256, 512];

var variances = map(function(n) {
  var data = fullData.slice(0, n);
  var posterior = weightPosterior(data);
  var mean = expectation(posterior, function(x){ return x; });
  var variance = expectation(posterior, function(x){ return Math.pow(x - mean, 2); });
  return variance;
}, dataSizes);

var ANSWER = variances;

var pseudoCounts = {a: 10, b: 10};

var weightPosterior = function(observedData) {
  return Infer({method: 'MCMC', burn: 1000, samples: 1000}, function() {
    var coinWeight = sample(Beta(pseudoCounts));
    var coinDist = Bernoulli({p: coinWeight});
    var obsFn = function(datum) { observe(coinDist, datum == 'h'); };
    mapData({data: observedData}, obsFn);
    return coinWeight;
  });
};

var fullData = _.flatten(repeat(256, function() { return ['h', 't']; }));

var dataSizes = [0, 2, 4, 8, 16, 32, 64, 128, 256, 512];

var variances = map(function(n) {
  var data = fullData.slice(0, n);
  var posterior = weightPosterior(data);
  var mean = expectation(posterior);
  var variance = expectation(posterior, function(x) {
    return Math.pow(x - mean, 2);
  });
  return variance;
}, dataSizes);

var ANSWER = variances;

Error: Too many arguments. Distributions take at most one argument.

var data = [
  {antennae: false, green: false, blarghNoise: false},
  {antennae: true,  green: true,  blarghNoise: true},
  {antennae: true,  green: true,  blarghNoise: true},
  {antennae: true,  green: true,  blarghNoise: true},
  {antennae: false, green: false, blarghNoise: false},
  {antennae: true,  green: true,  blarghNoise: true},
  {antennae: false, green: false, blarghNoise: false},
  {antennae: true,  green: true,  blarghNoise: true},
  {antennae: false, green: false, blarghNoise: false},
  {antennae: false, green: false, blarghNoise: false}
];

var model = function() {
  // Memoized function to generate group prototypes
  var getGroupPrototype = mem(function(groupId) {
    return {
      antennae: sample(Beta(0.5, 0.5)),
      green: sample(Beta(0.5, 0.5)),
      blarghNoise: sample(Beta(0.5, 0.5))
    };
  });
  
  // Get the two group prototypes
  var group1 = getGroupPrototype(1);
  var group2 = getGroupPrototype(2);
  
  // Observe each alien
  mapData({data: data}, function(alien) {
    // Each alien belongs to group 1 or 2 with equal probability
    var group = flip(0.5) ? group1 : group2;
    
    // Observe the alien's properties given their group
    observe(Bernoulli(group.antennae), alien.antennae);
    observe(Bernoulli(group.green), alien.green);
    observe(Bernoulli(group.blarghNoise), alien.blarghNoise);
  });
  
  return {group1: group1, group2: group2};
};

var ANSWER = Infer({method: 'MCMC', kernel: {HMC: {steps: 10, stepSize: .01}}, samples: 3000}, model);

Timeout after 60s

var data = [
  {antennae: false, green: false, blarghNoise: false},
  {antennae: true,  green: true,  blarghNoise: true},
  {antennae: true,  green: true,  blarghNoise: true},
  {antennae: true,  green: true,  blarghNoise: true},
  {antennae: false, green: false, blarghNoise: false},
  {antennae: true,  green: true,  blarghNoise: true},
  {antennae: false, green: false, blarghNoise: false},
  {antennae: true,  green: true,  blarghNoise: true},
  {antennae: false, green: false, blarghNoise: false},
  {antennae: false, green: false, blarghNoise: false}
];

var model = function() {
  // Memoized function to generate group prototype
  var getGroupPrototype = mem(function(groupId) {
    return {
      antennae: sample(Beta({a: 0.5, b: 0.5})),
      green: sample(Beta({a: 0.5, b: 0.5})),
      blarghNoise: sample(Beta({a: 0.5, b: 0.5}))
    };
  });

  var group1 = getGroupPrototype(1);
  var group2 = getGroupPrototype(2);

  // Observe each alien
  mapData({data: data}, function(alien) {
    // Each alien belongs to one of two groups with equal probability
    var groupId = flip(0.5) ? 1 : 2;
    var prototype = groupId === 1 ? group1 : group2;

    // Observe the alien's properties given the group prototype
    observe(Bernoulli({p: prototype.antennae}), alien.antennae ? 1 : 0);
    observe(Bernoulli({p: prototype.green}), alien.green ? 1 : 0);
    observe(Bernoulli({p: prototype.blarghNoise}), alien.blarghNoise ? 1 : 0);
  });

  return {group1: group1, group2: group2};
};

var ANSWER = Infer({method: 'MCMC', kernel: {HMC: {steps: 10, stepSize: 0.01}}, samples: 3000}, model);

Error: Too many arguments. Distributions take at most one argument.

var data = [
  {antennae: false, green: false, blarghNoise: false},
  {antennae: true,  green: true,  blarghNoise: true},
  {antennae: true,  green: true,  blarghNoise: true},
  {antennae: true,  green: true,  blarghNoise: true},
  {antennae: false, green: false, blarghNoise: false},
  {antennae: true,  green: true,  blarghNoise: true},
  {antennae: false, green: false, blarghNoise: false},
  {antennae: true,  green: true,  blarghNoise: true},
  {antennae: false, green: false, blarghNoise: false},
  {antennae: false, green: false, blarghNoise: false}
];

var model = function() {
  // Memoized per-group prototype generator
  var groupPrototype = mem(function(groupId) {
    return {
      antennae: sample(Beta(.5, .5)),
      green: sample(Beta(.5, .5)),
      blarghNoise: sample(Beta(.5, .5))
    };
  });
  
  // For each alien, sample group membership and condition on observations
  _.each(data, function(alien) {
    // 50/50 prior over group membership
    var group = sample(Categorical({ps: [0.5, 0.5], vs: [1, 2]}));
    var prototype = groupPrototype(group);
    
    // Likelihood of observed properties given group prototype
    var antennaeLik = alien.antennae ? prototype.antennae : (1 - prototype.antennae);
    var greenLik = alien.green ? prototype.green : (1 - prototype.green);
    var blarghLik = alien.blarghNoise ? prototype.blarghNoise : (1 - prototype.blarghNoise);
    
    factor(Math.log(antennaeLik * greenLik * blarghLik));
  });
  
  // Return posterior over both group prototypes
  return {
    group1: groupPrototype(1),
    group2: groupPrototype(2)
  };
};

var ANSWER = Infer({method: 'MCMC', kernel: {HMC: {steps: 10, stepSize: .01}}, samples: 3000}, model);

var data = [
  {antennae: false, green: false, blarghNoise: false},
  {antennae: true,  green: true,  blarghNoise: true},
  {antennae: true,  green: true,  blarghNoise: true},
  {antennae: true,  green: true,  blarghNoise: true},
  {antennae: false, green: false, blarghNoise: false},
  {antennae: true,  green: true,  blarghNoise: true},
  {antennae: false, green: false, blarghNoise: false},
  {antennae: true,  green: true,  blarghNoise: true},
  {antennae: false, green: false, blarghNoise: false},
  {antennae: false, green: false, blarghNoise: false}
];

var model = function() {
  // Memoized function to generate per-group prototype
  var getGroupPrototype = mem(function(groupId) {
    return {
      antennae: sample(Beta({a: 0.5, b: 0.5})),
      green: sample(Beta({a: 0.5, b: 0.5})),
      blarghNoise: sample(Beta({a: 0.5, b: 0.5}))
    };
  });
  
  var group1 = getGroupPrototype(1);
  var group2 = getGroupPrototype(2);
  
  // For each alien, sample which group it belongs to and observe its properties
  mapData({data: data}, function(alien) {
    var group = flip(0.5) ? 1 : 2;
    var prototype = group === 1 ? group1 : group2;
    
    observe(Bernoulli({p: prototype.antennae}), alien.antennae);
    observe(Bernoulli({p: prototype.green}), alien.green);
    observe(Bernoulli({p: prototype.blarghNoise}), alien.blarghNoise);
  });
  
  return {group1: group1, group2: group2};
};

var ANSWER = Infer({method: 'MCMC', kernel: {HMC: {steps: 10, stepSize: .01}}, samples: 3000}, model);

var data = [
  {antennae: false, green: false, blarghNoise: false},
  {antennae: true,  green: true,  blarghNoise: true},
  {antennae: true,  green: true,  blarghNoise: true},
  {antennae: true,  green: true,  blarghNoise: true},
  {antennae: false, green: false, blarghNoise: false},
  {antennae: true,  green: true,  blarghNoise: true},
  {antennae: false, green: false, blarghNoise: false},
  {antennae: true,  green: true,  blarghNoise: true},
  {antennae: false, green: false, blarghNoise: false},
  {antennae: false, green: false, blarghNoise: false}
];

var model = function() {
  var prototype = mem(function(group) {
    return {
      antennae: sample(Beta({a: 0.5, b: 0.5})),
      green: sample(Beta({a: 0.5, b: 0.5})),
      blarghNoise: sample(Beta({a: 0.5, b: 0.5}))
    };
  });

  mapData({data: data}, function(alien) {
    var group = sample(Categorical({ps: [0.5, 0.5], vs: [1, 2]}));
    var proto = prototype(group);
    observe(Bernoulli({p: proto.antennae}), alien.antennae);
    observe(Bernoulli({p: proto.green}), alien.green);
    observe(Bernoulli({p: proto.blarghNoise}), alien.blarghNoise);
  });

  return {
    group1: prototype(1),
    group2: prototype(2)
  };
};

var ANSWER = Infer({method: 'MCMC', kernel: {HMC: {steps: 10, stepSize: .01}}, samples: 3000}, model);

Error: Too many arguments. Distributions take at most one argument.

var data = [
  {antennae: false, green: false, blarghNoise: false},
  {antennae: true,  green: true,  blarghNoise: true},
  {antennae: true,  green: true,  blarghNoise: true},
  {antennae: true,  green: true,  blarghNoise: true},
  {antennae: false, green: false, blarghNoise: false},
  {antennae: true,  green: true,  blarghNoise: true},
  {antennae: false, green: false, blarghNoise: false},
  {antennae: true,  green: true,  blarghNoise: true},
  {antennae: false, green: false, blarghNoise: false},
  {antennae: false, green: false, blarghNoise: false}
];

var model = function() {

  // Memoized per-group prototypes with Beta(.5,.5) priors on each property
  var prototype = mem(function(group) {
    return {
      antennae:   sample(Beta(.5, .5)),
      green:      sample(Beta(.5, .5)),
      blarghNoise: sample(Beta(.5, .5))
    };
  });

  // For each alien, marginalize out the discrete group assignment so that
  // the model is fully continuous and compatible with HMC.
  mapData({data: data}, function(alien) {
    var proto1 = prototype(1);
    var proto2 = prototype(2);

    // Log-likelihood of this alien's data under group 1
    var loglik1 = Bernoulli({p: proto1.antennae}).score(alien.antennae)
                + Bernoulli({p: proto1.green}).score(alien.green)
                + Bernoulli({p: proto1.blarghNoise}).score(alien.blarghNoise);

    // Log-likelihood of this alien's data under group 2
    var loglik2 = Bernoulli({p: proto2.antennae}).score(alien.antennae)
                + Bernoulli({p: proto2.green}).score(alien.green)
                + Bernoulli({p: proto2.blarghNoise}).score(alien.blarghNoise);

    // 50/50 mixture: log( 0.5*p1 + 0.5*p2 ) = log(0.5) + logSumExp(loglik1, loglik2)
    var logMarginal = Math.log(0.5)
                    + Math.log(Math.exp(loglik1) + Math.exp(loglik2));

    factor(logMarginal);
  });

  return {
    group1: prototype(1),
    group2: prototype(2)
  };
};

var ANSWER = Infer(
  {method: 'MCMC', kernel: {HMC: {steps: 10, stepSize: .01}}, samples: 3000},
  model
);

var data = [
  {antennae: false, green: false, blarghNoise: false},
  {antennae: true,  green: true,  blarghNoise: true},
  {antennae: true,  green: true,  blarghNoise: true},
  {antennae: true,  green: true,  blarghNoise: true},
  {antennae: false, green: false, blarghNoise: false},
  {antennae: true,  green: true,  blarghNoise: true},
  {antennae: false, green: false, blarghNoise: false},
  {antennae: true,  green: true,  blarghNoise: true},
  {antennae: false, green: false, blarghNoise: false},
  {antennae: false, green: false, blarghNoise: false}
];

var logsumexp2 = function(a, b) {
  var m = Math.max(a, b);
  return m + Math.log(Math.exp(a - m) + Math.exp(b - m));
};

var model = function() {

  var getPrototype = mem(function(group) {
    return {
      antennae:   beta(.5, .5),
      green:      beta(.5, .5),
      blarghNoise: beta(.5, .5)
    };
  });

  var alienLogLik = function(alien, group) {
    var proto = getPrototype(group);
    return (
      Bernoulli({p: proto.antennae}).score(alien.antennae) +
      Bernoulli({p: proto.green}).score(alien.green) +
      Bernoulli({p: proto.blarghNoise}).score(alien.blarghNoise)
    );
  };

  mapData({data: data}, function(alien) {
    var ll1 = Math.log(0.5) + alienLogLik(alien, 1);
    var ll2 = Math.log(0.5) + alienLogLik(alien, 2);
    factor(logsumexp2(ll1, ll2));
  });

  return {
    group1: getPrototype(1),
    group2: getPrototype(2)
  };
};

var ANSWER = Infer({method: 'MCMC', kernel: {HMC: {steps: 10, stepSize: .01}}, samples: 3000}, model);

Error: Too many arguments. Distributions take at most one argument.

var data = [
  {antennae: false, green: false, blarghNoise: false},
  {antennae: true,  green: true,  blarghNoise: true},
  {antennae: true,  green: true,  blarghNoise: true},
  {antennae: true,  green: true,  blarghNoise: true},
  {antennae: false, green: false, blarghNoise: false},
  {antennae: true,  green: true,  blarghNoise: true},
  {antennae: false, green: false, blarghNoise: false},
  {antennae: true,  green: true,  blarghNoise: true},
  {antennae: false, green: false, blarghNoise: false},
  {antennae: false, green: false, blarghNoise: false}
];

var getGroupPrototype = mem(function(groupId) {
  return {
    antennae: sample(Beta(0.5, 0.5)),
    green: sample(Beta(0.5, 0.5)),
    blarghNoise: sample(Beta(0.5, 0.5))
  };
});

var model = function() {
  var group1 = getGroupPrototype(1);
  var group2 = getGroupPrototype(2);
  
  mapData({data: data}, function(alien) {
    var groupId = categorical({ps: [0.5, 0.5], vs: [1, 2]});
    var prototype = groupId === 1 ? group1 : group2;
    
    observe(Bernoulli(prototype.antennae), alien.antennae);
    observe(Bernoulli(prototype.green), alien.green);
    observe(Bernoulli(prototype.blarghNoise), alien.blarghNoise);
  });
  
  var mysteryGroupId = categorical({ps: [0.5, 0.5], vs: [1, 2]});
  var mysteryGroup = mysteryGroupId === 1 ? group1 : group2;
  observe(Bernoulli(mysteryGroup.blarghNoise), true);
  
  return {
    group1: group1,
    group2: group2,
    mysteryGroup: mysteryGroup
  };
};

var ANSWER = Infer(
  {method: "MCMC", kernel: {HMC: {steps: 10, stepSize: 0.01}}, samples: 3000},
  model
);

Error: Line 54: Did you mean var logProb = ?

var data = [
  {antennae: false, green: false, blarghNoise: false},
  {antennae: true,  green: true,  blarghNoise: true},
  {antennae: true,  green: true,  blarghNoise: true},
  {antennae: true,  green: true,  blarghNoise: true},
  {antennae: false, green: false, blarghNoise: false},
  {antennae: true,  green: true,  blarghNoise: true},
  {antennae: false, green: false, blarghNoise: false},
  {antennae: true,  green: true,  blarghNoise: true},
  {antennae: false, green: false, blarghNoise: false},
  {antennae: false, green: false, blarghNoise: false}
];

var properties = ['antennae', 'green', 'blarghNoise'];

var groupPrototype = mem(function(groupId) {
  var proto = {};
  mapData({data: properties}, function(prop) {
    proto[prop] = beta({a: 0.5, b: 0.5});
  });
  return proto;
});

var alienLikelihood = function(alien, prototype) {
  var logProb = 0;
  mapData({data: properties}, function(prop) {
    var p = prototype[prop];
    logProb = logProb + (alien[prop] ? Math.log(p) : Math.log(1 - p));
  });
  return logProb;
};

var model = function() {
  var group1 = groupPrototype(0);
  var group2 = groupPrototype(1);
  
  mapData({data: data}, function(alien) {
    var groupId = flip(0.5) ? 0 : 1;
    var prototype = groupId === 0 ? group1 : group2;
    factor(alienLikelihood(alien, prototype));
  });
  
  var mysteryGroup = flip(0.5) ? 0 : 1;
  var mysteryPrototype = mysteryGroup === 0 ? group1 : group2;
  observe(Bernoulli({p: mysteryPrototype.blarghNoise}), true);
  
  return {
    group1: group1,
    group2: group2,
    mysteryGroup: mysteryGroup
  };
};

var ANSWER = Infer(
  {
    method: 'MCMC',
    kernel: {HMC: {steps: 10, stepSize: 0.01}},
    samples: 3000
  },
  model
);

Error: Infer: 'mcmc' is not a valid method. The following methods are available: SMC, MCMC, PMCMC, asyncPF, rejection, enumerate, incrementalMH, forward, optimize, AIS, defaultInfer.

var data = [
  {antennae: false, green: false, blarghNoise: false},
  {antennae: true,  green: true,  blarghNoise: true},
  {antennae: true,  green: true,  blarghNoise: true},
  {antennae: true,  green: true,  blarghNoise: true},
  {antennae: false, green: false, blarghNoise: false},
  {antennae: true,  green: true,  blarghNoise: true},
  {antennae: false, green: false, blarghNoise: false},
  {antennae: true,  green: true,  blarghNoise: true},
  {antennae: false, green: false, blarghNoise: false},
  {antennae: false, green: false, blarghNoise: false}
];

var model = function() {
  // Memoized group prototypes
  var groupPrototype = mem(function(group) {
    return {
      antennae: beta(0.5, 0.5),
      green: beta(0.5, 0.5),
      blarghNoise: beta(0.5, 0.5)
    };
  });
  
  var group1 = groupPrototype(1);
  var group2 = groupPrototype(2);
  
  // Observe the 10 alien data points
  mapData({data: data}, function(datum) {
    var alienGroup = categorical({ps: [0.5, 0.5], vs: [1, 2]});
    var prototype = groupPrototype(alienGroup);
    
    observe(Bernoulli({p: prototype.antennae}), datum.antennae);
    observe(Bernoulli({p: prototype.green}), datum.green);
    observe(Bernoulli({p: prototype.blarghNoise}), datum.blarghNoise);
  });
  
  // Mystery alien: heard blargh but cannot see
  var mysteryGroup = categorical({ps: [0.5, 0.5], vs: [1, 2]});
  var mysteryPrototype = groupPrototype(mysteryGroup);
  observe(Bernoulli({p: mysteryPrototype.blarghNoise}), true);
  
  return {
    group1: group1,
    group2: group2,
    mysteryGroup: mysteryGroup
  };
};

var ANSWER = Infer(
  {method: 'mcmc', kernel: {HMC: {steps: 10, stepSize: 0.01}}, samples: 3000},
  model
);

Timeout after 60s

var data = [
  {antennae: false, green: false, blarghNoise: false},
  {antennae: true,  green: true,  blarghNoise: true},
  {antennae: true,  green: true,  blarghNoise: true},
  {antennae: true,  green: true,  blarghNoise: true},
  {antennae: false, green: false, blarghNoise: false},
  {antennae: true,  green: true,  blarghNoise: true},
  {antennae: false, green: false, blarghNoise: false},
  {antennae: true,  green: true,  blarghNoise: true},
  {antennae: false, green: false, blarghNoise: false},
  {antennae: false, green: false, blarghNoise: false}
];

var model = function() {
  // Memoized group prototypes with Beta(0.5, 0.5) priors per property
  var groupPrototype = mem(function(groupId) {
    return {
      antennae: beta(0.5, 0.5),
      green: beta(0.5, 0.5),
      blarghNoise: beta(0.5, 0.5)
    };
  });
  
  var group1 = groupPrototype(0);
  var group2 = groupPrototype(1);
  
  // Observe the 10 aliens with group assignments
  mapData({data: data}, function(alien) {
    var groupId = flip(0.5) ? 0 : 1;
    var prototype = groupId === 0 ? group1 : group2;
    
    observe(Bernoulli({p: prototype.antennae}), alien.antennae ? 1 : 0);
    observe(Bernoulli({p: prototype.green}), alien.green ? 1 : 0);
    observe(Bernoulli({p: prototype.blarghNoise}), alien.blarghNoise ? 1 : 0);
  });
  
  // Mystery alien: hear blargh but can't see it
  var mysteryGroupId = flip(0.5) ? 0 : 1;
  var mysteryPrototype = mysteryGroupId === 0 ? group1 : group2;
  observe(Bernoulli({p: mysteryPrototype.blarghNoise}), 1);
  
  return {
    group1: group1,
    group2: group2,
    mysteryGroup: mysteryGroupId
  };
};

var ANSWER = Infer({
  method: 'MCMC',
  samples: 3000,
  kernel: {HMC: {steps: 10, stepSize: 0.01}}
}, model);

var data = [
  {antennae: false, green: false, blarghNoise: false},
  {antennae: true,  green: true,  blarghNoise: true},
  {antennae: true,  green: true,  blarghNoise: true},
  {antennae: true,  green: true,  blarghNoise: true},
  {antennae: false, green: false, blarghNoise: false},
  {antennae: true,  green: true,  blarghNoise: true},
  {antennae: false, green: false, blarghNoise: false},
  {antennae: true,  green: true,  blarghNoise: true},
  {antennae: false, green: false, blarghNoise: false},
  {antennae: false, green: false, blarghNoise: false}
];

var model = function() {
  // Group prototypes: for each group, sample Beta(.5,.5) for each property
  var groupPrototype = mem(function(group) {
    return {
      antennae: beta(0.5, 0.5),
      green: beta(0.5, 0.5),
      blarghNoise: beta(0.5, 0.5)
    };
  });

  // Observe each alien in the data
  mapData({data: data}, function(alien) {
    // Sample group membership for this alien
    var group = flip(0.5) ? 1 : 2;
    var proto = groupPrototype(group);
    observe(Bernoulli({p: proto.antennae}), alien.antennae);
    observe(Bernoulli({p: proto.green}), alien.green);
    observe(Bernoulli({p: proto.blarghNoise}), alien.blarghNoise);
  });

  // Mystery alien: heard blargh noise but can't see it
  var mysteryGroup = flip(0.5) ? 1 : 2;
  var mysteryProto = groupPrototype(mysteryGroup);
  observe(Bernoulli({p: mysteryProto.blarghNoise}), true);

  var proto1 = groupPrototype(1);
  var proto2 = groupPrototype(2);

  return {
    group1: {
      antennae: proto1.antennae,
      green: proto1.green,
      blarghNoise: proto1.blarghNoise
    },
    group2: {
      antennae: proto2.antennae,
      green: proto2.green,
      blarghNoise: proto2.blarghNoise
    },
    mysteryGroup: mysteryGroup
  };
};

var ANSWER = Infer({
  method: 'MCMC',
  kernel: {HMC: {steps: 10, stepSize: 0.01}},
  samples: 3000
}, model);

var data = [
  {antennae: false, green: false, blarghNoise: false},
  {antennae: true,  green: true,  blarghNoise: true},
  {antennae: true,  green: true,  blarghNoise: true},
  {antennae: true,  green: true,  blarghNoise: true},
  {antennae: false, green: false, blarghNoise: false},
  {antennae: true,  green: true,  blarghNoise: true},
  {antennae: false, green: false, blarghNoise: false},
  {antennae: true,  green: true,  blarghNoise: true},
  {antennae: false, green: false, blarghNoise: false},
  {antennae: false, green: false, blarghNoise: false}
];

var model = function() {

  // Memoised per-group, per-property Beta(.5,.5) prototype weights
  var groupPrototype = mem(function(group, property) {
    return beta(0.5, 0.5);
  });

  // Memoised 50/50 group assignment for each observed alien
  var alienGroup = mem(function(i) {
    return flip(0.5) ? 1 : 2;
  });

  // Condition on all 10 observed aliens
  mapIndexed(function(i, alien) {
    var g = alienGroup(i);
    observe(Bernoulli({p: groupPrototype(g, 'antennae')}),   alien.antennae);
    observe(Bernoulli({p: groupPrototype(g, 'green')}),      alien.green);
    observe(Bernoulli({p: groupPrototype(g, 'blarghNoise')}), alien.blarghNoise);
  }, data);

  // Mystery alien: latent group, observe blarghNoise = true
  var mysteryGroup = flip(0.5) ? 1 : 2;
  observe(Bernoulli({p: groupPrototype(mysteryGroup, 'blarghNoise')}), true);

  return {
    group1: {
      antennae:    groupPrototype(1, 'antennae'),
      green:       groupPrototype(1, 'green'),
      blarghNoise: groupPrototype(1, 'blarghNoise')
    },
    group2: {
      antennae:    groupPrototype(2, 'antennae'),
      green:       groupPrototype(2, 'green'),
      blarghNoise: groupPrototype(2, 'blarghNoise')
    },
    mysteryGroup: mysteryGroup
  };
};

var ANSWER = Infer({
  method: 'MCMC',
  kernel: { HMC: { steps: 10, stepSize: 0.01 } },
  samples: 3000
}, model);

var data = [
  {antennae: false, green: false, blarghNoise: false},
  {antennae: true,  green: true,  blarghNoise: true},
  {antennae: true,  green: true,  blarghNoise: true},
  {antennae: true,  green: true,  blarghNoise: true},
  {antennae: false, green: false, blarghNoise: false},
  {antennae: true,  green: true,  blarghNoise: true},
  {antennae: false, green: false, blarghNoise: false},
  {antennae: true,  green: true,  blarghNoise: true},
  {antennae: false, green: false, blarghNoise: false},
  {antennae: false, green: false, blarghNoise: false}
];

var model = function() {

  // Mem'd group prototypes: two groups, three continuous Beta(.5,.5) properties each
  var groupPrototype = mem(function(group) {
    return {
      antennae:    beta(0.5, 0.5),
      green:       beta(0.5, 0.5),
      blarghNoise: beta(0.5, 0.5)
    };
  });

  // Observe each alien in the data
  mapData({data: data}, function(alien) {
    var group = flip(0.5) ? 1 : 2;
    var proto  = groupPrototype(group);
    observe(Bernoulli({p: proto.antennae}),    alien.antennae);
    observe(Bernoulli({p: proto.green}),       alien.green);
    observe(Bernoulli({p: proto.blarghNoise}), alien.blarghNoise);
  });

  // Mystery alien: heard blargh but alien is invisible
  var mysteryGroup = flip(0.5) ? 1 : 2;
  var mysteryProto = groupPrototype(mysteryGroup);
  observe(Bernoulli({p: mysteryProto.blarghNoise}), true);

  return {
    group1:       groupPrototype(1),
    group2:       groupPrototype(2),
    mysteryGroup: mysteryGroup
  };
};

var ANSWER = Infer({
  method: 'MCMC',
  kernel: { HMC: { steps: 10, stepSize: 0.01 } },
  samples: 3000
}, model);

var scores = [45, 45, 44, 45, 44, 45, 45, 45, 45, 45, 30, 20, 6, 44, 44, 27, 25, 17, 14, 27, 35, 30]
var subjIDs = _.range(scores.length)
var data = map(function(datum) {return _.zipObject(['subjID', 'score'], datum)}, _.zip(subjIDs, scores));

var ANSWER = Infer({method: 'MCMC', samples: 10000}, function() {
  // Define group success probabilities
  var p_bonafide = uniform(0.5, 1);
  var p_malingerer = uniform(0, p_bonafide);
  
  // Per-participant group membership
  var groupAssignments = map(function(subj) {
    return categorical({ps: [0.5, 0.5], vs: ['group1', 'group2']});
  }, subjIDs);
  
  // Observation function
  var obsFn = function(datum) {
    var group = groupAssignments[datum.subjID];
    var p = (group === 'group1') ? p_bonafide : p_malingerer;
    observe(Binomial({p: p, n: 45}), datum.score);
  };
  
  mapData({data: data}, obsFn);
  
  // Return participant memberships plus group rates
  return {
    groupAssignments: groupAssignments,
    p_bonafide: p_bonafide,
    p_malingerer: p_malingerer
  };
});

var scores = [45, 45, 44, 45, 44, 45, 45, 45, 45, 45, 30, 20, 6, 44, 44, 27, 25, 17, 14, 27, 35, 30]
var subjIDs = _.range(scores.length)
var data = map(function(datum) {return _.zipObject(['subjID', 'score'], datum)}, _.zip(subjIDs, scores));

var ANSWER = Infer({method: 'MCMC', samples: 10000}, function() {
  // Define group success probabilities
  var p_group1 = uniform(0.5, 1);  // bona fide group
  var p_group2 = uniform(0, p_group1);  // malingerer group (constrained to be lower)
  
  // Per-participant group membership
  var groupAssignment = map(function(i) {
    return flip(0.5) ? 'group1' : 'group2';
  }, subjIDs);
  
  // Observation function
  var obsFn = function(datum) {
    var subjID = datum.subjID;
    var score = datum.score;
    var group = groupAssignment[subjID];
    var p = group === 'group1' ? p_group1 : p_group2;
    observe(Binomial({p: p, n: 45}), score);
  };
  
  mapData({data: data}, obsFn);
  
  // Return participant memberships plus group rates
  return {
    groupAssignments: groupAssignment,
    p_bona_fide: p_group1,
    p_malingerer: p_group2
  };
});

var scores = [45, 45, 44, 45, 44, 45, 45, 45, 45, 45, 30, 20, 6, 44, 44, 27, 25, 17, 14, 27, 35, 30]
var subjIDs = _.range(scores.length)
var data = map(function(datum) {return _.zipObject(['subjID', 'score'], datum)}, _.zip(subjIDs, scores));

var ANSWER = Infer({method: 'MCMC', samples: 10000}, function() {
  // Define group success probs
  var p_group1 = uniform(0.5, 1);
  var p_group2 = uniform(0, p_group1);
  
  // Per-participant group membership
  var groups = map(function(subjID) {
    return categorical({ps: [0.5, 0.5], vs: ['group1', 'group2']});
  }, subjIDs);
  
  var obsFn = function(datum){
    var p = groups[datum.subjID] === 'group1' ? p_group1 : p_group2;
    observe(Binomial({p: p, n: 45}), datum.score);
  }
  mapData({data: data}, obsFn)
  
  return {
    group_memberships: groups,
    p_group1: p_group1,
    p_group2: p_group2
  };
});

var scores = [45, 45, 44, 45, 44, 45, 45, 45, 45, 45, 30, 20, 6, 44, 44, 27, 25, 17, 14, 27, 35, 30]
var subjIDs = _.range(scores.length)
var data = map(function(datum) {return _.zipObject(['subjID', 'score'], datum)}, _.zip(subjIDs, scores));

var ANSWER = Infer({method: 'MCMC', samples: 10000}, function() {
  // Sample group success probabilities
  var p_group1 = uniform(0.5, 1);  // bona fide group
  var p_group2 = uniform(0, p_group1);  // malingerers (lower than bona fide)
  
  // Sample prior probability of being bona fide
  var prior_bona_fide = uniform(0, 1);
  
  // For each participant, infer group membership and observe score
  var groupAssignments = map(function(datum){
    var group = categorical({vs: ['group1', 'group2'], ps: [prior_bona_fide, 1 - prior_bona_fide]});
    var p = group === 'group1' ? p_group1 : p_group2;
    observe(Binomial({p: p, n: 45}), datum.score);
    return {subjID: datum.subjID, group: group};
  }, data);
  
  return {
    participant_groups: groupAssignments,
    p_bona_fide: p_group1,
    p_malingerer: p_group2,
    prior_prob_bona_fide: prior_bona_fide
  };
});

var scores = [45, 45, 44, 45, 44, 45, 45, 45, 45, 45, 30, 20, 6, 44, 44, 27, 25, 17, 14, 27, 35, 30]
var subjIDs = _.range(scores.length)
var data = map(function(datum) {return _.zipObject(['subjID', 'score'], datum)}, _.zip(subjIDs, scores));

var ANSWER = Infer({method: 'MCMC', samples: 10000}, function() {
  // Group success probabilities
  var group1_p = uniform(0.5, 1);        // bona fide
  var group2_p = uniform(0, group1_p);   // malingerer, constrained < group1_p

  // Mixture weight: probability of being bona fide
  var pGroup1 = uniform(0, 1);

  // Per-participant group membership
  var memberships = map(function(subjID) {
    return flip(pGroup1) ? 'group1' : 'group2';
  }, subjIDs);

  var obsFn = function(datum) {
    var subjID = datum.subjID;
    var score = datum.score;
    var group = memberships[subjID];
    var p = group === 'group1' ? group1_p : group2_p;
    observe(Binomial({p: p, n: 45}), score);
  };

  mapData({data: data}, obsFn);

  return {
    group1_rate: group1_p,
    group2_rate: group2_p,
    memberships: memberships
  };
});

var scores = [45, 45, 44, 45, 44, 45, 45, 45, 45, 45, 30, 20, 6, 44, 44, 27, 25, 17, 14, 27, 35, 30]
var subjIDs = _.range(scores.length)
var data = map(function(datum) {return _.zipObject(['subjID', 'score'], datum)}, _.zip(subjIDs, scores));

var ANSWER = Infer({method: 'MCMC', samples: 10000}, function() {
  // Group success probabilities
  var group1_p = uniform(0.5, 1);          // bona fide
  var group2_p = uniform(0, group1_p);     // malingerer (constrained < group1_p)

  // Prior on group membership (mixing weight)
  var pGroup1 = uniform(0, 1);

  // Per-participant group membership
  var memberships = map(function(id) {
    return flip(pGroup1) ? 'group1' : 'group2';
  }, subjIDs);

  var obsFn = function(datum) {
    var subj = datum.subjID;
    var group = memberships[subj];
    var p = group === 'group1' ? group1_p : group2_p;
    observe(Binomial({p: p, n: 45}), datum.score);
  };

  mapData({data: data}, obsFn);

  return {
    group1_p: group1_p,
    group2_p: group2_p,
    memberships: memberships
  };
});

var scores = [45, 45, 44, 45, 44, 45, 45, 45, 45, 45, 30, 20, 6, 44, 44, 27, 25, 17, 14, 27, 35, 30];
var subjIDs = _.range(scores.length);
var data = map(function(datum) {
  return _.zipObject(['subjID', 'score'], datum);
}, _.zip(subjIDs, scores));

var ANSWER = Infer({method: 'MCMC', samples: 10000}, function() {
  // Latent group success probabilities
  var group1_p = uniform(0.5, 1);          // bona-fide group
  var group2_p = uniform(0, group1_p);     // malingerer group (always < group1_p)

  // Per-participant group membership (memoized so each ID gets one stable draw)
  var groupOf = mem(function(id) {
    return flip(0.5) ? 'group1' : 'group2';
  });

  var obsFn = function(datum) {
    var group = groupOf(datum.subjID);
    var p = group === 'group1' ? group1_p : group2_p;
    observe(Binomial({p: p, n: 45}), datum.score);
  };

  mapData({data: data}, obsFn);

  return {
    group1_p: group1_p,
    group2_p: group2_p,
    memberships: map(function(id) { return groupOf(id); }, subjIDs)
  };
});

Error: cpsInnerStatement

var maxNumber = 20;

var filterByInRange = function(set) {
  var inRange = function(v) { return v <= maxNumber && v >= 1; };
  return _.uniq(filter(inRange, set));
};

var genEvens = function() {
  return filter(function(v) { return v % 2 == 0 }, _.range(1, maxNumber + 1));
};

var genOdds = function() {
  return filter(function(v) { return v % 2 == 1 }, _.range(1, maxNumber + 1));
};

var genMultiples = function(base) {
  var multiples = map(function(v) { return base * v }, _.range(1, maxNumber + 1));
  return filterByInRange(multiples);
};

var genPowers = function(base) {
  var powers = map(function(v) { return Math.pow(base, v) }, _.range(0, maxNumber));
  return filterByInRange(powers);
};

var inSet = function(val, set) { 
  return _.includes(set, val); 
};

var makeRuleHypothesisSpace = function() {
  var multipleRules = map(function(b) { return 'multiples_of_' + b }, _.range(1, 12));
  var powerRules = map(function(b) { return 'powers_of_' + b }, _.range(1, 12));
  return multipleRules.concat(powerRules).concat(['evens', 'odds']);
};

var genSetFromInterval = function(a, b) {
  return _.range(a, b + 1);
};

var makeIntervalHypothesisSpace = function(start, end) {
  var intervals = [];
  for (var a = start; a < end; a++) {
    for (var b = a + 1; b <= end; b++) {
      intervals.push('interval_' + a + '_' + b);
    }
  }
  return intervals;
};

var getSetFromHypothesis = function(rule) {
  if (rule.indexOf('multiples_of_') === 0) {
    var base = parseInt(rule.split('_').pop());
    return genMultiples(base);
  } else if (rule.indexOf('powers_of_') === 0) {
    var base = parseInt(rule.split('_').pop());
    return genPowers(base);
  } else if (rule === 'evens') {
    return genEvens();
  } else if (rule === 'odds') {
    return genOdds();
  } else if (rule.indexOf('interval_') === 0) {
    var parts = rule.split('_');
    var a = parseInt(parts[1]);
    var b = parseInt(parts[2]);
    return genSetFromInterval(a, b);
  }
  return [];
};

var learnConcept = function(examples, testQuery) {
  return Infer({method: 'enumerate'}, function() {
    var ruleHypotheses = makeRuleHypothesisSpace();
    var intervalHypotheses = makeIntervalHypothesisSpace(1, maxNumber);
    var allHypotheses = ruleHypotheses.concat(intervalHypotheses);
    
    var hypothesis = categorical({
      vs: allHypotheses,
      ps: map(function(h) {
        return 0.5 / ruleHypotheses.length + 0.5 / intervalHypotheses.length;
      }, allHypotheses)
    });
    
    var set = getSetFromHypothesis(hypothesis);
    
    mapData({data: examples}, function(example) {
      observe(Categorical({vs: set, ps: map(function() { return 1; }, set)}), example);
    });
    
    var testQueryResponse = inSet(testQuery, set);
    
    return {hypothesis: hypothesis, testQueryResponse: testQueryResponse};
  });
};

var ANSWER = learnConcept([3, 10], 12);

Error: cpsInnerStatement

var maxNumber = 20;

var filterByInRange = function(set) {
  var inRange = function(v) { return v <= maxNumber && v >= 1; };
  return _.uniq(filter(inRange, set));
};

var genEvens = function() {
  return filter(function(v) { return v % 2 == 0; }, _.range(1, maxNumber + 1));
};

var genOdds = function() {
  return filter(function(v) { return v % 2 == 1; }, _.range(1, maxNumber + 1));
};

var genMultiples = function(base) {
  var multiples = map(function(v) { return base * v; }, _.range(0, maxNumber + 1));
  return filterByInRange(multiples);
};

var genPowers = function(base) {
  var powers = map(function(v) { return Math.pow(base, v); }, _.range(0, maxNumber + 1));
  return filterByInRange(powers);
};

var inSet = function(val, set) { return _.includes(set, val); };

var makeRuleHypothesisSpace = function() {
  var multipleRules = map(function(b) { return 'multiples_of_' + b; }, _.range(1, 12));
  var powerRules = map(function(b) { return 'powers_of_' + b; }, _.range(1, 12));
  return multipleRules.concat(powerRules).concat(['evens', 'odds']);
};

var genSetFromInterval = function(a, b) {
  return filter(function(v) { return v >= a && v <= b; }, _.range(1, maxNumber + 1));
};

var makeIntervalHypothesisSpace = function(start, end) {
  var intervals = [];
  var i = start;
  while (i < end) {
    var j = i + 1;
    while (j <= end) {
      intervals.push('interval_' + i + '_' + j);
      j = j + 1;
    }
    i = i + 1;
  }
  return intervals;
};

var getSetFromHypothesis = function(rule) {
  if (rule === 'evens') {
    return genEvens();
  } else if (rule === 'odds') {
    return genOdds();
  } else if (rule.substring(0, 10) === 'multiples_') {
    var base = _.parseInt(rule.substring(10));
    return genMultiples(base);
  } else if (rule.substring(0, 8) === 'powers_of_') {
    var base = _.parseInt(rule.substring(10));
    return genPowers(base);
  } else if (rule.substring(0, 9) === 'interval_') {
    var parts = rule.substring(9).split('_');
    var a = _.parseInt(parts[0]);
    var b = _.parseInt(parts[1]);
    return genSetFromInterval(a, b);
  } else {
    return [];
  }
};

var learnConcept = function(examples, testQuery) {
  return Infer({method: 'enumerate'}, function() {
    var ruleHypotheses = makeRuleHypothesisSpace();
    var intervalHypotheses = makeIntervalHypothesisSpace(1, maxNumber);
    var allHypotheses = ruleHypotheses.concat(intervalHypotheses);
    
    var hypothesisType = flip(0.5) ? 'rule' : 'interval';
    var hypothesis = hypothesisType === 'rule' 
      ? uniformDraw(ruleHypotheses)
      : uniformDraw(intervalHypotheses);
    
    var set = getSetFromHypothesis(hypothesis);
    
    mapData({data: examples}, function(example) {
      observe(Categorical({vs: set, ps: map(function() { return 1.0 / set.length; }, set)}), example);
    });
    
    var testQueryResponse = inSet(testQuery, set);
    
    return {hypothesis: hypothesis, testQueryResponse: testQueryResponse};
  });
};

var ANSWER = learnConcept([3, 10], 12);

Error: cpsInnerStatement

var maxNumber = 20;

var filterByInRange = function(set) {
  var inRange = function(v) { return v <= maxNumber && v >= 0; };
  return _.uniq(filter(inRange, set));
};

var genEvens = function() {
  return filter(function(v) { return v % 2 == 0; }, _.range(1, maxNumber + 1));
};

var genOdds = function() {
  return filter(function(v) { return (v + 1) % 2 == 0; }, _.range(1, maxNumber + 1));
};

var genMultiples = function(base) {
  var multiples = map(function(v) { return base * v; }, _.range(0, maxNumber + 1));
  return filterByInRange(multiples);
};

var genPowers = function(base) {
  var powers = map(function(v) { return Math.pow(base, v); }, _.range(0, maxNumber + 1));
  return filterByInRange(powers);
};

var inSet = function(val, set) { return _.includes(set, val); };

var makeRuleHypothesisSpace = function() {
  var multipleRules = map(function(b) { return 'multiples_of_' + b; }, _.range(1, 12));
  var powerRules = map(function(b) { return 'powers_of_' + b; }, _.range(1, 12));
  return multipleRules.concat(powerRules).concat(['evens', 'odds']);
};

var genSetFromInterval = function(a, b) {
  return _.range(a, b + 1);
};

var makeIntervalHypothesisSpace = function(start, end) {
  var intervals = [];
  for (var a = start; a < end; a++) {
    for (var b = a + 1; b <= end; b++) {
      intervals.push('interval_' + a + '_' + b);
    }
  }
  return intervals;
};

var getSetFromHypothesis = function(rule) {
  if (_.startsWith(rule, 'multiples_of_')) {
    var base = parseInt(rule.split('_')[2]);
    return genMultiples(base);
  } else if (_.startsWith(rule, 'powers_of_')) {
    var base = parseInt(rule.split('_')[2]);
    return genPowers(base);
  } else if (rule === 'evens') {
    return genEvens();
  } else if (rule === 'odds') {
    return genOdds();
  } else if (_.startsWith(rule, 'interval_')) {
    var parts = rule.split('_');
    var a = parseInt(parts[1]);
    var b = parseInt(parts[2]);
    return genSetFromInterval(a, b);
  }
  return [];
};

var learnConcept = function(examples, testQuery) {
  return Infer({method: 'enumerate'}, function() {
    var ruleHypotheses = makeRuleHypothesisSpace();
    var intervalHypotheses = makeIntervalHypothesisSpace(1, maxNumber);
    
    // 50/50 prior over rule vs. interval hypotheses
    var hypothesisType = uniformDraw(['rule', 'interval']);
    var hypothesis = hypothesisType === 'rule' ? 
      uniformDraw(ruleHypotheses) : 
      uniformDraw(intervalHypotheses);
    
    var set = getSetFromHypothesis(hypothesis);
    
    // Observe each example
    forEach(examples, function(example) {
      observe(Categorical({vs: set}), example);
    });
    
    return {
      hypothesis: hypothesis,
      testQueryResponse: inSet(testQuery, set)
    };
  });
};

var ANSWER = learnConcept([3, 10], 12);

Error: cpsInnerStatement

var maxNumber = 20;

var filterByInRange = function(set) {
  var inRange = function(v) { return v <= maxNumber && v >= 1; };
  return _.uniq(filter(inRange, set));
};

var genEvens = function() {
  return filter(function(v) { return v % 2 == 0; }, _.range(1, maxNumber + 1));
};

var genOdds = function() {
  return filter(function(v) { return (v + 1) % 2 == 0; }, _.range(1, maxNumber + 1));
};

var genMultiples = function(base) {
  var multiples = map(function(v) { return base * v; }, _.range(1, maxNumber + 1));
  return filterByInRange(multiples);
};

var genPowers = function(base) {
  var powers = map(function(v) { return Math.pow(base, v); }, _.range(0, 20));
  return filterByInRange(powers);
};

var inSet = function(val, set) { return _.includes(set, val); };

var makeRuleHypothesisSpace = function() {
  var multipleRules = map(function(b) { return 'multiples_of_' + b; }, _.range(1, 12));
  var powerRules    = map(function(b) { return 'powers_of_' + b; }, _.range(1, 12));
  return multipleRules.concat(powerRules).concat(['evens', 'odds']);
};

var genSetFromInterval = function(a, b) {
  return _.range(a, b + 1);
};

var makeIntervalHypothesisSpace = function(start, end) {
  var intervals = [];
  var i = start;
  while (i < end) {
    var j = i + 1;
    while (j <= end) {
      intervals.push('interval_' + i + '_' + j);
      j = j + 1;
    }
    i = i + 1;
  }
  return intervals;
};

var getSetFromHypothesis = function(rule) {
  if (rule === 'evens') {
    return genEvens();
  } else if (rule === 'odds') {
    return genOdds();
  } else if (_.includes(rule, 'multiples_of_')) {
    var parts = rule.split('_');
    var base = parseInt(parts[2]);
    return genMultiples(base);
  } else if (_.includes(rule, 'powers_of_')) {
    var parts = rule.split('_');
    var base = parseInt(parts[2]);
    return genPowers(base);
  } else if (_.includes(rule, 'interval_')) {
    var parts = rule.split('_');
    var a = parseInt(parts[1]);
    var b = parseInt(parts[2]);
    return genSetFromInterval(a, b);
  } else {
    return [];
  }
};

var learnConcept = function(examples, testQuery) {
  return Infer({method: 'enumerate'}, function() {
    var ruleHyps = makeRuleHypothesisSpace();
    var intervalHyps = makeIntervalHypothesisSpace(1, maxNumber);
    
    var isRule = flip(0.5);
    var hypothesis = isRule ? 
      uniformDraw(ruleHyps) : 
      uniformDraw(intervalHyps);
    
    var set = getSetFromHypothesis(hypothesis);
    
    mapData({data: examples}, function(example) {
      observe(Categorical({vs: set}), example);
    });
    
    return {
      hypothesis: hypothesis,
      testQueryResponse: inSet(testQuery, set)
    };
  });
};

var ANSWER = learnConcept([3, 10], 12);

program exited 0 but produced no output (likely silent failure or undefined ANSWER)

var maxNumber = 20;
var filterByInRange = function(set) {
  var inRange = function(v) { return v <= maxNumber && v >= 1; };
  return _.uniq(filter(inRange, set));
};
var genEvens = function() {
  return filter(function(v) { return v % 2 == 0; }, _.range(1, maxNumber + 1));
};
var genOdds = function() {
  return filter(function(v) { return (v + 1) % 2 == 0; }, _.range(1, maxNumber + 1));
};
var genMultiples = function(base) {
  var multiples = map(function(v) { return base * v; }, _.range(1, maxNumber + 1));
  return filterByInRange(multiples);
};
var genPowers = function(base) {
  var powers = map(function(v) { return Math.pow(base, v); }, _.range(0, maxNumber + 1));
  return filterByInRange(powers);
};
var inSet = function(val, set) { return _.includes(set, val); };

var makeRuleHypothesisSpace = function() {
  var multipleRules = map(function(b) { return 'multiples_of_' + b; }, _.range(1, 12));
  var powerRules    = map(function(b) { return 'powers_of_' + b; },    _.range(1, 12));
  return multipleRules.concat(powerRules).concat(['evens', 'odds']);
};

var genSetFromInterval = function(a, b) {
  return _.range(a, b + 1);
};

var makeIntervalHypothesisSpace = function(start, end) {
  var names = [];
  var as = _.range(start, end);
  return _.flatten(map(function(a) {
    var bs = _.range(a + 1, end + 1);
    return map(function(b) {
      return 'interval_' + a + '_' + b;
    }, bs);
  }, as));
};

var getSetFromHypothesis = function(rule) {
  if (rule.indexOf('multiples_of_') === 0) {
    var base = parseInt(rule.slice('multiples_of_'.length));
    return genMultiples(base);
  } else if (rule.indexOf('powers_of_') === 0) {
    var base = parseInt(rule.slice('powers_of_'.length));
    return genPowers(base);
  } else if (rule === 'evens') {
    return genEvens();
  } else if (rule === 'odds') {
    return genOdds();
  } else if (rule.indexOf('interval_') === 0) {
    var parts = rule.slice('interval_'.length).split('_');
    var a = parseInt(parts[0]);
    var b = parseInt(parts[1]);
    return genSetFromInterval(a, b);
  }
};

var learnConcept = function(examples, testQuery) {
  var ruleHypotheses = makeRuleHypothesisSpace();
  var intervalHypotheses = makeIntervalHypothesisSpace(1, maxNumber);
  
  var numRule = ruleHypotheses.length;
  var numInterval = intervalHypotheses.length;
  
  // 50/50 split between rule and interval hypotheses
  // Each rule hypothesis gets weight: 0.5 / numRule
  // Each interval hypothesis gets weight: 0.5 / numInterval
  
  var allHypotheses = ruleHypotheses.concat(intervalHypotheses);
  var ruleWeight = 0.5 / numRule;
  var intervalWeight = 0.5 / numInterval;
  var weights = map(function(h) {
    return _.includes(ruleHypotheses, h) ? ruleWeight : intervalWeight;
  }, allHypotheses);
  
  var model = function() {
    var hypothesis = categorical({ vs: allHypotheses, ps: weights });
    var set = getSetFromHypothesis(hypothesis);
    
    // Observe each example: it must be in the set
    // Using factor with log probability of observing from Categorical
    var setSize = set.length;
    
    // Each example is observed as drawn from Categorical over the set
    mapData({ data: examples }, function(example) {
      var exampleInSet = inSet(example, set);
      factor(exampleInSet ? -Math.log(setSize) : -Infinity);
    });
    
    var testQueryResponse = inSet(testQuery, set);
    return { hypothesis: hypothesis, testQueryResponse: testQueryResponse };
  };
  
  return Infer({ method: 'enumerate' }, model);
};

var ANSWER = learnConcept([3, 10], 12);

program exited 0 but produced no output (likely silent failure or undefined ANSWER)

var maxNumber = 20;

var filterByInRange = function(set) {
  var inRange = function(v) { return v <= maxNumber && v >= 1; };
  return _.uniq(filter(inRange, set));
};

var genEvens = function() {
  return filter(function(v) { return v % 2 === 0; }, _.range(1, maxNumber + 1));
};

var genOdds = function() {
  return filter(function(v) { return (v + 1) % 2 === 0; }, _.range(1, maxNumber + 1));
};

var genMultiples = function(base) {
  var multiples = map(function(v) { return base * v; }, _.range(1, maxNumber + 1));
  return filterByInRange(multiples);
};

var genPowers = function(base) {
  var powers = map(function(v) { return Math.pow(base, v); }, _.range(0, maxNumber + 1));
  return filterByInRange(powers);
};

var inSet = function(val, set) { return _.includes(set, val); };

var makeRuleHypothesisSpace = function() {
  var multipleRules = map(function(b) { return 'multiples_of_' + b; }, _.range(1, 12));
  var powerRules    = map(function(b) { return 'powers_of_' + b; },    _.range(1, 12));
  return multipleRules.concat(powerRules).concat(['evens', 'odds']);
};

// Returns all integers from a through b inclusive
var genSetFromInterval = function(a, b) {
  return _.range(a, b + 1);
};

// Returns 'interval_a_b' names for every (a,b) with start <= a < b <= end
var makeIntervalHypothesisSpace = function(start, end) {
  var as = _.range(start, end);          // a from start to end-1
  return _.flatten(map(function(a) {
    var bs = _.range(a + 1, end + 1);    // b from a+1 to end
    return map(function(b) {
      return 'interval_' + a + '_' + b;
    }, bs);
  }, as));
};

// Dispatch on rule prefix to produce the set of integers it denotes
var getSetFromHypothesis = function(rule) {
  if (rule === 'evens') {
    return genEvens();
  } else if (rule === 'odds') {
    return genOdds();
  } else if (rule.indexOf('multiples_of_') === 0) {
    var base = parseInt(rule.slice('multiples_of_'.length));
    return genMultiples(base);
  } else if (rule.indexOf('powers_of_') === 0) {
    var base2 = parseInt(rule.slice('powers_of_'.length));
    return genPowers(base2);
  } else if (rule.indexOf('interval_') === 0) {
    var suffix = rule.slice('interval_'.length);
    var underscoreIdx = suffix.indexOf('_');
    var a = parseInt(suffix.slice(0, underscoreIdx));
    var b = parseInt(suffix.slice(underscoreIdx + 1));
    return genSetFromInterval(a, b);
  }
};

var learnConcept = function(examples, testQuery) {
  var ruleHypotheses     = makeRuleHypothesisSpace();
  var intervalHypotheses = makeIntervalHypothesisSpace(1, maxNumber);

  return Infer({ method: 'enumerate' }, function() {
    // 50/50 prior: rule-based vs interval-based
    var useRule      = flip(0.5);
    var hypotheses   = useRule ? ruleHypotheses : intervalHypotheses;

    // Uniform draw within the chosen family
    var hypothesis   = uniformDraw(hypotheses);
    var set          = getSetFromHypothesis(hypothesis);

    // Observe each example as a draw from Categorical over the set
    mapData({ data: examples }, function(ex) {
      observe(Categorical({ vs: set }), ex);
    });

    var testQueryResponse = inSet(testQuery, set);

    return { hypothesis: hypothesis, testQueryResponse: testQueryResponse };
  });
};

var ANSWER = learnConcept([3, 10], 12);

var maxNumber = 20;

var filterByInRange = function(set) {
  var inRange = function(v) { return v <= maxNumber && v >= 1; };
  return _.uniq(filter(inRange, set));
};

var genEvens = function() {
  return filter(function(v) { return v % 2 === 0; }, _.range(1, maxNumber + 1));
};

var genOdds = function() {
  return filter(function(v) { return (v + 1) % 2 === 0; }, _.range(1, maxNumber + 1));
};

var genMultiples = function(base) {
  var multiples = map(function(v) { return base * v; }, _.range(1, maxNumber + 1));
  return filterByInRange(multiples);
};

var genPowers = function(base) {
  var powers = map(function(v) { return Math.pow(base, v); }, _.range(1, maxNumber + 1));
  return filterByInRange(powers);
};

var inSet = function(val, set) { return _.includes(set, val); };

var makeRuleHypothesisSpace = function() {
  var multipleRules = map(function(b) { return 'multiples_of_' + b; }, _.range(1, 12));
  var powerRules    = map(function(b) { return 'powers_of_' + b;    }, _.range(1, 12));
  return multipleRules.concat(powerRules).concat(['evens', 'odds']);
};

var genSetFromInterval = function(a, b) {
  return _.range(a, b + 1);
};

var makeIntervalHypothesisSpace = function(start, end) {
  var as = _.range(start, end);
  return _.flatten(map(function(a) {
    var bs = _.range(a + 1, end + 1);
    return map(function(b) {
      return 'interval_' + a + '_' + b;
    }, bs);
  }, as));
};

var getSetFromHypothesis = function(rule) {
  if (rule === 'evens') {
    return genEvens();
  } else if (rule === 'odds') {
    return genOdds();
  } else if (rule.indexOf('multiples_of_') === 0) {
    var mBase = _.parseInt(rule.slice('multiples_of_'.length));
    return genMultiples(mBase);
  } else if (rule.indexOf('powers_of_') === 0) {
    var pBase = _.parseInt(rule.slice('powers_of_'.length));
    return genPowers(pBase);
  } else {
    // interval_a_b
    var body  = rule.slice('interval_'.length);
    var parts = body.split('_');
    var a = _.parseInt(parts[0]);
    var b = _.parseInt(parts[1]);
    return genSetFromInterval(a, b);
  }
};

var learnConcept = function(examples, testQuery) {
  var ruleSpace     = makeRuleHypothesisSpace();
  var intervalSpace = makeIntervalHypothesisSpace(1, maxNumber);

  return Infer({method: 'enumerate'}, function() {
    // 50/50 prior between rule-based and interval hypotheses
    var useRule    = flip(0.5);
    var space      = useRule ? ruleSpace : intervalSpace;
    var hypothesis = space[randomInteger(space.length)];
    var set        = getSetFromHypothesis(hypothesis);

    // Each example is observed as drawn uniformly from the concept's extension
    mapData({data: examples}, function(example) {
      observe(Categorical({vs: set}), example);
    });

    var testQueryResponse = inSet(testQuery, set);
    return {hypothesis: hypothesis, testQueryResponse: testQueryResponse};
  });
};

var ANSWER = learnConcept([3, 10], 12);

var maxNumber = 20;
var filterByInRange = function(set) {
  var inRange = function(v) { v <= maxNumber && v >= 0 };
  return _.uniq(filter(inRange, set));
};
var genEvens = function() {
  return filter(function(v) { return v % 2 == 0 }, _.range(1, maxNumber));
};
var genOdds = function() {
  return filter(function(v) { return (v + 1) % 2 == 0 }, _.range(1, maxNumber));
};
var genMultiples = function(base) {
  var multiples = map(function(v) { return base * v }, _.range(maxNumber));
  return filterByInRange(multiples);
};
var genPowers = function(base) {
  var powers = map(function(v) { return Math.pow(base, v) }, _.range(maxNumber));
  return filterByInRange(powers);
};
var inSet = function(val, set) { return _.includes(set, val); };
var makeRuleHypothesisSpace = function() {
  var multipleRules = map(function(b) { return 'multiples_of_' + b }, _.range(1, 12));
  var powerRules    = map(function(b) { return 'powers_of_' + b },    _.range(1, 12));
  return multipleRules.concat(powerRules).concat(['evens', 'odds']);
};
var genSetFromInterval = function(a, b) { return _.range(a, b+1); };
var makeIntervalHypothesisSpace = function(start, end) {
  var allIntervals = _.flatten(map(function(s) {
    return map(function(e) { return [s, e] }, genSetFromInterval(s+1, end));
  }, genSetFromInterval(start, end)));
  return map(function(x) { return 'interval_' + x[0] + '_' + x[1] }, allIntervals);
};
var getSetFromHypothesis = function(rule) {
  var parts = rule.split('_');
  return parts[0] == 'multiples' ? genMultiples(_.parseInt(parts[2])) :
         parts[0] == 'powers'    ? genPowers(_.parseInt(parts[2])) :
         parts[0] == 'evens'     ? genEvens() :
         parts[0] == 'odds'      ? genOdds() :
         parts[0] == 'interval'  ? genSetFromInterval(_.parseInt(parts[1]), _.parseInt(parts[2])) :
         null;
};
var learnConcept = function(examples, testQuery) {
  return Infer({method: 'enumerate'}, function() {
    var rules = makeRuleHypothesisSpace();
    var intervals = makeIntervalHypothesisSpace(1, maxNumber);
    var hypothesis = flip(0.5) ? uniformDraw(rules) : uniformDraw(intervals);
    var set = getSetFromHypothesis(hypothesis);
    mapData({data: examples}, function(example) {
      observe(Categorical({vs: set}), example);
    });
    return {hypothesis: hypothesis, testQueryResponse: inSet(testQuery, set)};
  });
};

var examples = [3, 6, 9];
var pQueries = map(function(query) {
  var dist = learnConcept(examples, query);
  var marginal = marginalize(dist, function(x) { return x.testQueryResponse; });
  return expectation(marginal);
}, _.range(1, 21));

var ANSWER = pQueries;

var maxNumber = 20;
var filterByInRange = function(set) {
  var inRange = function(v) { return v <= maxNumber && v >= 0; };
  return _.uniq(filter(inRange, set));
};
var genEvens = function() {
  return filter(function(v) { return v % 2 == 0; }, _.range(1, maxNumber + 1));
};
var genOdds = function() {
  return filter(function(v) { return (v + 1) % 2 == 0; }, _.range(1, maxNumber + 1));
};
var genMultiples = function(base) {
  var multiples = map(function(v) { return base * v; }, _.range(0, maxNumber + 1));
  return filterByInRange(multiples);
};
var genPowers = function(base) {
  var powers = map(function(v) { return Math.pow(base, v); }, _.range(0, maxNumber + 1));
  return filterByInRange(powers);
};
var inSet = function(val, set) { return _.includes(set, val); };
var makeRuleHypothesisSpace = function() {
  var multipleRules = map(function(b) { return 'multiples_of_' + b; }, _.range(1, 12));
  var powerRules = map(function(b) { return 'powers_of_' + b; }, _.range(1, 12));
  return multipleRules.concat(powerRules).concat(['evens', 'odds']);
};
var genSetFromInterval = function(a, b) { return _.range(a, b + 1); };
var makeIntervalHypothesisSpace = function(start, end) {
  var allIntervals = _.flatten(map(function(s) {
    return map(function(e) { return [s, e]; }, genSetFromInterval(s + 1, end));
  }, genSetFromInterval(start, end)));
  return map(function(x) { return 'interval_' + x[0] + '_' + x[1]; }, allIntervals);
};
var getSetFromHypothesis = function(rule) {
  var parts = rule.split('_');
  return parts[0] == 'multiples' ? genMultiples(_.parseInt(parts[2])) :
         parts[0] == 'powers' ? genPowers(_.parseInt(parts[2])) :
         parts[0] == 'evens' ? genEvens() :
         parts[0] == 'odds' ? genOdds() :
         parts[0] == 'interval' ? genSetFromInterval(_.parseInt(parts[1]), _.parseInt(parts[2])) :
         null;
};
var learnConcept = function(examples, testQuery) {
  return Infer({method: 'enumerate'}, function() {
    var rules = makeRuleHypothesisSpace();
    var intervals = makeIntervalHypothesisSpace(1, maxNumber);
    var hypothesis = flip(0.5) ? uniformDraw(rules) : uniformDraw(intervals);
    var set = getSetFromHypothesis(hypothesis);
    mapData({data: examples}, function(example) {
      observe(Categorical({vs: set}), example);
    });
    return {hypothesis: hypothesis, testQueryResponse: inSet(testQuery, set)};
  });
};

var examples = [3, 6, 9];
var pQueries = map(function(query) {
  var dist = learnConcept(examples, query);
  var marginal = marginalize(dist, function(x) { return x.testQueryResponse; });
  return expectation(marginal);
}, _.range(1, maxNumber + 1));

var ANSWER = pQueries;

var maxNumber = 20;
var filterByInRange = function(set) {
  var inRange = function(v) { v <= maxNumber && v >= 0 };
  return _.uniq(filter(inRange, set));
};
var genEvens = function() {
  return filter(function(v) { return v % 2 == 0 }, _.range(1, maxNumber));
};
var genOdds = function() {
  return filter(function(v) { return (v + 1) % 2 == 0 }, _.range(1, maxNumber));
};
var genMultiples = function(base) {
  var multiples = map(function(v) { return base * v }, _.range(maxNumber));
  return filterByInRange(multiples);
};
var genPowers = function(base) {
  var powers = map(function(v) { return Math.pow(base, v) }, _.range(maxNumber));
  return filterByInRange(powers);
};
var inSet = function(val, set) { return _.includes(set, val); };
var makeRuleHypothesisSpace = function() {
  var multipleRules = map(function(b) { return 'multiples_of_' + b }, _.range(1, 12));
  var powerRules    = map(function(b) { return 'powers_of_' + b },    _.range(1, 12));
  return multipleRules.concat(powerRules).concat(['evens', 'odds']);
};
var genSetFromInterval = function(a, b) { return _.range(a, b+1); };
var makeIntervalHypothesisSpace = function(start, end) {
  var allIntervals = _.flatten(map(function(s) {
    return map(function(e) { return [s, e]; }, genSetFromInterval(s+1, end));
  }, genSetFromInterval(start, end)));
  return map(function(x) { return 'interval_' + x[0] + '_' + x[1]; }, allIntervals);
};
var getSetFromHypothesis = function(rule) {
  var parts = rule.split('_');
  return parts[0] == 'multiples' ? genMultiples(_.parseInt(parts[2])) :
         parts[0] == 'powers'    ? genPowers(_.parseInt(parts[2])) :
         parts[0] == 'evens'     ? genEvens() :
         parts[0] == 'odds'      ? genOdds() :
         parts[0] == 'interval'  ? genSetFromInterval(_.parseInt(parts[1]), _.parseInt(parts[2])) :
         null;
};
var learnConcept = function(examples, testQuery) {
  return Infer({method: 'enumerate'}, function() {
    var rules = makeRuleHypothesisSpace();
    var intervals = makeIntervalHypothesisSpace(1, maxNumber);
    var hypothesis = flip(0.5) ? uniformDraw(rules) : uniformDraw(intervals);
    var set = getSetFromHypothesis(hypothesis);
    mapData({data: examples}, function(example) {
      observe(Categorical({vs: set}), example);
    });
    return {hypothesis: hypothesis, testQueryResponse: inSet(testQuery, set)};
  });
};

var pQueries = map(function(query) {
  var dist = learnConcept([3, 6, 9], query);
  var marginal = marginalize(dist, function(x) { return x.testQueryResponse; });
  return expectation(marginal, function(x) { return x ? 1 : 0; });
}, _.range(1, 21));

var ANSWER = pQueries;