Convert a NFA to Regular Expression

Question

I found a same question on this website, and the answer was a PDF describing how to convert an NFA to a regex. But this is not working because this method has some conditions:

1. There are transitions going from the initial state to all other states, and there are no transitions into the initial state.
2. There is a single accept state that has only transitions coming into it (and no outgoing transitions).
3. The accept state is distinct from the initial state.
4. Except for the initial and accepting states, all other states are connected to all other states via a transition. In particular, each state has a transition to itself.

And in my example the start state is just going to the next state but not to all states (e.g q0 goes to q1 but not to q2, q3), and there are transitions into the start state.

So what is the easiest way to convert an NFA to regex? I am not giving an NFA example becuase I don't have a spesific one, is just a general question, because I come across with this kind of DFA where the start state is not connected with all the states, and the are transitions into the start state.

I want a general algorithm to convert this kind of NFAs.

Answer 1

The answer is assuming those conditions, because any NFA can be modified to fit those requirements.

For any kind of NFA, you can add a new initial state q₀ that has an epsilon-transition to the original initial state, and also using an additional transition symbol called ∅ (they call it empty set symbol, assumed to be a symbol which does not match any symbol from the original NFA) from it to any other states, then use this new state as the new initial state. Note that this does not change the language accepted by the original NFA. This would make your NFA satisfies the first condition.

For any kind of NFA, you can add a new acceptance state q_a that has an epsilon-transition from all acceptance state in the original NFA. Then mark this as the only acceptance state. Note that this does not change the language accepted by the original NFA. This would make your NFA satisfies the second condition.

By the above construction, by setting q₀ != q_a, it satisfies the third condition.

And in the link you provided, the fourth condition is explained by having a special transition symbol called ∅ (the empty set symbol) for which no actual alphabet from original NFA can match. So you can add transitions with this new symbol from every state to any other state. Note that this does not change the language accepted by the original NFA.

So now the NFA has been modified to satisfies the four requirements, you can apply the algorithm there to convert the NFA into Regular Expression, which would accept the same language as the original NFA.

Edit to answer further question:

To answer your question in the comment, consider the NFA with two states, q_A and q_B. q_A is the initial state as well as the only acceptance state. We have a transition from q_A to itself with symbol 0,1. We also have transition from q_A to q_B with symbol 1. Lastly we have transition from q_B to q_A with symbol 0.

Visualization:

 0,1    
  |  1
->qA----->qB
  ^       |
  |-------|
     0

Step 2. When we normalize the NFA, just put the new init state (q_init) that points to q_A, and put a new acceptance state (q_acc) from q_A.

Step 3. We want to remove q_A. So q_A is the q_rip in the algorithm (in page 3). Now we need to consider every states that enters q_A and every states that exits from q_A. In this case, there are two states pointing to q_A, that are q_init and q_B. There are two states that are pointed to by q_A, that are q_B and q_acc. By the algorithm, we replace the transitions q_in->q_rip->q_out with a transition q_in->q_out, having the transition symbol R_dir+R_in(R_rip)*R_out, where:

1. R_dir is the original transition from q_in to q_out
2. R_in is the original transition from q_in to q_rip
3. R_rip is the original loop at q_rip
4. R_out is the original transition from q_rip to q_out

So in this case we replace the transition q_init->q_A->q_B with q_init->q_B with transition symbol (0+1)*1. Continuing this process, we will create in total 4 new transitions:

1. q_init->q_B: (0+1)*1
2. q_init->q_acc: (0+1)*
3. q_B->q_B: 0(0+1)*1
4. q_B->q_acc: 0(0+1)*

Then we can remove q_A.

Step 4. We want to remove q_B. Again, we identify the q_in and q_out. There is only one state coming to q_B here, which is q_init, and there is only one state departing from q_B, which is q_acc. So we have:

1. R_dir = (0+1)*
2. R_in = (0+1)*1
3. R_rip = 0(0+1)*1
4. R_out = 0(0+1)*

So the new transition q_init->q_acc will be:

R_dir+R_in(R_rip)*R_out

(0+1)* + (0+1)*1 (0(0+1)*1)* 0(0+1)*

And we can remove q_B.

Step 5. Since every state in the original NFA has been removed, we are done. So the final regex is shown above.

Note that the final regex might not be optimal (and in most cases it won't be optimal), this is expected from the algorithm. Finding the shortest regex for an NFA (or even DFA) in general is very difficult (although for this example it's easy to see that the first component already covers all possible strings)

For completeness, the shortest regex accepting the same language will be:

(0+1)*