W3C home > Mailing lists > Public > public-rdfa-wg@w3.org > August 2010

Re: Comment on RDFa 1.1 Core: Profiles, term mappings, and URIs as literals (ISSUE-39)

From: Richard Cyganiak <richard.cyganiak@deri.org>
Date: Thu, 12 Aug 2010 19:23:21 +0100
Cc: Mark Birbeck <mark.birbeck@webbackplane.com>, Ivan Herman <ivan@w3.org>, public-rdfa-wg@w3.org
Message-Id: <C9F8625E-21FA-49BF-9A90-6F89AA1D504D@deri.org>
To: Simon Grant <asimong@gmail.com>
Simon,

I don't think that any of this is relevant to RDFa, and that we're  
just going down a useless RDF Semantics rathole. If you think "RDF  
doesn't work that way", may I ask you to please quote some spec text.

On 12 Aug 2010, at 14:49, Simon Grant wrote:
>> That is correct, but consistent with my proposed definition of  
>> rdfa:term.
>> In RDF Semantics language, rdfa:term identifies the binary  
>> relationship that
>> holds between an entity and a short form for the URI of that entity.
>
> Richard seems to me to be implying, both through the use of the word  
> "the"
> in "short from for the URI of that entry" and in the use of the  
> imaginary
> predicate "foo:uriLength", that an entity has exactly one URI.

I didn't mean to imply that. Substitute "a" for "the" if that helps.  
But fine, let's unpack this a bit.

Entities don't "have" URIs at all. We think of certain URIs as  
identifying certain things in our domain of interest, but this  
association is by convention, it is not governed by the RDF  
specifications (with the exception of the built-in terms in the rdf:  
and rdfs: namespaces, whose referent is fixed by the RDF  
specifications).

But anyway, by convention it is fine and common to think of several  
URIs as identifying the same thing.

> In which case, what is put forward as a trivially true statement
> "<http://xmlns.com/foaf/0.1/name> foo:uriLength 30 ."
> could be unpacked (in English, let's ground this discussion outside  
> RDF) as
> * The FOAF concept of name is represented (by me) by a particular  
> URI (even
> though it might be represented by many other URIs).
> * The URI that I use (at present, at least) for this concept has a  
> length of
> 30.

No. It would simply be: "The thing identified by <http://xmlns.com/foaf/0.1/name 
 > (whatever it is) has one identifier of length 30." Which is  
trivially true -- no matter what the URI actually identifies, the  
statement is always true. If I add sameAs statements to the mix, to  
assert that different URIs identify the same thing as this one  
(whatever that thing is), then the statement remains true -- the thing  
has at least one URI of length 30. So the following graph is trivially  
true under OWL semantics:

   <http://xmlns.com/foaf/0.1/name> foaf:uriLength 30 .
   <http://xmlns.com/foaf/0.1/name> foaf:uriLength 13 .
   <http://xmlns.com/foaf/0.1/name> owl:sameAs <http://ex.org> .

That's not quite intuitive, but shows that it is all consistent with  
OWL and RDF semantics: The *thing* identified by both of these URIs  
has identifiers of length 30 and 13.

Note that for our discussion of rdfa:term, this whole story is pretty  
much a non-issue, for three reasons:

1. rdfa:term is typically used with classes and properties, and  
owl:sameAs is only used for individuals. owl:equivalentClass and  
owl:equivalentProperty would be used instead, and they don't have the  
effect of asserting co-reference between URIs, they only assert  
equivalence for purposes of OWL reasoning.

2. Furthermore, RDF Semantics and OWL reasoning are only concerned  
with a single graph -- statements that may or may not exist in other  
graphs are irrelevant. Given that RDFa is explicit about which  
profiles to include for processing, problems can only arise if the  
profile author or RDFa document author did something funny.

3. The case of several URIs being mapped to the same term has to be  
resolved by the RDFa spec anyways, no matter if this arises from  
owl:sameAs or from authoring mistakes.

> how it is conceivable to have an actual URI as
> the subject of a triple?

This isn't about the *subject*, it's about the *object*. The *object*  
of a statement can be some property of a URI identifying the subject,  
such as its length in characters, or its short name.

> Would it be reasonable to say that this is a
> trade-off for RDF as a whole -- that we gain conciseness at the  
> expense of
> ruling out a whole area of expressibility?

No, that's false, see counter-example above.

> Presumably, to do this in RDF would require some special mechanism to
> indicate that what is being talked about is a URI, not a thing that  
> might be
> represented by a URI, and we don't currently have that mechanism.

You don't need a special mechanism. It's just a question of how you  
define the relationships identified by your property URIs:

"foo:uriLength identifies the relationship between an entity and the  
length of an URI identifying the entity."

"rdfa:term identifies the relationship between an entity and a short  
name for a URI identifying the entity."

Best,
Richard



>
> I hope this is at least a reasonable representation of the issue --  
> if not,
> apologies and I will welcome correction.
>
> Simon
>
> -- 
> Simon Grant
> +44 7710031657
> http://www.simongrant.org/home.html
Received on Thursday, 12 August 2010 18:23:56 GMT

This archive was generated by hypermail 2.2.0+W3C-0.50 : Friday, 27 April 2012 04:55:07 GMT