# Introducing Nominals to the Combined Query Answering Approaches for EL

So-called combined approaches answer a conjunctive query over a description logic ontology in three steps: first, they materialise certain consequences of the ontology and the data; second, they evaluate the query over the data; and third, they filter the result of the second phase to eliminate unsound answers. Such approaches were developed for various members of the DL-Lite and the EL families of languages, but none of them can handle ontologies containing nominals. In our work, we bridge this gap and present a combined query answering approach for ELHO---a logic that contains all features of the OWL 2 EL standard apart from transitive roles and complex role inclusions. This extension is nontrivial because nominals require equality reasoning, which introduces complexity into the first and the third step. Our empirical evaluation suggests that our technique is suitable for practical application, and so it provides a practical basis for conjunctive query answering in a large fragment of OWL 2 EL.

## Authors

• 6 publications
• 18 publications
• 35 publications
06/20/2022

08/06/2018

### Query Answering for Rough EL Ontologies (Extended Technical Report)

Querying large datasets with incomplete and vague data is still a challe...
10/31/2011

### Conjunctive Query Answering for the Description Logic SHIQ

Conjunctive queries play an important role as an expressive query langua...
02/04/2014

In order to meet usability requirements, most logic-based applications p...
11/14/2017

### Goal-Driven Query Answering for Existential Rules with Equality

Inspired by the magic sets for Datalog, we present a novel goal-driven a...
07/01/2021

### Computing CQ lower-bounds over OWL 2 through approximation to RSA

Conjunctive query (CQ) answering over knowledge bases is an important re...
11/29/2013

### Top-k Query Answering in Datalog+/- Ontologies under Subjective Reports (Technical Report)

##### This week in AI

Get the week's most popular data science and artificial intelligence research sent straight to your inbox every Saturday.

## 1 Introduction

Description logics (DLs) [Baader et al.2007] are a family of knowledge representation formalisms that underpin OWL 2 [Cuenca Grau et al.2008]—an ontology language used in advanced information systems with many practical applications. Answering conjunctive queries (CQs) over ontology-enriched data sets is a core reasoning service in such systems, so the computational aspects of this problem have received a lot of interest lately. For expressive DLs, the problem is at least doubly exponential in query size [Glimm et al.2008]. The problem, however, becomes easier for the [Baader, Brandt, and Lutz2005] and the DL-Lite [Calvanese et al.2007] families of DLs, which provide the foundation for the OWL 2 EL and the OWL 2 QL profiles of OWL 2. An important goal of this research was to devise not only worst-case optimal, but also practical

algorithms. The known approaches can be broadly classified as follows.

The first group consists of automata-based approaches for DLs such as OWL 2 EL [Krötzsch, Rudolph, and Hitzler2007] and Horn- and Horn- [Ortiz, Rudolph, and Simkus2011]. While worst-case optimal, these approaches are typically not suitable for practice since their best-case and worst-case performance often coincide.

The second group consists of rewriting-based approaches. Roughly speaking, these approaches rewrite the ontology and/or the query into another formalism, typically a union of conjunctive queries or a datalog program; the relevant answers can then be obtained by evaluating the rewriting over the data. Rewriting-based approaches were developed for members of the DL-Lite family [Calvanese et al.2007, Artale et al.2009], and the DLs [Pérez-Urbina, Motik, and Horrocks2010] and Horn- [Eiter et al.2012], to name just a few. A common problem, however, is that rewritings can be exponential in the ontology and/or query size. Although this is often not a problem in practice, such approaches are not worst-case optimal. An exception is the algorithm by DBLP:conf/dlog/Rosati07 that rewrites an ontology into a datalog program of polynomial size; however, the algorithm also uses a nondeterministic step to transform the CQ into a tree-shaped one, and it is not clear how to implement this step in a goal-directed manner.

The third group consists of combined approaches, which use a three-step process: first, they augment the data with certain consequences of the ontology; second, they evaluate the CQ over the augmented data; and third, they filter the result of the second phase to eliminate unsound answers. The third step is necessary because, to ensure termination, the first step is unsound and may introduce facts that do not follow from the ontology; however, this is done in a way that makes the third step feasible. Such approaches have been developed for logics in the DL-Lite [Kontchakov et al.2011] and the [Lutz, Toman, and Wolter2009] families, and they are appealing because they are worst-case optimal and practical: only the second step is intractable (in query size), but it can be solved using well-known database techniques.

None of the combined approaches proposed thus far, however, handles nominals—concepts containing precisely one individual. Nominals are included in OWL 2 EL, and they are often used to state that all instances of a class have a certain property value, such as ‘the sex of all men is male’, or ‘each German city is located in Germany’. In this paper we present a combined approach for —the DL that covers all features of OWL 2 EL apart from transitive roles and complex role inclusions. To the best of our knowledge, this is the first combined approach that handles nominals. Our extension is nontrivial because nominals require equality reasoning, which increases the complexity of the first and the third step of the algorithm. In particular, nominals may introduce recursive dependencies in the filtering conditions used in the third phase; this is in contrast to the known combined approach for [Lutz, Toman, and Wolter2009] in which filtering conditions are not recursive and can be incorporated into the input query. To solve this problem, our algorithm evaluates the original CQ and then uses a polynomial function to check the relevant conditions for each answer.

Following KRH:ELP-08, instead of directly materialising the relevant consequences of the ontology and the data, we transform the ontology into a datalog program that captures the relevant consequences. Although seemingly just a stylistic issue, a datalog-based specification may be beneficial in practice: one can either materialise all consequences of the program bottom-up in advance, or one can use a top-down technique to compute only the consequences relevant for the query at hand. The latter can be particularly useful in informations systems that have read-only access to the data, or where data changes frequently.

We have implemented a prototypical system using our algorithm, and we carried out a preliminary empirical evaluation of (i) the blowup in the number of facts introduced by the datalog program, and (ii) the number of unsound answers obtained in the second phase. Our experiments show both of these numbers to be manageable in typical cases, suggesting that our algorithm provides a practical basis for answering CQs in an expressive fragment of OWL 2 EL.

The proofs of our technical results are provided in

## 2 Preliminaries

We use the standard notions of variables, constants, function symbols, terms, atoms, formulas, and sentences [Fitting1996]. We often identify a conjunction with the set of its conjuncts. A substitution is a partial mapping of variables to terms; and are the domain and the range of , respectively; is the restriction of to a set of variables ; and, for a term or a formula, is the result of simultaneously replacing each free variable occurring in with . A Horn clause is an expression of the form , where and each are atoms. Such is a fact if , and it is commonly written as . Furthermore, is safe if each variable occurring in also occurs in some . A logic program is a finite set of safe Horn clauses; furthermore, is a datalog program if each clause in is function-free.

In this paper, we interpret a logic program in a model that can be constructed bottom-up. The Herbrand universe of is the set of all terms built from the constants and the function symbols occurring in . Given an arbitrary set of facts , let be the smallest superset of such that, for each clause and each substitution mapping the variables occurring in the clause to the Herbrand universe of , if , then . Let be the set of all facts occurring in ; for each , let ; and let . Then is the minimal Herbrand model of , and it is well known that satisfies for each Horn clause and

the vector of all variables occurring in

.

In this paper we allow a logic program to contain the equality predicate . In first-order logic, is usually interpreted as the identity over the interpretation domain; however, can also be explicitly axiomatised [Fitting1996]. Let be the set containing clauses (1)–(3), an instance of clause (4) for each -ary predicate occurring in and each , and an instance of clause (5) for each -ary function symbol occurring in and each .

 →x≈x (1) x1≈x2 →x2≈x1 (2) x1≈x2∧x2≈x3 →x1≈x3 (3) R(→x)∧xi≈x′i →R(x1,…,x′i,…,xn) (4) xi≈x′i →f(…,xi,…)≈f(…,x′i,…) (5)

The minimal Herbrand model of a logic program that contains is the minimal Herbrand model of .

Conjunctive Queries.   A conjunctive query (CQ) is a formula with a conjunction of function-free atoms over variables . Variables are the answer variables of . Let be the set of terms occurring in .

Let be a substitution such that contains only constants. Then, , where is obtained from by removing each variable for which is defined. Note that, according to this definition, non-free variables can also be replaced; for example, given and , we have .

Let be a logic program, let be the minimal Herbrand model of , and let be a CQ that uses only the predicates occurring in . A substitution is a candidate answer for in if and contains only constants; furthermore, such a is a certain answer to over , written , if a substitution exists such that , , and .

Description Logic.   DL is defined w.r.t. a signature consisting of mutually disjoint and countably infinite sets , , and of atomic concepts (i.e., unary predicates), roles (i.e., binary predicates), and individuals (i.e., constants), respectively. Furthermore, for each individual , expression denotes a nominal—that is, a concept containing precisely the individual . Also, we assume that and are unary predicates (without any predefined meaning) not occurring in . We consider only normalised knowledge bases, as it is well known [Baader, Brandt, and Lutz2005] that each knowledge base can be normalised in polynomial time without affecting the answers to CQs. An TBox is a finite set of axioms of the form shown in the left-hand side of Table 1, where , , , and . An ABox is a finite set of facts constructed using the symbols from , , and . Finally, an knowledge base (KB) is a tuple , where is an TBox and an is an ABox such that each predicate occurring in also occurs in .

We interpret as a logic program. Table 1 shows how to translate a TBox into a logic program . Moreover, let be the set of the following clauses instantiated for each atomic concept and each role occurring in .

 A(x)→⊤(x)R(x,y)→⊤(x)R(x,y)→⊤(y)

A knowledge base is translated into the logic program . Then, is unsatisfiable if . Furthermore, given a conjunctive query and a candidate answer for , we write iff is unsatisfiable or . Although somewhat nonstandard, our definitions of DLs are equivalent to the ones based on the standard denotational semantics [Baader et al.2007]. Given a candidate answer for , deciding whether holds is -complete in combined complexity, and -complete in data complexity [Krötzsch, Rudolph, and Hitzler2007].

## 3 Datalog Rewriting of TBoxes

For the rest of this section, we fix an arbitrary knowledge base . We next show how to transform into a datalog program that can be used to check the satisfiability of . In the following section, we then show how to use to answer conjunctive queries.

Due to axioms of type 6 (cf. Table 1), may contain function symbols and is generally not a datalog program; thus, the evaluation of may not terminate. To ensure termination, we eliminate function symbols from using the technique by KRH:ELP-08: for each and each occurring in , we introduce a globally fresh and unique auxiliary individual . Intuitively, represents all terms in the Herbrand universe of needed to satisfy the existential concept . KRH:ELP-08 used this technique to facilitate taxonomic reasoning, while we use it to obtain a practical CQ answering algorithm. Please note that depends on both and , whereas in the known approaches such individuals depend only on [Lutz, Toman, and Wolter2009] or [Kontchakov et al.2011].

Datalog program is obtained by translating each axiom of type other than 6 in the TBox of into a clause as shown in Table 1, and by translating each axiom in into clauses and . Furthermore, the translation of into datalog is given by .

Let be the following TBox:

 KRC\ISA\SOMEtaughtJProf\SOMEtaught⊤\ISACourseCourse\ISA\SOMEtaughtProf\setofkr\ISAKRCProf\ISA\SOMEadvisorProfKRC\ISACourseJProf\ISA\setofjohn\omit\span\omit$\rangetaughtProf$

Then, contains the following clauses:

The following result straightforwardly follows from the definition of and .

[] Program can be computed in time linear in the size of .

Next, we prove that the datalog program can be used to decide the satisfiability of . To this end, we define a function that maps each term in the Herbrand universe of to the Herbrand universe of as follows:

 δ(w)={w if w∈\indnames,oR,A if w is of the form w=fR,A(w′).

Let and be the minimal Herbrand models of and , respectively. Mapping establishes a tight relationship between and as illustrated in the following example.

Let , let be as in Example 3, and let . Figure 1 shows a graphical representation of the minimal Herbrand models and of and , respectively. The grey dotted lines show how relates the terms in to the terms in . For the sake of clarity, Figure 1 does not show the reflexivity of .

Mapping is a homomorphism from to .

[] Let and be the minimal Herbrand models of and , respectively. Mapping satisfies the following three properties for all terms and , each , and each .

1. implies .

2. implies .

3. implies .

For a similar result in the other direction, we need a couple of definitions. Let be an arbitrary Herbrand model. Then, is the set containing each term that occurs in in at least one fact with a predicate in ; note that, by this definition, we have whenever occurs in only in assertions involving the predicate. Furthermore, H is the set of all terms such that, for each term with , we have . We say that the terms in are ‘true’ auxiliary terms—that is, they are not equal to an individual in . In Figure 1, bold terms are ‘true’ auxiliary terms in and .

[] Let and be the minimal Herbrand models of and , respectively. Mapping satisfies the following five properties for all terms and in , each , and each .

1. implies that .

2. and imply that
.

3. and imply that
is of the form , that , and that a term exists such that .

4. and imply that
.

5. For each term occurring in , term exists such that .

Lemmas 1 and 1 allow us to decide the satisfiability of by answering a simple query over , as shown in Proposition 1. The complexity claim is due to the fact that each clause in contains a bounded number of variables [Dantsin et al.2001].

[] For an arbitrary knowledge base, if and only if . Furthermore, the satisfiability of can be checked in time polynomial in the size of .

In this section, we fix a satisfiable knowledge base and a conjunctive query . Furthermore, we fix and to be the minimal Herbrand models of and , respectively.

While can be used to decide the satisfiability of , the following example shows that cannot be used directly to compute the answers to .

Let be as in Example 3, and let , , and be the following conjunctive queries:

Furthermore, let be the following substitutions:

Finally, let each be the projection of to the answer variables of . Using Figure 1, one can readily check that , but , for each .

This can be explained by observing that is a homomorphic image of . Now homomorphisms preserve CQ answers (i.e.,  implies ), but they can also introduce unsound answers (i.e., does not necessarily imply ). This gives rise to the following notion of spurious answers.

A substitution with and is a spurious answer to if is not a certain answer to over .

Based on these observations, we answer over in two steps: first, we evaluate over and thus obtain an overestimation of the certain answers to over ; second, for each substitution obtained in the first step, we eliminate spurious answers using a special function . We next formally introduce this function. We first present all relevant definitions, after which we discuss the intuitions. As we shall see, each query in Example 4 illustrates a distinct source of spuriousness that our function needs to deal with.

Let be a substitution s.t.  and . Relation for , , and is the smallest reflexive, symmetric, and transitive relation closed under the rule, where is the set containing each individual from for which no individual exists such that .

Please note that the definition is actually a reformulation of the definition of , but based on the consequences of rather than the facts in .

Relation is reflexive, symmetric, and transitive, so it is an equivalence relation, which allows us to normalise each term to a representative of its equivalence class using the mapping defined below. We then construct a graph that checks whether substitution matches ‘true’ auxiliary individuals in a way that cannot be converted to a match over ‘true’ auxiliary terms in .

Let and be as specified in Definition 4. Function maps each term to an arbitrary, but fixed representative of the equivalence class of that contains . Furthermore, the directed graph is defined as follows.

• Set contains a vertex for each term such that .

• Set contains an edge for each atom of the form in such that .

Query is aux-cyclic w.r.t.  and () if contains a cycle; otherwise, is aux-acyclic w.r.t.  and ().

We are now ready to define our function that checks whether a substitution is a spurious answer.

Let and be as specified in Definition 4. Then, function returns if and only if at least one of the following conditions hold.

1. Variable exists such that .

2. Terms and occurring in exist such that and .

3. Query is aux-cyclic w.r.t.  and .

We next discuss the intuition behind our definitions. We ground our discussion in minimal Herbrand models and , but our technique does not depend on such models: all conditions are stated as entailments that can be checked using an arbitrary sound and complete technique. Since is an knowledge base, model is forest-shaped: roughly speaking, the role assertions in that involve at least one functional term are of the form or for ; thus, can be viewed as a family of directed trees whose roots are the individuals in and whose edges point from parents to children or to the individuals in . This is illustrated in Figure 1, whose lower part shows the the forest-model of the knowledge base from Example 4. Note that assertions of the form are introduced via equality reasoning.

Now let be a substitution such that , and let . If is not a spurious answer, it should be possible to convert into a substitution such that and . Using the queries from Example 4, we next identify three reasons why this may not be possible.

First, may map an answer variable of to an auxiliary individual, so by the definition cannot be a certain answer to ; condition (a) of Definition 4 identifies such cases. Query and substitution from Example 4 illustrate such a situation: and is a ‘true’ auxiliary individual, so is not a certain answer to .

The remaining two problems arise because model is not forest-shaped, so might map into in a way that cannot be converted into a substitution that maps into .

The second problem is best explained using substitution and query from Example 4. Query contains a ‘fork’ . Now is a ‘true’ auxiliary individual, and so it represents ‘true’ auxiliary terms ,   , and so on. Since is forest-shaped, a match for in obtained from would need to map to one of these terms; let us assume that . Since is forest-shaped and is a ‘true’ auxiliary term, this means that both and must be mapped to the same term (in both and ). This is captured by the rule: in our example, the rule derives , and condition (b) of Definition 4 checks whether maps and in a way that satisfies this constraint. Note that, due to role hierarchies, the rule needs to be applied to atoms and with . Moreover, such constraints must be propagated further up the query. In our example, due to , atoms in also constitute a ‘fork’, so the rule derives ; now this allows condition (b) of Definition 4 to correctly identify as spurious.

The third problem is best explained using substitution and query from Example 4. Model contains a ‘loop’ on individual , which allows to map into . In contrast, model is forest-shaped, and so the ‘true’ auxiliary terms that correspond to do not form loops. Condition (c) of Definition 4 detects such situations using the graph . The vertices of correspond to the terms of that are matched to ‘true’ auxiliary individuals (mapping simply ensures that equal terms are represented as one vertex), and edges of correspond to the role atoms in . Hence, if is cyclic, then the substitution obtained from would need to match the query over a cycle of ‘true’ auxiliary terms, which is impossible since is forest-shaped.

Unlike the known combined approaches, our approach does not extend with conditions that detect spurious answers. Due to nominals, the relevant equality constraints have a recursive nature, and they depend on both the substitution and on the previously derived constraints. Consequently, filtering in our approach is realised as postprocessing; furthermore, to ensure correctness of our filtering condition, auxiliary individuals must depend on both a role and an atomic concept. The following theorem proves the correctness of our approach.

[] Let be a satisfiable KB, let be a CQ, and let be a candidate answer for . Then, iff a substitution exists such that , , , and .

Furthermore, can be evaluated in polynomial time, so the main source of complexity in our approach is in deciding whether holds. This gives rise to the following result.

[] Deciding whether

holds can be implemented in nondeterministic polynomial time w.r.t. the size of

and , and in polynomial time w.r.t. the size of .

## 5 Evaluation

To gain insight into the practical applicability of our approach, we implemented our technique in a prototypical system. The system uses HermiT, a widely used ontology reasoner, as a datalog engine in order to materialise the consequences of and evaluate . The system has been implemented in Java, and we ran our experiments on a MacBook Pro with 4GB of RAM and an Intel Core 2 Duo 2.4 Ghz processor. We used two ontologies in our evaluation, details of which are given below. The ontologies, queries, and the prototype system are all available online at http://www.cs.ox.ac.uk/isg/tools/KARMA/.

The LSTW benchmark [Lutz et al.2012] consists of an OWL 2 QL version of the LUBM ontology [Guo, Pan, and Heflin2005], queries , and a data generator. The LSTW ontology extends the standard LUBM ontology with several axioms of type 6 (see Table 1). To obtain an ontology, we removed inverse roles and datatypes, added 11 axioms using 9 freshly introduced nominals, and added one axiom of type 4 (see Table 1). These additional axioms resemble the ones in Example 3, and they were designed to test equality reasoning. The resulting signature consists of 132 concepts, 32 roles, and 9 nominals, and the ontology contains 180 axioms. From the 11 LSTW queries, we did not consider queries , , , and because their result sets were empty: relies on existential quantification over inverse roles, and the other three are empty already w.r.t. the original LSTW ontology. Query is similar to query from Example 4, and it was designed to produce only spurious answers and thus stress the system. We generated data sets with , and universities. For each data set, we denote with L- the knowledge base consisting of our ontology and the ABox for universities (see Table 2).

SEMINTEC is an ontology about financial services developed within the SEMINTEC project at the University of Poznan. To obtain an ontology, we removed inverse roles, role functionality axioms, and universal restrictions, added nine axioms of type 6 (see Table 1), and added six axioms using 4 freshly introduced nominals. The resulting ontology signature consists of 60 concepts, 16 roles, and 4 nominals, and the ontology contains 173 axioms. Queries are tree-shaped queries used in the SEMINTEC project, and we developed queries ourselves. Query resembles query from LSTW, and queries and were designed to retrieve a large number of answers containing auxiliary individuals, thus stressing condition (a) of Definition 4. Finally, the SEMINTEC ontology comes with a data set consisting of approximately 65,000 facts concerning 18,000 individuals (see row SEM in Table 2).

The practicality of our approach, we believe, is determined mainly by the following two factors. First, the number of facts involving auxiliary individuals introduced during the materialisation phase should not be ‘too large’. Table 2 shows the materialisation results: the first column shows the number of individuals before and after materialisation and the percentage of ‘true’ auxiliary individuals, the second column shows the number of unary facts before and after materialisation and the percentage of facts involving a ‘true’ auxiliary individual, and the third column does the same for binary facts. As one can see, for each input data set, the materialisation step introduces few ‘true’ auxiliary individuals, and the number of facts at most doubles. The number of unary facts involving a ‘true’ auxiliary individual does not change with the size of the input data set, whereas the number of such binary facts increases by a constant factor. This is because, in clauses of type 6, atoms do not contain a variable, whereas atoms do.

Second, evaluating over should not produce too many spurious answers. Table 3 shows the total number of answers for each query—that is, the number of answers obtained by evaluating the query over ; furthermore, the table also shows what percentage of these answers are spurious. Queries , , , and retrieve a significant percentage of spurious answers. However, only query has proven to be challenging for our system due to the large number of retrieved answers, with an evaluation time of about 40 minutes over the largest knowledge base (L-20). Surprisingly, also performed rather poorly despite a low number of spurious answers, with an evaluation time of about 20 minutes for L-20. All other queries were evaluated in at most a few seconds, thus suggesting that queries and are problematical mainly because HermiT does not implement query optimisation algorithms typically used in relational databases.

## 6 Conclusion

We presented the first combined technique for answering conjunctive queries over DL ontologies that include nominals. A preliminary evaluation suggests the following. First, the number of materialised facts over ‘true’ anonymous individuals increases by a constant factor with the size of the data. Second, query evaluation results have shown that, while some cases may be challenging, in most cases the percentage of answers that are spurious is manageable. Hence, our technique provides a practical CQ answering algorithm for a large fragment of OWL 2 EL.

We anticipate several directions for our future work. First, we would like to investigate the use of top-down query evaluation techniques, such as magic sets [Abiteboul, Hull, and Vianu1995] or SLG resolution [Chen and Warren1993]. Second, tighter integration of the detection of spurious answers with the query evaluation algorithms should make it possible to eagerly detect spurious answers (i.e., before the query is fully evaluated). Tamingrolehie already implemented a filtering condition as a user-defined function in a database, but it is unclear to what extent such an implementation can be used to optimise query evaluation. Finally, we would like to extend our approach to all of OWL 2 EL.

## Acknowledgements

This work was supported by the Royal Society; Alcatel-Lucent; the EU FP7 project OPTIQUE; and the EPSRC projects ExODA, MASI, and QueRe.

## References

• [Abiteboul, Hull, and Vianu1995] Abiteboul, S.; Hull, R.; and Vianu, V. 1995. Foundations of Databases. Addison-Wesley.
• [Artale et al.2009] Artale, A.; Calvanese, D.; Kontchakov, R.; and Zakharyaschev, M. 2009. The DL-Lite Family and Relations.

Journal of Artificial Intelligence Research

36:1–69.
• [Baader et al.2007] Baader, F.; Calvanese, D.; McGuinness, D.; Nardi, D.; and Patel-Schneider, P. F., eds. 2007. The Description Logic Handbook: Theory, Implementation, and Applications. Cambridge University Press. ISBN 9780511717383.
• [Baader, Brandt, and Lutz2005] Baader, F.; Brandt, S.; and Lutz, C. 2005. Pushing the Envelope. In Kaelbling, L. P., and Saffiotti, A., eds., Proceedings of the 19th International Joint Conference on Artificial Intelligence (IJCAI 2005), 364–369. Edinburgh, UK: Morgan Kaufmann Publishers.
• [Calvanese et al.2007] Calvanese, D.; De Giacomo, G.; Lembo, D.; Lenzerini, M.; and Rosati, R. 2007. Tractable Reasoning and Efficient Query Answering in Description Logics: The DL-Lite Family.

Journal of Automated Reasoning

9(3):385–429.
• [Chen and Warren1993] Chen, W., and Warren, D. S. 1993. Query evaluation under the well-founded semantics. In Proceedings of the 12th ACM SIGACT-SIGMOD-SIGART symposium on Principles of database systems, PODS ’93, 168–179. New York, NY, USA: ACM.
• [Cormen et al.2009] Cormen, T. H.; Leiserson, C. E.; Rivest, R. L.; and Stein, C. 2009. Introduction to Algorithms (3. ed.). MIT Press.
• [Cuenca Grau et al.2008] Cuenca Grau, B.; Horrocks, I.; Motik, B.; Parsia, B.; Patel-Schneider, P.; and Sattler, U. 2008. OWL 2: The next step for OWL. Journal of Web Semantics 6(4):309–322.
• [Dantsin et al.2001] Dantsin, E.; Eiter, T.; Gottlob, G.; and Voronkov, A. 2001. Complexity and expressive power of logic programming. ACM Computing Surveys 33(3):374–425.
• [Eiter et al.2012] Eiter, T.; Ortiz, M.; Simkus, M.; Tran, T.-K.; and Xiao, G. 2012. Query Rewriting for Horn-SHIQ Plus Rules. In Proceedings of the 26th AAAI Conference on Artificial Intelligence, (AAAI 2012). AAAI Press.
• [Fitting1996] Fitting, M. 1996. First-order logic and automated theorem proving (2nd ed.). Secaucus, NJ, USA: Springer-Verlag New York, Inc.
• [Glimm et al.2008] Glimm, B.; Horrocks, I.; Lutz, C.; and Sattler, U. 2008. Conjunctive Query Answering for the Description Logic . Journal of Artificial Intelligence Research 31:151–198.
• [Guo, Pan, and Heflin2005] Guo, Y.; Pan, Z.; and Heflin, J. 2005. LUBM: A benchmark for OWL knowledge base systems. Journal of Web Semantics 3(2–3):158–182.
• [Kontchakov et al.2011] Kontchakov, R.; Lutz, C.; Toman, D.; Wolter, F.; and Zakharyaschev, M. 2011. The Combined Approach to Ontology-Based Data Access. In Walsh, T., ed., Proceedings of the 22nd International Joint Conference on Artificial Intelligence (IJCAI 2011). AAAI Press.
• [Krötzsch, Rudolph, and Hitzler2007] Krötzsch, M.; Rudolph, S.; and Hitzler, P. 2007. Conjunctive queries for a tractable fragment of OWL 1.1. In Aberer, K.; Choi, K.-S.; Noy, N.; Allemang, D.; Lee, K.-I.; Nixon, L.; Golbeck, J.; Mika, P.; Maynard, D.; Mizoguchi, R.; Schreiber, G.; and Cudré-Mauroux, P., eds., Proceedings of the 6th International Semantic Web Conference (ISWC’07), volume 4825 of LNCS, 310–323. Springer.
• [Krötzsch, Rudolph, and Hitzler2008] Krötzsch, M.; Rudolph, S.; and Hitzler, P. 2008. ELP: Tractable rules for OWL 2. In Sheth, A.; Staab, S.; Dean, M.; Paolucci, M.; Maynard, D.; Finin, T.; and Thirunarayan, K., eds., Proceedings of the 7th International Semantic Web Conference (ISWC’08), volume 5318 of LNCS, 649–664. Springer.
• [Lutz et al.2012] Lutz, C.; Seylan, I.; Toman, D.; and Wolter, F. 2012. The Combined Approach to OBDA: Taming Role Hierarchies using Filters. In Fokoue, A.; Liebig, T.; Goodman, E.; Weaver, J.; Urbani, J.; and Mizell, D., eds., Proceedings of the Joint Workshop on Scalable and High-Performance Semantic Web Systems (SSWS+HPCSW 2012), volume 943 of CEUR Workshop Proceedings, 16–31. CEUR-WS.org.
• [Lutz, Toman, and Wolter2009] Lutz, C.; Toman, D.; and Wolter, F. 2009. Conjunctive Query Answering in the Description Logic Using a Relational Database System. In Boutilier, C., ed., Proceedings of the 21st International Joint Conference on Artificial Intelligence, (IJCAI 2009), 2070–2075. AAAI Press.
• [Ortiz, Rudolph, and Simkus2011] Ortiz, M.; Rudolph, S.; and Simkus, M. 2011. Query Answering in the Horn Fragments of the Description Logics and . In Walsh, T., ed., Proceedings of the 22nd International Joint Conference on Artificial Intelligence (IJCAI 2011), 1039–1044. Barcelona, Spain: AAAI Press.
• [Pérez-Urbina, Motik, and Horrocks2010] Pérez-Urbina, H.; Motik, B.; and Horrocks, I. 2010. Tractable Query Answering and Rewriting under Description Logic Constraints. Journal of Applied Logic 8(2):186–209.
• [Rosati2007] Rosati, R. 2007. On Conjunctive Query Answering in . In Calvanese, D.; Franconi, E.; Haarslev, V.; Lembo, D.; Motik, B.; Turhan, A.-Y.; and Tessaris, S., eds., Proceedings of the 20th International Workshop on Description Logics (DL-2007), CEUR Workshop Proceedings. CEUR-WS.org.