Artificial Intelligence (AI) is a branch of computer science that focuses on developing machines capable of performing tasks that normally require human intelligence, such as learning, reasoning, problem-solving, perception, and decision-making. AI systems analyze data, identify patterns, and make intelligent decisions without being explicitly programmed for every situation. Unlike traditional programs that follow fixed instructions, AI systems can learn from data and adapt over time. Examples: Self-driving cars, chatbots, medical diagnosis systems.

The Turing Test was proposed by Alan Turing in 1950 to evaluate whether a machine can exhibit intelligent behavior equivalent to a human. In the test, a human judge interacts with both a machine and a human through text messages. If the judge cannot reliably distinguish the machine from the human, the machine is considered intelligent. It is important because it provided the first practical measure of machine intelligence. The test focuses on behavior and conversation rather than internal mechanisms.

Traditional Programming: Humans define explic it rules, the system follows step -by-step instructions, output strictly depends on predefined logic, and no learning occurs. Artificial Intelligence: Systems learn from data, algorithms adapt and improve over time, decision -making evolves with experience, and AI can handle uncertainty and complex environments. Example: In traditional programming, spam detection rules are manually written. In AI -based spam detection, the system learns patterns from thousands of emails and builds its own predictive model. Thi s learning capability is what makes AI fundamentally different.

An Intelligent Agent is an autonomous system that perceives its environment through sensors and takes actions through actuators in order to achieve specific goals. It follows the continuous cycle: Perception (sense environment)  Decision (process information)  Action (act on environment). Components: Sensors gather input, Agent Program makes decisions, Actuators execute actions. Example: A self-driving car — Sensors: cameras, radar, LiDAR. Agent Program: AI model analyzing traffic and road conditions. Actuators: Steering, braking, acceleration. The car continuously senses, decides, and acts.

There are five main types of intelligent agents: (1) Simple Reflex Agent: Acts only on current percept using IF -THEN condition-action rules. No memory. Example: Thermostat. (2) Model-Based Agent: Maintains an internal model of the world. Handles partially observable environments. Example: Robot vacuum remembering cleaned areas. (3) Goal-Based Agent: Uses planning and search to achieve specific goals. Example: GPS route planning. (4) Utility-Based Agent: Maximizes a utility function to balance trade-offs. Example: Self-driving car balancing safety,

A Rational Agent is an agent that selects actions expected to maximize its performance measure based on its percept sequence and knowledge of the environment. Rationality depends on four key factors: (1) Performance measure — how success is evaluated. (2) Pe rcept sequence — history of all observations. (3) Prior knowledge of the environment. (4) Available actions. Important: Rational does NOT mean perfect. A rational agent makes the BEST POSSIBLE decision based on available information. Example: A delivery drone chooses the safest and fastest route based on weather, battery level, and traffic — this is rational even if not always perfect.

PEAS is a structured framework used to define the task environment of an intelligent agent. P = Performance Measure (criteria for success), E = Environment (where agent operates), A = Actuators (actions agent can take), S = Sensors (what agent perceives). Example — Self-Driving Car: Performance: Safety, speed, comfort, le gal compliance. Environment: Roads, traffic, weather, pedestrians. Actuators: Steering wheel, brakes, accelerator. Sensors: Cameras, radar, GPS, LiDAR. Example — Spam Filter: Performance: High detection accuracy, low false positives. Environment: Incoming emails. Actuators: Mark spam/allow email. Sensors: Email content, metadata.

A Knowledge-Based System (KBS) is an AI system that uses stored knowledge and logical reasoning to solve complex problems, replicating the expertise of human specialists. Main Components: (1) Knowledge Base: Stores facts and rules. Example rule: IF fever AND cough THEN possible flu. (2) Inference Engine: Applies logical reasoning (forward/backward chaining) to derive conclusions. (3) Working Memory: Stores current input data for processing. (4) Explanation System: Explains why a certain conclusion was reached. Inference Methods: Forward Chaining (facts to conclusion) and Backward Chaining (goal to facts). KBS were especially popular in 1970s-80s for medical diagnosis and expert systems.

ELIZA was one of the earliest AI programs, developed in the 1960s by Joseph Weizenbaum at MIT. It simulated a psychotherapist and responded to user input using pattern matching and scripted templates. Example interaction: User: 'I feel sad.' ELIZA: 'Why do you feel sad?' ELIZA did not truly understand language — it detected keywords, rephrased input, and used predefined templates. Historical Significance: (1) Demonstrated that conversation can be simulated with simple rules. (2) Showed how easily humans attribute intelligence to machines (ELIZA effect). (3) Highlighted limitations of rule -based language processing. (4) Marked an imp ortant milestone in conversational AI history.

Knowledge Representation (KR) is the method of organizing and storing information in a structured, formal way so that AI systems can understand, process, and use it for reasoning and decision-making. It is how we teach machines to 'know' things formally. Characteristics of Good KR: (1) Representational Adequacy: Can represent all necessary knowledge. (2) Inferential Adequacy: Can derive new knowledge from existing knowledge. (3) Inferential Efficiency: Enables efficient reasoning. (4) Acquisitional Efficiency: Easy addition of new knowledge. Methods include: Logical rules, knowledge bases, ontologies, semantic networks, and frames. Without structured KR, AI systems cannot perform logical reasoning.

Propositional Logic is the simplest form of logic used in AI. It deals with propositions — statements that are either true or false. Logical Operators: AND ( ), OR ( ), NOT (¬), IMPLIES ( ), BICONDITIONAL ( ). Example: P = 'It is raining', Q = 'Ground is wet'. Rule: P  Q means 'If it is raining, ground is wet'. Limitations: (1) Cannot represent relationships between objects — e.g., 'Father(Ali, Ahmed)'. (2) Cannot use variables — cannot write general rules. (3) Cannot express universal statements like 'All humans are mortal'. Because of these limitations, Predicate Logic (First-Order Logic) was developed to provide a more powerful representation.

Predicate Logic, also called First -Order Logic (FOL), is more expressive than Propositional Logic. It allows representation of objects, properties, relationships, variables, and quantifiers. Components: (1) Constants: Specific objects — Ali, Car1, 5. (2) Variables: x, y, z. (3) Predicates: Express properties — Human(x), Father(Ali, Ahmed). (4) Universal Quantifier (for all): Applies to every element. (5) Existential Quantifier (there exists): Applies to at least one element. Example: 'All humans are mortal' in Predicate Logic: For all x, if Human(x) then Mortal(x). If Human(Ali) is given, then Mortal(Ali) can be logically concluded. This allows systematic reasoning.

Deductive Reasoning: Moves from general rules to specific conclusions. If all premises are true, the conclusion is logically guaranteed. Structure: General Rule + Specific Fact = Conclusion. E xample: All humans are mortal. Ali is human. Therefore, Ali is mortal. Used in: Rule -based expert systems, logical proof systems. Inductive Reasoning: Moves from specific observations to general conclusions. The conclusion is probable but NOT guaranteed. Example: Ali is mortal, Sara is mortal, Ahmed is mortal. Therefore (probably), all humans are mortal. Used in: Machine Learning where systems generalize from training data. Key difference: Deductive gives certain conclusions; inductive gives probable conclusions.

An Inference Mechanism is a procedure that applies reasoning rules to derive new knowledge from existing facts. Forward Chaining (Data-Driven): Starts with known facts, applies rules repeatedly, generates new facts, continues until goal reached. Example: F act: 'Patient has fever AND cough'. Rule: IF fever AND cough THEN possible flu. Conclusion: 'Possible flu'. Used in: Expert systems, monitoring systems. Backward Chaining (Goal -Driven): Starts with a goal, works backward to verify if known facts support it . Example: Goal: 'Is ground wet?' Rule: IF rain THEN wet. Sub -goal: 'Is it raining?' If yes, goal confirmed. Used in: Prolog programming, diagnostic systems, goal verification.

Uninformed Search (also called Blind Search) explores the search space without any additional knowledge about the goal location. It only uses: initial state, possible actions, and goal test. It does not know which direction is closer to the goal. Types: (1) Breadth First Search (BFS): Explores level by level. Complete and optimal. (2) Depth First Search (DFS): Explores deepest nodes first. Less memory but incomplete. (3) Depth Limited Search (DLS): DFS with a maximum depth limit to prevent infinite paths. (4) Iterative De epening Search (IDS): Repeatedly applies DLS with increasing depth limits. Complete, optimal, and memory efficient. These algorithms are used when no domain-specific knowledge is available.

Breadth First Search (BFS) explores nodes level by level, expanding the shallowest nodes first before going deeper. Data Structure: Queue (FIFO — First In, First Out). Working: Start at root node, add to queue. Remove first node, check if goal. If not, expand children and add them to queue. Repeat until goal found or queue empty. Example traversal (root A, children B,C, grandchildren D,E,F): A  B  C  D  E  F. Properties: Completeness: Yes — always finds solution if it exists. Optimality: Yes — finds shortest path when all step costs are equal. Time Complexity: O(b^d). Space Complexity: O(b^d). Advantage: Guarantees shortest path. Disadvantage: Requires large memory for wide trees.

Depth First Search (DFS) explores the deepest nodes first, going down one branch completely before backtracking to explore other branches. Data Structure: Stack (LIFO — Last In, First Out). Working: Start at root, expand one child, continue deeper, if dead end reached then backtrack, explore other branches. Example traversal: A  B  D  E  C  F. Properties: Completeness: No — can get stuck in infinite paths. Optimality: No — does not guarantee shortest path. Time Complexity: O(b^m ) where m = maximum depth. Space Complexity: O(bm) — much less than BFS. Advantage: Uses significantly less memory than BFS. Disadvantage: May loop infinitely; first solution found may not be optimal.

Depth Limited Search (DLS): A modified DFS that restricts search to a predefined depth limit L. Prevents the algorithm from exploring infinitely deep paths. If limit is too small, s olution may be missed. Time: O(b^L), Space: O(bL). Incomplete and non-optimal. Iterative Deepening Search (IDS): Combines the advantages of BFS and DFS. Repeatedly performs DLS with increasing depth limits (0, 1, 2, 3…) until goal is found. Properties: C omplete: Yes. Optimal: Yes (equal costs). Time: O(b^d). Space: O(bd). Advantage over BFS: Uses much less memory. Advantage over DFS: Guaranteed to find solution. Slight disadvantage: Re -explores nodes at smaller depths, causing some redundant computation.

Informed Search (Heuristic Search) is a search strategy that uses problem-specific knowledge to find solutions more efficiently than uninformed methods. Instead of exploring all paths blindly, it uses a heuristic function to estimate how close a state is to the goal. Heuristic Function h(n): Estimates the cost or distance from the current node n to the goal state. h(n) = estimated cost from node n to goal. Characteristics of Good Heuristic: Easy to compute, provides accurate estimates, never overestimates actual cost (admissible), reduces unnecessary exploration. Examples: Straight-line distance in maps, Manhattan distance (|x1 -x2| + |y1 -y2|) in grid problems, Euclidean distance in continuous space problems.

Greedy Best First Search (GBFS) is an informed search algorithm that always expands the node appearing closest to the goal according to the heuristic function h(n). Evaluation function: f(n) = h(n) — only estimates remaining cost to goal, ignores actual cost traveled. Algorithm: Evaluate h(n) for neighbors, insert in priority queue ordered by h(n), expand node with lowest h(n), continue until goal found. Example: In navigation, always move to city with smallest straight-line distance to destination. Advantages: Faster than uninformed search, fewer node expansions. Disadvantages: NOT guaranteed optimal solution. Can get stuck in local minima. Performance entirely depends on heuristic quality.

The A* (A-Star) Algorithm is one of the most powerful and widely used informed search algorithms. It combines the advantages of Uniform Cost Search (actual cost) and Greedy Best First Search (heuristic estimate). Evaluation function: f(n) = g(n) + h(n), where g(n) = actual cost from start to current node, h(n) = heuristic estimate from current node to goal. Working: Start from initial node, calculate f(n) for each neighbor, select node with lowest f(n), expand it and update neighbors, continue until goal reached. A* is complete and optimal when heuristic is admissible. Applications: GPS navigation, video game pathfinding, robotics navigation, logistics planning.

An Admissible Heuristic is one that never overestimates the true cost to reach the goal. Formal condition: h(n) <= h*(n), where h(n) = heuris tic estimate and h*(n) = true minimal cost. Why it matters: Admissible heuristics GUARANTEE that A* always finds the optimal (shortest/cheapest) solution. If h(n) overestimates, A* might skip the optimal path thinking it is too expensive. Example: In GPS n avigation, straight-line distance is admissible because actual road distance can never be shorter than straight-line distance. Consistent Heuristic: A stronger property — h(n) <= cost(n,n') + h(n'). All consistent heuristics are admissible but not vice versa.

Local Search is an optimization technique where the algorithm starts with an initial solution and iteratively improves it by exploring neighboring solutions. Unlike path-based search, local search only cares about the final solution — not the path taken to reach it. It maintains only the current state in memory. Advantages: (1) Works efficiently in very large or infinite state spaces. (2) Uses very little memory — only current state sto red. (3) Faster than traditional complete search methods. (4) Ideal for optimization problems where you want the best solution. (5) Practical for real-world scheduling, routing, configuration problems. Applications: Route optimization, machine learning hyperparameter tuning, job scheduling, protein folding.

Hill Climbing is a greedy local search algorithm that always moves toward a better solution by selecting the best neighboring state at each step. Working: Start with initial solution, generate all neighboring solutions, evaluate them, move to the best neighbor, repeat until no better neighbor exists. Idea: Always move uphill (toward better solutions). Limitations: (1) Local Maximum: Algorithm sto ps at a peak that is not globally optimal — there may be a better solution elsewhere. (2) Plateau: All neighbors have equal value — algorithm cannot determine which direction to move. (3) Ridge Problem: The path to the optimal solution requires moves that initially appear to be worse. Advantages: Simple, fast, uses very little memory. Disadvantage: Cannot guarantee global optimal solution.

Simulated Annealing is an improved local search algorithm inspired by the annealing process in metallurgy — heating metal and slowly cooling it to remove defects. Unlike Hill Climbing, Simulated Annealing sometimes accepts worse solutions to escape local maxima. Working: Start with initial solution and high temperature. Pick a random neighbor. If better — always accept it. If worse — accept it with probability P = e^(-deltaE/T). Gradually reduce temperature. Stop when temperature is very low. Key insight: At high temperature, bad moves are frequently accepted (exploration). As temperature decreases, fewer bad moves accepted (exploitation). Result: Avoids local maxima and finds near-optimal solutions. Used in: Chip design, traveling salesman problem, scheduling optimization.

Q22. What is an Admissible Heuristic? Why does it matter?

BFS (Breadth First Search): Data structure=Queue. Complete=Yes. Optimal=Yes. Time=O(b^d). Space=O(b^d). Explores level by level. Best when s olution is shallow. DFS (Depth First Search): Data structure=Stack. Complete=No. Optimal=No. Time=O(b^m). Space=O(bm). Explores deepest first. Uses less memory but may loop. DLS (Depth Limited Search): Similar to DFS but with depth limit L. Complete=No. Op timal=No. Time=O(b^L). Space=O(bL). Prevents infinite loops. IDS (Iterative Deepening Search): Combines BFS+DFS. Complete=Yes. Optimal=Yes. Time=O(b^d). Space=O(bd). Memory efficient like DFS, complete like BFS. Best choice when depth is unknown and memory is limited.

Machine Learning (ML) is a subset of AI that enables systems to learn patterns from data without being explicitly programmed for every situation. It allows machines to improve their performance over time. Types: (1) Supervised Learning: Trains on labeled data (input -output pairs). Goal is to predict output for new inputs. Examples: spam detection, image classification, price prediction. (2) Unsupervised Learning: Trains on unlab eled data. Discovers hidden patterns and structures. Examples: customer clustering, anomaly detection, dimensionality reduction. (3) Reinforcement Learning: Agent learns by interacting with environment, receiving rewards and penalties. Examples: game playing AI, robotic control, autonomous driving. ML is the foundation of most modern AI applications.

Natural Language Processing (NLP) is the AI field that enables machines to understand, interpret, a nd generate human language. It bridges the communication gap between humans and computers. Key NLP Tasks: (1) Tokenization: Breaking text into words or tokens. (2) Stemming/Lemmatization: Reducing words to their root form. (3) Sentiment Analysis: Detecting opinions and emotions in text. (4) Machine Translation: Translating text between languages. (5) Named Entity Recognition (NER): Identifying names of people, places, organizations. (6) Text Classification: Assigning categories to documents. (7) Question An swering: Automatically answering questions from text. Real -world Applications: Chatbots, virtual assistants (Siri, Alexa), Google Translate, spam filters, search engines.

Computer Vision is the AI field that enables machines to interpret and understand visual information from images and videos, similar to how humans use their eyes and brain. Key Applications: (1) Facial Recognition: Identifying individuals from photos or videos. (2) Object Detection: Identifyi ng and locating objects in images — used in autonomous cars. (3) Medical Image Diagnosis: Detecting diseases in X -rays, MRIs, CT scans. (4) Autonomous Vehicle Navigation: Understanding road, traffic lights, pedestrians. (5) Image Segmentation: Dividing ima ge into meaningful regions. (6) OCR (Optical Character Recognition): Reading text from images. Primary Technology: Convolutional Neural Networks (CNNs) have revolutionized Computer Vision, enabling human -level accuracy in many visual tasks.

A Neural Network is a computational model inspired by the structure of the human brain's biological neurons. It consists of layers of interconnected nodes (artificial neurons). Structure: (1) Input Layer: Receives raw data. (2) Hidden Layer(s): Process and transform information. (3) Output Layer: Produces final result. Each connection has a weight adjusted during training. Training Process: Forward pass (compute output)  Calculate loss (error)  Backward pass (back propagation)  Update weights using gradient descent  Repeat until model learns. Deep Learning uses networks with many hidden layers. Applications: Image recognition, speech recognition, NLP, medical diagnosis, fraud detection, self-driving cars.

AI has transformative applications across industries: Healthcare: Disease detection, medical imaging analysis, robotic surgery, drug discovery, personalized treatment. Finance: Fraud detection, risk assessment, algorithmic trading, credit scoring, customer service chatbots. Education: Adaptive learning platforms, intelligent tutoring systems, automated grading, personalized study plans. Transportation: Self -driving vehicles, traffic management, route optimization, air traffic control. Business/Marketing: Recommendation systems (Netflix, Amazon), customer behavior analysis, predictive analytics. Cybersecurity: Intrusion detection, threat prediction, malware detection. Agriculture: Crop monitoring, yiel d prediction, precision farming. Manufacturing: Predictive maintenance, quality control inspection. Entertainment: Game AI, content generation, deepfakes.

As AI grows more powerful, several ethical concerns have emerged: (1) Algorithmic Bias: AI systems producing unfair or discriminatory outputs due to biased training data — affecting hiring, lending, criminal justice. (2) Data Privacy: AI collecting and processing large amounts of personal data without consent. (3) Transparency (Black Box Problem): AI making decisions humans cannot understand or explain. (4) Accountability: Difficulty determining who is responsible when AI makes harmful decisions. (5) Job Displacement: AI automation potentially replacing millions of workers. (6) Deepfakes and Misinformation: AI generating realistic fake media for manipulation. (7) Autonomous Weapons: Ethical use of AI in military systems. Responsible AI development ensures fairness, safety, transpare ncy, and societal benefit.

A State Space is the set of all possible states or configurations that can occur in a problem, from the initial state to the goal state. It defines the complete problem environment for search algorithms. Components: (1) Initial State: The starting configuration of the problem. (2) Actions/Operators: Possible moves from one state to another. (3) Transition Model: How each action changes the current state. (4) Goal Test: Checks whether the current state is the goal. (5) Path Cost: The cost of reaching a state from the initial state. Representation: State space is usually represented as a tree or graph. Example: In a maze, each position is a state, moving left/right/up/down are actions, and the exit is the goal state. Search algorithms explore this space to find a solution path.

Complete Search Algorithm : Guarantees finding a solution if one exists. If no solution exists, it correctly reports failure. Example: BFS is complete — will always find goal if reachable. DFS is incomplete — can get stuck in infinite path and miss solution. Optimal Search Algorith m: Guarantees finding the BEST solution with the lowest path cost. Example: BFS is optimal when all step costs are equal. A* with admissible heuristic is optimal — always finds cheapest path. DFS is not optimal — finds first solution found, not necessarily cheapest. IDS is both complete and optimal. A* with admissible heuristic is both complete and optimal. These two properties together define the quality of

Reinforcement Learning (RL) is a type of Machine Learning where an agent learns through trial and error by interacting with an environment. The agent receives rewards for good actions and penalties for bad actions, and aims to maximize total cumulative reward over time. Key Components: Agent (the learner/decision maker), Environment (what agent interacts with), State (current situation), Action (choice made by agent), Reward (feedback signal — positive or negative). Popular Algorithm: Q -Learning updates action -value estimates based on rewards received. Famous Applications: AlphaGo (defeated world Go champion), AlphaZero (chess, Go), game-playing AI, robotic arm control, autonomous driving, resource management in data centers.

Minimax is a search algorithm used in two-player adversarial games like chess, tic-tac-toe, and checkers. It assumes both players play optimally. MAX player tries to maximize their score. MIN player tries to minimize MAX's score. Working: Build a game tree of all possible moves. Assign utility values to terminal states (Win=+1, Loss=-1, Draw=0). Propagate values upward — MAX nodes take maximum child value, MIN nodes take minimum. Choose the move with the best minimax value. Alpha -Beta Pruning is an optimization that eliminates branches that cannot affect the final decision, reducing the search space without losing accuracy. Example: In tic-tac-toe, minimax can play perfectly by considering all possible game outcomes.

Greedy Best First Search: Evaluation function f(n) = h(n) — only considers estimated cost to goal. Ignores actual cost g(n) already paid. Fast but NOT optimal. Can get stuck in local minima. May choose paths that look good but end up longer. A* Algorithm: Evaluation function f(n) = g(n) + h(n) — considers BOTH actual path cost AND estimated remaining cost. Complete and optimal (with admissible heuristic). More reliable and finds guaranteed shortest path. Slightly more computation than Greedy. Summary: Greedy search asks 'Which node looks closest to goal?'. A* asks 'Which node gives the best total path cost (traveled + estimated remaining)?'. A* is preferred in most applications requiring optimal solutions.

Modus Ponens is the most fundamental and important inference rule in logic -based AI reasoning. It states: If 'P implies Q' is true, and 'P' is true, then 'Q' must be true. Formal structure: Premise 1: P  Q (If P then Q). Premise 2: P (P is true). Conclusion: Q (Therefore Q is true). Example 1: If it rains, ground gets wet. It is raining. Therefore, ground is wet. Example 2: IF fever AND cough THEN possible flu. Patient has fever AND cough. Therefore, patient possibly has flu. Importance: Modus Ponens is the basis of forward chaining in expert systems. It guarantees logically certain conclusions when premises are true. It is used extensively in knowledge -based systems and automated theorem proving.

Forward Chaining (Data-Driven): Starts with known facts in working memory. Applies rules whose conditions match known facts. Adds conclusions to working memory as new facts. Continues firing rules u ntil goal is reached or no more rules apply. Best when: Facts are known and you want to derive all possible conclusions. Used in: Expert systems, monitoring systems, business rule engines. Backward Chaining (Goal-Driven): Starts with a specific goal to prove. Finds rules that could produce the goal as their conclusion. Sets rule conditions as sub -goals to verify. Recursively verifies sub-goals until confirmed by known facts. Best when: A specific goal is known and you want to

The Dartmouth Conference of 1956 is historically significant as the official birth of Artificial Intelligence as an academic discipline. Organized by John McCarthy, Marvin Minsky, Claude Shannon, and others at Dartmouth College, USA. Key contributions: (1) The term 'Artificial Intelligence' was officially coined and introduced by John McCarthy. (2) It established AI as a formal field of research. (3) It brought together the founding scientists of AI. (4) It set the initial research agenda — building machines that can reason like humans. Before Dartmouth, similar work existed but had no unified identity. After Dartmouth, AI research programs were established at major universities and research labs worldwide. This conference marks the formal beginning of the AI era.

Propositional Logic: Uses only simple propositions (true/false statements). No variables, no objects, no relationships. Limited expressiveness. Example: P = 'Ali is mortal'. Cannot say 'All humans are mortal'. Operators: AND, OR, NOT, IMPLIES. Predicate Lo gic (First -Order Logic): Uses objects, predicates (properties/relationships), variables, and quantifiers. Much more expressive. Can represent general rules. Example: For all x, if Human(x) then Mortal(x). Can then conclude: if Human(Ali) then Mortal(Ali). Key Differences: Propositional Logic uses no variables; Predicate uses x, y, z. Propositional cannot represent relationships; Predicate can. Predicate Logic is far more powerful and is the standard for AI knowledge representation and automated reasoning systems.

Search algorithms in AI are techniques used to systematically explore possible states of a problem until a goal state is found. They are fundamental to AI because: Many AI problems are naturally formulated as search problems. Examples: Route planning (find path from A to B), puzzle solving (8-puzzle, Rubik's cube), game playing (chess, Go), robot navigation, planning and scheduling. Types: Uninformed Search (BFS, DFS, DLS, IDS) — explore without extra knowledge. Informed Search (A*, Greedy) — use heuristics for efficiency. Local Search (Hill Climbing, SA, GA) — optimize solutions. Key properties evaluated: Completeness (finds solution if exists), Optimality (finds best solution), Time complexity, Space complexity.

Admissible Heuristic: A heuristic that NEVER overestimates the true cost to reach the goal. Formal condition: h(n) <= h*(n) for all nodes n, where h*(n) is the true minimal cost. Guarantees that A* finds optimal solution. Example: Straight-line distance in maps — roads can never be shorter than straight -line. Consistent (Monotone) Heuristic: A stronger condition — the heuristic satisfies the triangle inequality: h(n) <= cost(n, n') + h(n') for all nodes n and successors n'. This means heuristic values decrease smoothly along paths. Relationship: All consistent heuristics are admissible, but not all admissible heuristics are consistent. Consistency also guarantees A* never needs to re-expand nodes, making it more efficient.

A Utility Function is a mathematical function that assigns a numerical value (utility) to each possible state or outcome, representing how desirable that state is to the agent. It allows the agent to make rational choices when goals conflict or when multiple objectives must be balanced. Purpose: Goes beyond simple goal achievement (yes/no) to measure the DEGREE of desirability. Example: Self -driving car utility function might consider: Safety (weight=0. 5) + Speed (weight=0.3) + Comfort (weight=0.2). Different routes score differently on these factors. The agent chooses the route with highest total utility. Utility-based agents are more flexible and realistic than purely goal-based agents because

Knowledge Engineering is the process of eliciting, structuring, formalizing, and encoding expert human knowledge into an AI knowledge -based system. It involves collaboration between knowledge engineers (AI specialists) and domain experts (doctors, lawyers, engineers, etc.). Steps: (1) Problem identification — define the scope. (2) Knowledge acquisition — interview experts, analyze documents. (3) Knowledge representation — encode knowledge in formal language (rules, logic). (4) Implementation — build the knowledge base and inference engine. (5) Testing and validation — verify correctness. Challenges: Experts may have difficulty articulating the ir knowledge (tacit knowledge). Knowledge may be incomplete, inconsistent, or uncertain. The knowledge acquisition bottleneck is a major challenge in building expert systems.

AI is transforming healthcare in multiple ways: (1) Medical Imaging: Deep learning models detect diseases in X-rays, MRIs, CT scans — often with accuracy matching or exceeding radiologists. (2) Disease Diagnosis: AI systems analyze patient symptoms, history, and test results to sug gest diagnoses. (3) Drug Discovery: AI accelerates identification of drug candidates by analyzing molecular structures — AlphaFold predicts protein structures. (4) Personalized Medicine: AI analyzes genetic data to tailor treatments to individual patients. (5) Robotic Surgery: AI-assisted robots perform precise surgical procedures. (6) Predictive Analytics: Predicting patient deterioration or disease outbreaks. (7) Administrative Tasks: Automated scheduling, billing, record management. AI in healthcare improves accuracy, speed, and accessibility of medical care.

Deep Learning is a subset of Machine Learning that uses neural networks with many layers (deep neural networks) to automatically learn hierarchical representations of data. Unlike traditional ML that requires manual feature engineering, deep learning automatically learns features from raw data. Architecture: Multiple hidden layers between input and output — each layer learns increasingly abstract repr esentations. Key types: Convolutional Neural Networks (CNNs) for images. Recurrent Neural Networks (RNNs) for sequential data (text, speech). Transformers for NLP tasks (BERT, GPT). Training: Backpropagation and gradient descent on large datasets using pow erful GPUs. Applications: Image classification, speech recognition, natural language processing, game playing, generative AI. Deep learning has driven most AI breakthroughs since 2012.

A well-defined AI search problem consists of five components: (1) Initial State: The starting configuration — where the search begins. Example: Starting city A in route planning. (2) Actions/Operators: The set of possible actions available to the agent in each state. Example: Move North, South, East, West. (3) Transition Model: Defines the result of taking an action in a state — produces the next state. (4) Goal Test: A function that determines whether a given state is the goal state. Example: Reached destination city B. (5) Path Cost: A function that assigns a cost to each path (sequence of actions). Used to find optimal solutions. Solution: A sequence of actions from initial state to goal state. Optimal Solution: The solution with the lowest path cost.

The future of AI includes exciting developments across many dimensions: (1) Artificial General Intelligence (AGI): Creating AI systems with broad human -level intelligence across all domains — not yet achieved. (2) Explainable AI (XAI): More transparent and interpretable AI systems for high-stakes decisions. (3) Human-AI Collaboration: AI