Foundations of Implementations for For- mal Argumentation
Federico Cerutti, Sarah A. Gaggl, Matthias Thimm, Johannes P. Wallner
abstract. We survey the current state of the art of general tech- niques, as well as specific software systems for solving tasks in ab- stract argumentation frameworks, structured argumentation frame- works, and approaches for visualizing and analysing argumentation.
Furthermore, we discuss challenges and promising techniques such as parallel processing and approximation approaches. Finally, we ad- dress the issue of evaluating software systems empirically with links to the International Competition on Computational Models of Argu- mentation.
1 Introduction
Compared to related areas such as argumentation theory [van Eemerenet al., 2014], research conducted in the formal argumentation community seeks formal accounts of argumentation with explicit links to knowledge repre- sentation and reasoning, and artificial intelligence [Brachman and Levesque, 2004; Russell and Norvig, 2003]. An important feature for these accounts is computability, i. e., the possibility to provide algorithmic methods to solve problems.
In this paper, we survey general computational techniques and concrete implementations for solving problems related to formal argumentation. We distinguish between: (1) Approaches to abstract argumentation frameworks, (2) Approaches to structured argumentation frameworks (such as ASPIC+
andDeLP), and (3) Other approaches, including semi-formal systems related to visualization of argumentation processes or exchange of arguments on the web.
Between them, the most active research direction within the formal argu- mentation community1is devoted to the first category—algorithms and sys- tems for abstract argumentation frameworks—reviewed in Section 2. The
1Approaches in the third category are also addressed by other research communities such as human-computer-interaction and web science.
relevant computational problems and their (high) computational complex- ity have been studied in e. g. [Dunne and Wooldridge, 2009]. Here, we focus on the algorithmic issues and techniques to handle the high computational complexity of some of those problems. The development of implementations has accelerated recently, also due to the foundation of the International Competition on Computational Models of Argumentation (ICCMA):2 be- sides discussing general techniques we will also survey concrete systems.
We will also look at techniques and systems solving problems for struc- tured approaches to formal argumentation. Due to the multitude of different approaches to structured argumentation, computational techniques and al- gorithms are usually tailored towards specific approaches. We will discuss them in Section 3.
In order to complement our survey we will also have a brief look at other systems that incorporate some kind of (semi-)formal argumentation such as argument schemes and argumentation technologies (or debating technolo- gies) which are popular in many other fields besides the formal argumen- tation community. In contrast to the perspective of artificial intelligence and knowledge representation usually taken by researchers in the formal argumentation community, the focus of the systems in this third category is on human-computer interaction and supporting critical thinking. We will discuss these systems in Section 4, concluding the survey part of this paper.
In Section 5 we will look beyond the current state of the art of algorithms and systems and current challenges for the development of systems, such as parallelization and approximation algorithms, focusing on abstract and structured argumentation approaches. A recent effort to promote the devel- opment of systems for solving argumentation tasks is the ICCMA: the first instance of the competition took place in 2015 [Thimm et al., 2016]. We will discuss this competition and general methods for empirically evaluating systems in Section 6.
2 Abstract Argumentation Implementations
In this section we will give an overview of implementations for abstract Ar- gumentation Frameworks (AFs) following the approach from Dung [Dung, 1995] and give an overview of existing systems for Dung’s framework as well as for some related formalisms.
One can divide the implementations for abstract AFs into two categories:
thereduction-based approach and the direct approach. The former one re- duces the problem at hand into another formalism to exploit existing solvers from the other formalism. We will discuss this method and the dedicated
2http://argumentationcompetition.org(on 27/04/2017).
implementations in the following subsection. The other possibility is to de- sign algorithms to directly solve the problem. This implementation method will be presented in Subsection 2.2. For a more detailed discussion on im- plementation methods for AFs we refer to [Charwatet al., 2015].
Before we go into details on the different approaches we briefly introduce the background on abstract argumentation [Dung, 1995] and the notation we will use in this section. For comprehensive surveys on argumentation semantics the interested reader is referred to [Baroniet al., 2011a].
Definition 2.1 Anargumentation framework (AF)is a pairAF =hAr,atti, where Ar is a finite set of arguments and att ⊆Ar×Ar is the attack re- lation. The pair ha, bi ∈ Ar means that a attacks b. A set S ⊆ Ar of arguments attacks b (in AF), if there is an a∈ S, such that ha, bi ∈ att . An argument a∈Ar is defendedby S ⊆Ar (in AF) iff, for each b∈Ar , it holds that, ifhb, ai ∈att , thenS attacksb (inAF). Given a setS⊆Ar , S+={a∈Ar | hb, ai ∈att, b∈S}, andS−={a∈Ar | ha, bi ∈att, b∈ S}.
The inherent conflicts between the arguments are solved by selecting subsets of arguments, where a semantics σ assigns a collection of sets of arguments to an argumentation frameworkAF. The basic requirement for all semantics is that none of the selected arguments attack each other3. Definition 2.2 Let AF =hAr,atti be an AF. A set S ⊆Ar is said to be conflict-free (in AF), if there are no a, b ∈S, such that ha, bi ∈att . We denote the collection of sets which are conflict-free (in AF) by cf(F).
Definition 2.3 LetAF =hAr,attibe an AF, then S∈cf(AF)is
• a stable extension, i. e.S ∈ EST(AF), if each a∈Ar\S is attacked by S in AF;
• an admissibleextension, i. e. S∈ EAD(AF), if eacha∈S is defended by S;
• a preferred extension, i. e. S ∈ EPR(AF), if S ∈ EAD(AF) and for each T ∈ EAD(AF),S6⊂T;
• a complete extension, i. e. S ∈ ECO(AF), if S ∈ EAD(AF) and for each a∈Ar defended by S it holds that a∈S;
3We concentrate here on the basic Dung-style argumentation framework, and do not consider approaches like value-based argumentation frameworks (VAFs) [Bench-Capon, 2003] or inconsistency tolerant semantics [Dunne et al., 2009] (where this requirement does not hold), as our main focus is on implementation methods.
• the groundedextension (ofAF), i. e. the unique setS=EGR(AF), if S ∈ ECO(AF)and for eachT ∈ ECO(AF),T 6⊂S.
The typical problems of interest in abstract argumentation are the following decision problems for given AF = hAr,atti, a semantics σ, a ∈ Ar and S⊆Ar:
• VerificationVerσ: isS∈ Eσ(AF)?
• Credulous acceptanceCredσ: isacontained in at least oneσextension ofAF?
• Skeptical acceptance Skeptσ: is a contained in everyσ extension of AF?
• Non-emptinessExists¬∅σ : is there any S∈ Eσ(AF) for whichS6=∅?
Computational complexity of decision problems on AFs is well-studied. For an overview see e. g. [Dunne and Wooldridge, 2009].
2.1 Reduction-based Implementations
Reduction-based implementations are a very common approach as one ben- efits from very sophisticated solvers developed and improved by several communities. The underlying idea is to exploit existing efficient software which has originally been developed for other purposes. To this end, one has to formalize the reasoning problems within other formalisms such as constraint-satisfaction problems (CSP) [Rossi et al., 2006], propositional logic [Biere et al., 2009] or answer-set programming (ASP) [Brewka et al., 2011]. The general methodology of the reduction-based approach is to re- duce the problem at hand to the target formalism, run the solver (of the target formalism) and interpret the output as the solutions of the original problem, as depicted in Figure 1.
2.1.1 SAT-based Approach
Reductions to SAT have been first advocated in [Dunne and Bench-Capon, 2002] and [Dunne and Bench-Capon, 2003] and then further developed by Besnard and Doutre [Besnard and Doutre, 2004], and later extended by means of quantified propositional logic [Arieli and Caminada, 2013;
Egly and Woltran, 2006]. Several prominent systems use reductions to SAT, such as Cegartix [Dvoˇr´ak et al., 2014] and {j}ArgSemSAT [Ceruttiet al., 2014c; Cerutti et al., 2016b; Cerutti et al., 2017] that both rely on iterative calls to SAT solvers for argumentation semantics of high complex- ity (i. e. being located on the second level of the polynomial hierarchy).
Further SAT-based systems include prefMaxSAT [Vallati et al., 2015;
Problem
Target Formalism Solver
Solution
Output
?
- -
6
Reduction Interpreting
Figure 1. Reduction-based approach.
Faberet al., 2016], which uses the MaxSAT approach for the computation of preferred semantics; theLabSATSolver [Beierleet al., 2015], which uses propositional formulas based on labellings and, for the subset maximiza- tion task, the PrefSat Algorithm [Ceruttiet al., 2014a] that then become {j}ArgSemSAT. The system CoQuiAAS [Lagniez et al., 2015], which also uses SAT encodings for some semantics, will be explained in Subsec- tion 2.1.2, as the maximization task necessary for instance for preferred semantics is performed by means of constraint programming.
Background. Let us consider a set of propositional variables (or atoms) P and the connectives∧,∨,→and¬, denoting respectively the logical con- junction, disjunction, material implication and negation. The constants>
and⊥denote respectivelytrueandfalse. In addition, we consider quantified Boolean formulae (QBF) with the universal quantifier∀and the existential quantifier ∃ (both over atoms), that is, given a formula φ, then Qpφ is a QBF, with Q ∈ {∀,∃} and p ∈ P. Q{p1, . . . , pn}φ is a shorthand for Qp1· · ·Qpnφ. A propositional variable pin a QBF φis free if it does not occur within the scope of a quantifier Qp and bound otherwise. If φ con- tains no free variable, then φis said to be closed and otherwise open. We will write φ[p/ψ] to denote the result of uniformly substituting each free occurrence ofpwithψin formulaφ.
An interpretation I ⊆ P defines for each propositional variable a truth assignment where p ∈ I indicates that p evaluates to true while p /∈ I indicates that pevaluates to false. This generalizes to arbitrary formulae in the standard way: Given a formula φ and an interpretationI, then φ evaluates to true under I (i. e.,I satisfies φ) if one of the following holds (withp∈ P).
• φ=pandp∈I
• φ=¬pandp6∈I
• φ=ψ1∧ψ2 and bothψ1andψ2 evaluate to true underI
• φ=ψ1∨ψ2 and one ofψ1 andψ2 evaluates to true underI
• φ=ψ1→ψ2 andψ1 evaluates to false orψ2 evaluates to true under I
• φ=∃pψ and one of ψ[p/>] andψ[p/⊥] evaluates to true underI
• φ=∀pψ and both ψ[p/>] andψ[p/⊥] evaluate to true underI.
If an interpretation I satisfies a formula φ, denoted by I |= φ, we say thatI is a model ofφ.
Reductions to propositional logic. The first reduction-based approach [Besnard and Doutre, 2004; Egly and Woltran, 2006] we consider here uses propositional logic formulae (without quantifiers) to encode the problem of finding admissible sets. Given an AF AF =hAr,atti, for each argument a∈Ar a propositional variable va is used. Then, S ⊆Ar is an extension under semanticsσiff{va|a∈S} |=φ, withφbeing a propositional formula that evaluates AF AF under semantics σ (below we will present in detail how to translate AFs into formulae). Formally, the correspondence between sets of extensions and models of a propositional formula can be defined as follows.
Definition 2.4 Let T ⊆2Ar be a collection of sets of arguments and let I ⊆2P be a collection of interpretations. We say that T andI correspond to each other, in symbolsT ∼=I, if
1. for eachS∈ T, there exists anI∈ I, such that{a|va∈I, a∈Ar}= S;
2. for eachI∈ I, there exists anS∈ T, such that{a|va∈I, a∈Ar}= S; and
3. |T |=|I|.
Given an AFAF =hAr,atti, the following formula can be used to solve the enumeration problem of admissible semantics.
admAr,att := ^
a∈Ar
(va→ ^
hb,ai∈att
¬vb) ∧(va → ^
hb,ai∈att
( _
hc,bi∈att
vc)) (1)
a b c d e
Figure 2. Example argumentation framework.
Note that an empty conjunction is treated as >, whereas the empty dis- junction is treated as⊥.
The models ofadmAr,att now correspond to the admissible sets of AF, i. e., we have EAD(AF) ∼= {M | M |= admAr,att}. The first conjunction in (1) ensures that the resulting set of arguments is conflict-free, that is, whenever we accept an argumenta(i. e.,vaevaluates to true under a model), all its attackers cannot be accepted. The second conjunct expresses the defense of arguments by stating that, if we accepta, then for each attacker b, some defenderc must be accepted as well.
Example 2.5 Let AF = hAr,atti be an AF with Ar = {a, b, c, d, e} and att={ha, bi,hb, ci,hc, bi,hd, ci,hd, ei,he, ei} as depicted in Figure 2. The corresponding propositional formula admAr,att is as follows.
admAr,att ≡(va → >)∧
(vb→(¬va∧ ¬vc))∧
(vc→(¬vb∧ ¬vd))∧
(vd→ >)∧
(ve→(¬vd∧ ¬ve))∧
(va → >)∧
(vb→(⊥ ∧(vb∨vd)))∧
(vc→((va∨vc)∧ ⊥))∧
(vd→ >)∧
(ve→(⊥ ∧vd))
It is easy to see that I = {I1, I2, I3, I4} represents the set of models of
admAr,att, where
I1={va 7→ ⊥, vb7→ ⊥, vc7→ ⊥, vd7→ ⊥, ve7→ ⊥}, I2={va 7→ >, vb7→ ⊥, vc7→ ⊥, vd7→ ⊥, ve7→ ⊥}, I3={va 7→ ⊥, vb7→ ⊥, vc7→ ⊥, vd7→ >, ve7→ ⊥}, I4={va 7→ >, vb7→ ⊥, vc7→ ⊥, vd7→ >, ve7→ ⊥}.
AsT ={S1, S2, S3, S4}, withS1={},S2={a},S3={d}andS4={a, d}, is the set of all admissible sets of AF we clearly have the correspondence I ∼=T as desired.
Reductions to quantified Boolean formulas. For problems beyond NP we require a more expressive formalism than propositional logic. For this purpose we consider QBFs. In the following we will show how to reduce a given AF into a QBF such that the models of the QBF correspond to the preferred extensions of the AF [Egly and Woltran, 2006].
In order to realize the maximality check for preferred semantics we need to be able to compare two sets of atoms w.r.t. set inclusion. Consider the formula
Ar<Ar0:= ^
a∈Ar
(va→va0)∧ ¬ ^
a0∈Ar0
(va0 →va),
where Ar0 = {a0 | a ∈ Ar}. This formula ensures that any model M |= (Ar < Ar0) satisfies {a ∈ Ar | va ∈ M} ⊂ {a ∈ Ar | va0 ∈ M}. Now we can state the QBFprfAr,att for preferred extensions. Let the quantified variables beAr0v={va0 |a0 ∈Ar0}andatt0={ha0, b0i | ha, bi ∈att}. Then
prfAr,att:=admAr,att ∧ ¬∃Ar0v((Ar <Ar0)∧admAr0,att0). (2)
Thus, for any AFAF =hAr,attian interpretationIis a model ofprfAr,att iff it satisfies the formula for admissible sets and there exists no “bigger”
interpretationI0that also satisfies the the corresponding formula for admis- sible sets.
Example 2.5 (continued) There, I4 is the only interpretation which satisfies the QBF prfAr,attand the corresponding setS4is the only preferred extension of AF.
Similar approaches have been proposed by Arieli and Caminada in [Arieli and Caminada, 2013] and for Abstract Dialectical Frameworks by Diller et al. inQADF[Dilleret al., 2015].
Iterative application of SAT solvers. The final approach we outline here is based on the idea of iteratively searching for models of propositional formulae and has been instantiated in the systems{j}ArgSemSAT[Cerutti et al., 2014a; Ceruttiet al., 2014c; Ceruttiet al., 2016b] andCegartix[Dvoˇr´ak et al., 2014; Dvoˇr´ak et al., 2014]. The idea is to use an algorithm which iteratively constructs formulae and searches for models of these formulae. A new formula is generated based on the model of the previous one (or based on the fact that the previous formula is unsatisfiable). At some point the algorithm reaches a final decision and terminates.
The iterative approach is suitable when the problem to be solved cannot be decided in general—under standard complexity theoretic assumptions—
by the satisfiability of a single propositional formula, constructible in poly- nomial time without quantifiers. This is, for instance, the case with skepti- cal acceptance under preferred semantics, where the corresponding decision problem is ΠP2-complete. Instead of reducing the problem to a single QBF formula, the solving task is delegated to the iterative scheme of an algorithm querying a SAT solver multiple times.
The algorithms for preferred semantics work roughly as follows. To com- pute preferred extensions we traverse the search space of a computationally simpler semantics. For instance, we can iteratively search for admissible sets or complete extensions and iteratively extend them until we reach a maximal set, which is a preferred extension. By generating a new candidate for an admissible set or a complete extension, which is not contained in an already visited preferred extension, we can enumerate all preferred exten- sions in this manner. This allows answering both credulous and skeptical reasoning problems as well.
For deciding e. g. skeptical acceptance of an argument under preferred semantics one requires, in the worst case, an exponential number of calls to the SAT solver—under standard complexity-theoretic assumptions. How- ever, the actual number of SAT calls in the iterative SAT scheme depends on the number of preferred extensions of the given AF, see [Dvoˇr´ak et al., 2014].
In the following, we sketch theCegartix approach from [Dvoˇr´ak et al., 2014] for skeptical acceptance of an argument under preferred semantics.
The algorithm returns YES ifais skeptically accepted, NO otherwise. To do so we try to construct a preferred extension which does not containa. If this is possible we know thatais not skeptically accepted under preferred semantics, otherwise the algorithm returns YES.
1) Check if there is an interpretationIsatisfying the formulaφ(initially φ =admAr,att∧ ¬va). If such an interpretationI exists, go to Step 2. Otherwise there is no admissible set which does not containa, and
the algorithm returns YES.
2) Try to add new arguments toI by updating it (as long as possible) with interpretations satisfying the formula
admAr,att∧ ¬va∧( ^
a∈Ar,va∈I
va)∧( _
a∈Ar,va6∈I
va).
3) For the maximized interpretationI, check if it is possible to add the argumentato it by checking for models of the formula
φ0=admAr,att∧( ^
a∈Ar,va∈I
va)∧( _
a∈Ar,va6∈I
va).
If there is an interpretation I0 satisfyingφ0, there is a preferred ex- tension which contains a. Otherwise, there is a preferred extension, namely the one represented by the interpretation I, which does not contain the argument a. In this case the algorithm outputs NO and terminates.
4) The algorithm continues with the search for a different preferred ex- tension which does not contain the arguments ofI by modifying the formulaφas follows:
φ0 =φ∧( _
a∈Ar,va6∈I
va).
Go to Step 1.
Example 2.5 (continued) Let us exemplify the algorithm of Cegartix on our AF from Example 2.5, where we want to decide skeptical acceptance of the argument d. We know that there are four interpretations satisfying the formula for admissible sets and only I1 andI2 satisfy the formula φ= admAr,att ∧ ¬vd of Step 1. Let us continue with I =I1 which represents the admissible set S1 = {}. In Step 2, we update I by setting va to >.
Remember, we cannot set vd to > as φ contains the clause ¬vd. In Step 3 we check if there is an I0 satisfying the formula φ0 = admAr,att∧va∧ (vb∨vc∨vd∨ve). Indeed I0 ={va 7→ >, vb 7→ ⊥, vc 7→ ⊥, vd 7→ >, ve 7→
⊥} is a model of φ0, thus we constructed a preferred extensions, namely S = {a, d} containing the argument a. In Step 4 we update our formula toφ=admAr,att∧ ¬vd∧(vb∨vc∨vd∨ve)and go to Step 1. In the next iteration, we check the new formulaφfor models, but asφis not satisfiable the algorithm outputs YES and terminates.
One can use a modified version of the above algorithm to enumerate all preferred extensions. More concretely, one can add the obtained pre- ferred extension from Step 2 to the output-set and then update the for- mula as in Step 4, while omitting Step 3. Further, the conjunct contain- ing a negated variable for the queried argument must be removed. The PrefSat approach [Cerutti et al., 2014a] as implemented in the system {j}ArgSemSAT [Cerutti et al., 2014c; Cerutti et al., 2016b] uses this method to compute all preferred labellings.
2.1.2 Reductions to Constraint Satisfaction Problems
In the following we introduce reductions to another target formalism, namely Constraint Satisfaction Problems (CSPs) [Rossi et al., 2006], which allow to solve combinatorial search problems. Reductions to CSP have been ad- dressed by Amgoud and Devred [Amgoud and Devred, 2011] and Bistarelli, Pirolandi, and Santini [Bistarelliet al., 2009; Bistarelli and Santini, 2010;
Bistarelli and Santini, 2011; Bistarelli and Santini, 2012b; Bistarelli and Santini, 2012a]; the latter works led to the development of the ConArg system. Further systems based on CSP are CoQuiAAS [Lagniez et al., 2015] and ASGL [Sprotte, 2015]. The approach of CSP is inherently re- lated to propositional logic reductions as introduced in Subsection 2.1.1, see also [Walsh, 2000] for a formal analysis of the relation between the two approaches.
A CSP can generally be described by a triple (X, D, C), where X = {x1, . . . , xn}is the set of variables, D={D1, . . . , Dn} is a set of finite do- mains for the variables and C = {c1, . . . , cm} a set of constraints. Each constraintciis a pair (hi, Hi) wherehi= (xi1, . . . , xik) is ak-tuple of vari- ables andHi is ak-ary relation over D. In particular, Hi is a subset of all possible variable values representing the allowed combinations of simultane- ous values for the variables inhi. An assignmentvis a mapping that assigns to every variable xi ∈X an element v(xi)∈Di. An assignment v satisfies a constraint ((xi1, . . . , xik), Hi) ∈ C iff (v(xi1), . . . , v(xik)) ∈ Hi. Finally, a solution is an assignment v to all variables such that all constraints are satisfied, denoted by (v(x1), . . . , v(xn)).
Finding a valid assignment of a CSP is in general NP-complete. Never- theless, several programming libraries support constraint programming, like ECLiPSe,4 SWI Prolog,5 Gecode,6 JaCoP,7 Choco,8 Turtle9 (just to men-
4http://eclipseclp.org/(on 27/04/2017).
5http://www.swi-prolog.org/(on 27/04/2017).
6http://www.gecode.org/(on 27/04/2017).
7https://github.com/radsz/jacop(on 27/04/2017).
8http://www.choco-solver.org/(on 27/04/2017).
9https://github.com/timfel/turtle(on 27/04/2017).
tion some of them) and allow for efficient implementations of CSPs. These constraint programming solvers make use of techniques like backtracking and local search.
Given an AFAF =hAr,atti, the associated CSP (X, D, C) is specified as X =Ar and for eachai ∈X, Di ={0,1}. The constraints are formu- lated depending on the specific semantics σ. For example, solutions that correspond to conflict-free sets can be obtained by defining a constraint for each pair of arguments a and b with ha, bi ∈ att, where the two vari- ables may not be set to 1 at the same time. Here, the constraint is of the form ((a, b),((0,0),(0,1),(1,0))) which is equivalent to the cases when the propositional formula (a→ ¬b) evaluates to true.
In the following, we will use the notation from [Amgoud and Devred, 2011], because it reflects the similarities between the CSP approach and the reductions to propositional logic as outlined above.
For admissible semantics we get the following constraints.
CAD =n
(a→ ^
b:hb,ai∈att
¬b)∧(a→ ^
b:hb,ai∈att
( _
c:hc,bi∈att
c))
a∈Aro (3)
The first part ensures conflict-free sets and the second part encodes the defense of arguments. Then, for an AF AF =hAr,atti and its associated admissible CSP (X, D, CAD), (v(x1), . . . , v(xn)) is a solution of the CSP iff the set{xj, . . . , xk} s.t.v(xi) = 1 is an admissible set inAF.
Example 2.5 (continued) For our AF we obtain the following admissible CSP (X, D, CAD). X =A, for eachai∈X we have Di={0,1} and
CAD={(a→ >)∧(a→ >),(b→ ¬a∧ ¬c)∧(b→ ⊥ ∧d), (c→ ¬b∧ ¬d)∧(c→(a∨c)∧ ⊥),(d→ >)∧(d→ >), (e→ ¬d∧ ¬e)∧(e→ ⊥ ∨d)}.
This CSP has the following solutions: (0,0,0,0,0),(1,0,0,0,0),(0,0,0,1,0), (1,0,0,1,0)which correspond to the admissible sets ofAF, namely{},{a},{d}
and{a, d}.
Most CSP solvers do not support subset maximization. Thus, for pre- ferred semantics, Bistarelli and Santini [2012a] propose an approach that iteratively computes admissible/complete extensions and adds constraints to exclude certain sets, such that one finally obtains the preferred exten- sions.
Reductions to Weighted Partial Max-SAT. This approach has been implemented inCoQuiAAS[Lagniezet al., 2015] and inprefMaxSAT[Val-
latiet al., 2015; Faberet al., 2016] and is particularly tailored to maximiza- tion problems as needed to compute preferred semantics. AWeighted Par- tial Max-SAT problem is a problem which maximizes the sum of weights as- sociated to constraints, where the termpartialmeans that some constraints have an infinite weight, which means they need to be satisfied. The sys- temCoQuiAAS uses a SAT-Solver but the problem of Weighted Partial Max-SAT is more related to Constraint Programming, therefore we discuss this approach in this section, but of course it is also closely related to the previous section.
The computation of preferred extensions in [Lagniezet al., 2015] is based on complete extensions which are obtained as follows. For an AF AF = hAr,attiand for eacha∈Ar we use a boolean variableva.
compAr,att :=
^
a∈Ar
va→( ^
b∈Ar:hb,ai∈att
¬vb)∧(va↔( ^
b∈Ar:hb,ai∈att
_
c∈Ar:hc,bi∈att
vc))
The models ofcompAr,att correspond to the complete extensions ofAF, i. e., we have ECO(F) ∼={M|M |= compAr,att}. Then, the maximal models of compAr,att correspond to the preferred extensions of AF. To obtain these one uses the concept of a maximal satisfiable subset (MSS). For a set of formulasF the set of formulas S ⊆ F is a MSS iff S is satisfiable and for eachc∈ F \ S,S ∪ {c}is unsatisfiable.
Now, the computation of preferred extension reduces to the computation of MSSs of the sets of weighted formulas
prfAr,att={(compAr,att,+∞),(a1,1), . . . ,(an,1)}
wherea1, . . . , an∈Ar.
2.1.3 Reductions to Answer Set Programming
The use of logic programming to solve abstract argumentation problems has been initiated by several authors (the survey article by Toni and Ser- got [Toni and Sergot, 2011] provides a good overview), including the ap- proach proposed by Nieveset al. [Nieves et al., 2008], where the program is re-computed for every input instance; Wakaki and Nitta [Wakaki and Nitta, 2008], who use labelling-based semantics; and the approach by Egly et al. [Egly et al., 2010a], which follows extension-based semantics. Here, we focus on the latter—the ASPARTIX approach— [Egly et al., 2010a;
Dvoˇr´ak et al., 2013a; Gaggl et al., 2015], which relies on a query-based implementation where the argumentation framework to be evaluated is pro- vided as an input database. From this point of view, the SAT or CSP
methods can be seen as a compiler-like approach to abstract argumenta- tion, while the ASP method acts like an interpreter.
A large collection of such ASP queries is provided by theASPARTIX-D andASPARTIX-V systems. Furthermore, theDIAMOND system [Ell- mauthaler and Strass, 2014] forAbstract Dialectical Frameworks(ADFs), as well as theGERD system [Dvoˇr´aket al., 2015] forextended argumentation frameworks(EAFs) are based on ASP. In the following, we first give a brief introduction to ASP. We then present how the computation of admissible sets can be encoded in ASP. In order to obtain preferred extensions, it is necessary to check for subset-maximality of admissible sets. We will give pointers to the literature on several approaches for the subset-maximality check and refer to [Charwatet al., 2015] for a detailed discussion.
Background. Let us consider disjunctive logic program under the answer- set semantics [Gelfond and Lifschitz, 1991].10 We fix a countable setU of (domain) elements, also calledconstants, and suppose a total order<over the domain elements. An atom is an expressionp(t1, . . . , tn), where pis a predicateof arity n≥0 and eachti is either a variable or an element from U. An atom isground if it is free of variables. BU denotes the set of all ground atoms overU.
A(disjunctive) rule rwith n≥0, m≥k≥0,n+m >0 is of the form a1∨ · · · ∨an ←b1, . . . , bk, notbk+1, . . . , notbm
where a1, . . . , an, b1, . . . , bm are atoms, and “not” stands for default nega- tion. An atomais a positive literal, whilenotais a default-negated literal.
Thehead ofr is the set H(r) = {a1, . . . , an} and the body of ris B(r) = B+(r)∪B−(r) withB+(r) ={b1, . . . , bk}andB−(r) = {bk+1, . . . , bm}. A ruleris normal ifn≤1 and aconstraint ifn= 0. A ruler issafe if each variable inH(r) occurs in B+(r). A ruleris ground if no variable occurs in r. Afact is a ground rule with a single literal in the head and with an empty body. An (input) database is a set of facts. A program is a finite set of safe disjunctive rules. For a programπand an input databaseD, we often writeπ(D) instead ofD∪π. If each rule in a program is normal (resp.
ground), we call the program normal (resp. ground).
For any program π, let Uπ be the set of all constants appearing in π.
Gr(π) is the set of rules rτ obtained by applying, to each rule r ∈ π, all possible substitutions τ from the variables in r to elements of Uπ. An interpretation I ⊆BU satisfies a ground rule riff H(r)∩I6=∅ whenever B+(r)⊆IandB−(r)∩I=∅. I satisfies a ground programπ, if eachr∈π is satisfied byI. A non-ground ruler(resp. a programπ) is satisfied by an
10For further background, see [Eiteret al., 1997; Brewkaet al., 2011].
interpretationIiffIsatisfies all groundings ofr(resp.Gr(π)). I⊆BUis an answer set ofπiff it is a subset-minimal set satisfying theGelfond-Lifschitz reduct πI ={H(r)←B+(r)|I∩B−(r) =∅, r ∈Gr(π)}. For a program π, we denote the set of its answer sets byAS(π).
Reduction to ASP. We now provide fixed queries for admissible sets in such a way that an argumentation framework AF is given as an input databaseFb and the answer sets of the programπe(Fb) are in a certain one- to-one correspondence with the respective extensions, wheree∈ {AD,PR}.
For an AFAF =hAr,atti, we define
Fb={arg(a)|a∈Ar} ∪ {att(a, b)| ha, bi ∈att}.
We have to guess candidates for the selected type of extensions and then check whether a guessed candidate satisfies the corresponding conditions, where default negation is an appropriate concept to formulate such a guess within a query. In what follows, we use unary predicates in(·) and out(·) to perform a guess for a setS⊆Ar, where in(a) meansa∈S.
Similar to Definition 2.4, we define the subsequent notion of correspon- dence which is relevant for our purposes.
Definition 2.6 LetT ⊆2U be a collection of sets of domain elements and letI ⊆2BU be a collection of sets of ground atoms. We say that T and I correspond to each other, in symbolsT ∼=I, iff
1. for eachS∈ T, there exists an I∈ I, such that{a|in(a)∈I}=S;
2. for eachI ∈ I, there exists an S ∈ T, such that{a|in(a)∈I}=S;
and 3. |T |=|I|.
LetAF =hAr,attibe an argumentation framework. The following pro- gram fragment guesses, when augmented byFb, any subsetS⊆Aand then checks whether the guess is conflict-free inAF:
πcf ={in(X)←notout(X),arg(X);
out(X)←notin(X),arg(X);
←in(X),in(Y),att(X, Y)}.
The program moduleπAD for the admissibility test is as follows:
πAD = πcf ∪ {defeated(X)←in(Y),att(Y, X);
←in(X),att(Y, X),notdefeated(Y)}.
For each conflict-free set one computes the arguments defeated by the set via the predicate defeated/1. The constraint then rules out those sets where an argument in the guessed set is attacked by an argument which is not defeated by the set, thus there is an argument in the conflict-free set which is not defended.
For any AFAF =hAr,atti, the admissible sets ofAF correspond to the answer sets ofπAD augmented byFb, i. e.EAD(AF)∼=AS(πAD(Fb)).
For semantics beyond NP we need to make use ofdisjunctionin the logic program. There are several different ways how to encode these semantics.
The first approach was to use the so calledsaturation encodings as pointed out in [Egly et al., 2010a] which are part of ASPARTIX. Other encod- ings also incorporated inASPARTIX are the metasp encodings [Dvoˇr´ak et al., 2013a], and the recently proposed encodings based on conditional disjunction which make use of a particular property of preferred semantics as shown in [Gagglet al., 2015].
2.2 Direct Implementations
A direct implementation refers to a dedicated algorithm for a reasoning problem of a specific semantics. The advantage is that direct implemen- tations directly incorporate some problem-specific shortcuts, which is often not possible—or it leads to limited improvement—in the case of reduction- based implementations.
2.2.1 Labelling-based Algorithms
Many direct implementations are based on an alternative characterization for semantics using certain labelling functions for arguments [Verheij, 1996b;
Doutre and Mengin, 2001; Modgil and Caminada, 2009; Nofalet al., 2014b;
Nofal et al., 2014a; Verheij, 2007]. A labelling usually assigns each argu- ment one of the following labels Λ = {in,out,undec}, which stand for accepted, rejected and undecided arguments. A labelling is a total function Lab :Ar →Λ. In the following we write x(Lab) for {a∈ Ar | Lab(a) = x}. For instance, in(Lab) is the set of all in-labeled arguments. Some- times we will also represent a labellingLabas the triplehin(Lab),out(Lab), undec(Lab)i.
One advantage of labellings is that the label of one argument has an immediate consequence to its neighbours. For example, if an argument a is labeled with in, all arguments attacked by a will be labeled with out.
Such labelling-based algorithms have been materialized in several systems, see Table 1.
Enumeration. Several labelling-based algorithms to enumerate all exten- sions for various semantics have been proposed. For instance, the algo- rithm in [Nofal et al., 2014a] makes use of five labels, namely Λ = {in,
out,must out,blank,undec}, where the additional labelblankdenotes the not yet labeled arguments andmust out is assigned to arguments that at- tack in-labeled arguments. Initially all arguments are labeled with blank.
Then, the algorithm selects an a∈blank(Lab) which is labeled withinin the left branch andundecin the right branch of the search tree. Every time an argument ais labeled with inall arguments attacked by it are labeled outand all remaining arguments which attackaare labeled withmust out.
These steps are repeated until there are no arguments left to be labeled.
The algorithm stores a preferred extension in one branch if each argument has one of the labels in,outand undecand the in-labeled arguments are not a subset of a previously stored preferred extension. Then, the algorithm backtracks to try to find all preferred extensions.
For the selection of the next argument to be labeled out fromblank(Lab) the following heuristics are used.
• Don’t pick an argument ato label it iniff there is ab ∈ {a}− such that Lab(b)6=outand there is no c∈ {b}− withLab(c) =blank.
• Don’t pick an argumentato label itundeciff eachb∈ {a}− is either labeled withoutormust out.
• First select those blank-labeled argument to be labeledinwhich are not attacked at all or all its attacker are labeled withoutormust out.
• Otherwise, select a blank-labeled argument to be labeled in which attacks the most not out-labeled arguments.
Here we have only considered the case of preferred semantics, but for most of the semantics labelling-based algorithms have been proposed in the literature: algorithms for grounded and stable semantics are given in [Mod- gil and Caminada, 2009]; algorithms for semi-stable and stage semantics can be found in [Caminada, 2007; Caminada, 2010; Modgil and Cami- nada, 2009]. Recently [Nofal, 2013] studied improved algorithms for enu- merating grounded, complete, stable, semi-stable, stage and ideal seman- tics. Labelling-based Algorithms are implemented in the ArguLab [Pod- laszewski et al., 2011] system as well as in the ArgTools [Nofal et al., 2012].
Decision Procedures. In the following we will exemplify the use of la- bellings in an algorithm dedicated to credulous reasoning with preferred semantics, following the work of [Verheij, 2007], which is implemented in the CompArg system. In credulous reasoning one is only interested if a particular argument is accepted in at least one extension, thus we try
to produce a witness (or counter-example) for this argument, instead of computing all extensions.
The algorithm starts with labelling the queried argument withinand all the other arguments withundec. Then, it iterates the following two steps.
Firstly, it checks whether the set ofin-labeled arguments is conflict-free and if so label all arguments attacking them without. Otherwise terminate the branch of the algorithm. Secondly, for each argument a which is labeled outbut not attacked by an argument labelledin, it picks anundeclabeled attackerbofaand label it within. In case there are several such arguments, it starts a new branch of the algorithm for each choice. If no such argument exists it terminates the branch. It stops a branch as soon as no more changes to labellings are made. In that case, it has reached an admissible labelling acting as proof for the credulous acceptance of the queried argument.
Consider the AF of Example 2.5 and the argumentc. In the first step we obtain the following intermediate labelling
Lab1=h{c},{},{a, b, d, e}i.
Asin(Lab1) is conflict-free, we label all arguments attackingcwithout:
Lab2=h{c},{b, d},{a, e}i.
Next we need to make argumentsbanddlegally outby labelling at least one of their attacker within. In case ofb this is already fulfilled ascis labeled within. However, the argumentdhas no attacker, so the algorithm stops.
We could not construct an admissible labelling for accepting the argument c, thus it is not credulously accepted under preferred semantics.
2.2.2 Dynamic Programming-based Approaches
We briefly mention the dynamic programming-based approach, which is defined on tree decompositions of argumentation frameworks. Many argu- mentation problems have been shown to be solvable in linear time for AFs of bounded tree-width [Dunne, 2007; Dvoˇr´aket al., 2012c; Courcelle, 1989].
First introduced in [Dvoˇr´aket al., 2012b], this approach especially aims at the development of efficient algorithms that turn complexity-theoretic re- sults into practice. The algorithms from [Dvoˇr´aket al., 2012b] are capable of solving credulous and skeptical reasoning problems under admissible and preferred semantics. Later, this approach was extended to work with stable and complete semantics [Charwat, 2012]. Further fixed-parameter tractabil- ity results were obtained for AFs with bounded clique-width [Dvoˇr´aket al., 2010] and in the work on backdoor sets for argumentation [Dvoˇr´ak et al., 2012a]. Negative results for other graph parameters like bounded cycle- rank, directed path-width, and Kelly-width can be found in [Dvoˇr´ak et al., 2012b].
Problem
Tree-Decomposition Normalization Dynamic Algorithm Solution
?
- -
6
Parsing
Figure 3. Dynamic-programming approach based on tree-decompositions.
Systems implemented towards this approach are dynPARTIX [Char- wat, 2012; Dvoˇr´ak et al., 2013b] as well as the D-FLAT system [Bliem, 2012; Bliem et al., 2012]. D-FLAT is a general-purpose system that is capable of solving problems from multiple domains. The methodology un- derlying both systems is to build a tree-decomposition of a framework and then run a dynamic programming algorithm on the tree-decomposition to obtain the extensions of the desired semantics, as depicted in Figure 3. For an extensive discussion of the approach we refer to [Charwatet al., 2015].
2.3 Summary
In this section we discussed the two main approaches to implement abstract argumentation frameworks, namely the reduction-based and the direct im- plementation approach. Systems which implement the reduction-based ap- proach are very popular, as they benefit from highly sophisticated solvers.
One can say that they delegate the difficult part of the design of an efficient algorithm to the solvers of the target formalism. This might be the reason why so many solvers make use of this approach (see Table 1). On the other side the direct implementations can incorporate shortcuts if specific proper- ties for certain structures in AFs are known, and in particular when it comes to the reasoning problems of skeptical and credulous acceptance, these al- gorithms can benefit from them. Many direct implementation algorithms make use of labellings. Table 1 summarizes all systems.
3 Structured Argumentation Implementations
This section gives an overview of algorithmic approaches to structured argu- mentation [Besnardet al., 2014] and their respective systems. In contrast to abstract argumentation where arguments are interpreted as abstract enti- ties and only logical relationships between arguments are taken into account,
Direct Reduction-BasedTyp e
Reference
{j}ArgSemSAT Yes SAT [Ceruttiet al., 2014c;
Ceruttiet al., 2016b;
Ceruttiet al., 2017]
ArgTools Yes Labellings [Nofalet al., 2014b]
ArguLab Yes Labellings [Podlaszewskiet al., 2011]
ASGL Yes CSP [Sprotte, 2015]
ASPARTIX-D Yes ASP, SAT [Eglyet al., 2010a;
Gaggl and Manthey, 2015]
ASPARTIX-V Yes ASP [Gagglet al., 2015]
ASSA Yes Matrices [Hadjisoteriou, 2015]
Carneades Yes Labellings [Gordonet al., 2007]
Cegartix Yes SAT [Dvoˇr´aket al., 2014]
CompArg Yes Labellings [Verheij, 2007]
ConArg Yes CSP [Bistarelliet al., 2015]
CoQuiAAS Yes SAT [Lagniezet al., 2015]
DIAMOND Yes ASP [Ellmauthaler and
Strass, 2014]
Dungell Yes Haskell [van Gijzel and Nilsson, 2013]
EqArgSolver Yes Equations, Labellings
[Rodrigues, 2016]
GERD Yes ASP [Dvoˇr´aket al., 2015]
GRIS Yes Equations,
Labellings
[Gabbay and Rodrigues, 2015]
LabSATSolver Yes SAT, Labellings
[Beierleet al., 2015]
LamatzSolver Yes [Lamatz, 2015]
prefMaxSAT Yes SAT [Vallatiet al., 2015;
Faberet al., 2016]
ProGraph Yes [Groza and Groza,
2015]
QADF Yes QBF,
Labellings
[Dilleret al., 2015]
ZJU-ARG Yes Labellings [Liaoet al., 2013]
Table 1. Summary of abstract argumentation implementations.
structured argumentation considers an argument’s internal structure for sev- eral aspects including evaluation. Within formal argumentation, formalisms for structured argumentation assume a formalized knowledge base, often in a logical or rule-based form, from which arguments and their relations are constructed. Conceptually, formalisms for structured argumentation often follow the steps of the so-called argumentation process or argumentation pipeline (see e. g. [Dung, 1995, Sections 4 and 5] and [Caminada and Am- goud, 2007, Section 2]):
1. argument construction;
2. determining conflicts among arguments;
3. evaluation of acceptability of arguments; and 4. drawing conclusions.
Argument construction typically refers to the task of building arguments composed of a claim and a derivation of that claim (e. g. a proof tree) from the given knowledge base. Moreover, conflicts need to be recorded, e. g., when claims of two arguments are contradictory, or when the derivation of an argument’s claim contradicts with the claim of another argument. Eval- uation of acceptability refers to formal means of finding acceptable argu- ments, and finally conclusions can be drawn from the acceptable arguments.
From a computational point of view, all of the steps of the process taken individually can be quite computationally expensive: for instance even con- struction of single arguments may be computationally complex (NP-hard in cases); a large number of arguments may be constructed; finding conflicts can be non-trivial; and evaluation of acceptability has in general a high complexity, as in the case of abstract argumentation.
Several algorithmic approaches have been proposed, which result in a quite heterogeneous and evolving field comprising of many different solu- tions. In the following we highlight properties that distinguish algorithms for structured argumentation from each other.
Reasoning on structural or abstract representation. The first aspect that distinguishes algorithms and systems for structured argumentation is that they may deviate from the conceptual argumentation process. In par- ticular, the approaches can be roughly categorized whether they perform
• (query-based) structural reasoning; or
• reasoning on an abstract representation.
knowledge base a?
b!
c!
evaluation or query-answering on structure
on abstract representation
Figure 4. Argumentation process from a computational point of view
The latter classification encompasses algorithms that explicitly construct an abstract representation, e. g. an AF, and perform reasoning solely on that representation. Algorithms following the other approach construct no such representation, but combine argument construction, conflict discovery, and argument evaluation in possibly interleaving steps and take structured information from the input knowledge base into consideration in possibly every step.
Algorithms that perform structural reasoning are typically query-based, i. e., decide acceptability of a certain claim, and construct arguments for and counterarguments against the queried claim from the knowledge base. A structural approach can restrict argument construction more easily than the abstract approach, in particular for query-based reasoning, since structural information can be used to determine which arguments have an effect on the query or the currently processed argument.
On the other hand, the abstract approach first “compiles” the structured knowledge base and subsequently all reasoning can be performed on the abstraction. In some cases “full” knowledge of all arguments occurring in the abstract representation is required to perform reasoning, e. g. for stable semantics. Conceptually, the abstract approach follows more closely the argumentation process. We illustrate structural and abstract approaches to algorithms for structured argumentation in Figure 4. In this figure trian- gles are arguments with internal structure and round vertices are abstract arguments.
Dedicated and reduction-based approaches. Similarly as for approach- es to implement abstract argumentation, we can distinguish between di-
rect or dedicated approaches and reduction-based approaches to implement structured argumentation. An approach is reduction-based if the input is translated to a problem of another target formalism with available solvers for that problem. Direct algorithms solve the problem at hand with a domain-specific dedicated algorithm. Direct algorithms have the benefit of incorporating domain-specific properties and optimizations more easily.
On the other hand, reduction approaches can re-use off-the-shelf solvers.
Reduction-based approaches for structured argumentation typically incor- porate all involved tasks, i.e., argument construction, conflict evaluation, and deciding acceptability of arguments. When constructing an abstract representation, approaches to structured argumentation can also be hybrid systems, i.e., providing a direct or reduction-based approach for construct- ing the abstraction, and providing another for abstract reasoning. Usual tar- get systems for reduction-based approaches are Prolog systems, solvers for Boolean satisfiability (SAT) and related formalisms, and solvers for answer- set programming (ASP) [Brewkaet al., 2011]. We also call an algorithm or system reduction-based if it incorporates a translation of subproblems to a target language with available solvers.
Considered Approaches. In the following we overview concrete algo- rithmic approaches to structured argumentation, introducing them with examples and discussing the main computational problems, properties of interest from a computational point of view, and algorithms and systems proposed to solve the problem.11 We focus on implemented algorithms for abstract rule-based argumentation (in particular concrete instantiations of the general ASPIC+ formalism) [Prakken, 2010; Modgil and Prakken, 2014], assumption-based argumentation (ABA) [Bondarenko et al., 1997;
Toni, 2014], argumentation based on logic programming, in particular based on defeasible logic programs (DeLPs) [Garc´ıa and Simari, 2004; Garc´ıa and Simari, 2014], argumentation based on classical logic [Besnard and Hunter, 2008], and Carneades [Gordon et al., 2007]. Complementing information can be found in a review of implementations for defeasible reasoning [Bryant and Krause, 2008], in particular sections 4.2.7, 4.3.1, 4.3.2, 4.3.3, and 4.3.4;
in the review for argumentation for the social web [Schneideret al., 2013];
and in the overview on research in argumentation systems given by [Simari, 2011].
11Tools presented and referenced within the following subsections sometimes do not solve the same reasoning tasks proposed for a formalism. We refer the reader to the references for each algorithm and tool for the exact problem definitions that are solved.
rules arguments p→b A1:p b⇒f A2:A1→b p→f A3:A1→f A4:A2⇒f
p b f
p f
A1
A2
A4
A3
A1
A2
A4 A3
Figure 5. Tweety example knowledge base in ASPIC+ (left) with axiomp, structure of corresponding arguments (middle), and AF (right).
3.1 Abstract Rule-Based Argumentation
In this section we focus on systems for abstract rule-based argumenta- tion, in particular concrete instantiations of the ASPIC+ [Prakken, 2010;
Modgil and Prakken, 2014] formalism. We begin with a brief introduction to a concrete instantiation of ASPIC+ following notation of [Modgil and Prakken, 2014]. Input in this formalism is a knowledge base consisting of several components, central among them are (ordinary) premises and ax- ioms, defeasible and strict rules, and preferential information. Semantics are specified via a translation to an abstract argumentation framework. Argu- ments are constructed by chaining premises or axioms with rules. Conflicts among arguments are defined via so-called undercuts, rebuts, and under- mining among arguments, all respecting the preferential information.
We illustrate the concepts in a toy example knowledge base in Figure 5.
Example 3.1 Figure 5 shows two strict rules (with a simple arrow→) and one defeasible rule (using a double-lined arrow⇒), and assumingp(Tweety is a penguin) to be an axiom, one can infer the four arguments shown in the figure, namely by a strict rule that Tweety is a bird (b), that birds normally fly (via a defeasible rule inferring f), and that penguins do not fly (via a strict rule inferring f; note that overlining indicates contrariness). The structure of the arguments is visualized in the middle of Figure 5 where we also see the only conflict in this example, namely that argument A3 attacks A4 via rebut (contradictory conclusions). On the right of Figure 5 the abstract AF is shown.
Computational problems for abstract rule-based argumentation include argument construction, conflict discovery, and semantic evaluation. These problems may be tackled in an intertwined way, for instance interleaving construction and evaluation or following more closely the argumentation process step-by-step and thus firstly constructing the abstract argumenta-
tion framework and then proceeding by semantical evaluation.
As a rough and general outline for algorithms based on structural rea- soning, given a potential conclusion (e. g. Tweety can fly in example Fig- ure 5), arguments can be constructed via backward chaining using rules until premises or axioms are found. For instance, argumentA4can be constructed from conclusionf and back-chaining of two rules until axiompis reached.
Counterarguments can be found in a similar manner by back-chaining from conclusions of arguments that would attack the arguments constructed so far. The so constructed arguments, i. e., arguments in favor of the queried claim and the counterarguments, corresponds to a game-theoretic approach to compute acceptability of the given query (and one of its argument in favor) under the specified semantics. For instance, one can conclude that A3 is contained in an admissible set{A3}.
We begin our survey of systems for abstract rule-based argumentation with theTOASTsystem12[Snaith and Reed, 2012]. TOASTdirectly fol- lows the steps of the argumentation pipeline by constructing an abstract AF from given input knowledge base and delegates the reasoning tasks to a dedicated AF reasoner, namely the Dung-O-Matic web service [Snaith et al., 2010]. As an example, given the input in Figure 5 (left) the sys- tem would return a semantical evaluation of the AF shown on the right of that figure. The TOAST and Dung-O-Matic system together provide a system supporting axioms, premises, assumptions, and preferential infor- mation (last link and weakest link principles, see also [Modgil and Prakken, 2014]), rules, and a user-specified contrariness relation. The system further supports reasoning on the resulting AF under grounded, preferred, semi- stable, and stable semantics. TOAST is available as both a Java-based web service and web form.
Next we overview contributions to systems for abstract rule-based ar- gumentation by Vreeswijk, which influenced subsequent successor systems.
These systems follow query-based structural reasoning. Vreeswijk’s works for argumentation systems are well summarized in the survey of [Bryant and Krause, 2008, Sections 4.3.1, 4.3.2, 4.3.3, and 4.3.4]. A system that re- sulted from Vreeswijk’s PhD thesis [Vreeswijk, 1993],IACAS(InterActive Argumentation System), was written in LISP and is one of the earliest im- plementations of structured argumentation that is capable of handling input with strict and defeasible rules. This system allows for argument generation for or against a queried claim, and concluding its acceptability taking all the arguments into consideration. Vreeswijk’s argumentation system (AS) is a Ruby-based implementation that handles strict and defeasible rules and tries to construct an admissible set containing an argument that concludes the
12http://www.arg.dundee.ac.uk/toast/(on 27/04/2017).
queried claim. Two systems based on Vreeswijk’sAShave been developed, namely the ASPIC Inference EngineandArgue tuProlog [Bryant et al., 2006].
TheASPIC Inference Engineis available from the ASPIC resources at the Cancer Research UK’s Advanced Computation Laboratory.13 It pro- vides both a web-based front-end and aJava-based system that implement query-based structural reasoning under grounded and (credulous) admis- sible semantics. The Java-based implementation offers a graphical user- interface.
A reduction approach to the language of Prolog is used inArgue tuProlog and the system is presented in [Bryantet al., 2006]. The reduction utilizes a game-theoretic approach for implementing ASPIC, similarly as the previ- ous approaches. In contrast to reduction approaches for other formalisms, Argue tuProlog reduces the input to several Prolog queries, i. e., every query for an argument for each player is instantiated as a separate Prolog call and thus the dialogue can be terminated at any time.
We conclude this section with Wietske Visser’s Epistemic and Practical Reasoner (EPR)14 [Visser, 2008] which is a direct Java-based implemen- tation that implements query-based reasoning under grounded semantics, (credulous) admissible semantics, and e-p semantics [Prakken, 2006]. The system provides a graphical user-interface, and is documented in detail in Wietske Visser’s master’s thesis [Visser, 2008].
3.2 Assumption based argumentation
In assumption-based argumentation (ABA) [Bondarenkoet al., 1997; Toni, 2014], arguments and conflicts are drawn from three main components: a knowledge base, a set of assumptions, and a contrariness relation. We il- lustrate these concepts in Figure 6. On the left of Figure 6 we see an ABA framework, with four rules, the set of assumptionsAcontainingaande, and the contrariness relation relating the two assumptions to be contrary tof anddrespectively (denoted viaa=f and e=d). Arguments (in squares) and conflicts (with solid arrows) that can be drawn from this framework are shown on the right of the figure. These arguments correspond to proof trees of claims. More concretely, the arguments’ structure is based on the rules with the conclusion shown on the top of the squares and attacks take place based on assumptions and their contraries. For instance, the argu- ment withf as the conclusion attacks the argument with conclusionb, since this argument requires the assumptionawhich is the contrary off (a=f).
Arguments without assumptions are not attacked, e. g. argument with con-
13http://aspic.cossac.org(on 27/04/2017).
14http://www.wietskevisser.nl/research/epr/(on 27/04/2017).
c← A={a, e}
b←a a=f d←b, c e=d
f ←e a
>
c
e f a b
a b
>
c d
e
Figure 6. ABA framework (left) and its corresponding arguments and at- tacks (right)
clusionc.
Semantics of ABA can be defined via extensions as sets of arguments or, equivalently, as sets of assumptions. For instance, in the example in Figure 6 the set of arguments with claims forc,f, ande(that in this instance uniquely determine the corresponding arguments) is an admissible extension of the ABA framework (no attacks between these arguments are present and all attackers from outside are counterattacked). The corresponding set of assumptions is{e}.
A typical reasoning task for ABA frameworks is to check whether an argument for a given claim is contained in an extension under a specified semantics. The computational complexity for reasoning with an abstract ABA formalism has been investigated in [Bondarenkoet al., 1997]. In [Bon- darenkoet al., 1997] decision problems for credulous and skeptical accep- tance are studied and the complexity ranges from polynomial-time decidable to completeness for ΣP4, a class on the fourth level of the polynomial hier- archy.
Common to several algorithms for computing acceptability of a given claim under a specified semantics in a given ABA framework are so-called dispute derivations [Craven and Toni, 2016; Dung et al., 2006; Dung et al., 2007; Gaertner and Toni, 2007b; Gaertner and Toni, 2008; Toni, 2013].
Intuitively, dispute derivations can be seen as a game-theoretic construc- tive proof of acceptability of the given claim by constructing (part of) the argument in favor of the claim as well as constructing (parts of) its counter- arguments and their counterarguments. Dispute derivations were proposed for grounded, admissible, and ideal semantics, called respectively GB, AB,
and IB15 dispute derivations [Dung et al., 2007], which are an advance- ment of the proof trees proposed in [Dung et al., 2006]. In [Gaertner and Toni, 2007b; Gaertner and Toni, 2008] structured dispute derivations were proposed that explicitly compute the dialectical structure hidden in dispute derivations, e. g., computing the attack structure explicitly. A parametrized version of dispute derivations was proposed in [Toni, 2013] that have a richer output incorporating both equivalent views of semantics of ABA, namely the view of extensions as sets of arguments and sets of assumptions.
In this paper we illustrate concepts of dispute derivations by showing GB-dispute derivations [Dunget al., 2007]. In Figure 7 we see on the left a representation of a simple ABA framework with assumptions A={b, c}
and a rule that infersa without assumptions. The grounded extension of this ABA framework contains the arguments forcanda, which are uniquely determined in this particular framework. A GB-dispute derivation is a se- quence of quadruples (Pi, Oi, Ai, Ci) with integer i denoting the sequence or step. The ingredients for a step are the sentences or nodes for proponent (Pi) and opponent (Oi), the assumptions for defense of the queried claim (Ai) and assumptions for the opponent, so-called culprits (Ci). The com- ponentPi is a set of sentences and bothAiandCiare sets of assumptions.
The second component of the quadruple,Oi, is a set of sets containing sen- tences. For querying acceptability for a claimαwe initialize withP0={α}, A0=α∩A, and emptyO0andC0, whereAis the set of assumptions in the ABA framework. We next illustrate the basics of GB-dispute derivations by recalling the corresponding sequences from [Dunget al., 2007], where we assume a selection functionf that selects at each step either an element in Pior inOiand in the latter case an element of the set selected. For a given ABA framework and a selection function f, a GB-dispute derivation of a defense setD for sentenceαis a finite sequence of quadruples
(P0, O0, A0, C0), . . . ,(Pi, Oi, Ai, Ci), . . . ,(Pn, On, An, Cn)
with P0 = {α}, A0 = α∩A, and empty O0 and C0; Pn = On = ∅ and An = D; and for every 0 ≤ i < nand X =f(Pi, Oi, Ai, Ci) the selected element s. t.
1. ifX ∈Pi then (a) ifX ∈Athen
Pi+1 = Pi\X, Ai+1 = Ai,
Ci+1 = Ci, Oi+1 = Oi∪ {{X}}
15Here, the “B” stands for belief.
