The Timpson Lyceum · Computation Theory

Lecture 10 (Computation Theory) Pushdown Automata, Non-Context-Free Languages, and Pumping Lemma 2.0

Pushdown Automata, Non-Context-Free Languages, and Pumping Lemma 2.0 – Lecture 10

Overview

This lecture completes the theory of pushdown automata (PDAs) and pivots to proving that some languages are not context-free. We pin down the formal six-tuple definition of a PDA and the precise acceptance condition, then build several example machines and write one out as an explicit transition table. We state (and sketch one direction of) the equivalence between PDAs and context-free grammars: a language is context-free if and only if some PDA recognizes it. Finally, we develop the pumping lemma for context-free languages, reasoning about parse-tree height in Chomsky normal form rather than about a machine's states. This pumping lemma is the central tool for proving a language has no context-free grammar.

Key Concepts

Pushdown automaton (PDA). A PDA is like a nondeterministic finite automaton augmented with a stack. On each transition it may read an input symbol, pop a symbol off the top of the stack, and push a string of symbols onto the stack — any of these "may" be the empty string. The stack gives the machine unbounded memory (organized last-in-first-out), which is exactly the extra power that lets it recognize context-free languages.

Formal definition. A PDA is a 6-tuple $(Q, \Sigma, \Gamma, \delta, q_0, F)$ where:

• $Q$ — finite set of states.
• $\Sigma$ — input alphabet (symbols read from the input).
• $\Gamma$ — stack alphabet (symbols stored on the stack; need not equal $\Sigma$). The marker \text{\}$ is conventionally pushed first to mark the bottom of the stack.
• $\delta : Q \times \Sigma_\varepsilon \times \Gamma_\varepsilon \to \mathcal{P}(Q \times \Gamma_\varepsilon)$ — the transition function. Given a state, an input symbol (or $\varepsilon$), and a popped stack symbol (or $\varepsilon$), it returns a set of (next state, pushed symbol) pairs. The power set $\mathcal{P}$ encodes nondeterminism — one configuration may lead to several choices. Here $\Sigma_\varepsilon = \Sigma \cup \{\varepsilon\}$ and $\Gamma_\varepsilon = \Gamma \cup \{\varepsilon\}$.
• $q_0 \in Q$ — start state.
• $F \subseteq Q$ — set of accept states (multiple allowed).

Acceptance. A PDA accepts $w = w_1 w_2 \cdots w_m$ (each $w_i \in \Sigma_\varepsilon$) if there exist a sequence of states $r_0, r_1, \ldots, r_m$ and a sequence of stack contents $s_0, s_1, \ldots, s_m \in \Gamma^*$ such that:

1. $r_0 = q_0$ and $s_0 = \varepsilon$ — start in the start state with an empty stack.
2. For each $i$, the move is legal: writing $s_i = a t$ and $s_{i+1} = b t$ (with $a, b \in \Gamma_\varepsilon$ and $t \in \Gamma^*$), we require $(r_{i+1}, b) \in \delta(r_i, w_{i+1}, a)$ — i.e. pop $a$, push $b$, leaving the rest $t$ untouched.
3. $r_m \in F$ — end in an accept state.

By convention these machines push \text{\}$ first and pop it last so the stack is empty at acceptance, but emptying the stack is a design habit, not a strict requirement of the definition.

Explicit transition tables. A PDA can be written as a table indexed by (current state) × (input symbol) × (popped stack symbol), with each cell holding the set of reachable (state, pushed symbol) pairs. Because the table is genuinely three-dimensional, most cells are the empty set and the layout is awkward — which is why machines are normally drawn as state diagrams instead of tabulated.

Example languages.

• $\{0^n 1^n\}$ — push a $0$ for each input $0$, nondeterministically guess the midpoint, then pop a $0$ for each input $1$; pop \text{\}$ to accept.
• $\{w w^{R}\}$ (a string followed by its reverse) — push each input symbol on the first half, guess the midpoint, then require each next symbol to match (pop) the top of the stack.
• Complements such as the complement of $\{w w^{R}\}$ — handled by splitting odd-length strings into a stack-free path and forcing at least one mismatch on the even path.
• $\{a^i b^j c^k : i = j \text{ or } i = k\}$ — count the $a$'s on the stack, then nondeterministically choose to match them against the $b$'s or against the $c$'s.

Two stacks = a Turing machine. A single stack cannot recognize $\{ww\}$. Adding a second stack jumps to full Turing-machine power; beyond two stacks, more stacks add nothing.

Equivalence of PDAs and CFGs. A language is context-free if and only if some PDA recognizes it. The grammar-to-PDA direction is constructive: build a PDA that keeps the current sentential form on its stack.

• Push S\text{\}$ (start variable over bottom marker).
• For each grammar rule $A \to w$, add $\varepsilon$-moves that pop $A$ and push the symbols of $w$ (in reverse, so the leftmost ends up on top).
• For each terminal $a$, add a move that reads $a$ and pops $a$.
• When only \text{\}$ remains, pop it and accept.

The reverse direction (PDA-to-grammar) is also true but its proof is long (two nested inductions), so it is taken on faith here.

Chomsky normal form (CNF). Every CFL has a grammar where every rule is $A \to BC$ (two variables) or $A \to a$ (one terminal); only the start variable may derive $\varepsilon$, and nothing derives the start variable. In CNF the binary-branching parse tree forces a height bound: a string of length $n$ has a parse tree of height at least $h \ge \lceil \log_2 n \rceil + 1.$ The height also equals the longest chain of variables from root to a terminal.

Repeating variables drive pumping. If a root-to-leaf path is long enough, some variable $R$ must repeat. The subtree at the higher occurrence $R^*$ can be replaced by the subtree at the lower $R$ (or vice versa), growing or shrinking the derivation while keeping it valid. This is the context-free analogue of "taking a loop."

Pumping lemma for context-free languages. If $A$ is context-free, there is a pumping length $p$ such that every $s \in A$ with $|s| \ge p$ can be written $s = uvxyz$ with:

1. $|vy| \ge 1$ (the pumped parts are nonempty),
2. $|vxy| \le p$ (the pumped region is bounded),
3. $uv^{n}xy^{n}z \in A$ for every $n \ge 0$.

The constant is $p = 2^{|V|}$ where $|V|$ is the number of variables. A string of length $\ge p$ forces a parse tree of height $> |V|$, hence a repeated variable, hence a split $uvxyz$ that can be pumped. The bound $|vxy| \le p$ comes from the lowest repeating variable: the subtree below $R^*$ has height $\le |V| + 1$, so it yields at most $2^{|V|} = p$ symbols.

Using it to prove non-context-freeness (contrapositive). A language $A$ is not context-free if: for every $p$, there is a string $s \in A$ with $|s| \ge p$ such that for every split $s = uvxyz$ with $|vy| \ge 1$ and $|vxy| \le p$, there is some $n$ with $uv^{n}xy^{n}z \notin A$. This is the tool used (next time) to show $\{0^n 1^n 0^n\}$ is not context-free.

Worked Example

Goal. Confirm the pumping length / parse-tree-height relationship that underlies the lemma, and read off a sample pumping decomposition.

For a grammar in Chomsky normal form, a derived string of length $n$ has a parse tree whose height satisfies $h \ge \lceil \log_2 n \rceil + 1$. With $|V|$ variables, set the pumping length $p = 2^{|V|}$; any string of length $\ge p$ then forces $h > |V|$, so a variable repeats along some root-to-leaf path.

Take a grammar with $|V| = 3$ variables (so $p = 2^3 = 8$) and a string of length $n = 8$:

Because a variable $R$ repeats, label the lower occurrence $R$ and the higher $R^*$ and split the string as $s = uvxyz$, where $u,z$ descend from the root but not from $R^*$; $v,y$ descend from $R^*$ but not from $R$; and $x$ descends from $R$. CNF guarantees $R^*$ contributes a symbol outside $R$'s subtree, so $|vy| \ge 1$; and the subtree under $R^*$ has height $\le |V|+1$, so $|vxy| \le 2^{|V|} = p$. Replacing $R$'s subtree by $R^*$'s repeatedly (or collapsing it) pumps the string:

where $n = 0$ corresponds to collapsing $R^*$ down to $R$ (deleting one copy of $v$ and $y$).

Summary

• A PDA is the 6-tuple $(Q,\Sigma,\Gamma,\delta,q_0,F)$: an NFA plus a stack, with nondeterministic transitions valued in $\mathcal{P}(Q \times \Gamma_\varepsilon)$.
• Acceptance requires a run from $q_0$ with an empty stack to an accept state, each step popping/pushing consistently with $\delta$.
• PDAs and context-free grammars are equivalent; the grammar-to-PDA construction keeps the sentential form on the stack (push S\text{\}$, expand variables via$\varepsilon$-moves, match terminals, pop$\text{$}$ to accept).
• A single stack cannot recognize $\{ww\}$; two stacks already give full Turing-machine power.
• In Chomsky normal form, a length-$n$ string forces parse-tree height $\ge \lceil \log_2 n \rceil + 1$, so a string of length $\ge p = 2^{|V|}$ forces a repeated variable.
• The CFL pumping lemma ($s = uvxyz$ with $|vy| \ge 1$, $|vxy| \le p$, $uv^n x y^n z \in A$) and its contrapositive are the standard tools for proving a language is not context-free.