Structural constraints for dynamic operators in abstract argumentation

1.Introduction

In the last decades there has been a steady stream of advances in formal approaches to argumentation within artificial intelligence (AI) [4,19]. Central to many formal models in argumentation are argumentation frameworks (AFs) due to the work by Dung in 1995 [53]. AFs can be seen as a reasoning formalism that is both foundational and simple: AFs consist of abstract arguments and directed attacks (conflicts) between these arguments. The simplicity of AFs is an appealing quality, which is witnessed by the fact that several approaches use AFs as their core reasoning engine [22,23,28,45,54,85,86]. Reasoning in this way is done via instantiating AFs in a principled way such that the arguments capture what can be argued for, and the attacks cover ways in which the arguments are conflicting. Semantics of AFs provide different means of conflict handling, in order to find acceptable arguments. Importantly, semantics of AFs only rely on the abstract view of AFs, i.e., abstract arguments and their conflict relations suffice to find acceptable arguments from an argumentative point of view for many applications. By inspecting the content of acceptable arguments one can trace back concrete claims that are acceptable.

AFs are also prominent as a formal basis for an emergent topic in formal argumentation, namely that of dynamics of argumentation [10,34,44,48,52], which can partially also be attributed to the easy-to-grasp conceptual nature of AFs. The investigation of dynamics of argumentation arose naturally in the research community since argumentation is an inherently dynamic process of, e.g., posing arguments and counterarguments towards goals in a debate.

In their initial usage, AFs were applied on “static” forms of reasoning, i.e., reasoning in contexts that give rise to AFs that do not change. While the principles of dynamic scenarios are compatible with AFs, in that AFs can be dynamically adapted, care needs to be taken when utilizing AFs in a dynamic context. For instance, dynamic operations, if solely done on AFs, may miss certain dependencies between arguments that are apparent when considering the internal structure of the arguments, but which have been “abstracted away” during instantiation.

While certain generalizations of AFs [31,39], particularly those that incorporate support relations, e.g., based on necessary supports [92], make it possible to explicate the apparently implicit support relation between a1 and a2, ultimately the same underlying problem remains: modifications on abstract frameworks may miss interdependencies between arguments.

In this paper we argue that despite these drawbacks of AFs when utilizing them in dynamic operations, abstract argumentation formalisms, as introduced by Dung [53] and to which this special issue is dedicated, are still a very useful notion for studying dynamics of argumentation. We argue that existing dynamic operators, and new ones, can be augmented to incorporate key structural constraints. Our goal in this paper is to provide means with which dynamic operations on abstract arguments can be extended so that (i) certain structural constraints are taken into account and (ii) operators can still work on a convenient and (partial) abstract level.

Towards our goal, we view dynamic operations on abstract arguments (and their relations) as operators working in three layers: a semantic layer, a structural layer, and a syntax layer. In the first layer, a semantical change is specified by an operator. As a concrete example, consider extension enforcement as defined in [10]: given an AF and a set of arguments, the output is a modified AF whose semantics contains the given set of arguments as an extension. This operator finds interpretations as strategic moves in an argumentation [58]. Enforcement defines certain conditions on the semantics of the output (or, equivalently, constraints on the semantics of an output AF). On the structural side, extension enforcement specifies that the output AF shall be close to the input AF (via a defined notion of distance between input and output AF structures). Finally, syntactically, the operator requires that the output is, again, an AF.

Fig. 1.

(a) Three layers for dynamic operators and (b) outcomes that satisfy constraints of each layer.

More broadly, we find that the semantical layer of a dynamic operator defines semantical constraints on the output, the structural layer specifies constraints on the structure of the output, and the syntax layer specifies the concrete syntax an output shall have. We illustrate this “workflow” in Fig. 1(a). Analogously, one can view each layer of an operator as (a set of) constraints, each constraining the possible candidate solutions, see Fig. 1(b). In the case of enforcement, the first layer constrains the set of candidate AFs to be those that satisfy the semantical constraint, then the second layer constrains to choose, among those satisfying the first layer, those structures that are close to the input.

With this article, we contribute to the second layer, the structural layer, by giving properties that can be required by an output structurally, with the aim of giving developers of dynamic operators a further handle to extend operators to cover more application scenarios. As the formal foundation, we use abstract dialectical frameworks (ADFs) [30,55] as the formal model that undergoes a change in this paper. Although ADFs are more complex than AFs, in the sense that the acceptance conditions of arguments can be specified in a liberal manner, they are still an abstract formalism with abstract arguments, and, importantly, have been shown to capture several abstract formalisms in argumentation in AI [95], and, thus, extend the reach of our contributions also to other formalisms than AFs.

To further our aim of supporting development of dynamic operators, we utilize the proposed constraints in two case studies. In the first case study we show how enforcement on AFs can be adapted to ADFs such that relations between arguments may only be modified in a way that corresponds to support between arguments, in contrast to attacks on AFs. In this way, we both aim to present a showcase of the constraints and show how to generalize existing dynamic operators on AFs to the more general setting of ADFs. Indeed, many dynamic approaches are currently restricted to AFs only. By using ADFs, and applying suitable structural constraints, one can lift current operators on AFs to ADFs, while keeping the intuitions of the operators.

In a second case study, we stay on the level of AFs, but adapt the existing enforcement operator to respect information of the instantiation. Concretely, for a general view on structured argumentation formalisms, we show how the constraints can be applied so that modifications to an AF do not miss interdependencies between arguments on their internal structure.

Since dynamic operators are, even without further constraints, often computationally hard [44,102], we study the complexity of the constraints we consider in this paper, and also the operators arising from the two case studies, in order to show which constraints can be feasibly “added” to operators. In order to have a clearer picture, we present an implementation in answer set programming (ASP) [29,71,88] and an empirical evaluation of the support enforcement on ADFs from the first case study. Our findings are that even when working in a more general abstract framework, and with complex constraints, state-of-the-art search engines (such as ASP) are capable of feasibly solving many instances up to certain sizes.

We summarize the main contributions of this article in the following.

The article begins with recalling background in Section 2 (AFs and ADFs) and Section 3 (enforcement). We present and exemplify structural constraints in Section 4, and proceed to the case studies in Section 5 and Section 6. Our analysis of complexity of constraints and case studies is presented in Section 7, and our prototype implementation and experiments in Section 8. We close with a discussion on further existing operators for which our constraints can be applied (Section 9) and on related work (Section 10). This article significantly extends the conference version [101] by expanded discussion and illustration, more formal details on the first case study, inclusion of the second case study, giving full proofs, and updated experiments.

2.Abstract argumentation frameworks

In this section we recall the basics of two well-known abstract argumentation frameworks, namely Dung’s argumentation frameworks (AFs) [53] and abstract dialectical frameworks (ADFs) [30]. There exists a whole range of abstract formalisms for argumentation, such as bipolar frameworks (BAFs) [3,36], extended argumentation frameworks (EAFs) [83], argumentation frameworks with recursive attacks (AFRAs) [6] and their subsequent extensions [35,40,65], value-based frameworks (VAFs) [18], and preference-based frameworks (PAFs) [2], to name some of the prominent formalisms, which are also surveyed in recent articles [31,39]. Our choice of AFs and ADFs is justified by AFs being the common core to all these other approaches, and that ADFs generalize (translate to) many other approaches [95].

2.1.Argumentation frameworks

We start the formal preliminaries with Dung’s argumentation frameworks (AFs) [53] and semantics for these frameworks [5]. An AF consists of a set of abstract arguments and directed attacks between these arguments.

Definition 1.

An argumentation framework (AF) is a pair F=(A,R), where A is a finite set of arguments and R⊆A×A is the attack relation. The pair (a,b)∈R means that a attacks b.

Example 2.

AFs have a natural representation as directed graphs. Consider an AF F=({a,b,c,d},R) with four arguments and the following attacks: R={(a,b),(b,a),(a,c),(b,c),(c,d)}. This AF is illustrated in Fig. 2(a).

Fig. 2.

Illustrations of the AF and the corresponding ADF from Example 3 and Example 4.

A central notion towards the semantics of AFs is that of defense of arguments.

Definition 2.

Let F=(A,R) be an AF. An argument a∈A is defended (in F) by a set S⊆A if for each b∈A such that (b,a)∈R there exists a c∈S such that (c,b)∈R.

Semantics for argumentation frameworks are defined through a function σ which assigns to each AF F=(A,R) a set σ(F)⊆2A of extensions. We consider for σ the functions cf, adm, com, grd, and prf, which stand for conflict-free, admissible, complete, grounded, and preferred, respectively. Towards the definition we make use of the characteristic function of AFs, defined for an AF F=(A,R) by FF(S)={x∈A∣x is defended by S}.

Table 1

Extensions of semantics σ from Example 2

σ	σ(F)
cf	{∅,{a},{b},{c},{d},{a,d},{b,d}}
adm	{∅,{a},{b},{a,d},{b,d}}
com	{∅,{a,d},{b,d}}
grd	{∅}
prf	{{a,d},{b,d}}

Definition 3.

Let F=(A,R) be an AF. An S⊆A is conflict-free (in F) if there are no a,b∈S such that (a,b)∈R. We denote the set of conflict-free sets by cf(F). For an S∈cf(F) it holds that

• S∈adm(F) iff S⊆FF(S);

• S∈com(F) iff S=FF(S);

• S∈grd(F) iff S is the least fixed-point of FF; and

• S∈prf(F) iff S∈adm(F) and there is no T∈adm(F) with S⊂T.

It is well-known that for any AF F it holds that cf(F)⊇adm(F)⊇com(F)⊇prf(F). We use the term σ-extension to refer to an extension under a semantics σ∈{cf,adm,com,grd,prf}. We note that conflict-free sets and admissible sets are usually not referred to as a semantics, since, commonly, these two notions are seen as auxiliary concepts. Nevertheless, for the sake of uniformity, we will refer to the set of conflict-free sets and the set of admissible sets as conflict-free and admissible semantics. However, we do emphasize that by referring to conflict-free sets or admissible sets by conflict-free semantics or admissible semantics does not imply a prescriptive endeavor of placing these two concepts into the set of “full” argumentative semantics. Similarly, we sometimes call conflict-free sets or admissible sets conflict-free or admissible extensions, likewise with no intention of viewing them as being on the same level as extensions of other semantics.

Example 3.

Consider the AF F in Example 2. For the considered semantics σ we show the corresponding extensions in Table 1.

3.Enforcement on argumentation frameworks

Enforcement on AFs deals with the task of how to modify a given AF such that the modified AF satisfies certain semantical constraints. Usually also the number of modifications has to be minimum. Enforcement has been studied from several angles: possibility and impossibility results [9,10], representational aspects and use cases in a logical setting [25,51,58], computational aspects [44,90,102], and axiomatic studies [11,51,58,73].

Several variants of enforcement have been defined. For the purposes of this paper, we look at the enforcement variant called non-strict enforcement under strong expansions with a bounded number of expanded arguments [44]. This choice is mostly due to illustrative reasons; other variants fit the aims of the paper, as well. We base our results on this variant, since it is intuitively appealing: expansions relate to addition of arguments, with the strong variant indicating attacks originating only from new arguments. Compared to other operations studied, “strict” variants would place more restrictions on the semantic goal, and other types of expansions [8] have different restrictions which attacks may be added.

For an AF F=(A,R), an expansion of F is any F′=(A′,R′) with A⊆A′ and R⊆R′ (new arguments and new attacks may be added arbitrarily). Given an AF F=(A,R), a strong expansion of F that adds new arguments A′, with A∩A′=∅, is a modified AF F′=(A∪A′,R′) with R⊆R′ (all original attacks are in R′) and if an attack (a,b)∈R′∖R was added, then a∈A′ and b∈A (new attacks originate from new arguments onto original arguments only).

Based on strong expansions, we define enforcement as follows.

That is, one needs to find a modified AF F′ that strongly expands F by new arguments A′ and S must be part of a σ-extension of F′. Among all candidates, typically, one further restricts solution AFs to be optimal w.r.t. the modifications to the attacks. This is specified by finding an optimal AF F∗=(A∪A′,R∗) that non-strictly enforces S under σ and there is no F′=(A∪A′,R′) that non-strictly enforces S under σ and |(RΔR′)|<|(RΔR∗)|, with Δ the usual symmetric difference: XΔY=(X∖Y)∪(Y∖X).

Fig. 3.

Enforcing {a,d} being part of the grounded extension, by adding argument e and attack (e,b) (Example 6).

4.Structural constraints for dynamic operators

This section introduces several constraints to be used to extend current dynamic operators, and support development of new operators. From a principled point of view, we consider dynamic operators that take an ADF D as input and produce a modified ADF D∗ as output. For the sake of readability, we will, unless stated otherwise, refer to a modified ADF by D∗=(A∗,L∗,C∗). A dynamic operator then defines certain constrains on the output, namely on (i) the semantics, (ii) the structure, and (iii) the concrete syntax. We first exemplify constraints on the enforcement operator from Section 3 when lifted from AFs to ADFs.

That is, we want to enforce that I is “part” of a σ-interpretation by modifying D in the following way: there has to be a σ-interpretation I′ such that if an argument a is assigned true (false) by I, then I′ assigns true (false) to a, as well. Further, analogously as for AFs, one can look at optimality constraints: we say that an ADF D∗=(A∗,L∗,C∗) is an optimal solution to non-strict enforcement if D∗ non-strictly enforces I under σ, and there is no D′=(A′,L′,C′) with |(LΔL′)|<|(LΔL∗)| that non-strictly enforces I under σ. Intuitively, there has to be a σ-interpretation I′ in the modified D∗ such that the requirements of I are met (some arguments have to be true, some false, undecided arguments are not constrained). Compared to Definition 8 the only major change is to respect the three-valued semantics of ADFs.

Within the three-layered view, this adapted enforcement operator works as follows:

Example 7.

Consider again the ADF D from Example 4. Say we want to enforce that both a and d are true in the grounded interpretation. Further, say we may add only argument e. This means, we desire to enforce interpretation I={a↦t,b↦u,c↦u,d↦t,e↦u} (a and d must be true, all other arguments are unconstrained). Unmodified, both arguments are undecided in the grounded interpretation of D, since the grounded interpretation assigns all arguments to undecided. The enforcement can be achieved by adding an argument e (similarly as in Example 6 for enforcement on AFs) that “attacks” argument b, by adapting the acceptance condition of b to φb′=¬a∧¬e (from originally φb=¬a). This enforcement is shown in Fig. 4.

Fig. 4.

Enforcing {a,d} being true in the grounded interpretation: adding argument e, with φe=⊤ and adapting φb to φb′=¬a∧¬e (Example 7).

We now proceed to introducing several structural constraints that are intended to refine candidate ADFs for a dynamic operator on ADFs. The enforcement operator defined above is one example for such an operator, but in the following we do not assume a concrete operator (however, we connect several constraints to the enforcement operator). Formally, a constraint c is specified in such a way that one can decide whether an ADF satisfies the constraint. The intention is then to choose, among all ADFs satisfying the given semantical constraints, e.g., from the ADF enforcement operator defined above, one ADF satisfying a given structural constraint c. Many of the subsequent constraints are intended to be used in a mix of several constraints. That is why we begin with defining how to state combinations of constraints.

Boolean combinations of constraints. In the following, when K={c1,…,cn} is a set of (structural) constraints, we consider also the constraint that is a Boolean combination of these constraints. That is, a Boolean formula Φ that has as its variables constraints in K. Satisfaction, for an ADF D, of Φ is then defined in a standard way: if D satisfies a ci∈K, then Φ=ci is satisfied by D; if Φ=¬ci, then D satisfies Φ if it does not satisfy ci; the connectives of conjunction and disjunction are defined in the standard way, as well.

General constraints. For concrete atomic constraints, we start with basic constraints, namely ones that specify limits of arguments and links. That is, for a given ADF D∗=(A∗,L∗,C∗) (a potential output ADF), argument sets A and A′, and sets of links L and L′, we define the following constraints, with L|A∗=L∩(A∗×A∗).

Argument constraints. The next basic constraint gives a concrete handle which arguments are present in the output. For an ADF D∗=(A∗,L∗,C∗) and argument a we define:

That ADFs with only attacking links and SETAFs have a connection has been established by a translation of SETAFs to ADFs [95]. That ADFs with only attacking links have a corresponding form as SETAFs, in case no acceptance condition is unsatisfiable, can be shown by considering that each acceptance condition in an attack-only ADF can be represented via a Boolean formula in conjunctive normal form with only negative literals. A similar result has been shown for BADFs in [61, Theorem 3.1.23]; we specialize this result to attack-only ADFs and state a direct proof for the sake of completeness.

From this result it can be inferred, via [78, Proposition 1], that if each acceptance condition is either equal to ⊤ or in CNF with negative literals, the ADF in question can be written as a SETAF. However, unsatisfiable conditions (φa=⊥) have no direct analogue. The underlying intuition is that if a set of arguments X attacks, in a SETAF, an argument a, then this can be written as ⋁b∈X¬b (one of the attackers must be “out” or false for the set-attack to be countered). If more sets attacking a exist, then this can be represented as a Boolean formula in CNF: ⋀(X,a)⋁b∈X¬b. An unsatisfiable formula φ≡⊥ cannot be directly represented in this way.

Constraining the underlying graph structure of an ADF, i.e., (A∗,L∗), can be useful, as well, e.g., with constraint (L4). Example graph classes are directed acyclic graphs or bipartite graphs. For instance, directed acyclic graphs have appealing properties: one can view “leaf” arguments (i.e., arguments x whose dependencies parD(x) are empty) as, e.g., undisputed or evidential facts, or assumptions. In some formal approaches to (abstract) argumentation, arguments without dependencies are necessary, for instance for evidential argumentation systems (EASes) [93]. Computationally, acyclicity exhibits milder complexity than general graph structures, for several reasoning tasks, both for AFs [53,59,60] and for ADFs [77]. Bipartite graphs also enjoy interesting properties [56], and can be seen as arguments from two parties corresponding to the bipartite partition.

Constraints on acceptance conditions. We proceed to constraints on acceptance conditions. Given an ADF D∗=(A∗,L∗,C∗), a φs∈C∗, v∈{t,f}, a three-valued interpretation I, a two-valued interpretation I′, and a formula ψ, we define the following constraints. Recall that by φ[I] we denote the formula obtained by replacing arguments assigned to true by ⊤ and to false by ⊥, and by I′(φ) we denote the evaluation of the Boolean formula φ by a two-valued interpretation I′.

Constraints on characteristic functions. Next we introduce a different type of constraint on the characteristic functions of ADFs ΓD∗. Let v,v′∈{t,f,u}, and s and s′ be arguments.

Weights and optimization. For optimization constraints, define the cost of an ADF D via cost(D). For this paper, we let the cost function be abstract.

5.Case study: An enforcement operator for ADFs based on supports

In this section we use some of the proposed constraints to adapt the enforcement operator on ADFs to allow for only supporting links to be added. For the sake of readability, we will continually develop this operator.

We adapt non-strict enforcement under strong expansions of ADFs, as defined in Definition 9. We briefly recall this operator. Given an ADF D=(A,L,C), a semantics σ, an interpretation I, and arguments to expand A′, it holds that D∗=(A∗,L∗,C∗) is a solution if two conditions hold. First (A∗,L∗) is to be a strong expansion of (A,L) (first two items of Definition 9). The second condition is that ∃I′∈σ(D∗) s.t. I⩽iI′. For illustrative purposes, we initially drop the condition of optimality on modified links.

Consider, first, a variant of this operator that respects the following constraint:

Example 14.

Consider ADF D=({a,b,c},L,C) with φa=b, φb=c, and φc=⊥. Assume that we expand with an argument d and that we want to enforce a to be true in an admissible interpretation. This can be achieved simply by modifying φa to φa′=b∨¬b (see Fig. 5(a)). Note that this modified ADF is an expansion, and new links are supporting (there are no new links).

Another potentially unintended example is when we desire to have an argument a false in an admissible interpretation of an expanded ADF. Say we have only one argument a, and may add argument b. The following modification can be applied: φa∗=φa∧b and φb∗≡⊥. That is, one can specify that argument a is accepted only if b is true, and stating that b is never acceptable. Intuitively, one “supports” an argument by requiring a new argument, and declaring that the new argument is not acceptable.

Fig. 5.

Enforcing a being true in an admissible interpretation via support enforcement: without further constraints (a), without modifying acceptance conditions when expanded arguments are rejected (b), and additionally when optimizing added links (Example 14).

Let us utilize the structural constraints to specify permissible changes in a more rigorous way. Consider that acceptance conditions shall be unchanged if new arguments are rejected (similarly as in Example 11 and constraint type (C4)):

In light of the preceding example, in addition we now specify that the cost of a solution D∗ is |LΔL∗| (similarly as for enforcement on AFs). A solution D∗ is optimal if there is no other solution with strictly less cost.

Finally, we specify that expanded arguments are always acceptable: for each a′∈A′ we have φa′∗≡⊤. Summarizing, we use the following constraints (with constraint type on the right):

Additionally, this operator uses constraints of type (A1) and (L1) in order to specify expansions, and (O2) for the optimization. We call the corresponding operator that is defined via Definition 9 and respects these three constraints support enforcement.

As the reader might have guessed, when looking at Example 16, support enforcement is possible if no argument is enforced to be false.

The preceding proposition implies straightforward solutions to the support enforcement for arguments to be enforced to be true. The same simple modification is not applicable for arguments to be enforced to be false: a direct support of a new argument onto such an argument can only lead to more cases of acceptance. In such a case, an indirect support of, e.g., an attacker can lead to a successful enforcement. In any case, while we abstain in the above definition from introducing further constraints to support enforcement, several further constraints can be feasibly added, such as constraints which links are allowed to be added, and how acceptance conditions may change. In Section 7, we investigate which further constraints can be added to support enforcement (or other operations) without increased computational complexity.

Further, if enforcement is possible (independently of whether arguments are to be true/false), for a concrete instance, then it is possible with a singleton argument to expand, whenever the interpretation that represents the enforcement goal assigns undecided to the expanded arguments (if two ore more expanded arguments must be true, then one cannot restrict to one expanded argument). Formally, if one can enforce the desired status among the original arguments, then one can do so, for the original arguments, with a single new argument.

6.Case study: An enforcement operator for structured argumentation

In this section we will use our structural constraints to adapt the non-strict enforcement operator on AFs (Definition 8) to respect knowledge bases from structured argumentation the AF was instantiated from. On a high-level, the enforcement operator we define receives as input an AF instantiated by a part of a given knowledge base, and aims to find an expansion of that AF enforcing certain arguments, with expansions respecting the knowledge base. Formal approaches to structured argumentation are quite heterogeneous [7], which is why we abstract from these approaches, in order to capture the intuitions of several formalisms.

Structured argumentation approaches [21,22,28,68,72,85] provide formal recipes for instantiating arguments and their relationships from a given knowledge base. In several cases the formalism that is instantiated is an AF [28,85]. We assume that a knowledge base is given as a set B of elements. This set may contain facts, rules, or further ingredients required to instantiate arguments. In this paper we do not specify these elements. For our purposes we assume only a few functions that a structured argumentation approach is composed of: (i) a function args that returns all (abstract) arguments that can be generated from a knowledge base, (ii) a given function kb that returns for a set of arguments their contents, i.e., returns the subset B′⊆B that is needed to instantiate the arguments, and (iii) a function att that returns all attacks that can be instantiated. Formally, we also assume that the functions behave well, i.e., we have kb(args(B))⊆B for any knowledge base B (every knowledge base element, when inspecting instantiated arguments from knowledge base B, is in B) and we assume that it holds that A⊆args(kb(A) (when looking at the base of a set of arguments, then all these arguments can be constructed from that base). For att, we assume that (a,b)∈att(B) implies {a,b}⊆args(B). Further, we assume that for B′⊆B we get f(B′)⊆f(B) for f∈{args,att}, and for argument sets A′⊆A we have kb(A′)⊆kb(A). This means that all functions args, att, and kb are ⊆-monotone. While subset monotonicity for the functions args and kb appear rational, there are cases when att is, in fact, not subset-monotone: in presence of preferences, that are to be included in a knowledge base, addition of preferences might affect presence of attacks non-monotonically. We discuss impact of this at the end of this section, but leave the main part of this section to deal with the case of ⊆-monotone att functions.

Example 18.

We exemplify the functions args, kb, and att by a simple knowledge base, and associated AF that is constructed in the case of assumption-based argumentation frameworks (ABA) [28]. Similar functions can be defined, e.g., for the ASPIC+ framework [85]. We will not explicate the definitions of ABA, but stay on an intuitive level, and also, for illustration purposes, simplify some notions.

Two main ingredients for ABA are assumptions and rules. Say we have four assumptions {a,b,c,d}, and rules as shown in Fig. 6: from a one can derive x, from b one can derive the negation (contrary) of a, from c one can derive the negation of b, from a and c together one can derive y, and finally from d one can derive z. These derivations directly correspond to the arguments a1 to a5. By the contraries the arguments derive, one can infer that a2 attacks a1 and that a3 attacks a2. That is, for B={a,b,c,d} we get args(B)={a1,a2,a3,a4,a5}, att(B)={(a2,a1),(a3,a2)}, and e.g., kb({a1,a4})={a,c}.22 In Fig. 7 we show for each B′⊇{a,b} the corresponding abstract argumentation framework. For instance, for B′={a,b,c} we have F3.

Fig. 6.

A simple structured (assumption-based) argumentation framework (Example 18). For the ABA framework consisting of four assumptions a, b, c, and d, and rules as shown in (b), several arguments can be constructed, with five arguments shown in (a). Attacks arise when an argument concludes a negated assumption of another argument (e.g., argument a2 attacks argument a1 on assumption a).

In the following we assume that we are given both a knowledge base B, and an AF F=(args(B),att(B)) instantiated from this base. Further, we assume a subframework F′=(A′,R′) as the current state of argumentation such that B′⊆B and A′=args(B′) and R′=att(B′). One interpretation of this context is that the arguments in F′ have been uttered, while the remaining part of the knowledge base B∖B′ has not been uttered (or, is “private” to an agent). For instance, in Fig. 7, F4 corresponds to the full AF, for the knowledge base from Example 18, and F1 could be a current AF.

The enforcement operator we now define aims to provide means to find a knowledge base B∗, with args(B′)⊆args(B∗)⊆args(B), such that a desired argument (or set of arguments) is acceptable, under a certain semantics σ. Towards the operator, we again adapt the existing enforcement operator in AFs (recall Definition 8), and modify this operator, as follows (the full definition is given in Definition 10). First, for the expansion we do not require strongness nor addition of all arguments that may added. Further, we apply the following constraints (the arguments that may be added are args(B)∖args(B′)).

Fig. 7.

AFs associated to parts of the knowledge base that contain a and b (Examples 18 and 19). For each AF Fx (x∈{1,…,4}) the corresponding knowledge base Bx is shown above. It holds that kb(Ax)=Bx with Ax the argument set of Fx.

Next we show that the structured enforcement operator behaves “well” regarding the given knowledge base. That is, if B is the full knowledge base and F′ is the current AF, then (i) no elements outside the knowledge base are invented, (ii) a solution AF F∗ contains all arguments that can be constructed when considering its base, and (iii) no attack was omitted.

We close this section with some remarks on the structured enforcement operator. First, we note that there are cases when an AF corresponding to the whole knowledge base does not achieve that a desired set of arguments is part of an extension, but a subframework might. That is, when interpreting the structured enforcement as “disclosing” information, in form of AF expansion for part of a knowledge base, an agent may withhold information in its own knowledge base, but still achieve the enforcement goal. We exemplify this behavior in a simple example.