Re: SUO: Vote 2001-02: IFF Foundation Ontology
Robert,
I appreciate the very concrete message. This is exactly the sort of
discussion needed if we're to create an actual standard.
1. I notice that you're using sorted quantifiers. That isn't in SUO-KIF
nor the latest KIF group draft that Michael Gruninger has prepared,
although they are in the version at
<http://logic.stanford.edu/kif/dpans.html#6.3>. You don't appear to cite
which version of KIF you're using in your IJCAI paper or proposal for
SUO. Which version do you use?
2. You've shown below how a natural language sentence could be expressed
in a way consistent with a version of KIF and the IFF. However, it's not
clear (to me at least) what value is being added by IFF itself. You use
the term 'event' in the formalization below but no such term appears in
IFF. In contrast, SUMO does have notions of events (and times, roles of
actors etc) which provide a definition for that term.
So, your example in SUO-KIF <http://suo.ieee.org/suo-kif.html> alone would be
"Sue ate the cheese sandwich before her meeting with John."
(subclass-of person agent)
(subclass-of sandwich object)
(subclass-of eating-event event)
(subclass-of meeting-event event)
(subclass-of name string)
(subclass-of cheese object)
(subclass-of person event)
(subclass-of person name)
(subclass-of event name)
(nth-domain 1 performed-by event)
(nth-domain 2 performed-by agent)
(nth-domain 1 has-name object)
(nth-domain 2 has-name name)
(nth-domain 1 object-destroyed event)
(nth-domain 2 object-destroyed object)
(nth-domain 1 contains-substance object)
(nth-domain 2 contains-substance object)
(nth-domain 1 participant event)
(nth-domain 2 participant agent)
(nth-domain 1 before event)
(nth-domain 2 before event)
(exists (?ee ?me ?sw ?s ?j ?c)
(and
(instance-of ?ee eating-event)
(instance-of ?me meeting-event)
(instance-of ?sw sandwich)
(instance-of ?s person)
(instance-of ?j person)
(instance-of ?c cheese)
(performed-by ?ee ?s)
(has-name ?s "sue")
(object-destroyed ?ee ?sw)
(contains-substance ?sw ?c)
(participant ?me ?s)
(participant ?me ?j)
(has-name ?j "john")
(before ?ee ?me)))
The problem (I would say) with this formulation as well as what you provide
below is that there is no upper ontology being used. The term 'event' is
meaningless because it is just a token with no formal definition. In
contrast, the SUMO formalization would be
(subclass-of Cheese Food)
(subclass-of Sandwich Food)
(exists (?ee ?me ?sw ?s ?j ?c)
(and
(instance-of ?ee Eating)
(instance-of ?me Meeting)
(instance-of ?sw Sandwich)
(instance-of ?s Human)
(instance-of ?j Human)
(instance-of ?c Cheese)
(agent ?ee ?s)
(documentation ?s "sue")
(patient ?ee ?sw)
(material ?sw ?c)
(patient ?me ?s)
(patient ?me ?j)
(documentation ?j "john")
(before ?ee ?me)))
SUMO already has definitions for concepts like Eating, the stuff an object
is made of ('material') etc. Instead of being just tokens, the concepts
have some meaning by virtue of their associated axioms. That's why the
list of statements prior to the formalization of the English example
sentence is so small - all those concepts already exist in SUMO.
So, in summary, what does the IFF version of the example provide us that
the SUO-KIF-only version does not?
Adam
At 04:42 PM 8/17/2001 -0700, Robert E. Kent wrote:
>Adam,
>
>Below I took your example, did some analysis and illustrated how it might be
>encoded using the IFF Model Theory Ontology (to be submitted later this fall
>in version 3.0 of the IFF Foundation Ontology). I only worked on encoding
>the syntactic aspect, with the source KIF expression translated to the
>(internal) target IFF expression. Note that the source code could be in any
>1st-order language (KIF, CGIF, some XML-ese, etc.). It would also be
>interesting to illustrate semantics by using instances and their
>classifications. Or also to illustrate 1st-order interpretations.
>
>
>----- Original Message -----
>From: "Adam Pease" <apease@ks.teknowledge.com>
>To: "Robert E. Kent" <rekent@ontologos.org>; "John F. Sowa"
><sowa@bestweb.net>
>Cc: "SUO" <standard-upper-ontology@ieee.org>; "Chris Menzel"
><cmenzel@philebus.tamu.edu>; "Yang Yun" <yangyun@metacrawler.com>; "pat
>hayes" <phayes@ai.uwf.edu>
>Sent: Thursday, August 16, 2001 3:15 PM
>Subject: Re: SUO: Vote 2001-02: IFF Foundation Ontology
>
>
> > Robert,
> > One way to help show the relevance and accessibility of the IFF
>ontology
> > would be to give some examples of how to code the information expressed in
> > common English statements in IFF.
> > I did something similar in the series of "Hamlet" examples in the
> > message copied below, as well as the dialog with Josiane Caron-Pargue also
> > copied below.
> >
> > Adam
>
>__________________________________________________
>
>Part I. Here are equivalent expressions of a sentence (proposition) in
>various languages.
>__________________________________________________
>
>NL (English):
>
>"Sue ate the cheese sandwich before her meeting with John."
>
>new KIF:
>
>(exists (?ee (eating-event ?ee)
> ?me (meeting-event ?me)
> ?sw (sandwich ?sw)
> ?s (person ?s)
> ?j (person ?j)
> ?c (cheese ?c))
> (and (performed-by ?ee ?s) (has-name ?s "sue")
> (object-destroyed ?ee ?sw)
> (contains-substance ?sw ?c)
> (participant ?me ?s)
> (participant ?me ?j) (has-name ?j "john")
> (before ?ee ?me)))
>
>CGIF:
>...
>
>__________________________________________________
>
>Part II. Here is an analysis of the sentence.
>__________________________________________________
>
>This is a sentence (or proposition) expressible in a 1st-order language.
>Let us call the language "example-language" and the sentence
>"example-sentence."
>__________
>
>There are seven content words in the NL representation of the sentence:
>
>Sue
>ate
>cheese
>sandwich
>before
>meeting
>John
>
>There are eleven terms (corresponding to logical predicate symbols) and two
>names (corresponding to logical constants) in the KIF representation of the
>sentence:
>
>eating-event
>meeting-event
>sandwich
>person
>cheese
>performed-by
>has-name
>object-destroyed
>contains-substance
>participant
>before
>
>"sue"
>"john"
>__________
>
>There are six *entity instances* (objects, individuals or particulars)
>(corresponding to the six existentially quantified variables) involved in
>this sentence:
>
>two persons
>two names, "sue" and "john"
>two events, an eating-event and a meeting-event
>one sandwich
>one cheese
>__________
>
>On the surface there are six *entity types* involved in this sentence:
>
>eating-event
>meeting-event
>sandwich
>person
>name
>cheese
>
>The entity types 'eating-event' and 'meeting-event' are reified or converted
>from the relation types 'eat' and 'meet', possibly for the purpose of
>temporal ordering of actions.
>__________
>
>This sentence does not exist in isolation. In the background there are any
>number of other entity types with appropriate subtype and disjointness
>constraints:
>
>person subtype agent
>sandwich subtype object
>eating-event subtype event
>meeting-event subtype event
>name subtype string
>cheese subtype object
>person disjoint event
>person disjoint name
>event disjoint name
>__________
>
>There are six binary *relation types* involved in this sentence:
>
>performed-by
> signature(performed-by) = (event, agent)
>has-name
> signature(has-name) = (object, name)
>object-destroyed
> signature(object-destroyed) = (event, object)
>contains-substance
> signature(contains-substance) = (object, object)
>participant
> signature(participant) = (event, agent)
>before
> signature(before) = (event, event)
>__________
>
>Also, in the background there are any number of other relation types with
>appropriate subtype and disjointness constraints.
>
>__________________________________________________
>
>Part III. Here is an encoding of the syntax in terms of elements of the IFF
>Model Theory Ontology.
>__________________________________________________
>
>Some initial syntactic declarations:
>
>(lang$language example-language)
> (= (lang$entity-type example-language) example-entity-type)
> (= (lang$relation-type example-language) example-relation-type)
> (= (lang$signature example-language) example-signature)
> (= (lang$index example-language) example-index)
>(= (lang$entity-theory example-language) example-entity-theory)
> (= (if.th$subtype example-entity-theory) example-entity-subtype)
> (= (if.th$disjoint example-entity-theory) example-entity-disjoint)
>(= (lang$relation-theory example-language) example-relation-theory)
>
>__________
>
>Declarations for the entity types:
>
>(example-entity-type eating-event)
>(example-entity-type meeting-event)
>(example-entity-type sandwich)
>(example-entity-type person)
>(example-entity-type name)
>(example-entity-type cheese)
>__________
>
>Declarations for the entity type constraints:
>
>(example-entity-subtype [person agent])
>(example-entity-subtype [sandwich object])
>(example-entity-subtype [eating-event event])
>(example-entity-subtype [meeting-event event])
>(example-entity-subtype [name string])
>(example-entity-subtype [cheese object])
>(example-entity-disjoint [person event])
>(example-entity-disjoint [person name])
>(example-entity-disjoint [event name])
>__________
>
>Declarations for the relation types:
>
>(example-relation-type performed-by)
>(example-relation-type has-name)
>(example-relation-type object-destroyed)
>(example-relation-type contains-substance)
>(example-relation-type participant)
>(example-relation-type before)
>__________
>
>Traditional declarations for the relation type signatures might go as
>follows:
>
>(= (example-signature performed-by) [event agent])
>(= (example-signature has-name) [object name])
>(= (example-signature object-destroyed) [event object])
>(= (example-signature contains-substance) [object object])
>(= (example-signature participant) [event agent])
>(= (example-signature before) [event event])
>
>Here, we usually think of the n-th argument type as being indexed by the
>(n+1)st natural number.
>__________
>
>However, for convenience and flexibility, the IFF Model Theory Ontology
>generalises these numerical indices to abstract indices. A more hidden, but
>quite important, motive for doing this is to represent languages in terms of
>hypergraphs. For each language L, we assume an adequate (possibly
>denumerable) collection of *indices* index_L. Indices are used for naming
>the (functional) participants of relations. They correspond to the lines of
>identity and lambda variables of conceptual graphs. Indices are used to
>build expressions (formulas) of L.
>
>Here are some indices declared for the example expression.
>
>(example-index ee)
>(example-index me)
>(example-index e)
>(example-index e1)
>(example-index e2)
>(example-index sw)
>(example-index o)
>(example-index o1)
>(example-index o2)
>(example-index s)
>(example-index j)
>(example-index p)
>(example-index a)
>(example-index n)
>(example-index c)
>__________
>
>The *signature* of a relation type is an finitely indexed collection of
>(possibly duplicate) entity types. The indexing elements of a signature are
>a finite subset of the indices of L. More precisely, the signature of a
>relation type is a pair consisting of a subset of indices called the *arity*
>of the relation type and a map (function) from the arity to the set of
>entity types.
> signature_L(R) : arity_L(R) -> index_L
>
>Here are the actual declarations for the relation type signatures:
>
>(= ((example-signature performed-by) e) event)
>(= ((example-signature performed-by) s) agent)
>(= ((example-signature has-name) p) person)
>(= ((example-signature has-name) n) name)
>(= ((example-signature object-destroyed) e) event)
>(= ((example-signature object-destroyed) o) object)
>(= ((example-signature contains-substance) o1) object)
>(= ((example-signature contains-substance) o2) object)
>(= ((example-signature participant) e) event)
>(= ((example-signature participant) a) agent)
>(= ((example-signature before) e1) event)
>(= ((example-signature before) e2) event)
>__________
>
>Construction of the sentence:
>
>IFF expressions (formulas) are just like IFF relation types -- they have an
>arity and a signature. If fact, it is important to observe the IFF
>expressions _are_ relation types of an extended language. This gives a
>very important homogeneous quality to the model-theoretic framework.
>
>The IFF expression that represents the above sentence is built step-wise
>bottom-up. This particular expression has eight atomic expressions, followed
>by a conjunction, followed by a composite existential quantification. Here
>are the five steps needed to build this example expression.
>
>1. Relation types are embedded as expressions with the same arity and
>signature.
>
>((lang$expression example-language) performed-by-embedding)
>(= performed-by-embedding
> ((lang$relation2expression example-language) performed-by))
>...
>
>2. During the build process, certain expressions may need to be restricted
>to subtypes of their arity. Restriction includes renaming by indices of the
>same type.
>
>((lang$expression example-language) performance-atom)
>(= performance-atom
> (((lang$restriction example-language) performance-atom-signature)
>performed-by-embedding)
>...
>
>3. The argument for the conjunction operator is formed as a collection of
>atoms.
>
>((set$power (lang$expression example-language)) expression-set)
>(expression-set performance-atom)
> ...
>(expression-set before-atom)
>
>4. A conjoined expression is constructed.
>
>((lang$expression example-language) example-conjunction)
>(= example-conjunction
> ((lang$and example-language) expression-set))
>
>5. The composite existential quantifications are built (a macro is used
>here).
>
>((lang$sentence example-language) example-sentence)
>(= example-sentence
> (((lang$existential-quantifier example-language) [ee me sw s j c])
>example-conjunction))
>__________
>
>As I mentioned above, we could also give examples of declaring and
>manipulating instances, both entity and relation, in the IFF Model Theory
>Ontology -- thus building a model, not just a language. Also, we could give
>examples of 1st-order interpretations.
>
>Robert E. Kent
>rekent@ontologos.org
Adam Pease
Teknowledge
(650) 424-0500 x571