LEARNING OBJECTIVES:

In this course, the learners will be able to develop expertise related to the following:

1. To learn the basics of designing intelligent agents that can solve general purpose problems.

2. To represent and process knowledge, plan and act, reason under uncertainty and can learn from experiences.

UNIT–I

No. of Hours: 12 Chapter/Book Reference: TB1 [Chapters - 1, 2, 3]; TB2 [Chapters- 1, 3, 4]

Overview of AI: Introduction to AI, Importance of AI, AI and its related field, AI techniques,

Problem solving agents, Criteria for success.

Problems, problem space and search: Defining the problem as a state space search, Depth First Search, Breadth First search, Production Systems and its characteristics, Issues in the design of the search programs.

Heuristic search techniques: Generate and test, hill climbing, best first search technique, A*, AO*, problem reduction, constraint satisfaction.

UNIT–II

No. of Hours: 12 Chapter/Book Reference: TB1 [Chapters - 5, 6]; TB2 [Chapters - 7, 8, 9,

10] RB1 [Chapters - 5, 6, 7]

Knowledge Representation: Definition and importance of knowledge, Knowledge representation, various approaches used in knowledge representation, Issues in knowledge representation, Semantic net frame.

Logical Reasoning: Logical agents, propositional logic, inferences, Syntax and semantics of First Order Logic, Inference in First Order Logic Knowledge Base, forward chaining, backward chaining, unification, resolution

UNIT–III

No. of Hours: 10 Chapter/Book Reference: TB1 [Chapters - 7, 8, 15]; TB2 [Chapters - 13,

14]

Handling Uncertainty: Non-Monotonic Reasoning, Probabilistic reasoning, Bayes ‘Theorem, Certainty factors and Rule-based Systems, Bayesian Networks, Dempster-Shafer Theory, Introduction to Fuzzy logic. Fuzzy set definition & types. Membership functions. Designing a fuzzy set for a given application

Natural Language Processing: Introduction, Syntactic Processing, Semantic Processing, Pragmatic Processing.

UNIT–IV

No. of Hours: 10 Chapter/Book Reference: TB1 [Chapter 17]; TB2 [Chapters - 18, 19]

Learning: Introduction to Learning, Rote Learning, learning by taking advice, learning in problem solving, learning from examples: Induction, Explanation-based Learning, Discovery, Analogy, Neural Networks, and Genetic Learning.

Expert System: Introduction to expert System, Case study of Expert system (Prolog/any programming Language).

TEXT BOOKS:

TB1. Rich and Knight, “Artificial Intelligence”, Tata McGraw Hill, 1992.

TB2. Stuart Russell and Peter Norvig, “Artificial Intelligence: A Modern Approach”, Prentice Hall, Second Edition (Indian reprint: Pearson Education)

REFERENCE BOOKS:

RB1. George F.Luger Artificial Intelligence Pearson Education

RB2. Ben Coppin Artificial Intelligence Illuminated Jones and Bartlett Publisher

BT levels” most commonly refers to Bloom’s Taxonomy levels—a framework used in education to classify learning objectives by complexity. Bloom’s Taxonomy is a widely used educational framework that classifies learning objectives into levels of increasing complexity. It was originally developed by Benjamin Bloom in 1956 and later revised in 2001 to better reflect active thinking and modern teaching practices.

Example :

Internal Exam : October Mid

Practical Exam : November End

Final Exam : December Starting

===========================================================

Assignment-1 [Handwritten]

Assignment -2

Assignment-3

==========================================================

Refer AI Question Bank for Practice

===========================================================

Explore : https://indiaai.gov.in/

INDIAai (https://indiaai.gov.in/) is the Government of India’s official portal for Artificial Intelligence, created by the Ministry of Electronics and Information Technology (MeitY) to build a national AI ecosystem. It serves as a central hub for AI innovation, education, research, and policy development in India.

Overview of INDIAai

Launched by: Ministry of Electronics and Information Technology (MeitY)
Purpose: To democratize AI access, foster innovation, and promote ethical, inclusive AI development across India.
Vision: Position India as a global leader in responsible and scalable AI adoption.

🌍 Major Initiatives

Global IndiaAI Summit (2024, New Delhi): Focused on compute capacity, foundational models, datasets, and ethical AI.
India–AI Impact Summit 2026: Announced by Prime Minister Narendra Modi; first global AI summit hosted in the Global South (Feb 19–20, 2026).
Global Partnership on AI (GPAI): India’s collaboration with international AI research and policy networks.

📚 Resources Available on the Portal

News & Articles: Latest AI developments and government initiatives.
Case Studies & Research Reports: Indian and global AI applications.
Startups Directory: Profiles of emerging AI ventures.
Events Calendar: Summits, workshops, and hackathons.
Educational Materials: AI learning modules and FutureSkills programs.

Unit-by-Unit PowerPoint content for quick access.

Unit-wise notes for your convenience

Explore https://course.fast.ai/Resources/kaggle.html

Earn a Coursera Certificate based on "AI" or from INDIAAI course (any AI course)

Free AI Courses

[Kaggle Learn](https://www.kaggle.com/learn?utm_source=chatgpt.com)

[fast.ai](https://course.fast.ai?utm_source=chatgpt.com)

[DeepLearning.AI](https://www.deeplearning.ai?utm_source=chatgpt.com)

[NPTEL](https://nptel.ac.in?utm_source=chatgpt.com)

[Coursera](https://www.coursera.org?utm_source=chatgpt.com) (audit for free)

Links For Coding & AI Implementation

[Google Colab](https://colab.research.google.com?utm_source=chatgpt.com) Python, free GPU, notebooks for All AI practicals
[Kaggle](https://www.kaggle.com?utm_source=chatgpt.com) Datasets, competitions, notebooks ML, data preprocessing, projects
[Hugging Face](https://huggingface.co?utm_source=chatgpt.com) NLP models, LLMs, datasets NLP, Transformers
[Scikit-learn Documentation](https://scikit-learn.org?utm_source=chatgpt.com) Machine Learning algorithms Classification & clustering
[TensorFlow](https://www.tensorflow.org?utm_source=chatgpt.com) Deep Learning Advanced AI
[PyTorch](https://pytorch.org?utm_source=chatgpt.com) Research and AI development Deep Learning

Links for Robotics & Simulation

[Roboflow](https://roboflow.com?utm_source=chatgpt.com) – Computer vision projects with Colab integration.

[OpenCV](https://opencv.org?utm_source=chatgpt.com) – Image processing.

[ROS (Robot Operating System)](https://www.ros.org?utm_source=chatgpt.com) – Robotics programming.

[NVIDIA Isaac Lab](https://developer.nvidia.com/isaac-lab?utm_source=chatgpt.com) – Robot simulation.

Physical Visits (Delhi NCR)

National Science Centre – Robotics exhibits, AI demonstrations, STEM workshops.
Indian Institute of Technology Delhi – Robotics and AI research labs (through prior permission).
Indraprastha Institute of Information Technology Delhi – AI and robotics labs, seminars, and technical events. Their robotics club, CYBORG, regularly conducts hands-on activities.
Atal Tinkering Labs – Many schools and innovation hubs host robotics demonstrations and maker activities.

THE BIG PICTURE OF YOUR ENTIRE SYLLABUS

I recommend teaching the syllabus through this conceptual journey:

ARTIFICIAL INTELLIGENCE

│

┌─────────────────┼─────────────────┐

│ │ │

SEARCH REASONING LEARNING

│ │ │

BFS / DFS Logic / Probability ML / NN

A* / AO* Fuzzy Logic Genetic

CSP Uncertainty Learning

│ │ │

└─────────────────┼─────────────────┘

│

APPLICATIONS

│

┌─────────────────┼─────────────────┐

│ │ │

NLP Expert Systems Robotics

Download Programs for LAB File

What AI does

1. Understand: Read text, images, voice

2. Reason: Solve problems, plan steps

3. Create: Write, code, design, make images/video

4. Act: Use tools, search web, send emails, book meetings

2. Types of AI you use daily

3. How an AI Agent works

Goal → Think → Use Tools → Learn from Result → Repeat

Ex: "Find me 3 IT jobs in Delhi" → Searches → Filters → Summarizes → Sends you

4. What you can build with AI right now

1. Personal agent: Email writer, meeting scheduler, researcher

2. Business agent: Customer support, resume screener, content creator

3. Creative agent: Image generator, video editor, music maker

Best AI Tools for 2026

Work: Meeting notes, emails, research, data analysis
Study: Tutor, flashcards, paper summarizer
Content: Image gen, video, voice cloning, social posts

1. For WORK 💼

2. For STUDY 📚

3. For CONTENT 🎨

Top 3 "Must-Have" Stack for 2026

Meta AI: Daily assistant + images + brainstorming

NotebookLM: For study and research with your own files

Canva + HeyGen: For all content and videos

Is Google Maps intelligent?
Is Siri intelligent?
Is ChatGPT intelligent?
Is a calculator intelligent?
Is a chess-playing computer intelligent?
Is a washing machine intelligent?
Is a self-driving car intelligent?

Artificial Intelligence is not just about robots. AI is about designing systems that can perceive, reason, learn, and act to achieve goals.

Perceive → Interpret → Represent → Reason → Learn → Decide → Act → Evaluate

A useful classroom model is:

Perceive → Represent → Reason → Learn → Decide → Act (PR²LDA)

What does Perceive mean in AI?

Perception is the process through which an AI system collects information or observations from its environment using available inputs such as:

Cameras → images and video
Microphones → speech and sounds
Sensors → temperature, motion, pressure, distance
Text → documents, messages, web content
User input → commands and questions
Databases/APIs → structured information

Perception is not the same as understanding.

Artificial Intelligence is not just about robots. AI is about designing systems that can perceive information from their environment, represent that information in a meaningful form, reason about it, learn from experience, make decisions, and act to achieve specific goals.

Perceive → Interpret → Represent → Reason → Learn → Decide → Act → Evaluate

For example:

Self-driving car

Camera detects an object

↓

PERCEIVE

"Something is in front of me"

↓

INTERPRET

"That object appears to be a pedestrian"

↓

REPRESENT

Pedestrian = Object + Location + Distance + Movement

↓

REASON

Pedestrian may cross the road

↓

DECIDE

Reduce speed / Brake

↓

ACT

Apply brakes

↓

EVALUATE

Did the action achieve the goal safely?

                    ┌───────────────┐

                    │   ENVIRONMENT │

                    └───────┬───────┘

│

▼

                     👁 PERCEIVE

                  Collect Information

│

▼

                    🧩 INTERPRET

                 Extract Meaning

│

▼

                   🗂 REPRESENT

              Organize Knowledge

│

▼

                     🧠 REASON

                Analyze Possibilities

│

▼

                    📚 LEARN

                Improve from Experience

│

▼

                    🎯 DECIDE

                 Select Best Action

│

▼

                     ⚙️ ACT

               Take Action in World

│

▼

                    🔄 EVALUATE

               Check the Result

│

                            └──────────► New Perception

1. Introduction to Artificial Intelligence

Simple definition

AI is the field of computer science concerned with creating systems that can perform tasks that normally require human-like intelligence.

These tasks include:

Perception
Reasoning
Learning
Problem solving
Decision making
Language understanding
Planning

Classroom analogy

Imagine a student preparing for an examination.

The student:

Observes the question.
Understands the problem.
Recalls knowledge.
Reasons about possible answers.
Chooses the best answer.
Acts by writing it.

An AI system tries to replicate some of these capabilities computationally.

2. Importance of AI

"Why did AI become so important now?"

Discuss:

Huge amounts of data
Faster processors
GPUs
Cloud computing
Better algorithms
Deep learning
Availability of open-source frameworks
Generative AI

Real-world examples

Domain	AI Application
Healthcare	Disease prediction
Education	Personalized learning
Banking	Fraud detection
Agriculture	Crop monitoring
Transport	Autonomous driving
Retail	Recommendation systems
Cybersecurity	Threat detection
Entertainment	Content recommendation
Language	Translation and chatbots

Artificial Intelligence

│

├── Machine Learning

│ │

│ └── Deep Learning

│ │

│ └── Generative AI

│

├── Knowledge Representation

├── Search

├── Reasoning

├── Robotics

└── NLP

Important point:

AI ≠ Machine Learning

Machine Learning is one approach within AI.

Similarly:

Deep Learning ⊂ Machine Learning

And modern generative AI systems are built using advanced machine learning/deep learning methods.

3. AI AND RELATED FIELDS

This is an important examination topic.

Field	Main Question
AI	How can machines behave intelligently?
ML	How can machines learn from data?
Deep Learning	How can neural networks learn complex representations?
NLP	How can computers process human language?
Computer Vision	How can machines understand images/videos?
Robotics	How can machines perceive and act in the physical world?
Expert Systems	How can expert knowledge be represented computationally?
Data Science	How can data be analyzed for insights and decisions?

Classroom activity

A scenario:

"A farmer uses a smartphone app that identifies crop disease from a leaf photograph."

Which fields are involved?

Answer could include:

Computer Vision
Machine Learning
Deep Learning
AI
Agriculture

4. AI TECHNIQUES

Search
Knowledge representation
Reasoning
Planning
Learning
Natural language processing
Pattern recognition
Neural networks
Fuzzy logic
Evolutionary computation

5. PROBLEM-SOLVING AGENTS

This is one of the most important concepts of Unit I.

What is an agent?

An agent is something that:

Perceives its environment through sensors and acts upon that environment through actuators.

Human example

Eyes/Ears

↓

Perception

↓

Brain

↓

Decision

↓

Hands/Legs

↓

Action

AI example

Camera/Sensor

↓

Perception

↓

AI System

↓

Decision

↓

Motor/Software Action

Example: Self-driving car

Sensors:

Camera
Radar
LiDAR
GPS

Decision:

"Pedestrian detected."

Action:

Brake.

6. CRITERIA FOR SUCCESS

A rational agent should:

Achieve its goal
Use available information
Make appropriate decisions
Perform efficiently
Handle changing environments

Introduce the concept:

Rationality ≠ Perfection

A rational agent makes the best decision based on available information, not necessarily a decision that guarantees a perfect outcome.

Differentiate between Automation and AI Agent

🔎 7. PROBLEM, PROBLEM SPACE AND SEARCH

This is where you should begin practical AI programming.

Analogy

Imagine finding a route from Delhi to Jaipur.

You have:

Initial state = Delhi
Goal state = Jaipur
Possible cities = states
Roads = actions
Route = solution

This is a state-space search problem.

Initial State

↓

Possible Actions

↓

New States

↓

More Actions

↓

Goal State

8. BREADTH-FIRST SEARCH — BFS

BFS explores level by level.

Analogy

Imagine searching for a person in a building.

You first check:

Floor 1
Then Floor 2
Then Floor 3

You don't go deep into one room immediately.

Data structure

Queue

First In → First Out

Python practical

from collections import deque

def bfs(graph, start, goal):

queue = deque([[start]])

visited = set()

while queue:

path = queue.popleft()

node = path[-1]

if node == goal:

return path

if node not in visited:

visited.add(node)

for neighbor in graph[node]:

new_path = list(path)

new_path.append(neighbor)

queue.append(new_path)

return None

Classroom example

Use:

A → B, C

B → D, E

C → F

D → G

9. DEPTH-FIRST SEARCH — DFS

DFS explores deeply before backtracking.

Data structure

Stack

Last In → First Out

Analogy

Imagine exploring a maze.

You follow one path until:

You reach the destination, or
You reach a dead end.

Then you go back.

Python practical

def dfs(graph, node, goal, visited=None):

if visited is None:

visited = set()

if node == goal:

return True

visited.add(node)

for neighbor in graph[node]:

if neighbor not in visited:

if dfs(graph, neighbor, goal, visited):

return True

return False

DFS (Depth‑First Search) and BFS (Breadth‑First Search) are *fundamental search algorithms in AI*

"AI agents "often solve search problems in pathfinding, puzzle solving, decision trees and in many more ways .

BFS vs DFS

Feature	BFS	DFS
Structure	Queue	Stack
Search	Level-wise	Depth-wise
Complete	Yes, under standard conditions	Not always
Memory	Higher	Lower generally
Shortest path	Yes for equal-cost edges	No guarantee
Best use	Shortest path	Deep exploration

Exam question

Qs. Differentiate between BFS and DFS? (5-Marks)

10. PRODUCTION SYSTEMS

Production Systems in AI

A production system in artificial intelligence is a rule based computational model that represents knowledge as condition–action (IF–THEN) rules and uses an inference mechanism to search for solutions by repeatedly matching rules against the current state of the problem. It is one of the earliest and most influential architectures for knowledgebased systems and expert systems.

Designing a production system is closely tied to designing a search program that explores possible sequences of rule applications.

Core Components of a Production System

A typical AI production system has four main components:

1. Rule Base (Production Rules)
   A set of rules of the form Ci → Ai, where Ci is the condition (pattern to match) and Ai is the action (conclusion or operation).
   Rules encode domain knowledge in a modular, humanreadable “IF condition THEN action” format.

2. Working Memory (Global Database)
   A dynamic data structure that holds the current facts, states, and intermediate results about the problem.
   As rules fire, facts are added, modified, or removed from working memory, representing the evolving state of the search.
3. Inference Engine (Control System)
   The mechanism that repeatedly:
     Matches rule conditions against working memory,
     Selects which applicable rule(s) to fire (conflict resolution),
     Executes the actions, updating working memory.
   Implements strategies like forward chaining (datadriven) or backward chaining (goaldriven).
4. Control Strategy / Search Mechanism
   Defines how the system searches through the space of possible rule applications to reach a goal.
   Includes decisions about rule ordering, priority, and when to stop (e.g., goal reached, no rules applicable).

Types of production systems in AI (basic, monotonic, nonmonotonic, commutative) illustrate different structural and logical properties of rule based reasoning.

Please note : The inference engine sits between the knowledge base and working memory, orchestrating rule matching and execution.

Key Characteristics of Production Systems

Production systems are characterized by several important properties:

1. Simplicity and Uniformity

All knowledge is expressed in a uniform IF–THEN structure, making rules easy to read, write, and audit.

2. Modularity

Each rule is an independent knowledge unit; rules can be added, removed, or modified with minimal impact on others.

3. Modifiability

Systems can start with a skeletal rule set and be incrementally refined for specific applications.

4. Knowledge Intensive Design

The rule base stores pure knowledge separate from control logic; semantics are largely captured by the rule structure itself.

5. Expressiveness and Intuitiveness

Naturallanguagelike rules make it easier to encode expert knowledge and explain system behavior.

6. GoalOriented Processing

The system continues applying rules until a specified goal state or termination condition is reached.

Production systems are often classified by their logical behavior:

Monotonic – Once a fact is derived, it remains true; knowledge only grows.
Nonmonotonic – Facts can be retracted or revised as new information arrives.
Commutative – The order of rule application does not affect the final result.
Partially commutative – Order matters only in some cases.

Monotonic vs nonmonotonic reasoning shows whether derived facts can be retracted, affecting how the system handles changing or uncertain information.

Production Systems as Search Mechanisms

In AI, a production system implements search over a state space:

State = contents of working memory at a given time.
Operator = firing a rule, which transforms one state into another.
Search process = sequence of rule firings from an initial state to a goal state.

Thus, designing a production system is closely tied to designing a search program that explores possible sequences of rule applications.

State space search flowcharts show the generic loop: initialize state, check goal, generate successors, avoid revisiting states—exactly what a production system’s control strategy does over rule based states.

Issues in the Design of Search Programs

When designing search programs (including those underlying production systems), several key issues arise:

1. State Space Complexity

Size of the state space can be enormous or even infinite, especially in realworld domains.

Exhaustive search quickly becomes infeasible; the number of possible states grows exponentially with problem depth (combinatorial explosion).

Designers must choose representations and abstractions that keep the effective state space manageable.

The 8puzzle is a classic example where the state space is large but finite; even such simple problems illustrate how quickly search spaces grow.

2. Choice of Search Strategy

Designers must decide among:

Uninformed searches (BFS, DFS, uniformcost) vs informed/heuristic searches (A, greedy bestfirst).

Forward vs backward chaining in rulebased systems.

Tradeoffs between completeness (guaranteed to find a solution if one exists), optimality (best solution), time, and space complexity.

3. Memory Management

Many search algorithms require storing large numbers of states (e.g., BFS stores all frontier nodes). In production systems, working memory can grow large as facts accumulate, especially in nonpruned forward chaining.

Memory constraints force designers to use techniques like iterative deepening, beam search, or limited depth strategies.

4. Heuristic Design and Quality

Effective heuristics are crucial for pruning the search space and guiding it toward promising regions.

Poor heuristics can mislead the search, causing it to explore irrelevant branches or miss good solutions.

In rule based systems, heuristic knowledge may be encoded as rule priorities, metarules, or control strategies.

5. Handling Dynamic and Uncertain Environments

Real world problems often involve changing information, partial observability, and uncertainty.)

Monotonic production systems struggle when facts must be retracted; nonmonotonic reasoning and belief revision mechanisms are needed.

Search programs must be robust to noise, incomplete data, and evolving goals.

6. Efficiency vs Accuracy Tradeoff

More thorough search (e.g., exhaustive, optimal algorithms) increases accuracy but may be too slow for realtime or largescale applications.

Approximate or anytime algorithms provide “good enough” solutions quickly but may not guarantee optimality.

In production systems, this shows up as a tension between firing many rules for completeness vs using aggressive pruning and prioritization for speed.

7. Control and Conflict Resolution

When multiple rules are applicable, the system must decide which rule to fire (conflict resolution). Poor conflict resolution strategies can lead to:

Inefficiency – many irrelevant rules fire, wasting cycles.

Opacity – difficulty understanding why a particular path was taken.

Designing clear priorities, metarules, or structured control knowledge is essential.

8. Lack of Learning

Classical rule based production systems do not automatically learn from past problem solving episodes.

Each new problem may require reexploring similar search paths unless explicit learning mechanisms (e.g., case libraries, rule induction) are added.

Modern AI often hybrids production systems with machine learning to address this limitation.

Summary

A production system can be explained as:

IF condition

THEN action

Example:

IF temperature > 38°C

THEN suspect fever

Components:

Production rules
Working memory
Control strategy

Characteristics

Rule-based
Modular
Knowledge represented as rules
Uses inference
Can separate knowledge from control

11. HEURISTIC SEARCH

This is a major transition.

"Blind search asks: What can I try?"

"Heuristic search asks: What should I try first?"

A heuristic is an estimate or rule of thumb that helps guide search.

Heuristic search in AI is a guided search method that uses a rule of thumb or estimate to reach a goal faster than checking every possibility. It is useful when brute-force search or Blind search would take too much time or memory.

Heuristic search in AI

Heuristic search is a search technique that uses a smart estimate to choose the most promising path toward the goal. The estimate is called a heuristic function $ℎ (𝑛)$ (n), which approximates the cost from a node to the goal.

Core idea

Instead of exploring every possible path, the algorithm prefers nodes that look closer to the goal. This makes the search faster and more practical for large problems

Simple idea

Think of it like planning a route on Google Maps. Instead of exploring all roads, the system picks the roads that seem most promising based on an estimate of distance or cost. In AI, that estimate is called a heuristic function.

How it works

A heuristic search algorithm usually does this:

Starts from an initial state.
Uses a heuristic value to estimate how close each possible move is to the goal.
Expands the most promising option first.
Repeats until it finds a goal state or runs out of good choices.

Why it is useful

Heuristic search is faster and more efficient than uninformed search because it does not blindly explore the whole search space. It is common in pathfinding, game playing, and optimization problems.

Main limitation

It does not always guarantee the best solution. Sometimes it finds a good solution quickly, but not the optimal one, because it relies on estimates rather than full exploration.

Example

If you are solving a maze, a heuristic might estimate “how far this position is from the exit.” The search then prefers moves that appear to bring you closer to the exit, instead of trying every possible path.vationventures+1

Common algorithms

Some well-known heuristic search methods are:

Best-first search.
Hill climbing.
A* search, which combines actual cost and estimated cost.

Easy way to remember

Heuristic search is like choosing a path using a smart guess about which direction is closer to the goal. Uninformed search is like searching step by step without any clue about which branch is better.mcgill+1

A* and hill climbing

A* is a classic heuristic search method that uses $𝑓 (𝑛) = 𝑔 (𝑛) + ℎ (𝑛)$ (n)=g(n)+h(n), where $𝑔 (𝑛)$ (n) is the cost so far and $ℎ (𝑛)$ (n) is the estimated cost to the goal. That is why A* is widely used in pathfinding.

Hill climbing is another heuristic search method that repeatedly moves to a better neighboring state until no improvement is found. It is simple, but it can get stuck at a local optimum.

If you are finding the shortest route on a map, heuristic search uses estimated distance to the destination, while uninformed search may check many roads one by one.

A* example

A* is the best-known heuristic search algorithm. It uses:

𝑓 (𝑛) = 𝑔 (𝑛) + ℎ (𝑛)

where $𝑔 (𝑛)$ is the cost from the start node to $𝑛$ , and $ℎ (𝑛)$ is the estimated cost from $𝑛$ to the goal.ubc+2

Why it matters

Heuristic search is useful when exact search would be too slow. It is widely used in route finding, game playing, and optimization.

Limitation

Heuristic search is efficient, but it depends on the quality of the heuristic. If the estimate is poor, the algorithm may become slow or miss the best path.

Tiny example

If you are navigating a map, a heuristic can be the straight-line distance to the destination. The search then prefers roads that seem to reduce that distance

Algorithms

A* flowchart

Start with the initial node.
Put it in the open list.
Pick the node with the smallest $f(n) = g(n) + h(n)$
If it is the goal, stop and return the path.
Otherwise, expand its neighbors.
Update their costs and parents if a better path is found.
Move the current node to the closed list.
Repeat until the goal is found or the open list becomes empty.

Hill climbing flowchart

Start with the initial state.
Evaluate all neighboring states.
Choose the neighbor with the best value.
If it is better than the current state, move to it.
If no neighbor is better, stop.
The current state is the final solution, though it may be only a local optimum.

Simple comparison

A* searches more intelligently and can find the optimal path when the heuristic is suitable.
Hill climbing is simpler, but it can get stuck at a local optimum.

1. Heuristic search: search using experience or smart guess.

2. A*: finds best path using actual cost plus estimated cost.

3. Hill climbing: keeps moving to a better nearby state until no improvement is possible.

“If I want to reach a goal, I can either search blindly or use a smart guess.

Heuristic search uses the smart guess.

A* uses smart guess plus real cost.

Hill climbing only moves to the best nearby option.”

Using python Language full Hill climbing code explained line by line in very simple language

graph = {

'A': ['B', 'C'],

'B': ['D', 'E'],

'C': ['F'],

'D': ['G'],

'E': ['G'],

'F': ['G'],

'G': []

}

scores = {

'A': 1,

'B': 3,

'C': 2,

'D': 4,

'E': 5,

'F': 6,

'G': 10

}

def neighbors(node):

return graph[node]

def value(node):

return scores[node]

best = hill_climbing('A', neighbors, value)

print(best)

Line-by-line explanation

1. graph = {...}

This creates a dictionary.

It stores which node is connected to which other nodes.

Example:

A is connected to B and C
B is connected to D and E

So this is called a graph representation using a dictionary.

2. scores = {...}

This is another dictionary.

It stores the value of each node.

Example:

A = 1
B = 3
C = 2

These values help the algorithm decide which node is better.

3. def neighbors(node):

This defines a function named neighbors.

A function is a block of code that does a specific job.

4. return graph[node]

This returns the list of neighbors of that node.

Example:

if node = 'A'
then graph['A'] gives ['B', 'C']

So this function tells us the next possible nodes.

5. def value(node):

This defines another function named value.

It gives the score of a node.

6. return scores[node]

This returns the score stored in the scores dictionary.

Example:

value('B') gives 3
value('G') gives 10

7. best = hill_climbing('A', neighbors, value)

This starts the hill climbing algorithm from node A.

It uses:

neighbors to find nearby nodes
value to compare their scores

The algorithm keeps moving to the better node.

8. print(best)

This prints the final best node found by hill climbing.

In this example, the output will be:

python

Pyhon implementation of A* with step-wise explanation.

A* Python code

import heapq

def a_star(graph, start, goal, h):

    open_list = []

    heapq.heappush(open_list, (h(start, goal), 0, start))

    came_from = {}

    g_cost = {start: 0}

    closed_set = set()

    while open_list:

        f, g, current = heapq.heappop(open_list)

        if current == goal:

            path = [current]

            while current in came_from:

                current = came_from[current]

                path.append(current)

            return path[::-1]

        if current in closed_set:

            continue

        closed_set.add(current)

        for neighbor, cost in graph.get(current, {}).items():

            new_g = g_cost[current] + cost

            if neighbor not in g_cost or new_g < g_cost[neighbor]:

                g_cost[neighbor] = new_g

                came_from[neighbor] = current

                new_f = new_g + h(neighbor, goal)

                heapq.heappush(open_list, (new_f, new_g, neighbor))

    return None

Example graph

graph = {

    'A': {'B': 1, 'C': 4},

    'B': {'D': 2, 'E': 5},

    'C': {'F': 1},

    'D': {'G': 3},

    'E': {'G': 1},

    'F': {'G': 2},

    'G': {}

heuristic_values = {

    'A': 7, 'B': 6, 'C': 2, 'D': 4, 'E': 2, 'F': 1, 'G': 0

def h(node, goal):

    return heuristic_values[node]

path = a_star(graph, 'A', 'G', h)

print(path)

Step-wise explanation

1. `graph`

This stores the graph and the cost of moving from one node to another.

Example:

A -> B costs 1
A -> C costs 4

2. `h(node, goal)`

This is the heuristic function.
It gives an estimated cost from a node to the goal.

3. `open_list`

This is a priority queue.
A* always picks the node with the lowest f value first.

4. `g_cost`

This stores the real cost from the start node to the current node.

5. `f = g + h`

A* uses this formula:

g = actual cost so far
h = estimated future cost
f = total estimated cost

6. `came_from`

This remembers the parent of each node so that we can rebuild the final path.

7. Main loop

Pick the node with the smallest f
If it is the goal, stop
Otherwise, check all neighbors
Update costs if a better path is found

8. Path reconstruction

When the goal is found, the algorithm moves backward using came_from and builds the final path.

Output for this example

['A', 'B', 'E', 'G']

“A* tries to find the shortest path by combining two things:

the cost already traveled and the estimated cost to the goal.”

AO* program with a step-wise explanation. AO* is used for AND-OR graphs, where some choices need one best child and some need all children together

Python code

class AOStar:

    def __init__(self, graph, heuristic):

        self.graph = graph

        self.heuristic = heuristic

        self.status = {}

        self.solution = {}

    def minimum_cost(self, node):

        children_groups = self.graph.get(node, [])

        min_cost = float('inf')

        best_group = None

        for group in children_groups:

            cost = 0

            for child, edge_cost in group:

                cost += edge_cost + self.heuristic.get(child, 0)

            if cost < min_cost:

                min_cost = cost

                best_group = group

        return min_cost, best_group

    def ao_star(self, node):

        if node not in self.graph or not self.graph[node]:

            self.status[node] = 'Solved'

            return self.heuristic.get(node, 0)

        min_cost, best_group = self.minimum_cost(node)

        self.heuristic[node] = min_cost

        self.solution[node] = best_group

        all_solved = True

        for child, _ in best_group:

            if self.status.get(child) != 'Solved':

                all_solved = False

                self.ao_star(child)

        if all_solved:

            self.status[node] = 'Solved'

        return self.heuristic[node]

graph = {

    'A': [[('B', 1), ('C', 1)], [('D', 2)]],

    'B': [[('E', 2)], [('F', 3)]],

    'C': [[('G', 2)]],

    'D': [],

    'E': [],

    'F': [],

    'G': []

heuristic = {

    'A': 10,

    'B': 4,

    'C': 3,

    'D': 2,

    'E': 1,

    'F': 5,

    'G': 2

ao = AOStar(graph, heuristic)

ao.ao_star('A')

print("Solution graph:", ao.solution)

print("Status:", ao.status)

print("Updated heuristic:", ao.heuristic)

Line-by-line Explanation of the AO* code in very simple way

1. Class and setup

class AOStar:

This creates a class named AOStar. A class is like a blueprint for the algorithm.

def __init__(self, graph, heuristic):

This is the constructor. It runs when we create an object of the class.

self.graph = graph
self.heuristic = heuristic
self.status = {}
self.solution = {}

These lines store:

the graph structure,
heuristic values,
whether a node is solved,
the final selected solution path or subgraph.

2. Finding minimum cost

def minimum_cost(self, node):

This function finds the cheapest option for a given node.

children_groups = self.graph.get(node, [])

This gets all possible child groups of that node.

min_cost = float('inf')
best_group = None

These are used to store the lowest cost found so far and the best group.

for group in children_groups:

This loops through each possible group of children.

cost = 0

This starts cost calculation for one group.

for child, edge_cost in group:
    cost += edge_cost + self.heuristic.get(child, 0)

For each child in the group:

add the edge cost,
add the heuristic value of that child.

if cost < min_cost:
    min_cost = cost
    best_group = group

If this group is cheaper than the previous best, store it.

return min_cost, best_group

Return the minimum cost and the best group.

3. Main AO* function

def ao_star(self, node):

This is the main AO* search function.

if node not in self.graph or not self.graph[node]:

If the node has no children, it is a leaf node.

self.status[node] = 'Solved'
return self.heuristic.get(node, 0)

A leaf node is marked as solved and its heuristic value is returned.

4. Choosing the best group

min_cost, best_group = self.minimum_cost(node)

This finds the best child group for the current node.

self.heuristic[node] = min_cost

Update the heuristic value of the current node with the new minimum cost.

self.solution[node] = best_group

Store the chosen best group as part of the solution.

5. Solving child nodes

all_solved = True

Assume all children are solved.

for child, _ in best_group:

Check each child in the best group.

if self.status.get(child) != 'Solved':
    all_solved = False
    self.ao_star(child)

If a child is not solved yet:

mark that not all children are solved,
recursively solve that child.

6. Marking node as solved

if all_solved:
    self.status[node] = 'Solved'

If all required children are solved, then the current node is also solved.

return self.heuristic[node]

Return the updated cost of the node.

7. Graph example

graph = {
    'A': [[('B', 1), ('C', 1)], [('D', 2)]],
    'B': [[('E', 2)], [('F', 3)]],
    'C': [[('G', 2)]],
    'D': [],
    'E': [],
    'F': [],
    'G': []
}

This means:

A has two choices:
- solve B and C together,
- or solve D.
B also has two choices:
- E,
- or F.

This is why AO* is useful: it can handle AND and OR conditions.

8. Heuristic values

heuristic = {
    'A': 10,
    'B': 4,
    'C': 3,
    'D': 2,
    'E': 1,
    'F': 5,
    'G': 2
}

These are estimated costs of nodes.

Smaller values mean the node looks cheaper or more promising.

9. Running the algorithm

ao = AOStar(graph, heuristic)
ao.ao_star('A')

This creates an AO* object and starts the search from node A.

10. Printing result

print("Solution graph:", ao.solution)
print("Status:", ao.status)
print("Updated heuristic:", ao.heuristic)

These lines show:

which nodes were chosen,
which nodes are solved,
the updated heuristic values.

“AO* is used when a problem has AND and OR choices.
It checks all possible child groups, chooses the cheapest one, solves those children, and updates the parent cost.
It continues until the starting node is solved.”

Very short version

“AO* is a heuristic search algorithm for AND-OR graphs.
It selects the best solution group, solves child nodes, and backtracks cost updates until the root is solved.”

12. GENERATE AND TEST

Simple idea:

Generate a possible solution

↓

Test the solution

↓

Correct?

/ \

Yes No

↓ ↓

Stop Generate again

Example

Password guessing is conceptually similar:

Generate candidate

↓

Test candidate

↓

Correct?

PROBLEM REDUCTION

Large problem:

Solve Exam

↓

Study Syllabus

↓

Study Units

↓

Study Topics

↓

Practice Questions

Break a complex problem into smaller subproblems.

CONSTRAINT SATISFACTION PROBLEMS — CSP

A CSP contains:

Variables
Domains
Constraints

Example: Timetable

Variables:

Subject A

Subject B

Subject C

Domains:

Monday

Tuesday

Wednesday

Constraints:

Two subjects cannot occupy the same room/time.

Other examples:

Sudoku
Map coloring
N-Queens
Exam scheduling

UNIT II — KNOWLEDGE REPRESENTATION AND LOGICAL REASONING

The central question:

"How can a machine represent what it knows?"

KNOWLEDGE REPRESENTATION

Knowledge representation is the process of representing knowledge in a form that a computer can use for reasoning.

Analogy

A human student has knowledge stored mentally.

AI needs a computational equivalent.

Real World

↓

Knowledge

↓

Representation

↓

Reasoning

↓

Decision

1. Knowledge in Artificial Intelligence

1.1 Meaning of Knowledge

Knowledge is organized information about objects, events, properties, relationships, rules, and procedures that can be used to solve problems or make decisions.

Example

Suppose an AI system stores the following information:

Delhi is a city.
Delhi is located in India.
India is a country.
All cities located in India have Indian Standard Time.
Delhi is located in India.

The system can infer:

Delhi follows Indian Standard Time.

The first statements are stored knowledge, while the final statement is derived knowledge.

1.2 Data, Information, and Knowledge

Concept	Meaning	Example
Data	Raw facts or symbols	39, fever, cough
Information	Processed or organized data	Patient has fever
Knowledge	Information plus relationships and rules	Fever and cough may indicate infection
Wisdom/Decision	Appropriate action based on knowledge	Recommend medical consultation

1.3 Types of Knowledge

Type	Meaning	Example
Factual knowledge	Describes facts about the world	Delhi is in India
Structural knowledge	Describes relationships	A car has an engine
Procedural knowledge	Describes how to perform a task	To log in, enter username and password
Heuristic knowledge	Experience-based rule of thumb	If the road is wet, drive slowly
Meta-knowledge	Knowledge about knowledge	This rule is more reliable than that rule
Common-sense knowledge	General everyday knowledge	Ice melts when heated
Domain knowledge	Knowledge of a specific field	A router forwards packets

2. Importance of Knowledge

Knowledge is essential because an intelligent system must do more than store data. It must interpret facts, identify relationships, reason about alternatives, and take suitable action.

Applications

Medical diagnosis.
Chatbots and question-answering systems.
Recommendation systems.
Robotics.
Natural-language understanding.
Expert systems.
Semantic search.
Fraud detection.
Educational tutoring systems.
IoT fault diagnosis.

A good knowledge representation should help a computer store, retrieve, update, explain, and reason with knowledge.

3. Knowledge Representation

3.1 Definition

Knowledge Representation (KR) is the process of formally representing real-world knowledge in a form that a computer can understand and use for reasoning.

A knowledge representation system generally contains:

Knowledge Base+Inference Mechanism=Intelligent Behaviour\text{Knowledge Base} + \text{Inference Mechanism} = \text{Intelligent Behaviour}Knowledge Base+Inference Mechanism=Intelligent Behaviour

3.2 Knowledge Base

A Knowledge Base (KB) is a collection of facts and rules.

Example

text

Fact 1: Student(Riya)

Fact 2: Studies(Riya, AI)

Rule: If a person studies AI, then the person learns reasoning.

From these statements:

text

LearnsReasoning(Riya)

can be derived.

3.3 Components of Knowledge Representation

Component	Purpose
Facts	Store known truths
Concepts	Represent objects or categories
Relations	Connect concepts
Rules	Express conditions and conclusions
Constraints	Restrict valid possibilities
Inference engine	Derive new facts
Explanation facility	Explain how a conclusion was reached

4. Properties of Good Knowledge Representation

A good KR system should provide the following:

4.1 Representational Adequacy

It should represent all important objects, properties, relationships, events, and rules of the domain.

4.2 Inferential Adequacy

It should allow the system to derive new knowledge from existing knowledge.

4.3 Inferential Efficiency

It should support reasoning without unnecessary computation.

4.4 Acquisitional Efficiency

It should be easy to add new facts and rules.

4.5 Explainability

It should explain why a conclusion was reached.

Example

Instead of displaying only:

text

Loan rejected.

an explainable system should display:

text

Loan rejected because income is below the threshold and credit history is poor.

5. Approaches to Knowledge Representation

The major approaches covered in this unit are:

Logical representation.
Semantic-network representation.
Frame representation.
Production-rule representation.
Ontology-based representation.

5.1 Comparison of Approaches

Approach	Main structure	Best suited for	Limitation
Logic	Formal statements	Precise reasoning	Can become complex
Semantic network	Nodes and labelled links	Relationships and inheritance	Ambiguous semantics
Frames	Slots and fillers	Objects and stereotyped situations	Exceptions may be difficult
Production rules	IF–THEN rules	Expert systems and decisions	Rule explosion
Ontology	Concepts, properties, axioms	Shared domain vocabulary	Requires careful design

Exam related Qs Ans

Knowledge representation (KR) is crucial in AI because it allows machines to store, organize, and use information in a structured way, enabling them to reason, learn, and make intelligent decisions. Without KR, AI systems would only process raw data without understanding or context.

Qs Why Knowledge Representation is Important (6-Marks)

Transforms raw data into usable knowledge: AI systems need structured knowledge to interpret inputs and act intelligently.
Supports reasoning and decision-making: Enables logical inference, problem-solving, and predictions.
Improves efficiency: Helps AI systems respond faster and more accurately by organizing information.
Enables learning from experience: Past knowledge can be reused for new situations.
Foundation for intelligent applications: Used in expert systems, chatbots, recommendation engines, and medical diagnosis tools.

Types of Knowledge in AI

Type Description Example
Declarative Knowledge Facts and concepts Delhi is the capital of India
Procedural Knowledge Steps to perform tasks Algorithm for sorting numbers
Heuristic Knowledge Rules of thumb from experience Doctor guessing flu from symptoms
Structural Knowledge Relationships between concepts Car is a type of vehicle
Meta Knowledge Knowledge about knowledge Knowing which rule works best in math problems

Techniques of Knowledge Representation

Logical Representation: Uses propositional/predicate logic.
Example: “All humans are mortal. Socrates is human → Socrates is mortal.”
Semantic Networks: Graphs showing relationships.
Example: Dog → isA → Animal → isA → Living Thing.

What is a Frame ?

Frames: Templates with attributes.

Example: Car frame → slots for color, engine, model.

Rule-Based Systems: IF–THEN rules.

Example: IF fever AND cough → THEN possible flu.

Neural Representation: Used in deep learning.

Example: Image recognition systems storing patterns.

Real-Life Examples

Medical Diagnosis
AI expert systems store diseases and symptoms in structured rules.
Example: IF fever + cough → suggest flu.
Chatbots & Voice Assistants
Use semantic networks and rules to understand queries and respond meaningfully.
Example: “What is the capital of India?” → retrieves stored fact: New Delhi.
Recommendation Systems (Netflix, Amazon)
Represent user preferences and item attributes to suggest movies/products.
Example: “User likes action movies → recommend John Wick.”

⚠️ Challenges

Complexity: Representing real-world knowledge is difficult.
Ambiguity: Human language and concepts can be vague.
Scalability: Large knowledge bases require efficient storage and retrieval.
Dynamic updates: Knowledge must evolve with new information.

Knowledge representation is the backbone of AI intelligence. It’s what allows machines to “understand” and “reason” instead of just processing data. For teaching, you can illustrate with a medical expert system or a semantic network of animals — both make abstract concepts tangible.

Logical Representation

Logical representation uses formal symbols and rules to describe knowledge.

Start with plain English, not symbols

∀x (Universal quantifier — "for all / every")

"Every student in this class has a laptop." → ∀x (Student(x) → HasLaptop(x))
"All dogs bark." → ∀x (Dog(x) → Barks(x))
"Every number is either even or odd." → ∀x (Even(x) ∨ Odd(x))

∃x (Existential quantifier — "there exists / some / at least one")

"Some student scored 100 marks." → ∃x (Student(x) ∧ Scored100(x))
"There is a prime number greater than 100." → ∃x (Prime(x) ∧ x > 100)
"Someone in this room speaks French." → ∃x (Person(x) ∧ Speaks(x, French))

∀ pairs with → (implication)

∃ pairs with ∧ (and).

This single rule prevents 80% of the mistakes.

Statement	Wrong (common mistake)	Right
"All students like AI"	∀x (Student(x) ∧ Likes(x,AI))	∀x (Student(x) → Likes(x,AI))
"Some student likes AI"	∃x (Student(x) → Likes(x,AI))	∃x (Student(x) ∧ Likes(x,AI))

Explanation : ∀x (Student(x) ∧ Likes(x,AI)) → "Everything in the universe is a student and likes AI" — including chairs, numbers, your phone.. Similarly ∃x (Student(x) → Likes(x,AI)) is trivially true even if no student likes AI, as long as one non-student exists in the domain .

Python program

python

# ∀x P(x) — "for all x, P(x) holds" — like an AND over a loop
all(P(x) for x in domain)     # True only if EVERY element satisfies P

# ∃x P(x) — "there exists an x such that P(x) holds" — like an OR over a loop
any(P(x) for x in domain)     # True if AT LEAST ONE element satisfies P

Example:

python

students = ["Aman", "Riya", "Kabir"]
scores = {"Aman": 45, "Riya": 91, "Kabir": 60}

# ∀x (Student(x) → Passed(x))   -- did everyone pass?
all(scores[s] >= 40 for s in students)

# ∃x (Student(x) ∧ ScoredAbove90(x))  -- did someone score above 90?
any(scores[s] > 90 for s in students)

∀x ∃y Likes(x, y) → "Everyone has someone they like" (each person can like a different person)
∃y ∀x Likes(x, y) → "There is one specific person that everyone likes" (a single shared favorite)

Show this with a dating/friendship example — it's memorable: "Every student has a favorite teacher" (∀x∃y) is very different from "There's one teacher every student has as their favorite" (∃y∀x).

Negation — the rule they must memorize

Statement	Negation
¬∀x P(x)	∃x ¬P(x)
¬∃x P(x)	∀x ¬P(x)

Plain English trick: "Not everyone passed" = "Someone failed." "No one passed" = "Everyone failed."

¬∀x Passed(x) ≡ ∃x ¬Passed(x) — "It's not true that all passed" = "At least one didn't pass"
¬∃x Passed(x) ≡ ∀x ¬Passed(x) — "No one passed" = "Everyone failed"

Practice exercise set

"All birds can fly" → ∀x (Bird(x) → CanFly(x))
"Some birds cannot fly" → ∃x (Bird(x) ∧ ¬CanFly(x))
"No student failed the exam" → ∀x (Student(x) → ¬Failed(x)) or equivalently ¬∃x (Student(x) ∧ Failed(x))
Translate: ∃x (Programmer(x) ∧ Knows(x, Python)) → "There is at least one programmer who knows Python"
Translate: ∀x (Movie(x) → HasGenre(x)) → "Every movie has a genre"

Advantages

Precise and unambiguous.
Supports formal inference.
Suitable for theorem proving.
Easy to verify mathematically.

Limitations

Difficult to represent uncertain knowledge.
Difficult to represent vague concepts.
Large knowledge bases may require expensive reasoning.
Natural-language conversion is challenging.

What is a Logical Agents

A logical agent is an AI agent that decides what to do by carrying a knowledge base (KB) — a set of logical sentences about the world — and reasoning over it, instead of relying only on fixed condition-action rules.

A logical agent is like a detective. It doesn't have a camera feed of the crime as it happens (raw perception only gets it clues). Instead it writes every clue into a notebook (the KB), then reasons

— "if the window is broken and the dog didn't bark, then the intruder was known to the dog" — to derive new facts that were never directly observed.

The KB-agent cycle

Percept (sensor input) TELL add sentence to KB (Knowledge Base)

ASK query KB for best action Inferencen engine Action executed

Fig 1. Generic knowledge-based agent loop: TELL adds new percepts as sentences; ASK queries the KB using inference to choose an action.

Every knowledge-based agent supports two core operations:

TELL — add a new sentence (fact) to the KB.
ASK — query the KB to see if a sentence is entailed, i.e. can be proven true.

Why "logical"?

	Meaning
Knowledge-level description	We can describe the agent by what it knows, independent of how it is implemented.
Declarative	You build the agent by TELLing it facts and rules, not by hand-coding behaviour.
Compositional	New knowledge can be added incrementally without redesigning the agent.

Propositional Logic

Propositional Logic (PL) is the simplest logic: it deals with propositions — statements that are either True or False — combined using logical connectives.

Syntax — building sentences

Symbol	Name	Meaning	Example
¬	Negation	NOT	¬P
∧	Conjunction	AND	P ∧ Q
∨	Disjunction	OR	P ∨ Q
⇒	Implication	IF...THEN	P ⇒ Q
⇔	Biconditional	IFF	P ⇔ Q

Atomic sentences are single proposition symbols (P, Q, Rain). Complex sentences combine atomic ones with connectives, e.g. (Rain ∧ ¬Umbrella) ⇒ WetClothes.

Semantics — truth tables

Semantics defines the truth value of a sentence given a "model" (an assignment of True/False to every symbol).

P	Q	¬P	P∧Q	P∨Q	P⇒Q	P⇔Q
T	T	F	T	T	T	T
T	F	F	F	T	F	F
F	T	T	F	T	T	F
F	F	T	F	F	T	T

Analogy

Think of ⇒ (implication) as a promise: "If it rains, I'll carry an umbrella." The only way to break this promise is if it rains and you don't carry an umbrella (T⇒F = False). If it doesn't rain, you can carry an umbrella or not — the promise is never broken, so the row is always True. This is why F ⇒ anything is always True (a vacuous promise).

Key semantic terms

Model — one specific truth assignment to all symbols (e.g. P=True, Q=False).
Satisfiable — true in at least one model.
Valid / Tautology — true in every model, e.g. P ∨ ¬P.
Unsatisfiable / Contradiction — false in every model, e.g. P ∧ ¬P.
Entailment (⊨) — KB ⊨ α means α is true in every model where KB is true. This is the formal basis of "sound reasoning."

️ Worked Example

KB: P ⇒ Q, P. Does KB ⊨ Q?

Check every model where the KB is true: the only model satisfying both P⇒Q and P is P=T, Q=T. In that single model Q is also True. So yes, KB ⊨ Q.

Inference in Propositional Logic

Inference is the process of deriving new true sentences from existing ones in the KB, using well-defined rules, without having to enumerate every possible model (which is called model checking and grows exponentially with the number of symbols).

Standard inference rules

Rule	Form	Reads as
Modus Ponens	α⇒β, α ⊢ β	If α implies β, and α is true, β is true.
And-Elimination	α∧β ⊢ α	From a conjunction, either conjunct follows.
Double Negation	¬¬α ⊢ α	Not-not-true means true.
Unit Resolution	α∨β, ¬β ⊢ α	If one disjunct is false, the other must be true.
Resolution	α∨β, ¬β∨γ ⊢ α∨γ	The general resolution rule (see §9).

Propositional resolution is refutation-complete: repeatedly applying resolution to a set of clauses will eventually derive the empty clause if and only if the original set is unsatisfiable. This single rule is enough to build a complete theorem prover for PL — no other inference rule is strictly required.

Conjunctive Normal Form (CNF)

Resolution requires sentences in CNF — a conjunction of clauses, each clause being a disjunction of literals, e.g. (P∨¬Q) ∧ (¬P∨R). Any PL sentence can be converted to CNF via:

1. Eliminate ⇔ using α⇔β ≡ (α⇒β)∧(β⇒α)

2. Eliminate ⇒ using α⇒β ≡ ¬α∨β

3. Push ¬ inward using De Morgan's laws until it applies only to atoms

4. Distribute ∨ over ∧ to reach clause form

Propositional Logic

A proposition is a declarative statement that is either True or False, but not both.”

Examples:

P: Delhi is the capital of India. → True

Q: 5 + 3 = 10. → False

“Is ‘How are you?’ a proposition?”

Answer: No, because it is a question and cannot be assigned True/False.

What is Propositional Logic?

Propositional Logic is a branch of logic in which we represent statements using symbols and determine whether combinations of those statements are true or false.

We normally use letters: P, Q, R, S...

For example: P = “It is raining.” Q = “I will carry an umbrella.”

Now we can combine them logically.

Logical Connectives

This is the main part of AI

Symbol Name Meaning

¬P NOT Negation

P ∧ Q AND Both must be true

P ∨ Q OR At least one must be true

P → Q Implication If P, then Q

P ↔️ Q Biconditional P if and only if Q

1. NOT — ¬P

Suppose: P = “Today is Monday.” Then:

¬P = “Today is not Monday.”

If P is True → ¬P is False.

If P is False → ¬P is True.

Example : “P = The student has submitted the assignment.”

What is ¬P?

“The student has not submitted the assignment.”

2. AND — P ∧ Q

AND means both conditions must be true.

Suppose:

P: I have my ID card.

Q: I have my college uniform.

Then:

P ∧ Q: I have my ID card and my college uniform.

For AND:

P Q P ∧ Q

T T T

T F F

F T F

F F F

Example

“You can enter the lab if you have your ID card AND your lab file.”

ID card? Yes. Lab file? No. Can you satisfy the condition?

→ No.

That's AND.

3. OR — P ∨ Q

OR means at least one condition is true.

Example: P: I will travel by metro.

Q: I will travel by bus.

P ∨ Q: “I will travel by metro OR bus.”

Truth table:

P Q P ∨ Q

T T T

T F T

F T T

F F F

Example

“You can submit the assignment through Google Classroom OR email.”

If the student submits through either one → condition is True.

4. IMPLICATION — P → Q

This is usually the most confusing connective, so spend more time here.

Read: P → Q as:

If P, then Q.

Example: P: It rains. Q: I carry an umbrella.

Therefore: P → Q means:

If it rains, then I carry an umbrella.

Truth table:

P Q P → Q

T T T

T F F

F T T

F F T

The easiest way to remember

Implication is FALSE only when:

P is True but Q is False.

Everything else is True.

Real-life example

Teacher says:

“If you attend the class, then you will get attendance.”

Student attends → attendance given → True

Student attends → attendance NOT given → False

This makes the concept much easier for students.

5. Biconditional — P ↔️ Q

Read it as: P if and only if Q or simply: P exactly when Q.

It is True when both have the same truth value.

P Q P ↔️ Q

T T T

T F F

F T F

F F T

Example:

“You can enter the examination hall if and only if you have your admit card.”

Both conditions must correspond.

Practice this example now!..

Let: P: It is raining. Q: I carry an umbrella.

Write these statements :

1. ¬P

2. P ∧ Q

3. P ∨ Q

4. P → Q

5. P ↔️ Q

Answers:

1. ¬P → It is not raining.

2. P ∧ Q → It is raining and I carry an umbrella.

3. P ∨ Q → It is raining or I carry an umbrella.

4. P → Q → If it is raining, then I carry an umbrella.

5. P ↔️ Q → It is raining if and only if I carry an umbrella.

Practice this example also:

P: Username is correct.

Q: Password is correct.

Then:

P ∧ Q

means: Username is correct AND password is correct.

Only when both are True can the user log in.

What if :

Username = correct

Password = incorrect

What is: P ∧ Q?

Answer → False

Example :

P: Student attends class.

Q: Student submits assignment.

Practice this example for given propositional :

1. ¬P

2. P ∧ Q

3. P ∨ Q

4. P → Q

5. P ↔️ Q

So “Propositional logic allows us to convert ordinary statements into mathematical/logical expressions. Once we represent statements using P, Q, R and logical operators, computers can evaluate those expressions systematically.”

Home work : Take 5 real-life statements and identify: Proposition P/Q/R representation

NOT

AND

Implication

Classroom Exercise: Propositional Logic

Exercise 1 — Proposition or Not?

Identify whether each statement is a proposition.

1. Delhi is the capital of India.

2. What is your name?

3. 10 + 5 = 15.

4. Close the door.

5. The Earth is flat.

6. Is it raining?

7. Java is a programming language.

8. Please submit your assignment.

Answers:

1. Yes ✅ 2. No ❌ 3. Yes ✅ 4. No ❌

2. Yes ✅ 6. No ❌ 7. Yes ✅ 8. No ❌

Exercise 2 — Assign P and Q

P: Neha is singing.

Q: She is having a mike.

Write in words:

1. ¬P

2. P ∧ Q

3. P ∨ Q

4. P → Q

5. P ↔️ Q

Exercise 3 — Truth Table Challenge Let:

P: Student attends class.

Q: Student submits assignment.

Complete this table :

P Q P ∧ Q P ∨ Q P → Q

T T ? ? ?

T F ? ? ?

F T ? ? ?

F F ? ? ?

Time : 5 minutes.

Answer:

P Q P ∧ Q P ∨ Q P → Q

T T T T T

T F F T F

F T F T T

F F F F T

⭐ P → Q is false only when P is True and Q is False.

Exercise 4 — Real-Life Logic

Convert these into symbolic form.

Let:

P: I have an ID card.

Q: I have my college uniform.

1. I have an ID card and uniform.

2. I have an ID card or uniform.

3. I don't have an ID card.

4. If I have an ID card, then I can enter the college.

5. I have an ID card if and only if I have my uniform.

Answers

1. P ∧ Q

2. P ∨ Q

3. ¬P

4. P → Q (if Q is defined as “I can enter the college”)

5. P ↔️ Q

Exercise 5 Let:

P: Username is correct.

Q: Password is correct.

A user can log in only when both the username and password are correct.

What logical expression represents this?

Answer:

P ∧ Q

Username = True, Password = False. Can the user log in?

Answer: No → False.

⚡ Quick 5-Minute Challenge

Write these on your noteboo:

P = “The computer is switched on.”

Q = “The computer is connected to Wi-Fi.”

Explain:

1. What does P ∧ Q mean?

2. What does P ∨ Q mean?

3. What does ¬P mean?

4. What does P → Q mean?

5. When is P → Q false?

What is a Logical Agent in AI

"Logical agents" refers to AI agents that use formal logic to represent knowledge about the world and to reason about what to do. It's a core topic in classical/symbolic AI (this is chapter terminology from Russell & Norvig's Artificial Intelligence: A Modern Approach, among other places).

The core idea

Instead of hard-coding behavior for every situation, a logical agent:

Maintains a knowledge base (KB) — a set of sentences in some logical language, representing facts about the world.
Perceives the environment and adds new facts to the KB.
Infers new facts using logical rules of inference (things not directly observed but that follow from what's known).
Decides on actions by reasoning about what the KB implies is true, safe, or goal-achieving, then adds the chosen action back to the KB.

This is often summarized as the agent having a TELL operation (add knowledge) and an ASK operation (query what follows).

Key building blocks

Propositional logic: statements that are true/false, combined with AND, OR, NOT, IMPLIES. Simple but limited — can't easily express things like "every room is dirty" without enumerating each room.
First-order logic (FOL): adds objects, relations, and quantifiers (∀ "for all", ∃ "there exists"), letting agents express general rules ("all humans are mortal") rather than specific instances.
Inference: mechanisms like resolution, forward chaining, and backward chaining that derive new true statements from the KB.
Entailment: the idea that KB ⊨ α means "α is true in every world where KB is true" — the logical backbone of what an agent is allowed to conclude.

Example

Setup: A smart home agent decides whether to turn on the sprinklers. It knows a simple rule about rain and wet grass.

Symbols (propositions):

R = "It rained last night"
W = "The grass is wet"
S = "The sprinkler ran last night"

Rules (knowledge given to the agent):

 directly)

Goal: Did the sprinkler run?

Inference, step by step:

We know W is true (grass is wet — observed fact).
We know ¬R (it did not rain).
From rule R → W: this tells us rain would cause wet grass, but since ¬R, this rule doesn't explain the wetness. (Careful: we can't conclude ¬W from ¬R — that would be a logical error called "denying the antecedent." All we know is rain isn't the cause here.)
So the grass is wet for some other reason. The only other rule we have is S → W.
But wait — logically, W alone doesn't prove S either (wet grass could have another unknown cause — this is the same fallacy in reverse, called "affirming the consequent").
Honest conclusion: With just these two rules, the agent cannot strictly prove S is true. It can only say: "Rain is ruled out as the cause; if the sprinkler is the only other possible cause in this model, then S is likely true" — but that's a probabilistic guess, not a valid deduction.

This is actually a useful lesson: it shows a real limitation of pure logical agents — they can only conclude what is guaranteed by the rules, never what is merely plausible.

A sprinkler is a device that sprays water, usually used to water grass, plants, or a lawn automatically. It's often connected to a house or underground pipe system.

In the logic example, "sprinkler" wasn't about the device itself — it was just used as a stand-in fact (a proposition) that represents one possible reason the grass got wet, separate from rain.

Another Example

Setup: An agent is in a cave with rooms. Some rooms are dangerous because they contain a pit. The agent can't see a pit directly, but if a room is next to a pit, it feels a "breeze."

Symbols (propositions):

P1,2 = "There is a pit in room [1,2]"
B1,1 = "The agent feels a breeze in room [1,1]"

Rule (knowledge given to the agent):

A room has a breeze if and only if a neighboring room has a pit. For room [1,1] with neighbor [1,2] and [2,1]:

B1,1  ⟺  (P1,2 ∨ P2,1)

Read as: "Breeze in [1,1] if and only if there's a pit in [1,2] OR in [2,1]."

What the agent perceives:

B1,1 = true       (agent feels a breeze in [1,1])
P2,1 = false      (agent already checked, no pit there)

Inference (simple logic, step by step):

From the rule: B1,1 ⟺ (P1,2 ∨ P2,1)
We know B1,1 is true, so (P1,2 ∨ P2,1) must be true.
We know P2,1 is false.
Since the OR needs at least one side true, and one side (P2,1) is false, the other side must be true.
Conclusion: P1,2 = true — there is a pit in room [1,2].

The agent never "saw" the pit — it deduced it purely from a rule plus two known facts. That's the essence of a logical agent: it doesn't guess, it proves.

This same idea scales up — real systems chain dozens of rules together automatically (this is called inference), but the underlying mechanic is always this kind of step-by-step deduction.

Setup: We want to represent facts about a family and derive a new fact using a general rule.

Objects: Ram, Lava, Kush
Predicates: Father(x, y) = "x is the father of y" ; Sibling(x, y) = "x and y are siblings"

Facts given to the system:Father(Ram, Lava) ("Ram is the father of Lava")

Father(Ram Kush)       ("Ram is the father of Kush")

General rule (using a quantifier):

∀x ∀y ∀z  Father(x, y) ∧ Father(x, z) ∧ (y ≠ z) → Sibling(y, z)

("For any x, y, z: if x is the father of both y and z, and y and z are different people, then y and z are siblings")

Inference:

Plug in x = Ram, y = Lava, z = Kush (this substitution step is called Universal Instantiation — we discussed this earlier).
Check the rule's conditions: Father(Ram, Lava) ✓, Father(Ram, Kush) ✓, Lava ≠ Kush ✓.
All conditions hold, so we conclude:

Sibling(Lava, Kush)   ("Lava and Kush are siblings")

What makes this a good teaching example:

It shows a function-free, pure relational rule (no FatherOf(x) function needed here — Father(x,y) is a relation, not a function).
It shows three variables in one rule (x, y, z), which is a step up in complexity from the earlier single-variable Socrates example.
It naturally introduces the inequality condition (y ≠ z), a detail students often forget — without it, the rule would wrongly conclude every person is their own sibling (Sibling(Lava, Lava)).

INFERENCES IN LOGICAL REASONING

What Is an Inference?

An inference is a conclusion reached on the basis of evidence and reasoning, rather than on explicit statement. When we infer, we go beyond what is directly given and add something new using logic, prior knowledge, or pattern recognition.

"Inference = Given information + Reasoning → New conclusion (not explicitly stated)." Emphasise that the conclusion is not printed in the data; it is built by the reader/thinker.

Example of Analogy — The Detective and the Doctor

• Sherlock Holmes analogy: Holmes never “sees” the criminal confess. He sees muddy boots, a torn sleeve, and a pocket watch, and infers the person’s profession and recent journey. The clues are the premises; the deduction is the inference.

• Doctor analogy: A doctor does not see “dengue” written on the patient. She sees fever, rash, and low platelet count, and infers the diagnosis. Symptoms = premises; diagnosis = inference.

• Programmer analogy: A programmer does not see the word “bug” in the output. She sees a wrong result and a stack trace, and infers which line of code is faulty — this is exactly the same inferential process used in debugging.

Inference vs. Related Terms

Types of Inference

Logical reasoning courses generally classify inference into three major types.

Deductive Inference (General → Specific)

Moves from general premises that are accepted as true to a specific conclusion that must also be true if the premises are true. It is “certainty-preserving.”

Classic example (syllogism): Premise 1: All BCA students study Discrete Mathematics. Premise 2: Rahul is a BCA student. Conclusion: Rahul studies Discrete Mathematics. (100% certain if premises are true)

• CS analogy: A compiler applying a fixed grammar rule to source code — if the rule and the input token stream are correct, the parse result is guaranteed correct.

• Used in: mathematical proofs, algorithm correctness proofs, rule-based expert systems, if-else logic in programs.

Inductive Inference (Specific → General)

Moves from specific observations to a general conclusion. The conclusion is probable, not certain — new evidence can overturn it.

Example: Observation: The last 50 emails from "lottery-winner@xyz.com" were spam. Conclusion: Emails from this address are (probably) spam. (Almost certainly true, but not logically guaranteed — the 51st could be genuine.)

• CS analogy: This is exactly how a machine-learning spam filter or recommendation engine works — it generalises a rule from many training examples, and can occasionally be wrong.

• Used in: statistics, machine learning, scientific hypotheses, testing software with sample test cases and generalising "the module works."

Abductive Inference (Best Explanation)

Starts from an observation and infers the most likely explanation, given incomplete information. Common in diagnosis and troubleshooting.

Example: Observation: The program crashes only when the input file is empty. Best explanation: The code probably does not handle the empty-file edge case. (Plausible, and the first hypothesis a debugger would test — but not the only possible explanation.)

• CS analogy: This is the everyday logic of debugging, root-cause analysis, and medical/technical diagnosis — you pick the explanation that best fits the clues, then test it.

Side-by-Side Comparison

Valid and Invalid Inferences

An inference is logically valid when the conclusion necessarily follows from the premises, regardless of whether the premises themselves happen to be true. Validity is about structure, not content.

Valid form (even with a false premise): All cats can fly. (false premise) Tom is a cat. Therefore, Tom can fly. → VALID in structure, but UNSOUND, because the first premise is false.

• Sound argument = valid structure + true premises. This is the gold standard in logical reasoning.

• Common student trap: assuming an argument is “correct” just because the conclusion feels true. Structure must be checked independently of the conclusion's plausibility.

Frequent Fallacies (Invalid Inferences) — with Everyday Examples

Facts & Figures

• Aristotle formalised deductive reasoning through the syllogism over 2,300 years ago (4th century BCE) — still the backbone of formal logic taught today.

• Inductive reasoning was systematically championed by Francis Bacon in the early 1600s as the foundation of the modern scientific method.

• The term "abduction" was coined by philosopher C. S. Peirce in the late 19th century to describe hypothesis-forming reasoning, distinct from deduction and induction.

• Modern relevance for BCA students: supervised machine learning is essentially large-scale inductive inference; expert systems and rule engines rely on deductive inference; and automated debugging/diagnostic tools rely on abductive inference.

• Logical reasoning sections are a standard, heavily-weighted component of campus placement aptitude tests (commonly 20–25% of an aptitude paper in Indian recruitment drives), making this topic directly relevant to BCA placements.

Identify type of inference?

• "Every laptop in the lab uses Windows. This is a lab laptop. So it uses Windows." — Deductive

• "Every time I've submitted an assignment late on this portal, I've lost 10% marks. I'll probably lose marks if I submit late again." — Inductive

• "My Wi-Fi icon shows connected, but no page loads. The router was just restarted by my flatmate." — Abductive (best explanation: router still rebooting/DNS issue)

Summary

"Every time you debug code, train a model, or prove a theorem, you are practising one of these three inference types — logical reasoning is not an abstract subject, it is what you already do every day as a programmer."

Semantic Networks

A semantic network is a graph-based knowledge representation method in which:

Nodes represent objects, concepts, or events.
Edges represent relationships between nodes.

Semantic networks are commonly represented as labelled directed graphs.[youtube]

In a semantic net, Penguin inherits from Bird but overrides can fly In a frame, Penguin has a slot Can Fly = No despite Bird’s default Yes.

Definition: A semantic network (or semantic net) is a graph-based representation of knowledge.

Structure:
- Nodes → represent concepts or entities (e.g., Bird, Penguin).
- Edges → represent relationships (e.g., is-a, has-part, can-do).
Example:
- Node: Bird → property: can fly.
- Node: Penguin → edge: is-a Bird but property override: cannot fly.
Strengths:
- Intuitive and visual.
- Supports inheritance (properties flow down the hierarchy).
Weaknesses:

Limited for complex quantified logic.
Can become ambiguous with exceptions.

Example:

Animal

↑

Mammal

↑

Dog

has-a

↓

Tail

A semantic network represents:

Concepts
Relationships
Properties

🗂️ Frames

Definition: Frames are object-centered structures that represent stereotypical situations or entities.
Structure:

Frame = like a data record.
Slots = attributes or properties (e.g., Color, Habitat).
Fillers = values for slots (e.g., Color = White, Habitat = Antarctica).
Facets = constraints, default values, or procedural attachments.

A frame is like a structured record.

Example

FRAME: Student

Name: Rahul

Age: 20

Course: BCA

Semester: 5

Analogy: A frame is similar to a class/object structure in programming.

Example:
- Frame: Penguin
  - Slot: Type → Bird
  - Slot: Can Fly → Default = Yes, Override = No
  - Slot: Habitat → Antarctica
Strengths:
- Organizes structured knowledge naturally.
- Handles defaults and inheritance well.
Weaknesses:

Exceptions across frames can be clumsy.
Less visual than semantic nets.

Semantic Net → like a mind map connecting ideas.

Frame → like a data table or form with fields filled in.

Example

text

is-a

Dog -------> Animal

| has

Tail

This represents:

Dog is an animal.
Dog has a tail.

Common Relationships

Relationship	Meaning	Example
is-a	Class relationship	Dog is-a Animal
instance-of	Object belongs to a class	Bruno instance-of Dog
has-part	Component relationship	Car has-part Engine
owns	Possession	Riya owns Laptop
located-in	Location	College located-in Delhi
causes	Causal relationship	Rain causes WetRoad
uses	Functional relationship	Student uses Library

APPROACHES TO KNOWLEDGE REPRESENTATION

Teach:

Logical representation
Semantic networks
Frames
Production rules
Ontologies

FIRST-ORDER LOGIC

FOL introduces:

Objects
Predicates
Variables
Quantifiers

Example:

Human(Socrates)

Rule:

∀x Human(x) → Mortal(x)

Therefore:

Mortal(Socrates)

FORWARD CHAINING

Starts with known facts.

Facts

↓

Rules

↓

New Facts

↓

More Rules

↓

Conclusion

Example:

Fact:

Bird(Tweety)

Rule:

Bird(x) → CanFly(x)

Conclusion:

CanFly(Tweety)

BACKWARD CHAINING

Starts with a goal.

Goal

↓

Which rule can prove it?

↓

What conditions are needed?

↓

Can conditions be proven?

Analogy

A detective asks:

"How can I prove the suspect is guilty?"

Then works backward from the conclusion.

UNIFICATION

Unification finds substitutions that make expressions identical.

Example:

Likes(Ravi, x)

Likes(Ravi, Mary)

Substitution:

x = Mary

RESOLUTION

Resolution is an inference technique used to derive conclusions by contradiction.

Case Study Framework

Explore more case studies here also

Title: AI‑Powered Library Search System for Academic Resources

1. Problem Statement

Students and faculty often struggle to locate relevant academic resources (books, research papers, journals) in large digital libraries. Traditional keyword‑based search fails to capture context, leading to irrelevant or incomplete results.

Challenge: How can AI‑driven search techniques improve accuracy, relevance, and user satisfaction in academic resource retrieval?

2. Objectives

Implement a smart search engine using AI techniques.
Compare keyword‑based search vs semantic search.
Demonstrate how heuristic search algorithms (A*, BFS, DFS) can optimize query handling.
Evaluate system performance using metrics like precision, recall, and response time.

3. Methodology

Data Collection

Use a dataset of academic papers, books, and journals (e.g., from Google Scholar, arXiv, or institutional repositories).

System Design

Phase 1: Implement keyword‑based search (TF‑IDF, inverted index).
Phase 2: Implement semantic search using NLP + embeddings (Word2Vec, BERT).
Phase 3: Apply heuristic search algorithms to optimize query expansion and ranking.

Tools & Technologies

Python (scikit-learn, NLTK, spaCy, gensim)
Database: MySQL / MongoDB
Graph search: networkx library

Evaluation

Compare keyword vs semantic search results.
Measure accuracy (precision/recall), efficiency (response time), and user satisfaction (survey/feedback).

4. Expected Outcomes

Semantic search provides more relevant results than keyword search.
Heuristic search improves efficiency in query handling.
Students and faculty experience faster, smarter resource discovery.
Case study demonstrates practical application of AI + search techniques in education.

5. Deliverables

Working prototype of the AI‑powered search system.
Comparative analysis report (keyword vs semantic search).
Presentation with flowcharts, algorithm explanation, and performance metrics.

📖 Case Study 2

Title: AI‑Driven Job Portal Recommendation Engine

1. Problem Statement

Job seekers often face difficulty finding suitable opportunities due to generic keyword matching. Employers also struggle to identify the right candidates quickly.

Challenge: How can AI search techniques improve job‑candidate matching efficiency?

2. Objectives

Implement a recommendation engine for job portals.
Compare rule‑based search vs AI‑driven semantic search.
Use heuristic search to rank candidates/jobs by relevance.

3. Methodology

Dataset: Job listings + candidate resumes (sample datasets or synthetic data).
Techniques:

Keyword search (TF‑IDF).
Semantic search (embeddings, cosine similarity).
Heuristic ranking (A* search for best fit).

Tools: Python, scikit‑learn, spaCy, gensim.

4. Expected Outcomes

Improved candidate‑job matching accuracy.
Faster retrieval compared to traditional search.
Demonstrated use of AI in recruitment systems.

📖 Case Study 3

Title: Smart Campus Navigation Using AI Search Algorithms

1. Problem Statement

Large campuses confuse new students and visitors. Traditional maps are static and don’t adapt to real‑time changes (blocked paths, events).

Challenge: How can AI search techniques optimize navigation inside a campus?

2. Objectives

Design a smart navigation system for campus routes.
Apply graph search algorithms (Dijkstra, A*, BFS).
Integrate real‑time updates (blocked paths, shortest routes).

3. Methodology

Dataset: Campus map converted into a graph (nodes = locations, edges = paths).
Techniques:

BFS/DFS for basic pathfinding.
Dijkstra/A* for shortest path with heuristics.

Tools: Python, networkx, Google Maps API (optional).

4. Expected Outcomes

Efficient route suggestions for students/faculty.
Demonstrated application of AI search in real‑world navigation.
Prototype mobile/web app for campus use.

📖 Case Study 4

Title: AI‑Powered Medical Diagnosis Support System

1. Problem Statement

Doctors often need quick decision support for diagnosis. Traditional systems rely on static rules and don’t adapt well to complex symptom combinations.

Challenge: How can AI search techniques assist in faster, more accurate diagnosis?

2. Objectives

Build a decision support system for medical diagnosis.
Compare rule‑based search vs heuristic search.
Use AI to suggest possible conditions based on symptoms.

3. Methodology

Dataset: Public medical datasets (e.g., symptom‑disease mappings).
Techniques:

Decision trees for rule‑based diagnosis.
Heuristic search for narrowing down possibilities.
NLP for symptom input.

Tools: Python, scikit‑learn, NLTK.

4. Expected Outcomes

Faster diagnosis suggestions.
Demonstrated efficiency of heuristic search in medical decision support.
Prototype system usable for academic demonstration.

CLASS Framework for AI- BCA-303
1) Podcast-based learning

2) Flip class
3) PPT presentation
4) Research paper publication
5) Minor Project
6) Assignments : 3
7) Lab file
8)Case studies just click here
9) Group Discussion (GD)
10)Blog writing on AI / ML
11) Quiz
12)AI tool comparison (compare different AI tools for the same task) like chatgpt, perplexity, copilot, claude etc.
13)Journal/article review (summarize and critique a recent AI paper)
14)Peer teaching (students teach one topic to the class)
15) Prompt engineering exercises (for generative AI)
16)Model implementation challenge (implement a given algorithm)
17)Debugging challenge (find and fix errors in ML code)
18)Ethics debate (e.g., "Should AI replace human decision-making?")
19) GitHub portfolio submission (upload code and documentation)

20) Research proposal writing (identify a problem and propose an AI solution)

Each student to:

1. Create a GitHub portfolio.

2. Complete 10 Kaggle micro-courses.

3. Build 5 Google Colab notebooks.

4. Participate in one Kaggle competition.

5. Fine-tune one Hugging Face NLP model.

6. Develop one end-to-end AI mini-project.

7. Visit one AI/robotics lab or science centre and submit a reflection report.

8. Present one recent AI research paper.

Pages

Master AI with BCA 303T

Core idea

Easy way to remember

A* and hill climbing

A* example

Why it matters

Limitation

Tiny example

A* flowchart

Hill climbing flowchart

Simple comparison

A* Python code

Example graph

Step-wise explanation

1. graph

2. h(node, goal)

3. open_list

4. g_cost

5. f = g + h

6. came_from

7. Main loop

8. Path reconstruction

Output for this example

“A* tries to find the shortest path by combining two things:

Python code

1. Class and setup

2. Finding minimum cost

3. Main AO* function

4. Choosing the best group

5. Solving child nodes

6. Marking node as solved

7. Graph example

8. Heuristic values

9. Running the algorithm

10. Printing result

Very short version

Start with plain English, not symbols

Python program

Negation — the rule they must memorize

Practice exercise set

What Is an Inference?

Example of Analogy — The Detective and the Doctor

Inference vs. Related Terms

Types of Inference

Deductive Inference (General → Specific)

Inductive Inference (Specific → General)

Abductive Inference (Best Explanation)

Side-by-Side Comparison

Valid and Invalid Inferences

Frequent Fallacies (Invalid Inferences) — with Everyday Examples

Facts & Figures

Identify type of inference?

Summary

🗂️ Frames

No comments:

Post a Comment

E-Learning Resource - Tecnia Library

Pages

Pages

1. `graph`

2. `h(node, goal)`

3. `open_list`

4. `g_cost`

5. `f = g + h`

6. `came_from`