Introduction

 HEURISTIC SEARCH
TECHNIQUES
 HEURISTIC SEARCH TECHNIQUES
 The artificial intelligence provides the appropriate search technique to solve the
problem,
 Because the problem that falls within the artificial intelligence are too complex
to be solved by
 the direct technique. Hence AI provides the varieties of heuristic search for
solving these problems.
1.Generate –and –Test
2.Hill Climbing
3.Best- first search
4. Problem reduction
5.Constraint Satisfaction
6.Mean –End analysis
 GENERATE –AND –TEST METHOD
 The generate and test method consist of following steps:
1. Generate a possible solution for some problem. Hence it generates a particular
point in the problem space and for some other problem it generates a path from
start state.
2. Test to see if this is actually a solution by comparing the chosen point or the
endpoint of chosen path to set the acceptable goal states.
3. If the solution has been found then quit otherwise go to step (1).
 If the generation of possible solution performed systematically then this
procedure will find a solution eventually. Unfortunately if the problem space is
very large then generate-and-test takes very long time for finding the solution.
 The generate -and-test algorithm is a depth first search procedure since the
complete solution must be generated before they can be tested.
 HILL CLIMBING
 The Hill Climbing is a variant of generate-and test procedure. In this method
we take the feedback from the possible solution which is used to help the
generator to decide which direction to move in the search space. In the pure
generate-and-test method the function respond only yes or no but if the test
function is augmented with heuristic function that provide an estimate of how
close a given state is to a goal state.
 Hill Climbing is often used when a good heuristic function is available for
evaluating state but when no other useful knowledge is available.
 Example: Suppose you are in unfamiliar city without a map and you want to
get down town .You simply aim for some location. The heuristic function is
just distance between the current location and the location of the goal. The
desire states are those in which the distance is minimum
 Algorithms

The Key difference is that the use of evaluating

function and the task specific knowledge into the
control process .
 LOCAL MAXIMUM
 It is a state that is better than all its
neighbor but it is not better than some
other states farther away.
 Local maximum are frustrating because
they often occur almost within sight of a
solution.
 PLATEAU
 Plateau is a flat area of the search space in
which a whole set of neighboring states the
same value. In this it is not possible to
determine the best direction in which to move
by making local comparison.
RIDGE
 Ridge is a special kind of local maximum. It
is an area of the search space that is higher
than surrounding areas and that itself has
slope. In this it is impossible to traverse a
ridge by single moves.
 SIMULATED ANNEALING
 The simulated annealing as a computational process is patterned after
the physical process of annealing in which physical substances such as
metals are melted and then gradually cooled until some solid state is
reached. Hence the goal of this process is produce of minimal energy in
final state. Hence we can say this minimal energy level is equivalent to
the heuristic function. Hence
 We have to minimize the value of heuristic function of some level in
which we found the goal.
 Physical substances usually move from higher energy level to lower
energy level.
 But there is some probability of that transition to higher energy state
will occur.
 BEST-FIRST SEARCH
 Best-first search is a search algorithm, which explores a graph by expanding
the most promising node chosen according to a specified rule.
 Judea Pearl described best-first search as estimating the promise of node n by
a “heuristic evaluation function f(n) which, in general, may depend on the
description of n, the description of the goal, the information gathered by the
search up to that point, and most important, on any extra knowledge about the
problem domain.”
 Some authors have used “best-first search” to refer specifically to a search
with a heuristic that attempts to predict how close the end of a path is to a
solution, so that paths, which are judged closer to a solution, are extended
first. This specific type of search is called greedy best-first search.
 Efficient selection of the current best candidate for extension is typically
implemented using a priority queu
ALGORITHM: BEST FIRST SEARCH
 1. OR-GRAPHS:-
 This algorithm will operate by searching a directed graph in which each node
represents a point in the problem space. Each node will contain to a
description of the problem state it represents and how promising node it is.
The list of successor will make it possible if a better node or path found to an
existing node then to propagate the improvement down to its successor. Hence
this type of graph called OR - graph. Since each of its branches represent an
alternative problem-solving path.
 In each step of the best first search process we select the most promising node
with the help appropriate heuristic function to each of them. After that we
expand the chosen node rules to generate its successor. If one of them is
solution then we quit otherwise again the most promising node if selecting and
process continues. This search can return to it whenever all other gets bad i.e.
the again most promising path.
. OR-GRAPHS(cont..)
 OR-GRAPHS(cont..)
 As shown above fig beginning of best first procedure there is one node we
expand it . We generate three nodes. The heuristic function, which is an
estimate of the cost of getting to solution from a given node, is applied to each
of these new nodes. Since node D is most promising node we expand it
producing two-successor node E and F. But at this stage we look another,
which is going through B, is more promising. Hence we expand it and generate
G and H. But again when these two nodes are evaluated they look less
promising than other path. So the attention is returned to the path D and E and
E is then expand producing J and I. At next stage J is expanded since it is more
promising. This process can continue until a solution is found.
To implement such graph –search procedure we need two lists of nodes.
 OPEN: Open is actually a priority queue in which the elements with highest –priority are those with
most promising value of the heuristic function. Hence the nodes that has been generated and have
heuristic function but it is not examined.
 CLOSE: In this list we keep the node that already examined. We keep these nodes in memory
because whenever a new node is generated we need to check whether it has been generated before.
 2) THE A* ALGORITHM
 The best first search algorithm can be simplified of an algorithm
called A*Algorithm in which we use heuristic function g, h`, f`. G
is the measure of cost getting from initial state to current state
(node). The function h’ is an estimate of the additional cost of
getting from current node to a goal state. This is the place where
knowledge about the problem domain is exploited. The combined
function f ‘=g+ h’ represent an estimate of the cost of getting from
the initial state to a goal state along the path that generate the
current node. If more than one path generate the node then the
algorithm will record the best one.
 A* algorithm can be used whether we are interested in finding a
minimal cost.
 THE A* ALGORITHM(cont..)
1. Start with OPEN containing only the initial node. Set the nodes g
value to zero then it h’ value to whatever it is and its f’ value to h’
+0=h’. Set closed to empty list.
2. Until a goal node is found repeat the following procedure.
 If there are no node in OPEN report failure otherwise pick the
node on OPEN with lowest f’ value and call is BESTNODE.
Remove it from OPEN and place on CLOSED and see if
BESTNODE is a goal state then exit otherwise generate the
successor of BESTNODE. For each SUCCESSOR do the
following
 THE A* ALGORITHM(cont..)
 Set SUCCESSOR to point back to BESTNODE. These backwards links
will make it possible to recover the path once a solution is found.
 Compute g’ (SUCCESSOR) = g(BESTNODE) + the cost of getting from
BESTNODE to SUCCESSOR.
 See if SUCCESSOR is the same as any node on OPEN then call node OLD
because this node already exists. We can throw SUCCESSOR away and
add OLD to the list of BESTNODE’ s SUCCESSOR. At this point we must
decide whether OLD’ s parent link reset to the point of BESTNODE. We
have just found SUCCESSOR is cheaper than the current best path to OLD.
Hence we see whether it is cheaper to get to OLD via its current parent or to
SUCCESSOR via BESTNODE by comparing their g values. If OLD is
cheaper then we do nothing. If SUCCESSOR is cheaper then reset OLD’ s
parent link to point to BESTNODE record the new cheaper path in g(OLD)
and update f ‘(OLD).
 THE A* ALGORITHM(cont..)
 If the SUCCESSOR was not an OPEN see if it is CLOSED, if so called node on
CLOSED OLD and add OLD to the list of BESTNODE’ s successor. At that
time check to see if the new path or old path is better then set the parent link and
g and f’ values appropriately. If we have just found a better path to OLD we
propagate the improvement to OLD successor. TO propagate the new cost
downward changing the each node g and f’ value and terminating each branch
when you reach either a node with no successor or a node to which an equivalent
or better path was already been found.
 If the successor was not already on either OPEN or CLOSED then put it on
OPEN and add it to the list of BESTNODES successor and compute
 F’ (SUCCESSOR)=g(SUCCESSOR)+h’(SUCCESSOR)

 PROBLEM REDUCTION :-
 When a problem can be divided into a set of sub problems, where each sub
problem can be solved separately and a combination of these will be a
solution, AND-OR graphs or AND - OR trees are used for representing the
solution. The decomposition of the problem or problem reduction generates
AND arcs. One AND are may point to any number of successor nodes. All
these must be solved so that the arc will rise to many arcs, indicating several
possible solutions. Hence the graph is known as AND - OR instead of AND. .
 1. AND- OR GRAPH
 AND-OR is useful for representing the solution of the problems
that can be solved by decomposing them into a set of smaller
problems after that all of them solved. This decomposition or
reduction generates arc that we call AND arcs. One AND arc
may point to any number of successor nodes all of which must
be solved in order for the arc to point to a solution just as in OR
graph. Hence different arc may come from single node
indicating variety of ways in which the original problem might
be solved. Hence this type of structure is called AND-OR graph.
AND arcs are indicated with a line connecting to all the
components
 1. AND- OR GRAPH(cont..)

This type of algorithm finds a path from the starting node of the
graph to a set of nodes representing the solution. Also it may be
necessary to get to more than one solution state since each arm of
AND arc must lead to its own solution node. The number at each
node represent the value of f’ at that node. Hence for every
operation has a uniform cost so each arc with a single successor
has a cost of 1 and each AND arc with multiple successor has a
cost of 1 for each of its components. For example consider:
 1. AND- OR GRAPH(cont..)

Here we expand B with cost 5. In AND-OR algorithm we

describe a node value and call it FUTILITY. If the estimated
cost of solution is greater than the value of FUTILITY then we
quit the search. FUTILITY is threshold such that any solution
with a cost above it is too expensive to be practical.
 2. AO*(AO star) algorithms
 The main difference between the A*(A star)
and AO*(AO star) algorithms is that A* algo is a OR
graph algorithm and AO* is a AND-OR graph
http://algorithm.In OR graph algorithm it just find only
one solution (i.e either OR solution means this OR this
OR this).But in the AND-OR graph algo it find more
than one solution
 AO*is a best-first algorithm for solving a cyclic
AND/OR graphs.
 AO*(AO star) algorithms(cont..)
 Initialise the graph to start node
 Traverse the graph following the current path accumulating nodes that have
not yet been expanded or solved
 Pick any of these nodes and expand it and if it has no successors call this
value FUTILITY otherwise calculate only f' for each of the successors.
 If f' is 0 then mark the node as SOLVED
 Change the value of f' for the newly created node to reflect its successors by
back propagation.
 Wherever possible use the most promising routes and if a node is marked
as SOLVED then mark the parent node as SOLVED.
 If starting node is SOLVED or value greater than FUTILITY, stop, else repeat
from 2.
AO* algorithm
1. Let G be a graph with only starting node INIT.
2. Repeat the followings until INIT is labeled SOLVED
or h(INIT) > FUTILITY
a) Select an unexpanded node from the most promising path
from INIT (call it NODE)
b) Generate successors of NODE. If there are none, set h(NODE)
= FUTILITY (i.e., NODE is unsolvable); otherwise for each
SUCCESSOR that is not an ancestor of NODE do the
following:
i. Add SUCCESSSOR to G.
ii. If SUCCESSOR is a terminal node, label it SOLVED and set
h(SUCCESSOR) = 0.
iii. If SUCCESSPR is not a terminal node, compute its h
 AO* algorithm (Cont.)
c) Propagate the newly discovered information up the graph
by doing the following: let S be set of SOLVED nodes or
nodes whose h values have been changed and need to have
values propagated back to their parents. Initialize S to
Node. Until S is empty repeat the followings:

i. Remove a node from S and call it CURRENT.

ii. Compute the cost of each of the arcs emerging from CURRENT.
Assign minimum cost of its successors as its h.
iii. Mark the best path out of CURRENT by marking the arc that had
the minimum cost in step ii
iv. Mark CURRENT as SOLVED if all of the nodes connected to it
through new labeled arc have been labeled SOLVED
v. If CURRENT has been labeled SOLVED or its cost was just
changed, propagate its new cost back up through the graph. So add
all of the ancestors of CURRENT to S.
An Example
An Example

(8) A
An Example

[12] A [13]
4 5
5
(1) B D (8)

(2)
C
An Example

[15] A [13]
4 5
5
(4) B 2 D (8)

(2)
C
An Example
[15] A [8]
4 5
5
(4) B 2 D (3)

(2)
C 2
4

(1) E

(0) G
An Example
[15] A [9]
4 5
5
(4) B 2 D (4)

(2)
C 2
2
4

(3) E
3

(0) G
An Example
[15] A Solved
4 5
5
(4) B 2 D Solved

(2)
C 2
2
4

(3) E
3

(0) G Solved
 Constraint Satisfaction
 In artificial intelligence and operations research, constraint
satisfaction is the process of finding a solution to a set
of constraints that impose conditions that the variables must
satisfy.
 Constraint satisfaction problems (CSPs) are mathematical problems
defined as a set of objects whose state must satisfy a number
of constraints or limitations. CSPs represent the entities in a problem as a
homogeneous collection of finite constraints over variables, which is
solved by constraint satisfaction methods. CSPs are the subject of intense
research in both artificial intelligence and operations research, since the
regularity in their formulation provides a common basis to analyze and
solve problems.
CSP Example: Cryptharithmetic puzzle
Problem:
 Problem Statement
How to assign decimal digits to
letters, so that the following sum
is valid? Assume that we already SEND
know that + MORE
 The possible digits set for the

letters is {0,1,2,…9};
--------
 M must be 1; MONEY
 Two different letters can't be

assigned the same digit

using c1,c2 and c3 to represent carries
changing problem to solve 4 equations

S E N D D+E = Y+10*C1
M O R E C1+N+R = E+10*C2
+ C3 C2 C1 C2+E+O = N+10*C3
---------------------- C3+S+M = O+10*M
M O N E Y
Exercise