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

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

   http://tech.groups.yahoo.com/group/jena-dev/message/25702
   (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
   <http://tech.groups.yahoo.com/group/jena-dev/message/25716>

   "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

   http://www.w3.org/TR/owl-semantics/mapping.html#4.2

   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

   <http://tech.groups.yahoo.com/group/jena-dev/message/25769>

[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].

Bye,
Michael