Efficiently extracting a module from a given ontology that captures all the ontology's knowledge about a set of specified terms is well-understood task. It can be solved, for instance, by locality-based modules. In contrast, extracting all modules of an ontology is computationally difficult because there can be exponentially many. However, it is reasonable to assume that, by revealing the modular structure of an ontology, we can obtain information about its topicality, connectedness, structure, superfluous parts, or agreement between actual and intended modeling. Furthermore, incremental reasoning makes use of a number of, although not all possible, modules of an ontology. Chances are that real-life ontologies have significantly fewer modules than the worst cases. We report on experiments to obtain or estimate this number and to evaluate the modular structure of an ontology where we succeeded to compute it. In that evaluation, we look at the number and sizes of the modules, as well as the relation between module sizes and number and sizes of signatures that lead to the module.

Even in small ontologies that only contain Figure 1: A justification for Person tens of axioms, there can be multiple reasons for an entailment, none of which may be obvious. It is for this a number of justifications that all participants ranked "difficult" reason that there has recently been a lot of focus on generating to "impossible" to understand. This includes people explanations for entailments in ontologies. In the who have over two years experience of working with OWL, OWL world, justifications are a popular form of explanation building ontologies and even includes people who have developed for entailments. A justification is a minimal subset OWL reasoners. This is indicative that justification of an ontology that is sufficient for an entailment to hold understanding can be a real problem.

Reasoning with dates and duration has long been addressed by the community. Existing duration ontologies, however, lack complete axiomatizations of their intended models; many simply represent timedurations as real numbers and treat the duration function as a metric on the timeline. We show that such approaches are inadequate and provide a first-order ontology of duration that overcomes these limitations.

We propose a new family of probabilistic description logics (DLs) that, in contrast to most existing approaches, are derived in a principled way from Halpern's probabilistic first-order logic. The resulting probabilistic DLs have a two-dimensional semantics similar to certain popular combinations of DLs with temporal logic and are well-suited for capturing subjective probabilities. Our main contribution is a detailed study of the complexity of reasoning in the new family of probabilistic DLs, showing that it ranges from PTime for weak variants based on the lightweight DL EL to undecidable for some expressive variants based on the DL ALC.

The DL-Lite family of Description Logics has been designed with the specific goal of allowing for answering complex queries (in particular, conjunctive queries) over ontologies with very large instance sets (ABoxes). So far, in DL-Lite systems, this goal has been actually achieved only for relatively simple (short) conjunctive queries. In this paper we present Presto, a new query answering technique for DL-Lite ontologies, and an experimental comparison of Presto with the main previous approaches to query answering in DL-Lite. In practice, our experiments show that, in real ontologies, current techniques are only able to answer conjunctive queries of less than 7-10 atoms (depending on the complexity of the TBox), while Presto is actually able to handle conjunctive queries of up to 30 atoms. Furthermore, in the cases that are already successfully handled by previous approaches, Presto is significantly more efficient.

Databases and related information systems can benefit from the use of ontologies to enrich the data with general background knowledge. The DL-Lite family of ontology languages was specifically tailored towards such ontology-based data access, enabling an implementation in a relational database management system (RDBMS) based on a query rewriting approach. In this paper, we propose an alternative approach to implementing ontology-based data access in DL-Lite. The distinguishing feature of our approach is to allow rewriting of both the query and the data. We show that, in contrast to the existing approaches, no exponential blowup is produced by the rewritings. Based on experiments with a number of real-world ontologies, we demonstrate that query execution in the proposed approach is often more efficient than in existing approaches, especially for large ontologies. We also show how to seamlessly integrate the data rewriting step of our approach into an RDBMS using views (which solves the update problem) and make an interesting observation regarding the succinctness of queries in the original query rewriting approach.

Recent years have seen the advent of large and complex ontologies, most notably in the medical domain. As a consequence, structuring mechanisms for ontologies are nowadays viewed as an indispensible tool. A basic such mechanism is the automatic decomposition of the vocabulary of an ontology into independent parts. In this paper, we study decompositions that are syntax independent in the sense that the resulting partitioning depends only on the meaning of the vocabulary items, but not on the concrete syntactic form of the axioms in the ontology. We present the first systematic investigation of decompositions of this type in the context of ontologies. Specifically, we focus on ontologies formulated in description logics and provide a variety of results that range from theorems stating the existence of unique finest decompositions to complexity results and algorithms computing decompositions. We also investigate the relationship between the existence of unique finite decompositions and a variant of the Craig interpolation property called parallel interpolation.

Description Logics (DLs) are knowledge representation formalisms that provide, for example, the logical underpinning of the W3C OWL standards. Conjunctive queries (CQs), the standard query language in databases, have recently gained significant attention for querying DL knowledge bases. Several different techniques are available for a wide range of DLs. Nevertheless, for OWL 1 DL and OWL 2 DL, decidability of CQ entailment is an open problem. So far, the combination of nominals, inverse roles, and number restrictions caused unsolvable problems. We tackle this problem and present a decidability result for entailment of unions of CQs in a DL with all three problematic constructors. For queries with only simple roles, our result also shows decidability in the logic that underpins OWL 1 DL and we believe that the presented results will pave the way for further progress towards CQ entailment decision procedures for OWL.

There is currently a growing interest in techniques for hiding parts of the signature of an ontology Kh that is being reused by another ontology Kv. Towards this goal, Cuenca Grau, Motik, and Kazakov (2009) recently proposed the import-by-query framework, which makes the content of Kh accessible through a limited query interface. If Kv reuses the symbols from Kh in a certain restricted way, one can reason over Kv U Kh by accessing only Kv and the query interface. In this paper, we map out the landscape of the import-by-query problem. We show that certain restrictions of our original framework are strictly necessary to make reasoning possible, we propose extensions that overcome some of the expressivity limitations, we present several novel reasoning algorithms, and we outline the limitations of the new framework.

Ontologies can be used to provide an enriched vocabulary for the formulation of queries over instance data. We identify query emptiness and predicate emptiness as two central reasoning services in this context. Query emptiness asks whether a given query has an empty answer over all data sets formulated in a given signature. Predicate emptiness is defined analogously, but quantifies universally over all queries that contain a given predicate. In this paper, we determine the computational complexity of query emptiness and predicate emptiness in the EL, DL-Lite, and ALC-families of description logics, investigate the connection to ontology modules, and perform a practical case study to evaluate the new reasoning services.