Lecture 03

Advanced Pattern Matching

1
Objectives
• Learn about field constraints
• Learn how to use functions and expressions
• Learn how to perform summing values using rules
• Learn how to use the bind function
• Learn how to use I/O functions
• Learn how to use the test conditional element
• Learn how to use the predicate field constraint and the return value constraint
• Examine the or, and, not, exists, forall logical elements.

2
Field Constraints
• In addition to pattern matching capabilities and variable bindings, CLIPS has more
powerful pattern matching operators.
• Consider writing a rule for all people who do not have brown hair:
• We could write a rule for every type of hair color that is not brown.
• This involves testing the condition in a roundabout manner – tedious, but effective.

3
Field Constraints
• The technique for writing a rule for all non-brown hair colors implies that we have
the ability to supply all hair colors – virtually impossible.
Red, green,
purple, yellow,
pink…etc???

• An alternative is to use a field constraint to restrict the values a field may have on
the LHS – the THEN part of the rule.

4
Connective Constraints
• Connective constraints are used to connect variables and other constraints.
• Not connective – the ~ acts on the one constraint or variable that immediately
follows it.
• Or constraint – the symbol | is used to allow one or more possible values to match a
field or a pattern.
• And constraint – the symbol & is useful with binding instances of variables and on
conjunction with the not constraint.

5
Finding People with Blue Eyes
(deftemplate person
(slot name)
(slot eyes)
(slot hair))

(deffacts people
(person (person
(name Jane) (name Jack)
(eyes blue) (eyes blue)
(hair red) (hair black)
) )
(person (person
(name Joe) (name Jeff)
(eyes green) (eyes green)
(hair brown) (hair brown)
) ))

6
Finding People
Find a person with blue eyes.
(defrule find-blue-eyes
(person
(name ?name) Variable

(eyes blue)
)
=>
(printout t ?name " has blue eyes." crlf)
)

7
Finding People
Find a person without brown hair.
(defrule find-without-brown-hair
(person
(name ?name)
(hair ~brown) Not brown
)
=>
(printout t ?name " does not have brown hair")
)

8
Finding People
Find a person with either black or brown hair.
(defrule find-black-or-brown-hair
(person
(name ?name)
(hair black | brown )
)
=>
(printout t ?name " has dark hair” crlf)
)

9
Finding People
• Find a person with either black or brown hair.
Specify the color of the hair.
(defrule find-black-or-brown-hair
(person
(name ?name)
(hair ?color& black | brown)
)
=>
(printout t ?name " has “ ?color " hair" )
)
10
Finding People
Find a person with neither black nor brown hair.
Specify the color of the hair.
(defrule find-black-nor-brown-hair
(person
(name ?name)
(hair ?color&~ black &~ brown)
)
=>
(printout t ?name " has " ?color " hair" )
)
11
Functions and Expressions
• CLIPS has the capability to perform calculations.

• The math functions in CLIPS are primarily used for modifying

numbers that are used to make inferences by the application
program.

12
Numeric Expressions in CLIPS
• Numeric expressions are written in CLIPS in LISP-style – using prefix form – the
operator symbol goes before the operands to which it pertains.
• Example #1:
• 5 + 8 (infix form) → + 5 8 (prefix form)

• Example #2:
• (infix) (y2 – y1) / (x2 – x1) > 0
• (prefix) (> ( / ( - y2 y1 ) (- x2 x1 ) ) 0)

13
Return Values
• Most functions (addition) have a return value that can be an integer, float, symbol,
string, or multivalued value.
• Some functions (facts, agenda commands) have no return values – just side effects.
• Return values for +, -, and * will be integer if all arguments are integer, but if at least
one value is floating point, the value returned will be float.

14
Variable Numbers of Arguments
• Many CLIPS functions accept variable numbers of arguments.
• Example:
• CLIPS> (- 3 5 7)  returns 3 - 5 = -2 - 7 = -9
• There is no built-in arithmetic precedence in CLIPS – everything is evaluated from
left to right.
• To compensate for this, precedence must be explicitly written.

15
Embedding Expressions
• Expressions may be freely embedded within other expressions:

16
Summing Values Using Rules
• Suppose you wanted to sum the areas of a group of rectangles.
• The heights and widths of the rectangles can be specified using the
deftemplate:

(deftemplate rectangle (slot height) (slot width))

• The sum of the rectangle areas could be specified using an ordered fact such as:
(sum 20)
Ordered fact = facts with a
relation name that does not
have a corresponding
deftemplate.
17
Summing Values
• A deffacts containing sample information is:

(deffacts initial-information
(rectangle (height 10) (width 6))
(rectangle (height 7) (width 5))
(rectangle (height 6) (width 8))
(rectangle (height 2) (width 5))
(sum 0))

Initialize sum = 0

18
Summing Values
(defrule sum-rectangles
(rectangle (height ?height) (width ?width))
?sum <- (sum ?total)
=>
(retract ?sum)
(assert (sum (+ ?total (* ?height ?width)))))

Computer Computer
hangs!!! hangs!!!

19
Summing Values

20
The Bind Function
• Sometimes it is advantageous to store a value in a temporary variable to avoid
recalculation.
• The bind function can be used to bind the value of a variable to the value of an
expression using the following syntax:

• (bind <variable> <value>)

21
I/O Functions
• When a CLIPS program requires input from the user of a program, a read function
can be used to provide input from the keyboard:

CLIPS>(defrule get-name
=>
(printout t “what is your name? “)
(bind ?response (read))
(assert (user’s-name ?response)))
CLIPS>(run)

22
Read Function from Keyboard
• The read function can only input a single field at a time.
• Characters entered after the first field up to the  are discarded.
• To input, say a first and last name, they must be delimited with quotes, “xxx xxx”.
• Data must be followed by a carriage return to be read.

23
Readline Function
• To read an entire line of input, the readline function can be
used:
(readline [<logical-name>])
• Example:

(defrule get-name
=>
(printout t “What is your name? “
(bind ?response (readline))
(assert (user’s-name ?response)))

24
Readline Function
• Continue from previous slide, if we type (reset) then (run),

CLIPS> (reset)
CLIPS> (run)
What is your name? CY Ting
CLIPS>(facts)
f-0 (initial-fact)
f-1 (user’s-name “CY Ting”)

25
Predicate Functions
• A predicate function is defined to be any function that returns:
• TRUE
• FALSE
• Any value other than FALSE is considered TRUE.
• We say the predicate function returns a Boolean value.

26
I/O from/to Files
• Input can also come from external files.
• Output can be directed to external files.
• Before a file can be accessed, it must be opened using the open function:

Example:
(open “mydata.dat” data “r”)

• mydata.dat – is the name of the file (path can also be provided)

27
I/O from/to Files
• data – is the logical name that CLIPS associates with the file
• “r” – represents the mode – how the file will be used – here read access
• The open function acts as a predicate function
• Returns true if the file was successfully opened
• Returns false otherwise

28
File Access Modes

29
Close Function
• Once access to the file is no longer needed, it should be closed.
• Failure to close a file may result in loss of information.
• General format of the close function:
• (close [<file-ID>])

(close data)  example

30
Reading / Writing to a File
• Which logical name used, depends on where information will be written – logical
name t refers to the terminal (standard output device).

31
Formatting
• Output sent to a terminal or file may need to be formatted – enhanced in
appearance.
• To do this, we use the format function which provides a variety of formatting styles.
• General format:
(format <logical-name> <control-string> <parameters>*)

32
Formatting
• Logical name – t – standard output device; or logical name associated with a file.
• Control string:
• Must be delimited with quotes
• Consists of format flags to indicate how parameters should be printed
• 1 – 1 correspondence between flags and number of parameters – constant values or expressions
• Return value of the format function is the formatted string – nil can be used to suppress printing.

33
Formatting
Example:
(format nil “Name: %-15s Age: %3d” “Bob Green” 35) 

Produces the results:

“Name: Bob green Age: 35”

34
 Specifications of Format Flag

• %-M.Nx

• The “-” means to left justify (right is the default)

• M = total field width – no truncation occurs

• N = number of digits of precision – default = 6

• x = display format specification

35
Display Format Specifications

36
The Test Conditional Element
• Processing of information often requires a loop.
• Sometimes a loop needs to terminate automatically as the result of an arbitrary
expression.
• The test condition provides a powerful way to evaluate expressions on the LHS of a
rule.
• Rather than pattern matching against a fact in a fact list, the test CE evaluates an
expression – outermost function must be a predicate function.

37
Test Condition
• A rule will be triggered only if all its test CEs are satisfied along with other patterns.

(test <predicate-function>)

Example:

(test (> ?value 1))

38
 Test Condition: Example
CLIPS> (defrule testing
(amount ?value)
(test (> ?value 2))
=>
(printout t "bigger!" crlf))
CLIPS> (assert (amount 5))
<Fact-1>
CLIPS> (run)
Bigger!

39
Predicate Field Constraint
• The predicate field constraint : allows for performing predicate tests directly within
patterns.
• The predicate field constraint is more efficient than using the test CE.
• It can be used just like a literal field constraint – by itself or part of a complex field.
• The predicate field constraint is always followed by a function for evaluation
(predicate function).
• Example:

(pizza-size ?size)
(pizza-size ?size&:(> ?size 1))
(test (> ?size 1)

40
Return Value Constraint
• The return value constraint = allows the return value of a function to be used for
comparison inside a pattern.
• The return value constraint must be followed by a function (not necessarily a
predicate function).
• The function must have a single-field return value.

41
Return Value Constraint
CLIPS> (clear)
CLIPS> (deftemplate data (slot x) (slot y))
CLIPS> (defrule twice
(data (x ?x) (y =(* 2 ?x)))
=>)
CLIPS> (assert (data (x 2) (y 4)) ; f-0
(data (x 3) (y 9))) ; f-1
<Fact-1>
CLIPS> (agenda)
0 twice: f-0
For a total of 1 activation.

42
The OR Conditional Element
• Consider the two rules:

43
OR Conditional Element
• These two rules can be combined into one rule – or CE requires
only one CE be satisfied:

44
The And Conditional Element
• The and CE is opposite in concept to the or CE – requiring all
the CEs be satisfied:

45
Not Conditional Element
• When it is advantageous to activate a rule based on the
absence of a particular fact in the list, CLIPS allows the
specification of the absence of the fact in the LHS of a rule
using the not conditional element:

46
Not Conditional
• We can implement this as follows:

47
The Exists Conditional Element
• The exists CE allows one to pattern match based on the existence of at least one fact
that matches a pattern without regard to the total number of facts that actually
match the pattern.
• This allows a single partial match or activation for a rule to be generated based on
the existence of one fact out of a class of facts.

48
Exists Conditional

49
Exists
• When more than one emergency fact is asserted, the message
to the operators is printed more than once. The following
modification prevents this:

50
Exists
• This assumes there was already an alert – triggered by an
operator-emergency rule. What if the operators were merely
placed on alert to a drill:

51
Exists
• Now consider how the rule has been modified using the exists CE:

(defrule operator-alert-for-emergency
(exists (emergency))
(not (operator-alert))
=>
(printout t “Emergency: Operator Alert” crlf)
(assert (operator-alert))))

52
 Forall / Logical
Conditional Elements
• The forall CE allows one to pattern match based on a set of CEs that are satisfied for
every occurrence of another CE.

• The logical CE allows one to specify that the existence of a fact depends on the
existence of another fact or group of facts.

• The general format of the forrall CE is as follows:

(forall <first-CE> <remaining-CEs>+)

53
Forall / Logical
Conditional Elements
• Each fact matching the <first-CE> must also have facts that match all of the
<remaining-CEs>.
(deftemplate emergency (slot type) (slot location))
(deftemplate fire-squad (slot name) (slot location))
(deftemplate evacuated (slot building))

(defrule all-fires-being-handled
(forall (emergency (type fire) (location ?where))
(fire-squad (location ?where))
(evacuated (building ?where)))
=>
(printout t “All buildings that are on fire “ crlf
“have been evacuated and” crlf
“have firefighters on location” crlf))

54
Forall / Logical
Conditional Elements

(emergency (type fire) (location A))

(fire-squad (location A))
(evacuated (building A))

(emergency (type fire) (location B))

(fire-squad (location B))
(evacuated (building B))

(emergency (type fire) (location C))

55
Forall / Logical
Conditional Elements

(emergency (type fire) (location A))

(fire-squad (location A))
(evacuated (building A))

(emergency (type fire) (location B))

(fire-squad (location B))
(evacuated (building B))

(emergency (type fire) (location C))

(fire-squad (location C))
(evacuated (building C))
56