Re: MISC: Internet Media Type registration: proposed TAG finding

>On Thu, 2002-05-23 at 19:14, Peter F. Patel-Schneider wrote:
>>  [Moved from WebOnt to RDF Logic per the direction of the WebOnt chair.]
>[oops; quite...]
>
>>  From: Dan Connolly <connolly@w3.org>
>>  Subject: Re: MISC: Internet Media Type registration: proposed TAG finding
>>  Date: 23 May 2002 17:31:20 -0500
>[...]
>>  > But that's not all there is to it. dc:title is a term
>>  > with widely deployed semantics/meaning/definition/specification.
>>  > The dublin core folks have some reasonably clear notion
>>  > of which interpretations are consistent with its
>>  > intended use and which are not.
>>
>>  I fail to see how the intended meaning of dc:title can be considered to be
>>  part of RDF, except for that portion of the intended meaning that is
>>  captured by RDF triples that are available on the web and are readily
>>  retrieved from a well-known place. To make it otherwise would turn RDF
>>  into an undefined thing. 
>
>Hmm... incompletely defined, yes, of course.
>i.e. tomorrow I expect to find out more about how
>folks are using the framework; i.e. to see how
>they've further elaborated it.
>
>
>>  For example, I could claim that pfps:Truth is a part of RDF, whose intended
>>  meaning is the type of all true propositions in first-order logic.  Does
>>  mean that RDF captures first-order truth?  Not at all!
>
>I'm not sure what you mean by 'captures', but yes, your pfps schema/spec
>would provide a term that folks can use to claim, in RDF syntax,
>that things are first-order truths.

That is simply ridiculous. That makes RDF able to express the whole 
of human thought. To make claims like this is irresponsible.  Look, 
"folks" can use anything in any way they like, as long as they are 
using it between folk. But that is not the issue for the SW: we have 
to provide meaning for *software* to publish and use, and the 
meanings are only those meanings that software can (based on the 
language specs) actually utilize. That does not include comments 
written in English.

>It wouldn't be unprecedented, by the way:
>
>   http://www.w3.org/2000/10/swap/log#Truth

Wow, scales fall from my eyes! It is SO easy to define logical truth! 
I wonder why all those dead Polish and German guys had so much 
trouble with it. Maybe they were just stupid.... but no, I guess they 
didn't have access to the Power of the Web, that was probably what 
was wrong.

Seriously, that document (1) does not define logical truth in any way 
whatsoever (2) says this: - <rdfs:Class 
rdf:about="http://www.w3.org/2000/10/swap/log#Truth">
   <rdfs:comment>Something which is true: belive it as you would 
belive this. Understood natively by cwm in that it will execute rules 
in a formula declared a Truth within a formula it is already taking 
rules from.</rdfs:comment>

which seems to indicate that log#Truth in fact is simply supposed to 
mean 'asserted', which is perfectly meaningful, but is not the same 
as 'logically true'. And in fact, the document does not define *any* 
meanings in RDF, or constrain the RDF interpretations, in any way 
whatsoever. It is just English with RDF decorations added. (The CWM 
code might be said to be a kind of implicit machine-readable 
constraint on interpretations of this vocabulary - along the lines of 
'this means whatever it takes to make CWM produce valid conclusions' 
- but it goes well beyond what an RDF engine would be able to make 
use of.)

>
>>  > These
>>  > informal prose documents, e.g. the dublin core spec,
>>  > still have semantics: they still divide interpretations
>>  > into true and false.
>>
>>  Sure, but this informal part is *not* part of RDF.
>
>I accept that as your opinion. I disagree.
>Perhaps if you'd share the argument that leads
>you to that conclusion, we could discuss it further.

The onus is on you to justify what on the face of it is a ridiculous 
claim. On what basis can ANY formalism claim to encompass an informal 
meaning?

>  > > I don't think that notion of "meaning of a document"
>>  > is specified very well, but I think
>  > > it's what most RDF authors/implementors have
>>  > in mind.
>>
>>  If so, then they are seriously deluding themselves that they are doing
>>  RDF.  They are instead doing RDF + what I mean, or RWIM.
>
>Again, I'm not sure what you mean by 'doing RDF', but it's
>plain to me, from the usage of RDF that I can see (RSS,
>PRISM, dublin core, XMP, ...) that
>the framework includes this sort of thing.

There is no way that any amount of 'usage' could extend the semantics 
of RDF past what it in fact is. Delusions do not constitute meaning.

>  > > Now likewise, the DAML+OIL spec divides interpretations
>>  > between those that are consistent with it and those
>>  > that are not.
>>
>>  Well, aside from the fact that DAML+OIL interpretations are not RDF
>>  interpretations, sure.
>
>I consider that a bug in the DAML+OIL spec; I hope we fix
>it in OWL.
>
>
>>  > If I say
>>  >	:age rdf:type ont:UniqueProperty.
>>  >	:bob :age "10".
>>  >	:bob :age "20".
>>  >
>>  > and I investigate its meaning in the Resource Description
>>  > Framework, I start with the conjunction of the three
>>  > facts there, and then I'll look up rdf:type; its
>>  > spec tells me the extension of rdf:type is computed
>>  > from the class extension of its object; so I go
>>  > and look up ont:UniqueProperty, and I discover
>>  > that its class extension is properties whose
>>  > subjects determine their objects uniquely.
>>
>>  Who discovers this, and how? 
>
>As explained above, I (i.e. anybody using
>the framework) use the deployed URI infrastructure
>to dereference http://www.daml.org/2001/03/daml+oil#UniqueProperty
>and I see:
>
><rdfs:Class rdf:ID="UniqueProperty">
>   <rdfs:label>UniqueProperty</rdfs:label>
>   <rdfs:comment>
>     compare with maxCardinality=1; e.g. integer successor:
>     if P is a UniqueProperty, then if P(x, y) and P(x, z) then y=z.
>     cf OIL FunctionalProperty.
>   </rdfs:comment>
>   <rdfs:subClassOf
>rdf:resource="http://www.w3.org/1999/02/22-rdf-syntax-ns#Property"/>
></rdfs:Class>
>
>The comment there is reasonably clear as a constraint
>on interpretations, no?

NO!!! It is not in any way a constraint on interpretations, any more 
than a comment in a program is code. A comment is a COMMENT, and that 
is all. YOU can read that and understand it, Dan, because you are a 
HUMAN BEING WHO UNDERSTANDS ENGLISH. The whole point of the semantic 
web is to allow SOFTWARE AGENTS to do a little understanding. When 
you can write a Perl script that can figure out the content of the 
English comments, then maybe you can claim that the meaning of the 
comments is part of the meaning of the formalism. It still wouldn't 
be part of RDF, but you could call it RDFE .

>I didn't know much about
>model theory when I wrote it, but it seems to work OK.
>
>>  > But the RDF MT tells me that "10" and "20"
>>  > denote distinct things, so there isn't any
>>  > way to satisfy the combination of this
>>  > document, the rdf:type spec, and the
>>  > ont:UnambiguousProperty spec, no matter
>>  > what specification for :age I might find.
>>  > i.e. this document, combined with the
>>  > specifications for the terms it uses,
>>  > is false.
>>
>>  Sure, but what you have done is *not* RDF, it is RDF plus DAML+OIL.
>
>I disagree that it's not RDF.

It is RDF syntax, of course, since DAML+OIL is encoded in RDF syntax. 
It isn't correct according to RDF semantics. RDF syntax with DAML+OIL 
semantics is not RDF, its DAML+OIL.

>That seems like saying that XHTML documents are not XML documents...
>or that TCP packets aren't IP packets. They clearly are.

No, its not like that. Its like saying that what makes a TCP packet 
correct TCP can't be determined without knowing TCP; it goes beyond 
the IP spec.

Your sense of 'being RDF' is coherent, but trivial. In this sense, 
all of human language is really 'mark', where 'mark' is any set of 
marks on a surface. True, but completely pointless and uninteresting 
as a claim, and unimportant as an observation.

>  > > That's how DAML+OIL fits into the Resource Description Framework,
>>  > and how I hope/expect OIL will too.
>
>[oops... s/OIL/OWL/]
>
>>  That is, DAML+OIL does not fit into the Resource Description Framework,
>>  instead it extends the Resource Description Framework (or, more accurately,
>  > DAML+OIL could extend the Resource Description Framework if the natural
>>  extension didn't give rise to paradoxes).
>
>In what way does it not fit into the framework? I don't see
>the distinction you're trying to make. Are you talking
>about daml:collection syntax? Yes, that was (an attempt
>at) an extension to the framework, I suppose. But otherwise,
>DAML+OIL ontologies seem to use the framework without
>changing it; they seem to fit right in.

If that were true, then it would be impossible to express daml:union 
in DAML, since it is provably impossible to express it in RDF.

>Let's put it this way: does dublin core fit into the framework?
>Or is RDF+dc an extension? How about a document that
>uses RDFS, DAML+OIL, and dublin core together? Is that
>another sort of extension?

Dan, you cannot possibly be this obtuse. Surely you know the 
distinction between a language and a set of axioms in that language. 
DC is a set of assertions in RDF, right? That means that one can 
interpret those DC assertions using the RDF semantics and they mean 
something that approximates to what the DC writers had in mind, 
roughly. If you do that to DAML, you often *don't * get an 
approximation of what the writer of the DAML had in mind.

>  > > An RDFS tool can handle a document that uses WebOnt terms
>>  > much more gracefully than a version 2 word processor
>>  > usually handles version 3 documemtns: halt and catch
>>  > fire totally.
>>
>>  Sure, an RDFS tool can handle a DAML+OIL document - by treating it as an
>>  RDFS document and completely ignoring the DAML+OIL part.
>
>No, not completely ignoring the DAML+OIL part: it can
>still tell that daml:Class is a subclass of rdfs:Class
>and come to lots of relevant/licensed conclusions.

That is rdfs:subClassOf, right? So you are not ignoring the DAML+OIL 
*vocabulary* (of course) but you are treating it like an RDFS 
vocabulary, ie ignoring the DAML+OIL meaning. I think that is what 
Peter meant by 'ignoring the DAML+OIL part'.

>  > > e.g. given the age 10/20 example above, an RDFS-capapble
>>  > tool might not detect the inconsistency by reducing
>>  > the possible interpretations to none, but it can
>>  > tell that in all satisfying interpretations,
>>  > :age has rdf:type rdf:Property; it can derive
>>  > conclusions by erasure and existential introduction,
>>  > by subPropertyOf and subClassOf rules, etc.
>>  >
>>  > That's partial understanding.
>>
>>  Well, maybe, but such partial understanding is prone to misunderstandings.
>>  (Think of propositional negation.)
>
>What about it?
>
>>   I don't see how it could be more gain
>>  than loss, in general.
>
>Er... so you expect every agent to completely understand every document?
>Surely that's a non-starter, no?
>
>>
>>  > [...]
>>  > > >At the instance data level, all this shouldn't matter. (Thankfully, for
>>  > > >the poor end users...)
>>  > >
>>  > > It has to matter. If someone marks up their webpage using WebOnt,
>>  > > then an RDF engine isn't going to be able to understand it, right?
>>  >
>>  > It will understand it partially.
>>
>>  Sure, but the non-understood part may completely change the meaning of the
>>  other part,
>
>No, I don't think so...
>
>>  so the partial understanding may not be related to the ``real''
>>  meaning in any worthwhile fashion.
>
>it's monotonic, in that the more you understand, the fewer
>interpretations are models. You can't rule out models by
>failing to understand something.

True, but there is another issue. The more complicated language may 
have more complicated models also (usually will). The extra structure 
is invisible to the lower language; so the semantic constraints that 
are imposed by the higher language cannot be stated in terms of the 
model theory of the lower language.

>Can you think of an example where the non-understood part
>changes the meaning of the other part?

Well, a natural example would be adding datatyping information to 
change the meaning of a literal, if we treated RDF literals in a 
rational fashion as denoting expressions. (I know we don't do this 
right now, but only at considerable cost, and incidentally violating 
the conventions used by the dc. )

Pat

>Maybe this monotonicity is a constraint on vocabulary
>specifications that I didn't mention earlier.
>You can't, for example, specify that the semantics
>of my:magicThing are such that
>	my:magicThing dc:title "abc".
>means that "abc" is *not* a title.
>
>Er... well, you could, but that would say that documents
>that use your vocabulary are always unsatisfyable/false.
>So that case is still monotonic.
>
>In general, vocabulary specs start with property extensions,
>and rdf:type delegates to class extensions.
>
>>   If that is what you want then go right
>>  ahead, but don't expect me to send any business to a system that acts in
>>  this fashion.
>>
>>  > > This isn't rocket science: all of computation is like this.
>>  >
>>  > No, some computation degrades gracefully. Try looking
>>  > a the W3C home page, written in XHTML 1.0 circa 1999, with
>>  > a web browser written in 1994. I think you'll find
>>  > a remarkable degree of fidelity.
>>
>>  Sure, sometimes you win.  However, you can also lose.
>
>Well, partial understanding in the semantic web isn't
>just a matter of syntactic sloppiness... it's constrained
>to be monotonic. So I don't see how you can lose.
>
>
>--
>Dan Connolly, W3C http://www.w3.org/People/Connolly/


-- 
---------------------------------------------------------------------
IHMC					(850)434 8903   home
40 South Alcaniz St.			(850)202 4416   office
Pensacola,  FL 32501			(850)202 4440   fax
phayes@ai.uwf.edu 
http://www.coginst.uwf.edu/~phayes