Inductive Logic Programming in Databases: from Datalog to DL+log

Inductive Logic Programming (ILP) has been historically concerned with the induction of rules from examples for classification purposes (Nienhuys-Cheng and de Wolf 1997). Due to the close relation between Logic Programming and Relational Databases (Ceri et al. 1990), ILP has established itself as a major approach to Relational Data Mining (Džeroski and Lavrač 2001). Indeed, Datalog (Ceri et al. 1989) is the most widely used Knowledge Representation (KR) framework in ILP. Conversely, interesting extensions of Datalog such as Datalog ¬∨ (Eiter et al. 1997) have attracted very little attention in ILP. Some effort has been made also at making ILP more able to face the challenges posed by Relational Data Mining applications, e.g. scalability (Blockeel et al. 1999). However the actual added value of ILP with respect to far more efficient approaches still remains the use of prior conceptual knowledge (also known as background knowledge, or shortly BK) during the learning process which enables the induction of conceptually meaningful rules. Yet, the BK in ILP is often not organized around a well-formed conceptual model. This practice seems to ignore the latest achievements in conceptual modeling such as ontologies. In Artificial Intelligence, an ontology refers to an engineering artifact (more precisely, produced according to the principles of Ontological Engineering (Gómez-Pérez et al. 2004)), constituted by a specific vocabulary used to describe a certain reality, plus a set of explicit assumptions regarding the intended meaning of the vocabulary words. This set of assumptions has usually the form of a first-order logical (FOL) theory, where vocabulary words appear as unary or binary predicate names, respectively called concepts and relations. More formally, an ontology is a formal explicit specification of a shared conceptualization for a domain of interest (Gruber 1993). Among the other things, this definition emphasizes the fact that an ontology has to be specified in a language that comes with a formal semantics. Only by using such a formal approach ontologies provide the machine interpretable meaning of concepts and relations that is expected when using an ontology-based approach. Among the formalisms proposed by Ontological Engineering, the most currently used are Description Logics (DLs) (Baader et al. 2007). In particular, the advent of the Semantic Web (Berners-Lee et al. 2001) has given a tremendous impulse to research on DL-based ontology languages. Indeed the DL SHIQ (Horrocks et al. 2000) has been the starting point for the definition of the W3C standard mark-up language OWL (Horrocks et al. 2003). Note that DLs are decidable fragments of FOL that are incomparable with Clausal Logics (CLs) as regards the expressive power (Borgida 1996) and the semantics (Rosati 2005b). Yet, DLs and CLs can be combined according to some limited forms of hybridization. E.g., DL+log ¬∨ is a general KR framework that allows for the tight integration of DLs and Datalog ¬∨ by imposing the condition of weak DL-safeness on hybrid rules (Rosati 2006) 1 . We argue that the adoption of such hybrid KR systems can help overcoming the current difficulties in accommodating ontologies in ILP. In this paper we address an issue that has been brought to the attention of the database community with the advent of the Semantic Web, i.e. the issue of how ontologies (and semantics conveyed by them) can help solving typical database problems, through a better understanding of KR aspects related to databases. In particular, we investigate this issue from the ILP perspective by considering two database problems: • the definition of views • the definition of constraints for a database whose schema is represented also by means of an ontology. Both can be reformulated as ILP problems and can benefit from the expressive and deductive power of the KR framework DL+log ¬∨ , mainly from its nonmonotonic (NM) features. We illustrate the application scenarios by means of examples. The paper is organized as follows. Section 2 provides basic notions on DLs, a short Table 1. Syntax and semantics of some typical DL constructs. bottom (resp. top) concept ⊥ (resp. ⊤) ∅ (resp. ∆ I ) atomic concept summary of KR research on the integration of DLs and CLs, and a brief introduction to ILP. Section 3 introduces syntax, semantics and reasoning of DL+log ¬∨ . Section 4 and Section 5 define the ILP proposals for inducing database views and database constraints, respectively, within the DL+log ¬∨ framework. Section 6 surveys related work. Section 7 concludes the paper with final remarks. DLs are a family of decidable FOL fragments that allow for the specification of knowledge in terms of classes (concepts), instances (individuals), and binary relations between instances (roles) (Borgida 1996). Complex concepts can be defined from atomic concepts and roles by means of constructors. Syntax and semantics of some typical DL constructs are reported in Table 1. E.g., concept descriptions in the basic DL AL are formed according to only the constructors of atomic negation, concept conjunction, value restriction, and limited existential restriction. The DLs ALC and ALN are members of the AL family. The former extends AL with (arbitrary) concept negation (also called complement and equivalent to having both concept union and full existential restriction), whereas the latter with number restriction. The DL ALCN R adds to the constructors inherited from ALC and ALN a further one: role intersection. Conversely, in the DL SHIQ (Horrocks et al. 2000) it is allowed to invert roles and to express qualified number restrictions of the form ≥ nR • C and ≤ nR • C where R is a simple role. Also transitivity holds for roles. A role (expression) is called complex if it contains any role operations other than inversion, e.g. role intersection. A DL knowledge base (KB) Σ can state both is-a relations between concepts (axioms) and instance-of relations between individuals (resp. couples of individuals) and concepts (resp. roles) (assertions or facts). Axioms form the so-called terminological box (TBox) T whereas facts are contained in the so-called assertional box (ABox) A. A SHIQ KB encompasses also a role box (RBox) R which consists of a finite set of role equivalence and role inclusion axioms. Therefore hierarchies can be defined over not only concepts but also roles. Transitivity of roles is also specified by means of axioms. Thus, when a DL-based ontology language is adopted, an ontology is nothing else than a TBox, possibly together with a RBox. If the ontology is populated, it corresponds to a whole DL KB, i.e. encompassing also an ABox. The semantics of DLs can be defined directly with set-theoretic formalizations as shown in Table 2 or through a mapping to FOL as shown in (Borgida 1996). An interpretation I = (∆ I , • I ) for a DL KB consists of a domain ∆ I and a mapping function • I . Under the Unique Names Assumption (UNA) (Reiter 1980), individuals are mapped to elements of ∆ I such that a I = b I if a = b. Yet UNA does not hold by default in DLs. Thus individual equality (inequality) assertions may appear in a DL KB (see Table 2). An interpretation I is a model of a KB Σ = (T , A) iff it satisfies all axioms and assertions in T and A . Also the KB represents many different interpretations, i.e. all its models. This is coherent with the Open World Assumption (OWA) that holds in FOL semantics. A DL KB is satisfiable if it has at least one model. An ABox assertion α is a logical consequence of a KB Σ, written Σ |= α, if all models of Σ are also models of α. The main reasoning task for a DL KB Σ is the consistency check which tries to prove the satisfiability of Σ. The consistency check is performed by applying decision procedures mostly based on tableau calculus. Another well known reasoning service in DLs is instance check, i.e., the check of whether an ABox assertion is a logical implication of a DL KB. A more sophisticated version of instance check, called instance retrieval, retrieves, for a DL KB Σ, all (ABox) individuals that are instances of the given (possibly complex) concept expression C , i.e., all those individuals a such that Σ entails that a is an instance of C . In data-intensive applications, querying KBs plays a central role. Instance retrieval is, in some aspects, a rather weak form of querying: although possibly complex concept expressions are used as queries, we can only query for tree-like relational structures, i.e., a DL concept cannot express arbitrary cyclic structures. The possibility of expressing conjunctive queries (CQ) and unions of conjunctive queries (UCQ) is widely studied in DLs. Let P C and P R be the alphabets of concept names and role names, respectively. A Boolean UCQ over the alphabet P C ∪ P R is a FOL sentence of the form q 1 ∨ . . . ∨ q n , where each q i is a conjunction ∃ X conj i ( X ) of atoms whose predicates are in P C ∪ P R and whose arguments are either constants or variables from the tuple X . A Boolean CQ corresponds to a Boolean UCQ in the case when n = 1. The Boolean UCQ entailment problem in DLs is defined as follows: A KB Σ entails a UCQ Q = q 1 ∨ . . . ∨ q n , written as Σ |= q 1 ∨ . . . ∨ q n , if, for every model I of Σ, there is some i such that q i is satisfied in I and 1 ≤ i ≤ n. Note that instance check can be expressed as the problem of query entailment problem of a Boolean CQs constituted by just one ground atom. The Boolean CQ/UCQ containment problem2 in DLs is defined as follows: Given a DL-TBox T , a Boolean CQ Q 1 and a Boolean UCQ Q 2 over the alphabet This problem has been proved decidable for many DLs, notably for the very expressive SHIQ (Glimm et al. 2008) and SHOQ (Glimm et al. 2008). Finally, when the UNA does not hold, it can be immediately reduced to the Boolean UCQ entailment problem (Calvanese et al. 2008). In the rest of the paper we shall consider DLs without UNA. The integration of ontologies and relational databases follows the tradition of KR research on hybrid systems, i.e. those systems which are constituted by two or more subsystems dealing with distinct portions of a single KB by performing specific reasoning procedures (Frisch and Cohn 1991). The motivation for investigating and developing such systems is to improve on two basic features of KR formalisms, namely representational adequacy and deductive power, by preserving the other crucial feature, i.e. decidability. Those KR systems that integrate ontologies and relational databases will be referred to as DL-CL hybrid KR systems in the rest of the paper. They implement different solutions to the problem of combining DLs and CLs. Indeed DLs and CLs are FOL fragments incomparable as for the expressiveness (Borgida 1996) and the semantics (Rosati 2005a) but combinable at different degrees of integration. The integration is said to be tight when a model of the hybrid KB is defined as the union of two models, one for the DL part and one for the CL part, which share the same domain. In particular, combining DLs with CLs in a tight manner can easily yield to undecidability if the interaction scheme between the DL and the CL part of a hybrid KB does not fulfill some condition of safeness (Rosati 2005b). Indeed safeness allows to solve the semantic mismatch between DLs and CLs, namely the OWA for DLs and the CWA for CLs3 . In the following we shall briefly describe two exemplary cases of tightly-integrated DL-CL hybrid KR systems: AL-log (Donini et al. 1998) and Carin (Levy and Rousset 1998). The former is safe whereas the latter is not. AL-log (Donini et al. 1998) is a hybrid KR system that integrates ALC (Schmidt-Schauss and Smolka 1991) and Datalog (Ceri et al. 1989). In particular, variables occurring in the body of rules may be constrained with ALC concept assertions to be used as 'typing constraints'. This makes rules applicable only to explicitly named objects. A further restriction is that only Datalog atoms are allowed in rule heads. Reasoning for AL-log knowledge bases is based on constrained SLD-resolution, i.e. an extension of SLD-resolution with a tableau calculus for ALC to deal with constraints. Constrained SLD-resolution is decidable and runs in single non-deterministic exponential time. Constrained SLD-refutation is a complete and sound method for answering ground queries, i.e. conjunctions of ground Datalog atoms and ALC concept assertions. A comprehensive study of the effects of combining DLs and CLs can be found in (Levy and Rousset 1998). Here the family Carin of hybrid languages is presented. Special attention is devoted to the DL ALCN R. The results of the study can be summarized as follows: (i) answering CQs over ALCN R TBoxes is decidable, (ii) query answering in a logic obtained by extending ALCN R with non-recursive Datalog rules, where both concepts and roles can occur in rule bodies, is also decidable, as it can be reduced to answering a UCQ, (iii) if rules are recursive, query answering becomes undecidable, (iv) decidability can be regained by disallowing certain combinations of constructors in the logic, and (v) decidability can be regained by requiring rules to be role-safe, where at least one variable from each role literal must occur in some non-DL-atom. As in AL-log, query answering is decided using constrained resolution and a modified version of tableau calculus. Inductive Logic Programming (ILP) was born at the intersection between Logic Programming and Concept Learning (Muggleton 1990). From Logic Programming it has borrowed the KR framework, i.e. Horn Clausal Logic (HCL). From Concept Learning it has inherited the inferential mechanisms for induction, the most prominent of which is generalization. Concept Learning is concerned with the problem of automatically inducing the general definition of some concept (called target), given examples labeled as instances or noninstances of the concept. In ILP the target is the predicate whose definition is returned by the inductive learning process as a hypothesis. The definition may consist of one or more clauses. A distinguishing feature of ILP with respect to other forms of Concept Learning is the use of prior knowledge of the domain of interest, called background knowledge (BK). Therefore, induction with ILP generalizes from individual instances/observations in the presence of BK, finding valid hypotheses. Validity depends on the underlying setting. At present, there exist several formalizations of induction in ILP that can be classified according to the following two orthogonal dimensions: the scope of induction (discrimination vs characterization) and the representation of observations (ground definite clauses vs ground unit clauses) (De Raedt and Dehaspe 1997). Discriminant induction aims at inducing hypotheses with discriminant power as required in tasks such as classification where observations encompass both positive and negative examples. Characteristic induction is more suitable for finding regularities in a data set. This corresponds to learning from positive examples only. For a thorough discussion of differences between discriminant and characteristic induction see (Michalski 1983). The second dimension affects the notion of coverage, i.e. the condition under which a hypothesis explains/confirms an observation. In learning from entailment (also called normal or explanatory ILP setting), hypotheses are clausal theories, observations are ground definite clauses, and a hypothesis covers an observation if the hypothesis logically entails the observation (Frazier and Pitt 1993). In learning from interpretations (also called nonmonotonic or confirmatory ILP setting), hypotheses are clausal theories, observations are Herbrand interpretations (ground unit clauses) and a hypothesis covers an observation if the observation is a model for the hypothesis (De Raedt and Džeroski 1994). Summing up, when learning from entailment with the aim of discrimination, a hypothesis is valid (or correct) if it logically entails all positive examples and none of the negative examples. The former condition of validity is called completeness, whereas the latter is referred to as consistency. If the scope of induction is characterization, the condition of consistency is dropped out from the notion of validity due to the absence of negative examples. The two settings for the case of learning from interpretations can be defined similarly. In Concept Learning, thus in ILP, generalization is traditionally viewed as search through a partially ordered space of inductive hypotheses (Mitchell 1982). According to this vision, an inductive hypothesis is a clausal theory and the induction of a single clause requires (i) structuring, (ii) searching and (iii) bounding the space of clauses (Nienhuys-Cheng and de Wolf 1997). First we focus on (i) by clarifying how the algebraic notion of ordering can be applied to clauses. A generality relation allows for determining which one, between two clauses, is more general than the other. It defines a pre-order (or quasi order) on the set of clauses, i.e. a partially-ordered set of equivalence classes. One such ordering is θ-subsumption (Plotkin 1970): Given two clauses C and D , we say that F.A. Lisi C θ-subsumes D if there exists a substitution θ, such that C θ ⊆ D4 . Given the usefulness of BK, orders have been proposed that reckon with it. Among them is relative subsumption (Plotkin 1971): Given two clauses C and D and a clausal theory K, we say that C subsumes D relative to K if there exists a substitution θ such that K |= ∀(C θ ⇒ D ). Also, generalized subsumption (Buntine 1988) is of interest to this paper: Given two definite clauses C and D standardized apart5 and a definite program K, we say that C subsumes D w.r.t. K iff there exists a ground substitution θ for C such that (i) head (C )θ = head (D )σ and (ii) K ∪ body(D )σ |= body(C )θ where σ is a Skolem substitution6 for D with respect to {C } ∪ K. In the general case, generalized subsumption is undecidable and does not introduce a lattice7 on a set of clauses. Because of these problems, θ-subsumption is more frequently used in ILP systems. Yet for Datalog generalized subsumption is decidable and admits a least general generalization. Once structured according to a generality order, the space of hypotheses can be searched (ii) by means of refinement operators. A refinement operator is a function which computes a set of specializations or generalizations of a clause according to whether a top-down or a bottom-up search is performed. The two kinds of refinement operator have been therefore called downward and upward, respectively. A good refinement operator should satisfy certain desirable properties (van der Laag 1995). We shall illustrate these properties for the case of downward refinement operators but analogous conditions are actually required to hold for the upward ones as well. Ideally, a downward refinement operator should compute only a finite set of specializations of each clause -otherwise it will be of limited practical use. When it accomplishes this condition, it is called locally finite. Furthermore, it should be complete: every specialization should be reachable by a finite number of applications of the operator. Finally, it is better only to compute proper specializations of a clause, for otherwise repeated application of the operator might get stuck in a sequence of equivalent clauses, without ever achieving any real specialization. Operators that satisfy all these conditions simultaneously are called ideal. It has been shown that ideal refinement operators do not exist for both full and Horn clausal languages ordered by either subsumption or the stronger orders (e.g. implication). In order to define a refinement operator for full clausal languages, it is necessary to drop one of the three properties of idealness. Since local finiteness and completeness are usually considered the most important among these properties, this means that locally finite and complete, but improper refinement operators can be defined for full clausal languages. On the other hand, in order to retain all the three properties of idealness, it seems that the only possibility is to restrict the search space. Hence, the definition of refinement operators is usually coupled with the specification of a declarative bias for bounding the space of clauses (iii). Bias concerns anything which constrains the search for theories, e.g. a language bias specifies syntactic constraints on the clauses in the search space. One such constraint is connectedness: A clause C is connected if each variable occurring in head (C ) also occurs in body(C ). The constraint of linkedness is also widely used one of its terms is linked. A term t in some literal l i ∈ C is linked with linking-chain of length 0, if t occurs in head (C ), and with linking-chain of length d + 1, if some other term in l i is linked with linking-chain of length d . The link-depth of a term t in l i is the length of the shortest linking-chain of t . The KR framework of DL+log ¬∨ (Rosati 2006) allows for the tight integration of DLs (Baader et al. 2007) and Datalog ¬∨ (Eiter et al. 1997). More precisely, it allows a DL KB to be extended with Datalog ¬∨ rules according to the so-called weak safeness condition as shown in the following. Formulas in DL+log ¬∨ are built upon three mutually disjoint predicate alphabets: an alphabet P C of concept names, an alphabet P R of role names, and an alphabet P D of Datalog predicates. We call a predicate p a DL-predicate if either p ∈ P C or p ∈ P R . Then, we denote by N a countably infinite alphabet of constant names. An atom is an expression of the form p( X ), where p is a predicate of arity n and X is a n-tuple of variables and constants. If no variable symbol occurs in X , then p( X ) is called a ground atom (or fact). If p ∈ P C ∪ P R , the atom is called a DL-atom, while if p ∈ P D , it is called a Datalog atom. Given a description logic DL, a DL+log ¬∨ KB B is a pair (Σ, Π), where Σ is a DL KB and Π is a set of Datalog ¬∨ rules, where each rule R has the form ) is an atom and: • each p i is either a DL-predicate or a Datalog predicate; • each r j , u k is a Datalog predicate; • each s l is a DL-predicate; • (Datalog-safeness) every variable occurring in R must appear in at least one of the atoms r 1 ( Y 1 ), . . . , r m ( Y m ), s 1 ( Z 1 ), . . . , s k ( Z k ); • (weak DL-safeness) every head variable of R must appear in at least one of the atoms r 1 ( Y 1 ), . . . , r m ( Y m ). We remark that the condition of weak DL-safeness allows for the presence of variables that only occur in DL-atoms in the body of R. This condition allows to overcome the main representational limits of the safe approaches by keeping the integration scheme still decidable. Indeed, the notion of DL-safeness proposed in (Motik et al. 2005) can be expressed as follows: every variable of R must appear in at least one of the atoms r 1 ( Y 1 ), . . . , r m ( Y m ). Therefore, DL-safeness forces every variable of R to occur also in the Datalog atoms in the body of R. This disables the possibility of expressing CQs and UCQs. By weakening the DL-safeness condition, this possibility can be enabled. For these reasons, DL+log ¬∨ is located between AL-log and Carin along the expressivity line. Without loss of generality, we can assume that in a DL+log ¬∨ KB (Σ, Π) all constants occurring in Σ also occur in Π. Let us consider a DL+log ¬∨ KB B (adapted from (Rosati 2006)) integrating the following DL-KB Σ (ontology about persons) For DL+log ¬∨ two semantics have been defined: a FOL semantics and a NM semantics. The FOL semantics does not distinguish between head atoms and negated body atoms. Thus, the rule (1) is equivalent to: The NM semantics is based on the stable model semantics of Datalog ¬∨ . According to it, DL-predicates are still interpreted under OWA, while Datalog predicates are interpreted under CWA. Notice that, under both semantics, entailment can be reduced to satisfiability, since it is possible to express constraints in the Datalog program. In particular, it is immediate to verify the following theorem on ground query answering (Rosati 2006). Theorem 1 Given a DL+log ¬∨ KB (Σ, Π) and a ground atom α, (Σ, Π) |= α iff (Σ, Π∪{← α}) is unsatisfiable. Analogously, CQ answering can be reduced to satisfiability in Datalog ¬∨ , more precisely it can be performed by means of multiple satisfiability tests. Consequently, Rosati (2006) concentrates on the satisfiability problem in DL+log ¬∨ KBs. It has been shown that, when the rules are made out of Datalog ∨ (i.e., without negated atoms), the above two semantics are equivalent with respect to the satisfiability problem. In particular, FOL-satisfiability can always be reduced (in linear time) to NM-satisfiability by rewriting rules from the form (1) to the form (2). Hence, only the satisfiability problem under the NM semantics is deeply treated in (Rosati 2006). With reference to Example 1, it can be easily verified that all NM-models for B satisfy the following ground atoms: 1. boy(Paul) (since rule [R1] is always applicable for {X/Paul} and [R1] acts like a default rule, which can be read as follows: if X is a person enrolled in course c1, then X is a boy, unless we know for sure that X is a girl); 2. girl(Mary) (since rule [R2] is always applicable for {X/Mary}); 3. boy(Bob) (since rule [R3] is always applicable for {X/Bob}, and, by rule [R4], the conclusion girl(Bob) is inconsistent with Σ); 4. MALE(Paul) (due to rule [R5] and conclusion 1); 5. FEMALE(Mary) (due to rule [R4] and conclusion 2). Notice that B |= NM FEMALE(Mary), while Σ |= FOL FEMALE(Mary). In other words, adding rules has indeed an effect on the conclusions one can draw about DLpredicates. Moreover, such an effect also holds under the FOL semantics of DL+log-KBs, since it can be verified that B |= FOL FEMALE(Mary) in this case. NMSAT-DL+log(B) 1. satisfiable=false 2. if there exists a partition (GP , GN ) of grp (Π) such that 3. (a) Π(GP , GN ) has a stable model and 4. (b) T |= CQ(A ∪ GP ) ⊂ UCQ(GN ) 5. then satisfiable=true 6. endif return satisfiable The problem statement of NM-satisfiability for finite DL+log ¬∨ KBs relies on the aforementioned Boolean CQ/UCQ containment problem for the DL part and on the so-called DL-grounding of the Datalog ¬∨ component. In particular, DL-grounding is an adaptation of the grounding operation used in stable model semantics to the DL+log ¬∨ case. Given a DL+log ¬∨ KB B = (Σ, Π), we denote by C Π the set of constants occurring in Π. The DL-grounding of Π, denoted as gr p (Π), is a set of Boolean CQs obtained by grounding all and only the DL-parts of rule bodies and the DLatoms appearing in rule heads in Π with respect to the constants in C Π . Note that grounding in gr p (Π) is partial, since the variables that only occur in DL-atoms in the body of rules are not replaced by constants in gr p (Π). Similarly to gr p (Π), we define the partial grounding of Π on C Π , denoted as pgr (Π, C Π ), as the program obtained from Π by grounding with the constants in C Π all variables except for the existential variables of rules that only occur in DL-atoms. Finally, given a partition (G P , G N ) of gr p (Π), we denote by Π(G P , G N ) the ground Datalog ¬∨ program obtained from pgr (Π, C Π ) by taking into account the two sets G P and G N so that no DL-predicate occurs in such a program. Let G be a set of Boolean CQs. Then, we denote by CQ (G) (resp. UCQ (G)) the Boolean CQ (resp. UCQ) corresponding to the conjunction (resp. disjunction) of all the Boolean CQs in G. The algorithm NMSAT-DL+log for deciding NMsatisfiability of DL+log ¬∨ KBs has a very simple structure (see Figure 1). It guesses a partition (G P , G N ) of gr p (Π) that is consistent with the DL-KB Σ = (T , A) (Boolean CQ/UCQ containment problem) and such that Π(G P , G N ) has a stable model. More details can be found in (Rosati 2006). The decidability of reasoning, thus of ground query answering, in DL+log ¬∨ depends on the decidability of the Boolean CQ/UCQ containment problem in DL. For any DL, satisfiability of DL+log ¬∨ KBs (under both FOL and NM semantics) is decidable iff Boolean CQ/UCQ containment is decidable in DL (Rosati 2006). From Theorem 2 and from previous results on query answering and query containment in DLs, it follows the decidability of reasoning in several instantiations of DL+log ¬∨ . In all these decidable cases, ground queries can be answered by applying NMSAT-DL+log. The complexity of reasoning in DL+log ¬∨ depends on the specific DL chosen for instantiating the framework. We remind the reader to (Rosati 2006) for the analysis of some cases. 4 Inducing Database Views in DL+log ¬ with ILP In this section we consider the problem of defining a new view in a database whose schema is partly represented by an ontology. We suppose that there are tuples known to belong to the view as well as tuples known not to belong to the view. Cast in the DL+log ¬ framework, this problem boils down to the problem of building DL+log ¬ rules defining a Datalog predicate p which stands for the view name. Tuples are ground Datalog facts that are true for p if they belong to the view, false otherwise. The database problem of interest can be reformulated as the following problem of discriminant induction. We assume that the background theory B in Definition 2 is a DL+log ¬ KB which consists of an intensional part K (i.e., the TBox T plus the set Π R of rules) and an extensional part F (i.e., the ABox A plus the set Π F of facts). Also we denote by P C (B), P R (B), and P D (B) the sets of concept, role and Datalog predicate names occurring in B, respectively. Note that p ∈ P D (B). Throughout this section we shall consider a database Π in the form of the following Datalog The language L of hypotheses in Definition 2 must allow for the generation of DL+log ¬ rules starting from three disjoint alphabets P C (L) ⊆ P C (B), P R (L) ⊆ P R (B), and P D (L) ⊆ P D (B). Also we distinguish between P + D (L) and P - D (L) in order to specify which Datalog predicates can occur in positive and negative literals, respectively. More precisely, we consider DL+log ¬ rules of the form where the unique literal p( X ) in the head is formed out of a Datalog-predicate p which represents the target predicate. Note that the conditions of linkedness and connectedness usually assumed in ILP are guaranteed by the conditions of Datalog safeness and weak DL safeness valid in DL+log ¬∨ . Suppose that the Datalog-predicate happy is the target and the set P + D (L happy )∪ P C (L happy ) ∪ P R (L happy ) = {famous/1, RICH/1, LOVES/2, WANTS-TO-MARRY/2} provides the building blocks for the language L happy . The following DL+log ¬ rules R happy belonging to L happy can be considered definitions for the target predicate happy. The set O of observations in Definition 2 contains facts of the kind p( a i ) where p is the target predicate and a i is a tuple of individuals occurring in the ABox A. We assume B ∩ O = ∅. Furthermore, the description of each observation o i ∈ O is in the background theory and may be incomplete due to the inherent nature of DL+log ¬ . Therefore, the normal ILP setting is the most appropriate to the learning problem in hand and can be extended to DL+log ¬ as follows. Let R ∈ L be a DL+log ¬ rule, B a DL+log ¬ KB, p the target predicate, and Note that the coverage test can be reduced to query answering in DL+log ¬ KBs which in turn can be reformulated as a satisfiability problem of the KB. The rule R happy In order to support the induction of DL+log ¬ rules with ILP techniques, the language L of hypotheses needs to be equipped with a generality order so that (L, ) is a search space. Therefore, the next two subsections, Section 4.1 and Section 4.2, are devoted to suggested techniques for structuring and searching the hypothesis space, respectively. Conversely, Section 4.3 sketches an ILP algorithm employing these techniques to solve the original problem of inducing database views. The definition of a generality order for hypotheses in L must consider the peculiarities of DL+log ¬ . One issue arises from the presence of NAF literals (i.e., negated Datalog literals) both in the background theory and in the language of hypotheses. As pointed out in (Sakama 2001), rules in normal logic programs are syntactically regarded as Horn clauses by viewing the NAF-literal ¬p(X ) as an atom not p(X ) with the new predicate not p. Then any result obtained in ILP on Horn logic programs is directly carried over to normal logic programs. Assuming one such treatment of NAF literals, we propose to adapt generalized subsumption (Buntine 1988) to the case of DL+log ¬ rules and provide a characterization of the resulting generality order, denoted by ¬ K , that relies on the reasoning tasks known for DL+log ¬∨ and from which a test procedure can be derived. Let R 1 , R 2 ∈ L be two DL+log ¬ rules standardized apart, K a DL+log ¬ KB, and σ a Skolem substitution for R 2 with respect to {R 1 } ∪ K. We say that R 1 is more general than R 2 w.r.t. K, denoted by R 1 ¬ K R 2 , iff there exists a ground substitution θ for R 1 such that (i) head (R 1 )θ = head (R 2 )σ and (ii) K∪body(R 2 )σ |= body(R 1 )θ. We say that R 1 is strictly more general than R 2 w.r.t. K, denoted by Note that condition (ii) is a variant of the Boolean CQ/UCQ containment problem because body(R 2 )σ and body(R 1 )θ are both Boolean CQs. The difference between (ii) and the original formulation of the problem is that K encompasses not only a TBox but also a set of rules. Nonetheless this variant can be reduced to the satisfiability problem for finite DL+log ¬ KBs. Indeed the skolemization of body(R 2 ) allows to reduce the Boolean CQ/UCQ containment problem to a CQ answering problem. Due to the aforementioned link between CQ answering and satisfiability, checking (ii) can be reformulated as proving that the KB (T , Π R ∪ body(R 2 )σ ∪ {← body(R 1 )θ}) is unsatisfiable. Once reformulated this way, (ii) can be solved by applying the algorithm NMSAT-DL+log. It can be proved that ≻ ¬ K is a decidable quasi-order (i.e. it is a reflexive and transitive relation) for DL+log ¬ rules. In particular, the decidability of ≻ ¬ K follows from the decidability of DL+log ¬ . As pointed out in Section 4.1, the space (L, ≻ ¬ K ) is a quasi-ordered set, therefore it can be searched by refinement operators. In the following, we define a downward refinement operator for a DL+log ¬ language. Let L be a DL+log ¬ language of hypotheses built out of the three finite and disjoint alphabets P C (L), P R (L), and be a rule R belonging to L. We define a downward refinement operator ρ ¬ for (L, K ) such that the set ρ ¬ (R) contains all R ′ ∈ L that can be obtained from R by applying one of the following refinement rules: l ⊑ s l All the rules of ρ ¬ are correct, i.e. the R ′ 's obtained by applying any of the rules of ρ ¬ to R ∈ L are such that R ≻ ¬ K R ′ . This can be proved intuitively by observing that they act only on body(R). Thus condition (i) of Definition 4 is satisfied. Furthermore, it is straightforward to notice that the application of any of the rules of ρ ¬ to R reduces the number of models of R. In particular, as for SpecOntoLit , this intuition follows from the semantics of DLs. So condition (ii) also is fulfilled. H ← H ∪ {R}; 13. Ideal refinement operators have been proven not to exist for clausal languages ordered by θ-subsumption or stronger orders but can be approximated by dropping the requirement of properness or by bounding the language (Nienhuys-Cheng and de Wolf 1997). We choose the latter option because it guarantees that, if (L, ) is a quasi-ordered set, L is finite and is decidable, then there always exists an ideal refinement operator for (L, ). In our case, since ≻ ¬ K is a decidable quasi-order for any DL with decidable Boolean CQ/UCQ containment problem, we only need to bound L in a suitable manner. From Definition 5 we know that the alphabets P C (L), P R (L), and P + D (L) ∪ P - D (L) are finite. Having Datalog as basis for the CL part of DL+log ¬ avoids the generation of infinite terms. Yet, the expressive power of DL+log ¬ requires several other bounds to be imposed on L in order to guarantee its finiteness. It is necessary to introduce a complexity measure for DL+log ¬ rules, as a pair of two different coordinates. Considering that the complexity of a DL+log ¬ rule resides in its body, the former coordinate is the size (i.e. the difference between the number of symbol occurrences and the number of distinct variables) of the biggest literal in body(R), while the latter is the number of literals in body(R). To keep L finite, we need first to set a maximum value for these two coordinates. Second, it is necessary to set the maximum number of specialization/generalization steps of the DL literals so that the search in the ontology is also depth-bounded. The algorithm in Figure 2 defines the main procedure of NMLEARN-DL+log ¬ . Notice that the outer loop (4-14) corresponds to a variant of the sequential covering algorithm, i.e., it learns new rules one at a time, removing the positive examples covered by the latest rule before attempting to learn the next rule (13). The hypothesis space search performed by NMLEARN-DL+log ¬ is best understood by viewing it hierarchically. Each iteration through the outer loop (4-14) adds a new rule to its disjunctive hypothesis H. The effect of each new rule is to generate the current disjunctive hypothesis (i.e., to increase the number of instances it classifies as positive), by adding a new disjunct. Viewed at this level, the search is a bottomup search through the space of hypotheses, beginning with the most specific empty disjunction (1) and terminating when the hypothesis is sufficiently general to cover all positive training examples ( 14). The inner loop (7-11) performs a finer-grained search to determine the exact definition of each new rule. This loop searches a second hypothesis space, consisting of conjunctions of literals, to find a conjunction that will form the preconditions for the new rule. Within this space, it conducts a top-down, hill-climbing search, beginning with the most general preconditions possible (5), then adding literals one at a time to specialize the rule (7) until it avoids all negative examples. To select the most promising specialization from the candidates generated at each step ( 9 In this section we face the problem of inducing an integrity theory H for a database Π whose instance Π F is given and whose schema K encompasses an ontology Σ and a set Π R of rules linking the database to the ontology. We assume that Π and Σ shares a common set of constants so that they can constitute a DL+log ¬∨ KB B. Given: • an intensional Datalog database Π R and a DL ontology Σ integrated into a DL+log ¬∨ KB K (background theory); • a set O = Π F of ground Datalog facts (observation); and • a set L of constraints on the form of DL+log ¬∨ rules to be induced (language of hypotheses) the problem of defining an integrity theory for Π F is to induce a set H ⊂ L (hypothesis) of DL+log ¬∨ rules from O and K such that H confirms O by taking K into account. Note that, as opposite to the learning problem formally stated in Definition 2, the background theory in Definition 6 is a DL+log ¬∨ KB K which does not include the extensional part Π F of the database. Indeed Π F plays the role of the unique observation from which the learning process should induce a theory H. Conversely, similarly to Section 4, we denote by P C (B), P R (B), and P D (B) the sets of concept, role and Datalog predicate names occurring in B, respectively, assuming that B = Σ ∪ Π. Throughout this section we shall refer to a database about students in the form of a Datalog ¬∨ program Π which consists of an extensional part Π F with the following facts: boy(Paul) girl(Mary) enrolled(Paul,c1) enrolled(Mary,c1) enrolled(Mary,c2) enrolled (Bob,c3) and an intensional part Π R with the following rules: linking the database to an ontology about persons expressed as the following DL KB Σ: Note that Π and Σ can be integrated into a DL+log ¬∨ KB B (adapted from (Rosati 2006)) that concerns the individuals Bob, Mary, and Paul and builds upon the alphabets P C (B) = {FEMALE/1, MALE/1, PERSON/1}, P R (B) = {FATHER/2}, and P D (B) = {boy/1, girl/1, enrolled/2}. The language L of hypotheses in Definition 6 must allow for the generation of DL+log ¬∨ rules starting from three disjoint alphabets P C (L) ⊆ P C (B), P R (L) ⊆ P R (B), and P D (L) ⊆ P D (B). Analogously to Section 4, we distinguish between P + D (L) and P - D (L) in order to specify which Datalog predicates can occur in positive and negative literals, respectively. The following DL+log ¬∨ rules: belong to the language L built upon the alphabets P C (L) = P C (B), P R (L) = ∅, P + D (L) = {boy/1, girl/1, enrolled( ,c1), enrolled( ,c2), enrolled( ,c3)}, and P - D (L) = {boy/1, girl/1}. The scope of induction in the learning problem of interest is characterization because we are looking for a theory which confirms the observation. Also, since a DL+log ¬∨ KB may be incomplete due to the inherent nature of this KR framework, the most appropriate setting for induction is the one for learning from entailment. The coverage test proposed in the following generalizes the case illustrated in Definition 3 to observations which are not singletons of facts. Let R ∈ L be a DL+log ¬∨ rule, K a DL+log ¬∨ KB, and O = {p i ( a i )} a set of ground Datalog facts. We say that R covers O under entailment w.r.t. It is immediate to notice that the coverage test of Definition 7 can be reduced to Boolean CQ answering in DL+log ¬∨ KBs and therefore to a NM-satisfiability problem. In the following we sketch the ingredients for an ILP system able to discover such integrity theories on the basis of NMSAT-DL+log. The order of relative subsumption (Plotkin 1971) is suitable for extension to DL+log ¬∨ rules because it can cope with arbitrary clauses and admit an arbitrary finite set of clauses as the background theory. Let R 1 , R 2 ∈ L be two DL+log ¬∨ rules, and K a DL+log ¬∨ KB. We say that R 1 is more general than R 2 w.r.t. K, denoted by R 1 ¬∨ K R 2 , if there exists a substitution θ such that K |= ∀(R 1 θ ⇒ R 2 ). We say that R 1 is strictly more general than R 2 w.r.t. K, denoted by Let us consider the following DL+log ¬∨ rules belonging to the language L specified in Example 10: It can be easily proved that R 1 ¬∨ K R 2 . Let θ = {X/A} be the substitution to be applied to R 1 and let us suppose that, for every A, if A is enrolled in the course c1, then A is a boy (i.e. the rule R 1 θ is true), thus we can also say that A is either a boy or a girl (i.e. the rule R 2 is true). Note that R 2 ¬∨ K R 1 . Let us now consider the following DL+log ¬∨ rules also belonging to L: In order to prove that R 3 ¬∨ K R 4 , we apply θ = {X/A} to R 3 and suppose that, for every A, if A is enrolled in the course c1, then A is a MALE (i.e. the rule R 1 θ is true). Due to axiom [A2] occurring in the ontology Σ reported in Example 9, A is a PERSON (i.e. the rule R 4 is true). It is immediate to verify that R 3 ≻ ¬∨ K R 4 . The generality relation defined by ¬∨ K is a quasi-order on DL+log ¬∨ rules, therefore the resulting space (L, ¬∨ K ) can be searched by means of refinement operators. A refinement operator for (L, ¬∨ K ) should generate DL+log ¬∨ rules good at expressing integrity constraints. Since we assume the database Π and the ontology Σ to be correct, a rule R must be modified to make it satisfiable by Π ∪ Σ by either (i) strenghtening body(R) or (ii) weakening head (R). Let L be a DL+log ¬∨ language of hypotheses built out of the three finite and disjoint alphabets P C (L), P R (L), and P + D (L) ∪ P - D (L), and be a rule R belonging to L. We define a downward refinement operator ρ ¬∨ for (L, K ) such that the set ρ ¬∨ (R) contains all R ′ ∈ L that can be obtained from R by applying one of the following refinement rules: Note that, since we are working under NM-semantics, two distinct rules, namely AddDataLit B -and AddDataLit H , are devised for adding negated Datalog atoms to the body and for adding Datalog atoms to the head, respectively. It can be proved that all the rules of ρ ¬∨ are correct, i.e. the R ′ 's obtained by applying any of the rules of ρ ¬∨ to R ∈ L are such that R ≻ ¬∨ K R ′ . Intuitively, it is sufficient to observe that the application of any of the rules of ρ ¬∨ conceived to strenghten body(R) reduces the number of models of R whereas the rules aiming at weakening head (R), when applied, do not augment the number of models of R. From the rule belonging to the language L specified in Example 10: ← enrolled(X,c1) we obtain the following rules by applying AddDataLit B + : ← enrolled(X,c1), boy(X) ← enrolled(X,c1), girl(X) ← enrolled(X,c1), enrolled(X,c2) ← enrolled(X,c1), enrolled(X,c3) the following ones by applying AddDataLit B -: ← enrolled(X,c1), not boy(X) ← enrolled(X,c1), not girl(X) the following ones by applying AddOntoLit B : the following ones by applying AddDataLit H : boy(X) ← enrolled(X,c1) girl(X) ← enrolled(X,c1) enrolled(X,c2) ← enrolled(X,c1) enrolled(X,c3) ← enrolled(X,c1) and the following ones: by applying AddOntoLit H . The integrity theory H we would like to discover is a set of DL+log ¬∨ rules. It must be induced by taking the background theory K = Σ ∪ Π R into account so that B = (Σ, Π ∪ H) is a NM-satisfiable DL+log ¬∨ KB. The algorithm in Figure 3 defines the main procedure of NMDISC-DL+log ¬∨ : it starts from an empty theory H (1), and a queue Q containing only the empty clause (2). It then applies a search process (3) where each element R is deleted from the queue Q (4), and tested for satisfaction w.r.t. the data Π F by taking into account the background theory K and the current integrity theory H (5). Note that the NM-satisfiability test includes also the current induced theory in order to deal with the nonmonotonicity of induction in the normal ILP setting. If the rule R is satisfied by the database (6), it is added to the theory (7). If the rule is violated by the database, its refinements according to L are considered (8). The search process terminates when Q becomes empty (9). Note that the algorithm does not specify the search strategy. In order to get a minimal theory (i.e., without redundant clauses), a pruning step and a post-processing phase can be added to NMDISC-DL+log ¬∨ by further calling NMSAT-DL+log8 . With reference to Example 12, the following DL+log ¬∨ rule: is the only one passing the NM-satisfiability test at step (5) of the algorithm NMDISC-DL+log ¬∨ . It is added to the integrity theory. All the other rules are further refined. When the learning process ends at step (9) because the queue of rules has become empty, the integrity theory will encompass the rules reported in Example 10 because they are satisfied by the database. Very few ILP frameworks have been proposed so far that adopt a hybrid DL-CL representation for both hypotheses and background knowledge (Rouveirol and Ventos 2000;Kietz 2003;Lisi 2008;Lisi and Esposito 2008). They are less or differently expressive than the one presented in this paper. The framework proposed in (Rouveirol and Ventos 2000) focuses on discriminant induction and adopts the ILP setting of learning from interpretations. Hypotheses are represented as Carin-ALN non-recursive rules with a Horn literal in the head that plays the role of target concept. The coverage relation of hypotheses against examples adapts the usual one in learning from interpretations to the case of hybrid Carin-ALN BK. The generality relation for hypotheses is defined as an extension of generalized subsumption. Procedures for testing both the coverage relation and the generality relation are based on the existential entailment algorithm of Carin. Following (Rouveirol and Ventos 2000), Kietz studies the learnability of Carin-ALN , thus providing a pre-processing method which enables ILP systems to learn Carin-ALN rules (2003). In (Lisi 2008), the representation and reasoning means come from AL-log. Hypotheses are represented as constrained Datalog clauses. Note that this framework is general, meaning that it is valid whatever the scope of induction is. The generality relation for one such hypothesis language is an adaptation of generalized subsumption to the AL-log KR framework. It gives raise to a quasi-order and can be checked with a decidable procedure based on constrained SLD-resolution. Coverage relations for both ILP settings of learning from interpretations and learning from entailment have been defined on the basis of query answering in AL-log. As opposite to (Rouveirol and Ventos 2000), the framework has been partially implemented in an ILP system (Lisi and Malerba 2004) that supports a variant of frequent pattern discovery where rich prior conceptual knowledge is taken into account in order to find patterns at multiple levels of description granularity. The framework presented in (Lisi and Esposito 2008) is the closest to the present work. Indeed it faces the problem of learning in DL+log, i.e. by disregarding the NM features of DL+log ¬∨ . Yet the framework is more general than the one illustrated here because two cases of rule learning are considered, one aimed at inducing rules with one Datalog literal in the head and the other rules with one DL literal in the head. The former kind of rule will enrich the Datalog part of the KB, whereas the latter will extend the DL part. The main procedure of NMLEARN-DL+log ¬ follows the principles of FOIL (Quinlan 1990) but shows some peculiarities due to the nature of the underlying KR framework, e.g. the setting of learning from entailment (which is more powerful than the use of extensional background theory and coverage testing), and the ordering of generalized subsumption (instead of θ-subsumption). The main procedure of NMDISC-DL+log ¬∨ is inspired by CLAUDIEN (De Raedt and Bruynooghe 1993) as for the scope of induction and the algorithm scheme but differs from it in several points, notably the adoption of (i) relative subsumption instead of θ-subsumption, (ii) stable model semantics instead of completion semantics, and (iii) learning from entailment instead of learning from interpretations, to deal properly with the chosen representation formalism for both the background theory and the language of hypotheses. ILP has been also applied to data engineering tasks such as the interactive restructuring of databases giving rise to the so-called Inductive Data Engineering (IDE) (Flach 1993;Flach 1998;Savnik and Flach 2000). The main idea is to use induction to determine integrity constraints, such as functional and multivalued dependencies, that are valid (or almost valid) in a database and then use the constraints to decompose (restructure) the database. In this paper, we have investigated two ILP solutions for learning in the KR framework of DL+log ¬∨ , both valid for any DL for which the instantiation of the framework is decidable, but one restricted to Datalog ¬ and the other for the full framework. Indeed, well-known ILP techniques for induction such as the orderings of generalized subsumption and relative subsumption have been reformulated in terms of the deductive reasoning mechanims of DL+log ¬∨ , namely by relying on the algorithm NMSAT-DL+log devised to prove NM-satisfiability of DL+log ¬∨ KBs. Notably, we have defined generality orders, refinement operators and coverage tests on the basis of NMSAT-DL+log. Though the work presented in this paper is not yet supported by empirical evidence, it shows that it is feasible for ILP to go beyond Datalog towards DL+log ¬∨ . The potential of this extended ILP has been illustrated in two traditional database problems, i.e. the definition of views and the definition of integrity theories, for which we have sketched ad-hoc ILP al-gorithms, NMLEARN-DL+log ¬ and NMDISC-DL+log ¬∨ , respectively. The NM features as well as the DL component of DL+log ¬∨ enable these algorithms to build hypotheses with expressiveness far greater than the one reachable with the predecessors FOIL and CLAUDIEN. Notably, ontologies accommodate elegantly in the solution to the database problems being considered. From the ILP viewpoint the expressive power of DL+log ¬∨ has, of course, raised some technical difficulties. In particular, the critical point has been the DL component that has required an appropriate treatment when defining both the generality orders and the refinement operators. Also the setting of learning from entailment turned out to be the most appropriate for the induction within the DL+log ¬∨ KR framework. As next step towards any practice, we plan to first analyze the complexity and then produce an efficient and scalable implementation of these ILP algorithms. Adopting less expressive but tractable instantiations of DL+log ¬∨ may turn out crucial from this point of view. E.g., DL-Lite (Calvanese et al. 2007) has been proved to be good at making DL+log ¬∨ practically useful (Rosati 2006). Another point is the definition of so-called optimal refinement operators to be actually employed in NMLEARN-DL+log ¬ and NMDISC-DL+log ¬∨ . Indeed, ideal refinement operators are mainly of theoretical interest, because in practice they are often very inefficient. More constructive -though possibly improper -refinement operators are usually to be preferred over ideal ones. Optimal refinement operators can be easily derived from those proposed in this paper. Learning in DL+log ¬∨ is also promising for Semantic Web applications for the following reasons. First, it can deal with ontologies almost as expressive as the ones that OWL allow. Indeed, as already mentioned, SHIQ has been the starting point for the definition of OWL and gives rise to one of the currently most expressive decidable instantiations of DL+log ¬∨ . Second, it can deal with incomplete knowledge thanks to the NM features of DL+log ¬∨ . Third, it can deal with ontologies and rules tightly integrated as devised by the W3C Rule Interchange Format (RIF) working group.9 Indeed the activity of the RIF group concerns (i) the definition of a core language with extensions some of which (the nonmonotonic ones) will most likely be inspired by hybrid DL-CL languages like DL+log ¬∨ and (ii) the identification of use cases many of which are suitable to our algorithms for application. As a final remark, we would like to point out that the shift from Datalog to DL+log ¬∨ in ILP paves the way to an extension of Relational Learning (and Data Mining), named Onto-Relational Learning, which accounts for ontologies in a clear, well-founded and systematic way. Following the work reported in this paper, we can build new-generation ILP systems able to learn from relational databases integrated with ontologies according to the principles of Onto-Relational Learning. We prefer to use the name DL+log ¬∨ instead of the original one DL+log in order to emphasize the Datalog ¬∨ component of the framework. This problem was called existential entailment in(Levy and Rousset 1998). Note that the OWA and CWA have a strong influence on the results of reasoning. This definition relies on the set notation for clauses. Two clauses C and D are said to be standardized apart if they have no variables in common. Let B be a clausal theory and C be a clause. Let X 1 , . . . , Xn be all the variables appearing in C , and a 1 , . . . , an be distinct constants (individuals) not appearing in B or C . Then the substitution {X 1 /a 1 , . . . , Xn /an } is called a Skolem substitution for C w.r.t. B. A lattice is a partially ordered set (also called a poset) in which any two elements have a unique supremum (the elements' least upper bound) and an infimum (greatest lower bound). Based on the following consequence of the Deduction Theorem in FOL: Given a KB B and a rule R in DL+log ¬∨ , we have that B |= R iff B ∧ ¬R is unsatisfiable. http://www.w3.org/2005/rules/wiki/RIF Working Group