Pellet: An OWL DL Reasoner

Bijan Parsia and Evren SirinMINDSWAP Research Group

University of Maryland, College Park, MDbparsia@isr.umd.edu, evren@cs.umd.edu

AbstractReasoning capability is of crucial importanceto many applications developed for the Seman-tic Web. Description Logics provide sound andcomplete reasoning algorithms that can effec-tively handle the DL fragment of the Web On-tology Language (OWL). However, existing DLreasoners were implemented long before OWLcame into existence and lack some features thatare essential for Semantic Web applications, suchas reasoning with individuals, querying capabil-ities, nominal support, elimination of the uniquename assumption and so forth. With these ob-jectives in mind we have implemented an OWLDL reasoner and deployed it in various kinds ofapplications.

1 IntroductionMany applications developed for the Semantic Web re-quire some kind of reasoning capability. Providing soundand complete reasoning services is essential for many ofthese applications to function properly. There are knowneffective reasoning algorithms for Description Logics thatcan effectively handle the Lite (as the DL SHIF(D)) and(nearly all of) the DL dialects of OWL (as the DL SH-ION(D)). Existing DL reasoners, most notably FaCT andRacer, are quite efficient but do not meet some importantrequirements. In general, a Semantic Web reasoner shouldhandle individuals (provide ABox reasoning), should notmake the Unique Name Assumption, should support entail-ment checks, should answer conjunctive ABox queries andshould work with XML Schema datatypes. At this stage ofSemantic Web adoption, having an open-source reasonerthat tries to meet these requirements is critical. Pellet hasbeen developed to address these issues and has becomeboth our test bed for experiments with DL and SemanticWeb reasoning as well as our standard reasoning compo-nent. While not (yet) in the performance range of Racer orFaCT, it has many features that makes it a good choice forvarious lighter weight situations.

2 Pellet’s FeaturesPellet has a number of features either driven by OWL re-quirements or Semantic Web issues.

Ontology analysis and repair OWL has two major di-alects, OWL DL and OWL Full, with OWL DL being a

subset of OWL Full. All OWL knowledge bases are en-coded as RDF/XML graphs. OWL DL imposes a numberof restrictions on RDF graphs, some of which are substan-tial (e.g., that the set of class names and individual namesbe disjoint) and some less so (that every item have a “type”triple). Ensuring that an RDF/XML document meets allthe restrictions is a relatively difficult task for authors,andmany existing OWL documents are nominally OWL Full,even though their authors intended for them to be OWL DL.Pellet incorporates a number of heuristics to detect “DLiz-able” OWL Full documents and “repair” them.

Datatype reasoning XML Schema has a rich set of“simple” datatypes including various numeric types (inte-gers and floats), strings, and date/time types. It also hasseveral mechanisms, both standard and unusual, for creat-ing new types out of the base types. For example, it’s possi-ble to define a datatype by restricting the integers to the setof integers whose canonical representation has only 10 dig-its, or whose string representation matches a certain regularexpression. Currently, XML Schema systems tend towardvalidation of documents. Pellet can test the satisfiabilityofconjunctions of thus constructed datatypes.

Entailment In Semantic Web, entailment is the key in-ference whereas the Description Logic community have fo-cused on satisfiability and subsumption. While entailmentcan be reduced to satisfiability, most DL systems do notsupport it directly. In part to pass a large portion of theOWL test suite, we implemented entailment support in Pel-let.

Conjunctive ABox query Query answering is yet an-other important feature for Semantic Web. We have im-plemented an ABox query answering module in Pellet us-ing the so-called “rolling-up” technique[Horrocks and Tes-saris, 2002]. We have devised algorithms to optimize thequery answering by changing how likely candidates forvariables are found and verified. Exploiting the dependen-cies between different variable bindings helps us to reducethe total number of satisfiability tests, thus speeding up thequery significantly.

3 Pellet SystemPellet is based on tableaux algorithms developed for ex-pressive Description Logics[Horrockset al., 2000]. It sup-ports all the OWL DL constructs including owl:oneOf andowl:hasValue. Currently, there is no known sound, com-plete, decidable and effective algorithm for all of OWL DL(in particular, there is none for handling nominals with in-

verse properties and cardinality restrictions). Pellet uses acombination of existing sound and complete algorithms toprovide reasoning that is sound and complete for OWL DLwithout nominals (i.e., SHIN(D)) and OWL DL without in-verse properties (i.e., SHON(D)). We use these algorithmsin combination to achieve sound but incomplete reasoningwith regard to all of DL. This has proved practically usefulin our current work.

Figure 1 shows the main components of Pellet reasoner.An OWL ontology is parsed into RDF triples (RDF/XML,N3 and N-Triple syntaxes are supported). Pellet validatesthe species of the ontology while the triples are converted toassertions and axioms in the knowledge base. If the ontol-ogy level is OWL Full because of missing type triples thenPellet uses some heuristics to repair the ontology. For ex-ample an untyped resource that has been used in the pred-icate position of a triple will be inferred to be a datatypeproperty if the triple has a literal in the object position.As usual, Pellet stores the axioms about classes in theTBox component and stores the assertions about individ-uals in the ABox component. TBox partitioning, absorp-tion and lazy unfolding optimizations are implemented.The tableau reasoner uses the standard tableau rules (asdescribed above) and includes various standard optimiza-tions such as dependency directed backjumping, seman-tic branching and early blocking strategies. Datatype rea-soning for the built-in and derived primitive XML Schemadatatypes are supported.

Pellet is implemented in pure Java and available underthe MIT licence. The source files along with some mini-mal documentation can be downloaded from the Pellet Webpage (http://www.mindswap.org/2003/pellet/).

Figure 1: Architecture of Pellet reasoner

4 ApplicationsThe capabilities of Pellet are exposed from a Java API, acommand line interface, and a Web form. The Web formhas been used by a number of people for species valida-tion, consistency checking, and experimenting with OWLDL classification and entailment. Pellet provides program-matic access to the reasoning functions through two differ-ent interfaces, one for the Jena toolkit and one for the OWLAPI library.

Pellet is the default reasoner in Swoop, a lightweight on-tology browser and editor. Pellet is used for classification,class satisfiability testing, query, and species validation andrepair. Pellet is also used to find the inconsistent conceptdescriptions in browsed ontologies. This feature helps tolocate the errors in the ontology. Generating explanationsfor inconsistencies would notably improve the usefulnessof the reasoner in Swoop, and is being worked on as a fu-ture enhancement.

We also use Pellet for web service discovery and com-position. Pellet has been incorporated as the knowledgebase for a version of the SHOP2[Nau et al., 2003] plan-ning system to evaluate the preconditions of Web Servicesand simulate the effects of executing these services. Pel-let is also being used as a service matchmaker as a partof Fujitsu Lab of America’s Task Computing Environment(TCE) [Masuokaet al., 2003]. The OWL-S service de-scriptions are loaded to Pellet and subsumption relation be-tween the inputs and outputs of Web Services are computedto find likely matches.

5 Future WorkWe have begun experimenting with various multi-ontology/logic formalisms, such as distributed descriptionlogics and E-Connections, implementation techniques. Ini-tial results have been both instructive and promising. Wealso aim to integrate the reasoner with rules to support Se-mantic Web Rule Language (SWRL). Other future workprojects include generating explanations for concept satis-fiability, querying usingK operator and experimenting withnon-monotonic reasoning using annotated logics.

6 AcknowledgementsThe authors would like to thank Ron Alford, MichealGrove and Daniel Hewitt who helped in the implementa-tion of some modules in Pellet.

References[Horrocks and Tessaris, 2002] Ian Horrocks and Sergio

Tessaris. Querying the semantic web: a formal ap-proach.ISWC 2002, pages 177–191. 2002.

[Horrockset al., 2000] I. Horrocks, U. Sattler, and S. To-bies. Practical reasoning for very expressive descriptionlogics. Logic Journal of the IGPL, 8(3):239–263, 2000.

[Masuokaet al., 2003] Ryusuke Masuoka, Bijan Parsia,and Yannis Labrou. Task computing - the semantic webmeets pervasive computing.ISWC2003, Florida, 2003.

[Nauet al., 2003] Dana Nau, Tsz-Chiu Au, Okhtay Il-ghami, Ugur Kuter, William Murdock, Dan Wu, andFusun Yaman. SHOP2: An HTN planning system.Jour-nal of Artificial Intelligence Research, December 2003.