Converting Instance Checking to Subsumption: A Rethink for Object Queries over Practical Ontologies

Efficiently querying Description Logic (DL) ontologies is becoming a vital task in various data-intensive DL applications. Considered as a basic service for answering object queries over DL ontologies, instance checking can be realized by using the most specific concept (MSC) method, which converts instance checking into subsumption problems. This method, however, loses its simplicity and efficiency when applied to large and complex ontologies, as it tends to generate very large MSCs that could lead to intractable reasoning. In this paper, we propose a revision to this MSC method for DL SHI, allowing it to generate much simpler and smaller concepts that are specific enough to answer a given query. With independence between computed MSCs, scalability for query answering can also be achieved by distributing and parallelizing the computations. An empirical evaluation shows the efficacy of our revised MSC method and the significant efficiency achieved when using it for answering object queries.


Introduction
Description logics (DLs) play an ever growing role in providing a formal and semantic-rich way to model and represent structured data in various applications, including semantic web, healthcare and biomedical research, etc. [1]. A knowledge base in description logic, usually referred to as a DL ontology, consists of an assertional component (ABox ) for data description, where individuals (single objects) are introduced and their mutual relationships are described using assertional axioms. Semantic meaning of the ABox data can then be unambiguously specified by a terminological component (TBox ) of the DL ontology, where abstract concepts and roles (binary relations) of the application domain are properly defined.
In various applications of description logics, one of the core tasks for DL systems is to provide an efficient way to manage and query the assertional knowledge (i.e. ABox data) in a DL ontology, especially for those data-intensive applications; and DL systems are expected to scale well with respect to (w.r.t.) the fast growing ABox data, in settings such as semantic webs or biomedical systems. The most basic reasoning service provided by existing DL systems for retrieving objects from ontology ABoxes is instance checking, which tests whether an individual is a member of a given concept. Instance retrieval (i.e. retrieve all instances of a given concept) then can be realized by performing a set of instance checking calls.
In recent years, considerable efforts have been dedicated to the optimization of algorithms for ontology reasoning and query answering [2]- [4]. However, due to the enormous amount of ABox data in realistic applications, existing DL systems, such as HermiT [4] [5], Pellet [6], Racer [7] and FaCT++ [8], still have difficulties in handling the large ABoxes, as they are all based on the (hyper) tableau algorithm that is computationally expensive for expressive DLs (e.g. up to EXPTIME for instance checking in DL ), where the complexity is usually measured in the size of the TBox, the ABox and the query [9]- [13]. In practice, since the TBox and the query are usually much smaller compared with the ABox, the reasoning efficiency could be mostly affected by the size of the ABox.
One of the solutions to this reasoning scalability problem is to develop a much more efficient algorithm that can easily handle large amount of ABox data. While another one is to reduce size of the data by either partitioning the ABox into small and independent fragments that can be easily handled in parallel by existing systems [14]- [16], or converting the ABox reasoning into a TBox reasoning task (i.e. ontology reasoning without an ABox), which could be "somewhat" independent of the data size, the TBox is static and relatively simple, as demonstrated in this paper.
A common intuition about converting instance checking into a TBox reasoning task is the so-called most specific concept (MSC) method [10] [17] [18] that computes the MSC of a given individual and reduces any instance checking of this individual into a subsumption test (i.e. test if one concept is more general than the other). More precisely, for a given individual, its most specific concept should summarize all information of the individual in a given ontology ABox, and should be specific enough to be subsumed by any concept that the individual belongs to. Therefore, once the most specific concept C of an individual a is known, in order to check if a is an instance of any given concept D, it is sufficient to test if C is subsumed by D. With the MSC of every individual in the ABox, the efficiency of online object queries can then be boosted by performing an offline classification of all MSCs that can pre-compute many instance checks [10]. Moreover, if a large ontology ABox consists of data with great diversity and isolation, using the MSC method for instance checking could be more efficient than the original ABox reasoning, since the MSC would have the tableau algorithm to explore only the related information of the given individual, potentially restricted to a small subset of the ABox. Also, this method allows the reasoning to be parallelized and distributed, since MSCs are independent of each other and each preserves complete information of the corresponding individual.
Despite these appealing properties possessed by the MSC method, the computation of a MSC could be difficult even for a very simple description logic such as . The difficulty arises mainly from the support of qualified existential restrictions (e.g. ∃R.C) in DLs, such that when converting a role assertion (e.g. R(a,b)) of some individuals into an existential restriction, so that information of that given individual may not be preserved completely. For a simple example, consider converting assertions into a concept for individual a . In this case, we can always find a more specific concept for a in the form of by increasing n , and none of them would capture the complete information of individual a . Such information loss is due to the occurrence of cycles in the role assertions, and none of the existential restrictions in DL could impose a circular interpretation (model) unless nominals (e.g. {a}) are involved or (local) reflexivity is presented [5].
Most importantly, due to the support of existential restrictions, computation of the MSC for a given individual may involve assertions of other entities that are connected to it through role assertions. This implies not only the complexity of the computation for MSCs but also the potential that the resulting MSCs may have larger than desired sizes. In fact, in many of the practical ontology ABoxes (e.g. a social network or semantic webs), most of the individuals could be connected to each other through role assertions, forming a huge connected component in the ABox graph. Under this situation, the resulting MSC could be extremely large and reasoning with it may completely degenerate into an expensive reasoning procedure.
In this paper, we propose a revised MSC method for DL that attempts to tackle the above mentioned problems, by applying a call-by-need strategy together with optimizations. That is, instead of computing the most specific concepts that could be used to answer any queries in the future, the revised method takes into consideration only the related ABox information with current query and computes a concept for each individual that is only specific enough to answer it w.r.t. the TBox. Based on this strategy, the revision allows the method to generate much simpler and smaller concepts than the original MSCs by ignoring irrelevant ABox assertions. On the other hand, the complexity reduction comes with the price of re-computation (i.e. online computation of MSCs) for every new coming query, if no optimization is applied. Nevertheless, as shown in our experimental evaluation, the simplicity achieved could be significant in many practical ontologies, and the overhead is thus negligible compared with the reasoning efficiency gained for each instance checking and query answering. Moreover, due to the re-computations, we do not assume a static ontology or query, and the ABox data is amenable to frequent modifications, such as insertion or deletion, which is in contrast to the original MSC method where a relatively static ABox is assumed. A procedure for instance retrieval based on our revised MSC method is shown in Figure 1.
The revised MSC method could be very useful for efficient instance checking in many practical ontologies, where the TBox is usually small and manageable while the ABox is in large scale as a database and tends to change frequently. Particularly, this method would be appealing to large ontologies in non-Horn DLs, where current optimization techniques such as rule-based reasoning or pre-computation may fall short. Moreover, the capability to parallelize the computation is another compelling reason to use this technique, in cases where answering object queries may demand thousands or even millions of instance checking tasks.
Our contributions in this paper are summarized as follows:

1)
We propose a call-by-need strategy for the original MSC method, instead of computing the most specific concepts offline to handle any given query, which allows us to focus on the current queries and to generate online much smaller concepts that are sufficient to compute the answers. This strategy makes our MSC method suitable for query answering in ontologies, where frequent modifications to the ontology data are not uncommon;

2)
We propose optimizations that can be used to further reduce sizes of computed concepts in practical ontologies for more efficient instance checking;

3)
Finally, we evaluate our approach on a range of test ontologies with large ABoxes, including ones generated by existing benchmark tools and realistic ones used in biomedical research. The evaluation shows the efficacy of our proposed approach that can generate significantly smaller concepts than the original MSC. It also shows the great reasoning efficiency that can be achieved when using the revised MSC method for instance checking and query answering.
The rest of the paper is organized as follows: in Section 2, we introduce the background knowledge of a description logic and DL ontology; in Section 3, we give more detailed discussion about the MSC method and our call-by-need strategy; Section 4 presents the technical details of the revised MSC method; Section 5 discusses the related work; Section 6 presents an empirical evaluation on our proposed method; and finally, Section 7 concludes our work.

Preliminaries
The technique proposed in this paper is for description logic . For technical reasons, we need a constrained use of nominals on certain conditions (i.e. assertion cycles), which requires logic . Thus, in this section, we give a brief introduction to formal syntax and semantics of logic , DL ontologies, and basic reasoning tasks for derivation of logical entailments from DL ontologies.

Description Logic
The vocabulary of description logic includes a set R of named roles with a subset of R + ⊆ R of transitive roles, a set C of named (atomic) concepts, and a set I of named individuals.

Definition 2.1 (
Role)-A role in is either a named (atomic) one R ∈ R or an inverse one Rwith R ∈ R, and the complete role set of can be denoted R* = R ∪ {R -|R ∈ R}. To avoid role representation such as R --, a function Inv(·) is defined, such that Inv(R) = R -Rif R is a role name, and Inv(R) = P if R = Pfor some role name P . A role R is transitive, denoted Trans(R), if either R or Inv(R) belongs to R + .

Definition 2.2 ( Concept)-A
-concept is either an atomic (named) concept or a complex one that can be defined using the following constructs recursively where A is an atomic concept C, o in is a named individual, and R ∈ R*.

Description logic
is then defined as a fragment of , which disallows the use of nominal (i.e. {o}) as a construct for building complex concepts. For example, given an atomic concept A , both A and ∃R.A are simple-form concepts, while ∃R 1 .(A∃R 2 .A) is not, since its maximum level of nested quantifiers is two. Notice however, an arbitrary concept can be linearly reduced to the simple form by assigning new concept names for fillers of the quantifiers. For example, ∃R 1 .∃R 2 .C can be converted to ∃R 1 .D by letting D ≡ ∃R 2 .C where D is a new concept name.
Assumption: For accuracy of the technique presented in this paper, without loss of generality, we assume all ontology concepts are in simple form as defined previously, and the concept in any concept assertion is atomic.

Definition 2.5 ( Ontology)-A ontology is a tuple, denoted
, where is called a TBox and is called an ABox.
The TBox is constituted by a finite set of role inclusion axioms (i.e. R 1 ⊑ R 2 with R 1 , R 2 ∈ R*) and a finite set of concept inclusion axioms in the form of C ⊑ D and C ≡ D , where C , D are concepts. The former is called a general concept inclusion axiom (GCI), and the latter can be simply converted into two GCIs as C ⊑ D and D ⊑ C .
The ABox consists of a finite set of assertions, in the form of A(a) (concept assertion) and R(a,b) (role assertion), where A is a concept, R is a role, and a, b are named individuals in I . In a role assertion R(a,b) , individual a is referred to as a R -predecessor of b , and b is a R - An interpretation satisfies an axiom C ⊑ D (written ), iff , and satisfies an axiom or assertion: If satisfies every axiom and assertion of an ontology , is called a model of , written . In turn, is said satisfiable iff it has at least one model; otherwise, it is unsatisfiable or inconsistent.

Definition 2.6 (Logical Entailment)-Given an ontology
and an axiom α , α is called a logical entailment of , denoted , if α is satisfied in every model of .

Definition 2.7 (Instance Checking)-Given an ontology , a DL concept C and an
individual a ∈ I , instance checking is defined to test if holds.
Notice that, instance checking is considered the central reasoning service for information retrieval from ontology ABoxes [19], and more complex reasoning services, such as instance retrieval, can be realized based on this basic service. Instance checking can also be viewed as a procedure of individual "classification" that verifies if an individual can be classified into some defined DL concepts. An intuition to implement this instance checking service is to convert it into a concept subsumption test by using the so-called most specific concept (MSC) method.

Definition 2.8 (Most Specific Concept [20])-Let
be an ontology, and a be an individual in I . A concept C is called the most specific concept for a w.r.t. , written , if for every concept D that , .
The MSC method turns the instance checking into a TBox reasoning problem. That is, once the most specific concept of an individual a is known, to decide if holds for an arbitrary concept D , it suffices to test if [10].

Classification of Individuals
The MSC method for individual checking is based on the idea that, an individual can be classified into a given concept D , if and only if there exists a concept behind its ABox assertions subsumed by D [17] [18] [20]. Computation of the MSC for a given individual then demands converting its ABox assertions into a concept. This task can be easily accomplished if the individual possesses only concept assertions, by simply collapsing the involved concepts into a single term using the concept conjunction. When role assertions are involved, however, a more complex procedure is demanded, and the method we used here is called rolling-up [23], which is elaborated in the next section.
Using the MSC method for instance checking might eliminate the memory limitation for reasoning with large ABoxes, especially when the ABox consists of data in great diversity and isolation. This is simply because each computed should comprise of only related information of the given individual, and makes the subsumption test (i.e. ) as efficient as an ontology reasoning that explores only a (small) portion of .
However, as discussed in Section 1, due to the support of existential restrictions in DLs, great complexity for computation of MSC's may arise when role assertions are involved.
Besides, due to the completeness that should be guaranteed by each i.e. the MSC should be subsumed by any concept that the individual a belongs to.), the resulting MSC's may turn out to be a very large concept, whenever there is a great number of individuals in connected to each other by role assertions. In the worst case, reasoning with a MSC may degenerate into a complete ABox reasoning that could be prohibitively expensive. For example, when preserves complete information of , its interpretation will form a tableau, the size of which can be in the same scale of .

The Call-by-Need Strategy
Since the larger than desired sizes of MSCs are usually caused by its completeness as discussed above, a possible optimization to the MSC method is thus to abandon the completeness that is required to deal with any query concepts, and to apply a "call-by-need" strategy. That is, for an arbitrary query concept D , instead of computing the MSC for each individual a , we compute a concept that is only specific-enough to determine if a can be classified into D . As suggested by its name, this revision to the original MSC method, instead of taking the complete information of individual a , when computing the "MSC", will consider only the ABox assertions that are relevant to the current query concept.
A simple way to realize this strategy is to assign a fresh name A every time to a given (complex) query concept D by adding the axiom A ≡ D to 1 , and to concentrate only on ABox assertions that would (probably) classify an individual a into A w.r.t. . Consequently, this implementation requires an analysis of the ontology axioms/assertions, such that the possibility of each role assertion to affect individual classification (w.r.t. named concept in ) can be figured out. Computation of a specific-enough concept should then concentrate on role assertions that are not impossible. We abuse the notation here to denote this specifi-cenough concept for individual a w.r.t. ABox , current query concept , and named concepts in as , and we call the method that uses for instance checking the method.

Definition 3.1
Let be an ontology, a be an individual in , and a current query concept for individuals. A concept C is called a specific-enough concept for a w.r.t. named concepts in , and , written , if , .
Since in our procedure we will add the query concept into as a named concept, we can simplify the notation as .

A Syntactic Premise
To decide whether a role assertion could affect classification of a given individual, a sufficient and necessary condition as stated previously is that, the concept behind this assertion conjuncted with other essential information of the individual should be subsumed by the given concept w.r.t. [17] [18] [20]. Formally, for a role assertion R(a,b) that makes individual a classified into a concept A , the above sufficient and necessary condition in can be expressed as: (1) where b ∈ B is entailed by , and concept A 0 summarizes the rest of the information of a that is also essential to this classification, with A 0 ⊑ A .
As shown in [16], for subsumption (1) to hold when A is a named concept, there must exist some role restriction ∃R′.C with R ⊑ R′ in left-hand side of TBox axioms (see (2) and the following axiom equivalency) for concept definition; otherwise ∃R.B is not comparable (w.r.t. subsumption) with other concepts (except Τ and its equivalents). This syntactic condition for the deduction of (1) is formally expressed in the following proposition.

Proposition 3.1 ([16])-Let be a ontology with simple-form concepts only, ∃R.B, A 0 and A be concepts, where A is named. If
with A 0 ⋢ A , there must exist some GCIs in in the form of: (2) where R ⊑ R′ and ⋈ is a place holder for ⊔ and ⊓ , C i 's are concepts. Also note the following equivalence: This proposition is proven in [16]. It states in fact a syntactic premise in for a role assertion to be essential for some individual classification. That is, if a role assertion R(a, b) is essential for derivation of A(a) for some named concept A , there must exist a related axiom in in the form of (2) for R ⊑ R′ . We denote this syntactic premise for R(a, b) to affect a 's classification as SYN_COND . Using this condition, we can easily rule out role assertions that are definitely irrelevant to the query concept and will not be considered during the computation of a .

Computation of MSC T
In this section, we present the technique that computes a for a given individual w.r.t. a given query. We assume the ABox considered here is consistent, since for any inconsistent ABox, the is always the bottom concept ⊥ [24]. Essentially, the task is to convert ABox assertions into a single concept for a given individual, using the concept conjunction and the so-called rolling-up technique. This rolling-up technique was introduced in [23] to convert conjunctive queries into concept terms, and was also used by [25] to transform datalog rules into DL axioms. We adapt this technique here to roll up ABox assertions into DL concepts.

The Rolling-Up Procedure
Converting concept assertions into a concept is straightforward by simply taking conjunction of the involved concepts. When role assertions are involved, the rolling-up technique can be used to transform assertions into a concept by eliminating individuals in them. For example, given the following assertions (3) transforming them for individual Tom using the rolling up and concept conjunction can generate a single concept assertion Generalize the Information-The transformation here is for individual Tom, and if individual Mary is not explicitly indicated in the query, it should be sufficient to rewrite has Parent (Tom,Mary), Lawyer (Mary) into ∃has Parent.Lawyer (Tom) , without loss of any information that is essential for query answering. Even if Mary is explicitly indicated in the query, we can still eliminate it by using a representative concept that stands for this particular individual in the given ABox [26]. For example, we can add an assertion A mary (Mary) to the ABox, where A mary is a new concept name and a representative concept for individual Mary. The above role assertions for Tom then can be transformed into concept ∃has Parent.(Lawyer ⊓ A mary )(Tom)(Mary) ; and if the query is also rewritten using concept Mary, the completeness of the query answering can be guaranteed, as indicated by the following theorem [26]. The rolling-up procedure here can be better understood by considering a graph induced by the role assertions to be rolled up, which is defined as follows:

Definition 4.1-A set of ABox role assertions in
can be represented by a graph , in which there is a node x for each individual x in the assertions, and an edge between node x and y for each role assertion R( x, y) .
Notice that, due to the support of inverse roles in , edges in are not directed. A role path in the graph is then defined as a set of roles corresponding to the set of edges (no duplicate allowed) leading from one node to another. For example, given assertions R 1 (x, y) and R 2 (x, y), the role path from x to z is , and its reverse from z to x is  (3), we simply treat this individual as the root, and roll up assertions from leaves to root to generate the concept Transitive Role: In the rolling-up procedure, no particular care needs to be taken to deal with transitive roles, since any role assertions derived from transitive roles will be automatically preserved [26]. For example, given R a transitive role, R(a,b) , R(b,c) two role assertions, and B(b), C(c) two concept assertions in the ABox, rolling-up these four assertions for individual a can generate assertion ∃R.(B ⊓ ∃R.C)(a) , from which together with the TBox axioms, we can still derive the fact that Assertion Cycles: This rolling-up technique, however, may suffer information loss if the graph contains cycles (i.e. a role path leading from one node to itself without duplicate graph edges). For example, given the following two assertions: individuals x and y are related by two roles, and a cycle is thus induced in the corresponding graph. Rolling-up assertions for individual x using the method described above might generate concept , and the fact that x is connected to the same individual y through different roles is lost. Consequently, this may compromise the resulting concept as a specific-enough concept for x to answer the current query. For example, let C be a query concept defined as: It can be found out through ABox reasoning that individual x is an instance of C ; while on the other hand, it is also not difficult to figure out that is not subsumed by C .
Multiple solutions to this problem have been proposed, such as an approximation developed by [27], and the use of cyclic concept definition with greatest fixpoint semantics [24] [28]. In this paper, we choose to use the nominal (e.g. {x}) to handle circles as suggested by [19] [20], which allows explicit indication of named individuals in a concept, hence, being able to indicate the joint node of a cycle. The above two assertions in (4) then can be transformed into a concept for individual x as either or , each with the nominal used for a chosen joint node, and both preserve complete information of the cycle. In our approach, when rolling up a cycle in , we always treat the cycle as a single branch and generate concepts of the second style. That is, our procedure will treat a chosen joint node x as both the tail (i.e. leaf) and the head (i.e. root) of the branch. For clarity of the following presentation, we denote the tail as x t and the head as x h .
Based on the discussion so far, the transformation of assertions for a given individual now can be formalized as follows. Let x be a named individual, and γ be an ABox assertion for x . γ can be transformed into a concept C γ for x : Notice that, concept D here is a obtained concept when rolling up branch(es) in up to node y , and transforming any assertion of a cycle tail x t always generates {x t }, as complete information of x will be preserved when rolling up to the head x h . Thereafter, given a set S of all assertions of individual x , can be obtained by rolling up all branches induced by role assertions in S and taking the conjunction of all obtained concepts. When S is empty, however, individual x in the ABox can only be interpreted as an element of the entire domain, and thus, the resulting concept is simply the top entity . Computation of a then can be formalized using the following equation:

Branch Pruning
To apply the call-by-need strategy, the previously defined syntactic premise SYN_COND is employed, and a branch to be rolled up in graph will be truncated at the point where the edge does not have SYN_COND satisfied. More precisely, if an assertion R(x, y) in a branch does not have the corresponding SYN_COND satisfied, it will not affect any classification of individual x w.r.t. . Moreover, any effects of the following assertions down the branch will not be able to propagate through R(x, y) to x , and thus should not be considered during the rolling-up of this branch.
This branch pruning technique could be a simple yet an efficient way to reduce complexity of a , especially for those practical ontologies, where many of the ABox individuals may have a huge number of role assertions and only a (small) portion of them have SYN_COND satisfied. For a simple example, consider an individual x in an ontology ABox with the following assertions: where n could be a very large number and only R 1 has SYN_COND satisfied. Rolling up these assertions for individual x without the pruning will generate the concept where y i ∈ C i . Using this concept for any instance checking of x could be expensive, as its interpretation might completely restore the tableau structure that is induced by these assertions. However, when the pruning is applied, the new should be ∃R 1 .C 1 , the only role restriction that is possible to affect individual classification of x w.r.t. named concepts in .
Going beyond such simple ontologies, this optimization technique may also work in complex ontologies, where most of the role assertions in ABox could have SYN_COND satisfied. For example, consider the following assertions with all roles except R 2 having SYN_COND satisfied. Rolling up these assertions for individual x 0 will start from the leaf x n+1 up towards the root x 0 , and generate the concept where x n+1 ∈ C . However, with pruning applied, the rolling-up in this branch will start from x 2 instead of x n+1 , since R 2 (x 2 , x 3 ) will not affect classification of individual x 2 w.r.t. and the branch is truncated at this point. Furthermore, with branch pruning, cycles should only be considered in the truncated graph, which may further simplify the computation of 's.

Further Optimization and Implementation
The branch pruning here is based on SYN_COND to rule out irrelevant assertions, which in fact can be further improved by developing a more rigorous premise for a role assertion to affect individual classification. For exposition, consider the following ontology : When computing using the proposed method, assertion R(a,b) will be rolled up as the corresponding SYN_COND is satisfied. However, it is not difficult to see that, R(a,b) here actually makes no contribution to a 's classification, since individual b is in the complement of concept C , making a an instance of . Besides, individual a has already been asserted as an instance of concept , and hence cannot be classified into D unless the ABox is inconsistent.
With these observations, a more rigorous premise based on SYN_COND can be derived. That is, to determine the possibility for R(a,b) to affect classification of individual a , beyond checking in the existence of any axiom in the form of with R ⊑ R′ and ⋈ a place holder for ⊔ and ⊓ , we also check the following cases for any found axiom: , respectively for ⋈ standing for ⊓ or ⊔ .
If either one of the above cases happens, that particular ∃R′.C 1 in the left hand side of the axiom in fact makes no contribution to the inference of a's classification, unless the ABox is inconsistent where MSCs are always ⊥ [24]. Thus, a revised condition requires not only the existence of a related axiom in the form of (2) but also with none of the above cases happening. We denote this condition as SYN_COND* , and use it to rule out assertions that are irrelevant to the current query.
This optimization is useful to prevent rolling-up of role assertions in an arbitrary direction on existence of related axioms in . Instead, it limits the procedure to the direction that is desired by the original intention underlying the design of the given ontology. For example, in (5), the axiom ∃R.C ⊑ D specifies that, any individual having a R -neighbor in C is an instance of D and any individual having a R − -neighbor in is an instance of 3 .
However, if individual x is asserted to have a R -neighbor in or a R --neighbor in D , that role assertion should not be rolled-up for x just on existence of this axiom.
With all the insights discussed so far, an algorithm for computation of is presented here as a recursive procedure, the steps of which are summarized in Figure 2. Basis: For a leaf node x in , which has no other role assertions except those up the branches, rolling it up yields the conjunction of concepts in its concept assertions, which preserves sufficient information of the part of the branch being rolled so far. If x is the tail of a cycle, returning {x t } is sufficient, as other information of x will be gathered when the rolling-up comes to the head.

Inductive
Step: Let x be a node in the middle of some branch(es) in . For every role assertion R i (x,y i ) of x down the branch, assume the procedure generates a concept D i for rolling up to each node y i , which preserves sufficient information (w.r.t. current query) of the part of branches being rolled up so far. Then, rolling up each R i (x, y i ) generates ∃R.D i , and together with concept assertions of x, the concept conjunction preserves sufficient information of all branches being rolled up to x . If x is marked as a joint node of a cycle, {x h } is also in the conjunction, so that the circular path property can be preserved. If x is the root node, the conjunction is thus a that preserves sufficient information of x w.r.t. current query.
This algorithm visit every relevant ABox assertion at most once, and it terminates after all related assertions are visited.

Related Work
The idea of most specific concept for instance checking was first discussed in [18], and later extensively studied by [17] [20] for the algorithms and the computational complexity. To deal with existential restrictions when computing the most specific concept, [24] [28] [29] discussed the use of cyclic concepts with greatest fixpoint semantics for preservation of information induced by the role assertions, and [27] also proposed an approximation for most specific concept in DLs with existential restrictions.
A common direction of these optimization techniques is to reduce the high degree of nondeterminism that is mainly introduced by GCIs in the TBox: given an GCI C ⊑ D , it can be converted to a disjunction , for which a tableau algorithm will have to nondeterministically choose one of the disjuncts for tableau expansion, resulting in an exponential-time behavior of the tableau algorithm w.r.t. the data size. Absorption optimizations [22] [31] [32] were developed to reduce such nondeterminism by combining GCIs for unfoldable concepts, such that the effectiveness of lazy unfolding can be maximized. For example, axioms A ⊑ C and A ⊑ D can be combined into A ⊑ C ⊓ D, where A is a named concept; then the inference engine can deduce C ⊓ D (a) if the ABox contains A (a). Notice however, this technique may allow only parts of TBox axioms to be absorbed, thus, may not be able to eliminate all sources of nondeterminism especially when ontologies are complex. Based on the absorption optimization, [33] proposed an approach for efficient ABox reasoning for that will convert ABox assertions into TBox axioms, apply a absorption technique on the TBox, and covert instance retrieval into concept satisfaction problems.
Another way to reduce nondeterminism is the exploration of Horn clauses in DLs, since there exist reasoning techniques for Horn clauses that can be deterministic [5] [34]. [5] takes advantage of this in their HermiT reasoner by preprocessing a DL ontology into DL-clauses and invoking the hyperresolution for the Horn clauses, avoiding unnecessary nondeterministic handling of Horn problems in existing DL tableau calculi.
For non-Horn DL, techniques such as model merging [2] and pseudo model merging [30] can be used to capture some deterministic information of named individuals. These techniques are based on the assumption of a consistent ABox and the observation that usually individuals are members of a small number of concepts. The (pseudo) model merging technique merges clash-free tableau models that are constructed by disjunction rules for a consistent ABox, and can figure out individuals that are obviously non-instance of a given concept. For example, if in one tableau model individual a belongs to concept C while in another a belongs to , it is then obvious that individual a cannot be deterministically inferred to be an instance of concept C , thus, eliminating the unnecessary instance checking for C(a) .
Another option for scalable ABox reasoning is the use of tractable DL languages. For example, the description logic EL and its extension EL ++ , which allow existential restrictions and conjunction as introduced by [35] [36], possess intriguing algorithmic properties such that the satisfiability problem and implication in this DL language can be determined in polynomial time. Another notable example of lightweight DLs is the socalled DL-LITE family identified by [37], which is specifically tailored to capture basic DL properties and expressivity while still be able to achieve low computational complexity for both TBox and ABox reasoning. In [9] [38] they further identified that, for conjunctive queries that are FOL-reducible, answering them in ontologies of any DL-LITE logic enjoys a LOGSPACE data complexity.
Based on the above lightweight DLs, efficient DL reasoners are developed, such as OWLIM [39], ELK reasoner [40], and Oracle's native inference engine for RDF data sets [41]. [42] proposed an approximation technique for instance retrieval, which computes both lower bound and upper bound of an answer set of individuals for a given query concept. Their approach invokes an axiom rewriting procedure that converts an ontology in Horn DL into a datalog program, and then uses Oracle's native inference engine to derive the bounds for query answering.
Recently, techniques for partitioning or modularizing ABoxes into logically-independent fragments have been developed [15] [16]. These techniques partition ABoxes into logicallyindependent modules, such that each will preserve complete information of a given set of individuals, and thus can be reasoned independently w.r.t. the TBox and be able to take advantage of existing parallel-processing techniques.

Empirical Evaluation
We implemented the rolling-up procedures for computation of 's based on the OWL API 4 , and evaluated the MSC method for instance checking and retrieving on a lab PC with Intel(R) Xeon(R) 3.07 GHz CPU, Windows 7, and 1.5 GB Java Heap. For the test suite, we have collected a set of well-known ontologies with large ABoxes:

2)
Arabidopsis thaliana (AT) and Caenorhabditis elegans (CE) are two biomedical ontologies 5 , sharing a common TBox called Biopax that models biological pathways;

3)
DBpedia* (DP) ontologies are extended from the original DBpedia ontology [44]: expressivity of their TBox is extended from to by adding complex roles and concepts defined on role restrictions; their ABoxes are obtained by random sampling on the original triple store.
Details of these ontologies can be found in Table 1, in terms of DL expressivity, number of atomic concepts (# Cpts), TBox axioms (# Axms), named individuals (# Ind.), and ABox assertions (# Ast.). Notice that, DL expressivity of AT and CE is originally , but in our experiments, number restrictions (i.e. ) in their ontology TBox are removed.

Complexity of
Using the MSC (or ) method, the original instance checking problem is converted to a subsumption test, the complexity of which could be computationally high w.r.t. both size of a TBox and size of the testing concepts [10]. Therefore, when evaluating the rolling-up procedure for computation of 's, one of the most important criteria is the size of each resultant , as it is the major factor to the time efficiency of a subsumption test, given a relatively static ontology TBox.
As we already know, one of the major source of complexity in ontology reasoning is the socalled "and-branching", which introduces new individuals in the tableau expansion through the ∃-rule, and affects the searching space of the reasoning algorithm as discussed in [10].
Thus, when evaluating sizes of computed 's, we measure both the level of nested quantifiers (i.e. quantification depth) and the number of conjuncts of each . For example, the concept has quantification depth 2 and number of conjuncts 2 (i.e. and ).
6.1.1. Experiment Setup-To evaluate and show efficacy of the proposed strategy and optimization, we have implemented the following three versions of the rolling-up method for comparison:

V1
The original rolling-up procedure adapted to ABox assertions without applying the call-by-need strategy, which computes the most specific concept w.r.t. for a given individual;

V2
The rolling-up procedure with the proposed call-by-need strategy based on SYN_COND , which features the branch pruning as fully discussed in Section 4.2; V3 The rolling-up procedure with the call-by-need strategy based on SYN_COND* discussed in Section 4.3.
We compute the for each individual in every ontology using the three methods respectively, and report in Table 2 and Table 3 the maximum and the average of quantification depth and number of conjuncts of the concepts, respectively. We also demonstrate the running-time efficiency of the optimized rolling-up procedure by showing the average time spent on computation of a for each individual in Figure 3. Table 2 and Table 3, the sizes of 's generated by V2 and V3 are significantly smaller than those generated by V1 (the original method), which are almost in the same scale of size of the corresponding ontology ABox. The large size of 's from V1 is caused by the fact that most individuals (greater than 99%) in each of these ontologies are connected together by role paths in the graph. The bulk of each makes the original MSC method completely inefficient and unscalable for answering object queries, as a subsumption test based on these concepts would be prohibitively expensive as a complete ABox reasoning. Thus, the comparison here reflects the potential and the importance of our proposed optimizations in this paper, which revive the MSC (i.e. method as an efficient way for instance checking and object query answering.

Result Analysis-As we can see from
The comparison between V2 and V3 demonstrates the efficacy of the optimization technique discussed in Section 4.3, which could prevent the rolling-up in arbitrary directions by providing a more rigorous precondition based on SYN_COND . This optimization could be useful in many practical ontologies, especially when their ABoxes contain "hot-spots" individuals that connect (tens of) thousands of individuals together and could cause the rolling-up to generate concepts with a prohibitive quantification depth.
In particular, in our previous study of modularization for ontology ABoxes [16], the biomedical ontologies (i.e. AT and CE ) are found to be complex with many of their ontology roles (33 out of 55) used for concept definitions, and their ABoxes are hard to be modularized even with various optimization techniques applied [16]. However, in this paper, we found much simpler 's can also be achieved in these complex ontologies when the optimization (i.e. SYN_COND*) is applied. For example, the maximum quantification depths of computed 's in both AT and CE are decreased significantly from more than 1000 to less than 10. Nevertheless, it should also be noted that, effectiveness of this optimization may vary on different ontologies, depending on their different levels of complexity and different amount of explicit information in their ABoxes that can be explored for optimization.

Reasoning with
In this section, we will show the efficiency that can be achieved when using the computed for instance checking and retrieving. We conduct the experiments on the collected ontologies, and measure the average reasoning time that is required when performing instance checking (for every ABox individual) and instance retrieval using the method, respectively.

Experiment Setup-We
will not compare our method with a particular optimization technique for ABox reasoning, such as lazy unfolding, absorption, or model merging, etc., since they have already been built into existing reasoners and it is usually hard to control reasoners to switch on or off a particular optimization technique. Additionally, the method still relies on the reasoning services provided by the state-of-art reasoners. Nevertheless, we do compare the reasoning efficiency between the method and a regular complete ABox reasoning using existing reasoners, but only to show the effectiveness of the proposed method for efficient instance checking and data retrieving. Moreover, we also compare the method with the ABox partitioning method (modular reasoning) developed in [16], as they are developed based on the similar principles and both allow parallel or distributed reasoning.

The
's here are computed using algorithm V3, and the ABox partitioning technique used is the most optimized one presented in [16]. For a regular complete ABox reasoning, the reasoners used are OWL DL reasoners, HermiT [5] and Pellet [6], each of which has its particular optimization techniques implemented for the reasoning algorithm. Both the method and the modular reasoning are based on reasoner HermiT, and they are not parallelized but instead running in an arbitrary sequential order of 's or ABox partitions.
Queries: LUBM comes with 14 standard queries. For biomedical and DBpedia* ontologies respectively, queries listed in Figure 4 are used.
For each test ontology, we run the reasoning for each of the given queries. We report the average reasoning time spent on instance checking ( Figure 5) and instance retrieval ( Figure  6), respectively. The reasoning time reported here does not include the time spent for resource initialization (i.e. ontology loading and reasoner initialization), since the initialization stage can be done offline for query answering. However, it is obvious that the method should be more efficient, since it only requires to load an ontology TBox while a regular ABox reasoning requires to load an entire ontology (including large ABoxes). For reasoning with 's and ABox partitions, any updates during the query answering procedure (e.g. update the reasoner for different ABox partitions or different 's) is counted into the reasoning time.
Another point worth noting here is that, for answering object queries using either modular reasoning or the method, the overhead (time for ABox modularization or computation of 's) should be taken into account. However, as shown in previous section and in [16], this overhead is negligible comparing with the efficiency gained on the reasoning, not to mention when these two methods get parallelized using existing frameworks such as MapReduce [45].

Result
Analysis-As can be seen from the above two figures, using the method, reasoning efficiency for both instance checking and instance retrieval in the testing ontologies has been improved significantly: 1) by more than three orders of magnitude when comparing with a complete reasoning; 2) and by about two orders of magnitude (except in LUBM1 and LUBM2) when comparing with the modular reasoning. For the latter, the improvement in LUBM1 and LUBM2 are not as significant as in others, which is because of the simplicity of these two ontologies that allows fine granularity of ABox partitions to be achieved [45].
On the other hand, using the method in complex ontologies, such as AT and CE, the great improvement in reasoning efficiency comes from the reduction of searching space for reasoning algorithms, by branch pruning and also concept absorption during the computation of 's. For example, consider an individual x having the following n role assertions: where y i ∈ D and n tends to be large in these practical ontologies. Rolling up these assertions may generate a set of ∃R.D 's, the conjunction of which is still ∃R.D . Thus, when using this concept for instance checking, the interpretation may generate only one Rneighbor of individual x instead of n .

Scalability Evaluation
Using the method for query answering over large ontologies is intended for distributed (parallel) computing. However, even if it is executed sequentially in a single machine, linear scalability may still be achieved on large ontologies that are not extremely complex; and there are mainly two reasons for that: first, the computation of 's focuses on only the query-relevant assertions instead of the entire ABox; second, the obtained 's could be very simple, sizes of which could be significantly smaller than that of the ABoxes. We test the scalability of this method for query answering (sequentially executed) using the benchmark ontology LUBM, which models organization of universities with each university constituted about 17,000 related individuals. The result is show in Figure 7.

Conclusions and Outlook
In this paper, we proposed a revised MSC method for efficient instance checking. This method allows the ontology reasoning to explore only a much smaller subset of ABox data that is relevant to a given instance checking problem, thus being able to achieve great efficiency and to solve the limitation of current memory-based reasoning techniques. It can be particularly useful for answering object queries over those large non-Horn DL ontologies, where existing optimization techniques may fall short and answering object queries may demand thousands or even millions of instance checking tasks. Most importantly, due to the independence between 's, scalability for query answering over huge ontologies (e.g. in the setting of semantic webs) could also be achieved by parallelizing the computations.
Our technique currently works for logic , which is semi-expressive and is sufficient for many of the practical ontologies. However, the use of more expressive logic in modeling application domains requires more advanced technique for efficient data retrieving from ontology ABoxes. For the future work, we will investigate on how to extend the current technique to support or that are featured with (qualified) number restrictions. We will concentrate on extending the rolling-up procedure to generate number restrictions, such as ≥ nR.T or ≥ nR.C , whenever there is a need. We will also have to take a particular care of the identical individual problem, where concepts and role assertions of an individual can be derived via individual equivalence. A procedure for instance retrieval for a given query based on our revised MSC method. Xu Table 3 Number of conjuncts of 's from different rolling-up procedures.