Assumption-Based Argumentation Dialogues

1 Introduction

Argumentation-based agent dialogues have been widely studied, e.g. in [McBurney and Parsons, 2009; Black and Hunter, 2009; Prakken, 2005; 2006], as a framework to support agreement amongst artificially intelligent agents. We present a novel formal model of argumentation-based dialogues between (two) agents, using assumption-based argumentation (ABA) [Bondarenko et al., 1997; Dung et al., 2009]. This is a general-purpose, widely applicable form of argumentation where arguments are built from rules and supported by assumptions, and attacks against arguments are directed at the assumptions supporting the arguments, and are provided by arguments for the contrary of assumptions.

In our dialogue model, agents can utter claims (to be debated), rules, assumptions and contraries. Thus, dialogues "build" an ABA framework shared between the agents.

The model is given in terms of (various kinds of) legalmove functions, to determine which moves agents can make during dialogues, and outcome functions, to determine whether dialogues have been successful. These functions are defined in terms of dialectical trees drawn from the dialogues (and implicitly constructed during them).

To prove soundness of our approach, we connect our dialogue model with the admissibility semantics for ABA, sanctioning a set of assumptions/arguments as admissible iff it does not attack itself and it counter-attacks all attacks against it. In particular, we prove that the claim debated by a successful dialogue is supported by a set of assumptions/argument in an admissible set (and this is the set of assumptions/arguments identified during the dialogue) w.r.t. the shared ABA framework drawn from the dialogue. This result relies upon a correspondence result between dialectical trees and the concrete dispute trees given in [Dung et al., 2006]

to pave the way towards a computational counterpart (in the form of dispute derivations) for the admissibility semantics.

Our dialogue model is generic in that it does not focus on any particular dialogue type, e.g. information seeking, persuasion or negotiation. However, for the sake of illustration, we demonstrate persuasion as an application of our model.

The paper is organised as follows. Section 2 reviews the ABA framework. Section 3 presents the dialogue model. Section 4 introduces dialectical trees. Section 5 gives our main formal results. Section 6 demonstrates a persuasion dialogue. Section 7 discusses related works. Section 8 concludes.

2 Background

An ABA framework [Bondarenko et al., 1997; Dung et al., 2009] is a tuple 〈L,R,A, C〉 where

• 〈L,R〉 is a deductive system, with L the language and R a set of rules of the form s0 ← s1, . . . , sm(m ≥ 0);
• A ⊆ L is a (non-empty) set, referred to as assumptions;
• C is a total mapping from A into L, where C(a) is referred to as the contrary of a.

Given a rule ρ of the form s0←s1, . . ., sm, s0 is referred as the head and s1, . . . ,sm as the body, Head(ρ) = s0 and Body(ρ) = {s1, . . . ,sm}. As in [Dung et al., 2006], we enforce that ABA frameworks are flat, i.e. assumptions do not occur in the head of rules. Also, without loss of generality, we enforce that no two assumptions may have the same contrary.

In ABA, arguments are deductions of claims using rules and supported by sets of assumptions, and attacks are directed at the assumptions in the support of arguments. Informally, following [Dung et al., 2009]:

• an argument for (the claim) c ∈L supported by S ⊆A (S⊢c in short) is a tree with nodes labelled by sentences in L or by τ, 1 the root labelled by c, leaves either τ or assumptions in S, and non-leaves s with as children the elements of the body of some rule with head s;
• an argument S1 ⊢ c1 attacks an argument S2 ⊢ c2 iff c1 is the contrary of one of the assumptions in S2.

Attacks between (sets of) arguments correspond in ABA to attacks between sets of assumptions:

1 τ /∈L represents "true" and stands for the empty body of rules.

• a set of assumptions A attacks a set of assumptions B iff an argument supported by a subset of A attacks an argument supported by a subset of B.

With argument and attack defined, standard argumentation semantics can be applied in ABA [Dung et al., 2009]. We focus on the admissibility semantics, as follows:

• a set of assumptions is admissible iff it does not attack itself and it attacks all sets of assumptions that attack it;
• an argument S ⊢ s belongs to an admissible extension supported by Δ ⊆ A iff S ⊆ Δ and Δ is admissible.

Our main result will be proven using the concrete dispute trees of [Dung et al., 2006], where a concrete dispute tree for a sentence s ∈ L is a (possibly infinite) tree T c such that

1. every node of T c is labelled by a multi-set of sentences in L and is either a proponent node or an opponent node;
2. the root of T c is a proponent node labelled by {s};
3. given a proponent node N labelled by P, if P is empty, then N is a leaf; otherwise, there exists some selected 2 occurrence of a sentence p in P and
4. if p ∈ A, then there is one child of N, which is an opponent node labelled by {C(p)}, and one child of N that is a proponent node labelled by P - {p};
5. If p ̸∈ A, then there is some ρ ∈ R with Body(ρ) = S and there is exactly one child of N, which is a proponent node labelled by P-{p}∪S;
6. given an opponent node N labelled by O, then O̸= {}, there is a selected occurrence of a sentence o in O and
7. (i) if o ∈ A, then (a) either o is ignored and there is exactly one opponent child of N, labelled by O-{o}; (b) or o is chosen as culprit, and there is exactly one proponent child of N, labelled by {C(o)};
8. (ii) If o ̸∈ A and there is no ρ ∈ Rwith Head(ρ) = o, then N is a leaf; else, for every o ← S ∈ R, there is an opponent child of N labelled by O-{o}∪S;
9. there is no infinite sequence of proponent nodes in T c ; there are no nodes in T c except those given by 1-4.

Given a concrete dispute tree T c , the defence set of T c (Def(T c )) is the union of all assumptions in proponent nodes and the culprits of T c (Cul(T c )) are all assumptions chosen as culprits in 4(i)(b). A concrete dispute tree is admissible iff the intersection of its defence set and its culprits is empty. The defence set of an admissible concrete dispute tree T c for a sentence s is admissible and there exists an argument S ⊢ s that belongs to an admissible extension supported by the defence set of T c (corollary 6.1 in [Dung et al., 2006]).

3 Dialogues

We define dialogues as sequences of utterances between two agents a1 and a2 sharing a common language L. Formally:

Definition 1. An utterance from agent ai to agent aj (i, j = 1, 2, i ̸= j) is a tuple 〈ai, aj, InReply, C, ID〉, where:

2 Selections are performed by a given selection function, that picks a sentence in an input multi-set [Dung et al., 2006].

• C (the content) is of one of the following forms: clm(s) for some s ∈ L (a claim), rl(s0←s1,. . . ,sm) for some s0,. . . ,sm∈L (a rule), asm(a) for some a ∈ L (an assumption), ctr(a, s) for some a, s ∈ L (a contrary), a pass sentence π, such that π /∈ L.
• ID ∈ N (the identifier).
• InReply ∈ N ∪ {0} (the target); InReply < ID.

We refer to an utterance with content π (other than π) as a pass-utterance (non-pass-utterance resp.).

Intuitively, a pass indicates that the agent does not have or want to contribute information at that point in the dialogue.

Definition 2. For any two utterances ui ̸= uj , uj is related to ui iff ui = 〈 , , ,Ci, ID〉, uj = 〈 , , ID,Cj, 〉, 3 and one of the following cases holds:

1. Cj = rl(ρj), Head(ρj) = h and either Ci = rl(ρi) with h ∈ Body(ρi), or Ci = ctr( , h), or Ci = clm(h);
2. Cj = asm(a) and either Ci = rl(ρ) with a ∈ Body(ρ), or Ci = ctr( , a), or Ci = clm(a);
3. Cj = ctr(a, ) and Ci = asm(a).

Intuitively, an utterance is related to another if it contributes to expanding an argument (case 1), identifies an assumption in the support of an argument (case 2) or starts the construction of a counter-argument (case 3). Note that an utterance may be related to an utterance from the same agent or not. Also, no pass-utterance can be related to an utterance and no utterance can be related to a pass-utterance.

Definition 3. A dialogue Dai aj (s) (between agents ai and aj , for claim s ∈ L), i, j = 1, 2, i ̸= j, is a finite sequence 〈u1, . . . , un〉, n ≥ 0, where each ul, l = 1, . . . , n, is an utterance from ai when l is odd, and aj when l is even, and:

1. the content of the first utterance, u1, is clm(s); no other utterance has clm( ) as its content;
2. each non-pass-utterance other than the claim utterance is related to its target utterance;
3. the target of pass- and claim utterances is 0;
4. no two consecutive utterances are pass-utterances, other than possibly the last two utterances, un-1 and un.

If the last two utterances are pass-utterances, then Dai aj (s) is referred as complete.

Note that in this definition of dialogue, we implicitly force a strict interleaving between agents.

Below, U and D stand for the sets, resp., of all utterances as in definition 1 and of all dialogues as in definition 3.

By means of dialogues agents exchange information and build a shared framework, as follows:

Definition 4. The framework drawn from a dialogue δ = 〈u1, . . . , un〉 is 〈L,Rδ,Aδ, Cδ〉 where 5

• Rδ = {r|rl(ρ) is the content of some ui in δ};
• Aδ = {a|asm(a) is the content of some ui in δ};
• Cδ is a mapping such that, for any a ∈ Aδ, Cδ(a) = c such that ctr(a, c) is the content of some ui in δ, if one exists, and is undefined otherwise.

The framework drawn from the dialogue in example 3.1 is Fδ = 〈L,Rδ,Aδ, Cδ〉, in which

Note that Fδ in this example is a flat ABA framework, but, in general, the framework drawn from a dialogue may not be an ABA framework, since C may not be total. Even when it is an ABA framework, it may not be flat, as the agents may disagree on the assumptions. Finally, there may be a nondeterministic choice as to what the contrary of an assumption is in Cδ, as the agents may have uttered different contrary utterances for this assumption. In the remainder of this section, we refine our dialogues so that the frameworks drawn from them are flat ABA frameworks and the choice of contrary is deterministic. This refinement builds upon the notion of legal-move function to restrict the kind of utterances allowed in dialogues , similarly to communication protocols.

Definition 5. A legal-move function is a mapping λ : D ↦→ U such that, given δ = Dai aj (s) = 〈u1, . . . , un〉:

where x=i (x=j) when n is even (odd resp.), x ̸= y, and

1. if C ̸= π, then there exists no i, 1 ≤ i ≤ n, such that ui = 〈 , , t,C, i〉;

This definition imposes that there is no repeated utterance to the same target in a dialogue (condition 1), and that assumptions have a single contrary (condition 2). Condition 2 guarantees a deterministic choice of contrary. However, the definition of legal-move function does not impose any "mentalistic" requirement on agents, such as that they utter information they hold true within their ABA framework.

Definition 6. A flat legal-move function is such that if, for n≥0, λ(〈u1, . . . , un〉)=〈ax, ay, t, C,n+1〉, then

• C = asm(a) only if there exists no ui for 1 ≤ i ≤ n with content rl(ρ) and Head(ρ) = a;
• C = rl(ρ) only if there exists no ui for 1 ≤ i ≤ n with content asm(a) and Head(ρ) = a.

Trivially, the framework drawn from a dialogue generated by a flat legal-move function, if an ABA framework, is flat.

5 Here and throughout the paper L is implicit.

Legal-move functions provide some guidance as to what agents should utter during dialogues. In order to guarantee that the contrary mapping in the framework drawn from a dialogue is total, we will use the notion of outcome function, checking specific properties in a generated dialogue:

Definition 7. An outcome function is a mapping ω : D ↦→ {true, false}. The ABA outcome function ωABA is such that, given δ = 〈u1, . . . , un〉 ∈ D, ωABA(δ) = true iff ∀ui = 〈 , , , asm(a), i〉 ∃uj = 〈 , , i, ctr(a, c), j〉, for 1≤i≤j≤n.

We focus on dialogues where each utterance results from applying a flat legal-move function to the dialogue prior to that utterance, and for which ωABA is true. We refer to these dialogues as ABA dialogues. Trivially:

Proposition 1. The framework drawn from an ABA dialogue is a flat ABA framework.

Below we refine the notions of legal-move and outcome functions to guarantee that dialogues compute admissible arguments. These refinements are given using dialectical trees.

4 Dialectical trees

Nodes of dialectical trees are either proponent or opponent nodes, as in the case of concrete dispute trees (see section 2). However, in a dialectical tree, nodes are labelled with pairs of multi-sets of sentences and are associated with an utterance in the dialogue from which the tree is extracted. This extraction ignores the pass-utterances, i.e. a dialectical tree is extracted from the π-pruned sequence obtained from a dialogue, consisting of all non-pass utterances in the dialogue. Note that, since no non-pass utterance has a pass-utterance as its target (see definition 3), the target of every utterance in a π-pruned sequence is guaranteed to be in this sequence.

The label of each node in a dialectical tree represents an argument's claim or support (see definition 10 below). The first component of this label holds sentences (referred to as marked) that have been "declared" as assumptions in some utterance in the dialogue prior to (the utterance corresponding to) that node. The second component holds sentences (referred to as unmarked) that have been introduced in the dialogue but have not yet been "discussed" in any utterance. Formally:

Definition 8. A dialectical tree drawn from a dialogue δ =Dai aj (s) = 〈u1, . . . , un〉 (n ≥ 0) is a tree T (δ) whose nodes are tuples ([Smd, Sumd], L, U) where

• Smd and Sumd are (multi-)sets 6 of sentences in L
• L is either P (proponent) or O (opponent)
• U ∈ N (the u-id)

and T (δ) is T m(δ) in the sequence T 0 (δ), T 1 (δ), . . . , T m(δ) constructed inductively from the π-pruned sequence δ′ = 〈u′1 , . . . , u′m〉 obtained from δ, as follows:

• T 0 (δ) is empty;
• T 1 (δ) consists solely of the root ([{}, {s}], P, 1);

6 Multi-sets are needed to prove Lemma 1, as this relies upon Corollary 6.1 of [Dung et al., 2006] that is proven for multi-sets.

• let T i (δ) be the i-th tree and u′i+1 = 〈 , , t,C, id〉, for 0<i<m; then T i+1 (δ) is T i (δ) with additional nodes ([1Smd,1Sumd], L, id), . . . , ([kSmd,kSumd], L, id)
• children of the existing nodes ([1S∗md ,1S∗umd ], L∗ , U ∗ 1 ), . . . , ([kS∗md ,kS∗umd ], L∗ , U ∗ k ) resp., where k > 0 and U ∗ 1 , . . . ,U ∗ k are such that
• if C=rl(ρ) and there is u′j =〈 , , t, rl(ρ′ ), 〉 (0 < j ≤ i) in δ′ with ρ′ ̸= ρ but Head(ρ)=Head(ρ′ ), then let u′j1 = 〈 , , t, rl(ρ′1 ), jid1〉, . . . , u′jk = 〈 , , t, rl(ρ′k ), jidk〉 be all utterances in δ′ with target t, 0 < jl ≤ i, and ρ′l ̸= ρ but Head(ρ′l ) = Head(ρ), for l = 1, . . . , k; then U ∗ 1 , . . . ,U ∗ k are the u-ids of the parents in T i (δ) of the nodes ([ , ], , jidl), l = 1, . . . , k;
• otherwise, U ∗ 1 , . . . ,U ∗ k are the u-ids of the leaf nodes in T i (δ) which are descendants of nodes of the form ([ , ], , t);

and ([jSmd, jSumd], L, id) (1 ≤ j ≤ k) are such that

• if C = asm(a) then jSmd =j S∗md ∪ {a}, jSumd =j S∗umd \ {a}, L = L∗ ;
• if C = rl(ρ) then jSmd =j S∗md , jSumd = (jS∗umd \ {Head(ρ)}) ∪ {Body(ρ)}, L = L∗ ;

As an example, figure 1 (Left) 7 gives the dialectical tree drawn from the dialogue in example 3.1.

Definition 9. Given a dialectical tree T (δ),

• the defence set Def(T (δ)) is the union of all marked sentences from proponent nodes;
• the culprits Cul(T (δ)) are given by the set of all marked sentences s in opponent nodes N such that the child of N in T (δ) is ([{}, {c}], P, ), and Cδ(s) = c in the ABA framework 〈L, Rδ, Aδ, Cδ〉 drawn from δ.

Arguments (in the ABA framework drawn from a dialogue) can be drawn from a dialectical tree, as follows:

Definition 10. A potential argument drawn from a dialectical tree T (δ) is S⊢S′c such that

• N = ([S, S′ ], L, ) is a node of T (δ),
• N ′ = ([{}, {c}], L, ) is the closest ancestor of N (possible N ′ = N) such that the parent of N ′ has a label L′ different fromL, and
• every child of N has a label different from L

An actual argument drawn from T (δ) is a potential argument S⊢{}c drawn from T (δ).

we obtain the dialectical tree given in figure 1 (Middle). Here, {d}⊢{g}q is a new potential argument that is not an actual argument. Note that nodes may hold empty Smd and Sumd components, as in figure 1.

Some potential arguments correspond to ABA arguments:

Proposition 2. Let 〈L,Rδ,Aδ, Cδ〉 be the ABA framework drawn from an ABA dialogue δ and S⊢S′ c a potential argument drawn from T (δ). If S′ ⊆ Aδ then S ∪ S′ ⊢{} c is an ABA argument w.r.t. 〈L,Rδ,Aδ, Cδ〉.

Thus, actual arguments are necessarily ABA arguments.

We consider now restricted forms of dialectical trees, that we then use below to refine our notion of legal-move function (and to prove Lemma 1).

Definition 11. A dialectical tree T (δ) is

• patient iff for all nodesN = ([ , Sumd], L, ) in T (δ), N has a child N ′ = ([ , ], L′ , ), L′ ̸= L, iff Sumd = {};
• focused iff

1. each proponent node ([Smd, ], P, ) has either no child, or a single proponent child, or one opponent child per assumption in Smd, and

2. each opponent node has either no child, or any number of opponent children, or one single proponent child.

Basically, arguments in a patient tree are fully expanded (cf. actual) before being attacked. The left tree in figure 1 is patient, whereas the middle tree is not (since the opponent node 13 has a proponent child even though its unmarked component is {g}). In focused trees, no alternative ways to support or defend claims are considered simultaneously. Both left and middle tree in figure 1 are focused. The following example gives a non-focused tree.

The resulting dialectical tree, in figure 1 (Right), is not a focused dialectical tree. Indeed, its root has two proponent children. Accordingly, the rightmost, newly added branch considers an alternative defence (given by {d}) to the defence (given by {a, d}) considered in the left-most branch.

The restricted form of legal-move function we consider is guaranteed to generate patient, focused trees, as follows:

Definition 12. A (flat) legal-move function λ : D ↦→ U is a patient and focused legal-move function iff for every dialogue

δ ∈ D such that T (δ) is patient and focused, T (δ′ ) is still patient and focused, where δ′ is the dialogue δ extended with the utterance λ(δ) (represented as δ ◦ λ(δ): if δ = 〈u1, . . . , un〉, then δ′ = δ ◦ λ(δ) = 〈u1, . . . , un, λ(δ)〉).

Thus, when an agent decides what to utter, it needs to keep the current dialectical tree into account and make sure that its new utterance keeps the tree patient and focused. As a result, the dialectical tree can be seen as a commitment store.

Our dialogue model so far does not force agents to say legitimate utterances possible given the dialogue so far, where, for example, in the ABA dialogue δ∗

u∗ = 〈a1, a2, 8, rl(q ←), 9〉 is a possible legitimate utterance, since q ←∈ Rδ due to utterance 7.

Definition 13. The exhaustive outcome function ωex is such that, given δ ∈ D and 〈L,Rδ,Aδ, Cδ〉 the framework drawn from δ, ωex(δ) = true iff ωABA(δ) = true and ∄u′ with content either asm(a), for a ∈ Aδ, or rl(ρ), for ρ ∈ Rδ, or ctr(a, c), for c = Cδ(a), such that δ ◦ u′ is an ABA dialogue.

Thus, ωex(δ∗ )=false and ωex(δ∗◦u∗ )=true. Note that exhaustiveness does not force complete dialogues or that agents contribute to dialogues with relevant information they hold.

We refer to ABA dialogues generated by a patient, focused legal-move function and for which ωex is true as exhaustive.

5 Formal results

In this section we link dialogues and the admissible argumentation semantics. First we refine the outcome function so that if a dialogue has a true outcome then the (fictional) proponent has the last word in the dialogue, namely all leaves in the dialectical tree are proponent nodes or "dead-end" opponent nodes (not corresponding to any actual argument). Formally:

Definition 14. The last word outcome function ωlw is such that, given δ ∈ D, ωlw(δ) = true iff ωex(δ) = true, there is no non-empty proponent leaf and no empty opponent leaf in T (δ), where a node ([S1, S2], , ) is empty iff S1 ∪S2 = {}.

We refer to exhaustive dialogues for which ωlw is true as positive. The dialogue in example 3.1 is positive. Positive dialogues give dialectical trees corresponding to concrete dispute tree with the same defence set and culprits. Formally:

Lemma 1. Given a dialogue δ = Daj ai (s) such that ωlw(δ) = true, there is a concrete dispute tree T c for s, such that Def(T (δ)) = Def(T c ) and Cul(T (δ)) = Cul(T c ).

Proof. (Sketch) 1) Given that n≥1 is the number of nodes in T (δ), we assign a unique number 1 ≤ i ≤ n to each node of T (δ) so that if i<j then Ni is an ancestor of Nj (the root is N1 = ([{}, {s}], P, 1)). We then construct the sequence T ′ 0 ,T ′ 1 ,. . . ,T ′n such that T ′ 0 is empty, T ′ 1 consists solely of the root N ′1 = (P, {s}), and, for 0< i< n, T ′ i+1 is T ′ i with an extra node N ′ i+1 child of the node N ′k corresponding to Nk in T (δ) that is the parent of Ni+1. If Ni+1=([Si+1 md , Si+1 umd ], Li+1 , ), then N ′k =(L′ , S′ ) with L′ = Li+1 and S′=Si+1 md ∪Si+1 umd . 2) We remove all duplicate nodes in T ′n , getting T ′′ . 3) We transform T ′′ so that each proponent node has at most one opponent node as a child, getting T c . 4) We prove that T c is a concrete dispute tree.

As in the case of concrete dispute trees, the defence set of a dialectical tree may not be admissible, as it may attack itself. We refine the notion of outcome function by enforcing that this set does not attack itself, as follows:

Definition 15. The admissible outcome function ωADM is such that, given δ ∈ D, ωADM(δ) = true iff ωlw(δ) = true and Def(T (δ)) ∩ Cul(T (δ)) = {}. If δ is positive and ωADM(δ) = true, we say that δ is successful.

Theorem 1. Given a successful dialogue Daj ai (s) = δ, then there exists an argument S ⊢ s that belongs to an admissible extension supported by Def(T (δ)) w.r.t. the ABA framework drawn from δ.

Proof. If ωADM(δ) = true, by Lemma 1 there exists a concrete dispute tree T c such that Def(T (δ)) = Def(T c ) and Cul(T (δ)) = Cul(T c ). By Corollary 6.1 of [Dung et al., 2006] (see section 2), the theorem holds.

6 Illustration

Two agents, Jenny (J) and Amy (A), are planning a film night together and want to agree on a movie to watch. The agreement can be reached through a dialogue, as follows:

J: Let's see if Terminator is a good movie to watch.

A: OK.

• J: I want a movie that is fun and has a good screening time.

A: OK.

• J: To me, a movie is fun if it is an action movie. A: OK.
• J: And, Terminator is an action movie.

A: OK.

• J: I also believe Terminator starts at the right time.
• A: Are you sure it is not going to be too late? J: Why?
• A: I don't know. I am just afraid so.
• J: It won't be too late if it finishes by 10 o'clock.
• A: I see. Indeed Terminator finishes by 10 o'clock.

J: OK. 8 Conclusion

A: OK.

Here Jenny succeeds in persuading Amy to watch the movie she proposes. Amy had the opportunity to disagree and challenge Jenny, but Jenny managed to produce a compelling argument. This natural language dialogue gives an informal reading of the dialogue in our framework. 8

This dialogue is successful and, by theorem 1, wM(t) belongs to an admissible extension of the drawn ABA framework. This corresponds to Jenny having persuaded Amy, in that no objections have been raised that could not be addressed, and Jenny's view point is non-contradictory.

7 RelatedWork

[McBurney and Parsons, 2009] give an overview of dialogue games for argumentation. Our work can be seen as providing a novel dialogue game for ABA. [Prakken, 2006] reviews dialogue systems for persuasion. Section 6 illustrates how our model can be used for persuasion. However, it can also be used for other kinds of dialogues, e.g. information-seeking.

[Parsons et al., 2007] examine three notions of relevance in dialogues where utterances are arguments and attacks. Our utterances are at at a finer granularity level, as they correspond to rules etc. Thus, there is no direct mapping between our work and their relevance.

[Black and Hunter, 2009] present a formal system for inquiry dialogues based on DeLP as the underlying argumentation framework. Our work differs from theirs as (1) it does not focus on inquiry dialogues; (2) it uses ABA; (3) it does not force full disclosure of all relevant knowledge as they do.

[Prakken, 2005] defines a formal system for persuasion. The main differences with our work are: (1) proponent and opponent roles are pre-assigned to agents before the dialogue whereas in our work agents can play both roles within the same dialogue; (2) he considers the grounded semantics, whereas we use admissibility; (3) his set of utterances refer to arguments and attacks, as in the case of [Parsons et al., 2007]; (4) he forces the support of arguments to be minimal, whereas we do not, in the spirit of [Dung et al., 2010]; (5) he does not impose a strict interleaving, whereas we do, similarly to [Black and Hunter, 2009]. (6) he does not allow agents to jointly construct arguments whereas we do.

8wM stands for watchMovie, t for Terminator, sT for screenTime, f for fun, aM for actionMovie, fT for finishbyTen.

We presented a formal dialogue model for assumption-based argumentation (ABA). The model is not tailored to any dialogue type. We chose to illustrate the model with a persuasion dialogue. We proved that our model is sound by connecting it with the admissibility argumentation semantics for ABA. Thus, our dialogues can be seen as a distributed mechanism for computing admissible extensions (supporting claims).

We have assumed that agents exchange their views in ABA-format, namely ABA serves as a standard for the exchange of information between agents. However, agents may adopt an internal representation different fromABA.

Future work includes further investigating properties of model, including soundness w.r.t. other argumentation semantics, as well as completeness. We are also interested in extending the model to allow for a more flexible turn-making than strict interleaving, to support conversations amongst more than two agents, and to refine the model as to prevent undesirable strategic behavior of agents, e.g. along the lines of [Rahwan et al., 2009]. Finally, we plan to develop applications of our model for the various kinds of dialogue types, e.g. inquiry, information-seeking and negotiation.