1.

Define Total Turing test, bounded rationality ,decision theory, neurons

1. Total Turing Test:
The Total Turing Test is a way to check if a machine is truly intelligent. Unlike the
normal Turing Test, which only checks if a machine can have a conversation like a
human, the Total Turing Test also checks if the machine can see, hear, touch, and
perform actions like a human. It tests both the machine’s thinking and its ability to
interact with the physical world.
2. Bounded Rationality:
Bounded rationality means that decisions are not always perfect because of limits like
time, data, or computing power. In AI, machines may not always find the best solution
but instead aim for a good enough solution that works within these limits. For
example, an AI might quickly choose a path in a maze without exploring all
possibilities.
3. Decision Theory:
Decision theory is the study of how choices are made. In AI, it helps machines decide
the best action to take, especially when the outcome is uncertain. It uses probabilities
to predict outcomes and utility (value) to choose the action with the most benefit.
For example, a self-driving car might use decision theory to decide whether to stop or
overtake based on risks and benefits.
4. Neurons:
Neurons in AI are the basic building blocks of artificial neural networks. They are
inspired by the neurons in the brain. Each neuron receives input (data), processes it
using mathematical operations, and sends output to other neurons. This process
helps AI systems learn patterns, such as recognizing images, predicting outcomes, or
understanding language.
2. Explain the significant contributions of various branches in the foundations of AI
Artificial Intelligence (AI) is built from ideas and knowledge from many different fields.
Each of these fields has made important contributions to AI’s development.
Mathematics is essential for AI because it helps design the algorithms (step-by-step
instructions) and models used in AI. Key areas like linear algebra, probability, and
calculus allow AI to process data, make predictions, and improve over time. Linear
algebra helps AI understand and manage data, probability helps it predict future
outcomes, and calculus is used to improve the model by making small adjustments to it.
Computer Science is a big part of AI because it focuses on programming and designing
the systems that run AI. Computer science provides important tools like algorithms, data
storage, and programming languages that let AI solve problems. For example, search
algorithms in computer science help AI decide the best move in games like chess or
guide a robot to navigate an area.
Psychology helps AI by showing how humans think, learn, and solve problems. AI
systems learn from experience, just like people do, using techniques like reinforcement
learning. This is when an AI learns by interacting with its environment and getting
feedback on its actions. For example, a chatbot learns how to better respond to human
emotions over time.
Neuroscience is important to AI because it studies how the human brain works. AI uses
the idea of artificial neural networks, which are inspired by the brain. These networks
help AI recognize patterns and learn from experience, such as recognizing faces in
photos or understanding spoken words.
Linguistics helps AI understand and use human language. With natural language
processing (NLP), AI can read, understand, and respond to text or speech. This
technology powers applications like voice assistants (e.g., Siri or Alexa) and translation
tools (e.g., Google Translate), which help AI understand what we say and respond
accordingly.
Philosophy helps AI think logically and make ethical decisions. It deals with questions like
"How should AI make decisions?" and "What is fair?". AI uses these ideas to make sure
its decisions are responsible and ethical. For example, AI systems used in hiring need to
be fair and avoid bias, which is influenced by philosophy.
Economics contributes to AI by providing ways to make decisions when resources are
limited. Game theory and decision-making ideas from economics help AI decide what to
do when there are different choices or risks. For example, in financial markets, AI uses
these ideas to make decisions that try to maximize profits while reducing risk.
These fields all come together to make AI more powerful and able to think, learn, and
solve problems in smart ways.
3. Give PEAS specification for Wumpus world Problem
The Wumpus World is a classic problem in artificial intelligence used to illustrate the
concepts of perception, action, and reasoning in intelligent agents. The PEAS
(Performance Measure, Environment, Actuators, Sensors) framework can be used to
describe the Wumpus World as follows:
Performance Measure:
The performance measure for the agent in the Wumpus World is typically based on a
combination of factors, including:
* Survival: The agent must avoid being killed by the Wumpus or falling into a pit.
 * Gold: The agent must find the gold and return to the start location.
* Time: The agent must complete its task in a reasonable amount of time.
Environment:
* The environment in the Wumpus World is discrete, deterministic, and known.
* It consists of a 4x4 grid of rooms, some of which contain pits, the Wumpus, or gold.
* The agent can perceive the presence of pits and breezes (indicating a pit in an adjacent
room) and the stench of the Wumpus (indicating its presence in an adjacent room).
Actuators:
The agent's actuators allow it to perform the following actions:
* Move: The agent can move to an adjacent room.
* Turn Left: The agent can turn left 90 degrees.
* Turn Right: The agent can turn right 90 degrees.
* Shoot: The agent can shoot an arrow in the direction it is facing.
Sensors:
The agent's sensors allow it to perceive the following information:
* Breeze: Indicates the presence of a pit in an adjacent room.
* Stench: Indicates the presence of the Wumpus in an adjacent room.
* Glitter: Indicates the presence of gold in the current room.
* Bump: Indicates that the agent has tried to move into a wall.
* Scream: Indicates that the Wumpus has been killed.
4.Explain Milestones of AI with reference to (i) Neural networks failure to
generalize (ii) Advent of DENDRAL (iii) Emergence of Intelligent Agents

1. Neural Networks Failure to Generalize

One major milestone in AI history was the failure of early neural networks to
generalize effectively. In the 1960s and 1970s, researchers were excited about the
potential of neural networks, which are systems inspired by the human brain.
However, these early networks faced a significant issue: they couldn’t generalize well.
This means that they would perform well on specific tasks they had been trained on
but struggled to apply the knowledge to new, unseen data. For example, a neural
network trained to recognize certain patterns might fail when faced with similar but
slightly different patterns. This led to a slowdown in research during the 1970s, often
referred to as the "AI Winter," when interest and funding for AI research decreased.

2. Advent of DENDRAL

A major breakthrough came with the development of DENDRAL, an early expert

system in the 1960s and 1970s, designed to help chemists identify the structure of
chemical compounds. DENDRAL was significant because it demonstrated the power
of expert systems, which use specific knowledge about a domain to solve problems.
Unlike general-purpose neural networks, DENDRAL focused on a narrow field
(chemistry) and used rules and logical reasoning to come to conclusions. This system
helped chemists make complex decisions faster and more accurately than before,
showing the potential for AI in specialized areas. The success of DENDRAL marked
the rise of knowledge-based systems in AI, where expert knowledge is used to solve
domain-specific problems, making AI practical and valuable for specific industries.

3. Emergence of Intelligent Agents

The next important milestone was the emergence of intelligent agents in the 1990s.
An intelligent agent is a system that perceives its environment, makes decisions
based on its perceptions, and takes actions to achieve specific goals. These agents
are designed to act autonomously, learn from experience, and adapt to changing
environments. The development of intelligent agents led to the creation of multi-
agent systems, where multiple intelligent agents interact with each other and work
towards a common goal. The rise of intelligent agents paved the way for
applications like autonomous vehicles, robotics, and smart assistants like Siri and
Alexa. These agents are now used in many real-world applications, showcasing AI’s
ability to think, learn, and act in dynamic environments.

Conclusion

These milestones represent key points in AI history. The neural networks failure to
generalize marked a period of frustration and led to a reevaluation of AI techniques.
The advent of DENDRAL showed that AI could be powerful in specific, expert-
driven areas. Finally, the emergence of intelligent agents opened new possibilities
for AI, making it more dynamic and applicable to a wider range of industries. These
developments have helped AI evolve into the field we know today, with systems that
can think, learn, and act intelligently.

5. Differentiate: (i)semi-dynamic vs dynamic (ii) episodic vs sequential

(iii)deterministic vs stochastic

(i) Semi-dynamic vs Dynamic

 • Dynamic: A dynamic environment is one where things keep changing all the
time, even if the agent isn’t doing anything. The environment changes on its
own due to external factors. For example, in a video game where the world
itself changes as time passes, regardless of the player's actions.
• Semi-dynamic: A semi-dynamic environment is one where the environment
can change while the agent is acting, but not completely. Some parts of the
environment change, but others stay the same for a period. For instance, in
self-driving cars, road conditions and traffic change over time, but traffic lights
and road signs usually stay constant for a while before changing...

(ii) Episodic vs Sequential

• Episodic: In an episodic task, the agent’s actions in one part of the task do
not affect the other parts. Each action or decision is independent of the others,
and the task is broken down into separate episodes. For example, when an AI
system classifies individual images in an image recognition task, each image is
treated separately, and the decision made for one image doesn’t affect the
next.
• Sequential: In a sequential task, the agent’s actions are dependent on what
happened before. Each decision impacts the next one. For example, in a maze
navigation task, each step taken by the agent affects the next one, as the
agent has to remember its path and make decisions based on what it has
learned so far

(iii) Deterministic vs Stochastic

• Deterministic: A deterministic environment is one where the outcome of

every action is predictable and certain. If the agent knows the current state
and the action it takes, it can always predict what will happen next. For
example, in a game of tic-tac-toe, the outcome of each move is completely
determined by the current game state, with no randomness involved.
• Stochastic: A stochastic environment is one where the outcome of an action
is uncertain or random. Even if the agent knows the current state, there is no
guarantee that the result of an action will always be the same. For example, in
a game where dice are thrown, the outcome of rolling the dice is random and
cannot be predicted exactly, making it a stochastic environment.

6.Give PEAS specification of biometric authentication system

1. Performance Measure
The performance measure evaluates how well the biometric authentication system
performs its task. For biometric authentication, the performance can be measured
based on:
• Accuracy: The ability to correctly identify or verify the individual (low false
positives and false negatives).
• Speed: How quickly the system can process the biometric data and provide a
decision.
• Security: The system’s ability to prevent unauthorized access.
• User Experience: How easy and seamless the authentication process is for users.

2. Environment
The environment for a biometric authentication system is the physical and digital
setup where it operates. This includes:
• User’s biometric data: Fingerprint, face, iris scan, voice, etc., are collected for
verification.
• Database: A storage of authorized biometric data for comparison.
• Authentication devices: Hardware like fingerprint scanners, cameras, or
sensors used to collect biometric data.
• Security systems: Systems that protect against unauthorized access to
biometric data and make decisions based on the comparisons.

3. Actuators:
Actuators are the components that perform actions in response to decisions made by
the system. In a biometric authentication system, actuators include:
• Access control: Granting or denying access to a system or secure area based
on the authentication result.
• User feedback: Displaying results (e.g., "Access Granted" or "Access Denied")
on a screen or through an audio system.
• Locking or unlocking: If the system controls physical access (like doors), the
actuator could be a lock that opens or closes.

4. Sensors:
Sensors are devices that gather biometric data from the user for processing. In
biometric authentication systems, sensors include:
• Fingerprint scanners: Capture the unique pattern of a person’s fingerprints.
• Facial recognition cameras: Capture images of a person’s face to compare with
stored data.
• Iris scanners: Capture the unique patterns in a person’s iris for identification.
• Voice recognition microphones: Capture a person's voice for voice biometrics.
• Thermal scanners: In some cases, thermal sensors might be used for face or
body temperature detection as part of a multi-factor authentication system.
 7.Define five components of a problem. Write a complete state space for a
vacuum cleaner to clean 2 squares P and Q. Q is to the right of P

Five Components of a Problem in AI

When solving an AI problem, the problem can be broken down into five key
components. These components help define the task and how the solution can be
approached:
1. InitialState:
The initial state is where the agent starts in the environment. It defines the
starting conditions or the starting point of the task.
o For example, in the vacuum cleaner problem, the initial state could be the
vacuum cleaner starting at square P, with both squares (P and Q) possibly
being dirty.
2. Actions:
Actions are the operations the agent can perform to change its state. These
actions help the agent transition from one state to another.
o In the vacuum cleaner example, the actions could include:
▪ Move Left: Move the vacuum cleaner from P to Q.
▪ Move Right: Move the vacuum cleaner from Q to P.
▪ Clean: Clean the square the vacuum cleaner is currently in.
3. Transition Model:
The transition model defines the result of each action, describing how the
environment changes when an action is performed.
o In the vacuum cleaner example, after performing an action like “clean,” the
state of the square changes from dirty to clean. Moving from one square
to another simply changes the position of the vacuum cleaner without
affecting the dirtiness of the squares.
4. GoalState:
The goal state is the desired state that the agent aims to reach. It represents the
condition that the agent needs to achieve to consider the task completed.
o In the vacuum cleaner problem, the goal state would be both squares (P
and Q) being clean, and the vacuum cleaner being either in P or Q (the
exact location doesn’t matter as long as both squares are clean).
5. PathCost:
The path cost measures the cost of the actions taken to reach the goal state.
The agent seeks to minimize this cost, which could be measured in terms of
time, steps, or resources used.
o In this case, the path cost could be the number of moves or actions
(cleaning and moving) the vacuum cleaner takes to clean both squares.
Complete State Space for Vacuum Cleaner (P and Q)
Let’s define the state space for a vacuum cleaner tasked with cleaning two squares (P and Q):
• States: A state in this problem is represented by a tuple (Position, P, Q), where:
o Position indicates where the vacuum cleaner is (either P or Q).
o P represents the cleanliness of square P (clean or dirty).
o Q represents the cleanliness of square Q (clean or dirty).
Let’s assume:
• Clean = 1 (the square is clean).
• Dirty = 0 (the square is dirty).
The vacuum cleaner can start in any of the two squares, and each square can be either
clean or dirty.

States for the Vacuum Cleaner Problem

1. (P, 0, 0): The vacuum cleaner is at square P, and both squares (P and Q) are dirty.
2. (P, 0, 1): The vacuum cleaner is at square P, square P is dirty, and square Q is
clean.
3. (P, 1, 0): The vacuum cleaner is at square P, square P is clean, and square Q is
dirty.
4. (P, 1, 1): The vacuum cleaner is at square P, and both squares (P and Q) are clean.
5. (Q, 0, 0): The vacuum cleaner is at square Q, and both squares (P and Q) are
dirty.
6. (Q, 0, 1): The vacuum cleaner is at square Q, square P is dirty, and square Q is
clean.
7. (Q, 1, 0): The vacuum cleaner is at square Q, square P is clean, and square Q is
dirty.
8. (Q, 1, 1): The vacuum cleaner is at square Q, and both squares (P and Q) are
clean.

Actions and Transitions:

The vacuum cleaner can perform the following actions:
• Clean: Clean the current square the vacuum cleaner is at.
• Move Left: Move from square Q to square P.
• Move Right: Move from square P to square Q.

Example Transitions:
• Starting at (P, 0, 0) (both squares dirty), the vacuum cleaner can:
o Clean P → Transition to (P, 1, 0) (P cleaned).
o Move Right → Transition to (Q, 0, 0) (vacuum moves to Q, both squares
still dirty).
• If the vacuum cleaner is at (Q, 0, 0), it can:
o Clean Q → Transition to (Q, 0, 1) (Q cleaned).
 o Move Left → Transition to (P, 0, 0) (vacuum moves back to P, both squares
still dirty).

Goal State:
The goal state is when both squares are clean. So, the goal state is (P, 1, 1) or (Q, 1, 1),
where both P and Q are clean.

Path Cost:
The path cost can be counted as the number of actions the vacuum cleaner takes,
such as cleaning or moving between squares.

8. Compare and contrast the time , space complexity ,optimality , completeness

for Breadth first search and Depth First Search algorithms

1. Time Complexity:
• BFS:
o O(b^d): BFS explores every level of the tree or graph, and in the worst
case, it needs to explore all possible nodes. Here, b is the branching factor
(average children per node) and d is the depth of the goal.
• DFS:
o O(b^d): DFS also explores all nodes in the worst case, but it may explore
deeply into one branch before considering others. The time complexity is
the same as BFS in the worst case.
Comparison: Both BFS and DFS have the same time complexity in the worst case,
O(b^d).

2. Space Complexity:
• BFS:
o O(b^d): BFS stores all the nodes at each level in the queue, so its space
requirement is high, especially when the tree or graph is large.
• DFS:
o O(bd): DFS uses a stack to keep track of the path it's currently exploring,
so it only needs to store nodes in that path. This results in lower space
complexity compared to BFS.
Comparison: DFS requires less memory (space) than BFS.

3. Optimality:
• BFS:
o Optimal: BFS guarantees the shortest path to the goal because it explores
all nodes at one level before moving to the next level.
 • DFS:
o Not Optimal: DFS can find a solution but doesn't guarantee it's the
shortest. It might explore a long path before finding a goal.
Comparison: BFS is optimal for finding the shortest path, while DFS is not guaranteed
to find the best solution.

4. Completeness:
• BFS:
o Complete: If there is a solution, BFS will always find it, as it checks all nodes
level by level.
• -DFS:
o Not Always Complete: If there are infinite paths or loops, DFS may get
stuck and fail to find a solution.
Comparison: BFS is complete, while DFS may not always find a solution in infinite or
cyclic spaces.

9. Explain Iterative deepening Depth first search algorithm with an example

Iterative Deepening Depth-First Search (IDDFS) Algorithm

Iterative Deepening Depth-First Search (IDDFS) is a combination of two search
strategies: Depth-First Search (DFS) and Breadth-First Search (BFS). It aims to
combine the memory efficiency of DFS with the optimality of BFS.

In IDDFS, the algorithm performs a series of DFS searches, starting with a depth of 0
(just the root), and increases the depth limit by one after each search, until it reaches
the solution or the maximum depth. This way, it explores all nodes at the shallowest
depth first, like BFS, but uses the memory efficiency of DFS.

Steps in IDDFS:
 1. Start with depth limit 0: Perform a DFS up to depth 0 (just the starting node).

2. Increase depth limit: Increase the depth limit by 1 and perform a DFS again up
to this new limit.

3. Repeat: Continue this process until the goal is found or the maximum depth is
reached.

Example:

Let’s consider a simple tree and find a solution using IDDFS.

Here, we want to find node G.

1. First Iteration (Depth Limit = 0):

o Start at A. No child nodes are explored at this level (depth 0), so we

move on to the next iteration.

2. Second Iteration (Depth Limit = 1):

o Start at A. Explore its child nodes B and C. Since G is not at depth 1,

move to the next iteration.
3. Third Iteration (Depth Limit = 2):

o Start at A. Explore B and C.

o For B, explore its children D and E. For C, explore F.

o Still no G found, so increase the depth limit and repeat.

4. Fourth Iteration (Depth Limit = 3):

o Start at A. Explore B, C, D, E, F.

o For B, explore D and E.

 o For D, go deeper and find G at depth 3.

At depth 3, the solution G is found. IDDFS would stop here.

10.For an automatic taxi driver application, explain Goal and utility agents with
appropriate block diagrams

Explanation of Goal and Utility Agents in an Automatic Taxi Driver Application

In the context of an automatic taxi driver application, Goal-Based Agents and Utility-
Based Agents are two types of intelligent agents that help the taxi achieve its
objectives effectively.

1. Goal-Based Agents

A Goal-Based Agent acts based on predefined goals. It selects actions that will lead
to the achievement of these goals. In the taxi driver application, the goal can be to
safely transport passengers from the pickup location to the destination.

Key Features:

• The agent decides actions by evaluating how well they achieve the goal.
• It does not consider the "quality" of the solution but only ensures the goal is met.

Example in Taxi Application:

• Goal: Drive the passenger from point A to point B.

• Actions: Avoid obstacles, follow traffic rules, and stop at the destination.

• Perception: The taxi detects the current location, obstacles, and passenger
instructions.
• Decision-making: Based on the goal (destination), the taxi plans the route and
avoids obstacles.
• Action: Execute the planned actions, like turning, accelerating, or stopping.
2. Utility-Based Agents

A Utility-Based Agent goes a step further than a Goal-Based Agent. It evaluates not
just achieving the goal but also how "good" or "efficient" each action is, based on a
utility function. In the taxi driver application, it considers factors like fuel efficiency,
shortest route, time, and passenger comfort to optimize the journey

Key Features:

• Considers both achieving the goal and maximizing utility.

• Balances multiple factors to provide the best overall outcome.

Example in Taxi Application:

• Goal: Drive the passenger from point A to point B.

• Utility Function: Minimize time, fuel consumption, and maximize passenger comfort.

• Actions: Choose the shortest or least congested route, maintain smooth

driving, and avoid sharp turns.

• Perception: The taxi monitors current traffic conditions, fuel levels, and
passenger preferences.
• Decision-making: Evaluates possible routes and actions based on a utility
function.
Action: Execute the action that maximizes overall utility (e.g., taking a less
congested route).
Conclusion:

In an automatic taxi driver application, Goal-Based Agents ensure the taxi meets its
primary objective (reaching the destination), while Utility-Based Agents optimize
the process, improving overall efficiency and passenger satisfaction. Both play crucial
roles in intelligent decision-making

11.Given a 3×3 board with 8 tiles (each numbered from 1 to 8) and one empty
space in a 8-puzzle Problem as shown in the figure below. Place the numbers
so as to match the final configuration using DFS and BFS. We can slide four
adjacent tiles (left, right, above, and below) into the empty space.

Initial State:

The initial state of the puzzle is:

123

560

784

Goal State:

The goal state is:

123

586

074

DFS Solution

1. Start at the Initial State: Place the initial state on the stack.

2. Pop and Expand: Pop the top state from the stack. Generate all possible
successor states by sliding tiles adjacent to the empty space.
 3. Check for Goal: If a successor state matches the goal state, the solution is
found.

4. Push Successors: Push the generated successor states onto the stack.

5. Repeat: Continue steps 2-4 until the stack is empty or the goal state is reached.

BFS Solution

1. Start at the Initial State: Enqueue the initial state.

2. Dequeue and Expand: Dequeue the front state from the queue. Generate all
possible successor states.
3. Check for Goal: If a successor state matches the goal state, the solution is
found.

4. Enqueue Successors: Enqueue the generated successor states at the rear of the
queue.

5. Repeat: Continue steps 2-4 until the queue is empty or the goal state is
reached.

Analysis

• DFS: DFS might explore irrelevant paths and potentially get stuck in loops,
especially if the search space is large. It might not find the shortest solution.

• BFS: BFS guarantees to find the shortest solution path (if one exists) because it
explores all nodes at a given depth before moving to the next level. However,
it can require more memory as it needs to store all nodes at a particular level.

Manual Solution Visualization:

The provided image shows the sequence of moves leading to the final state. Each
step represents a move made by sliding a tile into the empty space.

Step 1: Initial

123

560

784

Step 2:

123

506
784

Step 3:

123

586

704

Step 4: Final

123

586

074

In this example, the solution is found in 3 moves.

Note:

• Manually performing DFS and BFS can be time-consuming, especially for

larger search spaces.

• This is a simplified example. In more complex scenarios, it's often more

practical to use a computer program to implement the search algorithms.

12.With an algorithm explain Depth limited search

Depth Limited Search (DLS) is a modified version of Depth First Search (DFS),
designed to limit the search depth to a specified level, preventing it from going too
deep and potentially getting stuck in infinite loops. It is a type of uninformed
search algorithm used in AI for traversing or searching tree-like structures (such as
game trees, decision trees, or problem-solving spaces).

Algorithm Explanation:

1. Input:

o The root node of the search tree.

o A depth limit LL, which is the maximum depth the search can reach.

2. Process:
o Start at the root node.

o Explore each branch of the tree by recursively expanding the child nodes.
 o Keep track of the current depth in the search. If the depth exceeds the
limit LL, stop exploring further down that branch.

o If a solution (goal state) is found at or within the limit, return it. If the
limit is reached without finding a goal, backtrack and explore other
branches.

o If no solution is found within the depth limit, report that the search
failed.

3. Termination:

o The algorithm terminates when either:

▪ The goal is found within the allowed depth.

▪ The algorithm has explored all nodes up to the depth limit and has
not found a solution.

13. The missionaries and cannibals problem is stated as follows. Three

missionaries and three cannibals are on one side of a river, along with a boat
that can hold one or two people. Find a way to get everyone to the other side
without ever leaving a group of missionaries in one place outnumbered by the
cannibals in that place
a. Formulate the problem precisely, making only those distinctions necessary to
ensure a valid solution. Draw a diagram of the complete state space.

b. Implement and solve the problem optimally using an appropriate search

algorithm. Is it a good idea to check for repeated states?

Part a: Formulation of the Missionaries and Cannibals Problem

ProblemStatement:
We have 3 missionaries (M) and 3 cannibals (C) on one side of a river, along with a
boat that can carry at most 2 people. The goal is to get all the missionaries and
cannibals across the river without violating the rule that at no time can the number of
cannibals outnumber the missionaries on either side of the river.

State Space Representation:

Each state can be represented as a 4-tuple:

(M_L, C_L, M_R, C_R)

Where:

• M_L: The number of missionaries on the left bank of the river.

• C_L: The number of cannibals on the left bank of the river.

• M_R: The number of missionaries on the right bank of the river.

• C_R: The number of cannibals on the right bank of the river.

Initially:

• (M_L,C_L,M_R,C_R)=(3,3,0,0)
Where all the missionaries and cannibals are on the left side of the river.
Goal state:

• (M_L,C_L,M_R,C_R)=(0,0,3,-3)
Where all the missionaries and cannibals are safely on the right side of the river.

Constraints:

• At no point on either side of the river can the number of cannibals exceed the
number of missionaries (i.e., M_L ≥ C_L and M_R ≥ C_R on both sides).

Possible Actions:

• One or two people (missionaries or cannibals) can cross the river in the boat.
 • The boat can either go from the left bank to the right bank or from the right
bank to the left bank.

• At each step, one or two people move, and the state of the system changes
accordingly.

Diagram of the State Space:

The state space can be visualized as a graph where each node represents a state, and
the edges represent valid actions (movements of one or two people between the
banks). Below is a simplified diagram of the initial states and possible actions.

The nodes are marked as (M_L, C_L, M_R, C_R), and arrows represent valid moves
between states.
The diagram would continue expanding in a similar fashion until the goal state is reached.

Part b: Solving the Problem using a Search Algorithm

To solve this problem, an appropriate search algorithm needs to be used. Breadth-

First Search (BFS) is a good choice because it will find the optimal solution (i.e., the
fewest number of moves) due to its nature of exploring all possible states level by level.

Steps to Implement BFS for the Missionaries and Cannibals Problem:

1. Initialize the search:

o Begin from the initial state (3, 3, 0, 0) and add it to the open list.

2. State exploration:

o At each step, explore all valid actions (i.e., possible boat movements that
do not violate the constraints).
o Generate the next states and check if they lead to the goal state (0, 0, 3, 3).

3. Goal test:

o The goal state is when all missionaries and cannibals are on the right side
of the river.
4. Termination:

o Once the goal state is found, backtrack to trace the optimal sequence of
moves.

Is It a Good Idea to Check for Repeated States?

Yes, it is a good idea to check for repeated states in this problem. Without checking
for repeated states, the search algorithm could re-explore the same states multiple
times, leading to inefficiency and longer computation time. This problem has a large
state space, and without pruning (checking for repeated states), the search would
become exponentially larger as it would revisit the same states multiple times. By
keeping track of visited states, the algorithm can avoid unnecessary work, ensuring
that it explores each state only once.

Example BFS Execution:

1. Start at (3, 3, 0, 0)

2. Generate valid actions and explore the resulting states.

3. Add valid states to the queue and continue until the goal state (0, 0, 3, 3) is
reached.

14.Define in your own words the following terms: state, state space, search
tree, search node, goal, action, transition model, and branching factor.

1. State: A state is a specific situation or condition in a problem. It represents a

snapshot of the system at any point in time, showing the current values or
situation of all relevant variables.

2. State Space: The state space is the collection of all possible states that can be
reached from the initial state, by applying actions over time. It’s like a map that
shows all possible situations that can occur during the problem-solving
process.

3. Search Tree: A search tree is a graphical representation of the process of

searching through states to find a solution. Each node in the tree represents a
state, and edges represent the actions that transition from one state to
another.

4. Search Node: A search node represents a state in the search process. It

contains information about the current state, the parent node (previous state),
and the action taken to reach that state.

5. Goal: The goal is the target state or condition we aim to reach while solving
the problem. It represents the desired outcome or solution to the problem.

6. Action: An action is a step or operation that moves from one state to another.
It transforms the current state into a new state based on certain rules.

7. Transition Model: The transition model describes how actions move from one
state to another. It defines the rules or mechanisms that explain how states
evolve when an action is applied.
 8. Branching Factor: The branching factor is the number of possible actions (or
child nodes) that can be taken from any given state. It’s a measure of how
many choices are available at each step in the search tree.

15. Outline a generic knowledge-based agents’ program. Write PEAS

specification for Wumpus world.

Generic Knowledge-Based Agent Program:

A knowledge-based agent operates by using a knowledge base (KB) to make

decisions. It works in the following way:

1. Perceive: The agent perceives the environment and gathers information using
sensors.

2. Reason: It processes this information using its knowledge base and reasoning
mechanisms to make inferences and conclusions.

3. Decide: Based on the reasoning, the agent decides on an action to take.

4. Act: The agent takes action using actuators to affect the environment.

The core components are:

• Knowledge Base (KB): A collection of facts and rules that represent the
agent's knowledge about the world.

• Inference Mechanism: A process that helps the agent derive new knowledge
from the existing knowledge base.

• Reasoning: The agent uses logical or probabilistic reasoning to make

decisions.

• Learning: If applicable, the agent may improve its knowledge over time based
on experience.

PEAS Specification for Wumpus World:

PEAS stands for Performance measure, Environment, Actuators, and Sensors. Here's
the PEAS specification for the Wumpus World:

1. Performance Measure:

o The goal is to find the gold and bring it back to the starting point,
avoiding pits and the Wumpus. A good performance is when the agent
collects the gold, survives, and returns to the start.

o Negative points for falling into a pit or being eaten by the Wumpus.
 o Positive points for collecting the gold and safely exiting.

2. Environment:

o A grid world with 4x4 or larger dimensions.

o The environment contains:

▪ Wumpus: A dangerous creature that kills the agent if it is in the

same square.

▪ Pits: Dangerous areas that kill the agent.

▪ Gold: The target that the agent must find.

▪ Empty squares: Safe areas where the agent can move.

o The environment is partially observable (the agent only knows about

adjacent squares).

3. Actuators:

o The agent can move in the four cardinal directions (North, South, East,
West).

o The agent can grab the gold when it is on the same square as the gold.

o The agent can shoot an arrow to kill the Wumpus (if the Wumpus is in a
line of sight).

4. Sensors:

o The agent can detect the following:

▪ Breeze: Indicates a pit in an adjacent square.

▪ Stench: Indicates the Wumpus is in an adjacent square.

▪ Glitter: Indicates the gold is in the current square.

▪ Smell of the Wumpus: Detects the Wumpus's presence in the same

room.

This PEAS specification outlines how the knowledge-based agent functions in the
Wumpus World environment, using sensors to gather information, actuators to
perform actions, and a performance measure to evaluate success.

16.
Apply the A* search to find the solution path from a to z. Heuristics are with
nodes, and cost is with edges. Write all steps as well as open and closed lists for
full marks.

Heuristics and Costs:

• Heuristics (h): We'll use the estimated cost to reach the goal node 'z' from
each node. The heuristic values are provided next to the nodes in the image.

• Costs (c): The cost of traversing each edge is given by the values on the
edges.

A* Search Algorithm:

1. Initialization:

o Create an OPEN list and a CLOSED list. Initially, the OPEN list contains
only the start node 'a' with its f(n) value calculated as:

o f(a) = g(a) + h(a) = 0 + 14 = 14

where g(a) is the cost to reach 'a' from the start (0 in this case).

2. Iteration:

o Select Node: Select the node with the lowest f(n) value from the OPEN
list. In this case, it's 'a'.

o Expand Node: Remove the selected node ('a') from the OPEN list and
add it to the CLOSED list. Generate all successor nodes of 'a' (nodes
connected to 'a' by an edge).
 o Evaluate Successors: For each successor node:

▪ Calculate g(n) as the cost to reach the successor from the start node .

▪ Calculate h(n) using the heuristic value provided.

▪ Calculate f(n) = g(n) + h(n).

▪ If the successor is already in the OPEN list, check if the new path to
it has a lower cost. If so, update its g(n), f(n), and parent.

▪ If the successor is not in the OPEN or CLOSED lists, add it to the

OPEN list with its calculated f(n), g(n), h(n), and set its parent as the
current node.

o Repeat: Repeat steps 2 and 3 until the goal node 'z' is selected from the
OPEN list.

Step-by-Step Solution:

1. Initial State:

o OPEN: {a(14)}

o CLOSED: {}

2. Expand a:

o OPEN: {b(16), c(17)}

o CLOSED: {a}

3. Expand b:

o OPEN: {c(17), f(27), e(26)}

o CLOSED: {a, b}
4. Expand c:

o OPEN: {f(27), e(26), d(24)}

o CLOSED: {a, b, c}

5. Expand e:

o OPEN: {f(27), d(24), z(31)}

o CLOSED: {a, b, c, e}

6. Expand d:
 o OPEN: {f(27), z(31)}

o CLOSED: {a, b, c, e, d}

7. Expand f:

o OPEN: {z(31)}

o CLOSED: {a, b, c, e, d, f}

8. Expand z:

o OPEN: {}

o CLOSED: {a, b, c, e, d, f, z}

Solution Path:

The solution path is found to be: a -> c -> d -> e -> z with a total cost of 31.

Note:

• The heuristic values used in this example are admissible (i.e., they never
overestimate the actual cost to the goal). This is crucial for A* search to
guarantee finding the optimal solution.

• If multiple nodes have the same f(n) value, you can choose any of them to
expand next. This can lead to different solution paths, but the cost of the
optimal path will remain the same.

17.Explain forward chaining and backward chaining in propositional logic

with examples
18. Convert the following sentence B1,1 ⇔ (P1,2 ∨ P2,1) into CNF giving
detailed steps
19.Explain various reasons for failure of First Order Logic Define a sample space
for picking 2 tokens from 6 tokens of lab questions with token taken first time
is not replaced.

Failure of First-Order Logic (FOL) in AI

First-Order Logic (FOL) is a widely used formal system for representing knowledge
and reasoning. However, despite its strengths, FOL faces several limitations,
especially in practical AI applications. Below are the various reasons for the failure or
limitations of First-Order Logic:

1. Incomplete Knowledge Representation:

• Explanation: FOL requires all knowledge to be explicitly stated. It cannot

handle situations where some knowledge is implicit or unknown. In complex
real-world situations, it is difficult to capture all the nuances and context
needed for accurate reasoning.
• Example: Consider the statement "John is tall." FOL would require a strict
definition of "tall," but in practice, what is considered "tall" may vary
depending on context (e.g., country, age group).

2. Lack of Handling Uncertainty:

• Explanation: FOL assumes that knowledge is either true or false, which works
well for certain problems but fails in uncertain or incomplete scenarios. Real-
world problems often involve probabilities or uncertain facts that FOL cannot
handle directly.

• Example: If a weather forecast states, "It is likely to rain tomorrow," FOL

cannot represent this uncertainty. It only works with clear true/false facts like
"It will rain tomorrow."

3. Difficulty with Default Assumptions and Exceptions:

• Explanation: FOL struggles to handle situations where general rules have

exceptions. It assumes that all facts are either true or false, which makes it hard
to account for default reasoning where most things hold true, but there are
exceptions.

• Example: A general rule might be "All birds can fly." However, an exception
exists with birds like penguins and ostriches, which cannot fly. FOL needs
explicit rules for every exception, which is inefficient.

4. Complexity of Computation:
 • Explanation: FOL can become computationally expensive, especially when
reasoning with large knowledge bases. The process of inference can require
exhaustive searches through many possibilities, which becomes impractical for
large-scale problems.

• Example: In a situation with many rules and facts, FOL may take too long to
draw conclusions because it has to check many combinations of these rules.

5. Inability to Handle Commonsense Reasoning:

• Explanation: FOL is rigid and does not support commonsense reasoning well.
Human reasoning often involves making assumptions, filling in missing
information, or using intuition—tasks that FOL struggles with.

• Example: If someone says, "John is in the kitchen," a human might infer that
John is inside the house, but FOL would need a strict rule or fact explicitly
stating that kitchens are inside houses.
6. Identity and Equality Problems:

• Explanation: FOL deals with objects and their properties, but it sometimes has
difficulty with identity (i.e., determining if two objects are the same) or equality
in complex domains. Handling this requires special care and definitions.

• Example: If you have two different representations of the same object, FOL
may fail to recognize them as the same object unless explicitly stated.

Sample Space for Picking 2 Tokens from 6 Tokens (Without Replacement)

Now, let's define the sample space for the problem of picking 2 tokens from 6
tokens, where the token chosen the first time is not replaced.

Given:
• There are 6 tokens labelled T1 , T2 , T3 , T4 , T5 , T6

• Two tokens are chosen in sequence without replacement.

Step 1: Understand the Experiment

• We are selecting two tokens sequentially.

• Since we are not replacing the token after it is selected, the number of tokens
decreases after the first selection.
 • The order in which the tokens are selected matters because the tokens are not
replaced.

Step 2: Possible Outcomes

For each selection:

1. For the first token, we can choose from 6 possible tokens.

2. After the first token is selected, for the second token, we have 5 remaining
tokens to choose from.

Thus, the total number of possible outcomes is:

6 x 5 = 30

Step 3: List All Possible Outcomes

Each outcome is a pair of tokens chosen in sequence. We can list all the possible
outcomes as follows:

This gives us 30 possible ordered pairs of tokens

Step 4: Conclusion

The sample space consists of 30 possible ordered pairs (since the selection order
matters and tokens are not replaced).

The sample space is:

This represents all the possible outcomes of selecting 2 tokens from the 6 available
tokens without replacement.

There are 30 outcomes in total, as shown by the list of pairs

(Summary:
 • Failure of First-Order Logic: Issues such as incomplete knowledge
representation, handling uncertainty, inability to deal with exceptions, and
computational complexity are the main reasons for FOL's limitations in real-
world AI applications.

• Sample Space for Picking 2 Tokens from 6: When selecting 2 tokens from 6
tokens without replacement, the total number of possible ordered outcomes is
30, and the sample space consists of 30 pairs of tokens.)

20. Define Universal and Existential Instantiation and give examples for both.
Prove the following using Backward and Forward chaining: "As per the law, it is
a crime for an American to sell weapons to hostile nations. Country E, an
enemy of America, has some missiles, and all the missiles were sold to it by
Solan, who is an American citizen." Prove that "Solan s criminal."
21.Complete the following exercises about logical sentences:

a. Translate into good, natural English (no xs or ys!):

∀ x, y, l Speaks Language (x, l) ∧ Speaks Language (y, l)

⇒ Understands (x, y) ∧ Understands (y, x).

b. Explain why this sentence is entailed by the sentence

∀ x, y, l Speaks Language(x, l) ∧ Speaks Language(y, l)

⇒ Understands (x, y).

c. Translate into first-order logic the following sentences:

(i) Understanding leads to friendship.

(ii) Friendship is transitive.

Remember to define all predicates, functions, and constants you use

22.Write appropriate quantifiers for the following

(i) Some students read well

(ii) Some students like some books

(iii) Some students like all books

(iv) All students like some books

(v) All students like no books

Explain the concept of Resolution in First Order Logic with appropriate procedure
Resolution in First-Order Logic

What is Resolution?

Resolution is a technique used in First-Order Logic (FOL) to prove statements. It checks if

a goal (a logical sentence) is true by deriving a contradiction.

Procedure:

1. Convert Statements to Clausal Form:

o Rewrite all statements into conjunctive normal form (CNF), which is a

conjunction of disjunctions of literals.

2. Negate the Goal:

o Negate the statement you want to prove and add it to the set of clauses.

3. Apply Resolution Rule:

o Combine clauses containing complementary literals (e.g., P and ¬P) to create

new clauses. This process eliminates complementary literals.

4. Check for Contradiction:

o If an empty clause (⊥) is derived, it means the negated goal is false, so
the original goal is true.
23.Consider a knowledge base containing just two sentences: P(a) and P(b). Does
this knowledge base entail ∀x P(x)? Explain your answer in terms of models.
24. Show from first principles that P(a | b ∧ a) = 1.
25. Let continuous variables X1, . . . ,Xk be independently distributed according to the
same probability density function f(x). Prove that the density function for max{X1, . .
. ,Xk} is given by kf(x)(F(x))k−1, where F is the cumulative distribution for f.
26.
27.The convex composition [a, q1; 1 − a, q2] of q1 and q2 is a transition probability
distribution, that first chooses one of q1 and q2 with probabilities a and 1 − a,
respectively, and then applies whichever is chosen. Prove that if q1 and q2 are in
detailed balance with π, then their convex composition is also in detailed balance
with π. (Note: this result justifies a variant of GIBBS-ASK in which variables are
chosen at random rather than sampled in a fixed sequence.)

b. Prove that if each of q1 and q2 has π as its stationary distribution, then the
sequential composition q =q1 ◦ q2 also has π as its stationary distribution.
28. Using the axioms of probability, prove that any probability distribution on a
discrete random variable must sum to 1.
Conclusion:

Using the axioms of probability, we have proved that the probabilities in a discrete random
variable's distribution must always sum to 1. This ensures that the total likelihood of all
possible outcomes covers the entire sample space.

29.We have a bag of three biased coins a, b, and c with probabilities of coming up
heads of 20%, 60%, and 80%, respectively. One coin is drawn randomly from the bag
(with equal likelihood of drawing each of the three coins), and then the coin is
flipped three times to generate the outcomes X1, X2, and X3.
a. Draw the Bayesian network corresponding to this setup and define the necessary CPTs.

b. Calculate which coin was most likely to have been drawn from the bag if the
observed flips come out heads twice and tails once