ARTIFICIAL INTELLIGENCE FUNDAMENTALS (AIF)

│
├─── UNIT 1: INTRODUCTION TO AI
│ │
│ ├─── CORE CONCEPTS
│ │ ├─── Definition & Need [Branch creating intelligent systems mimicking human cognition]
│ │ ├─── Scope (Narrow/General/Super AI) [Range from task-specific to human-surpassing intelligence]
│ │ ├─── Examples (Maps, ChatGPT, Alexa, Face Recognition) [Real-world AI applications in daily use]
│ │ └─── AI vs Traditional Software [Learning & adaptation vs fixed rule-based programming]
│ │
│ ├─── ★★★ CAN MACHINES THINK? ★★★
│ │ ├─── Human Thinking (Emotions, Consciousness, Creativity) [Mental processes involving feelings & self-awareness]
│ │ ├─── Machine Thinking (Algorithms, Data, Logic) [Computational processes following programmed rules]
│ │ ├─── Alan Turing's View (1950) [Proposed behavioral test instead of defining thinking]
│ │ └─── ★★★ TURING TEST ★★★ [Test where machine passes if judge can't identify it from human]
│ │ ├─── Components (Judge, Human, Machine) [Three participants in the imitation game]
│ │ ├─── Process (Text-based, Imitation) [Communication through text to hide physical form]
│ │ ├─── Purpose (Behavior vs Internal Thinking) [Evaluates external actions not internal states]
│ │ └─── Evaluation Criteria [Judge's inability to distinguish determines success]
│ │
│ ├─── HISTORY OF AI
│ │ ├─── Before 1950 (Philosophical Foundations) [Early ideas about logic & machine reasoning]
│ │ ├─── 1950 (Turing Question) [Alan Turing asked "Can machines think?"]
│ │ ├─── 1956 (John McCarthy, Dartmouth Conference) [Term "Artificial Intelligence" coined, AI recognized as field]
│ │ ├─── 1960s (Early Programs, Game Playing) [Development of basic problem-solving programs]
│ │ ├─── 1970s (First AI Winter, Challenges) [Period of reduced funding due to limited progress]
│ │ ├─── 1980s (Expert Systems Era) [Rule-based systems for specialized domains gained popularity]
│ │ ├─── 1990s (Machine Learning Growth) [Shift from rules to learning from data]
│ │ ├─── 2000s (Data-Driven AI, Big Data) [Internet & massive datasets enabled better AI]
│ │ └─── Present (Deep Learning, Neural Networks) [Brain-inspired models dominate modern AI]
│ │
│ ├─── ★★★ INTELLIGENT AGENT ★★★ [Entity that perceives environment & acts to achieve goals]
│ │ │
│ │ ├─── ★★ Definition ★★
│ │ │ └─── Entity (Perceives → Sensors, Acts → Actuators) [System observing via sensors, responding via actuators]
│ │ │
│ │ ├─── Components [Four basic parts of intelligent agent]
│ │ │ ├─── Sensors (Camera, Microphone, Keyboard) [Input devices collecting environmental information]
│ │ │ ├─── Actuators (Motors, Speakers, Display) [Output devices performing actions in environment]
│ │ │ ├─── Agent Program (Decision Logic) [Brain deciding which action to take]
│ │ │ └─── Environment (Surroundings) [External world where agent operates]
│ │ │
│ │ ├─── ★★ Properties ★★ [Key characteristics defining intelligent behavior]
│ │ │ ├─── Autonomy (Independent Operation) [Works without constant human intervention]
│ │ │ │ └─── Example: Roomba Vacuum [Self-navigating cleaning robot]
│ │ │ ├─── Reactivity (Real-time Response) [Perceives & responds to environmental changes]
│ │ │ │ └─── Example: Smart Thermostat [Adjusts temperature based on conditions]
│ │ │ ├─── Pro-activeness (Anticipates Needs) [Initiates goal-directed actions proactively]
│ │ │ │ └─── Example: Spam Filter [Blocks threats before reaching inbox]
│ │ │ ├─── Social Ability (Interaction/Collaboration) [Communicates with other agents/humans]
│ │ │ │ └─── Example: Siri [Coordinates with multiple apps & services]
│ │ │ ├─── Learning/Adaptability (Improves via Experience) [Performance enhances over time through feedback]
│ │ │ │ └─── Example: Netflix Recommendations [Refines suggestions based on viewing history]
│ │ │ └─── Rationality (Goal-Oriented, Optimal Actions) [Selects best actions to maximize performance]
│ │ │ └─── Example: Self-driving Car [Optimizes routes considering traffic & safety]
│ │ │
│ │ ├─── ★★★ RATIONALITY ★★★ [Ability to choose best action for goal achievement]
│ │ │ ├─── Definition (Best Action for Goals) [Selecting action that maximizes performance measure]
│ │ │ ├─── Performance Maximization [Always tries to do the right thing]
│ │ │ ├─── Based On (Perceptions, Knowledge, Actions) [Decisions use available information & capabilities]
│ │ │ ├─── Rationality ≠ Perfection [Makes best decision with available info, not omniscient]
│ │ │ ├─── Rationality vs Intelligence [Right action vs thinking/learning ability]
│ │ │ └─── Examples (Vacuum Cleaner, Self-driving Car) [Cleaning efficiently, following traffic rules]
│ │ │
│ │ ├─── Structure [Architectural organization of agent components]
│ │ │ ├─── Environment (Rooms, Roads, Chessboard) [Operational surroundings providing context]
│ │ │ ├─── Sensors → Perception [Input pathway for environmental awareness]
│ │ │ ├─── Agent Program → Processing [Decision-making computational core]
│ │ │ └─── Actuators → Actions [Output pathway for environmental interaction]
│ │ │
│ │ └─── Behavior [Patterns of actions agent performs]
│ │ ├─── Actions Based on Perceptions [Responses determined by sensory input]
│ │ ├─── Determined by Agent Program [Logic/rules governing action selection]
│ │ ├─── Goal Achievement [Actions directed toward objective completion]
│ │ └─── Rational Behavior [Optimal action selection for performance]
│ │
│ ├─── ENVIRONMENT IN AI [Everything outside agent with which it interacts]
│ │ ├─── Definition (Everything Outside Agent) [External world beyond agent boundaries]
│ │ ├─── Provides Inputs [Supplies information for agent perception]
│ │ ├─── Affected by Actions [Changes based on agent's operations]
│ │ ├─── Examples (Roads, Rooms, Chessboard) [Specific operational contexts]
│ │ └─── Types (Deterministic, Stochastic, etc.) [Classifications by predictability & properties]
│ │
│ ├─── ★★ AI PROBLEMS ★★ [Tasks requiring reasoning, search, or decision-making]
│ │ │
│ │ ├─── Definition (Task Requiring Reasoning/Search) [Challenge solvable through intelligent processing]
│ │ │
│ │ ├─── Characteristics [Properties defining AI problem complexity]
│ │ │ ├─── Large State Space [Vast number of possible states/solutions]
│ │ │ ├─── Uncertainty [Unpredictable outcomes of actions]
│ │ │ ├─── Incomplete Information [Agent lacks full environmental knowledge]
│ │ │ ├─── Dynamic Environment [Conditions change during problem-solving]
│ │ │ └─── Multiple Solutions [More than one acceptable answer exists]
│ │ │
│ │ └─── Components [Elements defining the problem structure]
│ │ ├─── Initial State [Starting configuration/position]
│ │ ├─── Actions/Operators [Possible moves/operations available]
│ │ ├─── State Space [Set of all reachable states]
│ │ ├─── Goal State [Desired final configuration]
│ │ └─── Path Cost [Expense of reaching goal from start]
│ │
│ ├─── UNDERLYING ASSUMPTIONS [Foundational conditions assumed in AI design]
│ │ └─── Basic Conditions for AI Design [Simplifying assumptions enabling practical solutions]
│ │
│ ├─── ★★★ AI TOOLS & TECHNIQUES ★★★ [Resources & methods for building intelligent systems]
│ │ │
│ │ ├─── TOOLS (What We Use) [Software, languages, frameworks for AI development]
│ │ │ │
│ │ │ ├─── Programming Languages [Code platforms for AI implementation]
│ │ │ │ ├─── Python (NumPy, Pandas, TensorFlow, PyTorch) [Most popular, rich AI ecosystem]
│ │ │ │ ├─── LISP (Symbolic Processing, Expert Systems) [Early AI language for symbolic reasoning]
│ │ │ │ └─── PROLOG (Logic-based, NLP) [Logic programming for reasoning systems]
│ │ │ │
│ │ │ ├─── Frameworks & Libraries [Pre-built tools simplifying AI implementation]
│ │ │ │ ├─── TensorFlow (Deep Learning) [Google's neural network framework]
│ │ │ │ ├─── PyTorch (Research) [Facebook's research-oriented deep learning]
│ │ │ │ ├─── Scikit-learn (ML Algorithms) [Classical machine learning library]
│ │ │ │ └─── Keras (Neural Networks API) [High-level neural network interface]
│ │ │ │
│ │ │ ├─── Knowledge Representation Tools [Systems for storing & organizing knowledge]
│ │ │ │ ├─── Knowledge Bases [Repositories of facts & rules]
│ │ │ │ ├─── Rule-based Systems [If-then logic structures]
│ │ │ │ ├─── Semantic Networks [Graph-based concept relationships]
│ │ │ │ └─── Frames & Ontologies [Structured knowledge representations]
│ │ │ │
│ │ │ └─── Data Handling Tools [Systems for managing AI data requirements]
│ │ │ ├─── Databases [Structured data storage systems]
│ │ │ ├─── Big Data (Hadoop, Spark) [Distributed processing for massive datasets]
│ │ │ └─── Data Preprocessing Libraries [Tools for cleaning & preparing data]
│ │ │
│ │ └─── TECHNIQUES (How We Solve) [Methods for problem-solving in AI]
│ │ │
│ │ ├─── Search Techniques [Methods exploring solution spaces]
│ │ │ ├─── BFS (Breadth-First) [Level-by-level exploration using queue]
│ │ │ ├─── DFS (Depth-First) [Deep exploration using stack]
│ │ │ ├─── Best-First Search [Heuristic-guided node selection]
│ │ │ └─── A* (Cost + Heuristic) [Optimal search combining actual & estimated cost]
│ │ │
│ │ ├─── Knowledge Representation [Encoding real-world knowledge for machines]
│ │ │ ├─── Propositional Logic [Boolean logic with true/false statements]
│ │ │ ├─── Predicate Logic [First-order logic with variables & quantifiers]
│ │ │ ├─── Semantic Networks [Node-link graphs representing concepts]
│ │ │ └─── Frames [Slot-filler structures for objects]
│ │ │
│ │ ├─── Reasoning Techniques [Methods for drawing conclusions]
│ │ │ ├─── Logical Reasoning [Deduction using rules & facts]
│ │ │ ├─── Probabilistic Reasoning [Inference under uncertainty]
│ │ │ └─── Fuzzy Reasoning [Handling imprecise/vague information]
│ │ │
│ │ ├─── Learning Techniques [Methods enabling improvement from experience]
│ │ │ ├─── Machine Learning [Algorithms learning patterns from data]
│ │ │ ├─── Neural Networks [Brain-inspired layered models]
│ │ │ └─── Reinforcement Learning [Learning through reward/punishment]
│ │ │
│ │ └─── Planning Techniques [Methods for action sequence determination]
│ │ ├─── Goal-based Planning [Working backward from objectives]
│ │ ├─── State-space Planning [Searching through possible states]
│ │ └─── Heuristic Planning [Using estimates to guide planning]
│ │
│ ├─── AI APPLICATIONS [Real-world uses of artificial intelligence]
│ │ ├─── Healthcare (Diagnosis, Medical Imaging, Surgery) [Disease detection, scan analysis, robotic operations]
│ │ ├─── Education (Personalized Learning, Tutoring) [Adaptive content, intelligent teaching systems]
│ │ ├─── Business/Finance (Fraud Detection, Risk Analysis) [Transaction monitoring, investment assessment]
│ │ ├─── Robotics (Navigation, Object Recognition) [Movement planning, visual identification]
│ │ ├─── Transportation (Self-driving Cars, Route Optimization) [Autonomous vehicles, traffic management]
│ │ ├─── NLP (Chatbots, Virtual Assistants) [Conversational AI, voice-controlled helpers]
│ │ ├─── Entertainment (Recommendations, Gaming) [Content suggestion, intelligent opponents]
│ │ └─── Security (Surveillance, Threat Detection) [Monitoring systems, anomaly identification]
│ │
│ └─── CHALLENGES OF AI [Obstacles & limitations in AI development]
│ ├─── Data Dependency [Requires large high-quality datasets to function]
│ ├─── High Cost [Expensive hardware & skilled professionals needed]
│ ├─── Lack of Human Intelligence [Missing emotions, creativity, common sense]
│ ├─── Ethical & Privacy Issues [Concerns about data misuse & surveillance]
│ ├─── Bias & Fairness [Systems inherit prejudices from training data]
│ ├─── Security Risks [Vulnerability to cyber-attacks & manipulation]
│ └─── Job Displacement [Automation may reduce employment opportunities]
│
│
├─── UNIT 2: PROBLEM SOLVING
│ │
│ ├─── ★★★ PROBLEM-SOLVING AGENT ★★★ [Intelligent agent deciding action sequences to achieve goals]
│ │ │
│ │ ├─── Definition [Agent determining sequence of actions for goal achievement]
│ │ │ └─── Agent Deciding Action Sequence for Goal [Plans & executes steps toward objective]
│ │ │
│ │ ├─── Process (Understand → Search → Execute) [Three-phase approach to problem resolution]
│ │ │
│ │ ├─── Applications [Domains where problem-solving agents are used]
│ │ │ ├─── Robotics [Autonomous movement & task completion]
│ │ │ ├─── Game Playing [Strategic move selection in games]
│ │ │ ├─── Automated Planning [Scheduling & resource allocation]
│ │ │ ├─── Decision-making Systems [Optimal choice selection]
│ │ │ └─── Navigation & Route Planning [Path finding & optimization]
│ │ │
│ │ └─── Working Steps [Five-stage problem-solving process]
│ │ ├─── 1. Perception (Collect Info via Sensors) [Gather environmental data through inputs]
│ │ ├─── 2. Problem Formulation [Define problem structure & components]
│ │ │ ├─── Initial State [Starting configuration/position]
│ │ │ ├─── Possible Actions [Available operations/moves]
│ │ │ └─── Goal State [Desired final configuration]
│ │ ├─── 3. Search for Solutions [Explore action sequences leading to goal]
│ │ ├─── 4. Evaluation & Decision Making [Compare & select best solution]
│ │ │ ├─── Cost [Financial/computational expense]
│ │ │ ├─── Time [Duration required]
│ │ │ ├─── Resource Usage [Memory, energy, materials consumed]
│ │ │ └─── Probability of Success [Likelihood of achieving goal]
│ │ └─── 5. Learning & Improvement [Enhance future performance from experience]
│ │
│ ├─── TYPES OF PROBLEMS [Classification by action reversibility & impact]
│ │ │
│ │ ├─── 1. Ignorable Problems [Steps can be skipped without affecting solution]
│ │ │ ├─── Some Steps Can Be Ignored [Non-critical actions can be omitted]
│ │ │ ├─── Low Complexity/Risk [Simple with minimal consequences]
│ │ │ └─── Example: ML Parameter Tuning [Fine-tuning hyperparameters]
│ │ │
│ │ ├─── 2. Recoverable Problems [Mistakes can be corrected/undone]
│ │ │ ├─── Wrong Actions Can Be Corrected [Errors are fixable]
│ │ │ ├─── Actions Are Reversible [Can backtrack from decisions]
│ │ │ └─── Example: Game Playing [Try different strategies after mistakes]
│ │ │
│ │ └─── 3. Irrecoverable Problems [Actions permanent, cannot be undone]
│ │ ├─── Actions Cannot Be Undone [Irreversible decisions]
│ │ ├─── High Risk [Serious consequences of errors]
│ │ └─── Example: Autonomous Vehicles, Medical Robots [Safety-critical applications]
│ │
│ ├─── ★★★ STATE SPACE SEARCH ★★★ [Finding solution by exploring all possible states]
│ │ │
│ │ ├─── Definition [Fundamental problem-solving method in AI]
│ │ │ ├─── Method to Find Solution [Systematic exploration technique]
│ │ │ ├─── Explores All Possible States [Examines every reachable configuration]
│ │ │ └─── Transitions Between States [Moves from one state to another via actions]
│ │ │
│ │ ├─── Applications [Where state space search is applied]
│ │ │ ├─── Path Finding [Route discovery in graphs/maps]
│ │ │ ├─── Puzzle Solving [8-puzzle, Rubik's cube solutions]
│ │ │ ├─── Game Playing [Move selection in chess, checkers]
│ │ │ └─── Robotics & Planning [Motion planning, task scheduling]
│ │ │
│ │ ├─── ★★ Important Terminologies ★★ [Key concepts in state space search]
│ │ │ ├─── State (Specific Condition/Situation) [Particular configuration at given time]
│ │ │ ├─── Initial State (Starting Point) [Where search begins]
│ │ │ ├─── Goal State (Desired Final State) [Target configuration to reach]
│ │ │ ├─── Transition (Action Changing State) [Operation moving between states]
│ │ │ ├─── Path (Sequence: Initial → Goal) [Series of states from start to end]
│ │ │ └─── Search Strategy (Method to Decide Next State) [Algorithm choosing which state to explore]
│ │ │
│ │ └─── Steps in State Space Search [Six-step search process]
│ │ ├─── Step 1: Define State Space [Identify all states & connecting actions]
│ │ ├─── Step 2: Choose Search Strategy (BFS/DFS) [Select exploration method]
│ │ ├─── Step 3: Start from Initial State [Begin at starting configuration]
│ │ ├─── Step 4: Expand Nodes (Generate Next States) [Create successor states from current]
│ │ ├─── Step 5: Avoid Repeated States [Track visited to prevent loops]
│ │ └─── Step 6: Terminate (Goal Found/No States Left) [End when solved or exhausted]
│ │
│ ├─── ★★★ INFORMED vs UNINFORMED SEARCH ★★★ [Comparison of guided vs blind search]
│ │ │
│ │ ├─── INFORMED SEARCH [Uses heuristics to guide toward goal]
│ │ │ ├─── Uses Heuristics (Extra Knowledge) [Employs domain-specific estimates]
│ │ │ ├─── Goal-Directed & Focused [Searches toward target intelligently]
│ │ │ ├─── Faster (Fewer Nodes Expanded) [Explores less of search space]
│ │ │ ├─── Lower Cost [Reduced computational resources]
│ │ │ ├─── More Efficient [Better time/space performance]
│ │ │ ├─── May Not Always Find Solution [Depends on heuristic quality]
│ │ │ ├─── Guided by Heuristic Values [Uses estimates to prioritize]
│ │ │ ├─── Shorter Implementation [Simpler code structure]
│ │ │ └─── Example: Best-First Search [Priority-based node expansion]
│ │ │
│ │ └─── UNINFORMED SEARCH [No domain knowledge, blind exploration]
│ │ ├─── No Extra Information [Uses only problem definition]
│ │ ├─── Uses Only Problem Description [Start, actions, goal only]
│ │ ├─── Blind Search (Trial-and-Error) [Systematic but unintelligent exploration]
│ │ ├─── Slower (More States Explored) [Examines larger search space]
│ │ ├─── Higher Cost [More computation required]
│ │ ├─── Less Efficient [Worse performance metrics]
│ │ ├─── Always Guarantees Solution (If Exists) [Complete when solution exists]
│ │ ├─── No Guidance [No direction toward goal]
│ │ ├─── Longer Implementation [More complex code]
│ │ └─── Examples: BFS, DFS [Queue-based & stack-based search]
│ │
│ ├─── ★★★ BEST-FIRST SEARCH ★★★ [Informed search selecting most promising node]
│ │ │
│ │ ├─── Introduction [Overview of algorithm]
│ │ │ ├─── Informed Search Algorithm [Uses heuristic knowledge]
│ │ │ ├─── Selects Most Promising Node [Chooses best candidate each step]
│ │ │ ├─── Based on Heuristic Function [Uses estimate of goal distance]
│ │ │ └─── Goal: Reach Target Quickly [Optimizes speed to solution]
│ │ │
│ │ ├─── ★★ Heuristic Function ★★ [Estimation function guiding search]
│ │ │ ├─── h(n) = Estimated Cost to Goal [Value predicting remaining distance]
│ │ │ ├─── Smaller h(n) → Closer to Goal [Low value means near target]
│ │ │ ├─── Larger h(n) → Farther from Goal [High value means distant]
│ │ │ └─── Expands Node with Smallest h(n) [Always picks minimum estimate]
│ │ │
│ │ ├─── Data Structure [Storage mechanism for algorithm]
│ │ │ └─── Priority Queue (Ordered by Heuristic) [Maintains nodes sorted by h(n)]
│ │ │
│ │ ├─── Working Principle [Core algorithm philosophy]
│ │ │ └─── "Expand Node Closest to Goal" [Always explore most promising path]
│ │ │
│ │ ├─── Algorithm Steps [Six-step procedure]
│ │ │ ├─── 1. Place Start in OPEN (Priority Queue) [Initialize with initial state]
│ │ │ ├─── 2. If OPEN Empty → Fail [No solution found]
│ │ │ ├─── 3. Select/Remove Node (Lowest h(n)) [Pick best candidate]
│ │ │ ├─── 4. If Goal → Stop [Solution found, terminate]
│ │ │ ├─── 5. Expand Node, Add Children to OPEN [Generate successors]
│ │ │ └─── 6. Repeat Until Goal Found [Loop until success]
│ │ │
│ │ ├─── Advantages [Benefits of using Best-First]
│ │ │ ├─── Faster Than Uninformed Search [Reduced exploration time]
│ │ │ ├─── Uses Problem-Specific Knowledge [Leverages domain information]
│ │ │ └─── Efficient in Real-world Problems [Practical performance gains]
│ │ │
│ │ └─── Disadvantages [Limitations of Best-First]
│ │ ├─── Not Always Shortest Path [May miss optimal solution]
│ │ ├─── Depends Heavily on Heuristic [Quality determines effectiveness]
│ │ └─── Can Be Misled by Poor Heuristic [Bad estimates hurt performance]
│ │
│ ├─── ★★ BREADTH-FIRST SEARCH (BFS) ★★ [Level-by-level uninformed search]
│ │ ├─── Explores Level by Level [Examines all nodes at depth d before d+1]
│ │ ├─── Uses Queue (FIFO) [First-in-first-out data structure]
│ │ ├─── Complete (Finds Solution if Exists) [Guaranteed to find goal if reachable]
│ │ ├─── Optimal (Shortest Path) [Finds minimum-depth solution]
│ │ ├─── High Space Complexity [Stores all nodes at current level]
│ │ ├─── Time Complexity: O(b^d) [b=branching factor, d=depth]
│ │ └─── Example: Maze Solving [Finding exit in labyrinth]
│ │
│ ├─── ★★ DEPTH-FIRST SEARCH (DFS) ★★ [Deep exploration uninformed search]
│ │ ├─── Explores Depth-wise [Goes deep before exploring siblings]
│ │ ├─── Uses Stack (LIFO) [Last-in-first-out data structure]
│ │ ├─── Less Memory [Stores only path from root to current]
│ │ ├─── Not Always Optimal [May not find shortest path]
│ │ ├─── Memory Problem (Can Get Stuck) [May explore infinite paths]
│ │ ├─── Time Complexity: O(b^m) [b=branching factor, m=max depth]
│ │ └─── Example: Graph Traversal [Visiting all connected nodes]
│ │
│ ├─── ★★★ DIJKSTRA'S ALGORITHM ★★★ [Shortest path algorithm for weighted graphs]
│ │ │
│ │ ├─── Introduction [Algorithm overview]
│ │ │ ├─── Graph Search Algorithm [Operates on weighted graphs]
│ │ │ ├─── Finds Shortest Path from Start to All Nodes [Computes minimum distances]
│ │ │ ├─── Works with Non-negative Weights [Requires positive edge costs]
│ │ │ └─── Applications [Real-world uses]
│ │ │ ├─── Google Maps [Route navigation]
│ │ │ ├─── Network Routing [Data packet paths]
│ │ │ ├─── GPS Systems [Vehicle navigation]
│ │ │ └─── Robot Navigation [Path planning]
│ │ │
│ │ ├─── Basic Idea [Core algorithm concept]
│ │ │ ├─── Select Node with Smallest Distance [Greedy selection strategy]
│ │ │ ├─── Update Neighbor Distances [Relaxation of edges]
│ │ │ └─── Principle: "Choose Nearest Unexplored First" [Always pick closest unvisited]
│ │ │
│ │ ├─── Key Terms [Important definitions]
│ │ │ ├─── Graph (Nodes + Edges) [Network structure representation]
│ │ │ ├─── Weight (Cost/Distance) [Edge value representing cost]
│ │ │ ├─── Source Node (Starting Point) [Origin of path search]
│ │ │ └─── Shortest Path (Minimum Total Weight) [Least-cost route]
│ │ │
│ │ ├─── Working Steps [High-level procedure]
│ │ │ ├─── 1. Assign Distance 0 to Start, ∞ to Others [Initialize distances]
│ │ │ ├─── 2. Mark All Nodes Unvisited [Create unvisited set]
│ │ │ ├─── 3. Select Unvisited with Smallest Distance [Pick minimum]
│ │ │ ├─── 4. Update Neighbor Distances [Edge relaxation]
│ │ │ ├─── 5. Mark Selected as Visited [Remove from unvisited]
│ │ │ └─── 6. Repeat Until All Visited/Goal Reached [Loop to completion]
│ │ │
│ │ ├─── Algorithm Steps (Detailed) [Detailed implementation]
│ │ │ ├─── 1. Initialize All Distances as ∞ (Except Start = 0) [Setup phase]
│ │ │ ├─── 2. Add All to Priority Queue [Create min-heap]
│ │ │ ├─── 3. Pick Node with Smallest Distance [Extract minimum]
│ │ │ ├─── 4. For Each Neighbor: [Process adjacent nodes]
│ │ │ │ └─── New Distance = Current + Edge Weight [Calculate alternative path]
│ │ │ ├─── 5. If New Distance < Old → Update [Relaxation condition]
│ │ │ └─── 6. Continue Until All Processed [Termination]
│ │ │
│ │ ├─── Advantages [Benefits of Dijkstra's]
│ │ │ ├─── Always Finds Shortest Path [Guaranteed optimal solution]
│ │ │ ├─── Very Reliable [Proven correctness]
│ │ │ └─── Widely Used in Real Life [Industry standard]
│ │ │
│ │ ├─── Disadvantages [Limitations of Dijkstra's]
│ │ │ ├─── Does Not Work with Negative Weights [Fails with negative cycles]
│ │ │ └─── Slower for Very Large Graphs [Performance degrades with size]
│ │ │
│ │ └─── ★ Dijkstra vs Best-First Search ★ [Comparison of algorithms]
│ │ ├─── Dijkstra: Uses Real Distance [Actual accumulated cost]
│ │ ├─── Best-First: Uses Estimated Distance (Heuristic) [Predicted cost to goal]
│ │ ├─── Dijkstra: Always Shortest Path [Guarantees optimality]
│ │ ├─── Best-First: May Not Give Shortest Path [Heuristic-dependent]
│ │ ├─── Dijkstra: More Accurate [Precision over speed]
│ │ └─── Best-First: Faster but Approximate [Speed over precision]
│ │
│ ├─── REDUNDANT PATHS [Repeated state exploration problem]
│ │ ├─── Definition (Revisiting Same State) [Exploring already-visited configurations]
│ │ ├─── Impact on Efficiency [Wastes time & memory]
│ │ ├─── Avoidance Techniques [Methods to prevent revisiting]
│ │ └─── Memory to Store Visited States [Track explored nodes]
│ │
│ ├─── SEARCH TREE & STATE SPACE [Visual & conceptual representations]
│ │ ├─── Search Tree (Visual Representation) [Hierarchical node structure]
│ │ ├─── State Space (All Possible States) [Complete set of configurations]
│ │ ├─── Node Expansion [Generating successor states]
│ │ └─── Path from Root to Goal [Solution sequence]
│ │
│ ├─── PERFORMANCE METRICS [Evaluation criteria for search algorithms]
│ │ ├─── Time Complexity [Computational steps required]
│ │ ├─── Space Complexity [Memory storage needed]
│ │ ├─── Completeness (Guarantees Solution) [Will find solution if exists]
│ │ ├─── Optimality (Best Solution) [Finds optimal path]
│ │ └─── Memory Requirements [Storage capacity needed]
│ │
│ └─── PROBLEM EXAMPLES [Classic AI problems demonstrating search]
│ ├─── 8-Puzzle Problem [Sliding tile puzzle requiring state search]
│ ├─── Maze Solving [Finding path through labyrinth]
│ ├─── Graph Traversal [Visiting all nodes in network]
│ ├─── Route Planning [Finding optimal path between locations]
│ └─── Robot Path Planning [Autonomous navigation planning]
│
│
└─── ★★★★★ EXAM-FOCUSED QUESTIONS ★★★★★ [Critical questions for exam preparation]
│
├─── UNIT 1 - CRITICAL QUESTIONS [Most important Unit 1 topics]
│ ├─── ★★★ Define Artificial Intelligence ★★★ [Branch creating intelligent systems mimicking human cognition]
│ ├─── ★★★ Define Intelligent Agent ★★★ [Entity perceiving via sensors & acting via actuators for goals]
│ ├─── ★★★ What is Rationality? ★★★ [Choosing best action based on available info to maximize performance]
│ ├─── ★★★ What are AI Problems? ★★★ [Tasks requiring reasoning/search with large state space & uncertainty]
│ ├─── ★★★ Tools & Techniques for AI Applications ★★★ [Python/LISP/PROLOG + BFS/DFS/ML/Neural Networks]
│ ├─── ★★★ Define Turing Test ★★★ [Test where machine passes if judge can't distinguish from human]
│ └─── ★★★ Can Machines Think Like Humans? ★★★ [Machines simulate thinking via algorithms, not consciousness]
│
└─── UNIT 2 - CRITICAL QUESTIONS [Most important Unit 2 topics]
├─── ★★★ Define Problem-Solving Agent ★★★ [Agent deciding action sequences to achieve goals]
├─── ★★★ Concept of State Space Search ★★★ [Finding solution by exploring all possible states & transitions]
├─── ★★★ Informed vs Uninformed Search ★★★ [Heuristic-guided vs blind exploration comparison]
├─── ★★★ Best-First Search Concept ★★★ [Informed search expanding node with smallest heuristic value]
├─── ★★★ Breadth-First Search Concept ★★★ [Level-by-level exploration using queue, finds shortest path]
└─── ★★★ Dijkstra's Algorithm ★★★ [Shortest path algorithm using real distances for weighted graphs]