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

>On Fri, 2002-05-24 at 12:56, Peter F. Patel-Schneider wrote:
>>
>>  WARNING:  My conclusions below depend on the assumption that RDF agents do
>>  not need to understand the implications of natural language prose as the
>>  objects of rdfs:comment statements.
>[...]
>
>My position is that they don't need to, but it helps if they do.
>[below I learn more about what you mean by 'RDF agent', which
>changes things somewhat...]
>
>>  From: Dan Connolly <connolly@w3.org>
>>  Subject: Re: MISC: Internet Media Type registration: proposed TAG finding
>>  Date: 23 May 2002 22:08:16 -0500
>>
>>  > On Thu, 2002-05-23 at 19:14, Peter F. Patel-Schneider wrote:
>>  >
>>  > > From: Dan Connolly <connolly@w3.org>
>>  > > Date: 23 May 2002 17:31:20 -0500
>>
>>  [...]
>>
>>  [ example document, modified
>>	:best-friend rdf:type ont:UniqueProperty.
>>	:bob :best-friend :margaret .
>> 	:bob :best-friend :peggy .
>>	:peggy :age "35" .
>>  ]
>>
>>  > > Sure, but what you have done is *not* RDF, it is RDF plus DAML+OIL.
>>  >
>>  > I disagree that it's not RDF.
>>
>>  Well, then suppose that our RDF agents have a disagreement on the meaning
>>  of this RDF document.  My RDF agent says that the above document is a
>>  perfectly fine RDF document, and that, according to that document,
>>  :bob has a :best-friend that is :margaret
>>       and a :best-friend that is :peggy
>>  and that the :age of :peggy is the two-character english string "35".
>>  Your RDF agent says that the above is a fine RDF document but that it also
>>  entails that the :age of :margaret is the two-character english string "35".
>>  At this point my RDF agent publishes on the web that your RDF agent makes
>>  unsupported conclusions and should not be trusted.
>>
>>  I claim that my RDF agent is completely justified in publishing a claim
>>  that your RDF agent is broken in a dangerous fashion and that no one should
>>  trust anything it says.
>
>That seems counter to common sense. That seems like saying
>an IOU document
>
>	"I owe you one dollar"
>
>doesn't mean that I could pay you with 4 quarters, since
>the relationship between a dollar and quarters isn't
>specified in the IOU.

Right, it IS counter to common sense. I hate to break this news to 
you, Dan, but computers are not very good at common sense. In fact, 
trying to give a glimmer of common sense to computers has been a 
central concern in AI for about 30 years now, and gave rise to the 
entire field of knowledge representation, ontology languages, 
description logics and so on that constitute the technology being 
adapted for the SW. So yes, indeed, we are NOT assuming that the 
agents have any common sense. If they did, we probably wouldn't need 
to mark up web pages with all this formalized stuff.

>The author of the best-friend document, by choosing to use
>ont:UniqueProperty class, licensed inferences
>based on the specification of that class. The conclusion
>that "35" is an :age of :margaret is supported
>by the DAML+OIL spec.

But in the example, it was RDF agents doing the analysis, not 
DAML+OIL agents. That is the point: WHICH language are we working in 
here?

>
>In some ways, this example is quite crisp, but there
>seems to be some ambiguity in the discussion... I'm
>not exactly sure what you mean by 'RDF agent',
>and the term 'entails' is used ambiguously: your
>agent seems to claim that anything beyond
>simple entailment
>   http://www.w3.org/TR/2002/WD-rdf-mt-20020429/#entail
>is dangerous and should not be trusted.
>
>I can think of two agents (cwm and Euler) that
>do a lot more than simple entailment, when
>asked to. I think of them as RDF agents.

Well, you are of course free to think whatever you want, but that 
isn't the way that this kind of terminology is usually used. It seems 
to me that your usage renders the term 'RDF agent' almost vacuous, 
since *anything* could be an RDF agent. I bet with a little work one 
could compile Java into RDF triple stores in some wierd way; would 
that make the Java VM into an RDF agent?

>
>>  > 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.
>>
>>  I'm not talking about daml:collection.  I'm talking about meaning, not
>>  syntax.  The meaning that comes from the DAML+OIL model theory, or the
>>  meaning that comes from the commonly-understood meaning of natural language
>>  utterances that are objects of RDF triples, is not part of the RDF
>>  meaning of these triples.
>
>I'm not sure what to make of that; I'm not sure what you
>mean by 'RDF meaning', nor by one meaning being part
>of another.

RDF meaning is what is sanctioned by the RDF model theory. We could 
be generous and include RDFS entailment, actually.

>
>>  > 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?
>  >
>>  Any part of Dublin Core that has is part of an RDF(S) document can be
>>  considered to be part of RDF(S).  However, if Dublin Core has formal
>>  portions that are not captured by an RDF(S) document, such as functionality
>>  conditions on some of its properties, then Dublin Core is a strict
>>  extension of RDF.  As DAML+OIL is an extension of RDF(S), so DAML+OIL +
>>  Dublin Core is, of necessity, an extension of RDF(S).
>
>Hmm... maybe I could learn to talk that way.
>(what about informal portions by the way? I don't expect there's
>a formal definition of dc:title, yet I stick by my
>claim that "pears and apples" is not a dc:title
>of http://www.w3.org/, according to he dublin core specs.)

The central issue is whether you would expect a piece of software to 
be able to come to this conclusion. Would an RDF reasoner barf if you 
told it that

<http://www.w3.org/> [dc:title] "pears and apples" .

or would it just draw some very wierd conclusions? If the latter, 
then your claim has no justification and it is dangerous to stick to 
it, since you might be misled into thinking that your intended 
meaning is the actual meaning, a well-known dangerous trap.

>
>
>
>>  [...]
>>
>>
>>  > Er... so you expect every agent to completely understand every document?
>>  > Surely that's a non-starter, no?
>>
>>  No.  I expect an RDF agent to completely understand the RDF meaning of
>>  every RDF document.  At the very least, I expect an RDF agent to not
>>  understand anything else.
>
>Hmm... it seems by 'RDF agent' you mean some sort of diagnostic
>testing tool for RDF documents, not any sort of interesting
>agent.

No, he means something that can draw RDF-valid conclusions. (What 
else could "RDF agent" mean in this context? )

>Clearly, by that definition, my tool that concludes "35"
>is an age of :margaret isn't an RDF agent.
>
>>   Any agent that makes conclusions that are not
>>  sanctioned by the RDF model theory is doing more than RDF, and had better
>>  be very sure not to label its conclusions as RDF conclusions.
>
>er... 'RDF conclusion'... another new term. I suppose
>you mean the sort of conclusion supported (only)
>by simple entailment.
>
>But yes, the conclusion that "35" is an age of :margaret
>isn't supported by simple entialment alone, and
>justification of that conclusion needs to be clear
>about including the DAML+OIL spec.
>
>>  Think of the example where two agents are trying to determine whether one
>>  owes the other some money.  If one agent presents the other with a
>>  derivation labelled as a valid RDF (or first-order logic) entailment, then
>>  it had better be a valid RDF (or first-order logic) entailment, not
>>  something that only comes from some extra-RDF semantic conditions (or
>>  conditions outside of first-order logic).
>
>Yes, justifications have to cite their sources.

What kind of 'source'? It's not enough to cite the DAML source if you 
are an RDF agent, since *considered as RDF* it doesn't mean what it 
means as DAML+OIL. You also need to say what inference conditions you 
are using to draw conclusions from the source.

>  > > > Sure, but the non-understood part may completely change the 
>meaning of the
>>  > > other part,
>>  >
>>  > No, I don't think so...
>>
>>  Why not?  What about
>>
>>	<fol:negation>
>>	  <fol:statement>
>>	    <rdf:Person rdf:about="#John">
>>	      <loves rdf:resource="#Mary">
>>	    </rdf:Person>
>>	  </fol:statement>
>>	</fol:negation>
>
>I'm not sure how to parse that. If I presume that fol:negation
>is an RDF typednode, and convert to (something close to) KIF, I get:
>
>   (exists (?n)
>     (rdf:type ?n fol:negation)
>     (fol:statement ?n #John)
>     (rdf:type #John rdf:Person)
>     (loves #John #Mary)
>   )
>
>so... ?n is a negation, and it's somehow related to John.
>I think you meant to express something like
>   (not (loves John Mary))
>but that's really awkward to do in RDF

Its *impossible* to do in RDF. If you could express negation in RDF 
then the Herbrand lemma would be false.

>, but I suppose
>it could look like:
>
>   <fol:Negation>
>     <fol:predicateSymbol>http:...#loves</fol:predicateSymbol>
>     <fol:subjectSymbol>http:...#John</fol:predicateSymbol>
>     <fol:objectSymbol>http:...#loves</fol:objectSymbol>
>   </fol:Negation>
>
>where fol:Negation is specified ala:
>
>   (forall (?n ?s ?p ?o)
>     (<=>
>       (and
>         (predicateSymbol ?n ?p)
>         (subjectSymbol ?n ?s)
>         (objectSymbol ?n ?o)
>         (wtr
>            '(not (holds `(str->sym ?p) `(str->sym ?s) `(str->sym ?o))) )
>       )
>       (rdf:type ?n fol:Negation)
>   )
>
>But even in that case, I *only* eliminate models when I
>learn the meaning of fol:Negation (i.e. when I add that axiom).
>
>I can only constrain the meaning by learning more.
>
>>  > > 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.
>>
>>  Sure, if you require a monotonic relationship, then the relationship is
>>  monotonic.  However, where does the requirement for a monotonic
>  > relationship come in?
>
>Hmm... good question. Maybe it's been implicit all along.
>Maybe it belongs in the RDF model theory spec, in
>a discussion of... umm... 'extensions' to RDF,
>as you call them.

Sorry, its not going in there. This is a huge can of worms and it 
isn't RDF's problem. Send it to WebOnt.

>
>I suppose I'll send a comment to www-rdf-comments.
>
>>  > Can you think of an example where the non-understood part
>>  > changes the meaning of the other part?
>>
>>  Sure.  See above.
>>
>>  > 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.
>>
>>  Well, of course, if you require the relationship to be a monotonic
>>  extension, then you get monotonic relationships.  However, as discussed
>>  extensively, requiring the relationship to be monotonic leads to severe
>>  problems.
>
>I reamain hopeful those problems can be solved.

I wish you would come up with some solutions, then. The rest of us 
are stuck in the mire.

Pat


-- 
---------------------------------------------------------------------
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

Received on Wednesday, 29 May 2002 13:08:56 UTC