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

> 
> [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?

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.

There are many ways to use these things.


	--michael

Received on Tuesday, 24 July 2007 17:44:45 UTC