Kleene's algorithm

Algorithm description

According to Gross and Yellen (2004), the algorithm can be traced back to Kleene (1956). A presentation of the algorithm in the case of deterministic finite automata (DFAs) is given in Hopcroft and Ullman (1979). The presentation of the algorithm for NFAs below follows Gross and Yellen (2004).

Given a nondeterministic finite automaton M = (Q, Σ, δ, q₀, F), with Q = { q₀,...,q_n } its set of states, the algorithm computes

the sets R^k
_ij of all strings that take M from state q_i to q_j without going through any state numbered higher than k.

Here, "going through a state" means entering and leaving it, so both i and j may be higher than k, but no intermediate state may. Each set R^k
_ij is represented by a regular expression; the algorithm computes them step by step for k = -1, 0, ..., n. Since there is no state numbered higher than n, the regular expression Rⁿ
_0j represents the set of all strings that take M from its start state q₀ to q_j. If F = { q₁,...,q_f } is the set of accept states, the regular expression Rⁿ
₀₁ | ... | Rⁿ
_0f represents the language accepted by M.

The initial regular expressions, for k = -1, are computed as follows for i≠j:

R⁻¹
_ij = a₁ | ... | a_m where q_j ∈ δ(q_i,a₁), ..., q_j ∈ δ(q_i,a_m)

and as follows for i=j:

R⁻¹
_ii = a₁ | ... | a_m | ε where q_i ∈ δ(q_i,a₁), ..., q_i ∈ δ(q_i,a_m)

In other words, R⁻¹
_ij mentions all letters that label a transition from i to j, and we also include ε in the case where i=j.

After that, in each step the expressions R^k
_ij are computed from the previous ones by

R^k
_ij = R^k-1
_ik (R^k-1
_kk)^* R^k-1
_kj | R^k-1
_ij

Another way to understand the operation of the algorithm is as an "elimination method", where the states from 0 to n are successively removed: when state k is removed, the regular expression R^k-1
_ij, which describes the words that label a path from state i>k to state j>k, is rewritten into R^k
_ij so as to take into account the possibility of going via the "eliminated" state k.

By induction on k, it can be shown that the length of each expression R^k
_ij is at most ⁠1/3⁠(4^k+1(6s+7) - 4) symbols, where s denotes the number of characters in Σ. Therefore, the length of the regular expression representing the language accepted by M is at most ⁠1/3⁠(4ⁿ⁺¹(6s+7)f - f - 3) symbols, where f denotes the number of final states. This exponential blowup is inevitable, because there exist families of DFAs for which any equivalent regular expression must be of exponential size.

In practice, the size of the regular expression obtained by running the algorithm can be very different depending on the order in which the states are considered by the procedure, i.e., the order in which they are numbered from 0 to n.