Revision approach
- Intelligent action selection
- Agents; search; games
- Knowledge; reasoning; learning; perception
- Available information and objectives
- Assumptions and success evidence
- Technique selection
👁 Full explanation
Study intelligent agents, search and games, knowledge and reasoning, learning, and perception as connected ways to choose actions. For each problem identify the available information, objective, assumptions, and evidence of success before choosing a technique. - Six-item course priority
- Comparison mastery
- Applied practice over option letters
👁 Full explanation
Give this course its official six-item priority. Learn the comparisons, then practise applying them rather than memorizing option letters. - Paper traces and assumptions
- Frontier order and path costs
- Quantifier scope
- Learning feedback and evaluation splits
- Completeness conditions
- Optimality conditions
👁 Full explanation
Trace frontier order, path costs, quantifier scope, learning feedback, and evaluation splits on paper. State the conditions behind completeness and optimality. - Weak-concept question index
- Multiple valid choices
- Damaged notation
- Mapped clarifications
👁 Full explanation
Use the question reference index to revisit weak concepts. Check notation and assumptions carefully when several choices appear valid.
AI01
AI capabilities and scope
[Exam Focus]- Artificial intelligence scope
- Reasoning; learning; planning; perception; language
- Applied AI: useful solutions
- Cognitive AI: biological intelligence models
- Human behavior and experimental validation
👁 Full explanation
Artificial intelligence studies systems that perform tasks requiring intelligence: reasoning, learning, planning, perception and language. Applied AI builds useful solutions; cognitive AI uses computational models to investigate biological intelligence. A model should be compared with human behavior or experimental observations before claiming it explains human thought. - Narrow, general and strong AI
- Weak AI: bounded tasks
- Face recognition; spam; voice assistants
- General AI: transferable domain competence
- Strong AI: actual understanding
- Humanoid appearance ≠ general intelligence
- Autonomous vehicles ≠ general intelligence
- Feature count ≠ general intelligence
👁 Full explanation
Narrow or weak AI addresses bounded tasks, such as face recognition, spam filtering or a voice assistant. General AI denotes broad competence transferable across domains; strong AI also has a philosophical meaning involving actual understanding. Do not equate a humanoid body, autonomous vehicle, or many features with general intelligence. - Exam trap Data analysis–AI overlap
- Learning or inference criterion
- Categorical exclusion trap
👁 Full explanation
Data analysis overlaps AI when it uses learning or inference. It is not categorically excluded from AI.
15 related practice questions
Blueprint: AI2 · Note references: AI_MOD, AI_SHORT, AI_DEEP
- Artificial intelligence scope
AI02
Four approaches and the Turing test
[Exam Focus]- Four AI approaches
- Thinking humanly: mental processes
- Thinking rationally: valid logic
- Acting humanly: humanlike behavior
- Acting rationally: expected objective achievement
- Thought versus behavior evaluation
👁 Full explanation
Thinking humanly models human mental processes; thinking rationally derives conclusions by valid logic. Acting humanly seeks humanlike behavior; acting rationally selects actions expected to achieve objectives. Thought processes and observed behavior are different evaluation targets. - Conversational Turing test
- Judge: human–machine dialogue distinction
- Language; knowledge; reasoning; learning
- Operational behavior criterion
- Consciousness-proof trap
- Cognitive models: response times and errors
- Psychological experiments
👁 Full explanation
The conversational Turing test asks whether a judge can reliably distinguish a machine from a human through their dialogue. It requires language use, knowledge, reasoning and often learning. It tests an operational behavior criterion, not proof of consciousness. Cognitive models can be tested against response times, errors and psychological experiments. - Worked example Approach identification
- Best action sequence: acting rationally
- Human-error modeling: thinking humanly
👁 Full explanation
Choose the approachFinding a best action sequence to a goal fits acting rationally. Explaining human errors with a computational model fits thinking humanly.
9 related practice questions
Blueprint: AI2 · Note references: AI_MOD, AI_SHORT, AI_DEEP
- Four AI approaches
AI03
Agents, percepts and action
[Exam Focus]- Agent interaction
- Sensors perceive; actuators/effectors act
- Cameras versus motors
- Software messages versus API requests
- Human agents versus artificial agents
👁 Full explanation
An agent perceives an environment through sensors and acts through actuators or effectors. Cameras sense; motors move. Software sensors may be incoming messages and software actions may be API requests. Humans are agents but are not artificial agents. - Agent function and architecture
- Percept: single observation
- Percept sequence: entire observation history
- f:P*→A
- Agent = architecture + program
- Program implements function
- Environment beyond search space
- Autonomy: experience over designer instructions
👁 Full explanation
A percept is one observation; a percept sequence is the entire observation history. An agent function maps percept sequences to actions: f:P*→A. An agent program implements that mapping on an architecture; agent = architecture + program. Environment means the setting in which it senses and acts, not merely the search space. Autonomy means relying substantially on experience rather than only a designer’s prior instructions.
15 related practice questions
Blueprint: AI2 · Note references: AI_MOD, AI_SHORT, AI_DEEP
- Agent interaction
AI04
Rationality and performance
[Exam Focus]- Rationality and success measures
- External performance: safety; deliveries; time; cost
- Prior knowledge and percept history
- Available actions
- Best expected performance given information
👁 Full explanation
A performance measure defines success externally: safety, useful deliveries, elapsed time, or cost. Rationality depends on that measure, prior knowledge, percept history, and available actions. A rational agent selects the action with the best expected performance given its information. - Rationality versus omniscience
- Omniscience: advance outcome knowledge
- Rationality without guaranteed success
- All actions fail boundary case
- Rational information gathering and exploration
👁 Full explanation
Omniscience would mean knowing actual action outcomes in advance. Rationality does not require omniscience or guaranteed success. Even complete outcome knowledge cannot create a successful action when every available action fails. Information gathering and exploration may therefore be rational actions. - Worked example Expected versus realized route time
- Rational expectation: 20 minutes
- Unforeseen closure: 40 minutes
👁 Full explanation
Uncertain routeA route with expected travel time 20 minutes can be the rational choice even if an unforeseen closure makes it take 40 minutes.
5 related practice questions
Blueprint: AI2 · Note references: AI_MOD, AI_SHORT, AI_DEEP
- Rationality and success measures
AI05
Specify the task with PEAS
[Exam Focus]- PEAS task specification
- Performance measure; Environment; Actuators; Sensors
- Specification before agent design
- Taxi performance: safety and travel time
- Taxi environment: roads; traffic; passengers
- Taxi actuators: steering; brakes; displays
- Taxi sensors: cameras; positioning; speed
👁 Full explanation
PEAS means Performance measure, Environment, Actuators, Sensors. Specify all four before designing an agent. For a taxi: performance includes safety and travel time; environment includes roads, traffic and passengers; actuators include steering, brakes and displays; sensors include cameras, positioning and speed readings. - PEAS category traps
- Sensor influence ≠ actuation
- Performance measure: success criterion
- Percept sequence: observation evidence
- Agent observations versus designer knowledge
👁 Full explanation
A sensor is not an actuator just because it influences a decision. The performance measure is not the percept sequence: one defines success, the other supplies evidence. Separate what the agent can observe from what a designer knows about the world.
1 related practice question
Blueprint: AI2 · Note references: AI_MOD, AI_SHORT, AI_DEEP
- PEAS task specification
AI06
Simple and model-based reflex agents
- Simple reflex agent
- Current-percept condition–action rules
- Dirty → clean
- No persistent world-state memory
- Sufficient current information assumption
- Partial observation: identical percept, different actions
👁 Full explanation
A simple reflex agent matches condition–action rules against the current percept only: if dirty, clean. It has no persistent world-state memory. This is adequate when the current observation contains everything needed for its rule, but partial observability can make the same percept require different actions. - Model-based reflex agent
- Previous state and previous action
- Current percept
- World-change and action-effect models
- Internal-state condition–action rules
- Shared rule use
- Distinguishing memory and world model
👁 Full explanation
A model-based reflex agent maintains internal state using the previous state, previous action, current percept, and models of world change and action effects. It then applies rules to that state. Both kinds can use condition–action rules; memory and a world model distinguish them. - Worked example Hidden cleaned-room memory
- Internal state beyond sensor range
- Current dirt detection: no memory requirement
👁 Full explanation
Remember a hidden roomRemembering that a room was cleaned after it leaves sensor range requires internal state. Merely detecting current dirt does not.
6 related practice questions
Note references: AI_MOD, AI_SHORT, AI_DEEP
- Simple reflex agent
AI07
Goals, utility and model updates
- Goals versus utility
- Goal: desired-state action sequences
- Utility: desirability and trade-offs
- Maximum expected utility
- EU(a)=Σs P(s|a,evidence)U(s)
- Destination goal
- Arrival time; safety; cost preferences
👁 Full explanation
A goal-based agent considers future action sequences that reach a desired state. A utility-based agent compares degrees of desirability and trade-offs, choosing maximum expected utility: EU(a)=Σs P(s|a,evidence)U(s). Reaching the destination is a goal; balancing arrival time, safety and cost requires preferences among outcomes. - Internal model versus external action
- Post-action state prediction
- State update ≠ environment modification
- Unused goal variable trap
- BEST_ACTION dependence on goal
- Coexisting model, goal, utility, learning capabilities
👁 Full explanation
Updating an internal state after selecting an action predicts the action’s effect; it does not itself modify the external environment. A stored variable named goal is insufficient to prove a goal-based policy if BEST_ACTION never uses it. Model-based, goal-based, utility-based and learning capabilities can coexist.
6 related practice questions
Note references: AI_MOD, AI_SHORT, AI_DEEP
- Goals versus utility
AI08
Learning-agent components
[Exam Focus]- Learning-agent components
- Performance element: action selection
- Learning element: future improvement
- Critic: standard-based evaluation and feedback
- Problem generator: useful exploratory experience
👁 Full explanation
The performance element selects actions. The learning element changes the agent to improve future performance. The critic evaluates behavior against a performance standard and supplies feedback. The problem generator suggests exploratory actions likely to yield useful experience. - Learning: task T, performance P, experience E
- Spam T: email classification
- Spam E: labeled messages
- Spam P: recall at required precision
- Exploration: information versus immediate reward
- Exploitation: currently best-known action
- Learning across reflex, goal, utility agents
👁 Full explanation
Learning is improvement on task T, measured by P, through experience E. For spam filtering, T is classifying email, E is past labeled messages, and P might be recall at a required precision. Exploration trades immediate reward for information; exploitation uses the best action currently known. Learning can improve reflex, goal-based or utility-based agents.
6 related practice questions
Blueprint: AI1 · Note references: AI_MOD, AI_SHORT, AI_DEEP
- Learning-agent components
AI09
Environment dimensions
[Exam Focus]- Observation and transition dimensions
- Fully observable: relevant state revealed
- Partially observable: hidden or noisy information
- Deterministic: state/action determine successor
- Stochastic: random outcomes
- Strategic opponent uncertainty versus randomness
👁 Full explanation
Fully observable means sensors reveal relevant state; partially observable means relevant information is hidden or noisy. Deterministic means state and action determine the next state; stochastic means outcomes involve randomness. Strategic uncertainty about an opponent is distinct from dice-like randomness. - Environment dimension contrasts
- Episodic independence versus sequential effects
- Static deliberation versus dynamic change
- Semidynamic: clock changes score
- Discrete alternatives versus continuous ranges
- Known/unknown: transition-model knowledge
- Model knowledge ≠ observability
👁 Full explanation
Episodic decisions are independent; sequential decisions affect later situations. Static worlds do not change while deliberating; dynamic ones do. A clock affecting score makes an otherwise static game semidynamic. Discrete quantities have distinct alternatives; continuous quantities vary along real-valued ranges. Known versus unknown concerns knowledge of the transition model, not observability. - Worked example Environment classification examples
- Chess: sequential; discrete; deterministic given moves
- Untimed chess: static
- Timed chess: semidynamic
- Fixed crossword: static
- Driving: partial; sequential; dynamic; partly continuous
👁 Full explanation
Classify examplesChess is sequential, discrete and deterministic given both players’ chosen moves; untimed chess is static, timed chess semidynamic. A fixed crossword is static. Driving is partially observable, sequential, dynamic and partly continuous.
10 related practice questions
Blueprint: AI2, AI4 · Note references: AI_MOD, AI_SHORT, AI_DEEP
- Observation and transition dimensions
AI10
Single-state, multiple-state and contingency problems
- State uncertainty representations
- Single-state: known deterministic, fully observed
- Sensorless/multiple-state: no observation
- Known deterministic transitions
- Belief state: possible-state set
👁 Full explanation
With a known deterministic model and full observation, a single current state can be used. Without observation but with known deterministic transitions, a sensorless or multiple-state problem tracks a belief state: a set of possible states. - Contingency versus exploration
- Nondeterminism or partial observation
- Percept-dependent plan branches
- Unknown state space or transition model
- Exploration/online search
- Observation alone insufficient
- Overlapping classifications
- Partial deterministic description: ambiguous category
👁 Full explanation
Nondeterminism or partial observation may require a contingency plan with branches based on later percepts. Exploration or online search is required when the state space or transition model is unknown; observation alone does not identify this category. These classifications can overlap. A pairing based only on “partially observable, deterministic” cannot distinguish a known sensorless problem from an unknown exploration problem.
1 related practice question
Note references: AI_AIMA
- State uncertainty representations
AI11
Formulate before searching
[Exam Focus]- Goal then problem formulation
- Initial state and legal actions
- Transition model
- Goal test and action costs
- Search: sequence selection
- Execution: applying actions
- State abstraction: irrelevant details removed
👁 Full explanation
First formulate the goal; then formulate the problem by specifying initial state, legal actions, transition model, goal test, and action costs. Search selects a sequence; execution applies it. A state abstracts away irrelevant world details. - Search problem examples
- Routes: cities; roads; neighboring successors
- Accumulated distance or time
- Solution: legal goal-ending path
- Optimal: minimum path cost
- Automatic programming/program synthesis
- Program satisfying specification
- Conditional plans and loops: richer representations
👁 Full explanation
In route finding, states are cities, actions are roads, successors are neighboring cities, and path cost is accumulated distance or time. A solution is a legal path ending at a goal; an optimal solution has minimum cost. Automatic programming or program synthesis searches for a program satisfying a specification; conditional plans and loops require richer representations than a fixed action list.
4 related practice questions
Blueprint: AI3 · Note references: AI_MOD, AI_SHORT, AI_DEEP
- Goal then problem formulation
AI12
Frontiers and evaluation criteria
[Exam Focus]- Search nodes and frontier
- State; parent; action; depth; path cost
- Expansion generates successors
- OPEN/frontier: pending candidates
- CLOSED: expanded states
- Same state ≠ same node/cost
👁 Full explanation
A search node records a state plus parent, action, depth and path cost. Expanding a node generates its successors. OPEN or frontier stores discovered candidates awaiting expansion; CLOSED records expanded states. Reaching the same state through different paths does not imply the same node or cost. - Search evaluation criteria
- Completeness under stated assumptions
- Optimality: best solution
- Time: generated work
- Space: simultaneous storage
- b: branching; d: shallowest goal
- m: maximum depth; ℓ: limit
- Graph V,E versus implicit-tree bounds
👁 Full explanation
Completeness means finding a solution if one exists under stated assumptions; optimality means returning the best solution. Time counts work, often generated nodes; space counts simultaneous storage. Let b be branching factor, d shallowest goal depth, m maximum search depth, and ℓ a depth limit. Graph-search bounds in vertices V and edges E differ from implicit-tree bounds.
2 related practice questions
Blueprint: AI3, AI4 · Note references: AI_MOD, AI_SHORT, AI_DEEP
- Search nodes and frontier
AI13
Breadth-first search
[Exam Focus]- BFS: FIFO oldest-first
- Root → head removal → goal test
- Unseen successors appended at tail
- Depth order: 0,1,2,…
- Complete: finite b, finite goal depth
- Minimum number of edges
- Minimum cost: equal positive step costs
👁 Full explanation
BFS removes the oldest frontier entry using a FIFO queue. Start with the root, remove the head, test it, append unseen successors at the tail, and repeat. It explores depths 0,1,2,… and is complete for finite b and a finite-depth goal. It minimizes number of edges, so minimum cost requires equal positive step costs. - BFS complexity conventions
- 1+b+…+b^d
- Generation-time testing: O(b^d)
- Depth-d expansion: O(b^(d+1))
- Explicit visited graph: O(V+E) time
- Explicit visited graph: O(V) space
👁 Full explanation
The tree contains 1+b+…+b^d nodes through depth d, giving O(b^d) under generation-time goal testing. Expanding depth-d nodes before testing can generate depth d+1 and yields O(b^(d+1)); specify the convention. Explicit finite graph traversal with visited-state tracking takes O(V+E) time and O(V) space. - Worked example BFS queue trace
- Children S:[A,B], A:[C,D]
- Removal: S,A,B,C,D
- Child-order assumption
👁 Full explanation
Trace a queueIf S has children A,B and A has C,D, BFS removal order starts S,A,B,C,D, assuming that child order.
6 related practice questions
Blueprint: AI3, AI4 · Note references: AI_MOD, AI_SHORT, AI_DEEP
- BFS: FIFO oldest-first
AI14
Depth-first search
[Exam Focus]- DFS: deepest pending branch
- LIFO stack or recursion
- FILO = LIFO
- Left-first trace: S,A,C before B
- Push rightmost first
👁 Full explanation
DFS follows the deepest pending branch using a LIFO stack or recursion. FILO means the same order as LIFO. With the same children as BFS, a left-first DFS visits S,A,C before B; push rightmost children first to pop the leftmost first. - DFS guarantees and bounds
- Implicit-tree time: O(b^m)
- Pending-sibling space: O(bm)
- Path-only recursive space: O(m)
- Generally nonoptimal
- Infinite-path and cycle failure
- Finite visited graph: complete
- Visited-state storage: O(V)
- Bank space O(b^m): time confusion
👁 Full explanation
Implicit-tree worst-case time is O(b^m), and space is O(bm) when pending siblings are stored, or O(m) for path-only recursive generation. DFS is not generally optimal and can fail on infinite paths or cycles. On a finite graph, visited-state tracking makes traversal complete but needs O(V) storage. Do not confuse the O(b^m) worst-case time bound with the DFS space bounds above.
5 related practice questions
Blueprint: AI3, AI4 · Note references: AI_MOD, AI_SHORT, AI_DEEP
- DFS: deepest pending branch
AI15
Uniform-cost search and Dijkstra
[Exam Focus]- UCS: minimum actual g(n)
- Priority queue
- Goal acceptance on removal
- First-generation goal trap
- Edge relaxation: cheaper path
- Updated frontier cost and parent
👁 Full explanation
UCS uses a priority queue ordered by actual accumulated path cost g(n). Remove a minimum-g node; accept a goal when removed, not when first generated. Relax each edge: if a cheaper path is found, update its frontier cost and parent. - UCS and Dijkstra conditions
- Finite branching; step cost ≥ε>0
- UCS completeness and optimality
- Finite graph: nonnegative edges, duplicate handling
- Dijkstra: reachable minimum distances
- UCS: goal stop, on-demand states
- Queue initialization: implementation choice
- Negative edges: finalized-distance failure
👁 Full explanation
With finite branching and each step at least ε>0, UCS is complete and optimal. Finite graphs permit nonnegative edges with proper duplicate handling. Dijkstra uses the same minimum-distance principle, often computing all reachable distances; UCS commonly stops at a goal and generates states on demand. Queue initialization is an implementation choice, not a fundamental distinction. Negative edges invalidate the usual finalized-distance argument.
2 related practice questions
Blueprint: AI3, AI4 · Note references: AI_MOD, AI_SHORT, AI_DEEP
- UCS: minimum actual g(n)
AI16
Depth Limits and Bidirectional Search
[Exam Focus]- Depth-limited and iterative deepening
- DLS: DFS to ℓ
- Cutoff versus failure
- Goals beyond ℓ missed
- Limits: 0,1,2,…
- Finite b: shallowest solution
- Time O(b^d); frontier space O(bd)
- Optimal: equal step costs
- Deepest level dominates repeated work
👁 Full explanation
DLS runs DFS to depth ℓ and reports cutoff separately from failure. It misses goals deeper than ℓ. Iterative deepening runs DLS with limits 0,1,2,…; for finite b it finds the shallowest solution with O(b^d) time and O(bd) frontier space, optimal for equal step costs. Repeated shallow work is small compared with the deepest level. - Bidirectional search and IDA*
- Start and goal frontiers
- Reverse actions and meeting tests
- Equal-cost BFS: O(b^(d/2)) time/space
- Weighted search: sound stopping bound
- First intersection ≠ cheapest
- IDA*: f=g+h threshold deepening
👁 Full explanation
Bidirectional search grows from start and goal until frontiers connect. With suitable reverse actions, meeting tests and equal-cost BFS, time and space may fall to O(b^(d/2)). Weighted variants require a sound stopping bound; the first intersection need not be cheapest. IDA* deepens an f=g+h threshold rather than only a depth limit.
4 related practice questions
Blueprint: AI3, AI4 · Note references: AI_MOD, AI_SHORT, AI_DEEP
- Depth-limited and iterative deepening
AI17
Heuristics and greedy best-first search
[Exam Focus]- Heuristic versus uninformed search
- h(n): remaining cost or promise
- Problem-specific knowledge
- Reduced exploration versus heuristic computation cost
- Uninformed: definition and known costs
- UCS uses g, remains uninformed
👁 Full explanation
A heuristic h(n) estimates remaining cost or evaluates promise using problem-specific knowledge. It can reduce explored work, but computing it also costs time. Uninformed algorithms use only the problem definition and known costs; UCS remains uninformed despite using g. - Greedy best-first search
- Best-first family: evaluation-ordered OPEN
- Greedy f=h; minimum estimate
- Past cost ignored
- Expensive route trap
- Loops without duplicate checks
- Infinite misleading branches
- Finite graph, full duplicate handling: complete
- Generally nonoptimal
- Finite-tree worst case: O(b^m)
👁 Full explanation
Best-first is a family that orders OPEN by an evaluation function. Greedy best-first uses f=h and removes the smallest estimate, ignoring the cost already paid. It can choose an expensive route, loop without duplicate checks, or follow an infinite misleading branch. On a finite graph with full duplicate handling it is complete, but not generally optimal. Its implicit finite-tree worst case can be O(b^m).
18 related practice questions
Blueprint: AI3, AI4 · Note references: AI_MOD, AI_SHORT, AI_DEEP
- Heuristic versus uninformed search
AI18
Admissibility, consistency and A*
[Exam Focus]- A*, admissibility and consistency
- f(n)=g(n)+h(n)
- Admissible: 0≤h(n)≤h*(n)
- h*: true cheapest remaining cost
- Consistent: h(n)≤c(n,n′)+h(n′)
- h(goal)=0
- Consistency ⇒ admissibility on goal-reaching states
- Consistency: nondecreasing path f
👁 Full explanation
A* orders by f(n)=g(n)+h(n). Admissibility means 0≤h(n)≤h*(n), the true cheapest remaining cost. Consistency means h(n)≤c(n,n′)+h(n′) on every edge, with h(goal)=0; it implies admissibility on states with goal paths. Consistency makes f nondecreasing along a path. - A* guarantees and traps
- Tree optimality: admissible h
- No-reopen graph search: consistent h
- Admissible inconsistent h: reopen improved g
- Goal test on minimum-f removal
- Infinite-space completeness: finite branching
- Positive lower-bounded step costs
- Exponential worst-case time and memory
- No universal heuristic speed guarantee
👁 Full explanation
Admissibility suffices for optimal A* tree search; graph search that never reopens CLOSED states normally requires consistency. With an admissible inconsistent heuristic, reopen states when g improves. Test a goal when removed at minimum f. Completeness also needs finite branching and positive lower-bounded costs in infinite spaces. Worst-case time and memory can be exponential; no heuristic universally guarantees speed.
10 related practice questions
Blueprint: AI3, AI4 · Note references: AI_MOD, AI_SEARCH, AI_SHORT
- A*, admissibility and consistency
AI19
Work a heuristic-search example
[Exam Focus]- Greedy versus A* trace
- Edges: SA=2, SB=1, AG=2, BG=10
- h(A)=2; h(B)=1; h(G)=0
- Greedy B→G: cost 11
- A*: f(A)=4, f(B)=2
- Expand B; G cost 11
- Expand A; replace G cost 4
- Remove goal: optimal cost 4
👁 Full explanation
For S→A cost 2, S→B cost 1, A→G cost 2, B→G cost 10, set h(A)=2, h(B)=1, h(G)=0. After expanding S, greedy chooses B because 1<2 and can then choose G, returning cost 11. A* compares A:f=2+2=4 and B:f=1+1=2; after B, its G entry costs 11. It next expands A and replaces G with cost 4, which is removed and accepted. - Heuristic lower-bound examples
- Unit sliding-puzzle moves
- Misplaced tiles excluding blank
- Summed Manhattan distances excluding blank
- Straight-line ≤ road distance
- Travel-time conversion: valid speed bound
👁 Full explanation
For a sliding puzzle with unit moves, misplaced-tile count and summed Manhattan distances excluding the blank are lower bounds. Straight-line distance is a lower bound on road distance; it is not automatically a lower bound on travel time without conversion using a valid speed bound.
Blueprint: AI3, AI4 · Note references: AI_MOD, AI_SHORT, AI_DEEP
- Greedy versus A* trace
AI20
Local optimization and evolutionary search
[Exam Focus]- Local search and hill climbing
- Complete candidate; objective improvement
- Path may be irrelevant
- First-improvement: first better neighbor
- Steepest-ascent: all neighbors
- Stochastic choice among improvements
- Local maxima; plateaus; ridges
- Random restarts; limited sideways steps
- No guaranteed success
👁 Full explanation
Local search keeps a complete candidate configuration and improves its objective; the path may be irrelevant. Hill climbing chooses better neighbors. First-improvement accepts the first improvement; steepest-ascent examines all neighbors; stochastic variants choose among improvements. Local maxima, plateaus and ridges can stop progress. Random restarts or limited sideways steps can help without guaranteeing success. - Genetic and means–ends search
- Population and fitness evaluation
- Parent selection
- Crossover; mutation; replacement
- No global optimality guarantee
- Means–ends: current–goal difference
- Difference-reducing operator
- Recursive precondition solving
- Backward A* misconception
👁 Full explanation
A genetic algorithm maintains a population, evaluates fitness, selects parents, applies crossover and mutation, and repeats replacement. It searches without guaranteeing global optimality. Means–ends analysis selects a difference between current and goal states, chooses an operator reducing it, and recursively solves its preconditions. Neither method is simply A* running backward.
2 related practice questions
Blueprint: AI3, AI4 · Note references: AI_MOD, AI_SHORT, AI_DEEP
- Local search and hill climbing
AI21
Constraint satisfaction
[Exam Focus]- Constraint satisfaction problem
- Variables X; domains D; constraints C
- Solution: every variable, every constraint
- Complete: all variables assigned
- Consistent: no violated constraints
- Complete assignment may be inconsistent
👁 Full explanation
A CSP specifies variables X, domains D, and constraints C. A solution assigns every variable a value and satisfies every constraint. Complete means all variables assigned; consistent means no violated constraint. A complete assignment can still be inconsistent. - CSP search and propagation
- Backtracking: assign, try, undo failure
- Fewest remaining values
- Degree tie-breaker
- Least-constraining value
- Forward checking: incompatible neighbor removal
- Arc consistency: unsupported binary values removed
- Problem framework, not fourth uninformed traversal
👁 Full explanation
Backtracking assigns a variable, tries a legal value, and undoes the choice on failure. Choose the variable with fewest remaining values; break ties by degree; try values that rule out fewest neighbor choices. Forward checking removes incompatible neighbor values. Arc consistency removes a value when a binary constraint offers it no support in the other domain. CSP is a problem framework using search and propagation, not a universal fourth uninformed traversal.
1 related practice question
Blueprint: AI3 · Note references: AI_MOD, AI_SHORT, AI_DEEP
- Constraint satisfaction problem
AI22
Games and minimax
[Exam Focus]- Adversarial game formulation
- Competing objectives
- States and player to move
- Legal actions and successor function
- Terminal test and utility
- Perfect information: visible state/history
- Future choices still unknown
- Perfect information may include chance
- Zero-sum: opposite gains/losses
👁 Full explanation
Adversarial search models agents with competing objectives. A game specifies states, player to move, legal actions, successor function, terminal test and utility. Perfect information means previous moves and current state are visible; it does not reveal future choices or imply absence of chance. Zero-sum utility makes one player’s gain the other’s loss. - Minimax and chance nodes
- Terminal utilities
- MIN: minimum; MAX: maximum
- Maximum-valued root action
- Best guarantee against optimal opposition
- Modeled-tree limitation
- Chance nodes: probability-weighted outcomes
👁 Full explanation
Minimax assigns terminal utilities, takes minima at MIN nodes and maxima at MAX nodes, then chooses a maximum-valued root action. It gives the best guaranteed outcome against optimal opposition within the modeled tree. For stochastic outcomes add chance nodes weighted by probabilities. - Worked example Minimax backup example
- MIN[3,5]=3
- MIN[2,9]=2
- MAX chooses first branch: 3
👁 Full explanation
Back up leavesIf two MIN children have leaves [3,5] and [2,9], their values are 3 and 2. MAX chooses the first branch with value 3.
4 related practice questions
Blueprint: AI3 · Note references: AI_MOD, AI_SHORT, AI_DEEP
- Adversarial game formulation
AI23
Alpha–beta and game evaluation
[Exam Focus]- Alpha–beta pruning
- Alpha: MAX lower bound
- Beta: MIN upper bound
- Bounds passed downward
- MAX updates alpha; MIN updates beta
- Prune: alpha≥beta
- Same-tree minimax value preserved
- Good move ordering
- Worst O(b^m); ideal O(b^(m/2))
👁 Full explanation
Alpha is MAX’s best lower bound; beta is MIN’s best upper bound. Pass bounds down, update alpha at MAX and beta at MIN, and prune when alpha≥beta. Pruning preserves the minimax value for the same searched tree. Good move ordering increases pruning: worst-case O(b^m), ideal ordering about O(b^(m/2)). - Cutoff evaluation functions
- Estimated position desirability
- Positive MAX; negative MIN
- +1/0/−1: win/draw/loss convention
- Material: weighted pieces
- Mobility: legal options
- Territory: controlled regions
- Combined features
- Limited computation, no victory guarantee
👁 Full explanation
At a depth cutoff use an evaluation function estimating position desirability. Positive favors the designated MAX player, negative MIN; the scale is a convention, with +1/0/−1 often win/draw/loss. Material counts weighted pieces; mobility counts legal options; territory scores controlled regions. These are different features, often combined. Heuristics improve limited computation, not guarantee victory.
7 related practice questions
Blueprint: AI3, AI4 · Note references: AI_MOD, AI_SHORT, AI_DEEP
- Alpha–beta pruning
AI24
Represent knowledge for inference
[Exam Focus]- Knowledge representation and inference
- Facts; objects; relations; events; rules
- Syntax: legal expressions
- Semantics: meaning
- Knowledge base: assertions
- Inference system: derived consequences
- Declarative: what true
- Procedural: how to act
👁 Full explanation
Knowledge representation encodes facts, objects, relations, events and rules so a machine can use them. Syntax defines legal expressions; semantics defines their meaning. A knowledge base stores assertions; an inference system derives consequences. Declarative knowledge says what is true; procedural knowledge specifies how to act. - Knowledge representation structures
- Semantic networks: labeled concept relations
- is-a links
- Frames: slots; values; defaults
- Production systems: IF–THEN rules
- Working-memory matching and rule selection
- Graph: frequently-bought-together relationships
- Frames: attributes
- Recommendation requirements determine suitability
👁 Full explanation
A semantic network connects concept nodes by labeled relations such as is-a. Frames describe stereotyped entities through slots, values and defaults. Production systems use IF conditions THEN conclusions or actions, matching rules against working memory and selecting among applicable rules. A graph suits relationships such as frequently bought together; frames suit attributes. No representation is always best for recommendation without task requirements.
6 related practice questions
Blueprint: AI1 · Note references: AI_MOD, AI_SHORT, AI_DEEP
- Knowledge representation and inference
AI25
Propositional logic and models
[Exam Focus]- Propositional connectives
- Atoms: whole truth-valued claims
- ¬P: negation
- P∧Q: both; P∨Q: at least one
- P→Q false: P true, Q false
- P↔Q: matching truth values
- P→Q ≡ ¬P∨Q
- De Morgan: ¬(P∧Q) ≡ ¬P∨¬Q
👁 Full explanation
Propositional atoms represent whole true-or-false claims. ¬P negates; P∧Q requires both; P∨Q requires at least one; P→Q is false only when P is true and Q false; P↔Q requires matching truth values. Thus P→Q ≡ ¬P∨Q. De Morgan gives ¬(P∧Q) ≡ ¬P∨¬Q. - Models, validity and entailment
- Model: satisfying interpretation
- Valid: every interpretation
- Satisfiable: at least one
- Unsatisfiable: no interpretations
- Invalid ≠ unsatisfiable
- P∨¬P: valid
- P: satisfiable, invalid
- P∧¬P: unsatisfiable
- KB⊨α: all KB models satisfy α
👁 Full explanation
A model is an interpretation making a sentence true. Valid means true in every interpretation; satisfiable means true in at least one; unsatisfiable means true in none. Invalid means not valid, and may still be satisfiable. P∨¬P is valid; P is satisfiable but not valid; P∧¬P is unsatisfiable. Entailment KB⊨α means every model of KB also satisfies α.
1 related practice question
Blueprint: AI1 · Note references: AI_MOD, AI_SHORT, AI_DEEP
- Propositional connectives
AI26
First-order logic and quantifier scope
[Exam Focus]- First-order logic vocabulary
- Objects; predicates; functions; quantified variables
- Human(a): property
- Likes(a,b): relation
- father(a): function term
- Propositional logic: no object quantifiers
- Assigned atom values determine truth
👁 Full explanation
First-order logic adds objects, predicates, functions and quantified object variables. Human(a) is a property; Likes(a,b) a relation; father(a) a function term. Propositional logic has no object quantifiers, but its truth still depends on the assigned atom values. - Quantifier translation and scope
- All humans: ∀x(Human(x)→Mortal(x))
- Tall student: ∃x(Student(x)∧Tall(x))
- Translation patterns, not connective prohibitions
- ∀x∃y Likes(x,y): potentially different y
- ∃y∀x Likes(x,y): shared y
- ¬∀x P(x) ≡ ∃x¬P(x)
- Negation swaps quantifiers
- Bound occurrences within correct scope
👁 Full explanation
Use ∀x(Human(x)→Mortal(x)) for all humans, and ∃x(Student(x)∧Tall(x)) for at least one tall student. These are useful translation patterns, not rules forbidding other connectives. ∀x∃y Likes(x,y) allows a different y for each x; ∃y∀x Likes(x,y) requires one shared y. Negation swaps quantifiers: ¬∀x P(x) ≡ ∃x¬P(x). Only occurrences within the correct quantifier’s scope are bound. - Worked example Existential conjunction trap
- ∃x(StandingAt(x,door)∧Tall(x))
- Same individual, both predicates
- Implication: unrelated vacuous witness
👁 Full explanation
Someone at the door∃x(StandingAt(x,door)∧Tall(x)) requires one individual satisfying both predicates. Using implication instead allows an unrelated individual to satisfy it vacuously.
4 related practice questions
Blueprint: AI1 · Note references: AI_MOD, AI_SHORT, AI_DEEP
- First-order logic vocabulary
AI27
Inference, unification and chaining
[Exam Focus]- Inference and unification
- Modus ponens: P,P→Q ⊢ Q
- Modus tollens: P→Q,¬Q ⊢ ¬P
- Affirming consequent trap
- Universal instantiation: object substitution
- Consistent unifying substitution
- Knows(x,Ada),Knows(Ben,y): x=Ben,y=Ada
- Distinct constants cannot unify
👁 Full explanation
Modus ponens derives Q from P and P→Q; modus tollens derives ¬P from P→Q and ¬Q. Affirming Q does not prove P. Universal instantiation substitutes an object for a universally quantified variable. Unification finds a consistent substitution: Knows(x,Ada) and Knows(Ben,y) unify with x=Ben,y=Ada. Distinct constants cannot be unified by renaming them. - Resolution and chaining
- P∨Q,¬P∨R ⊢ Q∨R
- Refutation: KB plus ¬α
- Clause form and contradiction
- Forward chaining: facts → rules
- Backward chaining: query → required premises
- Soundness: truth preservation
- Completeness: all entailed conclusions
- Specified-setting qualification
👁 Full explanation
Resolution combines clauses P∨Q and ¬P∨R into Q∨R. To prove α, add ¬α to KB in clause form and derive contradiction. Forward chaining starts with facts and fires rules; backward chaining starts with a query and proves required premises. Sound inference preserves truth; completeness means finding all entailed conclusions in its specified setting.
Blueprint: AI1 · Note references: AI_MOD, AI_SHORT, AI_DEEP
- Inference and unification
AI28
Deduction, induction and abduction
[Exam Focus]- Reasoning forms
- Deduction: truth-preserving rules
- Mortal people + Ada → mortal Ada
- Induction: observations → generalization
- New examples may overturn induction
- Abduction: plausible explanation
- Wet ground: rain or sprinklers
- Analogy: similar-situation pattern transfer
👁 Full explanation
Deduction applies truth-preserving rules: all people are mortal; Ada is a person; therefore Ada is mortal. Induction generalizes observations to a broader rule and can be overturned by new examples. Abduction proposes a plausible explanation: wet ground suggests rain, although sprinklers could explain it. Analogy transfers a pattern between similar situations. - Monotonic and default reasoning
- Classical entailment: consequences persist
- Added premises preserve deductions
- Nonmonotonic defaults: retractable conclusions
- Bird usually flies; penguin exception
- Incomplete knowledge; no truth guarantee
- Blind search ≠ reasoning definition
👁 Full explanation
Classical logical entailment is monotonic: adding premises preserves previous consequences. Default reasoning can be nonmonotonic: infer a bird usually flies, then withdraw this when told it is a penguin. Common-sense defaults are useful with incomplete knowledge, but are not guaranteed truths. Blind search is a search strategy, not a definition of reasoning.
6 related practice questions
Blueprint: AI1 · Note references: AI_MOD, AI_SHORT, AI_DEEP
- Reasoning forms
AI29
Probability and uncertain models
[Exam Focus]- Probability and Bayes
- P(¬A)=1−P(A)
- P(A|B)=P(A∩B)/P(B), P(B)>0
- P(H|E)=P(E|H)P(H)/P(E)
- Posterior; likelihood; prior; evidence
- Exclusive exhaustive hypotheses
- P(E)=ΣiP(E|Hi)P(Hi)
👁 Full explanation
Probability describes uncertainty about events. P(¬A)=1−P(A); P(A|B)=P(A∩B)/P(B), for P(B)>0. Bayes gives P(H|E)=P(E|H)P(H)/P(E): posterior equals likelihood times prior divided by evidence probability. For mutually exclusive exhaustive hypotheses, P(E)=ΣiP(E|Hi)P(Hi). - Uncertain graphical models
- Bayesian network: directed acyclic graph
- Conditional probability tables
- Joint: product of parent-conditioned probabilities
- Markov: next depends on current state
- Entire-history dependence excluded by assumption
- Uncertainty versus fuzzy membership
👁 Full explanation
A Bayesian network is a directed acyclic graph with conditional probability tables; its joint distribution factors as the product of each node’s probability given its parents. A Markov model assumes the next state depends on the current state rather than the entire past. These represent uncertainty; fuzzy membership represents a different issue. - Worked example Bayes numerical method
- Prior 0.1; likelihood 0.8
- Alternative likelihood 0.2
- Evidence: 0.08+0.18=0.26
- Posterior: 0.08/0.26≈0.308
- Likelihood ≠ posterior
👁 Full explanation
Update a hypothesisIf P(H)=0.1, P(E|H)=0.8 and P(E|¬H)=0.2, then P(E)=0.26 and P(H|E)=0.08/0.26≈0.308. Likelihood 0.8 is not the posterior.
2 related practice questions
Blueprint: AI1 · Note references: AI_MOD, AI_SHORT, AI_DEEP
- Probability and Bayes
AI30
Fuzzy logic and vague categories
[Exam Focus]- Fuzzy membership versus probability
- Graded membership: 0≤μ(x)≤1
- Warm/tall vague concepts
- Warm degree 0.7 ≠ probability 70%
- Boolean: true/false
- Probability: uncertain events
👁 Full explanation
Fuzzy sets assign graded membership μ(x) between 0 and 1 to concepts such as warm or tall. A temperature can belong to warm with degree 0.7. This is not a 70% probability that an otherwise crisp warm proposition is true. Boolean logic uses only true and false; probability describes uncertainty about events. - Fuzzy controller pipeline
- Fuzzify measurements
- Graded IF–THEN rules
- Combine outputs
- Defuzzify numerical action
- Fuzzy control: linguistic degrees
- RL: reward-based adaptation
- Complex/uncertain environment: insufficient method criterion
👁 Full explanation
A fuzzy controller fuzzifies measurements, applies graded IF–THEN rules, combines outputs and often defuzzifies to a numerical action. Fuzzy control suits linguistic rules about degrees; reinforcement learning suits reward-based adaptation. Merely saying an environment is complex or uncertain does not uniquely select either method.
3 related practice questions
Blueprint: AI1, AI4 · Note references: AI_FUZZY
- Fuzzy membership versus probability
AI31
Supervised learning and prediction
[Exam Focus]- Supervised prediction
- Labeled input–target mapping
- Classification: discrete labels
- Institution generations; spam/nonspam
- Regression: numeric targets, prices
- Predictive analytics: historical-pattern forecasts
- Classification or regression
- Target before method
👁 Full explanation
Supervised learning fits a mapping from labeled input–target examples. Classification predicts discrete labels, such as institution generations or spam/nonspam; regression predicts numeric quantities, such as prices. Predictive analytics uses historical patterns to forecast outcomes and can use either. Specify the target before choosing a method. - Decision trees and impurity
- Internal attribute tests; branches; leaf predictions
- ID3: high information gain
- H(S)=−Σpᵢlog₂pᵢ
- Gain: parent minus weighted child entropy
- Gini=1−Σpᵢ²
- Pure class: Gini zero
- Pruning against overfitting
- Supervised neural networks, SVMs, trees
👁 Full explanation
A decision tree tests an attribute at each internal node, follows the corresponding branch and predicts at a leaf. ID3 chooses high information gain: H(S)=−Σpᵢlog₂pᵢ; gain is parent entropy minus weighted child entropy. Gini impurity is 1−Σpᵢ², zero for a pure class. Pruning limits overfitting. Neural networks, support-vector machines and trees can all be supervised.
5 related practice questions
Blueprint: AI1, AI4 · Note references: AI_MOD, AI_SHORT, AI_DEEP
- Supervised prediction
AI32
Unsupervised, Semi-supervised and Active Learning
[Exam Focus]- Unsupervised structure discovery
- No target labels
- Clustering: similar-example groups
- Association: co-occurrence
- Dimensionality reduction: feature compression
- High within-cluster similarity
- Low between-cluster similarity
- Appropriate distance
- K-means: nearest assignment ↔ centroid updates
👁 Full explanation
Unsupervised learning seeks structure without target labels: clustering groups similar examples; association finds co-occurrence; dimensionality reduction compresses features. Good clusters have high within-cluster similarity and low between-cluster similarity under an appropriate distance. K-means alternates assignment to nearest centroids and centroid updates. - Semi-supervised and active learning
- Semi-supervised: labeled plus unlabeled
- Active: informative oracle-label queries
- Active learning still uses labels
- Exploratory learning: ambiguous terminology
- Unsupervised exploration versus active acquisition
- Feedback definition
- Summarization/time-series labels depend on training targets
👁 Full explanation
Semi-supervised learning combines some labels with additional unlabeled data. Active learning chooses informative cases for an oracle to label; it still uses labels. “Exploratory learning” is not an exclusive standard synonym: it can mean unsupervised exploration or active data acquisition, so define the feedback. A task named summarization or time-series analysis is not automatically supervised; its training targets determine that.
10 related practice questions
Blueprint: AI1, AI4 · Note references: AI_MOD, AI_SHORT, AI_ACTIVE
- Unsupervised structure discovery
AI33
Reinforcement learning
[Exam Focus]- Reinforcement learning interaction
- Observe → act → reward/new observation
- Policy improvement
- Expected cumulative reward objective
- Outcome reward ≠ correct-action label
- Delayed rewards
- Correct-looking action without immediate reward
👁 Full explanation
An RL agent observes state information, takes an action, receives reward and a new observation, and improves its policy to maximize expected cumulative reward. Rewards evaluate outcomes rather than supply the correct action label. Rewards may be delayed; not every correct-looking action receives immediate reward. - RL return and policy
- Gt=rt+1+γrt+2+γ²rt+3+…
- 0≤γ<1
- Policy: states/histories → action choices
- Exploration: information
- Exploitation: currently estimated reward
- RL⊂ML⊂AI
- No labels: RL or unsupervised
- Distinguishing reward-driven interaction
👁 Full explanation
An illustrative discounted return is Gt=rt+1+γrt+2+γ²rt+3+…, with 0≤γ<1. The policy maps states or histories to action choices. Exploration gathers information; exploitation pursues currently estimated reward. RL is part of machine learning, which is part of AI. “No labels” alone fits both unsupervised learning and RL; reward-driven interaction distinguishes RL.
11 related practice questions
Blueprint: AI1, AI4 · Note references: AI_MOD, AI_SHORT, AI_DEEP
- Reinforcement learning interaction
AI34
Neural networks and deep learning
[Exam Focus]- Neuron and activation functions
- z=Σiwixi+b; a=φ(z)
- x=(2,1), w=(0.5,−1), b=0.2
- Weighted sum: z=0.2
- Linear: z
- Sigmoid: 1/(1+e^(−z))
- tanh: bipolar
- ReLU: max(0,z)
- Nonlinear multilayer relationships
👁 Full explanation
A neuron computes z=Σiwixi+b and output a=φ(z). For x=(2,1), w=(0.5,−1), b=0.2, z=0.2. Linear activation returns z; sigmoid returns 1/(1+e^(−z)); tanh is bipolar; ReLU returns max(0,z). Nonlinearities let multiple layers represent nonlinear relationships. - Network architectures and training
- Feedforward: output-directed, no recurrent loops
- Recurrent: state across sequence steps
- Weight adjustment through gradients/backpropagation
- Backpropagation ≠ recurrent connection
- Deep learning: multiple representation layers
- Learned image, sound, text features
- CNN: shared filters across image locations
- ANN: brain-inspired abstraction
- Literal brain-simulation trap
- DL⊂ML⊂AI
👁 Full explanation
Feedforward networks pass signals toward outputs without recurrent state loops; recurrent networks carry state across sequence steps. Training adjusts weights, often through gradients and backpropagation. Backpropagation is not the same as a recurrent connection. Deep learning uses multiple representation layers and can learn features from images, sound and text. CNNs share filters across image locations. ANN is a brain-inspired abstraction, not a literal brain simulation; DL⊂ML⊂AI.
9 related practice questions
Blueprint: AI1 · Note references: AI_MOD, AI_SHORT, AI_DEEP
- Neuron and activation functions
AI35
Generalization and validation
[Exam Focus]- Generalization failures and controls
- Overfitting: training details, poor unseen performance
- Underfitting: limited or poorly fitted model
- Learning curve: performance versus training size/progress
- Complexity control
- Regularization; pruning
- More representative data
👁 Full explanation
Overfitting means fitting training-specific details so performance drops on unseen data; underfitting means the model is too limited or poorly fitted even on training data. A learning curve plots performance against training size or training progress. Complexity control, regularization, pruning and more representative data can help. - Training, validation and test splits
- Training: parameter fitting
- Validation: model/settings selection
- Held-out test: final estimation
- k-fold: k models, k−1 training folds
- Remaining-fold evaluation; average scores
- Stratification: approximate label proportions
- Preprocessing fitted inside training folds
- Time-respecting splits
- Repeated test tuning: information leakage
👁 Full explanation
Train data fits parameters; validation data selects models or settings; a held-out test set estimates final performance. In k-fold validation, train k models, each on k−1 folds and evaluate on the remaining fold, then average scores. Stratification approximately preserves label proportions. Fit preprocessing within each training fold. Time-ordered data needs splits respecting time; repeated tuning on the final test set leaks information.
3 related practice questions
Blueprint: AI1, AI4 · Note references: AI_MOD, AI_SHORT, AI_CV
- Generalization failures and controls
AI36
Measure the right errors
[Exam Focus]- Classification confusion matrix
- Fixed positive class
- TP: true positives; TN: true negatives
- FP: false alarms; FN: missed positives
- Accuracy=(TP+TN)/N
- Precision=TP/(TP+FP)
- Recall=TP/(TP+FN)
- F1=2PR/(P+R)
- Averaging and zero-denominator conventions
👁 Full explanation
With a fixed positive class, TP means true positives, FP false positive predictions, FN missed positives, TN true negatives. Accuracy=(TP+TN)/N; precision=TP/(TP+FP); recall=TP/(TP+FN); F1=2PR/(P+R). State the averaging and zero-denominator convention when relevant. - Metric calculation and selection
- TP=30, FP=10, FN=20, TN=40
- Accuracy=70%; precision=75%; recall=60%
- F1≈66.7%
- Rare-class failure hidden by accuracy
- Missed positives: recall
- Costly false alarms: precision
- MAE=mean|y−ŷ|
- MSE=mean(y−ŷ)²
- Squared errors emphasize large misses
👁 Full explanation
For TP=30, FP=10, FN=20, TN=40, accuracy=70%, precision=75%, recall=60%, and F1≈66.7%. Accuracy can hide failure on a rare class. Choose recall when missed positives matter; choose precision when false alarms are costly. Regression errors include MAE=mean|y−ŷ| and MSE=mean(y−ŷ)²; squared error penalizes large misses more strongly.
1 related practice question
Blueprint: AI4 · Note references: AI_SHORT
- Classification confusion matrix
AI37
Language processing tasks
[Exam Focus]- Natural language processing tasks
- Language interpretation and generation
- Translation; dialogue; summarization
- Question answering; text generation
- Speech recognition: audio → text
- Speech synthesis: generated speech
- Overlapping fields, distinct input/output tasks
👁 Full explanation
NLP interprets and generates human language: translation, dialogue, summarization, question answering and text generation. Speech recognition converts audio to text; speech synthesis generates speech. They overlap language processing but solve different input/output tasks. - Language processing levels
- Tokenization: words; punctuation; subwords
- POS tagging: grammatical roles
- NER: people; organizations; locations
- Parsing: grammatical structure
- Semantics: meaning
- Discourse: sentence links
- Pragmatics: context and speaker intent
- Sentiment: evaluative tone
- Bank: lexical ambiguity
- Telescope: attachment ambiguity
👁 Full explanation
Tokenization divides text into processing units; tokens may be words, punctuation or subwords. POS tagging assigns grammatical roles; named-entity recognition identifies people, organizations and locations. Parsing identifies grammatical structure; semantics concerns meaning; discourse links sentences; pragmatics uses context and speaker intent. Sentiment analysis predicts evaluative tone. Ambiguity can occur at every level: “bank” has multiple senses, and “I saw the man with a telescope” has multiple attachments.
10 related practice questions
Blueprint: AI2 · Note references: AI_MOD, AI_SHORT, AI_DEEP
- Natural language processing tasks
AI38
Morphology, sounds and prosody
- Morphology and speech sounds
- Meaningful word parts
- un-happi-ness: prefix; stem; suffix
- cats: cat + plural -s
- Tokenization: processing boundaries
- Phonetics: physical speech sounds
- Phonology: sound patterns and contrasts
👁 Full explanation
Morphology studies meaningful word parts: un-happi-ness contains a prefix, stem and suffix; cats contains cat and plural -s. It differs from tokenization, which identifies processing boundaries. Phonetics studies physical speech sounds; phonology studies a language’s sound patterns and contrasts. - Prosody and contextual meaning
- Stress; rhythm; timing
- Prominence and intonation
- Syllables and phrases
- Rising pitch: possible question
- Stress shifts: emphasis
- Dialogue and speech-processing cues
- Pragmatics: intended contextual meaning
- Pragmatics ≠ word-internal structure
👁 Full explanation
Prosody concerns stress, rhythm, timing, prominence and intonation across syllables and phrases. A pitch rise can help signal a question; shifting stress can change emphasis. These cues assist dialogue and speech processing. Pragmatics concerns intended meaning in context, not the internal components of words.
2 related practice questions
Note references: AI_MOD, AI_PROSODY
- Morphology and speech sounds
AI39
Perception, vision and robotics
[Exam Focus]- Computer vision tasks and limits
- Image/video interpretation
- Classification: content names
- Detection: object locations
- Segmentation: pixel labels
- Recognition: object/person identity
- Occlusion; lighting changes; noise
- Unfamiliar conditions; incomplete context
- Face detection versus open-world perception
👁 Full explanation
Computer vision interprets images or video: classification names image content, detection locates objects, segmentation labels pixels, and recognition identifies objects or people. Occlusion, lighting change, noise, unfamiliar conditions and incomplete context make open-world perception difficult even when a face detector works well. - Robotic sensing, planning and action
- Mechanical; electrical; control; computing systems
- Sensors; controller; power supply
- Actuators and end effector
- Legged; wheeled; tracked locomotion
- Terrain; stability; efficiency trade-offs
- Autonomous software ≠ robot
- Humanoid shape ≠ general intelligence
👁 Full explanation
Robotics combines mechanical, electrical, control and computing systems to sense, plan and act physically. Components include sensors, controller, power supply, actuators and an end effector. Locomotion may be legged, wheeled or tracked, with trade-offs in terrain, stability and efficiency. Software can act autonomously without being a robot. Humanoid shape is not evidence of general intelligence.
8 related practice questions
Blueprint: AI2, AI4 · Note references: AI_MOD, AI_SHORT, AI_DEEP
- Computer vision tasks and limits
AI40
Expert systems and choosing methods
[Exam Focus]- Expert system components
- Specialized domain knowledge; equipment diagnosis
- Domain expert: expertise
- Knowledge engineer: elicitation and encoding
- Inference engine: knowledge base/working facts
- User interface: interaction
- Explanation facility: why/how conclusions
👁 Full explanation
An expert system applies specialized knowledge to a domain such as equipment diagnosis. The domain expert supplies expertise; the knowledge engineer elicits and encodes it; the inference engine reasons over a knowledge base and working facts. The user interface handles interaction; an explanation facility presents why or how a conclusion was reached. - Method selection and responsible evaluation
- Rules: inspectable, brittle, maintenance cost
- Learned patterns: representative data and validation
- Search: explicit action alternatives
- Probability: uncertain evidence
- Data/evaluation bias and unfairness
- Group-specific errors
- Robustness; privacy; human oversight
- Automation benefit assumption trap
👁 Full explanation
Rules offer inspectable domain reasoning but can be brittle and costly to maintain. Learned models handle data-rich patterns but depend on representative data and validation. Search suits explicit action alternatives; probabilistic models suit uncertain evidence. Bias in data or evaluation can create unfair outcomes. Evaluate errors across relevant groups, robustness, privacy and human oversight rather than assuming automation is always beneficial.
6 related practice questions
Blueprint: AI2, AI4 · Note references: AI_MOD, AI_SHORT, AI_DEEP
- Expert system components
AI41
Clarify search and logic questions
- Search-question clarifications
- A*: forward best-first, g+h
- No inherent backward frontier
- A*/IDA*: conditional optimality
- A*/IDA*: exponential worst cases
- Minimum heuristic = estimated closest
- LIFO = FILO
👁 Full explanation
A* is forward best-first search combining actual past cost with estimated future cost; it does not inherently run a backward frontier. Both A* and IDA* can have exponential worst cases and optimality under their conditions. “Minimum heuristic” and “estimated closest” describe the same greedy choice. LIFO and FILO are synonyms. - Ambiguous search and validity stems
- Current-state information ≠ heuristic proof
- Estimated remaining cost criterion
- False: invalid iff unsatisfiable
- False: satisfiable implies valid
- Multiple false options
- Repair: all false or specified claim
👁 Full explanation
Using information from the current state alone does not establish that a search uses a heuristic. Ask whether remaining cost is estimated. Both “invalid iff unsatisfiable” and “satisfiable implies valid” are false in general; distinguish validity from satisfiability. Evaluate each validity claim separately, or identify all false statements when several are offered.
7 related practice questions
Note references: AI_MOD, AI_SEARCH
- Search-question clarifications
AI42
Distinguish agent categories and components
- Agent-class naming conventions
- Five including learning
- Four decision architectures before learning
- Count requires convention
- Target-based may mean goal-based
- Unity-based ≠ utility-based
👁 Full explanation
The common teaching list contains five agent classes when learning agents are included, or four decision architectures before learning is added. State the convention when counting agent types. “Target-based” can mean goal-based; “unity-based” is not utility-based. - Agent classification evidence
- Generic rule: memory unspecified
- Simple versus model-based reflex memory
- Unused goal ≠ goal-based policy
- Sensors/effectors: interaction only
- Interaction ≠ omniscience/intelligence
- Effector/actuator options: nonunique without distinction
👁 Full explanation
A generic rule does not distinguish simple from model-based reflex without specifying memory. A goal declaration unused by the action policy does not establish goal-based behavior. “Sensors and effectors” describes interaction, not omniscience or intelligence by itself. Define the mechanical distinction when comparing effectors and actuators as acting components.
10 related practice questions
Note references: AI_MOD, AI_SHORT, AI_DEEP
- Agent-class naming conventions
AI43
Clarify overlapping learning and AI labels
- Overlapping learning labels
- ANN; genetic search; RL improvement
- Experience-based performance changes
- Deep learning: architecture family
- Supervised; unsupervised; reinforcement objectives
- Trees and deep models: potentially supervised
- Regime evidence: labels, rewards, unlabeled structure
👁 Full explanation
ANNs, genetic search and reinforcement learning all improve candidate behavior or performance through experience in different ways. Deep learning is an architecture family usable with supervised, unsupervised or reinforcement objectives. Decision trees and deep models may both be supervised. To distinguish learning regimes, specify labels, reward or unlabeled structure. - AI-label question traps
- Face recognition: applied and narrow
- Emulating intelligence and building learning systems
- Humanlike problem-solving: insufficient expert-system criterion
- Python; C++; Java implementations
- Common language: nonunique answer
- McCarthy: naming, not sole invention
👁 Full explanation
Face recognition is both an applied task and a narrow capability. Broad machine-intelligence goals can include emulating human intelligence and building systems that learn. Humanlike problem-solving alone does not uniquely select expert systems. Python is widely used, but C++ and Java also implement AI; “commonly used” does not isolate one language. McCarthy is associated with naming AI, not its sole invention.
21 related practice questions
Note references: AI_MOD, AI_SHORT, AI_DEEP
- Overlapping learning labels
AI44
Source Damage and Assumption Repairs
- Quantifier negation
- ∀x∃y∃t¬F(x,y,t)
- Each person: failed fooling person/time
- Equivalent: ¬∃x∀y∀t F(x,y,t)
- Nobody fools everybody all the time
- Correct D; bold C wrong
- C: stronger prohibition on every success
- Read the formula carefully
👁 Full explanation
The formula ∀x∃y∃t¬F(x,y,t) means that for each person there is a person and time at which fooling fails. By quantifier negation this is ¬∃x∀y∀t F(x,y,t), so nobody fools everybody all the time. Forbidding every successful instance is a much stronger claim than this formula. - Implementation and task assumptions
- Dijkstra/UCS: stated implementations
- Queue initialization: nonintrinsic difference
- Chess moves: sequential
- Independently reset matches: episodic
- Recommendation suitability requires requirements
- Graph relationships: support, not exclusivity
👁 Full explanation
Compare Dijkstra and uniform-cost search under stated implementations rather than treating queue initialization as an intrinsic difference. For chess, specify the unit of decision: moves within a match are sequential; independently reset matches can be episodes. Select a recommendation design from explicit requirements; graph relationships can support a choice without excluding other designs.
5 related practice questions
Note references: AI_MOD, AI_DEEP, AI_VISUAL
- Quantifier negation
No matching topics. Clear the search or change the filter.
Blueprint learning outcomes
- AI1 · Understand reasoning, knowledge representation and learning techniques of artificial intelligence
AI08, AI24, AI25, AI26, AI27, AI28, AI29, AI30, AI31, AI32, AI33, AI34, AI35 - AI2 · Assess the role of AI in gaining insight into intelligence and perception
AI01, AI02, AI03, AI04, AI05, AI09, AI37, AI39, AI40 - AI3 · Understand the use of heuristics in search problems and games
AI11, AI12, AI13, AI14, AI15, AI16, AI17, AI18, AI19, AI20, AI21, AI22, AI23 - AI4 · Evaluate the strengths and weaknesses of these techniques and their applicability to different tasks
AI09, AI12, AI13, AI14, AI15, AI16, AI17, AI18, AI19, AI20, AI23, AI30, AI31, AI32, AI33, AI35, AI36, AI39, AI40