Lesson 16 adds one unbounded stack to a finite automaton. It explains why a stack is exactly the right addition and what its last-in-first-out discipline still forbids, then covers transitions that read, pop, and push, with each part optional, and the bottom-marker trick for testing emptiness. It gives the formal seven-tuple and the six-tuple variant, configurations and the computation relation, and the final-state and empty-stack acceptance conventions with conversions in both directions. Designs follow for matched counts, palindromes, two kinds of bracket, and strict inequalities. It closes with the result that deterministic pushdown automata are strictly weaker, giving the standard witness language and explaining why the subset construction cannot be transferred.
Subject: Theory of Computation · 116 slides · symbolic lesson
Open the interactive version of this deck · Homework for this lesson
Title
Theory of Computation · Lesson 16
Bolt one unbounded stack onto a finite automaton. It is exactly enough memory to match nesting — and no more.
Objectives
Lesson 13 gave a generator for the context-free languages. This lesson gives the recognizer. By the end you can:
Warm-up
Discussion prompt
Before we open Pushdown Automata: without looking back, what was the main idea of Chomsky Normal Form, and what could you do by the end of it that you could not do before?
Hint: One sentence for the idea, one for the skill. If the second one is blank, that is the part to revisit.
Answer:
Lesson 15 makes grammars uniform. Covers the two permitted rule shapes and the single start-variable exception, the derivation-length property that follows, removing useless variables with generating computed before reachable, removing epsilon-rules by adding one alternative per subset of nullable positions and why every subset is needed, removing unit rules by closing over unit pairs including cycles, lifting terminals and binarizing long rules, and the full four-pass pipeline with a justification for each ordering constraint.
Section
Section 1
Concept
Lesson 11 pinned down exactly what finite automata lack: the ability to carry an unbounded quantity from one part of a string to a later part.
Matched counts, balanced brackets and palindromes all failed for the same reason. The machine had to remember something whose range grew with the input, and finitely many states cannot.
\[ \text{unbounded quantity to carry} \;\Rightarrow\; \text{no finite automaton} \]
So the fix is to add storage. The question is how much, and with what discipline — because unrestricted storage would overshoot and give the machines of Lesson 20 straight away.
Counterexample
Discussion prompt
Matched counts, balanced brackets and palindromes all failed for the same reason. The machine had to remember something whose range grew with the input, and finitely many states cannot.
That is stated as though it always holds. Do one of two things: produce a case where it fails, or say precisely what rules such a case out. "It just does" is not on the menu.
Hint: Hunt at the extremes first — zero, one, negative, empty, equal. If every extreme survives, the reason they survive is the proof.
Intuition
Adding a stack gives unbounded storage with a severe restriction: only the top item is visible, and items come off in the reverse order they went on.
That restriction is exactly right for nesting. An opening bracket goes on the stack and its matching closing bracket takes it off, so the most recent unmatched opening is always the one on top.
| Memory added | Recognizes | Too much? |
|---|---|---|
| nothing | regular languages | — |
| one stack | context-free languages | no — matches nesting exactly |
| two stacks | everything a Turing machine can | yes — overshoots |
| a counter | a proper subclass | no — undershoots |
Comparison
Comparison matrix
From A stack is the smallest useful addition: refill the Recognizes column from what you know. The rest of the table is as it appeared.
| Memory added | Recognizes | Too much? |
|---|---|---|
| nothing | regular languages | — |
| one stack | context-free languages | no — matches nesting exactly |
| two stacks | everything a Turing machine can | yes — overshoots |
| a counter | a proper subclass | no — undershoots |
Concept
A stack supports exactly three moves, and nothing else is available.
There is no way to look at the second item, count the items, or read the bottom without removing everything above it. Those restrictions are what keep the model from being too powerful.
\[ \text{visible} = \text{top symbol only} \]
Analogy
Discussion prompt
Explain The three operations by analogy to something with no Theory of Computation in it at all — a queue, a recipe, a map, a bank balance, whatever fits. Then say where your analogy breaks.
Hint: An analogy that never breaks is not an analogy, it is the same idea wearing a hat. Find the seam — that is the part that is actually new.
Answer:
A stack supports exactly three moves, and nothing else is available.
Ranking
Put in order
Put the moves of Match brackets with a stack, by hand into the order they have to happen.
Why: These are the moves of the worked example in the order it makes them, and each one is set up by the one before it. Record that one more closing bracket is now owed.
Worked example
Before any formalism, run the algorithm you would write yourself, and notice it uses only the three operations.
Set up
Why: Start with an empty stack and read the input left to right.
On an opening bracket, push
Why: Record that one more closing bracket is now owed.
\[ ( \;\longrightarrow\; \text{push} \]
On a closing bracket, pop
Why: If the stack is empty there was nothing to match, so reject. Otherwise remove one item.
\[ ) \;\longrightarrow\; \text{pop, or reject if empty} \]
At the end, check the stack is empty
Why: Anything left means an opening bracket was never matched.
Verify on three inputs
Why: The string with two nested pairs pushes twice then pops twice, ending empty — accept. The string with a closing bracket first tries to pop an empty stack — reject. The string with one unmatched opening ends with an item still present — reject. All three verdicts match the language.
\[ (()) \in L \qquad )( ,\ (() \notin L \ \checkmark \]
Picture it
Animation
Shows: Each line of the worked example "Match brackets with a stack, by hand", appearing one at a time.
The same working the example does, in the order a tutor would write it.
Takeaway: The string with two nested pairs pushes twice then pops twice, ending empty — accept. The string with a closing bracket first tries to pop an empty stack — reject. The string with one unmatched opening ends with an item still present — reject. All three verdicts match the language.
Concept
The stack's depth is what carries the unbounded quantity, so bounding it would collapse the model back to finite automata.
A stack of depth at most k has finitely many possible contents, so the machine's whole situation — state plus stack — takes finitely many values. That is a finite automaton with more states.
\[ \text{bounded stack} \;\Rightarrow\; \text{finitely many situations} \;\Rightarrow\; \text{regular} \]
Unboundedness is therefore not a convenience but the entire source of the extra power, exactly as unbounded nesting depth was the source of the difficulty.
Explain it
Discussion prompt
Explain Why the stack must be unbounded to a student a year behind you. No notation, no jargon they have not met — and it still has to be true.
Hint: If your explanation needs a symbol they have never seen, you are describing the notation rather than the idea.
Answer:
The stack's depth is what carries the unbounded quantity, so bounding it would collapse the model back to finite automata.
Intuition
The discipline that makes a stack useful also limits it, and knowing the limit early explains Lesson 18.
Items come off in reverse order, so a stack can compare a prefix against a reversed suffix — but not against a suffix in the same order. And once popped, an item is gone, so a quantity can be checked once and not twice.
| Language | Within reach? | Why |
|---|---|---|
| matched counts | yes | push then pop once |
| palindromes | yes | reversal is what a stack gives |
| a block written twice | no | needs the same order, not reversed |
| three matched counts | no | the count is consumed by the first check |
Discrimination
Sort into buckets
Sort these by Within reach?, from memory, without looking back at What a stack still cannot do. Telling them apart on the spot is the skill; the table is only where the answer happens to be written down.
Ranking
Put in order
These are the steps of Deciding whether a stack suffices, scrambled. Put them back in order before the next slide shows you.
Why: This is the order the recipe itself gives. Recalling the sequence without the slide in front of you is the difference between recognising the method and being able to run it — most of what goes wrong in practice is a step done out of turn.
Pattern
Before designing a machine, ask whether the language's structure fits a stack's discipline.
The fourth line covers every design in this lesson. The fifth covers the standard non-context-free examples.
Elimination
Eliminate the wrong options
Why can a pushdown automaton recognize palindromes but not strings consisting of a block written twice?
3 of these 4 are wrong. Strike them one at a time, and say what rules each one out before you strike the next. The survivor is the answer.
Survives elimination: A
Why: Pushing the first half and popping while reading the second compares the second half against the reverse of the first — exactly the palindrome condition. A repeated block needs the second half compared in the same order, and a stack cannot produce that.
Check
Think about the order items come off.
Check your understanding
Why can a pushdown automaton recognize palindromes but not strings consisting of a block written twice?
Answer: A
Why: Pushing the first half and popping while reading the second compares the second half against the reverse of the first — exactly the palindrome condition. A repeated block needs the second half compared in the same order, and a stack cannot produce that.
Intuition
There is a deeper reading of what the stack holds, and Lesson 17 makes it precise.
When a machine is built from a grammar, the stack holds the part of the derivation not yet matched against the input — the pending obligations. Popping a symbol discharges one obligation.
So the stack is not an ad-hoc memory: it is the frontier of a partially built parse tree. That is why exactly this discipline matches exactly this class of grammars.
\[ \text{stack contents} \;\longleftrightarrow\; \text{unmatched part of the derivation} \]
Section
Section 2
Concept
A single move of the machine involves three things at once, and every one of them is optional in a specific sense.
A transition is written with the input, the popped symbol and the pushed string, separated by commas and an arrow.
\[ a, X \to \gamma \]
Read that as: on input a, with X on top of the stack, remove X and put the string in its place.
Concept
Each of the three components may be the empty string, and each choice means something specific.
| Written | Means |
|---|---|
| a symbol as input | consume that symbol |
| empty input | move without consuming — a free move |
| a symbol as pop | require it on top, and remove it |
| empty pop | do not inspect or remove anything |
| a symbol as push | put it on top |
| empty push | put nothing back — a net pop |
Pushing two symbols where one was popped grows the stack by one; pushing the same symbol back leaves the depth unchanged.
Trade off
Comparison matrix
From The three optional parts: every row here is a choice with a cost. Fill the Means column, then say which row you would actually pick and what you give up for it.
| Written | Means |
|---|---|
| a symbol as input | consume that symbol |
| empty input | move without consuming — a free move |
| a symbol as pop | require it on top, and remove it |
| empty pop | do not inspect or remove anything |
| a symbol as push | put it on top |
| empty push | put nothing back — a net pop |
Step zero
Discussion prompt
Read three transitions — before any calculation: what is the plan? Name the moves in order, in plain English, without doing the arithmetic.
Hint: It starts with: A pure push
Answer:
Worked example
Translate the notation into plain English, since every design that follows is written this way.
A pure push
Why: Read an a, do not inspect the stack, and put an X on top. The stack grows by one.
\[ a, \varepsilon \to X \]
A pure pop
Why: Read a b, require an X on top, and put nothing back. The stack shrinks by one.
\[ b, X \to \varepsilon \]
A test that leaves the stack alone
Why: Read nothing, require the bottom marker on top, and put it straight back. This checks the stack is otherwise empty without disturbing it.
\[ \varepsilon, Z \to Z \]
Note the third is how emptiness is tested
Why: A stack cannot be asked whether it is empty. The standard trick is to push a marker at the start and test for it, which is what the seven-tuple's initial stack symbol is for.
Verify the depth changes are as stated
Why: The first adds one symbol and removes none, the second removes one and adds none, and the third removes one and adds one. Net changes of plus one, minus one and zero — matching the descriptions.
\[ +1, \; -1, \; 0 \ \checkmark \]
Picture it
Animation
Shows: Each line of the worked example "Read three transitions", appearing one at a time.
The same working the example does, in the order a tutor would write it.
Takeaway: The first adds one symbol and removes none, the second removes one and adds none, and the third removes one and adds one. Net changes of plus one, minus one and zero — matching the descriptions.
Concept
Plotting the stack depth against the input position is a fast way to understand what a machine is doing.
| Shape of the profile | What the machine is doing |
|---|---|
| rises then falls once | store a prefix, match it against a suffix |
| rises and falls repeatedly | match nested structure as it goes |
| stays near zero | the stack is barely used — probably a regular language |
| rises without falling | nothing is ever checked — the design is incomplete |
The last row is a genuine bug signal. A machine that pushes and never pops is not using its stack to decide anything, so its language is regular whatever the design intended.
Estimation
Predict first
Practise the diagnostic on a machine described only by what it does to the stack.
Commit before you compute: what does Read a language off a stack profile come out to? A rough magnitude and the right form is enough — the point is to have something concrete to be wrong about.
Correct: Verify the inference on three strings
Why: A prediction you can defend turns the computation into a check rather than a leap of faith — and an answer that contradicts it is caught on the spot. The string acb has one of each and empties the stack; aaccbb has an extra c and has no applicable transition at the second c; ab has no c at all and never leaves the first phase.
Worked example
Practise the diagnostic on a machine described only by what it does to the stack.
Take the description
Why: The machine pushes one marker per symbol while reading a's, does nothing to the stack while reading a single c, then pops one marker per symbol while reading b's.
Read the profile
Why: The depth rises through the first block, is flat for one symbol, then falls through the last block — a single rise and fall.
Infer the condition
Why: The number of pops must match the number of pushes for the stack to empty, so the two blocks have equal length, with the middle symbol as a marker.
\[ L = \{\, a^{n}cb^{n} : n \ge 0 \,\} \]
Check the marker's role
Why: The single c makes the phase boundary visible in the input, so no guessing is needed and the machine is deterministic.
Verify the inference on three strings
Why: The string acb has one of each and empties the stack; aaccbb has an extra c and has no applicable transition at the second c; ab has no c at all and never leaves the first phase. Only the first is accepted, matching the inferred language.
\[ acb,\ aacbb \in L \qquad aaccbb,\ ab \notin L \ \checkmark \]
Picture it
Animation
Shows: Each line of the worked example "Read a language off a stack profile", appearing one at a time.
The same working the example does, in the order a tutor would write it.
Takeaway: The single c makes the phase boundary visible in the input, so no guessing is needed and the machine is deterministic.
Concept
These machines are nondeterministic by default, in exactly the sense of Lesson 5, and for the same reasons.
A configuration may have several applicable transitions, or none. Acceptance requires some computation to succeed, and a stuck branch proves nothing.
\[ \text{accept} \iff \exists \text{ an accepting computation} \]
Free moves are available too, so the machine may reorganize its stack without consuming input. Both features are used constantly in the designs of Section 5.
Missing information
Discussion prompt
Run the standard machine for matched counts, tracking state, remaining input and stack together.
What do you need to know — or decide — before the first line can be written? List everything the problem has to hand you.
Hint: Anything you would have to invent to get started is a thing the problem must supply.
Answer:
State one, the whole input still to read, and an empty stack apart from the bottom marker.
Worked example
Run the standard machine for matched counts, tracking state, remaining input and stack together.
\[ q_1: \; a, \varepsilon \to X \qquad q_2: \; b, X \to \varepsilon \]
Start
Why: State one, the whole input still to read, and an empty stack apart from the bottom marker.
\[ (q_1, \; aabb, \; Z) \]
Push for each a
Why: Two a's are read, pushing one marker each. The stack now records how many b's are owed.
\[ (q_1, \; bb, \; XXZ) \]
Switch to popping
Why: A free move takes the machine to the second state, where b's are matched against the stack.
\[ (q_2, \; bb, \; XXZ) \]
Pop for each b
Why: Two b's are read, each requiring and removing one marker. The stack returns to just the bottom marker.
\[ (q_2, \; \varepsilon, \; Z) \]
Verify acceptance and check a rejected string
Why: The input is exhausted with only the marker left, so the counts matched and the string is accepted. Running aab instead leaves one marker on the stack with no input remaining, so no accepting computation exists — correctly rejecting it.
\[ aabb \in L \qquad aab,\ abb \notin L \ \checkmark \]
Picture it
Animation
Shows: Each line of the worked example "Trace a machine on a matched-count string", appearing one at a time.
The same working the example does, in the order a tutor would write it.
Takeaway: The input is exhausted with only the marker left, so the counts matched and the string is accepted. Running aab instead leaves one marker on the stack with no input remaining, so no accepting computation exists — correctly rejecting it.
Anomaly
Predict first
A student writes this, and it looks reasonable:
Design a machine that accepts only when the stack has been fully emptied.
It is wrong. Say what breaks — and say it before you turn the page.
Correct: Write a move that fires when nothing is on the stack, and let it enter the accepting state.
Design a machine that accepts only when the stack has been fully emptied.
Why: Write a move that fires when nothing is on the stack, and let it enter the accepting state.
Trap
Design a machine that accepts only when the stack has been fully emptied.
Add a transition conditioned on an empty stack
Why: Write a move that fires when nothing is on the stack, and let it enter the accepting state.
\[ \varepsilon, \text{empty} \to \varepsilon \]
Notice the notation cannot express it
Why: Every transition's pop component names a symbol to require, or names nothing at all. There is no symbol meaning 'the stack is empty', and a transition that pops nothing fires regardless of the contents.
Design a machine that accepts only when the stack has been fully emptied.
Push a bottom marker before anything else
Why: The very first move, consuming no input, pushes a symbol used nowhere else.
\[ \varepsilon, \varepsilon \to Z \]
Test for the marker instead of for emptiness
Why: Seeing the marker on top means everything pushed above it has been popped, which is the condition that was wanted.
\[ \varepsilon, Z \to \varepsilon \]
Note this is what the seven-tuple formalizes
Why: The initial stack symbol in the formal definition is exactly this marker, provided by the definition rather than pushed by hand.
\[ Z_0 \in \Gamma \ \checkmark \]
Notation
Annotate
From Trap: assuming the stack can be tested for emptiness — read this one piece at a time. What is each part doing?
On: \( \varepsilon, \text{empty} \to \varepsilon \)
Pattern
Given an unfamiliar machine, this recovers what it does.
The second step is the most informative. A machine's stack profile — where it grows and where it shrinks — usually reveals the language immediately.
Section
Section 3
Concept
Two more components than a finite automaton: an alphabet for the stack, and a symbol to start it with.
\[ P = (Q, \Sigma, \Gamma, \delta, q_0, Z_0, F) \]
| Component | What it is |
|---|---|
| Q | a finite set of states |
| the input alphabet | symbols the machine reads |
| the stack alphabet | symbols the machine may push |
| the transition function | described on the next slide |
| the start state | one element of Q |
| the initial stack symbol | one element of the stack alphabet |
| F | the accepting states |
The two alphabets are usually different and need not overlap. The stack alphabet often contains markers that never appear in any input.
Comparison
Comparison matrix
From The seven-tuple: refill the What it is column from what you know. The rest of the table is as it appeared.
| Component | What it is |
|---|---|
| Q | a finite set of states |
| the input alphabet | symbols the machine reads |
| the stack alphabet | symbols the machine may push |
| the transition function | described on the next slide |
| the start state | one element of Q |
| the initial stack symbol | one element of the stack alphabet |
| F | the accepting states |
Concept
It takes a state, an input symbol or nothing, and a stack symbol, and returns a set of next moves — each a state paired with a string to push.
\[ \delta : Q \times \Sigma_{\varepsilon} \times \Gamma_{\varepsilon} \to \mathcal{P}\big(Q \times \Gamma^{*}\big) \]
Returning a set is the nondeterminism, exactly as in Lesson 5. The subscripted alphabets are the ones extended with the empty string, allowing free moves and stack-blind moves.
The pushed component is a string, so one move may push several symbols at once. That is what lets a grammar rule with a long right-hand side be applied in a single step.
Step zero
Discussion prompt
Write the seven-tuple for a machine — before any calculation: what is the plan? Name the moves in order, in plain English, without doing the arithmetic.
Hint: It starts with: List the states
Answer:
Worked example
Formalize the matched-count machine traced earlier.
\[ q_1: \; a, \varepsilon \to X \qquad q_1 \to q_2 \text{ freely} \qquad q_2: \; b, X \to \varepsilon \]
List the states
Why: One for the pushing phase, one for the popping phase, and one accepting state reached after the marker check.
\[ Q = \{q_1, q_2, q_3\} \]
List the two alphabets
Why: The input alphabet holds the two letters; the stack alphabet holds the counting marker and the bottom marker.
\[ \Sigma = \{a,b\}, \qquad \Gamma = \{X, Z\} \]
Write the transition entries
Why: Four entries: push on a, switch phase freely, pop on b, and check the bottom marker freely.
\[ \delta(q_1,a,\varepsilon) = \{(q_1, X)\}, \quad \delta(q_2,b,X) = \{(q_2,\varepsilon)\} \]
Name the start state, initial stack symbol and accepting set
Why: Start in the pushing phase with the bottom marker on the stack; accept in the third state.
\[ q_0 = q_1, \quad Z_0 = Z, \quad F = \{q_3\} \]
Verify the tuple reproduces the traced computation
Why: Running the tuple on the four-symbol string gives the same four configurations traced in Section 2, ending in the accepting state with only the bottom marker present. Nothing was lost in the formalization.
\[ aabb \in L(P) \ \checkmark \]
Picture it
Animation
Shows: Each line of the worked example "Write the seven-tuple for a machine", appearing one at a time.
The same working the example does, in the order a tutor would write it.
Takeaway: Running the tuple on the four-symbol string gives the same four configurations traced in Section 2, ending in the accepting state with only the bottom marker present. Nothing was lost in the formalization.
Concept
Some texts drop the initial stack symbol and start with an empty stack. Both conventions are in wide use and neither is more powerful.
| Convention | Components | Emptiness test |
|---|---|---|
| seven-tuple | includes an initial stack symbol | test for that symbol |
| six-tuple | starts with an empty stack | push your own marker first |
Converting between them is one transition: a six-tuple machine gains a first move pushing a marker, and a seven-tuple machine can ignore its initial symbol. This deck uses the seven-tuple, and flags where the choice matters.
\[ \varepsilon, \varepsilon \to Z_0 \quad\text{— the bridging move} \]
Prediction
Predict first
Why does the transition function of a pushdown automaton return a string to push rather than a single symbol?
Answer it in your own words, now, with nothing to choose from. The options are on the next slide — and picking the right one off a list is an easier skill than producing it.
Correct: So one move can push several symbols, matching a grammar rule with a long right-hand side
Why: Lesson 17 builds a machine from a grammar by pushing a rule's entire right-hand side in one move. Allowing a string keeps that construction to one transition per rule rather than a chain of them.
Check
Look at what the transition function returns.
Check your understanding
Why does the transition function of a pushdown automaton return a string to push rather than a single symbol?
Answer: A
Why: Lesson 17 builds a machine from a grammar by pushing a rule's entire right-hand side in one move. Allowing a string keeps that construction to one transition per rule rather than a chain of them.
Concept
configuration — A snapshot of the whole machine: its current state, the input still to be read, and the entire stack contents.
\[ (q, \; w, \; \gamma) \]
The stack is written top-first by convention, so the leftmost symbol is the one a pop would remove. Getting this orientation backwards is the commonest source of confusion in traces.
A configuration is to these machines what a state was to finite automata: everything the machine knows. The difference is that there are now infinitely many possible configurations.
Worked example
Apply a transition formally, as a relation on configurations.
\[ (q, \; aw, \; X\gamma) \;\vdash\; (p, \; w, \; \beta\gamma) \]
Read the left side
Why: The machine is in some state, the next input symbol is a, and the top of the stack is X with the rest below.
Find an applicable transition
Why: A move is applicable when its input component matches the next symbol or is empty, and its pop component matches the top symbol or is empty.
Apply it
Why: The state changes, the matched input symbol is consumed, the popped symbol is removed, and the pushed string takes its place — leaving everything below untouched.
Note what is unchanged
Why: The part of the stack below the popped symbol is carried through verbatim. That is the formal statement of 'only the top is visible'.
Verify on a concrete step
Why: From the pushing state with input aabb and stack Z, the push transition consumes one a and puts X above Z, giving the state with input abb and stack XZ. The tail Z was carried through untouched, exactly as the relation describes.
\[ (q_1, aabb, Z) \vdash (q_1, abb, XZ) \ \checkmark \]
Picture it
Animation
Shows: Each line of the worked example "Step between configurations", appearing one at a time.
The same working the example does, in the order a tutor would write it.
Takeaway: From the pushing state with input aabb and stack Z, the push transition consumes one a and puts X above Z, giving the state with input abb and stack XZ. The tail Z was carried through untouched, exactly as the relation describes.
Concept
Chain single steps to get whole computations, using the reflexive transitive closure exactly as in Lesson 13.
\[ (q_0, \; w, \; Z_0) \;\vdash^{*}\; (q, \; \varepsilon, \; \gamma) \]
A computation is accepting when it consumes the whole input and finishes in a configuration the acceptance convention approves of. The two conventions are the subject of the next section.
Because the machine is nondeterministic, a single input generally has many computations. Only one need be accepting.
Section
Section 4
Concept
The first convention is the familiar one: consume the input and finish in a state belonging to the accepting set.
\[ w \in L(P) \iff (q_0, w, Z_0) \vdash^{*} (q, \varepsilon, \gamma) \text{ for some } q \in F \]
The stack contents at the end are irrelevant under this convention. Whatever is left over is simply ignored.
This matches the finite-automaton convention and is what the seven-tuple's accepting set is for.
Concept
The second convention ignores the state instead: consume the whole input and finish with nothing on the stack.
\[ w \in N(P) \iff (q_0, w, Z_0) \vdash^{*} (q, \varepsilon, \varepsilon) \]
Under this convention the accepting set plays no role at all, and machines are often written as six-tuples with it omitted.
The two conventions recognize exactly the same class of languages, but a given machine usually accepts different languages under each.
Estimation
Predict first
Show the conventions are interchangeable, which is why textbooks may pick either.
Commit before you compute: what does Convert between the two conventions come out to? A rough magnitude and the right form is enough — the point is to have something concrete to be wrong about.
Correct: Verify both directions preserve the language
Why: A prediction you can defend turns the computation into a check rather than a leap of faith — and an answer that contradicts it is caught on the spot. In the first, an accepting computation ends exactly when the original emptied its stack; in the second, exactly when the original reached an accepting state.
Worked example
Show the conventions are interchangeable, which is why textbooks may pick either.
From empty stack to final state
Why: Push a fresh bottom marker below everything, using a new start state. Then a free move that pops the marker enters a new accepting state.
\[ \varepsilon, Z_{\text{new}} \to \varepsilon \;\text{ into the accepting state} \]
See why the fresh marker is needed
Why: Without it, the machine could not tell an empty stack from one still holding symbols, since emptiness cannot be tested directly.
From final state to empty stack
Why: Add a draining state reachable freely from every accepting state, which pops any symbol and consumes no input until the stack is bare.
\[ \varepsilon, X \to \varepsilon \;\text{ for every } X \in \Gamma \]
See why a fresh bottom marker is needed here too
Why: Without one, the draining state could empty the stack from a non-accepting configuration and wrongly accept. The marker ensures only the intended computations reach an empty stack.
Verify both directions preserve the language
Why: In the first, an accepting computation ends exactly when the original emptied its stack; in the second, exactly when the original reached an accepting state. Neither adds nor removes strings, so the two conventions define the same class.
\[ \{L(P)\} = \{N(P')\} \ \checkmark \]
Picture it
Animation
Shows: Each line of the worked example "Convert between the two conventions", appearing one at a time.
The same working the example does, in the order a tutor would write it.
Takeaway: In the first, an accepting computation ends exactly when the original emptied its stack; in the second, exactly when the original reached an accepting state. Neither adds nor removes strings, so the two conventions define the same class.
Anomaly
Predict first
A student writes this, and it looks reasonable:
A machine accepts the matched counts by final state. What does it accept by empty stack?
It is wrong. Say what breaks — and say it before you turn the page.
Correct: The two conventions define the same class of languages, so the same machine must accept the same language under either.
A machine accepts the matched counts by final state. What does it accept by empty stack?
Why: The two conventions define the same class of languages, so the same machine must accept the same language under either.
Trap
A machine accepts the matched counts by final state. What does it accept by empty stack?
Assume the conventions agree
Why: The two conventions define the same class of languages, so the same machine must accept the same language under either.
\[ L(P) \overset{?}{=} N(P) \]
Test the assumption
Why: The machine leaves its bottom marker on the stack when it accepts, so its stack is never empty. Under the empty-stack convention it accepts nothing at all.
\[ N(P) = \varnothing \]
A machine accepts the matched counts by final state. What does it accept by empty stack?
Distinguish the class from the machine
Why: The conventions define the same class of languages: for every machine under one convention there is some machine under the other. That is a statement about existence, not about the same machine.
\[ \{L(P) : P\} = \{N(P) : P\} \]
Convert explicitly if the same language is wanted
Why: Apply the construction from the previous slides, which builds a different machine accepting the same language under the other convention.
\[ L(P) = N(P') \;\text{ for the constructed } P' \ \checkmark \]
Two truths and a lie
Sort into buckets
Some of these hold up and some are the exact mistakes this lesson is built to prevent. Sort them.
Ranking
Put in order
Put the moves of Trace an accepting and a rejecting computation into the order they have to happen.
Why: These are the moves of the worked example in the order it makes them, and each one is set up by the one before it. Push each symbol read; at some point guess the midpoint and switch phases freely; then pop, requiring each input symbol to match the symbol popped.
Worked example
Run the palindrome machine on two inputs, to see nondeterminism at work.
\[ \text{push phase} \;\to\; \text{free switch} \;\to\; \text{match phase} \]
Describe the machine
Why: Push each symbol read; at some point guess the midpoint and switch phases freely; then pop, requiring each input symbol to match the symbol popped.
Trace an accepting branch on abba
Why: Push a and b, switch after two symbols, then pop b against b and a against a. The stack returns to the marker with the input exhausted.
\[ (q_1, abba, Z) \vdash^{*} (q_2, ba, baZ) \vdash^{*} (q_2, \varepsilon, Z) \]
Note the branches that fail
Why: Switching after one symbol or three symbols leads to a mismatch, and those branches die. Acceptance needs only the one branch that guessed correctly.
Trace the rejecting input abab
Why: Every possible midpoint guess leads to a mismatch, since the string does not read the same backwards.
Verify the verdicts
Why: The first input has an accepting computation and is accepted; the second has none, since every guess fails, and is rejected. Both match the palindrome condition, and the machine needed nondeterminism to find the midpoint.
\[ abba \in L \qquad abab \notin L \ \checkmark \]
Picture it
Animation
Shows: Each line of the worked example "Trace an accepting and a rejecting computation", appearing one at a time.
The same working the example does, in the order a tutor would write it.
Takeaway: The first input has an accepting computation and is accepted; the second has none, since every guess fails, and is rejected. Both match the palindrome condition, and the machine needed nondeterminism to find the midpoint.
Constraint
Discussion prompt
Run Tracing a computation reliably with this step confiscated:
Consume exactly one input symbol per step, or none for a free move.
Is it still possible? If it is, say what takes its place and what it costs you. If it is not, say exactly what that step was providing that nothing else does.
Hint: A step you can drop for free was never load-bearing. If you cannot drop it, name the thing that goes wrong the moment it is gone.
Answer:
Pattern
Configurations have three components and it is easy to lose track of one.
The fourth habit is worth the extra writing. Most trace errors are a symbol silently dropped from the middle of the stack.
Edge cases
Discussion prompt
Tracing a computation reliably works on the cases you have just seen. Push it to the edge: what is the most degenerate input it still handles — empty, zero, one item, everything equal — and what is the first case where it stops being true? Name the case, not just "it breaks".
Hint: Try the smallest legal input, then the largest, then the one where two things collide. Methods are specified at their edges; the middle takes care of itself.
Answer:
Configurations have three components and it is easy to lose track of one.
Commit first
Predict first
Under the final-state convention, what must be true of the stack when a string is accepted?
Commit to an answer, then rate it — certain, fairly sure, or guessing — and write the rating down before you turn the page.
Correct: Nothing — the stack contents are ignored
Why: The final-state convention examines only the state reached after the input is exhausted. Whatever remains on the stack plays no part in the decision, which is exactly what distinguishes it from the empty-stack convention.
The rating matters as much as the answer: confident-and-wrong is the combination that survives revision, because nothing about it feels like it needs revisiting.
Check
Recall what each convention examines at the end.
Check your understanding
Under the final-state convention, what must be true of the stack when a string is accepted?
Answer: A
Why: The final-state convention examines only the state reached after the input is exhausted. Whatever remains on the stack plays no part in the decision, which is exactly what distinguishes it from the empty-stack convention.
Section
Section 5
Pattern
Designing a stack machine is answering two questions rather than one.
The second question is the new one. Finite-automaton design had a single phase; almost every stack machine has at least two, and the boundary between them is guessed.
Hypothesis
Predict first
Design: matched counts is about to be worked. State your hypothesis first: which rule or definition decides this one, and what is the first move it forces? Then watch whether the example agrees with you.
Correct: Answer the storage question
Why: Store one marker per a. They come back in reverse order, which is fine because all markers are identical.
A hypothesis you wrote down is falsifiable; a vague sense of how it will go is not. If the example opens somewhere else, that gap is the thing worth chasing.
Worked example
The canonical design, built by the recipe.
\[ L = \{\, a^{n}b^{n} : n \ge 0 \,\} \]
Answer the storage question
Why: Store one marker per a. They come back in reverse order, which is fine because all markers are identical.
Answer the phase question
Why: Two phases: pushing while reading a's, popping while reading b's. The switch happens exactly once, at the boundary.
Write the transitions
Why: Push on a in the first phase, switch freely, pop on b in the second, and check the marker at the end.
\[ a,\varepsilon \to X; \quad \varepsilon,\varepsilon \to \varepsilon; \quad b,X \to \varepsilon; \quad \varepsilon,Z \to \varepsilon \]
Check the empty string
Why: Switching phases immediately and testing the marker accepts the empty string, which has zero of each and belongs to the language.
Verify on three strings
Why: The empty string and aabb are accepted; aab leaves a marker unpopped and abb runs out of markers, so both are rejected. All three match the language.
\[ \varepsilon,\ aabb \in L \qquad aab,\ abb \notin L \ \checkmark \]
Picture it
Animation
Shows: Each line of the worked example "Design: matched counts", appearing one at a time.
The same working the example does, in the order a tutor would write it.
Takeaway: Switching phases immediately and testing the marker accepts the empty string, which has zero of each and belongs to the language.
Step zero
Discussion prompt
Design: palindromes over two symbols — before any calculation: what is the plan? Name the moves in order, in plain English, without doing the arithmetic.
Hint: It starts with: Answer the storage question
Answer:
Worked example
Here the stored symbols matter, not just their count.
\[ L = \{\, w : w = w^{R} \,\} \]
Answer the storage question
Why: Store each symbol read, so the first half can be compared against the second. Reversal is automatic.
Answer the phase question
Why: The midpoint is not marked in the input, so it must be guessed with a free move — which is why nondeterminism is essential here.
Handle both parities
Why: Even-length palindromes switch phases directly; odd-length ones must additionally consume the single middle symbol without pushing it.
\[ \varepsilon,\varepsilon \to \varepsilon \quad\text{and}\quad a,\varepsilon \to \varepsilon \;\text{ at the switch} \]
Write the matching phase
Why: For each symbol, a transition requiring the same symbol on top and popping it.
\[ a,a \to \varepsilon; \quad b,b \to \varepsilon \]
Verify on both parities and a non-member
Why: The even palindrome abba is accepted by guessing the midpoint after two symbols; the odd palindrome aba is accepted by consuming the middle b at the switch. The string ab has no successful guess, so it is rejected.
\[ abba,\ aba,\ \varepsilon \in L \qquad ab \notin L \ \checkmark \]
Picture it
Animation
Shows: Each line of the worked example "Design: palindromes over two symbols", appearing one at a time.
The same working the example does, in the order a tutor would write it.
Takeaway: The even palindrome abba is accepted by guessing the midpoint after two symbols; the odd palindrome aba is accepted by consuming the middle b at the switch. The string ab has no successful guess, so it is rejected.
Missing information
Discussion prompt
Now the stack symbols must record which bracket is owed.
What do you need to know — or decide — before the first line can be written? List everything the problem has to hand you.
Hint: Anything you would have to invent to get started is a thing the problem must supply.
Answer:
One symbol per bracket kind, so a pop can check that the closing bracket matches the opening it is closing.
Worked example
Now the stack symbols must record which bracket is owed.
\[ L = \text{properly nested strings over two bracket kinds} \]
Choose the stack alphabet
Why: One symbol per bracket kind, so a pop can check that the closing bracket matches the opening it is closing.
\[ \Gamma = \{X_{(}, X_{[}, Z\} \]
Push on every opening bracket
Why: The symbol pushed records which kind was opened.
Pop on every closing bracket, requiring a match
Why: A round closing bracket pops only the round marker, and likewise for square. A mismatch has no applicable transition, so that branch dies.
\[ ) , X_{(} \to \varepsilon; \quad ] , X_{[} \to \varepsilon \]
Note that only one phase is needed
Why: Unlike the previous designs, pushing and popping interleave freely, so no phase change and no guessing are required. This machine is deterministic.
Verify on a nested, an interleaved and a mismatched string
Why: The nested string with a square pair inside a round pair is accepted, and so is the sequence of two separate pairs. The string closing a round bracket with a square one has no applicable transition and is rejected.
\[ ([]) ,\ ()[] \in L \qquad (] \notin L \ \checkmark \]
Picture it
Animation
Shows: Each line of the worked example "Design: balanced brackets of two kinds", appearing one at a time.
The same working the example does, in the order a tutor would write it.
Takeaway: The nested string with a square pair inside a round pair is accepted, and so is the sequence of two separate pairs. The string closing a round bracket with a square one has no applicable transition and is rejected.
Intuition
Three designs, and only two of them needed to guess. The difference is worth naming.
| Language | Guess needed? | Why |
|---|---|---|
| balanced brackets | no | each symbol says whether to push or pop |
| matched counts | no, in practice | the first b marks the switch |
| palindromes | yes | the midpoint is invisible in the input |
| a union of two languages | yes | which branch to take is not determined |
The rule of thumb: guessing is needed when the input contains no marker for a decision the machine must make. That is exactly the situation Section 6 shows a deterministic machine cannot handle.
Trade off
Comparison matrix
From Where nondeterminism is genuinely needed: every row here is a choice with a cost. Fill the Why column, then say which row you would actually pick and what you give up for it.
| Language | Guess needed? | Why |
|---|---|---|
| balanced brackets | no | each symbol says whether to push or pop |
| matched counts | no, in practice | the first b marks the switch |
| palindromes | yes | the midpoint is invisible in the input |
| a union of two languages | yes | which branch to take is not determined |
Estimation
Predict first
A counting condition that is an inequality rather than an equality.
Commit before you compute: what does Design: more a's than b's come out to? A rough magnitude and the right form is enough — the point is to have something concrete to be wrong about.
Correct: Verify on three strings
Why: A prediction you can defend turns the computation into a check rather than a leap of faith — and an answer that contradicts it is caught on the spot. The string a has one surplus a and is accepted; aab has one surplus and is accepted; ab cancels to nothing and is rejected, as is the empty string.
Worked example
A counting condition that is an inequality rather than an equality.
\[ L = \{\, w \in \{a,b\}^{*} : \#_a(w) > \#_b(w) \,\} \]
Decide what to store
Why: Store the running excess. Push a marker for each unmatched a, and pop one for each b that cancels an a.
Handle a b with no a to cancel
Why: The excess can go negative, so push a second kind of marker recording surplus b's. The stack then holds markers of one kind only, whichever is currently in surplus.
\[ \Gamma = \{A, B, Z\} \]
Write the cancelling transitions
Why: Reading an a pops a surplus-b marker if one is on top, and otherwise pushes a surplus-a marker. Reading a b does the mirror image.
Choose the acceptance condition
Why: Accept when the input is exhausted and at least one surplus-a marker is on top, which means the a's strictly outnumber the b's.
\[ \varepsilon, A \to A \;\text{ into the accepting state} \]
Verify on three strings
Why: The string a has one surplus a and is accepted; aab has one surplus and is accepted; ab cancels to nothing and is rejected, as is the empty string. All four match the strict inequality.
\[ a,\ aab \in L \qquad ab,\ \varepsilon \notin L \ \checkmark \]
Picture it
Animation
Shows: Each line of the worked example "Design: more a's than b's", appearing one at a time.
The same working the example does, in the order a tutor would write it.
Takeaway: The string a has one surplus a and is accepted; aab has one surplus and is accepted; ab cancels to nothing and is rejected, as is the empty string. All four match the strict inequality.
Prediction
Predict first
Why does the palindrome machine need nondeterminism while the bracket machine does not?
Answer it in your own words, now, with nothing to choose from. The options are on the next slide — and picking the right one off a list is an easier skill than producing it.
Correct: The midpoint is not marked in the input, so it must be guessed
Why: The bracket machine decides what to do from the current input symbol alone — opening means push, closing means pop. The palindrome machine must switch from pushing to matching at a point the input does not indicate, so it guesses and relies on one branch succeeding.
Check
Think about what a stack returns and in what order.
Check your understanding
Why does the palindrome machine need nondeterminism while the bracket machine does not?
Answer: A
Why: The bracket machine decides what to do from the current input symbol alone — opening means push, closing means pop. The palindrome machine must switch from pushing to matching at a point the input does not indicate, so it guesses and relies on one branch succeeding.
Section
Section 6
Concept
A machine is deterministic when no configuration ever offers a choice — and with free moves in play that takes two conditions, not one.
The second condition is the one that is easy to overlook. A free move competing with a reading move is a genuine choice, even though only one of them consumes input.
\[ \delta(q,\varepsilon,X) \neq \varnothing \;\Rightarrow\; \delta(q,a,X) = \varnothing \text{ for every } a \]
Concept
For finite automata, Lesson 6 proved nondeterminism added nothing. Here that fails, and the failure is one of the most important facts in the chapter.
The deterministic machines recognize a strictly smaller class. Some context-free languages have no deterministic machine at all.
\[ \text{DPDA languages} \;\subsetneq\; \text{context-free languages} \]
So the subset-construction trick of Lesson 6 must fail here — and seeing why it fails is more instructive than the statement itself.
Intuition
Lesson 6 determinized a finite automaton by making each set of possible states a single state. That worked because there were finitely many such sets.
Here the machine's situation is a state and a stack, and there are infinitely many possible stacks. So the set of possible situations is infinite, and it cannot be packed into a finite state set.
\[ \text{situations} = Q \times \Gamma^{*} \;: \text{ infinite} \]
Worse, the branches may have different stacks, and one stack cannot simulate several at once. That is the structural obstacle, and no cleverer construction gets around it.
Explain it
Discussion prompt
Explain Why the subset construction fails to a student a year behind you. No notation, no jargon they have not met — and it still has to be true.
Hint: If your explanation needs a symbol they have never seen, you are describing the notation rather than the idea.
Answer:
Lesson 6 determinized a finite automaton by making each set of possible states a single state. That worked because there were finitely many such sets.
Step zero
Discussion prompt
A language with no deterministic machine — before any calculation: what is the plan? Name the moves in order, in plain English, without doing the arithmetic.
Hint: It starts with: Check the language is context-free
Answer:
Worked example
The standard witness, and the argument for why determinism fails on it.
\[ L = \{\, a^{n}b^{n} \,\} \;\cup\; \{\, a^{n}b^{2n} \,\} \]
Check the language is context-free
Why: Each half has an easy grammar, and the union is context-free by combining them with a fresh start variable, as Lesson 13 showed.
See what a machine must do
Why: It reads a block of a's and pushes markers. Then the b's arrive, and it must pop one marker per b, or one per two b's — depending on which half the string belongs to.
Notice the decision cannot be deferred
Why: The rate of popping must be chosen when the first b is read, but which rate is correct is determined only by how many b's eventually arrive.
\[ \text{decide at the first } b \;\text{, learn the answer at the last} \]
See how nondeterminism handles it
Why: A nondeterministic machine guesses the rate at the switch and runs both branches. One of them is correct, and acceptance needs only that one.
Verify the deterministic obstruction is real
Why: A deterministic machine has exactly one computation, so it must commit to one rate with no information distinguishing the cases. Whichever it picks, strings of the other half are rejected — so no single deterministic machine accepts both halves.
\[ \text{one computation} \;+\; \text{two possible rates} \;\Rightarrow\; \text{failure} \ \checkmark \]
Picture it
Animation
Shows: Each line of the worked example "A language with no deterministic machine", appearing one at a time.
The same working the example does, in the order a tutor would write it.
Takeaway: Each half has an easy grammar, and the union is context-free by combining them with a fresh start variable, as Lesson 13 showed.
Concept
One closure property separates the deterministic subclass sharply from the full class, and it is proved much as in Lesson 4.
A deterministic machine has exactly one computation per input, so swapping accepting and non-accepting states negates every verdict — provided the machine always finishes reading the input.
\[ \text{one computation} \;\Rightarrow\; \text{swapping } F \text{ negates the answer} \]
Two technical repairs are needed first: the machine must not get stuck, and it must not loop forever on free moves. Both are fixable by adding a dead state and bounding the free-move chains.
The general context-free languages have no such property, as Lesson 19 shows — which makes this closure a genuine mark of the deterministic subclass rather than a convenience.
Analogy
Discussion prompt
Explain Deterministic languages are closed under complement by analogy to something with no Theory of Computation in it at all — a queue, a recipe, a map, a bank balance, whatever fits. Then say where your analogy breaks.
Hint: An analogy that never breaks is not an analogy, it is the same idea wearing a hat. Find the seam — that is the part that is actually new.
Answer:
One closure property separates the deterministic subclass sharply from the full class, and it is proved much as in Lesson 4.
Ranking
Put in order
Put the moves of Use complement closure to separate the classes into the order they have to happen.
Why: These are the moves of the worked example in the order it makes them, and each one is set up by the one before it. Lesson 19 exhibits one: the complement of the strings consisting of a block written twice.
Worked example
A short argument showing the deterministic subclass is strictly smaller, using closure rather than a direct construction.
Take a context-free language whose complement is not context-free
Why: Lesson 19 exhibits one: the complement of the strings consisting of a block written twice.
Suppose it had a deterministic machine
Why: Then by the closure property just proved, its complement would also have one.
Derive the contradiction
Why: A language with a deterministic machine is certainly context-free, so the complement would be context-free — contradicting the choice of language.
\[ L \text{ deterministic} \;\Rightarrow\; \overline{L} \text{ context-free} \]
Conclude
Why: The language is context-free but has no deterministic machine, so the deterministic subclass is strictly smaller.
Verify the argument needs no explicit machine analysis
Why: Unlike the earlier witness, this argument never inspects a machine's behaviour — it runs entirely on closure properties. Both routes reach the same conclusion, and this one generalizes to any language whose complement escapes the class.
\[ \text{deterministic} \;\subsetneq\; \text{context-free} \ \checkmark \]
Picture it
Animation
Shows: Each line of the worked example "Use complement closure to separate the classes", appearing one at a time.
The same working the example does, in the order a tutor would write it.
Takeaway: Unlike the earlier witness, this argument never inspects a machine's behaviour — it runs entirely on closure properties. Both routes reach the same conclusion, and this one generalizes to any language whose complement escapes the class.
Concept
Deterministic machines are weaker, and they are also far more useful in practice. Both facts matter.
| Property | Deterministic | Nondeterministic |
|---|---|---|
| languages recognized | a strict subclass | all context-free |
| closed under complement | yes | no |
| parsing time | linear | cubic |
| used by real parsers | yes | rarely |
The complement row is the one to remember. Deterministic machines can be complemented by swapping accepting states, much as in Lesson 4 — and Lesson 19 shows the general context-free languages cannot.
Discrimination
Sort into buckets
Sort these by Deterministic, from memory, without looking back at What determinism does buy. Telling them apart on the spot is the skill; the table is only where the answer happens to be written down.
Intuition
Three model families have now been compared for the effect of nondeterminism, and the answers are not uniform.
| Model | Nondeterminism adds power? | Established in |
|---|---|---|
| finite automata | no | Lesson 6 |
| pushdown automata | yes | this lesson |
| Turing machines | no | Lesson 22 |
So the finite-automaton result was not a general principle, and neither is this one. Each model must be checked separately — which is exactly why Lesson 31's question about polynomial time remains open.
Comparison
Comparison matrix
From This is the first place the two models diverge: refill the Nondeterminism adds power? column from what you know. The rest of the table is as it appeared.
| Model | Nondeterminism adds power? | Established in |
|---|---|---|
| finite automata | no | Lesson 6 |
| pushdown automata | yes | this lesson |
| Turing machines | no | Lesson 22 |
Elimination
Eliminate the wrong options
Why can the subset construction not be used to determinize a pushdown automaton?
3 of these 4 are wrong. Strike them one at a time, and say what rules each one out before you strike the next. The survivor is the answer.
Survives elimination: A
Why: The construction turned each set of possible states into one state, which needs the collection of such sets to be finite. Here a situation is a state together with a stack, and stacks are unbounded, so the collection is infinite and cannot be a finite state set.
Check
Think about why Lesson 6's construction does not transfer.
Check your understanding
Why can the subset construction not be used to determinize a pushdown automaton?
Answer: A
Why: The construction turned each set of possible states into one state, which needs the collection of such sets to be finite. Here a situation is a state together with a stack, and stacks are unbounded, so the collection is infinite and cannot be a finite state set.
Intuition
Practical parsing tools work only with deterministic languages, and they accept that limitation deliberately.
A deterministic machine parses in time linear in the input, with no backtracking and no ambiguity about which rule applied. A nondeterministic one needs a cubic-time table algorithm and may return several trees.
So language designers arrange for their syntax to be deterministic — adding keywords, delimiters and terminators precisely so that every decision is visible when it must be made. The dangling-else resolutions of Lesson 14 are exactly this discipline in practice.
\[ \text{linear parsing} \;\Longleftarrow\; \text{deterministic syntax, by design} \]
Counterexample
Discussion prompt
Practical parsing tools work only with deterministic languages, and they accept that limitation deliberately.
That is stated as though it always holds. Do one of two things: produce a case where it fails, or say precisely what rules such a case out. "It just does" is not on the menu.
Hint: Hunt at the extremes first — zero, one, negative, empty, equal. If every extreme survives, the reason they survive is the proof.
Ranking
Put in order
These are the steps of Choosing a machine or a grammar, scrambled. Put them back in order before the next slide shows you.
Why: This is the order the recipe itself gives. Recalling the sequence without the slide in front of you is the difference between recognising the method and being able to run it — most of what goes wrong in practice is a step done out of turn.
Pattern
Both describe this class, and Lesson 17 proves them equivalent. The choice is by task.
The fourth line is where practice lives. Real parsers are deterministic machines derived from grammars, and the restriction to deterministic languages is why some grammars must be rewritten before a parser generator will accept them.
Real world
Discussion prompt
Outside this lesson: where does Pushdown Automata actually turn up? Name one concrete situation — a job, a piece of software someone ships, a decision somebody has to make — and say which part of Choosing a machine or a grammar is doing the work in it.
Hint: Vague is the failure mode here. "Engineering" is not a situation; "deciding whether this build is fast enough to ship" is.
Answer:
Lesson 16 adds one unbounded stack to a finite automaton. It explains why a stack is exactly the right addition and what its last-in-first-out discipline still forbids, then covers transitions that read, pop, and push, with each part optional, and the bottom-marker trick for testing emptiness. It gives the formal seven-tuple and the six-tuple variant, configurations and the computation relation, and the final-state and empty-stack acceptance conventions with conversions in both directions. Designs follow for matched counts, palindromes, two kinds of bracket, and strict inequalities. It closes with the result that deterministic pushdown automata are strictly weaker, giving the standard witness language and explaining why the subset construction cannot be transferred.
Connect it up
Draw it
One page, no notation unless you need it: draw how these connect — Why a Stack · The Machine, Informally · The Formal Definition · Acceptance, Two Ways · Designing Machines · Deterministic Machines Are Weaker. Put an arrow wherever one of them is what makes another possible, and label the arrow with why.
Recap
You have the recognizer for the context-free languages, and you know the one place its behaviour differs from the finite-automaton story.
| Situation | Move |
|---|---|
| something must be matched in reverse | push it, then pop against the later part |
| a phase boundary not marked in the input | a free move, and rely on nondeterminism |
| the stack must be tested for emptiness | push a bottom marker and test for that |
| two possible behaviours, chosen too early | the language may have no deterministic machine |
| a count must be checked twice | a stack cannot — expect Lesson 18 to rule it out |
Lesson 17 proves these machines recognize exactly the languages the grammars of Lesson 13 generate, completing the pairing.
Want this taught 1-on-1? Alexander tutors Theory of Computation — $55/session, free consultation.