# Re: Some Approaches to Avoiding Paradox with Asserted Reifications

From: Jos De_Roo <jos.deroo.jd@belgium.agfa.com>
Date: Wed, 11 Sep 2002 12:20:41 +0200
To: Sandro Hawke <sandro@w3.org>

Message-ID: <OF33DCA360.209261E3-ONC1256C31.00373616@agfa.be>
```
Well, my take on that one was/is that e.g.
{ :x a :R } log:implies { { :x a :x } a log:Falsehood } .
{ { :x a :x } a log:Falsehood } log:implies { :x a :R } .
is just 2 asserted statements
:s1 log:implies :s2 .    #statement :s3
:s2 log:implies :s1 .
and neither :s1 nor :s2 are asserted by that.
Not knowing anything about negation, this is
just a vicious circle out of which we couldn't
derive any evidence.
Knowing about negation this is a plain
contradiction :s3 & ~:s3 out of which we shouln't
derive any evidence.

-- ,
Jos De Roo, AGFA http://www.agfa.com/w3c/jdroo/

Sandro Hawke <sandro@w3.org>
Sent by: www-rdf-logic-request@w3.org
2002-09-11 12:09 AM

To:     www-rdf-logic@w3.org, timbl@w3.org, connolly@w3.org
cc:
Subject:        Some Approaches to Avoiding Paradox with Asserted Reifications

In sketching out a vocabulary (ontology) for reifying logical
statements in RDF [1], I've come across a few different approaches for
avoiding the self-reference paradoxes that arise in a naive approach.

To stumble across a Liar Paradox [2] [3] we need only introduce a
class naive:FalseStatement, which includes all the rdf:Statement
objects which are not true.  Then we can say

_:x rdf:subject _:x.
_:x rdf:predicate rdf:type.
_:x rdf:object naive:FalseStatement.

which says that there exists an rdf:Statement which says that it is
false.  The truth value of that statement is now ill-defined.  If we
were to suppose it was true, we'd learn it was false.  If we were to
suppose it was false, we'd learn it was true -- at least following
classical notions of logic.

How can we avoid this situation?

0.  Avoid RDF.   :-)

1.  Instead of naive:FalseStatement, use nonlooping:FalseStatement,
the class of all rdf:Statements which are at once both (1) not true
and (2) non-looping.

To define "non-looping", let's use a stratification approach, where
statements are "first-order" if none of their elements (subject,
predicate, or object) is a statement; they are second-order if they
are first-order or if one or more of their elements is a first-order
statement; ... they are Nth order if each of their elements are of
order N-1 or less.  Nonlooping statements must be of some finite
order.

This is the approach I feel most confident in.   With this approach
the triples

_:x rdf:subject _:x.
_:x rdf:predicate rdf:type.
_:x rdf:object nonlooping:FalseStatement.

are simply false.  A document which asserts those three triples is
false.  They say that such a rdf:Statement exists, but it does not.

I wouldn't expect most RDF software to recognize this fact -- it would
handle documents with these triples like any other documents, unless
it happened to understand nonlooping:FalseStatement.  Then it would
probably do some different processing, but without an RDF processing
model defined, it's hard to say what that might be.

Occasionally there are versions of RDF(S) floated (by the WG) which do
specify a way to have RDF graphs with no models; this graph would be
free to have models at the RDF(S) level, but would not have any models
for an observer who happens to know the meaning of
nonlooping:FalseStatement.

2.  Use safe:FalseStatement, the class of all rdf:Statements which are
both (1) not true, and (2) will not lead to a paradox.

This sounds fine, but I'm not sure how to formalize (2).  I heard there
was some such approach in one version of KIF's wtr predicate, but I
can't find it.   If (1) starts to pan out, then more work on (2) would
probably be worthwhile.

3.  Avoid negation.  Stick to a positive logic, as N3 does.  Fine, but
I'd like more.  This is kind of a non-answer.  (I did some work in
this direction, calling it Positive Triples Logic, before I decided
option (1) was feasible.)

4.  Put negation at a higher level.  Have your base logic be positive
as in (3), but suggest people who want negation define it and the rules
for it.  As with TimBL's N3-based partial DAML-validator [4], the
rules can not make the system inconsistent; instead, they lead to a
triple which is used as an indicator of inconsistency by some agent or
user.

My sense is that this doesn't help.  The rules (like modus tollens)
for doing inference based on negation information will either land us
back in the land of ill-defined truth values (at their level), or will
have to address the problem in some other way (such as requiring
non-looping statements).

5.  Use intuitionist logic [5].  I've heard this one, but I don't
understand it well enough to see how it helps.  I can almost see
constructivism giving the same kind of stratification as I defined in
(1), but I'm a long way from seeing the details.  Anybody care to
explain?

yours, for a more semantic web,
-- sandro

[1] http://www.w3.org/2002/08/LX/RDF/layering