CS B351 : Intro to AI and Computer Simulation

1. CS B351: Intro to AI and Computer Simulation Instructor: Kris Hauser http://cs.indiana.edu/~hauserk

2. Agenda • Searching, data structures, and algorithms • Breadth-first search • Depth-first search • Uniform-cost search

3. Defining a Search Problem S • State space S • Successor function: x  S  SUCC(x)  2S • Initial state s0 • Goal test: xS GOAL?(x) =T or F • Arc cost

4. State Graph • Each state is represented by a distinct node • An arc (or edge) connects a node s to a node s’ if s’ SUCC(s) • The state graph may contain more than one connected component

5. I Solution to the Search Problem • A solution is a path connecting the initial node to a goal node (any one) • The cost of a path is the sum of the arc costs along this path • An optimal solution is a solution path of minimum cost • There might be no solution ! G

6. 8 8 2 2 8 2 7 3 3 4 4 7 7 3 4 5 5 1 1 6 6 5 1 6 8 2 3 4 7 8 2 8 4 2 3 4 7 3 7 5 1 6 5 1 6 5 1 6 Search Graph!= State Graph If states are allowed to be revisited,the search tree may be infinite even when the state space is finite

7. 8 2 PARENT-NODE 3 4 7 BOOKKEEPING 5 1 6 STATE CHILDREN Action Right Depth 5 ... Path-Cost 5 yes Expanded Search Graph Node != State Depth of a node N = length of path from root to N (depth of the root = 0)

8. 8 2 8 2 7 3 4 7 3 4 5 1 6 5 1 6 Fringe of Search Tree • The fringe is the set of all search nodes that haven’t been expanded yet 8 2 3 4 7 5 1 6 8 2 7 3 4 5 1 6 8 2 8 2 3 4 7 3 4 7 5 1 6 5 1 6

9. Search Strategy • The fringe is the set of all search nodes that haven’t been expanded yet • The fringe is implemented as a priority queue FRINGE • INSERT(node,FRINGE) • REMOVE(FRINGE) • The ordering of the nodes in FRINGE defines the search strategy

10. Search Algorithm #1 SEARCH#1 1. If GOAL?(initial-state) then return initial-state 2. INSERT(initial-node,FRINGE) 3.Repeat: 4. If empty(FRINGE) then return failure 5.N REMOVE(FRINGE) 6.s  STATE(N) 7. For every state s’ in SUCCESSORS(s) 8. Create a new node N’ as a child of N 9. If GOAL?(s’) then return path or goal state 10. INSERT(N’,FRINGE) Expansion of N

11. Blind Search Strategies

12. Arc cost = 1 Arc cost = c(action) 0 Blind Strategies • Breadth-first • Bidirectional • Depth-first • Depth-limited • Iterative deepening • Uniform-Cost(variant of breadth-first)

13. 1 2 3 4 5 6 7 Breadth-First Strategy • New nodes are inserted at the end of FRINGE FRINGE = (1)

14. 1 2 3 4 5 6 7 Breadth-First Strategy • New nodes are inserted at the end of FRINGE FRINGE = (2, 3)

15. 1 2 3 4 5 6 7 Breadth-First Strategy • New nodes are inserted at the end of FRINGE FRINGE = (3, 4, 5)

16. 1 2 3 4 5 6 7 Breadth-First Strategy • New nodes are inserted at the end of FRINGE FRINGE = (4, 5, 6, 7)

17. Performance Measures • CompletenessA search algorithm is complete if it finds a solution whenever one exists[What about the case when no solution exists?] • OptimalityA search algorithm is optimal if it returns a minimum-cost path whenever a solution exists • ComplexityIt measures the time and amount of memory required by the algorithm

18. Important Parameters • Maximum number of successors of any state branching factor b of the search tree • Minimal length (≠ cost) of a path between the initial and a goal state depth d of the shallowest goal node in the search tree

19. Evaluation • b: branching factor • d: depth of shallowest goal node • Breadth-first search is: • Complete? Not complete? • Optimal? Not optimal?

20. Evaluation • b: branching factor • d: depth of shallowest goal node • Breadth-first search is: • Complete • Optimal if step cost is 1 • Number of nodes generated: ???

21. Evaluation • b: branching factor • d: depth of shallowest goal node • Breadth-first search is: • Complete • Optimal if step cost is 1 • Number of nodes generated: 1 + b + b2 + … + bd= ???

22. Evaluation • b: branching factor • d: depth of shallowest goal node • Breadth-first search is: • Complete • Optimal if step cost is 1 • Number of nodes generated: 1 + b + b2+ … + bd = (bd+1-1)/(b-1) = O(bd) •  Time and space complexity is O(bd)

23. Time and Memory Requirements Assumptions: b = 10; 1,000,000 nodes/sec; 100bytes/node

24. Time and Memory Requirements Assumptions: b = 10; 1,000,000 nodes/sec; 100bytes/node

25. 1 1 2 2 3 3 4 4 5 5 6 6 7 7 8 8 9 9 10 10 11 11 12 12 ? 13 13 14 15 15 14 Remark • If a problem has no solution, breadth-first may run forever (if the state space is infinite or states can be revisited arbitrary many times)

26. s Bidirectional Strategy 2 fringe queues: FRINGE1 and FRINGE2 Time and space complexity isO(bd/2)  O(bd) if both trees have the same branching factor b Question: What happens if the branching factor is different in each direction?

27. 2 3 FRINGE = (1) 4 5 Depth-First Strategy • New nodes are inserted at the front of FRINGE 1

28. 2 3 FRINGE = (2, 3) 4 5 Depth-First Strategy • New nodes are inserted at the front of FRINGE 1

29. 2 3 FRINGE = (4, 5, 3) 4 5 Depth-First Strategy • New nodes are inserted at the front of FRINGE 1

30. 2 3 4 5 Depth-First Strategy • New nodes are inserted at the front of FRINGE 1

31. 2 3 4 5 Depth-First Strategy • New nodes are inserted at the front of FRINGE 1

32. 2 3 4 5 Depth-First Strategy • New nodes are inserted at the front of FRINGE 1

33. 2 3 4 5 Depth-First Strategy • New nodes are inserted at the front of FRINGE 1

34. 2 3 4 5 Depth-First Strategy • New nodes are inserted at the front of FRINGE 1

35. 2 3 4 5 Depth-First Strategy • New nodes are inserted at the front of FRINGE 1

36. 2 3 4 5 Depth-First Strategy • New nodes are inserted at the front of FRINGE 1

37. 2 3 4 5 Depth-First Strategy • New nodes are inserted at the front of FRINGE 1

38. Evaluation • b: branching factor • d: depth of shallowest goal node • m: maximal depth of a leaf node • Depth-first search is: • Complete? • Optimal?

39. Evaluation • b: branching factor • d: depth of shallowest goal node • m: maximal depth of a leaf node • Depth-first search is: • Complete only for finite search tree • Not optimal • Number of nodes generated (worst case): 1 + b + b2+ … + bm = O(bm) • Time complexity is O(bm) • Space complexity is O(bm) [or O(m)] • [Reminder: Breadth-first requires O(bd) time and space]

40. Depth-Limited Search • Depth-first with depth cutoff k (depth at which nodes are not expanded) • Three possible outcomes: • Solution • Failure (no solution) • Cutoff (no solution within cutoff)

41. Iterative Deepening Search • Provides the best of both breadth-first and depth-first search • Main idea: Totally horrifying ! IDS For k = 0, 1, 2, … do: Perform depth-first search with depth cutoff k (i.e., only generate nodes with depth  k)

42. Iterative Deepening

43. Iterative Deepening

44. Iterative Deepening

45. Performance • Iterative deepening search is: • Complete • Optimal if step cost =1 • Time complexity is: (d+1)(1) + db + (d-1)b2 + … + (1) bd= O(bd) • Space complexity is: O(bd) or O(d)

46. Calculation db + (d-1)b2 + … + (1) bd =bd+2bd-1 +3bd-2 +… +db = (1 + 2b-1 + 3b-2 + … + db-d)bd  (Si=1,…,ib(1-i))bd = bd(b/(b-1))2

47. Number of Generated Nodes (Breadth-First & Iterative Deepening) • d = 5 and b = 2 120/63 ~ 2

48. Number of Generated Nodes (Breadth-First & Iterative Deepening) • d = 5 and b = 10 123,456/111,111 ~ 1.111

49. Recap • BFS: Complete, optimal • O(bd) time and space • DFS: Not complete nor optimal • O(bd) space, unbounded time • ID: Complete, optimal • O(bd) space, O(bd) time

50. Related Topics • Non-unit costs • Revisited states • Heuristic search