DR-Prolog:A System for Reasoning with Rules and Ontologies on the Semantic Web

Grigoris Antoniou and Antonis Bikakis Computer Science Department, University of Crete, Greece Institute of Computer Science, FORTH, Greece {antoniou,bikakis}@ics.forth.gr

Abstract ñ Efficient reasoning support exists to support rule lan- Defeasible reasoning is a rule-based approach for guages. efficient reasoning with incomplete and inconsis- ñ Rules are well known in practice, and are reasonably tent information. Such reasoning is, among others, well integrated in mainstream information technology. useful for ontology integration, where conflicting information arises naturally; and for the modeling Possible interactions between description logics and monotonic rule systems were studied in [Grosof et al., of business rules and policies, where rules with ex- 2003]. Based on that work and on previous work on hybrid ceptions are often used. This paper describes these scenarios in more detail, and reports on the imple- reasoning [Levy and Rousset, 1998] it appears that the best one can do at present is to take the intersection of the ex- mentation of a system for defeasible reasoning on pressive power of Horn logic and description logics; one the Web. The system (a) is syntactically compatible with RuleML; (b) features strict and defeasible way to view this intersection is the Horn-definable subset of OWL. rules, priorities and two kinds of negation; (c) is This paper is devoted to a different problem, namely con- based on a translation to logic programming with flicts among rules declarative semantics; (d) is flexible and adaptable . Here we just mention the main sources of such conflicts, which are further expanded in section 2. to different intuitions within defeasible reasoning; At the ontology layer: and (e) can reason with rules, RDF, RDF Schema ñ and (parts of) OWL ontologies. Default inheritance within ontologies ñ Ontology merging 1 Introduction And at the logic and reasoning layers: The development of the Semantic Web [Berners Lee et al., ñ Rules with exceptions as a natural representation of 2001] proceeds in layers, each layer being on top of other business rules layers. At present, the highest layer that has reached suffi- ñ Reasoning with incomplete information cient maturity is the ontology layer in the form of the description logic based languages of DAML+OIL [Connolly Defeasible reasoning is a simple rule-based approach to et al., 2001] and OWL [Dean and Schreiber, 2004]. reasoning with incomplete and inconsistent information. It The next step in the development of the Semantic Web can represent facts, rules, and priorities among rules. This will be the logic and proof layers that will offer enhanced reasoning family comprises defeasible logics [Nute, 1994; representation and reasoning capabilities. Rule systems ap- Antoniou et al., 2001] and Courteous Logic Programs [Gro- pear to lie in the mainstream of such activities. Moreover, sof 1999]. The main advantage of this approach is the com- rule systems can also be utilized in ontology languages. So, bination of two desirable features: enhanced representa- in general rule systems can play a twofold role in the Se- tional capabilities allowing one to reason with incomplete mantic Web initiative: (a) they can serve as extensions of, or and contradictory information, coupled with low computa- alternatives to, description logic based ontology languages; tional complexity compared to mainstream nonmonotonic and (b) they can be used to develop declarative systems on reasoning. top (using) ontologies. Reasons why rule systems are ex- In this paper we report on the implementation of a defea- pected to play a key role in the further development of the sible reasoning system for reasoning on the Web. Its main Semantic Web include the following: characteristics are the following: ñ Seen as subsets of predicate logic, monotonic rule sys- ñ Its user interface is compatible with RuleML tems (Horn logic) and description logics are orthogo- [RuleML], the main standardization effort for rules on nal; thus they provide additional expressive power to the Semantic Web. ontology languages. ñ It is based on Prolog. The core of the system consists senting its technical details, we motivate the use of non- of a well-studied translation [Antoniou et. al., 2001] of monotonic rules in more detail. defeasible knowledge into logic programs under Well- Reasoning with Incomplete Information: Antoniou and Founded Semantics [van Gelder et al., 1991]. This de- Arief [2002] describe a scenario where business rules have clarative translation distinguishes our work from other to deal with incomplete information: in the absence of certain information some assumptions have to be made which implementations [Grosof et al., 2002; Maher et al., lead to conclusions not supported by classical predicate 2001]. logic. In many applications on the Web such assumptions ñ The main focus is on flexibility. Strict and defeasible must be made because other players may not be able (e.g. rules and priorities are part of the interface and the im- due to communication problems) or willing (e.g. because of plementation. Also, a number of variants were imple- privacy or security concerns) to provide information. This is mented (ambiguity blocking, ambiguity propagating, the classical case for the use of nonmonotonic knowledge conflicting literals; see below for further details). representation and reasoning [Marek and Truszczynski, 1993]. ñ The system can reason with rules and ontological Rules with Exceptions: Rules with exceptions are a natu- knowledge written in RDF Schema (RDFS) or OWL. ral representation for policies and business rules [Antoniou The latter happens through the transformation of the et. al, 1999]. And priority information is often implicitly or RDFS constructs and many OWL constructs into rules. explicitly available to resolve conflicts among rules. Poten- Note, however, that a number of OWL constructs can- tial applications include security policies [Ashri et al., 2004; not be captured by the expressive power of rule lan- Li et al., 2003], business rules [Antoniou and Arief 2002], guages. personalization, brokering, bargaining, and automated agent negotiations [Governatori et al., 2001]. As a result of the above, DR-Prolog is a powerful de- Default Inheritance in Ontologies: Default inheritance is clarative system supporting a well-known feature of certain knowledge representation ñ rules, facts and ontologies formalisms. Thus it may play a role in ontology languages, ñ all major Semantic Web standards: RDF, RDFS, which currently do not support this feature. Grosof and OWL, RuleML Poon [2003] present some ideas for possible uses of default inheritance in ontologies. A natural way of representing ñ monotonic and nonmonotonic rules, open and closed default inheritance is rules with exceptions, plus priority world assumption, reasoning with inconsistencies. information. Thus, nonmonotonic rule systems can be util- The paper is organized as follows. Section 2 describes the ized in ontology languages. main motivations for conflicting rules on the Semantic Web. Ontology Merging: When ontologies from different au- Section 3 describes the basic ideas of defeasible reasoning. thors and/or sources are merged, contradictions arise natu- Sections 4 describes the translation of defeasible logic, and rally. Predicate logic based formalisms, including all current of RDF, RDFS and (parts of) OWL into logic programs. Semantic Web languages, cannot cope with inconsistencies. Section 5 reports on the implemented system. Section 6 dis- If rule-based ontology languages are used and if rules are cusses related work, and section 7 concludes with a sum- interpreted as defeasible (that is, they may be prevented mary and some ideas for future work. from being applied even if they can fire) then we arrive at nonmonotonic rule systems. A skeptical approach, as adopted by defeasible reasoning, is sensible because it does 2 Motivation for Nonmonotonic Rules on the not allow for contradictory conclusions to be drawn. More- Semantic Web over, priorities may be used to resolve some conflicts We believe that we have to distinguish between two types of among rules, based on knowledge about the reliability of knowledge on the Semantic Web. One is static knowledge, sources or on user input. Thus, nonmonotonic rule systems such as factual and ontological knowledge which contains can support ontology integration. general truths that do not change often. And the other is dynamic knowledge, such as business rules, security poli- 3 Defeasible Logics cies etc. that change often according to business and strate- gic needs. The first type of knowledge requires monotonic 3.1 Basic Characteristics reasoning based on an open world assumption to guarantee correct propagation of truths. But for dynamic knowledge The root of defeasible logics lies on research in knowledge flexible, context-dependent and inconsistency tolerant non- representation, and in particular on inheritance networks. monotonic reasoning is more appropriate for drawing prac- Defeasible logics can be seen as inheritance networks ex- tical conclusions. pressed in a logical rules language. In fact, they are the first Obviously, a combination of both types of knowledge is nonmonotonic reasoning approach designed from its begin- required for practical systems. Defeasible logic, as described ning to be implementable. in section 3, supports both kinds of knowledge. Before pre- Being nonmonotonic, defeasible logics deal with poten- tial conflicts (inconsistencies) among knowledge items. Thus they contain classical negation, contrary to usual logic 3.2 Syntax programming systems. They can also deal with negation as A defeasible theory D is a couple (F,R,>) where F is a finite failure (NAF), the other type of negation typical of non- set of facts, R a finite set of rules, and > a superiority rela- monotonic logic programming systems; in fact, Wagner tion on R. In expressing the proof theory we consider only [2003] argues that the Semantic Web requires both types of propositional rules. Rules containing free variables are in- negation. In defeasible logics, often it is assumed that NAF terpreted as the set of their variable-free instances. is not included in the object language. However, as Anto- There are two kinds of rules (fuller versions of defeasible niou et al. [2000a] show, it can be easily simulated when logics include also defeaters): Strict rules are denoted by A necessary. Thus, we may use NAF in the object language ç p, and are interpreted in the classical sense: whenever the and transform the original knowledge to logical rules with- premises are indisputable then so is the conclusion. An ex- out NAF exhibiting the same behavior. ample of a strict rule is “Professors are faculty members”. Conflicts among rules are indicated by a conflict between Written formally: professor(X) ç faculty(X). Inference from their conclusions. These conflicts are of local nature. The strict rules only is called definite inference. Strict rules are simpler case is that one conclusion is the negation of the intended to define relationships that are definitional in na- other. The more complex case arises when the conclusions ture, for example ontological knowledge. Ω have been declared to be mutually exclusive, a very useful Defeasible rules are denoted by A p, and can be de- representation feature in practical applications. feated by contrary evidence. An example of such a rule is Ω Defeasible logics are skeptical in the sense that conflict- faculty(X) tenured(X) which reads as follows: “Profes- ing rules do not fire. Thus consistency of drawn conclusions sors are typically tenured”. is preserved. A superiority relation on R is an acyclic relation > on R (that is, the transitive closure of > is irreflexive). When r > Priorities on rules may be used to resolve some conflicts 1 r , then r is called superior to r , and r inferior to r . This among rules. Priority information is often found in practice, 2 1 2 2 1 expresses that r may override r . For example, given the and constitutes another representational feature of defeasible 1 2 defeasible rules logics. r: professor(X) Ω tenured(X) The logics take a pragmatic view and have low computa- r’: visiting(X) Ω ¬tenured(X) tional complexity. This is, among others, achieved through which contradict one another: no conclusive decision can be the absence of disjunction and the local nature of priorities: made about whether a visiting professor is tenured. But if only priorities between conflicting rules are used, as op- we introduce a superiority relation > with r’ > r, then we posed to systems of formal argumentation where often more can indeed conclude that a visiting professor cannot be ten- complex kinds of priorities (e.g. comparing the strength of ured. reasoning chains) are incorporated. A formal definition of the proof theory is found in [Anto- Generally speaking, defeasible logics are closely related niou et al., 2001]. to Courteous Logic Programs [Grosof, 1997]; the latter were developed much later than defeasible logics. DLs have the 3.3 Simulation of Negation As Failure in the Ob- following advantages: ject Language ñ They have more general semantic capabilities, e.g. in We follow a technique based on auxiliary predicates first terms of loops, ambiguity propagation etc. presented in [Antoniou et al., 2000a], but which is often used in logic programming. According to this technique, a ñ They have been studied much more deeply, with defeasible theory with NAF can be modularly transformed strong results in terms of proof theory [Antoniou et al., into an equivalent one without NAF. Every rule 2001], semantics [Maher, 2002] and computational r: L1,…,Ln, ¬M1,…, ¬Mk Ω L complexity [Maher, 2001]. As a consequence, its can be replaced by the rules: translation into logic programs, a cornerstone of DR- r: L1,…,Ln, neg(M1),…,neg(Mk) Ω L Prolog, has also been studied thoroughly [Maher et al., Ω neg(M1) 2001; Antoniou and Maher, 2002]. … Ω However, Courteous Logic Programs have also had some neg(Mk) Ω advantages: M1 ¬neg(M1) … ñ They were the first to adopt the idea of mutually ex- Mk Ω ¬neg(Mk) clusive literals, an idea incorporated in DR-Prolog. where neg(M1),…,neg(Mk) are new auxiliary atoms. If we ñ They allow access to procedural attachments, some- restrict attention to the original language, the set of conclu- thing we have chosen not to follow in our work so far. sions remains the same. In the following we discuss in more detail some of the ideas and concepts mentioned here. Ω Ω 3.4 Ambiguity Blocking and Ambiguity Propagat- ri: q1,q2,…,qn ¬M for all rules ri: q1,q2,…,qn L ing Behavior The superiority relation among the rules of the defeasible theory is propagated to the “new” rules. A literal is ambiguous if there is a chain of reasoning that supports a conclusion that p is true, another that supports that ¬p is true, and the superiority relation does not resolve 4 Translation into Logic Programs this conflict. We can illustrate the concept of ambiguity propagation through the following example. 4.1 Translation of Defeasible Theories Ω r1: quaker(X) pacifist(X) The translation of a defeasible theory D into a logic program Ω r2: republican(X) ¬pacifist(X) P(D) has a certain goal: to show that Ω r3: pacifist(X) ¬hasGun(X) p is defeasibly provable in D ˜ Ω r4: livesInChicago(X) hasGun(X) p is included in the Well-Founded Model of P(D) quaker(a) Two different translations have so far been proposed, republican(a) sharing the same basic structure: livesInChicago(a) ñ The translation of [Antoniou et al., 2000b; Maher et r3 > r4 al., 2001] where a meta-program was used. Here pacifist(a) is ambiguous. The question is whether this ambiguity should be propagated to the dependent literal ñ The translation of [Antoniou and Maher, 2002], which hasGun(a). In one defeasible logic variant it is detected that makes use of control literals. rule r3 cannot fire, so rule r4 is unopposed and gives the It is an open question which is better in terms of compu- defeasible conclusion hasGun(a). This behavior is called tational efficiency, although we conjecture that for large ambiguity blocking, since the ambiguity of pacifist(a) has theories the meta-program approach is better, since in the been used to block r3 and resulted in the unambiguous con- other approach a large number of concrete program clauses clusion hasGun(a). is generated. Therefore, we have adopted this approach in On the other hand, in the ambiguity propagation variant, our implementation. although rule r3 cannot lead to the conclusion hasGun(a) (as pacifist(a) is not provable), it opposes rule r4 and the con- Translation of Ambiguity Blocking Behavior clusion hasGun(a) cannot also be drawn. The metaprogram which corresponds to the ambiguity This question has been extensively studied in artificial in- blocking behavior of the defeasible theories consists of the telligence, and in particular in the theory of inheritance net- following program clauses: works. A preference for ambiguity blocking or ambiguity The first three clauses define the class of rules used in a propagating behavior is one of the properties of non- defeasible theory. monotonic inheritance nets over which intuitions can clash. supportive_rule(Name,Head,Body):- Ambiguity propagation results in fewer conclusions being strict(Name,Head,Body). drawn, which might make it preferable when the cost of an supportive_rule(Name,Head,Body):- incorrect conclusion is high. For these reasons an ambiguity defeasible(Name,Head,Body). propagating variant of DL is of interest. rule(Name,Head,Body):- supportive_rule (Name,Head,Body). 3.4 Conflicting Literals The following clauses define the definite provability: a Usually in Defeasible Logics only conflicts among rules literal is definitely provable if it is a fact or is supported by a with complementary heads are detected and used; all rules strict rule, the premises of which are definitely provable. with head L are considered as supportive of L, and all rules definitely(X):- fact(X). with head ¬L as conflicting. However, in applications often definitely(X):- strict(R,X,L), definitely_provable(L). literals are considered to be conflicting, and at most one of a definitely_provable([]). certain set should be derived. For example, the risk an in- definitely_provable(X):- definitely(X). vestor is willing to accept may be classified in one of the definitely_provable([X1|X2]):- definitely_provable(X1), categories low, medium, and high. The way to solve this definitely_provable(X2). problem is to use a constraint rule of the form The next clauses define the defeasible provability: a lit- conflict :: low, medium, high eral is defeasibly provable, either if it is definitely provable, Now if we try to derive the conclusion high, the conflict- or if its complemetary is not definitely provable, and it is ing rules are not just those with head ¬high, but also those supported by a defeasible rule, the premises of which are with head low and medium. Similarly, if we are trying to defeasibly provable, and which is not overruled. prove ¬high, the supportive rules include those with head defeasibly(X):- definitely(X). low or medium. defeasibly(X):- negation(X,X1), supportive_rule(R,X,L), In general, given a conflict :: L, M, we augment the de- defeasibly_provable(L), sk_not(definitely(X1)), feasible theory by: sk_not(overruled(R,X)). r : q ,q ,…,q ç ¬L for all rules r : q ,q ,…,q ç M defeasibly_provable([]). i 1 2 n i 1 2 n defeasibly_provable(X):- defeasibly(X). ri: q1,q2,…,qn ç ¬M for all rules ri: q1,q2,…,qn ç L ri: q1,q2,…,qn Ω ¬L for all rules ri: q1,q2,…,qnΩ M defeasibly_provable([X1|X2]):- defeasibly_provable(X1), In addition, for processing RDF Schema information, the defeasibly_provable(X2). following rules capturing the semantics of RDF Schema The next clause defines that a rule is overruled when constructs are created: there is a conflicting rule, the premises of which are defea- a: C(X):- rdf:type(X,C). sible provable, and which is not defeated. b: C(X):- rdfs:subClassOf(Sc,C),Sc(X). overruled(R,X):- negation(X,X1), c: P(X,Y):- rdfs:subPropertyOf(Sp,P),Sp(X,Y). supportive_rule(S,X1,U), defeasibly_provable(U), d: D(X):- rdfs:domain(P,D),P(X,Z). sk_not(defeated(S,X1)). e: R(Z):- rdfs:range(P,R),P(X,Z). The next clause defines that a rule is defeated when there Parts of OWL ontologies can also be translated using is a superior conflict rule, the premises of which are defea- logical rules, which capture the semantics of some of the sibly provable. The last two clauses are used to define the OWL constructs. For example the following rules are used negation of a literal. to capture the semantics of transitive, symmetric and inverse defeated(S,X):- sup(T,S), negation(X,X1), properties respectively. supportive_rule(T,X1,V), defeasibly_provable(V). o1: P(X,Z):- P(X,Y), P(Y,Z), negation(~(X),X):- !. rdf:type(P,owl:TransitiveProperty). negation(X,~(X)). o2: P(X,Y):- P(Y,X), rdf:type(P,owl:SymmetricProperty). For a defeasible theory D = (F,R,>), where F is the set of o3: P(X,Y):- Q(Y,X),owl:Inverseof(P,Q). the facts, R is the set of the rules, and > is the set of the su- o4: Q(X,Y):- P(Y,X),owl:Inverseof(P,Q). periority relations between the rules of the theory, we add Other OWL constructs which are also supported by our sys- facts according to the following guidelines: tem are: owl:equivalentClass, owl:equivalentProperty, fact(p). for each p≠F owl:sameIndividualAs, owl:sameAs, property restrictions strict(ri,p,[q1,…,qn]). for each rule r: q1,q2,…,qn p ≠R (owl:allValuesFrom, owl:hasValue), owl collections etc. defeasible(ri,p,[q1,…,qn]). for each r: q1,q2,…,qn Ј p ≠R All the above rules are created at compile-time, i.e. before sup(r,s). for each pair of rules such that r>s the actual querying takes place. Therefore, although at first they seem second-order, because they contain variables in Translation of Ambiguity Propagating Behavior place of predicate names, they are actually first-order rules, In order to support the ambiguity propagation behavior of a i.e. predicate names are constant at run-time. defeasible theory, we only have to modify the program clauses which define when a rule is overruled. In particular, in this variant a rule is overruled when there is a conflicting 5 Implementation rule, the premises of which are supported, and which is not DR-Prolog, in accordance with the general philosophy of defeated. logic programming, is designed to answer queries. In fact, overruled(R,X):- negation(X,X1), there are two kinds of queries, depending on which strength supportive_rule(S,X1,U), supported_list(U), of proof we are interested in: definite or defeasible provabil- sk_not(defeated(S,X1)). ity. The next clauses define that a literal is supported, either if it is definitely provable, or if there is a supportive rule, the premises of which are supported, and which is not defeated. supported(X):- definitely(X). supported(X):- supportive_rule(R,X,L), supported_list(L), sk_not(defeated(R,X)). supported_list([]). supported_list(X):- supported(X). supported_list([X1|X2]):- supported_list(X1), supported_list(X2). 4.2 Translation of RDF(S) and parts of OWL ontologies In order to support reasoning with RDF/S and OWL ontologies, we translate RDF data into logical facts, and RDFS and OWL statements into logical facts and rules. For RDF data, the SWI-Prolog RDF parser [SWI] is used to transform it into an intermediate format, representing triples as rdf(Subject, Predicate, Object). Some additional processing (i) transforms the facts further into the format Figure 1: The overall architecture of DR-Prolog Predicate(Subject, Object); (ii) cuts the namespaces and the In Figure 1 we present the overall architecture of our sys- “comment” elements of the RDF files, except for resources tem. The system works in the following way: The user im- which refer to the RDF or OWL Schema, for which name- ports defeasible theories, either using the syntax of defeasi- space information is retained. ble logic, or in the RuleML syntax, that we describe below. The former theories are checked by the DL Parser, and if defeasible logic; so, it does support ambiguity propagation, they are syntactically correct, they are passed to the Logic nor conflicting literals and variables. Also, it does integrate Translator, which translates them into logic programs. The with other Semantic Web languages and systems, and is RuleML defeasible theories are checked by the RuleML thus an isolated solution. Parser and translated into defeasible theories, which are also DR-DEVICE [Bassiliades, 2004] is another effort on im- passed to the Logic Translator and transformed into logic plementing defeasible reasoning, albeit with a different ap- programs. The Reasoning Engine compiles the logic pro- proach. DR-DEVICE is implemented in Jess, and integrates grams and the metaprogram which corresponds to the user’s well with RuleML and RDF. It is a system for query an- choice of the defeasible theory variants (ambiguity blocking swering. Compared to the work of this paper, DR-DEVICE / propagating), and evalutes the answers to the user’s que- supports only one variant, ambiguity blocking, thus it does ries. The logic programming system that we use as the Rea- not offer the flexibility of this implementation. At present, it soning Engine is XSB. The advantages of this system are does not support RDFS and OWL ontologies. basically two: (a) it supports the well-founded semantics of SweetJess [Grosof et al., 2002] is another implementation logic programs through the use of tabled predicates, and its of a defeasible reasoning system (situated courteous logic sk_not negation operator; and (b) it offers an easy and effi- programs) based on Jess. It integrates well with RuleML. cient way to communicate with the other parts of the sys- Also, it allows for procedural attachments, a feature not tem.The RDF&OWL Translator is used to translate the supported by any of the above implementations, not by the RDF/S and OWL information into logical facts and rules, system of this paper. However, SweetJess is more limited in which can be processed by the rules, provided by the user. flexibility, in that it implements only one reasoning variant The DTD that we have developed to represent defeasible (it corresponds to ambiguity blocking defeasible logic). theories in XML format, is in fact an extension of the Moreover, it imposes a number of restrictions on the pro- RuleML DTDs [RuleML]. The elements that we add / mod- grams it can map on Jess. In comparison, our system im- ify to support the defeasible theories are: plements the full version of defeasible logic. ñ The “rulebase” root element which uses strict and defeasible rules, fact assertions and superiority relations. 7 Conclusion ñ The “imp” and “def” elements, which consist of a In this paper we described reasons why conflicts among “_head” and a “_body” element, accept a “name” at- rules arise naturally on the Semantic Web. To address this tribute, and refer to the strict and defeasible rules. problem, we proposed to use defeasible reasoning which is known from the area of knowledge representation. And we ñ The “superiority” empty element, which accepts the reported on the implementation of a system for defeasible name of two rules as its attributes (“sup” & “inf”), and reasoning on the Web. It is Prolog-based, supports RuleML refers to the superity relation between these two rules. syntax, and can reason with monotonic and nonmonotonic rules, RDF facts and RDFS and OWL ontologies.. 6 Related Work Planned future work includes: ñ Adding arithmetic capabilities to the rule language, There exist several previous implementations of defeasible and using appropriate constraint solvers in conjunction logics. Conington et al. [2002] give the historically first implementation, D-Prolog, a Prolog-based implementation. with logic programs. It was not declarative in certain aspects (because it did not ñ Implementing load/upload functionality in conjunction use a declarative semantic for the not operator), therefore it with an RDF repository, such as RDF Suite [Alexaki et did not correspond fully to the abstract definition of the al., 2001] and Sesame [Broekstra et al., 2003]. logic. Also, D-Prolog supported only one variation thus it ñ lacked the flexibility of the implementation we report on. Applications of defeasible reasoning and the devel- Finally it did not provide any means of integration with Se- oped implementation for brokering, bargaining, auto- mantic Web layers and concepts, a central objective of our mated agent negotiation, and security policies. work. Deimos [Maher et al., 2001] is a flexible, query process- References ing system based on Haskell. It implements several variants, but not conflicting literals. Also, it does not integrate with [Alexaki et al., 2001] S. Alexaki, V. Christophides, G. Semantic Web (for example, there is no way to treat RDF Karvounarakis, D. Plexousakis and K. Tolle (2001). The data and RDFS/OWL ontologies; nor does it use an XML- ICS-FORTH RDFSuite: Managing Voluminous RDF based or RDF-based syntax for syntactic interoperability). Description Bases. In Proc. 2nd International Workshop Thus it is an isolated solution. Finally, it is propositional and on the Semantic Web, Hongkong, May 1, 2001. does not support variables. [Antoniou and Arief, 2002] G. Antoniou and M. Arief Delores [Maher et al., 2001] is another implementation, (2002). Executable Declarative Business rules and their which computes all conclusions from a defeasible theory. It use in Electronic Commerce. In Proc. ACM Symposium is very efficient, exhibiting linear computational complex- on Applied Computing ity. Delores only supports ambiguity blocking propositional [Antoniou et al., 1999] G. Antoniou, D. Billington and M.J. [Grosof, 1997] B. N. Grosof (1997). Prioritized conflict Maher (1999). On the analysis of regulations using de- handing for logic programs. In Proc. of the 1997 Inter- feasible rules. In Proc. 32nd Hawaii International Con- national Symposium on Logic Programming, 197-211 ference on Systems Science [Grosof et al., 2002] B. N. Grosof, M. D. Gandhe and T. W. [Antoniou et al., 2001] G. Antoniou, D. Billington, G. Gov- Finin: SweetJess: Translating DAMLRuleML to JESS. ernatori and M.J. Maher (2001). Representation results RuleML 2002. In: Proc. International Workshop on Rule for defeasible logic. ACM Transactions on Computa- Markup Languages for Business Rules on the Semantic tional Logic 2, 2 (2001): 255 - 287 Web [Antoniou et al., 2000a] G. Antoniou, M. J. Maher and D. [Grosof et al., 2003] B. N. Grosof, I. Horrocks, R. Volz and Billington (2000). Defeasible Logic versus Logic Pro- S. Decker (2003). Description Logic Programs: Combin- gramming without Negation as Failure. Journal of Logic ing Logic Programs with Description Logic". In: Proc. Programming 41,1 (2000): 45-57 12th Intl. Conf. on the World Wide Web (WWW-2003), [Antoniou et al., 2000b] G. Antoniou, D. Billington, G. ACM Press Governatori, M. J. Maher: A Flexible Framework for [Grosof and Poon, 2003] B. N. Grosof and T. C. Poon Defeasible Logics. In Proc. AAAI’ 2000, 405-410 (2003). SweetDeal: representing agent contracts with ex- [Antoniou and Maher, 2002] G. Antoniou, M.J. Maher ceptions using XML rules, ontologies, and process de- (2002). Embedding Defeasible Logic into Logic Pro- scriptions. In Proc. 12th International Conference on grams. In Proc. ICLP 2002, 393-404 World Wide Web. ACM Press, 340 – 349 [Ashri et al., 2004] R. Ashri, T. Payne, D. Marvin, M. Sur- [Levy and Rousset, 1998] A. Levy and M.-C. Rousset ridge and S. Taylor (2004). Towards a Semantic Web (1998). Combining Horn rules and description logics in Security Infrastructure. In Proc. of Semantic Web Ser- CARIN. Artificial Intelligence 104, 1-2 (1998):165 - vices 2004 Spring Symposium Series, Stanford Univer- 209 sity, California [Li et al., 2003] N. Li, B. N. Grosof and J. Feigenbaum [Bassiliades et al., 2004] N. Bassiliades, G. Antoniou and I. (2003). Delegation Logic: A Logic-based Approach to Vlahavas (2004). DR-DEVICE: A Defeasible Logic Sys- Distributed Authorization. In: ACM Transactions on In- tem for the Semantic Web. In Proc. 2nd Workshop on formation Systems Security 6,1 (2003) Principles and Practice of Semantic Web Reasoning [Maher, 2002] M. J. Maher: A Model-Theoretic Semantics (PPSWR04), LNCS, Springer 2004 (accepted) for Defeasible Logic. In Proc. Paraconsistent Computa- [Berners-Lee et al., 2001]T. Berners-Lee, J. Hendler, and O. tional Logic 2002, Datalogisker Srkifter 95 ,67-80 Lassila (2001). The Semantic Web. Scientific American, [Maher, 2001] M. J. Maher: Propositional Defeasible Logic 284, 5 (2001): 34-43 has Linear Complexity. Logic Programming Theory and [Broekstra et al., 2003] J. Broekstra, A. Kampman and F. Practice 1(6): 691-711 (2001) van Harmelen (2003) Sesame: An Architecture for [Maher et al., 2001]M. J. Maher, A. Rock, G. Antoniou, D. Storin gand Querying RDF Data and Schema Informa- Billington and T. Miller (2001). Efficient Defeasible tion. In: D. Fensel, J. A. Hendler, H. Lieberman and W. Reasoning Systems. International Journal of Tools with Wahlster (Eds.), Spinning the Semantic Web, MIT Press, Artificial Intelligence 10,4 (2001): 483--501 197-222 [Marek and Truszczynski, 1993] V.W. Marek and M. [Connolly et al., 2001] D. Connolly, F. van Harmelen, I. Truszczynski (1993). Nonmonotonic Logics; Context Horrocks, D. L. McGuinness, P. F. Patel-Schneider and Dependent Reasoning. Springer Verlag L. A. Stein (2001). DAML+OIL Reference Description. [Nute, 1994] D. Nute (1994). Defeasible logic. In Handbook www.w3.org/TR/daml+oil-reference of logic in artificial intelligence and logic programming [Conington et al., 1997] M. A. Covington, D. Nute and A. (vol. 3): nonmonotonic reasoning and uncertain reason- Vellino (1997). Prolog Programming in Depth, 2nd ed. ing. Oxford University Press Prentice-Hall [RuleML] RuleML. The Rule Markup Language Initiative. [Dean and Schreiber, 2004] M. Dean and G. Schreiber www.ruleml.org (Eds.) (2004). OWL Web Ontology Language Reference. [SWI] SWI-Prolog, http://www.swi-prolog.org www.w3.org/TR/2004/REC-owl-ref-20040210/ [Wagner, 2003] G. Wagner: Web Rules Need Two Kinds of [van Gelder et al., 1991] A. van Gelder, K. Ross and J. Negation. In Proc. First Workshop on Semantic Web Schlipf (1991). The well-founded semantics for general Reasoning, LNCS 2901, Springer 2003, 33-50 logic programs. Journal of the ACM 38 (1991): 620— 650 [XSB] XSB, Logic Programming and Deductive Database System for Unix and Windows. [Governatori et al., 2001] G. Governatori, M. Dumas, A. ter http://xsb.sourceforge.net Hofstede and P. Oaks (2001). A formal approach to legal negotiation. In Proc. ICAIL 2001, 168-177