Re: (very) first draft of semantics available

My comments and suggestions:


Required for FWD:

Remove loaded words (irrational, idiot's, ...)

Fix datatypes




Externally-visible changes to the semantics:

1/ Ill-typed literals do not denote.  This changes the satsifiability status
of some graphs with ill-typed literals.  For example
  ex:John ex:age "57.0"^^xsd:integer .
is now unsatisfiable in any RDF interpretation with xsd:integer as a
datatype.

2/ LV is no longer used.  OWL uses LV from RDF, and so would have a dangling
pointer.

3/ Literal values need not be in the domain of discourse.


Issues:

1/ Which interpretations can be used in entailment?
There are no problems with using partial interpretations in RDF per se, I
think, but consider
  "24"^^xsd:integer rdf:type xsd:integer .
under {xsd:integer}-RDF-interpretations.  Is this true in all such
interpretations?  If not, then how does this work for entailment?

2/ The empty graph is not true in all simple interpretations.  Does this
matter?

3/ Are rdf:XMLLiteral and rdf:HTML required for RDF interpretations?


Technical Suggestions

1/ Move xsd:string and rdf:LTL into D-entailment.  Even if this doesn't
happen, there is no need to treat xsd:string or rdf:langString specially in
simple entailment.  Then there would be no need to have any special
datatypes, proceeding as follows:
- a datatype is a mapping from either strings or strings and language pairs
     into a value space
  - for example, xsd:string, xsd:integer, rdf:langString
- a D-intepretation is respect to a set of pairs of names and datatypes,
  i.e., its set of datatype associations
- all datatype associations must be compatible with XML Schema Datatypes
- all datatype associations must include rdf:langString and xsd:string and
???
- RDF interpretations might have just these datatypes or might also have
  others
Currently there is no need that a datatype for xsd:string has an L2V that
maps strings into themselves.  Such a datatype is, of course, rather
useless, but nonetheless permisssable.
This would also fix the "effectively recognized" business, as well.

2/ Bad languages tags are invalid syntax and cannot occur in RDF graphs.

3/ Fixes for datatypes
- RDF - if v is in the value set of D then <v,D> in IEXT(I(rdf:type))
NOTE:  This makes the domain of discourse for all D-interpretations
infinite.
- RDFS - if D is a datatype then <D,I(rdfs:Datatype)> in IEXT(I(rdf:type))

Technical wording changes:

1/ Rewrites for partial interpretations, including:
- simple semantic mapping for literals is partial
- simple semantic mapping for a triple is false if any literal in it does
not denote
- do all IRIs denote?  If so there are lots of places where the wording
indicates that they might not.  If not, then this should be made clear how
they might not.


Other Suggestions

1/ Remove philosophical stuff that could go into the idiot's guide.

2/ All simple interpretations used to be finite, so the note about
finiteness of D-interpretations is a bit awkward.

3/ Remove note on infinity of RDF interpretations and subsequent discussion.

4/ Move discouraged stuff to an appendix and label it as historical, or
simply remove it.

5/ Remove stuff about OOP.

6/ Remove note on inference rules, which even uses a particular meaning for
"inference rule".



Other Wording changes:

1/ Initial note saying that this document depends on the new version of
CONCEPTS, which is not yet written, but that there should be no surprises.

2/ Hyperlink defined terms back to their definitions, either in Concepts or
Semantics, e.g.
- name
- vocabulary
- ground RDF graph
- ill-typed (particularly important as this is a forward reference)
- lean graph
- ...

3/ It is unfortunate that vocabulary is used in two senses: a) the domain of
IS, and b) vocabulary interpretations.


Typos:

1/ *IL* was not a partial mapping

2/ rules given above XXXXXfor namesXXXXX