The Timpson Lyceum · Computation Theory

Lecture 8 (Computation Theory) Pumping Lemma, Right Linear Grammars, and Context-Free Grammars

Overview

This lecture closes out the theory of regular languages and opens the study of grammars. It begins by reviewing the pumping lemma — the standard tool for proving that a language is not regular — restating the pumping property and the contradiction argument behind it. It then introduces right linear grammars, a rule-based way of generating strings that turns out to be logically equivalent to DFAs, NFAs, and regular expressions. Along the way it fixes the vocabulary of grammars (variables, terminals, rules, yields, derives, language of a grammar) and surveys which yes/no questions about regular languages are decidable. Finally it moves up one level to context-free grammars (CFGs), introducing parse trees, ambiguity, and why precedence-preserving grammars matter for compilers.

Key Concepts

Regular language. A language $A$ is regular if some DFA recognizes it. DFAs, NFAs, and regular expressions are all logically equivalent, so any of them can describe exactly the regular languages.

The pumping lemma (pumping property). Every regular language has the pumping property, so contrapositively, lacking it proves non-regularity. Formally: for every regular language $A$ there is a number $p$ (the pumping length, typically the number of states in a recognizing DFA) such that every string $s \in A$ with $|s| \ge p$ can be split as $s = xyz$ with

$|xy| \le p$ ,
$|y| \ge 1$ , and
$xy^{i}z \in A$ for every $i \ge 0$ .

The intuition: a DFA with $p$ states reading a string of length $\ge p$ must revisit a state, so the string contains a loop. The looped portion $y$ can be repeated ("pumped up") or removed ("pumped down") any number of times and the result still lands in an accept state.

Negation (how it is used). To show $A$ is not regular, show the property fails: for any $p$ an adversary names, you can exhibit a string of length $> p$ such that for every legal split ( $|xy| \le p$ , $|y| \ge 1$ ) there is some $i$ with $xy^{i}z \notin A$ .

Right linear grammar (a regular grammar). A 4-tuple $G = (V, \Sigma, R, S)$ where $V$ is a finite set of variables (capital letters), $\Sigma$ is a finite set of terminals (everything else), $V \cap \Sigma = \varnothing$ , $R$ is a finite set of rules, and $S \in V$ is the start variable. Every rule has one of three forms:

$A \to bC$ (terminal then variable),
$A \to b$ (single terminal), or
$A \to \varepsilon$ (empty string),

with $A, C \in V$ and $b \in \Sigma$ . The variable always sits at the right end of the string, so generation proceeds left to right. A left linear grammar simply puts the variable on the left; both are regular grammars and are logically equivalent. Right linear grammars are logically equivalent to DFAs/NFAs: the rules mirror a DFA's transitions ( $R$ plays the role of $\delta$ ) and $A \to \varepsilon$ marks accept states.

Grammar vocabulary (all grammars). For strings $u, v, w$ of terminals and variables:

Yields ( $\Rightarrow$ ): if $A \to w$ is a rule, then $uAv \Rightarrow uwv$ — one rule application.
Derives ( $\stackrel{*}{\Rightarrow}$ ): $u \stackrel{*}{\Rightarrow} v$ if $u = v$ or there is a finite chain $u \Rightarrow u_1 \Rightarrow u_2 \Rightarrow \cdots \Rightarrow v$ — any number of yields.
Language of a grammar: $L(G) = \{\, w \in \Sigma^{*} \mid S \stackrel{*}{\Rightarrow} w \,\}$ — the terminal-only strings derivable from the start variable.

Decidable questions about regular languages. All of the following can always be answered yes/no for DFAs/NFAs/regex/linear grammars (in contrast to Turing machines, where they become undecidable):

Membership: does a machine accept string $w$ ? (Simulate it.)
Equivalence: do two machines accept the same language? Check $A - B = \varnothing$ and $B - A = \varnothing$ . Since regular languages are closed under intersection and complement, $A - B = A \cap \overline{B}$ is regular; build its DFA and check whether its minimal form is the single-state machine with no accept state (recognizes $\varnothing$ ).
Infiniteness: is the language infinite? Convert to a regular expression — it is infinite iff a Kleene star appears (equivalently, the machine has a loop on a path to an accept state).
Subset: is $L(A) \subseteq L(B)$ ? Check $A - B = \varnothing$ .

Context-free grammar (CFG). Same 4-tuple $G = (V, \Sigma, R, S)$ , but rules are relaxed to $A \to \alpha$ where the left side is a single variable and the right side $\alpha$ is any string of variables and terminals. "Context-free" means a variable may be replaced regardless of its surrounding symbols. (A context-sensitive grammar allows more than one symbol on the left, e.g. $AB \to \ldots$ , so replacement depends on context.) Right linear grammars are a subset of CFGs, and CFGs are strictly more powerful than DFAs — e.g. $A \to 0A1 \mid \varepsilon$ generates $\{0^{n}1^{n} : n \ge 0\}$ , a non-regular language.

Parse trees. A derivation can be drawn as a tree whose root is $S$ , whose internal nodes are variables, and whose leaves (read left to right) spell the generated string. A well-chosen arithmetic grammar makes the tree encode operator precedence: forcing multiplication to bind before addition.

Ambiguity. A string is derived ambiguously if it has two or more distinct parse trees. A grammar is ambiguous if it generates any string ambiguously. Compilers avoid this by using restricted, unambiguous CFGs (the LR(k) grammars). Deciding whether an arbitrary CFG is ambiguous is undecidable in general (though decidable for particular cases and for LR(k) grammars) — like how there is no general solution formula for degree-5 polynomials even though specific ones are solvable.

Worked Example

Prove $A = \{0^{n}1^{n} : n \ge 0\}$ is not regular (pumping lemma, by contradiction).

Rule first, then the work: assume $A$ is regular with pumping length $p$ , choose a witness string longer than $p$ , then show every legal split can be pumped out of $A$ .

\begin{aligned} s &= 0^{p}1^{p}, \qquad |s| = 2p \ge p \quad(\text{witness}) \\ s = xyz,\quad &|xy| \le p,\ |y| \ge 1 \;\Rightarrow\; y \text{ lies entirely in the } 0\text{'s, so } y = 0^{k},\ 1 \le k \le p \\ xy^{2}z &= 0^{\,p+k}\,1^{\,p} \quad(\text{pump up: } i = 2) \\ &\text{since } p + k > p,\ \text{the count of } 0\text{'s} \neq \text{count of } 1\text{'s} \;\Rightarrow\; xy^{2}z \notin A \end{aligned}

Every admissible split yields a string outside $A$ , contradicting the pumping property. Therefore no such $p$ exists and $A$ is not regular. $\blacksquare$

Summary

The pumping lemma states a property all regular languages share; proving a language lacks it (pick a worst-case string, show every legal $xyz$ split pumps out of the language) proves non-regularity.
Right linear grammars ( $A \to bC$ , $A \to b$ , $A \to \varepsilon$ ) generate exactly the regular languages and join DFAs, NFAs, and regular expressions as four equivalent descriptions of the same class.
Grammar terminology: a rule application yields ( $\Rightarrow$ ); a chain of applications derives ( $\stackrel{*}{\Rightarrow}$ ); the language of a grammar is all terminal strings derivable from $S$ .
For regular languages, membership, equivalence, infiniteness, and subset are all decidable — equivalence reduces to checking $A - B = \varnothing$ and $B - A = \varnothing$ via closure under intersection and complement.
Context-free grammars allow any string on the right side of a rule (left side stays one variable); they are strictly more powerful than DFAs and capture languages like $\{0^{n}1^{n}\}$ .
Parse trees visualize derivations and can encode precedence; a grammar is ambiguous if some string has two or more parse trees — compilers rely on unambiguous LR(k) grammars to avoid this.