Die Konvertierung regulärer Ausdrücke in (minimale) NFA, die dieselbe Sprache akzeptieren, ist mit Standardalgorithmen, z . B. dem Thompson-Algorithmus, einfach . Die andere Richtung scheint jedoch langweiliger zu sein, und manchmal sind die resultierenden Ausdrücke chaotisch.

Welche Algorithmen gibt es, um NFA in gleichwertige reguläre Ausdrücke umzuwandeln? Gibt es Vorteile hinsichtlich Zeitaufwand oder Ergebnisgröße?

^{Dies soll eine Referenzfrage sein. Bitte fügen Sie eine allgemeine Beschreibung Ihrer Methode sowie ein nicht triviales Beispiel bei.}

Es gibt verschiedene Methoden, um die Konvertierung von endlichen Automaten in reguläre Ausdrücke durchzuführen. Hier werde ich diejenige beschreiben, die normalerweise in der Schule unterrichtet wird und die sehr visuell ist. Ich glaube, es wird in der Praxis am häufigsten verwendet. Das Schreiben des Algorithmus ist jedoch keine so gute Idee.

Methode zum Entfernen des Zustands

Dieser Algorithmus behandelt den Graphen des Automaten und ist daher für Algorithmen nicht sehr geeignet, da er Graphprimitive wie ... state removal benötigt. Ich werde es mit übergeordneten Primitiven beschreiben.

Die Schlüsselidee

Die Idee ist, reguläre Ausdrücke an Kanten zu berücksichtigen und dann Zwischenzustände zu entfernen, während die Kantenbeschriftungen konsistent bleiben.

Das Hauptmuster lässt sich im Folgenden an Figuren ablesen. Die erste hat Bezeichnungen zwischen , die reguläre Ausdrücke e , f , g , h , i sind, und wir möchten q entfernen .$p,q,r$$e,f,g,h,i$$q$

Nach dem Entfernen setzen wir zusammen (wobei die anderen Kanten zwischen p und r erhalten bleiben , dies wird hier jedoch nicht angezeigt):$e,f,g,h,i$$p$$r$

Beispiel

Verwenden Sie dasselbe Beispiel wie in Raffaels Antwort :

wir entfernen nacheinander :$q_2$

und dann :$q_3$

dann müssen wir noch einen Stern auf den Ausdruck von bis q 1 anwenden . In diesem Fall ist der Endzustand ebenfalls initial, so dass wir wirklich nur einen Stern hinzufügen müssen:$q_1$$q_1$

Algorithmus

L[i,j]ist der Ausdruck der Sprache von bis q j . Zuerst entfernen wir alle Mehrkanten:$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

Nun ist die staatliche Entfernung. Angenommen, wir möchten den Zustand entfernen :$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 i q k q j q $ε$$q_i$$q_k$$q_j$$q_k$

Nun, wie benutzt man remove(k)? Sie sollten End- oder Anfangszustände nicht leichtfertig entfernen, da Sie sonst Teile der Sprache vermissen.

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

Wenn Sie nur einen Endzustand und einen Anfangszustand der :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])

Wenn Sie mehrere Endzustände (oder sogar Anfangszustände) haben, gibt es keine einfache Möglichkeit zum Zusammenführen dieser Zustände außer der Anwendung der transitiven Abschlussmethode. Normalerweise ist dies kein Problem von Hand, aber beim Schreiben des Algorithmus ist dies umständlich. Eine viel einfachere Problemumgehung besteht darin, alle Paare und den Algorithmus im (bereits vom Status entfernten) Diagramm auszuführen, um alle Ausdrücke abzurufen, wobei angenommen wird , dass der einzige Anfangszustand und der einzige Endzustand ist state, dann mache die Vereinigung aller .e s , f s f e s , $(s,f)$$e_{s,f}$$s$$f$$e_{s,f}$

Dies und die Tatsache, dass dadurch Sprachen dynamischer geändert werden als bei der ersten Methode, machen sie beim Programmieren fehleranfälliger. Ich schlage vor, eine andere Methode zu verwenden.

Nachteile

In diesem Algorithmus gibt es viele Fälle, zum Beispiel, um auszuwählen, welchen Knoten wir entfernen möchten, wie viele Endzustände am Ende vorliegen, ob ein Endzustand auch anfänglich sein kann usw.

Beachten Sie, dass dieser Algorithmus jetzt, da er geschrieben wurde, der Methode der transitiven Schließung sehr ähnlich ist. Lediglich der Kontext der Nutzung ist unterschiedlich. Ich empfehle nicht, den Algorithmus zu implementieren, aber es ist eine gute Idee, die Methode manuell zu verwenden.

Methode

Die schönste Methode, die ich gesehen habe, ist eine, die den Automaten als Gleichungssystem von (regulären) Sprachen ausdrückt, die gelöst werden können. Es ist besonders schön, da es prägnantere Ausdrücke liefert als andere Methoden.

Sei eine NFA ohne -Übergänge. Erstellen Sie für jeden Zustand die Gleichung$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}$

wobei die Menge der Endzustände und bedeutet , es ist ein Übergang von mit markiertem . Wenn Sie als oder lesen (abhängig von der Definition Ihres regulären Ausdrucks), sehen Sie, dass dies eine Gleichung für reguläre Ausdrücke ist.$F$$q_i \overset{a}{\to} q_j$$q_i$$q_j$$a$$\cup$$+$$\mid$

Zur Lösung des Systems benötigen Sie Assoziativität und Verteilungsfähigkeit von und (String-Verkettung), Kommutativität von und Ardens Lemma ¹:$\cup$$\cdot$$\cup$

Lassen reguläre Sprachen mit . Dann,$L,U,V \subseteq \Sigma^*$$\varepsilon \notin U$

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

Die Lösung ist eine Menge von regulären Ausdrücken , einer für jeden Zustand . beschreibt genau die Wörter, die von akzeptiert werden können, wenn es in gestartet ; daher ist (wenn der Anfangszustand ist) der gewünschte Ausdruck.$Q_i$$q_i$$Q_i$$A$$q_i$$Q_0$$q_0$

Beispiel

^{Der Übersichtlichkeit halber bezeichnen wir Singleton-Mengen nach ihrem Element, dh . Das Beispiel stammt von Georg Zetzsche.$a = \{a\}$}

Betrachten Sie diese NFA:

^{[ Quelle ]}

Das entsprechende Gleichungssystem lautet:

$\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}$

Stecken Sie nun die dritte Gleichung in die zweite:

$\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}$

Für den letzten Schritt wenden wir Ardens Lemma mit , und . Beachten Sie, dass alle drei Sprachen regulär sind und , sodass wir das Lemma anwenden können. Nun stecken wir dieses Ergebnis in die erste Gleichung:$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}$

Somit haben wir einen regulären Ausdruck für die Sprache gefunden, die vom obigen Automaten akzeptiert wird, nämlich

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

Beachten Sie, dass es ziemlich prägnant ist (vergleiche mit dem Ergebnis anderer Methoden), aber nicht eindeutig bestimmt wird. Lösen des Gleichungssystems mit einer anderen Reihenfolge von Manipulationen führt zu einem anderen Äquivalent! - Ausdrücke.

1. Einen Beweis für Ardens Lemma finden Sie hier .

Brzozowski algebraische Methode

Dies ist die gleiche Methode wie die in Raphaels Antwort beschriebene , jedoch unter dem Gesichtspunkt eines systematischen Algorithmus und dann tatsächlich des Algorithmus. Die Implementierung gestaltet sich einfach und natürlich, sobald Sie wissen, wo Sie anfangen sollen. Es kann auch von Hand einfacher sein, wenn das Zeichnen aller Automaten aus irgendeinem Grund unpraktisch ist.

Wenn Sie einen Algorithmus schreiben, müssen Sie bedenken, dass die Gleichungen immer linear sein müssen, damit Sie eine gute abstrakte Darstellung der Gleichungen erhalten, was Sie beim Lösen von Hand vergessen können.

Die Idee des Algorithmus

Ich werde nicht beschreiben, wie es funktioniert, da es in Raphaels Antwort, die ich vorher lesen möchte, gut gemacht ist. Stattdessen konzentriere ich mich darauf, in welcher Reihenfolge Sie die Gleichungen lösen sollten, ohne zu viele zusätzliche Berechnungen oder zusätzliche Fälle durchzuführen.

Ausgehend von Ardens genialer Lösung zur wir den Automaten als eine Menge von Gleichungen der Form betrachten:$X=A^*B$$X=AX∪B$

Wir können dies durch Induktion auf lösen, indem wir die Arrays und entsprechend aktualisieren . Im Schritt haben wir:$n$$A_{i,j}$$B_{i,j}$$n$

und Ardens Regel gibt uns:

und durch Setzen von und wir:$B'_n = A_{n,n}^* B_n$$A'_{n,i}=A_{n,n}^*A_{n,i}$

und wir können dann alle Bedürfnisse von im System entfernen , indem wir für :$X_n$$i,j<n$

A ' i , j = A i , j + A i , n A ' n ,

Wenn wir mit gelöst haben , erhalten wir eine Gleichung wie folgt: n = $X_n$$n=1$

ohne . So haben wir unseren regulären Ausdruck bekommen.$A'_{1,i}$

Der Algorithmus

Dank dessen können wir den Algorithmus erstellen. Um die gleiche Konvention wie in der obigen Induktion zu haben, werden wir sagen, dass der Anfangszustand und dass die Anzahl der . Zuerst die Initialisierung zum Füllen von : m $q_1$$m$$B$

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

und :$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] := ∅

und dann die Lösung:

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]

Der endgültige Ausdruck lautet dann:

e := B[1]

Implementierung

Auch wenn es ein Gleichungssystem zu sein scheint, das für einen Algorithmus zu symbolisch erscheint, eignet sich dieses System gut für eine Implementierung. Hier ist eine Implementierung dieses Algorithmus in Ocaml (defekter Link) . Beachten Sie, dass bis auf die Funktion brzozowskialles gedruckt oder für Raffaels Beispiel verwendet werden soll. Beachten Sie, dass es eine überraschend effiziente Funktion zur Vereinfachung regulärer Ausdrücke gibt simple_re.

Transitive Verschlussmethode

Diese Methode ist einfach in Form eines Algorithmus zu schreiben, generiert jedoch absurd große reguläre Ausdrücke und ist unpraktisch, wenn Sie sie von Hand ausführen, meistens, weil dies zu systematisch ist. Es ist jedoch eine gute und einfache Lösung für einen Algorithmus.

Die Schlüsselidee

$R^k_{i,j}$$q_i$$q_j$$\{q_1, …, q_k\}$$n$

$R_{i,j}$$q_i$$q_j$$q_k$$i,j$$R'_{i,j}$$q_k$

$R$$R^{k-1}$$R'$$R^k$

Beispiel

Wir werden dasselbe Beispiel wie in Raphaels Antwort verwenden . Zunächst können Sie nur die direkten Übergänge verwenden.

$a$$ε$$(ε+a)$

$q_0$$q_1$$R^0$$R^1$

$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$

$q_2$$q_2$$q_1$$ε$$q_1$$a$$ε^*$$b$

$R^2$$R^3$$R^3_{1,1}$$1$$a$$R^0$$(∅+a)$$a$$R^1$$((∅+a)+ε(ε)^*a)$

Algorithmus

Initialisierung:

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

Transitive Schließung:

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)

$q_s$

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

$(∅)^*+(a+(∅)^*)(ε)^*(a + ∅)$$aa$