Pellet: An OWL DL Reasoner |
|
| Overview Features Using Pellet Download Support FAQ Publications Acknowledgments |
OverviewPellet is an open-source OWL-DL reasoner written in Java, originally developed at the University of Maryland's Mindswap Lab, and funded by a diverse group of organizations. Pellet is based on the tableaux algorithms developed for expressive Description Logics (DL). It supports the full expressivity OWL-DL including reasoning about nominals (enumerated classes). In addition to OWL-DL, as of version 1.4, Pellet supports all the features proposed in OWL 1.1, with the exception of n-ary datatypes. Thus the expressivity of supported DL is SROIQ(D), which extends the well-known DL SHOIN(D) (the DL that corresponds to OWL-DL) with
Pellet provides many different reasoning services as described below. It also incorporates various optimization techniques described in the DL literature and contains several novel optimizations for nominals [2], conjunctive query answering [3], and incremental reasoning [5]. You can find more detailed information about the architecture of the system and its features in [1]. Future Development & SupportClark & Parsia, LLC is available to provide commercial support for Pellet including R&D, maintenance, application development, etc. Feel free to get in touch with us if you need commercial-level support for Pellet—or other Semantic Web or AI-related development efforts—or want to prioritize the direction of Pellet's future development. FeaturesStandard Reasoning ServicesPellet provides all the standard inference services that are traditionally provided by DL reasoners: Consistency checking Ensures that an ontology does not contain any contradictory facts. The OWL Semantics document provides the formal definition of ontology consistency which Pellet uses. Concept satisfiability Checks if it is possible for a class to have any instances. If a class is unsatisfiable, then defining an instance of that class will cause the whole ontology to be inconsistent. Classification Computes the subclass relations between every named class to create the complete class hierarchy. The class hierarchy can be used to answer queries such as getting all or only the direct subclasses of a class. Realization Finds the most specific classes that an individual belongs to; in other words, computes the direct types for each of the individuals. Realization can only be performed after classification since direct types are defined with respect to a class hierarchy. Using the classification hierarchy, it is also possible to get all the types for that individual. Conjunctive Query AnsweringPellet includes an ABox query engine which supports answering conjunctive ABox queries with or without non-distinguished variables. Note: answering queries that contain cycles through non-distinguished variables with respect to an OWL-DL ontology is an open problem and is not presently supported. Cycles through distinguished variables can be handled and several optimizations have been implemented in Pellet query engine as described in [3]. In the presence of non-distinguished query variables, the rolling-up technique is used to answer the queries. Queries can be formulated using SPARQL. But only queries that correspond to conjunctive ABox queries are supported. These are SPARQL queries that satisfy three conditions:
The SPARQL query forms SELECT, CONSTRUCT and ASK are supported but features such as OPTIONAL and FILTER are not supported by the query engine. Note that it is still possible to answer such queries using Jena's SPARQL query engine on a Pellet-backed inference model. Please see the Pellet FAQ for the differences between two query engines. Ontology Analysis and RepairOWL has two major dialects, OWL-DL and OWL-Full, with OWL-DL being a subset of
OWL Full. All OWL ontologies are encoded as RDF graphs. OWL-DL imposes a number of
restrictions on RDF graphs, some of which are substantial (e.g., that the set of
class names and individual names be disjoint) and some less so (that every item
have a Datatype Reasoning and User-defined Simple DatatypesXML Schema has a rich set of basic datatypes including various numeric types (integers and floats), strings, and date/time types. It also has several mechanism, both standard and unusual for creating new types out of the base types. Pellet can test the satisfiability of conjunctions of such user-defined datatypes. The user-defined datatypes can be described in an external XML schema as in this example ontology and schema. As of Pellet 1.4, the preferred way to define user-defined datatypes is using the inline syntax proposed in OWL 1.1 and embedding the datatype descriptions inside OWL ontologies as in this example ontology. Ontology DebuggingDetection of unsatisfiable concepts in an ontology is a straight-forward task. However, the diagnosis and resolution of the bug is generally not supported at all. For example, no explanation is given as to why the error occurs (e.g., by pinpointing axioms in the ontology responsible for the clash) or how dependencies between classes cause the error to propagate (i.e., by distinguishing root from derived unsatisfiable classes). Pellet provides support for both kinds of tasks by pinpointing axioms that cause an inconsistency and the relation between unsatisfiable concepts [7]. Currently, these features are provided in a separate development branch, but there is a version of Swoop that integrates the explanation-generating version of Pellet to allow users debug ontologies. Reasoning with Dynamic OntologiesOne important challenge for the reasoner is to reason with changing knowledge bases, e.g. in an ontology editor. The current state of the art in DL reasoners does not try to handle updates incrementally. Pellet presently has some support to maintain reasoner state. For example, if there are additions only to the ABox (and there are no nominals), then the previous classification tree is kept and reused. We are in the process of revamping Pellet to maintain as much state as possible through additions and deletions. Preliminary results [5] show up to three orders of magnitude improvement in consistency checking after an ABox addition or deletion. Rules SupportPellet has support for AL-log (Datalog + OWL-DL) via a coupling with a Datalog reasoner. It incorporates the traditional algorithm and a new pre-compilation technique that is incomplete but more efficient. The key idea of this implementation is to pre-process all of the DL atoms that appear in the Datalog rules and include them as facts in the Datalog subsystem. Once the preprocessing is done, queries can be answered by the Datalog component using any of the known techniques for Datalog query evaluation. More information is available here. Pellet also has an experimental implementation of a direct tableau algorithm for a DL-safe rules extension to OWL-DL. Preliminary empirical results [4] have been encouraging. We think that the DL-safe implementation is practical for small to mid-sized ontologies, especially when the full expressivity of OWL-DL is needed. Multi-Ontology Reasoning using E-ConnectionsAn E-Connection is a knowledge representation language defined as a combination of other logical
formalisms. We use E-Connections as a language for defining and instantiating combinations of
OWL-DL ontologies, i.e. as a way of combining KBs, rather than logics. This approach provide an
alternative to Using PelletPellet provides many different ways to access its reasoning capabilities:
Please see the documentation provided in the distribution package for details about these methods. DownloadSimply download the following zip file and put lib/pellet.jar in your classpath:
Source codeEach distribution package comes with the source code. If you want the latest bug fixes and features, the latest version of the source code is available from the Subversion repository located at http://owldl.com.svn/pellet. Subversion web site contains various graphical tools (RapidSVN, TortoiseSVN) for SVN. There are also command line versions of SVN for different operating systems here. You can check out the code with following command: svn co http://owldl.com/svn/pellet/trunk pellet
You can then use Apache Ant (version 1.5 or above) to build Pellet. Running 'ant' in the trunk directory should be enough. The resulting jar file are placed in dist/lib/pellet.jar. Please see the documentation provided for more details. Community & Commercial SupportPellet is open source software, available under the terms of the MIT License. Support is provided on a "best-effort" basis at the Pellet users mailing list. You can post a message to this public mailing list after you subscribe to the list. The archives of the mailing list is also available here. The distribution file comes with some documentation to get you started with Pellet. There is a set of example programs showing how to use Pellet with Jena and OWL-API libraries. The details of the API is described in the included javadocs. There is also a Frequently Asked Questions document answering some basic questions about Pellet. The ongoing development of Pellet is commercially supported by Clark & Parsia, LLC; including R&D, maintenance, application development, etc. Feel free to get in touch with us if you need Pellet support or want to prioritize the direction of Pellet's future development. Publications
AcknowledgmentsThanks to the Mindswap Lab, especially its director Dr. Jim Hendler, and all the students who've contributed to Pellet. This site is sponsored by Clark & Parsia, LLC, a Semantic Web company offering commercial support and development for Pellet. |
© Copyright 2006 Clark & Parsia, LLC. All Rights Reserved.
Tue Nov 7 00:33:15 EST 2006