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.