2 Background

A logic program is a set of propositional formulas. A rule is a propositional formula of the form $H \leftarrow B$ where the head $H$ is a disjunction of literals and the body $B$ is either $\top$ or a conjunction of literals. A rule is normal if $H$ is an atom $a$ , and it is a choice rule if $H$ is a disjunction $a \vee \neg a$ for some atom $a$ . If $B$ is $\top$ , we write simply $H$ , and if the rule is normal, we call it a fact. We often identify a set of facts with the corresponding set of atoms. A normal logic program is a set of normal rules. An interpretation is a set of propositional atoms. An interpretation $X$ is a stable model of a logic program $\Pi$ if it is a subset minimal model of the program that results from replacing in $\Pi$ every maximal subformula that is not satisfied by $X$ by $\bot$ (Reference FerrarisFerraris, 2005). The set of stable models of a logic program $\Pi$ is denoted by $\mathit{SM}(\Pi )$ . A logic program with weak constraints is a set $\Pi _1 \cup \Pi _2$ where $\Pi _1$ is a logic program and $\Pi _2$ is a set of weak constraints of the form $ :\sim \, F[\mathit{w}, \mathit{l}]$ where $F$ is a formula, $\mathit{w}$ is a real number weight, and $\mathit{l}$ is a nonnegative integer. The cost of a stable model $X$ of $\Pi _1$ at some nonnegative integer level $l$ is the sum of the costs $w$ of the weak constraints $:\sim \, F[\mathit{w}, \mathit{l}]$ from $\Pi _1$ whose formula $F$ is satisfied by $X$ . Given two stable models $X$ and $Y$ of $\Pi _1$ , $X$ is preferred to $Y$ wrt. $\Pi _2$ if there is some nonnegative integer $l$ such that the cost of $X$ at $l$ is smaller than the cost of $Y$ at $l$ , and for all $l^{\prime} \gt l$ , the costs of $X$ and $Y$ at $l^{\prime}$ are the same. $X$ is an optimal model of $\Pi _1 \cup \Pi _2$ if it is a stable model of $\Pi _1$ and there is no stable model $Y$ of $\Pi _1$ such that $Y$ is preferred to $X$ wrt. $\Pi _2$ (Reference Buccafurri, Leone and RulloBuccafurri et al., 2000).

We review the definition of Lpmln from Reference Lee and WangLee and Wang (2016). An Lpmln program $\Pi$ is a finite set of weighted formulas $w : F$ where $F$ is a propositional formula and $w$ is either a real number (in which case, the weighted formula is called soft) or $\alpha$ for denoting the infinite weight (in which case, the weighted formula is called hard). If $\Pi$ is an Lpmln program, by $\Pi ^{\mathit{soft}}$ and $\Pi ^{\mathit{hard}}$ we denote the set of soft and hard formulas of $\Pi$ , respectively. For any Lpmln program $\Pi$ and any set $X$ of atoms, ${\overline{\Pi }}$ denotes the set of (unweighted) formulas obtained from $\Pi$ by dropping the weights, and $\Pi _X$ denotes the set of weighted formulas $w : F$ in $\Pi$ such that $X \models F$ . Given an Lpmln program $\Pi$ , $\mathit{SSM}(\Pi )$ denotes the set of soft stable models $ \{X \mid X \textrm{ is a stable model of }{{\overline{\Pi _X}}} \}.$ The total weight of $\Pi$ , written $\mathit{TW}(\Pi )$ , is defined as $\mathit{exp}(\sum _{w:F \in \Pi }w)$ .

The weight $W_{\Pi }(X)$ of an interpretation and its probability $P_{\Pi }(X)$ are defined, respectively, as

\begin{align*}{W_{\Pi }(X)} & = \begin{cases}{\mathit{TW}(\Pi _X)} & \textrm{ if } X \in{\mathit{SSM}(\Pi )} \\ 0 & \textrm{ otherwise } \end{cases} \\ \textrm{ and } \\{P_{\Pi }(X)} & = \lim _{\alpha \rightarrow \infty } \frac{{W_{\Pi }(X)}}{\sum _{Y \in{\mathit{SSM}(\Pi )}}{W_{\Pi }(Y)}} \, . \end{align*}

An interpretation $X$ is called a probabilistic stable model of $\Pi$ if ${P_{\Pi }(X)} \neq 0$ .

Example 1. Let $\Pi _1$ be the Lpmln program that consists of the following formulas:

\begin{equation*} \begin {array}{c@{\hspace {25pt}}c} \alpha : a & 1 : b \end {array} \end{equation*}

The soft stable models of $\Pi _1$ are $\emptyset$ , $\{a\}$ , $\{b\}$ , and $\{a,b\}$ . Their weights and probabilities are as follows:

\begin{align*}{W_{\Pi _1}(\emptyset )} & =0 &{W_{\Pi _1}(\{a\})} & =\mathit{exp}(\alpha ) &{W_{\Pi _1}(\{b\})} & = \mathit{exp}(1) &{W_{\Pi _1}(\{a,b\})} & =\mathit{exp}(1+\alpha ) \\{P_{\Pi _1}(\emptyset )} & =0 &{P_{\Pi _1}(\{a\})} & \approx 0.269 &{P_{\Pi _1}(\{b\})} & =0 &{P_{\Pi _1}(\{a,b\})} & \approx 0.731 \end{align*}

To calculate the probabilities, we first determine the denominator

\begin{align*} \sum _{Y \in{\mathit{SSM}(\Pi )}}{W_{\Pi }(Y)} = 0 + \mathit{exp}(\alpha ) + \mathit{exp}(1) + \mathit{exp}(1 + \alpha ) \, . \end{align*}

For the soft stable model $\{b\}$ , we get

\begin{align*}{P_{\Pi _1}(\{b\})} = \lim _{\alpha \rightarrow \infty } \frac{\mathit{exp}(1)}{\mathit{exp}(\alpha ) + \mathit{exp}(1) + \mathit{exp}(1 + \alpha )} \, . \end{align*}

If we apply $\lim _{\alpha \rightarrow \infty }$ , we see that the denominator tends to infinity, while the numerator is a constant. Therefore, the whole expression tends to $0$ as $\alpha$ approaches infinity. In the same way, we can simplify the denominator by removing the $\mathit{exp}(1)$ as it will always be dominated by the other terms containing $\mathit{exp}(\alpha )$ . For the soft stable models $\{a\}$ and $\{a,b\}$ we then get the exact probabilities ${P_{\Pi _1}(\{a\})} = 1 / (1+e)$ and ${P_{\Pi _1}(\{a,b\})} = e / (1+e)$ whose approximate values we showed above. For the soft stable model $\{ \emptyset \}$ , the probability is $0$ since the weight is $0$ .

Let $\Pi _2=\Pi _1 \cup \{\alpha : \neg a\}$ . The soft stable models of $\Pi _2$ are the same as those of $\Pi _1$ , but their weights and probabilities are different:

\begin{align*}{W_{\Pi _2}(\emptyset )} & =\mathit{exp}(\alpha )\! &{W_{\Pi _2}(\{a\})} & =\mathit{exp}(\alpha )\!\! &{W_{\Pi _2}(\{b\})} & =\mathit{exp}(1+\alpha )\!\! &{W_{\Pi _2}(\{a,b\})} & =\mathit{exp}(1+\alpha ) \\{P_{\Pi _2}(\emptyset )} & =0.134 &{P_{\Pi _2}(\{a\})} & =0.134 &{P_{\Pi _2}(\{b\})} & = 0.365 &{P_{\Pi _2}(\{a,b\})} & =0.365 \end{align*}

Let $\Pi _3$ and $\Pi _4$ replace the formula $1: b$ by the two formulas $\alpha : b \vee \neg b$ and $1 : \neg \neg b$ in $\Pi _1$ and $\Pi _2$ , respectively, i.e., $\Pi _3 = \{ \alpha : a, \, \alpha : b \vee \neg b, \, 1 : \neg \neg b \}$ and $\Pi _4=\Pi _3 \cup \{\alpha : \neg a\}$ . The soft stable models of $\Pi _3$ are the same as those of $\Pi _1$ , their weights are the same as in $\Pi _1$ but incremented by $\alpha$ , since all of them satisfy the new choice rule $\alpha : b \vee \neg b$ , and their probabilities are the same as in $\Pi _1$ . The same relation holds between the soft stable models of $\Pi _4$ and $\Pi _2$ .

Besides the standard definition, we consider also an alternative definition for Lpmln from Reference Lee and WangLee and Wang (2016), where soft stable models must satisfy all hard formulas of $\Pi$ . In this case, we have

\begin{align*}{\mathit{SSM}^{\mathit{alt}}(\Pi )} = \left \{X \mid X \textrm{ is a (standard) stable model of }{{\overline{\Pi _X}}} \textrm{ that satisfies }{{\overline{{\Pi ^{\mathit{hard}}}}}} \right\} \,, \end{align*}

while the weight $W_{\Pi }^{\mathit{alt}}(X)$ of an interpretation and its probability $P_{\Pi }^{\mathit{alt}}(X)$ are defined, respectively, as

\begin{align*}{W_{\Pi }^{\mathit{alt}}(X)} & = \begin{cases}{\mathit{TW}({\Pi ^{\mathit{soft}}}_X)} & \textrm{ if } X \in{\mathit{SSM}^{\mathit{alt}}(\Pi )} \\[3pt] 0 & \textrm{ otherwise } \end{cases} \\ \textrm{ and } \\{P_{\Pi }^{\mathit{alt}}(X)} & = \frac{{W_{\Pi }^{\mathit{alt}}(X)}}{\sum _{Y \in{\mathit{SSM}^{\mathit{alt}}(\Pi )}}{W_{\Pi }^{\mathit{alt}}(Y)}} \, . \end{align*}

The set $\mathit{SSM}^{\mathit{alt}}(\Pi )$ may be empty if there is no soft stable model that satisfies all hard formulas of $\Pi$ , in which case $P_{\Pi }^{\mathit{alt}}(X)$ is not defined. On the other hand, if $\mathit{SSM}^{\mathit{alt}}(\Pi )$ is not empty, then for every interpretation $X$ , the values of $P_{\Pi }^{\mathit{alt}}(X)$ and $P_{\Pi }(X)$ are the same (cf. Proposition2 from Reference Lee and WangLee and Wang (2016)).

In the next paragraphs, we adapt the definition of ProbLog from Reference Fierens, den Broeck, Renkens, Shterionov, Gutmann, Thon, Janssens and RaedtFierens et al. (2015) to our notation. A basic ProbLog program $\Pi$ consists of two parts: a set ${{\Pi }^{\mathit{normal}}}$ of normal rules and a set ${{\Pi }^{\mathit{probs}}}$ of probabilistic facts of the form $p :: a$ for some probability $p$ and some atom $a$ . Without loss of generality, we consider that $p$ is strictly between $0$ and $1$ . By ${{\mathit{choices}(\Pi )}}$ , we denote the set $\{ a \mid p :: a \in{{{\Pi }^{\mathit{probs}}}}\}$ of atoms occurring in the probabilistic facts of such a program. We say that a basic ProbLog program is valid if it satisfies these conditions:

1. 1. The probabilistic atoms $a \in{{{\mathit{choices}(\Pi )}}}$ must not occur in any head $H$ of any rule $H \leftarrow B$ from ${\Pi }^{\mathit{normal}}$ .

2. 2. For every set $X \subseteq{{{\mathit{choices}(\Pi )}}}$ , the well-founded model (Reference Van Gelder, Ross and SchlipfVan Gelder et al., 1991) of ${{{\Pi }^{\mathit{normal}}}}\cup X$ must be total.

The second condition holds, in particular, if ${{\Pi }^{\mathit{normal}}}$ is positive or stratified (Reference Van Gelder, Ross and SchlipfVan Gelder et al., 1991). Note also that if the second condition holds, then the program ${{{\Pi }^{\mathit{normal}}}}\cup X$ has a unique stable model that coincides with the true atoms of its well-founded model. Following Reference Fierens, den Broeck, Renkens, Shterionov, Gutmann, Thon, Janssens and RaedtFierens et al. (2015), we consider only basic ProbLog programs that are valid.

Given a basic ProbLog program $\Pi$ , the probability $P_{\Pi }(X)$ of an interpretation $X$ is defined as follows:

• • If $X$ is the (unique) stable model of ${{{\Pi }^{\mathit{normal}}}}\cup (X \cap{{{\mathit{choices}(\Pi )}}})$ , then $P_{\Pi }(X)$ is the product of the products

  \begin{align*} \prod _{\substack{\phantom{a}p :: a \in{{{\Pi }^{\mathit{probs}}}} \\ a \in X}}p \textrm{ and } \prod _{\substack{\phantom{a}p :: a \in{{{\Pi }^{\mathit{probs}}}} \\ a \notin X}}1 - p. \end{align*}

• • Otherwise, $P_{\Pi }(X)$ is $0$ .

Example 3. Let $\Pi _6$ be the ProbLog program that consists of the following elements:

\begin{equation*} \begin {array}{c@{\hspace {25pt}}c} b \leftarrow \neg a & 0.4 :: a \end {array} \end{equation*}

We have that ${{{\Pi }_{6}^{\mathit{probs}}}}=\{ 0.4 :: a\}$ , and ${{{\Pi }_{6}^{\mathit{normal}}}}=\{ b \leftarrow \neg a\}$ , ${{{\mathit{choices}(\Pi _6)}}}=\{a\}$ . Program $\Pi _6$ is valid because it satisfies both condition 1, since the unique atom $a \in{{{\mathit{choices}(\Pi _6)}}}$ does not occur in the head of the unique rule of ${{\Pi }_{6}^{\mathit{normal}}}$ , and condition 2, since the program ${{\Pi }_{6}^{\mathit{normal}}}$ is stratified. The interpretations $\{a\}$ and $\{b\}$ have probability $0.4$ and $0.6$ , respectively, and the others have probability $0$ .

In Reference Fierens, den Broeck, Renkens, Shterionov, Gutmann, Thon, Janssens and RaedtFierens et al. (2015), the definition of an inference task may include the specification of some evidence. Here, to simplify the presentation, it is convenient to include the evidence as part of a ProbLog program. To do this, we represent this evidence by formulas of the form $\neg a$ or $\neg \neg a$ for some atom $a$ , which we call evidence literals. We use evidence literals of the form $\neg \neg a$ , instead of normal atoms of the form $a$ , to distinguish them clearly from normal facts and to simplify our presentation later. Then, we consider extended ProbLog programs that contain a set ${{\Pi }^{\mathit{evidence}}}$ of evidence literals in addition to normal rules and probabilistic facts. Both the notation and the definition of validity that we introduced above carry over naturally to ProbLog programs of this extended form. Just like before, we consider only valid extended ProbLog programs. Next, let $\Pi$ be an extended ProbLog program. If $X$ is an interpretation, by $P^{\mathit{basic}}_{\Pi }(X)$ we denote the probability $P_{{{{\Pi }^{\mathit{normal}}}}\cup{{{\Pi }^{\mathit{probs}}}}}(X)$ of the corresponding basic ProbLog program. Then, the probability of the evidence of $\Pi$ is the sum of the basic probabilities $P^{\mathit{basic}}_{\Pi }(X)$ of the interpretations $X$ that satisfy all evidence literals in ${{\Pi }^{\mathit{evidence}}}$ . Finally, given an extended ProbLog program $\Pi$ , the probability $P_{\Pi }(X)$ of an interpretation $X$ is

• • undefined if the probability of the evidence of $\Pi$ is zero, otherwise

• • it is $0$ if $X$ does not satisfy all evidence literals in ${{\Pi }^{\mathit{evidence}}}$ , and otherwise

• • it is the quotient between $P^{\mathit{basic}}_{\Pi }(X)$ and the probability of the evidence of $\Pi$ .

Basic ProbLog programs are a special case of extended ProbLog programs where ${{\Pi }^{\mathit{evidence}}}$ is empty. From now on, we refer to extended ProbLog programs simply as ProbLog programs.

We close this section with the definition of the probability of a query atom $q$ that is similar in both versions of Lpmln and in ProbLog: it is undefined if the probability of the interpretations of the corresponding program is undefined, which cannot happen with the standard definition of Lpmln, and otherwise it is the sum of the probabilities of the interpretations that contain the query atom.

3 The language $\textit{Lpmln}^{\pm }$

In this section, we introduce the language $\textit{Lpmln}^{\pm }$ and present translations from Lpmln to $\textit{Lpmln}^{\pm }$ , and from $\textit{Lpmln}^{\pm }$ to ProbLog. The former are used in the frontends of Lpmln, ProbLog and P-log, combined with the translations from ProbLog and P-log to Lpmln from Reference Lee and WangLee and Wang (2016) and Reference Lee and YangLee and Yang (2017), respectively. The latter is used in the solving component of plingo to translate from $\textit{Lpmln}^{\pm }$ to ProbLog and run a problog solver.

The language $\textit{Lpmln}^{\pm }$ is based on Lpmln under the alternative semantics. The superscript $\pm$ in the name indicates that the new language both extends and restricts Lpmln. The extension simply consists in adding weak constraints to the language. This is a natural extension that allows us to capture the whole Lpmln language under both the alternative and the standard semantics. On the other hand, the restriction limits the form of soft formulas to soft integrity constraints of the form $w : \neg F$ for some propositional formula $F$ . This is attractive because it allows us to provide a definition of the semantics that is arguably very simple and intuitive. Interestingly, the translations from ProbLog and P-log (Reference Lee and WangLee and Wang, 2016; Reference Lee and YangLee and Yang, 2017) fall into this fragment of Lpmln. Recall that in ASP, integrity constraints of the form $\neg F$ do not affect the generation of stable models, but they can only eliminate some of the stable models generated by the rest of the program. In Lpmln, soft integrity constraints parallel that role, since they do not affect the generation of soft stable models, but they can only affect the probabilistic weights of the soft stable models generated by the rest of the program. More precisely, it holds that the soft stable models of an Lpmln program $\Pi$ remain the same if we remove from $\Pi$ all its soft integrity constraints. The reader can check that this is the case in our example programs $\Pi _3$ and $\Pi _4$ if we remove their soft integrity constraint $1 : \neg \neg b$ . This observation leads us to the following proposition.

This allows us to leave aside the notion of soft stable models and simply replace in $W_{\Pi }^{\mathit{alt}}(X)$ and $P_{\Pi }^{\mathit{alt}}(X)$ the set $\mathit{SSM}^{\mathit{alt}}(\Pi )$ by $\mathit{SM}({{\overline{{\Pi ^{\mathit{hard}}}}}})$ . From this perspective, an Lpmln program of this restricted form has two separated parts: $\Pi ^{\mathit{hard}}$ , which generates stable models, and $\Pi ^{\mathit{soft}}$ , which determines the weights of the stable models, from which their probabilities can be calculated.

With these ideas, we can define the syntax and semantics of $\textit{Lpmln}^{\pm }$ programs. Formally, an $\textit{Lpmln}^{\pm }$ program $\Pi$ is a set of hard formulas, soft integrity constraints, and weak constraints, denoted, respectively, by $\Pi ^{\mathit{hard}}$ , $\Pi ^{\mathit{soft}}$ , and $\Pi ^{\mathit{weak}}$ . In what follows, we may identify a hard formula or a set of them with their corresponding unweighted versions. We say that $\Pi$ is normal if $\Pi ^{\mathit{hard}}$ is normal. By $\mathit{OPT}^{{\pm }}(\Pi )$ we denote the optimal stable models of ${{\overline{{\Pi ^{\mathit{hard}}}}}} \cup{\Pi ^{\mathit{weak}}}$ . Then, the weight and the probability of an interpretation $X$ , written $W_{\Pi }^{{\pm }}(X)$ and $P_{\Pi }^{{\pm }}(X)$ , are defined as

\begin{align*}{W_{\Pi }^{{\pm }}(X)} & = \begin{cases}{\mathit{TW}({\Pi ^{\mathit{soft}}}_X)} & \textrm{ if } X \in{\mathit{OPT}^{{\pm }}(\Pi )} \\[3pt] 0 & \textrm{ otherwise } \end{cases} \\ \textrm{ and } \\{P_{\Pi }^{{\pm }}(X)} & = \frac{{W_{\Pi }^{{\pm }}(X)}}{\sum _{Y \in{\mathit{OPT}^{{\pm }}(\Pi )}}{W_{\Pi }^{{\pm }}(Y)}} \, . \end{align*}

Note that, as before, $\mathit{OPT}^{{\pm }}(\Pi )$ may be empty, in which case $P_{\Pi }^{{\pm }}(X)$ is not defined. Naturally, when $\Pi ^{\mathit{weak}}$ is empty the semantics coincide with the alternative semantics for Lpmln. In this case, $\mathit{OPT}^{{\pm }}(\Pi )$ is equal to $\mathit{SM}({{\overline{{\Pi ^{\mathit{hard}}}}}})$ , which by Proposition1 is equal to $\mathit{SSM}^{\mathit{alt}}(\Pi )$ , and both definitions are the same.

3.1 From Lpmln to $\textit{Lpmln}^{\pm }$

We translate Lpmln programs to $\textit{Lpmln}^{\pm }$ programs following the idea of the translation lpmln2wc from Reference Lee and YangLee and Yang (2017). An Lpmln program $\Pi$ under the standard semantics is captured by the $\textit{Lpmln}^{\pm }$ program $\mathit{standard}(\Pi )$ that contains

• • the hard formulas $ \{ \alpha : F \vee \neg F \mid w:F \in \Pi \}$ ,

• • the soft formulas $\{ w : \neg \neg F \mid w :F \in \Pi, w \neq \alpha \}$ , and

• • the weak constraints $\{ :\sim \, F [-1,1] \mid w : F \in \Pi, w = \alpha \}$ .

The hard formulas generate the soft stable models of $\Pi$ , the weak constraints select those which satisfy most of the hard formulas of $\Pi$ , while the soft formulas attach the right weight to each of them, without interfering in their generation. The alternative semantics is captured by the translation $\mathit{alternative}(\Pi )$ that contains

• • the hard formulas $\{ \alpha : F \mid w:F \in \Pi, w = \alpha \} \cup \{ \alpha : F \vee \neg F \mid w:F \in \Pi, w \neq \alpha \}$ ,

• • the same soft formulas as in $\mathit{standard}(\Pi )$ , and

• • no weak constraints.

The first hard formulas enforce that the hard formulas of $\Pi$ must be satisfied, while the latter is the same as in $\mathit{standard}(\Pi )$ , but only for the soft formulas of $\Pi$ . The weak constraints are not needed anymore.

Proposition 2. Let $\Pi$ be an Lpmln program. For every interpretation $X$ , it holds that

\begin{align*} &{P_{\Pi }(X)} ={P_{{\mathit{standard}(\Pi )}}^{{\pm }}(X)} \quad \textrm{ and } \\ &{P_{\Pi }^{\mathit{alt}}(X)} ={P_{{\mathit{alternative}(\Pi )}}^{{\pm }}(X)} \, . \end{align*}

Example 6. The $\textit{Lpmln}^{\pm }$ programs $\Pi _3$ , $\Pi _4$ , and $\Pi _5$ of our examples are the result of applying the previous translations to the Lpmln programs $\Pi _1$ and $\Pi _2$ . Namely, $\Pi _3$ is $\mathit{alternative}(\Pi _1)$ , $\Pi _4$ is $\mathit{alternative}(\Pi _2)$ , and $\Pi _5$ is $\mathit{standard}(\Pi _1)$ . Accordingly, for all interpretations $X$ , it holds that ${P_{\Pi _1}^{\mathit{alt}}(X)}={P_{\Pi _3}^{{\pm }}(X)}$ , ${P_{\Pi _2}^{\mathit{alt}}(X)}={P_{\Pi _4}^{{\pm }}(X)}$ , and ${P_{\Pi _1}(X)}={P_{\Pi _5}^{{\pm }}(X)}$ . The program $\mathit{standard}(\Pi _2)$ is $\Pi _5\cup \{\alpha : \neg a \vee \neg \neg a, \, :\sim \, \neg a [-1,1]\}$ .

As noted in Reference Lee, Talsania and WangLee et al. (2017), these kinds of translations can be troublesome when applied to logic programs with variables in the input language of clingo (Reference Calimeri, Faber, Gebser, Ianni, Kaminski, Krennwallner, Leone, Maratea, Ricca and SchaubCalimeri et al., 2020). This is the case of the Lpmln frontend in plingo, where the rules at the input can be seen as safe implications $H \leftarrow B$ where $H$ is a disjunction and $B$ a conjunction of first-order atoms. It is hard to see how to apply the previous translations in such a way that the resulting soft formulas and weak constraints belong to the input language of clingo, since the result has to safisfy clingo’s safety conditions. For instance, if we try to apply the $\mathit{standard}$ translation to the hard rule a(X) :- b(X)., a possible approach could generate the two weak constraints : a(X). [-1,X] and : not b(X). [-1,X], but the second of them is not safe and will not be accepted by clingo. To overcome this problem, we can use the negative versions of the previous translations, based on the translation lpmln2wc $^{pnt}$ from Reference Lee and YangLee and Yang (2017), where the soft formulas for both translations are

\begin{equation*}\{ -w : \neg F \mid w :F \in \Pi, w \neq \alpha \},\end{equation*}

and the weak constraints for the standard semantics are

\begin{equation*}\{ :\sim \, \neg F [1,1] \mid w : F \in \Pi, w = \alpha \}.\end{equation*}

Observe that now $F$ always occurs under one negation. In this case, when $F$ has the form $H \leftarrow B$ , the formulas $\neg F$ can be simply written as $\neg H \wedge B$ , and this formulation can be easily incorporated into clingo. For instance, a(X) :- b(X). is translated in this way to : not a(X), b(X). [1,X], which is safe and accepted by clingo. These negative versions are the result of applying to $\mathit{standard}(\Pi )$ and $\mathit{alternative}(\Pi )$ the translation of the following proposition, and then simplifying the soft formulas of the form $-w : \neg \neg \neg F$ to $-w : \neg F$ .

Proposition 3. Given an $\textit{Lpmln}^{\pm }$ program $\Pi$ , let $\mathit{negative}(\Pi )$ be the program

\begin{align*}{\Pi ^{\mathit{hard}}} \cup \{ -w : \neg F \mid \, w : F \in{\Pi ^{\mathit{soft}}} \} \cup \{ :\sim \, \neg F [-w,l]\mid \, :\sim \, F [w,l] \in{\Pi ^{\mathit{weak}}}\} \, . \end{align*}

For every interpretation $X$ , it holds that $P_{\Pi }^{{\pm }}(X)$ and $P_{{\mathit{negative}(\Pi )}}^{{\pm }}(X)$ coincide.

This proposition is closely related to Corollary 1 from Reference Lee and YangLee and Yang (2017).

Example 7. The program $\mathit{negative}(\Pi _5)$ is $\{ \alpha : a \vee \neg a, \, :\sim \, \neg a [1,1], \, \alpha : b \vee \neg b, \, -1 : \neg \neg \neg b \}$ . Its last formula can be simplified to $-1 : \neg b$ . The optimal stable models of this program are $\{a\}$ and $\{a,b\}$ , their weights are $\mathit{exp}(-1)$ and $\mathit{exp}(0)$ , respectively, and their probabilities are the same as in $\Pi _5$ .

3.2 From ProbLog to $\textit{Lpmln}^{\pm }$ and back

Reference Lee and WangLee and Wang (2016) show how to translate ProbLog programs to Lpmln. We obtain a translation from ProbLog to $\textit{Lpmln}^{\pm }$ by combining that translation with our $\mathit{alternative}$ translation from Lpmln to $\textit{Lpmln}^{\pm }$ . Recall that we may identify a hard formula or a set of them by their corresponding unweighted versions. Let $\Pi$ be a ProbLog program, then the $\textit{Lpmln}^{\pm }$ program ${{\mathit{problog2lpmln}(\Pi )}}$ is:Footnote ¹

\begin{align*}{{{\Pi }^{\mathit{normal}}}} \cup{{{\Pi }^{\mathit{evidence}}}} \cup \{ a \vee \neg a \mid p :: a \in{{{\Pi }^{\mathit{probs}}}}\} \cup \{ \mathit{ln}(p/(1-p)) : \neg \neg a \mid p :: a \in{{{\Pi }^{\mathit{probs}}}}\}. \end{align*}

Proposition 4. Let $\Pi$ be a ProbLog program. For every interpretation $X$ , it holds that $P_{\Pi }(X)$ and $P_{{{{\mathit{problog2lpmln}(\Pi )}}}}^{{\pm }}(X)$ are the same.

Example 8. Given our previous ProbLog program $\Pi _7=\{ b \leftarrow \neg a, \, \neg b, \, 0.4 :: a \}$ , the $\textit{Lpmln}^{\pm }$ program ${{\mathit{problog2lpmln}(\Pi _7)}}$ consists of the following formulas:

\begin{equation*}\begin {array}{c@{\hspace {25pt}}c@{\hspace {25pt}}c@{\hspace {25pt}}c} b \leftarrow \neg a & \neg b & a \vee \neg a & -0.405 : \neg \neg a \end {array}\end{equation*}

where $-0.405$ is the result of $\mathit{ln}(0.4/(1-0.4))$ . It holds that $P_{{{{\mathit{problog2lpmln}(\Pi _7)}}}}^{{\pm }}(X)$ is $1$ when $X=\{a\}$ , and it is $0$ otherwise, which is the same as $P_{\Pi _7}(X)$ .

In the remainder of this section, we present a translation in the other direction, from $\textit{Lpmln}^{\pm }$ to ProbLog. The translation applies to non-disjunctive $\textit{Lpmln}^{\pm }$ programs without weak constraints. At first sight, it may seem counterintuitive that such a translation is possible, since ProbLog is based on the well-founded semantics, and the second condition for valid ProbLog programs severely restricts the form of their normal part. However, a closer look reveals that this restriction can be compensated by the other components of ProbLog’s programs: probabilistic facts and evidence literals. As we will see, they can fulfill the role of choice rules and integrity constraints in ASP, respectively. Under this view, ProbLog programs resemble logic programs that follow the Generate, Define and Test methodology (Reference LifschitzLifschitz, 2002) where probabilistic facts generate possible solutions, normal rules define additional predicates, and evidence literals filter the actual solutions. This relation makes the existence of a translation more intuitive. We make it precise in the next paragraphs.

We present the translation for a normal $\textit{Lpmln}^{\pm }$ program $\Pi$ without weak constraints, whose soft formulas have the form $w : \neg \neg a$ for some atom $a$ . We assume that in $\Pi$ there are no different soft formulas $w_1 : \neg \neg a$ and $w_2 : \neg \neg a$ for the same atom $a$ . Using well-known translations, it is easy to extend the results to more general types of $\textit{Lpmln}^{\pm }$ programs, as long as the complexity of deciding the satisfiability of the hard part remains in $\mathit{NP}$ , and the programs contain no weak constraints. In fact, the implementation of this translation in our system plingo works for non-disjunctive clingo programs (Reference Calimeri, Faber, Gebser, Ianni, Kaminski, Krennwallner, Leone, Maratea, Ricca and SchaubCalimeri et al., 2020).

We modify $\Pi$ in four steps until we have a $\textit{Lpmln}^{\pm }$ program that, in step 5, we can easily turn into a ProbLog program by inverting the translation ${{\mathit{problog2lpmln}}}$ . We take as our running example the following $\textit{Lpmln}^{\pm }$ program $\Pi _8$ that is the result of applying to $\Pi _3$ the usual translation from choice rules to normal rules:

\begin{equation*} \begin {array}{c@{\hspace {35pt}}c@{\hspace {35pt}}c@{\hspace {35pt}}c} a & b \leftarrow \neg \mathit {nb} & \mathit {nb} \leftarrow \neg b & 1 : \neg \neg b \end {array} \end{equation*}

The (optimal) stable models of $\Pi _8$ are $\{a,\mathit{nb}\}$ and $\{a,b\}$ . Their probabilities are $0.269$ and $0.731$ , respectively, just like those of $\{a\}$ and $\{a,b\}$ with respect to $\Pi _3$ .

Step 1. We assume that the atom $\mathit{bot}$ does not occur in $\Pi$ , and we add the literal $\neg{\mathit{bot}}$ to $\Pi$ . In the end, this will be the unique evidence literal in the resulting ProbLog program. Integrity constraints $\bot \leftarrow B$ are not allowed in ProbLog, but once we have the evidence literal $\neg{\mathit{bot}}$ , we can represent them simply by ${\mathit{bot}} \leftarrow B$ . This shows how evidence literals fulfill the role of integrity constraints.

Step 2. For every atom $a$ occurring in $\Pi$ , we add the following rules introducing a new atom $a^{\prime}$ that works as a copy of $a$ :

(1) \begin{align} \begin{array}{c@{\hspace{25pt}}c@{\hspace{25pt}}c}{a^{\prime}} \vee \neg{a^{\prime}} &{\mathit{bot}} \leftarrow a \wedge \neg{a^{\prime}} &{\mathit{bot}} \leftarrow \neg a \wedge{a^{\prime}} \end{array} \end{align}

The choice rule selects a truth value for $a^{\prime}$ , while the other rules act as integrity constraints that enforce the truth values of $a$ and $a^{\prime}$ to be the same. After adding $\neg{\mathit{bot}}$ and these rules to $\Pi$ , the resulting $\textit{Lpmln}^{\pm }$ program has the same stable models as before, but for every atom $a$ in a stable model, we also have its copy $a^{\prime}$ . Apart from this, the probabilities of the stable models remain the same. In our example, we add to $\Pi _8$ the literal $\neg{\mathit{bot}}$ , as well as the formulas (1) for the three atoms $a$ , $b$ , and $\mathit{nb}$ occurring in $\Pi _8$ . The stable models are now $\{a,{a^{\prime}},\mathit{nb},{\mathit{nb}^{\prime}}\}$ and $\{a,{a^{\prime}},\mathit{b},{\mathit{b}^{\prime}}\}$ , and their probabilities are, as before, $0.269$ and $0.731$ .

Step 3. To be able to satisfy condition 2 of valid ProbLog programs, we turn the set of normal rules of the original program into a set of stratified rules, by replacing every negative literal $\neg a$ occurring in them by $\neg{a^{\prime}}$ . That is, we replace every normal rule $r$ in the original program of the form:

\begin{equation*} a_0 \leftarrow a_1 \wedge \ldots \wedge a_m \wedge \neg {a_{m+1}}, \ldots, \neg {a_n} \end{equation*}

by the normal rule ${\mathit{stratify}}(r)$ :

\begin{equation*} a_0 \leftarrow a_1 \wedge \ldots \wedge a_m \wedge \neg {{a^{\prime}}_{m+1}}, \ldots, \neg {{a^{\prime}}_n}. \end{equation*}

This replacement does not affect the stable models of the program, given that $a$ and $a^{\prime}$ are equivalent and the replacement only happens in negative literals. If we also replaced the atoms $a_1$ to $a_m$ by ${a^{\prime}}_1$ to ${a^{\prime}}_m$ , then the resulting program would represent the supported models of the original program instead of the stable ones. It is easy to see that the resulting set of rules is stratified because the atoms $a^{\prime}$ occurring in the negative literals do not occur in any head. In our example, the three normal rules of $\Pi _8$ are replaced by these ones:

\begin{equation*} \begin {array}{c@{\hspace {35pt}}c@{\hspace {35pt}}c} a & b \leftarrow \neg {\mathit {nb}^{\prime}} & \mathit {nb} \leftarrow \neg {b^{\prime}}\end {array} \end{equation*}

Step 4. To invert the translation ${\mathit{problog2lpmln}}$ , we have to translate every pair of a choice rule and a soft formula of our current $\textit{Lpmln}^{\pm }$ program into a probabilistic fact., for doing this, we need such a pairing between choice rules and soft formulas. We achieve it as follows. We replace every soft formula of the form $w : \neg \neg a$ by $w : \neg \neg{a^{\prime}}$ . This does not change the probabilities of the stable models, since $a$ and $a^{\prime}$ are equivalent. Additionally, for the atoms $a$ not occurring in the soft formulas, we add the trivial formula $0 : \neg \neg{a^{\prime}}$ . Clearly, this does not affect the probabilities of the stable models. At this point, for every choice rule ${a^{\prime}} \vee \neg{a^{\prime}}$ in our $\textit{Lpmln}^{\pm }$ program there is one soft formula $w : \neg \neg{a^{\prime}}$ , and vice versa. In our example, the previous soft formula $1 : \neg \neg b$ is replaced by these ones:

\begin{equation*} \begin {array}{c@{\hspace {35pt}}c@{\hspace {35pt}}c} 0 : \neg \neg {a^{\prime}} & 1 : \neg \neg {b^{\prime}} & 0 : \neg \neg {\mathit {nb}^{\prime}} \end {array} \end{equation*}

Step 5. To finalize, we just have to invert the translation ${{\mathit{problog2lpmln}}}$ . We do it by replacing every pair of a choice rule ${a^{\prime}} \vee \neg{a^{\prime}}$ and a soft formula $w : \neg \neg{a^{\prime}}$ by the probabilistic fact $e^w / (e^w + 1) ::{a^{\prime}}$ . The function from $w$ to $e^w / (e^w + 1)$ to calculate the probabilities is simply the inverse of the function from $p$ to $\mathit{ln}(p/(1-p))$ to calculate the weights in ${{\mathit{problog2lpmln}}}$ . In particular, for $w=0$ , it leads to the probability $0.5$ . Note how probabilistic facts fulfill the role of the choice rules, and at the same time, they stand for the soft formulas. In our example, the choice rules from (1) and the previous soft formulas are replaced by the following probabilistic facts:

\begin{equation*} \begin {array}{c@{\hspace {35pt}}c@{\hspace {35pt}}c} 0.5 :: {a^{\prime}} & e/(e+1) :: \neg \neg {b^{\prime}} & 0.5 :: {\mathit {nb}^{\prime}} \end {array} \end{equation*}

In the resulting ProbLog program, the interpretations $\{a,{a^{\prime}},\mathit{nb},{\mathit{nb}^{\prime}}\}$ and $\{a,{a^{\prime}},\mathit{b},{\mathit{b}^{\prime}}\}$ have probabilities $0.269$ and $0.731$ , respectively, and the other interpretations have probability $0$ . This is the same as in $\Pi _8$ , once we eliminate the additional atoms $a^{\prime}$ , $b^{\prime}$ , and $\mathit{nb}^{\prime}$ .

Finally, we can put all the steps of the translation together. Let $\Pi$ be our original program, let $\mathit{atoms}(\Pi )$ denote the set of atoms of $\Pi$ , and $\mathit{soft}(\Pi )$ denote the set of atoms $\{a \mid w : \neg \neg a \in{\Pi ^{\mathit{soft}}}\}$ occurring in the soft formulas of $\Pi$ . Then, the ProbLog program ${{\mathit{lpmln2problog}(\Pi )}}$ consists of:

• • the normal rules

  \begin{align*} \{{\mathit{bot}} \leftarrow a \wedge \neg{a^{\prime}} & \mid a \in{\mathit{atoms}(\Pi )}\} \, \cup \\ \{{\mathit{bot}} \leftarrow \neg a \wedge{a^{\prime}} & \mid a \in{\mathit{atoms}(\Pi )}\} \, \cup \\ \{{{\mathit{stratify}}(r)} & \mid r \in{\Pi ^{\mathit{hard}}}\}, \end{align*}

• • the probabilistic facts

  \begin{align*} \{ e^w / (e^w + 1) ::{a^{\prime}} \mid w : \neg \neg a \in{\Pi ^{\mathit{soft}}} \} & \, \cup \\ \{ 0.5 ::{a^{\prime}} \mid a \in{\mathit{atoms}(\Pi )}\setminus{\mathit{soft}(\Pi )}\} &, \end{align*}

• • and the evidence literals $\{\neg{\mathit{bot}}\}.$

Observe that this is a valid ProbLog program. Condition 1 of validity is satisfied because the atoms $a^{\prime}$ occurring in the probabilistic facts do not occur in any head of the normal rules, and condition 2 is satisfied because the normal rules are stratified. The following proposition states the correctness of the translation.

Proposition 5. Let $\Pi$ be a normal $\textit{Lpmln}^{\pm }$ program $\Pi$ without weak constraints, whose soft formulas have the form $w : \neg \neg a$ for some atom $a$ that has at most one formula of that form. For every interpretation $X$ disjoint from $\{{a^{\prime}}\mid a \in{\mathit{atoms}(\Pi )}\}$ it holds that $P_{\Pi }^{{\pm }}(X)$ and $P_{{{{\mathit{lpmln2problog}(\Pi )}}}}(X\cup \{{a^{\prime}}\mid a \in X\})$ are the same.

4 The language of plingo and its frontends

In this section, we first describe the core language of plingo that basically re-interprets the language of clingo in terms of the semantics of $\textit{Lpmln}^{\pm }$ . After that, we illustrate the frontends of plingo with examples, showing in each case what is the result of the translation to the core language of plingo.

The main idea of plingo is to keep the input language of clingo, and re-interpret weak constraints at priority level $0$ as soft integrity constraints. As explained above, these constraints are not considered to determine the optimal stable models, but instead are used to determine the weights of those models, from which their probabilities are calculated. For programs in the input language of plingo (or of clingo, i.e., the same) we can in fact provide a general definition that relies on the definitions used for clingo (Reference Calimeri, Faber, Gebser, Ianni, Kaminski, Krennwallner, Leone, Maratea, Ricca and SchaubCalimeri et al., 2020), and that therefore covers its whole language. We define a plingo program $\Pi$ as a logic program in the language of clingo, and we let $\mathit{OSM}^{\mathit{plingo}}(\Pi )$ denote the optimal stable models of $\Pi$ without considering weak constraints at level $0$ , and $\mathit{Cost}_{\Pi }(X,0)$ denote the cost of the interpretation $X$ at priority level $0$ , according to the definitions of Reference Calimeri, Faber, Gebser, Ianni, Kaminski, Krennwallner, Leone, Maratea, Ricca and SchaubCalimeri et al. (2020). Then, the weight and the probability of an interpretation $X$ , written $W_{\Pi }^{\mathit{plingo}}(X)$ and $P_{\Pi }^{\mathit{plingo}}(X)$ , respectively, are analogous to $W_{\Pi }^{\mathit{alt}}(X)$ and $P_{\Pi }^{\mathit{alt}}(X)$ , but replacing the set $\mathit{SSM}^{\mathit{alt}}(\Pi )$ by $\mathit{OSM}^{\mathit{plingo}}(\Pi )$ :

\begin{align*}{W_{\Pi }^{\mathit{plingo}}(X)} & = \begin{cases} \mathit{exp}({\mathit{Cost}_{\Pi }(X,0)}) & \textrm{ if } X \in{\mathit{OSM}^{\mathit{plingo}}(\Pi )} \\ 0 & \textrm{ otherwise } \end{cases} \\ \textrm{ and } \\{P_{\Pi }^{\mathit{plingo}}(X)} & = \frac{{W_{\Pi }^{\mathit{plingo}}(X)}}{\sum _{Y \in{\mathit{OSM}^{\mathit{plingo}}(\Pi )}}{W_{\Pi }^{\mathit{plingo}}(Y)}} & \, . \end{align*}

4.1 The frontend of lpmln

Listing 1 shows the birds example from Reference Lee and WangLee and Wang (2016) using the frontend of Lpmln. To start with, there is some general knowledge about birds: both resident birds and migratory birds are birds, and a bird cannot be both resident and migratory. This is represented by the hard rules in Lines 1-3 that are written as common clingo rules. Additionally, from one source of information, we have the fact that $\texttt{jo}$ is a resident bird, while from another, we have that $\texttt{jo}$ is a migratory bird. For some reason, we hold the first source to be more trustworthy than the second. This information is represented by the soft rules in Lines 4 and 5 where the weights are expressed by the (integer) arguments of their &weight/1 atoms in the body. The first soft rule corresponds to the weighted formula $2 : resident(jo)$ and the second to $1 : migratory(jo)$ . Under both the standard and the alternative semantics, this program has three probabilistic stable models: $\{\}$ , $\{{resident(jo)},{bird(jo)}\}$ , and $\{{migratory(jo)},{bird(jo)}\}$ , whose probabilities are $0.09$ , $0.67$ , and $0.24$ , respectively. They can be computed by plingo, running the command plingo –mode=lpmln birds.plp for the standard semantics, and using the option –mode=lpmln-alt for the alternative semantics.

Listing 1. Lpmln birds example (birds.plp).

Listing 2. Translation of the birds example.

Plingo translates Lpmln programs using the negative versions of the $\mathit{standard}$ and $\mathit{alternative}$ translations from Section 3.1. Considering first the alternative semantics, the hard rules remain the same, while the soft ones are translated as shown in Listing 2. According to the negative version of the $\mathit{alternative}$ translation, the soft formula $2 : resident(jo)$ becomes the hard formula $\alpha : resident(jo) \vee \neg resident(jo)$ and the soft formula $-2 : \neg resident(jo)$ . In plingo, the first is written as the choice rule in Line 1 and the second as the weak constraint at level $0$ of Line 2. The translation of the other soft fact is similar. Considering now the standard semantics, the first rule of Listing 1 becomes the choice rule bird(X) :- resident(X) together with the weak constraint : not bird(X), resident(X).[-1@1,X]. The second rule is translated similarly. The third one becomes simply : resident(X), migratory(X). [-1@1,X], since the additional choice rule is a tautology and can be skipped. Observe that both weak constraints use the variable X in the expression [-1@1,X]. This ensures that stable models obtain a weight of -1 for every ground instantiation of the corresponding body that they satisfy.

4.2 The frontend of ProbLog

We illustrate the frontend of ProbLog with an example where we toss two biased coins whose probability of turning up heads is $0.6$ . We would like to know what is the probability of the first coin turning up heads, given some evidence against the case that both coins turn up heads. The representation in plingo is shown in Listing 3. The first rule represents the toss of the coins. Its ground instantiation leads to two probabilistic facts, one for each coin, whose associated probabilities are specified by the &problog/1 atom in the body. The argument of &problog/1 atoms is a string that contains either a float number or an expression, for example $``\texttt{3/5}"$ . Since the argument is a probability, the string must either contain or evaluate to a real number between $0$ and $1$ . The next line poses the query about the probability of the first coin turning up heads, using the theory atom &query/1, whose unique argument is an atom. Finally, Lines 3 and 4 add the available evidence, using the theory atom &evidence/2, whose arguments are an atom and a truth value (true or false). In ProbLog, the probabilistic facts alone lead to four possible worlds: $\{\}$ with probability $0.4*0.4=0.16$ , $\{\texttt{heads(1)}\}$ and $\{\texttt{heads(2)}\}$ with probability $0.6*0.4=0.24$ each, and $\{\texttt{heads(1)}, \texttt{heads(2)}\}$ with probability $0.6*0.6=0.36$ . The last possible world is eliminated by the evidence, and we are left with three possible worlds. Then, the probability of $\texttt{heads(1)}$ is the result of dividing the probability of $\{\texttt{heads(1)}\}$ by the sum of the probabilities of the three possible worlds, that is $\frac{0.24}{0.16+0.24+0.24}=0.375$ . This is the result that we obtain running the command plingo –mode=problog coins.plp.

Plingo translates ProbLog programs using the translation ${{\mathit{problog2lpmln}}}$ from Section 3.2. The result in this case is shown in Listing 4. In the propositional case, the probabilistic ProbLog fact $0.6 :: heads(1)$ is translated to the weighted fact $w: heads(1)$ , where $w=ln(0.6/(1-0.6))\approx 0.40546$ Footnote ² that in $\textit{Lpmln}^{\pm }$ becomes the hard formula $\alpha : heads(1) \vee \neg heads(1)$ together with the soft integrity constraint $w : \neg \neg heads(1)$ . The translation for the other probabilistic fact is similar. In plingo, for C = 1..2, the hard formula is written as the choice rule of Line 1, and the soft one is written as a weak constraint at level $0$ in the next line, after simplifying away the double negation, where @f(X) is an external function that returns the natural logarithm of X/(1-X). Going back to the original program, the &query/1 atom is stored by the system to determine what reasoning task to perform, the normal rule in Line 3 is kept intact, and the &evidence/1 atom is translated to the integrity constraint of Line 4, which excludes the possibility of both coins turning up heads.

Listing 3. ProbLog tossing coins example (coins.plp).

Listing 4. Translation of the coins example.

4.3 The frontend of P-log

We illustrate the frontend of P-log with a simplified version of the dice example from Reference Baral, Gelfond and RushtonBaral et al. (2009), where there are two dice of six faces. The first dice is fair, while the second one is biased to roll $6$ half of the times. We roll both dice and observe that the first rolls a $1$ . We would like to know what is the probability of the second dice rolling another $1$ . The representation in plingo using the P-log frontend is shown in Listing 5. Given that the original language P-log is sorted, a representation in that language would contain the sorts $\mathit{dice}=\{\texttt{d1},\texttt{d2}\}$ and $\mathit{score}=\{\texttt{1}, \ldots, \texttt{6}\}$ , and the attribute $\mathit{roll}: \mathit{dice} \to \mathit{score}$ . In plingo there are no attributes, and the sorts are represented by normal atoms, like in the first two lines of Listing 5. Then, for example, to assert that the result of rolling dice d2 is 6, in P-log one would write an assignment roll(d2) = 6 stating that the attribute roll(d2) has the value 6, while in plingo one would use a normal atom of the form roll(d2,6). Going back to the encoding, Line 3 contains a random selection rule that describes the experiments of rolling every dice D. Each of these experiments selects at random one of the scores of the dice, unless this value is fixed by a deliberate action of the form &do(A), which does not occur in our example. Line 3 contains a probabilistic atom stating that the probability of dice d2 rolling a 6 is $1/2$ . By the principle of indifference, embodied in the semantics of P-log, the probability of each of the $5$ other faces of d2 is $(1-1/2)/5=0.1$ , while the probability of each face of d1 is $1/6$ . Line 5 represents the observation of the first dice rolling a $1$ , and the last line states the query about the probability of the second dice rolling another $1$ . Running the command plingo –mode=plog dice.plp, we obtain that this probability is, as expected, $0.1$ . If we replace the query by &query(roll(d1,1)), then we obtain a probability of $1$ , and not of $1/6$ , because the observation in Line 5 is only consistent with the first dice rolling a $1$ .

Listing 5. P-log dice example (dice.plp).

Listing 6. Translation of the dice example.

Plingo translates P-log programs by combining the translation from Reference Lee, Talsania and WangLee et al. (2017) to Lpmln with the $\mathit{alternative}$ translation from Section 3.1. Given the input file dice.plp, plingo copies the normal rules of Lines 1–2, translates the rules specific to P-log into the Listing 6, stores internally the information about the &query atom, and adds the general meta-encoding of Listing 7. In Listing 6, Line 5 defines for every dice D one random experiment, identified by the term roll(D), which may select for the attribute roll(D) one possible score X. The atoms defined that way are fed to the first rule of the meta-encoding to choose exactly one of those assignments, represented in this case by n special predicate h/1 (standing for ”holds”), which is made equivalent to the predicate roll/2 in Lines 5–6 of Listing 7. Those lines are the interface between the specific input program and the general meta-encoding. They allow the latter to refer to the atoms of the former using the predicate h/1. Next, Line 2 of Listing 6 defines the probability of the second dice rolling a 6 in the experiment identified by the term roll(d2). This is used in Line 6 of the meta-encoding, where @f1(P) returns the logarithm of P, to add that weight whenever the following conditions hold: the attribute A has the value V, this value has not been fixed by a deliberate action, and some probabilistic atom gives the probability P. If there is no such probabilistic atom, then the rule of Line 9 derives that the assignment chosen in the experiment E receives the default probability, calculated in Lines 11–14 following the principle of indifference mentioned above, where @f2(Y) returns the logarithm of 1-Y, and @f3(M) returns the logarithm of 1/M. The idea of this calculation is as follows. For some experiment E, the number Y accounts for the sum of the probabilities of the probabilistic atoms related to E, and M is the number of outcomes of the experiment E for which there are no probabilistic atoms. Then, the probability of each outcome of the experiment E for which there is no probabilistic atom is (1-Y)*(1/M). Instead of multiplying those probabilities 1-Y and 1/M, the encoding adds their logarithms, and it does so in two steps: one in each of the last two weak constraints. Finally, the observation fact generated in Line 3 of Listing 6 is handled by Lines 3-4 of Listing 7, and the possible deliberate actions, represented by atoms of the form do(A), are handled in Line 6 of the meta-encoding.

Listing 7. Meta-encoding for the frontend of P-log.

5 The system plingo

The implementation of plingo is based on clingo and its Python API (v5.5, Reference Gebser, Kaminski, Kaufmann, Ostrowski, Schaub and WankoGebser et al. (2016)). The system architecture is described in Figure 1. The input is a logic program written in some probabilistic language: $\textit{Lpmln}^{\pm }$ , Lpmln, ProbLog or P-log. For $\textit{Lpmln}^{\pm }$ , the input language (orange element of Figure 1) is the same as the input language of clingo, except for the fact that the weights of the weak constraints can be strings representing real numbers. For the other languages, the system uses the corresponding frontends that translate the input logic programs (yellow elements of Figure 1) to the input language of plingo using the Transformer module, as illustrated by the examples in Section 4. Among other things, this involves converting the theory atoms (preceeded by “&”) to normal atoms. The only exception to this is &query atoms that are eliminated from the program and stored internally. For P-log, the frontend also appends the meta-encoding (Listing 7) to the translation of the input program.

Fig 1. System architecture of plingo. The frontends are colored in yellow. Modules of the system are gray boxes. The green flow corresponds to most probable explanation (MPE) inference, the blue one to exact marginal inference, and the red one to approximate inference, all of them using plingo’s internal solving algorithms. The purple flow corresponds to MPE and marginal inference using problog.

Plingo can be used to solve two reasoning tasks: most probable explanation (MPE) inference and marginal inference. MPE inference corresponds to the task of finding the most probable stable model of a probabilistic logic program.Footnote ³ Following the approach of Reference Lee, Talsania and WangLee et al. (2017), this task is reduced in plingo to finding one optimal stable model of the input program using clingo’s built-in optimization methods. The only changes that have to be made concern handling the strings that may occur as weights of weak constraints, and switching the sign of such weights, since otherwise clingo would compute a least probable stable model. Regarding marginal inference, it can be either applied in general or with respect to a query. In the first case, the task is to find all stable models and their probabilities. In the second case, the task is to find the probability of some query atom, which is undefined if the input program has no stable models, and otherwise it is the sum of the probabilities of the stable models that contain that atom. The basic algorithm of plingo for both cases is the same. First, the system enumerates all optimal stable models of the input program excluding the weak constraints at level $0$ . Afterward, those optimal stable models are passed, together with their costs at level $0$ , to the Probability module, which calculates the required probabilities.

In addition to this exact method (represented by the upper blue arrows in Figure 1), plingo implements an approximation method (red arrows in Figure 1) based on the approach presented in Reference Pajunen and JanhunenPajunen and Janhunen (2021). The idea is to simplify the solving process by computing just a subset of the stable models and using this smaller set to approximate the actual probabilities. Formally, in the definitions of $W_{\Pi }^{\mathit{plingo}}(X)$ and $P_{\Pi }^{\mathit{plingo}}(X)$ , this implies replacing the set $\mathit{OSM}^{\mathit{plingo}}(\Pi )$ by one of its subsets. In the implementation, the modularity of this change is reflected by the fact that the Probability module is agnostic to whether the stable models that it receives as input are all or just some subset of them. For marginal inference in general, this smaller subset consists of $k$ stable models with the highest possible probability, given some positive integer $k$ that is part of the input. To compute this subset, the Solver module of plingo uses a new implementation for the task of answer set enumeration in the order of optimality (ASEO) presented in Reference Pajunen and JanhunenPajunen and Janhunen (2021). Given some positive integer $k$ , the implementation first computes the stable models of the smallest cost, then, among the remaining stable models, computes the ones of the smallest cost, and so on until $k$ stable models (if they exist) have been computed.Footnote ⁴ For marginal inference with respect to a query, the smaller subset consists of $k$ stable models containing the query of the highest possible probability and another $k$ stable models without the query of the highest possible probability. In this case, the algorithm for ASEO is set to compute $2\times k$ stable models in total. But once it has computed $k$ stable models that contain the query, or $k$ stable models that do not contain the query, whichever happens first, it adds a constraint enforcing that the remaining stable models fall into the opposite case.

Plingo offers a third solving method that generates a ProbLog program using the translation ${{\mathit{lpmln2problog}}}$ and afterward runs a problog solver. This method can be used for both MPE and marginal inference. In fact, it can leverage all solving modes and options of a ProbLog solver. In Figure 1, it is represented by the purple arrow. The Translator component takes as input a $\textit{Lpmln}^{\pm }$ program and uses the meta-programming option –output=reify of clingo (Reference Kaminski, Romero, Schaub and WankoKaminski et al., 2023) to ground and reify that program into a list of facts. Then, in our first approach, we just combined those facts with a ProbLog meta-encoding implementing the translation ${{\mathit{lpmln2problog}}}$ . While this approach was very elegant, it turned out to be inefficient, because problog 2.2 needed too much time to ground the meta-encoding. Perhaps a more experienced ProbLog programmer could develop a more performant meta-encoding.Footnote ⁵ In our case, we decided to move the grounding efforts to clingo. We developed a meta-encoding that implements the translation ${{\mathit{lpmln2problog}}}$ , but replaces the ProbLog’s probabilistic facts of the form $p :: a$ by ASP facts of the form $prob(p,a)$ . This meta-encoding, together with the reified program, is grounded by clingo using option –text, resulting in a ground normal logic program. The final ProbLog program is the combination of this program with a small ProbLog meta-encoding that creates the corresponding probabilistic facts given the atoms $\mathit{prob}(p,a)$ . This is the approach that is actually implemented in plingo. We would like to highlight that, although in Section 3.2 we have defined the translation ${{\mathit{lpmln2problog}}}$ only for normal logic programs, the actual implementation in plingo covers the whole non-disjunctive part of the clingo language (Reference Calimeri, Faber, Gebser, Ianni, Kaminski, Krennwallner, Leone, Maratea, Ricca and SchaubCalimeri et al., 2020). Furthermore, the meta-encoding has been optimized to minimize the number of new atoms that it introduces. For example, for programs that follow the Generate, Define, and Test methodology (Reference LifschitzLifschitz, 2002) of ASP, the meta-encoding only introduces the atoms $a^{\prime}$ of the translation for those original atoms $a$ that are not generated by the choice rules and do occur in soft formulas.

6 Experiments

In this section, we experimentally evaluate the three solving methods of plingo version 1.1 and compare them to native implementations of Lpmln, ProbLog, and P-log.Footnote ⁶ For Lpmln, we evaluate the system lpmln2asp (Reference Lee, Talsania and WangLee et al., 2017) that is the foundation of the basic implementation of plingo. For ProbLog, we consider the problog system version 2.2.2 (Reference Fierens, den Broeck, Renkens, Shterionov, Gutmann, Thon, Janssens and RaedtFierens et al., 2015) that implements various methods for probabilistic reasoning. In the experiments, we use one of those methods that is designed specifically to answer probabilistic queries. It converts the input program to a weighted Boolean formula and then applies a knowledge compilation method for weighted model counting. For P-log, we evaluate two implementations, which we call plog-naive and plog-dco (Reference BalaiiBalaii, 2017). While the former works like plingo and lpmln2asp by enumerating stable models, the latter implements a different algorithm that builds a computation tree specific to the input query. All benchmarks were run on an Intel $^{\textrm{{TM}}}$ Xeon E5-2650v4 under Debian GNU/Linux 10, with 24 GB of memory and a timeout of 1200s per instance.

We have performed three experiments. In the first one, our goal is to evaluate the performance of the three solving methods of plingo and compare it to the performance of all the other systems on the same domain. In particular, we want to analyze the solving time and the accuracy of the approximation method for different values of the input parameter $k$ , and we want to compare the problog-based method of plingo with the system problog running an original ProbLog encoding. In the second experiment, our goal is to compare plingo with the implementations of P-log on domains that are specific to this language. Finally, the goal of the third experiment is to compare plingo and lpmln2asp on the task of MPE inference. In particular, in this case, the basic implementation of plingo and the implementation of lpmln2asp are very similar and boil down to a single call to clingo. Here, we would like to evaluate if in this situation there is any difference in performance between both approaches.

In the first experiment, we compare all systems on the task of marginal inference with respect to a query in a probabilistic Grid domain from Reference ZhuZhu (2012),which appeared in a slightly different form in Reference Fierens, den Broeck, Renkens, Shterionov, Gutmann, Thon, Janssens and RaedtFierens et al. (2015). We have chosen this domain because it can be easily and similarly represented in all these probabilistic languages, which is required if we want to compare all systems in terms of a single benchmark. In this domain, there is a grid of size $m \times n$ , where each node $(i,j)$ passes information to the nodes $(i+1,j)$ and $(i,j+1)$ if $(i,j)$ is not faulty, and each node in the grid can be faulty with probability $0.1$ . The task poses the following question: what is the probability that node $(m,n)$ receives information from node $(1,1)$ ? To answer this, we run exact marginal inference with all approaches, and approximate marginal inference with plingo for different values of $k$ : $10^1$ , $10^2$ , …, and $10^6$ . The results are shown in Figure 2. On the left side, there is a cactus plot representing how many instances were solved within a given runtime. The dashed lines represent the runtimes of approximate marginal inference in plingo for $k=10^5$ and $k=10^6$ . Among the exact implementations, problog and the problog-based method of plingo are the clear winners. Their solving times are almost the same, showing that in this case the translation generated by plingo does not incur in any additional overhead. The specific algorithm of problog for answering queries is much faster than the other exact systems that either have to enumerate all stable models or, in the case of plog-dco, may have to explore its whole solution tree. The runtimes among the rest of the exact systems are comparable, but plingo is a bit faster than the others. For the approximation method, on the right side of Figure 2, for every value of $k$ and every instance, there is a dot whose coordinates represent the probability calculated by the approximation method and the true probability (calculated by problog). This is complemented by Table 1 that shows the average absolute error and the maximal absolute error for each value of $k$ in $\%$ , where the absolute error for some instance and some $k$ in $\%$ is defined as the absolute value of the difference between the calculated probability and the true probability for that instance, multiplied by $100$ . We can see that, as the value of $k$ increases, the performance of the approximation method deteriorates, while the quality of the approximated probabilities increases. A good compromise is found for $k=10^5$ , where the runtime is better than problog, and the average error is below $1\%$ .

Table 1. Average and maximal error (in $\%$ ) of the approximation method on the Grid domain for different values of $k$

Fig 2. Runtimes of all systems and quality of the approximation method on the Grid domain.

In the second experiment, we compare the performance of the two exact methods of plingo using the P-log frontend with the two native implementations of that language, on tasks of marginal inference with respect to a query in three different domains: NASA, Blocks, and Squirrel. The NASA domain (Reference BalaiiBalaii, 2017) involves logical and probabilistic reasoning about the faults of a control system. For this domain, there are only three instances. All of them are solved by basic plingo in about a second, while problog-based plingo takes between $1$ and $80$ s, plog-naive between $1$ and $5$ s, and plog-dco between $40$ and $100$ se. The Blocks domain (Reference ZhuZhu, 2012) starts with a grid and a set of $n$ blocks and asks what is the probability that two locations are still connected after the $n$ blocks have been randomly placed on the grid. In the experiments, we use a single map of $20$ locations and vary $n$ between $1$ and $5$ . The results are shown in Figure 3, where we can see a similar pattern as in the NASA domain: basic plingo and plog-naive solve all instances in just a few seconds, while plog-dco needs much more time for the bigger instances, and plingo combined with problog times out in all instances. The Squirrel domain (Reference Baral, Gelfond and RushtonBaral et al., 2009; Reference BalaiiBalaii, 2017) is an example of Bayesian learning, where the task is to update the probability of a squirrel finding some food in a patch on day $n$ after failing to find it on the first day. In the experiments we vary the number of days $n$ between $1$ and $27$ . The results are shown in Figure 3. In this domain, problog-based plingo can solve instances for up to $16$ days, while plog-naive can solve instances for up to $23$ days, and plingo and plog-dco can solve instances for up to $27$ days. To interpret the results, recall that the underlying algorithms of plog-naive and plingo are very similar. Hence, we conjecture that the better performance of plingo is due to details of the implementation. On the other hand, plog-dco uses a completely different algorithm. According to the authors (Balaii, Reference Balaii2017), this algorithm should be faster than plog-naive when the value of the query can be determined from a partial assignment of the atoms of the program. This may be what is happening in the Squirrel domain, where it is on par with plingo, while it does not seem to be the case for the other domains. We hoped that the problog-based method would allow plingo to solve faster the P-log benchmarks, but the results are in the opposite direction. In these domains, clingo generates relatively big ground programs in a short time, and then ProbLog’s solving components take a long time to reason about those programs.

Fig 3. Runtimes of plingo, plog-naive and plog-dco on the P-log domains.

In the third experiment, we compare the performance of the exact methods of plingo using the Lpmln frontend with the system lpmln2asp on tasks of MPE inference in two domains: Alzheimer and Smokers. The goal in the Alzheimer domain (Reference Raedt, Kimmig and ToivonenRaedt et al., 2007) is to determine the probability that two edges are connected in a directed probabilistic graph based on a real-world biological dataset of Alzheimer genes (Shterionov, Reference Shterionov2015).Footnote ⁷ The data consists of a directed probabilistic graph with 11530 edges and 5220 nodes. In the experiments we select different subgraphs of this larger graph, varying the number of nodes from $100$ to $2800$ . The results are shown in Figure 4, where we observe that problog-based plingo is slower than the other two methods, which behave similarly except on some instances of middle size and which can be solved by lpmln2asp but not by basic plingo. The Smokers domain involves probabilistic reasoning about a network of friends. Originally it was presented in Reference Domingos, Kok, Lowd, Poon, Richardson and SinglaDomingos et al. (2008), but we use a slightly simplified version from (Reference Lee, Talsania and WangLee et al., 2017). In the experiments we vary the number of friends in the network. In Figure 4, we can observe that basic plingo is the fastest, followed by lpmln2asp and then by problog-based plingo. Given that the underlying algorithms of basic plingo and lpmln2asp are similar, we expected them to have a similar performance. Looking at the results, we have no specific explanation for the differences in some instances of the Alzheimer domain, and we conjecture that they are due to the usual variations in solver performance. On the Smokers domain, the worse performance of lpmln2asp seems to be due to the usage of an external parser that increases a lot the preprocessing time for the bigger instances. With respect to problog-based plingo, in both domains, it spends most of its time grounding the translation with clingo, which seems to explain its worse performance.

Fig 4. Runtimes of plingo and lpmln2asp on the Lpmln domains.