Extension-Based Argumentation Semantics via Logic Programming Semantics with Negation as Failure

Abstract

Extension-based argumentation semantics have been shown to be a suitable approach for performing practical reasoning. Since extension-based argumentation semantics were formalized in terms of relationships between atomic arguments, it has been shown that extension-based argumentation semantics (such as the grounded semantics and stable semantics) can be characterized by logic programming semantics with negation as failure. Recently, it has been shown that argumentation semantics such as the preferred semantics and the CF2 semantics can be characterized in terms of logic programming semantics. In this paper, we make a short overview w.r.t. recent results in the close relationship between extension-based semantics and logic programming semantics with negation as failure. We also show that there is enough evidence to believe that the use of declarative approaches based on logic programming semantics with negation as failure is a practical approach for performing practical reasoning following an argumentation reasoning approach.

-

Argumentation theory is a formal discipline within Artificial Intelligence (AI) where the aim is to make a computer assist in or perform the act of argumentation. During the last years, argumentation has been gaining increasing importance in Multi-Agent Systems (MAS), mainly as a vehicle for facilitating rational interaction (i.e.interaction which involves the giving and receiving of reasons) [ 4, 14 ]. A single agent may also use argumentation techniques to perform its individual reasoning because it needs to make decisions under complex preferences policies, in a highly dynamic environment.

Although several approaches have been proposed for capturing representative patterns of inference in argumentation theory, Dung’s approach, presented in [ 7 ], is a unifying framework which has played an influential role on argumentation research and AI. The kernel of Dung’s framework is supported by four extension-based argumentation semantics (we will refer to them also as abstract argumentation semantics): grounded semantics, stable semantics, preferred semantics, and complete semantics. When Dung introduced his argumentation approach, he proved that it can be regarded as a special form of logic programming with negation as failure. In fact, he showed that the grounded and stable semantics can be characterized by the well-founded and stable model semantics respectively. This result has at least two main implications: 1. It defines a general method for generating metainterpreters for argumentation systems 2. It defines a general method for studying abstract argumentation semantics’ properties in terms of logic programming semantics’ properties. As we can see, the study of abstract argumentation semantics in terms of logic programming semantics has important implications for closing the gap between theoretical results and argumentation systems. Despite these implications, until 2007 the only extension-based argumentation semantics characterized in terms of logic programming semantics were the grounded and stable semantics. Recently, there are novel results which have shown that extension-based argumentation semantics (such as the preferred) semantics can be characterized in terms of logic programming semantics [ 5, 11 ]. In fact, there are results which show that not only a logic programming approach can characterize extension-based argumentation semantics but also it can define new extension based argumentation semantics [ 12 ].

In this paper, we present a survey of recent results w.r.t. the close relationship between extension-based semantics and logic programming semantics with negation as failure. These results are in two directions: 1. The identification of dual characterizations between extension-based argumentation semantics and logic programming semantics. These results represent an extension of Theorem 17 presented in [ 7 ]. These results are based on regarding argumentation frameworks into logic programs. 2. The implementation of logic programming metainterpreters for inferring extension-based argumentation semantics. These metainterpreters are based on the platform of Answer Set Programming (ASP)1 and a characterization of extension-based argumentation semantics in terms of labels (IN, OUT, UNDEC). This labeling process has shown to be a practical approach for defining interactive algorithms for inferring extension-based argumentation semantics [ 10 ]. However, there are results that show that the declarative specification of a labeling process defines an easy approach for computing extension-based argumentation semantics [ 16, 15 ]. 1 Answer Set Programming is a novel approach of logic programming which was suggested by the non-monotonic reasoning community [ 1 ].

The rest of the paper is divided as follows: In x2, the syntax of valid logic programs in ASP is introduced, some basic concepts of the Dung’s argumentation approach are defined and the characterization of extension-based argumentation semantics in terms of the labels: IN, OUT, UNDEC is presented. In x3, some recent results w.r.t. the relationship between extension-based argumentation semantics and logic programming semantics are presented. In x4, some approaches for implementing logic programming metainterpreters for inferring extension-based argumentation semantics are presented. Finally, in the last section some conclusions are presented. 2

Background

In this section, we present some basic concepts on: a) the syntax of logic programs b) extension-based argumentation semantics c) a labeling approach for characterizing extension-based argumentation semantics. 2.1

Syntax of Logic Programs

A signature L is a finite set of elements that we call atoms. A literal is an atom, a (positive literal), or the negation of an atom not a (negative literal). Given a set of atoms fa1; : : : ; ang, we write not fa1; : : : ; ang to denote the set of literals fnot a1; : : : ; not ang. A disjunctive clause is a clause of the form: a1 _ _ am am+1; : : : ; aj ; not aj+1; : : : ; not an where ai is an atom, 1 i n. When n = m and m > 0, the disjunctive clause is an abbreviation of the fact a1 _ _ am > where > is an atom that always evaluate to true. When m = 0 and n > 0 the clause is an abbreviation of ? a1; : : : ; aj ; not aj+1; : : : ; not anwhere ? is an atom that always evaluate to false. Clauses of this form are called constraints (the rest non-constraints). A disjunctive logic program is a finite set of disjunctive clauses.

We denote by LP the signature of P , i.e., the set of atoms that occur in P. Given a signature L, we write P rogL to denote the set of all the programs defined over L. 2.2

Extension-based Argumentation Semantics

We are going to present a short introduction of Dung’s argumentation approach. A fundamental Dung’s definition is the concept called argumentation framework which is defined as follows: Definition 1. [ 7 ] An argumentation framework is a pair AF = hAR; attacksi, where AR is a set of arguments, and attacks is a binary relation on AR, i.e.attacks AR AR.

Following Dung’s reading, we say that A attacks B (or B is attacked by A) if attacks(A; B) holds. Similarly, we say that a set S of arguments attacks B (or B is attacked by S) if B is attacked by an argument in S.

Definition 2. [ 7 ] A set S of arguments is said to be conflict-free if there are no arguments A, B in S such that A attacks B.

Definition 3. [ 7 ] (1) An argument A 2 AR is acceptable with respect to a set S of arguments if and only if for each argument B 2 AR: If B attacks A then B is attacked by S. (2) A conflict-free set of arguments S is admissible if and only if each argument in S is acceptable w.r.t. S.

The (credulous) semantics of an argumentation framework is defined by the notion of preferred extensions.

Definition 4. [ 7 ] A preferred extension of an argumentation framework AF is a maximal (w.r.t. inclusion) admissible set of AF.

Another relevant semantics that Dung introduced is the stable semantics of an argumentation framework which is based in the notion of stable extension. Definition 5. [ 7 ] A conflict-free set of arguments S is called a stable extension if and only if S attacks each argument which does not belong to S.

Dung also defined a skeptical semantics which is called grounded semantics and it is defined in terms of a characteristic function.

FAF (S) = fAj A is acceptable w.r.t. S g Definition 6. [ 7 ] The characteristic function, denoted by FAF , of an argumentation framework AF = hAR; attacksi is defined as follows:

FAF : 2AR ! 2AR Definition 7. [ 7 ] The grounded extension of an argumentation framework AF, denoted by GEAF , is the least fixed point of FAF

Dung defined the concept of complete extension which provides the link between preferred extensions (credulous semantics), and grounded extension (skeptical semantics).

Definition 8. [ 7 ] An admissible set S of arguments is called complete extension if and only if each argument which is acceptable w.r.t. S, belongs to S.

In [ 7 ], a general method for generating metainterpreters in terms of logic programming for argumentation systems was suggested. This is the first approach which regards an argumentation framework as a logic program. This metainterpreter is divided in two units: Argument Generation Unit (AGU), and Argument Processing Unit (APU). The AGU is basically the representation of the attacks upon an argumentation framework and the APU consists of two clauses. In order to define these clauses, let us introduce the predicate d(x), where the intended meaning of d(x) is: “the argument x is defeated” and the predicate acc(x), where the intended meaning of acc(x) is: “the argument x is acceptable”.

(C1) acc(x) (C2) d(x)

not d(x) attack(y; x); acc(y)

The first one (C1) suggests that the argument x is acceptable if it is not defeated and the second one (C2) suggests that an argument is defeated if it is attacked by an acceptable argument. Formally, the Dung’s metainterpreter is defined as follows: Definition 9. Given an argumentation framework AF = hAR; attacksi, PAF denotes the logic program defined by PAF = AP U + AGU where AP U = fC1; C2g and AGU = fattacks(a; b) >j(a; b) 2 attacksg

For each extension E of AF , m(E) is defined as follows:

m(E) = AGU [ facc(a)ja 2 Eg [ fd(b)jb is attacked by some a 2 Eg Based on PAF , Dung was able to characterize the stable semantics and the grounded semantics.

Theorem 1. Let AF be an argumentation framework and E be an extension of AF. Then 1. E is a stable extension of AF if and only if m(E) is an answer set of PAF 2. E is a grounded extension of AF if and only if m(E) [ fnot def eat(a)ja 2 Eg is the well-founded model of PAF

This result is really important in argumentation semantics, in fact it has at least two main implications: 1. It defines a general method for generating metainterpreters for argumentation systems and 2. It defines a general method for studying abstract argumentation semantics’ properties in terms of logic programming semantics’ properties.

As we can see, the study of abstract argumentation semantics in terms of logic programming semantics has important implications. 2.3

Extension-based Argumentation Semantics via Labeling

A common approach for deciding acceptability of arguments is by considering a labeling process. The labeling approach is a suitable approach for characterizing argumentation semantics [ 9, 10 ].

The labeling process is based in a labeling mapping. In this paper, we are going to consider the mapping presented in [ 10 ] which considers three labels: in, out and undec. This mapping is defined as follows: Given an argumentation framework AF = hAR; attacksi, for any argument a 2 AR one can define functions IN (a) , OU T (a) and U N DEC(a) that return true if the argument a is labeled in, out and undec respectively, and false otherwise. Also, the sets IN , OU T and U N DEC can be defined as the sets containing all the arguments in the framework labeled in, out and undec respectively.

A special type of labeling is the reinstatement labeling. A reinstatement labeling is a labeling that, given an Argumentation framework AF = hAR; attacksi and attacks(a; b) if f (a; b) 2 attacks meets the following two properties: 8a 2 AR : OU T (a) = true if f 9b 2 AR : attacks(b; a) ^ IN (b) = true 8a 2 AR : IN (a) = true if f 8b 2 AR : attacks(b; a) then OU T (b) = true

Some authors have shown that by considering a mapping process one can characterize the extension-based argumentation semantics defined by Dung in [ 7 ] and also some other new argumentation semantics that have been defined by the argumentation community. Some of these characterizations are [ 10 ]: – Complete extensions are equal to reinstatement labellings. – Grounded extensions are equal to reinstatement labellings, where the set IN is minimal. That is, there is no other possible reinstatement labeling in the same Argumentation Framework with a set IN 0 such that IN 0 IN . – Preferred extensions are equal to reinstatement labellings, where the set IN is maximal. That is, there is no other possible reinstatement labeling in the same Argumentation Framework with a set IN 0 such that IN IN 0. – Stable extensions are equal to reinstatement labellings, where the set

U N DEC is empty. That is, 8a 2 AR : a 2= U N DEC. – Semi-stable extensions are equal to reinstatement labellings, where the set U N DEC is minimal. That is, there is no other possible reinstatement labeling in the same Argumentation Framework with a set U N DEC0 such that U N DEC0 2 U N DEC.

In the following sections, we are going to present some recent results which extend Theorem 1 and its implications.

Extension-Based Semantics as Logic Programming Semantics with Negation as Failure

In this section, we are going to introduce some recent results which extend Theorem 1. For this aim, we are going to introduce some simple mappings in order to regard argumentation frameworks in terms of logic programs. Definition 10. Let AF = hAR; attacksi be an argumentation framework, then PA1F , PA2F and PA3F are defined as follows:

PA1F = [

f a2AR b:(b;a)2attacks

[ PA2F = [

f a2AR b:(b;a)2attacks

Theorem 2. Let AF be an argumentation framework and E be a set of arguments. Then:

2 We say that c defends a if b attacks a and c attacks b.

– E is the grounded extension of AF iff tr(E) is the well-founded model of

A1F [ A2F [ A3F . – E is a stable extension of AF iff tr(E) is a stable model of

P si1AF [ A2F [ A3F . – E is a preferred extension of AF iff tr(E) is a p-stable model of 1 2 AF [ AF [ A3F .

This theorem was proved in [ 5 ]. Observe that essentially, this theorem is extending Theorem 1 and suggests that one can capture three of the well accepted argumentation semantics in one single logic program and three different logic programming semantics. The interesting part of this kind of results is that one can explore meta-interpreters of these argumentation semantics in terms of solvers of logic programming semantics . Also, one can explore non-monotonic reasoning properties of argumentation semantics in terms of their corresponding logic programming semantics. For instance, a possible research issue in this line is to explore the non-monotonic properties of the preferred semantics via p-stable semantics. It is worth mentioning that the p-stable semantics is based on paraconsistent logics. This suggests that one can characterize the preferred semantics in terms of paraconsistent logics.

The identification of non-monotonic reasoning properties which could represent a good-behavior of an argumentation semantics represents a hot topic since recently the number of new argumentation semantics in the context of Dungs argumentation approach has increased. The new semantics are motivated by the fact that the extension based semantics introduced by Dung in [ 7 ] have exhibited a variety of problems common to the grounded, stable and preferred semantics [ 13, 3 ].

One of the approaches that has been emerging for building new extensionbased argumentation semantics was introduced in [ 3 ]. This approach is based on a solid concept in graph theory: strongly connected components (SCC). In [ 3 ], several alternative argumentation semantics were introduced; however, from them, CF2 is an argumentation semantics that has shown to have good-behavior [ 2 ].

In [ 12 ], an new approach for building argumentation semantics was introduced. In this approach the author suggests to use any logic programming semantics. By considering this approach, the authors were able to characterize the argumentation semantics CF2.

Theorem 3. [ 12 ] Let AF be an argumentation framework and E be a set of arguments. Then, E is a CF2 extension AF iff tr(E) is M M r model of A1F [ A3F .

This theorem suggests that the relationship between the approach presented in [ 3 ] and [ 12 ] is close. In fact, both Theorem 2 and Theorem 3 suggest that not only one can characterize argumentation semantics in terms of logic programming semantics but also one can define new argumentation semantics in terms of logic programming semantics.

4 Inferring Extension-Based Semantics via NonMonotonic

Reasoning Tools

So far, we have shown that logic programming semantics can be a suitable approach for exploring properties of extension-based argumentation semantics and defining new argumentation semantics. In this section, we show that the use of nonmonotic tools represent a potential approach for building intelligent systems based on an argumentation reasoning process. 4.1

Preferred Semantics by Positive Disjunctive Logic Programs

Taking advantage of the mappings presented in Definition 10, in [ 11 ], it was shown that by considering A1F [ A2F as a propositional formula its minimal models characterize the preferred extensions of the given argumentation framework. In fact, by transforming A1F into a positive disjunctive logic program one can characterize the preferred semantics in terms of stable model semantics as follows: Definition 11. Let AF = hAR; attacksi be an argumentation framework ,a 2 AR and attacks(a; b) if f (a; b) 2 attacks. We define the transformation function (a) as follows: (a) = f

[ b:attacks(b;a) fd(a) _ d(b)gg [ f

[ b:attacks(b;a) fd(a)

^ c:attacks(c;b) d(c)gg

Now we define the function in terms of an argumentation framework.

Definition 12. Let AF = hAR; attacksi be an argumentation framework. We define its associated general program as follows:

AF =

(a) [ a2AR Theorem 4. Let AF = hAR; attacksi be an argumentation framework and S AR. S is a preferred extension of AF if and only if compl(S) is a stable model of AF .

This theorem suggest that one can use any disjunctive answer set solver as DLV [ 6 ] for inferring the preferred semantics. It is worth mentioning that by considering PA1F , PA2F and PA3F one can use any answer solver for computing the stable and grounded semantics.

Computing Extension-Based Argumentation Semantics by Labeling

Until now, we have shown that we can infer extension-based argumentation semantics by regarding an argumentation framework as a logic program. However, as we saw in x2.3 some extension-based argumentation semantics can be characterized by considering labeling process. The labeling represents an alternative approach for computing extension-based argumentation semantics in terms of logic programming with negation as failure. In particular, there are results that show that by considering a labeling process one is able to compute the grounded, stable, preferred and complete argumentation semantics in terms of answer set semantics. An outstanding trend of computing such labellings is via answer set solvers.

The following two sections present studies that explore ASP applications that are able to compute various argumentation semantics, as well as decide whether an argument is sceptically or credulously accepted with reference to the chosen semantics. The idea behind these works is to transform an argumentation framework into a single normal logic program that references an argumentation semantics (either preferred, grounded, stable or complete). The answer set of the resulting program is a labeling [ 10 ] that expresses an argument-based extension for the chosen semantics.

Once programs to compute every available semantics are available, a procedure to decide if an argument is sceptically or credulously accepted in the semantic can be introduced. The following mapping between skeptical or credulous arguments, argumentation frameworks and argumentation semantics is defined. Given an argumentation framework AF = hAR; attacksi, an argument a 2 AR, and an argumentation semantics S: a) a is credulously justified if a 2 IN in, at least, one possible labeling that matches the restrictions defined by the semantic S. b) a is sceptically justified if a 2 IN in every possible labeling that matches the restrictions defined by the semantic S. 4.3

First Approach for Implementing an Argumentation MetaInterpreter in ASP

This section presents an approach for implementing an argumentation metainterpreter presented in [ 16 ] based on answer-set semantics to compute admissible, preferred, stable, semi-stable, complete, and grounded extensions.

The following programs are specified given an Argumentation Framework AF = hAR; attacksi, two variables X and Y , the predicate symbol arg that denotes that the variable a is an argument of AF , and the functions IN (X ) , OU T (X ) defined before.

The program formed by the set of rules CF is able to compute complete extensions. The set of rules CF is as follows:

IN(x) arg(x); not OUT (x). OUT (x) arg(x); not IN(x).

? IN(x); IN(Y ); defeat(X; Y ). defeat(X; Y ) (X; Y ) 2 attacks.

The program formed by the set of rules CF [ stable is able to compute stable extensions. The set of rules stable is as follows:

defeated(X) IN(Y ); attack(Y; X) 2 attacks.

The program formed by the set of rules CF [ compute complete extensions. The set of rules OUT (X); not defeated(X).

stable [ complete is able to complete is as follows: not defended(X) defeat(Y; X); not defeated(Y ). OUT (X); not not defended(X). Computing grounded, preferred and semi-stable extensions is a bit harder, because they require a labeling that maximizes or minimizes the elements in a set. In order to compute these extensions, this approach makes use of a stratified program [ 1 ]. This program defines the order operator ( < ) between the arguments in the domain, and derives predicates for minimal, maximal and successor. For doing so, the following program, < is defined: lt(X; Y ) arg(X); arg(Y ); X < Y . nsucc(X; Z) lt(X; Y ); lt(Y; Z). succ(X; Y ) lt(X; Y ); not nsucc(X; Y ). ninf(Y ) lt(X; Y ).

inf(X) arg(X); not ninf(X). nsup(X) lt(X; Y ). sup(X) arg(X); not nsup(X). Using the program above, the predicate def end(X ) is defined. This predicate is derived if for a given Argumumentation Framework AF = hAR; attacksi, each argument Y : Y 2 AR def end(X; Y ). In order ensure that def end(X; Y ) is checked for every available argument, variable Y ranges from the minimal to the maximal using successor relations. The program def end that defines the above mentioned predicate, is as follows: defend upto(X; Y ) inf(Y ); arg(X); not defeat(Y; X). defend upto(X; Y ) inf(Y ); in(Z); defeat(Z; Y ); defeat(Y; X). defend upto(X; Y ) succ(Z; Y ); defend upto(X; Z); not defeat(Y; X). defend upto(X; Y ) succ(Z; Y ); defend upto(X; Z); in(V ); defeat(V; Y ); defeat(Y; X). defend(X) sup(Y ); defend upto(X; Y ).

The program formed by the set of rules < [ def end [ grounded extensions. The set of rules ground is as follows: ground computes in(X) defended(X).

Computing both preferred and semi-stable extensions will make use of the programs < and def end defined above. However this process is a bit more complicated, because it requires computing maximal sets instead of minimal ones. For tackling this issue the analyzed approach makes use of a saturation technique. This technique consists in building a labeling S such that every other possible labeling T that complies with certain conditions (either maximal I N or U N DEC labels) does not characterize an admissible extension.

First of all, in order to model the maximal sets that both preferred and semistable extensions require, the program def end presented above is slightly modified, to include predicates inN and outN . The meaning of the predicates varies depending the type of semantic computed (either preferred or semi-stable) so they are defined later, in the program associated to this semantics. The program undef eated is defined as follows: undefeated upto(X; Y ) inf(Y ); outN(X); outN(Y ). undefeated upto(X; Y ) inf(Y ); outN(X); not defeat(Y; X). undefeated upto(X; Y ) succ(Z; Y ); undefeated upto(X; Z); outN(Y ). undefeated upto(X; Y ) succ(Z; Y ); undefeated upto(X; Z); not defeat(Y; X).

undefeated(X) sup(Y ); undefeated upto(X; Y ).

The program formed by the sets of rules adm [ computes preferred extensions. The set of rules < [ undef eated [ pref erred pref erred is as follows: inf(Y ); out(Y ); outN(Y ).

Second Approach for Implementing an Argumentation

MetaInterpreter in ASP

The work presented in this section[ 15 ] is an approach for computing Dung’s standard argumentation semantics as well as semi-stable semantics via ASP.

The base of all this programs is a set of rules defining the Argumentation Framework, that is, both the available arguments and the attack relations between them. Given an argumentation framework AF = hAR; attacksi, and two constants a and b the following ASP program , known as AF can be defined: ag(a) . for any argument a 2 AR def(a; b). for any pair (a; b) 2 attacks

The program formed by the set of rules AF [ Complete is able to compute complete extensions. Given two variables X and Y , the predicate symbols ng and arg and the functions I N (x); OU T (x); U N DEC(x) defined before, the set of rules Complete is as follows:

IN(x) ag(x); not ng(x). ng(x) IN(y); def(y; x). ng(x) UNDEC(y); def(y; x). OUT (x) IN(y); def(y; x). UNDEC(x) ag(x); not IN(x) ; not OUT (x).

The program formed by the set of rules AF [ Complete [ Stable is able to compute stable extensions. The set of rules Stable is as follows: ? UNDEC(x)

Computing grounded, preferred and semi-stable extensions is a bit harder, because it implies the need to minimize or maximize the elements in certain sets. In order to be able to compute such semantics, the following program, known as AF M AX is defined: m1(Lt) L. for any set of arguments Lt : 8a 2 LtIN(a) [ UNDEC(a) m2(Lt; j) >. cno(j) >. 1 j where is the number of possible labellings in the framework, and Lt is a set of arguments labeled IN or UNDEC in the labeling number j. i(Lt) for any set of arguments Lt : 8a 2 Lt IN(a) u(Lt) for any set of arguments Lt : 8a 2 Lt UNDEC(a) The program formed by the set of rules AF [ AFM AX [ Complete [ P ref erred is able to compute preferred extensions.. The set of rules P ref erred is as follows: c?(Y ) d(Ycn);on(oYt)c;(mY1)(.X); i(X); not m2(X; Y ). d(Y ) m2(X; Y ); i(X); not m1(X).

The program formed by the set of rules AF [ AFM AX [ Complete [ Grounded is able to compute grounded extensions. The set of rules Grounded is as follows: c?(Y ) c(Yc)n;on(oYt)d;(mY1)(.X); i(X); not m2(X; Y ). d(Y ) m2(X; Y ); i(X); not m1(X).

The program formed by the set of rules AF [ AFM AX [ semi stable is able to compute semi-stable extensions.

The set of rules semi stable is as follows: c(Y ) cno(Y ); m1(X); u(X); not m2(X; Y ). d(Y ) m2(X; Y ); u(X); not m1(X). ? c(Y ); not d(Y ).

Complete [

Discussion w.r.t. Label Process

Labeling provides an easy and intuitive approach to argumentation theory. It is based on simple and easy principles that are simpler to explain and understand than extension-based approaches.

Computing the labels that are to be assigned to nodes via an ASP program allows to build and interpreter that processes the Argumentation Framework as input, in contrast to using a fixed logic program which depends on the Argumentation Framework to process. In this sense, the interpreter is easier to understand, extend and debug. Moreover, it eases the process of formally proving the correspondence between answer sets and extensions. Finally, having an interpreter which is independent of the Argumentation Framework allows to easily change the framework without having to re-generate the logic program. However, it must be noted that a full decoupling between the input Argumentation Framework and the programs used to compute its labellings has not been achieved. Both works present programs that are bounded to the Argumentation Framework when computing grounded, preferred and semi-stable extension. In the first work analyzed if the Argumentation Framework changes, predecessor, successor and maximal properties of arguments must be re-built, whereas in the second one constant must be updated. 5

Conclusions

In this paper, we have presented a survey of resent results w.r.t. the dual relationship between extension-based argumentation semantics and logic programming semantics (see x3). We have presented as well results that show that answer set programming is suitable approach for building Argumentation MetaInterpreters (see x4). We have presented two approaches for exploring extension-based argumentation semantics in terms of logic programming. On the one hand, the first approach [ 16 ] presents a more complex but more versatile code due to the usage of the stratified programming and saturation techniques. On the other hand, the second one [ 15 ] presents a more simple code, but it has to be meta-coded by an external program due to being bound to the number of available arguments in the argumentation framework. Both approaches are based on mapping the argumentation framework to a labeling system, this facilitates the computational treatment of the argumentation semantics in terms of declarative specifications. There are still several open issues to explore in the close relationship between argumentation theory and logic programming with negation as failure. One of the most appealing issues is exploring the inference of CF2 semantics in terms of answer set models.

References

1. C. Baral . Knowledge Representation, Reasoning and Declarative Problem Solving . Cambridge University Press, Cambridge, 2003 .

2. P. Baroni and M. Giacomin . On principle-based evaluation of extension-based argumentation semantics . Artificial Intelligence. , 171 ( 10 -15): 675 - 700 , 2007 .

3. P. Baroni , M. Giacomin , and G. Guida. SCC-recursiveness: a general schema for argumentation semantics . Artificial Intelligence , 168 : 162 - 210 , October 2005 .

4. T. J. M. Bench-Capon and P. E. Dunne . Argumentation in artificial intelligence. Artificial Intelligence , 171 ( 10 -15): 619 - 641 , 2007 .

5. J. L. Carballido , J. C. Nieves , and M. Osorio . Inferring Preferred Extensions by Pstable Semantics . Iberoamerican Journal of Artificial Intelligence (Inteligencia Artificial) ISSN : 1137 - 3601 , 13 ( 41 ): 38 - 53 , 2009 (doi: 10.4114/ia.v13i41.1029).

6. S. DLV . Vienna University of Technology. http://www.dbai.tuwien.ac.at/proj/dlv/, 1996 .

7. P. M. Dung . On the acceptability of arguments and its fundamental role in nonmonotonic reasoning, logic programming and n-person games . Artificial Intelligence , 77 ( 2 ): 321 - 358 , 1995 .

8. G. Governatori , M. J. Maher , G. Antoniou, and D. Billington . Argumentation semantics for defeasible logic . J. Log. Comput. , 14 ( 5 ): 675 - 702 , 2004 .

9. H. Jakobovits and D. Vermeir . Robust semantics for argumentation frameworks . Journal of logic and computation , 9 ( 2 ): 215 - 261 , 1999 .

10. S. Modgil and M. Caminada . Argumentation in Artificial Intelligence, chapter Proof Theories and Algorithms for Abstract Argumentation Frameworks , pages 105 - 129 . Springer, 2009 .

11. J. C. Nieves , M. Osorio , and U. Corte´s. Preferred Extensions as Stable Models . Theory and Practice of Logic Programming , 8 ( 4 ): 527 - 543 , July 2008 .

12. J. C. Nieves , M. Osorio , and C. Zepeda . Expressing Extension-Based Semantics based on Stratified Minimal Models . In H. Ono, M. Kanazawa , and R. de Queiroz, editors, Proceedings of WoLLIC 2009 , Tokyo, Japan, volume 5514 of FoLLI-LNAI subseries, pages 305 - 319 . Springer Verlag, 2009 .

13. H. Prakken and G. A. W. Vreeswijk . Logics for defeasible argumentation . In D. Gabbay and F. Gu ¨nthner, editors, Handbook of Philosophical Logic , volume 4 , pages 219 - 318 . Kluwer Academic Publishers, Dordrecht/Boston/London, second edition, 2002 .

14. I. Rahwan and P. McBurney . Argumentation technology: Introduction to the special issue . IEEE Intelligence Systems , 22 ( 6 ): 21 - 23 , 2007 .

15. K. N. Toshiko Wakaki . New Frontiers in Artificial Intelligence , volume 5447 /2009 of Lecture Notes in Computer Science, pages 254 - 269 . 2009 .

16. S. W. Uwe Egly , Sarah Alice Gaggl. Answer-set programming encodings for argumentation frameworks . Technical report, DBAI , 2008 .