1. AI in game (II) 권태경 Fall, 2006

2. outline Problem-solving agent Search

3. Problem-solving agent One kind of goal-based agent Finds a sequence of actions –That leads to desirable states Needs to do –Goal formulation Current situation and performance measure –Problem formulation The process of deciding what actions and states to consider, given a goal Level of detail

4. Problem-solving agent

5. Example: Romania On holiday in Romania; currently in Arad Flight leaves tomorrow from Bucharest Formulate goal: –be in Bucharest Formulate problem: –states: various cities –actions: drive between cities Find solution: –sequence of cities, e.g., Arad, Sibiu, Fagaras, Bucharest

6. Example: Romania Map

7. problem definition: 4 components A problem is defined by four items: 1.initial state e.g., “ in Arad" 2.actions or successor function S(x) = set of action – state pairs –e.g., S(Arad) = {, … } Or –Initial state and successor function define a state space (e.g. graph) 3.goal test, can be –explicit, e.g., x = “ in Bucharest" –implicit, e.g., Checkmate(x) 4.path cost (additive) –c(x,a,y): step cost of action a to go from state x to state y, assumed to be ≥ 0 –Path cost: sum of the costs of the actions along the path A solution is a sequence of actions leading from the initial state to a goal state

8. Schematic diagram Actions Initial state Goal test state space successor function

9. Problem definition in real world Real world is absolutely complex  state space must be abstracted for problem solving (Abstract) state = set of real states (Abstract) action = complex combination of real actions –e.g., "Arad  Zerind" represents a complex set of possible routes, detours, rest stops, etc. For guaranteed realizability, any real state "in Arad ” must get to some real state "in Zerind" (Abstract) solution is valid if it is mapped to –set of real paths that are solutions in the real world Each abstract action should be "easier" than the original problem –usefulness

10. Vacuum world state space graph states? actions? goal test? path cost? L: go Left R: go Right S: Suck

11. Vacuum world state space graph states? dirt (2 2 ) and robot location(2), total 8 actions? Left, Right, Suck goal test? no dirt at all locations path cost? 1 per action

12. Example: The 8-puzzle states? actions? goal test? path cost?

13. Example: The 8-puzzle states? locations of tiles (9!/2) actions? move blank left, right, up, down goal test? = goal state (given) path cost? 1 per move [Note: optimal solution of n-Puzzle family is NP-hard]

14. 15-Puzzle Sam Loyd offered $1,000 of his own money to the first person who would solve the following problem: 12 14 11 15 10 13 9 5678 4321 12 15 11 14 10 13 9 5678 4321 ?

15. But no one ever won the prize !!

16. outline Problem-solving agent Search

17. Solving is Searching Solving the problem is done by a search through the state space A solution is a path connecting the initial node to a goal node (any one) I G

18. Tree search algorithms Basic idea: –exploration of state space by generating successors of already-explored states (a.k.a.~expanding states)

19. Tree search example Initial state will be the root

20. Tree search example Whenever a state is generated (or visited or explored), its children nodes will be the next candidate states to explore (but not immediately!) Here “arad” is expanded –Children nodes are placed into the queue

21. Tree search example “sibiu” is expanded

22. Implementation: general tree search fringe: the set (here, q) of visited but not expanded nodes Make-node(e): creates a queue with e (element) Insert(e,q): inserts e to q (queue) Remove-front(q) returns first(q) InsertAll(e,q) inserts a set of elements into q

23. Implementation: general tree search The Expand function creates new nodes, filling in the various fields and using the SuccessorFn of the problem to create the corresponding states.

24. Implementation: states vs. nodes A state is a (representation of) a physical configuration A node is a data structure constituting part of a search tree includes state, parent node, action, path cost g(x), depth

25. Search strategies A search strategy is defined by picking the order of node expansion Strategies are evaluated along the following dimensions: –completeness: does it always find a solution if one exists? –time complexity: number of nodes generated –space complexity: maximum number of nodes in memory –optimality: does it always find a least-cost solution? Time and space complexity are measured in terms of –b: maximum branching factor of the search tree –d: depth of the least-cost solution –m: maximum depth of the state space (may be ∞)

26. Uninformed search strategies Uninformed search strategies use only the information available in the problem definition Also called blind search 5 approaches –Breadth-first search –Uniform-cost search –Depth-first search –Depth-limited search –Iterative deepening search

27. Breadth-first search Expand shallowest unexpanded node Implementation: –fringe is a FIFO queue, i.e., new successors go at end

28. Breadth-first search Expand shallowest unexpanded node Implementation: –fringe is a FIFO queue, i.e., new successors go at end

29. Breadth-first search Expand shallowest unexpanded node Implementation: –fringe is a FIFO queue, i.e., new successors go at end

30. Breadth-first search Expand shallowest unexpanded node Implementation: –fringe is a FIFO queue, i.e., new successors go at end

31. Properties of breadth-first search Complete? Yes (if b is finite) Time? 1+b+b 2 +b 3 + … +b d + b(b d -1) = O(b d+1 ) Space? O(b d+1 ) (keeps every node in memory) Optimal? Yes (if cost = 1 per step) Space is the bigger problem (more than time) d+1 level nodes are queued & If the last node is goal

32. Uniform-cost search Expand least-cost unexpanded node Implementation: –fringe = queue ordered by path cost Equivalent to breadth-first if step costs all equal Complete? Yes, if step cost ≥ ε –Should eliminate any zero-cost action Time? # of nodes with g() ≤ cost of optimal solution, O(b 1+  C*/ ε  ) where C * is the cost of the optimal solution Space? # of nodes with g() ≤ cost of optimal solution, O(b 1+  C*/ ε  ) Optimal? Yes – nodes expanded in increasing order of g() g(x): the path cost of a node x

33. Depth-first search Expand deepest unexpanded node Implementation: –fringe = LIFO queue, i.e., put successors at front

34. Depth-first search Expand deepest unexpanded node Implementation: –fringe = LIFO queue, i.e., put successors at front

35. Depth-first search Expand deepest unexpanded node Implementation: –fringe = LIFO queue, i.e., put successors at front

36. Depth-first search Expand deepest unexpanded node Implementation: –fringe = LIFO queue, i.e., put successors at front

37. Depth-first search Expand deepest unexpanded node Implementation: –fringe = LIFO queue, i.e., put successors at front Black nodes: expanded and no children nodes in memory

38. Depth-first search Expand deepest unexpanded node Implementation: –fringe = LIFO queue, i.e., put successors at front

39. Depth-first search Expand deepest unexpanded node Implementation: –fringe = LIFO queue, i.e., put successors at front

40. Depth-first search Expand deepest unexpanded node Implementation: –fringe = LIFO queue, i.e., put successors at front

41. Depth-first search Expand deepest unexpanded node Implementation: –fringe = LIFO queue, i.e., put successors at front

42. Depth-first search Expand deepest unexpanded node Implementation: –fringe = LIFO queue, i.e., put successors at front

43. Depth-first search Expand deepest unexpanded node Implementation: –fringe = LIFO queue, i.e., put successors at front

44. Depth-first search Expand deepest unexpanded node Implementation: –fringe = LIFO queue, i.e., put successors at front

45. Properties of depth-first search Complete? No: fails in infinite-depth spaces, spaces with loops –Modify to avoid repeated states along path  complete in finite spaces Time? O(b m ): terrible if m is much larger than d – but if solutions are dense, may be much faster than breadth-first Space? O(bm), i.e., linear space! Optimal? No m: the maximum depth of the tree

46. Depth-limited search = depth-first search with depth limit l, i.e., nodes at depth l have no successors