UNINFORMED SEARCH

Problem-solving agents

Example: Romania

On holiday in Romania; currently in Arad.

Flight leaves tomorrow from Bucharest

What do we need to define?

Problem Formulation

The process of defining actions, states and goal.

States: Cities (e.g. Arad, Sibiu, Bucharest, etc)

Actions: GoTo(adjacent city)

Goal: Bucharest

Why not “turn left 5 degrees” or “walk 100 meters forward…”?

Abstraction

The process of removing details from a representation. Simplifies the problem Makes problems tractable (possible to

solve) Humans are great at this!

Imagine a hierarchy in which another agent takes care of the lower level details, such as navigating from the city center to the highway.

Back to Arad…

We are in Arad and need to find our way to Bucharest.

Step 1 – Check Goal Condition

Check, are we at the goal? (obviously not in this case, but we need to

check in case we were)

Step 2 – Expand Current Node

Enumerate all the possible actions you could take from the current state

Formally: apply each legal action to the current state, thereby generating a new set of states.

From Arad can go to: Sibiu Timisoara Zerind

Step 3 – Select which action to perform

Perform one of the possible actions (e.g. GoTo(Sibiu))

Then go back to Step 1 and repeat.

This is an example of Tree Search Exploration of state space by generating

successors of already-explored states (a.k.a. expanding states)

Usually performed offline, as a simulation

Returns the sequence of actions that should be performed to reach the goal, or that the goal is unreachable.

Example: Romania

Tree Search

Tree search example

Tree search example: start with Sibiu

Tree search example: need to process the descendants of Sibiu

Note that we can loop back to Arad. Have to make sure we don’t go in circles forever!

Tree search algorithms

Implementation: general tree search

a.k.a. frontier

This is the part that distinguishes different search strategies

Search strategies

A search strategy is defined by picking the order of node expansion

Uninformed search strategies Uninformed search strategies use only

the information available in the problem definition

What does it mean to be uninformed? You only know the topology of which states

are connected by which actions. No additional information.

Later we’ll talk about informed search, in which you can estimate which actions are likely to be better than others.

Breadth-first search

Expand shallowest unexpanded node Implementation:

Fringe is a FIFO queue, i.e., new successors go at end

Breadth-first search

Expand shallowest unexpanded node Implementation:

Fringe is a FIFO queue, i.e., new successors go at end

Breadth-first search

Expand shallowest unexpanded node Implementation:

Fringe is a FIFO queue, i.e., new successors go at end

Breadth-first search

Expand shallowest unexpanded node Implementation:

Fringe is a FIFO queue, i.e., new successors go at end

BFS on a Graph

Search Strategy Evaluation: finding solutions

Strategies are evaluated along the following dimensions: completeness: does it always find a

solution if one exists? optimality: does it always find a least-cost

solution?

Search Strategy Evaluation: complexity

(cost) Two types of complexity

time complexity: number of nodes visited space complexity: maximum number of nodes

in memory

Time and space complexity are measured in terms of b: maximum branching factor of the search

tree (may ∞) d: depth of the least-cost solution m: maximum depth of the state space (may be

∞)

Properties of breadth-first search Complete?

Yes (if b is finite)

Optimal? Yes (if cost = 1 per step)

Time? 1+b+b2+b3+… +bd = O(bd)

Space? O(bd) (keeps every node in memory)

Problems of breadth first search Space is the biggest problem (more than

time)

Example from book, BFS b=10 to depth of 10 3 hours (not so bad) 10 terabytes of memory (really bad)

Only reason speed is not a problem is you run out of memory first

Problems of breadth first search BFS is not optimal if the cost of some

actions is greater than others…

Uniform-cost search

For graphs with actions of different cost Equivalent to breadth-first if step costs all

equal

Expand least-cost unexpanded node Implementation:

fringe = queue sorted by path cost g(n), from smallest to largest (i.e. a priority queue)

Uniform-cost search

Uniform-cost search

Complete? Yes, if step cost ≥ ε

Time? O(bceiling(C*/ ε)) where C* is the cost of the optimal solution

Space? # of nodes with g ≤ cost of optimal solution, O(bceiling(C*/ ε))

Optimal? Yes – nodes expanded in increasing order of g(n)

See book for detailed analysis.

Depth-first search

Expand deepest unexpanded node Implementation: fringe = LIFO queue, i.e., put successors at front

(i.e. a stack)

Depth-first search

Expand deepest unexpanded node Implementation:

fringe = LIFO queue, i.e., put successors at front

Depth-first search

Expand deepest unexpanded node Implementation:

fringe = LIFO queue, i.e., put successors at front

Depth-first search

Expand deepest unexpanded node Implementation:

fringe = LIFO queue, i.e., put successors at front

Depth-first search

Expand deepest unexpanded node Implementation:

fringe = LIFO queue, i.e., put successors at front

Depth-first search

Expand deepest unexpanded node Implementation:

fringe = LIFO queue, i.e., put successors at front

This is the part that distinguishes different search algorithms

Search Solution

Each node needs to keep track of its parent

Once the goal is found, traverse up the tree to the root to find the solution

Properties of depth-first search

Complete? No: fails in infinite-depth spaces Yes: in finite spaces

Optimal? No

Time? O(bm): (m is max depth of state space) terrible if m is much larger than d but if solutions are plentiful, may be much faster than breadth-

first

Space? O(bm), i.e., linear space!

Depth-limited search

depth-first search with depth limit l (i.e., don’t expand nodes past depth l)

… will fail if the goal is below the depth limit

Iterative deepening search

Iterative deepening search l =0

Iterative deepening search l =1

Iterative deepening search l =2

Iterative deepening search l =3

Properties of iterative deepening search

Complete? Yes

Time? (d+1)b0 + d b1 + (d-1)b2 + … + bd = O(bd)

Space? O(bd)

Optimal? Yes, if step cost = 1

Bidirectional Search

Run two simultaneous searches One forward from the start One backward from the goal

Hope that the searches meet in the middle bd/2 +bd/2 << bd

Summary of algorithms

Graph search

The closed set keeps track of loops in the graph so that the search terminates.

Questions?

Waitlisted? Talk to me after class.