Tableau Calculi for Logic Programs under Answer Set Semantics

Transcription

1 Tableau Calculi for Logic Programs under Answer Set Semantics Martin Gebser and Torsten Schaub 1 Institut für Informatik Universität Potsdam August-Bebel-Str. 89, D Potsdam {gebser,torsten}@cs.uni-potsdam.de We introduce formal proof systems based on tableau methods for analyzing computations in Answer Set Programming (ASP). Our approach furnishes fine-grained instruments for characterizing operations as well as strategies of ASP solvers. The granularity is detailed enough to capture a variety of propagation and choice methods of algorithms used for ASP solving, also incorporating SAT-based and conflict-driven learning approaches to some extent. This provides us with a uniform setting for identifying and comparing fundamental properties of ASP solving approaches. In particular, we investigate their proof complexities and show that the run-times of best-case computations can vary exponentially between different existing ASP solvers. Apart from providing a framework for comparing ASP solving approaches, our characterizations also contribute to their understanding by pinning down the constitutive atomic operations. Furthermore, our framework is flexible enough to integrate new inference patterns, and so to study their relation to existing ones. To this end, we generalize our approach and provide an extensible basis aiming at a modular incorporation of additional language constructs. This is exemplified by augmenting our basic tableau methods with cardinality constraints and disjunctions. Categories and Subject Descriptors: D.1.6 [Logic Programming]: General Terms: Theory Additional Key Words and Phrases: Answer Set Programming, Tableau calculi, Proof complexity 1. INTRODUCTION Answer Set Programming (ASP; [Baral 2003]) is an appealing tool for knowledge representation and reasoning. Its attractiveness is supported by the availability of efficient off-the-shelf solvers that allow for computing answer sets of logic programs. However, in contrast to the neighboring area of Satisfiability (SAT; [Biere et al. 2009]) checking, where solving approaches can be analyzed by means of resolution proof theory (cf. [Beame and Pitassi 1998; Beame et al. 2004; Pipatsrisawat and Darwiche 2011]), ASP lacks formal frameworks for describing inferences con- 1 Affiliated with the School of Computing Science at Simon Fraser University, Burnaby, Canada, and the Institute for Integrated and Intelligent Systems at Griffith University, Brisbane, Australia. This paper combines and extends [Gebser and Schaub 2006b; 2007]; the former received the best paper award at ICLP 06. Permission to make digital/hard copy of all or part of this material without fee for personal or classroom use provided that the copies are not made or distributed for profit or commercial advantage, the ACM copyright/server notice, the title of the publication, and its date appear, and notice is given that copying is by permission of the ACM, Inc. To copy otherwise, to republish, to post on servers, or to redistribute to lists requires prior specific permission and/or a fee. c 20YY ACM /20YY/ $5.00 ACM Transactions on Computational Logic, Vol. V, No. N, Month 20YY, Pages 1 62.

2 2 Martin Gebser and Torsten Schaub ducted by ASP solvers. This has led to great heterogeneity in the description of algorithms for ASP solving, ranging over operational [Faber 2002; Simons et al. 2002; Anger et al. 2005; Calimeri et al. 2006; Konczak et al. 2006] and procedural [Lin and Zhao 2004; Ward and Schlipf 2004; Giunchiglia et al. 2006; Lin et al. 2006; Gebser et al. 2007; Giunchiglia et al. 2008] characterizations, which complicates identifying fundamental properties of algorithms (such as soundness and completeness) as well as formal comparisons between them. Our work is motivated by the desire to converge the various heterogeneous characterizations of current ASP solvers inferences by developing common proof-theoretic foundations. Examples for this are the Davis-Putnam-Logemann-Loveland (DPLL; [Davis and Putnam 1960; Davis et al. 1962]) procedure and Conflict-Driven Clause Learning (CDCL; [Marques-Silva and Sakallah 1999; Moskewicz et al. 2001; Eén and Sörensson 2004]) for SAT, which are both based on resolution proof theory. As in the context of SAT, the proof-theoretic perspective allows us to identify general, rather than solver-specific, properties and to study inferences by their admissibility, rather than from an implementation point of view. To this end, we introduce a family of tableau calculi (cf. [D Agostino et al. 1999]) for ASP, viewing answer set computations as derivations in an inference system: a branch in a tableau corresponds to a successful or unsuccessful attempt to compute an answer set; an entire tableau represents a traversal of the search space. Our approach furnishes fine-grained instruments for characterizing propagation operations as well as search strategies of ASP solvers. In particular, relating the approaches of ASP solvers to appropriate tableau calculi, in the sense that computations of a solver correspond to tableaux of an associated calculus, allows us to analyze the (best-case) complexities of ASP solving strategies. In fact, we investigate the proof complexities of different approaches, depending on choice operations. It turns out that exponentially different run-times of best-case computations can be obtained for existing ASP solvers. Furthermore, our proof-theoretic frameworks allow us to describe and study new inference patterns, going beyond implemented systems. As a result, we obtain a looporiented approach to unfounded set handling, which is not restricted to SAT-based solvers, and we also identify backward propagation operations for unfounded sets. While our basic tableau framework mainly aims at characterizing inference patterns of solvers on the common language fragment of (propositional) normal programs, in practice, ASP solvers additionally support composite language constructs, such as dlv s aggregates [Faber et al. 2008] or smodels cardinality and weight constraints [Simons et al. 2002]. To address these extensions, too, we generalize our basic approach towards a flexible framework amenable to additional language constructs. For simplicity, we begin with characterizing inferences in a generic core fragment in which rule heads and bodies consist of atomic literals. We then gradually extend this setting by focusing on particular aggregates, understood as expressions over collections of literals. To this end, we first view conjunctions in rule bodies as simple Boolean aggregates. Embedding them into our generic framework, we characterize a class of logic programs that is as expressive as normal programs (already dealt with in our basic approach). We further augment our generic framework with cardinality constraints as well as disjunctions in rule heads. The integration of these popular language constructs gives an idea of how to adapt our proof-theoretic approach to richer settings. The remainder of this paper is organized as follows. After providing the necessary background on (normal) logic programs, Section 3 introduces our basic tableau framework for them. In Section 4, we apply our methodology to characterize well-known logic programming operators and existing ASP solvers, investigating both traditional (DPLL-style) approaches as well as those based on translation to SAT or natively supporting conflict-driven learning. Section 5 shifts the focus to logic programs over extended languages, for which we first provide a generic core frame-

3 Tableau Calculi for Logic Programs under Answer Set Semantics 3 work that is afterwards extended to conjunctions, cardinality constraints, and disjunctions. In Section 6, we analyze the relative power of several practically relevant tableau calculi in terms of (best-case) proof complexity. Section 7 and 8 conclude the paper by surveying related work and discussing the achieved results, respectively. Finally, proofs are provided in the appendix. 2. NORMAL LOGIC PROGRAMS Given an alphabet P, a normal (logic) program Π is a finite set of rules of the form p 0 p 1,..., p m, not p m+1,..., not p n (1) where 0 m n and each p i P is an atom for 0 i n. A literal is an atom p or its (default) negation not p. For a rule r as in (1), let head(r) = p 0 be the head of r and body(r) = {p 1,..., p m, not p m+1,..., not p n } be the body of r. We sometimes write a rule r as (head(r) body(r)), where body(r) represents the conjunction of its contained literals. For a set B of literals, let B + = B P and B = {p P not p B}; accordingly, for body(r) = {p 1,..., p m, not p m+1,..., not p n }, we get body(r) + = {p 1,..., p m } and body(r) = {p m+1,..., p n }. We denote the set of atoms occurring in a program Π by atom(π), and the set of bodies occurring in Π is given by body(π) = {body(r) r Π}. For regrouping rule bodies with the same head p, let body(p) = {body(r) r Π, head(r) = p}. 2 Given a program Π such that body(r) = for all r Π, a set X of atoms is closed under Π if, for every r Π, head(r) X or body(r) + X; Cn(Π) denotes the (unique) smallest set of atoms closed under Π. The reduct of a normal program Π relative to a set X of atoms is defined by Π X = {head(r) body(r) + r Π, body(r) X = }. A set X of atoms is an answer set of a normal program Π if Cn(Π X ) = X. As an example, consider the program Π 1 = {a ; c not b, not d; d a, not c} and its two answer sets {a, c} and {a, d}. A (partial) assignment A over a domain, dom(a), is a set of entries of the form T v or F v, indicating whether some v dom(a) is true or false, respectively. The complement of an entry l is denoted by l, that is, T v = F v and F v = T v. Letting A T = {v dom(a) T v A} and A F = {v dom(a) F v A}, we say that A is contradictory if A T A F ; otherwise, A is non-contradictory. Furthermore, A is total if it is non-contradictory and A T A F = dom(a). For a normal program Π, we fix dom(a) to atom(π) body(π) in the sequel. For instance, with Π 1, the (partial) assignment {T, F b} maps the body of rule (a ) to true and the atom b to false, and the assignment {T, F b, T a, T c, F {a, not c}, F d, T {not b, not d}} is total. For a normal program Π and a set U atom(π), we define the external bodies of U for Π by EB Π (U) = {body(r) r Π, head(r) U, body(r) + U = }. We call U an unfounded set of Π wrt an assignment A if EB Π (U) A F. 3 Since the union of two unfounded sets remains unfounded, the union of all unfounded sets of Π wrt A, denoted by U Π (A), is the greatest unfounded set of Π wrt A. Semantically, an unfounded set identifies atoms that lack external support (cf. [Lee 2005]) and thus ought to be false. The (positive) dependency graph of Π is (atom(π), {(head(r), p) r Π, p body(r) + }). A non-empty U atom(π) is a loop [Lin and Zhao 2004] of Π if, for every pair p, q U (including p = q), there is a path of non-zero length from p to q in the dependency graph of Π such that all vertices in the path belong to U. 2 For convenience, we overload function body to refer to sets of bodies associated with a program or an atom, respectively. 3 Original unfounded sets [Van Gelder et al. 1991] rely on EB Π (U) {B body(π) (B + A F ) (B A T ) }.

4 4 Martin Gebser and Torsten Schaub We denote the set of all loops of Π by loop(π). The main interest of loops is that they can be unfounded even if each contained atom is (circularly) supported by some rule with non-false body. 3. TABLEAUX FOR NORMAL LOGIC PROGRAMS We describe calculi consisting of tableau rules for the construction of answer sets of logic programs. A tableau for a logic program Π and an initial assignment A is a binary tree with the rules of Π and the entries of A at its root. 4 Further entries can be generated by applying tableau rules in the following standard way [D Agostino et al. 1999]: given a tableau rule and a branch in a tableau such that the prerequisites of the rule hold in the branch, the tableau can be extended by appending entries to the end of the branch as specified by the rule. Note that every branch corresponds to a pair (Π, A); we draw on this relationship for identifying branches in the sequel. For some v dom(a), we say that T v or F v can be deduced by a set T of tableau rules in a branch (Π, A) if the entry can be generated by applying some rule in T other than Cut (see below). We let D T (Π, A) denote the set of entries deducible by T in (Π, A); DT (Π, A) represents the set of entries in a smallest branch that extends (Π, A) and is closed under T, that is, D T (Π, DT (Π, A)) D T (Π, A). A branch (Π, A) is contradictory if A is contradictory, and non-contradictory otherwise; (Π, A) is complete (wrt a tableau calculus T ) if it is contradictory or if A is total and D T (Π, A) A. A tableau is complete if all of its branches are complete. A complete tableau for a logic program and the empty assignment such that all branches are contradictory is called a refutation for the program (meaning that the program has no answer set). Our tableau rules for normal programs Π are shown in Figure 1. For convenience, they make use of two conjugation functions, t and f. For a literal l, define: tl = { T l if l dom(a) F v if l = not v for v dom(a) fl = { F l if l dom(a) T v if l = not v for v dom(a) In view of this, the FTB rule in (a) expresses that truth of a rule body can be deduced if the body s literals hold in a branch. Conversely, if the body is already assigned to false and all but one literal hold, the remaining literal must necessarily be false; this contrapositive argument is formalized by the BFB rule in (b). Likewise, the tableau rules FTA and FFB in (c) and (e) capture straightforward conditions under which an atom must be assigned to true or a body to false, respectively. Their contrapositives are given by BFA and BTB in (d) and (f). The remaining tableau rules in (g) (k) are subject to provisos. For an application of FFA in (g), deducing an unsupported atom p to be false, ( ) stipulates that B 1,..., B m comprise all bodies of rules with head p. Its contrapositive, the BTA rule in (h), is also guided by ( ). The outer structure of WFN[Ω] and WFJ[Ω] in (i) and (j), aiming at unfounded sets, is similar to FFA and BTA, yet their proviso ( [Ω]) requires a concerned atom p to belong to some set U Ω such that B 1,..., B m comprise all external bodies of U for Π. We below investigate two alternative options for Ω: Ω = 2 atom(π) and Ω = loop(π). Finally, ( [Γ]) guides applications of the Cut[Γ] rule in (k) by restricting cut objects v to members of Γ. For a normal program Π, we below consider Γ = atom(π), Γ = body(π), and Γ = atom(π) body(π). 5 Note that a Cut application adds entries T v and F v as the left and the right child to the end of a branch, thus reflecting non-determinism in assigning v. With every other tableau rule, its consequent is appended to a branch, i.e., applications are deterministic. The deterministic tableau rules in Figure 1 preserve answer sets; this also applies to Cut when considering both resulting branches. Different tableau calculi, viz. particular rule sets, yield char- 4 We do not mark the immanent validity of rules in Π by T, as rules are not assigned by A. 5 The Cut rule may, in principle, introduce more general structures, which would necessitate further decomposition rules.

5 Tableau Calculi for Logic Programs under Answer Set Semantics 5 p l 1,..., l n tl 1,..., tl n T {l 1,..., l n } (a) Forward True Body (FTB) F {l 1,..., l i 1, l i, l i+1,..., l n } tl 1,..., tl i 1, tl i+1,..., tl n fl i (b) Backward False Body (BFB) p l 1,..., l n T {l 1,..., l n } T p (c) Forward True Atom (FTA) p l 1,..., l n F p F {l 1,..., l n } (d) Backward False Atom (BFA) p l 1,..., l i,..., l n fl i F {l 1,..., l i,..., l n } (e) Forward False Body (FFB) T {l 1,..., l i,..., l n } tl i (f) Backward True Body (BTB) T p F B 1,..., F B m ( ) F p (g) Forward False Atom (FFA) F B 1,..., F B m ( [Ω]) F p (i) Well-Founded Negation (WFN[Ω]) F B 1,..., F B i 1, F B i+1,..., F B m ( ) T B i (h) Backward True Atom (BTA) T p F B 1,..., F B i 1, F B i+1,..., F B m ( [Ω]) T B i (j) Well-Founded Justification (WFJ[Ω]) T v F v (k) Cut (Cut[Γ]) ( [Γ]) ( ) : p atom(π), body(p) {B 1,..., B m } body(π) ( [Ω]) : p U, U Ω, EB Π (U) {B 1,..., B m } body(π) ( [Γ]) : v Γ Fig. 1. Tableau rules for normal programs. acteristic correspondences. For instance, D{FTB,FTA,FFB,FFA} (Π, A) corresponds to Fitting s operator [Fitting 2002], and D (Π, A) amounts to the well-founded operator {FTB,FTA,FFB,WFN[2 atom(π) ]} [Van Gelder et al. 1991]. Similarly, we show below that D{(a) (h)} (Π, A) coincides with unit propagation on a program s completion [Clark 1978; Apt et al. 1987], and D (Π, A) {(a) (h),wfn[2 atom(π) ]} captures smodels propagation [Simons et al. 2002], that is, well-founded operator enhanced by backward propagation. Furthermore, the following tableau calculi are of particular interest:

6 6 Martin Gebser and Torsten Schaub a c not b, not d d a, not c T T a F b T c F c T {not b, not d} (BTA) F {not b, not d} (BFA) F d (BTB) T d (BFB) F {a, not c} (FFB) T {a, not c} (FTB) Fig. 2. T comp T smodels T nomore T nomore++ (FTB) (FTA) (FFA) (Cut[atom(Π 1 )]) Complete tableau of T smodels for Π 1 and the empty assignment. = {(a) (h), Cut[atom(Π) body(π)]} = {(a) (h), WFN[2 atom(π) ], Cut[atom(Π)]} = {(a) (h), WFN[2 atom(π) ], Cut[body(Π)]} = {(a) (h), WFN[2 atom(π) ], Cut[atom(Π) body(π)]} An exemplary complete tableau of T smodels is given in Figure 2, where rule applications are indicated by rule names, e.g., (Cut[atom(Π 1 )]). Both branches in Figure 2 are non-contradictory. They comprise Π 1 along with total assignments: the left branch represents answer set {a, c}, while the right one gives answer set {a, d}. The tableau calculi that include WFN[2 atom(π) ] to deal with unfounded sets are sound and complete, which can be formalized as follows. THEOREM 3.1. Let Π be a normal program. Then, we have that the following holds for tableau calculi T smodels, T nomore, and T nomore++: (1) Every incomplete tableau for Π and can be extended to a complete tableau for Π and. (2) Program Π has an answer set X iff every complete tableau for Π and has a unique noncontradictory branch (Π, A) such that A T atom(π) = X. (3) Program Π has no answer set iff every complete tableau for Π and is a refutation. In particular, note that each of Cut[atom(Π)], Cut[body(Π)], and Cut[atom(Π) body(π)] is sufficient to complete tableaux for Π and. However, we show in Section 6 that different proof complexities are obtained wrt such Cut variants. Moreover, as each of T smodels, T nomore, and T nomore++ admits a (unique) non-contradictory complete branch (Π, A) in some tableau iff (Π, A) belongs to every complete tableau for Π and, Theorem 3.1 remains valid when replacing every by some in the second and the third item of its statement. 4. CHARACTERIZING EXISTING ASP SOLVERS In this section, we discuss the relationships between the tableau rules in Figure 1 and existing ASP solving approaches. As it turns out, our tableau rules are well-suited for describing the main principles of a variety of ASP solvers. We however start in Section 4.1 by showing correspondences with familiar logic programming operators: Fitting s operator [Fitting 2002] and the well-founded operator [Van Gelder et al. 1991]. Section 4.2 then covers traditional approaches to answer set computation for normal programs, including smodels [Simons et al. 2002], dlv [Leone et al. 2006], nomore [Konczak et al. 2006], and nomore++ [Anger et al. 2005]. Finally, we sketch in Section 4.3 how tableau rules relate to propagation principles of SAT-based solvers assat [Lin and Zhao 2004], cmodels [Giunchiglia et al. 2006], and sag [Lin et al. 2006] as well as to the

7 Tableau Calculi for Logic Programs under Answer Set Semantics 7 approaches of native conflict-driven learning ASP solvers smodels cc [Ward and Schlipf 2004] and clasp [Gebser et al. 2007]. 4.1 Fitting s Operator and Well-Founded Operator Given a normal program Π and an assignment A, the two operators in question can be defined in terms of the following sets of atoms: T Π (A) = {head(r) r Π, body(r) + A T, body(r) A F } N Π (A) = atom(π) \ {head(r) r Π, (body(r) + A F ) (body(r) A T ) = } U Π (A) = U atom(π),eb Π(U) {body(r) r Π,(body(r) + A F ) (body(r) A T ) } U T Π (A) contains the head atoms of rules whose bodies hold wrt A. In contrast, if an atom of N Π (A) occurs in the head of any rule, then the body of the rule is falsified by A. Given that neither T Π (A) nor N Π (A) make use of any entry over body(π), they can be viewed as functions mapping partial interpretations over atoms. In fact, for A = {T p p A T atom(π)} {F p p A F atom(π)}, we have that T Π (A) = T Π (A ) and N Π (A) = N Π (A ). Similarly, it holds that U Π (A) = U Π (A ), where the idea is to reflect the greatest unfounded set, U Π (A), without referring to entries over body(π). Thus, U Π (A) collects all U atom(π) such that every external body of U for Π is falsified by A, i.e., EB Π (U) {body(r) r Π, (body(r) + A F ) (body(r) A T ) }. Given that, for every p N Π (A), we have EB Π ({p}) body(p) {body(r) r Π, (body(r) + A F ) (body(r) A T ) }, it is always the case that N Π (A) U Π (A), while the converse does not hold in general. With the sets T Π (A), N Π (A), and U Π (A) at hand, we can now make the partial interpretations obtained by Fitting s operator and the well-founded operator precise. The following assignment amounts to the result of an application of Fitting s operator: {T p p T Π (A)} {F p p N Π (A)}. The result of an application of the well-founded operator is the assignment {T p p T Π (A)} {F p p U Π (A)}. While both operators use T Π (A) to infer true atoms, false atoms are obtained via either N Π (A) or U Π (A). Since N Π (A) U Π (A), the result of Fitting s operator is always subsumed by the one of the well-founded operator. For illustration, consider the following normal program: Π 2 = {a not b; b not a; c b, not a; c d; d b, not a; d c; e c; e d} For A = {T a, F b}, we get T Π2 (A) = {a}, N Π2 (A) = {b}, and U Π2 (A) = {b, c, d, e}. That is, {T a, F b} is the result of applying Fitting s operator to A, while {T a, F b, F c, F d, F e} is obtained with the well-founded operator. For linking the operators to tableau rules, the following result characterizes the sets of inferred atoms in terms of FTB plus FTA, and by FFB along with either FFA or WFN[2 atom(π) ], respectively, where FFA is subsumed by WFN[2 atom(π) ]. PROPOSITION 4.1. Let Π be a normal program and A an assignment. Then, we have that (1) T Π (A) = ( D {FTA} (Π, D {FTB} (Π, A)) ) T ; (2) N Π (A) = ( D {FFA} (Π, D {FFB} (Π, A)) ) F ; (3) U Π (A) = ( D {WFN[2 atom(π) ]}(Π, D {FFB} (Π, A)) ) F. On the right-hand sides, the application of either FTB or FFB serves as an intermediate step to propagate the truth of all or the falsity of some body literal to the body as such.

8 8 Martin Gebser and Torsten Schaub The valuations of bodies are then exploited by FTA, FFA, and WFN[2 atom(π) ], which in turn deduce atoms assigned to true and false, respectively, in an application of Fitting s operator or the well-founded operator. For instance, given A = {T a, F b}, D {FTB} (Π 2, A) = {T {not b}} gives rise to D {FTA} (Π 2, D {FTB} (Π 2, A)) = {T a}. Furthermore, we have that D {FFB} (Π 2, A) = {F {not a}, F {b, not a}}, D {FFA} (Π 2, D {FFB} (Π 2, A)) = {F b}, and D {WFN[2 atom(π 2 ) ]} (Π 2, D {FFB} (Π 2, A)) = {F b, F c, F d, F e}. As stated in Proposition 4.1, these outcomes correspond to T Π2 (A) = {a}, N Π2 (A) = {b}, and U Π2 (A) = {b, c, d, e}. Although we omit further details, note that the correspondences established in Proposition 4.1 carry forward to iterated applications and fixpoints of Fitting s operator and the well-founded operator, respectively. In particular, the entries over atom(π) in D{FTB,FTA,FFB,FFA} (Π, ) and D (Π, ) yield the least fixpoint of Fitting s operator and the well-founded {FTB,FTA,FFB,WFN[2 atom(π) ]} operator, respectively; additional entries over body(π) make valuations of bodies explicit. 4.2 Traditional ASP Solvers We start by investigating the relationship between smodels [Simons et al. 2002] (and dlv [Leone et al. 2006]) on the one hand and our tableau rules on the other hand. After that, we extend these considerations to the rule-based approach of nomore [Konczak et al. 2006] as well as to the hybrid assignments dealt with by nomore++ [Anger et al. 2005]. The atom-based approach of smodels (logically) works on assignments over atoms, and its propagation (cf. [Simons et al. 2002; Ward and Schlipf 2004]) can be specified in terms of the tableau rules shown in Figure 3. 6 While FI expresses that the head of a rule whose body literals hold must be true, its contrapositive, CFH, describes that a body literal of a rule must not hold if the head is false and all other body literals hold already. Moreover, an unsupported atom p must be false, and ARC reflects this by checking for the presence of some body literal that does not hold in every rule with head p. Conversely, CTH expresses that the body literals of a rule (p l 1,..., l i,..., l n) must hold if an atom p is true and any other rule with head p contains some body literal that does not hold. 7 Finally, AM formalizes that any atom p belonging to some unfounded set U, in view of some false body literal in every element of EB Π (U), must be false. Note that Figure 3 does not show a contrapositive of AM, as smodels propagation does not include such reasoning; it could still be defined analogously to CTH, yet requiring the conditions p U, U atom(π), and {r Π head(r) U, body(r) + U =, body(r) {l 1,..., l m } = } {p l 1,..., l i,..., l n} in the proviso (thus checking that every element of EB Π (U) \ {{l 1,..., l i,..., l n}} contains some body literal that does not hold), while there is a true atom p in U. Augmenting the tableau rules in Figure 3 with Cut[atom(Π 1 )], we can generate the following tableau for Π 1 and the empty assignment: a c not b, not d d a, not c T a F b T c F c F d (CTH) T d (CFH) (FI) (ARC) (Cut[atom(Π 1 )]) 6 The names of tableau rules in Figure 3 are aligned to the ones used for smodels propagation rules in [Ward and Schlipf 2004], and the tableau rules reflect smodels propagation rules by respective prerequisites and consequents. 7 If p = p, then (p l 1,..., l i,..., l n) is the only remaining rule to support p; otherwise, the true atom p is unsupported, and arbitrary body literals may be deduced in the face of a contradiction.

9 Tableau Calculi for Logic Programs under Answer Set Semantics 9 p l 1,..., l n tl 1,..., tl n T p Forward Inference (FI) fl 1,..., fl m F p ( ) All Rules Canceled (ARC) p l 1,..., l i,..., l n T p, fl 1,..., fl m tl ( ) i Contraposition for True Heads (CTH) p l 1,..., l i 1, l i, l i+1,..., l n F p, tl 1,..., tl i 1, tl i+1,..., tl n fl i Contraposition for False Heads (CFH) fl 1,..., fl m ( ) F p At Most (AM) ( ) : p atom(π), {r Π head(r) = p, body(r) {l 1,..., l m} = } = ( ) : p atom(π), {r Π head(r) = p, body(r) {l 1,..., l m} = } {p l 1,..., l i,..., l n} ( ) : p U, U atom(π), EB Π (U) {body(r) r Π, body(r) {l 1,..., l m} = } Fig. 3. Deterministic tableau rules for traditional (atom-based) ASP solvers. This tableau is similar to the one of T smodels shown in Figure 2, yet it omits entries for rule bodies. Note that F d and T d can likewise be generated by applying ARC (or AM) and FI (instead of CTH and CFH), and corresponding alternative deductions of entries (generated in different order) in the left and the right branch of the tableau in Figure 2 rely on FFA (or WFN[2 atom(π) ]) and FTA (instead of BTB and BFB). The next result characterizes smodels propagation in terms of the tableau rules in Figure 1. PROPOSITION 4.2. Let Π be a normal program and A an assignment. Then, we have that (1) D {FI} (Π, A) = D {FTA} (Π, D {FTB} (Π, A)); (2) D {ARC} (Π, A) = D {FFA} (Π, D {FFB} (Π, A)); (3) D {CTH} (Π, A) = D {BTB} (Π, D {BTA} (Π, D {FFB} (Π, A) {T p p A T atom(π)})); (4) D {CFH} (Π, A) = D {BFB} (Π, D {BFA} (Π, A) {T p p A T atom(π)} {F p p A F atom(π)}); (5) D {AM} (Π, A) = D {WFN[2 atom(π) ]}(Π, D {FFB} (Π, A)).

10 10 Martin Gebser and Torsten Schaub As in Proposition 4.1, FTB and FFB are used on the right-hand sides to reflect truth or falsity of bodies wrt their contained literals by corresponding entries. Also observe that the characterizations of FI, ARC, and AM are similar to those of T Π (A), N Π (A), and U Π (A) in Proposition 4.1. In addition, backward propagation via CTH and CFH is captured by means of BTA plus BTB and BFA plus BFB, respectively, deducing first entries for bodies that need to be either true or false and then corresponding entries for their contained literals. In view of the fact that all tableau rules used on the right-hand sides in Proposition 4.2 are contained in tableau calculus T smodels (along with the observation that their application conditions are monotonic wrt assignments), we immediately conclude the following. COROLLARY 4.3. Let Π be a normal program and A an assignment. Then, we have that D {FI,ARC,CTH,CFH,AM} (Π, A) D T smodels (Π, A). To illustrate that the converse of Corollary 4.3 does not hold in general, even if we limit the attention to entries over atoms, consider the following normal program: Π 3 = {a not b; b not a; c b, not a; d b, not a} Given A = {F c}, we obtain D {FI,ARC,CTH,CFH,AM} (Π 3, A) = {F c}, while D T smodels (Π 3, A) = {F c, F {b, not a}, F d}. Note that the falsity of atom c necessitates the falsity of body(c b, not a) because c would be derived otherwise. However, since there is more than one literal in {b, not a}, it is not immediately clear which body literal ought to be false. Hence, an atom-only approach like the one of smodels gets stuck. In contrast, when we assign the body {b, not a} to false, we see that (d b, not a) is inapplicable as well, which enables T smodels to deduce F d. We note that, given the similarities between smodels and dlv on normal programs [Giunchiglia et al. 2008], the latter is also characterized by the tableau rules in Figure 3 (along with Cut[atom(Π)]). Interestingly, both smodels and dlv use dedicated data structures in their implementations for indicating (in)applicability of program rules: in smodels, a rule with a false body is marked as inactive [Simons 2000]; similarly, dlv determines truth values of bodies from specific counters [Faber 2002]. It is thus justified to describe the proceeding of atom-based solvers by assignments and tableau rules that incorporate both atoms and bodies. 8 Hence, for comparing atom-based to other ASP solving approaches, we in the following refer to T smodels, rather than a calculus built from the tableau rules in Figure 3. As shown above, T smodels slightly overestimates the propagation capacities of atom-based solvers, so that lower bounds for its efficiency, considered in Section 6, also apply to the real solvers, viz. smodels and dlv. A similar analysis as in Proposition 4.2 is also possible for the rule-based approach of nomore, amounting to assignments over rule bodies, and for the hybrid approach of nomore++. By assigning truth values to atoms as well as bodies, the latter works on the same basis as its associated tableau calculus T nomore++. In fact, although we omit the details, it is not hard to verify that the propagation operators P, B, and U (cf. [Anger et al. 2005]) implemented by nomore++ match the deterministic tableau rules in T nomore++. Furthermore, the choice operator C of nomore++ coincides with Cut[atom(Π) body(π)]. On the other hand, when we consider nomore augmented with backward propagation [Linke et al. 2002], we obtain that its propagation is subsumed by T nomore. As with T smodels and smodels, we have that some entries deducible by T nomore are not inferred by nomore. The following program illustrates that assignments over rule bodies only may be less 8 In [Giunchiglia and Maratea 2005], additional variables for bodies, one for each rule in a program, are explicitly introduced for comparing smodels to DPLL, and the characterization of smodels propagation rules in terms of unit propagation provided in [Gebser and Schaub 2006a] likewise shows that rule bodies serve as inherent structural variables.

11 Tableau Calculi for Logic Programs under Answer Set Semantics 11 informative than assignments that also include atoms: Π 4 = {a b; b c; b not c; c a, not b} Given A = {T {b}}, since two rules, (b c) and (b not c), have b as their head, nomore cannot determine a unique program rule to derive b from, so that its propagation cannot infer anything. In contrast, D T nomore (Π 4, A) = {T {b}, T a, T b, F {a, not b}, F c, F {c}, T {not c}}. Here, the fact that the atom b must be true yields that the body {a, not b} is necessarily false, from which T nomore then deduces the remaining entries. 4.3 SAT-Based and Conflict-Driven Learning ASP Solvers Lin and Zhao [Lin and Zhao 2004] showed that the answer sets of a normal program Π coincide with the models of the completion of Π satisfying all loop formulas of Π. By introducing auxiliary variables for rule bodies, as also used in [Babovich and Lifschitz 2003] to avoid an exponential blow-up due to clausification, the completion, Comp(Π), and loop formulas, LF (Π), of a program Π can be defined as follows: Comp(Π) = {p B ( p B +p q B q) B body(π)} {p ( B body(p) p B) p atom(π)} LF (Π) = {( p U p) ( B EB Π(U) p B) U loop(π)} Given that a program Π may yield exponentially many (non-redundant) loop formulas [Lifschitz and Razborov 2006], SAT-based ASP solvers assat [Lin and Zhao 2004], cmodels [Giunchiglia et al. 2006], and sag [Lin et al. 2006] do not a priori construct LF (Π). Rather, they use some SAT solver to generate a model of Comp(Π) and, afterwards, check whether the model contains a loop U of Π whose loop formula is violated. If so, U is unfounded wrt the model at hand, and adding the loop formula for U eliminates the model as an answer set candidate. 9 Regarding the generation of answer set candidates, the following analog of Theorem 3.1 applies to T comp and models of Comp(Π). THEOREM 4.4. Let Π be a normal program. Then, we have that the following holds for tableau calculus T comp : (1) Every incomplete tableau for Π and can be extended to a complete tableau for Π and. (2) Comp(Π) has a model X iff every complete tableau for Π and has a unique noncontradictory branch (Π, A) such that (A T atom(π)) {p B B A T body(π)} = X. (3) Comp(Π) has no model iff every complete tableau for Π and is a refutation. Theorem 4.4 shows that T comp captures exactly the models of Comp(Π) for a normal program Π. 10 Since T comp admits a non-contradictory complete branch (Π, A) in some tableau iff (Π, A) belongs to every complete tableau for Π and, Theorem 4.4 (like Theorem 3.1) remains valid when replacing every by some in the second and the third item of its statement. By Theorem 3.1, adding WFN[2 atom(π) ] to T comp leads to a tableau calculus characterizing answer sets. However, SAT-based ASP solvers check for unfounded loops rather than arbitrary unfounded sets, while atom-wise unfounded set handling is accomplished via FFA (enclosed in Comp(Π)). Given that FFA is subsumed by WFN[2 atom(π) ], but not by WFN[loop(Π)], the next 9 While assat and cmodels apply sophisticated unfounded set checks only wrt total answer set candidates, sag can perform them also wrt partial assignments generated by a SAT solver. 10 The models of the completion of a logic program Π are also called the supported models of Π [Apt et al. 1987].

12 12 Martin Gebser and Torsten Schaub result, which shows that WFN[2 atom(π) ] and WFN[loop(Π)] plus FFA yield the same deductive closure (in combination with FFB, deducing the falsity of bodies from body literals that do not hold), tells us that limiting WFN to loops abolishes overlaps between tableau rules. PROPOSITION 4.5. Let Π be a normal program and A an assignment. Then, we have that D {FFB,WFN[2 atom(π) ]} (Π, A) = D {FFB,FFA,WFN[loop(Π)]}(Π, A). In view of Proposition 4.5, by adding the tableau rule WFN[loop(Π)] to T comp, we characterize models of Comp(Π) LF (Π), which coincide with the answer sets of Π. THEOREM 4.6. Let Π be a normal program. Then, we have that the following holds for tableau calculus T comp {WFN[loop(Π)]}: (1) Every incomplete tableau for Π and can be extended to a complete tableau for Π and. (2) Program Π has an answer set X iff every complete tableau for Π and has a unique noncontradictory branch (Π, A) such that A T atom(π) = X. (3) Program Π has no answer set iff every complete tableau for Π and is a refutation. As with Theorem 3.1 and 4.4, we have that Theorem 4.6 remains valid when replacing every by some in the second and the third item of its statement. For illustration, consider the following normal program: Π 5 = {a not b; b not a; c a; c d; d c, not a; e c; e d} We have that loop(π 5 ) = {{c, d}} and EB Π5 ({c, d}) = EB Π5 ({c, d, e}) = {{a}}. For A = {F {a}}, we thus get D {WFN[2 atom(π 5 ) ]} (Π 5, A) = {F c, F d, F e}, while D {WFN[loop(Π5)]}(Π 5, A) = {F c, F d} does not include F e. As body(e) = {{c}, {d}} ( D{FFB} (Π 5, {F c, F d}) ) F, F e D (Π {FFB,FFA,WFN[loop(Π5)]} 5, A) nonetheless holds. Hence, the combination of FFB, FFA, and WFN[loop(Π 5 )] allows us to deduce the same entries as obtained with FFB and WFN[2 atom(π5) ]. To see the relationship between the tableau rules in Figure 1 and the clausal representation of Comp(Π) LF (Π), given a tableau rule with prerequisites l 1,..., l n and l as its consequence, we define a clause δ by δ = {p v T v {l 1,..., l n, l}} { p v F v {l 1,..., l n, l}} where we let p v = v if v is an atom in P. For Π 5 as above and the tableau rules in T comp, the following theory constitutes the union of (unsubsumed) clauses given by tableau rules (other than Cut[atom(Π 5 ) body(π 5 )]): = { {p {not b}, b}, {p {not a}, a}, {p {a}, a}, {p {d}, d}, {p {c}, c}, {p {c,not a}, c, a} } (2) { } { p{not b}, b}, { p {not a}, a}, { p {a}, a}, { p {d}, d}, { p {c}, c}, (3) { p {c,not a}, c}, { p {c,not a}, a} { } {a, p{not b} }, {b, p {not a} }, {c, p {a} }, {c, p {d} }, {d, p {c,not a} }, (4) {e, p {c} }, {e, p {d} } { { a, p {not b} }, { b, p {not a} }, { c, p {a}, p {d} }, { d, p {c,not a} }, { e, p {c}, p {d} } } (5) The clauses in (2) are obtained from tableau rule FTB, and likewise from its contrapositive BFB. Similarly, the clauses in (3), (4), and (5) result from FFB or BTB, FTA or BFA, and FFA or BTA, respectively. Note that the clauses in rephrase the equivalences contained in Comp(Π 5 ), so

13 Tableau Calculi for Logic Programs under Answer Set Semantics 13 that Comp(Π 5 ). In fact, the (deterministic) tableau rules in T comp express conditions for unit propagation, as performed in SAT solvers used by assat, cmodels, and sag. When we extract clauses from tableau rule WFN[loop(Π 5 )], or likewise from WFJ[loop(Π 5 )], we get the theory Λ: Λ = { { c, p {a} }, { d, p {a} } } Once clauses from Λ LF (Π 5 ) have been added to Comp(Π 5 ) (to eliminate some invalid answer set candidate), they can be used for unit propagation in a SAT solver, just like the clauses in. In native conflict-driven learning ASP solvers, such as smodels cc [Ward and Schlipf 2004] and clasp [Gebser et al. 2007], the clauses obtained from tableau rules contribute reasons for conflicts. For clasp, such clauses correspond to the sets Π and Λ Π of nogoods (cf. [Gebser et al. 2007]), and the (implicit) constraints propagated by smodels cc, extracting reasons relative to smodels propagation rules, are closely related to clauses obtained from tableau rules (cf. [Giunchiglia and Maratea 2005; Gebser and Schaub 2006a; Giunchiglia et al. 2008]). This indicates that the tableau rules in Figure 1 are well-suited to characterize conditions for propagation as applied in both SAT-based and native conflict-driven learning ASP solvers. Of course, our tableaux reflect neither preprocessing techniques, such as the ones described in [Babovich and Lifschitz 2003; Gebser et al. 2008], nor backjumping and learning schemes of conflict-driven learning SAT and ASP solvers (see, e.g., [Marques-Silva and Sakallah 1999; Zhang et al. 2001; Eén and Sörensson 2004; Biere et al. 2009]). We note that the calculus based on state transition graphs presented in [Lierler 2011] captures backjumping and conflict-driven learning as performed by smodels cc ; in that work, the clauses attributed to smodels cc avoid auxiliary variables for rule bodies in favor of (non-erasable) duplicate literals. Finally, let us comment on some particularities of unfounded set handling. On the one hand, Proposition 4.5 shows that tableau rule WFN[2 atom(π) ] can be replaced by more restrictive rule WFN[loop(Π)] without sacrificing deducible entries. In fact, SAT-based ASP solvers concentrate the consideration of positive recursion on loops, and native ASP solvers like clasp, dlv, and smodels exploit strongly connected components of programs dependency graphs to achieve a similar effect. However, no existing ASP solver incorporates a contrapositive of WFN, that is, WFJ[2 atom(π) ] or WFJ[loop(Π)], in its propagation (unless loop formulas have been recorded). An approach to extend unfounded set handling in this direction has been presented in [Chen et al. 2008; 2009]. Unfortunately, it amounts to failed-literal detection (cf. [Freeman 1995; Simons et al. 2002]), whose high (polynomial) computational cost makes its unrestricted application prohibitive in practice. It is still interesting that a result similar to Proposition 4.5 cannot be obtained for WFJ[2 atom(π) ] and WFJ[loop(Π)]. The fact that the latter tableau rule is strictly weaker than the former can be observed by considering Π 5 along with A = {T e}. Since EB Π5 ({c, d, e}) = {{a}}, we obtain that T {a} D {WFJ[2 atom(π 5 ) ]} (Π 5, A). On the other hand, since loop(π 5 ) = {{c, d}} and body(e) = {{c}, {d}}, neither WFJ[loop(Π 5 )] nor any of the tableau rules (a) (i) in Figure 1 (in particular, BTA) is applicable in the branch (Π 5, A), that is, D {(a) (i),wfj[loop(π5)]}(π 5, A) =. Regarding the impact of not at all applying WFJ or restricting the sets of atoms to which it can be applied to loops, in Section 6, we show that WFJ can be simulated by means of Cut and WFN, using exactly the idea of failed-literal detection. 5. GENERIC TABLEAUX FOR COMPOSITE LANGUAGE CONSTRUCTS In what follows, we generalize our approach and develop an extensible tableau framework for logic programs incorporating composite language constructs, such as dlv s aggregates [Faber et al. 2008] or smodels cardinality and weight constraints [Simons et al. 2002]. To this end, we take a more abstract perspective than before and view, e.g., conjunctions as (simple) Boolean aggregates,

14 14 Martin Gebser and Torsten Schaub which like atoms can be preceded by not. However, we also show below that the dedicated tableau framework introduced in Section 3 and the generic approach developed in the sequel coincide on the common language fragment of normal programs. The basic idea of our generic approach is to specify core tableau rules that, for one, aim at establishing model conditions by propagating truth and falsity of entries along program rules. For instance, consider the rule (0{a, d}1 1{b, not e}2), including two cardinality constraints. 11 If 1{b, not e}2 holds wrt an assignment, we know that 0{a, d}1 must hold as well; conversely, 1{b, not e}2 must not hold if it is known that 0{a, d}1 does not hold. In our generic framework, such inferences are reflected by deducing T 0{a, d}1 from T 1{b, not e}2 or, conversely, F 1{b, not e}2 from F 0{a, d}1. Notice that we associate truth values with cardinality constraints, and that matching them to truth values of the cardinality constraints literals requires specific tableau rules. Hence, when we below augment our framework with composite language constructs, we also introduce such construct-specific tableau rules. Regardless of concrete program syntax, an answer set must be a minimal model of the reduct relative to itself, as in the case of normal programs (cf. Section 2). Our generic tableau rules reflect this minimality requirement by investigating external supports of sets of atoms. To this end, for a rule (α β) and an assignment A, we make use of two predicates, sup A (α, S) and sup A (β, S ), to check whether a set S of atoms can be supported via α and whether β can hold independently of atoms in S. Since our tableau rules consider subsets S of S, viz. S = or S = S, the two predicates allow us to test whether (α β) provides an external support for S wrt A. Of particular interest are the cases where there is no external support for S, as it tells us that all atoms of S must be false, or where there is exactly one external support (α β) for S. In the latter case, if S contains some true atom, we know that β must hold, and additional entries might be required too, for which we provide two sets, min A (α, S) and max A (β, S ). For instance, if at least one of the entries T a and T b belongs to a given assignment A and the rule (0{a, d}1 1{b, not e}2) is the single external support for the set {a, b}, we get min A (0{a, d}1, {a, b}) = {F d} and max A (1{b, not e}2, {a, b}) = {F e}. In fact, if d was true, the upper bound 1 of 0{a, d}1 would be reached, so that no further atom can be supported. Likewise, if the literal not e in 1{b, not e}2 was false, the lower bound 1 of 1{b, not e}2 could only be achieved by making b true, so that the support is not external to {a, b}. Since the definitions of sup, sup, min, and max are specific to a language construct at hand, we below develop them gradually upon integrating composite language constructs into our generic framework. To be more precise, after in Section 5.1 generalizing the definitions from Section 2, we devise generic tableau rules in Section 5.2. These are augmented with tableau rules for conjunctions, cardinality constraints, and disjunctions in Section 5.3, 5.4, and 5.5, respectively. 5.1 Answer Sets for Propositional Theories Among several proposals defining answer sets for logic programs accommodating particular language extensions (e.g., [Simons et al. 2002; Ferraris and Lifschitz 2005; Faber 2005; Ferraris 2005; Liu and Truszczyński 2006; Faber et al. 2011]), we rely on the one by Ferraris [Ferraris 2005], as it is general enough to deal with arbitrary (ground) aggregates and has a firm basis in the logic of here-and-there [Pearce 1996; Lifschitz et al. 2001]. To achieve generality, this semantics 11 A cardinality constraint like 1{b, not e}2 resembles a linear inequality, viz. 1 b + (1 e) 2, over Boolean variables. By assigning each of the variables b and e to either 1 (true) or 0 (false), the inequality evaluates to true or false, respectively. For instance, (1 1) 2 holds with b = e = 1, while (1 1) 2, obtained with b = 0 and e = 1, does not hold.

15 Tableau Calculi for Logic Programs under Answer Set Semantics 15 applies to propositional theories and identifies aggregates with propositional formulas. Formally, a propositional theory is a finite set of propositional formulas, constructed from atoms in an alphabet P and the connectives,,, and. Any other connective is considered as an abbreviation, in particular, φ stands for (φ ). An interpretation, represented by the set X of its entailed atoms, is a model of a propositional theory Φ if X = φ for all φ Φ, where = is the standard satisfaction relation of propositional logic. The reduct, denoted by Φ X, of Φ wrt X is a propositional theory, (recursively) defined as follows: Φ X = { φ X φ Φ } if X = φ φ X = φ if φ X φ X 1 φ X 2 if X = φ and φ = (φ 1 φ 2 ) for {,, } Intuitively, all (maximal) subformulas of Φ that are false in X are replaced by in Φ X, while other subformulas of Φ stay intact. Hence, any model X of Φ is a model of Φ X as well. Also note that all occurrences of negation, i.e., subformulas of the form (φ ), are replaced by constants in Φ X, since either φ or (φ ) is false in X. An interpretation X is an answer set of a propositional theory Φ if X is a minimal model of Φ X. In fact, an answer set X of Φ is the unique least model of Φ X because all atoms occurring in Φ X belong to X, but a least model of Φ X is, in general, not guaranteed to exist. As an example, consider the propositional theory Φ = {a b} along with its reducts Φ = { }, Φ {a} = {a }, Φ {b} = { b}, and Φ {a,b} = {a b}. While is not a model of Φ, the proper subsets {a} and {b} of {a, b} are models of Φ {a,b}. As {a} and {b} are minimal models of Φ {a} and Φ {b}, respectively, they are answer sets of Φ. Furthermore, observe that a is the only atom occurring in Φ {a}, and the same applies to b and Φ {b}. In a general setting, we understand a (propositional) logic program Π over an alphabet P as a finite set of rules of the form (α β) where α and β are literals, that is, expressions over P possibly preceded by not. As before, atom(π) denotes the set of atoms occurring in Π. In the following, we refine heads α and bodies β for obtaining particular classes of logic programs. The semantics of a logic program is given by the answer sets of an associated propositional theory, obtained via a translation τ described below. However, the proof-theoretic characterizations we provide apply directly to logic programs, without translating them to propositional theories. 5.2 Generic Tableau Rules We begin with a simple class of unary programs where rules (α β) are restricted to atomic literals, that is, each of α and β is equal to either p or not p for an atom p P. 12 The semantics of a unary program Π is given by the answer sets of a propositional theory, τ[π], (recursively) defined as follows: τ[π] = {τ[β] τ[α] (α β) Π} (6) { τ[v] if π = not v τ[π] = (7) π if π P 12 Our notion of a unary program is different from the one considered in [Janhunen 2006]. The latter allows for one positive and arbitrarily many negative body literals, but not for negative head literals.