Q.P.

Code – 23CSC201

Second Semester M.Sc. Degree Examination, September 2024

(CBCS Scheme)

Computer Science

Paper CPT 2.1 – ARTIFICIAL INTELLIGENCE

Time: 3 Hours]

[Max. Marks: 70

Instructions to Candidates: Answer all the mains.

1. Answers any TEN questions of the following: (10 x 2 = 20)

1. Answer in Brief:

(a) Define variable binding.

A variable is said to be a bound variable in a formula if it occurs within the scope of the

Example: ∀x [A (x) B( y)], here x and y are the bound variables

quantifier.
 (b)In which scenarios depth first search would be efficient instead of
breadth first search?

Depth-First Search (DFS) is more efficient than Breadth-First Search (BFS) in

the following scenarios:

*1. Searching in a deeply nested graph or tree*:

*2. Finding connected components*:

*3. Topological sorting*:

*4. Finding strongly connected components*:

*5. Solving puzzles and games*:

*6. File system traversal*:

© What is week/soft AI?

Weak or Narrow AI, also known as Soft AI, refers to artificial intelligence
systems designed to perform a specific task or set of tasks, typically within a
limited domain or context.
 (c) State the Bayes’ rule.
2. Bayes' Rule:
3. Bayes' Theorem:*
4.
5. P(H|E) = P(E|H) × P(H) / P(E)
6.
7.
8. *Where:*
9.
10. P(H|E) = Posterior probability (probability of hypothesis H given
evidence E)
11.
12. P(E|H) = Likelihood (probability of evidence E given hypothesis
H)
13.
14. P(H) = Prior probability (probability of hypothesis H before
considering evidence E)
15.
16. P(E) = Normalizing constant (probability of evidence E under all
possible hypotheses)

€ List out the Implementation challenges in representation of resource

constraints.

Implementation Challenges in Representation of Resource Constraints in AI:

*Computational Complexity Challenges*

1. NP-hardness: Many resource constraint problems are computationally
intractable.

2. Scalability: Large problem instances can be difficult to solve.

3. Real-time processing: AI systems require fast processing for real-time

decision-making.

*Knowledge Representation Challenges*

1. Formalizing domain knowledge: Difficulty in representing complex

resource constraints.

2. Ontology development: Creating and maintaining relevant ontologies.

3. Data quality: Inaccurate or incomplete data affects constraint

representation.

*Reasoning and Inference Challenges*

1. Consistency checking: Ensuring constraint satisfaction.

2. Conflict resolution: Handling conflicting constraints.

3. Uncertainty handling: Reasoning with uncertain or incomplete information.

*Optimization Challenges*

1. Multi-objective optimization: Balancing competing resource constraints.

2. Constraint relaxation: Finding optimal trade-offs.

3. Dynamic optimization: Adapting to changing resource constraints.

*Integration Challenges*

1. Integrating with existing systems: Incorporating resource constraints into

legacy AI systems.

2. Interoperability: Ensuring seamless communication between different AI

components.

*Explainability and Transparency Challenges*

1. Interpretability: Understanding constraint-based decision-making.

2. Justification: Providing explanations for resource allocation.

*Resource-Specific Challenges*

1. Time constraints: Representing time-dependent resource availability.

2. Spatial constraints: Modeling spatially-dependent resource allocation.

3. Financial constraints: Representing budgetary limitations.

*Domain-Specific Challenges*

1. Healthcare: Representing patient-specific resource constraints.

2. Finance: Modeling market-specific resource constraints.

3. Logistics: Optimizing resource allocation for supply chain management.

*Solution Approaches*
1. Constraint Programming (CP)

2. Mathematical Programming (MP)

3. Satisfiability (SAT) Solvers

4. Heuristics and Metaheuristics

5. Machine Learning (ML) and Deep Learning (DL)

*Best Practices*

1. Formalize domain knowledge

2. Use standardized representation languages

3. Implement incremental constraint satisfaction

4. Utilize explanation generation techniques

5. Monitor and adapt to changing resource constraints

Addressing these implementation challenges enables

effective representation of resource constraints in AI
 systems, leading to more efficient and informed decision-
making.

(1)List out the limitations of iterative deepening A search

technique.
17. Limitations of Iterative Deepening Depth-First Search (IDDFS):
18.
19.
20. *Computational Complexity*
21.
22.
23. 1. Increased time complexity due to repeated searches
24. 2. Higher computational overhead
25.
26.
27. *Search Efficiency*
28.
29.
30. 1. Inefficient for very large search spaces
31. 2. May get stuck in infinite loops
32. 3. Difficulty handling cyclic graphs
33.
34.
35. *Optimality*
36.
37.
38. 1. Not guaranteed to find optimal solution
39. 2. May settle for suboptimal solution
40.
41.
42. *Completeness*
43.
44.
45. 1. Not complete for graphs with negative weights
46. 2. May miss solutions due to depth limits
47.
48.
49. *Space Complexity*
50.
51.
52. 1. Requires additional memory for iterative searches
53. 2. Higher memory usage
54.
55.
56. *Real-Time Performance*
57.
58.
59. 1. Not suitable for real-time systems
60. 2. May cause delays
61.
62.
63. *Parallelization*
64.
65.
66. 1. Difficult to parallelize
67. 2. Limited scalability
68.
69.
70. *Heuristic Guidance*
71.
72.
73. 1. Limited guidance from heuristics
74. 2. May not utilize heuristics effectively
75.
76.
77. *Comparison to Other Algorithms*
78.
79.
80. 1. Less efficient than A* search for informed searches
81. 2. Less effective than Breadth-First Search (BFS) for unweighted
graphs
82. 3. Less scalable than Dijkstra's algorithm for large graphs
83.
84.
85. *Other Limitations*
86.
87.
88. 1. Depth limits may not be effective
89. 2. May require manual tuning of parameters
 90. 3. Limited handling of dynamic environments
91. 4. Difficulty handling uncertain or probabilistic environments
92.
93.
94. *Mitigation Strategies*
95.
96.
97. 1. Use informed search heuristics
98. 2. Implement iterative deepening with bounded depth
99. 3. Utilize bidirectional search
100. 4. Combine IDDFS with other search algorithms
101. 5. Optimize search parameters
102.
103.
104. To overcome these limitations, consider combining IDDFS with
other search techniques or using more advanced algorithms like:
105.
106.
107. 1. A* search
108. 2. Dijkstra's algorithm
109. 3. Bidirectional search
110. 4. Breadth-First Search (BFS)
111. 5. Best-First Search (BFS)
112.
113.
114. IDDFS remains a useful technique for:
115.
116.
117. 1. Small to medium-sized search spaces
118. 2. Simple search problems
119. 3. Educational purposes
120.
121.
122. Carefully evaluate the trade-offs and limitations of IDDFS before
applying it to your specific problem.

(g) What is declarative knowledge?

Declarative knowledge, also known as descriptive knowledge, is a type of

knowledge that describes facts, concepts, and relationships.
Characteristics:

1. Statements of fact

2. Descriptive

3. Propositional

4. Explicit

5. Factual

Examples:

1. Historical events

2. Scientific facts

3. Definitions

4. Geographic information

5. Procedures

Types:

1. Semantic knowledge (meaning-based)

2. Episodic knowledge (event-based)

3. Procedural knowledge (action-based)

Declarative Knowledge Involves:

1. Knowing that (facts)

2. Understanding concepts

3. Recognizing relationships

4. Recalling information

Contrast with Procedural Knowledge:

1. Knowing how (skills)

2. Performing tasks

3. Executing procedures

Acquisition:

1. Learning through instruction

2. Reading

3. Experience

4. Observation
Representation:

1. Propositional networks

2. Semantic networks

3. Frames

4. Ontologies

Importance:

1. Foundation for problem-solving

2. Enables reasoning

3. Supports decision-making

4. Facilitates communication

Applications:

1. Expert systems

2. Knowledge graphs

3. Natural Language Processing (NLP)

4. Artificial Intelligence (AI)

5. Education

Declarative knowledge provides:

1. Context for procedural knowledge

2. Framework for understanding

3. Basis for inference

4. Support for critical thinking

Notable Theories:

1. Knowledge Representation Theory

2. Semantic Network Theory

3. Frame Theory

Cognitive Science and AI applications heavily rely on declarative knowledge

for:

1. Knowledge representation

2. Reasoning

3. Decision-making
4. Natural Language Understanding

Declarative knowledge serves as the foundation for:

1. Building intelligent systems

2. Supporting human learning

3. Enhancing decision-making

Understanding declarative knowledge helps:

1. Develop more effective AI systems

2. Improve knowledge representation

3. Enhance human learning and memory.

(h) Define Belief networks.

Belief Networks, also known as Bayesian Networks (BNs), are probabilistic

graphical models representing relationships between variables.

*Definition:*

A Belief Network is a directed acyclic graph (DAG) consisting of:

1. Nodes (vertices): Representing random variables or hypotheses.

2. Edges (arcs): Representing conditional dependencies between variables.

3. Conditional Probability Tables (CPTs): Assigning probabilities to each node

given its parents.

*Key Components:*

1. Nodes:

- Random variables (discrete or continuous)

- Hypotheses or events

2. Edges:

- Directed (causal or conditional)

- Undirected (associative)

3. CPTs:

- Probability distributions for each node

- Conditional on parent nodes

*Properties:*

1. Directed acyclic graph (DAG)

2. Conditional independence

3. Joint probability distribution

4. Factorization of probability

*Applications:*

1. Decision-making under uncertainty

2. Risk analysis

3. Expert systems

4. Machine learning

5. Natural Language Processing (NLP)

6. Image recognition

7. Bioinformatics

8. Finance

*Advantages:*

1. Compact representation of complex relationships

2. Efficient inference and querying

3. Handling uncertainty and ambiguity

4. Flexibility in modeling

*Inference Techniques:*

1. Exact inference (variable elimination)

2. Approximate inference (sampling, MCMC)

3. Belief propagation

4. Junction tree algorithm

*Learning Belief Networks:*

1. Parameter learning (Maximum Likelihood Estimation)

2. Structure learning (search and scoring)

3. Bayesian learning

*Types of Belief Networks:*

1. Naive Bayes

2. Bayesian Networks (BNs)

3. Dynamic Bayesian Networks (DBNs)

4. Temporal Bayesian Networks (TBNs)

5. Causal Bayesian Networks (CBNs)

*Tools and Software:*

1. BayesNet (Matlab)

2. PyMC3 (Python)

3. BNLearn (R)

4. SMILE (Java)

5. GeNIe (C++)
*Real-World Examples:*

1. Medical diagnosis systems

2. Financial risk analysis models

3. Image recognition systems

4. Natural Language Processing (NLP) models

5. Recommendation systems

Belief Networks provide:

1. Powerful representation of uncertainty

2. Efficient inference mechanisms

3. Flexible modeling capabilities

By understanding Belief Networks, you can:

1. Model complex relationships

2. Make informed decisions under uncertainty

3. Analyze risks and uncertainties

4. Develop intelligent systems.

(i)/What is a monotonic Production System?

A Monotonic Production System (MPS) is a type of rule-based system used in
artificial intelligence, particularly in expert systems and knowledge
representation.

*Definition:*

A Monotonic Production System is a production system that satisfies the

following properties:

1. Monotonicity: The system's knowledge base monotonically increases,

meaning new knowledge is added, but existing knowledge is never deleted
or retracted.

2. Rule-based: The system uses production rules (if-then statements) to

reason and make decisions.

3. Forward chaining: The system applies rules in a forward direction, from

premises to conclusions.

*Characteristics:*

1. Knowledge base: A set of production rules and facts.

2. Inference engine: Applies rules to derive new conclusions.

3. Monotonic addition: New rules and facts are added, but existing ones
remain.

*Properties:*

1. Consistency: The system maintains consistency, ensuring new knowledge

doesn't contradict existing knowledge.

2. Cumulativity: The system accumulates knowledge, allowing it to reason

with increasingly more information.

*Advantages:*

1. Efficient reasoning

2. Easy knowledge acquisition

3. Robustness to incomplete knowledge

4. Scalability

*Applications:*
1. Expert systems

2. Knowledge management

3. Decision support systems

4. Natural Language Processing (NLP)

5. Ontology-based systems

*Examples:*

1. MYCIN (expert system for medical diagnosis)

2. DENDRAL (expert system for molecular analysis)

3. PROLOG (logic programming language)

*Comparison to Non-Monotonic Systems:*

Non-monotonic systems allow knowledge retraction or revision, whereas
monotonic systems do not.

*Formal Representation:*

A Monotonic Production System can be represented as:

P = (R, F)

where:

R = set of production rules

F = set of facts

*Inference Procedure:*

1. Match rules against facts

2. Apply matching rules to derive new conclusions

3. Add new conclusions to the knowledge base

By understanding Monotonic Production Systems, you can:

1. Develop efficient rule-based systems

2. Represent knowledge effectively

3. Reason with incomplete information

4. Build scalable expert systems

)‫ (ن‬What is a frame problem?

The Frame Problem is a fundamental issue in artificial intelligence (AI),

particularly in knowledge representation and reasoning.

*Definition:*

The Frame Problem refers to the challenge of efficiently representing and

updating knowledge about a dynamic world, while minimizing unnecessary
changes to the knowledge base.

*Problem Statement:*
Given a knowledge base and a set of actions or events, how can we:

1. Represent the

(k) Explain the significance of parsing in natural language processing.

Parsing is a crucial step in Natural Language Processing (NLP) that enables

the analysis and understanding of sentence structure and meaning.

*Significance of Parsing in NLP:*

1. Syntax Analysis: Parsing helps identify the grammatical structure of

sentences.

2. Semantic Interpretation: Parsing facilitates the extraction of meaning from

text.

3. Text Understanding: Parsing enables NLP systems to comprehend text

context.

4. Information Extraction: Parsing aids in extracting relevant information.

5. Sentiment Analysis: Parsing helps identify sentiment and opinion.

*Types of Parsing:*

1. Top-Down Parsing

2. Bottom-Up Parsing

3. Chart Parsing

4. Shift-Reduce Parsing

5. Dependency Parsing

*Techniques Used:*

1. Context-Free Grammars (CFG)

2. Phrase Structure Grammars (PSG)

3. Lexical-Functional Grammars (LFG)

4. Head-Driven Phrase Structure Grammars (HPSG)

5. Statistical Parsing

*Applications:*

1. Sentiment Analysis

2. Text Summarization

3. Machine Translation
4. Question Answering

5. Text Classification

6. Named Entity Recognition (NER)

7. Part-of-Speech (POS) Tagging

8. Speech Recognition

*Benefits:*

1. Improved Accuracy

2. Enhanced Understanding

3. Efficient Processing

4. Better Decision-Making

5. Increased Automation

*Challenges:*

1. Ambiguity Resolution

2. Handling Out-of-Vocabulary Words

3. Dealing with Noisy Data

4. Complexity of Human Language

5. Contextual Understanding
*Real-World Examples:*

1. Virtual Assistants (e.g., Siri, Alexa)

2. Language Translation Apps (e.g., Google Translate)

3. Sentiment Analysis Tools (e.g., IBM Watson)

4. Text Summarization Software (e.g., SummarizeBot)

5. Chatbots and Conversational AI

*Key Researchers:*

1. Noam Chomsky

2. Richard Montague

3. Joan Bresnan

4. Ronald Kaplan

5. Mark Steedman

*Influential Papers:*

1. "Syntactic Structures" (Chomsky, 1957)

2. "The Logical Structure of Linguistic Theory" (Montague, 1970)

3. "A Parsing Algorithm for Lexical-Functional Grammar" (Bresnan et al.,

1982)
Parsing plays a vital role in NLP, enabling computers to analyze and
understand human language, facilitating various applications and improving
human-computer interaction.

(1)Explain Random search.

2. Random Search (RS) is a simple, stochastic optimization algorithm
used to find the optimal solution for a problem.
3.
4.
5. *Key Characteristics:*
6.
7.
8. 1. Random initialization
9. 2. Iterative search
10. 3. Random perturbations
11. 4. Evaluation-based selection
12.
13.
14. *How Random Search Works:*
15.
16.
17. 1. Initialize a random solution within the search space.
18. 2. Evaluate the solution using a fitness function or objective
function.
19. 3. Apply random perturbations to the current solution.
20. 4. Evaluate the new solution.
21. 5. If the new solution is better, replace the current solution.
22. 6. Repeat steps 3-5 until termination conditions are met.
23.
24.
25. *Types of Random Search:*
26.
27.
28. 1. Pure Random Search (PRS)
29. 2. Directed Random Search (DRS)
30. 3. Random Search with Memory (RSM)
31.
32.
33. *Advantages:*
34.
35.
36. 1. Simplicity
37. 2. Easy to implement
38. 3. No gradient information required
39. 4. Global optimization capabilities
40. 5. Robustness to noise and outliers
41.
42.
43. *Disadvantages:*
44.
45.
46. 1. Slow convergence
47. 2. High computational cost
48. 3. No guarantee of optimality
49. 4. Sensitive to problem dimensionality
50. 5. Difficulty in handling constraints
51.
52.
53. *Applications:*
54.
55.
56. 1. Hyperparameter tuning
57. 2. Model selection
58. 3. Feature selection
59. 4. Optimization problems
60. 5. Machine learning
61. 6. Deep learning
62. 7. Robotics
63. 8. Control systems
64.
65.
66. *Comparison to Other Optimization Algorithms:*
67.
68.
69. 1. Gradient Descent (GD)
70. 2. Genetic Algorithms (GA)
71. 3. Particle Swarm Optimization (PSO)
72. 4. Simulated Annealing (SA)
73. 5. Bayesian Optimization (BO)
74.
75.
76. *Real-World Examples:*
77.
78.
79. 1. Hyperparameter tuning for neural networks
80. 2. Optimization of control systems
81. 3. Resource allocation problems
82. 4. Scheduling problems
83. 5. Portfolio optimization
84.
85.
86. *Python Implementation:*
87.
88.
89. ```
90. import numpy as np
91.
92. def random_search(obj_func, bounds, num_iter):
93. best_x = None
94. best_y = np.inf
95.
96. for _ in range(num_iter):
97. x = np.random.uniform(bounds[0], bounds[1])
98. y = obj_func(x)
99.
100. if y < best_y:
101. best_x = x
102. best_y = y
103.
104. return best_x, best_y
105.
106. # Example usage
107. def obj_func(x):
108. return x**2
109.
110. bounds = [-10, 10]
 111. num_iter = 100
112.
113. best_x, best_y = random_search(obj_func, bounds, num_iter)
114. print(f"Best solution: x = {best_x}, y = {best_y}")
115. ```
116.
117. Random Search is a versatile optimization algorithm suitable for
various problems, offering simplicity and robustness. However, its
convergence speed and optimality guarantees are limited compared to
other algorithms.
(1)II. Write short notes on the following (Answer any FOUR) : (4 x 5
= 20)

118. Explain Breadth First Search in detail with a suitable example.

Breadth-first Search:
o Breadth-first search is the most common search strategy for traversing
a tree or graph. This algorithm searches breadthwise in a tree or graph,
so it is called breadth-first search.
o BFS algorithm starts searching from the root node of the tree and
expands all successor node at the current level before moving to nodes
of next level.
o The breadth-first search algorithm is an example of a general-graph
search algorithm.
oBreadth-first search implemented using FIFO queue data structure.
Advantages:
o BFS will provide a solution if any solution exists.
o If there are more than one solutions for a given problem, then BFS will
provide the minimal solution which requires the least number of steps.
Disadvantages:It requires lots of memory since each level of the tree must
be saved into memory to expand the next level.
o BFS needs lots of time if the solution is far away from the root node.
Example:
In the below tree structure, we have shown the traversing of the tree using
BFS algorithm from the root node S to goal node K. BFS search algorithm
traverse in layers, so it will follow the path which is shown by the dotted
arrow, and the traversed path will be:
1. S---> A--->B---->C--->D---->G--->H--->E---->F---->I---->K

Time Complexity: Time Complexity of BFS algorithm can be obtained by

the number of nodes traversed in BFS until the shallowest Node. Where the
d= depth of shallowest solution and b is a node at every state.
T (b) = 1+b2+b3+.......+ bd= O (bd)
Space Complexity: Space complexity of BFS algorithm is given by the
Memory size of frontier which is O(bd).
Completeness: BFS is complete, which means if the shallowest goal node is
at some finite depth, then BFS will find a solution.
Optimality: BFS is optimal if path cost is a non-decreasing function of the
depth of the node.

2. Explain hidden Markov model in detail.

 Hidden Markov Models (HMMs) are statistical models used for
modeling and analyzing sequential data, where the underlying system is
assumed to be a Markov process with unobserved (hidden) states.

*Key Components:*

1. *Hidden States*: Unobserved states (Q) that generate observations.

2. *Observations*: Measurable outcomes (O) that depend on hidden states.

3. *Transition Probabilities*: Probabilities of moving from one hidden state to

another (A).

4. *Emission Probabilities*: Probabilities of observing a particular observation

given a hidden state (B).

5. *Initial State Distribution*: Probability distribution over initial hidden states

(π).

*Mathematical Representation:*

Let Q = {q1, q2, …, qN} be the set of hidden states, O = {o1, o2, …, oM} be
the set of observations, and T be the number of time steps.

HMM is defined by:

1. Transition Probability Matrix: A = [a(I, j)] where a(I, j) = P(qt+1 = j | qt = i)

2. Emission Probability Matrix: B = [b(j, k)] where b(j, k) = P(ot = k | qt = j)

3. Initial State Distribution: π = [πi] where πi = P(q1 = i)

*HMM Parameters:*

1. *λ* = (A, B, π)

*HMM Inference:*

1. *Forward Algorithm*: Computes probability of observing sequence O given

model λ.

2. *Viterbi Algorithm*: Finds most likely state sequence Q given observation

sequence O.

3. *Baum-Welch Algorithm*: Estimates model parameters λ given

observation sequence O.

*Applications:*

1. *Speech Recognition*: HMMs model speech patterns.

2. *Natural Language Processing*: HMMs model text structure.

3. *Bioinformatics*: HMMs model protein sequences.

4. *Time Series Analysis*: HMMs model financial data.

5. *Image Processing*: HMMs model image features.

*Advantages:*
1. *Flexibility*: Handles sequential data with varying lengths.

2. *Efficiency*: Computational complexity is linear in sequence length.

3. *Interpretability*: Hidden states provide insight into underlying system.

*Disadvantages:*

1. *Assumes Markov Property*: Sequential dependence may not hold.

2. *Computational Complexity*: Increases with number of hidden states.

3. *Overfitting*: Model complexity may lead to poor generalization.

*Real-World Example:*

*Speech Recognition*:

HMM models phonemes (hidden states) and their corresponding acoustic

features (observations). Given an audio signal, the HMM infers the most
likely phoneme sequence.

*Code Implementation:*

```

Import numpy as np

# Define HMM parameters

A = np.array([[0.9, 0.1], [0.5, 0.5]]) # Transition probabilities

B = np.array([[0.8, 0.2], [0.4, 0.6]]) # Emission probabilities

Pi = np.array([0.6, 0.4]) # Initial state distribution

# Define observation sequence

O = [0, 1, 0, 1, 0]

# Forward algorithm

Def forward(A, B, pi, O):

Alpha = np.zeros((len(O), len(pi)))

Alpha[0] = pi * B[:, O[0]]

For t in range(1, len(O)):

Alpha[t] = np.dot(alpha[t-1], A) * B[:, O[t]]

Return alpha

Alpha = forward(A, B, pi, O)

# Viterbi algorithm

Def viterbi(A, B, pi, O):

Delta = np.zeros((len(O), len(pi)))

Psi = np.zeros((len(O), len(pi)))

Delta[0] = pi * B[:, O[0]]

Psi[0] = -1

For t in range(1, len(O)):

For j in range(len(pi)):

Max_prob = 0

Max_state = 0
 For I in range(len(pi)):

Prob = delta[t-1, i] * A[I, j] * B[j, O[t]]

If prob > max_prob:

Max_prob = prob

Max_state = i

Delta[t, j] = max_prob

Psi[t, j] = max_state

Return delta, psi

Delta, psi = viterbi(A, B, pi, O)

```

4. Explain state space approach in solving any Al problem. Discuss this for
water jug problem.

The State Space Approach is a fundamental problem-solving strategy in

Artificial Intelligence (AI). It involves representing a problem as a set of
states and finding a path from an initial state to a goal state.

*Key Components:*

1. State Space: A set of all possible states of the problem.

2. Initial State: The starting point of the problem.

3. Goal State: The desired solution.

4. Transition Model: Defines how to move from one state to another.

5. Search Strategy: Method used to explore the state space.

*Water Jug Problem:*

*Problem Statement:*

You have two water jugs, one with a capacity of 3 liters and the other with a
capacity of 5 liters. How can you measure exactly 4 liters of water using
these two jugs?

*State Space Representation:*

- State: (x, y), where x is the amount of water in the 3-liter jug and y is the
amount of water in the 5-liter jug.

- Initial State: (0, 0)

- Goal State: (0, 4) or (4, 0)

- Transition Model:

- Fill 3-liter jug: (x, y) → (3, y)

- Fill 5-liter jug: (x, y) → (x, 5)

- Empty 3-liter jug: (x, y) → (0, y)

- Empty 5-liter jug: (x, y) → (x, 0)

- Pour from 3-liter to 5-liter: (x, y) → (x-z, y+z), where z is the amount
poured

- Pour from 5-liter to 3-liter: (x, y) → (x+z, y-z)

*Search Strategy:*

1. Breadth-First Search (BFS)

2. Depth-First Search (DFS)

3. A* Search

*Solution:*

Using BFS or DFS, the solution path is:

(0, 0) → (3, 0) → (3, 5) → (3, 4) → (0, 4)

*Steps:*

1. Fill the 3-liter jug.

2. Fill the 5-liter jug.

3. Pour from the 3-liter jug to the 5-liter jug until the 5-liter jug has 4 liters.
*Advantages:*

1. Systematic exploration of the state space.

2. Guaranteed to find a solution if one exists.

*Disadvantages:*

1. Can be computationally expensive for large state spaces.

2. Requires careful definition of the transition model.

*Code Implementation:*

```

from collections import deque

def water_jug_problem():

queue = deque([(0, 0)])

visited = set((0, 0))

while queue:

x, y = queue.popleft()
if (x, y) == (0, 4) or (x, y) == (4, 0):

return True

# Fill 3-liter jug

if x < 3:

new_state = (3, y)

if new_state not in visited:

queue.append(new_state)

visited.add(new_state)

# Fill 5-liter jug

if y < 5:

new_state = (x, 5)

if new_state not in visited:

queue.append(new_state)

visited.add(new_state)

# Empty 3-liter jug

if x > 0:

new_state = (0, y)

if new_state not in visited:

queue.append(new_state)

visited.add(new_state)

# Empty 5-liter jug

if y > 0:

new_state = (x, 0)
 if new_state not in visited:

queue.append(new_state)

visited.add(new_state)

# Pour from 3-liter to 5-liter

if x > 0 and y < 5:

z = min(x, 5-y)

new_state = (x-z, y+z)

if new_state not in visited:

queue.append(new_state)

visited.add(new_state)

# Pour from 5-liter to 3-liter

if y > 0 and x < 3:

z = min(y, 3-x)

new_state = (x+z, y-z)

if new_state not in visited:

queue.append(new_state)

visited.add(new_state)

return False

print(water_jug_problem()) # Output: True

```
The State Space Approach provides a systematic way to solve problems like
the Water Jug Problem. By representing the problem as a set of states and
transitions, we can find a solution using search strategies like BFS or DFS.

5. Explain the steps involved in natural language processing.

Natural Language Processing (NLP) involves several steps to analyze,

understand, and generate human language:

*Text Preprocessing*

1. Text Cleaning: Remove punctuation, special characters, and stop words.

2. Tokenization: Split text into individual words or tokens.

3. Stemming or Lemmatization: Reduce words to base form.

4. Part-of-Speech (POS) Tagging: Identify word types (noun, verb, adjective,

etc.).

*Syntactic Analysis*

1. Sentence Parsing: Analyze sentence structure.

2. Dependency Parsing: Identify word relationships.

3. Constituency Parsing: Identify phrase structure.

*Semantic Analysis*
1. Named Entity Recognition (NER): Identify entities (people, places,
organizations).

2. Sentiment Analysis: Determine text sentiment (positive, negative,

neutral).

3. Topic Modeling: Identify underlying topics.

4. Word Sense Induction: Determine word meanings.

*Discourse Analysis*

1. Coreference Resolution: Identify pronoun references.

2. Discourse Parsing: Analyze text structure.

3. Dialogue Act Recognition: Identify speaker intentions.

*Pragmatic Analysis*

1. Intent Identification: Determine speaker goals.

2. Speech Act Recognition: Identify speech acts (requests, questions, etc.).

3. Implicature Resolution: Infer implied meaning.

*Language Generation*
1. Text Generation: Generate text from scratch.

2. Language Translation: Translate text between languages.

3. Summarization: Generate summaries of text.

*Machine Learning in NLP*

1. Supervised Learning: Train models on labeled data.

2. Unsupervised Learning: Train models on unlabeled data.

3. Deep Learning: Use neural networks for NLP tasks.

*NLP Applications*

1. Sentiment Analysis

2. Language Translation

3. Text Summarization

4. Question Answering

5. Chatbots

6. Speech Recognition

7. Information Retrieval

8. Text Classification
*NLP Tools and Technologies*

1. NLTK (Natural Language Toolkit)

2. spaCy

3. Stanford CoreNLP

4. TensorFlow

5. PyTorch

6. Keras

7. Gensim

*Challenges in NLP*

1. Ambiguity

2. Contextual Understanding

3. Sarcasm and Irony

4. Multi-Language Support

5. Domain Adaptation

6. Handling Out-of-Vocabulary Words

7. Dealing with Noisy Data

Understanding these steps and challenges helps develop effective NLP

systems for various applications.
6. Write a program to implement 8 puzzle problem.

Import copy

From heapq import heappush, heappop

N=3

Row = [1, 0, -1, 0]

Col = [0, -1, 0, 1]

Class priorityQueue:

Def _init_(self):

Self.heap = []

Def push(self, node):

Heappush(self.heap, node)

Def pop(self):

Return heappop(self.heap)

Def empty(self):
Return len(self.heap) == 0

Class node:

Def _init_(self, parent, mat, empty_tile_pos, cost, level):

Self.parent = parent

Self.mat = mat

Self.empty_tile_pos = empty_tile_pos

Self.cost = cost

Self.level = level

Def _lt_(self, nxt):

Return self.cost < nxt.cost

Def calculateCost(mat, final) -> int:

Count = 0

For I in range(n):

For j in range(n):
If mat[i][j] != final[i][j]:

Count += 1

Return count

Def newNode(mat, empty_tile_pos, new_empty_tile_pos, level, parent, final) -

> node:

New_mat = copy.deepcopy(mat)

X1, y1 = empty_tile_pos

X2, y2 = new_empty_tile_pos

New_mat[x1][y1], new_mat[x2][y2] = new_mat[x2][y2], new_mat[x1][y1]

Cost = calculateCost(new_mat, final)

New_node = node(parent, new_mat, new_empty_tile_pos, cost, level)

Return new_node

Def printMatrix(mat):

For I in range(n):
For j in range(n):

Print(“%d “ % (mat[i][j]), end=” “)

Print()

Def isSafe(x, y):

Return 0 <= x < n and 0 <= y < n

Def printPath(root):

If root is None:

Return

printPath(root.parent)

printMatrix(root.mat)

print()

def solve(initial, empty_tile_pos, final):

pq = priorityQueue()

cost = calculateCost(initial, final)

root = node(None, initial, empty_tile_pos, cost, 0)

pq.push(root)

while not pq.empty():

minimum = pq.pop()

if minimum.cost == 0:

printPath(minimum)

return

for I in range(4):

new_tile_pos = [

minimum.empty_tile_pos[0] + row[i],

minimum.empty_tile_pos[1] + col[i]

If isSafe(new_tile_pos[0], new_tile_pos[1]):
Child = newNode(minimum.mat, minimum.empty_tile_pos, new_tile_pos,

Minimum.level + 1, minimum, final)

Pq.push(child)

Initial = [

[1, 2, 3],

[5, 6, 0],

[7, 8, 4]

Final = [

[1, 2, 3],

[5, 8, 6],

[0, 7, 4]

Empty_tile_pos = [1, 2]
Solve(initial, empty_tile_pos, final)

OUTPUT:

123

560

784

123

506

784

123

586

704

123

586

074
III. Answer any THREE questions of the following: (3 x 10 = 30)

7. Essay type questions (Answer any THREE):

(a) Explain A algorithm in detail with a suitable example.

(b) (i) What is the mini-Max search technique? What is alpha beta cut-off?
(5)oThe most common search technique in game playing is Minimax search
procedure. It is depth-first depth-limited search procedure. It is used for
games like chess and tic-tac-toe.

Minimax algorithm uses two functions –

MOVEGEN : It generates all the possible moves that can be generated from
the current position.

STATICEVALUATION : It returns a value depending upon the goodness from

the viewpoint of two-player

This algorithm is a two player game, so we call the first player as PLAYER1
and second player as PLAYER2. The value of each node is backed-up from its
children. For PLAYER1 the backed-up value is the maximum value of its
children and for PLAYER2 the backed-up value is the minimum value of its
children. It provides most promising move to PLAYER1, assuming that the
PLAYER2 has make the best move. It is a recursive algorithm, as same
procedure occurs at each level.

Alpha-beta pruning is a modified version of the minimax algorithm. It is an

optimization technique for the minimax algorithm.
  As we have seen in the minimax search algorithm that the number of
game states it has to examine are exponential in depth of the tree.
Since we cannot eliminate the exponent, but we can cut it to half.
Hence there is a technique by which without checking each node of
the game tree we can compute the correct minimax decision, and
this technique is called pruning. This involves two threshold
parameter Alpha and beta for future expansion, so it is called alpha-
beta pruning. It is also called as Alpha-Beta Algorithm.

 Alpha-beta pruning can be applied at any depth of a tree, and
sometimes it not only prune the tree leaves but also entire sub-tree.

 The two-parameter can be defined as:

a. Alpha: The best (highest-value) choice we have found so far at any
point along the path of Maximizer. The initial value of alpha is -∞.

b. Beta: The best (lowest-value) choice we have found so far at any point
along the path of Minimizer. The initial value of beta is +∞.

The Alpha-beta pruning to a standard minimax algorithm returns the same

move as the standard algorithm does, but it removes all the nodes which are
not really affecting the final decision but making algorithm slow. Hence by
pruning these nodes, it makes the algorithm fast.

(ii) Build a virtual assistant for Wikipedia using Wolfram Alpha and Python.
(5)

Here’s a basic outline to build a virtual assistant for Wikipedia using

Wolfram Alpha and Python:
*Requirements:*

1. Python 3.x

2. Wolfram Alpha API (free or paid)

3. Wikipedia API (MediaWiki API)

4. Natural Language Processing (NLP) library (e.g., NLTK, spaCy)

5. Speech Recognition library (e.g., SpeechRecognition, PyAudio)

*Virtual Assistant Components:*

1. *Natural Language Processing (NLP)*:

- Tokenize user input

- Identify intent (search, summary, etc.)

- Extract keywords

2. *Wolfram Alpha Integration*:

- Send queries to Wolfram Alpha API

- Parse responses

3. *Wikipedia Integration*:

- Search Wikipedia using MediaWiki API

- Retrieve article summaries or full text

4. *Speech Recognition*:

- Recognize user voice input

- Convert speech to text

5. *Text-to-Speech (TTS)*:

- Convert text responses to speech

*Python Code:*

```

Import nltk

From nltk.tokenize import word_tokenize

Import wolframalpha

From wikipedia import wikipedia

Import speech_recognition as sr

From gtts import gTTS

Import os

# Wolfram Alpha API credentials

APP_ID = “YOUR_APP_ID”

# Wikipedia API credentials

WIKI_API = wikipedia.Wikipedia()

# Speech recognition

R = sr.Recognizer()

# Text-to-speech

Tts = gTTS(text=””, lang=”en”)

Def process_input(input_text):

# Tokenize input

Tokens = word_tokenize(input_text)
 # Identify intent

Intent = “”

If “search” in tokens or “find” in tokens:

Intent = “search”

Elif “summary” in tokens:

Intent = “summary”

# Extract keywords

Keywords = [token for token in tokens if token.isalpha()]

Return intent, keywords

Def wolfram_alpha_query(keywords):

# Create Wolfram Alpha query

Query = “ “.join(keywords)

Wa = wolframalpha.Client(APP_ID)

Response = wa.query(query)

# Parse response

Answer = “”

If response[“@success”] == “true”:

Answer = response[“pod”][0][“subpod”][“value”]

Return answer

Def wikipedia_search(keywords):
 # Search Wikipedia

Search_results = WIKI_API.search(keywords)

# Retrieve article summary or full text

Article_title = search_results[0]

Article = WIKI_API.page(article_title)

Summary = article.summary

Return summary

Def speech_to_text():

# Recognize speech

With sr.Microphone() as source:

Audio = r.listen(source)

Try:

Input_text = r.recognize_google(audio)

Except sr.UnknownValueError:

Input_text = “”

Return input_text

Def text_to_speech(text):

# Convert text to speech

Tts.text = text

Tts.save(“output.mp3”)

Os.system(“start output.mp3”)
Def main():

While True:

# Recognize speech input

Input_text = speech_to_text()

# Process input

Intent, keywords = process_input(input_text)

# Query Wolfram Alpha or Wikipedia

If intent == “search”:

Answer = wolfram_alpha_query(keywords)

Elif intent == “summary”:

Answer = wikipedia_search(keywords)

# Convert answer to speech

Text_to_speech(answer)

If __name__ == “__main__”:

Main()

```

*Note:* This code is a basic outline and requires modifications to work

seamlessly. You’ll need to:

1. Replace `YOUR_APP_ID` with your actual Wolfram Alpha API ID.

2. Install required libraries using pip.

3. Modify the code to handle errors and exceptions.

4. Improve the NLP component for better intent identification and keyword
extraction.

5. Enhance the speech recognition and text-to-speech components.

*Future Development:*

1. Integrate more APIs (e.g., Google Maps, Weather)

2. Improve conversational flow

3. Add support for multiple languages

4. Develop a GUI or web interface

5. Explore machine learning models for better intent identification and

response generation.

(c) List and explain the various methods used to solve traveling salesman
problem.

The Traveling Salesman Problem (TSP) is an NP-hard problem that

involves finding the shortest possible tour that visits a set of cities and
returns to the starting city. Here are various methods used to solve TSP:

*Exact Methods*

1. *Branch and Bound*: Explores all possible solutions, using bounds to

eliminate branches that will not lead to optimal solutions.

2. *Dynamic Programming*: Breaks down the problem into smaller sub-

problems, solving each only once.

3. *Integer Linear Programming*: Formulates TSP as an integer linear

program, solving it using linear programming techniques.
*Heuristics*

1. *Nearest Neighbor (NN)*: Starts at a random city, repeatedly choosing the

closest unvisited city.

2. *2-Opt*: Repeatedly applies 2-opt exchanges to improve the tour.

3. *Christofides Algorithm*: Combines NN with 2-opt to improve solutions.

4. *Genetic Algorithm*: Uses principles of natural selection and genetics to

search for good solutions.

*Metaheuristics*

1. *Simulated Annealing*: Inspired by annealing in metallurgy, gradually

reduces randomness to converge on a solution.

2. *Tabu Search*: Uses memory to avoid revisiting recently explored

solutions.

3. *Ant Colony Optimization*: Inspired by ant colonies, uses pheromone trails

to guide search.

4. *Particle Swarm Optimization*: Inspired by flocking behavior, uses particle

movements to search.

*Approximation Algorithms*
1. *Christofides Algorithm*: Guarantees a solution within 1.5 times the
optimal tour length.

2. *Metric TSP Algorithm*: Uses triangle inequality to reduce search space.

3. *Guillotine Algorithm*: Divides the problem into smaller sub-problems.

*Hybrid Methods*

1. *Memetic Algorithm*: Combines genetic algorithms with local search.

2. *Hybrid Genetic Algorithm*: Combines genetic algorithms with other

heuristics.

3. *Hybrid Simulated Annealing*: Combines simulated annealing with other

heuristics.

*Other Methods*

1. *Concorde TSP Solver*: A branch-and-bound algorithm for solving TSP.

2. *Dantzig-Wolfe Decomposition*: Decomposes TSP into smaller sub-

problems.

3. *Benders Decomposition*: Decomposes TSP into smaller sub-problems.

*Comparison of Methods*
| Method | Time Complexity | Solution Quality |

| Exact Methods | High | Optimal |

| Heuristics | Low-Moderate | Good |

| Metaheuristics | Moderate-High | Excellent |

| Approximation Algorithms | Low-Moderate | Good |

| Hybrid Methods | Moderate-High | Excellent |

The choice of method depends on:

1. Problem size

2. Desired solution quality

3. Computational resources

4. Time constraints

Note that no single method performs best for all instances of TSP.

(d) Explain the back propagation algorithm for neural set.

The Backpropagation (BP) algorithm is a widely used training method for

neural networks:

*How Backpropagation Works:*

1. Forward Pass:
 - Input data flows through the network, layer by layer.

- Each neuron applies its activation function.

- Output is calculated.

2. Error Calculation:

- Difference between predicted output and actual output (target).

- Error is calculated using a loss function (e.g., Mean Squared Error).

3. Backward Pass:

- Error is propagated backwards through the network.

- Gradients of the loss function with respect to each weight and bias are
calculated.

4. Weight Update:

- Weights and biases are adjusted based on gradients and learning rate.

*Mathematical Formulation:*

Given:

- Neural network with L layers

- Input x, output y

- Target output t

- Loss function E

- Learning rate η
Forward Pass:

1. Input layer: z0 = x

2. Hidden layers: zl = σ(Wlzl-1 + bl)

3. Output layer: y = σ(WLyL-1 + bL)

Error Calculation:

E = (1/2) * (y - t)^2

Backward Pass:

1. Output layer error: δL = (y - t) * σ'(WL yL-1 + bL)

2. Hidden layer errors: δl = (WL+1 δl+1) * σ'(Wlzl-1 + bl)

3. Weight gradients: ∂E/∂Wl = δlzl-1^T

4. Bias gradients: ∂E/∂bl = δl

Weight Update:

Wl = Wl - η * ∂E/∂Wl
bl = bl - η * ∂E/∂bl

*Key Components:*

1. Activation Functions: σ (e.g., sigmoid, ReLU)

2. Loss Functions: E (e.g., MSE, Cross-Entropy)

3. Learning Rate: η

4. Gradient Descent: Weight update rule

*Types of Backpropagation:*

1. Online BP: Update weights after each example.

2. Batch BP: Update weights after each batch.

3. Mini-Batch BP: Update weights after each mini-batch.

*Advantages:*

1. Efficient training

2. Robust to noise

3. Handles non-linear relationships

*Disadvantages:*

1. Slow convergence

2. Local minima

3. Requires careful hyperparameter tuning

*Real-World Applications:*

1. Image classification

2. Speech recognition

3. Natural language processing

4. Time series forecasting

*Code Implementation:*

```

import numpy as np

def sigmoid(x):

return 1 / (1 + np.exp(-x))
def sigmoid_derivative(x):

return x * (1 - x)

def backpropagation(x, y, weights, biases, learning_rate):

# Forward pass

z0 = x

z1 = sigmoid(np.dot(weights[0], z0) + biases[0])

output = sigmoid(np.dot(weights[1], z1) + biases[1])

# Error calculation

error = (1/2) * (output - y)**2

# Backward pass

delta_output = (output - y) * sigmoid_derivative(output)

delta_hidden = np.dot(weights[1].T, delta_output) * sigmoid_derivative(z1)

# Weight update

weights[0] -= learning_rate * np.dot(delta_hidden, z0.T)

weights[1] -= learning_rate * np.dot(delta_output, z1.T)

biases[0] -= learning_rate * delta_hidden

biases[1] -= learning_rate * delta_output

return weights, biases

# Initialize weights, biases, and learning rate

weights = [np.random.rand(2, 2), np.random.rand(2, 1)]

biases = [np.random.rand(2), np.random.rand(1)]

learning_rate = 0.1

# Train network

for i in range(1000):

x = np.array([1, 2])

y = np.array([0.5])

weights, biases = backpropagation(x, y, weights, biases, learning_rate)

```

(e) Write a short note on:

(i) LISP as Al language

(5+5)

LISP (LISt Processing) is a programming language well-suited for Artificial

Intelligence (AI) tasks due to its unique features:

_Advantages:_

1. Recursive data structures

2. Functional programming

3. Dynamic typing

4. Macros for meta-programming

5. Easy integration with other languages

_Key Features:_

1. Lists: Fundamental data structure

2. Atoms: Basic elements (symbols, numbers)

3. Functions: Can take functions as arguments and return functions

4. Macros: Expand code at compile-time

5. Closures: Functions with lexical scoping

_Applications in AI:_

1. Expert Systems

2. Natural Language Processing (NLP)

3. Computer Vision

4. Robotics

5. Machine Learning

_Why LISP for AI:_

1. Flexible data structures

2. Easy to implement recursive algorithms

3. Functional programming simplifies code

4. Macros enable domain-specific languages

5. Dynamic typing allows for rapid prototyping

_LISP Dialects:_

1. Common Lisp

2. Scheme

3. Clojure

4. Emacs Lisp

_Notable AI Projects using LISP:_

1. ELIZA (1966): Natural Language Processing chatbot

2. MYCIN (1976): Expert system for medical diagnosis

3. MACSYMA (1969): Computer algebra system

4. Cyc (1984): Large-scale knowledge base

_Comparison to Other AI Languages:_

1. Prolog: Logic-based, less flexible data structures

2. Python: More popular, but less suitable for symbolic computation

3. Java: More verbose, less dynamic typing

_Resources:_

1. "The LISP Programming Language" by Richard P. Gabriel

2. "Common Lisp: The Language" by Guy L. Steele Jr.

3. "LISP in 100 Pages" by Paul Graham

4. LISP tutorials and documentation

_Code Example:_

```

; Define a function to calculate factorial

(defun factorial (n)

(if (zerop n)

(* n (factorial (- n 1)))))

; Call the function

(factorial 5) ; returns 120

; Define a macro to create a new function

(defmacro create-function (name args body)

`(defun ,name ,args ,body))

; Use the macro

(create-function add-two (x) (+ x 2))

(add-two 3) ; returns 5

```

(ii) Fuzzy set

. A fuzzy set is a mathematical concept that extends classical set theory to
handle uncertainty and vagueness.

*Key Features:*

1. Membership degrees: Elements have degrees of membership (μ) between

0 and 1.

2. Fuzzy boundaries: Set boundaries are not crisp.

3. Non-binary logic: Uses fuzzy logic instead of binary logic.

*Fuzzy Set Operations:*

1. Union (∪): μ(x) = max(μ1(x), μ2(x))

2. Intersection (∩): μ(x) = min(μ1(x), μ2(x))

3. Complement ©: μ(x) = 1 – μ(x)

*Fuzzy Set Types:*

1. Normal fuzzy sets: μ(x) = 1 for some x.

2. Subnormal fuzzy sets: μ(x) < 1 for all x.

3. Fuzzy numbers: Special case of fuzzy sets.

*Applications:*

1. Control systems

2. Image processing

3. Pattern recognition

4. Decision-making

5. Artificial intelligence

6. Data mining

7. Natural language processing

*Fuzzy Logic:*

1. Fuzzy propositions: Statements with fuzzy truth values.

2. Fuzzy inference: Deriving conclusions from fuzzy premises.

3. Defuzzification: Converting fuzzy outputs to crisp values.

*Fuzzy Inference Systems:*

1. Mamdani fuzzy model

2. Sugeno fuzzy model

3. Tsukamoto fuzzy model

*Advantages:*

1. Handles uncertainty and vagueness

2. Robust to noise and imprecision

3. Flexible and adaptable

*Disadvantages:*

1. Computational complexity

2. Difficulty in defining membership functions

3. Limited interpretability

*Real-World Examples:*

1. Image segmentation

2. Speech recognition

3. Expert systems

4. Autonomous vehicles

5. Medical diagnosis
*Mathematical Representation:*

Let X be a universe of discourse. A fuzzy set A is defined as:

A = {(x, μA(x)) | x ∈ X}

Where μA(x) ∈ [0, 1] is the membership function.

*Code Implementation:*

```

Import numpy as np

Def fuzzy_set(x, a, b, c):

If x <= a:

Return 0

Elif x >= c:

Return 1

Else:

Return (x – a) / (b – a)
X = np.linspace(0, 10, 100)

Y = [fuzzy_set(I, 2, 5, 8) for I in x]

Import matplotlib.pyplot as plt

Plt.plot(x, y)

Plt.show()

```