Layering OWL on RDF using unasserted triples

The Web Ontology WG

Current version

This version: May 27, 2002

Editor: Jonathan Borden jonathan@openhealth.org

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)

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

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

-- Peter Patel-Schneider http://lists.w3.org/Archives/Public/www-webont-wg/2002Apr/0240.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
>

-- Peter Patel-Schneider quoted in http://lists.w3.org/Archives/Public/www-webont-wg/2002May/0057.html

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.

]]

-- Pat Hayes 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.

[[

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

]]

-- Peter Patel-Schneider 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.
]]
-- A. Tarski 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.

]]

-- Pat Hayes 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:

-- Jeremy Carroll 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:

-- Peter Patel-Schneider 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. As Jeremy Carroll notes 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.

]]

-- Jeremy Carroll 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   Guus Schreiber 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 by Jonathan Borden 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 proposed by Pat Hayes 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 (note: that these are but two mechanisms discussed by the WebOnt WG which acknowledges the possibility that other appropriate solutions may exist):

  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.