Lecture 2: Problem Solving and Search

Transcription

1 Lecture 2: Problem Solving and Search ACSC 368 Harris Papadopoulos Problem Solving as State-Space Search Consider finite problems that can be represented in terms of: an initial state, one or more goal states, and a set of operators to transform the system from one state to another. Solving the problem may correspond to: either reaching a goal state, or finding the best (or at least an acceptable) sequence of operations to reach a goal state. The Wolf, Goat and Cabbage Problem The Wolf, Goat and Cabbage Problem (cont.) A farmer and his wolf, goat, and cabbage come to the north side of a river that they wish to cross. There is a boat, but it has only room for two, and the farmer is the only one that can row. If the goat and the cabbage are left alone together, the goat will eat the cabbage. Similarly, if the wolf and the goat are together without the farmer, the goat will be eaten. Devise a series of crossings of the river so that all concerned make it across safely. itial State: Goal State: Operators: Wolf, goat, cabbage and farmer are on the north side of the river. Wolf, goat, cabbage and farmer are on the south side of the river. Farmer can move one thing at a time across the river in the boat, or he can cross alone. But the goat cannot be left alone with the cabbage or with the wolf. Prolog Representation of WGC Prolog Representation of WGC initial(([f, w, g, c], [])). final(([], [f, w, g, c])). % operators of the form: % next_state(state, NewState) next_state(([f N], S), (N, [f S])) :- move(n, S, N, S), safe(n). next_state((n, [f S]), ([f N], S)) :- move(s, N, S, N), safe(s). % move of w, or g, or c, and not f move(a, B, A, B). move(a, B, A, [M B]) :- select(m, A, A). % when is a side of the river safe if the farmer is not there? safe([g]). safe(l) :- not(member(g, L)).

2 Blind Search Systematic exploration of a search tree, making no use of knowledge about the particular problem. Depth-first search: Search used by the Prolog interpreter. Simple to implement, but may get stuck in an infinite branch and fail to find a goal state in another branch. May not find shortest route to goal. Breadth-first search: Visit all states at one level before moving on to the next. Will inevitably find a shortest route to a goal state, but requires a large amount of memory. Depth-First Search 2 A B C 3 D 4 E F Go H J K 8 Go L M N O P 6 Q 7 R S T U V Depth-First Search Algorithm To extend a path into an answer-path do if the path has reached a goal state then return it as an answer-path else if the current path can be extended to a new state then save the current state and continue to extend the path from the new state else backtrack to extend the path from the previous state to a different child To extend the path into a new state do find another state which can be reached from the last state in the path; the state found is the new state Depth-First Search Algorithm To extend a path into an answer-path do if the path has reached a goal state then return it as an answer-path else if the current path can be extended to a new state then save the current state and continue to extend the path from the new state else backtrack to extend the path from the previous state to a different child To extend the path into a new state do find another state which can be reached from the last state in the path and which does not already occur in the path; the state found is the new state Depth-First Search in Prolog depth_first_search(anspath) :- initial(it), depth_first([it], AnsPath). depth_first([s Path], [S]) :- final(s),!. depth_first([s Path], [S AnsPath]) :- extend([s Path], S), depth_first([s, S Path], AnsPath). extend([s Path], S) :- next_state(s, S), not(member(s, [S Path])). Breadth-First Search 2 A 3 B 4 C D 6 E 7 F 8 Go H J K Go L M N O P 2

3 Breadth-First Search Algorithm To search for an answer-path do create a queue containing a single path consisting of the initial state, and apply the breadth-first procedure to expand this queue until an answer-path is found. To expand a queue do if any path in the queue has reached a goal state then return that path as an answer-path else expand the first path of the queue in all possible ways creating a list of the resulting paths, append the list of extended paths to the end of the queue, remove the first path from the queue, and continue to expand the new queue Breadth-First Search Algorithm (cont.) To expand a path in all possible ways and create a list of the resulting paths do collect all paths S + path, where S is an extended state of path, into a list Breadth-First Search in Prolog breadth_first_search(anspath) :- initial(it), breadth_first([[it]], AnsPath). breadth_first(pathq, AnsPath) :- member([s RestP], PathQ), final(s),!, reverse([s RestP], AnsPath). breadth_first([path RestQ], AnsPath) :- expand(path, NewPaths), append(restq, NewPaths, PathQ), breadth_first(pathq, AnsPath). expand(path, List) :- setof([s Path], extend(path, S), List),!. expand(path, []). % in case setof fails: node has no successor Heuristic Search The use of heuristics, based on knowledge of the problem, improves the efficiency of a search process by providing a control strategy. Its effect is to prune the search tree. Heuristics are rules of thumb. They often provide a good solution but not necessarily the best: they are approximations and are not guaranteed to be right. They may even lead to a dead end. Heuristics may just be incorporated in operations (e.g. this state, such-and-such is likely to be a sensible action ). More usefully we calculate a heuristic evaluation function, which estimates the value of a possible next state. Evaluation Functions An evaluation function maps a problem state to a numeric value, which measures the desirability of that state relative to the problem to be solved; the smallest the value for a state, the more desirable it is. Which aspects of the problem state are considered, how these are evaluated, and how much weight is given to each one, are chosen in such a way that the value of the function at a given node in the search tree gives as good an estimate as possible of whether that node is on the path to a solution. Examples: Chess: Material advantage of the player. Route-finding: Distance from destination. Hill-Climbing Search Depth-First Search guided by an evaluation function (6) 2 A (28) B (29) C (48) 3 D 4 E (32) F Go H (22) J (36) (24) (3) (0) (29) K Go L M N (9) O P (2) (0) (2) (33) (88) (32) (24) (27) (6) (6) (3) 3

4 Hill-Climbing Search Algorithm To extend a path into an answer-path do if the path has reached a goal state then return it as an answer-path else if the current path can be extended to a new state then save the current state and continue to extend the path from the best new state else backtrack to extend the path from the previous state to the next best child To extend the path into the best new state do create a list of all possible states which can be reached from the last state in the path ordered in increasing value, and find the first state in this list which does not already occur in the path; this is the best new state Hill-Climbing Search in Prolog hill_climb_search(anspath) :- initial(it), hill_climb([it], AnsPath). hill_climb([s Path], [S]) :- final(s),!. hill_climb([s Path], [S AnsPath]) :- extend_best([s Path], S), hill_climb([s, S Path], AnsPath). extend_best([s Path], S) :- best_next_state(s, S), not(member(s, [S Path])). best_next_state(s, S) :- setof((v,ns), (next_state(s,ns), value(ns,v)), List), member((v, S), List). Best-First Search Breadth-First Search guided by an evaluation function (6) 2 A (28) 4 B (29) C (48) 3 D (24) E (32) F Go H (22) J (36) (3) (0) (29) K Go L M N (9) O P (2) (0) (2) (33) (88) (32) (24) (27) (6) (6) (3) Best-First Search Algorithm To search for an answer-path do start with a list containing just the initial state and its value, and apply the best-first procedure to expand this path-list until an answer-path is found. To expand a path-list with best-first search do if the first path in the list has reached a goal state then return that path as an answer-path else expand the first path in the list in all possible ways, creating a list of the resulting paths ordered in increasing value of the last state in each path, then merge this list with the list of the remaining paths to get a new ordered list, and continue to expand the new list Best-First Search in Prolog best_first_search(anspath) :- initial(it), value(it, V), best_first([[v,it]], AnsPath). best_first([[_,s Path] _], AnsPath) :- final(s),!, reverse([s Path], AnsPath). best_first([path Rest], AnsPath) :- expand(path, NewPaths), merge(newpaths, Rest, NewList), best_first(newlist, AnsPath). expand([_ Path], List) :- setof([v,s Path], (extend(path,s), value(s,v)), List),!. expand(_, []). % in case setof fails: node has no successor Best-First Search in Prolog (cont.) merge([], L, L) :-!. merge(l, [], L) :-!. merge([h T], [H2 T2], [H Rest]) :- less(h, H2),!, merge(t, [H2 T2], Rest). merge(l, [H2 T2], [H2 Rest]) :- merge(l, T2, Rest). less([v Path], [V2 Path2]) :- V < V2. Note: The first element of each list that represents a path, is the value of the last state in that path. 4

5 Cost Functions A cost function gives a path from the initial to the current state a numeric value. Normally one is looking for a path to the goal state with the smallest possible value of the cost function. This can be used in heuristic search: Best-cost search = breadth-first search + cost function Best-path search = breadth-first search + cost function + evaluation function Examples: Route-finding: Distance travelled. Repairing a car: Time to reach given state of repair, or financial cost Best-Cost Search Breadth-First Search guided by a cost function 4 A B 2 C D 8 E F Go 3 H 6 J K 0 Go L M N 7 O P Best-Cost Search in Prolog best_cost_search(anspath) :- initial(it), best_cost([[0,it]], AnsPath). best_cost([[_,s Path] _], AnsPath) :- final(s),!, reverse([s Path], AnsPath). best_cost([path Rest], AnsPath) :- expand(path, NewPaths), merge(newpaths, Rest, NewList), best_cost(newlist, AnsPath). Best-Cost Search in Prolog (cont.) expand([c, S Path], List) :- setof([c, S, S Path], (extend([s Path], S), costsum(s, C, S, C)), List),!. expand(_, []). costsum(s, C, S, C) :- cost(s, S, D), C is C + D. % in case setof fails: node has no successor Best-Path Search (A*) Breadth-First Search guided by cost + evaluation functions (6) A (28) 3 B (29) C (48) D (24) (32) E 4 F Go H (22) J (36) 8 9 (3) (0) (29) K 7 Go L M N (9) O P (2) (0) (2) (33) (88) (32) (24) (27) (6) (6) (3) Best-Path Search in Prolog best_path_search(anspath) :- initial(it), value(it, V), best_path([[v, V, it]], AnsPath). best_path([[_, _, S Path] _], AnsPath) :- final(s),!, reverse([s Path], AnsPath). best_path([path Rest], AnsPath) :- expand(path, NewPaths), merge(newpaths, Rest, NewList), best_path(newlist, AnsPath).

6 Best-Path Search in Prolog (cont.) expand([c, V, S Path], List) :- setof([c, V, S, S Path], (extend([s Path], S), recost(s,c,v,s,c,v)), List),!. expand(_, []). % in case setof fails: node has no successor recost(s, C, V, S, C, V) :- value(s, V), cost(s, S, D), C is C V + D + V. Optimality of A* The best-path, or A*, search algorithm uses a combined heuristic function as follows: For each node state n in the search tree, let g(n) be the cost of reaching that node, i.e. the sum of the costs of each step in the path to the node (exact), and h'(n) be the value of the evaluation function at node n (estimate). Then A* search minimises the combined function ƒ(n) where, ƒ(n) = g(n) + h'(n). It turns out that if the evaluation function h'(n) satisfies certain conditions, A* search is both complete and optimal. Optimality of A* Suppose the real value of the evaluation function is h(n). Then it can be proved that if h'(n) h(n) for every state n, the A* algorithm will never return a suboptimal path to the goal. Such an evaluation function, that never overestimates the cost to reach the goal, is said to be an admissible heuristic. Admissible heuristics are by nature optimistic, because they think the cost of solving the problem is less than it actually is. Explanation: Since g(n) is the exact cost to reach n, then if h'(n) is admissible we have as immediate consequence that ƒ(n) never overestimates the true cost of a solution through n. Developing Search Trees To develop a search tree, start at the initial state and carry out the search algorithm, only adding states to the tree when they are reached by path expansion under the algorithm. Do not include any repeated states on a given path through the tree. (States can of course be duplicated on different paths.) Stop the tree development, on a goal state, only when the algorithm would finish (which is not necessarily the first goal state found). Developing Search Trees for Heuristic Algorithms the case of heuristic search algorithms, the developed tree illustrates how the algorithm in question prunes back the search tree. order to develop the search tree of a given heuristic algorithm based on breadth-first, you need to create a table showing the path list considered by that algorithm at each point of time, together with the list generated by the expansion of each path. The paths in the resulting lists should also include their value and/or cost. Problem Characteristics The problem-solving approach may depend on the characteristics of the problem in question: Decomposable? Recovery possible from bad steps? Predictable universe? Obvious which is good solution? Is desired solution a state or a path? Does solving the problem require a large amount of knowledge? Human help needed? 6

7 Given the state-space graph: (9) 2 3 () Revision Exercise A B C (7) (4) 4 7 D (2) E (4) 4 6 Go (0) Develop the search tree created by the best-path (A*) search algorithm, making clear the order in which states are expanded. Adversary Search (Game Playing) Consider the simplest type of game: Deterministic (non-probabilistic) Open (fully observable environment) Two-player Turn-taking Zero-sum (equal and opposite utility functions of players at the end of the game) Example Game Placing Dominoes Placing Dominoes Game Tree Each player places a domino in turn to cover exactly two squares, on a 3 by 3 board. One player ( ) can place dominoes horizontally, and the other player ( You ) can place dominoes vertically. The winner is the last one who will be able to place a domino. The tree for this game is shown in the next slide. You - (You win) You - - Minimax Search Most game search trees are too large to look at all possible consequences of a move. So how well we play will depend on how far ahead we look (disregarding higher knowledge based on pattern matching and recognition), and how well we evaluate each possible state. Suppose we have an evaluation function applicable to each state of play (e.g. material value in pieces of chess). We can then choose the next move with the highest value. I would choose A. One-Ply Search A B C (8) (3) (-2) 7

8 You Minimise Maximise Two-Ply Search A B C D E F G H J K (9) (-6) (0) (0) (-2) (-4) (-3) (n) is the value of the evaluation function for each state from my viewpoint. Whereas I try to maximise the state as I see it, you try to minimise it. So to decide which move to take looking two steps ahead, I must back up the values. this case I would choose B as my next move. Minimax Value backing up the values of the end nodes we assume that both players play optimally. So for our moves, we back up the highest values, whereas for the opponent s moves, we back up the lowest values. The resulting value of each state is called its minimax value. Exercise - Three-Ply Search Suppose I look three steps ahead: You Minimise Max. L Maximise A B C D E F G H J K M N O P W X Y (8) (-2) () (3) (-0) (-2) (2) (4) () (-3) (3) (-) (7) (2) Now which move should I choose from? 8