An Implementation of the IFF Procedure in DALI

Transcription

1 An Implementation of the IFF Procedure in DALI Stefania Costantini, Emiliano Sebastiani, Arianna Tocchio 1 Introduction Abductive Logic Programming (ALP) [11] [12] has found broad application as a powerful tool for hypothetical reasoning with incomplete knowledge, as it combines: abduction, that operates by labeling some pieces of information as abducibles, i.e. as possible hypotheses which can be assumed to hold, provided that they are consistent with the given knowledge base; and logic programming, enriched with integrity constraints to further restrict the range of possible hypotheses. In recent years, a variety of proof procedures for ALP have been proposed. A very important one is the IFF procedure of Fung and Kowalski [8]. Among the other proposals, the ACLP procedure [13] integrates abductive reasoning with constraint solving. Some recent procedures are explicitly aimed at improving the IFF. The CIFF [7] procedure is aimed at providing increasing generality on the kind of constraints that can be expressed, also in view of the definition of logical agents and multi-agent systems. On the same line, in the SCIFF procedure [1] abducibles represent hypotheses about agent behaviour; SCIFF deals with the concept of fulfillment, i.e., the correspondence of abduced atoms with events (that a logical agent has perceived) recorded in a history. All these procedures are sound, but have problems with completeness, which is not achieved for the general case. In this paper, we present a novel implementation of the IFF proof procedure. The approach of this paper is indebted to [6], that proposes some abstract argumentationbased proof procedures for assumption-based reasoning (of which abduction is an instance) building on the stable model semantics of [9]. We overcome completeness problems and obtain a correct and complete implementation by adopting a completely different novel approach. Rather that re-implementing the procedure in fact, we translate an ALP program into other formalisms, of which we exploit the inference engines. In particular, our proposal relies upon: Answer Set Programming (ASP), which is a new logic programming paradigm [14] the Answer Set (or equivalently Stable Model) semantics [9]; and the new logic programming language DALI [3] [16], which provides special proactive features, so that one can specify conditions that are to be automatically checked. Precisely, a given ALP program is (automatically) translated into: (i) an ASP program, that generates a superset of the abductive explanations (that are the expected results of the ALP program) and (ii) a DALI program that rules out incorrect solutions. Due to the proactive features of DALI, there is no need of defining a meta-interpreter: rather, the different conditions of each IFF rule are checked concurrently (and, potentially, in parallel) by means of the special DALI mechanism of internal events. 1

2 The advantages of our proposal are: (i) the implementation is correct and complete, relies on available tools (i.e., Answer Set solvers and the DALI interpreter) (ii) it can easily be extended to encompass new features, such as probability of explanations. The limits of our proposal are: (a) we consider only ALP programs that can be transposed into DATALOG programs (on which the Answer Set semantics is defined), i.e., no function symbols are allowed; (b) constraints are limited to those that can be expressed in ASP; (c) we interpret classical negation as negation-as-failure; (d) we disallow disjunction in the definition of constraints. 2 Abductive Logic Programming An abductive logic program is a pair (Th, IC) consisting of a theory Th and a finite set of integrity constraints IC. A theory is a set of so-called iff-definitions: p(x 1,...,X k ) D 1,..., D n The predicate symbol p must not be a special predicate (constraint predicates, =, and ) and there can be at most one iff-definition for every predicate symbol. Each of the disjuncts D i is a conjunction of literals. Negative literals are written as implications (e.g. q(x,y) ). The variables X 1,..., X k are implicitly universally quantified with the scope being the entire definition. Any other variable is implicitly existentially quantified, with the scope being the disjunct in which it occurs. Any predicate that is neither defined nor special is called an abducible. The integrity constraints in the set IC are implications of the following form: L 1... L m A 1... A n. Each of the L i must be a literal (with negative literals again being written in implication form); each of the A i must be an atom. Any variables are understood to be implicitly universally quantified with the scope being the entire implication. A query Q is a conjunction of literals. Variables occurring in Q are implicitly existentially quantified. A theory provides definitions for certain predicates and integrity constraints restrict the range of possible interpretations. A query may be regarded as an observation against the background of the world knowledge encoded in a given abductive logic program. An answer to such a query would then provide an explanation for this observation: it would specify which instances of the abducible predicates have to be assumed to hold for the observation to hold as well. In addition, such an explanation should also validate the integrity constraints. This intuitive account of the semantics of ALP may be formalized as follows. A correct answer to a query Q with respect to an abductive logic program (Th, IC) is a pair (,σ), where is a finite set of ground abducible atoms and σ is a substitution for the free variables in Q, such that: Th Comp( ) = IC Qσ A suitable interpretation of the entailment operator = would the usual consequence relation of first-order logic with the restriction that constraint predicates have to be interpreted according to the semantics of the chosen constraint system and equalities evaluate to true whenever their two arguments are unifiable. Comp( ) stands for the completion of the set of abducibles in, i.e. any ground abducible atom not occurring in is assumed to be false. An ALP program may have no correct answer. In the following, we take abductive explanations to be minimal correct answers, i.e., those such that no subset is a correct answer. 2

3 3 Answer Set Programming Answer Set Programming (ASP) is an emergent paradigm of logic programming [14] based on the Answer Set (or equivalently Stable Model) semantics [9] [10]: each solution to a problem is represented by an Answer Set (also called a Stable Model) of a deductive database/function free logic program encoding the problem itself. The Answer Set semantics is a view of logic programs as sets of inference rules (more precisely, default inference rules). Alternatively, one can see a program as a set of constraints on the solution of a problem, where each answer set represents a solution compatible with the constraints expressed by the program. Consider for instance the simple program {q : not p. p: not q.}: the first rule is read as assuming that p is false, we can conclude that q is true. Vice versa, the second rule is read as assuming that q is false, we can conclude that p is true. This program has two answer sets. In the first one, q is true whereas p is false; in the second one, p is true whereas q is false. Notice that the above program represents an even cycle, i.e. each atom depends indirectly (and via negation) upon itself, through an even number of dependencies, corresponding to an even number of rules. Then, in ASP we are able to manage cyclic negative dependencies that represent incomplete knowledge or denote the possibility of different alternatives, by representing each consistent choice by means of an Answer Set. Unlike with other semantics, a program may have several answer sets (as before), or may have no answer set, because conclusions are included in an answer set only if they can be justified. The following program has no answer set: {a : notb. b : notc. c: nota.} The reason is that in every minimal model of this program there is a true atom that depends (in the program) on the negation of another true atom. Whenever a program has no answer sets, one says that the program is inconsistent. Correspondingly, checking for consistency means checking for the existence of answer sets. To solve a problem using ASP means to write a logic program whose answer sets correspond to solutions, and then find a solution using an Answer Set solver. The basic approach to writing such a program is known as the generate-and-test strategy. First one writes a group of rules for defining the search space of potential solutions i.e., an easy-to-describe superset of the set of solutions. Then one adds a constraints (rules with empty head) that suitably prune the set solutions. The search space is often generated by using even cycles of the form described above. For each proposition a that can be either true or false, one introduces a new atom, say no a, and adds to the program the cycle {a : notno a. no a: nota.}. This generates two candidate answer sets, one where a is true and the other one where a is false (and no a true), namely {a} and {no a}. Analogously, with any even number of atoms, say a 1,...,a n with n even: the even cycle a 1 : notno a 1,no a 1 : nota 2,..., a n : notno a n,no a n : nota 1 has two answer sets, namely {a 1,...,a n } and {no a 1,...,no a n }. In the rest of the paper, when saying an even cycle involving a 1,...,a n we mean an even cycle with these structure, and these answer sets. The two partial answer sets of all the even cycles are then combined in all possible ways, thus generating the whole search space. ASP solvers take as input the ground instantiation of given program. Then, in program rules each variable must be directly or indirectly characterized by domain 3

4 predicates that define ranges of constants. Given for instance rule p(x) : q(x), one must actually write it in the form p(x) : dom(x),q(x) where the simplest option is that dom(x) defines exhaustively all constants occurring in the program. The reader may refer to the web site [17] for many examples about ASP and for references to the existing solvers. 4 The DALI language The DALI language is mainly aimed at modeling Agents and Multi-Agent systems in computational logic [3] [4] [16]. In the proposed implementation of the IFF procedure we use DALI instead of prolog for defining a filter program that verifies the correctness of a candidate abductive hypothesis because, in the line of [12] [7] [1] and many others, we want to be able to define logical agents capable of abductive reasoning. DALI is an Active Logic Programming that enhances prolog-like logic programming by means of patterns for reactivity, proactivity and memory. The formalization models these concepts by introducing different kinds of events, with a suitable treatment. There are in particular the classes of external, present, past and internal events. Events are managed by special rules, called reactive rules. Proactivity, i.e., the ability of activating inference processes without user intervention according to suitable (predefined though customizable) conditions is what makes the language active, and is based on the mechanism of internal events. Any atomic proposition occurring in the head of a rule can be designated to be treated as an internal event, by means of a specific directive to the language interpreter. Then, the interpreter will repeatedly try to prove the proposition, according to the frequency of attempts and the terminating conditions specified in the directive. As soon as the proof succeeds, the proposition is interpreted as a stimulus for triggering further inference, i.e., as an event that, rather that coming form the outside, has been originated internally in the program. This further inference is understood as a reaction to this event, and specified in the body of a reactive rule, that is intended to be executed when its head (the internal event) is true. The internal event mechanism then implies then definition of two rules. The first one contains the conditions that must be true so that the reaction (in the second rule) may happen. For the sake of readability, in the second rule the internal event is indicated with postfix I, and the new connective :> is adopted to indicate that the body is attempted whenever the head has been proved. IntEvent: Conditions IntEvent I :> Body If the reactive rule is omitted, then it is implicitly of the form IntEvent I :> true, i.e., it does nothing. Consider the following simple example, where the program concludes that it is late if it runs after midnight and, if so, decides (as a reaction) to go home. late: after midnight. late:> go home. 4

5 After reaction, every event eis recorded as a past event with syntax ep : timestamp where the timestamp can be omitted whenever not needed. In the example, after reaction the program will contain the new fact latep : t. Past events and are kept (and then possibly removed) according to user indication. Apart from event management, DALI is close in syntax and semantics to the plain Hornclause language. The DALI inference engine is based on an extended resolution [3] corresponding to an operational model [16]. The language semantics is defined as an evolutionary semantics [5]. Namely, the semantics of a given DALI program P is defined in terms of a modified program Ps, where reactive and proactive rules are reinterpreted in terms of standard Horn Clause rules. The reception of each kind of event is formalized as a suitable program transformation step. Then, one will have an initial program P 0 = Ps which, according to these programtransformation steps (each one transforming P i into P i+1 ), gives rise to a Program Evolution Sequence PE = [P 0,...,P n ]. The program evolution sequence will have a corresponding Semantic Evolution Sequence ME = [M 0,...,M n ] where M i is the semantic account of P i. In the case of DALI, this is either the least Herbrand model or the well-founded model if one uses negation-as-failure (the reader may refer for instance to [15] for definitions). The couple P E; M E is the Evolutionary Semantics of program P, corresponding to the particular sequence of events that has happened, and to the order in which they have been considered. Whenever an internal event a becomes true in the semantics of P j, the related program transformation step will asserted a as a new fact, thus deriving P j+1. There, the new fact will allow reaction to be triggered, and a to be then asserted as a past event ap. 5 An ASP+DALI implementation of the IFF Procedure In this section we present the proposed implementation of the IFF procedure. We make the simplifying assumption that each integrity constraint in IC has an atom as its head,i.e., that it is of the form L 1... L m A where A is an atom. Also, we assume to restrict constraint predicates occurring in both iff rules and IC constraints (equalities, inequalities, etc.) to those that are coped with by Answer Set solvers. As a running example, we consider the following variation of a well-known example proposed by R. A. Kowalski. Example 5.1 The theory T says that grass can be wet whenever (if and only if) either it rained, or the sprinkler had been activated, or there is dew on it. Then, it is stated that the weather is cold. The integrity constraint part IC state that rain is possible only if the weather is cloudy, dow requires cold wet weather, and that, actually, it was not cloudy. Finally, the abducibles part Ab state which are the fact that we can assume to be true to account for the given situation, assuming that a consistent explanation is possible. T: grass-is-wet rain-last-night sprinkler-was-on night-dew. cold-weather. IC: cloudy-last-night rain-last-night. 5

6 night-dew cold-weather, wet-weather. false cloudy-last-night. Ab: rain-last-night, sprinkler-was-on, cloudy-last-night, wet-weather Q: grass-is-wet In this case, the weather not being cloudy rules out rain. {sprinkler was on} and {wet weather, dew} are instead abductive explanations, i.e., minimal correct answers. Given ALP program P, we do the following: 1. Translate (in a standard way) P into: an ASP program P and a DALI program P. This involves a preliminary pre-processing of P into an intermediate form P i as described below. 2. Let S be the set M 1,ldots,M n of the answer sets of P, obtained by means of an answer set solver. As we will see, S corresponds to a superset of the abductive explanations of P. Then for each M i : (a) Get rid of some of the auxiliary predicates, so as to restrict the remaining atoms to be ground instances of abducibles and then we assert these atoms as facts (unit clauses) in P. (b) Run P augmented with the new facts. As we will see, P accepts only if M i corresponds to an abductive explanation. (c) If P accepts, obtain the abductive explanation E Mi corresponding to M i by a final simple post-processing. The pre-processing step is defined as follows: Definition 5.1 The intermediate form P i If an abducible predicate p occurs in more than one rule of T, say in a number s of rules, it is renamed into p 1, p 2,...p s so that the rules do not interfere. If s is odd, we also conventionally add p s+1 so as to obtain an even number of versions of p. Each rule of T, of the form p(x 1,...,X k ) D 1,..., D n is rewritten into the set of rules: p(x 1,...,X k ) d 1 (X 1,...,X k ),..., d n (X 1,...,X k ) d i (X 1,...,X k ) D i, i n where the d i s are new atoms. The advantages of the intermediate form are that of: having atomic conditions on the right-hand-side of the iff rules; making iff rules independent of each other by standardizing abducibles apart. Clearly, later on it will be necessary to relate renamed abducibles, in that if an abductive explanations contains, e.g., p 1 (Args) it must contain also p 2 (Args), etc. for each renamed version. 6

7 5.1 The ASP program P Definition 5.2 Given an ALP program P, the corresponding ASP program P is obtained as follows from the intermediate version P i of P : 1. Every iff rule of the form p(x 1,...,X k ) d 1 (X 1,...,X k ),..., d n (X 1,...,X k ) is rewritten as the set of rules p(x 1,...,X k ) : d 1 (X 1,...,X k ). p(x 1,...,X k ) : d n (X 1,...,X k ). 2. Integrity constraints of IC, which are of the form H Body, are rewritten as H : Body. 3. For each abducible atom p(x 1,...,X m ) Ab: (a) if p has not been renamed, add the even cycle involving p; (b) if p has been renamed into p 1,..., p r add the even cycle involving p 1,..., p r. 4. Given query Q in P, add rules: query : Q. : query. where query is a fresh auxiliary predicate. 5. In all the above rules, for each variable X occurring therein add in the body of the rule the subgoal dom(x) and, for each constant c occurring in P, add the unit clause dom(c) where dom is a fresh auxiliary predicate. Each answer set M of P (if any) corresponds to a candidate abductive explanation E M of P by selecting only the atoms corresponding to abducible predicates and collapsing each tuple of atoms p1(args),..., p r (args) corresponding to renamed abducible predicates (if any) into the single atom p(args). Then, the answer sets M 1,ldots,M n of P correspond to a set of candidate abductive explanations E = {E M1,ldots,E Mn }. Example 5.2 Below is the program P corresponding to our running example (where for brevity the predicate names are shortened in an obvious way). Since the program is propositional, no domain predicate is needed. The pre-processing phase in this case changes nothing. grasswet : rain. grasswet : sprinkler. grasswet : dew. cold. cloudy : rain. dew : wet, cold. 7

8 : cloudy. cloudy : not nocloudy. nocloudy : not cloudy. rain : not norain. norain : not rain. sprinkler : not nosprinkler. nosprinkler : not sprinkler. wet : not nowet. nowet : not wet. query : grasswet. : not query. Its answer sets are the following: M 1 = {query,grasswet, dew, wet, nosprinkler, norain, nocloudy, cold} M 2 = {query,grasswet, sprinkler, nowet, nodew, norain, nocloudy, cold} M 3 = {query,grasswet, sprinkler, wet, dew, norain, nocloudy, cold} Notice that in all of them we have norain and nocloudy because of the integrity constraints in IC that rule out cloudy and consequently rain. These answer sets correspond to candidate abductive explanations: E M1 = {wet,dew} E M2 = {sprinkler} E M3 = {sprinkler,wet,dew} where E M1 and E M2 are abductive explanations as they are minimal. Theorem 5.1 For every abductive explanation E of P, E E. Proof 1 (Sketch) All the iff rules of P are represented in the if direction, and all the integrity constraints are represented as such. The ASP constraint : query forces the given query Q to be true in all the answer sets, which requires selecting suitable combinations of (ground versions of) the abducibles. These combinations are made available by the even cycles, provided that the even cycle involving any renamed abducible predicates p guarantees that if p i (args) is assumed, all the sibling versions p1(args),..., p r (args) are coherently assumed, and can then be collapsed into one. This proves the hypothesis. Clearly however, splitting iff rules into one rule for each disjunct means relaxing the minimality assumption, and then there will some E Mj which are not minimal as redundant assumptions are made. 5.2 The DALI program P Definition 5.3 Given an ALP program P, the corresponding DALI program P is obtained as follows from the intermediate version P i of P, assuming that the component Th of P contains a number r of iff rules: 1. The t-th iff rule occurring in Th (t r), of the form p(x 1,...,X k ) d 1 (X 1,...,X k ),..., d n (X 1,...,X k ) is rewritten as the rule: 8

9 ifft : p(x 1,...,X k ). where ifft is designated to be an internal event, plus a set of n rules, where for j k the first rule has the form: p(x 1,..., X k ) : d 1 (X 1,..., X k ), not d 2 (X 1,..., X k ),..., not d n (X 1,..., X k ). and the j-th rule has the form: p(x 1,..., X k ) : d j (X 1,..., X k ), not d 1 (X 1,..., X k ),..., not d j 1 (X 1,..., X k ), not d j+1 (X 1,...,X k ),..., not d n (X 1,...,X k ). 2. Each rule of the form H Body defining the d i s is rewritten as H : Body. 3. The two following rules are finally added: iff : iff1p,...,iffrp. iffi :> accepta. where accepta is an action, that communicates a positive result to the environment where the program will be situated (in the simplest case, the program can print something). Definition 5.4 (Minimality Check) Given a candidate abductive explanation E Mi returned by P, the corresponding minimality check is performed by: (i) extracting from M i all atoms A corresponding to abducible predicates (so that all versions of renamed abductive predicates remain distinct, and thus the different iff clauses are independent); (ii) adding them as unit clause to P ; (iii) running P. The minimality check is successfully if P accepts, i.e., executes the accepta action. Example 5.3 Below is the program P corresponding to our running example. iff1 : grasswet. grasswet : rain, not sprinkler, not dew. grasswet : sprinkler, not rain, not dew. grasswet : dew, not rain, not sprinkler. iff1 : cold. cold. iff : iff1p,iff2p. iffi :> accepta. Predicates iff1, iff2 and iff are internal events, i.e., they are repeatedly attempted concurrently. Assume to add any of the candidate abductive explanations E Mi to the program (by adding its atoms as unit clauses). Each of the iff1 and iff2 checks minimality of the corresponding iff rule by checking that only one disjunct holds. Whenever they succeed, there is no reaction but they become past events, with syntax iff1p, iff2p. If they both succeed, the internal event iff, which has the role of collecting the outcome 9

10 of all the iff rules, will succeed as well. The reaction to this internal event will be that of accepting, thus certifying minimality of the candidate explanation which is being examined. Clearly, E M3 will not be accepted as both sprinkler and dew hold. We have not provided an explicit rejection since, in the view of agents reasoning within resource bounds, a candidate explanation is assumed to be rejected whenever it is not accepted within a given time limit. Theorem 5.2 Given a candidate explanation E, DALI program P accepts if and only if E it is an abductive explanation. Proof 2 (Sketch) Trivially, program P checks that only one disjunct of each iff rule holds. This relies upon the fact that abducibles that occur in several rules are renamed, though they are coherently generated together by P. Corollary The implementation P + P is a complete and a correct implementation of IFF procedure. The advantages of the DALI implementation upon a prolog implementation are at least the following: Program P can be part of a wider agent program. In an agent context we may not have a whole candidate abductive explanation given from the start; rather, its elements can reach the agent at different times: the mechanism of internal events that are repeatedly attempted guarantees that each iff rule can be processed as soon as the related abductive assumptions become known (though some limited modifications to the above program are needed, to rule out other alternatives as soon as one is verified). We can state a limit time threshold for acceptance by simply making it explicit in the directive related to the internal event iff. 5.3 Concluding Remarks In conclusion, we observe that our implementation copes with the IFF proof procedure with simplifications and analysis of general cases, corresponding (with some simplifying assumptions) to the formulation of Fung and Kowalski. We have basically exploited logical equivalences for rewriting of iff clauses into other logic languages. This is the key of our procedure, and has allowed us to obtain soundness and completeness. We have overcome the most difficult part of previous formulations, i.e., the individuation of general cases, thus excluding every ambiguity that can exist in choosing a reduction rule instead of another one. We are experimenting possible improvements, such as a declarative definition of the probability (or weight) of alternative explanations or preferences among abducibles. To this aim, we can either exploit existing features of ASP, or take profit from extensions like for instance LPODS [2] where one can write expressions such as A B, where the new connective stands for ordered disjunction. The expression intuitively stands for: if possible A, but if A is impossible then (at least) B. If there are several disjuncts, the first one represents the best preferred option, the second one represents the second best option, etc. 10

11 References [1] Marco Alberti, Marco Gavanelli, Evelina Lamma, Paola Mello, and Paolo Torroni. The SCIFF abductive proof-procedure. In Stefania Bandini and Sara Manzoni (eds), AI*IA 2005: Advances in Artificial Intelligence: Proceedings of the 9th Congress of the Italian Association for Artificial Intelligence. LNAI 3673, pp , Springer Verlag, Berlin, [2] G. Brewka. Logic Programming with Ordered Disjunction, In Proceedings of AAAI-02, Edmonton, Canada, [3] S. Costantini and A. Tocchio. A Logic Programming Language for Multi-agent Systems. In S. Flesca, S. Greco, N. Leone, G. Ianni (eds.), Logics in Artificial Intelligence, Proceedings of the 8th European Conference, JELIA LNAI 2424, Springer-Verlag, Berlin, [4] S. Costantini, A. Tocchio, The DALI Logic Programming Agent-Oriented Language. In J. J. Alferese and J. Leite(eds.), Logics in Artificial Intelligence, Proceedings of the 9th European Conference, Jelia LNAI 3229, Springer- Verlag, Berlin, [5] S. Costantini, A. Tocchio. About declarative semantics of logic-based agent languages. In M. Baldoni and P. Torroni (eds.), Declarative Agent Languages and Technologies, Post-Proceedings of DALT LNAI 3229, Springer-Verlag, Germany, [6] P.M. Dung, P. Mancarella, and F. Toni. Argumentation-based proof procedures for credulous and sceptical non-monotonic reasoning. In A.C. Kakas and F. Sadri (eds.), Computational Logic: Logic Programming and Beyond Essays in Honour of Robert A. Kowalski, pp LNAI 2408, Springer Verlag, Berlin, [7] U. Endriss P. Mancarella F. Sadri G. Terreni F. Toni. The CIFF Proof Procedure for Abductive Logic Programming with Constraints. In J. J. Alferese and J. Leite(eds.), Logics in Artificial Intelligence, Proceedings of the 9th European Conference, Jelia LNAI 3229, Springer-Verlag, Berlin, [8] T. H. Fung and R. A. Kowalski. The IFF proof procedure for abductive logic programming. Journal of Logic Programming, 33(2): , [9] M. Gelfond and V. Lifschitz. The stable model semantics for logic programming. in: Proceedings of 5th JICSLP conference, pp The MIT Press, [10] M. Gelfond and V. Lifschitz. Classical negation in logic programs and disjunctive databases. New Generation Computing, pp , [11] A. C. Kakas, R. A. Kowalski, and F. Toni. Abductive logic programming. Journal of Logic and Computation, 2(6), pp , [12] A. C. Kakas, R. A. Kowalski, and F. Toni. The role of abduction in logic programming. In Handbook of Logic in Artificial Intelligence and Logic Programming, volume 5, pages Oxford University Press,

12 [13] A. C. Kakas, A. Michael, and C. Mourlas. ACLP: Abductive constraint logic programming. Journal of Logic Programming, 44, pp , [14] V. Lifschitz. Answer Set Planning. in: D. De Schreye (ed.) Proceedings of the 1999 International Conference on Logic Programming ICLP 99 (invited talk), pp The MIT Press, [15] H. Przymusinska and T. C. Przymusinski. Semantic issues in deductive databases and logic programs. in: R.B. Banerji (eds.) Formal Techniques in Artificial Intelligence, a Sourcebook, Elsevier Sc. Publ. B.V. (North Holland), [16] A. Tocchio. Multi-Agent sistems in computational logic, Ph.D. Thesis, Dipartimento di Informatica, Universitá degli Studi di L Aquila, [17] WASP Teaching ASP Website. By the Working Group on Answer Set Programming (WASP), URL: 12