Re: Comments on Last-Call Working Draft of RDF 1.1 Semantics

Here is a concrete proposal for changes to be made in RDF 1.1 Concepts 
and RDF 1.1 Semantics.

tl;dr: concepts defines datatype maps as a mapping from some IRIs to 
datatypess, and introduces the terms "recognized datatype IRIs" (the 
domain of the datatype map) and "recognized datatypes" (the range of the 
datatype map).

Using this terminology, the modifications to semantics are surprisingly 
minimal. Almost all text relating to D-entailment stays the same as in 
RDF 1.1 Semantics CR.

However, I request that datatype map are used in the semantic condition 
for D-entailment. Once this is set, the other semantic conditions in 
other entailment regime can stay almost identifical.

I also ask Michael to review my proposal. The phrasing, if retaining the 
idea, can be improved.



Changes to concepts:
====================

5.4  Datatype Maps

Datatypes are identified by IRIs.  In order to know the value of a 
literal, implementations should be able to associate its datatype IRI to 
the datatype it identifies.
This association between IRIs and datatypes is called a <def>datatype 
map</def> and it is formally defined as a mapping from a set of IRIs to 
datatypes.

The set of IRIs in a datatype map is known as the <def>recognized 
datatype IRIs</def>, the datatypes associated with recognized IRIs by 
the datatype map are called the <def>recognized datatypes</def>, and 
datatype maps MUST satisfy the following conditions:

  - If the datatype IRI 
http://www.w3.org/1999/02/22-rdf-syntax-ns#XMLLiteral is recognized, 
then it must be paired with the datatype rdf:XMLLiteral defined in this 
specification.
  - If the datatype IRI http://www.w3.org/1999/02/22-rdf-syntax-ns#HTML 
is recognized, then it must be paired with the datatype rdf:HTML defined 
in this specification.
  - If the datatype IRI 
http://www.w3.org/1999/02/22-rdf-syntax-ns#PlainLiteral is recognized, 
then it must be paired with the datatype rdf:PlainLiteral defined in 
[RDF:PLAINLITERAL].
  - If the datatype IRI http://www.w3.org/2002/07/owl#rational is 
recognized, then it must be paired with the datatype rdf:PlainLiteral 
defined in [OWL 2 Structural Specification].
  - If the datatype IRI http://www.w3.org/2002/07/owl#real is 
recognized, then it must be paired with the datatype rdf:PlainLiteral 
defined in [OWL 2 Structural Specification].
  - If a datatype IRI of the form http://www.w3.org/2001/XMLSchema#xxx 
is recognized, then it must be paired with the RDF-compatible XSD type 
named xsd:xxx.

Other specifications may impose additional constraints on the datatype 
map, for example, require support for certain datatypes.

Implementations are free to recognize datatype IRIs that are not part of 
a W3C specification, in which case they SHOULD provide in their 
documentation the definition of the datatype to which the IRI maps to, 
making the datatype map explicit. However, if an implementation solely 
recognizes datatypes contained in XSD union {rdf:HTML, rdf:XMLLiteral, 
rdf:HTML, owl:rational, owl:real}, then it MAY only provide a set of 
recognized IRIs because the associate datatypes are constrained by this 
specification.

<Note:> RDF Test cases never use datatypes outside the list above, so 
entailment tests refer to sets of recognized IRIs without making the 
datatype map explicit.</Note>
<Note:> If an implementation recognizes a datatype outside the list 
above, it SHOULD rely on a datatype IRI that can dereference to a 
specification of the associated datatype.  If it does so, then it is 
possible to define the datatype map of the implementation simply as a 
set of recognized IRIs</Node>.



Changes to semantics:
=====================

List of places where the notion of "identifying" and "recognizing" is used:

In Section 4: "For example, the fact that the IRI 
http://www.w3.org/2001/XMLSchema#decimal is widely used as the name of a 
datatype described in the XML Schema document [XMLSCHEMA11-2] might be 
described by saying that the IRI identifies that datatype. If an IRI 
identifies something it may or may not refer to it in a given 
interpretation, depending on how the semantics is specified. For 
example, an IRI used as a graph name identifying a named graph in an RDF 
dataset may refer to something different from the graph it identifies."

  --> requires no change, in my opinion

Section 5: "Semantic extensions may impose further constraints upon 
interpretation mappings by requiring some IRIs to refer in particular 
ways. For example, D-interpretations, described below, require some 
IRIs, understood as identifying and referring to datatypes, to have a 
fixed denotation."

  --> requires no change because even with datatype maps, certain 
datatype IRIs are required to have a fixed denotation.

Section 7: "Datatypes are identified by IRIs. Interpretations will vary 
according to which IRIs they recognize as denoting datatypes. We 
describe this using a parameter D on simple interpretations, where D is 
the set of recognized datatype IRIs. We assume that a recognized IRI 
identifies a unique datatype wherever it occurs, and the semantics 
requires that it refers to this identified datatype. The exact mechanism 
by which an IRI identifies a datatype IRI is considered to be external 
to the semantics. RDF processors which are not able to determine which 
datatype is identified by an IRI cannot recognize that IRI, and should 
treat any literals with that IRI as their datatype IRI as unknown names."

  --> change this to: "Datatypes are identified by IRIs. Interpretations 
will vary according to which IRIs they recognize as denoting datatypes. 
We describe this using a parameter D on simple interpretations, where D 
is a datatype map, with recognized datatype IRIs S. A recognized IRI 
identifies the unique datatype it maps to according to the datatype map 
wherever it occurs, and the semantics requires that it refers to this 
identified datatype. RDF processors that do not recognized a given IRI 
cannot determine which datatype is identified by this IRI, and should 
treat any literals with that IRI as well as their datatype IRI as 
unknown names."

The second change note in Section 7 can be changed to:

<Change note:> RDF 1.1 introduces the notion of recognized datatype IRIs 
and recognized datatypes which corresponds to the set of IRIs in a 
datatype map and to the datatypes associated with these IRIs, 
respectively. The use of this notion simplifies the exposition of 
D-entailment.

Next paragraph: "A literal with datatype d denotes the value obtained by 
applying this mapping to the character string sss: L2V(d)(sss)."

  --> change to "If a datatype IRI uuu is recognized in a datatype map 
D, then a literal with datatype IRI uuu denotes the value obtained by 
applying this mapping to the character string sss: L2V(D(uuu))(sss)."

Next paragraph: "RDF processors are not required to recognize any 
datatype IRIs other than rdf:langString and xsd:string, but when IRIs 
listed in Section 5 of [RDF11-CONCEPTS] are recognized, they MUST be 
interpreted as described there, and when the IRI rdf:PlainLiteral is 
recognized, it MUST be interpreted to refer to the datatype defined in 
[RDF-PLAIN-LITERAL]. RDF processors MAY recognize other datatype IRIs, 
but when other datatype IRIs are recognized, the mapping between a 
recognized IRI and the datatype it refers to MUST be specified 
unambiguously, and MUST be fixed during all RDF transformations or 
manipulations."

  --> change to "RDF processors are not required to recognize any 
datatype IRIs other than rdf:langString and xsd:string, but when IRIs 
listed in Section 5 of [RDF11-CONCEPTS] are recognized, they MUST be 
interpreted as described there, and when the IRI rdf:PlainLiteral is 
recognized, it MUST be interpreted to refer to the datatype defined in 
[RDF-PLAIN-LITERAL]. RDF processors MAY recognize other datatype IRIs, 
but when other datatype IRIs are recognized, the datatype map 
associating the recognized IRI to the datatype it refers to MUST be 
specified unambiguously, and MUST be fixed during all RDF 
transformations or manipulations."

2 paragraphs later: "RDF processors which fail to recognize a datatype 
IRI will not be able to detect some entailments which are visible to one 
which does."

  --> (optional) rather than "which fail to recognize" simply say "which 
do not recognize", because it does not need to be a failure, it could be 
on purpose

Section 7.1: "Let D be a set of IRIs identifying datatypes."

  --> change to "Let D be a datatype map."

Semantic conditions: "If rdf:langString is in D, then for every 
language-tagged string E with lexical form sss and language tag ttt, 
IL(E)= < sss, ttt' >, where ttt' is ttt converted to lower case using 
US-ASCII rules"

  --> (optional) change to "If rdf:langString is recognized in D" (but I 
can live with the idea that an element is included in a map if it 
belongs to the domain

"For every other IRI aaa in D, I(aaa) is the datatype identified by aaa, 
and for every literal "sss"^^aaa, IL("sss"^^aaa) = L2V(I(aaa))(sss)"

  --> change to "For every other IRI aaa recognized in D, I(aaa) = 
D(aaa), and for every literal "sss"^^aaa, IL("sss"^^aaa) = L2V(I(aaa))(sss)"

The right hand side of the last equality could read "L2V(D(aaa))(sss)" 
of course.

Section 7.2: ""

  --> add a sentence: "When a datatype map D can be nonambiguously 
characterized with a set of IRIs (for instance, when the recognized 
datatype IRIs are contained in XSD IRIs) then D is reduced to a set and 
this specification use this as an abbreviation, such as RDF entailment 
recognizing {rdf:langString, xsd:string}"

After technical note: "In all of this language, 'D' is being used as a 
parameter to represent some set of datatype IRIs, and different D sets 
will yield different notions of satisfiability and entailment."

  --> change to "In all of this language, 'D' is being used as a 
parameter to represent some mapping from datatype IRIs to datatypes, and 
different D maps will yield different notions of satisfiability and 
entailment."

The following sentence is compatible with datatype maps because a 
mapping is formally a set of pairs, so the empty set is a mapping, 
mappings can be subset of others, etc.: "The more datatypes are 
recognized, the stronger is the entailment, so that if D ? E and S 
E-entails G then S must D-entail G. Simple entailment is { }-entailment, 
i.e. D-entailment when D is the empty set, so if S D-entails G then S 
simply entails G."

  --> keep as is.

Section 7.2.1: "For example, if D contains xsd:decimal then ..."

  --> Again here, a datatype map does not contain datatype IRIs or 
datatypes strictly speaking (they only contain pairs) but I think this 
is acceptable abuse of notation, so I request no change. The following 
paragraphs in the section have similar harmless abuse of notation.

Section 8: "RDF-D interpretations MAY fail to recognize these datatypes."

  --> (optional) replace "fail to" by "not"

Section 8.1: "When D is {rdf:langString, xsd:string} then we simply say 
S RDF entails E."

  --> Here, given the text to be put in RDF concepts, it is ok to define 
the datatype map as a set when it only contains standard datatype IRIs. 
So no change is needed.

RDFS semantic conditions: "for every other IRI aaa in D, ICEXT(I(aaa)) 
is the value space of I(aaa)"

  --> change to "for every other recognized IRI aaa in D, ICEXT(I(aaa)) 
is the value space of I(aaa)"  (Note that it could be equivalently 
ICEXT(D(aaa)), but due to the RDF semantic conditions, it's the same thing.

"for every IRI aaa in D, I(aaa) is in ICEXT(I(rdfs:Datatype))"

  --> change to "for every recognized IRI aaa in D, I(aaa) is in 
ICEXT(I(rdfs:Datatype))"

Section 9.2.1, RDFS entailment patterns: "rdfs1 	any IRI aaa in D"

  --> "any recognized IRI aaa in D"



I haven't looked at the appendices for the moment.
-- 
Antoine Zimmermann
ISCOD / LSTI - Institut Henri Fayol
École Nationale Supérieure des Mines de Saint-Étienne
158 cours Fauriel
42023 Saint-Étienne Cedex 2
France
Tél:+33(0)4 77 42 66 03
Fax:+33(0)4 77 42 66 66
http://zimmer.aprilfoolsreview.com/

Received on Wednesday, 11 December 2013 15:23:30 UTC