There are many reasoners out there and I know can implement a "Loose coupling architecture" but I would really like to know what are the benefits of one over the other before I start.

hermiT, Pellet, FaCT++ etc'

asked 28 Aug '10, 14:44

Harel's gravatar image

accept rate: 25%


Hi Harel... Might help to clear up whether this is a general question, or if you have a specific use-case in mind. It sounds like the latter, so can be you more specific about what you need? What kind of data you're looking at? What tasks you envisage?

(28 Aug '10, 15:03) Signified ♦ Signified's gravatar image

I was aiming for a general answer, thanks :)

(28 Aug '10, 21:15) Harel Harel's gravatar image

I know this question is old but I just came across it and thought that this paper might be useful for anyone making comparisons between reasoners:


Ideally I would have posted this as a comment but I don't think it's possible for me to do that anymore.

(27 Mar '14, 08:30) Vegenad Vegenad's gravatar image

@Vegenad, I don't know why you weren't able to post a comment, but I have converted it for you.

(27 Mar '14, 23:24) Jeen Broekstra ♦ Jeen%20Broekstra's gravatar image

I can't give you the benefit of each reasoner on the market but I can give you a few reasons why you could prefer a reasoner over another:

  • open source VS close source + what licence it uses;
  • free (as in "I don't paid") VS not free ("it costs me money");
  • implementation language, portability;
  • which logic it reason over (typically, which sublanguage of OWL it deals with);
  • performance: this is usually very difficult to compare because all reasoners have strength on specific cases that are different than the other, but you can have absolute requirement in terms of performance.

For instance, HermiT is a complete OWL 2 DL reasoner implemented in Java and open source under the GNU Lesser General Public License (LGPL). It also features some rule-based capability. Pellet has similar goal has HermiT, being a complete OWL 2 DL reasoner implemented in Java and can reason with SWRL rules and with a dual licence. Additionally, Pellet has some specific optimisation for OWL 2 EL ontologies. FaCT++ is implemented in C++ and is open source. RacerPro is a commercial product. Etc. In terms of performance, it is very difficult to tell which one is better and I don't really know where you can find test results.

For OWL-specific reasoners, you can find a list at http://www.w3.org/2007/OWL/wiki/Implementations with some indication about them.

If several reasoners correspond to your criteria, you may send an email to the developer and ask for technical details. They are usually happy to help when someone is willing to use their tool.

permanent link

answered 28 Aug '10, 15:22

Antoine%20Zimmermann's gravatar image

Antoine Zimm... ♦
accept rate: 34%

:) thanks Zimmermann

(28 Aug '10, 21:15) Harel Harel's gravatar image

One criterion for comparing existing Semantic Web reasoners is the language fragment they are created for.

The three reasoners that you list as examples (HermiT, Pellet, Fact++) are all generic OWL 2 DL reasoners, so they all cover the same language, namely OWL 2 DL. But there are already a couple of reasoners around that are meant to be used with ontologies conforming to the new OWL 2 profiles, such as OWL 2 EL. The profiles are sub languages of OWL 2 DL, with the same semantics but with a restricted syntax. Such profile reasoners cannot generally be expected to work on every OWL 2 DL ontology, but on their particular fragment they have a good chance to be significantly faster than generic OWL 2 DL reasoners, since they have been specifically implemented for this profile.

Another class of reasoners is given by those reasoners that are typically rule-based and are often part of RDF frameworks or triple stores, such as the Jena OWL reasoner, OWLIM, or all the OWL 2 RL/RDF rule reasoners that have been created recently. I will refer to them as "RDF rule reasoners". They generally work on arbitrary RDF graphs, without (much) restrictions, so they go beyond OWL 2 DL syntactically.

Concerning semantic expressivity, RDF rule reasoners are pretty weak compared to OWL DL reasoners, in particular when it comes to more logic-style reasoning. On the other hand, RDF rule reasoners are able to reliably work on RDF graphs outside the DL fragment, and can draw conclusions there that OWL 2 DL reasoners will generally not provide. I will give examples below.

Another difference is the typical reasoning tasks that these kinds of reasoners support. The core reasoning tasks of OWL DL reasoners are class satisfiability checking, ontology consistency checking, classification (the computation of all subsumption relationships between named classes), and a couple of concrete queries. RDF rule reasoners are often either implemented as forward-chainers, which supports efficient SPARQL querying on once materialized RDF graphs; or as backward chainers, which supports flexible query answering on RDF graphs without the need to compute the whole inference closure first.

Internally, RDF rule reasoners typically treat an ontology directly as a set of RDF triples, while OWL DL reasoners normally work on a representation that corresponds to the OWL 2 Syntax, which is considerably different from RDF. One can get an idea of this internal representation of DL reasoners when one transforms an ontology given in RDF to the OWL 2 Functional Syntax with the Manchester Syntax Converter.

Here is an example entailment of the OWL 2 RL/RDF rules (and probably of most other RDF rule reasoners) that is outside the OWL 2 DL specification, due to its use of rdf:type as a "normal" property:

ex:isTypeOf owl:inverseOf rdf:type .
ex:Country ex:isTypeOf ex:England .
ex:England rdf:type ex:Country .

Note that this does not mean that no OWL 2 DL reasoner can be applied to such input. In fact, Pellet and HermiT process this input without signaling an error. The difference is that both DL reasoners classify the example as a /non/-entailment.

And here is an example of an OWL 2 DL valid conclusion (boring declaration and header triples omitted) that you will not get from applying the OWL 2 RL/RDF rules (and probably not from any other existing RDF rule reasoner):

ex:p rdfs:range [ owl:unionOf (ex:C1 ex:C2) ] .
ex:s ex:p ex:o .
ex:o rdf:type ex:D .
ex:D owl:disjointWith ex:C1 .
ex:o rdf:type ex:C2 .
permanent link

answered 29 Aug '10, 20:52

Michael%20Schneider's gravatar image

Michael Schn... ♦
accept rate: 34%

One of the first things to consider is what level of OWL reasoning you need. Or if you need OWL reasoning at all (I note the question hints at this). OWL is not the only kind of reasoning, but is well-designed and provides for some computational guarantees. I'd suggest taking a look at the OWL 2 standard - the overview is a good starting point http://www.w3.org/TR/owl2-overview/.

There are four profiles to choose from: DL, RL, QL, and EL. Each of these are subsets of OWL Full and have their own limitations from the full spec. DL is described in http://www.w3.org/TR/2009/REC-owl2-syntax-20091027/ and the other profiles are described in http://www.w3.org/TR/owl2-profiles/. Look at these closely to match your requirements against the what the profiles emphasize. For example, RL emphasizes polynomial scaling that can be implemented in rule-based systems. This is powerful because it integrates well with existing rule processors (see below). EL is optimized for applications with ontologies that have large numbers of properties and/or classes, in DL-speak, Tbox reasoning. QL emphasizes conjunctive query-type reasoning and designed to allow rewriting queries into relational form. In DL-speak, one might be able to say this profile emphasizes Abox reasoning.

In the end, OWL will never be enough, as you are restricted to a solution space that is primarily driven by classification problems in FOL form. In pragmatic systems this means that some other kind of processing is necessary for a complete solution. Therefore it is necessary up front to understand how the reasoner of choice will integrate with a rule processing engine. The alternative, of course, is to run the OWL reasoner alone and implement all other computations in Java, etc.

In addition to the traditional OWL reasoners, I'd suggest looking int TopQuadrant's SPARQL rules (aka SPIN) and its OWL 2 RL profile implementation. This provides all of the reasoning capabilities of OWL 2 RL, plus the flexibility of customizing the rules. For more on that see Dean Allemang's "Extending OWL RL" - http://dallemang.typepad.com/my_weblog/2010/08/extending-owl-rl-.html. A discussion here of OWL 2 RL in this forum is also germane - http://www.semanticoverflow.com/questions/1570/what-criteria-was-used-for-selecting-omitting-owl-2-rl-rdf-rules. With this kind of solution the rules and OWL reasoning are stated in the same language (SPARQL) and executed with the same engine.

permanent link

answered 28 Aug '10, 16:57

scotthenninger's gravatar image

scotthenninger ♦
accept rate: 17%

edited 28 Aug '10, 17:07

Your answer
toggle preview

Follow this question

By Email:

Once you sign in you will be able to subscribe for any updates here



Answers and Comments

Markdown Basics

  • *italic* or _italic_
  • **bold** or __bold__
  • link:[text](http://url.com/ "title")
  • image?![alt text](/path/img.jpg "title")
  • numbered list: 1. Foo 2. Bar
  • to add a line break simply add two spaces to where you would like the new line to be.
  • basic HTML tags are also supported

Question tags:


question asked: 28 Aug '10, 14:44

question was seen: 6,086 times

last updated: 27 Mar '14, 23:24