Another method, not covered by the answers above, is *finite transformation of automaton*. As a simple example, let us show that ordinary languages are closed under the *mix* operation, defined as follows:

$$

L_1 mathop {S} L_2 = {x_1y_1 ldots x_n y_n in Sigma ^ *: x_1 ldots x_n in L_1, y_1 ldots y_n in L_2 }

$$

You can display a shutdown under shuffle using closing properties, but you can also view it directly with the help of DFA. Suppose that $ A_i = langle Sigma, Q_i, F_i, delta_i, q_ {0i} rangle $ is a DFA that accepts $ L_i $ (for $ i = 1,2 $). We build a new DFA $ langle Sigma, Q, F, delta, q_0 rangle $ as follows:

- The set of states is $ Q_1 times Q_2 times {1,2 } $, where the third component remembers whether the following symbol is a $ x_i $ (when 1) or a $ y_i $ (when 2).
- The initial state is $ q_0 = langle q_ {01}, q_ {02}, 1 rangle $.
- Accepting states are $ F = F_1 times F_2 times {1 } $.
- The transition function is defined by $ delta ( langle q_1, q_2, 1 rangle, sigma) = langle delta_1 (q_1, sigma), q_2, 2 rangle $ and $ delta ( langle q_1 , q_2, 2 rangle, sigma) = langle q_1, delta_2 (q_2, sigma), 1 rangle $.

A more sophisticated version of this method involves *guessing*. For example, let's show that ordinary languages are closed under *overthrow*, C is,

$$ L ^ R = {w ^ R: w in Sigma ^ * }. $$

(Here $ (w_1 ldots w_n) ^ R = w_n ldots w_1 $.) This is one of the standard close operations, and the invert closure is easily derived from the manipulation of regular expressions (which can be considered as the counterpart of the finite automaton transformation into regular expressions) – just invert the regular expression. But you can also prove the closure using the NFAs. Suppose that $ L $ is accepted by a DFA $ langle Sigma, Q, F, delta, q_0 rangle $. We build a $ langle Sigma NFA, Q, F, delta, q $ _0 $ row, where

- The set of states is $ Q = Q cup {q $ _0 }.
- The initial state is $ q $ _0.
- The state of single acceptance is $ q_0 $.
- The transition function is defined as follows: $ delta # (q -0, epsilon) = F $, and for any state $ q in Q $ and $ sigma in Sigma $, $ delta (q, sigma) = {q: delta (q, sigma) = q $ .

(We can get rid of $ q $ _0 if we allow multiple initial states.) The guessing component here is the final state of the word after its inversion.

Guessing often involves also checking. A simple example is the closing under *rotation*:

$$ R (L) = {yx in Sigma ^ *: xy in L }. $$

Suppose $ L $ is accepted by the DFA $ langle Sigma, Q, F, delta, q_0 rangle $. We build a $ langle Sigma NFA, Q, F, delta, q $ _0 rangle $, which works as follows. The NFA first guesses $ q = delta (q_0, x) $. It then checks that $ delta (q, y) in F $ and that $ delta (q_0, x) = q $, passing from $ y $ to $ x $ in a non-deterministic way. This can be formalized as follows:

- The states are $ Q = {q \\\\\\\\\\\\\\\\\\\\\\\\\\\\\\ ' In addition to the initial state $ q $ _0, the states are $ langle q, q_ {curr}, s rangle $, where $ q $ is the state we have guessed, $ q_ {curr} $ is the current state, and $ s $ specifies whether we are at the $ y $ portion of the input (when 1) or the $ x $ portion of the input ( when 2).
- The final states are $ F = { langle q, q, 2 rangle: q in Q } $: we accept when $ delta (q_0, x) = q $.
- The transitions $ delta # (q '_0, epsilon) = { langle q, q, 1 rank: q in Q } $ implement guess $ q $.
- The transitions $ delta # ( langle q, q_ {curr}, s rangle, sigma) = langle q, delta (q_ {curr}, sigma), s rangle $ (for each $ q, q_ {curr} in Q $ and $ s in {1,2 } $ simulate the original DFA.
- The transitions $ delta # ( langle q, q_f, 1 rangle, epsilon) = langle q, q_0,2 rangle $, for each $ q in Q $ and $ q_f in F $ , implement moving the $ y $ part to the $ x $ part. This is only allowed if we have reached a final state on the $ y $ part.

Another variant of the technique incorporates bounded counters. For example, consider the change *change the closing distance*:

$$ E_k (L) = {x in Sigma ^ *: text {there is $ y in L $ whose edit distance of $ x $ is at most $ k $} }. $$

Let DFA $ langle Sigma, Q, F, delta, q_0 rank $ for $ L $, and construct a NFA $ langle Sigma, Q, F, delta & # 39 ;, q '_0 rangle $ for $ E_k (L) $ as follows:

- The set of states is $ Q = Q times {0, ldots, k } $, where the second element counts the number of changes made up to now.
- The initial state is $ q '_0 = langle q_0,0 rangle $.
- Accepting states are $ F = F times {0, ldots, k } $.
- For each $ q, sigma, i $, we have transitions $ langle delta (q, sigma), i rank in delta ( langle q, i rangle, sigma) $.
- Insertions are handled by the transitions $ langle q, i + 1 rangle in delta ( langle q, i rangle, sigma) $ for all $ q, sigma, i $ such that $ i <k $.
- Deletions are handled by the transitions $ langle delta (q, sigma), i + 1 row in delta ( langle q, i row, epsilon) $ for all $ q, sigma, i $ such that $ i <k $.
- The substitutions are similarly manipulated by the transitions $ langle delta (q, sigma), i + 1 rangle in delta # ( langle q, i rangle, tau) $ for all $ q , sigma, tau, i $ such that $ i <k $.