1. Warm-up
We’ll often have a warm-up exercise for the 10 minutes before class starts. Here’s the first one…
Write the pseudo code for breadth first search and depth first search
Iterative version, not recursive
class TreeNode
TreeNode[] children()
boolean isGoal()
BFS(TreeNode start)…
DFS(TreeNode start)…

2. Announcements Upcoming due dates Account forms Step-by-step videos
F 5 pm Proj 0
M 11:59 pm HW 1
Be careful of edX timezone (UTC)!
Account forms
Pick-up after lecture (if you like)
Step-by-step videos
Found in edX Courseware (linked on edX Syllabus)

3. CS 188: Artificial Intelligence
Search
Please retain proper attribution and the reference to ai.berkeley.edu. Thanks!
Instructors: Stuart Russell and Pat Virtue

4. Today Agents that Plan Ahead Search Problems Uninformed Search Methods
Depth-First Search
Breadth-First Search
Uniform-Cost Search
General theme in the class:
A goal we have in mind.
A mathematical abstraction to formalize this
Algorithms that operate on these abstractions

5. Reflex Agents Reflex agents:
Choose action based on current percept (and maybe memory)
May have memory or a model of the world’s current state
Do not consider the future consequences of their actions
Consider how the world IS
Examples: blinking your eye (not using your entire thinking capabilities), vacuum cleaner moving towards nearest dirt

6. Agents that Plan Ahead Planning agents: Spectrum of deliberativeness:
Decisions based on predicted consequences of actions
Must have a transition model: how the world evolves in response to actions
Must formulate a goal
Consider how the world WOULD BE
Spectrum of deliberativeness:
Generate complete, optimal plan offline, then execute
Generate a simple, greedy plan, start executing, replan when something goes wrong

7. Demo Mastermind

8. Demo Replanning

9. Search Problems

10. Search Problems A search problem consists of:
A state space
For each state, a set
Actions(s) of allowable actions
A transition model Result(s,a)
A step cost function c(s,a,s’)
A start state and a goal test
A solution is a sequence of actions (a plan) which transforms the start state to a goal state
{N, E} 1 N E
Often comes back on exams
Goal test – sometimes more than one state that satisfies having achieved the goal, for example, “eat all the dots”
Abstraction

11. Search Problems Are Models

12. Example: Travelling in Romania
State space:
Cities
Actions:
Go to adjacent city
Transition model
Result(A, Go(B)) = B
Step cost
Distance along road link
Start state:
Arad
Goal test:
Is state == Bucharest?
Solution?
Infinitely many solutions! Some better than others

13. What’s in a State Space? Problem: Pathing Problem: Eat-All-Dots
The real world state includes every last detail of the environment
Wrong example for “eat-all-dots”: (x, y, dot count)
A search state abstracts away details not needed to solve the problem
Problem: Pathing
State representation: (x,y) location
Actions: NSEW
Transition model: update location
Goal test: is (x,y)=END
Problem: Eat-All-Dots
State representation: {(x,y), dot booleans}
Actions: NSEW
Transition model: update location and possibly a dot boolean
Goal test: dots all false
MN states
MN2MN states

14. Quiz: Safe Passage
Problem: eat all dots while keeping the ghosts perma-scared
What does the state representation have to specify?
(agent position, dot booleans, power pellet booleans, remaining scared time)

15. State Space Graphs and Search Trees

16. State Space Graphs
State space graph: A mathematical representation of a search problem
Nodes are (abstracted) world configurations
Arcs represent transitions resulting from actions
The goal test is a set of goal nodes (maybe only one)
In a state space graph, each state occurs only once!
We can rarely build this full graph in memory (it’s too big), but it’s a useful idea

17. More Examples
Typical finite graph explicitly defined (theoretical CS)

18. More Examples
Typical exponential (or infinite) graph implicitly defined (AI)

19. Search Trees A search tree: This is now / start Possible futures
Different plans that achieve the same state, will be different nodes in the tree.
A search tree:
A “what if” tree of plans and their outcomes
The start state is the root node
Children correspond to possible action outcomes
Nodes show states, but correspond to PLANS that achieve those states
For most problems, we can never actually build the whole tree

20. Quiz: State Space Graphs vs. Search Trees
Consider this 4-state graph:
How big is its search tree (from S)? S a b G a S G b ∞
Important: Lots of repeated structure in the search tree!

21. Tree Search

22. Search Example: Romania

23. Searching with a Search Tree
Expand out potential plans (tree nodes)
Maintain a frontier of partial plans under consideration
Try to expand as few tree nodes as possible

24. General Tree Search Important ideas:
function TREE-SEARCH(problem) returns a solution, or failure
initialize the frontier using the initial state of problem loop do
if the frontier is empty then return failure choose a leaf node and remove it from the frontier if the node contains a goal state then return the corresponding solution
expand the chosen node, adding the resulting nodes to the frontier
Important ideas:
Frontier
Expansion
Exploration strategy
Main question: which frontier nodes to explore?

25. A Note on Implementation
Nodes have state, parent, action, path-cost
A child of node by action a has
state = result(node.state,a)
parent = node
action = a
path-cost = node.path-cost step-cost(node.state, a, self.state)
Extract solution by tracing back parent pointers, collecting actions

26. Depth-First Search

27. Depth-First Search Strategy: expand a deepest node first
Implementation: Frontier is a LIFO stack S G d b p q c e h a f r a b c e d f h p r q S a b d p c e h f r q G

28. Search Algorithm Properties

29. Search Algorithm Properties
Complete: Guaranteed to find a solution if one exists?
Optimal: Guaranteed to find the least cost path?
Time complexity?
Space complexity?
Cartoon of search tree:
b is the branching factor
m is the maximum depth
solutions at various depths
Number of nodes in entire tree?
1 + b + b2 + …. bm = O(bm)
1 node b …
b nodes
b2 nodes
m tiers
bm nodes

30. Depth-First Search (DFS) Properties
What nodes does DFS expand?
Some left prefix of the tree.
Could process the whole tree!
If m is finite, takes time O(bm)
How much space does the frontier take?
Only has siblings on path to root, so O(bm)
Is it complete?
m could be infinite, so only if we prevent cycles (more later)
Is it optimal?
No, it finds the “leftmost” solution, regardless of depth or cost … b
1 node
b nodes
b2 nodes
bm nodes
m tiers

31. Breadth-First Search

32. Breadth-First Search Strategy: expand a shallowest node first
Implementation: Frontier is a FIFO queue S G d b p q c e h a f r
Search
Tiers S a b d p c e h f r q G

33. Breadth-First Search (BFS) Properties
What nodes does BFS expand?
Processes all nodes above shallowest solution
Let depth of shallowest solution be s
Search takes time O(bs)
How much space does the frontier take?
Has roughly the last tier, so O(bs)
Is it complete?
s must be finite if a solution exists, so yes!
Is it optimal?
Only if costs are all 1 (more on costs later)
1 node b …
b nodes
s tiers
b2 nodes
bs nodes
bm nodes

34. Quiz: DFS vs BFS

35. Quiz: DFS vs BFS When will BFS outperform DFS?
When will DFS outperform BFS?
[Demo: dfs/bfs maze water (L2D6)]

36. Video of Demo Maze Water DFS/BFS (part 1)

37. Video of Demo Maze Water DFS/BFS (part 2)

38. Iterative Deepening
Idea: get DFS’s space advantage with BFS’s time / shallow-solution advantages
Run a DFS with depth limit 1. If no solution…
Run a DFS with depth limit 2. If no solution…
Run a DFS with depth limit 3. …..
Isn’t that wastefully redundant?
Generally most work happens in the lowest level searched, so not so bad! b …

39. Finding a Least-Cost Path
START
GOAL d b p q c e h a f r 2 9 8 1 3 4 15
BFS finds the shortest path in terms of number of actions.
It does not find the least-cost path. We will now cover
a similar algorithm which does find the least-cost path.

40. Uniform Cost Search

41. Uniform Cost Search S G 2 Strategy: expand a cheapest node first:b p q c e h a f r 2
Strategy: expand a cheapest node first:
Frontier is a priority queue (priority: cumulative cost) 1 8 2 2 3 9 2 8 1 1 15 S a b d p c e h f r q G 9 1 3 4 5 17 11 16 11
Cost contours 6 13 7 8 11 10

42. Uniform Cost Search (UCS) Properties
What nodes does UCS expand?
Processes all nodes with cost less than cheapest solution!
If that solution costs C* and arcs cost at least  , then the “effective depth” is roughly C*/
Takes time O(bC*/) (exponential in effective depth)
How much space does the frontier take?
Has roughly the last tier, so O(bC*/)
Is it complete?
Assuming best solution has a finite cost and minimum arc cost is positive, yes!
Is it optimal?
Yes! (Proof next lecture via A*) b
c  1 …
c  2
C*/ “tiers”
c  3

43. Uniform Cost Issues Remember: UCS explores increasing cost contours…
c  3
c  2
c  1
Remember: UCS explores increasing cost contours
The good: UCS is complete and optimal!
The bad:
Explores options in every “direction”
No information about goal location
We’ll fix that soon!
Start
Goal

44. Video of Demo Empty UCS

45. Video of Demo Maze with Deep/Shallow Water --- DFS, BFS, or UCS
Video of Demo Maze with Deep/Shallow Water --- DFS, BFS, or UCS? (part 1)
Let students guess which one of the three it is. (This is BFS.)

46. Video of Demo Maze with Deep/Shallow Water --- DFS, BFS, or UCS
Video of Demo Maze with Deep/Shallow Water --- DFS, BFS, or UCS? (part 2)
Let students guess which one of the three it is. (This is UCS.)

47. Video of Demo Maze with Deep/Shallow Water --- DFS, BFS, or UCS
Video of Demo Maze with Deep/Shallow Water --- DFS, BFS, or UCS? (part 3)
Let students guess which one of the three it is. (This is DFS.)

48. Tree Search vs Graph Search

49. Tree Search: Extra Work!
Failure to detect repeated states can cause exponentially more work.
State Graph
Search Tree
O(2m)
O(m)

50. Tree Search: Extra Work!
Failure to detect repeated states can cause exponentially more work.
State Graph
Search Tree
O(4m)
O(2m2)
m=20: 800 states
1,099,511,627,776 tree nodes

51. General Tree Search
function TREE-SEARCH(problem) returns a solution, or failure
initialize the frontier using the initial state of problem
loop do
if the frontier is empty then return failure choose a leaf node and remove it from the frontier if the node contains a goal state then return the corresponding solution
expand the chosen node, adding each child to the frontier

52. General Graph Search
function GRAPH-SEARCH(problem) returns a solution, or failure
initialize the frontier using the initial state of problem
initialize the explored set to be empty loop do
if the frontier is empty then return failure choose a leaf node and remove it from the frontier if the node contains a goal state then return the corresponding solution
add the node to the explored set
expand the chosen node, adding each child to the frontier
but only if the child is not already in the frontier or explored set
Theorem: each state appears at most once in the search tree constructed

53. Tree Search vs Graph Search
Avoids infinite loops: m is finite in a finite state space
Eliminates exponentially many redundant paths
Requires memory proportional to its runtime!

54. Search Gone Wrong?