Re: namespaces

> The first several sentences of Section 2.1 are:
> Before we can use a set of terms, we need a precise indication of  
> what specific vocabularies are being used. A standard initial  
> component of an ontology includes a set of XML namespace  
> declarations enclosed in an opening rdf:RDF tag. These provide a  
> means to unambiguously interpret identifiers and make the rest of  
> the ontology presentation much more readable. A typical OWL ontology  
> begins with a namespace declaration similar to the following.

The "unambiguous interpretation" is to transform a brief, ambiguous  
identifier like 'type' into an unambiguous identifier (the full URI)  
through QName expansion. Namespace declarations are how you tell the  
XML parser how to expand the QNames it encounters.

This is the whole "webby knowledge representation" part -- the use of  
unique identifiers, rather than the ambiguous terms used by human  
beings. No more arguing about whether a lemon is a fruit or a faulty  
car. No "fruit flies like a banana, time flies like an arrow".

The use of QNames is the "much more readable" part, because RDF  
becomes very verbose without abbreviations.

Linked Data does not lose any kind of identification, because the  
identification you think exists does not exist.

For example, these three fragments of OWL mean exactly the same thing:

<?xml version="1.0" ?>
<rdf:RDF xmlns:owl=""
   <owl:Class rdf:about="" />

<?xml version="1.0" encoding="utf-8"?>
<rdf:RDF xmlns:rdf="">
   <rdf:Description rdf:about="">
     <rdf:type rdf:resource=""/>

<?xml version="1.0" ?>
<ns0:RDF xmlns:ns1=""
   <ns1:Class rdf:about="" />

because they all represent the following triple:

   <> < 
 > <> .

The second alternative doesn't include a namespace declaration for  
OWL. The third alternative offers different names for the same  
namespace declarations. The meaning is the same. Consequently, the  
namespace declaration is irrelevant; mere syntactic sugar.

The N-Triples version doesn't even afford the opportunity to define  
namespaces, but it has the same meaning in RDF and OWL.

> The namespaces identify the fundamental definitions that other terms  
> depend on.
> If your linked data approach dereferences everything, you lose that  
> identification.
> If you don't like the OWL approach, that's fine with me.

You'll see from my examples above that the namespaces have nothing to  
do with identifying the fundamental definitions; the URIs of the  
resources do that job.

In other words, <> is the  
identifier for Class in OWL, regardless of how you syntactically  
encode it, or whether a namespace is defined which allows you to  
abbreviate it.

Linked Data says "don't use stupid hacks (like trying to dereference  
syntax elements such as namespace URIs) to find descriptions of  
entities: dereference the entity URIs themselves". You seem to have  
latched on to the stupid hack.

> In the RDF/OWL world, my definition of context is its identification  
> with an
> XML namespace.

You would do better by defining the context as the particular URL from  
which you fetched a graph -- which only sometimes would be a URL used  
for an XML namespace in a particular serialization of the graph.

Another approach you could take would be to assign contexts to  
representations fetched by following owl:imports links; these  
unambiguously refer to other OWL ontologies.

> By associating contexts and namespaces, I hope to show the folks on  
> the
> Semantic Web list that namespaces are not necessarily mere syntactic
> conveniences, that they can have a deeper meaning.

Any deeper meaning you draw is unfounded. Do not mistake syntactic  
convenience for formality.

I advise you to forget about RDF/XML. If it doesn't exist in N- 
Triples, you should be wary about including it in your mental model of  
RDF. RDF is just triples. OWL is built on RDF.

The one benefit of the many syntaxes for RDF is that they provide  
ample opportunities to illustrate that RDF is not defined  
syntactically. Stop assigning meaning to syntax. It might be valid in  
mKR, but it's not correct to do so in RDF.

I hope that clarifies things somewhat.


Received on Saturday, 30 August 2008 00:21:36 UTC