Come creare DFA dall'espressione regolare senza utilizzare NFA?

12

L'obiettivo è quello di creare DFA da un'espressione regolare e l'utilizzo di "Exp regolare> NFA> Conversione DFA" non è un'opzione. Come si dovrebbe fare per farlo?

Ho fatto questa domanda al nostro professore ma mi ha detto che possiamo usare l'intuizione e gentilmente rifiutato di fornire qualsiasi spiegazione. Quindi volevo chiederti.

"Conversione regolare> NFA> Conversione DFA" non è un'opzione perché una tale conversione richiede molto tempo per convertire un'espressione regolare piuttosto complessa. Ad esempio, per un certo regex "regex> NFA> DFA" richiede 1 ora per un essere umano. Devo convertire regex in DFA in meno di 30 minuti.

— Raffaello
fonte

2

Devi fornire più contesto. Quale algoritmo (informale) stai attualmente utilizzando per tradurre espressioni regolari? Potrebbe essere utile spiegare il processo con un esempio come a(a|ab|ac)*a+. Puoi tradurlo direttamente in un NDFA che riduci in un DFA, oppure puoi normalizzarlo in qualcosa che si associa immediatamente a un DFA.

— amon

Devi farlo su esempi specifici con qualsiasi mezzo o devi fornire una procedura generale per essere applicato da un computer?

— babou,

18

Dato che vuoi "convertire regex in DFA in meno di 30 minuti", suppongo che tu stia lavorando a mano su esempi relativamente piccoli.

In questo caso puoi usare l'algoritmo di Brzozowski , che calcola direttamente l'automa Nerode di una lingua (che è noto essere uguale al suo automa deterministico minimo). Si basa su un calcolo diretto dei derivati e funziona anche per espressioni regolari estese che consentono l'intersezione e la complementazione. Lo svantaggio di questo algoritmo è che richiede di verificare l'equivalenza delle espressioni calcolate lungo la strada, un processo costoso. Ma in pratica, e per piccoli esempi, è molto efficiente. $[1]$

Quozienti a sinistra . Let sia un linguaggio di e lasciare che essere una parola. Allora Il linguaggio è chiamato un quoziente di sinistra (o sinistra derivato ) di . $L$ $A^*$ $u$

u^{- 1} L = {v \in {UN}^{*} | u v \in L}

$u^{-1}L = \{v \in A^* \mid uv \in L \}$

u^{- 1} L

$u^{-1}L$

L

$L$

Automa di Nerode . L' automa Nerode di è l'automa deterministico dove , e la funzione di transizione è definita, per ogni , dalla formula Attenzione a questa definizione piuttosto astratta. Ogni stato di è un quoziente sinistro di di una parola, e quindi è una lingua di . Lo stato iniziale è la lingua , e l'insieme degli stati finali è l'insieme di tutti i quozienti di sinistra di $L$ $\mathcal{A}(L) = (Q, A, \cdot, L, F)$ $Q = \{u^{-1}L \mid u \in A^*\}$ $F = \{u^{-1}L \mid u \in L\}$ $a \in A$

(u^{- 1} L) \cdot un' = {un'}^{- 1} (u^{- 1} L) = (u un')^{- 1} L

$(u^{-1}L)\cdot a = a^{-1}(u^{-1}L)=(ua)^{-1}L$

A

$\mathcal{A}$

L

$L$

A^{*}

$A^*$

L

$L$

L

$L$ per una parola di .

L

$L$

L'algoritmo di Brzozowski . Lascia che siano lettere. Si possono calcolare i quozienti di sinistra usando le seguenti formule: $a, b$

\begin{aligned} {un'}^{- 1} 1 & = 0 & {un'}^{- 1} B & = {\begin{cases} 1 & Se un' = B \\ 0 & Se un' \neq B \end{cases} \\ {un'}^{- 1} (L_{1} \cup L_{2}) & = {un'}^{- 1} L_{1} \cup u^{- 1} L_{2}, & {un'}^{- 1} (L_{1} ∖ L_{2}) & = {un'}^{- 1} L_{1} ∖ u^{- 1} L_{2}, \\ {un'}^{- 1} (L_{1} \cap L_{2}) & = {un'}^{- 1} L_{1} \cap u^{- 1} L_{2}, & {un'}^{- 1} L^{*} & = ({un'}^{- 1} L) L^{*} \end{aligned}

$\begin{align*} a^{-1}1 &= 0 & a^{-1}b &= \begin{cases} 1 &\text{if $a = b$}\\ 0 &\text{if $a \not= b$}\\ \end{cases}\\ a^{-1}(L_1 \cup L_2) &= a^{-1}L_1 \cup u^{-1}L_2,& a^{-1}(L_1 \setminus L_2) &= a^{-1}L_1 \setminus u^{-1}L_2,\\ a^{-1}(L_1 \cap L_2) &= a^{-1}L_1 \cap u^{-1}L_2, & a^{-1}L^* &= (a^{-1}L)L^* \end{align*}$

\begin{aligned} {un'}^{- 1} (L_{1} L_{2}) & = {\begin{cases} ({un'}^{- 1} L_{1}) L_{2} & SI 1 \notin L_{1}, \\ ({un'}^{- 1} L_{1}) L_{2} \cup {un'}^{- 1} L_{2} & SI 1 \in L_{1} \end{cases} \end{aligned}

$\begin{align*} a^{-1}(L_1L_2) &= \begin{cases} (a^{-1}L_1)L_2 &\text{si $1 \notin L_1$,}\\ (a^{-1}L_1)L_2 \cup a^{-1}L_2 &\text{si $1 \in L_1$}\\ \end{cases}\\ %\\v^{-1}(u^{-1}L) &= (uv)^{-1}L. \end{align*}$

Esempio . Per , otteniamo in successione: che fornisce il seguente automa minimo. $L = (a(ab)^*)^* \cup (ba)^*$

\begin{aligned} 1^{- 1} L & = L = L_{1} \\ {un'}^{- 1} L_{1} & = (un' B)^{*} (un' (un' B)^{*})^{*} = L_{2} \\ B^{- 1} L_{1} & = un' (B un')^{*} = L_{3} \\ {un'}^{- 1} L_{2} & = B (un' B)^{*} (un' (un' B)^{*})^{*} \cup (un' B)^{*} (un' (un' B)^{*})^{*} = B L_{2} \cup L_{2} = L_{4} \\ B^{- 1} L_{2} & = \emptyset \\ {un'}^{- 1} L_{3} & = (B un')^{*} = L_{5} \\ B^{- 1} L_{3} & = \emptyset \\ {un'}^{- 1} L_{4} & = {un'}^{- 1} (B L_{2} \cup L_{2}) = {un'}^{- 1} L_{2} = L_{4} \\ B^{- 1} L_{4} & = B^{- 1} (B L_{2} \cup L_{2}) = L_{2} \cup B^{- 1} L_{2} = L_{2} \\ {un'}^{- 1} L_{5} & = \emptyset \\ B^{- 1} L_{5} & = un' (B un')^{*} = L_{3} \end{aligned}

$\begin{align*} 1^{-1}L &= L=L_1\\ a^{-1}L_1 &=(ab)^*(a(ab)^*)^*=L_2\\ b^{-1}L_1 &= a(ba)^*=L_3\\ a^{-1}L_2 &= b(ab)^*(a(ab)^*)^* \cup (ab)^*(a(ab)^*)^*=bL_2 \cup L_2=L_4\\ b^{-1}L_2 &=\emptyset \\ a^{-1}L_3 &=(ba)^*=L_5\\ b^{-1}L_3 &=\emptyset \\ a^{-1}L_4 &= a^{-1}(bL_2 \cup L_2)=a^{-1}L_2=L_4 \\ b^{-1}L_4 &= b^{-1}(bL_2 \cup L_2)= L_2\cup b^{-1}L_2 = L_2 \\ a^{-1}L_5 &= \emptyset\\ b^{-1}L_5 &=a(ba)^*=L_3 \end{align*}$ L'automa minimo

$[1]$ J. Brzozowski, Derivatives of Regular Expressions, J.ACM 11 (4), 481–494, 1964.

Modifica . (5 aprile 2015) Ho appena scoperto che una domanda simile: quali algoritmi esistono per la costruzione di un DFA che riconosce il linguaggio descritto da una data regex? è stato chiesto su cstheory. La risposta affronta in parte i problemi di complessità.

— J.-E. perno
fonte

Puoi dire di più sulla complessità di questo algoritmo?

— babou,

@babou La conversione di un RE in un DFA è difficile per PSPACE, quindi è sicuramente esponenziale.

— jmite,

Questo dovrebbe probabilmente andare nella risposta. L'OP inizia con "le costruzioni standard tramite NFA sono troppo lente" e parte della risposta sembra essere "sfortuna, non c'è davvero una soluzione rapida". Resta da discutere se questo qui sia migliore della costruzione standard. (cc @jmite)

— Raffaello

@jmite Sì, me lo aspettavo. Il motivo della mia domanda è perché questo modo di costruire il DFA dovrebbe quindi essere considerato più semplice. (nota: il sistema ha impiegato un giorno intero per avvisarmi della risposta di @ jmite).

— babou,

2

J.-E. Pin fornisce la risposta migliore in termini di formalità e completezza, ma penso che ci sia qualcosa da dire per l '"intuizione" a cui il tuo professore sta suggerendo.

Nella maggior parte di questi casi, la cosa più semplice da fare è guardare un'espressione regolare, capire quale linguaggio sta accettando, quindi usare la tua creatività / intelligenza per costruire un DFA che accetta quel linguaggio.

Non esiste un modo semplice per farlo, a parte gli algoritmi forniti da altri, ma ecco alcune linee guida che potrebbero rivelarsi utili.

Chiediti, potrei scrivere un programma che accetta questo RE usando solo variabili intere booleane o molto piccole? Quindi scrivi quel programma e convertilo in un DFA dove c'è uno stato per ogni combinazione di valori.
Cerca parti dell'espressione regolare che sai di poter accettare in modo deterministico, dove sai "Se vedo questo, allora devo abbinare questa parte della RE". Non ce ne saranno sempre tonnellate, ma l'identificazione di queste parti può mostrare le parti che saranno facili da creare un DFA, in modo da poter dedicare più tempo alle parti che richiedono davvero non determinismo.
La costruzione del sottoinsieme per NFA-> DFA non è in realtà così complicata da un algoritmo. Quindi, se si tratta di un compito, non di una domanda d'esame, potrebbe essere più veloce codificare un'implementazione e consentire al programma di convertire NFA in DFA. Se hai usato il tuo codice, non dovrebbero esserci problemi di plagio.

Ricorda che, qualunque cosa tu faccia, qualsiasi tecnica esploderà esponenzialmente nel peggiore dei casi (a meno che non trovi un algoritmo polinomiale per questo, nel qual caso, congratulazioni, hai dimostrato e ora sei un milionario .) $P=NP=PSPACE$

Prova a "guardare avanti", taglia gli angoli quando puoi usare la tua intuizione in luoghi in cui l'algoritmo richiederebbe molti passaggi ma il suo risultato è chiaro.

— jmite
fonte

-2

Anche se questo non è il modo corretto ma funziona il più delle volte.

Primo passo : trova la stringa più piccola che può essere accettata dall'espressione regolare. Secondo passaggio : disegnare gli stati necessari con la transazione della macchina che accetta la stringa minima. Terzo passaggio : per tutti gli stati disegnare le rimanenti transazioni alfabetiche.

Ad esempio: Regular Expression (0 + 1) * 1 "String che termina con 1" Step 1: String più piccola: 1 Step 2: due stati Q0 e Q1. avendo la transazione di 1 da Q0 a Q1. e Q1 è lo stato accettante. Passaggio 3: per lo stato Q0, la transazione Q0 1 è relativa a Q1. Ora esegui 0 transazioni nel Q0 stesso. Per Q1 State, la transazione Q1 1 rimarrà nel Q1. E 0 transazione andrà nel Q0.

— Naveen CS
fonte