Re: making statements about the lexical form of a URI

On Fri, 2010-08-13 at 08:49 +0200, Reto Bachmann-Gmuer wrote:
> 
> 
> On Fri, Aug 13, 2010 at 12:52 AM, Nathan <nathan@webr3.org> wrote:
>         David Booth wrote:
>                 On Thu, 2010-08-12 at 21:57 +0100, Dave Reynolds
>                 wrote:
>                 [ . . . ]
>                                   "http://xmlns.com/foaf/0.1/name" a
>                                 foo:URI;
>                                       foo:uriLength 30;
>                                       foo:uriAuthorityHost
>                                 "xmlns.com";
>                                       foo:xxxxx
>                                 <http://xmlns.com/foaf/0.1/name>;
>                                 
>                                 The specific question is, how do you
>                                 unambiguously identify a URI in order
>                                 to make statements about the lexical
>                                 form of that URI?
>                         In OWL full the domain of owl:Thing is the
>                         whole universe of discourse,
>                         including literals. So I believe in OWL Full
>                         you can equate a individual
>                         with a literal and then describe properties of
>                         that individual:
>                         
>                          [] owl:sameAs
>                         "http://xmlns.com/foaf/0.1/name"^^xsd:anyURI;
>                             foo:uriLength 30;
>                          foo:uriAuthorityHost "xmlns.com" . 
>  
> there seems to be a misunderstanding here.  
>                         
>                         Using a blank node rather than a URI is not
>                         necessary but is clearer. 
>                 . . . except of course that it *is* necessary at
>                 present, because at
>                 present RDF does not permit literals as subjects.  
>         
>         
>         Thanks, saved me saying that one :) 
> Instead of using a bnode you could use nay URIRef, which would name
> the literal value. The UriRef used as name for the literal uri need
> not have any relation to it.

Exactly:

     http://my.namespace.of.lexicalforms/1234 
         owl:sameAs "http://xmlns.com/foaf/0.1/name"^^xsd:anyURI;
         foo:uriLength 30;      
         foo:uriAuthorityHost "xmlns.com" .

Expresses the same relationship as the blank node version but does not
use a literal as a subject. 
>         also, with regards owl:sameAs - given my example at the top,
>         how would one specify: (associate the literal with the uri)
>         
>          <http://xmlns.com/foaf/0.1/name> owl:sameAs
>         "http://xmlns.com/foaf/0.1/name"^^xsd:anyURI .
>         
>         given that
>          <http://xmlns.com/foaf/0.1/name> owl:sameAs
>         <http://ex.org/blah> .
>         
>         and
>          <http://ex.org/blah> owl:sameAs
>         "http://ex.org/blah"^^xsd:anyURI.
>         
>         because the above triples would imply all kinds of Falsehoods 
> The graph with these three triples expresses a contradiction, it is
> false in every possible world, but there's nothing wrong with that ;)

It's not just that it's a contradiction but it is saying something
different from what was intended (I hope!).  We wouldn't actually want
the resource <http://xmlns.com/foaf/0.1/name> to denote its own
spelling, it denotes the FOAF name relationship.

If you really want to do this sort of thing you could introduce a
predicate eg:prefURI which links a concept to the spelling of the
preferred URI for denoting that concept - bearing in mind there might be
multiple preferred URIs.

   <http://xmlns.com/foaf/0.1/name>
       eg:prefURI [
           owl:sameAs "http://xmlns.com/foaf/0.1/name"^^xsd:anyURI;
           foo:uriLength 30;      
           foo:uriAuthorityHost "xmlns.com" .
       ].

I'm unclear on the usefulness of any of this but technically it is
possible.

BTW in RIF there is a pred:iri-string predicate which can map between a
resource expressed as an IRI and a spelling as a string. This is not a
syntactic mapping if you equate two individuals then iri-string will be
a many to many relationship and provide both spellings for both
individuals.

Dave

Received on Friday, 13 August 2010 08:01:28 UTC