The Timpson Lyceum · Computation Theory

Lecture 6 (Computation Theory) Nondeterministic Finite Automata and Regular Expressions

Overview

This lecture closes out the theory of finite automata and opens the study of regular expressions. Having already established that NFAs and DFAs are equivalent in power, we use the flexibility of NFAs to prove that the regular languages are closed under the three regular operations — union, concatenation, and star — plus complement and intersection. We then preview how to argue that a language is not regular, using the looping (pumping) intuition. Finally, we define regular expressions precisely and prove one direction of their equivalence with finite automata: every regular expression denotes a regular language. The throughline is that all of these tools are just different ways of certifying that a language is regular.

Key Concepts

DFA vs. NFA (recap). A DFA (deterministic finite automaton) must have exactly one transition out of every state for every input symbol — no missing arrows and no two arrows on the same symbol from one state. An NFA (nondeterministic finite automaton) may omit arrows (a missing transition means that computation branch dies), may have several arrows on the same symbol, and may take $\varepsilon$ -transitions (move without consuming input). An NFA accepts a string if some computation path reaches an accept state. NFAs and DFAs recognize exactly the same class of languages, so building either one for a language $A$ proves $A$ is regular.

Closed operation. A set is closed under an operation if applying it never escapes the set (e.g. the natural numbers are closed under addition but not subtraction). The regular operations are:

Union $A_1 \cup A_2$ — strings in either language ("or").
Concatenation $A_1 A_2$ — a prefix from $A_1$ followed by a suffix from $A_2$ .
Star $A^{*}$ — zero or more strings of $A$ concatenated; always includes $\varepsilon$ .

Closure under union. Given NFAs $N_1, N_2$ for $A_1, A_2$ , add a new start state $q_0$ with $\varepsilon$ -transitions to the old start states (which stop being start states). The combined machine guesses which sub-machine to run.

Closure under concatenation. Connect every accept state of $N_1$ to the start state of $N_2$ via an $\varepsilon$ -transition, and un-mark $N_1$ 's accept states. Nondeterminism "guesses" where to split the string; the old accept states keep their transitions so the machine can choose either to keep reading in $N_1$ or jump.

Closure under star. Add a new start state $q_0$ that is also an accept state (so $\varepsilon$ is accepted), with an $\varepsilon$ -transition to the old start state, and add $\varepsilon$ -transitions from every old accept state back to the old start state (so the machine can loop and restart any number of times).

Closure under complement. Easiest with a DFA: take a DFA for $A$ and toggle the accept states — the new accept set is $Q \setminus F$ . Every state that was accepting becomes non-accepting and vice versa, so the machine accepts exactly the strings $A$ rejected.

Closure under intersection. Free from De Morgan's laws: $A_1 \cap A_2 = \overline{\overline{A_1} \cup \overline{A_2}}$ . Since regular languages are closed under union and complement, they are closed under intersection. (The set operations $\cap, \cup, \overline{\;\cdot\;}$ behave exactly like logical $\wedge, \vee, \lnot$ .)

Non-regular languages (preview). The language $\{\,0^n 1^n : n \ge 0\,\}$ is not regular. Intuition via contradiction: if a DFA with $k$ states accepted it, then reading $0^k$ forces a repeated state, so the computation contains a loop. Pumping that loop extra times yields a string with too many $0$ s that the machine still accepts — but that string is not in the language, a contradiction. This is the seed of the pumping lemma.

Regular expression. Defined inductively. $R$ is a regular expression if it is one of:

a symbol $a$ from the alphabet $\Sigma$ ,
$\varepsilon$ (the empty string),
$\varnothing$ (the empty set),
$R_1 \cup R_2$ for regular expressions $R_1, R_2$ ,
$R_1 R_2$ (concatenation),
$R_1^{*}$ (star).

Notation and precedence. $\Sigma$ abbreviates $(0 \cup 1)$ over the binary alphabet, so $\Sigma^{*}$ is all binary strings. Precedence, like arithmetic, is star, then concatenation, then union (star $\approx$ exponent, concatenation $\approx$ multiply, union $\approx$ add).

Algebraic identities ( $\varepsilon$ behaves like $1$ , $\varnothing$ like $0$ ):

$R \cup \varnothing = R$
$R \,\varepsilon = R$
$R\, \varnothing = \varnothing$
$\varnothing^{*} = \varepsilon$ (any starred expression generates at least $\varepsilon$ )
Concatenation distributes over union: $(0 \cup \varepsilon)1^{*} = 0\,1^{*} \cup \varepsilon\,1^{*}$ .

Regular expressions denote regular languages. The language generated by any regular expression is regular, proved by converting each of the six cases to an NFA: cases 1–3 are tiny base machines, and cases 4–6 reuse the union/concatenation/star constructions above.

Worked Example

Goal: Convert the regular expression $(ab) \cup a$ into an NFA mechanically, by applying the six conversion rules — base machines for symbols, then concatenation, union, and (to illustrate) star.

State the constructions used:

\begin{aligned} ab \;&=\; (\text{NFA for } a)\;\xrightarrow{\varepsilon}\;(\text{NFA for } b) &&\text{(concatenation: link accept}\to\text{start, drop old accepts)} \\ (ab)\cup a \;&=\; q_{0}\;\xrightarrow{\varepsilon}\;\{N_{ab},\,N_{a}\} &&\text{(union: new start with two } \varepsilon\text{-branches)} \\ \big((ab)\cup a\big)^{*} \;&=\; q_{0}'\;(\text{accept})\;\xrightarrow{\varepsilon}\;N_{\cup},\quad F \xrightarrow{\varepsilon} q_{0}' &&\text{(star: accepting new start, loop accepts}\to\text{start)} \end{aligned}

Reading off the result: build a two-state machine accepting $a$ and another accepting $b$ , splice them with an $\varepsilon$ -transition to get $ab$ , build a fresh machine for $a$ , add a new start state with $\varepsilon$ -arrows into both pieces to realize the union, and (for the star) add an accepting start state that $\varepsilon$ -loops back from the accept states. The resulting NFA is far larger than necessary, but it is produced purely by the rules — proving every regular expression has an equivalent NFA, hence denotes a regular language.

Summary

NFAs are no more powerful than DFAs, so building either certifies a language is regular; NFAs just make the closure proofs trivial.
Regular languages are closed under union (new $\varepsilon$ -branching start), concatenation ( $\varepsilon$ -link accepts to next start), and star (accepting new start that $\varepsilon$ -loops back).
They are also closed under complement (toggle a DFA's accept states) and intersection (via De Morgan: $A_1 \cap A_2 = \overline{\overline{A_1}\cup\overline{A_2}}$ ).
Not every language is regular: $\{0^n 1^n\}$ fails because any finite machine must loop on long inputs, and that loop can be pumped to accept illegal strings — the pumping intuition.
A regular expression is built inductively from symbols, $\varepsilon$ , and $\varnothing$ using union, concatenation, and star, with precedence star $>$ concatenation $>$ union; $\varepsilon$ acts like $1$ and $\varnothing$ like $0$ (and $\varnothing^{*}=\varepsilon$ ).
Every regular expression denotes a regular language, shown by converting its six cases into an equivalent NFA; the converse (every regular language has a regular expression) comes next.