Building expert systems in Prolog

308 Pages·2001·1.47 MB·english

by  Merritt D.

Building Expert Systems in Prolog
by
Dennis Merritt
John Stannard on the first free ascent of Foops - 1967

Published by:
Amzi! inc.
5861 Greentree Road
Lebanon, OH 45036 U.S.A.
phone [phone]
fax [phone]
e-mail [email protected]
web www.amzi.com
Book Edition Copyright ©1989 by Springer-Verlag.
On-line Edition Copyright ©2000 by Amzi! inc. All Rights Reserved.
This document ("Work") is protected by copyright laws and international copyright treaties, as well as other intellectual
property laws and treaties. You may use and distribute copies of this Work provided each copy of the Work is a true and
complete copy, including all copyright and trademark notices, and each copy is accompanied by a copy of this notice.
You may not distribute copies of this Work for profit either on a standalone basis or included as part of your own
product or work without written permission from Amzi! You may not charge any fees for copies of this work including
media or download fees. You may not include this Work as part of your own works. You may not rename, edit or create
any derivative works from this Work. Contact Amzi! for additional licensing arrangements.
Amzi! is a registered trademark and Logic Server, Active Prolog Tutor, Adventure in Prolog and the flying squirrel logo
are trademarks of Amzi! inc.
Last Updated: August 2000
PDF version March 2001 edited, designed and compiled by Daniel L. Dudley ([email protected])

ii
Preface
When I compare the books on expert systems in my library with the production expert systems I know of, I note that
there are few good books on building expert systems in Prolog. Of course, the set of actual production systems is a little
small for a valid statistical sample, at least at the time and place of this writing – here in Germany, and in the first days
of 1989. But there are at least some systems I have seen running in real life commercial and industrial environments,
and not only at trade shows.
I can observe the most impressive one in my immediate neighborhood. It is installed in the Telephone Shop of the
German Federal PTT near the Munich National Theater, and helps configure telephone systems and small PBXs for
mostly private customers. It has a neat, graphical interface, and constructs and prices an individual telephone
installation interactively before the very eyes of the customer.
The hidden features of the system are even more impressive. It is part of an expert system network with a distributed
knowledge base that will grow to about 150 installations in every Telephone Shop throughout Germany. Each of them
can be updated individually overnight via Teletex to present special offers or to adapt the selection process to the
hardware supplies currently available at the local warehouses.
Another of these industrial systems supervises and controls in "soft" real time the excavators currently used in Tokyo
for subway construction. It was developed on a Unix workstation and downloaded to a single board computer using a
real time operating system. The production computer runs exactly the same Prolog implementation that was used for
programming, too.
And there are two or three other systems that are perhaps not as showy, but do useful work for real applications, such as
oil drilling in the North Sea, or estimating the risks of life insurance for one of the largest insurance companies in the
world. What all these systems have in common is their implementation language: Prolog, and they run on "real life"
computers like Unix workstations or minis like VAXs. Certainly this is one reason for the preference of Prolog in
commercial applications.
But there is one other, probably even more important advantage: Prolog is a programmer's and software engineer's
dream. It is compact, highly readable, and arguably the "most structured" language of them all. Not only has it done
away with virtually all control flow statements, but even explicit variable assignment too!
These virtues are certainly reason enough to base not only systems but textbooks on this language. Dennis Merritt has
done this in an admirable manner. He explains the basic principles, as well as the specialized knowledge representation
and processing techniques that are indispensable for the implementation of industrial software such as those mentioned
above. This is important because the foremost reason for the relative neglect of Prolog in expert system literature is
probably the prejudice that "it can be used only for backward chaining rules." Nothing is farther from the truth. Its
relational data base model and its underlying unification mechanism adapt easily and naturally to virtually any
programming paradigm one cares to use. Merritt shows how this works using a copious variety of examples. His book
will certainly be of particular value for the professional developer of industrial knowledge-based applications, as well as
for the student or programmer interested in learning about or building expert systems. I am, therefore, happy to have
served as his editor.
Peter H. Schnupp
Munich, January 1989
Building Expert Systems in Prolog iii
Acknowledgements
A number of people have helped make this book possible. They include Dave Litwack and Bill Linn of Cullinet who
provided the opportunity and encouragement to explore these ideas. Further thanks goes to Park Gerald and the Boston
Computer Society, sounding boards for many of the programs in the book. Without the excellent Prolog products from
Cogent (now Amzi!), AAIS, Arity, and Logic Programming Associates none of the code would have been developed. A
special thanks goes to Peter Gable and Paul Weiss of Arity for their early help and Allan Littleford, provider of both
Cogent Prolog and feedback on the book. Jim Humphreys of Suffolk University gave the most careful reading of the
book, and advice based on years of experience. As have many other Mac converts, I feel compelled to mention my
Macintosh SE, Microsoft Word and Cricket Draw for creating an enjoyable environment for writing books. And finally
without both the technical and emotional support of Mary Kroening the book would not have been started or finished.

iv
Table of Contents
Preface........................................................................................................iii
Acknowledgements...................................................................................iv
1 Introduction............................................................................................1
1.1 Expert Systems............................................................................................1
1.2 Expert System Features...............................................................................3
Goal-Driven Reasoning.............................................................................................3
Uncertainty.................................................................................................................4
Data Driven Reasoning.............................................................................................4
Data Representation..................................................................................................5
User Interface............................................................................................................6
Explanations..............................................................................................................7
1.3 Sample Applications.....................................................................................7
1.4 Prolog...........................................................................................................8
1.5 Assumptions.................................................................................................8
2 Using Prolog's Inference Engine..........................................................9
2.1 The Bird Identification System......................................................................9
Rule formats..............................................................................................................9
Rules about birds.....................................................................................................10
Rules for hierarchical relationships..........................................................................10
Rules for other relationships....................................................................................11
2.2 User Interface.............................................................................................13
Attribute Value pairs................................................................................................13
Asking the user........................................................................................................13
Remembering the answer.......................................................................................14
Multi-valued answers...............................................................................................14
Menus for the user...................................................................................................15
Other enhancements...............................................................................................16
2.3 A Simple Shell............................................................................................16
Command loop........................................................................................................17
A tool for non-programmers.....................................................................................19
2.4 Summary....................................................................................................19
Exercises..........................................................................................................19
3 Backward Chaining with Uncertainty.................................................21
3.1 Certainty Factors........................................................................................21
An Example.............................................................................................................21
Rule Uncertainty......................................................................................................22
User Uncertainty......................................................................................................22
Combining Certainties.............................................................................................23
Properties of Certainty Factors................................................................................23
3.2 MYCINs Certainty Factors..........................................................................24
Determining Premise CF.........................................................................................24
Building Expert Systems in Prolog v
Combining Premise CF and Conclusion CF............................................................24
Premise Threshold CF.............................................................................................25
Combining CFs........................................................................................................25
3.3 Rule Format................................................................................................26
3.4 The Inference Engine.................................................................................27
Working Storage......................................................................................................27
Find a Value for an Attribute....................................................................................27
Attribute Value Already Known................................................................................28
Ask User for Attribute Value....................................................................................28
Deduce Attribute Value from Rules.........................................................................28
Negation..................................................................................................................30
3.5 Making the Shell.........................................................................................30
Starting the Inference..............................................................................................31
3.6 English-like Rules.......................................................................................32
Exercises..........................................................................................................33
4 Explanation..........................................................................................35
Value of Explanations to the User...........................................................................35
Value of Explanations to the Developer..................................................................35
Types of Explanation...............................................................................................36
4.1 Explanation in Clam...................................................................................36
Tracing.....................................................................................................................38
How Explanations....................................................................................................39
Why Questions........................................................................................................41
4.2 Native Prolog Systems...............................................................................43
Exercises..........................................................................................................46
5 Forward Chaining................................................................................47
5.1 Production Systems...................................................................................47
5.2 Using Oops.................................................................................................48
5.3 Implementation...........................................................................................52
5.4 Explanations for Oops................................................................................56
5.5 Enhancements...........................................................................................56
5.6 Rule Selection............................................................................................57
Generating the conflict set.......................................................................................57
Time stamps............................................................................................................58
5.7 LEX.............................................................................................................58
Changes in the Rules..............................................................................................59
Implementing LEX...................................................................................................59
5.8 MEA............................................................................................................61
Exercises..........................................................................................................62
6 Frames..................................................................................................65
6.1 The Code....................................................................................................66
6.2 Data Structure............................................................................................66
vi Table of Contents
6.3 The Manipulation Predicates......................................................................68
6.4 Using Frames.............................................................................................74
6.5 Summary....................................................................................................75
Exercises..........................................................................................................75
7 Integration............................................................................................77
7.1 Foops (Frames and Oops).........................................................................77
Instances.................................................................................................................77
Rules for frinsts........................................................................................................79
Adding Prolog to Foops...........................................................................................80
7.2 Room Configuration...................................................................................81
Furniture frames......................................................................................................82
Frame Demons........................................................................................................83
Initial Data................................................................................................................84
Input Data................................................................................................................85
The Rules................................................................................................................86
Output Data.............................................................................................................89
7.3 A Sample Run............................................................................................90
7.4 Summary....................................................................................................91
Exercises..........................................................................................................91
8 Performance.........................................................................................93
8.1 Backward Chaining Indexes.......................................................................93
8.2 Rete Match Algorithm.................................................................................94
Network Nodes........................................................................................................95
Network Propagation...............................................................................................96
Example of Network Propagation............................................................................97
Performance Improvements....................................................................................99
8.3 The Rete Graph Data Structures..............................................................100
8.4 Propagating Tokens.................................................................................101
8.5 The Rule Compiler...................................................................................103
8.6 Integration with Foops..............................................................................108
8.7 Design Tradeoffs......................................................................................109
Exercises........................................................................................................109
9 User Interface.....................................................................................111
9.1 Object Oriented Window Interface...........................................................111
9.2 Developer's Interface to Windows............................................................111
9.3 High-Level Window Implementation.........................................................114
Message Passing..................................................................................................115
Inheritance.............................................................................................................115
9.4 Low-Level Window Implementation..........................................................117
Exercises........................................................................................................120
Building Expert Systems in Prolog vii
10 Two Hybrids.......................................................................................121
10.1 CVGEN...................................................................................................121
10.2 The Knowledge Base.............................................................................122
Rule for parameters...............................................................................................122
Rules for derived information.................................................................................123
Questions for the user...........................................................................................124
Default rules...........................................................................................................124
Rules for edits........................................................................................................125
Static information...................................................................................................125
10.3 Inference Engine....................................................................................126
10.4 Explanations...........................................................................................127
10.5 Environment...........................................................................................128
10.6 AIJMP.....................................................................................................129
10.7 Summary................................................................................................130
Exercises........................................................................................................130
11 Prototyping.........................................................................................131
11.1 The Problem...........................................................................................131
11.2 The Sales Advisor Knowledge Base......................................................131
Qualifying...............................................................................................................132
Objectives - Benefits - Features............................................................................132
Situation Analysis..................................................................................................133
Competitive Analysis.............................................................................................133
Miscellaneous Advice............................................................................................134
User Queries..........................................................................................................134
11.3 The Inference Engine.............................................................................135
11.4 User Interface.........................................................................................136
11.5 Summary................................................................................................138
Exercises........................................................................................................138
12 Rubik's Cube......................................................................................139
12.1 The Problem...........................................................................................139
12.2 The Cube................................................................................................140
12.3 Rotation..................................................................................................142
12.4 High Level Rules....................................................................................142
12.5 Improving the State................................................................................143
12.6 The Search.............................................................................................144
12.7 More Heuristics......................................................................................145
12.8 User Interface.........................................................................................145
12.9 On the Limits of Machines......................................................................146
Exercises........................................................................................................146
viii Table of Contents
Appendices - Full Source Code.............................................................147
A Native..................................................................................................149
Birds Knowledgebase (birds.nkb)...................................................................149
Native Shell (native.pro).................................................................................153
B Clam....................................................................................................157
Car Knowledgebase (car.ckb)........................................................................157
Birds Knowledgebase (birds.ckb)...................................................................158
Clam Shell (clam.pro).....................................................................................163
Build Rules (bldrules.pro)...............................................................................176
C Oops ...................................................................................................179
Room Knowledgebase (room.okb).................................................................179
Animal Knowledgebase (animal.okb).............................................................184
Oops Interpreter (oops.pro)............................................................................187
D Foops..................................................................................................193
Room Knowledgebase (room.fkb)..................................................................193
Foops (foops.pro)...........................................................................................200
E Rete-Foops.........................................................................................211
Room Knowledgebase (room.rkb)..................................................................211
Rete Compiler (retepred.pro).........................................................................218
Rete Runtime (retefoop.pro)...........................................................................225
F Windows.............................................................................................239
Windows Demonstration (windemo.pro)........................................................239
Windows (windows.pro).................................................................................243
G Rubik...................................................................................................273
Cube Solver (rubik.pro)..................................................................................273
Cube Display (rubdisp.pro).............................................................................286
Cube Entry (rubedit.pro).................................................................................289
Move History (rubhist.pro)..............................................................................291
Moves and Rotations (rubmov.pro)................................................................293
Rubik Help (rubhelp.pro)................................................................................296
Rubik Data (rubdata.pro)................................................................................297

Building Expert Systems in Prolog ix