RDF(S), Rules, and OWL Dialects

In order to meet the expectations for a useful heap of ontologies and structured metadata, the Semantic Web requires scalable high-performance storage and reasoning infrastructure. The major challenge, when trying to build such an infrastructure, is connected to the expressivity of the underlying standards: RDF(S) and OWL. Although RDF(S) can be considered a simple knowledge representation (KR) language, it is already a challenging task to implement a semantic repository for it, which compares in performance and scalability to an entry-level relational database management system (RDBMS). Going upward the Semantic Web stack of specifications, the repository engineer faces more and more challenging obstacles. Even the simplest dialect of OWL, OWL Lite, is a description logic (DL) without algorithms allowing for efficient inference and query answering over knowledge bases (KB) scaled to millions of facts (triples).

Still other problem, associated with the layering of the dialects in OWL, arises out of the fact that OWL Lite and DL are not extensions of RDFS. A particular consequence is that not all RDFS definitions are at the same time valid OWL Lite/DL definitions. In other words, the semantics of OWL Lite and DL are incompatible with that of RDF(S), [Grosof et al, 2003]; there exists no backward compatibility between these OWL dialects and RDFS. Consider what the consequences of this would be if one tries to “upgrade” to OWL an application, which uses RDFS schema and RDFS-compliant repository. The upgrade should start with a replacement of its RDFS schemata with OWL ontologies and with at adoption of a repository that supports OWL or a fragment of it. Even the most direct translation of an RDFS schema (e.g. re-labeling of the rdfs:class-es to owl:class), without the addition of any further complexity, can lead to inconsistencies and unintended differences in the inference results. And this is caused by the simple fact that many RDFS schemata are not (directly) translatable into OWL Lite/DL ontologies.

Thus, a safe "upgrade" of an application from RDFS to OWL requires transition to OWL's most complex dialect, namely to OWL Full. But the logical complexity of OWL Full is so extreme that for most applications, sound and complete reasoning with respect to its semantics is impractical.


Nowadays, logical programming (LP) is used mainly as a common name for rule-based logical languages and systems related to PROLOG. One of the most popular LP languages is Datalog; still another is F-Logic, with its different flavors supported by Flora 2 and Ontobroker. As a rule of thumb, systems based on LP are more efficient and scalable as compared to the ones based on DL. However, a direct comparison is not possible, because these two paradigms support semantics of quite different nature - there are definitions that can be expressed in F-Logic, while this is impossible in OWL-DL, and vice versa.

Recently, OWL DLP emerged as a new dialect, offering a prospective compromise between expressive power, efficient reasoning, and compatibility. OWL DLP is defined in [Grosof et al, 2003] as the intersection of the expressivity of OWL DL and LP. In effect, OWL DLP is the most expressive sub-language of OWL DL that can be efficiently mapped to Datalog. OWL DLP is simpler than OWL Lite. As compared to the Lite and DL dialects, the semantics of OWL DLP is easier to align to the one of RDFS. And yet, the alignment can only be achieved through the enforcement of additional modeling constraints and transformations.

RDFS Semantics

The semantics of RDFS is defined by Patrick Hayes through a set of axiomatic triples and entailment rules. They determine the full set of valid inferences from an RDF graph (the RDF representation of any ontology, knowledge base, or dataset). Even though the concrete logical apparatus is not trivial, the entailment rules can be intuitively explained as follows. Each rule has a set of premises that conjunctively define its body. The premises represent “extended” RDF statements, where variables can occupy any of the three possible positions in the triple (that of a subject, of a predicate, or of an object). The head of the rule comprises of one or more consequences, each of which represents in its turn an RDF statement. The consequences may not contain free variables, i.e. such that are not used within the body of the rule. The consequences may contain blank nodes. As an example, consider the following rule (named "rdfs9" as part of the RDFS semantics):

uuu rdfs:subClassOf xxx
vvv rdf:type uuu        => vvv rdf:type xxx

The "RDFS entailment" is the only "native" reasoning task supported by the RDFS semantics. It is the process of entailment of one (target) RDF graph from another (source) RDF graph by means of the set of rules that define the semantics of RDFS. In other words, it is the process of applying the entailment rules to RDF graphs in order to infer new triples, which can be regarded as a logical consequence of the initial (source) graph. The newly inferred triples can be denoted as inferred closure of the source graph. The only way to determine whether a specific statement can be inferred from an RDF graph is to check if it is a member of its inferred closure.


Herman ter Horst defines RDFS extensions aiming at more general rule support and a fragment of OWL, which is more expressive than DLP and fully compatible with RDFS. First, he defines R-entailment, which extends the RDFS-entailment in the following ways:

  • it can operate on the basis of any set of rules R (i.e. allows for extension or replacement of the standard set, defining the semantics of RDFS);
  • it operates over the so-called generalized RDF graphs, where blank nodes can appear as predicates (a possibility disallowed in RDF);
  • rules without premises are used to declare axiomatic statements;
  • rules without consequences imply inconsistency.

OWL Horst

Horst extends and modifies the D-entailment rules from [Hayes04] in two steps as follows:

  • D* adds to RDFS support for reasoning with typed literals;
  • pD* adds rules that provide partial support for OWL.

The following primitives are supported: FunctionalProperty, InverseFunctionalProperty, SymmetricProperty, TransitiveProperty, sameAs, inverseOf, equivalentClass, equivalentProperty, onProperty, hasValue, someValuesFrom, allValuesFrom, differentFrom, disjointWith. The last two primitives are supported through inconsistency rules, which "fire" in case of the so-called P-clashes. It is important to bear in mind that some of the primitives are only partially supported; most notable, the standard OWL entailments related to someValuesFrom and allValuesFrom are supported in one direction only (i.e. there is no full support for the iff-semantics of these OWL primitives).

We call "OWL Horst" the dialect of OWL, described above, i.e. such that it is supported by means of pD*-entailment. As it was emphasized and proven in [Horst05], this language has a number of important features:

  • It is a proper (backward-compatible) and natural extension of RDFS. In contrast to OWL DLP, it imposes no constraints on the RDFS semantics. The widely discussed meta-classes (classes as instances of other classes) are not disallowed in OWL Horst. Furthermore, OWL Horst does not encompass the unique name assumption;
  • Unlike the DL-based rule languages, like SWRL, R-entailment provides a formalism for rule extensions without the DL-related constraints;
  • Its complexity is not as extreme as that of SWRL or of any of the other approaches that combine DL ontologies with rules. OWL Horst makes possible decidable rule extensions of OWL.

Naive OWL Fragments Map

The figure below represents a simplified map of the complexity of a number of OWL dialects and related languages, as well as of their disposition towards DL and LP-based semantics.

The languages that still lack a standardization are given using rectangles with dashed borders. The dot-bordered rectangle, labeled OWLIM, presents the most complex OWL dialect supported by the OWLIM semantic repository.


[Grosof et al, 2003] Grosof, B., Horrocks, I., Volz, R. and Decker, St. Description Logic Programs: Combining Logic Programs with Description Logic. In Proc. of WWW2003, May 2003.

[Hayes, 2004] Hayes, P. RDF Semantics. W3C Recommendation, 10 February 2004.

[ter Horst, 2005] ter Horst, H. J. Combining RDF and Part of OWL with Rules: Semantics, Decidability, Complexity. In Proc. of ISWC 2005, Galway, Ireland, November 6-10, 2005. LNCS 3729, pp. 668-684.