Justifying Answer Sets using Argumentation

11/20/2014 ∙ by Claudia Schulz, et al. ∙ Imperial College London 0

An answer set is a plain set of literals which has no further structure that would explain why certain literals are part of it and why others are not. We show how argumentation theory can help to explain why a literal is or is not contained in a given answer set by defining two justification methods, both of which make use of the correspondence between answer sets of a logic program and stable extensions of the Assumption-Based Argumentation (ABA) framework constructed from the same logic program. Attack Trees justify a literal in argumentation-theoretic terms, i.e. using arguments and attacks between them, whereas ABA-Based Answer Set Justifications express the same justification structure in logic programming terms, that is using literals and their relationships. Interestingly, an ABA-Based Answer Set Justification corresponds to an admissible fragment of the answer set in question, and an Attack Tree corresponds to an admissible fragment of the stable extension corresponding to this answer set.

READ FULL TEXT VIEW PDF
POST COMMENT

Comments

There are no comments yet.

Authors

page 1

page 2

page 3

page 4

This week in AI

Get the week's most popular data science and artificial intelligence research sent straight to your inbox every Saturday.

1 Introduction

Answer Set Programming (ASP) is one of the most widely used non-monotonic reasoning paradigms, allowing to efficiently compute solutions to problems involving defaults and exceptions [Gelfond (2008)]. A problem is represented in terms of a logic program, that is if-then clauses containing negation-as-failure (NAF) literals which express exception conditions for the applicability of clauses. The solutions to the problem are then given by the declarative answer set semantics [Gelfond and Lifschitz (1991)] for the logic program. ASP is applied in a variety of different areas, ranging from bioinformatics [Baral et al. (2004)] over music composition [Boenn et al. (2011)] to multi-agent systems [Son et al. (2009)]. Answer set solvers like clingo [Gebser et al. (2011)], smodels [Niemelä et al. (2000)], and DLV [Eiter et al. (1997)] provide efficient tools for the computation of answer sets.

Especially with respect to the application of ASP in real-world scenarios involving non-experts, it is useful to have an explanation as to why something does or does not belong to a solution. As an example, consider a medical decision support system which operates on a logic program comprising general treatment decision rules along with facts about a patient’s medical conditions. The answer sets of such a logic program contain treatment suggestions or exclusions for the given patient. For a doctor using this medical decision support system, it is important to know why the system suggests a certain treatment as well as why a treatment is not part of a solution. In ASP terms, the doctor needs a justification as to why a literal is or is not contained in an answer set. This is particularly important if the doctor’s intended treatment decision disagrees with the system’s suggestion. However, no matter whether an answer set is computed by an answer set solver or by hand using trial and error, it is a plain set of literals. That is to say that an answer set does not provide any justification as to why certain literals are part of it whereas others are not.

In this paper we present two methods for justifying literals with respect to an answer set of a consistent logic program by applying argumentation theory, another widely used technique in the field of non-monotonic reasoning. Here, we use Assumption-Based Argumentation (ABA) [Bondarenko et al. (1997), Dung et al. (2009)], a structured argumentation framework which constructs arguments from rules and assumptions, and attacks from the notion of contrary of assumptions. ABA is particularly suitable for our purpose as it was inspired by logic programming, default logic and other non-monotonic reasoning approaches [Bondarenko et al. (1997)] which are closely related to ASP. Due to this connection, it is straight forward to construct the translated ABA framework of a logic program, i.e. the ABA framework expressing the same problem as the logic program. One of the semantics for ABA frameworks is the stable extension semantics [Bondarenko et al. (1997), Dung (1995b)], which has its roots in the stable model semantics for logic programs. Since the answer set semantics is based on the stable model semantics as well, every answer set of a logic program corresponds to a stable extension of the translated ABA framework, and vice versa. We make use of this connection to justify literals with respect to a given answer set of a consistent logic program by means of arguments in the context of the corresponding stable extension of the translated ABA framework.

The first justification approach, an Attack Tree, expresses how to construct an argument for the literal in question (the supporting argument) as well as which arguments attack the argument for the literal in question (the attacking arguments); the same information is provided for all arguments attacking the attacking arguments, and so on. The second justification approach, an ABA-Based Answer Set (ABAS) Justification of a literal, represents the same information as an Attack Tree, but expressed in terms of literals rather than arguments. An ABAS Justification comprises facts and NAF literals necessary to derive the literal in question (the “supporting literals”) as well as information about literals which are in conflict with the literal in question (the “attacking literals”). The same information is provided for all supporting and attacking literals of the literal in question, for all their supporting and attacking literals, and so on.

An Attack Tree is a (possibly infinite) tree with nodes holding arguments, where the argument held by a child node attacks the argument held by the parent node. Since arguments are trees themselves, indicating which components (rules, assumptions) are necessary to construct the argument, an Attack Tree has a two-layered structure: It is a tree consisting of trees. An ABAS Justification is the flattened version of an Attack Tree, containing literal-pairs which express the different parent-child relations expressed in an Attack Tree. The relation between arguments in the Attack Tree is represented in terms of literal-pairs which are in an attack relation; the relation between components of an argument is represented in terms of literal-pairs which are in a support relation. An ABAS Justification can also be interpreted as a graph, where every literal occurring in a pair forms a node in the graph. The graph has a support edge between two literal-nodes if these two literals occur as a literal-pair in a support relation in the ABAS Justification. Analogously, the graph has an attack edge between two literal-nodes if these two literals occur as a literal-pair in an attack relation in the ABAS Justification.

Our justification approaches have two purposes. On the one hand, they contribute to the field of answer set justification research, which has been identified as an important but not yet sufficiently studied research area [Lacave and Diez (2004), Brain and De Vos (2008)]. The reason to use ABA for explanations instead of constructing justifications from the logic program straight away in terms of simple derivations or proof trees [Arora et al. (1993), Ferrand et al. (2012)] is that ABA is conceptually close to logic programs but provides additional concepts and constructs which have been identified as useful for explanation purposes, such as the notion of arguments and attacks [Bench-Capon et al. (1991), Moulin et al. (2002)]. On the other hand, our justification approaches also provide a theoretical impact with respect to the relation between non-monotonic reasoning systems. Even though ASP has been applied to argumentation theory in the sense that an argumentation framework can be equivalently expressed in ASP [Toni and Sergot (2011), Thimm and Kern-Isberner (2008)], the converse has not been discussed in the literature. To the best of our knowledge, Attack Trees and ABAS Justifications are the first approaches applying argumentation theory for ASP, with the exception of

  • early work on manually constructing arguments and attacks from a logic program according to Toulmin’s argument scheme, which then serves as an explanation of the logic program [Bench-Capon et al. (1991)]; and

  • Argumentation-Based Answer Set Justification [Schulz et al. (2013)] which can be considered as a predecessor of ABAS Justifications. Similarly to ABAS Justifications, Argumentation-Based Answer Set Justifications are constructed from arguments and attacks between them, but using the ASPIC+ argumentation framework [Prakken (2010)] instead of ABA.

The paper is organized as follows: In Section 2 we recall some key concepts of ASP and ABA and give some preliminary definitions and results building upon this background. Furthermore, we give a motivating (medical) example for ABAS Justifications. In Section 3 we show how to translate a logic program into an ABA framework and prove their correspondence with respect to the stable model semantics. In Section 4 we introduce Attack Trees drawn from a translated ABA framework as a first justification method, show their relationship with abstract dispute trees for ABA [Dung et al. (2006)], and characterize the explanation they provide as an admissible fragment of the answer set in question. Based on Attack Trees, we define two forms of ABAS Justifications: Basic ABA-Based Answer Set Justifications (Section 5) demonstrate the main idea of flattening Attack Trees, yielding a justification in terms of literals and their relations. Labelled ABA-Based Answer Set Justifications (Section 6) are a more elaborate version of Basic ABA-Based Answer Set Justifications, following the same flattening strategy, but additionally using labels to solve some deficiencies of the basic variant. In Section 7 we compare ABAS Justifications to related work and in Section 8 we conclude.

2 Background and Preliminaries

This section describes all necessary background about ASP and ABA to understand the definitions of ABAS Justifications. In addition, we prove some core results about concepts in ASP and in ABA which have not or have only partially been considered in the literature before. We then use these to prove our main results in the remainder of the paper.

2.1 Answer Set Programming

A logic program is a (finite) set of clauses of the form with . All are classical ground111As conventional in the logic programming literature, clauses containing variables are shorthand for all their ground instances. literals, i.e. atoms or negated atoms , and are negation-as-failure (NAF) literals. The classical literal on the left-hand side of the arrow is referred to as the clause’s head, all literals on the right of the arrow form the body of the clause. If the body of a clause is empty, the head is called a fact.

Notation 1

The letter is used for a literal in general, i.e. a classical literal or a NAF literal . denotes the Herbrand Base of , that is the set of all ground atoms of . is the set of all classical literals of , and consists of all NAF literals of . We say that is the corresponding classical literal of a NAF literal .

In the following, we recall the concept of answer sets as introduced in [Gelfond and Lifschitz (1991)]. Let be a logic program not containing NAF literals. The answer set of , denoted , is the smallest set such that:

  1. for any clause in : if then ; and

  2. if contains complementary classical literals and .

For a logic program , possibly containing NAF literals, and any set , the reduct is obtained from by deleting:

  1. all clauses with in their bodies where , and

  2. all NAF literals in the remaining clauses.

Then, is an answer set of if it is the answer set of the reduct , i.e. if . A logic program is inconsistent if it has no answer set or if its only answer set is ; otherwise it is consistent. In the remainder of the paper, and if not stated otherwise, we assume that logic programs are consistent.

Note that answer sets only contain classical literals. However, if for an answer set of and some classical literal , then is considered satisfied with respect to . Thus, we introduce the following new definition.

Definition 1 (Answer Set with NAF literals)

Let be a logic program and let be a set of classical literals. consists of all NAF literals whose corresponding classical literal is not contained in . If is an answer set of , then is an answer set with NAF literals of .

Intuitively, consists of all literals in an answer set plus all NAF literals which are satisfied with respect to . For the purpose of proving correspondence between answer sets of a logic program and stable extensions of an argumentation framework in Section 3, we introduce a new reformulation of answer sets in terms of modus ponens and prove correspondence with the original definition:

Notation 2

denotes derivability using modus ponens on as the only inference rule. , for a logic program and , denotes the logic program . When used on such , treats NAF literals purely syntactically as in [Eshghi and Kowalski (1989)] and treats facts as where for any logic program and any set of NAF literals .

Lemma 1

Let be a consistent logic program and let be a set of classical literals.

  • is an answer set of if and only if .

  • is an answer set with NAF literals of if and only if .

We prove both items:

  • If is an answer set of then . This means that there exists a clause such that . It follows that there exists a clause such that and . Then, by Definition 1, . Thus, .
    For the other direction, if then (1) or (2) there exists a clause such that and . In the first case, is a NAF literal which should not be part of . This is satisfied since and therefore . In the second case, since contains no clause with a NAF literal in its head it follows that , i.e. . Then, by definition of reduct, . Since , , thereby satisfying the condition of an answer set for to be in .

  • If is an answer set with NAF literals then by Definition 1, . Then, by the first item . By Notation 2, and therefore for any logic program . Thus, not restricting the conclusions of modus ponens to yields .
    For the other direction, if then by the proof of the first item or where is an answer set. Thus, is equivalent to , satisfying Definition 1.

2.2 An intuitive example of ASP

Let Dr. Smith be an ophtalmologist (an eye doctor) and let one of his patients be Peter, who is diagnosed by Dr. Smith as being shortsighted. Based on this diagnosis, Dr. Smith has to decide on the most suitable treatment for Peter, taking into account the additional information he has about his patient, namely that Peter is afraid to touch his own eyes, that he is a student, and that he likes to do sports. Based on this information and his specialist knowledge, Dr. Smith decides that the most appropriate treatment for Peter’s shortsightedness is laser surgery. Dr. Smith now checks whether this decision is in line with the recommendation of his decision support system, which is implemented in ASP.

Example 1

The following logic program represents the decision support system used by Dr. Smith. It encodes some general world knowledge as well as an ophtalmologist’s specialist knowledge about the possible treatments of shortsightedness. also captures the additional information that Dr. Smith has about his shortsighted patient Peter.

afraidToTouchEyes

has only one answer set .

To Dr. Smith’s surprise, the answer set computed by the decision support system contains the literal but not , suggesting that Peter should get intraocular lenses instead of having laser surgery. Dr. Smith now finds himself in the difficult situation to determine whether to trust his own treatment decision or whether to take up the system’s suggestion even without understanding it. Providing Dr. Smith with an explanation of the system’s treatment suggestion or with an explanation as to why his own intended decision might be wrong would make it considerably easier for Dr. Smith to decide whether to trust himself or the decision support system.

We will use this example of Dr. Smith and his patient Peter to demonstrate our explanation approaches and to show how they can be applied to explain the solutions of a decision support system which is based on ASP.

2.3 ABA frameworks

Much of the literature on argumentation in Artificial Intelligence focuses on two kinds of argumentation frameworks. Abstract Argumentation

[Dung (1995b)] assumes that a set of abstract entities (the arguments) are given along with an attack relation between them. In contrast, structured argumentation frameworks such as [Prakken (2010), García and Simari (2004), Governatori et al. (2004)] provide mechanisms for the construction of arguments from given knowledge, mostly in the form of rules, and for identifying the attack relation between arguments based on the structure of arguments. We will here focus on the structured argumentation framework of [Bondarenko et al. (1997), Dung et al. (2009)] called Assumption-Based Argumentation (ABA).

An ABA framework [Dung et al. (2009)] is a tuple , where

  • is a deductive system with
    a formal language and
    a set of inference rules of the form such that and all are sentences in ;

  • is a non-empty set of assumptions;

  • is a total mapping from into defining the contrary of each assumption, where denotes the contrary of .

Note that in this paper we use the same notation for inference rules in ABA and for clauses in a logic program. This will facilitate the presentation of our methods later. We also adopt the logic programming terminology of “head”, “body”, “fact”, and (see Notation 2) for ABA frameworks. The following definitions are restricted to flat ABA frameworks, where assumptions do not occur as the head of inference rules, as we only need this kind of framework for our purposes.

In this paper we use a notion of ABA argument which is slightly different from the definitions in the ABA literature, in that an ABA argument as defined here comprises not only the set of assumptions supporting this argument as in standard ABA, but also the set of facts used in the construction of this argument.

Definition 2 (ABA Argument)

Let be an ABA framework. An argument for (the conclusion) supported by a set of assumption-premises and a set of fact-premises is a finite tree, where every node holds a sentence in , such that

  • the root node holds ;

  • for every node

    • if is a leaf then holds either an assumption or a fact;

    • if is not a leaf and holds the sentence , then there is an inference rule () and has children, holding respectively;

  • is the set of all assumptions held by leaves;

  • is the set of all facts held by leaves.

We now define some further terminology for special kinds of arguments and for naming arguments in general.

Notation 3

An argument for supported by and is denoted . We often use a unique name to denote an argument, e.g. is an argument with name . With an abuse of notation, the name of an argument sometimes stands for the whole argument, for example denotes the argument . An argument of the form is called assumption-argument, and similarly an argument of the form is called fact-argument. Given some argument with and , we say that is the assumption-argument of the assumption-premise of argument and that is the fact-argument of the fact-premise of .

Definition 2 generates the notion of argument in [Dung et al. (2009)]: If is an argument according to Definition 2, then is an argument in [Dung et al. (2009)]. Conversely, if is an argument in [Dung et al. (2009)], then there exists some such that is an argument according to Definition 2.

ABA arguments can be naturally formulated in terms of , as follows:

Lemma 2

Let be an ABA framework. is an argument in if and only if and .

This follows directly from the definition of arguments.

The attack relation between arguments defined here is a slight variation of the notion in [Dung et al. (2009)], as it considers arguments with both assumption- and fact-premises.

Definition 3 (Attacks)

An argument attacks an argument on the assumption-premise if and only if and . Equivalently, we say that is attacked by or that is an attacker of .
A set of arguments attacks an argument if and only if there is an argument which attacks . A set of arguments attacks a set of arguments if and only if attacks some argument .

This definition of attack is purely based on the notion of contrary of assumptions, i.e. fact-premises only occur as part of the argument but do not directly influence the attack relation. Since arguments as introduced here and in [Dung et al. (2009)] correspond, the attack relation in Definition 3 directly correspond to attacks in [Dung et al. (2009)]: If an argument attacks an argument according to Definition 3, then attacks as defined in [Dung et al. (2009)]. Conversely, if attacks as defined in [Dung et al. (2009)], then there exist such that attacks according to Definition 3.

2.4 ABA semantics

The semantics of argumentation frameworks are given in terms of extensions, i.e. sets of arguments deemed to be “winning”. For our purposes we focus on the admissible and on the stable extension semantics introduced in [Dung (1995b)] for Abstract Argumentation and in [Bondarenko et al. (1997)] for ABA. Let be an ABA framework and let be a set of arguments in .

  • defends an argument if and only if attacks all attackers of .

  • is an admissible extension of if and only if does not attack itself and defends all arguments in .

  • is a stable extension of if and only if does not attack itself and attacks each argument in which does not belong to , or, equivalently, if and only if .

Admissible extensions can also be defined using trees of attacking arguments.

An abstract dispute tree [Dung et al. (2006)] for an ABA argument is a (possibly infinite) tree such that:

  1. Every node in the tree is labelled by an argument and is assigned the status of proponent or opponent node, but not both.

  2. The root is a proponent node labelled by .

  3. For every proponent node labelled by an argument and for every argument attacking , there exists a child of which is an opponent node labelled by .

  4. For every opponent node labelled by an argument , there exists exactly one child of which is a proponent node labelled by an argument which attacks .

  5. There are no other nodes in the tree except those given by 1-4 above.

An abstract dispute tree is admissible [Dung et al. (2009)] if and only if no argument labels both a proponent and an opponent node. It has been shown that the set of all arguments labelling proponent nodes in an admissible dispute tree is an admissible extension [Dung et al. (2007)]. We will use this result to characterize our justification approaches.

We now look at some properties of the stable extension semantics which will be used throughout the paper. Lemma 3 characterizes a stable extension in terms of the assumption-premises of arguments contained in this stable extension as all arguments not attacked by this stable extension.

Lemma 3

Let be an ABA framework and let be a set of arguments in . is a stable extension of if and only if where .

Similar to the proof of Theorem 3.10 in [Bondarenko et al. (1997)]: By the definition of stable extension, is a stable extension if and only if . Then, by Definitions 2 and 3, and by Definition 3. This can be split into where .

After defining a stable extension in terms of the properties of its arguments, we now take a closer look at conditions for an argument to be or not to be contained in a stable extension. The following lemma characterizes the arguments contained in a stable extension: An argument is part of a stable extension if and only if the assumption-arguments of all its assumption-premises and the fact-arguments of all its fact-premises are in this stable extension.

Lemma 4

Let be an ABA framework and let be a stable extension of . if and only if it holds that and it holds that .

Note that fact-arguments are always part of a stable extension as they cannot be attacked, so we only focus on assumption-arguments.

  • From left to right: If then by Lemma 3 , . Consequently, is not attacked by , so by definition of stable extension .

  • From right to left: If it holds that then by definition of stable extension no is attacked by , so for none of the there exists an . Thus, is not attacked by , so .

The following lemma characterizes conditions for an argument not to be in a given stable extension: An argument is not part of a stable extension if and only if the assumption-argument of one of its assumption-premises is not in this stable extension:

Lemma 5

Let be an ABA framework and let be a stable extension of . if and only if such that .

  • From left to right: If then is attacked by on some . Consequently, is attacked by , so .

  • From right to left: If such that then is attacked by , meaning that there is some . Thus, is attacked by on , so .

3 Translating a logic program into an ABA framework

In order to use ABA for the justification of literals with respect to an answer set of a consistent logic program, the logic program has to be expressed as an ABA framework first.

3.1 The translation

We use the approach of [Bondarenko et al. (1997)] for translating a logic program into an ABA framework, where the clauses of a logic program form the set of ABA rules and NAF literals are used as assumptions in ABA.

Definition 4 (Translated ABA framework)

Let be a logic program. is the translated ABA framework of where:

  • for every :

Note that the clauses of a logic program can be directly used as rules in the translated ABA framework as we utilize the same notation for both of them. Note also that translated ABA frameworks are always flat since NAF literals do not occur in the head of clauses of a logic program.

Example 2

The following logic program will serve as a running example throughout the paper, where :

The translated ABA framework of is with:

The following fourteen arguments can be constructed in , including eight assumption-arguments ( - ) and one fact-argument ():














The attacks between these arguments are given as a graph in Figure 1. An arrow from a node to a node in the graph represents that the argument held by attacks the argument held by .

Figure 1: Attacks between arguments in the translated ABA framework of (see Example 2) represented by arrows between the arguments. The three arguments at the top (, , ) are neither attacked nor do they attack other arguments, so there are no arrows connecting them with other arguments.

3.2 Correspondence between Answer Sets and Stable Extensions

In this section, we describe the relationship between answer sets of a logic program and stable extensions of the translated ABA framework. This connection will be used for our justification approaches. Theorem 1 states that an answer set with NAF literals consists of the conclusions of all arguments in the “corresponding” stable extension. Conversely, Theorem 2 expresses that a stable extension consists of all arguments supported by NAF literals which are satisfied with respect to the “corresponding” answer set. Note that part of this correspondence has been stated without a formal proof in [Bondarenko et al. (1997)].

Theorem 1

Let be a logic program and let . Let be a set of arguments in and let be the set of all conclusions of arguments in .
is a stable extension of if and only if is an answer set with NAF literals of .

  • is a stable extension of

  • iff with
    (by Lemma 3)

  • iff with
    (by Lemma 2)

  • iff with
    (by Definition 4)

  • iff with
    and
    (by construction of , see above)

  • iff with
    and (by Definition 1)

  • iff and
    (substituting in )

  • iff is an answer set with NAF literals of (by Lemma 1)

Theorem 2

Let be a logic program and let . Let be a set of classical literals and let be the set of arguments in whose assumption-premises are in .
is an answer set of if and only if is a stable extension of .

  • is an answer set of

  • iff with
    (by Lemma 1 and Definition 1)

  • iff with
    (by Definition 4)

  • iff with
    (by Lemma 2)

  • iff with
    (by Lemma 1)

  • iff with
    (by Lemma 2)

  • iff with
    and (by construction of , see above)

  • iff with
    and (by Lemma 3)

  • iff and

  • iff is a stable extension of (by Lemma 3)

Example 3

The logic program from Example 2 has two answer sets: and . The respective sets of satisfied NAF literals are and . Considering the attacks between arguments in the translated ABA framework (see Figure 1), two stable extensions can be determined for : , , , and have to be part of all stable extensions as they are not attacked. Then, , , and cannot be in any stable extension as they are attacked by . Consequently, is part of all stable extensions since it is only attacked by , which is definitely not contained in any stable extension. As and attack each other and are not furthered attacked by other arguments, there are two stable extensions, one containing and the other one containing . The first stable extension also comprises and as attacks all their attackers, whereas the second one additionally comprises and since attacks all their attackers. Thus, the two stable extensions of are and . As expected, the conclusions of arguments in the stable extensions, for