W3C home > Mailing lists > Public > www-rdf-interest@w3.org > September 2004

Re: OWL and real world

From: Tanel Tammet <tammet@staff.ttu.ee>
Date: Fri, 24 Sep 2004 18:37:42 +0300
Message-ID: <41543F46.3080908@staff.ttu.ee>
To: david.celjuska@bt.com
Cc: www-rdf-interest@w3.org, Adrian Walker <adrianw@snet.net>
david.celjuska@bt.com wrote:

>>>So my qestion at the bottom is how we could handly this
>>>kind of exceptions? Because we know that life is full of
>>>exceptions. Some birds don't fly, same mammals lay eggs
>>>(Platypus is only one of them and to have a special class just
>>>for this pour guy...), and who knows and one can never be sure.
>>People have researched these kinds of things for decades.
>>Read some intro about "nonmonotonic logic", and then
>>continue with "default logic", which is a fairly clean
>>subfield of the former. 
>This might sound like weird question but Am I right
>then if I say  that exceptions as I mentioned them are out
>of the scope of FOL and thus can not be modelated in formal
It is not that simple. In one sense, nothing is out of the scope
of FOL: you can encode anything. A trivial "proof": FOL contains
Turing-complete programming languages as small subsets of
FOL, hence you can program anything in FOL.

However, in a _practical sense_ the exceptions are outside the
scope of FOL. Consider some FOL options:

- you can always enumerate all the known exceptions, and
explicitly add them to the rules. Like this:

bird(x) & not ostrich(x) & not penguin(x) & ... & => flies(x)

which quickly becomes both unmaintanable and extremely
hard to solve.

- you can start encoding default operations, modalities, probabilistic
reasoning, etc in FOL: doing this, you really use those extended
logics, and use FOL as a programming language underneath, which
is also not the way you normally expect to use FOL. All your
facts and rules become pretty complex structures in the FOL
sense, and any derivations become extremely hard.

The simplest pragmatical choice - what people have adopted
in SQL, DATALOG and PROLOG - is the famous "closed world
assumption" (CWA), meaning that anything which cannot be proved is
automatically negated. If you cannot derive flies(John), you assume
not flies(John). This is, however, not satisfactory for the general
case, and (from the practical standpoint) requires that the queries are
 solvable: you have to use a very restricted logic or encode all your
knowledge in a solvable way (by programming, essentially).
CWA is one specific case of nonmonotonic reasoning.

Adrian, you wrote:
Actually, there's are a rather straightforward, pragmatic solution to these
kinds of questions.

The basic idea is, don't try to hard code everything you need about the 
world in a fixed system of logic. (Most OWL folks seem to assume you 
have to do

Instead, tie some lightweight natural language processing to logical 
rules, so
that people can see what the predicates are supposed to mean in the real 

Underneath the logical rules, have an inference method that supports a 
declarative assignment of meaning, and allows nonmonotonic 


In a way I agree to this: there are pragmatical solutions for specific
domains.  The SQL approach, for example, is an even simpler example
of a pragmatical solution. I do also believe that it is a good idea to
use a special negation-as failure operator, and this covers
quite a lot of practical cases.

However,  these kinds of solutions are never universal nor
domain-independent. The solutions become also more and more
complex as they target wider and wider applicability. The
same, seemingly straightforward negation-as-failure brings a huge
amount of complexity into play.
             Tanel Tammet
Received on Friday, 24 September 2004 15:37:31 UTC

This archive was generated by hypermail 2.4.0 : Friday, 17 January 2020 22:44:52 UTC