Knowledge Compilation of Logic Programs Using ... - UCLA CS

Under consideration for publication in Theory and Practice of Logic Programming

1

Knowledge Compilation of Logic Programs Using Approximation Fixpoint Theory Bart Bogaerts and Guy Van den Broeck Department of Computer Science, KU Leuven, Belgium (e-mail: [email protected],[email protected]) submitted 1 January 2003; revised 1 January 2003; accepted 1 January 2003

Abstract Recent advances in knowledge compilation introduced techniques to compile positive logic programs into propositional logic, essentially exploiting the constructive nature of the least fixpoint computation. This approach has several advantages over existing approaches: it maintains logical equivalence, does not require (expensive) loop-breaking preprocessing or the introduction of auxiliary variables, and significantly outperforms existing algorithms. Unfortunately, this technique is limited to negation-free programs. In this paper, we show how to extend it to general logic programs under the well-founded semantics. We develop our work in approximation fixpoint theory, an algebraical framework that unifies semantics of different logics. As such, our algebraical results are also applicable to autoepistemic logic, default logic and abstract dialectical frameworks.

1 Introduction There is a fundamental tension between the expressive power of a knowledge representation language, and its support for efficient reasoning. Knowledge compilation studies this tension (Cadoli and Donini, 1997; Darwiche and Marquis, 2002), by identifying languages that support certain queries and transformations efficiently. It studies the relative succinctness of these languages, and is concerned with building compilers that can transform knowledge bases into a desired target language. For example, after compiling two CNF sentences into the OBDD language (Bryant, 1986), their equivalence can be checked in polynomial time. Applications of knowledge compilation are found in diagnosis (Huang and Darwiche, 2005), databases (Suciu et al., 2011), planning (Palacios et al., 2005), graphical models (Chavira and Darwiche, 2005; Fierens et al., 2015) and machine learning (Lowd and Domingos, 2008). These techniques are most effective when the cost of compilation can be amortised over many queries to the knowledge base. Knowledge compilation has traditionally focused on subsets of propositional logic and Boolean circuits in particular (Darwiche and Marquis, 2002; Darwiche, 2011). Logic programs have received much less attention, which is surprising given their historical significance in AI and current popularity in the form of answer set programming (ASP) (Marek and Truszczy´ nski, 1999). Closest in spirit are techniques to encode logic programs into CNF (Ben-Eliyahu and Dechter, 1994; Lin and Zhao, 2003, 2004; Janhunen, 2004, 2006). A notable difference with traditional knowledge

2

B. Bogaerts and G. Van den Broeck

compilation is that many of these encodings are task-specific: the resulting CNF is not equivalent to the logic program. Instead, it is equisatisfiable for the purpose of satisfiability checking, or has an identical model count for the purpose of probabilistic inference (Fierens et al., 2015).1 These encodings often introduce new variables and loop-breaking formulas, which blow up the representation. Lifschitz and Razborov (2006) showed that there can be no polynomial translation of ASP into a flat propositional logic theory without auxiliary variables.2 Recently, Vlasselaer et al. (2015) introduced a novel knowledge compilation technique for positive logic programs. As an example, consider the logic program P defining the transitive closure r of a binary relation e: ) ( ∀X, Y : r (X, Y ) ← e(X, Y ). ∀X, Y, Z : r (X, Y ) ← e(X, Z) ∧ r (Z, Y ). Intuitively, Vlasselaer et al. (2015) compute the minimal model of P for all interpretations of e(·, ·) simultaneously. They define a lifted least fixpoint computation where the intermediate results are symbolic interpretations of r (·, ·) in terms of e(·, ·). For example, in a domain {a, b, c}, the interpretation of r (a, b) in the different steps of the least fixpoint computation would be. r (a, b) :

f

e(a, b)

e(a, b) ∨ (e(a, c) ∧ e(c, b))

I.e., initially, r(a, b) is false; next r(a, b) is derived to be true if e(a, b) holds; finally, r(a, b) also holds if e(a, c) and e(c, b) hold. The result of this sequence is a symbolic, Boolean formula representation of the well-founded model for each interpretation of e; this formula can be used for various inference tasks. This approach has several advantages over traditional knowledge compilation methods: it preserves logical equivalence3 (and hence, enables us to port any form of inference—e.g., abductive or inductive reasoning, (weighted) model counting, query answering, . . . ) and does not require (expensive) loop-breaking preprocessing or auxiliary variables. Vlasselaer et al. (2015) showed that this method for compiling positive programs (into the SDD language (Darwiche, 2011)) significantly outperforms traditional approaches that compile the completion of the program with added loop-breaking formulas. Unfortunately, the methods of Vlasselaer et al. (2015) do not work in the presence of negation, i.e., if the immediate consequence operator is non-monotone. In this paper, we show how the well-founded model computation from Van Gelder et al. (1991), that works on partial interpretations, can be executed symbolically, resulting in the parametrised well-founded model. By doing this, we essentially compute the well-founded model of an exponential number of logic programs at once. Our algorithm works in principle on any representation of Boolean formulas; we study complexity for this algorithm taking Boolean circuits as target language; 1 2 3

Probabilistic inference on the CNF may itself perform a second knowledge compilation step. Similar, task-specific, translation techniques of logic programs into difference logic (Janhunen et al., 2009) and ordered completion (Asuncion et al., 2012) exist. In the sense that an interpretation is a model of the resulting propositional theory if and only if it is a model of the given logic program under the parametrised well-founded semantics.

Knowledge Compilation of Logic Programs Using AFT

3

in this case we find that our algorithm has polynomial time complexity. General Boolean circuits are not considered to be an interesting target language, as they are not tractable for any query of interest. However, what we achieve here is a change of semantic paradigm that uncovers all the machinery for propositional logic (SAT solvers, model counters, etc.). It is a required step before further compiling the circuit into a language such as OBDD or SDD, which do permit tractable querying. It is also possible to encode the circuit into CNF, similar to Janhunen (2004). There is a long list of queries and transformations that become supported on logic programs (under the well-founded semantics), by virtue of our algorithm. After a transformation to propositional logic, we can use standard tools to check whether one logic program is entailed by another, find models that are minimal with respect to some optimisation term, check satisfiability, count or enumerate models, and forget or condition variables (Darwiche and Marquis, 2002). For example, the following definition of the transitive closure of e syntactically differs from the previous. ( ) ∀X, Y : r (X, Y ) ← e(X, Y ). ∀X, Y, Z : r (X, Y ) ← r (X, Z) ∧ r (Z, Y ). With our algorithm, we can compile both programs into an OBDD representation. On these OBDDs, we can verify the equivalence of the logic programs using existing OBDD algorithms. As logic programs under the well-founded semantics encode inductive definitions (Denecker and Vennekens, 2014), we now have the machinery to check that two definitions define the same concept for each interpretation of the parameters (e in our example). Moreover, our algorithm can be stopped at any time to obtain upper and lower bounds on the fixpoint, which gives us approximate knowledge compilation for logic programs (Selman and Kautz, 1996). The original motivation for this research is the fact that probabilistic inference tools such as ProbLog (Fierens et al., 2015) use knowledge compilation for probabilistic inference by (weighted) model counting; they compile a logic program into a d-DNNF or SDD (with auxiliary variables) and subsequently calling a weighted model counter. Vlasselaer et al. showed that for positive logic programs, this can be done much more efficiently using bottom-up compilation techniques. We extend these techniques to general logic programs to capture the full ProbLog language. More generally, we develop our ideas in approximation fixpoint theory (AFT), an abstract algebraical theory that captures all common semantics of logic programming, autoepistemic logic, default logic, Dung’s argumentation frameworks and abstract dialectical frameworks (as shown by Denecker et al. (2000) and Strass (2013)). Afterwards, we show how the algebraical results apply to logic programming. We thus extend the ideas by Vlasselaer et al. (2015) in two ways; first, by developing a theory that works for general logic programs and secondly by lifting the theory to the algebraical level. Due to the high level of abstraction, our proofs are (relatively) compact and our algebraical results are immediately applicable to all aforementioned paradigms. Due to page restrictions, proofs are postponed to Appendix B and we only apply our theory to logic programming. Summarised, the main contributions of this paper are as follows: (i) we present

4


the algebraical foundations for a novel knowledge compilation technique for general logic programs, (ii) we apply the algebraical theory to logic programming, resulting in a family of equivalence-preserving algorithms, (iii) we show that Boolean circuits are at least as succinct as propositional logic programs (under the parametrised well-founded semantics), and (iv) we pave the way towards knowledge compilation for other non-monotonic formalisms, such as autoepistemic logic.

2 Preliminaries 2.1 Lattices and Approximation Fixpoint Theory A complete lattice hL, ≤i is a set L equipped with a partial order ≤ such that W every subset S of L has a least upper bound, denoted S and a greatest lower V bound, denoted S. If x and y are two lattice elements, we use the notations V W x ∧ y = {x, y} and x ∨ y = {x, y}. A complete lattice has a least element ⊥ and a greatest element >. An operator O : L → L is monotone if x ≤ y implies that O(x) ≤ O(y). Every monotone operator O in a complete lattice has a least fixpoint, denoted lfp(O). A mapping f : (L, ≤L ) → (K, ≤K ) between lattices is a lattice morphism if it preserves least upper bounds and greatest lower bounds, i.e. W W V V if for every subset X of L, f ( X) = f (X) and f ( X) = f (X). Given a lattice, approximation fixpoint theory makes uses of the bilattice L2 . We define projections as usual: (x, y)1 = x and (x, y)2 = y. Pairs (x, y) ∈ L2 are used to approximate all elements in the interval [x, y] = {z | x ≤ z ∧ z ≤ y}. We call (x, y) ∈ L2 consistent if x ≤ y, that is, if [x, y] is non-empty. We use Lc to denote the set of consistent pairs. Pairs (x, x) are called exact. The precision ordering on L2 is defined as (x, y) ≤p (u, v) if x ≤ u and v ≤ y. In case (u, v) is consistent, (x, y) is less precise than (u, v) if (x, y) approximates all elements approximated by (u, v), or in other words if [u, v] ⊆ [x, y]. If L is a complete lattice, then so is hL2 , ≤p i. AFT studies fixpoints of operators O : L → L through operators approximating O. An operator A : L2 → L2 is an approximator of O if it is ≤p -monotone, and has the property that for all x, O(x) ∈ A(x, x). Approximators are internal in Lc (i.e., map Lc into Lc ). As usual, we restrict our attention to symmetric approximators: approximators A such that for all x and y, A(x, y)1 = A(y, x)2 . Denecker et al. (2004) showed that the consistent fixpoints of interest are uniquely determined by an approximator’s restriction to Lc , hence, we only define approximators on Lc . AFT studies fixpoints of O using fixpoints of A. The A-Kripke-Kleene fixpoint is the ≤p -least fixpoint of A and has the property that it approximates all fixpoints of O. A partial A-stable fixpoint is a pair (x, y) such that x = lfp(A(·, y)1 ) and y = lfp(A(x, ·)2 ). The A-well-founded fixpoint is the least precise partial A-stable fixpoint. An A-stable fixpoint of O is a fixpoint x of O such that (x, x) is a partial Astable fixpoint. The A-Kripke-Kleene fixpoint of O can be constructed by iteratively applying A, starting from (⊥, >). For the A-well-founded fixpoint, Denecker and Vennekens (2007) worked out a similar constructive characterisation as follows. An A-refinement of (x, y) is a pair (x0 , y 0 ) ∈ L2 satisfying one of the following conditions (i) (x, y) ≤p (x0 , y 0 ) ≤p A(x, y), or (ii) x0 = x and A(x, y 0 )2 ≤ y 0 ≤ y. An


5

A-refinement is strict if (x, y) 6= (x0 , y 0 ). We call refinements of the first kind application refinements and refinements of the second kind unfoundedness refinements. A well-founded induction of A is a sequence (xi , yi )i≤β with β an ordinal such that • (x0 , y0 ) = (⊥, >); • (xi+1 , yi+1 ) is an A-refinement of (xi , yi ), for all i < β; W • (xλ , yλ ) = ≤p {(xi , yi ) | i < λ} for each limit ordinal λ ≤ β. A well-founded induction is terminal if its limit (xβ , yβ ) has no strict A-refinements. For a given approximator A, there are many different terminal well-founded inductions of A. Denecker and Vennekens (2007) showed that they all have the same limit, which equals the A-well-founded fixpoint of O. Denecker and Vennekens (2007) also showed how to obtain maximally precise unfoundedness refinements. Proposition 2.1 (Denecker and Vennekens, 2007 ) x Let A be an approximator of O and (x, y) ∈ L2 . Let SA be the operator on L that 0 0 maps every y to A(x, y )2 . This operator is monotone. The smallest y 0 such that x ). (x, y 0 ) is an unfoundedness refinement of (x, y) is given by y 0 = lfp(SA 2.2 Logic Programming In this paper, we restrict our attention to propositional logic programs. However, AFT has been applied in a much broader context (Denecker et al., 2000; Pelov et al., 2007; Antic et al., 2013) and our results apply in these richer settings as well. Let Σ be an alphabet, i.e., a collection of symbols called atoms. A literal is an atom p or its negation ¬p. A logic program P is a set of rules r of the form h ← l1 ∧ l2 ∧ · · · ∧ ln , where h is an atom called the head of r, denoted head (r), and the li are literals. The formula l1 ∧ l2 ∧ · · · ∧ ln is the body of r, denoted body(r). A rule r = ∀X : h ← ϕ is, as usual, a shorthand for the grounding of r, the collection of rules obtained by substituting the variables X by elements from a given domain. W If p ∈ Σ, the formula ϕp is r∈P∧head(r)=p body(r). An interpretation I of the alphabet Σ is an element of 2Σ , i.e., a subset of Σ. The set of interpretations 2Σ forms a lattice equipped with the order ⊆. The truth value (t or f ) of a propositional formula ϕ in a structure I, denoted ϕI is defined as usual. With a logic program P, we associate an immediate consequence operator (van Emden and Kowalski, 1976) TP mapping structure I to TP (I) = {p | ϕIp = t}. 2 In the context of logic programming, elements of the bilattice 2Σ are fourvalued interpretations, pairs I = (I1 , I2 ) of interpretations. A four-valued interpretation maps atoms p ∈ Σ to tuples of two truth values (pI1 , pI2 ). Such tuples are often identified with four-valued truth values (true (t), false (f ), unknown (u) and inconsistent (i)). Intuitively, pI1 represents whether p is true, and pI2 whether p is possible, i.e., not false. Thus, the following correspondence holds t = (t, t), f = (f , f ), u = (f , t) (and i = (t, f )). The pair (I1 , I2 ) approximates all interpretations I 0 with I1 ⊆ I 0 ⊆ I2 . We are mostly concerned with consistent (also called partial) interpretations: tuples (I1 , I2 ) with I1 ⊆ I2 , i.e., interpretations that map no atoms to i. If I is a partial interpretation, and ϕ a formula, we write

6


ϕI for the standard three-valued valuation based on Kleene’s truth tables (Kleene, 1938). We often identify interpretation I with the partial interpretation (I, I). The most common approximator for logic programs is Fitting’s (2002) immediate consequence operator ΨP , a generalisation of TP to partial interpretations: ΨP (I)1 = {a ∈ Σ | ∃r ∈ P : body(r)I = t ∧ head(r) = a}, ΨP (I)2 = {a ∈ Σ | ∃r ∈ P : body(r)I 6= f ∧ head(r) = a} Denecker et al. (2000) showed that the ΨP -well-founded fixpoint of TP is the wellfounded model of P (Van Gelder et al., 1991) and that ΨP -stable fixpoints are exactly the stable models of P (Gelfond and Lifschitz, 1988). Parametrised Logic Programs We briefly recall the parametrised well-founded semantics. This semantics has been implicitly present in the literature for a long time, by assigning a meaning to an intensional database. We follow the formalisation by Denecker and Vennekens (2007). For parametrised logic programs, the alphabet Σ is partitioned into a set Σp of parameter symbols and a set Σd of defined symbols. Only defined symbols occur in heads of rules. Given a Σp -interpretation I, P defines an immediate consequence operator TPI : 2Σd → 2Σd equal to TP except that the value of atoms in Σp is fixed to their value in I. Similarly, Fitting’s immediate consequence operator ΨIP induces an operator on (2Σd )2 . J is a model 4 of P under the parametrised well-founded semantics (denoted J |=wf P) if J ∩ Σd is the J∩Σ J∩Σ ΨP p -well-founded fixpoint of TP p . By adding a probability distribution over the parameter symbols, we obtain the ProbLog language (Fierens et al., 2015). 3 Algebraical Theory In this section we develop the algebraical foundations of our techniques. We follow the intuitions presented in the introduction: we define one operator that “summarises” an entire family operators (these will be immediate consequence operators for different interpretations of the parameter symbols). We study the relationship between the well-founded fixpoint of the summarising operator and the original operators. Before formally introducing parametrisations, we focus on a simpler situation: we show that surjective lattice morphisms preserve the well-founded fixpoint. 3.1 Surjective Lattice Morphisms Definition-Proposition 3.1 Let O : L → L be an operator and f : L → K a lattice morphism. We say that O respects f if for every x, y ∈ L with f (x) = f (y), it holds that f (O(x)) = f (O(y)). If f is surjective and O respects f , then there exists a unique operator Of : K → K with Of ◦ f = f ◦ O, which we call the projection of O on K. 4

Note that this definition of model differs from the traditional definition of model of a logic program. To emphasise this difference, we use J |=wf P to refer to the parametrised wellfounded semantics and J |= T for the satisfaction relation of propositional logic.


7

If f : L → K is a lattice morphism, f 2 : L2 → K 2 : (x, y) 7→ (f (x), f (y)) is a lattice morphism from the bilattice L2 to the bilattice K 2 . Definition 3.2 Let A : L2 → L2 be an approximator and f : L → K a lattice morphism. We say that A respects f if A respects f 2 in the sense of Definition 3.1. Furthermore, if f is surjective, we define the projection of A on K as the unique operator Af : K 2 → K 2 with Af ◦ f 2 = f 2 ◦ A. Below, we assume that f : L → K is a surjective lattice morphism, that O : L → L f # / / hK, ≤i z Of O hL, ≤i is an operator and A : L2 → L2 an approximator of O such that both O and A respect x & 2 f2 f (see Figure 1). Intuitively elements of L A / / hK 2 , ≤p i Af hL , ≤p i can be thought of as symbolic representaFig. 1. Overview of the operators tions of interpretations, while the elements of K are classical interpretations. The following proposition explicates the relationship between well-founded inductions in L and in K. This proposition immediately leads to a relationship between the A-well-founded model of O and the Af -well-founded model of Of . Proposition 3.3 If (xj , yj )j≤α is a well-founded induction of A, then (f (xj ), f (yj ))j≤α is a wellfounded induction of Af . If (xj , yj )j≤α is terminal, then so is (f (xj ), f (yj ))j≤α . Theorem 3.4 If (x, y) is the A-well-founded fixpoint of O, then, (f (x), f (y)) is the Af -well-founded fixpoint of Of . 3.2 Parametrisations Definition 3.5 Let L and K be lattices. Suppose (fi : L → K)i∈I is a family of surjective lattice morphisms. We call L a parametrisation of K (through (fi )i∈I ) if for every x, y ∈ L it holds that x ≤ y if and only if for every i ∈ I, fi (x) ≤ fi (y). A parametrisation L of a lattice K can be used to “summarise” multiple operators (the Ofi ) on K by means of a single operator O on L which abstracts away certain details. In the next section, we use this to compute a symbolic representation of the parametrised well-founded model. Theorem 3.6 Suppose L is a parametrisation of K through (fi )i∈I . Let O : L → L be an operator and A an approximator of O such that both O and A respect each of the fi . If (x, y) is the A-well-founded fixpoint of O, the following hold. 1. For each i, (fi (x), fi (y)) is the Afi -well-founded fixpoint of Ofi . 2. If the Afi -well-founded fixpoint of Ofi is exact for every i, then so is the A-well-founded fixpoint of O.

8

B. Bogaerts and G. Van den Broeck 4 Operator-Based Knowledge Compilation

We assume throughout this section that P refers to a parametrised logic program with parameters Σp and defined symbols Σd . In order to apply our theory to logic programming, we will define an operator (and approximator) that summarises the immediate consequence operators of P for all Σp -interpretations. Partial interpretations map defined atoms to a tuple (t, p) of two-valued truth values. We generalise this type of interpretations: we want (partial) interpretations to be parametrised in terms of the parameters of the logic program. Instead of assigning a tuple (t, p) of Boolean values to each atom, we will hence assign a tuple of two propositional formulas over Σp to each atom in Σd . In order to avoid redundancies, we work modulo equivalence. Let LΣp be the language of all propositional formulas over vocabulary Σp . If ϕ is a propositional formula, we use ϕ¯ to denote the equivalence class of ϕ, i.e., the set of propositional formulas equivalent to ϕ.5 Let Lp be the set of equivalence classes of elements in LΣp . We define an order ≤Lp on Lp as follows: ϕ¯ ≤Lp ψ¯ if ϕ entails ψ (in standard propositional logic). This order is well-defined (independent of the choice of representatives ϕ and ψ); with this order, Lp is a complete lattice. Boolean operations on Lp are defined by applying them to representatives. Definition 4.1 A symbolic interpretation of Σd in terms of Σp is a mapping Σd → Lp . The symbolic interpretation lattice Ldp is the set of all symbolic interpretations of Σd in terms of Σp . The order ≤ on Ldp is the pointwise extension of ≤Lp . A partial symbolic interpretation is an element of the bilattice (t, p) ∈ (Ldp )2 such that t ≤ p. The condition t ≤ p in Definition 4.1 excludes inconsistent interpretations. If Σp is the empty vocabulary (i.e., if P has no parameters), then the lattice Lp is {¯f , ¯t} with order ¯f ≤ ¯t. Hence, in this case, a (partial) symbolic interpretation is “just” a (partial) interpretation. As with classical interpretations, we often identify a symbolic interpretation A with the partial symbolic interpretation (A, A). Intuitively, a (partial) symbolic interpretation summarises many different classical (partial) interpretations; when we instantiate such as (partial) symbolic interpretation with a Σp -interpretation, we obtain a unique (partial) Σd -interpretation. The following definition formalises this intuition. Definition 4.2 If S = (At , Ap ) is a partial symbolic interpretation and I is a Σp -interpretation, the concretisation of S by I is the partial interpretation S I such that for every symbol a ∈ Σd with At (a) = ϕt and Ap (a) = ϕp , it holds that S I (a) = (ϕIt , ϕIp ). The above concept is well-defined (independent of the choice of representatives ϕt en ϕp ). A symbolic interpretation can thus be seen as a mapping from Σp interpretations to Σd -interpretations. This kind of mapping is of particular interest, since the parametrised well-founded semantics induces a similar mapping: it 5

Notice that a ¯ is not the negation of an atom a. We use ¬a for the negation of a.


9

associates with every Σp -interpretation a Σd -interpretation, namely the ΨIP -wellfounded model of TPI . It is this relationship between Σp - and Σd -interpretations that we wish to capture in propositional logic. Furthermore, as explained below, it is easy to translate a symbolic interpretation into propositional logic. Definition 4.3 Let A be a symbolic interpretation and ψp a representative of A(p) for each p ∈ Σd . V We call a propositional theory T a theory of A if it is equivalent to p∈Σd p ⇔ ψp . All theories of A are equivalent. We sometimes abuse notation and refer to the theory of A, denoted Th(A), to refer to any theory from this class. The goal now is to find a symbolic interpretation A such that Th(A) is equivalent to P. Our choice of representatives will depend on the target language of the compilation. The value of a propositional formula ϕ in a partial interpretation I is an element of {t, f , u} (or, a tuple of two Booleans) obtained by standard three-valued valuation. This can easily be extended to symbolic interpretations, where the value of a formula in a (partial) symbolic interpretation is a tuple of two Σp formulas. Definition 4.4 Let ϕ be a Σ-formula and S = (At , Ap ) a partial symbolic interpretation. The value of ϕ in S is a tuple (ϕt , ϕp ) ∈ L2p defined inductively as follows: • • • •

p(At ,Ap ) = (¯ p, p¯) if p ∈ Σp and p(At ,Ap ) = (At (p), Ap (p)) if p ∈ Σd , (At ,Ap ) (ψ ∧ξ) = (ψt ∧ ξt , ψp ∧ ξp ) if ψ (At ,Ap ) = (ψt , ψp ) and ξ (At ,Ap ) = (ξt , ξp ) (At ,Ap ) (ψ ∨ξ) = (ψt ∨ ξt , ψp ∨ ξp ) if ψ (At ,Ap ) = (ψt , ψp ) and ξ (At ,Ap ) = (ξt , ξp ) (At ,Ap ) (¬ψ) = (¬ψp , ¬ψt ) if ψ (At ,Ap ) = (ψt , ψp ).

Evaluation of formulas has some nice properties. It commutes with concretisation (Proposition 4.5) and induces a parametrisation (Proposition 4.6). Proposition 4.5 I For every formula ϕ over Σ, S ∈ (Ldp )2 and I ∈ 2Σp , it holds that ϕS = (ϕS )I . Proposition 4.6 The lattice Ldp is a parametrisation of 2Σd through the mappings (πI : Ldp → 2Σd : A 7→ AI )I∈2Σp . Recall from Section 2.2 that ϕp is the disjunction of all bodies of rules defining p; using this we can generalise both TP and ΨP to a symbolic setting. Definition 4.7 The partial parametrised immediate consequence operator ΨP : (Ldp )2 → (Ldp )2 is defined by ΨP (S)(p) = ϕSp for every p ∈ Σd . The parametrised immediate consequence operator is the operator TP : Ldp → Ldp that maps A to TP (A), where TP (A)(p) = ϕA p for each p ∈ Σd . It deserves to be noticed that the operator TP almost coincides with the operator TcP defined by Vlasselaer et al. (2015) (the only difference is that we work modulo equivalence). The following proposition, which follows easily from our algebraical theory, shows correctness of the methods developed by Vlasselaer et al. (2015).

10


Theorem 4.8 If P is a positive logic program, then TP is monotone. For every Σ-interpretation I, it then holds that I |=wf P if and only if I |= Th(lfp(TP )). Theorem 4.9 For any parametrised logic program P, the following hold: 1. ΨP is an approximator of TP . 2. For every Σp -structure I, it holds that ΨIP ◦ πI2 = πI2 ◦ ΨP . Definition 4.10 Let P be any parametrised logic program. The parametrised well-founded model of P is the ΨP -well-founded fixpoint of TP . Applying Theorem 3.4, combined with Proposition 4.5 and Theorem 4.9 yields: Theorem 4.11 If the parametrised well-founded model of P is exact, i.e., of the form (A, A) for some symbolic interpretation A, then for every Σ-interpretation I, it holds that I |=wf P if and only if I |= Th(A). Example 4.12 We illustrate the various concepts introduced above on the smokers problem, a popular problem in probabilistic logic programming. Consider a group of people. A person of this group smokes if he is stressed, or if he is friends with a smoker. This results in the following logic program Ps with a domain of three people {a, b, c}: ∀X : smokes(X) ← stress(X) ∀X, Y : smokes(X) ← fr (X, Y ) ∧ smokes(Y ) This program has parameters stress(·) and fr (·, ·) and defined symbols smokes(·). The parametrised well-founded model of Ps is the symbolic interpretation As : Σd → Lp : such that As (smokes(a)) =stress(a) ∨ (stress(b) ∧ fr (a, b)) ∨ (stress(c) ∧ fr (a, c)) ∨(stress(c) ∧ fr (b, c) ∧ fr (a, b)) ∨(stress(b) ∧ fr (c, b) ∧ fr (a, c)) and symmetrical equations hold for smokes(b) and smokes(c). Notice that Th(As ) is equivalent to Ps , in the sense that J |= Th(As ) if and only if J |=wf Ps . For example, let I be the Σp -interpretation {stress(a), fr (b, a)}. We know that the ΨIPs -well-founded fixpoint of TPI r is I 0 := {smokes(a), smokes(b)}; this equals AIs and I ∪ I 0 is indeed a model of Th(As ). Since Ps is positive, TPs is monotone and its least fixpoint can be computed by iteratively applying the operator TPs starting from the smallest symbolic interpretation; this yields the following sequence (only the value of smokes(a) is explicated;


11

for smokes(b) and smokes(c), similar equations hold): smokes(a) 7→ ¯f

⊥: TPs (⊥) :

smokes(a) 7→ stress(a)

TP2s (⊥) TP3s (⊥)

smokes(a) 7→ stress(a) ∨ (stress(b) ∧ fr (a, b)) ∨ (stress(c) ∧ fr (a, c))

:

As .

=

In Figure 2, a circuit representation of Th(As ) is depicted. In this circuit, the different layers correspond to different steps in the computation of the parametrised well-founded model of Ps . Figure 2 essentially contains proofs of atoms smokes(·); this illustrates that the compiled theory can be used for example for abduction. Th(As ) ∧ ⇔

⇔

smokes(a) TP3s (⊥)

smokes(b) ∨

∧

TP2s (⊥)

∧

∧

∧

∧

∧

∧

TP0s (⊥)

fr (a, b)

∧

∧

∧

∧

∧

stress(b) fr (a, c)

fr (b, a)

∧

∨

f

As (smokes(a))

∧

∨

∨

f

stress(a)

∨ ∧

∨

∨ ∧

smokes(c) ∨

∨ ∧

TP1s (⊥)

⇔

∧

f

As (smokes(b))

stress(c) fr (b, c)

fr (c, a)

As (smokes(c)) fr (c, b)

Fig. 2. A circuit representation of the smokers theory Th(As ) and the different steps in the computation of TPs .

For general logic programs, TP is not guaranteed to be monotone and hence the parametrised well-founded model cannot be computed by iteratively applying TP . Luckily, well-founded inductions provide us with a constructive way to compute it. Example 4.13 Consider a dynamic domain in which two gear wheels are connected. Both wheels can be activated by an external force; since they are connected, whenever one wheel turns, so does the other. Both wheels are connected to a button. If an operator hits the button associated to some gear wheel, this means that he intends the state of the wheel to change (if a wheel was turning, its external force is turned off, if the wheel was standing still, its external force is activated). If the operator does not hit the button, the external force is set to the current state of the wheel. Initially, both

12


external forces are inactive. This situation (limited to two time points) is modelled in the following logic program Pw (turns i (T ) means that wheel i is turning at time point T and button i (T ) means that the button of wheel i is pressed at time T ):   turns 1 (0) ← turns 2 (0) turns 2 (0) ← turns 1 (0)       turns 1 (1) ← turns 2 (1) turns 2 (1) ← turns 1 (1)  turns 1 (1) ← turns 1 (0) ∧ ¬button 1 (0) turns 2 (1) ← turns 2 (0) ∧ ¬button 2 (0)      turns 1 (1) ← ¬turns 1 (0) ∧ button 1 (0) turns 2 (1) ← ¬turns 2 (0) ∧ button 2 (0) This logic program has defined symbols turns · (·) and parameters button · (·). The parametrised well-founded model of Pw is computed by a well-founded induction of ΨPw . We start from the least precise partial symbolic interpretation, i.e., S0 that maps every turns · (·) to (¯f , ¯t). Since S0 is a fixpoint of ΨPw , the only possible type of refinement is unfoundedness refinement, resulting in S1 that maps turns 1 (0) 7→ (¯f , ¯f ) turns 1 (1) 7→ (¯f , ¯t)

turns 2 (0) 7→ (¯f , ¯f ) turns 2 (1) 7→ (¯f , ¯t)

Application refinement then results in the partial symbolic interpretation S2 = ΨPw (S1 ) that maps turns 1 (0) 7→ (¯f , ¯f )

turns 2 (0) 7→ (¯f , ¯f )

turns 1 (1) 7→ (button 1 (0), ¯t)

turns 2 (1) 7→ (button 2 (0), ¯t)

Another application refinement then results in the partial symbolic interpretation S3 = ΨPw (S2 ) that maps turns 1 (0) 7→ (¯f , ¯f )

turns 2 (0) 7→ (¯f , ¯f )

turns 1 (1) 7→ (button 1 (0) ∨ button 2 (0), ¯t) turns 2 (1) 7→ (button 2 (0) ∨ button 1 (0), ¯t) Finally, one last unfoundedness refinement results in the symbolic interpretation Aw that maps turns 1 (0) 7→ ¯f

turns 2 (0) 7→ ¯f

turns 1 (1) 7→ button 1 (0) ∨ button 2 (0)

turns 2 (1) 7→ button 1 (0) ∨ button 2 (0)

In Figure A 1 in Appendix A, a circuit representation of Th(Aw ) is depicted. In this circuit, the different layers correspond to the evolution of the lower bound in different steps in the computation of the parametrised well-founded model of Pw (unfoundedness refinements are not visualised). In Figure A 2, the circuit for this examples with time ranging from 0 to 2 is depicted. Example 4.14 (Example 4.12 continued ) Well-founded inductions also work for positive logic programs. Let S0 denote the least precise partial interpretation. Since Ps is positive, it holds for every i and X that ΨPi (S0 )(smokes(X)) = (TPi (⊥)(smokes(X)), ¯t). s

s

Hence, repeated application refinements yield the partial symbolic interpretation


13

(As , >). One final unfoundedness refinement then results in the parametrised wellfounded model of Ps , namely As . Discussion The condition in Theorem 4.11 naturally raises the question “what happens if the parametrised well-founded model is not exact?”. First of all, our techniques also work in this setting. Indeed, Theorem 3.6 (1) guarantees that instantiating the the parametrised well-founded model of P with a Σp -interpretation I results in the ΨIP -well-founded fixpoint of TPI . Example 4.15 Let PNT be the following logic program a ← ¬b. b ← ¬a. c ← ¬b

c ← e.

d ← a ∧ ¬c.

with parameter symbol e and defined symbols a, b, c and d. The parametrised wellfounded model of PNT is then SNT such that SNT (a) = (f , t)

SNT (b) = (f , t)

SNT (c) = (e, t)

SNT (d) = (f , ¬e)

However, in this text we mainly focus on programs with an exact parametrised well-founded model. Corollary 3.6 guarantees that this condition is satisfied for all logic programs in which the standard well-founded model is two-valued. This kind of programs is common in applications for deductive databases (Abiteboul and Vianu, 1991) and for representing inductive definitions (Denecker and Vennekens, 2014). Classes that satisfy this condition include monotone and (locally) stratified logic programs (Przymusinski, 1988). This restriction is typically not satisfied by ASP programs, where stable semantics is used. However, it deserves to be stressed that there is a strong relationship between ASP programs and logic programs under the parametrised well-founded semantics. Most ASP programs, e.g., those used in ASP competitions, are so-called generate-define-test (GDT) programs. They consist of three modules. A generate module opens the search space (i.e., it introduces parameter symbols); a define module contains inductive definitions for which well-founded and stable semantics coincide (as argued by Denecker and Vennekens (2014)) and a test module consist of constraints. Denecker et al. (2012) have argued that a GDT program is the monotone conjunction of its different modules. Hence, our technique can be used to compile the define part of a GDT program. The example below illustrates that only compiling this part results in an interpretation that captures the meaning of this definition more closely, by preserving more structural information. Example 4.16 (Example 4.15 continued ) The first two rules of PNT encode a choice rule for a (or b). The define module of this program is the program Pdef = b ← ¬a. c ← ¬b c ← e. d ← a ∧ ¬c. with parameter symbols a and e, and defined symbols b, c and d. The parametrised

14


well-founded model of Pdef is the symbolic interpretation Adef such that Adef (b) = ¬a

Adef (c) = a ∨ e

Adef (d) = a ∧ ¬(a ∨ e) = f

As can be seen, the parametrised well-founded model now contains the information that d is false, independent of the value of the parameter symbols (independent of the choice made in the choice rules in the original example). 5 Algorithms Based on the theory developed in the previous section, we now discuss practical algorithms for exact and approximate knowledge compilation of logic programs. 5.1 Exact Knowledge Compilation The definition of a well-founded induction provides us with a fixpoint procedure to compute the parametrised well-founded model. Our algorithms are parametrised by a language L, referred to as the target language; this can be any representation of propositional formulas. We describe our algorithm, which we call Compile(L), as a (non-deterministic) finite-state-machine. A state S consists of an assignment of two formulas St (q) and Sp (q) in L (over vocabulary Σp ) to each atom q ∈ Σd . Hence, a state S corresponds to the partial symbolic interpretation SS = (At , Ap ) such that for each q ∈ Σd , At (q) = St (q) and Ap (q) = Sp (q). The transitions in our finite-state-machine are exactly those tuples of states (S, S0 ) such that SS0 is a ΨP -refinement of SS . We further restrict these transitions to maximally precise transitions: application refinements that refine S to ΨP (S) and unfoundedness refinements as described in Proposition 2.1. Furthermore, we propose to make the resulting finite-statemachine deterministic by prioritising application refinements over unfoundedness refinements since they are cheaper, i.e., they only require one application of ΨP . The final output of Compile(L) is a theory Th(A) in L, where A is the parametrised well-founded model of P. When L denotes Boolean circuits, each application of ΨP adds a layer of Boolean gates over the circuits in Ss . When L denotes a language with a so-called Apply function (Van den Broeck and Darwiche, 2015) (e.g., SDDs), each application of ΨP calls Apply to conjoin or disjoin circuits from Ss . Figure 2 contains an example circuit for the smokers problem (Example 4.12). The different layers in the circuit correspond to different steps in a well-founded induction (or the least fixpoint computation). Our algorithm follows the well-founded induction as described in Example 4.14, by prioritising application refinements over unfoundedness refinements. Similarly, our algorithm also follows the well-founded induction from Example 4.13. During the execution, circuits to represent the upper and lower bounds are gradually built (layer by layer). Theorem 5.1 Let LBC be the language of Boolean circuits. The following hold: (i) Compile(LBC ) has polynomial-time complexity and (ii) the size of the output circuit of Compile(LBC ) is polynomial in the size of P.


15

In the terminology of Darwiche and Marquis (2002), this means that Boolean circuits are at least as succinct as logic programs under the parametrised well-founded semantics. With other languages, for example when L denotes OBDDs or SDDs, our algorithm can take exponential time, and its output can take exponential space in the size of P. This is not surprising given the fact these languages support many (co-)NP hard inference tasks in polynomial time. Because they support equivalence checking (which is convenient to detect fixpoints early) and have a practically efficient Apply function (Van den Broeck and Darwiche, 2015), OBDDs and SDDs are excellent languages for use in Compile. 5.2 Approximate Knowledge Compilation The above section provides us with a way to perform various types of inference on logic programs: we can compile any logic program into a target formalism suitable for inference (e.g., SDD for equivalence checking or weighted model counting, CNF for satisfiability checking, etc.). However, when working with large programs this approach will be infeasible, simply because compilation is too expensive. In this case, we often want to perform approximate knowledge compilation (Selman and Kautz, 1996). Well-founded inductions provide us with the means to do this. Proposition 5.2 Suppose the parametrised well-founded model of P is (A, A). Let (Ai,1 , Ai,2 ) be a well-founded induction of ΨP . Then for every i, Th(Ai,1 ) |= Th(A) |= Th(Ai,2 ). One application of approximate knowledge compilation is in approximate inference by weighted model counting (WMC) (Chavira and Darwiche, 2008) for probabilistic logic programs (Fierens et al., 2015). Let ϕ be a formula (query) over Σ and w a weight function on Σ. Then it follows immediately from Proposition 5.2 that WMC(Th(Ai,1 ) ∧ ϕ, w) ≤ WMC(P ∧ ϕ, w) ≤ WMC(Th(Ai,2 ) ∧ ϕ, w). As Compile(L) follows a well-founded induction, it can be stopped at any time to obtain an upper and lower bound on the weighted model count (and therefore on the probability of the query). In fact, Proposition 5.2 can be used to perform any (anti)-monotonic inference task approximately. 6 Conclusion In this paper, we presented a novel technique for knowledge compilation of general logic programs; our technique extends previously defined algorithms for positive logic programs. Our work is based on the constructive nature of the well-founded semantics: we showed that the algebraical concept of a well-founded induction translates into a family of anytime knowledge compilation algorithms. We used this to show that Boolean circuits are at least as succinct as logic programs (under the parametrised well-founded semantics). Our technique also extends to Kripke-Kleene semantics and to other knowledge representation formalisms. Extending the implementation by Vlasselaer et al. (2015) to general logic programs and testing it on a set of benchmarks are topics for future work.

16

B. Bogaerts and G. Van den Broeck References

Abiteboul, S. and Vianu, V. 1991. Datalog extensions for database queries and updates. J. Comput. Syst. Sci. 43, 1, 62–124. Antic, C., Eiter, T., and Fink, M. 2013. Hex semantics via approximation fixpoint theory. In Proceedings of LPNMR. 102–115. Asuncion, V., Lin, F., Zhang, Y., and Zhou, Y. 2012. Ordered completion for first-order logic programs on finite structures. Artif. Intell. 177–179, 1–24. Ben-Eliyahu, R. and Dechter, R. 1994. Propositional semantics for disjunctive logic programs. Ann. Math. Artif. Intell. 12, 1-2, 53–87. Bryant, R. E. 1986. Graph-based algorithms for Boolean function manipulation. IEEE Transactions on Computers 35, 677–691. Cadoli, M. and Donini, F. M. 1997. A survey on knowledge compilation. AI Commun. 10, 3-4, 137–150. Chavira, M. and Darwiche, A. 2005. Compiling bayesian networks with local structure. In Proceedings of IJCAI. 1306–1312. Chavira, M. and Darwiche, A. 2008. On probabilistic inference by weighted model counting. Artif. Intell. 172, 6-7, 772–799. Darwiche, A. 2011. SDD: A new canonical representation of propositional knowledge bases. In Proceedings of IJCAI. 819–826. Darwiche, A. and Marquis, P. 2002. A knowledge compilation map. J. Artif. Intell. Res. (JAIR) 17, 229–264. ´ ski, M., and Vennekens, J. 2012. A Denecker, M., Lierler, Y., Truszczyn Tarskian informal semantics for answer set programming. In ICLP (Technical Communications). 277–289. ´ ski, M. 2000. Approximations, staDenecker, M., Marek, V., and Truszczyn ble operators, well-founded fixpoints and applications in nonmonotonic reasoning. In Logic-Based Artificial Intelligence, Springer. Vol. 597. 127–144. ´ ski, M. 2004. Ultimate approxiDenecker, M., Marek, V., and Truszczyn mation and its application in nonmonotonic knowledge representation systems. Information and Computation 192, 1 (July), 84–121. Denecker, M. and Vennekens, J. 2007. Well-founded semantics and the algebraic theory of non-monotone inductive definitions. In LPNMR. 84–96. Denecker, M. and Vennekens, J. 2014. The well-founded semantics is the principle of inductive definition, revisited. In Proceedings of KR. 22–31. Fierens, D., Van den Broeck, G., Renkens, J., Shterionov, D. S., Gutmann, B., Thon, I., Janssens, G., and De Raedt, L. 2015. Inference and learning in probabilistic logic programs using weighted boolean formulas. TPLP 15, 3, 358–401. Fitting, M. 2002. Fixpoint semantics for logic programming — A survey. Theoretical Computer Science 278, 1-2, 25–51. Gelfond, M. and Lifschitz, V. 1988. The stable model semantics for logic programming. In Proceedings of ICLP/SLP. 1070–1080. Huang, J. and Darwiche, A. 2005. On compiling system models for faster and more scalable diagnosis. In Proceedings of AAAI. 300–306.


17

Janhunen, T. 2004. Representing normal programs with clauses. In Proceedings of ECAI. 358–362. Janhunen, T. 2006. Some (in)translatability results for normal logic programs and propositional theories. Journal of Applied Non-Classical Logics 16, 1-2, 35–86. ¨ , I., and Sevalnev, M. 2009. Computing stable models Janhunen, T., Niemela via reductions to difference logic. In LPNMR, E. Erdem, F. Lin, and T. Schaub, Eds. LNCS, vol. 5753. Springer, 142–154. Kleene, S. C. 1938. On notation for ordinal numbers. The Journal of Symbolic Logic 3, 4, 150–155. Lifschitz, V. and Razborov, A. A. 2006. Why are there so many loop formulas? ACM Trans. Comput. Log. 7, 2, 261–268. Lin, F. and Zhao, J. 2003. On tight logic programs and yet another translation from normal logic programs to propositional logic. In Proceedings of IJCAI. 853–858. Lin, F. and Zhao, Y. 2004. ASSAT: Computing answer sets of a logic program by SAT solvers. AIJ 157, 1-2, 115–137. Lowd, D. and Domingos, P. 2008. Learning arithmetic circuits. 383–392. ´ ski, M. 1999. Stable models and an alternative logic Marek, V. and Truszczyn programming paradigm. In The Logic Programming Paradigm: A 25-Year Perspective. Springer-Verlag, 375–398. Palacios, H., Bonet, B., Darwiche, A., and Geffner, H. 2005. Pruning conformant plans by counting models on compiled d-dnnf representations. In Proceedings of ICAPS. 141–150. Pelov, N., Denecker, M., and Bruynooghe, M. 2007. Well-founded and stable semantics of logic programs with aggregates. TPLP 7, 3, 301–353. Przymusinski, T. C. 1988. On the declarative semantics of deductive databases and logic programs. In Foundations of Deductive Databases and Logic Programming. Morgan Kaufmann, 193–216. Selman, B. and Kautz, H. A. 1996. Knowledge compilation and theory approximation. J. ACM 43, 2, 193–224. Strass, H. 2013. Approximating operators and semantics for abstract dialectical frameworks. AIJ 205, 39–70. ´, C., and Koch, C. 2011. Probabilistic databases. Suciu, D., Olteanu, D., Re Van den Broeck, G. and Darwiche, A. 2015. On the role of canonicity in knowledge compilation. In Proceedings of AAAI. van Emden, M. H. and Kowalski, R. A. 1976. The semantics of predicate logic as a programming language. J. ACM 23, 4, 733–742. Van Gelder, A., Ross, K. A., and Schlipf, J. S. 1991. The well-founded semantics for general logic programs. J. ACM 38, 3, 620–650. Vlasselaer, J., Van den Broeck, G., Kimmig, A., Meert, W., and De Raedt, L. 2015. Anytime inference in probabilistic logic programs with TP compilation. In Proceedings of IJCAI. Available on https://lirias.kuleuven. be/handle/123456789/494681.

18

B. Bogaerts and G. Van den Broeck Appendix A Figures

This appendix contains some figures associated with the gear wheels example (Example 4.13). The first figure contains a circuit representation of the parametrised well-founded model of logic program Pw from Example 4.13. Th(Aw ) ∧ ⇔ turns 1 (0)

⇔

⇔

∨

∨

⇔

turns 1 (1)

turns 2 (1)

f

∨

f ∧

turns 1 (0) button 1 (0)

f

∨ ∧

¬ f

turns 2 (0)

∧ ¬

f ∧

¬

¬

f

f

turns 1 (1)

turns 2 (1)

f turns 2 (0) button 2 (0)

Fig. A 1. A circuit representation of the gear wheel theory Th(Aw ).

The next figure contains a circuit representation of the parametrised well-founded model of the following logic program Pw,2 that represent the gear wheel example with time ranging from 0 to 2:   turns 1 (0) ← turns 2 (0) turns 2 (0) ← turns 1 (0)           turns (1) ← turns (1) turns (1) ← turns (1) 1 2 2 1         turns 2 (2) ← turns 1 (2)   turns 1 (2) ← turns 2 (2) turns 1 (1) ← turns 1 (0) ∧ ¬button 1 (0) turns 2 (1) ← turns 2 (0) ∧ ¬button 2 (0)        turns 1 (1) ← ¬turns 1 (0) ∧ button 1 (0) turns 2 (1) ← ¬turns 2 (0) ∧ button 2 (0)         turns 1 (2) ← turns 1 (1) ∧ ¬button 1 (1) turns 2 (2) ← turns 2 (1) ∧ ¬button 2 (1)      turns 1 (2) ← ¬turns 1 (1) ∧ button 1 (1) turns 2 (2) ← ¬turns 2 (1) ∧ button 2 (1)

19 Knowledge Compilation of Logic Programs Using AFT

⇔

f turns 1 (0)

turns 1 (0)

¬

⇔

∨

∨ ∧

turns 1 (1)

∧

turns 1 (1)

button 1 (0)

¬

¬

∧

turns 1 (2)

button 1 (1)

⇔

∧

Th(Aw,2 )

⇔

∨

∧

∨

¬

∨ ¬

¬

button 2 (1)

turns 2 (2)

∧

turns 2 (2)

∨ ∧

turns 1 (2)

¬

∧

⇔

∨

∨

¬

turns 2 (1)

∧

turns 2 (1)

turns 2 (0)

button 2 (0)

⇔

f

turns 2 (0)

Fig. A 2. A circuit representation of the gear wheel example for up to two time points.

20

B. Bogaerts and G. Van den Broeck Appendix B Proofs

Definition-Proposition 3.1. Let O : L → L be an operator and f : L → K a lattice morphism. We say that O respects f if for every x, y ∈ L with f (x) = f (y), it holds that f (O(x)) = f (O(y)). If f is surjective and O respects f , then there exists a unique operator Of : K → K with Of ◦ f = f ◦ O, which we call the projection of O on K. Proof We prove the existence and uniqueness of Of . Choose x ∈ K. Since f is surjective, there is a x0 ∈ L with f (x0 ) = x. We know that Of must map x to f (O(x0 )), hence uniqueness follows. Furthermore, this mapping is well-defined (independent of the choice of x0 ) since O respects f. Proposition A.1 If (x0 , y 0 ) is an A-refinement of (x, y), then (f (x0 ), f (y 0 )) is an Af -refinement of (f (x), f (y)). Proof 1. First suppose (x0 , y 0 ) is an application A-refinement of (x, y). Thus (x, y) ≤p (x0 , y 0 ) ≤p A(x, y). From the fact that f is a lattice morphism, it follows that f 2 (x, y) ≤p f 2 (x0 , y 0 ) ≤p f 2 (A(x, y)). From the fact that f respects A, we then find f 2 (x, y) ≤p f 2 (x0 , y 0 ) ≤p Af (f 2 (x, y)), hence f 2 (x0 , y 0 ) is an application Af -refinement of f 2 (x, y). 2. The second direction is analogous to the first. Suppose (x0 , y 0 ) is an unfoundedness A-refinement of (x, y). Thus x0 = x and A(x, y 0 )2 ≤ y 0 ≤ y. Then also f (x0 ) = f (x) and f (A(x, y 0 )2 ) ≤ f (y 0 ) ≤ f (y), thus Af (f (x), f (y 0 ))2 ≤ f (y 0 ) ≤ f (y) and the result follows. Lemma A.2 If O and Of are monotone, then f (lfp(O)) = lfp(Of ).


21

Proof The least fixpoint of O is the limit of the sequence ⊥ → O(⊥) → O(O(⊥)) → . . . . It follows immediately from the definition of Of that for every ordinal n, f (On (⊥)) = Ofn (f (⊥)) = Ofn (⊥K ), hence the result follows.

Proposition 3.3. If (xj , yj )j≤α is a well-founded induction of A, then (f (xj ), f (yj ))j≤α is a wellfounded induction of Af . If (xj , yj )j≤α is terminal, then so is (f (xj ), f (yj ))j≤α .

Proof The first claim follows directly (by induction) from Proposition A.1. For the second claim, all that is left to show is that if there are no strict Arefinements of (xα , yα ), then there are also no strict Af -refinements of (f (xα ), f (yα )). First of all, since (xα , yα ) is a fixpoint of A, it also follows for every i that Af (f (xα ), f (yα )) = f 2 (A(xα , yα )) = (f (xα ), f (yα )). Thus, there are no strict application refinements of Af either. Since there are no unfoundedness refinements of (xα , yα ), Proposition 2.1 yields f (x) x x = SAf ◦ f . . It is easy to see that for every i, the operator f ◦ SA that yα = lfp SA x x Hence, Lemma A.2 (for the operator SA ) guarantees that f (yα ) = f (lfp SA ) = f (x) lfp SAf . Thus, using Proposition 2.1 we find that there is no strict unfoundedness refinement of (f (xα ), f (yα )).

Theorem 3.4. If (x, y) is the A-well-founded fixpoint of O, then, (f (x), f (y)) is the Af -well-founded fixpoint of Of .

Proof Follows immediately from Proposition 3.3.

Theorem 3.6. Suppose L is a parametrisation of K through (fi )i∈I . Let O : L → L be an operator and A an approximator of O such that both O and A respect each of the fi . If (x, y) is the A-well-founded fixpoint of O, the following hold. 1. For each i, (fi (x), fi (y)) is the Afi -well-founded fixpoint of Ofi . 2. If the Afi -well-founded fixpoint of Ofi is exact for every i, then so is the A-well-founded fixpoint of O.

22


Proof The first point immediately follows from Theorem 3.4. Using the first point, we find that if the Afi -well-founded fixpoint of Ofi is exact for every i, then fi (x) = fi (y) for every i. Hence the definition of parametrisation guarantees that x = y as well, i.e., the A-well-founded fixpoint of O is indeed exact.

Proposition 4.5. I For every formula ϕ over Σ, S ∈ (Ldp )2 and I ∈ 2Σp , it holds that ϕS = (ϕS )I . Proof Trivial.

Proposition 4.6. The lattice Ldp is a parametrisation of 2Σd through the mappings (πI : Ldp → 2Σd : A 7→ AI )I∈2Σp . Proof It is clear that the mappings πI are lattice morphisms since evaluation of propositional formulas commutes with Boolean operations. Now, for A, A0 ∈ Ldp , it holds that A ≤ A0 if and only if for every atom p ∈ Σd , A(p) entails A0 (p). This is equivalent to the condition that for every p ∈ Σd and every interpretation I ∈ 2Σd , A(p)I ≤ A0 (p)I , i.e., with the fact that for every I, πI (A) ≤ πI (A0 ) which is what we needed to show.

Theorem 4.8. If P is a positive logic program, then TP is monotone. For every Σ-interpretation I, it then holds that I |=wf P if and only if I |= Th(lfp(TP )). Proof Follows immediately from the definition of the parametrised well-founded semantics combined with Lemma A.2.

Theorem 4.9. For any parametrised logic program P, the following hold: 1. ΨP is an approximator of TP . 2. For every Σp -structure I, it holds that ΨIP ◦ πI2 = πI2 ◦ ΨP .


23

Proof 1. It follows immediately from the definitions that for exact interpretations S = (A, A), ΨP coincides with TP . ≤p -monotonicity follows directly from the definition of evaluation of formulas (Definition 4.4). 2. We find that for every S ∈ (Ldp )2 and every p ∈ 2Σd , ΨIP (πI2 (S))(p) = ΨIP (S I )(p) = ϕSp

I

= (ϕSp )I = (ΨP (S)(p))I = πI2 (ΨP (S)(p)), which indeed proves our claim. Lemma A.3 For every Σp -interpretation I, there are at most |Σd | strict refinements in a wellfounded induction of ΨIP . Proof Every strict refinement should at least change one of the atoms in Σd from unknown to either true or false, hence the result follows. Lemma A.4 Suppose (xi , yi )i≤β is a well-founded induction of TP in which every refinement is maximally precise, i.e., either of the form (x, y) → TP (x, y) or an unfoundedness refinement satisfying the condition in Proposition 2.1. The following hold: • there are at most |Σd | subsequent strict application refinements in (xi , yi )i≤β , and • if unfoundedness refinements only happen in (xi , yi )i≤β when no application refinement is possible, then there are at most |Σd | unfoundedness refinements. Proof For the first part, we notice that every sequence of maximal application refinements maps (by πI ) onto a sequence of maximal application refinements of ΨIP . Furthermore, from the proof of Proposition 3.3, it follows that if a TP -refinement is strict, then at least on of the induced ΨIP -refinements must be strict as well. The result now follows from Lemma A.3. The second point is completely similar to the first. There can be at most |Σd | strict unfoundedness refinements in any well-founded induction of ΨIP . Furthermore, the condition in this point guarantees that if for some I, an unfoundedness refinement in the induced well-founded induction is not strict, then neither will any later unfoundedness refinements. Hence, the result follows.

24


Theorem 5.1. Let LBC be the language of Boolean circuits. The following hold: (i) Compile(LBC ) has polynomial-time complexity and (ii) the size of the output circuit of Compile(LBC ) is polynomial in the size of P. Proof First, we notice that if we have a circuit representation of S, then the representation of ΨP (S) consists of the same circuit with maximally three added layers since ϕp is a DNF for every defined atom p (a layer of negations, one of disjunctions and one of conjunctions). Furthermore, the size of these layers is linear in terms of the size of P. Similarly, the representation of an unfoundedness refinement will only be quadratically in the size of P (quadratically since computing the smallest y 0 is a refinement takes a linear number of applications). The two results now follow from Lemma A.4, which yields a polynomial upper bound on the number of refinements, and which also allows us to ignore the stop conditions (in general checking whether a fixpoint is reached is a co-NP problem, namely checking equivalence of two circuits; however, we do not need to do this since we have an upper bound on the maximal number of refinements before such a fixpoint is reached). Proposition 5.2. Suppose the parametrised well-founded model of P is (A, A). Let (Ai,1 , Ai,2 ) be a well-founded induction of ΨP . Then for every i, Th(Ai,1 ) |= Th(A) |= Th(Ai,2 ). Proof Denecker and Vennekens (2007) showed that if (xi , yi )i≤β is a well-founded induction of A and (x, y) the A-well-founded model of O, then for every i ≤ β, it holds that (xi , yi ) ≤p (x, y). Our proposition immediately follows from this result.