Disjunctive Logic Programming as Constrained ... - Semantic Scholar
Disjunctive Logic Programming as Constrained Inferences Jia-Huai You, Xianchang Wang, Li-Yan Yuan
Department of Computing Science University of Alberta Edmonton, Canada T6G 2H1 fyou,xcwang,[email protected]
Abstract
Earlier, we have proposed a logic, called priority logic [16, 18], where a theory consists of a collection of logic programming-like inference rules (without default negation) and a priority constraint among them. We showed that nonmonotonic reasoning in general can be viewed as a reasoning based on selecting monotonic inferences that satisfy the speci ed priority constraints. The goal of this paper is to investigate how semantics of disjunctive programs can be understood as selecting monotonic inferences. We focus on credulous semantics. We show that the stable semantics of a disjunctive program can be represented by priority logic. The highlight of this paper is an interesting new semantics for disjunctive programs discoved during this study which extends the stable semantics for disjunctive programs in the same way as the regular semantics extends stable semantics for normal programs. This shows that the view of nonmonotonic reasoning in terms of constraint inferences leads to interesting new insights into semantics of nonmonotonic reasoning.
1 Introduction In the past, nonmonotonic reasoning has mainly been studied in formalisms where default assumptions constitute a necessary component, e.g. defaults in default logic, negation-as-failure in logic programming, disbeliefs in various nonmonotonic modal logics and assumptions in some abductive and argumentation frameworks. In classic logic, reasoning is based on monotonic inferences. Such a sequence of inferences can be viewed as an argument that supports one's assertion. The notion of constrained monotonic inferences is about selecting some of these monotonic inferences according to a speci ed constraint. As an example, consider the bird- y example: Birds normally y unless it can be shown otherwise. Suppose we know that dead birds don't y, neither do hungry birds. The problem can be represented as a positive program with priority constraint (for simplicity, we remove the condition bird): 1: fly 2: :fly dead bird 3: :fly hungry bird 1
with priority 1 2 and 1 3, meaning when either 2 or 3 is applied, the application of 1 should be blocked. Now, assume we know that the bird is dead: 4: dead bird Consider the two monotonic derivations, I1 = f1g which concludes fly , and I2 = f4; 2g which concludes :fly. The speci ed priority selects I2 , because rule 2 being applicable blocks the application of rule 1. Earlier, we have formulated this idea into a logic, called priority logic, and shown in [18] that Reiter's default logic and Horty's defeasible inheritance networks [9] can be expressed in priority logic. This second result seems particularly interesting since it presents a partial answer to Horty's challenge that it is impossible to relate path-based reasoning to general nonmonotonic formalisms. In addition, we demonstrated that variations of the existing semantics of default logic may be studied through priority logic. Further in [16], we showed that parallel and prioritized circumscription of existential quanti er-free formulas can be represented in priority logic. Priority logic o ers a number of advantages over the conventional formalisms relying on default assumptions. Chief among these is a language construct by which one can express, directly, that some evidence is stronger than others directly. For example, one may express that the evidence that Quakers are paci sts is stronger than the evidence that Republicans are not, and thus to avoid contradiction by speci cation. This feature seems to be particularly important in legal reasoning, since the coordination of con icting pro les of legal relevance is often accomplished by establishing preference relations among assertions and arguments. The goal of this paper is to investigate how some of the logic program semantics can be expressed in priority logic. An important implication of this study is that once negation-as-failure can be represented in priortity logic, we get a formalism that supports both default negation and priority, since the former can be \compiled" into the latter. In other words, in this formalism, default negation comes \free". The central technique used here is based on a translation of a logic program to a priority program. Then the relationship is established between the semantics of a logic program and the semantics of its translated priority program. For normal programs, it is well known that the well-founded model, and stable and regular models are least and maximal xpoints of a monotonic operator [21]. In [17], similar semantics are de ned for priority logic programs, and their relations with the semantics of normal programs eatablished. The main interest of this paper lies in disjunctive programs. We show in Section 3 that the stable semantics can be expressed as selecting monotonic inferences. The main result of this paper is a new, credulous semantics discoved during this study. This semantics extends the stable semantics for disjunctive programs in the same way as the regular semantics [20] extends the stable semantics for normal programs. It also has a natural interpretation 2
of abduction. This result can be seen as an extension of Dung's early work [4] where he shows how restricted classes of disjunctive programs can be understood in terms of abduction in the sense of Eshghi and Kowalski [6]. However he left the question open as what exactly is an abductive semantics for the class of all disjunctive programs. The details are given in Section 4. For the paper to be self-contained, we introduce priority logic in the next section. Detailed development of the results sketched above will be given in the two sections that follow it. Related work and nal remarks are given in Section 5.
2 Priority Logic 2.1 Language
Suppose L is a rst order language connectives :; _; ^; ; ; 9; 8. The formulas of L are de ned as usual. They are denoted by ; ; , possibly with a subscript. We consider a xed domain, such as the Herbrand domain of L, denoted by HL , or simply H. An inference scheme is of the form 1 ; :::; m where m 0, i 's and are formulas of L. When m = 0, we may simply write . Each inference scheme represents a set of inference rules, where the free variables in the scheme have been instantiated by terms from the underlying domain, in this case, H. Generally we use a label with variables to name a rule scheme. The variables in a label are the free variables appearing in the scheme. For example, we use l(x; y ) to label the rule scheme q (x) p(x; y ). Like a scheme, a label with variables represents all the instantiated labels. A priority theory (or, called a priority logic program) is a couple hR; i where R is a set of inference schemes and is a relation on R. In the sequel, we often only mention inference rules and ground priorities. In such cases, it is assumed that rule schemes and priorities are already instantiated. For an inference rule r = 1 ; :::; m, Pre(r) refers to f 1 ; :::; mg and Cons(r) to . Intuitively, a priority constrains whether a rule can be applied or not: if l l0 and l0 is applied, then the inference rule l should be suspended. In priority logic, we place no restriction on a priority constraint. Properties like transitivity may be speci ed by the user, depending on the intended applications. Let ` be an inference relation, P be a set of inference rules, and S a set of formulas. The familiar consequence operator TP is de ned as: TP (S ) = fCons(r) : r 2 P; S ` Pre(r)g If ` is monotonic, then TP is also monotonic. In this case, it has a unique least xpoint, which is denoted here by TP"! . The applicable rules in a rule set P , denoted App(P ), is de ned as: App(P ) = fr 2 P : TP"! ` Pre(r)g. In the sequel, if not said otherwise, ` is taken as the standard rst order derivation relation. 3
2.2 Arguments as semantics
A primary interest in a priority logic program lies in what can be derived by using which inference rules. A derivation is just a chain of reasoning using inference rules. At a level of conceptualization, this can be understood as a notion of argument which serve as an important building block in reasoning with priority.
De nition 2.1 (Argument on hP; i) Let hP; i be a priority logic program. An argument is a ( nite or in nite) set of inference rules in P such that I 's rules can be arranged into a sequence, say I = fw1; :::; wn; :::g, such that for every wi 2 I , where i 0, we have Tf"w!1 ;:::;w ?1 g ` Pre(wi). i
That is, an argument is just a sequence of rules, each of which is applicable by the rules prior to it. The set notation used in the de nition is for convenience. Given a priority logic program hR; i, we are interested in those arguments that agree with the speci ed constraint . The construction of such an argument involves how to extend an argument I by possibly admitting mroe rules into it. Since when we specify r r0 , we mean the applicability of r0 blocks that of r, a natural notion of extending an argument I is: I admits a rule r (i.e. r extends I ) if there is no other rule r0 in I that blocks r. For example, consider the example bird fly ostrich don0t: 1 : fly bird 2 : :fly ostrich 3 : bird ^ ostrich where 1 2. Let I = f3; 2g. Thus, 1 cannot extend I . Since the notion of priority may have di erent interpretations, in general one can take the approach that the semantics of a priority logic program depends on a parameter R, which is a mapping over arguments. We call such a mapping an extensibility function. We now de ne the most intuitive extensibility function discussed above.
De nition 2.2 Let hR; i be a priority logic program, I be an argument, r be a rule in R. We de ne an extensibility function R1 as follows: R1(I ) = App(fr : 8r0 2 I; r 6 r0g): Note that, since each rule in an argument must be applicable in the argument itself, the employment of App is technical and ensures that the resulting set of rules is an argument.
De nition 2.3 Given an extensibility function R, an argument I is said to be self-extensible under R if I R(I ). 4
Not all arguments are self-extensible. E.g. with P = hf1 : a g; f1 1gi under R1, clearly f1g is not self-extensible, since R1(f1g) = ;. The approach based on extensibility function is suciently exible to allow various application-dependent extensions and modi cations. For example, one can strengthen the notion of extensibility by insisting on consistent extension: given an argument I and rule r, r extends I if there is no r0 2 I such that r r0 and if I implies the precondition of r then r's conclusion must not contradict I . This extensibility function can be used to express Horty's defeasible inheritance networks [9]. The details can be found in [18]. >From now on, we will say \a priority logic program hP; i with R (or under R)", to re ect the fact that the rst step in choosing a semantics is to specify how to extend an argument. However, since the technical results of this paper only depend on R1 given above, the reader can always safely assume R1 in place of a general extensibility function R.
De nition 2.4 (Stable argument) Let hP; i be a priority logic program with extensibility function R. An argument I is said to be a stable argument if R(I ) = I . A stable argument I is just a xpoint of extending I . That is, the rules in I are precisely those applicable rules that are not blocked by rules in it, no more, no less.
Example 2.1 (Closed world assumption)
Suppose there are n cities. Consider a database of ight connections between pairs of these cities. This can be represented by a priority logic program, under R1, as follows: 1 : fflight(A; B ) : if A; B are directly connectedg 2(x; y ) : :flight(x; y ) 3(x; y ) : flight(x; y ) flight(x; y ) 2(x; y ) 3(x; y ) This priority logic program has one and only one consistent stable argument I such that any two cities A and B are connected if and only if it is known they are connected. Obviously, this is a simple application of the closed world assumption of Reiter [12]. A stable argument is a total argument. E.g. suppose I is a stable argument under R1. Then, by de nition any rule r in I extends I (selfextensible) and for any rule r 62 I , if r's precondition can be concluded from I , then there is some rule r in I such that r0 r. Because of this totality, a priority logic program may not have a stable argument. For example, P = hf1 : a ; 2 : b g; f1 1gi has no stable argument under R1. To resolve this problem, we propose partial semantics, i.e., the kind of semantics that are de ned for all programs and give information on the portion of the program that \make sense", For example, for the program P above, since 2 is irrelevant to the con icting information, the argument 5
f2g should be accepted. Such a semantics depends on the properties of extensibility functions R. De nition 2.5 Let hP; i be a priority logic program with extensibility function R. R is monotonic i for any arguments I1 and I2 , I1 I2 implies R(I1) R(I2). R is anti-monotonic i for any arguments I1 and I2, I1 I2 implies R(I2) R(I1). If R is not monotonic, then there is no guarantee that a stable argument exists. However, if R is anti-monotonic then R2, the operator that applies R twice, is monotonic. It thus has a least xpoint and possibly other xpoints. It can be checked easily that R1 de ned earlier is anti-monotonic.
De nition 2.6 Let P = hR; i with a monotonic or anti-monotonic extensibility function R. A xpoint I of R2 is called an alternating argument of P if it is a xpoint of R2. It is said to be normal under R if I R(I ).1 By de nition, any normal alternating argument must be self-extensible, and a stable argument must be also a normal alternating argument. Hence the least normal alternating argument is exactly the intersection of all the normal alternating arguments, and thus serves as a kind of skeptical semantics. On the other hand, the maximal normal alternating arguments serve as a kind of credulous semantics. We call the least normal alternating argument the well-founded argument, and maximal normal alternating arguments regular arguments.
Example 2.2 Consider P = hf1 : a ; 2 : b ; 3 : c g; f1 2; 2 1gi under R1. P has a well-founded argument f3g and two regular arguments f1; 3g and f2; 3g, both of which are also stable. The importance of the the well-founded semantics of a priority logic program lies in its tractability. Since it is the least xpoint of a monotonic operator which can be computed iteratively from the empty argument, the semantics is tractable as far as the underlying monotonic function can be tractably computed. The relationship between semantics of priority logic programming and normal logic programming is given earlier in [17].
Theorem 2.1 Let P a normal program. There exists a polynomial time
transformation from P to a priority program P such that the well-founded model of P corresponds to the well-founded argument of P and regular models2 of P correspond to regular arguments of P . 1 The notion of alternating xpoint was introduced by Van Gelder [7] and later studied by a number of authors. 2 hence preferential extensions of Dung [5] and partial stable models of Sacca and Zaniolo [13], which are all equivalent to regular models [21].
6
3 Representing Stable Semantics of Disjunctive Programs A disjunctive program is a set of program clauses of the form:
1 j ::: j k 1 ; :::; m; not 1; :::; not n where i 's, i 's, and i 's are (ground) atoms. not is called an assumption. We denote by ASL the set of all assumptions in the underlying language L. We may use A B; not C to denote a clause where A is the set of atoms in the head, B the set of atoms in the body, and not C the set of the assumptions in the body. Conveniently, if C is a set of atoms, not C also denotes the set of assumptions not for each 2 C , and conversely, if not C is a set of assumptions C denotes the set of atoms appearing in these assumptions. A stable model M of a disjunctive program P is a set of atoms, which is a minimal model of the following transformed program:
B; not C 2 P; and 8(not ) 2 not C; 62 M g To express the stable semantics of a disjunctive program P in priority logic, we translate P into a priority logic program. First, we need some notations. Let Q be a set of atoms. We will denote by :Q the set of negative literals : , for each 2 Q. When we want to denote a disjunction with the classic connective of disjunction _ by a set of literals W , we use W_ . For example, if W = fa; b; :cg then W_ means a _ b _ :c. PM = fA
B :A
De nition 3.1 (Transformation stable (P )) The (stable) transformation of a disjunctive program P , denoted stable (P ), is a priority program hR; i, where R = fH_ :C j A B; not C 2 P; H_ = A [ :Bg [ fl: : : j not 2 ASLg [ fl : j not 2 ASLg = fl: l j not 2 ASLg Example 3.1 Let P = fd c; not e; c a; c b; a j b g. Its translation is stable (P ) = hR; i where R contains 1 : d _ :c :e 2 : c _ :a 3 : c _ :b 4 : a_b and for 2 fa; b; c; eg l : l: : : 7
and
= fl: l g
There are exactly two stable arguments:
I1 = fl:a; lb; lc ; l:e; ld; 1; 2; 3; 4g I2 = fl:b; la; lc ; l:e; ld; 1; 2; 3; 4g
They correspond, respectively, to the two stable models: M1 = fa; c; dg and M2 = fb; c; dg. Let us verify that I1 is a stable argument: fl:a; 4g ` b, and thus rule lb is applicable which blocks rule l:b; similarly, fl:a; 4; 3g ` c, and thus lc is applicable which blocks l:c ; nally, fl:a; l:e; 4; 3; 1g ` d, and thus ld is applicable. That is, any rule that is not in I1 is either not applicable (e.g. a a), or blocked by the priority speci ed in . Further, extending I1 yields precisely the same set of rules, i.e., R1(I1 ) = (I1 ). Therefore, it is a stable argument. Intuitively, stable transformation identi es an assumption not with : , and then applies CWA. The rst major result of this paper is that this
interpretation of the semantics of a disjunctive program coincides with that of stable models.
Theorem 3.1 Let P be a disjunctive program. For any stable model M of P , its translation stable (P ) has a stable argument I such that 62 M i l: 2 I , and 2 M i I ` . Conversely, for each stable argument I of stable (P ), there is a stable model M such that l: 2 I i 62 M , and I ` i 2 M . PROOF: We show the rst claim (from stable model to stable argument). The converse is similar. Suppose M is a stable mode of P . Then M is a minimal model of the positive disjunctive program PM . It is easy to check that M is a minimal model of PM i
f: : 62 M g [ fA [ :B : A
B 2 PM g j= f 2 M g
The righthand side of this equivalence leads to a construction of an argument of stable (P ) as follows:
I = fl: 62 M g[fH_
:C 2 stable(P ) : 8 2 C; 62 M g[fl : 2 M g Assume that the rule application sequence of I is as given in the same order above. Then obviously, I satis es the conditions: 62 M i l: 2 I and 2 M i I ` . 8
We now show that I is stable, i.e. R1(I ) = I . There are three kinds of rules in I , l: rules, l rules, and the remaining rules from stable (P ). Only the rst two kinds are related by . It is not dicult to see for any l: rule or l rule, it is in I i it is in R1(I ). For example, if l 2 I then is derivable. Since l: l , l: is blocked, i.e., l: 62 I . It follows that l 2 R1(I ). Other cases are similar. Since R1(I ) contains the same set of l: and l rules as that of I , the applicability of any of the remaining rules in stable (P ) does not change. We thus conclude R1(I ) = I . That is, I is a stable argument of stable (P ). 2 Since minimal models of a positive disjunctive program are just stable models, the above correspondence applies to positive disjunctive programs.
Corollary 3.1 Let P be a positive disjunctive program. There is one-one correspondence between minimal models M of P and stable arguments I of stable (P ): 62 M i l: 2 I and 2 M i I ` . There is an interesting implication of representing a semantics in priority logic; namely, priority logic can be seen as a formal system that supports both default assumptions and priorities over positive rules, since the former can be \compiled" into the latter. For example, suppose during the construction of a knowledge base, one has already written the following disjunctive program 1: drive j take bus 2: drive not car broken 3: take bus not good weather where j is the connective of epistemic disjunction. This is an incomplete speci cation as both drive and take bus are in the same answer set. To say that driving takes higher priority, one can specify that the second rule blocks the third by a priority constraint 3 2.3
4 Partial Stable Semantics for Disjunctive Programs 4.1 Why another semantics?
There are several reasons why the semantics to be proposed is interesting and important. First, it is well-known that a drawback of the stable semantics is that a disjunctive program may not have a stable model. Dung [5] uses the barber's paradox to illustrate this drawback for the case of normal program. Here we extend it to a disjunctive program. 3 Of course, the same e ect can be achieved by good weather not broken, which seems unintuitive and unnatural: how come car being broken or not has something to do with weather?
9
Example 4.1 Consider the disjunctive program: shave(bob; x) not shave(x; x) pay cash(y; x) j pay by credit(y; x) shave(x; y)
pay cash(x; y) pay by credit(x; y) This program intuitively says that bob shaves those who do not shave themselves; If x shaves y then y pays x by cash or credit, either way is accepted. Assume there is at least one another person, called greg . Then clearly, we should conclude bob shaves greg , and greg pays bob by cash or by credit, accepted(x; y) accepted(x; y)
either way is accepted. This program however has no stable model.
For this program, the static semantics [11] gives the correct solution. However, one should realize that static semantics is not designed to be capable of abductive reasoning. For example, if we observe that greg pays cash, abductive reasoning would yield abducibles that greg does not pay by credit and greg does not shave himself. There are other application domains in which the static semantics is not applicable. For example, in planning and scheduling, in general we are interested in any plan that achieves the goal, and any schedule that satis es the speci ed constraints. This is a form of credulous reasoning. In the case of normal programs, the drawback of the stable semantics mentioned above can be resolved by a weaker notion of a stable model, called regular model in [20], partial stable model in [13], and preferred extension in [5], which are all equivalent [21]. However, for disjunctive programs, a satisfactory weaker notion of stable model has not been presented in the literature. In [20], regular semantics is de ned for disjunctive programs. However, both Przymusinsk and Eiter have independently observed a drawback of the regular semantics for disjunctive programs; namely, it does not always obey the CWA principle. This can be illustrated by the following example.
Example 4.2 Consider the following disjunctive program: ajbjc a not b b not c c not a There are three regular models, each of which has exactly one true atom and two unde ned. One wonders how the true atom in such a model is obtained. Dung in [4] showed how some restricted classes of disjunctive programs can be understood as abduction in the sense of Eshghi and Kowalski [6]. But he left the question open as what is an abductive semantics for the class of all 10
disjunctive programs. The question becomes more interesting in light of the fact that Eshghi and Kowalski's procedure bears an e ective implementation: all it needs, on top of a traditional negation-as-failure proof procedure, is a mechanism to handle two kinds of loops, odd and even negative dependency loops,4 and the procedure is sound, and complete as well with positive loop checking, for the regular semantics of normal programs (cf. [8, 5]).
4.2 Partial stable semantics by constrained inferences
First, we strengthen the notion of derivation by a new inference rule whose aim is tentatively commit an assumption in order to derive additional information. For this purpose, we assume, for each assumption not in ASL , there is an atom not .
Rule of Tentative Assumption Commitment (RTAC): not i 1 _ ::: _ n ????????????? 1 _ ::: _ i?1 _ i+1 _ ::: _ n where i is an atom, any j , where i = 6 i, is a literal, and n > 1.
This inference rule is similar to resolution. Intuitively, it says that if we assume not we can make it stronger in an attempt to derive additional, tentative information. Since not is weaker than : , we do not want to treat not and as logical contradiction. This is prevented by the requirement n > 1. In the rest of this section, by a derivation, we mean the standard rst order derivation relation augmented by the above rule of inference. We will denote this derivation relation by `d . Note that this relation will be used, implicitly, in the construction of an argument. Now program transformation should be modi ed accordingly to t this rule of inference. Let us denote by not Q the set of atoms not for each not 2 not Q.
De nition 4.1 (Transformation p partial(P )) The (partial stable) transformation of a disjunctive program P is a priority program p stable (P ) = hR; i, where R = fH_ not C j A B; not C 2 P; H_ = A [ :Bg [ flnot : not j not 2 ASLg [ fl : j not 2 ASLg
= flnot l j not 2 ASLg In general, this procedure can be as ecient as any backward chaining proof procedure for the well-founded semantics. This claim is based on the following fact: Odd loops are treated exactly the same in both semantics, and for even loops, a procedure for the wellfounded semantics assigns the value undefined, and Eshghi and Kowalski's procedure simply indicates \in a model". 4
11
We are now ready to de ne the partial stable semantics based on the notion of partial stable assumption set.
De nition 4.2 Let P be a disjunctive program. Let p stable (P ) be its (partial stable) transformation and I a regular argument of p stable (P ). Then, S is a partial stable assumption set i the following holds: not 2 S i lnot 2 I . Since a stable argument is also a regular argument, and thus a stable model corresponds to a partial stable assumption set, the partial stable semantics extends stable semantics in the same way as the regular semantics extends stable semantics for normal programs.
Example 4.3 Consider disjunctive program P = fa j b
Its transformation yields
not a; not bg.
1 : a _ b not a; not b lnot a : not a lnot b : not b la : a a lb : b b and = flnot a la; lnot b lb g. The ony regular argument is the empty set. Thus, the partial stable semantics of P is described by the empty partial stable assumption set. The program however has no stable model. Suppose there is an additional clause in P , say, c j; d , then there will be two regular arguments for the transformed priority program, which correspond to the two partial stable assumptions sets: fnot cg and fnot dg. This shows that the semantics based on partial stable assumption sets does not collapse in case of non-existence of a stable model.
Example 4.4 The program in Example 4.2 also has one partial stable assumption set, the empty set.
Example 4.5 For the program in Example 4.1, its (partial stable) transformation yields a priority program hR; i where R contains (with obvious abbreviation and omission of
if the body is empty)
1: shave(bob; x) not shave(x; x) 2: cash(y; x) _ credit(y; x) _ :shave(x; y ) 3: accepted(x; y ) _ :cash(x; y ) 4: accepted(x; y ) _ :credit(x; y ) Assuming there are only three kinds of assumptions
fnot shave(x; x); not cash(x; y); not credit(x; y)g; 12
R contains additional rules: lnot shave (x) : not shave(x; x) lnot cash (x; y) : not cash(x; y) lnot credit (x; y) : not credit(x; y)
and consists of
lshave (x) : shave(x; x) shave(x; x) lcash (x; y) : cash(x; y) cash(x; y) lcredit (x; y) : credit(x; y) credit(x; y)
lnot shave (x) lshave (x) lnot cash (x; y) lcash (x; y) lnot credit (x; y) lcredit (x; y) Assume there are two people, bob and greg . Then the disjunctive program
has two partial stable assumption sets, one of which contains (among others) not shave(greg; greg ) and not cash(greg; bob), and the other contains not shave(greg; greg) and not credit(greg; bob).
Since a regular argument is a (maximal) xpoint of a monotonic operator, there is at least one partial stable assumption set for any disjunctive program.
Proposition 4.1 Every disjunctive program has at least one partial stable assumption set.
Apparently by de nition, the partial stable semantics for disjunctive programs reduces to the regular semantics for normal programs. The following result shows that this semantics satis es a desirable property; namely, each true atom derived by a program along with any of its partial stable assumption set is \founded". The proof is straightforward.
Theorem 4.1 Suppose P is a disjunctive program. Let be an atom, S a partial stable assumption set, and P [ S `d . Then there exists a clause A B; not C in P such that 2 A, not C S , P [ S `d B, and for each in, either not 2 S or P [ S `d .
4.3 Abductive reasoning with partial stable semantics
There is a natural notion of abduction associated with the proposed semantics. The key lies again in the use of the derivation relation augmented by RTAC. In general, an abductive framework be a triple h; Ab; IC i where P is a rst order theory, Ab is the set of abducibles, and IC is set of rst order formulas serving as integrety constraints. We restrict to a special class of abductive frameworks that correspond to disjunctive logic programming. Namely, we let be a disjunctive program, Ab be the set of assumptions, and IC = f? ( 1 _ ::: _ n ); not 1; :::; not n j n 1g 13
Let be an atom. We say that a set E of abducibles is an explanation of if P [ E `d and P [ E [ IC 6 `d ?
Example 4.6 Continuing with the Barber's example (Example 4.5), suppose we observe that greg pays cash to bob, cash(greg; bob). Then there is a partial stable assumption set S such that
P [ S `d cash(greg; bob) and P [ S [ IC 6 `d ? Thus, S is an explanation of cash(greg; bob).
Theorem 4.2 Let P be any disjunctive program and S be any partial stable assumption set of P . Then P [ S [ IC 6 `d ?. PROOF: Assume P [ S [ IC `d ?. Then P [ S `d f( 1 _ ::: _ n); not 1 ; :::; not n g where n 1. Using RTAC, we have P [ S `d i for each 1 i n. Let IS be the regular argument of p stable (P ) that corresponds to S . Note that lnot 2 IS , since not 2 S . But clearly lnot 62 R1(IS ). This implies IS 6 R1(IS ). Thus, IS cannot be a regular argument because it is not i
i
normal, and hence S is not a partial stable assumption set. Contradiction.
2
There is a technical implication of the use of ? to denote a constraint. It separates the case of deriving ? from deriving logical contradiction. For example, one can incorporate explicit negation by adding to IC constraints
f? ; : ; 2 Lg where denotes explicitly negated atom . That is, is viewed as an
atom to start with, and its intended meaning is de ned by integrey constraints. Then, an abductive semantics for extended disjunctive programs can be de ned as by those partial stable assumption sets S , for which we have P [ S [ IC 6 `d ?.
5 Related Work and Final Remark The concept of logic programming without default negation was rst suggested in [10] and further developed in [3]. The authors argue that a knowledge representation language without using default negation can avoid the possible confusions arising from the use of default and explicit negation. Priority in this framework however relies on the existence of contradiction. The e ect of its interaction with contradiction is usually hard to predicate. As a result, the semantics of a program under this notion of priority may not 14
be intuitive to what is intended. This treatment of priority also complicates the relation between programs with default negation (normal programs) and those without. This is because the transformation from the former to the latter has to resort to contradiction in order to have a one-one correspondence (cf. [19] for more details). Recently, Sakama and Inoue proposed prioritized logic programming, where priority is among literals and assumptions, not among rules [14]. Priority here is used to reduce the number of answer sets in disjunctive logic programming, while our notion of priority can remove answers from an answer set. Brewka recently proposes dynamic priority where a priority predicate is used in program rules just like any other predicate, and preferences are determined dynamically [2]. Extension of priority logic with dynamic priority constraint presents an interesting but challenging future research topic. Work is also under way to show that Eshghi-Kowalski's abductive procedure, augmented by standard resolution procedure, can be used to answer queries for disjunctive programs under the partial stable semantics. One notes that partial deduction as given in [15] is in fact a form of resolution. Thus, a disjunctive program can be rst partially evaluated so that clauses with head-cycles are no longer needed. Then, for head-cyclic free programs, the program obatined by an operation called shifting [4] can be used by Eshghi-Kowalski's procedure to show that an atom is true w.r.t. one partial stable assumption set. Or alternatively, Eshghi-Kowalski's procedure can be augmented by resolution dynamically. Aravindan proposed [1] a simpli ed abductive framework for disjunctive logic programming that provides a new inference rule for negation based on failure to explain where the disjunctive program clauses are simply of the form A1 _ ::: _ An B1 ; :::; Bm such that Ai and Bi are atoms with n 1 and m 0. Although the semantic is exactly the same that of (E)GCWA and its procedural interpretation based on the notion of support-for-negation, this study present a close relationship between abduction and negation. As we can see, the idea behind this framework is not new but still minimal model reasoning and hence can be expressed by our regular augment as follows: Let D be a disjunctive logic program of [1] and a sentence. Then there exists no adductive explanation for wrt D i D `d min : i p stable (D) has no regular argument such that is true in that argument. Also, empty set fg is an abductive explanation for wrt D i D `d min i p stable (D)'s every argument can conclude . Further questions have not been discussed in this work [1]: When default negation has been introduced into disjunctive logic programs, how the minimal mode be extended such that it can deal with default negation? Our framework give an elegant and simple resolution for this problem: For example, suppose we have a program: D = fp _ q not pg, Under our framework, the priority logic program p stable (D) is as follows: f1 : p _ q not p; lnot p : not p ; lnot q : not q ; lp : p ; lq : q qg 15
with priority relation:
set.
flnot p preclp; lnot q lq g. has only one regular argument: flnot p; 1; lqg which can conclude q; not p. So we not p is a partial stable assumption
References [1] Chandrabose Aravindan. An abductive framework for negation in disjunctive logic programming. Technical report, University of KoblenzLandau, 1996. [2] G. Brewka. Well-founded semantics for extended logic programming with dynamic preference. Journal of Arti cial Intelligence Research, 4:19{36, 1996. [3] Y. Dimopoulos and A. Kakas. Logic programming without negation as failure. In Proc. International Logic Programming Symposium. MIT Press, 1995. [4] P. Dung. Acyclic disjunctive logic programs with abductive procedures as proof procedure. In Proc. 1992 Fifth Generation Computer Systems, pages 555{561, 1992. [5] P. Dung. An argumentation theoretic foundation for logic programming. J. Logic Programming, 22:151{177, 1995. [6] K. Eshghi and R.A. Kowalski. Abduction compared with negation by failure. In Proc. 6th ICLP, pages 234{254. MIT Press, 1989. [7] A. Van Gelder. The alternating xpoint of logic programs with negation. J. Computer and System Sciences, pages 185{221, 1993. The preliminary version appeared in PODS '89. [8] L. Giordano, A. Marteli, and M. Sapino. A semantics for eshghi and kowalski's abductive procedure. In Proc. 10th ICLP. MIT Press, 1993. [9] J.F. Horty. Some direct theories of non-monotonic inheritance. In D. Gabbay and C. Hogger, editors, Handbook of logic and arti cial intelligence and logic programming, pages 111{187. Oxford University, 1991. [10] A. Kakas, P. Mancarella, and P. Dung. The acceptability semantics for logic programs. In Proc. ICLP, pages 504{519, 1994. [11] T. C. Przymusinski. Static semantics for normal and disjunctive logic programs. Annals of Mathematics and Arti cial Intelligence, 1995. 16
[12] R. Reiter. On closed world data bases. In H. Gallaire and J. Minker, editors, Logic and Data Bases, pages 55{76. Plenum Press, 1978. [13] D. Sacca and C. Zaniolo. Stable models and non-determinism in logic programs with negation. In Proc. the 9th ACM PODS, pages 205{217, 1990. [14] C. Sakama and K. Inous. Representing priorities in logic programs. In Proc. Int'l Conference and Symposium on Logic Programming. MIT Press, 1996. [15] Jurgen Dix Stefan Brass. Disjunctive semantics based upon partinal and botton-up evaluation. In Proc. Non-monotoic Reasoning and Logic Programming, 1995. [16] X. Wang, J. You, and L. Yuan. Circumscription by inference rules with priority. In Proc. 12th European Conf. on Arti cial Intelligence, pages 110{115, 1996. [17] X. Wang, J. You, and L. Yuan. Logic programming without default negation revisited. Tr96-25, Dept. Computing Science, University of Alberta, 1996. [18] X. Wang, J. You, and L. Yuan. Nonmonotonic reasoning = monotonic inferences + priority. In Proc. JICSLP Post-Conference Workshop on Nonmonotonic Extensions of Logic Programming, 1996. To appear in LNAI J. Dix, P. Pereira, and T. Przymusinski (eds). [19] Xianchang Wang, Jia-Huai You, and Li Yan Yuan. Priority logic program, argument and normal logic programming. Technical report, Department of Computing Science, University of Alberta, 1995. [20] J. You and L. Yuan. A three-valued semantics for deductive databases and logic programs. Journal of Computer And system Sciences, 49:334{ 361, 1994. A short version appears in Prec. PODS '90. [21] J. You and L. Yuan. On the equivalence of semantics for normal logic programs. J. Logic Programming, 22(3):211{222, 1995.
17
Department of Computing Science University of Alberta Edmonton, Canada T6G 2H1 fyou,xcwang,[email protected]
Abstract
Earlier, we have proposed a logic, called priority logic [16, 18], where a theory consists of a collection of logic programming-like inference rules (without default negation) and a priority constraint among them. We showed that nonmonotonic reasoning in general can be viewed as a reasoning based on selecting monotonic inferences that satisfy the speci ed priority constraints. The goal of this paper is to investigate how semantics of disjunctive programs can be understood as selecting monotonic inferences. We focus on credulous semantics. We show that the stable semantics of a disjunctive program can be represented by priority logic. The highlight of this paper is an interesting new semantics for disjunctive programs discoved during this study which extends the stable semantics for disjunctive programs in the same way as the regular semantics extends stable semantics for normal programs. This shows that the view of nonmonotonic reasoning in terms of constraint inferences leads to interesting new insights into semantics of nonmonotonic reasoning.
1 Introduction In the past, nonmonotonic reasoning has mainly been studied in formalisms where default assumptions constitute a necessary component, e.g. defaults in default logic, negation-as-failure in logic programming, disbeliefs in various nonmonotonic modal logics and assumptions in some abductive and argumentation frameworks. In classic logic, reasoning is based on monotonic inferences. Such a sequence of inferences can be viewed as an argument that supports one's assertion. The notion of constrained monotonic inferences is about selecting some of these monotonic inferences according to a speci ed constraint. As an example, consider the bird- y example: Birds normally y unless it can be shown otherwise. Suppose we know that dead birds don't y, neither do hungry birds. The problem can be represented as a positive program with priority constraint (for simplicity, we remove the condition bird): 1: fly 2: :fly dead bird 3: :fly hungry bird 1
with priority 1 2 and 1 3, meaning when either 2 or 3 is applied, the application of 1 should be blocked. Now, assume we know that the bird is dead: 4: dead bird Consider the two monotonic derivations, I1 = f1g which concludes fly , and I2 = f4; 2g which concludes :fly. The speci ed priority selects I2 , because rule 2 being applicable blocks the application of rule 1. Earlier, we have formulated this idea into a logic, called priority logic, and shown in [18] that Reiter's default logic and Horty's defeasible inheritance networks [9] can be expressed in priority logic. This second result seems particularly interesting since it presents a partial answer to Horty's challenge that it is impossible to relate path-based reasoning to general nonmonotonic formalisms. In addition, we demonstrated that variations of the existing semantics of default logic may be studied through priority logic. Further in [16], we showed that parallel and prioritized circumscription of existential quanti er-free formulas can be represented in priority logic. Priority logic o ers a number of advantages over the conventional formalisms relying on default assumptions. Chief among these is a language construct by which one can express, directly, that some evidence is stronger than others directly. For example, one may express that the evidence that Quakers are paci sts is stronger than the evidence that Republicans are not, and thus to avoid contradiction by speci cation. This feature seems to be particularly important in legal reasoning, since the coordination of con icting pro les of legal relevance is often accomplished by establishing preference relations among assertions and arguments. The goal of this paper is to investigate how some of the logic program semantics can be expressed in priority logic. An important implication of this study is that once negation-as-failure can be represented in priortity logic, we get a formalism that supports both default negation and priority, since the former can be \compiled" into the latter. In other words, in this formalism, default negation comes \free". The central technique used here is based on a translation of a logic program to a priority program. Then the relationship is established between the semantics of a logic program and the semantics of its translated priority program. For normal programs, it is well known that the well-founded model, and stable and regular models are least and maximal xpoints of a monotonic operator [21]. In [17], similar semantics are de ned for priority logic programs, and their relations with the semantics of normal programs eatablished. The main interest of this paper lies in disjunctive programs. We show in Section 3 that the stable semantics can be expressed as selecting monotonic inferences. The main result of this paper is a new, credulous semantics discoved during this study. This semantics extends the stable semantics for disjunctive programs in the same way as the regular semantics [20] extends the stable semantics for normal programs. It also has a natural interpretation 2
of abduction. This result can be seen as an extension of Dung's early work [4] where he shows how restricted classes of disjunctive programs can be understood in terms of abduction in the sense of Eshghi and Kowalski [6]. However he left the question open as what exactly is an abductive semantics for the class of all disjunctive programs. The details are given in Section 4. For the paper to be self-contained, we introduce priority logic in the next section. Detailed development of the results sketched above will be given in the two sections that follow it. Related work and nal remarks are given in Section 5.
2 Priority Logic 2.1 Language
Suppose L is a rst order language connectives :; _; ^; ; ; 9; 8. The formulas of L are de ned as usual. They are denoted by ; ; , possibly with a subscript. We consider a xed domain, such as the Herbrand domain of L, denoted by HL , or simply H. An inference scheme is of the form 1 ; :::; m where m 0, i 's and are formulas of L. When m = 0, we may simply write . Each inference scheme represents a set of inference rules, where the free variables in the scheme have been instantiated by terms from the underlying domain, in this case, H. Generally we use a label with variables to name a rule scheme. The variables in a label are the free variables appearing in the scheme. For example, we use l(x; y ) to label the rule scheme q (x) p(x; y ). Like a scheme, a label with variables represents all the instantiated labels. A priority theory (or, called a priority logic program) is a couple hR; i where R is a set of inference schemes and is a relation on R. In the sequel, we often only mention inference rules and ground priorities. In such cases, it is assumed that rule schemes and priorities are already instantiated. For an inference rule r = 1 ; :::; m, Pre(r) refers to f 1 ; :::; mg and Cons(r) to . Intuitively, a priority constrains whether a rule can be applied or not: if l l0 and l0 is applied, then the inference rule l should be suspended. In priority logic, we place no restriction on a priority constraint. Properties like transitivity may be speci ed by the user, depending on the intended applications. Let ` be an inference relation, P be a set of inference rules, and S a set of formulas. The familiar consequence operator TP is de ned as: TP (S ) = fCons(r) : r 2 P; S ` Pre(r)g If ` is monotonic, then TP is also monotonic. In this case, it has a unique least xpoint, which is denoted here by TP"! . The applicable rules in a rule set P , denoted App(P ), is de ned as: App(P ) = fr 2 P : TP"! ` Pre(r)g. In the sequel, if not said otherwise, ` is taken as the standard rst order derivation relation. 3
2.2 Arguments as semantics
A primary interest in a priority logic program lies in what can be derived by using which inference rules. A derivation is just a chain of reasoning using inference rules. At a level of conceptualization, this can be understood as a notion of argument which serve as an important building block in reasoning with priority.
De nition 2.1 (Argument on hP; i) Let hP; i be a priority logic program. An argument is a ( nite or in nite) set of inference rules in P such that I 's rules can be arranged into a sequence, say I = fw1; :::; wn; :::g, such that for every wi 2 I , where i 0, we have Tf"w!1 ;:::;w ?1 g ` Pre(wi). i
That is, an argument is just a sequence of rules, each of which is applicable by the rules prior to it. The set notation used in the de nition is for convenience. Given a priority logic program hR; i, we are interested in those arguments that agree with the speci ed constraint . The construction of such an argument involves how to extend an argument I by possibly admitting mroe rules into it. Since when we specify r r0 , we mean the applicability of r0 blocks that of r, a natural notion of extending an argument I is: I admits a rule r (i.e. r extends I ) if there is no other rule r0 in I that blocks r. For example, consider the example bird fly ostrich don0t: 1 : fly bird 2 : :fly ostrich 3 : bird ^ ostrich where 1 2. Let I = f3; 2g. Thus, 1 cannot extend I . Since the notion of priority may have di erent interpretations, in general one can take the approach that the semantics of a priority logic program depends on a parameter R, which is a mapping over arguments. We call such a mapping an extensibility function. We now de ne the most intuitive extensibility function discussed above.
De nition 2.2 Let hR; i be a priority logic program, I be an argument, r be a rule in R. We de ne an extensibility function R1 as follows: R1(I ) = App(fr : 8r0 2 I; r 6 r0g): Note that, since each rule in an argument must be applicable in the argument itself, the employment of App is technical and ensures that the resulting set of rules is an argument.
De nition 2.3 Given an extensibility function R, an argument I is said to be self-extensible under R if I R(I ). 4
Not all arguments are self-extensible. E.g. with P = hf1 : a g; f1 1gi under R1, clearly f1g is not self-extensible, since R1(f1g) = ;. The approach based on extensibility function is suciently exible to allow various application-dependent extensions and modi cations. For example, one can strengthen the notion of extensibility by insisting on consistent extension: given an argument I and rule r, r extends I if there is no r0 2 I such that r r0 and if I implies the precondition of r then r's conclusion must not contradict I . This extensibility function can be used to express Horty's defeasible inheritance networks [9]. The details can be found in [18]. >From now on, we will say \a priority logic program hP; i with R (or under R)", to re ect the fact that the rst step in choosing a semantics is to specify how to extend an argument. However, since the technical results of this paper only depend on R1 given above, the reader can always safely assume R1 in place of a general extensibility function R.
De nition 2.4 (Stable argument) Let hP; i be a priority logic program with extensibility function R. An argument I is said to be a stable argument if R(I ) = I . A stable argument I is just a xpoint of extending I . That is, the rules in I are precisely those applicable rules that are not blocked by rules in it, no more, no less.
Example 2.1 (Closed world assumption)
Suppose there are n cities. Consider a database of ight connections between pairs of these cities. This can be represented by a priority logic program, under R1, as follows: 1 : fflight(A; B ) : if A; B are directly connectedg 2(x; y ) : :flight(x; y ) 3(x; y ) : flight(x; y ) flight(x; y ) 2(x; y ) 3(x; y ) This priority logic program has one and only one consistent stable argument I such that any two cities A and B are connected if and only if it is known they are connected. Obviously, this is a simple application of the closed world assumption of Reiter [12]. A stable argument is a total argument. E.g. suppose I is a stable argument under R1. Then, by de nition any rule r in I extends I (selfextensible) and for any rule r 62 I , if r's precondition can be concluded from I , then there is some rule r in I such that r0 r. Because of this totality, a priority logic program may not have a stable argument. For example, P = hf1 : a ; 2 : b g; f1 1gi has no stable argument under R1. To resolve this problem, we propose partial semantics, i.e., the kind of semantics that are de ned for all programs and give information on the portion of the program that \make sense", For example, for the program P above, since 2 is irrelevant to the con icting information, the argument 5
f2g should be accepted. Such a semantics depends on the properties of extensibility functions R. De nition 2.5 Let hP; i be a priority logic program with extensibility function R. R is monotonic i for any arguments I1 and I2 , I1 I2 implies R(I1) R(I2). R is anti-monotonic i for any arguments I1 and I2, I1 I2 implies R(I2) R(I1). If R is not monotonic, then there is no guarantee that a stable argument exists. However, if R is anti-monotonic then R2, the operator that applies R twice, is monotonic. It thus has a least xpoint and possibly other xpoints. It can be checked easily that R1 de ned earlier is anti-monotonic.
De nition 2.6 Let P = hR; i with a monotonic or anti-monotonic extensibility function R. A xpoint I of R2 is called an alternating argument of P if it is a xpoint of R2. It is said to be normal under R if I R(I ).1 By de nition, any normal alternating argument must be self-extensible, and a stable argument must be also a normal alternating argument. Hence the least normal alternating argument is exactly the intersection of all the normal alternating arguments, and thus serves as a kind of skeptical semantics. On the other hand, the maximal normal alternating arguments serve as a kind of credulous semantics. We call the least normal alternating argument the well-founded argument, and maximal normal alternating arguments regular arguments.
Example 2.2 Consider P = hf1 : a ; 2 : b ; 3 : c g; f1 2; 2 1gi under R1. P has a well-founded argument f3g and two regular arguments f1; 3g and f2; 3g, both of which are also stable. The importance of the the well-founded semantics of a priority logic program lies in its tractability. Since it is the least xpoint of a monotonic operator which can be computed iteratively from the empty argument, the semantics is tractable as far as the underlying monotonic function can be tractably computed. The relationship between semantics of priority logic programming and normal logic programming is given earlier in [17].
Theorem 2.1 Let P a normal program. There exists a polynomial time
transformation from P to a priority program P such that the well-founded model of P corresponds to the well-founded argument of P and regular models2 of P correspond to regular arguments of P . 1 The notion of alternating xpoint was introduced by Van Gelder [7] and later studied by a number of authors. 2 hence preferential extensions of Dung [5] and partial stable models of Sacca and Zaniolo [13], which are all equivalent to regular models [21].
6
3 Representing Stable Semantics of Disjunctive Programs A disjunctive program is a set of program clauses of the form:
1 j ::: j k 1 ; :::; m; not 1; :::; not n where i 's, i 's, and i 's are (ground) atoms. not is called an assumption. We denote by ASL the set of all assumptions in the underlying language L. We may use A B; not C to denote a clause where A is the set of atoms in the head, B the set of atoms in the body, and not C the set of the assumptions in the body. Conveniently, if C is a set of atoms, not C also denotes the set of assumptions not for each 2 C , and conversely, if not C is a set of assumptions C denotes the set of atoms appearing in these assumptions. A stable model M of a disjunctive program P is a set of atoms, which is a minimal model of the following transformed program:
B; not C 2 P; and 8(not ) 2 not C; 62 M g To express the stable semantics of a disjunctive program P in priority logic, we translate P into a priority logic program. First, we need some notations. Let Q be a set of atoms. We will denote by :Q the set of negative literals : , for each 2 Q. When we want to denote a disjunction with the classic connective of disjunction _ by a set of literals W , we use W_ . For example, if W = fa; b; :cg then W_ means a _ b _ :c. PM = fA
B :A
De nition 3.1 (Transformation stable (P )) The (stable) transformation of a disjunctive program P , denoted stable (P ), is a priority program hR; i, where R = fH_ :C j A B; not C 2 P; H_ = A [ :Bg [ fl: : : j not 2 ASLg [ fl : j not 2 ASLg = fl: l j not 2 ASLg Example 3.1 Let P = fd c; not e; c a; c b; a j b g. Its translation is stable (P ) = hR; i where R contains 1 : d _ :c :e 2 : c _ :a 3 : c _ :b 4 : a_b and for 2 fa; b; c; eg l : l: : : 7
and
= fl: l g
There are exactly two stable arguments:
I1 = fl:a; lb; lc ; l:e; ld; 1; 2; 3; 4g I2 = fl:b; la; lc ; l:e; ld; 1; 2; 3; 4g
They correspond, respectively, to the two stable models: M1 = fa; c; dg and M2 = fb; c; dg. Let us verify that I1 is a stable argument: fl:a; 4g ` b, and thus rule lb is applicable which blocks rule l:b; similarly, fl:a; 4; 3g ` c, and thus lc is applicable which blocks l:c ; nally, fl:a; l:e; 4; 3; 1g ` d, and thus ld is applicable. That is, any rule that is not in I1 is either not applicable (e.g. a a), or blocked by the priority speci ed in . Further, extending I1 yields precisely the same set of rules, i.e., R1(I1 ) = (I1 ). Therefore, it is a stable argument. Intuitively, stable transformation identi es an assumption not with : , and then applies CWA. The rst major result of this paper is that this
interpretation of the semantics of a disjunctive program coincides with that of stable models.
Theorem 3.1 Let P be a disjunctive program. For any stable model M of P , its translation stable (P ) has a stable argument I such that 62 M i l: 2 I , and 2 M i I ` . Conversely, for each stable argument I of stable (P ), there is a stable model M such that l: 2 I i 62 M , and I ` i 2 M . PROOF: We show the rst claim (from stable model to stable argument). The converse is similar. Suppose M is a stable mode of P . Then M is a minimal model of the positive disjunctive program PM . It is easy to check that M is a minimal model of PM i
f: : 62 M g [ fA [ :B : A
B 2 PM g j= f 2 M g
The righthand side of this equivalence leads to a construction of an argument of stable (P ) as follows:
I = fl: 62 M g[fH_
:C 2 stable(P ) : 8 2 C; 62 M g[fl : 2 M g Assume that the rule application sequence of I is as given in the same order above. Then obviously, I satis es the conditions: 62 M i l: 2 I and 2 M i I ` . 8
We now show that I is stable, i.e. R1(I ) = I . There are three kinds of rules in I , l: rules, l rules, and the remaining rules from stable (P ). Only the rst two kinds are related by . It is not dicult to see for any l: rule or l rule, it is in I i it is in R1(I ). For example, if l 2 I then is derivable. Since l: l , l: is blocked, i.e., l: 62 I . It follows that l 2 R1(I ). Other cases are similar. Since R1(I ) contains the same set of l: and l rules as that of I , the applicability of any of the remaining rules in stable (P ) does not change. We thus conclude R1(I ) = I . That is, I is a stable argument of stable (P ). 2 Since minimal models of a positive disjunctive program are just stable models, the above correspondence applies to positive disjunctive programs.
Corollary 3.1 Let P be a positive disjunctive program. There is one-one correspondence between minimal models M of P and stable arguments I of stable (P ): 62 M i l: 2 I and 2 M i I ` . There is an interesting implication of representing a semantics in priority logic; namely, priority logic can be seen as a formal system that supports both default assumptions and priorities over positive rules, since the former can be \compiled" into the latter. For example, suppose during the construction of a knowledge base, one has already written the following disjunctive program 1: drive j take bus 2: drive not car broken 3: take bus not good weather where j is the connective of epistemic disjunction. This is an incomplete speci cation as both drive and take bus are in the same answer set. To say that driving takes higher priority, one can specify that the second rule blocks the third by a priority constraint 3 2.3
4 Partial Stable Semantics for Disjunctive Programs 4.1 Why another semantics?
There are several reasons why the semantics to be proposed is interesting and important. First, it is well-known that a drawback of the stable semantics is that a disjunctive program may not have a stable model. Dung [5] uses the barber's paradox to illustrate this drawback for the case of normal program. Here we extend it to a disjunctive program. 3 Of course, the same e ect can be achieved by good weather not broken, which seems unintuitive and unnatural: how come car being broken or not has something to do with weather?
9
Example 4.1 Consider the disjunctive program: shave(bob; x) not shave(x; x) pay cash(y; x) j pay by credit(y; x) shave(x; y)
pay cash(x; y) pay by credit(x; y) This program intuitively says that bob shaves those who do not shave themselves; If x shaves y then y pays x by cash or credit, either way is accepted. Assume there is at least one another person, called greg . Then clearly, we should conclude bob shaves greg , and greg pays bob by cash or by credit, accepted(x; y) accepted(x; y)
either way is accepted. This program however has no stable model.
For this program, the static semantics [11] gives the correct solution. However, one should realize that static semantics is not designed to be capable of abductive reasoning. For example, if we observe that greg pays cash, abductive reasoning would yield abducibles that greg does not pay by credit and greg does not shave himself. There are other application domains in which the static semantics is not applicable. For example, in planning and scheduling, in general we are interested in any plan that achieves the goal, and any schedule that satis es the speci ed constraints. This is a form of credulous reasoning. In the case of normal programs, the drawback of the stable semantics mentioned above can be resolved by a weaker notion of a stable model, called regular model in [20], partial stable model in [13], and preferred extension in [5], which are all equivalent [21]. However, for disjunctive programs, a satisfactory weaker notion of stable model has not been presented in the literature. In [20], regular semantics is de ned for disjunctive programs. However, both Przymusinsk and Eiter have independently observed a drawback of the regular semantics for disjunctive programs; namely, it does not always obey the CWA principle. This can be illustrated by the following example.
Example 4.2 Consider the following disjunctive program: ajbjc a not b b not c c not a There are three regular models, each of which has exactly one true atom and two unde ned. One wonders how the true atom in such a model is obtained. Dung in [4] showed how some restricted classes of disjunctive programs can be understood as abduction in the sense of Eshghi and Kowalski [6]. But he left the question open as what is an abductive semantics for the class of all 10
disjunctive programs. The question becomes more interesting in light of the fact that Eshghi and Kowalski's procedure bears an e ective implementation: all it needs, on top of a traditional negation-as-failure proof procedure, is a mechanism to handle two kinds of loops, odd and even negative dependency loops,4 and the procedure is sound, and complete as well with positive loop checking, for the regular semantics of normal programs (cf. [8, 5]).
4.2 Partial stable semantics by constrained inferences
First, we strengthen the notion of derivation by a new inference rule whose aim is tentatively commit an assumption in order to derive additional information. For this purpose, we assume, for each assumption not in ASL , there is an atom not .
Rule of Tentative Assumption Commitment (RTAC): not i 1 _ ::: _ n ????????????? 1 _ ::: _ i?1 _ i+1 _ ::: _ n where i is an atom, any j , where i = 6 i, is a literal, and n > 1.
This inference rule is similar to resolution. Intuitively, it says that if we assume not we can make it stronger in an attempt to derive additional, tentative information. Since not is weaker than : , we do not want to treat not and as logical contradiction. This is prevented by the requirement n > 1. In the rest of this section, by a derivation, we mean the standard rst order derivation relation augmented by the above rule of inference. We will denote this derivation relation by `d . Note that this relation will be used, implicitly, in the construction of an argument. Now program transformation should be modi ed accordingly to t this rule of inference. Let us denote by not Q the set of atoms not for each not 2 not Q.
De nition 4.1 (Transformation p partial(P )) The (partial stable) transformation of a disjunctive program P is a priority program p stable (P ) = hR; i, where R = fH_ not C j A B; not C 2 P; H_ = A [ :Bg [ flnot : not j not 2 ASLg [ fl : j not 2 ASLg
= flnot l j not 2 ASLg In general, this procedure can be as ecient as any backward chaining proof procedure for the well-founded semantics. This claim is based on the following fact: Odd loops are treated exactly the same in both semantics, and for even loops, a procedure for the wellfounded semantics assigns the value undefined, and Eshghi and Kowalski's procedure simply indicates \in a model". 4
11
We are now ready to de ne the partial stable semantics based on the notion of partial stable assumption set.
De nition 4.2 Let P be a disjunctive program. Let p stable (P ) be its (partial stable) transformation and I a regular argument of p stable (P ). Then, S is a partial stable assumption set i the following holds: not 2 S i lnot 2 I . Since a stable argument is also a regular argument, and thus a stable model corresponds to a partial stable assumption set, the partial stable semantics extends stable semantics in the same way as the regular semantics extends stable semantics for normal programs.
Example 4.3 Consider disjunctive program P = fa j b
Its transformation yields
not a; not bg.
1 : a _ b not a; not b lnot a : not a lnot b : not b la : a a lb : b b and = flnot a la; lnot b lb g. The ony regular argument is the empty set. Thus, the partial stable semantics of P is described by the empty partial stable assumption set. The program however has no stable model. Suppose there is an additional clause in P , say, c j; d , then there will be two regular arguments for the transformed priority program, which correspond to the two partial stable assumptions sets: fnot cg and fnot dg. This shows that the semantics based on partial stable assumption sets does not collapse in case of non-existence of a stable model.
Example 4.4 The program in Example 4.2 also has one partial stable assumption set, the empty set.
Example 4.5 For the program in Example 4.1, its (partial stable) transformation yields a priority program hR; i where R contains (with obvious abbreviation and omission of
if the body is empty)
1: shave(bob; x) not shave(x; x) 2: cash(y; x) _ credit(y; x) _ :shave(x; y ) 3: accepted(x; y ) _ :cash(x; y ) 4: accepted(x; y ) _ :credit(x; y ) Assuming there are only three kinds of assumptions
fnot shave(x; x); not cash(x; y); not credit(x; y)g; 12
R contains additional rules: lnot shave (x) : not shave(x; x) lnot cash (x; y) : not cash(x; y) lnot credit (x; y) : not credit(x; y)
and consists of
lshave (x) : shave(x; x) shave(x; x) lcash (x; y) : cash(x; y) cash(x; y) lcredit (x; y) : credit(x; y) credit(x; y)
lnot shave (x) lshave (x) lnot cash (x; y) lcash (x; y) lnot credit (x; y) lcredit (x; y) Assume there are two people, bob and greg . Then the disjunctive program
has two partial stable assumption sets, one of which contains (among others) not shave(greg; greg ) and not cash(greg; bob), and the other contains not shave(greg; greg) and not credit(greg; bob).
Since a regular argument is a (maximal) xpoint of a monotonic operator, there is at least one partial stable assumption set for any disjunctive program.
Proposition 4.1 Every disjunctive program has at least one partial stable assumption set.
Apparently by de nition, the partial stable semantics for disjunctive programs reduces to the regular semantics for normal programs. The following result shows that this semantics satis es a desirable property; namely, each true atom derived by a program along with any of its partial stable assumption set is \founded". The proof is straightforward.
Theorem 4.1 Suppose P is a disjunctive program. Let be an atom, S a partial stable assumption set, and P [ S `d . Then there exists a clause A B; not C in P such that 2 A, not C S , P [ S `d B, and for each in, either not 2 S or P [ S `d .
4.3 Abductive reasoning with partial stable semantics
There is a natural notion of abduction associated with the proposed semantics. The key lies again in the use of the derivation relation augmented by RTAC. In general, an abductive framework be a triple h; Ab; IC i where P is a rst order theory, Ab is the set of abducibles, and IC is set of rst order formulas serving as integrety constraints. We restrict to a special class of abductive frameworks that correspond to disjunctive logic programming. Namely, we let be a disjunctive program, Ab be the set of assumptions, and IC = f? ( 1 _ ::: _ n ); not 1; :::; not n j n 1g 13
Let be an atom. We say that a set E of abducibles is an explanation of if P [ E `d and P [ E [ IC 6 `d ?
Example 4.6 Continuing with the Barber's example (Example 4.5), suppose we observe that greg pays cash to bob, cash(greg; bob). Then there is a partial stable assumption set S such that
P [ S `d cash(greg; bob) and P [ S [ IC 6 `d ? Thus, S is an explanation of cash(greg; bob).
Theorem 4.2 Let P be any disjunctive program and S be any partial stable assumption set of P . Then P [ S [ IC 6 `d ?. PROOF: Assume P [ S [ IC `d ?. Then P [ S `d f( 1 _ ::: _ n); not 1 ; :::; not n g where n 1. Using RTAC, we have P [ S `d i for each 1 i n. Let IS be the regular argument of p stable (P ) that corresponds to S . Note that lnot 2 IS , since not 2 S . But clearly lnot 62 R1(IS ). This implies IS 6 R1(IS ). Thus, IS cannot be a regular argument because it is not i
i
normal, and hence S is not a partial stable assumption set. Contradiction.
2
There is a technical implication of the use of ? to denote a constraint. It separates the case of deriving ? from deriving logical contradiction. For example, one can incorporate explicit negation by adding to IC constraints
f? ; : ; 2 Lg where denotes explicitly negated atom . That is, is viewed as an
atom to start with, and its intended meaning is de ned by integrey constraints. Then, an abductive semantics for extended disjunctive programs can be de ned as by those partial stable assumption sets S , for which we have P [ S [ IC 6 `d ?.
5 Related Work and Final Remark The concept of logic programming without default negation was rst suggested in [10] and further developed in [3]. The authors argue that a knowledge representation language without using default negation can avoid the possible confusions arising from the use of default and explicit negation. Priority in this framework however relies on the existence of contradiction. The e ect of its interaction with contradiction is usually hard to predicate. As a result, the semantics of a program under this notion of priority may not 14
be intuitive to what is intended. This treatment of priority also complicates the relation between programs with default negation (normal programs) and those without. This is because the transformation from the former to the latter has to resort to contradiction in order to have a one-one correspondence (cf. [19] for more details). Recently, Sakama and Inoue proposed prioritized logic programming, where priority is among literals and assumptions, not among rules [14]. Priority here is used to reduce the number of answer sets in disjunctive logic programming, while our notion of priority can remove answers from an answer set. Brewka recently proposes dynamic priority where a priority predicate is used in program rules just like any other predicate, and preferences are determined dynamically [2]. Extension of priority logic with dynamic priority constraint presents an interesting but challenging future research topic. Work is also under way to show that Eshghi-Kowalski's abductive procedure, augmented by standard resolution procedure, can be used to answer queries for disjunctive programs under the partial stable semantics. One notes that partial deduction as given in [15] is in fact a form of resolution. Thus, a disjunctive program can be rst partially evaluated so that clauses with head-cycles are no longer needed. Then, for head-cyclic free programs, the program obatined by an operation called shifting [4] can be used by Eshghi-Kowalski's procedure to show that an atom is true w.r.t. one partial stable assumption set. Or alternatively, Eshghi-Kowalski's procedure can be augmented by resolution dynamically. Aravindan proposed [1] a simpli ed abductive framework for disjunctive logic programming that provides a new inference rule for negation based on failure to explain where the disjunctive program clauses are simply of the form A1 _ ::: _ An B1 ; :::; Bm such that Ai and Bi are atoms with n 1 and m 0. Although the semantic is exactly the same that of (E)GCWA and its procedural interpretation based on the notion of support-for-negation, this study present a close relationship between abduction and negation. As we can see, the idea behind this framework is not new but still minimal model reasoning and hence can be expressed by our regular augment as follows: Let D be a disjunctive logic program of [1] and a sentence. Then there exists no adductive explanation for wrt D i D `d min : i p stable (D) has no regular argument such that is true in that argument. Also, empty set fg is an abductive explanation for wrt D i D `d min i p stable (D)'s every argument can conclude . Further questions have not been discussed in this work [1]: When default negation has been introduced into disjunctive logic programs, how the minimal mode be extended such that it can deal with default negation? Our framework give an elegant and simple resolution for this problem: For example, suppose we have a program: D = fp _ q not pg, Under our framework, the priority logic program p stable (D) is as follows: f1 : p _ q not p; lnot p : not p ; lnot q : not q ; lp : p ; lq : q qg 15
with priority relation:
set.
flnot p preclp; lnot q lq g. has only one regular argument: flnot p; 1; lqg which can conclude q; not p. So we not p is a partial stable assumption
References [1] Chandrabose Aravindan. An abductive framework for negation in disjunctive logic programming. Technical report, University of KoblenzLandau, 1996. [2] G. Brewka. Well-founded semantics for extended logic programming with dynamic preference. Journal of Arti cial Intelligence Research, 4:19{36, 1996. [3] Y. Dimopoulos and A. Kakas. Logic programming without negation as failure. In Proc. International Logic Programming Symposium. MIT Press, 1995. [4] P. Dung. Acyclic disjunctive logic programs with abductive procedures as proof procedure. In Proc. 1992 Fifth Generation Computer Systems, pages 555{561, 1992. [5] P. Dung. An argumentation theoretic foundation for logic programming. J. Logic Programming, 22:151{177, 1995. [6] K. Eshghi and R.A. Kowalski. Abduction compared with negation by failure. In Proc. 6th ICLP, pages 234{254. MIT Press, 1989. [7] A. Van Gelder. The alternating xpoint of logic programs with negation. J. Computer and System Sciences, pages 185{221, 1993. The preliminary version appeared in PODS '89. [8] L. Giordano, A. Marteli, and M. Sapino. A semantics for eshghi and kowalski's abductive procedure. In Proc. 10th ICLP. MIT Press, 1993. [9] J.F. Horty. Some direct theories of non-monotonic inheritance. In D. Gabbay and C. Hogger, editors, Handbook of logic and arti cial intelligence and logic programming, pages 111{187. Oxford University, 1991. [10] A. Kakas, P. Mancarella, and P. Dung. The acceptability semantics for logic programs. In Proc. ICLP, pages 504{519, 1994. [11] T. C. Przymusinski. Static semantics for normal and disjunctive logic programs. Annals of Mathematics and Arti cial Intelligence, 1995. 16
[12] R. Reiter. On closed world data bases. In H. Gallaire and J. Minker, editors, Logic and Data Bases, pages 55{76. Plenum Press, 1978. [13] D. Sacca and C. Zaniolo. Stable models and non-determinism in logic programs with negation. In Proc. the 9th ACM PODS, pages 205{217, 1990. [14] C. Sakama and K. Inous. Representing priorities in logic programs. In Proc. Int'l Conference and Symposium on Logic Programming. MIT Press, 1996. [15] Jurgen Dix Stefan Brass. Disjunctive semantics based upon partinal and botton-up evaluation. In Proc. Non-monotoic Reasoning and Logic Programming, 1995. [16] X. Wang, J. You, and L. Yuan. Circumscription by inference rules with priority. In Proc. 12th European Conf. on Arti cial Intelligence, pages 110{115, 1996. [17] X. Wang, J. You, and L. Yuan. Logic programming without default negation revisited. Tr96-25, Dept. Computing Science, University of Alberta, 1996. [18] X. Wang, J. You, and L. Yuan. Nonmonotonic reasoning = monotonic inferences + priority. In Proc. JICSLP Post-Conference Workshop on Nonmonotonic Extensions of Logic Programming, 1996. To appear in LNAI J. Dix, P. Pereira, and T. Przymusinski (eds). [19] Xianchang Wang, Jia-Huai You, and Li Yan Yuan. Priority logic program, argument and normal logic programming. Technical report, Department of Computing Science, University of Alberta, 1995. [20] J. You and L. Yuan. A three-valued semantics for deductive databases and logic programs. Journal of Computer And system Sciences, 49:334{ 361, 1994. A short version appears in Prec. PODS '90. [21] J. You and L. Yuan. On the equivalence of semantics for normal logic programs. J. Logic Programming, 22(3):211{222, 1995.
17
