evaluation of logic as a representation for ontologies

Tom Gruber <Gruber@Sumex-AIM.Stanford.edu>
Message-id: <2923846845-12485232@KSL-Mac-69>
Date: Wed, 26 Aug 92  12:40:45 PDT
From: Tom Gruber <Gruber@Sumex-AIM.Stanford.edu>
To: Shared KB working group <srkb@ISI.EDU>
Subject: evaluation of logic as a representation for ontologies
In-reply-to: Msg of Mon, 24 Aug 92 18:28:06 edt from davis@ai.mit.edu (Randall Davis) 
Randy Davis reminds us to look where we think the key is, rather than
where the light is good:

--- Excerpt from Randy Davis (Mon, 24 Aug 92 18:28:06 edt) ---

> I think it's crucial in this undertaking to describe the world as it is,
> which includes bibliographies-as-they-are-with-the-
> details-that-drive-librarians-(and-sometimes-the-rest-of-us)-to-distraction.

> It's absolutely crucial: otherwise this is an exercise in the definitions we
> can write, not a exercise in finding out what we need to say; an exercise in
> what our current KR languages permit or make easy, not an exercise in finding
> out what we need to say.  Knowledge representation needs to be about the
> world, and the world as it is, not as we wish it would be.

I see two points to be teased out of his admonition.
First, one should not sacrifice the validity or accuracy of the
knowledge represented, just because it better suits our tools.
Second, representation is a means to an end, and we should should use
whatever is appropriate (and evaluate our methods) with an eye on the
goal (i.e. of knowledge sharing and reuse). 

On the first point, Lewis Johnson and Bob Neches pointed out that
modeling is inherently incomplete and oversimpifying, and that one
should seek an appropriate model for the given task.

--- Excerpt from Lewis Johnson (Tue, 25 Aug 92 09:10:29 PDT) ---

> I think it's worth emphasizing that ALL models ignore some
> real-world complexity.  That's what modeling is all about. 
> It's not a shortcoming of existing models but an essential
> characteristic of them.

> Different models are appropriate for different tasks.  A
> model that captures complexity relevant to all tasks will
> probably be appropriate for no task.

--- Excerpt from Robert Neches (Mon, 24 Aug 92 20:47:41 PDT) ---

> It's critical to strike a balance between ignoring complexity and
> getting swamped in it.  My personal view it that the way to do so is to
> focus on ontologizing that facilitates merging software into larger
> units.

Hopefully, we can guide our choices about what to represent and at
what levels of fidelity according to the anticipated needs for
particular domains/tasks.  That's the rationale for breaking into
special interest groups, looking for smallish ontologies in "niches"
where people have a need to share KBs, modules, and services.  It
distinguishes this effort from the (original) Cyc vision of building a
comprehensive knowledge base that is not biased toward any particular
tasks or domains.

This pragmatic strategy leaves unanswered a basic research question:
how can you determine which commitments to make in a common ontology
(or shared knowledge base) without limiting the applicability of the
thing to a single, narrow task or a specific problem-solving method?
In other words, how can one parameterize a knowledge base specify a
knowledge-level communication protocol to anticipate a range of
inferential and informational needs?

I don't know.  That's what we're trying to find out (empirically).

What about the second interpretation of Randy's warning?  Maybe the
whole idea of using a declarative logic to represent ontologies is
inappropriate to the goal of knowledge sharing.  I don't have a answer
here, either, but let's look at the issue in the context of the biblio
example.  Consider three properties of logic as a representation for
defining terms:

  1. Logical definitions are inadequate for open textured predicates.
  2. Logical definitions are constraints on meaning.
  3. Logical definition are unambiguous.

  1. Logical definitions are inadequate for open textured predicates.

--- Excerpt from Randy Davis (Mon, 24 Aug 92 18:28:06 edt) ---

>    (define-class UNIVERSITY (?x)
>      "A university is an institute of higher learning that offers a
>    graduate research program.  Of importance here is the fact that
>    universities sponsor the publication of dissertations."

> Dartmouth College (and a famous Supreme Court case from the mid
> 1800's) agree that the institution is a college, not a University, yet it
> has a grad research program, pubishes dissertations, etc.

This is a good example, because the textual definition I offered was
based on dictionary definitions:

    1: an institution of higher learning providing facilities for teaching
    and research and authorized to grant academic degrees; specif: one
    made up of an undergraduate division which confers bachelor's degrees
    and a graduate division which comprises a graduate school and professional
    schools each of which may confer master's degrees and doctorates

    I. 1. a. The whole body of teachers and scholars engaged, at a particular
   place, in giving and receiving instruction in the higher branches of learning;
   such persons associated together as a society or corporate body, with definite
   organization and acknowledged powers and privileges (esp. that of conferring
   degrees), and forming an institution for the promotion of education in the
   higher or more important branches of learning; also, the colleges, buildings,
   etc., belonging to such a body.  In recent use, const. without article: at (or
   to) university, etc. Sometimes, especially in former use, synonymous with
   college: see college sb. 4 c.

Yet, as Randy points out, case law has made exceptions and blurred the
defining criteria mentioned.  This suggests that logic is not adequate
for representing such "open textured" predicates.  Does this mean that
logic is inappropriate for definitions in ontologies?  Perhaps.

However, the bibliography ontology was not designed to be used to make
decisions about whether something is a university (e.g., for legal
reasoning); rather, the ontology is supposed to help integrate tools
and databases that manipulate bibliographic data.  The definition of
university is incomplete.  But recall that definitions are USUALLY
incomplete: that is, rarely do we know necessary and sufficient
conditions for membership in a class or satisfaction of a relation.
Thus, "university" is a typical case of a PRIMITIVE DEFINITION.  This
is not a property of the formalism, but of our domain knowledge, or
our willingness to agree to oversimplifying rules for the purpose of
sharing knowledge among a limited set of agents.

  2. Logical definitions are constraints on meaning.

The axioms tell us what must hold for an interpretation to make sense.
But they don't tell us which interpretation to adopt.  As we add
clauses to definitions we reduce the possible interpretations.  We
specify ontoligical commitments by writing constraints: e.g., that
agents must have unique names.  We rarely can say exactly what
something is, except for formal entities (e.g., month-name).

In the biblio ontology, we found that it would be much easier to let
every field of a reference take almost any value, bounded only by
syntactic restrictions such as string or number.  This is essentially
what one finds on data models, the ontologies du jour in the
commercial world.  By adding axioms (the :def and :axiom-def
statements in definitions) we "semantically" constrain the values of
fields.  The effect is to reduce the possible interpretations, 
by excluding inconsistent usage of terms, rather than to suggest the
meaning of terms (e.g., with examples, analogies).

This property of the representation (which follows from the
model-theoretic semantics) makes it easy to say "X must be a Y" but
hard to say something like "X can be A, B, or C, but it needn't be any
of them." For example, we know something about what the address
field of a reference should be.  We know it should be a name of some
place, plus we know that the place is somehow associated with the
publication event of the document.  However, the definition of the
address field can't describe that knowledge formally:

   (define-relation REF.ADDRESS (?ref ?address)
     "The place (e.g., city) where a document is published.  Means
   different things depending on the reference type."
     :def (and (reference ?ref)
               (city-address ?address)))
   (define-class CITY-ADDRESS (?name)
     "A city-address is a string that identifies a city
   somewhere in the world.  We distinguish it from other
   names to facilitate integrating it with ontologies that
   include representations for locations and alternative ways
   of identifying places."
     :def (biblio-name ?name))

The axioms constraining the meaning of ref.address are distributed in
specializations of the general class of references.  For example, for
many documents the ref.address is the address of the publisher:

   (define-relation INHERITS-PUBLISHER-FROM-DOCUMENT (?ref)
   ...          (have-same-values ?ref ref.address
                               (compose* publisher.address
                                         doc.publisher ref.document))

whereas for a proceedings the address is the location of the conference:

   (define-class PROCEEDINGS-PAPER-REFERENCE (?ref)
     ...             (have-same-values ?ref ref.address
                              (compose* conf.address
                                        doc.conference ref.document)))

Again, we find that the axioms only chip away on possible
interpretations -- they never quite capture the intended meaning.

3.  Logical definitions are unambiguous.  

The discipline of logic can make it difficult to say what you want to
say at times, but it might be that the enforced clarity will help with
the goal of specifying ontological commitments.  Let's look at a few
examples to see in what ways this property is a bug or a feature.

For example, the question

> (Or are document authors allow to be any agent?  Not clear from a
> quick scan of the defns.)

can be answered by inspection.  The original definition of document
authors was:

   (define-relation DOC.AUTHOR (?doc ?agent) ?name
     "The creator(s) of a document.  Not necessarily the author of a
   work published in the document, but often so.  The author is a real
   agent, not a name of an agent."
     :def (and (document ?doc)
               (agent ?agent)))

The "?name" on the first line is a typo [a fragment left over from a
previous version] that should have been caught by the parser, and can
be ignored.  That aside, it should have been clear, from doc string
and axiom, that the range of the doc.author relation is agents.

The definition in the new ontology refines that restriction, pushing
the question of whether document authors are agents or just people
into the definition of authors:

   (define-relation DOC.AUTHOR (?doc ?author)
     "The creator(s) of a document.  Not necessarily the author of a
   work published in the document, but often so.  The author is a real
   agent, not a name of an agent."
     :def (and (document ?doc)
               (author ?author)))

   (define-class AUTHOR (?x)
     "An author is an agent who writes things.  An author must have a
   name, which is its real name as an agent.  The name as author
   may or may not be the agent's name, but usually is."
     :def (and (agent ?x)
               (has-one ?x agent.name))
     :default-constraints (have-same-values ?x author.name agent.name)
     :issues ((:see-also AUTHOR.NAME)))

To answer Randy's query now requires a single step inference: that the
range of doc.author is author and author is a subclass of agent.

> Stephen King and Samuel Clemens are both going to be problematic.

In other words, what about pseudonyms?  Well, in the original
ontology, I was FORCED, by the formalism, to make a decision on this
question.  I chose to "ignore the complexity of the world" and assume
that author names are people's real names, used as identifiers.  That
assumption is embodied in the following three definitions.  The first
says that author names that appear in references are the names of
agents.  The second says that an agent name is the value of the
agent.name relation for some agent.  The third definition says that
agent.name is a function: there is at most one name per agent.  Thus,
pseudonyms are not allowed.

   (define-relation REF.AUTHOR (?ref ?author-name)
     "Relation between a reference and the name(s) of the
   creator(s) of the publication."
     :def (and (reference ?ref)
               (agent-name ?author-name)))

   (define-class AGENT-NAME (?name)
     "A string that is the name of some agent."
     :axiom-def (exact-range AGENT.NAME AGENT-NAME))

   (define-function AGENT.NAME (?agent) :-> ?name
     "Function from an agent to the name by which it goes.
   One name per agent."
     :def (and (agent ?agent)
               (biblio-name ?name)))

Conclusion: the unabiguity of logic forces a decision on details like
this, but it may require nontrivial deductive inference to answer a
query about a specification in this form.  In other words, a
commitment specified in logic may be both unabiguous and implicit!
The answer to a question about the ontology may not be obvious on
inspection (i.e., it requires inference rather than lookup), but once
you get an answer you can be sure of it (because it can be proven).

But does the unambiguity of logic PREVENT one from allowing
pseudonyms?  No.  In the second version of the biblio ontology, they
are explicitly recognized.  Note that author.name is a relation, not a
function.  The commitment that documents are authored by agents (not
names) has been preserved, but the relationship between authors and
their names have been made more complicated.

   (define-class AUTHOR (?x)
     "An author is an agent who writes things.  An author must have a
   name, which is its real name as an agent.  The name as author
   may or may not be the agent's name, but usually is."
     :def (and (agent ?x)
               (has-one ?x agent.name))
     :default-constraints (have-same-values ?x author.name agent.name)
     :issues ((:see-also AUTHOR.NAME)))
   (define-relation AUTHOR.NAME  (?author ?name)
     "An author name is the name of an agent used to identify
   it as an author.  It is not necessarily unique; authors may
   go by pseudonyms."
     :def (and (author ?author)
               (biblio-name ?name)
               (or (agent.name ?author ?name)
                   (penname ?author ?name))))
   (define-relation PENNAME (?author ?name)
     "An author's pseudonym [Webster].  An author may use several
   pseudonyms.  Which name is a function of the document."
     :def (author.name ?author ?name)
     :issues ((:see-also DOC.AUTHOR-NAME)))

> And committees? How about committees with pseudonyms (eg, the
> Bourbaki, who wrote a well known set of elementary mathematics
> texts)?

The mind of a good lawyer is a terrible thing to waste on law :-).  

These questions are interesting to me because the question themselves
are ambiguous.  How about committees for what?  Using logic as a
representation is going to force the query into something like this:

   Can there be an author of a document that is a collection of
   persons, whose name is not any of the persons?

Again, we can look up the definition of doc.author (or ref.author)
to see.  By either definition of doc.author given above, we know that
the author is an agent.  The question is, can a committee be an agent?
The definition is agent is

   (define-class AGENT (?x)
     "An agent is something or someone that can act on its
   own and produce changes in the world.  There is more to
   agenthood than that, but for this ontology that is all
   that matters."
     :def (and (biblio-thing ?x)
               (has-one ?x agent.name))
     :axiom-def (subclass-partition
                  (setof person
     :issues ("could be merged with more meaningful definitions
               of agenthood in larger ontologies."))
The subclass-partition statement says that an agent might be a person
or organization, and that it can't be both.  We could argue that a
committee is neither a person nor an organization.  But since the 
partition isn't exhaustive, it allows for other kinds of agents that
don't fit the definition of either subclass.  So there is no reason
why committees can't be authors, as long as we admit them as agents.


In summary, I've laid out some of the properties of logic as a
representation for the task of writing definitions in ontologies.  It
is perfectly acceptable to propose alternative representations (e.g.,
some have argued for using only unstructured English).  However, I
would encourage a similar analysis when comparing alternatives: what
properties does a representation offer that help or hinder the task of
sharing and reusing knowledge bases, knowledge-based software, and
knowledge-level communication among agents?