2.1 Probabilistic logic programming

ProbLog. ProbLog (De Raedt et al. Reference De Raedt, Kimmig and Toivonen2007) is a probabilistic language extending Prolog, where facts and clauses are annotated with (mutually independent) probabilities. Probabilistic logic programs based on distribution semantics, such as ProbLog, can be viewed as a “programming language” generalization of Bayesian networks (Sato Reference Sato1995). A normal logic program $\mathcal{L}$ is a finite set of normal rules of the form $ h \leftarrow b_1,\dots,b_{n}$ . We use the standard terminology about atoms, terms, predicates, and literals. The head h is an atom and the body $b_1,\dots,b_n$ is a logical conjunction of literals. Rules with empty body are called facts. We denote with ${\sim}a$ the negation as failure of an atom a, used to make literals, and with $\lnot a$ the classical logical negation of an atom a.

We model uncertainty in logic programs by annotating facts with probabilities: the probabilities of facts are mutually independent and each probabilistic fact, that is, $p::f.$ , corresponds to an atomic choice, that is, a choice between including f in the program (with probability p) or discarding it ( $1-p$ ). A probabilistic normal logic program $\mathcal{L}=F\cup R$ is thus a set F of facts annotated with probabilities plus a set of logic rules R. The set of facts F is disjoint from the heads of the rules R, nonetheless rule heads can be annotated as syntactic sugar: $p::h\leftarrow b_1,\dots,b_n.$ is equivalent to a new fact $p::f.$ plus $h\leftarrow f, b_1,\dots,b_n.$

Example 2 The well-known alarm Bayesian network (Pearl Reference Pearl1989) can be encoded as a ProbLog program. An alarm is triggered by either an earthquake or a burglary: if the neighbor is at home you will receive a call. The neighbor at home, the earthquake, and the burglary are independent events occurring with a certain probability, thus encoded as probabilistic facts. Probabilistic facts are marginally independent and therefore correspond to nodes of the Bayesian network that do not have common parents or ancestors. The logic rules determine whether you get a call or not, and thus correspond to the conditional dependencies of the Bayesian network.

Distribution semantics. A probabilistic logic program $\mathcal{L} =F\cup R$ is queried for the likelihood of atoms. The probability of an atom is commonly defined by the distribution semantics (Sato Reference Sato1995). A total choice $\omega$ is a combination of atomic choices over all probabilistic facts, that is, a subset of the set of all ground facts F, that is, $\omega\subseteq F$ . We denote the set of all total choices of $\mathcal{L}$ , that is, the power set of F, with $\Omega_\mathcal{L}$ . The probabilities of the facts define a probability distribution over the $2^{|F|}$ total choices. The possible non-probabilistic subprograms $\omega\cup R, \omega \in\Omega_{\mathcal{L}}$ , which we call possible worlds, are obtained from $\mathcal{L}$ by including or discarding a fact according to the corresponding atomic choice. An interpretation is an assignment of a truth value to all atoms in the Herbrand base of a program. An interpretation is called a model of the theory if it satisfies all formulas in the theory.

The distribution semantics relies on a one-to-one mapping between possible worlds and models: many PLP frameworks, for example, ProbLog, PRISM, and CP-Logic, restrict the class of valid inputs to programs where each total choice corresponds to a two-valued well-founded model (Gelder et al. Reference Gelder, Ross and Schlipf1991). The underlying assumption is that choices are modeled exclusively by means of probabilistic facts, and that they are independent. Under this assumption many algorithms and reasoning techniques have been developed to perform inference and parameter learning tasks, which we present in the rest of this section.

Inference. The MARG inference task is the task of computing the probability of success of a query, that is, the sum of the probability of each possible world where the query is true, under the (possibly empty) given evidence. Evidence is a set of atoms whose truth value is known. In particular:

Definition 1 (The MARG Inference task) Given

• − A program $\mathcal{L}$ : let G be the set of all ground (probabilistic and derived) atoms of $\mathcal{L}$ .

• − A set $E\subseteq G$ of observed atoms (evidence), along with a vector e of corresponding observed truth values ( $E = e$ ).

• − A set $Q\subseteq G$ of atoms of interest (queries).

Find the marginal distribution of every query atom given the evidence, that is, computing $P(q\,|\,E = e)$ for each $q \in Q$ .

In the ProbLog2 system the probabilistic inference task is reduced to a weighted model counting problem ( $\mathit{WMC}$ ) (Cadoli and Donini Reference Cadoli and Donini1997). WMC is the problem of computing the weight of a propositional logic formula $\varphi$ , given a weight function w that assigns a positive (real) weight value to each literal v and $\lnot v$ ( $v\in G$ ). Let $\mathit{MOD}(\mathcal{L})$ be the set of valid interpretations for $\mathcal{L}$ , the $\mathit{WMC}$ of $\varphi$ is:

\[\mathit{WMC}_{\mathcal{L}}(\varphi)= \sum_{M\in \mathit{MOD}(\mathcal{L}),M\models \varphi}\prod_{l\in M}w(l).\]

The probability $P(q|E=e)$ is computed as $\mathit{WMC}_{\mathcal{L}}(\varphi)$ where $\varphi$ is the propositional representation of $q\land E=e$ . The weight function is defined as follows: for all probabilistic facts $(p:f)$ , $w(f)=p$ and $w(\lnot f)=1-p$ ; for all atoms $a\in E$ if a is true (false) $w(a)=1$ , $w(\lnot a) = 0$ (resp. $w(a)=0$ , $w(\lnot a) = 1$ ); for all remaining (logical) atoms a, $w(a)=w(\lnot a) =1$ .

Example 4 The possible world of Example 2 corresponding to $\{\mathit{burglary},\mathit{neighbor\_at\_home}\}$ has probability $0.1\cdot(1-0.2)\cdot 0.5= 0.04$ . To find the probability of being called we sum the probabilities of all other possible worlds whose model contains $\mathit{neighbor\_calls}$ , namely $\{\mathit{earthquake},\mathit{neighbor\_at\_home}\}$ and $\{\mathit{burglary},\mathit{earthquake},\mathit{neighbor\_at\_home}\}$ , which are respectively $(1-0.1)\cdot 0.2\cdot 0.5= 0.09$ and $0.1\cdot 0.2\cdot 0.5= 0.01$ . Therefore, $P(\mathit{neighbor\_calls})=\mathit{WMC}(\mathit{neighbor\_calls})=0.04+0.09+0.01=0.14$ .

The task of model counting is #P-complete in general, therefore the logic program is transformed into a representation where this task becomes tractable (Fierens et al. Reference Fierens, den Broeck, Thon, Gutmann and De Raedt2011). $\mathcal{L}$ is in fact transformed by means of knowledge compilation into a smooth d-DNNF formula (deterministic decomposable negation normal form) (Darwiche Reference Darwiche2004) or a sentential decision diagram (Choi et al. Reference Choi, Kisa and Darwiche2013). In this paper we focus on d-DNNFs because we base our approach on a knowledge compiler to d-DNNFs for stable model counting (Aziz et al. Reference Aziz, Chu, Muise and Stuckey2015).

On d-DNNFs the task of model counting becomes tractable. The d-DNNF is further transformed into an equivalent arithmetic circuit, by replacing conjunctions and disjunctions respectively with multiplication and summation nodes, and by replacing leaves with the weight of the corresponding literals. Arithmetic circuits allow us to efficiently perform the task of $\mathit{WMC}$ .

Fig. 1. Smooth d-DNNF for the implication $\mathit{neighbor\_calls} \leftarrow \mathit{alarm}, \mathit{neighbor\_at\_home}$ (left) and the corresponding arithmetic circuit (right).

Learning. Learning from interpretations of parameters in a ProbLog program is implemented in a likelihood maximization setting (Gutmann et al. Reference Gutmann, Thon and De Raedt2011). In the learning from interpretations task the input is a program $\mathcal{L}$ where some probabilities are unknown (parameters), and a set of interpretations for $\mathcal{L}$ . Interpretations can be partial, that is, the observation of truth values contains only a subset of all atoms. The goal is to estimate the value of the parameters such that the predicted values maximize the likelihood of the given interpretations:

Definition 3 (Max-Likelihood Parameter Estimation) Given

• − A program $\mathcal{L}\mathbf{(p)} = F {\cup} R$ where F is a set of probabilistic facts and R contains the rules describing the background knowledge. $\mathbf{p} = \langle p_1, ..., p_N\rangle$ is a set of unknown parameters attached to probabilistic facts.

• − A set $\mathbb{I}$ of (partial) interpretations $\{I_1, ..., I_M\}$ as training examples.

Find the maximum likelihood probabilities $\widehat{\mathbf{p}} = \langle \widehat{p_1}, ..., \widehat{p_N}\rangle$ for the interpretations in $\mathbb{I}$ . Formally,

\[ \widehat{\mathbf{p}} = \arg \max_\mathbf{p} P(\mathbb{I}|\mathcal{L}\mathbf{(p)}) = \arg\max_\mathbf{p} \prod^M_{m=1} P(I_m|\mathcal{L}\mathbf{(p)}). \]

Parameters are iteratively updated by an alternation of an expectation step (E step) which computes the expected value of the learnable parameters under the current model, and the maximization step (M step) which updates the parameters estimates to maximize the likelihood of the observed data.

Example 6 Consider Example 5 but now the probability of $\mathit{alarm}$ is a learnable parameter. In ProbLog the expression $\mathit{t(0.4)::alarm.}$ denotes a learnable probability which is initialized at $0.4$ in the expectation-maximization (EM) algorithm:

Given a set of interpretations reflecting the original probability distribution we can learn the probability of $\mathit{0.28::alarm.}$ even if the observation of alarm is not given. In fact, we provide three types of partial interpretations:

$I_1$ : $\{\lnot calls,\lnot at\_home\}$ (50 examples)

$I_2$ : $\{\mathit{calls}, \mathit{at\_home}\}$ (14 examples)

$I_3$ : $\{\mathit{\lnot call}, at\_home\}$ (36 examples)

The first corresponds to the possible worlds where $\mathit{at\_home}$ prevents the call regardless of $\mathit{alarm}$ (50% of the examples corresponding to the probability of $\mathit{at\_home}=\mathit{false}$ ). The second is the case where both are true and the third where $\mathit{alarm}$ is false. The first iteration of the EM algorithm considers the frequency of each example and the probability according to the model with the probability of $\mathit{alarm}$ initialized at $0.4$ . The iteration 0 then associates to $I_1$ the current probability of $\mathit{alarm}$ being either true or false, that is, $0.4$ . On the other hand, in $I_2$ (resp. $I_3$ ) $\mathit{alarm}$ has probability 1 (resp. 0) of being true (E step). The updated probability that maximizes the probability of the set of training examples is thus $\frac{50\cdot 0.4 + 14\cdot 1 + 36\cdot 0}{100}=0.34$ (M step). Iteration 1 then repeats the E step with the updated probability $0.34::\mathit{alarm}$ . The probabilities of $\mathit{alarm}$ in $I_1,I_2$ , and $I_3$ are, respectively, $0.34,1.0,$ and 0 (E step) and the new updated probability is $\frac{50\cdot 0.34 + 14\cdot 1 + 36\cdot 0}{100}=0.31$ (M step). Further iterations converge to the true probability of $0.28::\mathit{alarm}$ .

Causal effects.An alternative view of ProbLog that we exploit in this paper is in terms of CP-logic, a logical language for representing probabilistic causal laws. Probabilistic causal laws model the probability distribution of a set of random variables that are related by a causal process, that is, the variables interact through a sequence of non-deterministic or probabilistic events. ProbLog and CP-logic are closely related as the syntax of a ProbLog program is similar to that of a CP-theory in which each rule has precisely one head atom. Moreover, the semantics of a ground ProbLog program coincides completely with the semantics of CP-Logic. This close relation makes available in ProbLog a modeling technique from CP-logic that we exploit in this paper: the inhibition effect (Meert and Vennekens Reference Meert and Vennekens2014) and negations in the head (Vennekens Reference Vennekens2013).

Negation in the head gives an interpretation of the negation of heads from ASP in the context of epistemic reasoning and logic theories defining causal mechanisms. In the rest of the paper we adopt this interpretation for negated heads, where the goal is to describe epistemic causal effects and not to obtain classical negation from negation as failure. Vennekens (Reference Vennekens2013) discusses in detail the differences with classic negation in ASP. In the context of PLP, each rule $\lnot h\leftarrow b_1,\dots,b_n.$ is interpreted by replacing all heads h in the program with a new atom $h_{pos}$ and all heads $\lnot h$ with a new atom $h_{neg}$ , and the rule $h\leftarrow h_{pos},{\sim}h_{neg}.$ is added. This last rule thus defines that h can be inferred from any of the causes of h (making $h_{pos}$ true) only if there is no cause for believing in $h_{neg}$ , the opposite of h. The inhibition effect is the resulting decrease in the probability of h when the probability of $\lnot h$ ( $h_{neg}$ ) increases.

The noisy-or effect (Meert and Vennekens Reference Meert and Vennekens2014) describes the aggregation of the causal probabilities for an atom which appears as the head of multiple (causal) rules.

Example 7 We adapt the travel example from Meert and Vennekens (Reference Meert and Vennekens2014) to describe the inhibition effect in ProbLog. Alice is traveling during a pandemic and therefore there is a chance of getting infected. This probability is influenced by two factors: first, if Alice travels with public means of transport there is some probability of being infected there. Second, if Alice is vaccinated then there is a chance that she will not be infected. We encode this last rule with the inhibition effect, which describes a decrease in the probability of infection when vaccinated.

The two rules correspond to the following rewriting:

Stable models. In this paper we will extend ProbLog’s semantics, based on two-valued unique well-founded models, with stable model semantics (Gelfond and Lifschitz Reference Gelfond and Lifschitz1988), where models are two-valued, but a logic program can have more than one stable model. Given a normal logic program $\mathcal{L}$ and a set S of atoms interpreted as true, called candidate model, stable model semantics is defined in terms of the reduct of a program $\mathcal{L}$ w.r.t. S. The reduct of $\mathcal{L}$ w.r.t. S, $\mathcal{L}^S$ , is defined as follows: (1) for all $r\in \mathcal{L}$ remove r from $\mathcal{L}$ if $a\in S$ is negated in the body of r; (2) for all $r\in \mathcal{L}$ remove from the body of r all $\lnot a$ if $a\notin S$ . If S is a minimal model for $\mathcal{L}^S$ then S is a stable model (answer set) for $\mathcal{L}$ .

2.2 Probabilistic argumentation

We will consider the application of PLP and smProbLog to probabilistic argumentation problems (Hunter et al. Reference Hunter, Polberg, Potyka, Rienstra and Thimm2021). An abstract argumentation framework (or argument graph) (Dung Reference Dung1995) is a pair (A,R) where A is a set of arguments and $R\subseteq A\times A$ is a binary (attack) relation over A. Figure 2 represents an example from Hunter et al. (Reference Hunter, Polberg and Thimm2020) of argument graph (A,R) where $A=\{a_1,a_2,a_3,a_4\}$ and $R=\{(a_1,a_2),(a_2,a_1),(a_3,a_1),(a_4,a_2)\}$ .

Fig. 2. Abstract argumentation framework. Edges represent attacks, nodes are arguments.

In recent years several extensions and modifications of this formulation have been proposed in order to encode more complex argumentation reasoning systems. Among the most relevant, we find bipolar argument frameworks (Amgoud et al. Reference Amgoud, Cayrol, Lagasquie-Schiex, Delgrande and Schaub2004), weighted argumentation frameworks (Amgoud et al. Reference Amgoud, Ben-Naim, Doder and Vesic2017), and probabilistic argumentation frameworks (Li et al. Reference Li, Oren and Norman2011).

Bipolar argumentation frameworks introduce a support relation $R^+$ along with the attack relation $R^-$ . A bipolar argument graph is thus a triple $(A,R^-,R^+)$ , where A is a set of arguments and $R^-\subseteq A\times A$ (resp. $R^+\subseteq A\times A$ ) is a binary attack (support) relation over A.

Weighted argumentation frameworks (A,R,w) augment the traditional argument graph (A,R) with a weighting function $w: A\rightarrow[0,1]$ and belong to a general class of gradual argumentation frameworks (Cayrol and Lagasquie-Schiex Reference Cayrol and Lagasquie-Schiex2005), where arguments’ acceptability is evaluated on a fine-grained numerical scale or ranking.

Gradual and bipolar frameworks are combined into quantitative bipolar argumentation frameworks (QBAFs) (Baroni et al. Reference Baroni, Rago and Toni2019), where each argument has a (possibly empty) set of attackers, a (possibly empty) set of supporters, and an initial evaluation (possibly the same for all arguments) on a chosen scale. These elements contribute to a final argument evaluation, provided by a strength function on the chosen scale. A QBAF is thus a quadruple $(A,R^-,R^+,\tau)$ consisting of a finite set A of arguments, a binary (attack) relation $R^-$ on A, a binary (support) relation $R^+$ on A, and a total function $\tau: A \rightarrow I$ , where I is the chosen scale. $\tau(a)$ is thus the base score of a, for any $a \in A$ .

Finally, a probabilistic argument graph (Li et al. Reference Li, Oren and Norman2011) is a tuple $(A,R,P_A,P_{R})$ where: (A,R) is an argument graph and $P_A$ and $P_{R}$ are functions: $P_A:A\rightarrow[0,1]$ and $P_{R}:A\times A\rightarrow[0,1]$ . Figure 3 describes a probabilistic argument graph derived from the example in Figure 2. The values assigned by the functions $P_A$ and $P_R$ are usually interpreted with two different approaches: the constellations approach and the epistemic approach (Hunter Reference Hunter2013). The constellations approach interprets the probabilities as uncertainty over the structure of the graph and models a probability distribution over subgraphs. Each subgraph is evaluated according to the traditional extension-based semantics (Dung Reference Dung1995). An extension is a subset of the arguments that is acceptable w.r.t. a given criterion, therefore a distribution over acceptable arguments is derived from (1) the probability distribution over the possible subgraphs, and (2) the subset of acceptable arguments in each subgraph. The epistemic approach on the other hand interprets the probabilities as a direct measure of an agent’s belief in the arguments. The accepted arguments are those having probability higher than 0.5, and the argument graph is used to reason about the consistency of the agent’s beliefs with respect to the relations encoded in the graph.

Fig. 3. Probabilistic abstract argumentation framework. Edges represent attacks, nodes are arguments (cfr. Figure 2).

4.1 Formal semantics

We define the models for each total choice and the corresponding probability in order to extend a probability distribution over total choices to a probability distribution over models. Each total choice $\omega$ corresponds to: (1) a probability $P(\omega)$ as defined by distribution semantics and (2) a set $SM(\omega)$ of stable models, over which the probability gets distributed if it is non-empty. For this distribution to be well-defined, we only consider programs with finite Herbrand base, and thus a finite number of interpretations.

Definition 7 Given a valid smProbLog program $\mathcal{L}$ , the probability $ P(\omega)$ of a total choice $\omega$ is:

\[P(\omega)=\prod_{(f:p)\in\mathcal{L}, f\in\omega} p\cdot\prod_{(f:p)\in\mathcal{L}, f\not\in\omega} 1-p.\]

that is, the product of the probabilities of the facts for being included/excluded from $\omega$ .

We distinguish two cases: $SM(\omega)=\emptyset$ and $|SM(\omega)|>0$ , and we define accordingly a set of models for a possible world.

A model is a three-valued interpretation (T,F) where T is the set of true atoms and F is the set of false atoms. The remaining atoms are interpreted as being part of an inconsistent possible world.

Definition 9 Given a probabilistic logic program $\mathcal{L}$ and let $HB(\mathcal{L})$ be its Herbrand base. For each total choice $\omega\in \Omega_\mathcal{L}$ , the corresponding set of models $\mathit{MOD}(\mathcal{L},\omega)$ is:

\begin{equation*} \mathit{MOD}(\mathcal{L},\omega) = \begin{cases} \{(\emptyset, \emptyset)\} & \text{if $|SM(\omega)| = 0$.} \\ \{(M_{\omega}, HB(\mathcal{L})\backslash M_{\omega})\;|\; M_{\omega}\in SM(\omega)\} & \text{if $|SM(\omega)| > 0$.} \\ \end{cases} \end{equation*}

Each total choice thus has at least one model: either the “inconsistent” model or one or more stable models. We extend the probability of the total choices to a distribution over the corresponding models by applying the maximum-entropy principle.

The probability of a model $M_{\omega}\in \mathit{MOD}(\mathcal{L},\omega)$ is the probability of the corresponding total choice $\omega$ normalized w.r.t. the number of the models for that possible world:

Definition 10 Given a probabilistic normal logic program $\mathcal{L}$ and a total choice $\omega$ , $\forall M_{\omega}\in \mathit{MOD}(\mathcal{L},\omega)$ :

\[\hat{P}(M_{\omega}) = \frac{P(\omega)}{|\mathit{MOD}(\mathcal{L},\omega)|}.\]

We thus derive a distribution over models $\hat{P}$ from the probability distribution over total choices P. We can now define the probability of the program of being inconsistent and of a query of an atom. The degree of inconsistency of the program $\mathcal{L}$ , $\mathbb{P}(\mathcal{L}\vdash\bot)$ is the sum of the probabilities of interpreting the atoms as inconsistent in each possible world:

\[\mathbb{P}(\mathcal{L}\vdash\bot)=\sum_{\omega\in\Omega_\mathcal{L}, \mathit{MOD}(\mathcal{L},\omega)=\{(\emptyset, \emptyset)\}} \hat{P}((\emptyset, \emptyset)).\]

As for the consistent possible worlds, we can query the program for the probability of an atom being interpreted as true (or false):

Definition 11 Given a probabilistic normal logic program $\mathcal{L}$ , the probability of success of querying a is the probability of interpreting a true in a consistent possible world:

\[\mathbb{P}(a)=\sum_{a\in M_{\omega},(M_{\omega}, HB(\mathcal{L})\backslash M_{\omega})\in \mathit{MOD}(\mathcal{L},\omega),\omega\in\Omega_\mathcal{L}}\hat{P}(M_{\omega}). \]

Note that we can derive the probability of an atom being false from the probability of the inconsistent possible worlds and the probability of success:

\[\mathbb{P}(\lnot a) = 1 - \mathbb{P}(\mathcal{L}\vdash\bot) - \mathbb{P}(a), \]

because the probability mass of the non-inconsistent models is divided over the two-valued stable models, therefore if an atom is in a consistent possible world, then it is interpreted either true or false.

5.1 Epistemic properties

The joint probability distribution describes the subjective assignment of beliefs to arguments coherent with all possible belief choices of prior bias and relations, regardless of arbitrary thresholds. This means that the joint beliefs are globally coherent with the argumentative structure and therefore the marginal beliefs are also locally coherent with the parents and children’s beliefs. The properties for epistemic probabilistic argumentation by Polberg et al. (Reference Polberg, Hunter and Thimm2017) can thus be used to evaluate the bias of the agent, which is indeed an arbitrary assignment of values, but in evaluating the joint probability distribution, having probability higher than 0.5 has no special meaning. We clarify this by considering some of these properties and show that the marginal belief of the arguments defined by the joint distribution is compatible with the given argumentative structure even if they may not satisfy such properties.

Coherency. Polberg et al. (Reference Polberg, Hunter and Thimm2017) define coherency in epistemic probabilistic argumentation as the property that for all attacks (a,b) believed with probability $>0.5$ , $P_A(a)\leq 1-P_A(b)$ . In the joint probability distribution the marginal probability of arguments $\mathbb{P}(arg(\_))$ is coherent not just locally, considering pairwise marginals, but globally, where the structure of all relations and biases is taken into account.

Rational. A rational (resp. strict) assignment resembles the conflict-free principle that if an attacker a is accepted than the target b should not: $P_R((a,b))>0.5$ and $P_A(a) > 0.5$ implies $P_A(b)\leq 0.5$ (resp. $P_A(b)<0.5$ ). In our framework, when choosing a set of prior beliefs (probabilistic facts) the conflict-freeness of the accepted (true) arguments is always guaranteed by the logic rules. This does not exclude the possibility that both a and b in the joint probability distribution are believed with probability $>0.5$ . In fact, when an argument has high bias, for example, we think it is almost certain, only a combination of strong attackers with strong relations can lower its inferred probability under 0.5.

Protective. A (restricted) protective assignment is such that $P_R((a,b))\geq 0.5$ (resp. $P_R((a,b))>0.5$ ) and $P_A(b) > 0.5$ implies $P_A(a)\leq 0.5$ . Similarly to the rational property, in epistemic probabilistic argumentation this is the principle of rejecting the attacker if the target is accepted. Again, this principle in the joint belief distribution is not enforced by means of the probability (belief) values, but by means of the logical structure of the attack relation.

Similar arguments can be constructed for the other properties from Polberg et al. (Reference Polberg, Hunter and Thimm2017): past epistemic argumentation approaches consider the probabilities of the argument graph as the marginal beliefs of the agent and check if those are (locally) rational, coherent, Our approach uses this arbitrary assignment as the prior set of beliefs, and the argumentative structure, to infer a joint belief distribution that is compatible with the initial arbitrary assignment according to the probability postulates and the logical relations of the arguments. The joint belief (probability) distribution thus represents how the prior beliefs (biases) interact with each other to define marginal and conditional beliefs that are coherent with the given priors and argumentative (logic) structure.

6.1 Inference task

The state-of-the-art inference technique for probabilistic logic programs is reducing the inference task to a WMC problem (cfr. Section 2), therefore we consider its applicability in the context of our semantics. In ProbLog2 inference is implemented by means of a transformation of the ground program to conjunctive normal form (CNF), which is the input for a knowledge compiler (under well-founded semantics) that returns the logical circuit (e.g., a d-DNNF) such that on the corresponding arithmetic circuit the WMC task can be solved in polynomial time (Figure 5). In the rest of the section we describe the adaptations required to this inference technique required for smProbLog’s semantics.

Fig. 5. ProbLog2 inference schema.

The normalization of the weight of the models entails considering a variant of the $\mathit{WMC}$ problem where models are weighted with the corresponding normalization constant. We denote such constant with $\hat{w}(M_\omega)$ , where $M_\omega$ is a model for a total choice $\omega$ , hence $\hat{w}(M_\omega)=\frac{1}{|\mathit{MOD}(\mathcal{L},\omega)|}$ . The $\mathit{WMC}$ problem ( $\mathit{WMC}_{\mathcal{L}}(\varphi)= \sum_{M\in \mathit{MOD}(\mathcal{L}),M\models \varphi}\prod_{l\in M}w(l)$ ) thus becomes:

\[\widehat{\mathit{WMC}}_{\mathcal{L}}(\varphi)= \sum_{M\in \mathit{MOD}(\mathcal{L}),M\models \varphi}\hat{w}(M)\cdot\prod_{l\in M}w(l).\]

This formulation of the problem requires us to determine the weights $\hat{w}(M_\omega)$ , which, contrary to the weights of the literals, are not known from $\mathcal{L}$ . In order to determine the weighting function $\hat{w}$ we thus need to solve an additional counting problem, namely the task of counting how many models agree on a subset of atoms in $\mathcal{L}$ , that is, the probabilistic facts. We now describe the reduction pipeline in smProbLog to a $\mathit{\widehat{WMC}}$ problem. The reduction can be broadly divided into four components, represented in Figure 6: (1) grounding the program $\mathcal{L}$ , (2) compiling the logic theory $\mathcal{L}$ into a d-DNNF, (3) deriving a circuit for retrieving the number of models corresponding to a total choice and an arithmetic circuit for the $\mathit{WMC}_{\mathcal{L}}$ problem, and (4) the evaluation of the two circuits to define the solution of the $\mathit{\widehat{WMC}_{\mathcal{L}}}$ problem (Algorithm 2).

Fig. 6. smProbLog inference schema. (*) denotes a different version of dsharp from ProbLog2, specific for stable model counting.

(1) Grounding. In smProbLog we adopt a standard bottom-up grounding technique. In ProbLog2, the detection of cycles through negations during the grounding step is used as a sufficient condition to reject invalid programs. On the contrary, we use the absence of cycles through negations as a condition to reduce to ProbLog’s evaluation algorithm, where smProbLog’s semantics is equivalent, as discussed in Section 8.1. In fact, when this is the case, we skip the enumeration step (Step 3) because $\hat{w}(M)=1$ for all stable (and well-founded) models M. Therefore, the $\widehat{\mathit{WMC}}_{\mathcal{L}}$ problem becomes equivalent to a $\mathit{WMC}_{\mathcal{L}}$ problem.

(2) Compilation. The goal of the compilation step is to transform the ground propositional theory in a representation that allows us to answer efficiently queries about the probability of atoms. Knowledge compilation produces a logical circuit describing the possible worlds’ models of the input propositional theory. Therefore, this step regards exclusively the logical part of the program, while the following inference steps concern the computation of probabilities. As in Problog2, the knowledge compiler is a black box with respect to the probabilistic inference system. Therefore, in smProbLog we are only concerned with transforming the propositional ground theory to the suitable input format. The input format and the implementation details of the knowledge compiler in smProbLog can be found in Aziz et al. (Reference Aziz, Chu, Muise and Stuckey2015), which extends the dsharp compiler (Muise et al. Reference Muise, McIlraith, Beck and Hsu2012) with stable model semantics. In ProbLog2 the input format is a theory in CNF, Aziz et al. (Reference Aziz, Chu, Muise and Stuckey2015) replace it with an encoding in CNF format of the rules, variables, and the corresponding strongly connected components. The output is a logical circuit, a d-DNNF, describing the stable models of the input propositional theory. The circuit therefore expresses only the models corresponding to the consistent total choices. This representation, with a standard transformation in an arithmetic circuit, allows efficient stable model counting, that is, solving the $\mathit{WMC}$ problem. Figure 7 shows the output of the knowledge compilers from the representations of Example 20 and 22. Contrary to ProbLog2, however, the transformation of the logical circuit into an arithmetic circuit is not sufficient to solve the $\widehat{\mathit{WMC}}$ problem. This because the arithmetic circuit allows us to efficiently compute the solution to a $\mathit{WMC}$ problem, but the normalization constants $\hat{w}$ are still unknown. Unless the weighting is determined by the absence of cycles through negations, as defined in the previous paragraph, the enumeration step is required to associate each model to the corresponding normalization constant.

Fig. 7. Compilation step of Example 20 (top right) and Example 22 (left). Models for both theories are compactly encoded as d-DNNF logical circuits. $bg={\mathit{burglary}}$ , $eq={\mathit{earthquake}}$ , $al={\mathit{alarm}}$ , $df={\mathit{defective}}$ , $rt={\mathit{right}}$ .

(3) Enumeration.The purpose of the enumeration step is to count the number of stable models corresponding to each (consistent) total choice, which defines $\hat{w}$ . Unfortunately, this operation cannot be performed efficiently on the representation obtained from the knowledge compiler, because models corresponding to the same total choice may be represented by different nodes and subtrees. Therefore, on this kind of representation we are forced to traverse the circuit in order to retrieve the list of models and the corresponding total choices.

We thus derive from the d-DNNF a circuit where each leaf for a literal l is replaced by a set of (partial) models $\{\{l\}\}$ , disjunctions are replaced by the union of the children and conjunctions correspond to the Cartesian product of the children (Figure 8). Traversing bottom-up such circuit returns the list of models, from which we build a map $\#:\Omega_\mathcal{L}\rightarrow\mathbb{N}$ from total choices to the corresponding number of models, that is, $\#(\omega)=|\mathit{MOD}(\mathcal{L},\omega)|$ . The reciprocal thus defines the normalization constants $\hat{w}$ . For instance, in Example 22 we obtain $\#(\omega_1)=\#(\omega_2)=\#(\omega_3)=1$ , $\#(\omega_4)=2$ , hence $\hat{w}(\{{\mathit{burglary}},{\mathit{alarm}},{\mathit{earthquake}},{\mathit{right}}\})=\hat{w}(\{{\mathit{burglary}},{\mathit{alarm}}\})=\hat{w}(\{{\mathit{earthquake}},\mathit{{\mathit{defective}}}\})=1$ , and $\hat{w}(\{{\mathit{alarm}}\})=\hat{w}(\{\mathit{{\mathit{defective}}}\})=\frac{1}{2}$ . Note that the total choices that do not appear in the enumeration of models are those that have zero models and thus are inconsistent. Because probabilistic facts are disjoint from the rules’ heads, for each model described by the circuit the truth value of the literals corresponding to probabilistic facts defines the corresponding total choice (they can be true iff chosen by $\omega$ ).

Fig. 8. Enumeration step of Example 20 (top right) and Example 22 models (left). Each node contains the corresponding (partial) models. Diamonds are union nodes, squares are Cartesian products. M is the complete list of the 5 models of Example 22.

The circuit traversal is a computationally expensive step since it entails enumerating all possible models. Contrary to sums (logical ORs) and products (logical ANDs), the Cartesian product is not a linear-time operation. Therefore, the computational cost of the internal nodes raises with the length of the lists of partial models corresponding to the children. For this reason, the study of novel knowledge compilation techniques that produce a representation where the normalization constants can be obtained from linear time operations is an interesting direction for improvement.

This is a novel problem because smProbLog semantics applies a different normalization constant per total choice ( $2^n$ with n facts), while in probabilistic ASP the normalization constant is the same for all models, that is, the weight of all possible worlds. This can be obtained with a single evaluation of the weight of the root of the circuit. Therefore, obtaining the normalization constants from a circuit where node-level operations are computable in linear time would remove this bottleneck, which is introduced because we consider a fundamentally different inference task.

(4) Evaluation. As we previously mentioned, to evaluate $P(q\,|\,E=e)$ , with $\varphi=q\land E=e$ , on a program $\mathcal{L}$ we solve the problem $\widehat{\mathit{WMC}}_{\mathcal{L}}(\varphi)= \sum_{M\in \mathit{MOD}(\mathcal{L}),M\models \varphi}\hat{w}(M)\prod_{l\in M}w(l)$ . The weights of the leaves in the arithmetic circuit are instantiated according to the query and the given evidence (Section 2). Fierens et al. (Reference Fierens, den Broeck, Thon, Gutmann and De Raedt2011) show that the arithmetic circuit derived from the d-DNNF computes $\mathit{WMC}_{\mathcal{L}}(\varphi)= \sum_{M\in \mathit{MOD}(\mathcal{L}),M\models \varphi}\prod_{l\in M}w(l)$ . Under a one-to-one correspondence between models and total choices, given $\omega\in\Omega_\mathcal{L}$ and its model $M_{\omega}$ , $\mathit{WMC}(M_\omega) = \mathit{WMC}(\omega)$ . Therefore, if the enumeration step is skipped, that is, $\hat{w}(M_{\omega})=1$ for all stable (and well-founded) models $M_{\omega}$ , then $\mathit{WMC}(M_\omega) = \mathit{WMC}(\omega) = \widehat{\mathit{WMC}}(M_\omega)$ .

On the contrary, if there are multiple models for some total choices, then $\mathit{WMC}(M_\omega) = \mathit{WMC}(\omega) \neq \widehat{\mathit{WMC}}(M_\omega)$ , because $\mathit{WMC}(M_{\omega})$ overcounts the normalized weights of the models corresponding to the same total choice. Figure 9 shows the weight calculation of the root node of the circuit: the root corresponds to all consistent total choices (e.g., Figure 8). Example 22 shows that the original algorithm overcounts the weight when multiple stable models correspond to the same total choice. This because, their weight is not normalized (cfr. Example 36 for the explanation of the 1.25 weight). This raises the question as to how the evaluation algorithm has to account for the normalization constants for smProbLog semantics.

Fig. 9. $\mathit{WMC}$ of Example 20 (top right) and Example 22 (left). Each node contains the corresponding weight, logical variables do not influence the weights. Diamonds are sum nodes, squares are product nodes.

As Figure 8 shows, multiple models can correspond to the same node, therefore it is not possible to associate a normalization constant to a single node. Moreover, the aggregation of the weights in one value per node, as in Figure 9, is no longer possible, because two partial models (e.g., $\{\{bg\},\{\lnot bg\}\}$ ) may be conjoined (multiplied) with partial models (weights) that require different normalization constants. Once the weights are aggregated it is not possible to normalize the different components of the weight with different constants. We now describe two evaluation strategies to normalize weights in the evaluation step.

The first is essentially a repetition of the enumeration step: we traverse again the circuit bottom-up and along with each set of atoms we carry the corresponding weight: once a total choice is defined, the weights of each partial model are multiplied and normalized w.r.t. the corresponding number of models obtained from the enumeration step. The drawback of this strategy is that the complexity of the enumeration step is repeated at each query.

The second method is to exploit the efficiency of the $\mathit{WMC}$ task on the circuit and compute first the unnormalized weight of the root and then correct it (Algorithm 2). For each total choice $\omega$ s.t. $n=\#(\omega)>1$ and $\omega\models \varphi$ , the unnormalized evaluation of the circuit overcounts the weight of its models, because they are not multiplied by $\hat{w}(M_\omega)=\frac{1}{n}$ . Remember that the unnormalized weight of a model is the probability of the corresponding total choice: $\mathit{WMC}(M_\omega) = \mathit{WMC}(\omega)=P(\omega)$ , therefore the unnormalized weight is such that

\[\mathit{WMC}(M_\omega)= \hat{w}(M_\omega)\cdot \mathit{WMC}(\omega) + (1-\hat{w}(M_{\omega}))\cdot \mathit{WMC}(\omega).\]

Since $\hat{w}(M_\omega)=\frac{1}{n}$ and $\mathit{WMC}(\omega)=P(\omega)$ , each weight the of models $M_\omega\in \mathit{MOD}(\mathcal{L},\omega)$ is overcounted by

\[(1-\hat{w}(M_{\omega}))\cdot\mathit{WMC}(\omega)=\frac{P(\omega)\cdot(n-1)}{n}.\]

Removing such weight from the unnormalized one, gives the probability defined by smProbLog’s semantics:

\[\widehat{\mathit{WMC}}(M_{\omega})=\mathit{WMC}(M_{\omega})-\frac{P(\omega)\cdot(n-1)}{n}=P(\omega)-\frac{P(\omega)\cdot(n-1)}{n}=\frac{P(\omega)}{n} = \hat{P}(M_{\omega}).\]

The overhead of this method per query lies in the iteration over the total choices with multiple models to retrieve and apply the different normalization constants. On the other hand, there is no additional cost in the operations performed at a node level while traversing the circuit, in contrast to the Cartesian product operations in the first method. Algorithm 2 describes the correction of the weight for any formula $\varphi$ , where only the models and total choices compatible with $\varphi$ contribute to $\mathit{WMC}(\varphi)$ with unnormalized weights. In Section 7 we show experimentally that exploiting the efficiency of the $\mathit{WMC}$ task results in the evaluation step being significantly faster than the enumeration step, whose complexity reflects on the first method.

Since the circuit describes only the stable models for consistent total choices, in the case of inconsistent programs we derive the probability of an inconsistency by removing from 1 the weight (probability) of the consistent total choices, as described in Section 4.

Algorithm 2 Evaluation step Schema

6.2 Learning task

In this section we show that the EM learning algorithm implemented in ProbLog2 (Gutmann et al. Reference Gutmann, Thon and De Raedt2011) is correct also for consistent smProbLog programs. With inconsistent programs, in fact, learning is not possible in a traditional EM setting, because we cannot associate a selection of probabilistic facts to an interpretation of inconsistent atoms. If one of the atoms is inconsistent then all other atoms are inconsistent. Therefore, we can estimate $\mathbb{P}(\mathcal{L}\models\bot)$ by counting the proportion of inconsistent observations, but we cannot learn how that estimate is distributed across the total choices causing an inconsistency. This information is essential, in this learning setting, to estimate the probability that an atom is chosen. Cussens (Reference Cussens2001) extends the EM framework in stochastic logic programs (Muggleton et al. Reference Muggleton1996) to account for failed derivation paths. In future work, investigating the applicability of his failure adjusted maximization algorithm to inconsistent probabilistic logic programs might offer a solution to overcome the limits of a traditional EM framework on inconsistent smProbLog programs. On the other hand, we show that in the case of consistent smProbLog programs we can learn the probabilities of the program in both total and partial observability.

Total observability. The correctness under total observability is guaranteed by the fact that probabilistic facts are independent. In fact, in total observability each interpretation $I_m\in \mathbb{I}$ observes the truth value of each atom and probabilistic fact of $\mathcal{L}$ . This case reduces to counting the number of true occurrences of each probabilistic fact in the interpretations $\mathbb{I}$ . We clarify this by analyzing Equation (1) from Gutmann et al. (Reference Gutmann, Thon and De Raedt2011) which is also implemented in smProbLog. Let $\hat{p_n}$ be the estimate for $p_n::f_n$ . Let $\theta_{n,j}^m$ be the j-th possible grounding substitution for $f_n$ in the interpretation $I_m$ . Interpretations $I_j$ thus represent a possible combination of ground substitutions for the probabilistic facts. Let $J^m_n$ be the number of such substitutions, and $Z_n=\sum^M_{m=1} J_n^m$ is the total number of ground instances of $f_n$ in all training examples:

(1) \begin{equation} \hat{p_n} = \frac{1}{Z_n} \sum^M_{m=1} \sum^{J^m_n}_{j=1} \delta_{n,j}^m \text{where } \delta^m_{n,j}= \begin{cases} & 1 \text{ if } f_n\theta^m_{n,j}\in I_m; \\ & 0 \text{ else}. \end{cases}\end{equation}

The outermost sum ranges over all observed interpretations and the innermost sum counts each different observation of a ground instance of $f_n$ . Each number of ground substitutions observed is then divided by the total number of ground substitutions. The estimate $ \hat{p_n}$ is thus defined as the proportion of ground substitutions observed over all interpretations observed. This is correct for smProbLog programs because the observation of a probabilistic fact remains independent of the rest of the program for each interpretation.

Partial observability. The correctness under partial observability is guaranteed by the fact that the parameter updates rely on probabilistic inference, which is performed under smProbLog’s semantics and thus returns correct probability estimates. In the partially observable case, where each interpretation $I_m$ observes the truth value of a subset of $\mathcal{L}$ , the parameter update iteration relies on probabilistic inference to update the likelihood of a fact given $I_m$ . At each iteration k the parameters from the previous iteration $k-1$ are used in $\mathcal{L}$ to compute the conditional expectation of the parameter given the interpretations, until convergence. The number of observations $\delta^m_{n,j}$ in ((1)) is replaced by the conditional expectation under the current model $\mathbb{E}[\delta^m_{n,j}|I_m]$ :

(2) \begin{equation} \hat{p_n} = \frac{1}{Z_n} \sum^M_{m=1} \sum^{J^m_n}_{j=1} \mathbb{E}[\delta^m_{n,j}|I_m].\end{equation}

To compute the conditional expectation values we query the model for $\mathbb{P}(f_n)$ at each step under the current parameters estimate. This means that the normalization w.r.t. multiple stable models is incorporated in the conditional probabilities computed by the inference task, therefore also the parameter estimate is normalized w.r.t. the different stable models that may correspond to a given partial observation. Since the algorithmic procedure for learning in smProbLog remains the same as ProbLog2, except from the inference step, Example 6 is a valid example also for learning from a partial interpretation in smProbLog.

8.1 Probabilistic logic programming

Both three-valued well-founded model semantics and stable model semantics have been considered to extend traditional PLP framework’s semantics: Hadjichristodoulou and Warren (Reference Hadjichristodoulou and Warren2012) present an extension of PRISM based on three-valued well-founded models. When considering general normal logic programs, well-founded semantics (Gelder et al. Reference Gelder, Ross and Schlipf1991) is a three-valued semantics, that is, logical atoms can be true, false, or undefined. A three-valued interpretation is a pair $I=(T,F)$ where T and F are disjoint subsets of the Herbrand base $HB(\mathcal{L})$ of the program $\mathcal{L}$ . The (ground) atoms in T (resp. F) are interpreted as true (resp. false) in I. The remaining atoms in $HB(\mathcal{L})\backslash(T\cup F)$ are said to be undefined. A three-valued model is thus a three-valued interpretation which satisfies all the rules of the program. Our approach is different because with stable model semantics we assign a truth value to the non-deterministic choices that well-founded semantics would label as undefined. At the same time we use the third value to denote the absence of stable models.

On the other hand, the application of stable model semantics in PLP is represented by probabilistic answer set programming (ASP) (Cozman and Mauá 2017; 2020). Table 3 summarizes the differences between the frameworks, which emerge on the definition of the probability distribution and the definition of model of a possible world.

Table 3. PLP frameworks comparison. n.a. = not applicable. $2^*$ = the logic semantics is two-valued stable models, but we introduce a third value for total choices with 0 stable models.

Relation with probabilistic ASP. The key difference between smProbLog and probabilistic ASP frameworks is that our semantics is based on the distribution semantics, that is, we define a probability distribution over models from a probability distribution over total choices. On the contrary, probabilistic ASP languages such as P-Log (Baral et al. Reference Baral, Gelfond and Rushton2009) and LPMLN Lee and Wang (Reference Lee and Wang2016) use the probability labels to directly define a (globally normalized) probability distribution over the models of a (derived) program. This difference allows us to preserve the marginal probability of independent facts in the joint distribution in the presence of multiple stable models, and to measure the probability of an inconsistency in a program. In fact, following the probabilistic ASP approach can give counterintuitive results as we show in Example 36.

In this paper we focus on computing exact probabilities as Baral et al. (Reference Baral, Gelfond and Rushton2009) and Lee and Wang (Reference Lee and Wang2016) rather than defining an interval of probabilities for each atom as in credal semantics (Lukasiewicz Reference Lukasiewicz and Wiley1998). Cozman and Mauá (2020) remarks the difference between a credal semantics approach and a distribution semantics approach like ours. They emphasize that in distribution semantics a probabilistic fact $p::f.$ the fact f is imposed with probability p and discarded with probability $1-p$ , while their approach distinguishes between taking f with probability p and $\lnot f$ with probability $1-p$ . Moreover, credal semantics are defined only for consistent logic programs, as in Azzolini et al. (Reference Azzolini, Bellodi and Riguzzi2022). Recent work (Rocha and Cozman Reference Rocha and Cozman2022) extends credal semantics to L-Credal semantics to handle inconsistencies. We illustrate the differences by means of the graph coloring example from Cozman and Mau´a (2016), other comparisons are also present in Rocha and Cozman (Reference Rocha and Cozman2022).

Example 38 Consider the following program:

Credal semantics here define probability intervals based on the stable models of the two cases where edge(4,5) is present (one model) or not (two models). The possible colorings are represented in Figure 13. Credal semantics define a lower ( $\underline{\mathbb{P}}$ ) and upper ( $\overline{\mathbb{P}}$ ) probability for each node: $\underline{\mathbb{P}}(\mathit{coloredBy}(1,\mathit{yellow})) = 0$ , $\overline{\mathbb{P}}(\mathit{coloredBy}(1,\mathit{yellow})) = \frac{1}{2}$ , $\underline{\mathbb{P}}(\mathit{coloredBy}(4,\mathit{yellow})) = \frac{1}{2}$ , $\overline{\mathbb{P}}(\mathit{coloredBy}(4,\mathit{yellow})) = 1$ , and $\underline{\mathbb{P}}(\mathit{coloredBy}(3,\mathit{red})) = \overline{\mathbb{P}}(\mathit{coloredBy}(3,\mathit{red})) = 1$ . On the contrary with our semantics we compute exact values: $\mathbb{P}(\mathit{coloredBy}(1,\mathit{yellow}))=0.25$ , $\mathbb{P}(\mathit{coloredBy}(4,\mathit{yellow}))=0.75$ , $\mathbb{P}(\mathit{coloredBy}(3,\mathit{red}))=1$ . These values derive from the probability of $0.5$ of the coloring with edge(4,5) and the probability of $\frac{0.5}{2}$ of each of the two possible coloring without edge(4,5).

Fig. 13. Possible colorings of Example 38.

Relations with traditional PLP. Our approach generalizes traditional PLP frameworks on programs without function symbols: when a program defines total choices corresponding to exactly one two-valued well-founded model, then the semantics agree on both models and probability. As for the model, if a normal logic program has a total two-valued well-founded model, then the model is the unique stable model (Gelder et al. Reference Gelder, Ross and Schlipf1991). Thus, in this case $|M(\omega)|=1$ for each total choice $\omega$ , from which it follows that $\hat{P}(M_{\omega})=P(\omega)$ for the single stable model $M_{\omega}\in \mathit{MOD}(\mathcal{L},\omega)$ ( $\mathit{MOD}(\mathcal{L},\omega) = \{M_{\omega}\}$ ). This means that the probability of the model is the probability of the corresponding total choice as in (probabilistic) two-valued well-founded semantics. The one-to-one correspondence between total choices and stable models also guarantees that $\mathbb{P}((\emptyset,\emptyset))=0$ .

For this reason, our pipeline is also a generalization of ProbLog2’s pipeline. ProbLog2 (Fierens et al. Reference Fierens, den Broeck, Thon, Gutmann and De Raedt2011) reduces the probabilistic inference task to a WMC problem (Cadoli and Donini Reference Cadoli and Donini1997) in three steps:

1. 1. Compute the relevant grounding, that is, ground only the part of the program necessary to answer the query.

2. 2. Convert the ground rules into an equivalent boolean formula (CNF).

3. 3. Compile the boolean formula into an arithmetic circuit to efficiently compute the weighted model count of the formula.

The grounding procedure in ProbLog2 computes the relevant ground program w.r.t. the given queries Q and evidence E. The relevant ground program is obtained by applying SLD resolution to prove all atoms in $Q\cup E$ . However, in smProbLog an atom can be derived from a logical choice whose atoms are not directly justified by some (probabilistic) fact, therefore in this case meaningful parts of the program would not be included in the relevant ground program. This is why we use a standard bottom-up technique. Aziz et al. apply stable model counting techniques in ProbLog (aspProbLog). In particular, they replace the Dsharp compiler (Muise et al. Reference Muise, McIlraith, Beck and Hsu2012) used to implement step 3 with a stable model knowledge compiler (an extension of Dsharp itself). Step 2 is also modified, since the CNF conversion is skipped and a simple representation of the ground rules is provided to the stable model knowledge compiler. However, aspProbLog does not change the semantics of ProbLog, and invalid programs according to the original semantics are still rejected. Moreover, aspProbLog does not implement the syntactical features of ProbLog2 on which our approach to argumentation is based, such as negation in the heads or annotated rules.

Distribution semantics has been proven by Sato (Reference Sato1995) to be well-defined for definite programs with function symbols, and later Riguzzi (Reference Riguzzi2015) proves this for the case of normal programs with two-valued well-founded models. Studying the semantics of smProbLog programs with function symbols is thus an interesting direction for future work.

8.2 Probabilistic argumentation

Our approach is novel as previous work considers different semantics and reasoning techniques for probabilistic argument graphs. Table 4 summarizes these differences: the choice between interpreting probabilities as in the constellation approach or as in the epistemic approach, approaching the problem from PLP modeling a single joint probability distribution as in Bayesian networks, whether it can reason about marginal and conditional queries about the probability of arguments, and the implementation in a framework where the probabilities of the graph can be learned. Moreover, our framework is the only one providing an implementation that can learn from observations (of accepted arguments).

Table 4. Argumentation frameworks comparison. $\sim{}$ denotes partial support

Epistemic. We follow the epistemic interpretation of probabilities (Hunter et al. Reference Hunter, Polberg and Thimm2020; Hunter Reference Hunter2013) as a direct measure of the belief of an agent in arguments. Section 5 already discussed the main differences with previous work. We use fine-grained (gradual) evaluations of relations and base scores for arguments in a bipolar setting similarly to quantified bipolar argument frameworks (QBAFs) (Baroni et al. Reference Baroni, Rago and Toni2019). Similarly to our framework, in a QBAF a set of arguments contains both an attack and support relation, and defines a base score $\tau$ , which corresponds in our case to the prior probability (belief) $P_A$ , as Baroni et al. (Reference Baroni, Rago and Toni2019) describes it: “ the nature and meaning of the base score $[\ldots]$ corresponds to an assessment of arguments which precedes the consideration of the relations of attack and support with other arguments.” In our case the joint probability distribution is the result of this consideration. QBAF is a restricted setting compared to our framework since we also define a score (following the terminology of Reference Baroni, Rago and ToniBaroni et al. (2019)) for the relations $R^+$ and $R^-$ , besides considering set-attacks. Most importantly, we do this with probabilistic semantics.

PLP. At the same time, we propose a mapping from probabilistic argument graphs to probabilistic logic programs, which provides a novel semantics for probabilistic argument graphs. We consider a single probability distribution in a Bayesian style rather than families of distributions. Previous work in fact focused on reasoning about the properties of families of probability distributions that are consistent with the argument graph and additional constraints (epistemic graphs) (Hunter et al. Reference Hunter, Polberg and Thimm2020).

Despite following the epistemic approach, our framework has similarities with the constellations approach. The definition of the distribution over subgraphs in the constellations approach is similar to the distribution over subprograms $F\cup R$ of distribution semantics. In fact, the distribution modeled by the probabilistic logic program is determined by the probability that an argument is included in a possible world, similar to the inclusion or exclusion of nodes and edges in the subgraphs considered in the constellations approach. However, in order to determine whether an argument is true or not, we rely on the stable model semantics for logic programs. In the constellations approach, on the other hand, the admissible arguments are defined by the classical extension-based semantics (Dung Reference Dung1995). Stable models are equivalent to stable extensions for basic arguments graphs (Dung Reference Dung1995). We consider however more sophisticated relations between arguments that cannot be encoded in a traditional (probabilistic) abstract argumentation framework, for example, support (Amgoud et al. Reference Amgoud, Cayrol, Lagasquie-Schiex, Delgrande and Schaub2004) or set-attacks (Nielsen and Parsons Reference Nielsen and Parsons2006). For this reason, our approach does not fit any of the previous categorizations about the connections between logic (programming) and argumentation (Besnard et al. Reference Besnard, Cayrol and Lagasquie-Schiex2020).

Modeling (deterministic) argumentation problems by means of logic programming dates back to the foundational work of Dung (Reference Dung1995). Dung (Reference Dung1995) proposes a method to define meta-interpreters for argument systems encoding the extension-based semantics as logic rules. A change in argumentation semantics thus requires to encode in the meta-interpreter a new reasoning technique. This is the approach taken in Mantadelis and Bistarelli (Reference Mantadelis and Bistarelli2020), while we directly compute the stable models semantics for logic programs on a mapping from argument graphs to probabilistic logic programs.

Wu et al. (Reference Wu, Caminada and Gabbay2009) propose a mapping for Dung’s abstract argumentation frameworks to logic programs, therefore they do not address the probabilistic settings as well as other extensions to the original framework considered in this paper. Wu et al. (Reference Wu, Caminada and Gabbay2009) focus on complete labelings and propose a translation where given an argument graph (A,R), given a set of attacks of the form $(b_i,a)\in (A,R)$ , $i\in\{1,\dots,n\}$ a logic rule of the form $a\leftarrow {\sim}b_1, \dots, {\sim}b_n.$ is added to the logic program translation. This is a similar principle followed in our encoding, where attacks $(b_i,a)$ with $P_R((b_i,a))=p_i$ are translated to rules of the form $p_i::\lnot a\leftarrow b_i.$ In fact, the rewriting of negation in the head produces rules $a \leftarrow a_{pos}, {\sim}a_{not}$ plus $p_i::a_{not} \leftarrow b_i$ . Therefore, in both cases all attackers $b_i$ must be false in order to consider a acceptable. However, there is a difference between negation in the head (and the corresponding translation) and negation in the body. Attacks directly encoded with negation in the body do not exclude that the two choices can be true at the same time because of external justification, but exclude that both are false. Vice versa, an encoding with negation in the head excludes that both choices are true at the same time, but not that both can be false (e.g., in Example 23).

Example 39 Consider the difference between a program with a loop with negation in the body (A) and one with negation in the head (B).

Program A is the program of Example 23. Program B is a similar encoding with negation in the body. In this case the possible worlds $\omega_2$ and $\omega_3$ have the same models of A. However, for $\omega_1=\{\}$ where program A has an empty model, program B has the models $\{\{{\mathit{stay\_at\_Y}}\}, \{{\mathit{stay\_at\_X}}\}\}$ . While program B forces a choice when the counterarguments are not accepted, program A allows no choice. At the same time, program B allows on $\omega_4$ to infer a stay at both hotels from the counterarguments for each, that is, the model $\{{\mathit{too\_expensive\_X}}, {\mathit{too\_noisy\_Y}}, {\mathit{stay\_at\_X}}, {\mathit{stay\_at\_Y}}\}$ . Table 5 compares the models for each total choice.

Table 5. Possible models comparison of Example 39

Past work on the connections with logic programming beyond basic abstract argumentation frameworks are limited to the deterministic setting, except for the work by Rocha and Cozman (Reference Rocha and Cozman2022). They adopt the translation by Wu et al. (Reference Wu, Caminada and Gabbay2009) to encode assumption based argumentation frameworks (Bondarenko et al. Reference Bondarenko, Toni and Kowalski1993) in a probabilistic logic program. Caminada et al. (Reference Caminada, Sá, Alcântara and Dvorák2015) explore equivalence relations for more expressive deterministic argumentation frameworks, by framing logic programming semantics in terms of argumentation semantics. Alfano et al. (Reference Alfano, Greco, Parisi and Trubitsyna2020) consider the opposite approach and follow in a deterministic setting a similar approach to ours for probabilistic argumentation. In fact, a simple but general logical framework is shown to be able to capture, in a systematic and succinct way, the different features of several argumentation frameworks under different argumentation semantics. The authors remark how the flexibility of a logic programming approach encourages the study of more extensions and can be used for better understanding the semantics of extended argumentation frameworks.

Marginals and conditionals. With our methodology it is possible to apply general PLP reasoning techniques to probabilistic argument graphs, such as marginal probability computation (Example 27), conditioning over evidence (Example 28), and parameter learning (Section 6.2). This results in a modular, expressive, extensible framework reflecting the dynamic nature of beliefs in an argumentation process. On the contrary, argumentation systems like epistemic graphs require (ad-hoc) reasoning algorithms that do not follow the traditional probabilistic reasoning techniques. In the framework by Rocha and Cozman (Reference Rocha and Cozman2022) conditioning on atoms that appear negated in a body is deferred to future work.

Implementation. In Section 6 we presented a system that computes smProbLog semantics, while in the past the focus has been on developing new argumentation semantics rather than tools to compute them. Moreover, we provide an implementation of the EM learning algorithm for probabilistic parameters whose application to probabilistic argumentation problems is novel.