Re: URIs

A couple of comments:

1.  The "processing model" of RDF isn't "ambiguous", it is 
*unspecified*;  that is, no processing model is specified, and that is 
deliberate.   RDF doesn't define if and when a URI should be 
dereferenced from an RDF model because RDF doesn't assume URIs identify 
things that can be retrieved.

RDF Semantics (http://www.w3.org/TR/rdf-mt/) says:

"The semantics does not assume any particular relationship between the 
denotation of a URI reference and a document or Web resource which can 
be retrieved by using that URI reference in an HTTP transfer protocol, 
or any entity which is considered to be the source of such documents. 
Such a requirement could be added as a semantic extension, but the 
formal semantics described here makes no assumptions about any 
connection between the denotations of URI references and the uses of 
those URI references in other protocols."

The RDF Primer (http://www.w3.org/TR/rdf-primer/) Appendix A says:

"Both RDF and Web browsers use URIrefs to identify things. However, RDF 
and browsers interpret URIrefs in slightly different ways. This is 
because RDF uses URIrefs only to identify things, while browsers also 
use URIrefs to retrieve  things. Often there is no effective difference, 
but in some cases the difference can be significant. One obvious 
difference is that when a URIref is used in a browser, there is the 
expectation that it identifies a resource that can actually be 
retrieved: that something is actually "at" the location identified by 
the URI. However, in RDF a URIref may be used to identify something, 
such as a person, that cannot be retrieved on the Web. People sometimes 
use RDF together with a convention that, when a URIref is used to 
identify an RDF resource, a page containing descriptive information 
about that resource will be placed on the Web "at" that URI, so that the 
URIref can be used in a browser to retrieve that information. This can 
be a useful convention in some circumstances, although it creates a 
difficulty in distinguishing the identity of the original resource from 
the identity of the Web page describing it (a subject discussed further 
in Section 2.3). However, this convention is not an explicit part of the 
definition of RDF, and RDF itself does not assume that a URIref 
identifies something that can be retrieved."

Connecting the use of URIs as logical names in RDF and OWL, and their 
use as identifiers of retrievable resources in conventional Web access, 
is certainly a matter of great interest to a lot of people, but it is a 
matter for additional work (the TAG has done some, and this group can 
probably make useful contributions based on their experience).

2.  The answer to the question of whether you should be able to find 
something by dereferencing a namespace URI is related to the comments 
above.

The RDF Primer (Section 2.2) notes:

"In addition, sometimes an organization will use a vocabulary's 
namespace URIref as the URL of a Web resource that provides further 
information about that vocabulary. For example, as noted earlier, the 
QName prefix dc: will be used in Primer examples, associated with the 
namespace URIref http://purl.org/dc/elements/1.1/. In fact, this refers 
to the Dublin Core vocabulary described in Section 6.1. Accessing this 
namespace URIref in a Web browser will retrieve additional information 
about the Dublin Core vocabulary (specifically, an RDF schema). However, 
this is also just a convention. RDF does not assume that a namespace URI 
identifies a retrievable Web resource (see Appendix B for further 
discussion)."

And Appendix B says:

"A convention that is sometimes followed is to create a Web page to 
describe the markup language (and the intended meaning of the tags) and 
use the URL of that Web page as the URI for its namespace. However, this 
is just a convention, and neither XML nor RDF assumes that a namespace 
URI identifies a retrievable Web resource."

Once again, both XML and RDF are unambiguous in using 
namespace/vocabulary URIs as pure names, not necessarily as retrieval 
addresses.

This isn't to deny the usefulness of being able to dereference a URI and 
get something useful (or to be able to find the RDF or OWL describing a 
vocabulary when you're trying to process statements employing that 
vocabulary).  I'm merely pointing out that RDF and OWL were deliberately 
trying to use URIs as pure names, and leave the interaction with Web 
retrieval for additional work.  Now all we need to do is do it :-)

--Frank

Xiaoshu Wang wrote:
> Alan,
> 
>> Dereference, in that context, means something different than 
>> what I was using the term for.
>> They mean that there has to be a definition of the subject 
>> and object in the OWL file or one of the imports.
>>
>> I was using it to mean, go to the network and do a geturl of 
>> the uri and do something with the results. OWL and RDF 
>> doesn't specify that you do that. That would certainly not 
>> work, since most of the URLs prior to the semantic web don't 
>> have RDF or OWL content.
> 
> OWL/RDF is build on URI not vice versa.  If the dereference of a URI returns
> a document that is not an RDF document, it simply means that the RDF engine
> should stop dereferencing at that particular branch.
> 
> But I do agree, the processing model of the RDF is ambiguious.  There is no
> explicit statement about if and when a URI should be dereferenced from an
> RDF model.  For example, given a simple model of:
> 
> http://www.example.com/foo a http://www.example.com/bar.  
> 
> It is not clear if we should de-reference either URI.  Although OWL defines
> an owl:import, I am still not sure about two problems:
> 
> First, it is still unclear how to process the URI in basic RDF document that
> does not use OWL.
> Second, owl:import must be used in an ontology header and its range must be
> an owl:Ontology as well.
> 
> Then, my question is what is definition an Ontology?  For example, should
> the above example case be an ontology?  
> If not, then I cannot use any other ontologies in the sense of using
> owl:import.  
> If yes, what RDF/OWL statements are not ontology?
> 
> Two things needs to be clarified, IMHO.
> (1) The default processing model of RDF.
> (2) The owl:import should be changed.  Its namespace should be moved to
> rdf/rdfs.  and its domain and range should be changed to "namespace" URI
> rather than an "owl:ontology".
> 
> A related issue is whether the defined ontology/RDF statements should be
> placed under its namespace URI. I firmly think it MUST but currently it is
> not enforced by any standard. The matter is considered only as a best
> practice issue.  But if an ontology is not placed under its namespace, I am
> not sure how it can be used.  For instance, gene ontology is not placed
> under its namespace.  Dereference its namesapce
> http://www.geneontology.org/owl/# returns a 404. So, how you can use GO
> under a generic RDF engine without specific tailored code?  
> 
> I have this confusion when thought about writing a clear definition of
> ontology for the ontology task force, but cannot get a clear answer of
> myself.  I am hoping that I can find more time to do more research on that.
> But I might have overlooked something.  If everyone thinks not, maybe we
> should raise the issue to the TAG group.
> 
> Xiaoshu
>     
> 
> 
>

Received on Monday, 19 June 2006 17:07:46 UTC