In a nutshell, what is OWL Horst reasoning compared to other types of reasoning? Where does it fit on the expressivity vs performance scale? How does it compare to, say, the reasoner choices in Jena? How popular is it? How necessary is it if you have one or more other types of reasoning available to you in a reasoner?
In formal circles, OWL Horst is called pD*. You'll see it called the former by implementers and sometimes in the literature. You'll see it called the latter in the standards and other reasoning literature.
A guy called Herman ter Horst proposed a ruleset which incorporates RDFS and D entailment (it also fixes a bug in the standard) and extends that with some basic support for OWL using the following rules:
As such, it is very much an extension of DLP, which was one of the original proposals to support OWL with rules.
Funny thing is, lot's of papers and implementers claim that they support it because it's scalable, and you can't do more without becoming unscalable, or something. Fact of the matter is, it's not really a great profile to implement (it wasn't really designed to be). It still inherits all of the syntactic baggage from RDFS relating to container-membership properties (e.g., rdf:_1 ...) where you can infer an infinite number of triples (rdf:_1 a rdfs:ContainerMembershipProperty ; rdfs:subPropertyOf rdfs:member .) from an empty graph (EDIT: actually, not quite true... see Ivan's answer). Besides all that RDF(S) syntactic crap, it's cubic, and not particularly scalable. If you add this triple to any RDF graph:
rdf:type owl:sameAs owl:sameAs .
...and recursively apply the pD* rules materialising inferences, you'll end up with every triple representing every combination of known terms (since everything will be inferred to be the same as itself, and everything can be replaced with everything else).
In terms of rule-based entailment regimes, it "covers" simple entailment, RDF, RDFS, D*, and DLP for OWL. In turn, OWL 2 RL/RDF (which is newer) is broader than pD*: in particular, OWL 2 RL/RDF also offers partial support for OWL features which (i) use RDF lists: e.g., owl:unionOf (ii) can be used to detect inconsistency: e.g., owl:disjointWith; (iii) stuff new in OWL 2: e.g., owl:hasKey. More technically, OWL 2 RL/RDF rules are based on iff semantics, which is not strictly true of pD* (which is more like an extension to RDFS based on if semantics).
In terms of standard (Direct Semantics based) OWL profiles, it's a bit of a different beast, and hard to relate them... they have some overlapping expressivity, but neither fully cover the other. Borrowing Figure 1 from [a]:
(pD*sv is a silly extension of pD* you should feel free to ignore.)
With respect to how popular it is, until OWL 2 RL/RDF came along, it was probably the most extensive formal proposal to support OWL with rules. Along those lines, it's implemented fairly widely, including by OWLIM, WebPIE, and Ivan's RDFSClosure (EDIT: now superceded by OWL RL as per Ivan's answer).
[a] Herman J. ter Horst: Completeness, decidability and complexity of entailment for RDF Schema and a semantic extension involving the OWL vocabulary. J. Web Sem. 3(2-3): 79-115 (2005)
Some additions to "Signified"'s pretty large nutshell:-)
- The usual approach, also referred to by ter Horst, to handle those rdf:_i properties (which is the major source of infinity) is to consider only those that are in the Graph on which the whole process operates, ie, not to include all axiomatic triples that are infinite in number. This is also the approach being taken in the RDF and RDFS entailments document that is being defined for SPARQL 1.1. That makes the reasoning essentially finite (there are some other things with bnodes, but that is a different matter).
- In some sense, OWL 2 RL has superseded the ter Horst semantics in practice, though OWL 2 RL has been greatly influenced by Herman ter Horst's papers. The OWL 2 RL profile recommendation does not automatically include the RDFS axiomatic triples, thereby also sidestepping the infinity issue. The discussions today are more around the question whether a smaller subset of OWL, combined with RDFS, should be defined (along the same rule based axiomatic approach) or whether OWL 2 RL should be 'it' for those purposes.
- Thanks for mentioning my online tool, but the one referred to has been superseded by my more general OWL RL service that does a ter Horst "style" RDFS reasoning as well (and it has a greatly improved management of datatype). Beware: it is highly inefficient, stupid, more of a proof of concepts than of any other value, ie, it works only on relatively simple small graphs…