ANSWER KEY:

1.) Define AI and write the application of AI:

Artifical Intelligence(AI) refers to the development of
computer systems that can perform tasks that typically
require human intelligence such as
1. Virtual Assistants: Siri, Alexa, Google Assistant
2. Image Recognition: Facebook, Google Photos
3. Self-Driving Cars: Tesla, Waymo
4. Healthcare: Diagnosis, Treatment, Patient Care
5. Cybersecurity: Threat Detection, Prevention
6. Chatbots: Customer Service, Language Translation

2.)Characterize the environment of an agent playing soccer

Dynamic and Multi-agent: Involves multiple players and
continuous movement.
Partially Observable: The agent can’t see the entire field at
once.
Stochastic and Sequential: Outcomes are uncertain and
actions depend on previous decisions

3.) What is Heuristic function?

Heuristic function is a method used in AI to estimate the
cost or distance to reach a goal from a given state. It helps in
making decisions to optimize the search process.
4.) What are the things that agent knows in online search
problems?
1. *Initial state*: The starting point or current position of the
agent.
2. *Actions*: The available set of actions the agent can take
from its current state.
The agent doesn't know the full environment or outcome of
actions ahead of time and must explore the environment in
real-time.

5.) Write the components of a game?

The key components of games in AI are:
1.Initial State: The starting configuration of the game,
including the positions of all players and pieces.
2.Successor Function: A set of legal moves or actions
available to players, which defines possible transitions
between states.
PART B
6(a) Define an agent , Explain the four basic agents that
embody the principles underlying intelligent system with
examples.
Definition of an Agent
An agent in artificial intelligence (AI) is an entity that
perceives its environment through sensors and acts upon
that environment through actuators to achieve specific goals.
Agents can be software programs, robots, or any system that
can make decisions and take actions autonomously.

Four Basic Types of Agents

Simple Reflex Agents
Description: These agents select actions based on the current
percept, ignoring the rest of the percept history. They
operate using condition-action rules (if-then statements).
Example: A thermostat that turns on the heater if the
temperature drops below a certain threshold. It doesn’t
consider past temperatures, only the current reading.
-Based Reflex Agents Model
Description: These agents maintain an internal state that
depends on the percept history. They use this state to handle
partially observable environments.
Example: A self-driving car that keeps track of nearby
vehicles and pedestrians. It uses this information to make
decisions about speed and direction, considering both
current and past observations.
Goal-Based Agents
Description: These agents act to achieve specific goals. They
use goal information to choose actions that lead to the
desired outcome.
Example: A navigation system that plans a route from point A
to point B. It considers various routes and selects the one
that best achieves the goal of reaching the destination
efficiently.
Utility-Based Agents
Description: These agents aim to maximize their performance
measure by considering the utility of different states. They
choose actions based on a utility function that quantifies the
desirability of different outcomes.
Example: An investment algorithm that selects a portfolio of
stocks to maximize expected returns while minimizing risk. It
evaluates the utility of different investment strategies to
make optimal decisions.
Real-World Examples
Simple Reflex Agent: A light switch that turns on when it
detects motion.
Model-Based Reflex Agent: A robot vacuum that maps the
layout of a room to clean more efficiently.
Goal-Based Agent: A chess-playing AI that plans several
moves ahead to checkmate the opponent.
Utility-Based Agent: A recommendation system that
suggests products to users based on their preferences and
past behavior.

7(a) What is Heuristic search technique in AI? How does

heuristics search works? Explain its advantages and
disadvantages?
Heuristic Search in AI
A *heuristic search* is an informed search strategy in
Artificial Intelligence (AI) that improves search efficiency by
utilizing domain-specific knowledge (heuristics) to guide the
search process toward a goal. Heuristics are estimates or
"rules of thumb" used to evaluate the likelihood of a node
leading to an optimal or satisfactory solution. They help in
prioritizing the search by suggesting which paths are most
promising, rather than searching blindly.
Working of Heuristic Search
1. Initial Setup:
- The algorithm starts with an initial state (starting node)
and a goal state.

2. Heuristic Function (h(n)):

 - A heuristic function is defined, which estimates the cost to
reach the goal from a given node (n). This is a key part of
guiding the search process.
3. Priority Queue:
- The nodes are stored in a priority queue, where the
priority is determined by the heuristic value (or a
combination of heuristic and actual cost, depending on the
algorithm).
4. Node Expansion:
- At each step, the algorithm picks the node with the best
heuristic value, expands it (generates its neighboring nodes),
and evaluates the new nodes using the heuristic function.
5. Repeat:
- This process is repeated until the goal node is found or the
search space is exhausted
1. Greedy Best-First Search:
- Selects the node with the lowest heuristic value (h(n)).
- Focuses purely on the heuristic to reach the goal faster but
doesn't guarantee the shortest path.
2. A* Search:
- Uses a combination of actual cost and heuristic value (f(n)
= g(n) + h(n), where g(n) is the actual cost to reach node n).
 - It guarantees an optimal solution if the heuristic function
is admissible (i.e., it never overestimates the cost).
Advantages of Heuristic Search
1. Efficiency:
- Heuristic search can significantly reduce the number of
nodes explored compared to uninformed search strategies
like Breadth-First Search (BFS) or Depth-First Search (DFS),
making it more efficient in larger problem spaces.
2. Goal-Oriented:
- Heuristic search is more goal-oriented since the search is
guided by the heuristic function toward promising paths,
helping to find solutions faster.
3. Improves Scalability:
- Heuristic search techniques are better suited for complex
and large problem spaces, where traditional uninformed
search would be computationally expensive or infeasible.
4. Flexible:
- Different heuristics can be tailored for different problems,
providing flexibility to adapt the search strategy based on
domain-specific knowledge.
Disadvantages of Heuristic Search
1. Non-Optimality (in some cases):
 - If the heuristic is not well-designed or inaccurate, it can
lead to suboptimal solutions, particularly in greedy
approaches.
7(b) Elaborate on the need for local search algorithm and
discuss any one algorithm in detail?
Local search algorithms are essential in artificial intelligence
and optimization for several reasons:
Efficiency in Large Search Spaces: They are particularly useful
when the search space is vast, making exhaustive search
impractical.
Optimization: They help find high-quality solutions for
complex problems where exact solutions are computationally
expensive or impossible to find.
Flexibility: They can be applied to a wide range of problems,
including scheduling, routing, and resource allocation.
Simplicity: Many local search algorithms are straightforward
to implement and understand
Hill Climbing Algorithm-:
Let’s delve into the Hill-Climbing Algorithm, a popular local
search method:
Hill-Climbing is an iterative algorithm that starts with an
arbitrary solution and makes incremental changes to improve
it. The goal is to reach the peak of the “hill,” which
represents the optimal solution.
Process:
Initialization: Start with an initial solution, often generated
randomly.
Evaluation: Assess the quality of the current solution using an
objective function.
Neighbor Generation: Generate neighboring solutions by
making small changes to the current solution.
Selection: Choose the neighbor that improves the objective
function the most.
Iteration: Repeat the evaluation and selection steps until no
better neighboring solution exists.
Types of Hill-Climbing
Simple Hill-Climbing: Chooses the first neighbor that
improves the solution.
Steepest-Ascent Hill-Climbing: Evaluates all neighbors and
selects the best one.
Stochastic Hill-Climbing: Randomly selects neighbors to
explore.
Example:
Consider a robot navigating a terrain to find the highest
point. The robot starts at a random location and evaluates
the height of its current position. It then moves to the
neighboring position with the highest elevation. This process
continues until the robot reaches a point where no
neighboring position has a higher elevation.
Pros and Cons
Pros:Easy to implement.
Works well in small or smooth search spaces.
Cons:May get stuck in local optima.
Limited exploration of the search space.
Hill-Climbing is a foundational algorithm in AI, often used as a
building block for more complex methods123.

8(a) Brief on MinMax algorithm and also discuss the need of

alphabeta pruning?
Minimax Algorithm:
The Minimax algorithm is a decision-making algorithm used
in artificial intelligence, particularly in game theory and
computer games. It is designed to minimize the possible loss
in a worst-case scenario (hence “min”) and maximize the
potential gain (hence “max”). Here’s a brief overview:
How It Works
Game Tree Construction: The algorithm constructs a game
tree where each node represents a game state, and each
edge represents a possible move.
Evaluation: Terminal nodes (end states of the game) are
evaluated with a utility function that assigns a value based on
the outcome (win, lose, or draw).
Backpropagation: The utility values are propagated back up
the tree. If it’s the maximizer’s turn, the node takes the
maximum value of its children; if it’s the minimizer’s turn, it
takes the minimum value.
Optimal Move Selection: At the root of the tree, the
maximizer selects the move that leads to the highest utility
value.
Example:
In a game of tic-tac-toe, the Minimax algorithm evaluates all
possible moves and their outcomes, ensuring that the AI
makes the best possible move to either win or draw the
game123.
Alpha-Beta Pruning:
Alpha-Beta Pruning is an optimization technique for the
Minimax algorithm. It reduces the number of nodes
evaluated in the game tree, making the algorithm more
efficient.
Need for Alpha-Beta Pruning
Efficiency: Without pruning, the Minimax algorithm
evaluates every possible move, which can be computationally
expensive, especially in complex games like chess.
Depth Exploration: Pruning allows the algorithm to explore
deeper levels of the game tree within the same time
constraints, leading to better decision-making.
How It Works
Alpha: The best value that the maximizer can guarantee at
that level or above.
Beta: The best value that the minimizer can guarantee at that
level or below.
During the tree traversal:
Pruning: If the current node’s value is worse than the
previously examined nodes (for the maximizer or minimizer),
the subtree rooted at this node is pruned (i.e., not explored
further).
Comparison: Alpha and beta values are updated during the
traversal to keep track of the best options for both players.
Example
In a chess game, if a move is found that leads to a better
outcome for the maximizer, any subsequent moves that
would lead to a worse outcome for the maximizer are
pruned, saving computational resources.
8(b) Outline the structure of CSP, Explain backtracking search
and local search for CSP
A Constraint Satisfaction Problem (CSP) consists of three
main components:
1. Variables: A set of variables, \( X_1, X_2, ..., X_n \), which
need to be assigned values.
2. Domains: Each variable \( X_i \) has a domain \( D_i \),
which is the set of possible values it can take.
3. Constraints: A set of constraints \( C_1, C_2, ..., C_m \),
each involving a subset of variables, which define the
allowable combinations of values these variables can take.
Example:
In the context of a *Sudoku puzzle*:
- Variables: The empty cells in the Sudoku grid.
- Domains: The numbers 1 through 9.
- Constraints: The condition that each number must appear
exactly once in each row, column, and 3x3 subgrid.
CSP Goal:
The goal in a CSP is to assign values to all variables such that
all constraints are satisfied. If no such assignment exists, the
problem is considered *unsolvable*.
Backtracking Search for CSP

Backtracking search is a depth-first search algorithm used to

solve CSPs. It incrementally builds a solution by assigning
values to variables one at a time, and *backtracks* when it
encounters a variable assignment that violates any
constraints.
Steps:
1. Start at the first variable and assign it a value from its
domain.
2. Check consistency: After assigning a value, check if the
current assignment violates any constraints.
3. Recursive assignment: Move to the next variable, and
repeat the process of assigning a value and checking
consistency.
4. Backtrack if needed: If a constraint is violated, undo the
last assignment (backtrack) and try a different value for the
previous variable.
5. Continue until all variables are assigned values (solution
found) or no more possible assignments (unsolvable).
Techniques to Improve Backtracking:
- Forward Checking: After assigning a variable, eliminate
inconsistent values from the domains of unassigned
variables.
-Constraint Propagation: Use algorithms like Arc Consistency
(AC-3) to reduce the search space by enforcing consistency
between variables before and during the search.
-Heuristics: Apply variable ordering heuristics like Minimum
Remaining Values (MRV) or Least Constraining Value (LCV) to
improve efficiency.
Example:
In solving a Sudoku puzzle using backtracking:
- Start by filling one cell with a valid number.
- Check if that number violates any Sudoku constraints.
- If it does, backtrack and try a different number for that cell.
Local Search for CSP
*Local Search* is an optimization-based technique used for
solving CSPs by iteratively improving an initial (often
incomplete or inconsistent) assignment of variables.
Characteristics:
- Incomplete: The search does not necessarily guarantee
finding a solution.
- Iterative: It starts with a random or greedy assignment and
iteratively improves the solution by making small local
changes (e.g., changing the value of one variable).
Steps:
1. Initial Assignment: Start with an initial (possibly
inconsistent) assignment of values to variables.
2. Neighboring Assignments: At each step, generate
neighboring solutions by changing the value of one or more
variables.
3. Objective Function: Evaluate the neighboring assignments
using a cost function, typically based on the number of
constraints violated.
4. Move to Better Neighbor: If a neighboring assignment is
better (fewer constraint violations), move to it.
5. Stopping Criteria: Stop when a solution is found (no
constraint violations) or after a fixed number of iterations.
Techniques:
- Hill Climbing: Always move to a better neighbor if one
exists.
- Simulated Annealing: Occasionally allows moving to worse
neighbors to escape local minima.
- Min-Conflicts Heuristic: Choose the value that minimizes the
number of constraint violations for a randomly selected
variable.
Example:
In the N-Queens problem:
- Start with a random arrangement of queens on the board.
- Iteratively move queens to reduce the number of conflicts
(i.e., queens attacking each other).
- Continue until there are no conflicts or the search halts.
Summary:
- Backtracking search explores the search space
systematically, trying all possibilities, and backtracking when
a constraint is violated.
- Local search operates on a complete but potentially
inconsistent assignment and tries to improve it iteratively by
minimizing constraint violations.
Both methods have their strengths and are applied based on
the nature of the CSP problem.
PART C
9(a) Explain the real-world problem with examples
Memory-Bounded Heuristic Search (MBHS) is a search
strategy that balances exploration and memory usage,
ensuring efficient problem-solving within limited memory.
Here's a detailed explanation:
Motivation:Traditional search algorithms, like A* and
Breadth-First Search (BFS), require significant memory to
store explored nodes. This limits their applicability in
memory-constrained environments or large problem spaces.
Key Components:
1. Heuristic Function (h): Estimates distance from node to
goal.
2. Cost Function (g): Calculates distance from start to node.
3. Evaluation Function (f): Combines h and g (f = g + h).
4. Memory Bound: Maximum amount of memory allocated
for search.
Techniques:
1. Iterative Deepening: Gradually increases search depth,
restarting search with increased depth limit.
2. Transposition Tables: Stores and reuses previously
explored nodes to avoid redundant exploration.
3. Hash-Based Search: Uses hash functions to efficiently store
and retrieve nodes.
4. Graph-Based Search: Explores graph structure to minimize
memory usage.
5. Node Compression: Reduces memory footprint by
compressing node representations.
Algorithms:
1. Memory-Bounded A (MB-A*):* Modifies A* to use iterative
deepening and transposition tables.
2. Iterative Deepening Depth-First Search (IDDFS): Combines
depth-first search with iterative deepening.
3. Memory-Efficient Best-First Search (MEBFS): Adaptation of
best-first search for memory-constrained environments.
Characteristics:
1. Limited memory usage: MBHS algorithms ensure memory
usage stays within allocated bounds.
2. Heuristic guidance: Heuristic functions guide search
towards promising areas.
3. Efficient exploration: MBHS balances depth and breadth to
minimize redundant exploration.
4. Balances depth and breadth: MBHS algorithms adapt to
problem structure to optimize search.
Advantages:

1. Handles large problem spaces: MBHS algorithms can tackle

problems with vast search spaces.
2. Reduces memory requirements: MBHS minimizes memory
usage, making it suitable for resource-constrained systems.
3. Improves search efficiency: Heuristic guidance and efficient
exploration reduce search time.
Applications:
1. Artificial Intelligence: MBHS is used in AI systems with
limited memory or processing power.
2. Game Playing: MBHS enhances game-playing agents'
performance in memory-constrained environments.
3. Planning and Scheduling: MBHS optimizes planning and
scheduling tasks with limited resources.
4. Resource-Constrained Systems: MBHS is essential for
systems with limited memory, processing power, or energy.
9(b) Discuss about a* search and memory bounded heuristic
search
A* (A-Star) Search Algorithm: Detailed Explanation
Overview
A* is a popular pathfinding algorithm used to find the
shortest path between two points in a weighted graph or
network.
Key Components
1. Heuristic Function (h): Estimates distance from node to
goal.
2. Cost Function (g): Calculates distance from start to node.
3. Evaluation Function (f): Combines h and g (f = g + h).
4. Open List: Priority queue storing nodes to explore.
5. Closed List: Set of explored nodes.
Step-by-Step Process
1. Initialize start and goal nodes.
2. Create open list and add start node.
3. While open list is not empty:
a. Dequeue node with lowest f value (node_n).
b. If node_n is goal, return path.
c. Evaluate neighbors.
d. Update open and closed lists.

Heuristic Function (h)

1. Admissible: Never overestimates distance.
2. Consistent: Estimated distance decreases as node
approaches goal.
3. Optimistic: Estimated distance is less than or equal to true
distance.
Evaluation Function (f)
f=g+h
Example
Suppose we want to find the shortest path from Arad to
Bucharest:
| Node | g | h | f |
| --- | --- | --- | --- |
| Arad | 0 | 366 | 366 |
| Zerind | 75 | 374 | 449 |
| ... | ... | ... | ... |
| Bucharest | 418 | 0 | 418 |
Properties
1. Completeness: Guaranteed to find a solution if one exists.
2. Optimality: Finds the shortest path.
3. Efficiency: Minimizes nodes explored.
Variants
1. Dijkstra's Algorithm: No heuristic (h = 0).
2. Greedy Best-First Search: No cost function (g = 0).
3. Iterative Deepening A* (IDA*): Combines A* with iterative
deepening.
Applications
1. Video games (pathfinding).
2. GPS navigation.
3. Robotics.
4. Network routing.
A* is widely used due to its efficiency and effectiveness in
finding optimal paths.