Artificial Intelligence

UNIT – 02 - Problems Solving, Search and Control Strategies

01. Solving Problems by Searching :-

 Problem-solving by searching is a fundamental technique in artificial intelligence that
involves searching through a space of possible solutions to find an optimal solution
to a problem.
 The search space is defined by a set of possible states or configurations, and the goal
is to find a path from an initial state to a goal state that satisfies some criteria or
objective.
 The search algorithm works by exploring the search space systematically, typically
using a tree or graph data structure that represents the possible states and
transitions between them.
 The search algorithm starts at the initial state and generates a sequence of candidate
states or configurations, based on a set of rules or heuristics that guide the search.
 At each step, the search algorithm evaluates each candidate state or configuration
and selects the most promising one to continue the search.
  The search algorithm continues until it reaches a goal state that satisfies the problem
criteria or objective, or until it exhausts the search space without finding a solution.
 Different search algorithms can be used depending on the specific problem and
search space, such as breadth-first search, depth-first search, iterative deepening
search, A* search, or beam search.
 The choice of search algorithm depends on factors such as the size and complexity of
the search space, the availability of domain-specific knowledge, and the desired
balance between completeness, optimality, and efficiency.
 Problem-solving by searching can be applied to a wide range of problems in artificial
intelligence, such as planning, scheduling, optimization, and game playing.
Overall, problem-solving by searching is a powerful technique in artificial intelligence that
enables intelligent systems to find optimal solutions to complex problems by systematically
exploring a search space of possible solutions. The choice of search algorithm and heuristics
depends on the specific problem and application, and the efficiency and effectiveness of the
search algorithm can have a significant impact on the performance and capabilities of the
intelligent system.

02. Study and analysis of various searching algorithms :-

1. Breadth-first search: This algorithm explores all the nodes at a given depth level
before moving on to the next level. It guarantees that the shortest path to a goal
state will be found, but it can be memory-intensive for large search spaces.
2. Depth-first search: This algorithm explores a path as far as possible before
backtracking to explore other paths. It can be more memory-efficient than breadth-
first search, but it may not find the shortest path to a goal state.
3. Uniform-cost search: This algorithm expands the node with the lowest path cost,
where the path cost is the sum of the costs of all the actions taken to reach that
node. It guarantees that the optimal solution will be found if all the actions have
non-negative costs.
4. Iterative deepening search: This algorithm combines the advantages of breadth-first
and depth-first search by performing a series of depth-limited searches with
increasing depth limits until a solution is found. It can be memory-efficient and
optimal for a wide range of search spaces.
5. A* search: This algorithm combines the advantages of uniform-cost search and
heuristics by expanding the node with the lowest estimated cost, where the
estimated cost is the sum of the path cost and a heuristic function that estimates the
remaining cost to reach a goal state. It can find optimal solutions efficiently for many
search spaces.
 6. Greedy best-first search: This algorithm expands the node that is closest to the goal
state according to a heuristic function. It can be efficient but may not find optimal
solutions.
7. Beam search: This algorithm is a variant of best-first search that expands the k-best
nodes at each step, where k is a user-defined parameter. It can be more efficient
than best-first search for large search spaces.
Overall, the choice of search algorithm depends on the characteristics of the search space,
the availability of domain-specific knowledge, and the desired balance between
completeness, optimality, and efficiency. Different search algorithms can be combined or
modified to suit specific applications and problems in artificial intelligence.

03. Implementation of Depth-first search :-

Depth First Search: Depth-first search (DFS) is an algorithm for traversing or searching
tree or graph data structures. The algorithm starts at the root node (selecting some
arbitrary node as the root node in the case of a graph) and explores as far as possible along
each branch before backtracking. It uses last in- first-out strategy and hence it is
implemented using a stack.

Implementation
import java.util.*;

public class DFS {

// DFS algorithm that returns a list of actions from start to goal state
public List<String> search(Problem problem) {
Set<State> visited = new HashSet<>();
Stack<State> stack = new Stack<>();
stack.push(problem.getInitialState());
while (!stack.empty()) {
State state = stack.pop();
visited.add(state);
if (problem.isGoalState(state)) {
return getPath(state);
}
for (Action action : problem.getActions(state)) {
State successor = problem.getResult(state, action);
if (!visited.contains(successor)) {
stack.push(successor);
}
}
}
return null;
}

// helper method that returns a list of actions from start to the given state
private List<String> getPath(State state) {
List<String> path = new ArrayList<>();
while (state.getParent() != null) {
path.add(state.getAction());
state = state.getParent();
}
Collections.reverse(path);
return path;
}
}
In this implementation, we have a search method that takes a Problem object as input and
returns a list of actions from the start state to the goal state. The algorithm maintains a set
of visited states and a stack of unexplored states. It starts by pushing the initial state onto
the stack and entering a loop that continues until either the stack is empty or a goal state is
found. In each iteration of the loop, the algorithm pops a state from the stack, adds it to the
set of visited states, and checks if it is a goal state. If it is, it calls a helper method getPath to
retrieve the list of actions that lead to this state. Otherwise, it generates all successor states
of the current state using the getActions and getResult methods of the Problem object, and
pushes those that have not been visited onto the stack. If no goal state is found, the
algorithm returns null.
The getPath method is a helper method that takes a goal state as input and returns a list of
actions that lead to this state from the start state. It does this by following the parent field
of the input state backwards until the start state is reached, and adding the action that was
taken to reach each state to a list. The list is then reversed to obtain the correct order of
actions.
Note that this implementation assumes that the Problem class has the following methods:
getInitialState: returns the start state of the problem
isGoalState: takes a state as input and returns true if it is a goal state
getActions: takes a state as input and returns a list of possible actions from that state
getResult: takes a state and an action as input and returns the resulting state after taking
that action.

04. Problem-Solving Agents :-

A problem-solving agent is an intelligent agent that is capable of finding solutions to a given
problem. It operates in an environment and receives percepts from the environment and
produces actions that affect the environment. The main goal of a problem-solving agent is
to achieve its performance measure by finding a sequence of actions that leads to a desired
state or goal.
Problem-solving agents can be implemented using various AI techniques such as search
algorithms, rule-based systems, genetic algorithms, and machine learning. Here are some
key components of a problem-solving agent:
 Problem formulation: This involves defining the problem in terms of the initial state,
actions, successor function, and goal test. The initial state represents the starting
state of the problem, the actions represent the possible actions that can be taken in
the environment, the successor function maps each action to the resulting state, and
the goal test determines whether a given state is a goal state.
  Search algorithms: Search algorithms are used to explore the space of possible
actions and find a sequence of actions that leads to a goal state. There are various
search algorithms such as depth-first search, breadth-first search, uniform-cost
search, and A* search. These algorithms differ in terms of the order in which they
explore the search space and the criteria used to select the next node to explore.
 Heuristics: Heuristics are used to guide the search towards the goal state by
providing an estimate of how close a given state is to the goal state. Heuristics can
be admissible or inadmissible, depending on whether they underestimate or
overestimate the distance to the goal state. A* search is an example of a search
algorithm that uses heuristics to guide the search.
 Rule-based systems: Rule-based systems are used to represent knowledge about the
problem domain in the form of rules. These rules are used to infer new knowledge
and make decisions based on the current state of the problem. Rule-based systems
are often used in conjunction with search algorithms to find solutions to complex
problems.
 Genetic algorithms: Genetic algorithms are used to solve optimization problems by
mimicking the process of natural selection. They work by evolving a population of
candidate solutions through successive generations of mutation and selection.
Genetic algorithms can be used to find optimal or near-optimal solutions to a wide
range of problems.
 Machine learning: Machine learning techniques such as supervised learning,
unsupervised learning, and reinforcement learning can be used to learn a solution to
a problem from examples or experience. For example, a reinforcement learning
agent can learn to take actions that maximize its long-term reward in the
environment.
Overall, problem-solving agents are a key application of AI that can be used to solve a wide
range of problems in various domains such as robotics, healthcare, finance, and
transportation.

04. Searching for Solutions :-

Searching for solutions is a fundamental problem in AI and can be addressed using various
search algorithms. A search algorithm explores the space of possible actions and finds a
sequence of actions that leads to a goal state. Here are some key concepts and algorithms
related to searching for solutions:
 State space: A state space is a set of all possible states that can be reached from the
initial state by taking a sequence of actions. The state space can be represented as a
graph, where the nodes represent the states and the edges represent the actions
that can be taken to reach the next state.
  Search tree: A search tree is a tree-like structure that represents the process of
searching for a solution in the state space. The root node represents the initial state,
and the child nodes represent the states that can be reached from the parent node
by taking a single action. The search tree is constructed by applying a search
algorithm to the state space.
 Search algorithm: A search algorithm is a method used to explore the state space
and find a sequence of actions that leads to a goal state. Some common search
algorithms include depth-first search, breadth-first search, uniform-cost search, and
A* search. These algorithms differ in terms of the order in which they explore the
search space and the criteria used to select the next node to explore.
 Heuristics: Heuristics are used to guide the search algorithm towards the goal state
by providing an estimate of how close a given state is to the goal state. A heuristic
function evaluates the quality of a state based on its distance to the goal state.
Heuristics can be admissible or inadmissible, depending on whether they
underestimate or overestimate the distance to the goal state.
 Optimality: A search algorithm is said to be optimal if it always finds the optimal
solution, i.e., the solution with the minimum cost. Uniform-cost search and A*
search are examples of optimal search algorithms.
Overall, searching for solutions is a key problem in AI and has numerous applications in
various domains such as robotics, gaming, and planning. The choice of search algorithm and
heuristic function depends on the nature of the problem and the available resources.

05. Uninformed Search Strategies :- Uninformed search strategies are search

algorithms that do not use any domain-specific knowledge or heuristics to guide the search.
They explore the search space in a systematic way and rely on the structure of the search
tree to find a solution. Here are some common uninformed search strategies:
 Breadth-First Search (BFS): BFS explores the search tree level by level, starting from
the root node. It expands all the nodes at the current level before moving on to the
next level. This ensures that the shortest path to the goal node is found first, but it
may require a lot of memory to store the expanded nodes.
 Depth-First Search (DFS): DFS explores the search tree depth-first, starting from the
root node and moving down the tree until a leaf node is reached. It then backtracks
to the most recent node with unexplored children and continues the search. DFS is
memory-efficient but may not find the shortest path to the goal node.
 Uniform-Cost Search (UCS): UCS expands the node with the lowest path cost, where
the path cost is the sum of the costs of all the actions taken to reach the node. It is
optimal and complete, but may be slow in cases where the cost of actions varies
widely.
  Depth-Limited Search (DLS): DLS is a modified version of DFS that limits the depth of
the search tree. It may not find a solution if the depth limit is too small, but it can
avoid infinite loops that can occur in DFS.
 Iterative Deepening Depth-First Search (IDDFS): IDDFS is a combination of DLS and
DFS that gradually increases the depth limit until a solution is found. It is complete
and optimal for finite depth trees.
Uninformed search strategies are useful when there is little or no knowledge about the
problem domain. However, they may not be efficient for complex problems where the
search space is large and the goal state is far away. In such cases, heuristic-based search
algorithms such as A* search may be more appropriate.

06. Breadth-first search :- Breadth-First Search (BFS) is a search algorithm that explores
the search space level by level. It starts from the root node and visits all the nodes at the
current level before moving on to the next level. BFS is often used to find the shortest path
between two nodes in a graph.
The algorithm works as follows:
1. Start at the root node and mark it as visited.
2. Add the root node to the queue.
3. While the queue is not empty:
 Dequeue the first node from the queue.
 Visit all the unvisited neighbors of the dequeued node.
 Mark each visited neighbor as visited and add it to the queue.
4. If the goal node is found during the search, stop the algorithm and return the path to
the goal node.
5. If the queue becomes empty and the goal node has not been found, the algorithm
fails.
BFS guarantees that it will find the shortest path between the starting node and the goal
node if such a path exists. However, it may not be the most efficient algorithm in terms of
time or space complexity.

Let's consider the following graph:

A
/|\
B C D
/\ |
E F G
\ |
H I
Here are the steps of the BFS algorithm in our example:
1. Start at node A and mark it as visited.
2. Add node A to the queue: queue = [A].
3. Dequeue the first node from the queue (node A) and visit its unvisited neighbors B,
C, and D.
4. Mark nodes B, C, and D as visited and add them to the queue: queue = [B, C, D].
5. Dequeue node B from the queue and visit its unvisited neighbors E and F.
6. Mark nodes E and F as visited and add them to the queue: queue = [C, D, E, F].
7. Dequeue node C from the queue and visit its unvisited neighbor G.
8. Mark node G as visited and add it to the queue: queue = [D, E, F, G].
9. Dequeue node D from the queue and visit its unvisited neighbor I. Goal node found!
10. Return the path from node A to node I: A -> D -> I.
Therefore, the shortest path from node A to node I is A -> D -> I, which has a length of 2.

07. Uniform-cost search :-

Uniform-Cost Search (UCS) is a search algorithm that is similar to Breadth-First Search, but it
takes into account the cost of each path. UCS aims to find the lowest-cost path from the
starting node to the goal node.
The algorithm works as follows:
1. Start at the root node and mark it as visited.
2. Add the root node to the priority queue with a cost of 0.
3. While the priority queue is not empty:
 Dequeue the node with the lowest cost from the priority queue.
 If the dequeued node is the goal node, stop the algorithm and return the
path to the goal node.
 Otherwise, visit all the unvisited neighbors of the dequeued node.
 For each neighbor, calculate the cost of the path to that neighbor and add it
to the total cost of the path from the starting node to the neighbor.
 If the neighbor has not been visited, mark it as visited and add it to the
priority queue with its cost as the priority.
 If the neighbor has already been visited and the new cost to reach it is lower
than the previous cost, update the neighbor's cost in the priority queue.
 4. If the goal node is not found and the priority queue becomes empty, the algorithm
fails.
UCS guarantees that it will find the lowest-cost path between the starting node and the goal
node if such a path exists. However, it may not be the most efficient algorithm in terms of
time or space complexity, especially if there are many paths with the same cost. To improve
the efficiency of UCS, a heuristic function can be used to guide the search towards the goal
node. This variant of UCS is called A* search.

08. Depth-first search :-

Depth-First Search (DFS) is a search algorithm that explores the search space by traversing
as far as possible along each branch before backtracking. It starts from the root node and
goes as deep as possible in the search tree before backtracking.
The algorithm works as follows:
1. Start at the root node and mark it as visited.
2. If the goal node is found during the search, stop the algorithm and return the path to
the goal node.
3. Otherwise, visit an unvisited neighbor of the current node.
4. If all neighbors have been visited or there are no neighbors, backtrack to the
previous node and continue the search from there.
5. Repeat steps 2-4 until the goal node is found or all nodes have been visited.
DFS does not guarantee that it will find the shortest path between the starting node and the
goal node, and it may get stuck in an infinite loop if the search tree has cycles. However, it is
often faster and uses less memory than other search algorithms, especially if the solution is
deep in the search tree. DFS is often used as a building block for more complex search
algorithms, such as depth-limited search and iterative deepening search.

09. Depth-limited search :- Depth-Limited Search (DLS) is a variant of Depth-First

Search that limits the maximum depth of the search tree. It starts at the root node and
explores the search space by traversing as far as possible along each branch until the
maximum depth is reached.
The algorithm works as follows:
1. Start at the root node and mark it as visited.
2. If the goal node is found during the search, stop the algorithm and return the path to
the goal node.
 3. If the maximum depth has been reached, backtrack to the previous node and
continue the search from there.
4. Otherwise, visit an unvisited neighbor of the current node.
5. If all neighbors have been visited or there are no neighbors, backtrack to the
previous node and continue the search from there.
6. Repeat steps 2-5 until the goal node is found or the maximum depth has been
reached.
DLS is useful when the search space is large and DFS would take too long to find a solution.
By limiting the depth of the search, DLS reduces the time and space complexity of the
algorithm. However, DLS may miss a solution if the maximum depth is set too low, and it
may take a long time to find a solution if the maximum depth is set too high. DLS can be
combined with iterative deepening search to improve the performance of the algorithm.

10. Iterative deepening depth-first search :-

Iterative Deepening Depth-First Search (IDDFS) is a combination of DFS and DLS that
overcomes the limitations of both algorithms. It starts with a maximum depth limit of 1 and
gradually increases the depth limit until the goal node is found.
The algorithm works as follows:
1. Start at the root node and set the maximum depth limit to 1.
2. Perform DFS with the depth limit of 1.
3. If the goal node is found during the search, stop the algorithm and return the path to
the goal node.
4. If the goal node is not found and the maximum depth limit has not been reached,
increase the maximum depth limit by 1 and repeat step 2.
5. If the goal node is not found and the maximum depth limit has been reached, stop
the algorithm and return failure.
IDDFS has the advantages of both DFS and DLS. Like DFS, it searches the tree in a depth-first
manner, which can be more efficient than breadth-first search for large and deep trees. Like
DLS, it limits the depth of the search, which can prevent the algorithm from getting stuck in
an infinite loop and reduce the space complexity of the algorithm.

Additionally, IDDFS ensures that the shortest path to the goal node is found, even if the goal
node is deep in the search tree. However, IDDFS may repeat some of the search work
between iterations, which can slow down the algorithm for large trees.
11. Bi-directional search Informed (Heuristic) Search Strategies :-
Bi-directional search and Informed (Heuristic) Search Strategies are two different search
techniques in AI:
1. Bi-Directional Search:
 Bi-directional search is a search technique that starts the search from both the start
and the goal nodes and works towards the middle.
 It can be applied to both uninformed and informed search algorithms such as
Breadth-First Search, Depth-First Search, and A* Search.
 Bi-directional search is useful when the search space is large and the shortest path
between the start and goal nodes is not known.
 It can reduce the search space and improve the efficiency of the search algorithm.
2. Informed (Heuristic) Search Strategies:
 Informed search strategies use heuristic functions to guide the search towards the
goal node.
 They are more efficient than uninformed search strategies such as Breadth-First
Search and Depth-First Search because they use additional information to guide the
search.
 The most commonly used informed search algorithm is A* Search, which uses both
the actual cost and the estimated cost to the goal node to evaluate the nodes in the
search space.
 The heuristic function used in A* Search should be admissible, meaning it never
overestimates the actual cost to the goal node, and consistent, meaning the
estimated cost of reaching a neighboring node plus the cost of getting from that
node to the goal node is never greater than the estimated cost of getting directly to
the goal node.
In summary, bi-directional search and informed search strategies are two different
techniques in AI that can be used to improve the efficiency and effectiveness of the search
algorithms.
Bi-directional search starts the search from both the start and goal nodes, while informed
search strategies use heuristic functions to guide the search towards the goal node. A*
Search is a commonly used informed search algorithm that uses both actual cost and
estimated cost to evaluate the nodes in the search space.

12. Greedy best-first search A* search :- Greedy Best-First Search and A* Search are
two informed search algorithms in AI:
 1. Greedy Best-First Search:
 Greedy Best-First Search is an informed search algorithm that uses heuristic
functions to guide the search towards the goal node.
 It evaluates the nodes in the search space based on the estimated cost to the goal
node, without considering the actual cost of reaching the node.
 Greedy Best-First Search is an example of a greedy algorithm, which means it
chooses the node that appears to be the best choice at each step without
considering the consequences of that choice.
 Greedy Best-First Search can be efficient for small search spaces, but it may not find
the optimal path to the goal node.
2. A* Search:
 A* Search is an informed search algorithm that uses both the actual cost and the
estimated cost to the goal node to evaluate the nodes in the search space.
 It combines the benefits of both uniform-cost search and greedy best-first search
algorithms, making it more efficient than both algorithms.
 A* Search uses a heuristic function that estimates the cost of reaching the goal node
from each node in the search space, and it adds this estimated cost to the actual cost
of getting to each node to evaluate its priority.
 The heuristic function used in A* Search should be admissible, meaning it never
overestimates the actual cost to the goal node, and consistent, meaning the
estimated cost of reaching a neighboring node plus the cost of getting from that
node to the goal node is never greater than the estimated cost of getting directly to
the goal node.
 A* Search is guaranteed to find the optimal path to the goal node if the heuristic
function used is admissible.
In summary, Greedy Best-First Search and A* Search are two informed search algorithms
that use heuristic functions to guide the search towards the goal node. Greedy Best-First
Search evaluates the nodes based on the estimated cost to the goal node, while A* Search
combines the actual cost and the estimated cost to evaluate the nodes. A* Search is more
efficient than Greedy Best-First Search and guaranteed to find the optimal path if the
heuristic function used is admissible.

13. Minimizing the total estimated solution cost :-

Minimizing the total estimated solution cost in AI can be achieved through the following
techniques:
 1. Heuristic Functions: A good heuristic function can estimate the distance or cost to
the goal node more accurately, which can lead to more efficient and optimal search
algorithms.
2. Admissible Heuristics: An admissible heuristic never overestimates the cost to the
goal node, which guarantees that the search algorithm will find the optimal solution
if one exists.
3. Consistent Heuristics: A consistent heuristic satisfies the triangle inequality, which
means the estimated cost of reaching a neighboring node plus the cost of getting
from that node to the goal node is never greater than the estimated cost of getting
directly to the goal node.
4. A* Search: A* Search is an optimal and complete search algorithm that combines the
actual cost of getting to a node with the estimated cost of getting to the goal node.
A* Search uses an admissible and consistent heuristic function to guide the search
towards the goal node.
5. Iterative Deepening A*: Iterative Deepening A* is a variant of A* Search that can be
more memory-efficient for larger search spaces. It uses a series of depth-limited
searches with increasing depths, and it prunes nodes that have a total estimated
cost greater than the cost of the best solution found so far.
6. IDA*: IDA* (Iterative Deepening A*) is a complete search algorithm that uses
iterative deepening with a depth-first search strategy to minimize the total
estimated solution cost. It can be more memory-efficient than A* Search for large
search spaces, but it may expand some nodes multiple times.
Overall, minimizing the total estimated solution cost in AI involves using heuristic functions,
admissible and consistent heuristics, and optimal and complete search algorithms like A*
Search, Iterative Deepening A*, and IDA*.

14. Conditions for optimality :- Optimality in AI refers to finding the best possible
solution to a problem. The following conditions must be met for a search algorithm to be
optimal:
1. Admissibility: An admissible heuristic never overestimates the actual cost of
reaching the goal node. If a heuristic is admissible, then the search algorithm will
always find the optimal solution.
2. Consistency: A consistent heuristic satisfies the triangle inequality. If a heuristic is
consistent, then the search algorithm is guaranteed to find the optimal solution.
3. Monotonicity: A monotonic heuristic is a consistent heuristic that is also non-
decreasing. If a heuristic is monotonic, then the cost of reaching a node from its
parent plus the estimated cost of reaching the goal node from that node is never less
than the estimated cost of reaching the goal node from the parent.
 4. Optimal Path Property: The optimal path property states that if a search algorithm
finds a path to a node n that has a total estimated cost f(n), then the total estimated
cost of the optimal path to n is not less than f(n).
5. Complete: A search algorithm is complete if it is guaranteed to find a solution if one
exists.
Overall, a search algorithm that satisfies these conditions is guaranteed to find the optimal
solution to a problem.

15. Admissibility and consistency :- Admissibility and consistency are two important
properties of heuristic functions used in informed (heuristic) search algorithms in artificial
intelligence. Here are their definitions and key characteristics:
1. Admissibility: A heuristic function is admissible if it never overestimates the actual
cost of reaching the goal state from the current state.
Key characteristics of admissible heuristics:
 They are always optimistic (i.e., they never overestimate the cost of reaching the
goal state).
 They may be less informed than other heuristics, but they are guaranteed to be
admissible.
 Examples of admissible heuristics include the number of misplaced tiles in the 8-
puzzle game, and the shortest distance between two cities on a map (assuming no
obstacles).
2. Consistency (or monotonicity): A heuristic function is consistent if the estimated cost
of reaching a neighboring state plus the cost of getting from the current state to that
neighboring state is always less than or equal to the estimated cost of reaching the
goal state from the current state. In other words, the heuristic function satisfies the
triangle inequality. Consistent heuristics are important because they guarantee that
the search algorithm will find the optimal solution, even if the search space is
infinite.
Key characteristics of consistent heuristics:
 They are always admissible (i.e., they never overestimate the cost of reaching the
goal state).
 They are more informed than admissible heuristics, but they may be more
computationally expensive.
 Examples of consistent heuristics include the Euclidean distance between two points
on a map, and the Manhattan distance between two points on a grid.
16. Optimality of A* :- Here are the key points that explain the optimality of A*:
1. Completeness: A* is a complete algorithm, meaning that it is guaranteed to find a
solution if one exists in a finite search space.
2. Admissibility: A* uses a heuristic function that is admissible, meaning that it never
overestimates the cost of reaching the goal state from the current state. This
ensures that A* will always find the optimal solution to the problem, as long as the
search space is finite.
3. Consistency: A* also requires that the heuristic function be consistent, meaning that
it satisfies the triangle inequality. This ensures that A* will always find the optimal
solution to the problem, even if the search space is infinite.
4. Optimality: Because A* uses an admissible and consistent heuristic function, it is
guaranteed to find the optimal solution to the problem by exploring the search
space in a way that is both efficient and effective.
5. Time and space complexity: The time and space complexity of A* depends on the
quality of the heuristic function used. In the best case scenario, where the heuristic
function is perfect, A* has a time complexity of O(d), where d is the depth of the
optimal solution. In the worst case scenario, where the heuristic function is poor, A*
may have to explore all nodes in the search space and has a time complexity of
O(b^d), where b is the branching factor of the search tree.
Overall, the optimality of A* is based on its ability to combine information about the
cost of the path from the start state to the current state and the estimated cost of the
path from the current state to the goal state to efficiently explore the search space and
find the optimal solution.

17. Memory-bounded heuristic search :- Here are the key points that explain the
memory-bounded heuristic search:
1. Memory constraints: Memory-bounded heuristic search is designed to work within a
specified memory constraint, which limits the amount of memory that can be used
to store the search tree.
2. Best-first search: Memory-bounded heuristic search is based on the best-first search
algorithm, which explores the most promising nodes in the search space first.
3. Heuristic function: Memory-bounded heuristic search uses a heuristic function to
estimate the cost of the path from the current state to the goal state.
4. Limited-depth search: In order to stay within the memory constraint, memory-
bounded heuristic search performs a limited-depth search, which means that it only
explores nodes up to a certain depth in the search tree.
5. Priority queue: Memory-bounded heuristic search uses a priority queue to store the
nodes in the search tree, ordered by their estimated cost to the goal state.
6. Iterative deepening: If a solution is not found within the memory constraint and
limited-depth search, memory-bounded heuristic search can use iterative deepening
to gradually increase the depth of the search until a solution is found or the memory
constraint is exceeded.
7. Trade-off between memory and optimality: Memory-bounded heuristic search
trades off optimality for memory usage. The search may not always find the optimal
solution to the problem, but it will find the best solution possible within the memory
constraint.
Overall, memory-bounded heuristic search is a useful approach when memory usage is a
concern, and the search must be able to operate within a specified memory constraint.
The trade-off between optimality and memory usage is an important consideration
when choosing between different search algorithms.

18. Heuristic Functions :- A heuristic function, also known as an evaluation function,

is a function used to evaluate a particular state in a search problem. It is commonly used
in artificial intelligence and computer science to estimate the distance or cost between a
given state and a goal state in a search space.
The aim of a heuristic function is to reduce the search space and improve the efficiency
of the search algorithm. A good heuristic function should be efficient, consistent, and
admissible.
 Efficiency: The heuristic function should be fast enough to compute so that the
search algorithm can run in a reasonable amount of time.
 Consistency: The heuristic function should be consistent in that it should always
underestimate the actual distance or cost from a given state to the goal state.
 Admissibility: The heuristic function should be admissible in that it should never
overestimate the actual distance or cost from a given state to the goal state.
There are several types of heuristic functions, including:
1. Manhattan distance heuristic: This heuristic is used in grid-based problems, where
the shortest distance between two points is measured along the horizontal and
vertical axes.
2. Euclidean distance heuristic: This heuristic is used in problems where the shortest
distance between two points is measured along a straight line.
3. Maximum heuristic: This heuristic chooses the maximum distance between the
current state and the goal state among all possible distances.
4. Minimum heuristic: This heuristic chooses the minimum distance between the
current state and the goal state among all possible distances.
5. Pattern database heuristic: This heuristic stores precomputed values of distances
between a set of states and the goal state, and uses these values to estimate the
distance between the current state and the goal state.
Heuristic functions are commonly used in search algorithms such as A* and IDA*.

19. Generating admissible heuristics from sub problems :-

One way to generate an admissible heuristic function is to decompose the main problem
into sub-problems and then generate a heuristic function for each sub-problem. The
heuristic function for the main problem can then be obtained by combining the heuristic
functions of the sub-problems in some way.
To ensure that the resulting heuristic function is admissible, we need to make sure that
the sum of the heuristic values of the sub-problems never overestimates the true cost
from the current state to the goal state.
Here's an example of how to generate an admissible heuristic function from sub-
problems:
Suppose we have a main problem of finding the shortest path between two cities, A and
B, on a map. We can decompose this problem into sub-problems of finding the shortest
path between A and each intermediate city, C and D, and then finding the shortest path
between each intermediate city and B. We can then generate a heuristic function for
each sub-problem as follows:
1. Heuristic function for finding the shortest path from A to C:
 Calculate the straight-line distance between A and C (this is an admissible
heuristic because the actual distance is never less than the straight-line
distance).
2. Heuristic function for finding the shortest path from C to D:
 Calculate the straight-line distance between C and D.
3. Heuristic function for finding the shortest path from D to B:
 Calculate the straight-line distance between D and B.
We can then combine these heuristic functions to generate a heuristic function for the
main problem by summing the heuristic values of each sub-problem:
h(A,B) = h(A,C) + h(C,D) + h(D,B)
This heuristic function is admissible because the sum of the heuristic values of the sub-
problems never overestimates the true cost from A to B.
20. Pattern databases :- Pattern databases (PDBs) are a technique for generating
admissible heuristic functions for search problems. They work by pre-computing the
optimal solution cost from a set of states to the goal state, and then using these pre-
computed costs as heuristic estimates during search.
Here are some key points about pattern databases:
1. Definition: A pattern database is a table that stores pre-computed solution costs for
a set of sub-problems of the original problem. Each sub-problem is defined by a
pattern of some subset of the problem's state variables.
2. Pre-computation: The cost of the optimal solution for each sub-problem is
computed offline and stored in the pattern database.
3. Heuristic estimate: During search, the heuristic function is computed by looking up
the pre-computed solution cost for the sub-problem that matches the current state.
4. Admissibility: Pattern databases generate admissible heuristic functions because the
stored solution costs are optimal for the corresponding sub-problems, and the
heuristic function never overestimates the true cost from the current state to the
goal state.
5. Size: The size of a pattern database depends on the number of sub-problems and the
size of each sub-problem. In general, the larger the database, the better the quality
of the heuristic function, but the more memory is required.
6. Computation time: The computation time required to generate a pattern database
can be significant, but it only needs to be done once and can be reused for multiple
search problems.
7. Applications: Pattern databases have been used successfully in a variety of search
problems, including puzzle-solving, robotic motion planning, and game playing.
Overall, pattern databases provide an effective way to generate admissible heuristic
functions for search problems by pre-computing the optimal solution cost for a set of
sub-problems. This technique can significantly improve the efficiency and effectiveness
of search algorithms.

21. Learning heuristics from experience :- Learning heuristics from experience

involves using machine learning techniques to automatically generate heuristic functions
from a set of training examples. The training examples consist of pairs of states and their
associated optimal solution costs, which are used to train a machine learning model to
predict the solution cost of new states.
Here are some key points about learning heuristics from experience:
1. Training data: The training data consists of pairs of states and their optimal solution
costs. These can be obtained from expert solutions or by solving the problem using a
computationally expensive algorithm.
2. Features: Features are extracted from each state to provide input to the machine
learning model. These features can be hand-crafted or learned automatically using
feature engineering techniques.
3. Machine learning model: The machine learning model is trained on the training data
to predict the optimal solution cost of new states. Popular machine learning
algorithms for this task include decision trees, neural networks, and regression
models.
4. Generalization: The trained model is tested on a separate set of validation data to
ensure that it generalizes well to new, unseen states.
5. Admissibility: To ensure that the resulting heuristic function is admissible, the model
should be trained to predict a lower bound on the true solution cost.
6. Efficiency: The efficiency of the learned heuristic function depends on the quality of
the features, the size of the training data, and the complexity of the machine
learning model.
7. Applications: Learning heuristics from experience has been successfully applied to a
variety of search problems, including puzzle-solving, robotic motion planning, and
game playing.
Overall, learning heuristics from experience provides a powerful and flexible approach
for generating effective heuristic functions for search problems. By automatically
learning from training data, these techniques can significantly improve the efficiency
and effectiveness of search algorithms.

22. Beyond Classical Search :- Classical search algorithms are effective for solving
many types of problems, but they have limitations in certain situations. Here are some
ways that search algorithms can be extended beyond classical search:
1. Adversarial Search: Adversarial search is used for two-player games, such as chess
or go, where each player takes turns making moves. Minimax algorithm with alpha-
beta pruning is a popular adversarial search algorithm.
2. Stochastic Search: Stochastic search algorithms are used when the outcomes of
actions are uncertain, such as in robotics or financial planning. Examples of
stochastic search algorithms include Monte Carlo Tree Search and particle swarm
optimization.
3. Evolutionary Search: Evolutionary search algorithms are inspired by natural
selection and genetics. These algorithms use population-based methods to evolve a
set of solutions to a problem, such as genetic algorithms and genetic programming.
4. Heuristic Search: Heuristic search algorithms use domain-specific knowledge to
guide the search process, rather than relying solely on the structure of the search
space. Examples include A* search and beam search.
5. Reinforcement Learning: Reinforcement learning is a type of machine learning that
involves an agent learning to make decisions based on feedback in the form of
rewards or penalties. This approach is commonly used for problems involving
decision-making, such as game playing or robotics.
6. Online Search: Online search algorithms are designed to operate in dynamic
environments where the search space changes over time. Examples include
incremental search and real-time search.
7. Hierarchical Search: Hierarchical search algorithms decompose a problem into a
hierarchy of sub-problems, allowing for more efficient search by exploiting the
structure of the problem. Examples include hierarchical task networks and subgoal
graphs.
Overall, extending search algorithms beyond classical search involves adapting the
algorithm to the specific characteristics of the problem being solved. By choosing the
appropriate search algorithm, it is possible to significantly improve the efficiency and
effectiveness of the search process.

23. Local Search Algorithms and Optimization Problems :-

Local search algorithms are a class of optimization algorithms that iteratively improve a
candidate solution by making small, locally optimal changes. These algorithms are
particularly useful for solving optimization problems, where the goal is to find the best
possible solution from a set of possible solutions.
Here are some key points about local search algorithms and optimization problems:
1. Optimization problems: Optimization problems involve finding the best possible
solution from a set of possible solutions. Examples include finding the shortest path
between two points or minimizing the cost of a production process.
2. Candidate solutions: Local search algorithms start with a candidate solution and
iteratively improve it by making small, locally optimal changes.
3. Objective function: The quality of a candidate solution is measured by an objective
function, which assigns a score to each solution based on how well it satisfies the
optimization criteria.
4. Local search: Local search algorithms make small changes to the candidate solution
to improve its score. These changes are usually based on local information, such as
the neighborhood of the current solution.
 5. Hill climbing: Hill climbing is a popular local search algorithm that repeatedly makes
the best move to improve the current solution until a local maximum is reached.
6. Simulated annealing: Simulated annealing is a local search algorithm that allows for
occasional "bad" moves to escape local maxima. This is achieved by gradually
decreasing the probability of accepting worse solutions over time.
7. Tabu search: Tabu search is a local search algorithm that avoids revisiting recently
visited solutions or making previously tried moves. This helps to avoid getting stuck
in cycles or revisiting previously explored regions of the search space.
Overall, local search algorithms are powerful tools for solving optimization problems. By
iteratively improving a candidate solution, these algorithms can efficiently search large
solution spaces and find high-quality solutions. The choice of local search algorithm
depends on the specific characteristics of the problem being solved and the properties
of the solution space.

24. Hill-climbing search Simulated annealing :- Hill-climbing search and simulated

annealing are two popular local search algorithms that are used to find the optimal solution
for optimization problems. Here is a point-wise comparison of these two algorithms:
Hill-Climbing Search:
 Hill-climbing search is a simple and widely used local search algorithm that
repeatedly makes the best move to improve the current solution until a local
maximum is reached.
 The algorithm starts with an initial solution and evaluates its objective function. It
then explores the neighboring solutions and selects the best one as the next
solution. This process is repeated until no further improvements can be made.
 The algorithm is prone to getting stuck in local maxima or plateaus, where there are
no better solutions in the immediate neighborhood. It is also sensitive to the initial
solution and can converge to suboptimal solutions.
 Hill-climbing search is computationally efficient and easy to implement.
Simulated Annealing:
 Simulated annealing is a more sophisticated local search algorithm that allows for
occasional "bad" moves to escape local maxima. This is achieved by gradually
decreasing the probability of accepting worse solutions over time.
 The algorithm starts with an initial solution and evaluates its objective function. It
then randomly selects a neighboring solution and decides whether to accept it based
on a probability function that depends on the current temperature and the
difference in objective function values between the current and neighboring
solutions.
  The algorithm gradually decreases the temperature, which reduces the probability of
accepting worse solutions and increases the likelihood of convergence to the optimal
solution.
 Simulated annealing is less prone to getting stuck in local maxima than hill-climbing
search, but it requires tuning of the temperature schedule and other parameters. It
is also computationally more expensive than hill-climbing search.
In summary, hill-climbing search is a simple and computationally efficient local search
algorithm that can converge quickly to local maxima. Simulated annealing is a more
sophisticated algorithm that is less prone to getting stuck in local maxima, but it requires
more computational resources and tuning of parameters. The choice of algorithm depends
on the specific characteristics of the problem being solved and the properties of the solution
space.

25. Local beam search :- Local beam search is a local search algorithm that is used to
solve optimization problems by iteratively improving the quality of a set of candidate
solutions. Here is a point-wise explanation of how local beam search works:
1. Initialization: The algorithm starts with k randomly generated candidate solutions,
also known as the beam, where k is a user-defined parameter.
2. Evaluation: The objective function is evaluated for each candidate solution in the
beam. The solutions are then sorted in descending order of their objective function
values.
3. Generation of neighbors: For each solution in the beam, a set of neighboring
solutions is generated by applying some transformation, such as flipping a bit or
swapping two elements. These neighbors are then evaluated using the objective
function.
4. Selection: The k best solutions, including the initial beam, are selected from the set
of neighbors based on their objective function values.
5. Termination: If the best solution in the beam is the optimal solution, the algorithm
terminates. Otherwise, the beam is updated with the new set of solutions, and the
process is repeated from step 2 until a termination criterion is met.
Some key points about local beam search include:
 The algorithm maintains a set of k candidate solutions, known as the beam, at each
iteration.
 The beam is updated by selecting the k best solutions from the set of neighbors
generated for each solution in the current beam.
 Local beam search is a variant of beam search, a tree search algorithm that explores
a fixed number of candidate solutions, known as the beam width, at each level of the
search.
  Local beam search is a stochastic algorithm, and the quality of the solutions it
produces depends on the initial beam, the transformation used to generate
neighbors, and the selection criterion used to update the beam.
In summary, local beam search is a local search algorithm that maintains a set of candidate
solutions, known as the beam, and iteratively improves them by generating and evaluating
neighboring solutions. The algorithm is simple to implement and can be effective for solving
optimization problems when the search space is large and the optimal solution is not known
in advance.

26. Genetic algorithms :- Genetic algorithms are a class of optimization algorithms that
use principles inspired by natural evolution to find high-quality solutions to optimization
problems. Here is a point-wise explanation of how genetic algorithms work:
1. Initialization: The algorithm starts with a population of randomly generated
candidate solutions, where each solution is represented as a string of genes.
2. Evaluation: The objective function is evaluated for each candidate solution in the
population, and the solutions are sorted in descending order of their objective
function values.
3. Selection: A subset of the population is selected for reproduction based on their
fitness, which is a measure of their objective function value. Common selection
methods include tournament selection, roulette wheel selection, and rank-based
selection.
4. Reproduction: The selected solutions are used to create offspring solutions through
a combination of crossover and mutation operations. Crossover involves exchanging
genetic material between two parent solutions to create a new offspring solution,
while mutation involves randomly changing a gene in a single solution to create a
new offspring solution.
5. Replacement: The offspring solutions are evaluated using the objective function and
added to the population, replacing some of the existing solutions. This ensures that
the population size remains constant.
6. Termination: The algorithm terminates when a stopping criterion is met, such as a
maximum number of generations or a satisfactory level of solution quality.
Some key points about genetic algorithms include:
 The algorithm maintains a population of candidate solutions, which evolves over
time through selection, reproduction, and replacement.
 The genetic operators of crossover and mutation are used to create new solutions by
combining the genetic material of existing solutions.
  Genetic algorithms are stochastic algorithms, and the quality of the solutions they
produce depends on the initial population, the selection criterion, and the genetic
operators used.
 Genetic algorithms can be effective for solving optimization problems when the
search space is large and the optimal solution is not known in advance.
In summary, genetic algorithms are a class of optimization algorithms that use principles
inspired by natural evolution to find high-quality solutions to optimization problems. The
algorithm maintains a population of candidate solutions that evolves over time through
selection, reproduction, and replacement, and uses genetic operators such as crossover and
mutation to create new solutions.

27. Local Search in Continuous Spaces :-

Local search algorithms are commonly used to find optimal or near-optimal solutions to
optimization problems in continuous spaces. Here is a point-wise explanation of how local
search can be applied in continuous spaces:
1. Initialization: The algorithm starts with an initial solution, which is typically
generated randomly or through some other method.
2. Evaluation: The objective function is evaluated for the initial solution, and the
solution is stored as the current best solution.
3. Generation of neighbors: A set of neighboring solutions is generated by applying
some transformation to the current best solution. This transformation can be as
simple as perturbing the solution by a small amount or as complex as using a
gradient-based method to find the direction of steepest ascent or descent.
4. Selection: The best solution from the set of neighbors is selected based on its
objective function value. If this solution is better than the current best solution, it
becomes the new current best solution.
5. Termination: The algorithm terminates when a stopping criterion is met, such as a
maximum number of iterations or a satisfactory level of solution quality.
Some key points about local search in continuous spaces include:
 The neighbourhood of a solution in a continuous space is typically defined by a
distance metric, such as Euclidean distance.
 The choice of transformation used to generate neighbors can have a significant
impact on the quality of the solutions produced. Some common methods include
random perturbations, gradient descent/ascent, and local linear models.
 Local search can be combined with other optimization techniques, such as simulated
annealing or genetic algorithms, to improve the quality of the solutions produced.
  Local search is most effective when the objective function is smooth and continuous,
and when the search space is not too large.
In summary, local search can be used to find optimal or near-optimal solutions to
optimization problems in continuous spaces by generating and evaluating neighboring
solutions. The choice of transformation used to generate neighbors and the stopping
criterion used to terminate the algorithm are key factors that determine the quality of the
solutions produced.

28. Searching with Non-deterministic Actions :- Searching with non-deterministic

actions is a type of search problem where the effects of actions are uncertain or non-
deterministic. Here is a point-wise explanation of how to search with non-deterministic
actions:
1. State representation: The problem state is represented as a set of variables that
describe the state of the world.
2. Action representation: Actions are represented as conditional effects that specify
their possible outcomes given the current state.
3. Successor function: A successor function is defined to generate a set of possible
successor states for a given state and action. This function takes into account the
non-deterministic effects of the action.
4. Search algorithm: A search algorithm is used to search for a sequence of actions that
lead from the initial state to a goal state. The search algorithm can be based on any
of the classical search algorithms such as breadth-first search, depth-first search, or
A* search.
5. Evaluation function: An evaluation function is used to evaluate the quality of the
search path based on the goal criteria.
Some key points about searching with non-deterministic actions include:
 The non-deterministic effects of actions can be represented in different ways, such
as probabilistic effects, conditional effects, or nondeterministic effects.
 The successor function generates a set of possible successor states for a given state
and action, taking into account the non-deterministic effects of the action. This
function can be implemented using techniques such as Monte Carlo simulation or
probability distributions.
 The evaluation function can take into account the probability or expected value of
reaching the goal state, as well as the cost of the actions taken to reach it.
 Search algorithms can be adapted to deal with non-deterministic actions by
incorporating probabilistic or stochastic search strategies.
In summary, searching with non-deterministic actions involves representing the state and
action space in a way that accounts for the uncertainty or non-determinism of the effects of
actions. Successor functions and evaluation functions are used to generate and evaluate
search paths, and search algorithms can be adapted to handle non-deterministic effects.

29. AND-OR search trees :- AND-OR search trees are a type of search tree used in
artificial intelligence to represent and solve problems that involve both conjunctions (AND)
and disjunctions (OR).
In an AND-OR search tree, each node represents a proposition that is either an AND node or
an OR node. An AND node represents a proposition that is true only if all its children are
true, while an OR node represents a proposition that is true if any of its children is true.
To search for a solution in an AND-OR search tree, we start at the root node and recursively
explore the tree by applying the following rules:
 If the current node is an AND node, we evaluate all of its children, and if all of them
are true, we continue exploring the tree from each child node. Otherwise, we
backtrack and continue exploring from the parent node.
 If the current node is an OR node, we evaluate its children one at a time, and if any
of them is true, we continue exploring the tree from that child node. Otherwise, we
backtrack and continue exploring from the parent node.
The goal of the search is to find a path from the root node to a leaf node that represents a
solution to the problem being solved. The leaf nodes of an AND-OR search tree represent
the possible solutions to the problem.
AND-OR search trees are commonly used in game-playing algorithms, natural language
processing, and other areas of artificial intelligence.

30. Searching with Partial Observations :- Searching with partial observations refers
to the process of searching for a solution in a problem where not all information is available
at all times. Here are some key points about searching with partial observations:
 Partial observations are common in real-world problems, where not all information
is available at all times. Examples include navigation, robotics, and sensor networks.
 In such problems, the agent may have to make decisions based on incomplete
information, which can lead to uncertainty and risk.
 One approach to searching with partial observations is to use probabilistic models,
such as Bayesian networks or Markov decision processes, which can incorporate
uncertain and incomplete information into the search process.
 Another approach is to use heuristic search algorithms, such as A* or beam search,
which can use partial information to guide the search towards a solution.
 In some cases, it may be necessary to use techniques such as filtering or smoothing
to infer missing information from partial observations.
 Searching with partial observations can be computationally expensive, as the search
space can be very large and the uncertainty can lead to many possible paths.
Therefore, it is important to use efficient algorithms and representations to manage
the complexity of the search.
 Finally, searching with partial observations requires careful consideration of the
trade-offs between exploration and exploitation, as the agent must balance the need
for new information with the need to make decisions based on existing information.