IBM Research Report. Scalable Conjunctive Query Evaluation over Large and Expressive Knowledge Bases

Transcription

1 RC24563 (W ) May 20, 2008 Computer Science IBM Research Report Scalable Conjunctive Query Evaluation over Large and Expressive Knowledge Bases Julian Dolby, Achille Fokoue, Aditya Kalyanpur, Li Ma*, Edith Schonberg, Kavitha Srinivas, Xing Zhi Sun* IBM Research Division Thomas J. Watson Research Center P.O. Box 218 Yorktown Heights, NY *IBM Research Division China Research Laboratory Building 19, Zhouguancun Software Park 8 Dongbeiwang West Road, Haidian District Beijing, P.R.China Research Division Almaden - Austin - Beijing - Cambridge - Haifa - India - T. J. Watson - Tokyo - Zurich LIMITED DISTRIBUTION NOTICE: This report has been submitted for publication outside of IBM and will probably be copyrighted if accepted for publication. It has been issued as a Research Report for early dissemination of its contents. In view of the transfer of copyright to the outside publisher, its distribution outside of IBM prior to publication should be limited to peer communications and specific requests. After outside publication, requests should be filled only by reprints or legally obtained copies of the article (e.g., payment of royalties). Copies may be requested from IBM T. J. Watson Research Center, P. O. Box 218, Yorktown Heights, NY USA ( reports@us.ibm.com). Some reports are available on the internet at

2 Scalable Conjunctive Query Evaluation Over Large and Expressive Knowledge Bases Julian Dolby 1, Achille Fokoue 1, Aditya Kalyanpur 1, Li Ma 2, Edith Schonberg 1, Kavitha Srinivas 1, and Xingzhi Sun 2 1 IBM Watson Research Center,P.O.Box 704, Yorktown Heights, NY 10598, USA dolby, achille, adityakal, ediths, ksrinivs@us.ibm.com 2 IBM China Research Lab, Beijing , China malli,sunxingz@cn.ibm.com Abstract. Conjunctive query answering over OWL-DL ontologies is intractable in the worst case, but we present novel techniques which allow for efficient querying of large expressive knowledge bases in secondary storage. In particular, we show that we can effectively answer conjunctive queries without building a full completion forest for a large Abox (unlike state of the art tableau reasoners). Instead we rely on the completion forest of a dramatically reduced summary of the Abox. We demonstrate the effectiveness of this approach in Aboxes with up to 45 million assertions. 1 Introduction Scalable conjunctive query answering is an important requirement for many large-scale Semantic Web applications. In this paper, we present a tableaubased reasoning solution for answering conjunctive queries over large and expressive Aboxes. We consider queries with only distinguished variables because such queries are more realistic in practice and can also be answered more efficiently. Our approach handles the expressive DL SHIN (OWL-DL minus nominals and datatypes), and scales to Aboxes with up to 45 million assertions. In our previous work, we have developed an efficient summarization based technique to do sound and complete membership query answering over SHIN KBs containing millions of assertions [1]. At its core, the technique applies a standard tableau algorithm to a summary Abox A rather than the original Abox A. The summary A is created by aggregating individuals with the same concept sets into a single summary individual. Consistency checking is then performed on A. If the summary is consistent when a negated query is added to a summary individual a, then all individuals mapped to a can be ruled out as solutions to the query. If the summary is inconsistent, it is possible that either (i) a subset of individuals mapped to a are instances of the query or (ii) the inconsistency is a spurious effect of the summarization. We determine the answer through refinement, a process which selectively expands the summary Abox by focusing on inconsistency justifications (minimal assertion sets implying the inconsistency), and making them more precise w.r.t the original Abox. Precise

3 justifications are then used to find query solutions. A key point here is that even a precise summary justification is not at the level of Abox individuals, and the scalability of the approach comes from the fact that it makes decisions on groups of individuals as a whole in the summary. For example, when the algorithm concludes that a particular summary individual a is a solution to the membership query C(x), it implies that all the Abox individuals mapped to a are solutions. A natural question is whether this technique can be extended to solving relationship queries, and hence arbitrary conjunctive queries. Unfortunately, the nature of our summarization algorithm is such that what works well for solving membership queries does not hold fully for relationship queries. A simple example illustrates the fundamental limitation. Consider the relationship query R(x,y) over an Abox A with summary A. This translates into a membership query over the summary as follows: We add a new atomic concept N y as a type to every summary individual in A, and then check for the membership query: R.N y. Unfortunately, while this technique gives us all Abox individuals mapped to x, it cannot tell us all the solution tuples for R(x,y) in the Abox, because not all Abox justifications for these tuples necessarily appear in the summary in its original structure 3. As a result, we are forced to find all solution justifications in the Abox, which is an NP-complete problem [3], making this approach impractical. Our basic approach therefore is to split the conjunctive query into its component membership atoms and relationship atoms, solve these two parts separately, and join the respective bindings at the end. For example, consider a conjunctive query C(x) R(x,y) D(y) S(y,z) where x,y,z are distinguished variables, C,D are concepts and R,S are roles. Our algorithm does the following: 1. We evaluate the membership queries C(x), D(y) using an extension of our previous summarization and refinement technique (see section 4), to find potential solution bindings for x,y (here, variable z does not have any type constraints and so all Abox individuals are considered potential bindings for z). A key point here is to filter out membership query bindings that do not satisfy the remaining relationship constraints in the query, and for this we use the completion forest of the summary Abox to estimate query candidates. This narrows the candidate search space significantly. We prove correctness of this novel optimization in Section 3 (Theorem 1). 2. We then evaluate the relationship query R(x,y) (resp. S(y,z)) by focusing on x, y (resp. y, z) individual bindings found in step 1. Details of how we evaluate relationship queries efficiently, using a Datalog rule-set and optimizations based on the completion forest of the summary Abox, are in Section We join the resultant bindings found across all the relationship query atoms in step 2 to obtain conjunctive query solutions. The entire conjunctive query algorithm that combines steps 1 and 2 is presented in Section 6. Our contributions in this paper are as follows: (a) we present a technique to perform scalable conjunctive query answering over large and expressive Aboxes 3 For details, see [2].

4 which relies on an important new property using the completion forest of the summary Abox for various optimizations (b) we demonstrate the effectiveness of this technique with very large Aboxes on the UOBM benchmark, (c) we demonstrate graceful degradation of our algorithm s performance, such that queries whose solutions do not exploit non-determinism in the KB (e.g., do not require non-deterministic mergers between individuals) are performed very efficiently. 2 Background 2.1 Definition of Conjunctive Query Given a knowledge base (KB) K and a set of variables V disjoint with the set Ind of named individuals in K, a conjunctive query Q is of the form (x 1,...,x n ) q 1... q m where, for 1 i n, x i V and, for 1 j m, q j is a query term. A query term q is of the form C(x) or R(x,y) where x and y are either variables or named individuals in K, C is a concept expression and R is a role. V ar(q) refers to the set of variables occurring in query Q. Let π : V ar(q) Ind be a total function from variables in Q to named individual in K. For a query term q, π.q denotes the query term obtained by substituting in q all occurrences of a variable x by π(x). (a 1,...,a n ) is a solution in the KB K of the conjunctive query Q of the form (x 1,...,x n ) q 1... q m iff. there is a total function π : V ar(q) Ind such that the following hold : (1), for 1 i n, π(x i ) = a i, and (2), for 1 j m, K = π.q j (i.e. K entails π.q j ). 2.2 Summarization and Refinement In our earlier work, we presented an algorithm based on summarization and refinement to scale consistency checking and membership query answering to large Aboxes in secondary storage. A key feature of our algorithm is that we perform consistency detection on a summarized version of the Abox rather than the Abox in secondary storage [4]. A summary Abox A can be constructed by mapping all individuals in the original Abox A with the same concept set to a single individual in the summarya. Formally, an Abox A is a summary Abox of a SHIN 4 Abox A if there is a mapping function f that satisfies the following constraints: (1) if a : C A then f(a) : C A (2) if R(a, b) A then R(f(a),f(b)) A (3) if a b A then f(a) f(b) A If the summary Abox A obtained by applying the mapping function f to A is consistent w.r.t. a given Tbox T and a Rbox R, then A is consistent w.r.t. T and R. However, the converse does not hold. In general, an inconsistency in the 4 We assume without loss of generality that A does not contain an assertion of the form a =b

5 summary may reflect either a real inconsistency in the original Abox, or could simply be an artifact of the summarization process. In the case of an inconsistent summary, we use a process of iterative refinement described in [1] to make the summary more precise, to the point where we can conclude that an inconsistent summary A reflects a real inconsistency in the actual Abox A. Refinement is a process by which only the part of the summary that gives rise to the inconsistency is made more precise, while preserving the summary Abox properties(1)-(3). To pinpoint the portion of the summary that gives rise to the inconsistency, we focus on the justification for the inconsistency, where a justification is a minimal set of assertions which, when taken together, imply a logical contradiction. 3 Optimizing Conjunctive Querying With the Summary Completion Forest One novelty of our approach is that we use the completion forest obtained from the consistency check on the significantly smaller summary to rule out obvious non-solutions in the Abox. This is a significant departure from existing tableau reasoners which use the completion forest on the original Abox for optimizing conjunctive queries. This section establishes the basis for our use of the summary completion forest for optimizing conjunctive queries. First, we briefly present important tableaux algorithm concepts and notations. As described in [5], the tableaux algorithm operates on a completion forest F = (G, L,, =) where G is a graph, with nodes corresponding to individuals and edges corresponding to relations; L is a mapping from a node x in G to a set of concepts, L(x), and from an edge < x,y > in G to a set of roles, L(< x,y >), in R; = is an equivalence relation corresponding to the equality between nodes of G; and is the binary relation distinct from on nodes of G. At the beginning of the execution of the tableaux algorithm on an Abox A, the completion forest is initialized as follows: There is a node x in G iff there is an individual x in A. < x,y > is an edge in G with R L(< x,y >) iff R(x,y) A. For x and y in G, x y iff x y A. Initially, there are no x and y in G such that x =y. The tableaux algorithm consists of executing a set of non-deterministic rules to satisfy constraints in A. As soon as an obvious inconsistency, a clash, is detected, the algorithm either backtracks and selects a different non-deterministic choice or stops if all non-deterministic choices have already been made. A root node a is a node present in the initial completion forest (it corresponds to the named individual with the same name in A). For a root node c in the completion forest F, the root node α(c) is defined as follows (informally, α(c) corresponds to the node in which c has been directly or indirectly merged): c if L(c) α(c) = d if L(c) =, d is the unique root node in F with L(d) and d =c

6 Now, assuming that the original Abox A is consistent, there are two reasons for the use of the completion forest of its summary for candidate pruning purpose: First, since A is consistent, as discussed in [1], a consistent summary A of A can always be built through a finite number of refinements. Second, as established by theorem 1 below, if F denotes the clash-free completion forest resulting from the consistency check on the summary A of A, then there exists a complete and clash-free completion forest F resulting from a direct application of tableau rules on A such that for two named individuals in A a and b if α(f(b)) is not a R-neighbor 5 of α(f(a)) then b is not a R-neighbor of a. In other words, we can rule out the existence of R-neighbors of a in F based on the non-existence of R-neighbors of α(f(a)) in F. Therefore, candidate solutions for a query of the form R(x,y) can be pruned based on completion forest checking on F instead of F. Theorem 1 Let K = (A, T, R) be a consistent knowledge base. Let f be a summary mapping function that maps A to a consistent summary Abox A. Let F be the complete and clash-free completion forest resulting from a consistency check on A, T and R. There exists a complete and clash-free completion forest F resulting from an application of tableau rules directly on A such that, for named individuals a and b in F originally present in A and a role S in R, (1) L(a) L (α(f(a))) (where L(a) denotes the concept set of a in F, and L (α(f(a))) is the concept set of the α(f(a)) in F (2) if b is S-neighbor of a in F, then, in F, α(f(b)) is a S-neighbor of α(f(a)). Proof. The proof relies on the following main ideas: First, to make sure that properties (1) and (2) of Theorem 1 hold, we use F to guide the execution of non-deterministic rules on A (i.e. we make the same choices as in F ). Second, we maintain, during the execution of the tableau algorithm on A, a mapping σ that maps nodes x in the completion forest F obtained from A to nodes in F, regardless of whether x refers to a root node, or to a generated node. Furthermore, the relationship between a node x in F and σ(x) should be compatible with properties (1) and (2) of Theorem 1. This mapping of x in F to nodes in F is not straightforward in the presence of blocking, because there is no guarantee that an unblocked generated node x in F always maps to a node in F that is also not blocked. We therefore formally define the function σ as mapping a node x in F to a pair (u,u ) of nodes in F, to handle the case when x is related to a blocked node u. The node u in the pair is the node that blocks u if u is blocked; if u is not blocked, then u and u are the same (u = u ). Let F be the completion forest initialized from A in the standard way. Before the start of the execution of tableau rules on F, the function σ maps a root node in F to a pair of nodes in F as follows: 5 By definition, y is a R-neighbor of x iff. S(x, y) A or P(y, x) A where S and P are subroles of R

7 For a root node a in F, we define σ(a) = (α(f(a)),α(f(a))) As new generated nodes are introduced during the execution of the tableau rules on F, the mapping σ is extended to these new nodes as explained in the treatment of the -rule and -rule. σ(a)[1] denotes the first element of the pair σ(a), and σ(a)[2] is its second element. We show by induction that at any given step k of a particular execution 6 of tableau rules on F the following holds: for all nodes x and y in F (A ) L k (x) L (σ(x)[1]) (where L k (x) denotes the concept set of a at step k of the execution of the standard tableau algorithm on A, and L (σ(x)[1]) is the concept set of the σ(x)[1] in F ) (B ) if y is a S-neighbor of x and y is either a root node or a generated child of x, then, in F, σ(y)[2] is a S-neighbor of σ(x)[1]. (C ) for σ(x) = (u,u ), u = u iff. u is not blocked (D ) for σ(x) = (u,u ), u u iff. u is blocked by u. (E ) if x y holds in F, then σ(x)[2] σ(y)[2] holds in F It is very important to note that, since F is clash-free, if, at any step k, (A ), (B ) and (E ) hold, then, at any step k, F is clash-free. The details of the induction proof is given in [2]. 4 Solving the Membership Query Part To evaluate all the membership query atoms in the conjunctive query efficiently, we restrict our tests to candidate individuals that conservatively satisfy all the relationship atoms in the conjunctive query by making use of the completion forest of the summary Abox. Note that in general (as described in [6]), the completion forest of an Abox can be used to rule out candidates a,b to test for a relationship query R(x, y). The intuition here is that a completion forest F represents an abstraction of a model of the Abox, and thus if b is not an R neighbor of a in F (and R is not transitive), the relation R(a,b) cannot be entailed by the KB. We apply the same principle to the completion forest of the summary Abox, which is possible due to Theorem 1. Also, we extend this idea by checking possible satisfaction of all the relationships in the conjunctive query. The algorithm SELECT-CANDIDATES-MQ to select test candidates is shown below. Basically, the algorithm transforms the relationship atoms in the original conjunctive query into a SPARQL query Q r and issues it over the completion forest of the summary F. Solutions to Q r give us candidates to test for the membership constraints. During the transformation, special care is taken for constants appearing in role atoms. Since Q r is evaluated on the summary, constants are replaced by the corresponding summary individuals that they are mapped to. Since we assume that all variables in the original conjunctive query are distinguished, we need 6 An execution in which non-deterministic choices are made based on choices made in F as explained in the treatment of non-deterministic rules

8 Select-Candidates-MQ(F, R, f, R j(x k, x l ) (1 j n)) Input: F Completion forest of Summary Abox, R Rbox of the original KB, f Abox Summary mapping function, R j(x k, x l ) Set of role atoms in original conjunctive query Output: τ(x i) mapping from variables to summary individuals (1) V s set of all variables in role atoms R j (1 j n) (2) R s set of all role atoms R j(x k, x l )(1 j n) (3) For any constant c in any of the role atoms in R s, obtain the summary individual s f(c), and replace c by s (4) Create a SPARQL query Q r whose SELECT clause is V s and whose WHERE clause is R s. (5) Issue Q r over F with only Rbox inferencing using R to obtain solution mapping τ(x i) (6) Remove individual solutions from τ which are considered anonymous in F (7) Since F may contain mergers between individuals in A, expand any individual binding i in τ by its equivalence set (sameas(i)) (8) return τ(x i) to consider the variables in role atoms in the select clause of Q r. The query is evaluated considering the Rbox R of the original KB, as we would like to capture relationships that can be inferred due to sub-property, inverse or transitive axioms in it (Note that the Tbox need not be considered since we do not care about concepts and concept-related axioms at this point). Since F is small, evaluating this query is straightforward. The result of executing Q r is a mapping τ from variable to summary individuals, the latter becoming test candidates for the membership query constraints on the former. Note that the completion forest of the summary Abox may contain anonymous individuals that are generated due to the presence of existential quantifiers in the KB. Obviously, these anonymous summary individuals are not present in the original Abox either and so we do not need to test them. Therefore, we discard any anonymous individuals from τ. Having identified suitable test candidates, we now proceed to test them for their respective membership query atoms, using our summarization and refinement algorithm [1].While the previous work focused on testing a single membership query on the summary, it can be easily extended to test multiple membership queries on the summary at the same time. The main difference is that we now start by adding the negation of all the membership types to their respective summary individual candidates, before testing for inconsistency (for details of other optimizations to membership querying, see [2]). SOLVE-MQ, sketched below, captures the essence of the evaluation of membership queries.

9 Solve-MQ( Q, A,T,R ) Input: Q the conjunctive query, A Abox, T Tbox, R Rbox Output: A c consistent version of summary Abox, f c summary mapping function for A c, F c completion forest of A c, β mapping from a variable to summary individuals satisfying its type constraints (1) (A,f) compute summary abox of A and its mapping function f (2) (A c,f c) consistent version of A and its mapping function obtained through refinement (3) F c complete and clash-free completion forest of A c (4) τ Select-Candidates-MQ(F c, R,f c, R j(x k, x l ) Q) (5) foreach variable x k in Q (6) if variable x k has type constraints in Q (7) β(x k ) compute, through refinement, summary individuals in τ(x k ) instances of concept C p(x k ) Q Cp (8) else (9) β(x k ) τ(x k ) (10) return (A c, f c, F c, β) 5 Solving the Relationship Query Part In this section, we discuss how we evaluate each of the role atoms R(x,y) in the conjunctive query. We solve an atomic role query in three steps: 1. Section 5.1: We estimate an upper bound on potential relationship solutions for R(x,y) in the Abox by capturing all possible ways in which relationships can be inferred in SHIN. We do this efficiently using using the completion forest of the summary Abox and a set of Datalog rules. The rules are restricted to the membership query solutions that are output in the previous step. 2. Section 5.2: After estimating potential role assertion solutions in the Abox, we identify definite or deterministically-derived role assertions, since we do not have to test for them. 3. Section 5.3: Finally, we test and solve the remaining potential relationship solutions in the summary Abox. 5.1 Estimating Potential Solutions for an Atomic Role Query R(x, y) Our approach to estimate potential solutions to role queries consists in first understanding how, in the completion forest F of an Abox A, a root node can acquire new root node R-neighbors (i.e. root node R-neighbors that were not present before the beginning of rule execution). Then, we devise a set of simple rules (see Figure 2) to conservatively estimate potential R-neighbors. These rules are simple enough to be efficiently evaluated using a datalog engine. Figure 1 illustrates the two ways a root node a in F can acquire new R-neighbors that are root nodes during the execution of the tableaux algorithm on F:

10 Fig. 1. Acquisition of named individual R-neighbors (A) The root node a is merged with another root node d and acquires root node R-neighbors of d. The merger is performed to satisfy the maximum cardinality restriction nq in the concept set of c. This case also captures acquisition of R-neighbors through mergers involving root neighbors of a. (B) The root node b is merged with a generated node x to satisfy the maximum cardinality restriction nq in the concept set of a. As a result of this merger, b becomes a R-neighbor of a since x was a R-neighbor of a. Let us assume that F is a complete and clash-free completion forest of the summary A of the Abox A, and F is the complete and clash-free completion forest of A given by Theorem 1. We can conservatively account for acquisition of named R-neighbors of a through mergers with named individuals by applying rules (see rules N amedm erge, SameRel1, and SameRel2 in Figure 2) on the Abox that trigger a merger between a and d if (1) a is a Q-neighbor of c in A (explicitly or as a result of evaluation of our simple rules), (2) d is a Q-neighbor of c in A (explicitly or as a result of evaluation of our simple rules), and (3), in the completion forest F, nq L (α(f(c))). If the last condition is not satisfied, Theorem 1 guarantees that a merger between a and d is not possible in F since nq cannot be the concept set of c in F. One way to account for mergers between root nodes and generated nodes is to have rules that create these generated nodes. However, this is not practical because too many nodes might be generated, complex blocking mechanism will be required to ensure termination, and the resulting rules will not be simple enough to be efficiently evaluated by a datalog engine. Our approach to conservatively account for mergers illustrated in Figure 1 (B) is to first observe that in order for them to occur in F, the following conditions must be satisfied: a role generator ( S.C or ms, where S is a role in the Rbox) must be in the concept set of a (otherwise, a cannot have a generated node as its neighbor), and a maximum cardinality restriction nq must be in the concept set of a and, the following must hold: b must be a Q-neigbhor of a, and x must be a Q-neigbhor of a.

11 For a named individual a in the abox A, Theorem 1 allows us to check whether a maximum cardinality nq and a role generator concept ( S.C or ms ) can be present in the concept set of a in the completion forest F of A simply by checking whether they are in concept set of α(f(a)) in F. This reduces the number of potential individuals a and b such that b can become a R-neighbor of a through mergers of type (B). To further reduce this number, we need a good upper bound on the set φ a of roles P such that there is a generated node x P-neighbor of a in F, since R has to be in φ a. A direct consequence of property (B ) in the proof of Theorem 1 is that the following set is such an upper bound: {P there is a P-neigbhor of α(f(a)) in F }. Let φ f(a) be an upper bound of the set φ a that depends only on information in F. We can now express all the necessary conditions for b to possibly become a R-neighbor of a in F through a merger of type (B) in terms of information present in F : an existential restriction S.C or a minimum cardinality restriction ms must be in the concept set of α(f(a)) in F. a maximum cardinality restriction nq must be in the concept set of α(f(a)) and, the following must hold: b must be a Q-neigbhor of a (either explicitly in A or through the application of rules to estimate potential new mergers) {Q,R} φ f(a) (because there must be a generated node x which is both a Q-neighbor of a and a R-neighbor of a in F). finally, α(f(b)) must be a R-neighbor of α(f(a))(direct consequence of Theorem 1 and the fact that b has become R-neighbor of a in F) Based on the previous necessary conditions, rule U nnamedm erge in Figure 2 accounts for potential acquisition of new R-neighbors in F through merger of type (B). For transitive roles, we perform the transitive closure over the estimated inferred neigbhors (computed by rules in Figure 2). It is important to note that new relations found after the application of the transitive closure cannot cause merger rules to trigger because, in SHIN, maximum cardinality restrictions can only be defined on simple roles (i.e. roles which are not transitive and do not have transitive subrole). Finally, the rule Relevance in Figure 2 forces the rule engine to focus only on relationships appearing in the conjunctive query Q, and on the individual solutions which satisfy the membership constraints in Q, specified by the mapping β in the output of algorithm SOLVE-MQ. 5.2 Finding Definite Role Assertions After estimating potential role assertion solutions in the Abox, we identify definite or deterministically-derived role assertions, since we do not have to test for them. In particular, consider the rule N amedm erge in Figure 2 which conservatively estimates potential mergers between named Abox individuals. We can

12 (Init) InfTriple(X, R, Y) :- R(X, Y ) A (SameSym) same(x,y) :- same(y, X) (SameTrans) same(x, Y) :- same(x,z) and same(z,y) (NamedMerge) same(x, Y) :- f(z) = A and nr L (α(a)) and X Y and InfTriple(Z, R, X) and InfTriple(Z, R, Y) (SameRepl1) InfTriple(X, R, Y) :- same(x,z) and InfTriple(Z, R, Y) (SameRepl2) InfTriple(X, R, Y) :- same(y,z) and InfTriple(X, R, Z) (UnnamedMerge) InfTriple(X, R, Y) :- f(x) = A and f(y ) = B and nt L (α(a)) and ( S.C L (α(a)) or ms L (α(a))) and (α(b) is a R-neigbhor of α(a) in F ) and {R, T } φa and InfTriple(X, T, Y) (SubRole) InfTriple(X, R, Y) :- S R and InfTriple(X, S, Y) and S R (InvRole) InfTriple(X, R, Y) :- S = R and InfTriple(Y, S, X) (Relevance) RelInfTriple(X, R, Y) :- InfTriple(X, R, Y) and f(x) = A and f(y ) = B and R(x 1, x 2) Q and A β(x 1) and B β(x 2) Fig. 2. PotentialRuleSet: Rules to compute potential new named individual neighbors that are relevant to conjunctive query Q. Main output: RelInfTriple be more precise here for deterministic mergers if we somehow identify which Abox individuals mapped to summary individual A are entailed to be of type 1.R. Conceptually, this amounts to solving the membership query 1.R(A) in the summary Abox, which we evaluate efficiently using our membership query answering solution. Similar analysis is done for the rule U nnamedm erge to identify Abox individuals that have role-generators ( m.s or S.C) as an entailed type. This gives us two new rules DefnNamedMerge, DefnUnnamedMerge shown in Figure 3, which replace the rules NamedMerge, UnnamedMerge in the PotentialRuleSet (Figure 2) to produce the rule set DefnRuleSet that computes definite Abox relationship solutions. (SummaryKB Defn) K = (A, T, R) (DefnNamedMerge) same(x, Y) :- f(z) = A and K = 1R(A) and X Y and InfTriple(Z, R, X) and InfTriple(Z, R, Y) (DefnUnnamedMerge) InfTriple(X, R, Y) :- f(x) = A and f(y ) = B and K = 1T(A) and ( K = S.C(A) or K = ms(a)) and S R and S T and InfTriple(X, T, Y) Fig. 3. DefnRuleSet: Obtained by replacing NamedMerge and UnnamedMerge in the PotentialRuleSet with the rules shown 5.3 Solving Remaining Potential Role Assertions Having found potential role assertions solutions for R(x, y) in the Abox and identifying the definite ones, we are left with testing the remaining potential solutions.

13 Suppose the remaining potential tuples to test are {R(u 1,v 1 ),...R(u n,v n )}, where u k,v k, (1 k n) are Abox individuals. Instead of testing these tuples in the Abox, we test them in the summary, i.e., for a given tuple R(u k,v k ) we identify the summary individuals to which u k,v k are mapped, say a i,b j respectively, and test whether R(a i,b j ) is entailed in the summary KB. This test is done by reducing the problem to membership query answering as described in the introduction. However, the limitation here is that when we find a tuple solution R(b i,b j ) in the summary (where b i,b j are summary individuals), we cannot compute all Abox relationship solutions from it all we know is that every individual mapped to b i is entailed to have an R-relation to some individual in b j (and vice-versa, every individual mapped to b j has an R relation to some individual mapped to b i ) 7. In this case, for the sake of completeness, we are left with no choice other than to split one of the summary individuals down to the level of the Abox individuals mapped to it and test for relationships subsequently. Obviously, we choose to split the summary individual which has less Abox individuals mapped to it, to restrict the size of our summary Abox. Even in this worst case scenario, the performance of the algorithm is not severely affected as only one end of the tuple is split and the grouping of individuals is still preserved at the other end. Also, other than the tested tuples, the rest of the summary remains unchanged (so typically a large part of the Abox is still summarized). We combine the three steps discussed in this section into an algorithm SOLVE- RQ that finds all solutions to a relationship query. Solve-RQ(R(x i, x j), A, T, R, A c, f c, F c, β) Input: R(x i, x j) Relationship query, A Abox, T Tbox, R Rbox, A c Consistent Summary of A, f c Abox Summary mapping function, F c Completion forest of A c, β output mapping from Solve-MQ(..) Output: S set of pairs (a, b) s.t. (A, T, R) = R(a, b) (1) DefnInfTriple RelInfT riple computed after evaluation of DefnRuleSet using T, R, β, A c (for A ), f c (for f) (2) S DefnInfT riple (3) PotentialInfTriple RelInfTriple computed after evaluation of PotentialRuleSet using R, β, A c (for A ), f c (for f) and F c (for F ) (Note: Init rule here initializes InfTriple as a union of role assertions in A and DefnInfTriple) (4) PotentialInfTriple PotentialInfTriple - DefnInfTriple (remaining potential Abox role assertion solutions) (5) Test and Solve P otentialinft riple as described in Section 5.3 to get solution pairs S (6) S S S (7) return S 7 From a precise summary justification for R(b i, b j), we can issue an SQL query based on the justification pattern to get some relationship pair solutions in the Abox, but this would not be complete. For details, see [2]

14 6 Putting it all together Finally, our complete conjunctive query answering algorithm, SOLVE-CQ, combines SOLVE-MQ and SOLVE-RQ. Solve-CQ(Q, A, T, R) Input: Q Conjunctive query, A Abox, T Tbox, R Rbox Output: S set of tuple solutions to Q (1) [A c,f c, F c, β] Solve-MQ(Q,A,T,R) (2) foreach R(x j, x k ) in Q (3) S Rj,k Solve-RQ(R(x j, x k ), A, T, R, A c,f c, F c, β) (4) S join all relationship solutions in S Rj,k for all R(x j, x k ) in Q (5) return S 7 Computational Experience 7.1 Correctness and Scalability tests We evaluated our approach on the UOBM benchmark [7], which was modified to SHIN expressivity. We used 14 of the 15 queries defined in the benchmark (query Q2, which is a pure membership query, was not included in our evaluation). The results are reported for 1, 5, 10, 30, 100 and 150 universities. We compared our results against KAON2 [8]. (Pellet [9] did not scale to even one university). For KAON2, we set all maximum cardinality restrictions to one because of KAON2 limitations. Our experiments were conducted on a 2-way 2.4GHz AMD Dual Core Opteron system with 16GB of memory running Linux, and a maximum heap size of 2G. The Abox was stored in a IBM DB2 V9.1 for SHER and MySQL V5.0 for KAON2. Dataset type assertions role assertions 1 25K 214K 5 120K 928K K 1,816K K 6.5M M 22.4M M 33.5M (a) Dataset Statistics Table 1. Evaluation data Reasoner Dataset Avg. Time St.Dev Range KAON KAON KAON SHER SHER SHER SHER SHER SHER (b) Runtimes in sec The size of the datasets are given in Table 1 (a). Table 1 (b) summarizes the times taken (in seconds) by KAON2 and SHER solely for query answering, i.e., in both cases, the times do not include the knowledge base pre-processing and

15 setup costs. KAON2 ran out of memory on UOBM-30. In 13 out of 14 queries SHER and KAON2 had 100% agreement. The difference on query Q15 was due to differences in the constraints used. As can be seen, the average runtimes for SHER are significantly lower, usually by an order of magnitude, than those for KAON2. [2] presents more detailed data on the evaluation performance for each query on each KB. On all queries, except query 9, SHER scales almost linearly from UOBM-1 to UOBM-150. Query 9, which has 3 role atoms, is an example of a query where we can improve our performance by using a cost model based approach to control the order of evaluation of query atoms as explained in [6]. 7.2 Handling Non-deterministic Mergers In experiments described in the previous subsection, UOBM queries did not exploit non-deterministic mergers between individuals in the Abox to produce new inferred results. Therefore, we modified the UOBM dataset to generate new relationships from non-deterministic mergers between named individuals, and considered a new query whose solutions required this. We added disjoint relations between the four UOBM concepts FineArts, Science, HumanitiesAndSocial, Engineering representing course subjects, and a set of Abox assertions each resembling the pattern shown in Figure 4. The newly added individual LS 1 had typeleisurestudent, which is defined as ( 3. takescourse) in the UOBM Tbox. LS 1 was assigned four takescourse relations to individuals C 1..C 4 respectively. In general, we randomly added any one of the four course subjects mentioned above as a type to C i, 1 i 3 (C 4 is always assigned the type Course). In the case shown, C 1,C 2,C 3 are mutually disjoint concepts and hence the maxcardinality restriction in the type of LS 1 causes a non-deterministic merger between C 4 and any one C j (1 j 3), which in turn causes C 4 to acquire a new istaughtby relation to the Lecturer individual L 1. To exploit this behavior, we considered the query: Q ND : (x, y, z) LeisureStudent(x) takescourse(x, y) Course(y) ist aughtby(y, z) Lecturer(z). In the example shown, there are 4 tuple solutions to Q ND, three of which are explicit (LS 1,C 1 /C 2 /C 3,L 1 ), and one is inferred (LS 1,C 4,L 1 ). We modified UOBM-1, UOBM-5 and UOBM-10 by adding 100, 200 and 300 instances of LeisureStudent respectively. These numbers and datasets were chosen since as the pattern in Figure 4 shows, generation of new relationships due to non-deterministic mergers is non-trivial and seldom seen in large quantities in practice. We then evaluated Q ND on the modified datasets. KAON2 is unable to handle this query since it cannot deal with non-deterministic mergers. Results of this query evaluation using SHER are shown in Figure 5. In the table, the column E (resp. I) stands for the number of explicit (resp. inferred) solutions for the query introduced by our script, P A, computed in step (4) of SOLVE- RQ, is the number of potential relationship pairs in the Abox that need to be tested, P A is the number of summary pairs corresponding to the Abox pairs counted in P A, and S A is the number of summary solution tuples found using the procedure described in Section 5.3, which are eventually split down to the individual level.

16 Dataset Time E I P A P A S A (in s) Fig. 5. Evaluating Q ND Fig. 4. Abox pattern creating new istaughtby relations from non-deterministic mergers As the results show, the algorithm demonstrates a graceful degradation for this query. For example, in UOBM-10, there are = 938 entailed istaughtby relationships (152 due to non-deterministic mergers 8 ), however our algorithm finds, in step(4) of SOLVE-RQ, that only 319 need to be tested. Moreover, they are first tested through their corresponding summary pairs as explained in Section 5.3. As result, only 15 out of 100 summary pairs are found to be solutions 9, and only one end of these 15 pairs are split down to the individual level. We feel that the times shown are acceptable for realistic use-cases. 8 Related Work & Conclusions Scalable reasoning algorithms exist for Aboxes in secondary storage, but they either assume role-free Aboxes [10], or relatively inexpressive-dls [11]. For the more expressive OWL-DL, state-of-the-art tableau reasoners such as Pellet and RACER have recently incorporated optimizations to support conjunctive query answering over large Aboxes ([6], [12]). Inspired by relational-database join optimizations, the systems use various heuristics to estimate a cost-model for evaluating the various query atoms in the conjunctive query, to determine an efficient join order. Additionally, the completion forest of the Abox (aka pseudo-model) is used to identify obvious solutions and non-solutions to a query. Finally, Tbox and Rbox information is used to rewrite conjunctive queries into a simpler form. However, a fundamental limitation is that they work with the complete Abox, 8 Only istaughtby relations can be inferred due to non-deterministic mergers. 9 Not all potential relationships are solutions since the script may not necessarily add disjoint subject types to individuals C 1, C 2, C 3.

17 and the complexity of the tableau reasoning algorithm makes it infeasible to build a completion forest for a large and expressive Abox, which affects both solution pruning and testing. For this reason, the current implementations of these systems scale to thousands but not millions of Abox assertions. On the other hand, KAON2, which we included in our evaluation, is a nontableau based approach that relies on translating Description Logic to disjunctive datalog [13] and is able to scale to an Abox with a million assertions. However, KAON2 has problems dealing with max-cardinality restrictions (for cardinality greater than 1) and even excluding such restrictions, is unable to scale to an Abox with 7 million assertions. Our technique appears to scale almost linearly for conjunctive queries of large, expressive Aboxes composed of million Abox assertions. As future work, we plan to integrate a cost-model to determine an efficient join order for the query atoms. References 1. Dolby, J., A.Fokoue, Kalyanpur, A., A.Kershenbaum, L.Ma, E.Schonberg, K.Srinivas: Scalable semantic retrieval through summarization and refinement. Proc. of the 22nd Conf. on Artificial Intelligence (AAAI 2007) (2007) 2. Dolby, J., Fokoue, A., Kalyanpur, A., Ma, L., Schonberg, E., Srinivas, K., Sun, X.: Scalable conjunctive query evaluation: Technical report. In: projects.nsf/pages/iaa.index.html/$file/techreportcq.pdf. (2008) 3. Kalyanpur, A., Parsia, B., Horridge, M., Sirin, E.: Finding all justifications of owl dl entailments. In: Proc. of Int. Semantic Web Conf. (ISWC-2007). (2007) 4. A.Fokoue, A.Kershenbaum, L.Ma, E.Schonberg, K.Srinivas: The summary abox: Cutting ontologies down to size. Proc. of the Int. Semantic Web Conf. (ISWC 2006) (2006) Horrocks, I., Sattler, U., Tobies, S.: Reasoning with individuals for the description logic SHIQ. Proc. of 17th Int.Conf. on Automated Deduction (2000) Sirin, E., Parsia, B.: Optimizations for answering conjunctive abox queries: First results. In: Proc. of the Description Logics Workshop. (DL-06). (2006) 7. Ma, L., Yang, Y., Qiu, Z., Xie, G., Pan, Y.: Towards a complete owl ontology benchmark. In: Proc. of the third European Semantic Web Conf.(ESWC 2006). (2006) Hustadt, U., Motik, B., Sattler, U.: Reducing shiq - description logic to disjunctive datalog programs. Proc. of the 9th Int. Conf. on Knowledge Representation and Reasoning (KR 2004) (2004) 9. Sirin, E., Parsia, B.: Pellet: An owl dl reasoner. In: Description Logics. (2004) 10. Bechhofer, S., Horrocks, I., Turi, D.: The owl instance store: System description. Proc. of 20th Int.Conf. on Automated Deduction (2005) Calvanese, D., Giacomo, G.D., Lembo, D., Lenzerini, M., Rosati, R.: Dl-lite: Tractable description logics for ontologies. Proc. of AAAI (2005) 12. Moller, R., Haarslev, V., Wessel, M.: On the scalability of description logic instance retrieval. In: Proc. of the Description Logics Workshop. (DL-06). (2006) 13. U.Hustadt, Motik, B., Sattler, U.: Reducing shiq description logic to disjunctive datalog programs. (Proc. of 9th Intl. Conf. on Knowledge Representation and Reasoning (KR2004))