The Timpson Lyceum · Computation Theory

Lecture 7 (Computation Theory) Regular Expressions and the Pumping Lemma

Overview

This lecture closes out regular expressions and opens the study of non-regular languages. First we prove the converse of last time's result: every regular language is generated by some regular expression. The proof introduces a temporary tool, the generalized NFA (GNFA), and a "state-ripping" procedure that collapses any NFA down to a two-state machine whose single edge is the desired regular expression. This completes the chain showing regular expressions, NFAs, and DFAs are all logically equivalent. We then turn to the pumping lemma, the standard tool for proving a language is not regular, and use it to prove that $\{0^n 1^n : n \ge 0\}$ is non-regular.

Key Concepts

Goal of the section. Last time: if $R$ is a regular expression, then $L(R)$ is regular. This time: the converse — if $A$ is regular, some regular expression $R$ generates it. Together these make regular expressions equivalent in power to NFAs and DFAs.

Regular expression (recap). Built from three base cases — a single symbol $a$ (shorthand for the set $\{a\}$), the empty string $\varepsilon$ (the set $\{\varepsilon\}$), and the empty set $\emptyset$ — closed under union, concatenation, and star. Every symbol stands for a one-element set; all operations are set operations.

Generalized NFA (GNFA). An NFA whose edges are labeled with regular expressions rather than single symbols. By convention a GNFA has:

• exactly one accept state, distinct from the start state;
• an arrow from every state (except the accept state) to every state (except the start state) — so the start state has no incoming edges and the accept state has no outgoing edges.

Formal definition. Let $\mathcal{R}$ be the set of all regular expressions over $\Sigma$. A GNFA is a 5-tuple $G = (Q, \Sigma, \delta, q_{\text{start}}, q_{\text{accept}})$ where the transition function

$\delta : (Q \setminus \{q_{\text{accept}}\}) \times (Q \setminus \{q_{\text{start}}\}) \to \mathcal{R}$

takes a pair of states (from-state, to-state) and outputs the regular expression labeling that edge. Unlike a DFA/NFA, the output is the edge label, not the next state.

Converting an NFA to a GNFA. Add a new start state with an $\varepsilon$-arrow into the old start, and a new single accept state with $\varepsilon$-arrows from all old accept states. Then fill in every missing edge with the label $\emptyset$ (an $\emptyset$-edge can never be taken, so the language is unchanged). Every label is now a regular expression.

When a GNFA accepts. $G$ accepts $w$ if $w$ can be split as $w = w_1 w_2 \cdots w_k$ and there is a sequence of states $r_0, r_1, \ldots, r_k$ with $r_0 = q_{\text{start}}$, $r_k = q_{\text{accept}}$, and each piece $w_i \in L\big(\delta(r_{i-1}, r_i)\big)$ — i.e. each piece is generated by the regular expression on the edge it traverses.

State-ripping. To remove an interior state $q_{\text{rip}}$, for every pair $q_i$ (any non-accept state) and $q_j$ (any non-start state) update the edge $q_i \to q_j$ to account for paths that detoured through $q_{\text{rip}}$:

$\delta'(q_i, q_j) = R_1 R_2^{*} R_3 \cup R_4,$

where $R_1 = \delta(q_i, q_{\text{rip}})$, $R_2 = \delta(q_{\text{rip}}, q_{\text{rip}})$, $R_3 = \delta(q_{\text{rip}}, q_j)$, and $R_4 = \delta(q_i, q_j)$ (the old direct edge). Because $\emptyset$-labels simplify away ($\emptyset R = \emptyset$, $R \cup \emptyset = R$), many of these collapse to a single term.

Conversion theorem. If $A$ is regular, some regular expression generates it. Proof idea: take an NFA for $A$, convert to a GNFA $G$ with $k$ states. If $k = 2$, the single edge's label $R$ satisfies $L(R) = A$. If $k > 2$, rip out any interior state to get an equivalent $G'$ with one fewer state, and repeat. Since $G$ is finite, ripping terminates at $k = 2$, leaving a regular expression $R$ with $L(R) = A$.

Pumping lemma (statement). If $A$ is regular, there is a pumping length $p$ (you may take $p$ = number of states in a DFA for $A$) such that every $s \in A$ with $|s| \ge p$ can be written $s = xyz$ with:

1. $xy z \in A$ already, and for all $i \ge 0$, $x y^{i} z \in A$;
2. $|y| \ge 1$ (the loop reads at least one symbol);
3. $|xy| \le p$ (the loop occurs within the first $p$ symbols).

Why it holds. Reading $p$ symbols visits $p+1$ states; with only $p$ states some state $q_r$ repeats, forcing a loop. Let $x$ be read up to the first visit of $q_r$, $y$ the loop $q_r \to q_r$, and $z$ the rest. Traversing the loop $i$ times (or skipping it, $i=0$) keeps the string in the language.

Using it (contrapositive). To prove $A$ is not regular, show $A$ lacks the pumping property: for every $p$, there exists a string $s \in A$ with $|s| \ge p$ such that for every split $s = xyz$ satisfying $|xy| \le p$ and $|y| \ge 1$, some $i$ makes $x y^{i} z \notin A$.

Worked Example

Claim. $A = \{0^{n} 1^{n} : n \ge 0\}$ is not regular.

Assume for contradiction $A$ is regular, so the pumping lemma applies with some pumping length $p$. Choose the string $s = 0^{p} 1^{p}$, which lies in $A$ and has $|s| = 2p \ge p$. The lemma gives a split $s = xyz$ with $|xy| \le p$ and $|y| \ge 1$. Since $xy$ is the first $\le p$ symbols of $s$ and those are all $0$s, both $x$ and $y$ consist only of $0$s, so $y = 0^{m}$ with $m \ge 1$. Pump up with $i = 2$:

This string has $p+m$ zeros but only $p$ ones, and since $m \ge 1$ the counts differ, so $0^{p+m}1^{p} \notin A$. But the pumping lemma guaranteed $x y^{2} z \in A$ — a contradiction. Hence the assumption fails and $A$ is not regular. $\blacksquare$

Summary

• Every regular language is generated by some regular expression — the converse needed to make regular expressions, NFAs, and DFAs all equivalent.
• The proof uses a GNFA: an NFA with regular-expression edge labels, one accept state, and edges between all permitted state pairs; its transition function maps a pair of states to a regular expression.
• State-ripping removes interior states one at a time via $\delta'(q_i,q_j) = R_1 R_2^{*} R_3 \cup R_4$, shrinking any GNFA to two states whose single edge is the regular expression for the language.
• The pumping lemma says long strings ($|s| \ge p$) in a regular language contain a loop and split as $s = xyz$ with $|xy| \le p$, $|y| \ge 1$, and $x y^{i} z \in A$ for all $i \ge 0$.
• It holds because reading $p$ symbols forces a repeated state (a loop) in a $p$-state machine, which can be traversed any number of times.
• To prove non-regularity, apply the contrapositive: pick a hard string and show no valid split survives pumping — as with $\{0^n1^n\}$, where pumping the all-zero loop breaks the equal-count condition.