A 5" a4-

, fl. ,
«.(ns’m

 

4

O ' I I.
’3‘”...
x i

29365:; .-

A -_ A. ‘
“egzewt

J.—

_ I-

~.,-.

. .n.
5‘31"”-
4nf~

‘. "’4‘

‘Jvz. .
V; o ‘ ‘
aicfis *
i“ WA‘rw; "
4'“ - “ W: ‘

“7'11
.m‘nV
, ,

 

ifii

This is to certify that the

dissertation entitled

REASONING WITH CONTRADICTORY
DEDUCTIVE DATABASES

presented by

ANASTAS IA ANALYTI

has been accepted towards fulfillment
of the requirements for

PhD COWUTER SCIENCE

degree in

 

 

L": \E‘o’acmawv: \Q

 

 

Major professor

Date

 

MS U is an Affirmative Action/Equal Opportunity Institution 0-12771

 

 

 

» «iiiiiiiiiiiiiw

 

LIBRARY
Michigan State
University

 

 

 

PLACEfll-IETURNBOXto tomovo thloochockommmywrocad.
TO DA lDFINESrotumonor botmdoto duo.

DATE DUE DATE DUE DATE DUE

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

MSU IoAn Afflmofivo Action/Emu Oppomnlty Inothdlon
mm:

 

REASONING WITH CONTRADICTORY DEDUCTIVE
DATABASES

By

Anastasia Analyti

A DISSERTATION
Submitted to
Michigan State University
in partial firlfillment of the requirements
for the degree of

DOCTOR OF PHILOSOPHY

Department of Computer Science

1 994

ABSTRACT

REASONING WITH CONTRADICTORY DEDUCTIVE DATABASES

By

Anastasia Analyti

Deductive databases have become a dominant field of research in recent years because they provide
(i) an expressive environment for data modelling, (ii) a single, declarative language for expressing
queries, constraints, views, and programs, and (iii) a clear separation of declarative and procedural
concepts. A deductive database consists of two parts: a set of known facts, and a set of rules fi’om
which new facts can be derived. Consistency of derived facts is not a realistic assumption in many
applications. In the presence of contradiction, classical logic fails to give any semantics to the
deductive database. Thus, even a single erroneous datum could destroy all meaningful information.
The goal of this research is to derive useful information fiom a set of contradictory rules. In the
investigated framework, both negation by default and classical negation are supported. Rules are
equipped with a partial order expressing their relative reliability in case of conflict. In this thesis,
we propose the reliable semantics and contradiction-free semantics for contradictory deductive
databases. In the proposed semantics, a rule ordering based on reliability is used to choose between
conflicting rules. When no choice is possible, the conflicting rules are considered unreliable and
their conclusions are blocked. Conclusions from rules that do not contribute to the contradictions
are considered reliable and they are used for the derivation of new information. We give equivalent
fixpoint and model theoretic characterizations of the proposed semantics. For the contradiction-free

semantics we present an equivalent procedural characterization for computing answers to queries.

Both skeptical and credulous types of reasoning are considered. Some of the advantages of the
proposed semantics are: (i) they cover a broader domain of logic programs than those semantics
proposed earlier, (ii) they are well-defined for every contradictory program in this broader domain,
(iii) they extend several semantics proposed earlier, and (iv) they can be computed in polynomial
time with respect to the size of the program P when the Herbrand Base of P is finite.

A more general framework is presented where rules are encapsulated into modules. The
prospect of contradiction is even stronger when information is distributed in a set of modules. The
code of a module is usually hidden from other modules. Thus, modules export their results while
they hide the way these results are computed. A partial order expresses the relative reliability of
conclusions drawn by these modules. The semantics for this extended framework is called modular
reliable semantics. We present a fixpoint and model theoretic characterization of the modular
reliable semantics. This framework can be used to model multi-agent systems where the knowledge
of several experts is represented in a single system.

An application of the reliable semantics to deductive object-oriented databases is also
described. In deductive object-oriented databases, rule prioritization can be used (i) to express the
fact that specific rules are more reliable than general ones, (ii) to give priorities to inherited rules
that are in conflict as a result of multiple inheritance and (iii) to give priorities to class rules that

are in conflict as a result of multiple specializations of the same object.

To my parents

ACKNOWLEDGEMENTS

I would like to thank my advisor Dr. Sakti Pramanik for all his support in my academic and
personal life. He helped me build a strong background in the database area. He taught me how to
do research and attack problems. He helped me financially in all possible ways and gave me
emotional support when I most nwded. I would like to thank Dr. Herman Hughes, Dr. William
Punch, 111, Dr. Gerald Ludden, and Dr. Jacob Plotkin for serving as my committee members and
helping me in identifying some of the important issues investigated in this thesis. I would also like
to express my appreciation to the Computer Science Department and College of Engineering for
their financial support.

Many thanks go to Vasu Vuppala and Walid Tout for answering my numerous Unix-related
questions. My friends Argyrios Geralds, Michael Tomaritis, Mingxia Man, Divesh Srivastava, and
Anastassios Petropoulos have been a powerful source of support. Finally, I would like to thank my

parents for their encouragement in achieving my academic goals.

ii

TABLE OF CONTENTS

LIST OF FIGURES v
1 INTRODUCTION 1
l. 1 Problem Description . l
1.2 Overview of Semantics for Logic programs 2
1.3 Our Approaches for Avoiding Contradictions 9
1.4 Dissertation Outline . . . l4
2 RELIABLE SEMANTICS FOR EXTENDED LOGIC PROGRAMS WITH RULE
PRIORITIZATION 17
2.1 Introduction . . 17
2. 2 r-models for Extended Programs with Rule Prioritization. 18
2. 3 Reliable Semantics . . . 28
2.3.1 Reliable Model 28
2.3.2 Stable r-models . 34
2. 3. 3 Diagnosis Example . 39
2. 4 Related Work. . . 41
2. 4. l Three-Valued Stable Model Semantics . 41
2. 4.2 Answer Set Semantics . . 42
2 ..4 3 Extended Well-Founded Semantics 43
2.4.4 Relevant Expansion 44
2.4.5 Conservative Vivid Logic 44
2.4.6 Predicate Logic Extensions 45
2.4.7 Ordered Logic . 46
2.4.8 Default Logic . 50
2.5 Conclusions 53
3 MODULAR RELIABLE SEMANTICS FOR MODULAR LOGIC PROGRAMS WITH
RESULT PRIORITIZATION 55
3.1 Introduction . . . 55
3 .2 Informal Presentation and Intuitions . . 57
3. 3 m-models for Prioritized Modular Logic programs . 60
3 .4 Modular Reliable Semantics for Prioritized Modular Logic Programs 68
3.4.1 Reliable m-model . . . . 68
3. 4. 2 Stable m-models . 74
3 .5 Modular Reliable Semantics for Prioritized Extended Logic Programs 78
3 ..5 1 Definitions . . 79
3.5.2 Relationship with the Modular Reliable Semantics of Modular Logic Programs. 81
3 .6 Related Work. . . 84
3.6.1 Combining Multiple Deductive Databases . . 84
3. 6.2 A Distributed Assumption Truth Maintenance System. 86

TABLE OF CONTENTS

LIST OF FIGURES v
1 INTRODUCTION 1
l. 1 Problem Description . l
1.2 Overview of Semantics for Logic programs 2
1.3 Our Approaches for Avoiding Contradictions 9
1.4 Dissertation Outline . . . l4
2 RELIABLE SEMANTICS FOR EXTENDED LOGIC PROGRAMS WITH RULE
PRIORITIZATION 17
2.1 Introduction . . . . . . . l7
2. 2 r—models for Extended Programs with Rule Prioritization. . . . . . l8
2. 3 Reliable Semantics . . . . . . . . . . . . . 28
2.3.1 Reliable Model . . . . . . . . . . . . . 28
2.3.2 Stable r-models . . . . . . . . . . . . . 34
2. 3. 3 Diagnosis Example . . . . . . . . . . . . . 39
2. 4 Related Work. . . . . . . . . . . 41
2.4.1 Three-Valued Stable Model semantics . . . . . . . . . 41
2. 4. 2 Answer Set Semantics . . . . . . . . . . . 42
2. 4. 3 Extended Well-Founded Semantics . . . . . . . . . 43
2.4.4 Relevant Expansion . . . . . . . . . . . . 44
2.4.5 Conservative Vivid Logic . . . . . . . . . . . 44
2.4.6 Predicate Logic Extensions . . . . . . . . . . . 45
2.4.7 Ordered Logic . . . . . . . . . . . . . . 46
2.4.8 Default Logic . . . . . . . . . . . . . . 50
2.5 Conclusions . . . . . . . . . . . . . . . 53
3 MODULAR RELIABLE SEMANTICS FOR MODULAR LOGIC PROGRAMS WITH
RESULT PRIORITIZATION 55
3.1 Introduction . . . . . . . . . . . . 55
3. 2 Informal Presentation and Intuitions . . . . . . . . . 57
3. 3 m-models for Prioritized Modular Logic programs . . . . 60
3. 4 Modular Reliable Semantics for Prioritized Modular Logic Programs . . . 68
3 ..4 l Reliable m-model . . . . . . . . . 68
3.4.2 Stable m-models . . . . . 74
3. 5 Modular Reliable Semantics for Prioritized Extended Logic Programs . . . 78
3.5.1 Definitions . . 79
3.5.2 Relationship with the Modular Reliable Semantics of Modular Logic Programs. 81
3. 6 Related Work. . . 84
3.6.1 Combining Multiple Deductive Databases . . . . . . . 84
3. 6. 2 A Distributed Assumption Truth Maintenance System. . . . . . 86

3.7Conclusions...............87

4 CONT RADICT ION-F REE SEMANTICS FOR EXTENDED LOGIC PROGRAMS

WITH RULE PRIORITIZATION 89
4.1 Introduction. . . . . . . . . . 89
4. 2 c-models for Prioritized Extended Programs . . . . . . . . 90
4. 3 Contradiction-Free Semantics . . . . . . . . . . . 94
4. 4 Related Work. . . . . . . . . . . . 98
4.4.1 Semantics Covered in Section 2.4.. . . . . . . 98

4. 4. 2 Semantics Following the Contrapositive Rule Approach . . . . . 101

4 4. 3 Doyle's Truth Maintenance System . . . . . . . . . 102

4.5 Procedural Semantics . . . . . . . . . . . . . 106

4.6 Conclusions . . . . . . . . . . . . . . . 112

5 RELIABLE OBJECT LOGIC 115

5.1 Introduction . . . . . . . . . . . . 115

5. 2 Reliable Object Logic Programs. . . . . . . . . . . 117

5. 3 Reliable Semantics for ROL Programs . . . . . . . . . 121

5.4 Conclusions . . . . . . . . . . . . . . . 126

6 CONCLUSIONS AND FUTURE RESEARCH 127

A PROOFS OF SECTION 4.3 133

B PROPOSITIONAL PROOF THEORY AND PROLOG META-INTERPRETERS 139

8.1 Contradiction-Free Semantics . . . . . . . . . . . 139

8.2 Reliable Semantics . . . . . . . . . . . . . 142

BIBLIOGRAPHY 146

iv

LIST OF FIGURES

2.1 A digital circuit . . . . . . . . . . . . . . 39
3.1 DNA fragments . . . . . . . . . . . . . . 62
5.1 A class hierarchy . . . . . . . . . . . . . . 119

CHAPTER 1

INTRODUCTION

1.1 Problem Description

A deductive database is a set of sentences in a knowledge representation language. The knowledge
representation language that we consider here is logic programming. Logic programs represent
information about a problem in temrs of rules. The idea that logic can be used as a programming
language was introduced by Colmerauer and Kowalski [41]. The semantics of a logic program
specifies what is true or false and can be defined declaratively or procedurally. The declarative
characterization of a logic program is the specification of its "meaning" in terms of a fixpoint of an
operator (fixpoint semantics) or in terms of a particular set of interpretations satisfying certain
properties (model theoretic semantics). The procedural characterization of a logic program is
given through a query answering algorithm that receives as input a specific query and retums its
truth value.

Classical logic has been successful only in representing very precise reasoning such as that
found in mathematics. However, human reasoning is often based on conflicting evidence and on
assumptions which are not always valid. When a logic program is contradictory, instead of
discarding the whole program, we would like to separate the reliable from the unreliable part of the
information. This way, useful conclusions can be derived from the reliable information. The goal of
this work is to define semantics for logic programs that may be contradictory. The semantics
should extend well-known semantics for non-contradictory logic programs. We consider rules to be
defaults. Rule prioritization can be viewed as a tool to specify confidence information about these

defaults. Some of the reasons for rule prioritization are:

2

0 Dijkrence in the reliability of sources. It is possible that a number of sources provide
infomration about a particular topic. If the sources contradict, we wish to use ordering to resolve
conflicts.

o The dominance of specific over general information. Object-oriented programming is an
example where this principle is employed.

0 Regulation. Regulation can indicate the priority of different conflicting directives. For example,
university laws require that foreign students pay out-of-state tuition and TAs pay in-state tuition.
However, if a student is both foreign and TA, the directives for TAs are given higher priority
than the directives for foreign students.

The prospect of contradiction is even stronger when information is distributed in a set of
modules. The code of a module is usually hidden from other modules. Thus, modules export their
results while they hide the way these results are computed. When exported results are in conflict,

prioritization of results can express higher confidence in some results over others.

1.2 Overview of Semantics for Logic programs

A normal logic program P consists of a finite set of clauses of the form: At—L],...,L,,, where A is
an atom and ViS n, L,- is a literal, i.e., an atom or its negation. The atom on the left hand side of a
rule is called the head of the rule and is denoted by Head,. The expression on the right hand side of
the rule is called the body of the rule and is denoted by Body,. The Herbrand Universe of P is the

set of all ground (variable-fies) temrs which can be formed by using the constant and function
symbols appearing in P. The Herbrand Base of P ([1812) is the set of all ground atoms which can

be formed by using the predicates appearing in P with the terms in the Herbrand Universe of P.

A 2-valued model of a program P evaluates each literal in HBP as true (value 1) or false
(value 0). A 2-valued model M is represented as a subset of HBP where atoms in M are true and
atoms not in M are false. In contrast, a 3-valued model of P evaluates each literal in HBP as true
(value 1), false (value 0) or unknown (value 1/2) and is represented as a subset of HBP U ~HBP.

For any 3-valued model M, there is no atom A St. AeM and ~AeM. IfAeM then A is true, if

3

~AeM then A is false, and if neither AeM nor ~AeM then A is unknown. Let M be a 2-valued or
3-valued model of P. The truth value of a set of literals S w.r.t. M is defined as the least truth value
of the literals in S. Let M(S) denote the truth value of S w.r.t. M, where S is a literal or a set of
literals. Then, M(Head,)2M(Body,.), for every rule r in P.

Initial work on logic programming was only concerned with logic programs with no negation
(Horn logic programs). Inspired by SL-resolution [40] (linear resolution with selection function), '

Hill [33] developed a linear resolution procedure, called SLD-resolution (SL-resolution for definite
programs). A goal in an SLD-resolution is of the form (—Al ..... A", where A,- are atoms. An SLD-

refutation ofgoal G] = (-Al.....An is a sequence ofgoals 01,...,Gnv s.t. Gnv = (— and Vi<n', GM
is obtained from Gi= e—Bl,...,Bk as follows:
(i) Bm is an atom in 6,, called the selected atom,
(ii) 3 rule C(—C1,...,C1 in P and substitution at s.t. Ema,- =C9-,
(iii) Gi+r= (8],...,Bm_1,C1,...,C1,Bm+,..,Bk)6.
The sequence of substitutions 61,...,6nv,1 is an answer of goal G]. The SLD-resolution is sound and
complete for answering positive queries in Horn logic programs and less expensive than SL-
resolution.

van Emden and Kowalski [7 5] presented an equivalent fixpoint characterization of the positive

consequences of a Horn logic program. Specifically, let P be a Horn logic program and I an
interpretation of P. Then, the van Emden and Kowalski operator ‘Pp(1) is defined as follows:

‘Pp(1)={A| 3 rule Ae—A1,....An in P s.t. A,- is true w.r.t. I, ViSn}.

Let tip? 0(1)=1, rptml(1)= in an "(1))u‘I’T"(1), and imam: u{ siphon n<w}, where a) is the
first infinite ordinal. The positive consequences of P are defined as the least,1 fixpoint of ‘1’}; which
coincides with rapture). Thus, the positive consequences ofP can be obtained by iterating to times
the ‘PP operator.

 

1 We say that a model M of P is the least, model of P ifi'M(L)S M'(L) for any model M' and
classical literal L of P.

If logic prograrnnring is to be useful in practical situations, it must be able to represent
negative information. There are two ways in which one can represent negative information:
(i) By allowing the explicit representation of negative information (explicit negation).

(ii) By introducing a metarule which infers negative information (negation by default).

According to the first approach, negative information is represented explicitly by allowing
classical negation in the heads and bodies of the rules. A disadvantage of this approach is that it is
not feasible to include in the logic program every piece of negative information in the problem
domain. For example, the amount of negative infomration that applies to any individual is limitless.
For this reason, the idea of introducing a metarule which infers negative information, not explicitly
specified in the logic program, was conceived.

Reiter [3 9] introduced the closed world assumption (C WA) metarule. According to the C WA,
~A is inferred from a Horn logic program P if A is not classically provable fi'om P, i.e., A is not
true in all 2-valued models of P. However, when negations are present in the bodies of the rules
(normal programs), the C WA generally leads to an inconsistent theory. For example, if
P={p<—~q.} then P has two 2-valued models {p} and {q}. Consequently, CWA(P)={~p, ~q} and
PUCWA(P) is inconsistent. Several senrantics for normal programs have been proposed. A weaker
form of the C WA, called negation as finite failure (NAP), was developed by Clark [16]. According
to NAF, a ground literal ~A is inferred when the proof of A using SLD-resolution fails finitely.

Clark, augmented SLD-resolution with the NAF rule. The augmented resolution was named
SLDNF-resolution (linear resolution with selection function for definite clauses using negation-as-
failure) by Lloyd [45]. For example, in the program P={p(—~q.}, the SLDNF-resolution will infer
thatqis falseandpistrue. Clark definedthemodel theoretic semantics ofanonnal program using
the completion of the program and proved the soundness of the SLDNF-resolution w.r.t. this
semantics. The idea behind the completion of a program P is that the disjunction of the bodies of

theruleswithheadanatomAcanbeviewedasnecessaryconditionforAtobetrue.Inother
words, if{A(—Bodyn,...,A<—Body,.n} isthesetofrules inPwithheadA thenthestatementAt—r

5
Body,.,v...vBody,.n is assumed to hold. This implies that negative infomration about A (A is false)

eanbeinferred ifnone ofthe bodies ofthe rules with headA is true.

Unfortunately, Clark's semantics has some serious drawbacks [61]. One of them is that the
Clark's completion of a program P is often inconsistent, i.e., the completion of P may not have any
2-valued models. In this case, the semantics of P is considered undefined. For example, the
completion of P={a<—. pe— ~p.} is {at—mac pH ~p.} which is inconsistent. Thus, P is not
given any semantics even though a should intuitively be true. Moreover, if the meaningless rule
pt— p is added to P then the completion of the new program is {ae—Mrue. pH~pr.}. The
semantics of P u{p(— p} is (a, p} even though the semantics of P should not have been changed

with the addition of rule pe—p.
Apt, Blair and Walker [7] split the program rules of a normal program P into layers $1,...,S,,

so that the negative predicates in the body of a rule in layer S,- are defined in layers below Si. Then,
they define: IS, =‘1"5175‘40), 132=‘I’32TW(IS, ), 1s..=‘f’s..T“’(Is...)-

The literal set 13,, is proved to be a minimal 2-valued model of P. The meaning of the program P is
defined as that represented by 13". Programs that can be split the above way, i.e., programs free
from recursion through negative predicates, are called stratified. Though this semantics is widely
accepted, not all logic programs with an intuitive meaning are stratified. Przymusinski [57] defined
the perfect model semantics and extended the previous semantics to a larger subclass of programs,
called locally stratified programs. A program P is locally stratified if it is possible to split HBP
into disjoint sets $1,...,Sa,..., so that for every rule A(—A1,...,An,~Bl,...,~Bm in P, where At: Bi are
atoms, the following are true:

(i) ViSn, stratum(Ai) S stratum(A),

(ii) VjSm, stratum(Bj) < stratum(A),

where stratum(A)=a ifi‘ the atom A belongs to Sa.

However, there are progranrs that are not locally stratified but have an intuitive meaning. For
example, the program P={p(—-—q,a. q<—~p.} is not locally stratified but the SLDNF-resolution
willinfcrthattheatomsa,parefalscandatomqistrue.

van Gelder, Ross and Schlipf [76] define the well-founded semantics (WES) which
characterizes all normal programs. The WFS is the least2 fixpoint of a monotonic operator W p.

The W F(J) operator is defined as follows:

0 T(J)== {LI 3 rule r: Le—L1,...,L,, in P s.t. Lie 7W, ViSn}.

0 F(J) is the greatest set S of classical literals s.t. VLe S, if r is a rule in P with Headr=L then
ElL'e Body, s.t. L'e S or ~L'e J.

o W p(J)=T(J)U-F(J).

The transfinite sequence {la} is defined as follows: 10={ }, Ia+l=Wp(Ia) and Ia= U{Ib | b<a}
if a is a limit ordinal. Let d be the least ordinal s.t. 1d+1=1d- The WFS of P is the meaning
represented by Id. Since W p is monotonic, the least fixpoint of W p exists but it may not be
reached at a). where to is the first infinite ordinal. The WFS is a 3-valued model of P, denoted by
WFIWP. The WFS extends the perfect model semantics [57] for locally stratified programs and
gives more intuitive results than the Clark semantics [16]. The WFS is accepted by a large number
of researchers but some argue that it is very "weak" because it does not assign the truth value true
or false to all the atoms that should intuitively have one. For example, the WES of h{p(—~q.
q<—~p. at—p. at—q.) is {} though a should be true either p is true or q is true.

Gelfond and Lifschitz [26] give the definition of a stable model of a normal program P. They
define the Pl] transformation, where I is a 2-valued interpretation, as follows:

(i) Remove from P all rules that contain in their body a default literal ~L s.t. I(L)=l.

(ii) Remove from the body of the remaining rules of P any default literal ~L s.t. 1(L)=0.
A stable model is a 2-valued interpretation M that satisfies leastv(P/M)=M where leastv(P/M)

is the least, model of the positive program P/M. It can be shown that a 2-valued interpretation
M={L1,...,L,,} is a stable model 0 fP ifl‘for each L,- there is at least one rule in P with head L;
whose all body literals are true w.r.t. M and all positive body literals are in {L1,...,Li,1}. A

disadvantage of the stable model semantics is that a nomral program may not have any 2-valued

 

2AsetIistheleastclementofasetIiferIandIcJ,forallJeI.

7

stable models. Przymusinski [60] generalizes the definition of a 2-valued stable model to that of a
3-valued stable model. He shows that every normal program P has a 3-valued stable model and
that the W3 of P is the intersection of all of its 3-valued stable models.

All of the above semantics take into account the positions of the atoms in the rules. For
example, let P={p<—~q. }. Then, P is classically equivalent to {pvq.} and has two minimal
classical models {p} and {q}. Yet, all of the above semantics for normal programs agree that in the
intended semantics for P, q is false because there is no information indicating that q is true. Since q
is false, p is derived from the unique rule of P. Przymusinski [5 7] argues that the syntax of the
rules determines the relative priorities among atoms for truth value minimization. Specifically, let
A beanatomandraruleinPthen
0 1f~A is in Body, then A has higher priority than Head,.

0 If A is in Body, then A has no less priority than Head,.
Thus, inP={p(—~q.}, the trutlrvalue ofq is nrininrizedfirstandq is evaluated as false. Then,p is
evaluated as true because ofthe rulep<—~q.

Normal programs support only negation by default. Gelfond and Lifschitz [26] introduce the
extended programs which contain explicit negation in addition to negation by default. Thus,
extended programs provide negative information both implicitly (negation by default ~) and
explicitly (classical negation a). Classical negation is needed: (i) in case of incomplete information,
since it may not be justified for a particular infomration to be considered false because of absence
of further infomration (closed world reasoning), (ii) when negative infomration should be inferred if
some conditions are satisfied, for example, alight_off (— light_on, and (iii) to represent default
reasoning and exceptions, for example, some of the exceptions of the general rule fly(X)<— bird(X)
are: ‘ffly(X)<- ostrich(X) and *fly(X)t— penguin(X). V

Several semantics for extended programs have been proposed in the literature [60, 27, 20, 52,
55, 54, 79, 21, 77]. Yet, these semantics are not defined for all extended programs. In [60], the
well-founded model (WP) [76] of an extended program P is computed as that of a normal

program after replacing every literal -L of P with a new atom —I_L. Yet, the well-founded model of

an extended program can be contradictory. For example, the well-founded model of P={-p(—~a.
p(—. b<—.} is {~a, "p, p, b} and because of the contradiction, P is not given any semantics in
[60]. However, intuitively, the rule b(— is not "suspect" for the violation of the constraint .l.<—p,-p
and thus b should be true. Moreover, it is possible that the W3 of an extended program is not
coherent. The coherence property supports the intuition that if a literal is explicitly false then it
should also be false by default. For example, the W3 of P={-'p(-. p(—~p. a(-—~p.} is {"p}
indicating that -'p is true but the truth values of p and a are unknown. However, intuitively, if “p is
true, p should be false and a should be evaluated as true. The extended well-founded semantics
[54] extends the WFS for nomral programs and achieves coherence by enforcing the inference rules
{~L(—-'L| Le HBP} (coherence rules).

Gelfond and Lifschitz [27] define the answer set semantics for extended programs by
extending the PI] transformation [26] to extended programs P. Let P be a positive program. Then,
a(P)=def HBp if least,(P) contains a pair of complementary literals. Otherwise, a(P)=def least,(P).
An answer set of an extended program P is a 2-valued interpretation M that satisfies a(P/M)=lll
(classically negative literals in HM are considered as new atoms). The answer-set semantics of an
extended program is defined as the intersection of its answer-sets. If HBP is an answer set of P thm
P is called contradictory. The answer set semantics of a contradictory program is meaningless
because it implies every literal in 173,). For example, the answer set semantics of P={'~p<—. p(—.
a(—.} is HBP.

The contradiction removal semantics (CRS), defined in [52, 55], extends the WFS for normal
programs and avoids contradictions brought about by C WAs. For example, the CRS of
P={-p(—~a. p(-—. b<—.} is {p, b} which is non-contradictory. Yet, the problem of
contradictions is not totally solved since no semantics is given to P' ={-'p<—. p(—. b<—.} even
though b should be true. The same arguments hold for the argumentation semantics defined in
[21].

9

1.3 Our Approaches for Avoiding Contradictions

In this section, we give the underlying intuitions of our approaches for handling contradictions in

logic programs. Consider the program
P={r1: a<-. r2: b(—-. r3: pt— a. r4: ap<—. r5: ct— p. r6: d(— “'p.}.

All literals a, b, p, “p, c, d are evaluated as true in WMP. Thus, according to the WFS, both of
the complementary literals p and “p are true. Moreover, the literals p and “p are used to infer
literals c and d using nrles r5 and r6, respectively. However, because of the contradiction and the
fact that there is no information about the relative reliability of the rules, the truth values of p and
“p should be unknown and all derivations using literals p and “p should be blocked. Thus, all
literals p, “p, c, d should be evaluated as unknown. Generally speaking, in the desired semantics of
an extended program, no literal should be evaluated as true if its derivation is based on
contradictory infomration. Note that according to the W3 of P, literal a is true. Though the
derivation of a is not based on contradictory information, the literal a contributes to the derivation
of the pair of complementary literals {p, Hp}. Thus, it is possible that the information of rule r1 is
faulty. In other words, rule r] should be considered unreliable and literal a should be evaluated as
unknown. It is our belief that in case of contradiction, we should not only restrict inferences from
contradictory literals but also from literals (possible sources of the contradiction) contributing to
the derivation of contradictory literals. Literal b should be evaluated as true because it is neither a
source of a contradiction nor its derivation is based on contradictory information. In other words,
rule r2 is reliable.

Since there is no information about the relative reliability of the rules, all rules r1, r3, and r4
are unreliable. In our proposed semantics, if rule r4 has higher priority than rule r, or r3 then r4 is
consideredreliableand-‘pisevaluatedastrue. This isbecausethe WFSofthe rules inPwith
priority no lower than r4 is non-contradictory. If nrle r1 has higher priority than rule r3 or r4 then
r1 is considered reliable and a is evaluated as true. Otherwise, r1 is considered unreliable.

Let P be an extended program and S a set of literals. A dependency path T of a literal L w.r.t.
S is a sequence of goals 61,...,G,, defined as follows: (i) Gl= (—L, (ii) ViSn, all literals in G, are in

10

S, and (iii) V1<i$n, G,- results from GM by replacing a literal L' in GM with the literals in the
body of a rule r in P U{~L(—"‘LI Le HBp} which has head L' (this is called expansion of L' using
rule r). We say that a literal L' contributes to the derivation of a pair of complementary literals {L,
“L} in S if there is a dependency path T of L or -'L w.r.t. S s.t. L' is a member of a goal in T. For
example, let P={r1:p(-— ~a, b. r2: “pt—a r3: b<—.} then a dependency path of p w.r.t. WFMP
={~a, p, "p, b, -u, ~-'b} is: Gl=p<—, Gz= (- ~a,b. Since {p, Hp};WPMp and b is in 62, we
say that b contributes to the derivation of {p, *p} in WFMP.

Let P be a program with contradictory well-founded model. We will take two approaches in
order to avoid the contradiction. According to the first approach, a C WA ~Le WFMP is evaluated

as true only if ~L is reliable, i.e., it does not contribute to the derivation of any pair of
complementary literals in WFMP. When all literals in the body of a rule r are true, Head, is

evaluated as true only if r is reliable, i.e., Head, does not contribute to the derivation of any pair
of complementary literals in typing), where P, is the set of rules in P with priority no lower than
r. Let I be a set of literals evaluated as true. Rules with head in {*Ll LEI} are called blocked w.r.t.
I. Literals that are not reliable in P may be reliable in P,, where P, equals P minus the blocked

rules w.r.t. 1. Thus, an iterative process can be defined starting from the empty interpretation until
a fixpoint is reached. Specifically, we define the monotonic operator WP(1) which intuitively
contains all literals in WFMp, which are reliable. The meaning of P is the least fixpoint of Wp(l).
For example, consider the program P ={ r1: -ra(—. r2: at— “p. r3: -'p(-. r4: p(—.} and
assume that r3 has lower priority than r4. Then, WFMP ={m, “p, p, a} which is contradictory.
Rule r1 is unreliable in P9 because rip,,Tw(o)={p, "p, a, -'a} and Head,., = "'a contributes to the
derivation of {a, pa}. Similarly, rule r3 is unreliable in P0. In contrast, rule r4 is reliable in P0
because rpjaxch} which is consistent. Thus, wp(o)={p}. Let 1=wp(o). Since rule r3 is
blocked w.r.t. I, P, = {r1: -u(—. r2: at— "p. r4: pt—.}. Since WFMp, = {-la, p, ~a, ~wp}
which is consistent, nrle r1 is reliable in P1. Thus, WpT3(O)=WpTZ(O)= {-a, p, ~a, ~ap} and the

sernantiee of P is {-a, p, ~a, ~ap}.

11

When a literal L in a goal of a dependency path 7‘ is expanded using a rule r, not all literals in
Body, should always be included in the expansion. For example, let r be a rule in P s.t. Head, is

true independently of the truth value of a literal Le Body, Then, L should not be included in the

expansion of Head, using rule r. For example, assume P contains the rule r: ce—a,-b where a and

b are the inputs and c is the output of an OR gate. Note that if a is true then the head c of r is true
independently of the truth value of literal "b. Thus, the literal -'b should not be included in the
expansion of c using rule r. The same is true in the case of general rules and exceptions. For
example, consider the rules r1: burns(X)(—-match(X), r2: match(a)<-—, and r3: “bums(a)<—. Though
we have the information that a does not bum, it is possible that we do not want to consider the
information match(a) as unreliable because a may be a wet match. Thus, match(a) should not be
included in the expansion of bums(a) using nrle r1. Because of the above arguments, it is our
belief that the user should be able to decide which literals in the bodies of the rules should be
included in the expansion of a literal in a dependency path.

A problem of this approach is that if the WFM of a program P is consistent then every literal
Le WFMP is considered reliable even when “L cannot be false. For example, consider the program

P ={r1: p(- ~p. r2: ‘gt—p. r3: q.}. Since WFMP = {q, ~ap}, the semantics of P according
to the first approach is {q, ~-'p}. Thus, q is evaluated as true even though for p either true or false,
“'q is derived fiom rules r1 and r2. Since r3 does not have higher priority than the other rules, it is
arguable that q should not be considered reliable and the truth value of q should be unknown. This
viewpoint is adopted by our second approach for avoiding contradictions.

In our second approach, the derivation of contradictory beliefs is avoided by expanding the
original program P with the contrapositives of its rules. The expanded program is denoted by
exp(P). For example, if
P ={switch_ont—.

light_on<—switch_on, ~broken.

light_ofl<—.

alight_ofl<—light_on.

12

“light_on(-—light_off.

}
then WFIMP ={switch_on, light_on, light_ofif clight_on, alight_ofif ~—~switch_on, ~broken,
~abroken} which is contradictory. However, Wlilltlexpab)= {switch_on. broken, lightgofl
alight_on, ~light_on, ~alight_ofif ~aswitch_on, ~abroken},
where exp(P)= P u { brokent—switch_on, alight_on. aswitch_on<—-light_on,~broken. }.
WFMMP) is consistent and gives the intuitive results.

Not all of the contradictions can be resolved this way. For example, consider
P ={switch_ont—-.

light_ofl(—.

light_on(—.

alight_oflt—light_on.

alight_ont—It'ght_oflf

}
then exp(P)=P and WEI/Imp): {switch_on, light__on, light_ofl§ alight_on, alight_ofl,'
~-'swttch_on} which is contradictory. To avoid the contradiction, we take the following approach.
Whmallliterals inthebodyofaruleraretrue,theheadL ofris evaluatedastrueonly if-'L is c-
unfounded w.r.t. r, i.e., it cannot be derived from the set of rules in exp(P) with priority no lower
thanrandthecohererrce rules. Letheasetofliterals evaluatedastrue. Then, ruleswithheadin
{"Ll L61} are considered blocked w.r.t. I. Literals that were not c-unfounded in P may be c-
unfounded in P], where P, equals P minus the blocked rules w.r.t. 1. Thus, an iterative process can
be defined starting from the empty interpretation until a fixpoint is reached, similarly to the first

approach.
Not all contrapositivea of a nrle should always be considered. Let r be a rule in P s.t. Head, is

true independentlyofthetruthvalueofaliteralLinthebodyofr. Then,thecontrapositiveofr
with head “L should not be added to exp(P). For example, assume P contains the rule r". ct—arb

whereaandbaretheinputsandcistheoutputofanORgate.Notethatifinputaistruethen

 

Willi
W:

“P

Corr

higher

Pengul

13

output c is true independently of the truth value of input “b. Because of this, the contrapositive
b(—a,-'c of r is meaningless. Consider the general rule bums(X)(—match(X). If we know that
something does not burn we might not want to derive (from the contrapositive of the rule) that it is
not a match because it may be a wet match. Because of the above arguments it is our belief that the
user should decide if the contrapositive of a rule should be considered or not.

A problem of the second approach for avoiding contradictions is that by taking the
contrapositives of the nrles, some of the priorities of the atoms based on their positions in the rules
are lost. For example, consider
P ={rl :fly(X)<— bird(X), ~ab1(X).

r2: *fly(X)(— penguin(X), ~ab2(X).

r3: ab1(X)(—penguin(X), ~ab2(X).

r4: penguin(a)(—.

}
then WFMp={penguin(a), ~ab2(a), abl(a), afly(a), ~apenguin(a), ~-ab2(a), ~'~ab1(a), ~fly(a)}
which is non contradictory. The semantics of P according to the first approach coincides with
WFMP which is the intuitively correct semantics. However, WFMMP): {penguin(a),
-~penguin(a)} and thus, rrreaningful information in P is lost in mm” This is becausc in P,
the atom ab2(a) is given higher priority for truth value minimization than the atom ab1(a).
Consequently, in WFMP, ab2(a) is evaluated as false and ab1(a) is evaluated as true. However, by
taking the contrapositive of rule r3 in exp(P), this syntactically determined priority is lost.

In both of the above approaches, some of the conflicts can be resolved by considering the
partial ordering of rules (rule prioritization). For example, if the rule "fly(X)(—penguin(X) is given
higher priority than the more general nrle fly(X)(—bird(X) then we will correctly derive that
penguin a does not fly. However, not all of the conflicts can be resolved using the priorities of the
rules.

14

1.4 Dissertation Outline
The Chapters in this thesis are outlined as follows:

Chapter 2 develops the reliable semantics (RS) for extended programs with rule prioritization and
integrity constraints (EPP). RS avoids contradictions by taking the first approach presented in
section 1.3. The concepts of reliable rule and reliable default literal w.r.t. an interpretation are
developed. These are used in the declarative definition of RS. We give both a fixpoint and model
theoretic characterization of the reliable semantics and prove that they are equivalent. The model
theoretic characterization of the RS of an EPP, P is given by defining the stable r-models of P. We
prove that RS is the least stable r-model of P. RS is shown to be a generalization of (i) the well-
founded semantics for normal programs [7 6], (ii) extended well-founded semantics for non-
contradictory extended programs [54], and (iii) ordered logic for ordered logic programs [24, 43].
Other related work is also discussed. Appendix B contains a prolog program which works as an RS

inference engine for propositional EPPs.

In Chapter 3, the reliable semantics is extended to a class of programs, called prioritized modular.

logic programs (PAfl’s). The semantics of the extended class is called modular reliable semantics
(AIRS). A PMP consists of a set of modules and a partial order <def on the predicate definitions

(Mp), whereMis a module andp is a predicate exported by M. When a conflict occurs, <M

expresses our relative confidence in the predicate definitions contributing to the conflict. The
concept of reliable indexed literal w.r.t. an interpretation is developed. This is used in the
declarative definition of MRS. We present both a fixpoint and model theoretic characterimtion of
the reliable semantics and prove that they are equivalent. The model theoretic characterization of
the MRS of P is given by defining the stable m-models of P. MRS is shown to be the least stable m-
nrodel of P. We show that under certain conditions a PMP can be translated to an equivalent
extended program with rule prioritization. The use of MRS for modelling multi-agent systems is

15

presented. Related work on combining multiple deductive databases and maintaining consistency in

a distributed environment is discussed.

Chapter 4 develops the contradiction-free semantics (CPS) for extended programs with rule
prioritization. CPS avoids contradictions by taking the second approach presented in section 1.3.
The concept of c-unfounded literal w.r.t. a rule and an interpretation is developed. This is used in
the declarative definition of CPS. We give both a fixpoint and model theoretic characterization of
CPS and prove that they are equivalent. The model theoretic characterization of the CPS of a
program P is given by defining the stable c-models of P. CPS is shown to be the least stable c-
model of P. We show that CPS generalizes (i) the well-founded semantics for normal programs
[76], (ii) ordered logic for ordered logic programs [24, 43], and (iii) strong belief revision
semantics for extended programs [79]. Other related work is also discussed. The SLCF-resolution
(linear resolution with selection function for contradiction-flee semantics) for computing answers
for extended programs with rule prioritization is presented. The SLCF-resolution is shown to be
sound and complete w.r.t. CPS. Appendix A contains the proofs of section 4.3. Appendix B
contains a proof procedure and the corresponding prolog program which works as an CPS

inference engine for propositional programs.

Chapter 5 describes an application of RS to deductive object-oriented databases. An object-oriented
logic programming language, called reliable object logic (ROL) is presented. In ROL, data and
behavior are encapsulated into classes which are structured in a generalization lattice. Object-
registration rules are used to register an object to a class or to exclude it from a class. Method rules
define the behavior of the objects of a class. Method rules are inherited from the superclasses to
subclasses. Every ROL program P can be translated to an equivalent EPP, P'. The RS of P is
defined as the RS of P'.

16

Parts of the thesis have been published as follows. The content of Chapter 2 appears in [3, 6].

The content of Chapter 3 appears in [5]. The content of Chapter 4 appears in [4].

CHAPTER 2

RELIABLE SEMANTICS FOR EXTENDED LOGIC
PROGRAMS WITH RULE PRIORITIZATION

2.1 Introduction

Several semantics for extended programs have been proposed in the literature [60, 27, 20, 52, 55,
54, 79, 21, 77]. Yet, these semantics are not defined for all extended programs. In [60], the well-
founded model [76] of an extended program P is computed as that of a normal program after
replacing every literal -'L of P with a new atom —i_L. However, the well-founded model of an
extended program can be contradictory. For example, the well-founded model of P={*~p<—-a.
p(-—. b<—.} is {~a, “p, p, b} and because of the contradiction, P is not given any semantics in
[60]. Yet, intuitively, the rule b(—- is not "suspect" for the violation of the constraint it—prp and
thus b should be true.

The contradiction removal semantics (CRS), defined in [52, 55], extends the well-founded
semantics [76] and avoids contradictions brought about by C WAs. For example, the CRS of
P--{-p<—~a. p(—. b(-.} is {p, b} which is non-contradictory. Yet, the problem is not totally
solved since no senranties is given to P' ={-p(—. p<—. be.) even though b should be true. The
same arguments hold for the argumentation semantics defined in [21].

Prioritization of defaults is investigated in [42, 24, 25, 11, 12, 43, 64, 65, 66]. Yet, negation
by default is not considered in these works. In [42, 24, 25, 43], alternative semantics for ordered
logic programs are presented. A default in an ordered logic program is a unidirectional rule. In [11,
12],adefaultisaclause,thatis,thereisnodistinctionbetweentheheadandthebodyofadefault
rule. The work in [65, 66] is the most general from the point of view that defaults are general

17

18

formulas and when a default instance cannot be satisfied, partial satisfaction of it, is considered. A
conceptualization of both implicit and explicit preferences on data is given in [35].

An extended program with rule prioritization (EPP) consists of a set of partially ordered
rules and a set of constraints. In this chapter, we define the reliable semantics (RS) for EPPs. RS
extends the well-founded semantics [76] and the extended well-founded semantics [54] to EPPs.
The RS of an EPP is always defined and does not violate any constraint. Every EPP has at least
one stable r-model. The RS of a program P is the least fixpoint of a monotonic Operator and the
least stable r-model of P. All ordered logic program can be seen as an EPP which is fi'ee of default
literals, S,={} V rule r, and all constraints are of the form: .Lt—LrL. If P is an ordered logic
program then the RS of P coincides with the skeptical c—partial model of P [24] and is a subset of
the well-founded partial model of P [43]. When the Herbrand base of an EPP is finite, the

complexity of computing RS is polynomial w.r.t. the size of the program.

2.2 r-models for Extended Programs with Rule Prioritization

Our alphabet contains a finite set of constant, predicate and variable symbols from which terms
and atoms are constructed in the usual way. A classical literal is either an atom A or its classical
negation “A. The classical negation of a literal L is denoted by “L and -'(-'L) =L. The symbol ~
stands for negation by default and ~(~L) =L. A default literal is denoted by ~L, where L is a

classical literal.
An extended program with rule prioritization (EPP) is a tuple P=<Rp,ICp,<R>. R p is a

finite set of rules r: Lot— L1,...,Lm,~Lm+1,...,~L,,, where r is a label and L,- are classical literals.
Every rule r has a corresponding set S, cBody,, called the preliminary suspect set of r. ICp is a
finite set of constraints .l.<—L1,...,Lk, where L; are classical literals. The precise meaning of S, will
be given in the definitions. Intuitively, when a constraint .Lt—Ll....,Lk is violated, the rules used in
the last step of the derivation of L,- are considered "suspect." Ifa rule r is "suspect" for a constraint
violation then the rules and CWAs used in the last step of the derivation of literals in S, are also

"suspect."

19

The values of S, depend on the reasons for a constraint violation. There are two basic views
on the reasons for the violation of a constraint J.<—L1,..,Lk: (v1) rules used in the last step of the
derivation of L,- are incomplete1 or (v2) CWAs and/or rules used in same step of the derivation of
L; are unreliable. According to the first view (v1), the skeptical meaning of the program P' ={rlz
a<—. r2: b<—. r3:p(—a. r4: “pt—b} is {a, b}. Rules r] and r2 are not used in the last step ofthe
derivation of p, -'p and thus according to (v1), they are reliable. On the contrary, rules r3 and r4
are used in the last step of the derivation of p, “p and thus they are considered incomplete, i.e., r3
should be pt—a,~b or r4 should be "pt—bra. Consequently, the literals a, b are evaluated as true
whereas both p and “'p are undefined. View (v1) is implied by ordered logic [24, 43] and vivid
logic [77] and becomes explicit in our framework when S,={} V rule r. For example, if S,,={},
Vis4 then rules r3 and r4 are "suspect" for the violation of .Lt—p,‘*p. However, rules r1 and r2 are
not "suspect" because the literals a and b do not belong to S,3 or S”. According to the second view
(v2), which is more conservative than (v1), the skeptical meaning of P' is {}. This is because all

rules in P' are used in the derivation of p, "p and thus all rules in P’ are considered unreliable.

View (v2) becomes explicit in our framework when S,=Body,, V rule r. For example, if Sn
=Body,, , ViS4 then not only nrles r3, r4 but also r1, r2 are ”suspect” for the constraint violation.

Other views corresponding to S, ${} and S, tit-Body, for a rule r are also possible. For
exarnple, consider the program P'={r1: a(—. r2: b(—. r3: “p<—. r4: pt—a,b.}. If S,4={a} then
rule r, is "suspect" for the violation of .Lt—prp and rule r2 is not. Consequently, the skeptical
meaning of P' is {b}. Similarly, if S,4={b} then the skeptical meaning of P' is {a}.

The relation <R :RPXR p is a strict partial order (irreflexive, asymmetric and transitive),
denoting the relative reliability of the rules. Let r and r' be two rules. The notation r<r' mans that
r is less reliable than r', that is, r<r' iff(r,r')e<n. The notation r it r'means that r is not less

reliable that r'. Note that, r it r since <R is irreflexive. Intuitively, a rule r is considered reliable if

 

1 We say that a rule is incomplete if not all possible exceptions are enumerated in its body.

lib

20

it is not "suspect" for any constraint violation caused by rules with priority no lower than r. Thus,

deciding if a rule r is reliable depends only on the rules r' it r.
The set of instantiated classical literals of P is called the Herbrand Base (HBP) of P. The

constraints in BC p={.L(-L,"Ll Le HBp} are called basic constraints. We assume that BC p :1Cp.
An EPP, P, is called extended iff [C p =BC p and <R={ }. An extended program P is called normal
ifl‘ rules in P are fiee of classically negative literals. If S is a set of literals then ~S=de,{~L| Le S}
and “Sad-"Ll Le S}.

The instantiation of an EPP, P, is defined as follows: The instantiations of Rp and 1C 1) are
defined the usual way. Let rm and r',“, be instances of rules r and r' in P then rw<r'~ ifl‘ r<r'. In
the rest of the paper, we assume that programs have been instantiated and thus all rules are
propositional.

Example 2.2.1 (credit confusion problem): Consider the following EPP, P=<Rp,ICp,<R>:
Rp={ I‘ IfAnn is a foreign student (resp. teaching assistant) then she needs 12 (resp. 6) credits I"I
r1 : need_credits(ann, 12)<—foreign_stud(ann).
r2: need_credits(ann,6)e—TA(ann).
r3: TA(ann).
r4: foreign_stud(ann). where S,,={ }, V154},
ICp={ ic: .l.(—need_credits(ann,6), need_credits(ann,12). } and r1<r2.

Every classical model of Rp violates the constraint ic. Rule r2 is considered reliable because
no constraint violation is caused by rules with priority no lower than r2, that is, r2, r3 and r4. Rule
r1 is "suspect" for the violation of ic caused by r1, r2, r3 and r4 because Head,.eBodyyc.
Consequently, rule r1 is unreliable. Since S,l={} and Sn={}, the rules r3 and r4 with heads
TA(ann) and foreign_stud(ann) are not "suspect" for the violation of ic. Consequently, r3 and r4
are reliable. The literals TA(ann), foreign_stud(ann) and need_credits(ann,6) should be true in the
desired semantics ofP because they are derived from the reliable nrles r2, r3 and r4.

Sn ={} expresses that rule r] is incomplete, i.e., not all possible exceptions are enumerated in

the body of r1. Consequently, though rule r, is ”suspect", there is no reason to suspect rule r4

21

which is used for the derivation foreign_stud(ann)e Body“. In contrast, if S,,= {foreign_stud(ann)}
then the rule r4 is "suspect" for the constraint violation. Consequently, r4 is unreliable and the truth
value of foreign_stud(ann) is undefined. If r1<r4 or r2<r4 or r3<r4 then r4 is reliable independently
of the value of S,l and thus foreign_stud(ann) is evaluated as true. Similarly, if Sn={} or r1<r3 or
r2<r3 or r4<r3 then r3 is reliable and TA(ann) is evaluated as true. Otherwise, r3 is considered
unreliable and the truth value of TA(ann) is undefined.
Example 2.2.2 (unloading the gun [31]): Consider the following EPP, P=<Rp,ICp,<R >:
Rp={ r1: loaded(tl)<—loaded(t0). rn: loaded(t,,)<—loaded(tn_1).

r0: Ioaded(t0). rmlz aloaded(tn). where S,,.={ }, ViSn+l } ,
1Cp=BCp and ’i< r0 and "i< 'n+lt Vie {l,..., n} }.

Rules r1,...,rn are instances of the default rule "if a gun is loaded at time t,- tlren it will still be
loaded at time ’i+l ." Rules r0 and rm] represent the facts that the gun is loaded at time to and it is
found unloaded at time ’n- Note that every classical model of Rp violates the constraint
.Lt-loaded(tn),-'loaded(t,,). The rules r0 and rm] are reliable because they have higher priority
than r‘,...,r,, and they do not generate any constraint violation. Since S,,,={}, the rules r‘,...,r,,-1
are not ”suspect" for the constraint violation even though they are used in the derivation of
loaded(tn). So, rules rl,...,r,,-1 are reliable and the only unreliable rule is rn. This implies that the
gun remained loaded until ’n-l'

If S,,={loaded(ti-l)}, VISiSn, then all rules r-, j=l,...,n, are "suspect" for the constraint
violation because they are used in the derivation of loaded(tj), j=l,...,n. Consequently, all rules
r1,...,r,, are unreliable. This implies that the gun was unloaded some time between t1 and tll but we

do not know exactly when.

Definition 2.2.1 (interpretation): Let P be an EPP. A set l=7U~F is an interpretation of P iff T
and F are disjoint subsets of HBp. An interpretation 1 is consistent ifl‘ there is no constraint

.L(-—L1,...,Ln in P s.t. Lie T, ViSn. An interpretation I is coherent ifl‘ it satisfies the coherence

property. Le F if-rLe T.

22

In interpretation I=7U~F, T contains the classically true literals, ”'7' contains the classically
false literals and F contains the literals false by default. When I is a consistent interpretation, there
is no L such that Le T and "Le T because this will violate the basic constraint .L(-—L,-'L. The
coherence property first appeared in [54] and it expresses the intuition that if a literal is classically
false then it is also false by default.

Definition 2.2.2 (truth valuation of a literal): A literal L is true (resp. false) w.r.t. an
interpretation I iffLeI (resp. ~LeI). A literal that is neither true nor false w.r.t. I, it is undefined

w.r.t. I.

An interpretation 1 can be seen equivalently as a firnction from the set of ground classical
literals to {OJ/2,1}, where 1(L)=l when L is true w.r.t. I, 1(L)=O when L is false w.r.t. I and
1(L)=l/2 when L is undefined w.r.t. 1. Both views of an interpretation, as a set and as a function,
will be used in the paper. Note that, I(~L)=l—I(L), for any literal L. If I is a coherent interpretation
then 1(L)=l implies I(~L)=0. We define [(0)351 and I(S)=Mmin{I(L)| LeS} where S is a non-
empty set of literals.

The coherence operator (coh) transforms an interpretation to a coherent one.

Definition 2.2.3 (coh operator [54]): Let I=TU~F be an interpretation of an EPP. coh(I) is the
coherent interpretation NF, where F=RJ{L| "Le T}.

Let I be a set of literals known to be true. In Definitions 2.2.6 and 2.2.8, the concepts of
reliable default literal and reliable rule w.r.t. I are defined. These concepts are used in the
fixpoint computation of the RS of an EPP. In RS, a default literal ~L is true by C WA only if ~L is a
reliable default literal w.r.t. RS and a rule r is used for the derivation of Head,. only if r is a reliable
rule w.r.t. RS.

The next definition expresses that a rule r should be blocked if *Head, is known to be true.
Definition 2.2.4 (blocked rule): Let I be a literal set. A rule r is blocked w.r.t. I ifi‘ "Head,.e I.

23

To decide if a default literal is reliable w.r.t. I, all possible constraint violations should be
considered. For this, the set of literals P051 is computed. Intuitively, Posl is the possibly

inconsistent well-founded model of R p when rules are blocked as indicated in I and coherence is
enforced. Specifically, P031 is the least fixpoint of the monotonic operator PW 1 which resembles
the W operator of the well-founded semantics [76]. When P is a normal program, PWQEW.
Definition 2.2.5 (possible literal set w.r.t. I): Let P be an EPP and 1,] be sets of literals. The
possible literal set w.r.t. 1, Pos 1, is defined as follows:

0 PTLJ(])={L | El rule r: L<—L1,...,Ln in P s.t. r is not blocked w.r.t. I and Lie TUJ, ViSn}.

. PT1(J)= utprulam) | a<(n}, where (i) is the first marine ordinal.

0 PF(J) is the greatest set S of classical literals s.t. VLeS, if r is a rule in P s.t. Head,.-"L then
3L'e Body, s.t. L'e S or ~L'eJ}).

0 PW 1(J)=coh(PT1(J)u~PF(J)).

- P031 is the least fixpoint of the operator PW 1.

A default literal ~K is reliable w.r.t. I if there is no constraint violation caused by Posl that
depends on ~K. In other words, ~K is reliable if it is not "suspect" for any constraint violation. If r
is a rule with Body, :Posl and a constraint violation depends on Head,. then the constraint

violation depends also on all literals in S,. If a constraint violation depends on a default literal ~K
then the constraint violation depends also on -'K.
Definition 2.2.6 (dependency set w.r.t. I, reliable default literal): Let P be an EPP, L be a literal

and I be a set of literals.
o The dependency set of L w.r.t. I, Dep1(L), is the least set D(L) such that:

- if L is the default literal ~K then {~K} ;D(~K) and D(‘*K)<;D(~K).

- if 3 r: Le—L1,...,Ln in P s.t. Body, cPosI then {L}:D(L) and VLie Sr, D(L,);D(L).
o A default literal ~K is unreliable w.r.t. I iffB .Le—L1,...,L,, in P s.t. ~Ke Dep1(Li), for an tSn and
Lje P051, Vje { l,...,n}-{t}. Otherwise, ~K is reliable w.r.t. I.

24

Note that only the dependency sets of literals in S, are considered in the computation of
Dep1(Head,.). This is because even if r is "suspect" for a constraint violation caused by Pos1, the
rules and C WAs used in the derivation of Bodyr—S, are not necessarily "suspect" for this constraint
violation.

Example 2.2.3: Consider the EPP, P=<Rp, [C p, <R>z

Rp=(r1:fly. rzzqfly(—~bird. with Sn={~bird} }, ICp=BCp and <R={}.

The default literal ~bird is unreliable w.r.t. I=0 because .l.(-—fly,-fly is a constraint,
~birde Dep1(“fly) and flye Posl =coh( {fly, “fly, ~bird}. In case that Sn={ }, ~bird is reliable w.r.t.
I because ~birde Dep1('*fly) and ~birde= Dep 1(fly).

To decide if a rule r is reliable w.r.t. I, all possible constraint violations caused by rules with
priority no lower than r, should be considered. For this, the set of literals Posh] is computed.

Intuitively, Posh] is the set of literals proved by {~L(—- “Ll Le HBp} and the rules r' sf r when
rules are blocked as indicated in I and the truth value of Bodyrr -S,.v is as indicated in Pas].

Let r,r' be rules. We define r ER r' when r"<r ifl‘ r"<r’, V rule r". The equivalence relation ER
partitions the rules in P into equivalence classes. The equivalence class of a rule r is denoted by [r].

Whenr=-Rr',thesetofrules with priority no lowerthanristhesameasthesetofrules with

priority no lower than r'. So, if r an r' then Posh] = Poser. In other words, the literal set Posh]

corresponds to the class of rules [r].

Definition 2.2.7 (possible literal set w.r.t. [r] and I): Let P be an EPP, r be a rule and I be a
literal set. The possible literal set w.r.t. [r] and I, Posr’I, is defined as follows:

0 P,J(Pos) = coh( {Head,.v | 3 rule r' in P s.t. (i) r' at r, (ii) r' is not blocked w.r.t. 1, (iii) Srv gPos
and (iv) Bodyrv —S,vc.Pos1})
. pow = u{P,. late) I a<tn}, where (1) stands for the first infinite ordinal.

25
A rule r is reliable w.r.t. I if there is no constraint violation caused by Poer that depends on r.

Intuitively, r is reliable if it is not "suspect" for any constraint violation caused by rules r' K r. If a
constraint violation depends on a rule r" then the constraint violation depends also on all rules r' sfi
r with (i) Head,.: as," or ~-Head,.v 68,", (ii) Sr' gPoer and (iii) Bodyrv -S,.r gPosI. In the
computation of RS, the derivation of literals in Bodyrv -S,.' may be based on C WAs and rules r' < r
that are in conflict with r. This is because these CWAs and rules are not necessarily "suspect" for

this conflict and thus not necessarily unreliable. Since only rules r' at r are used in the computation
of Poer, the truth value of Body,» -S,.v should be as indicated by Pos 1. Intuitively, the truth value

of Bodyrr -S,.v is independent of <R.
Definition 2.2.8 (dependency set w.r.t. [r] and I, reliable rule): Let P be an EPP, r be a rule, L

be a literal and I be a literal set.
0 The dependency set of L w.r.t. [r] and I, Dep,J(L), is the least set D(L) such that:

- if L is the default literal ~K then {~K} CD(~K) and D(-K)<;D(~K).
- if r': Le—L1,...,L,, in P s.t. (i) r' «it r, (ii) Sr: cPosu and (iii) Bodyrv —S,.' cPosI then
{L};D(L) and VLie Srv, D(Li);D(L).
0 A rule r is unreliable w.r.t. I iff (i) S, dosh], (ii) Body, -S,. cPosI and (iii) 3 .L(—L1,...,Ln in

P s.t. Head,.e Dep,J(Li), for an iSn and Lie Posh], Vje{l,...,n}-{i}. Otherwise, r is reliable

w.r.t. 1.

Similarly to Posh], if r a“ r’ then Dep, J(L)=Dep,.v ,1(L) V literal L. Note that only the
dependency sets of literals in SA are considered in the computation of Dep,J(Head,.v). This is
because even if r' is "suspect" for a constraint violation caused by Pos, ,1, the rules and C WAs used
in the derivation of Body,: -S,.v are not necessarily ”suspect" for this constraint violation.

Note that ifSrv = Bodyrr V rule r’ then Posh] does not contain literals whose derivation is

based on CWAs. This implies that no rule r is considered unreliable merely due to constraint
violations caused by C WAS. Intuitively, when Srr = Bodyrv V rule r', every mle is given higher

26

priority than the CWAs. In Example 2.2.4, we show that this is not true when there is a literal
Le Bodyrv —S,.v for a rule r' and Le Pos 1.

Example 2.2.4: Let P be as in Example 2.2.3, i.e.,

Rp={r1: fly. rzz'flyi-wbird. with Sn={~bird}}, ICp=BCp and <R={}.

In Example 2.2.3, we showed ~bird is unreliable w.r.t. I=0. Thus, we expect the literal ~bird to be
evaluated as unknown. The rule r. is reliable w.r.t. I because Poan =coh({/ly}) and
Head,.,e Depn'fi'rfly). Thus, we expect the literal fly to be evaluated as true. Rule r2 is reliable
w.r.t. I because Sn={~bird} is not a subset of Posh] =coh( {fly}).

In case that Sn={} then ~bird is reliable w.r.t. I and Pos,, ,1 =Poan =coh( {fly, "fly”. The
rule r, is unreliable w.r.t. I because Head,.,e DeanUly). The rule r2 is unreliable w.r.t. I because
Headne Deanfifly) and Bodyn-Sn=Body,-2 :Posl. Thus, we expect the literals fly, “fly to be
evaluated as unknown and the literal ~bird to be evaluated as true.

Note that when Sn={~bird}, rule r] is reliable and ~bird is unreliable w.r.t. I. Intuitively, if

Sn={~bird} then rule r1 is given higher priority than CWA ~bird. This is not true when Sn={},
i.e., rule r, is unreliable and ~bird is reliable w.r.t. 1.
Example 2.2.5: Let P be as in Example 2.2.1 and 1=0. Then, rule r2 is reliable w.r.t. 1 since
Poan = coh({TA(ann), foreign_stud(ann), need_credits(ann,6)” and Headne
Depmflneed_credits(ann,12))={}. Though Poan = coh({TA(ann), foreign_stud(ann),
need_credits(ann,6), need_credits(amr,12)}) violates the constraint ic, rule r4 is reliable w.r.t. 1
since Headne Depr4’1(need_credits(ann,X))= {need_credits(ann,X)} for X=6, 12. Similarly to r4,
rule r3 is reliable w.r.t. 1. Rule r, is unreliable w.r.t. 1 since need_credits(ann,6)e Poan,
Head,.,e Depn’1(need_credits(ann, 12)) and Body,I --S,.I = Body,l ; Poe].

If S,,={foreign_stnd(ann)} then the rule r4 is unreliable w.r.t. I because Headne
Depr4,1(need_credits(ann,12)). However, for any value of S,,, if r2<r4 then Poan=c0h( (TA(ann),
foreign_stud(ann}) and thus rule r4 is reliable w.r.t. 1. Similarly, for any value of S,,, if r1<r4 or

r3<r4 then rule r4 is reliable w.r.t. I.

27
Definition 2.2.9 (truth valuation of a rule): Let P be an EPP. A rule r is r-true w.r.t. an
interpretation 1 ifl‘: (i) I(Head,)Zl(Body,.) or (ii) 1(Body,.)=l/2 and [(uHeadr)=l or (iii) I(Body,)=l
and (I(Head,)=l/2 or I(-‘Head,.)=l) and r is unreliable w.r.t. 1.
Definition 2.2.10 (r-model): Let P be an EPP. A consistent, coherent interpretation 1 of P is an r-
model of P ifl‘ every rule in P is r-true w.r.t. 1.

Example 2.2.6: Let P be as in Example 2.2.4. Then, M=coh( {fly}) is an r-model of P. We will

show that ~bird is not true in any r—modcl of P. Let M’ be an r-model of P. Then, flyeM' because
r] is reliable w.r.t. 0 and consequently r] is reliable w.r.t. M' 20. This implies that *flyEM'

because M’ is a consistent interpretation of P. So, ~birdEM' because otherwise “flyeM’ since r2 is

reliable w.r.t. M 20. The literal -'fly should also belong to M' because M' is a coherent
interpretation. In case that Sn={}, the r—models are M1={~bird}, M2=coh({/ly,~bird}) and

M3=coh({—'fly,~bird}).

Example 2.2.7: Let P be as in Example 2.2.1. Then, M=coh({TA(ann), foreign_stud(ann),

need_credits(ann,6)}) is an r-model of P. We will show that M is the unique r-model of P. In
Example 2.2.5, we showed that rules r2, r3 and r4 are reliable w.r.t. I=0. Let M' be an r-model of

P. Then, r2, r3 and r4 are reliable w.r.t. M' :0. So, the literals TA(ann), foreign_stud(ann),
need_credits(ann,6) belong to M'. The literal need_credits(ann,12)eM' because otherwise M' will

violate the constraint ic.

Let P be a nomral program and I be an interpretation as defined in [58, 60]. In [60], a rule r is
true w.r.t. I ifi‘ I(Head,)21(Body,.). Since P is a normal program, rules do not contain classically

negative literals and the only constraints are the basic constraints. So, every rule in P is reliable
w.r.t. I ' =IU{~“AIA is an atom of P} and conditions (ii) and (iii) in Definition 2.2.9 are not
satisfied by I', for all rules in P. This implies that a rule r in P is r-true w.r.t. I' ifl‘r is true w.r.t. 1.

Proposition 2.2.1: Let P be a normal program. M is a model of P ifl‘Mu{~"A| A is an atom of P}

is an r-model of P.

28

The partial order <R' is an extension of the partial order <R iff (r,r')e <R implies (r,r')e <R'.
Let P=<Rp,ICp,<R > and P'=<Rp,le,<R' > be EPPs, where <R' is an extension of <R. It is
desirable that any r-model of P ' is an r-model of P. This is because, if the reliabilities of rules r and
r' cannot be compared then both r<r' and r'<r are possible. So, any extension of <R is possible to

express the relative reliability of the rules in Rp

Proposition 2.2.2: Let P=<RPJCP,<R > be an EPP and <R' be an extension of <R. Every r-model
of P'=<Rp,IC p,<R' > is an r-model of P.

Proof: Let M be an r-model of P'. Then, M is a consistent, coherent interpretation of P. If r is a
rule in P then r is r-true w.r.t. M in P'. We will show that r is r-true w.r.t. M in P. It is enough to

show that if r is unreliable w.r.t. M in P' then r is unreliable w.r.t. M in P. Assume that r is
unreliable w.r.t. M in P'. Since <R' is an extension of <3, the set of rules with priority no lower than

r in P' is a subset of that in P. So, PosM, Posr’M and Dep,,M(L) in P' are subsets of the

corresponding sets in P. This implies that r is unreliable w.r.t. M in P. 0

2.3 Reliable Semantics

In this Section, we define the reliable model, stable r-models and reliable semantics of an EPP, P.
We define the reliable model of P as the least fixpoint of a monotonic operator. We show that
reliable model of P is the least stable r-model of P.

2.3.1 Reliable Model
In the computation of reliable model of P, RMp, a default literal ~L is true by C WA only if ~L is

reliable w.r.t. RMp A rule r is used for the derivation of Head,. only if r is a reliable rule w.r.t.

RMp.
Thedefinitionofanr-unfoundedsetforanEPPextendsthatofanunfoundedsetforanonnal

program [76]. If S is an r-unfounded set w.r.t. a literal set J then VLe S, ~L is reliable w.r.t. J.

Note that if P is a normal program then all default literals of P are reliable w.r.t. any literal set J.

29

Definition 2.3.1 (r-unfounded set): Let P be an EPP and J be a set of literals. A set S of classical
literals is r-unfounded w.r.t. J iff VLeS, (i) if r is a rule in P with Head,=L then ElL'e Body, s.t.

L'E S or ~L'eJ and (ii) ~L is reliable w.r.t. J.

The WP operator for EPPs extends the Wp operator for normal programs [76]. This is

because if P is a normal program and J a literal set then (i) every rule is reliable w.r.t. J and (ii) a

set S is an r-unfounded set w.r.t. J iff S is an unfounded set w.r.t. J.
Definition 2.3.2 (W p operator): Let P be an EPP and J be a set of literals. We define:

0 T J(T)={L [3 rule r: Le—L] ..... Ln in P s.t. (i) Lie TUJ, V191 and (ii) r is reliable w.r.t. J}.
. T(J)= utrflam) |a<w}, where (i) is the first limit ordinal.

0 F(J) is the greatest r-unfounded set w.r.t. J.

. Wp(J)=coh(T(J)u~F(J)).

The sequence {TJTa} is monotonically increasing (w.r.t. Q). 80, TU) is the least fixpoint of
the operator T J. The union of two r-unfounded sets w.r.t. an interpretation J is an r-unfounded set

w.r.t. J. So, F(J) is the union of all r-unfounded sets w.r.t. J. We define the transfinite sequence
{Ia} as follows:10={}, Iafi=Wp(Ia) and Ia= U{Ib l b<a} if a is a limit ordinal.
Proposition 2.3.1: Let P be an EPP. {la} is a monotonically increasing (w.r.t. ;) sequence of

consistent, coherent interpretations of P.

Proof: We will show that WP is a monotonic operator. Let I,J be interpretations of P s.t. IgJ.

T(1)<;T(J) follows from the fact that if a rule r is reliable w.r.t I then r is reliable w.r.t. J.

F(I);F(J) follows from the fact that if a default literal ~L is reliable w.r.t. I then ~L is reliable
w.r.t. J. Since colt is a monotonic operator, Wp is a monotonic operator and {Ia} is a

monotonically increasing sequence w.r.t. ;.

We will prove by induction that for all a, there is no constraint ic' s.t. Bodyicv :10. This is

true for a=0. Assume that it is true for ordinals <a. We will prove that it is true for a.

30

Assume first that a=b+l is a successor ordinal. Let a'=b'+l be the first ordinal s.t. TIbTa'M)
is inconsistent. If TIbTG'M) violates a basic constraint then let ic be one of the violated basic
constraints. Otherwise, let to be any of the violated constraints. Let Rb,a' = {r | rule r is fired in the
computation of T(Ic) for c< b or in the computation of TIbT‘TQ) for cs a'}. Let [(6 Bodin s.t.
Ke T1,T0’(o), K2 1,, and K2 T1,,“ ’(o). Such a literal exists since a' is the first ordinal s.t. T1,,Ta'(o)
is inconsistent.

Case 1: The constraint ic is the basic constraint .L(-— K, “K.

Choose the smallest c' s.t. 1c!“ contains “K. We will show that there is no L s.t. L-E F(Ic), c< c',
and ~Le Dep1c(-'K). Since Vc< c', «Kn IO and there is no literal K' s.t. K'e 10 and *K'e lelb'lo),
it follows that Vc< c', K6 Poslc. Ifthere is L, c s.t. Le F(Ic), c < c', and ~Le Dep1c(-'K) then ~L is
unreliable w.r.t. 1c which is a contradiction (all literals in ~F(Ic) are reliable w.r.t 1,). Similarly,
there is no L s.t. Le F(Ic), c< b, and ~Le Dep1c(K). This implies that there is a rule rme Rb,a'
which is used in the derivation of K, "KE Postb and Headme Dep,.’1b(K). Moreover,
Schosmyb and Bodym-Schoslb. Thus, rule rm is unreliable w.r.t. 1b which is a
contradiction.

Case 2: The constraint ic is not a basic constraint.

Then, there is no literal K' s.t. K'e 1c, c< b, and '"K'e TI,T0’(o). This implies that Vc<b,
TIbT“'(0)cPoslc and consequently, BodyiccPoslc. We will show that there is no L s.t. Le F(Ic),
c<b, and ~LE DepIC(K), for a KeBodyic. Assume that there is L, c s.t. Le F(Ic), c< b, and
~Le Dep1c(K), for a Ke Bodyic. Then, Bodymgpos 1, and ~Le DepIC(K), for a [(6 Bodyic.
Consequently, ~L is unreliable w.r.t. [C which is a contradiction (all literals in ~F(Ic) are reliable
w.r.t 16.). Let Ric be the set of the rules reRb'at which are used in the derivation of literals in
Bodyic and Head,.e Dep,Jb(K), for a Ke Bodyic. Let rme Ric be s.t. there is no reRk, and r<r,,r
Then, Bodyicgl’ostb and Head,,,e Depr_,1b(K), for a [(6 Bodyic. Moreover, S,,<;Pos,m,lb,
Bodym-Sthos 1,. Consequently, rule rm is unreliable w.r.t. 1b which is a contradiction.

So, Ia does not violate any constraint.

31
Let a be a limit ordinal and assume that there is constraint ic in P s.t. Bodyicgla. Then, there is a

successor ordinal b+l<a s.t. Bodyicglbfl. This is a contradiction because of the inductive

hypothesis. So, Ia is consistent for all a.

We will prove by induction that for all a, there is no literal L s.t. Le Ia and ~Le1a. The proof

is similar to that of the well-founded semantics [76]. It is true for a=0. Assume that it is true for
ordinals <a. We will prove that it is true for a.

Assume first that a=b+l is a successor ordinal. We will prove by a second induction that for
all a', there is no literal L s.t. Le TIbTa'M) and ~Le1a. This is true for a'=O. Assume this is true for
ordinals <a'. Let a' =b'+l is a successor ordinal. Let S be any set of classical literals that has a
non-empty intersection with TIbTa'M). Choose the smallest c s.t. 1‘.“ has a non-empty intersection
with S and the smallest c' s.t. TICT‘ 41(0) has a non-empty intersection with S. Note that c<b or
c=b and c'<a’. Let Le T130“ Roms. Then, L is derived from a rule r s.t. Body,gT1cTc'(0)UIc.
From hypothesis, there is no literal Ke Body,, s.t. ~Ke1b. Moreover, from the way r is defined,
there is no classical literal K in Body, s.t. KeS. So, S is not r-unfounded w.r.t. 1b. This implies
that TIbT“'(0)nF(Ib)=G. So, T(Ib)nF(1b)=G. Moreover, there is no classical literal L s.t. Le T(Ib)
and "Le T(Ib), because Ia does not violate any constraint. So, there is no literal L s.t. Le Ia and
~Le Ia.

Let a be a limit ordinal and assume that there is L s.t. Lela and ~LeIa. Then, there is a
successor ordinal b+l<a s.t. Le lb“ and ~Le1b+1. This is a contradiction because of the inductive

hypothesis.
Ia is a coherent interpretation, for all a, because of the cob operator in the definition of W 1).

Proposition 2.3.1 follows. 0

Since {la} is monotonically increasing (w.r.t. c), there is a smallest countable ordinal d s.t.

1d=1d+l [23].
Proposition 2.3.2: Let P be an EPP. Then, Id is an r-model of P.

32

Proof: From Proposition 2.3.1, Id is a consistent, coherent interpretation. Let r be a rule in P. We
will show that r is r-true w.r.t. 1d-

(i) If Id(Body,)=l/2 and Id(I-Iead,)=0 then Id(-'Head, =l because otherwise Id(Head, =l/2.

(ii) If Id(Body,)=l and Ia(Head,)=l/2 then r is unreliable w.r.t. Id because otherwise, from the
definition of T(Id), Id(Head,)=l.

(iii) If Ia(Body,)=l and IAHead,)=0 then r is unreliable w.r.t. Id because otherwise, from the
definition of T(Id), Id(Head,)=l. Since r is unreliable w.r.t. 1d, it follows that Id(-Head,)=l
because otherwise, from the definition of F (Id), Id(Head,)=l/2.

(iv) In all the other cases, Id(Head,)ZId(Body,). 0

Definition 2.3.3 (reliable semantics): Let P be an EPP. The reliable model of P, denoted as RM 1),

is the interpretation Id. The reliable semantics of P is the "meaning" represented by RMp.

Example 2.3.1: Consider the EPP, P=<Rp,IC}o,<R >:
Rp=(r1: q. r2: p(—q. r3: “p. r4: p<—~r. with S,,=Body,,, Vis4},
ICp=BCp and r3<r2, r2<r1, r3<rl.
Computation of W 13(0): Rule r1 is reliable w.r.t. 0 because it has higher priority than rules r2
and r3 and rules r1, r4 do not generate a constraint violation. Similarly, rule r2 is reliable w.r.t. 0.
In contrast, rule r3 is unreliable w.r.t. 0 because pe Posn,g=coh({q, p, “p}) and
Head,.,e Depn,9(-'p). So, T(0)={q. p}. The literal ~r is unreliable w.r.t. 0 because
ape posfl=coh({q, p, “p, ~r}) and ~re Dep0(p). So, F (0)={} and Wp(0)=coh( {p,q}).
Computation of wplztc): Rule r3 is unreliable w.r.t. wpto). So, T(wp(o»='r(o).
However, ~r is reliable w.r.t. Wp(0) because r3 is blocked w.r.t. Wp(0) and consequently,
“pE Pose. So, F(wplo))={~r} and WPT2(0)=coh({p, q, ~r}).
Computation of wPT3(o): Because r3 is unreliable w.r.t. wplzlo), it follows that
WPT3(0)=WPT’(0).
So, RMp =wPTZ(c).

33

Example 2.3.2: Let P be the program of Example 2.2.1. Then, the interpretation coh({TA(ann),
foreign_stud(ann), need_credits(ann,6)}) is the reliable model of P. If P' is as P with <R={} then

the reliable model of P' is coh({TA(ann), foreign_stud(ann)}) which corresponds to the skeptical
meaning of P'. If P' is as P with S, =Body, V rule r then rules r3 and r4 are unreliable w.r.t. 0 and

thus the reliable model of P' is {}.

Proposition 2.3.3: Let P=<RPJCP,<R> be an EPP. The complexity of computing RMp is
0(ll-IBp|*|Rp|‘max(|ICp|, lHBp|*lECRI), where ECR is the set of equivalence classes of Rp w.r.t.

'3-
Proof: The following algorithm, RM(program P), returns the reliable model of P. To compute

F(l), its complement set is constructed first, as in [76].

RM(EPP program P)
{ new_1={};
repeat
I=new_I;
compute Pos[, /" Step I *l
for each Le HBp do compute Dep1(L); endfor /‘ Step 2 ‘/
for each m inP do /" Step 3 */
compute Pos,f, /"‘ Step 3.1 ‘l
for each Le HBp do compute Dep, 1(L); endfor /* Step 3.2 ‘/
endfor

repeat /‘ Step 4: Compute T(I) ‘/
for each rule r in P do
if Body, gnew_l and r is reliable w.r.t. I then add Head, to new_I; endif

endfor
until no change in new_1;

compl_F={Le HBp l ~L is unreliable w.r.t. I}; I“ Step 5 *I
repeat /" Step 6: Compute HBp -F(1) ‘/
foreach ruler inPdo
if no literal in Body, is false w.r.t. I and all classical literals in Body, are in compl_F

then add H, to compl_F;

34

endif
endfor
until no change in compl_F;
for each Le I-IBP do I‘ Step 7*/

if Le compl_F then add ~L to new_1; endif
endfor

new_1=coh(new_1); /* Step 8: Compute coh(T(I)U~F (1)) */
until I=new__I;
retum(I);

}
The complexity of computing Pas] is the same as that of computing the well-founded model of

P when every literal -'L is replaced by a new atom —t_L. So, the complexity of Step 1 is [HBp|*]Rp|
[78, 69]. The complexity of Step 2 is IIIBPI‘IRPI because the complexity of computing Dep1(L), for
a literal L, is [RP]. The complexity of Step 3.1 is lRpl and that of Step 3.2 is lHBp|*|Rp|. So, the
complexity of Step 3 is [ECRPIHBPPIRPL The complexity of Step 4 is llel‘lRp] since Pos,1 and
Dep, 1(L), VLe HBp, have already been computed. The complexity of Step 5 is |ICp|*|HBp] <
[ICpl‘lRp] and that of Step 6 is [RP] [19]. The complexity of Steps 7 and 8 is lHBp]. Since {la} is a
monotonically increasing sequence w.r.t. c, the total number of iterations until I=new_1, is less
than IHBp]. So, the complexity of the algorithm RM(P) is 0(IHBpl‘lRpl‘max(|ICp|, lHPpNECRI).
0

2.3.2 Stable r-models

The reliable model of an EPP corresponds to its skeptical meaning. Credulous meanings can be
obtained using the transformation Pl, 1, where I is an interpretation of P. The transfomration P/I for

a normal program P is defined in [26, 60]. P/,I extends H] to EPPs.

Definition 2.3.4 (transformation P/,I): Let P be an EPP and I be an interpretation of it. The

program P1,! is obtained as follows:

(i) Remove from P all rules that contain in their body a default literal ~L s.t. 1(L)=l.
(ii) Remove from P any rule r with I(-'Head,)=l.

35
(iii) If r is a rule in P s.t. l(Body,)=l and I(Head,)=l/2 then replace r with Head,(—u.

(iv) Remove from the body of the remaining rules of P any default literal ~L s.t. 1(L)=O.
(v) Replace all remaining default literals ~L with u.
(vi) lfI(L)=l/2 and ~L is unreliable w.r.t. I then add the rule Lt—u.

(vii) Replace every classically negative literal “A with a new atom --._A.

The program PI,I is a non-negative program with a special proposition it. For any
interpretation J, J(u)=l/2. When P is a normal program and M is a model of P [60], PI,M a P/M
since Steps (ii), (iii), (vi) and (vii) do not have any effect on PI,M.

We say that a model M of P is the least, model of P ifi‘ M(L)SM'(L) for any model M' and
classical literal L of P. The least, model of a non-negative program ean be obtained as the least,
fixpoint of the ‘I’p operator [60] which generalizes the immediate consequence operator of [75].
Definition 2.3.5 (Pp operator) [60]: Let P be a non-negative program, I be an interpretation and
A be an atom of P. ‘I’p(1) is defined as follows:

(i) 'I’p(I)(A)=l if3 rule Ae—A1,....A,, inP s.t. I(A,-)=l, ViSn.
(ii) ‘I’p(l)(A)=l/2 if ‘I’p(I)(A)¢l and 3 rule At—A1,...,A,, in P s.t.1(A,-)21/2, ViSn.

(iii) 'I’p(l)(A)=0, othenvise.

Definition 2.3.6 (stable r-model): Let P be an EPP and M be an r-model of P. M is a stable r-
model of P ifl‘ least,(P/,M)=M.

Stable r-models represent the credulous "meanings" of a program. For example, let P' be as
the program P of Example 2.2.1 with <R={}. The stable r-models of P' are:
M1= coh( {TA(ann), foreign_stud(ann), need_credits(ann,6)}),
M2= coh( {TA(ann), foreign_stud(ann), need_credits(ann,12)}), and
M3=RMpt= coh( {TA(ann), foreign_stud(ann)}).

The unique stable r-model of program P of Example 2.2.1 is:
RM p = coh({TA(ann), foreign_stud(ann), need_credits(ann,6)}).

36

Proposition 2.3.4: Let P be an EPP. The reliable model of P is a stable r-model of P.

Proof: Let RM be the reliable model of P. From Proposition 2.3.2, RM is an r-model of P. So, it is
enough to show that RM=leastv(Pl,RM). Let least,(P/,RM)=IU~F, where T, F are sets of classical

literals. Let Ia=TaU~Fa, where T 0, Fa are sets of classical literals and RM = Id. First, we will
prove by induction that T bU~Fb gTU~F, Vbsd. It is true that T OgT and FogF. Suppose that
T agT and FagF, Va<b. If b is a limit ordinal then T bgT and FbgF since Ib= U{Ia| a<b}.
Assume therefore that b=a+1. It is true that T10T0(0)g:T. Assume that T107“ '(0):T. we will show
that TlaTa"”(0)<;T. Let Le T107“ “(0). Then, 3 r1.<—Ll,...,Ln in P s.t. r is reliable w.r.t. Ia and
ViSn either (i) Lie 1,, or (ii) L,- is a classical literal and Lie TlaTato). Since 1,;an and Le RM,
there is a rule Le—L'l,....L'm in Pl,RM where L'],..., 'm are all the classical literals in {L1,...,L,,}.
From the facts T1,T0'(o)gr,1a;m~F and the definition of least,(P/, RM), it follows that Le T.
This implies that T(Ia)=Tb;T.

Now, we will Show that FbgF. Since Fb= “TbuF(Ia), it is enough to show that “TbgF and
F(Ia)t;F. If Le -'T b then “LeRM and from Step (ii) of Def. 2.3.4, Le F. Consequently, "'de
For all rules Ht—L'l,...,L'm,~Ll,..,~Ln in P (Li, U; are classical literals) with He F(Ia) either
EliSm, L',e F(Ia)UFa or Han, LJe T a. This implies that, for each rule Ht—L'1,...,L'm,~Ll,..,~Ln in
P with He F(Ia) either there is a corresponding rule Ht—A 1,...,Ak in HM (from Steps (iv) and (v)
of Def. 2.3.4) with Age F(Ia)uF for an iSk or there is no corresponding rule in PerM (from the
Steps (i) and (ii) of Def. 2.3.4). Note that, no rule Ht—u is added to PerM (from Steps (iii) and
(vi) of Def. 2.3.4) because H is false w.r.t. RM. So, for each rule H<-—Ah...,Ak in P/,RM with
He F(Ia)UF, BiSk such that A ,e F(Ia)uF. From the definition of least,(P/,RM), it follows that
F(Ia);F. Consequently, 17ch

So, we proved that T dcT and ngF.

WewillshowthatTgTd Ietabethefirstordinals.t.thereisaliteralLerand
wptla'waLH, where PEP/,RM. Then, there is a rule r. Le—A1,...,Ak in PerM with

37

‘I’vaa(0)(A,-)=l, ViSk. This implies that there is a rule in P whose body literals are true w.r.t.
RM. Since Le T d, it follows that "Le T d or L is unknown w.r.t. RM. If “Le T d then from Step (ii)
of Def. 2.3.4, Let T which is a contradiction. If L is unknown w.r.t.RM, the rule r should not exist
in PI,RM because of the Step (iii) of Def. 2.3.4 and the fact that all of the body literals of r are
true w.r.t. ‘I’vaa(0) and thus w.r.t. RM. So, Le T d and consequently T :Td.

We will show that 17ng Let Fcoh={H| “He T d}. FcohCer because RM is a coherent
interpretation. For all rules He—A],...,Ak in PerM with He F—Fcoh, there is iSk such that AieF.
This implies that for each rule Ht—L'],...,L'm,~Ll,...,~Ln in P (L, L',- are classical literals) with
He F’Fcoh either (i) Sign, L'ie F (from Steps (iv) and (v) of Def. 2.3.4) or (ii) Elan, LJe T d (from
Step (i) of Def. 2.3.4). We will show that VHe F—Fcoh, ~H is reliable w.r.t. RM. If ~H is
unreliable w.r.t RM then He F (1d) and consequently, RM(H)21/2. However, if He F then He T and
consequently RM(H)¢1. So, RM(H)=l/2 and the rule Hé—u should be added to P/,RM (from Step
(vi) of Def. 2.3.4). This implies that HEP: which is a contradiction. So, VHe F-Fcoh, ~H is
reliable w.r.t. RM. Since F(Id) is the maximum set that satisfies the property satisfied by F-Fcoh,
F—FcothUd). So, FCFd.

Consequently, RM=Td U~F d = T U~F=leastv(Pl,RM). 0

Proposition 2.3.5: Let P be an EPP. The reliable model of P is the least stable r-model of P.

Proof: Let RM be the reliable model of P. From Proposition 3.4, RM is a stable r-model of P. So,
it is enough to Show that if M is a stable r-model of P then RMcM=least,(P/,M). Let M=TU~F,

where T, F are sets of classical literals. Let Ia=Tau~Fa, where Ta, Fa are sets of classical literals
and RM = Id. We will Show by induction that IbQNF, VbSd. It is true that T ogT and Fog}?
Suppose that T acT and FagF, Va<b. If b is a limit ordinal then TbgT and FbgF since Ib= U{Ia]
c<b}. Assume therefore that b=a+l. It is true that TIUT°(0):T Assume that r,,Ta’(o);r, we will
show that r1,T0'+1(o);r. Let Le rlalawta). Then, a rzLe-L1,...,Ln in P s.t. r is reliable w.r.t. Ia
and ViSn either (i) L,-e Ia or (ii) L, is a classical literal and Lie TIaTa'M). Since IagM, it follows

38

that r is reliable w.r.t. M. From the facts that M is an r-model of P, IagM, Tlala'(o);r and r is
reliable w.r.t. M, it follows that Le T. So, T(Ia)=Tb<_;T.

Now, we will show that FbgF. Since Fb= aTbUFUa), it is enough to show that aTbgF and
F (Ia)t;F. lfLe '"T b then aLeM and from Step (ii) of Def. 2.3.4, Le F. Consequently, *Tch. For
all rules H4—L'1,..., ’m,~Ll,..,~L,, in P (L,-, L',- are classical literals) with He F(Ia) either BiSm,
L',e F(Ia)UFa or Elan, LJe T a- This implies that, for each rule rJI<—L'1,...,L'm'~Ll,..,~L,, in P
with He F(Ia) either there is a corresponding rule H<—A 1,...,Ak in HM (from Steps (iv) and (v) of
Def. 2.3.4) with Aie F (Ia)UF for an iSk or there is no corresponding rule in P/,M (from Steps (i)
and (ii) of Def. 2.3.4). Note that, r is not transformed into H(—u in HM in Step (iii) of Def. 2.3.4
because the facts IagM and leastv(P/,M)=M imply that SiSm, L'ie T or 3!an, Lje F. Moreover, no
rule Ht—u with He F (la) is added to P/M in Step (vi) of Def. 2.3.4 because the facts ~H is reliable
w.r.t. Ia and IagM imply that ~H is reliable w.r.t. M. So, for each rule Ht—Al,...,Ak in PIM with
He F(Ia)UF, 3iSk s.t. A ,-e F(Ia)UF. From the definition of least,(P/,M), it follows that Le F So,
FbgF and thus T dcT and chF. Consequently, RM=Td U~Fd C T U~F=M. 0

Proposition 2.3.6: Let P=<RpJCp,<R > be an EPP and <R' be an extension of <R. Every stable r-
model of P'=<Rp,ICp,<R' > is a stable r-model of P and Mp Q My.

Proof: Let M be a stable r-model of P'. We will Show that every default literal which is unreliable
w.r.t. M in P' is also unreliable w.r.t. M in P. Assume that ~L is unreliable w.r.t. M in P'. Since <R'
is an extension of <3, the set of rules with priority no lower than r in P' is a subset of that in P. So,
PosM and DepM(I<), for a literal K, in P' are subsets of the corresponding sets in P and
consequently ~L is unreliable w.r.t. M in P.

Let 5%{Ll M(L)=l/2 and ~L is unreliable w.r.t. M}. For all Le S, least,(P'/M)(L)=l/2 because
least,(P'/M)=M. This and the fact PI,M = P'I,M U{L<—u| Le S} imply that least,(P/M)=
least,(P'/M)=M From Proposition 2.2.2, M is an r—model of P. So, M is a stable r-model of P.
Since Rle is the least stable r-model of P, RMpcRMpv. 0

39

2.3.3 Diagnosis Example
We will consider an application of RS to diagnosis and we will Show how prioritized defaults can
be used to express the relative reliability of circuit components.

Example 2.3.3:

~>—e

I2 _/
b d

 

Figure 2.1: A digital circuit

The circuit of Figure 2.1 consists of two inverters and one AND gate. To reason about its
behavior, we give a simple formulation with an EPP, P=<R}o,IC1o,<R >;

Rp={ /* description of II gate */
r1: “cea,OK_Il. r2: ct—aa,OK__Il.
/"‘ description of 12 gate “'/
r3: -d<—b, OK_12. r4: d(-—-'b, OK_12.
/" description of Al gate ‘/
r5: et—c,d,OK_Al. r6: aet—cc,OK_Al. r7: net—ad, OK_AI.
r8: a. l‘ a input has value 1 */ r9: "b. /" b input has value 0 ‘/
r10: e. l’ e output has value I *l
/" assumptions that gates are working correctly*/
r“: OK_II. r12: OK_12. r13: OK_AI.
S,,=Body,,, ViSl3},
ICp=BCp, and <R indicates that any rule ri, i=l,...,10 has higher priority than any rule rj,

j=ll,12,13.

40

Note that every classical model of R p violates the constraint .l.(—e, “e. Apparently, the above
circuit is faulty. Though there is no evidence that 12 does not work correctly, one of the gates 11
and Al should be faulty. All rules r,-, i510, are reliable w.r.t. 0 because they have higher priority
than rules r11, r12 and r13 and do not generate any constraint violation. Rule rn also is reliable
w.r.t. 0 because OK_I2 does not belong neither to Depm,0(e) nor to Dep,n,g(-'e). Rule r” is
unreliable w.r.t. 0 because ee Posmfl and OK_Ile Dep,n,0(-re). Similarly, rule r13 is unreliable
w.r.t. 0. The reliable model of P is RMp=coh( {a, ab, d, e, OK_12}). The truth values of OK_Il,
OK_AI are unknown because rules r” and r13 are unreliable. The truth values of c and -'c are
unknown because the truth value of OK_Il is unknown. The stable r-models of P are:

M l=coh({a,-'b,d, e, OK_12,0K_AI }) and M2=coh({a,-'b,-c,d, e, OK_11,0K_I2}).
Ifwe extend <R with r1 I< r13, indicating that gate Al is more reliable than gate 11 then the unique
stable r-model of the new program equals M1.

Let P’ be as P with S,={} V rule r. All rules in P' except r7 and r10 are reliable w.r.t. 0.
Consequently, RMpv ={a,-'b,-'c,d,OK_Il,OK_12,0K_Al} indicating that all gates are working
correctly but the truth value of output e is unknown. The stable r-models of P' are:

M1 = coh( {a,-bred. e,OK_Il,OK_12,0K_Al }) and

M2 = coh( {a,-'b,-'c,d,-e,OK_Il,OK__12,0K__Al }).

ModelM'l indicatesthatoutputehasvalue l andthatallgatesareworkingcorrectly. Thisisan
unintuitive result because if all gates are working correctly then output e should have value 0.
Model M2 indicates that output e has value 0. This is also an unintuitive result because rule r10,
which expresses that the observed value of e is 1, has higher priority than rules r11, r12 and r13.
The same reliable model and stable r-models are derived when P' is extended with r11< r13. The
reason for these unintuitive results is that S,={} V rule r in P', even though the rules r} are
complete, for all i510. When a rule r,-, for i510, is in conflict with an observed output, the truth
value of any literal in Body,, may be mistaken. For this, Sn should be equal to Body,,, for all i510.

pro

41

2.4 Related Work
In this Section, we review earlier work on semantics of subclasses of EPPs and give the

relationship of these semantics with the reliable semantics.

2.4.1 Three-Valued Stable Model Semantics
Przymusinski [60] defines the 3-valued stable model semantics for normal programs by extending
the Pl] transformation [26] to 3-va1ued interpretations 1. Specifically, if P is a nomral program and
I is a 3-valued interpretation of it then the non-negative program P/I is defined as follows:
(i) Remove from P all rules that contain in their body a default literal ~L s.t. 1(L)=l.
(ii) Remove from the body of the remaining rules of P any default literal ~L s.t. 1(L)=O.
(iii) Replace all remaining default literals ~L with u.

A 3-valued stable model of P is a 3-valued interpretation M of P that satisfies least,(P/MFM.
The 3-valued stable model semantics of P is defined as the intersection of all the 3-valued stable
models of P. As the next proposition shows, the reliable semantics is a generalization of the 3-
valued stable model semantics.
Proposition 2.4.1: Let P be a normal program. Then, M is a 3-valued stable model of P ifl‘
MU{~“A] A is an atom of P} is a stable r-model of P.
Proof: When P is a nomral program, M is a 3-valued stable model of P ifl‘MU{-~A| A is an atom
of P} is an extended stable model of P [54]. Proposition 2.4.1 now follows fiom Proposition 2.4.3.
0

Przymusinski has shown that the intersection of all 3-valued stable models of a normal
program P coincides with the well-founded model of P [76]. Consequently, Proposition 2.4.1
implies that the reliable model of a normal program coincides with its well-founded model.

pic

42

2.4.2 Answer Set Semantics

Gelfond and Lifschitz [27] define the answer set semantics for extended programs by extending the
Pl] transformation [26] to extended programs P. A 2-valued interpretation is a set of classical
literals. A classical literal L is true (resp. false) w.r.t. a 2-valued interpretation I iff LeI (resp.
LEI). Specifically, if P is an extended program and I is a 2-valued interpretation then the program
PI] is defined as follows:

(i) Remove fi'om P all rules that contain in their body a default literal ~L s.t. 1(L)=l.

(ii) Remove from the body of the remaining rules of P any default literal ~L s.t. 1(L)=0.

Let P be a positive program. If least‘,(P) contains a pair of complementary literals then
a(P)=dc,HBp. Otherwise, a(P)=wleastv(P). An answer set of an extended program P is a 2-valued
interpretation M that satisfies a(PIM)=M. The answer-set semantics of an extended program is
defined as the intersection of its answer-sets. When P is a normal program, the answer set
semantics of P coincides with the stable model semantics of P [26]. However, similarly to the
stable model semantics, the answer set semantics is not defined for all programs. There are several
arguments for and against this. Some researchers would like to dismiss logic programs without any
answer sets as not good (analogous to ”inconsistent theories" in case of first order theories) theories
while others would like to have a semantics that characterizes all logic programs. We believe that
the second is the correct approach since the knowledge base may contain information that should
be salvaged. For example, consider the program P={p(—~p. a. }. P has no answer set even though

a should be true. The reliable semantics of P is {a, ~11, -'p}.

An extended program P can have an answer set HBp. In this case, P is called contradictory
[27] and HBp is the unique answer set of P. For example, when WFMP is contradictory, the answer

set semantics of P is HBp. Thus, when P is contradictory, all information in P is lost. For example,
the unique answer set of P={p. *p. a.} is HBP. The problem of finding whether an extended
program has an answer set is NP-eomplete [22].

The following relationship between the answer-set semantics and RS can be shown.

43
Proposition 2.4.2: Let P be an extended program. If Mflpr is an answer-set of P then Mu{~A|

Ae M} is a stable r-model of P.
Proof: P is non-contradictory since M¢HB p is an answer-set of P. So, if M is an answer-set of P
then MU{~A| Ae M} is an extended stable model of P [54]. Proposition 2.4.2 now follows from

Proposition 2.4.3. 0

The well-founded semantics and the reliable semantics are sometimes over-skeptical but in
return they offer a constructive definition and efficiency. This will be clearer with the following
example. Let P={pé—~q. qt—~p. at—q. a<—p.}. Then, the answer sets of P are {p,a},
{q,a} whereas the reliable semantics of P is {-~a, -*p, ~-‘q}. Thus, according to reliable
semantics of P, a is undefined even though a is true in all answer sets of P. So, the answer set
semantics based on the intersection of the answer sets infers a even though it remains undecided

aboutp and q.

2.4.3 Extended Well-Founded Semantics
Let P be an extended program and I an interpretation of it. In [54], the operator (DP is defined as

d)p(1)=coh(leastv(P/I)) if least,(P/I) does not contain a pair of complementary literals. Otherwise,
(Dp(1) is not defined. The extended well-founded model (XWFIV! p) of P is defined in [54] as the
least fixpoint of (DP. An extended stable model of P is a fixpoint of (DP. Let Io={ }, ImI=¢p(Ia)
and Ia= U{Ib | b<a} if a is a limit ordinal Then, XWIWP=Id where d is the smallest ordinal s.t.
1d+1=1d- When there exists an a s.t. (Dp(Ia) is not defined, P is called contradictory.

Proposition 2.4.3: Let P be a non-contradictory extended program. Then, M is an extended stable
model of P ifi‘ M is a stable r-model of P.

Proof: Let M be an extended stable model of P. From the definition of extended stable model [54],
M is an r-model of P and least,(P/,M)=M. So, M is a stable r-model of P.

Let M be a stable r-model of P. Since P is a non-contradictory extended program, there is no
L s.t. Le P080 and “Le P080 and XWFMIFPOSQ. So, all default literals and rules in P are reliable

ta.)
.-

44
w.r.t. [=0 This implies that default literals and rules in P are reliable w.r.t. M. Consequently,
Steps (iii) and (vi) of Definition 2.3.4 have no effect on P/,M. So, from the definition of extended

stable model, M is an extended stable model of P. 0

Proposition 2.4.3 implies that if P is a non-contradictory extended program then the reliable
model of P coincides with the extended well-founded model of P. When P is contradictory, the
extended well-founded semantics of P is not defined in contrast to the reliable semantics. For
example, consider the extended program P={ap. p. b. }. P has three stable r-models (b, -~b},

(up, b, ~p, -'b} and {p, b. ~“p, ~-b} but no extended well-founded semantics.

2.4.4 Relevant Expansion

In [79], a program P with constraints is called revisable if it has a A-model, that is, if there is a
consistent interpretation M s.t. for every rule r in P, M(Head,)2M(Body,). Witteveen [79] shows
that every revisable program P whose well-founded model [76] is inconsistent, can be expanded
into a new program P' (relevant expansion) that has consistent well-founded model. The

foundation of a literal L, F(L), is defined as follows:
A classical literal L'e F(L) ifi‘ 3 mle r s.t. all literals in Body, are true w.r.t WPMp and

(i) ~L'e Body, or (ii) ~L’e F(K) for a classical literal Ke Body,.

The relevant expansion of P is the program P' =P U{L<— ~L I Le FLU} which has consistent
well-founded model. The semantics of P is defined as the well-founded model of P '. However, the
well-founded model of P' may not be a coherent interpretation of P. Moreover, when P is not

revisable, P is not given any semantics in [79]. For example, the program P of Example 2.2.1 with
<R={} is not revisable but it has three stable r-models.

2.4.5 Conservative Vivid Logic

The conservative reasoning for extended programs, presented by Wagner [77], is as follows:

.9
.‘

PHI

fort

45
0 A literal L is true iff (i) 3 rule r s.t. Head,=L and Body, is true and (ii) V rule r' s.t. Head,v =-'L,
Body,v is false.
0 A literal L is false iff (i) V rule r with Head,=L, Body, is false or (ii) 3 rule r s.t. Head,v = -'L
and Body, is true.
In [72], it is shown that an extended program P can be translated into a normal program PC, s.t. the
three-valued completion of PC, is sound and complete w.r.t. the conservative reasoning. The
program PC, is obtained as follows:
0 For every rule L(—- Body, (resp. “Lt— Body,) in P, where L is a positive classical literal, Pa.
contains the clause L+ (— Body, (resp. L‘(— Body,.).
0 For every classical literal L, P‘., contains the clauses Lt— L+, ~L‘ and -'L<- L', ~L+.
For example, if P={p. “p. a(—~p.} then
Pa.={p+. p. a+ (— ~p. a (— a‘, ~a'. -'a (— cr, ~a+. p <—p+, ~p. "p <—p', ~p".}.
and the CVL semantics is M={a, -~a}. Note that neitherp nor "p is evaluated as true because
of the rules “p4— and p<—, respectively. However, ~p is evaluated as true because of the rule "pt—
even though there is the rulept— in P. Consequently, a“ and a are evaluated as true. In contrast, in
the reliable semantics ofP, the truth values of ~p and a are unknown. We think that this is a more

intuitive result because of the mle p<— in P.
The C VL semantics of an extended program P can be a strict subset of the WFMP even when

WFMP is consistent and the intuitively correct semantics. For example, if P = {-'p (— ~p. p.}
then Par={tr <— ~p- p*- p <-p*'. ~p'- ‘72 Hr. ~p*.}.
Note that P is consistent and WIMP—1p, -'p} which is the intuitively correct semantics. Yet, the

three-valued completion of P‘., and thus, the C VL semantics of P does not imply neither p nor ~ap.

2.4.6 Predicate Logic Extensions
Prioritization of defaults is supported in [11, 12] and in [64]. In all ofthese works, a default is a
formula containing only the classical connectives -' and (-. When P has a classical model, the

semantics ofP in [11, 12, 64] coincide with the predicate logic semantics ofP. In [11, 12, 64],

46

rules are considered to be clauses, i.e., there is no distinction between the head and the body of a

rule. For example, the program P = {p (— “p.} is considered equivalent with {p.} and the

semantics ofP is {p}. In contrast, the WFM of P' ={p (— ~p.} is U. In all of these works the
semantics of P is defined as follows:

0 Let M, N be two classical interpretations and D(M), D(N) the set of defaults in P that are
classically satisfied by M, N, respectively. Then, M < N iff D(M)¢D(N) and Vre (D(N)-D(M»,
Sr'e (D(M)—D(N)) s.t. r < r'.

0 An interpretationM is called intended ifl‘ there is no other interpretation N s.t. N < M.

0 The semantics of P is defined as the intersection of all intended models of P.

The most reliable consistent set of premisses D when rules are totally ordered rl<...<r,, is
defined as follows: Do: 0 and V0<iSn, if D,U{r,-} is consistent then Dt+l=Di U03} else Di+l=D,-.
Roos [64] shows that the proposed semantics coincides with the intersection of all classical models
of the most reliable consistent set of premisses for all linear extensions of <R. However, the number
of linear extensions of <R can be exponentially large. For example, the number of linear extensions
of <R={} is nl, where n is the number of defaults.

The intended models of program P in Example 2.3.3 are: M1=coh( {a,-b,c,d,e,-'OK_11,
OK_12,0K_A1}) and M2=coh( {a,ab,-'c,d, e, OK_II,OK_12,-OK_A1}). Thus, the semantics of P

according to [11, 12] and [64] agree with the RSofP.

2.4.7 Ordered Logic

Prioritization of rules is also investigated in [24, 43]. An ordered logic program is a partially-
ordered set of rules without negation by default. Even though the c-assumption-free semantics [24]
and assumption-free semantics [43] are defined for all ordered logic programs, negation by default
is not supported and only the basic constraints are considered. The skeptical c-partial model of an
ordered logic program P is defined in [24] as follows:

0A]

oil

ill

rl

nth

Pro;

Proo

emit
ClESl
Ulc fl
527W
abuzh

15110“.

47
0 A literal set S is c-unfounded w.r.t. an interpretation 1 iff VLe S, if r is a rule in P with Head,=L
then either (i) 3 rule r’ s.t. r’ #1 r, Head,' = *Head, and Body,r UHead,v g] or (ii) Body, n S at

0.
0 A rule r is c-deflasible w.r.t. 1 iff 3 rule r' s.t. r' K r, Head,v = “Head, and (Body,v U Heady)

n (10(1) = 0, where Uc(I) is the greatest c-unfounded set w.r.t. I.
0 The sceptical c-partial model of P is the least fixpoint of the monotonic operator S(1)= {LI 3 rule
r in P s.t. Head,=L, Body,;I and r is not c-defeasible w.r.t. I}.

The skeptical c-partial model of the program P in Example 2.3.3 is
{a,-b,-'c,d,OK_Il,OK_12, OK_AI}. This is because rules r7 and r10 are the only c-defeasible
rules w.r.t. 0 in P. According this model, all gates are working correctly but the truth value of the
output e is unknown. This unintuitive result is derived because in [24], the rule ordering r'<r
represents that rule r is an exception of mle r'. This corresponds in our framework with the case
that S,={} V rule r. In Example 2.3.3, we showed that ifS,={} V rule r then rules r7 and r10 are
the only unreliable rules w.r.t. 0 and the reliable model equals the skeptical c-partial model of P.
The next proposition shows that the reliable model of every ordered logic program, P, coincides

with the skeptical c-partial model of P.
Proposition 2.4.4: Let k<Rp, ICp,<R> be an EPP which is free from default literals, S,={} V

rule r, and 1C, =Bcp. Then, M is the skeptical c-partial model of P [24] ifiM is the set of
classical literals in RMp.

Proof: To simplify the proof, we redefine the operator T(J) of Def. 2.3.2 as follows: T(J)={L| 3
rule r in P s.t. Head,=L, Body,;J and r is reliable w.r.t. J}. Note that both definitions give
equivalent reliable semantics. Let Ia=WpT“(0), for all a. We will show by induction that the set of
classical literals in 1,, coincides with Slate), for all a. This is true when a=0. Suppose that it is
true for all ordinals S a. We will show that the set of classical literals in 10+] coincides with
SWIM). Since S(I)={L | a rule r s.t. Head,=L, Body, :1 and r is not c-defeasible w.r.t. 1}, it is
enough to show that for each rule r, Body, :1, and r is reliable w.r.t. 1,, iff Body,t;ST“(0) and r

is not c-defeasible w.r.t. Slam).

48

Body, 9:1,, and r is reliable w.r.t. Ia

(From the inductive hypothesis and the fact that Body, is free of default literals, it follows that
Body, :slalel.)

iff Body, cSTato) and rule r is reliable w.r.t. 1,,

(From the fact S, ={} V rule r and the reliable rule definition, it follows that r is reliable w.r.t. Ia
ifl' (i) 3 no rule r' K r with Head,v = “Head, and Body,v :Posla or (ii) Body, is not a subset of
P031“. Note that Body, gST“(0)<;Ia:Posla. )

iffBody, gSTaazl) and 3 no rule r' K r with Head,v = "Head, and Body,v UHead,v :Posla

iff Body, :STato) and a no r' act with Head, = «Head, and (Body,.! UHead,v) n (HBp-
P081a1=0

(Let r' be a rule in P with Body,v gPosIa. Then, r' is blocked w.r.t. 1,, iff *Head,v eIa ifi 3 r" K r'
with Head,» = -Head,t and Body,» uHead,» gslaua). Consequently, Uctsla(0»=HBp —Pos 1,. )
iffBody, gslato) and a no r' K r with Head,v = -Head, and (Body,v UHead,v) n UctsTa(c))=o
ifl' Body, gslato) and t is not c-defeasible w.r.t. Slam). o

In [43], the well-founded partial model of an ordered logic program P is defined as follows:
I A literal set S is unfounded w.r.t. an interpretation I ifl‘ VLe S, if r is a rule in P with Head,=L

then either (i) 3 rule r' s.t. r' K r, Head,v = “Head, and Body,v (:1 or (ii) Body, n S at: 0.
0 A rule r is defeasible w.r.t. I ifl‘ 3 rule r' s.t. r' K r, Head,v = '"Head, and Body,.! n U(I) = 0,

where U(I) is the greatest unfounded set w.r.t. I.
o The well-founded partial model of P is the least fixpoint of the monotonic operator S(I)= {Ll 3
rule r in P s.t. Head,=L, Body,t;I and r is not defeasible w.r.t. 1}.

Similarly to [24], rule ordering in [43] represents exceptions and not reliability. This
corresponds in our fiamework with the case that S,={} V rule r. Indeed, the reliable model ofthe

program P in Example 2.3.3 with S,={} V rule r, is the same as the well-founded partial model of

P. Another difference between the reliable model and the well-founded partial model is

49

demonstrated by the following example: The well-founded partial model of P={p. apt-q. "q. q.}
with <R={} is {p}. According to this model, p is true even though “p can also be derived fi'om P.

This is because rule pt— is not considered defeasible. According to [43], the literal q is ambiguous
and thus the derivation of q and “p is blocked. In [70], a similar ambiguity blocking approach

applied to inheritance networks was severely questioned. In our approach, ambiguities are
propagated and thus, rule pt— is considered unreliable. Note that RMp ={}, independently of the

values of S,.

Proposition 2.4.5 5110va that the reliable semantics is more Skeptical than the assumption-free
semantics of [43]. The proposition follows immediately from Proposition 2.4.4 and the fact that the
skeptical c-partial model of an ordered logic program P is a subset of the well-founded partial

model of P [Theorem 8, 24].
Proposition 2.4.5: Let P=<Rp, ICp,<R> be an EPP which is flee from default literals, S,={} V

rule r, and ICp =BCp. Then, the set of classical literals in RMp is a subset of the well-founded

partialmodel of P [43].

The mle ordering <R in RS expresses that in case of conflict, one mle is considered more

reliable than another. Saying that r is more reliable than r' is different than saying that r is an
exception to r'. Let r: Lt—Ll,...,L,, and r': L's—L'l,...,L'm be two rules The fact that r is an

exception of r' can be expressed by replacing the old rule r' with r': L't—L'1,... ',,,~name,. and by
adding the rule: name,(—L],...,Lm [53, 56]. For example, let r: -flies(X)<—penguin(X) and r':
flies(X)<—bird(X). The fact that r is an exception of r' is represented by replacing the old rule r'
with r': flies(X)<—bird(X),~nflX) and adding the rule nflX)(-—penguin(X). The relation <R is
extended as follows: The added rule has lower (resp. higher) priority than a rule r" ifl‘ r<r" (resp.

r"<r).

50

2.4.8 Default Logic
According to default logic, when only partial information is available, the program can be
augmented with a set of default rules. Conclusions drawn with the aid of these defaults are not
certain and they can be defeated by the acquisition of more information.

In Reiter's default logic [63], defaults are represented as inference rules which have a

consistency-check side condition. More specifically, a default rule is an expression of the form:

a 2 b]...bn
c

where a,bl,...,bn and c are well-formed formulas (wffs). The formula a is called precondition, the
formulas bl,..., bn are called justifications and they are checked for consistency with the database
and the formula c is called consequent of the default rule. For example, one would encode the

default "Birds can fly" in default logic as:

b(x];flx)
fix)

which is read as: if x is a bird and it is consistent to conclude that x can fly, then x can fly.

A default theory in Reiter's formalism is a set of sentences W with a set of default rules D. An
extension of this default theory is a logical theory T such that:

1. None of the rules can be consistently applied to obtain a conclusion not already in the extension.

2. Subject to this condition, the extension is minimal.

Consider Fas an operator on a logical theory T, returning a new logical theory F(T) which is
the result of applying a default rule in D to T. Then, TQIIT). An extension E is a least fixed point
of the operator 1". A default theory may have more than one extensions. In default logic, exceptions
should be coded up in the rules. For example, consider the well-known inheritance with exceptions
example: the class of penguins is a subclass of the class of birds but the property of "being able to
fly," which holds by default for birds, is not inherited by the penguins. The knowledge base

51

contains (i) the premises: a is a penguin, penguins are birds, and (ii) the defaults: birds usually can
fly, penguins usually cannot fly. The problem is: "Does a fly?"

One may consider coding this in default logic, as follows:

(X is a variable, p stands for penguin, b for bird, f for fly)

19(0). b(X)<-P(X)- Mil/X.) new"
10’) “fl/Y)

However, even though we expect that a does not fly, the above default theory has two extensions,
one containing f(a) (a flies) and another containing 7(a). To obtain only one extension that

contains fla), the first default should be stated as follows:

W
flX)

Thus, the fact that penguins are exceptions to the default about birds should be explicitly indicated
in the rule. It seems easier to represent exceptions with a hierarchy of defaults, where more
specific defaults have higher priority. The previous example can be stated with an EPP as follows:
P ={ r1 :f(X)(—b(X). r2: “Mt—pm. r3: b(X)<-—p(X). r4: p(a).}

with 8,, = Sn={ }, S,3 ={p(X)}and rl<rz, r2<r3, r2<r4. The reliable model of P contains 7(a), as it
was expected. Assume that later we find that an emu is a bird that generally does not fly. We do
not nwd to modify any rule in P but only add the rules (rs: *flX)<-—e(X). r6: b(X)(—e(X).} with
S,5={}, S,6={e(X)} and the priorities {r1<rs<r6} to it.

A default d in default logic can have a much more powerful representation than a rule in an
extended logic program, since the prerequisite, justifications and consequent of d can be general
wfis. However, a relationship between the RS and the extensions of a special subclass of default
theories can be derived using a result in [27]. Let P be an extended program and TP be the default

theory that contains the default:

L.m:m+ n
L0

52
for any rule L0(—L1,...,L,,,,~L,,,+l,...,~L,, in P. Gelfond and Lifschitz [27] have shown that the

deductive closure of an answer set of an extended program P is an extension of the default theory

T p and vice versa. The next proposition follows from this result and proposition 2.4.2.

Proposition 2.4.6: Let P be an extended logic program. Then, any extension of the default theory
T p is the deductive closure of a stable r—model of P.

Similarly to the answer set semantics [27], there are default theories which do not have

extensions. For example, consider the default theory I 'p:

_:_. :“g
P ‘I
The corresponding extended logic program is: P={r12 p<-. r2: q<—~q. }. The reliable model of P

is RMP ={p, ~-‘p, -q}. The reverse of Proposition 2.4.6 does not hold Since RMp is a stable
model of P but T F has no extension.
A default theory T may have an inconsistent extension in which case it is the only extension of

T. For example, the default theory

—'- —‘— —‘_’

P 10 q
has an inconsistent extension.

The circuit of Example 2.3.3 can be formulated by a default theory (D, W), where Wcontains
the rules r}, i=l,...,l9 and D contains the default rules:

OK_Il OK_IZ OK_Al

The extensions of the above default theory are the deductive closures of the models:
M1={a,-b,c,d, e,-OK_II, OK_12,0K_AI} and M2={a,—~b,-c,d, e, OK_11,0K_12,-OK_A1 }.
Thus, the semantics default logic gives to P coincides with the deductive closure of RS of P.

Since we have only one-level assumptions, both RS and default logic work equally well.

However, a hierarchy of assumptions can be easily handled by RS but not by default logic.

53

2.5 Conclusions

In this chapter, we presented the reliable semantics (RS) for extended programs with rule
prioritization and integrity constraints. We gave both a fixpoint and model theoretic
characterization of RS and proved that they are equivalent. RS is always defined and non-
eontradictory. The RS fixpoint operator avoids contradictions by taking the first of the approaches
presented in Section 1.3. The operator takes into account the priorities of the rules. Rules in P are

implicitly given higher priority than C WAs.
Every rule r has a corresponding set S, gBody,, called the preliminary suspect set of r. When

a constraint .I.<—L1,...,Lk is violated, the rules used in the last step of the derivation of L,- are
considered ”suspect." If a rule r is "suspect" for a constraint violation then the rules and C WAs
used in the last step of the derivation of literals in S, are also "suspect." The values of S, depend on
the reasons for a constraint violation. The motivation behind the idea of the preliminary suspect
sets is given in section 1.3. Criteria for defining the values of the preliminary suspect sets are given
in section 2.2. Intuitively, a rule r is considered reliable if it is not ”suspect" for any constraint
violation caused by rules with priority no lower than r. A C WA is considered reliable if it is not
”suspect" for any constraint violation caused by the well-founded model of P. Only reliable C WAs
and literals derived from reliable rules are consequences of the fixpoint operator of RS.

The model theoretic characterization of the RS of P is given by defining the stable r-models of
P. In subsection 2.3.2, we proved that RS is the least stable r-model of P. RS represents the
skeptical "meaning" of P and thus none of its conclusions is based on unreliable rules or CWAs.
The degree of "skepticism" in RS depends on the preliminary suspect sets of its rules. Credulous
conclusions are obtained by isolating the conflicting results in the multiple stable r—models of P.
Stable r-models of P represent possible "meanings" of P. For example, if P={ "pt—n p(—.} then
P has two stable r-models {“p, ~p} and {p, -~p} which correspond to the two possible meanings
of P. The RS of P is {} which is the intersection of the two stable r-models. In subsection 2.3.1, we
proved that when the Herbrand base of an EPP is finite, the complexity of computing RS is

polynomial w.r.t. the size of the program.

54

In section 2.4, we proved that RS extends the well-founded semantics for normal programs
[76] and extended well-founded semantics [54] for non-contradictory extended programs [54]. RS
generalizes the approaches taken ill ordered logic [24, 43] and conservative vivid logic [77], in the

sense that the latter approaches correspond to the case that S,={} V rule r. RS also generalizes the

approach taken in relevant expansion [79], in the sense that the latter corresponds to the case that
S,=Body, V rule r. In subsection 2.4.7, we proved that if P is an ordered logic program then the
RS of P coincides with the skeptical c-partial model of P [24] and is a subset of the well-founded
partial model of P [43]. We also showed that rule prioritization in RS expresses reliability whereas
in ordered logic it represents exceptions. Ordered logic does not support negation by default and
vivid logic does not support rule prioritization. The relevant expansion approach does not support
rule prioritization and fails to give semantics to every contradictory extended program. Thus, RS

provides a broader framework for unifying these semantics.

CHAPTER 3

MODULAR RELIABLE SEMANTICS FOR MODULAR
LOGIC PROGRAMS WITH RESULT PRIORITIZATION

3.1 Introduction

Modules in a reasoning system arise as a result of a functional decomposition of a complex
reasoning task into a number of simpler subtasks. Each module is an interactive reasoning
subsystem that is used for the (often partial) definition of its exported predicates. In our
framework, a knowledge base consists of a set of modules. Each module contains a set of rules
viewed as an open logic theory [13] with a set of input literals. A module represents an incomplete
specification of some domain because its input literals are defined in other modules. However, a
module becomes a standard extended logic program (closed module) when the truth values of its
input literals are known.

The prospect of contradiction is even stronger when information is distributed in a set of
modules. The code of a module is usually hidden from other modules. Thus, modules export their
results while they hide the way these results are computed. Independent modules export results
obtained only by local information. Independent modules may represent independent data and
knowledge bases. Supervisory modules may aggregate results of lower-level modules or resolve
conflicts between lower-level modules. Cooperating modules exchange intermediate results
towards a conunon goal. When exported results are in conflict, prioritimtion of results can express
higher confidence in some results over others.

Several different proposals assign declarative semantics to modular logic programs including
[48, 49, I4, 44, 68, 50, 9]. Yet, the problem of conflicting predicate definitions by the different
modules is not investigated in the above works. In [68], the syntactical side of modularity is

55

56

modules is not investigated in the above works. In [68], the syntactical side of modularity is
handled. In [14], an algebra of modules is proposed. In [48, 49, 44, 50, 9] dynamic compositions
of modules are considered where the nesting of the modules indicates the direction in which
information is exported/imported. For example, to prove goal G in query [M ]][M2]G, module M2
imports information exported by M1 but not vice versa. In this paper, only statically configured
modules are considered, that is, each module M imports information fiom other modules as
specified in the definition of M .

A prioritized modular logic program (Plltfl’) consists of a set of modules and a partial order

<def on the predicate definitions (M, p), where M is a module and p is a predicate exported by M.

We assume that modules are intemally consistent. However, a PM is possibly not globally
consistent. When a conflict occurs, <def expresses our relative confidence in the predicate
definitions contributing to the conflict. Each module has a set of local literals that are inaccessible

to other modules. Literals that can be accessed (imported) by any module have the form
{M1,...,Mn}°A, {M1,...,M,,}: “A or {M1,...,M,,}: ~A, where M,- are module names and A is a

conventiOnal atom whose predicate is exported by all Mi. Intuitively, a literal {Ml,...,Mn}'A is
evaluated as true if (i) A is derived from a module M; and (ii) if “A is derived fi‘om a module M]- at
114,- then resultA has higher priority than result "A. A literal {Ml,...,Mn}: ~A is evaluated as true if
{M1,...,Mn}: “A is true or ~A is true in all modules Mi-

We present a semantics for PAWS, called modular reliable semantics (ll/IRS), which assigns a
truth value true, false or unknown to every literal. Every PW has at least one stable m-model.
The ms of a program P is the least fixpoint of a monotonic operator and the least stable m-model
of P. When a PM is contradictory, exported results (represented by indexed literals) are
considered unreliable if: (i) they contribute to a contradiction, and (ii) they do not have higher
priority than the other contributing results. The ms of a PM, P, represents the skeptical meaning

of P and thus none of its conclusions is based on unreliable exported results. Credulous

57
conclusions are obtained by isolating the conflicting results in the multiple stable m-models of P.
The complexity of computing MRS is polynomial w.r.t. the size of the program (when the Herbrand
Base of P is finite).

A prioritized extended logic program (PEP) consists of a set of partially ordered rules. A
PEP can be translated into a PM by considering each rule as a module that imports all predicates
appearing in its body and exports its head predicate. Consequently, the MRS for PEPs is also
defined. AIRS is defined for all PEPs and extends the well-founded semantics [76] and the extended
well-founded semantics [54]. Under certain conditions, a PMP can be translated into a PEP with

equivalent modular reliable semantics.

3.2 Informal Presentation and Intuitions

Our fiamework can be used for the representation of result-sharing cooperating agents [46]. A
complex task is statically decomposed into a set of simpler subtasks, each assigned to an agent.
Each of the subtasks may be decomposed into even simpler subtasks, each assigned to a lower-
level agent. An agent consists of a theory and, implicitly, by an inference mechanism. The theory of
an agent is encapsulated in a module whose name is used for the identification of the agent.
Typically, the subtask of an agent can not be solved only with local information and agents import
results exported from other agents. Agents may have overlapping or even identical capabilities.
Therefore, it is possible that they export agreeing or contradictory results. When agents M 1, M2
export contradictory conclusions about a literal L, the truth value of L w.r.t. M1, M2 (expressed by
the truth value of the literal {M1, M2} J.) is unknown. Yet, agents M1, M2 maintain their individual
beliefs about L which is expressed by the truth value of the literals {M1}:L, {M2} 2L, respectively.
Example 3.2.1: Sensors S 1, 82 are gathering information from two difl‘erent angles about the
persons entering a building. Modules M1, M2 are assigned with the identification of terrorists based
on the information collected from sensors S1, 8;, respectively. Each module M1, M2 exports the

58

result entered(terrorist) (resp. aentered(terrorist)) iff it reaches the conclusion that an (resp. no)
terrorist has entered the building. It is possible that M1, M2 disagree, i.e., M1 exports

entered(terrorist) whereas M2 exports “entered(terrorist). The results exported by M 1, M2 can be

queried by other modules in various ways. For example,

0 Query] t—{Ml } :entered(terrorist), {M2} :entered(terrorist).
Query] is true if entered(terrorist) is true in both M1, M2. Query] is false by default if
entered(terrorist) is false (by default or classically) in at least one of M 1, M2.

0 Queryz (—{M] }: -'entered(terrorist).
Queryz is true if -entered(terrorist) is true in M1 (even if entered(terrorist) is true in M2).

0 Query; (—{M1 , M2}: entered(terrorist).
Query3 is true if entered(terrorist) is true in at least one of M 1, M2 and M1, M2 do not disagree.
Query3 is false by default if entered(terrorist) is false in both M1, M2.

0 Query4 e—{Ml }: ~entered(terrorist).
Query4 is true if entered(terrorist) is false in M1 (even if entered(terrorist) is true in M2).

0 Querys (—{M 1, M2}: ~entered(terrorist).

Querys is true if entered(terrorist) is false in both M1, M2.

Individual agent theories are assumed to be consistent. Yet, the consistency of the union of
agent theories is not assured. As we saw in Example 3.2.1, one case of contradiction is when
independent modules export contradictory results. In this case, the contradiction depends only on
the independent modules and it is relatively easy to resolve. Yet, generally, contradictions may
involve several module interactions. For example, an agent exports a faulty result, this result is
imported by another’agent which exports a faulty result based on the imported faulty result. After a

few module interactions, contradiction may arise in two ways :

59

(i) Complementary literals are derived inside an module. For example, both q, -'q are derived inside
module M3 of program P. Note that the derivation of q, “q is based on the imported results

{Ml}=p. {Maize respectively.

program P
module M1 exports p module M2 exports r module M3 imports p, r
rules p. rules r_ rules q (— {M1}:p. “qt- {M2}:r.

(ii) Complementary literals are exported fiom two different modules. For example, in program P2,
module M2 exports the result "~q. Module M3 exports q whose derivation is based on {M 1 }:r.

program P2
module M1 exports r module M2 exports q module M3 imports r exports q
rules r_ rules "q. rules q(-— {M1 } :r.

When contradiction appears, the sources of the contradiction are traced back to the
contributing exported results. Domain specific information might indicate that some exported
results are more reliable (have higher priority) than others. Let resl and resz be two exported
results contributing to the contradiction. If res] has higher priority than res2 and no contradiction
arises without res2 then only res] is taken into account. If the priority of res], res; cannot be
compared then both are eliminated from lltfllS (skeptical approach). For example, in the program P
above, {Ml}:p and {M2}:r are two exported results contributing to the derivation of q, 'rq in
module M3. If the definition of p in M1 has higher priority than that of r in M2, i.e., (Mz, r) <“
(Mb p), then result {M1}:p is considered more reliable than {M2}:r. In this case, {M1}:p is true
and {M2}:r is unknown in all stable m-models of P. Ifnone of {M1}:p, {M2}:r is more reliable
thantheotherthentheir truth value inMRSis unknown. Results {M1}:p, {M2}:rare isolated inthe
stable m-models of P. In other words, there is a stable m-model which evaluates only {M1}:p as
true and another which evaluates only {M2} :r as true.

60

3.3 m-models for Prioritized Modular Logic programs

Our alphabet contains a finite set of constant, predicate and variable symbols from which ordinary
atoms are constructed in the usual way. It also contains a finite set of module names. An indexed
atom has the form {M1,...M,,}'A, where A is an ordinary atom and M, are module names. A
classical literal is either an atom A or its classical negation “A. The classical negation of a literal
L is denoted by “L, where {*L)=L. A default literal is the default negation ~L of a classical
literal L, where ~(~L)=L. A literal is called indexed when its corresponding atom is indexed. We
define {M1,...M,,}:-A = *{M1,...,M,,}‘A and {M1,...,Mn}:~A= ~{Ml,...,M,,}:A, where M, are
module names and A is an ordinary atom. The classical literals L, aL are called complementary to
each other. The predicate of a literal L is denoted by predL.

A module with name M is a tuple <ExpM, ImpM, RM>. The set ExpM contains the predicates
that are exported (defined) by M. The set ImpM contains the predicates imported by M. The set RM
contains rules of the form: L(—L1,...,L,,,,~Lm+l,...,~L,,, where L is a non-indexed classical literal
and L} are classical literals. If an indexed literal {M1,...,M,,}'L is in the body of a mle then M
imports L fiom the modules M,,...,M,,. If a non-indexed literal L is in the body of a mle and
predLe ImpM then M imports L from all modules that export predL. '

A prioritized modular logic program (PM), P, is a pair <Modp, <def >. Modp is a set of
modules and <def is a partial order on Defp, where Defp ={(M,p) IMeModp and pe ExpM}. Each

(Mp)e Defp represents the definition of predicate p in module M. If {M1,...,M,,}J. is an indexed
literal appearing in P then (Mia-edge Defp, ViSn.

Individual modules are assumed to be consistent but their union may be inconsistent. Thus,
when complementary literals are derived within a module M, it is beeause of unreliable information
imported byM. When literals L, "L are derived from difl‘erent modulesM,M', it is because the
definition of predL in M, M' is unreliable or the information imported by M, M’ is unreliable. When

61

conflict occurs, <Mexpresses our relative confidence in the predicate definitions contributing to the
conflict. Let (Mp) and (M ',p') be in Defp. The notation (Mp) <def (M ',p') (resp. (M,p) KM (M',p’))
means that the definition of p in M is less (resp. not less) trusted than that of p' in M '. Intuitively, a
literal L exported by a module M is reliable if it does not contribute to any derivation of
complementary literals caused by definitions (M 'p') K” ,predL). Note that, the reliability of L is

not affected by predicate definitions less trusted than the definition of predL in M.
We define SL= {Me Modp | predLe ExpM}, where L is a literal. The indexed literals SLLL are

called globally indexed. To simplify the presentation of the semantics a renaming mechanism is

employed. Let r be a mle in a module M. Then, the head L of r is replaced by a new literal MtiL.
Every non-indexed literal L in the body of r with predLe ImpM is replaced by M#L. Every non-

indexed literal L in the body of r with predLe ImpM is replaced by the globally indexed literal SL'L.
Literals MitL are called local to M and they are not accessed by other modules. In contrast to local
literals, indexed literals are accessible to all modules. When we refer to a PMP, we assume that the
above renaming has already been done. Note that after renaming, only local and indexed literals
appear in a module M. We define Mil-'A = WM and M#~A = ~M#A, where M is a module name

and A is an ordinary atom.
The Herbrand Base (HBP) of a PMP, P, consists of (i) the instantiations of the classical

literals appearing in P, (ii) the globally indexed classical literals SLzL, where L is the instantiation
of a literal in P, and (iii) all literals MiiL, where L is an instantiated literal and WpredLE Defp.
'Ihe instantiation of a PM is obtained by replacing each module with its instantiation which is
defined in the usual way. In the rest of the paper, we assume that programs have been instantiated
and thus all rules are propositional.

Let M be a module. We define closeu(M) as the extended logic program that results if we

replace every indexed literal in M with the special proposition u (meaning undefined). We say that
M is internally consistent iff the extended well-founded semantics [54] of closeu(M) is defined

62
(the WFM of closeu(M) is not contradictory). All modules of a PM are assumed to be internally

consistent.
Example 3.3.1: A cantig is a set of overlapping DNA fragments that span some region of a

genome [80]. One method to detect overlaps uses common features (restriction digest patterns,
hybridization signals, STS hits). The idea is that if the same feature is found in two DNA
fragments then they probably overlap. The overlap is not certain because of unreliable
experimental results and feature repetition in the genome. Consider the following PW (before
renaming) with modules 0D (OverlapData), 0F (OverlapFeature), F (Feature): (terms that start

 

with capital are variables)
figure x DNA fragment 1
Lame x DNA fragment 2

 

 

Figure 3.1: DNA fragments

module 0D exports overlap /* Very reliable Overlap data ‘/

rules “overlap(fragl,frag2).

module 0F exports overlap imports feat
If If the same feature Feat is found in fragments Fragl and Frag2 then the fragments overlap ‘/

rules overlap(Fragl,Frag2)(—fieat(Fragl,Feat), feat(Frag2,Feat).

module F exports feat /‘ A feature x is found in fiagmentsfragl and frag2 ‘/

rules feat(fi'agl, x). feat(frag2, x).

(F feat) <a. (0D,0verlap) I“ overlap data in CD are more reliable than the experimental data in F 'I

63

Even though the modules OD, 0F and F are internally consistent, their union is inconsistent
because both overlap(fragl,fi:ag2) and mverlapw'aglflagZ) can be derived from the above rules.
Note that 'aoverlap(frag1,frag2) is derived from module 0D and that the derivation of
overlap(f‘raglfrag2) from module 0F depends on feat(fragl,x) and feat(frag2,x), exported by
module F. Since (F,feat)<def (OD,overlap), i.e., the definition of feat in F is less reliable that of
overlap in 0D, the results fiaat(fragl ,x) and feat(fi'ag2,x) are considered unreliable. Thus, the truth
value of the literals feat(fragl ,x) and feat(frag2,x) is considered unknown and the literal
‘bverlap(fiagl,fiag2) is evaluated as true. After the renaming mechanism is employed, modules
become:

module 0D exports overlap

rules -OD#overlap(frag1,fr'ag2).

module 0F exports overlap imports feat
rules OFiioverlap(Fragl,Frag2)<— {F} :feat(Fragl, Feat), {F} :feat(FragZ, Feat).

module F exports feat
rules Fit/eatViagl, x). Fiifeat(fi'ag2, x).

Definition 3.3.1 (interpretation): Let P be a PMP. An interpretation 1 is a set of literals TU~F,
where T and Fare disjoint sets of classical literals. I is consistent iff TnaT = 0. I is coherent iff it

satisfies the coherence property. “TQF.

An interpretationlcan also be seen as a pair <1“, 1,03, wherelwis the set ofindexed literals
contained in I and 1,0,[M], for any module M, is the set of local literals of M contained in I.

64
Definition 3.3.2 (truth valuation of a literal): A literal L is true (resp. false) w.r.t. an

interpretation I ifi‘ LeI (resp. ~Lel). A literal that is neither true nor false w.r.t. I, it is undefined

w.r.t. I.

The truth value of a literal MitL represents the truth value of L in module M. A classical literal
{M1,...,M,,}J. is true iffMiiiL is true for an iSn and {M],...,M,,}1. is reliable. A default literal

~{M],...,Mn}'L is true ifl’~M,-#L is true for all iSn and ~{Ml,...,Mn}:L is reliable. Let I be a set of
literals known to be true. In Definition 3.3.5, the concept of reliable indexed literal is defined which
is used in defining the m-models and in the fixpoint computation of the modular reliable semantics.
To decide if an indexed literal S 'L is reliable w.r.t. a definition (Mp), all possible derivations of
complementary literals caused by definitions (M'p') KM (Mp) should be considered. SL is
reliable if it does not contribute to any such derivation of complementary literals. Intuitively,
1,0511“.le contains the literals possible to derive when results exported by modules M ' with

(M'predL) <w (Mp) are ignored. Posmle is defined as the least fixpoint of a monotonic operator

which resembles the well-founded semantics operator [76].
Definition 3.3.3 (possible literal set): Let P be a PM, I,J sets of literals and (M,p)e Defp. The

possible literal set w.r.t. (Mp) and I, denoted by Poswpu, is defined as follows:
- P’I'W.p,_,(J)={M’#L | 3 M'#L(—Ll,...,L,, in moduleM’ s.t. LieJ, ViSn} U
{S'Le HBp | -S:LrEI and 3 M'e S s.t. M'iiLeJ and (M'pred,) K“, Mp»
- PFM P1J(J) is the greatest set U c; HBp s.t.
(i) if MiiLe U and r is a rule s.t. Head, = M'#L then 3Ke Body, s.t. Ke U or ~Ke J,
(ii) if SLe U then VM'e S, M ’#Le U and (M 'predl) K” (Mp).
‘ waww = cahmrMle‘J) U ”PF [WM-’1)-
- Poem,“ is the least fixpoint of the operator PWWJ,”

65
A local literal M'iiLe PTIMJJIJU) iff there is a rule r with Head, = M '#L and Body, c J. Since

modules are assumed to be internally consistent, we do not need to verify that "'M'iiLe I. An
indexed literal {M1,...,Mn}:Le "Mill/(J) ifl‘a{Ml,...,M,,}:L is not true w.r.t. I and for an iSn, L
is true in M,- w.r.t. J and Wipredl) Kg, (Mp). Conditions (i) and (ii) in the definition of
PFMPIJU)’ generalize the concept of unfounded set, as defined in [76]. The additional condition
(ii) expresses that {M1,...,M,,}J. is false by default if for all iSn, L is false by default in M,- and .
(MipredL) K” (Mp). Coherence is enforced by the coh operator in the definition of wa.le(-’)-
Intuitively, a literal S1. is reliable w.r.t. (Mp) and I ifi‘ there are no K, "‘K in Posmpu s.t. the

derivation of K depends on S1. The dependency set of K w.r.t. (Mp) and I is the set of literals in
Poswm that the derivation of K depends on. Since I is a set of literals known to be true, the

dependency set of a literal KeI equals {}.
Definition 3.3.4 (dependency set): Let P be a PMP, I a set of literals and (M,p)e Defp. The
dependency set of a literal K w.r.t. (Mp) and I, denoted by DepwplfK), is the least set D(K) such

that ifKeIthen D(K)={} else
(i) If K= ~M’#L is a default literal thar
(a) D(-M#L) t; D(~M'#L) and
(b) V M'#L(-L1,...,L,, inM', if ~L,e Poswle for iSn then D(~L,):D(~M'#L).
(ii) If K=M'#L is a classical literal then
if M'#L£—L1,...,L,, inM' s.t. {L1,...,L,,};Posw.puthen D(L,)<;D(M'#L), ViSn.
(iii) IfK= ~SJ. is a default literal then
(a) D(‘iS'lJ cD(—~tS:L) and
(b) if VM'e S, (M'pred,) K“ (Mp) and ~M'#Le Posmpu then D(~M'#L) ;D(~S:L), VM'e S
and ~S'1Le D(~S:L), VS'cS.
(iv) IfK= S:L is a classical literal then
(a) D(llfliL) ;D(S:L), VM'e S s.t. W'predl) K“ (Mp) and S'2Le D(SzL), VS';S.

66

Case (i) expresses that ~M'#L can be true because of the coherence inference rule or the
default rule for negation. Case (ii) expresses that if M’#L<—L1,...,L,, is a rule and all L,- are true

then M'iiL is true. Case (iii) expresses that if “S:L is true or ~M’#L is true for all M'e S then ~SJ.
is true Case (iv) expresses that if M '#L is true for an M'eS then S:L is true and if S"L is true for
an S'gSthen S1. is true.
Definition 3.3.5 (reliable indexed literal): Let P be a PMP, I a set of literals, S1. a literal,
(MpredL)e Defp, Me S and p be equal to predL.
0 The literal S:L is unreliable w.r.t. (Alp) and 1 iff 3 '"Ke Poswle s.t.

ifK = S':L with S' 3 S then S:Le DepwleW'iiL) for anM’e S' s.t. (M'p) K“ (Mp)

else S:Le DepwplfK).

0 The literal SJ. is reliable w.r.t. (Mp) and 1 iff it is not unreliable w.r.t. (Mp) and 1.

Assume that S:L is unreliable w.r.t. (Alp) and I. If K of Definition 3.3.5 is a loeal literal
M'iiL' then (i) the literals K, “K are derived inside module M' and (ii) S1. contributes to the
derivation of K. IfK = S"L' at SJ. is an indexed literal then: (i) there are literals M'iiL', -M'#L'
derived in modules M'e S’ and M"eS' s.t. (M'p) K“, (Mp) and (M"p) Kw (Mp), and (ii) S1.
contributes to the derivation of M'iiL'. If K = SJ. then there are literals MiiL, M'#L derived in
modulesM'eSandM'eSwith (M'p) Kdef (Mp) and (M"p) K” (Mp).

Example 3.3.2: Let P be the PM of Example 3.3.1 and [=0

PoleD’mflapu = coh({-'0D#overlap(fi'agl,frag2), “{OD} :overlap(fi'agl,frag2),
“(OD,OF} :overlap(fi'ag l ,fi'agZ) })

The literal “{OD} :overlap(fragl,frag2) is reliable w.r.t. (OD,overlap) and I because
a{OD}:overlap(fragl,frag2) e Depl00,m,apu("K), VKe Posroomtapu-

Similarly, 100,017} :overlap(fragl,frag2) is reliable w.r.t. (OD,overlap) and I.

67

Poslpquy = coh({l'tfeatwaglxt {F} :featlfraglx). Ftflatwagh). {Fl feat(fragzx),
Olilioverlap(fragl ,fr'ag2), {0F} :overlap(frag l ,fragZ), {OD,OF} :overlap(frag l ,frag2),
-'0D#overlap(fragl frag2), *{OD} :overlap(frag l frag2 ), “{OD,0F} :overlap(fragl,frag2)})
The literal {F} feat(fraglx) is unreliable w.r.t. (F fear) and I because

(i) “{OD,0F}:overlap(fragl,frag2) e PolekW and

(ii) {F} :feat(fi’agl,x) e DeplFfw,lJ({OD,0F} :overlap(fragl,frag2)).

Similarly, {F} :feat(frag2,x) is unreliable w.r.t. (F feat) and I.

Poslopmu = Polelle. The literal {0F} :overlapUi'aglfragZ) is reliable w.r.t. (0F,overlap)

and 1 whereas the literal {00,017} :overlap(fragl,frag2) is not.

Definition 3.3.6 (nu-model): Let P be a PMP. A consistent, coherent interpretation I is an m-model
of P ifl‘ (i) V rule r, I(Head,)ZI(Body,) and (ii) V classical literal S:L, both of the following are

true:
- if I(S'L)¢l then VMe S s.t. I(M#L)=l, Si is unreliable w.r.t. (AlpredL) and I

- if I(S:L)=0 then I("‘S'L)=l or VMe S, I(M#L)=0.

'Since condition (i) defines 3-valued models [60], an m-model of P is a 3-valued model of
every module of P. In condition (ii), the first subcondition expresses that if S1. is a classical literal,
MeS and I(M#L)=l then I(S:L) can be :1 only if S1. is unreliable w.r.t. (M,predl) and I. The
purpose of the second subcondition in condition (ii) is to allow S1. to be false when aSzL holds,
even if3MeSs.t. I(M#L)>0 (L is not false inM).

Example 3.3.3: Let P be as in Example 3.3.1. Then, I is an m-model ofP:

68
I =coh({Fii feat(frang), FiifeatmagZJ), -0D#overlap(/i'ag l frag2),
-'{ 0D} :overlap(frag l ,frag2), “{OD,0F} :overlap(frag l ,frag2)} ).

3.4 Modular Reliable Semantics for Prioritized Modular Logic

Programs
In this Section, we define the reliable m-model, stable m-models and modular reliable semantics

of a PMP, P. We show that the reliable m-model of P is the least stable m-model of P.

3.4.1 Reliable m-model
An m-unfounded set U w.r.t. J is also an unfounded set w.r.t. J according to [76] with an additional

constraint: if S:Le U then ~S1. should be reliable w.r.t. (MpredL) and J, VMe S.
Definition 3.4.1 (nr-unfounded set): Let P be a PA? and J a set of literals. A literal set U gHBp

is m-unfounded w.r.t. J ifi‘
(i) if M#Le U and r is a rule with Head,=M#L then 3Ke Body, s.t. Ke U or ~KeJ,

(ii) if S:Le U then VMe S, M#Le U and ~S:L is reliable w.r.t. (Mpredl) and J.

The Wp operator extends the WP operator of the well-founded senmntics [76], to PAfl’s.
Definition 3.4.2 (W p operator): Let P be a PM and J a set of literals. We define:

0 T(J)={M#L |3M#L<—L1,...,L,, in moduleM s.t. LieJ. ViSn} U
{S:Le HPP |M#Le J, Me S and SJ. is reliable w.r.t. (Mpredl) and J}

' F (J) is the greatest m-unfounded set w.r.t. J.
' me=cohrwiu~rwl

The union of two m-unfounded sets w.r.t. J is an m-unfoum set w.r.t. J. So, F(J) is the
union of all m-unfounded sets w.r.t. J. We define the transfinite sequence {Ia} as follows:

69
10={}, 1a,,=wp(1a) and 1a: cub | b<a} ifa is a limit ordinal.

Proposition 3.4.1: Let P be a PMP. {la} is a monotonically increasing (w.r.t. :) sequence of
consistent, coherent interpretations of P.

Proof: We will show that WP is a monotonic operator. Let I,J be interpretations of P s.t. 1;].
Then, T(I)<;T(J) because if a classical literal S1. is reliable w.r.t. a predicate definition (M,predL)
and I then SJ. is also reliable w.r.t. (M,predL) and J. F(DCFU) because if a default literal ~S1L is
reliable w.r.t. a predicate definition (M,predl) and I then ~SJ. is also reliable w.r.t. (M,predL) and
J. Since coh is a monotonic operator, WP is a monotonic operator and {Ia} is a monotonically

increasing sequence w.r.t. ;.

We will prove by induction that for all a, there is no literal K s.t. {K,*K};Ia This is true for

a=0. Assume that it is true for ordinals <a. We will prove that it is true for a. Assume first that
a=b+l is a successor ordinal. Assume that there is literal K s.t. {K,-'K}c;1a. Since 1b is consistent

we can assume that KE Ib- Since {K,-'K}g:Ia and the modules are internally consistent, there is
classical or default literal S:LE 1b which in the computation of 1b is considered reliable w.r.t. a
predicate definition (M,predL) and 1c, for c<b, *Ke Posw'pl’lc and S:Le Depw’pl’IJK). However,
this is a contradiction. Thus, la is consistent.

Let a be a limit ordinal and assume that there is literal K s.t. {K,-K};la. Then, there is a
successor ordinal b+l<a s.t. {K,“K};Ib+1. This is a contradiction because of the inductive

hypothesis. So, la is consistent for all a.

We will prove by induction that for all a, there is no literal L s.t. Le Ia and ~Le Ia. It is true

fora=0. Assumethatitistrue forordinals <a. Wewillprovethatit istrue fora. Assumefiistthat
a=b+l is a successor ordinal. We will prove that there is no literal L s.t. Lela and ~LeIa. This is

true for a=0. Assume this is true for ordinals <a. Let S be any set of classical literals that has a
non-empty intersection with T(Ib). Choose the smallest c s.t. [0+1 has a non-empty intersection

70
with S. Note that ch. Let Ke Ic+1nS. IfK is a local literal M#L then M#L is derived fi'om a rule r

s.t. Body,.:lc. If K is a global literal S1. then 3MeS s.t. M#L is derived fiom a rule r with
Body,.;lcr, c'<c. From hypothesis, there is no literal Ke Body,., s.t. ~Ke1b. Moreover, from the
way r is defined, there is no classical literal K in Body,. s.t. KeS. So, S is not m-unfounded w.r.t.
lb. This implies that T(Ib)nF(Ib)=0. Moreover, there is no classical literal L s.t. Le T(Ib) and
“Le T(Ib), because Ia does not violate any constraint. So, there is no literal L s.t. Le Ia and
~Le Ia. Let a be a limit ordinal and assume that there is L s.t. Le Ia and ~Le Ia. Then, there is a
successor ordinal b+l<a s.t. Le 1b+l and ~Le 1b+1- This is a contradiction because of the inductive

hypothesis.
la is a coherent interpretation, for all a, because of the cob operator in the definition of W p.

Proposition 3.4.1 follows. 0

Since {la} is monotonically increasing (w.r.t. g), there is a smallest ordinal d s.t. 1d=1d+1-
Proposition 3.4.2: Let P be a PMP. Then, Id is an m-model of P.
Proof: From Proposition 3.4.1, Id is a consistent, coherent interpretation. Let r be a rule in P. We
will show that r is m-true w.r.t. Id.
(i) For every rule r, Id(Head,.)ZId(Body,.).
(ii) IfS:L is a classical literal, Id(S;L)¢l, and 3MeS s.t. Id(M#L)=l then S:L is unreliable w.r.t.
(M,pred,) and Id because otherwise, fiom the definition of T(Id), Ia(Si.)=l.
(iii) If S:L is a classical literal, Id(SJ,)=O, and ElMeS s.t. Id(M#L)¢0 then Id(-'S:L)=l because
otherwise, from the definition of F(Id), Id(SJ.)¢O. 0

Definition 3.4.3 (modular reliable semantics): Let P be a PW. The reliable m-model of P,
denoted as MP, is the interpretation Id. The modular reliable semantics of P is the "meaning”

represented by RM».

71

It is possible that a local literal M#Le RMp but {M} :LE RMP. This, intuitively, means that

module M concludes L but that conclusion may be erroneous.
Example 3.4.1: Let P be the program of Example 3.3.] and I be the m-model of Example 3.3.3.
Then, I is the reliable m-model of P. 1 can also be seen as a pair (1,“, 1,0,), where:

1,,,,= coh({ -{01) } :overlap(frag 1 ,fragZ), 100,05} :overlap(fragl,frag2)} ) and
1.0.[F]= coh({mfeaflfmglxh ”feat(fmghn ), 1,..[0F]={} and

1,400] = coh( {-OD#overlap(fragl,frag2)}).

When <M={ }, RMP = coh({FiifeatVraglch Fhfeat(frag2,x), -'OD#overlap(fmgl,fr'ag2)}).

Proposition 3.4.3: Let P be a PW. The complexity of computing RMp is 0(IHBpl3‘lRpl).
Proof: The following algorithm, RM(program P), returns the reliable m-model of P. To compute

F(I), its complement set is constructed first, as in [76].

RM(P1W’ program P)
{ neW_1={ };
repeat
I=new_1; '
for each Wp)e Defp do /" Step 1 I"I
compute Posww; endfor /"' Step 1.1 ‘l

for each Le HBP do compute Depw‘pua); endfor /* Step 1.2 ‘/
endfor

repeat /‘ Step 2: Compute T(I) I'/
for each rule r in P do
if Body,. cnewJ then add Head,. to new}; endif

endfor

for each M#Le new__1 do
for each Sle HBp do

if Me S and SJ. is reliable w.r.t. (M,predL) and I then add S:L to new_I; endif

endfor
endfor
until no change in new_1;

72
compl_F= {Sle HBP | ~S'L is unreliable w.r.t. (M,predL) and I, for an Me S}; /* Step 3 */
repeat /* Step 4: Compute HBP —F(I) */
for each rule r in P do
if no literal in Body,. is false w.r.t. I and all classical literals in Body,. are in compl_F

then add Head,. to compl_F;
endif
endfor
until no change in compl_F;
for each Le HBp do /* Step 5*/

if LE compl_F then add ~L to new_I; endif
endfor

new_1=coh(new_1); /* Step 6: Compute coh(T(I)U~F(I)) ‘/
until I=new_1;
returnU);
}

The complexity of computing P03, is the same as that of computing the well-founded model of
PlMle’ where PtMle= P U {Si(—M'#L| Sie HBP, M'e S, “Siel and (M',predL) st” (M,p)} U
{S:L<—u | ElM'e S, and (Al'predL) <clef ,p)} and every literal “L is replaced by a new atom -:_L.
So, the complexity of Step 1.1 is IHBpPIRpl [Witt9L Schl92]. The complexity of Step 1.2 is
IHBPI'IRPI because the complexity of computing Dep](L), for a literal L, is lRpl. So, the complexity
of Step 1 is IDefp|*|HBp|*|Rp| < WBp|2*|Rp|. The complexity of Step 2 is IHBplz‘lRpl since
Poem!” and Depw p] 1(L), VLe HBP, have already been computed. The complexity of Step 3 is
IHBPF and that of Step 4 is lRpl [DoGa84]. The complexity of Steps 5 and 6 is IHBpl. Since {Ia}

is a monotonically increasing sequence w.r.t. ;, the total number of iterations until I=new_1, is less
than lHBpl. So, the complexity of the algorithm RM(P) is O(|HBp|3*|Rp|). 0

According to MRS presented in the previous sections, the confidence in a globally indexed
default literal ~L, derived by the default rule for negation, depends on the minimal priorities of
(M,pred,)e Defp. Thus, in case of conflict, ~L may not be considered less reliable than literals that

their derivation is not based on closed-world assumptions. When this is undesirable for a set of

73
predicates Pred~ , a new module M~ can be added which has no rules but exports all predicates in

Pred__. Moreover, (M~,p') <M(M, p) for all p'e Fred and definitions (M, p) other than (M~,p).
Example 3.4.2: Consider the PMP, P:

module M1 exports broken

rules M1#brokem— ~M]#spark. M l#spark.

module M2 exports start

rules M2#start (— ~broken. /* ~broken represents a globally indexed literal */

module M3 exports start /"' observed data */

rules ‘rM3#start.

<der={}-

The MRS of P is: coh( {M1#spark, ~M1#broken, “M3#start, "(M3):start}). Note that the truth
value of the literal {M2, M3}:start is unknown This expresses that M2, M3 export conflicting
results about start and that none of these results has higher priority than the other. One may argue

that closed-world assumptions should have lower priority than explicit rules. Thus, the result
exported from M2 should count less than that of M3 and {M2M3}°start should be evaluated as

true. This is obtained by adding a module M~ to P as follows:
module M... exports broken

rules {}
W~,broken) <H(Ml,broken), (M~,broken) <M(M2,start) and (Mgbroken) <der(M3,start).

The MRS of the new P is: coh( {M 1 #spark, ~M]#broken, "M3#start, "r {M3} :start,

“{M2M3}:start}).

74

3.4.2 Stable m-models

The reliable m-model of a PMP corresponds to its skeptical meaning. Credulous meanings can be
obtained using the transfomiation P/ml, where I is an interpretation of P. The transformation PI] is

defined in [26, 60] for a nomral program P. PIMI extends P” to PMPs.

Definition 3.4.4 (transformation P/Ml): Let P be a PMP and I an interpretation. The program PI"!
is obtained fi'om P as follows:

(i) Remove all rules that contain in their body a default literal ~L such that 1(L)=l.

(ii) Remove all rules r such that 1(-'Head,.)=l.

(iii) Remove fi'om the body of the remaining rules any default literal ~L such that 1(L)=O.

(iv) Replace all remaining default literals ~L with u.
(v) For all S:Le HBp s.t. I(S:L)=l/2,

- for all Me S, if I(M#L)=l then add S1,(—-u else add S:L(—M#L,
— if ElMe S s.t. ~SLL is unreliable w.r.t. (M,predL) and I then add S1.(—u.

(vi) For all S:Le HBp s.t. I(S:L)¢l/2 and l(-'S1.)¢l, add S1.<—M#L, VMe S.

The program P/,,I is a non-negative program with a special proposition u. For any
interpretation J, J(u)=l/2. When P is a nomral program and I is a model of P [60], Pl”! a PI] since
Steps (iv) and (v) do not have any effect on P/ml. We say that a model I of P is the least, model of
P ifl‘I(L)SI'(L), for any model 1' and classical literal L of P.

Definition 3.4.5 (stable m-model): Let P be a PMP and 1 an m-model of P. I is a stable m-model
of P ifl‘ least,(P/.I)=I.

Let I be a stable m-model of P. If S:L is unreliable w.r.t. (M,predL) and I, for an MeS then the
truth value of S:L can be unknown w.r.t. I even if I(M#L)=l. If ~S1. is unreliable w.r.t. (M,predL)

75
and I, for an MeS then the truth value of S1. can be unknown w.r.t. I even if IW#L)=O, for all

Me S.
The export rule set of P is defined as ERP = {S.'L(-—M#L| S:LeHBp and Me S}U

{~S:L(—~M1#L,...,~M,,#L | S:LeHBp and S ={Ml,...,Mn}}. An interpretation 1 of P satisfies
re ERP iff 1(Body,.)¢l or I(Head,)=l. Let I 1, 12 be two stable m-models of P. We say that I] s“,
12 ifi‘ (i) Vre ERp, if I 1 satisfies r then [2 satisfies r and (ii) I] C 12 or are ERp s.t. 12 satisfies r and
I] does not satisfy r. In other words, 11 S“, 12 iffIz satisfies more export rules than I] or (II c 12
and [2 satisfies the same export rules as 11). Maximal (w.r.t. Sm) stable m-models can be seen as

the credulous meanings of P.
Example 3.4.3: Let P be the program of Example 3.3.1. RMP is given in Example 3.4.1. Then, P

has four stable m-models:

11=RMP, 12=RMP U coh({ {F} :feat(fragl,x)}), I3=RMP U coh({ {F} :feat(frag2,x)}) and
I4=RMp u coh({ {F} :feat(fragl,x), {F} feat(frag2,x), OFitoverlap(/ragl,fragZ),

{0F} :overlap(fragl ,frag2) } ).

12, I3 and 14 are maximal (w.r.t. Sm) stable m-models of P. Note that

Model 12 does not satisfy {F} feat(frag2,x)(— F#fiat(fiag2,x),

Model 13 does not satisfy {F} feat(fraglgtk— F#feat(fi'agl,x) and

Model 14 does not satisfy {OD,0F} :overlap(fraglfrag2)(-— 0F#overlap(fraglflag2).

Proposition 3.4.4: Let P be a PW. The reliable m-model of P is a stable m-model of P.

Proof: Let RM be the reliable m-model of P. From Proposition 3.4.2, RM is an m-model of P. So,
it is enough to show that RM=Ieast,(Pl,,,RM). Let leastv(P/,,,RM)=7\J~F, where T, F are sets of

classical literals. Let Ia= awFa, where Ta, Fa are sets of classieal literals and RM = 1d. First, we
will prove by induction that T bu~Fb :TUvF, VbSd It is true that T ogT and FogF. Suppose that
TagT and FagF, Va<b. If b is a limit ordinal then Tbgf and Fch since Ib= U{Ial a<b}.

76
Assume therefore that b=a+l. Let Le 1b- IfL is the local literal M#L’ then 3 M#L'(-—L1,...,Ln in M

s.t. ViSn, Lie Ia. Since IagTU~F, there is a rule M#L'e— '1,...,L'm in P/,,,RM where L'1,...,L'm are
all the classical literals in {L1,....L,,}. From the fact IagflU~F and the definition of leastv(P/,,,RM),
it follows that M#L'eT. lf L is the indexed literal S:L' then 3MeS, s.t. M#L'ela. Since
RM(S:L')=1, the rule S1.'<-M:L’ is in PI,,,RM. From the fact IagTu~F and the definition of

least,(P/,,,RM), it follows that S1.'e T. This implies that T(Ia)=Tb(;T.

Now, we will show that FbgF. Since Fb= “TbUF(Ia), it is enough to show that “TbgF and
F(Ia)cF. If Le "T b then “Le RM and fiom Steps (ii), (vi) of Def. 3.4.4, there is no rule with head
L in PI_RM. Consequently, LeF and “Tch. For all rules M#Lt—L'1,...,L'm.~Ll,..,~L,, in P (Li,
L 'i are classical literals) with M#Le F(Ia) either SiSm, L'ie F(Ia)uFa or San, Lje Ta. This implies
that for each rule M#Lt—L '1....,L'm,~L1,..,~L,, in P with M#Le F(Ia) either there is a corresponding
rule M#Le—Al,...,Ak in PIMRM (fiom Steps (iii) and (iv) of Def. 3.4.4) with A i5 F(Ia)uF for an iSk
or there is no corresponding rule in HM (from the Steps (i) and (ii) of Def. 3.4-.4). If r is a rule
in PIMRM with head an indexed literal S1.e F(Ia) that r is of the form S:L(—M#L with M#Le F(Ia).
Note that, no rule Sth—u is added to PIMRM (from Step (v) of Def. 3.4.4) because S:L is false
w.r.t. RM. So, for each rule H<—A1,...,Ak in HM with He F(Ia)uF, SiSk such that Ate F(Ia)UF.
From the definition of Ieastv(leRM), it follows that F (Ia);F . Consequently, F ch.

SO, we proved that T dgT and ngF.

We will show that TgTd. Let a be the first ordinal s.t. there is a literal Ler and
‘PpoTa’tlwaH, where P'IiP/mRM. If L is the local literal my then there is a rule
M#L's—Al,..,.4,, in PIMRM with wp:Ta(o)(A,)=1, ViSk. This implies that there is a rule in P with
head M#L' whose body literals are true w.r.t. RM. Consequently, M#L'er which is a
contradiction. if L is the indexed literal S1.’ then there is a rule 81.'(—M#L' in ”mm with

77
‘I’PrTa(0)(M#L')=l, ViSk. Consequently, there is an MeS s.t. M#L'e T d- Since Le T d, it follows

that "'Le T d or L is unknown w.r.t. RM. If “Le T d then from Step (vi) of Def. 3.4.4, Let T which is
a contradiction. lf L is unknown w.r.t. RM then the rule r should not exist in P/mRM because of the
Step (v) of Def. 3.4.4 and the fact thatM#L'e T d- So, Le T d and consequently T ;T d-

We will show that Fng. Let Fcoh={H| aHe T d}. FcohCFd because RM is a coherent
interpretation. For all rules He-A1,...,Ak in PImRM with He F—Fcoh, there is iSk such that AieF.
This implies that for each rule Ht—L'l,...,L'm,~L1,...,~L,, in P (L,-, U; are classical literals) with
He F-Fcoh either (i) BiSm, L'ieF (fi'om Steps (iii) and (iv) of Def. 3.4.4) or (ii) 319:, LJe T d
(from Step (i) of Def. 3.4.4). Let S:Le F—Fcoh. Then, RM(S:L)¢1 because otherwise, S:Le T which
is a contradiction. We will show that VMe S, M#Le F. Assume that ElMe S, M#Le F. If
RM("S:L)=1 then S1.e Fcoh, which is a contradiction. 1f RM(S1.)=l/2 then there is a rule Sth—u
in P/mRM (from Step (v) of Def. 3.4.4), which is a contradiction since S:Le F. Thus, RM(S:L)=0
and for all Me S, M#Le F. We will show that VMe S, ~S1. is reliable w.r.t. (M, 17de and RM. If
~S:L is unreliable w.r.t. (M, [2de and RM for an MeS then S:Le F04) and consequently,
RM(S:L)Zl/Z since S1.e Fcoh- However, 81.95 T since S:LeF and consequently, RM(S:L)¢1. So,
RM(Sl.)=1/2 and the rule S1.e—u should be added to leRM (from Step (v) of Def. 3.4.4). This
implies that S:LEFI which is a contradiction. So, if S:LeF—Fcoh then VMe S, ~S1. is reliable
w.r.t. (M, mall) and RM. Since F(Id) is the maximum set that satisfies the property satisfied by set
F—Fcoh, F—FcothUd). So, Fng.

Consequently, RM=Td U~Fd = T U~F=leastv(P/MRM). 0

Proposition 3.4.5: The reliable m-model of a PW is its least stable m-model.

Proof: Let RM be the reliable m-model of P. From Proposition 3.3.4, RM is a stable m-model of P.
So, it is enough to show that if I is a stable m-model of P then RMd=least,(P/,,,M). Let I =TU~F,
where T, F are sets of classical literals. Let 1a=TaU~Fa. where Ta, Fa are sets of classical literals

78
and RM = Id. We will show by induction that IbgTu~F, VbSd. It is true that T ogT and FogF.

Suppose that T acT and FagF, Va<b. If b is a limit ordinal then T bcT and Fch since 1b: UUaI
a<b}. Assume therefore that b=a+l. Let Le 1b- IfL is the local literal M#L' then 3 M#L'e—Ll,...,Ln
in P s.t. ViSn, Lie la. Since IGQNF, M#L'e T. If L is the indexed literal S1.’ then ElMe S, s.t.
M#L'e Ia and S:L' is reliable w.r.t. W, predL.) and la. Since lag], it follows that S:L' is reliable
w.r.t. (M, predL.) and I. From the facts that I is an m-model of P, lag], and S:L' is reliable w.r.t.
(M, predL.) and I, it follows that Le T. So, T(Ia)=Tbc;T.

Now, we will show that FbgF. Since Fb= “TbuF(la), it is enough to show that “TbgF and
F(Ia);F. IfLe "'T b then “Le! and from Steps (ii), (vi) of Def. 3.4.4, there is no rule with head L
in PIMI. Consequently, LeF and “Tbs-.17. For all rules M#L(—L'1,...,L'm'~L1,..,~L,, in P (Li, U; are
classical literals) with M#Le F(Ia) either EliSm, L',-e F(Ia)UFa or 3an, Lje Ta. This implies that
for each rule M#Lt—L '1....,L'm, ~Ll,..,~L,, in P with M#Le F(Ia) either there is a corresponding rule
M#Le—A1,...,Ak in Pl,,,l (from Steps (iii) and (iv) of Def. 3.4.4) with A16 F(Ia)\JF for an iSk or
there is no corresponding rule in PIMI (fi'om the Steps (i) and (ii) of Def. 3.4.4). If r is a rule in leI
with head an indexed literal S:Le F (Ia) then r is of the form Sit—M#L with M#Le F(Ia). Note that,
no rule S1.(—u is added to P/,,,I (fiom Step (v) of Def. 3.4.4) because the facts 10;] and
Ieast,(Pl,,,I)=I imply that for all Me S, M#Le T. So, for each He F(Ia)UF, if He—A1,...,Ak is a rule
in PIMI then SiSk such that A ie F(Ia)UF. From the definition of least,(P/,,,I), it follows that
F(Ia)s:F. Consequently, FocF.

So, we proved that TdcT and FacF. 0

3.5 Modular Reliable Semantics for Prioritized Extended Logic
Programs

In this section, we define the modular reliable semantics of prioritized extended logic programs and
we relate it with the modular reliable semantics of prioritized modular logic programs.

79

3.5.1 Definitions

A prioritized extended logic program (PEP), P, is a pair <Rp, <R>. The set RP contains a set of
rules r::Lo(—L1,..., Lm,~Lm+1,...,~Ln, where r is the label of the rule and L,- are classical literals.
The partial order <R c; RP x Rp denotes the relative reliability of the rules. A PEP is an extended
program ifl‘ <a=i }.

A PEP, P, can be translated into a PMP, trM(P), by considering each rule as a module that
imports all of its body predicates and exports its head predicate. Consequently, we can define the
modular reliable semantics of P from that of trM(P), that is, if IM is an interpretation, m-model,
stable m-model or the reliable m-model of trM(P) then I= {Ll SL1.e 1M} is an interpretation, m-
model, stable m-model or the reliable m-model of P, respectively. Note that, every indexed literal
appearing in trM(P) is globally indexed. We say that a rule r in P is reliable (resp. unreliable) w.r.t.
I ifi‘SHmzHead, is reliable (resp. unreliable) w.r.t. (r,Head,.) and IM={SL1. | Le I} in trM(P).

Direct definitions of the stable m-models and the reliable m-model of a PEP which are

equivalent to the above definitions, are given below.
Definition 3.5.1 (possible literal set): Let P be a PEP, I,J sets of literals and reRP. The possible

literal set w.r.t. r and I, denoted by Pas”, is defined as follows:
- ,J(J)={L | 3 r':: Le—L1,...,L,, in P s.t. (i) LieJ. ViSn, (ii) r'tfir, and (iii) “Lie 1}
0 PF,.J(J) isthegreatest set UgHBpst.
ifLe Uand r' is a rule with Head,. = L then r'vfir and 3K6 Body,. s.t. Ke Uor ~KeJ.
0 PW,.J(J) = coh(PT,J(J) U ~PF,J(J)).
0 Posrl is the least fixpoint of the operator PW”.

80
Definition 3.5.2 (dependency set): Let P be a PEP, I a set of literals and re RP. The dependency

set of a literal K w.r.t. r and 1, denoted by Dep, 1(K), is the least set D(K) such that if KeI then
D(K)={} else
(i) If K is a classical literal then
if r':: L4—L1,...,L,, in RP s.t. r' at r and {Ll,...,Ln}cPos,.J then {L}UD(L,-)<;D(L), ViSn.
(ii) If K= ~L is a default literal then

(a) {~L}UD("L) :D(~L) and
(b) if for every rule r’ with Head,.v = L, it holds that r' at r and ElKe Body,. s.t. ~Ke Poer

then V Lt—L1,...,Ln in RP, if ~L,-e Posr', for iSn then D(~L,~);D(L).

Definition 3.5.3 (reliable literal): Let P be a PEP, 1 a set of literals and r a rule in P.
0 The literal L is unreliable w.r.t. r and 1 iff 3 “'Ke Posd and Le Dep,J(K).

0 The literal L is reliable w.r.t. r and I iff L is not unreliable w.r.t. r and I.

The definition of an m-model of a PEP is the same as that of an r-model of an EPP (given in

Definitions 2.2.9 and 2.2.10).
Definition 3.5.4 (W P operator): Let P be a PEP and J a set of literals. We define:

e T(J)={L | 31".: Lt—L1,...,L,, in P s.t. LieJ, ViSn and L is reliable w.r.t. r and J}
0 F(J) is thegreatest literal set UcHBP s.t. ifLe Uand ris a nllewithHeadr=L then
(i) 3K6 Body,. s.t. Ke U or ~KeJ and (ii) ~L is reliable w.r.t. r and J.

o Wp(J)=coh(T(J)U~F(J)).

Definition 3.5.5 (transformation PIMI): Let P be an PEP and I be an interpretation of it. The
program PI”! is obtained as follows:

(i) Remove from P all nrles that contain in their body a default literal ~L s.t. 1(L)=l.

81
(ii) Remove from P any rule r with 1(aHead, =1.
(iii) If r is a rule in P s.t. I(Body,)=l and 1(Head,.)=l/2 then replace r with Head,.é—u.
(iv) Remove from the body of the remaining rules of P any default literal ~L s.t. I(L)=0.
(v) Replace all remaining default literals ~L with u.
(vi) If 1(L)=l/2 and 3 rule r s.t. Head,=L and ~L is unreliable w.r.t. r and I then add the rule L<-u.

(vii) Replace every classically negative literal “A with a new atom -._A.

The definition of the reliable m—model of a PEP is the same as that of the reliable m-model of
a PM (given in Definition 3.4.3). The definition of a stable m-model of a PEP is the same as
that of a stable m-model of a PMP (given in Definition 3.4.5).

3.5.2 Relationship with the Modular Reliable Semantics of Modular Logic
Programs

Under certain conditions, a PM can be translated into a PEP with equivalent modular reliable
semantics.

Proposition 3.5.1: Let P = <M0dp, <def > be a Plvfl’ s.t. every indexed literal appearing in P is
globally indexed and let RM denote the set of rules in P. Let trE(P)=<RE, <R > be a PEP defined as

follows:
- RM c RB.
- lfMiiLe HBP andM exports predL then add rm; SL1.(- M#L to RE.

‘ 'uJFn ru_L.ifl'(Al,pr-ed,_) <def(M',predL.) and rM_L<Rr, for each rM_Le RE and reRM.

Then, I is a stable m—model (resp. reliable m-model) of P ifl‘ I is a stable m-model (resp. reliable m-
model) oftrB(P). .

Proof: Let Pa = trE(P). Operators with index PE (resp. P) operate on the program Pa (resp. P). Let
WT’HGF uthaao» a<b} when b is a limit ordinal and 1a=wTap(e) for any ordinal a.

32
Similarly, let wap,(e)= uleap,(e)| a<b} when b is a limit ordinal and ra=wTaP,(o) for any

ordinal a. We will prove by induction that Ia=1’a, for any ordinal a. It is true that a=0. Suppose
that it is true Va<b. lf b is a limit ordinal then hypothesis is obviously true. Assume therefore that
b=a+l. Let Le Tp(la). If L is the local classical literal M#L' then 3 r2: M#L'e—L1,...,L,, in RM s.t.
ViSn, Lie Ia. Since modules are internally consistent and r,,,_L<R r for each Que RE and re RM, it
follows that M#L' is reliable w.r.t. r and Pa. Consequently, M#L'e TPE(I'a). If L is the globally
indexed classical literal S:L' then 3M#L’eIa s.t. S1.’ is reliable w.r.t. (M,predL.) and 10. This
implies that 3 ru_L.:: S1. 't—MiiL' s.t. M#L'e 10. Moreover, since S1.’ is reliable w.r.t. (M,predL.) and
la in P and the priorities of the rules rm, in PE correspond to the priorities of the definitions
(M,predl) in P, S:L' is reliable w.r.t. r”! and I'd in PE. Consequently, S1. 'e TPEU’a).

Let Le TpE(I'a). lfL is a local classical literal M#L' then El MiltL't—L1,...,Ln in PE and thus, in
P s.t. ViSn, Lie I'a. This implies that M#L'e Tp(Ia). If L is a globally indexed classical literal S1.’
then 3 ruin S:L't—MiiL' s.t. M#L'e 1'0 and S1.’ is reliable w.r.t. rM_L. and 1", in PE. This implies
that 3 M#L'e Ia s.t. S:L' is reliable w.r.t. (M,predL.) and la in P. Consequently, S:L'e Tp(Ia). Thus,
TPB(I'a)=TP(Ia).

If Le 1b is the default literal ~L' and “L'e Tp(la) then -'L'e TPrU'a) and consequently,
~L'eI'b. IfLeI'b is the default literal ~L' and -'L'e TPs-(I'a) then "L'e Tp(Ia) and consequently,
~L'elb.

If a local literal M#L'e Fp(Ia) then ~M#L' is reliable w.r.t. any rule r in PE with Head,=M#L'
because modules are internally consistent and r,,_L<R r for each rue RE and reRM. If an indexed
literal S:L'E Fp(Ia) then ~S1.’ is reliable w.r.t. (M,predL.) and I“, for any MeS and since the
Priorities of the rules r“ in PE correspond to the priorities of the definitions (M,predl) in P, ~S:L'
is l‘eliable w.r.t. r and 1'“, for any r in P5 with Head,=S1L'. Thus, S:L'e FPsU'al- IfS1.’e Fp3(1'a)

then ~S1.’ is reliable w.r.t. r and 1' , for any r in PE with Head,=SzL'. Since S:L'e—MiiL', VMeS

83
are rules in PE, S:L' is reliable w.r.t. (M,predL.) and Ia, VMe S. Thus, S1.'e Fp(Ia). Consequently,
FPE(I'a)=Fp(Ia).
So, we have shown that Ib=1'b.

Let I is a stable m-model of P. We will show that 1 is a stable m-model of PE. For any local
literal M#L, the literals ~M#L and M#L are reliable w.r.t. any rule in PE with Head,:M#L. Thus, it
is enough to show that if ~S1. (resp. S1.) is unreliable w.r.t. MpredL) and 1 in P , for an Me S then
~S1. (resp. SJ.) is unreliable w.r.t. r,“ and I in PE. This follows from the fact that the priorities of
the rules rM_L in PE correspond to the priorities of the definitions Wpredl) in P. Similarly, we can
show that if I is a stable m-model of P then I is a stable m-model of PE. 0

Note that the priorities of the rules r,“ in trE(P) correspond to the priorities of the definitions
(M,predl) in P. The indexed atoms of P are treated as conventional atoms in trE(P).

We have not obtained a result similar to that of Proposition 3.5.1 when not globally indexed
literals appear in P. Consider the obvious translation of P to a PEP, tr'E(P)=<RB, <R >, definw as
follows:

- RM c; RB.

- If MLe HBP andM exports predL then add rm}: {M} :L<— M#L to RB.
- For each S1.e HBP and S'1.e HBP s.t. S g S’, add rs_s._L:: S':L(— S1. to RE.
— ru_L<Rru_L.ifi‘ (M,predL) <defMpredL.)

- 'u_r.<a r, for each ru_Le R,5 and re RM.

- rwfR '83.!» for each Que RB and rs_s._Le RE.

TheMRS of P and that of tr'B(P), may not be equivalent as it is shown in the following example.

Example 3.5.2: Consider the PM, P:
module M1 exports p module M2 exports p module M3
I'IIICSMliip. rules 'Mziip. rulesM3#r ('— {Ml}1p, "{Mzkp.

84

and <dcf={}.

Then, tr'E(P) = < RB, <R > where:

RE={r1:: Mliip. r22: “Mziip. r3:: M3#r (— {M1}:p, “"{M2}2p.
rml 1:: {M1}:p(—M1#p. rm”: “{Mz}:p(— “Mziip.
rMmeuzz {M1,M2}:pe— {M1}:p. rlmummppii a{Ml,M2}:p<- "*{Mz}:p. }

and rMU<R r for all reRE-{rmy rmj}.

The MRS of P is: coh( {M1 #1). “leip. M3#r. {M1}:p, ~{M2} :p}) whereas the MRS of tr’E(P) is:
coh( {Ml#p, “M2#p}). Note that, in the MRS of tr'E(P), the truth value of literals {M1}:p, {M2} :p,
(M1M2}:p is unknown whereas in theMRSofP only the truth value of {MIM2}2p is unknown.

3.6 Related Work
In this section, we review related work on combining multiple deductive databases and maintaining

consistency in a distributed environment.

3.6.1 Combining Multiple Deductive Databases
In [71], local databases DB.,...,DB,, are combined with a supervisory database (DB) in a

fiamework based on annotated logic. Each literal in this approach is annotated with a subset of the
names of the local databases and a truth value. For example, L:[DBl, true] (resp. L:[DBl, falsel)
is an annotated atom which expresses that literal L (resp. “L) is believed to be true in DB}. A
combination axiom expresses that the truth value of a literal L according to a set of local databases

D is the least upper bound of the truth values of L according to the non-empty subsets of D. For
example, if L:[DBl,true] and L:[DBZ, false] are true then L:[{DBl,DBz}, true] is true. Note that

85
this is in contrast with MRS. In MRS, the truth value of {DBl,DB2}1. is considered unknown

unless the definition of predL in one of DB] or D82 is more reliable than in the other.

The supervisory DB can access literals defined in the local DBs. Yet, local DBs can access
only local information. The resolution of conflicts between the local DBs is the responsibility of the

supervisory DB. For example, the supervisory DB, S, may contain rules such as:

L: [S, V](— L:[DBl, V], expressing that the truth value of a literal L in S is the same as the truth

value of L in DB 1 (Vis a variable representing the truth value of L) or

L: [S, glb(Vl,...,Vn)] (— L:[DBl, V1],...,L:[DB,,, Vn], expressing that the truth value of a literal L in

S is the greater lower bound (in the lattice of truth values) of the truth values of L in DB1,...,DB,,.
In contrast to this approach, in MRS, modules can import information from any other module

as indieated in their definitions. Moreover, conflict resolution is incorporated in the semantics.
Work on combining deductive databases has also been done in [10]. Let DB,,...,DBm be a set

of positive logic programs to be combined in a single DB which should comply with a set of

constraints. Even though DB,,...,DB,,, are assmned to be consistent, DB may violate the

constraints. In [10], when a constraint J.(—L],...,Ln is violated, the rules with head Ly, iSn, are

removed from DB and the disjunctions

(leLz),...,(leLn), (L2vL3),...,(L2vL,,), ..., (L -lVLn)-

are added to DB. Thus, DB is a disjunctive logic program. Note that the formula

(LIVI/z)A...A(LlVLn)/\

(lqu3)A...A(L2an)/\

(Ln_1vL,,)
is equivalent to (LIA...Ln.1)V...V(LIA...AL]_1AL,'+IA...ALn)V...V(L2/\...ALn).
The maximum information is saved with this approach since to maintain consistency, one of L,-

should not be provable in DB. However, it is possible that literals L]....,L,, are based on unreliable

86
information which will continue to be evaluated as true in [10]. In MRS, not only the literals Li,

iSn, are considered "suspect" for the violation of the constraint but also the literals used in the

derivation of Li, iSn.

3.6.2 A Distributed Assumption Truth Maintenance System

In [46], a problem solving framework for distributed assumption based reasoning is described. The
fmmework, called distributed assumption truth maintenance (DATM) framework, is based on the
problem solving paradigm of result sharing rule-based systems using assumption-based truth
maintenance systems [17]. According to [46], each agent is equipped with inference rules,
communications rules, facts, and an assumption truth maintenance system (ATMS) which is
composed of truth maintenance rules and an assumption data base. Truth maintenance rules
indicate the sets of facts that constitute an inconsistency and how an inconsistency finding should
be propagated to the other agents. Communication rules specify the conditions under which local
results should be shared with other agents and the list of agents that results should be transmitted
to.

Each agent makes assumptions and works with its consequents until inconsistency is detected
after an inference step. Each result is associated with the agent responsible for its derivation. This
provides a way to trace back results, supporting global belief revision. This belief revision
approach is in contrast with our approach where contradiction is avoided before it is generated.

The basic inference engine cycle for an agent is the following:

Inferencing

1. Check current set of beliefs against all rules. Decide which inference rule to fire.
2. Execute the inference rule. Record the inference.

Belief Updating and Result Sharing
3. Check all truth maintenance rules .l.(—L1,...,L,,.

151

87
4. If an inconsistency is detected, record the set of incompatible assumptions in a NOGOOD
assumption set.
5. Determine which agents should be contacted with a message containing the NOGOOD
assumption set.
6. Execute all the instantiated communications rules and accept any incoming messages.
7. Update NOGOODS database with incoming NOGOODS assumption sets. Update working

memory and assumption database with incoming results.

Similarly, to a single-agent TMS (reviewed in subsection 4.4.3), a DATMS considers only
one solution per time out of a set of multiple admissible solutions. This is because the main goal of
a TMS is to maintain a consistent set of beliefs. In contrast, the main goal of the modular reliable
semantics, presented in this Chapter, is to draw conclusions that are satisfied in all of the stable m-
models of the combined knowledge base. Moreover, in our approach, a complete consistency check
is performed before a result is exported whereas in DATMS, results are exported as indicated by

the communication rules and when inconsistency is detected, global belief revision is performed.

3.7 Conclusions

We have presented the modular reliable semantics (MRS) of prioritized modular logic programs
(PMPs). The purpose of the modular reliable semantics is to derive reliable information from
contradictory PWs. Every PMP has at least one stable m-model. The reliable m-model of a

program P is the least stable m-model of P and it represents the skeptical "meaning" of P. Maximal
(w.r.t. S.) stable m-models of P represent the credulous ”meanings" of P. The complexity of

computing MRS is polynomial w.r.t. the size of the program (when HBp is finite). Since a

prioritized extended logic program (PEP) is naturally translated into a PM, the modular reliable

88
semantics for a PEP is also defined. In subsection 3.5.2, we proved that under certain conditions, a
Pllfl’ can be translated into a PEP with equivalent modular reliable semantics.

One application of MRS is deriving trustworthy information after combining multiple
deductive databases (083) that are not fully reliable. For example, when the DBs of difl‘erent
scientific labs are combined, conflicts may occur because of measurement errors. Each DB can be
seen as a low-level independent module exporting results computed fiom local information only.
On top of the local DBs, supervisory modules may be added for the processing of the local results.
Several dependence relationships between the supervisory modules and the local DBs and among
the supervisory modules themselves can exist. Future work should include the identification of
these relationships and their representation in our framework.

In section 3.6, we compare MRS with related work on combining multiple deductive databases

and maintaining consistency in a distributed environment.

CHAPTER 4

CONTRADICTION-F REE SEMANTICS FOR EXTENDED
LOGIC PROGRAMS WITH RULE PRIORITIZATION

4.1 Introduction
A prioritized extended program (PEP) consists of a set of partially ordered rules. Every rule r has
a corresponding set C ,. gBody, which is called the contrapositive set of r. We define the

contradiction-free semantics (CPS) of a PEP, P, by expanding it with the contrapositives r' of
every rule r such that Head,.: e {aLl Le C,}. The motivation for this expansion was given in
section 1.3. CPS is always defined and non-contradictory. Every PEP has at least one stable c-
model. We show that the CPS of a program P is the least fixpoint of a monotonic operator and the
least stable c-model of P. When the Herbrand base of P is finite, the complexity of computing CPS
is polynomial w.r.t. the size of the expansion of P. The SLCF-resolution (linear resolution with
selection function for contradiction-flee semantics) for computing answers for extended program
with rule prioritization is presented. The SLCF-resolution is shown to be sound and complete w.r.t.
CPS.

CPS extends the well-founded semantics for nomral programs [76] to PEPs. The use of
contrapositives for resolving contradictions in CPS has been supported by [28, 78]. Yet, in these
works, rule prioritization is not considered, the semantics is not always defined, and C r=Bodyr for
every rule r. CPS semantics is also related to ordered logic [24, 43] (reviewed in subsection 2.4.7).
Let P be an ordered logic program, i.e., P does not contain default literals and C,={} for every rule
r. Then, the CPS of P coincides with the skeptical c—partial model of P [24] and is a subset of the
well-founded partial model of P [43].

89

90

4.2 c-models for Prioritized Extended Programs

A prioritized extended program (PEP) is a tuple P=<Rp,<R>. Rp is a set of rules r: Lot—-
L1,...,Lm,~Lm+1,...,~Ln, where r is a label and L,- are classical literals. Every rule r has a
corresponding set C, gBody,, called the contrapositive set of r. The precise meaning of C, will be
given in the definitions. Intuitively, when there is a rule r s.t. both Body, and aHead, are derived
from P, the value of C, indicates the "suspects" for the contradiction. When Cr={}, the rule r is
considered incomplete‘. When C, ¢{ }, the contradiction is considered as evidence that one of the
literals in C, was wrongly derived. Thus, the CWAs and/or rules used in some step of the
derivation of literals in C, are considered unreliable. To facilitate this reasoning, P is expanded
with the contrapositives r' of every rule r such that Head,v e {aLl Le C,}.

For example, consider the program P={rlz a. r2: b. r3zpe—a. r4: “pt—b. with Cra=ii and
C,4 ={}}. Because both a, “p are derived in P and C,-, ={}, the rule r3 is considered incomplete,
i.e., r3 should be p<—-a,~“p. A similar argument applies to rule r4. Thus, literals a, b can be
reliably evaluated as true but the truth value of p is unknown. In contrast, consider the program P'
={rlz a. r2: b. r3zpt—a. r4: ap<—b. with C,3 ={a} and C,4={b}}. Since C,3 ={a}, the rule r]
used for the derivation of a is considered unreliable. Similarly, the mle r2 used for the derivation of
b is considered unreliable. By expanding P' with the contrapositives r'3: -'a(-— -'p and r'4: "b<—p,
the derivation of a, b from rules r1, r2 is blocked and the literals a, b, p are evaluated as unknown.
The view C,={} for every rule r is implicit in ordered logic [24, 43] and vivid logic [77]. The view
C, = Body, for every rule r is adopted in [28, 78]. Yet, other views such as C,¢{} and C, ¢Body,
for a rule r are also possible.

The relation <R ngxRp is a strict partial order (irreflexive, asymmetric and transitive),
denoting the relative reliability ofthe rules. Let r and r' be two rules. The notation r<r'means that
risless reliablethanr',thatis, r<r'ifl‘(r,r’)e<k. Thenotationrvf r'meansthatrisnot less
reliable that r'. Note that, r at r since <R is irreflexive. Intuitively, when Body, is true, Head, is

 

1 We say that a rule is incomplete if not all possible exceptions are enumerated in its body.

(x.

91

evaluated as true iff aHead, cannot be derived from rules with priority no lower than r. Thus,
deciding if Head, is true depends only on the rules r’ «t r. Note that a PEP with <R={} is an

extended logic program. In all sections but section 4.5, we assume that programs have been
instantiated and thus all rules are propositional. For every classical literal L, “(~L)=L.
Definition 4.2.1 (program expansion): Let P be a PEP. The expansion exp(P) of P is also a

PEP defined as follows:
0 For every rule r1lé—Ll,... ,Ln of P, exp(P) contains the rules {r',-z -'L,-(—-Ll,...,Li_1,L,-+1,...,L,,,-'H|

Lie C, and C,v,= (C ,—{L,-})U{‘*H } } (called contrapositives of r) and the rule r.
o The partial ordering of the rules of P is extended to the rules of exp(P) as follows: If r and r' are
two rules of P with r<r' (resp. r‘tr') then r and any contrapositive of r has less (resp. neither less

nor more) priority than r' and any contrapositive of r'. If r and r' are contrapositives then rvfir'.

Note that exp(exp(P))=exp(P).
Definition 4.2.2 (interpretation): Let P be a PEP. A set I=TU~F is an interpretation of P ifl‘ T
and F are disjoint subsets of HBp. An interpretation I is consistent ifi' there is no L such that both
Le T and "Le T. An interpretation 1 is coherent iff it satisfies the coherence property: if Le T then
“Le F .
Definition 4.2.3 (truth valuation of a literal): A literal L is true (resp. false) w.r.t. an

interpretation I ifl‘LeI (resp. ~LeI). A literal that is neither true nor false w.r.t. I, it is undefined

w.r.t. I.

In Definition 4.2.4, the concept of c-unfounded classical literal w.r.t. a mle r and

interpretation I is defined. I represents a set of literals known to be true. This concept is used in the
fixpoint computation of CPS. In particular, a rule r is used for the derivation of Head, only if

“Head, is c-unfounded w.r.t. r and CPS. Intuitively, a literal L is c-unfounded w.r.t. r and I if L

cannotbederived from the rules r'vf rwhenliterals areassumed tobefalseas indicatedinl.

92

Definition 4.2.4 (c-unfounded literal w.r.t. r and I): Let P be a PEP, r a mle and I an

interpretation. A classical literal L is called c—unfounded w.r.t. r and 1 iff there is a classical literal
set S s.t. LeS and VHe S, if r’ is a rule in exp(P) s.t. Head,v =H and r'vfir then (i) I(Body,v)=0 or

(ii) there is a classical literal L'e C,' s.t. L'e S or (iii) there is a default literal ~L'e C,r s.t. ~L'e S .

Note that if a literal L is c-unfounded w.r.t. r and 1 then L is c-unfounded w.r.t. r and any
interpretation 1' 21. If a rule r is unidirectional (C,={}) and I(Body,)¢0 then Head, is not c-

unfounded w.r.t. any rule r' s.t. r {r'. Intuitively, when C,=Body, Vrule r, every rule is given
higher priority than the C WAs. In Example 4.2.1, we show that this is not true when there is a
literal Le Body, -C, for a rule r. An algorithm that decides if a literal L is c-unfounded w.r.t. r and
I is given in Appendix A. The time-complexity of the algorithm is linear w.r.t. the size of exp(P).
Example 4.2.1: Let P be the expanded (with contrapositives) PEP:

Rp =(r1zfly. rzzaflyé— ~bird. r’zz bird(— fly. with C ,,={~bird}, C,v,={fly}} and <R={}.
Then, the literal “fly is c-unfounded w.r.t. r1 and 0 (in Def. 4.2.4 take S={-'fly, abird}). This
implies that fly can be reliably derived from rule r1. Intuitively, in this case, rule r] is given higher
priority than the C WA, ~bird. However, this is not the case if C,,={ }. Consider the program P’:
Rpr ={rlzfly. rzzafly(— ~bird. with Cn={}} and <R={}.

Then, the literal “fly is not c-unfounded w.r.t. r, and 0 since there is no S to satisfy conditions in
Def. 4.2.4. This, intuitively, implies that r1 is blocked and fly is evaluated as unknown.

Example 4.2.2: (credit confusion problem) Consider the following expanded PEP, P=<Rp, <R>:
Rp={ /* If Ann is a foreign student (resp. teaching assistant) then she needs 12 (resp. 6) credits *I
r]: need_credits(ann,12)(—foreign_stud(ann). r2: need_credits(ann6)<—TA(ann).
’33 TA(ann). r4: foreign_stud(ann).
rsz-need_credits(ann,6)(—need_credits(ann, 12).
r'5 :meed_credits(ann, 12)<—need_credits(ann,6).
with C,,={} for i=l,2,3,4, C,,={need_credits(ann,12)} and C,v5={need_credits(ann,6)}}

93
80d rl<r5, r2<r5, r3<r5, r4<r5, r‘<r'5, r2<r'5, r3<r’5, r4<r'5 and r1<r2.

/‘ Rules rs and r'5 have higher priority than the other rules */

The literal aTA(ann) is c-unfounded w.r.t. r3 and 0 (in Def. 4.2.4 take S={-TA(ann)}). So,
TA(ann) can be reliably derived fi'om rule r3. Similarly, foreign_stud(ann) can be reliably derived
from rule r4. Since r‘<rz, the literal “need_credits(ann,6) is c-unfounded w.r.t. r2 and 0 (in Def.
4.2.4 take S={-'need_credits(ann,6), need_credits(ann,12)}). So, need_credits(ann,6) can be
reliably derived from rule r2. In contrast, -'need_credits(ann, 12) is not c-unfounded w.r.t. r] and 0.
However, if P' is as P with fi,={} then meed_credits(ann,6) is not c-unfounded w.r.t. r2 and 0 in
P'.

Definition 4.2.5 (truth valuation of a rule): Let P be a PEP. A rule r in exp(P) is c-true w.r.t. an
interpretation 1 ifl‘ (i) I(Head,)ZI(Body,) or (ii) I(Body,)=l/2 and I(-Head,)=1 or (iii) I(Body,)=l
and (I(Head,)=l/2 or I(-Head, =1) and “Head, is not c—unfounded w.r.t. r and 1.

Definition 4.2.6 (c-model): Let P be a PEP. A consistent, coherent interpretation 1 of P is a c-

model of P iff every rule in exp(P) is c-true w.r.t. 1.
Example 4.2.3: Let P be as in Example 4.2.1 andM be a c-model ofP. Then,flyeMbecause r1

should be c-true w.r.t. M and afly is c-unfounded w.r.t. r1 andM 20. In contrast, fly is not true in
all models of P’ of Example 4.2.1. The c-models of P' are M1={~bird}, M2=coh( {fly,~bird}) and
M3=coh({"fly,~bird}).

Example 4.2.4: Let P be as in Example 4.2.2. Then, M=coh({TA(ann), foreign_stud(ann),
need_credits(ann,6), need_credits(ann,12)” is a c-model of P. We will show that M is the unique

c-model of P. Let M' be a c—model of P. Then, “TA(ann), foreign_stud(ann),
“need_credits(ann,6), need_credits(ann,12) are c-unfounded w.r.t. Mat?) and rules r3, r4, r2 and

r's, respectively. Thus, McM'. The literal need_credits(ann,12)eM' because otherwise
-'need_credits(ann,6)eM' (need_credits(ann,6) is c-unfounded w.r.t. r5 and MQG) and thus, M' is

contradictory.

94

Let P be a normal program and I an interpretation as defined in [58, 60]. In [60], a rule r is
true w.r.t. I ifi‘ I(Head,)ZI(Body,). Since P is a normal program, the heads of the rules are atoms.

Consequently, the bodies of all contrapositives of a rule r in P contain the classically negative
literal aHead,. This implies that all classically negative literals are c-unfounded w.r.t. any rule and
I. If I' =IU{~"‘AI A is an atom of P} then conditions (ii) and (iii) in Def. 4.2.5 are not satisfied by
1', for all rules in P. This implies that a rule r in P is c-true w.r.t. I' ifi‘ r is true w.r.t. 1.

Proposition 4.2.1: Let P be a normal program. M is a model of P iffMU{-'A| A is an atom of P}
is a c-model of P, independently of the values of C,.

4.3 Contradiction-Free Semantics
In this section, we define the contradiction-free model, stable c-models and contradiction- ree
semantics of a PEP, P. We define the contradiction-free model of P as the least fixpoint of a

monotonic operator and we show that it is the least stable c-model of P.
Definition 4.3.1 (W p operator): Let P be a PEP and J a set of literals. We define:

0 T J(T)={L Brit—L, ..... L,, in exp(P) s.t. Lie IUJ, ViSn and "L is c-unfounded w.r.t. r and J}.

. T(J)= unfato) | M}, where (l) is the first limit ordinal.

- F(J) is the greatest set of classical literals S s.t. VLe S, if r is a rule in exp(P) with Head,=L then
J(Body,)=0 or ElL'e Body, s.t. L'e S.

0 W p(J)=coh(T(J)U-F (J)).

When “Head, is not c-unfounded w.r.t. r and J, we say that r is blocked w.r.t. J. Note that the
sequence {T fa} is monotonically increasing (w.r.t. g). 80, T(J) is the least fixpoint of T}. We
define the transfinite sequence: Io={}, 10+1=Wp(Ia) and Ia= U{Ib | b<a} if a is a limit ordinal.
Proposition 4.3.1: Let P be a PEP. {la} is a monotonically increasing (w.r.t. c) sequence of
consistent, coherent interpretations of P.

Proof: Given in Appendix A. 0

95

Since {1a} is monotonically increasing (w.r.t. g), there is a smallest countable ordinal d s.t.

1d=1d+l-
Proposition 4.3.2: Let P be a PEP. Then, Id is a c-model of P.

Proof: Given in Appendix A. 0

Definition 4.3.2 (contradiction-free semantics): Let P be a PEP. The contradiction-free model of
P (CPMp) is the c-model Id- The contradiction-free semantics (CPS) of P is the ”meaning"

represented by CPMp.

In Example 4.3.1, we show that contrapositives are necessary in order to avoid the derivation

of complementary literals in {Ia}.

Example 4.3.1: Consider the PEP, P=<Rp, <R >:

Rp={rl: OK_M. r2: “rings. r3: ringst— OK_M. with C,.,=Body,,} and r'<rz<r3.

Rule r3 expresses that if machine M is OK then it rings. Rule r2 expresses the observation that
machineM does not ring. Rule r1 expresses the assumption that machineM is OK.

The program exp(P) is as follows:

Rw={rl: OK_M. r2: “rings. r3: ringst— OK_M. r'3: “OK_M (— arings.

with C ”=Body,3 and C ,3=Body,r,} and r‘<rz<r3, r1 <rz<r'3.

Since rings is c-unfounded w.r.t. r2 and O, aringse T(O). Since, the literal -OK_M is not 0-
unfounded w.r.t. r1 and 0, rule r] is blocked w.r.t. 0. Since OK_M is c-unfounded w.r.t. r':, and O,
'0K_Me T(O) (derived fi'om r'3). So, T(O)=(-'rings, 'OK_M}, F (O)={} and
Wp(0)=coh({-'rings, eong} ). Because wPT2(e)=wp(e), it follows that cm, = coh({arings,

-0K_M}).

We will show that contrapositives are necessary in order to avoid the derivation of
complementary literals. Assume that exp(P)=P. Then, -0K_M is c-unfounded w.r.t. r] and O and

thus OK_Me WAG). Consequently, rings is derived from r3, since “rings is c-unfounded w.r.t. r3

96

and 0. However, cringse WP(O) (derived from r2), since rings is c-unfounded w.r.t. r2 and 0. So,
WAO)=coh({0K_M, rings, firings» which is inconsistent.

Let P' be as P with the additional rule r4: rings. Let r3<r4, expressing that r4 is a more
reliable observation than r3. Then, W F(O)=coh({rings}) where rings is derived from rule r4. Note
that “OK_M is not c-unfounded w.r.t. r1 and O in P' and thus r1 is blocked w.r.t. O. In contrast,
-OK_M is c-unfounded w.r.t. rl and W140) because Body, 3= {firings} is false w.r.t. Wpt(0).

Thus, CPMPo = wP.T2(o)=coh({0K_M, rings}).

Example 4.3.2: Let P be the program of Example 4.2.2. Then, CPMp= coh( {TA(ann),
foreign_stud(ann), need_credits(ann,6), -'need_credits(12)}). If P' is as P with <R={} then CFMP.
=coh({TA(ann), foreign_stud(ann)}) which corresponds to the skeptical meaning of P'. If P' is as P
with C, =Body, ‘0’ rule r then “TA(ann) (resp. foreign_stud(ann)) is not c-unfounded w.r.t. r3
(resp. r4) and 0 because of the contrapositive of r2 (resp. r1) in exp(P) Thus, CPMpo ={}.
Proposition 4.3.3: Let P be a PEP. The complexity of computing CW}: is 0(IHBpl‘lexp(P)|2).

Proof: Given in Appendix A. 0

An algorithm for computing GIMP is given in Appendix A. The contradiction-flee model of a
PEP corresponds to the skeptical meaning of the program. Other meanings can be obtained using
the transformation P/J, where I is an interpretation of P. The transformation PI! is defined in [26,
60] for a normal program P. P/cI extends P/I to PEPs.

Definition 4.3.3 (transformation P/cl): Let P be an expanded PEP and I be an interpretation of it.
The program P/cI is obtained as follows:

(i) Remove from P all rules that contain in their body a default literal ~L s.t. 1(L)=l.

(ii) Remove fi'om P any rule r with I(-Head,)=l.

(iii) Ifr is a rule in P s.t. I(Body,)=l and I(Head,)=l/2 then replace r with Head,(—u.

(iv) Remove from the body ofthe remaining rules ofP any default literal ~L s.t. 1(L)=0.
(v) Replace all remaining default literals ~L with u.

97

(vi) Replace every classically negative literal aA with a new atom -1_A.

Example 4.3.5: Let P be as in Example 4.2.2 andM be as in Example 4.2.4. Then
He] ={need_credits(6)<—TA(mary). TA(mary). foreign_stud(mary).

meed_credits(12)(—need_credits(6). }

The program He 1 is a non-negative program with a special proposition a. For any
interpretation J, J(u)=l/2. When P is a normal program and M is a model of P [60], P/cM 5 HM
since Steps (ii), (iii), and (vi) do not have any efl'ect on P/cM.

Definition 4.3.4 (stable c-model): Let P be a PEP and M a c-model of P. M is a stable c-model
of P ifl' leastv(exp(P)/c M)=M.

Example 4.3.6: Let P' be as P in Example 4.2.2 with <R={}. Let

M1==coh( {TA(ann), foreign_stud(ann), need_credits(ann,6), -rneed_credits(12)}) and
M2=coh({TA(ann), foreign_stud(ann), need_credits(ann,12), -rneed_credits(6)}).

Then, M1 ansz are stable c-rnodels of P'.

The program P of Example 4.2.2 has a unique stable c-model equal to Cmp.

Let M be a stable c-model of P. Changing the ordering of the rules in P, the condition
least,(exp(P)/,,M)=M will still be satisfied but M may not be a c-model of the new program For

example, let P be as in Example 4.2.2 and M be as in Example 4.2.4. Then, M is a stable c-model
of P. If we replace r l<"2 in P with r2<rl , the condition leastv(exp(P)/c M)=M is still satisfied.

However, M is not a c-model of the new program P' because —rneed__credits(12) becomes c-
unfounded w.r.t. r1 andM and thus, r1 is not c-true w.r.t. M in P'.

Proposition 4.3.4: Let P be a PEP. Then, CPMP is a stable c-model of P.

Proof: Given in Appendix A. 0
Proposition 4.3.5: Let P be a PEP. Then, CPMP is the least stable c-model of P.

Proof: Given in Appendix A. 0

98

4.4 Related Work

In this Section, we relate the contradiction-free semantics with existing work.

4.4.1 Semantics Covered in Section 2.4
The contradiction-flee semantics for PEPs is a generalization of the 3-valued stable model
semantics which is defined for normal programs [60].

Proposition 4.4.1: Let P be a nomral program. Then, M is a 3-valued stable model of P iff
MU{~“A| A is an atom of P} is a stable c-model of P, independently of the values of C, in P.

Proof: =>) Let M be a 3-valued stable model of P. It is easy to verify that M'=MU{~-'A| A is an
atom of P} is a c-model of P. Let r'AO(—A1,...,Am,~Am+1,...,~An be a rule in P where At»
ie {0,...,n} are atoms. Since M is a 3-valued stable model of P, least,(P/M)=M. Because the heads
of all rules in P are atoms, every rule r in exp(P) with Head,= “A has a literal *8 in the body,
where A,B are atoms. This implies that every literal “A, where A is an atom, is c—unfounded w.r.t.
any mle r and M. Moreover, all literals aA, where A is an atom, are false w.r.t. least,(exp(P)/M')
and every contrapositive of a rule in P has a false literal in its body w.r.t. leastv(exp(P)/,M'). So,
least,(exp(P)/M')= leastv(P/M)U{~-'A| A is an atom}= MU{~“AI A is an atom}w. So,
MU{~“A| A is an atom of P} is a stable c-model of P.

4:) The proofis similar tothe proofof =>. 0

Proposition 4.4.1 implies that the contradiction-free model of a normal program P coincides

with the well-founded model of P [76].

The following relationship between CPS and the answer set semantics [27] can be shown.
Proposition 4.4.2: Let P be an extended program with C,={} ‘v’ rule r. IszttHBp is an answer-set

[27] of P thenMU{~A| Ae M} is a stable c-model of P.

99
Proof: P is non-contradictory since M#HBP is an answer-set of P. So, if M is an answer-set of P

then Mu{~A| .46 M} is an extended stable model of P [54]. Proposition 4.4.2 now follows fiom

Proposition 4.4.3. 0

The relationship between CPS and extended well-founded semantics [54] is given in the next
two propositions.
Proposition 4.4.3: Let P be a non-contradictory extended program with C,={} V rule r. lfM is an
extended stable model [54] of P then M is a stable c-model of P.
Proof: Since C,={} V rule r, exp(P)=P. Let M be an extended stable model of P. From the
definition of extended stable model [54], M is a c-model of P and leastv(P/c M)=M. So, M is a

stable c-model of P. 0

The reverse of Proposition 4.4.3 does not hold. For example, consider P ={rlz p(— ~p.
r2:a(—p. r3:-u. with C,={} V rule r}. Then, {} is a stable c-model ofP since a is not c-
unfounded w.r.t. r2 and Q. However, {} is not an extended stable model of P.

Proposition 4.4.4: Let P be an extended program with C,=Body,. V rule r. If XWFSMP) is
defined then it coincides with CFSP.

Proof: Assume that XWFSMP) is defined. We will show by induction that pra(o)=
ommwo), for all a (the operator 4),. is defined in subsection 2.4.3). This is true when a=0.
suppose that it is true for all ordinals s a. We will show that wPTa+l(o)=¢ap(P,T¢H(o). it is
enough to show that for each rule r in exp(P), ifBodyflmp)Ta(fl). Then, Body,.:WpTaw) and
«Head, is c-unfounded w.r.t. r and wPTaio). Let r be a rule in exp(P) with Bodygompfam)
then from hypothesis, Body,.;WpTaw). Since XWSMP) is defined, ompflafim) is
consistent. Since Cr=Bodyr V rule r and <R={}, every classical literal not in ¢MP)T0+ 1(0) is c-
unfounded w.r.t. any rule and ompflam). Since Head,.e ompfafim), it follows that
“Head,.e ‘I’m P)Ta+1(o) and thus, «Head, is c-unfounded w.r.t. r and praw). o

100
The above proposition is not true when C,.:Body, for a rule r. For example consider the
prong ={r1: p(— ~p. r2: as— p. r2: “a. with C,={} V rule r}. Then, CFSP ={} whereas
the XWFSP is {‘u, ~a, ~72}-

The relationship between CFS and ordered logic [24, 43] is given in the next two propositions.
Proposition 4.4.5: Let P = <Rp, <R> be a PEP which is free from default literals and C,={} V
rule r. Then, the set of classical literals in CFMP coincides with the skeptical c-partial model of P
[24].

Proof: To simplify the proof, we redefine the operator T(J) of Def. 4.3.1 as follows: T(J)={L| 3
rule r in P s.t. Head,=L, Body,.;J and "L is c-unfounded w.r.t. r and .1}. Note that both definitions

give equivalent semantics. Let Ia=WpT“(0), for all a.

We will show by induction that the set of classical literals in 1a is a subset of ST“(0), for all
a. This is true when a=0. Suppose that it is true for all ordinals S a. We will show that the set of
classical literals in 10,.l is a subset of STa+l(o). Since S(1)={L| 3 rule r s.t. Head,=L, Body, :1
and r is not c-defeasible w.r.t. I}, it is enough to show that for each rule r, if Body,. :10 and
«Head, is c-unfounded w.r.t. r and 1,, then Body,;STa(o) and r is not e-defeasible w.r.t. STam).

Body,. gla and *Head, is c-unfounded w.r.t. r and 1,,

(From the inductive hypothesis and the fact that Body, is free of default literals, it follows that
Body, :sTaiei.)

=9 Body, :STam) and «Head, is c-unfounded w.r.t. r and 1,,

(From the fact 8, ={} V rule r and Def. 4.2.4, it follows that “Head,. is c-unfounded w.r.t. r and
la ifi‘ 3 no rule r' «it r with Head,.: = “Head,. and Ia(Body,.v)¢O)

=9 Body,. cSTaw) and 3 no rule r’ it r with Head,.r = "Head,. and Body,.: n ~Ia= 0

=9 Body, cSTaaa) and a no rule #4: r with Head,t = «Head, and Body,t n msTa(o))= 0

=9 Body, gsTam) and a no r' 4: r with Head,.: = «Head, and (Body,.! UHead,v) n Uc(sTa(o))=o
=9 Body, :STam) and r is not e-defeasi‘ble w.r.t. 870(0).

101
So, we have shown that the set of classical literals in CFMp is a subset of the skeptical c-
partial model of P. We will Show by induction that STOW) is a subset of the set of classical literals
in 1a.”, for all a. This is true when cr—=O. Suppose that it is true for all ordinals S a. We will Show
that STGHM) is a subset of the set of classical literals in 1a+2- It is enough to Show that for each
rule r, if Body,;ST“(0) and r is not c-defeasible w.r.t. Sum) then Body,. Clan and "Head,. is c-
unfounded w.r.t. r and 1a+l~

Body,. :ST‘KQ) and r is not c-defeasible w.r.t. ST“(0)
(From the inductive hypothesis and the fact that Body,. is free of default literals, it follows that
Body,- CIa+1-)
=9 Body, :10, l and a no r' at r with Head,.: = «Head, and (Body,.! UHead,v) n (F(ST“(0))= 0
:9 Body,. Cla+l and 3 no rule r' it r with Head,.! = *Head, and Body,.: n ~Ia+|= 0
=9 Body,. :10.” and 3 no rule r' ifi r with Head,.: = “Head,. and Ia+1(Body,.v)¢0
=9 Body,. :10“ and "Head,. is c-unfounded w.r.t. r and 10+].

So, we have shown that the skeptical c-partial model of P is a subset of the set of classical
literals in CPMP. Proposition 4.4.5 now follows. 0

Proposition 4.4.6 shows that the reliable semantics is more skeptical than the assumption-flee
semantics of [43]. The proposition follows immediately from Proposition 4.4.5 and the fact that the
skeptical c-partial model of an ordered logic program P is a subset of the well-founded partial

model of P [Theorem 8, 24].
Proposition 4.4.6: Let P = <Rp, <R> be a PEP which is free from default literals and C,={} V

rule r. Then, the set of classical literals in CFMp is a subset of the well-founded partial model of P

[43].

4.4.2 Semantics Following the Contrapositive Rule Approach

The use of contrapositives for resolving contradictions appears in [28, 29, 7 8]. Yet, in these works,
rule prioritization is not considered and C,=Body,. V rule r (all contrapositives of a rule are

102

considered). Let P be an extended program. Giordano and Martelli [28] define a generalized stable
model (GSM) of P as a 2-valued stable model [26] of exp(P) with the constraints {it—L, “Ll
Le HBP}. The generalized stable model semantics (GSMS) is defined as the intersection of all the
GSMs of P. Since not all programs have a 2-valued stable model, the GSMS of a program P is not
always defined. The next proposition gives the relationship between GSMS and CPS and follows
directly from Proposition 4.4.1.

Proposition 4.4.7: Let P be an extended program with C ,=Body,. V rule r then every generalized
stable model of P is a stable c-model of P.

The reverse of Proposition 4.4.7 is not valid. For example, {a, ~m}, {a, «ma, -'p} are stable
c-models of P={p. “q. a.} and P' = {p <—-p. a.}, respectively. Yet, the GSMS of P and P'
are undefined.

Witteveen [78] defines the strong belief revision model (SBRM) of an extended program P as
the WW of the expansion of P with (i) the contrapositives of the rules, (ii) the rules {Lt- -'L|
Le HBP}, and (iii) the constraints {J. <—L, aLl LEHBP}. Let P=<Rp,<n> with <R={} and
C,=Body,. V rule r. When the rules {L<— ~-'L| Le HBP} are removed from the expansion of P in
[78] and coherence is enforced then the SBRM of P coincides with the XWPMMP) [54] (see

Section 2.4.3). Then, it follows fi'om Proposition 4.4.3 that when the SBRM of P exists, it
coincides with CPSp.

4.4.3 Doyle's Truth Maintenance System

A truth maintenance system (TMS) is a subsystem of an overall reasoning system. The problem

solver of the reasoning system passes to the TMS the inferences it makes (justifications) and the

TMS decides which of the propositions should be believed or not. The primary tasks of a TMS are:

l. truth maintenance: to provide for a consistent interpretation of the nodes in the network and to
update the belief status of the nodes alter the addition of new justifications.

2. belief revision: to perform conflict-resolution when a node which has been declared to be a
contradiction is found to have a valid justification.

103

The need for belief revision has been the basic motivation for the introduction of N83. Many
times decisions should be made with incomplete infomration. Because of this, choices may be
found to be wrong and alternatives nwd to be considered. The two most influential types of TMS
are: Doyle's TMS [18], also called Justification-based TMS, and the Assumption-based TMS [l7],
abbreviated ATMS. An ATMS supports reasoning from multiple hypothetical premise sets. Its
main purpose is to compute for each proposition, minimal consistent assumption sets such as the
proposition is derived from the corresponding hypothetical premises. Here, we will be concerned
only with Doyle's TMS.

A justification is a formula of the form: j=< c<—A,OUT(B) >. The belief of a proposition c is
justified by a justification j=< c<—A,OUT(B) > if all propositions in A={a1,...,a,,} are believed and
all propositions in B={b1,...,bm} are disbelieved. A distinguished proposition J. is used to represent
contradiction and when it is used as consequent of a justification, it allows constraints to be stated.
A dependency network is a tuple (NJ), where J is a set of justifications and N contains all
propositions appearing in some justification jeJ. The purpose of a TMS is to assign to all
pmpositions in N, a label IN (believed) or OUT (disbelieved) in such a way that:

l) A proposition justified by at least one justification is labelled IN.

2) A proposition is labelled IN iff it is justified by a non-circular argument, i.e. a proposition
cannot justify itself.

3) The proposition .L is labelled OUT.

A label that satisfies the above three conditions is called admissible. Given a set of
justifications J, the TMS tries to compute an admissible labelling. If it is the case that the
proposition .L is labelled IN, a contradiction has been found and the TMS has to trace back
(dependency-directed backtracking) to find the non-monotonic justifications underlying the
contradiction so as to revise the labelling. There are two possibilities: either there exists an
alternative admissible labelling where no contradiction-node is IN or there is no such alterative
labelling. Inthesecondcase,anewjustificationiscreatcdtoget rid ofthe contradictionbymaking
IN one of the OUT propositions supporting the belief in J.. Therefore, not only dependency-

 

 

104

directed backtracking produces a switching from one belief state to another for the given set of
justifications but it also modifies the set of justifications itself. It can be seen that the conflict

resolution process mainly relies on reasoning backwards from the contradiction .L using
justifications in their contrapositive directions. In fact, performing several inference steps through
the contrapositives of the justifications, starting fi'om .L allows belief revision by forcing OUT-
assumptions to be labelled IN. This will become clearer With the following example. Let
J={ TA(x).

foreign(x).

takes_credits(x,6)e—TA(x), OUT(ab_TA(x)).

takes_credits(x,9)é—foreign(x), OUT(ab_foreign(x)).

_Lt— takes_credits(x,6), takes_credits(x,9).

}

The only well-founded and closed labelling of J is: IN={TA(x), foreign(x), takes_credits(x,6),
takes_credits(x,9), .L}, OUT={ab_TA(x), ab_foreign(x)} which is inconsistent.
To eliminate the contradiction J., the TMS adds the internal justifications:
ab_foreign(x)(— takes_credits(x,6), foreign(x) or ab_TA(x)(-— takes_credits(x,9), TA(x).
This can be seen equivalently to adding the contrapositives:
{'takes_credits(x,9)(— takes_credits(x,6). ab_foreign(x)<-—foreign(x), 'takes_credits(x,9).}
or {‘Itakes_credits(x,6)<-—takes_credits(x,9). ab_TA(x)<—TA(x), ‘takes_credits(x,6).}
Then, the resulting admissible labellings will be
IN={TA(x), foreign(x), takes_credits(x,6), ab_foreign(x)}, OUT={ab_TA(x), takes_credits(x,9)}
or
IN={TA(x), foreign(x), takes_credits(x,9), ab_TA(x)}, OUT={ab_foreign(x),takes_credits(x,6)}.

An extended program P can be mapped to a dependency network (Np, JP) as follows [29]. Let
Np={Ll L is a classieal literal of P}. The set of justifications Jp is defined as follows:
0 If r: Lac-L1,...,Lm,~Lm+1,...,~Ln is a rule in P then Jp contains the justifications:

—Lot—L1,...,L,,,,OUT(L,,,.,,...,L,,).

105
— “Lie- -'L0,L1,...,L,-,1,L,-rr 1,...,Lm,OUT(Lm+1,...,Ln), where i=l,...,m and Lie C,.
—LJ<— “L0,L1,...,Lm,OUT(Lm+1,...,Lj_1,LJ-+1,...,L,,), where j=m+l,...,n and ~LJ€ C,.
o If A is an atom of P then JP contains the justifications: .L(— A,-:A.
- JP does not contain any other justification.

The following relationship between the GSMS [28] (described in section 4.4.2) of an extended
program P with C ,=Body, V rule r and the admissible labellings of (NPJP) is shown in [29]:
Proposition 4.4.8 [29]: Let P be an extended program with C ,=Body, V rule r. Then, an
admissible labelling G of (NPJP) is mapped to a 2-valued generalized stable model MG of P and
vice versa, as follows: L is IN (resp. OUT) w.r.t. G iff L is true (resp. false) w.r.t. MG, where
Le HBp.

All admissible labelling G of (Np, Jp) is mapped to a stable c-model MG of P in a similar

way. However, the reverse is not true since there is no admissible labelling for all dependency
networks. For example, the dependency networks
DI = ({p, "p, a}, J) where J={p. “p. a. .l.<—p, an} and
02 = ({p, a}, J) where J={p<—OUT(p). a.}
do not have any admissible labelling.
Elkan [22] has shown that given a dependency network D=(N,J) without constraints, the
problem of finding whether D has an admissible labelling is NP-complete w.r.t. the size of N.
Given a set of rules which admits multiple admissible solutions, a TMS considers one solution
per time. This is because the main goal of a TMS is to maintain a consistent set of beliefs.
However, the main goal ofour semantics is to reason about knowledge that can be inconsistent and
draw conclusions that are satisfied in all of stable c-models of the knowledge base. This is the
skeptical view of a knowledge source. If only the computation of one admissible state is required
from an application then a TMS has the advantage that additional information about the modelled
worldwillnotrequirctherecomputationofallthederivedbeliefs sincemanyofthemwillstillbe
valid. According to the CPS, additional information entails the computation of a new contradiction-

106

free model, that is, we have to start from scratch. This is not a major disadvantage when the

skeptical "meaning" of the knowledge base is desired.

4.5 Procedural Semantics

In this section, we present SLCF-resolution (CF for contradiction-flee), a proof procedure to
answer queries on PEPs based on the contradiction-flee semantics. SLCF-resolution is inspired by
the approach to constructive negation taken in SLDFA -resolution [59].

Substitutions in goals are replaced by constraints which are represented by Greek letters. The
idempotent substitution {xi/t1,“ xn/tn} corresponds to the constraint x1=tl,...,xn=tn. A constraint
9 is satisfiable iff CET |=9 , where CET stands for the Clark equality theory [45]. We use the letter
Q to represent a list of literals. A goal is a formula <—6,Q, where 6 is a satisfiable constraint. An
SLCF-refittation ofa goal is defined in Def. 4.5.1. Let t—e,Q be a goal. wplato) l= sag iffthere
exists an SLCF-refutation of rank a for the goal <—-9,Q. A selection function selects a literal flour a
goal. The selected literal of a goal is underlined, e.g., the selected literal of <—6,a,L,b is L.
Definition 4.5.1: Let P be a PEP and a be a countable ordinal. An SLCF-refiitation of rank 021
for a goal G is a sequence of goals G1,...,Gn s.t. G1=G, Gn= <—-9" and VG,- one of the following is
true:

I. (i) Gi= (—6,Q,I_.(xl,...,x,,),Q' and
(ii) 3 a variant r: L(tl,...,tn)(— L1,...,Lm ofa rule in exp(P) and
(iii) 39' s.t. <—9,9',c(aL) r-fails at rank 5 0 (Def. 4.5.3) and
(iv) Gm= (—0,9’,(x1=t1,...,x,,=t,,),Q, L1,...,Lm,Q'.
or
2. Gi= <-9,Q,~L,Q' where L is a classical literal and one of the following is true:
(i) there is 6' s.t. (—9,9',L fails at rank < a (Def. 4.5.2) and GM: (—-6,0’,Q,Q'or
(ii) there is an SLCF-computed answer 9' of rank 5 a for (—9,'"L and Gi+1= <—0,0', Q,Q'.
The constraint 0" restricted to the fine variables of G is an SLCF-computed answer of rank a for

G.

107

A goal (—9,6',c(L) r-fails at rank a+l iff every ground instance of 6,9',L is c-unfounded w.r.t.
r and WPT"(O). Thus, condition I expresses that the head L of a rule r is true if all literals in the
body of the rule are true and "L is c-unfounded w.r.t. r and CPS. Note that an SLCF-computed
answer of rank a+2 for <——6,~L is 0,0' iff (i) 39' s.t. the goal (—9,9',L fails at rank a+1 which
means that every ground instance of 6,9',Le F(WPT‘KO» or (ii) 36' s.t. 9,6' is satisfiable and every
ground instance of 6,6'rLe WPT‘MM) (coherence). The constraint 9' in conditions l(iii) and 2(i)
of Def. 4.5.1 can be computed similarly to the way failed answers are computed in [59].
Definition 4.5.2: Let P be a PEP and a2] a countable ordinal. A goal G fails at rank a ifl‘ there
existsatreeTs.t. (i)ThasrootG, (ii)nonodeofThastheform <—0, and(iii)VnodeN,Nisa

goal and
I. If N= (—0,Q,L_(xl,..., x"),Q' s.t. L is a classical literal then one of the following is true:

(i) N is not the root, there is an SLCF-computed answer 0' of rank < a for e—9,—'L(x1,..., x"),
and N has children: (—9,91,Q,L(x1,..., x”),Q',.. .,<—9,9 ,Q,L(xl,..., x"),Q', where
CET |= 9—>9'v91v...v0,,,

(ii) For every variant r: L(t1,...,t,,)<— L1,...,Lm of a rule in exp(P) s.t. 9,(xl=tl,..., xn=tn) is
satisfiable, N has a child: (——9,(xl=tl,...,x,,=t,,), Q, L1,..., Lm, Q'.

2. If N= <—-0,Q,~I_.(x1,..., x"),Q' s.t. L is a classical literal then one of the following is true:
(i) There is an SLCF-computed answer 0' of rank <a for t—G, L(x1,...,x,,) and N has children:
<—6,0hQ,~L(xl,...,xn),Q’, ..., (—-9,0m,Q,~L(xl,...,xn),Q'. where CET l= G—sd’velv ...v0m.

(ii) Nhas a child: (—0, Q, Q'.

Definition 4.5.3: Let P be a PEP, a2] a countable ordinal and G= <—9",c(K) a goal where K is a
classical literal. G r-fails at rank a iff there exists a tree T s.t. (i) T has root G (ii) no node of T has

theformt-0,and(iii)VnodeN,Nisagoaland
1. If N= 6-9,Q,c(L(xl,..., xn)),Q' s.t. L is a classical literal then one of the following is true:

108

(i) N is not the root, there is an SLCF-computed answer 9' of rank < a for (-6,-‘L(x1,..., x"), and
N has children: 99,91 ,Q,c(L(xl,..., xn)),Q', .. ., e—O,0m,Q,c(L(x1,..., xn)),Q'. where
CET |= 9—> 6’v61v...v6,,,
(ii) For every variant r': L(t1,..., tn)<—L1,...,Lm of a rule in exp(P) s.t. 6,(x1=t1,..., x,,=t,,) is
satisfiable and r' if r, N has a child: 6—9,(x1=t1,..., x,,=t,,),Q,L'1,... ’m,Q', where:
— if Lie C,. and L,- is a classical literal then L',-= c(L,-),
-— if Lie C,. and L,- is the default literal ~L' then L}: c(-L ’),
-- ifLitE C,. and L,- is a classical literal then L'i= Li,
- ifLie C,. and L,- is the default literal ~L'then L',= -'L'.
2. If N= (—9,Q,_L_(xl,..., x"),Q’ s.t. L is a classical literal then one of the following is true:
(i) There is an SLCF-computed answer 9' of rank < a for (—6,*L(x1,..., x") and N has children:
(—9,6bQ,L(x1,..., x"),Q', ..., <—0,9m,Q,L(x1,..., x"),Q', where CET |= 9—) 6'\/61v...v6m

(ii) Nhas a child (—9, Q,Q'.

We will give a difiemnt characterization of CPS where Wp(I) is expressed through the least,
models of transformations of P w.r.t I. The new characterization is used in the proof of the
soundness and completeness of the SLCF-resolution. Let P be a PEP, ground(P) the ground

instantiation of P and I an interpretation of it.
Let r be a rule of ground(exp(P)). The program P/.(r,1) is defined as follows:

(i) Remove from ground(exp(P)) any rule r' s.t. r'< r.
(ii) Replace every default literal ~L in the new program with “L.

(iii) Replace every literal L in the body of a rule in the new program s.t. I(-'L)=I with false.
(iv) IfL is inthe body ofa rulerinthenewprogram andLESr, replaceL with true.

Note that the least, model of P/,(r,l) contains all literals that are not c-unfounded w.r.t. r and I.

The program P/,I is defined as follows:
(i) Remove fi'om ground(exp(P)) any rule r s.t. “Head,.e leastv(P/.(r,l)).

109

(ii) Add to the new program the rules {~L. |~Le 1}.
Note that the least, model of P/,I contains (i) the classical literals that are true in Wp(1) and (ii) the

default literals in I. Step (i) expresses that if the body of a rule r is true then Head,. is derived only
if '"Head, is c-unfounded w.r.t. r and I.

The program P/fl is defined as follows:
(i) Replace every classical literal L in the body of a rule in ground(exp(P)) s.t. 1(“L)=l with false.

(ii) Add to the new program the rules {~L. | ~Lel}.
The least, model of PI]! contains all classical literals that are not in F(I).

The programs P/,(r,l), P/,I and PI]! are positive logic programs because literals “A and ~A,
where A is an atom, are treated as new atoms. It can be seen that Tp(1)=leastv(P/,I), FP(1)=HBP -
leastv(P/f1)). Thus, Wp(1)= coh(leastv(P/, I) u ~(HBP —leastv(P/f1))). Note that if P is a positive
program then least,(P)= T 150(9), where T p is the immediate consequence operator of van Emden
and Kowalski [75]. Let IO={}, ImI=Wp(Ia) and la: UUb | b<a} ifa is a limit ordinal.

Lemma 4.5.1 (Soundness): Let P be a PEP, R a selection rule, L a classical literal, K a literal, and
r a rule.

1. If 6' is an SLCF-computed answer of rank a for goal 6—9,K then every ground instance of 6',K

is true w.r.t. la.
2. If goal é—6,L fails at rank a+l then every ground instance of 0,L is in F(Ia).
3. If goal (—-6,c(L) r-fails at rank a+l then every ground instance of 0,L is c—unfounded w.r.t. r and
la.
Proof: We will prove the proposition by transfinite induction. Assume that it is true for bSa. We
will provethat it is alsotrue fora+l.

1. By part 2 and 3 of the inductive hypothesis, every ground instance of an SLCF-refutation of
rank a+l is an SLD-refutation [45] w.r.t the positive program Pl, 1a- By the soundness of the

110

SLD-resolution, every ground instance of 93L is true w.r.t. least,(P/,1a). Thus, every ground
instance of 6,L belongs to Wp(Ia) since Wp(I)= coh(leastv(P/,I) U ~(HBP -leastv(P/f I))).

2. Assume L' is a ground instance of 6,L s.t. part 2 does not hold. This implies that there is a tree T
that satisfies the conditions of Def. 4.5.2 and L' is not in F(Ia). Since L' is not in F(Ia),
L'e leastv(P/f1a). By the completeness of the SLD-resolution, for the computation rule used in the
tree T, there exists an SLD-refutation for (-—L' ill P/f Ia. Thus, T has a node of the form <—0'
which is a contradiction.

3. Assume L' is a ground instance of 9,L s.t. part 3 does not hold. This implies that there is a tree T
that satisfies the conditions of Def. 4.5.3 and L' is not c-unfounded w.r.t. r and la. Since L' is not
c-unfounded w.r.t. Ia, L'e leastv(P/,(r, 10)). By the completeness of the SLD—resolution, for the
computation rule used in the tree T, there exists an SLD-refutation for <—L' in P/.(r, 1,). Thus, T

has a node of the form (—0’ which is a contradiction. 0

Lemma 4.5.2 (completeness): Let P be a PEP, R a selection rule, L a classical literal, and (—6,L a

goal.

I. If a ground instance L' of 0,L is true w.r.t. Ia then there is an SLCF-computed answer 9' of rank
a for goal <—0,L s.t. L' is a ground instance of 0',L.

2. Ifevery ground instance of 6,L is in F(Ia) then goal (—9,L fails at rank 0+1.

3. If every ground instance of 9,L is c—unfounded w.r.t. a rule r and 1,, then goal (—9,c(L) r-fails at

rank a+l.

Proof: We will prove the proposition by transfinite induction. Assume that it is true for bSa. We

will prove that it is also true for a+l.
1. Since L'e Ia“, it follows that L'e least,(P/,Ia). By the completeness of the SLD-resolution there

is an SLD-refutation for (—L' and P/,Ia. By the mgu lemma [45], there is an SLD-refutation R of
t—L with computed answer ts.t. L'is an instance oftL. From parts 2 and 3 ofthe inductive
hypothesis, there is 9 s.t. adding 9 to every goal of R results in an SLCF-refutation of rank a+l of

<—9,L with answer 9' s.t. L' is a ground instance of 9',L.

Ill
2. Assume that every ground instance of 0,L is in F(Ia) but <—-6,L does not fail at rank a+l.

Consider a tree T with root <—9,L that satisfies the conditions (iii)l and (iii)2(i) of Def. 4.5.2.

Then, T should have a node of the form (—9". Consider a ground instance T ' of T. Then, T ' is an
SLD-derivation of a ground instance of 9,L in P/fIa with root L'. By the soundness of the SLD-

resolution, L'e least,(P/fla). So, there is a ground instance of 6,L which is not in F(Ia) which is a
contradiction.

3. Assume that every ground instance of 9,L is c-unfounded w.r.t. a rule r and la but <-9,L does
not r-fail at rank a+l. Consider a tree T with root 6-9,L that satisfies the conditions (iii)l and
(iii)2(i) of Def. 4.5.3. Then, T should have a node of the form (—9". Consider a ground instance
7" of T. Then, T ' is an SLD-derivation of a ground instance of 6,L in P/u(r,l) with root L'. By the
soundness of the SLD-resolution, L'e least,(P/u(r,l)). So, there is a ground instance of 0,L which
is not c-unfounded w.r.t. r and 1a which is a contradiction. 0

The next proposition follows from lemmas 4.5.1 and 4.5.2.
Proposition 4.5.1 (soundness, completeness): Let P be a PEP, R a selection rule, Q a list of
classical and default literals and G (—0,Q a goal. If 9’ is an SLCF—computed answer for G then
every ground instance of 0',Q is true w.r.t. CPMP. If Qt is ground and true w.r.t. CPM,D then there

is an SLCF-computed answer 9' for G s.t. Qt is a ground instance of 9',Q. Every ground instance
of 0,Q is false w.r.t. CPMP ifl‘ the goal (—6,Q fails.

Example 4.5.1: Consider the PEP, P=<Rp, <R >:

Rp={r1: -'q(0). r2: “q(l). r3: p(X). r4: -'q(X)(- ~s(X). r5: q(X)(- p(X).

with C,=Body,. V rule r} and r‘< r3. Then, the expanded program exp(P) is as follows:
Rmp)={r|: “'q(0). r2: ‘9“). r3: p(X). r4: "iq(X)<— ~s(X). r'4: s(X)(— q(X).
r5: q(X)(—p(X). r'5: 'ip(X)(-— "q(X). with C,=Body, V rule r} and "1< r3.

112
An SLCF-refiltation for (— q(X) is: G, = (— g(X), G2 = (— Xttl, 200 (using rule r5 in condition 1

of Def. 4.5.1).
The goal (— Xatl, c(-'q(X)) r5-fails since there exists a tree satisfying the conditions of Def. 4.5.3.

<— Xrtl, dam)
I (using rule r4 in condition l(ii) of Def. 4.5.3)

(— Xatl, c(a_s_(X)) (it is a leaf)

G3 = (— Xatl (using rule r3 in condition 1 of Def. 4.5.1).

The goal (— Xatl, c(-'p(X)) r3-fails since there exists a tree satisfying the conditions of Def. 4.5.3.

<— th, c("2(X))
I (using rule r'5 in condition l(ii) of Def. 4.5.3)

<- Xfl. 0(‘Q(X))
Note that, since rl<r3, rule r1 cannot be used in condition l(ii) of Def. 4.5.3.
Since X¢1,X=l is unsatisfiable, rule r2 cannot be used in condition l(ii) ofDef. 4.5.3.
I (using rule r4 in condition l(ii) of Def. 4.5.3)

(— X¢l, c("§(X)) (it is a leaf)

So, an SLCF-computed answer for (- q(X) is Xel.

SLCF-resolution is an ideal procedural semantics since termination is not guaranteed for all
programs. A proof procedure for propositional logic programs that incorporates loop daection and

always terminates is given in Appendix B.

4.6 Conclusions
In this chapter, we presented the contradiction-flee semantics (CPS) for prioritized extended
programs (PEP). We gave both a fixpoint and model theoretic characterization of CPS and proved

113

that they are equivalent. CPS is always defined and non-contradictory. The CPS fixpoint operator

avoids contradictions by taking the second approach presented in section 1.3.
Every rule r has a corresponding set C ,. gBody, which is called the contrapositive set of r. If

r is a rule s.t. both Body,. and “Head,. are derived from P then the value of C, indicates which
literals are ”suspect" for the contradiction. When C,={}, only Head,. is "suspect." When C,. ¢{},
the literals in C ,. are also considered "suspect." To facilitate this reasoning, P is expanded with the

contrapositives r' of every rule r such that Head,.ve {aLl Le C,.}. The motivation behind the idea of

the contrapositive sets is given in section 1.3. Criteria for defining the values of the contrapositive

sets are given in subsection 4.2.

In the computation of the fixpoint of the CPS fixpoint operator, when Body,. is true for a rule
r in exp(P) then Head,. is evaluated as true iff “Head,. cannot be derived from rules in exp(P) with

priority no lower than r. The model theoretic characterization of the CPS of P is given by defining
the stable c-models of P. In section 4.3, we proved that CPS is the least stable c-model of P and
that when the Herbrand base of P is finite, the complexity of computing CPS is polynomial w.r.t.
lexP(P)|.

In section 4.4, we relate CPS with existing semantics. CPS extends the well-founded
semantics for nomral programs [76] to PEPs. CPS is a proper generalization of the approaches

followed in ordered logic [24, 43] and conservative vivid logic [77] which correspond to the case
that S,={} V rule r. However, S,={} V rule r, expresses only exceptions. CPS also generalizes the

approach followed in the generalized stable model semantics [28] and strong belief revision
semantics [7 8] which corresponds to the case that S,=Body, V rule r. However, S,=Body, V rule r
is not always correct since the contraposition may not hold for default rules as it was indicated in
section 1.3. Thus, CPS gives a new unifying definition of these approaches.

Specifically, ifP is an extended program with S,=Body, V nrle r then the CPS ofP is a
subset of the generalized stable model semantics of P [28], if the latter is defined. Moreover, the
CPS of P coincides with the strong belief revision semantics of P, if the latter is defined. IfP is an
ordered logic program then the CPS of P coincides with the skeptical c-partial model of P [24] and

 

114

is a subset of the well-founded partial model of P [43]. Ordered logic does not support negation
by default. Generalized stable model semantics and strong belief revision semantics do not support
rule prioritization and fail to give semantics to every contradictory extended program.

A procedural counterpart to the declarative semantics for CFS is developed in section 4.5. The
SLCF-resolution for computing answers for PEPs is presented. SLCF-resolution is based on the
constructive negation approach in which answering of non-ground queries with negated atoms is

attempted. The SLCF-resolution is shown to be sound and complete w.r.t. CPS.

CHAPTER 5

RELIABLE OBJECT LOGIC

5.1 Introduction
In object-oriented databases, data and behavior are encapsulated into object classes which are
structured in a generalization hierarchy. A class lower in the hierarchy (subclass) inherits the
general behavior of its ancestors (superclasses). General behavior may be overridden by special
behavior defined in the subclasses. Logic programming has a profound effect on object-oriented
databases providing both their logical foundations and extending their power.

Many proposals have tried to combine object-oriented and logic programming [81, 37, 38, 32,
13, ll, 47, 36]. In [32], object-preserving rules are used to extend an object of a class C ' to an
object of a subclass C of C'. Each class C has a set of explicit attributes EC. Objects of class C

can be assigned a value for any of the EC attributes. They can also be assigned a value for any of

the explicit attributes of the superclasses of the class C. This way, each class inherits all attribute
definitions fi'om its superclasses. However, the sets of explicit attributes in difl‘erent classes should
be disjoint and inherited attributes cannot be redefined. Thus, only monotonic inheritance is
supported. The unambiguous naming requirement imposes severe constraints which contradict
with the properties of object-oriented programming such as modularity, reusability and incremental
design. Moreover, no parameten'zed attributes (methods) are expressed.

In F-Logic [37, 38], classes and individual objects are indistinguislmble and both are
considered as objects in the class hierarchy. Individual objects are leafs in the class hierarchy even
though the reverse is not always true. Deductive rules manipulate the whole class hierarchy which
is not fixed a priory. Deductive rules can create new objects on the fly. An IS-A term C:C' in the
headofarulecanbeusedtoindicatethataclass Cisasubclass ofC'orthatan individual object

115

 

if.
that

pro!

116

C is an instance of a class C '. Among all untyped models of a program, the minimal for
inheritance models are selected. The defined inheritance is inheritance of values and not of rules.
However, we feel that behavior (rules) and not actual values is what should be inherited.

In [I 1], rules are inherited from superclasses to subclasses. As it was indicated in subsection
2.4.6, in [l 1], rules are considered to be clauses, i.e., there is distinction between the head and the
body of the rule. The authors assume that methods have only one signature and that object names
indicate the class of the object. Thus, the presence of the most specific class for each object is
assumed. This requires an unreasonable large number of classes to support multiple object roles
[51]. The authors define the intended semantics of an object. Their definition, given in subsection
2.4.6, captures the non-monotonic inheritance of clauses. When inherited and local clauses
contradict, the local clauses are given higher priority. The global semantics of a program does not
always exist.

In this Chapter, we describe an object-oriented logic programming language, called reliable
object logic (ROL). In ROL, data and behavior are encapsulated into classes which are structured
in a generalimtion lattice. Object-registration rules are used to register an object to a class or to
exclude it fi'om a class. For example, the information that a student is (resp. is not) graduate is
represented if the student is registered to (resp. excluded from) the grad-student class. In ROL,
object-registration rules can register an object to multiple classes. So, in contrast to [l l], ROL
supports multiple object roles without the requirement of the most specific class for an object. For
example, a student can be member of the TA class and the foreign_student class even though no
foreign_TA class exists.

Method rules define the behavior of the objects of a class. Method rules are inherited fi'om
the superclasses to subclasses. This means that a member of a class C should satisfy the method
rules of the superclasses of C unless a conflict occurs. Some of the conflicts can be resolved using
a rule ordering relation. According to the specificity dominance principle, the method rules of a
class usually have higher priority than these of its superclasses. The reliable semantics of a ROL
program is defined by translating the ROL program to an equivalent EPP. In DOODs, rule

117

prioritization can be used (i) to express the fact that specific rules are more reliable than general
ones, (ii) to give priorities to inherited rules that are in conflict as a result of multiple inheritance
and (iii) to give priorities to class rules that are in conflict as a result of multiple specializations of

the same object.

5.2 Reliable Object Logic Programs
The alphabet of ROL contains a finite set of class, object and method names, variable symbols
including Self Classes are related with a subclass-superclass relationship, <C, which is a strict
partial order. Objects are registered into classes and manipulated through the ROL rules.

Each class C has a set of parameters, called parameters of C. The signature of C specifies the

classes of these parameters.
Definition 5.2.1 (class signature): The signature of a class C has a form: C(C 1,...,C,,) where

C1,...,C,, are the classes ofthe parameters of C.

The signature of a method meth on a class C specifies the classes of the input/output

parameters of meth when it is applied to an object of class C.
Definition 5.2.2 (declared method signature): The declared signature, DSIdeeth), of a

method meth on a class C has a form: meth(C1,...,C,,) where n is the arity of meth and C1,....C,,
are the classes of the parameters of meth. DSIdeeth) may not be defined.

When the declared signature of a method on a class C is not defined, the signatures of the

method on the direct superclasses of C are inherited.
Definition 5.2.3 (method signature): The signature, SIdeeth), of a method meth on class C is

defined as follows: If DSIdeeth) is defined then SIGC(meth)= {DSIdeeth)}. Otherwise,
SIGC-(meth)={DSIGC(meth) | DSIGC(meth) is defined, C<CC' and there is C<C...<CC"<C..<CC'
such that for all C " in the sequence with C "<CC ', DSIGCu(meth) is not defined}.

118
An object registration atom tozC or t0:C(t,,...,t,,) indicates that the object to is member of the
class C with parameters tl,...,tn. A method atom to meth(t1,...,tn) indicates that the method meth is
applied to the object to with input-output parameters t1,...,t,,.
Definition 5.2.4 (term, atom, literal):

0 A term is a variable or an object name.

0 An object registration atom has the form: tozC or t0:C(tl,...,t,,) where C is a class name with n
parameters and toast" are terms.

0 A method atom has the form: to meth(t1,...,tn) where meth is a method with arity n and 10.....tn

are terms.
0 An object registration (resp. method) literal is an object registration (resp. method) atom A, its

classical negation “A or its default negation ~A,

Definition 5.2.5 (rule, constraint):

0 An object registration rule has the form: r: Li—Ll,...,Lm where L is an object registration literal
and L1,...,L,,, are literals. The preliminary suspect set S, of rule r is a subset of {L}....,Lm}.

0 A method rule has the form r: Selflmeth(t],..,tn)(— L1,...,Lm or r: “Selfmeth(tl,..,tn)<—
L1,...,Lm, where Selfmeth(tl,..,tn) is a method atom and L1,...,L,,, are literals. The preliminary
suspect set S, ofrule r is a subset of {L],...,L,,,}.

0 A constraint has the form .L(— L1,...,Lm, where L1,... L", are literals.

When the head of a rule r is t:C or t:C(t1,...,t,,), we say that r registers object tto C. When
the head of a rule r is "t:C or “t:C(tl,...,tn), we say that r excludes object t from C.
Definition 5.2.6 (class specification): The specification of a class C is a tuple SPECC=<SIGC,
MSIGC, labelC, RC> where:
- SIGC is the signature of class C.
- labelc has the form C(X1,...Xn) where X 1,...,Xn are universally quantified variables,

representing the parameters of C.

119

—MS1GC is the set of declared signatures of methods on C.
-MRC is a finite set ofmethod rules.

When a rule reMRC, we say that r is applied to the members of class C.
Definition 5.2.7 (ROL program): A ROL program is a tuple P=<CSPECP, ORP, ICP, <C, <R >
where:
- CSPECP is the set of all class specifications.
— ORP is a finite set of object registration rules.
—1Cp is a finite set of constraints.
- C is a strict partial ordering relation between classes.

- <R is a strict partial ordering relation between method rules.

If r,r' are method rules such that r<r' then r' is considered more reliable than r only when r,r'
are applied to the same object.
Example 5.2.1: The following is a ROL program (signatures are ignored and terms starting with a

capital letter are variables). The class hierarchy is given in Figure 5.1.

student

9rad_stud

/\

TA foreign _grad_stud

Figure 5.1: The class hierarchy

120

Class Specifications (CSPECP):
student(Name,Country,Credits) {
r1: Self.name(Name).
r2: Selficitizenship(Country).
r3: Self.firll_time()(-—Self.full_time_credits(X), CreditsZX. Sn={Self.full_time_credits(X)}
/* If a student takes more credits than needed for the student to be considered
full-time then the student is full-time. ‘/
grad_stud(){
r4: Self.fi111_time_credits(9).
TA(Course){ /“' TA stands for teaching assistant ‘/
r5: Selfteaches(Course).
' r6: Selffilllfltime_credits(6).}
foreign _grad_stud(){
r7: Selffilll_time_credits(12).}
Object Registration Rules (ORP):
r8: X:foreign_grad_stud(—X:grad_stud, X.citizenship(Y),Y¢"USA".
Sn={X:grad_stud, X .citizenship(Y)}
r9: ann:student("Ann","UK",12).
r10: annzTA.
Constraints (ICp):
.Lt—X.full_time_credits(Y), X.full_time_credits(Z),Y¢Z. /* fiill_time_credits is functional */
Rule Priorities: r406, r4<r7, r706. /" Specificity dominance principle and regulation ‘/
Theprogramgivesthenumberofcreditsthatagraduatestudentneedstotaketobe
considered full time. If a graduate student is not TA (teaching assistant) or foreign student then
he/she needs 9 credits. Ifa foreign graduate student is not TA then he/she needs 12 credits. A TA
needs only 6 credits.

121

5.3 Reliable Semantics for ROL programs
Let P be a ROL program. To define the reliable semantics of P, P is mapped to an EPP, f,,(P).

Definition 5.3.1 (fL transformation) Let P be a ROL program. The fL transformation maps a ROL
literal to a conventional literal as follows:

0 Ift0:C(tl,...,t,,) is an atom of P then fL(t0:C(t1,...,tn))=C(to,t1,...,tn) and fi(t0:C)anember_C(t0).
0 Ift0.meth(t1,...,t,,) is an atom of P then fL(tO.meth(t1,...,tn))=meth(to,t1,...,tn).

. IfA is an atom ofP then fL(-A)= «fL(A) and th-or )=~fL(A).

If S is a set of ROL literals then fL(tS')=d¢f{fL(L)| Le S}. In the next definition, we symbolize

Body, with Ed, and S, is subscript of (— in rule r.

Definition 5.3.2 (I, transformation) )1, maps a ROL program, P, to an EPP as follows:

(i) If C is a class with n parameters then f,(P) contains the rule:

r. member_C(X0)(—Bd, C(X0,X1,...,X,,).
(ii) IfC is a class with signature C(Cl,...,C,,) then f,,(P) contains the rule:
r: wtyped_C(X1,...,X,,)(—Bd, member_C1(Xl),..., member_Cn(X,,).
(iii) Let meth be a method and C be a class. If C ’<cC, meth(C1,...,C,,)€ SIGC(meth) and
C'l,...,C'm are the direct subclasses of C'tllenj;,(P) contains the rule:
r: wtyped_meth_C(X',Xl ,...,X,,)<—Bd, member_C'(X'),~mernber__C '1 (X'),. . .,~member_C 'm(X'),
member_C I (X 1 ),. . .,member_C,,(X n)-
(iv) IfC is a direct subclass ofC’thenf,(P) contains the rules:
i”. member_C'(X)(—-Bd, member_C(X) and r': member_C(X)(—Bd,. "member__C'(X).

(v) Let r: Selfmeth(tl,...,tm)(-—S,L1,...,Ln be a method rule inMRC. Then, f,(P) contains the rules:
{meth(Self,t1,...,tm)efi(s,)fi(&0?MbelC), wtyped_meth_C(Self,t1,...,tm),fL(L1),...,fL(Ln) |
Selfe 08.1}, where OBJ is the set of object names in P.

(vi) Let r. t0:C(tl,...,tm)(-—S,L1,...,Ln be an object registration rule Then, f,(P) contains the rule:

122
C(t0,t1,...,tm)<—fi(s,) wtyped_C(t1,...,tm),fL(L1),...fL(Ln).
(vii) Let .Lt-«Ll,...,Ln be a constraint in P. Then, f,,(P) contains the constraint J.<—fL(L1),...,fL(Ln).
(viii) The <R relation in f,.(P) is defined as follows:
- If r,r' are rules created in (i),(ii),(iii) or (iv) then r<>r'.

- If r is a rule created in (i),(ii),(iii) or (iv) then r’ <r V rule r’ created in (v) or (vi).
- Let r,r' be rules created in (v). If r, r' have heads the literals meth(o,t1,...,tm) and

meth'(o,t'],...,t'm), and correspond to rules rROL and r'ROL in P with rROLQ'ROL then r<r’.

The literals wtyped_C(tl ,...,t,,) and wtyped_meth_C(t1,...,tn) are called well-typing literals. A
rule in f,(P) whose head is a well-typing literal. is called well-typing rule. An atom 00:C(ol,...,on)
(resp. oometh(ol,...,o,,)) is well-typed if objects o,-,ViSn, are members of the classes as indicated
in the signature of the class C (resp. method meth). An interpretation of a ROL program P is a set
7U~F where T,F are disjoint sets of ground classical literals of P.

Definition 5.3.3 (well-typed atom, literal) Let P be a ROL program and I an interpretation of it.

0 A ground atom o:C(ol,...,o,,) is well-typed w.r.t. 1 iff C has signature C(Cl,...,C,,) and oi:Cie I,
ViSn.

o A ground atom o.meth(o],...,on) is well-typed w.r.t. 1 iff there is a class C' such that
meth(Cl,...,C,,)e SIGC(meth), o,-:C,~e I, ViSn and if C'1,...,C'm are all the direct subclasses of C'
then ozC'eI, ~o:C'ieI ViSm.

0 A well-typed ground literal is a well-typed ground atom or its negation.

A member of a class C is a member of all superclasses of C. An object that is not a member
of a class C is not member of any subclass of C.
Definition 5.3.4 (well-typed interpretation) Let P be an ROL program. An interpretation I of P is
well-oped ifl‘ all classical literals in I are well-typed w.r.t. I and
(i) if o:C(ol,...,o,,)eI then ozCeI.

(ii) if o:CeI then o:C'e I, for all classes C' with C<CC'.

123

(iii) if 'iozCeI (resp. ~ozCeI) then ”'0:C '61 (resp. ~02C'e l). for all classes C ' with C '<CC.

To compute the reliable model of a ROL program, the reliable model of f,.(P) is computed
first.

Definition 5.3.5 (reliable model) Let P be a ROL program and M be an interpretation of P. M is

an o-model (resp. stable o-model, reliable model) of P iff M ' is an r-model (resp. stable r-model,
reliable model) of f,(P) andM= L"(M'—{L| L is a well-typing 1iteral}).

Let r be a rule in fP(P) created in Steps (v) or (vi) of Definition 5.3.2. Note that the well-
typing literal L“ in Body, does not belong to the preliminary suspect set of r. This implies that
C WAs and rules used in the derivation of L,“ are not "suspects" for constraint violations that
depend on r.

The rules in f,,(P) created in Steps (i),(ii),(iii) and (iv) of Definition 5.3.2 are reliable w.r.t.
any interpretation because they have higher priority than any other rule in f,,(P). This guarantees
that every o-model of P is a well-typed interpretation of P.

Proposition 5.3.1 Let P be a ROL program IfM is an o-model of P then M is a well-typed
interpretation of P.

Proof: (Steps in the proof are referring to Definition 5.3.2). From the well-typing rules added to
f,(P) in Steps (ii) and (iii) and the well-typing literal in the body of a rule added to f,(P) in Steps
(v) and (vi), it follows that all classical literals in M are well-typed. From the rules added to f}(P)
in Step (i), it follows that ifo:C(ol,...,on)eM then ozCeM From the rules added tof,(P) in Step
(iv), it follows that if o:CeM then ozC'eM and if -o:C'eM (resp. ~o:C'eM) then -o:CeM (resp.
~ozCeM), for all classes C,C' such that C<CC’.

Proposition 5.3.2 Lethe aROL program IfMis a stable o-model ofPthen there is only oneM'
such thatM' is a stable r-model of f,(P) and M= L"(M'-{L| L is a well-typing 1iteral}).

124

Proof: Assume that M' and M" are r-models of j},(P) and M= L"(M'-{L| L is a well-typing
litera1})=fL"()\J"-{L| L is a well-typing 1iteral}). Then, M' and M" differ only on well-typing
literals. However, this is not possible because of the rules added to j}(P) in Steps (ii) and (iii) of

Definition 5.3.2.

Example 5.3.1: Let P be the ROL program of Example 5.2.1. Then, fP(P) is as follows:

(well_typing rules and literals are ignored)

Method Rules (created in Step (v) of Definition 5.3.2):
r]: name(arm,Name)<—student(ann,Name,Country,Credits).

r2: citizenship(ann,Country)<—student(ann,Name,Country,Credits).
r3: filll_time(ann)(-—student(ann,Name,Country,Credits), filll_time_credits(ann,X),CreditsZX.
Sn={firll_time_credits(ann,X)}
r4: full_time_credits(ann,9)<—member_grad_stud(ann).
r5: teaches(ann,Course)<-—TA(ann,Course).
r6: filll_time_credits(ann,6)<—TA(ann,Course).
r7: full_time_credits(ann,12)<—member_foreign_grad_stud(ann).
Object-Registration Rules (created in Step (vi) of Definition 5.3.2):
r8: member_foreign_grad_stud(X)<—member_grad_stud(X), citizenship(X,Y),Y¢"USA".
Sn={member_grad_stud(X), citizenship(X,Y)}
r9: student(ann,"Ann","UK",12).
r10: member_TA(ann).
Class Membership Definitions (created in Step (i) of Definition 5.3.2):
r1 13 member_student(X)<-—student(X,Name,Country,Credits).
r12: member _grad_stud(X)£—grad_stud(X,Credits).
r13: member_TA(X)(—TA(X,Course).
r14: member_foreign_grad_stud(X)e-foreign_grad_stud(X).

Class Membership Relationships (created in Step (iv) of Definition 5.3.2):

125

r15: member_student(X)(—member_grad_stud(X).
r16: member_grad_stud(X)<—- member_studenKX).
r17: member _grad_stud(X)<— member_TA(X).
r18: member_TA(Xy— member_grad_stud(X).
r19: member _grad_stud(X)<-—member_foreign _grad_stud(X).
r20: -'member_foreign_grad_stud(X)<—1nember_gmd_smd(X).
with S,,={ }, Vi $11 and i¢3,8 and S,,.=Body,,, Vi>l 1.
Constraints:
.l.<-full_time_credits(X,Y),full_time_credits(X,Z),Y¢Z.
Rule Priorities:

r406, r4<r7’ r7<r6 and r,- <rj, Vi $10 and j>10.

The reliable model of P is RM p=T pu~F p where:

T p={annzstudent("Ann","UK",12), annzstudent, ann:grad_stud, annzTA, ann:foreign_grad_stud,
ann.name("Ann"), ann.citizenship(”UK”), ann.firll_time_credits(6), ann.firll_time()}

and Fp=HBp-TP-{ann.filn_t1me_cred1t5(X)l x=9, 12}.

Let P' be the ROL program that results if we eliminate r7<r6 from <R of P. Then, the reliable
model of P' is RMpt=Tpt U~Fptwherez
T pt={ann:student("Ann","UK",12), annzstudent, ann:grad_stud, annzTA, ann:foreign_grad_stud,

ann.name("Ann"), ann.citizenship("UK”)}
and PP: =HBP' -TP' -{ann.full_time_credits(x)| F6,9,12}-{ann.full_time()} .

It is arguable that ann.full_time() should be true because even though it is unknown which of
{ann.filll_time_credits(6), ann.full_time_credits(12)} is true, the literal ann.full_timeO is true ill
both cases. A similar argument applies against ordered logic [43], too. However, in [10] (reviewed
in subsection 3.6.1), ann.full_time() is derived because the disjunction
ann.filll_time__credits(6)vann.filll_time_credits( 12) is added to the knowledge base.

126

5.4 Conclusions

An applieation of RS to deductive object-oriented databases (0000s) is described. We present a
simple but powerful logic, called reliable object logic (ROL). ROL models important aspects of the
object-oriented paradigm such as object-identity, class hierarchy, multiple inheritance, multiple

roles of an object and defaults. Each object of a class C has a set of attributes which are defined
when the object is registered into the class. An object registration atom t0:C(tl,...,t,,) indicates that

object to is a member of class C and has attribute values t1,...,t,,. Each class has a set of methods
which are applied to the objects of the class. A method atom tozmeth(t1,...,tn) indicates that the
method meth is applied to the object to with input-output parameters t],...,tn. Object registration
rules and method rules are used to register objects into classes and to compute the results of the

application of methods to objects, respectively. Rule prioritization makes it possible to deal with

default properties, exceptions and contradictions in the context of object-oriented programming.

CHAPTER 6
CONCLUSIONS AND FUTURE RESEARCH

We have presented two approaches, namely reliable semantics (RS) and contradiction-free
semantics (CPS), for dealing uniformly with incomplete information, exceptions and contradictions
in logic programs. Incomplete information is handled with the incorporation of classical negation.
Exceptions are expressed (i) by using classical negation and rule prioritization or (ii) by using
classical negation and negation be default. Contradiction is avoided by using the concepts of
reliable rule and reliable closed-world assumption (C WA) in the first approach and c-unfounded
literal in the second approach.

0 Incomplete information

According to the closed-world reasoning, negative information ~A is true if A cannot be derived
from the rules of the program. However, when the rules give only an incomplete definition of a
predicate, closed-world reasoning cannot be applied for this predicate. It is possible that A is not
derived fi'om the program rules, not because A is false but because of missing information.
Classical negation ('i) allows us to reason in the absence of the domain-closure assumption for a
set of predicates PredOW (0W stands for open-world). Specifically, if A is an atom with predicate
in Predow then A should be considered false only if -'A is derivable from the program. Closed-
world reasoning can still be used for predicates with complete positive definitions.

0 Exceptions

Allowing classical negation in the heads of rules is also useful in expressing exceptions to general
rules. For example, the rule afly(X)<—penguin(X) expresses an exception to the general rule
fly(X)(-—bird(X). However, to avoid contradiction, either the default literal ~penguin(X) should be
added to the body of the general rule or the exception rule should be given higher priority than the

127

128

general rule. Even though both approaches can be expressed in the RS framework, the former
approach is not modular since for each exception, a default literal should be added to the body of
the general rule.

- Contradiction

Positive programs never cause contradiction. In contrast, an extended program can be
contradictory, i.e., it is possible that both literals A and “A are derived from the program. Let P be
such a contradictory program. Our semantics, instead of simply noticing the contradiction, derive
useful conclusions that are irrelevant to the contradiction. A characteristic of our approaches is
that they do not only restrict inferences from the contradictory literals A and “A but also from
literals (possible sources of the contradiction) contributing to the derivation of A and “A. The
preliminary suspect sets of the rules in the first approach and the contrapositive sets of the rules in
the second approach indicate how far back in the derivation path the sources of the contradiction
can be. Rule prioritization indicates our relative confidence in the conflicting rules. In our first
approach, the priorities and the preliminary suspect sets of the rules are used ill the definition of
reliable rule and reliable C WA. A conclusion is considered irrelevant to contradiction only if it is
derived from reliable rules and reliable C WAs. In our second approach, the priorities and the
contrapositive sets of the rules are used in the definition of a c-unfounded literal w.r.t. a rule r. A
conclusion L is considered irrelevant to contradiction only if it is derived from a rule r s.t. "L is c-
unfoundcd w.r.t. r.

RSandCPSaredefinedasthefixpoints oftwomonotonicoperators. Themodeltheoretic
characterization of the RS (resp. CPS) of a program P is given by defining the stable r-models
(resp. stable c-models) of P. Both RS and CPS are interpreted as the skeptical view of the world.
Stable r—models and stable c—models of P are interpreted as alternative enlarged consistmt belief
sets standing for different possible views of P. We have shown that RS (resp. CPS) is a stable r-
model (resp. stable c-model) of P and coincides with the intersection of all the stable r-models
(resp. stable c-models) of P. Because of this property, proof procedures for capturing skeptical
reasoningarerelatedtoonestablemodelinthesemanticsandimplyvalidityinall stablemodels.

129

In section 4.5, the SLCF-resolution (linear resolution with selection function for contradiction-free
semantics) for computing answers for extended programs with rule prioritization is presented. The
SLCF-resolution is shown to be sound and complete w.r.t. CPS.

In subsections 2.4.1 and 4.4.1, we showed that RS and CPS generalize the well-founded

semantics for normal programs [76]. In subsection 2.4.3, we showed that RS generalizes the
extended well-founded semantics for non-contradictory extended programs [54]. RS and CPS can
express uniformly various recent proposals for reasoning with contradictions in logic programs:
0 Ordered Logic [24, 43] (subsections 2.4.7 and 4.4.1). Ordered logic can be expressed in the RS
and CRS framework, by taking Sr={} V rule r. However, S,={} V rule r, expresses only
exceptions and not reliability. Thus, ordered logic can only handle contradictions caused by
exceptions to general rules. Since ordered logic does not support negation by default, exceptions
can only be expressed by giving them higher priority than the general rules. When complementary
literals A and “A are derived from conflicting rules with priorities that cannot be compared,
ordered logic blocks the inferences from the contradictory literals A and “A but not fi'om the
possible sources of the contradiction.

0 Conservative Vivid Logic [77] (subsection 2.4.5). Conservative vivid logic behaves similarly to

ordered logic when <R={ }. Thus, when complementary literals A and “A are derived from

conflicting rules, derivations from A and “A are blocked. Yet, possible sources of this contradiction
will still be used for further inferences.

0 Relevant Expansion [79] and Contradiction Removal Semantics [52, 55] (subsection 2.4.4).
Both approaches can be expressed in the RS Work by taking S,=Body, V rule r and <R={}.
In contrast to RS, these approaches do not support rule prioritization and they are applicable only
for a special kind of extended programs whose inconsistencies ean be removed by retracting some
CWAs.

0 Generalized Stable Model Semantics [28] and Strong Belief Revision Semantics [79]

(subsection 4.4.2). The strong belief revision semantics extends the generalized stable model

semantics from 2-valued to 3-valued logic. These approaches can be expressed in the CPS

I30
framework by taking C,=Body,. V rule r and <R={}. Thus, all contrapositives of the original rules

are considered to be valid. In CFS, the use of contrapositives can be controlled through the

contrapositive sets C r. Strong belief revision semantics and generalized stable model semantics do

not support rule prioritization. Moreover, they are not defined for every contradictory extended

program.

The main contributions of RS and CPS are summarized as follows:

0 Broader Domain. They cover a broader domain of logic programs than semantics proposed
earlier.

0 Uniform Framework. They provide a framework for dealing uniformly with incomplete
information, exceptions and contradictions in logic programs.

0 Generalization. They extend semantics proposed earlier for non—contradictory logic programs.
They express uniformly various proposals of reasoning with contradictions in logic programs.

0 Universality. They are well-defined for every contradictory program, i.e., they derive useful
conclusions that are irrelevant to the inconsistency.

0 Uniqueness. They coincide with the intersection of all stable models of the program. This implies
that the skeptical meaning of the program can be computed without the expensive computation of
all stable models.

0 Efficiency. They can be computed in polynomial time w.r.t. the size of the program, whm the
Herbrand base is finite.

In Chapter 3, the modular reliable semantics (MRS) for prioritized modular logic programs
(PA/H’s) is presented. A PW consists of a set of modules and a partial order <def on the predicate
definitions. By combining a set of modules to a single program, information may be obtained that
is not derivable from a single module. This way, large deductive databases can be developed in
parts and later be combined. Also, cooperative problem solving is possible by combining the
knowledge of individual agents. We assume that the knowledge of an agent is encapsulated in a
module. The problem of combining the knowledge of different agents is non-trivial because
individual agents usually hold conflicting views on their domain of expertise. MRS provides a

l3]

framework in which only agreeing results are exported from the modules but individual modules
can still maintain their internal beliefs. The concepts of local literal and reliable indexed literal are
developed. A local literal M#L represents the internal belief of agent M for the truth value of literal
L. A reliable indexed literal {M l,...,M,,}'L represents the agreeing belief of agents M1,...,M,, for
the truth value of literal L.

An application of RS to deductive object-oriented databases (00003) is described in Chapter
5. We present a simple but powerful logic, called reliable object logic (ROL). ROL models
important aspects of the object-oriented paradigm such as object-identity, class hierarchy, multiple
inheritance, multiple roles of an object and defaults. Rule prioritization can be used to give higher
priority to local than inherited rules, in case of conflict. Thus, rule prioritization makes it possible
to deal with default properties and exceptions in the context of object-oriented programming. Rule
prioritization can also be used for the avoidance of general contradictions.

The modular reliable semantics for PMPs can also have application in 0000:: since each
object class can be seen as a module. When classes are independently developed and then put
together, conflicts are likely. Since the class internal details may be unknown, we would like to
derive reliable information without class internal revision. The <def relationship between predicate
definitions can be used to express that in case of conflict, results from subclasses have higher
priority than results from superclasses. Indexed literals can be useful in the case of multiple
inheritance because the derivation of a literal from only one superclass or a set of superclasses of
an object can be queried. The "point of view" notion of multiple inheritance, proposed in [15], can
also be implemented using indexed literals S1,, where S is a set of classes representing the "point of
view" ofa class C and an object o [15]. The details of the representation ofa DOOD in the MS
framework remain to be investigated.

Rule prioritization in RS can express explicit priorities on the rules. For example, it can
indicate that rule r]: *fMXk—penguinm has higher priority than rule r2: fly(X)<—bird(X).
Touretzky [73, 74] claimed that prioritization among defaults can be obtained using implicit

specificity information even when no explicit rule prioritization exists. For example, since every

 

132
penguin is a bird, rule r] is implicitly more specific than rule r2. Note that explicit priorities
supplied by the user will still be useful to decide among conflicting rules which cannot be ordered
using implicit specificity information. Geerts and Vermeir [25] presented an approach in which
implicit and explicit priorities are combined in the framework of ordered logic. Future work should

be concerned with the combination of implicit and explicit priorities in our frameworks.

In subsection 3.6.1, we discussed work on combining local deductive databases P1,....,P,,. In
[10], when a constraint .L(-L1 ..... Ln is violated in the combined database P, the disjunction
le...vL,,, is added and the rules with head L,-, 1'9, are removed from P. Thus, P is a consistent
disjunctive program containing more information than the RS of P' =PIU... .uPn. For example, if P
contains the rules At—Ll, A<—L,, and A does not appear in any other rule in P then A will be
evaluated as true in [10] but as unknown in the RS of P'. Yet, a disadvantage of the approach in
[10] is that literals Ll ..... Ln may be based on unreliable information which will be evaluated as
true In the RS of P', not only the literals Li, iSn, are considered ”suspect" for the violation of the

constraint but also the literals used in the derivation of L,-, iSn. A combination of the approaches in

[10] and RS should be investigated.

When the constraints of an application are modified, it is possible that the application
programs do not satisfy the new constraints. Our semantics can be usefiil to applications whose
constraints change frequently. Though the application programs may violate the constraints, our
semantics will represent only the reliable information derived fi'om them. Future work should

include the investigation of specific applications and their requirements.

 

APPENDICES

 

APPENDIX A

PROOFS OF SECTION 4.3

Proof of Proposition 4.3.1: We will show that W p is a monotonic operator. Let I,J be

interpretations of P s.t. lg]. T(1)<;T(J) follows from the fact that if a literal L is c-unfounded w.r.t.

 

a rule r and I then L is c-unfounded w.r.t. a rule r and J. Since F(DQFU) and call is a monotonic

operator, W p is a monotonic operator and {Ia} is a monotonically increasing sequence of

interpretations w.r.t. ;.
We will prove by induction that for all a, there is no literal K s.t. {K,-'K};Ia~ This is true for j

 

a=0. Assume that it is true for ordinals <a. We will prove that it is true for a. Assume first that
a=b+1 is a successor ordinal. Assume that there is literal K s.t. {K,-'K}:Ia. This implies that there

is a literal Lela derived fi'om a rule r inP s.t. L is used in the derivation ofKor *Kand *L is not
c—unfounded w.r.t. a rule r and la. However, this is a contradiction because when a classical literal
L is derived from a rule r then “L is c-unfounded w.r.t. a rule r and la (Def. 4.3.1). Thus, la is

consistent.

Let a be a limit ordinal and assume that there is literal K s.t. {K,“K};Ia. Then, there is a
s“°c&ssor ordinal b+l<a s.t. {K,-K};Ib+1. This is a contradiction because of the inductive

hypothesis. So, Ia is consistent for all a.

We will prove by induction that for all a, there is no literal L s.t. Lela and ~LeIa. It is true

for N. Assumethatitistrueforordinals <a. Wewill provethat itis true fora. Assume firstthat
kb‘bl is a successor ordinal. We will prove that there is no literal L s.t. Le Ia and ~Le Ia. This is

“'“e for a=0. Assume this is true for ordinals <a. Let S be any set of classical literals that has a

133

134

non-empty intersection with T(Ib). Choose the smallest c s.t. 10+] has a non-empty intersection
with S. Note that (:9. Let Ke IcHnS. Then K is derived from a rule r in exp(P) s.t. Body,.glc.
From hypothesis, there is no literal K6 Body,., s.t. ~Ke 1b. Moreover, fiom the way r is defined,
there is no classical literal K in Body,. s.t. Ke S. So, S is not c-unfounded w.r.t. Ib~ This implies
that T(Ib)nF(Ib)=0. Moreover, there is no classical literal L s.t. Le T(Ib) and "Le T(Ib), because
Ia does not violate any constraint. So, there is no literal L s.t. Le Ia and ~Le 1a. Leta be a limit
ordinal and assume that there is L s.t. Le Ia and ~Le 10. Then, there is a successor ordinal b+l<a
s.t. L611,” and ~Le [b+l- This is a contradiction because of the inductive hypothesis.

la is a coherent interpretation, for all a, because of the col: operator in the definition of Wp.

Proposition 4.3.1 follows. 0

Proof of Proposition 4.3.2: From Proposition 4.3.1, Id is a consistent, coherent interpretation. Let
r be a rule in exp(P). We will show that r is c-true w.r.t. 14

(i) If Ia(Body,.)=1/2 and Id(Head,.)=O then Id(-'Head,.)=l because otherwise 14(Head,)=l/2.

(ii) IfId(Body,.)=l and IAHeadrkl/Z then *Head, is not c-unfounded w.r.t. r and Id because
otherwise, from the definition of T(Id), Id(Head,.)=l.

(iii) If IABody,)=l and Id(I-lead,.)=0 then "-‘Head, is not c-unfounded w.r.t. r and Id because
otherwise, from the definition of T(Id), Id(Head,.)=l. Since “Head,. is not c-unfounded w.r.t. r and
Id, it follows that Id(-'Head,.)=l because otherwise, fi'om the definition of F (Id), 10(Head,)=l/2.
(iv) In all the other cases, Id(I-lead,.)21d(Body,.). 0

Proof or Proposition 4.3.3: Let P be a propositional PEP. The algorithm CFM(program P)
returns the contradiction-free model of P. To compute F(I) and the set of c-unfounded literals w.r.t.

a rule r and I, the complement set is constructed first, as in [76]. The complexity of the algorithm
is 0(WBPHRexp(P)l2)-

 

135

CFM(PEP program P)
{ neW_1={};
repeat
I=new_I;
repeat /* Step 1: compute T(I) */

for each rule r of exp(P) do
if Body,. :new_1 and c-unfounded(-'Head,.. r, I) then add Head,. to new_1;
end /"' for */
until no change in new__1;

compl_F={ };
repeat /" Step 2: compute F(I) "‘l
for each rule r of exp(P) do
if 1(Body,.)¢0 and all body classical literals of r are true w.r.t. I
then add Head,. to compl_F;
end /‘ for */
until no change in compl_F;
for each Le HBP do /‘ Step 3 ‘I
if LE compl_F then add ~L to new_1;
end I‘ for "/

new__I = coh(new_1); I‘ Step 4: Compute coh(T(1)u~F(1)) */
until I=new_1;
retum(1);
}

c-unfounded(literal L, rule r, interpretation 1) /“ retums TRUE is L is c-unfounded w.r.t. r and I */
{ compl_U={};

repeat
for each rule r' ofexp(P) s.t. r’ sfir do

if I(Body,v)¢0 and for each Le Body,.v either L is true w.r.t. compl_U or LE C,.v
then add Head,.! and ~ *Headrv to compl_U;
end I" for ‘/
until no change in compl_ U;
_ if LE compl_U then retum(TR UE); else retum(FALSE);
}

The complexity of computing if a literal L is c-unfounded w.r.t. a rule r and interpretation 1 is
lRexp(P)| [19]. So, the complexity of Step 1 is lRexp(p)|2. The complexity of Step 2 is lRexp(P)l
[19]. The complexity of Steps 3 and 4 is lHBpl. Since {la} is a monotonieally increasing sequence
w.r.t. c, the total number of iterations until I=new__I, is less than |HBp|. So, the complexity of the
algorithm amp) is Gresham?) o

 

136

Proof of Proposition 4.3.4: Let CHM be the contradiction-flee model of P and let P ' be equal to
exp(P)/CCFM. From Proposition 4.3.2, CFM is a c-model of P. So, it is enough to show that

CFM=least,(P’). Let leastv(P')=7U~F, where T, F are sets of classical literals. Let Ia= awFa,
where T a: Fa are sets of classical literals and CFM = Id- First, we will prove by induction that
T bU'Fb :MF, VbSd. It is true that T OQT and FOQF. Suppose that T agT and FagF, Va<b. If
b is a limit ordinal then T bgT and FbgF since Ib= UUaI a<b}. Assume therefore that b=a+l. It is
true that T,,T0(o)<;r. Assume that T1,T0’(e):T. we will show that T,,Ta*1(o)gr. Let
Le T,,T0'+1(o). Then, 3 r'Lt—Ll ..... L" in exp(P) s.t. —~L is c-unfounded w.r.t. r and la and ViSn
either (i) Lie Ia or (ii) L,- is a classical literal and Lie TIGTa'M). Since [‘7ng and Le CFM,
there is a rule L6—L'1,...,L'm in P' where L’1,....L'm are all the classical literals in {L1,...,L,,}. From
the facts T10?“ '(0);T , 1‘,ng and the definition of leastv(P’), it follows that Le T. This implies
that T(Ia)=Tb;T.

Now, we will show that Fch. Since Fb= “TbUF(Ia), it is enough to show that “TbgF and
F(Ia):F. IfLe “T b then “Le CW and from Step (ii) of Def. 4.3.3, Le F. Consequently, “TbgF.
For all rules Ht—L'1,...,L'm,~L1,..,~L,, in exp(P) (Li: L'i are classical literals) with He F(Ia) either
BiSm, L'ie F(Ia)UFa or Elan, Lje T a- This implies that, for each rule Hé—L '1....,L'm, ~L1,..,~Ln in
exp(P) with He F(Ia) either there is a corresponding rule Ht—A1,....Ak in P' (from Steps (iv) and
(v) of Def. 4.3.3) with Aie F(Ia)uF for an iSk or there is no corresponding rule in P' (fi'om the
Steps (i) and (ii) of Def. 4.3.3). Note that, no rule Hr—u is added to P' (from Step (iii) of Def.
4.3.3) because H is false w.r.t. CFM. So, for each rule I-I(—A1,...,Ak in P' with He F(Ia)UF, SiSlc
such that Aie F(Ia)uF. From the definition of leastv(P'), it follows that F(Ia);F. Consequently,
FbgF. So, we proved that ngT and ngFI

We will show that Tch Let a be the first ordinal s.t. there is a literal Ler and
'I’vaa“I(@)(LFl. Then, there is a ruler. L<—A1,...,Ak in P’ with wp.Ta(g)(A,H, ViSk. This
implies that there is a rule in exp(P) whose body literals are true w.r.t. CFM. Since Let T d, it

137
follows that “Le T d or L is unknown w.r.t. CFM. If ~Le T d then from Step (ii) of Def. 4.3.3, Le T
which is a contradiction. If L is unknown w.r.t. CFM then the rule r should not exist in P' because
ofthe Step (iii) of Def. 4.3.4 and the fact that all of the body literals of r are true w.r.t. wptlaw)
and thus w.r.t. CFM. So, Le T d and consequently T QT d-

We will show that Fch Let Fcoh={H| *He T d}. FcohCFd because CFM is a coherent
interpretation. For all rules Hé—Al,...,Ak in P' with He F-Fcoh, there is iSk such that A ,eF. This
implies that for each rule H(—L'l ..... L'm,~L1,...~L,, in exp(P) (L, U; are classical literals) with
He F’Fcoh either (i) BiSm, L'ie F (from Steps (iv) and (v) of Def. 4.3.3) or (ii) 3an, LJe T d (fiom
Step (i) of Def. 4.3.4). Since F(Id) is the maximum set that satisfies the property satisfied by F—
Fcoha F—FcothUd). So, FCFd.

Consequently, RM=Td U~Fd = T U~F=leastv(P/,RM). 0

Proof of Proposition 4.3.5: Let CFM be the contradiction-free model of P. From Proposition

4.3.4, cm is a stable c-model of P. So, it is enough to show that if M is a stable c-model of P
then RMgM=leastv(exp(P)/,M). Let M =TU~F , where T, F are sets of classical literals. Let

Ia= aU'Fa: where T 0, Fa are sets of classical literals and RM = Id. We will show by induction
that Ibg:7U~F, VbSd. It is true that T OCT and Fog]? Suppose that TagT and FagF, Va<b. Ifb is
a limit ordinal then T bcT and Fch since 1b: UUaI a<b}. Assume therefore that b=a+l. It is
true that T1,70(n);rt Assume that r1,70'(c);r, we will show that T1,Ta°r1(c)gr. Let
Le Tlalarlm). Then, 3 rl(-L1 ..... Ln in P s.t. ~L is c-unfounded w.r.t. r and la and ViSn either
(i) L,-e Ia or (ii) L,- is a classical literal and Lie Tlalato). Since IacM, it follows that -'L is c-
unfounded w.r.t. r and M. From the facts that M is an c-model ofP, IacM, ”Talon-.7 and -L is
c-unfounded w.r.t. r and M, it follows that Le T. So, T(Ia)=Tb<;T.

Now, we will show that FbgF. Since F b: “TbUFUaL it is enough to show that "TbgF and
F(Ia)cF. IfLe “Tb then “LeM and from Step (ii) of Def. 4.3.3, Le F. Consequently, “TbgF. For
all rules Ht—L'l,...,L'm,~Ll,..,~Ln in P (L, U; are classical literals) with He F(Ia) either Sign,

'ie F(Ia)UFa or Elan, LJe T a- This implies that, for each rule rHt—L'l,...,L'm’~Ll,..,~L,, in P

138
with He F(Ia) either there is a corresponding rule H<—A1,...,Ak in exp(P)/CM (from Steps (iv) and
(v) of Def. 4.3.3) with A i5 F(Ia)UF for an iSk or there is no corresponding rule in exp(P)/M (from
Steps (i) and (ii) of Def. 4.3.3). Note that, r is not transformed into H<—u in exp(P)/CM in Step (iii)
of Def. 4.3.3 because the facts IagM and leastv(exp(P)/cll4)=M imply that HiSm, L'iE T or EIan,
L193 F. From the definition of least,(exp(P)ch), it follows that Le F. So, F bgF and thus T dgT and

ngF. Consequently, RM=Td U~Fd g: T U~F=M. 0

APPENDIX B

PROPOSITIONAL PROOF THEORY AND PROLOG
META-INTERPRETERS

B.1 Contradiction-Free Semantics
Let P be a propositional PEP and L a literal. CFS_deriv(L,{ }) returns SUCC (resp. FAIL) ifl‘ L is

true (resp. false or unknown) w.r.t. CPS. The routine distance_in_list(L, Literal_list, Distance)
returns SUCC if L is a member of the input Literal_list, i.e., Literal_list =L1,..., Li, L, Li+l,..., L".

The output Distance is ZERO if all literals L,L,-+1 ,...,Ln are default literals or have the form c(K).

CFS_deriv(classical literal L, ancestor list Anc)
{ if L unifies with ~ ~L' or -' "L' or ~ “L' then retum(CFS_deriv(L', {L)UAnc));
if ~Le Anc then return (FAIL); endif
if distance_in_list(L, Anc, Dist)=SUCC then
if Dist= ZERO and L is a default literal then retum(SUCC); else retum(FAIL); endif
endif
if L unifies with ~L' and CFS_deriv('~L', {L}uAnc)=SUCC then retum(SUCC); /“ coherence */
endif
ifL unifies with ~L'then I“ L is a default literal '/
for every rule r: L'(— Body, e exp(P) do
if notGlKe Body,. s.t. CFS_deriv(~K, {L}UAnc)=SUCC) then retum(FAIL); endif

endfor
retum(SUCC);
else l"I L is a classical literal */
flag=RETRY;
for every rule r: L(— Body,. e exp(P) and if flag=RETRY do
flag=SUCC;
for every literal Ke Body,. do
if CFS_deriv(K, {L}UAnc)=F AIL then flag=RETRY; break; endif
endfor
endfor
if flag=SUCC and c-unfounded(-'L, r, {L}UAncFSUCC then retum(SUCC);
else retum(FAIL);
endif

139

140

endif
}

c-unfounded(literal L, rule label r, ancestor list Anc)
/" return SUCC if L is unfounded w.r.t. r and CPS ‘/
{
if L unifies with -'-'L' then retum(c-unfounded(L', r, Anc));
if L unifies with ~L' then retum(c-unfoundedbL', r, Anc));
if distance_in_list(c(L), Anc, Dist)=SUCC then
if Disr—-ZERO then retum(SUCC); else retum(F AIL); endif
endif
for every rule r': L (— Body,.: s.t. r' {r do
if not (3K6 C ,r s.t. c-unfounded(K, r, {c(L)}UAnc)=SUCC or
ElKe Body,.: such that CPS_deriv(~K, {c(L)}uAnc)=SUCC)

then retum(FAIL);
endif
endfor
retum(SUCC);

}

The following Prolog program works as a CPS inference engine for extended programs with

rule prioritization. P is supposed to be already expanded and any rule r of exp(P) is stored as a
prolog fact: rule(r, Head,. <— Body,., C,.). Let G be a sequence of literals. The call

CPS_derive(G,{ }) succeeds (resp. fails) iff L is true (resp. false or unknown) in the CPS of P. If a
literal L succwds (resp. fails) as an intermediate result in the evaluation of CPS_derive(G,{ )) then
this result is stored in the relation result(literal, value) by asserting the fact results(L,succ) (resp.

results(LfaiD).

CF S_derive(true,_):- !.

CFS_derive(~true,_):- !, fail.

CF S_derive(~((GI,GZ)),Anc) :- CFS_derive(~Gl,Anc).

CF S_derive(~((Gl,GZ)),Anc) :- !, CF S_derive(~GZ,Anc).
CFS_derive((Gl,GZ),Anc) :- !, CF S_delive(Gl,Anc), CFS_derive(GZ,Anc).
CFS_derive(~(~G),Anc) :- !, CFS_derive(G,Anc).

CF S_delive(—(—G),Anc) :- !, CF S_derive(G,Anc).

CF S_derive(G,_):- results(G,succ), !.

CF S_derive(G,_) :- results(G,fail), !, fail.

CFS_derive(~G,Anc) :- member(G,Anc), !, fail.

CFS_derive(G,Anc) :- member(~G,Anc), !, fail.

CF S_derive(~G,_) :- results(G,succ), !, fail.

CFS_derive(G,_) :- results(~G,succ), !, fail.

CF S_derive(G,Anc) :- distance_in_list(G,Anc,F,Dist), !, ((Distero, G=(~_))->true).

14]

CF S_derive(~G,Anc) :- CF S_derive(—G,[~G|Anc]), !, assert(results(~G,succ)).
CF S_derive(~G,Anc):- !, findall(Body, rule(_,G<-Body,_), List),
(all_false(List,[~G|Anc])—> assert(results(~G,succ));
assert(results(~G, fail)), !, fail).
CF S_derive(G,Anc) :- ((rule(Label,G<-Body,_), CF S_derive(Body,[G|Anc]),
c_unfounded(-G,Label,[G|Anc]))-> assert(results(G,succ));
assert(results(G,fail)), !, fail).

% all false(List,Anc) succeeds iff all goals in List are false w.r.t. CPS.

all_false([],_):- !.
all_false([GlList],Anc):- CFS_derive(~G,Anc), all_false(LisLAnc).

% c_unfounded(LJabelAnc) succeeds ifl‘ literal L is c-unfounded w.r.t. the rule with label Label
% and the CPS.

c_unfounded($,_,_):- !, fail.

c_unfounded(true,_,_):- !, fail. .

c_unfounded((Gl,GZ),Label,Anc) :- c_unfounded(Gl,Label,Anc).

c_unfounded((Gl,GZ),Label,Anc) :- !, c_unfounded(G2,Label,Anc).

c_unfounded(~G,Label,Anc) :- !, c_unfounded(—G,Label,Anc).

c_unfounded(—(—G),Label,Anc):- !, c_unfounded(G,Label,Anc).

c_unfounded(G,Label,_):- results(~G,succ), !.

c_unfounded(G,Label,_) :- results(G,succ), !, fail.

c_unfounded(G,Label,Anc) :- distance_in_list(u(G),Anc,F,Dist),!,(Dist=zero->true).

c_unfounded(G,Label,Anc) :- findall(r(Labell,G<-Body,C), (rule(Labell,G<-Body,C),
not less _priority(Labell,Label)), List), all_c_unfounded(List,Label,[u(G)|Anc]).

% all_c.unfounded(Rule_list,Label,Anc) succeeds iff for all rules r in Rule_list one of the
% following is true: (i) a literal in the body of r is c-unfounded w.r.t. the rule with label Label and
% the CPS or (ii) a literal in the body of r is false w.r.t. CFS.

all_c_unfounded([],Label,_):- !.
all_c_unfounded([r(_,G<-Body,C)|List],Label,Anc):- all_members(Body,C,Bodyl),
c_unfounded(Bodyl,Label,Anc), all_c_unfounded(LisLIabel,Anc).
all_c_unfounded([r(_,G<-Body,_)|List],Label,Anc):- CF S_derive(~Body,Anc),
all_c_unfounded(LisLLabelAnc).

% distance_in_list(L, Literal_list, Distance) succeeds ifl‘ L is a member of the input Literal_list,
% i.e., Literal_list =L1,..., Li, L, Li+1,..., L". The output Distance is zero ifi‘ all literals

% L,L,-+],...,L,, are default literals or have the form c(K). Otherwise, it is non_zero.

distance_in_list(G,[GlAnc],F,zero) :- var(F),l.
distance_in_list(G,[GlAnc],n_z,non_zero) :- !.
distance_in_list(G,[~_,~X|Anc],F,Dist):- !, distance_in_list(G,[~X|Anc],F,Dist).

142

distance_in_list(G,[~_,X|Anc],_,Dist):- !, distance_in_list(G,[XlAnc],n_z,Dist).
distance_in_list(G,[_,~X|Anc],_,Dist):- !, distance_in_list(G,[~XlAnc],n_z,Dist).
distance_in_list(G,[u(_),u(X)|Anc],F,Dist):- !, distance_in_list(G,[u(X)|Anc],F,Dist).
distance_in_list(G,[u(_),X|Anc],_,Dist):- !, distance_in_list(G,[XlAnc],n_z,Dist).
distance_in_list(G,[__,u(X)|Anc],_,Dist):- !, distance_in_list(G,[u(X)|Anc],n_z,Dist).
distance_in_list(G,L,X|Anc],F,Dist):- !, distance_in_list(G,[XlAnc],F,Dist).

% all_members(G,C,Members) succeeds if Members is a list of literals s.t. if L is the ith literal in
% G and L is in C then L is the ith literal in Members. Otherwise, the ith literal in Members is $.

all_members((Gl,G2),C,Members):- !, all_members(Gl,C,Membersl),
all_members(GZ,C,MembersZ), Members=(Membersl,MembersZ).
all_members(G,C,Members):- member(G,C)-> Members=G; Members=$.

member(X,[XLj) :- !.
member(X,[__|L]) :- member(X,L).

append([].L.L).
append([XILl],L2,[X|L3]):- append(Ll,L2,L3).

B.2 Reliable Semantics

The following Prolog program works as an RS inference engine for extended programs with rule
prioritization. Any rule r in P is stored as a prolog fact: rule(r, Head,. <— Body,., S,.). Let G be a

sequence of literals. The call RS_derive(G,{}) succeeds (resp. fails) ifi‘ L is true (resp. false or
unknown) in the RS of P. If a literal L succeeds as an intermediate result in the evaluation of

CFS_derive(G, { }) then this result is stored in the relation succeeds(literal) by asserting the fact
succeeds(L). To simplify the Prolog program, we assume that S,. =Body,. for every rule r.

RS_derive(true,_):- !.

RS_derive(~true,_):- !, fail.

RS_derive(~((Gl,GZ)),Anc) :- RS_derive(~Gl,Anc).
RS_derive(~((Gl,GZ)),Anc) :- !, RS_derive(~GZ,Anc).
RS_derive((Gl,GZ),Anc) :- l, RS_derive(Gl,Anc), RS_derive(GZ,Anc).
RS_derive(~(~Lit),Anc) :- l, RS_derive(Lit,Anc).
RS_derive(—(—-Lit),Anc) :- l, RS_derive(Lit,Anc).

RS_derive(Lit,_):- succeeds(Lit), !.

RS_derive(~Lit,Anc) :- member(Lit,Anc), !, fail.

RS_derive(Lit,Anc) :- member(~Lit,Anc), !, fail.

RS_derive(~Lit,_) :- succeeds(Lit), !, fail.

RS_derive(Lit,_) :- succeeds(~Lit), l, fail.

RS_derive(Lit,Anc) :- distance_in_list(Lit,Anc,_,Dist),!,((Dist=zero, Lit=(~_))->true).

143

RS_derive(~Lit,Anc) :- literal_unreliable(~Lit,[~LitlAnc]), !, fail.
RS_derive(~Lit,Anc) :- RS_derive(~Lit,[~Lit|Anc]), !, assert(succeeds(~Lit)).
RS_derive(~Lit,Anc):- !, findall(Body, rule(_,Lit<-Body,_),List)
(all_false(List,[~LitlAnc])-> assert(succeeds(~Lit)); fail).
RS_derive(Lit,Anc) :- rule(Rule,Lit<-Body,_), RS_derive(Body,[LitlAnc]),
rule_unreliable(Rule,[LitlAnc])-> fail; assert(succeeds(Lit)).

all_false([],_):- !.
all_false([GlList],Anc):- RS_derive(~G,Anc), all_false(List,Anc).

% literal_unreliable(DefLit,Anc) succeeds iff the default literal DefLit is unreliable w.r.t. RS.

literal_unreliable(Deflit,Anc) :- constraint(<-Body), select_lit(Body,Lit,Rest),
depend(Lit,DefLit,[],Anc),possible(Rest,[],Anc).

% depend(L,DefLit,[],Anc) succeeds iff the literal DefLit is in the dependency set of the literal L
% w.r.t. RS.

depend(true,_,_):- !,fail.

depend((Gl,GZ),Defl.it,LAnc,Anc) :- depend(Gl,Defl..it,LAnc,Anc).

depend((Gl,GZ),Defl.it,LAnc,Anc) :- !, depend(GZ,DefLit,LAnc,Anc).

depend(—(—Lit),Defl.it,LAnc,Anc) :- !, depend(Lit,Defl..it,LAnc,Anc).

depend(DefLit,DefLit,_,_) :- !.

depend(~Lit,Defl.it,LAnc,Anc) :- !, depend(-Lit,DefLit,LAnc,Anc).

depend(Lit,Defl.it,LAnc,_) :- member(d(Lit),LAnc), !, fail.

depend(Lit,Defl.it,LAnc,Anc) :- rule(Rule,Lit<-Body,_),possible(Body,[d(Lit)|LAnc],Anc),
depend(Body,DefLit,[d(Lit)|LAnc],Anc).

% possible(L,LAnc,Anc) succeeds iff the literal L is in the possible set w.r.t. RS.

possible(true,_,_)1- !.
possible(~true,_,_):- !, fail.
possible(~(Gl,GZ),LAnc,Anc) :- possible(~GI,LAnc,Anc).
possible(~(Gl,GZ),LAnc,Anc) :- !, possible(~GZ,LAnc,Anc).
possible((Gl,GZ),LAnc,Anc) :- !, possible(Gl,LAnc,Anc), possible(G2,LAnc,Anc).
possible(~(~Lit),LAnc,Anc) :- !, possible(Lit,LAnc,Anc).
possible(—(-Lit),LAnc,Anc) :- l, possible(Lit,LAnc,Anc).
possible(~Lit,LAnc,Anc) :- possible(~Lit, [p(~Lit)|LAnc],Anc,), !.
possible(Lit,_,_):- succeeds(Lit), !.
possible(~Lit,LAnc,Anc) :- member(p(Lit),LAnc), !, fail.
possible(Lit,LAnc,Anc) :- manber(p(~Lit),LAnc), l, fail.
possible(~Lit,_,_) :- succeeds(Lit), !, fail.
possible(Lit,_,_) :- succeeds(~Lit), !, fail.
possible(Lit,LAnc,Anc) :- distance_in_list(p(Lit),LAnc,_,List), !, ((List=zero, LiF(~_))->true).
possible(~Lit,LAnc,Anc):- !, findall(Body, rule(_,Lit<-Body,_),List),

all _possibly_false(List, [p(~Lit)|LAnc],Anc).
possible(LiLAnc) :- rule(Rule,Lit<-Bod ,_), not RS_derive(—Lit,Anc),

possible(Body,[p(Lit)|LAnc],Anc).

144

all _possibly_false([],_,_):- !.
all _possibly_false([BodylList],LAnc,Anc):- possible(~Body,LAnc,Anc),
all _possibly_false(List,LAnc,Anc).

% rule_unreliable(Rule,Anc) succeeds ifl the rule with label Rule is unreliable w.r.t. RS.

rule_unreliable(Rule,Anc) :- constraint(<-Body), select_lit(Body,Lit,Rest),
r_depend(Lit,Rule,[],Anc),r_possible(Rest,Rule,[],Anc).

% r_depend(L,Rule,LocalAnc,Anc) succeeds iff the head of the rule with label Rule is in
% dependency set of the literal L w.r.t. rule Rule and RS. '

r_depend(true,_,_,_):- !,fail.

r_depend((Gl,GZ),Rule,LAnc,Anc) :- r_depend(Gl,Rule,LAnc,Anc).

r_depend((Gl,GZ),Rule,LAnc,Anc) :- !, r_depend(GZ,Rule,LAnc,Anc).

r_depend(-(-Lit),Rule,LAnc,Anc) :- !, r_depend(Lit,Rule,LAnc,Anc).

r_depend(Lit,Rule,_,_) :- !, rule(Rule,Lit<-Body,_,_).

r_depend(~Lit,Rule,LAnc,Anc) :— !, r_depend(—Lit,Rule,LAnc,Anc).

r_depend(Lit,Rule,LAnc,_) :- member(r_d(Lit,Rule),LAnc) !, fail.

r_depend(Lit,Rule,LAnc,Anc) :- rule(Rulel,Lit<-Body,_), not less _prior(Rulel,Rule),
r _possible(Body,Rule,[r_d(Lit,Rule)|LAnc],Anc),
r_depend(Body,Rule,[r_d(Lit,Rule)|LAnc],Anc).

% r _possible(L,Rule,LocalAnc,Anc) succeeds iff the literal L is in the possible set w.r.t. the rule
% with label Rule and RS.

r _possible(true,_,_):- !.
r _possible((Gl,G2),Rule,LAnc,Anc) :- l, r _possible(Gl,Rule,LAncAnc),
r _possible(GZ,Rule,LAncAnc).
r _possible(-(-Lit),Rule,LAncAnc) :- !, r _possible(Lit,Rule,LAncAnc).
r _possible(~Lit,Rule,LAncAnc) :- !, r _possible(-Lit,Rule,LAncAnc).
r _possible(Lit,Rule,LAncAnc) :- distance_in_list(r_p(Lit,Rule),LAnc,_,_), !, fail.
r _possible(Lit,Rule,LAncAnc) :- rule(Rulel,Lit<-Body,_), not less _prior(Rulel,Rule),
not RS_der(-Lit,Anc),
r _possible(Body,Rule, [r _p(Lit,Rule)|LAnc],Anc).

% select_lit(List, Lit, Rest) selects a literal Lit fi'om the list of literals List. The rest of the
% literals are stored in Rest.

select_lit(Lit,Lit,()) :- Lit \=(Gl,GZ).
select_lit((Lefi,Right),Lit, Rest) :- select_lit(Lefi,Lit,RestLefi), Rest=(RestLefi,Right).
select_lit((Lefi,Right),Lit,Rest) :- select_lit(Right,Lit,RestRight), Rest=(Left,RestRight).

% distance_in_list(L, Literal_list, Distance) succeeds ifi‘ L is a member of the input Literal_list,
% i.e., Litera1_list =Ll,..., Li, L, Li+1,..., In The output Distance is zero ifl‘ all literals

% L,L,-+l,...,Ln are either (i) default literals or (ii) have the form p(K), or (iii) have the form
r _p(K).

% Otherwise, it is non_zero.

145

distance_in_list(Lit,[LitlAnc],F,zero) :- var(F),!.
distance_in_list(Lit,[LitlAnc],n_z,non_zero) :- !.
distance_in_list(Lit,[~__,~X|Anc],F,List):- !, distance_in_list(Lit,[~XlAnc],F,List).
distance_in_list(Lit,[~__,X|Anc],_,List):- !, distance_in_list(Lit,[XlAnc],n_z,List).
distance_in_list(Lit,[_,~X|Anc],_,List):- !, distance_in_list(Lit,[~XlAnc],n_z,List).
distance_in_list(Lit,[p(_),p(X)|Anc],F,List):-!, distance_in_list(Lit,[p(X)|Anc],F,List).
distance_in_list(Lit,[p(_),X|Anc],_,List):- !, distance_in_list(Lit,[XlAnc],n_z,List).
distance_in_list(Lit,[_,p(X)|Anc],_,List):- !, distance_in_list(Lit,[p(X)|Anc],n_z,List).
distance_in_list(Lit,[r_p(_),r_p(X)|Anc],F,List):-!, distance_in_list(Lit,[r_p(X)|Anc],F,List).
distance_in_list(Lit,[r_p(_),X|Anc],_,List):- !, distance_in_list(Lit,[XlAnc],n_z,List).
distance_in_list(Lit,[_,r_p(X)|Anc],_,List):- !, distance_in_list(Lit,[r_p(X)|Anc],n_z,List).
distance_in_list(Lit,[_,X|Anc],F,List):- !, distance_in_list(Lit,[XlAnc],F,List).

member(X,[X|_]) :- !.
member(X,[__|L]) :- member(X,L).

BIBLIOGRAPHY

l1]

[2]

l3]

l4]

[5]

l6]

l7]

[8]

l9]

BIBLIOGRAPHY

S. Abiteboul, G. Lausen, H. Uphofl‘, E. Waller, Methods and Rules, Proc. of the 1993 ACM
SIGMOD Conference on the Management of Data, 1993, pp. 32-41.

H. Ait-Kaci, R. Nasr, Login: a Logic Programming Language with Built-In Inheritance,
Journal of Logic Programming, 3, 1986, pp. 185-215.

A. Analyti, S. Pramanik, Reliable Semantics for Extended Logic Programs with Rule
Prioritization, Proc. of the Workshop on Logic Programming with Incomplete Information, in
conjunction with the lntem. Logic Programming Symposium (ILPS'93), 1993, pp. 142-160.

A. Analyti, S. Pramanik, Semantics for Reasoning with Contradictory Extended Logic
Programs, to appear in the Proc. of the GULP-PRODE‘ 94 Joint Conference on Declarative

Programming, 1994.

A. Analyti, S. Pramanik, Declarative Semantics for Contradictory Modular Logic
Programs, to appear in the Proc. of the 8th International Symposium on Methodologies for
Intelligent Systems (ISMIS'94), 1994.

A. Analyti, S. Pramanik, Reliable Semantics for Extended Logic Programs with Rule
Prioritization, accepted for publication in the Journal of Logic and Computation, Oxford
University Press.

K.R Apt, HA. Blair, A. Walker, Towards a Theory of Declarative Knowledge, J. Minker
(ed), Foundations of Deductive Databases and Logic Programming, Morgan Kaufinann,
1988, pp. 89-148.

P. Atzeni, L.Cabibbo, G.Mecca, ISALOG: A declarative language for complex objects with
hierarchies, Proc. of the 1993 IEEE Conference on Data Engineering, 1993, pp. 219-228.

M. Baldoni, L. Giordano, A. Martelli, A Multimodal Logic to Define Modules in Logic
Programming, Proc. of the 1993 Intern. Logic Programming Symposium (ILPS'93), pp. 473-
487.

[10] C. Baral, S. Kraus, J. Minker, Combining multiple knowledge bases, IEEE Transactions on

Knowledge and Data Engineering, 3(2), June 1991, pp. 200-220.

146

147

[11] S. Brass, U.W. Lipeck, Semantics of Inheritance in Logical Object Specifications, C.
Delobel, M.Kifer, Y. Masunaga (eds.), Proc. of the 2nd Intern. Conference on Deductive and
Object-Oriented Databases, 1991, pp. 411-430.

[12] S. Brass, U.W. Lipeck, Bottom-Up Query Evaluation with Partially Ordered Defaults, Proc.
of the 3rd Intern. Conference on Deductive and Object-Oriented Databases (DOOD'93), 1993,
pp. 253-266.

[13] A. Brogi, E. Lamma, P. Mello, Objects in a Logic Programming Framework, Proc. of the
2nd Russian Conference on Logic Programming, 1991, pp. 102-113.

[14] A. Brogi, P. Mancarella, D. Pedreschi, F. Turini, Meta for Modularising Logic
Programming, Proc. of the 3rd lntem. Workshop on Meta-Programming in Logic (MET A-
92), 1992, pp. 105-119. Extended version in Technical Report, University of Pisa, 1992.

[15] B. Carre, J .M. Geib, The Point of View nation for Multiple Inheritance, Proc. of
ECOOP/OOPSLA'90, 1990, pp. 312-321.

[16] K. L. Clark, Negation as Failure, Logic and Data Bases, Plenum Press, 1978, pp. 293-322.

[ 17 ] de Kleer, An Assumption-Based Truth Maintenance System, Artificial Intelligence, Elsevier
Science Publishers, 28(2), 1986, pp. 127-162.

[18] J. Doyle, A Truth Maintenance System, Artificial Intelligence, Elsevier, 12(3), 1979, pp. 231-
272.

[19] W. Dowling, J . Gallier, Linear-Time Algorithms for Testing the Satisfiability of
Propositional Horn Formulas, Journal of Logic Programming, 3, (1984), pp. 267-284.

[20] RM. Dung, P. Ruarnviboonsuk, Well-Founded Reasoning with Classical Negation, A.
Nerode, W. Marek, V.S. Subrahrnanian (eds), Proc. of the 1st Intern. Workshop on Logic
Programming and Non-monotonic Reasoning, 1991, pp. 120-132.

[21] RM. Dung, An Argumentation Semantics for Logic Programs with Explicit Negation, Proc.
of the 10th lntem. Conference on Logic programming (ICLP'93), 1993, pp. 616-630.

[22] C. Elkan, A Rational Reconstruction on Nonmonotonic Truth Maintenance System, Artificial
Intelligence, Elsevier Science Publishers, 43(2), 1990, pp. 219-234.

[23] M. Fitting, A Kripke-Kleene Semantics for Logic Programs, Journal of Logic Programming,
2(4), 1985, pp. 295-312.

[24] D. Gabbay, E. Laenens, D. Vermeir, Credulous vs. Sceptical Semantics for Ordered Logic
Programs, J. Allen, R Pikes, E. Sandewall (eds.), Proc. of the 2nd Intern. Conference on

Knowledge Representation and Reasoning (KR'91), Morgan Kaufrnann, 1991, pp. 208-217.

148

[25] P. Geerts, D. Vermeir, Credulous and autoepistemic reasoning using ordered logic, A.
Nerode, W. Marek, V.S. Subrahmanian (eds), Proc. of the lst lntem. Workshop on Logic
Programming and Non-monotonic Reasoning, 1991, pp.21-36.

[26] M. Gelfond, V. Lifschitz, The Stable Model Semantics for Logic Programming, R. Kowalski,
K. Bowen (eds), Proc. of the 5th Symposium on Logic Programming, MIT Press, 1988, pp.
1070-1080.

[27] M. Gelfond, V. Lifschitz, Classical Negation in Logic programs and Disjunctive Databases,
New Generation Computing, 9, OHMSHA, 1991, pp. 365-385.

[28] L. Giordano, A. Martelli, General Stable Models, Truth Maintenance and Conflict
Resolution, Proc. of the 7th Intern. Conference on Logic Programming, 1990, pp. 427-441.

[29] L. Giordano, A. Martelli, Truth Maintenance Systems and Belief Revision, Proc. of the
ECA1-90 Workshop on Truth Maintenance Systems, 1990, pp. 71-86. .

[30] L. Giordano, A. Martelli, A Modal Reconstruction of Blacks and Modules in Logic
Programming, Proc. of the 1991 Intern. Logic Programming Symposium (ILPS'91), pp. 239-
253.

[31] M. Goldszmidt, J. Pearl, Rank-based systems: A simple approach to belief revision, belief
update and reasoning about evidence and actions, Proc. of the 3rd Intern. Conference on
Knowledge Representation and Reasoning (KR'92), 1992, pp. 661-672.

[32] A. Heuer, P. Sander, Preserving and Generating Objects in the LIVING INA LATTICE Rule
Language, IEEE Intern. Conference on Data Engineering, 1991, pp. 562-569.

[33] R. Hill, Lush resolution and its completeness, Technical Report DCL Memo 78, Department
of Artificial Intelligence, University of Edinburgh, August 1974.

[34] J. F. Horty, R. H. Thomason, D. S. Touretzky, The Skeptical Theory of Inheritance in
Nonmonotonic Semantics Networks, Journal of Artificial Intelligence, 42, 1990, pp. 311-348.

[35] A. Hunter, A Conceptualization of Preferences in Non-monotonic Proof Theory, D. Pearce
and G. Wagner (eds). Logics in Al, LNCS 633, 1992, pp. 174-188.

[36] M.H. Jamil, L.V.S. Lakshmanan, Realizing Orlog in LDL, I.S. Mumick (ed), Proc. of the
Workshop on Combining Declarative and Object-Oriented Databases (in cooperation with
ACM SIGMOD), May 1993, pp.45-59.

[37] M. Kifer, G. Lausen, F-logic: A higher-order language for reasoning about objects,
inheritance and scheme, J. Clifford, B. Lindsay, D. Maier (eds), Proc. of the 1989 ACM
SIGMOD Intern. Conference on the Management of Data, 1989, pp. 134-146.

[38] M. Kifer, G. Lausen, J. Wu, Logical Foundations of Object-Oriented and Frame-Based
Languages, Technical Report 90/ 14 (2-nd revision), Dept. of Computer Science, SUNY at
Stony Brook, August 1990. (To appear in the Journal of the ACM).

149

[39] R. Reiter, On Closed World Data Bases, Logic and Data Bases, Plenum Press, New York,
1978, pp. 55-76.

[40] RA. Kowalski, D. Kuehner, Linear Resolution with Selection Function, Artificial
Intelligence, 2, 1971, pp. 227-260.

[41] RA. Kowalski, Predicate Logic as a Programming Language, Information Processing,
North Holland, 1974, pp. 569-574.

[42] E. Laenens, D. Vermeir, A Fixpoint Semantics for Ordered Logic, Journal of Logic and
Computation, 1(2), Oxford University Press, 1990, pp. 159-185.

[43] E. Laenens, D. Vermeir, Assumption-flee Semantics for Ordered Logic Programs: On the
Relationship Between Well-founded and Stable Partial Models, Journal of Logic and
Computation, 2(2), Oxford University Press, 1992, pp. 133-172.

[44] E. Lamma, P. Mello, G. Rossi, Parametric Composable Modules in a Logic Programming
Language, Computer Languages, 18(2), Pergamon Press, 1993, pp. 105-123.

[45] J .W. Lloyd, Foundations of Logic Programming, Springer-Verlag, second edition, 1987.

[46] CL. Mason, R.R Johnson, DA TMS: A Framework for Distributed Assumption Based
Reasoning, Distributed Artificial Intelligence, 2, 1989, pp. 293-317.

[47] PG. McCabe, Logic and Objects, Prentice Hall, 1992.

[48] D. Miller, A Logical Analysis of Modules in Logic Programming, Journal of Logic
programming, 6, 1989, pp. 79-108.

[49] L. Monteiro, A. Porto, Contextual Logic Programming, Proc. of the 6th Intern. Conference
on Logic Programming (ICLP' 89), Lisbon, 1989, pp. 284-299.

[50] L. Monteiro, A. Porto, A Language for Contextual Logic Programming, Logic Programming
Languages: Constraints, Functions and Objects, MIT Press, 1993, pp. 115-147.

[51] A.H.H. Ngu, L. Wong, S. Widjojo, On Canonical and Non-canonical Classifications, C.
Delobel, M.Kifer, Y. Masunaga (eds), Proc. of the 2nd Intern. Conference on Deductive and
Object-Oriented Databases (DOOD'91), 1991, pp. 371-390.

[52] L.M. Pereira, J .J . Alferes, J .N. Aparicio, Contradiction Removal within Well Founded
Semantics, A. Nerode, W. Marek, V.S. Subrahmanian (eds), Proc. of the lst Intern.
Workshop on Logic programming and Non-monotonic Reasoning, 1991, pp. 106-119.

[53] L.M. Pereira, J .N. Aparicio, J .J. Alferes, Nonmonotonic Reasoning with Well Founded
Semantics, Proc. of the Intern. Conference on Logic Programming (ICLP',91), 1991, pp. 475-
504.

150

[54] L.M. Pereira, J .J . Alferes, Well Founded Semantics for Logic Programs with Explicit
Negation, B.Neumann (ed.), Proc. of the 10th European Conference on Artificial Intelligence,
John Wiley &Sons, 1992, pp. 102-106. Also, Technical Report, AI Centre, Uninova, March
1992.

[55] L.M. Pereira, JJ. Alferes, J.N. Aparicio, Contradiction Removal with Explicit Negation,
Proc. of the Applied Logic Conference, ILLC, 1992.

[56] L.M. Pereira, J.N. Aparicio, J .J . Alferes, Nonmonotonic Reasoning with Logic
Programming, Journal of Logic Programming, Elsevier Science Publishing, 17, 1993, pp.
227-263.

[57] T.C. Przymusinski, Perfect Model Semantics, Proceedings of the 5th International Conference
and Symposium on Logic Programming, R.A. Kowalski, K.A. Bowen (eds), 1988, pp. 1081-
1096.

[58] T. Przymusinski, Every Logic program has a Natural Stratification and an Iterated Fixed
Point Model, Proc. of the 8th Symposium on Principles of Database Systems, ACM
SIGACT-SIGMOD, 1989, pp. 11-21.

[59] W. Drabent, SIS-resolution without floundering, 2nd Intern. Workshop on Logic
programming and Non-monotonic Reasoning, 1993, pp.82-98. Extended version What is
failure? An approach to constructive negation submitted to Acta Informatica.

[60] T. Przymusinski, Well-Founded Semantics Coincides with the T hree- Valued Stable
Semantics, Fundamenta Informaticae XIII, IOS Press, 1990, pp. 445-463.

[61] H. Przymusinska, T. Przymusinski, Semantics Issues in Deductive Databases and Logic
Programs, R.B. Banerji (ed.), Formal Techniques in Artificial Intelligence, A Sourcebook,
Elsevier, Amsterdam, 1990, pp. 321-367.

[62] T.C. Przymusinski, Semantics of Disjunctive Logic Programs and Deductive Databases, C.
Delobel, M.Kifer, Y. Masunaga (eds), Proc. of the 2nd International Conference on
Deductive and Object-Oriented Databases, Morgan Kaufmann, 1991, pp. 85-107.

[63] R. Reiter, A Logic for Default Reasoning, Artificial Intelligence, Elsevier Science Publishers,
13, 1980, pp. 81-132.

[64] N. Roos, A Logic for Reasoning with Inconsistent Knowledge, Artificial Intelligence, Elsevier
Science Publishers, 57, 1992, pp. 69-103.

[65] M. Ryan, Defaults and Revision in Structured Theories, Proc. of the 6th IEEE Symposium
on Logic in Computer Science (LICS), 1991, pp. 362-373.

[66] M. Ryan, Representing Defaults as Sentences with Reduced Priority, Proc. of the 3rd
International Conference on Knowledge Representation and Reasoning (KR'92), 1992, pp.
649-660.

151

[67] C. Sakarna, Extended Well-Founded Semantics for Paraconsistent Logic Programs, Proc. of
the lntem. Conference on F ifih Generation Computer Systems (FGCS'94), ICOT, 1992, pp.
592-599.

[68] D.T. Sannella, L.A. Wallen, A calculus for the construction of modular Prolog programs
Journal of Logic Programming, 12, 1992, pp. 147-177.

[69] J. S. Schlipf, A Survey of Complexity and Undecidability Results in Logic Programming, H.
Blair, W. Marek, A. Nerode, J. Remmel (eds), Proc. of the Workshop on Structural
Complexity and Recursion-theoretic Methods in Logic Programming, 1992, pp. 143-165.

[70] L. A. Stein, Skeptical Inheritance: Computing the Intersection of Credulous Extensions,
Proc. of the 11th lntem. Joint Conference on Artificial Intelligence, 1989, pp. 1153-1158.

[71] VS. Subrahmanian, Amalgamating Knowledge Bases, to be published in ACM Transactions
on Database Systems (T ODS), 1994.

[7 2] F. Teusink, A Proof Procedure for Extended Logic Programs, Proc. of the 1993 lntem.
Logic Programming Symposium (ILPS'93), pp. 235-249.

[73] D. S. Touretzky, Implicit Ordering of Defaults in Inheritance Systems, International Joint
Conference on Artificial Intelligence (IJCAI-84), 1984, pp. 322-325.

[74] D. S. Touretzky, J. F. Horty, R. H. Thomason, A Clash of Intuitions: The Current State of
Nonmonotonic Multiple Inheritance Systems, International Joint Conference on Artificial
Intelligence (IJCAI-87), 1987, pp. 476-482.

[75] M. van Emden, R. Kowalski, The Semantics of Predicate Logic as a Programming
Language, Journal of the ACM, 23(4), 1976, pp. 733-742.

[76] A. van Gelder, K.A. Ross, J.S. Schlipf, The Well-Founded Semantics for General Logic
Programs, Journal of the Association for Computing Machinery, 38(3), July 1991, pp. 620-
650.

[77] G. Wagner, Reasoning with Inconsistency in Extended Deductive Databases, L.M. Pereira
and A. Nerode (eds), Proc. of the 2nd Intern. Workshop on Logic Programming and Non-
monotonic Reasoning, 1993, pp. 300-315.

[78] C. Witteveen, Skeptical Reason Maintenance is T ractable, Proc. of the 2nd lntem.
Conference on Knowledge Representation and Reasoning (KR91), 1991, pp. 570-581.

[79] C. Witteveen, Expanding Logic Programs, D. Pearce and G. Wagner (eds). Logics in Al,
LNCS 633, 1992, pp. 372-390.

[80] K. Yoshida, C. Smith, T. Kazic, G. Michaels, R. Taylor, D. Zawada, R Hagstrom, R.
Overbeek, Toward a Human Genome Encyclopedia, Proc. of the Intern. Conference on Fifth
Generation Computer Systems, 1992, pp. 307-317.

152

[81] C. Zaniolo, Object Identity and Inheritance in Deductive Databases - an Evolutionary
Approach, W. Kim (ed.), Proc. of the lst Intern. Conference on Deductive and Object-
Oriented Databases, 1989, pp. 106-1 14.

"Iilllllllllllll‘llli