La conversione di espressioni regolari in NFA (minimo) che accetta la stessa lingua è facile con algoritmi standard, ad esempio l'algoritmo di Thompson . L'altra direzione sembra essere più noiosa, tuttavia, e talvolta le espressioni risultanti sono disordinate.

Quali algoritmi esistono per convertire NFA in espressioni regolari equivalenti? Ci sono vantaggi in termini di complessità temporale o dimensioni dei risultati?

^{Questa dovrebbe essere una domanda di riferimento. Si prega di includere una descrizione generale del metodo e un esempio non banale.}

Esistono diversi metodi per eseguire la conversione da automi finiti a espressioni regolari. Qui descriverò quello che di solito viene insegnato a scuola, che è molto visivo. Credo che sia il più usato in pratica. Tuttavia, scrivere l'algoritmo non è una buona idea.

Metodo di rimozione dello stato

Questo algoritmo riguarda la gestione del grafico dell'automa e non è quindi molto adatto agli algoritmi poiché ha bisogno di primitive grafiche come ... rimozione dello stato. Lo descriverò usando primitivi di livello superiore.

L'idea chiave

L'idea è quella di considerare le espressioni regolari sui bordi e quindi rimuovere gli stati intermedi mantenendo coerenti le etichette dei bordi.

Lo schema principale può essere visto nelle figure seguenti. Il primo ha etichette tra che sono espressioni regolari e , f , g , h , i e vogliamo rimuovere q .$p,q,r$$e,f,g,h,i$$q$

Una volta rimosso, componiamo insieme (preservando gli altri bordi tra p e r ma questo non viene visualizzato su questo):$e,f,g,h,i$$p$$r$

Esempio

Usando lo stesso esempio della risposta di Raffaello :

rimuoviamo successivamente :$q_2$

e quindi :$q_3$

allora dobbiamo ancora applicare una stella sull'espressione da a q 1 . In questo caso, anche lo stato finale è iniziale, quindi è sufficiente aggiungere una stella:$q_1$$q_1$

Algoritmo

L[i,j]è la regexp della lingua da a q j . Innanzitutto, rimuoviamo tutti i bordi multipli:$q_i$$q_j$

for i = 1 to n:
  for j = 1 to n:
    if i == j then:
      L[i,j] := ε
    else:
      L[i,j] := ∅
    for a in Σ:
      if trans(i, a, j):
        L[i,j] := L[i,j] + a

Ora, la rimozione dello stato. Supponiamo di voler rimuovere lo stato :$q_k$

remove(k):
  for i = 1 to n:
    for j = 1 to n:
      L[i,i] += L[i,k] . star(L[k,k]) . L[k,i]
      L[j,j] += L[j,k] . star(L[k,k]) . L[k,j]
      L[i,j] += L[i,k] . star(L[k,k]) . L[k,j]
      L[j,i] += L[j,k] . star(L[k,k]) . L[k,i]

star(ε)=εe.ε=e∅+e=e∅.e=∅$∅$$ε$q k q j q $q_i$$q_k$$q_j$$q_k$

Ora, come si usa remove(k)? Non dovresti rimuovere leggermente gli stati finali o iniziali, altrimenti perderai parti della lingua.

for i = 1 to n:
  if not(final(i)) and not(initial(i)):
    remove(i)

Se hai solo uno stato finale e uno stato iniziale l'espressione finale è:q $q_f$$q_s$

e := star(L[s,s]) . L[s,f] . star(L[f,s] . star(L[s,s]) . L[s,f] + L[f,f])

Se hai diversi stati finali (o addirittura stati iniziali), non esiste un modo semplice di unire questi, se non quello di applicare il metodo di chiusura transitiva. Di solito questo non è un problema a mano ma questo è imbarazzante quando si scrive l'algoritmo. Una soluzione molto più semplice consiste nell'enumerare tutte le coppie ed eseguire l'algoritmo sul grafico (già rimosso dallo stato) per ottenere tutte le espressioni supponendo che sia l'unico stato iniziale e sia l'unico finale stato, quindi facendo l'unione di tutti .e s , f s f e s , $(s,f)$$e_{s,f}$$s$$f$$e_{s,f}$

Questo e il fatto che questo sta modificando i linguaggi in modo più dinamico rispetto al primo metodo lo rendono più soggetto a errori durante la programmazione. Suggerisco di usare qualsiasi altro metodo.

Contro

Ci sono molti casi in questo algoritmo, ad esempio per scegliere quale nodo dovremmo rimuovere, il numero di stati finali alla fine, il fatto che anche uno stato finale può essere iniziale, ecc.

Si noti che ora che l'algoritmo è stato scritto, è molto simile al metodo di chiusura transitiva. Solo il contesto dell'uso è diverso. Non consiglio di implementare l'algoritmo, ma usare il metodo per farlo manualmente è una buona idea.

Metodo

Il metodo più bello che ho visto è quello che esprime l'automa come sistema di equazione di linguaggi (regolari) che può essere risolto. È particolarmente bello in quanto sembra produrre espressioni più concise rispetto ad altri metodi.

Sia un NFA senza -transitions. Per ogni stato , crea l'equazione$A= (Q,\Sigma,\delta,q_0,F)$$\varepsilon$$q_i$

$\qquad \displaystyle Q_i = \bigcup\limits_{q_i \overset{a}{\to} q_j} aQ_j \cup \begin{cases} \{\varepsilon\} &,\ q_i \in F \\ \emptyset &, \text{ else}\end{cases}$

dove è l'insieme degli stati finali e significa che c'è una transizione da a etichettata con . Se leggi come o (a seconda della definizione delle tue espressioni regolari), vedi che questa è un'equazione di espressioni regolari.$F$$q_i \overset{a}{\to} q_j$$q_i$$q_j$$a$$\cup$$+$$\mid$

Per risolvere il sistema sono necessari associatività e distributività di e (concatenazione di stringhe), commutatività di e Lemma di Arden ¹:$\cup$$\cdot$$\cup$

Let linguaggi regolari con . Poi,$L,U,V \subseteq \Sigma^*$$\varepsilon \notin U$

$\qquad \displaystyle L = UL \cup V \quad \Longleftrightarrow \quad L = U^*V$

La soluzione è un insieme di espressioni regolari , una per ogni stato . descrive esattamente quelle parole che possono essere accettate da quando avviato in ; pertanto (se è lo stato iniziale) è l'espressione desiderata.$Q_i$$q_i$$Q_i$$A$$q_i$$Q_0$$q_0$

Esempio

^{Per motivi di chiarezza, denotiamo insiemi singleton per il loro elemento, ovvero . L'esempio è dovuto a Georg Zetzsche.$a = \{a\}$}

Considera questo NFA:

^{[ fonte ]}

Il sistema di equazione corrispondente è:

$\qquad \begin{align} Q_0 &= aQ_1 \cup bQ_2 \cup \varepsilon \\ Q_1 &= bQ_0 \cup aQ_2 \\ Q_2 &= aQ_0 \cup bQ_1 \end{align}$

Ora collega la terza equazione nella seconda:

$\qquad \begin{align} Q_1 &= bQ_0 \cup a(aQ_0 \cup bQ_1) \\ &= abQ_1 \cup (b \cup aa)Q_0 \\ &= (ab)^*(b \cup aa)Q_0 \end{align}$

Per l'ultimo passaggio, applichiamo il Lemma di Arden con , e . Nota che tutte e tre le lingue sono regolari e , permettendoci di applicare il lemma. Ora inseriamo questo risultato nella prima equazione:$L = Q_1$$U = ab$$V = (b \cup aa) \cdot Q_0$$\varepsilon \notin U = \{ab\}$

$\qquad \begin{align} Q_0 &= a(ab)^*(b \cup aa)Q_0 \cup baQ_0 \cup bb(ab)^*(b \cup aa)Q_0 \cup \varepsilon \\ &= ((a \cup bb)(ab)^*(b \cup aa) \cup ba)Q_0 \cup \varepsilon \\ &= ((a \cup bb)(ab)^*(b \cup aa) \cup ba)^* \qquad \text{(by Arden's Lemma)} \end{align}$

Pertanto, abbiamo trovato un'espressione regolare per la lingua accettata dall'automa sopra, vale a dire

$\qquad \displaystyle ((a + bb)(ab)^*(b + aa) + ba)^*.$

Si noti che è abbastanza sintetico (confrontare con il risultato di altri metodi) ma non determinato in modo univoco; risolvere il sistema di equazioni con una diversa sequenza di manipolazioni porta ad altri - equivalenti! - espressioni.

1. Per una prova del Lemma di Arden, vedi qui .

Metodo algebrico di Brzozowski

Questo è lo stesso metodo descritto nella risposta di Raffaello , ma dal punto di vista di un algoritmo sistematico e quindi, in effetti, dell'algoritmo. Risulta facile e naturale da implementare una volta che sai da dove cominciare. Inoltre, potrebbe essere più semplice a mano se il disegno di tutti gli automi è impraticabile per qualche motivo.

Quando scrivi un algoritmo devi ricordare che le equazioni devono essere sempre lineari in modo da avere una buona rappresentazione astratta delle equazioni, cosa che puoi dimenticare quando risolvi a mano.

L'idea dell'algoritmo

Non descriverò come funziona poiché è ben fatto nella risposta di Raffaello che suggerisco di leggere prima. Invece, mi concentro su in quale ordine dovresti risolvere le equazioni senza fare troppi calcoli o casi extra.

Partendo dalla regola di Arden soluzione ingegnosa s' l'equazione lingua possiamo considerare l'automa come un insieme di equazioni della forma:$X=A^*B$$X=AX∪B$

possiamo risolverlo inducendo su aggiornando di conseguenza le matrici e . Al passaggio , abbiamo:$n$$A_{i,j}$$B_{i,j}$$n$

e la regola di Arden ci dà:

e impostando e otteniamo:$B'_n = A_{n,n}^* B_n$$A'_{n,i}=A_{n,n}^*A_{n,i}$

e possiamo quindi rimuovere tutte le esigenze di nel sistema impostando, per :$X_n$$i,j<n$

Quando abbiamo risolto quando , otteniamo un'equazione come questa:$X_n$$n=1$

senza . Così abbiamo ottenuto la nostra espressione regolare.$A'_{1,i}$

L'algoritmo

Grazie a questo, possiamo costruire l'algoritmo. Per avere la stessa convenzione rispetto all'induzione precedente, diremo che lo stato iniziale è e che il numero di stato è . Innanzitutto, l'inizializzazione per riempire :$q_1$$m$$B$

for i = 1 to m:
  if final(i):
    B[i] := ε
  else:
    B[i] := ∅

e :$A$

for i = 1 to m:
  for j = 1 to m:
    for a in Σ:
      if trans(i, a, j):
        A[i,j] := a
      else:
        A[i,j] := ∅

e poi la risoluzione:

for n = m decreasing to 1:
  B[n] := star(A[n,n]) . B[n]
  for j = 1 to n:
    A[n,j] := star(A[n,n]) . A[n,j];
  for i = 1 to n:
    B[i] += A[i,n] . B[n]
    for j = 1 to n:
      A[i,j] += A[i,n] . A[n,j]

l'espressione finale è quindi:

e := B[1]

Implementazione

Anche se può sembrare un sistema di equazioni che sembra troppo simbolico per un algoritmo, questo è adatto per un'implementazione. Ecco un'implementazione di questo algoritmo in Ocaml (link non funzionante) . Nota che, a parte la funzione brzozowski, tutto è da stampare o da usare per l'esempio di Raffaello. Si noti che esiste una funzione sorprendentemente efficiente di semplificazione delle espressioni regolari simple_re.

Metodo di chiusura transitiva

Questo metodo è facile da scrivere in una forma di algoritmo, ma genera espressioni regolari assurdamente grandi ed è poco pratico se lo fai a mano, soprattutto perché è troppo sistematico. È una buona e semplice soluzione per un algoritmo però.

L'idea chiave

Lascia che rappresenti l'espressione regolare per le stringhe che vanno da a usando gli stati . Sia il numero di stati dell'automa.$R^k_{i,j}$$q_i$$q_j$$\{q_1, …, q_k\}$$n$

Supponiamo di conoscere già l'espressione regolare da a senza lo stato intermedio (eccetto le estremità), per tutti . Quindi puoi indovinare come l'aggiunta di un altro stato influirà sulla nuova espressione regolare : cambia solo se hai transizioni dirette a e può essere espresso in questo modo:$R_{i,j}$$q_i$$q_j$$q_k$$i,j$$R'_{i,j}$$q_k$

( è e è .)$R$$R^{k-1}$$R'$$R^k$

Esempio

Useremo lo stesso esempio della risposta di Raffaello . All'inizio, puoi usare solo le transizioni dirette.

Ecco il primo passo (nota che un self loop con un'etichetta avrebbe trasformato il primo in .$a$$ε$$(ε+a)$

Al secondo passo possiamo usare (che è stato rinominato in per noi, perché è già utilizzato per lo scopo sopra). Vedremo come funziona .$q_0$$q_1$$R^0$$R^1$

Da a : .$q_2$$q_2$$R^1_{2,2} = R^0_{2,2} + R^0_{2,1} {R^0_{1,1}}^* R^0_{1,2} = ε + b ε^* a = ε + ba$

Perché? È perché andare da a usando solo come stato intermedio può essere fatto rimanendo qui ( ) o andando a ( ), eseguendo il ciclo lì ( ) e ritornando ( ).$q_2$$q_2$$q_1$$ε$$q_1$$a$$ε^*$$b$

Puoi calcolare anche e , e ti darà l'espressione finale perché è sia iniziale che finale. Nota che qui è stata fatta molta semplificazione delle espressioni. Altrimenti la prima di sarebbe e la prima di sarebbe .$R^2$$R^3$$R^3_{1,1}$$1$$a$$R^0$$(∅+a)$$a$$R^1$$((∅+a)+ε(ε)^*a)$

Algoritmo

Inizializzazione:

for i = 1 to n:
  for j = 1 to n:
    if i == j:
      R[i,j,0] := ε
    else:
      R[i,j,0] := ∅
    for a in Σ:
      if trans(i, a, j):
        R[i,j,0] := R[i,j,0] + a

Chiusura transitiva:

for k = 1 to n:
  for i = 1 to n:
    for j = 1 to n:
      R[i,j,k] := R[i,j,k-1] + R[i,k,k-1] . star(R[k,k,k-1]) . R(k,j,k-1)

Quindi l'espressione finale è (supponendo che sia lo stato iniziale):$q_s$

e := ∅
for i = 1 to n:
  if final(i):
    e := e + R[s,i,n]

Ma puoi immaginare che generi brutte espressioni regolari. Puoi davvero aspettarti cose come che rappresenta la stessa lingua di . Si noti che semplificare un'espressione regolare è utile nella pratica.a $(∅)^*+(a+(∅)^*)(ε)^*(a + ∅)$$aa$