Classes are introduced in RDFS (rdfs:Class), which is built on top of RDF.

So why is there a property rdf:type, if RDF does not support classes (and everything is therefore untyped on the RDF level)?

asked 10 Dec '09, 12:21

Eric's gravatar image

accept rate: 0%


There is still some explanation beyond the historic one.

The RDF Semantics spec defines four language layers. Two of these layers are RDF and RDFS, the latter being an extension of the former. The RDF layer is semantically pretty weak, because it (mostly) considers an RDF graph as a set of plain triples. For example, the triple "ex:c rdfs:subClassOf ex:d" is not treated specifically by RDF as a class subsumption axiom, but just as a plain RDF triple. Nevertheless, the RDF layer already knows about properties, because the predicates of RDF triples are properties.

The RDF layer allows for the following conclusion: if you have an RDF triple "ex:s ex:p ex:o", then ex:p is a property. To support this idea adequately, the RDF layer comes with a predefined class rdf:Property, and it uses the special property rdf:type to signal that a given property is an instance of this class: "ex:p rdf:type rdf:Property".

In RDFS, which adds to RDF the notion of custom classes and their interrelationships, the semantics of the property rdf:type is extended to cope with such custom classes. But in any case, rdf:type is already used in the RDF layer in a restricted way. So the namespace "rdf" (instead of "rdfs") for rdf:type (and for rdf:Property) makes some sense, even if it is in fact the result of the language's evolution. :-)


answered 19 Mar '10, 12:04

Michael%20Schneider's gravatar image

Michael Schn... ♦
accept rate: 34%

As Michael mentions, RDF was standardised in two major phases.

The first phase (under W3C's Semantic Web activity) gave us the Feb 1999 Model and Syntax representation (from a Model and Syntax Working Group), and an RDF Schema specification from a Schema WG that only reached Candidate Recommendation stage, before things ran out of steam: the Metadata Activity expired, RDF was widely disliked in the XML scene, and the then super-important XML Schema WG were worrying that RDF would be imposed upon them from upon high (see and nearby).

A few years later under the Semantic Web Activity, the RDF specs were remade as the 'RDF Core', in parallel with the first phase of OWL standardisation. Nothing major was changed in RDF or RDFS, but a few things were tidied up.

But this isn't about Working Group politics really. The truth is both simpler and nicer: each specification builds upon bits that are touch on in lesser detail in previous specs. So in RDF M+S it was natural to introduce the idea of classes and properties, in a very light way (it was initially couched in terms of set membership). RDFS made this more explicit, and provided as small a schema language as could be created. OWL in turn took RDFS and added in a lot of things people wanted, eg. class specific constraints, class membership rules, etc.

And so this has left us with things scattered across various namespaces. I agree it could have been made tidier, but this was the partitioning we had in the late '90s and we're sorta left with it still.


answered 26 Dec '09, 22:39

DanBri's gravatar image

accept rate: 14%

I'm not sure if you really want to know the details (doesn't help building apps ;) but a little warning in advance: one should not to mix up the RDF model (the abstract syntax) with serialisations such as RDF/XML or RDFa as well as the model with the semantics.

Due to historical reasons and compromises made in the W3C standardisation process (but hey, to be fair, that's typical in standardisation, right ;) these things have not evolved in parallel (or: at the same time) but there were essentially two major outputs: 1999/2000 and 2004 (together with OWL).

That said, if you must, the answer is essentially in the RDF Semantics document in sec 3.1 and sec 4.1 - warning: you can go blind reading this :D

Further, related resources are:

  1. Why Is RDF The Way It Is?
  2. RDF semantics publishing history
  3. RDF model publishing history (note the 1999 superseded spec)

answered 23 Dec '09, 08:32

Michael%20Hausenblas's gravatar image

Michael Haus...
accept rate: 15%

rdf:type is actually part of RDFS

As to why it's namespaced to the RDF namespace and not the Schema namespace I'm not sure - perhaps someone who's been working with it for longer can give you the reasons/history behind that in another answer.

To be honest though pretty much all real-world RDF data is built using at least some RDF Schema even if no inference or anything is done


answered 10 Dec '09, 13:45

Rob%20Vesse's gravatar image

Rob Vesse ♦
accept rate: 29%

The problem there is that in the Semantic Web Stack RDF Schema is defined as a separate layer on top of RDF Core. Like Eric, I'm wondering why this is the way it has been designed.

What I found out was that RDF has been released initially in 1999, while RDFS with all these class-related properties and types has been released in 2000. My guess is that the intent of W3C was to create a Class structure, but didn't fully anticipate yet how to manage this.

[edit: I saw that there is an alternative image of the Semantic Web Stack available at; Here RDF and RDFS are grouped together]


answered 10 Dec '09, 14:05

Michel%20van%20Tol's gravatar image

Michel van Tol
accept rate: 11%

edited 11 Dec '09, 19:03

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]( "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



Asked: 10 Dec '09, 12:21

Seen: 2,935 times

Last updated: 19 Mar '10, 12:04