Download Knowledgebase Compilation for Efficient Logical Argumentation

Knowledgebase Compilation for Efficient Logical Argumentation
Philippe Besnard
Anthony Hunter
IRIT-CNRS,
Université Paul Sabatier,
118 rte de Narbonne, 31062 Toulouse, France
Department of Computer Science,
University College London,
Gower Street, London, WC1E 6BT, UK
Abstract
There are a number of frameworks for modelling argumentation in logic. They incorporate a formal representation of individual arguments and techniques for comparing conflicting
arguments. A common assumption for logic-based argumentation is that an argument is a pair Φ, α where Φ is minimal
subset of the knowledgebase such that Φ is consistent and Φ
entails the claim α. Different logics are based on different
definitions for entailment and consistency, and give us different options for argumentation. For a variety of logics, in
particular for classical logic, the computational viability of
generating arguments is an issue. Here, we present a solution that involves compiling a knowledgebase ∆ based on the
set of minimal inconsistent subsets of ∆, and then generating
arguments from the compilation. Whilst generating a compilation is expensive, generating arguments from a compilation
is relatively inexpensive.
Introduction
Argumentation is a vital aspect of intelligent behaviour by
humans. Consider diverse professionals such as politicians,
journalists, clinicians, scientists, and administrators, who all
need to to collate and analyse information looking for pros
and cons for consequences of importance when attempting
to understand problems and make decisions.
There are a number of proposals for logic-based formalisations of argumentation (for reviews see (Prakken &
Vreeswijk 2000; Chesnevar, Maguitman, & Loui 2001)).
These proposals allow for the representation of arguments
for and against some conclusion, and for attack relationships
between arguments. In a number of key examples of argumentation systems, an argument is a pair where the first item
in the pair is a minimal consistent set of formulae that proves
the second item which is a formula (see for example (Benferhat, Dubois, & Prade 1993; Elvang-Gøransson, Krause, &
Fox 1993; Besnard & Hunter 2001; Amgoud & Cayrol 2002;
Garcı́a & Simari 2004; Besnard & Hunter 2005)). Furthermore, in these approaches, the notion of attack is a form
of undercut, where one argument undercuts another argument when the conclusion of the first argument negates the
premises of the second argument.
c 2006, American Association for Artificial IntelliCopyright gence (www.aaai.org). All rights reserved.
In this paper, we consider viable algorithms for constructing undercuts. Let us assume that we construct undercuts
incrementally: We start with an argument Φ, α and then
we look for undercuts for this argument, and by recursion,
we look for undercuts to undercuts. We wish to find all
these arguments. This means a pruning strategy, such as
incorporated into defeasible logic programming (Garcı́a &
Simari 2004; Chesnevar, Simari, & Godo 2005), would not
meet our requirements since some undercuts would not be
obtained.
Let us start by considering the construction of individual
arguments. If ∆ is a knowledgebase, and we are interested
in a claim α, we seek an argument Φ, α where Φ ⊆ ∆.
Deciding whether a set of propositional classical formulae
is classically consistent is an NP-complete decision problem
and deciding whether a set of propositional formulae classically entails a given formula is a co-NP-complete decision
problem (Garey & Johnson 1979). However, if we consider
the problem as an abduction problem, where we seek the
existence of a minimal subset of a set of formulae that implies the consequent, then the problem is in the second level
of the polynomial hierarchy (Eiter & Gottlob 1995). Even
worse deciding whether a set of first-order classical formulae is consistent is an undecidable decision problem (Boolos,
Burgess, & Jeffrey 2002). So even finding the basic units of
argumentation is computationally challenging.
Proof procedures and algorithms have been developed for
finding preferred arguments from a knowledgebase following for example Dung’s preferred semantics (see for example (Prakken & Sartor 1997; Kakas & Toni 1999; Cayrol,
Doutre, & Mengin 2001; Dimopoulos, Nebel, & Toni 2002;
Dung, Kowalski, & Toni 2006)). However, these techniques and analyses do not offer any ways of ameliorating
the computational complexity inherent in finding arguments
and counterarguments even though it is a significant source
of computational inefficiency.
A possible approach to ameliorate the cost of entailment
is to use approximate entailment: Proposed in (Levesque
1984), and developed in (Schaerf & Cadoli 1995), classical
entailment is approximated by two sequences of entailment
relations. The first is sound but not complete, and the second is complete but not sound. Both sequences converge
to classical entailment. For a set of propositional formulae
∆, a formula α, and an approximate entailment relation |=i ,
the decision of whether ∆ |=i α holds or ∆ |=i α holds
can be computed in polynomial time. Approximate entailment has been developed for anytime coherence reasoning
(Koriche 2001; 2002). However, the approach still needs
to be further developed and evaluated for finding arguments
and counterarguments in argumentation. This would need
to start with a conceptualization of the notions of argument
and counteragument derived using approximate entailment
and approximate coherence.
Another approximation approach is cost-bounded argumentation proposed for a form of probabilistic argumentation (Haenni 2001). For this, the cost is a function of
the premises used for each argument, and this is justified
in terms of probabilities associated with the formulae. In
effect, the cost function biases which arguments are constructed in preference to others. This proposal may be adaptable for non-probabilistic argumentation, though given the
biases that emanate from the choice of cost function, it is
unlikely to be appropriate for all applications.
In this paper, we take a different approach by presenting a
solution that involves compiling a knowledgebase, and then
using the compilation to construct undercuts to an argument,
and then construct undercuts to undercuts by recursion. The
compilation of a knowledgebase ∆ is based on the minimal
inconsistent subsets of ∆.
We proceed as follows: We review an existing version
of logic-based argumentation, which is the basis for our approach to compilation; We provide some propositions concerning minimal inconsistent subsets of a knowledgebase
that we use to motivate the use of compilations; We present
our definition for compilation together with a theorem relating compilations and argumentation; We present the algorithm for generating arguments from a compilation, and
follow this with illustrative examples and completeness and
correctness theorems; and We present an algorithm for generating a compilation from a knowledgebase.
Logical argumentation
In this section we review an existing proposal for logicbased argumentation (Besnard & Hunter 2001). We consider a classical propositional language. We use α, β, γ, . . .
to denote formulae and ∆, Φ, Ψ, . . . to denote sets of formulae. Deduction in classical propositional logic is denoted by the symbol and deductive closure by Th so that
Th(Φ) = {α | Φ α}.
For the following definitions, we first assume a knowledgebase ∆ (a finite set of formulae) and use this ∆ throughout. We further assume that every subset of ∆ is given an
enumeration α1 , . . . , αn of its elements, which we call its
canonical enumeration. This really is not a demanding constraint: In particular, the constraint is satisfied whenever we
impose an arbitrary total ordering over ∆. Importantly, the
order has no meaning and is not meant to represent any respective importance of formulae in ∆. It is only a convenient
way to indicate the order in which we assume the formulae
in any subset of ∆ are conjoined to make a formula logically
equivalent to that subset.
The paradigm for the approach is a large repository of information, represented by ∆, from which arguments can be
constructed for and against arbitrary claims. Apart from information being understood as declarative statements, there
is no a priori restriction on the contents, and the pieces of
information in the repository can be as complex as possible.
Therefore, ∆ is not expected to be consistent. It need even
not be the case that every single formula in ∆ is consistent.
The framework adopts a very common intuitive notion of
an argument. Essentially, an argument is a set of relevant
formulae that can be used to classically prove some claim,
together with that claim. Each claim is represented by a formula.
Definition 1. An argument is a pair Φ, α such that: (1)
Φ ⊆ ∆; (2) Φ ⊥; (3) Φ α; and (4) there is no Φ ⊂ Φ
such that Φ α. We say that Φ, α is an argument for α.
We call α the claim (or consequent) of the argument and Φ
the support of the argument (we also say that Φ is a support
for α).
Example 1. Let ∆ = {α, α → β, γ → ¬β, γ, δ, δ →
β, ¬α, ¬γ}. Some arguments are:
{α, α → β}, β
{¬α}, ¬α
{α → β}, ¬α ∨ β
{¬γ}, δ → ¬γ
Arguments are not independent. In a sense, some encompass others (possibly up to some form of equivalence). To
clarify this requires a few definitions as follows.
Definition 2. An argument Φ, α is more conservative
than an argument Ψ, β iff Φ ⊆ Ψ and β α.
Example 2. {α}, α ∨ β is more conservative than
{α, α → β}, β.
Some arguments directly oppose the support of others,
which amounts to the notion of an undercut.
Definition 3. An undercut for an argument Φ, α is an
argument Ψ, ¬(φ1 ∧ . . . ∧ φn ) where {φ1 , . . . , φn } ⊆ Φ.
Example 3. Let ∆ = {α, α → β, γ, γ → ¬α}.
Then, {γ, γ → ¬α}, ¬(α ∧ (α → β)) is an undercut
for {α, α → β}, β. A less conservative undercut for
{α, α → β}, β is {γ, γ → ¬α}, ¬α.
Definition 4. Ψ, β is a maximally conservative undercut of Φ, α iff Ψ, β is an undercut of Φ, α such that
no undercuts of Φ, α are strictly more conservative than
Ψ, β (that is, for all undercuts Ψ , β of Φ, α, if Ψ ⊆
Ψ and β β then Ψ ⊆ Ψ and β β).
The value of the following definition of canonical undercut is that we only need to take the canonical undercuts into
account. This means we can justifiably ignore the potentially
very large number of non-canonical undercuts.
Definition 5. An argument Ψ, ¬(φ1 ∧. . .∧φn ) is a canonical undercut for Φ, α iff it is a maximally conservative
undercut for Φ, α and φ1 , . . . , φn is the canonical enumeration of Φ.
An argument tree describes the various ways an argument
can be challenged, as well as how the counter-arguments to
the initial argument can themselves be challenged, and so on
recursively.
Definition 6. A complete argument tree for α is a tree
where the nodes are arguments such that
Φ ∪ Φ ⊥. Therefore, Φ ∪ Ψ ∈ MinIncon(∆) and
Ψ ⊂ (Φ ∪ Ψ). 2
1. The root is an argument for α.
2. For no node Φ, β with ancestor nodes
Φ1 , β1 , . . . , Φn , βn is Φ a subset of Φ1 ∪ · · · ∪ Φn .
3. The children nodes of a node N consist of all canonical
undercuts for N that obey 2.
However, if Φ, α is the root of an argument tree, it is not
necessarily the case that there is an X ∈ MinIncon(∆), such
that Φ ⊂ X.
The second condition in Definition 6 ensures that each argument on a branch has to introduce at least one formula
in its support that has not already been used by ancestor arguments. This is meant to avoid making explicit undercuts
that simply repeat over and over the same reasoning pattern
except for switching the role of some formulae (e.g. in mutual exclusion, stating that α together with ¬α ∨ ¬β entails
¬β is exactly the same reasoning as expressing that β together with ¬α ∨ ¬β entail ¬α, because in both cases, what
is meant is that α and β exclude each other).
As a notational convenience, in examples of argument
trees the 3 symbol is used to denote the consequent of an
argument when that argument is a canonical undercut (no
ambiguity arises as proven in (Besnard & Hunter 2001)).
Example 4. Let ∆= {α ∨ β, α → γ, ¬γ, ¬β, δ ↔ β}. For
this, two argument trees for the consequent α∨¬δ are given.
{α ∨ β, ¬β}, α ∨ ¬δ {δ ↔ β, ¬β}, α ∨ ¬δ
↑
↑
{α → γ, ¬γ}, 3
{α ∨ β, α → γ, ¬γ}, 3
A complete argument tree is an efficient representation of the counterarguments, counter-counterarguments,
. . . Furthermore, if ∆ is finite, there is a finite number of argument trees with the root being an argument with the claim
α that can be formed from ∆, and each of these trees has
finite branching and a finite depth (the finite tree property).
Note, also the definitions presented in this section can be
used directly with first-order classical logic, so ∆ and α are
from the first-order classical language. Interestingly, the finite tree property also holds for the first-order case (Besnard
& Hunter 2005).
Minimal inconsistent subsets
If ∆ is consistent, then there are no counterarguments, otherwise the minimal inconsistent subsets of a knowledgebase
∆ summarise the conflicts that arise in ∆.
Definition 7. For a knowledgebase ∆, the set of minimal
inconsistent subsets of ∆, denoted MinIncon(∆), is defined
as follows.
MinIncon(∆) = {X ⊆ ∆ | X ⊥ and ∀Y ⊂ X, Y ⊥}
We are interested in the minimal inconsistent subsets of
∆ because of the following propositions.
Proposition 1. If Ψ, is a canonical undercut, then there
is an X ∈ MinIncon(∆), such that Ψ ⊂ X.
Proof: Let Φ, α be the argument for which Ψ, is a
canonical undercut. Therefore, Φ ∪ Ψ ⊥. Therefore, there
is a subset Φ ⊆ Φ where Φ ∪ Ψ ⊥ and for all Φ ⊂ Φ ,
Example 5. Let ∆ = {α, ¬α, β, ¬β}. Hence the minimal
inconsistent subsets are X1 = {α, ¬α} and X2 = {β, ¬β}.
Now consider the argument at the root of an argument tree
Φ, α ∧ β where Φ = {α, β}, Φ ⊂ X1 and Φ ⊂ X2 .
The following result shows how we can construct our
canonical undercuts from the set of minimal inconsistent
subsets of ∆.
Proposition 2. Let Φ, α be an argument. For all X ∈
MinIncon(∆), if Φ is a non-empty subset of X, then X \
Φ, is a canonical undercut for Φ, α.
Proof: Since X ∈ MinIncon(∆), and Φ ∩ X = ∅, we have
Φ ∪ (X \ Φ) ⊥. Furthermore, there is no W ⊂ (X \ Φ)
such that Φ ∪ W ⊥. Therefore, X \ Φ, is a canonical
undercut of Φ, α. 2.
Example 6. Let MinIncon(∆) = {{β, ¬β ∨ ¬γ, γ}}. Consider the argument {¬β ∨ ¬γ}, ¬(β ∧ γ). Clearly, {¬β ∨
¬γ} is a non-empty subset of {β, ¬β ∨ ¬γ, γ}. Hence,
{β, ¬β ∨ ¬γ, γ} \ {¬β ∨ ¬γ}, is a canonical undercut
of {¬β ∨ ¬γ}, ¬(β ∧ γ).
We generalize Proposition 2 as follows.
Proposition 3. Let Φ, α be an argument. For all X ∈
MinIncon(∆), if Φ ∩ X = ∅, and there is no Y ∈
MinIncon(∆), such that (Y \ Φ) ⊂ (X \ Φ), then X \ Φ, is a canonical undercut for Φ, α.
Example 7. Let MinIncon(∆) = {X1 , X2 } where X1 =
{α, ¬α} and X2 = {β, ¬β}. Now consider the argument
Φ, α ∧ β where Φ = {α, β}. Here X1 \ Φ, and X2 \
Φ, are each a canonical undercut for Φ, α.
We get the converse of Proposition 2 as follows.
Proposition 4. If Ψ, is a canonical undercut for Φ, α,
then there is an X such that X ∈ MinIncon(∆) and Ψ =
X \ Φ.
Proof: Assume Ψ, is canonical undercut for Φ, α.
Therefore, Ψ ¬(∧Φ) and there is no Ψ ⊂ Ψ such that
Ψ ¬(∧Φ). Therefore, Ψ ∪ Φ ⊥ and there is no Ψ ⊂ Ψ
such that Ψ ∪ Φ ⊥. Therefore, there is a Φ ⊆ Φ such
that Ψ ∪ Φ ∈ MinIncon(∆). Let X be Ψ ∪ Φ . Furthermore,
(X \ Φ) ∪ Φ ⊥ and there is no Z ⊂ (X \ Φ) such that
Z ∪ Φ ⊥. Hence, Ψ = X \ Φ. 2
Example 8. Let ∆ = {β, β → α, β → ¬α}. There is only
one minimal inconsistent subset which is {β, β → α, β →
¬α}. Now consider the argument {β, β → α}, α. There is
only one canonical undercut which is {β → ¬α}, . Furthermore, we have the following holding between the support of the argument, the support of the undercut, and the
minimal inconsistent subset.
{β → ¬α} = {β, β → α, β → ¬α} \ {β, β → α}
Minimal inconsistent subsets of a knowledgebase are not
necessarily disjoint. Consider X, Y ∈ MinIncon(∆) where
X ∩ Y = ∅. Furthermore, if the support of an argument
Φ, α is a subset of X, and Y ∩ Φ is non-empty, and there
is no Z ∈ MinIncon(∆), such that (Z \ Φ) ⊂ (Y \ Φ), then
Y \ Φ, is a canonical undercut for Φ, α, as captured in
the following result.
Proposition 5. Let Φ, α be an argument. For all X, Y ∈
MinIncon(∆), if X ∩ Y = ∅, and Φ ⊆ X, and Y ∩ Φ = ∅,
and there is no Z ∈ MinIncon(∆), such that (Z \ Φ) ⊂
(Y \ Φ), then Y \ Φ, is a canonical undercut for Φ, α.
Proof:
Let Φ, α be an argument, and let X, Y ∈
MinIncon(∆), be such that X ∩ Y = ∅, and Φ ⊆ X, and
Y ∩ Φ = ∅. Therefore (Y \ Φ) ∪ Φ ⊥. Also assume
there is no Z ∈ MinIncon(∆) such that (Z \ Φ) ⊂ (Y \ Φ).
Therefore there is no W ⊂ (Y \ Φ) such that W ∪ Φ ⊥.
Therefore Y \ Φ, is a canonical undercut for Φ, α. 2
Example 9. Let X1 , X2 ⊂ ∆ where X1 = {α, α → ¬β, β}
and X2 = {α, ¬α}. So X1 , X2 ∈ MinIncon(∆) and X1 ∩
X2 = ∅. Now consider the argument Φ, ¬β where Φ =
{α, α → ¬β}. So Φ ⊂ X1 and Φ ∩ X2 = ∅. Furthermore,
X2 \ Φ, is an undercut for Φ, .
Example 10. Let X1 , X2 , X3 ⊂ ∆ where
X1 = {¬α, ¬β, α ∨ β}
X2 = {¬α, α ∨ ¬β ∨ ¬γ, γ, β}
X3 = {β, ¬β}
Let MinIncon(∆) = {{X1 , X2 , X3 }}. Now consider the argument {α∨β}, α∨β. Let Φ = X1 \{α∨β} = {¬α, ¬β}.
So Φ, is a canonical undercut for {α ∨ β}, α ∨ β.
Furthermore, Φ ∩ X2 = ∅ and Φ ∩ X3 = ∅. However,
X2 \ Φ, is not a canonical undercut for Φ, , because
(X3 \ Φ) ⊂ (X2 \ Φ), whereas X3 \ Φ, is a canonical
undercut for Φ, .
We also see that every canonical undercut for a canonical undercut can be found using these overlapping minimal
inconsistent subsets of a knowledgebase.
Proposition 6. Let Φ, be a canonical undercut. If
Ψ, is a canonical undercut of Φ, then Ψ ⊂ Y for
some Y ∈ MinIncon(∆) such that X ∩ Y = ∅ for every
X ∈ MinIncon(∆) satisfying Φ ⊂ X.
Proof: Suppose Ψ, is a canonical undercut of Φ, .
Therefore, Ψ ∪ Φ ⊥ and there is not a Ψ ⊂ Ψ such
that Ψ ∪ Φ ⊥. Therefore, there is a Y ∈ MinIncon(∆)
such that Ψ ⊂ Y and Φ ∩ Y = ∅. Therefore, for every
X ∈ MinIncon(∆) such that Φ ⊂ X, it immediately follows
that X ∩ Y = ∅. 2
These results indicate that for any knowledgebase ∆, if
we have MinIncon(∆), we can find all undercuts to any argument without recourse to a consequence relation or a satisfiability check.
Compilation of a knowledgebase
Argument compilation is a process that involves finding all
the minimal inconsistent subsets of ∆, and then forming a
hypergraph from this collection of subsets. Given a knowledgebase ∆, the function Compilation(∆) gives the hypergraph that can then be used for efficiently building argument
trees.
Definition 8. Let Compilation(∆) = (N, A) where N =
MinIncon(∆) and
A = {(X, Y ) | X, Y ∈ N and X ∩ Y = ∅}
A graph is bidirectional if for each arc (X, Y ) in the
graph, (Y, X) is also in the graph. Clearly, for all ∆,
Compilation(∆) is a bidirectional hypergraph. Though
Compilation(∆) may be disjoint. Consider for example,
∆ = {α, ¬α, β, ¬β}.
Since the hypergraphs are bidirectional, we will represent them in the examples by just giving one of (X, Y ) and
(Y, X) for each of the arcs.
Example 11. Let ∆ = {δ ∧ ¬α, α, ¬α, α ∨ β, ¬β}. Hence
MinIncon(∆) = { X1 , X2 , X3 , X4 }, where X1 = {δ ∧
¬α, α}, X2 = {α, ¬α}, X3 = {¬α, α ∨ β, ¬β}, and X4 =
{δ∧¬α, α∨β, ¬β}. So the nodes and arcs of the hypergraph
are such that N = {X1 , X2 , X3 , X4 } and A = { (X1 , X2 ),
(X2 , X3 ), (X3 , X4 ), (X1 , X4 ) }.
The following result shows that an argument tree is composed from subgraphs of the compilation.
Theorem 1. Let Compilation(∆) = (N, A). If Φ, α is
the root of a complete argument tree T and Φ, α is the
parent node of Ψ, then the subtree of T rooted at Ψ, is isomorphic to a subgraph of (N, A).
Proof: Consider a branch Ψ0 , α, Ψ1 , , . . . , Ψm , in T (i.e., Ψ0 is Φ). The main step is to show that for
1 ≤ i ≤ m − 1, the fact that Ψi+1 , is a canonical undercut for Ψi , entails that there exist Xi and Xi+1 in N
satisfying (Xi , Xi+1 ) ∈ A.
Applying Proposition 4, there exists Xi ∈ N such that
Ψi = Xi \ Ψi−1 and there exists Xi+1 ∈ N such that
Ψi+1 = Xi+1 \ Ψi . Clearly, Xi = Ψi ∪ Ψi−1 and
Xi+1 = Ψi+1 ∪ Ψi . Since Ψi is trivially disjoint from
Ψi−1 and Ψi+1 , it then follows that Xi = Xi+1 implies
Ψi−1 = Ψi+1 . By the definition of an argument tree, the
support of an argument in T cannot be a subset of the support
of an ancestor: Here, Ψi−1 = Ψi+1 . Therefore, Xi = Xi+1 .
As Xi ∩ Xi+1 = ∅ is trivial, (Xi , Xi+1 ) ∈ A ensues.
There remains to show that no such branch is accounted for
by an unfolding of a cycle in (N, A). Assume Xj = Xj+k
for some j and k. Similarly to the above observation,
Xj = Ψj ∪ Ψj−1 and Xj+k = Ψj+k ∪ Ψj+k−1 . So,
Ψj ∪ Ψj−1 = Ψj+k ∪ Ψj+k−1 . Hence, Ψj+k ⊆ Ψj ∪ Ψj−1 .
However, the definition of an argument tree prohibits the
support of an argument to be a subset of the set-theoretic
union of the supports of its ancestors. That is, a contradiction arises. Therefore, Xj = Xj+k is impossible.
Lastly, it is immediate to notice that two siblings nodes cannot be accounted for by the same element in (N, A). Indeed, consider Ψ , and Ψ , in T sharing the same
parent node Ψ, . Assume that Proposition 4 yields the
same X in N for Ψ , and Ψ , . Then, Ψ = X \ Ψ
and Ψ = X \ Ψ. Trivially, Ψ = Ψ ensues but no two
distinct canonical undercuts for the same argument can have
the same support. Therefore, the assumption must be false
and the proof is over. 2
Corollary 1. Let Compilation(∆) = (N, A). If Ψ, is
canonical undercut for Φ, , and Φ, is itself a canonical undercut, then there is an (X, Y ) ∈ A, such that Φ ⊂ X
and Ψ ⊂ Y .
So by walking over Compilation(∆), we can construct argument trees from ∆. If we have an argument for the root
of the argument tree, then we can find undercuts and by recursion, undercuts to undercuts, by following the arcs of the
compilation. Moreover, we will argue in the next section,
the cost of using the compilation is much lower than constructing arguments directly from ∆.
Generating arguments from a compilation
Whilst argument compilation is expensive, once
Compilation(∆) has been computed, it can be used
relatively cheaply. Assume that we want to construct a
complete argument tree from ∆ with the argument Φ, α
as its root. Now we want to use the support of this argument
together with the hypergraph (i.e. Compilation(∆)) to
systematically build the argument tree.
The way we proceed is to find which nodes in the hypergraph have a non-empty set intersection with Φ. Suppose,
X is a node in the hypergraph and Φ ∩ X = ∅, then X \ Φ is
the support of a counterargument to Φ, α. Indeed, if there
is no node Y such that Φ ∩ Y = ∅ and (Y \ Φ) ⊂ (X \ Φ),
then X \ Φ, is a canonical undercut of Φ, α (according
to Proposition 3).
We now proceed by recursion looking for canonical undercuts to the canonical undercuts. For this we use the arcs
of the hypergraph. Suppose, Γj , is a canonical undercut
in the tree. Let Γi , be the parent of Γj , (i.e Γj , is
a canonical undercut of Γi , ). From this, we know there
is a node in the hypergraph X such that Γj = X \ Γi (c.f.
Proposition 4). Hence, Γj ⊂ X. Moreover, if there is an arc
in the hypergraph (X, Y ) and Y ∩ Γi = ∅, and there is no
arc (X, Z) in the hypergraph such that Z \ Φ ⊂ Y \ Φ, then
Y \ Γj , is a canonical undercut to Γj , (according to
Proposition 5).
Proposition 6 justifies that we pick one X, such that
X is a superset of Φ, and then we can find all the other
canonical undercuts of Φ, by just following the arcs in
Compilation(∆).
By keeping track of which arcs we have traversed in the
hypergraph, we can efficiently build a complete argument
tree. The Undercuts algorithm, presented in Definition
9, assumes that the argument for the root of the argument
tree is given as input. Then the algorithm determines where
this root argument is located in the hypergraph, and undertakes a depth-first search identifying canonical undercuts
by recursion. So for a knowledgebase ∆, the Undercuts
algorithm, together with subsidiary algorithms, only use
Compilation(∆).
Definition 9. The algorithm Undercuts takes the
root of an argument tree Φ, α and the hypergraph
Compilation(∆) = (N, A), and returns the nodes of the
argument tree. The first add statement puts the undercuts
to the root into the solution, and the second add statement
uses the algorithm Subcuts to find undercuts to undercuts
by recursion and puts them into the solution.
Undercuts(Φ, α, N, A)
FirstLevelSets = FirstLevel(Φ, α, N, A)
Output = ∅
while FirstLevelSets = ∅
remove X from FirstLevelSets
add X \ Φ, is an undercut of Φ, α to Output
add Subcuts(X \ Φ, N \ {X}, A, X, Φ) to Output
return Output
The algorithm FirstLevel takes the root of an argument
tree Φ, α and the hypergraph Compilation(∆) = (N, A),
and returns the subset of N that can be used for constructing
the undercuts to the root.
FirstLevel(Φ, α, N, A)
Candidates = {X ∈ N | Φ ∩ X = ∅}
Output = ∅
while Candidates = ∅
remove X from Candidates
if there is no Y ∈ Candidates ∪ Output
s.t. (Y \ Φ) ⊂ (X \ Φ)
then add X to Output
return Output
The algorithm Subcuts is a depth-first search algorithm
that takes the support of an argument, Γ, the set of available hypernodes M in the depth-first search, the current hypernode X, and the current union of the supports for the
arguments used on the branch up to the root S.
Subcuts(Γ, M, A, X, S)
Output = ∅
for all Y ∈ M
if (X,Y) ∈ A and Y ⊆ S and Y ∩ Γ = ∅
and there is no (X, Z) ∈ A
such that (Z \ Γ) ⊂ (Y \ Γ)
then add Y \ Γ, is an undercut of Γ, to Output
and add Subcuts(Y \ Γ, M \ {Y }, A, Y, S ∪ Y )
to Output
return Output
We illustrate the key features of the Undercuts algorithm
in Example 12 which shows how the FirstLevel algorithm
finds the nodes in N that intersect the root of the support,
how these are then used to generate the undercuts to the root,
and how the Subcuts algorithm finds the undercuts to the
undercuts.
Note, in the FirstLevel algorithm, that for each candidate node X, there is the following check (on the 6th line of
the algorithm).
there is no Y ∈ Candidates ∪ Output
such that (Y \ Φ) ⊂ (X \ Φ)
This is to ensure that the support for each undercut is minimal: The support of the root can involve formulae from more
than one minimally inconsistent set of formulae and so it is
not the case that every node X with a non-empty intersection with Φ is such that X \ Φ is minimal (as illustrated in
Example 13).
Note, in Subcuts we check that Y ∩ Γ = ∅ because we
want to ensure that Y \ Γ is inconsistent with Γ rather than
with the support of the parent of Γ, (which is illustrated
in Example 14). Also, in Subcuts, we check that Y ⊆ S,
because according to the definition of an argument tree, no
undercut on a branch can have a support that is a subset of
the union of the support of the ancestors.
Example 12. Consider ∆ = {α, ¬α, β ∧ ¬β, γ, γ →
δ, ¬δ, ¬γ ∨ δ} which has the following compilation (N, A),
where N = {X1 , X2 , X3 , X4 } and A = {(X4 , X3 )}.
X1
X2
X3
X4
= {α, ¬α}
= {β ∧ ¬β}
= {γ, γ → δ, ¬δ}
= {γ, ¬γ ∨ δ, ¬δ}
Now suppose, we have the following argument as the root of
the argument tree.
{γ, γ → δ}, δ ∨ β
We have support for one canonical undercut of the root (i.e.
FirstLevelSets = {X3 }).
X3 \ {γ, γ → δ} = {¬δ}
Also we have (X4 , X3 ) as an arc and so we have an undercut
to the undercut.
X4 \ {¬δ} = {γ, ¬γ ∨ δ}
There are no more arcs to consider and so the net result is
the following argument tree. The elements of N that are used
are given adjacent to the arrow in the following diagram.
{γ, γ → δ}, δ ∨ β
↑ X3
{¬δ}, ↑ X4
{γ, ¬γ ∨ δ}, In this example, we see that not all nodes are used in the
construction of this tree. Furthermore, one node will never
be used in any argument tree (i.e. X2 ).
Now suppose we have the following argument as the root
of the argument tree.
{γ, γ → δ, α}, δ ∧ α
We have supports for two canonical undercuts of the root
(i.e. FirstLevelSets = {X1 , X3 }).
X1 \ {γ, γ → δ, α} = {¬α}
X3 \ {γ, γ → δ, α} = {¬δ}
Also we have (X4 , X3 ) as an arc and so we have an undercut
to the second of the undercuts.
X4 \ {¬δ} = {γ, ¬γ ∨ δ}
There are no more arcs to consider and so the net result is
the following argument tree.
{γ, γ → δ, α}, δ ∧ α
X3
X1
{¬α}, {¬δ}, ↑ X4
{γ, ¬γ ∨ δ}, Example 13. Let ∆ = {α, β, ¬β, ¬α ∨ β}. So N =
{X1 , X2 }, where (X1 , X2 ) ∈ A, for X1 and X2 as follows.
X1 = {α, ¬β, ¬α ∨ β}
X2 = {β, ¬β}
Now consider the root of an argument tree Φ, α ∧ β, where
Φ = {α, β}. Here we have X1 ∩ Φ = ∅ and X2 ∩ Φ = ∅. So
both are candidates for forming supports for undercuts for
the root argument.
X1 \ Φ = {¬β, ¬α ∨ β}
X2 \ Φ = {¬β}
However, from the above, we see that we have the following.
X2 \ Φ ⊆ X1 \ Φ
Hence, X1 fails the condition on line 6 of the FirstLevel
algorithm, whereas X2 succeeds. Therefore, only X2 is used
to construct an undercut to the root. Also we have (X1 , X2 )
as an arc and so we have an undercut to the undercut. The
net result is the following argument tree.
{α, β}, α ∧ β
↑
{¬β}, ↑
{α, ¬α ∨ β}, Example 14. Let ∆ = {γ ∧ α, β, β → ¬α, ¬γ}. Hence,
N = {X1 , X2 }, where (X1 , X2 ) ∈ A, for X1 and X2 as
follows.
X1 = {γ ∧ α, β, β → ¬α}
X2 = {γ ∧ α, ¬γ}
For this, we get the following argument tree with root {γ ∧
α}, α.
{γ ∧ α}, α
X1
X2
{β, β → ¬α}, {¬γ}, Note, even though we have (X1 , X2 ) in A, we do not get
an undercut for {β, β → ¬α}, using X2 because of the
following which fails the condition on line 3 of the Subcuts
algorithm.
{β, β → ¬α} ∩ X2 = ∅
For the same reason, we do not get an undercut for
{¬γ}, using X1 .
Example 15. As another illustration, continuing Example
11, suppose {α ∨ β}, α ∨ β is the root of the tree. We have
supports for two canonical undercuts of the root which are
X3 \ {α ∨ β} = {¬α, ¬β}
X4 \ {α ∨ β} = {δ ∧ ¬α, ¬β}
X2
X1
H
@ HH
@ HH
@
H
X3
@
@
@@
@
@
@
X4 H @
X5
HH @
@
HH
@ H
X6
Figure 1: The compilation for Example 16 with nodes
X1 ,..,X6 .
We have (X3 , X2 ), (X3 , X4 ), and (X4 , X1 ) as arcs, and so
we have undercuts to undercuts as following.
X2 \ {¬α, ¬β} = {α}
X4 \ {¬α, ¬β} = {δ ∧ ¬α, α ∨ β}
X1 \ {δ ∧ ¬α, ¬β} = {α}
X3 \ {δ ∧ ¬α, ¬β} = {¬α, α ∨ β}
Finally, for the above undercuts, we have (X4 , X1 ),
(X2 , X1 ), and (X3 , X2 ) as arcs, and so we have undercuts
to undercuts as following.
X1 \ {δ ∧ ¬α, α ∨ β} = {α}
X1 \ {α} = {δ ∧ ¬α}
X2 \ {α} = {¬α}
X2 \ {¬α, α ∨ β} = {α}
The net result is the following argument tree labelled with
the element from N used for finding each undercut.
{α ∨ β}, α ∨ β
X3 X4
{¬α, ¬β}, {δ ∧ ¬α, ¬β}, X4 X2 ↑
↑ X1 X3
{δ ∧ ¬α, α ∨ β}, {α}, {α}, {¬α, α ∨ β}, X1 ↑
X1 ↑
↑ X2
↑ X2
{α}, {δ ∧ ¬α}, {¬α}, {α}, Example 16. This example represents an extreme case of
inconsistency in a knowledgebase. Let ∆ = {α ∧ β, α ∧
¬β, ¬α ∧ β, ¬α ∧ ¬β}, let N = { X1 , X2 , X3 , X4 , X5 , X6
}, and let A = {(X1 , X2 ), (X1 , X3 ), (X1 , X4 ), (X1 , X5 ),
(X2 , X3 ), (X2 , X4 ), (X2 , X6 ), (X3 , X5 ), (X3 , X6 ),
(X4 , X5 ), (X4 , X6 ), (X5 , X6 )}, which is illustrated in Figure 1, and where
X1 = {α ∧ β, α ∧ ¬β}
X2 = {α ∧ β, ¬α ∧ β}
X3 = {α ∧ β, ¬α ∧ ¬β}
X4 = {α ∧ ¬β, ¬α ∧ β}
X5 = {α ∧ ¬β, ¬α ∧ ¬β} X6 = {¬α ∧ β, ¬α ∧ ¬β}
Let
A1
A2
A3
A4
= {α ∧ β}, α ∧ β
= {α ∧ ¬β}, α ∧ ¬β
= {¬α ∧ β}, ¬α ∧ β
= {¬α ∧ ¬β}, ¬α ∧ ¬β
Hence, we get the following argument tree. Each arc is labelled with the index i of the set Xi ∈ N used to construct
the undercut.
A1
1
↑2
3
A2
A3
A4
4
5 4
6 5
6
A3
A4
A2
A4
A2
A3
↑6
↑6
↑5
↑5
↑4
↑4
A4
A3
A4
A2
A3
A2
Assuming some knowledgebase ∆, the following completeness result shows that for any argument, we get all the
canonical undercuts for it using the compilation of ∆.
Theorem
2. For
a
knowledgebase
∆,
let
Compilation(∆) = (N, A), Let Γ, α be an argument. For all X ∈ N such that Γ ⊆ X, if Ψ, is an
undercut for Γ, α then
• either Ψ = X \ Γ
• or Ψ = Y \ Γ for some Y ∈ N such that (X, Y ) ∈ A and
Y ∩ Γ = ∅
Proof: Let X ∈ N satisfy Γ ⊆ X and let Ψ, be an
undercut for Γ, α. It is sufficient to make the hypothesis
Ψ = X \ Γ and then prove Ψ = Y \ Γ for some Y ∈ N such
that Y ∩ Γ = ∅ and (X, Y ) ∈ A.
Ψ, is an undercut for Γ, α, hence Ψ is a minimal
consistent subset of ∆ such that Ψ ¬(γ1 ∧ . . . ∧ γn )
where Γ = {γ1 , . . . , γn }. By classical logic, there exists
a minimal subset Γ = {γ1 , . . . , γm
} of Γ that satisfies
Ψ ¬(γ1 ∧ . . . ∧ γm ) for some m > 0 (i.e., Γ is nonempty). So, Ψ ∪ Γ is minimally inconsistent.
Reasoning by reductio ad absurdum, assume some γi ∈
Γ ∩ Ψ. Then, Ψ, being an undercut for Γ, α means
that {γi } ∪ (Ψ \ {γi }) ¬(γ1 ∧ . . . ∧ γn ). By classical
logic, Ψ \ {γi } ¬(γ1 ∧ . . . ∧ γn ) ensues and Ψ would
not be a minimal subset of ∆ entailing ¬(γ1 ∧ . . . ∧ γn ), a
contradiction arises. Therefore, Ψ ∩ Γ = ∅.
Reasoning by reductio ad absurdum again, assume Ψ ⊆ X.
As Ψ, is an undercut for Γ, α, it follows that Ψ ∪ Φ is
inconsistent. X ∈ N means that X is minimally inconsistent. Hence, Γ ⊆ X and Ψ ⊆ X imply X = Γ ∪ Ψ. It
has been shown above that Ψ and Γ are disjoint, therefore
Ψ = X \ Γ and a contradiction arises. Hence, the assumption must be false. So, Ψ ⊆ X. That is, there exists ψ ∈ Ψ
such that ψ ∈ X.
Take Y to be Ψ ∪ Γ . (1) As Ψ ∩ Γ = ∅ has been shown,
Ψ = Y \ Γ. (2) Ψ ∪ Γ has been shown to be minimally
inconsistent, therefore Y ∈ N . (3) It has been shown that Γ
is non-empty, hence Γ ⊆ Γ yields Γ ∩ Y = ∅. (4) Lastly,
Γ ⊆ X ∩ Y ensues from Γ ⊆ Γ ⊆ X and it follows that
X ∩ Y is not empty because Γ is not. Now, Ψ ⊆ Y but
it has been shown that Ψ ⊆ X hence X = Y . An easy
consequence of X ∩ Y = ∅ and X = Y is (X, Y ) ∈ A. 2
For an argument Φ, α, the Undercuts algorithm is correct in the sense that it constructs a complete argument tree
with Φ, α as the root. This is captured in Theorem 3, and
it is based on the completeness result in Theorem 2, and the
soundness results in Proposition 2 and Proposition 5.
Theorem 3. For a knowledgebase ∆, a hypergraph
Compilation(∆) = (N, A), and an argument Φ, α, such
that Φ ⊆ ∆, the algorithm Undercuts(Φ, α, N, A) returns the canonical undercuts for a complete argument tree
T where the root of T is Φ, α.
Proof: From Proposition 2, we see that the call to the
FirstLevel algorithm ensures that all the canonical undercuts for Φ, α are returned. From Proposition 2, each of
the undercuts obtained via the FirstLevel algorithm are
indeed canonical undercuts for Φ, α.
From Proposition 2, we see that each call to the Subcuts
algorithm returns all canonical undercuts to canonical undercuts, since given an undercut Γ, where Γ ⊂ X for
some X ∈ N , all undercuts Y \ Γ, are returned where
(X, Y ) ∈ A and Y ⊆ S. The Subcuts algorithm is called
by recursion to obtain all canonical undercuts to each canonical undercut by recursion. Furthermore, from Proposition 5,
each of the undercuts obtained via the Subcuts algorithm
are indeed canonical undercuts in T . 2
We can consider the Undercuts algorithm, with the subsidiary algorithms FirstLevel and Subcuts, as constructing a depth-first search tree, annotating each node (except
the root) of the tree with an undercut, and annotating each
arc of the search tree with an arc from the hypergraph. In
this way, the depth-first search tree is isomorphic with an
argument tree rooted at Φ, α.
Whilst the Undercuts algorithm, with the subsidiary algorithms FirstLevel and Subcuts, construct a depth-first
search tree from the compilation, they do not backtrack. Furthermore, in order to construct an argument tree these algorithms only use constant time operations and tests, such as
set membership, set union, and set intersection. In contrast,
an algorithm for constructing an argument tree directly from
an knowledgebase ∆ has to search ℘(∆) to find undercuts,
and for each element Γ ∈ ℘(∆), if an undercut with claim
ψ is required, then the algorithm has to undertake the expensive tests of entailment (i.e. does Γ ψ hold?), consistency (i.e. does Γ ⊥ hold?), and minimality (i.e. does
Γ ∪ {γi } ψ hold for each γi ∈ Γ?).
Constructing a compilation
A compilation of a knowledgebase can be constructed by the
GenerateCompilation algorithm which in turn uses the
GenerateMinIncons algorithm. These are defined below
using the following subsidiary functions.
• Subsets(∆, C) which returns the set of subsets of ∆ that
have a cardinality C;
• NotSuperSet(Φ, Θ) which is Boolean function that is
true if there is no member of Θ that is a subset of Φ;
• Inconsistent(Φ) which is Boolean function that is true
if Φ ⊥.
The GenerateCompilation algorithm takes the set of
minimal inconsistent subsets of ∆, and then seeks all pairs of
minimal inconsistent subsets with non-empty intersections,
and hence giving the set of arcs of the graph.
Definition 10. Given a set of formulae ∆, the
GenerateCompilation algorithm finds the compilation for ∆.
GenerateCompilation(∆)
N = GenerateMinIncons(∆)
M =N
A=∅
while M = ∅
remove an arbitrary element X from M
let Temp = M
while Temp = ∅
remove an arbitrary element Y from Temp
if X ∩ Y = ∅
then A = A ∪ {(X, Y )}
return (N, A)
The GenerateMinIncons algorithm works by considering each subset of ∆ as a possible minimal inconsistent subset of ∆. The search is started with the subsets of smallest
cardinality, and then with each cycle of the outer while loop,
the cardinality of the subsets is increased by one. The inner
while loop checks each of the subsets Φ of a given cardinality. The if statement checks whether Φ is not a superset of a
minimal inconsistent subset that has already been identified,
and that Φ is inconsistent. If these conditions are met, then
Φ is added to the set of minimal inconsistent subsets Θ that
is eventually returned by the algorithm.
Definition 11. Given a set of formulae ∆, the
GenerateMinIncons algorithm returns all the minimal inconsistent subsets of ∆.
GenerateMinIncons(∆)
Θ=∅
C=1
while C ≤ |∆|
Ω = Subsets(∆, C)
while Ω = ∅
let Φ be an arbitrary member of Ω
if NotSuperSet(Φ, Θ) & Inconsistent(Φ)
then Θ = Θ ∪ {Φ}
Ω = Ω \ {Φ}
C =C +1
return Θ
We now turn to the complexity of constructing a compilation. We start by considering the potential size of
MinIncon(∆). Let Combinations(x, y) be the number
of combinations of subsets of cardinality y that can be
formed from a set of cardinality x. In other words,
Combinations(x, y) = x!/(x − y)!y!. Also, let z be the
greatest integer less then or equal to z.
Proposition 7. Let n = |∆| and m = n/2. If ∆ ⊥,
then 1 ≤ |MinIncon(∆)| ≤ Combinations(n, m).
Proof For any Φ ∈ MinIncon(∆), there is no Ψ ∈
MinIncon(∆) such that Φ ⊂ Ψ or Ψ ⊂ Φ. The largest
subset of ℘(∆) for which no element is a subset of any other
is the set of subsets of ∆ that are of cardinality n/2. The
number of these subsets is given by Combinations(n, m). 2
Whilst the above result shows that the cardinality of
MinIncon(∆) may be an issue, in practice it is likely this
cardinality will be significantly lower than the upper limit
and so be of an acceptable and manageable size.
Proposition 8. If |∆| = n, and m = n/2, and k =
Combinations(n, m), and Compilation(∆) = (N, A), then
|N | ≤ k and |A| ≤ (k × (k − 1)).
From this, we see that the expensive part of compilation is
the call GenerateMinIncons(∆), which in the worst case
involves 2n tests where |∆| = n, and each test is of the
following expensive form:
NotSuperSet(Φ, Θ) & Inconsistent(Φ)
In contrast, the algorithms for using the compilation are
relatively inexpensive, involving only constant cost operations and tests such as set membership, set intersection, and
set union. Hence, constructing a compilation is expensive,
whereas the cost of using it is relatively inexpensive.
Discussion
Much progress has been made on developing formalisms
for argumentation. Some algorithms for argumentation
have been developed (for example (Kakas & Toni 1999;
Cayrol, Doutre, & Mengin 2001; Baroni & Giacomin 2002;
Garcı́a & Simari 2004)). However, relatively little progress
has been made in developing techniques for overcoming the
computational challenges of constructing arguments.
In this paper, we have presented a compilation of a knowledgebase that uses the minimal inconsistent subsets of the
knowledgebase, together with an algorithm for constructing
undercuts for an argument, and by recursion, undercuts to
undercuts. Compilation is expensive, but constructing argument trees for an given root argument is relatively inexpensive.
In future research, we will address both theoretical and
empirical issues. At the theoretical level, we need to undertake a comprehensive computational complexity analysis of
the underlying decision problems related to compilation and
of the algorithms we have proposed here. These theoretical
analyses may include positioning our approach to compilation within a general framework for complexity analyses for
compilation techniques (Cadoli et al. 2002). At the empirical level, we need to implement the algorithms presented
here, and undertake trials with sufficently large knowledgebases to investigate the viability and utility of this form of
compilation.
Whilst our presentation is based on a particular approach
to logic-based argumentation, we believe the proposal could
be adapted for a range of other logic-based approaches
to argumentation (for example (Garcı́a & Simari 2004;
Amgoud & Cayrol 2002)) by adapting our definition for
minimal inconsistent subsets and our algorithm for using the
compilation.
References
Amgoud, L., and Cayrol, C. 2002. A model of reasoning
based on the production of acceptable arguments. Annals
of Mathematics and Artificial Intelligence 34:197–216.
Baroni, P., and Giacomin, M. 2002. Argumentation
through a distributed self-stabilizing approach. Journal of Experimental and Theoretical Artificial Intelligence
14(4):273–301.
Benferhat, S.; Dubois, D.; and Prade, H. 1993. Argumentative inference in uncertain and inconsistent knowledge
bases. In Proceedings of Uncertainty in Artificial Intelligence, 1449–1445. Morgan Kaufmann.
Besnard, P., and Hunter, A. 2001. A logic-based theory of
deductive arguments. Artificial Intelligence 128:203–235.
Besnard, P., and Hunter, A. 2005. Practical first-order argumentation. In Proc. of the 20th National Conference on
Artificial Intelligence (AAAI’2005), 590–595. MIT Press.
Boolos, G.; Burgess, J.; and Jeffrey, R. 2002. Computability and Logic. Cambridge University Press.
Cadoli, M.; Donini, F.; Liberatore, P.; and Schaerf, M.
2002. Preprocessing of intractable problems. Information
and Computation 176(2):89–120.
Cayrol, C.; Doutre, S.; and Mengin, J. 2001. Dialectical
proof theories for the credulous preferred semantics of argumentation frameworks. In Quantitative and Qualitative
Approaches to Reasoning with Uncertainty, volume 2143
of LNCS, 668–679. Springer.
Chesnevar, C.; Maguitman, A.; and Loui, R. 2001. Logical
models of argument. ACM Computing Surveys 32:337–
383.
Chesnevar, C.; Simari, G.; and Godo, L. 2005. Computing dialectical trees efficiently in possibilistic defeasible
logic programming. In Proceedings of the 8th Interntational Logic Programming and Non-monotonic Reasoning
Conference, volume 3662 of LNCS, 158–171. Springer.
Dimopoulos, Y.; Nebel, B.; and Toni, F. 2002. On the computational complexity of assumption-based argumentation
for default reasoning. Artificial Intelligence 141:57–78.
Dung, P.; Kowalski, R.; and Toni, F. 2006. Dialectic proof
procedures for assumption-based, admissible argumentation. Artificial Intelligence 170(2):114–159.
Eiter, T., and Gottlob, G. 1995. The complexity of logicbased abduction. Journal of the ACM 42:3–42.
Elvang-Gøransson, M.; Krause, P.; and Fox, J. 1993. Dialectic reasoning with classically inconsistent information.
In Proceedings of the Ninth Conference on Uncertainty in
Artificial Intelligence, 114–121. Morgan Kaufmann.
Garcı́a, A., and Simari, G. 2004. Defeasible logic programming: An argumentative approach. Theory and Practice of
Logic Programming 4(1):95–138.
Garey, M., and Johnson, D. 1979. Computers and Intractability. W H Freeman.
Haenni, R. 2001. Cost-bounded argumentation. International Journal of Approximate Reasoning 26:101–127.
Kakas, A., and Toni, F. 1999. Computing argumentation
in logic programming. Journal of Logic and Computation
9:515–562.
Koriche, F. 2001. On anytime coherence-based reasoning. In Quantitative and Qualitative Approaches to Rea-
soning with Uncertainty, volume 2143 of LNCS, 556–567.
Springer.
Koriche, F. 2002. Approximate coherence-based reasoning. Journal of Applied Non-classical Logics 12(2):239–
258.
Levesque, H. 1984. A logic of implicit and explicit belief.
In Proceedings of the National Conference on Artificial Intelligence (AAAI’84), 198–202.
Prakken, H., and Sartor, G. 1997. Argument-based extended logic programming with defeasible priorities. Journal of Applied Non-Classical Logics 7:25–75.
Prakken, H., and Vreeswijk, G. 2000. Logical systems for
defeasible argumentation. In Gabbay, D., ed., Handbook of
Philosophical Logic. Kluwer.
Schaerf, M., and Cadoli, M. 1995. Tractable reasoning via
approximation. Artificial Intelligence 74:249–310.