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?

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.

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:

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):

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.