W3C home > Mailing lists > Public > public-awwsw@w3.org > March 2011

Re: please review issue-57 document draft before Tuesday telcon

From: David Booth <david@dbooth.org>
Date: Fri, 18 Mar 2011 12:06:55 -0400
To: Jonathan Rees <jar@creativecommons.org>
Cc: nathan@webr3.org, AWWSW TF <public-awwsw@w3.org>
Message-ID: <1300464415.1954.69610.camel@dbooth-laptop>
On Wed, 2011-03-16 at 07:52 -0400, Jonathan Rees wrote:
> I guess my question is: Under "take it at face value," many URIs are
> supposed to be taken to refer to WS(u). So, under what set of
> circumstances, if any, will an automaton be able to detect that URI is
> supposed to refer to IR(u)?

I like the way you're putting this -- that the criterion is to enable an
automaton to make the detection -- but I think the way you've stated it
reflects too strong an RDF bias.  The vast majority of URIs on the web
-- easily 99%+ -- arguably refer to IR(u), not WS(u), so I think it
would make more sense to state the goal with the opposite default:
Under "take it at face value," many URIs are
supposed to be taken to refer to IR(u).  So, under what set of
circumstances, if any, will an automaton be able to detect that URI u is
supposed to refer to WS(u)?

But I think the bigger problem occurs if you implicitly assume that
IR(u) is not the same as WS(u).  In other words, the definition of :IR
MUST NOT say that it is disjoint with anything.  (And lest anyone
complain that if :IR is not disjoint with anything, then we have said
nothing useful about :IR, I will remind them that IsProvable(P) is not
the same as !IsProvable(!P).  Knowing that something has been "tagged"
as an :IR may indeed be useful to some applications.)

I think a way to state the chimera case 
is to say that an HTTP GET of u returning a 200 status implies:

 <u> a :IR ; log:uri "u" .       # Assertion set gh

Let's call this set of assertions "gh" (graph implied by the HTTP

Then, if the document retrieved from u happens to be interpretable as
RDF, that RDF might further say something like:

 <u> a :Toucan .                 # Assertion set gd

Let's call this set of assertions "gd" (graph expressed in the URI
declaration, or "account").

But is :IR owl:disjointWith :Toucan?  Not necessarily.  But suppose
someone else supplies another set of assertions "ga" (graph of ancillary

 :IR owl:disjointWith :Toucan .  # Assertion set ga

Now an RDF consumer that chooses to merge graphs gh, gd and ga will
obviously have a problem, because the result will be self-contradictory.
It will either need to forgo some of these assertions, or it will need
to split the identity of <u>.

On the other hand a different RDF consumer may happily choose to merge
only graphs gh and gd, thus allowing <u> to (ambiguously) denote
something that is both an :IR and a :Toucan in the merged graph.

Furthermore, a third RDF consumer may happily choose to merge only
graphs gh and ga, thus viewing <u> as only an :IR.

This brings us into the whole question of which assertions *should* be
used in what circumstances, i.e., what should these graphs contain,
which of them should be merged by whom under what circumstances, and
what should be done if there are contradictions?

There are several questions:

1. Precisely what assertions should be included in gh, the graph implied
by the HTTP 200 response?  The n3 rules at
were intended as a first crack toward nailing this down.

2. What responsibilities does a URI owner have in minting a new URI,
configuring his/her server, and hosting a URI declaration (or
"account")?  Many people have talked about this, including the "Cool
URIs for the semantic web" document:
and my papers on URI declarations:
and "The URI Lifecycle in Semantic Web Architecture":

3. If a URI owner does host a URI declaration (or "account"), what
assertions should it include or avoid?  For example, if gh asserts that
<u> is an :IR, should the URI declaration (or "account") include a
disjointness assertion like "<u> owl:disjointWith :Toucan" if <u> is
*only* intended to denote a toucan?  This has mostly been only vaguely
addressed in the past, however my paper on "The URI Lifecycle in
Semantic Web Architecture"
does propose that the URI declaration (or "account") should not contain
any assertions that would cause the transitive closure of URI
declarations (i.e., the ontological closure) to be contradictory.

4. What should be the RDF statement author's responsibilities, in
writing a graph of statements involving <u>, to help ensure that the
intended "meaning" of <u> will be understood by an RDF consumer?  The
URI Lifecycle paper also proposed an answer to this question.

5. What process and graphs should the RDF consumer use, in attempting to
determine the referent of a URI?  The URI Lifecycle paper proposes an
(initial) answer to this
and the paper on "Resource Identity and Semantic Extensions: Making
Sense of Ambiguity"
goes into much more detail on the proposed process or algorithm.

All of these questions need more work before we can hope to reach
community consensus, but we do at least have some starting points.

David Booth, Ph.D.

Opinions expressed herein are those of the author and do not necessarily
reflect those of his employer.
Received on Friday, 18 March 2011 16:07:23 UTC

This archive was generated by hypermail 2.4.0 : Friday, 17 January 2020 19:07:22 UTC