Multiparty Argumentation Game for Consensual Expansion

Stefano Bromuri

and Maxime Morge

Institute of Business Information Systems, University of Applied Sciences Western Switzerland, Sierre, Switzerland

Laboratoire d’Informatique Fondamentale de Lille, Universit

e Lille 1, Lille, France

Keywords:

Multi-Agent Systems, Argumentation, Multiparty Communication.

Abstract:

We consider here a set of agents, each of them having her own argumentation. Arguments and conﬂicts be-

tween them are subjective. The aim of each agent is to enrich her argumentation by taking into account the

arguments and conﬂicts of the other agents. We adopt here an individual-based approach where the cross-

fertilization of argumentations emerge from the interactions between the agents. For this purpose, we formal-

ize a multi-party argumentation game using Event Calculus. At the end of the game, each agent extends its

argumentation by using the arguments exchanged and the conﬂicts shared. As we show formally, such an ex-

pansion is consensual. By adopting an individual-based approach, our model is explanatory since it highlights

the conﬂicts between the agents.

1 INTRODUCTION

Multi-Agent Systems (MAS) is a ﬁrst-class paradigm

for analysing, designing and implementing systems

composed of autonomous interacting entities. Oppo-

sitions characterize these systems. Conﬂicts may ap-

pear between agents since each of them has a partial

perception of the environment or they have their own

objectives. Well-known mechanisms such as voting

systems or negotiation resolve these conﬂicts by ag-

gregating the viewpoints to reach an agreement. Un-

fortunately, these models are not explanatory. In the

argumentation approach, the positions (arguments)

and the oppositions (attacks) are ﬁrst-class citizens.

Argumentation is a computational calculus of opposi-

tions (Dung, 1995). In this paper, we adopt a dialec-

tical approach of argumentation where the argumen-

tation is the outcome of a dispute process (Prakken,

2006).

We consider here a set of agents, each of them

having her own argumentation. Arguments and con-

ﬂicts between arguments are subjective. They may be

different. For example, an agent can consider that an

argument attacks a second one while another agent

may have the same arguments without considering

them conﬂicting. Similarly, a third agent may not

know one of these arguments and therefore she ig-

nores this conﬂict.The aim of each agent is to enrich

her argumentation by taking into account the argu-

ments and conﬂicts of the other agents.

We adopt an individual-based approach where the

cross-fertilization of argumentations emerge from the

interactions between the agents. For this purpose,

we formalize a multiparty argumentation game using

Event Calculus (EC) (Kowalski and Sergot, 1986). At

the end of the game, each agent extends its argumen-

tation by using the arguments exchanged and the con-

ﬂicts shared. As we show formally, such an expan-

sion is consensual. By adopting an individual-based

approach, our model is explanatory since it highlights

the conﬂicts between the agents.

We start this paper by introducing the background

formalisms on which we built our argumentation

game (cf Section 2). Then, we deﬁne in Section 3,

the consensual expansion which is the outcome of our

game (cf Section 4). We discuss the related works (cf

Section 5). Section 6 concludes by summarising our

proposal and discussing our future plans.

2 BACKGROUND

In this section we discuss about the background for-

malisms that are necessary to understand our argu-

mentation game.

2.1 Argumentation

In this paper we adopt the abstract approach to argu-

mentation proposed in (Dung, 1995). Arguments are

160

Bromuri S. and Morge M..

Multiparty Argumentation Game for Consensual Expansion.

DOI: 10.5220/0004188301600165

In Proceedings of the 5th International Conference on Agents and Artiﬁcial Intelligence (ICAART-2013), pages 160-165

ISBN: 978-989-8565-38-9

 2013 SCITEPRESS (Science and Technology Publications, Lda.)

viewed as abstract entities supporting claims. The fact

that an argument is challenged by another captures the

notion of conﬂict.

Formally, an Argumentation Framework (AF) is

deﬁned as follows.

Deﬁnition 1 (AF). An Argumentation Framework is

a couple AF = hA, Ri where A is a ﬁnite set of argu-

ments, R ⊆ A × A is a binary relation called attack

relation.

If (a, b) ∈ R, then we say that a attacks b (we

write this as aRb). We call non-attack relation N =

(A × A) \ R. In this way, we highlight that the lack

of attack between arguments is interpreted as a non-

attack relation.

An argumentation framework does not allow to

model missing information. For this purpose, a Par-

tial Argumentation Framework (PAF) is an extension

of the AF model, proposed in (Coste-Marquis et al.,

2007), where the fact that an argument attacks (or not)

a second argument can be ignored. This missing in-

formation is captured by a binary relation, called ig-

norance relation.

Deﬁnition 2 (PAF). A partial argumentation frame-

work is a triplet PAF = hA,R,Ii where:

• hA,Ri is the underlying AF as deﬁned in Def. 1;

• I ⊆ A × A is the ignorance relation which veriﬁes

that R ∩ I =

We call non-attack relation N = (A × A) \ (R ∪ I).

2.2 Event Calculus

The Event Calculus (EC), introduced in (Kowalski

and Sergot, 1986), is a formalism for representing ac-

tions and their effects and so it is very suitable for

formalising an interaction protocol for agents. In this

section we brieﬂy describe the dialect of the EC that

we employ (Artikis et al., 2010).

EC is based on a many-sorted ﬁrst-order predicate

calculus represented as normal logic programs that

are executable in Prolog. The underlying time model

is linear. The EC manipulates ﬂuents. A ﬂuent repre-

sents a property which can have different values over

time. The term F = V (which denotes that ﬂuent F

has value V ) has been initiated by an action at some

earlier time-point and not terminated by another ac-

tion in the meantime. Tab. 1 summarizes the main EC

predicates we use in this paper. Predicates, function

symbols and constants start with a lower-case letter

while variables (starting with an upper-case letter) are

universally quantiﬁed.

The domain independent axioms of the EC are

represented in Fig. 1. Clause EC1 states that a prop-

erty holds at a time T if it has been initiated at time

Table 1: EC with multi-valued ﬂuents: predicates.

Predicate Meaning

initially(F=V) The value of ﬂuent F is V

at time 0.

holds at(F=V,T) The value of ﬂuent F is V

at time T.

initiates at(F=V, T ) At time T the ﬂuent F is

initiated to have value V.

terminates at(F=V, T ) At time T the ﬂuent F is

terminated from having

the value V.

update(E,T) An event E takes place at

time T updating the state

of the ﬂuents

Ts and the holding of that property has not been bro-

ken from the starting time Ts and the time of interest

T. To decide when a property is broken, we use the

clause EC2. This states that a property P is broken

between time Ts and T, if it is terminated at a time Ti

between Ts and T. The other clauses specify when a

property is initiated EC3 or terminated EC4, in terms

of the conditions holding in the current context, typi-

cally expressed in terms of the holds at/2 predicate,

meaning that such clauses will change according to

the particular domain being modelled with the EC.

(EC1) h o l d s a t ( F=V , T) ← i n i t i a t e s a t ( F=V , T

) ,

< T ,

not broken (F=V, T

, T ) .

(EC2) broken ( F=V1 , Tmin , Tmax) ← t e r m i n a t e s a t ( F=V

, T i ) ,

not V

= V

Tmin < Ti , T i < Tmax .

(EC3) i n i t i a t e s a t ( F=V, T ) ← happen s at ( Ev , T ) ,

Co nd i ti o n s [ T ] .

(EC4) t e r m i n a t e s a t ( F=V, T ) ← h appens at (Ev , T ) ,

Co nd i ti o n s [ T ] .

Figure 1: Axioms of the EC with multi-valued ﬂuents.

The EC allows us to construct executable speciﬁ-

cations of interaction protocols for agents.

3 PROBLEM

We consider here a set of agents, each of them having

its own arguments. The agents aim at expanding their

arguments, in particular the conﬂicts between them,

based on a consensus.

Formally, we consider here a proﬁle of n argumen-

tation frameworks

S = hAF

,. .. ,AF

i. Our goal here

is to expand this vector in a proﬁle of partial argumen-

tation frameworks

P = hPAF

,. .. ,PAF

i where each

PAF

expands the corresponding AF

with

S by tak-

MultipartyArgumentationGameforConsensualExpansion

161

ing account the arguments, the attacks and the non-

attacks from the other AFs in

For this purpose, we focus on the consensual ex-

pansion proposed by (Coste-Marquis et al., 2007). In

order to expand an AF

on a PAF

, we consider all the

arguments and only the consensual attacks.

Deﬁnition 3 (Consensual Expansion). Let

S =

hAF

,. .. ,AF

i be a proﬁle of n argumentation frame-

works AF

= hA

i (cf Def. 1) with 1 ≤ i ≤ n.

Let con f (

S) = (

) ∩ (

) be the set of non-

consensual attacks. The consensual expansion of AF

with

S is a partial argumentation framework PAF

i where:

• A

;

• R

= R

∪ ((

j6=i

) \ con f (

S));

• I

= con f (

S) \ (A

× A

Obviously, N

= (A

× A

) \ (R

∪ I

). The argu-

ments in the consensual expansion (A

) are all the

arguments from the initial proﬁle. A new attack is

added (R

) if it is consensual, i.e. if all agents which

initially consider these arguments agree on this con-

ﬂict. An attack is ignored (I

) if it is not consen-

sual (con f (

S)) and if it was not considered a priori

× A

It is worth noticing that, in order to determine

a consensual expansion, we assume to know the ar-

guments and the attacks (and non-attacks) of all the

agents. In the next section, we do not make such an

assumption.

4 PROPOSAL

We adopt here an individual-oriented approach where

the consensual expansion emerges from the interac-

tions between the agents. Our proposal consists of

a multiparty argumentation game, where more than

two agents, each of them with a AF, play and observe

moves on a gameboard. At the end of the game, each

agent builds its PAF with the arguments and the con-

ﬂicts recorded on the game-board.

Firstly, we begin to introduce the gameboard. Sec-

ondly, we formalize the argumentation game and its

output. Then we prove the correctness of the game.

Finally, we illustrate this game with an example.

4.1 Gameboard

The gameboard is a common environment perceived

by agents in which they can act by adding arguments,

attacks and non-attacks. These moves are evaluated

via an artifact which records the dialogue history.

Deﬁnition 4 (gb). At any moment, the gameboard is

an objective representation of the game with a triplet

gb = hAM, RM, DMi where:

• AM is the record list of argument moves;

• RM is the record list of attack moves;

• DM is the record list of denial moves.

Each utterance of a move is interpreted by the ar-

tifact for updating the gameboard in order to build the

common partial argumentation framework.

Deﬁnition 5 (AF

). We call common partial argu-

mentation framework PAF

= hA

i, the ar-

gumentation framework deﬁned such that:

• A

is the set of arguments in the argument moves

of AM;

• R

is the set attacks in the attack moves of RM;

• D

is the set of ignorances in the denial moves of

DM.

We aim at deﬁning the game such that the rational

rules of utterances and the rules of the game leads to

a common partial argumentation framework PAF

i which is:

1. complete, i.e. A

;

2. a coherent partial argumentation framework, i.e.

∩ D

3. consensual, i.e. R

(resp. D

) belongs all

the attacks which are consensual (resp. non-

consensual).

4.2 Argumentation Game

The game we propose is a n-players simultaneous

game. We formalize here our game using the EC and

the rational condition of utterance using abstract ar-

gumentation.

Our argumentation game is subdivided into two

subgames. The ﬁrst one aims at collecting all the ar-

guments of the agents. It is called argument game.

The second game aims at collecting all the consensual

attacks and all the non-consensual ones. It is called

attack game. The argument (resp. attack) argument

ends when all the players withdraw, i.e. when they

have no more arguments (resp. attacks) to push for-

ward.

The two following clauses handle the creation of

the game:

i n i t i a t e s a t ( gb ( Gb) = s t a t e ( argGame ) , T): −

ha ppens at ( create game ( GID , PL ) , T ) ,

not h o l d s a t ( gb (Gb)= st a t e ( ) , T ) .

i n i t i a t e s a t ( gb ( Gb) = p l a y e r s l i s t ( PL ) , T): −

ha ppens at ( create game ( Gb, PL ) , T ) ,

not h o l d s a t ( gb (Gb)= st a t e ( ) , T ) .

ICAART2013-InternationalConferenceonAgentsandArtificialIntelligence

162

While the ﬁrst clause handles the creation of the

gameboard GID by setting the game state argGame,

the second clause sets the list of players PL.

Argument Game. The moves update the gameboard

only if they are legal moves. The update game/3

predicate below, speciﬁes that a Move is produced as

an event that modiﬁes the state of a game Gb only if

such a move is legal at time T in such a game.

update game (Gb, AID , Move): −

now( T ) , l e g a l

a t (Gb, AID , Move , T ) ,

update (Move , T ) .

The legal at/4 predicate deﬁnes which moves

can be performed at a certain time. For example, if

the agent is trying to produce an assertion move, the

artifact checks if the argument in the assertion is a

new one. If this is the case it updates the common

partial argumentation framework.

i n i t i a t e s a t ( gb ( Gb) = argument ( AID , Arg ) , T): −

ha ppens at (move (Gb, AID , a l l , as s ert , ArgID , Arg ) , T ) .

l e g a l a t ( Gb, AID , move (Gb, AID , a l l , as s ert , ArgID , Arg ) , T): −

h o l d s a t ( move( Gb , AID , a l l , a s se r t , ArgID , Arg ) , T ) ,

not ( h o l d s a t ( gb (Gb)= argument ( , Arg ) , T ) ) .

In the case that the argument is already present in

the gameboard, the gameboard will not be updated,

because the legal at/4 predicate deﬁned above will

check if in the gameboard Gb it exists an argument

Arg that is the same as the one being asserted. It

is important to notice that the argument id (ArgID)

is required as the gameboard can have multiple ar-

guments simultaneously initiated. Furthermore, the

legal at/4 predicate can be used by the agents to

check if the next move they want to perform is a le-

gal move. In other words the legal at/4 predicate

can be used by the agents in combination with the

holds at/2 predicate of the EC to perceive the game-

board state.

The argument game ends when all the players

withdraw:

t e r m i n a t e s a t ( gb (Gb) = s t a t e ( argGame ) , T): −

ha ppens at (move (Gb, AID , a l l , with draw , no , no ) , T ) ,

not (

h o l d s a t ( gb (Gb)= p l ay e r ( AID2 ) , T ) ,

h o l d s a t ( pl a y e r ( AID2)= st a t u s ( moreArg ) , T ) ,

not AID = AID2

) .

i n i t i a t e s a t ( gb ( Gb) = s t a t e ( attGame ) , T): −

ha ppens at (move (Gb, AID , a l l , with draw , no , no ) , T ) ,

not (

h o l d s a t ( gb (Gb)= p l ay e r ( AID2 ) , T ) ,

h o l d s a t ( pl a y e r ( AID2)= st a t e (Gb, moreArg ) , T ) ,

not AID = AID2

) .

In the rules deﬁned above, the argument game

ends when all the agents perform a withdraw move,

and so the attack game is initiated. For the argument

game, the withdraw move is always legal.

Attack Game. In this game, agents assert/deny at-

tacks or withdraw. After an assertion (resp. deny),

the artifact updates the common partial argumentation

framework if it is the case:

i n i t i a t e s a t ( gb ( Gb) = at t a c k ( A t t ID ) , T): −

ha ppens at (move (Gb, AID , a l l , as s ert , At t ID , A t t ) , T ) .

i n i t i a t e s a t ( gb ( Gb) = ig n o re ( At t I D ) , T): −

ha ppens at (move (Gb, AID , AID2 , deny , Att I D , A t t ) , T ) .

Similarly to the previous subgame, the moves up-

date the gameboard only if they are legal moves.

l e g a l a t ( Gb, AID , move (Gb, AID , a l l , a s se r t , A t tID , A t t ) , T): −

not (

h o l d s a t ( gb (Gb)= at t a c k ( , A t t ) , T ) ,

h o l d s a t ( gb (Gb)= i gn or e ( , A t t ) , T )

) .

l e g a l a t ( Gb, AID , move (Gb, AID , a l l , deny , Att I D , A t t ) , T ) ,

h o l d s a t ( gb (Gb)= at t a c k ( , A t t ) , T ) ,

not h o l d s a t ( gb (Gb)= i gn or e ( , A t t ) , T ) .

The two legal at/4 predicates speciﬁed above

state that the assertion of an attack is legal if the at-

tack is not already present in the game, even if the

identiﬁer is different. Similarly, the deny of an attack

is legal if the attack already exists in the gameboard

and the attack is not already ignored. As for the argu-

ment game, a withdraw move is always legal.

The attack game ends when all the players with-

draws, which is also the termination condition for the

whole game:

t e r m i n a t e s a t ( gb (Gb) = s t a t e ( attGame ) , T): −

ha ppens at ( wi t h d r a w (Gb, AID ) , T ) ,

not (

h o l d s a t ( gb (Gb)= p l ay e r ( AID2 ) , T ) ,

h o l d s a t ( pl a y e r ( AID2)= st a t u s ( m ore att a c ks ) , T ) ,

not AID = AID2

) .

i n i t i a t e s a t ( gb ( Gb) = s t a t e ( f i n a l ) , T): −

ha ppens at ( wi t h d r a w (Gb, AID ) , T ) ,

not (

h o l d s a t ( gb (Gb)= p l ay e r ( AID2 ) , T ) ,

h o l d s a t ( pl a y e r ( AID2)= st a t u s ( m ore att a c ks ) , T ) ,

not AID = AID2

) .

Rational Rules. Each player ag

, which is associated

with an argumentation framework AF

= hA

i, can

check the legality of moves using the EC predicate

legal at/4 and submit it if it is the case.

As previously discussed, during the argument

game, agents assert new arguments or withdraw. At

time t, an agent can submit a move based on the fol-

lowing rational rule:

utters







m = hgid, ag

,all,assert, ai

if ∃a ∈ A

∧ legal at(gid, ag

,m,t)

m = hag

,all,withdraw, nulli else

(1)

MultipartyArgumentationGameforConsensualExpansion

163

During the attack game, an agent can submit at time t

a move based on the following rational rules:

utters











m = hgid, ag

,all,assert, (a, b)i if

∃(a,b) ∈ R

∧ legal at(gid, ag

,m,t)

m = hgid, ag

,ag

,deny, (a, b)i if

∃(a,b) ∈ N

∧ legal at(gid, ag

,m,t)

hgid, ag

,all,withdraw, nulli else

(2)

Here we assume that agents are honest.

4.3 Game Over

At the end of the game, some properties about the

common partial argumentation framework hold. For

brevity, we do not include here the proofs.

Property 1. The following properties are veriﬁed:

• The argument game and the attack game end.

• At the end of the argument game, A

• At each turn, R

∩ D

• At the end of the attack game, (a, b) ∈ R

iff (∃i |

(a,b) ∈ R

) ∧ (@ j | (a,b) ∈ N

)).

• At the end of the attack game, (a,b) ∈

iff ∃i, j | (a,b) ∈ R

∧ (a, b) ∈ N

4.4 Outcome

At the end of the game, each player expands her argu-

mentation framework with the arguments, the attacks

and the denials reported in the common partial argu-

mentation framework:

Deﬁnition 6 (Game Expansion). Let

S =

hAF

,. .. ,AF

i be a proﬁle of n argumentation

frameworks and AF

= hA

i be one of them. The

expansion of AF

with PAF

= hA

i is the

partial argumentation framework PAF

= hA

deﬁned such that:

1. A

= A

;

2. R

= R

∪ R

3. I

= D

\ (A

× A

)

Obviously, N

= (A

× A

) \ (R

∪ I

). It is worth

noticing that this expansion is built upon the initial

argumentation framework of the agent and the com-

mon partial argumentation framework. Contrary to

the consensual expansion (cf Def. 3), we do not need

to know the arguments and attacks of all the other

agents but only the outcome of the game.

The common partial argumentation framework al-

lows to expand the individual argumentation frame-

works in a consensual manner.

Property 2 (Consensual Game Expansion). Let

S =

hAF

,. .. ,AF

i a proﬁle of n argumentation frame-

work and let AF

= hA

i be one of them. The ex-

pansion of AF

with the common partial argumenta-

tion framework PAF

= hA

i is consensual

(cf Def. 3).

4.5 Example

We present here an illustrative example for our game.

We consider four agents associated to the pro-

ﬁle of argumentation frameworks depicts at top of

Fig. 2. At the end of the argument game, the com-

mon argumentation framework contains all the ex-

isting arguments in the system, A

= {a, b, c, d}.

At the end of the attack game, the common argu-

mentation framework (represented in the middle of

Fig. 2) contains all the consensual attacks (R

{(b,c), (c,d)}) represented by plain arrows and all the

non-consensual attacks represented by dotted arrows

= {(b, d), (b,a), (a,b), (a,d)}). At the end of the

game, each agent build her own PAF (shown at the

bottom of Fig. 2).

Finally, the common argumentation framework

contains all the conﬂicts exhibited through the dia-

logue in D

. Moreover, the gameboard contains in

DM all the conﬂicts which arise between the agents:

• the agents ag

and ag

disagree on (a, b), m

hag

,ag

,deny, (a, b)i;

• the agents ag

et ag

disagree on (b, d), m

hag

,ag

,deny, (b, d)i;

• the agents ag

et ag

disagree on (b,a), m

hag

,ag

,deny, (b, a)i;

• the agents ag

and ag

disagree on (a, d), m

hag

,ag

,deny, (a, d)i;

It is worth noticing that this list of disagreements

is not exhaustive. For instance, this execution does

not underline neither the disagreement between the

agents ag

and ag

over the attacks (b, a), nor the dis-

agreement between the agents ag

and ag

over the

attacks (a,b).

5 RELATED WORKS

There is few research on multiparty argumentation

games. Recently, (Bonzon and Maudet, 2011) have

proposed a multiparty persuasion protocol. This work

differs from our proposal. On one hand, (Bonzon

and Maudet, 2011) assume that all agents share the

same arguments and only the attacks are subjective.

We consider here that the arguments are distributed in

ICAART2013-InternationalConferenceonAgentsandArtificialIntelligence

164

PAF

a c

PAF

a c

PAF

a c

PAF

a c

PAF

a c

Figure 2: The proﬁle of argumentation frameworks (at top), the common argumentation framework (at middle) and the proﬁle

of partial argumentation frameworks (at bottom).

the multi-agent system. On the other hand, the game

proposed by (Bonzon and Maudet, 2011) arbitrates

among conﬂicting viewpoints. The outcome of such

an arbitration is then compared with the outcome of

the fusion of these viewpoints. In our approach, the

objective of the game is not a collective decision but

a cross-fertilization of views and the detection of the

conﬂicts between the agents.

(Bodenstaff et al., 2006) study the suitability of

the Event Calculus for formalising argumentation

game and its implementation with a declarative pro-

gramming language by carrying out two case studies.

With respect to this work, we differ as we consider

a multiparty game and our agents use the declarative

formalisation of the game to reason about the moves

which are allowed and the agents choose one of them.

6 CONCLUSIONS

In this paper, we have considered a set of agents,

each of them is equipped with her own argumentation

framework. In this way, the arguments are distributed

in the multi-agent system and the conﬂicts between

theses arguments are subjective. We have formalized

a multiparty argumentation game, where more than

two agents play and observe moves on a gameboard.

In this dialogue, each agent aims at expanding her ar-

gumentation by taking into account all the available

arguments and the consensual conﬂicts between these

arguments. In our individual-oriented approach, the

building of the consensual expansions emerges from

the interactions between the agents. We demonstrated

the termination and the correctness of our game. The

expansions are consensual if the agents are honest.

Moreover, our model is explanatory since it renders

intelligible the conﬂicts between the agents which ap-

pear during the process.

REFERENCES

Artikis, A., Sergot, M., and Paliouras, G. (2010). A logic

programming approach to activity recognition. In

ACM International Workshop on Events in Multime-

dia, pages 3–8.

Bodenstaff, L., Prakken, H., and Vreeswijk, G. (2006). On

formalising dialogue systems for argumentation in the

event calculus. In Proceedings of the Eleventh In-

ternational Workshop on Nonmonotonic Reasoning,

pages 374–382.

Bonzon, E. and Maudet, N. (2011). On the outcomes of

multiparty persuasion. In Proc. of the 10th Interna-

tional Joint Conference on Autonomous Agents and

Multiagent Systems (AAMAS 2011), pages 47–54.

Coste-Marquis, S., Devred, S., Konieczny, S., Lagasquie-

Schiex, M.-C., and Marquis, P. (2007). On the merg-

ing of Dung’s argumentation systems. Artif. Intell.,

171:730–753.

Dung, P. (1995). On the acceptability of arguments and

its fundamental role in nonmonotonic reasoning, logic

programming and n-person games. Artif. Intell.,

77:321–357.

Kowalski, R. and Sergot, M. (1986). A logic-based calculus

of events. New Gen. Comput., 4(1):67–95.

Prakken, H. (2006). Formal systems for persuasion dia-

logue. The Knowledge Engineering Review, 21:163–

188.

MultipartyArgumentationGameforConsensualExpansion

165