Re: Issues with classification a#b, a##b

Michael Kifer wrote:
>> [On the telecon I started to raise the issue of why having separate type 
>> and subclass modelling in RIF is problematic, especially for RDF/RDFS, 
>> the discussion timed out and I took the action to clarify the issue in 
>> email.]
>>
>> The core issue is that in RDF, RDFS and OWL/full the properties that 
>> express model level relations (rdf:type, rdfs:subClassOf etc) are not 
>> distinct from those that express instance level relations. There is no 
>> metamodel/model/instance layering.
>>
>> Take a concrete example:
>>
>>     :Dave rdf:type :Person .
>>     :Dave foaf:name  "Dave" .
>>     :Person rdfs:subClassOf :Animal .
>>
>> In Jos's translation this would correspond to RIF Frames:
>>
>>     :Dave [rdf:type -> :Person, foaf:name -> "Dave"] /\
>>                           :Person[rdfs:subClassOf :Animal]
>>
>> (I've omitted all the ".."^^rif:iri and stuck to curie format for IRIs 
>> for clarity so this is not legal RIF syntax.)
>>
>> I presume from the discussion that if we accept the Classification 
>> machinery then the translation would have to be modified to generate:
>>
>>     :Dave # :Person [foaf:name -> "Dave"] /\ :Person ## :Animal
>>
>> Now consider a RIF condition which asks for all the property values of a 
>> specific object:
>>
>>     :Dave[?p -> ?v]
>>
>> With raw RDF this should match the example data with the binding sets:
>>
>>     { {p=foaf:name, v="Dave"} {p=rdf:type, v=:Person} }
>>
>> if I have enabled RDFS semantics then there should be a third binding:
>>
>>    { {p=foaf:name, v="Dave"} {p=rdf:type, v=:Person}
>>                  {p=rdf:type, v=:Animal} }
>>
>> Whereas under the proposed semantics all I would get is:
>>
>>    { {p=foaf:name, v="Dave"} }
>>
>> Of course we could define # and ## to just be aliases for the frame 
>> slots corresponding to rdf:type and rdfs:subClassOf. However, that 
>> wouldn't be very helpful for people like Gary who want to use # and ## 
>> to represent a Java or XML Schema data models.
>>
>> We could define the aliases as part of the RDF translation so that all 
>> RDF datasets expressed in RIF would explicitly also include the 
>> correspondence rules:
>>
>>    ?p[rdf:type -> ?t] :- ?p # ?t .
>>    ?p[rdfs:subClassOf -> ?t] :- ?p ## ?t .
>>
>>    ?p # ?t :- ?p[rdf:type -> ?t] .
>>    ?p ## ?t :- ?p[rdfs:subClassOf -> ?t] .
>>
>> But that strikes me as horrible.
> 
> First, I am not sure we need the second pair of axioms. But even if we do,
> I do not see any problem here. Why is it horrible? You translate one theory
> into another. The theory that you are translating into RIF may have its
> peculiarities, which may require additional axioms. Why is RDF special so
> that its translation should somehow not use axioms?

It is only special in that it is defined by W3C as one of the 
foundations of the semantic web, RIF is part of the semantic web 
activity and our charter calls for us to define something which is RDF 
compatible.

Given enough mappings anything which is sufficiently computationally 
complete could be claimed as RDF compatible - it is a judgement call how 
natural and useful a given set of mappings is.

In this case the mappings to # and ## seems to buy us little.
We risk ending up with a nest of incompatible mappings. Gary, for 
example, would likely implement #/## by mapping to Java classes and 
would then be unable to translate rules like the above and would be 
unable to work with RDF data. Not a problem for him right now but given 
Oracle's investment in RDF and OWL it might be a problem in the future. 
Yet there is no difficulty in using Oracle's rule engine to process RDF 
data if it weren't for this seemingly artificial requirement to map 
different class hierarchy concepts to the same #/## machinery.

> Finally, none of the axioms are, in fact, necessary in the translation. You
> can use your old translation. As we discussed, we need a module/scope
> mechanism. An RDF KB can be embedded using your original translation into
> some module, say module named foobar. Another module may query that RDF KB
> using something like
> 
> ?- ?o[rdf:type->?c]@foobar.
> 
> or it may decide to "import" the RDF class hierarchy by adding a rule
> 
> ?o:?c :-  ?o[rdf:type->?c]@foobar.

That's a good point.

Though it would be preferable if RDF and XML data models could be mixed 
in the same module. RDF supports embedding of XML literals and a future 
semantic web dialect of RIF may want to be able to express rules which 
can navigate the internal structure of such literals within RDF data.

Dave
-- 
Hewlett-Packard Limited
Registered Office: Cain Road, Bracknell, Berks RG12 1HN
Registered No: 690597 England

Received on Tuesday, 24 July 2007 21:44:58 UTC