Bertossi, L.

Calì, Andrea

Milani, M.

Name not available

Query Answering on Expressive Datalog±OntologiesMostafa Milani1, Andrea Cal`ı2,3, and Leopoldo Bertossi11School of Computer ScienceCarleton University, Canada2Dept of Computer ScienceBirkbeck, Univ. of London, UK3Oxford-Man Institute of Quantitative FinanceUniversity of Oxford, UK{mmilani, bertossi}@scs.carleton.caandrea@dcs.bbk.ac.uk1 IntroductionThe Datalog± family of ontology languages [1], which extends Datalog withexistential quantification, has been gaining importance in the area of OntologyQuerying due to its capability of capturing several prominent Semantic Weblanguages as well as offering efficient query answering services in many variantsrelevant for applications. The core feature of Datalog± languages are so-calledtuple-generating dependencies (TGDs), which are the main form of rules. Suchrules allow the inference of new atoms from an initial set (a database), whichis captured by the notion of chase procedure. For example, consider the TGDr(X,Y ) → ∃Z s(X,Z) and a database D constituted by a single atom r(a, b).A chase step will generate the atom s(a, ζ), where ζ is a labelled null, thatis, a placeholder for an unknown value; notice that the constant b is lost inthis step as it doesn’t appear in the new atom. Conjunctive query answeringunder general TGDs is undecidable; languages of the Datalog± family imposetherefore restrictions on the form of rules so as to guarantee decidability and goodcomputational properties. Guarded (extended by weakly-guarded) Datalog± werethe first form of decidable Datalog± languages, inspired by guarded logic andcharacterised by the presence of a guard atom in each rule, that contains allvariables of that rule.The language called sticky Datalog± [1] was introduced in order to capturea “proper” notion of join in rules, that is, the occurrence of variables in twodistinct atoms of a rule in the absence of a guard for that rule. Weakly-stickyDatalog± is an extension of sticky Datalog± that extends sticky Datalog± byalso capturing the well-known class of weakly-acyclic TGDs.Let Σ be the following set of rules, where some body variables are marked(denoted by a hat sign, e.g. Xˆ; see [1]) as the result of a procedure that identifiespositions (arguments of predicates; for instance, p[1] is the position correspond-ing to the first argument of the predicate p) where, in the chase procedure, valuescan appear that can eventually be lost in a subsequent chase step.v(X) → ∃Y r(X,Y ) r(X, Yˆ ), r(Yˆ , Z) → p(X,Z).p(Xˆ, Yˆ ) → ∃Z p(Y,Z) p(Xˆ, Y ), p(Y,Z) → t(Y,Z)A set of rules is sticky if there is no marked variable in a rule that appearsmore than once in the body of the rule. Intuitively, stickiness can be defined bymeans of the following property: during a chase step according to a rule σ, eachvalue corresponding to a variable appearing more than once in σ is not lost inthe chase step, and it is also never lost in any subsequent step involving atomswhere it appears. Σ is not sticky, as easily seen.Weak-acyclicity is defined using the notion of rank of a position [2]. A positionhas finite (resp., infinite) rank if the number of labelled nulls that can appear inthat position in the chase procedure is finite (infinite). In the Datalog± programΣ above, ΠF = {v[1], r[1], r[2]} is the set of positions with finite rank andΠ∞ = {p[1], p[2]} is the set of positions with infinite rank. A Datalog± programis weakly-acyclic if all positions of predicates have finite rank. The program Σis not weakly-acyclic.A set of rules is weakly-sticky if every marked variable that is repeated inthe body of a rule appears at least once in a position with finite rank. Thisgeneralizes stickiness with acyclicity because the stickiness is only applied onvalues that appear in the positions with infinite rank. Here, Σ is weakly-sticky.Specifically in the second rule, the repeated variable Y appears in the positionsr[1] and r[2] in ΠF . In the last rule, Y is a repeated variable but not marked.So far, no non-trivial deterministic algorithm for CQ answering has beendevised for weakly-sticky Datalog±. In this paper we set the basis for the imple-mentation of conjunctive query (CQ) answering by the following contributions.1. We propose a bottom-up technique, where we ground the rules of Σ accord-ing to the database D in a suitable way. The expansion instance terminatesat a point dependent on the size of the query; the query can be then evaluateddirectly on the expanded instance.2. We propose a hybrid approach to CQ answering as follows. First, we trans-form all positions in ΠF into positions of rank 0 (that is, positions where onlyconstants can appear); then certain variables in such positions are grounded,that is, the variables are replaced by selected constants of the initial in-stance. The obtained program is a sticky program, for which a well-knownquery rewriting technique for CQ answering can be applied.2 A Grounding ApproachA first deterministic algorithm for query answering on a weakly-sticky Datalog±program Σ and a database is obtained by grounding the rules of Σ in a bottom-up fashion. The procedure is inspired by the version of the chase procedurein [5, 6]. We illustrate this technique by means of an example. Consider adatabase D = {p(a, b), v(b)}, a Boolean conjunctive query (BCQ) q = {u(X)},and a set of WS rules Σ as follows: σ1 : p(X,Y ) → ∃Z p(Y, Z) andσ2 : v(X), p(X,Y ), p(Y, Z) → u(Y ).We start from D and iteratively generate ground rules by mapping via ho-momorphism the body of the rules in Σ into D or the head of the rules in Σ′(the current set of ground rules). The basic procedure is as follows: we iterativelyadd a ground rule to Σ′ if its head atom is not homomorphic to the head of arule already in Σ′, until no new rule can be added. This “cautious” procedure,similar to the chase procedure in [5, 6], guarantees its termination. In our exam-ple, the algorithm stops after adding only one ground rule p(a, b) → p(b, ζ1) toΣ′, where ζ1 is a labelled null.In order to complete our grounding, we resume the above basic procedureMq times, where Mq is the number of existential variables in q. Before eachresumption, we freeze the labelled nulls, which after having been frozen areconsidered as constants. In our example, we have only one more resumption,which adds the rules, p(b, ζ1) → p(ζ1, ζ2) and v(b), p(b, ζ1), p(ζ1, ζ2) → u(ζ1).Resumptions are needed, intuitively, to capture applications of rules (in a chaseprocedure) where a join variable, appearing in two or more distinct atoms, aremapped to a labelled null.Now, the number of resumptions depends on the query, which makes ourgrounding dependent on the query; however, for practical purposes, we couldground with N resumptions so as to be able to answer queries with up to Nexistential variables, and if a query with more than N existential variables is tobe answered, we can incrementally retake the already-computed grounding andadd the required number of resumptions.3 A Hybrid ApproachIn this section, we propose an algorithm based on a hybrid approach that com-bines the grounding of specific variables in rules with the query rewriting al-gorithm from [3]. Given a set of WS rules Σ and a database D, our algorithmtransforms Σ according to D into a sticky set of rules Σ′. Sticky Datalog± en-joys first-order rewritability, that is, each CQ can be rewritten into a first-orderquery and directly answered on the database [3], providing the correct answer.As an example, consider D = {v(a), s(a, b)} and a set of WS rules Σ thatincludes σ1 and σ2 from the example in Section 2 as well as the following rules:σ3 : v(X) → ∃Y r(X,Y ).σ4 : r(X,Y ), s(X,Z) → t(Y, Z).σ5 : r(X,Y ), t(Y,Z) → p(X,Z).Let us call weak rules the rules in which some repeated marked body variablesappear at least once in a position with finite rank; we call such variables weakvariables. We aim at grounding the weak variables only, thus turning the WSprogram into a sticky program.In our example, σ4 and σ5 are weak rules withX and Y as their weak variablesrespectively. σ4 is partially grounded as a sticky rule r(a, Y ), s(a, Z) → r(Y, Z)since X can only take the value a from D. To (partially) ground σ5 we wouldneed Y to be replaced with a null value invented by σ3. Notice that the variableswe are to ground can only be in positions with finite rank, which guarantees thefiniteness of the partial grounding. Our algorithm consists of two phases.(Phase 1). We remove the existential variables that are in the positions withfinite rank with a method inspired by [4]. In the context of our example, we firstSkolemize σ3, that is the only rule with an existential variable in a position withfinite rank. The result is v(X) → r(X, f(X)). Next, we replace r(X, f(X))with an expanded predicate r′(X, f, X) with the higher arity that results intoa rule v(X) → r′(X, f, X) in which f is a fresh constant that represents thereplaced function. Then, we iteratively propagate the expanded predicate in thebody and head of the rules, possibly expanding other predicates e.g. t, obtainingthe new rules: σ′3 : v(X) → r′(X, f, X), σ′4 : r′(X,Y, Y ′), s(X,Z) → t′(Y, Y ′, Z),and σ′5 : r′(X,Y, Y ′), t′(Y, Y ′, Z) → p(X,Z). The result is a set of rules Σ0,∞ ={σ1, σ2, σ′3, σ′4, σ′5} with positions of rank either zero or infinite.(Phase 2). Now, we proceed with the grounding step where we replace theweak variables (X in σ′4 and Y, Y′ in σ′5) with values from D and the newconstant f. The result is a set of sticky rules Σ′ that includes σ1, σ2 and σ′3as well as the following rules, σ′′4 : r′(a, Y, Y ′), s(a, Z) → t′(Y, Y ′, Z), and σ′′5 :r′(X, f, a), t′(f, a, Z) → p(X,Z).To compute the answers to the query q, Σ′ and q are rewritten into a first-order query using the rewriting method for sticky rules [3]. The first-order queryis then evaluated on D.4 ConclusionWeakly-sticky Datalog± is an expressive ontology language with good compu-tational properties and capable of capturing the most prominent Semantic Weblanguages. We proposed two deterministic algorithms for answering conjunctivequeries on weakly-sticky Datalog±. This, we believe, sets the basis for practicalquery answering algorithms for real-world scenarios. We plan to continue ourwork by running experiments on large data sets. We also intend to refine thehybrid algorithm by devising solutions to reduce the number of constants of thedatabase used to ground the weak variables; this would improve the efficiencyof our approach.References1. A. Cali, G. Gottlob, and A. Pieris. Towards more expressive ontology languages:The query answering problem. Artificial Intelligence, 2012, 193:87-128.2. R. Fagin, P. G. Kolaitis, R. J. Miller, and L. Popa. Data Exchange: Semantics andQuery Answering. TCS, 2005, 336:89-124.3. G. Gottlob, G. Orsi, and A. Pieris. Query Rewriting and Optimization for Onto-logical Databases. Proc. TODS, 2014, 39(3):25.4. Kro¨tzsch, M. and Rudolph, S. Extending Decidable Existential Rules by JoiningAcyclicity and Guardedness. Proc. IJCAI, 2011, pp. 963-968.5. N. Leone, M. Manna, G. Terracina, and P. Veltri. Efficiently Computable Datalog±Programs. Proc. KR, 2012, pp. 13-23.6. M. Milani, L. Bertossi. Tractable Query Answering and Optimization for Exten-sions of Weakly-Sticky Datalog+-. Proc. AMW, 2015.

Query answering on expressive Datalog+/- ontologies

Abstract

Similar works

Full text

Available Versions

Name not available

Birkbeck Institutional Research Online