Complexity of abstract argumentation under a claim-centric view
Introduction
Formal argumentation is a vibrant field within AI. On the one hand, it provides genuine methods to model discourses or legal cases [4]. On the other hand, it is closely related to – and gives an orthogonal view on – several formalisms from the AI domain, including logic programming or nonmonotonic reasoning principles [22], [44], [13]. For both applications, a particular model is widely used which is known as instantiation-based argumentation (see e.g. [36]). An important step towards high-performance implementations of such argumentation systems is to understand the exact complexity of the underlying reasoning tasks and, in case of intractability results, to identify subclasses that can be solved efficiently. However, as we will clarify below, the vast majority of complexity analyses in the area of argumentation is in a certain sense decoupled from the instantiation-based approach, making some of these results inappropriate to identify the actual complexity of corresponding decision problems within instantiation-based argumentation.
Let us therefore start with delineating this approach. The instantiation process starts from a knowledge base (KB), which is potentially inconsistent. From KB, all possible arguments are constructed first. An argument typically contains a claim and a support which is a subset of KB and derives the claim. Next, the relationship between arguments is analysed. A standard model is to consider that argument α attacks argument β if the claim of α contradicts (parts of) the support of β. As soon as all arguments and attacks between arguments are given, one abstracts away from the contents of the arguments and it is only the remaining attack network that is evaluated, which is thus termed abstract argumentation framework (AF). Semantics for AFs then deliver a collection of sets of arguments which are understood as jointly acceptable; these sets are commonly referred to as extensions.
Example 1 Instantiating AFs from Logic Programs Let be a logic program (LP). The instantiation approach from [13] yields an AF with arguments , where α represents rule and has claim a; β represents rule with claim b; and represent rules and respectively, and both have as their claim c. The attack relation R is constructed, such that an argument representing rule r attacks an argument representing rule if the head of r occurs negated in the rule body of . Hence, ; see Fig. 1. Under this construction, stable model semantics of LPs corresponds to stable extensions of AFs (we omit technical details, they are not important for the sake of the argument; stable extensions of AFs will be formally introduced in the next section). In our example, the two stable models and of P are given via the two stable extensions and of . Note that the claims of yield and those of yield . ◊
Having computed the extensions, the instantiation process is completed by re-interpreting these sets of arguments in terms of their claims. Typical are credulous and skeptical acceptance queries, which can be posed on argument names or their claims. For instance, for skeptical acceptance one might be interested whether a particular argument α is contained in all extensions (we will refer to this kind of reasoning as argument-centric). However, in the light of the above discussion the following question (which gives a claim-centric view) appears more appropriate.
(SKEPT): is a particular claim c covered by all extensions, i.e. does every extension contain at least one argument with claim c?
Example 1 continued With the extensions of being and of , we note that no argument is skeptically accepted. However, c is a skeptical consequence of the program P. Hence, in order to check whether some claim is covered by each extension, we need to connect claims to their arguments, since argument acceptance alone is insufficient to decide this problem. ◊
This subtle difference between skeptical reasoning on arguments and skeptical reasoning on claims has already been noticed by Prakken and Vreeswijk [40, Example 25] and is also discussed in the recent handbook-chapter on ASPIC [39, Def. 2.18 and below].
While the complexity of deciding the acceptance of arguments is well explored (see e.g. [25], [15], [23], [32] and [27] for a survey), it is not sufficient or even misleading to simply transfer these results when considering the acceptance of claims. In contrast, the complexity of the entire instantiation process is largely unexplored, with the notable exception of the complexity analysis of assumption-based argumentation [19], [24]. While the complexity of constructing the arguments and identifying the conflicts is very specific to the concrete instantiation, the reasoning step that involves the acceptance of claims is common to many argumentation formalisms. The latter is what we shall investigate in this paper.
To this end, we introduce claim-augmented argumentation frameworks, that expand AFs by explicitly storing the claim of each argument. Such augmented frameworks allow (i) for a natural way of expressing the extensions in terms of claims, that might be shared across multiple arguments, relaxing the abstraction of AFs to some extent; (ii) for investigations of the computational complexity of reasoning over claims in terms of the initial KB. Understanding the complexity of this task is a key towards systems that perform sufficiently efficient in practical cases. In particular, as many of the reasoning problems are in general of high complexity, identifying tractable cases for these problems is crucial. However, as the existing literature on complexity analysis for (abstract) argumentation solely is concerned with reasoning over argument names (see e.g. [27]), it is unclear whether and how existing tractable fragments apply to the claim-centric view. Moreover, knowing which arguments have the same claims also provides new potential for tractable fragments.
In this paper, we shall thus provide a comprehensive complexity analysis for decision problems on argumentation frameworks which are centred on claims rather than on arguments. We will study two scenarios: (1) AFs where claims are attached to arguments in an arbitrary way, i.e. where we make no assumptions on the construction of the argumentation framework; (2) AFs where the assignments of claims to arguments satisfy a particular condition that reflects the assumption that an argument α attacks argument β if the claim of α contradicts (parts of) the support of β (like in the example above). Given that the attacks are constructed in that way, we have that arguments with the same claim attack the same arguments. We call such frameworks well-formed. The concept of well-formed frameworks represents the most fundamental case for instantiation-based argumentation, and follows the way argument frameworks are constructed in the realm of instantiations from Logic Programming [13], Assumption-based Argumentation [42], and the ASPIC+ framework (without preferences) [39]. The more relaxed variant (1) applies to (more advanced) instantiations without such restrictions on the attack relation, which allows to take concepts like argument strength or preferences into account.
Main contributions.
- •
We adapt the four main decision problems studied in the literature to our proposed model and provide a complete complexity analysis for seven popular semantics, namely conflict-free, naive, grounded, admissible, complete, stable and preferred. Moreover, we investigate the coherence problem which asks whether stable and preferred extensions coincide. Our results demonstrate that switching from an argument-centric view to a claim-centric view can lead to higher complexity, in particular for the verification problem.
- •
We show that in the case of well-formed frameworks this divergence is less drastic, and it is only the skeptical acceptance of naive semantics that remains harder than in the argument-centric case.
- •
In addition, we also address the complexity of common sub-classes of frameworks when adapted to our settings and provide fixed-parameter tractability results. In particular, the concept of claims being attached to arguments gives rise to novel parameterisations which are inaccessible in the standard argument-centric view.
A preliminary version of this paper has been presented at the thirty-third AAAI conference on artificial intelligence (AAAI-19) [34]. Beside providing full proofs and more detailed discussions, this version extends the preceding paper by several new complexity results, in particular results for the coherence problem.
Section snippets
Preliminaries
Let us introduce argumentation frameworks [22] and recall the semantics we study (for a comprehensive introduction, see [5]).
Definition 1 An argumentation framework (AF) is a pair where A is a finite1 set of arguments and is the attack relation. The pair means that a attacks b, and we say that a set attacks (in F) an argument b if
Claim-augmented argumentation frameworks
To ease our claim-centric complexity analysis, we consider AFs augmented by claims as a distinguished concept. We simply associate a claim to each argument in an AF and redefine extensions in terms of the claims. This will allow us to rephrase in a natural way the standard decision problems for AFs under a claim-centric view.
Definition 3 A claim-augmented argumentation framework (CAF for short) is a triple where is an AF and assigns a claim to each argument of A; is the set of
General complexity results
The concept of CAFs now allows us to adapt typical computational problems to our needs (recall the (SKEPT) problem from the introduction) and to study the complexity of abstract argumentation under a claim-centric view. Given semantics σ, a CAF , claim , and claims , we consider the following decision problems.
- •
: Does hold for at least one ? In other words, is c supported by at least one extension of , i.e. for some ?
- •
:
Analysing the tractability frontier
Most of the problems considered in the previous section are computationally intractable while the importance of efficient algorithms is evident. For AFs there is a line of research to overcome the complexity of hard problems by considering special graph classes or certain parameters that characterise the structure of the AF. In what follows, we consider those problems which we have identified to be computationally hard and examine potential tractable fragments and graph parameters. Given the
Discussion
Related work. Baroni et al. [9] propose multi stage labelling systems on top of argumentation systems. They model different ways from argument acceptance to statement justification (see also [8], [10]), and distinguish between argument- and statement-focused approaches to argumentation; the latter is in line with our claim-centric view. Their multi-labelling systems encompass several statement justification strategies from the literature and allow for a systematic comparison of structured
Declaration of Competing Interest
The authors declare that they have no known competing financial interests or personal relationships that could have appeared to influence the work reported in this paper.
Acknowledgements
The authors are grateful to the anonymous reviewers for their careful reviews and helpful comments.
This work is supported by the Austrian Science Fund (FWF): grants I2854, P30168, P32830 and Y698, and by the Vienna Science and Technology Fund (WWTF) under grant ICT19-065.
References (44)
- et al.
Easy problems for tree-decomposable graphs
J. Algorithms
(1991) - et al.
A general semi-structured formalism for computational argumentation: definition, properties, and examples of application
Artif. Intell.
(2018) - et al.
On the evaluation of argumentation formalisms
Artif. Intell.
(2007) - et al.
On the equivalence between logic programming semantics and argumentation semantics
Int. J. Approx. Reason.
(2015) Graph rewriting: an algebraic and logic approach
- et al.
On the fixed parameter complexity of graph enumeration problems definable in monadic second-order logic
Discrete Appl. Math.
(2001) - et al.
On the computational complexity of assumption-based argumentation for default reasoning
Artif. Intell.
(2002) - et al.
Graph theoretical structures in logic programs and default theories
Theor. Comput. Sci.
(1996) Computational properties of argument systems satisfying graph-theoretic constraints
Artif. Intell.
(2007)The computational complexity of ideal semantics
Artif. Intell.
(2009)
Coherence in finite argument systems
Artif. Intell.
Augmenting tractable fragments of abstract argumentation
Artif. Intell.
Towards fixed-parameter tractable algorithms for abstract argumentation
Artif. Intell.
Complexity of semi-stable and stage semantics in argumentation frameworks
Inf. Process. Lett.
Instantiating abstract argumentation with classical logic arguments: postulates and properties
Artif. Intell.
Graph minors. II. Algorithmic aspects of tree-width
J. Algorithms
Logical limits of abstract argumentation frameworks
J. Appl. Non-Class. Log.
Computational Complexity: A Modern Approach
Towards artificial argumentation
AI Mag.
An introduction to argumentation semantics
Knowl. Eng. Rev.
On extension counting problems in argumentation frameworks
On the justification of statements in argumentation-based reasoning
Cited by (23)
A claim-centric perspective on abstract argumentation semantics: Claim-defeat, principles, and expressiveness
2023, Artificial IntelligenceThe complexity landscape of claim-augmented argumentation frameworks
2023, Artificial IntelligenceRepresentative Answer Sets: Collecting Something of Everything
2023, Frontiers in Artificial Intelligence and ApplicationsThe Effect of Preferences in Abstract Argumentation under a Claim-Centric View
2023, Proceedings of the 37th AAAI Conference on Artificial Intelligence, AAAI 2023On the Expressive Power of Assumption-Based Argumentation
2023, Lecture Notes in Computer Science (including subseries Lecture Notes in Artificial Intelligence and Lecture Notes in Bioinformatics)