Re: Ill-typed vs. inconsistent?

Pat,

On Mon, Nov 12, 2012 at 6:21 PM, Pat Hayes <phayes@ihmc.us> wrote:

>
> Inconsistency isn't an error. If you want to suggest that we make
> ill-typed literals into a version of a syntactic error, I would go along
> with that, but it has consequences for parsers that the 2004 WG thought
> were too onerous. Since RDF's treatment of dataypes is open-ended, it means
> that when any new datatype is added, you have to re-write the parser code
> to catch a new class of errors. And it also means that RDF is kind of
> nonmonotonic (in a sense): adding RDF information can make previously legal
> RDF into illegal RDF.
>
> (Both of these issues would be solved or greatly eased if RDF simply
> adopted the XSD datatypes as the only, and fixed, set of RDF datatypes and
> ceased trying to be so future-general. If we were to do this, then I would
> absolutely vote for making ill-typed XSD literals into a *syntactic* error,
> and simply not mentioning ill-typing in the semantics at all.)
>
> But, if illtyped literals are syntactically legal, then as Semantics
> editor I insist that they must have some kind of meaning. This can be done
> in several ways. One is to simply say that all triples containing an ITL
> are false. This is simple but has several disadvantages. It means that
> there is no way to say anything about an ill-typed literal, and it means
> that a whole raft of "obvious" logical properties start to have exceptions.
> Basically, all tautologies involving literals can now be false, so all the
> axioms need to have ill-formed-literal exceptions written into them (and we
> have to check that they can't sneak in the back door by interactions
> between inference rules.) This is a well-known can of worms for logicians,
> which is one reason typed logics were invented, to push ill-typing into the
> syntax in order to keep the semantics from getting hopelessly muddy. The
> other way (and it is a general pattern for expressing typing in an untyped
> logic) is the one we used: allow these "bad" expressions to have a value,
> but insist that it is a value in a dustbin category that has a name, so
> that wellformedness can be expressed in the logic itself.
>

thank you for those explaination, which help me understand why ill-typed
literals do not make the graph D-inconsistent.
However...

My intuition is that, whenever I'm faced with a typed literal
"foo"^^xsd:integer,
this implies something like

    "foo"^^xsd:integer  rdf:type  xsd:integer .

(I'm indulging in allowing literals as subject, but I know that it won't
bother you ;)

Of course, the above triple is perfectly consistent in RDF-entailment.
However, it is inconsistent in XSD-entailment.

So my problem (and, I think, Richard's), is that that triple is *not*
entailed by the mere mention of "foo"^^xsd:integer, as my intuition would
have it.

  pa