This section presents a number of examples based on rolling dice, using different representations and increasingly complex rules.
We start with a variant of our earlier propositional coin example, but now using dice. It illustrates the use of annotated disjunctions, a probabilistic primitive that chooses exactly one of a number of alternatives (if their probabilities sum to 1.0, if the sum is less than 1.0, then with some probability none of the alternatives is picked). The first die is fair, the second has a higher chance of throwing a six. Furthermore, we define what it means to throw a six with both dice, or with at least one of them.
Also try adding evidence(someSix). (short for evidence(someSix,true).) to the box above and observe how the probabilities change if we observe that there is at least one six.
Let’s now consider an example where we are interested in whether the dice show even or odd numbers. We change the propositional representation of the previous example so we can define these properties just once instead of for each die individually, and we’ll use Prolog’s negation as failure to define even in terms of odd.
Note that as in Prolog, negation has to be used with care, as it is only safe on ground goals. We illustrate this by posing non-ground queries (using an anonymous variable denoted by _ as argument) to the same program.
For odd(_), this behaves as expected, i.e., it returns all ground instances of the query and their probabilities. The result reported for even(X1) is not meaningful. Obviously, this pitfall can easily be avoided here by writing explicit rules for even, which is left as an exercise for the reader.
We now consider yet another way to model dice, using fair ones only. This representation allows for convenient use of the results in arithmetic expressions, e.g., to add up the results from several dice. We query for the probabilities of the possible sums we can get from two dice given that the first number is even and the second odd.
It is easy to verify that the evidence restricts the possible outcomes to nine (equally likely) pairs, some of which result in the same sum. Bias the dice by changing the probability distribution or use different distributions for the two dice to see how this changes the result.
Let’s add another die, and ask for the sum of three rolls, given that the first number is smaller than the second, and the second smaller than the third.
Add query(outcome(_,_,_)). to verify that indeed only increasing sequences have non-zero posterior probability.
Let’s consider an infinite number of dice, which we roll one after the other until we see a six for the first time. What is the probability of stopping after n dice? The first die is always rolled, those with higher numbers D are only rolled if the previous roll did not stop the process. We use the built-in predicate between/3 to restrict querying to n = 1,2,3,4,5.
Uncomment the last two lines to verify that ProbLog indeed computes the expected probabilities. The last line uses a flexible probability, i.e., a probability that is computed from the arguments of the atom it is attached to.
The following example illustrates the use of a logic program with recursion and lists. We start by rolling the first die. Every roll determines the next die to roll, but we stop if we have used that die before. We query for the possible sequences of rolled dice. We use three-sided dice instead of the regular six-sided ones simply to restrict the number of possible outcomes (and thus inference time). We use the builtin between/3 to specify the identifiers of our dice, and regular Prolog definitions of member and reverse. The top level predicate roll calls the next predicate, which is responsible for recording which dice we have used and for determining when to stop.
Much of the code of the previous example was for controlling the sequence of rolls. We’ll now change the rules to generate infinite sequences, and query for finite prefixes of these sequences (of length 5 in our case, thanks to the list pattern with five anonymous variables used in the query). Here’s a first model. We roll the first die for sure, as specified by the fact roll([1]), and if we already have seen a list of rolls, we take the first element F of the list, roll its die, and add the outcome H to the front of the extended sequence.
The reason that most sequences have probability zero is that ProbLog uses stochastic memoization (or tabling), that is, if it encounters the same die a second time, it will not roll it again, but reuse the (memoized) result of the previous roll. Thus, if our first roll, which always uses die 1, produces a 1, then the sequence will only contain 1s, or if the sequence starts with 1 2 1, then it has to continue alternating between these two numbers. We can change this by adding an extra argument to the dice predicate that will be different on every call (sometimes called a trial identifier), as in the following program, which uses the sequence so far as extra argument. For fixed length, this results in a uniform distribution over all sequences of this length (change the length of the list pattern in the query to verify this).