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

DTTF: summary 5/27/2002 for review

From: Jonathan Borden <jonathan@openhealth.org>
Date: Tue, 28 May 2002 00:03:51 -0400
Message-ID: <026b01c205fc$aec77580$0301a8c0@ne.client2.attbi.com>
To: "WebOnt WG" <www-webont-wg@w3.org>
A new revision, for discussion at Thursday telecon.

Layering OWL on RDF using unasserted triples
-- http://www.openhealth.org/WOWG/DTTF-20020527

The WebOnt WG has been debating the issues surrounding the layering of OWL
onto RDF for the existence of the WG with seemingly no end. At its core, the
issue regards the ability to create a new language on top of an existing
language in which everything which is said, is said to be a truth, the new
language looses its ability to add anything to the equation or worse
paradoxes ensue.

The effort to both develop OWL as an extension to RDF and assert each and
every triple, appears to have been akin to an attempt to stuff a balloon
filled with water into a cube whose volume is less than that of the balloon:
every attempt to stuff the balloon in results in some part of the balloon
squeezing itself out somewhere.

The Problem
Peter Patel-Schneider has provided multiple and lengthly discourses on the
paradoxes that ensue as a result of OWL as a  "same syntax" extension of
RDF.

http://lists.w3.org/Archives/Public/www-webont-wg/2002Feb/0172.html

The problem seems to be a result of the requirement for:

1) all RDF triples to be asserted i.e. "truths"

2) classes as instances

3) OWL's need to support commonsense entailments e.g.
intersectionOf(student,employee) <=> intersectionOf(employee,student)

http://lists.w3.org/Archives/Public/www-webont-wg/2002May/0059.html

http://lists.w3.org/Archives/Public/www-webont-wg/2002May/0064.html

http://lists.w3.org/Archives/Public/www-webont-wg/2002Apr/0240.html

http://lists.w3.org/Archives/Public/www-webont-wg/2002May/0057.html

> _:1 fowl:onProperty rdf:type .
> _:1 fowl:hasClass _:2 .
> _:2 fowl:OneOf _:3 .
> _:3 fowl:first _:4 .
> _:3 fowl:rest fowl:nil .
> _:4 fowl:complementOf _:1 .
>
>   _:1 is the set of objects
>   that are related to a particular complement of _:1
>   via rdf:type
>
>   if x rdf:type _:1
>   then x rdf:type _:4
>   but _:1 and _:4 are complements
>
>   so not x rdf:type _:1
>   if not x rdf:type _:1
>   then x rdf:type _:4
>   because _:1 and _:4 are complements
>
>   but then x rdf:type _:1
>


Pat Hayes states the problem such paradoxes cause for the Semantic Web:

[[

Look, the paradoxes are not a programming problem, and they don't have
anything to do with non-termination. (A non-terminating process corresponds
to something that is undecideable, roughly, not to a paradox.) If the SW
tried to do reasoning in the presence of paradoxes, the problem would not be
that code fails to terminate. All the reasoning engines would work fine, and
if they were using DL-style logic then they would probably work quite
efficiently and rapidly, producing correct, checkable proofs using
semantically correct inference rules. However, the conclusions would all be
worthless, because that perfectly valid logic would be able to prove that
2+2=5 and the Pope was both a Roman Catholic and also not a Roman Catholic,
and so on. The problem would not be in the code, but in the content of the
expressions manipulated by the code. The correctness of the code would not
guarantee that the conclusions made any sense (in fact, it would guarantee
that they *didnt* make sense.) The conclusions produced by any reasoner are
only as good as the information it is given. In the presence of paradoxes it
can produce nonsense all by itself, so any information it handles is
potentially corrupted.
]]

http://lists.w3.org/Archives/Public/www-rdf-logic/2002Apr/0088.html
Such problems illustrate the subtleties which result from simple assertions
as simple "truthes" e.g. from Peter F. Patel-Schneider

[[

Now what about a document that consists of the following single statement:

         this a n3:falsehood .


Consider any interpretation for the document. Suppose the statement is
true in the interpretation.  But then the statement is false, because the
entire document belongs to n3:falsehood, and the statement is the only
statement in the document.  Suppose the statement is false in the
interpretation.  But then it is true, because the entire document does not
belong to n3:falsehood and the statement is the only statement in the
document.  Thus it is impossible to assign a truth value to this
statement (and document), thinking model theoretically, or it is possible
to derive both this formula and its negation, thinking proof
theoretically.

(The document is, of course, just the liar's paradox in another guise. If
anyone is uncomfortable with the use of an implicit scope for ``this'', the
statement


       { this a n3:falsehood } a log:Truth .


under a reading that log:Truth is contingent truth would have done just as
well.)

]]

http://lists.w3.org/Archives/Public/www-rdf-logic/2002Apr/0095.html

Followup:

http://lists.w3.org/Archives/Public/www-rdf-logic/2002Apr/0106.html

Tarski's "Liar's paradox" led to his stating:

[[
8. THE INCONSISTENCY OF SEMANTICALLY CLOSED LANGUAGES.7

     If we now analyze the assumptions which lead to the antinomy of the
liar, we notice the following:


We have implicitly assumed that the language in which the antinomy is
constructed contains, in addition to its expressions, also the names of
these expressions, as well as semantic terms such as the term "true"
referring to sentences of this language; we have also assumed that all
sentences which determine the adequate usage of this term can be asserted in
the language. A language with these properties will be called "semantically
closed."

We have assumed that in this language the ordinary laws of logic hold.
]]
-- http://www.ditext.com/tarski/tarski.html


And so the problem of such paradoxes may be intrinsic to attempts to "layer"
languages on top of languages which are "semantically closed" such as RDF
sans unasserted triples.

Solution
The provision for triples that are unasserted allows such triples to be
employed by OWL for purely syntactic purposes e.g.

<intersectionOf>
      <List>
         <first>
            <Class rdf:resource= "#student"/>
         </first>
         <rest>
            <List>
              <first>
                <Class rdf:resource="#employee"/>
              </first>
              <rest><nil/></rest>
            </List>
         </rest>
     </List>
</intersectionOf>

can be defined to entail =>

<intersectionOf>
   <List>
        <first>
            <Class rdf:resource="#employee"/>
        </first>
        <rest>
          <List><first>
                  <Class rdf:resource="#student"/>
             </first>
             <rest><nil/></rest>
          </List>
        </rest>
    </List>
</intersectionOf>

i.e. owl:List, owl:first, owl:rest are used for syntactic purposes by OWL,
whose MT defines the equivalence of the expressions regardless of the
"truth" about which is first etc.

Similarly expressions such as:

this owl:include <http://example.org/anOntology.owl> .

are used as syntactic extensions to RDF, and result in committment to the
referenced ontology.

The real requirement for unasserted triples comes down to the real inability
of a language to extend itself:

[[

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.

]]

http://lists.w3.org/Archives/Public/www-webont-wg/2002Apr/0253.html




"Comprehensive entailments" (CE) had been proposed as a "way out of the
dark" i.e. a solution wich does not involve unasserted triples:

http://lists.w3.org/Archives/Public/www-webont-wg/2002Apr/0155.html

  http://lists.w3.org/Archives/Public/www-webont-wg/2002May/0060.html

This proposal appears to have problems with paradoxes:

http://lists.w3.org/Archives/Public/www-webont-wg/2002May/0064.html

From a theoretical perspective Godel's Proof raises concerns as to the
viability of such an approach (e.g. substitute "CE" for "PM"). In any case,
given the raised paradox, such an approach would appear to require a
considerable degree of additional research which is not appropriate to the
charter of the WG.
http://lists.w3.org/Archives/Public/www-webont-wg/2002May/0098.html

It is important that the WebOnt WG proceed with accepted solutions to its
problems to the extent possible, and avoid the tendency to wander into
'research' activities. Jeremy Caroll has noted that the accepted DL
formalism of the "A-box/T-box" uses the "unasserted/asserted" distinction:

[[

The T-Box is the description of the classes and properties used in an
ontology or schema, the A-Box is the description of the objects in the
domain of discourse.

Thus rephrasing the very short summary, embedding these definitions of
the A-Box and T-Box words comes to:

All formally specified Description Logics separate the assertional
descriptions of objects in the domain of discourse from the
terminological descriptions of the classes and properties used within
these assertional descriptions. RDFS does not make this separation. Thus
the WebOnt WG has considered doing Description Logic without this
separation and concluded that it is too difficult. Darkness is a bit
that allows distinguishing: some (non-dark) parts of an RDF graph as
following RDFS semantics, this will correspond to the assertional
descriptions, from some parts of an RDF graph that correspond to the
terminological descriptions, these will not follow the RDFS semantics.
]]

-- http://lists.w3.org/Archives/Public/www-webont-wg/2002May/0212.html

It should be noted that this is one of several ways of developing the OWL
model theory and that to the extent that it prima facie does not provide for
classes as instances (e.g. see
http://lists.w3.org/Archives/Public/www-webont-wg/2002May/0223.html  ) that
the OWL model theory itself can still be develop to assert such classes as
instances.




Implementing "unasserted triples" in RDF.
The RDF MT as it stands is entirely compatible with triples that are not
asserted. A mechanism is needed to label such triples. There are several
options:

1) a syntactic device such as contexts e.g. embedded <rdf:RDF> or
<rdf:context> or <rdf:dark>

By this syntactic device, RDF 'contexts' may be implemented, triples
originating within which may not nessecarily be asserted. This syntactic
mechanism of identifying a collection of triples was proposed:
http://lists.w3.org/Archives/Public/www-rdf-comments/2002JanMar/0036.html

For example:

<owl:Class><owl:intersectionOf ><rdf:RDF><owl:Thing rdf:resource=
"#student"/><owl:Thing rdf:resource=
"#employee"/></rdf:RDF></owl:intersectionOf></owl:Class>

2) an RDFS based device such as
http://lists.w3.org/Archives/Public/www-webont-wg/2002Apr/0290.html

This mechanism would require the least change to RDF, perhaps only provision
for the "rdf:Unasserted" class. For example :

1) Assume owl:List, owl:first, owl:rest, owl:nil are dark -- that is triples
which have these as predicates are unasserted. This can be indicated by the
following (NT):

owl:List rdf:type rdf:Unasserted .
owl:first rdf:type rdf:Unasserted .
owl:rest rdf:type rdf:Unasserted .
owl:nil rdf:type rdf:Unasserted .

-- bind "owl" and "rdf" prefixes to namespace URIs

Now the _conclusion_ would be made from the _premise_ according the OWL
model theory, but of course not by the RDF model theory.

---PREMISE----
<owl:Class>
        <owl:intersectionOf>
                    <owl:List>
                            <owl:first rdf:resource="#student"/>
                            <owl:rest>
                                <owl:List>
                                    <owl:first rdf:resource="#employee"/>
                                    <owl:rest rdf:resource="...#nil"/>
                                </owl:List>
                           </owl:rest>
                    </owl:List>
        </owl:intersectionOf>
</owl:Class>

i.e.

_:C1 rdf:type owl:Class .
_:C1 owl:intersectionOf _:L1 .
_:L1 owl:first <#student> .
_:L1 owl:rest _:L2 .
_:L2 owl:first <#employee> .
_:L2 owl:rest owl:nil .


---PREMISE---

---CONCLUSION---
<owl:Class>
        <owl:intersectionOf>
                    <owl:List>
                            <owl:first rdf:resource="#employee"/>
                            <owl:rest>
                                <owl:List>
                                    <owl:first rdf:resource="#student"/>
                                    <owl:rest rdf:resource="...#nil"/>
                                </owl:List>
                           </owl:rest>
                    </owl:List>
        </owl:intersectionOf>
</owl:Class>

i.e.

_:C2 rdf:type owl:Class .
_:C2 owl:intersectionOf _:L3 .
_:L3 owl:first <#employee> .
_:L3 owl:rest _:L4 .
_:L4 owl:first <#student> .
_:L4 owl:rest owl:nil .

---CONCLUSION---

Now of course, such a conclusion licensed by the OWL MT does not itself
require unasserted triples, this serves as an example entailment to be made
by the OWL MT as an extension of the RDF MT. As such, the set of entailments
licensed by the OWL MT would be a proper superset of those made by the
underlying RDF MT, and hence a proper 'layering' of OWL on RDF is achieved.

The change required to RDF for this mechanism is:

1) provision of the rdf:Unasserted class in the RDF syntax

2) direction that triples having a predicate of type rdf:Unasserted are not
included in the asserted set of triples according to the RDF model theory.


Conclusion

WebOnt needs some unasserted, syntactic triples in order to proceed with
layering the OWL model theory on the RDF model theory. Two mechanisms are
provided:

1) a syntactic mechanism i.e. embedded <rdf:RDF>, the advantage is that this
may provide a general 'context' mechanism for RDF. The disadvantage, from
the WebOnt perspective is that OWL ontologies would be cluttered with
<rdf:RDF> elements, which would likely confuse users.

2) a semantic mechanism which does not provide a general context mechanism
for RDF but has the advantage from the WebOnt perspective of obviating any
required syntactic changes to DAML+OIL/OWL or any other RDF based language,
to indicate the unasserted triples. By this mechanism, the changes needed in
the RDF syntax would be minimal i.e. provision of the rdf:Unasserted class.
Received on Tuesday, 28 May 2002 00:01:07 GMT

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