Re: RDF Semantics - datatypes and "identifies" vs "denotes" - ISSUE-145

Hi Pat,

On 10/29/2013 12:53 AM, Pat Hayes wrote:
> On Oct 28, 2013, at 8:55 PM, David Booth <> wrote:
>> Hi Pat,
>> I'm trying to understand the rationale for defining the notion of
>> "identifies" as being distinct from "denotes".
> The RDF semantics *defines* the notion of denotation. It *uses* the
> notion of identification, which is also used and described in a
> number of other W3C standards and publications. The RDF semantics
> document does not set out to define this notion: it simply refers to
> it as being any any widely accepted notion of how IRIs map to
> meanings which is used and accepted externally to RDF.  Thus, for
> example, the IRI *identifies*
> the datatype called 'int' defined in section 3.4.17 of the W3C XML
> Schema Definition Language (XSD) 1.1 Part 2 Recommendation published
> on 5 April 2012, That this
> is true is not determined by anything in the RDF semantics: it is
> simply a fact, established by a complex set of social, linguistic and
> technical conventions about how certain IRIs are attached to accepted
> meanings. In order to ensure that RDF denotation agrees with this, so
> that interpretations  (in appropriate cases) map
> '' to that datatype, it is
> necessary to stipulate that denotation as defined in RDF coincides
> with this socially defined mapping from IRIs to meanings; and that,
> in turn, requires that we have a way to refer to this (and similar)
> mappings. That is why we use the term "identify" in the RDF Semantics
> document to refer to this (indeed to any defined-externally-to-RDF)
> mapping. (We could just say something like, these IRIs denote what
> everyone would expect them to denote, but that would probably not be
> considered to be acceptably precise.)

I think I see what you're getting at, but as written it sounds as though 
there are two separate notions being used within the formal semantics, 
whereas I think what you mean is that one of these terms ("identify") is 
intended to refer to the vague notion of identify/denote that is used 
*outside* of the formalization, and the other ("denote") is intended to 
refer to the precise *formalization* of that notion in the RDF 
semantics.  Is that correct?

BACKGROUND: We have pre-existing terms "identify" and "denote", and 
associated with these pre-existing terms we have pre-existing notions of 
what they mean.  In both cases those pre-existing notions generally 
refer to some kind of mapping from names to meanings.   THEREFORE: If 
I'm understanding properly, "identify" is being used in the RDF 
Semantics document to refer to this vague pre-existing notion of a 
mapping from names to meanings, whereas "denote" is being used to refer 
precisely to the *formalization* of that notion as a mapping in a 
particular interpretation.   Is that correct?

If so, then that would alleviate my concern about having two different 
IRI mappings defined, but I think the description of "identify" in 
section 4 should be clarified, because at present it sounds like 
"denote" is refering to an *alternate* notion of a mapping from names to 
meanings, rather than a formalization of the *same* notion.

I would suggest changing the second paragraph of section 4 to something 
Informally, IRI meanings may be determined in a number of socially 
defined ways external to the RDF semantics.  When we wish to refer to 
this informal, socially defined mapping from IRIs to meanings, we will 
use the word *identify* and its cognates.  In contrast, when we wish to 
refer to the precise formalization of this notion in the RDF semantics, 
we use the words *denotes* and *refers* interchangeably as synonyms for 
the relationship between an IRI or literal and what it refers to in a 
given interpretation, itself called the *referent* or *denotation*.

For example, the fact that the IRI is widely used as the name of a 
datatype described in the XML Schema document [XMLSCHEMA11-2] might be 
described informally by saying that the IRI identifies that datatype. 
But in the formal semantics it may or may not refer to that datatype in 
a given interpretation (depending on whether it is /recognized/).  As 
another example, an IRI used as a graph name identifying a named graph 
in an RDF dataset could refer, in a particular interpretation, to 
something different from the graph it informally identifies.

>> As I mentioned before, at first reading this appeared to me to be a
>> contrived distinction that was created to avoid having a URI denote
>> more than one thing.
> That was not the purpose of making the distinction.

Got it.  (I think.)  Thanks for the clarification.

>> But you argued that it was needed for the datatype semantics to
>> work out, so I wanted to understand that.
Section 7 says: "We assume that a recognized IRI identifies a unique 
datatype wherever it occurs, and the semantics requires that it refers 
to this identified datatype."  Therefore, for a recognized IRI, the 
"identifies" mapping is the same as the "denotes" mapping.  So at least 
for recognized IRIs, there appears to be no need to distinguish between 
"identifies" and "denotes".
> The necessity is to make the assertion, that in this case denotation
> is (defined to be) identical to identification, not be a tautology.
> As it stands, this is a definition (of denotes) which uses an
> predefined term (of identifies) in its body. If these two terms were
> considered to be identical in meaning, this definition would be
> vacuous. But in any case, they are not identical in *meaning*.

Okay, sounds good.


>> Is the distinction then needed for non-recognized IRIs?  But I
>> don't think I saw any semantic conditions or entailment rules for
>> non-recognized IRIs.  Are there some that I missed?  I'm not seeing
>> how the datatype semantics requires a distinction between
>> "identifies" and "denotes".  Can you explain?  Please feel free to
>> shift your reply to instead of posting to this
>> list.
>> Also, a few small editorial issues/typos:
>> 1. Two typos in this sentence: "RDF processors which are not able
>> to determine which datatype is identifier by an IRI cannot
>> recognize that IRI, and should treat any literals type with that
>> IRI as unknown names." s/identifier/identified/ s/type/typed/
> Yes, others had noted these. Now fixed.
>> 2. "Such literals SHOULD be treated like IRIs and assumed to
>> denote" should be "Such literals SHOULD be treated like IRIs and
>> SHOULD be assumed to denote"?
> No, because this follows from the first. But it could read "
> ...SHOULD be treated like IRIs and hence assumed to denote..."
>> 3. "A literal with datatype d denotes the value obtained by
>> applying this mapping to the character string sss: L2V(d)(sss)."
>> should be "A literal composed of character string sss with datatype
>> d denotes the value obtained by applying this mapping to sss:
>> L2V(d)(sss)."?
> Yes, I will make that change in the next edit.
> Pat
>> Thanks, David
> ------------------------------------------------------------ IHMC
> (850)434 8903 home 40 South Alcaniz St.            (850)202 4416
> office Pensacola                            (850)202 4440   fax FL
> 32502                              (850)291 0667   mobile
> (preferred)

Received on Tuesday, 29 October 2013 13:55:08 UTC