{'fraction_non_alphanumeric': 0.0389541748664605, 'fraction_numerical': 0.012954737138037672, 'mean_word_length': 4.792092750602488, 'pattern_counts': {'":': 1, '<': 1, '<?xml version=': 0, '>': 2, 'https://': 0, 'lorem ipsum': 0, 'www.': 0, 'xml': 0}, 'pii_count': 0, 'substrings_counts': 0, 'word_list_counts': {'cursed_substrings.json': 18, 'profanity_word_list.json': 0, 'sexual_word_list.json': 0, 'zh_pornsignals.json': 0}}
Probabilistic Programming Concepts

A multitude of different probabilistic programming languages exists today, all extending a traditional programming language with primitives to support modeling of complex, structured probability distributions. Each of these languages employs its own probabilistic primitives, and comes with a particular syntax, semantics and inference procedure. This makes it hard to understand the underlying programming concepts and appreciate the differences between the different languages. To obtain a better understanding of probabilistic programming, we identify a number of core programming concepts underlying the primitives used by various probabilistic languages, discuss the execution mechanisms that they require and use these to position state-of-the-art probabilistic languages and their implementation. While doing so, we focus on probabilistic extensions of logic programming languages such as Prolog, which have been developed since more than 20 years.


Introduction
The vast interest in statistical relational learning , probabilistic (inductive) logic programming  and probabilistic programming languages  has resulted in a wide variety of different formalisms, models and languages. The multitude of probabilistic languages that exists today provides evidence for the richness and maturity of the field, but on the other hand, makes it hard to get an appreciation and understanding of the relationships and differences between the different languages. Furthermore, most arguments in the literature about the relationship amongst these languages are about the expressiveness of these languages, that is, they state (often in an informal way) that one language is more expressive than another one (implying that the former could be used to emulate the latter). By now, it is commonly accepted that the more interesting question is concerned with the underlying concepts that these languages employ and their effect on the inference mechanisms, as their expressive power is often very similar. However, a multitude of different probabilistic primitives exists, which makes it hard to appreciate their relationships. 1 To alleviate these difficulties and obtain a better understanding of the field we identify a number of core probabilistic programming concepts and relate them to one another. We cover the basic concepts representing different types of random variables, but also general modeling concepts such as negation or time and dynamics, and programming constructs such as meta-calls and ways to handle sets. While doing so, we focus on probabilistic extensions of logic programming languages because this is (arguably) the first and best studied probabilistic programming paradigm. It has been studied for over 20 years starting with the seminal work of David Poole [1992] and Taisuke Sato [1995], and now includes languages such as CLP(BN ) , BLPs , ICL [Poole, 2008], PRISM [Sato and Kameya, 2001], ProbLog [De Raedt et al., 2007], LPADs [Vennekens et al., 2004], CP-logic [Vennekens et al., 2009], SLPs [Muggleton, 1996], PROPPR [Wang et al., 2013], P-log [Baral et al., 2009] and Dyna [Eisner et al., 2005]. Another reason for focussing on probabilistic extensions of logic programming languages is that the concepts are all embedded within the same host language, so we can focus on semantics rather than syntax. At the same time, we also relate the concepts to alternative probabilistic programming languages such as Church [Goodman et al., 2008], IBAL [Pfeffer, 2001], Figaro [Pfeffer, 2009] and BLOG [Milch et al., 2005] and to some extent also to statistical relational learning models such as RBNs [Jaeger, 2008], Markov logic [Richardson and Domingos, 2006], and PRMs . Most statistical relational learning approaches employ a knowledge-based model construction approach, in which the logic is used as a template for constructing a graphical model. Typical probabilistic programming languages, on the other hand, employ a variant of Sato's distribution semantics [Sato, 1995], in which random variables directly correspond to ground facts and a traditional program specifies how to deduce further knowledge from these facts. This difference explains why we introduce the concepts in the context of the distribution semantics, and discuss approaches to knowledge-based model construction separately.
Inference is a key challenge in probabilistic programming and statistical relational learning. Furthermore, the choice of inference approach often influences which probabilistic primitives can be supported. Enormous progress has been made in the past few years w.r.t. probabilistic inference and numerous inference procedures have been contributed. Therefore, we also identify some core classes of inference mechanisms for probabilistic programming and discuss which ones to use for which probabilistic concept. Inference in probabilistic languages also is an important building block of approaches that learn the structure and/or parameters of such models from data. Given the variety of approaches that exist today, a discussion of learning is beyond the scope of this paper.
To summarize, the key contributions of this paper are (1) the identification of a number of core concepts that are used by various probabilistic languages, (2) a discussion of the execution mechanisms that they require, and (3) a positioning of state-of-the-art probabilistic languages and implementations w.r.t. these concepts. Although many of the concepts we discuss are well-described in the literature, some even in survey papers Kersting, 2003, Poole, 2008], we believe a new and up-to-date survey is warranted due to the rapid the term concept to denote the underlying notion. Different primitives may hence realize the same concept. developments of the field which rapidly renders existing surveys incomplete and even outdated. To the best of our knowledge, this is also the first time that such a wide variety of probabilistic programming concepts and languages, also in connection to inference, is discussed in a single paper.
We expect the reader to be familiar with basic language concepts and terms of Prolog [Lloyd, 1989, Flach, 1994; a quick summary can be found in Appendix A.
This paper is organized as follows. We first discuss the distribution semantics (Section 2) and classify corresponding inference approaches according to their logical and probabilistic components (Section 3). Section 4 identifies the probabilistic programming concepts. In Section 5, we discuss the relation with statistical relational modeling approaches rooted in graphical models. Section 6 relates the different inference approaches to the probabilistic programming concepts.

Distribution Semantics
Sato's distribution semantics [Sato, 1995] is a well-known semantics for probabilistic logics that has been used many times in the literature, cf. [Dantsin, 1991, Poole, 1993, Fuhr, 2000, Poole, 2000, Sato and Kameya, 2001, Dalvi and Suciu, 2004, De Raedt et al., 2007. Prominent examples of Prolog-based languages using this semantics include ICL [Poole, 2008], PRISM [Sato and Kameya, 2001] and ProbLog [De Raedt et al., 2007, Kimmig et al., 2011a, even though there exist subtle differences between these languages as we will illustrate later. Sato has defined the distribution semantics for a countably infinite set of random variables and a general class of distributions. We focus on the finite case here, discussing the two most popular instances of the semantics, based on a set of independent random variables and independent probabilistic choices, respectively, and refer to [Sato, 1995] for details on the general case.

Probabilistic Facts
The arguably most basic instance of the distribution semantics uses a finite set of Boolean random variables that are all pairwise independent. Throughout the paper, we use the following running example inspired by the well-known alarm Bayesian network: 0.1 :: burglary. 0.7 :: hears alarm(mary). 0.2 :: earthquake. 0.4 :: hears alarm(john).
The program consists of a set R of definite clauses or rules, and a set F of ground facts f , each of them labeled with a probability p, written as p :: f . We call such labeled facts probabilistic facts. Each probabilistic fact corresponds to a Boolean random variable that is true with probability p and false with probability 1 − p. We use b, e, hm and hj to denote the random variables corresponding to burglary, earthquake, hears_alarm(mary) and hears_alarm(john), respectively. Assuming that all these random variables are independent, we obtain the following probability distribution P F over truth value assignments to these random variables and their corresponding sets of ground facts F ⊆ F : For instance, the truth value assignment burglary = true, earthquake = false, hears alarm(mary) = true, hears alarm(john) = false, which we will abbreviate as b ∧ ¬e ∧ hm ∧ ¬hj, corresponds to the set of facts {burglary, hears_alarm(mary)}, and has probability 0.1 · (1 − 0.2) · 0.7 · (1 − 0.6) = 0.0336. The corresponding logic program obtained by adding the set of rules R to the set of facts, also called a possible world, is burglary.
As each logic program obtained by fixing the truth values of all probabilistic facts has a unique least Herbrand model, P F can be used to define the success probability of a query q, that is, the probability that q is true in a randomly chosen such program, as the sum over all programs that entail q: Naively, the success probability can thus be computed by enumerating all sets F ⊆ F , for each of them checking whether the corresponding possible world entails the query, and summing the probabilities of those that do. As fixing the set of facts yields an ordinary logic program, the entailment check can use any reasoning technique for such programs. For instance, forward reasoning, also known as applying the T P operator, starts from the set of facts and repeatedly uses rules to derive additional facts until no more facts can be derived. In our example possible world (3), we thus start from {burglary, hears_alarm(mary)}, and first add alarm due to the second rule based on burglary. This in turn makes it possible to add calls(mary) using the third rule and substitution X=mary, and finally, call is added using the last rule, resulting in the least Herbrand model {burglary, hears_alarm(mary), alarm, calls(mary), call}. This possible world thus contributes to the success probabilities of alarm, calls(mary) and call, but not to the one of calls(john). An alternative to forward reasoning is backward reasoning, also known as SLD-resolution or proving, which we again illustrate for our example possible world (3). It starts from a given query, e.g., call, and uses the rules in the opposite direction: in order to prove a fact appearing in the head of a clause, we have to prove all literals in the clause's body. For instance, based on the last rule, to prove call, we need to prove calls(X) for some instantiation of X. Using the third rule, this means proving alarm, hears_alarm(X). To prove alarm, we could use the first rule and prove earthquake, but this fails for our choice of facts, as there is no rule (or fact) for the latter. We thus backtrack to the second rule for alarm, which requires proving burglary, which is proven by the corresponding fact. Finally, we prove hears_alarm(X) using the fact hears_alarm(mary), substituting mary for X, which completes the proof for call.
Going over all possible worlds in this way, we obtain the success probability of calls(mary), P s (calls(mary)) = 0.196, as the sum of the probabilities of six possible worlds (listed in Table 1).
Clearly, enumerating all possible worlds is infeasible for larger programs; we will discuss alternative inference techniques from the literature in Section 3.
For ease of modeling (and to allow for countably infinite sets of probabilistic facts), probabilistic languages such as ICL and ProbLog use non-ground probabilistic facts to define sets of random variables. All ground instances of such a fact are mutually independent and share the same probability value. As an example, consider a simple coin game which can be won either by throwing two times heads or by cheating. This game can be modeled by the program below. The probability to win the game is then defined by the success probability P s (win). 0.5 :: heads(X). 0.2 :: cheat successfully. win :− cheat successfully. win :− heads(1), heads(2).
Legal groundings of such facts can also be restricted by providing a domain, as in the following variant of our alarm example where all persons have the same probability of independently hearing the alarm: 0.1 :: burglary. 0.2 :: earthquake 0.7 :: hears alarm(X) :− person(X). person(mary). person(john). person(bob). person(ann).
If such domains are defined purely logically, without using probabilistic facts, the basic distribution is still well defined.
It is often assumed that probabilistic facts do not unify with other probabilistic facts or heads of rules.

Probabilistic Choices
As already noted by Sato [1995], probabilistic facts (or binary switches) are expressive enough to represent a wide range of models, including Bayesian networks, Markov chains and hidden Markov models. However, for ease of modeling, it is often more convenient to use multi-valued random variables instead of binary ones. The concept commonly used to realize such variables in the distribution semantics is a probabilistic choice, that is, a finite set of ground atoms exactly one of which is true in any possible world. Examples of such choices are the probabilistic alternatives of the Independent Choice Logic (ICL) [Poole, 2000] and probabilistic Horn abduction (PHA) [Poole, 1993], the multi-ary random switches of PRISM [Sato and Kameya, 2001], the probabilistic clauses of stochastic logic programs (SLPs) [Muggleton, 1996], and the annotated disjunctions of logic programs with annotated disjunctions (LPADs) [Vennekens et al., 2004], or the CP-events of CP-logic [Vennekens, 2007]. These are all closely related, e.g., the probabilistic clauses of SLPs map onto the switches of PRISM [Cussens, 2005], and the probabilistic alternatives of ICL onto annotated disjunctions (and vice versa) [Vennekens et al., 2004]. We therefore restrict the following discussion to annotated disjunctions [Vennekens et al., 2004], using the notation introduced below.
An annotated disjunction (AD) is an expression of the form where b 1 , . . . , b M is a possibly empty conjunction of literals, the p i are probabilities and N i=1 p i ≤ 1. Considered in isolation, an annotated disjunction states that if the body b 1 , . . . , b M is true at most one of the h i is true as well, where the choice is governed by the probabilities (see below for interactions between multiple ADs with unifying atoms in the head). If the p i in an annotated disjunction do not sum to 1, there is also the case that nothing is chosen. The probability of this event is 1 − n i=1 p i . A probabilistic fact is thus a special case of an AD with a single head atom and empty body.
The probabilistic fact states that we draw a ball from an urn with probability 0.4, and the annotated disjunction states that if we draw a ball, the color is picked uniformly among green, red and blue. As for probabilistic facts, a nonground AD denotes the set of all its groundings, and for each such grounding, choosing one of its head atoms to be true is seen as an independent random event. That is, the annotated disjunction 1 3 :: color(B, green); 1 3 :: color(B, red); 1 3 :: color(B, blue) :− ball(B).
defines an independent probabilistic choice of color for each ball B. As noted already by Vennekens et al. [2004], the probabilistic choice over head atoms in an annotated disjunction can equivalently be expressed using a set of logical clauses, one for each head, and a probabilistic choice over facts added to the bodies of these clauses, e.g. This example illustrates that annotated disjunctions define a distribution P F over basic facts as required in the distribution semantics, but can simplify modeling by directly expressing probabilistic consequences. As mentioned above, a probabilistic fact directly corresponds to an annotated disjunction with a single atom in the head and an empty body. Conversely, each annotated disjunction can -for the purpose of calculating success probabilities -be equivalently represented using a set of probabilistic facts and deterministic clauses, which together simulate a sequential choice mechanism; we refer to Appendix B for details.
Independent Causes Some languages, e.g. ICL [Poole, 2008], assume that head atoms in the same or different annotated disjunctions cannot unify with one another, while others, e.g., LPADs [Vennekens et al., 2004], do not make this restriction, but instead view each annotated disjunction as an independent cause for the conclusions to hold. In that case, the structure of the program defines the combined effect of these causes, similarly to how the two clauses for alarm in our earlier example (1) combine the two causes burglary and earthquake. We illustrate this on the Russian roulette example by Vennekens et al. [2009], which involves two guns.
to the probability of death being proven via the first or via the second annotated disjunction (or both). Assuming independent causes closely corresponds to the noisy-or combining rule that is often employed in the Bayesian network literature, cf. Section 5.

Inference Tasks
In probabilistic programming and statistical relational learning, the following inference tasks have been considered: • In the SU CC(q) task, a ground query q is given, and the task is to compute SU CC(q) = P s (q), the success probability of the query as specified in Equation (4). 2 • In the M ARG(Q | e) task, a set Q of ground atoms of interest, the query atoms, and a ground query e, the evidence, are given. The task is to compute the marginal probability distribution of each atom q ∈ Q given the evidence, The SU CC(q) task corresponds to the special case of the M ARG(Q | e) task with Q = {q} and e = true (and thus P s (e) = 1).
• The M AP (Q | e) task is to find the most likely truth-assignment q to the atoms in Q given the evidence e, that is, to compute M AP (Q | e) = arg max q P s (Q = q|e) • The M P E(U | e) task is to find the most likely world where the given evidence query e holds. Let U be the set of all atoms in the Herbrand base that do not occur in e. Then, the task is to compute the most likely truth-assignment u to the atoms in U , M P E(e) = M AP (U | e).
• In the V IT (q) task, a query q is given, and the task is to find a Viterbi proof of q. Let E(q) be the set of all explanations or proofs of q, that is, of all sets F of ground probabilistic atoms for which q is true in the corresponding possible world. Then, the task is to compute To illustrate, consider our initial alarm example (1) with e = calls(mary) and Q = {burglary, calls(john)}. The worlds where the evidence holds are listed in Table 1, together with their probabilities. The answer to the MARG task is P s (burglary|calls(mary)) = 0.07/0.196 = 0.357 and P s (calls(john)|calls(mary)) = 0.0784/0.196 = 0.4. The answer to the MAP task is burglary=false, calls(john)=false, as its probability 0.0756/0.196 is higher than 0.028/0.196 (for true, true), 0.042/0.196 (for true, false) and 0.0504/0.196 (for false, true). The world returned by MPE is the one corresponding to the set of facts {earthquake, hears_alarm(mary)}. Finally, the Viterbi proof of query calls(mary) is e ∧ hm, as 0.2 · 0.7 > 0.1 · 0.7 (for b ∧ hm).

Inference
We now provide an overview of existing inference approaches in probabilistic (logic) programming. As most existing work adresses the SUCC task of computing success probabilities, cf. Equation (4), we focus on this task here, and mention other tasks in passing where appropriate. For simplicity, we assume probabilistic facts as basic building blocks. Computing marginals under the distribution semantics has to take into account both probabilistic and logical aspects. We therefore distinguish between exact inference and approximation using either bounds or sampling on the probabilistic side, and between methods based on forward and backward reasoning and grounding to CNF on the logical side. Systems implementing (some of) these approaches include the ICL system AILog2 3 , the PRISM system 4 , the ProbLog implementations ProbLog1 5 and ProbLog2 6 , and the LPAD implementations cplint 7 and PITA 8 . General statements about systems in the following refer to these six systems.

Exact Inference
As most methods for exact inference can be viewed as operating (implicitly or explicitly) on a propositional logic representation of all possible worlds that entail the query q of interest, we first note that this set of possible worlds is given by the following formula in disjunctive normal form (DNF) and that the structure of this formula exactly mirrors that of Equation (5) defining the success probability in the case of probabilistic facts, where we replace summation by disjunction, multiplication by conjunction, and probabilities by truth values of random variables (or facts). In our initial alarm example (1), the DNF corresponding to calls(mary) contains the worlds shown in Table 1, and thus is  Forward Reasoning: Following the definition of the semantics of CP-logic [Vennekens et al., 2009], forward reasoning can be used to build a tree whose leaves correspond to possible worlds, on which success probabilities can be calculated. Specifically, the root of the tree is the empty set, and in each node, one step of forward reasoning is executed, creating a child for each possible outcome in the case of probabilistic facts or annotated disjunctions. For instance, consider the program 0.4 :: draw.
As illustrated in Figure 1, the first step using the probabilistic fact draw adds two children to the root, one containing draw, and one containing not(draw).
In the latter case, the body of the AD is false and thus no further reasoning steps are possible. For the world where draw is true, the AD introduces three children, adding green, red and blue, respectively, and no further reasoning steps are possible in the resulting worlds. Thus, each path from the root to a leaf constructs one possible world, whose probability is the product of assignments made along the path. Domains for non-ground facts have to be explicitly provided to ensure termination. While this approach clearly illustrates the semantics, even in the finite case, it suffers from having to enumerate all possible worlds, and is therefore not used in practice.
Backward Reasoning: Probably the most common inference strategy in probabilistic logic programming is to collect all possible proofs or explanations of a given query using backward reasoning, represent them in a suitable data structure, and compute the probability on that structure. As discussed in Section 2.3, an explanation is a partial truth value assignment to probabilistic facts that is sufficient to prove the query via SLD-resolution. For instance, b ∧ hm is the explanation for calls(mary) given by the derivation discussed in Section 2.1 (page 5), as it depends on burglary and hears_alarm(mary) being true, but not on any particular truth values of earthquake and hears_alarm(john). This query has a second proof, e ∧ hm, obtained by using the first clause for alarm during backward reasoning. We can describe the set of possible worlds where calls(mary) is true by the disjunction of all proofs of the query, , which is more compact than the disjunction (7) explicitly listing the six possible worlds. We cannot, however, calculate the probability of this more compact DNF by simply replacing conjunction by multiplication and disjunction by addition as we did for the longer DNF above. The reason is that the two proofs are not mutually exclusive, that is, they can be true in the same possible world. Specifically, in our example this holds for the two worlds b ∧ e ∧ hm ∧ hj and b ∧ e ∧ hm ∧ ¬hj, and the probability of these worlds, 0.1 · 0.2 · 0.7 · 0.4 + 0.1 · 0.2 · 0.7 · (1 − 0.4) = 0.014 is exactly the difference between 0.21 as obtained by the direct sum of products 0.1 · 0.7 + 0.2 · 0.7 and the true probability 0.196. This is also known as the disjoint-sum-problem, which is #Pcomplete [Valiant, 1979]. Existing languages and systems approach the problem from different angles. PHA [Poole, 1992] and PRISM [Sato and Kameya, 2001] rely on the exclusive explanation assumption, that is, they assume that the structure of the program guarantees mutual exclusiveness of all conjunctions in the DNF, which allows one to evaluate it as a direct sum of products (as done in the PRISM system). This assumption allows for natural modeling of many models, including e.g., probabilistic grammars and Bayesian networks, but prevents direct modeling of e.g., connection problems over uncertain graphs where each edge independently exists with a certain probability, or simple variations of Bayesian network models such as our running example. ICL [Poole, 2000] is closely related to PHA, but does not assume exclusive explanations. Poole instead suggests symbolic disjoining techniques to split explanations into mutually exclusive ones (implemented in AILog2). The ProbLog1 implementation of ProbLog [De Raedt et al., 2007, Kimmig et al., 2011a has been the first probabilistic programming system representing DNFs as Binary Decision Diagrams (BDDs), an advanced data structure that disjoins explanations. This technique has subsequently also been adopted for ICL and LPADs in the cplint and PITA systems [Riguzzi, 2009, Riguzzi andSwift, 2011]. AILog2 and cplint also support computing conditional probabilities. Riguzzi [2013c] has introduced an approach called PITA(OPT) that automatically recognizes certain independencies that allow one to avoid the use of disjoining techniques when computing marginal probabilities. Given its focus on proofs, backward reasoning can easily be adapted to solve the VIT task of finding most likely proofs, as done in the PRISM, ProbLog1 and PITA systems.
Reduction to Weighted Model Counting: A third way to approach the logic side of inference in probabilistic logic programming has been suggested by Fierens et al. [2011Fierens et al. [ , 2014, who use the propositional logic semantics of logic programming to reduce MARG inference to weighted model counting (WMC) and MPE inference to weighted MAX-SAT. The first step again builds a Boolean formula representing all models where the query is true, but this time, using conjunctive normal form (CNF), and associating a weight with every literal in the formula. More specifically, it grounds the parts of the logic program relevant to the query (that is, the rule groundings contributing to a proof of the query, as determined using backward reasoning), similar to what happens in answer set programming, transforms this ground program into an equivalent CNF based on the semantics of logic programming, and defines the weight function for the second step using the given probabilities. The second step can then use any existing approach to WMC or weighted MAX-SAT, such as representing the CNF as an sd-DNNF, a data structure on which WMC can be performed efficiently.
For instance, the relevant ground program for calls(mary) in our initial alarm example (1)  Next, the rules in the ground program are translated to equivalent formulas in propositional logic, taking into account that their head atoms can only be true if a corresponding body is true: The conjunction of these formulas is then transformed into CNF as usual in propositional logic. The weight function assigns the corresponding probabilities to literals of probabilistic facts, e.g., w(burglary) = 0.1, w(¬burglary) = 0.9, and 1.0 to all other literals, e.g., w(calls(mary)) = w(¬calls(mary)) = 1.0. The weight of a model is the product of all literal weights, and the WMC of a formula the sum of weights of all its models, which exactly corresponds to the success probability. Evidence can directly be incorporated by conjoining it with the CNF. Exact MARG inference using this approach is implemented in ProbLog2.
Lifted Inference is the topic of a lot of research in statistical relational learning today [Kersting, 2012, Poole, 2003. Lifted inference wants to realize probabilistic logic inference at the lifted, that is, non-grounded level in the same way that resolution realizes this for logical inference. The problem of lifted inference can be illustrated on the following example (cf. also Poole [2008]): In this case P s (popular(john)) = 1 − (1 − p) m where m is the number of friends of john, that is, to determine the probability that john is popular, it suffices to know how many friends john has. We do not need to know the identities of these friends, and hence, need not ground the clauses.
Various techniques for lifted inference have been obtained over the past decade. For instance, Poole [2003] shows how variable elimination, a standard approach to probabilistic inference in graphical models, can be lifted and  studied weighted model counting for first order probabilistic logic using a generalization of d-DNNFs for first order logic. Lifted inference techniques are -to the best of our knowledge -not yet supported by current probabilistic logic programming language implementations, which explains why we do not provide more details in this paper. It remains a challenge for further work. A recent survey on lifted inference is provided by Kersting [2012].

Approximate Inference using Bounds
As the probability of a set of possible worlds monotonically increases if more models are added, hard lower and upper bounds on the success probability can be obtained by considering a subset or a superset of all possible worlds where a query is true. For instance, let W be the set of possible worlds where a query q holds. The success probability of q thus is the sum of the probabilities of all worlds in W . If we restrict this sum to a subset of W , we obtain a lower bound, and an upper bound if we sum over a superset of W . In our example, as calls (mary) In practice, this approach is typically used with the DNF obtained by backward reasoning, that is, the set of proofs of the query, rather than with the possible worlds directly. This has initially been suggested for PHA by Poole [1992], and later also been adapted for ProbLog [De Raedt et al., 2007, Kimmig et al., 2008 and LPADs [Bragaglia and Riguzzi, 2011]. The idea is to maintain a set of partial derivations during backward reasoning, which allows one to, at any point, obtain a lower bound based on all complete explanations or proofs found so far, and an upper bound based on those together with all partial ones (based on the assumption that those will become proofs with probability one). For instance, (e ∧ hm) ∨ b provides an upper bound of 0.226 for the probability of calls(mary) based on the proof e ∧ hm (which provides the corresponding lower bound 0.14) and the partial derivation b (which still requires to prove hears_alarm(mary)). Different search strategies are possible here, including e.g., iterative deepening or best first search. Lower bounds based on a fixed number of proofs have been proposed as well, either using the k explanations with highest individual probabilities [Kimmig et al., 2011a], or the k explanations chosen by a greedy procedure that maximizes the probability an explanation adds to the one of the current set [Renkens et al., 2012]. Approximate inference using bounds is available in ProbLog1, cplint, and ProbLog2.

Approximate Inference by Sampling
While probabilistic logic programming often focuses on exact inference, approximate inference by sampling is probably the most popular approach to inference in many other probabilistic languages. Sampling uses a large number of random executions or randomly generated possible worlds, from which the probability of a query is estimated as the fraction of samples where the query holds. For instance, samples can be generated by randomly choosing truth values of probabilistic facts as needed during backward reasoning, until either a proof is found or all options are exhausted [Kimmig et al., 2008, Bragaglia and Riguzzi, 2011, Riguzzi, 2013b. Fierens et al. [2014] have used MC-SAT [Poon and Domingos, 2006] to perform approximate WMC on the CNF representing all models. Systems for languages that specify generative models, such as BLOG [Milch et al., 2005] and distributional clauses , cf. Sec. 4.2, often use forward reasoning to generate samples. A popular approach to sampling are MCMC algorithms, which, rather than generating each sample from scratch, generate a sequence of samples by making random modifications to the previous sample based on a so-called proposal distribution. This approach has been used e.g., for the probabilistic functional programming language Church [Goodman et al., 2008], for BLOG [Arora et al., 2010], and for the probabilistic logic programming languages PRISM [Sato, 2011] and ProbLog [Moldovan et al., 2013]. ProbLog1 and cplint provide inference techniques based on backward sampling, and the PRISM system includes MCMC inference.

Probabilistic Programming Concepts
While probabilistic programming languages based on the distribution semantics as discussed so far are expressive enough for a wide range of models, an important part of their power is their support for additional programming concepts. Based on primitives used in a variety of probabilistic languages, we discuss a range of such concepts next, also touching upon their implications for inference.

Flexible Probabilities
A probabilistic fact with flexible probability is of the form P :: atom where atom contains the logical variable P that has to be instantiated to a probability when using the fact. The following example models drawing a red ball from an urn with R red and G green balls, where each ball is drawn with uniform probability from the urn: Prob :: red(Prob). draw red(R, G):− Prob is R/(R + G), red(Prob).
The combination of flexible probabilities and Prolog code offers a powerful tool to compute probabilities on-the-fly, cf. e.g., [Poole, 2008]. Flexible probabilities have also been used in extended SLPs [Angelopoulos and Cussens, 2004], and are supported by the probabilistic logic programming systems AILog2, ProbLog1, cplint and ProbLog2. Indeed, probabilistic facts with flexible probabilities are easily supported by backward inference as long as these facts are ground on calling, but cannot directly be used with exact forward inference, as they abbreviate an infinite set of ground facts and thus would create an infinite tree of possible worlds. 9

Distributional Clauses
Annotated disjunctions -as specified in Section 2.2 -are of limited expressivity, as they can only define distributions over a fixed, finite number of head elements. While more flexible discrete distributions can be expressed using a combination of flexible probabilities and Prolog code, this may require significant programming effort. Gutmann et al. [2010] introduce Hybrid ProbLog, an extension of ProbLog to continuous distributions, but their inference approach based on exact backward reasoning and discretization severely limits the use of such distributions. To alleviate these problems, distributional clauses were introduced by Gutmann et al. [2011], whom we closely follow.
A distributional clause is a clause of the form where ∼ is a binary predicate used in infix notation. Similarly to annotated disjunctions, the head (h ∼ D)θ of a distributional clause is defined for a grounding substitution θ whenever (b 1 , . . . , b n )θ is true in the semantics of the logic program. Then the distributional clause defines the random variable hθ as being distributed according to the associated distribution Dθ. Possible distributions include finite discrete distributions such as a uniform distribution, discrete distributions over infinitely many values, such as a Poisson distribution, and continuous distributions such as Gaussian or Gamma distributions. The outcome of a random variable h is represented by the term (h). Both random variables h and their outcome (h) can be used as other terms in the program. However, the typical use of terms (h) is inside comparison predicates such as equal/2 or lessthan/2. In this case these predicates act in the same way as probabilistic facts in Sato's distribution semantics. Indeed, depending on the value of (h) (which is determined probabilistically) they will be true or false. Consider the following distributional clause program. ball(1). ball(2). . . . ball(k).
The first clause states that for every ball B, there is a random variable color(B) whose value is either green (with probability 0.7) or blue (with probability 0.3). This discrete distribution directly corresponds to the one given by the annotated disjunction 0.7 :: color(B, green); 0.3 :: color(B, blue) :ball(B). The second distributional clause in the example defines a random variable diameter(B,MD) for each ball B. This random variable follows a Gamma distribution with parameters MD/20 and 20, where the mean diameter MD depends on the color of the ball.
Distributional clauses are the logic programming equivalent of the mechanisms employed in statistical relational languages such as Bayesian Logic (BLOG) [Milch et al., 2005], Church [Goodman et al., 2008] and IBAL [Pfeffer, 2001], which also use programming constructs to define generative process that can define new variables in terms of existing one.
As we have seen in the example, annotated disjunctions can easily be represented as distributional clauses with finite, discrete distributions. However, distributional clauses are more expressive than annotated disjunctions (and the standard distribution semantics) as they can also represent continuous distributions.
Performing inference with distributional clauses raises some extra difficulties (see  for more details). The reason for this is that continuous distributions (such as a Gaussian or a Gamma-distribution) have uncountable domains. Typical inference with constructs such as distributional clauses will therefore resort to sampling approaches in order to avoid the need for evaluating complex integrals. It is quite natural to combine sampling for distributional clauses with forward reasoning 10 , realizing a kind of generative process, though more complex strategies are also possible, cf. .

Unknown Objects
One of the key contributions of Bayesian Logic (BLOG) [Milch et al., 2005] is that it allows one to drop two common assumptions, namely the closed world assumption (all objects in the world are known in advance) and the unique names assumption (different terms denote different objects), which makes it possible to define probability distributions over outcomes with varying sets of objects. This is achieved by defining generative processes that construct possible worlds, where the existence and the properties of objects can depend on objects created earlier in the process.
As already shown by Poole [2008], such generative processes with an unknown number of objects can often be modeled using flexible probabilities and Prolog code to specify a distribution over the number of objects as done in BLOG. Distributional clauses simplify this modeling task, as they make introducing a random variable corresponding to this number straightforward. We can then use the between/3 predicate to enumerate the objects in definitions of predicates that refer to them, cf. also [Poole, 2008]. Below, the random variable nballs stands for the number of balls, which is Poisson distributed with λ = 6. For each possible value (nballs), the corresponding number of balls are generated which are identified by the numbers 1, 2, . . . , (nballs).

Stochastic Memoization
A key concept in the probabilistic functional programming language Church [Goodman et al., 2008] is stochastic memoization. If a random variable in Church is memoized, subsequent calls to it simply look up the result of the first call, similarly to tabling in logic programming. On the other hand, for random variables that are not memoized, each reference to the variable corresponds to an independent draw of an outcome. In contrast to Church, probabilistic logic programming languages and their implementations typically do not leave this choice to the user. In ICL, ProbLog, LPADs and the basic distribution semantics as introduced in [Sato, 1995], each ground probabilistic fact directly corresponds to a random variable, i.e., within a possible world, each occurrence of such a fact has the same truth value, and the fact is thus memoized. Furthermore, the probability of the fact is taken into account once when calculating the probability of a proof, independently of the number of times it occurs in that proof. While early versions of PRISM [Sato, 1995, Sato andKameya, 1997] used binary or n-ary probabilistic choices with an argument that explicitly distinguished between different calls, this argument has been made implicit later on [Sato and Kameya, 2001], meaning that the PRISM implementation never memoizes the outcome of a random variable.
The difference between the two approaches can be explained using the following example. For the AD ( 1 3 :: color(green); 1 3 :: color(red); 1 3 :: color(blue)), there are three answers to the goal (color(X),color(Y)), one answer X = Y = c for each color c with probability 1 3 , as exactly one of the facts color(c) is true in each possible world when memoizing color (as in ProbLog and ICL). Asking the same question when color is not memoized (as in PRISM) results in 9 possible answers with probability 1 9 each. The query then -implicitly -corresponds to an ICL or ProbLog query (color(X,id1), color(Y,id2)), where the original AD is replaced by a non-ground variant ( 1 3 :: color(green, ID); 1 3 :: color(red, ID); 1 3 :: color(blue, ID)) and id1 and id2 are trial identifiers that are unique to the call.
Avoiding the memoization of probabilistic facts is necessary in order to model stochastic automata, probabilistic grammars, or stochastic logic programs [Muggleton, 1996] under the distribution semantics. There, a new rule is chosen randomly for each occurrence of the same nonterminal state/symbol/predicate within a derivation, and each such choice contributes to the probability of the derivation. The rules for a nonterminal thus form a family of independent identically distributed random variables, and each choice is automatically associated with one variable from this family.
Consider the following stochastic logic program. It is in fact a fragment of a stochastic definite clause grammar; the rules essentially encode the probabilistic context free grammar rules defining 0.3 : vp → verb, 0.5 : vp → verb, np and 0.2 : vp → verb, pp. There are three rules for the non-terminal vp and each of them is chosen with an associated probability. Furthermore, the sum of the probabilities for these rules equals 1. All inference approaches discussed here naturally support stochastic memoization; this includes the ones implemented in AILog2, ProbLog1, ProbLog2, cplint and PITA. The PRISM system uses exact inference based on backward reasoning in the setting without stochastic memoization. In principle, stochastic memoization can be disabled in backward reasoning by automatically adding a unique identifier to each occurrence of the same random variable. However, for techniques that build propositional representations different from mutually exclusive DNFs (such as the DNFs of BDD-based methods and the CNFs when reducing to WMC), care is needed to ensure that these identifiers are correctly shared among different explanations when manipulating these formulas. Backward sampling can easily deal with both memoized and dememoized random variables. As only one possible world is considered at any point, each repeated occurrence of the same dememoized variable is simply sampled independently, whereas the first result sampled within the current world is reused for memoized ones. Forward sampling cannot be used without stochastic memoization, as it is unclear up front how many instances are needed. MCMC methods have been developed both for ProbLog (with memoization) and PRISM (without memoization).

Constraints
In knowledge representation, answer set programming and databases, it is common to allow the user to specify constraints on the possible models of a theory. In knowledge representation, one sometimes distinguishes inductive definitions (such as the definite clauses used in logic programming) from constraints. The former are used to define predicates, the latter impose constraints on possible worlds. While the use of constraints is still uncommon in probabilistic logic programming 12 it is conceptually easy to accommodate this when working with the distribution semantics, cf. Fierens et al. [2012]. While such constraints can in principle be any first-order logic formula, we will employ clausal constraints here.
A clausal constraint is an expression of the form where the h i and b j are literals. The constraint specifies that whenever (b 1 . . . b M )θ is true for a substitution θ grounding the clause at least one of the h i θ must also 11 The dememoize keyword is used for clarity here; it is not supported by existing systems. 12 Hard and soft constraints are used in Markov Logic [Richardson and Domingos, 2006], but Markov Logic does not support inductive definitions as this requires a least Herbrand semantics, cf. Fierens et al. [2012]. be true. All worlds in which a constraint is violated become impossible, that is, their probability becomes 0. Constraints are very useful for specifying complex properties that possible worlds must satisfy.
To illustrate constraints, reconsider the alarm example and assume that it models a situation in the 1930s where there is only one phone available in the neighborhood implying that at most one person can call. This could be represented by the constraint X = Y :− calls(X), calls(Y).
Imposing this constraint would exclude all worlds in which both Mary and John hear the alarm and call. The total probability mass for such worlds is 0.4 · 0.8 = 0.32. By excluding these worlds, one looses probability mass and thus has to normalize the probabilities of the remaining possible worlds. For instance, the possible world corresponding to the truth value assignment burglary=true, earthquake=false, hears_alarm(mary)=true, hears_alarm(john)=false yielded a probability mass of 0.1 · (1 − 0.2) · 0.7 · (1 − 0.6) = 0.0336 without constraints. Now, when enforcing the constraint, one obtains 0.0336/(1 − 0.32). Thus the semantics of constraints correspond to computing conditional probabilities where one conditions on the constraints being satisfied.
Handling constraints during inference has not been a focus of inference in probabilistic logic programming, and -to the best of our knowledge -no current system provides explicit support for constraints.

Negation as Failure
So far, we have only considered probabilistic programs using definite clauses, that is, programs that only use positive literals in clause bodies, as those are guaranteed to have a unique model for any truth value assignment to basic probabilistic events. It is however possible to adopt Prolog's negation as failure on ground literals under the distribution semantics, as long as all truth values of derived atoms are still uniquely determined by those of the basic facts, cf., e.g., [Poole, 2000, Sato et al., 2005, Kimmig et al., 2009, Riguzzi, 2009, Fierens et al., 2014. Then, in each possible world, any ground query q either succeeds or fails, and its negation not(q) succeeds in exactly those worlds where q fails. Thus, the probability of a ground query not(q) is the sum of the probabilities of all possible worlds that do not entail q. Consider the following variant of our alarm example, where people also call if there is no alarm, but they have gossip to share: 0.1 :: burglary. 0.7 :: hears alarm(mary). 0.2 :: earthquake. 0.4 :: hears alarm(john). The new rule for calls(X) can only possibly apply in worlds where not(alarm) succeeds, that is, alarm fails, which are exactly those containing neither burglary nor earthquake. Using gm as shorthand for has_gossip(mary)= true, we obtain the additional explanation ¬e ∧ ¬b ∧ gm for calls(mary). Thus, in the presence of negation, explanations no longer correspond to sets of probabilistic facts as in the case of definite clause programs, but to sets of positive and negative literals for probabilistic facts. While not(alarm) has a single explanation in this simple example, in general, explanations for negative literals can be much more complex, as they have to falsify every possible explanation of the corresponding positive literal by flipping the truth value of at least one probabilistic fact included in the explanation.
Negation as failure can be handled in forward and backward reasoning both for exact inference and for sampling, though forward reasoning has to ensure to proceed in the right order. Exact inference with backward reasoning often benefits from tabling. Negation as failure complicates approximate inference using bounds, as explanations for failing goals have to be considered. AILog2, ProbLog1, ProbLog2, cplint and PITA all support negation as failure in their exact and sampling based approaches. The PRISM system follows the approach proposed by Sato et al. [2005] and compiles negation into a definite clause program with unification constraints. Current MCMC approaches in probabilistic logic programming do not support negation beyond that of probabilistic facts.

Second Order Predicates
When modeling relational domains, it is often convenient to reason over sets of objects that fullfil certain conditions, for instance, to aggregate certain values over them. In logic programming, this is supported by second order predicates such as findall/3, which collects all answer substitutions for a given query in a list. In the following example, the query sum(S) will first collect all arguments of f/1 into a list and then sum the values using predicate sum_list/2, thus returning S=3. Note that in Prolog, the list returned by findall/3 is unique. Under the distribution semantics, however, this list will be different depending on which possible world is considered. To illustrate this, we replace the definition of f/1 in our example with probabilistic facts: This behavior of second order predicates in the probabilistic setting can pose a challenge to inference. In principle, all inference approaches could deal with second order predicates. However, exact approaches would suffer from a blowup, as they have to consider all possible lists of elements -and thus all possible worlds -explicitly, whereas in sampling, each sample only considers one such list. As far as we know, the only system with some support for second order predicates is cplint, which allows bagof and setof with one of its backward reasoning modules [Riguzzi, 2013a].

Meta-Calls
One of the distinct features of programming languages such as Prolog and Lisp is the possibility to use programs as objects within programs, which enables meta-level programming. For their probabilistic extensions, this means reasoning about the probabilities of queries within a probabilistic program, a concept that is central to the probabilistic programming language Church, which builds upon a Lisp dialect [Goodman et al., 2008], and has also been considered with ProbLog [Mantadelis and Janssens, 2011]. Possible uses of such a feature include filtering of proofs based on the probability of subqueries, or the dynamic definition of probabilities using queries, e.g., to implement simple forms of combining rules as in the following example, where max_true(G1,G2) succeeds with the success probability of the more likely argument. In this section, we will use prob(Goal,Prob) to refer to an atom returning the success probability Prob of goal Goal, that is, implementing Equation (4). Note that such atoms are independent queries, that is, they do not share truth values of probabilistic facts with other atoms occurring in a derivation they are part of. Finally, if the second argument is a free variable upon calling, the success probability of prob(goal,Prob) is 1. For the sake of simplicity, we will assume here that the second argument will always be free upon calling. 13 We extend the example above with the following program. Querying for max_true(d,e) using backward reasoning will execute two calls to prob/2 in sequence: prob(d,P1) and prob(e,P2). Note that if multiple calls to prob/2 atoms occur in a proof, they are independent, i.e., even if they use the same probabilistic facts, those will (implicitly) correspond to different copies of the corresponding random variables local to that specific prob/2 call. Put differently, prob/2 encapsulates part of our possible worlds. In the example, b is thus a different random variable in prob(d,P1) and prob(e,P2). The reason for this encapsulation is twofold: first, the probability of a goal is not influenced by calculating the probability of another (or even the same) event before, and second, as prob/2 summarizes a set of possible worlds, the value of a random variable cannot be made visible to the outside world, as it may be different in different internal worlds. Indeed, in our example, b needs to be false to prove d, but true to prove e, so using the same random variable would force the top level query to be unprovable. We thus obtain a kind of hierarchically organized world: some probabilistic facts are used in the top level query, others are encapsulated in prob/2 atoms, whose queries might in turn rely on both directly called probabilistic facts and further calls to prob/2. In our example, prob(d,P1) uses random variables corresponding to probabilistic facts a and b, returning P1 = 0.5 · (1 − 0.7) = 0.15, prob(e,P2) uses random variables corresponding to probabilistic facts b and c, returning P2 = 0.7 · 0.2 = 0.14, and the top level query max_true(d,e) uses probabilistic fact p(0.15) and has probability P (more likely is true(d, e)) = 0.15. The probability of a derivation is determined by the probabilities of the probabilistic facts it uses outside all prob/2 calls. Those facts define the possible worlds from the point of view of the top level query. In those worlds, the random variables of the encapsulated parts are hidden, as they have been aggregated by prob/2. Returning to our example and abstracting from the concrete remainder of the program, we observe that for any given pair of goals g1,g2 and suitable program defining those goals, max_true(g1,g2) has exactly one proof: the first two body atoms always succeed and return the probabilities of the goals, the third atom deterministically finds the maximum m of the two probabilities, and the proof finally uses a single random variable p(m) with probability m. Thus, the query indeed succeeds with the probability of the more likely goal.
Another example for the use of prob/2 is filtering goals based on their probability: almost always false(G) :− prob(G, P), P < 0.00001. % rest of program (omitted) Note that in contrast to the previous example, this is a purely logical decision, that is, the success probability will be either 0 or 1 depending on the goal G.
To summarize, using meta-calls to turn probabilities into usable objects in probabilistic logic programming is slightly different from the other probabilistic programming concepts considered in this paper: it requires a notion of encapsulation or hierarchical world structure and cannot be interpreted directly on the level of individual possible worlds for the entire program. Mantadelis and Janssens [2011] introduce MetaProbLog 14 , a prototype implementation for ProbLog supporting nested meta-calls based on exact backward inference. As they discuss, meta-calls can be supported by any inference mechanism that can be suspended to perform inference for the query inside the meta-call. Such suspending is natural in backward reasoning, where the proof of a subgoal becomes a call to inference rather than a continuation of backward reasoning. With forward reasoning, such non-ground prob(goal,P) goals raise the same issues as other non-ground facts. Meta-calls of the form prob(goal,P) compute the grounding of P as the goal's probability, and using approximate inference to compute the latter will thus influence the grounding of such a fact, and therefore potentially also the consequences of this fact. This may affect the result of inference in unexpected ways, and it is thus unclear in how far approximation approaches are suitable for meta-calls. Goodman et al. [2008] state that supporting meta-calls (or nested queries) in MCMC inference in Church is expected to be straightforward, but do not provide details. Meta-calls are not supported in AILog2, PRISM, ProbLog1, ProbLog2, cplint and PITA.

Time and Dynamics
Among the most popular probabilistic models are those that deal with dynamics and time such as Hidden Markov Models (HMMs) and Dynamic Bayesian Networks. Dynamic models have received quite some attention within probabilistic logic programming. They can naturally be represented using logic programs through the addition of an extra "time" argument to each of the predicates. We illustrate this by giving two encodings of the Hidden Markov Model shown in Figure 2, where we restrict sequences to a given length (10 in the example). Following Vennekens et al. [2004], this model can be written as a set of annotated disjunctions: length ( Alternatively, following Sato and Kameya [1997], but writing PRISM's multivalued switches as unconditional annotated disjunctions 15 , the model can be  Forward and backward sampling naturally deal with a time argument (provided time is bounded in the case of forward reasoning). Naively using such a time argument with exact inference results in exponential running times (in the number of time steps), though this can often be avoided using dynamic programming approaches and principles, as shown by the PRISM system, which achieves the same time complexity for HMMs as corresponding special-purpose algorithms [Sato and Kameya, 2001].
Other approaches that have devoted special attention to modeling and inference for dynamics include Logical HMMs [Kersting et al., 2006], a language for modeling HMMs with structured states, CPT-L [ , a dynamic version of CP-logic, and the work on a particle filter for dynamic distributional clauses [Nitti et al., 2013].

Generalized Labels
As we have seen in Section 3, computing success probabilities in probabilistic logic programming is closely related to evaluating the truth value of a logical formula. Weighted logic programming languages such as Dyna [Eisner et al., 2005] 16 and aProbLog [Kimmig et al., 2011b] take this observation a step further and replace probabilities (or Boolean truth values) by elements from an arbitrary semiring and corresponding combination operators. 17 More specifically, Dyna assigns labels to ground facts in a logic program and computes weights of atoms in the heads of clauses as follows: conjunction (,) in clause bodies is replaced by semiring multiplication ⊗, that is, the weight of a body is the ⊗-product of the weights of its atoms, and if multiple clauses share the same head atom, this atom's weight is the ⊕-sum of the corresponding bodies, that is, :− is replaced by semiring addition ⊕. We illustrate the idea with a logic program defining reachability in a directed graph adapted from Cohen et al. [2008]: which in Dyna is interpreted as a system of (recursive) semiring equations reachable(S) ⊕ = initial(S).

reachable(S) ⊕ = reachable(R) ⊗ edge(R, S).
To get the usual logic programming semantics, we can combine this program with facts labeled with values from the Boolean semiring (with ⊗ = ∧ and ⊕ = ∨): which means that the weights of reachable atoms are computed as follows: Alternatively, one can label facts with non-negative numbers denoting costs and use ⊗ = + and ⊕ = min to describe single-source shortest paths: 16 Dyna is currently being extended into a more general language [Eisner and Filardo, 2011], but we consider the initial version here, as that one is more closely related to the probabilistic programming languages we discuss.
17 A semiring is a structure (A, ⊕, ⊗, e ⊕ , e ⊗ ), where addition ⊕ is an associative and commutative binary operation over the set A, multiplication ⊗ is an associative binary operation over the set A, ⊗ distributes over ⊕, e ⊕ ∈ A is the neutral element of ⊕, i.e., for all a ∈ A, a ⊕ e ⊕ = a, e ⊗ ∈ A is the neutral element of ⊗, i.e., for all a ∈ A, a ⊗ e ⊗ = a, and for all a ∈ A, e ⊕ ⊗ a = a ⊗ e ⊕ = e ⊕ . In a commutative semiring, ⊗ is commutative as well.
That is, the values of reachable atoms now correspond to the length of the shortest path rather than the existence of a path.
Given its origins in natural language processing, Dyna is closely related to PRISM in two aspects. First, it does not memoize labeled facts, but takes into account their weights each time they appear in a derivation, generalizing how each use of a rule in a probabilistic grammar contributes to a derivation. Second, again as in probabilistic grammars, it sums the weights of all derivations, but in contrast to PRISM or grammars does not require them to be mutually exclusive to do so.
The inference algorithm of basic Dyna as given by Eisner et al. [2005] 18 computes weights by forward reasoning, keeping intermediate results in an agenda and updating them until a fixpoint is reached, though other execution strategies could be used as well, cf. [Eisner and Filardo, 2011].
As Dyna, aProbLog [Kimmig et al., 2011b] replaces probabilistic facts by semiring-labeled facts, with the key difference that it bases the labels of derived facts on the labels of their models rather than those of their derivations, which requires semirings to be commutative. It thus directly generalizes the success probability (5) and the possible world DNF (6). ProbLog inference algorithms based on BDDs or sd-DNNFs can be directly adapted to aProbLog. 19 Rather than replacing probabilities with semiring labels, one can also combine them with utilities or costs, and use the resulting language for decision making under uncertainty, as done in DTProbLog [ Van den Broeck et al., 2010]. 20

Knowledge-Based Model Construction
So far, we have focused on probabilistic logic languages with strong roots in logic, where the key concepts of logic and probability are unified, that is, a random variable corresponds to a ground fact (or sometimes a ground term, as in distributional clauses), and standard logic programs are used to specify knowledge that can be derived from these facts. In this section, we discuss a second important group of probabilistic logic languages with strong roots in probabilistic graphical models, such as Bayesian or Markov networks. These formalisms typically use logic as a templating language for graphical models in relational domains, and thus take a quite different approach to combine logic and probabilities, also known as knowledge-based model construction (KBMC). Important representatives of this stream of research include PLPs [Haddawy, 1994], PRMs , BLPs , LBNs [Fierens et al., 2005], RBNs [Jaeger, 1997], CLP(BN ) [Santos , chain logic [Hommersom et al., 2009], Markov Logic [Richardson and Domingos, 2006], and PSL [Broecheler et al., 2010].
In the following, we relate the key concepts underlying the knowledge-based model construction approach to those discussed in the rest of this paper. We again focus on languages based on logic programming, such as PLPs, BLPs, LBNs, chain logic, and CLP(BN ), but mostly abstract from the specific lan-guage. These representation languages are typically designed so that implication in logic (":−") corresponds to the direct influence relation in Bayesian networks. The logical knowledge base is then used to construct a Bayesian network. So inference proceeds in two steps: the logical step, in which one constructs the network, and the probabilistic step, in which one performs probabilistic inference on the resulting network. We first discuss modeling Bayesian networks and their relational counterpart in the context of the distribution semantics, and then focus on CLP(BN ) as an example of a KBMC approach whose primitives clearly expose the separation between model construction via logic programming and probabilistic inference on the propositional model.

Bayesian Networks and Conditional Probability Tables
A Bayesian network (BN) defines a joint probability distribution over a set of random variables V = {V 1 , . . . , V m } by factoring it into a product of conditional probability distributions, one for each variable V i given its parents par(V i ) ⊆ V.
The parent relation is given by an acyclic directed graph (cf. Figure 4), where the random variables are the nodes and an edge V i → V j indicates that V i is a parent of V j . The conditional probability distributions are typically specified as conditional probability tables (CPTs), which form the key probabilistic concept of BNs. For instance, the CPT on the left of Figure 4 specifies that the random variable sprinkler takes value true with probability 0.1 (and false with 0.9) if its parent cloudy is true, and with probability 0.5 if cloudy is false. Formally, a CPT contains a row for each possible assignment x 1 , . . . , x n to the parent variables X 1 , . . . , X n specifying the distribution P (X|x 1 , . . . , x n ). As has been shown earlier, e.g., by Poole [1993] and Vennekens et al. [2004], any Bayesian network can be modeled in languages based on the distribution semantics by representing every row in a CPT as an annotated disjunction p 1 :: X(w 1 ); · · · ; p k :: X(w k ) :− X 1 (v 1 ), · · · , X n (v n ) where X(v) is true when v is the value of X. The body of this AD is true if the parent nodes have the values specified in the corresponding row of the CPT, in which case the AD chooses a value for the child from the corresponding distribution. As an example, consider the sprinkler network shown in Figure 4. The CPT for the root node cloudy corresponds to an AD with empty body 0.5 :: cloudy(t); 0.5 :: cloudy(f).
whereas the CPTs for sprinkler and rain require the state of their parent node cloudy to be present in the body of the ADs 0.1 :: sprinkler(t); 0.9 :: sprinkler(f) :− cloudy(t). The translation for the CPT of grass wet is analogous.  [Russell and Norvig, 2003].

Relational Dependencies
Statistical relational learning formalisms such as BLPs, PLPs, LBNs and CLP(BN ) essentially replace the specific random variables in the CPTs of Bayesian networks by logically defined random variable templates, commonly referred to as parameterized random variables or par-RVs for short [Poole, 2003], though the actual syntax amongst these systems differs significantly. We here use annotated disjunctions to illustrate the key idea. For instance, in a propositional setting, the following annotated disjunctions express that a specific student's grade in a specific course probabilistically depends on whether he has read the corresponding textbook or not: More concretely, the annotated disjunctions express that P (grade(S, C) = high) = 0.6 if the student has read the book of the course and P (grade(S, C) = high) = 0.1 otherwise. Thus the predicate grade depends on book/2 and reads/2. The dependency holds for all instantiations of the rule, that is, it acts as a template for all persons, courses, and books. This is what knowledgebased model construction approaches all share: the logic acts as a template to generate dependencies (here CPTs) in the graphical model. This also introduces a complication that is not encountered in propositional Bayesian networks or their translation to annotated disjunctions. To illustrate this, let us assume the predicate book/2 is deterministic and known. Then the propositional case arises when for each course there is exactly one book. The annotated disjunctions then effectively encode the conditional probability table P (Grade|Reads). However, if there are multiple books, say two, for one course, then the above template would specify two CPTs: one for the first book, P (Grade|Reads1), and one for the second, P (Grade|Reads2). In Bayesian networks, these CPTs need to be combined and there are essentially two ways for realizing this.
The first is to use a so-called combining rule, that is, a function that maps these CPTs into a single CPT of the form P (Grade|Reads1, Reads2). The most popular combining rule is noisy-or, for which P (Grade = high|Reads 1 , ..., Reads n ) = 1 − n i=1 (1 − P (Grade = high|Reads i = true)) where n is the number of books for the course. Using annotated disjunctions, this combining rule is obtained automatically, cf. Section 2.2. In the statistical relational learning literature, this approach is followed for instance in RBNs and BLPs, and several other combining rules exist, cf., e.g., [Jaeger, 1997, Natarajan et al., 2005. While combining rules are an important concept in KBMC, using them in their general form under the distribution semantics requires one to change the underlying logic, which is non-trivial. Hommersom and Lucas [2011] introduce an approach that models these interactions by combining the distribution semantics with default logic. Alternatively, one could use meta-calls, cf. Section 4.8.
The second way of dealing with the two distributions uses aggregation. In this way, the random variable upon which one conditions grade is the number of books the person read, rather than the reading of the individual books. This approach is taken for instance in PRMs and CLP(BN ). In the context of the distribution semantics, aggregation can be realized within the logic program using second order predicates, cf. Section 4.7. For instance, the following program makes a distinction between reading more than two, two, one, or none of the books:

Example: CLP(BN )
We now discuss CLP(BN )  in more detail, as it clearly exposes the separation between model construction via logic programming and probabilistic inference on the propositional model in KBMC. CLP(BN ) is embedded in Prolog 21 and uses constraint programming principles to construct a Bayesian network via logical inference. Syntactically, CLP(BN ) extends logic programming with constraint atoms that (a) define random variables together with their CPTs and (b) establish constraints linking these random variables to logical variables used in the logic program. The answer to a query in CLP(BN ) is the marginal distribution of the query variables, conditioned on evidence if available. The first phase of inference in CLP(BN ) uses backward reasoning in the logic program to collect all relevant constraints in a constraint store, the second phase computes the marginals in the Bayesian network defined by these constraints. Conditioning on evidence is straightforward, as it only requires to add the corresponding constraints to the store. 22 Specifically, a CLP(BN ) clause (in canonical form) is either a standard Prolog clause, or has the following structure: Here, body is a possibly empty conjunction of logical atoms, and the part in curly braces is a constraint atom. sk(C 1 , . . . , C t ) is a Skolem term not occurring in any other clause of the program (whose arguments C i are given via the input variables A j and the logical body), and CPT is a term of the form p(Values, Table, Parents), where Values is a list of possible values for sk(C 1 , . . . , C t ), Parents is a list of logical variables specifying the parent nodes, and Table the probability table given as a list of probabilities, where the order of entries corresponds to the valuations obtained by backtracking over the parents' values in the order given in the corresponding definitions. This CPT term can be given either directly or via the use of logical variables and unification.
We first illustrate this for the propositional case, using the following model 23 of the sprinkler Bayesian network as given in Figure  In the clause for the top node cloudy, the body consists of a single constraint atom that constrains the logical variable C to the value of the random variable cloudy. This random variable takes values f or t with probability 0.5 each, and has an empty parent list. Note that within constraint atoms, the = sign does not denote Prolog unification, but an equality constraint between a logical variable and the value of a random variable. The clause for sprinkler calls cloudy(C), thus setting up a constraint between C and the cloudy random variable, and then uses C as the only parent of the random variable sprinkler it defines. The first column of the CPT corresponds to the first parent value, the first row to the first child value, and so on, i.e., in case of cloudy=f, the probability of sprinkler=f is 0.5, whereas for cloudy=t, it is 0.9. The other two random variables are defined analogously, with their clauses again first calling the predicates for the parent variables to include the corresponding constraints. To answer the query sprinkler(S), which asks for the marginal of the random variable sprinkler, CLP(BN ) performs backward reasoning to find all constraints in the proof of the query, and thus the part of the Bayesian network relevant to compute the marginal. This first calls cloudy(C), adding the constraint C=cloudy to the store (and thus the cloudy node to the BN), and then adds the constraint S=sprinkler to the store, and the sprinkler node with parent cloudy to the BN.
When defining relational models, random variables can be parameterized by logical variables as in the following clause from the school example included in the implementation: registration_grade(R, Grade) :registration(R, C, S), course_difficulty(C, Dif), student_intelligence(S, Int), grade_table(Int, Dif, Table), { Grade = grade(R) with Table }. grade_table (I, D, p([a,b,c,d] Here, registration/3 is a purely logical predicate linking a registration R to a course C and a student S. The predicates course difficulty and student intelligence define distributions over possible values h(igh), m(edium), and l(ow) for the difficulty Dif of course C and the intelligence Int of student S, respectively. For each grounding r of the variable R in the database of registrations, this clause defines a random variable grade(r) with values a, b, c and d that depends on the difficulty of the corresponding course and the intelligence of the corresponding student. In this case, the CPT itself is not defined within the constraint atom, but provided by a Prolog predicate binding it to a logical variable.
Defining aggregation using second order predicates is straightforward in CLP(BN ), as random variables and constraints are part of the object level vocabulary. For instance, the following clause defines the performance level of a student based on the average of his grades: Here, avg_grade/2 sets up a new random variable whose value is the suitably defined average of the grade list Grades (and which thus has a deterministic CPT) and constrains Avg to that random variable, and level_table provides the list of CPT entries specifying how the level depends on this average. We refer to Santos  for a discussion of the inference challenges aggregates raise. Despite the differences in syntax, probabilistic primitives, and inference between CLP(BN ) and probabilistic extensions of Prolog following the distribution semantics, there are also many commonalities between those. As we discussed above, conditional probability tables can be represented using annotated disjunctions, and it is thus possible to transform CLP(BN ) clauses into Prolog programs using annotated disjunctions. On the other hand, Santos Costa and Paes [2009] discuss the relation between PRISM and CLP(BN ) based on a number of PRISM programs that they map into CLP(BN ) programs.

Probabilistic Programming Concepts and Inference
We round off this survey by summarizing the relations between the dimensions of SUCC inference as discussed in Section 3 and the probabilistic programming concepts identified in Section 4. On the probabilistic side, we focus on exact inference versus sampling, as conclusions for exact inference carry over to approximate inference with bounds in most cases. On the logical side, we focus on forward versus backward reasoning, as conclusions for backward reasoning carry over to the approach using weighted model counting. We provide an overview in Table 2, where we omit the concepts unknown objects, as those are typically simulated via flexible probabilities and/or continuous distributions, and constraints, as those have not yet been considered during inference. For generalized labels, we focus on aProbLog, as it is closer to the distribution semantics than Dyna, due to its semantics based on worlds rather than derivations. We do not include MCMC here, as existing MCMC approaches in the context of the distribution semantics are limited to the basic case of definite clause programs without additional concepts.

Dimensions of inference:
The main difference between exact inference and sampling is that the former has to consider all possible worlds or all proofs of the query, whereas the latter always considers one possible world or proof in isolation. As second order predicates and time and dynamics can increase the number of proofs exponentially (in the length of the answer list or the number of time steps), they are more easily handled by sampling based approaches, though   tabling can significantly improve performance of exact inference in dynamic domains. Sampling based approaches do not directly apply for generalized labels, as sampling exploits the probabilistic semantics of fact labels. The main difference between forward and backward reasoning is that the former generates all consequences of the probabilistic logic program, whereas the latter is query-driven and only considers relevant consequences, which can drastically improve efficiency. This difference is well-known in logic programming, and becomes even more important in the probabilistic setting, where we are interested in not just a single world or proof, but in all possible worlds or all proofs. The fact that backward reasoning is query-driven makes it well-suited for flexible probabilities and meta-calls, which cannot directly be handled in forward reasoning. The reason is that the corresponding subgoals have an infinite number of groundings, among which backward reasoning easily picks the relevant ones, which forward reasoning cannot do. The same effect makes it necessary to use stochastic memoization in forward reasoning, while backward reasoning can support dememoization (as in PRISM) as well as memoization (as in the various ICL, ProbLog and LPAD systems).
The roots of the distribution semantics in logic programming become apparent when considering inference for the two remaining key concepts, negation as failure and continuous distributions as provided by distributional clauses. While the logic concept of negation as failure is naturally supported in all combinations of exact inference or sampling and forward or backward reasoning, the probabilistic concept of continuous distributions is much more challenging, and only practical in sampling-based approaches.
Inference approaches: More specifically, exact inference using forward reasoning in the form discussed in Section 3.1 can be used for all programs with finitely many finite worlds, which (a) excludes the use of non-ground facts without explicitly given domains, flexible probabilities, meta-calls and continuous probabilities, and (b) requires stochastic memoization. As this approach additionally suffers from having to enumerate all possible worlds, it is not used in practice. 25 Exact inference using backward reasoning is the most widely supported inference technique in probabilistic logic programming, provided by AILog2, PRISM, ProbLog1, cplint, PITA and MetaProbLog. PRISM never uses stochastic memoization, whereas the other systems always use it. Only very limited forms of continuous distributions can be supported, cf. the work on Hybrid ProbLog [Gutmann et al., 2010]. All other concepts can be supported, but implementations differ in the ones they cover. Negation as failure is supported in all implementations. In addition, AILog2 and cplint support flexible probabilities, MetaProbLog supports flexible probabilities and meta-calls, and ProbLog1 supports flexible probabilities, limited use of continuous distributions (Hybrid ProbLog) and generalized labels (aProbLog). Approximate inference with bounds using backward reasoning is available in ProbLog1 and cplint, but restricted to definite clause programs, as the use of negation as failure complicates proof finding (as discussed in Section 4.6). As the WMC approach as implemented in ProbLog2 uses backward inference to determine the relevant grounding, that is, the groundings of clauses that appear in some proof of a query, the same observations as for exact backward inference apply in this case as well. ProbLog2 supports flexible probabilities and negation as failure.
Forward sampling in its simplest form as discussed in Section 3.1 can be used with programs whose worlds are all finite, which excludes the use of non-ground facts without explicitly given domains, flexible probabilities, and meta-calls, and requires stochastic memoization. In contrast to exact forward inference, forward sampling does support continuous distributions, as only one value is considered at a time. None of the probabilistic logic programming systems discussed here implement forward sampling.
Backward sampling is the most flexible approach and can in principle deal with all concepts except generalized labels. Backward sampling approaches are provided by ProbLog1 and cplint, which both support flexible probabilities and negation as failure. PRISM has a builtin for sampling the outcome of a query using backward reasoning, but does not use it for probability estimation.

Conclusions
Probabilistic programming is a rapidly developing field of research as witnessed by the many probabilistic programming languages and primitives that have been introduced over the past few years. In this paper, we have attempted to provide a gentle introduction to this field by focussing on probabilistic logic programming languages and identifying the underlying probabilistic concepts that these languages support. The same concept (e.g., probabilistic choice) can be realized using different syntactic primitives (e.g., switches, annotated disjunctions, etc.) leading to differences in the probabilistic programming languages. Probabilistic programming implementations not only differ in the primitives they provide but also in the way they perform probabilistic inference. Inference is a central concern in these languages, as probabilistic inference is computationally expensive. We have therefore also presented various probabilistic inference mechanisms and discussed their suitability for supporting the probabilistic programming concepts. This in turn allowed us to position different languages and implementations, leading to a broad survey of the state-of-the-art in probabilistic logic programming. quantified expression of the form h :− b 1 , ..., b n where h is an atom and the b i are literals. If n = 0, a clause is called fact and simply written as h. A definite clause program or logic program for short is a finite set of definite clauses. A normal logic program is a finite set of normal clauses. A substitution θ is an expression of the form {V 1 /t 1 , ..., V m /t m } where the V i are different variables and the t i are terms. Applying a substitution θ to an expression e (term or clause) yields the instantiated expression eθ where all variables V i in e have been simultaneously replaced by their corresponding terms t i in θ. If an expression does not contain variables it is ground. Two expressions e 1 and e 2 can be unified if and only if there are substitutions θ 1 and θ 2 such that e 1 θ 1 = e 2 θ 2 . In Prolog, unification is written using = as an infix predicate.
The Herbrand base of a logic program is the set of ground atoms that can be constructed using the predicates, functors and constants occurring in the program 26 . Subsets of the Herbrand base are called Herbrand interpretations. A Herbrand interpretation is a model of a clause h : − b 1 , . . . , b n . if for every substitution θ such that all b i θ are in the interpretation, hθ is in the interpretation as well. It is a model of a logic program if it is a model of all clauses in the program. The model-theoretic semantics of a definite clause program is given by its smallest Herbrand model with respect to set inclusion, the so-called least Herbrand model (which is unique). We say that a logic program P entails an atom a, denoted P |= a, if and only if a is true in the least Herbrand model of P .
The main inference task of a logic programming system is to determine whether a given atom, also called query (or goal ), is true in the least Herbrand model of a logic program. If the answer is yes (or no), we also say that the query succeeds (or fails). If such a query is not ground, inference asks for the existence of an answer substitution, that is, a substitution that grounds the query into an atom that is part of the least Herbrand model.
Normal logic programs use the notion of negation as failure, that is, for a ground atom a, not(a) is true exactly if a cannot be proven in the program. They are not guaranteed to have a unique minimal Herbrand model. Various ways to define the canonical model of such programs have been studied; see, e.g., [Lloyd, 1989, Chapter 3] for an overview.

B Annotated Disjunctions and Probabilistic Facts
As mentioned in Section 2.2, each annotated disjunction can be equivalently represented using a set of probabilistic facts and deterministic clauses. Using probabilistic facts is not sufficient, as those correspond to independent random variables. For instance, using probabilistic facts 1 3 :: color(green).  the probability of color(green), color(red) and color(blue) all being true is 1/27, whereas it is 0 for the annotated disjunction 1 3 :: color(green); 1 3 :: color(red); 1 3 :: color(blue). On the other hand, we can exploit the fact that negation of probabilistic facts is easily handled under the distribution seman-26 If the program does not contain constants, one arbitrary constant is added. tics 27 to encode an AD by simulating a sequential choice mechanism 28 . With this encoding, the three possible outcomes are mutually exclusive as in the AD and exactly one will be true in any possible world: 1 3 :: sw 1(color(green)). 1 2 :: sw 1(color(red)).
Note that the probabilities have been adapted to reproduce the probabilities of the different head atoms; we discuss the details of this adaptation below. 29 This mapping follows the general idea of representing a probabilistic model in an augmented space where random variables can be assumed independent, while capturing the dependencies in the deterministic part of the program [Poole, 2010]. For non-ground ADs, all logical variables have to be included in the probabilistic facts to ensure that all groundings correspond to independent random events. For instance, the AD ( 1 2 :: color(green); 1 2 :: color(red)) :− ball(Ball) would be represented as 1 2 :: sw 1(color(green), Ball).
As this example suggests, annotated disjunctions can be expressed using probabilistic facts by representing each annotated disjunction using the set of probabilistic factsp i :: sw id(h i , v 1 , . . . , v f ) and the following clauses h i :− b 1 , · · · , b m ,not(sw id(h 1 , v 1 , . . . , v f )), ..., not(sw id(h i−1 , v 1 , . . . , v f )), where id is a unique identifier for a particular AD and v 1 , . . . , v f are the free variables in the body of the AD. The probabilityp 1 is defined as p 1 and for i > 1 it isp One can recover the original probabilities fromp by setting p 1 :=p 1 and iteratively applying the following transformation for i = 2, 3, . . . , n Equation (9) and (10) together define a bijection between p andp which allows one to use parameter learning in either representation and map learned probabilities onto the other representation. If the p i sum to 1, it is possible to drop the last probabilistic fact sw id(h n ) since its probabilityp n is 1.