beta release of new OntolinguaTom Gruber <Gruber@KSL.Stanford.Edu>
Full-Name: Tom Gruber
Date: Fri, 14 May 93 19:06:02 PDT
From: Tom Gruber <Gruber@KSL.Stanford.Edu>
Subject: beta release of new Ontolingua
This is to announce a new release of the ontolingua software.
This is a beta release. Please report all problems to this list
<firstname.lastname@example.org> and we will try to support you in a timely
fashion. Thanks for your patience since the last release.
To get the new code, copy the compressed tar file
available by anonymous ftp from
The directory tree of sources and documentation is all there in expanded form
Here are the release notes, explaining what's new. Enjoy.
Ontolingua 3.2.0 Release Notes
We have just made available a new release of ontolingua on the
This is a complete source release of a new version of Ontolingua; you
must get the entire package and re-install to take advantage of the
new features. (Subsequent patch releases will only require grabbing
the patch file and recompiling.)
THE OFFICIAL, UP TO DATE DOCUMENTATION ON THE ONTOLINGUA SOFTWARE
IS THE ON-LINE DOCUMENTATION. Call the function (ol:help) for a quick,
on-line introduction. See also the /doc subdirectory for the reference
and user manuals. The file called "user-manual.tex" is out of date on the
details, but included because the basic ideas are still right. The paper
ontolingua-introduction.rtf,.hqx is a Microsoft Word document that has been
This new release includes the following changes in functionality:
0. EASIER INSTALLATION
Formerly, you needed to edit a variable to tell ontolingua where it
lives. Now it figures this out for itself, at least for Lucid,
Allegro, TI Explorers, and MacIntosh Common Lisp. To install
ontolingua, simply copy the source tree, load the file defsystem.lisp
>From the top level directory, and call the function
(user::compile-load-ontolingua). Once this is done, you only
load the defsystem.lisp and call (user::load-ontolingua). The load
process tells you how to get immediate help to get started.
1. TRANSLATION INTO STREAMS WITHOUT TARGET SYSTEM LOADED
Experience with the previous version of ontolingua indicated
that many users did not need runtime translation into the target
reprentation system (e.g., Loom or Epikit). Instead, they wanted to
translate files from KIF/ontolingua into the target representation, or
to simply analyze the ontology using ontolingua tools.
To accomodate this need, we changed the architecture of Ontolingua so
that one can do translations into streams (e.g., files) rather than
only to memory. Furthermore, we made it possible to do these
translations without the target representation system being loaded!
This is like cross compilation for programming languages. It has the
added benefit of freeing the Ontolingua user from having to have a
license to use a target system, just to see what an ontology would
look like in that representation. Ontolingua still has the capability
to call target systems directly at translation time.
The simplest way to perform translations of ontologies stored in files
is the function OL:TRANSLATE-FILE. Given the name of a file, e.g.,
my-onto.lisp, it creates another file, e.g., my-onto.loom, that is a
translation of the ontology into the specified target representation,
using the implementation name as the file type suffix. You may
specify a target implementation to TRANSLATE-FILE, so you don't have
to be "in" that implementation to use it.
Given a target implementation and a form such as OL:DEFINE-CLASS,
Ontolingua will either translate to a stream or call the target
representation directly. This behavior is governed by the variable
OL:*ONTO-TRACE*. By default this variable is set to NIL, which means
no tracing is done and the target system is called directly. If the
variable is set to :PRINT-ONLY, then will generate Lisp forms in the
syntax of the target system and print them to the stream
*trace-output* and the target system is not called. If the variable
is set to any other value except for NIL, then output is sent to a
trace stream AND the target implementation is called. One can divert
this output by binding OL:*TRANSLATION-OUTPUT-STREAM* to a stream such
as a file. Reading and evaluating the forms generated by output to a
stream should produce the same behavior as simply calling the target
system directly. The OL:*ONTO-TRACE* variable is used by the Gnu
emacs/iLisp support to display translations in your emacs environment.
TRANSLATE-FILE also uses *ONTO-TRACE* and *TRANSLATION-OUTPUT-STREAM*.
Ontolingua comes out of the box with the target implementation set to
:KIF. This transforms definitions in ontolingua syntax into a
canonical form of KIF definitions (putting cliches into second order
form where possible, etc). Translating to :KIF also has the effect of
storing the definitions on the property lists of the defined symbols
(unless the output has been diverted to a stream as explained above).
To change the default implementation, call OL:IN-IMPLEMENTATION.
If you want to use Ontolingua as a database for definitions, you might
also consider using the generic-kb implementation.
2. NEW TARGET IMPLEMENTATION: GENERIC-KB
Since many of the desired target languages are variants on simple
frame systems, Ontolingua now includes a target implementation called
generic-frame which can serve as a canonical form for frame systems.
It's kind of a "homeless person's frame system" -- just the bare minimum.
In Generic-frame, all objects (classes, instances, functions,
relations) are described as "frames" with slots. Where possible,
sentences in the KIF/Ontolingua definition are put into slot format,
and the remaining sentences are formulated as KIF axioms in the form
of Lisp S-expressions.
To use the new target application, simply set the current
implementation to :GENERIC-FRAME with the command
(OL:IN-IMPLEMENTATION :GENERIC-FRAME). Then translate your favorite
ontology into generic frame using (OL:TRANSLATE-FILE "my-onto.lisp")
and then take a look at "my-onto.generic-frame". For the brave,
just load an ontology into generic-frame and it will remember what
you told it. You can query the generic frame KB using the GKB protocol
3. NEW API FOR FRAME SYSTEMS -- THE GENERIC-KB PROTOCOL
There is a new Application Programmer Interface to frame systems
called Generic-KB (GKB). This provides a set of Lisp functions that
dispatch to implementation specific code supporting a variety of
object-centered representation systems. Functions support operations
such as get-slots, put-slot-value, put-facet-value, save-kb, etc.
It is not quite ready at the time of this release, but we plan a
For more information on the GKB protocol, please contact:
Peter Karp <email@example.com>
Tom Gruber <firstname.lastname@example.org>
4. CHANGES TO FRAME ONTOLOGY
We've added a few new classes, functions, and relations to the frame
ontology. Mainly these are for completeness, to support "slot-like"
forms of all the second-order concepts in the ontology. New
or changed definitions include: THING, COMPOSITION-OF, COMPOSE,
5. POLYMORPHISM IN FUNCTION DEFINITIONS
To support the polymorphic definition of functions, there is a new
keyword for define-function. A clause labeled by :when specifies the
conditions under which the given definition of the function makes
sense. This can be used to specify polymorphic definitions of general
operators such as + and *. This is currently experimental; see the
usage in the example ontologies. Ontolingua generate the appropriate
axioms for polymorphic definitions, but back-end translators are not
guaranteed to do the right thing with them.
6. SYSTEM ONTOLOGIES AS ONLINE DOCUMENTATION
In this release, when you load Ontolingua it automatically loads the
frame-ontology, the kif-ontology, and an ontology called
slot-constraint-sugar that defines some KL-ONE style shorthand names
for slot constraints. Having these ontologies loaded enables
hypertext access to the definitions of KIF and Ontolingua vocabulary.
In reasonable Lisp environments one can use the edit-definition
(meta-.) to jump from a symbol to its source definition, or
show-documentation to show the documentation string that is stored in
memory with the symbol. Ontolingua tells the Lisp environments where
to look. On Unix Lisps, the "iLisp" package for Gnu Emacs gives these
capabilities. And here's a tip for doing apropos search: all built-in
vocabulary (KIF, frame ontology, slot constraint sugar) is exported
>From the package named KIF. Loading these ontologies automatically
also prevents some nasty bootstrap problems for systems that cannot
tolerate theories with undefined terms (e.g. Loom).
7. NEW EXAMPLE ONTOLOGIES
The directory /examples under the ontolingua tree now includes some
nontrivial ontologies for engineering mathematics, and configuration
design. Comments are very welcome to email@example.com or
8. ORDER-INDEPENDENCE OF INCLUDED THEORIES
We have made every attempt to free the user from the need to load
included theories before the including theory. However, if you use a
target system that needs things loaded in a particular order, don't
blame us. :-)
9. CONTINUED SUPPORT FOR MULTIPLE LISPS.
Significant work has been done to ensure that this release works
acceptably under PCL as well as CLOS.
This package has been built and tested to some extent under Allegro
(4.1), Lucid (4.1), MCL (2.0p2) and TI (Sys 6.0+) Common LISPs. As
usual, please report all bugs, suggestions, comments, etc. to: