Defeasible logic programming: an argumentative approach

arXiv:cs/0302029v1 [cs.AI] 20 Feb 2003 To appear in Theory and Practice of Logic Programming 1 Defeasible Logic Programming An Argumentative Approach Alejandro J. Garcı́a Guillermo R. Simari [email protected] [email protected] Departament of Computer Science & Engineering Universidad Nacional del Sur - Bahı́a Blanca - Argentina Abstract The work reported here introduces Defeasible Logic Programming (DeLP), a formalism that combines results of Logic Programming and Defeasible Argumentation. DeLP provides the possibility of representing information in the form of weak rules in a declarative manner, and a defeasible argumentation inference mechanism for warranting the entailed conclusions. In DeLP an argumentation formalism will be used for deciding between contradictory goals. Queries will be supported by arguments that could be defeated by other arguments. A query q will succeed when there is an argument A for q that is warranted, i. e. the argument A that supports q is found undefeated by a warrant procedure that implements a dialectical analysis. The defeasible argumentation basis of DeLP allows to build applications that deal with incomplete and contradictory information in dynamic domains. Thus, the resulting approach is suitable for representing agent’s knowledge and for providing an argumentation based reasoning mechanism to agents. 1 Introduction Research in Nonmonotonic Reasoning, Logic Programming, and Argumentation have provided important results seeking to develop more powerful tools for knowledge representation and common sense reasoning. Advances in those areas are leading to important and useful results for other areas such as the development of intelligent agents and multi-agent system applications. The work reported here introduces Defeasible Logic Programming (DeLP), a formalism that combines results of Logic Programming and Defeasible Argumentation. DeLP provides the possibility of representing information in the form of weak rules in a declarative manner, and a defeasible argumentation inference mechanism for warranting the entailed conclusions. These weak rules are the key element for introducing defeasibility (Pollock, 1995) and they will be used to represent a relation between pieces of knowledge that could be defeated after all things are considered. We believe that common sense reasoning should be defeasible in a way that is not explicitly programmed. Defeat should be the result of a global consideration of the corpus of knowledge of the agent performing the inference. Defeasible Argumentation provides the tools for doing this. 2 Alejandro J. Garcı́a and Guillermo R. Simari Defeasible Argumentation is a relatively young area, but already mature enough to provide solutions for other areas. Argumentative Systems are now being applied for developing applications in legal systems, negotiation among agents, decision making, etc, (Prakken & Vreeswijk, 2000; Chesñevar et al., 2000; Garcı́a et al., 2000). As we will show below, DeLP considers two kinds of program rules: defeasible rules used for representing weak or tentative information, like “a mammal does not fly”, denoted ∼flies —< mammal , and strict rules used for representing strict (sound) knowledge, like mammal ← dog, “a dog is a mammal”. Syntactically, the symbol “—<” is all that distinguishes a defeasible rule from a strict one. Pragmatically, a defeasible rule is used to represent defeasible knowledge, i. e., tentative information that may be used if nothing could be posed against it. Defeasible rules will add a new representational capability for expressing a weaker link between the head and the body in a rule. A defeasible rule “Head —< Body ” is understood as expressing that “reasons to believe in the antecedent Body provide reasons to believe in the consequent Head ” (Simari & Loui, 1992). Strong negation is allowed in the head of program rules, and hence may be used to represent contradictory knowledge. Although strong negation has been introduced in several extensions of Logic Programming, many of those extensions handle contradictory programs in a way we feel could be improved. DeLP incorporates an argumentation formalism for the treatment of contradictory knowledge. This formalism allows the identification of the pieces of knowledge that are in contradiction. A dialectical process is used for deciding which information prevails. In particular, the argumentation based definition of the inference relation makes it possible to incorporate a treatment of preferences in an elegant way. In DeLP a query q will succeed when there is an argument A for q that is warranted. Intuitively, an argument is a minimal set of rules used to derive a conclusion. The warrant procedure involves looking for counter-arguments that could defeat A. Donald Nute in (Nute, 1994) remarks “An inference is defeasible if it can be blocked or defeated in some way”. Weak rules provide the locus where the blocking or defeating might occur. A query q will succeed if a supporting argument A for q is not defeated. In order to establish whether A is a non-defeated argument, argument rebuttals or counter-arguments that could be defeaters for A are considered, i. e., counter-arguments that by some criterion, are preferred to A. Our defeaters will take the form of arguments, therefore defeaters for the defeaters may exist. In this manner, starting with an argument A for a query q, a dialectical analysis it will consider all the defeaters for A, and then the defeaters for each defeater, and so on. DeLP provides a warrant procedure that implements that dialectical analysis. Thus, a query q will be warranted, if the argument A that supports q is found undefeated by the warrant procedure. During the dialectical analysis certain constraints are imposed for averting problematic situations such as producing an infinite sequence of defeaters. Thus, DeLP can manage defeasible reasoning and handle contradictory programs, allowing the representation of defeasible and non-defeasible knowledge. We will also discuss briefly in this paper how to extend DeLP for considering default negation. Defeasible Logic Programming An Argumentative Approach 3 The resulting approach is suitable for representing agent’s knowledge and for providing an argumentation based reasoning mechanism to agents. In (Garcı́a et al., 2000), a particular application for a multi-agent system in the stock market domain has been developed using DeLP. There, agents knowledge is specified in the form of a defeasible logic program, and agents reason using DeLP in order to reach decisions about buying or selling stocks. As Brewka states in (Brewka, 2001a), argumentation plays a central role in the communication of human and artificial agents and is an ubiquitous task in professional and everyday life. We agree with Brewka that it is necessary to “...take not only the logical, but also the procedural character of argumentation seriously...”. It is remarkable that Nute’s Defeasible Logic (Nute, 1994), recent extensions to defeasible logic (Antoniou et al., 2000a; Antoniou et al., 1998), and several defeasible argumentation formalisms (Loui, 1997a; Prakken & Sartor, 1997; Vreeswijk, 1997), also consider defeasible rules for representing knowledge. However, in most of these formalisms, a priority relation among rules must be explicity given with the program in order to decide between rules with contradictory consequents. This work is organized as follows. Section 2 introduces the language of DeLP without default negation. In Section 3 the defeasible argumentation formalism is developed. and two comparison criteria are introduced. A dialectical procedure for obtaining a warrant conclusion is developed in Section 5. In Section 6 DeLP with default negation is considered. Implementation issues and applications are described in Section 7, and finally in Section 8 the related work is surveyed. 2 The Language The DeLP language is defined in terms of three disjoint sets: a set of facts, a set of strict rules and a set of defeasible rules. In the language of DeLP a literal “L” is a ground atom “A” or a negated ground atom “∼A”, where “∼” represents the strong negation. Hence, literals have no variables. Definition 2.1 (Fact ) A fact is a literal, i. e. a ground atom, or a negated ground atom. Definition 2.2 (Strict Rule) A Strict Rule is an ordered pair, denoted “Head ← Body ”, whose first member, Head , is a literal, and whose second member, Body, is a finite non-empty set of literals. A strict rule with the head L0 and body {L1 , . . . , Ln } can also be written as: L0 ← L1 , . . . , Ln (n > 0). Definition 2.3 (Defeasible Rule) A Defeasible Rule is an ordered pair, denoted “Head —< Body”, whose first member, Head , is a literal, and whose second member, Body, is a finite non-empty set of literals. A defeasible rule with head L0 and body {L1 , . . . , Ln } can also be written as: L0 —< L1 , . . . , Ln (n > 0.) The syntax of strict rules correspond to basic rules (Lifschitz, 1996), but we call them ‘strict’ to emphasize the difference with the ‘defeasible’ ones. Observe that 4 Alejandro J. Garcı́a and Guillermo R. Simari strong negation may be used in the head of the rules. Some examples of strict rules are: “∼innocent ← guilty”, “dead ← ∼alive”. Syntactically, the symbol “—<” is all that distinguishes a defeasible rule from a strict one. Pragmatically, a defeasible rule is used to represent defeasible knowledge, i. e., tentative information that may be used if nothing could be posed against it. Thus, whereas a strict rule is used to represent non-defeasible information such as: “bird ← penguin” which expresses that “all penguins are birds”, a defeasible rule is used to represent defeasible knowledge such as “flies —< bird ” which expresses that: “reasons to believe that it is a bird provide reasons to believe that it flies”, or “birds are presumed to fly” or “usually, a bird can fly.” The symbols “ —< ” and “ ← ” denote meta-relations between sets of literals, and have no interaction with language symbols. In particular, there is no contraposition for program rules. In our examples, we will follow standard typographic conventions of Logic Programming extending them conveniently for representing DeLP rules. Program rules have a non-empty body. Observe that a strict rule with an empty body can be represented as a fact, but a defeasible rule with an empty body is not a fact. For example: “a —< ” would express that “there are (defeasible) reasons to believe in a”, and since this information is defeasible, then a could not be a fact. A defeasible rule with an empty body was introduced in several approaches and is called a presumption (Nute, 1988; Garcı́a et al., 1998; Garcı́a, 2000). For technical reasons we will develop the core of DeLP without considering presumptions, and they will be added as an extension to DeLP (see Section 6). Defeasible rules are not default rules. In a default rule ϕ : ψ1 . . . , ψn /χ the justification part ψ1 . . . , ψn is a consistency check that contributes in the control of the applicability of the rule. A defeasible rule represents a weak connection between head and body of the rule. The effect of a defeasible rule comes from a dialectical analysis, made by the inference mechanism, which involves the consideration of arguments and counter-arguments where that rule is included. Therefore, in a defeasible rule there is no need to encode any particular check. The advantage of this is notorious when the beliefs supported by knowledge represented by default rules change. The changes will lead to re-representing the new beliefs by modifying the justification part of those rules, which could lead to a re-representation cascade effect, see (Brewka & Eiter, 2000). Changes in the knowledge represented by defeasible rules, in general, is reflected with the sole addition of new defeasible rules to the representation. Therefore, if the knowledge base changes frequently, defeasible rules are a better alternative. In Example 8.1, we will introduce a more illustrative example comparing defaults and defeasible rules. The interested reader is referred to (Nute, 1994) where a comparison with other nonmonotonic theories is given. Definition 2.4 (Defeasible Logic Program) A Defeasible Logic Program P, abbreviated de.l.p., is a possibly infinite set of facts, strict rules and defeasible rules. In a program P, we will distinguish the subset Π of facts and strict rules, and the subset ∆ of defeasible rules. When required, we will denote P as (Π, ∆). Defeasible Logic Programming An Argumentative Approach 5 Strict and defeasible rules are ground. However, following the usual convention (Lifschitz, 1996), some examples will use “schematic rules” with variables. Given a “schematic rule” R, Ground (R) stands for the set of all ground instances of R. Given a de.l.p. P with schematic rules, we define (Lifschitz, 1996): Ground (P) = [ Ground (R) R∈P In order to distinguish variables from other elements of a schematic rule, we will denote variables with an initial uppercase letter. In DeLP there are four possible answers for a query: yes, no, undecided, or unknown (see Definition 5.3). Next, we will introduce some examples of defeasible logic programs, anticipating what will be the results of using our approach. In the following sections we will explain how the mentioned results are obtained. Example 2.1 Here follows the de.l.p. P 2.1 =(Π, ∆), where sets Π and ∆ have been separated for convenience of the presentation:   bird (X ) ← chicken(X )             flies(X ) —< bird (X ) bird (X ) ← penguin(X )             ∼flies(X ) —< chicken(X ) ∼flies(X ) ← penguin(X ) ∆= Π=    flies(X ) —< chicken(X ), scared (X )  chicken(tina)          penguin(tweety)  —< flies(X )   in trees(X ) nests       scared (tina) As will show in the following sections, in DeLP the answer for flies(tina) will be yes, whereas the answer for ∼flies(tina) will be no. The answer for flies(tweety) will be no, whereas the answer for ∼flies(tweety) will be yes. Example 2.2 Consider the following de.l.p. adapted from (Prakken & Vreeswijk, 2000):   has a gun(X ) —< lives in chicago(X )        —< lives in chicago(X ), pacifist (X )    ∼has a gun(X )         in chicago(nixon) lives   — < P 2.2 = pacifist (X ) quaker (X )      ∼pacifist (X ) —< republican(X )          quaker (nixon)       republican(nixon) As we will show in Example 5.4, the expected result will be obtained: the answer for pacifist (nixon) will be undecided, and the answer for ∼pacifist (nixon) will be also undecided. In a case like this, other approaches have the problem of the propagation of that “indecision”, and the answer for has a gun(nixon) is also undecided. However, this result will not happen in DeLP (see Example 5.5). Example 2.3 Consider the following de.l.p. P 2.3 = (Π, ∆): 6 Alejandro J. Garcı́a     Π=    and Guillermo R. Simari  h ← a    ∼h ← c b    d   a —< b ∆= c —< d In several approaches the literal a is accepted as proved from P 2.3 because there is no rule with “∼a” in its head, so no rule that contradicts “a —< b” can be found. However, observe that from literals “a” and “c” and the strict rules “h ← a” and “∼h ← c” two contradictory literals can be derived. In DeLP, this kind of contradiction through strict rules will be discovered and the answer for the literals “a” and “c” will be undecided. See section 8 for further details. Example 2.4 The following de.l.p. represents some information in the stock market domain:   buy stock (T ) —< good price(T )        —< good price(T ), risky company(T )    stock (T ) ∼buy       — <   risky company(T ) in fusion(T , Y )       — < closing(T ) risky company(T ) P 2.4 =  ∼risky company(T ) —< in fusion(T , Y ), strong(Y )          good price(acme)         fusion(acme, steel ) in       strong(steel ) As we will explain next, here the answer for buy stock (acme) will be yes. We will define next what constitute a defeasible derivation. In the following sections a proof procedure based on a defeasible argumentation formalism will be defined. Definition 2.5 (Defeasible Derivation) Let P= (Π, ∆) be a de.l.p. and L a ground literal. A defeasible derivation of L from P, denoted P |∼ L, consists of a finite sequence L1 , L2 , . . . , Ln = L of ground literals, and each literal Li is in the sequence because: (a) Li is a fact in Π, or (b) there exists a rule Ri in P (strict or defeasible) with head Li and body B1 , B2 , . . . , Bk and every literal of the body is an element Lj of the sequence appearing before Li (j < i.) Given a de.l.p. P, a derivation for a literal L from P is called ‘defeasible’, because as we will show next, there may exist information in contradiction with L that will prevent the acceptance of L as a valid conclusion. If the program P is expressed using schematic rules, then Ground (P) is used for obtaining defeasible derivations. Example 2.5 Defeasible Logic Programming An Argumentative Approach 7 Considering Example 2.1, the sequence: chicken(tina), bird (tina), flies(tina), is a defeasible derivation for the literal “flies(tina)”, obtained from the following set of rules in P 2.1 : { (bird (tina) ← chicken(tina)), (flies(tina) —< bird (tina)) }1 . Observe that from P 2.1 , there exists also a defeasible derivation for ∼flies(tina) from the sequence: chicken(tina), ∼flies(tina). Observation 2.1 Defeasible derivation is monotonic, i. e., let P be a de.l.p. and R be a set of program rules, if h has a defeasible derivation from P, then h has a defeasible derivation from P ∪ R. Observation 2.2 If a program P has no facts, then no defeasible derivation can be obtained. Given a literal L, there could be more than one defeasible derivation for L. Observe also, that a defeasible derivation could use both defeasible and strict rules, or it could use only one kind of rule. In what follows, sometimes we will call strict derivation, a derivation where only strict rules, and facts, are used. For instance, the literal “∼flies(tweety)” has a strict derivation from P 2.1 . The formal definition follows. Definition 2.6 (Strict Derivation) Let P be a de.l.p. and h a literal with a defeasible derivation L1 , L2 , . . . , Ln = h. We will say that h has a strict derivation from P, denoted P ⊢ L, if either h is a fact or all the rules used for obtaining the sequence L1 , L2 , . . . , Ln are strict rules. The symbol “ ” will be used to denote the complement of a literal with respect to strong negation, i. e. p is ∼p, and ∼p is p. Two literals are contradictory if they are complementary. Thus, flies(tina) and ∼flies(tina) are contradictory literals. Definition 2.7 (Contradictory set of rules) A set of rules is contradictory if and only if, there exists a defeasible derivation for a pair of complementary literals from this set. Observe that the de.l.p. of Example 2.1 is a contradictory set of rules because both flies(tina) and ∼flies(tina) can be defeasibly derived, (see Example 2.5.) The same happens to the de.l.p. of Example 2.4 for buy stock (acme) and ∼buy stock (acme). The use of strong negation in program rules enriches language expressiveness, and also allows to represent contradictory knowledge. In general, a useful defeasible logic program will be a contradictory set of rules. However, the set Π of facts and strict rules in a defeasible logic program P, which is used to represent non-defeasible information, must posses certain internal coherence. Observation 2.3 1 When required, parenthesis will be used for distinguishing one rule from another. 8 Alejandro J. Garcı́a and Guillermo R. Simari Note that the set Π of a de.l.p. corresponds to a logic program with strong negation. If a contradictory set Π is used in a de.l.p. then the answer would be Lit , as in Extended Logic Programming. Therefore, we will have the convention that in a de.l.p. P the set Π is non-contradictory. Although the set Π is assumed to be non-contradictory, P itself (i. e., Π ∪ ∆), could be contradictory. It is only in this form that a de.l.p. may contain contradictory information. Observe that the set Π of P 2.1 is non-contradictory, whereas the whole program P 2.1 is contradictory: the literals “flies(tina)” and “∼flies(tina)” have both a defeasible derivation from P 2.1 . In a case like this, when contradictory goals could be defeasibly derived, a formalism for deciding between them is needed. DeLP uses a defeasible argumentation formalism in order to perform such a task. Strong negation was introduced in Extended Logic Programming (Gelfond & Lifschitz, 1990). In this formalism, when a pair of contradictory literals is derived, the set Lit of all literals is derived without considering any further analysis. Suppose that we regard Example 2.1 above as an Extended Logic Program, by considering all its rules as strict rules. This program would be an Extended Logic Program without “not”, and clearly, from that program a pair of complementary literals (“flies(tina)” and “∼flies(tina)”) could be derived. Therefore, the answer set calculated according to (Gelfond & Lifschitz, 1990) is Lit . For deciding between contradictory goals, other formalism use a priority relation among program rules that need to be included in the program (Nute, 1994; Antoniou et al., 2000a; Antoniou et al., 1998; Prakken & Sartor, 1997; Kakas et al., 1994; Dimopoulos & Kakas, 1995) (see Section 8 below.) In DeLP, no priority relation is needed for deciding between contradictory goals. This characteristic maintains the declarative nature of the knowledge represented in DeLP, i. e. the interaction among the pieces of knowledge is not expressed in the language in any way but as a result of the influence of the whole corpus of the agent’s knowledge. For that reason, the burden of the defeasible inference falls upon the language processor, i. e. our system, which figures out the interactions, instead of on the knowledge encoder, i. e., the programmer. The programmer does not have to evoke the behavior of the representation in order to add procedural control to the defeasible rules. However, as it will be shown in Section 3.2.2, priorities between defeasible rules could be used in DeLP as an alternative comparison approach. 3 Defeasible Argumentation In this section, a defeasible argumentation formalism will be introduced. This formalism evolved from (Simari & Loui, 1992; Simari et al., 1994b; Garcı́a et al., 1998) into the DeLP framework. The central notion of the formalism is the notion of argument. Informally, an argument is a minimal and non-contradictory set of rules used to derive a conclusion. In DeLP, answers to queries will be supported by an argument. Thus, although a de.l.p. could be contradictory, answers to queries will be supported by a non-contradictory set of rules. The formal definition follows. Defeasible Logic Programming An Argumentative Approach 9 Definition 3.1 (Argument Structure) Let h be a literal, and P=(Π, ∆) a de.l.p.. We say that hA, hi is an argument structure for h, if A is a set of defeasible rules of ∆, such that: 1. there exists a defeasible derivation for h from Π ∪ A, 2. the set Π ∪ A is non-contradictory, and 3. A is minimal: there is no proper subset A′ of A such that A′ satisfies conditions (1) and (2). In short, an argument structure hA, hi, or simply an argument A for h, is a minimal non-contradictory set of defeasible rules, obtained from a defeasible derivation for a given literal h. The literal h will also be called the ‘conclusion’ supported by A. This notion was adapted from the argument structure definition given in (Simari & Loui, 1992). Note that strict rules are not part of an argument structure. Example 3.1 Consider the defeasible logic program of Example 2.1. The literal “∼flies(tina)” is supported by the following argument structure: h{∼flies(tina) —< chicken(tina)}, ∼flies(tina)i whereas the literal “flies(tina)” has two argument structures that support it: h{flies(tina) —< bird (tina)}, flies(tina)i h{flies(tina) —< chicken(tina), scared (tina)}, flies(tina)i Observe that in DeLP the construction of argument structures is nonmonotonic. That is, adding facts or strict rules to the program may cause some argument structures to be invalidated because they become contradictory. For example, consider the program P=(Π, ∆), where Π={a}, and ∆={h —< a}. From P there is an argument structure hA, hi=h{h —< a}, hi. However, from Π ∪ {∼h}, hA, hi is not longer an argument structure because the set Π ∪ {∼h} ∪ {h —< a} is a contradictory set. In other approaches to defeasible argumentation, argument construction is monotonic, and contradictory arguments are considered ‘self-defeating’ arguments, that is, arguments that defeat themselves. Condition 2 of the previous definition prevents the occurrence of self-defeating argument structures. We will come back to this issue in Section 4.1. Observation 3.1 If there exists a strict derivation for q, then there exists a unique argument structure for q: h∅, qi. This is so because there exists a defeasible derivation for q from Π ∪ ∅, Π ∪ ∅ is not contradictory by Observation 2.3, and there is no subset of ∅. The argument structure h∅, qi is unique because by condition 3 of Definition 3.1 (minimality) no superset of ∅ can be an argument structure. For example, the literal “∼flies(tweety)” has a strict derivation from P 2.1 , so h∅, ∼flies(tweety)i is its the unique argument structure. 10 Alejandro J. Garcı́a and Guillermo R. Simari It is interesting to note, that if q has a strict derivation, then q has a derivation from Π; hence, q has a defeasible derivation from Π ∪ A, for any set A of defeasible rules (see Observation 2.1.) Therefore, if there exists a defeasible derivation for q from Π ∪ A, for some set A, then Π ∪ A will be contradictory, and no argument structure for q could be obtained, because condition 2 of the definition of argument structure will not be satisfied. Definition 3.2 (Sub-argument structure) An argument structure hB, qi is a sub-argument structure of hA, hi if B ⊆ A. It is important to note that the union of arguments is not always an argument. That is, given two argument structures hA, hi and hB, qi, the set A ∪ B could be improper for being used as an argument, because A ∪ B could be not minimal or A ∪ B ∪ Π could be contradictory (see the following example.) Example 3.2 Consider the de.l.p.:   b —< c c  h1 ← b b —< d d h2 ← b  h ← h1 , h2  p ← h1  ∼p ← h2 The following argument structures can be obtained: hA1 , h1 i = h{b —< c}, h1 i and hA2 , h2 i = h{b —< d }, h2 i. Consider now the set A = A1 ∪ A2 = {(b —< c), (b —< d )}. From Π ∪ A there exists a defeasible derivation for h, however, hA, hi is not an argument structure because Π ∪ A is contradictory since p and ∼p have a defeasible derivation from Π ∪ A. Observe also that A is not the minimal set of defeasible rules that provides an argument structure for h because A1 is a proper subset of A, and hA, hi is an argument structure. As shown in Example 3.1, it is possible to have argument structures for contradictory literals. Thus, when considering a literal q, supported by argument A, arguments that contradict A could exist. In that situation it is clear that it would be interesting to have a preference criterion for deciding among arguments and their counter-arguments. This issue will be explored in the next section, but first, we will introduce a graphical representation for arguments that will be used in what follows. Arguments will be depicted as triangles. The upper vertex of the triangle will be labeled with the argument’s conclusion, and the set of defeasible rules in the argument will be associated with the triangle itself. Sub-arguments will be represented as smaller triangles contained in the triangle which corresponds to the main argument at issue. Figure 1 shows the graphical representation of an argument hA, hi, and one of its sub-arguments hB, qi. 3.1 Rebuttals or Counter-Arguments In DeLP, answers to queries will be supported by arguments. However, an argument may be defeated by other arguments. Informally, a query q will succeed if the Defeasible Logic Programming An Argumentative Approach 11 h ✂✂❇❇ ✂ q❇ ✂ ❇ ❇ ✂ ✂ ❇ ✂ ✂B ❇ ❇ ✂ ❇ A Fig. 1. An argument hA, hi, and a sub-argument hB, qi supporting argument for it is not defeated. In order to establish whether A is a non-defeated argument, argument rebuttals or counter-arguments that could be defeaters for A are considered, i. e., counter-arguments that for some criterion, are preferred to A. Since counter-arguments are arguments, there may exist defeaters for them, and so on. That suggests a dialectical analysis, that will be formally introduced in the next sections. Here, the notion of rebuttal or counter-argument is introduced. Definition 3.3 (Disagreement ) Let P=Π ∪ ∆ be a de.l.p.. We say that two literals h and h1 disagree, if and only if the set Π ∪ {h, h1 } is contradictory. Two complementary literals p and ∼p trivially disagree since for any set Π, {p, ∼p} ∪ Π is contradictory. Furthermore, two literals that are not complementary can also disagree. For example given Π = {(∼h ← b), (h ← a)}, the literals a and b disagree because Π ∪ {a, b} is contradictory. We will show below how this notion of disagreement will allow us to find direct and indirect conflicts between arguments. Definition 3.4 (Counter-argument ) We say that hA1 , h1 i counter-argues, rebutts, or attacks hA2 , h2 i at literal h, if and only if there exists a sub-argument hA, hi of hA2 , h2 i such that h and h1 disagree. If hA1 , h1 i counter-argues hA2 , h2 i at literal h, then h is called a counter-argument point, and the sub-argument hA, hi is called the disagreement sub-argument. Figure 2-(left) gives a graphical representation of an argument and one of its counterarguments in the conditions of Definition 3.4. Example 3.3 Continuing with Example 3.1, h{∼flies(tina) —< chicken(tina)}, ∼flies(tina)i is a counter-argument for h{flies(tina) —< bird (tina)}, flies(tina)i and vice versa. Note that in this particular case, the disagreement sub-argument is the argument itself. Consider now the argument structure hA4 , nests in trees(tina)i, where   nests in trees(tina) —< flies(tina) A4 = flies(tina) —< bird (tina) The argument structure h{∼flies(tina) —< chicken(tina)}, ∼flies(tina)i is a counterargument for hA4 , nests in trees(tina)i attacking an inner point, i. e., the counterargument point is flies(tina). 12 Alejandro J. Garcı́a and Guillermo R. Simari As shown in the previous Example, a counter-argument hA1 , h1 i for hA2 , h2 i, can attack directly the conclusion h2 of hA2 , h2 i, or can attack an inner point h of hA2 , h2 i. Hence, we will distinguish between a “direct” attack and an “indirect” attack. Figure 2 shows both cases. h2 h1 ✏✏✂❇ ✏✏ ✂✂❇❇ ✂❇ ✏ ✏ ✂h ✏ ✂ ❇ ❇ ✏ ✏ ✂ ❇ ❇ ✂ ❇ ✂ ✂ ❇ ✂ ❇ ✂ ✂A ❇ ❇ ✂ ❇ ✂ ✂ ❇ ❇ A2 A1 ✂ ✂ ✂ ✂ h4 h3 ✂✂❇❇ ✂ ❇ ✂✂❇❇ ✂ ❇ A4 ❇ ❇ ❇ ❇ ✂ ✂ ✂ ✂ ❇ ❇ ❇ ❇ A3 Fig. 2. Indirect attack (left) and direct attack (right) It is interesting to remark the following property of the counter-argument notion. If hA3 , h3 i is a counter-argument for hA4 , h4 i and the counter-argument point is h4 (direct attack) then hA4 , h4 i is also a counter-argument for hA3 , h3 i (see Figure 2right.) In the case that hA1 , h1 i is a counter-argument for hA2 , h2 i attacking an inner point h, with hA, hi as the disagreement sub-argument, then hA, hi is a counterargument for hA1 , h1 i (see Figure 2-left.) In the example above, the argument and its counter-argument have complementary conclusions (flies(tina) and ∼flies(tina).) In the following example we show an argument and a counter-argument supporting literals that are not complementary. The disagreement arises through Π. Example 3.4 Consider again P 2.3 =(Π, ∆), Π= { (h ← a), b, d , (∼h ← c) } and ∆= { (a —< b), (c —< d )}. From this program h{a —< b}, ai is a counter-argument for h{c —< d }, ci, because literals a and c disagree. In Observation 3.1, we have shown that any literal q that has a strict derivation is supported by h∅, qi. The following proposition states that for any de.l.p. P, and any literal q, an argument structure h∅, qi will not have any counter-arguments. In other words, strictly derived literals can not be rebutted. Proposition 3.1 There exists no possible counter-argument for an argument structure h∅, qi. Proof: Suppose that there exists a counter-argument hA, hi for h∅, qi, then, A ∪ ∅ ∪ Π should be a contradictory set, and therefore, A ∪ Π should be a contradictory set. However, if A ∪ Π is a contradictory, then hA, hi is not an argument structure, because condition 2 of the definition of argument would not hold. While the proposition above shows that an argument structure like h∅, qi has no counter-arguments, the following proposition states that h∅, qi can never be used as a counter-argument for any other argument structure hA, hi. Defeasible Logic Programming An Argumentative Approach 13 Proposition 3.2 The argument structure h∅, qi cannot be a counter-argument for any argument structure hA, hi. Proof: Suppose that there exists hA, hi, such that h∅, qi is a counter-argument for hA, hi. Then, A ∪ ∅ ∪ Π is a contradictory set, and then A ∪ Π is a contradictory set. However, if this is so, the set A could not be an argument, because condition 2 of the definition of argument would not hold. Given an argument structure hA, hi, there could be several counter-arguments attacking different points in A, or different counter-arguments attacking the same point in A. As we will show next, in order to verify whether an argument is nondefeated, all of its associated counter-arguments B 1 , B 2 , . . ., B k will be examined, each of them being a (defeasible) potential reason for rejecting A. If any B i is (somehow) “better” than, or unrelated to, A, then B i is a candidate for defeating A. However, if the argument A is “better” than one B i then B i will not be taken in consideration as a defeater A. This informal discussion shows the convenience of introducing a preference order among arguments. 3.2 Comparing Arguments The definition of a formal criterion for comparing arguments is a central problem in defeasible argumentation. Existing formalisms have adopted different solutions. Abstract argumentation systems usually assume an ordering in the set of all possible arguments (Dung, 1993b; Vreeswijk, 1997; Kowalski & Toni, 1996; Bondarenko et al., 1997). For instance, in Dung’s approach, an argumentation framework is a pair (Args, attack ), where Args is the set of all possible arguments and attack is a binary relation on Args. If (A, B ) ∈ attack then argument A attacks argument B . In other formalisms, explicit priorities among program rules are given. Thus, the conflict between two rules can be solved. This approach is used in d-Prolog (Nute, 1988), Defeasible Logic (Nute, 1992), extensions of Defeasible Logic (Antoniou et al., 2000a; Antoniou et al., 1998), and logic programming without negation as failure (Kakas et al., 1994; Dimopoulos & Kakas, 1995). In (Prakken & Sartor, 1997) it is also possible to reason (defeasibly) about priorities among rules. An alternative is to use the specificity criterion (Poole, 1985), and no explicit order among rules or arguments need to be given. Finally, other formalisms use no comparison criterion (Gelfond & Lifschitz, 1990). Next, we will introduce two criteria for comparing arguments. The first one based on specificity, and the second one based on priorities among program rules. 3.2.1 Generalized Specificity We will formally define a particular criterion called generalized specificity which allows to discriminate between two conflicting arguments. Intuitively, this notion of specificity favors two aspects in an argument: it prefers an argument (1) with 14 Alejandro J. Garcı́a and Guillermo R. Simari greater information content or (2) with less use of rules (more direct.) In other words, an argument will be deemed better than another if it is more precise or more concise (see the Example 3.5 below.) The next definition characterizes the specificity criterion, defined first in (Poole, 1985) and extended later to be used in defeasible argumentation (Simari & Loui, 1992; Simari et al., 1994b). Here, it is adapted to fit in the DeLP framework. As stated before, P |∼ h means that h has a defeasible derivation from P, and P ⊢ h means that h has a strict derivation from P. Definition 3.5 (Specificity) Let P=(Π, ∆) be a de.l.p., and let ΠG be the set of all strict rules from Π (without including facts.) Let F be the set of all literals that have a defeasible derivation from P (F will be considered as a set of facts.) Let hA1 , h1 i and hA2 , h2 i be two argument structures obtained from P. hA1 , h1 i is strictly more specific than hA2 , h2 i (denoted hA1 , h1 i ≻ hA2 , h2 i) if the following conditions hold: 1. For all H ⊆ F : if ΠG ∪ H ∪ A1 |∼ h1 and ΠG ∪ H 6⊢ h1 , then ΠG ∪ H ∪ A2 |∼ h2 , and 2. there exists H ′ ⊆ F such that ΠG ∪ H ′ ∪ A2 |∼ h2 and ΠG ∪ H ′ 6 ⊢ h2 , and ΠG ∪ H ′ ∪ A1 6|∼ h1 As mentioned before, it is not possible to have a defeasible derivation for a literal from a set of rules without facts. Therefore, from the set ΠG ∪ A1 it is not possible to have a defeasible derivation for h1 . However, from ΠG ∪ H ∪ A1 it could be possible because H is a set of literals (facts.) Thus, when ΠG ∪ H ∪ A1 |∼ h1 holds, we say that the set H activates hA1 , h1 i, or H is an activation set of hA1 , h1 i. Example 3.5 Consider the program P 2.1 of Example 2.1, the argument structure hA1 , h1 i= h{∼flies(tina) —< chicken(tina)}, ∼flies(tina)i is strictly more specific than hA2 , h2 i= h{flies(tina) —< bird (tina)}, flies(tina)i because hA1 , h1 i is ‘more direct’ than hA2 , h2 i (observe that hA2 , h2 i uses the strict rule bird (tina) ← chicken(tina).) In this example every activation set H of hA1 , h1 i also activates hA2 , h2 i, but the set H ′ = {bird (tina)} activates hA2 , h2 i but does not activate hA1 , h1 i. Using the same program, the argument structure hA3 , h3 i= h{flies(tina) —< chicken(tina), scared (tina)}, flies(tina)i will be preferred to hA1 , h1 i, because hA3 , h3 i is based in more information (the literals chicken(tina) and scared (tina)) than hA1 , h1 i. Observe that every activation set H of hA3 , h3 i contains the literals chicken(tina) and scared (tina), thus H actives hA1 , h1 i. However, the set H ′ = {chicken(tina)} activates hA1 , h1 i, and H ′ does not activate hA3 , h3 i. Therefore, hA3 , h3 i is strictly more specific than hA1 , h1 i. Definition 3.6 (Equi-Specificity) Two arguments hA1 , h1 i and hA2 , h2 i are equi-specific, denoted hA1 , h1 i ≡ hA2 , h2 i, iff A1 = A2 , and the literal h2 has a strict derivation from Π ∪ {h1 }, and the literal h1 has a strict derivation from Π ∪ {h2 }. Defeasible Logic Programming An Argumentative Approach 15 Lemma 3.1 Equi-specificity is an equivalence relation. Proof: Trivial by definition. The following proposition shows that strictly derived literals are ‘equi-specific’. Proposition 3.3 If A1 = ∅ and A2 = ∅, then hA1 , h1 i ≡ hA2 , h2 i Proof: If A1 and A2 are empty, then A1 = A2 , Π ⊢ h1 and Π ⊢ h2 . Hence, Π∪{h1 } ⊢ h2 and Π∪{h2 } ⊢ h1 . Observe also that since Π is not contradictory, then Π∪{h1 , h2 } is not contradictory. Proposition 3.4 If two argument structures hA1 , h1 i and hA2 , h2 i are equi-specific then h1 and h2 cannot disagree. Proof: If hA1 , h1 i ≡ hA2 , h2 i, then A1 = A2 , and Π ∪ {h1 } ⊢ h2 , and Π ∪ {h2 } ⊢ h1 . Suppose that h1 and h2 disagree, then the set Π ∪ {h1 , h2 } is contradictory. Since Π ∪ {h1 } ⊢ h2 , then Π ∪ {h1 } is contradictory, and therefore, hA1 , h1 i cannot be an argument structure because it does not satisfy condition 2 of argument definition. 3.2.2 Argument comparison using rule’s priorities Some formalisms define explicit priorities among rules and use these priorities for deciding between competing conclusions. The use of these priorities is usually embedded in the derivation mechanism and competing rules are compared individually during the derivation process. In such formalisms the derivation notion is bound to one single comparison criterion. In DeLP in order to decide between competing conclusions the arguments that support the conclusions are compared. Thus, the comparison criterion is independent of the derivation process, and could be replaced in a modular way. Next, we will introduce a particular comparison criterion which uses a form of ordering the rules by their priority as an example. We will show how a comparison criterion between arguments based on rule priorities can be formulated. We will assume that explicit priorities among defeasible rules are given with the program. Since strict rules represent sound information, there will be no priorities among them. Priorities will be allowed only between two defeasible rules. As showed in Proposition 3.1, a literal that has a strict derivation has no counter-argument. Therefore, implicitly, a strict derivation will be preferred over other arguments that use defeasible rules. Many comparison criteria could be defined. The priority based criterion defined below is but one example. Definition 3.7 Let P be de.l.p. and “>” a preference relation explicitly defined among defeasible rules. Given two argument structures hA1 , h1 i and hA2 , h2 i, the argument hA1 , h1 i will be preferred over hA2 , h2 i if: 16 Alejandro J. Garcı́a and Guillermo R. Simari 1. there exists at least one rule ra ∈ A1 , and one rule rb ∈ A2 , such that ra > rb , 2. and there is no rb′ ∈ A2 , and ra′ ∈ A1 , such that rb′ > ra′ . Example 3.6 Consider the following de.l.p.  buy stock (T ) —< good price(T )     ∼buy stock (T ) —< risky company(T )  P 3.6 = risky company(T ) —< in fusion(T , Y )    good price(acme)   in fusion(acme, steel ) And the priority: buy stock (T ) —< good price(T ) <            ∼buy stock (T ) —< risky company(T ) Using the criterion of Definition 3.7, the argument structure    ∼buy stock (acme) —< risky company(acme) , ∼buy stock (acme) risky company(acme) —< in fusion(acme, steel ) will be preferred over h{buy stock (acme) —< good price(acme)}, buy stock (acme)i A more sophisticated criterion could be obtained combining the two defined above. For example, considering first generalized specificity, and if no argument is preferred, then use the existing priorities. 4 Defeaters and Argumentation Lines Given an argument structure hA1 , h1 i, and a counter-argument hA2 , h2 i for hA1 , h1 i, these two arguments can be compared in order to decide which one prevails. Namely, if the counter-argument hA2 , h2 i is better than hA1 , h1 i w.r.t the comparison criterion used, then hA2 , h2 i will be called a proper defeater for A1 . If neither argument is better, nor worse, than the other, a blocking situation occurs, and we will say that hA2 , h2 i is a blocking defeater for hA1 , h1 i. If hA1 , h1 i is better than hA2 , h2 i, then hA2 , h2 i will not be considered as a defeater for hA1 , h1 i. Although a preference criterion is required for comparing arguments, the notion of defeating argument can be formulated independently of the particular argumentdiscriminating criterion that is being used. From now on, we will abstract away from the comparison criterion, assuming there exists a comparison criterion among arguments that we will denote “≻”. For the examples in the rest of the paper we will assume that “≻” means “strictly more specific” as defined above. Definition 4.1 (Proper Defeater ) Let hA1 , h1 i and hA2 , h2 i be two argument structures. hA1 , h1 i is a proper defeater for hA2 , h2 i at literal h, if and only if there exists a sub-argument hA, hi of hA2 , h2 i such that hA1 , h1 i counter-argues hA2 , h2 i at h, and hA1 , h1 i ≻ hA, hi. Observe that in the previous definition, the argument structure hA1 , h1 i is compared with the disagreement subargument hA, hi. Defeasible Logic Programming An Argumentative Approach 17 Example 4.1 In Example 3.5, since hA1 , h1 i is a counter argument for hA2 , h2 i, and hA1 , h1 i≻ hA2 , h2 i, then hA1 , h1 i is a proper defeater for hA2 , h2 i. Observe that hA3 , h3 i is a proper defeater for hA1 , h1 i. Definition 4.2 (Blocking Defeater ) Let hA1 , h1 i and hA2 , h2 i be two argument structures. hA1 , h1 i is a blocking defeater for hA2 , h2 i at literal h, if and only if there exists a sub-argument hA, hi of hA2 , h2 i such that hA1 , h1 i counter-argues hA2 , h2 i at h, and hA1 , h1 i is unrelated by the preference order to hA, hi, i. e., hA1 , h1 i ≻ 6 hA, hi, and hA, hi ≻ 6 hA1 , h1 i. Example 4.2 The Nixon Diamond provides the proverbial example of blocking defeaters. Consider the de.l.p. P 2.2 of Example 2.2. From P 2.2 , the following argument structures can be obtained: hA1 , h1 i= h{pacifist (nixon) —< quaker (nixon)}, pacifist (nixon)i and hA2 , h2 i= h{∼pacifist (nixon) —< republican(nixon)}, ∼pacifist (nixon)i. The argument hA2 , h2 i is a blocking defeater for hA1 , h1 i, and vice versa. As it will be shown below, in DeLP the answer for the query ‘pacifist (nixon)’ will be undecided. Definition 4.3 (Defeater ) The argument structure hA1 , h1 i is a defeater for hA2 , h2 i, if and only if either: 1. hA1 , h1 i is a proper defeater for hA2 , h2 i; or 2. hA1 , h1 i is a blocking defeater for hA2 , h2 i. Thus, a defeater for an argument structure can be identified as proper or blocking. As we will show below, this distinction will be considered by the warrant procedure. It is interesting to note, that most argumentation formalisms make no distinction between proper or blocking defeaters, and some of them only consider proper defeaters. The following proposition shows that during the argumentation process it is not possible to attack a subargument hA, hi with an argument hA1 , h1 i that is equi-specific to hA, hi. Proposition 4.1 If hA1 , h1 i is a defeater (proper or blocking) for hA2 , h2 i, and hA, hi is the corresponding disagreement subargument, then it cannot be the case that hA1 , h1 i ≡ hA, hi. Proof: Proposition 3.4 shows that if hA1 , h1 i ≡ hA, hi, then h1 and h could not disagree. Thus, hA1 , h1 i cannot be a counter-argument for hA2 , h2 i at h. In order to establish whether an argument structure hA0 , h0 i is non-defeated, all defeaters for hA0 , h0 i have to be considered. Suppose that hA1 , h1 i is a defeater for hA0 , h0 i, since hA1 , h1 i is an argument structure, then defeaters for hA1 , h1 i may exist, and so on. In this manner, a sequence of argument structures is created, where each element of the sequence defeats its predecessor. We formalize this notion next. 18 Alejandro J. Garcı́a and Guillermo R. Simari Definition 4.4 (Argumentation Line) Let P a de.l.p. and hA0 , h0 i an argument structure obtained from P. An argumentation line for hA0 , h0 i is a sequence of argument structures from P, denoted Λ = [hA0 , h0 i, hA1 , h1 i, hA2 , h2 i hA3 , h3 i, . . .], where each element of the sequence hAi , hi i, i > 0, is a defeater of its predecessor hAi−1 , hi−1 i. h0 h1 h2 h3 h4 ✟ ✟ ✟ ✟ ✂❇ ✟✟ ✂❇ ✟✟ ✂❇ ✟✟ ✂❇ ✟✟ ✂❇ ✂ ❇ ✂ ❇✟✟ ✂ ❇✟✟ ✂ ❇✟✟ ✂ ❇✟✟ ✂ ❇ ✂ ✟❇ ✂ ✟❇ ✂ ✟❇ ✂ ✟❇ ✂ ✂✂❇❇ ❇ ✂ ✂✂❇❇ ❇ ✂ ✂✂❇❇ ❇ ✂ ✂✂❇❇ ❇ ✂ ✂✂❇❇ ❇ ✂ ✂ ✂ ✂ ❇ ❇ ❇ ❇ ✂ ❇ ✂ ✂ ✂ ✂ ❇ ❇ ❇ ❇ ✂ ❇ A0 A1 A2 A3 A4 Fig. 3. Argumentation line As defined above, an argumentation line could result in an infinite sequence of arguments. However, in the following section we will impose some restrictions over the argumentation lines and only finite sequences will be allowed. In each argumentation line Λ = [hA0 , h0 i, hA1 , h1 i, hA2 , h2 i hA3 , h3 i, . . .], the argument hA0 , h0 i is supporting the main query h0 , and every argument hAi , hi i defeats its predecessor hAi−1 , hi−1 i. Then, hA0 , h0 i becomes a supporting argument for h0 , hA1 , h1 i an interfering argument, hA2 , h2 i a supporting argument, hA3 , h3 i an interfering one, and so on. Thus, an argumentation line can be split in two disjoint sets: ΛS of supporting arguments, and ΛI of interfering arguments. Definition 4.5 (Supporting and Interfering argument structures) Let Λ = [hA0 , h0 i, hA1 , h1 i, hA2 , h2 i hA3 , h3 i, . . .] an argumentation line, we define the set of supporting argument structures ΛS = { hA0 , h0 i, hA2 , h2 i, hA4 , h4 i, . . . }, and the set of interfering argument structures ΛI = {hA1 , h1 i, hA3 , h3 i, . . .}. Given an argument structure hA0 , h0 i, there can be many defeaters for hA0 , h0 i, and each of them will generate a different argumentation line. Observe also, that in these argumentation lines any of the arguments could have more than one defeater generating more argumentation lines starting with hA0 , h0 i. Example 4.3 Consider a program P where hA1 , h1 i defeats hA0 , h0 i, and hA2 , h2 i also defeats hA0 , h0 i. Up to this point there are two argumentation lines. Now suppose that hA3 , h3 i defeats hA1 , h1 i, and that both hA4 , h4 i and hA5 , h5 i defeat hA2 , h2 i, then there are several argumentation lines starting with hA0 , h0 i, here we show three of them: Λ1 = [hA0 , h0 i, hA1 , h1 i, hA3 , h3 i] Λ2 = [hA0 , h0 i, hA2 , h2 i, hA4 , h4 i] Λ3 = [hA0 , h0 i, hA2 , h2 i, hA5 , h5 i] Therefore, a process that considers all possible argumentation lines is needed. Before defining such a process, we will introduce some restrictions over argumentation lines. Defeasible Logic Programming An Argumentative Approach 19 4.1 Acceptable Argumentation Lines In this section we will show several undesirable situations that may arise in an argumentation line leading to an infinite sequence of defeaters. We will then impose certain constraints over the argumentation lines in order to avoid these problematic situations. Some of these situations were reported first in (Simari et al., 1994b). In the related literature, an argument structure hA, hi is said to be “self-defeating” if hA, hi is a defeater for itself. If hA, hi is a self-defeating argument structure then an argumentation line starting with hA, hi will be infinite (see Figure 4.) h h h h ✟ ✟ ✟ ✂❇ ✟✟ ✂❇ ✟✟ ✂❇ ✟✟ ✂❇ ✂ ❇ ✂ ❇✟✟ ✂ ❇✟✟ ✂ ❇✟✟ ✂ ❇ ✂ ✟❇ ✂ ✟❇ ✂ ✟❇ ✂ ✂✂❇❇ ❇ ✂ ✂✂❇❇ ❇ ✂ ✂✂❇❇ ❇ ✂ ✂✂❇❇ ❇ ❇ ❇ ✂ ✂ ✂ ❇ ✂ ❇ ❇ ❇ ✂ ✂ ✂ ❇ ✂ ❇ A A A ... A Fig. 4. Infinite argumentation line with a self defeating argument Many approaches of defeasible argumentation have to deal with self-defeating arguments. As stated next, arguments in DeLP will never be self-defeating. Proposition 4.2 In DeLP no argument structure can be self-defeating. Proof: Assume that hA, hi is self-defeating, then hA, hi would be a defeater for itself, and there should exist a counter-argument point q in A such that Π ∪ {h, q} is contradictory. Therefore Π ∪ A would be contradictory, and hA, hi would not be an argument structure. Another problematic situation, mentioned by Henry Prakken in (Prakken & Vreeswijk, 2000), are reciprocal defeaters. This happens when a pair of arguments defeat each other. Example 4.4 and Figure 5 shows that case: hA2 , d i defeats hA1 , bi, attacking the subargument hB, ∼d i, but hA1 , bi also defeats hA2 , d i attacking the subargument hA, ∼bi. d b A2 A1 ✟ ❍ ✂❇ ❍❍✟✟ ✂❇ ✂ ❇✟✟ ❍❍✂ ❇ ∼d ❇ ✟❇ ✂❍ ✂ ∼b ✂ ✂✂❇❇ ❇ ✂ ✂✂❇❇ ❇ ✂ B ❇ ✂ A ❇ ✂ ❇ ✂ ❇ Fig. 5. Reciprocal defeaters Example 4.4 Consider the following de.l.p.: { (d —< ∼b, c), (b —< ∼d , a), (∼b —< a), (∼d —< c), (a), (c) }. The argument hA2 , d i=h{(d —< ∼b, c), (∼b —< a)}, d i is a proper defeater for hA1 , bi=h{(b —< ∼d , a), (∼d —< c)}, bi, and vice versa. Observe that hA2 , d i is 20 Alejandro J. Garcı́a and Guillermo R. Simari strictly more specific than the subargument h{∼d is strictly more specific than h{∼b —< a}, ∼bi. —< c}, ∼d i of hA1 , bi, and hA1 , bi Clearly, this situation is undesirable as it leads to the construction of an infinite sequence of arguments. Therefore, reciprocal defeaters must be detected and avoided. The analysis prompted by Henry Prakken’s remark led to investigate other types of undesirable situations in argumentation. A circular argumentation is obtained when an argument structure is reintroduced again in an argumentation line to defend itself. Figure 6 shows an example of circular argumentation. There, the same argument A is reintroduced down the line as a supporting argument for itself leading to an infinite argumentation line. Circular argumentation was discussed first in (Simari et al., 1994b) as a particular case of fallacious argumentation. ∼r ∼p ∼q ∼s ∼r ✟ ✟ ✟ ✟ ✂❇ ✟✟ ✂❇ ✟✟ ✂❇ ✟✟ ✂❇ ✟✟ ✂❇ ✂ ❇ ✂ ❇✟✟ ✂ ❇✟✟ ✂ ❇✟✟ ✂ ❇✟✟ ✂ p❇ ✂ r✟❇ ✂ s✟❇ ✂ q✟❇ ✂ p✟❇ ✂ ✂✂❇❇ ❇ ✂ ✂✂❇❇ ❇ ✂ ✂✂❇❇ ❇ ✂ ✂✂❇❇ ❇ ✂ ✂✂❇❇ ❇ ✂ W ❇ ✂ Z ❇ ✂ Y ❇ ✂ X ❇ ✂ W ❇ ❇ ❇ ✂ ✂ ✂ ✂ ❇ ❇ ✂ ❇ A B C D ... A Fig. 6. Circular argumentation In order to avoid circular argumentation we need to impose the condition that no argument can be reintroduced in the same argumentation line. However, a more subtle case of circular argumentation happens with the reintroduction of a subargument. Figure 7 shows this situation: argument B is a defeater for A, and W is the disagreement sub-argument. Later in the line, argument W could be reintroduced as a defeater, allowing the reintroduction of B. Although the cycle can be detected and broken when B is reintroduced, the fallacious situation is the reintroduction of a subargument that was defeated earlier in the line. ∼r ∼p ∼q ∼s ✟✟✂❇ ✟✟✂❇ ✟✟✂❇ ✂❇ ✟ ✟ ✟ ✂ ❇ ✟ ✂ ❇ ✟ ✂ ❇ ✂ ❇ ✟ ✂ q✟❇✟ ✂ s✟❇✟ ✂ ∼p ❇ ✂ p✟❇✟ ✂ ✂✂❇❇ ❇ ✂ ✂✂❇❇ ❇ ✂ ✂✂❇❇ ❇ ✂ ✂✂❇❇ ❇ ✂ X ❇ ✂ Y ❇ ✂ Z ❇ ✂ W ❇ ❇ ❇ ❇ ✂ ✂ ✂ ❇ ✂ A B C p ✂✂❇❇ ... W D Fig. 7. Circular argumentation with a sub-argument A different, but also undesirable, situation is shown in Figure 8. There, the same argument A becomes both a supporting and an interfering argument of itself. This situation arises because the supporting argument C has a subargument Z for the literal r , which is contradictory with arguing in favor of ∼r (argument A.) The Defeasible Logic Programming An Argumentative Approach 21 introduction of an argument like C should be avoided in a sound argumentation line. Clearly, there should be agreement among supporting arguments (respectively interfering) in any argumentation line. This is expressed formally with the notion of argument concordance as proposed in (Simari et al., 1994b) and recalled next. Definition 4.6 (Concordance) Let P=(Π, ∆) be a de.l.p.. Two arguments hA1 , h1 i and hA2 , h2 i are concordant iff the set Π ∪ A1 ∪ A2 is non-contradictory. More generally, a set of argument Sn structures {hAi , hi i}ni=1 is concordant iff Π ∪ i=1 Ai is non-contradictory. ∼r ∼p ∼q ∼r ✟✟✂❇ ✟✟✂❇ ✟✟✂❇ ✂❇ ✂ ❇ ✟✟ ✂ ❇ ✟✟ ✂ ❇ ✟✟ ✂ ❇ ✂ q✟❇✟ ✂ r✟❇✟ ✂ p❇ ✂ p✟❇✟ ✂ ✂✂❇❇ ❇ ✂ ✂✂❇❇ ❇ ✂ ✂✂❇❇ ❇ ✂ ✂✂❇❇ ❇ ✂ Y ❇ ✂ Z ❇ ✂ X ❇ ✂ X ❇ ❇ ❇ ❇ ✂ ✂ ✂ ❇ ✂ A B C ... A Fig. 8. Contradictory argumentation line In the case shown in Figure 8, the cycle could be detected and broken disallowing the reintroduction of argument A. However, the fallacious move is the use of argument C that makes the set of supporting arguments non-concordant. Observe that the status of the first argument of the line will change depending on which criterion we use: on one hand, if we allow the use of C, and just forbid the reintroduction of A, the first argument in the line would not be defeated; on the other hand, if C is forbidden, the first argument of the line will be defeated. Therefore, we will establish the condition that the set of supporting arguments of an argumentation line must be concordant, and the same must hold for the set of interfering arguments. Thus, the introduction of argument C in the example of Figure 8 will not be allowed. A different ill-formed situation corresponds to the use of a blocking defeater to defeat a blocking defeater. Consider the following de.l.p.:   tiger (hobbes)   dangerous(X ) —< tiger (X ) ∼dangerous(X ) —< baby(X ) baby(hobbes)   ∼dangerous(X ) —< pet (X ) pet (hobbes) Here, A1 = { ∼dangerous(hobbes) —< baby(hobbes) } supports ∼dangerous(hobbes). The argument A2 = {dangerous(hobbes) —< tiger (hobbes) } is a blocking defeater for the argument A1 , and A3 ={ ∼dangerous(hobbes) —< pet (hobbes) } is a blocking defeater for A2 . The following argumentation line may be obtained: [A1 , A2 , A3 ]. Observe that although A2 is a defeater for A3 , A2 is not introduced again because it was already used in the line. If the argumentation line [A1 , A2 , A3 ] is accepted, then A3 defeats A2 , reinstating A1 . However, a blocking argument A3 is being used for defeating a blocking defeater A2 , but A2 was already blocked by A1 . This is equivalent to accepting that in a blocking situation having two arguments for “∼dangerous(hobbes)” is preferred over having just one argument for the contrary. In order to avert this problem, 22 Alejandro J. Garcı́a and Guillermo R. Simari when an argument hAi , hi i is used as a blocking defeater for hAi−1 , hi−1 i during the construction of an argumentation line, only a proper defeater could be used for defeating hAi , hi i. In DeLP, the undesirable situations mentioned above are avoided by requiring all argumentation lines to be acceptable as defined next. Definition 4.7 (Acceptable argumentation line) Let Λ = [hA1 , h1 i, . . . , hAi , hi i, . . . , hAn , hn i] be an argumentation line. Λ is an acceptable argumentation line iff: 1. Λ is a finite sequence. 2. The set ΛS , of supporting arguments is concordant, and the set ΛI of interfering arguments is concordant. 3. No argument hAk , hk i in Λ is a subargument of an argument hAi , hi i appearing earlier in Λ (i < k .) 4. For all i, such that the argument hAi , hi i is a blocking defeater for hAi−1 , hi−1 i, if hAi+1 , hi+1 i exists, then hAi+1 , hi+1 i is a proper defeater for hAi , hi i. It is interesting to note that changes in the definition of acceptable argumentation line may produce a different behavior of the formalism. Thus, this definition could be used as a way of tuning the system to obtain different results. 5 Warrant through Dialectical Analysis In DeLP a literal h will be warranted2 if there exists a non-defeated argument structure hA, hi. In order to establish whether hA, hi is non-defeated, the set of defeaters for A will be considered. Since each defeater D for A is itself an argument structure, defeaters for D will in turn be considered, and so on. Therefore, as stated in Example 4.3, more than one argumentation line could arise, leading to a tree structure that we will call dialectical tree. Definition 5.1 (Dialectical Tree) Let hA0 , h0 i be an argument structure from a program P. A dialectical tree for hA0 , h0 i, denoted ThA0 , h0 i , is defined as follows: 1. The root of the tree is labeled with hA0 , h0 i. 2. Let N be a non-root node of the tree labeled hAn , hn i, and Λ= [hA0 , h0 i, hA1 , h1 i, hA2 , h2 i, . . . , hAn , hn i] the sequence of labels of the path from the root to N . Let hB 1 , q1 i, hB 2 , q2 i, . . ., hB k , qk i be all the defeaters for hAn , hn i. For each defeater hB i , qi i (1 ≤ i ≤ k ), such that, the argumentation line Λ′ = [hA0 , h0 i, hA1 , h1 i, hA2 , h2 i, . . . , hAn , hn i, hB i , qi i] is acceptable, then the node N has a child Ni labeled hB i , qi i. If there is no defeater for hAn , hn i or there is no hB i , qi i such that Λ′ is acceptable, then N is a leaf. 2 In previous work we have used the term justification. We decide to adopt the term warrant in order to unify the terminology with other approaches. Defeasible Logic Programming An Argumentative Approach 23 In a dialectical tree every node (except the root) represents a defeater (proper or blocking) of its parent, and leaves correspond to non-defeated arguments. Each path from the root to a leaf corresponds to one different acceptable argumentation line. As we will show in Example 5.1 the dialectical tree provides a structure for considering all the possible acceptable argumentation lines that can be generated for deciding whether an argument is defeated. We call this tree dialectical because it represents an exhaustive dialectical analysis for the argument in its root. ✟✟ ✟ hB 1 , ∼bi hA, ai ❍❍ ❍ hB2 , ∼bi hC 1 , ∼f i hB 3 , ∼bi ❅ ❅ ❅ hC 2 , ∼f i hD1 , ∼hi Fig. 9. Dialectical tree for Example 5.1 Example 5.1 Consider the following de.l.p.:  a —< b ∼b —< e     —< c b e  c ∼f —< g, h    ∼b —< c, d h —< j   d j ∼b —< c, f f —< g g k ∼f —< i i ∼h —< k            Here, the literal a is supported by hA, ai= h{(a —< b), (b —< c)}, ai and there exist three defeaters for it, each of them starting three different argumentation lines: hB 1 , ∼bi = h{(∼b —< c, d )}, ∼bi, hB 2 , ∼bi = h{(∼b —< c, f ), (f —< g)}, ∼bi, and hB 3 , ∼bi = h{(∼b —< e)}, ∼bi. The first two are proper defeaters and the last one is a blocking defeater. Observe that the argument structure hB 1 , ∼bi has the counterargument h{b —< c}, bi, but it is not a defeater because the former is more specific. Thus, no defeaters for hB 1 , ∼bi exist and the argumentation line ends there. The argument structure hB 3 , ∼bi has a blocking defeater: h{b —< c}, bi. Note that h{b —< c}, bi is the disagreement subargument of hA, ai, therefore, it cannot be introduced because it produces an argumentation line that is not acceptable. The argument structure hB 2 , ∼bi has two defeaters that can be introduced: hC 1 , ∼f i = h{(∼f —< g, h), (h —< j )}, ∼f i (proper defeater) and hC 2 , ∼f i = h{(∼f —< i )}}, ∼f i (blocking defeater.) Thus, one of the lines is split in two argumentation lines. The argument hC 1 , ∼f i has a blocking defeater that can be introduced in the line: hD1 , ∼hi = h{(∼h —< k )}, ∼hi. Finally, observe that both hD 1 , ∼hi and hC 2 , ∼f i have a blocking defeater, but they cannot be introduced, because they make the argumentation line not acceptable. The dialectical tree for hA, ai is shown in Figure 9. 24 Alejandro J. Garcı́a and Guillermo R. Simari Observation 5.1 A subtree of a dialectical tree (i. e., a node with all its descendants) is not always a dialectical tree. Suppose we build an acceptable argumentation line where a defeater hA, hi will not be included because it would make the line unacceptable. There might be a subsequence of the mentioned line where the same defeater could be included, as the following example shows. Example 5.2 Consider the de.l.p. P= { (a —< b), (∼a —< c), (a —< f ), (b), (c), (d) }. Here, h{∼a —< c}, ∼ai and h{a —< b}, ai are blocking defeaters, and h{∼a —< c}, ∼ai and h{a —< f }, ai are also blocking defeaters. Consider the following dialectical tree, with only one argumentation line h{a —< b}, ai ↑ h{∼a —< c}, ∼ai The argument structure h{a —< f }, ai cannot be included in the tree as a defeater for h{∼a —< c}, ∼ai, because a blocking-blocking situation occurs, and the argument structure h{a —< b}, ai cannot be included as a defeater for h{∼a —< c}, ∼ai, because it was already used in the argumentation line. The node h{∼a —< c}, ∼ai is a subtree of the one above, but it is not a dialectical tree because h{a —< f }, ai and h{a —< b}, ai, which are defeaters for h{∼a —< c}, ∼ai, are not in the tree. hA, aiD ✟✟ ✟ hB1 , ∼biU ❍❍ ❍ hB 2 , ∼biD hC 1 , ∼f iD hB3 , ∼biU ❅ ❅ ❅ hC 2 , ∼f iU hD1 , ∼hiU Fig. 10. Marked dialectical tree for Example 5.1 In order to decide whether the root of a dialectical tree is defeated, a marking process will be defined. Nodes will be recursively marked as “D ” (defeated) or “U ” (undefeated) as follows: Procedure 5.1 (Marking of a dialectical tree) Let ThA, hi be a dialectical tree for hA, hi. The corresponding marked dialectical ∗ tree, denoted ThA, , will be obtained marking every node in ThA, hi as follows: hi ∗ 1. All leaves in ThA, hi are marked as “U ”s in ThA, . hi 2. Let hB, qi be an inner node of ThA, hi . Then hB, qi will be marked as “U ” ∗ in ThA, iff every child of hB, qi is marked as “D ”. The node hB, qi will be hi ∗ marked as “D ” in ThA, iff it has at least a child marked as “U ”. hi Defeasible Logic Programming An Argumentative Approach 25 This procedure suggests a bottom-up marking process, through which we are able to determine the marking of the root of a dialectical tree. Figure 10 shows the dialectical tree of Figure 9 after applying the marking procedure. The notion of warrant will be defined in terms of a marked dialectical tree as follows. Definition 5.2 (Warranted literals) ∗ Let hA, hi be an argument structure and ThA, its associated marked dialectical hi ∗ tree. The literal h is warranted iff the root of ThA, is marked as “U ”. We will hi say that A is a warrant for h. Proposition 5.1 If a literal q has a strict derivation from a de.l.p. P, then, q is warranted. Proof: By Observation 3.1, if there exists a strict derivation for q from P, then there exists a unique argument structure for q: h∅, qi. By Proposition 3.1, there exists no possible counter-argument for h∅, qi. Therefore, there will be no defeaters for h∅, qi, and then q will be a warranted. In other approaches (Dung, 1995; Toni & Kakas, 1995; Antoniou et al., 2000a; Pollock, 1995; Prakken & Sartor, 1997), the same idea that ‘an argument A will be defeated if there exists at least one defeater for it that it is not defeated’ is used, but in these approaches the notions of argument, defeater, or the argumentation process differ from ours. For example, in (Toni & Kakas, 1995), a similar tree structure was developed for computing the acceptability semantics for negation as failure, however, for them arguments correspond to a set of default negated literals. In (Prakken & Sartor, 1997) a dialogue tree is used, and in (Pollock, 1995) an “Inference Graph” was introduced. See Section 8 for further discussion on the related approaches. It is interesting to note that the notions of acceptable argumentation line and the dialectical tree provide a flexible structure for defining different argumentation protocols when considering different strategies for accepting defeaters during argumentation. This is an advantage over other formalisms where changing the protocol means changing the whole system. Based on the notion of warrant, we will define a modal operator of belief “B ”, where Bh means h is warranted, and ¬Bh means h is not warranted. Definition 5.3 (Answer to queries) The answers of a DeLP interpreter can be defined in terms a modal operator B . In terms of B , there are four possible answers for a query h: • • • • 3 yes, if Bh (h is warranted) no, if B h (the complement of h is warranted) undecided, if ¬Bh and ¬B ∼h (neither h nor ∼h are warranted.)3 unknown, if h is not in the language of the program. Observe that the symbol “¬” corresponds to classical negation in the meta-language of the modal operator 26 Alejandro J. Garcı́a and Guillermo R. Simari Example 5.3 Consider the de.l.p. of Example 5.1. There, the literal “w ” is not in the language of the program, so the answer for the query “w ” is unknown. The answer for “a” is undecided because as shown by the dialectical tree of Figure 10, the literal “a” is not warranted, and the literal “∼a” is also not warranted because there is no argument structure supporting it. The argument hB 1 , ∼bi has no defeaters, so “∼b” is warranted (B ∼b) and the answer for query “∼b” is yes. Since B ∼b, then the answer for query “b” is no. Example 5.4 Regarding the de.l.p. P 2.1 , the answer for flies(tina) is yes, and the answer for ∼flies(tina) is no. Considering the program P 2.2 , the answer for pacifist (nixon) is undecided, and the answer for ∼pacifist (nixon) is also undecided. In the case of example P 2.4 , the answer for buy stocks(acme) is yes, and the answer for buy stocks(alfa) is unknown. Example 5.5 From the de.l.p. P 2.2 of Example 2.2 the following argument structures can be obtained: hA1 , has a gun(nixon)i, hA2 , ∼has a gun(nixon)i, hA3 , ∼pacifist (nixon)i, and hA4 , pacifist (nixon)i, where A1 = {has a gun(nixon) —< lives in chicago(nixon)}   ∼has a gun(nixon) —< lives in chicago(nixon), pacifist (nixon) A2 = pacifist (nixon) —< quaker (nixon) A3 = {∼pacifist (nixon) —< republican(nixon)} A4 = {pacifist (nixon) —< quaker (nixon) } Here, hA3 , ∼pacifist (nixon)i is a blocking defeater for hA4 , pacifist (nixon)i, and vice versa, therefore in DeLP the answer for the query ‘pacifist (nixon)’ will be undecided. The argument structure hA2 , ∼has a gun(nixon)i is a proper defeater for hA1 , has a gun(nixon)i. Observe that hA3 , ∼pacifist (nixon)i is a blocking defeater for hA2 , ∼has a gun(nixon)i, since hA4 , pacifist (nixon)i is a subargument of hA2 , ∼has a gun(nixon)i. An argument behaving like hA2 , ∼has a gun(nixon)i is called in (Makinson & Schlechta, 1991) a “zombie argument”: it is not ‘alive’ because it is blocked by the argument hA3 , ∼pacifist (nixon)i, but it is not ‘fully dead’ because it is defeating the argument hA1 , has a gun(nixon)i. As stated in (Prakken & Vreeswijk, 2000), in such a case, for several argumentation formalisms, neither of the three arguments, A1 , A2 , A3 , is a warrant. In DeLP hA1 , has a gun(nixon)i is defeated by hA2 , ∼has a gun(nixon)i, but hA2 , ∼has a gun(nixon)i is in turn defeated by hA3 , ∼pacifist (nixon)i, reinstating hA1 , has a gun(nixon)i. The argument hA4 , pacifist (nixon)i cannot be used to defeat hA3 , ∼pacifist (nixon)i because the argumentation line will not be acceptable (see condition 4 of Definition 4.7). Therefore, A1 is a warrant for has a gun(nixon). Example 5.6 Defeasible Logic Programming  ∼p ← f      d h P 5.6 =    e   An Argumentative Approach  p —< d , h    ∼p —< d , h, ∼a   ∼a —< e    a —< e, f   f —< d From the de.l.p. above the following argument structures can be obtained: 27 hB, pi = h{p —< d , h}, pi hC, ∼pi = h{(∼p —< d , h, ∼a), (∼a —< e)}, ∼pi hA, ai = h{(a —< e, f ), (f —< d )}, ai We will first consider a potential warrant for literal p. hB, pi has the proper defeater hC, ∼pi defeated in turn by its proper defeater hA, ai in ∼a. If the argumentation line Λ1 = [hB, pi, hC, ∼pi, hA, ai] were acceptable, literal “p” would be warranted. Next, we will consider a potential warrant for literal ∼p. As stated above, hC, ∼pi has the proper defeater hA, ai, but note that hA, ai is also defeated by hB, pi (using the strict rule“∼p ← f ”). Consider Λ2 = [hC, ∼pi, hA, ai, hB, pi]. Although hC, ∼pi defeats hB, pi, it cannot be introduced in Λ2 because of the circularity restriction. If Λ2 were to be acceptable, the literal ∼p would now be warranted. Therefore, accepting Λ1 for p and Λ2 for ∼p would render both literals warranted. This will no happen in DeLP because neither Λ1 nor Λ2 satisfy the concordance restriction and therefore they are not acceptable argumentation lines. Observe that hB, pi and hA, ai are not concordant, and hB, pi and hC, ∼pi are not concordant either. 5.1 The Warrant Procedure with pruning In order to decide whether a literal h is warranted from a de.l.p. P, the warrant procedure has to find an argument structure hA, hi and, as established by Defini∗ tion 5.2, the root of ThA, has to be marked as “U ”. We will introduce in this hi section a procedure for deciding whether a given literal is warranted. This procedure will not explore, in general, the whole dialectical tree, and answers will therefore be computed in a more efficient way. Given a program P, there could be several argument structures hA1 , hi, . . . , hAi , hi for a literal h. However, the warrant procedure will not construct all the possible argument structures for h; it will consider each one of them in turn, exploring the associated dialectical tree. This optimization is similar in spirit to the one found in OSCAR (Pollock, 1996). ∗ Observe that a marked dialectical tree ThA, , like the one in Figure 11 (left), ai resembles the minimax tree used in Artificial Intelligence for game trees. Here, instead of nodes marked with 1 or -1, the tree has nodes marked “D ”, or “U ”. Note also that during the marking of the dialectical tree, some nodes are not contributing to the decision procedure (the marking), i. e. are such that they could be either “U ” or “D ” without changing the marking of the dialectical tree’s root. For example, in Figure 11 (left) the left-most child of the root is a “U ”, so the root 28 Alejandro J. Garcı́a and Guillermo R. Simari is a “D ”, no matter what the marking of the other two children of the root are. Hence, such a don’t-care node obviously belongs to a branch that may be pruned. This pruning process is similar to the α-β pruning of a mini-max tree. Clearly, during the marking procedure, once a node is labeled “U ” all of its siblings can be pruned. Figure 11 (left) shows a marked dialectical tree for argument structure hA, ai of Example 5.1 and the pruned tree in depth-first order (right.) hA, aiD ✟✟ ✟ hB1 , ∼biU ❍❍ ❍ hB 2 , ∼biD hC 1 , ∼f iD hB3 , ∼biU hA, aiD ✟✟ ✟ hB 1 , ∼biU ❍❍ ❍ -pruned- -pruned- ❅ ❅ ❅ hC 2 , ∼f iU hD1 , ∼hiU Fig. 11. Marked Dialectical tree for example 5.1 (left) and pruned (right) Given a query q the warrant procedure first will try to generate an argument structure A1 for q. If A1 for q is found, then the warrant procedure will try to build a defeater A2 for some counter-argument point in A1 (see the example below.) If such defeater exists, it will try to build a defeater A3 for A2 , and so on, building in this form an argumentation line. Thus, a dialectical tree will be generated in depth-first manner, considering (from left to right) every acceptable argumentation line. In a dialectical tree there are as many argumentation lines as leaves in the tree, and each of them could finish in a supporting or an interfering argument. Example 5.7 shows how a dialectical tree is constructed in a depth-first manner, considering supporting and interfering arguments for each possible argumentation line, and how the marking procedure and pruning is done while building the tree. Example 5.7 Suppose that, in order to find a warrant for h1 , the argument A1 is found, and the acceptable argumentation line [ hA1 , h1 i, hA2 , h2 i, hA3 , h3 i, hA4 , h4 i, hA5 , h5 i] is built, see Figure 12 (i.) In this situation, the acceptable argumentation line ends with the supporting argument A5 , so the marking procedure establishes that hA1 , h1 i is –up to this point– a “U ”. However, the warrant process cannot finish there because there could be more defeaters to consider. Therefore, the process will continue expanding other argumentation lines. First, note that although there could be more defeaters for A4 , considering them will not change A4 ’s status because of A5 . Therefore, the tree can be pruned at that point without considering further defeaters for A4 . However, the previous analysis does not apply to A3 , because if an undefeated defeater is found for it, the mark of A3 could change. It is for this reason that Defeasible Logic Programming An Argumentative Approach hA1 , h1 iU hA1 , h1 iD ✁ hA2 , h2 iD ✁ hA3 , h3 iU ✁ 29 ✁ hA2 , h2 iU ✁ hA3 , h3 iD ❆ hA4 , h4 iD hA′4 , h4′ iU ✁ hA5 , h5 iU (i) (ii) Fig. 12. Argumentation lines of Example 5.7 the procedure will look for any other possible defeater A4 ′ for A3 , creating a new argumentation line, see Figure 12-ii. If a defeater A4 ′ is found (with no defeaters), then the argumentation line will end with an interfering argument, and therefore A1 will be a “D ”, see Figure 12-ii. Again, pruning could be effected, because although there could be more defeaters for A3 , they cannot modify its status. However, there might be another defeater A3 ′ for A2 , creating, in that case, a new argumentation line. Figure 13 shows a Prolog-like specification of the top level of the warrant procedure with pruning. Predicates warrant/2 and defeated/2 specify how to perform the dialectical analysis. That is, a query Q will be warranted if an argument A for Q is found, and A is not defeated. The predicate find argument/2 (not developed in the figure) simply builds an argument for a given query. The predicate defeated/2, receives an argument A and an argumentation line ArgLine, and tries to find a defeater D for A, checking that D is acceptable as part of the argumentation line. If acceptable/3 succeeds, then it returns NewLine adding D to ArgLine. Since the argument A will be defeated if there exists a defeater that is in turn not defeated, then finally a call to \+ defeated(D,NewLine) is made. The predicate find defeater/2 calls find counterarg/2 that looks for an argument C that counter-argues A with a disagreement sub-argument SubA. The argument C will be a defeater for A if SubA is not better than C. The predicate better/2 succeeds when the first argument is better than the second regarding the chosen comparison criterion. Observe finally that the pruning is performed calling defeated/1 recursively with Prolog’s negation as failure “\+”. 30 Alejandro J. Garcı́a and Guillermo R. Simari warrant(Q,A):find_argument(Q,A), \+ defeated(A,[support(A,Q)]). % Q is a warranted literal % if A is an argument for Q % and A is not defeated defeated(A,ArgLine):find_defeater(A,D,ArgLine), acceptable(D,ArgLine,NewLine), \+ defeated(D,NewLine). % % % % find_defeater(A,C):find_counterarg(A,C,SubA), \+ better(SubA,C). % C is a defeater for A % if C counterargues A in SubA % and SubA is not better than C A is defeated if there is a defeater D for A acceptable within the line and D is not defeated Fig. 13. Specification of the Warrant Procedure with Pruning 6 DeLP Extensions 6.1 DeLP with Default Negation As discussed in (Alferes et al., 1996), logic programs, deductive databases, and more generally non-monotonic theories, use various forms of default negation, “not F ”, whose major distinctive feature is that ‘not F ’ is assumed by default, i. e., it is assumed in the absence of sufficient evidence to the contrary. In DeLP “absence of sufficient evidence” means “there is not warrant”. Therefore, the default negation ‘not F ’ will be assumed when the literal F is not warranted. We will discuss here briefly how to extend DeLP for using default negation. A more detailed paper with the definition of extended DeLP, and a comparison with other approaches is in preparation. When DeLP is extended to consider default negation, some characteristics of the formalism just described are affected. For a correct treatment of default negation in DeLP, further considerations will be required. Default negation will be allowed only preceding literals in the body of defeasible rules, e. g., ‘∼cross railway tracks —< not ∼train is coming 4 ’, and defeasible rules that use default negation will be called extended defeasible rules. The reason not allowing default negation in strict rules is twofold. On one hand, a strict rule ‘p ← not q’ is not completely strict, because the head ‘p’ will be derived assuming ‘not q’. On the other hand, the set Π of strict rules and facts could become a contradictory set in many cases. An Extended Defeasible Logic Program will be then, a set of Facts, Strict Rules and Extended Defeasible Rules. Since the decision of assuming an extended literal “not L” will be carried out by the dialectical process, the definition of defeasible derivation (Definition 2.5) is modified acordingly in extended DeLP. The change reflects that when an extended literal is found in the body of a rule, that literal will be ignored: 4 Adapted from an example attributed to John McCarthy in (Gelfond & Lifschitz, 1990). Defeasible Logic Programming An Argumentative Approach 31 Definition 6.1 (Extended Defeasible Derivation) Let P=(Π, ∆) be an extended defeasible logic program and L a ground literal. A defeasible derivation of L from P, denoted P |∼ L, consists of a finite sequence L1 , L2 , . . . , Ln = L of ground literals, and each literal Li is in the sequence because: (a) Li is a fact in Π, or (b) there exists a rule Ri in P (strict or defeasible) with head Li and body B1 , B2 , . . . , Bk and every literal of the body, except the ones preceded by default negation, is an element Lj of the sequence appearing before Li (j < i.) The definition of argument structure is also extended in order to avoid the introduction of self-defeating arguments, shown in the following example. Consider the set of defeasible rules: A={(a —< b), (b —< not a) }. From any de.l.p. including those rules, it is possible to obtain a defeasible derivation for “a”, assuming “not a”. However, an argument structure like hA, ai would be a new kind of self-defeating argument that we would like to avoid. Observe the new condition “2” below. Definition 6.2 (Extended Argument Structure ) Let h be a literal, and P=(Π, ∆) an extended defeasible logic program. An argument structure hA, hi for a ground literal h, is a set of extended defeasible rules of ∆, such that: 1. there exists a defeasible derivation for h from Π ∪ A. 2. if L is a literal in the defeasible derivation of h, then there is no defeasible rule in A containing “not L” in its body. 3. Π ∪ A is non-contradictory, and 4. A is minimal: there is no proper subset A′ of A such that A′ satisfies conditions (1) and (3). In extended DeLP, default negated literals will be another point of attack in an argument. Phan Dung in (Dung, 1993a) points out that “default negated literals are assumptions on which the derivation is based. The acceptance of the derivation depends on the acceptance of these assumptions”. In his work, Dung defines a notion of ground attack: an argument A′ for l , is a ground attack for A, if A contains a default negated literal not l . That is, an argument based on an assumption “not l ” could be attacked by an argument that supports the literal “l”. We will extend our notion of defeat, incorporating Dung’s notion of ground attack. Something similar was done in (Prakken & Sartor, 1997). We say that an argument structure hA, hi is an attack to an assumption of hB, qi, if the extended literal “not h” is in the body of a defeasible rule in B. The notion of defeater will be extended considering this new kind of attack. Definition 6.3 An argument structure hA1 , h1 i is a defeater for hA2 , h2 i, if and only if either: (a) hA1 , h1 i is a proper defeater for hA2 , h2 i, or (b) hA1 , h1 i is a blocking defeater for hA2 , h2 i, or (c) hA1 , h1 i is an attack to an assumption of hA2 , h2 i. 32 Alejandro J. Garcı́a and Guillermo R. Simari With this new definition of defeater, default negated literals become new points of attack. Thus, when the dialectical analysis is carried out, default negated literals could be defeated by arguments. It’s easy to see that DeLP negation satisfies the coherence principle established in (Alferes & Pereira, 1994; Pereira & Alferes, 1994): If “∼p” is warranted, then “not p” can be assumed. We claim that both negations are needed for representing knowledge in a natural manner. However, some approaches in the literature (Kakas et al., 1994; Dimopoulos & Kakas, 1995; Xianchang Wang, 1997) have tried to define default negation in terms of strong negation. Here follows some proposed transformations and counterexamples showing why they fail. In the approach of Logic Programming without Default Negation (Kakas et al., 1994; Dimopoulos & Kakas, 1995), a priority relation between rules is used for deciding between competing rules. In their approach they remove default negation using the following transformation: the rule “r0 :p ← q, not s” is transformed into two rules, “r1 :p ← q” and “r2 :∼p ← s”, with r1 < r2 . Hence, when s is not derivable, the rule r2 cannot be used, and there is a derivation for p. On the other hand when s is derivable, rule r2 blocks r1 . However, in this approach, when s becomes derivable after the transformation, the literal ∼p, that was not derivable from the original program is now derivable in the transformed one. This new derivable literal may cause unexpected results, as shown in Example 6.1 where we compare a de.l.p. P with default negation, and the program P ′ obtained with the transformation cited above. The program P ′ has the priority: (∼p —< r ) > (p —< q). Example 6.1 P′ P p —< q, not s q s a —< q ∼a —< ∼p p —< q ∼p —< s q s a —< q ∼a —< ∼p Observe that from P there is no argument for p, there is no argument for ∼p, and the literal a is warranted. However, in the transformed program P ′ the literal ∼p is warranted and there is no warrant for the literal a, because ∼p allows to build an argument for ∼a that defeats the argument for a. Further comments on the transformation cited above were reported in (Xianchang Wang, 1997). In (Xianchang Wang, 1997), where Priority Logic Programming was defined, another transformation is given: a rule “p ← not q” is transformed to “ p ← q”, where “q” is a new symbol. In addition, for every literal p of the program, two new rules are generated: “r1 : p ← p” and “r2 : p”, with r2 < r1 . We refer the interested reader to (Xianchang Wang, 1997) for the details of the transformation. Here follows an example of a de.l.p. P and its transformation P ′ . Defeasible Logic Programming An Argumentative Approach 33 Example 6.2 P P′ p ← not q p ← q q p p ← p q ← q In Example 6.2, from the transformed program P ′ new literals will be derived that may interact with other parts of the program. 6.2 DeLP with presumptions A defeasible rule with an empty body is called a presumption (Nute, 1988). In our approach a rule like “a —< ” would express that “there are (defeasible) reasons to believe in a”. Extending DeLP to consider presumptions is straightforward. We will show that only slight modifications need to be made in the formalism. An extended defeasible logic program will be a set of facts, strict rules, defeasible rules and presumptions. We will denote with ∆+ the set of defeasible rules, and presumptions. The definition of defeasible derivation is the only one that has to be extended in order to consider presumptions. In Definition 2.5, condition (a) has to be changed to: “Li is a fact or a presumption”. One major difference with respect to a regular de.l.p. is that presumptions are defeasible rules without body. Given an extended de.l.p. (Π,∆+ ) with no facts, defeasible derivations and arguments can still be obtained. For example, from the de.l.p. P1 = {(b —< ), (a —< b)} a defeasible derivation for “a” can be obtained. Thus, argument structures could be based on facts, on presumptions, or both. Since presumptions are a special case of defeasible rules, the notion of argument structure remains intact. However, given an argument structure hA, hi, the set A will be a set of defeasible rules that could include presumptions (A ⊆ ∆+ ). The definitions of disagreement, counter-argument, defeater, dialectical tree, and the warrant procedure are not affected by the inclusion of presumptions. The comparison criterion could be affected. As the following example shows, the specificity criterion defined in this paper has some problems when the argument contains presumptions. Example 6.3 Consider the extended de.l.p. (Π,∆+ ), where Π= {f}, and ∆+ = {(a —< p, f ), (p —< ), (∼a —< f ), (a —< t), (t —< )}. The following argument structures can be obtained: hA1 , ai = h{(a —< t), (t —< )}, ai hA2 , ∼ai = h{∼a —< f }, ∼ai hA3 , ai = h{(a —< p, f ), (p —< )}, ai 34 Alejandro J. Garcı́a and Guillermo R. Simari Observe that hA2 , ∼ai is based on the fact f , and hA1 , ai is based on the presumption t . Clearly, an argument based on facts should be preferible to one based on presumptions. In this case Definition 3.5 behaves as expected, because it states that hA2 , ∼ai is more specific than hA1 , ai. However, in other cases, this definition does not behave correctly. Observe now that hA2 , ∼ai is based on the fact f , hA3 , ai is based on the fact f and the presumption p, i. e. hA3 , ai is using more information. Here, Definition 3.5 states that hA2 , ∼ai and hA1 , ai are incomparable. The reason for this is that presumptions do not have a body and therefore the set H = {f } activates A2 . Other examples were analyzed in (Garcı́a, 2000). If the comparison criterion used is based on rules priorities, then the criterion has to find the way of preferring a fact over a presumption. Otherwise, an argument based on a fact and an argument based on a presumption (like hA2 , ∼ai and hA1 , ai in the example above) will be of equal strength. One simple way of solving the problems mentioned above is establishing that arguments based on facts will be preferable to arguments based on presumptions. The extension of the comparison criteria to consider presumptions is currently under study. 7 Implementation and Applications An interpreter of DeLP was implemented in Prolog, and can be used through the web (see http://cs.uns.edu.ar/∼ ajg/DeLP.html). Also an abstract machine called jam (Justification Abstract Machine) (Garcı́a, 1997) has been designed for the implementation of DeLP, as an extension of the Warren’s abstract machine (wam). A prototype implementation of the jam as a virtual machine was also developed, and is subject of future research. Applications that deal with incomplete and contradictory information can be easily modeled using DeLP programs. The defeasible argumentation basis of DeLP allows the building of applications for dynamic domains, where information may change. Thus, Defeasible Logic Programming can be used for representing knowledge and for providing an inference engine in many applications. A concrete application of DeLP was (Garcı́a et al., 2000), where a multi-agent system for the stock market domain was developed. The application consists of several deliberative agents for monitoring the stock market and performing actions based on the retrieved information. The agents reason using DeLP, and are capable of formulating arguments and counterarguments in order to decide whether to buy or sell some stock. Other applications are in progress. 8 Related Work DeLP combines Defeasible Argumentation and Logic Programming. In both areas there have been developed several related approaches. We will comment first the differences with other Defeasible Reasoning formalisms and then with extentions of Logic Programming that are related with our work. Defeasible Logic Programming An Argumentative Approach 35 8.1 Defeasible Logic and Argumentation Nute’s d-Prolog (Nute, 1988; Nute, 1994) was the first to introduce defeasible reasoning programming with specificity. d-Prolog syntax has strict and defeasible rules and strong negation. However, d-Prolog’s rules do not allow default negation. The language of d-Prolog provides facilities to define defeater rules like “sick birds do not fly”. The purpose of defeater rules is to account for the exceptions to defeasible rules. However, in (Antoniou et al., 2001) it is shown that defeaters can be simulated by means of strict and defeasible rules (in Nute’s sense). DeLP does not need to be supplied with defeater rules. The system will find the counterarguments among the arguments it is able to build, and will decide on the defeat relation using a comparison criterion. Thus, in DeLP the programmer does not need to encode explicit exceptions. One important difference between d-Prolog and our approach is the way in which contradictory conclusions are treated. In d-Prolog there is no notion of argument. In order to decide between two contradictory conclusions, d-Prolog compares only one pair of rules, whereas in DeLP the two arguments that support those conclusions are compared. Comparing only a pair of rules may be problematic as we show next. Consider the program P 1 = {(a —< b), b, (c —< d ), d , (h ← a), (∼h ← c)} of Example 2.3. In d-Prolog the literal a is accepted as proved from P 1 because there is no rule with “∼a” in its head, so no rule that contradicts “a —< b” is found. However, literals a and c disagree: literals h and ∼h are derivable from {a, c} ∪ {(h ← a), (∼h ← c)}. In DeLP, the argument B = {(c —< d )} is a blocking defeater for A = {a —< b}, because a and c disagree. Therefore, a fails to be warranted, and the answer for a is undecided. Answer for c is also undecided. Another problematic situation of comparing two rules without considering the rest of the program follows. Some approaches consider that R1 =“∼p —< q, r ” is better than R2 =“p —< q” because the body of R1 has more information. However, it may not be true, depending on the basis for the literal r . For instance, consider the program P 2 = {(p —< q), q, (∼p —< q, r ), (r ← q)}. Here, r is obtained strictly from q, so it’s not true that R1 is based on more information than R2 . Both rules have the same basis: the literal q. A major difference is that in d-Prolog there is no dialectical analysis, and no treatment for circular argumentation lines. The interested reader is referred to (Prakken & Vreeswijk, 2000), where other features of Nute’s work are discussed. Besides Nute’s work on Defeasible Logic, recent work by Grigoris Antoniou, David Billington, Michel Maher and Guido Governatori, has extended Nute’s approach, see (Antoniou et al., 2000a; Antoniou et al., 1998). Unfortunately, the same problems mentioned above for d-Prolog are inherited there. The defeasible argumentation formalism developed in (Simari & Loui, 1992) and used here, was inspired in part by Pollock’s work in Defeasible Reasoning (Pollock, 1987). However, Pollock has changed the way in which an argument is warranted, adopting 36 Alejandro J. Garcı́a and Guillermo R. Simari a multiple status assignment approach5 (Pollock, 1995; Pollock, 1996). Pollock has developed a computer program in Lisp, called OSCAR (Pollock, 1995) that performs defeasible reasoning. In OSCAR, arguments are sequences of linked reasons, and probabilities are used for comparing competing arguments. In a way similar to Nute’s defeater rules, explicit ‘undercutting’ defeaters can be expressed in his language. An inference graph is used by OSCAR for evaluating the status of arguments. Pollock argues that human reasoning is defeasible in two different senses. He distinguishes between ‘synchronically defeasible’ (a conclusion may be unwarranted relative to a larger set of inputs) and ‘diachronically defeasible’ (a conclusion may be retracted as a result of further reasoning, without any new input). Hence, in OSCAR an argument may be ‘justified’ in one stage of reasoning, and unjustified later, without any additional input. However an argument is ‘warranted’ when the reasoner reaches a stage, where for any new stages of reasoning the argument remains undefeated. This notion of warrant coincides with ours. However, in OSCAR a bottom-up procedure is used for computing justified and warranted arguments. In (Dung, 1995), P. Dung has proposed a very abstract and general argumentbased framework, where he completely abstracts from the notions of argument and defeat. In contrast with our approach of defining an object language for representing knowledge and a concrete notion of argument and defeat, Dung’s approach assumes the existence of a set of arguments ordered by a binary relation of defeat. However, he defines various notions of ‘argument extensions’, which aim to capture various types of defeasible consequence. Inspired by legal reasoning, H. Prakken and G. Sartor (Prakken & Sartor, 1997) have developed an argumentation system that, like ours, uses the language of extended logic programming. They introduce a dialectical proof theory for an argumentation framework fitting the abstract format developed by Dung, Kowalski et al. (Dung, 1995; Bondarenko et al., 1993). However, since they are inspired by legal reasoning, the protocol for dispute is rather different from our dialectical tree. A proof of a formula takes the form of a dialogue tree, where each branch of the tree is a dialogue between a proponent and an opponent. Proponent and opponent have different rules for introducing arguments, leading to an asymmetric dialogue. Later, Prakken (Prakken, 1997) generalized the system to default logic’s language. R. Kowalski and F. Toni (Kowalski & Toni, 1996) have outlined a formal theory of argumentation, in which defeasibility is stated in terms of non-provability claims. They argue that defeasible reasoning with rules of the form P if Q can be understood as “exact” reasoning with rules of the form P if Q and S cannot be shown, where S stands for one or more defeasible “non-provability claims”. In (Brewka, 2001a), a proposal of a new formal notion of argument systems is given, that focuses on capturing the most revelant aspects of realistic argumentation processes. His main interest is to capture the logic and procedural aspects of argumentation. The underlying language of his approach is preferential default logic. Other related approaches of defeasible argumentation are by Verheij (Verheij, 1996), 5 Unique and multiple status in (Prakken & Vreeswijk, 2000) assignments for arguments are analyzed in depth Defeasible Logic Programming An Argumentative Approach 37 Vreeswijk (Vreeswijk, 1997), Bondarenko (Bondarenko et al., 1997), and Loui (Loui, 1997b). Details of them can be found in the following surveys of defeasible argumentation: (Prakken & Vreeswijk, 2000), and (Chesñevar et al., 2000). 8.2 Logic Programming In (Gelfond & Lifschitz, 1990), Logic Programming with Classical Negation was introduced. There, when two complementary literals can be derived, the program becomes “contradictory” and every literal of the program can be derived. Since common sense reasoning is typically based on tentative information, and the representation of this kind of information leads in most cases to inconsistent knowledge bases, an extended logic program usually will derive all of the language. This problem was attacked in (Inoue, 1991), where Extended Logic Programming with Default Assumptions is considered. This approach resembles a defeasible argumentation system, but unfortunately no preference criterion for deciding between contradictory explanations was considered. In (Kakas et al., 1994), a semantics for default negation called “acceptability semantics” was introduced, based on previous works on default negation and abductive logic programming (Eshghi & Kowalski, 1989; Dung, 1991; Kakas et al., 1993). Sets of default negated literals are considered as extensions of the program, and a notion of “attack” between these sets is defined. An extension H is acceptable iff any attack A against H is not acceptable. A fixpoint operator for acceptability is given. They introduce a general theory of acceptability based on a binary relation “attack” that for LP is defined using a priority relation over program rules. Toni and Kakas in (Toni & Kakas, 1995), developed a proof procedure for the acceptability semantics mentioned above. In their approach a tree structure similar to our dialectical tree was developed. Both approaches share the idea of having a tree where children nodes attack the father node. However, as the intended application of these trees is computing a semantics for default negation, the nodes of their tree are sets of ‘abducibles’ (default negated literals), whereas a dialectical tree is a tree of arguments. Since they do not consider strong negation, both approaches are difficult to compare. In (Kakas et al., 1994) and later in (Dimopoulos & Kakas, 1995), “Logic Programming without Negation as Failure” (LPwNF) was introduced. A LPwNF program consists of a set of basic rules L0 ← L1 , . . . , Ln (where Li are literals that could use strong negation) and a given irreflexive and antisymmetric priority relation among program rules. They claim that default negation can be removed using a program transformation. The problem with this transformation (see Example 6.1) is that new literals are derivable that may cause other derivations to be blocked. Other problems with the transformation were reported in (Xianchang Wang, 1997). The proof procedure of LPwNF is very similar to the one of d-Prolog. Although in (Dimopoulos & Kakas, 1995) there is no comparison with Defeasible Logic, in (Antoniou et al., 2000a) a comparison among LPwNF, Defeasible Logic, and ‘Courteous Logic Programs’ is given. The main result of (Antoniou et al., 2000a) is that Defeasible Logic can prove everything that sceptical LPwNF can. In (Gelfond & Son, 1997) 38 Alejandro J. Garcı́a and Guillermo R. Simari a system to ‘investigate the methodology of reasoning with prioritized defaults in the language of logic programs under the answer set semantics’ was developed. Their system allows the representation of defeasible and strict rules, and the representation of an order among those rules. The way in which defeasible inferences are obtained is very similar to Antoniou et al. approach, although no comparison of these two systems is given. Sometimes, defeasible rules are considered as defaults in a default theory. However, defaults are not defeasible rules, as explained in (Nute, 1994). We will now introduce a more illustrative example adapted from (Covington et al., 1997). Example 8.1 Consider the following de.l.p. (left) and the same knowledge represented in a default theory (right). has shell (X ) —< mollusc(X ) ∼has shell (X ) —< cephalopod (X ) mollusc(X ) ← cephalopod (X ) cephalopod (fred ) mollusc(X ):has shell(X ) has shell(X ) cephalopod(X ):∼has shell(X ) ∼has shell(X ) mollusc(X ) ← cephalopod (X ) cephalopod (fred ) From the DeLP program above, there is an argument for ∼has shell (fred ) that is more specific than the argument for has shell (fred ). Hence, there is a warrant for ∼has shell (fred ). However, in Default Logic there are two extensions: one with ∼has shell (fred ) and the other with has shell (fred ). The reason is because the defaults express no connection between cephalopod and mollusc. To capture this conshell(X )∧∼cephalopod(X ) . nection, the first default should be changed to mollusc(X ):hashas shell(X ) That is, the exception must be explicitly encoded in the default. In DeLP, however, the exceptions are discovered by the warrant procedure. The above comparison seems to be unfair because default logic has no selection mechanism. However, in (Brewka & Eiter, 2000) default logic was extended in order to handle priorities, developing a Prioritized Default Logic (PDL). This approach has many properties which are relevant for argumentation, such as explicit representation of preferences and reasoning about these preferences. Although this approach is not explicitly argument-based, prioritized default theories extend default theories adding a strict partial order on defaults, using this ordering to define preferred extensions. PDL satisfies two reasonable principles for preference handling, which distinguishes PDL from other approaches. However, since an ordering of defaults is enforced, problems similar to those mentioned for comparing two rules are also present. Another important difference is that they only consider sets of default rules, without introducing strict rules, as was done here. In (Brewka, 2001b) a comparison between a variant of Defeasible Logic, called Ambiguity Propagating (Antoniou et al., 2000b), and the prioritized version of WellFounded Semantics for extended logic programs (Brewka, 1996) is given. The paper shows that under the condition that preferences are admitted between defeasible rules only, then all defeasibly provable literals by the defeasible logic variant are Defeasible Logic Programming An Argumentative Approach 39 true in prioritized well-founded semantics. It also shows that there are some desirable conclusions obtained by well-founded semantics that the variant of defeasible logic cannot obtain. In Prioritized Logic Program (PLP), a program is a pair (P , >) where P is a finite set of rules of the form “c ← a1 , . . . , an , not b1 , . . . , not bm ” and > is an acyclic preference relation on P . In PLP, a rule r is said to be defeated by a literal l if l = bi , for some i ∈ 1, . . . , m. Clearly, if no default negated literals are used in a program, then no rule is defeated. This represents a difference with DeLP because counter-arguments and defeaters are defined in term of strong negation. In PLP, default negated literals are the only point of attack, whereas in DeLP arguments are attacked by other arguments. The comparison in (Brewka, 2001b) is based on the translation of each defeasible rule “{a1 , . . . , an } ⇒ b” of default logic, to an extended rule with default negation: “b ← not ∼b, a1 , . . . , an ”. However, note that this translation captures only an attack to a rule, and not an attack to an argument (see the example of program P 1 above). One distinguishing feature of DeLP is the property of argument reinstatement. For example, consider the following de.l.p. P: a —< b ∼a —< b, c c —< i ∼c —< i, j b i j Here, the argument h{a —< b}, ai for the literal a has a proper defeater, the argument for ∼a: h{(∼a —< b, c), (c —< i )}, ∼ai. This one is in turn defeated by the proper defeater: h{∼c —< i, j }, ∼ci, that attacks the argument for ∼a in the inner point c. This third argument reinstates the first, and thus, there is a warrant for a. Therefore the set of warranted literals from P is W = {a, ∼c, b, i, j } In order to encode the program P in PLP, we have used the translation suggested in (Brewka, 2001b): r1 : a ← not ∼a, b r2 : ∼a ← not a, b, c r3 : c ← not ∼c, i r4 : ∼c ← not c, i, j r5 : b r6 : i r7 : j Without any priority, rules r1 , r2 , r3 and r4 are deleted, and the only derived literals are the facts b, i, j . If the priorities r2 > r1 and r4 > r3 are added to the program, then rules r1 and r3 are deleted and the derived literals are ∼c, b, i, j , that is the argument for ∼c does not reinstate the argument for a. A more formal comparison between our formalism and the approaches cited above is issue of future research. 40 Alejandro J. Garcı́a and Guillermo R. Simari 9 Conclusions and Future Work Defeasible Logic Programming combines Logic Programming and Defeasible Argumentation, and provides the possibility of representing information in the form of defeasible and strict rules in a declarative manner. A query q will be warranted, if the argument A that supports q is found undefeated by the dialectical analysis. During the dialectical analysis certain constrains are imposed for averting different kinds of fallacious argumentation. Thus, DeLP can manage defeasible reasoning and perform contradictory programs. The defeasible argumentation basis of DeLP allows to build applications that deal with incomplete and contradictory information in dynamic domains, where information may change. Thus, DeLP can be used for representing agent’s knowledge and for providing an inference engine. New applications of DeLP are in progress. We expect feedback from them to pursue future extensions. In (Garcı́a & Simari, 1999) a model for parallel defeasible logic programming is proposed. Besides existing forms of parallel logic programming, new sources of implicitly exploitable parallelism are considered: building arguments in parallel, searching for defeaters in parallel, and building a dialectical tree in parallel. An implementation of parallel DeLP is in preparation. An extension of DeLP with presumptions is also in study. The reader may have noticed that the dialectical tree associated with the warrant procedure could become quite large for non trivial situations. Much of the effort expended in the implementation was put on the task of performing an efficient search (Garcı́a, 2000; Simari et al., 1994a), However, more work should be done. Acknowledgments The authors are grateful to Jürgen Dix, Micheal Gelfond, Ron Loui, Francesca Toni, Hassan Aı̈t-Kaci, Grigoris Antoniou, Simon Parsons, John Pollock, Veronica Dahl and Paul Tarau for many helpful comments and suggestions. We wish to thank especially Carlos Ivan Chesñevar for many helpful discussions and the three anonymous referees for their useful suggestions. This work was partially supported by Secretarı́a de Ciencia y Técnica Universidad Nacional del Sur. References Alferes, José J., & Pereira, Luis Moniz. (1994). Contradiction: When avoidance equals removal, part I. Lecture notes in computer science, 798, 11–23. Alferes, José J., Pereira, Luis Moniz, & Przymusinski, Teodor C. (1996). Strong and explicit negation in nonmonotonic reasoning and logic programming. Lecture notes in computer science, 1126, 143–163. Antoniou, Grigoris, Billington, David, & Maher, Michel J. (1998). Normal forms for defeasible logic. Pages 160–174 of: Proceedings of international joint conference and symposium on logic programming. MIT Press. Antoniou, Grigoris, Maher, Michael J., & Billington, David. (2000a). Defeasible logic versus logic programming without negation as failure. Journal of logic programming, 42, 47–57. Defeasible Logic Programming An Argumentative Approach 41 Antoniou, Grigoris, Billington, David, Governatori, Guido, Maher, Michael J., & Rock, Andrew. (2000b). A family of defeasible reasoning logics and its implementation. Pages 459–463 of: Proceedings of european conference on artificial intelligence (ecai). Antoniou, Grigoris, Billington, David, Governatori, Guido, & Maher, Michael J. (2001). Representation results for defeasible logics. Acm transactions on computational logic, 2(2), 255–287. Billington, David, De Coster, Koen, & Nute, Donald. (1990). A modular translation from defeasible nets to defeasible logics. Journal of experimental and theoretical artificial intelligence, 2, 151–177. Bondarenko, Andrei, Toni, Francesca, & Kowalski, Robert A. (1993). An assumptionbased framework for non-monotonic reasoning. Proceedings 2nd. international workshop on logic programming and non-monotonic reasoning, 171–189. Bondarenko, Andrei, Dung, Phan M., Kowalski, Robert A., & Toni, Francesca. (1997). An abstract, argumentation-theoretic approach to default reasoning. Artificial intelligence, 93, 63–101. Brewka, Gerhard. (1996). Well-founded semantics for extended logic programs with dynamic preferences. Journal of artificial intelligence research, 4, 19–36. Brewka, Gerhard. (2001a). Dynamic argument systems: A formal model of argumentation processes based on situation calculus. Journal of logic and computation, 11(2), 257–282. Brewka, Gerhard. 2001b (Aug.). On the relation between defeasible logic and well-founded semantics. Proceedings lpnmr 2001. Brewka, Gerhard, & Eiter, Thomas. (2000). Prioritizing default logic. Pages 27–46 of: Hölldobler, Steffen (ed), Intellectics and computational logic: Papers in honor of wolfgang bibel. Dordrecht, Boston, London: Kluwer Academic Publishers. Chesñevar, Carlos I., Maguitman, Ana G., & Loui, Ronald P. (2000). Logical Models of Argument. Acm computing surveys, 32(4), 337–383. Chesñevar, Carlos I., Dix, Jürgen, Stolzenburg, Frieder, & Simari, Guillermo R. (2002). Relating defeasible and normal logic programming through transformation properties. Theoretical computer science. accepted for publication. Covington, Michael A., Nute, Donald, & Vellino, Andre. (1997). Prolog programming in depth. Prentice-Hall. Dahl, Veronica. (1999). Logic programming and languages. Wiley encyclopedia of electrical and electronics engineering, 11, 576–580. Dahl, Veronica, Tarau, Paul, & Li, Renwei. (1997). Assumption grammars for natural language processing. Fourteenth international conference on logic programming, 256– 270. Dimopoulos, Yannis, & Kakas, Antonis. (1995). Logic programming without negation as failure. Pages 369–384 of: Proceedings of 5th. international symposium on logic programming. Cambridge, MA: MIT Press. Dix, Jürgen. (1994). Semantics of logic programs: their intuitions and formal properties. Pages 227–313 of: Fuhrmann, André, & Rott, Hans (eds), Logic, action and information. Berlı́n–New York: de Gruyter. Dix, Jürgen, & Stolzenburg, Frieder. (1998). A framework to incorporate non-monotonic reasoning into constraint logic programming. Journal of logic programming, 37, 1–31. Dung, Phan M. (1991). Negation as hypothesis: An abductive foundation for logic programs. Proceedings of the 8th. international conference on logic programming. Paris, France: MIT Press. Dung, Phan M. (1993a). An argumentation semantics for logic programming with ex- 42 Alejandro J. Garcı́a and Guillermo R. Simari plicit negation. Pages 616–630 of: Proceedings 10th. intenational conference on logic programming. MIT Press. Dung, Phan M. (1993b). On the Acceptability of Arguments and its Fundamental Role in Nomonotonic Reasoning and Logic Programming. Proceedings of the 13th. international joint conference in artificial intelligence (ijcai), chambéry, francia. Dung, Phan M. (1995). On the acceptability of arguments and its fundamental role in nonmonotonic reasoning and logic programming and n-person games. Artificial intelligence, 77, 321–357. Eshghi, Kave, & Kowalski, Robert A. (1989). Abduction compared with negation as failure. Proceedings of the 6th. international conference on logic programming. Lisbon, Portugal: MIT Press. Garcı́a, Alejandro J. 1997 (July). Defeasible logic programming: Definition and implementation. M.Phil. thesis, Computer Science Department, Universidad Nacional del Sur, Bahı́a Blanca, Argentina. Garcı́a, Alejandro J. 2000 (Dec.). Defeasible logic programming: Definition, operational semantics and parallelism. Ph.D. thesis, Computer Science Department, Universidad Nacional del Sur, Bahı́a Blanca, Argentina. Garcı́a, Alejandro J., & Simari, Guillermo R. (1999). Parallel defeasible argumentation. Journal of computer science and technology special issue: Artificial intelligence and evolutive computation. http://journal.info.unlp.edu.ar/, 1(2), 45–57. Garcı́a, Alejandro J., Simari, Guillermo R., & Chesñevar, Carlos I. 1998 (Aug.). An argumentative framework for reasoning with inconsistent and incomplete information. Workshop on practical reasoning and rationality. 13th biennial European Conference on Artificial Intelligence (ECAI-98). Garcı́a, Alejandro J., Gollapally, Devender, Tarau, Paul, & Simari, Guillermo R. 2000 (Aug.). Deliberative stock market agents using jinni and defeasible logic programming. Proceedings of esaw’00 engineering societies in the agents’ world, workshop of ecai 2000. Gelfond, Michael. (1994). Logic programming and reasoning with incomplete information. Annals of mathematics and artificial intelligence, 12, 89–116. Gelfond, Michael, & Lifschitz, Vladimir. (1990). Logic programs with classical negation. Pages 579–597 of: Warren, D., & Szeredi, P. (eds), 7th international conference on logic programming. MIT Press. Gelfond, Michel, & Son, Tran C. (1997). Reasoning with prioritized defaults. Pages 164– 223 of: Lecture notes in artificial intelligence 1471, selected papers from the workshop on logic programming and knowledge representation. Inoue, Kazuko. (1991). Extended logic programming with default assumptions. Proceedings of 8th. international conference on logic programming. Kakas, Antonis C., Kowalski, Robert A., & Toni, Francesca. (1993). Abductive logic programming. Journal of logic and computation, 2, 719–770. Kakas, Antonis C., Mancarella, Paolo, & Dung, Phan M. (1994). The acceptability semantics for logic programs. Pages 504–519 of: Proceedings of the 11th. international conference on logic programming. Santa Margherita, Italy: MIT Press. Kowalski, Robert A., & Toni, Francesca. (1996). Abstract argumentation. Artificial intelligence and law, 4(3-4), 275–296. Li, Renwei, Pereira, Luis Moniz, & Dahl, Veronica. (1998). Refining action theories with abductive logic programming. Selected extended papers from the lpkr’97: Ilps’97 workshop on logic programming and knowledge representation, 123–138. Lifschitz, Vladimir. (1996). Foundations of logic programs. Pages 69–128 of: Brewka, G. (ed), Principles of knowledge representation. CSLI Pub. Defeasible Logic Programming An Argumentative Approach 43 Loui, Ronald P. (1997a). Alchourrón and Von Wright on Conflict among Norms. Pages 345–353 of: Nute, Donald (ed), Defeasible deontic logic, vol. 263. Synthese Library. Loui, Ronald P. 1997b (July). et al. Progress on Room 5: A Testbed for Public Interactive Semi-Formal Legal Argumentation. Proceedings of the 6th. international conference on artifcial intelligence and law. Makinson, David, & Schlechta, Karl. (1991). Floating conclusions and zombie paths: two deep difficulties in the directly skeptical approach to defeasible inference nets. Artificial intelligence, 48, 199–209. Nute, Donald. (1988). Defeasible reasoning: a philosophical analysis in prolog. Pages 251–288 of: Fetzer, J. H. (ed), Aspects of artificial intelligence. Kluwer Academic Pub. Nute, Donald. (1992). Basic defeasible logic. Fariñas del Cerro, Luis (ed), Intensional logics for programming. Oxford: Claredon Press. Nute, Donald. (1994). Defeasible logic. Pages 355–395 of: Gabbay, D.M., Hogger, C.J., & J.A.Robinson (eds), Handbook of logic in artificial intelligence and logic programming, vol 3. Oxford University Press. Pereira, Luis Moniz, & Alferes, José J. (1994). Contradiction: When avoidance equals removal, part II. Lecture notes in computer science, 798, 268–281. Pollock, John. (1987). Defeasible Reasoning. Cognitive science, 11, 481–518. Pollock, John. (1995). Cognitive carpentry: A blueprint for how to build a person. MIT Press. Pollock, John. (1996). Oscar - A general purpose defeasible reasoner. Journal of applied non-classical logics, 6, 89–113. Poole, David L. (1985). On the Comparison of Theories: Preferring the Most Specific Explanation. Pages 144–147 of: Proc. 9th IJCAI. IJCAI. Prakken, Henry. (1997). Logical tools for modelling legal argument. a study of defeasible reasoning in law. Kluwer Law and Philosophy Library. Prakken, Henry, & Sartor, Giovanni. (1997). Argument-based logic programming with defeasible priorities. J. of applied non-classical logics, 7(25-75). Prakken, Henry, & Vreeswijk, Gerard. (2000). Logical systems for defeasible argumentation. D.Gabbay (ed), Handbook of philosophical logic, 2nd ed. Kluwer Academic Pub. Simari, Guillermo R., & Loui, Ronald P. (1992). A Mathematical Treatment of Defeasible Reasoning and its Implementation. Artificial intelligence, 53, 125–157. Simari, Guillermo R., Chesñevar, Carlos I., & Garcı́a, Alejandro J. 1994a (Oct.). Focusing inference in defeasible argumentation. Iv iberoamerican congress on artificial intelligence (iberamia’94). Venezuela. Simari, Guillermo R., Chesñevar, Carlos I., & Garcı́a, Alejandro J. 1994b (Nov.). The role of dialectics in defeasible argumentation. XIV international conference of the chilenean computer science society. Toni, Francesca, & Kakas, Antonis C. (1995). Computing the acceptability semantics. Pages 401–415 of: Proceedings of the 3rd. international workshop on logic programming and non-monotonic reasoning. Lexington,USA: Springer Verlag. Verheij, Bart. 1996 (Dec.). Rules, reasons, arguments: formal studies of argumentation and defeat. Ph.D. thesis, Maastricht University, Holland. Vreeswijk, Gerard A. W. (1997). Abstract argumentation systems. Artificial intelligence, 90, 225–279. Xianchang Wang, Jia-Huai You, Li Y. Yuan. (1997). Logic programming without default negation revisited. Pages 1169–1174 of: Proceedings of ieee international conference on intelligent processing systems. IEEE.