Opponent Models with Uncertainty for Strategic Argumentation

1 Introduction

Argumentation systems offer a natural, easily understood representation of non-monotonic reasoning, and have been applied to a variety of problem domains including planning and practical reasoning [Toniolo et al., 2011] and legal reasoning [Grabmair and Ashley, 2010]. Critically, many of these domains are adversarial, requiring an agent to identify and advance some set of arguments which are most likely to enable it to achieve its goals. In order to do so, the agent employs a strategy, typically in the form of a heuristic, which selects appropriate arguments given some contextual knowledge.

We describe one such strategy, and examine some of its properties. Our strategy assumes that an agent is not only aware of the arguments that it is permitted to advance, as well as what has already been stated, but that it also has a belief regarding its opponent's knowledge, and that this relationship is recursive unto some depth (i. e. an agent a believes some arguments, and believes that b knows some arguments, as well as believing that b believes that a knows some arguments, and so on). While [Oren and Norman, 2009] have previously examined such a strategy, we extend and improve their work along several dimensions.

First, [Oren and Norman, 2009] assume that an agent holds only a single opponent model. However, uncertainty plays a crucial role in strategies, and we capture this uncertainty, associating different opponent models with different likelihoods. Second, agents are often unaware of all arguments in a domain, and we allow an agent to hold an opponent model containing arguments it itself is not aware of through the introduction of virtual arguments. Finally, we consider how an agent should update its knowledge and beliefs while taking part in a dialogue.

In [Prakken and Sartor, 2002] an influential four layered view of an argumentation system is described. The first two levels, consisting of the logical and dialectic layers, specify the content of an argument, and how arguments interact with each other. In our work, these layers are encapsulated within an abstract argumentation framework [Dung, 1995], which we summarise in Sec. 2. We encapsulate Prakken's procedural layer, which specifies how agents exchange arguments (via dialogue) via a general discourse model. This discourse model, described in Sec. 3, assumes only that agents take alternating turns in making moves, and further constrains the dialogue by limiting what moves can be made through a legal moves function. Section 4 then describes the agent model, associating a utility with specific arguments, and allowing for different types of belief states. This agent model captures Prakken's heuristic layer through the specification of agent strategy. We present three instances of the agent model, starting from the one described in [Oren and Norman, 2009], and repeatedly adding further layers of expressivity. Section 5 describes how an agent's beliefs should be updated as the dialogue progresses, following which we compare and empirically evaluate the different models in Sec. 6. Section 7 discusses related work, and we conclude in Sec. 8.

2 Formal preliminaries

In abstract argumentation theory, knowledge is represented by an abstract argumentation framework (or AF, in short), which is a set of arguments with an attack relation, cf. [Dung, 1995].

Definition 1 An AF is a pair (A,R) where A is the set of arguments and R ⊆ A × A is the attack relation.

The goal is to select sets of arguments, called extensions, that represent rational points of view on the acceptability of the arguments of the AF. The first condition for an extension to be rational is that it is conflict-free. Furthermore, if an argument is a member of an extension, it is assumed that it is defended by the extension. Formally:

Definition 2 Given an AF F = (A, R), an extension is a set E ⊆ A. E is said to be conflict-free iff ∄x, y ∈ E, (x, y) ∈ R. Given an argument x ∈ A, E is said to defend x iff ∀y ∈ A s.t. (y, x) ∈ R, ∃z ∈ E s.t. (z, y) ∈ R. We define D(A,R)(E) by D(A,R)(E) = {x ∈ A | E defends x}.

Using the notions of conflict-freeness and defense, we can define a number of argumentation semantics, each embodying a particular rationality criterion.

Definition 3 Let F = (A,R) be and E ⊆ A conflict-free extension. E qualifies as:

• complete iff E = D(A,R)(E),
• admissible iff E ⊆ D(A,R)(E),
• grounded iff E is minimal (w.r.t. set inclusion) among the set of complete extensions of F .

For the intuition behind the different semantics we refer the reader to [Dung, 1995].

3 The Discourse Model

The discourse model provides a way to specify the complete setting in which two agents (proponent P and opponent O) engage in a certain type of dialogue. Recalling the fourlayered model mentioned in the introduction, we first need a logical and dialectical layer. Here we use abstract argumentation theory, as presented in the previous section, and leave the logical content of arguments unspecified. We assume that there is a universal AF (A,R) which contains all arguments relevant to a particular discourse.

An agent Ag ∈ {P,O} has limited knowledge and is aware only of some subset BAg ⊆ A of arguments which she can put forward in a dialogue. We assume that the attack relation is determined by the arguments, so that the knowledge of an agent can be identified with the set BAg, inducing an AF (BAg, R∩(BAg×BAg)). In the remaining definitions, we assume (A,R) to be given.

Definition 4 (Dialogue trace) A dialogue trace is a finite sequence π = (M1, . . . ,Mn) s.t. M1, . . . ,Mn ⊆ A. Every Mi is called a move. We define Aπ = M1 ∪ . . . ∪Mn and

Next, we need to fill in the procedural layer. The main object with which we are concerned here is a dialogue trace, which represents a dialogue between P and O by a sequence of moves (i. e. sets of arguments M ⊆ A) made by P and O alternately, with P making the first move. Formally:

nπ = |M1|+...+|Mn|. π[n] denotes the dialogue trace consisting of the first n moves of π; π[0] is the empty sequence. The set of all possible dialogue traces is denoted by S.

The rules of the dialogue are captured by the legal move function legalmoves : S → 22A which returns valid followup moves for a particular dialogue trace. The heuristic, or strategic component is captured by an agent model, one for P and one for O.

Definition 5 (Agent model) An abstract agent model ∆ is a triple ∆ = (K, move, upd) where K is the belief state; move is a function mapping a dialogue trace and belief state to a set of moves, called the move function; and upd is a function mapping a belief state and a move to a new belief state, called the update function.

A belief state K captures the agent's knowledge, utility function and opponent model. The function move returns the set of moves for the agent, given her belief state and current dialogue trace and implements the agent's strategy. We assume that an agent's move function returns only legal moves. Note that an agent may be indifferent as to which move is best and can also decide to end the dialogue, i. e., move may return multiple or zero moves. Finally, the function upd takes a belief state K and the move made by the opponent and yields a new belief state K′ , the idea being that moves made by the opponent may change the agent's knowledge and beliefs.

Definition 6 A dialogue state is a pair (∆P,∆O) where ∆P,∆O are a proponent's and opponent's agent model. A dialogue trace π = (M1, . . . ,Mn) is called valid wrt. a legal move function legalmoves and a dialogue state (∆P,∆O) if and only if there exists a sequence of dialogue states ((∆0P ,∆0O ), . . . , (∆nP ,∆nO )) with ∆iAg = (KiAg , updAg,moveAg) such that ∆0P = ∆P, ∆0O = ∆O and, for i = 1, . . . , n:

1. Mi ∈ moveO(π[i -1],Ki-1 O ) if i is even,
2. Mi ∈ moveP(π[i -1],Ki-1 P ) if i is odd,
3. KiAg = upd(Ki-1 Ag ,Mi) for Ag ∈ {P,O}.

Note that, because the move function may return more than one move, there may be more than one valid and complete dialogue trace for a given pair of initial agent models. Our discourse model is thus nondeterministic with respect to how a dialogue evolves.

No moves can be added to a dialogue trace if an agent decides to end the dialogue. A dialogue trace is then complete: Definition 7 Let π = (M1, . . . ,Mn) be a valid dialogue trace with respect to a legal move function legalmoves and a dialogue state (∆P,∆O). We say π is complete if and only if there is no dialogue trace π′ = (M1, . . . ,Mn,Mn+1) which is valid with respect to legalmoves and (∆P,∆O).

In the following sections we present concrete instantiations of agent models. We demonstrate these models by fixing (A,R), specifying legalmoves, and showing the resulting valid dialogue traces.

4 Agent models for strategic argumentation

In this section we present three concrete instantiations of agent models. We focus here on the belief state K and move function. Each model extends the expressivity of the former. We show, by example, that these extensions are necessary to properly model strategically important beliefs of an agent. In each of the three agent models, the move function is based on a variant of the M* search algorithm [Carmel and Markovitch, 1996]. We postpone the treatment of the third component of an agent model (K,move, upd), namely the update function upd, returning to it in Section 5.

4.1 The simple agent model

The simple belief state of an agent (denoted by Ks) consists, first, of a set B ⊆ A containing the arguments that the agent is aware of. The goals of the agent are encoded by the utility function u, that returns the utility (a real number) that the agent assigns to a particular dialogue trace π ∈ S (cf. [Thimm and Garcia, 2010]). The agent's beliefs about the knowledge and goals of her opponent and about the beliefs about her opponent's belief about herself, etc., are modeled by simply nesting this structure, so that the third component of the simple belief state is again a simple belief state.

Definition 8 A simple belief state Ks is a tuple (B, u,E) where:

• u : S →R is the utility function,
• B ⊆ A is the set of arguments the agent is aware of,
• E = (B′ , u′ ,E′ ) is a simple belief state called the opponent state, such that B′ ⊆ B.

The intuition behind B′ ⊆ B in the above stems from the common sense notion that an agent cannot have beliefs about whether or not her opponent is aware of an argument that she herself is not aware of. In other words, If an agent believes that her opponent knows argument a, then surely the agent herself also knows a. We refer to this requirement as the awareness restriction.

Except for this restriction, this model is the same as the one presented by Oren and Norman [Oren and Norman, 2009]. They also present a variation of the maxmin algorithm (which is in turn a variation of the M* algorithm [Carmel and Markovitch, 1996]) that determines, given a belief state Ks and legalmoves function, the moves that yield the best expected outcome. We can use the same approach to define our moves function. The algorithm that defines the moves function is shown in Algorithm 1. Note that the actual algorithm only needs to return the set of best moves. To simplify the algorithm, however, we define it to return both the set of best moves and the expected utility of these moves.

The algorithm works as follows. Initially the bestMoves is empty and maxEU, acting as a lower bound on the expected utility to be improved upon, is set to the utility of the current trace. For every legal move M the set of best responses of the opponent is determined on line 5. Then, in lines 6 and 7 the expected utility of M is determined by again calling the move function. On line 8 we divide the expected utility of M by the number of opponent moves, taking into account all possible equally good moves the opponent can make without double counting. Lines 9-13 keep track of the moves, considered so far, that yield maximum expected utility. Note that, if bestMoves is empty at the end, not moving yields highest expected utility.

Algorithm 1 moves(π, (B, u, E))

1: maxEU=u(π) 2: bestMoves=∅ 3: for all M ∈ legalmoves(π) do 4: eu = 0 5: (oUtil , oMoves) = moves((π, M), E) 6: for all M ′ ∈ oMoves do 7: (nUtil , nMoves) = moves((π, M, M ′ ), (B, u, E)) 8: eu = eu +nUtil ∗ 1 |oMoves | 9: if eu > maxEU then 10: bestMoves = ∅ 11: if eu ≥ maxEU then 12: bestMoves = bestMoves ∪ {M} 13: maxEU = eu 14: return (maxEU, bestMoves)

Note that we assume that the nesting of the belief state is sufficiently deep to run the algorithm. Alternatively, the algorithm can easily be adapted (as shown in [Oren and Norman, 2009]) to deal with belief states of insufficient depth, or to terminate at some fixed search depth.

In the rest of this text, we use a utility function to the effect that the dialogue is about grounded acceptance of an argument x ∈ A. This has been called a grounded game in the literature [Modgil and Caminada, 2009]. We subtract arbitrary small values ϵ, for each move in the dialogue, capturing the idea that shorter traces are preferred, effectively driving the agents to put forward only relevant moves. Formally:

Definition 9 (Grounded game utility function) Let x ∈ A and Ag ∈ {P,O}. The grounded game utility function, denoted by u(x,Ag) g , evaluated over a dialogue trace π, is defined by:

Following [Modgil and Caminada, 2009], we may refer to x as in if it is within the (uniquely determined) grounded extension, out if it is attacked by an element from this extension, and undecided otherwise.

For simplicity, we assume that utility functions are fixed in all models, i. e., both agents have correct beliefs about the opponent's utility function. Furthermore, the legalmoves function that we use simply forces moves to consist of a single argument, and is defined by legalmoves1(π) = {{x} | x ∈ A}.

Example 1 Let (A,R), and E, F,G be the AF and belief states as shown in Figure 1. That is, E = (B, u(a,P ) g , F), F = (B′ ,-u(a,O) g ,G),G = (B′ , u(a,P) g , F) with B = {a, b, c, d, e} and B′ = {a, b, c, d}. We define the agent models Γ = (∆P,∆O) by ∆P = (E,moves, upd) and ∆O = (F,moves, upd), where upd is defined by upd(K,M) = K. In words, P is aware of all arguments and (correctly) believes that O is aware of only a, b, c and d. There is a single valid dialogue trace w.r.t. Γ, namely

({a}, {b}, {e}). The first move is obvious, i. e., if P would not put forward the argument a under consideration, she loses because the opponent can end the dialogue. The second move b is made because O (not being aware of e) believes she can counter the only possible countermove after b (i. e., c) by d, resulting in a win. As it turns out, P's quickest way to win is by moving e and not c. This ends the dialogue, as O cannot increase utility by putting forward any remaining argument. The utilities of the trace are 1 - 3ϵ for P and -1 - 3ϵ for O.

4.2 The uncertain agent model

A limitation of the simple agent model is that it assumes certainty about the opponent model. In the uncertain agent model, denoted Ku, we capture uncertainty by assigning (non-zero) probabilities to possible opponent modes:

Definition 10 An uncertain belief state Ku is a tuple (B, u, E , P ) where:

• u : S →R is the utility function,
• B ⊆ A is the set of arguments,
• E is a set of uncertain belief states (opponent belief states) such that ∀(B′ , u′ , E ′ , P ′ ) ∈ E: B′ ⊆ B,
• P : E → (0, 1] is a probability function s.t. ∑E∈E E = 1.

The corresponding moveu function, defined by algorithm 2, is a straightforward generalization of moves, taking into account probabilities of possible opponent models.

Algorithm 2 moveu(π, (B, u, E , P )) 1: maxEU = u(π) 2: bestMoves = ∅ 3: for all M ∈ legalmoves(π) do 4: eu = 0 5: for all E ∈ E do 6: (oUtil , oMoves) = (moveu((π, M), E)) 7: for all M ′ ∈ oMoves do 8: (nUtil , nMoves ) = moveu((π, M, M ′ ), (B, u, E , P )) 9: eu = eu +nUtil ∗ P(E′ ) ∗ 1 |oMoves | 10: if eu > maxEU then 11: bestMoves = ∅ 12: if eu ≥ maxEU then 13: bestMoves = bestMoves ∪ {M} 14: maxEU = eu 15: return (maxEU, bestMoves)

Example 2 Let (A,R),E, F1, F2,G1 and G2 be the AF and belief states as shown in Figure 2. We define the agent models ∆P by ∆P = (E,moveu, upd) and ∆O = (F1, moveu, upd), where upd is defined by upd(K, M) = K. In words, P is aware of all arguments and correctly believes O to be aware of c, d, but is uncertain about whether O knows a (p = 0.3) or b (p = 0.7). O in fact is aware of a and not of b. There is a single valid dialogue trace w.r.t. Γ, namely ({d}, {c}, {b}, {a}). Again, P first moves the argument d under consideration. O, believing that P does not know a, replies with c, believing this will be successful. Now, P has to choose between putting forward a or b. Putting forward a while O knows b (which O believes to be more likely) will make d undecided. Thus O puts forward b. It turns out that O was in fact aware of a, and thus puts this argument forward, changing the status of d from out to undecided. The result is a 'tie-break', i. e., both P and O assign a utility of 0 +/- 4ϵ to the trace in which d is neither accepted nor rejected.

4.3 The extended agent model

The two models presented so far assume that an agent cannot have beliefs about whether or not her opponent is aware of an argument that she herself is not aware of. While this is a natural assumption, it limits the kind of situations we can model. An agent can still believe that her opponent knows some argument, even if she is not aware of this argument herself. We model such arguments as virtual arguments. These are believed to exist but cannot put it forward in a dialogue. For example, if one is engaged in a dialogue with a physicist about the speed of light one may assume that the physicist has an argument for the speed of light being larger than 50kph. However, if one is not expert in physics, the exact nature of this argument might be unknown. Furthermore, we assume that if new argument is put forward, an agent knows whether or not this argument corresponds to a virtual argument she believed to exist. That is, she can recognize a new argument, and map it to a virtual argument. To model this, we add a set G of virtual arguments (such that G ∩ A = ∅), an attack relation R between virtual arguments and regular arguments, and a recognition function rec to the belief state. Formally:

Definition 11 Given a set of virtual arguments G, an extended belief state Ke is a tuple (B, u,G,R, rec, E, P) where:

• B ⊆ A is the set of arguments,

• u : S →R is the utility function,
• R ⊆ G×A∪A×G∪G×G is the attack relation,
• G ⊆ G is the set of virtual arguments believed to exist,
• rec : A→ 2G is the recognition function,
• P : E → (0, 1] is a probability function s.t. ∑E∈E = 1.
• E is a set of extended belief states, called opponent belief states, s.t. ∀(B′ , u′ , G′ , R′ , rec, E ′ , P ′ ) ∈ E: B′ ⊆ B,

Except for the added items, extended and uncertain belief states are similar and the movee function is, except for having differently typed parameters, is identical to moveu.

Example 3 Let (A,R),E, F1 and F2 be the AF and belief states shown in Figure 3. We define the agent models ∆P by ∆P = (E,movee, upd), where upd is defined by upd(K,M) = K. In words, P is aware of b, d, e and f and believes O is also aware of these arguments. In addition, P believes O may have counterarguments to b and d, with probability 0.3 and 0.7 respectively. In the belief state of P, not being aware of b and d, they are modeled as virtual arguments, i. e., x and y mapping to a and b respectively.

A possible dialogue trace is ({f}, {e}, {b}). Here, P puts forward f and O counters with e, believing this may be successful. For P, the choice of whether to put forward b or d depends on her beliefs about (virtual) counterarguments. P believes it more likely (with p = 0.7) that O can counter d and therefore b is P's best move.

5 Updating Opponent Models

When an opponent puts forward a move, an opponent model needs to be updated to take into account the knowledge conveyed by this move. We propose a number of upd functions to model such updates. (Again, we assume that utility functions are fixed and therefore do not change.)

Definition 12 Let Ks = (B, u,E) be a simple belief state and M ⊆ A a move. The simple update function upds is defined by upds(Ks, M) = (B ∪ M, u, upds(E, M)).

Note that, if Ks satisfies the awareness restriction then upds(Ks,M) does, too.

Definition 13 Let Ku = (B, u, E, P) be an uncertain belief state and M ⊆ A a move. The uncertain update function updu is defined by updu(Ku, M) = (B∪M, u, E ′ , P ′ ) where

In the above definition o we assume that arguments are observed independently of one another and, thus, probabilities stay robust in the light of observing unexpected moves. However, consider what occurs if the proponent believes that the opponent is aware of only of b with p = 0.3 and only of c with p = 0.7 how should those probabilities be adjusted when the opponent moves with argument a?

The problem is that this observation is inconsistent with the two opponent models considered possible. two ways exist to deal with this. First, we could switch to a uniform distribution, e. g. giving both states a probability of 0.5. Second, we could assume that the observations of arguments are probabilistically independent events. Taking the latter approach, we then add the observed move to every opponent model considered possible before, cf. Equation (1). Furthermore, some opponent models may collapse into one, so that we have to sum up probabilities for such states, cf. Equation (2).

Definition 14 Let Ke = (B, u,G,R, rec, E, P) be an extended belief state and M ⊆ A a move. The extended update function upde is defined via upde(Ke,M) = (B ∪ M, u, G′ , R′ , rec, E ′ , P ′ ) where

The following proposition establishes a strict hierarchy of our three models w.r.t. expressivity. For example, our approaches for strategic argument selection and update coincide when restricting to less expressive models. For that, we say that a simple belief state E = (A, u, ˆE) and an uncertain belief state E′ = (A′ , u′ , E, P) are equivalent, denoted E ∼ E′ , if A = A′ , u = u′ , E = { ˆE′}, P( ˆE′ ) = 1, and ˆE′ ∼ ˆE recursively. In other words, E ∼ E′ if E′ does not provide any information beyond E. Similarly, we define equivalence to an extended belief state E′′ if E′′ adds no virtual arguments.

Proposition 1 1. If E = (A, u,E) is a simple belief state

then (a) E′ = (A, u, E, P) with E = {E} and P(E) = 1 is

P(E) = 1 is an extended belief state and moves(π, E) = movee(π, E′ ) for every π upds(E, M) ∼ upde(E′ , M) for every M 2. If E = (A, u, E, P) is an uncertain belief state then E′ = (A, u,G,R, rec, E, P) with G = R = ∅ and rec(a) = ∅ for every a ∈ A is an extended belief state and moveu(π, E) = movee(π, E′ ) for every π updu(E, M) ∼ upde(E′ , M) for every M

Proofs are omitted due to space restrictions.

6 Implementation and Evaluation

We implemented the three different opponent models using Java in the Tweety library for artificial intelligence 1 . Our AF allows for the automatic generation of random abstract argumentation theories and simulates a dialogue between multiple agents. We used this AF to conduct experiments with our models and to evaluate their effectiveness in practice.

For evaluating performance we generated a random abstract argumentation theory with 10 arguments, ensuring that the argument under consideration is in its grounded extension, i. e. under perfect information the proponent should win the dialogue. However, from these 10 arguments only 50% are known by the proponent but 90% by the opponent. We used a proponent without opponent model and generated an extended belief state for the opponent (with maximum recursion depth 3). From this extended belief state we derived an uncertain belief state by simply removing the virtual arguments. From this uncertain belief state we derived a simple belief state by sampling a nested opponent model from the probability function in the uncertain belief state. For each

belief state we simulated a dialogue against the same opponent and counted the number of wins. We repeated the experiment 5000 times, with Figure 4 showing our results. As seen, increasing the complexity of the belief state yields better overall performance. In particular, note that the difference between the performances of the simple and uncertain belief states is larger than between uncertain and extended belief states. However, this observation is highly depended on the actual number of virtual arguments used (which was around 30 % of all arguments in this experiment) and is different for larger values (due to space restrictions we do not report on the results of those experiments).

7 RelatedWork

Recently, interest has arisen in combining probability with argumentation. [Hunter, 2012] describes two systems which concern themselves with the likelihood that an agent knows a specific argument, and we can view the possible argument AFs that can be induced from these likelihoods as possible models of agent knowledge. [Thimm, 2012] investigates probabilistic interpretations of abstract argumentation and relationships to approaches for probabilistic reasoning. Furthermore, [Oren et al., 2012] investigated strategies in such

1 http://tinyurl.com/tweety-opp

6 Implementation and Evaluation We implemented the three different opponent models using a probabilistic setting but concerned themselves with monologues rather than dialogues.

Java in the Tweety library for artificial intelligence 1 . Our AF allows for the automatic generation of random abstract argumentation theories and simulates a dialogue between multiple agents. We used this AF to conduct experiments with our models and to evaluate their effectiveness in practice. For evaluating performance we generated a random abstract argumentation theory with 10 arguments, ensuring that the argument under consideration is in its grounded extension, i. e. under perfect information the proponent should win the dialogue. However, from these 10 arguments only 50% are known by the proponent but 90% by the opponent. We used a proponent without opponent model and generated an Our work concerns itself with identifying the arguments an agent should advance at any point in a dialogue. Other work in this vein includes [Oren et al., 2006], which aims to minimise the cost of moves, with no concern to the opponent's knowledge, and without looking more than one step ahead when reasoning. Such a strategy can easily be encoded by our approach. By assigning probabilities to arguments, [Roth et al., 2007] constructed a game tree allowing dialogue participants to maximise the likelihood of some argument being accepted or rejected. The probabilities in that system arose from a priori knowledge, and no consideration was given to the possibility of an opponent model.

extended belief state for the opponent (with maximum recursion depth 3). From this extended belief state we derived an uncertain belief state by simply removing the virtual arguments. From this uncertain belief state we derived a simple belief state by sampling a nested opponent model from the probability function in the uncertain belief state. For each belief state we simulated a dialogue against the same opponent and counted the number of wins. We repeated the experiment 5000 times, with Figure 4 showing our results. As seen, increasing the complexity of the belief state yields bet[Rahwan and Larson, 2008; Rahwan et al., 2009] consider a very different aspect of strategy, attempting to identify situations which are strategy-proof, that is, when full revelation of arguments is the best course of action to follow. Similarly, [Thimm and Garcia, 2010] extends that work to structured AFs and also proposes some simple dominant strategies for other specific situations. This can be contrasted with our work, where e. g. withholding information can result in a better outcome for the agent than revealing all its arguments.

ter overall performance. In particular, note that the difference

between the performances of the simple and uncertain belief 8 Conclusions and FutureWork

states is larger than between uncertain and extended belief states. However, this observation is highly depended on the actual number of virtual arguments used (which was around 30 % of all arguments in this experiment) and is different for larger values (due to space restrictions we do not report on the results of those experiments). 7 RelatedWork Recently, interest has arisen in combining probability with argumentation. [6] describes two systems which concern themWe proposed three structures for modeling an opponents belief in strategic argumentation. Our simple model uses a recursive structure to hold the beliefs an agent has on the other agent's beliefs. We extended this model to incorporate quantitative uncertainty on the actual opponent model and qualitative uncertainty on the set of believed arguments. All our models have been implemented and we tested their performance in a series of experiments. As expected, increasing the complexity of the opponent modelling structure resulted in improved outcomes for the agent.

1 http://tinyurl.com/tweety-opp We consider several avenues of future work. First, agents using our strategies attempt to maximise their outcome, with selves wit ment, and induced f knowledg abstract a probabili gies in su with mon Our wo agent sho in this ve of moves, without l Such a st assigning tree allow of some a ties in tha sideration

[12; 1

tempting

is, when

action to

tured AF

gies for o

our work,

better out

8 Con

We propo

lief in str

cursive st

agent's b

titative u

tative unc

models h

mance in

the comp

in improv

We co

using our

no consi

cater for

ties into

virtual ar

no attack

while it i

tained fro

proach ov

ity of pre

lighted th

is used. S

to this do

rithms to

mentatio no consideration for risk. We seek to extend our work to cater for this notion by introducing second order probabilities into our system. We also intend to investigate whether virtual arguments are equivalent to a simpler system wherein no attacks between virtual arguments can exist. Furthermore, while it is difficult to obtain large scale argument graphs obtained from real world domains, we hope to validate our approach over such corpora. Finally, while our results (for clarity of presentation) focus on abstract argument, [Hadjinikolis et al., 2012] has highlighted the need for strategies when structured argumentation is used. Since the work presented here can easily be extended to this domain, we are in the process of adapting our algorithms to deal with dialogues built on top of structured argumentation.