GOVINDRAO WANJARI COLLEGE OF ENGINEERING & TECHNOLOGY

148,149 SALAI GODHANI, HUDKESWAR ROAD, NAGPUR

DEPARTMENT OF INFORMATION TECHNOLOGY

Sub Code: BTITC702 Subject: Artificial Intelligence Sem: VII Sem

………………………………………………………………………………………………………

Unit No. 3

Heuristic search strategies: Greedy best-first search, A* search, Memory bounded heuristic
search: local search algorithms & optimization problems: Hill climbing search, Simulated
annealing search, Local beam search, Genetic algorithms; Constraint satisfaction problems,
Local search for constraint satisfaction problems. Adversarial search: Games, optimal decisions
& strategies in games, The minimax search procedure, Alpha-beta pruning, Additional
refinements, Iterative deepening.

Heuristic Search Techniques in AI


One of the core methods AI systems use to navigate problem-solving is through
heuristic search techniques. These techniques are essential for tasks that involve
finding the best path from a starting point to a goal state, such as in navigation
systems, game playing, and optimization problems. This article delves into what
heuristic search is, its significance, and the various techniques employed in AI.

Understanding Heuristic Search

Heuristics operates on the search space of a problem to find the best or closest-to-optimal
solution via the use of systematic algorithms. In contrast to a brute-force approach, which
checks all possible solutions exhaustively, a heuristic search method uses heuristic information
to define a route that seems more plausible than the rest. Heuristics, in this case, refer to a set
of criteria or rules of thumb that offer an estimate of a firm's profitability. Utilizing heuristic
guiding, the algorithms determine the balance between exploration and exploitation, and thus
they can successfully tackle demanding issues. Therefore, they enable an efficient solution
finding process.
Significance of Heuristic Search in AI
The primary benefit of using heuristic search techniques in AI is their ability to handle large
search spaces. Heuristics help to prioritize which paths are most likely to lead to a solution,
significantly reducing the number of paths that must be explored. This not only speeds up the
search process but also makes it feasible to solve problems that are otherwise too complex to
handle with exact algorithms.

Components of Heuristic Search

Heuristic search algorithms typically comprise several essential components:
1. State Space: This implies that the totality of all possible states or settings, which is
considered to be the solution for the given problem.
2. Initial State: The instance in the search tree of the highest level with no null values,
serving as the initial state of the problem at hand.
3. Goal Test: The exploration phase ensures whether the present state is a terminal or
consenting state in which the problem is solved.
4. Successor Function: This create a situation where individual states supplant the current
state which represent the possible moves or solutions in the problem space.
5. Heuristic Function: The function of a heuristic is to estimate the value or distance from
a given state to the target state. It helps to focus the process on regions or states that
has prospect of achieving the goal.
Types of Heuristic Search Techniques
Over the history of heuristic search algorithms, there have been a lot of techniques created to
improve them further and attend different problem domains. Some prominent techniques
include:
1. A Search Algorithm*
A* Search Algorithm is perhaps the most well-known heuristic search algorithm. It uses a best-
first search and finds the least-cost path from a given initial node to a target node. It has a
heuristic function, often denoted as f(n)=g(n)+h(n)f(n)=g(n)+h(n), where g(n) is the cost from
the start node to n, and h(n) is a heuristic that estimates the cost of the cheapest path
from n to the goal. A* is widely used in pathfinding and graph traversal.
2. Greedy Best-First Search
Greedy best-first search expands the node that is closest to the goal, as estimated by a heuristic
function. Unlike A*, which takes into account the cost of the path from the start node to the
current node, the greedy best-first search only prioritizes the estimated cost from the current
node to the goal. This makes it faster but less optimal than A*.
3. Hill Climbing
Hill climbing is a heuristic search used for mathematical optimization problems. It is a variant of
the gradient ascent method. Starting from a random point, the algorithm takes steps in the
direction of increasing elevation or value to find the peak of the mountain or the optimal
solution to the problem. However, it may settle for a local maximum and not reach the global
maximum.
4. Simulated Annealing
Inspired by the process of annealing in metallurgy, simulated annealing is a probabilistic
technique for approximating the global optimum of a given function. It allows the algorithm to
jump out of any local optimums in search of the global optimum by probabilistically deciding
whether to accept or reject a higher-cost solution during the early phases of the search.
5. Beam Search
Beam search is a heuristic search algorithm that explores a graph by expanding the most
promising nodes in a limited set or "beam". The beam width, which limits the number of nodes
stored in memory, plays a crucial role in the performance and accuracy of the search.
Applications of Heuristic Search
Heuristic search techniques find application in a wide range of problem-solving scenarios,
including:
1. Pathfinding: Discovery, of the shortest distance that can be found from the start point
to the destination at the point of coordinates or graph.
2. Optimization: Solving the problem of the optimal distribution of resources, planning or
posting to achieve maximum results.
3. Game Playing: The agency of AI with some board games, e.g., chess or Go, is on giving
guidance and making strategy-based decisions to the agents.
4. Robotics: Scheduling robots` location and movement to guide carefully expeditions and
perform given tasks with high efficiency.

5. Natural Language Processing: Language processing tasks involving search algorithms,

such as parsing or semantic analysis, should be outlined. That means.

Advantages of Heuristic Search Techniques

Heuristic search techniques offer several advantages:
1. Efficiency: As they are capable of aggressively digesting large areas for the more
promising lines, they can allot more time and resources to investigate the area.
 2. Optimality: If the methods that an algorithm uses are admissible, A* guarantees of an
optimal result.
3. Versatility: Heuristic search methods encompass a spectrum of problems that are
applied to various domains of problems.
Limitations of Heuristic Search Techniques
1. Heuristic Quality: The power of heuristic search strongly depends on the quality of
function the heuristic horizon. If the heuristics are constructed thoughtlessly, then their
level of performance may be low or inefficient.
2. Space Complexity: The main requirement for some heuristic search algorithms could be
a huge memory size in comparison with the others, especially in cases where the search
space considerably increases.
3. Domain-Specificity: It is often the case that devising efficient heuristics depends on the
specifics of the domain, a challenging obstruction to development of generic
approaches.

A* Search Algorithm

Motivation
To approximate the shortest path in real-life situations, like- in maps, games where there can
be many hindrances.
We can consider a 2D Grid having several obstacles and we start from a source cell (colored red
below) to reach towards a goal cell (colored green below)
What is A* Search Algorithm?

A* Search algorithm is one of the best and popular technique used in path-finding and graph
traversals.

Why A* Search Algorithm?

Informally speaking, A* Search algorithms, unlike other traversal techniques, it has “brains”.
What it means is that it is really a smart algorithm which separates it from the other
conventional algorithms. This fact is cleared in detail in below sections.
And it is also worth mentioning that many games and web-based maps use this algorithm to
find the shortest path very efficiently (approximation).

Explanation

Consider a square grid having many obstacles and we are given a starting cell and a target cell.
We want to reach the target cell (if possible) from the starting cell as quickly as possible. Here
A* Search Algorithm comes to the rescue.
What A* Search Algorithm does is that at each step it picks the node according to a value-‘f’
which is a parameter equal to the sum of two other parameters – ‘g’ and ‘h’. At each step it
picks the node/cell having the lowest ‘f’, and process that node/cell.
We define ‘g’ and ‘h’ as simply as possible below
g = the movement cost to move from the starting point to a given square on the grid, following
the path generated to get there.
h = the estimated movement cost to move from that given square on the grid to the final
destination. This is often referred to as the heuristic, which is nothing but a kind of smart guess.
We really don’t know the actual distance until we find the path, because all sorts of things can
be in the way (walls, water, etc.). There can be many ways to calculate this ‘h’ which are
discussed in the later sections.

Algorithm
We create two lists – Open List and Closed List (just like Dijkstra Algorithm)

// A* Search Algorithm
1. Initialize the open list
2. Initialize the closed list
put the starting node on the open
list (you can leave its f at zero)

3. while the open list is not empty

a) find the node with the least f on
the open list, call it "q"
b) pop q off the open list

c) generate q's 8 successors and set their

parents to q

d) for each successor

 i) if successor is the goal, stop search

ii) else, compute both g and h for successor

successor.g = q.g + distance between

successor and q
successor.h = distance from goal to
successor (This can be done using many
ways, we will discuss three heuristics-

Manhattan, Diagonal and Euclidean

Heuristics)

successor.f = successor.g + successor.h

iii) if a node with the same position as

successor is in the OPEN list which has a

lower f than successor, skip this successor
iV) if a node with the same position as
successor is in the CLOSED list which has
a lower f than successor, skip this successor
otherwise, add the node to the open list
end (for loop)

e) push q on the closed list

end (while loop)
Greedy Best first search algorithm
What is the Greedy-Best-first search algorithm?
Greedy Best-First Search is an AI search algorithm that attempts to find the most promising path
from a given starting point to a goal. It prioritizes paths that appear to be the most promising,
regardless of whether or not they are actually the shortest path. The algorithm works by
evaluating the cost of each possible path and then expanding the path with the lowest cost. This
process is repeated until the goal is reached.
The algorithm works by using a heuristic function to determine which path is the most
promising. The heuristic function takes into account the cost of the current path and the
estimated cost of the remaining paths. If the cost of the current path is lower than the
estimated cost of the remaining paths, then the current path is chosen. This process is repeated
until the goal is reached.

How Greedy Best-First Search Works?

 Greedy Best-First Search works by evaluating the cost of each possible path and then
expanding the path with the lowest cost. This process is repeated until the goal is
reached.
 The algorithm uses a heuristic function to determine which path is the most promising.
 The heuristic function takes into account the cost of the current path and the estimated
cost of the remaining paths.
 If the cost of the current path is lower than the estimated cost of the remaining paths,
then the current path is chosen. This process is repeated until the goal is reached.
An example of the best-first search algorithm is below graph, suppose we have to find the
path from A to G
The values in red color represent the heuristic value of reaching the goal node G from current
node
1) We are starting from A , so from A there are direct path to node B( with heuristics value of 32
) , from A to C ( with heuristics value of 25 ) and from A to D( with heuristics value of 35 ) .

2) So as per best first search algorithm choose the path with lowest heuristics value , currently C
has lowest value among above node . So we will go from A to C.

3) Now from C we have direct paths as C to F( with heuristics value of 17 ) and C to E( with
heuristics value of 19) , so we will go from C to F.
4) Now from F we have direct path to go to the goal node G ( with heuristics value of 0 ) , so we
will go from F to G.

5) So now the goal node G has been reached and the path we will follow is A->C->F->G .

Advantages of Greedy Best-First Search:

  Simple and Easy to Implement: Greedy Best-First Search is a relatively straightforward
algorithm, making it easy to implement.
 Fast and Efficient: Greedy Best-First Search is a very fast algorithm, making it ideal for
applications where speed is essential.
 Low Memory Requirements: Greedy Best-First Search requires only a small amount of
memory, making it suitable for applications with limited memory.
 Flexible: Greedy Best-First Search can be adapted to different types of problems and
can be easily extended to more complex problems.
 Efficiency: If the heuristic function used in Greedy Best-First Search is good to estimate,
how close a node is to the solution, this algorithm can be a very efficient and find a
solution quickly, even in large search spaces.
Disadvantages of Greedy Best-First Search:
 Inaccurate Results: Greedy Best-First Search is not always guaranteed to find the
optimal solution, as it is only concerned with finding the most promising path.
 Local Optima: Greedy Best-First Search can get stuck in local optima, meaning that the
path chosen may not be the best possible path.

 Heuristic Function: Greedy Best-First Search requires a heuristic function in order to

work, which adds complexity to the algorithm.

 Lack of Completeness: Greedy Best-First Search is not a complete algorithm, meaning it

may not always find a solution if one is exists. This can happen if the algorithm gets
stuck in a cycle or if the search space is a too much complex.

Applications of Greedy Best-First Search:

 Pathfinding: Greedy Best-First Search is used to find the shortest path between two
points in a graph. It is used in many applications such as video games, robotics, and
navigation systems.

 Machine Learning: Greedy Best-First Search can be used in machine learning algorithms
to find the most promising path through a search space.
 Optimization: Greedy Best-First Search can be used to optimize the parameters of a
system in order to achieve the desired result.
 Game AI: Greedy Best-First Search can be used in game AI to evaluate potential moves
and chose the best one.
 Navigation: Greedy Best-First Search can be use to navigate to find the shortest path
between two locations.
  Natural Language Processing: Greedy Best-First Search can be use in natural language
processing tasks such as language translation or speech recognisation to generate the
most likely sequence of words.
 Image Processing: Greedy Best-First Search can be use in image processing to segment
image into regions of interest.

Hill Climbing in Artificial Intelligence

Hill climbing is a widely used optimization algorithm in Artificial Intelligence

(AI) that helps find the best possible solution to a given problem. As part of the local
search algorithms family, it is often applied to optimization problems where the
goal is to identify the optimal solution from a set of potential candidates.
Understanding Hill Climbing in AI
Hill Climbing is a heuristic search algorithm used primarily for mathematical
optimization problems in artificial intelligence (AI). It is a form of local search, which
means it focuses on finding the optimal solution by making incremental changes to an
existing solution and then evaluating whether the new solution is better than the
current one. The process is analogous to climbing a hill where you continually seek to
improve your position until you reach the top, or local maximum, from where no
further improvement can be made.
Hill climbing is a fundamental concept in AI because of its simplicity, efficiency, and
effectiveness in certain scenarios, especially when dealing with optimization problems
or finding solutions in large search spaces.

How Does the Hill Climbing Algorithm Work?

In the Hill Climbing algorithm, the process begins with an initial solution, which is then
iteratively improved by making small, incremental changes. These changes are evaluated by
a heuristic function to determine the quality of the solution. The algorithm continues to make
these adjustments until it reaches a local maximum—a point where no further improvement
can be made with the current set of moves.
Basic Concepts of Hill Climbing Algorithms

Hill climbing follows these steps:

1. Initial State: Start with an arbitrary or random solution (initial state).
2. Neighboring States: Identify neighboring states of the current solution by making small
adjustments (mutations or tweaks).
 3. Move to Neighbor: If one of the neighboring states offers a better solution (according to
some evaluation function), move to this new state.
4. Termination: Repeat this process until no neighboring state is better than the current
one. At this point, you’ve reached a local maximum or minimum (depending on whether
you’re maximizing or minimizing).
Hill Climbing as a Heuristic Search in Mathematical Optimization
Hill Climbing algorithm often used for solving mathematical optimization problems in AI. With
a good heuristic function and a large set of inputs, Hill Climbing can find a sufficiently good
solution in a reasonable amount of time, although it may not always find the global optimal
maximum.
In mathematical optimization, Hill Climbing is commonly applied to problems that
involve maximizing or minimizing a real function. For example, in the Traveling Salesman
Problem, the objective is to minimize the distance traveled by the salesman while visiting
multiple cities.
What is a Heuristic Function?
A heuristic function is a function that ranks the possible alternatives at any branching step in a
search algorithm based on available information. It helps the algorithm select the best route
among various possible paths, thus guiding the search towards a good solution efficiently.
Features of the Hill Climbing Algorithm
1. Variant of Generating and Testing Algorithm: Hill Climbing is a specific variant of the
generating and testing algorithms. The process involves:
 Generating possible solutions: The algorithm creates potential solutions within
the search space.
 Testing solutions: Each generated solution is evaluated to determine if it meets
the desired criteria.
 Iteration: If a satisfactory solution is found, the algorithm terminates; otherwise,
it returns to the generation step.
This iterative feedback mechanism allows Hill Climbing to refine its search by using information
from previous evaluations to inform future moves in the search space.
2. Greedy Approach: The Hill Climbing algorithm employs a greedy approach, meaning
that at each step, it moves in the direction that optimizes the objective function. This
strategy aims to find the optimal solution efficiently by making the best immediate
choice without considering the overall problem context.
Local Search Algorithms

1. Hill Climbing
2. Local Beam Search
3. Simulated Annealing

Types of Hill Climbing in Artificial Intelligence

1. Simple Hill Climbing Algorithm

Simple Hill Climbing is a straightforward variant of hill climbing where the algorithm evaluates
each neighboring node one by one and selects the first node that offers an improvement over
the current one.

Algorithm for Simple Hill Climbing

1. Evaluate the initial state. If it is a goal state, return success.
2. Make the initial state the current state.
3. Loop until a solution is found or no operators can be applied:
 Select a new state that has not yet been applied to the current state.

 Evaluate the new state.

 If the new state is the goal, return success.
 If the new state improves upon the current state, make it the current state and
continue.
 If it doesn’t improve, continue searching neighboring states.
4. Exit the function if no better state is found.

2. Steepest-Ascent Hill Climbing

Steepest-Ascent Hill Climbing is an enhanced version of simple hill climbing. Instead of moving
to the first neighboring node that improves the state, it evaluates all neighbors and moves to
the one offering the highest improvement (steepest ascent).

Algorithm for Steepest-Ascent Hill Climbing

1. Evaluate the initial state. If it is a goal state, return success.
2. Make the initial state the current state.
3. Repeat until the solution is found or the current state remains unchanged:
  Select a new state that hasn’t been applied to the current state.
 Initialize a ‘best state’ variable and evaluate all neighboring states.
 If a better state is found, update the best state.

 If the best state is the goal, return success.

 If the best state improves upon the current state, make it the new current state
and repeat.
4. Exit the function if no better state is found.
3. Stochastic Hill Climbing
Stochastic Hill Climbing introduces randomness into the search process. Instead of evaluating
all neighbors or selecting the first improvement, it selects a random neighboring node and
decides whether to move based on its improvement over the current state.
Algorithm for Stochastic Hill Climbing:
1. Evaluate the initial state. If it is a goal state, return success.

2. Make the initial state the current state.

3. Repeat until a solution is found or the current state does not change:
 Apply the successor function to the current state and generate all neighboring
states.
 Choose a random neighboring state based on a probability function.
 If the chosen state is better than the current state, make it the new current
state.
 If the selected neighbor is the goal state, return success.

4. Exit the function if no better state is found.

State-Space Diagram in Hill Climbing: Key Concepts and Regions
In the Hill Climbing algorithm, the state-space diagram is a visual representation of all possible
states the search algorithm can reach, plotted against the values of the objective function (the
function we aim to maximize).
In the state-space diagram:
 X-axis: Represents the state space, which includes all the possible states or
configurations that the algorithm can reach.
 Y-axis: Represents the values of the objective function corresponding to each state.
The optimal solution in the state-space diagram is represented by the state where the objective
function reaches its maximum value, also known as the global maximum.

Key Regions in the State-Space Diagram

1. Local Maximum: A local maximum is a state better than its neighbors but not the best
overall. While its objective function value is higher than nearby states, a global
maximum may still exist.

2. Global Maximum: The global maximum is the best state in the state-space diagram,
where the objective function achieves its highest value. This is the optimal solution the
algorithm seeks.

3. Plateau/Flat Local Maximum: A plateau is a flat region where neighboring states have
the same objective function value, making it difficult for the algorithm to decide on the
best direction to move.
4. Ridge: A ridge is a higher region with a slope, which can look like a peak. This may cause
the algorithm to stop prematurely, missing better solutions nearby.

5. Current State: The current state refers to the algorithm’s position in the state-space
diagram during its search for the optimal solution.

6. Shoulder: A shoulder is a plateau with an uphill edge, allowing the algorithm to move
toward better solutions if it continues searching beyond the plateau.

Simulated Annealing
Problem : Given a cost function f: R^n –> R, find an n-tuple that minimizes the value of f. Note
that minimizing the value of a function is algorithmically equivalent to maximization (since we
can redefine the cost function as 1-f).
Many of you with a background in calculus/analysis are likely familiar with simple optimization
for single variable functions. For instance, the function f(x) = x^2 + 2x can be optimized setting
the first derivative equal to zero, obtaining the solution x = -1 yielding the minimum value f(-1)
= -1. This technique suffices for simple functions with few variables. However, it is often the
case that researchers are interested in optimizing functions of several variables, in which case
the solution can only be obtained computationally.
One excellent example of a difficult optimization task is the chip floor planning problem.
Imagine you’re working at Intel and you’re tasked with designing the layout for an integrated
circuit. You have a set of modules of different shapes/sizes and a fixed area on which the
modules can be placed. There are a number of objectives you want to achieve: maximizing
ability for wires to connect components, minimize net area, minimize chip cost, etc. With these
in mind, you create a cost function, taking all, say, 1000 variable configurations and returning a
single real value representing the ‘cost’ of the input configuration. We call this the objective
function, since the goal is to minimize its value.
A naive algorithm would be a complete space search — we search all possible configurations
until we find the minimum. This may suffice for functions of few variables, but the problem we
have in mind would entail such a brute force algorithm to fun in O(n!).
Due to the computational intractability of problems like these, and other NP-hard problems,
many optimization heuristics have been developed in an attempt to yield a good, albeit
potentially suboptimal, value. In our case, we don’t necessarily need to find a strictly optimal
value — finding a near-optimal value would satisfy our goal. One widely used technique is
simulated annealing, by which we introduce a degree of stochasticity, potentially shifting from
a better solution to a worse one, in an attempt to escape local minima and converge to a value
closer to the global optimum.
Simulated annealing is based on metallurgical practices by which a material is heated to a high
temperature and cooled. At high temperatures, atoms may shift unpredictably, often
eliminating impurities as the material cools into a pure crystal. This is replicated via the
simulated annealing optimization algorithm, with energy state corresponding to current
solution.
In this algorithm, we define an initial temperature, often set as 1, and a minimum temperature,
on the order of 10^-4. The current temperature is multiplied by some fraction alpha and thus
decreased until it reaches the minimum temperature. For each distinct temperature value, we
run the core optimization routine a fixed number of times. The optimization routine consists of
finding a neighboring solution and accepting it with probability e^(f(c) – f(n)) where c is the
current solution and n is the neighboring solution. A neighboring solution is found by applying a
slight perturbation to the current solution. This randomness is useful to escape the common
pitfall of optimization heuristics — getting trapped in local minima. By potentially accepting a
less optimal solution than we currently have, and accepting it with probability inverse to the
increase in cost, the algorithm is more likely to converge near the global optimum. Designing a
neighbor function is quite tricky and must be done on a case by case basis, but below are some
ideas for finding neighbors in locational optimization problems.

 Move all points 0 or 1 units in a random direction

 Shift input elements randomly
 Swap random elements in input sequence
 Permute input sequence
 Partition input sequence into a random number of segments and permute segments

One caveat is that we need to provide an initial solution so the algorithm knows where to start.
This can be done in two ways: (1) using prior knowledge about the problem to input a good
starting point and (2) generating a random solution. Although generating a random solution is
worse and can occasionally inhibit the success of the algorithm, it is the only option for
problems where we know nothing about the landscape.
There are many other optimization techniques, although simulated annealing is a useful,
stochastic optimization heuristic for large, discrete search spaces in which optimality is
prioritized over time. Below, I’ve included a basic framework for locational-based simulated
annealing (perhaps the most applicable flavor of optimization for simulated annealing). Of
course, the cost function, candidate generation function, and neighbor function must be
defined based on the specific problem at hand, although the core optimization routine has
already been implemented.

Constraint Satisfaction Problems (CSP) in

Artificial Intelligence
Constraint Satisfaction Problems (CSP) play a crucial role in artificial intelligence
(AI) as they help solve various problems that require decision-making under certain
constraints. CSPs represent a class of problems where the goal is to find a solution
that satisfies a set of constraints. These problems are commonly encountered in fields
like scheduling, planning, resource allocation, and configuration.

What is a Constraint Satisfaction Problem (CSP)?

A Constraint Satisfaction Problem is a mathematical problem where the solution must meet a
number of constraints. In a CSP, the objective is to assign values to variables such that all the
constraints are satisfied. CSPs are used extensively in artificial intelligence for decision-making
problems where resources must be managed or arranged within strict guidelines.
Common applications of CSPs include:
 Scheduling: Assigning resources like employees or equipment while respecting time and
availability constraints.
 Planning: Organizing tasks with specific deadlines or sequences.
 Resource Allocation: Distributing resources efficiently without overuse.
Components of Constraint Satisfaction Problems

CSPs are composed of three key elements:

1. Variables: The things that need to be determined are variables. Variables in a CSP are
the objects that must have values assigned to them in order to satisfy a particular set of
constraints. Boolean, integer, and categorical variables are just a few examples of the
various types of variables, for instance, could stand in for the many puzzle cells that
need to be filled with numbers in a sudoku puzzle.

2. Domains: The range of potential values that a variable can have is represented by
domains. Depending on the issue, a domain may be finite or limitless. For instance, in
Sudoku, the set of numbers from 1 to 9 can serve as the domain of a variable
representing a problem cell.
3. Constraints: The guidelines that control how variables relate to one another are known
as constraints. Constraints in a CSP define the ranges of possible values for variables.
Unary constraints, binary constraints, and higher-order constraints are only a few
examples of the various sorts of constraints. For instance, in a sudoku problem, the
restrictions might be that each row, column, and 3×3 box can only have one instance of
each number from 1 to 9.
Types of Constraint Satisfaction Problems
CSPs can be classified into different types based on their constraints and problem
characteristics:
1. Binary CSPs: In these problems, each constraint involves only two variables. For
example, in a scheduling problem, the constraint could specify that task A must be
completed before task B.
 2. Non-Binary CSPs: These problems have constraints that involve more than two
variables. For instance, in a seating arrangement problem, a constraint could state that
three people cannot sit next to each other.
3. Hard and Soft Constraints: Hard constraints must be strictly satisfied, while soft
constraints can be violated, but at a certain cost. This distinction is often used in real-
world applications where not all constraints are equally important.
Representation of Constraint Satisfaction Problems (CSP)
In Constraint Satisfaction Problems (CSP), the solution process involves the interaction of
variables, domains, and constraints. Below is a structured representation of how CSP is
formulated:
1. Finite Set of Variables (V1,V2,…,Vn)(V1,V2,…,Vn):
The problem consists of a set of variables, each of which needs to be assigned a value
that satisfies the given constraints.
2. Non-Empty Domain for Each Variable (D1,D2,…,Dn)(D1,D2,…,Dn):
Each variable has a domain—a set of possible values that it can take. For example, in a
Sudoku puzzle, the domain could be the numbers 1 to 9 for each cell.
3. Finite Set of Constraints (C1,C2,…,Cm)(C1,C2,…,Cm):
Constraints restrict the possible values that variables can take. Each constraint defines a
rule or relationship between variables.
4. Constraint Representation:
Each constraint CiCi is represented as a pair <scope, relation>, where:
 Scope: The set of variables involved in the constraint.
 Relation: A list of valid combinations of variable values that satisfy the
constraint.
5. Example:
Let’s say you have two variables V1V1 and V2V2. A possible constraint could
be V1≠V2V1 =V2, which means the values assigned to these variables must not be
equal.
 Detailed Explanation:
o Scope: The variables V1V1 and V2V2.
o Relation: A list of valid value combinations where V1V1 is not equal
to V2V2.
Some relations might include explicit combinations, while others may rely on abstract relations
that are tested for validity dynamically.
CSP Algorithms: Solving Constraint Satisfaction Problems Efficiently
Constraint Satisfaction Problems (CSPs) rely on various algorithms to explore and optimize the
search space, ensuring that solutions meet the specified constraints. Here’s a breakdown of the
most commonly used CSP algorithms:
1. Backtracking Algorithm
The backtracking algorithm is a depth-first search method used to systematically explore
possible solutions in CSPs. It operates by assigning values to variables and backtracks if any
assignment violates a constraint.
How it works:

 The algorithm selects a variable and assigns it a value.

 It recursively assigns values to subsequent variables.
 If a conflict arises (i.e., a variable cannot be assigned a valid value), the algorithm
backtracks to the previous variable and tries a different value.
 The process continues until either a valid solution is found or all possibilities have been
exhausted.
This method is widely used due to its simplicity but can be inefficient for large problems with
many variables.
2. Forward-Checking Algorithm
The forward-checking algorithm is an enhancement of the backtracking algorithm that aims to
reduce the search space by applying local consistency checks.
How it works:

 For each unassigned variable, the algorithm keeps track of remaining valid values.
 Once a variable is assigned a value, local constraints are applied to neighboring
variables, eliminating inconsistent values from their domains.
 If a neighbor has no valid values left after forward-checking, the algorithm backtracks.
This method is more efficient than pure backtracking because it prevents some conflicts before
they happen, reducing unnecessary computations.
3. Constraint Propagation Algorithms
Constraint propagation algorithms further reduce the search space by enforcing local
consistency across all variables.
How it works:
 Constraints are propagated between related variables.
 Inconsistent values are eliminated from variable domains by leveraging information
gained from other variables.

 These algorithms refine the search space by making inferences, removing values that
would lead to conflicts.

Constraint propagation is commonly used in conjunction with other CSP algorithms, such
as backtracking, to increase efficiency by narrowing down the solution space early in the search
process.

Adversarial Search
Adversarial search is a search, where we examine the problem which arises when we try to
plan ahead of the world and other agents are planning against us.
o In previous topics, we have studied the search strategies which are only associated with
a single agent that aims to find the solution which often expressed in the form of a
sequence of actions.
o But, there might be some situations where more than one agent is searching for the
solution in the same search space, and this situation usually occurs in game playing.
o The environment with more than one agent is termed as multi-agent environment, in
which each agent is an opponent of other agent and playing against each other. Each
agent needs to consider the action of other agent and effect of that action on their
performance.
o So, Searches in which two or more players with conflicting goals are trying to explore
the same search space for the solution, are called adversarial searches, often known
as Games.
o Games are modeled as a Search problem and heuristic evaluation function, and these
are the two main factors which help to model and solve games in AI.
Types of Games in AI:

Deterministic Chance Moves

Perfect information Chess, Checkers, go, Othello Backgammon, monopoly

Bridge, poker, scrabble, nuclear

Imperfect information Battleships, blind, tic-tac-toe
war

o 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.
o 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.
o 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.
o 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.
Example: Backgammon, Monopoly, Poker, etc.
Note: In this topic, we will discuss deterministic games, fully observable environment, zero-sum,
and where each agent acts alternatively.
Zero-Sum Game
o Zero-sum games are adversarial search which involves pure competition.
o In Zero-sum game each agent's gain or loss of utility is exactly balanced by the losses or
gains of utility of another agent.
o One player of the game try to maximize one single value, while other player tries to
minimize it.
o Each move by one player in the game is called as ply.

o Chess and tic-tac-toe are examples of a Zero-sum game.

Zero-sum game: Embedded thinking
The Zero-sum game involved embedded thinking in which one agent or player is trying to figure
out:
o What to do.
 o How to decide the move
o Needs to think about his opponent as well
o The opponent also thinks what to do

Each of the players is trying to find out the response of his opponent to their actions. This
requires embedded thinking or backward reasoning to solve the game problems in AI.

Formalization of the problem:

A game can be defined as a type of search in AI which can be formalized of the following
elements:
o Initial state: It specifies how the game is set up at the start.
o Player(s): It specifies which player has moved in the state space.
o Action(s): It returns the set of legal moves in state space.

o Result(s, a): It is the transition model, which specifies the result of moves in the state
space.

o Terminal-Test(s): Terminal test is true if the game is over, else it is false at any case. The
state where the game ends is called terminal states.

o Utility(s, p): A utility function gives the final numeric value for a game that ends in
terminal states s for player p. It is also called payoff function. For Chess, the outcomes
are a win, loss, or draw and its payoff values are +1, 0, ½. And for tic-tac-toe, utility
values are +1, -1, and 0.
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:
o There are two players MAX and MIN.
o Players have an alternate turn and start with MAX.
o MAX maximizes the result of the game tree

o MIN minimizes the result.

Example Explanation:
o 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.
o Both players will compute each node, minimax, the minimax value which is the best
achievable utility against an optimal adversary.
o 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.
o 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.
o 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:
o It aims to find the optimal strategy for MAX to win the game.
o It follows the approach of Depth-first search.

o In the game tree, optimal leaf node could appear at any depth of the tree.
o Propagate the minimax values up to the tree until the terminal node discovered.
In a given game tree, the optimal strategy can be determined from the minimax value of each
node, which can be written as MINIMAX(n). MAX prefer to move to a state of maximum value
and MIN prefer to move to a state of minimum value then:

Mini-Max Algorithm in Artificial Intelligence

o 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.
o Mini-Max algorithm uses recursion to search through the game-tree.
o 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.
o In this algorithm two players play the game, one is called MAX and other is called MIN.
o Both the players fight it as the opponent player gets the minimum benefit while they get
the maximum benefit.
 o Both Players of the game are opponent of each other, where MAX will select the
maximized value and MIN will select the minimized value.
o The minimax algorithm performs a depth-first search algorithm for the exploration of
the complete game tree.
o The minimax algorithm proceeds all the way down to the terminal node of the tree,
then backtrack the tree as the recursion.
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

17. return minEva

Initial call:
Minimax(node, 3, true)
Working of Min-Max Algorithm:
 o The working of the minimax algorithm can be easily described using an example. Below
we have taken an example of game-tree which is representing the two-player game.
o In this example, there are two players one is called Maximizer and other is called
Minimizer.
o Maximizer will try to get the Maximum possible score, and Minimizer will try to get the
minimum possible score.
o This algorithm applies DFS, so in this game-tree, we have to go all the way through the
leaves to reach the terminal nodes.
o At the terminal node, the terminal values are given so we will compare those value and
backtrack the tree until the initial state occurs. Following are the main steps involved in
solving the two-player game tree:
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.
o For node D max(-1,- -∞) => max(-1,4)= 4
o For Node E max(2, -∞) => max(2, 6)= 6
o For Node F max(-3, -∞) => max(-3,-5) = -3

o For node G max(0, -∞) = max(0, 7) = 7

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.
o For node B= min(4,6) = 4
o 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.
o For node A max(4, -3)= 4
That was the complete workflow of the minimax two player game.
Properties of Mini-Max algorithm:
o Complete- Min-Max algorithm is Complete. It will definitely find a solution (if exist), in
the finite search tree.

o Optimal- Min-Max algorithm is optimal if both opponents are playing optimally.

o 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.

o 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.
Alpha-Beta Pruning
o Alpha-beta pruning is a modified version of the minimax algorithm. It is an optimization
technique for the minimax algorithm.
o As we have seen in the minimax search algorithm that the number of game states it has
to examine are exponential in depth of the tree. Since we cannot eliminate the
exponent, but we can cut it to half. Hence there is a technique by which without
checking each node of the game tree we can compute the correct minimax decision, and
this technique is called pruning. This involves two threshold parameter Alpha and beta
for future expansion, so it is called alpha-beta pruning. It is also called as Alpha-Beta
Algorithm.

o Alpha-beta pruning can be applied at any depth of a tree, and sometimes it not only
prune the tree leaves but also entire sub-tree.
o The two-parameter can be defined as:
o 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 -∞.
o 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 +∞.
o The Alpha-beta pruning to a standard minimax algorithm returns the same move as the
standard algorithm does, but it removes all the nodes which are not really affecting the
final decision but making algorithm slow. Hence by pruning these nodes, it makes the
algorithm fast.
Note: To better understand this topic, kindly study the minimax algorithm.
Condition for Alpha-beta pruning:
The main condition which required for alpha-beta pruning is:
1. α>=β

Key points about alpha-beta pruning:

o The Max player will only update the value of alpha.
o The Min player will only update the value of beta.
o While backtracking the tree, the node values will be passed to upper nodes instead of
values of alpha and beta.
o We will only pass the alpha, beta values to the child nodes.

Pseudo-code for Alpha-beta Pruning:

 1. function minimax(node, depth, alpha, beta, 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, alpha, beta, False)

9. maxEva= max(maxEva, eva)

10. alpha= max(alpha, maxEva)
11. if beta<=alpha
12. break
13. return maxEva

14.
15. else // for Minimizer player
16. minEva= +infinity
17. for each child of node do
18. eva= minimax(child, depth-1, alpha, beta, true)
19. minEva= min(minEva, eva)
20. beta= min(beta, eva)
21. if beta<=alpha
22. break
23. return minEva

Working of Alpha-Beta Pruning:

Let's take an example of two-player search tree to understand the 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.
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.
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.
Move Ordering in Alpha-Beta pruning:
The effectiveness of alpha-beta pruning is highly dependent on the order in which each node is
examined. Move order is an important aspect of alpha-beta pruning.
It can be of two types:

o Worst ordering: In some cases, alpha-beta pruning algorithm does not prune any of the
leaves of the tree, and works exactly as minimax algorithm. In this case, it also
consumes more time because of alpha-beta factors, such a move of pruning is called
worst ordering. In this case, the best move occurs on the right side of the tree. The time
complexity for such an order is O(bm).
o Ideal ordering: The ideal ordering for alpha-beta pruning occurs when lots of pruning
happens in the tree, and best moves occur at the left side of the tree. We apply DFS
hence it first search left of the tree and go deep twice as minimax algorithm in the same
amount of time. Complexity in ideal ordering is O(bm/2).
Rules to find good ordering:
Following are some rules to find good ordering in alpha-beta pruning:
 o Occur the best move from the shallowest node.
o Order the nodes in the tree such that the best nodes are checked first.
o Use domain knowledge while finding the best move. Ex: for Chess, try order: captures
first, then threats, then forward moves, backward moves.
o We can bookkeep the states, as there is a possibility that states may repeat.

What is Genetic Algorithm in Artificial Intelligence?

1. Define or Explain Genetic Algorithms and Biological Inspiration:
 Genetic Algorithms (GAs) are a class of optimization and search algorithms inspired by
the process of biological evolution. They simulate the process of natural selection to find
solutions to complex problems.
2. Basic Components of Genetic Algorithms:
 Population: A population represents a group of potential solutions to a problem. These
solutions are often referred to as "individuals" or "chromosomes."
 Selection: The selection process determines which individuals from the population will
be chosen as parents for reproduction based on their fitness (how well they solve the
problem).
 Crossover (Recombination): Crossover involves combining genetic information from
two parent individuals to create one or more offspring. This process mimics genetic
recombination in biology.
 Mutation: Mutation introduces small random changes or perturbations into the genetic
information of individuals. It adds an element of diversity to the population, allowing for
exploration of new solutions.
 Fitness Function: The fitness function quantifies how well an individual solves the
problem. It assigns a fitness score to each individual based on their performance, and
this score guides the selection process.
3. Illustrating Exploration of Solution Spaces:
 To understand how GAs explore solution spaces through evolution, consider an
example: the Traveling Salesman Problem (TSP). In TSP, the goal is to find the shortest
route that visits a set of cities and returns to the starting city.
 Initially, a population of possible routes (solutions) is generated randomly. Each route
represents a different way to visit the cities.
  During the evolution process:
 Selection favors routes with shorter distances, as determined by the fitness
function.
 Crossover combines genetic information from two parent routes to create new
routes.
 Mutation introduces slight variations in routes, potentially leading to improved
solutions.
 Over several generations, the population evolves. Routes with shorter distances become
more prevalent, and the algorithm converges toward an optimal or near-optimal
solution.
This evolutionary process of selection, crossover, and mutation continues until a termination
condition is met, such as a maximum number of generations or achieving a satisfactory
solution.
Through this dynamic exploration and optimization process, Genetic Algorithms effectively
navigate complex solution spaces, making them a powerful tool for solving a wide range of real-
world problems in AI, engineering, finance, and more.
Genetic Algorithm Workflow
Now, let's dive deeper into the step-by-step workflow of a Genetic Algorithm (GA). This process
mirrors the principles of biological evolution and problem-solving in AI.
Initialization:

 The process begins by creating an initial population of potential solutions to the

problem. These solutions, often represented as strings or vectors, are referred to as
individuals or chromosomes.
Selection:
 Selection is a critical step in GAs, where individuals are chosen for reproduction based
on their fitness. The more fit an individual is, the more likely it is to be selected as a
parent.
 Various selection methods can be used, such as roulette wheel selection, tournament
selection, or rank-based selection.
Crossover:
 Crossover, also known as recombination, involves taking genetic information from two
parent individuals and combining it to create one or more offspring.
  The way genetic information is combined varies depending on the problem and
encoding used. For example, in the case of binary strings, one-point or two-point
crossover can be applied.
Mutation:
 Mutation introduces small random changes into the genetic information of offspring.
This element of randomness helps maintain diversity within the population and allows
for exploration of new solutions.
 Mutation rates are typically low to prevent excessive disruption of good solutions.
Evaluation:
 The fitness function evaluates the performance of each individual in the population. It
quantifies how well each individual solves the problem.

 The fitness function guides the selection process by assigning higher fitness scores to
better solutions.

Termination:
 Termination criteria determine when the GA should stop running. Common termination
conditions include:
 Reaching a maximum number of generations.
 Achieving a satisfactory solution or fitness level.
 Running out of computation time or resources.
 Once the termination criteria are met, the GA concludes, and the best solution found is
returned.

By following this workflow, Genetic Algorithms iteratively evolve a population of potential

solutions, guiding them toward optimal or near-optimal solutions to complex problems. The
balance between exploration (mutation) and exploitation (crossover) ensures that GAs can
effectively tackle various real-world optimization and search challenges.
Genetic Algorithm in AI Workflow