W3C home > Mailing lists > Public > www-webont-wg@w3.org > April 2002

Re: ACTION: task force unasserted triples

From: Pat Hayes <phayes@ai.uwf.edu>
Date: Tue, 23 Apr 2002 12:14:18 -0500
Message-Id: <p05101516b8eb40d21bfb@[65.217.30.94]>
To: "Peter F. Patel-Schneider" <pfps@research.bell-labs.com>
Cc: www-webont-wg@w3.org
>From: Guus Schreiber <schreiber@swi.psy.uva.nl>
>Subject: ACTION: task force unasserted triples
>Date: Tue, 23 Apr 2002 13:35:23 +0200
>
>>  PROPOSED ACTION: for the "dark triple task force" (Jeremy Carroll,
>>  Jonathan Borden, Jos de Roo, Massimo Marchiori, Pat Hayes, Peter
>>  Patel-Schneider)
>> 
>>  Yesterday at the telecon of the Semantic Web Coordination Group the
>>  status of the "unasserted/dark triples" request to RDF Core was
>>  discussed. The CG felt that a  clarification of this request is needed,
>>  in particular:
>>
>>  1. Rationale for the request, including at least one understandable
>>  example which motivates the request.
>
>There has already been quite a number of statements of the rationale for
>this request and quite a number of examples that motivate the request.
>Without a clearer statement from the CG, how can the task force determine
>what to do?
>
>>  2. How do "unasserted triples" solve this problem?
>
>Again, there have been quite a number of statments of how dark triples
>solve this problem.  In general, there is an argument as to how the problem
>comes about, and dark triples destroys one of the premises of this
>argument.
>
>>  3. What do we lose (if anything) when adopting unasserted triples? 
>>  (See, e.g., Problems with dark triples approach, Jeremy Carroll Wed, Apr
>>  17 2002
>>  http://lists.w3.org/Archives/Public/www-webont-wg/2002Apr/0132.html)
>
>Well, a description of the difference between entailment without dark
>triples and entailment with dark triples would be quite complex and
>difficult to devise.  Why is it not sufficient to state that it is not
>possible to proceed without dark triples (or some other way of extending
>RDF syntax) and that it is possible to proceed with dark triples?
>
>>  The SW CG asks the Webont task force to come up with such a description
>>  by Monday May 6. Please indicate whether you accept this action and
>>  whether it is feasible to do this within the stated time frame..
>>

OK, my response is in the form of two additions to Peter's response, see below.

>  > Thanks, Guus
>
>
>All that said, here is what I consider to be an adequate response to the
>request.
>
>peter
>
>
>
>The Web Ontology Working Group is producing a language that can be used to
>build ontologies.  This language is supposed to use the syntax of RDF and
>to be compatible with the model theory of RDF. 
>
>However, taking all three of these together results in severe problems.
>
>
>Consider the following RDF graph
>
>   John rdf:type Student .
>   John rdf:type Employee .
>
>as the WebOnt language will include an intersection construct, this graph
>should entail
>
>   John rdf:type |intersection Student Employee| .
>
>in the WebOnt language (where |intersection Student Employee| is a short
>form for a unnamed node that is connected to some other RDF triples that
>carry the intersection construct applied to Student and Employee).
>However, this cannot be a valid entailment unless there is an object in the
>domain of discourse of the initial RDF graph that is this intersection.
>
>Therefore the model theory for the WebOnt language will have to include
>comprehension principles for these sort of classes.

To emphasize the point here. Constructs like |intersection...| could 
be given their own particular meaning by the WebOnt language's 
semantics if they were freely part of said WebOnt language; for 
example, it would be natural to say that above example is true in I 
when I(John) is in the set-theoretic intersection of ICEXT(IStudent)) 
and ICEXT(I(Employee)) , using the terminology of the RDF MT; and 
that kind of meaning would be a natural extension of the RDF model 
theory to this larger language.  (Notice that this says nothing about 
the existence of the intersection class as an object in the domain.) 
However, the syntactic and semantic layering requirements, taken 
together, rule this out. The requirement that this language uses the 
syntax of RDF imposes a syntactic restriction on the WebOnt language, 
since this syntactic construct must be encoded as an RDF graph. Now, 
all such constructs are assigned meanings by the RDF model theory. 
**If the WebOnt language could ignore those RDF meanings of the RDF 
encodings of its syntax, then the WebOnt language could assign its 
own semantic meanings to them.**  However, the requirement that the 
WebOnt language semantics be 'compatible' with RDF semantics seems to 
require that the meaning of any WebOnt language inference about an 
intersection include, or entail, the RDF meaning of the RDF syntactic 
encoding of the WebOnt language's intersection assertion. (Notice, 
not the meaning of the WebOnt language's expression, but rather of 
the RDF encoding of the expression.) And that, using any of the 
encoding methods that have been suggested, entails that the 
intersection class *exists*; which is a comprehension principle for 
the intersection class.

The situation can be summed up as follows. The WebOnt language is 
obliged by the layering requirements to treat its own syntactic 
constructions as assertions of the existence of a class corresponding 
to the syntactic construct(and in fact of a great deal else as well, 
eg lists). This is because the RDF meaning of the RDF encoding of 
every piece of the WebOnt language amounts to an assertion of the 
existence of that class. And, as Peter has shown, such a requirement 
is very dangerous, since it can rapidly lead to paradoxes or 
contradictions of various well-known kinds when the language is 
reasonably expressive. (It may be worth emphasizing that the kind of 
problems that Peter is talking about have been well-known now for 
close to a century, are widely studied, and that there is no easy or 
cute way to hack around them. Some very smart people (Hilbert, 
Russell, Church, Turing, Goedel, Quine, Kripke, Montague) have 
wrestled with these problems, and the consensus seems to be that 
there isn't any way to avoid them. Certainly they cannot be avoided 
by appeals to other kinds of logic, such as multi-valued logics or 
abandoning the law of excluded middle. They have the same kind of 
status in foundations of mathematics as, say, the conservation of 
energy has in physics. A blithe confidence that some way will be 
found to hack around them should be treated rather like a patent 
application for a perpetual-motion machine: its really not worth 
getting into the details of what is wrong with it.)

There are various ways to get past this problem. Some involve 
accepting the consequences imposed by the RDF layering but adapting 
the WebOnt language to work with them, eg by restricting its 
reasoning powers in some way, which is what Jeremy would like. (All 
such attempts strike me as misguided, as they involve WebOnt getting 
involved in doing original research in the foundations of set theory, 
and none of us are competent in this difficult and arcane area of 
mathematics.) Another would be to simply not encode the WebOnt 
language's syntax in RDF, but instead use some other notational 
framework (such as XML) which does not impose such strict 
model-theoretic meanings, as Peter has suggested. That option is 
ruled out by the WebOnt charter, I gather. The 'dark triples' 
proposal was an attempt to find a gap between the rock and the hard 
place by removing the assumption in the sentence emphasized above by 
the ** ** marks. It is simply to allow the WebOnt language to ignore 
part of the RDF meaning of the RDF encoding of its syntax (in some 
principled way, eg by ignoring the meaning of all triples which use a 
namespace associated with the WebOnt language's syntactic encoding). 
This proposal has other, independent, motivations; but here its role 
would be to allow the WebOnt language to continue to be parsed and 
processed as RDF, but to not necessarily be obliged to inherit the 
full RDF meaning of those RDF encodings, particularly when those 
meanings are at odds with its own intended meanings.

I would add that several of the current implementations of more 
complex languages such as DAML in RDF in fact already adopt this 
proposal, in effect, simply by searching the RDF graph for the 
appropriate 'higher-level' constructs (such as a daml:list 
construction encoded as a whole lot of RDF triples using the 
daml:first/daml:rest namespace) and then - and this is the key point 
- TOTALLY IGNORING their RDF meaning, and instead treating them as a 
DAML expression with a meaning defined by DAML. The extent to which 
the RDF meaning is ignored can be judged from the fact that much of 
this code will break if given a graph made using the daml:list 
vocabulary which happens to violate the syntactic assumptions of 
DAML, in spite of the fact that such a graph might be perfectly legal 
(and meaningful) RDF. An example would be a graph containing the 
triples
_:x daml:first "A" .
_:x daml:rest _:y .
_:x daml:rest _:z .
_:y daml:first "B" .
_:z daml:first "C" .
which, to emphasize, is perfectly legal RDF.  So this proposal is not 
a revolutionary change in RDF or WebOnt. It is simply a proposal to 
acknowledge, and make 'official', a common-sense assumption about 
language layering that is in fact already in widespread use and on 
which working code relies, and incorporate it into the semantics in a 
principled way. Right now, the hackers are free to do what they like, 
but the semantician's hands are tied by doctrinal constraints written 
into the charter: No fair.

A final comment. The 'dark triples' proposal has generated much 
controversy, and I do not quite understand why. I think it is often 
taken to mean more than it was intended to mean. However, the real 
reason might be because it acknowledges a basic flaw in a certain 
assumption which I suspect is widely accepted, and seen as 
fundamentally important, by many people in the W3C, even though I 
have not seen it clearly articulated. This is the idea that the SW 
can be built by starting with a very simple language, such as RDF, 
and using it *describe* other, more complicated, languages, so that 
those other languages can be brought into existence just by saying 
more and more RDF, and their meanings would somehow extend that of 
RDF while at the same time being described in RDF. This would be 
great, because (at least in principle) all we would need to implement 
would be an RDF engine, or maybe an XML engine, which would be a 
universal semantic machine, a kind of Semantic Turing Machine for the 
semantic web. This idea of a self-extending language that can, in 
principle, describe extensions to itself and then in some sense 
become those extensions, like a railway locomotive laying its own 
tracks ahead of itself, is a powerful vision, and one that I can see 
might excite considerable enthusiasm.  However, so is a 
perpetual-motion machine, and for much the same reasons. If my 
suspicions are right, and if this vision is what is driving the W3C 
SW project (and if the dark triples proposal is seen as a threat to 
its unity and coherence) then it is time that the W3C woke up.  It 
won't smell any coffee because Gödel burnt it all long ago, but at 
least it will stop dreaming.

Of course, if my suspicions are wrong, then I withdraw any imputation.


>Many more such examples can be constructed, together requiring a powerful
>theory of classes in the WebOnt language.  This theory is so powerful that
>it will contain inconsistencies, leading to a complete breakdown of the
>model theory for the WebOnt language.  (Even if the WebOnt language could
>be expressively limited to disallow the paradoxical classes, the same
>problem will reoccur at higher expressive levels in the Semantic Web
>tower.)
>
>
>If, however, the triples that are used to encode the syntax of the
>constructs of the WebOnt language are unasserted, then these constructs do
>not need to be part of the domain of discourse.  In this case, there is no
>need for comprehension axioms, and a non-trivial theory can be developed for
>the WebOnt language.
>
>What is lost?  Well, of course, quite a number of entailments are lost,

It might be worth emphasizing that one *wants* them to be 'lost'. 
That is, the form of words here may be misleading: this is rather 
like referring to urination as 'losing urine'; which is technically 
correct, but should not obscure the sense of relief obtained when it 
is gone.

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 Tuesday, 23 April 2002 13:28:16 GMT

This archive was generated by hypermail 2.2.0+W3C-0.50 : Monday, 7 December 2009 10:57:49 GMT