On the Aggregation of Argumentation Frameworks

1 Introduction

Argumentation is based on the exchange and the evaluation of interacting arguments. In Dung's abstract argumentation theory [Dung, 1995], argumentation frameworks are modelized by binary graphs, where the nodes represent the arguments, and the edges represent the attacks between them. Then the question is to know what are the set of arguments that can be conjointly accepted from such graphs.

Dynamics of argumentation frameworks is an interesting question. In the last years there have been a lot of contributions of the problem of evolution (revision) of argumentation frameworks [Cayrol et al., 2008; Boella et al., 2009; Amgoud and Vesic, 2009; da Costa Pereira et al., 2011; Baumann, 2012; Coste-Marquis et al., 2014a; 2014b]. But there are quite a few contributions on the aggregation of argumentation frameworks. This problem is an important one for multi-agent systems: suppose that each member of a group of agents has his own argumentation framework, that represents his beliefs, then the problem is to define a (social) argumentation framework that represents the beliefs of the group. This is an important question on its own, but also because this computed aggregated argumentation framework could be considered as the result of an ideal negotiation process, with respect to which the results of practical negotiation protocols (see e.g. the work by Bonzon and Maudet [2011]) could be evaluated.

Contributions on this issue have been mainly proposals of particular aggregation methods [Coste-Marquis et al., 2007; Tohm´e et al., 2008; Cayrol and Lagasquie-Schiex, 2011;

Gabbay and Rodrigues, 2012]. We focus on the methods that comply with classical Dung's setting, that means that they take as input classical abstract argumentation frameworks, and return as output either an abstract argumentation framework (or more generally a set of abstract argumentation frameworks), or a set of extensions. So we do not study here the proposal by Gabbay and Rodrigues [2012] since the result is an ordered set of arguments.

One interesting contribution is the work by Dunne et al. [2012], where the authors define "rationality" properties for this kind of aggregation methods, but do not check if existing methods satisfy them.

This is what we propose in this work. We study existing methods of the literature in the light of the proposed properties. We also propose an additional method based on WAFs (Weighted Argumentation Frameworks) [Dunne et al., 2011; Coste-Marquis et al., 2012a]. In these works, one of the possible interpretations of the weights on the attacks that is mentioned is that they may represent the number of agents in a group that agree with this attack. So we endorse this view, and check how to use these works to define aggregation methods.

The conclusions of this study are that, on one hand, none of the existing operators seem fully satisfactory, but, on the other hand, some of the properties proposed so far seem also too demanding. So this suggests that some further work is still required both on the definition of operators as well as on the study of their properties.

The remainder of this paper is as follows. In the next section we provide the necessary background on argumentation frameworks. Section 3 is a reminder about the weighted argumentation frameworks, and Section 4 recalls the proposals for aggregating argumentation frameworks. Section 5 studies the properties of these aggregation methods. In Section 6 we propose a new aggregation method (more precisely three variations), and study their properties. In Section 7 we sum up and discuss the obtained results, before concluding in Section 8.

2 Preliminaries

In this section, we briefly recall some key elements of abstract argumentation frameworks as proposed by Dung [1995].

Definition 1 An argumentation framework (AF) is a pair F = 〈A,R〉 with A a set of arguments and R a binary relation on A, i.e. R ⊆ A×A, called the attack relation. A set of arguments S ⊆ A attacks an argument b ∈ A, if there exists a ∈ S, such that (a, b) ∈ R. For an AF F = 〈A,R〉, we note Arg(F ) = A and Att(F ) = R.

In this paper we will focus on the standard semantics defined by Dung [1995]: We note Eσ(F) the set of extensions of F for the semantics σ ∈ {comp(lete), pref(erred), sta(ble), gr(ounded)}.

An argument a is skeptically accepted iff there is at least one extension and a belongs to all extensions. An argument is credulously accepted iff it belongs to at least one extension. We denote by saσ(F) (respectively caσ(F)) the set of skeptically (resp. credulously) accepted arguments in F.

3 Weighted Argumentation Frameworks

Let us now turn to an extension of Dung's framework that allows to put weights on the attacks [Dunne et al., 2011; Coste-Marquis et al., 2012a; 2012b].

Definition 2 A Weighted Argumentation Framework is a triple WF = 〈A, R, w〉 where 〈A, R〉 is a Dung abstract argumentation framework, and w : A×A → N is a function assigning a natural number to each attack (i.e. w(a, b) > 0 iff (a, b) ∈ R), and a null value otherwise (w(a, b) = 0 iff (a, b) /∈ R).

Let us note WF the standard argumentation framework obtained from a weighted argumentation framework WF by "forgetting" the weights, i.e. if WF = 〈A,R,w〉 then WF = 〈A, R〉. We later show how to use WAFs to aggregate several AFs. For the moment let us recall how one can use them for relaxing extensions and for selecting the best amongst several extensions.

3.1 Relaxing Extensions

Initially WAFs were introduced with the idea to make sure to obtain non-empty extensions [Dunne et al., 2011]. Roughly, the idea is to delete some attacks in order to obtain extensions. The following definitions come from the work by Coste-Marquis et al. [2012b]:

Definition 3 We say that ⊕ is an aggregation function if for every n ∈ N, ⊕ is a mapping from Nn to N such that:

• if xi ≥ x′i , then ⊕(x1, . . . , xi, . . . , xn) ≥ ⊕(x1, . . . , x′i , . . . , xn)
• ⊕(x1, . . . , xn) = 0 iff for every i, xi = 0
• ⊕(x) = x.

Definition 4 Let WF = 〈A, R, w〉 be a weighted argumentation framework, σ be a semantics, and ⊗ be an aggregation function. The aggregation of the weights of the attacks in a set S ⊆ R is w⊗(S, w) = ⊗(a,b)∈Sw(a, b).

The function Sub(R,w,β) returns the set of subsets of R whose total aggregated weight does not exceed β: Sub(R,w, β) = {S | S ⊆ R and w⊗(S,w) ≤ β}. The set of σβ⊗-extensions of WF, denoted E ⊗,β σ (WF), is defined as: E ⊗,β σ (WF) = {E ∈ Eσ(〈A,R\S〉) | S ∈ Sub(R,w, β)}.

In contrast to what happens in Dung's setting, several grounded extensions may exists when relaxing extensions are considered. In particular it may happen that the empty set belongs to a set of relaxed extensions, which can be problematic because it trivializes skeptical inference relation, so the next definition removes this empty set from the set of extensions.

The most interesting value of β is the smallest one that leads to a non-empty extension (for the semantics under consideration):

Definition 5 Given a weighted argumentation framework WF = 〈A, R, w〉, a semantics σ, and an aggregation function ⊗, the set of σ⊗-extensions of WF, denoted by E ⊗ σ (〈A,R,w〉) is defined as E ⊗ σ (〈A, R, w〉) = E ⊗,β σ (〈A,R,w〉) where 1 :

• E ⊗,β σ (〈A,R,w〉) is non-trivial 2 ,
• There is no β′ < β s.t. E ⊗,β′ σ (〈A,R,w〉) is non-trivial,
• For a set E of extensions, E = E \ {∅}

3.2 Best Extensions

In general, an argumentation framework may admit a large number of extensions for some semantics. Within the WAF setting, it is possible to take advantage of the available weights, in order to select the "best" extensions. In the paper by Coste-Marquis et al. [2012a] this selection process goes through a comparison of the extensions scores, expressing intuitively how good they are.

Definition 6 Let WF = 〈A, R, w〉 be a weighted argumentation framework. Let E and F be two extensions of WF for a given semantics σ and ⊕ be an aggregation function.

The ⊕-attack from E on F is: S⊕(E → F) = ⊕a∈E,b∈Fw(a, b). Then E >⊕ F iff S⊕(E → F) > S⊕(F → E).

Let us introduce an additional parameter to the best function, that will be useful for the operators we define in Section 7.

Definition 7 Let WF be a weighted argumentation framework and X be a set such that ∀x ∈ X, x ⊆ Arg(WF). Let ⊕ be an aggregation function. Then :

• best⊕1 (X,WF) = {E ∈ X | ∄E′ ∈ X, E′ >⊕ E}
• best⊕2 (X,WF) = argmaxE∈X|{E′ ∈ X | E >⊕ E′}|
• best⊕3 (X,WF) = argmaxE∈X|{E′ ∈ X | E >⊕ E′}| - |{E′ ∈ X | E′ >⊕ E}|
• best⊕4 (X,WF) = argmaxE∈XKS⊕(E), where KS⊕(E) = minE′∈X,E′ ̸=E(S⊕(E → E′ ))

Four natural ways to define the ordering >⊕ are proposed in [Coste-Marquis et al., 2012a] :

Definition 8 Let WF be a weighted argumentation framework. Let ⊕ be an aggregation function. Then, ∀i ∈ {1, 2, 3, 4}, bestσ,⊕ i (WF) = best⊕i (Eσ(WF),WF).

1 We add a third condition compared to the original definition [Coste-Marquis et al., 2012b], in order to directly encode the nontrivial skeptical inference [Coste-Marquis et al., 2012b].

2 A set of extensions is non-trivial if it has at least one non-empty extension.

4 Aggregation Operators

Some merging operators for argumentation frameworks, inspired by propositional logic merging operators [Konieczny and Pino P´erez, 2002], have been defined [Coste-Marquis et al., 2007]. From now on, we make the hypothesis that all the argumentation frameworks are defined on the same set of arguments X 3 . We use the notation AF for the set of all argumentation frameworks defined from the set of arguments X used by the agents.

Definition 9 Let p = 〈AF1, . . . ,AFn〉 be a profile, d be a distance between AFs, and ⊕ be an aggregation function. The merging operator △⊕d is defined as : △⊕d (〈AF1, . . . ,AF2〉) = {AF ∈ AF | AF minimizes ⊕ni=1 d(AF, AFi)}.

The distance used by Coste-Marquis et al. [2007] as an example is an edit distance (de), which is in our case equivalent to the cardinality of the symmetrical difference between the two attack relations. Typical examples of aggregation functions are sum (Σ) and leximax. In what follows, we focus on these two functions.

Inspired by voting methods, other aggregation operators have been defined by Tohm´e et al. [2008]. In particular, they propose a qualified voting method :

Definition 10 Let p = 〈AF1, . . . , AFn〉 be a profile and U ⊂ {AF1, . . . ,AFn}. Qualified voting is defined as QV (〈AF1, . . . ,AFn〉) = (A,R), where A is the set of arguments used by agents, and R = {(a, b) | a, b ∈ A and |{AFi : (a, b) ∈ Att(AFi)}| > max(|{AFi : (b, a) ∈ Att(AFi)}|,|{AFi : (a, b) /∈ Att(AFi) and (b, a) /∈ Att(AFi)}|) and U ⊆ {AFi | (a, b) ∈ Att(AFi)}}.

5 Properties of Aggregation Function

Dunne et al. [2012] propose some rationality properties for characterizing aggregation of sets of argumentation frameworks, based on translations of properties coming from social choice theory to the argumentation setting.

Recall that we note by AF the set of all argumentation frameworks defined from a (finite) set of arguments and that we suppose that all agents have the same set of arguments. We denote by N the set of all agents. An aggregation function γ is defined by γ : AFn → AF. We note ˆ F = (F1, . . . , Fn) a tuple in AFn . Unless stated explicitely all the properties are defined ∀ ˆ F ∈ AFn .

Anonymity. The aggregation function γ is anonymous if it produces the same argumentation framework for all permutations Π( ˆ AF) of the input.

Non-Triviality. An argumentation framework is non-trivial, for a semantics σ, if it has at least one non-empty extension: |Eσ(F)| ⩾ 1 and Eσ(F) ̸= {∅}. Let us note AFNTσ the set of non-trivial (for the semantics σ) argumentation frameworks. The aggregation function γ is σ-strongly non-trivial if the ouput is always non-trivial :

3 This allows to simplify the definitions for input AFs. Namely, we are not obliged to use the notion of partial argumentation framework [Coste-Marquis et al., 2007] that allows to represent the ignorance of an agent towards the fact that an attack holds or not, and that requires a first completion step before the proper merging.

The aggregation function γ is σ-weakly non-trivial if, when all the input frameworks are non-trivial, then the output framework is non-trivial:

Decisiveness. An argumentation framework is decisive, for a semantics σ, if it has exactly one non-empty extension: |Eσ(F)| = 1 and Eσ(F) ̸= {∅}. Let us note AFDσ the set of decisive (for the semantics σ) argumentation frameworks. The aggregation function γ is σ-strongly decisive if the output is always decisive :

The aggregation function γ is σ-weakly decisive if when all the input frameworks are decisive, then the output framework is decisive:

Unanimity. This property specifies that if all agents are unanimous with respect to some aspect of the domain (extensions, attacks, . . . ), for a semantics σ, then this unanimity should be reflected in the social outcome.

• Unanimous attack checks attacks between arguments:

• σ-unanimity concerns extensions:

• caσ-unanimity concerns credulous inference:

• saσ-unanimity concerns skeptical inference:

Majority. If a strict majority of agents agree on something, then this should be reflected in the social outcome:

• Majority attack concerns attacks between arguments:

• σ-majority concerns extensions:

(σ-MAJ) (|{Fi : S ∈ Eσ(Fi)}| > n2 ) ⇒S ∈ Eσ(γ( ˆ

• caσ-majority concerns credulous inference:

• saσ-majority concerns skeptical inference:

Closure. These properties say that the aggregation function must not invent some entity which does not exist in the input. · Closure says that the AF in output must match exactly one AF in input :

• Attack closure says that if one attack is in the AF in output, this attack must be present in at least one AF in input:

• σ-closure is related to extensions:

F ))

Tohm´e et al. [2008] propose some properties for characterizing good aggregation operators, inspired from social choice theory. They propose a property that they call Pareto condition, that is exactly Unanimous attack (UA), and a nondictatorship property, that is satisfied by all reasonable aggregation operators. We give below the two other properties that they propose, that are translations of meaningful social choice theory properties:

Positive responsiveness. This property says that increasing the number of agents that have an attack, should not decrease the chance for that attack to appear in the social outcome:

Independence of irrelevant alternatives. Deciding whether an attack holds or not should be concerned only with the attacks between these two arguments in the input profile.

This is not mentioned in [Tohm´e et al., 2008], but one can easily show that PR implies IIA:

Proposition 1 Positive responsiveness implies Independence of Irrelevance Alternatives.

To this set of properties from the literature we want to add a very simple property that is missing. Indeed, if all the AFs at the input coincide, the result of merging should be identical to this AF.

• Identity attack on the attacks :

• σ-Identity on the extensions :

• caσ-Identity on the credulous inference :

• saσ-Identity on the skeptical inference :

(saσ-ID) ∀F ∈ AFNTσ : saσ(γ(F, . . . , F)) = saσ(F) These four intuitive properties are particular cases of the property of unanimity. In the case where we merge a single AF (which represents the beliefs of one agent) then this property implies that the operator should not change this AF, that, as we will see, is not ensured by all aggregation methods.

6 Properties of Existing Operators

Let us first check what are the properties satisfied by the merging operators of Coste-Marquis et al. [2007]. Recall that the properties introduced by Dunne et al. are defined for a unique AF as output, whereas the merging operators may have several AFs as output. We generalize the properties from the previous section as follows: instead of asking that a property holds for the AF at the output, we ask that the same property is satisfied by all the output AFs. By following this idea, most of the properties can be generalized in a straightforward way. There exists no straightforward way to generalize the definition of IIA to the case when several AFs are allowed in the output. That is why we do not consider it in the remainder of the paper.

Proposition 2 △Σde satisfies Anonymity (ANON), the properties of Identity (A-ID, σ-ID, caσ-ID, saσ-ID), the properties of Unanimity (UA), Majority (MAJ-A), Attack closure (AC) and Positive responsiveness (PR) for every semantics σ ∈ {comp, pref, sta, gr}. The other properties are not satisfied.

Let us check now if there are more properties satisfied when we use the leximax as aggregation function.

Proposition 3 △leximax de satisfies Anonymity (ANON), the properties of Identity (A-ID, σ-ID, caσ-ID, saσ-ID), the properties of Unanimity (UA), Attack closure (AC) and Positive responsiveness (PR) for every semantics σ ∈ {comp, pref, sta, gr}. The other properties are not satisfied.

Let us now turn to the properties satisfied by the qualified voting method [Tohm´e et al., 2008].

Proposition 4 QV satisfies gr-weak non triviality (gr-WNT), gr-weak decisiveness (gr-WD), Attack closure (AC) and Positive responsiveness (PR). The other properties are not satisfied.

7 UsingWAFs for Aggregating AFs

Let us now propose new aggregation methods based on WAFs. When WAFs were introduced [Dunne et al., 2011; Coste-Marquis et al., 2012a; 2012b] one of the possible interpretations of the weights on the attack relation that was proposed was that it could represent the number of agents in a group that agree with the attack. So we endorse this interpretation and study how we can define operators that aggregate a set of AFs using techniques developed for WAFs.

7.1 FUSAll

The first method, noted FUSAll, consists in simply building a WAF where the weights represent the number of agents that agree with (i.e. that have) this attack. Once built, we use one of four best methods [Coste-Marquis et al., 2012a] in order to obtain, as output, a set of extensions representing the result of the aggregation of the profile.

Note that the construction of waf( ˆ AF) is exactly the one proposed by Cayrol and Lagasquie-Schiex [2011] up to a normalization of the weights, but in that work nothing is said about what to do with the obtained WAF. We propose to use the best methods in order to find extensions as output.

Let us now check which properties are satisfied by FUSAll. Note that these operators produce as result a set of extensions. Hence, some of the properties, dealing with attacks relation of the result, are not applicable in this framework, namely Unanimous attack (UA), Majority attack (MAJ-A), Closure (CLO), Attack closure (AC), Identity attack (ID-A) and Positive Responsiveness (PR). We recall also that in this paper we focus on the main semantics defined by Dung : σ ∈ {pref, gr, sta, comp}. Finally, concerning the best extensions, we choose to study the four best rules with the sum and the max as aggregation function (⊕ ∈ {Σ, max}).

Proposition 5 Let σ ∈ {comp, pref, sta, gr} be a semantics. Let ⊕ ∈ {Σ,max} be an aggregation function. FUSAll satisfies Anonymity (ANON) and properties gr-Identity (grID), cagr-Identity (cagr-ID) and sagr-Identity (sagr-ID) for each rule best. The other properties are not satisfied.

In particular, one of the properties that is not satisfied is non-triviality, meaning that with these operators we do not ensure to always have at least one result as output, which can be considered as an important drawback.

7.2 FUSAllNT

A solution to satisfy non-triviality is to ensure that the set of extensions of a WF is always non-empty, by using the relaxing extensions techniques [Coste-Marquis et al., 2012b].

Definition 12

Concerning the aggregation function used for relaxing extensions, we only focus on the sum 4 (⊗ = Σ).

Proposition 6 Let σ ∈ {comp, pref, sta, gr} be a semantics. Let ⊕ ∈ {Σ, max} and ⊗ = Σ be two aggregation functions. FUSAllNT satisfies Anonymity (ANON), σ-strong nontriviality (σ-SNT), σ-weak non triviality (σ-WNT) and properties gr-Identity (gr-ID), cagr-Identity (cagr-ID) and sagrIdentity (sagr-ID) for each rule best. The other properties are not satisfied.

This operator is useful if we want to take into account all the attacks given by the agents. However, the result does not represent the opinion of the majority. For instance, suppose that we have nine AFs with A = {a, b} and R = {} and one AF with the same arguments but R = {(a,b)}. If we merge these ten AFs by using an aggregation operator from this family, then the attack (a, b), only given by one agent, is present in the resulting system. This is clearly against the opinion of the majority.

7.3 FUSMajNT

So, it seems that a more natural way of constructing the WAF corresponding to the set of AFs should take into account the notion of majority during the construction of the WAF. This means that, instead of representing all the attacks of the profile, we only select the attacks accepted by a majority of agents.

4 That is the original definition by Dunne et al. [2012].

Definition 13

Let us now check what properties are satisfied by FUSMajNT .

Proposition 7 Let σ ∈ {comp, pref, sta, gr} be a semantics. Let ⊕ ∈ {Σ,max} and ⊗ = Σ be two aggregation functions. FUSMajNT satisfies Anonymity (ANON), σstrong non-triviality (σ-SNT),σ-weak non triviality (σ-WNT) and properties gr-Identity (gr-ID), cagr-Identity (cagr-ID) and sagr-Identity (sagr-ID) for each rule best. The other properties are not satisfied.

Note the surprising fact that the properties of majority are not satisfied by FUSMajNT .

8 Discussion

Let us sum up our results and discuss their impact. Table 1 summarizes the properties satisfied by all aggregation methods we considered in this paper. A cross × means that the property is not satisfied, symbol ✓means that the property is satisfied, ✓σ means that the property is satisfied for the semantics σ, and symbol - means that the property can not be applied to the operator (because the output of the operator is not compatible with the constraint given by the rule).

It is clear that there are few properties satisfied by the existing aggregation operators. There are two possible (nonexclusive) explanations: either the existing operators are not good enough, or the "rationality" properties are too demanding. Our point of view is that both are true to some extent; this means that more work is needed both in defining a set of rationality properties that capture more adequately the desirable behaviour of an aggregation operator, and on defining aggregation methods themselves.

Let us first argue that some of the properties are too strong (this means that not satisfying them is not that a disqualifying feature for an aggregation operator). To show that, we will use a simple and intuitive example which contradicts nine properties.

Example 1 Let AF1, AF2 and AF3 be the three argumentation frameworks represented in Figure 1. They all have the same (unique) complete/preferred/stable/grounded extension: {a,c,d,e}.

This proposed result can seem, at first sight, illogical if we look at the obtained extensions (and consequently the accepted arguments) since each AFi has the same extension {a, c, d, e}, so we could expect this extension to be the outcome. But if we look more closely at this example, we can see that this same extension is obtained for very different reasons. Each agent has a reason (argument) to reject b, but this attack is challenged by all the other agents, and thus could be interpreted as an error of this agent. So it is quite natural to refuse all attacks on b for the outcome aggregation framework, and that means that {a, c, d, e} should be rejected as the extension of the outcome (and that {b, d, c, e} is much more natural). In fact, it is the outcome that is obtained by the majority method (majority vote on the attack relation): all the AFi agree on the attack (b, a), whereas all other attacks have a maximum of one AFi supporting it. This is also the result obtained with FUSMajNT operators. However, that goes against the properties of unanimity, majority and closure related to extensions, credulous inference and skeptical inference 5 . So if one wants to obtain the expected outcome of this example, only the properties about the attack relations seem not problematic.

5σ-MAJ, caσ-MAJ, saσ-MAJ, σ-U, caσ-U, saσ-U, CLO, σ-C, caσ-C, and saσ-C

We want to insist on the fact that we give here a simple example with only three bases, but this example can be generalized with 100 agents (and 102 arguments), such that (b, a) is supported by all, and each agent i supports only an additional attack between argument ai and b (and he is the only one to support it). In this case the quasi-unanimity situation (all agents except one are against the other attacks) is much more striking.

The properties of decisiveness seem also much too strong requirements for most semantics that accept several extensions (and are trivial for the ones that accept at most one extension), so we propose to remove them from necessary properties also.

Basically our opinion is that the proposed properties were more or less direct translations of properties coming from social choice theory. This was certainly an important first step. However, argumentation frameworks have more structure than sets of candidates in voting problems, so the specificities of this structure of AFs have to be taken into account. We argue that these structural specificities invalidate some of the properties from social choice theory as being required for aggregation of AFs. This does not mean that they are not of interest, since they can be used to characterize some aggregation methods (they should be some methods that satisfy them), but they can not be considered as absolutely necessary requirements.

The shaded rows in Table 1 contain, in our opinion, the most desirable properties if one concentrates on the attack relation. And one can see that there is no existing aggregation method that fully satisfies all of these important properties. So this means that there is still work needed to define good aggregation operators. Indeed, Example 1 illustrates that there seem to be some incompatibilities between the rationality properties for aggregation of argumentation frameworks that deal with extensions and the ones that deal with attacks. Both approaches seems sensible, so this means that they should be two different sets of postulates, depending on the chosen priority, i.e. one that focuses on extensions and one that concentrates on the attack relation.

9 Conclusion

In this paper we put together the works from the literature on aggregation methods for Dung's abstract argumentation frameworks. We focus on the methods that take as input a profile of abstract argumentation frameworks, and give as result an argumentation framework, set of argumentation frameworks, or a set of extensions.

We also investigate the use of WAFs in order to aggregate profiles of AFs, and we end up with three possible definitions, FUSMajNT being certainly the most convincing.

We show that few of the proposed properties are satisfied by existing aggregation operators. The explanation seems to incriminate both suspects: the properties and the methods. At one hand, some of the properties seem to be too demanding in the general case. At the other hand, the existing operators do not satisfy even the most desirable properties.

Our results seem to suggest that a lot of work is still needed on the two fronts. A more careful study of the rationality properties for aggregation methods for abstract argumentation is required. And there is clearly room for definition of other (better?) aggregation methods.

We plan to study if using properties from propositional belief merging [Konieczny and Pino P´erez, 2002] could be more appropriate. Indeed, these properties were defined for a framework (propositional logic) that also has some structure. So we are working on the translation of these properties for argumentation framework merging, similarly to what have been done recently for belief revision [Coste-Marquis et al., 2014a], in order to define maybe more adequate rationality properties, and get some ideas to define new aggregation methods.

Acknowledgments

This work benefited from the support of the project AMANDE ANR-13-BS02-0004 of the French National Research Agency (ANR).