CS-E3220 Declarative Programming

Transcription

1 CS-E3220 Declarative Programming Lecture 7: Advanced Topics in ASP Aalto University School of Science Department of Computer Science Spring 2018

2 Motivation Answer sets and the stable model semantics allows us to understand the meaning of logic programs in an unambiguous way. At this lecture, we will introduce several concepts that help to understand the nature of logic programs even further. The presented characterizations of stable models form the basis for the efficient computation of answer sets. Logic Program SharedContext Propositional Variables Atoms Bodies Static Nogoods Implication Graph Solver 1...n Decision Heuristic Conflict Resolution Assignment Atoms/Bodies Preprocessing Program Builder Enumerator Nogood Distributor Propagation Unit Propagation Post Propagation Preprocessor Recorded Nogoods [Gebser et al.] ParallelSolve Counter T W... Queue P1 P2... Threads S1 S2... Shared Nogoods S Pn Sn 2/36

3 Program Development and Verification We need some notion(s) of equivalence to decide when two logic programs can be considered to have exactly the same meaning. It is possible to implement verification tasks by combining suitable translations of input programs, and using ASP solvers for the search of counter-examples. a a, c. a d, d. b. b c, d. c b. c d. d c. b. b c, d. c b. c d. d c. b. c d. d c. What are the correctness criteria for the simplifications done above? 3/36

4 Translating ASP Towards SAT Example Clark s completion provides a starting point for translations. Completion is faithful (i.e., model-preserving) for tight programs. Loop formulas can be introduced to cover arbitrary programs. Translations from ASP into SAT are necessarily non-modular: Normal Program Models Clauses a b. b a. {a}, {b} a b, a b a b. b a. /0 a b, a b, a b We cannot translate an ASP program rule-by-rule! 4/36

5 An Impossibility Result Theorem There is no faithful and modular translation Tr C from normal programs into sets of clauses. Proof Assume that for all normal programs P, P 1, and P 2, SM(P) /0 if and only if CM(Tr C (P)) /0, and Tr C (P 1 P 2 ) = Tr C (P 1 ) Tr C (P 2 ). Consider normal programs P 1 = {a a, b.} and P 2 = {b.}: 1. Now SM(P 1 ) = /0 implies that CM(Tr C (P 1 )) = /0. 2. Thus CM(Tr C (P 1 ) Tr C (P 2 )) = /0 and also CM(Tr C (P 1 P 2 )) = /0. 3. It follows that SM(P 1 P 2 ) = /0. A contradiction, since SM(P 1 P 2 ) = {{b}}. 5/36

6 Agenda Notions of Equivalence Translation-Based Verification Clark s Completion Tight Programs Loop Formulas Characterization of Stable Models 6/36

7 1. NOTIONS OF EQUIVALENCE The program development in ASP resembles that in conventional programming languages: the final program solving a particular problem is obtained after a number of revisions to the first version. Such revisions may aim at changing the set of answer sets or improving the performance of the answer-set solver. A basic question is whether the different versions of a program yield the same answer sets (capturing the solutions to a problem). We are mainly interested to answer this question in the case of weight constraint programs (WCPs) formed using: Normal rules: a b 1,...,b n, c 1,..., c m. Choice rules: {a 1,...,a h } b 1,...,b n, c 1,..., c m. Cardinality rules: a l {b 1,...,b n, c 1,..., c m }. Weight rules: a l {w 1 : b 1,...,w n : b n, v 1 : c 1,...,v m : c m }. 7/36

8 Weak and Strong Equivalence There are two basic notions of equivalence depending on whether we take into account the potential contexts of programs or not. Definition Two weight constraint programs P and Q are 1. (weakly) equivalent, denoted by P Q, iff SM(P) = SM(Q), and 2. strongly equivalent [Lifschitz, 2001], denoted by P s Q, iff for all weight constraint programs R, Proposition P R Q R, i.e., SM(P R) = SM(Q R). For all weight constraint programs P and Q, P s Q implies P Q (but not vice versa) and for any context program R, P R s Q R (congruence). 8/36

9 Examples Consider the weak/strong equivalence of following pairs of programs: P Q P Q? P s Q? a a. yes yes a b. a. yes no a b. b a. {a,b}. no no a b, b. yes yes a b. a b. a. yes no a a. a b. b a. yes no Provide a witnessing context R for the cases with P s Q! Example For the second pair of programs, adding b as a fact is sufficient: SM({a b. b. }) = {{b}} whereas SM({a. b. }) = {{a,b}}. 9/36

10 Characterization of Strong Equivalence Theorem Given a WCP P, an SE-interpretation is a pair N,M of ordinary interpretations such that N M At(P) [Turner, 2003]. An SE-interpretation N, M for P is an SE-model of P if and only if M = P and N = P M. Let SE(P) denote the set of SE-models of P. For any WCPs P and Q, P s Q if and only if SE(P) = SE(Q). Example Consider P = {a b. a b. } and Q = {a. } from the previous slide. The fact that P s Q is witnessed by 1. the context R = {b a. }, and 2. an SE-model /0,{a,b} of P which is not an SE-model of Q. Which SE-interpretations are the other SE-models of P and Q? 10/36

11 From Counter-Models to Context Programs The number of possible context programs R is much higher than the number of possible counter-models for strong equivalence. Actually, context programs can be restricted to unary programs consisting only of facts or unary rules of the form a b. Proposition Let P and Q be two WCPs such that N,M SE(P) but N,M SE(Q) and R a context program containing 1. for each a N, the fact a., and 2. for each a,b M \ N, the unary rule a b. Then M SM(P R), but M SM(Q R), i.e., R witnesses P s Q. Example For our preceding example, we obtain R with a b and b a. 11/36

12 Complexity Results The question is whether it is computationally feasible to verify P Q (or P s Q) for two programs under consideration. To ease complexity analysis, we distinguish the respective inclusion problems for and s as follows. Definition 1. The language WEQIN is the set of pairs P,Q of finite WCPs such that SM(P) SM(Q). 2. The language WEQ is the set of pairs P,Q of finite WCPs such that SM(P) = SM(Q). 3. The language SEQIN is the set of pairs P,Q of finite WCPs programs such that SE(P) SE(Q). 4. The language SEQ is the set of pairs P,Q of finite WCPs such that SE(P) = SE(Q). 12/36

13 Complexity Results Theorem The complement of WEQIN is in NP and NP-hard/complete, i.e., WEQIN is conp-complete. Theorem The complement of SEQIN is in NP, i.e., SEQIN is in conp. Theorem SEQIN is conp-hard [Lin, 2002]. Corollary Both WEQ and SEQ are conp-complete. We may use ASP solvers to study the equivalence of WCPs. 13/36

14 2. TRANSLATION-BASED VERIFICATION The idea is to translate two programs P and Q into a single program Tr EQ (P,Q) having a stable model iff M SM(P) such that M SM(Q). If such a stable model M is found, it acts as a certificate and a counter-model for programs P and Q not being equivalent. The translation-based verification of P Q counts on P Q Tr EQ (P,Q) and Tr EQ (Q,P) have no stable models. It is assumed (without loss of generality) that At(P) = At(Q). A number of new atoms not appearing in At(P) are needed: 1. an atom a for each atom a At(Q) to represent the reduct Q M with respect to a potential counter-example M, and 2. atoms d and f for additional control. 14/36

15 Translation for Equivalence Checking Definition For WCPs P and Q with At(P) = At(Q), the translation Tr EQ (P,Q) = P Q {d a, a. d a, a. a At(Q)} {f d, f. } where Q contains 1. a b 1,...,b n, c 1,..., c m for each basic rule, 2. a l {b 1,...,b n, c 1,..., c m } for each cardinality rule, 3. a i b 1,...,b n,a i, c 1,..., c m for each choice rule and head atom a i {a 1,...,a h }, and 4. a l {w 1 : b 1,...,w n : b n,v 1 : c 1,...,v m : c m } for each weight rule in the program Q. 15/36

16 Observations about the Translation Tr EQ (P,Q) Theorem The translation Tr EQ (P,Q) is designed to capture pairs P,Q of WCPs such that P,Q WEQIN. To this end, the parts of Tr EQ (P,Q) play the following roles: 1. The rules of P capture a stable model M SM(P). 2. The rules of Q express LM(Q M ) using At(Q). 3. Rules of the forms d a, a and d a, a check whether M and LM(Q M ) differ with respect to some a At(Q). 4. The rule f d, f excludes cases where there is no difference, i.e., M LM(Q M ) is enforced. For any WCPs P and Q with At(P) = At(Q), 1. the translation Tr EQ (P,Q) has a stable model M SM(P) such that M SM(Q), and 2. P Q SM(Tr EQ (P,Q)) = /0 and SM(Tr EQ (Q,P)) = /0. 16/36

17 Example Let us check the equivalence of the following programs: P: {a,b}. Q: a b. a a, b. b a. The translation Tr EQ (P,Q) consists of {a,b}. a a, b. a b. b a. d a, a. d b, b. d a, a. d b, b. f d, f. Given these, it is easy to verify the following: 1. There is N = {a,b,d} SM(Tr EQ (P,Q)) giving rise to a counter-model M = N At(P) SM(P) so that P Q. 2. The reduct Tr EQ (P,Q) N = {a. b. d a. d b. }. 17/36

18 Tool for Checking Equivalence There is a translator called LPEQ (v. 1.25) that implements the translation-based verification method described above. The actual search for potential counter-examples can be implemented using an ASP solver such as CLASP. The weak equivalence of two WCPs, first grounded with GRINGO (version 5 below), can be checked with the following commands: $ gringo --output smodels p1.lp > p1.sm $ gringo --output smodels p2.lp > p2.sm $ lpeq p1.sm p2.sm clasp 1 $ lpeq p2.sm p1.sm clasp 1 Classical and strong equivalence can be checked similarly. 18/36

19 3. CLARK S COMPLETION Our next goal is to characterize stable models of programs using the set of classical models CM(S) = {M Vars(S) M = S}. Ultimately, we aim at a faithful translation which preserves the semantics of a program (i.e., a one-to-one correspondence between stable models and classical models) up to At(P). Clark s completion procedure provides a preliminary translation of a normal program P into a propositional theory Comp(P). Although the translation Comp( ) is not faithful in general, it can be characterized in terms of supported models of programs. Definition We abbreviate a b 1,...,b n, c 1,..., c m by a B, C. Given a normal program P and an atom a At(P), let Def P (a) denote the definition of a in P, i.e., the set of normal rules a B, C P having the atom a as their head. 19/36

20 Completing Definitions of Atoms Definition For a finite normal program P, the completion Comp(P) includes a n i=1 ( b B i b c Ci c) for each atom a At(P) and the respective definition Def P (a) = {a B 1, C a B n, C n. }. A couple of observations about Comp(P) follow: 1. The transformation is not faithful in general because, e.g., SM(P) = {/0} and CM(Comp(P)) = {/0,{a,b}} for P = {a b. b a.} and Comp(P) = {a b,b a}. 2. The derivation of a CNF for Comp(P) is exponential in the worst case unless new atoms are introduced as names for rule bodies. 20/36

21 Supported Models Definition For a normal program P, an interpretation M At(P) is a supported model of P if and only if M = {a a B P M and B M}. Proposition If M At(P) is a supported model of a normal program P and a M, then there is a supporting rule a B, C P such that a is the head of the rule and M = B C. Example The program P = {a b. b a. } has two supported models M 1 = /0 and M 2 = {a,b} based on P M 1 = P = P M 2 but only M 1 is stable: 1. LM(P M 1) = LM(P) = /0 = M 1 and 2. LM(P M 2) = LM(P) = /0 M 2. 21/36

22 Properties of Stable and Supported Models Theorem For a normal program P, it holds in general that Proposition SM(P) SuppM(P) = CM(Comp(P)). If a normal program P contains only atomic rules of the form a C, then SM(P) = SuppM(P) = CM(Comp(P)). = The completion Comp( ) is faithful for atomic normal programs. Example Consider a program P = {a b. b a.} and its completion Comp(P) = {a b, b a} leading to a perfect match of models: SM(P) = {{a},{b}} = CM(Comp(P)). 22/36

23 4. TIGHT PROGRAMS It is possible to split programs into components as follows. Definition The dependency graph DG(P) of a WCP P is At(P), 1 where a 1 b holds for a,b At(P) if and only if (i) 1. there is a basic rule a B, C P, 2. there is a choice rule {A} B, C P such that a A, 3. there is a cardinality rule a l {B, C} P, or 4. there is a weight rule a l {w B : B, v C : C} P, and b B C, or (ii) a = b and a A for some choice rule {A} B, C P. Remark The positive dependency graph DG + (P) of P is defined analogously but using only (i) and positive dependencies (b B). 23/36

24 Strongly Connected Components The overall dependency relation ( At(P) 2 ) is the reflexive and transitive closure ( 1 ) of the immediate relation 1. Thus a b holds if and only if there is a sequence a 1,...,a n of atoms from At(P) such that n > 0 and a = a a n = b. Definition A strongly connected component (SCC) of DG(P) = At(P), 1 is a maximal subset S of At(P) such that a b and b a for every a,b S. Example The dependency graph DG(P) of the WCP a b. b c. c a. {a,b,c} d, e. d e. e d. b c Positive dep. Negative dep. d has SCCs S 1 = {a,b,c} and S 2 = {d,e}. a e 24/36

25 Tight Programs There are subclasses of normal programs P for which Comp(P) provides a sufficient (faithful) translation into propositional logic. Definition A normal program P is tight if and only if DG + (P) is acyclic. Example The program P 1 = {a b. b a, c. c a.} is tight whereas P 2 = {a b, c. b a. } is not. Theorem If a finite normal logic program P is tight, then SM(P) = CM(Comp(P)) = SuppM(P). 25/36

26 Relaxed Notions of Tightness It is possible that certain (syntactic) positive dependencies are never activated given the other rules of the program. The projection of DG + (P) = At(P), 1 with respect to an interpretation M At(P) is defined as M,{ a,b M 2 a 1 b}. The definition of tightness can be relaxed as follows. Definition 1. A normal logic program P is tight on an interpretation M At(P) iff the projection of DG + (P) with respect to M is acyclic. 2. A normal logic program P is tight if and only if P is tight on every supported model M SuppM(P). Example The program P = {a b. b a. f a, b, f.} is tight. 26/36

27 Relaxed Tightness in Action Example Consider the following program P n with n > 0 and Gnd(P n ): node(0..n). edge(n,n + 1) node(n), node(n + 1). edge(n,0). in(x,y) out(x,y), edge(x,y). out(x,y) in(x,y), edge(x,y). in(x,y) : edge(x,y). out(x,y), out(z,v), edge(x,y), edge(z,v), X Z. reach(x,y) in(x,y), edge(x,y). reach(x, Y) reach(x, Z), in(z, Y), node(x), edge(z, Y). E.g., when n = 2, one of the n + 1 = 3 supported models is M = {node(0), node(1), node(2), edge(0, 1), edge(1, 2), edge(2, 0), out(0, 1), in(1, 2), in(2, 0), reach(1, 2), reach(2, 0), reach(1, 0) }. The program Gnd(P n ) is tight on M indicating that M is stable. 27/36

28 5. LOOP FORMULAS Since Comp(P) is faithful for certain programs, the question is whether it can be revised to be faithful for all normal programs. As suggested by preceding examples, the answer to this question goes back to positively interdependent atoms in programs. Definition 1. Given a program P, a loop L is a set {a 1,...,a n } At(P) so that a a n and a n 1 a 1 in DG + (P). 2. The set of loops of a program P is denoted by loops + (P). Remarks On the basis of this definition, we observe that 1. atoms in a loop L are mutually dependent in terms of, and 2. a loop L need not be maximal, i.e., an SCC of DG + (P). 28/36

29 Supporting Rules A supported model M of P has a set of supporting rules SuppR(P,M) = {a B, C P M = B C}. A loop L for P must be similarly supported under stable models but the support for L must be external to L. Definition Given a loop L of a normal program P, the set ExtSupp(L,P) includes a formula ( b B b c C c) for each a L and each externally supporting rule a B, C P such that B L = /0. Definition The disjunctive loop formula LF P (L) associated with L loops + (P) is L ExtSupp(L, P) and LF(P) = {LF P (L) L /0 and L loops + (P)}. 29/36

30 Deriving Loop Formulas Example Consider the following normal logic program P: a b. b a. c d. d c. a c. b d. 1. There is only one nonempty loop L = {a,b} for P based on the positive dependencies a 1 b and b 1 a in DG + (P). 2. The set ExtSupp(L,P) = { c,d}. 3. The respective loop formula LF P (L) = a b c d c d a b b a c d Positive dep. Negative dep. 4. If the last two rules of P were deleted, the loop formula would be accordingly revised to a b ( a b). 30/36

31 6. CHARACTERIZATION OF STABLE MODELS Theorem Let P be a finite normal logic program P and M At(P) an interpretation. Then M SM(P) if and only if M = Comp(P) LF(P). Example For the program P from the preceding example, we have Comp(P) LF(P) = {a b c, b a d, c d, d c, a b c d} which has two classical models M 1 = {c} and M 2 = {a,b,d} so that SM(P) = {M 1,M 2 }. On the other hand, the model M 3 = {a,b,c} of Comp(P) does not satisfy LF(P) and thus M 3 SM(P). 31/36

32 Summary of Properties The translation Tr CL (P) = Comp(P) LF(P) is faithful. But the translation Tr CL (P) is exponential in the worst case. By introducing new atoms, the translation is feasible in polynomial time and the length of the translation is O( P log 2 ( At(P) )) where P gives the length of the program [Janhunen, 2006]. Example Consider, for instance, the number of loops for a program P n = {a i a j. 1 i,j n}. Any subset of At(P n ) = {a 1,...,a n } is a loop! 32/36

33 Computing Stable Models Clark s completion and loop formulas can be exploited in the computation of stable models. If the stability test fails for a candidate M SuppM(P), then LM(P M ) M, implying the existence of a loop L M \ LM(P M ). The AsSAT algorithm [Lin and Zhao, 2003] implements a DPLL-style search for stable models: Models of Comp(P) are searched using a SAT solver. Loop formulas are added incrementally for unstable models found. The one-shot translation of LP2SAT [Janhunen, 2006] is faithful and its output is valid input to a SAT solver as is. The CDNL-ASP algorithm [Gebser et al., 2012] uses CDCL and introduces completion and loop formulas only dynamically. 33/36

34 SUMMARY The expressive power of rules exceeds that of propositional formulas, making translations from ASP to SAT non-trivial. Loop formulas can be introduced in order to fill in the gap between tight and arbitrary (non-tight) programs. Clark s completion is an essential step/concept when implementing ASP in an efficient way. Moreover, many reasoning techniques that we addressed in the case of SAT checking can be readily exploited in ASP solving. 34/36

35 OBJECTIVES You are familiar with basic notions of equivalence that have been proposed for logic programs used on ASP. You understand how stable models can be characterized in terms of Clark s completion and loop formulas. You are able to calculate the following for small programs: The sets of models SM(P) and SuppM(P) = CM(Comp(P)). The dependency graphs DG(P) and DG + (P) and their SCCs. The set of loop formulas LF(P). You are aware of SAT solvers as potential search engines when implementing the search of answer sets. 35/36

36 Bibliography M. Gebser, B. Kaufmann, and T. Schaub: Conflict-Driven Answer Set Solving: from Theory to Practice, T. Janhunen: Some (In)translatability Results for Normal Logic Programs and Propositional Theories, V. Lifschitz: Strongly Equivalent Logic Programs, F. Lin: Reducing Strong Equivalence of Logic Programs to Entailment in Classical Propositional logic, F. Lin and Y. Zhao: ASSAT: computing answer sets of a logic program by SAT solvers, H. Turner: Strong Equivalence for Logic Programs and Default Theories (Made Easy), /36