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

Re: defaults

From: Peter F. Patel-Schneider <pfps@research.bell-labs.com>
Date: Tue, 22 Jan 2002 21:20:28 -0500
To: las@olin.edu
Cc: www-webont-wg@w3.org
Message-Id: <20020122212028C.pfps@research.bell-labs.com>
From: "Lynn Andrea Stein" <lynn.stein@olin.edu>
Subject: Re: defaults
Date: Tue, 22 Jan 2002 17:43:22 -0500


> Yup.  As I've said repeatedly, I think that we (the Semantic Web project) are stuck
> with the reality of living in a world with paradox, contradiction, and other logical
> difficulties.  

Well contradiction and other logical difficulties (like complexity) are
unavoidable (except if you can't even express contradiction, like in RDF
(at least mostly)).  On the other hand, a paradox (speaking logic-ese) is a
breakdown in the logical formalism itself, and, because of the way that
standard logical formalisms are constructed, causes a breakdown of the
entire formalism.  Thus true paradoxes are not a problem with the messy
world but are instead a problem with the formalisms that we create (or


> > I don't see the separation as causing any (extra) problems.   On the
> > contrary, I think that the separation can be a powerful tool in solving
> > problems that come up in web contexts.  For example, a non-referring
> > pointer can be handled at the ontology level without having to having to
> > worry about such possibilities at the object level.
> I guess I'm less sanguine than you that we can solve the job at hand using the tools
> that you propose.  But I eagerly await your demonstrations (while simultaneously
> trying to design alternatives that involve document manipulation at the base level).

I'm not really arguing that these problems can even be handled at a
separate level.  I'm just arguing that they are *harder* to handle at the
object level.  

> > > > Such constructs (e.g., daml:imports) can indeed have impact on the
> > > > behaviour of OWL implementations, of course, but this is generally in terms
> > > > of determining what pieces of syntax are fed into an OWL reasoner, and
> > > > definitely not in terms of affecting the OWL reasoner in any other way.
> > >
> > > What happens when the assertion that the OWL reasoner used to draw its conclusion
> > > is retracted by the previously asserting page?
> >
> > Well that depends on what you want to have happen.  One (easy) way would be
> > to have a very simple document level, i.e., only daml:imports.  The
> > ontology level could condition all object-level conclusions on the
> > documents remaining the same.
> What do you do when it changes?  Presumably you are suggesting that you withdraw your
> conclusions (i.e., "unfeed them" to the OWL reasoner?).  This of course makes your
> conclusions nonmonotonic without even introducing a default mechanism.  (Or, if you
> prefer, you can make them conditional with a need to continuously recheck the
> condition.  But since you can never know what'll be true by the time you finish your
> inferencing, it's hard to know how you could live with such a condition.)

Perhaps, but there is nothing theoretically wrong in making all your
conclusions conditional.  You can even design tools that optimise this

However, consider what happens if you do make documents part of your object
level.  You can have statements about documents in conditional contexts and in
negated contexts.  As documents do change, you almost certainly have to
have some temporal constructs inside your logic to model this behaviour.
And, you have to have these statements about documents affect the reasoning
you do with them, or you haven't really captured what you should.

> That these sorts of things are a part of the new world we're in is precisely my point.

And my point is that having documents as first-class objects is taking all
this mess and requiring that the logic handle it correctly.  Placing the
mess in a different level admits many more (partial) solutions, I believe.

> > How would you handle it in a formalism that has ontologies as objects?  I
> > think that the problems there are much harder.
> I don't think that they're considerably harder, but that's because I think that the
> without-ontologies problem is pretty darn hard, not because I think that the
> with-ontologies problem is easy.

Well I certainly disagree with you here.  

> > > > It may turn out that there is a way of making some version of defaults fit
> > > > into this part of OWL.  I expect that any such version of defaults will be
> > > > a very weak (or very strong) version of something like input completion.
> > >
> > > It may well turn out that this is so.  But that part will have these issues
> > > (nonmonotonicity, literal incorporation of syntax, etc.) whether we fit defaults
> > > in there or not.  It is also where the asserter lurks....OWL statements aren't
> > > true or false, they're asserted (by an agent or by the resolvent of a url or by a
> > > document) or not.
> >
> > Yes, and treating this ``asserting'' level as separate from the object
> > level makes a lot of sense to me.
> Hmm....This means that (Peter's) OWL is precisely what I said at the beginning,
> rarified, and exists in a world of absolute truth and absolute falsity, rather than a
> world of assertions by parties.  I think that this pretty directly contradicts TimBL's
> vision, FWIW, and I am inclined to agree rather strongly with TimBL on this one.

Well, if you are going to bring out the big guns, I may as well admit
defeat now.  Not!!  

To reflect one of your arguments back at you, I await (eagerly) your
solution to the integration of ontologies and documents as first-class
objects into a web ontology logic that also handles assertings and
self-reference.  In the meantime, I think I'll work on a version of
DAML+OIL that is divided into a standard logic level and a
document/ontology level. 

> Lynn

Received on Tuesday, 22 January 2002 21:21:15 GMT

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