Introduction to search

Chapter 3

Why study search?

Search is a basis for all AI search proposed as the basis of intelligence inference all learning algorithms, e.g., can be seen as

searching some space of hypothesis

Intelligence as search

“The solutions to problems are represented as symbol structures. A physical-symbol system exercises its intelligence in problem-solving by search -- that is, by generating & progressively modifying symbol structures until it produces a solution structure.”

The search task

Given a description of the initial state list of legal actions

• preconditions

• effects goal test -- tells you if a goal has been reached

Find an ordered list of actions to perform in order to

go from the initial state to the goal

Search as a graph

Nodes search-space states

Directed arcs legal actions from each state to another

ExampleRather than being given, however, we often

build the graph (implicitly) as we go; we aren’t given the graph explicitly

Trip as search

State: geographical location (city, street, etc.)

Actions: following a roadInitial state: MadisonGoal state: Minneapolis

The following is the basic outline for the various search algorithms

(some steps are modified depending on the specifics of the search, e.g. if doing hill climbing, iterative deepening, or beam search).

General Pseudocode for Searching

OPEN = { startNode } // Nodes under consideration. CLOSED = { } // Nodes we're done with.

while OPEN is not empty { remove an item from OPEN based on search strategy used - call it Xif goalState?(X) return the solution foundotherwise // Expand node X. { 1) add X to CLOSED 2) generate the immediate neighbors (ie, children of X) 3) eliminate those children already in OPEN or CLOSED 4) add REMAINING children to OPEN } } return FAILURE // Failed if OPEN exhausted without a goal being found

“Considering” a node

If goal-state?(node) then done else expand(node) expand = add previously unvisited neighbors /

children (states that be gotten to from node by applying the operators) to the OPEN list

Task: find a route from the start node to the goal node

build a tree (try all/many possible paths)OPEN list allows backtracking from a path that

“dies out”; saves other possible ways nodes under consideration (to be expanded)

CLOSED list prevents us from repeatedly trying a node & ending up in an infinite loop nodes that have been processed

Search algorithm explained

General search methodsGiven a set of search-space nodes, which

one should we consider next? Youngest [depth-first search]

• most recently created node Oldest [breadth-first search]

• least-recently created node Best [best-first search]

• requires a scoring function Random

• simulated annealing

Implementing search strategiesBreadth

queue: first in, first out put new nodes at the back of list

Depth stack: last in, first out put new nodes at the front of list

Best priority queue add new nodes then sort list

The next node to consider is popped off the front of the OPEN list

Example of search strategies

Search danger: infinite spaces

We must be careful that our search doesn’t go forever the goal we are looking for may not be in the

search space but because the space is infinite we might not know this

the goal may be in the search space but we go down an infinite branch

example

BFS tradeoffs

pros guaranteed to find a solution if it exists guaranteed to find the shortest solution (in

terms of arcs)

cons OPEN becomes too big [O(bd)] example

DFS tradeoffs

pros might find solution quickly needs less space for OPEN [O(b * m)] example

cons can get stuck (run forever) in infinite spaces might not find shortest solution

Best-first search tradeoffs

pro can use domain specific knowledge

con requires a good heuristic (scoring) function

Fixing DFS: iterative deepeningCombines the strengths of breadth- & depth-

first searchdo DFS but with depth limited to k

if find solution, done (return path, etc.) else, increment k & start over

don’t save partial solutions from previous iterations; too much memory required

due to exponential growth, most work is at the bottom

guaranteed to find the shortest solution, but OPEN doesn’t get too big (as in BFS)

Iterative deepening idea

We do only a little more work overall, but our storage needs are much less we get the good aspects of BFS -- shortest

solution without the negative aspects -- OPEN list too

big

Search space examples

Define state representation (k-rep) initial state goal state operators

Draw search space (if it is small)Build search Tree