I've been traveling for the past few days and didn't have a chance to
comment on this thread. I mostly agree with Ali, but I'd like to make
some comments, clarifications, and qualifications. (01)
AH
> What I meant to contrast is that in many ways Cyc is an example
> of a paradigm which represents the domain in an expressive language
> and then finds the appropriate subsets that match decidable logics
> for reasoning. At least, that's my understanding. It uses a variety
> of reasoners. (02)
I agree. But I would add that decidability is a property of the
*problem* to be solved, not a property of the *language* in which
it is expressed. (03)
The most important example is relational databases. The WHERE-clause
in SQL has the full expressive power of FOL. But it is used to state
problems that are not only decidable, they are tractable when used
with an RDB: (04)
1. To state a query that is evaluated in terms of the RDB. For such
purposes, the time to evaluate the query takes at most polynomial
time, where the exponent N is the number of quantifiers in the
expression. And if the column over which the quantifier ranges
is indexed, that quantifier can often be evaluated in log time. (05)
2. To state constraints on DB updates. These constraints can also
be evaluated in polynomial time. In effect, each constraint C
can be considered a query that asks whether C would be false in
the DB after the proposed update. (06)
3. To state triggers on DB updates. In effect, each trigger is
a rule, whose antecedent states a query to be evaluated after
any update that might make the antecedent of the rule true.
The consequent is either a procedure that performs some action
external to the DB (such as generating a message to be sent)
or another update to the DB (e.g., a forward-chaining Horn
clause step). (07)
Another point I state very frequently: the world economy runs on RDBs,
and that makes FOL the most widely used version of logic on the planet. (08)
My main complaint about SQL is that it has a notation that I used to
call the world's worst syntax for FOL -- but that was before I saw OWL. (09)
In any case, SQL notation has become very widely known, and vendors who
sell object-oriented DBs provide SQL as an option. And programmers use
SQL notation in *preference* to the path-based notations. (010)
AH
> But you're right, there are two parallel issues here. One is the actual
> reasoning involved, and the other re syntactic limitations imposed by a
> particular representation language. As John Sowa likes to point out,
> it is perfectly possible to write programs that never halt in any
> interesting programming language. However, people don't syntactically
> restrict programming languages in order to ensure the worst case cannot
> possibly be encountered. In this vein, the same applies to FOL. Except
> of course, ontology engineering is still in relative infancy compared to
> traditional programming, and it's easy to write "infinite loops." (011)
I mostly agree with this statement, especially the part that quotes
something I've been repeating for a long time. (012)
But I would take issue with the part that says ontology engineering
is in its infancy. Aristotle's subset of DL has been around for over
two millennia, and it is still the most widely used subset of OWL.
Furthermore, Cyc has been doing "ontology engineering" for 27 years,
with a total of over one millennium of person years of experience. (013)
In fact, if you look at published ontologies written in OWL, very few
use features that could not be expressed in A's syllogisms. Just
download them and look. Start with BFO. (014)
But if you want to do any serious computation, you very quickly
go beyond the "decidable" subset. LOOM and PowerLOOM were widely
used description logics, but the DL "thought police" declared their
designer, Bob MacGregor, to be persona non grata because he dared
to state the obvious: "Every user wants more expressive power,
and no users have ever asked for decidability." (015)
The ideal way to use DLs is the original T-Box and A-Box split:
use a very simple logic for the T-Box (A's syllogisms are fine,
but some Boolean expressions are a useful addition) and use
a more expressive logic for the A-box (FOL or some Horn-clause
logic would be good). (016)
But any kind of complexity is better stated in axioms for
the A-box than in a horrendously complex T-box. That's what
many very usable systems do. SWRL did that, but the DL
"thought police" banished it from the SemWeb stack because
it was (horror of horrors!) undecidable and usable. (017)
There's more to say, but I'll just point to an article I wrote
a few years ago: (018)
http://www.jfsowa.com/pubs/fflogic.pdf
Fads and Fallacies about Logic (019)
Final point: CycL is extremely expressive (it requires the IKL
extension to CL), but Doug Lenat said that they have *never* found
undecidability to be a problem for any practical application.
That doesn't mean that students don't need to study computational
complexity -- it just means that programmers know how to handle it. (020)
John (021)
_________________________________________________________________
Message Archives: http://ontolog.cim3.net/forum/ontolog-forum/
Config Subscr: http://ontolog.cim3.net/mailman/listinfo/ontolog-forum/
Unsubscribe: mailto:ontolog-forum-leave@xxxxxxxxxxxxxxxx
Shared Files: http://ontolog.cim3.net/file/
Community Wiki: http://ontolog.cim3.net/wiki/
To join: http://ontolog.cim3.net/cgi-bin/wiki.pl?WikiHomePage#nid1J (022)
|