The Timpson Lyceum · Computation Theory

Lecture 5 (Computation Theory) Nondeterministic Finite Automata

Nondeterministic Finite Automata – Lecture 5

Overview

This lecture introduces the nondeterministic finite automaton (NFA), the second model of computation in the study of regular languages. Where a deterministic finite automaton (DFA) follows exactly one forced path through its states, an NFA is allowed to branch: from a single state on a single symbol it may move to several states at once, none, or even change state without reading any input at all (an $\varepsilon$ -transition). We build intuition for how an NFA accepts a string, give the formal five-tuple definition, and then prove the central result of the section: every NFA can be converted into an equivalent DFA, so the two models recognize exactly the same class of languages (the regular languages). The payoff is practical — NFAs are often dramatically smaller and clearer to design than the equivalent DFA, even though they are no more powerful.

Key Concepts

Deterministic vs. nondeterministic. In a DFA, the current state plus the input symbol completely determine the next state — exactly one transition out of every state for every alphabet symbol. An NFA relaxes this: for a given state and symbol there may be zero, one, or many possible next states, and the machine may also take $\varepsilon$ -transitions (move without consuming any input).

How an NFA accepts. An NFA accepts a string if there exists at least one path through its states (a sequence of valid transitions) that consumes the whole string and ends in an accept state. Equivalently:

Think of the machine as exploring all possible paths in parallel — a computation tree. If any leaf lands in an accept state, the string is accepted.
Or think of it as a machine that may guess which branch to take and is assumed to always guess correctly when acceptance is possible.
If a branch reaches a state with no valid transition on the next symbol, that branch dies (rejects); other branches may still accept.

$\varepsilon$ -transitions. An edge labeled $\varepsilon$ lets the machine change state without reading a symbol. Reading $\varepsilon$ does not change the underlying string: the string $1\,\varepsilon\,1$ is just the string $11$ . So $\varepsilon$ never enters the alphabet of the language — it only appears in the transition rules. These transitions are what make operations like union easy to wire together.

Why NFAs are useful. NFAs frequently express a language far more transparently than a DFA. Example: "the string contains $11$ as a substring" is a tiny NFA, but as a DFA the same idea, or "the third-from-last symbol is a $1$ ," blows up — tracking the last three symbols needs $2^3 = 8$ states. The DFA and NFA are logically equivalent; the NFA is just easier for a human to read.

Formal definition. An NFA is a five-tuple $N = (Q,\ \Sigma,\ \delta,\ q_0,\ F)$ where $Q$ is a finite set of states, $\Sigma$ is a finite alphabet, $q_0 \in Q$ is the start state, and $F \subseteq Q$ is the set of accept states. The only piece that differs from a DFA is the transition function: $\delta : Q \times \Sigma_\varepsilon \to \mathcal{P}(Q),$ where $\Sigma_\varepsilon = \Sigma \cup \{\varepsilon\}$ and $\mathcal{P}(Q)$ is the power set of $Q$ (the set of all subsets of $Q$ ). So $\delta$ takes a state and either a symbol or $\varepsilon$ , and returns a set of states — possibly empty. For example $\delta(q_1, 1) = \{q_1, q_2, q_3\}$ , while a dead end gives $\delta(q_3, 0) = \varnothing$ .

Power set. $\mathcal{P}(S)$ is the set of all subsets of $S$ . If $|S| = n$ then $|\mathcal{P}(S)| = 2^n$ . E.g. $\mathcal{P}(\{1,2,3\})$ has $2^3 = 8$ elements, always including $\varnothing$ . This is exactly the supply of "states" we need when simulating an NFA, because after reading some input the NFA could be in any subset of its states at once.

Formal acceptance. $N$ accepts $w = w_1 w_2 \cdots w_n$ (each $w_i \in \Sigma_\varepsilon$ ) if there is a sequence of states $r_0, r_1, \dots, r_n$ such that:

$r_0 = q_0$ (start in the start state),
$r_{i+1} \in \delta(r_i, w_{i+1})$ for $i = 0, \dots, n-1$ (every step is a legal transition), and
$r_n \in F$ (end in an accept state).

Note there is one more state ( $n+1$ of them) than there are input symbols ( $n$ ).

Equivalence of NFAs and DFAs (the subset construction). Every NFA has an equivalent DFA. Given $N = (Q, \Sigma, \delta, q_0, F)$ , build a DFA $M = (Q', \Sigma, \delta', q_0', F')$ whose states are subsets of $N$ 's states — each DFA state records exactly which set of NFA states the machine could currently be in:

$Q' = \mathcal{P}(Q)$ ,
$F' = \{\, R \in Q' : R \cap F \neq \varnothing \,\}$ — accept whenever the current subset contains at least one of $N$ 's accept states.

To handle $\varepsilon$ -moves, define the $\varepsilon$ -closure $E(R)$ = the set of all states reachable from any state in $R$ using zero or more $\varepsilon$ -transitions (including the states of $R$ themselves). Then:

start state $q_0' = E(\{q_0\})$ ,
$\displaystyle \delta'(R, a) = E\!\left( \bigcup_{r \in R} \delta(r, a) \right)$ — read $a$ from every state you might be in, collect all resulting states, then take the $\varepsilon$ -closure.

Since every DFA is already (trivially) an NFA, the two models recognize the same languages. Corollary: a language $A$ is regular if and only if some NFA recognizes it.

Worked Example

Convert the NFA $N$ over $\Sigma = \{a, b\}$ with states $\{1, 2, 3\}$ , start state $1$ , accept state $F = \{1\}$ , and the single $\varepsilon$ -edge $1 \xrightarrow{\varepsilon} 3$ , whose transitions are:

\begin{aligned} &\delta(1,a) = \varnothing, \quad \delta(1,b) = \{2\}, \quad \delta(1,\varepsilon) = \{3\} \\ &\delta(2,a) = \{2,3\}, \quad \delta(2,b) = \{3\} \\ &\delta(3,a) = \{1\}, \quad \delta(3,b) = \varnothing \end{aligned}

Start state. Take the $\varepsilon$ -closure of the NFA start state. The general rule, then the substitution:

\begin{aligned} q_0' &= E(\{q_0\}) \\ &= E(\{1\}) = \{1, 3\} \quad(\text{since } 1 \xrightarrow{\varepsilon} 3). \end{aligned}

A transition. Compute $\delta'(\{1,3\}, a)$ using the subset rule, then substitute:

\begin{aligned} \delta'(R, a) &= E\!\left( \bigcup_{r \in R} \delta(r, a) \right) \\ \delta'(\{1,3\}, a) &= E\big( \delta(1,a) \cup \delta(3,a) \big) \\ &= E(\varnothing \cup \{1\}) = E(\{1\}) = \{1, 3\}. \end{aligned}

So from the DFA state $\{1,3\}$ , reading $a$ returns to $\{1,3\}$ . Because $\{1,3\}$ contains the NFA accept state $1$ , it is an accept state of the DFA ( $\{1,3\} \cap \{1\} = \{1\} \neq \varnothing$ ). Continuing this process for every reachable subset and both symbols produces a full DFA over the power set of $\{1,2,3\}$ whose accept states are every subset meeting $\{1\}$ — and it recognizes exactly the same language as $N$ .

Summary

A DFA has exactly one forced transition per state/symbol; an NFA may branch to several states, none, or move on $\varepsilon$ without reading input.
An NFA accepts a string if any path through its states consumes the whole string and ends in an accept state — imagine all branches explored in parallel, or a machine that always guesses correctly.
Formally $N = (Q, \Sigma, \delta, q_0, F)$ ; the only change from a DFA is $\delta : Q \times \Sigma_\varepsilon \to \mathcal{P}(Q)$ , returning a set of states (possibly $\varnothing$ ).
The power set $\mathcal{P}(Q)$ has $2^{|Q|}$ elements; it supplies the states for simulating an NFA, since the NFA can be in any subset of states at once.
Subset construction: every NFA converts to an equivalent DFA whose states are subsets of $Q$ , with start state $E(\{q_0\})$ , transitions $\delta'(R,a) = E\big(\bigcup_{r \in R} \delta(r,a)\big)$ , and accept states any subset meeting $F$ .
NFAs and DFAs are therefore equally powerful; a language is regular iff some NFA recognizes it. NFAs are valued for being smaller and clearer to design, not for extra power.