W3C home > Mailing lists > Public > public-rdf-wg@w3.org > February 2013

Re: (very) first draft of semantics available

From: Peter Patel-Schneider <pfpschneider@gmail.com>
Date: Thu, 21 Feb 2013 08:43:01 -0800
Message-ID: <CAMpDgVz_pfo3wzT1i3GFoVb-CyMR5nO7v0Gw5vaa-k61gE0NwQ@mail.gmail.com>
To: Pat Hayes <phayes@ihmc.us>
Cc: RDF WG <public-rdf-wg@w3.org>
On Feb 20, 2013, at 1:45 PM, Peter Patel-Schneider wrote:

[...]

> > Externally-visible changes to the semantics:
> >
> > 1/ Ill-typed literals do not denote.  [...]
> >
> > 3/ Literal values need not be in the domain of discourse.
>
> ?? They should be. Perhaps this is a slip, which I will correct.

For simple interpretations IL maps into IR.
For D-interpretations IL is equated to L2V for recognized datatypes.

Why then, the note saying that D-interpretations don't contain all possible
literal values and can be finite?  This is what caused my comment, and I
didn't dig deep enough to see that it wasn't true.

The question of whether even simple interpretations are finite is
confusing.  The first condition (please number them, by the way) says that
every language-tagged literal has an IL mapping, which then must be a
member of the domain, so this seems to show that simple interpretations are
infinite.

> > 2/ LV is no longer used.  OWL uses LV from RDF, and so would have a
> > dangling pointer.
>
> LV is still *defined* to be the set of all values of actual literals in
the universe. Its just not part of the basic structure. This should not
change anything for OWL.

Right, LV got moved from simple interpretations to D-interpretations, and I
missed that.  However, I believe that its status changed.  LV used to just
contain all the literal value spaces, but now it is defined as the union of
the literal value spaces.  This means that interpretations for different
sets of datatypes are different, which may break extensibility for some
languages.   OWL would certainly notice this change - an element of
rdfs:Literal has to belong to at least one of the recognized datatypes.

So, if the only datatype is boolean (which, I admit, isn't possible for RDF
or RDFS), then LV has precisely two elements.  This change also would be
noticeable in some languages.

> > Issues:
> >
> > 1/ Which interpretations can be used in entailment?
>
> Um, all interpretations? That is, xxx-entailment means truth is preserved
by all xxx-interpretations.
>
> > 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?
>
> Right now, no, because the constraints on classes involving rdf:type are
not introduced until we define RDFS. We could change this. Frankly I don't
think it really matters, as we could define entailment regimes for just
about any combination of the rdf: and/or rdfs: vocabularies and/or
datatyping.

> It does seem natural since rdf:type is in the rdf namespace, I agree.

Yes.

My confusion had to do with non-denoting well-formed literals, which don't
appear to be possible, but the document is very confusing on this point.

[...]

> > 2/ The empty graph is not true in all simple interpretations.
>
> Seems to me it is. Simple interpretation conditions say the only way a
graph can be false is by having a false triple, so empty must be true, no?
>
> > Does this matter?
>
> It would, yes.

Consider a simple interpretation where IL("ss"^^xsd:integer)="tt", which
appears to be possible.  This conflicts with the semantic conditions for
ground graphs.  From this, I leapt to that everything would be false, but I
see that this doesn't follow.

Nevertheless, this does seem to be very strange.

> > 3/ Are rdf:XMLLiteral and rdf:HTML required for RDF interpretations?
>
> No. We could change this, if you think it would be better if they were.
Again, perhaps they should be since these are in the rdf: namespace.

Huh?  Aren't RDF-interpretations defined as {rdf:XMLLiteral, rdf:HTML,
rdf:langString, xsd:string}-interpretations.

My question was rather whether this should be so.

> > Technical Suggestions

> > 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.
>
> Does this bother you? We could keep D-interpretations finite by only
requiring this condition for values denoted by a literal in the vocabulary.

See above.  It appears that all interpretations are infinite.

> I find myself pulled to conflicting directions over this (and related)
issues. On the one hand, the simplest way to state a lot of these conditons
is to state them for *all* values (as here) and similarly to say that all
interpretations are mappings from *all* IRIs, and so on. This avoids a host
of verbiage and fussing over exact domains of mappings, and qualifications
about being in the vocabulary and so on, none of which is really germane
and just clutters up the exposition for the average reader. But on the
other hand, this forces things to be infinite that could in fact be finite
and everything still work, and this finiteness is important for another
class of reader. I would hope that this other class of reader, competent in
model theory, would find it obvious that all of this can be restricted to
much smaller structures which are defined only on the vocabulary actually
in use in any given case, and that these can be finite. Can we rely on
this, do you think? Or are people going to say that since the simple
statement is labelled 'normative', that RDF structures are *required* to be
infinite?
>
> My inclination is to use the simple presentation in the body of the text,
but have notes linked to an appendix which explains the
restriction-to-actual-vocabulary variation and why it allows for finite
interpretation structures.
>
> Comments on this idea?
>
>
> > - 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
>
> We have both of these now, no?

Not in the definition of simple interpretations, where it should be, I
think.

> > - do all IRIs denote?
>
> Yes.
>
> > If so there are lots of places where the wording
> > indicates that they might not.
>
> The basic rules require that the IR mapping is total. Does that not cover
it?

Why then "Turned around, this means that in order for a graph to be true,
all the *IRI* and literal nodes in it must refer to something in the world
being described"?  This is confusing.

> > If not, then this should be made clear how
> > they might not.

> > Other Suggestions

[...]

> > 2/ All simple interpretations used to be [in]finite, so the note about
> > finiteness of D-interpretations is a bit awkward.
>
> I am assuming as an editorial stance that this document should not
presume that one has read the 2004 specs first, so might need to (re)state
things which have been obvious in the past.

> > 5/ Remove stuff about OOP.
>
> I want this in there somewhere, as this has given rise to a lot of
confusion in the past. (And still does, in fact.) Maybe in the beginner's
guide.

I think that concepts would be a much better place for it.

> > 6/ Remove note on inference rules, which even uses a particular meaning
for
> > "inference rule".
>
> Hmm. What do you feel about restating all these conditions as rules
(strike "inference") ? It could be done and a lot of readers would find it
easier to follow.

I don't know what this means.  My comment was about the note on "inference
rules".

> > Other Wording changes:

[...]

> > 3/ It is unfortunate that vocabulary is used in two senses: a) the
domain of
> > IS, and b) vocabulary interpretations.
>
> Yes. I have a thought to try out on you, which is to eliminate the first
sense of vocabulary altogether, and say that all interpretations are
defined on *all* IRIs. So the whole concept of an interpretation *of a
vocabulary* is simplified to not speak of vocabularies. The entire Web,
past present and future, is one giant vocabulary (or, if you prefer, one
giant FO language.) Of course they are all then infinite, but (as will be
pointed out in a technical note) the actual interpretation structure,
including the universe, can still be finite, and it is only necessary to
define the interpretation mapping for the IRIs (and literals) which are
actually in use.
>
> Comments on this idea? Seems to me it will make life easier for the folk
who are struggling with model theory in the first place, and will be an
obvious hack for those who are familiar with the basic ideas and might be
concerned about finiteness. The whole "of a vocabulary V" business does not
really play any useful role in the 2004 specs. And this would bypass a
whole pointless discussion about the infinitude of the rdf:_n container
vocabulary, for example.

[...]

peter
Received on Thursday, 21 February 2013 16:43:33 GMT

This archive was generated by hypermail 2.3.1 : Tuesday, 26 March 2013 16:25:54 GMT