Re: SUO: Vote 2001-02: IFF Foundation Ontology
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