Showing papers by "Matthew Horridge published in 2009"

OWL 2 Web Ontology Language

Abstract: The OWL 2 Web Ontology Language, informally OWL 2, is an ontology language for the Semantic Web with formally defined meaning. OWL 2 ontologies provide classes, properties, individuals, and data values and are stored as Semantic Web documents. OWL 2 ontologies can be used along with information written in RDF, and OWL 2 ontologies themselves are primarily exchanged as RDF documents. The OWL 2 Document Overview describes the overall state of OWL 2, and should be read before other OWL 2 documents. The Manchester syntax is a user-friendly compact syntax for OWL 2 ontologies; it is frame-based, as opposed to the axiom-based other syntaxes for OWL 2. The Manchester Syntax is used in the OWL 2 Primer, and this document provides the language used there. It is expected that tools will extend the Manchester Syntax for their own purposes, and tool builders may collaboratively extend the common language.

The OWL API: a Java API for working with OWL 2 ontologies

Abstract: This paper presents the OWL API a high level Application Programming Interface (API) for working with OWL 2 ontologies. The API is closely aligned with the OWL 2 structural specification. It supports parsing and rendering in the syntaxes defined in the W3C specification, namely, the Functional Syntax, RDF/XML, OWL/XML and the Manchester OWL Syntax. Finally, the reference implementation of the API, which is written in Java, includes validators for the various OWL 2 profiles - OWL 2 QL, OWL 2 EL and OWL 2 RL.

Explaining Inconsistencies in OWL Ontologies

Abstract: Justifications play a central role as the basis for explaining entailments in OWL ontologies. While techniques for computing justifications for entailments in consistent ontologies are theoretically and practically well-understood, little is known about the practicalities of computing justifications for inconsistent ontologies. This is despite the fact that justifications are important for repairing inconsistent ontologies, and can be used as a basis for paraconsistent reasoning. This paper presents algorithms, optimisations, and experiments in this area. Surprisingly, it turns out that justifications for inconsistent ontologies are more "difficult" to compute and are often more "numerous" than justifications for entailments in consistent ontologies: whereas it is always possible to compute some justifications, it is often not possible to compute all justifications for real world inconsistent ontologies.

A syntax for rules in OWL 2

Abstract: Being able to extend an OWL ontology with some form of rules is a feature that many ontology developers consider as very important. Nevertheless, working with rules in practice can be difficult since the tool support is not as good as for handling standard ontologies. Furthermore, the existing rule syntaxes are not very well aligned with the new OWL 2 standard. We propose, therefore, an extension to OWL 2 for representing rules, which is directly inspired by (DL Safe) SWRL rules, but uses and extends the succinct and human-readable functional-style syntax of OWL 2. We also propose an OWL/XML version of the syntax for easy XML serialization. Support for parsing such rules has been added to the new OWL API 3.0 and reasoning support is available in the two OWL 2 reasoners Pellet and HermiT. In HermiT, these rules can also be used in conjunction with description graphs.

Lemmas for Justifications in OWL

Abstract: Over the past few years there has been a significant amount of interest in the area of debugging and repairing of OWL ontologies. The process of debugging an ontology is necessary in the same way that debugging programme code is necessary – that is, debugging takes place in order to eradicate faults. In terms of ontology debugging, the faults manifest themselves as undesirable entailments. In particular, the entailment that a concept is unsatisfiable is almost always undesired. However, undesirable entailments are not restricted to unsatisfiable concepts. Other entailments, such as certain subsumptions between concepts, might be unintended and contrary to the modeler’s understanding of the domain, and thus, undesirable. Ontology debugging is the process of finding the causes of an undesirable entailment, understanding these causes, and modifying the ontology so that the undesirable entailment no longer holds. Without some kind of tool support, it can be very difficult, or even impossible, to work out why entailments arise in ontologies. Even in small ontologies, that only contain tens of axioms, there can be multiple reasons for an entailment, none of which may be obvious. It is for this reason that there has recently been a lot of focus on generating explanations for entailments in ontologies. In the OWL world, justifications are a popular form of explanation for entailments. Justifications are minimal subsets of an ontology that are sufficient for an entailment to hold. Virtually all mainstream ontology editors such as Protege-4, Swoop, and Top Braid Composer provide support for generating justifications as explanations for arbitrary entailments. Justifications have proved enormously useful for understanding and debugging ontologies. In [1], Kalyanpur presents a user study which showed that the availability of justifications had a significant positive impact on the ability of users to successfully diagnose and repair an ontology. Recently, justifications have been used for debugging very large ontologies such as SNOMED [2], where the size of the ontology prohibits efficient manual debugging. In the same way that debugging software requires an understanding of why errors in the code occur, it is necessary to understand why undesirable or unexpected entailments arise in a buggy ontology. Without this understanding, it