On 2002-05-30 23:38, "ext Pete Johnston" <[log in to unmask]> wrote:

> Patrick said:
>
>> I think folks are reading far too much into the term
>> 'namespace' and the relationship between namespaces used in
>> RDF/XML and the resultant URIs in the RDF graph model.
>>
>> In particular, in the RDF graph model, there are no such
>> things as namespaces, qnames, etc. Those are, of course
>> employed by the RDF/XML serialization, so that predicate URIs
>> can be expressed as element and attribute names. But the RDF
>> model uses URIs, not qnames. RDF is not XML. Namespaces and
>> qnames are not significant to, nor have representation in the
>> RDF graph.
>>
>> The value of rdfs:isDefinedBy is a URI denoting some resource
>> that defines the resource denoted by the subject of that
>> property. That's all. We don't know what the describing
>> resource is. It could be an RDF Schema instance. It could be
>> an HTML instance. It could be a PDF document. It could be a
>> portal to a relational database. We don't know. The semantics
>> of rdfs:isDefinedBy does not tell us.
>>
>> Furthermore, one cannot determine the namespace/name
>> partioning of any arbitrary URI used in an RDF graph. It is
>> not possible. That partitioning is not retained. It is lost
>> forever when the RDF/XML is parsed into the graph. Also lost
>> is the context of the qname, whether it was an element name,
>> an element-specific attribute name, or a global attribute
>> name. Cest la vie.
>>
>> The bottom line is that XML and RDF have different naming
>> architectures. XML uses qnames, which are based on pairings
>> of namespace URIs and local names. RDF uses URIs. There is a
>> rather simple, unidirectional, and lossy transformation
>> employed by RDF to get from qnames to URIs, but qnames and
>> namespaces have no meaning in the RDF graph.
>>
>> Namespaces and qnames for properties in RDF/XML are just a
>> means to an end, to serialize RDF statements and RDF ignores
>> the semantics of qnames defined by XML. Perhaps that's not
>> necessarily kosher, but that's how things are.
>
> Yes, I think I understand this.
>
> So.... _if_ the partioning of a set of terms by the association of
> subsets with distinct XML namespaces _is_ intended to carry some
> significance, and it is useful for an RDF application to present views
> of terms grouped in accordance with that partitioning, then that means
> we need to express that grouping explicitly in the RDF model in some
> way. i.e. a relationship between the terms to be grouped and some common
> resource.
>
> At the moment, I think (but I'm not completely sure!) we're saying there
> are circumstances in which we _would_ like an RDF application to be able
> to distinguish terms which in XML are associated with the namespace
> named http://purl.org/dc/terms/ from terms which in XML are associated
> with the namespace named http://purl.org/dc/elements/1.1/ ?

Well, there are two issues here, that seem to often get muddled
together.

1. What is the namespace that is used in the RDF/XML which is prepended
to the local name to generate the URI that lives in the RDF graph.

I would assert (possibly incorectly for all cases) that that namespace
is irrelevant to any use of the resultant RDF graph, and can safely
be ignored. It is just a feature of the XML serialization, but
namespaces are not a feature of the RDF model.

2. Often, a namespace is equated with a schema, or document model,
or ontology. This is perhaps understandable, given the fact that
often, coincidentally, there is but one schema, document model,
or ontology grounded in a given namespace -- but it is technically
incorrect. A namespace URI does not denote anything, insofar as
its role as a namespace. If that URI happens to also be the URI
of some resource, then OK, but that doesn't mean that the namespace
denotes the resource. Only that the URI of the resource was put
to double-use as also a namespace to provide a globally unique
partitioning for some set of names.

See my summary to the TAG for the details:

http://lists.w3.org/Archives/Public/www-tag/2002Feb/0023.html

> Is that right? If we don't need that distinction, then there is no
> problem.

We need a way to relate a term to resources which define it. And
we should use rdfs:isDefinedBy (or a subproperty of it) to do this,
but that resource is not a namespace. It might be an RDF schema.
It might be an HTML instance with prose for humans. It might be
text. Whatever.

Then, once we know the identity of that resource, we can look for
statements about the resource to determine its characteristics.
To that end, it would be good to have a standardized set of RDF
classes (or steal them from e.g. RDDL) by which to capture the
nature of those defining resources, as well as their MIME type,
character set, whatever information would be useful to an application
needing to interact with that resource.

> If we do need to make that distinction, at the moment the only means of
> doing so is on the basis of the rdfs:isDefinedBy properties associated
> with the individual terms. Is that a good basis for making that
> distinction, or should we be making some other explicit statement of the
> relationship between terms?

Well, I don't see how you can avoid making those statements explicitly,
especially since the nature of a given term may be defined by multiple
sources. Consider the case of localization labels. One may have one
RDF schema that defines the basic characteristics of the terms. But
then have additional language or locale specific schemas  that augments
the definition of those terms. And in both cases, the URIs denoting
those schemas is not in fact the same as the namespace used in the
RDF/XML serialization providing the URI of the terms. E.g.

In "uuid:8B005590-747E-11D6-9909-0003931DF47C" (core schema)
{
   <rdf:Property rdf:about="urn:foo:terms/owner">
      ...
      <rdfs:label xml:lang="en">Owner</label>
      <rdfs:isDefinedBy
         rdf:resource="uuid:8B005590-747E-11D6-9909-0003931DF47C"/>
      <rdfs:isDefinedBy
         rdf:resource="http://foo.com/docs/schemaguide.html"/>
      ...
   </rdf:Property>
}

In "uuid:BA0C6286-747E-11D6-9909-0003931DF47C" (schema providing
Finnish labels)
{
   <rdf:Description rdf:about="urn:foo:terms/owner">
      <rdfs:label xml:lang="fi">Omistaja</label>
      <rdfs:isDefinedBy
         rdf:resource="uuid:BA0C6286-747E-11D6-9909-0003931DF47C"/>
   </rdf:Description>
}

In "http://foo.com/publications/documentZ/meta.rdf"
{
   <rdf:Description rdf:about="urn:foo:publications/documentZ">
      <owner xmlns:xyz="urn:foo:terms/">John Doe</owner>
   </rdf:Description>
}

This is a simplification of a real world case. Note that in
neither of the actual schemas are namespaces for the terms
used. It is only in the actual RDF instance defining metadata
using those terms that a namespace is needed, and only because
you can't use a URI as an element name. Thus, the namespace
really has no meaning to the actual definition of the terms.

Also, it is not necessary that the URI denoting the defining
resources of a term be http: URLs. Yes, it's sometimes easier
if they are, but they need not be. I specified the example
using UUIDs to stress that what you are doing with
rdfs:isDefinedBy is identifying the resource, not necessarily
its web-accessible location.

Note also that the term 'owner' is defined by more than one
schema, as well as by some (presumably) prose document. And
that it does not share any namespace in common with them.

--

Hopefully the above is clear, and in some way useful.

Cheers,

Patrick


--

Patrick Stickler              Phone: +358 50 483 9453
Senior Research Scientist     Fax:   +358 7180 35409
Nokia Research Center         Email: [log in to unmask]