W3C home > Mailing lists > Public > semantic-web@w3.org > November 2006

Re: rdf:Property used as rdf:object in a triple

From: Michael Schneider <m_schnei@gmx.de>
Date: Mon, 06 Nov 2006 16:41:46 +0100
Message-ID: <454F57BA.70606@gmx.de>
To: semantic-web@w3.org
Hello, Hans!

Hans Teijgeler wrote at Sat 11/4/2006 7:25 AM:

 > rdf:Property is a subClassOf rdfs:Resource, so syntactically a property
 > could be the rdf:object of a triple.
 > My question is, whether or not there is something against doing that 
from a
 > semantics/reasoning point of view.

Two other people already stated that 'rdfs:subPropertyOf' statements 
take some rdf:Property as their object. I want to add that there is also 
regular use in OWL (not just in OWL-Full, but also in DL, even in 
Lite!), as with 'owl:inverseOf'; and whenever you create an 
owl:Restriction, you specify the restricted property by giving it to 
'owl:onProperty' as its object.

BTW, if you extend your question by asking, if there are any cases where 
properties can occur as the /subject/ of a statement, then, yes, there 
are: Take rdfs:{domain|range} assertions for example, or of course 
statements of the form 'p rdf:type rdf:Property'. :)

Hans Teijgeler wrote at Sun, 5 Nov 2006 10:47:23 +0100:

 > Let me explain this with a simple example:
 > *	
 > 	John isInvolvedWith Jane
 > *	
 > 	Jane's father Pete givesApprovalTo that relationship
 > This means that the isInvolvedWith relationship is the rdf:object of the
 > predicate 'givesApprovalTo'.

Hm, perhaps I do not correctly understand you. Do you talk about an RDF 
statement of the form

   :Pete :givesApprovalTo :isInvolvedWith ?

This would mean that Pete gives approval to the general relation, which 
can hold between two owl:ThingS. But what you probably want to say is 
that Pete gives approval to the specific involvement between John and 
Jane. And this is, formally, just a single /instance/ of the whole 
property 'isInvolvedWith': the tuple 'isInvolvedWith(John, Jane)'.

Now, while OWL has some class for collecting all /class/ instances 
(which is owl:Thing) there is nothing equivalent for /property/ 
instances (which could perhaps be called 'owl:Tuple'). But such a class 
is, IMHO, not necessary, because within RDF a relation instance is 
actually represented as a single /statement/, with the name of the 
relation as its predicate. And so, class rdf:Statement would take the 
place for collecting all possible property instances. And this means, we 
can use reification for this purpose. To be concrete, I would model the 
above story as (written in N3):

   :John :isInvolvedWith :Jane .

   :Pete :isFatherOf :Jane ;
      :givesApprovalTo [ a rdf:Statement ;
          rdf:subject :John ;
          rdf:predicate :isInvolvedWith ;
          rdf:object : Jane ] .

 > Is reification at all possible in an OWL environment? It seems not to 
be the
 > case.

Yes, it is! You can use Reification within your OWL-DL environment, but 
you have to regard some technical aspects. There was recently a 
discussion on the Jena list about that topic. If you like, you can read 
the complete thread starting at

   (Subject: "Still confused with reification (long)")

But that's a rather long thread, and thus I will provide you some 
summary. In his reply to the original post, Dave Reynolds from the Jena 
team said:

   Dave Reynolds in message

   "Because the RDF reification vocabulary has no actual semantics
   then there is no semantics to conflict with the OWL semantics
   and so no problems. See


   So you can in fact use RDF reification quite happily and it will
   not put you outside OWL/DL and so shouldn't upset any OWL
   reasoners like Pellet."

So there is actually nothing which stops you from using reification 
within OWL-DL, but you have at least to keep care on two technical points:

   * The names 'rdf:Statement' and 'rdf:{subject|predicate|object}'
     are unknown within OWL, so you have to explicitly introduce them
     within your custom OWL ontology.

   * The properties 'rdf:{subject|predicate|object}' must be able to
     get different kinds of things as their objects. For
     example 'rdf:object' can both be given an owl:Thing or some
     literal. So you cannot make 'rdf:object' a owl:ObjectProperty
     or a 'owl:DatatypeProperty'. Instead you must make it
     an 'owl:AnnotationProperty'.

To see how you can use reification within OWL, you can inspect the 
little demonstration OWL-Lite ontology, which I have attached to the end 
of message


[Please be careful if you want to read my complete post, because some 
things I wrote there were not correct, as stated by Dave Reynolds in 
later replies -- but the given demo ontology should be ok].


Received on Monday, 6 November 2006 15:47:28 UTC

This archive was generated by hypermail 2.3.1 : Wednesday, 7 January 2015 15:49:31 UTC