24 1541-1672/07/$25.00 2007 IEEE IEEE INTELLIGENT SYSTEMS
Published by the IEEE Computer Society
Argumentation Technology
Computing Arguments
and Attacks
in Assumption-Based
Argumentation
Dorian Gaertner and Francesca Toni, Imperial College London
M
ost computational frameworks for argumentation are based on abstract argu-
mentation, which determines an argument’s acceptability on the basis of its
ability to counterattack all arguments attacking it.
1
However, this view of argumenta-
tion doesn’t address how to find arguments, identify attacks, and exploit premises
shared by different arguments.
Assumption-based argumentation addresses these
three issues.
2–4
It’s a refinement of abstract argu-
mentation but remains general purpose, nonetheless.
Rather than considering arguments to be a primitive
concept, assumption-based argumentation defines
them as backward deductions (using sets of rules in
an underlying logic) supported by sets of assump-
tions. This approach reduces the notion of an attack
against an argument to that of deduction of a con-
trary of an assumption. (We describe assumptions
and contraries in more detail later.)
Computational models for assumption-based argu-
mentation
3,4
let us determine the acceptability of claims
by building and exploring a dialectical structure of
•a proponent’s arguments in favor of the claims,
• an opponent’s counterarguments against these
arguments,
• the proponent’s arguments against the counter-
arguments,
and so on. In more detail, the opponent disputes the
proponent’s arguments by attacking any of the sup-
porting assumptions of an argument. In turn, the pro-
ponent defends its arguments by defeating the oppo-
nent’s counterarguments by means of further argu-
ments, possibly with the aid of defending assump-
tions. This computation style has several advantages
over other computational mechanisms for argumen-
tation, owing mostly to the low-level granularity
afforded by
• interleaving the construction of arguments and the
identification of their supporting assumptions and
• exploring the dialectical structure of arguments
and counterarguments.
In particular, it avoids recomputation by filtering out
assumptions that have already been defended or
defeated.
However, this computation style obscures the dialec-
tical structure of proponent-opponent arguments and
counterarguments. For example, a proponent and
opponent can attack one another before arguments are
fully built, by starting to build an argument for the con-
trary of any assumption identified in a partially con-
structed argument by the other player. Also, a propo-
nent’s arguments are all “mixed” within a single set,
in the sense that this set holds assumptions supporting
This computational
framework renders
explicit arguments
and attacks while
reducing the problem
of computing
arguments for and
against claims to the
problem of computing
assumptions.

all the proponent’s arguments. Moreover, the
link between assumptions and the conclusions
they support (and thus the argument they form)
is lost in the computation. Finally, an oppo-
nent’s arguments might be only partially con-
structed at the end of the computation, because
they might have been defeated (and thus dis-
carded) as soon as a “culprit” assumption was
identified in them that the proponent could
defeat.
We’ve developed and implemented an argu-
mentation system combining the virtues of
assumption-based argumentation and abstract
argumentation and avoiding the problems
mentioned earlier. As in assumption-based
argumentation, we manipulate assumptions
and employ filtering to promote efficiency.
As in abstract argumentation, we compute,
for any given claim, the dialectical structure
of arguments and counterarguments lead-
ing to the claim’s acceptability. This system
extends our earlier CaSAPI (Credulous and
Skeptical Argumentation: Prolog Imple-
mentation) system.
5
The original CaSAPI
only lets us manipulate assumptions. How-
ever, it lets us compute notions of accept-
ability ranging from the credulous notion of
admissibility considered in this article
(details appear later) to “skeptical” notions,
disregarding conflicting alternatives to a
greater or lesser extent.
Assumption-based
argumentation
Assumption-based argumentation frame-
works are tuples L, R, A,
—
, where
•(L, R) is a deductive system with a lan-
guage L and a set of rules R,
• A  L is a nonempty set of assumptions,
and
•
—
is a total mapping from A to the power
set (L)  {{}}, where, for any   A,
is the nonempty set of contraries of .
(In the original framework,
—
is a total map-
ping from A into L; each assumption has a
single contrary.
2,3
The extension we adopt
here is useful, for example, to support deci-
sion making in agents.
5,6
)
Rules can be domain specific or domain
independent.
2
They can correspond to causal
information, argument schemes,
7
inference
rules and axioms in a chosen logic-based lan-
guage,
2
or laws and regulations.
8
Assump-
tions are sentences that can be questioned
and disputed (as opposed to axioms, which
are beyond dispute)—for example, uncertain
beliefs (“it will rain”), unsupported beliefs
(“I believe X”), or decisions (“law such-and-
such applies” or “perform action A”). A con-
trary, in general, is a reason the assumption
might be undermined and thus might need to
be dropped. For example, a contrary of the
assumption “it will rain” might be “it will be
sunny” and “it will snow,” or “¬ it will rain,”
depending on the underlying L (¬ is the
negation symbol). A contrary of the assump-
tion “law such-and-such applies” might be
“law such-and-such is overruled by another
law taking precedence.” A contrary of the
assumption “perform action A” might be
“perform action B” and “perform action C,”
where A, B, and C are mutually exclusive.
Finally, a contrary of the assumption “I
believe X” might be “X is not the case” or
“there is evidence against X.”
The mapping
—
need not be symmetric.
For example, “X is not the case” might be
a contrary of the assumption “I believe X,”
but the latter might not be an assumption.
Moreover, an agent’s preference for action
B over action A might force the assumption
“perform action B” to be a contrary of the
assumption “perform action A,” but not the
other way around.
We assume that the rules in R have the syn-
tax c
0
 c
1
,…,c
n
with n > 0 or c
0
, where c
i

L for i = 0, …, n. The left part, c
0
, is the rule’s
head; c
1
,…,c
n
(if present) is its body. We con-
sider the body of a rule c
0
to be empty; in this
case, we often refer to c
0
as a fact. For brevity
of presentation, we focus here on abstract,
symbolic examples. We restrict our attention
to flat assumption-based frameworks,
3,4
such
that if c  A, no rule in R has head c. These
frameworks are still quite general.
2
Example 1 shows a simple assumption-
based framework:
EXAMPLE 1. L = {p, a,¬a, b,¬b}, R = {p 
a; ¬a  b; ¬b  a}, A = {a, b}, and =
{¬a}, = {¬b}.
The choice of all elements of an assump-
tion-based framework depends on an appli-
cation’s knowledge-representation needs. For
instance, in example 1, we could have L also
include ¬p and have A not include a. In gen-
eral, if ¬ occurs at all in L, its role will be
purely syntactic (and L might not be closed
under negation, as in the example). Another
representation of the framework in the exam-
ple without using negation might be L = {p,
a, na, b, nb}, R = {p  a; na  b; nb  a},
A = {a, b}, and = {na}, = {nb}.
An argument in favor of a sentence x in L
supported by a set of assumptions X is a
(backward) deduction from x to X, via the
backward application of rules in R (with
respect to the direction , from the rule’s
head to its body). In example 1, we can
obtain an argument in favor of p supported
by {a} by applying p  a backwards. Also,
given q  b, p, we can obtain an argument
in favor of q supported by {b, a} by first
applying q  b, p backwards and then
applying p  a.
From now on, whenever it’s clear from the
context (and with an abuse of notation), we’ll
represent an argument in favor of x with sup-
port X as X  x, and we’ll refer to x as the con-
clusion of the argument X  x. This notation
equates an argument with the pair consisting
of its supporting assumptions and its conclu-
sion. It ignores the deduction that links the
two and, in particular, the rules used to gen-
erate the argument. It also ignores that we can
arrive at the same X  x relationship in more
than one way. However, the set of assump-
tions supporting an argument together with
the argument’s conclusion encapsulate the
argument’s essence. That is, the only way to
attack an argument is to attack one of its
assumptions by constructing an argument in
favor of a contrary of that assumption:
3,4
An argument X  x attacks an argument Y  y if
and only if x is a contrary of some assumption
in Y.
In example 1, {b}  ¬a attacks {a}  p be-
cause = {¬a}.
Assumption-based argumentation lets us
determine whether a rational reasoner would
accept a given claim. The claim could be, for
example, a potential belief of the reasoner or
a goal that an agent might hold or have
acquired. We represent the claim simply as
a
ba
b
a
α
NOVEMBER/DECEMBER 2007 www.computer.org/intelligent 25
We’ve developed and
implemented an argumentation
system combining the virtues
of assumption-based
argumentation and abstract
argumentation.