1. 1 CS 385 Fall 2006 Chapter 6 Building Control Algorithms for State Space Search Read 6.0- 6.2

2. 2 Summary of Chapters 3 and 4 1.Problem solving is search through a set of problem states 2.The state space model uses graph theory to represent the problem as states and transitions 3.Characteristics of state space search a. Solution is a path from start state to a goal. b. Search systematically tests alternative paths to the goal c. Backtracking allows recovery from paths that fail to reach the goal. d. Lists track states under consideration. e. DFS uses a stack, BFS uses a queue, BFS uses a priority queue

3. 3 Formal Tools Predicate Calculus: 1.A language for capturing complex semantic information and for reasoning based on that information. (formal semantics and inference rules). 2.One could formulate a problem and perform reasoning by hand. State-Space Search: 1.States of a problem are nodes, problem transitions are arcs, a solution is a path from start node to goal. 2.Methods of searching state spaces (dfs, bfs, heuristics). 3.Data-driven versus goal-driven (where on the graph do you start).

4. 4 Tools (cont) Now: We have a formal way to describe a problem using predicate calculus. Next: Automate the search process via an algorithm (pattern- directed search) which will be applied to a space of logical inferences. Recursion-based search Production systems Blackboard architecture (omit)

5. 5 6.1.1 Recursion A natural for search Algorithms are easier to write easier to analyze formally Recursion consists of a base case a recursive component that resolves into a smaller version of the problem and ultimately to the base case

6. 6 Recursion for List Membership function member(item, tail) //Pascal syntax begin if list is empty then return(fail) else if item = first item of list then return(success) else begin tail=list with first item removed member(item, tail) end member(X, [X|T]).//PROLOG member(X,[Y|T]) :- member(X,T).

7. 7 DFS without/with Recursion procedure depth-first search open = [start]closed = [ ] while open ≠ [ ] do remove leftmost state of open, call it X if X is goal, return success. generate all children of X put X on closed put children of X not already on open or closed on the left end of open function depthsearch(current_state) if current_state is a goal then return success add current_state to closed while current_state has unexmd children child := next unexmd child if depthsearch(child) = success then return(success) return(fail)

8. 8 Trace DFS without/with Recursion goal= 6: openclosed [1][ ] [2,3][1] [4,5,3][2,1] [5,3][4,2,1] 1 [3][5,4,2,1] 2 3 [6, 7] 4 5 6 7 callclosed depthsearch(1)[1] depthsearch(2)[2,1] depthsearch(4)[4,2,1] depthsearch(5)[5,4,2,1] depthsearch(3) depthsearch(6) ←success Notes: 1. The path in maintained in the nested procedure calls. 2. To keep track of the path, retrieve at each successful exit. 3. The open list on left is kept by the procedure activations (e.g. you retain the information necessary to go back to pick up other children). 4. Children are not generated until needed. This is good if it is expensive to generate them.

9. 9 DFS in PROLOG? Represent the state space: % a binary tree move(1, 2). move(1, 3). move(2, 4). move(2, 5). move(3, 6). move(3, 7). %depthfirst with no output dfs1(X, X). dfs1(X, Y) :- move(X, Z), dfs1(Z, Y). Trace: move(1,5)? (1): move(1,2) dfs(2,5)? (3): move(2,4) dfs(4,5) fail (4): move(2,5) dfs(5,5) succeed Problems: no output %depthfirst with output dfs2(X, Y) :- move(X, Z), write('trying node '), write(Z), nl, dfs2(Z, Y).

10. 10 6.1.2 Pattern-Directed Search Apply recursive search to develop a general search procedure for predicate calculus. How is goal-directed search for predicate calculus recursive? identify subgoal(s) that imply the goal recur on the subgoal(s) success if a subgoal matches a fact in the knowledge base

11. 11 This leaves out two possibilities: current goal is negated (  p) - -success if the goal fails current goal is a disjunction (p ..) -- success if all are satisfied with consistent bindings And directions for consistent bindings Rewritten on p.198

12. 12 Prove h using pattern_search: a b c a  b → d a  c → e b  d → f f → g a  e → h goal(h) (unifies with a conclusion apply to premise e  a) goal(e) (unifies with a conclusion apply to premise c  a) goal(c) (unifies with a fact) true goal(a) (unifies with a fact) true ← e is true goal(a) (unifies with a fact) true ← h is true

13. 13 Production Systems Pattern-directed search: based on a set of production rules (similar to but different from a rep. in predicate calculus). Production system: a system for pattern-directed control of problem solving. A production system consists of 1. A set of production rules (productions) 2. Working memory 3. Recognize/act cycle

14. 14 6.2 Production Systems 1. A set of production rules (productions) (condition/action) pairs condition: when the action can be applied action: the problem-solving step (add something to known facts or do something) if it is cold or rainy then drive to work p(x)  q(x) 2. Working memory the current state of the world what's true production rules can alter this

15. 15 Production Systems 3. Recognize/act cycle match patterns in working memory against conditions of production rules. conflict set = those rules with matches select one member of conflict set to fire (perform the action) this will change the contents of the working memory Conflict resolution: pick which rule to fire. Often the first whose condition matches current state. Pure production systems: no way to recover from dead ends (backtrack)

16. 16 Rewrite Rules for Sorting a String Rewrite rules for sorting a string (productions) 1. ba  ab 2. ca  ac 3. cb  bc Task: sort cbaca IterationWorking memoryConflict setRule fired 0cbaca1 2 3 3 1bcaca2 2 2bacca1 2 2 3bacac1 22 4 baacc11 5abacc11 6aabcc

17. 17 Using the Rules in in Reverse Order Rewrite rules for sorting a string (productions) 1. ba  ab 2. ca  ac 3. cb  bc IterationWorking memoryConflict setRule fired 0cbaca1 2 3 3 1bcaca2 2 2bacca1 2 2 3bacac1 22 4 baacc11 5abacc11 6aabcc

18. 18 Production System: the Knights Tour Can a knight (chess) visit each square on a board once? productions: knight on 1  move knight to 8,... Is there a path from one square to another? control algorithm:  X path(X,X)  X,Y path(X,Y) ←  Z [move(X,Z)  path(Z,Y)]

19. 19 Knights Tour Is there a path from 1 to 3? IterationCurrent square Goal square Conflict set Fire rule 0133, 43 18313, 1413 233done! working memory

20. 20 Knights Tour Is there a path from 2 to 3? IterationCurrent square Goal square Conflict set Fire rule 0233, 43 19315, 1615 2233, 43 39313, 1413 working memory

21. 21 Production Systems Newell and Simon: production systems are a model for how humans solve problems. Why? rules  long term memory, working memory (state of the world)  short term memory

22. 22 Control of Search in Production Systems Review: production systems more general than pattern directed search sometimes easier to formulate. This section: production systems allow opportunities to add heuristic control to search. (pattern-directed as implemented by pure PROLOG allowed arrangement and structure of rules, but not much else) 1. Data driven versus goal driven: compare Figures 6.9 and 6.10 on next slides Actually many strategies are combinations. MYCIN: starts with symptoms and forward chains (data driven). If at some point it suspects a disease, backward chain (goal driven).

23. 23 Figure 6.9: Data-driven search in a production system.

24. 24 Figure 6.10: Goal-driven search in a production system.

25. 25 Control of Search in Production Systems 2. Through the rule structure. E.g. the order of premises. Compare gpa_over_3(X)  application_finished(X)  candidate(X) application_finished(X)  gpa_over_3(X)  candidate(X) Harder to finish application than to check the gpa Checking gpa first saves effort. 3. Through conflict resolution. Note, move(1,8) is before move(1.6) in knight’s tour. Often conflict resolution is by order of the rules so that matters. knight0: no control, path(1,7) works, path(1,4) and path(1,9) loop knight1: put a footstep where you have been. knight2: keep a list.

26. 26 Knights Tour in PROLOG knight0.pro: %productions move(1,6). move(1,8). move(2,7). move(2,9).... %control path(Z,Z). path(X,Y):- move(X,W), path(W,Y). Trace path(1,7): path(1,7): move(1,6) try path(6,7) move(6,1) try path(7,2) move(7,6) try path(6,2) Whoops.

27. 27 Knights Tour in PROLOG Resolution (knight1.pro): path(X,Y):- move(X,W), not(been(W)), assert(been(W)), path(W,Y). But this adds been(6) to the database Try path(1,6) twice and the second time fails knight2.pro: path(Z,Z,L). path(X,Y,L):- move(X,Z), not(member(Z, L)), path(Z, Y, [Z|L]).

28. 28 Trace path(1,7, [1]): path(1, 7, [1]). move(1, 6) not member(6, [1]) succeeds path(6, 7, [6, 1] move(6, 1) not member(1, [1]) fails move(6,7) not member(7, [6,1]) succeeds path(7, 7, [7, 6, 1]) writelist([7, 6, 1]) Ch 15 has a longer one. Try yourself. How does the result get printed in knight2.pro? knight2.pro move(1,6). move(1,8). move(2,7). move(2,9). move(3,4). move(3,8). move(4,3). move(4,9). path(Z,Z,L). path(X,Y,L):- move(X,Z), not(member(Z, L)), path(Z, Y, [Z|L]). move(6,1). move(6,7). move(7,2). move(7,6). move(8,1) move(8,3). move(9,2). move(9,4).

29. 29 Blackboard Architecture (omit) Cooperating knowledge sources that share information and results Communication through a blackboard. Really a way of breaking a problem into smaller ones

30. 30 Homework 1a 4. Draw the nodes and arcs for the legal moves. Each node will be a 4-tuple indicating who performs each of the four tasks. The tuples should be ordered by decreasing importance (fire, cakes, tea, and poetry). For example, (c s s e) indicates the child is feeding the fire, the servant is serving cakes and pouring tea, and the elder is reading poetry, 5. Complete part a in full detail. For b and c it suffices to list the order in which states are visited and the current list of closed states. Redo 5a. using the production system notation, producing a trace of execution similar to the tables on p. 169 7 for 2, not 8 of the moves. 9 10