Knowledge Sharing Papers
Tom Gruber <email@example.com>
This file contains the abstracts for a public library of papers on the topic
of knowledge sharing. This directory contains the full papers in electronic
form. See the ARPA Knowledge Sharing Effort home
page (parent directory) for access to software and examples.
WWW Hint: Use the search command in your browser application (e.g., Mosaic)
to look for papers on a particular subject of interest.
You might also want to print this document as postscript and read the abstracts, then come back and fetch the full papers.
Table of Contents:
- Recent Changes
- Announcements of updates and new papers
- Access Information
- How to get copies of the
- List of Titles
- A table of contents listing the title of each document
- Full Abstracts and availability
of the papers, in author-sorted alphabetical order, complete with references
and availability information.
Dates of posting are shown in (parentheses).
Search for papers in this document using textual search from your WWW browser
or text editor. Some people find it useful to print this document (it looks
good in postscript form) and browse the abstracts on paper.
- New paper, A Generic Knowledge-Base Access Protocol by Karp and Gruber (Sept 94).
- New paper, Collaborative Engineering based on Knowledge Sharing Agreements, by Olsen, Cutkosky, Tenenbaum, & Gruber (June 94).
- Overview of SHADE project, by Kuokka et al., now on line in html format with up to date pointers to other online papers (June 94).
- New paper, An Ontology for Engineering Mathematics, by T. Gruber and G. Olsen, in html with links from to ontologies and cited papers (May 94).
- New paper, The Role of Reversible Grammars in Translating Between Representation Languages, by J. Van Baalen and R. Fikes (Nov 93).
- New paper, An Ontology of
Meta-Level Categories, by Nicola Guarino, Massimiliano
Carrara, and Pierdaniele Giaretta (Jan 94).
- New paper, The Ontological
Level, by Nicola Guarino (Dec 93).
- New SHADE paper by McGuire et al. now available (Jan 94).
- Short overview of Knowledge Sharing Effort by Bob Neches (Nov 93).
- PACT paper by Cutkosky et al. now online in hypertext format.
- Update of Toward principles for the design of ontologies used for
knowledge sharing, by Tom Gruber (Aug 93).
- New Description Logic (KRSS) spec, updated July 93.
- New article, A Knowledge Sharing Perspective on Protege, by Musen et al., Apr 93.
- Update of Dimensions of knowledge sharing by Mark Musen, (Apr 93).
If you are reading this from a World Wide Web browser, then you will be able view and retrieve the papers by following anchors in this document. Your WWW application may spawn a viewer or ask you to save the file locally.
Papers may also be obtained via anonymous ftp to
Each paper reference is accompanied by a "Available as" line. The names listed on that line are the names of files in this ftp directory.
Papers come in a variety of formats, indicated by their file extensions.
For example, filenames ending in the extension ".ps" are in Postscript. The conventions for file formats are:
- TeX or LaTeX
- Binhex encoding of a Macintosh document
- Microsoft Word RTF interchange format
- compressed using the Unix "compress" program (adaptive Lempel-Ziv
coding). Be sure to set ftp into binary mode before copying compressed
files. Compressed files are often directories that have been packaged up by the unix "tar" command. To unpack them, use the command
tar -xvf file.tar
List of Titles
Titles of documents that are listed in this file, sorted by title
Abstracts and Availability
J. Allen & N. Lehrer. DRAFT of the DARPA/Rome Laboratory Planning and
Scheduling Initiative Knowledge Representation Specification Language
(KRSL), Version 2.0.1 Reference Manual. ISX Corporation, June 26,
Available as: krsl.tar.Z (postscript files)
KRSL is the language used by the DRPI planning and sheduling
effort for specifying shared ontologies. The language includes
an ontology of time, measurement, resource, and planning
operations as built-in primitives. [abstract by TRG]
A separate set of files contains the actual "Shared Domain
Ontology" for military logistics (planes, ships, etc).
M. Cutkosky, R. Engelmore, R. Fikes, T. Gruber, M.
Genesereth, W. Mark, J. Tenenbaum, & J. Weber. PACT: An experiment
in integrating concurrent engineering systems. IEEE Computer, January 1993.
In special issue on computer-supported concurrent engineering.
[Note: the printed version is superior to the electronic form; get a copy from
the magazine if you are interested.]
Available as: pact.html,
The Palo Alto Collaboration Testbed (PACT) is a laboratory for
joint experiments in computer-aided concurrent engineering being
pursued by research groups at Stanford University, Lockheed,
Hewlett-Packard, and Enterprise Integration Technologies. The
current prototype integrates four preexisting concurrent
engineering systems into a common framework. Each of the
individual systems is used to model different aspects of a small
robotic manipulator, and to reason about them from a different
engineering perspective (dynamics, digital electronics, and
software). Initial PACT experiments have explored engineering
knowledge exchange in the context of a distributed simulation and
simple incremental redesign scenario. This paper describes the
nature of these experiments, the technology underlying them, and
the results they produced.
R. Fikes, M. Cutkosky, T. Gruber, & J. Van Baalen.
Knowledge Sharing Technology Project Overview.
Stanford University, Knowledge Systems Laboratory, Technical Report
KSL 91-71, November 1991.
Available as: kst-project.ps, kst-project.rtf (MS Word)
Ever since the mid-seventies, researchers have recognized that capturing
knowledge is the key to building large and powerful AI systems. In the years
since, system builders also found that representing knowledge is difficult and
time consuming. Although tools have been developed to help with knowledge
acquisition, knowledge base construction remains one of the major costs in
building an AI system. The development of most systems requires a new
knowledge base to be constructed from scratch. As a result, most systems
remain small to medium in size. Even if several systems are built within a
general area, such as medicine or electronics diagnosis, significant portions
of the domain must be rerepresented for every system that is created.
T. Finin, Don McKay, Rich Fritzson (Eds.). The KQML Advisory Group.
An overview of KQML: A Knowledge Query and Manipulation Language.
March 2, 1992.
Available as: kqml-overview.ps
We describe a language and protocol intended to support interoperability among
intelligent agents in a distributed application. Examples of applications
envisioned include intelligent multi-agent design systems as well as
intelligent planning, scheduling and replanning agents supporting distributed
transportation planning and scheduling applications. The language, KQML for
Knowledge Query and Manipulation Language, is part of a larger DARPA-sponsored
Knowledge Sharing Effort focused on developing techniques and tools to promote
the sharing of knowledge in intelligent systems. We will defined the concepts
which underly KQML and attempt to specify its scope and provide a model for
how it will be used.
T. Finin, J. Weber, G. Wiederhold, M. Genesereth, R. Fritzson, D. McKay,
J. McGuire, P. Pelavin, S. Shapiro, & C. Beck. Specification of the KQML
Agent-Communication Language. Enterprise Integration Technologies, Palo
Alto, CA, Technical Report EIT TR 92-04, updated July 1993.
Available as: kqml-spec.ps
The file kqml-spec.ps is a Postscript version of the latest KQML
draft specification. The spec defines the reserved KQML messages,
and the parameter names that are reserved in extensions to the set
of messages. Furthermore, this spec briefly describes protocol
layers both below (message transport) and above (agent policies and
architectures) KQML. Comments on the draft spec should be directed
to the firstname.lastname@example.org mailing list.
Message-passing is glue that builds large software systems out of
smaller software systems. There are many new standards and
toolkits that support the transport of messages among programs
(e.g., OMG CORBA, OSF DCE, ISIS, BSD Sockets, even ServiceMail),
but once connected, what should programs say to one another?
Sophisticated programs, especially knowledge-based "agents",
interact in may ways beyond the simple query-response paradigm of
standards like SQL, leading to a proliferation of incompatible
agent communication languages.
The DARPA Knowledge-Sharing Initiative has addressed this issue, in
part, though the Knowledge Query and Manipulation Language (KQML).
KQML is a language that programs can use to describe a variety of
different attitudes about information including queries,
assertions, action requests, information subscriptions, and
processing capabilities. Furthermore, KQML is an enabler of
information-flow architectures, though forwarding, broadcasting,
and brokering messages.
M. R. Genesereth, R. E. Fikes (Editors).
Knowledge Interchange Format, Version 3.0 Reference Manual.
Department, Stanford University, Technical Report Logic-92-1, June
Available as: kif.tex, kif.ps
Knowledge Interchange Format (KIF) is a computer-oriented
language for the interchange of knowledge among disparate
programs. It has declarative semantics (i.e. the meaning of
expressions in the representation can be understood without
appeal to an interpreter for manipulating those expressions); it
is logically comprehensive (i.e. it provides for the expression
of arbitrary sentences in the first-order predicate calculus); it
provides for the representation of knowledge about the
representation of knowledge; it provides for the representation
of nonmonotonic reasoning rules; and it provides for the
definition of objects, functions, and relations.
M. R. Genesereth. Knowledge Interchange Format. Principles of
Knowledge Representation and Reasoning: Proceedings of the Second
International Conference, Cambridge, MA, pages 599-600. Morgan
T. R. Gruber. The Role of Standard Knowledge Representation
for Sharing Knowledge-Based Technology. Stanford University,
Knowledge Systems Laboratory, Technical Report KSL-90-53, August 1990.
Available as: role-of-skr.ps
This note analyzes the role that a standard knowledge representation
language can play in the sharing of knowledge bases--among groups of
people and programs that can make use of the knowledge and across
research groups developing knowledge-based technology. Starting from
the assumption that a standard "interlingua" could be established, I
will lay out a space of possible ways in which knowledge bases can be
shared, then discuss the design requirements for a language to support
KB sharing, mechanisms for sharing formally-represented knowledge, and
some of the technology to facilitate the development and use of shared
T. R. Gruber. The Role of Common Ontology in Achieving
Sharable, Reusable Knowledge Bases. Principles of Knowledge
Representation and Reasoning: Proceedings of the Second International
Conference, Cambridge, MA, pages 601-602. Morgan Kaufmann, 1991.
Available as: role-of-onto.tex, role-of-onto.ps
T. R. Gruber. Ontolingua: A mechanism to support portable
ontologies. Stanford University, Knowledge Systems Laboratory,
Technical Report KSL-91-66, March 1992. Revision.
Available as: ontolingua-long.ps, ontolingua-long.tex
The best introduction to Ontolingua is found in: A Translation Approach to Portable Ontology Specifications (see below).
An ontology is a set of definitions of content-specific knowledge
representation primitives: classes, relations, functions, and
object constants. Ontolingua is mechanism for writing ontologies
in a canonical format, such that they can be easily translated
into a variety of representation and reasoning systems. This
allows one to maintain the ontology in a single, machine-readable
form while using it in systems with different syntax and
reasoning capabilities. The syntax and semantics are based on
the KIF knowledge interchange format. Ontolingua
extends KIF with standard primitives for defining classes and
relations, and organizing knowledge in object-centered
hierarchies with inheritance. The Ontolingua software provides
an architecture for translating from KIF-level sentences into
forms that can be efficiently stored and reasoned about by target
representation systems. Currently, there are translators into
LOOM, Epikit, and Algernon, as well as a canonical form of KIF.
This paper describes the basic approach of Ontolingua to the
ontology sharing problem, introduces the syntax, and describes
the semantics of a few ontological commitments made in the
software. Those commitments, which are reflected in the
ontolingua syntax and the primitive vocabulary of the frame
ontology, include: a distinction between definitional and
nondefinitional assertions; the organization of knowledge with
classes, instances, sets, and second-order relations; and
assertions whose meaning depends on the contents of the knowledge
base. Limitations of Ontolingua's ``conservative'' approach to
sharing ontologies and alternative approaches to the problem are
T. R. Gruber.
A Translation Approach to Portable Ontology Specifications.
Knowledge Acquisition, 5(2):199-220, 1993.
Available as: ontolingua-intro.rtf, ontolingua-intro.binhex, ontolingua-intro.ps
To support the sharing and reuse of formally represented knowledge
among AI systems, it is useful to define the common vocabulary in
which shared knowledge is represented. A specification of a
representational vocabulary for a shared domain of discourse --
definitions of classes, relations, functions, and other objects -- is
called an ontology. This paper describes a mechanism for defining
ontologies that are portable over representation systems. Definitions
written in a standard format for predicate calculus are translated by
a system called Ontolingua into specialized representations, including
frame-based systems as well as relational languages. This allows
researchers to share and reuse ontologies, while retaining the
computational benefits of specialized implementations.
We discuss how the translation approach to portability
addresses several technical problems. One problem is how to
accommodate the stylistic and organizational differences among
< representations while preserving declarative content. Another is how
to translate from a very expressive language into restricted
languages, remaining system-independent while preserving the
computational efficiency of implemented systems. We describe how
these problems are addressed by basing Ontolingua itself on an
ontology of domain-independent, representational idioms.
T. R. Gruber. Toward principles for the design of ontologies used for
knowledge sharing. In Formal Ontology in Conceptual Analysis and Knowledge
Representation, Nicola Guarino and Roberto Poli, editors, Kluwer Academic,
in preparation. Original paper presented at the International Workshop on
Formal Ontology, March 1993. Available as Stanford Knowledge Systems
Laboratory Report KSL-93-04.
Available as: onto-design.ps,
Recent work in Artificial Intelligence is exploring the use of formal
ontologies as a way of specifying content-specific agreements for the
sharing and reuse of knowledge among software entities. We take an
engineering perspective on the development of such ontologies. Formal
ontologies are viewed as designed artifacts, formulated for specific
purposes and evaluated against objective design criteria.
We describe the role of ontologies in supporting knowledge
sharing activities, and then present a set of criteria to guide the
development of ontologies for these purposes. We show how these
criteria are applied in case studies from the design of ontologies for
engineering mathematics and bibliographic data. The rationale for
selected design decisions in these ontologies is presented.
Alternative representations are compared and evaluated against the
general criteria. In particular, the case studies illustrate the
notions of encoding bias and ontological overcommitment and suggest
ways to avoid them in the design of ontologies for knowledge sharing.
T. R. Gruber and G. R. Olsen. An ontology for engineering mathematics. In J.
Doyle, P. Torasso and E. Sandewall, Ed., Fourth International Conference on
Principles of Knowledge Representation and Reasoning, Gustav Stresemann
Institut, Bonn, Germany, Morgan Kaufmann, 1994.
Available as: engmath.html, engmath.ps
We describe an ontology for mathematical modeling in engineering. The ontology
includes conceptual foundations for scalar, vector, and tensor quantities,
physical dimensions, units of measure, functions of quantities, and
dimensionless quantities. The conceptualization builds on abstract algebra and
measurement theory, but is designed explicitly for knowledge sharing purposes.
The ontology is being used as a communication language among cooperating
engineering agents, and as a foundation for other engineering ontologies. In
this paper we describe the conceptualization of the ontology, and show selected
axioms from definitions. We describe the design of the ontology and justify
the important representation choices. We offer evaluation criteria for such
ontologies and demonstrate design techniques for achieving them.
T. R. Gruber, J. M. Tenenbaum, & J. C. Weber. Toward a
knowledge medium for collaborative product development. Proceedings
of the Second International Conference on Artificial Intelligence in
Design, Pittsburgh, pages 413-432. Kluwer Academic, 1992.
Available as: shade.tex, shade.ps
Information sharing and decision coordination are central
problems for large-scale product development. This paper
proposes a framework for supporting a knowledge medium
[stefik86]: a computational environment in which explicitly
represented knowledge serves as a communication medium among
people and their programs. The framework is designed to support
information sharing and coordinated communication among members
of a product development organization, particularly for the tasks
of design knowledge capture, dynamic notification of design
changes, and active management of design dependencies. The
proposed technology consists of a shared knowledge representation
(language and vocabulary), protocols for foreign data
encapsulation and posting to the shared environment, and
mechanisms for content-directed routing of posted information to
interested parties via subscription and notification services. A
range of possible applications can be explored in this framework,
depending on the degree of commitment to a shared representation
by participating tools. A number of research issues, fundamental
to building such a knowledge medium, are introduced in the paper.
Nicola Guarino, Massimiliano Carrara, and Pierdaniele Giaretta
LADSEB-CNR Int. Rep. 6/93,
Preliminary version - November 30, 1993.
Available as: meta-level-categories.ps
The advantage of structured KR formalisms over pure first-order logic
is that some logical relations (like those corresponding to classes
and slots) have a peculiar structuring meaning. This meaning is the
result of ontological commitments which are however implicit and
strongly dependent on the particular task being considered, since the
formalism itself is in general neutral with respect to ontological
choices. We have argued elsewhere against this neutrality, claiming
that a rigorous ontological foundation for knowledge representation
can facilitate knowledge sharing and reuse. We focus in this paper on
some meta-level ontological distinctions among unary predicates, like
those between concepts, roles and assertional properties. Two are the
main contributions of this work, mostly based on a revisitation of
philosophical (and linguistic) literature largely extraneous to the KR
tradition. The first is a formal notion of ontological commitment,
based on a modal logic endowed with mereological and topological
primitives. The second is a definition of countability based on such
a framework, which exploits the topological notion of connection to
capture the intended semantics of mass nouns used as unary predicates:
for instance, it accounts for the various meanings of "gold" as said
of (i) a piece of gold; (ii) some quantity of gold; (iii) something
made of gold.
Available as: ontological-level.ps
"...a rigorous ontological foundation for knowledge representation can
improve the quality of the knowledge engineering process, making it
easier to build at least understandable (if not reusable) knowledge
bases. We contrast the notion of formal ontology, intended as a
theory of the a priori forms and natures of objects, to that of
(formal) epistemology, intended as a theory of meaning connections .
We show in the following how theories defined at the epistemological
level, based on structured representation languages like KL-ONE,
cannot be distinguished from their "flat" first-order logic
equivalents unless we make clear their implicit ontological
assumptions by stating formally what it means to interpret a unary
predicate as a concept (class) and a binary predicate as a "role"
(slot). We need therefore to introduce the notion of ontological
level, as an intermediate level between the epistemological and the
conceptual one (Fig. 6) . While the epistemological level is the
level of structure, the ontological level is the level of meaning. At
the ontological level, knowledge primitives satisfy formal meaning
postulates, which restrict the interpretation of a logical theory on
the basis of formal ontology, intended as a theory of a priori
Available as: johnson.ps
Investigations into Database Management System Support
for Expert System Shells
Verlyn M Johnson
Many expert system shells are available for developing
production rule based expert system applications. However, it is
difficult to rapidly change those applications to respond to
changing business conditions. Each shell has its own production
rule language and inferencing capabilities. It is unclear what
information can be shared (reused). Use of main memory instead
of a shared, common source for rules constrains the size of
applications and can result in duplication. Maintenance is not
immediately available to existing inference sessions and
updates made by a session only affect that session.
This thesis approaches production rules and working storage as
data that can be managed by enhanced database management systems
(DBMSs). Five expert system shells are studied. A composite
(canonical) production rule syntax is developed which provides
knowledge engineers with a common language for production rules.
It is mapped into an integrated data model for use by tool
developers who wish to design common production rule storage
databases and maintenance tools. Extensions to the data model
allow expert system shell developers to reduce main memory
constraints by using a DBMS to store and manage execution data.
The analysis performed in building the data model reveals where
translation, system enhancements, or standard definitions are
required to share production rules.
Two DBMS enhancements are defined to facilitate management of
production rule and execution data (but which also have other
applications). Reflexive indexes enable a DBMS to incrementally
maintain transitive closures (including multiple tables,
duplicates, side paths, and accumulated values) as a database
index. They simplify query formats, and eliminate the need for
recursive processing during retrieval. One use is to accumulate
rule premise evaluation values during inferencing. The inference
locking protocol allows concurrent, dynamic access by those
maintaining and executing control data. For example, it provides
greater flexibility in maintaining production rules by allowing
knowledge engineers to use multiple versions and notification to
control how updates to production rules affect other maintenance
and inference sessions. The protocol can also be used to extend
production rule capabilities by allowing production rules to
maintain production rules concurrently with other maintenance and
Peter D. Karp and Thomas R. Gruber. A Generic Knowledge-Base Access Protocol. SRI International Technical Report, 1994.
Available as: gfp.ps
This document proposes a protocol for accessing knowledge bases stored
in frame knowledge representation systems (FRSs). The protocol,
called Generic Frame Protocol (GFP), provides a set of Common Lisp functions that
provide a generic interface to underlying FRSs. The interface layer
allows an application some independence from the idiosyncrasies of
specific FRS software and enables the development of generic tools
(e.g., graphical browsers, frame editors) that operate on many FRSs.
This Generic Frame Protocol can be viewed as an extension of the Ontolingua
system, which provides a way to define classes, relations,
and functions that can be translated into a variety of FRSs. Ontolingua is
for declarative specification only, and does not provide a way to store and
retrieve facts in a knowledge base. The Generic Frame Protocol allows one to
write applications that use knowledge bases, including ontologies written in
The GFP protocol is complementary to language specifications developed to
support knowledge sharing. KIF, the Knowledge Interchange Format,
provides a declarative language for describing knowledge. As a pure
specification language, KIF does not include commands for knowledge base query
or manipulation. Furthermore, KIF is far more expressive than FRSs. The
Generic Frame Protocol focuses on operations that are efficiently supported by
most FRSs (e.g., operations on frames, slots, facets; inheritance and slot
James G. McGuire, Daniel R. Kuokka, Jay C. Weber, Jay M. Tenenbaum, Thomas
R. Gruber, Gregory R. Olsen. Journal of Concurrent Engineering: Applications and Research (CERA), 1(2), September 1993.
Available as: shade-cera.ps, shade-overview.html
Effective information sharing and decision coordination are vital to
collaborative product development and integrated manufacturing. However,
typical special-purpose CAE systems tend to isolate information at tool
boundaries, and typical integrated CAE systems tend to limit flexibility and
process innovation. The SHADE (SHAred Dependency Engineering) project strikes
a balance between these undesirable extremes by supporting reconfigurable
exchange of engineering knowledge among special-purpose CAE systems.
SHADE's approach has three main components: a shared knowledge representation
(language and domain-specific vocabulary), protocols supporting information
exchange for change notification and subscription, and facilitation services
for content-directed routing and intelligent matching of information consumers
and producers. This report gives an overview and selected details of the
progress through year two of the SHADE project.
Kuokka, D.R., McGuire, J.G, Weber, J.C., Tenenbaum, J.M., Gruber, T.R. and Olsen, G.R.,
SHADE: Knowledge-Based Technology for the Re-Engineering Problem - 1993 Annual Report.
A variant on the published paper above
Available as: shade-overview.html
Effective information sharing and decision coordination are vital to
collaborative product development and integrated manufacturing.
However, typical special-purpose CAE systems tend to isolate
information at tool boundaries, and typical integrated CAE systems
tend to limit flexibility and process innovation. The SHADE (SHAred
Dependency Engineering) project strikes a balance between these
undesirable extremes by supporting reconfigurable exchange of
engineering knowledge among special-purpose CAE systems. SHADE's
approach has three main components: a shared knowledge representation
(language and domain-specific vocabulary), protocols supporting
information exchange for change notification and subscription, and
facilitation services for content-directed routing and intelligent
matching of information consumers and producers. This report gives an
overview and selected details of the progress through year two of the
M. A. Musen. (1992). Dimensions of knowledge sharing and reuse.
Computers and Biomedical Research, 25, 435-467.
Available as: musen-dimensions.rtf, musen-dimensions.binhex
Many workers in medical informatics are seeking to reuse knowledge in
new applications and to share encoded knowledge across software
environments. Knowledge reuse involves many dimensions, including the
reapplication of lexicons, ontologies, inference syntax, tasks, and
problem-solving methods. Principal obstacles to all current work in
knowledge sharing involve the difficulties of achieving consensus
regarding what knowledge representations mean, of enumerating the
context features and background knowledge required to ascribe meaning
to a particular knowledge representation, and of describing knowledge
independent of specific interpreters or inference engines. Progress
in the area of knowledge sharing will necessitate more practical
experience with attempts to interchange knowledge as well as better
tools for viewing and editing knowledge representations at appropriate
levels of abstraction. The PROTEGE II project is one attempt to provide a
knowledge-base authoring environment in which developers can
experiment with the reuse of knowledge-level problem-solving methods,
task models, and domain ontologies.
Mark A. Musen and Samson W. Tu.
Problem-Solving Models for Generation of Task-Specific
In: Cuena, J. (ed.) Knowledge-Oriented Software Design. Amsterdam:
Available as: musen-protege-ii.rtf, musen-protege-ii.binhex
Much current work on knowledge acquisition for intelligent systems
concentrates on the use of predefined models of problem-solving
methods to define the roles in which domain knowledge is used to solve
particular application tasks. Knowledge-acquisition tools that
incorporate such models impose task-specific architectures on the
knowledge bases that the tools are used to construct. PROTEGE-I is a
metalevel program that generates knowledge-acquisition tools tailored
for classes of application tasks. PROTEGE-I includes a model of
problem solving via the method of episodic skeletal-plan refinement
(ESPR). Knowledge engineers extend this model of problem solving with
domain knowledge to define models of relevant application areas.
Current research in our laboratory concerns a new architecture,
PROTEGE-II, in which knowledge engineers assemble the ESPR model using
a library of smaller building blocks, called problem-solving
mechanisms. In addition to providing flexibility in the definition of
the control strategy for the expert systems that PROTEGE-II ultimately
generates, the new architecture allows knowledge engineers to
represent static domain knowledge as explicit ontologies of concepts
and relationships that may themselves be resuable.
Available as: kse-overview.text
Robert Neches's executive summary of the ARPA KSE.
R. Neches, R. Fikes, T. Finin, T. Gruber, R. Patil, T.
Senator, & W. R. Swartout.
Enabling technology for knowledge sharing.
AI Magazine, 12(3):16-36, 1991.
Building new knowledge-based systems today usually entails
constructing new knowledge bases from scratch. It could instead
be done by assembling reusable components. System developers
would then only need to worry about creating the specialized
knowledge and reasoners new to the specific task of their system.
This new system would interoperate with existing systems, using
them to perform some of its reasoning. In this way, declarative
knowledge, problem-solving techniques, and reasoning services
could all be shared among systems. This approach would
facilitate building bigger and better systems cheaply. The
infrastructure to support such sharing and reuse would lead to
greater ubiquity of these systems, potentially transforming the
knowledge industry. This article presents a vision of the future
in which knowledge-based system development and operation is
facilitated by infrastructure and technology for knowledge
sharing. It describes an initiative currently under way to
develop these ideas and suggests steps that must be taken in the
future to try to realize this vision.
Available as: dl-spec.tex, dl-spec.ps, dl-spec-changes.text
DRAFT of the specification for Description Logics, produced by the
KRSS working group of the DARPA Knowledge Sharing Effort. updated July 1993.
"Description logics" are systems like those in the KL-ONE family
that support the definition of conceptual terminology. Examples
include CLASSIC, LOOM, and BACK. This document was produced by a
collaboration of an international community of researchers in the
area of description logics. [abstract by trg]
Available as: postscript (4M)
Gregory R. Olsen,
Jay M. Tenenbaum, &
Thomas R. Gruber.
Collaborative Engineering based on Knowledge Sharing Agreements
Procedings of the 1994 ASME Database Symposium,
September 11-14, 1994, Minneapolis, MN.
The design of products by multi-disciplinary groups is a knowl
edge intensive activity. Collaborators must be able to exchange in
formation and share some common understanding of the
information's content. The hope, however, that a centralized stan
dards effort will lead to integrated tools spanning the needs of en
gineering collaborators is misplaced. Standards cannot satisfy the
information sharing needs of collaborators, because these needs
cannot be standardized.
This paper discusses the design and use of a shared representa
tion of knowledge (language and vocabulary) to facilitate commu
nication among specialists and their tools. The paper advances the
opinion that collaborators need the ability to establish and custom
ize knowledge sharing agreements (i.e. mutually agreed upon ter
minology and definitions) that are usable by people and their
machines. The paper describes a formal approach to representing
engineering knowledge, describes its role in a computational
framework that integrates a heterogeneous mix of software tools,
and discusses its relationship to current and emerging data ex
R. S. Patil, R. E. Fikes, P. F. Patel-Schneider, D. McKay, T.
Finin, T. R. Gruber, & R. Neches. The DARPA Knowledge Sharing
Effort: Progress report. In Charles Rich, Bernhard Nebel, & William
Swartout, Ed., Principles of Knowledge Representation and Reasoning:
Proceedings of the Third International Conference, Cambridge, MA,
Morgan Kaufmann, 1992.
Available as: kr92-status-report.ps
C. Petrie, The Redux' Server. To appear in the Proceedings of the
First International Conference on Intelligent and Cooperative Systems,
Rotterdam, May 12-14, 1993.
Available as: redux-prime.tex, redux-prime.ps
Redux' is a subset of the full REDUX model.
The latter performs problem solving. In contrast Redux' does
not and acts only as a decision maintenance server. It takes
objects of types defined in an ontology of decision components and
maintains dependencies between them. Redux' is
domain-independent. The dependency relationships are maintained on the
basis of proposition type and not content, except for some string
matching. Redux' servers are proposed as a mechanism for
federating heterogeneous design agents by encapsulating their design
decisions within a simple model and providing coordination services,
especially for design revision. This proposal is described within the
context of the SHADE and PACT projects.
J. Van Baalen & R. E. Fikes.
Available as: KSL-93-67.ps
A capability for translating between representation languages is critical for effective knowledge base reuse. We describe a translation technology for knowledge representation languages based on the use of an interlingua for communicating knowledge. The interlingua-based translation process can be thought of as consisting of three major steps: (1) translation from the source language into a subset of the interlingua, (2) translation between subsets of the interlingua, and (3) translation from a subset of the interlingua into the target language. The first translation step into the interlingua can typically be specified in the form of a grammar that describes how each top-level form in the source language translates into the interlingua. We observe that in cases where the source language does not have a declarative semantics, such a grammar is also a specification of a declarative semantics for the language. We describe the conditions under which such a grammar is reversible so that the grammar can also be used to translate out of the interlingua. In particular, we formally describe the translation process into and out of an interlingua, present a method for determining whether a given grammar in fact specifies how to construct a translation for every top-level form in a given source language; and present a method for determining whether a given grammar is reversible so that it can be used to translate both into and out of an interlingua.
E. Walther, H. Eriksson, & M. A. Musen. Plug and play:
Construction of task-specific expert-system shells using sharable
context ontologies. Knowledge Systems Laboratory, Stanford
University, Technical Report KSl-92-40, 1992.
Available as: protege.tex, protege.ps