SUO: Re: Sowa's piece and thoughts on tractability
Erik,
I believe that we agree on this point:
EL> I want to clarify that I didn't intend to make general remarks about
> the suitability of FOL or HOL for the purposes of AI, but to suggest
> that the choice of a language ought to be governed by the specific
> goals of the group.
But then the question arises about how many languages should there
be for every purpose that might arise. I agree that it is desirable
to use different subsets of logic for different purposes with different
inference engines. But there is no need to invent a new syntax for
every such purpose. A rich language such as KIF or CGs can be subsetted
for Horn-clause rules or for definitions of the kind that are used in
description logics (DLs).
I have nothing against people who want to invent different syntaxes,
and I have been arguing very strongly for using controlled natural
languages for expressing definitions and rules in defining ontologies.
Those subsets do require some training for the people who write them,
but anyone who can read the corresponding natural language can also
read the axioms and definitions in the controlled version.
EL> One of the challenges we face is that there is a lack of shared
> assumptions among software developers and researchers in AI. Software
> developers don't (typically) share the theoretical background
> necessary for discussing and creating ontologies for use in
> computational systems, and AI folks historically have shown a lack of
> enthusiasm for "bottom up" approaches that scale existing
> architectures or that make more modest assumptions about the language
> and notation required to express computer-readable knowledge.
Computers are capable of reading very rich notations without any
difficulty. Controlled NLs, for example, are probably the best
notations for domain experts to read. Learning to live within the
restrictions that must be observed for writing a controlled NL can
taught by programs that enforce the restrictions by menus, prompting,
and syntactic checks.
EL> One of the reasons for the difference is the professed difference in
> goals-- creating better or 'next-generation' software by making use of
> ontologies is different than creating a computer program that exhibits
> human-like intelligence. For the latter, FOL may in fact be necessary
> (as many AI researchers, or at least those in the 'logicist' camp,
> have often contended). For the former, it's! not obvious at all.
FOL is necessary for asking very mundane questions that are expressed
in SQL and for stating the constraints on valid updates to a database.
My recommendation is to use a controlled NL as the language interface
between computers and humans, and to let the computer do the necessary
syntax checks to ensure that the humans use the correct subset.
EL> I'm willing to grant this as a general methodological principle in
> knowledge-based development, but note that it is not, by itself, an
> argument for using FOL. Such an argument requires a premise that the
> sorts of facts included in an ontology and the application problems
> that rely on that ontology for their solution require treatment in FOL
> (and possibly HOL). In other words, I might accept your principle but
> apply it not in order to embrace FOL but as a way of choosing, say,
> between a simplified KIF and a more-simplified KIF.
You don't have to look at any kind of exotic application to see the
need for FOL. Just look at ordinary relational databases, which allow
any combination of boolean operators and quantifiers in queries and
constraints.
What I would recommend is an expressive language, such as KIF or CGs
for professional software developers and controlled NLs for domain
experts and other users. And for different applications or for
different purposes, those expressive languages might be restricted
further to accommodate the inference engines.
But those restrictions can be done by the software itself. For example,
someone who is analyzing knowledge about a particular domain might
make some statements in a restricted subset (such as a DL) and other
statements that use full FOL (which might be needed for a database
constraint). A syntax checker could easily detect the difference
between those statements and send one to the DL definitions and the
other to the DB constraints.
Such an approach would allow the domain expert to concentrate on
stating all the appropriate knowledge about the subject matter without
having to worry about the limitations of different inference engines.
John Sowa