Theoretical Analysis and Implementation of Abstract Argumentation Frameworks with Domain Assignments

. A representational limitation of current argumentation frameworks is their inability to deal with sets of entities and their properties, for example to express that an argument is applicable for a specific set of entities that have a certain property and not applicable for all the others. In order to address this limitation, we recently introduced Abstract Argumentation Frameworks with Domain Assignments (AAFDs), which extend Abstract Argumentation Frameworks (AAFs) by assigning to each argument a domain of application, i.e., a set of entities for which the argument is believed to apply. We provided formal definitions of AAFDs and their semantics, showed with examples how this model can support various features of commonsense and non-monotonic reasoning, and studied its relation to AAFs. In this paper, aiming to provide a deeper insight into this new model, we present more results on the relation between AAFDs and AAFs and the properties of the AAFD semantics, and we introduce an alternative, more expressive way to define the domains of arguments using logical predicates. We also offer an implementation of AAFDs based on Answer Set Programming (ASP) and evaluate it using a range of experiments with synthetic datasets.


Introduction
The production and evaluation of argumentative discourse rarely consists of opinions whose claims can precisely be judged as either true or false.There are almost always shades of truthfulness, which make a statement hold in certain situations and not in others.Non-monotonic, case-based, context-aware, defeasible and other forms of reasoning are based, to a smaller or larger extent, on this need to specify the conditions under which a proposition holds or, similarly, to refine the scope within which it can be accounted true.This paper presents a formal method to support such a refinement process using an argumentative formulation.
Both abstract [21] and structured argumentation frameworks [9] enable the revision of the acceptability status of arguments in the light of new evidence or stronger counterarguments.There is a rich literature on different semantics for deciding the acceptance of arguments.Yet, these frameworks are challenged when one does not need to decide whether an argument is generally valid or not, but rather to argue on the specific cases where it should be accepted.
Consider the following argument taken from a typical example of commonsense reasoning: "This fruit is an apple, and since apples are typically red, this fruit is red".The claim is based on a premise about apples that constitutes common knowledge.Apparently, there are numerous exceptions to this knowledge, such as Granny Smiths, rotten apples etc; nevertheless, an attack on the original argument with the position "This apple is a Granny Smith and Granny Smiths are green, therefore this apple is green" should not be read as an attempt to invalidate the argument altogether, but rather to limit the domain of its applicability: apples may still be red in general, and the same argument should still be considered valid in most cases, but when apples belong to a given cultivar, things may be different.Apart from commonsense reasoning, a similar need can be found in other domains, as for instance in negotiation dialogues, especially for multi-party quid pro quo conversations, in the legal domain, where the organisation of similar cases within the same argument is a typical practice for modelling legislation, or in security (or any other type of) policies, which specify both the "default" cases and all possible exceptions.
The representation of exceptional cases can be accommodated by non-monotonic logics, but not by argumentation frameworks, in which arguments are atomic entities.Thus, unless one creates one argument for each different element of the argument's domain, argumentation frameworks cannot distinguish between an argument about a specific entity and one referring to a set of entities of the same type, and cannot accommodate a notion of "partial acceptance", where an argument is acceptable for some entities only.
Structured argumentation frameworks are often used for modelling scenarios like the above.Under most structured argumentation approaches, such as deductive argumentation [10] or rule-based argumentation (ASPIC + ) [37], modelling a domain is based on a set of rules (e.g., "Granny Smiths are typically green") and a set of base facts, that determine, e.g., whether a given object is an apple, Granny Smith or otherwise.Reasoning then proceeds for any given object of interest, and any exceptional cases are considered for this specific object "as they arise" from the given rules and base facts.Interestingly, most structured argumentation frameworks are only used to generate the arguments and their relationships, whereas the reasoning for determining acceptability is still done using some abstract model (typically Dung's AAFs [21]).Thus, these models can handle only part of the reasoning process, namely the argument generation part; acceptability determination is handled by an abstract model.
Motivated by the above, we introduced in [40] a novel argumentation framework called "Abstract Argumentation Framework with Domain assignments" (AAFDs), in which arguments are abstract, but have a domain of application describing the cases that each argument can be applied to.As with other abstract frameworks, AAFDs include a binary attack relation, whose role is, however, different: instead of invalidating an argument or reducing its strength, it limits its domain of application (called scope).This allows capturing and reasoning with exceptional cases and "partial acceptance".Moreover, the concept of domains allows AAFDs to "lift" the domain modelling from the structured to the abstract level, thus providing an alternative way to perform the entire argumentation pipeline (including both the argument generation and the argument evaluation) using a single model.
In this paper, we extend the theoretical results presented in [40], by providing: (i) a method for partitioning an AAFD according to a partition of its universe (set of elements that can appear in the domain of an argument), which enables computing the extensions of an AAFD by combining the extensions of its parts; and (ii) an alternative, logicbased definition of the domain of an argument, which is more intuitive and expressive, and which enables integrating background knowledge (e.g. from ontologies, knowledge graphs or other knowledge bases) into an AAFD.We also present results on the practical application of the framework; specifically, (iii) an implementation of AAFDs in Answer Set Programming (ASP); (iv) an evaluation of the ASP implementation using a range of experiments with synthetic datasets; and (v) an example application of the ASP implementation for solving a team building problem.
In the rest of the paper, following a discussion of related work in Section 2, we present the definitions of AAFDs and their semantics in Section 3. In Section 4, we present some theoretical results, including a mapping to Abstract Argumentation Frameworks (AAFs), some complexity results, properties of the AAFD semantics, and a method for partitioning an AAFD.In Section 5, we present the ASP implementation, whereas the respective experimental evaluation appears in Section 6.In Section 7, we present the logic-based characterization of AAFDs discussed above.Finally, in Section 8, we conclude the paper and discuss our plans for future work.

Related work
Computational argumentation has largely been based on [21], in which an Abstract Argumentation Framework (AAF) was defined as a directed graph, i.e., a pair ⟨A, R⟩ consisting of a (possible infinite) set of arguments A and a binary attack relation R on this set.Then, different acceptability semantics for AAFs were defined in terms of extensions, i.e., sets of arguments that can be considered acceptable.In particular, a set S ⊆ A is: conflict-free iff it contains no arguments attacking each other, i.e., there is no a, b ∈ S such that (a, b) ∈ R admissible iff it is conflict-free and defends all its elements, i.e., for each argument b ∈ A attacking an argument a ∈ S (that is, (b, a) ∈ R), there is an argument in c ∈ S such that (c, b) ∈ R complete iff it is admissible and contains all the arguments it defends grounded iff it is minimal (w.r.t.set inclusion) among the complete extensions preferred iff it is maximal among the admissible extensions stable iff it is conflict-free and attacks all the arguments that it does not contain (i.e., for all arguments b ∈ A \ S, there is a ∈ S such that (a, b) ∈ R) Following that paper, various extensions have been proposed, enabling attacks to be directed towards attacks [5], adding support [17], preference [3] or other types of relations [34], adding weights to arguments [2] or attacks [24], associating arguments with values [8], or imposing hierarchies on arguments [35].However, little attention has been paid to what we call the scope of an argument, i.e., the class of entities that an argument can be applied to, despite the fact that it has been studied in other related areas, such as discourse analysis [38], linguistic argumentation [42] and political argumentation [41].
A recently proposed extension of AAFs allows associating arguments with topics [16].Topics and arguments are semantically interrelated, and the acceptability of an argument depends on the semantic proximity of the arguments that defend it.An important difference with our work is that acceptability is defined in terms of sets of arguments that satisfy certain conditions, so each argument is either accepted or not; in AAFDs, arguments may be partially accepted, i.e., accepted only for a set of entities.
Value-based Argumentation Frameworks (VAF) [8,32], like AAFDs, associate arguments with values.The meaning and the role of these values however is much different in the two frameworks.In VAFs, a value assigned to an argument represents the value that the argument promotes and preferences between values are used to impose an order over the arguments.In AAFDs the elements assigned to an argument represent the entities that the argument can be applied to, and they are inherent parts of the argument.
Structured argumentation frameworks (e.g., ASPIC + [37], ABA [13], DeLP [26]) provide ways to represent and reason with domain knowledge.For example, Hunter [30] investigates various ways to support non-monotonic reasoning in deductive argumentation [11], while other frameworks leverage (possibly defeasible) domain knowledge expressed in the base logic in the form of rules in order to construct arguments [37,26,13].Contradictions (possibly explicitly stated) are employed to determine attacks between arguments, which, in turn, allow the determination of acceptable arguments using some abstract argumentation framework.
Non-monotonic inheritance networks [29], which consist of nodes representing individuals or classes, and directed links, representing taxonomic relations, capture the idea of attacks that restrict the scope of arguments.However, they only enable reasoning with taxonomic relations and can be translated to AAFs [22].
Incomplete Abstract Argumentation Frameworks (IAAFs) were originally introduced by Dung in [20].In applications, incomplete argumentation frameworks may arise as intermediate states in an elicitation process, or when merging different beliefs about the state of an argumentation framework, or in cases where complete information cannot be obtained.In [7] IAAFs were brought back to light as the authors consider two specific models of IAAFs, one focusing on attack incompleteness and the other on argument incompleteness.IAAFs allow various interpretations of the arguments and the attacks that they make, due to the incomplete knowledge we have about them.Our framework indicates upon which elements an argument is applicable, which is different from interpreting arguments and attacks in more than one way, due to missing knowledge.

Domain Assignments
In this paper, we equip arguments with a domain of application, which corresponds to the elements of a given universe that the argument applies to; for example, an argument about apples refers to a specific set of elements, namely apples, and its validity does not extend to other elements of the universe, e.g., other fruits.The domain of application can be viewed, intuitively, as a way of breaking down an argument into a possibly infinite number of pieces, one for each element of its domain.These pieces do not refer to a logical part of the argument, e.g., a premise, but rather to the elements that the argument (as a whole) applies to, which can be accepted or rejected independently of the rest.This breakdown allows an argument to be attacked only for a specific part of its domain, i.e., some of its pieces, as in the introductory example, where an argument about Granny Smith apples only attacks the argument about apples on the specific subdomain of Granny Smith apples, without affecting its validity for other apples.This idea has the consequence that an attack does not necessarily invalidate an argument totally, and thus an argument can be partially accepted, i.e., accepted for only some elements of its domain.
To formalise these ideas, we use domain assignments, which are functions that associate each argument to a prior and posterior domain of application.The prior domain of application (or simply domain) represents the elements of the universe that the argument applies to.Attacks among arguments limit the applicability of the attacked argument, resulting in the argument's posterior domain of application (or simply scope), which represents the elements for which the argument is accepted as valid.Formally: Definition 1 (Domain Assignment).Consider a non-empty set U , called the universe, and a set of arguments A. A domain assignment of A to U is a function that maps each argument to a subset of U , i.e., D U : A → 2 U .
Scopes are the counterparts of extensions in the standard AAF semantics [21].In particular, an argument a of an AAF is accepted by an extension S if and only if a ∈ S. In AAFDs, acceptance refers to elements of arguments: an element u is accepted for an argument a if and only if u ∈ D U (a) for a posterior domain of application (scope) D U .Note how this captures the intuition of "partial acceptance", as explained above, i.e., the ability to accept an argument only for some of the elements that it applies to.
In the following, we fix some universe U , and omit reference to it for simplicity.Recall that Abstract Argumentation Frameworks (AAFs) are defined in [21] as a pair consisting of a set of arguments and a set of attacks (binary relation) among them.Abstract Argumentation Frameworks with Domain Assignments are AAFs equipped with a domain assignment: Definition 2 (AAFDs).An Abstract Argumentation Framework with Domain assignments, or AAFD for short, is a triple ⟨A, R, D U ⟩, such that A is a set of arguments, R ⊆ A 2 is a binary relation among arguments, and D U : A → 2 U is a domain assignment of A to U , called the prior domain assignment (or simply domain).

Semantics for AAFDs: Intuition and Desiderata
In Abstract Argumentation Frameworks [21], semantics are defined through extensions, which are subsets of the original set of arguments that satisfy specific properties.To allow partial acceptance, our analysis needs to be more fine-grained, and should concern the arguments' domains, rather than the arguments themselves.In particular, the semantics of an AAFD is defined as a domain assignment (the scope) that determines the subsets of the arguments' domains that satisfy certain properties, giving rise to semantics analogous to the classical ones (admissible, complete, etc.).
Before defining formally the semantics of an AAFD, we provide some relevant desiderata, inspired by postulates and principles defined in other related contexts (e.g., [6,23]).
The first requirement is about the relationship between the domain and the scope of the argument.In particular, we argue that the scope of an argument must always be a subset of its domain.This is reasonable, because the applicability of an argument is an inherent property of the argument, determined by the modeller based on its logical content; therefore, the argumentation framework (and its attacks) cannot increase it.This gives rise to the domain capping constraint (DC).
Further, the domain of an argument should not be arbitrarily reduced.For every element "missing" from the domain of an argument, there should be a valid reason, i.e., some external attack.In other words, if a subset of the domain of an argument receives no attack, it should be part of the argument's scope.This gives rise to the scope maximality constraint (SM).Note that a corollary of (DC) and (SM) combined is that an argument receiving no attack should be fully accepted, i.e., its scope should be equal to its domain.
The third requirement ensures that arguments are consistent to each other with respect to their scope.For example, if a attacks b, and u is in the domain of both a, b, then u cannot be in the scope of both arguments.This is called the scope consistency constraint (SC).
Another interesting intuition stems from considering elements that always appear "together" in the arguments' domains.Such elements are, in a sense, "indistinguishable", and there seems to be no reason to differentiate among them.In other words, elements that always appear together in the arguments' domains, should also appear together in their scope.This is the equal treatment constraint (ET).
To formalise this constraint, we will need to define the concept of elements that always appear "together": Definition 3 (Indistinguishable).Two elements u 1 , u 2 ∈ U are called indistinguishable, if and only if, for all a ∈ A, u 1 ∈ D U (a) if and only if u 2 ∈ D U (a).We write u 1 ∼ u 2 to denote that u 1 , u 2 are indistinguishable.
It is trivial to see that the relation ∼ is an equivalence relation (i.e., reflexive, symmetric and transitive), and thus breaks down U into disjoint equivalence classes.We denote by C = {C i } the equivalence classes generated by ∼.
Using Definition 3, we can now formally define the above constraints:

Semantics for AAFDs: formal definitions
To define our semantics, we first introduce the notion of limiting the domain of application: given a set of arguments A, and two domain assignments for all a ∈ A.
In the following, we define various classes of scope, which give rise to the respective semantics.In all the following definitions, we assume a fixed AAFD F = ⟨A, R, D U ⟩, and some scope D U : A → 2 U .As an example, we use the simple AAFD depicted in Figure 1, where U = {x, y, z}, A = {a, b}, R = {(a, b), (b, a)} and D U (a) = {x, y}, D U (b) = {x, y, z}.If we disregard the domains of a and b, the argument graph is the same as the one that was used by Dung to represent the famous Nixon's diamond problem, with a (in Dung's paper) standing for the argument "Nixon is anti-pacifist since he is a republican", and b standing for "Nixon is a pacifist since he is a Quaker" [21].Here, a and b represent two more general arguments: "all republicans are anti-pacifists", and "all Quakers are pacifists", respectively.Nixon is represented by one of the elements in the domain of both arguments, for example, x.The other two elements represent other people that we may want to reason about, e.g., y may represent Herbert Hoover who, like Nixon, was both a republican and a Quaker, while z may represent John Hickenlooper, a Quaker that is a member of the Democratic Party.
We start with the notion of compliant scope: A scope that is compliant simply guarantees that no arbitrary assignments are made as described by the DC requirement (see also Proposition 7).For this example framework, the scope D U Conflict-freeness ensures that the SC requirement is satisfied (see Proposition 7).Returning to the example of Figure 1, we note that Acceptability is defined as follows: Definition 6 (Acceptability).For a ∈ A, u ∈ U , such that u ∈ D U (a), the pair (a, u) is acceptable with respect to D U if and only if, whenever (b, a) ∈ R and u ∈ D U (b), there exists some c ∈ A such that (c, b) ∈ R and u ∈ D U (c).
An argument a ∈ A is called fully acceptable with respect to D U iff (a, u) is acceptable with respect to D U for all u ∈ D U (a) and D U (a) ̸ = ∅.It is called non-acceptable with respect to D U iff there is no u ∈ D U (a) such that (a, u) is acceptable with respect to D U .It is called partially acceptable with respect to D U if it is neither fully acceptable, nor non-acceptable with respect to D U .Using Definition 6, we can now define admissibility in AAFDs as follows: Definition 7 (Admissible).The scope D U is admissible if and only if it is conflict-free, and (a, u) is acceptable with respect to D U , for all a ∈ A, u ∈ D U (a).
Continuing the example of Figure 1, we note that the scope In the AAFD of Figure 1 To illustrate the above definitions, let us consider again the AAFD in Figure 1, and the following assignments: We can easily show that all the above assignments are complete.The only grounded one is D U 7 , whereas D U 5 , D U 6 , D U 8 are preferred and stable.None of the above types of scope captures the ideas behind the ET requirement described in Section 3.2.The following definition achieves that, using the notion of indistinguishable elements (Definition 3):

Looking at the previous examples, we note that D
Note that canonical semantics are orthogonal to other semantics, so any scope that is, e.g., admissible, complete, etc., may (or may not) also be canonical.
In the following, we use the following shorthands for the semantics introduced above: cm for compliant, cf for conflict-free, ad for admissible, co for complete, pr for preferred, gr for grounded, st for stable and ca for canonical.We use σ as a catchall symbol to indicate any of the above; for example, we write co-scope to refer to a complete scope, and σ-scope to refer to a scope of the type denoted by σ.
Following common practice in the argumentation literature, we can also define credulous and skeptical justification based on the available semantics [4].However, due to the nature of AAFDs, these notions apply to elements of arguments, not to arguments alone, and are based on the scopes (which are the counterpart of extensions in the standard AAFs).Formally: Definition 13.Consider an AAFD ⟨A, R, D U ⟩, some scope semantics σ, an element u ∈ U and some argument a ∈ A. We say that u is credulously justified (or credulously accepted) if and only if there exists some σ-scope D U such that u ∈ D U (a).We say that u is skeptically justified (or skeptically accepted) if and only if u ∈ D U (a) for all σ-scopes D U and there exists at least one σ-scope D U .

Formal properties and results for AAFDs 4.1 Mapping AAFDs to AAFs
Interestingly, it can be shown that the semantics of AAFDs are fully compatible with the classical semantics of AAFs [21], i.e., an AAFD can be viewed as an AAF (and viceversa, of course, e.g., when U is a singleton set).On the other hand, AAFDs provide a much more compact and intuitive representation.Below, we describe two different ways to map AAFDs to AAFs.
Natural mapping.For the first mapping, we assume that each element in the domain of an argument is spawning an argument in the AAF (creating also attacks in the natural way).In other words, each element u ∈ D U (a), along with the argument a itself (as a pair, a u ) are mapped into an argument in the AAF (see also Figure 2).Formally, the natural mapping is a mapping Φ nat , which maps an AAFD ⟨A, R, For simplicity, we abuse notation, and denote by , where D U is a compliant scope.In words, Φ nat (D U ) returns all elements a u such that u is in the scope of a (according to D U ).
The assumption for D U being a compliant scope is crucial for defining Φ nat (D U ). Indeed, if D U was not compliant, then it would force us to spawn elements of the form a u , where u / ∈ D U (a); such elements do not appear in A * .
The following proposition shows the equivalence in the semantics of the two representations: Fig. 2: Applying Φ nat on the AAFD of Figure 1 Natural mapping with equivalences.Although Φ nat achieves the required effect of mapping an AAFD into an AAF with equivalent semantics, it is not efficient because the size of the resulting AAF is highly dependent on the size of U , which is expected to be large (or even infinite).We show here a more sophisticated mapping, which leads to an AAF whose size only depends on the number of arguments in AAFD, but not on the size of U .The idea stems from the notion of indistinguishable elements (Definition 3), and applies only for compliant and canonical scopes.
The natural mapping with equivalences Φ [nat] is very similar to Φ nat , except that it creates, for each a ∈ A and for each equivalence class C i , just one argument in the AAF.In other words, if a ∈ A, u 1 ∼ u 2 (say u 1 , u 2 ∈ C 1 ) and u 1 , u 2 ∈ D U (a), then, instead of creating two arguments in the AAF (namely a u1 , a u2 ), Φ [nat] creates just one (a C1 ). Figure 3 shows the application of Φ [nat] on the AAFD of Example 1, for the equivalence classes Formally, we define a mapping Φ [nat] , which maps an AAFD ⟨A, R, Again, we abuse notation, and denote by , where D U is a compliant and canonical scope.As before, this allows us to model the scope of AAFD arguments in the AAF representation.Note that, in the above definition of Φ [nat] (D U ), the assumption for D U being a compliant and canonical scope is crucial.For compliance, the reason is similar to the respective reason given in the description of the natural mapping Φ nat .With respect to canonical, suppose that D U is not canonical and take some . Then, it is not clear whether a C (which essentially represents both u 1 and u 2 as candidates for inclusion in the scope of a) should be in on the AAFD of Figure 1 The following result shows that Φ [nat] preserves the semantics during the mapping of an AAFD to an AAF; note, however, that this result applies only when we restrict ourselves to the realm of canonical scopes: , and a compliant and canonical scope D U in F.Then, for σ ∈ {cf , ad, co, gr, pr, st},

Complexity results
Next, we consider the problem of determining the complexity of reasoning with AAFDs, as well as the size benefits that the more compact representation of AAFDs provides, compared to its respective AAF (through the Φ nat and Φ [nat] mappings).
We first address the problem of how to represent AAFs and AAFDs, as well as the respective sizes.For AAFs, the result is trivial: the size of F = ⟨A, R⟩ is |F|= |A|+|R|≤ |A|+|A| 2 = O(|A| 2 ).For AAFDs the respective result is given in the following proposition: Proposition 3. Consider an AAFD F = ⟨A, R, D U ⟩ defined over universe U , and let C be the set of equivalence classes determined by the equivalence relation ∼ over F. Then: Using the above result, Proposition 4 provides bounds (both standard and asympotic) for the size of an AAF that corresponds to an AAFD (under Several interesting observations can be made from Proposition 4. First, the AAFD representation is typically more compact than its respective AAF (see results #2, #5), as the latter can be quadratic in size in the worst-case scenario (under both mappings) with respect to the former.Note that this is only a worst-case scenario: for example, one could create an AAFD where the elements are assigned in arguments in such a way that the respective attacks do not materialise (i.e., arguments attacking each other having disjoint elements).Such a structure would create a small AAF, as the non-materialised attacks will not be represented in the result.If such non-materialised attacks are numerous enough, an AAFD may end up being larger than its respective AAF.On the other hand, if we don't have such "bogus" attacks in the AAFD, then the AAFD is a more compact representation, because the respective AAF will have as many arguments as the mappings of D U in the AAFD (typically many more than the AAFD's arguments), and its attacks will correspondingly be much more numerous.
Another interesting observation stems from results #3 and #4, and the fact that we typically expect |A| to be much smaller than |U |, as the elements in question are usually expected to be more numerous than the rules (arguments) that apply to them.If it is the case that 2 |A| ≤ |U |, then the bound given by result #3 is tighter than the one given by #4, and thus the worst-case size of Φ [nat] (F) does not depend on U .On the other hand, when U is not as large, we can still employ the bound of result #4, which is identical to the one given for Φ nat (result #1).The same observations apply for the asymptotic sizes.A corollary of the above analysis is also the fact that Φ [nat] is at least as spaceefficient as Φ nat in all cases (result #6).The following important corollary follows also from result #3 of Proposition 4: With regards to time complexity, Proposition 5 below shows that there is a quadratictime reduction of any reasoning problem in AAFDs to its respective problem in AAFs (as expected, by the results of Proposition 4): Proposition 5.For any given reasoning problem in AAFDs, there is a polynomial-time (quadratic) reduction to the respective reasoning problem in AAFs.
It should be noted that the above analysis regarding the space and time complexity applies for the simple representation of AAFDs, where domains are represented through the enumeration of their elements.More sophisticated representations (e.g., through predicates or other methods -see Section 7) may have a much smaller representational footprint, but may incur additional computational overheads (to determine the domains, as needed).Further analysis would require specific assumptions on the type of predicates/formulas used for the representation, and is omitted.

Properties of AAFD semantics
The equivalence between the semantics of AAFDs and AAFs (Proposition 1) means that most of the results that have appeared in the literature regarding AAFs can be trivially applied to AAFDs as well (e.g., on the existence, multiplicity, and relation of different types of scope).In particular, cf , ad, co, gr and pr-scopes always exist, the gr-scope is unique, a st-scope is also a pr-scope, a scope that is pr or gr is also co, a co-scope is ad, and an ad-scope is cf .Also, a cf -scope is cm, by definition.The proof of these results follows directly from Proposition 1 and the respective results in [21] and elsewhere.We can also show the following, which is specific for AAFDs: Proposition 6.In any AAFD, there exists at least one cm-scope and at least one σscope that is also a ca-scope, for σ ∈ {cm, cf , ad, co, gr, pr}.Also, if there exists a st-scope, then there exists a st-scope that is also a ca-scope.
The following proposition shows how the various semantics defined in Section 3.3 meet the requirements described in Section 3.2: Proposition 7. Consider an AAFD ⟨A, R, D U ⟩ and a scope D U .Then: -For σ ∈ {cm, cf , ad, co, pr, gr, st}, if D U is a σ-scope, then it satisfies DC.
-If D U is a ca-scope, then it satisfies ET.
-If D U is ca-σ, then it satisfies DC, SM, SC, ET.
-If D U is ca-st, then it satisfies DC, SM, SC, ET.
From Corollary 2, it follows that a scope that is ca-co, ca-gr, or ca-pr always exists, and it satisfies all requirements set in Subsection 3.2.Thus, although suitability of semantics is application-dependent, we argue that ca-co, ca-gr and ca-pr-scopes seem more plausible for most applications.The same is true for ca-st-scopes, when they exist.

Partitions of AAFDs
An important observation regarding AAFDs is that the computation of the semantics for some element (or subset of elements) of the universe is independent of the other elements.Therefore, one can "break down" the computation of an AAFD's semantics by considering partitions of the universe U , and restricting the AAFD over these partitions.Then, by combining the resulting semantics of each partition, we can get the semantics of the original AAFD.Note that any partition of U would do; in the extreme case, each element of the universe can be treated individually.
To understand this, consider the AAFD shown in the top-left of Figure 4. We can break down (partition) U into its elements, and compute the respective scope for each, as visualised in the other boxes of Figure 4.Then, we can combine the semantics of the different restrictions, by taking all combinations; the result will be the scope of the original AAFD.-In F {y} , the scope that assigns y to c is complete.
-In F {z} , the scope that assigns z to a is complete.
-In F {w} , the scope that assigns w to b, d is complete.
-In F {v} , the scope that assigns v to b, d is complete.
Similarly, if you take any other combination of co-scopes for the restricted AAFDs and combine them, you get a complete extension for F (and vice-versa); and the same holds for all types of semantics.This idea is formalised next.
whose universe is V , and which is defined as follows: Now, we define the partition of an AAFD, which consists of breaking down the universe into disjoint pieces, and taking the restriction for each: Definition 15.Consider an AAFD F = ⟨A, R, D U ⟩, and a family of sets V = {V i }, such that V i ⊆ U for all i.Set F Vi the restriction of F on V i .Then, the family {F Vi } is called a partition of F if and only if i V i = V and V i ∩ V j = ∅ for all i ̸ = j.
Given an AAFD F and its corresponding equivalence relation (∼), and the set of equivalence classes that ∼ generates (say {C i }), the family {F Ci } is a partition of F that we will call the canonical partition.Another interesting partition is the one in which all V i are singleton sets, i.e., {F {u} | u ∈ U }; this is called the atomic partition.Note that the partition shown in Figure 4 is an atomic partition, but also a canonical one.
Next, we provide a method to combine the scopes of the AAFDs in a partition, to create the "combined scope": Definition 16.Given a family of functions f i : X → 2 Yi , we define the concatenation of f i as the function f : X → 2 i Yi such that f (x) = i f i (x).We denote f by ⊔ i f i .
Note that scopes are essentially mappings (i.e., functions) returning sets of elements.Thus, the concatenation operator can be applied on them, and corresponds to the "combination" (mentioned informally above) of the scopes of the AAFDs that compose the partition of a larger AAFD.More formally, the following theorem holds: Proposition 8. Consider an AAFD F = ⟨A, R, D U ⟩ and a partition {F Vi } of F.Then, the following hold: 1.For σ ∈ {cm, cf , ad, co, pr, gr, st} it holds that D Vi is a σ-scope in F Vi for all i if and only if Proposition 8 essentially captures the intuition mentioned in the beginning of this subsection: we can decide whether a scope is a σ-scope (for any semantics σ), by checking whether its components generated by any given partition are σ-scope.Conversely, we can construct a σ-scope by identifying σ-scopes of smaller AAFDs (the partitions of the original).The latter observation means that the above result can be leveraged in different ways when it comes to the implementation of AAFD semantics for more efficient implementations.
One possible way is to consider the atomic partition.Under this viewing, each of the restricted AAFDs has a singleton universe, so it is essentially an AAF, and standard, optimized algorithms for computing each semantics can be used (see [18] for a related survey).Then, the results of these algorithms can be composed to compute the actual σ-scopes of the original AAFD.
Another way is to use the canonical partition, which also guarantees that the results will be canonical (according to the second case of Proposition 8).On the other hand, a canonical partition is not necessarily an atomic one, so we need to resort to implementations specifically tailored for AAFDs (or, we could use the trick above with the atomic partition, to reduce each computation to the computation of AAF semantics).
In this section, we present an implementation of the different AAFD semantics using a declarative programming language, namely the Answer Set Programming (ASP [33]) formalism.We further discuss the encoding of a problem that is often met in various domains, in order to showcase the simplicity in modelling both theoretical and practical notions using AAFDs.A Web interface is also available for users to run custom examples 1 .

An Encoding of AAFD Semantics
The implementation of the different AAFD semantics was driven by our aim to generate a simple and intuitive, rather than an efficient, encoding.As such, we chose ASP, a highly expressive declarative programming language, which enables the encoding of the semantics to be very close to the formal definitions, and the formulation of application domains and queries to become straightforward.The fact that ASP can be executed by very efficient reasoners, such as Clingo [27] and Asprin2 [14] is a bonus; nevertheless, if efficiency is the target, one can develop custom programming techniques or rely on solvers properly adapted for efficient handling of argumentation frameworks, which might result in better performance, such as ASPARTIX [25], pyglaf [1], µ-toksia [36] or ConArg [12].
For our programs, a problem instance needs to be modelled following a specific format, in order to be properly interpreted by the AAFD encodings.Specifically, arguments definition, elements definition, domain assignments, and attack relations need to be modelled as shown next: argument(arg1).argument(arg2).... element(elem1).element(elem2).... domain(argXX, elemYY).

... attacks(argXX, argZZ).
That is, the argument/1 and element/1 unary predicates, and the domain/2 and attacks/2 binary predicates can be used to populate a particular domain and to axiomatise the attack relations among arguments.For instance, attacks(arg1, arg2) defines an attack from argument arg1 to argument arg2, whereas domain(arg1, elemA) indicates that the element elemA is assigned to the domain of argument arg1.
We now explain how we compute the different AAFD semantics using ASP (the code is also available in Appendix B).For all semantics, the program first generates all possible scopes, i.e., all possible assignments of elements to arguments, using the following choice rule (note that words starting with a capital letter denote variables): {scope(A, U) : element(U)} :-argument(A).
Given the argument and element instances defined for a particular domain, this rule generates all possible scopes, i.e., all possible assignments of elements to arguments.
Then, using the constraint shown next, the program eliminates all non-compliant scopes, i.e., all scopes that assign elements to arguments that are not included in their domain; in other words, with this constraint in place, the program implements the definition of compliant scopes (Def.4): :-scope(A, U), not domain(A, U).
The following constraint further eliminates any scope that assigns the same element to two arguments that are in conflict, resulting in the set of conflict-free scopes (Def.5): :-attacks(A1, A2), scope(A1, U), scope(A2, U).
In order to implement the ad-semantics, additionally to the above clauses, we use the following rules to define when an assignment is acceptable (as per Def.

acceptable(A, U) :domain(A, U), not notAcceptable(A, U).
The intuition is that an argument should not be attacked on its assigned element, or it should be defended from any attacks it receives on its assigned element.We also use the following constraint to filter out scopes containing assignments that are not acceptable, implementing the definition of admissible scopes (Def.7): :-scope(A, U), not acceptable(A, U).
For the co-semantics (as defined in Def.8), the encoding uses an additional constraint rule, which filters out scopes that do not contain all acceptable assignments: :-domain(A, U), acceptable(A, U), not scope(A, U).
The first rule computes the cardinality of each co-scope, while the second optimisation rule keeps the set minimal models only.Note that this cardinality-based checking is sufficient, given that grounded scopes are unique, and thus any non-grounded complete scope will have strictly more argument-element pairs than the grounded one.
For the pr-semantics (as defined in Def.10), additionally to the clauses that compute the ad-scopes, we use the following optimisation statement, in order to find the maximal with respect to set inclusion models: It should be noted that for the pr-semantics code only, one needs to use Asprin, a specialised reasoner for computing qualitative and quantitative optimisations in ASP.
Finally, for the st-semantics (as defined in Def.11), the program starts with the clauses that compute the conflict-free scopes (as described above), and then uses the following two rules to filter out those scopes for which an argument-element pair neither attacks nor is attacked by another pair in the same scope: argumentGetsScopeAttackOn(A, U):-domain(A, U), attacks(B, A), scope(B, U). :-domain(A, U), not scope(A, U), not argumentGetsScopeAttackOn(A, U).

A Team-Building Example
The ASP implementation of the different AAFD semantics can be proved more helpful when considered as part of a general system that applies logic programming in order to address specific tasks, rather than when executed as standalone programs.A characteristic case is provided next, where an AAFD encoding can offer leverage both in terms of intuitiveness in modelling declaratively the parameters of a given problem and of implementation easiness.Specifically, inspired by [39], we model a team building example, which is a generalisation of a typical graph colouring problem: given a set of students (characters p to w, in our case) and their friendship relationships, we wish to divide this set into different groups, in such a manner that no student is placed in a group with one or more of her friends.Additionally, we would like the number of such groups to be kept minimal.The conflict-free semantics of AAFDs is sufficient for producing answers for this problem, but with the incorporation of certain integrity constraints that help eliminate unnecessary results.In particular, the following ASP code listing instantiates the aforementioned problem, starting with the enumeration of students and the specification of friendship relations among them.We model the latter as attack relations; the idea is to consider each student as an argument, whose scope will be the group she will be assigned to.As such, initially the domain of each student is any available group and the scope that will be generated through the process of calculating AAFD conflict-free extensions will denote the group that each student will be assigned to.

% All groups exist in the domain of any node domain(A, E) :element(E), argument(A).
%% Constraint A % Eliminate cases, where a student belongs to no group hasNonEmptyScope(A) :argument(A), scope(A, _).
There are two remarks worth noting about this encoding.First, the generation of all conflict-free extensions produces correct answers, but also generates a number of counter-intuitive answers for the domain extensions.Constraints A and B ensure that we only keep a subset of the extensions that are relevant to the domain, i.e., those where all students belong to exactly one group.As this is a domain-specific requirement, such constraints can be added to complement the more generic AAFD semantics.
Second, initially, one does not know how many groups need to be generated, especially if minimization is required.To keep the encoding simple, we let parameter max (the number of groups to consider) to be treated as a constant provided by the user at command-line (a better solution would be to adopt an incremental solving approach provided by most reasoners, until a solution can be found automatically).This way the user can test different values.For instance, when setting max = 1 or max = 2, the reasoner cannot compute any satisfiable answer, but when max = 3, the reasoner returns 30 equally acceptable distinct solutions, some of which appear next: Answer: 1 scope(p,1) scope(t,1) scope(r,2) scope(u,2) scope(v,2) scope(q,3) scope(s,3) scope(w,3) Answer: 2 scope(p,1) scope(t,1) scope(w,1) scope(r,2) scope(u,2) scope(v,2) scope(q,3) scope(s,3) ... Answer: 30 scope(q,1) scope(s,1) scope(w,1) scope(r,2) scope(t,2) scope(v,2) scope(p,3) scope(u,3) The main point that emerges from this example is the easiness of coupling AAFD semantics with constructs offered by logic programming languages, such as integrity constraints in this case, which help approach problems in a succinct and intuitive way.Encoding the same domain using an AAF approach is also feasible, but would require listing a much larger number of relations among arguments, which would cast the solving more complex and the modeling difficult to maintain even for small problem instances.

Evaluation
In this section, we conduct an extensive experimental evaluation of our encoding.The goal of this analysis is not to argue that the given implementation is faster or more scalable in comparison to other approaches.Our intention, instead, is to investigate the performance and the breaking points of even a simple implementation of AAFDs, such as ours, while executing tasks ranging from simple to resource-intensive ones.Hopefully, this will enable the knowledge engineer who wishes to model a particular domain with AAFDs to understand what to expect with respect to the domain requirements, and where to focus on for achieving performance gains.

Data Generation and Experimental Setup
As there are no available datasets containing arguments annotated with their corresponding domains, we decided to generate synthetic data with diverse characteristics, in order to use them as input to the ASP implementation for the calculation of AAFD extensions.The parameters that vary among the input datasets include the number of arguments (#arguments) and the number of elements of the domain (#elements), the average number of elements assigned to each argument (#assignments), and the average number of attacks made by an argument (#attacks).Specifically, we generated two families (batches) of AAFD datasets: 3the first batch scales with respect to the total number of domain elements: while the #arguments ranges in {2, 3, 4, 5}, the #elements takes values from the set {10, 20, 50, 100, 200, 500}.In addition, the #assignments varies between 25%, 50%, 75%, and 100% from a median value randomly chosen from the interval ] (where N is the #arguments and X = 0.25, 0.50, 0.75, or 1, accordingly).Finally, the #attacks is a randomly chosen number from the interval Ultimately, there is a total of 96 cases, for each of which we created 10 different AAFD instances, adding up to 960 different input datasets.
the second batch scales with respect to the total number of domain arguments: while the #elements ranges in {1, 2, 3, 4}, the #arguments takes values from the set {10, 50, 100, 200, 500}.The #attacks varies between 25%, 50%, 75%, and 100% from a median value randomly chosen from the interval [ ] (where N is the #arguments and X = 0.25, 0.50, 0.75, or 1, accordingly).The #assignments is a randomly chosen number from the interval Ultimately, there is a total of 80 cases, for each of which we created again 10 different AAFD instances, adding up to 800 different input datasets.
In order to generate these datasets, we developed a randomiser based on AFBench-Gen2 [19] using Python 3.9 with the module random4 .The randomiser can create an AAFD from scratch with a random number of arguments, elements, attacks and assignments, as requested by the user.The number of attacks and the number of assignments are, however, restricted by the number of arguments and the number of elements of the domain, respectively.

Experimental Results
Given our dataset of 1760 different AAFDs, we measured the time needed for the reasoner to compute a single (find one/FO−σ) and all (find all/FA−σ) scopes for σ ∈ {ad, co, gr, pr, st}.For the FA−σ case, we also measured the number of scopes (models) produced.For the ad, co, and st semantics, we set a timeout threshold of 15sec, after which we terminated the reasoner, while for the gr and pr semantics the timeout threshold was set at 50sec; the decision for applying two different thresholds was driven by the observation that it is much easier for the less restrictive semantics to generate a vast number of models in a very short period of time, in comparison to the ones that require optimisation to be performed before producing results.All experiments were conducted on a 6-core Intel(R) Xeon(R) CPU E5-2640 v4 @ 2.40GHz system, running Ubuntu 20.04.4,Clingo v5.6.2 and Asprin v3.1.1 (Aprin runs with Clingo v5.4.0).Table 1: A sample of the results recorded for the ad and co semantics There are certain general observations that can be made by looking at the results as a whole.For start, there is a distinctive difference in reasoning complexity between the two batches: even the most difficult cases in the first batch (domains with 500 element and 5 arguments) produce a few million of models in a couple of seconds for ad and co semantics, whereas the corresponding most difficult cases for the second batch (domains with 500 arguments and 4 elements) reach the timeout threshold before producing even a single model.Table 1 presents only a small sample of the experimental results recorded in the CSV files that are available online (a "+" mark next to the num-ber of models means that the reasoner was forced to stop before exhausting the search space, therefore more models may exist).
Table 2: Average and mean execution time of the 2 nd batch, for the ad semantics To understand if it is the number of arguments or the number of attacks per argument that plays the most important role in making the second batch more computationally intensive, we can look at the average and mean execution times in Table 2: all cases, apart from the ones with 500 arguments terminate before the threshold; moreover, increasing the mean variance of attacks only slightly decreases execution times.This leads to the conclusion that we would probably prefer -at least slightly-to model domains with fewer arguments, even if there are a lot of attacks among them, rather than having big argumentation graphs.
It should be noted that the timeout threshold is also reached in many cases of the first batch too, but this is due to the vast number of models produced there; indeed, another general observation is the much larger set of models produced when having more elements (first batch) in comparison to having more arguments (second batch).Furthermore, we can also notice in Table 2 that domains with 100 arguments and only a few elements produce all scopes in less than a second.Considering also the very small execution times of the first batch, according to which the number of domain elements weigh much less in comparison to the number of arguments, one can conclude that it would be feasible to model domains with a few hundreds of arguments and elements, even following a simple encoding as ours, at least as far as the ad, co, and st semantics are concerned.Of course, increasing the elements would probably increase the number of scopes produced, at least for the less restrictive semantics, which in a realistic setting is not very practical (choosing between a few hundred thousand alternatives may seem arbitrary and would require additional domain heuristics to be applied in order to decide which scope to keep).Still, this finding means that the knowledge engineer can approach a wide range of realistic domains without investing too much effort in applying complex modeling techniques for dealing with performance issues.
Although the same pattern is also observed for the gr and pr semantics, available as the supplementary material online, the execution times deteriorate much more steeply: even with a higher threshold, there are many more cases reaching the timeout limit, scattered across all inputs variations, and not just for the extreme cases.The obvious conclusion here is that we would prefer to model domains that produce fewer results under the less restrictive semantics before applying the restrictive ones, so that the calculation of the gr and pr semantics would require a much shorter search space to explore and prune, in order to find optimal models 5 .
Another finding worth noting is that the gain in execution times observed between the FO−σ and the FA−σ cases is almost insignificant for all semantics, apart from the pr ones.This can be attributed to the way grounding is performed with the Clingo reasoner, which needs to be completed before the solving process starts.Incremental grounding and solving is also offered as an option by this reasoner, which, therefore, may be worth investigating for certain domains.The pr semantics, on the other hand, which are the only ones calculated using the Asprin reasoner, are often more efficiently computed in the FO−σ case, especially for the first batch.Asprin is specifically designed for finding optimal models under certain preferences, and although optimisation is also applied for the gr semantics with Clingo, in that case the reasoner converges to the optimal model, whereas with Asprin optimal models are returned even before solving is completed.
Finally, it may be of interest to point out the high number of unsatisfiable AAFDs, among both batches, for the st semantics (also available online).With just a few exceptions, their calculation takes less than 2sec to compute, even for the larger datasets.
In this section, we consider a specific way to define the domain assignments of an AAFD, based on a logical formalism.This avoids the need to explicitly enumerate the individual elements that are in the domain of an argument, which may be a tedious or time-consuming process.
Our proposal generalises the idea of "background theory", originally proposed in [40].We argue that this is a more natural and expressive representation of the domains of arguments, which also avoids certain modelling issues.Consider, for instance, the following argument: "all doctors are licensed to practice general medicine".Assume also that it so happens that in a specific context that we want to reason about (e.g., our local hospital), all doctors are female.If we represent the domain of this argument by spelling out the individuals, we lose the information that it is the profession of the individuals that this argument relies on, and not their gender.
The idea is based on the fact that the domain of an argument, viewed from the logical perspective, is essentially a unary predicate.As an example, if we want to say that the domain of an argument a is those hospital doctors that are not surgeons, we could express it using the following rule, which assigns a logical expression to a predicate (say δ a (x)) that represents the domain of a: r : δ a (X) ← doctor(X), not surgeon(X) Extending the idea further, we could consider a logic program Π that encodes the background knowledge (for example information about the roles of the people that work in our local hospital); the domain of a would then contain exactly those elements u of the universe (in our example, people working in our local hospital) that are entailed from r and Π.
More formally, we consider a logic programming language L, as defined in [28].The signature of a logic program Π in L consists of a set of constants, a set of variables and a set of predicates.A term is a variable or a constant.An atom is an expression of the form p(t 1 , . . ., t n ), where p is a predicate of arity n and t 1 , . . ., t n are terms.A literal is an atom a or its negation, ¬a.Knowledge is encoded in Π using rules of the form: r : l 1 ← l 2 , . . ., l m , not l m+1 , . . ., not l n where r is a label, each l i is a literal in Π, and not denotes default negation.We assume the stable model semantics of logic programs and we use the symbol ⊩ to denote entailment under this semantics.We define a logic-based AAFD as follows: -L is a logic programming language that contains (among others) one unary predicate δ a and one unary predicate ε a for each a ∈ A -Π is a logic program in L * , which is a subset of L that does not contain the δ a , ε a predicates -A is a set of arguments -R ⊆ A 2 is a set of attacks between arguments -∆ = {r ∆ i : δ a (X) ← l 1 , . . ., l m , not l m+1 , . . ., not l n | i ≥ 0, l j ∈ L * , a ∈ A} Intuitively, L is the language that allows us to express the background knowledge, which is encoded in Π.The constants of L are essentially the elements of the universe (i.e., the set U in the terminology of Section 3).The domain of each argument a is represented by a unary predicate δ a , which appears in the head of zero or more rules in ∆ and is determined by evaluating the respective rules over Π.In particular, δ a should be interpreted as follows: an element u is in the domain of an argument a if and only if The semantics of logic-based AAFDs can be defined in purely logical terms, as shown in the following definitions.We start with the notion of a scope, which, analogously with the domain (∆), is defined as a set of rules each having as its head a unary predicate (ε a (X)) specifying the scope of an argument a ∈ A.
The intuition behind ε a (u) is that u is accepted for a if and only if Π ∪ E ⊩ ε a (u).The semantics are now defined as follows: Definition 19.Consider a logic-based AAFD F = ⟨L, Π, A, R, ∆⟩, and a scope E. E is compliant if and only if for every a -Admissible, if and only if it is conflict-free and for any a ∈ A, u ∈ U , (a, u) is acceptable with respect to E whenever Π ∪ E ⊩ ε a (u) -Complete, if and only if it is admissible and for any a ∈ A, u ∈ U , Π ∪ E ⊩ ε a (u) whenever (a, u) is acceptable with respect to E -Grounded, if and only if it is complete and, for any complete scope  republican(hoover).quaker(hoover).

democrat(hickenlooper). quaker(hickenlooper).}
Consider the following scopes: All three scopes are compliant, conflict-free, admissible and complete.E is also grounded, but neither preferred nor stable.E ′ and E ′′ are preferred and stable, but not grounded.According to E, nixon is not in the scope of a ).The same results hold for hoover, while hickenlooper is in the scope of b and not in the scope for a according to any of E, E ′ and E ′′ .
The semantics of logic-based AAFDs are equivalent with the set-based semantics of AAFDs (as defined in Section 3).Specifically, for any AAFD F = ⟨L, Π, A, R, ∆⟩, we can create its corresponding F* = ⟨A, R, D U ⟩, by setting for all a ∈ A, u ∈ U .Then, for any of the semantics σ of AAFDs, it holds that E is a σ-scope of the logic-based AAFD, F, if and only if D U , defined as follows, is a σ-scope of the set-based AAFD, F*: Moreover, the ASP implementation we presented in Section 5 supports reasoning with logic-based AAFDs.The only difference is that in logic-based AAFDs the input must be in a format like the following, which implements the Nixon's diamond example: argument(a).argument(b).domain(a, X):-quaker(X).domain(b, X):-republican(X).republican(nixon).quaker(nixon).republican(hoover).quaker(hoover).democrat(hickenlooper). quaker(hickenlooper).

Conclusion
In [40], we introduced a novel argumentation framework, called Abstract Argumentation Framework with Domain Assignments (in short AAFD), where each argument has a domain of application that describes the entities that it refers to and can be applied on.Attacks in an AAFD essentially restrict an argument's domain of application.This framework can be seen as a refinement of AAFs that allows making and reasoning with arguments that do not refer to an individual entity or case, but rather to sets of entities or cases.This enables representing various features of non-monotonic reasoning, such as default knowledge and exceptions, and reasoning with them at the argument level.
In this paper, we extend the results we presented in [40] with: a method for partitioning an AAFD according to a partition of its universe, which enables computing the extensions of an AAFD by combining the extensions of its parts; an alternative logicbased characterization of the domains of arguments, which enables injecting background knowledge into an AAFD; an ASP implementation that computes the scopes of an AAFD and its evaluation; and an example application.
In the future, we plan to extend our theoretical and practical investigations of AAFDs.In terms of theory, we plan to study the relations between AAFDs and other abstract frameworks such as Value-based Argumentation Frameworks [8] and Incomplete Abstract Argumentation Frameworks [7].In particular, we want to study whether AAFDs can play the role of a unifying framework incorporating the features of other argumentation frameworks.We also plan to integrate the notion of argument domains to other argumentative frameworks, such as Abstract Dialectical Frameworks [15] and Probabilistic Argumentation Frameworks [31].Another plan is to investigate the relation of AAFDs with structured argumentation frameworks [9], specifically deductive argumentation [10], assumption-based argumentation (ABA) [13], defeasible logic programming (DeLP) [26] and rule-based argumentation (ASPIC + ) [37].By mapping structured arguments with claims that contain variables to abstract arguments with domains, an AAFD will enable reasoning with such arguments, which is not currently possible with AAFs.In more practical terms, we plan to develop more efficient implementations that will exploit features of AAFDs such as equivalence classes of elements and predicates allowing to reason with sets of elements instead of individual elements.We also plan to investigate further applications of AAFDs in domains that involve reasoning with sets of entities or cases, such as negotiation dialogues and legal reasoning.
b [u] ∈ A * it is the case that (b [u] , a [u] ) ∈ R * .Then, by claim 2, u ∈ D U (a), u ∈ D U (b) and (b, a) ∈ R. Since (a, u) is acceptable with respect to D U in F, it follows that there exists c ∈ A such that (c, b) ∈ R and u ∈ D U (c).Since u ∈ D U (c), and (2) ⇒ (1) Suppose that a [u] is acceptable with respect to Φ [nat] (D U ) in F * .We will show that (a, u) is acceptable with respect to D U in F. Indeed, suppose that for an argument b ∈ A it is the case that (b, a) ∈ R and u ∈ D U (b).Then, a [u] , b [u] ∈ A * , so (b [u] , a [u] ) ∈ R * .Since a [u] is acceptable with respect to Φ [nat] (D U ) in F * , it follows that there exists some c This implies that for c ∈ A, (c, b) ∈ R and u ∈ D U (c), which shows that (a, u) is acceptable with respect to D U in F. Claim 4. For any two compliant and canonical scopes D U 1 , D U 2 , the following statements are equivalent: Proof of claim 4. By the definition of Φ [nat] and claim 1, we observe that Φ ).The result now follows trivially from the above.
Proof of the proposition.Now we can proceed to the proof of the actual proposition, for the different possible values of σ.For σ = cf , we observe the following: D U is a cf -scope in F ⇔ (by the definition of cf -scope) there exist no a, b ∈ A such that (a, b) ∈ R and u ∈ D U (a) ∩ D U (b) ⇔ (by the definition of R * , the fact that D U is compliant and canonical, and claim 1) there exist no a [u] , b [u] ∈ A * such that (a [u] , b [u] ) ∈ R * and a This concludes the proof.

Proof of Proposition 3
For the first result, we observe that |F|= |A|+|R|+|D U |.Moreover, R ⊆ A Take any reasoning problem in AAFD.To solve it, we can transform the input AAFD (say F) into its respective AAF (say F ′ ) using Φ nat , solve the problem in the AAF realm, and translate the result back into AAFD terminology, exploiting Proposition 1.
Let us now compute the complexity of each of those steps.Finally, the problem of recasting the result into the AAF realm requires time linear with respect to the size of the result, which can be at most equal to the size of the AAF, i.e., M ′ = O(M 2 ).
Given the above, and Proposition 1, the result is proved.⊓ ⊔

Proof of Proposition 6
We first observe that, for D U = D U , we have that D U is cm and ca.S is a ca-pr-scope in F. Using analogous arguments, we can show the result for ca-gr, ca-co, ca-ad and ca-cf .For the case of st-scopes, let us pick, from each equivalence class C ∈ C, some representative u C ∈ C (this is possible, by the Axiom of Choice).For any u, we denote by û the representative of u, i.e., û = u C , where u ∈ C (and thus, u ∼ u C ).Now consider a stable scope D U .We construct a scope D U 0 , such that, for any a ∈ A, u ∈ U , u ∈ D U 0 (a) if and only if û ∈ D U (a).It is clear that D U 0 is a cm-scope: indeed, suppose that u ∈ D U 0 (a) \ D U (a).Then, by the definition of D U 0 , the ∼ relationship and the fact that u ∼ û, it follows that û ∈ D U (a) \ D U (a), i.e., D U is not a cm-scope, a contradiction.Moreover, D U 0 is a ca-scope: indeed, for u 1 ∼ u 2 it follows that û1 = û2 so, for any a ∈ A, u 1 ∈ D U 0 (a) if and only if u 2 ∈ D U 0 (a).Further, D U 0 is a cf -scope: indeed, it is compliant, so suppose that there exist some a, b ∈ A, u ∈ U such that By definition, a cm-scope satisfies DC.Also, if D U is a cf , ad, co, pr, gr, or st scope, then it is also cm, so it satisfies DC.
For SM, suppose that D U is a co-scope, and take some a ∈ A, u ∈ D U (a) \ D U (a). Suppose, for the sake of contradiction, that there is no b ∈ A such that (b, a) ∈ R and u ∈ D U (b).Then, by Definition 6, (a, u) would be acceptable with respect to D U , thus, since D U is a co-scope, u ∈ D U (a), a contradiction.Thus, D U satisfies SM.Moreover, if D U is a gr, pr or st-scope, then it is also a co-scope, so it satisfies SM.
For SC, it follows by definition that a cf -scope satisfies SC.Also, if D U is an ad, co, pr, gr, or st scope, then it is also cf , so it satisfies SC.
For ET, the result follows from Definitions 3, 12, and the formulation of the ET constraint.⊓ ⊔

Proof of Proposition 8
Set D U = ⊔ i D Vi .Before proceeding with the main proof, we show a number of simple claims that will be useful in the following: (⇐) Take some u ∈ V i and u ∈ D U (α).By the definition of D U , there exists some j such that u ∈ D Vj (α).Since D Vj (α) ⊆ V j for all j (by the definition of F Vj ), and since V i ∩ V j = ∅ for all j ̸ = i, it follows that j = i, i.e., u ∈ D Vi (α).Claim 2. If u ∈ D U (α), for some α ∈ A, then there exists i such that u ∈ D Vi (α) ∩ V i .Proof of claim 2. Since u ∈ D U (α) ⊆ U , and {F Vi } is a partition of F, it follows that there exists some i such that u ∈ V i .Moreover, by Definition 16 and the fact that D U = ⊔ i D Vi , it follows that there exists some j such that u ∈ D Vj (α), thus u ∈ V j .
If i ̸ = j, then V i ∩ V j = ∅, a contradiction by the fact that u ∈ V i ∩ V j , so we conclude that i = j.This completes the proof of the claim.Claim 3. If u ∈ D U (α), for some α ∈ A, then there exists i such that u ∈ D Vi (α) ∩ V i .
Proof of claim 3. Analogous to claim 2. Claim 4. Take any α ∈ A, u ∈ D Vi (α) for some i.Then (α, u) is acceptable with respect to D Vi in F Vi if and only if (α, u) is acceptable with respect to D U in F. Proof of claim 4. We first observe that, since u ∈ D Vi (α), it follows that u ∈ V i , u ∈ D U (α) and u ∈ U , so the expressions "(α, u) is acceptable with respect to D Vi in F Vi " and "(α, u) is acceptable with respect to D U in F" are defined.We also note that R Vi = R. Now we can go ahead and show the claim: (⇒) Take some (β, α) ∈ R, u ∈ D U (β).Then, (β, α) ∈ R Vi .Moreover, since u ∈ V i , it follows that u ∈ D U (β) ∩ V i = D Vi (β).Thus, by the hypothesis that (α, u) is acceptable with respect to D Vi in F Vi , it follows that there exists some c ∈ A Vi = A such that (c, β) ∈ A Vi = A and u ∈ D Vi (c).By Claim 1, the latter implies that u ∈ D U (c), which completes this part of the proof.
(⇐) Take some (β, α) ∈ R Vi , u ∈ D Vi (β).Then u ∈ V i .Moreover, (β, α) ∈ R and u ∈ D U (β) (by Definition 14).Thus, by the hypothesis that (α, u) is acceptable with respect to D U in F, it follows that there exists some c ∈ A = A Vi such that (c, β) ∈ A = A Vi and u ∈ D U (c).By Claim 1, and the fact that u ∈ V i , the latter implies that u ∈ D Vi (c), which concludes the proof of the claim.

1
(a) = {x, y}, D U 1 (b) = {y, z} (in the context of the Nixon's diamond problem, this would mean that Nixon and Hoover are anti-pacifists, and Hoover and Hickenlooper are pacifists) is compliant.a ⟨x, y⟩ b ⟨x, y, z⟩
, the scope D U 4 (a) = {x, y}, D U 4 (b) = {z} is complete.Complete scopes satisfy the SM requirement (see Proposition 7).Definition 9 (Grounded).The scope D U is grounded if and only if it is a minimal (with respect to ⊑) complete scope.Definition 10 (Preferred).The scope D U is preferred if and only if it is a maximal (with respect to ⊑) admissible scope.Definition 11 (Stable).The scope D U is a stable scope if and only if it is conflict-free, and for any a ∈ A, u ∈ U , if u ∈ D U (a) \ D U (a), then there exists b ∈ A such that (b, a) ∈ R and u ∈ D U (b).
in F * .The case σ = ad follows from the case σ = cf , the definition of Φ [nat] , claim 3 and Definition 7. The case σ = co follows from the case σ = ad, the definition of Φ [nat] , claim 3 and Definition 8.The case σ = gr follows from the case σ = co, the definition of Φ [nat] , claim 4 and Definition 9.The case σ = pr follows from the case σ = ad, the definition of Φ [nat] , claim 4 and Definition 10.For σ = st, we observe the following: D U is a st-scope in F ⇔ (by the definition of st-scope) for any a ∈ A, u ∈ D U (a) \ D U (a), there exists b ∈ A such that (b, a) ∈ R and u ∈ D U (b) ⇔ (by claim 1, the definition of Φ [nat] , and the fact that D U is compliant and canonical) for any a To start, let us consider an AAFD F = ⟨A, R, D U ⟩. Its size is |F|= |A|+|R|+|D U |. Set M = |F|.We set F ′ = Φ nat (F) and M ′ = |F ′ |.By Proposition 4 it follows that M ′ = O(M 2 ).The transformation process, done using Φ nat , requires O(M 2 ) time.To see this note the following: for each (a, u) such that u ∈ D U (a), we create one argument; for each (a, b, u) such that (a, b) ∈ R and u ∈ D U (a) ∩ D U (b) we create one attack.The first problem is linear with respect to |D U |, and thus linear with respect to M (i.e., O(M )).For the second, we need to check, for each (a, b) ∈ R, whether u ∈ D U (a) and u ∈ D U (b).Given that |R|≤ M and |D U |≤ M , this requires quadratic time at worst (i.e., O(M 2 )).
For the other cases, let us consider the AAFD F = ⟨A, R, D U ⟩ over some universe U .Let us denote by C the set of all the equivalence classes regarding ∼.Set F * = Φ [nat] (F), and suppose that F * = ⟨A * , R * ⟩.Now take any set S ⊆ A * , and define the scope D U S such that u ∈ D U S (a) if and only if a C ∈ S and u ∈ C. It is easy to see that D U S is canonical and compliant, and that Φ [nat] (D U S ) = S. Now, since F * is an AAF, it has at least one pr-scope, say S, thus, by the above results and Proposition 2, D U (a, b) ∈ R and u ∈ D U 0 (a) ∩ D U 0 (b).Then, û ∈ D U (a) ∩ D U (b), i.e., D U is not cf , a contradiction.Finally, we show that D U 0 is a st-scope: it is cf , so consider some a ∈ A, u ∈ U such that u ∈ D U (a) \ D U 0 (a).Then, by construction, û ∈ D U (a) \ D U (a), so, since D U is st, there exists some b ∈ A such that (b, a) ∈ R and û ∈ D U (b), thus u ∈ D U 0 (b), i.e., D U 0 is a st-scope.We conclude that D U 0 is a ca-st-scope, which completes the proof.⊓⊔Proof of Proposition 7

Claim 1 .
For all α ∈ A, D Vi (α) = D U (α) ∩ V i .Proof of claim 1. (⇒) If u ∈ D Vi (α), then u ∈ V iby the definition of D Vi , and also u ∈ D U (α) by the definition of D U .
and only if it is admissible and, for any admissible scope E 2, whereas the function D U can be modelled as a list of argument-element pairs, each pair appearing at most once in the list, so for its size the following holds:|D U |≤ |A|•|U |.Combining the above observations, we get: |F|≤ |A|+|A| 2 +|A|•|U |.The second result is direct from the first.For the third result, we observe that equivalence classes must be disjoint from each other, and their union should be the entire universe U .Thus,|C|≤ |U |.Moreover, suppose that |A|= k and A = {a 1 , ..., a k }.Set S i = D U (a i ) for i = 1, ..., k.Now take two elements u 1 , u 2 ∈ U such that u 1 ∼ u 2 .It is clear, by Definition 3, that, for all i = 1, ..., k, u 1 ∈ S i if and only if u 2 ∈ S i .Therefore, each equivalence class is completely characterised by the particular combination of membership relations of its members to each of S i .This implies that there are at most 2 k equivalence classes.Combining the above, the result follows.Let us suppose thatF 1 = ⟨A 1 , R 1 ⟩, F 2 = ⟨A 2 , R 2 ⟩.For result #1, note that, by the definition of Φ nat , |A 1 |≤ |A|•|U |.Obviously, |F 1 |≤ |A 1 |+|A 1 | 2 .Combining the above observations, we get the result.Result #2 follows directly from result #1 and the fact that |F|≥ |D U |= |A|•|U |.For results #3, #4, we observe, by the definition of Φ [nat] , that |A 2 |≤ |A|•|C|, where C is the set of equivalence classes of F, under the equivalence relation ∼.By Proposition 3, |C|≤ min{2 |A| , |U |}.Moreover, |F 2 |= |A 2 |+|R 2 |≤ |A 2 |+|A 2 | 2 ≤ |A|•|C|+|A| 2 •|C| 2 .Applying the bound of Proposition 3 on the size of C, we can easily show results #3, #4.Result #5 follows directly from results #3, #4 and the fact that |F|≥ |D U |= |A|•|U |.Result #6 is trivial once we observe that, by construction, |A 1 |≤ |A 2 | and |R 1 |≤ |R 2 |. ⊓ ⊔