Knowledge Interchange Format Specification
Chapter 1: Introduction
Knowledge Interchange Format (KIF) is a formal language for the
interchange of knowledge among disparate computer programs (written by
different programmers, at different times, in different languages, and so
KIF is not intended as a primary language for interaction with human
users (though it can be used for this purpose). Different programs can
interact with their users in whatever forms are most appropriate to their
applications (for example frames, graphs, charts, tables, diagrams, natural
language, and so forth).
KIF is also not intended to be an internal representation for
knowledge within computer programs or within closely related sets of
programs (though it can be used for this purpose as well). Typically, when
a program reads a knowledge base in KIF, it converts the data into its own
internal form (specialized pointer structures, arrays, etc.). All
computation is done using these internal forms. When the program needs to
communicate with another program, it maps its internal data structures into
The purpose of KIF is roughly analogous to that of Postscript. Postscript
is commonly used by text and graphics formatting programs in communicating
information about documents to printers. Although it is not as efficient as a
specialized representation for documents and not as perspicuous as a specialized
wysiwyg display, Postscript is a programmer-readable representation that
facilitates the independent development of formatting programs and printers.
While KIF is not as efficient as a specialized representation for knowledge nor
as perspicuous as a specialized display (when printed in its list form), it too
is a programmer-readable language and thereby facilitates the independent
development of knowledge-manipulation programs.
The definition of KIF is highly detailed. Some of these details are essential;
others are arbitrary. The following general features are essential in the
definition of KIF.
In addition to these hard criteria, KIF is designed to maximize in a joint fashion
the following somewhat softer measures as well (to the extent possible while
satisfying the preceding criteria).
- The language has declarative semantics. It is possible to
understand the meaning of expressions in the language without appeal to an
interpreter for manipulating those expressions. In this way, KIF differs from
other languages that are based on specific interpreters, such as Emycin
- The language is logically comprehensive -- it provides for the
expression of arbitrary sentences in predicate calculus. In this way,
it differs from relational database languages (many of which are confined to
ground atomic sentences) and Prolog-like languages (that are confined to Horn
- The language provides for the representation of knowledge about the
representation of knowledge. This allows us to make all knowledge
representation decisions explicit and permits us to introduce new knowledge
representation constructs without changing the language.
- Translatability. A central operational requirement for KIF is
that it enable practical means of translating declarative knowledge
bases to and from typical knowledge representation languages.
- Readability. Although KIF is not intended primarily as a
language for interaction with humans, human readability facilitates
its use in describing representation language semantics, its use as a
publication language for example knowledge bases, its use in assisting humans
with knowledge base translation problems, etc.
- Implementability. Although KIF is not intended for use within programs
as a representation or communication language, it can be used for that
purpose if so desired.
Michael R. Genesereth