Classical Problem Solving

1
Classical Problem Solving

• Design of Computer
• Problem Solvers
• CS 344
• Winter 2000

2
Last time

• AI programming versus conventional programming
• Emphasis on knowledge representation
• Overview of systems
• Homework 0
• Preview of homework 1

3
This weeks themes

• Problem-solvers see the world in terms of problem
  spaces
• Describe the problem in its own terms, and let
  Lisp make up the difference

4
Components of a Problem Space

• States (conditions of the world)
• Initial state (where we are)
• Goal state (where we want to be)
• Operators (actions that can change the current
  state)
• Problem solving
• Construct a path of states, using available
  operators, from initial to goal state

Problem-solvers see the world in terms of
problem spaces
5
Sample Problem Spaces

• Subway travel
• Initial state Davis Street
• Goal state Morse Street
• Operators Take purple line, take red line
• Chess
• Initial state Board setup
• Goal state Checkmate condition
• Operators Chess moves

Problem-solvers see the world in terms of
problem spaces
6
How to characterize a problem space

• Characterizing states
• Often symbols or propositional expressions
• Comparing states
• Choosing operators
• Operator applicability (can we use it?)
• Operator preference (is it the best one?)
• Search strategy
• When do we backtrack? Breadth or depth-first? Use
  means-end analysis?

Problem-solvers see the world in terms of
problem spaces
7
Methods for choosing operators

• When is an operator applicable?
• Preconditions
• Which applicable operator is best?
• First available
• May assume that operators written in order of
  preference (e.g., travel ops ordered by speed)
• Random
• Choose one--if it doesnt work out, try other.
• Distance metric
• Pick a metric that tells us which is best

Problem-solvers see the world in terms of
problem spaces
8
Why study the classical method of problem solving?

• Historically early method in AI
• GPS (Newell Simon, 1963)
• STRIPS (Fikes Nilsson, 1971)
• Descendants still viable SOAR, Deep Blue
• Provides a vocabulary for discussing problem
  solving
• States, operators, and problem spaces

Problem-solvers see the world in terms of
problem spaces
9
Classical Problem Solving

• Separation between the search method and the
  problem space
• Search method generic search methods
• Problem space representation of problem as set
  of states and operators

Problem Space
Search Engine
10
How Problem Spaces provide modularity and
explicitness
Search Engine
Problem Space Representation
11
Basic search methods

• Breadth-first
• Try all applicable operators before choosing
  secondary operators
• Depth-first
• On the operator chosen, continue searching until
  either goal is reached or search fails
• Best-first
• Use a distance metric to choose best operator
  each time

12
Building CPS

• Need a problem space API between a problem
  space and the search engine
• Requirements
• Way to describe basic characteristics of states
  and operators in problem space
• Should provide multiple, interchangable search
  engines
• Should work with novel problem spaces

Describe the problem in its own terms, and let
Lisp make up the difference.
13
Constructing a pluggable classical problem
solver

• Whats a pluggable data structure?
• Why build a pluggable problem space obj?
• Search engines, to be general, need a consistent
  API for the problem space
• No guarantee that all problem spaces will respect
  that API
• Use a pluggable class, called Problem, which
  mediates between the two and allow an arbitrary
  problem space to be used with many different
  search engines.

Describe the problem in its own terms, and let
Lisp make up the difference.
14
PROBLEM Defstruct
Code

• Each problem object defines a particular problem
  space
• E.g., taking subway from MIT to aquarium
• Requires following functions to define problem
  space
• Goal recognizer
• State identicality test
• Print states
• Applicable operators for given state
• Distance function

Once we have these, we can create generic
search engines that will work with any problem
space.
15
Using pluggable function slots
Function description
PROBLEM slot
When has goal been found? Return set of
applicable operators Are states the same? Remove
path from possible paths? Estimate of distance to
goal Print state Print solution path segment
Goal-recognizer Operator-applier States-identical
Path-filter Distance-remaining State-printer Solut
ion-element-printer
Code
16
Path object structure
Code

• Records a particular solution path in terms of
  intermediate states and operators
• Has links back to the problem space, so that a
  path struct can be taken and extended easily.

17
State and Operator defstructs?

• Wheres the state defstruct?
• Wheres the op defstruct?
• CPS code doesnt define them.
• Instead
• Operator and state data structures are implicit
  in the comparison functions
• Operator-applier, states-identical?,
  goal-recognizer, distance-remaining, state-printer

Describe the problem in its own terms, and let
Lisp make up the difference.
18
Basic search methods

• Breadth-first
• Try all applicable operators before choosing
  secondary operators
• Depth-first
• On the operator chosen, continue searching until
  either goal is reached or search fails
• Best-first
• Use a distance metric to choose best operator
  each time

19
Bsolve function (simplified)

• (defun bsolve (initial aux curr-path new-paths)
• Apply breadth-first search to problem space.
• (do ((queue (list (list initial initial))
• (append (cdr queue) new-paths)))
• ((null queue))
• (setq curr-path (car queue))
• (when (goal-recognized? (car curr-path)
• (return curr-path))
• (setq new-paths (extend-path curr-path))

20
Extend-path (simplified)

• (defun extend-path (path aux new-paths new-path
  pr)
• Extend the given path, and return a list of
  possible paths1
• (setq pr (path-pr path))
• (dolist (op (pr-operators pr) new-paths)
• (dolist (op-pair (apply-op path op pr))
• (setq new-path
• (make-path
• (add-to-path path (cdr op-pair) (car
  op-pair))))
• (unless (path-has-loop? new-path) avoid
  loops
• (unless (and (pr-path-filter pr)
• (funcall (pr-path-filter pr)
  new-path))
• (push new-path new-paths))))))

21
Extend-path (simplified)

• (defun extend-path (path aux new-paths new-path
  pr)
• Extend the given path, and return a list of
  possible paths1
• (setq pr (path-pr path))
• (dolist (op (pr-operators pr) new-paths)
• (dolist (op-pair (apply-op path op pr))
• (setq new-path
• (make-path
• (add-to-path path (cdr op-pair) (car
  op-pair))))
• (unless (path-has-loop? new-path) avoid
  loops
• (unless (and (pr-path-filter pr)
• (funcall (pr-path-filter pr)
  new-path))
• (push new-path new-paths))))))

Apply each op to paths end state.
22
Extend-path (simplified)

• (defun extend-path (path aux new-paths new-path
  pr)
• Extend the given path, and return a list of
  possible paths1
• (setq pr (path-pr path))
• (dolist (op (pr-operators pr) new-paths)
• (dolist (op-pair (apply-op path op pr))
• (setq new-path
• (make-path
• (add-to-path path (cdr op-pair) (car
  op-pair))))
• (unless (path-has-loop? new-path) avoid
  loops
• (unless (and (pr-path-filter pr)
• (funcall (pr-path-filter pr)
  new-path))
• (push new-path new-paths))))))

Apply domain-specific filter.
23
Bsolve function (simplified)

• (defun bsolve (initial aux curr-path new-paths)
• Apply breadth-first search to problem space.
• (do ((queue (list (list initial initial))
• (append (cdr queue) new-paths)))
• ((null queue))
• (setq curr-path (car queue))
• (when (goal-recognized? (car curr-path)
• (return curr-path))
• (setq new-paths (extend-path curr-path))

24
Bsolve function (simplified)
Fifo queue
(defun bsolve (initial aux curr-path new-paths)
Apply breadth-first search to problem space.
(do ((queue (list (list initial initial))
(append (cdr queue) new-paths)))
((null queue)) (setq curr-path (car queue))
(when (goal-recognized? (car curr-path)
(return curr-path)) (setq new-paths
(extend-path curr-path))
25
Code
Bsolve function (simplified)
Fifo queue
(defun bsolve (initial aux curr-path new-paths)
Apply breadth-first search to problem space.
(do ((queue (list (list initial initial))
(append (cdr queue) new-paths)))
((null queue)) (setq curr-path (car queue))
(when (goal-recognized? (car curr-path)
(return curr-path)) (setq new-paths
(extend-path curr-path))
Check current state to see if goal reached
26
Dsolve
LIFO
(append new-paths (cdr queue)))
27
The Agenda type determines the search
characteristics
FIFO Breadth-first
LIFO Depth-first
28
More search variants (variants.lsp)

• Best-first search
• Estimate distance from goal for each solution
  path
• Sort queue so that closest solution paths tried
  first
• How good must the distance metric be?
• Beam search
• Same as best-first search, but limit size of
  queue to a fixed beam width

29
Example 1 Subway navigation
Lets use our search engine to tackle a
commonly-used search space the Boston T
30
Building the representation

• Representation
• Stations the lines they are on, x-y map
  coordinates
• Lines the stations on that line
• Problem space mapping
• State station
• Operator Take the line to another station
• Definition mechanism
• T definitions

Describe the problem in its own terms, and let
Lisp make up the difference.
31
Stations

• (defstruct (subway-station (PRINT-FUNCTION
  subway-station-print-procedure))
• "Data structure representating a single subway
  station."
• (name nil) Name of station.
• (lines nil) Subways lines it is on.
• (coordinates nil)) For advanced CPS versions
  which use a distance metric.
• (defun subway-station-print-procedure (pr str
  ignore)
• "Print name of station."
• (declare (ignore ignore))
• (format str "ltStation Agt" (subway-station-name
  pr)))

32
Defining a station

• (defvar KENDALL-SQUARE)
• (setq KENDALL-SQUARE
• (make-subway-station
• name Kendall-square
• lines (RED-LINE)
• coordinates (1 . 0))
• (push Kendall-square (subway-line-stations
  RED-LINE))
• (push Kendall-square stations)

33
Defining a station

• (defmacro defstation (name lines optional (x 0)
  (y 0))
• "Define a subway station."
• (progn
• (defvar ,name)
• (setq ,name (make-subway-station
• NAME ',name
• LINES ',lines
• COORDINATES (cons ,x ,y)))
• ,_at_ (mapcar '(lambda (line)
• (push ',name
  (subway-line-stations ,line))) lines)
• (push ',name stations)))

34
Defining a station

• (defvar KENDALL-SQUARE)
• (setq KENDALL-SQUARE
• (make-subway-station
• name Kendall-square
• lines (RED-LINE)
• coordinates (1 . 0))
• (push Kendall-square (subway-line-stations
  RED-LINE))
• (push Kendall-square stations)
• (defstation Kendall-Square (Red-Line) 1.0 0.0)

Describe the problem in its own terms, and let
Lisp make up the difference.
35
Defining a station

• (defstation South-Station (Red-Line) 3.0 -1.0)
• (defstation Washington (Red-Line Orange-Line)
  2.75 -0.75)
• (defstation Kendall-Square (Red-Line) 1.0 0.0)
• (defstation Central-Square (Red-Line) -1.0 0.0)
• (defstation Harvard-Square (Red-Line) -2.0 1.0)
• (defline Red-Line)
• (defline Green-Line)
• (defline Orange-Line)
• (defline Blue-Line)

Describe the problem in its own terms, and let
Lisp make up the difference.
36
Setting up Subway problem
PROBLEM
? ? ? ? ? ? ?
Goal-recognizer Operator-applier States-identical
Path-filter Distance-remaining State-printer Solut
ion-element-printer
37
Setting up Subway problem
PROBLEM
Subway-states-identical? Subway-operator-finder Su
bway-states-identical? Prune-subway-path Subway-di
stance Format Print-subway-path
Goal-recognizer Operator-applier States-identical
Path-filter Distance-remaining State-printer Solut
ion-element-printer
RUN
38
Test run
39
Next time Algebra!

• Bradys example
• log (x1) log(x-1) c.

40
Classical Problem Solving, II

• Design of Computer
• Problem Solvers
• CS 344
• Winter 2000

41
Lessons from last time

• Constructing problem spaces
• See a problem in terms of a problem space
• How to construct a pluggable problem space
• Represent the problem in its own terms
• Search engines
• Breadth, Depth, and Best-First
• Fitting the representation to the task
• DefLine, DefStation.

42
Today Solving algebraic expressions

• Algebra as a problem space
• Alan Bundys model for heuristic-based
  simplification of algebra problems.
• Building the system
• Representing states and operators
• Pattern matching
• How to build it
• Making canonical expressions
• Homework 1
• Preview of homework 2 (Natural Deduction)

43
A quick example Bundys challenge

• 1. loge(x1) loge (x-1) c.
• 2. loge(x1) (x-1) c.
• 3. logex2-1 c.
• 4. x2-1ec.
• 5. x2 ec 1.
• 6. x /- sqrt(ec 1).

44
Algebra as a Problem Space

• The problem space is the transformational grammar
• States valid sentences within that grammar
• Operators transformation operators
• Solving algebraic expressions
• 3X 5X - 2. What is the value for X?
• Significant expert-novice differences
• What do expects know that novices dont?

45
Algebra as a Problem Space

• States Algebraic equations
• Initial state Starting equation.
• Goal state Version of equation with X (unknown)
  on the left.
• Operators Transformations of the equation using
  various algebraic laws.
• PathSets of transformations.
• Distance metric ??

Data structures?
46
Bundys Claim

• Experts have control knowledge that lets them
  avoid many false paths
• This knowledge limits the needed search
• Transform equations to reduce the depth and
  frequency of unknown variable.
• Each transformation either reduces the number of
  unknowns, or brings them closer together.
• Three kinds of methods isolation methods,
  collection methods, and attraction methods.
• This is best understood by graphing the equation.

47
Isolation methods

• Reduces the depth of the occurrences of the
  unknown
• Examples
• U - W Y U Y W
• log(U,w) Y U WY
• Assumptions
• U contains x, Y W do not.

48
Isolation methods
Reduce the depth of unknowns.
3. logex2-1 c. 4. x2-1ec.
Depth4.
Depth3.
49
Collection methods

• Reduce the number of occurrences of the unknown
• Examples
• UW UY U(WY)
• (U V)(U - V) U2 - V2
• Assumptions
• U and V contain x, W Y do not.

50
Collection methods
Collect together multiple instances of the
unknown
2. loge(x1) (x-1) c. 3. logex2-1 c.
One less X.
51
Attraction methods

• Bring occurrences of the unknown closer
  together
• Examples
• WU WV W(U V)
• log(U,w) log(V,w) log(UV,w)
• Assumptions
• U and V expressions contain x
• W expression does not.

52
Attraction methods
Bring occurrences of the unknown closer together
Distance4.
1. loge(x1) loge (x-1) c. 2. loge(x1)
(x-1) c.
Distance2.
53
A quick derivation, revisited.

• 1. loge(x1) loge (x-1) c.
• 2. loge(x1) (x-1) c.
• 3. logex2-1 c.
• 4. x2-1ec.
• 5. x2 ec 1.
• 6. x /- sqrt(ec 1).

• 1. Initial
• 2. Attract log sum.
• 3. Collect prod diffs
• 4. Isolate log.
• 5. Isolate difference.
• 6. Isolate square

54
Algebra as a problem space

• States Algebraic equations
• Initial state Starting equation.
• Goal state Version of equation with X (unknown)
  on the left.
• Operators Transformations of the equation using
  various algebraic laws.
• PathSets of transformations.
• Distance metric ??

Data structures?
55
Implementing Bundys idea

• States equations in Lisp form
• ( (- U W) Y) for U - W Y.
• Operators
• Functions which perform individual isolation,
  collection and attraction methods
• Distance metric
• Function that measures depth and frequence of X.
• Glue
• Flexible pattern matcher for operators and
  simplifier rules
• Simplifier rules run after each operation
• Canonicalize expressions

56
Pluggable problem space
Function description
PROBLEM slot
When has goal been found? Return set of
applicable operators Are states the same? Remove
path from possible paths? Estimate of distance to
goal Print state Print solution path
segment Operator list
Goal-recognizer Operator-applier States-identical
Path-filter Distance-remaining State-printer Solut
ion-element-printer Operators
57
Pluggable problem space

• Search Engine
• bsolve
• dsolve
• best-solve

58
Setting up Algebra problem solver
PROBLEM
? ? ? ? ? ? ?
Goal-recognizer Operator-applier States-identical
Path-filter Distance-remaining State-printer Solut
ion-element-printer
59
Setting up Algebra problem solver
PROBLEM
Got-algebra-goal? Find-algebra-operator Equal NIL
Algebra-distance Format Print-derivative-step
Goal-recognizer Operator-applier States-identical
Path-filter Distance-remaining State-printer Solut
ion-element-printer Operators
60
Some of these functions are easy

• Got-algebra-goal?
• Find-algebra-operator (misnamed, btw).
• States-identical EQUAL
• But wait, what about
• ( ( x y) z) vs. ( z ( y x))?
• This leaves
• The operators themselves
• The pattern matcher
• The distance metric

61
Got algebra goal

• (defun occurs-in? (exp1 exp2)
• "True if expression 1 is contained somewhere in
  expression 2."
• (cond ((equal exp1 exp2) t)
• ((null exp2) nil)
• ((listp exp2)
• (or (occurs-in? exp1 (car exp2))
• (occurs-in? exp1 (cdr exp2))))))
• (defun has-unknown? (exp)
• "True if expression contains unknown value."
• (occurs-in? 'x exp))
• (defun no-unknown? (exp)
• "True if expression contains no unknown
  values."
• (not (occurs-in? 'x exp)))

(defun got-algebra-goal? (state) "Has goal of
algebra problem been met?" (and (eq
(cadr state) 'x) LHSX (no-unknown?
(rhs state))))
62
Canonicalization

• Equations must be canonicalized to allow for
  better matching of expressions
• Get rid of trivial cases
• ( x 0) gt x.
• ( 3 7) gt 10.
• Flatten trees
• ( (x y) z) gt ( x y z).
• Sort the terms
• ( z x b) gt ( b x z).

63
Building the operators

• Requires ability to match particular patterns and
  then transform them.
• Well need a pattern matcher
• Operators
• Isolation, collection attraction
• Also a canonicalization operator
• Will canonicalize the expression, if needed.
• Will throw in a bunch of trivial
  simplifications.
• Also needs a pattern matcher

64
Creating a pattern matcher

• For matching
• (? x) Matches symbol, binding to pattern var
  X
• (?? x) Matches sequence, binding to segment
  var X
• (? x test) Matches single symbol x that also
  returns true when passed to function test.
• Matcher returns either a set of bindings or FAIL
• (match ( (? A) (? B) (? C)) ( 1 2 3)) returns
  ((c 3) (b 2) (a 1))
• For simplification
• subst function for instantiating matched
  patterns.
• (eval ( (? X) (? Y))) Matches X and Y, and
  then adds them and returns that value.
• splice act similarly, but splices result into
  list.

65
Tree-walking for dummies
Tree-walking Apply Foo to every element in tree
thing. Function foo-treewalk (thing) Null
thing? Return nil. Atom thing? Then Foo
Thing. List thing? Foo-treewalk the
car(thing). Foo-treewalk the cdr(thing).
66
Creating a pattern matcher

• (defun match (pat dat optional (dict nil))
• "Take a single pattern and data, and return
  any matches based on the pattern. Dictionary
  contains binding list."
• (cond ((eq dict FAIL) FAIL) Propagate
  lossage
• ((eq pat dat) dict)
• ((element-var? pat)
• (match-element-var pat dat dict))
• ((not (consp pat))
• (if (equal? pat dat) dict FAIL))
• ((segment-var? (car pat))
• (match-segment-var pat dat dict))
• ((not (consp dat)) FAIL)
• (t (match (cdr pat) (cdr dat)
• (match (car pat) (car dat)
  dict)))))

67
Creating a pattern matcher

• (defun match-element-var (pat dat dict aux entry
  pred)
• "Match single element pattern variable to given
  data, using
• the bindings in dictionary. Returns either
  FAIL or updated binding dictionary."
• (setq entry (lookup-var pat dict))
• (cond (entry
• (if (equal? (cadr entry) dat) dict FAIL))
• (t (setq pred (var-restriction pat))
• (cond ((or (not pred)
• (funcall pred dat))
• (bind-element-var (var-name pat) dat dict))
• (t FAIL)))))

68
Creating a pattern matcher

• (defun match-segment-var (pat dat dict aux entry
  rest)
• "Given sequence pattern variable, attempt
  matching. Returns either bindings or FAIL."
• (setq entry (lookup-var (car pat) dict))
• (cond (entry check for match
• (setq rest
• (check-segment dat (segment-beg entry)
• (segment-end
  entry)))
• (if (eq rest FAIL) FAIL
• (match (cdr pat) rest dict)))
• (t Search for alternate segment bindings
• (try-segment-bindings (car pat) (cdr pat) dat
  dict))))

69
Uses of the pattern matcher

• Two uses
• Bundys method operators
• Simplifier rules for canonicalization operator

70
Simplifier rules

• Simplifier rules are used by the canonicalization
  operator
• Identities x 0 x x 1 x.
• Canonicalization Ordering operands for
  consistant matching
• Evaluation computing the function of constants
• Canonicalization operator runs all the simplifier
  rules each time it is called.

71
Simplifier rules

• Rules have simple before/after pattern.
• Flush degenerate cases
• ((? op /?) (? e)) (? e))
• (( (? zero zero?) (?? e)) ( (?? e)))
• Combine numerical constants
• (((? op /?) (? e1 numberp) (? e2
  numberp) (?? e3))
• ((? op) (EVAL ((? op) (? e1) (? e2)))
  (?? e3)))
• ((- (? e1 numberp) (? e2 numberp)) (EVAL
  (- (? e1) (? e2))))
• ((- (? e1 numberp)) (EVAL (- (? e1))))
• Flatten ,
• (((? op /?) (?? e1) ((? op) (?? e2) (??
  e3)))
• ((? op) (?? e1) (?? e2) (?? e3)))
• Canonicalize ,
• (((? op /?)
• (?? terms,'(lambda (terms) (not
  (sorted? terms 'alglt)))))
• ((? op) (SPLICE (EVAL (sort (quote (?
  terms)) 'alglt)))))

72
Canonicalization operator

• TRY-CANONICALIZATION
• -gt SIMPLIFY
• -gt SIMPLIFY-IT
• -gt TRY-MATCHER-RULES
• (defun try-matcher-rules (exp rules)
• Return the original expression by default
• (dolist (rule rules exp)
• (let ((bindings (match (rule-pattern rule)
  exp nil)))
• (unless (eq bindings FAIL)
• (return-from try-matcher-rules
• (substitute-in (rule-result rule)
• bindings))))))

73
Setting up Algebra problem solver
PROBLEM
Got-algebra-goal? Find-algebra-operator Equal NIL
Algebra-distance Format Print-derivative-step
Goal-recognizer Operator-applier States-identical
Path-filter Distance-remaining State-printer Solut
ion-element-printer Operators
74
Setting up the operators in the problem space

• (defun setup-algebra-problem ()
• "Create an generic algebra 'problem space'."
• (make-problem
• NAME 'Algebra
• GOAL-RECOGNIZER 'got-algebra-goal?
• OPERATOR-APPLIER 'find-algebra-operator
• STATE-PRINTER '(lambda (f) (format nil "A"
  f))
• SOLUTION-ELEMENT-PRINTER 'print-derivation-st
  ep
• STATES-IDENTICAL? 'equal
• DISTANCE-REMAINING 'algebra-distance
• OPERATORS '((Isolate-Log try-isolate-log)
• (Isolate-Sum try-isolate-sum)
• (Isolate-Difference
  try-isolate-difference)
• (Isolate-Square
  try-isolate-square)
• (Collect-Product-Difference
  try-collect-prod-diff)
• (Attract-Log-Sum
  try-attract-log-sum)
• (Canonicalize try-canonicalization
  ))))

(defun find-algebra-operator (state operator)
Operators take the form (ltnamegt ltproceduregt)
(funcall (cadr operator) state))
75
Building the rest of the operators

• Attempt to match the current expression
• If it fails, return FAIL
• If it succeeds, do the substitution and simplify.

76
Operators

• Example
• (defun try-isolate-square (form aux bindings)
• (setq bindings
• (match '( (sqr (? arg has-unknown?))
• (? rhs no-unknown?))
• form))
• (unless (eq bindings FAIL)
• (,(cons (isolate-square ,form)
• (simplify (substitute-in ( (? arg)
  (sqrt (? rhs)))
• 
  bindings))))))

77
Operators
Operators

• Example
• (defun try-isolate-square (form aux bindings)
• (setq bindings
• (match '( (sqr (? arg has-unknown?))
• (? rhs no-unknown?))
• form))
• (unless (eq bindings FAIL)
• (,(cons (isolate-square ,form)
• (simplify (substitute-in ( (? arg)
  (sqrt (? rhs)))
• 
  bindings))))))

Attempt to match X2 expression.
78
Operators
Operators

• Example
• (defun try-isolate-square (form aux bindings)
• (setq bindings
• (match '( (sqr (? arg has-unknown?))
• (? rhs no-unknown?))
• form))
• (unless (eq bindings FAIL)
• (,(cons (isolate-square ,form)
• (simplify (substitute-in ( (? arg)
  (sqrt (? rhs)))
• 
  bindings))))))

Attempt to match X2 expression.
If success, substitute bindings into new
expression
79
Attraction and Collection Ops

• (defun try-collect-prod-diff (form aux bindings
  results)
• (dolist (ldt (find-least-dominating-terms form)
  results)
• (setq bindings
• (match '( ( (? v no-unknown?)
• (? u has-unknown?))
• (- (? u) (? v)))
• ldt))
• (unless (eq bindings FAIL)
• (push (cons (collect-product-sum ,ldt)
• (simplify
• (subst (substitute-in
• (- (sqr (? U)) (sqr (? V)))
• bindings)
• ldt form)))
• results))))

80
Setting up Algebra problem solver
PROBLEM
Got-algebra-goal? Find-algebra-operator Equal NIL
Algebra-distance Format Print-derivative-step
Goal-recognizer Operator-applier States-identical
Path-filter Distance-remaining State-printer Solut
ion-element-printer Operators
81
Algebra-distance

• (defun algebra-distance (expr)
• "Estimate how close this expression is to
  solution, return number."
• (labels ((sum-tree-depth
• (exp depth)
• (cond ((null exp) 0)
• ((eq exp 'X) depth)
• ((not (listp exp)) 0)
• (t ( (sum-tree-depth (car exp) (1 depth))
• (sum-tree-depth (cdr exp) depth))))))
• ( (sum-tree-depth (lhs expr) 1)
• (sum-tree-depth (rhs expr) 1))))

82
Running the system
83
Moral For working through a problem space,
control knowledge is essential

• Bundys insights
• It is not enough to know what the rules are
• Control knowledge needed to know when to apply
  particular rules
• Careful analysis of a domain can avoid a lot of
  search
• More leverage in domain-specific knowledge than
  in domain-general search techniques
• Imposing a problem-space on a problem
• Represent the problem in its own terms
• Not done here as much, but in Subway problem.
• Homework fix this.

84
Homework 1
Due January 21 by midnight!

• Build a better algebra system.
• Chapter 3, Problem 5 (parts a b), then extend
  system to solve 10 problems given on web page.

85
Better operator definitions
(defun try-collect-prod-diff (form aux bindings
results) (dolist (ldt (find-least-dominating-term
s form) results) (setq bindings (match '( (
(? v no-unknown?) (? u has-unknown?))
(- (? u) (? v))) ldt)) (unless (eq
bindings FAIL) (push (cons (collect-product-s
um ,ldt) (simplify (subst
(substitute-in (- (sqr (? U)) (sqr (?
V))) bindings) ldt form)))
results))))

• Before
• After

(defAlgebraOperator collect-prod-diff COLLECTION
(Uv)(U-v) gt (U2 - V2). ( ( (? v
no-unknown?) (? u has-unknown?))
(- (? u) (? v))) (- (sqr (? U)) (sqr (? V))))
86
Reading for next week

• Chapters 4-5 on Pattern-Directed Rule Systems
• Download code for TRE and FTRE
• Note
• Natural deduction system implemented for FTRE,
  but not TRE.

87
Homework 2 Preview

• Extend the Natural Deduction system to use
  premises and goals.
• BPS, pp. 148-149
• Exercise 17, (a) and (b)
• Exercise 18, (a), (b), and (c)
• Hints
• Start early if possible.
• Run the ND examples with the debug flag on, and
  contemplate the output carefully before modifying
  the rule set.
• Building a driver loop that automates the testing
  process (and turns the debug flag on and off
  cleverly) will make your life easier.

Due January 28 by midnight!