FIRE A DESCRIPTION LOGIC BASED RULE ENGINE FOR OWL ONTOLOGIES WITH SWRL-LIKE RULES

Transcription

1 FIRE A DESCRIPTION LOGIC BASED RULE ENGINE FOR OWL ONTOLOGIES WITH SWRL-LIKE RULES KRUTHI BHOOPALAM A THESIS IN THE DEPARTMENT OF COMPUTER SCIENCE AND SOFTWARE ENGINEERING PRESENTED IN PARTIAL FULFILLMENT OF THE REQUIREMENTS FOR THE DEGREE OF MASTER OF COMPUTER SCIENCE CONCORDIA UNIVERSITY MONTRÉAL, QUÉBEC, CANADA SEPTEMBER 2005 c KRUTHI BHOOPALAM, 2005

2 CONCORDIA UNIVERSITY School of Graduate Studies This is to certify that the thesis prepared By: Kruthi Bhoopalam Entitled: Fire A Description Logic Based Rule Engine for OWL Ontologies with SWRL-like Rules and submitted in partial fulfillment of the requirements for the degree of Master of Computer Science complies with the regulations of this University and meets the accepted standards with respect to originality and quality. Signed by the final examining commitee: Dr. Hon Fung Li Dr. Shiri V. Nematollaah Dr. Sabine Bergler Dr. Volker Haarslev Chair Examiner Examiner Supervisor Approved Chair of Department or Graduate Program Director 20 Dr. Nabil Esmail, Dean Faculty of Engineering and Computer Science

3 Abstract Fire A Description Logic Based Rule Engine for OWL Ontologies with SWRL-like Rules Kruthi Bhoopalam The present decade has seen significant progress towards realizing the vision of the Semantic Web. This progress has most often been seen in the levels of maturity reached by each layer in the architectural layers representing the Semantic Web vision. The ontology layer reached a substantial level of maturity with the OWL Web Ontology Language (OWL) being recommended by the World Wide Web Consortium (W3C) as the standard for representing ontologies on the Web. This move has triggered several other standardizations and led to interesting research results that have further strengthened the ontology layer. This has motivated the Semantic Web community to venture further towards the rules layer in the vision. One of the interesting lines of research in this context is to extend OWL with rules both syntactically and semantically and providing a sound, complete and terminating reasoning support for the extension. Our present work corresponds to this line of research. We investigate the problem of providing a description logic (DL) based rule reasoning support for OWL ontologies extended with rules. Guided by the Semantic Web Rule Language (SWRL) extension to OWL, we recognize a rule language called the SWRL-like rule language as a rule-extension to OWL. The SWRL-like rule language has a similar syntax as SWRL but differs in its semantics. We propose the system Fire, a rule reasoning engine for the extension of OWL ontologies with SWRL-like rules. The reasoning procedure proposed for the Fire system follows active domain semantics to ensure termination. The reasoning procedure is conjectured to be sound and complete based on the approach followed in the CARIN system. Contrary to several existing translation-based approaches for reasoning with OWL ontologies combined with rules, our proposal provides direct DL based rule inferencing that is synchronous with the OWL inferencing. This synchronous integration with a DL reasoner offers immediate feedback about rule consequences in the OWL knowledge base (KB). The proposal is supported with a prototype Java implementation iii

4 of the Fire system. The prototype implements the RETE algorithm for pattern matching. Our experiments with the pattern matcher algorithm indicate higher efficiency and speed of the implemented RETE algorithm in matching DL facts with SWRL-like rule patterns, compared to a naïve approach to pattern-matching. The implemented prototype is sound based on the sound and complete reasoning of the DL reasoner RACER. Termination is ensured by the active domain semantics. The prototype does not guarantee completeness of reasoning due to the unavailability of an important OWL reasoning service from any of the existing DL reasoners. iv

5 Acknowledgments Maathru devo bhava. (Respect thy mother like God) Pithru devo bhava. (Respect thy father like God) Aachaarya devo bhava. (Respect thy teacher like God) I dedicate this work to my parents and my supervisor. My profound thanks to my supervisor Dr.Volker Haarslev for his guidance, help and constant encouragement. In the past two years, his direction and support at every step of my work have helped me a lot in my learning. My mother Sumitra, my father Krishnamurthy, and my younger brother Rahul have always been a tremendous source of motivation, strength, and encouragement for my education. My gratitude to my family is immense. My heartfelt thanks to my colleagues and friends for their support and encouragement academically or otherwise. In particular, Xi Deng - for assisting me with all my doubts with a smile, Hemanth - for always being there and encouraging me, Sabeel - for answering my every small question without getting bored, Anup - for teaching me a lot, Israat - for all the discussions and help, Ram - for the ever-cheerful support, Tejas - for being so good, Gurudath - for being ever-entertaining despite his mood, Uma - for being so caring and Vasavi - for all the care and support. A special thanks to my close friends for those neverending jokes which always refreshed my mind. Montreal has been home because of them. v

6 Contents List of Figures List of Tables ix x 1 Introduction Progress Towards the Semantic Web Vision From Ontology to DL Based Rules The OWL Web Ontology Language The Semantic Web Rule Language - SWRL Syntax Semantics The SWRL-like Rule Language Syntax Semantics Contribution of Thesis Organization of Thesis Preliminaries SWRL-like Rules The Rule Reasoning Process Consequences of Rule Application Decidability DL-Safe Rules Sound and Complete Reasoning Problem Definition and the Proposed Solution vi

7 3 Fire Design and Implementation of the Prototype Design DL Reasoner Services Reading Rules Pattern Matching Rule Application Termination Reasoning Pseudo-algorithm Soundness, Completeness, and Termination of Our Design Implementation DL Reasoner Rule Parser Pattern Matching Component Rule Application Component Implementation of the RETE Algorithm Soundness, Completeness, and Termination of the Prototype Implemented Optimization Evaluation Experimental Results Example Cases Example Example Example Example Example Related Work HOOLET SWRLJessTab for Protégé SweetRules KAON AL-Log r-hybrid KBs vii

8 5 Conclusion Goals Vs. Achievements Future Work Bibliography 48 A Trace of an Example 53 A.1 The Example Ontology family.owl A.2 Trace of family.owl viii

9 List of Figures 1 The architectural layers in the Semantic Web vision The design phase architecture of the Fire system The refined architecture of the Fire system in the implementation phase Illustration of the RETE algorithm for pattern matching An example OWL ontology with SWRL-like rules Pictorial illustration of the initially asserted facts in family.owl ontology ix

10 List of Tables 1 Summary of comparison between the performances of the RETE algorithm approach and the naïve approach to pattern matching Initially asserted facts in the family.owl ontology x

11 Chapter 1 Introduction The Web of today was designed with a goal that the vast information it holds will not only be used for human-to-human communication but also for enabling machines to participate and help. This goal is reflected by the design issues of the Web 1 in the discussion, A roadmap to the Semantic Web. But the content on the Web has grown in a way that most of it is designed mainly for human consumption. The ways in which the data is structured are also for human consumption, which are not evident to machine processing of the data. Tim Berners-Lee, the creator of the World Wide Web, envisioned the Semantic Web project to overcome this obstacle for realizing the full power of the Web. The goal of this project is to extend the Web in a way to utilize the full participation and help of machines. The approach is to (i) develop languages to represent and structure data, including their meaning (semantics) and (ii) to establish a universal medium for exchange of information. This should be done in a formal way that is suited for machine consumption (Such representations of information are in addition to the existing versions of representations designed for human consumption). Machines could then be engineered to better understand such information enhanced with formal semantics, to perform automated reasoning with the Web content, and carry out more intelligent tasks on behalf of the user. At this point it should be clear that the concept of machine-understandable information does not indicate the ability of the machine to comprehend human language. It only indicates a machine s ability to solve a well-defined problem by performing well-defined operations on existing welldefined data. 2 It involves humans in the process of defining the data and the operations over them, in a formal way that gives the machine its ability to understand the meaning of

12 the information it processes. 1.1 Progress Towards the Semantic Web Vision Figure 1(a) pictorially depicts the Semantic Web vision and is popularly known as the Semantic Web layer cake first used by Tim Berners-Lee. It shows the architectural layers of the vision. Each layer corresponds to a level of knowledge representation and structuring that is needed to realize the vision, with the standard technologies that are enabling them. There have been growing efforts in realizing this vision. Owing to these efforts and to the recent broad consensus in the community to include rules along with ontologies in the Semantic Web architecture, a more refined layer diagram resulted [ADG 05]. The refined layer diagram is shown in Figure 1(b), which is borrowed from Tim Berners-Lee s keynote talk at ISWC We present below, a brief description of these layers in the architecture diagram represented by both Figures 1(a) and 1(b). (a) (b) Figure 1: The architectural layers in the Semantic Web vision. The XML (extensible Markup Language) layer: XML allows to mark-up and structure arbitrary content by means of nested, attributed elements. The structuring has no particular semantics to indicate what the structure means. XML plays the role of just a syntax carrier and this layer corresponds to a basic syntax layer

13 The RDF (Resource Definition Framework) Model and Syntax layer: This layer corresponds to the meaning of data. RDF allows encoding, exchange, and reuse of structured metadata. In principle, information is represented by generic means, say by directed partially labelled graphs that may be serialized using XML. Contrary to XML, RDF allows assigning global identifiers to such information resources and allows one resource document to refer to and extend statements made in other resource documents. This feature mainly motivates for its use in this data layer. The Ontology layer: This layer corresponds to the formal common agreement about the meaning of data in terms of ontologies. Ontologies formally describe the shared conceptualizations of particular domains of interest. This description can be used to describe structurally heterogeneous and distributed information sources found on the Web. Ontologies help both people and machines to communicate concisely by defining shared and common domain theories and vocabularies. They support the exchange of semantics as well as syntax. The Rules layer and the Logic layer: These two layers together allow for querying meaningful data. Rules in these layers enable automated reasoning with the formally specified, structured data, to enable interesting inferences. The Proof layer: This layer has been conceived to allow the explanation of given answers generated by automated agents. This will require the translation of agents internal reasoning mechanisms into some unifying proof representation language. It supports the exchange of proofs between such agents, enabling a common understanding of how a desired information is derived. In recent years, the Semantic Web research community has seen significant advancements towards realizing this architectural vision. The advancements have been in the form of standardizations of languages and Web technologies that enable this vision. The progress is seen in terms of levels of maturity reached in each layer. The OWL Web Ontology Language (OWL) 4 which is a description logic 5 [BCM 03, BN03] based language, has been one such advancement which is now the World Wide Web consortium recommended standard for representing ontologies on the Web. OWL provides three sublanguages with Description logics are also popularly known as terminological logics or concept languages. 3

14 increasing expressivity, the OWL Lite sublanguage, the OWL DL sublanguage, and the OWL Full language. Details of these sublanguages are presented in Section From Ontology to DL Based Rules The Semantic Web and the description logics (DL) communities have seen dedicated stateof-the-art reasoners like RACER[HM01], FaCT[Hor98], Pellet 6 among others, providing efficient decidable reasoning over portions of the OWL language (specifically OWL DL). With OWL, and the significant progress its standardization has triggered, the ontology layer has attained a substantial level of maturity towards the vision. Many complex relationships between concepts can be expressed in OWL. But, when it comes to expressing certain relationships between roles, the expressivity offered by OWL is not enough. Consider the example to express the definition of a role hasuncle as the composition of roles hasparent and hasbrother. Another example (borrowed from [Rec02]) to express propagation across transitive roles: a fracture locatedin the femur bone, where femur bone isparto f the leg, means a fracture is locatedin the leg. Here the isparto f is transitive. These ideas cannot be expressed in OWL without additional expressive features. Non-availability of known DL algorithms for decidable reasoning with the full OWL language and a need for expressivity not offered even by the full OWL language, have motivated research interests towards extending OWL DL with more expressive features. The broad consensus in the community indicates that such an extension should involve adding rules over the ontology layer. A move towards this extension points us towards several existing proposals for integrating ontologies and rules. Generally, a rule is composed of an antecedent and a consequent, both made up of zero or more atoms. 7 An atom is made up of a predicate with an arity of one or more. Atoms can refer to the elements of a knowledge base (KB) and specify conditions involving them. So, basically the body and head of rules specify certain conditions and rules are used to derive new inferences about the knowledge represented by a KB. Rules are logically treated in two ways namely, (i) as trigger rules and (ii) as logical implications. Trigger rules are popular with rule based knowledge representation systems and expert systems. Trigger rules usually operate only in one direction i.e., from antecedent Throughout the thesis, body is synonymously used with antecedent, and head is synonymously used with consequent. 4

15 to consequent. Their intended meaning is simple and can be read as: if the conditions in the antecedent are known to hold, then conclude that the conditions in the consequent also hold. Whereas, the logical implications operate in both directions. That is, the contraposition law 8 holds on such rules. Their intended meaning can be read as: whenever the conditions specified in the antecedent hold, then the conditions specified in the consequent must also hold. The contraposition law gives the additional meaning that can be read as: if the conditions in the consequent do not hold, then the conditions in the antecedent also do not hold. Both kind of rules mentioned above offer added expressivity to the DL based ontology language it extends, enabling it to express complex relationships between its elements. Two recent papers [ADG 05] and [Ros05] provide classifications of existing proposals for integrating ontologies and rules. [ADG 05] surveys work on combining rules and ontologies for the Semantic Web. The classification suggested is based on the degree of integration of the ontologies and rules: (i) hybrid approach: it strictly separates rule predicates from the ontology predicates that can appear in rule antecedents, and offers reasoning by interfacing existing rule and ontology reasoners and (ii) homogenous approach: it embeds both ontology and rules in a common logical language and does not distinguish between rule and ontology predicates appearing in rule bodies and offers reasoning either by a general reasoner of the common logic language or by constructing a specialized reasoner for the rule language. [Ros05] mentions hybrid systems constituted of two or more subsystems, each dealing with a distinct portion of the KB and using specific representation formalisms and reasoning procedures. Following these lines we classify only those existing proposals that integrate DL based ontologies with rules. Hybrid approach: This approach combines a DL ontology language with an existing rule language (mostly Datalog or its extensions). The rule component and the ontology component of the hybrid KB are treated distinctly. The ontology remains unchanged, but rules are built upon them. The interaction between the two components is obtained by enforcing some constraints on the predicates (both rule and ontology) in rule bodies and on the individuals/constants that the variables in these predicates can be bound with. Generally, in systems following this approach the set 8 According to the law of contraposition the logical implication p q and its contrapositive q p are logically equivalent, where p and q are logical sentences/statements. 5

16 of symbols used as concept and role names by the ontology (i.e., ontology predicates) have an alphabet that is disjoint with the set of predicate symbols used by rule atoms in the rule language (i.e., rule predicates). But they share a common alphabet for variables and individuals/constants. The reasoning support for the hybrid knowledge is by interfacing existing ontology reasoners with existing rule reasoners. This approach is well-suited for the construction of tools for accessing heterogenous information systems. It benefits existing systems that are structurally represented by a DL based language, having application-specific rule programs and having a need to integrate both. Homogenous approach: This approach basically works by treating the ontology and rules homogeneously in a single logic language. From a DL point of view, this can be further classified as follows: Translation based Approach. The ontology and rules are both translated to be embedded in a common logical language preserving their individual semantics. Reasoning support is provided by a general reasoner of the common language. DL based Approach. The rule language in systems following this approach is generally a strict syntactic and semantic extension of the DL ontology language. The extension is itself an ontology language and is allowed to express the knowledge of the KB. Both ontology and rules use the common alphabet for the set of predicate symbols, variables and constants. Reasoning support for the ontology is extended by constructing a specialized reasoner to handle rule inferencing. Our present work in the thesis is relevant to the line of research introduced above, focussing on the rules layer from the ontology layer in the Semantic Web architecture in Figure 1(b). We follow the homogenous DL based approach described above to combine the DL based OWL language with a rule language. For the rule language, we are guided by the recent proposal, the Semantic Web Rule Language (SWRL) [HPB 04] which combines the OWL DL and OWL Lite sublanguages of the OWL with the Unary/Binary Datalog RuleML sublanguages of the Rule Markup Language 9. The SWRL rules are treated as logical implications described earlier in this section. We recognize a rule language that is 9 6

17 similar to SWRL in syntax, but a little different in semantics, which we call as the SWRLlike rule language. The main difference is the treatment of rules as trigger rules. We concentrate our work on the extension of OWL with this SWRL-like rule language and propose a reasoning system, Fire, for the extension. We present a prototype that partially implements the proposed design of the Fire reasoning engine. The following sections set the stage for understanding the rest of the thesis, by discussing the ontology language OWL and the rule language SWRL. We then identify the SWRL-like rule language on which this thesis focuses, describe why it is called so and how it differs from SWRL. 1.3 The OWL Web Ontology Language The OWL Web Ontology Language [OWL04] is the W3C standard for representing ontologies on the Web. It is a stepping stone in the progress towards achieving the Semantic Web vision (see Figure 1). The OWL language is a DL based semantic markup language for publishing and sharing ontologies on the Web. It is developed as a vocabulary extension of RDF (the Resource Description Framework) and is derived from the DAML+OIL Web Ontology Language 10. The syntax of the language enables defining and instantiating Web ontologies in the form of descriptions of classes, properties and their instances. The formal semantics of the language specifies how to derive the ontology s logical conclusions (facts not literally present in the ontology but entailed by the semantics). OWL provides three sublanguages offering increasing levels of expressivity. Each is an extension of its simpler predecessor, both in what can be legally expressed and in what can be logically derived. OWL Lite corresponds to the DLSHIF D n µ. It is a basic functional subset of the entire language allowing for classification hierarchies and simple constraint features. OWL DL is that subset of OWL corresponding to the description logicshoin D n µ, for which decidable reasoning procedures exist. It is expressive enough to represent and model domains that have complex relationships between its identified classes. But the only relationship between properties that it allows to express is subsumption between atomic properties, i.e., being able to express something like, hasfather is a subpropertyof hasparent

18 Adding rules can increase the expressivity of OWL DL to express more complex relationship between properties, especially by using variables. OWL Full has the maximum expressiveness, has the full syntax of OWL language and the syntactic freedom of RDF. There exists no known DL algorithms to decidably reason with OWL Full. 1.4 The Semantic Web Rule Language - SWRL The SWRL [HPB 04] is a recent proposal to the W3C to extend OWL with rules. It is based on a combination of OWL DL and OWL Lite sublanguages of OWL with the Unary/Binary Datalog RuleML sublanguages of the Rule Markup Language 11. The rule extension is by adding rule axioms to the set of OWL axioms. The proposal extends the OWL abstract syntax to include the syntax of these rules and the OWL model-theoretic semantics to provide a formal meaning for ontologies that include rules written in this syntax. The extension is strictly a syntactic and semantic extension, hence has a tight integration to OWL Syntax A SWRL rule axiom is made up of an antecedent and a consequent, both consisting of zero or more atoms. A rule with either zero atoms in the body (unconditional facts that always hold), or zero atoms in the head (a trivially empty head that never holds) is not interesting for adding expressivity to OWL. Such rules are better expressed in OWL without rule constructs or as queries respectively. In a rule with multiple atoms in the body, the body is treated as a conjunction of its atoms. In a rule with multiple atoms in the head, the head also is treated as a conjunction. But such a rule can be easily transformed into multiple rules each with a single-atom head [HPB 04]. Rule atoms can be of the form: 12 C xµ where C is an OWL Class (a simple named class or a class description) or a data range 13 and x is either a variable, OWL individual or OWL data value The abstract syntax of SWRL rule axioms, in a version of extended BNF notation, is given in

19 P x yµ where P is an OWL Property (an object property or a datatype property), x is either a variable or an OWL individual and y is either a variable, an OWL individual or an OWL data value. sameas x yµ, differentfrom x yµ where x, y are variables or OWL individuals. builtin r x µ where r is a built-in relation and x are OWL data values. C xµ can be referred to as a concept atom/class atom, P x yµ can be referred to as a role atom/property atom. According to [HPB 04] variables in a rule are treated as universally quantified, limited to the scope of that rule. Rules must be safe, i.e., only variables that occur in the rule body may occur in the rule head 14. The syntax of SWRL doesn t allow disjunction of atoms, negation of atoms or any non-monotonic features like negation as failure or defaults. An informal human-readable syntax for these rules is also specified for ease of readability and a typical rule in this syntax would look like: hasparent?x?yµ haschild?y?zµ µ hassibling?x?zµ It states that an individual x having a parent y who in-turn has a child z, is a sibling of z Semantics A SWRL rule is treated as a logical implication between its body and head. The intended meaning is that: whenever the conditions in the rule body hold, then the conditions in the rule head must also hold. It is important to recall that, the law of contraposition holds on this implication. Accordingly, if a rule holds, its contrapositive also holds (See Section 1.2). According to the SWRL proposal citehpb04, the formal semantics for the rules are given by an extension of the OWL interpretation by defining bindings. These bindings map variables in rules to elements in the ontology domain. A rule is satisfied by an interpretation iff every binding that satisfies its body also satisfies its head. A rule body or rule head is satisfied if the conjunction of its atoms is satisfied. A concept atom C xµ is said to be satisfied if x is an instance of the class description or data range C. A role atom P x yµ is 14 Unsafe rules allow variables in the head that do not occur anywhere in the body. If this is allowed, the definition of bindings for variables cannot be defined correctly in this context. Also, termination of reasoning cannot be guaranteed as all the individuals in the KB could be used to bind the variable in the head. E.g., the rule Child?xµ µ isinnocent?yµ is unsafe. 9

20 said to be satisfied if x is related to y by role P. A sameas x yµ atom is said to be satisfied if x is interpreted as the same object as y. A differentfrom x yµ atom is said to be satisfied if x and y are interpreted as different objects, and a builtin r x µ atom is said to be satisfied if the built-in relation r holds on the interpretations of the arguments. An interpretation satisfies an ontology iff it satisfies every axiom (OWL axioms and rule axioms) and fact in the ontology. It is important to again note that since a rule is treated as a logical implication, the implied meaning is that the contraposition law holds on the implication (rule). For example, whenever the rule: hasparent?x?yµ haschild?y?zµ µ hassibling?x?zµ holds, its contrapositive implication: hassibling?x?zµ µ hasparent?x?yµ haschild?y?zµµ also holds. It has been pointed out from the first version of the SWRL proposal that this kind of a rule-extension to OWL DL makes it undecidable [HPS04]. According to citemss04, the reason is that OWL DL is a logic with tree model property (i.e., any satisfiable KB in this logic has a model of a certain tree-shaped form). So, the satisfiability (i.e., existence of a model) of a KB in this logic can be decided by searching for only such tree-shaped models and ensuring termination of the search. Addition of SWRL kind of rules to this logic causes loss of this tree model property. This leads to undecidability of interesting reasoning problems for the combination of OWL DL and SWRL rules. 1.5 The SWRL-like Rule Language The SWRL-like rule language that we consider here is very much like SWRL, sharing the SWRL syntax and the human-readable syntax that are discussed in Section 1.4. The difference is in the semantics. We describe the language and hightlight its differing semantics from SWRL. 10

21 1.5.1 Syntax A SWRL-like rule is made up of an antecedent and a consequent, both consisting of one or more atoms. 15 The head of a rule consists of exactly one atom 16 and a rule body with multiple atoms is treated as a conjunction of its atoms. Rule atoms can be of the form: C xµ where C is a simple named OWL Class and x is either a variable or an OWL individual. P x yµ where P is an OWL object property and x, y are variables or OWL individuals. Note that currently the syntax does not allow OWL class description atoms, OWL data range atoms, OWL datatype property atoms, sameas and differentfrom atoms or built-in atoms. Not allowing OWL class description atoms is not a restriction since, for every class description C, we can always introduce an atomic named class A C Ú C to the terminology of the KB and use A C in the rule [MSS04]. The sameas µ and differentfrom µ atoms are for syntactic convenience and not for increasing the expressivity of OWL. Such (in)equalities can already be expressed using the combined power of OWL and rules without explicit (in)equality atoms [HPB 04] Semantics A SWRL-like rule is treated as a trigger rule (see Section 1.2), as opposed to a SWRL rule which is a logical implication. So the contraposition law does not hold on a SWRL-like rule. Operational semantics are given for these rules. The intended meaning for a SWRLlike rule is that: if the conditions in the rule body are proved to hold, then derive that the condition in the rule head holds. The rules are applicable only in one direction, namely, from rule body to rule head. The rules are treated with active domain semantics, i.e., the variables in rule atoms are bound only to explicitly named individuals in the ontology domain and not to anonymous individuals encountered during the proof. 15 Rules with zero atoms in the head or zero atoms in the body are not considered interesting for adding expressivity to OWL. 16 This is not a restriction on expressivity, since a rule with a conjunction of atoms in the head can be easily transformed to multiple rules each with a single-atom head [HPB 04]. 11

22 1.6 Contribution of Thesis In the thesis we consider a SWRL-like rule language that shares its syntax with the SWRL rule language, but has different semantics. For OWL ontologies extended with rules expressed in this language, we provide a DL based reasoning support. Our contributions in this work include: 1. Recognizing the rule language, SWRL-like, for a practical implementation, which is very similar to the SWRL but differing slightly in semantics. 2. A proposal for a rule engine, called the Fire system, for reasoning with OWL ontologies extended with SWRL-like rules. 3. A prototype implementation of the Fire system offering sound, terminating and direct DL based reasoning that is synchronous with OWL reasoning. 4. Implementation of the RETE algorithm [For82] for handling pattern matching of DL facts and DL rule patterns. 1.7 Organization of Thesis In Chapter 2 we present the background for this work. First, we state the background that guided the way we approached the problem addressed in the thesis. This is followed by a detailed description of the SWRL-like rule language, the rule reasoning process, possible approaches to ensure termination of reasoning and a sound and complete reasoning method. The chapter ends with a statement of the problem addressed and the solution we propose. Chapter 3 is dedicated to the design of the proposed system Fire and the implementation details of the prototype developed by this thesis. The explanation is based on the overall architecture and the implemented architecture of Fire. At the end, we present a specific optimization we implemented for the prototype. In Chapter 4 we discuss the results from our experiments with the prototype implementation. This is followed by an evaluation of the design and prototype implementation, by discussing how the example cases introduced are handled. We end this chapter with a discussion of related work. In Chapter 5 we conclude the thesis with a discussion of our goals and achievements in the thesis followed by an overview of the future work. 12

23 Chapter 2 Preliminaries This work is closely related to the dedicated state-of-the-art DL reasoner RACER [HMW04], which offers sound and complete reasoning for OWL DL almost completely 1. In the view of bringing DL ontologies closer to the implemented systems (frame-based systems or rule based systems), our concern is towards extending DL ontologies with DL based rules, and supporting it by a DL based system for reasoning with rules. With this background, the standardization of OWL [OWL04] as the W3C standard for representing ontologies on the Web and the recent proposal to the W3C, SWRL [HPB 04], to extend OWL with rules, we were motivated towards implementing a DL based rule reasoning support for OWL ontologies extended with this such rules. A survey of the relevant literature in this direction shows significant amount of work done in combining ontologies and rules. However, for the present work we are concerned with the literature about combining DL based ontologies and rules. We find that most often the literature in this direction is combining with DL ontologies, the rules from either a Datalog (or its extensions) program, DL-safe subset of SWRL language or epistemic rules using the K-operator. A discussion of the related work is presented in Section 4.3. Our research approach is to have OWL DL as the base and extend it with a rule language similar to SWRL, which can be supported by a practical implementation. This way we intend to still offer reasoning support for complete OWL DL, not restricting it in any way, and provide a practical reasoning support for rules offering direct inferencing over DL 1 RACER s support for complete OWL DL currently has two limitations. One, approximation of nominals (individuals in class expressions) and two, currently not handling user-defined datatypes types given as external XML Schema specifications. See for details. 13

24 based rules. We consider a language similar to SWRL, which we call as the SWRL-like rule language, presented in Section 1.5. Our analysis and decisions are guided by two factors, (i) feasible practical implementation using existing tools and (ii) maintain decidability of the reasoning support for the combination. 2.1 SWRL-like Rules We recall that the SWRL-like rules have a similar syntax as SWRL (see Sections 1.4 and 1.5). A rule is treated as a trigger rule, meaning the reasoning mechanism applies the rule in only one direction namely, antecedent to consequent. A typical SWRL-like rule in the human-readable syntax is of the form antecedent µ consequent where the antecedent is made up of one or more rule atoms that are treated as a conjunction and the consequent is made up of exactly one rule atom. A rule atom can be either of Concept atom: A rule atom with a concept predicate of the form C Xµ, where C is an OWL named class X is either a variable 2 or an OWL individual. Role atom: A rule atom with a role predicate of the form R X Yµ, where R is an OWL object property X, Y are either variables or OWL individuals. Unlike in SWRL, the SWRL-like rule language does not allow built-in relations, data ranges, sameas, or differentfrom predicates. As mentioned in [HPB 04], not allowing sameas and differentfrom kind of rule atoms does not necessarily decrease the expressive power of the combined language as these (in)equalities can still be expressed using the combined power of OWL and rules without these explicit atoms. Similarly allowing only named classes in concept atoms does not restrict expressivity in rules, since class descriptions can be replaced with an equivalent definition of a named concept added to the KB. 2 In the thesis we use the standard convention of indicating a variable by prefixing it with a question mark e.g.,?x 14

25 In many DL systems like CLASSIC 3 the concept of epistemic K-operator was used to provide a formal semantics for the procedural behavior of trigger rules [DLN 98]. Unlike the usual DL operators that refer to objects in the domain, the epistemic operator K refers to what the KB knows about the domain. In a sense, epistemic operators allow forms of local closed-world reasoning over an otherwise open-world knowledge. 2.2 The Rule Reasoning Process In terms of the operational semantics of the SWRL-like rule language, the behavior of trigger rules in the rule reasoning process is usually described in terms of a forward reasoning process. In the process described below, we consider the following form of a typical trigger rule as a representative for SWRL-like rules for clarity. C Xµ µd Xµ wherec andd are concepts, and X is either a variable or an OWL individual. Consider a typical ontology knowledge base (KB) as a pairk T A µ, wheret is the TBox (for terminologies) anda is the ABox (for assertions). This KB is extended by a finite setr of trigger rules typically of the form introduced above. The operational semantics of the DL based trigger rules inr can be described by the forward reasoning process as follows [BN03]. Starting with an initial KB K, a series of KBsK 0µ,K 1µ is constructed, wherek 0µ =K andk i 1µ is obtained fromk iµ by adding a new assertiond aµ wheneverr contains a rulec Xµ µd Xµ, such that K iµ C aµ holds, butk iµ does not contain the factd aµ, for any individual a ink iµ. Note that this reasoning process eventually halts because the given initial KB K contains only finitely many individuals and there are only finitely many rules in given R. Hence, there are only finitely many assertionsd aµ that can possibly be added. The KB resulting after the series of rule applications isk iµ having the same TBox ask 0µ but the ABox has been augmented by the assertions introduced by the rules.k iµ is the final KB that results when no more augmentation to the KB is possible. Note that like OWL entailments, rule inferences are also monotonic, i.e., the assertions introduced by rules can only add new facts to the KB but never take away the already existing facts. Rules can only introduce new concept/role assertions and cannot introduce new individuals or new rules for that matter

26 The resulting final KBK iµ is therefore independent of the order of rule applications. The process can be similarly extended for rules with property atoms also. 2.3 Consequences of Rule Application The application of a SWRL-like rule augments the KB by introducing new assertions in it. For a rule engine it is important to consider the consequences of such augmentation in the KB. In a given state of the KB, the body of a rule must be satisfied according to its semantics (see Section 1.4), for a rule to become applicable (or to be triggered) with an instantiation. Note that more than one such instantiation could trigger the rule simultaneously. Identifying such triggered rules and their corresponding instantiation(s) is one of the most important tasks in the rule reasoning process. The application of such a triggered rule is done by materializing its head with the rule instantiation, i.e., by suitably grounding the variables in the rule head atom with bindings from the rule instantiation and then asserting the grounded atom to the KB. The materialized head of a triggered rule is called a rule inference. The rule is then said to be fired once with an instantiation. The following consequences of rule firing are vital to our discussion. A rule inference could be a part of the instantiation that in-turn triggers some rule in the next reasoning cycle. A rule inference could in-turn cause new entailments in the KB. A rule inference could contradict the facts in the KB, which we term as introducing an inconsistency in the KB. These consequences have to be handled by the reasoning support, if the tight integration with OWL is to be retained. Meaning, given a state of the KB, the rule inferences and the possibly resulting new entailments in that state of the KB must be considered for the next cycle of reasoning. A cycle of reasoning comprises of identifying which rules are triggered in a given state of the KB and applying those rules to the KB according to some specific strategy (see Section 3.1.4). Also, an inconsistency possibly introduced in a reasoning cycle has to be detected at the earliest to enable the user or the application to recognize the corresponding rule that is responsible for introducing contradicting facts in the KB. 16

27 2.4 Decidability OWL DL and rule languages like SWRL (whose rules are restricted forms of function-free Horn clauses) are both decidable logics. Their combination gives the much needed expressive power, at the same time makes the combined logic undecidable. From the illustrated example and discussions in [MSS04], we understand that one of the main reasons for this undecidability is because these rules allow reasoning over anonymous individuals encountered during the proof. This kind of arbitrary interaction between the OWL DL features and rule features is avoided, to maintain decidability, in the so-called DL-safe approach. The literature [MSS04] proposes this as a decidable rule extension to OWL DL and provides reasoning by reduction of the DLSHIQ to a disjunctive Datalog program DL-Safe Rules In this approach, the atoms in the rules (a kind of Horn clauses) are restricted to being DL-atoms. That is, only unary atoms or binary atoms are allowed whose predicates can be respectively OWL classes or OWL properties. The OWL class used as a predicate must be a simple OWL named class. Further, it is required that each variable that occurs in the atoms of the rule body must occur in a non-dl atom in the body. This is to ensure that the variables are bound only to explicitly defined individuals in the KB and not to anonymous individuals encountered during the proof. For example: hasparent?x?yµ hasbrother?y?zµ µ hasuncle?x?zµ This rule is DL-unsafe because the variables x, y and z in the body occur only in DL-atoms and not in non-dl atoms. This is made DL-safe as follows, hasparent?x?yµ hasbrother?y?zµ O?xµ O?yµ O?zµ µ hasuncle?x?zµ by introducing an external non-dl predicateo in the rules. For every variable v occurring in the rule body, a non-dl atom,o vµ, is conjuncted to the rule body (in this caseo xµ, O yµ ando zµ). Also, for every explicit OWL individual ı in the KB, a concept assertion O ıµ is added to the KB. In this way the rule reasoning mechanism can ensure that the variables in the rule body are bound to only explicitly existing individuals in the KB. This is called DL-safety and it makes the reasoning approach decidable. However, it is important to consider the consequence of such a safety restriction on an example case illustrated 17

28 below. Consider the following DL-unsafe rule, R?x?yµ R?z?yµ µ C?yµ where R is an object property, C is a named class and i, j are variables, along with the following assertions anne : S R jim anne : U R jim The former assertion states that anne is an instance of a concept that is related by role S to some individual that is in-turn related by role R to the individual jim. Similarly, the latter states that anne is an instance of a concept that is related by role U to some individual that is in-turn related by role R to the individual jim. Intuitively, jim should be inferred as an instance of C from the DL-unsafe rule shown above, though jim is not related by property R to an explicitly named individual of the KB considered. But with the DL-safety restriction applied to the above rule, it is easy to see that the inference j : C is not derived by rule reasoning. This kind of restricting the reasoning to explicitly named individuals in the KB is generally known in the DL world as active domain semantics. The advantage of retaining decidability in this way vs. a need for applications or users to be able to derive such an inference ( j : C) is an issue of discussion on which an applicationspecific rule reasoning support should be based on. The authors of [HAMS05] are of the opinion that this kind of DL-safety restriction is not very restrictive in many cases because a significant number of applications like metadata management on the Semantic Web or information integration require extensive ABox reasoning (query answering or instance checking) and such applications know most individuals by name. But for applications that require intensional (TBox) reasoning, this is obviously a severe restriction as typically only a handful of individuals is known by name in such applications. The DL reasoner RACER and its query language nrql both implement this active domain semantics in their ABox query services. So, any system making use of inference services of RACER automatically inherits this safety feature. 2.5 Sound and Complete Reasoning A sound and complete reasoning is both sensible and always desirable by any application. Providing a sound and complete reasoning is hence a main focus of a reasoning support for 18

29 a combination of OWL and rules. In this context we present the approach followed in the CARIN system [LR98] and later present how we follow a similar approach in our current work. The CARIN system is a family of representation languages providing a hybrid integration of Horn rules and description logics (specifically, subsets of thealcnr DL). Two specific subsets of CARIN are identified in [LR98] and a sound and complete reasoning procedure is offered for both. The reasoning is done in two steps namely, the DL-reasoning step and the rule reasoning step. This procedure is well summarized in [ADG 05] as follows: In the DL reasoning step, the DL-component of a given knowledge base is used to construct a set of its completions, each of which is represented by a finite set of DL-atoms and determines a canonical model of a program. A rule component of a CARIN knowledge base consisting of all hybrid rules and facts can now be augmented by the set of DL-assertions determined by a completion of the DL component. There is a finite number of such augmented rule components. In the rule reasoning step a standard forward chaining is done for each augmented rule component, using the added DL-assertions as new facts. A non-dl atom is entailed by the knowledge base iff it is entailed by each of its augmented rule components. Following this approach in CARIN, we make a conjecture that a similar procedure described below is sound and complete for OWL ontologies extended with SWRL-like rules. The procedure is also done in two steps as follows. The tableau completion rules are used to construct all possible completions of the KB. Each clash-free completion will be represented by a finite set of facts (concept and role assertions), and determines a canonical model of the KB. Note that there can be finitely many such completions. In each such clashfree completion, a forward chaining is performed with its facts and all the SWRL-rules of the KB. The resulting instantiations for the rule head of applicable rules are derived as the set of rule inferences from each completion. The intersection of all such sets derived from each completion, determines the set of rule inferences that are common in all models of the KB. This intersection set determines the final set of rule inferences for the given state of the KB. A concept assertion C aµ where C is an OWL concept and a is an OWL individual, belonging to this final set, is entailed by the OWL KB iff it is inferred as a rule inference in the forward chaining on each of the clash-free completions of the KB. The final set of rule 19