UNIT I PROBLEM SOLVING

Introduction to AI - AI Applications - Problem solving agents – search algorithms – uninformed search

strategies – Heuristic search strategies – Local search and optimization problems – adversarial search –
constraint satisfaction problems (CSP)

1.1 Introduction to AI

Artificial Intelligence is composed of two words Artificial and Intelligence, where Artificial
defines "man-made," and intelligence defines "thinking power", hence AI means "a man-made thinking
power."

So, we can define AI as:

"It is a branch of computer science by which we can create intelligent machines which can behave like a
human, think like humans, and able to make decisions."

Artificial Intelligence exists when a machine can have human based skills such as learning, reasoning, and
solving problems.

With Artificial Intelligence you do not need to pre-program a machine to do some work, despite that you can
create a machine with programmed algorithms which can work with own intelligence.

Why Artificial Intelligence?

o​ Create software or devices which can solve real-world problems very easily and with accuracy such
as health issues, marketing, traffic issues, etc.
o​ Create your personal virtual Assistant, such as Cortana, Google Assistant, Siri, etc.
o​ Build Robots which can work in an environment where survival of humans can be at risk.
o​ AI opens a path for other new technologies, new devices, and new Opportunities.

Goals of Artificial Intelligence

Following are the main goals of Artificial Intelligence:

1.​ Replicate human intelligence

2.​ Solve Knowledge-intensive tasks
3.​ An intelligent connection of perception and action
4.​ Building a machine which can perform tasks that requires human intelligence such as:
o​ Proving a theorem
o​ Playing chess
o​ Plan some surgical operation
 o​ Driving a car in traffic
5.​ Creating some system which can exhibit intelligent behavior, learn new things by itself, demonstrate,
explain, and can advise to its user.

What Comprises to Artificial Intelligence?

To create the AI first we should know that how intelligence is composed, so the Intelligence is an intangible
part of our brain which is a combination of Reasoning, learning, problem-solving perception, language
understanding, etc.

To achieve the above factors for a machine or software Artificial Intelligence requires the following
discipline:

Advantages of Artificial Intelligence

Following are some main advantages of Artificial Intelligence:

o​High Accuracy with less errors: Prone to less errors and high accuracy as it takes decisions as per
pre-experience or information.
o​High-Speed: Very high-speed and fast-decision making, can beat a chess champion in the Chess game.
o​High reliability: Can perform the same action multiple times with high accuracy.
o​Useful for risky areas: Can be helpful in situations such as defusing a bomb, exploring the ocean floor,
where to employ a human can be risky.
o​Digital Assistant: Provide digital assistant to the users such as AI technology is currently used by various
E-commerce websites to show the products as per customer requirement.
o​Useful as a public utility: A self-driving car which can make our journey safer and hassle-free, facial
recognition for security purpose, Natural language processing to communicate with the human in
human-language, etc.

Disadvantages of Artificial Intelligence

o​ High Cost: The hardware and software requirement of AI is very costly as it requires lots of maintenance
to meet current world requirements.
o​ Can't think out of the box: Even we are making smarter machines with AI, but still they cannot work
out of the box, as the robot will only do that work for which they are trained, or programmed.
o​ No feelings and emotions: So it cannot make any kind of emotional attachment with human, and may
sometime be harmful for users if the proper care is not taken.
o​ Increase dependency on machines: With the increment of technology, people are getting more
dependent on devices and hence they are losing their mental capabilities.
o​ No Original Creativity: AI machines cannot beat this power of human intelligence and cannot be
creative and imaginative.

1.2 AI Applications

1. AI in Astronomy
o​ Useful to solve complex universe problems. Helpful for understanding the universe such as how it
works, origin, etc.

2. AI in Healthcare
o​ In the last, five to ten years, healthcare Industries are applying AI to make a better and faster
diagnosis than humans. AI can help doctors with diagnoses and can inform when patients are
worsening so that medical help can reach to the patient before hospitalization.

3. AI in Gaming
o​ The AI machines can play strategic games like chess, where the machine needs to think of a large
number of possible places.

4. AI in Finance
o​ The finance industry is implementing automation, chatbot, adaptive intelligence, algorithm trading,
and machine learning into financial processes.

5. AI in Data Security
o​ The security of data is crucial for every company and cyber-attacks are growing very rapidly in the
digital world. AI can be used to make your data more safe and secure. Some examples such as AEG
bot, AI2 Platform, are used to determine software bug and cyber-attacks in a better way.
6. AI in Social Media
o​ Social Media sites such as Facebook, Twitter, and Snapchat contain billions of user profiles, which
need to be stored and managed in a very efficient way. AI can organize and manage massive amounts
of data. AI can analyze lots of data to identify the latest trends, hashtag, and requirement of different
users.

7. AI in Travel & Transport

o​ Capable of doing various travel related works such as from making travel arrangement to suggesting
the hotels, flights, and best routes to the customers. Travel industries are using AI-powered chatbots
which can make human-like interaction with customers for better and fast response.

8. AI in Automotive Industry
o​ Some Automotive industries are using AI to provide virtual assistant to their user for better
performance. Such as Tesla has introduced TeslaBot, an intelligent virtual assistant.
o​ Various Industries are currently working for developing self-driven cars which can make your
journey more safe and secure.

9. AI in Robotics:
o​ With the help of AI, we can create intelligent robots which can perform tasks with their own
experiences without pre-programmed.
o​ Humanoid Robots are best examples for AI in robotics, recently the intelligent Humanoid robot
named as Erica and Sophia has been developed which can talk and behave like humans.

10. AI in Entertainment
o​ Some entertainment services are Netflix or Amazon. With the help of ML/AI algorithms, these
services show the recommendations for programs or shows.

11. AI in Agriculture
o​ Agriculture is an area which requires various resources, labor, money, and time for best result.
Agriculture is applying AI as agriculture robotics, solid and crop monitoring, predictive analysis.

12. AI in E-commerce
o​ AI is helping shoppers to discover associated products with recommended size, color, or even brand.

13. AI in education:
o​ AI can automate grading so that the tutor can have more time to teach. AI chatbot can communicate
with students as a teaching assistant.
o​ AI in the future can be work as a personal virtual tutor for students, which will be accessible easily at
any time and any place.
 o​

What is an Agent?

An agent can be anything that perceive its environment through sensors and act upon that environment
through actuators. An Agent runs in the cycle of perceiving, thinking, and acting.

An agent can be:

o​ Human-Agent: A human agent has eyes, ears, and other organs which work for sensors and hand,
legs, vocal tract work for actuators.
o​ Robotic Agent: A robotic agent can have cameras, infrared range finder, NLP for sensors and
various motors for actuators.
o​ Software Agent: Software agent can have keystrokes, file contents as sensory input and act on those
inputs and display output on the screen.

Hence the world around us is full of agents such as thermostat, cell phone, camera, and even we are also
agents.

Before moving forward, we should first know about sensors, effectors, and actuators.

Sensor: Sensor is a device which detects the change in the environment and sends the information to other
electronic devices. An agent observes its environment through sensors.
Actuators: Actuators are the component of machines that converts energy into motion. The actuators are
only responsible for moving and controlling a system. An actuator can be an electric motor, gears, rails, etc.

Effectors: Effectors are the devices which affect the environment. Effectors can be legs, wheels, arms,
fingers, wings, fins, and display screen. Effectors rely on actuators to move and operate effectively.

Intelligent Agents:

An intelligent agent is an autonomous entity which act upon an environment using sensors and actuators for
achieving goals. An intelligent agent may learn from the environment to achieve their goals. A thermostat is
an example of an intelligent agent.

Following are the main four rules for an AI agent:

o​ Rule 1: An AI agent must have the ability to perceive the environment.

o​ Rule 2: The observation must be used to make decisions.
o​ Rule 3: Decision should result in an action.
o​ Rule 4: The action taken by an AI agent must be a rational action.

Rational Agent:

A rational agent is an agent which has clear preference, models uncertainty, and acts in a way to maximize its
performance measure with all possible actions.

A rational agent is said to perform the right things. AI is about creating rational agents to use for game theory
and decision theory for various real-world scenarios.
 For an AI agent, the rational action is most important because in AI reinforcement learning algorithm, for
each best possible action, agent gets the positive reward and for each wrong action, an agent gets a negative
reward.

Structure of an AI Agent

The task of AI is to design an agent program which implements the agent function. The structure of an
intelligent agent is a combination of architecture and agent program. It can be viewed as:

1.​ Agent = Architecture + Agent program

Following are the main three terms involved in the structure of an AI agent:

Architecture: Architecture is machinery that an AI agent executes on.

Agent Function: Agent function is used to map a percept to an action.

1.​ F : P* → A

Agent program: Agent program is an implementation of agent function. An agent program executes on the
physical architecture to produce function f.

Example:

●​ If P={"obstacle detected","path clear"} then P* might include histories like:

o​ ["pathclear","obstacledetected"]
o​ ["pathclear","pathclear"].
●​ The function f maps these histories to actions A, such as:
o​ f(["pathclear","obstacledetected"])="turn left"
o​ f(["pathclear","pathclear"])="move forward".

PEAS Representation

PEAS is a type of model on which an AI agent works upon. When we define an AI agent or rational agent,
then we can group its properties under PEAS representation model. It is made up of four words:

o​ P: Performance measure
o​ E: Environment
o​ A: Actuators
o​ S: Sensors

Here performance measure is the objective for the success of an agent's behaviour.
Let's suppose take a self-driving car then PEAS representation will be:

Performance: Safety, time, legal drive, comfort

Environment: Roads, other vehicles, road signs, pedestrian

Actuators: Steering, accelerator, brake, signal, horn

Sensors: Camera, GPS, speedometer, odometer, accelerometer, sonar.

Agent Environment in AI

An environment is everything in the world which surrounds the agent, but it is not a part of an agent itself.
An environment can be described as a situation in which an agent is present.

The environment is where agent lives, operate and provide the agent with something to sense and act upon it.
An environment is mostly said to be non-feministic.

Features of Environment

As per Russell and Norvig, an environment can have various features from the point of view of an agent:

1.​ Fully observable vs Partially Observable

2.​ Static vs Dynamic
3.​ Discrete vs Continuous
4.​ Deterministic vs Stochastic
5.​ Single-agent vs Multi-agent
6.​ Episodic vs sequential
7.​ Known vs Unknown
8.​ Accessible vs Inaccessible

1. Fully observable vs Partially Observable:

o​ If an agent sensor can sense or access the complete state of an environment at each point of time then
it is a fully observable environment, else it is partially observable.
o​ A fully observable environment is easy as there is no need to maintain the internal state to keep track
history of the world.
o​ An agent with no sensors in all environments then such an environment is called as unobservable.

2. Deterministic vs Stochastic:
 o​ If an agent's current state and selected action can completely determine the next state of the
environment, then such environment is called a deterministic environment.
o​ A stochastic environment is random in nature and cannot be determined completely by an agent.
o​ In a deterministic, fully observable environment, agent does not need to worry about uncertainty.

3. Episodic vs Sequential:

o​ In an episodic environment, there is a series of one-shot actions, and only the current percept is
required for the action.
o​ However, in Sequential environment, an agent requires memory of past actions to determine the next
best actions.

4. Single-agent vs Multi-agent

o​ If only one agent is involved in an environment, and operating by itself then such an environment is
called single agent environment.
o​ However, if multiple agents are operating in an environment, then such an environment is called a
multi-agent environment.
o​ The agent design problems in the multi-agent environment are different from single agent
environment.

5. Static vs Dynamic:

o​ If the environment can change itself while an agent is deliberating then such environment is called a
dynamic environment else it is called a static environment.
o​ Static environments are easy to deal because an agent does not need to continue looking at the world
while deciding for an action.
o​ However for dynamic environment, agents need to keep looking at the world at each action.
o​ Taxi driving is an example of a dynamic environment whereas Crossword puzzles are an example of
a static environment.

6. Discrete vs Continuous:

o​ If in an environment there are a finite number of percept’s and actions that can be performed within
it, then such an environment is called a discrete environment else it is called continuous
environment.
o​ A chess game comes under discrete environment as there is a finite number of moves that can be
performed.
o​ A self-driving car is an example of a continuous environment.

7. Known vs Unknown
 o​ Known and unknown are not actually a feature of an environment, but it is an agent's state of
knowledge to perform an action.
o​ In a known environment, the results for all actions are known to the agent. While in unknown
environment, agent needs to learn how it works in order to perform an action.

8. Accessible vs Inaccessible
o​ If an agent can obtain complete and accurate information about the state's environment, then such an
environment is called an Accessible environment else it is called inaccessible.
o​ An empty room whose state can be defined by its temperature is an example of an accessible
environment.
o​ Information about an event on earth is an example of Inaccessible environment.

1.3 Problem solving agents

Types of AI Agents

Agents can be grouped into five classes based on their degree of perceived intelligence and capability. All
these agents can improve their performance and generate better action over the time. These are given below:
o​ Simple Reflex Agent
o​ Model-based reflex agent
o​ Goal-based agents
o​ Utility-based agent
o​ Learning agent

1. Simple Reflex agent:

o​ The Simple reflex agents are the simplest agents. These agents take decisions on the basis of the
current percept’s and ignore the rest of the percept history.
o​ These agents only succeed in the fully observable environment.
o​ The Simple reflex agent does not consider any part of percepts history during their decision and
action process.
o​ The Simple reflex agent works on Condition-action rule, which means it maps the current state to
action. Such as a Room Cleaner agent, it works only if there is dirt in the room.
o​ Problems for the simple reflex agent design approach:
o​ They have very limited intelligence
o​ They do not have knowledge of non-perceptual parts of the current state
o​ Mostly too big to generate and to store.
o​ Not adaptive to changes in the environment.
2. Model-based reflex agent

o​ A model-based reflex agent is one that uses internal memory and a percept history to create a model
of the environment in which it's operating and make decisions based on that model.
o​ The term percept means something that has been observed or detected by the agent.
o​ The Model-based agent can work in a partially observable environment, and track the situation.
o​ A model-based agent has two important factors:
o​ Model: It is knowledge about "how things happen in the world," so it is called a
Model-based agent.
o​ Internal State: It is a representation of the current state based on percept history.
o​ These agents have the model, "which is knowledge of the world" and based on the model they
perform actions.
o​ Self-driving cars are a great example of a model-based reflex agent. The car is equipped with sensors
that detect obstacles, such as car brake lights in front of them or pedestrians walking on the sidewalk.
As it drives, these sensors feed percepts into the car's memory and internal model of its environment.
o​ Updating the agent state requires information about:

a.​ How the world evolves

a.​ How the agent's action affects the world.
3. Goal-based agents

o​ The knowledge of the current state environment is not always sufficient to decide for an agent to
what to do.
o​ The agent needs to know its goal which describes desirable situations.
o​ Goal-based agents expand the capabilities of the model-based agent by having the "goal"
information.
o​ They choose an action, so that they can achieve the goal.
o​ These agents may have to consider a long sequence of possible actions before deciding whether the
goal is achieved or not. Such considerations of different scenario are called searching and planning,
which makes an agent proactive.
o​ A simple example would be the shopping list; our goal is to pick up everything on that list. This
makes it easier to decide if you need to choose between milk and orange juice because you can only
afford one. As milk is a goal on our shopping list and the orange juice is not we chose the milk.
o​ For example, a group of friends plan to go on a road trip. They have learned from past experiences
that cars are more comfortable and suitable for longer distances. They search for the shortest route;
this search is carried out keeping the destination in mind.
o​ Here, the destination is the goal. Search and planning is carried out while keeping the end goal in
mind. Past experiences were used to take the initial step towards solving the problem.
4. Utility-based agents

o​ These agents are similar to the goal-based agent but provide an extra component of utility
measurement which makes them different by providing a measure of success at a given state.
o​ Utility-based agent act based not only goals but also the best way to achieve the goal.
o​ The Utility-based agent is useful when there are multiple possible alternatives, and an agent has to
choose in order to perform the best action.
o​ The utility function maps each state to a real number to check how efficiently each action achieves
the goals.
o​ A self-driving car, for instance, has many goals to consider when heading toward its destination:
choosing the quickest route, ensuring the safety of its passengers, avoiding road closures or traffic
jams, among others.
5. Learning Agents

o​ A learning agent in AI is the type of agent which can learn from its past experiences, or it has
learning capabilities.
o​ It starts to act with basic knowledge and then able to act and adapt automatically through learning.
o​ A learning agent has mainly four conceptual components, which are:

a.​ Learning element: It is responsible for making improvements by learning from

environment
a.​ Critic: Learning element takes feedback from critic which describes that how well the agent
is doing with respect to a fixed performance standard.
b.​ Performance element: It is responsible for selecting external action
c.​ Problem generator: This component is responsible for suggesting actions that will lead to
new and informative experiences.
o​ Hence, learning agents are able to learn, analyse performance, and look for new ways to improve the
performance.
1.4 search algorithms

Problem-solving agents:

In Artificial Intelligence, Search techniques are universal problem-solving methods.

Rational agents or Problem-solving agents in AI mostly use these search strategies or algorithms to solve a
specific problem and provide the best result.
Problem-solving agents are the goal-based agents and use atomic representation.

Search Algorithm Terminologies:

o​ Search: Searching is a step by step procedure to solve a search-problem in a given search space. A

search problem can have three main factors:

a.​ Search Space: Search space represents a set of possible solutions, which a system may have.

a.​ Start State: It is a state from where agent begins the search.

b.​ Goal test: It is a function which observe the current state and returns whether the goal state

is achieved or not.

o​ Search tree: A tree representation of search problem is called Search tree. The root of the search tree

is the root node which is corresponding to the initial state.

 o​ Actions: It gives the description of all the available actions to the agent.

o​ Transition model: A description of what each action do, can be represented as a transition model.

o​ Path Cost: It is a function which assigns a numeric cost to each path.

o​ Solution: It is an action sequence which leads from the start node to the goal node.

o​ Optimal Solution: If a solution has the lowest cost among all solutions.

Properties of Search Algorithms:

Following are the four essential properties of search algorithms to compare the efficiency of these
algorithms:

Completeness: A search algorithm is said to be complete if it guarantees to return a solution if at least any
solution exists for any random input.

Optimality: If a solution found for an algorithm is guaranteed to be the best solution (lowest path cost)
among all other solutions, then such a solution for is said to be an optimal solution.

Time Complexity: Time complexity is a measure of time for an algorithm to complete its task.

Space Complexity: It is the maximum storage space required at any point during the search, as the
complexity of the problem.

Types of search algorithms

Based on the search problems we can classify the search algorithms into uninformed (Blind search)
search and informed search (Heuristic search) algorithms.
Uninformed/Blind Search:

The uninformed search does not contain any domain knowledge such as closeness, the location of the goal. It
operates in a brute-force way as it only includes information about how to traverse the tree and how to
identify leaf and goal nodes.

Uninformed search applies a way in which search tree is searched without any information about the search
space like initial state operators and test for the goal, so it is also called blind search. It examines each node
of the tree until it achieves the goal node.

It can be divided into five main types:

o​ Breadth-first search
o​ Uniform cost search
o​ Depth-first search
o​ Iterative deepening depth-first search
o​ Bidirectional Search
Informed Search

Informed search algorithms use domain knowledge. In an informed search, problem information is available
which can guide the search. Informed search strategies can find a solution more efficiently than an
uninformed search strategy. Informed search is also called a Heuristic search.

A heuristic is a way which might not always be guaranteed for best solutions but guaranteed to find a good
solution in reasonable time.

Informed search can solve much complex problem which could not be solved in another way.

An example of informed search algorithms is a traveling salesman problem.

1.​ Greedy Search

2.​ A* Search

1.5 uninformed search strategies

Uninformed search is a class of general-purpose search algorithms which operates in brute force-way.
Uninformed search algorithms do not have additional information about state or search space other
than how to traverse the tree, so it is also called blind search.

Following are the various types of uninformed search algorithms:

1.​ Breadth-first Search

2.​ Depth-first Search
3.​ Depth-limited Search
4.​ Iterative deepening depth-first search
5.​ Uniform cost search
6.​ Bidirectional Search

1. Breadth-first Search:

o​ Breadth-first search is the most common search strategy for traversing a tree or graph. This
algorithm searches breadthwise in a tree or graph, so it is called breadth-first search.
o​ BFS algorithm starts searching from the root node of the tree and expands all successor node at the
current level before moving to nodes of next level.
o​ The breadth-first search algorithm is an example of a general-graph search algorithm.
o​ Breadth-first search implemented using FIFO queue data structure.

Advantages:
 o​ BFS will provide a solution if any solution exists.
o​ If there are more than one solutions for a given problem, then BFS will provide the minimal solution
which requires the least number of steps.

Disadvantages:

o​ It requires lots of memory since each level of the tree must be saved into memory to expand the next
level.
o​ BFS needs lots of time if the solution is far away from the root node.

Example:

In the below tree structure, we have shown the traversing of the tree using BFS algorithm from the root node
S to goal node K. BFS search algorithm traverse in layers, so it will follow the path which is shown by the
dotted arrow, and the traversed path will be:

1.​ S---> A--->B---->C--->D---->G--->H--->E---->F---->I---->K

Time Complexity: Time Complexity of BFS algorithm can be obtained by the number of nodes traversed in
BFS until the shallowest Node. Where the d= depth of shallowest solution and b is a node at every state.

T (b) = 1+b2+b3+.......+ bd= O (bd)

Space Complexity: Space complexity of BFS algorithm is given by the Memory size of frontier which is
O(bd).

Completeness: BFS is complete, which means if the shallowest goal node is at some finite depth, then BFS
will find a solution.

Optimality: BFS is optimal if path cost is a non-decreasing function of the depth of the node.

2. Depth-first Search

o​ Depth-first search is a recursive algorithm for traversing a tree or graph data structure.
o​ It is called the depth-first search because it starts from the root node and follows each path to its
greatest depth node before moving to the next path.
o​ DFS uses a stack data structure for its implementation.
o​ The process of the DFS algorithm is similar to the BFS algorithm.

Note: Backtracking is an algorithm technique for finding all possible solutions using recursion.

Advantage:

o​ DFS requires very less memory as it only needs to store a stack of the nodes on the path from root
node to the current node.
o​ It takes less time to reach to the goal node than BFS algorithm (if it traverses in the right path).

Disadvantage:

o​ There is the possibility that many states keep re-occurring, and there is no guarantee of finding the
solution.
o​ DFS algorithm goes for deep down searching and sometime it may go to the infinite loop.

Example:

In the below search tree, we have shown the flow of depth-first search, and it will follow the order as:

Root node--->Left node ----> right node.

It will start searching from root node S, and traverse A, then B, then D and E, after traversing E, it will
backtrack the tree as E has no other successor and still goal node is not found. After backtracking it will
traverse node C and then G, and here it will terminate as it found goal node.

Completeness: DFS search algorithm is complete within finite state space as it will expand every node
within a limited search tree.

Time Complexity: Time complexity of DFS will be equivalent to the node traversed by the algorithm. It is
given by:

T(n)= 1+ n2+ n3 +.........+ nm=O(nm)

Where, m= maximum depth of any node and this can be much larger than d (Shallowest solution
depth)

Space Complexity: DFS algorithm needs to store only single path from the root node, hence space
complexity of DFS is equivalent to the size of the fringe set, which is O(bm).

Optimal: DFS search algorithm is non-optimal, as it may generate a large number of steps or high cost to
reach to the goal node.

3. Depth-Limited Search Algorithm:

A depth-limited search algorithm is similar to depth-first search with a predetermined limit. Depth-limited
search can solve the drawback of the infinite path in the Depth-first search. In this algorithm, the node at the
depth limit will treat as it has no successor nodes further.

Depth-limited search can be terminated with two Conditions of failure:

o​ Standard failure value: It indicates that problem does not have any solution.
o​ Cutoff failure value: It defines no solution for the problem within a given depth limit.

Advantages:

Depth-limited search is Memory efficient.

Disadvantages:

o​ Depth-limited search also has a disadvantage of incompleteness.

o​ It may not be optimal if the problem has more than one solution.

Example:

Completeness: DLS search algorithm is complete if the solution is above the depth-limit.

Time Complexity: Time complexity of DLS algorithm is O(bℓ).

Space Complexity: Space complexity of DLS algorithm is O(b×ℓ).

Optimal: Depth-limited search can be viewed as a special case of DFS, and it is also not optimal even if ℓ>d.

4. Uniform-cost Search Algorithm:

Uniform-cost search is a searching algorithm used for traversing a weighted tree or graph. This algorithm
comes into play when a different cost is available for each edge. The primary goal of the uniform-cost search
is to find a path to the goal node which has the lowest cumulative cost. Uniform-cost search expands nodes
according to their path costs form the root node. It can be used to solve any graph/tree where the optimal cost
is in demand. A uniform-cost search algorithm is implemented by the priority queue. It gives maximum
priority to the lowest cumulative cost. Uniform cost search is equivalent to BFS algorithm if the path cost of
all edges is the same.

Advantages:

o​ Uniform cost search is optimal because at every state the path with the least cost is chosen.

Disadvantages:

o​ It does not care about the number of steps involve in searching and only concerned about path cost.
Due to which this algorithm may be stuck in an infinite loop.
Example:

Completeness:

Uniform-cost search is complete, such as if there is a solution, UCS will find it.

Time Complexity:

Let C* is Cost of the optimal solution, and ε is each step to get closer to the goal node. Then the number of
steps is = C*/ε+1. Here we have taken +1, as we start from state 0 and end to C*/ε.

Hence, the worst-case time complexity of Uniform-cost search is O(b1 + [C*/ε])/.

Space Complexity:

The same logic is for space complexity so, the worst-case space complexity of Uniform-cost search is

O(b1 + [C*/ε]).

Optimal:

Uniform-cost search is always optimal as it only selects a path with the lowest path cost.

5. Iterative deepening depth-first Search:

The iterative deepening algorithm is a combination of DFS and BFS algorithms. This search algorithm finds
out the best depth limit and does it by gradually increasing the limit until a goal is found.

This algorithm performs depth-first search up to a certain "depth limit", and it keeps increasing the depth
limit after each iteration until the goal node is found.

This Search algorithm combines the benefits of Breadth-first search's fast search and depth-first search's
memory efficiency.

The iterative search algorithm is useful uninformed search when search space is large, and depth of goal node
is unknown.

Advantages:

o​ It combines the benefits of BFS and DFS search algorithm in terms of fast search and memory
efficiency.

Disadvantages:

o​ The main drawback of IDDFS is that it repeats all the work of the previous phase.

Example:

Following tree structure is showing the iterative deepening depth-first search. IDDFS algorithm performs
various iterations until it does not find the goal node.

The iteration performed by the algorithm is given as:

1'st Iteration-----> A​
2'nd Iteration----> A, B, C​
3'rd Iteration------>A, B, D, E, C, F, G​
4'th Iteration------>A, B, D, H, I, E, C, F, K, G​
In the fourth iteration, the algorithm will find the goal node.

Completeness:

This algorithm is complete if the branching factor is finite.

Time Complexity:

Let's suppose b is the branching factor and depth is d then the worst-case time complexity is O(bd).

Space Complexity:

The space complexity of IDDFS will be O(bd).

Optimal:

IDDFS algorithm is optimal if path cost is a non- decreasing function of the depth of the node.
6. Bidirectional Search Algorithm:

Bidirectional search algorithm runs two simultaneous searches, one form initial state called as
forward-search and other from goal node called as backward-search, to find the goal node. Bidirectional
search replaces one single search graph with two small subgraphs in which one starts the search from an
initial vertex and other starts from goal vertex. The search stops when these two graphs intersect each other.

Bidirectional search can use search techniques such as BFS, DFS, DLS, etc.

Advantages:

o​ Bidirectional search is fast.

o​ Bidirectional search requires less memory

Disadvantages:

o​ Implementation of the bidirectional search tree is difficult.

o​ In bidirectional search, one should know the goal state in advance.

Example:

In the below search tree, bidirectional search algorithm is applied. This algorithm divides one graph/tree into
two sub-graphs. It starts traversing from node 1 in the forward direction and starts from goal node 16 in the
backward direction.

The algorithm terminates at node 9 where two searches meet.

 Completeness: Bidirectional Search is complete if we use BFS in both searches.

Time Complexity: Time complexity of bidirectional search using BFS is O(bd).

Space Complexity: Space complexity of bidirectional search is O(bd).

Optimal: Bidirectional search is Optimal.

1.6 Heuristic search strategies

Informed Search Algorithms

Informed search algorithm contains an array of knowledge such as how far we are from the goal, path cost,
how to reach to goal node, etc.

This knowledge help agents to explore less to the search space and find more efficiently the goal node.

The informed search algorithm is more useful for large search space.

Informed search algorithm uses the idea of heuristic, so it is also called Heuristic search.

Heuristics function: Heuristic is a function which is used in Informed Search, and it finds the most
promising path.

It takes the current state of the agent as its input and produces the estimation of how close agent is from the
goal.

The heuristic method, however, might not always give the best solution, but it guaranteed to find a good
solution in reasonable time.

Heuristic function estimates how close a state is to the goal. It is represented by h(n), and it calculates the
cost of an optimal path between the pair of states. The value of the heuristic function is always positive.

Admissibility of the heuristic function is given as:

1.​ h(n) <= h*(n)

Here h(n) is heuristic cost, and h*(n) is the estimated cost. Hence heuristic cost should be less than or
equal to the estimated cost.
Pure Heuristic Search:

Pure heuristic search is the simplest form of heuristic search algorithms. It expands nodes based on their
heuristic value h(n).

It maintains two lists, OPEN and CLOSED list. In the CLOSED list, it places those nodes which have
already expanded and in the OPEN list, it places nodes which have yet not been expanded.

On each iteration, each node n with the lowest heuristic value is expanded and generates all its successors
and n is placed to the closed list. The algorithm continues unit a goal state is found.

In the informed search we will discuss two main algorithms which are given below:

o​ Best First Search Algorithm(Greedy search)

o​ A* Search Algorithm

1.) Best-first Search Algorithm (Greedy Search):

Greedy best-first search algorithm always selects the path which appears best at that moment. It is the
combination of depth-first search and breadth-first search algorithms. It uses the heuristic function and
search.

Best-first search allows us to take the advantages of both algorithms. With the help of best-first search, at
each step, we can choose the most promising node. In the best first search algorithm, we expand the node
which is closest to the goal node and the closest cost is estimated by heuristic function, i.e.

f(n)= g(n).

Where, h(n)= estimated cost from node n to the goal.

The greedy best first algorithm is implemented by the priority queue.

Best first search algorithm:

o​ Step 1: Place the starting node into the OPEN list.
o​ Step 2: If the OPEN list is empty, Stop and return failure.
o​ Step 3: Remove the node n, from the OPEN list which has the lowest value of h(n), and places it in
the CLOSED list.
o​ Step 4: Expand the node n, and generate the successors of node n.
o​ Step 5: Check each successor of node n, and find whether any node is a goal node or not. If any
successor node is goal node, then return success and terminate the search, else proceed to Step 6.
 o​ Step 6: For each successor node, algorithm checks for evaluation function f(n), and then check if the
node has been in either OPEN or CLOSED list. If the node has not been in both list, then add it to
the OPEN list.
o​ Step 7: Return to Step 2.

Advantages:
o​ Best first search can switch between BFS and DFS by gaining the advantages of both the algorithms.
o​ This algorithm is more efficient than BFS and DFS algorithms.

Disadvantages:
o​ It can behave as an unguided depth-first search in the worst case scenario.
o​ It can get stuck in a loop as DFS.
o​ This algorithm is not optimal.

Example:
Consider the below search problem, and we will traverse it using greedy best-first search. At each iteration,
each node is expanded using evaluation function f(n)=h(n) , which is given in the below table.

In this search example, we are using two lists which are OPEN and CLOSED Lists. Following are the
iteration for traversing the above example.
Expand the nodes of S and put in the CLOSED list

Initialization: Open [A, B], Closed [S]

Iteration 1: Open [A], Closed [S, B]

Iteration 2: Open [E, F, A], Closed [S, B]​

: Open [E, A], Closed [S, B, F]

Iteration 3: Open [I, G, E, A], Closed [S, B, F]​

: Open [I, E, A], Closed [S, B, F, G]

Hence the final solution path will be: S----> B----->F----> G

Time Complexity: The worst case time complexity of Greedy best first search is O(bm).

Space Complexity: The worst case space complexity of Greedy best first search is O(bm). Where, m is the
maximum depth of the search space.

Complete: Greedy best-first search is also incomplete, even if the given state space is finite.

Optimal: Greedy best first search algorithm is not optimal.

2.) A* Search Algorithm:

A* search is the most commonly known form of best-first search. It uses heuristic function h(n), and cost to
reach the node n from the start state g(n). It has combined features of UCS and greedy best-first search, by
which it solve the problem efficiently. A* search algorithm finds the shortest path through the search space
using the heuristic function. This search algorithm expands less search tree and provides optimal result faster.
A* algorithm is similar to UCS except that it uses g(n)+h(n) instead of g(n).

In A* search algorithm, we use search heuristic as well as the cost to reach the node. Hence we can combine
both costs as following, and this sum is called as a fitness number.

At each point in the search space, only those node is expanded which have the lowest value of f(n), and the
algorithm terminates when the goal node is found.

Algorithm of A* search:

Step1: Place the starting node in the OPEN list.

Step 2: Check if the OPEN list is empty or not, if the list is empty then return failure and stops.

Step 3: Select the node from the OPEN list which has the smallest value of evaluation function (g+h), if
node n is goal node then return success and stop, otherwise

Step 4: Expand node n and generate all of its successors, and put n into the closed list. For each successor n',
check whether n' is already in the OPEN or CLOSED list, if not then compute evaluation function for n' and
place into Open list.

Step 5: Else if node n' is already in OPEN and CLOSED, then it should be attached to the back pointer
which reflects the lowest g(n') value.

Step 6: Return to Step 2.

Advantages:
o​ A* search algorithm is the best algorithm than other search algorithms.
o​ A* search algorithm is optimal and complete.
o​ This algorithm can solve very complex problems.

Disadvantages:
o​ It does not always produce the shortest path as it mostly based on heuristics and approximation.
o​ A* search algorithm has some complexity issues.
o​ The main drawback of A* is memory requirement as it keeps all generated nodes in the memory, so
it is not practical for various large-scale problems.

Example:
In this example, we will traverse the given graph using the A* algorithm. The heuristic value of all states is
given in the below table so we will calculate the f(n) of each state using the formula f(n)= g(n) + h(n), where
g(n) is the cost to reach any node from start state.
Here we will use OPEN and CLOSED list.

Solution:
Initialization: {(S, 5)}

Iteration1: {(S--> A, 4), (S-->G, 10)}

Iteration2: {(S--> A-->C, 4), (S--> A-->B, 7), (S-->G, 10)}

Iteration3: {(S--> A-->C--->G, 6), (S--> A-->C--->D, 11), (S--> A-->B, 7), (S-->G, 10)}

Iteration 4 will give the final result, as S--->A--->C--->G it provides the optimal path with cost 6.

Points to remember:

o​ A* algorithm returns the path which occurred first, and it does not search for all remaining paths.
o​ The efficiency of A* algorithm depends on the quality of heuristic.
o​ A* algorithm expands all nodes which satisfy the condition f(n)<="" li="">

Complete: A* algorithm is complete as long as:

o​ Branching factor is finite.

o​ Cost at every action is fixed.

Optimal: A* search algorithm is optimal if it follows below two conditions:

 o​ Admissible: the first condition requires for optimality is that h(n) should be an admissible heuristic
for A* tree search. An admissible heuristic is optimistic in nature.
o​ Consistency: Second required condition is consistency for only A* graph-search.

If the heuristic function is admissible, then A* tree search will always find the least cost path.

Time Complexity: The time complexity of A* search algorithm depends on heuristic function, and the
number of nodes expanded is exponential to the depth of solution d. So the time complexity is O(b^d), where
b is the branching factor.

Space Complexity: The space complexity of A* search algorithm is O(b^d)

Real-Time Example: A Search Algorithm in GPS Navigation Systems*

Scenario: Finding the Shortest Route in Google Maps
When you use Google Maps for navigation, it needs to find the shortest and fastest route from your
current location to your destination. Instead of checking all possible routes (which is
computationally expensive), Google Maps applies the A Search Algorithm*, which uses a heuristic
function to guide the search efficiently.
How the Heuristic Works in A Algorithm*

1.​ G(n) - Cost So Far: The actual distance from the starting point to the current location.
2.​ H(n) - Heuristic Estimate: An estimated distance from the current location to the
destination (e.g., straight-line or Manhattan distance).
3.​ F(n) = G(n) + H(n): The total estimated cost to reach the destination.

The heuristic function H(n) helps prioritize routes that are more likely to lead to the shortest path,
rather than exploring all possible paths.
Why is it Efficient?

●​ Instead of checking all roads, the heuristic focuses on roads that are more likely to lead to
the shortest path.
●​ It speeds up navigation systems by reducing unnecessary computations.
●​ It provides real-time updates by dynamically recalculating the best route based on live
traffic conditions.

Other Real-Time Applications of Heuristics in AI

1.​ Chess AI (e.g., AlphaZero) – Uses heuristics to evaluate board positions and prioritize the
most promising moves.
2.​ Spam Filters – Heuristic rules help classify emails as spam based on keywords, metadata,
and behavior analysis.
3.​ Medical Diagnosis (IBM Watson) – Uses heuristic algorithms to narrow down possible
diseases based on symptoms and medical history.

Heuristics allow AI to make fast, practical decisions where brute-force methods are infeasible.

1.7 Local search and optimization problems

Hill Climbing Algorithm in Artificial Intelligence
o​ Hill climbing algorithm is a local search algorithm which continuously moves in the direction of
increasing elevation/value to find the peak of the mountain or best solution to the problem. It
terminates when it reaches a peak value where no neighbour has a higher value.
o​ Hill climbing algorithm is a technique which is used for optimizing the mathematical problems. One
of the widely discussed examples of Hill climbing algorithm is Traveling-salesman Problem in
which we need to minimize the distance travelled by the salesman.
o​ It is also called greedy local search as it only looks to its good immediate neighbour state and not
beyond that.
o​ A node of hill climbing algorithm has two components which are state and value.
o​ Hill Climbing is mostly used when a good heuristic is available.
o​ In this algorithm, we don't need to maintain and handle the search tree or graph as it only keeps a
single current state.

Features of Hill Climbing:

Following are some main features of Hill Climbing Algorithm:

o​ Generate and Test variant: Hill Climbing is the variant of Generate and Test method. The Generate
and Test method produce feedback which helps to decide which direction to move in the search
space.
o​ Greedy approach: Hill-climbing algorithm search moves in the direction which optimizes the cost.
o​ No backtracking: It does not backtrack the search space, as it does not remember the previous
states.

State-space Diagram for Hill Climbing:

The state-space landscape is a graphical representation of the hill-climbing algorithm which is showing a
graph between various states of algorithm and Objective function/Cost.

On Y-axis we have taken the function which can be an objective function or cost function, and state-space on
the x-axis. If the function on Y-axis is cost then, the goal of search is to find the global minimum and local
minimum. If the function of Y-axis is Objective function, then the goal of the search is to find the global
maximum and local maximum.
Different regions in the state space landscape:

Local Maximum: Local maximum is a state which is better than its neighbour states, but there is also
another state which is higher than it.

Global Maximum: Global maximum is the best possible state of state space landscape. It has the highest
value of objective function.

Current state: It is a state in a landscape diagram where an agent is currently present.

Flat local maximum: It is a flat space in the landscape where all the neighbor states of current states have
the same value.

Shoulder: It is a plateau region which has an uphill edge.

Types of Hill Climbing Algorithm:

o​ Simple hill Climbing:

o​ Steepest-Ascent hill-climbing:
o​ Stochastic hill Climbing:

1. Simple Hill Climbing:

Simple hill climbing is the simplest way to implement a hill climbing algorithm. It only evaluates the
neighbor node state at a time and selects the first one which optimizes current cost and set it as a
current state. It only checks it's one successor state, and if it finds better than the current state, then move
else be in the same state. This algorithm has the following features:
 o​ Less time consuming
o​ Less optimal solution and the solution is not guaranteed

Algorithm for Simple Hill Climbing:

o​ Step 1: Evaluate the initial state, if it is goal state then return success and Stop.
o​ Step 2: Loop Until a solution is found or there is no new operator left to apply.
o​ Step 3: Select and apply an operator to the current state.
o​ Step 4: Check new state:

a.​ If it is goal state, then return success and quit.

a.​ Else if it is better than the current state then assign new state as a current state.
b.​ Else if not better than the current state, then return to step2.
o​ Step 5: Exit.

2. Steepest-Ascent hill climbing:

The steepest-Ascent algorithm is a variation of simple hill climbing algorithm. This algorithm examines all
the neighboring nodes of the current state and selects one neighbor node which is closest to the goal state.
This algorithm consumes more time as it searches for multiple neighbors

Algorithm for Steepest-Ascent hill climbing:

o​ Step 1: Evaluate the initial state, if it is goal state then return success and stop, else make current
state as initial state.
o​ Step 2: Loop until a solution is found or the current state does not change.

a.​ Let SUCC be a state such that any successor of the current state will be better than it.
a.​ For each operator that applies to the current state:

a.​ Apply the new operator and generate a new state.

a.​ Evaluate the new state.
b.​ If it is goal state, then return it and quit, else compare it to the SUCC.
c.​ If it is better than SUCC, then set new state as SUCC.
d.​ If the SUCC is better than the current state, then set current state to SUCC.
o​ Step 5: Exit.

3. Stochastic hill climbing:

Stochastic hill climbing does not examine for all its neighbor before moving. Rather, this search algorithm
selects one neighbor node at random and decides whether to choose it as a current state or examine another
state.
Problems in Hill Climbing Algorithm:

1. Local Maximum: A local maximum is a peak state in the landscape which is better than each of its
neighboring states, but there is another state also present which is higher than the local maximum.

Solution: Backtracking technique can be a solution of the local maximum in state space landscape. Create a
list of the promising path so that the algorithm can backtrack the search space and explore other paths as
well.

2. Plateau: A plateau is the flat area of the search space in which all the neighbor states of the current state
contains the same value, because of this algorithm does not find any best direction to move. A hill-climbing
search might be lost in the plateau area.

Solution: The solution for the plateau is to take big steps or very little steps while searching, to solve the
problem. Randomly select a state which is far away from the current state so it is possible that the algorithm
could find non-plateau region.
3. Ridges: A ridge is a special form of the local maximum. It has an area which is higher than its surrounding
areas, but itself has a slope, and cannot be reached in a single move.

Solution: With the use of bidirectional search, or by moving in different directions, we can improve this
problem.

Simulated Annealing:

A hill-climbing algorithm which never makes a move towards a lower value guaranteed to be incomplete
because it can get stuck on a local maximum. And if algorithm applies a random walk, by moving a
successor, then it may complete but not efficient. Simulated Annealing is an algorithm which yields both
efficiency and completeness.

In mechanical term Annealing is a process of hardening a metal or glass to a high temperature then cooling
gradually, so this allows the metal to reach a low-energy crystalline state. The same process is used in
simulated annealing in which the algorithm picks a random move, instead of picking the best move. If the
random move improves the state, then it follows the same path. Otherwise, the algorithm follows the path
which has a probability of less than 1 or it moves downhill and chooses another path.

1.8 adversarial search

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

Imperfect information Battleships, blind, tic-tac-toe Bridge, poker, scrabble, nuclear

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
stochasticgames.​
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.​ if MaximizingPlayer then // for Maximizer Player
5.​ maxEva= -infinity
6.​ for each child of node do
7.​ eva= minimax(child, depth-1, false)
8.​ maxEva= max(maxEva,eva) //gives Maximum of the values
9.​ return maxEva
10.​
11.​ else // for Minimizer player
12.​ minEva= +infinity
13.​ for each child of node do
14.​ eva= minimax(child, depth-1, true)
15.​ minEva= min(minEva, eva) //gives minimum of the values
16.​ 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)= 4p

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:

a.​ 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 -∞.
a.​ 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).
1.9 constraint satisfaction problems (CSP)

Constraint Satisfaction Problems in Artificial Intelligence

A problem is solved when each variable has a value that satisfies all the constraints on the variable.
A problem described this way is called a constraint satisfaction problem, or CSP.

The main idea is to eliminate large portions of the search space all at once by identifying
variable/value combinations that violate the constraints.

Finding a solution that meets a set of constraints is the goal of constraint satisfaction problems (CSPs), a type

of AI issue.

Finding values for a group of variables that fulfil a set of restrictions or rules is the aim of constraint

satisfaction problems.

For tasks including resource allocation, planning, scheduling, and decision-making, CSPs are frequently

employed in AI.

There are mainly three basic components in the constraint satisfaction problem:

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.

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.

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.

Constraint Satisfaction Problems (CSP) representation:

●​ The finite set of variables V1, V2, V3 ……………..Vn.

●​ Non-empty domain for every single variable D1, D2, D3 …………..Dn.

●​ The finite set of constraints C1, C2 …….…, Cm.

●​ where each constraint Ci restricts the possible values for variables,

●​ e.g., V1 ≠ V2

●​ Each constraint Ci is a pair <scope, relation>

●​ Example: <(V1, V2), V1 not equal to V2>

●​ Scope = set of variables that participate in constraint.

●​ Relation = list of valid variable value combinations.

●​ There might be a clear list of permitted combinations. Perhaps a relation that is

abstract and that allows for membership testing and listing.

●​ To solve a CSP, we need to define a state space and the notion of a solution. Each state in a
CSP is defined by an assignment of values to some or all of the variables, {Xi = vi, Xj = vj ,
. . .}.
●​ An assignment that does not violate any constraints is called a consistent or legal
assignment.
●​ A complete assignment is one in which every variable is assigned, and a solution to a CSP is
a consistent, complete assignment.
●​ A partial assignment is one that assigns values to only some of the variables.

Example problem: Map colouring

We are given the task of colouring each region either red, green, or blue in such a way that no
neighbouring regions have the same colour. To formulate this as a CSP, we define the variables to
be the regions

X = {WA,NT,Q,NSW,V,SA,T} .

The domain of each variable is the set Di = {red , green , blue }. The constraints require
neighbouring regions to have distinct colours. Since there are nine places where regions border,
there are nine constraints:

C = {SA ̸= WA,SA ̸= NT,SA ̸= Q,SA ̸= NSW,SA ̸= V, WA̸=NT,NT ̸=Q,Q̸=NSW,NSW ̸=V}.

Here we are using abbreviations; SA ̸= WA is a shortcut for ⟨(SA, WA), SA ̸= WA⟩, where SA ̸=
WA can be fully enumerated in turn as

{(red , green ), (red , blue ), (green , red ), (green , blue ), (blue , red ), (blue , green )} . There are
many possible solutions to this problem, such as

{WA=red, NT =green, Q=red, NSW =green, V =red, SA=blue, T =red }.

It can be helpful to visualize a CSP as a constraint graph, as shown in Figure 6.1(b). The nodes of
the graph correspond to variables of the problem, and a link connects any two variables that
participate in a constraint.

Why formulate a problem as a CSP?

One reason is that the CSPs yield a natural representation for a wide variety of problems; if you
already have a CSP-solving system, it is often easier to solve a problem using it than to design a
custom solution using another search technique.

In addition, CSP solvers can be faster than state-space searchers because the CSP solver can quickly
eliminate large swatches of the search space. For example, once we have chosen {SA = blue} in the
Australia problem, we can conclude that none of the five neighbouring variables can take on the
value blue.

5
Without taking advantage of constraint propagation, a search procedure would have to consider 3 =

243 assignments for the five neighbouring variables; with constraint propagation we never have to
5
consider blue as a value, so we have only 2 = 32 assignments to look at, a reduction of 87%.
In regular state-space search we can only ask: is this specific state a goal? No? What about this one?
With CSPs, once we find out that a partial assignment is not a solution, we can immediately discard
further refinements of the partial assignment.

Furthermore, we can see why the assignment is not a solution—we see which variables violate a
constraint—so we can focus attention on the variables that matter.

As a result, many problems that are intractable for regular state-space search can be solved quickly
when formulated as a CSP.

Example problem: Job-shop scheduling

Factories have the problem of scheduling a day’s worth of jobs, subject to various constraints. In
practice, many of these problems are solved with CSP techniques.

Consider the problem of scheduling the assembly of a car. The whole job is composed of tasks, and
we can model each task as a variable, where the value of each variable is the time that the task
starts, expressed as an integer number of minutes.

Constraints can assert that one task must occur before another—for example, a wheel must be
installed before the hubcap is put on—and that only so many tasks can go on at once. Constraints
can also specify that a task takes a certain amount of time to complete.
We consider a small part of the car assembly, consisting of 15 tasks: install axles (front and back),
affix all four wheels (right and left, front and back), tighten nuts for each wheel, affix hubcaps, and
inspect the final assembly. We can represent the tasks with 15 variables:

X = {AxleF,AxleB,WheelRF,WheelLF,WheelRB,WheelLB,NutsRF, Nuts LF , Nuts RB , Nuts LB ,

Cap RF , Cap LF , Cap RB , Cap LB , Inspect } .

The value of each variable is the time that the task starts. Next we represent precedence constraints
between individual tasks. Whenever a task T1 must occur before task T2 , and task T1 takes
duration d1 to complete, we add an arithmetic constraint of the form

T1 + d1 ≤ T2 .

In our example, the axles have to be in place before the wheels are put on, and it takes 10 minutes to
install an axle, so we write

AxleF + 10 ≤ WheelRF ; AxleF + 10 ≤ WheelLF ; AxleB + 10 ≤ WheelRB; AxleB + 10 ≤ WheelLB .

Next we say that, for each wheel, we must affix the wheel (which takes 1 minute), then tighten the
nuts (2 minutes), and finally attach the hubcap (1 minute, but not represented yet):

WheelRF +1≤NutsRF; WheelLF +1≤NutsLF; WheelRB + 1 ≤ NutsRB; WheelLB + 1 ≤ NutsLB;

NutsRF +2≤CapRF; NutsLF +2≤CapLF;

NutsRB + 2 ≤ CapRB; NutsLB + 2 ≤ CapLB .

Suppose we have four workers to install wheels, but they have to share one tool that helps put the
axle in place.

We need a disjunctive constraint to say that Axle and Axle must not overlap in time; either one
comes first or the other does:

(AxleF +10≤AxleB) or (AxleB +10≤AxleF).

This looks like a more complicated constraint, combining arithmetic and logic. But it still reduces to
a set of pairs of values that AxleF and AxleF can take on.

We also need to assert that the inspection comes last and takes 3 minutes. For every variable except
Inspect we add a constraint of the form X + dX ≤ Inspect . Finally, suppose there is a requirement to
get the whole assembly done in 30 minutes. We can achieve that by limiting the domain of all
variables:

Di = {1,2,3,...,27} .

This particular problem is trivial to solve, but CSPs have been applied to job-shop scheduling
problems like this with thousands of variables.

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.

​
Applications of CSPs in AI
CSPs are widely used across different fields and industries due to their flexibility and capability of
solving real-world problems efficiently. Some notable applications include:
1.​ Scheduling: CSPs are extensively used in scheduling problems, such as employee shifts, flight
schedules, and course timetabling. The goal is to allocate tasks or resources while respecting
constraints like time, availability, and precedence.
2.​ Puzzle Solving: Many logic puzzles, such as Sudoku, crosswords, and the N-Queens problem,
can be formulated as CSPs, where the constraints ensure the puzzle rules are followed.
3.​ Configuration Problems: In product design or software configuration, CSPs help in choosing the
right components or settings based on given requirements and restrictions. For example, in
configuring a computer system, constraints could specify that certain components are
incompatible with others.
4.​ Robotics and Planning: CSPs are used in pathfinding and task planning for autonomous agents
and robots. For instance, a robot might need to navigate an environment while avoiding
obstacles and minimizing energy consumption, which can be modeled as a CSP.
5.​ Natural Language Processing (NLP): In NLP, CSPs can be applied to tasks like sentence
parsing, where the goal is to find a valid syntactic structure based on grammar rules
(constraints).

Challenges in Solving CSPs

While CSPs offer a powerful framework for solving many AI problems, they also pose several
challenges:
1.​ Scalability: As the number of variables and constraints increases, the size of the solution space
grows exponentially, making it challenging to find solutions in a reasonable time.
2.​ Dynamic CSPs: In real-world problems, constraints and variables may change over time,
making it necessary to adapt the solution dynamically. These are known as Dynamic CSPs, and
solving them efficiently requires specialized techniques.
3.​ Inconsistent or Over-constrained Problems: Sometimes, it is impossible to satisfy all constraints,
leading to inconsistent problems. Techniques like constraint relaxation or optimization
approaches can help in finding acceptable solutions in such cases.