1

Unit-2
Introduction to Search: Searching for solutions, uninformed search strategies, informed
search strategies, Local search algorithms and optimistic problems, Adversarial Search,
Search for games. , Alpha - Beta pruning.

SOLVING PROBLEMS BY SEARCHING

The simplest agents were the reflex agents, which base their actions on a direct mapping from
states to actions. Such agents cannot operate well in environments for which this mapping
would be too large to store and would take too long to learn. Goal-based agents, on the other
hand, can succeed by considering future actions and the desirability of their outcomes. This
kind of goal-based agent called a problem-solving agent. Problem-solving agents decide
what to do by finding sequences of actions that lead to desirable states.
Problem-Solving Agent
Intelligent agents are supposed to maximize their performance measure. In general, an agent
with several immediate options of unknown value can decide what to do by first examining
different possible sequences of actions that lead to states of known value, and then choosing
the best sequence. This process of looking for such a sequence is called search.
A search algorithm takes a problem as input and returns a solution in the form of an action
sequence. Once a solution is found, the actions it recommends can be carried out. This is
called the execution phase. After formulating a goal and a problem to solve, the agent calls a
search procedure to solve it. It then uses the solution to guide its actions, doing whatever the
solution recommends as the next thing to do-typically, the first action of the sequence-and
then removing that step from the sequence. Once the solution has been executed, the agent
will formulate new goal.

RAJEEV KUMAR, AP, IT, HCST, FARAH, MATHURA

Well-defined problems and solutions

A problem can be defined formally by four components:
1) The initial state that the agent starts in. For example, the initial state for our agent in
Romania might be described as In(Arad).
2) A description of the possible actions available to the agent. The most common
formulation uses a successor function. For example, from the state In(Arad), the
successor function for the Romaniaproblem would return
{ (G o(Sibzu),I n(Sibiu)), (Go(T imisoara), In( Tzmisoara)), (Go(Zerznd),I n(Zerind)))
Together, the initial state and successor function implicitly define the state
space of the problem-the set of all states reachable from the initial state. A path in the
state space is a sequence of states connected by a sequence of actions.
3) The goal test, which determines whether a given state is a goal state. The agent's goal
in Romania is the singleton set {In(Bucharest)).
4) A path cost function that assigns a numeric cost to each path. The problem-solving
agent chooses a cost function that reflects its own performance measure.
A solution to a problem is a path from the initial state to a goal state. Solution
quality is measured by the path cost function, and an optimal solution has the lowest
path cost among all solutions.

Example Problem

Toy problems
The first example we will examine is the vacuum world. This can be formulated as a problem
as follows:
States: The agent is in one of two locations, each of which might or might not contain
dirt. Thus there are 2 x 22 = 8 possible world states.
Initial state: Any state can be designated as the initial state.

RAJEEV KUMAR, AP, IT, HCST, FARAH, MATHURA

Successor function: This generates the legal states that result from trying the three
actions (Left, Right, and Suck). The complete state space is shown in Figure 3.3.
Goal test: This checks whether all the squares are clean.
Path cost: Each step costs 1, so the path cost is the number of steps in the path.

The 8-puzzle Problem

The 8-puzzle consists of a 3 x 3 board with eight numbered tiles and a blank space. A tile
adjacent to the blank space can slide into the space. The object is to reach a specified goal
state, such as the one shown on the right of the figure. The standard formulation is as follows:
States: A state description specifies the location of each of the eight tiles and the
blank in one of the nine squares.
Initial state: Any state can be designated as the initial state. Note that any given goal
can be reached from exactly half of the possible initial states.
Successor function: This generates the legal states that result from trying the four
actions (blank moves Left, Right, Up, or Down).
Goal test: This checks whether the state matches the goal configuration.
Path cost: Each step costs 1, so the path cost is the number of steps in the path.

RAJEEV KUMAR, AP, IT, HCST, FARAH, MATHURA

The 8-queens problem

The goal of the 8-queens problem is to place eight queens on a chessboard such that no
queen attacks any other. (A queen attacks any piece in the same row, column or diagonal.)
There are two main kinds of formulation. An incremental formulation involves operators
that augment the state description, starting with an empty state; for the 8-queens problem, this
means that each action adds a queen to the state. A complete-state formulation starts with
all 8 queens on the board and moves them around. In either case, the path cost is of no
interest because only the final state counts. The first incremental formulation one might try is
the following:
States: Any arrangement of 0 to 8 queens on the board is a state.
Initial state: No queens on the board.
Successor function: Add a queen to any empty square.
Goal test: 8 queens are on the board, none attacked.

Real-world problems
Consider a simplified example of an airline travel problem specified as follows:
States: Each is represented by a location (e.g., an airport) and the current time.
Initial state: This is specified by the problem.
Successor function: This returns the states resulting from taking any scheduled flight
(perhaps further specified by seat class and location), leaving later than the current
time plus the within-airport transit time, from the current airport to another.
Goal test: Are we at the destination by some pre specified time?
Path cost: This depends on monetary cost, waiting time, flight time, customs and
immigration procedures, seat quality, time of day, type of airplane, frequent-flyer
mileage awards, and so on.

RAJEEV KUMAR, AP, IT, HCST, FARAH, MATHURA

The travelling salesperson problem (TSP)

The travelling salesperson problem (TSP) is a touring problem in which each city must be
visited exactly once. The aim is to find the shortest tour. The problem is known to be NP
hard, but an enormous amount of effort has been expended to improve the capabilities of TSP
algorithms.
A VLSI layout problem

A VLSI layout problem requires positioning millions of components and connections on a

chip to minimize area, minimize circuit delays, minimize stray capacitances, and maximize
manufacturing yield. The layout problem comes after the logical design phase, and is usually
split into two parts: cell layout and channel routing. In cell layout, the primitive components
of the circuit are grouped into cells, each of which performs some recognized function. Each
cell has a fixed footprint (size and shape) and requires a certain number of connections to
each of the other cells. The aim is to place the cells on the chip so that they do not overlap
and so that there is room for the connecting wires to be placed between the cells. Channel
routing finds a specific route for each wire through the gaps between the cells. These search
problems are extremely complex, but definitely worth solving.
Robot navigation is a generalization of the route-finding problem described earlier. Rather
than a discrete set of routes, a robot can move in a continuous space with (in principle) an
infinite set of possible actions and states.

SEARCHING FOR SOLUTIONS

The root of the search tree is a search node corresponding to the initial state, In(Arad). The
first step is to test whether this is a goal state. Clearly it is not, but it is important to check so
that we can solve trick problems like "starting in Arad, get to Arad." Because this is not a
goal state, we need to consider some other states. This is done by expanding the current
state; that is, applying the successor function to the current state, thereby generating a new
set of states.
In this case, we get three new states: In(Sibiu), In(Timisoara), and In(Zerind). Now we must
choose which of these three possibilities to consider further Suppose we choose Sibiu first.
We check to see whether it is a goal state (it is not) and then expand it to get In(Arad),
In(Fagaras), In(Oradea), and In(RimnicuVi1cea). We can then choose any of these four, or
go back and choose Timisoara or Zerind. We continue choosing, testing, and expanding until
either a solution is found or there are no more states to be expanded. The choice of which
state to expand is determined by the search strategy.
There are many ways to represent nodes, but we will assume that a node is a data structure
with five components:
STATE: the state in the state space to which the node corresponds;
PARENT-NODE: the node in the search tree that generated this node;
ACTION: the action that was applied to the parent to generate the node;
PATH-COST: the cost, traditionally denoted by g(n), of the path from the initial state
to the node, as indicated by the parent pointers; and
DEPTH: the number of steps along the path from the initial state.
A node is a bookkeeping data structure used to represent the search tree. A state
corresponds to a configuration of the world. Thus, nodes are on particular paths, as defined
by PARENT-NODE pointers, whereas states are not. Furthermore, two different nodes can
contain the same world state, if that state is generated via two different search paths. We also
RAJEEV KUMAR, AP, IT, HCST, FARAH, MATHURA

need to represent the collection of nodes that have been generated but not yet expandedthis collection is called the fringe or frontier. Each element of the fringe is a leaf node, that
is, a node with no successors in the tree.

We will assume that the collection of nodes is implemented as a queue. The operations on a
queue are as follows:

RAJEEV KUMAR, AP, IT, HCST, FARAH, MATHURA

Measuring problem-solving performance

The output of a problem-solving algorithm is either failure or a solution. We will evaluate an
algorithm's performance in four ways:
Completeness: Is the algorithm guaranteed to find a solution when there is one?
Optimality: Does the strategy find the optimal solution?
Time complexity: How long does it take to find a solution?
Space complexity: How much memory is needed to perform the search?
Time and space complexity are measured in terms of
b-maximum branching factor of the search tree
d-depth of the least-cost solution
m-maximum depth of the state space

UNINFORMED SEARCH STRATEGIES

An uninformed (a.k.a. blind, brute-force) search algorithm generates the search tree without
using any domain specific knowledge. All they can do is generate successors and distinguish
a goal state from a non-goal state. All search strategies are distinguished by the order in
which nodes are expanded.

Breadth-first search
Breadth-first search is a simple strategy in which the root node is expanded first, then all
the successors of the root node are expanded next, then their successors, and so on. In
general, all the nodes are expanded at a given depth in the search tree before any nodes at the
next level are expanded.
Breadth-first search can be implemented by calling TREE-SEARCH with an empty fringe
that is a first-in-first-out (FIFO) queue, assuring that the nodes that are visited first will be
expanded first. The FIFO queue puts all newly generated successors at the end of the queue,
which means that shallow nodes are expanded before deeper nodes. First lesson is that, the
memory requirements are a bigger problem for breadth9rst search than is the execution time.
The second lesson is that the time requirements are still a major factor. In general,
exponential-complexity search problems cannot be solved by uninformed methods for any but
the smallest instances.

RAJEEV KUMAR, AP, IT, HCST, FARAH, MATHURA

Properties of breadth-First search

Uniform-cost search
Breadth-first search is optimal when all step costs are equal, because it always expands the
shallowest unexpanded node. By a simple extension, we can find an algorithm that is optimal
with any step cost function. Instead of expanding the shallowest node, uniform-cost search
expands the node n with the lowest path cost. Note that if all step costs are equal, this is
identical to breadth-first search.
Uniform-cost search does not care about the number of steps a path has, but only about their
total cost. Therefore, it will get stuck in an infinite loop if it ever expands a node that has a
zero-cost action leading back to the same state

RAJEEV KUMAR, AP, IT, HCST, FARAH, MATHURA

Depth-first search
Depth-first search always expands the deepest node in the current fringe of the search tree.
The search proceeds immediately to the deepest level of the search tree, where the nodes have
no successors. As those nodes are expanded, they are dropped from the fringe, so then the
search "backs up" to the next shallowest node that still has unexplored successors.
This strategy can be implemented by TREE-SEARCH with a last-in-first-out (LIFO) queue,
also known as a stack. As an alternative to the TREE-SEARCH implementation, it is
common to implement depth-first search with a recursive function that calls itself on each of
its children in turn.
Depth-first search has very modest memory requirements. It needs to store only a single path
from the root to a leaf node, along with the remaining unexpanded sibling nodes for each
node on the path. Once a node has been expanded, it can be removed from memory as soon
as all its descendants have been fully explored.
The drawback of depth-first search is that it can make a wrong choice and get stuck going
down a very long (or even infinite) path when a different choice would lead to a solution near
the root of the search tree.

RAJEEV KUMAR, AP, IT, HCST, FARAH, MATHURA

10

RAJEEV KUMAR, AP, IT, HCST, FARAH, MATHURA

11

Depth-limited search
The problem of unbounded trees can be alleviated by supplying depth-first search with a
predetermined depth limit l. That is, nodes at depth l are treated as if they have no successors.
This approach is called depth-limited search. The depth limit solves the infinite-path
problem.

Iterative deepening depth-first search

Iterative deepening search (or iterative deepening depth-first search) is a general strategy,
often used in combination with depth-first search that finds the best depth limit. It does this
by gradually increasing the limit-first 0, then 1, then 2, and so on-until a goal is found. This
will occur when the depth limit reaches d, the depth of the shallowest goal node.
Iterative deepening combines the benefits of depth-first and breadth-first search. Like depthfirst search, its memory requirements are very modest: O(bd) to be precise. Like breadth-first
search, it is complete when the branching factor is finite and optimal when the path cost is a
non decreasing function of the depth of the node. Iterative deepening search may seem
wasteful, because states are generated multiple times.
In an iterative deepening search, the nodes on the bottom level (depth d) are generated once,
those on the next to bottom level are generated twice, and so on, up to the children of the
root, which are generated d times. So the total number of nodes generated is

RAJEEV KUMAR, AP, IT, HCST, FARAH, MATHURA

12

Bidirectional search
The idea behind bidirectional search is to run two simultaneous searches-one forward from
the initial state and the other backward from the goal, stopping when the two searches
meeting the middle.

RAJEEV KUMAR, AP, IT, HCST, FARAH, MATHURA

13

INFORMED (HEURISTIC) SEARCH STRATEGIES

An informed search strategy one that uses problem-specific knowledge beyond the
definition of the problem itself can find solutions more efficiently than an uninformed
strategy. A key component of these algorithms is a heuristic function denoted by h (n):
h (n) = estimated cost of the cheapest path from node n to a goal node.

Greedy best-first search

Greedy best-first search tries to expand the node that is closest to the goal, on the: grounds that this is
likely to lead to a solution quickly. Thus, it evaluates nodes by using just the heuristic function: f (n) =
h(n).
Let us see how this works for route-finding problems in Romania, using the straight line distance
heuristic, which we will call hSLD. If the goal is Bucharest, we will need to know the straight-line
distances to Bucharest,

It suffers from the same defects as depth-first search-it is not optimal, and it is incomplete
(because it can start down an infinite path and never return to try other possibilities). The
worst-case time and space complexity is O(bm), where m is the maximum depth of the search
space. With a good heuristic function, however, the complexity can be reduced substantially.

RAJEEV KUMAR, AP, IT, HCST, FARAH, MATHURA

14

A* search
The most widely-known form of best-first search is called A* search (pronounced "A-star
Search"). It evaluates nodes by combining g (n), the cost to reach the node, and h (n.), the
cost to get from the node to the goal:
f (n)=g (n) + h (n)
g (n) = the path cost from the start node to node n,
h (n) = the estimated cost of the cheapest path from n to the goal,
f (n) = the estimated cost of the cheapest solution through n.
A* search is both complete and optimal. In this case, A* is optimal if h(n) is an admissible
heuristic-that is, provided that h(n) never overestimates the cost to reach the goal.
Admissible heuristics are by nature optimistic, because they think the cost of solving the
problem is less than it actually is. Since g(n) is the exact cost to reach n, we have as
immediate consequence that f (n) never overestimates the true cost of a solution through n.

RAJEEV KUMAR, AP, IT, HCST, FARAH, MATHURA

15

RAJEEV KUMAR, AP, IT, HCST, FARAH, MATHURA

16

Suppose a suboptimal goal node G2 appears on the fringe, and let the cost of the optimal
solution be C*. Then, because G2 is suboptimal and because h (G2=) 0 (true for any goal
node), we know
f (G2) = g(G2) + h(G2) = g(G2) > C*
If h (n) does not overestimate the cost of completing the solution path, then we know that
f (n) = g(n) + h(n)<=C* .
Now we have shown that f (n) <=C* < f (G2) so G2 will not be expanded and A* must
return an optimal solution.
A heuristic h (n) is consistent if, for every node n and every successor n' of n generated by
any action a, the estimated cost of reaching the goal from n is no greater than the step cost of
getting to n' plus the estimated cost of reaching the goal from n':
h (n)<=c(n, a , n') + h(n).
Another important consequence of consistency is the following: if h (n) is consistent, then the
values off (n) along any path are nondecreasing. The proof follows directly from the
definition of consistency. Suppose n' is a successor of n; then g(n')= g(n)+ c(n,a , n') for some
a, and we have
It follows that the sequence of nodes expanded by A* using GRAPH-SEARCH is in non
decreasing order of f (n). Hence, the first goal node selected for expansion must be an optimal
Solution, since all later nodes will be at least as expensive.
LOCAL SEARCH ALGORITHMS AND OPTIMIZATION PROBLEMS
Local search algorithms operate using a single current node (rather than multiple paths) and
generally move only to neighbours of that node. Typically, the paths followed by the search
are not retained. Although local search algorithms are not systematic, they have two key
advantages: (1) they use very little memoryusually a constant amount; and (2) they can
often find reasonable solutions in large or infinite (continuous) state spaces for which
systematic algorithms are unsuitable. In addition to finding goals, local search algorithms are
useful for solving pure optimization problems, in which the aim is to find the best state
according to an objective function.

RAJEEV KUMAR, AP, IT, HCST, FARAH, MATHURA

17

A landscape has both "location" (defined by the state) and "elevation" (defined by the value
of the heuristic cost function or objective function). If elevation corresponds to cost, then the
aim is to find the lowest valleya global minimum; if elevation corresponds to an objective
function, then the aim is to find the highest peaka global maximum. Local search
algorithms explore this landscape. A complete local search algorithm always finds a goal if
one exists; an optimal algorithm always finds a global minimum/maximum.

Hill-climbing search
It is simply a loop that continually moves in the direction of increasing valuethat is, uphill.
It terminates when it reaches a "peak" where no neighbour has a higher value. The algorithm
does not maintain a search tree, so the data structure for the current node need only record the
state and the value of the objective function. Hill climbing does not look ahead beyond the
immediate neighbours of the current state.

Unfortunately, hill climbing often gets stuck for the following reasons:
Local maxima: a local maximum is a peak that is higher than each of its
neighbouring states but lower than the global maximum. Hill-climbing algorithms that
reach the vicinity of a local maximum will be drawn upward toward the peak but will
then be stuck with nowhere else to go.
Ridges: Ridges result in a sequence of local maxima that is very difficult for greedy
algorithms to navigate
Plateaux: a plateau is a flat area of the state-space landscape. It can be a flat local
maximum, from which no uphill exit exists, or a shoulder, from which progress is
possible.

RAJEEV KUMAR, AP, IT, HCST, FARAH, MATHURA

18

Simulated annealing
A hill-climbing algorithm that never makes "downhill" moves toward states with lower value
(or higher cost) is guaranteed to be incomplete, because it can get stuck on a local maxi-mum.
In contrast, a purely random walkthat is, moving to a successor chosen uniformly at
random from the set of successorsis complete but extremely inefficient. Therefore, it seems
reasonable to try to combine hill climbing with a random walk in some way that yields both
efficiency and completeness. Simulated annealing is such an algorithm.

Local beam search

The local beam search algorithm keeps track of k states rather than just one. It begins with k
randomly generated states. At each step, all the successors of all k states are generated. If
anyone is a goal, the algorithm halts. Otherwise, it selects the k best successors from the
complete list and repeats.
At first sight, a local beam search with k states might seem to be nothing more than running k
random restarts in parallel instead of in sequence. In fact, the two algorithms are quite
different. In a random-restart search, each search process runs independently of the others. In
a local beam search, useful information is passed among the parallel search threads.

Adversarial search:-Adversarial search is used in games where one player's attempts to

maximize their fitness (win) is opposed by another player.
Search For Game
Game-playing programs developed by AI researchers since the beginning of the modern AI
era Ex. Programs playing chess, checkers, etc
Specifics of the game search:
Sequences of players decisions we control
Decisions of other player(s) we do not control
Contingency problem: many possible opponents moves must be covered by the solution.
Opponents behaviour introduces an uncertainty in to the game. We do not know exactly
what the response is going to be.
Rational opponent maximizes it own utility (payoff) function
RAJEEV KUMAR, AP, IT, HCST, FARAH, MATHURA

19

Types of game problems:

Adversarial games:
Win of one player is a loss of the other
Cooperative games:
Players have common interests and utility function
Game search problem
Game problem formulation:
Initial state: initial board position + info whose move it is
Operators: legal moves a player can make
Goal (terminal test): determines when the game is over
Utility (payoff) function: measures the outcome of the game and its desirability
Search objective:
find the sequence of players decisions (moves) maximizing its utility (payoff)
Consider the opponents moves and their utility

The minimax algorithm

The minimax algorithm computes the minimax decision from the current state. It uses a
simple recursive computation of the minimax values of each successor state, directly
implementing the defining equations. The recursion proceeds all the way down to the leaves
of the tree, and then the minimax values are backed up through the tree as the recursion
unwinds.
The minimax algorithm performs a complete depth-first exploration of the game tree. If the
maximum depth of the tree is m and there are b legal moves at each point, then the time
complexity of the minimax algorithm is 0(bm). The space complexity is 0(bm.) for an

RAJEEV KUMAR, AP, IT, HCST, FARAH, MATHURA

20

algorithm that generates all actions at once, or 0(m) for an algorithm that generates actions
one at a time.

Optimal decisions in multiplayer games

First, we need to replace the single value for each node with a vector of values. For example,
in a three-player game with players A, B, and C, a vector (vA,vB,vC) is associated with each
node. For terminal states, this vector gives the utility of the state from each player's
viewpoint.
RAJEEV KUMAR, AP, IT, HCST, FARAH, MATHURA

21

ALPHABETA PRUNING
The problem with minimax search is that the number of game states it has to examine is
exponential in the depth of the tree. The trick is that it is possible to compute the correct
minimax decision without looking at every node in the game tree.
Alphabeta pruning is a search algorithm that seeks to decrease the number of nodes that are
evaluated by the minimax algorithm in its search tree. It stops completely evaluating a move
when at least one possibility has been found that proves the move to be worse than a
previously examined move. Such moves need not be evaluated further. When applied to a
standard minimax tree, it returns the same move as minimax would, but prunes away
branches that cannot possibly influence the final decision.

RAJEEV KUMAR, AP, IT, HCST, FARAH, MATHURA

22

Alpha-beta pruning gets its name from the following two parameters that describe bounds on
the backed.-up values that appear anywhere along the path:
= the value of the best (i.e., highest-value) choice we have found so far at any
choice point along the path for MAX.
= the value of the best (i.e., lowest-value) choice we have found so far at any choice
point along the path for MIN.
Alpha-beta search updates the values of and as it goes along and prunes the remaining
branches at a node (i.e., terminates the recursive call) as soon as the value of the current node
is known to be worse than the current a or p value for MAX or MIN, respectively.

Fig: - The alpha-beta search algorithm.

RAJEEV KUMAR, AP, IT, HCST, FARAH, MATHURA