ARTIFICIAL INTELLEGENCE

UNIT-II
Problem solving state space search
tree and control strategies

1
Introduction:
 A method of identifying the proper solution for specific problem.
 Start State to the Desired Solution state
 PS is most viewed and concentrated area of AI.
 Propose a systematic search mechanism for to reach the goal state.
 Solve the task by series of actions.
 For Example: Solving the problem of identifying the specific path from source to
destination.
 In AI, problems are defined in a state space where the solution is identified with
specific flow of starting from start state to goal state.

Steps problem-solving in AI: The problem of AI is directly associated with the nature
of humans and their activities. So we need a number of finite steps to solve a problem
which makes human easy works.
These are the following steps which require to solve a problem :
Goal Formulation: This one is the first and simple step in problem-solving. It
organizes finite steps to formulate a target/goals which require some action to achieve
the goal. Today the formulation of the goal is based on AI agents.

2
Problem formulation: It is one of the core steps of problem-solving which decides
what action should be taken to achieve the formulated goal. In AI this core part is
dependent upon software agent which consisted of the following components to
formulate the associated problem.
Components to formulate the associated problem:

Initial State: This state requires an initial state for the problem which starts the AI
agent towards a specified goal. In this state new methods also initialize problem
domain solving by a specific class.

Action: This stage of problem formulation works with function with a specific class
taken from the initial state and all possible actions done in this stage.

Transition: This stage of problem formulation integrates the actual action done by the
previous action stage and collects the final stage to forward it to their next stage.

Goal test: This stage determines that the specified goal achieved by the integrated
transition model or not, whenever the goal achieves stop the action and forward into
the next stage to determines the cost to achieve the goal.
Path costing: This component of problem-solving numerical assigned what will be the
cost to achieve the goal. It requires all hardware software and human working cost.
3
Genral problem solving:
The General Problem Solver (GPS) was an AI program proposed
by Herbert Simon, J.C. Shaw, and Allen Newell.
It was the first useful computer program that came into existence in the AI world.
The goal was to make it work as a universal problem-solving machine.
Even though GPS was intended to be a general purpose, it could only solve well-
defined problems, such as proving mathematical theorems in geometry and logic.
But in the real world, this quickly becomes intractable because of the number of
possible paths you can take.
If it tries to brute force a problem by counting the number of walks in a graph, it
becomes computationally infeasible.
Charecteristics of problem :
• Decomposable to smaller or easier problems.
• Solution steps can be ignored or undone.
• Predictable problem universe.
• Good solutions are obvious.
• Uses internally consistent knowledge base.
• Requires lots of knowledge or uses knowledge to constrain solutions
• Requires periodic interaction between human and computer

4
Exhaustive searches
 In computer science, brute-force search or exhaustive search, also known
as generate and test
 It is a very general problem-solving technique and algorithmic paradigm that
consists of systematically enumerating all possible candidates for the solution and
checking whether each candidate satisfies the problem's statement.
 The brute-force method for finding an item in a table – namely, check all entries of
the latter, sequentially – is called linear search.

Heuristic search techniques

5
Heuristic Search Techniques
Direct Heuristic Search Technique
1. Other names for these are Blind Search, Uninformed Search, and Blind Control Strategy.
2. These aren’t always possible since they demand much time or memory.
3. They search the entire state space for a solution and use an arbitrary ordering of operations.
4. Examples of these are Breadth First Search (BFS) and Depth First Search (DFS).
Weak Heuristic Search Technique
5. Other names for these are Informed Search, Heuristic Search, and Heuristic Control Strategy.
6. These are effective if applied correctly to the right types of tasks and usually demand domain-
specific information.
7. We need this extra information to compute preference among child nodes to explore and
expand.
8. Each node has a heuristic function associated with it.

6
Hill Climbing in Artifical Intelligence
First, let’s talk about Hill Climbing in Artifical Intelligence.
This is a heuristic for optimizing problems mathematically.
We need to choose values from the input to maximize or minimize a
real function.
Features of Hill Climbing in AI
• Let’s discuss some of the features of this algorithm (Hill Climbing):
• It is a variant of the generate-and-test algorithm
• It makes use of the greedy approach
Types of Hill Climbing in AI
• Simple Hill Climbing- This examines one neighboring node at a
time and selects the first one that optimizes the current cost to be the
next node.
• Steepest Ascent Hill Climbing- This examines all neighboring nodes
and selects the one closest to the solution state.
• Stochastic Hill Climbing- This selects a neighboring node at random
and decides whether to move to it or examine another. 7
Let’s take a look at the algorithm for simple hill
climbing.
• Evaluate initial state- if goal state, stop and return
success. Else, make initial state current.
• Loop until the solution reached or until no new operators
left to apply to current state:
• a. Select new operator to apply to the current producing
new state.
• b. Evaluate new state:
• If a goal state, stop and return success.
• If better than the current state, make it current state,
proceed.
• Even if not better than the current state, continue until the
solution reached.
• Exit. 8
Problems with Hill Climbing in AI
We usually run into one of three issues-
Local Maximum- All neighboring states have values worse than the current. The greedy approach
means we won’t be moving to a worse state. This terminates the process even though there may
have been a better solution. As a workaround, we use backtracking.
Plateau- All neighbors to it have the same value. This makes it impossible to choose a direction.
To avoid this, we randomly make a big jump.
Ridge- At a ridge, movement in all possible directions is downward. This makes it look like a peak
and terminates the process. To avoid this, we may use two or more rules before testing.
Best-First Search (BFS) Heuristic Search
Define list OPEN with single node s– the start node.
IF list is empty, return failure.
Remove node n (node with best score) from list, move it to list CLOSED.
Expand node n.
IF any successor to n is the goal node, return success and trace path from goal node to s
to return the solution.
FOR each successor node:
Apply evaluation function f.
IF the node isn’t in either list, add it to list OPEN.
Loop to step 2.

9
Iterative Deepening A*
• Iterative deepening A* (IDA*) is a graph traversal and path search algorithm that
can find the shortest path between a designated start node and any member of a set
of goal nodes in a weighted graph.
• It is a variant of iterative deepening depth-first search that borrows the idea to use a
heuristic function to evaluate the remaining cost to get to the goal from the A*
search algorithm.
• Since it is a depth-first search algorithm, its memory usage is lower than in A*, but
unlike ordinary iterative deepening search, it concentrates on exploring the most
promising nodes and thus does not go to the same depth everywhere in the search
tree.
• Unlike A*, IDA* does not utilize dynamic programming and therefore often ends
up exploring the same nodes many times.
• While the standard iterative deepening depth-first search uses search depth as the
cutoff for each iteration, the IDA* uses the more informative f(n)=g(n)+h(n),
where g(n)is the cost to travel from the root to node n and h(n) is a problem-
specific heuristic estimate of the cost to travel from n to the goal.
• The algorithm was first described by Richard Korf in 1985

10
constraint satisfaction
 Constraint satisfaction originated in the field of artificial intelligence in the 1970s
(see for example (Laurière 1978)).
 During the 1980s and 1990s, embedding of constraints into a
programming language were developed.
 Languages often used for constraint programming are Prolog and C++.
Solving
 Constraint satisfaction problems on finite domains are typically solved using a form
of search.
 The most used techniques are variants of backtracking, constraint propagation, and
local search.
 These techniques are used on problems with nonlinear constraints.
Constraint satisfaction toolkits
 Constraint satisfaction toolkits are software libraries for
imperative programming languages that are used to encode and solve a constraint
satisfaction problem.
 Cassowary constraint solver, an open source project for constraint satisfaction
(accessible from C, Java, Python and other languages).
 Comet, a commercial programming language and toolkit
 Gecode, an open source portable toolkit written in C++ developed as a production-
quality and highly efficient implementation of a complete theoretical background. 11
 Problem reduction and game playing
Problem reduction:
We already know about the divide and conquer strategy, a solution to a problem can be
obtained by decomposing it into smaller sub-problems.
Each of this sub-problem can then be solved to get its sub solution. These sub solutions
can then recombined to get a solution as a whole.
That is called is Problem Reduction. This method generates arc which is called
as AND arcs. One AND arc may point to any number of successor nodes, all of which
must be solved in order for an arc to point to a solution.

12
Problem Reduction algorithm:
1.Initialize the graph to the starting node.
2. Loop until the starting node is labelled SOLVED or until its cost
goes above FUTILITY:
(i) Traverse the graph, starting at the initial node and following the
current best path and accumulate the set of nodes that are on that
path and have not yet been expanded.
(ii) Pick one of these unexpanded nodes and expand it. If there are
no successors, assign FUTILITY as the value of this node.
Otherwise, add its successors to the graph and for each of them
compute f'(n). If f'(n) of any node is O, mark that node as SOLVED.
(iii) Change the f'(n) estimate of the newly expanded node to reflect
the new information provided by its successors. Propagate this
change backwards through the graph. If any node contains a
successor arc whose descendants are all solved, label the node itself
as SOLVED.

13
Mini-Max Algorithm in Artificial Intelligence
 Mini-max algorithm is a recursive or backtracking algorithm which is
used in decision-making and game theory. It provides an optimal move
for the player assuming that opponent is also playing optimally.
 Mini-Max algorithm uses recursion to search through the game-tree.
 Min-Max algorithm is mostly used for game playing in AI. Such as
Chess, Checkers, tic-tac-toe, go, and various tow-players game. This
Algorithm computes the minimax decision for the current state.
 In this algorithm two players play the game, one is called MAX and
other is called MIN.
 Both the players fight it as the opponent player gets the minimum
benefit while they get the maximum benefit.
 Both Players of the game are opponent of each other, where MAX will
select the maximized value and MIN will select the minimized value.
 The minimax algorithm performs a depth-first search algorithm for the
exploration of the complete game tree.
 The minimax algorithm proceeds all the way down to the terminal
node of the tree, then backtrack the tree as the recursion. 14
Pseudo-code for MinMax Algorithm:
1. function minimax(node, depth, maximizingPlayer) is
2. if depth ==0 or node is a terminal node then
3. return static evaluation of node
4.
5. if MaximizingPlayer then // for Maximizer Player
6. maxEva= -infinity
7. for each child of node do
8. eva= minimax(child, depth-1, false)
9. maxEva= max(maxEva,eva) //gives Maximum of the values
10. return maxEva
11.
12. else // for Minimizer player
13. minEva= +infinity
14. for each child of node do
15. eva= minimax(child, depth-1, true)
16. minEva= min(minEva, eva) //gives minimum of the values
15
17. return minEva
Working of Min-Max Algorithm:
Step-1: In the first step, the algorithm generates the entire game-tree and apply the utility function
to get the utility values for the terminal states. In the below tree diagram, let's take A is the initial
state of the tree.
Suppose maximizer takes first turn which has worst-case initial value =- infinity, and minimizer
will take next turn which has worst-case initial value = +infinity.

Step 2: Now, first we find the utilities value for the Maximizer, its initial value is -∞, so we will
compare each value in terminal state with initial value of Maximizer and determines the higher
nodes values. It will find the maximum among the all.
• For node D max(-1,- -∞) => max(-1,4)= 4
• For Node E max(2, -∞) => max(2, 6)= 6
• For Node F max(-3, -∞) => max(-3,-5) = -3
• For node G max(0, -∞) = max(0, 7) = 7
16
Step 3: In the next step, it's a turn for minimizer, so it will compare all nodes
value with +∞, and will find the 3rd layer node values.
• For node B= min(4,6) = 4
• For node C= min (-3, 7) = -3

Step 4: Now it's a turn for Maximizer, and it will again choose the maximum
of all nodes value and find the maximum value for the root node. In this game
tree, there are only 4 layers, hence we reach immediately to the root node,
but in real games, there will be more than 4 layers.
• For node A max(4, -3)= 4

17
Properties of Mini-Max algorithm:
 Complete- Min-Max algorithm is Complete. It will definitely find a
solution (if exist), in the finite search tree.
 Optimal- Min-Max algorithm is optimal if both opponents are
playing optimally.
 Time complexity- As it performs DFS for the game-tree, so the time
complexity of Min-Max algorithm is O(bm), where b is branching
factor of the game-tree, and m is the maximum depth of the tree.
 Space Complexity- Space complexity of Mini-max algorithm is
also similar to DFS which is O(bm).
Limitation of the minimax Algorithm:
 The main drawback of the minimax algorithm is that it gets really
slow for complex games such as Chess, go, etc.
 This type of games has a huge branching factor, and the player has
lots of choices to decide. This limitation of the minimax algorithm
can be improved from alpha-beta pruning which we have
discussed in the next topic.
18
Alpha-Beta Pruning
Alpha-beta pruning is a modified version of the minimax algorithm. It is an
optimization technique for the minimax algorithm.
The two-parameter can be defined as:
– Alpha: The best (highest-value) choice we have found so far at any point along
the path of Maximizer. The initial value of alpha is -∞.
– Beta: The best (lowest-value) choice we have found so far at any point along
the path of Minimizer. The initial value of beta is +∞.
The main condition which required for alpha-beta pruning is:
α>=β
Key points about alpha-beta pruning:
 The Max player will only update the value of alpha.
 The Min player will only update the value of beta.
 While backtracking the tree, the node values will be passed to upper
nodes instead of values of alpha and beta.
 We will only pass the alpha, beta values to the child nodes.

19
Pseudo-code for Alpha-beta Pruning:
• function minimax(node, depth, alpha, beta, maximizingPlayer) is
• if depth ==0 or node is a terminal node then
• return static evaluation of node
•
• if MaximizingPlayer then // for Maximizer Player
• maxEva= -infinity
• for each child of node do
• eva= minimax(child, depth-1, alpha, beta, False)
• maxEva= max(maxEva, eva)
• alpha= max(alpha, maxEva)
• if beta<=alpha
• break
• return maxEva
•
• else // for Minimizer player
• minEva= +infinity
• for each child of node do
• eva= minimax(child, depth-1, alpha, beta, true)
• minEva= min(minEva, eva)
• beta= min(beta, eva)
• if beta<=alpha
• break
20
• return minEva
Working of Alpha-Beta Pruning:
Step 1: At the first step the, Max player will start first move from node A where α= -∞ and β= +∞,
these value of alpha and beta passed down to node B where again α= -∞ and β= +∞, and Node B
passes the same value to its child D

Step 2: At Node D, the value of α will be calculated as its turn for Max. The value of α is
compared with firstly 2 and then 3, and the max (2, 3) = 3 will be the value of α at node D and
node value will also 3.
Step 3: Now algorithm backtrack to node B, where the value of β will change as this is a turn of
Min, Now β= +∞, will compare with the available subsequent nodes value, i.e. min (∞, 3) = 3,
hence at node B now α= -∞, and β= 3.

21
In the next step, algorithm traverse the next successor of Node B which is node E, and the values
of α= -∞, and β= 3 will also be passed.
Step 4: At node E, Max will take its turn, and the value of alpha will change. The current value of
alpha will be compared with 5, so max (-∞, 5) = 5, hence at node E α= 5 and β= 3, where α>=β, so
the right successor of E will be pruned, and algorithm will not traverse it, and the value at node E
will be 5.

Step 5: At next step, algorithm again backtrack the tree, from node B to node A. At node A, the value of alpha
will be changed the maximum available value is 3 as max (-∞, 3)= 3, and β= +∞, these two values now passes
to right successor of A which is Node C.
At node C, α=3 and β= +∞, and the same values will be passed on to node F.
Step 6: At node F, again the value of α will be compared with left child which is 0, and max(3,0)= 3, and then
compared with right child which is 1, and max(3,1)= 3 still α remains 3, but the node value of F will become 1.

22
Step 7: Node F returns the node value 1 to node C, at C α= 3 and β= +∞, here the value of beta
will be changed, it will compare with 1 so min (∞, 1) = 1. Now at C, α=3 and β= 1, and again it
satisfies the condition α>=β, so the next child of C which is G will be pruned, and the algorithm
will not compute the entire sub-tree G.

Step 8: C now returns the value of 1 to A here the best value for A is max (3, 1) = 3. Following is
the final game tree which is the showing the nodes which are computed and nodes which has
never computed. Hence the optimal value for the maximizer is 3 for this example.

23
Two player perfect information games
 The perfect examples of deterministic, two-player, zero-sum, and perfect-
information games are chess, checkers, tic-tac-toe, and Go. Looking at the
image, the minimizer will choose the child node with the lowest score [min
(3, 12, 8) = 3].
 Perfect information: A game with the perfect information is that in which
agents can look into the complete board. Agents have all the information
about the game, and they can see each other moves also. Examples are Chess,
Checkers, Go, etc.
 Imperfect information: If in a game agents do not have all information about
the game and not aware with what's going on, such type of games are called
the game with imperfect information, such as tic-tac-toe, Battleship, blind,
Bridge, etc.
 Deterministic games: Deterministic games are those games which follow a
strict pattern and set of rules for the games, and there is no randomness
associated with them. Examples are chess, Checkers, Go, tic-tac-toe, etc.
 Non-deterministic games: Non-deterministic are those games which have
various unpredictable events and has a factor of chance or luck. This factor of
chance or luck is introduced by either dice or cards. These are random, and
each action response is not fixed. Such games are also called as stochastic
games. 24
Example: Backgammon, Monopoly, Poker, etc.
Game tree:
 A game tree is a tree where nodes of the tree are the game states and Edges of the tree are the
moves by players. Game tree involves initial state, actions function, and result Function.
Example: Tic-Tac-Toe game tree:
 The following figure is showing part of the game-tree for tic-tac-toe game. Following are
some key points of the game:
 There are two players MAX and MIN.
 Players have an alternate turn and start with MAX.
 MAX maximizes the result of the game tree
 MIN minimizes the result.

25
Example Explanation:
 From the initial state, MAX has 9 possible moves as he starts first. MAX place x
and MIN place o, and both player plays alternatively until we reach a leaf node
where one player has three in a row or all squares are filled.
 Both players will compute each node, minimax, the minimax value which is the
best achievable utility against an optimal adversary.
 Suppose both the players are well aware of the tic-tac-toe and playing the best play.
Each player is doing his best to prevent another one from winning. MIN is acting
against Max in the game.
 So in the game tree, we have a layer of Max, a layer of MIN, and each layer is
called as Ply. Max place x, then MIN puts o to prevent Max from winning, and this
game continues until the terminal node.
 In this either MIN wins, MAX wins, or it's a draw. This game-tree is the whole
search space of possibilities that MIN and MAX are playing tic-tac-toe and taking
turns alternately.
 Hence adversarial Search for the minimax procedure works as follows:
 It aims to find the optimal strategy for MAX to win the game.
 It follows the approach of Depth-first search.
 In the game tree, optimal leaf node could appear at any depth of the tree.
 Propagate the minimax values up to the tree until the terminal node discovered.
********THE END***********
26