Modular Equivalence for Normal Logic Programs

Transcription

1 Modular Equivalence for Normal Logic Programs Emilia Oikarinen and Tomi Janhunen Department of Computer Science and Engineering Helsinki University of Technology (TKK) P.O. Box 5400, FI TKK, Finland and Abstract A Gaifman-Shapiro-style architecture of program modules is introduced in the case of normal logic programs under stable model semantics. The composition of program modules is suitably limited by module conditions which ensure the compatibility of the module system with stable models. The resulting module theorem properly strengthens Lifschitz and Turner s splitting set theorem (1994) for normal logic programs. Consequently, the respective notion of equivalence between modules, i.e. modular equivalence, proves to be a congruence relation. Moreover, it is analyzed (i) how the translation-based verification technique from (Janhunen & Oikarinen 2005) is accommodated to the case of modular equivalence and (ii) how the verification of weak/visible equivalence can be reorganized as a sequence of module-level tests and optimized on the basis of modular equivalence. Introduction Answer set programming (ASP) is a very promising constraint programming paradigm (Niemelä 1999; Marek & Truszczyński 1999; Gelfond & Leone 2002) in which problems are solved by capturing their solutions as answer sets or stable models of logic programs. The development and optimization of logic programs in ASP gives rise to a metalevel problem of verifying whether subsequent programs are equivalent. To solve this problem, a translation-based approach has been proposed and extended further (Janhunen & Oikarinen 2002; Turner 2003; Oikarinen & Janhunen 2004; Woltran 2004). The underlying idea is to combine two logic programs P and Q under consideration into two logic programs EQT(P, Q) and EQT(Q, P ) which have no stable models iff P and Q are weakly equivalent, i.e. have the same stable models. This enables the use of the same ASP solver, such as SMODELS (Simons, Niemelä, & Soininen 2002), DLV (Leone et al. 2006) or GNT (Janhunen et al. 2006), for the equivalence verification problem as for the search of stable models in general. First experimental results (Janhunen & Oikarinen 2002; Oikarinen & Janhunen The research reported in this paper has been partially funded by the Academy of Finland (project #211025). The financial support from Helsinki Graduate School in Computer Science and Engineering, Nokia Foundation, and Finnish Cultural Foundation is gratefully acknowledged. 2004) suggest that the translation-based method can be effective and sometimes much faster than performing a simple cross-check of stable models. As a potential limitation, the translation-based method as described above treats programs as integral entities and therefore no computational advantage is sought by breaking programs into smaller parts, say modules of some kind. Such an optimization strategy is largely preempted by the fact that weak equivalence, denoted by, fails to be a congruence relation for, i.e. weak equivalence is not preserved under substitutions in unions of programs. More formally put, P Q does not imply P R Q R in general. The same can be stated about uniform equivalence (Sagiv 1987) but not about strong equivalence (Lifschitz, Pearce, & Valverde 2001) which admits substitutions by definition. From our point of view, strong equivalence seems inappropriate for fully modularizing the verification task of weak equivalence. This is simply because two programs P and Q may be weakly equivalent even if they build on respective modules P i P and Q i Q which are not strongly equivalent. For the same reason, program transformations that are known to preserve strong equivalence (Eiter et al. 2004) do not provide an inclusive basis for reasoning about weak equivalence. Nevertheless, there are cases where one can utilize the fact that strong equivalence implies weak equivalence. For instance, if P and Q are composed of strongly equivalent pairs of modules P i and Q i for all i, then P and Q can be directly inferred to be strongly and weakly equivalent. These observations about strong equivalence motivate the strive for a weaker congruence relation that is compatible with weak equivalence at program-level. To address the lack of a suitable congruence relation in the context of ASP, we propose a new design in this article. The design superficially resembles that of Gaifman and Shapiro (1989) but stable model semantics (Gelfond & Lifschitz 1988) and special module conditions are incorporated. The feasibility of the design is crystallized in a module theorem which shows the module system fully compatible with stable models. In fact, the module theorem established here is a proper strengthening of the splitting set theorem established by Lifschitz and Turner (1994) in the case of normal logic programs. The main difference is that our result allows negative recursion between modules. Moreover, it enables the introduction of a notion of

2 equivalence, i.e. modular equivalence, which turns out to be a proper congruence relation and reduces to weak equivalence for program modules which have a completely specified input and no hidden atoms. This kind of modules correspond to normal logic programs with completely visible Herbrand base. If normal programs P and Q are composed of modularly equivalent modules P i and Q i for all i, then P and Q are modularly equivalent or equivalently stated weakly equivalent. The notion of modular equivalence opens immediately new prospects as regards the translationbased verification method (Janhunen & Oikarinen 2002; Oikarinen & Janhunen 2004). First of all, the method can be tuned for the task of verifying modular equivalence by attaching a context generator to program modules in analogy to (Woltran 2004). Second, we demonstrate how the verification of weak equivalence can be reorganized as a sequence of tests, each of which concentrates on a pair of respective modules in the programs subject to the verification task. The plan for the rest of this article is as follows. As a preparatory step, we briefly review the syntax and semantics of normal logic programs and define notions of equivalence addressed in the sequel. After that we specify program modules as well as establish the module theorem discussed above. Next, we define the notion of modular equivalence, prove the congruence property for it, and give a brief account of computational complexity involved in the respective verification problem. Connections between modular equivalence and the translation-based method for verifying visible equivalence (Janhunen & Oikarinen 2005) are also worked out. Finally, we briefly contrast our work with earlier approaches and present our conclusions. Normal Logic Programs We will consider propositional normal logic programs in this paper. Definition 1 A normal logic program (NLP) is a (finite) set of rules of the form h B +, B, where h is an atom, B + and B are sets of atoms, and B = { b b B} for any set of atoms B. The symbol denotes default negation or negation as failure to prove (Clark 1978). Atoms a and their default negations a are called default literals. A rule consists of two parts: h is the head and the rest is the body. Let Head(P ) denote the set of head atoms appearing in P, i.e. Head(P ) = {h h B +, B P }. If the body of a rule is empty, the rule is called a fact and the symbol can be omitted. If B =, the rule is positive. A program consisting only of positive rules is a positive logic program. Usually the Herbrand base Hb(P ) of a normal logic program P is defined to be the set of atoms appearing in the rules of P. We, however, use a revised definition: Hb(P ) is any fixed set of atoms containing all atoms appearing in the rules of P. Under this definition the Herbrand base of P can be extended by atoms having no occurrences in P. This aspect is useful e.g. when P is obtained as a result of optimization and there is a need to keep track of the original Herbrand base. Moreover, Hb(P ) is supposed to be finite whenever P is. Given a normal logic program P, an interpretation M of P is a subset of Hb(P ) defining which atoms of Hb(P ) are true (a M) and which are false (a M). An interpretation M Hb(P ) is a (classical) model of P, denoted by M = P iff B + M and B M = imply h M for each rule h B +, B P. For a positive program P, M Hb(P ) is the (unique) least model of P, denoted by LM(P ), iff there is no M = P such that M M. Stable models as proposed by Gelfond and Lifschitz (1988) generalize least models for normal logic programs. Definition 2 Given a normal logic program P and an interpretation M Hb(P ) the Gelfond-Lifschitz reduct P M = {h B + h B +, B P and M B = }, and M is a stable model of P iff M = LM(P M ). Stable models are not necessarily unique in general: a normal logic program may have several stable models or no stable models at all. The set of stable models of a NLP P is denoted by SM(P ). We define a positive dependency relation Hb(P ) Hb(P ) as the reflexive and transitive closure of a relation 1 defined as follows. Given a, b Hb(P ), we say that b depends directly on a, denoted a 1 b, iff there is a rule b B +, B P such that a B +. The positive dependency graph of P, Dep + (P ), is a graph with Hb(P ) as the set of vertices and { a, b a, b Hb(P ) and a b} as the set of edges. The negative dependency graph Dep (P ) can be defined analogously. A strongly connected component of Dep + (P ) is a maximal subset C Hb(P ) such that for all a, b C, a, b is in Dep + (P ). Thus strongly connected components of Dep + (P ) partition Hb(P ) into equivalence classes. The dependency relation can then be generalized for the strongly connected components: C i C j, i.e. C j depends on C i, iff c i c j for any c i C i and c j C j. A splitting set for a NLP P is any set U Hb(P ) such that for every rule h B +, B P, if h U then B + B U. The set of rules h B +, B P such that {h} B + B U is the bottom of P relative to U, denoted by b U (P ). The set t U (P ) = P \ b U (P ) is the top of P relative to U. The top can be partially evaluated with respect to an interpretation X U resulting a program e(t U (P ), X) that contains a rule h (B + \ U), (B \ U) for each h B +, B t U (P ) such that B + U X and (B U) X =. Given a splitting set U for a NLP P, a solution to P with respect to U is a pair X, Y such that X U, Y Hb(P ) \ U, X SM(b U (P )), and Y SM(e(t U (P ), X)). The splitting set theorem relates solutions with stable models. Theorem 1 (Lifschitz & Turner 1994) Let U be a splitting set for a NLP P and M Hb(P ). Then M SM(P ) iff the pair M U, M \ U is a solution to P with respect to U. Notions of Equivalence The notion of strong equivalence was introduced by Lifschitz, Pearce and Valverde (2001) whereas uniform equiva-

3 lence has its roots in the database community (Sagiv 1987); cf. (Eiter & Fink 2003) for the case of stable models. Definition 3 Normal logic programs P and Q are (weakly) equivalent, denoted P Q, iff SM(P ) = SM(Q); strongly equivalent, denoted P s Q, iff P R Q R for any normal logic program R; and uniformly equivalent, denoted P u Q, iff P F Q F for any set of facts F. Clearly, P s Q implies P u Q, and P u Q implies P Q, but not vice versa (in both cases). Strongly equivalent logic programs are semantics preserving substitutes of each other and the relation s can be understood as a congruence relation among normal programs, i.e. if P s Q, then P R s Q R for all normal programs R. On the other hand, uniform equivalence is not a congruence, as shown in Example 1 below. Consequently, the same applies to weak equivalence and thus and u are best suited for the comparison of complete programs, and not for modules. Example 1 (Eiter et al. 2004, Example 1) Consider normal logic programs P = {a.} and Q = {a b. a b.}. It holds P u Q, but P R Q R for R = {b a.}. Thus P s Q and u is not a congruence relation for. For P Q to hold, the stable models in SM(P ) and SM(Q) have to be identical subsets of Hb(P ) and Hb(Q), respectively. The same can be stated about strong and uniform equivalence. This makes these notions of equivalence less useful if Hb(P ) and Hb(Q) differ by some atoms which are not trivially false in all stable models. Such atoms might, however, be of use when formalizing some auxiliary concepts. Following the ideas from (Janhunen 2003) we partition Hb(P ) into two parts Hb v (P ) and Hb h (P ) which determine the visible and the hidden parts of Hb(P ), respectively. In visible equivalence the idea is that the hidden atoms in Hb h (P ) and Hb h (Q) are local to P and Q and negligible as regards the equivalence of the two programs. Definition 4 (Janhunen 2003) Normal logic programs P and Q are visibly equivalent, denoted by P v Q, iff Hb v (P ) = Hb v (Q) and there is a bijection f : SM(P ) SM(Q) such that for all interpretations M SM(P ), M Hb v (P ) = f(m) Hb v (Q). Note that the number of stable models is preserved under v. Such a strict correspondence of models is much dictated by the ASP methodology: the stable models of a program usually correspond to the solutions of the problem being solved and thus v preserves the number of solutions, too. In the fully visible case, i.e. Hb h (P ) = Hb h (Q) =, the relation v becomes very close to. The only difference is the additional requirement Hb(P ) = Hb(Q) insisted by v. This is of little importance as Herbrand bases can always be extended to meet Hb(P ) = Hb(Q). Since weak equivalence is not a congruence, visible equivalence cannot be a congruence either. The relativized variants of strong and uniform equivalence introduced by Woltran (2004) allow the context to be constrained using a set of atoms A. Definition 5 Normal logic programs P and Q are strongly equivalent relative to A, denoted by P A s Q, iff P R Q R for all normal logic programs R over the set of atoms A; uniformly equivalent relative to A, denoted by P A u Q, iff P F Q F for all sets of facts F A. Setting A = in the above reduces both relativized notions to weak equivalence, and thus neither is a congruence. Eiter et al. (2005) introduce a very general framework based on equivalence frames to capture various kinds of equivalence relations. Most of the notions of equivalence defined above can be defined using the framework. Visible equivalence is exceptional in the sense that it does not fit into equivalence frames based on projected answer sets. A projective variant of Definition 4 would simply equate {M Hb v (P ) M SM(P )} to {N Hb v (Q) N SM(Q)}. As a consequence, the number of answer sets may not be preserved which we find somewhat unsatisfactory because of the general nature of ASP as discussed after Definition 4. Consider, for instance programs P = {a b. b a. } and Q n = P {c i d i. d i c i. 0 < i n} with Hb v (P ) = Hb v (Q n ) = {a, b}. Whenever n > 0 these programs are not visibly equivalent but they would be equivalent under the projective definition. With sufficiently large values of n it is no longer feasible to count the number of different stable models (i.e. solutions) if Q n is used. Modular Logic Programs We define a logic program module similarly to Gaifman and Shapiro (1989), but consider the case of normal logic programs instead of positive (disjunctive) logic programs. Definition 6 A triple P = (P, I, O) is a (propositional logic program) module, if 1. P is a finite set of rules of the form h B +, B ; 2. I and O are sets of propositional atoms such that I O = ; and 3. Head(P ) I =. The Herbrand base of module P, Hb(P), is the set of atoms appearing in P combined with I O. Intuitively the set I defines the input of a module and the set O is the output. The input and output atoms are considered visible, i.e. the visible Herbrand base of module P is Hb v (P) = I O. Notice that I and O can also contain atoms not appearing in P, similarly to the possibility of having additional atoms in the Herbrand bases of normal logic programs. All other atoms are hidden, i.e. Hb h (P) = Hb(P) \ Hb v (P). As regards the composition of modules, we follow (Gaifman & Shapiro 1989) and take the union of the disjoint sets of rules involved in them. The conditions given by Gaifman and Shapiro are not yet sufficient for our purposes, and we impose a further restriction denying positive recursion between modules. Definition 7 Consider modules P 1 = (P 1, I 1, O 1 ) and P 2 = (P 2, I 2, O 2 ) and let C 1,..., C n be the strongly connected components of Dep + (P 1 P 2 ). There is a positive recursion between P 1 and P 2, if C i O 1 and C i O 2 for some component C i.

4 The idea is that all inter-module dependencies go through the input/output interface of the modules, i.e. the output of one module can serve as the input for another and hidden atoms are local to each module. Now, if there is a strongly connected component C i in Dep + (P 1 P 2 ) containing atoms from both O 1 and O 2, we know that, if programs P 1 and P 2 are combined, some output atom a of P 1 depends positively on some output atom b of P 2 which again depends positively on a. This yields a positive recursion. Definition 8 Let P 1 = (P 1, I 1, O 1 ) and P 2 = (P 2, I 2, O 2 ) be modules such that 1. O 1 O 2 = ; 2. Hb h (P 1 ) Hb(P 2 ) = Hb h (P 2 ) Hb(P 1 ) = ; and 3. there is no positive recursion between P 1 and P 2. Then the join of P 1 and P 2, denoted by P 1 P 2, is defined, and P 1 P 2 = (P 1 P 2, (I 1 \ O 2 ) (I 2 \ O 1 ), O 1 O 2 ). Remark. Condition 1 in Definition 8 is actually redundant as it is implied by condition 3. Also, condition 2 can be circumvented in practice using a suitable scheme, e.g. based on module names, to rename the hidden atoms uniquely for each module. Some observations follow. Since each atom is defined in one module, the sets of rules in P 1 and P 2 are disjoint, i.e. P 1 P 2 =. Also, Hb(P 1 P 2 ) = Hb(P 1 ) Hb(P 2 ), Hb v (P 1 P 2 ) = Hb v (P 1 ) Hb v (P 2 ), and Hb h (P 1 P 2 ) = Hb h (P 1 ) Hb h (P 2 ). Note that the module conditions above impose no restrictions on negative dependencies or on positive dependencies inside modules. The input of P 1 P 2 might be smaller than the union of inputs of individual modules. This is illustrated by the following example. Example 2 Consider modules P = ({a b.}, {b}, {a}) and Q = ({b a.}, {a}, {b}). The join of P and Q is defined, and P Q = ({a b. b a.},, {a, b}). The following hold for the intersections of Herbrand bases under the conditions 1 and 2 in Definition 8: Hb v (P 1 ) Hb v (P 2 ) = Hb(P 1 ) Hb(P 2 ) = (I 1 I 2 ) (I 1 O 2 ) (I 2 O 1 ), and Hb h (P 1 ) Hb h (P 2 ) =. Join operation has the following properties: Identity: P (,, ) = (,, ) P = P for all P. Commutativity: P 1 P 2 = P 2 P 1 for all modules P 1 and P 2 such that P 1 P 2 is defined. Associativity: (P 1 P 2 ) P 3 = P 1 (P 2 P 3 ) for all modules P 1, P 2 and P 3 such that the joins are defined. Note that equality sign = used here denotes syntactical equivalence, whereas semantical equivalence will be defined in the next section. The stable semantics of a module is defined with respect to a given input, i.e. a subset of the input atoms of the module. Input is seen as a set of facts (or a database) to be added to the module. Definition 9 Given a module P = (P, I, O) and a set of atoms A I the instantiation of P with the input A is P(A) = P F A, where F A = ({a. a A},, I). Note that P(A) = (P {a. a A},, I O) is essentially a normal logic program with I O as the visible Herbrand base. We can thus generalize the stable model semantics for modules. In the sequel we identify P(A) with the respective set of rules P F A, where F A = {a. a A}. In the following M I acts as a particular input with respect to which the module is instantiated. Definition 10 An interpretation M Hb(P) is a stable model of a module P = (P, I, O), denoted by M SM(P), iff M = LM(P M F M I ). We define a concept of compatibility to describe when a stable model M 1 of module P 1 can be combined with a stable model M 2 of another module P 2. This is exactly when M 1 and M 2 share the common (visible) part. Definition 11 Let P 1 and P 2 be modules, and M 1 SM(P 1 ) and M 2 SM(P 2 ) their stable models which are compatible, iff M 1 Hb v (P 2 ) = M 2 Hb v (P 1 ). If a program (module) consists of several modules, its stable models are locally stable for the respective submodules; and on the other hand, local stability implies global stability as long as the stable models of the submodules are compatible. Theorem 2 (Module theorem). Let P 1 and P 2 be modules such that P 1 P 2 is defined. Now, M SM(P 1 P 2 ) iff M 1 = M Hb(P 1 ) SM(P 1 ), M 2 = M Hb(P 2 ) SM(P 2 ), and M 1 and M 2 are compatible. Proof sketch. M 1 and M 2 are clearly compatible and it is straightforward to show that conditions 1 and 2 in Definition 8 imply M 1 SM(P 1 ) and M 2 SM(P 2 ). Consider P 1 = (P 1, I 1, O 1 ), P 2 = (P 2, I 2, O 2 ) and their join P = P 1 P 2 = (P, I, O). Let M 1 SM(P 1 ), and M 2 SM(P 2 ) be compatible and define M = M 1 M 2. There is a strict total ordering < for the strongly connected components C i of Dep + (P ) such that if C i < C j, then C i C j and C j C i ; or C i C j and C j C i. Let C 1 < < C n be such an ordering. Show that exactly one of the following holds for each C i : (i) C i I, (ii) C i O 1 Hb h (P 1 ), or (iii) C i O 2 Hb h (P 2 ). Finally, show by induction that M ( k i=1 C i ) = LM(P M F M I ) ( k i=1 C i ) holds for 0 k n by applying the splitting set theorem (Lifschitz & Turner 1994). Example 3 shows that condition 3 in Definition 8 is necessary to guarantee that local stability implies global stability. Example 3 Consider P 1 = ({a b.}, {b}, {a}) and P 2 = ({b a.}, {a}, {b}) with SM(P 1 ) = SM(P 2 ) = {, {a, b}}. The join of P 1 and P 2 is not defined because of positive recursion (conditions 1 and 2 in Definition 8 are satisfied, however). For a NLP P = {a b. b a.}, we get SM(P ) = { }. Thus, the positive dependency between a and b excludes {a, b} from SM(P ).

5 Theorem 2 is strictly stronger than the splitting set theorem (Lifschitz & Turner 1994) for normal logic programs. If U is a splitting set for a NLP P, then P = B T = (b U (P ),, U) (t U (P ), U, Hb(P ) \ U), and it follows from Theorems 1 and 2 that M 1 SM(B) and M 2 SM(T) iff M 1, M 2 \ U is a solution for P with respect to U. On the other hand the splitting set theorem cannot be applied to e.g. P Q from Example 2, since neither {a} nor {b} is a splitting set. Our theorem also strengthens a module theorem given in (Janhunen 2003, Theorem 6.22) to cover normal programs that involve positive body literals, too. Moreover, Theorem 2 can easily be generalized for modules consisting of several submodules. Consider a collection of modules P 1,..., P n such that the join P 1 P n is defined (recall that is associative). We say that a collection of stable models {M 1,..., M n } for modules P 1,..., P n, respectively, is compatible, iff M i and M j are pairwise compatible for all 1 i, j n. Corollary 1 Let P 1,..., P n be a collection of modules such that P 1 P n is defined. Now M SM(P 1 P n ) iff M i = M Hb(P i ) SM(P i ) for all 1 i n, and the set of stable models {M 1,..., M n } is compatible. Corollary 1 enables the computation of stable models on a module-by-module basis, but it leaves us the task of excluding mutually incompatible combinations of stable models. Example 4 Consider modules P 1 = ({a b.}, {b}, {a}), P 2 = ({b c.}, {c}, {b}), and P 3 = ({c a.}, {a}, {c}). The join P = P 1 P 2 P 3 is defined, P = ({a b. b c. c a.},, {a, b, c}). Now SM(P 1 ) = {{a}, {b}}, SM(P 2 ) = {{b}, {c}} and SM(P 3 ) = {{a}, {c}}. To apply Corollary 1 for finding SM(P), one has to find a compatible triple of stable models M 1, M 2, and M 3 for P 1, P 2, and P 3, respectively. Now {a} SM(P 1 ) and {c} SM(P 2 ) are compatible, since {a} Hb v (P 2 ) = = {c} Hb v (P 1 ). However, {a} SM(P 3 ) is not compatible with {c} SM(P 2 ), since {c} Hb v (P 3 ) = {c} = = {a} Hb v (P 2 ). On the other hand, {c} SM(P 3 ) is not compatible with {a} SM(P 1 ), since {a} Hb v (P 3 ) = {a} = = {c} Hb v (P 1 ). Also {b} SM(P 1 ) and {b} SM(P 2 ) are compatible, but {b} SM(P 1 ) is incompatible with {a} SM(P 3 ). Nor is {b} SM(P 2 ) compatible with {c} SM(P 3 ). Thus it is impossible to select M 1 SM(P 1 ), M 2 SM(P 2 ) and M 3 SM(P 3 ) such that {M 1, M 2, M 3 } is compatible, which is understandable as SM(P) =. Modular Equivalence The definition of modular equivalence combines features from relativized uniform equivalence (Woltran 2004) and visible equivalence (Janhunen 2003). Definition 12 Logic program modules P = (P, I P, O P ) and Q = (Q, I Q, O Q ) are modularly equivalent, denoted by P m Q, iff 1. I P = I Q = I and O P = O Q = O, and 2. P(A) v Q(A) for all A I. Modular equivalence is very close to visible equivalence defined for modules. As a matter a fact, if Definition 4 is generalized for program modules, the second condition in Definition 12 can be revised to P v Q. However, P v Q is not enough to cover the first condition in Definition 12, as visible equivalence only enforces Hb v (P) = Hb v (Q). If I =, modular equivalence coincides with visible equivalence. If O =, then P m Q means that P and Q have the same number of stable models on each input. Furthermore, if one considers the fully visible case, i.e. Hb h (P) = Hb h (Q) =, modular equivalence can be seen as a special case of A-uniform equivalence for A = I. Recall, however, the restrictions Head(P ) I = Head(Q) I = imposed by module structure. With a further restriction I =, modular equivalence coincides with weak equivalence because Hb(P) = Hb(Q) can always be satisfied by extending Herbrand bases. Basically, setting I = Hb(P) would give us uniform equivalence, but the additional condition Head(P ) I = leaves room for the empty module only. Since v is not a congruence relation for, neither is modular equivalence. The situation changes, however, if one considers the join operation which suitably restricts possible contexts. Consider for instance the programs P and Q given in Example 1. We can define modules based on them: P = (P, {b}, {a}) and Q = (Q, {b}, {a}). Now P m Q and it is not possible to define a module R based on R = {b a.} such that Q R is defined. Theorem 3 Let P, Q and R be logic program modules. If P m Q and both P R and Q R are defined, then P R m Q R. Proof. Let P = (P, I, O) and Q = (Q, I, O) be modules such that P m Q. Let R = (R, I R, O R ) be an arbitrary module such that P R and Q R are defined. Consider an arbitrary M SM(P R). By Theorem 2, M P = M Hb(P) SM(P) and M R = M Hb(R) SM(R). Since P m Q, there is a bijection f : SM(P) SM(Q) such that M P SM(P) f(m P ) SM(Q), and M P (O I) = f(m P ) (O I). (1) Let M Q = f(m P ). Clearly, M P and M R are compatible. Since (1) holds, also M Q and M R are compatible. Applying Theorem 2 we get M Q M R SM(Q R). Define function g : SM(P R) SM(Q R) as g(m) = f(m Hb(P)) (M Hb(R)). Clearly, g restricted to the visible part is an identity function, i.e. M (I I R O O R ) = g(m) (I I R O O R ). Function g is a bijection, since g is an injection: M N implies g(m) g(n) for all M, N SM(P R), since f(m Hb(P)) f(n Hb(P)) or M Hb(R) N Hb(R).

6 g is a surjection: for any M SM(Q R), N = f 1 (M Hb(Q)) (M Hb(R)) SM(P R) and g(n) = M, since f is a surjection. The inverse function g 1 : SM(Q R) SM(P R) can be defined as g 1 (N) = f 1 (N Hb(Q)) (N Hb(R)). Thus P R m Q R. It is instructive to consider a potentially stronger variant of modular equivalence defined in analogy to strong equivalence (Lifschitz et al. 2001): P s m Q iff P R m Q R holds for all R such that P R and Q R are defined. However, Theorem 3 implies that s m adds nothing to m since P s m Q iff P m Q. Complexity Remarks Let us then make some observations about the computational complexity of verifying modular equivalence of normal logic programs. In general, deciding m is conphard, since deciding the weak equivalence P Q reduces to deciding (P,, Hb(P )) m (Q,, Hb(Q)). In the fully visible case Hb h (P ) = Hb h (Q) =, deciding P m Q can be reduced to deciding relativized uniform equivalence P I u Q (Woltran 2004) and thus deciding m is conp-complete in this restricted case. In the other extreme, Hb v (P) = Hb v (Q) = and P m Q iff P and Q have the same number of stable models. This suggests a much higher computational complexity of verifying m in general because classical models can be captured with stable models (Niemelä 1999) and counting stable models cannot be easier than #SAT which is #P-complete (Valiant 1979). A way to govern the computational complexity of verifying m is to limit the use of hidden atoms as done in the case of v by Janhunen and Oikarinen (2005). Therefrom we adopt the property of having enough visible atoms (the EVA property for short) defined as follows. For a normal program P and an interpretation M v Hb v (P ) for the visible part of P, the hidden part P h /M v of P relative M v contains for each rule h B +, B P such that h Hb h (P ) and M v = B v + Bv, the respective hidden part h B + h, B h. The construction of the hidden part P h /M v is closely related to the simplification operation simp(p, T, F ) proposed by Cholewinski and Truszczyński (1999), but restricted in the sense that T and F are subsets of Hb v (P ) rather than Hb(P ). More precisely put, we have P h /M v = simp(p, M v, Hb v (P ) M v ) for any program P. Definition 13 A normal logic program P has enough visible atoms iff P h /M v has a unique stable model for every interpretation M v Hb v (P ). The intuition behind Definition 13 is that the interpretation of Hb h (P ) is uniquely determined for each interpretation of Hb v (P ) if P has the EVA property. Consequently, the stable models of P can be distinguished on the basis of their visible parts. By the EVA assumption (Janhunen & Oikarinen 2005), the verification of v becomes a conpcomplete problem for SMODELS programs 1 involving hidden atoms. This complexity result enables us to generalize the translation-based method from (Janhunen & Oikarinen 1 This class of programs includes normal logic programs. 2002) for deciding v. Although verifying the EVA property can be hard in general, there are syntactic subclasses of normal programs (e.g. those for which P h /M v is always stratified) with the EVA property. It should be stressed that the use of visible atoms remains unlimited and thus the full expressiveness of normal rules remains at our disposal. So far we have discussed the role of the EVA assumption in the verification of v. It is equally important in conjunction with m. This becomes evident once we work out the interconnections of the two relations in the next section. Application Strategies The objective of this section is to describe ways in which modular equivalence can be exploited in the verification of visible/weak equivalence. One concrete step in this respect is to reduce the problem of verifying m to that of v by introducing a special module G I that acts as a context generator. A similar technique is used by Woltran (2004) in the case of relativized uniform equivalence. Theorem 4 Let P and Q be program modules such that Hb v (P) = Hb v (Q) = O I. Then P m Q iff P G I v Q G I where G I = ({a a. a a a I},, I) is a module generating all possible inputs for P and Q. Proof sketch. Note that G I has 2 I stable models of the form A {a a I \ A} for each A I. Thus P v P G I and Q v Q G I follow by Definitions 2 and 4 and Theorem 2. It follows that P m Q iff P(A) v Q(A) for all A I iff P G I v Q G I. As a consequence of Theorem 4, the translation-based technique from (Janhunen & Oikarinen 2005, Theorem 5.4) can be used to verify P m Q given that P and Q have enough visible atoms (G I has the EVA property trivially). More specifically, the task is to show that EQT(P G I, Q G I ) and EQT(Q G I, P G I ) have no stable models. The introduction of modular equivalence was much motivated by the need of modularizing the verification of weak equivalence 2. We believe that such a modularization could be very effective in a setting where Q is an optimized version of P. Typically Q is obtained by making some local modifications to P. In the following, we propose a further strategy to utilize modular equivalence in the task of verifying the visible/weak equivalence of P and Q. An essential prerequisite is to identify a module structure for P and Q. Basically, there are two ways to achieve this: either the programmer specifies modules explicitly or strongly connected components of Dep + (P ) and Dep + (Q) are computed to detect them automatically. Assuming the relationship of P and Q as described above, it is likely that these components are pairwise compatible and we can partition P and Q so that P = P 1 P n and Q = Q 1 Q n where the respective modules P i and Q i have the same input and output. Note that P i and Q i can be the same for a number of i s under the locality assumption. In this setting, the verification of P i m Q i for each pair of modules P i and Q i is not of interest as P i m Q i does 2 Recall that v coincides with for programs P and Q having equal and fully visible Herbrand bases.

7 not necessarily imply P v Q. However, the verification of P v Q can still be organized as a sequence of n tests at the level of modules, i.e. it is sufficient to show Q 1 Q i 1 P i P n m Q 1 Q i P i+1 P n (2) for each 1 i n and the resulting chain of equalities conveys P v Q under the assumption that P and Q have a completely specified input. If not, then m can be addressed using a similar chaining technique based on (2). Example 5 Consider normal logic programs P and Q both consisting of two submodules, i.e. P = P 1 P 2 and Q = Q 1 Q 2 where P 1, P 2, Q 1, and Q 2 are defined by P 1 = ({c a.}, {a, b}, {c}), P 2 = ({a b.},, {a, b}), Q 1 = ({c b.}, {a, b}, {c}), and Q 2 = ({b a.},, {a, b}). Now, P 1 m Q 1, but P 1 and Q 1 are visibly equivalent in all contexts produced by both P 2 and Q 2 (in this case actually P 2 m Q 2 holds, but that is not necessary). Thus P 1 P 2 m Q 1 P 2 m Q 1 Q 2, which verifies P v Q as well as P Q. It should be stressed that the programs involved in each test (2) differ in P i and Q i for which the other modules form a common context, say C i. A way to optimize the verification of P i C i m Q i C i is to view C i as a module generating input for P i and Q i and to adjust the translation-based method from (Janhunen & Oikarinen 2005) for such generators. More specifically, we seek computational advantage from using EQT(P i, Q i ) C i rather than EQT(P i C i, Q i C i ) and especially when the context C i is clearly larger than the modules P i and Q i. By symmetry, the same strategy is applicable to Q i and P i. Related Work The notion of modular equivalence is already contrasted with other equivalence relations in previous sections. Bugliesi, Lamma and Mello (1994) present an extensive survey of modularity in conventional logic programming. Two mainstream programming disciplines can be identified: programming-in-the-large where programs are composed with algebraic operators (O Keefe 1985) and programmingin-the-small with abstraction mechanisms (Miller 1986). Our approach can be classified in the former discipline due to resemblance to that of Gaifman and Shapiro (1989). But stable model semantics and the denial of positive recursion between modules can be pointed out as obvious differences in view of their approach. A variety of conditions on modules have also been introduced. For instance, in contrast to our work, Maher (1993) forbids all recursion between modules and considers Przymusinski s perfect models rather than stable models. Brogi et al. (1994) employ operators for program composition and visibility conditions that correspond to the second item in Definition 8. However, their approach covers only positive programs and the least model semantics. Etalle and Gabbrielli (1996) restrict the composition of constraint logic program (CLP) modules with a condition that is close to ours: Hb(P ) Hb(Q) Hb v (P ) Hb v (Q) but no distinction between input and output is made; e.g. O P O Q is allowed according to their definitions. They also strive for congruence relations but in the case of CLPs. Eiter, Gottlob, and Mannila (1997) consider the class of disjunctive Datalog used as query programs π over relational databases. As regards syntax, such programs are disjunctive programs which cover normal programs (involving variables though) as a special case. The rough idea is that π is instantiated with respect to an input database D for the given input schema R. The resulting models of π[d], which depend on the semantics chosen for π, are projected with respect to an output schema S. To link this approach to ours, it is possible to view π as a program module P with input I and output O based on R and S, respectively. Then π[d] is obtained as P(D). In contrast to our work, their module architecture is based on both positive and negative dependencies and no recursion between modules is tolerated. These constraints enable a straightforward generalization of the splitting set theorem for the architecture. Faber et al. (2005) apply the magic set method in the evaluation of Datalog programs with negation, i.e. effectively normal programs. This involves the concept of an independent set S of a program P which is a specialization of a splitting set (recall Theorem 1). Roughly speaking, the idea is that the semantics of an independent set S is not affected by the rest of P and thus S gives rise to a module T = {h B +, B P h S} of P so that T P and Head(T ) = S. Due to close relationship to splitting sets, independent sets are not that flexible as regards parceling normal programs. For instance, the splittings demonstrated in Examples 2 and 4 are impossible with independent sets. In certain cases, the distinction of dangerous rules in the definition of independent sets pushes negative recursion inside modules which is unnecessary in view of our results. Finally, the module theorem of Faber et al. (2005) is weaker than Theorem 2. Eiter, Gottlob and Veith (1997) address modularity within ASP and view program modules as generalized quantifiers the definitions of which are allowed to nest, i.e. P can refer to another module Q by using it as a generalized quantifier. This is an abstraction mechanism typical to programmingin-the-small approaches. Conclusion In this article, we a propose a module architecture for logic programs in answer set programming. The compatibility of the module system and stable models is achieved by allowing positive recursion to occur inside modules only. The current design gives rise to a number of interesting results. First, the splitting set theorem by Lifschitz and Turner (1994) is generalized to the case where negative recursion is allowed between modules. Second, the resulting notion of modular equivalence is a proper congruence relation for the join operation between modules. Third, the verification

8 of modular equivalence can be accomplished with existing methods so that specialized solvers need not be developed. Last but not least, we have a preliminary understanding how the task of verifying weak equivalence can be modularized using modular equivalence. Yet the potential gain from the modular verification strategy has to be evaluated by conducting experiments. A further theoretical question is how the existing model theory based on SE-models and UE-models (Eiter & Fink 2003) is tailored to the case of modular equivalence. There is also a need to expand the module architecture and module theorem proposed here to cover other classes of logic programs such as e.g. weight constraint programs, disjunctive programs, and nested programs. References Brogi, A.; Mancarella, P.; Pedreschi, D.; and Turini, F Modular logic programming. ACM Transactions on Programming Languages and Systems 16(4): Bugliesi, M.; Lamma, E.; and Mello, P Modularity in logic programming. Journal of Logic Programming 19/20: Cholewinski, P., and Truszczyński, M Extremal problems in logic programming and stable model computation. Journal of Logic Programming 38(2): Clark, K. L Negation as failure. In Gallaire, H., and Minker, J., eds., Logic and Data Bases. New York: Plenum Press Eiter, T., and Fink, M Uniform equivalence of logic programs under the stable model semantics. In Proc. of the 19th International Conference on Logic Programming, volume 2916 of LNCS, Mumbay, India: Springer. Eiter, T.; Fink, M.; Tompits, H.; and Woltran, S Simplifying logic programs under uniform and strong equivalence. In Proc. of the 7th International Conference on Logic Programming and Nonmonotonic Reasoning, volume 2923 of LNAI, Fort Lauderdale, USA: Springer. Eiter, T.; Gottlob, G.; and Mannila, H Disjunctive datalog. ACM Transactions on Database Systems 22(3): Eiter, T.; Gottlob, G.; and Veith, H Modular logic programming and generalized quantifiers. In Proc. of the 4th International Conference on Logic Programming and Nonmonotonic Reasoning, volume 1265 of LNCS, Dagstuhl, Germany: Springer. Eiter, T.; Tompits, H.; and Woltran, S On solution correspondences in answer-set programming. In Proc. of 19th International Joint Conference on Artificial Intelligence, Edinburgh, UK: Professional Book Center. Etalle, S., and Gabbrielli, M Transformations of CLP modules. Theoretical Computer Science 166(1 2): Faber, W.; Greco, G.; and Leone, N Magic sets and their application to data integration. In Proc. of 10th International Conference on Database Theory, ICDT 05, volume 3363 of LNCS, Edinburgh, UK: Springer. Gaifman, H., and Shapiro, E Fully abstract compositional semantics for logic programs. In Proc. of the 16th ACM SIGPLAN-SIGACT symposium on Principles of programming languages, Austin, Texas, USA: ACM Press. Gelfond, M., and Leone, N Logic programming and knowledge representation the A-Prolog perspective. Artificial Intelligence 138:3 38. Gelfond, M., and Lifschitz, V The stable model semantics for logic programming. In Proc. of the 5th International Conference on Logic Programming, Seattle, Washington: MIT Press. Janhunen, T., and Oikarinen, E Testing the equivalence of logic programs under stable model semantics. In Proc. of the 8th European Conference on Logics in Artificial Intelligence, volume 2424 of LNAI, Cosenza, Italy: Springer. Janhunen, T., and Oikarinen, E Automated verification of weak equivalence within the SMODELS system. Submitted to Theory and Practice of Logic Programming. Janhunen, T.; Niemelä, I.; Seipel, D.; Simons, P.; and You, J.-H Unfolding partiality and disjunctions in stable model semantics. ACM Transactions on Computational Logic 7(1):1 37. Janhunen, T Translatability and intranslatability results for certain classes of logic programs. Series A: Research report 82, Helsinki University of Technology, Laboratory for Theoretical Computer Science, Espoo, Finland. Leone, N.; Pfeifer, G.; Faber, W.; Eiter, T.; Gottlob, G.; and Scarcello, F The DLV system for knowledge representation and reasoning. ACM Transactions on Computational Logic. Accepted for publication. Lifschitz, V., and Turner, H Splitting a logic program. In Proc. of the 11th International Conference on Logic Programming, Santa Margherita Ligure, Italy: MIT Press. Lifschitz, V.; Pearce, D.; and Valverde, A Strongly equivalent logic programs. ACM Transactions on Computational Logic 2(4): Maher, M. J A transformation system for deductive database modules with perfect model semantics. Theoretical Computer Science 110(2): Marek, W., and Truszczyński, M Stable models and an alternative logic programming paradigm. In The Logic Programming Paradigm: a 25-Year Perspective. Springer- Verlag Miller, D A theory of modules for logic programming. In Proc. of the 1986 Symposium on Logic Programming, Salt Lake City, USA: IEEE Computer Society Press. Niemelä, I Logic programming with stable model semantics as a constraint programming paradigm. Annals of Math. and Artificial Intelligence 25(3-4): Oikarinen, E., and Janhunen, T Verifying the equivalence of logic programs in the disjunctive case. In Proc. of the 7th International Conference on Logic Programming

9 and Nonmonotonic Reasoning, volume 2923 of LNAI, Fort Lauderdale, USA: Springer. O Keefe, R. A Towards an algebra for constructing logic programs. In Proc. of the 1985 Symposium on Logic Programming, Sagiv, Y Optimizing datalog programs. In Proc. of the 6th ACM SIGACT-SIGMOD-SIGART Symposium on Principles of Database Systems, San Diego, USA: ACM Press. Simons, P.; Niemelä, I.; and Soininen, T Extending and implementing the stable model semantics. Artificial Intelligence 138(1 2): Turner, H Strong equivalence made easy: Nested expressions and weight constraints. Theory and Practice of Logic Programming 3(4-5): Valiant, L. G The complexity of enumeration and reliability problems. SIAM Journal on Computing 8(3): Woltran, S Characterizations for relativized notions of equivalence in answer set programming. In Proc. of the 9th European Conference on Logics in Artificial Intelligence, volume 3229 of LNAI, Lisbon, Portugal: Springer.