Dung's famous abstract argumentation frameworks represent the core formalism for many problems and applications in the field of argumentation which significantly evolved within the last decade. Recent work in the field has thus focused on implementations for these frameworks, whereby one of the main approaches is to use Answer-Set Programming (ASP). While some of the argumentation semantics can be nicely expressed within the ASP language, others required rather cumbersome encoding techniques. Recent advances in ASP systems, in particular, the metasp optimization frontend for the ASP-package gringo/claspD provides direct commands to filter answer sets satisfying certain subset-minimality (or -maximality) constraints. This allows for much simpler encodings compared to the ones in standard ASP language. In this paper, we experimentally compare the original encodings (for the argumentation semantics based on preferred, semi-stable, and respectively, stage extensions) with new metasp encodings. Moreover, we provide novel encodings for the recently introduced resolution-based grounded semantics. Our experimental results indicate that the metasp approach works well in those cases where the complexity of the encoded problem is adequately mirrored within the metasp approach.

Authors

• 12 publications
• 3 publications
• 3 publications
• 39 publications
• Improved Answer-Set Programming Encodings for Abstract Argumentation

The design of efficient solutions for abstract argumentation problems is...
07/23/2015 ∙ by Sarah A. Gaggl, et al. ∙ 0

• Solving Set Optimization Problems by Cardinality Optimization via Weak Constraints with an Application to Argumentation

Optimization - minimization or maximization - in the lattice of subsets ...
12/22/2016 ∙ by Wolfgang Faber, et al. ∙ 0

• Harnessing Incremental Answer Set Solving for Reasoning in Assumption-Based Argumentation

Assumption-based argumentation (ABA) is a central structured argumentati...
08/09/2021 ∙ by Tuomo Lehtonen, et al. ∙ 0

• ConArg: a Tool to Solve (Weighted) Abstract Argumentation Frameworks with (Soft) Constraints

ConArg is a Constraint Programming-based tool that can be used to model ...
12/12/2012 ∙ by Stefano Bistarelli, et al. ∙ 0

• Web-based Argumentation

Assumption-Based Argumentation (ABA) is an argumentation framework that ...
12/14/2016 ∙ by Kenrick, et al. ∙ 0

• Modeling Stable Matching Problems with Answer Set Programming

The Stable Marriage Problem (SMP) is a well-known matching problem first...
02/28/2013 ∙ by Sofie De Clercq, et al. ∙ 0

• Encoding Higher Level Extensions of Petri Nets in Answer Set Programming

06/15/2013 ∙ by Saadat Anwar, et al. ∙ 0

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

In Artificial Intelligence (AI), the area of argumentation (the survey by Bench-Capon and Dunne [3] gives an excellent overview) has become one of the central issues during the last decade. Although there are now several branches within this area, there is a certain agreement that Dung’s famous abstract argumentation frameworks (AFs) [7] still represent the core formalism for many of the problems and applications in the field. In a nutshell, AFs formalize statements together with a relation denoting rebuttals between them, such that the semantics gives a handle to solve the inherent conflicts between statements by selecting admissible subsets of them, but without taking the concrete contents of the statements into account. Several semantical principles how to select those subsets have already been proposed by Dung [7] but numerous other proposals have been made over the last years. In this paper we shall focus on the preferred [7], semi-stable [4], stage [17], and the resolution-based grounded semantics [1]. Each of these semantics is based on some kind of -maximality (resp. -minimality) and thus is well amenable for the novel metasp concepts which we describe below.

Let us first talk about the general context of the paper, which is the realization of abstract argumentation within the paradigm of Answer-Set Programming (see [16] for an overview). We follow here the ASPARTIX111See http://rull.dbai.tuwien.ac.at:8080/ASPARTIX for a web front-end of ASPARTIX. approach [11], where a single program is used to encode a particular argumentation semantics, while the instance of an argumentation framework is given as an input database. For problems located on the second level of the polynomial hierarchy (i.e. for preferred, stage, and semi-stable semantics) ASP encodings turned out to be quite complicated and hardly accessible for non-experts in ASP (we will sketch here the encoding for the stage semantics in some detail, since it has not been presented in [11]). This is due to the fact that tests for subset-maximality have to be done “by hand” in ASP requiring a certain saturation technique. However, recent advances in ASP solvers, in particular, the metasp optimization front-end for the ASP-system gringo/claspD allows for much simpler encodings for such tests. More precisely, metasp allows to use the traditional statement (which in its standard variant minimizes wrt. cardinality or weights, but not wrt. subset inclusion) also for selection among answer sets which are minimal (or maximal) wrt. subset inclusion in certain predicates. Details about metasp can be found in [13].

Our first main contribution will be the practical comparison between handcrafted encodings (i.e. encodings in the standard ASP language without the new semantics for the statement) and the much simpler metasp encodings for argumentation semantics. The experiments show that the metasp encodings do not necessarily result in longer runtimes. In fact, the metasp encodings for the semantics located on the second level of the polynomial hierarchy outperform the handcrafted saturation-based encodings. We thus can give additional evidence to the observations in [13], where such a speed-up was reported for encodings in a completely different application area.

Our second contribution is the presentation of ASP encodings for the resolution-based grounded semantics [1]. To the best of our knowledge, no implementation for this quite interesting semantics has been released so far. In this paper, we present a rather involved handcrafted encoding (basically following the NP-algorithm presented in [1]) but also two much simpler encodings (using metasp) which rely on the original definition of the semantics.

Our results indicate that metasp is a very useful tool for problems known to be hard for the second-level, but one might loose performance in case metasp is used for “easier” problems just for the sake of comfortability. Nonetheless, we believe that the concept of the advanced statement is vital for ASP, since it allows for rapid prototyping of second-level encodings without being an ASP guru.

The remainder of the paper is organized as follows: Section 2 provides the necessary background. Section 3 then contains the ASP encodings for the semantics we are interested in here. We first discuss the handcrafted saturation-based encoding for stage semantics (the ones for preferred and semi-stable are similar and already published). Then, in Section 3.2 we provide the novel metasp encodings for all considered semantics. Afterwards, in Section 3.3 we finally present an alternative encoding for the resolution-based grounded semantics which better mirrors the complexity of this semantics. Section 4 then presents our experimental evaluation. We conclude the paper with a brief summary and discussion for future research directions.

2 Background

2.1 Abstract Argumentation

In this section we introduce (abstract) argumentation frameworks [7] and recall the semantics we study in this paper (see also [1, 2]). Moreover, we highlight complexity results for typical decision problems associated to such frameworks.

Definition 1

An argumentation framework (AF) is a pair where is a set of arguments and is the attack relation. The pair means that attacks . An argument is defended by a set if, for each such that , there exists a such that .

Example 1

Consider the AF with and , , , , , , , , and the graph representation of :

Semantics for argumentation frameworks are given via a function which assigns to each AF a set of extensions. We shall consider here for the functions , , , , , , , and which stand for stable, admissible, complete, preferred, grounded, resolution-based grounded, stage, and semi-stable semantics respectively. Towards the definition of these semantics we have to introduce two more formal concepts.

Definition 2

Given an AF

of is defined as . Moreover, for a set , we denote the set of arguments attacked by as , and define the range of as .

Definition 3

Let be an AF. A set is conflict-free (in ), if there are no , such that . denotes the collection of conflict-free sets of . For a conflict-free set , it holds that

• , if ;

• , if ;

• , if ;

• , if and there is no with ;

• , if and there is no with ;

• , if and there is no with ;

• , if there is no in , such that .

We recall that for each AF , the grounded semantics yields a unique extension, the grounded extension, which is the least fix-point of the characteristic function .

Example 2

Consider the AF from Example 1. We have and as the stable extensions and thus . The admissible sets of are , , , , , , , and therefore ,. Finally we have , , , with being the grounded extension.

On the base of these semantics one can define the family of resolution-based semantics [1], with the resolution-based grounded semantics being the most popular instance.

Definition 4

A resolution of an contains exactly one of the attacks , if , , and no further attacks. A set is a resolution-based grounded extension of if (i) there exists a resolution such that ;222Abusing notation slightly, we use for denoting the unique grounded extension of . and (ii) there is no resolution such that .

Example 3

Recall the AF from Example 1. There is one mutual attack and thus we have two resolutions and . Definition 4 gives us two candidates, namely and ; as they are not in -relation they are the resolution-based grounded extensions of .

We now turn to the complexity of reasoning in AFs. To this end, we define the following decision problems for the semantics introduced in Definitions 3 and 4:

• Credulous Acceptance : Given AF and an argument . Is contained in some ?

• Skeptical Acceptance : Given AF and an argument . Is contained in each ?

• Verification of an extension : Given AF and a set of arguments . Is ?

We assume the reader has knowledge about standard complexity classes like and NP and recall that

is the class of decision problems that can be decided in polynomial time using a nondeterministic Turing machine with access to an

NP-oracle. The class is defined as the complementary class of , i.e. .

In Table 1 we summarize complexity results relevant for our work [1, 6, 8, 9, 10].

We first give a brief overview of the syntax and semantics of disjunctive logic programs under the answer-sets semantics

[14]; for further background, see [15].

We fix a countable set of (domain) elements, also called constants; and suppose a total order over the domain elements. An atom is an expression , where is a predicate of arity and each is either a variable or an element from . An atom is ground if it is free of variables. denotes the set of all ground atoms over .

A (disjunctive) rule is of the form

,

with , , where are atoms, and “” stands for default negation. The head of is the set = and the body of is . Furthermore, = and = . A rule is normal if and a constraint if . A rule is safe if each variable in occurs in . A rule is ground if no variable occurs in . A fact is a ground rule without disjunction and empty body. An (input) database is a set of facts. A program is a finite set of disjunctive rules. For a program and an input database , we often write instead of . If each rule in a program is normal (resp. ground), we call the program normal (resp. ground). Besides disjunctive and normal program, we consider here the class of optimization programs, i.e. normal programs which additionally contain statements

 #minimize[l1=w1@J1,…,lk=wk@Jk], (1)

where is a literal, an integer weight and an integer priority level.

For any program , let be the set of all constants appearing in . is the set of rules obtained by applying, to each rule , all possible substitutions from the variables in to elements of . An interpretation satisfies a ground rule iff whenever and . satisfies a ground program , if each is satisfied by . A non-ground rule (resp., a program ) is satisfied by an interpretation iff satisfies all groundings of (resp., ). is an answer set of iff it is a subset-minimal set satisfying the Gelfond-Lifschitz reduct . For a program , we denote the set of its answer sets by .

For semantics of optimization programs, we interpret the statement wrt. subset-inclusion: For any sets and of atoms, we have , if for any weighted literal occurring in (1), implies . Then, is a collection of relations of the form for priority levels and weights . A standard answer set (i.e. not taking the minimize statements into account) of dominates a standard answer set of wrt.  if there are a priority level and a weight such that does not hold for , while holds for all where . Finally a standard answer set is an answer set of an optimization program wrt.  if there is no standard answer set of that dominates wrt. .

Credulous and skeptical reasoning in terms of programs is defined as follows. Given a program and a set of ground atoms . Then, we write (credulous reasoning), if is contained in some answer set of ; we write (skeptical reasoning), if is contained in each answer set of .

We briefly recall some complexity results for disjunctive logic programs. In fact, since we will deal with fixed programs we focus on results for data complexity. Depending on the concrete definition of , we give the complexity results in Table 2 (cf. [5] and the references therein). We note here, that even normal programs together with the optimization technique have a worst case complexity of (resp. ).

Inspecting Table 1 one can see which kind of encoding is appropriate for an argumentation semantics.

3 Encodings of AF Semantics

In this section we first show how to represent AFs in ASP and we discuss three programs which we need later on in this section333We make use of some program modules already defined in [11].. Then, in Subsection 3.1 we exemplify on the stage semantics the saturation technique for encodings which solve associated problems which are on the second level of the polynomial hierarchy. In Subsection 3.2 we will make use of the newly developed metasp optimization technique. In Subsection 3.3 we give an alternative encoding based on the algorithm of Baroni et al. in [1], which respects the lower complexity of resolution-based grounded semantics.

All our programs are fixed which means that the only translation required, is to give an AF as input database to the program for a semantics . In fact, for an AF , we define as

 ^F={arg(a)∣a∈A}∪{defeat(a,b)∣(a,b)∈R}.

In what follows, we use unary predicates and to perform a guess for a set , where represents that . The following notion of correspondence is relevant for our purposes.

Definition 5

Let be a collection of sets of domain elements and let be a collection of sets of ground atoms. We say that and correspond to each other, in symbols , iff (i) for each , there exists an , such that ; (ii) for each , it holds that ; and (iii) .

Consider an AF . The following program fragment guesses, when augmented by , any subset and then checks whether the guess is conflict-free in :

 πcf ={ in(X)←notout(X),arg(X); out(X)←notin(X),arg(X); ←in(X),in(Y),defeat(X,Y)}.
Proposition 1

For any AF ,

Sometimes we have to avoid the use of negation. This might either be the case for the saturation technique or if a simple program can be solved without a Guess&Check approach. Then, encodings typically rely on a form of loops where all domain elements are visited and it is checked whether a desired property holds for all elements visited so far. We will use this technique in our saturation-based encoding in the upcoming subsection, but also for computing the grounded extension in Subsection 3.2. For this purpose the program , which is taken from [11], is used to encode the infimum, successor and supremum of an order over the domain elements in the predicates and respectively. The order over the domain elements is usually provided by common ASP solvers.

Finally, the following module computes for a guessed subset the range (see Def. 2) of in an AF .

 πrange = {in_range(X)←in(X); {in_range(X)←in(Y),defeat(Y,X); {not_in_range(X)←arg(X),notin_range(X)}.

3.1 Saturation Encodings

In this subsection we make use of the saturation technique introduced by Eiter and Gottlob in [12]. In [11], this technique was already used to encode the preferred and semi-stable semantics. Here we give the encodings for the stage semantics, which is similar to the one of semi-stable semantics, to exemplify the use of the saturation technique.

In fact, for an AF and we need to check whether no with exists. Therefore we have to guess an arbitrary set and saturate in case (i) is not conflict-free, and (ii) . Together with this is done with the following module, where holds the current guess for and holds the current guess for . More specifically, rule checks for (i) and the remaining two rules with in the head fire in case (indicated by predicate described below), or there exists an such that (here we use predicate from above and predicate which we also present below). As is easily checked one of these two conditions holds exactly if (ii) holds.

 πsatstage ={ inN(X)∨outN(X)←arg(X); fail←inN(X),inN(Y),defeat(X,Y); fail←eqplus; fail←in_range(X),not_in_rangeN(X); inN(X)←fail,arg(X); outN(X)←fail,arg(X); ←notfail}.

For the definition of predicates and we make use of the aforementioned loop technique and predicates from program .

 πrangeN ={ undefeated_upto(X,Y)←inf(Y),outN(X),outN(Y); undefeated_upto(X,Y)←inf(Y),outN(X),notdefeat(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), undefeated_upto(X,Y)←notdefeat(Y,X); not_in_rangeN(X)←sup(Y),outN(X),undefeated_upto(X,Y); in_rangeN(X)←inN(X); in_rangeN(X)←outN(X),inN(Y),defeat(Y,X)}.
 π+eq ={ eqp_upto(X)←inf(X),in_range(X),in_rangeN(X); eqp_upto(X)←inf(X),not_in_range(X),not_in_rangeN(X); eqp_upto(X)←succ(Z,X),in_range(X),in_rangeN(X),eqp_upto(Z); eqp_upto(X)←succ(Y,X),not_in_range(X),not_in_rangeN(X),eqp_upto(Y); eqplus←sup(X),eqp_upto(X)};
Proposition 2

For any AF , , where .

3.2 Meta ASP Encodings

The following encodings for preferred, semi-stable and stage semantics are written using the statement when evaluated with the subset minimization semantics provided by metasp. For our encodings we do not need prioritization and weights, therefore these are omitted (i.e. set to default) in the minimization statements. The fact optimize(1,1,incl) is added to the meta ASP encodings, to indicate that we use subset inclusion for the optimization technique using priority and weight .

We now look at the encodings for the preferred, semi-stable and stage semantics using this minimization technique. First we need one auxiliary module for admissible extensions.

Now the modules for preferred, semi-stable and stage semantics are easy to encode using the minimization statement of metasp. For the preferred semantics we take the module and minimize the predicate. This in turn gives us the subset-maximal admissible extensions, which captures the definition of preferred semantics. The encodings for the semi-stable and stage semantics are similar. Here we minimize the predicate from the module.

The following results follow now quite directly.

Proposition 3

For any AF , we have

1. ,

2. , and

3. .

Next we give two different encodings for computing resolution-based grounded extensions. Both encodings use subset minimization for the resolution part, i.e. the resulting extension is subset minimal with respect to all possible resolutions. The first one computes the grounded extension for the guessed resolution explicitly (adapting the encoding from [11]; instead of the predicate we use , since we need the grounded extensions of a restricted relation). In fact, the module which we give next guesses this restricted relation for a resolution .

 πres ={ defeat_minus_beta(X,Y)←defeat(X,Y),notdefeat_minus_beta(Y,X), defeat_minus_beta(X,Y)← X≠Y; defeat_minus_beta(X,Y)←defeat(X,Y),notdefeat(Y,X); defeat_minus_beta(X,X)←defeat(X,X)}.

The second encoding uses the metasp subset minimization additionally to get the grounded extension from the complete extensions of the current resolution (recall that the grounded extension is in fact the unique subset-minimal complete extension). We again use the restricted relation.

Now we can give the two encodings for resolution-based grounded semantics.

 πgrd∗_metasp = πgrd∪πres∪{#minimize[in]} π′grd∗_metasp = πcom∪πres∪{#minimize[in]}.
Proposition 4

For any AF and , corresponds to in the sense of Definition 5, but without property (iii).

3.3 Alternative Encodings for Resolution-based Grounded Semantics

So far, we have shown two encodings for the resolution-based grounded semantics via optimization programs, i.e. we made use of the statement under the subset-inclusion semantics. From the complexity point of view this is not adequate, since we expressed a problem on the NP-layer (see Table 1) via an encoding which implicitly makes use of disjunction (see Table 2 for the actual complexity of optimization programs). Hence, we provide here an alternative encoding for the resolution-based grounded semantics based on the verification algorithm proposed by Baroni et al. in [1]. This encoding is just a normal program and thus located at the right level of complexity.

We need some further notation. For an AF and a set we define as the sub-framework of wrt ; furthermore we also use as a shorthand for . By , we denote the set of strongly connected components of an AF which identify the vertices of a maximal strongly connected444A directed graph is called strongly connected if there is a directed path from each vertex in the graph to every other vertex of the graph. subgraphs of ; is thus a partition of . A partial order over , denoted as for , is defined, if such that there is a directed path from to in .

Definition 6

A is minimal relevant (in an AF ) iff is a minimal element of and satisfies the following:

1. the attack relation of is irreflexive, i.e.  for all arguments ;

2. is symmetric, i.e. ;

3. the undirected graph obtained by replacing each (directed) pair in with a single undirected edge is acyclic.

The set of minimal relevant SCCs in is denoted by .

Proposition 5 ([1])

Given an AF such that and , where , a set of arguments is resolution-based grounded in , i.e. iff the following conditions hold:

1. ;

2. , where , and ;

3. , where and are as in (ii) and .

To illustrate the conditions of Proposition 5, let us have a look at our example.

Example 4

Consider the AF of Example 1. Let us check whether is resolution-based grounded in , i.e. whether . is the grounded extension of and , hence the first Condition (i) is satisfied. We obtain and . We observe that is a stable extension of the AF ; that satisfies Condition (ii). Now we need to check Condition (iii); we first identify the necessary sets: , and . It remains to check which is easy to see. Hence, .

The following encoding is based on the Guess&Check procedure which was also used for the encodings in [11]. After guessing all conflict-free sets with the program , we check whether the conditions of Definition 6 and Proposition 5 hold. Therefore the program makes a copy of the actual arguments, defeats and the guessed set to the predicates and . The first variable in these three predicates serves as an identifier for the iteration of the algorithm (this is necessary to handle the recursive nature of Proposition 5). In all following predicates we will use the first variable of each predicate like this. As in some previous encodings in this paper, we use the program to obtain an order over the arguments, and we start our computation with the infimum represented by the predicate .

 πarg_set ={ arg_set(N,X)←arg(X),inf(N); inU(N,X)←in(X),inf(N); defeatN(N,Y,X)←arg_set(N,X),arg_set(N,Y),defeat(Y,X)}.

We use here the program (which is a slight variant of the program ) together with the program where we perform a fixed-point computation of the predicate , but now we use an additional argument for the iteration step where predicates , and replace , and . In we then obtain the predicate which identifies argument to be in the grounded extension of the iteration .

 πgroundN =πcf∪π<∪πarg_set∪πdefendedN∪{ inS(N,X)←defendedN(N,X)}.

The next module computes the arguments in , represented by the predicate , via predicates and (for and ). The two constraints check condition (i) of Proposition 5.

 πF_minus_range ={ in_SplusN(N,X)←inS(N,X); in_SplusN(N,X)←inS(N,Y),defeatN(N,Y,X); u_cap_Splus(N,X)←inU(N,X),in_SplusN(N,X); ←u_cap_Splus(N,X),notinS(N,X); ←notu_cap_Splus(N,X),inS(N,X); notInSplusN(N,X)←arg_set(N,X),notin_SplusN(N,X)}.

The module computes , where denotes that an argument is contained in a set . Therefore we need to check all three conditions of Definition 6. The first two rules compute the predicate if there is a path between the arguments . With this predicate we will identify the SCCs. The third rule computes for all arguments violating Condition (a). Next we need to check Condition (b). With we obtain those arguments which do not have a symmetric attack to any other argument from the same component. Condition (c) is a bit more tricky. With predicate we say that there is a path from to not going over argument in the framework . With this predicate at hand we can check for cycles with . Then, to complete Condition (c) we derive for all arguments which are connected to a cycle (or a self-defeating argument). In the predicate , we put all the three conditions together and say that an argument is possibly in a set if (i) , (ii) is neither connected to a cycle nor self-defeating, and (iii) for all it holds that