1. CS 416 Artificial Intelligence Lecture 3 Uninformed Searches Lecture 3 Uninformed Searches

2. Romania On holiday in Romania; currently in Arad. Flight leaves tomorrow from Bucharest at 1:00. Let’s configure this to be an AI problem. On holiday in Romania; currently in Arad. Flight leaves tomorrow from Bucharest at 1:00. Let’s configure this to be an AI problem.

3. Romania What’s the problem? Accomplish a goalAccomplish a goal –Reach Bucharest by 1:00 So this is a goal-based problem What’s the problem? Accomplish a goalAccomplish a goal –Reach Bucharest by 1:00 So this is a goal-based problem

4. Romania Is there more to it? Do it well… according to a performance measureDo it well… according to a performance measure –Minimize distance traveled Is there more to it? Do it well… according to a performance measureDo it well… according to a performance measure –Minimize distance traveled

5. Romania What’s an example of a non-goal-based problem? Live long and prosperLive long and prosper Maximize the happiness of your trip to RomaniaMaximize the happiness of your trip to Romania Don’t get hurt too muchDon’t get hurt too much What’s an example of a non-goal-based problem? Live long and prosperLive long and prosper Maximize the happiness of your trip to RomaniaMaximize the happiness of your trip to Romania Don’t get hurt too muchDon’t get hurt too much

6. Romania What qualifies as a solution? You can/cannot reach Bucharest by 1:00You can/cannot reach Bucharest by 1:00 You can reach Bucharest in x hoursYou can reach Bucharest in x hours The shortest path to Bucharest passes through these citiesThe shortest path to Bucharest passes through these cities The sequence of cities in the shortest path from Arad to Bucharest is ________The sequence of cities in the shortest path from Arad to Bucharest is ________ The actions one takes to travel from Arad to Bucharest along the shortest pathThe actions one takes to travel from Arad to Bucharest along the shortest path What qualifies as a solution? You can/cannot reach Bucharest by 1:00You can/cannot reach Bucharest by 1:00 You can reach Bucharest in x hoursYou can reach Bucharest in x hours The shortest path to Bucharest passes through these citiesThe shortest path to Bucharest passes through these cities The sequence of cities in the shortest path from Arad to Bucharest is ________The sequence of cities in the shortest path from Arad to Bucharest is ________ The actions one takes to travel from Arad to Bucharest along the shortest pathThe actions one takes to travel from Arad to Bucharest along the shortest path

7. Romania What additional information does one need? A mapA map What additional information does one need? A mapA map

8. More concrete problem definition A state space Which cities could you be in An initial state Which city do you start from A goal state Which city do you aim to reach A function defining state transitions When in city foo, the following cities can be reached A function defining the “cost” of a state sequence How long does it take to travel through a city sequence

9. More concrete problem definition A state space Choose a representation An initial state Choose an element from the representation A goal state Create goal_function(state) such that TRUE is returned upon reaching goal A function defining state transitions successor_function(state) = {,, …} A function defining the “cost” of a state sequence cost (sequence) = number

10. State Space Real world is absurdly complex  state space must be abstracted for problem solving (Abstract) state = set of real states(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.(Abstract) action = complex combination of real actions, e.g., “Arad  Zerind” represents a complex set of possible routes, detours, rest stops, etc. (Abstract) solution = set of real paths that are solutions in the real world(Abstract) solution = set of real paths that are solutions in the real world Each abstract action should be “easier” than the original problem and should permit expansion to a more detailed solution Real world is absurdly complex  state space must be abstracted for problem solving (Abstract) state = set of real states(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.(Abstract) action = complex combination of real actions, e.g., “Arad  Zerind” represents a complex set of possible routes, detours, rest stops, etc. (Abstract) solution = set of real paths that are solutions in the real world(Abstract) solution = set of real paths that are solutions in the real world Each abstract action should be “easier” than the original problem and should permit expansion to a more detailed solution

11. Important notes about this example Static environment (available states, successor function, and cost functions don’t change)Static environment (available states, successor function, and cost functions don’t change) Observable (the agent knows where it is… percept == state)Observable (the agent knows where it is… percept == state) Discrete (the actions are discrete)Discrete (the actions are discrete) Deterministic (successor function is always the same)Deterministic (successor function is always the same) Static environment (available states, successor function, and cost functions don’t change)Static environment (available states, successor function, and cost functions don’t change) Observable (the agent knows where it is… percept == state)Observable (the agent knows where it is… percept == state) Discrete (the actions are discrete)Discrete (the actions are discrete) Deterministic (successor function is always the same)Deterministic (successor function is always the same)

12. Problem Solving Agents Restricted form of general agent: function SIMPLE-PROBLEM-SOLVING-AGENT(percept) returns an action static: seq, an action sequence, initially empty static: seq, an action sequence, initially empty state, some description of the current world state state, some description of the current world state goal, a goal, initially null goal, a goal, initially null problem, a problem definition problem, a problem definition state <- UPDATE-STATE(state, percept) state <- UPDATE-STATE(state, percept) if seq is empty then if seq is empty then goal <- FORMULATE-GOAL(state) goal <- FORMULATE-GOAL(state) problem <- FORMULATE-PROBLEM(state, goal) problem <- FORMULATE-PROBLEM(state, goal) seq <- SEARCH(problem) seq <- SEARCH(problem) action <- RECOMMENDATION(seq, state) action <- RECOMMENDATION(seq, state) seq <- REMAINDER(seq, state) seq <- REMAINDER(seq, state) return action return action Restricted form of general agent: function SIMPLE-PROBLEM-SOLVING-AGENT(percept) returns an action static: seq, an action sequence, initially empty static: seq, an action sequence, initially empty state, some description of the current world state state, some description of the current world state goal, a goal, initially null goal, a goal, initially null problem, a problem definition problem, a problem definition state <- UPDATE-STATE(state, percept) state <- UPDATE-STATE(state, percept) if seq is empty then if seq is empty then goal <- FORMULATE-GOAL(state) goal <- FORMULATE-GOAL(state) problem <- FORMULATE-PROBLEM(state, goal) problem <- FORMULATE-PROBLEM(state, goal) seq <- SEARCH(problem) seq <- SEARCH(problem) action <- RECOMMENDATION(seq, state) action <- RECOMMENDATION(seq, state) seq <- REMAINDER(seq, state) seq <- REMAINDER(seq, state) return action return action

13. Vacuum world example Floor has two locationsFloor has two locations Vacuum can move from one location to the otherVacuum can move from one location to the other Locations are clean/dirtyLocations are clean/dirty Vacuum can clean the location in which it isVacuum can clean the location in which it is Clean the floorClean the floor Floor has two locationsFloor has two locations Vacuum can move from one location to the otherVacuum can move from one location to the other Locations are clean/dirtyLocations are clean/dirty Vacuum can clean the location in which it isVacuum can clean the location in which it is Clean the floorClean the floor

14. Example: Vacuum World state space graph States: Integer dirt and robot locations (ignore dirt amounts)Integer dirt and robot locations (ignore dirt amounts)Actions: Left, Right, Suck, NoOpLeft, Right, Suck, NoOp Goal test: No dirtNo dirt Path cost: 1 per action (0 for NoOp)1 per action (0 for NoOp)States: Integer dirt and robot locations (ignore dirt amounts)Integer dirt and robot locations (ignore dirt amounts)Actions: Left, Right, Suck, NoOpLeft, Right, Suck, NoOp Goal test: No dirtNo dirt Path cost: 1 per action (0 for NoOp)1 per action (0 for NoOp)

15. Example: Vacuum World state space graph States? Actions? Goal test? Path cost?

16. Other Examples Fifteen Puzzle Robotic Assembly Traveling Salesman Protein Design Fifteen Puzzle Robotic Assembly Traveling Salesman Protein Design 10319 135711 1581412 246

17. Tree Search Algorithms Basic idea: Simulated exploration of state space by generating successors of already explored states (AKA expanding states)Simulated exploration of state space by generating successors of already explored states (AKA expanding states) function TREE-SEARCH(problem, strategy) returns a solution, or failure returns a solution, or failure initialize the search tree using the initial state of problem initialize the search tree using the initial state of problem loop do loop do if there are no more candidates for expansion then return failure if there are no more candidates for expansion then return failure choose a leaf node for expansion according to strategy if the node contains a goal state then return the corresponding solution else expand the node and add the resulting nodes to the search tree else expand the node and add the resulting nodes to the search tree end end Basic idea: Simulated exploration of state space by generating successors of already explored states (AKA expanding states)Simulated exploration of state space by generating successors of already explored states (AKA expanding states) function TREE-SEARCH(problem, strategy) returns a solution, or failure returns a solution, or failure initialize the search tree using the initial state of problem initialize the search tree using the initial state of problem loop do loop do if there are no more candidates for expansion then return failure if there are no more candidates for expansion then return failure choose a leaf node for expansion according to strategy if the node contains a goal state then return the corresponding solution else expand the node and add the resulting nodes to the search tree else expand the node and add the resulting nodes to the search tree end end

18. Example: Arad  Bucharest function TREE-SEARCH(problem, strategy) returns a solution, or failure returns a solution, or failure initialize the search tree using the initial state of problem initialize the search tree using the initial state of problem loop do loop do if there are no more candidates for expansion then return failure if there are no more candidates for expansion then return failure choose a leaf node for expansion according to strategy if the node contains a goal state then return the corresponding solution else expand the node and add the resulting nodes to the search tree else expand the node and add the resulting nodes to the search tree end end function TREE-SEARCH(problem, strategy) returns a solution, or failure returns a solution, or failure initialize the search tree using the initial state of problem initialize the search tree using the initial state of problem loop do loop do if there are no more candidates for expansion then return failure if there are no more candidates for expansion then return failure choose a leaf node for expansion according to strategy if the node contains a goal state then return the corresponding solution else expand the node and add the resulting nodes to the search tree else expand the node and add the resulting nodes to the search tree end end Arad

19. Example: Arad  Bucharest function TREE-SEARCH(problem, strategy) returns a solution, or failure returns a solution, or failure initialize the search tree using the initial state of problem initialize the search tree using the initial state of problem loop do loop do if there are no more candidates for expansion then return failure if there are no more candidates for expansion then return failure choose a leaf node for expansion according to strategy if the node contains a goal state then return the corresponding solution else expand the node and add the resulting nodes to the search tree else expand the node and add the resulting nodes to the search tree end end function TREE-SEARCH(problem, strategy) returns a solution, or failure returns a solution, or failure initialize the search tree using the initial state of problem initialize the search tree using the initial state of problem loop do loop do if there are no more candidates for expansion then return failure if there are no more candidates for expansion then return failure choose a leaf node for expansion according to strategy if the node contains a goal state then return the corresponding solution else expand the node and add the resulting nodes to the search tree else expand the node and add the resulting nodes to the search tree end end Arad

20. Example: Arad  Bucharest function TREE-SEARCH(problem, strategy) returns a solution, or failure returns a solution, or failure initialize the search tree using the initial state of problem initialize the search tree using the initial state of problem loop do loop do if there are no more candidates for expansion then return failure if there are no more candidates for expansion then return failure choose a leaf node for expansion according to strategy if the node contains a goal state then return the corresponding solution else expand the node and add the resulting nodes to the search tree else expand the node and add the resulting nodes to the search tree end end function TREE-SEARCH(problem, strategy) returns a solution, or failure returns a solution, or failure initialize the search tree using the initial state of problem initialize the search tree using the initial state of problem loop do loop do if there are no more candidates for expansion then return failure if there are no more candidates for expansion then return failure choose a leaf node for expansion according to strategy if the node contains a goal state then return the corresponding solution else expand the node and add the resulting nodes to the search tree else expand the node and add the resulting nodes to the search tree end end Arad

21. Example: Arad  Bucharest function TREE-SEARCH(problem, strategy) returns a solution, or failure returns a solution, or failure initialize the search tree using the initial state of problem initialize the search tree using the initial state of problem loop do loop do if there are no more candidates for expansion then return failure if there are no more candidates for expansion then return failure choose a leaf node for expansion according to strategy if the node contains a goal state then return the corresponding solution else expand the node and add the resulting nodes to the search tree else expand the node and add the resulting nodes to the search tree end end function TREE-SEARCH(problem, strategy) returns a solution, or failure returns a solution, or failure initialize the search tree using the initial state of problem initialize the search tree using the initial state of problem loop do loop do if there are no more candidates for expansion then return failure if there are no more candidates for expansion then return failure choose a leaf node for expansion according to strategy if the node contains a goal state then return the corresponding solution else expand the node and add the resulting nodes to the search tree else expand the node and add the resulting nodes to the search tree end end Arad Zerind (75) Timisoara (118) Sibiu (140)

22. Example: Arad  Bucharest function TREE-SEARCH(problem, strategy) returns a solution, or failure returns a solution, or failure initialize the search tree using the initial state of problem initialize the search tree using the initial state of problem loop do loop do if there are no more candidates for expansion then return failure if there are no more candidates for expansion then return failure choose a leaf node for expansion according to strategy if the node contains a goal state then return the corresponding solution else expand the node and add the resulting nodes to the search tree else expand the node and add the resulting nodes to the search tree end end function TREE-SEARCH(problem, strategy) returns a solution, or failure returns a solution, or failure initialize the search tree using the initial state of problem initialize the search tree using the initial state of problem loop do loop do if there are no more candidates for expansion then return failure if there are no more candidates for expansion then return failure choose a leaf node for expansion according to strategy if the node contains a goal state then return the corresponding solution else expand the node and add the resulting nodes to the search tree else expand the node and add the resulting nodes to the search tree end end Arad Zerind (75) Timisoara (118) Sibiu (140)

23. Example: Arad  Bucharest function TREE-SEARCH(problem, strategy) returns a solution, or failure returns a solution, or failure initialize the search tree using the initial state of problem initialize the search tree using the initial state of problem loop do loop do if there are no more candidates for expansion then return failure if there are no more candidates for expansion then return failure choose a leaf node for expansion according to strategy if the node contains a goal state then return the corresponding solution else expand the node and add the resulting nodes to the search tree else expand the node and add the resulting nodes to the search tree end end function TREE-SEARCH(problem, strategy) returns a solution, or failure returns a solution, or failure initialize the search tree using the initial state of problem initialize the search tree using the initial state of problem loop do loop do if there are no more candidates for expansion then return failure if there are no more candidates for expansion then return failure choose a leaf node for expansion according to strategy if the node contains a goal state then return the corresponding solution else expand the node and add the resulting nodes to the search tree else expand the node and add the resulting nodes to the search tree end end Arad Zerind (75) Timisoara (118) Sibiu (140)

24. Example: Arad  Bucharest function TREE-SEARCH(problem, strategy) returns a solution, or failure returns a solution, or failure initialize the search tree using the initial state of problem initialize the search tree using the initial state of problem loop do loop do if there are no more candidates for expansion then return failure if there are no more candidates for expansion then return failure choose a leaf node for expansion according to strategy if the node contains a goal state then return the corresponding solution else expand the node and add the resulting nodes to the search tree else expand the node and add the resulting nodes to the search tree end end function TREE-SEARCH(problem, strategy) returns a solution, or failure returns a solution, or failure initialize the search tree using the initial state of problem initialize the search tree using the initial state of problem loop do loop do if there are no more candidates for expansion then return failure if there are no more candidates for expansion then return failure choose a leaf node for expansion according to strategy if the node contains a goal state then return the corresponding solution else expand the node and add the resulting nodes to the search tree else expand the node and add the resulting nodes to the search tree end end Arad Zerind (75) Timisoara (118) Sibiu (140) Dradea (151) Faragas (99) Rimnicu Vilcea (80)

25. Implementation: states vs. nodes State (Representation of) a physical configuration(Representation of) a physical configurationNode Data structure constituting part of a search treeData structure constituting part of a search tree –Includes parent, children, depth, path cost g(x) States do not have parents, children, depth, or path cost! State (Representation of) a physical configuration(Representation of) a physical configurationNode Data structure constituting part of a search treeData structure constituting part of a search tree –Includes parent, children, depth, path cost g(x) States do not have parents, children, depth, or path cost!

26. Implementation: general tree search function TREE-SEARCH (problem, fringe) returns a solution, or failure fringe  INSERT(MAKE-NODE(INITIAL-STATE[problem]), fringe) fringe  INSERT(MAKE-NODE(INITIAL-STATE[problem]), fringe) loop do loop do if fringe is empty then return false if fringe is empty then return false node  REMOVE-FRONT(fringe) node  REMOVE-FRONT(fringe) if GOAL-TEST[problem] applied to STATE(node) succeeds return node if GOAL-TEST[problem] applied to STATE(node) succeeds return node fringe  INSERTALL(EXPAND(node, problem), fringe) fringe  INSERTALL(EXPAND(node, problem), fringe) function EXPAND (node, problem) returns a set of states successors  the empty set successors  the empty set for each action, result in SUCCESSOR-FN[problem](STATE[node]) do for each action, result in SUCCESSOR-FN[problem](STATE[node]) do s  a new NODE s  a new NODE PARENT-NODE[s]  node; ACTION[s]  action; STATE(s)  result PARENT-NODE[s]  node; ACTION[s]  action; STATE(s)  result PATH-COST[s]  PATH-COST[node] + STEP-COST(node, action, s) PATH-COST[s]  PATH-COST[node] + STEP-COST(node, action, s) DEPTH[s]  DEPTH[node] + 1 DEPTH[s]  DEPTH[node] + 1 add s to successors add s to successors return successors Find the error on this page! function TREE-SEARCH (problem, fringe) returns a solution, or failure fringe  INSERT(MAKE-NODE(INITIAL-STATE[problem]), fringe) fringe  INSERT(MAKE-NODE(INITIAL-STATE[problem]), fringe) loop do loop do if fringe is empty then return false if fringe is empty then return false node  REMOVE-FRONT(fringe) node  REMOVE-FRONT(fringe) if GOAL-TEST[problem] applied to STATE(node) succeeds return node if GOAL-TEST[problem] applied to STATE(node) succeeds return node fringe  INSERTALL(EXPAND(node, problem), fringe) fringe  INSERTALL(EXPAND(node, problem), fringe) function EXPAND (node, problem) returns a set of states successors  the empty set successors  the empty set for each action, result in SUCCESSOR-FN[problem](STATE[node]) do for each action, result in SUCCESSOR-FN[problem](STATE[node]) do s  a new NODE s  a new NODE PARENT-NODE[s]  node; ACTION[s]  action; STATE(s)  result PARENT-NODE[s]  node; ACTION[s]  action; STATE(s)  result PATH-COST[s]  PATH-COST[node] + STEP-COST(node, action, s) PATH-COST[s]  PATH-COST[node] + STEP-COST(node, action, s) DEPTH[s]  DEPTH[node] + 1 DEPTH[s]  DEPTH[node] + 1 add s to successors add s to successors return successors Find the error on this page!

27. Search strategies A 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?Completeness – does it always find a solution if one exists? Time complexity – number of nodes generated/expandedTime complexity – number of nodes generated/expanded Space complexity – maximum nodes in memorySpace complexity – maximum nodes in memory Optimality – does it always find a least cost solution?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 treeb – maximum branching factor of the search tree d – depth of the least-cost solutiond – depth of the least-cost solution m – maximum depth of the state space (may be infinite)m – maximum depth of the state space (may be infinite) A 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?Completeness – does it always find a solution if one exists? Time complexity – number of nodes generated/expandedTime complexity – number of nodes generated/expanded Space complexity – maximum nodes in memorySpace complexity – maximum nodes in memory Optimality – does it always find a least cost solution?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 treeb – maximum branching factor of the search tree d – depth of the least-cost solutiond – depth of the least-cost solution m – maximum depth of the state space (may be infinite)m – maximum depth of the state space (may be infinite)

28. Uninformed Search Strategies Uninformed strategies use only the information available in the problem definition Breadth-first searchBreadth-first search Uniform-cost searchUniform-cost search Depth-first searchDepth-first search Depth-limited searchDepth-limited search Iterative deepening searchIterative deepening search Uninformed strategies use only the information available in the problem definition Breadth-first searchBreadth-first search Uniform-cost searchUniform-cost search Depth-first searchDepth-first search Depth-limited searchDepth-limited search Iterative deepening searchIterative deepening search

29. Breadth-first search Expand shallowest unexpanded node Implementation: Fringe is a FIFO queue, i.e., new successors go at endFringe is a FIFO queue, i.e., new successors go at end Execute first few expansions of Arad to Bucharest using Breadth-first searchExecute first few expansions of Arad to Bucharest using Breadth-first search Expand shallowest unexpanded node Implementation: Fringe is a FIFO queue, i.e., new successors go at endFringe is a FIFO queue, i.e., new successors go at end Execute first few expansions of Arad to Bucharest using Breadth-first searchExecute first few expansions of Arad to Bucharest using Breadth-first search

30. Breadth-first Search Arad Zerind Arad ZerindTimisoaraSibiu Oradea ZerindSibiu Timisoara AradLugoj Sibiu DradeaFaragas Rimnicu Vilcea

31. Computation cost of BFS 1 2 3 LevelNodes 0 1 b b2b2 b3b3

32. Computation cost of BFS If goal is in d = level 2 Cost = 1 + b + b 2 + b 3 – b = O (b d+1 ) If goal is in d = level 2 Cost = 1 + b + b 2 + b 3 – b = O (b d+1 ) 1 2 3 LevelNodes 0 1 b b2b2 b3b3

33. Computation cost of BFS Cost = 1 + b + b 2 + b 3 – b = O (b d+1 ) Big Oh Notation There exist positive constants: c, b 0, d 0 such that for all b >= b 0 and d >= d 0There exist positive constants: c, b 0, d 0 such that for all b >= b 0 and d >= d 0 Cost = 1 + b + b 2 + b 3 – b = O (b d+1 ) Big Oh Notation There exist positive constants: c, b 0, d 0 such that for all b >= b 0 and d >= d 0There exist positive constants: c, b 0, d 0 such that for all b >= b 0 and d >= d 0 Figure 2.1 from Cormen, Leiserson, Rivest

34. Space cost of BFS Because you must be able to generate the path upon finding the goal state, all visited states must be stored

35. Properties of breadth-first search Complete?? Yes (if b (max branch factor) is finite) Time?? 1 + b + b 2 + … + b d + b(b d -1) = O(b d+1 ), i.e., exponential in d Space?? O(b d+1 ) (keeps every node in memory) Optimal?? Only if cost = 1 per step, otherwise not optimal in general Space is the big problem; can easily generate nodes at 10 MB/s, so 24hrs = 860GB! Complete?? Yes (if b (max branch factor) is finite) Time?? 1 + b + b 2 + … + b d + b(b d -1) = O(b d+1 ), i.e., exponential in d Space?? O(b d+1 ) (keeps every node in memory) Optimal?? Only if cost = 1 per step, otherwise not optimal in general Space is the big problem; can easily generate nodes at 10 MB/s, so 24hrs = 860GB!

36. Uniform-first search Expand least-cost unexpanded node Implementation: Fringe is a queue ordered by costFringe is a queue ordered by cost Execute first few expansions of Arad to Bucharest using Breadth-first searchExecute first few expansions of Arad to Bucharest using Breadth-first search Expand least-cost unexpanded node Implementation: Fringe is a queue ordered by costFringe is a queue ordered by cost Execute first few expansions of Arad to Bucharest using Breadth-first searchExecute first few expansions of Arad to Bucharest using Breadth-first search

37. Uniform-cost Search Arad Zerind (75) Arad (150)Oradea (146) Timisoara (118) Arad (193)Lugoj (229) Sibiu (140) Oradea (291)Faragas (139) Bucharest (350) Sibiu (238) Rimnicu (220) Vilcea

38. Uniform-cost search Complete?? If step cost ≥ ε Time?? If all costs are equal = O (b d )If all costs are equal = O (b d ) Space?? O(b C/ ε ) Optimal?? Yes–nodes expanded in increasing order of g(n) Complete?? If step cost ≥ ε Time?? If all costs are equal = O (b d )If all costs are equal = O (b d ) Space?? O(b C/ ε ) Optimal?? Yes–nodes expanded in increasing order of g(n)

39. Depth-first search Expand deepest unexpanded node Implementation: Fringe = LIFO queue, i.e., a stackFringe = LIFO queue, i.e., a stack Execute first few expansions of Arad to Bucharest using Depth-first searchExecute first few expansions of Arad to Bucharest using Depth-first search Expand deepest unexpanded node Implementation: Fringe = LIFO queue, i.e., a stackFringe = LIFO queue, i.e., a stack Execute first few expansions of Arad to Bucharest using Depth-first searchExecute first few expansions of Arad to Bucharest using Depth-first search

40. Depth-first search Complete??Time??Space??Optimal??Complete??Time??Space??Optimal??

41. Complete?? No: fails in infinite-depth spaces, spaces with loops.No: fails in infinite-depth spaces, spaces with loops. Can be modified to avoid repeated states along path  complete in finite spacesCan be modified to avoid repeated states along path  complete in finite spacesTime?? O(b m ) : terrible if m is much larger than d, but if solutions are dense, may be much faster than breadth-firstO(b m ) : terrible if m is much larger than d, but if solutions are dense, may be much faster than breadth-firstSpace?? O(bm), i.e., linear space!O(bm), i.e., linear space!Optimal?? NoNoComplete?? No: fails in infinite-depth spaces, spaces with loops.No: fails in infinite-depth spaces, spaces with loops. Can be modified to avoid repeated states along path  complete in finite spacesCan be modified to avoid repeated states along path  complete in finite spacesTime?? O(b m ) : terrible if m is much larger than d, but if solutions are dense, may be much faster than breadth-firstO(b m ) : terrible if m is much larger than d, but if solutions are dense, may be much faster than breadth-firstSpace?? O(bm), i.e., linear space!O(bm), i.e., linear space!Optimal?? NoNo

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

43. Iterative deepening search function ITERATIVE-DEEPENING-SEARCH(problem) returns a solution inputs: problem, a problem inputs: problem, a problem for depth  0 to ∞ do for depth  0 to ∞ do result  DEPTH-LIMITED-SEARCH(problem, depth) result  DEPTH-LIMITED-SEARCH(problem, depth) if result ≠ cutoff then return result if result ≠ cutoff then return result end end function ITERATIVE-DEEPENING-SEARCH(problem) returns a solution inputs: problem, a problem inputs: problem, a problem for depth  0 to ∞ do for depth  0 to ∞ do result  DEPTH-LIMITED-SEARCH(problem, depth) result  DEPTH-LIMITED-SEARCH(problem, depth) if result ≠ cutoff then return result if result ≠ cutoff then return result end end

44. Properties of iterative deepening Complete?? YesYesTime?? (d+1)b 0 + db 1 + (d-1)b 2 + … b d = O(b d )(d+1)b 0 + db 1 + (d-1)b 2 + … b d = O(b d )Space?? O(bd)O(bd)Optimal?? If step cost = 1If step cost = 1 Can be modified to explore uniform-cost treeCan be modified to explore uniform-cost treeComplete?? YesYesTime?? (d+1)b 0 + db 1 + (d-1)b 2 + … b d = O(b d )(d+1)b 0 + db 1 + (d-1)b 2 + … b d = O(b d )Space?? O(bd)O(bd)Optimal?? If step cost = 1If step cost = 1 Can be modified to explore uniform-cost treeCan be modified to explore uniform-cost tree

45. Summary All tree searching techniques are more alike than different Breadth-first has space issues, and possibly optimality issues Uniform-cost has space issues Depth-first has time and optimality issues, and possibly completeness issues Depth-limited search has optimality and completeness issues Iterative deepening is the best uninformed search we have explored Next class we study informed searches All tree searching techniques are more alike than different Breadth-first has space issues, and possibly optimality issues Uniform-cost has space issues Depth-first has time and optimality issues, and possibly completeness issues Depth-limited search has optimality and completeness issues Iterative deepening is the best uninformed search we have explored Next class we study informed searches