Introduction To Clips: Expert Systems: Principles and Programming, Fourth Edition

Chapter 7:
Introduction to
CLIPS
Expert Systems: Principles and

Programming, Fourth Edition
Objectives
• Learn what type of language CLIPS is
• Study the notation (syntax) used by CLIPS
• Learn the meaning of a field and what types exit
• Learn how to launch and exit from CLIPS
• Learn how to represent, add, remove, modified,
and duplicated in CLIPS
Expert Systems: Principles and Programming, Fourth Edition 2

Objectives
• Learn how to debug programs using the watch
command
• Learn how to use the deffacts construct to define
a group of facts
• Learn how to use the agenda command and
execute CLIPS programs
• Learn about commands that can manipulate
constructs

Objectives
• Learn how to use the printout command
• Learn how to use multiple rules
• Learn how to use the set-break command
• Learn how to use the load and save constructs
• Learn how to use variables, single and multifield
wildcards, and comment constructs

What is CLIPS?
• CLIPS is a multiparadigm programming
language that provides support for:
– Rule-based
– Object-oriented
– Procedural programming
• Syntactically, CLIPS resembles:
– Eclipse
– CLIPS/R2
– JESS

Other CLIPS Characteristics
• CLIPS supports only forward-chaining rules.
• The OOP capabilities of CLIPS are referred to as
CLIPS Object-Oriented Language (COOL).
• The procedural language capabilities of CLIPS
are similar to languages such as:
– C
– Ada
– Pascal
– Lisp

CLIPS Characteristics
• CLIPS is an acronym for C Language Integrated

Production System.
• CLIPS was designed using the C language at the

NASA/Johnson Space Center.
• CLIPS is portable – PC  CRAY.

CLIPS Notation
• Symbols other than those delimited by < >, [ ], or
{ } should be typed exactly as shown.
• [ ] mean the contents are optional and < > mean
that a replacement is to be made.
• * following a description means that the
description can be replaced by zero or more
occurrences of the specified value.

CLIPS Notation
• Descriptions followed by + mean that one or
more values specified by description should be
used in place of the syntax description.
• A vertical bar | indicates a choice among one or

more of the items separated by the bars.

Fields
• To build a knowledge base, CLIPS must read
input from keyboard / files to execute commands
and load programs.
• During the execution process, CLIPS groups
symbols together into tokens – groups of
characters that have the same meaning.
• A field is a special type of token of which there
are 8 types.

Numeric Fields
• The floats and integers make up the numeric
fields – simply numbers.
• Integers have only a sign and digits (ex: 3, -5, 56,
+77).
• Floats have a decimal and possibly “e” for
scientific notation.
– 3.7 3700e-3
– 5e+2 6e4

Symbol Fields
• Symbols begin with printable ASCII characters followed
by zero or more characters, followed by a delimiter.
• A delimiter can be:
– Non-printable ASCII character (space, tab, carriage return, or
line field).
– Double quotation marks “
– Opening ( and closing ) parenthesis
– the ; semicolon, the & ampersand, the | vertical bar, the ~
tilde , and the less <
• A delimiter cannot contain delimiters (except it can
begin with <) and cannot begin with ? and $?
• CLIPS is case sensitive.
String Fields
• Strings must begin and end with double quotation
marks.
• Spaces w/in the string are significant.
• The actual delimiter symbols can be included in a
string by preceding the character with a
backslash.
– “”ali “”  three tokens
– “\” ali\””  “”ali“”
– “\\ ali\\”  “\ali\”
Address Fields
• External addresses represent the address of an
external data structure returned by a user-defined
function.
• Fact address fields are used to refer to a specific
fact.
• Instance Name / Address field – instances are
similar to facts addresses but refer to the instance
rather than a fact.

Entering / Exiting CLIPS
• The CLIPS prompt is: CLIPS>
• This is the type-level mode where commands can
be entered.
• To exit CLIPS, one types: CLIPS> (exit) 
• CLIPS will accept input from the user / evaluate
it / return an appropriate response:
CLIPS> (+ 3 4)   value 7 would be returned.

Facts and CLIPS
• To solve a problem, CLIPS must have data or
information with which to reason.
• Each chunk of information is called a fact.
• Facts consist of:
– Relation name (symbolic field)
– Zero or more slots w/associated values

Example Fact in CLIPS

Deftemplate
• Before facts can be constructed, CLIPS must be
informed of the list of valid slots for a given
relation name.
• A deftemplate is used to describe groups of facts
sharing the same relation name and contain
common information.

Deftemplate General Format

Deftemplate vs. Ordered Facts
• Facts with a relation name defined using
deftemplate are called deftemplate facts.
• Facts with a relation name that does not have a

corresponding deftemplate are called ordered
facts – have a single implied multifield slot for
storing all the values of the relation name.

Adding Facts
• CLIPS store all facts known to it in a fact list.
• To add a fact to the list, we use the assert command.
(assert <facts>+)

Displaying Facts
(facts [<start> [<end> [<maximum> ]]])
– Where <start> , <end> and <maximum> are positive integers
• CLIPS> (facts) 

Removing Facts
• Just as facts can be added, they can also be
removed.
(retract <fact-index>+)
• Removing facts results in gaps in the fact
identifier list.
• To remove a fact:
CLIPS> (retract 2) 

Example

Example – cont.

Modifying Facts
• Slot values of deftemplate facts can be modified using
the modify command:

Results of Modification
• A new fact index is generated because when a
fact is modified:
– The original fact is retracted
– The modified fact is asserted
• The duplicate command is similar to the modify

command, except it does not retract the original
fact.

Watch Command
• The watch command is useful for debugging purposes.
(watch <watch-item>)
(unwatch <watch-item>)
• <watch-item> can be facts, rules, activations, statistics,
compilations, focus, deffunctions, globals, generic-
functions, methods, instances, slots, messages, message-
handlers, or all.
• If facts are “watched”, CLIPS will automatically print a
message indicating an update has been made to the fact
list whenever either of the following has been made:
– Assertion
– Retraction
Watch Command

Deffacts Construct
• The deffacts construct can be used to assert a
group of facts.
• Groups of facts representing knowledge can be
defined as follows:
(deffacts <deffacts name> [<optional-comment>]
<facts> * )
• The reset command removes all facts from the
fact list and then asserts the facts in adeffacts
statements.
Deffacts Construct

The Components of a Rule
• To accomplish work, an expert system must have
rules as well as facts.
• Rules can be typed into CLIPS (or loaded from a
file).
• Consider the pseudocode for a possible rule:
IF the emergency is a fire
THEN the response is to activate the sprinkler system

Rule Components
• First, we need to create the deftemplate for the
types of facts:
(deftemplate emergency (slot type))
-- type would be fire, flood, etc.
• Similarly, we must create the deftemplate for the

types of responses:
(deftemplate response (slot action))
-- action would be “activate the sprinkler”

Rule Components
• The rule would be shown as follows:
(defrule fire-emergency “An example rule”

(emergency (type fire))
=>
(assert (response
(action activate-sprinkler-system))))

Analysis of the Rule
• The header of the rule consists of three parts:
1. Keyword defrule
2. Name of the rule – fire-emergency
3. Optional comment string – “An example rule”
• After the rule header are 1+ conditional
elements – pattern CEs
• Each pattern consists of 1+ constraints intended
to match the fields of the deftemplate fact

Rule Components

Analysis of Rule
• If all the patterns of a rule match facts, the rule is
activated and put on the agenda.
• The agenda is a collection of activated rules.
• The arrow => represents the beginning of the
THEN part of the IF-THEN rule.
• The last part of the rule is the list of actions that
will execute when the rule fires.

The Agenda and Execution
• To run the CLIPS program, use the run
command:
CLIPS> (run [<limit>])
-- the optional argument <limit> is the maximum

number of rules to be fired – if omitted, rules will fire
until the agenda is empty.

Execution
• When the program runs, the rule with the highest
salience on the agenda is fired.
• Rules become activated whenever all the patterns
of the rule are matched by facts.
• The reset command is the key method for starting
or restarting .
• Facts asserted by a reset satisfy the patterns of
one or more rules and place activation of these
rules on the agenda.

What is on the Agenda?
• To display the rules on the agenda, use the agenda
command:
CLIPS> (agenda) 
• Refraction is the property that rules will not fire more

than once for a specific set of facts.
• The refresh command can be used to make a rule fire
again by placing all activations that have already fired
for a rule back on the agenda.
(refresh <rule-name>)



Command for Manipulating
Constructs
• The list-defrules command is used to display the
current list of rules maintained by CLIPS.
(list-defrules)
• The list-deftemplates displays the current list of
deftemplates. (list-deftemplates)
• The list-deffacts command displays the current list
of deffacts. (list-deffacts)
• The ppdefrule, ppdeftemplate and ppdeffacts
commands display the text representations of a
defrule, deftemplate, and a deffact, respectively.
Constructs

Commands
• The undefrule, undeftemplate, and undeffacts
commands are used to delete a defrule, a
deftemplate, and a deffact, respectively.
(undefrule <rule-name>)
• The clear command clears the CLIPS environment
and adds the initial-fact to the CLIPS environment.
• The printout command can also be used to print
information.

Constructs

Commands
• (printout <logical-name> <print-
items>*)
<logical-name> indicates the output destination
of the command (for example, printer, screen,
etc)
Ex: (printout t "his name is ahmad" crlf)
t: is defined to be the screen and could be
defined to be another output device.

Other Commands
• set-break – allows execution to be halted before any
rule from a specified group of rules is fired.
(set-break <rule-name>)
• show-breaks – show break points. (show-breaks)
• remove-break – remove a break point.
(remove-break [<rule-name>])
• load – allows loading of rules from an external file.
(load <file-name>)
(load “C:\constructs.clp”)
• save – opposite of load, allows saving of constructs to
disk (save <file-name>)
•Example (saving facts):
CLIPS> (facts)
f-0 (initial-fact)
f-1 (fire second)
f-2 (fire third)
For a total of 3 facts.
CLIPS> (save-facts “C:\myfacts.dat”)
TRUE
CLIPS>
•If we open the file “C:\myfacts.dat” then we find the

following data inside it:
(initial-fact)
(fire second)
(fire third)

Saving Facts

•Example (loading facts):
CLIPS> (facts)
CLIPS> (load-facts “C:\myfacts.dat”)
TRUE
CLIPS>
f-0 (initial-fact)
f-1 (fire second)
f-2 (fire third)
CLIPS>

Other Commands
• (set-break <rule-name>)
this command will put a break point at <rule-
name>.
• (show-breaks): list all break points.
• (remove-break [<rule-name>])
If <rule-name> is provided then it will removes the
break point in it, otherwise it will removes all
break points.

Example 1:
CLIPS> (defrule first => (assert (fire second)))
CLIPS> (rules)
first
For a total of 1 defrule.
CLIPS> (defrule second (fire second) => (assert (fire third)))
CLIPS> (defrule third (fire third) =>)
CLIPS> (agenda)
0 first: f-0
For a total of 1 activation.
CLIPS> (watch rules)
CLIPS> (reset)
CLIPS> (facts)
f-0 (initial-fact)
For a total of 1 fact.
CLIPS> (run)
FIRE 1 first: f-0
FIRE 2 second: f-1
FIRE 3 third: f-2
Example 2 (set break points):
CLIPS> (defrule first => (assert (fire second)))
CLIPS> (defrule second (fire second) => (assert (fire
third)))
CLIPS> (defrule third (fire third) =>)
CLIPS> (rules)
first
second
third
For a total of 3 defrules.
CLIPS> (agenda)
0 first: f-0
CLIPS> (set-break second)
CLIPS> (set-break third)
CLIPS> (show-breaks)
second
third
CLIPS> (watch rules)
CLIPS> (reset)
CLIPS> (show-breaks)
second
third
CLIPS> (facts)
f-0 (initial-fact)
For a total of 1 fact.
CLIPS> (run)
FIRE 1 first: f-0
Breaking on rule second.
CLIPS> (run)
FIRE 1 second: f-1
Breaking on rule third.
CLIPS> (run)
FIRE 1 third: f-2
CLIPS>
Commenting and Variables
• Comments – provide a good way to document
programs to explain what constructs are doing.
comments starts with semicolon and ends with
carriage return.
; comment here
• Variables – store values, the same as symbols but
syntax requires preceding with a question mark
(?) followed by a character.

CLIPS> (deftemplate person (slot name )(slot eyes))
CLIPS> (defrule find-blue-eyes (person (name ?name)(eyes blue))
=> (printout t ?name " has blue eyes" crlf))
CLIPS> (rules)
find-blue-eyes
For a total of 1 defrule.
CLIPS> (assert (person (name jane)(eyes green))
(person (name jack)(eyes blue)))
<Fact-1>
CLIPS> (facts)
f-0 (person (name jane) (eyes green))
f-1 (person (name jack) (eyes blue))
CLIPS> (agenda)
0 find-blue-eyes: f-4
CLIPS> (run)
jack has blue eyes
CLIPS>
Fact Addresses, Single-Field
Wildcards, and Multifield Variables
• A variable can be bound to a fact address of a fact
matching a particular pattern on the LHS of a rule
by using the pattern binding operator “<-”.
• Single-field wildcards can be used in place of
variables when the field to be matched against can
be anything and its value is not needed later in the
LHS or RHS of the rule.
• Multifield variables and wildcards allow matching
against more than one field in a pattern $?.

Example (fact address):
CLIPS> (deftemplate person (slot name )(slot eyes))

CLIPS> (defrule retract-rule
?f1 <- (person (eyes blue))
?f2 <- (person (eyes green))
=>
(retract ?f1)
(modify ?f2 (eyes black))
)

Summary
• In this chapter, we looked at the fundamental
components of CLIPS.
• Facts make up the first component of CLIPS,
made up of fields – symbol, string, integer, or
float.
• The deftemplate construct was used to assign slot
names to specific fields of a fact.
• The deffacts construct was used to specify facts
as initial knowledge.

Summary
• Rules make up the second component of a CLIPS
system.
• Rules are divided into LHS – IF portion and the
RHS – THEN portion.
• Rules can have multiple patterns and actions.
• The third component is the inference engine –
rules having their patterns satisfied by facts
produce an activation that is placed on the
agenda.

Summary
• Refraction prevents old facts from activating rules.
• Variables are used to receive information from facts
and constrain slot values when pattern matching on
the LHS of a rule.
• Variables can store fact addresses of patterns on the
LHS of a rule so that the fact bound to the pattern
can be retracted on the RHS of the rule.
• We also looked at single-field wildcards and
multifield variables.

Introduction To Clips: Expert Systems: Principles and Programming, Fourth Edition

Uploaded by

Document Information

Original Description:

Original Title

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

Introduction To Clips: Expert Systems: Principles and Programming, Fourth Edition

Uploaded by

Copyright:

Available Formats

Chapter 7:

Expert Systems: Principles and

Expert Systems: Principles and Programming, Fourth Edition 2

Expert Systems: Principles and Programming, Fourth Edition 3

Expert Systems: Principles and Programming, Fourth Edition 4

Expert Systems: Principles and Programming, Fourth Edition 5

Expert Systems: Principles and Programming, Fourth Edition 6

• CLIPS is an acronym for C Language Integrated

• CLIPS was designed using the C language at the

• CLIPS is portable – PC  CRAY.

Expert Systems: Principles and Programming, Fourth Edition 7

Expert Systems: Principles and Programming, Fourth Edition 8

• A vertical bar | indicates a choice among one or

Expert Systems: Principles and Programming, Fourth Edition 9

Expert Systems: Principles and Programming, Fourth Edition 10

Expert Systems: Principles and Programming, Fourth Edition 11

Expert Systems: Principles and Programming, Fourth Edition 14

Expert Systems: Principles and Programming, Fourth Edition 15

Expert Systems: Principles and Programming, Fourth Edition 16

Expert Systems: Principles and Programming, Fourth Edition 17

Expert Systems: Principles and Programming, Fourth Edition 18

Expert Systems: Principles and Programming, Fourth Edition 19

• Facts with a relation name that does not have a

Expert Systems: Principles and Programming, Fourth Edition 20

Expert Systems: Principles and Programming, Fourth Edition 21

Expert Systems: Principles and Programming, Fourth Edition 22

Expert Systems: Principles and Programming, Fourth Edition 23

Expert Systems: Principles and Programming, Fourth Edition 24

Expert Systems: Principles and Programming, Fourth Edition 25

Expert Systems: Principles and Programming, Fourth Edition 26

• The duplicate command is similar to the modify

Expert Systems: Principles and Programming, Fourth Edition 27

Expert Systems: Principles and Programming, Fourth Edition 29

Expert Systems: Principles and Programming, Fourth Edition 31

Expert Systems: Principles and Programming, Fourth Edition 32

• Similarly, we must create the deftemplate for the

Expert Systems: Principles and Programming, Fourth Edition 33

(defrule fire-emergency “An example rule”

Expert Systems: Principles and Programming, Fourth Edition 34

Expert Systems: Principles and Programming, Fourth Edition 35

Expert Systems: Principles and Programming, Fourth Edition 36

Expert Systems: Principles and Programming, Fourth Edition 37

-- the optional argument <limit> is the maximum

Expert Systems: Principles and Programming, Fourth Edition 38

Expert Systems: Principles and Programming, Fourth Edition 39

• Refraction is the property that rules will not fire more

Expert Systems: Principles and Programming, Fourth Edition 40

Expert Systems: Principles and Programming, Fourth Edition 42

Expert Systems: Principles and Programming, Fourth Edition 43

Expert Systems: Principles and Programming, Fourth Edition 45

Expert Systems: Principles and Programming, Fourth Edition 46

Expert Systems: Principles and Programming, Fourth Edition 47

Expert Systems: Principles and Programming, Fourth Edition 48

•If we open the file “C:\myfacts.dat” then we find the

Expert Systems: Principles and Programming, Fourth Edition 50

Expert Systems: Principles and Programming, Fourth Edition 51

Expert Systems: Principles and Programming, Fourth Edition 52

Expert Systems: Principles and Programming, Fourth Edition 53

Expert Systems: Principles and Programming, Fourth Edition 57

Expert Systems: Principles and Programming, Fourth Edition 59

CLIPS> (deftemplate person (slot name )(slot eyes))

Expert Systems: Principles and Programming, Fourth Edition 60