[Top] [All Lists]

Re: [ontolog-forum] OWL and lack of identifiers

To: Pat Hayes <phayes@xxxxxxx>
Cc: Ontolog Forum <ontolog-forum@xxxxxxxxxxxxxxxx>
From: Waclaw Kusnierczyk <Waclaw.Marcin.Kusnierczyk@xxxxxxxxxxx>
Date: Mon, 16 Apr 2007 21:51:09 +0200
Message-id: <4623D3AD.1030605@xxxxxxxxxxx>
Pat Hayes wrote:
>> Pat Hayes wrote:
>>>>>> , but we could say that u1 is the subject of the triple,
>>>>>> etc., but then we need to be clear in distinguishing the triple as an
>>>>>> expression and the proposition it expresses, of which u1 is not the
>>>>>> subject.)
>>>>> Right. The notion of proposition does not really get used in RDF. 
>>>>> Although if you check the recommended semantics for reified 
>>>>> triples, the reification is interpreted as a proposition rather 
>>>>> than a syntactic expression.
>>>> In the docs, you differentiate between a triple (in the abstract) 
>>>> and a particular realization of it, in some physical document. This 
>>>> is perhaps what you mean here, but this still does not seem to me to 
>>>> be the distinction between a proposition and an expression.
>>> No, thats not what I meant. I was referring to the suggested truth 
>>> conditions for reified triples, in which the (take a deep breath) 
>>> object of the subject property is the referent of the subject URI of 
>>> the original triple, not the subject URI itself.
>>> ...
>> Still holding...  Yes, this is clear from the (suggested) semantics of 
>> the reification vocabulary.  But I were far from even mentioning 
>> reification.
>>>>>> Note that an RDF(S) triple may have a literal rather than an 
>>>>>> identifier
>>>>>> as the object.  Using this form, you can explicitly connect a URI to
>>>>>> another URI, so that the latter is the referent of the former.  
>>>>>> Although
>>>>>> the core RDF(S) vocabulary does not provide you with a URI for the
>>>>>> relation of identity, there is nothing in the way to create one.
>>>>> But this relation isn't identity, its more like 'refers to' 
>>>>> (actually its inverse). BUt I agree, one can add this property. It 
>>>>> can't be described in OWL or even in normal FOL, so one needs some 
>>>>> external machinery or extension in any case.
>>>> No, you're wrong here.  Since the URI in the subject position is 
>>>> treated as a reference and not as an entity, you can't make a 
>>>> statement such as 'u1 denotes u2'.
>>> You can if you have a name for u1. Of course you cannot use the URI 
>>> to name itself, but you had already noted that point (on which we 
>>> agree, of course).
>> What I was saying is that you the triple
>> u1 u2 u3
>> does not *necessarily* say anything about the URI u1;  it may, though, 
>> if u1 is self-referential (and why couldn't it be?)  That is, there is 
>> nothing in the RDF semantics that would forbid a URI to name itself.
>> The *form* of the statement in RDF would be a triple like
>>> u3 denotes u2 .
>>> where 'u3' is the URI used to refer to the URI 'u1'. My point - and I 
>>> think we are in violent agreement here - is that the relationship of 
>>> naming, which has to hold between u3 and u1 in order for this to be 
>>> any use, is something outside the RDF model. But this should not be 
>>> surprising: RDF is very simple, and even its own reification 
>>> vocabulary needs some kind of external machinery to connect the 
>>> subject URI of the reification graph to the original triple which the 
>>> reification is supposed to describe.
>>>>  You need to make a statement such as 'u1 is u2', where the first 
>>>> URI is dereferenced, and the other is not
>>> You can't do it that way (in legal RDF) as the RDF spec requires all 
>>> URIs to be dereferenced.
>> I do can, since a URI is just a sequence of characters organized 
>> according to specific syntactic rules (this is a syntactically 
>> modified but semantically rather accurate definition of URI).  Thus, 
>> the following triple has the effect of asserting that a URI is 
>> self-referential:
>> protocol://domain/some-name protocol://domain/identity-relation 
>> "protocol://domain/some-name"
>> where "protocol://domain/some-name" is a string literal which happens 
>> to be a valid URI, the same as used in the subject (of the triple).  
>> Thus, the referent of the URI protocol://domain/some-name is in the 
>> relation of identity (say) with the string enclosed in double quotes 
>> (which do not belong to the string!) -- that is the URI denotes itself.
>> There is no quotation in RDF. Perhaps we should
>>> have put it in, but its too late now. In fact, reification seems to 
>>> have died and not be widely mourned, so maybe this omission is not in 
>>> fact of great importance.
>> There is no quotation, but since URIs are strings, a string 
>> indiscernible from a URI is in effect identical with the URI.
>> But even if this fails, for some reason, you can use a URI to refer to 
>> itself by just intending to do so, as you would intend to use a URI to 
>> denote a dog, say.
>> vQ
> Ahhh, I see now what you have been saying. Sorry if I was slow. Yes, you 
> are right, in princiople we could have slef-referntial URIs, and their 
> characteristic hallmark woul dbe that they were equal to their own 
> quotations. (It would be better to use a typed literal with xsd:anyURI, 
> which is unambiguously understood to refer to URI, even if URIs are 
> considered different from strings (which they are by some people; giving
> protocol://domain/some-name protocol://domain/identity-relation 
> "protocol://domain/some-name"^^http://www.w3.org/2001/XMLSchema#anyURI .    (01)

This is exactly what I said in one of my first posts on this issue, 
though I restrained myself from using the concrete syntax:    (02)

<u1> <u2> "u1"^<uri>    (03)

asserts self-referentiality of u1, provided that u2 denotes identity, 
and uri denotes the xml-schema datatype anyURI (though this is optional, 
I think).    (04)

(Note that the triple above is in fact a triple with a nested triple 
with a nested pair.)    (05)

> But this cannot be a general solution, since most triples contain URIs 
> whose intended interpretation is not themselves, but something that was 
> the topic of the representation containing the triple in the first 
> place. Making them refer to themselves will change their meaning, and 
> the meaning of the ontologies that contain them. So what we need as a 
> general device is a way to create a new URI (<u3> in my message) which 
> refers to a given URI, i.e. in effect a quoting mechanism. Such a thing 
> could of course be set up, by defining a 'uri-quoting' name space and 
> forming the new u3 URI out of it and the old u1 URI in some systematic way.
> Im afraid I have lost track of what this purpose of this thread is :-)    (06)

The initial purpose of my communications was to defend the thesis that 
it is possible (at least in rdf) to make statements about uris in a way 
that leaves no question whether it is the ur or its referent that the 
statement is about.  Someone complained that it is not clear whether an 
expression involving a URI is about the URI or about its referent, and I 
claim that, in RDF at least, it is clear:    (07)

"<u1> predicate object" is about the *referent* of u1, and about a URI 
iff the referent of u1 is a URI, and about u1 iff the referent of u1 is u1.    (08)

Self-referential URIs are of little importance, I showed that you can 
have such because you agreed with me that there cannot be 
self-referential URIs in RDF.    (09)

vQ    (010)

> Pat
>     (011)

Wacek Kusnierczyk    (012)

Department of Information and Computer Science (IDI)
Norwegian University of Science and Technology (NTNU)
Sem Saelandsv. 7-9
7027 Trondheim
Norway    (013)

tel.   0047 73591875
fax    0047 73594466
------------------------------------------------------    (014)

Message Archives: http://ontolog.cim3.net/forum/ontolog-forum/  
Subscribe/Config: http://ontolog.cim3.net/mailman/listinfo/ontolog-forum/  
Unsubscribe: mailto:ontolog-forum-leave@xxxxxxxxxxxxxxxx
Shared Files: http://ontolog.cim3.net/file/
Community Wiki: http://ontolog.cim3.net/wiki/ 
To Post: mailto:ontolog-forum@xxxxxxxxxxxxxxxx    (015)

<Prev in Thread] Current Thread [Next in Thread>