Re: How will the semantic web emerge

Like a lot of things related to RDF, the answer to the question of 
whether or not rdf:type is optional is generally "it depends".

It depends, for example, on whether you mean literally mean RDF by 
itself, or some other layer like RDFS or OWL (it certainly doesn't seem 
to be optional in OWL DL, for example).  In RDF, rdf:type is just 
another piece of descriptive information.  You may provide one, or you 
may not (or you may provide several;  ex:a may be both a dessert topping 
and a floor wax).

It also depends on what kinds of special semantics your application may 
associate with the class given as the value of rdf:type (and whether you 
expect other applications to conform to them).  For instance, in your 
example

  [ a foaf:Person;
    foaf:mbox <mailto:me@eg.com>;
  ].

you say "it helps to know that I am dealing with a foaf:Person not a 
foaf:Agent".  If that's what this example conveys, this would appear to 
involve some "extra-OWL" semantics;  since foaf:mbox is defined as 
having a domain of foaf:Agent (and foaf:Person is a subclass of 
foaf:Agent), this would ordinarily tell you (at least in OWL) that 
you're dealing with *both* a foaf:Person and a foaf:Agent, not one as 
opposed to the other.

(Note also that if the example had been

  [ a foaf:Agent;
    foaf:mbox <mailto:me@eg.com>;
  ].

explicitly specifying the type foaf:Agent really would be optional from 
an information perspective, since you could infer the type just from the 
foaf:mbox property.)

More generally, it depends on your general approach to describing things 
on the Web.  You can use RDF with a kind of object-oriented design 
philosophy, in which case specifying what type something is an instance 
of is really important (like, it determines what set of properties 
you're going to use to describe it, and what other types are related to 
it in various ways).  That can all be useful information (and crucial 
for specific applications), as long as you realize that RDF isn't really 
prescriptive in the sense that OO type systems are.

The other end of the spectrum is to simply describe things as thoroughly 
as possible, using whatever properties you like (possibly borrowed from 
multiple schemas or ontologies you find useful, with your own added as 
you need them.)  In many cases, that's the sort of thing you might well 
get anyway if you scoop up as much descriptive information about a given 
instance as you can find, since many different people (or agents) may 
have added their own descriptions (using their own vocabularies) to what 
was initially posted about it.  People can then categorize instances 
into their own local type systems / categorizations based on the 
descriptions of the instances, rather than the other way around (as in 
"if it's got a mailbox, it must be what *I* call an "actor", regardless 
of what foaf says it is").  That's the way a lot of description logic 
systems are supposed to work anyway.  And, of course, in this case 
there's already been a certain amount of "ontological commitment" since 
it assumes some general understanding of what a "mailbox" is, even if 
not on what the right categorization scheme is.

In practice, you'll get different applications making different 
assumptions, and mixtures of the two approaches.  One obvious mixture is 
for a single information publisher to provide type information (and 
point to a schema), and to use the schema for validation purposes just 
to make sure the data accurately reflects the publisher's intentions. 
At the same time, it might well be less important that consumers of that 
data completely buy into the publisher's type system.

I personally think we need to make sure the more flexible approaches are 
still usable in our applications (even though I recognize the value of 
extreme strictness in specific applications).  In my view, a lot of the 
potential value of XML has been lost by simply using it as an encoding 
of fixed-format data records in angle brackets.  I would not like to see 
RDF fall into this same trap.

--Frank

Henry Story wrote:
> All I see is a re-statement of an opinion on your litmus test page.  Not 
> a backing of it.
> I have not followed the XSD problem. But there is a difference with  OWL 
> ontologies in that they
> machine readable descriptions   can easily be placed at the other end  
> of the URL which identifies your class.
> 
> So
> 
> [ a foaf:Person;
>   foaf:mbox <mailto:me@eg.com>;
> ].
> 
> Is a useful statement it seems to me. If you retrieve http:// 
> xmlns.com/foaf/0.1/Person
> with the application/xml+rdf mime type then you will get a machine  
> readable description of the
> type. I don't think it is that easy with xsd (but am happy to be  
> corrected).
> 
> Anyway, it helps to know that I am dealing with a foaf:Person not a  
> foaf:Agent. In rdf every
> statement is optional of course. But that does not meant they are not  
> useful.
> 
> Henry
> 
> On 20 Dec 2005, at 18:39, Joshua Allen wrote:
> 
>> I call it my RDF "litmus test".  I think "rdf:type is optional, and at
>> best a hint".  It's the same sort of issues we had with XSD -- what is
>> the boundary where XSD is useful?  XSD for validation is fine.  XSD  as a
>> type system is going too far.
> 
> 
>

Received on Tuesday, 20 December 2005 20:53:04 UTC