Knowledge Sharing Papers

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 papers

List of Titles

A table of contents listing the title of each document

Full Abstracts and availability

Abstracts of the papers, in author-sorted alphabetical order, complete with references and availability information.

Dates of posting are shown in (parentheses).

• 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).

Access Information

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.

Host: ksl.stanford.edu
Directory: /pub/knowledge-sharing/papers/

Formats

.ps

Postscript

.tex

TeX or LaTeX

.binhex

Binhex encoding of a Macintosh document

.rtf

Microsoft Word RTF interchange format

.Z

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 uncompress file.tar.Z tar -xvf file.tar

• A Translation Approach to Portable Ontology Specifications
• An Ontology for Engineering Mathematics
• An Ontology of Meta-Level Categories
• An overview of KQML: A Knowledge Query and Manipulation Language
• Collaborative Engineering based on Knowledge Sharing Agreements
• DARPA/Rome Laboratory Planning and Scheduling Initiative Knowledge Representation Specification Language (KRSL)
• Dimensions of knowledge sharing and reuse
• DRAFT of the specification for Description Logics
• Enabling technology for knowledge sharing
• Investigations into Database Management System Support for Expert System Shells
• KIF Abstract
• Knowledge Interchange Format, Version 3.0 Reference Manual
• Knowledge Sharing Technology Project Overview
• Ontolingua: A mechanism to support portable ontologies
• Overview of the ARPA Knowledge Sharing Effort
• PACT: An experiment in integrating concurrent engineering systems
• Plug and play: Construction of task-specific expert-system shells using sharable context ontologies
• Problem-Solving Models for Generation of Task-Specific Knowledge-Acquisition Tools
• SHADE: Technology for Knowledge-Based Collaborative Engineering
• Specification of the KQML Agent-Communication Language
• The DARPA Knowledge Sharing Effort: Progress report
• The Ontological Level
• The Redux' Server
• The Role of Common Ontology in Achieving Sharable, Reusable Knowledge Bases
• The Role of Reversible Grammars in Translating Between Representation Languages
• The Role of Standard Knowledge Representation for Sharing Knowledge-Based Technology
• Toward a knowledge medium for collaborative product development
• Toward principles for the design of ontologies used for knowledge sharing.

DARPA/Rome Laboratory Planning and Scheduling Initiative Knowledge Representation Specification Language (KRSL)

Available as: krsl.tar.Z (postscript files)

Abstract:

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).

PACT: An experiment in integrating concurrent engineering systems

Available as: pact.html, pact.ps, pact.tex

Abstract:

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.

Knowledge Sharing Technology Project Overview

Available as: kst-project.ps, kst-project.rtf (MS Word)

Abstract:

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.

An overview of KQML: A Knowledge Query and Manipulation Language

Available as: kqml-overview.ps

Abstract:

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.

Specification of the KQML Agent-Communication Language

Available as: kqml-spec.ps

Abstract:

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.

Knowledge Interchange Format, Version 3.0 Reference Manual

Available as: kif.tex, kif.ps

Abstract:

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.

KIF Abstract

M. R. Genesereth. Knowledge Interchange Format. Principles of Knowledge Representation and Reasoning: Proceedings of the Second International Conference, Cambridge, MA, pages 599-600. Morgan Kaufmann, 1991.

The Role of Standard Knowledge Representation for Sharing Knowledge-Based Technology

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

Abstract:

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 KBs.

The Role of Common Ontology in Achieving Sharable, Reusable Knowledge Bases

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

Ontolingua: A mechanism to support portable ontologies

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).

Abstract:

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 discussed.

A Translation Approach to Portable Ontology Specifications

Available as: ontolingua-intro.rtf, ontolingua-intro.binhex, ontolingua-intro.ps

Abstract:

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.

Toward principles for the design of ontologies used for knowledge sharing.

Available as: onto-design.ps, onto-design.rtf, onto-design.binhex

Abstract:

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.

An ontology for engineering mathematics

Available as: engmath.html, engmath.ps

Abstract:

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.

Toward a knowledge medium for collaborative product development

Available as: shade.tex, shade.ps

Abstract:

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.

An Ontology of Meta-Level Categories

Nicola Guarino, Massimiliano Carrara, and Pierdaniele Giaretta
LADSEB-CNR Int. Rep. 6/93, Preliminary version - November 30, 1993.

Available as: meta-level-categories.ps

Abstract:

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.

The Ontological Level

Nicola Guarino

Available as: ontological-level.ps

Abstract:

"...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 distinctions..."

Investigations into Database Management System Support for Expert System Shells

Available as: johnson.ps

Investigations into Database Management System Support for Expert System Shells

Verlyn M Johnson <VERLYN@RCHVMP.IINUS1.IBM.COM>

Abstract:

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 inference sessions.

A Generic Knowledge-Base Access Protocol

Available as: gfp.ps

Abstract:

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 Ontolingua.

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 constraint checking).

SHADE: Technology for Knowledge-Based Collaborative Engineering

Available as: shade-cera.ps, shade-overview.html

Abstract:

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.

SHADE: Technology for Knowledge-Based Collaborative Engineering

A variant on the published paper above

Available as: shade-overview.html

Abstract:

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.

Dimensions of knowledge sharing and reuse

Available as: musen-dimensions.rtf, musen-dimensions.binhex

Abstract:

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.

Problem-Solving Models for Generation of Task-Specific Knowledge-Acquisition Tools

Available as: musen-protege-ii.rtf, musen-protege-ii.binhex

Abstract:

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.

Overview of the ARPA Knowledge Sharing Effort

Robert Neches

Available as: kse-overview.text

Abstract:

Robert Neches's executive summary of the ARPA KSE.

Enabling technology for knowledge sharing

Abstract:

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.

DRAFT of the specification for Description Logics

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.

Abstract:

"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]

Collaborative Engineering based on Knowledge Sharing Agreements

Available as: postscript (4M)

Gregory R. Olsen, Mark Cutkosky, 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.

Abstract:

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 change standards.

The DARPA Knowledge Sharing Effort: Progress report

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

The Redux' Server

Available as: redux-prime.tex, redux-prime.ps

Abstract:

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.

The Role of Reversible Grammars in Translating Between Representation Languages

J. Van Baalen & R. E. Fikes.

Available as: KSL-93-67.ps

Abstract:

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.

Plug and play: Construction of task-specific expert-system shells using sharable context ontologies

Available as: protege.tex, protege.ps