Re: Ontologies for RDF structures, not just atoms

Hi Pierre-Antoine,

Yes, you are completely right, my bad.

Property chains have their limitations in cardinality constraints and they also can't be used to reify datatype properties but I still think that for most cases they are useful enough and provide a simple means to declare shortcuts.

Think about it: in your data you will only need to use the "reified property classes" if you want to attach additional information to a relationship and then the simple relationship gets inferred. Otherwise you state the simple relationship. Now when you query the data you can do the same: if you're interested in additional data about some relationship then you will use the "reified property class" in your query pattern - which might not match if the data only uses the simple relationship but that's no problem because in that case the data will not contain any additional information about the relationship anyway. And if you're just interested in the existance of the relationship then you can use the simple relationship in your query pattern because that will always be there, either explicitly stated or inferred.
What would be a use-case where you need to infer the reified version?

@Holger: And btw, I don't think that's bending OWL to any particular needs - this is exactly what property chains have been added to the language for. It's all just different perspectives on the same thing, whether you think of it as reification or as providing shortcuts - in the end it's just a modelling pattern.

Regards,
  Simon


Pierre-Antoine Champin wrote:
> Hi Simon,
> 
> with OWL property chains, you can express the 'ONLY IF' part of the rule
> below, but not the 'IF' part, because a single property be a subprop of
> a property chain, but not the other way around.
> 
>   pa
> 
> On 20/04/2010 20:38, Simon Reinhardt wrote:
>> Pierre-Antoine Champin wrote:
>>> The good thing with english is that you can easily swap from the
>>> 'relation' view ("dates") to the 'reified' view ("couple"). In an
>>> ontology, you have to *commit* (as in "ontological commitment") to a
>>> particular representation, which really depends on the needs of your
>>> application. You can also accept both representations, and add inference
>>> rules that would state the equivalence between them :
>>>
>>>   there is a ?couple involving ?john and ?mary
>>>   IF AND ONLY IF
>>>   ?john dates ?mary
>>>
>>> but not all ontology languages would be able to express it (I don't
>>> think OWL is).
>> 
>> In OWL 2 you can do that using property chains.
>> 
>> Suppose you have a class ex:Couple representing your reified couple concept and a relation ex:coupleMember linking an ex:Couple to a foaf:Person (with the cardinality restricted to two if you want, although that might be problematic in combination with property chains, I'm not sure). Then you can declare that for the path going from a foaf:Person to an ex:Couple (using the inverse of ex:coupleMember) and then going from that ex:Couple to another foaf:Person (this time using ex:coupleMember itself) there exists a shortcut, namely ex:dates.
>> 
>> In Turtle syntax:
>> 
>> ex:dates a owl:ObjectProperty ;
>>  owl:propertyChainAxiom ([a owl:ObjectProperty ; owl:inverseOf ex:coupleMember] ex:coupleMember) .
>> 
>> 
>> Regards,
>>   Simon
> 
> 
>

Received on Wednesday, 21 April 2010 18:50:49 UTC