## An Analysis of the Computational Complexity

## of DeLP through Game Semantics

### Preliminary Report

### Laura A. Cecchi

∗§_{Pablo R. Fillottrani}

†‡
lcecchi@uncoma.edu.ar fillottrani@inf.unibz.it
### Guillermo R. Simari

‡ grs@cs.uns.edu.ar∗_{Depto. de Cs. de la Computaci´on - Fa.E.A.} †_{Faculty of Computer Science}
Universidad Nacional del Comahue Free University of Bozen/Bolzano

Buenos Aires 1400 - (8300) Neuqu´en - Argentina Piazza Domenicani, 3 - (39100) Bolzano - Italia

§_{Depto. de Cs. Exactas y Naturales - U.A.R.G.} ‡_{Depto. de Cs. e Ing. de la Computaci´on}
Universidad Nacional de la Patagonia Austral Universidad Nacional del Sur

L.de la Torre 1070 - (9400) R´ıo Gallegos - Argentina Av. Alem 1253 - (8000) Bah´ıa Blanca - Argentina

Key Words: Argumentative Systems, Defeasible Reasoning, Logic Programming, Game-based Semantics, Complexity

Abstract

Defeasible Logic Programming (DeLP) is a suitable tool for knowledge representation and reasoning. Its operational semantics is based on a dialectical analysis where arguments for and against a literal interact in order to determine whether this literal is believed by a reasoning agent. The semanticsGS is a declarative trivalued game-based semantics for DeLP that is sound and complete for DeLP operational semantics.

Complexity theory has become an important tool for comparing diﬀerent formalism and for helping to improve implementations whenever is possible. For these reasons, it is important to investigate the computational complexity and expressive power of DeLP.

## 1

## Introduction

Defeasible Logic Programming (DeLP) is a general argumentation based tool for knowledge
representation and reasoning [GS04]1_{. Its operational semantics is based on a dialectical analysis}

where arguments for and against a literal interact in order to determine whether this literal is believed by a reasoning agent. The semantics GS is a declarative trivalued game-based semantics for DeLP that links game and model theories [CS04]. Soundness and completeness of GS with respect to DeLP operational semantics have been proved.

Even thought complexity for nonmonotonic reasoning systems has been studied in depth for several formalisms such us default logic, autoepistemic logic, circumscription, abduction and logic programming [CS93, DEGV01] until now not many complexity results for argumentation systems have been reported. This situation can partly be explained by the fact that, historically, implementations of argumentation systems have been limited to the legal area and with no real time response restriction (see [Pol95, Ver98]). However, in recent years, several applications have been developed and implemented using argumentation systems related, for instance, with multiagents systems and web search [ABCMB04, CM04, BAV04].

Complexity theory has become an important tool for comparing diﬀerent formalism and for helping to improve implementations whenever is possible. For this reason, it is important to analyze computational complexity and expressive power of DeLP, since the former tells us how diﬃcult it is to answer a query, while the latter gives precise characterization of the concepts that it is possible to deﬁne as queries.

Even though Dimopoulus et al. [DNT02] presents computational complexity of the argu-mentation based abstract framework for default reasoning [BDKT97], DeLP does not ﬁt in this framework. Another notable study of computational complexity of defeasible systems has been done in [Mah01]. However, the defeasible theory analyzed diﬀers from DeLP in several points, such as the kind of knowledge: facts and strict, defeasible and defeaters rules and its operational semantics.

In this paper we present a complexity analysis of DeLP through game-semantics GS. In particular, we have determined that computing rigorous consequences is P-complete and that the decision problem of whether “a set of defeasible rules is an argument for a literal under a defeasible logic program” is in P.

The rest of the paper is structured as follows. In section 2, we brieﬂy present basic concepts of DeLP. Section 3, describe the declarative semantics game-basedGS. Next we analyze DeLP through GS semantics pointing out which decision problems must been studied. In section 5, we present the main results of this paper: the complexity analysis of some problems in DeLP. Finally, we present our conclusions and future research lines.

## 2

## DeLP and Operational Semantics Intuitions

We will start by introducing some of the basic concepts in DeLP. In the language of DeLP a literal L is a atom A or a negated atom ∼A, where ∼ represents the strong negation in the logic programming sense. The complement of a literal L, denoted as L, is deﬁned as follows:

L=∼A, if Lis an atom, otherwise if L is a negated atom, L=A.

Definition 1 A strict rule is an ordered pair, denoted “Head ← Body”, whose ﬁrst member

“Head” is a ground literal, and whose second member “Body” is a ﬁnite set of ground literals.

A strict rule with head L0 and body {L1, . . . Ln, n > 0} can also be written as L0 ← L1, . . . Ln. If body is the empty set, then we can write L0. and it is call a Fact. A defeasible rule is an

ordered pair, denoted “Head —< Body”, whose ﬁrst member “Head” is a ground literal, and

whose second member “Body” is a ﬁnite, non-empty set of ground literals. A defeasible rule
with head L0 and body {L1, . . . Ln, n >0} can also be written as L0 —<L_{1}, . . . Ln.

A defeasible logic program P, abbreviated de.l.p., is a set of strict rules and defeasible rules. We will distinguish the subsetΠ of strict rules and the subset∆ of defeasible rules, and we will denote P =hΠ,∆i, when required.

Intuitively, whereas Π is a set of certain and exception-free knowledge, ∆ is a set of defeasible knowledge, i.e., tentative information that could be used, whenever nothing is posed against it. Even though a de.l.p. may be an inﬁnite set of strict and defeasible rules, complexity analysis has been limited to ﬁnite de.l.p..

DeLP operational semantics is based on developments in non monotonic argumentation systems [Pol87, SL92]. An argument for a literal L is a minimal subset of ∆ that together with Π consistently entails L [GS04]. Thus, an agent can explain a literal L, throughout this argument.

However, in order to determine whether a literal Lis supported from a de.l.p.a dialectical tree forLis built. An argument forLrepresents the root of the dialectical tree, and every other node in the tree is a defeater argument against its parent. At each level, for a given a node we must consider all the arguments against that node. Thus every node has a descendant for every defeater. A comparison criteria is needed for determining whether an argument defeats another one. Even though there exists several preference relations considered in the literature, in this ﬁrst approach we will abstract away from that issue.

We will say that a literal Lis warranted if there is an argument forL, and in the dialectical tree each defeater of the root is itself defeated. Recursively, this leads to a marking procedure of the tree that begins by considering that leaves in the dialectical tree are undefeated arguments as a consequence of having no defeaters to consider. Finally, an agent will believe in a literal

L, if L is a warranted literal.

There exist four possible answers for a query L: yesif Lis warranted, no if Lis warranted (i.e., the complement of L is warranted), undecided if neither L nor L are warranted, and

unknown if L is not in the underlying signature of the program.

We have brieﬂy given an intuitive introduction to the DeLP language and the dialectical procedure for obtaining a warranted conclusion. For complete details on DeLP see [GS04]. Now we will continue with the analysis of the declarative semantics GS for DeLP.

## 3

## Basic Concepts on Game Semantics

Games have an analogy with a dispute and, therefore, that analogy extends to argument-based
reasoning. A dispute can be seen as a game where in an alternating manner, the player P_{,}

the proponent, starts with an argument for a literal. The player O_{, the opponent, attacks}

The semanticsGS is a declarative trivalued game-based semantics for DeLP that links game and model theories. Soundness and completeness of GS with respect to DeLP operational semantics have been proved [CS04]. In the following we present some notions of GS, for more details see [CS00, CS04].

Definition 2 LetP be a de.l.p.. Agame-based interpretation forP, or G-Interpretation forP

for short, is a tuple hT, Fi, such that T andF are subsets of atoms of the underlying signature of P and T ∩F =∅.

Let Lit be the set of all the ground literals that can generated considering the underlying
signature of a de.l.p.. The set of atoms undecided is deﬁned as the set U =Lit+_{− {}_{T} _{∪}_{F}_{}}_{,}

being Lit+ the set of all the atoms in Lit.

Movements in a game are arguments. For every argument A for a literal L we can built
a game whose ﬁrst move is A. Thus, a family of games will be obtained considering all the
arguments for L. Each game can ﬁnish in two possible ways: won by the P _{or won by the} O_{.}

There is no place for a draw. As the ﬁrst move is made by the P_{, we are interested in those}

games won by this player.

Definition 3 Let P be a plr, L an atom of the underlying signature of P, F(L,P) the game

family for the literal L and F(L,P) the game family for the literal L for the plr P. A game-based model for P, that we name G-Model of P, is a G-interpretation hT, Fi such that:

• If there exists a gameG(hA, Li,P) in the familyF(L,P) won by P_{, then} _{L} _{belongs to} _{T}_{.}
• If there exists a gameG(hA, Li,P)in the family F(L,P)won by P_{, then}_{L} _{belongs to} _{F}_{.}

Since we only consider literals under the signature of de.l.p., the G-model deﬁnition does not contemplate the answer unknown. The minimal G-model deﬁnes a sound and complete semantics GS for DeLP [CS04].

In order to capture through a game the dialectical procedure, we need to deﬁne in a declar-ative way the movements of such game: the argument. The followings deﬁnitions are based on the notation introduced in [Lif96].

Definition 4 [CS00] Let X be a set of ground literals. The set X is rigorously closed under

a de.l.p. P, if for every strict rule Head ←Body of P, Head ∈ X whenever Body ⊆ X and for every defeasible rule Head′

—<Body′ of P, Head′ ∈X whenever Body′ ⊆X.

The set X is consistent if there is no literal L such that {L, L} ⊆ X. Otherwise, we will say that X is inconsistent.

We say that X is logically closed if it is consistent or it is equal to Lit.

Intuitively, if the set of knowledge of an agent is rigorously closed under a de.l.p., the agent will not believe in a literal that she cannot explain.

Definition 5 [CS00]LetΨa set of strict and defeasible rules. Theset of rigorous consequences

under the rules Ψ, that we will denoted CnR(Ψ), is the least set of literals w.r.t. the inclusion, such that it is logically closed and rigorously closed under Ψ.

Let P be a de.l.p., the set of rigorous consequences of P is deﬁned as CnR(P).

Definition 6 [CS00] Let P = hΠ,∆i a de.l.p.. We say that hA, Li is an argument structure for a ground literal L, if A is a set of defeasible rules of ∆, such that:

1. L∈CnR(Π∪ A) 2. CnR(Π∪ A) 6= Lit

3. A is w.r.t. inclusion, i.e., there is no A′ _{⊆ A} _{such that satisﬁes (1) and (2).}

We have brieﬂy presented the DeLP language and its operational and declarative game-based semantics. Now, we will be able of analyzing the system and studying its complexity.

## 4

## Discussion on

## GS

## Complexity

There are four ways to measure the complexity of evaluating queries in a speciﬁc language [Var82, PY97, DEGV01]:

• Data complexity: a speciﬁc query in the language is ﬁxed and we study the complexity

of applying this query to arbitrary databases. The complexity is then given as a function of the size of the databases.

• Program complexity or expression complexity: a speciﬁc database is ﬁxed and

we study the complexity of applying queries represented by arbitrary expressions in the language. The complexity is given as a function of the length of the expression.

• Combined complexity: considers both query and database instance as input variables.

Combined complexity is rarely diﬀerentiated from expression complexity.

• Parametric complexity: complexity is expressed as function of some reasonable

para-meters. For instance, the number of variables appearing in the query [PY97].

The main complexity measure for logic programming is combined complexity. Hereafter, when we refer to the complexity of a fragment of logic programming, we mean the following type of complexity [DEGV01]:

Complexity of (some fragment of ) logic programming: is the complexity of checking if

for variable programs P and variable ground atoms A, P |=A.

Consequently, as we are interested in computing the complexity of defeasible logic programming, and following the above principle, we will investigate if a query A is warranted by a de.l.p.

P = (Π,∆), denoted Π|=∆A, adapting [Cap03] notation.

DeLP is an skeptical reasoning system since every consequence of a defeasible logical pro-gram is analyzed considering all the arguments for and against it. The semanticsGS, a trivalued game semantics, characterizes such skeptical reasoning by the setT and F, since T ∪F is the set of all warranted literals, where F is the set of the complements of every member of F. Undecided literals are those literalsLfor which there is no warrant forLor for the complement of L. In this case we must contemplate two possibilities:

• The literal has an argument for or against it, but it is defeated.

Thus when considering DeLP in relation to game semantics, there are two relevant compu-tational problems to analyze:

• Deciding whether a formulaαbelongs to the setT or to the setF of a gameG(hA, Li,P)
won by the proponent P_{.}

• Deciding a formulaα belongs to the set U =Lit+

− {T ∪F} of undecided atoms in the G-model.

The former problem, hereafter called gamesat, involves ﬁnding just a game won by the pro-ponent, but in order to capture the latter it is necessary to ﬁnd all the games for the literal and for the complement of this literal and to prove that none of them is won by the proponent.

Arguments and counterarguments are the movements in the game. Thus, for analyzing the complexity we study the following decision problem: is a given subset A of ∆ an argument for a literal L? Accordingly with the deﬁnition of argument this problem has three parts: is

L a consequence of Π∪ A?, is Π∪ A consistent?, and is there a subset A′ _{of} _{A} _{such that it}

is consistent with Π and that together with Π derives L? In the next sections we present the main results of this work: this problem is in P; furthermore, deciding whether a literal is a consequence of a set of defeasible rules union Π is P-complete.

## 5

## The Complexity of Computing an Argument

Building arguments is the computational core of DeLP, for this reason this work analyzes the complexity of the following decision problem: whether a given subset of defeasible rules is an argument for a literal under a de.l.p.. As mentioned above, this problem can be divided in three parts according to argument deﬁnition.

Let P = hΠ,∆i be a de.l.p., L be a literal and A ⊆ ∆. First condition of deﬁnition 6, that involves rigorous consequences concept is h ∈ CnR(Π∪ A). In [CS00], we have

de-ﬁned a transformation Φ from a de.l.p. into a deﬁnite logic program, i.e., a logic program with just horn clauses. Brieﬂy, Φ transforms negated atoms in new atoms without negation, Φ(H—<B) = Φ(H) ← Φ(B) and all other rules or atoms remain the same. We will use this

transformation and the following lemma in order to reduce the rigorous consequences of ade.l.p.

into consequences of a propositional deﬁnite logic programming.

Lemma 1 Let DP be deﬁnite logic program and M be the minimal model of DP, then M=

CnR(DP).

We are interested in computing the time complexity of verifying whether L∈CnR(Π∪ A).

We shall construct a logic program with just Horn clauses, denoted HP(Π,A, L) such that

h∈CnR(Π∪ A) if and only if HP(Π,A, L)|=yes .

Suppose that L1, . . . , Ln are all the literals in Π∪ A. We deﬁne HP(Π,A, L) as follows:

HP(Π,A, L) = Φ(Π)∪Φ(A)∪ {yes←Φ(L)} ∪ {yes←Φ(Li),Φ(Li) : 1 ≤i≤n}

logic program DP satisﬁes a ground atom A, i.e., DP |= A, and hornsat, i.e., the decision problem of whether or not there is a truth assignment that satisﬁes a collection of horn clauses, are P-complete [DEGV01, PY97].

Lemma 2 HP(Π,A, L)is a reduction from L∈CnR(Π∪ A)into propositional logic

program-ming.

Proof: In order to prove our claim, we have to establish that:

1. L∈CnR(Π∪ A) if and only ifHP(Π,A, L)|=yes.

We will consider two cases:

• Π∪ A is consistent.

L ∈ CnR(Π ∪ A) if and only if Φ(L) ∈ Φ(CnR(Π ∪ A)) if and only if Φ(L) ∈

CnR(Φ(Π∪ A))(see [CS00]) if and only if, by theorem 1, Φ(L) is in the minimal

model of Φ(Π∪ A) if and only if HP(Π,A, L) |= yes by the deﬁnition of minimal model, the monotonicity property and the use of the ruleyes←Φ(L).

• Π∪ A is inconsistent.

L∈CnR(Π∪ A) = Lit if and only if there exists i,1 ≤i≤ n, such that Φ(Li) and

Φ(Li) are in Φ(CnR(Π∪ A)) if and only if Φ(Li) and Φ(Li) are in the minimal model

of HP(Π,A, L) if and only if HP(Π,A, L)|= yes by deﬁnition of minimal models, monotonicity property and the use of the rule yes←Φ(Li),Φ(Li).

2. HP is computed in logarithmic space: the transformation is quite simple and is feasible in logarithmic space, since rules can be generated independently of each other except those of the form yes←Φ(Li),Φ(Li) which depends on the literal in the input.

ThereforeHP(Π,A, L) is a reduction from L∈CnR(Π∪ A) into propositional logic

program-ming. ¥

Theorem 1 Let P = (Π,∆) a de.l.p., A ⊆ ∆ and L a literal. Determining whether L ∈

CnR(Π∪A) is P-complete.

Proof:

• Membership: The least ﬁxpointT∞

P of the operatorTP, given a deﬁnite logic programP

can be computed in polynomial time [Pap94, PMG98, DEGV01]: the number of iterations is bounded by the number of rules plus one. Each iteration step is feasible in polynomial time. Thus ﬁnding the minimal model of a logic program with just Horn clauses is in

P [DEGV01].

By lemma 2, L ∈ CnR(Π∪ A) has been reduced to propositional logic programming.

Therefore,L∈CnR(Π∪A) is in P.

• Hardness: Horn rules are strict rules in a de.l.p., and the minimal model of a deﬁnite logic programP is equal to CnR(P). Therefore, by applying reduction by generalization,

we have reduced P |= L to L ∈ CnR(Π∪A). Propositional logic programming is P

Algorithm: Minimal

Input: A an argument for a literal L, and Π a set of strict rules.

Output: true if A is a minimal argument for L, false otherwise

minimal=true Aux= A

While minimal and not Aux=∅do

selectH —<B ∈Aux

A′ =A − {H —<B}

if h∈CnR(Π∪A′) then minimal=false

else Aux= Aux - {H —<B}

Figure 1: Algorithm for verifying if a set of defeasible rules is minimal with respect to set inclusion for deriving a literal L.

¥

Until now we have proved that ﬁrst condition of argumentation deﬁnition is P-complete. In the rest of this section we will analyze complexity results over a de.l.p.P = (Π,∆), with m

atoms, n strict rules and k defeasible rules.

In Figure 1, we present an algorithm for verifying whether a set of defeasible rules is minimal with respect to set inclusion for entail a literal L. Worst case of the minimality condition is consider assuming that the argument has at most k defeasible rules, i.e., ∆ is an argument. Computing minimality condition involves k loops verifying that L∈CnR(Π∪A′), which is in

P. Thus, this problem is solvable in polynomial time and therefore, it is in P.

Finally, to check if the set of defeasible rules is consistent under a de.l.p., we verify that there is no atom such the atom and its complement are members ofCnR(Π∪A). In the worst

case, when CnR(Π∪A) is consistent, this algorithm must control every atom in the signature

of the de.l.p.. Thus, to check if it is consistent is proportional to the number of atoms and therefore is in P.

Both cases can be reduced to propositional logic programming. Because of lack of space we will not present in detail this development but we will explain it brieﬂy. We ﬁrst transform a

de.l.p. into a set of horn clauses. Strict rules Head ← L1, L2, . . . , Ln have been transformed

into

sr(Head,(L1,L2, . . . ,Ln))

and defeasible rules Head—<L_{1}, L_{2}, . . . , Ln have been transformed into

dr(Head,(L1,L2, . . . ,Ln))

Theorem 2 The decision problem “is a given subset of defeasible rules an argument for a literal under a de.l.p.?” is in P.

As a consequence of theorem 2, computing every movement in a game is tractable. However,

gamesatrequires to build every argument that is a response against each argument introduced
as a defeater of a previous move. Furthermore, we must also take into account the preference
criterion between arguments. Unlike the defeasible system analyzed in [Mah01] in which the
preference relation is static, DeLP′_{s comparison criterion is modular. Therefore, depending on}

what criterion is chosen, computation could become intractable. One of the criterion used as an example is generalized speciﬁcity [SGCnS02], and even though its complexity has not been analyzed, we conjecture that is not tractable.

## 6

## Conclusion and Future Work

We have analyzed DeLP through theGSsemantics, pointing out which decision problems must been studied. We have proved that computing rigorous consequences isP-complete and we have proved that the decision problem “whether a given subset of defeasible rules is an argument for a literal under a de.l.p.” is in Pand therefore, it is tractable. However we will be required to compute all the arguments for and against a literal for playing games. Considering the nonmonotonic formalisms complexity results [CS93] we believe that this problem is beyond the tractable class.

As future work, we will analyze the complexity of gamesatand the decision problem that deals with undecided literals and we will study the data complexity in order to compare the expressive power of DeLP and of other non monotonic formalisms.

### Acknowledgments

This research was partially supported by Secretar´ıa General de Ciencia y Tecnolog´ıa of the Universidad Nacional del Sur, by the Universidad Nacional del Comahue (Proyecto de Investi-gaci´on 04/E046) and by Agencia Nacional de Promoci´on Cient´ıﬁca y Tecnol´ogica (PICT 2002 No. 13096, PICT 2003 15043, PAV 076).

## References

[ABCMB04] Katie Atkinson, Trevor Bench-Capon, and Peter Mc Burney. A dialogue game protocol for multi-agent argument over proposals for action. Technical Report ULCS-04-007, Department of Computer Science, University of Liverpool, Liver-pool, U.K., 2004.

[BAV04] N. Bassiliades, G. Antoniou, and I. Vlahavas. A defeasible logic reasoner for the semantic web. In Proc. of the Workshop on Rules and Rule Markup Languages for the Semantic Web, pages 49–64, 2004.

[Cap03] Marcela Capobianco. Argumentaci´on Rebatible en Entornos Din´amicos. PhD thesis, Universidad Nacional del Sur, 2003.

[CM04] C. Ches˜nevar and A. Maguitman. ARGUENET: An Argument-Based Recom-mender System for Solving Web Search Queries. In Proc. of the 2nd IEEE Intl. IS-2004 Conference, pages 282–287, Varna, Bulgaria, June 2004.

[CS93] M. Cadoli and M. Schaerf. A survey of complexity results for nonmonotonic logics.

Journal of Logic Programming, 17:127–160, 1993.

[CS00] Laura A. Cecchi and Guillermo R. Simari. Sobre la Relaci´on entre la Deﬁnici´on Declarativa y Procedural de Argumento. InVI CACiC, Ushuaia, 2000.

[CS04] Laura A. Cecchi and Guillermo R. Simari. Sobre la relaci´on entre la Sem´antica GS y el Razonamiento Rebatible. In X CACiC - Universidad Nacional de La Matanza, San Justo - Pcia. de Buenos Aires, 2004.

[DEGV01] Evgeny Dantsin, Thomas Eiter, Georg Gottlob, and Andrei Voronkov. Com-plexity and expressive power of logic programming. ACM Computing Surveys (CSUR), 33(3):374 – 425, September 2001.

[DNT02] Yannis Dimopoulos, Bernhard Nebel, and Francesca Toni. On the Computational Complexity of Assumption-based Argumentation for Default Reasoning.Artiﬁcial Intelligence, 141(1):57–78, 2002.

[GJ79] Michael R. Garey and David S. Johnson. Computers and Intractability: A Guide to the Theory of NP-Completeness. W.H. Freeman and Company, 1979.

[GS04] Alejandro J. Garc´ıa and Guillermo R. Simari. Defeasible Logic Programming: An Argumentative Approach. Theory and Practice of Logic Programming, 4(1):95– 138, 2004.

[Lif96] Vladimir Lifschitz. Foundations of logic programming. In G. Brewka, editor,

Principles of Knowledge Representation, pages 1–57. CSLI Publications, 1996. [Mah01] Michael J. Maher. Propositional defeasible logic has linear complexity. Theory

and Practice of Logic Programming, 1(6):691–711, 2001.

[Pap94] Christos Papadimitriou. Computational Complexity. Addison-Wesley Publishing Company, 1994.

[PMG98] D. Poole, A. Mackworth, and R. Goebel. Computational Intelligence : A logical approach. Oxford University Press, 1998.

[Pol87] John Pollock. Defeasible Reasoning. Cognitive Science, 11:481–518, 1987.

[Pol95] John L. Pollock. Cognitive Carpentry. Mass: Bradford/MIT Press, Cambridge, 1995.

[SGCnS02] Frieder Stolzenburg, Alejandro J. Garc´ıa, Carlos I. Ches˜nevar, and Guillermo R. Simari. Computing Generalized Speciﬁcity. Journal of Applied Non-Classical Logics, 12:1–27, 2002.

[SL92] Guillermo R. Simari and Ronald P. Loui. A mathematical treatment of defeasible reasoning and its implementation. Artiﬁcial Intelligence, 53:125–157, 1992. [Var82] Moshe Y. Vardi. The complexity of relational query languages. In Proceedings

of the Fourteenth Annual ACM Symposium on Theory of Computing, STOC82, pages 137–146, New York, NY, USA, May 1982. ACM Press.

[Ver98] B. Verheij. Argumed - a template-based argument mediation system for laweyers. In J.C. Hage, T. J. Bench-Capon, A.W. Koers, C.N.J. de Vey Mestdagh, and C.A. Gr¨utters, editors, Legal Knowledge Based Systems. JURIX: The Eleventh Conference, pages 113–130, 1998.

### Appendix: Horn clauses to manage minimality and consistency

Reduction of minimality problem into propositional logic programming

% cons(L,A): is true whenever a literal L is consequences of the argument A % and the strict rules.

cons(L,A):-sr(L,B),consBody(B,A).

cons(L,A):-member(dr(L,B),A),consBody(B,A).

% consBody(B,A): is true if the body B of a rule is consequence of A % and the strict rules.

consBody(true,_).

consBody((A,B),RR)<-- cons(A,RR),consBody(B,RR). consBody(A,RR)<-- A\=(_B,_C),cons(A,RR).

%nocons(L,A) is true if L is not a consequence of an argument A. nocons(L,A):-nomember(dr(L,B),A),pi(Pi),nomember(sr(L,B),Pi). nocons(L,A):-member(dr(L,B),A),noconsBody(B,A).

nocons(L,A):-sr(L,B),B\=true,noconsBody(B,A).

% noconsBody(B,A): is true if he body B is not consequence of an argument A % and the strict rules.

noconsBody((A,_B),RR)<-- nocons(A,RR).

noconsBody((A,B),RR)<-- cons(A,RR),noconsBody(B,RR). noconsBody(A,RR)<-- A\=(_B,_C),nocons(A,RR).

% del_rule(AP,AP,L,A): is true if argument A, included in AP, has no % superfluous rule.

del_rule([],_,_,[]). del_rule(R,[],_,R).

del_rule([R|RR],RC,L,A)<-- cons(L,RR),delete(R,RC,RD),del_rule(RR,RD,L,A). del_rule([R|RR],RC,L,A)<-- nocons(L,RR),append(RR,[R],RI),delete(R,RC,RD),

del_rule(RI,RD,L,A).

% such that the literal L is a consequence. minimal(AP,L,A):-del_rule(AP,AP,L,A).

Reduction of consistent problem into propositional logic programming

% Complement of a literal with respect to strong negation. complement(no(L), L).

complement(L, no(L)).

% Consistency: consistent(A) is true if A is consistent consistent([]).

consistent(Arg)<-- atomCab(Atomos), consArg(Arg,Atomos,Cons), revCons(Cons,Cons).

% revcons(A,B) is true if for every element E in A, E and its complement % are member of B.

revCons([],_Cons).

revCons([C|RC],Cons)<-- member(C,Cons),complement(C,NC), nomember(NC,Cons),revCons(RC,Cons).

% consArgAux(Arg,Atomos,AtomsCons)is true if AtomsCons contains every atom % in Atoms such that it is consequence of Arg union strict rules set. consArgAux(_Arg,[],[]).

consArgAux(Arg,[no(A)|RA],[no(A)|RC])<-- cons(no(A),Arg), consArgAux(Arg,RA,RC). consArgAux(Arg,[no(A)|RA],RC)<-- nocons(no(A),Arg),consArgAux(Arg,RA,RC).

consArgAux(Arg,[A|RA],[A|RC])<-- cons(A,Arg), consArgAux(Arg,[no(A)|RA],RC). consArgAux(Arg,[A|RA],RC)<-- nocons(A,Arg),consArgAux(Arg,[no(A)|RA],RC).

% consArgAux(Arg,Atomos,AtomosConsecuencia) is true if AtomsCons contains every % atom in Atoms, without repeated elements such that it is consequence of Arg % union strict rules set.

consArg(Arg,Atomos,Cons)<-- consArgAux(Arg,Atomos,ConsArg), delete_repeated(ConsArg,Cons).

% atomCab(Atomos) is true if Atomos contais every atom in the head of a rule. atomCab(Atomos)<-- litCab([],L),achieve_atoms(L,Atomos).

% litCab(LA,LN) is true if LN contains all literals in the head of % defeasible and strict rules.

litCab(LA,LN)<-- dr(C,_B),nomember(C,LA),litCab([C|LA],LN). litCab(LA,LN)<-- sr(C,_B),nomember(C,LA),litCab([C|LA],LN). litCab(L,L).

% achieve_atoms(Lit,Atoms) is true if Atoms contains all the atoms achieve_atoms([],[]).