Re: presenting data models in RIF

Michael Kifer wrote:
> Following up on the issue of whether RIF needs its own subclassOf thingie,
> I would argue that in order to support exchange of data models (strongly
> argued for by Gary and, as I understood at the last f2f, favored by
> Christian)

and objected to by me as being out of scope of RIF

> we also need a minimalistic way to specify domains and ranges.
> Similar to RDF but, again, without RDFS's ad hoc assumptions (about
> the globality of definitions, etc.).

They are not ad hoc (and continually sniping in this way is not 
particularly helpful).

> As in the case of the rif:subclassOf relationship, RDFS and other systems
> will be able to map their models into RIF and thus present (much of)
> them for exchange.
> 
> What I have in mind is, again, minimalistic and shared by all languages
> I know of. We need constructs like
> 
> abc[foo => xyz] or (abc[foo rif:hasType xyz], if you wish)
> 
> which say that class abc has a property foo. For any object in abc, the
> value of this property must be a member of class xyz.
> The semantics will support only the following axioms:
> 
> Inheritance:
>     ?Cl[?Prop => ?Type] <- ?Cl rif:subclassOf ?SC and ?SC[?Prop =>?Type].
> 
> Relaxation:
>     ?Cl[?Prop => ?Type] <-
>                         ?SubType rif:subclassOf ?Type and ?Cl[?Prop =>?SubType].

No implied constraint checking?

> One of the problems in RDFS is that a statement like ``foo rdfs:range bar''
> says that 'bar' is always the range of 'foo'. One cannot say that in one
> class the range of foo is bar, but in some other class it is something else
> (perhaps completely unrelated to bar). Ditto with rdfs:domain.

Of course you can express such "local" range axioms in OWL.

> Such global scoping is a no-no for OO languages. 

Given OWL then the global/local question is a non-issue.

I would have thought the more substantive difference is that in OO 
languages these are purely schema constraints and don't sanction 
inferences as they do in the ontology languages. Furthermore OO 
languages make a disjointness assumption between non-inheriting classes 
which makes such range declarations useful as constraints in a way that 
they often aren't in ontologies.

> In particular, for PR
> languages whose data model is based on Java. But with the above model, one
> could state, say,
> 
> Person[name=>PersonName].
> Dog[name=>String].
> PersonName[first=>String, last=>String].
> 
> without problems. Here the range of name on objects in class Person is one
> thing and on objects in class Dog some other thing.
> 
> 
> RDFS and other systems can be directly mapped into the above model. To
> capture RDFS semantics, one would add additional axioms. For instance, if
> we add the class of everything, Object, then the globality of rdfs:range
> and rdfs:domain are captured by these axioms:
> 
> Object[?P => ?T] <- ?P rdfs:range ?T.

But any system which implements your => by mapping this to OO style 
constraints would be unable to implement such a rule.

Furthermore your inheritance/relaxation semantics are not directly 
sanctioned on rdfs:domain/range (though this would only be an issue if 
the rdfs:range mapping were two way).

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

Received on Thursday, 16 August 2007 17:33:37 UTC