The Exam Mindset

The final is handwritten. That changes the goal: you are not trying to memorize Lean output, you are training proof-state prediction. A proof state has a context above the line and a goal below it. Before each tactic step, ask what the context contains and what exact goal remains.

One Safe First Move

If the goal is an implication, use assume. If the goal is Q -> P, assume q : Q; the remaining goal becomes P, already available as p. If the goal instead matches a term in the context exactly, exact closes it.

variables P Q : Prop
example (p : P) : Q -> P :=
begin
  assume q,
  exact p,
end

The Evidence Problem

From not (P /\ Q), you know the pair cannot exist. You do not yet know whether P failed, whether Q failed, or both. That is why the direction not (P /\ Q) -> not P \/ not Q needs classical help in the course treatment.

Classical De Morgan Pattern

variables P Q : Prop
open classical

theorem dm2_em :
  not (P /\ Q) -> not P \/ not Q :=
begin
  assume npq,
  cases em P with p np,
  right,
  assume q,
  apply npq,
  constructor,
  exact p,
  exact q,
  left,
  exact np,
end

Universal Chaining

variables A : Type
variables PP QQ : A -> Prop

example : (forall x : A, PP x) ->
  (forall y : A, PP y -> QQ y) ->
  forall z : A, QQ z :=
begin
  assume p pq a,
  apply pq,
  apply p,
end

Existential Chaining

variables A : Type
variables PP QQ : A -> Prop

example : (exists x : A, PP x) ->
  (forall y : A, PP y -> QQ y) ->
  exists z : A, QQ z :=
begin
  assume p pq,
  cases p with a pa,
  existsi a,
  apply pq,
  exact pa,
end

Boolean Definition From Rows

Fix the first Boolean input. If the row pattern says "return the second input", write | tt b := b. If it says "always true", write | ff b := tt.

def bimp : bool -> bool -> bool
| tt b := b
| ff b := tt

Natural Reduction Trace

For course-style addition, recursion follows the second argument. Reduction means unfolding the matching equation until constructors remain:

def add : ℕ -> ℕ -> ℕ
| m 0 := m
| m (nat.succ n) := nat.succ (add m n)

So reduce by stripping successors from the second input until the base case appears.

Boolean Definitions Worth Knowing

def bxor : bool -> bool -> bool
| tt b := bnot b
| ff b := b

def biff : bool -> bool -> bool
| tt b := b
| ff b := bnot b

bxor flips the second input when the first input is true. biff keeps the second input when the first input is true and flips it when the first input is false.

Boolean-to-Proposition Bridge

&&, ||, and bnot compute on Boolean data. /\, \/, and not combine propositions. The lecture bridge is is_tt b, meaning the Boolean value b is true as a proposition.

List Shape

#check (@list.nil)
#check (@list.cons)

[1,2,3] is shorthand for 1 :: 2 :: 3 :: []. If a :: l = b :: m, then injection gives equality of heads and equality of tails. No-confusion says nil cannot equal a cons list.

Tree Shape

inductive Tree : Type
| leaf : Tree
| node : Tree -> ℕ -> Tree -> Tree

Tree sort builds a binary-search tree, then reads it with in-order traversal: left subtree, root, right subtree.

Insertion Example

The revision notes keep the list-insertion example ins 5 [6, 4, 2]. With the retained comparator, it reduces to [6, 5, 4, 2]. The exam skill is to trace one comparison at a time, not to recite the whole sorting algorithm.

What Can Be Tested

No-confusion and injectivity matter. [] cannot equal a :: l, and a :: l = b :: m gives both a = b and l = m. The notes say the injection tactic itself is not the exam target, but the injective property is still fair game.

Learning Targets

1. Distinguish symbols, words, alphabets, and languages.
2. Use epsilon, Sigma*, membership, and length notation accurately.
3. Compute language operations: concatenation, union, and Kleene star.

Concept Explanation

An alphabet, usually denoted by Σ, is a finite set of symbols. A word is a finite sequence of symbols from that alphabet. The empty word epsilon has length 0 and is still a word. Sigma* is the set of all finite words over Sigma, including epsilon.

A language is any subset of Sigma*. For Sigma = {0,1}, the set of words with an even number of 1s is a language, and the question 0101 in L? is a membership question.

Learning Targets

1. Read DFA and NFA transition diagrams as formal transition functions.
2. Trace input using extended transitions and NFA marker sets.
3. Explain why subset construction proves DFA/NFA equivalence for regular languages.

Concept Explanation

A DFA has exactly one current state. After reading the whole word, it accepts if that state is in F. The extended transition delta-hat(q,w) means "start at q and consume the whole word w".

An NFA may have many possible current states, beginning from S subset Q. It accepts if at least one possible path consumes the whole word and ends in a final state. Subset construction makes a DFA whose states are sets of NFA states.

Learning Targets

1. Parse regular expressions using precedence and parentheses.
2. Explain the NFA constructions for union, concatenation, and star.
3. Use table filling for DFA minimisation and pumping lemma reasoning for non-regularity.

Concept Explanation

Regular expressions are algebraic descriptions of languages. a denotes the singleton language {a}, r+s denotes union, rs denotes concatenation, and r* denotes zero or more repetitions.

Every regular expression can be converted to an NFA, and every DFA/NFA language can be described by a regular expression. Minimisation removes redundant DFA states; the pumping lemma helps prove that some languages cannot be regular.

Learning Targets

1. Read PDA transition notation and update stack contents correctly.
2. Trace instantaneous descriptions using input remainder and stack contents.
3. Compare final-state acceptance with empty-stack acceptance.

Concept Explanation

An instantaneous description records the machine state, unread input, and current stack. A PDA can use epsilon moves and nondeterministic choices, so a trace may branch. The stack is last-in-first-out memory, which is why it suits nested or mirrored structure.

Final-state acceptance means the input is consumed and the current state is final. Empty-stack acceptance means the input is consumed and the stack has been emptied. Standard constructions can convert between these acceptance styles, but exam traces must follow the requested mode.

Concept Explanation

A CFG is a tuple G = (V, Sigma, R, S). V is the finite set of nonterminals, Sigma is the alphabet of terminals, R is the finite set of productions, and S is the start symbol. A production such as A -> alpha replaces one nonterminal with a string of terminals and nonterminals.

A sentential form is any string reachable from S during derivation. The final word is reached when no nonterminals remain. A leftmost derivation always rewrites the leftmost remaining nonterminal; a rightmost derivation always rewrites the rightmost one.

Worked Derivation

G:
S -> a S b | epsilon

Leftmost derivation of aabb:
S
=> a S b
=> a a S b b
=> a a epsilon b b
= aabb

The intermediate strings S, a S b, and a a S b b are sentential forms. The completed terminal string aabb belongs to the generated language.

Concept Explanation

A deterministic PDA has at most one valid move for a given state, input situation, and stack top. The important exam trap is epsilon/input competition: if an epsilon transition is available for a state and stack top, an input-consuming transition for the same state and stack top cannot also be available.

The delimiter language { w $ w^R | w in {0,1}* } is DPDA-friendly because $ tells the machine exactly when to stop pushing and start popping. Without a delimiter, the midpoint must be guessed, which needs nondeterminism.

Worked DPDA Trace

Input: 01$10
Before $: push symbols
read 0, stack: 0 Z
read 1, stack: 1 0 Z
read $, switch to matching
read 1, pop 1
read 0, pop 0
accept when input is done and stack returns to Z

The delimiter removes the ambiguous control decision. The stack stores w; the second half must match it in reverse order.

Concept Explanation

The hierarchy moves from regular languages to context-free languages, context-sensitive languages, recursive languages, and recursively enumerable languages. A context-sensitive grammar uses non-contracting productions: the right side is at least as long as the left side, except for the usual special start-symbol S -> epsilon caveat.

Unrestricted grammars remove that length restriction and match the power of Turing-machine recognizable languages. A Turing machine is commonly given as (Q, Sigma, Gamma, delta, q0, B, F), with input alphabet Sigma, tape alphabet Gamma, blank B, transition function delta, start state q0, and accepting states F.

Worked TM Trace

Language idea: 0ⁿ1ⁿ
Input: 0011
1. Mark the leftmost unmarked 0 as X.
2. Move right to the leftmost unmarked 1 and mark it Y.
3. Return left to find the next unmarked 0.
4. Repeat until no unmarked 0 remains.
5. Accept if only X and Y markers remain.

The markers store which symbols have already been paired. The finite state controls the scan direction and detects malformed order, such as a remaining 0 after marked 1s.

Concept Explanation

A recognizer accepts strings in the language but may loop forever on strings outside it. A decider always halts, accepting members and rejecting nonmembers. Recursive languages are decidable; recursively enumerable languages are recognizable. Every recursive language is RE, but not every RE language is recursive.

The halting problem asks whether there is a general algorithm that decides whether an arbitrary program halts on an arbitrary input. The standard result is negative, so it marks a boundary on what computation can decide.

Worked Exam Map

Earlier course:
alphabet -> DFA/NFA -> regex -> pumping

Middle course:
PDA -> CFG -> DPDA -> ambiguity

Final course:
CSG -> TM -> recognizer/decider -> halting
lambda calculus -> Church-Turing idea
P vs NP -> Partition as an NP example

Transcript-derived Lecture 11 guidance: the revision cues point to synthesis: know definitions, trace small machines, and explain limits with concise examples rather than long formal proofs. The short Lecture 11 slide source confirms only the exam-guidance/revision session structure.

Learning Targets

1. Separate a general problem from a concrete instance.
2. Explain when exact methods, heuristics, local search, and stochastic methods fit.
3. Write the six-part search setup examiners keep asking for.

Concept Explanation

A heuristic is not magic. It is a trade: give up a guarantee, gain a route through a huge search space. That trade is useful for TSP, bin packing, MAX-SAT, timetabling, and other problems where enumerating every solution is not realistic.

In exam writing, define the representation, the objective function, and the neighbourhood. Without those three, the search method has nowhere concrete to operate.

Learning Targets

1. Trace first-improvement and best-improvement hill climbing.
2. Explain plateaus, ridges, and local optima without overclaiming.
3. Instantiate the component checklist for MAX-SAT, TSP, bin packing, or knapsack.

Concept Explanation

Hill climbing keeps a current solution and moves to a better neighbour. Best improvement checks the neighbourhood and takes the best improving move. First improvement takes the first improving move it finds. Both can stop at a local optimum even when a better solution exists elsewhere.

For MAX-SAT, a common representation is a bit string assigning truth values. A neighbour flips one bit. Some descriptions maximise satisfied clauses; the lecture traces often minimise unsatisfied clauses. Say which convention you are using, then show the assignment, the changed bit, and the new score.

Learning Targets

1. Explain exploration and exploitation using concrete search behaviour.
2. Trace simulated annealing acceptance for a worse move.
3. Compare ILS, Tabu Search, and SA as escape mechanisms.
4. Recognise the named move-acceptance and Tabu Search details that appear in the slides.

Concept Explanation

Iterated local search repeatedly improves a solution, perturbs it, then runs local search again. Tabu Search uses memory so recent moves or attributes are temporarily forbidden. Simulated annealing sometimes accepts worse moves, especially early when the temperature is high.

Do not define a metaheuristic as "a better heuristic." The exam-safe definition is that it is a general strategy for guiding subordinate search procedures across many optimisation problems.

Learning Targets

1. Write genetic algorithm pseudocode with the right operators.
2. Compute roulette-wheel selection probabilities from fitness values.
3. Explain why representation changes the crossover and mutation operators.
4. Place memetic algorithms, evolution strategies, and genetic programming in the evolutionary-method family.

Concept Explanation

A population holds many candidate solutions. Selection biases reproduction toward fitter individuals. Crossover recombines parents. Mutation adds small random variation. Replacement decides who survives into the next generation.

A memetic algorithm adds local improvement to individuals, usually after crossover or mutation. In exam terms: GA gives broad exploration; local search sharpens candidates.

Learning Targets

1. Distinguish metaheuristics from hyper-heuristics.
2. Classify selection vs generation and online vs offline learning.
3. Model exam timetabling as graph colouring.
4. Recognise HyFlex, LD/SD graph-colouring choices, and application details from the hyper-heuristic slides.

Concept Explanation

A selection hyper-heuristic chooses among existing low-level heuristics. A generation hyper-heuristic creates new heuristics. A no-learning system follows a fixed rule, an online system learns while solving, and an offline system learns before being used.

For timetabling, graph colouring gives the cleanest exam explanation. Vertices are exams. Edges mean two exams clash because at least one student takes both. Colours are timeslots.

Learning Targets

1. Compare declarative, procedural, semantic, and heuristic knowledge.
2. Explain syntax vs semantics in logic-based representation.
3. Write concise answers on CBR, LLMs, and chain-of-thought prompting.
4. Recognise production rules, frames, conceptual graphs, DSS, learning agents, and decision-tree exam prompts.

Concept Explanation

Symbolic AI uses explicit symbols and rules, such as logic, frames, production rules, and case libraries. Non-symbolic AI uses distributed numeric representations, such as neural networks. A good answer says what is represented and how inference or retrieval works.

For LLMs, mention transformer-style sequence modelling and self-attention at a high level. For chain-of-thought, say it encourages intermediate reasoning steps, but can still produce wrong or unfaithful explanations.

Learning Targets

1. List conceptual-model components and requirements.
2. Classify simulations as static/dynamic, discrete/continuous, deterministic/stochastic.
3. Sketch stock-flow logic without confusing stocks and rates.
4. Explain how simplification choices such as aggregation, exclusion, and random variables affect a conceptual model.

Concept Explanation

A conceptual model is the bridge between the real situation and the implemented simulation. It says what is inside the boundary, what is ignored, and which assumptions are acceptable for the decision being supported.

Discrete-event simulation changes state at event times. System dynamics uses stocks, flows, and feedback loops. Agent-based modelling simulates individual agents and their interactions.

Learning Targets

1. Turn a vague AIM question into a structured answer quickly.
2. Spot the marking words: define, compare, trace, compute, classify, discuss.
3. Use exam caveats without turning them into waffle.

Exam-Focus Map

Trace: hill climbing, SA, GA selection, stack/stock-flow style model logic. Compare: exact vs heuristic, local search vs metaheuristic, metaheuristic vs hyper-heuristic, symbolic vs non-symbolic. Define: neighbourhood, objective, fitness, syntax, semantics, validity, stochastic.

Learning agents and decision trees show up in older papers. Know the definitions, then put most of your time into the topics that repeat more often: search, GA, hyper-heuristics, KR&R, LLM/CoT, and simulation.