Title
Implementing Regexes 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 Regexes with NFAs Example: \(\string{(a \cup ab)^* b}\)
Converting NFAs to Regexes
Theorem: Any NFA-decidable language is regex-decidable.
Starting point: “Expression Automata” (or “Generalized NFAs” in Sipser)
Label the transition arrows of an NFA 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 Regexes
Theorem: Any NFA-decidable language is regex-decidable.
Starting point: “Expression Automata” (or “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 expression automaton.
- Incrementally convert \(N\) into a simpler equivalent expression automaton \(E\) of the form:
where \(R\) is a regular expression.
Then \(L(N) = L(E) = L(R)\)!
Converting NFAs to Regexes: First Step
In our first step, we modify \(N\) so that its start/accept states already have the desired form:
- No transitions into the start state.
- There is a single accept state with no outbound transitions.
Given \(N = (Q, \Sigma, \Delta, q_0, F)\),
construct \(N' = (Q', \Sigma, \Delta', s, F')\):
- \(Q' = Q \cup \{s, a\}\) where \(s, a \notin Q\)
- \(F' = \{a\}\)
- Assuming \(\Delta\) represents a
set of transitions: \(\Delta' = \Delta \cup \{(s, \emptystring, q_0)\} \cup \setbuild{(q, \emptystring, a)}{q \in F}\)
\(L(N') = L(N)\) because:
There exists a computation sequence of \(N\) \(r_1, r_2, \ldots, r_n\) that accepts \(w\) if and only if \(s, r_1, r_2, \ldots, r_n, a\) is a computation sequence of \(N'\) accepting \(w\).
Converting NFAs to Regexes: Incremental Simplification
We then apply incremental simplifications that remove the states “in the box” one by one:
How does this work in general?
Converting NFAs to Regexes: Incremental Simplification
The final simplification step operates on an EA that looks like:
We can rip state “i” out of the diagram but still accept strings whose computational sequences through it by changing the connection between \(s\) and \(a\):
Both EAs accept exactly strings of the form
- \(w \in L(W)\), or
- \(x y^k z\) for some \(k \in \N\) where \(x \in L(X), y \in L(Y)\), and \(z \in L(Z)\).
Converting NFAs to Regexes: 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{a}{\to} i\) and \(i \stackrel{b}{\to} r\) (even if \(q = r\))
- For each of these pairs, transform:
into: 
- Repeat until only 2 states remain!
Example Conversion (Dave’s Figure 6.7)
