Title
Implementing regex’s with NFAs
Theorem: Any regex-decidable language is NFA-decidable.
Proof
Inductive proof:
For any regular expression \(R\), we can construct an NFA \(N\) such that \(L(N) = L(R)\).
The base cases of the inductive definition are the base cases of the proof!
If \(R = a\) for some \(a \in \Sigma\), then \(L(R) = \{a\}\) decided by the NFA
If \(R = \emptystring\), then \(L(R) = \{\emptystring\}\) decided by the NFA
If \(R = \emptyset\), then \(L(R) = \{\}\) decided by the NFA
Implementing regex’s with NFAs example: \((a \cup ab)^* b\)
\(\stackrel{\Large \nwarrow}{\large \leftarrow}\) base cases
- Note that this is equivalent to the NFA
True or False: Collapsing two NFA states connected by an \(\emptystring\)-transition always preserves its behavior.
Implementing regex’s with NFAs example: \((a \cup ab)^* b\)
- \(\stackrel{\Large \nwarrow}{\large \leftarrow}\) base cases
- Don’t optimize by collapsing two states between \(\varepsilon\)-transition. (unsafe in general, even if it works in this special case)
Converting NFAs to regex’s
Theorem: Any NFA-decidable language is regex-decidable.
Starting point: “Expression Automata” (EA) (or “Generalized NFAs” in Sipser)
Label the transition arrows of an EA with regular expressions that match substrings of the input rather than individual symbols.
- ❌ \(\emptystring\)
- ❌ \(\string{a}\)
- ❌ \(\string{b}\)
- ✅ \(\string{ba}\)
- ✅ \(\string{bba}\)
- ✅ \(\string{baa}\)
- ❌ \(\string{baaba}\)
- ✅ \(\string{baababa}\)
- ✅ \(\string{baababa}\)
- ✅ \(\string{bbaaababbba}\)
- ❌ \(\string{bbaabab}\)
- ❌ \(\string{bbaababab}\)
Converting NFAs to regex’s
Theorem: Any NFA-decidable language is regex-decidable.
Starting point: “Expression Automata” (EA; “Generalized NFAs” in Sipser)
Label the transition arrows of an NFA with regular expressions that match substrings of the input rather than individual symbols.
Proof idea:
- Any NFA \(N\) is already a valid EA.
- Incrementally convert \(N\) into an equivalent EA \(E\) of the form:
where \(R\) is a regular expression.
Then \(L(N) = L(E) = L(R)\)!
Converting NFAs to regex’s: Incremental simplification
We then apply incremental simplifications that remove the states “in the box” (not \(s\) or \(a\)) one by one:
How does this work in general?
Converting NFAs to regex’s: Incremental simplification
The final simplification step operates on an EA that looks like:
What strings take this EA from \(s\) to \(a\)? They either:
- match \(W\),
- or they start with a prefix matching \(X\), followed by zero or more substrings matching \(Y\), followed by a suffix matching \(Z\), i.e., strings that match \(X Y^* Z\).
We can rip state “i” out of the diagram but still accept strings whose computation sequences go through \(i\), by changing the transition between \(s\) and \(a\):
Both EAs accept exactly strings of the form \(w \in L(W)\), or of the form \(x y_1 y_2 \dots y_k z\) for some \(k \in \N\), where \(x \in L(X)\), each \(y_i \in L(Y)\), and \(z \in L(Z)\).
- In general, some of the transitions may not exist, e.g., if there is no \(s \stackrel{W}{\to} a\) transition, use \(X Y^* Z\); if no self-loop on \(i\), use \(W \cup XZ\); if neither, then use \(XZ\).
Converting NFAs to regex’s: Incremental simplification
When more than three states remain:
- Select any state other than \(s\) or \(a\) and call it \(i\).
- Iterate over pairs of states \(q\) and \(r\) with transitions \(q \stackrel{X}{\to} i\) and \(i \stackrel{Z}{\to} r\) (even if \(q = r\))
- For each of these pairs, transform:
into: 
- This new transition represents the ways to get from \(q\) to \(r\), without going through any other states other than possibly \(i\).
- More precisely, iterate over pairs of transitions in/out of \(i\) (more on this in a bit).
- Repeat until only \(s\) and \(a\) remain!
Example removing state \(i\)
- How to get from \(q\) to \(t\) going through \(i\)? \(0^*1\) (go from \(q\) to \(i\)) \((00)^*\) (loop on \(i\)) \(1^+\) (go from \(i\) to \(t\))
- add new transition: \(q \stackrel{0^*1 (00)^* 1^+}{\to} t\)
- How to get from \(q\) to \(r\) going through \(i\)? \(\fragment{0^*1} \fragment{(00)^*} \fragment{\emptystring} \fragment{= 0^*1 (00)^*}\)
- replace existing \(q \stackrel{110}{\to} r\) transition with: \(q \stackrel{110\ \ \cup\ \ 0^*1(00)^*}{\to} r\)
- How to get from \(t\) to \(r\) going through \(i\)? \(\fragment{01 (00)^* \emptystring = 01 (00)^*}\)
- add new transition: \(t \stackrel{01(00)^*}{\to} r\)
- How to get from \(t\) to \(t\) going through \(i\)? \(\fragment{01 (00)^* 1^+}\)
- add new self-transition: \(t \stackrel{01(00)^*1^+}{\to} t\)
Other pairs of states, e.g., (\(s,r\) or \(q,q\)), not listed because either the first has no transition to \(i\) or the second has no transition from \(i\).