W3C home > Mailing lists > Public > public-owl-wg@w3.org > April 2008

RE: ISSUE-119: What can be done against the Russell paradox?

From: Michael Schneider <schneid@fzi.de>
Date: Sun, 27 Apr 2008 13:41:19 +0200
Message-ID: <0EF30CAA69519C4CB91D01481AEA06A08BDDE5@judith.fzi.de>
To: "Peter F. Patel-Schneider" <pfps@research.bell-labs.com>
Cc: <public-owl-wg@w3.org>
Hi, Peter!

Peter F. Patel-Schneider wrote:

>From: "Michael Schneider" <schneid@fzi.de>
>Subject: RE: ISSUE-119: What can be done against the Russell paradox?
>Date: Sat, 26 Apr 2008 01:12:27 +0200
>> Hi, Peter!
>> Peter F. Patel-Schneider wrote:
>> >From: "Michael Schneider" <schneid@fzi.de>
>> >Subject: ISSUE-119: What can be done against the Russell paradox?
>> >Date: Sat, 26 Apr 2008 00:07:50 +0200
>> >
>> >> Dear Peter!
>> >>
>> >> Regrettably, I wasn't able to attend the last telco, so I haven't
>> >able to
>> >> discuss the Russell problem there.
>> >>
>> >> The minutes cite you:
>> >>
>> >>   Peter Patel-Schneider: one can do a patch to keep things the
>> >>   Peter Patel-Schneider: that might be adequate
>> >>
>> >> Do you mean by this that you know about some method to restrict the
>> >semantics
>> >> of the self restrictions in a way that we still have all OWL 2 DL
>> >entailments
>> >> in OWL 2 Full?
>> >
>> >I thought that we already discussed this.  The trick is to fiddle
>> >the comprehension principle for self restrictions to not apply on
>> >rdf:type.
>> Before I answer the rest of you mail, I will first want to make sure
>that I
>> correctly understand you in this point.
>> Do you mean the following or a variant of it:
>>     "Guarded" Comprehension Principle:
>>     ----------------------------------
>>     IF
>>         p rdf:type owl:ObjectProperty .
>> -->     p owl:differentFrom rdf:type .
>>     THEN
>>         _:x rdf:type owl:SelfRestriction .
>>         _:x owl:onProperty p .
>> where "_:x" is an existential variable?
>Well that is not a comprehension principle, you need something like
>     IF  p belongs to the class extension of owl:ObjectProperty
>         and p is not equal to the denotation of rdf:type
>     THEN there must be a domain element x such that
>          x belongs to the class extension of owl:SelfRestriction
>	  and x and the denotation of p is in the property extension of

Ok, but this doesn't help: With such a comprehension principle, there will be 
OWL 2 DL entailments, which are /not/ OWL 2 Full entailments (e.g. the one I 

>> But if you have the following two graphs G_L and G_R:
>>     G_L := {
>>         :alice rdf:type owl:Thing .
>>         :loves rdf:type owl:ObjectProperty .
>>         :alice :loves :alice .
>>     }
>>     G_R := {
>>         :alice rdf:type _:s .
>>         _:s rdf:type owl:SelfRestriction .
>>         _:s owl:onProperty :loves .
>>     }
>> AFAICT, G_L entails G_R in OWL 2 DL, right?
>> But with the guarded comprehension principle above, this won't be an
>> entailment in OWL 2 Full anymore.
>Yes, as you state below you also need a premise of something like
>	:loves owl:differentFrom rdf:type

Yes. But my example graphs G_L and G_R, which do not contain such 
'differentFrom' triples, would still be syntactically valid input to OWL 2 
Full. So we would still have an example of an OWL 2 DL entailment, which is 
/not/ an OWL 2 Full entailment.

>> The reason is that the guarded comprehension principle now only
>"fires" on
>> property :loves, if :loves can be entailed to be owl:differentFrom
>> But without giving more information in graph G_L, there will exist a
>> satisfying interpretation for G_L in which the URI ':loves' happens to
>> denote the same individual as the URI 'rdf:type' (making :alice
>> into a class, but this doesn't matter in OWL Full). So, a self
>> class on property :loves does not exist, at least not deduced from the
>> guarded comprehension principle.
>> The guard in the guarded comprehension principle does not only protect
>> against the "real" rdf:type, but also against most other properties
>> an ontology. This approach is too strong for maintaining Theorem 2.
>Well you also have to fiddle a bit more.
>You could fiddle with Theorem 2, for example by adding something like
>	... O augmented with suitable distinctness conditions, i.e., all
>	properties in O are distinct from rdf:type entails ...

But changing Theorem 2 will /not/ bring back those missing entailments which I 
am talking about.

What a change of Theorem 2 does, however, is changing the approach how the 
semantic relationship between OWL DL and OWL Full is measured. In the case 
that we change Theorem 2 in a way that it "hides away" certain OWL-DL 
entailments which are OWL-Full non-entailments, the new Theorem 2 will not be 
a measurement anymore which compares the two languages based on all their 
produced entailments.

But if we allow us in general to change Theorem 2 in such a way, then there 
might exist other options to do this.

>You could also fiddle with the semantic conditions, adding something
>like the denotation of all names that are not rdf:type are different
>from the denotaiton of rdf:type.

This would be a kind of Unique Name Assumption on the name "rdf:type" solely. 
I do not know how to do this in an RDF-based language.

Also note: All these suggestions above would not help against properties, 
which are only /equivalent/ to rdf:type. For example, the following RDF graph

  :clonedType owl:equivalentProperty rdf:type .
  :clonedType owl:differentFrom rdf:type .

would /not/ be satisfiable in OWL 2 Full, even if the guarded version of the 
comprehension principle for self restrictions is used. The reason is that the 
guard will happily let the :clonedType pass -- with fatal consequences.

>But, again, what did you expect in OWL Full?   OWL 1 Full was dancing
>right up against the cliff.   Adding useful expressive power to OWL
>requires delicate work so that OWL Full doesn't fall into the abyss.
>As an alternative, I suppose that the WG could just go the N3 way with
>OWL Full.

I am not yet convinced that an RDFS-based language needs to be close to the 
abyss when it tries to compete with OWL DL w.r.t. semantic expressivity. Maybe 
the problem has rather to do with the way how the semantic expressivity is 
compared for these two languages.

What I would like to know is the following: What was the motivation to compare 
OWL DL (a description logic) with OWL Full (an RDFS-based logic) on the basis 
of common entailments? I.e. why is there a criterion (Theorem 2) of the style: 
"If the RDF graph O1 DL-entails the RDF graph O2, then O1 is also required to 
Full-entail O2."? I would expect that such a criterion only makes sense, if 
the semantic meaning of the syntactic expression O1 is the same both under OWL 
DL and OWL Full semantics, and ditto for O2.

Btw: What do you mean by "the N3 way"?


Received on Sunday, 27 April 2008 11:42:05 UTC

This archive was generated by hypermail 2.3.1 : Tuesday, 6 January 2015 21:42:04 UTC