Algoritmo per ridurre un DFA introducendo il non determinismo?

Ciò è in qualche modo correlato a un'altra domanda che ho posto , ma ritengo che sia abbastanza diverso da giustificare la propria domanda.

Sto facendo delle ricerche in cui sto cercando di trovare la struttura dei complementi di una certa classe di lingue finite. È facile per me ottenere i DFA minimi che accettano questi linguaggi, ma vorrei esaminare quale tipo di struttura hanno i NFA che accettano questi linguaggi, in particolare in che modo il non determinismo aiuta con le dimensioni dello stato degli automi (i DFA sono esponenzialmente grandi).

Il problema è che la principale tecnica di riduzione di NFA utilizza equivalenze, che non produrranno alcuna riduzione se inizio con un DFA minimo (dal momento che utilizza sostanzialmente la stessa tecnica). Se inizio con un DFA non minimo, sputa semplicemente il DFA minimo.

Quello che mi chiedo è, ci sono algoritmi che possono iniziare con un DFA e ridurlo in un NFA più piccolo introducendo il non determinismo? Esistono "tecniche standard" per farlo?

Ho trovato riduzioni dei preordini , che sembrano promettenti ma difficili da attuare. Sono aperto a molti suggerimenti.

Per l'euristica efficiente suggerirei di esaminare la letteratura CAD sul problema della codifica dello stato (assegnando identificatori binari agli stati di un DFA per minimizzare la quantità di logica per la funzione di transizione dello stato.) Devadas e Newton, "Decomposizione e fattorizzazione di sequenze finite macchine a stati ", IEEE TCAD , 8 (11): 1206-1217, 1989 sottolinea che esiste una stretta relazione tra codifica dello stato e decomposizione della macchina a stati.

Se per un DFA con $N$ afferma di assegnare un unico $M$ identificatore di stato bit per ogni stato ($\lg_2N < M\leq N$), quindi hai sostanzialmente decomposto il DFA in una rete di $M$macchine a due stati interagenti. Equivalentemente: hai definito un set$S$ con $M$ elementi e assegnato un sottoinsieme univoco di $S$a ogni stato nel tuo DFA originale. Questo è anche ciò che fa l' algoritmo di costruzione del powerset Rabin-Scott . Quindi, facendo una codifica di stato sul DFA, stiamo cercando di decodificare il set da cui è partito l'algoritmo di costruzione del powerset.

Nel tradizionale problema di codifica dello stato tutte le codifiche sono legali e esiste una funzione oggettiva (correlata alla quantità di logica nella funzione di transizione di stato) che si sta tentando di ridurre al minimo. Per generare un NFA è necessario risolvere una versione vincolata del problema di codifica in cui:

una codifica di $M$gli identificatori di bit agli stati DFA rappresentano un iff NFA per ogni simbolo dell'alfabeto la funzione di transizione per ciascun bit è una semplice disgiunzione di bit. (Non è consentita alcuna congiunzione o negazione.)

Quindi potresti elencare tutto $M$ codifiche bit per tutti $\lg_2N < M\leq N$e controlla se ognuno soddisfa il vincolo. (Nota che per$M=N$ la banale codifica "one-hot" soddisfa sempre i vincoli e ti dà il DFA.) L'enumerazione è però ridicolmente grande, (il libro di testo di Di Micheli lo dà come qualcosa di simile $\frac{2^M !}{(2^M - N)!M!}$.) Il motivo per cui sto suggerendo la letteratura CAD è che ci sono tecniche per fare questa ricerca implicitamente piuttosto che enumerare (ad esempio, usando BDD, vedi Lin, Touati e Newton, "Non preoccuparti della minimizzazione di sequenze multilivello reti logiche, " Int'l Conf Comp-Aided Dsgn ICCAD-90: 414-417, 1990 .

Esempio

Prendi il seguente DFA, (con una codifica di stato che ho derivato da barare (ho generato il DFA da un NFA usando Rabin-Scott, e la codifica rappresenta i sottoinsiemi scelti da Rabin-Scott.))

Se chiamiamo i bit nell'assegnazione di stato ABCD, quando il simbolo di input è 1, la funzione di transizione è A = A, B = A, C = B, D = C. Quando il simbolo di input è 0, la funzione di transizione è A = A, C = B, D = C. Questa è una funzione di transizione puramente disgiuntiva senza congiunzione o negazione, quindi questa codifica di stato ci dà un NFA. Gli stati nell'NFA corrispondono uno a uno con i bit nella codifica e la funzione di transizione è come data:

Formulazione come problema booleano di soddisfacibilità

La descrizione informale di cui sopra porta direttamente a una codifica come problema booleano di soddisfacibilità. Esiste un insieme di variabili che descrivono le transizioni nell'NFA e un insieme di variabili per la codifica dello stato DFA che verrebbero derivate da Rabin-Scott per l'NFA scelto. Le transizioni del DFA specifico che si sta tentando di decomporre vengono utilizzate per posizionare vincoli sulle transizioni NFA.

Supponiamo di ricevere un DFA con $N$ afferma per una lingua con $S$ simboli e vorremmo derivarne un $M$ stato NFA, con $\lg_2N<M\leq N$. Useremo le variabili$y_{sft}$ per rappresentare le possibili transizioni nell'NFA. $y_{sft}$sarà vero se c'è una transizione nell'NFA dallo stato NFA$f$ allo stato NFA$t$sul simbolo $s$. Nell'esempio precedente NFA, l'alfabeto è di dimensione 2 e ci sono 4 stati NFA, quindi ci sono$SM^2=32$ $y$ variabili e $y_{0AA}, y_{1AA}$, e $y_{1AB}$ sono tutti veri mentre $y_{1DA}$ è falso.

Useremo le variabili $x_{dn}$ per indicare se l'algoritmo Rabin-Scott dovrebbe includere o meno lo stato NFA $n$ nel set di stati che etichettano lo stato DFA $d$. Nell'esempio sopra abbiamo$N=8$ Stati DFA e $M=4$ NFA afferma quindi ci sono 32 $x$variabili. Nell'esempio sopra supponiamo che lo stato più in basso (quello etichettato "1011") sia stato$k$, poi $x_{kA}$, $x_{kC}$, e $x_{kD}$ sono veri mentre $x_{kB}$ è falso.

Ora i vincoli. Prima di tutto, Rabin-Scott deve trovare una codifica diversa per ogni stato DFA, quindi per gli stati DFA$i < j$ e tutti gli stati NFA $\{A,B,\cdots, D\}$:

$$(x_{iA} \neq x_{jA}) + (x_{iB} \neq x_{jB}) + \cdots + (x_{iD} \neq x_{jD}).$$

Quindi deve accadere che se Rabin-Scott trovasse una transizione dallo stato DFA $i$ allo stato DFA $j$ sul simbolo $s$ quindi per ogni stato NFA $k$ incluso nella codifica di $j$ deve esserci uno stato NFA $l$ dalla codifica dello stato DFA $j$ tale che la NFA originale ebbe una transizione da $l$ per $k$. Nell'esempio sopra, sul simbolo "1" c'è una transizione DFA dallo stato DFA "1000" allo stato DFA "1100", quindi deve esserci una transizione NFA dallo stato NFA A agli stati A e B NFA e nessuna transizione NFA da NFA stato A a NFA stato C o D. Quindi per ciascuno dei$o(SN^2)$ bordi nel DFA abbiamo i vincoli:

$$\begin{eqnarray*} x_{jA} & = & y_{sAA} x_{iA} + y_{sBA} x_{iB} + \cdots + y_{sDA} x_{iD} \\ x_{jB} & = & y_{sAB} x_{iA} + y_{sBB} x_{iB} + \cdots + y_{sDB} x_{iD} \\ & & \cdots \\ x_{jD} & = & y_{sAD} x_{iA} + y_{sBD} x_{iB} + \cdots + y_{sDD} x_{iD}. \end{eqnarray*}$$

Infine, dobbiamo affrontare l'inizio e accettare gli stati. Lo stato iniziale di DFA è codificato con l'unione degli stati iniziali di NFA, quindi è meglio non codificare lo stato iniziale di DFA con il set vuoto, quindi$x_0A + x_0B + \cdots + x_0D$. E infine abbiamo bisogno di un insieme di variabili$f_n$per indicare se ogni stato NFA è uno stato di accettazione NFA. È necessario che la codifica per ogni stato di accettazione di DFA contenga almeno uno stato di accettazione di NFA e che la codifica per ogni stato di non accettazione di DFA non contenga stati di accettazione di NFA:$x_{iA}f_A + x_{iB}f_B + \cdots + x_{iD}f_D$ per DFA accetta gli stati $i$ e $\neg (x_{jA}f_A + x_{jB}f_B + \cdots + x_{jD}f_D)$ per gli stati non accettati di DFA $j$.

Ridurre al minimo gli NFA è difficile, tanto difficile che persino l'approssimazione è difficile; vedi Ridurre al minimo NFA e le espressioni regolari di Gramlich e Schnitger (2005). Questo articolo sembra avere anche alcuni riferimenti utili, ad esempio NFA Reduction Algorithms by Means of Regular Inequonies di Champarnaud and Coulon (2002) che contiene tecniche di minimizzazione.

Esistono alcune nozioni di FSA canoniche che non sono necessariamente deterministiche, quindi possono essere più piccole del DFA minimo. Un esempio sono gli FSA "residui", per i quali si possono calcolare gli FSA residui canonici in modo abbastanza diretto, vedere F. Denis, A. Lemay e A. Terlutte. "Automi a stati finiti residui", Fundamenta Informaticae 51 (4): 339-368, 2002 . Esistono diverse alternative.