W3C home > Mailing lists > Public > www-rdf-logic@w3.org > June 2002

Re: Implementing statement grouping, contexts, quads and scopes

From: pat hayes <phayes@ai.uwf.edu>
Date: Tue, 25 Jun 2002 11:45:30 -0500
Message-Id: <p05111b0eb93e4ca75c0b@[]>
To: Patrick Stickler <patrick.stickler@nokia.com>
Cc: www-rdf-logic@w3.org

>On 2002-06-24 18:00, "ext Jonathan Borden" <jonathan@openhealth.org> wrote:
>>  Patrick Stickler wrote:
>>>  On 2002-06-24 10:47, "ext Patrick Stickler" <patrick.stickler@nokia.com>
>>>  wrote:
>>>>  On 2002-06-21 15:53, "ext Jonathan Borden" <jonathan@openhealth.org>
>>  wrote:
>  >>>> The concept of "dark triples" as a layering option seems to be getting
>>  a bit
>>>>>  misunderstood. The essence of "dark" or "unasserted" triples is simply
>>  that,
>>>>>  from a technical perspective, it is difficult (some would indeed say
>>>>>  impossible) to define a language such as OWL (and given the constraints
>>>>>  placed on this language by the WebOnt charter etc.) in RDF if OWL is to
>>  have
>>>>>  the characteristics we desire, and RDF triples are all "truths".
>>>>  I consider RDF to already have a mechanism for expressing unasserted
>>>>  triples, namely reification. The only reason folks want to create
>>  something
>>>>  else, IMO, is simply because the RDF/XML syntax is so obese. I.e.
>  >>>  <rdf:Statement>
>>>>      <rdf:subject   rdf:resource="#foo"/>
>>>>      <rdf:predicate rdf:resource="&owl;bar"/>
>>>>      <rdf:object    rdf:resource="#bas"/>
>>>>   </rdf:Statement>
>>  Yes, this syntax is not acceptable for Semantic Web languages that are are
>>  to be 'layered' on RDF.
>>  ...
>>>  Note also that unasserted "dark" statements at the RDF-level can be
>>>  asserted at any given higher level where they have meaning in a automated
>>>  and generic fashion.
>>>  OWL level assertions can be easily automated using this approach
>>>  by a single rule:
>>>  {
>>>     ?x rdf:type rdf:Statement .
>>>     ?x rdf:subject ?s .
>>>     ?x rdf:predicate ?p .
>>>     ?x rdf:object ?o .
>>>     ?p rdf:type owl:OWLPredicate .
>>>  }
>>>  log:implies
>>>  {
>>>     ?s ?p ?o .
>>>  }
>>>  Done.
>>  Well these sorts of issues and purported solutions appear to be a uniform
>>  characteristic of attempts to develop languages _in_ RDF that are also to be
>>  layered _on_ RDF (e.g. TimBL's "layer cake" as it is called).
>>  Don't you see what you are trying to do?
>>  You are writing an N3 formula _which is not RDF but as if it were something
>>  in RDF_ and casually tossing this out as a solution to some problem _in
>>  OWL_.
>>  How is OWL to use such a formula if OWL is to be layered on RDF? How are
>>  such rules supposed to be specified? Sure if we accept N3 this is no problem
>>  but that's the point: N3 formulas, when represented as triples, use
>>  collections of unasserted triples. This is most basic:
>>  X=> Y
>>  does not imply (i.e. assert) X so you need a way to _say_ "X" without
>>  asserting X.
>>  But hold on and understand this:
>>  You are proposing RDF reification as a way to 'implement' unasserted triples
>>  but you are using _another_ mechanism of unasserted triples in order to
>>  'implement' reification. It is exactly these sorts of arguments that are
>>  akin to trying to develop a perpetual motion machine.
>>  So certainly if you give us a mechanism for N3 formulae the problem would be
>>  solved. That is the whole point, really.
>>  Jonathan
>As I mentioned in another posting, how a given upper layer asserts
>the statements that are meaningful at the upper layer which are
>unnasserted at the lower layers is not central to the approach
>I was proposing.
>I was using N3 simply to illustrate that it can be easily automated.

Of course it can be easily implemented. That is not the point. One 
can write a PERL script to render HTML into XML, but that doenst make 
the HTML spec into the XML spec.

>It can be simply a requirement on all OWL processors that they "pretend"
>that unasserted RDF statements which contain OWL predicates are
>asserted -- or part of an OWL preprocessor on an RDF graph which
>maps unasserted OWL statements into asserted RDF statements. Whatever.

This whole discussion isn't helped by getting ostentatiously vague 
and sloppy at the point where the problems arise. Look, if a 'higher' 
level language could be given a licence to 'pretend' that some piece 
of RDF means something different, of course there would be no 
layering problem. That is exactly why we are suggesting a 
dark-triples mechanism, in fact. But the people who wrote the Webont 
charter were, and are, most insistent that OWL be layered on top of 
RDF in the very exact sense that OWL*is* legal, and correct, RDF. OWL 
cannot pretend anything about RDF: it has to use RDF correctly. It is 
that insistence on precision of inter-layer registration that causes 
all the difficulties. If we are allowed to ignore the bumps and saw 
off the pieces that get in the way, then the process of getting 
things to fit together seems easy, and indeed if we could do that it 
would be easy. No doubt there is working code somewhere that takes 
liberties like this. That is irrelevant: we can't.

Pat Hayes

IHMC					(850)434 8903   home
40 South Alcaniz St.			(850)202 4416   office
Pensacola,  FL 32501			(850)202 4440   fax
Received on Tuesday, 25 June 2002 12:45:33 UTC

This archive was generated by hypermail 2.3.1 : Wednesday, 2 March 2016 11:10:38 UTC