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

Assumption-based argumentation (ABA) is a central structured argumentation formalism. As shown recently, answer set programming (ASP) enables efficiently solving NP-hard reasoning tasks of ABA in practice, in particular in the commonly studied logic programming fragment of ABA. In this work, we harness recent advances in incremental ASP solving for developing effective algorithms for reasoning tasks in the logic programming fragment of ABA that are presumably hard for the second level of the polynomial hierarchy, including skeptical reasoning under preferred semantics as well as preferential reasoning. In particular, we develop non-trivial counterexample-guided abstraction refinement procedures based on incremental ASP solving for these tasks. We also show empirically that the procedures are significantly more effective than previously proposed algorithms for the tasks. This paper is under consideration for acceptance in TPLP.


Introduction
Argumentation, and in particular the study of computational models of argument, constitutes a core research area in artificial intelligence, and knowledge representation and non-monotonic reasoning in particular (Baroni et al. 2018). Computational models for structured argumentation, as opposed to abstract argumentation, make the internal structure of arguments explicit, supporting the view that arguments are most often made explicit through derivations from more basic structures, thereby having an intrinsic structure. Various structured argumentation formalisms have been proposed, each with their own features and applications (Čyras et al. 2018;Modgil and Prakken 2018;Besnard and Hunter 2018;García and Simari 2018).
In this work we focus on the commonly studied logic programming fragment of assumptionbased argumentation (ABA) (Čyras et al. 2018) and its extension, ABA + , equipped with preferences (Čyras and Toni 2016a). These central structured argumentation formalisms have found applications e.g., in decision making in a multi-agent context (Fan et al. 2014), game theory (Fan and Toni 2016), and in choosing treatment recommendations based on clinical guidelines and preferential information given by patients (Čyras and Oliveira 2019). In addition to applications, the challenge of developing efficient systems for ABA reasoning is also highlighted by the 2021 ICCMA argumentation system competition, which for the first time called for ABA reasoning systems for several NP-hard problems.
Among the algorithmic approaches proposed for reasoning in ABA (Dung et al. 2006;Gaertner and Toni 2007;Toni 2013;Craven et al. 2013;Craven and Toni 2016;Lehtonen et al. 2017;Lehtonen et al. 2021), in terms of scalability arguably the currently most efficient practical approach is based on encoding ABA reasoning tasks declaratively using answer set programming (ASP) (Gelfond and Lifschitz 1988;Niemelä 1999), and invoking off-the-shelf ASP solvers for the reasoning part (Lehtonen et al. 2021;Caminada and Schulz 2017). While this approach is noticeably more efficient than other competing ABA reasoning systems on NP-complete variants of ABA reasoning, the approach was not directly extended to cover all beyond-NP variants of ABA reasoning, i.e., reasoning tasks which are presumably hard for the second-level of the polynomial hierarchy. In particular, skeptical acceptance in ABA under preferred semantics was treated resorting to the so-called Asprin approach, although a direct treatment would be viable. Further, credulous reasoning in ABA + under admissible and complete semantics was not covered.
Motivated by the success of ASP-based ABA reasoning, in this work we harness very recent advances in incremental ASP solving (Kaminski et al. 2020;Gebser et al. 2011) for developing counterexample-guided abstraction refinement (Clarke et al. 2003;Clarke et al. 2004) style algorithms for skeptical reasoning in ABA under preferred semantics, as well as credulous reasoning in ABA + under admissible and complete semantics. Compared to the currently existing ABA reasoning systems supporting these tasks, in particular the Asprin-based (Brewka et al. 2015) approach to reasoning in ABA under preferred semantics (Lehtonen et al. 2021), and the ABAplus system (Bao et al. 2017) for enumerating admissible and complete assumption sets in ABA + , our approach provides significant performance improvements in practice and allows for directly reasoning about credulous acceptance in ABA + . Our implementation is available at https://bitbucket.org/coreo-group/aspforaba.
We focus on the commonly studied logic programming fragment of ABA and ABA + . In particular, we assume a deductive system (L , R) with L a set of atoms and R a set of inference rules over L with a rule r ∈ R having the form a 0 ← a 1 , . . . , a n with a i ∈ L . To distinguish ABA atoms from atoms in answer set programming, we refer to the former as sentences. We denote the head of rule r by head(r) = {a 0 } and the (possibly empty) body of r by body(r) = {a 1 , . . . , a n }.
An ABA + framework is a tuple F = (L , R, A , , ≤) with (L , R) a deductive system, a set of assumptions A ⊆ L , a function mapping assumptions A to sentences L , and a preorder ≤ on A . The strict counterpart < of ≤ is defined as usual by a < b iff a ≤ b and b ≤ a, for a, b ∈ A . An ABA framework, that is ABA + without preferences, is an ABA + framework with ≤ = / 0, denoted by (L , R, A , ). In this paper, we focus on so-called flat ABA + frameworks where assumptions cannot be derived, i.e., do not occur in heads of rules. We assume that each set in an ABA + is finite.
There are two notions of derivations for ABA: tree-derivations and forward-derivations. ABA + is in general defined through tree-derivations. We briefly recall both notions. A sentence s ∈ L is tree-derivable from a set of assumptions X ⊆ A and rules R ⊆ R, denoted by X |= R s, if there is a finite tree with the root labeled by s, the leaves labeled by elements of X, and for each internal node there is a rule r ∈ R such that the node itself is labeled by head(r) and the set of labels of the children of this node is body(r). For each rule r ∈ R there is a node labeled in this way. For brevity, R can be left unspecified and be assumed to be some suitable subset of R. A sentence a ∈ L is forward-derivable from a set X ⊆ A via rules R, denoted by X R a, if there is a sequence of rules (r 1 , . . . , r n ) such that head(r n ) = a, for each rule r i we have r i ∈ R, and each sentence in the body of r i is derived from rules earlier in the sequence or is in X, i.e., body(r i ) ⊆ X ∪ j<i head(r j ). The deductive closure for an assumption set X w.r.t. rules R is given by Th R (X) = {a | X R a}.
Definition 1 Let (L , R, A , , ≤) be an ABA + framework, and A, B ⊆ A be two sets of assumptions.
In words, set A attacks B if (i) from a subset A of A, one can tree-derive a contrary of an assumption b ∈ B and no member in A is strictly less preferred than b, or (ii) from B, via subset B one can tree-derive a contrary of an assumption a ∈ A and some member of B is strictly less preferred than a. Attacks of type (i) are normal <-attacks and those of type (ii) reverse <-attacks, with the intuition that the (non-preference based) conflict in (i) succeeds and in case of (ii) is countered and reversed by the preference relation. For brevity, we omit set notation when A <-attacks a singleton {b} (then we say A <-attacks b).
Definition 3 Let F = (L , R, A , , ≤) be an ABA + framework. Further, let A ⊆ A be a conflict-free set of assumptions in F. Set A is • <-complete in F if A is admissible in F and contains every assumption set defended by A; We use the term <-σ assumption set for an assumption set under a semantics σ ∈ {adm, com, prf }, i.e., <-admissible, <-complete, and <-preferred assumption set, respectively.
For ABA, we refer to the corresponding semantics without the preference relation < (e.g., complete semantics instead of <-complete semantics). Attacks ( / 0-attacks) in ABA frameworks simplify to attacks from A to B when Main reasoning tasks on ABA + are the following.

Definition 4
Let F = (L , R, A , , ≤) be an ABA + framework and <-σ a semantics. A sentence s ∈ L is The tasks for ABA are analogous (disregarding <).

Example 1
Let F be an ABA + framework with A = {a, b, c}, b = x, c = y, a < c, and R = {(x ← a), (y ← a)}. We have {a} normally <-attacks b and {c} reversely <-attacks a. The <-admissible sets of F are / 0, {c}, and {b, c}, and the framework has the unique <-complete set {b, c}.
We focus on computationally hard reasoning tasks in ABA and ABA + . Deciding skeptical acceptance under preferred semantics in ABA is Π P 2 -complete (Dimopoulos et al. 2002). In ABA + , credulous acceptance under <-admissible semantics is Σ P 2 -complete, and checking whether a set is <-admissible and <-complete is coNP-complete and coNP-hard, respectively (Lehtonen et al. 2021).

Algorithms
We present ASP-based counterexample-guided abstraction refinement (CEGAR) algorithms for beyond-NP reasoning tasks in ABA and ABA + . The CEGAR-based algorithms follow the iterative schema of considering an NP-abstraction of the solution space (containing spurious solutions), and drawing candidates from this space. At each iteration, a candidate solution is obtained (if one remains) by calling an ASP solver. If no further candidate solutions can be obtained, the search terminates. If a candidate is obtained, one checks with another ASP solver call whether the candidate is an actual solution. If it is, the search terminates. If not, a counterexample is obtained, and the abstraction is refined (solution space is reduced) by ruling out from further consideration at least the candidate solution.
We briefly recap basic ASP concepts. An answer set program π consists of rules r of the form h ← b 1 , . . . , b k , not b k+1 , . . . , not b m , where h and each b i is an atom. A literal is an atom or a default negated (not ) atom. A rule is positive if k = m, a fact if m = 0, and a constraint if there is no head h (then a shorthand for the same rule with a fresh atom a in the head and default negated in the body). An atom b i has the form p(t 1 , . . . ,t n ) with p a predicate and with each t j a constant or a variable. An answer set program, a rule, and an atom, respectively, is ground if it is free of variables. For a non-ground program, GP is the set of rules obtained by applying all possible substitutions from the variables to the set of constants appearing in the program. An interpretation I, i.e., a subset of all the ground atoms, satisfies a positive rule r = h ← b 1 , . . . , b k iff all positive body elements b 1 , . . . , b k are in I implies that the head atom is in I. For a program π consisting only of positive rules, let Cl(π) be the uniquely determined interpretation I that satisfies all rules in π and no subset of I satisfies all rules in π. Interpretation I is an answer set of a ground 0}} is the reduct; and of a non-ground program π if I is an answer set of GP of π. A program π is satisfiable iff there is an answer set of π.
We make use of the following shorthands. Let I be an interpretation (set of ASP atoms), p be some ASP predicate of arity one, and M = {l 1 , . . . , l n } a set of ASP literals. We define p(I) = {p(x) | p(x) ∈ I}, and constr(M) = ← l 1 , . . . , l n . That is, p(I) is a set of atoms p(x) which are contained in the interpretation, and constr(M) is an ASP constraint containing M as its body. For reasons of convenience, if l is an ASP literal, we also define the shorthand constr(l) = ← l (i.e., allowing M to be a set or a single literal).
In the following we refer to forward-derivations when talking about derivations. For ABA, tree and forward-derivations are equivalent for the problems considered here (Dung et al. 2006;Dung et al. 2010). While forward-derivations are not directly applicable for ABA + , for our approach to <-admissible and <-complete semantics we employ previous results (Lehtonen et al. 2021) together with new ones (Section 3.2), which allow for avoiding naive application of tree-derivations which would require explicitly constructing arguments.

Skeptical Acceptance under Preferred Semantics
We begin with skeptical reasoning under preferred semantics in ABA, which is a Π P 2 -complete problem. Following successful schemes for the same reasoning task on abstract argumentation frameworks (AFs) (Cerutti et al. 2018), we present Algorithm 1 for deciding skeptical acceptance of sentences in an ABA framework. We encode the given ABA framework F = (L , R, A , ) as ASP: assign each rule a unique identifier (R = {r 1 , ..., r n }) and let Listing 1 presents module π com for finding complete assumption sets, including a possible queried sentence (Lehtonen et al. 2021). Now I is an answer set of ABA(F) ∪ π com iff {a | in(a) ∈ I} is a complete assumption set of F, and one can derive the sentence x from this complete assumption set iff supported(x) ∈ I. Further, out(I) contains the assumptions of F that are not part of in(I).
Algorithm 1 decides skeptical acceptance under preferred semantics for ABA frameworks by first generating a complete assumption set 1 within the framework that does not derive the queried sentence s (Line 2). If there is no answer set found in the first application of the while loop in Line 2, then all complete assumption sets of F derive s, and the algorithm terminates. Otherwise, we add to the ASP encoding π the constraint ruling out the complete set encoded in in(I) as a solution: we add constr(out(I)), which states that at least one atom in out(I) must not be present in an answer set from now on (excluding in(I) and its subsets). Subsequently, we iteratively generate proper supersets of a currently found complete assumption set not deriving s (loop starting in Line 5). When this inner loop terminates, we found a complete assumption set that is ⊆-maximal among all complete assumption sets that do not derive s, and π currently contains the last constraint ruling out this particular complete assumption set and its subsets. In Line 8, we check with an ASP solver call whether π ∪ in(I) := π ∪ {in(a). | in(a) ∈ I} is satisfiable. If it is, there is a complete assumption set that is a proper superset of the assumptions encoded in in(I) and that derives s. In this case in(I) is not a preferred assumption set and thus not a counterexample to s being skeptically accepted under preferred semantics, so the algorithm proceeds to searching for a new candidate (Line 2). Importantly, π still contains the constraints ruling out any subset of in(I). On the other hand, if in Line 8 the ASP solver reports unsatisfiability, in(I) represents a preferred assumption set not deriving s, constituting a counterexample to s being skeptically accepted under preferred semantics. To enumerate all preferred assumption sets, it suffices to omit the query and Line 8, and collect each answer after exiting the inner loop; see Appendix A.
The following proposition states the correctness of the approach; correctness follows by the previous discussion on the details of the algorithm and the employed encodings.

Proposition 1
Algorithm 1 decides skeptical acceptance under preferred semantics for ABA frameworks, i.e., for a given ABA framework F = (L , R, A , ) and sentence s ∈ L , Algorithm 1 returns YES if s is skeptically accepted under preferred semantics in F, and NO otherwise.

ABA + Properties
We move on to ABA + , in this section first giving an alternative characterization of <-admissible and <-complete semantics to better suit our algorithmic setting, and then showing complexity membership result for <-complete semantics. In contrast to ABA (and AFs), credulous acceptance under <-admissible and <-complete semantics does not coincide (Čyras 2017, Example 3.6). Further, <-attacks differ from (non-preference-based) attacks, requiring more complex computation (Lehtonen et al. 2021). We begin with stating conditions for an assumption set to be <-admissible or <-complete, on which we base our algorithms. Define for an assumption set A the set of assumptions U not individually <-attacked by A by U = {a ∈ A | A does not <-attack a}.

Proposition 2
Given an ABA + framework F, a conflict-free set of assumptions A in F, and the set of assumptions U that A does not individually <-attack, it holds that

Proof
For the first item, assume that A is <-admissible. It follows that if a set B of assumptions <attacks A we have A <-attacks B (A defends itself due to admissibility). Thus, there is no B s.t. B <-attacks A and A does not <-attack B. For the other direction, assume that there is no B ⊆ U such that A does not <-attack B and B <-attacks A. Suppose there is a set C of assumptions that <-attacks A. If C ∩ (A \U) = / 0 (C contains an assumption outside U), then A <-attacks C (on a particular assumption, and, due to subset monotonicity of <-attacks, also C). Consider the case that C ∩ (A \U) = / 0. Then C ⊆ U (since U ⊆ A ). If A does not <-attack C, then we arrive at a contradiction (contradicts our assumption of the right hand side of the formal statement). Thus, A <-attacks C. It follows that A defends itself against all C ⊆ A that <-attack A. Since A is assumed to be conflict-free, it follows that A is <-admissible.
For the second item, assume that A is <-complete. Then A is <-admissible by definition. Let a ∈ A \ A. It follows from definition that A does not defend {a}. This implies that there is a set B that <-attacks {a} and A does not <-attack B. Since A <-attacks any set C with C ∩U = / 0, we have B ⊆ U. For the other direction, assume that A is <-admissible, and for all a ∈ A \ A there is a set B ⊆ U such that B <-attacks {a} and A does not <-attack B. Suppose A is not <-complete: then there is a set C such that A defends C and C ⊆ A. Let c ∈ C \ A, implying that c ∈ A \ A. Then, by assumption, there is a B ⊆ U such that B <-attacks {c} and A does not <-attack B. This is a contradiction to {c} being defended by A. Thus, A is <-complete.
The first item implies that we can focus on assumption sets among U for checking defense. From the second item, it follows that given a <-complete assumption set A, for every a ∈ U (and even for every a ∈ A ) it holds that either a ∈ A, or U <-attacks a. This fact can be used to prune candidates for <-complete assumption sets.
Complementing earlier results, we show a complexity membership result for credulous acceptance under <-complete semantics. The proof uses Proposition 2 and an earlier result (Lehtonen et al. 2021, Proposition 11): after guessing a set of assumptions, checking <-admissibility amounts to verifying whether each <-attacker is <-attacked (in coNP), and checking whether the set contains all defended sets amounts to checking for each individual assumption outside A whether this assumption is not defended (each check in NP).

Theorem 3
Credulous acceptance under <-complete semantics in ABA + is in Σ P 2 .

Proof
Non-deterministically construct a set of assumptions A. Now check whether (i) the queried sentence is derivable from A, (ii) A is <-admissible, and (iii) A is <-complete. Checking (i) and conflict-freeness can be done in polynomial time. Construct U = {u ∈ A | A does not <-attack u}, which is doable in polynomial time (Lehtonen et al. 2021, Proposition 11, item 1). For checking further conditions of <-admissibility, check for each set of assumptions B ⊆ U whether B <-attacks A without A <-attacking B. Checking for two concrete sets of assumptions whether one <-attacks the other is doable in polynomial time (Lehtonen et al. 2021, Proposition 11, items 1 and 2). Thus, one can check whether A defends itself via a check in coNP. For checking whether A is also <-complete, check for each a ∈ A \ A whether there is some set B ⊆ U such that B <-attacks a and A does not <-attack B. This is in NP. These checks establish whether A is <-complete, by Proposition 2, and whether the queried sentence is derivable from A, satisfying the definition of credulous acceptance. Overall, this gives a non-deterministic polynomial time algorithm that accesses an NP oracle, showing membership in Σ P 2 for credulous acceptance under <-complete semantics.

<-Admissible Semantics
We proceed to algorithms for ABA + , starting with Algorithm 2 for deciding credulous acceptance under <-admissible semantics in a given ABA + framework F. This algorithm can be straightforwardly extended to cover enumeration of all <-admissible sets. We first give details of the algorithm, and subsequently explanations of the underlying ASP encodings.
We represent a given ABA + framework F = (L , R, A , , ≤) in ASP as ABA + (F) = ABA(F) ∪ {preferred(x, y). | y ≤ x} ∪ π + preferences . Listing 2 shows π + preferences . Algorithm 2 employs the ASP modules π cand = ABA + (F)∪π + cf ∪{constr(not supported(s))} and π check = ABA + (F)∪π + defended ∪ π + suspect−defeat . The former, π cand , encodes the abstraction (candidate search space) by considering conflict-free sets of assumptions that contain the queried sentence s in in(I), for an answer set I of the encoding, and additionally computes all singleton assumptions not <-attacked by in(I), in the ASP atoms undefeated(I). In Line 5 of Algorithm 2 we check, based on Proposition 2, whether in(I) corresponds to an <-admissible set in F: the ASP encoding is satisfiable iff there is a subset of undefeated(I) that is not <-attacked by in(I) but that <-attacks in(I) (via either normal or reverse <-attacks). If in(I) does correspond to an <-admissible set, this is a witness to s being credulously accepted. Otherwise, we exclude this assumption set via the constraint constr(out(I) ∪ in(I)).
We present π + cf in Listing 3, π + defended in Listing 4 and π + suspect−defeat in Listing 5. The first six lines of Listing 3 encode conflict-freeness (note that conflict-freeness is independent of preferences (Čyras and Toni 2016b)). In brief, in(I) encodes a guess of an assumption set and supported(I) which sentences are derivable from this set. For computing assumptions x that are individually <-attacked by the assumptions A encoded by in(I), we make use of a result proven by Lehtonen et al. (2021, Lemma 8). Checking whether A normally <-attacks an x can directly be encoded by forward-derivations: if from the subset A ⊆ A which are not less preferred to x one can derive the contrary of x, a normal <-attack from A to x exists. For the remaining assumptions, it holds that A reversely <-attacks x if from {x} one can derive the contrary of an assumption a ∈ A with x < a.
From in(I) and undefeated(I) obtained as facts from an earlier ASP call, the encodings in Listings 4 and 5 determine whether in(I) defends itself against undefeated(I). In Listing 4, we guess a subset of the undefeated assumptions (called suspects here) and check whether this set <-attacks in(I) but is not <-attacked by in(I) (making in(I) undefended and not <-admissible). Line 1 encodes the guess and normal <-attacks as before. Reverse <-attacks from a set larger than one are more involved; the idea is taken from Lehtonen et al. (2021, proof of Proposition 11.2). We compute what is supported by in(I). The set in(I) is reversely <-attacked by the suspect(I) set if one can tree-derive from in(I) a contrary of an assumption x in the suspect(I) set, with the required assumptions among in(I) having an assumption less preferred than x. To show that there is such a derivation tree from a subset A of the assumptions corresponding to in(I) that derives a contrary y of x, with one assumption a ∈ A being less preferred than x, we check whether one can reach y from a via the derivation rules (implying existence of such a tree). In Listing 5, normal and reverse <-attacks from in(I) to suspect(I) are determined analogously to <-attacks from suspect(I) to in(I). The final constraints of Listings 4 and 5 ensure that suspect(I) <-attacks in(I), but not vice versa. If ABA + (F) ∪ π + defended ∪ π + suspect−defeat is unsatisfiable, the assumption set encoded in in(I) defends itself.
The following proposition states the correctness of Algorithm 2 based on Proposition 2 and the previous discussion on the details of the algorithm and the employed encodings.

<-Complete Semantics
For deciding credulous acceptance under <-complete semantics, we present Algorithm 3. There are two key differences to Algorithm 2: the abstraction π cand is stronger and verifying whether a candidate assumption set is <-complete is more involved. For the former, in addition to the constraints posed in Algorithm 2, we add that if in(I) corresponds to a conflict-free set of assumptions A and U is the set of all assumptions which are not individually <-attacked by A, then for each a ∈ U it must hold that either a ∈ A or a is <-attacked by U. By Proposition 2, this only rules out assumption sets that are not <-complete. As we will see in the experiments, pruning the search space in this manner can significantly speed up computation. For verifying whether a conflict-free set of assumptions is <-complete, Algorithm 3 checks in Lines 7-9 for each a ∈ U whether a is defended by A, in addition to verifying <-admissibility (Line 6).
Enumeration of <-complete assumption sets can be achieved by reporting all found answers and not terminating until there are no candidates, and finding a <-complete assumption set by omitting the query and reporting in(I) on Line 9; see Appendix A. Enumeration also finds the <-grounded assumption set, which is defined as the intersection of all <-complete sets.
In module π + prune (Listing 6) we compute <-attacks on singleton assumptions. We consider singleton assumptions in U, and whether they are <-attacked by U. The final constraint rules out exactly the condition mentioned after Proposition 2, namely that there is an a ∈ A such that a / ∈ in(I) and a is not <-attacked by U. Via the encoding in Listing 7 together with Listing 5 we check whether, given a set in(I) and an assumption target(I), in(I) defends target(I). More specifically the module is unsatisfiable if there is no set of assumptions, called suspects here, that attack target(I) without in(I) attacking Listing 6: Module π + prune pref supported by undefeated(X,Y) ← no less preferred(X,Y), assumption(X), undefeated(X). pref supported by undefeated(X,Y) ← head(R,X), pref triggered by undefeated(R,Y). pref triggered by undefeated(R,Y) ← pref supported by undefeated(X,Y) : body(R,X), assumption(Y), head(R, ). undefeated normally defeated by undefeated(Y) ← undefeated(Y), pref supported by undefeated(X,Y), contrary(Y,X). undefeated reversely defeated by undefeated(Z) ← less preferred(Z,X), undefeated(X), contrary(X,Y), derivable from undefeated(Y,Z). ← out(Y), undefeated(Y), not undefeated normally defeated by undefeated(Y), not undefeated reversely defeated by undefeated(Y).
← not target normally attacked, not target reversely attacked.
the suspect set. In other words, the encoding is unsatisfiable if the target(I) is defended by in(I).
We check if the target is normally or reversely <-attacked via suspect(I). As before, in Listing 5 we compute normal and reverse <-attacks from in(I) to the suspect(I) set.
The following proposition states the correctness of the approach.

Proposition 5
Algorithm 3 decides credulous acceptance under <-complete semantics, i.e., for a given ABA framework F = (L , R, A , ) and s ∈ L , Algorithm 3 returns YES if s is credulously accepted under <-complete semantics in F, and NO otherwise.

Empirical Evaluation
We implemented the ASP-based CEGAR algorithms using the incremental Python interface of Clingo v5.4.0 (Gebser et al. 2016;Kaminski et al. 2020). The implementation is available at https://bitbucket.org/coreo-group/aspforaba. We empirically evaluate its performance, comparing it to current state-of-the-art approaches: the Asprin-based (Brewka et al. 2015) approach to skeptical acceptance under preferred semantics (Lehtonen et al. 2021) and the ABAplus system which supports computing assumption sets in ABA + under <-admissible and <-complete semantics (Bao et al. 2017). A direct comparison with ABAplus is only applicable for frameworks which satisfy the so-called WCP property due to restrictions in ABAplus.
For comparison with Asprin we use similar benchmarks as Lehtonen et al. (2021), with |L | = 250, 500, 1000, 1500, . . . , 8000. For each |L |, we generated 20 frameworks with 15% and 30% of the sentences assumptions each for a total of 680 frameworks. The number of rules per head and body lengths, respectively, were randomly chosen from [1,20]. For comparison with ABAplus, we use the 120 frameworks that satisfy the WCP property first used by Lehtonen et al. (2021) containing up to 30 sentences. The experiments were run single-threaded on 2.6-GHz Intel Xeon E5-2670 processors using per-instance 600-s time and 16-GB memory limit. Figure 1 (left) shows a per-instance runtime comparison of the Asprin-based approach and our incremental ASP-based CEGAR algorithm for skeptical ABA reasoning under preferred semantics. The CEGAR approach clearly outperforms Asprin. A comparison of ABAplus and our CE-GAR approach is shown in Table 1. The CEGAR approach dominates ABAplus in performance on the task of assumption set enumeration (as supported by ABAplus) under both <-admissible and <-complete semantics. We conclude that the CEGAR algorithms based on incremental ASP outperform the current state of the art on all of the three reasoning tasks.
Runtimes for Asprin are in its enumeration mode rather than query mode as Asprin is consistently faster on this task using enumeration, as shown in Figure 2 (left). Conversely, Figure 2 (right) shows that using our CEGAR approach, most instances are solved faster via direct skeptical reasoning compared to assumption set enumeration; there is only a handful of instances on which enumeration is faster.
For more insights into our CEGAR approach to ABA + , we generated larger instances with 50-500 sentences. For each |L |, we generated 30 instances with 15% and 30% assumptions each taking as preferences random permutations of the assumptions, with assumption a i set to be preferred to a j for i < j in the permutation with probabilities 5%, 15% or 40% (10 instances for each probability). On these instances the stronger abstraction for <-complete semantics yields significant runtime improvements over the weaker abstraction, enabling scaling up to 500 sentences (Figure 1 right). The runtime improvements are at least in part due to the fact that the stronger abstraction results in considerably fewer iterations (essentially number of candidates found). Using the weaker abstraction the algorithm takes on average 1148 iterations, compared to 12 when using the stronger abstraction. Figure 3 (left) shows the iterations taken to solve each instance. Further, the runtimes of the CEGAR approach using the stronger abstraction under <-complete semantics are similar between the task of finding an assumption set without a query and credulous reasoning on both unsatisfiable and satisfiable instances; Figure 3 (right) shows the overall runtime results for credulous reasoning under <-complete semantics. We also observe that with a larger number of sentences being assumptions (30% vs 15%) instances tend to become harder to solve for all the considered problems.

Conclusions
We developed an approach to beyond-NP reasoning in assumption-based argumentation frameworks based on recent advances in incremental answer set solving. In particular, we detailed ASP-based counterexample-guided abstraction refinement procedures for skeptical acceptance under preferred semantics in ABA and credulous reasoning under <-admissible and <-complete semantics in ABA + , and assumption set enumeration for all of these. Our implementation of the approach empirically outperforms previous algorithmic solutions to these reasoning tasks. We developed a stricter abstraction for <-complete semantics, speeding up solving in practice, and obtained complexity upper bounds for credulous reasoning in ABA + under <-complete semantics. A promising direction for further work is to extend the CEGAR approach considered in this work to other beyond-NP reasoning problems in ABA, such as reasoning over general (i.e. possibly non-flat) ABA frameworks.