Environment KEE

Knowledge Engineering Environment KEE

KEE from Intellicorp is the most widely used of the high-end expert system development shells. It is available on Symbolics, Xerox and Texas Instru- ments Artificial Intelligence workstations, Apollo, DEC and Sun workstations,DEC VAX mini computers and 80386-based IBM PC-compatible computers. It provides a powerful and sophisticated development environment, offering hierarchical object representation of data and rules, partitioning of the rulebase, an inference engine providing agenda-driven chaining in addition to backward and forward chaining, and a Truth Maintenance System for what-if and assumption-based reasoning. It offers a suite of development tools, such as specialized structured editors and several methods to build the data structures, induding menus and an English-like construction language. A sophisticated graphics toolkit allows the creation of user interfaces which canbe directly driven by the data values in the knowledge base. KEE has facilities to call the C language, direct two-way communication with SQL-based database systems (through KEEConnection) and on IBM PCs and compatibles the ability to call on PC applications, datafiles and resources. A distributed processing version ofKEE, called Rim-TimeKEE, allows a host VAX computer to support KEE applications whose interfaces reside on PC terminals. Intellicorp also offers SIMKIT, an object-oriented simulation package built on KEE which integrates simulation and expert systems.

James Martin 1988 KEE/ 1 Functionality Matrix

CD IBM Mainframe Environment DEC Environment PC Environment Micro-to-Mainframe Link MF&PC Implementation ujW CD LAN Support cc _| 2 High-End Workstations 50< Other Al Workstations o 9_ Machines 5 > LISP S 2 CD LISP Co-Processor x UJ BS_ Hooks to External Sequential Files Hooks to Mainframe DBMS: R/W to File UJ Hooks to Non-IBM Mini DBMS: R/W to File O □ Hooks to PC DBMS/Spreadsheets -32. Hooks to Procedural Languages coy CD Security Forward Chaining Backward Chaining UJ Agendas O r_!_ u_ w Multiple Agendas cc 2 Demons ES 5 Flexibility of Conflict Resolution *(_

Inductionfrom Example Data UJ 5 O Flexibility of Rule Languages Q 5 Flexibility and Types ofFacts UJ 5 Flexibilityof Frames 3 Object-Oriented Language Confidence Factors * 4 InferenceTrace cc 3 Knowledge Base Entry v 4 Compiler/Interpreter 2 5 Breakpoints UJ pJ 5 Knowledge Tree Cv o Data Dictionary OP

4 Screen Generation cc 3 Reports and Forms Generator UJ 4 Data Editor ?!_. 2 Natural Language DO Interface 2 O 5 Advanced Query Language UJ P

■I full function EH partial function 5 optimal -> 1 minimal O not available

CL CO Product Information Software KEE Version 3.0 for workstations KEE Version 3.0 for 80386-based IBM-compatible PCs KEEConnection SimKit " Run-Time KEE KEE Versions 1.0 & 2.0 and Intelliscope are no longer sold.

Pricing KEE Version 3.0 (workstations) $46,500 academic price $9,250 KEE Version 3.0 (386 PCs) $9,900 KEEConnection $15,500 (varies with hardware) academic price $5,000 SimKit $21,000 academic price $4,125 Run-TimeKEE (single-user workstation) $5,000 Pricing varies, depending on number of licenses purchased, and indudes 3-9 days training for 2 persons and one year's support. Support services indude standard consultants, senior scientist consultants and/or apprenticeship training (4 weeks).

Hardware all 80386-based IBM PC-compatible computers IBMPC RT Symbolics 36XX series Xerox 1100 series Sun 3 workstations Apollo Domain workstations TI Explorer I and II DEC VAX series MicroVAX II workstations

For more informationon KEE, KEEConnection & SimKit, contact: Intellicorp 1975El Camino Real West Mountain View, California 94040-2216 U.S.A. Telephone: 415-965-5500

The Martin Report View ofthe Product 5

Product Overview 7

\. Product Environment 9

j Product Components 10 _ Knowledge Representation 16

j Developer Interface 24 \ User Interface 26 i' j Documentation & Support 28 f Product Strengths 28

Product Limitations 29

Technology Development Intellicorp's Knowledge Engineering Environment (KEE) is a sophisticated Environment expert system shell that has migrated from high-end AI workstations to micro computers, general-purpose workstations and VAX mini computers. The complete KEE development environment is now available on 386 PCs for about 1/4 the cost of the AI workstation version and within the mid- range of expert system shell prices. It is one of the richest expert system shell environments, providing the user with a broad range of knowledge representation and inferencing mechanisms, as well as an unusuallypower- ful graphics interfacing capability. It has some of the most powerful and flexible development support available. KJ__E's chief weakness is its lack of full integration with MIS systems, althoughrecent extensions are beginning to overcome the problem. Intellicorp offers a powerful linkbetween SQL- based database management system andKEE, allowing partial integration into the MIS environment. C language calls are available on some hardware for access to MIS applications. KEE applications can be very portable ifthe developer restricts the application to the tools provided within the KEE environment and avoids use of lISP. The only platform dependencies of the KEE environment are screen sizes, fonts and any LISP usedby the application developer. Functionality KEE supports a variety ofknowledge representation including facts, rules, objects, demons andprocedural code. TheKEEWorlds truth maintenance system allows a user to efficiently build expert systems in domains that other shells would not support well, such as planning, scheduling, what-if analysis and any problem that includes independent subproblems. The agenda-driven inference engine and rule clauses allow much greater separation of data (rules, facts and frames) and control (how and when to applyrules) than other shells. It supports the forward andbackward chain- ingfound in other shells in fact, several types of each. Finally, the agenda architecture enables— the easy construction of a blackboard architecture for control. Several types of problems can be solved well usingblack- board architectures, notable signal and data interpretation applications. Developer The developer interface is flexible, offering several ways of building the Interface expert system, ranging from pseudo-English commands, to mouse with graphic icons and menus, to IISP-likefunctions. It can, therefore, accommodate any userfrom a relative novice to an AI and LISP expert. However, KEE requires more training than do most other shells for effective use of the myriad features it contains. KEE has excellent tracing facilities that allow monitoring of not onlyrule execution, but also of changes to the data values in frames. The changes can be shown as graphic images, such as dials or gauges. It allows the changing of data values at breakpoints in the execution and the addition or deletionof facts.

© James Martin 1988 KEE/5 The PC version ofKEE requires a substantial amount of memory. Intellicorp recommends that the 386-based PC version be run with 10MB ofRAM and a 100MB hard disk. The complexity ofKEE causes some loss of efficiency, even on AI workstations. Some users have felt it runs slowly. Comparison The expert system developer can use KEE to develop either an expert, -with Trends stand-alone, decision-making system; a specialized advice-giving assistant to an expert; or a simulation system for exploring alternatives. TheKEE explanation facilities do not, however, provide the depth of explanation representation necessary to easily build good educationor training systems orfor building good second opinion, advice-giving systems. Although the knowledge representation inKEE provides more than enough sophistica- tion to represent the domains of such systems, the support of explanation facilities is meager, providing only traces of a system's deductions or the sequence ofrule firing. It does not provide a facility for automatically providing even "canned" English text to explain the reasoning behind a rule (much less a more sophisticated explanation).

Strategy Genetic TheKnowledge Engineering Environment (KEE) from Intellicorp is an Engineering integrated development facility for building andrunning expert By-Product systems. Developed in 1983by IntelliGenetics Inc. as a general purpose tool to help build expert systems, KEE was a by-product of their experience developing their first product, a genetic engineering AI system. The genetic engineering part of the company has been sold, making KEE and related products the sole focus of Intellicorp. TheKEE system is now in use at over 250 sites. Additional The initialKEE product was introduced in 1983 on high-powered AI work- Products stations such as the Symbolics LISP Machine and the Xerox AI workstation. Intellicorp introduced KEE on the TI Explorer in early 1985 and by the end of 1985 had announced two additional products to extend itself beyond the AI workstation market ~ SimKit and the PC-Host delivery system. SimKit took advantage of the object-oriented model underlyingKEE to implement a simulationbuilding package that is easily integrated into a KEE expert system. Intellicorp also showed, with PC-Host, that it understood customers' need for integration of expert systems with their traditional computing environment. PC-Host allows KEE to run as a delivered product in a distributed fashion, with a central VAX or Symbolics host running the core ofKEE while one or many PC compatibles handled the graphics interfacefor the KEE user. In 1986,KEE was migrated to conventional desktop workstations, first the Sim 3 family of workstations, then the Apollo Domain workstations. To further broaden KEE's usefulness, KEEConnection was announced in early 1987, along with Intelliscope. KEEConnection links a KEE application with an SQL-compatible database management systemresiding on the same host or network. KEEConnection was developed initiallyfor Symbolics machines and has been recently extended to support Sun 3 workstations. It provides a connection to the SQL-based ORACIE database and implements a bridge between the external database andthe KEE knowledge base.

6/KEE © 1988 James Martin Advanced Intelliscope was an "intelligent database assistant" built on KEEConnection, QueryProduct for browsing, searching and analyzing databases. It was withdrawnfrom the market in early 1988 and is currently being used as a component of customized KEE-based applications running on Symbolics processors. In mid-1987, theKEE/C integration toolkit was announced, a set of tools and functions for mutual calling between LISP (in whichKEE is written) and C. Intellicorp continues to migrateKEE to other workstations, and unveiled the 80386-basedIBM PC version ofKEE in 1987. Though it has an agreement with IBM to jointlywork on a version ofKEE running on IBM equipment (probably mainframes), Intellicorp is placing a greater emphasis on vertical integration. It is pursuing consulting as a business and packaging its expert systems consultants with KEE systems to seed businesses with applications. It is also entering in jointventures to develop application and tools.

Product Overview Complex Toolset TheKEE product provides developers with a powerful and flexible set of tools suitable for building large, sophisticated expert systems. Because the development system is complex, it is not geared toward a casual developer who is simply curious about the capabilities of expert systems. However, this very complexity provides KEE with the functionality required to support effective solutions in domains where simpler shells cannot. A developer can initially use KEE for a pilot expert system and later extend the pilot system to a full application. KEE is well-suited for applications in many areas. Its rich inference facilities and detailed, highly-graphical developer's facilities give it distinct advantages over other products in the general areas listed inBoxKEE-1. For business applications, KEE has been used for a variety of expert systems in virtually all areas of business, some of which are also listed inBox KEE-1.

Knowledge engineers have a wide choice of knowledge representations in KEE includingrule-based, form-based, object-oriented and procedure- oriented. It supports both forward and backward chaining. Aknowledge engineer can tailor the solution strategy to be data-directed, goal-directed or both or can enlist use of an agenda. Truth In its support ofreasoning under uncertainty, KEE does not represent Maintenance uncertainty by Bayesian methods or certainty factors. Instead, it provides an advanced form ofTruth Maintenance, which allows efficient reasoning with assumptions, alternatives, constraints and deductions based on them. Graphical With KEE's object-oriented graphicspackages, KEEPictures and Active- Interfaces Images3, as well as its graphical debuggingtools, knowledge engineers can design easy-to-use graphical interfaces for the application system. Recent KEE-related products include: KEEConnection - used to access databases external to the KEEsystem (currently available on Symbolics machines and Sun workstations to access ORACLE databases).

SSB

Wfflimimfflm wsvHEmjmm

" RESOURCE ALLOCATION " WHAT-IF ANALYSIS " SIGNAL OR DATA INTERPRETATION (where a blackboard expert system architecture is useful) " SIMULATIONMODELING

issi^^li^^^SßiSiSii

" MANAGEMENT - forecasting, planning & project management FINANCE & ACCOUNTING - financial statement analysis, credit " assessment " OPERATIONS - design, layout, scheduling, diagnosis & correction, process control, cell design, maintenance " SALES — airline seat discount management " PERSONNEL -training

BoxKEE-1: KEE Applications

8 /KEE 1988 James Martin IntelliScope - used to provide an integrated expert system environment for intelligently querying, browsing and analyzing databases (Intelliscope has been temporarily withdrawnfrom the market).

Product Environment Portable Any application written withKEE using the Commonwindows, Active- images andKEEPictures graphics facilities is easily ported to other hardware platforms. All the development versions ofKEE support the same set ofKEE features with the following exceptions: LISP languageincompatibilities: To the extent that the application relies on the underlyingLISP implementation, incompatibilities between different versions ofLISP may cause problems. calls to C language: C language support underKEE is currently available only on the Sun family of workstations and will soon be extended to the VAX versions ofKEE.

size ofscreens

fonts: KEE uses the fonts available on the host operating system (which are not consistently defined across platforms). Access via C All KEE development systems allow access to the underlying LISP to LISP, C Sc language on all hardware platforms. KEE on the Sun workstations Applications currently offers functions calling to andfrom the C language. This facility will also be available infuture releases for the DEC VAX computers. This gives the ability to access other applications to the extent they are callable from C.

Hardware KEE 3.0 is available on Digital VAX family of mini computers, MicroVAX II workstations, Sun 3 workstations, Apollo Domain workstations, Sym- bolics 3600workstations, Xerox AI workstations, TI Explorer I and II workstations and 80386-based, IBM-compatible PCs. AKEE application can also be delivered in a distributed version with a DEC VAX VMS server and 286-based PC compatible workstation, where the PC handles the KEE user interface graphics, and the VAX server manages the reasoning and knowledge base. Intellicorp and IBM have recently announced a joint agreement to port KEE to IBM environments.

Channels to TheKEE system comes in two main hardware configurations, as a External development system and as a delivered system. The development Software configuration runs on any Symbolics AI workstation, Xerox AIworksta- Systems tion, Texas InstrumentsExplorer workstationand the Sun-3 family of workstations. All of the development systems can also serve as delivery systems. KEE is also available in aPC and host mini computer configuration, as a delivery system only. The PC and mini-computer host configuration is available with any member of the VAXfamily of computers serving as the host and any IBM PC, PC compatible or Apple Macintosh as the PC.

© James Martin 1988 KEE/9 TheKEE PC-HOST system puts the facilities forreasoning with, representing and explaining the knowledge base on the host mini computer. All the user interfacefunctions of the KEE systemreside on the PC. These include the graphical representation of the elements of the knowledge base. Because many PCs support color graphics, the PC-HOST configuration uses an extended interface which allows the developer to take advantage of color graphics in designingthe user interface.

The PC-HOST system comes with software tools to aid the developer in porting and installing a developed KEE application system from the development environment to the PC and VAX host system.

Product Components The core of the KEE system consists of its frame-object knowledge base, agenda-based inference engine and inference-maintainingKeeWorlds system. It is available in two configurations, a development system and a delivery system. FigureKEE-1 illustrates the integration ofKEE with the system environment and Figure KEE-2 shows the integrated functionality of the product.

Common Interface Facilities KEE user interface facilities include a very flexible command environment, good explanation facilities and full support of debugging and training facilities. TheKEE user and developer interfaces on workstations includes a rich variety offunctions, driven bycommands, menus, mouse use on menus, icons, windows and graphics, as well as KEE's pseudo-English Tell&Ask language. The user can switch from activity to activity. For example, the user can move from data entry to viewing the rule tree simply by selecting the window for that activity with the mouse. Parts of the system can be commanded from graphic interfaces which represent the options as buttons or switches to be set. Commands can be completed or arguments can be entered by selecting the appropriate object(s) withthe mouse in some cases.

Explanation ofrules is limited to HOW andWHY reports, in a combination of text and graphical displays. WithKEEPictures and Activelmages, a developer can incorporate other types of explanation as needed, using pictures, animation or plain text.

The inferences made in a consultation can be viewed as a graph, at the end of a consultation. Inferencing can also be tracked with KEE's tracing facility, to show its progress in both forward and backward chaining. A developer can also easilybuild a monitor to showchanging values of important data objects during the consultation. When KEEWorlds are being used, the progress of the consultation is shown in the World's browser. The user can direct the KEEWorld's inferencing with the browsingfacility if desired.

Security maintained by DBMS

Figure KEE-1: Integration ofKEE with System Environment

SYMBOLICS ASCII text VAX-PC LISP IBM 386 PC MS-DOS via KEE Distributed Calls to C DEC VAX Ultrix Connection System Micro VAX II VMS, Ultrix Sun, Apollo Tl Explorer Xerox 1100

Figure KEE-2: Integrated Product Functionality

SQL-based

VMS, The rule base can be displayed in a lattice showing the inferencing dependencies. The knowledge base can also be displayed graphically in a lattice to show inheritance relationships, and manipulated with the mouse. The knowledge base lattice can be built using the mouse on its lattice graph.

External System Interface WSP&C KEE provides only direct access to the underlying code unless additional facilities are purchased. It now provides LISP and (through foreign function calls) C access. Access to LISP is possible on all hardware platforms. C access is currently available on the Sun workstation version ofKEE, from KEE to C and from C to KEE. Intellicorp plans to provide the same capability for KEE systems hosted on VAX computers. C access will not be provided on AI workstations and is not currently planned for the IBMPC version of KEE. Both LISP and C giveKEE read/write access to sequential files. TheKEE system presently provides integration with Intellicorp's SIMKIT, an object-oriented simulation designing tool and with interfaces to several packages on PCs, including spreadsheets and databases. The Intellicorp SIMKIT product allows users to build simulations by graphicallybuilding up com- posite objects and definingthe relationships and connections between objects. It provides a libraryofready-made objects for several applications which may be easily modified for re-use. KEE is integrated with packages on PCs including interactionwith several spreadsheets and databases. These interfaces are available onlywith the PC-HOST configuration ofKEE, not in the development workstation environment. KEE cannot invoke PC application or be invoked by them except through user-written Croutines. No PC The only types ofPC files KEE is currently able to read or write are File Access ordinaryASCII textfiles or bitmap graphics files. Intellicorp plans to provide access for several formats ofPC files in later releases, including Lotus' 1-2-3,DDE and database files. SQL/Based Intellicorp offers communication with SQL-based database systems on the Databases Symbolics family of computers in a separate package called KEEConnec- tion. KEEConnection provides a mapping editor whichtranslates a request for information into an SQL query and transmits the query to the data base server ifthe system is networked. Mappings include one-to-one, one-to- many, many-to-one, transformation of datafrom one type in the database to another inKEE and vice-versa and computation of a newvalue from several data values.

Data can be downloaded from the database to KEE and uploaded from KEE to the database at any point the application calls for it, either as a procedural part or to find a value called for in arule premise or conclusion. The trans- mittal of datacan be optimized for efficiency of access. KEEConnection keeps track of whichinformation has passed between the two systems. The product can generate quite sophisticated queries and permits efficient management offile access facilities. KEEConnection currently supports ORACLE, INGRES, BRITTON LEE RS3OO and IDMSOO. KEEConnection relies on the external database management systems to enforce security and understands the types of security supported by the DBMS.

Interface Building Tools Interface To build and use the systems, KEE provides graphicinterface building tools Building Tools via: KEEPictures and Activelmages3; Tell&Askpseudo-English language; structured editors; and libraryofKEE-specific LISP functions. Built around these tools and the desktop, window and mouse environment, KEE provides explanation and debuggingfacilities. The development environment includes all of the above facilities; the delivery system lacks the editing and debugging tools. When the product is delivered in the PC/HOST environment, the graphical interface components are separated from the rest of the delivery system, withthe graphical subsystems remaining resident on the PC and the core reasoning functions residing on the mini-computer host. KEE's knowledge base is an object-oriented system which allows the developer to define classes of objects and specify inheritance relationships between them. The actual data of the system are contained in instances members ~ of the classes. —

Structure ofKnowledge Base Objects & The object and frame approach to knowledge representation provides the Frames developer with a variety of options to structure the knowledge in the knowledge base, making it possible to represent domains clearly, maintain the representation easily and create simulations quickly. The dass and subdass representation does away with the need for rules torepresent inheritance information, such as Ais aB. The integrated representation system ofKEE indudesrules in the object and frame hierarchy, allowing a developer to represent structural relationships between rules, unlike many systems. This is a significant aid to development and maintenance and, as used inKEE, can provide an increase in execution efficiency.

Rule-Firing Agenda Rule-Firing Some expert systems and expert system shells, especially simpler ones, Agenda build in the inference methods which decide whichrule to fire at a given cyde of the system, often choosing an arbitrarycriterion such as the order of the rules in the file defining them. Other systems, induding KEE, allowthe developer to control the order in whichrules are chosen to be applied. KEE uses an agenda system, which keeps all the rules which could fire on a list and on each cyderemoves the rule at the front of the list and places any rules which match on new data into the appropriate place on the agenda.

14/KEE © 1988 James Martin The method for ordering rules on the agenda can be controlled by the developer, and KEE supplies several default methods (described later). Control/Data The KEE inference engine is both forward- and backward-chaining and Separation maintains an agenda for each type of chaining; which enables agenda- driven chaining to be easily implemented. The system provides several ordering methods for agendas which allowuser-defined ordering or efficiency-based ordering and three chaining techniques for backward chaining breadth-first, depth-first and "best"-first. With agenda-driven chaining, knowledge— about how to proceed when solving the application system problem can be isolated from knowledge about the structure of the application. The former can be represented in the inference engine, whilethe rules can be reserved for knowledge about the application. In other words, control can be separated from data. lines of TheKeeWorlds facility supports KEE's state-of-the-art Truth Maintenance Reasoning system. It maintains arecord of the inferences made byrules and organizes the collections offacts into compatible sets, called contexts. Several lines of reasoning can be pursued simultaneously, based on different alternatives or different assumptions, and these lines ofreasoning can be compared or combined. When the knowledge base of a particular context becomes contradictory, the KEEWorlds facility can "backtrack" to a new context where only the contradictory data andreasoning is removed. This capability is especially useful for expert systems in the planning domain.

Command Interface Command TheTell & Ask language provides a pseudo-English command interface Interface to create and alter objects in the knowledge base, as well as access information in the knowledge base. It can also be used as dauses in a rule, making the rule somewhat easier to understand.

Graphics Facility Graphics The graphics facilities,KEEPictures and Activelmages3, allowthe Customization developer to easily build a graphical interface to the application system which can animate, display information and get user input through changes in graphical information. They make the user interface easy to customize. They also allow the developer to easily build a knowledge engineer's interface which, in the words of one user, is a "programmer's dream."

Editors Specialized The KEE editors indude not onlystandard AI Workstation editors but Editors KEE-specific specialized editors, as well. For example, the rule editor will parse certain parts of the rule as they are entered and will parse the entire rule when the editor is exited. These functions detect a large dass of errors. Function KEE-specific LISP functions allow the proficient developer access to the Power entire power of the KEE system. In addition, the functions can be incorporated in the system rules, allowing sophisticated manipulation of the expert system.

© James Martin 1988 KEE/ 15 DebuggingFacilities Debugging KEE debuggingfacilities indude excellent displays of trace information, Traces which are easilychanged while the system isrunning, static analysis of the rules' interdependendes displayed in graph form, numerous graphical traces of the running system, breakpoint setting facilities and, through the graphics tools, the ability to easilycustomize a flexible developer's interface. How- ever, the system does not allow easy examination of the inference engine operations. This is possible only through those facilities provided by the lISP environment of the host workstations or directly through LISP language.

Explanation Facilities

Only Simple Explanation facilities in KEE are much less developed than other parts Reasoning of the system. A user can only get a simple trace of the system's Traces reasoning behind a givenfact, augmentedby comments attached to the rules invoked in performing the reasoning. Other systems allow such things as attaching text explanations to rules (which are automatically supplied when explanation is desired) or building models of the domain (which indude higher-level explanations to give the theoretical background for a sequence ofrules.) Knowledge Representation Instance The knowledge about an application isrepresented in KEE by a hierarchy Objects offrames or objects, aknowledge representation technique which allows multiple inheritance. This is inherently a more powerful way to represent knowledge than the simple rule-based methods usedby many expert system tools. In an object-oriented system, all entities in the application are objects and are defined in a lattice or tree of dasses and subclasses which terminate in the Instance objects, which contain data. All dass and subclass objects are also instances of higher classes of objects. Instance objects can be equipped to respond to messages sent to them: a message causes the invocation of a function local to the object, called a method. In KEE, an object is a frame unit, which consists of a collection of slots. Slots are composed of associated methods. Groups offrame hierarchies for a specific application are stored in a file called a Knowledge Base orKB. Rules are also represented as objects and can be organized in a hierarchy of dasses and sub-classes. This allows the system builder to organize knowledge about the application in an under- standable, logical fashion. Knowledge about unchanging aspects of the application can be modeledwith frame objects. Interactions between different parts of the application and changing aspects of the application can be modeled with rules and with methods attached to frame Units. Ways ofreasoning about the application and drawing condusions can also be captured in rules, ~ the basis for using expert systems. Truth Certain dasses ofrules in KEE invoke the KeeWorlds Truth Maintenance Maintenance facility, allowing users to reason efficiently about alternatives and constraints. TheKeeWorlds facility creates representations of deductions, called justifications. The justificationsrecord the deductions made byrules, so that

16/KEE © 1988 James Martin changes in assumptions or alternatives can be made withoutundoing a deduction which does not depend on the former assumption or alternative. Rules which make choices inreasoning between alternatives create different sets offacts for each choice, called worlds or contexts. Users can solve certain problems efficiently with this facility; e.g., planning problems, planning with constraints, such as resource allocation and scheduling applications and problems of data interpretation where data is poor or multiple problems produce the data. TheKEEWorlds Browser, described in the Developer Interface section, allows examination and comparison of the different "worlds" created by an application.

InheritanceProperties ofFrames & Objects Units, Slots The object-oriented method ofrepresenting frames, used in KEE, places & Facets each frame in an inheritance lattice of dasses and subdasses. Aknowledge base is a collection of such lattices. An object (or frame) represents one dass or subclass in the lattice, called a Unit inKEE. Each Unit is described by the Slots which make it up, either its own or inherited from ancestor(s) in the lattice. Each Slot iscomposed ofFacets, one to hold the value of the Slot and others to describe various parameters of the Slot and its values. Units are connected in a latticeby links between the dass Unit and its subdasses, often referred to as parent and children. Each subdass Unit can, in turn, have its own subdasses, for which it is the parent. The KEE representation allows a subdass to belong to more than one dass, so it may inherit "characteristics", that is, slots and their definitions, from more than one parent dass. For example, a frame Unit to define an oil and gas partnership subdass might inherit attributes from two parents, an oil and gas venture Unit and a limitedpartnership Unit. A designer may control inheritance from a dass by designating slots in the dass frame as either own slots or member slots. Own slots may be changed by all rules, while member slots can be changed only by one predefined type ofrule. Inheritanceby a child Unitcan also be controlled by setting inheritance parameters in the child Units. KEE also distinguishes between subdass Units of a dass and member Units of a dass (called instances in some object-oriented programming languages). Both are aescendants, but member Units inherit their slots differently from subdass Units: subdass Units inherit member slots of their parents as member slots which are passed on to their own subdasses, while member frame Units inherit all slots as own slots. Akey difference between the object representation and standard frame hierarchies is that a function which applies to the frame can be stored in one of the frame slots. Suchfunctions are called methods in object-oriented programming and are invoked by a message to the object which contains them. Method functions canbe inherited, modified and added to by the frame's descendants. The knowledge engineer can encode knowledge in the most appropriate form, induding procedural forms, using objects with methods. Simulations are especially easilyrepresented by this approach.

© James Martin 1988 KEE/ 17 Building the KEE provides three interfaces for building knowledge bases, using three Knowledge Base different approaches. mouse-driven menus; Tell & Ask pseudo-English language; LISP procedural language. For users unfamiliar withLISP, the elements of a KB can be built interactively usingthe mouse with menus or to a limited extent by using the Tell & Ask logic language. The Tell & Ask facility provides users a means for fram- ing statements of propositional logic in a pseudo-English format (and a prefix format as well). As in the Prolog language, statements can be used to match available information or to assert or retract information. Users familiar withLISP may use KEE functions directly, which correspond to the Tell & Ask and menu commands. Any mix of the three approaches can be used. Knowledge engineers can build the knowledge base by mouse and menu by selecting the appropriate command from the command menu applicable to that part of the knowledge base. The appropriate menu can be reached by selecting with the mouse the part of a representation which the user wishes to work on. A typical menu structure for KEE World commands contains the following items: AddFacts Display Unit Compare Worlds Explain Create Exdusion Set Query Facts Create World Show Changes Delete Facts Show Facts Destroy World

To construct the knowledge base interactively using Tell & Ask, the user types commands into the Lisplistener window, after selecting a knowledge base to workwith. The ASSERT function is used to build the knowledge base, e.g:

(ASSERT *(AI_L PHILLIPS* HEADS ARE SCREWDRIVERS ) (ASSERT '(ALL TORX ARE SCREWDRIVERS)) > The QUERY function can be used to queryfacts stored in the knowledge base, e.g.,

(QUERY '(ALL ?Z ARE SCREWDRIVERS) NIL NIL :HOW.MANY 'ALL) The system would reply to the QUERY with: ((ALL PHILLIPS,HEADS ARE SCREWDRIVERS) (ALL TORX ARE SCREWDRIVERS)) UsingKEE functions inLisp, the user would enter: (Create* slot ' (Foo kbnarae) 'slotnaroe *own)

18 /KEE © 1988 James Martin Rules & Worlds Rules inKEE provide the designer withmore structure in their creation and application than conventional rule-based reasoning systems. Three dasses ofrules are supported to: provide the conventional power of production rules, represent deductive inferences from the facts of the system and provide the framework forreasoning about alternative assumptions or alternative actions. The first typeof rules can also be used to simulate events in the model of the application domain which makes up the expert system knowledge base. Assumptions Certain dasses of problems require the solver to make assumptions about what could be true or which steps might solve a problem and determine which set of assumptions are consistent withwhat is known about a problem domain or which steps arrive at a solution without violating constraints of the problem. KEEWorlds provides an efficient way ofrepresenting this type ofreasoning in a system which uses rules to represent reasoning steps. This kind of system is called a Truth Maintenance System. It automatically maintains sets ofconsistent and inconsistent assumptions, in a way which allows the system to "undo" onlythose assumptions or steps which lead to contradiction, while keeping reasoning steps which did not depend on the contradictory assumptions. (Example 2).

Because rules are represented inKEE as objects, the knowledge engineer can organize the rules into useful dasses and subdasses to enhance clarity by reflecting the underlyingprinciples of the application in that organization. The rule organization can also be used by the solution strategy to efficiently direct the selection and application of rules. KEE uses three dasses ofrules to help the designer build an application, which are integral to the function- ing of the KEEWorlds facility: Deduction Rules: represent reasoning to determine whichfacts would be accepted as correct, given a set of assumptions. Anexample of a deduction rule follows:

(IF (THE CURRENT-ROOM OF ACME,SHIPPER IS tROOM) THEN DEDUCE (THE ROOM OF CART IB ?ROOM)) NewWorld Action Rules: determine alternatives or assumptions. They create a new context or world, to hold the set offacts consistent with each assumption. Also, if several worlds exist inwhich one of theserules might be applied, a new world is created which combines them when the rule is applied, as long as doing so does not create any inconsistencies, for example: (IF (FIND (THE CURRENT-ROOM OF ACME.SHIPPER IS ?ROOM) USING NO,RULES (?DOOR CONNECTS tROOM TO tNEXT.ROOM) THEN IN.NEW*WORIO. (DELETE (THE NEARBY-OBJECT OF ACME-SHIPPER IS ?X)) (CHANGE.TG (THE NEARBY-DOOR OF ACME.SHIPPER IS ?DOOR) ) )

© James Martin 1988 KEE/ 19 Same World Action Rules: make changes in the initial knowledge base or in onlythe world (context) in which they apply. This dass ofrules is the only one which enables reasoning about the structure of the application, as shown in the following example: (IF (THE ROOM.SELECTION OF ?OBJECT IS ?ROOM) (THE STACKING. DECISION OF fOBJECT IS SETTLED) THEN (ADD (THE SHIPPING.GOAL OF tOBJECT IS SATISFIED) ) ) A typical rule is composed of conditions and either condusions or actions. KEE rule conditions are composed of statements in the English-like syntax of the Tell&Ask language, such as The Color of Clyde is Red) . This would check that the ColorV slot in the frame Unit named Clyde contains the value Red. Clauses can contain variables, such as the size of opening is small. Typical condusions might be written as Add the size of Clyde is small, whichwould add the value small to the slot size of frame Unit Clyde. Other operators are delete, to delete a fact; change.to, which changes a fact; and lisp, which allows the execution of arbitrary lisp procedural code. The forms that a fact dause may take is determinedby the command syntax of Tell&Ask. Commands are used to:

set value for an own slot (The Height of John is small); set value for a member slot (The Height of all SLEDS is 50) make a Unit a member of some dass (John is in Class Carpenter);

make a Unit a subdass of same dass (All carpenters are craft sworkers)

Control Strategy & InferenceEngine Agenda- The KEE inference engine consists ofboth a forward-chaining and a Controlled backward-chaining engine. Both engines are agenda controlled; i.e., when arule premise matches on forward chaining, the rule is entered on an ordered list ofrules to be fired (according to some orderingcriterion. This criterion can be controlled by the user, although a default value is supplied. Similarly, goals to be pursued are placed on an ordered list of goals. Truth The KEEWorlds facility supports state-of-the-art truth maintenance Maintenance capability. TheKEEWorlds facility provides the ability to "reason" using assumptions, alternatives and constraints, by building and maintaining different "contexts"for deduction from the different assumptions, etc. This form oftruth maintenance allows simultaneous consideration of several solutions which may be contradictory and enables the system tofollow a "best-first"reasoning path in choosing between solutions. It also provides the dependency-directedbacktracking of earlier truth maintenance methods in a more efficient fashion.

20/KEE © 1988 James Martin InExample 2, an earlier system would have marked the invalid information and deductions from it to remove them from the deductive engine. KEEWorlds simply moves the focus of the engine to another "world" where the incompatibilities are not present. The agenda method of control hascertain advantages — the order in which rules are to be fired or goals are to be pursued can be explicitly set by the designer, which can make the reasoning process somewhat dearer. Rather than constructingrules in some arbitrary fashion in order to getthe firing order wanted or storing them in a certain order in order to achieve the same effect, the ordering decisions are made explicitly. Because the order of application can be explicitly determined, the designer is given substantially more power and flexibility. TheKEE agenda-control system provides several built-in methods for explicitly controlling firing order and allows the designerto write other ordering methods if needed. Thebuilt-in methods are fairly simple, and can only be applied one at a time. The KEE system does allow the agenda ordering method to be changed by directly invoking the forward chainer or the backward chainer. Each chainer has its own ordering strategy, which can be set each time the chainer is invoked. KEE does not allow"parallel" firing of severalrules during one cyde; so, a designer must be careful when writingrules to simulate parallel systems. TheKEE agenda method has certain disadvantages. The operation of the agenda could lead a user into inadvertent error, and the methods for explicitly orderingrules and goals are not very useful for explaining why a certain order was used. Inference A user could write a rule with the expectation that it willfire only when EngineFlaw the conditions are met. Because it is placed on the agenda immediately upon its conditions being met (but may not immediately fire), otherrules may in the meantime invalidate the rule's conditions for firing, causing an error. The KEE system does not recheck arule's conditions before firing, nor does itremove a rule from the agenda if its conditions are no longer met. The ordering methods supplied withKEE fall into two categories: Ordering byrule premise complexity and ordering by weights whichthe user gives each rule or rule dass. Both are useful in creating some structured way to order the application ofrules, but the reasoning behind the ordering is lost unless it is documented by the designer. Weights assigned to the rules are arbitrary numbers, which have no theoretical justificationunless the designercarefully builds a theoretical justification intothe documentation. That justification, if it exists, is not available to the KEE system, however. It cannot be invoked by a userrequiring explanation. Forward chaining can be orderedby the following methods: least-premise complexity: Therules with the most condition dauses and the least precise clauses fire first. greatest-premise complexity: Therules with the most condition clauses and the most precise dausesfire first.

21 © James Martin 1988 KEE/ least-weight: Rules with the lowest weight fire first, where weight is an integer slot on each rule. greatest-weight: Rules withthe greatest weight fire first. weighted: Rules are compared for the complexity oftheir premises, as above. Iftworules have the same premise complexity, the one with the highest weight fires first. weighted, greatest-premise complexity: Compares the rules as for greatest premise complexity and breaks ties byrule weights. Backward chaining can be orderedby the following methods (Figure KEE-3); depth-first: Sub-goals of the first goal on the agenda are inserted before other goals on the agenda which are siblings of that goal. breadth-first: Sibling goals ofthe first goal on the agenda are used/fired before subgoals of that goal. Sub-goals are inserted after sibling goals and subgoals of any siblingwhich are already on the agenda.

best-first: The goal most likely to lead to a solution is placed first on the agenda. In most problem-solving systems, thisrequires some function to evaluate each goal in the current problem state, in order to determine which one is best. TheKEE function expands each goal under consideration into a stack of subgoals and chooses the goal with the smallest stack, so the "best" solution is the one which appears to have the fewest steps. Further control ofbackward chaining may be achieved by the following mechanism:

Attempting to fulfill a goal will generate a set ofrules whichcould fulfill the goal. The designer can assign one of the forward-chaining ordering methods to use for determining the order in which the rules will be considered. To invoke forward chaining using the Greatest Weight ordering method, the user would type this at the LispListener window: Assert » (the color of Clyde is grey) * horse _ rules wl : agenda.controller * greatest .weight)' The first item after Assert is the fact which initiates chaining. The second, horse .rules, is the name of a dass ofrules to be used preferentially in deduction. The third, Wl, is the world into whichthe fact is inserted. The last two are the two elements which show that the agenda ordering method to be used is Greatest Weight.

Figure KEE-3 (a): Trace ofDepth-First Search

2 5 THE THE THE OCCUPATION STATUS.SEEKING YUPPIE.RULE.. ALFRED 1 7VAR2 ALFED 3 THE TYPE ______THE 6 7WHAT 7VAR3

4_____ THE THE VW.OWNER.RULE 7VAR4 ALFRED I IS POOR

Figure KEE-3 (b): Trace ofBreadth-First Search

2 5 6 START THE THE THE MERCEDES.OWNER.RULE «■_ YUPPIE.RULE.I ALFRED 7VAR2 ALFED

THE TYPE START THE STATION.WAGON.OWNER.RULE —■» 7 7WHAT 1 THE A 7VAR4 **

Figure KEE-3 (c): Trace ofBest-First Search

Figure KEE-3: Backward Chaining

OF START OWNEROF START OCCUPATION ALFREDS.CARIS "^~ MERCEDES.OWNER.RULE■— ALFREDS.CARIS»-^ OF IS OF IS WHITE-COLLAR HIGH

START OWNEROF START MERCEDES.OWNER.RULE ALFREDS.CARIS OF IS OF IS WHITE-COLLAR HIGH

OF START OWNEROF ALFREDS.CARIS STATION.WAGON.OWNER.RULE ALFREDS.CARIS

START OWNEROF ALFREDS.CARIS S.I.S OF

OWNEROF START OCCUPATION «__ ALFREDS.CARIS STATUS.SEEKING OF IS OF IS WHITE-COLLAR HIGH

OF OWNEROF ALFREDS.CARIS ALFREDS.CARIS ?VAR3

START OWNEROF VW.OWNER.RULE ALFREDS.CARIS Developer Interface The KEE development environment is powerful, flexible and complex. It rests on the environments provided by the AIworkstations on whichKEE runs, whichthemselves provide a sophisticated, flexible, powerful design environment. In addition to being stylisticallycompatible withthese environments, the KEE environment also provides simpler development facilities for a developer unfamiliarwith AI workstations. Menu & Mouse TheKEE development environment provides a menu-and-mouse desktop environment with substantial graphics support for debugging, editing and the end-user interface. Editing and debuggingfacilities are both mouse- and-menu and textual; changes are made via text editors or the pseudo- English of the Tell&Ask facility, whichever the developer prefers.

TheKEE environment can be confusing because it provides several ways to accomplish a given task, in order to allow users tochoose the style of interaction which they find comfortable. Complication is increased because not all functions can be easily or even partiallyperformed through each interface. The developer must become familiar with the properties of different interfaces. For instance, the Tell&Ask language addresses only some of the functions a developer would like to perform, in order to build and alter data structures, but not enable the user to alter aspects of the inference engine. The debugging facilities are also dispersed. They cannot all be invoked from a single place, but must be invoked at the level of the system object to which they apply. Some are invoked at KB level menus, others at the rule dass description of a group ofrules and still others at individual rules. TheKEE system graphics provide a great deal of support for expert system development. The mouse-and-menu desktop interface allows the developer to view several aspects of the application design at once. The graphical representations offrames and rules gives a compact and dear picture ofrela- tionships and structure. The graphical interface packages, KEEPictures and Activelmages3, provide useful tools for altering facilities. For example, a developer can easilybuild a graphical interface to trace changes to part of the knowledge base or build an interface to allowmany of the debugging switches and facilities to be invoked from a single window.

Editing Facilities The editing facilities consist of: Fill-in-the-blank templates whichcan be invoked bythe appropriate command in a menu. These allow the user to build the frame Units and rules. Separate templates exist for each of the rule dasses, frame Units and slots.

Mouse and menu editing facilities allowthe user to add, change or remove parts of already created frame Units or rules. These editing facilities often require invoking fill-in-the-blank templates for the following operations:

Pseudo-English commands in Tell&Ask to add orremove frame Units or change them, their slots and their position in the hierarchy. Rules (frame Units of a type) can also be built in this manner.

24/KEE © 1988 James Martin Fuller texteditors, for rules, frame Units and slots, as well as other parts of the KEE system whichcannot easily be created using the menu-and-mouse system or pseudo-English Tell&Ask. Special methods or functions usedby the inference engine are one example. TheKEE editors do not perform consistency or completeness checks, automatically catch misspellings or perform similar "intelligent" tasks. Hie environment does not have any "intelligent assistants", whichin some systems maintain models of the knowledge base or aid the designer. The rule editor does parse dauses entered as Tell&Ask formulas and the entire rule is parsed when the editor is exited.

The"template style" editing facilities allow the user to build the system part bypart. It queries the user about the values desired for each of the parts of the typical rule, frame Unit or slot. Aframe Unit typicallywould be created in the following manner, prompting the developer for each value needed for a usual frame Unit. The commands possible withmouse and menu are described in the knowledge representation section and consist ofcreation, deletion and single value replacement. The "template style" interfaces are cumbersome for developing production rules, and the KEE manuals sug- gestthat rules be created with the rule editor. English-Like Thepseudo-English Tell&Ask facility provides many of the simple func- Commands tions available with the mouse and menu. It has the advantage of being both English-like and executable, so that Tell&Ask expressions can provide very readable condusion clauses inrules. Several types of text editors are available in the KEE system. Developers can use any of the generic editors available with the AI Workstation operating system, such as ZMACS. The system also provides a Rule Editor that will parse Tell&Ask dauses entered, if necessaryand parses the entire rule upon exiting. It also provides a template for the rule, if desired. Finally, therule dass in which the newrule belongs is reindexed when the Rule Editor is exited.

DebuggingFacilities Debugging The KEE debuggingfacilities include the powerful facilities available from the AI workstation for tracing, settingbreakpoints and examining the state ofthe computation. Facilities have been added to aid debugging expert systems written inKEE. TheKEE debuggingfacilities include: graphic tracing ofrule application;

graphic browsing through the various states of possibility in KEEWorlds using the KEEWorlds browser; easily built graphical tracing of any part of the knowledge base, using Activelmages3 andKEEPictures; text message tracing of chaining; How andWhy facilities for "explaining" reasoning done by the system;

© James Martin 1988 KEE/ 25 setting a breakpoint on a rule (or rules) to break upon its firing; editing of facts in the database at breakpoints or in the KEEWorlds browser; commands to undo previous actions of the system; a command to graphically display (in a deduction net) all the rules with their inferencing relationships to one another. Graphical The Activelmages3 package provides an easily used facility for designing Debugging graphical debugging displays. They can automatically show changes in the values ofvarious slots orframe Units as the system runs. (Use of the Activelmages3 system is explained in the User Interface section.) Another use of the debuggingfacilities is to provide the developer an interface for conveniently controlling the application ofrules of arule dass in the inference engine or for controlling the debuggingfeatures. HOW &; WHY The HOW andWHY facilities perform trivial explanation, by simply Facilities recapitulating the logical dependency ofrule application and the resulting facts. They are invoked by selecting EXPLAIN from either the KEEWorlds command menu or the KEE Logo menu. Tracing & The tracing, stepping and breakpoint settingfacilities are spread out over Breakpoints several parts of the package and must be set at the appropriate locations or through a debugging graphical interface. Breaking on firing a particular rule must be done by changing the chainer.break slot of the particular rule dass, for example. Some shell systems allowbreakpoints to be setfrom one interface, to effect any ofthe several stages of the inference engine cyde and only invoked when certain conditions are met (such as a particular rule being involved or a particular clause matched). Tracing of changes in slot values can be donevery clearly using the Activelmages3 package. The built-in tracing functions are AND.TRACE, OR.TRACE, TEST.TRACEand FCTRACE. AND.TRACE and OR.TRACE trace the application ofrules duringbackward chaining. Debugging Theactions of the inference engine cannot be monitored by the KEE Limitations debuggingfacilities. Hie agenda of the inference engine is not readily examined. The firing agenda manipulating methods must be examined with the AI workstation facilities. Itsreasoning is not induded in explanation of How and Why, giving no debugging support for problems with the inference engine and its reasoning functions. KEE also does not support examination or debugging of the process ofmatching facts withrule premises. Overall, the KEE system is well suited for tracing and explaining the presence of an action, but fails to support explanation or determination of why something did not occur.

User Interface

The KEE system does not tie the developer into a specific model of user interaction, but instead provides a powerful set of tools whichallow sophisticated customization of the interface and the form of user interaction.

26/KEE © 1988 James Martin TheKEE system provides sophisticated graphics support for user interfaces, supplying a good libraryof components for graphical output and for graphical representation of input using the mouse. KEE does not provide a frameworkfor sophisticated explanation of the system's reasoning, onlyfor a tracing of the rule application steps and the deductive inferences made. With the KEEWorlds facility, it does provide the ability to compare results of different sets of assumptions or alternatives. The system does not provide the user withthe means to integrate its output in documents or reports easily, although it does supply conduits to certain relational databases. It does not support natural language processing. Explanation The explanation facility can be invoked from the KEEWorlds browser by Facility selecting the EXPLAIN option from either the KEEWorlds command menu or the KEE LOGO command window at the top level. The facility will explain either why a given fact is true in its context by showing how it was derived, or it will explainwhy the context is inconsistentand the fact thereby invalid by showing the reasoning and derivation of a contradiction in that context. Graphics Two packages contain the graphics interface tools, the KEEPictures Interfaces package and the Activelmages3 package. The two packages serve different functions. TheKEEPictures package tools can be used to display pictures relevant to the application, have them shrink, expand, move, flash orrespond to selection by the mouse as directedby user input. They can be created and displayedby methods for a frame Unit or by firing ofrules. The following commands are used for integrating a graphicalrepresenta- tion with the knowledge base: Attach Image Panel attaches a graphicrepresentation from the Activelmages3 Knowledge— Base which can contain graphical images representing the knowledge base state. Attach KP Viewport — attaches a KEEPictures windowto the KB. KEEPictures The KEEPictures package allows creation of different pictures and sub- Facility pictures, in a hierarchy. It also allows the creation of different views of the same picture, either of different parts, at different scales or both. This is done by attaching different viewports to the same picture. Besides a standard library of geometricforms, KEEPictures supports bitmaps and allows bitmap pictures to be doned, facilitating animation. The libraryof standard objects also indudes dials, gauges, graphs, histograms, etc. KEEPic- tures also indudes a "painting" package. Activelmage3 The Activelmages3 package supports interactive graphical objects and Facility displays. A developer could build a debugging interface or an interactive interface for a training expert system. Activelmages has two types of components, image panels and Active Images. An image panel is attached to a frame Unit or to a knowledge base and provides the frame for the display. Active images are attached to Units or to individual slots in a Unit and display or effect changes in the Unit. They are associated withthe image panel in whichthey are displayed.

© James Martin 1988 KEE/ 27 Documentation &; Support Evaluation of TheKEE documentation is plentiful. It suffers, however, from continual Documentation use of jargoninvented by Intellicorp for the various parts ofKEE. Until these terms are understood, the manuals are not very dear. The organization of the manuals is adequate, although it is not always apparent where to lookfor a given piece of information. They seek to serve double duty as tutorial andreference manuals, andtherefore fall short of excellence in either category, mixing extendedexamples withlists of the functionality or options available at various points. Themanual should have been divided into two documents, an introductory manual and an encydopedic manual. The glossary of the manuals is generally good, explaining most terms dearly. Some obvious entries (e.g., mouse) are too long, while Truth Maintenance jargonterms are virtually unexplained. The indices are useful and thorough, induding all or most ofthe KEE functions and terms as well as more general categories of interest. Tutorial An introductory tutorial is provided with the KEE system on-line. There are also numerous examples in the manuals and an extended example in the manual with the correspondingKEE code on a tape. Intellicorp offers two dasses ofconsulting services, by regular staff and by senior scientists. This is a growing source of revenue and one of the strategic directions the company is emphasizing.

Product Strengths support for a very wide range of expert system solutions; flexible knowledge representation frames, rules, objects and demons are available in sophisticated— and simple forms; very flexible inference engine supports forward and backward chaining with agendas and is one— of the few expert system shells which can support blackboard architectures; good support for what-if and assumption-drivenreasoning using the KEEWorlds Truth Maintenance System; wide range of platforms are available for it AI workstations such as Symbolics, Xerox and Texas Instruments; ordinary— workstations from Sun and Digital Equipment; VAX mini computers and 80386-based PCs. It is also available in a VAX server to 286PC workstation distributed configuration; transportable applications; the only problems are incompatibilities in anyLISP code used, screen sizes and fonts; access to and from underlyingLISP and to and from C on Sun workstations and VAX mini computers;

28 /KEE © 1988 James Martin very powerful and flexible interface to SQL-based database management systems available at extracost; excellent graphical interface package, making the end-user interface customizable; numerous graphics objects, animation and windows; provision for four different styles of interaction to accommodate an interactionrange from naive user to expert knowledge engineer; pseudo-English commands, menus-graphics-and-mousing, editors and IISP-style functions; good set of development and debugging tools, induding structured editors, unstructured editors, graphical construction of the data structures, breakpointing and graphical monitors ofrule execution and changing data values; Product Limitations Apowerful hardware platform (such as a 386 PC with 10MB extra memory) is required to run the development version at a good speed. It is complex; therefore it has a comparatively long learningcurve. The documentation is only adequately organized and is full ofKEE- specific jargon. It is somewhat necessary to know the name of the facility that would provide a specific function in order to know where to look in the documentation. Very little interactive or on-line help is available. Not all the functionality of the system is available in each style of interaction; so, several different ways to interactwiththe system may have to be used. It does not have built-in data structures for reasoning about time. It does not support certainty factors, Bayesian or fuzzy logic methods of expert systemreasoning. There is only moderate support for explanation ofreasoning. Any explanation more sophisticated than a rule trace withassociated text would have to be built by the developer. OnlyASCII files may be accessed since there is no ability to call PC application programs. Call facility is available on other platforms only through C language calls. Because it is so sophisticated, it sometimes does unnecessary work for some types of applications, which may result in slowrun-time per- formance on some platforms.