Combining First-Order Logic Knowledge Bases and Logic Programming using fol-programs Master Thesis

Transcription

1 Combining First-Order Logic Knowledge Bases and Logic Programming using fol-programs Master Thesis Michael Felderer, July 2006 supervised by Univ.-Prof. Dr. Thomas Strang under co-supervision of Jos De Bruijn, MSc

2 Abstract The integration of knowledge bases in classical first-order logic (and in particular of ontologies in various description logics) with rule languages rooted in logic programming is receiving considerable attention in the context of current efforts around Semantic-Web languages. Towards this integration we introduce fol-programs, which combine logic programs under the answer set and the wellfounded semantics with first-order logic knowledge bases and which generalize dl-programs, a closely related approach combining description logics with rules. Therefore, we define a syntax and a semantics for fol-programs, namely we define minimal model, strong answer set, weak answer set and well-founded semantics for fol-programs, to properly generalize the semantics of ordinary logic programs to fol-programs. We then show computational properties of fol-programs and prove that fol-programs are more expressive than dl-programs. Finally, we present our implementation of the well-founded semantics of fol-programs based on the deductive database engine Ontobroker and the automated theorem prover for first-order logic Vampire and discuss representative reasoning experiments on it. i

3 Acknowledgements I would like to thank my immediate supervisor Jos de Bruijn for his guidance through my thesis. He always tried to answer my questions in full depth as soon as possible and let me profit from his tremendous knowledge on logic programming and combinations of it with classical theories. Also, I wish to thank all my lecturers who guided me through the master course in computer science at the University of Innsbruck and taught me the theoretical principles which made it possible for me to work on this thesis. In this sense, I especially want to thank Axel Polleres for his lecture on logic programming, Jos de Bruijn for his lecture on the Semantic Web and Georg Moser for his lectures on logic and algorithm theory. Finally, I want to thank my parents, Peter and Theresia, for their understanding, support and endless love. ii

4 Contents Abstract Acknowledgements List of Figures i ii vi List of Tables 1 1 Introduction 2 2 Preliminaries First-Order Logic Logic Programming Minimal Herbrand model Answer Set Semantics Well-Founded Semantics Description Logics Decidability and Undecidability Combining Classical Logics with Nonmonotonic Rules Issues to Combining Classical Logics and Rule-based Languages Domain of Discourse Uniqueness of Names Interaction between FOL knowledge bases and Rules Settings for Combining Classical Logic and Rules Current Approaches Combining Knowledge Bases SWRL and Subsets DL + log and its Predecessors dl-programs dl-programs Syntax Semantics Minimal Model Semantics of positive dl-programs iii

5 4.2.2 Answer Set Semantics of dl-programs Strong Answer Set Semantics of dl-programs Weak Answer Set Semantics of dl-programs Well-Founded Semantics of dl-programs fol-programs Syntax Semantics Minimal Model Semantics of positive fol-programs Answer Set Semantics of fol-programs Strong Answer Set Semantics of fol-programs Weak Answer Set Semantics of fol-programs Well-Founded Semantics of fol-programs Properties of fol-programs Computational Properties of fol-programs fol-programs and dl-programs Implementation and Experiments Reasoning Tools Vampire Ontobroker Input Format of the fol-programs reasoner Syntax of fol-rules Syntax of FOL knowledge bases Architecture of the fol-programs reasoner Implementation of the fol-programs builtins Overview Main classes Experiments Example Example Example Example Summary and Conclusions 90 Bibliography 92 A Listings of fol-programs 98 A.1 Source of Example A.1.1 Listing of abstract dl.flo A.1.2 Listing of abstract dl.flo A.1.3 Queries and Results iv

6 A.2 Source of Example A.2.1 Listing of computer shop.flo A.2.2 Listing of computer shop.vkb A.2.3 Queries and Results A.3 Source of Example A.3.1 Listing of graph.flo A.3.2 Listing of graph.vkb A.3.3 Queries and Results A.3.4 Additional Example A.4 Source of Example A.4.1 Listing of numbers.flo A.4.2 Listing of numbers.vkb A.4.3 Queries and Results v

7 List of Figures 6.1 Ontobroker Inference Procedure Architecture of fol-programs implementation Class Diagram of Fol Builtin Graph A.1 Family Graph vi

8 List of Tables 5.1 Knowledge Base Mapping Example Mapping of SHOIN axioms in computer shop KB to FOL formulas 87 1

9 Chapter 1 Introduction The question of combining knowledge bases in classical first-order logic with rule languages rooted in logic programming is recently gaining increasing interest in the context of the Semantic Web. The latter is built from different layers, of which the Ontology Layer is currently the highest layer of sufficient maturity, as evidenced by the W3C recommendation of the OWL Web ontology language [DS04]. Attention is now shifting towards defining a rule language for the Semantic Web which integrates with OWL. Such a rule language allows for defining relationships between the data on the Semantic Web, integrity constraints, policies, reactive behavior and workflows. From a formal point of view, OWL (DL) can be seen as a syntactic variant of an expressive description logic [BCM + 03], i.e., SHOIN (D) [HPS03], which is a decidable subset of classical-first order logic. Declarative rule languages, on the contrary, are usually based on logic programming, adopting a non-classical semantics via minimal Herbrand models and often including extensions with nonmonotonic negation [GRS91, GL88]. Therefore the main differences between classical logic and rule-based languages are assumptions concerning an open vs. a closed world, an open vs. a closed domain and non-uniqueness vs. uniqueness of names. Combinations of ontologies, or more generally, first-order logic (FOL) knowledge bases, and rule bases need to take these differences into account. There have recently been several approaches for integrating such classical ontologies (FOL knowledge bases) and rules [ELST04a, ELST04b, Ros05, Ros06, GHVD03, HPSB + 04, MSS05]. From all these approaches SWRL [HPSB + 04], DL + log [Ros06] and dl-programs [ELST04a, ELST04b] are the most promising ones [dbept06]. In SWRL and DL + log the interaction between rules and FOL knowledge bases is based on single models whereas in dl-programs the interaction is based on exchanging entailments. Therefore, in dl-programs the logic program and the description logics knowledge base are viewed as separate components which are only connected through a minimal interface. This allows for a more flexible and intuitive integration of rules and classical ontologies in dl-programs than in SWRL and DL + log. Therefore, it is possible to implement an efficient 2

10 reasoning system for dl-programs by a straightforward integration of existing reasoners and to apply different semantics to dl-programs, namely answer set semantics, which is widely used for knowledge representation and reasoning in planning, scheduling and combinatorics and which allows for using powerful off-the-shelf reasoners like DLV [LPF + 04], and well-founded semantics, which assigns an unique well-founded model to every logic program and allows for efficient query answering on the Semantic Web. According to that we think that dl-programs are a very promising approach for further extensions. Especially for modelling complex domains of knowledge and for reasoning on them, it may be useful to combine rules with full firstorder logic ontologies, which allow for expressing knowledge beyond description logics [Bor96]. Therefore, in this thesis we extend dl-programs to fol-programs, combining logic programs using arbitrary terms under the answer set and wellfounded semantics with full first-order knowledge bases. Obviously, fol-programs are more expressive than dl-programs and can therefore simulate them and the key inference tasks of fol-programs are only decidable if the inference tasks are decidable in the logic program and if satisfiability is decidable in the FOL knowledge base. Our main contributions are as follows. We consider some alternatives for the syntax of fol-programs and discuss their advantages and disadvantages. Based on the results of our discussion we fix a syntax for fol-programs, define it formally and provide some examples which explain the definitions. We then define the semantics of fol-programs in three steps. We first define minimal model semantics for positive fol-programs which is the basis for answer set semantics and well-founded semantics. Then we define two flavors of answer set semantics, namely strong answer set semantics resp., weak answer set semantics to handle resp., ignore the nonmonotonicity of some queries to the FOL knowledge base. Finally, we define well-founded semantics for fol-programs without classical negation and without nonmonotonic queries to the FOL knowledge base. The canonical reasoning tasks, i.e., checking Strong Answer Set Existence, Weak Answer Set Existence and Well-Founded Entailment are undecidable for fol-programs in general. We then show for each of these reasoning tasks that it is decidable if we restrict our fol-program to function-free rules and to an FOL knowledge base for which satisfiability is decidable. We show that fol-programs are strictly more expressive than dl-programs by (i) defining a mapping which assigns to every dl-program an fol-program in a way such that both programs have the same semantics, i.e., the same minimal models, the same strong resp., weak answer sets and the same well-founded model, and 3

11 (ii) by providing examples of fol-programs for which no dl-program with the same meaning exists. We have implemented the well-founded semantics of fol-programs, which allows for efficient query-answering on the Semantic Web, based on Ontobroker as logic programming reasoner and Vampire as first-order reasoner. We have then tested the implementation on some examples to show its expressive power and the simulation of dl-programs. The thesis is structured by the following chapter numbers: 2 Preliminaries. In this chapter we define the basic concepts needed for formally defining the syntax, the semantics and computational properties of folprograms, i.e., we review the syntax and semantics of first-order logic, logic programming and description logics and we informally introduce the notion of decidability. 3 Combining Classical Logics with Nonmonotonic Rules. In this chapter we address the main differences between classical logics and rule-based languages and then we discuss current approaches combining FOL and LP, namely SWRL and its subsets, DL + log and its predecessors and dl-programs. 4 dl-programs. In this chapter we review dl-programs formally and discuss some semantical and computational properties of them. 5 fol-programs. In this chapter we motivate and define the syntax, answer set semantics and well-founded semantics of fol-programs. We then show that fol-programs are strictly more expressive than dl-programs and define decidable fragments of fol-programs. 6 Implementation and Experiments. In this chapter we describe our prototypical implementation of the well-founded semantics of fol-programs based on Ontobroker and Vampire and experiments with it. 7 Summary and Conclusion. Finally we summarize our work, draw conclusions about our investigations on fol-programs and discuss possible future extensions of fol-programs. 4

12 Chapter 2 Preliminaries In this chapter we define those concepts formally, needed for a formal definition of dl-programs in Chapter 4 and fol-programs in Chapter 5. In Section 2.1 we review First-Order Logic, following [Fit96]. In Section 2.2 we review Logic Programming restricted to extended programs: we treat minimal Herbrand models which are appropriate for defining the semantics of positive programs and stratified programs [Llo87], answer set semantics [GL88] and well-founded semantics [GRS91] which both capture the semantics of normal programs. In Section 2.3 we introduce description logics as a very important formalism for representing ontologies. Finally, in Section 2.4 we study basic results of decidability in first-order logic, logic programming and description logics. 2.1 First-Order Logic In this section, we review classical First-Order Predicate Logic under the usual Tarski-style semantics (see e.g. [Fit96] or [End00]). In our treatment of First- Order Logic we follow the treatment of [Fit96]. Only those concepts of first-order logic are defined (sometimes without any additional motivation) that are applied in the following chapters. Every first-order language L is constructed by a collection of different categories of symbols: (1) a countable set of variables V, whose elements are written as x 1, x 2,... (or informally as x, y, z) (2) a finite set of operators:,,,,, ( bottom ), ( top ), ( forall ), ( exists ), = (3) a finite set of auxiliary symbols: parentheses, comma (4) countable sets of constant symbols, function symbols and predicates symbols, called a signature 5

13 Categories (1) - (3) are fixed, but (4), its so called signature, may vary for every first order-language L. Therefore, a first-order language is determined by the choice of its signature. Definition 2.1 (Signature). The signature Σ of a first-order language L is defined by a finite or countable set P of relation symbols or predicate symbols, each of which has a positive integer, called arity, associated with it finite or countable set F of function symbols, each of which has a positive integer, called arity, associated with it finite or countable set C of constant symbols A signature Σ = P, F, C is function-free iff F =. A first order-language is function-free iff its signature is function-free. The signature Σ of a first-order language L is denoted by Σ = P, F, C if its signature is of special interest. If we do not want to define the signature Σ = P, F, C of a first-order language L explicitly or stress its relation to a language, then we write L(P, F, C). We now define terms and atomic formulae by induction. Definition 2.2 (Terms). Let Σ = P, F, C be the signature of a first-order language L. The set of terms of L is defined as follows: Any variable is a term in L. Any constant in C is a term in L. If f is a function symbol in F of arity n and t 1,..., t n are terms in L, then f(t 1,..., t n ) is a term in llang. A ground term is a term without variables. Definition 2.3 (Atomic Formulae). Let Σ = P, F, C be the signature of a firstorder language L. The set of atomic formulae, also called atoms, of L is defined as follows: If p is a predicate symbol in P of arity n and t 1,..., t n are terms in L, then p(t 1,..., t n ) is an atomic formula in L. and are atomic formulae in L. If t 1, t 2 are terms in L, then t 1 = t 2 is an atomic formula in L. Ground atomic formulae or ground atoms are atomic formulae without variables. 6

14 The arity assigned to function symbols and predicate symbols is denoted by superscripted numbers. E.g., f 1 may denote a function symbol of arity 1 and p 2 may denote a predicate symbol of arity 2. In the remainder, the arity may be assigned implicitly to function symbols and predicate symbols by a consistent application of the symbols in the definition of knowledge bases or rules. For an n-ary predicate symbol p, the list of terms t 1,..., t n may be replaced by a boldface letter and thus, p(t 1,..., t n ) may also be written as p(t). This notation is especially used for denoting dl-atoms and fol-atoms in the following chapters. Based on the definitions of terms and atomic formulae, we now define inductively define formulae. Definition 2.4 (Formulae). Given the formulae φ, ψ L, the set of formulae of a first-order language L is defined as follows: Every atomic formula is a formula in L. φ is a formula in L. (negation) (φ ψ) is a formula in L. (conjunction) (φ ψ) is a formula in L. (disjunction) (φ ψ) is a formula in L. (implication) (φ ψ) is a formula in L. (equivalence) Given the variable x, then x φ is a formula L. Given the variable x, then x φ is a formula in L. Definition 2.5 (Literal). Let L be a first-order language. A literal in a firstorder language L is an atom in L or the negation of an atom in L. A positive literal in L is an atom in L. A negative literal in L is the negation of an atom in L. A ground literal in L is a ground atom in L or the negation of a ground atom in L. The set of terms, resp., the set atoms, resp., the set of formulae resp., the set of literals of a first-order language L is also denoted by L-terms, resp., L-atoms, resp., L-formulae, resp., L-literals. Definition 2.6. The scope of x (resp., x) in x φ (resp., x φ) is φ. Quantifier combinations x and x bind every occurrence of x in their scope. Occurrences of variables that are not bound, are called free. A formula is open if it has free variables. A formula is closed if it has no free variables. A closed formula is also called a sentence. 7

15 Example 2.1. Let L be a first-order language with signature Σ = P, F, C, where P = {p 1, q 2 }, F = {f 1, g 2 } and C = {a, b, c}. Then, g(x, b) and g(f(x), y) are terms in L. q(a, g(c, y)) and f(a) = g(f(x), c) are (atomic) formulae and thus literals in L, p(a) is a negative literal in L, (p(x) q(a, f(x))) and x(p(x) p(a)) are formulae in L. x q(x, y) is not a closed formula because y occurs free in it. The formula y x q(x, y) does not have a free occurrence of any variable, therefore it is closed. If we write φ L, then we treat a first-order language L as a set of formulae, such that φ L iff φ is a formula in L according to Definition 2.4. The arity of all function and predicate symbols is denoted implicitly by a consistent application of these symbols. The signature of φ L is the signature of the first-order language L. Definition 2.7 (FOL knowledge base). An FOL knowledge base Φ, also called an FOL theory, in a first-order language L is a set of formulae in L, denoted Φ L. The signature of Φ is obtained from all the constant symbols, function symbols and predicate symbols which occur in Φ. A FOL knowledge base is function-free iff its signature is function-free. Definition 2.8 (Interpretation). An interpretation for a first-order language L(P, F, C) (or L-interpretation) is a pair I = D, J, where D is a nonempty set, called the domain of the interpretation and J is a mapping, called the interpretation function, which associates: to every constant symbol c C an element c J D. to every function symbol f F of arity n, some n-ary function f J : D n D. to very predicate symbol p P of arity n, some n-ary relation p J D n. A variable assignment A in a L-interpretation I = D, J is a mapping which assigns an element x A D to every variable in L. A variable assignment A is an x-variant of A if y A = y A for every variable y x. Definition 2.9. Let I = D, J be an interpretation of the language L(P, F, C), and let A be a variable assignment in this interpretation. To each term t in L we associate a value t I,A as follows: For every constant symbol c C, c I,A = c J. For every variable x in L, x I,A = x A. If t = f(t 1,..., t n ), then t I,A = f J (t I,A 1,..., t I,A n ). 8

16 Example 2.2. Let L be a first-order language with signature Σ, where P =, F = {s, add} and C = {zero}. Let I = D, J be an interpretation with domain D = {0, 1, 2,...} = N 0 and an interpretation function J defined as follows: zero J = 0, s J is the successor function over N 0 and add J is the addition operation over N 0. Thus, if A is a variable assignment such that x A = 2, then (add(x, s(zero))) I,A = 3. Definition 2.10 (Satisfaction). Let I = D, J be an interpretation for L, A a variable assignment and φ a formula in L. We say that an interpretation I satisfies φ, given the variable assignment A, iff I = A φ, which is inductively defined as follows: I = A p(t 1,..., t n ) iff (t I,A 1,..., t I,A n ) p J I = A and I = A I = A t 1 = t 2 iff t I,A 1 = t I,A 2, for terms t 1,t 2 I = A φ iff I = A φ I = A (φ ψ) iff I = A φ and I = A ψ I = A (φ ψ) iff I = A φ or I = A ψ I = A (φ ψ) iff I = A φ or I = A ψ I = A (φ ψ) iff I = A φ or I = A ψ and I = A ψ or I = A φ I = A xφ iff for every x-variant A of A, I = A φ I = A xφ iff for some x-variant A of A, I = A φ A formula φ is satisfied by an interpretation I, i.e., φ is true in I, written I = φ, iff I = A φ for all variable assignments A. We say a formula φ is valid iff I = φ for every interpretation I. We say a formula φ is satisfiable iff I = φ for some interpretation I. We say I is a model of φ iff I = φ. We say I is a model of an FOL knowledge base Φ iff I = φ for every formula φ Φ. An FOL knowledge base Φ is satisfiable if there is a model I of Φ. Example 2.3. Let Σ be a signature with P = {}, F = {s, add} and C = {zero}. Consider I = N 0, J with J as in the previous example and a variable assignment A with x A = 2. Then I = A add(x, zero) = s(s(zero)) because (add(x, zero)) I,A = (s(s(zero))) I,A evaluates to 2 = 2. I = add(x, zero) = add(zero, x) because of the commutativity of the addition operation on N 0. φ φ is a valid formula. 9

17 Definition 2.11 (Entailment, Logical Consequence). An FOL knowledge base Φ entails a formula φ L, written as Φ = φ, iff for all models I in L for which I = Φ, also I = φ. For Φ = φ we also say that φ is a logical consequence of Φ. An FOL knowledge base Φ entails an FOL knowledge base Ψ iff P hi = ψ for every ψ Ψ. Two FOL knowledge bases Φ and Ψ are equivalent iff Φ = Ψ and Ψ = Φ. Every finite FOL knowledge base Φ is equivalent to the conjunction of its elements. Therefore, a knowledge base may also be interpreted as conjunction of formulas. Note that as long as an FOL knowledge base does not contain open formulae, a variable assignment is not necessary to determine the truth of a formulae. In the remainder of this document we assume every FOL knowledge base Φ consists only of closed formulae, unless indicated otherwise. 2.2 Logic Programming Logic Programming is based on a subset of first-order logic, called Horn Logic 1. However, the semantics of logic programs is based on minimal Herbrand models, rather than first-order models [Llo87, Doe94]. Logic Programming can be extended with default negation under different types of semantics. The most popular ones, which are treated in this section and applied in the following chapters, are the Answer Set Semantics (ASS) [GL91] and the Well-Founded Semantics (WFS) [GRS91]. Definition 2.12 (Extended Rule, Normal Rule). Let Σ = P, F, C be a signature, h, b 1,..., b m, m 0 be literals (as defined in the previous section). An extended rule r is of form h b 1,..., b k, not b k+1,..., not b m, m 0, H(r) = h is called the head of r. B(r) = {b 1,..., b k, not b k+1,..., not b m } is called the body of r. B(r) can be partitioned into B + (r) and B (r), where B + (r) = {b 1,..., b k } and B (r) = {b k+1,..., b m }. The elements of B + (r) are said to occur positively and the elements of B (r) are said to occur (default-)negated in the body of the rule r. An extended rule is not-free if B (r) =. A normal rule (or rule) is an extended rule which only has atoms or default-negated atoms in its body. Therefore, normal rules are extended rules where classical negation does not occur. A positive 1 Horn Logic Programs are sets of Horn rules. A Horn rule is a disjunction of literals with at most one positive literal, i.e., it is of form h 1... h n b (the b is optional), which has the same meaning as h 1... h n b 10

18 rule is an extended rule which is not-free. B(r) =. A fact is an extended rule r with We follow the standard convention in logic programming that requires variables in extended programs to begin with a capital letter. Example 2.4. Let Σ = P, F, C be a signature, where P = ({p, q, u}, F = {f} and C = {a}. Then u(x, f(a)) p(x), q(a), not p(a) is an extended rule r with H(r) = u(x, f(a)), B + (r) = {p(x, a), q(a)} and B (r) = { p(a)}. u(x, f(a)) p(x), q(a), not p(a) is a normal rule. p(x) q(x), u(a, a) is a positive rule. For readability reasons, facts are sometimes denoted without arrows, e.g. in the previous example a rule p(a), may also be written as p(a). Definition 2.13 (Extended Program, Normal Program). Let L be a first-order language. An extended program Π is a finite set of extended rules in L. A normal program (or program) is a finite set of normal rules. An extended program is notfree if all rules are not-free. Therefore, normal programs are not-free extended programs. A positive (or definite) program is a program which consists only of positive rules. The signature of an extended program Π is obtained from all constants, function symbols and predicate symbols which occur in Π. It is obtained from all the constants, function symbols and predicate symbols which occur in Π. An extended program is function-free iff its signature is function-free. In the remainder of this document, we assume that a signature Σ is implicitly given for every extended program and we define Σ by all constant symbols, function symbols and predicate symbols occurring in an extended program, i.e., extended programs are denoted as sets of rules and its signature is defined by all constant, function and predicate symbols occurring in it. Example 2.5. The normal program Π is defined as follows: {p(a) q(x, f(b)), not p(x) ; q(a, b) q(b, a)} is not positive because of its first rule. Its signature Σ = P, F, C is defined by P = {p 1, q 2 }, F = {f 1 } and C = {a, b} because these are the predicate, function and constant symbols with the superscripted arity occurring in Π. Note that there are two different types of negation with a different meaning in extended programs: (i)classical negation ( ), also called explicit negation and (ii) negation as failure ( not ), also called default-negation. Intuitively, for an atom a, not a means a is not believed (i.e., is unknown or false), whereas a means s is false (see, e.g. [She88] for formal differences between the two types of negation and further consequences). We say negative literal, as defined in Definition 2.5, for a classical-negated atom and negated literal or NAF-literal for a default-negated literal. 11

19 2.2.1 Minimal Herbrand model First, we introduce the minimal Herbrand semantics for positive programs and then we extend minimal Herbrand semantics for special subclass of rules with default-negation, so called stratified rules. Definition 2.14 (Herbrand universe). The Herbrand universe of an extended program Π, denoted U Π is the set of all ground terms which can be formed using the constant and function symbols in the signature of Π. Definition 2.15 (Herbrand base). The Herbrand base of an extended program Π, denoted B Π, is the set of all ground atomic literals which can be formed with the predicate symbols in the signature of Π and the terms in U Π, i.e., all formulas of the form: p(t 1,..., t n ) or p(t 1,..., t n ) with p an n-ary predicate symbol in the signature of Π and t 1,..., t n U Π. The Herbrand base of a normal program Π, denoted B Π, is the set of all ground atoms Definition 2.16 (Grounding). The grounding of an extended program Π (or ground instantiation of Π), denoted ground(π), is the ground instantiation of Π, which can be obtained as follows: The ground instantiation of a rule r is the collection of all formulae r[x 1 /t 1,..., x n /t n ] with x 1,..., x n denoting the variables which occur in r and t 1,..., t n ranging over all terms in U Π. The ground instantiation of an extended program ground(π) is defined as the union of the ground instantiation of all rules r Π. For literals l = a (resp., l = a), where a is an atom, we use l to denote a (resp., a) and for sets of literals S, we define S = { l l S} and S + = {a S a is an atom}. A set S B Π is consistent iff S S =. A set S B Π which is not consistent is inconsistent. A literal l is inconsistent with S iff l S. Definition 2.17 (Herbrand interpretation). A Herbrand interpretation I of Π is a consistent subset of B Π. A Herbrand interpretation I of an extended program Π corresponds to a first-order logic interpretation U Π, J where U Π is the Herbrand universe of Π and J satisfies the following conditions: c J = c for every constant symbol c C (f(t 1,..., t n )) I = f(t 1,..., t n ) for very n-ary function symbol f F and ground terms t 1,..., t n. and I = φ iff φ is in the Herbrand interpretation. Herbrand interpretations satisfy the unique-names assumption, i.e., for any two distinct ground terms in the Herbrand universe, their interpretations are distinct as well. 12

20 Definition 2.18 (Herbrand model). Let Π be a positive program. A Herbrand interpretation I of Π is a model of Π iff for every rule h b 1,..., b n ground(π) the following condition holds: If b 1,..., b n I, then h I The intersection of all Herbrand models of a positive program Π is also a model of Π (Model Intersection Property) and is called the minimal Herbrand model. There is also a computational characterization of the minimal Herbrand model based on the least fixpoint of the immediate consequence operator of Π. Definition 2.19 (Fixpoint of operators). An operator T is a function T : P(U) P(U), where P(U) denotes the powerset of a countable set U. An operator T : P(U) P(U) is monotonic iff I J implies T (I) T (J) for all I, J U. A set X U is called a fixpoint of the operator T : P(U) P(U) iff T (X) = X. According to the Fixpoint Theorem of Knaster and Tarski [KM97] each monotonic operator T has a least fixpoint lfp(t ). Moreover if an operator T is continuous 2, then by Kleene s theorem [Doe94], lfp(t ) can be computed as follows: lfp(t ) = T ( ), where T i is inductively defined by T 0 =, T i+1 = T (T i ) for i = 0, 1, All operators considered in this document are monotonic and continuous, therefore the least fixpoint can always be computed in this way. Especially, the minimal Herbrand model of a positive program Π can be characterized as least fix point of the following immediate consequence operator. Definition 2.20 (Immediate Consequence Operator). Let Π be a normal program. The immediate consequence operator T Π is the function T Π : P(B Π ) P(B Π ) defined as follows: { BΠ if X inconsistent T Π (X) = {H(r) r ground(π) and l X for all l B(r)} otherwise Example 2.6. The minimal Herbrand model of the following ground positive program Π p(a) r(a) q(a) p(a), r(a) 2 The notion of continuous operators is not defined formally here, because it is based on the theory of lattices, see e.g. [Llo87] for a formal definition. 13

21 can be computed as follows: T 0 Π = T 1 Π = T Π( ) = {p(a), r(a)} TΠ 2 = T Π(TΠ 1 ) = {p(a), r(a), q(a)} TΠ 3 = T Π (TΠ) 2 = TΠ 2 = TΠ. Thus, lfp(t Π ) = T Π = {p(a), r(a), q(a)} is the minimal Herbrand model of Π. Minimal Herbrand models can also be defined for an extended program Π with default negation: A Herbrand interpretation I of Π is a model of Π iff for every rule h b 1,..., b k, not b k+1,..., not b n ground(π) the following condition holds: If b 1,..., b k I and b k+1,..., b n I, then h I But, as the following example shows, the minimal Herbrand model for extended programs is not unique any more. Example 2.7. The following extended program r(a) (2.1) q(x) not p(x), r(x) (2.2) p(x) not q(x), r(x) (2.3) has two minimal Herbrand models: {r(a), q(a)} and {r(a), p(a)}. minimal Herbrand model is not unique. Hence, the The least fixpoint computation of the extension of the immediate consequence operator for extended programs, T Π : P(B Π) P(B Π ), defined as follows: B Π if X inconsistent T Π (X) = {H(r) r ground(π), l X if l B + (r) and l X if l B (r)} otherwise does not compute minimal Herbrand models in general because, e.g. in Example 2.7, {r(a), p(a), q(a)} is a fixpoint of T Π but not a minimal Herbrand model of Example 2.7. Note that for stratified programs, which are a subset of extended programs, the fixpoints of the extended consequence operator T Π are minimal Herbrand models. 14

22 Definition 2.21 (Stratification). A stratification of a normal program Π is a mapping function λ : B Π {0, 1,..., k} such that (i) λ(h(r)) λ(l) for each r ground(π) and l B + (r) (ii) λ(h(r)) > λ(l) for each r ground(π) and l B (r) An extended program Π is stratified iff it has a stratification λ of some length k 0. Example 2.8. The following extended program p(a) r(a) q(x) not p(x), r(x) is stratified because there exists a mapping function λ defined as follows λ(p(a)) = 0, λ(r(a)) = 0, λ(q(a)) = 1. Thus, the minimal Herbrand model can be computed via the extended fixpoint operator and it is {p(a), r(a)}. The extended program in Example 2.7 is not stratified because for a mapping function both λ(q(a)) > λ(p(a)) (according to rule (2.2)) and λ(p(a)) > λ(q(a)) (according to rule (2.3)) must hold, which is not possible. We make use of the definition and computation of minimal Herbrand models in the definitions of answer set and well-founded semantics in Subsections and 2.2.3, but also in the definitions of the semantics of dl-programs in Chapter 4 and fol-programs in Chapter Answer Set Semantics Our treatment of the answer set semantics (ASS) of extended programs follows the original definitions in [GL91]. The underlying ideas of ASS have originally been applied to normal program as stable model semantics (SMS) [GL88]. For normal programs ASS coincides with SMS in the sense that the same set of models is generated. ASS is defined for ground extended programs. Therefore, ASS for arbitrary extended programs Π is defined for its grounding ground(π). We first define Gelfond-Lifschitz transform which transforms an extended program to a positive program. Definition 2.22 (Gelfond-Lifschitz transform). Let Π be an extended program and I B Π. The Gelfond-Lifschitz transform of Π with respect to I, denoted Π I, is obtained from ground(π) by: (i) Deleting each rule r with B (r) I (ii) Deleting the negative body from every remaining rule 15

23 The Gelfond-Lifschitz transform of Π is also called the reduct of Π. Clearly, Π I doesn t contain not, and is therefore a positive logic program which has a unique minimal model used for defining the notion of an answer set of an extended program. Definition 2.23 (Answer Set). Let Π be an extended program. An answer set of Π is an interpretation I B Π such that I is the minimal model of Π I. The following example illustrates the computation of answer sets. Example 2.9. Consider the following normal program Π: p(a) not q(a) q(a) not p(a) Π has two answer sets: {p(a)} and {q(a)}. We can see this as follows: Let I = {p(a)} be an interpretation. The Gelfond-Lifschitz transform Π {p(a)} is p(a). Now, clearly, I is the answer set of Π {p(a)}. Similar for I = {q(a)}. Finally, we define entailment for the answer set semantics. Due to the fact that each normal program may have zero or more answer sets, there are different approaches for defining entailment in answer set semantics. We consider cautious and brave entailment. Definition 2.24 (Cautious Entailment). An extended program Π cautiously entails a ground atomic formula a iff a I for every answer set I of Π. Definition 2.25 (Brave Entailment). An extended program Π bravely entails a ground atomic formula a iff a I for some answer set I of Π. In the remainder of this document, whenever talking about entailment under the answer set semantics we mean cautious entailment, unless specified otherwise Well-Founded Semantics There exist several approaches to well-founded semantics, e.g. [Prz90, Fit91, BS91, GRS91]. Because there is no consensus on how to define well-founded semantics for extended programs, we restrict ourselves to the definition of wellfounded semantics for normal programs. We follow the classical definition of well-founded semantics for normal programs from [GRS91]. Therefore, we first define the notion of an unfounded set, which provides the basis for negative conclusions in the well-founded semantics. 16

24 Definition 2.26 (Partial and Total Interpretation). Let Π be a normal program and B Π its Herbrand base. A partial interpretation of Π, or three-valued interpretation, I is a consistent subset of B Π. A total interpretation of Π, or two-valued interpretation, is a partial interpretation of Π that contains every atom of B Π or its negation. A literal is true in I when it is in I, it is false in I when its complement is in I and we say, it is undefined in I when neither the literal nor its negation is in I. Definition 2.27 (Unfounded Set). Let Π be a normal program, B Π its Herbrand base and I a partial interpretation. U B Π is an unfounded set of Π with respect to I, iff for every h U and every rule r ground(π) with H(r) = h, either (i) b I U for some atom b B + (r), (ii) b I for some atom b B (r). In order to define the well-founded semantics, we introduce three operators (see previous subsection for its definition), also called transformations in this context. Definition For a ground normal program Π and a partial interpretation I B Π we define the transformations T Π : P(B Π ) P(B Π ), U Π : P(B Π ) P(B Π ) and W Π : P(B Π ) P(B Π ) as follows: T Π (I) = {H(r) r Π, B + (r) B (r) I}, i.e., h T Π (I) iff there is some rule r Π with head h and each literal in the body of r is true in I. U Π (I) is the greatest unfounded set of Π with respect to I, which is the union of all sets which are unfounded with respect to I W Π (I) = T Π (I) U Π (I) W Π is monotonic, thus we can define the well-founded semantics of a normal program Π by the least fixpoint of W Π. Definition 2.29 (Well-Founded model). The least fixpoint of W Π, is the wellfounded model of Π, denoted W F M(Π). According to the previous subsection the least fixpoint of W Π can be computed as follows, lfp(w Π ) = W Π ( )3 In case, lfp(w Π ) B Π is a total interpretation of Π, then lfp(w Π ) is a total well-founded model. An atom a B Π is well-founded (resp., unfounded) w.r.t. Π iff a (resp., a) is in lfp(w Π ). WFS is defined for ground normal programs. Therefore, WFS for arbitrary normal programs Π is defined for its grounding ground(π). Finally, we define entailment for the well-founded semantics of normal programs. 3 It is in general not guaranteed that the least fixpoint is finite; thus the computation may never terminate. 17

25 Definition 2.30 (Entailment). A normal program Π entails a ground atom b under the well-founded semantics, denoted Π = b, if it is true in W F M(Π). Example Consider the following normal program Π: p(a) not q(a) q(a) not p(a) Π has one well-founded model in which both p(a) and q(a) are undefined. There are two important distinctions between the answer set semantics for normal programs, also called stable model semantics, and the well-founded semantics as defined in this subsection: (1) the well-founded semantics is threevalued (true, false, undefined), whereas the answer set semantics is two-valued (true, false) and (2) every normal program has exactly one well-founded model, whereas every normal program has zero or more answer sets. There are, however, also commonalities. The following are some of the results which have been obtained from [GRS91] about the relationship between stable model semantics and well-founded semantics. Proposition 2.1 (from [GRS91]). Every stratified normal program Π has a total well-founded model W F M(Π). W F M(Π) is also the unique answer set of Π. Proposition 2.2 (from [GRS91]). If a normal program Π has a total well-founded model W F M(Π), W F M(Π) is also the unique answer set of Π. 2.3 Description Logics Description Logics (DLs) [BCM + 03, BS01, CGLN01] are a family of knowledge representation languages that can be used to represent the knowledge of an application domain in a structured and formally well-understood way. The name description logics is motivated by the fact that, on the one hand, the important notions of the domain are described by concept descriptions, i.e., expressions that are built from atomic concepts (unary predicates) and atomic roles (binary predicates) using the concept and role constructors provided by the particular DL. On the other hand, DLs differ from their predecessors, such as semantic networks and frames, in that they are equipped with a formal, logic-based semantics [BHS03]. Basic description logics differ in the constructors and axioms, they provide for modelling knowledge. In this section, we give formal definitions of the syntax and semantics of the rather expressive Description Logic SHOIN which is also of practical relevance because it is the Description Logic underlying OWL DL [HPS03]. Let A, R and I be nonempty finite and pairwise disjoint sets of atomic concepts, atomic roles and individuals. We use R to denote the set of all inverse R of atomic roles R R. 18

26 A role in the DL SHOIN is an element of R R. A Concept description in the DL SHOIN is inductively defined as follows: Let C,D be concept descriptions, A an atomic concept, R an atomic role, o 1,... o n individuals and n a nonnegative integer. C,D A (atomic concept) (top) (bottom) (C D) (intersection) (C D) (union) C (negation) R.C (exists restriction) R.C (value restriction) nr (atleast restriction) nr (atmost restriction) {o 1,..., o n } (oneof ) R.{o} (hasvalue) We now define axioms in SHOIN which allow the expression of relations between concepts, roles and individuals. Definition 2.31 (Axiom). Let C,D be concepts, R,S be roles and a,b individuals. An axiom in the DL SHOIN is an expression of the following form: (1) C D (concept equivalence) (2) R S (role equivalence) (3) C D (concept inclusion) (4) R S (role inclusion) (5) T rans(r) (role transitivity) (6) C(a) (concept membership) (7) R(a, b) (role membership) (8) a = b, resp. a b (equality, resp. inequality) Due to different reasoning tasks and their optimized implementation, axioms are partitioned into terminological axioms and assertional axioms [BCM + 03, DL96]. Terminological axioms are about general properties of concepts and roles. In the previous list of axiom definitions (1)-(5) are terminological axioms. Assertional axioms comprise assertions on individual objects. In the previous list of axiom definitions (6)-(8) are assertional axioms. In Description Logic Systems 19

27 like Racer [HM01], reasoning on terminological axioms is implemented in a so called TBox and reasoning on assertional axioms is implemented in a so called ABox. The separation into a TBox and an ABox has no logical significance but may be conceptually and implementationally convenient. We now define Description Logic Knowledge Bases as finite sets of DL-axioms and give an example. Definition 2.32 (Description Logic Knowledge Base). A Description Logic Knowledge Base L in a Description Logic DL, denoted L DL, is a finite set of DL-axioms. A Description Logic Knowledge Base L, denoted DL-knowledge base, is a Description Logic Knowledge Base in any DL. This term is used whenever the underlying DL is not relevant, e.g. when defining dl-programs in Chapter 4. Example The following knowledge base from [ELST04b] in the description logic SHOIN models a small computer store that obtains its hardware from several vendors. It uses the following set of axioms in SHOIN which contain information about the product range that is provided by each vendor and about possible rebate conditions (we assume here that choosing two or more parts from the same seller causes a discount). For some parts a shop may already be contracted as a supplier. Let A = {P art, Shop} be a set of atomic concepts, R = {provides, supplier} be a set of atomic roles and I = {harddisk, cpu, case, s 1, s 2, s 3 } be a set of individuals. 1supplier Shop supplier.p art 2supplier Discount P art(harddisk) P art(cpu) P art(case) Shop(s 1 ) Shop(s 2 ) Shop(s 3 ) provides(s 1, case) provides(s 2, cpu) provides(s 3, case) provides(s 1, cpu) provides(s 2, harddisk) provides(s 3, harddisk) supplier(s 3, case) We will revisit this example in Chapter 6 and test it on our implementation of fol-programs. We now define a the semantics of SHOIN by analogy to the semantics of first-order logic via the concepts of an interpretation and the satisfaction relation. Definition 2.33 (Interpretation). An interpretation of a Description Logic DL is a pair I =, I where is a nonempty set, called the (abstract) domain, and I is a mapping, called the interpretation function of the DL, which assigns to each atomic concept from A a subset of, to each individual o I an element of and to each atomic role from R a subset of. The mapping function 20

28 I of a DL is extended by induction to all concept and role definitions of that DL. For the DL SHOIN this extension is defined as follows: ({o 1,..., o n }) I = {o I 1,..., oi n } ( R.{o}) I = {x x, o I R I } (C D) I = C I D I (C D) I = C I D I ( C) I = \ C I ( R.C) I = {x y x, y R I y C I } ( R.C) I = {x y x, y R I y C I } ( nr) I = {x #{ x, y R I } n} ( nr) I = {x #{ x, y R I } n} (R ) I = { b, a a, b R I }, where C and D are concepts, R,S are roles and o 1,..., o n are individuals, n is a nonnegative integer and #S denotes the cardinality of a set S. Definition 2.34 (Satisfaction). Let I =, I be an interpretation for a Description Logic DL. The satisfaction relation is defined for all DL-axioms F, denoted I = F. For SHOIN the satisfaction relation is defined as follows: I = C D iff C I = D I I = R S iff R I = S I I = C D iff C I D I I = R S iff R I S I I = T rans(r) iff R I is transitive I = C(a) iff a I C I I = R(a, b) iff a I, b I R I I = a = b iff a I = b I I = a b iff a I b I An interpretation I of a DL satisfies the axiom F, or I is a model of F, iff I = F. I satisfies a DL knowledge base L, or I is a model of L, denoted I = L, iff I = F for all F L. We say L is satisfiable (resp., unsatisfiable) iff L has a (resp., no) model. An axiom F is a logical consequence of L, denoted L = F, iff every model of L satisfies F. A negated axiom F is a logical consequence of L, denoted L = F, iff every model of L does not satisfy F. 21

29 From the previous definitions, one can immediately derive a number of (so called standard) inference problems for DL systems that are commonly studied. Concept Satisfiability, i.e., a concept C is satisfiable with respect to a DL knowledge L if there exists a model I of L such that C I is nonempty. Concept Subsumption, i.e., a concept C is subsumed by a concept D with respect to a DL knowledge base L if C I D I for every model I of L. Concept subsumption can be reduced to concept satisfiability [BCM + 03]. Knowledge Base Satisfiability, i.e., a DL knowledge base L is satisfiable if there is an interpretation of L which is a model of L. Instance Checking,i.e., given a DL knowledge base L, then an individual o is an instance of a concept C if o I C I for every model I of L. As shown in [BCM + 03] the inference problems of concept satisfiability, concept subsumption and instance checking can be reduced a check of knowledge base (un)satisfiability. In all description logics introduced so far, knowledge must be represented on the abstract logical level. In many applications, one would like to be able to refer to concrete domains and predefined predicates on these domains when defining concepts. An example of such a concrete domain could be the set of nonnegative integers, with predicates such as or <. The extension of a DL by a concrete domain D is denoted by adding (D) to the name of a DL, e.g. SHOIN (D), which corresponds to the ontology language OWL DL. Description Logics with concrete domains still have a formal declarative semantics and there exist appropriate reasoning algorithms for DLs with concrete domains [BCM + 03, HMW01]. Most DLs are similar to 2-variable fragment of function-free FOL [Bor96], because concepts correspond to unary predicates, roles correspond to binary predicates and there are no more than two variables under the scope of a quantifier an exception are transitive properties, which have three variables. 2.4 Decidability and Undecidability In this section, we give an informal overview of the most important decidability and undecidability results 4 for first-order logic, logic programming and description logics which are referred to in the remainder of this document. Intuitively, a property (relation), represented by a subset A of all possible problem instances B, is decidable if there is a decision procedure for membership 4 see, e.g. [HMU00] for a formal approach to decidability based on Turing machines and e.g. [Coo04] for a formal approach to decidability based on µ-recursive functions. 22