what's new in ontolingua 3?

• Mail folder: Ontolingua Mail
• Next message: Tom Gruber: "BNF for Ontolingua"
• Previous message: Tom Gruber: "ontolingua lives"

Message-id: <2922680826-6745878@KSL-Mac-69>
Date: Thu, 13 Aug 92  00:47:06 PDT
From: Tom Gruber <Gruber@Sumex-AIM.Stanford.edu>
To: ontolingua@SUMEX-AIM.Stanford.EDU
Subject: what's new in ontolingua 3?

Here are some of the things that are new to the newest ontolingua:
The reference manual is the most complete source of detailed
information.  This note should give a flavor.

-- handles the KIF 3.0 syntax. 

 Individual variables are now prefixed with '?' instead of '$'.
Functions can be used in the relational position.   Etc.

-- theories.

Ontologies are now partitioned into theories, which are logically just
sets of definitions/axioms (still a global _namespace_).  Theories can
include other theories.  Theories appear are analogous to Common
Lisp's packages: the user defines a theory, declares that a file is in
a theory, and imports from more general theories into specializations.

-- new keywords:

  :AXIOM-DEF and :AXIOM-CONSTRAINTS

   Second order sentences should now be put in sentences labeled
with one of these, rather than imixed up with the :DEF, :IFF-DEF,
and :CONSTRAINTS sentences.   This is to avoid confusion.  
For example, 
   (define-class C (?i) :DEF (P ?i)) 
means that all C's are P's, and translates as
  (=> (C ?i) (P ?i)).
This can also be said using the second-order relation subclass-of:
  (subclass-of C P).
However, if we put the subclass-of statement in the :DEF, the
straightforward interpretation would be:
  (=> (C ?i) (subclass-of C P))
which expands into
  (=> (C ?i) (=> (C ?i) (P ?i)))
which doesn't mean what was intended.

So you put the second order sentences in :AXIOM-DEF if they are
definitional and in :AXIOM-CONSTRAINTS if they are just assertions.

-- New forms for defining axioms and instance

-- Slightly different syntax for functions:

   (define-function (?arg1 ?arg2) :-> ?result
      "notice the new result variable above"
     :def (and (domain-constraint ?arg1)
             (more-constraints ?arg2)
             (RANGE-constrait ?result))
     :lambda-body (term-involving ?arg1 >arg2))

We found this more descriptive than an earlier :result-variable
keyword included with the other keywords (which is still supported in
the code).  Now functions look almost like relations, which is right
since they are relations.  Note that you can describe the function as
a relation using the :DEF sentence (e.g., domain and range
constraints) as well as giving a :LAMBDA-BODY term which denotes the
value in terms of the inputs.

-- New relations in the frame ontology to support KL-ONE style
definitions that relate classes to restrictions on their slots.

  value-type, has-value, has-values, value-cardinality, has-at-least,
  has-at-most, has-one, has-some, can-have-one, cannot-have,
  has-value-of-type, has-one-of-type

These are all axiomatically defined relations, not language
primitives.  They translate into restrictions on the number and type
of values that a slot (binary relation) can have when applied to a
given concept (class).

  have-same-values and compose*

are used to describe role chains, such as
  (define-class person (?p)
    :def (have-same-values ?p grandmother (compose* mother parent)))

which means that a grandmother of a person is a mother of a parent of
the person.

  class-partition, subclass-partition, and exhaustive-subclass-partition

allow you to describe sets of mutually disjoint classes.


-- more sophisticated canonicalization done by ontolingua before
sending things off to the back-end translators.  We recognize cliches
that are equivalent to the supported second-order relations, and the
translators only have to recognize the second-order statements (which
are ground and unstructured).  There is an ongoing project at the KSL
and U Wyoming that is doing reall snazzy transformations of complex
KIF sentences into known forms; we are looking to incorporate some of
that technology into future OL releases.

-- Programming environment utilities.  Some emacs support so that you
can evaluate ontolingua forms in a buffer, and watch what it would
translate into.  You can do this in a read-only or evaluation mode.
This is nice for developing ontologies that you want to be sure will
work in your favorite KR system.  Also, there is a "meta-." hypertext
command, so that you can mouse on a symbol to see where it is defined
(and go to that place in a file if desired).  This already works for
Lisp Machines, and we're trying to find a portable way to do this in
the Unix / Emacs based Lisp environments (probably with ILisp - do
people use it?).