Wie erstelle ich DFA aus regulären Ausdrücken ohne Verwendung von NFA?

12

Ziel ist es, DFA aus einem regulären Ausdruck zu erstellen, und die Verwendung von "Regular exp> NFA> DFA-Konvertierung" ist keine Option. Wie soll man das machen?

Ich stellte diese Frage unserem Professor, aber er sagte mir, dass wir Intuition benutzen können und lehnte es freundlicherweise ab, Erklärungen abzugeben. Also wollte ich dich fragen.

"Regular exp> NFA> DFA conversion" ist keine Option, da eine solche Konvertierung viel Zeit in Anspruch nimmt, um einen recht komplexen regulären Ausdruck zu konvertieren. Beispielsweise dauert für einen bestimmten Ausdruck "Regex> NFA> DFA" 1 Stunde für einen Menschen. Ich muss Regex in weniger als 30 Minuten in DFA konvertieren.

— Raphael
quelle

2

Sie müssen mehr Kontext bereitstellen. Mit welchem (informellen) Algorithmus übersetzen Sie derzeit reguläre Ausdrücke? Es kann hilfreich sein, Ihren Prozess an einem Beispiel wie dem folgenden zu erläutern a(a|ab|ac)*a+. Sie können dies entweder direkt in einen NDFA übersetzen, den Sie in einen DFA reduzieren, oder Sie können ihn auf etwas normalisieren, das sofort einem DFA zugeordnet wird.

— amon

Müssen Sie dies an konkreten Beispielen mit welchen Mitteln auch immer tun, oder müssen Sie ein allgemeines Verfahren angeben, um von einem Computer angewendet zu werden?

— Babou

18

Da Sie "Regex in weniger als 30 Minuten in DFA konvertieren" möchten, arbeiten Sie vermutlich von Hand an relativ kleinen Beispielen.

In diesem Fall können Sie den Brzozowski-Algorithmus , der direkt den Nerode-Automaten einer Sprache berechnet (von dem bekannt ist, dass er dem minimalen deterministischen Automaten entspricht). Es basiert auf einer direkten Berechnung der Ableitungen und funktioniert auch für erweiterte reguläre Ausdrücke, die eine Schnittmenge und Ergänzung ermöglichen. Der Nachteil dieses Algorithmus besteht darin, dass die Äquivalenz der dabei berechneten Ausdrücke überprüft werden muss. Dies ist ein teurer Prozess. Aber in der Praxis und für kleine Beispiele ist es sehr effizient. $[1]$

Linke Quotienten . Sei eine Sprache von und sei ein Wort. Dann Die Sprache einen aufgerufen wird linken Quotient (oder links Derivat ) von . $L$ $A^*$ $u$

u^{- 1} L = {v \in {EIN}^{*} ∣ u v \in L}

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

u^{- 1} L

$u^{-1}L$

L

$L$

Nerode-Automat . Der Nerode Automat von ist die deterministische Automat , wobei , und die Übergangsfunktion wird für jedes $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\}$ , nach der Formel Hüten Sie sich vor dieser eher abstrakten Definition. Jeder Zustand von ist ein linker Quotient von durch ein Wort und daher eine Sprache von . Der Ausgangszustand ist die Sprache , und der Satz von Endzuständen ist die Menge aller linken Quotienten von durch ein Wort von . $a \in A$

(u^{- 1} L) \cdot ein = {ein}^{- 1} (u^{- 1} L) = (u ein)^{- 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$

L

$L$

$a, b$

\begin{aligned} {ein}^{- 1} 1 & = 0 & {ein}^{- 1} b & = {\begin{cases} 1 & wenn ein = b \\ 0 & wenn ein \neq b \end{cases} \\ {ein}^{- 1} (L_{1} \cup L_{2}) & = {ein}^{- 1} L_{1} \cup u^{- 1} L_{2}, & {ein}^{- 1} (L_{1} ∖ L_{2}) & = {ein}^{- 1} L_{1} ∖ u^{- 1} L_{2}, \\ {ein}^{- 1} (L_{1} \cap L_{2}) & = {ein}^{- 1} L_{1} \cap u^{- 1} L_{2}, & {ein}^{- 1} L^{*} & = ({ein}^{- 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} {ein}^{- 1} (L_{1} L_{2}) & = {\begin{cases} ({ein}^{- 1} L_{1}) L_{2} & si 1 \notin L_{1}, \\ ({ein}^{- 1} L_{1}) L_{2} \cup {ein}^{- 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*}$

$L = (a(ab)^*)^* \cup (ba)^*$

\begin{aligned} 1^{- 1} L & = L = L_{1} \\ {ein}^{- 1} L_{1} & = (ein b)^{*} (ein (ein b)^{*})^{*} = L_{2} \\ b^{- 1} L_{1} & = ein (b ein)^{*} = L_{3} \\ {ein}^{- 1} L_{2} & = b (ein b)^{*} (ein (ein b)^{*})^{*} \cup (ein b)^{*} (ein (ein b)^{*})^{*} = b L_{2} \cup L_{2} = L_{4} \\ b^{- 1} L_{2} & = \emptyset \\ {ein}^{- 1} L_{3} & = (b ein)^{*} = L_{5} \\ b^{- 1} L_{3} & = \emptyset \\ {ein}^{- 1} L_{4} & = {ein}^{- 1} (b L_{2} \cup L_{2}) = {ein}^{- 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} \\ {ein}^{- 1} L_{5} & = \emptyset \\ b^{- 1} L_{5} & = ein (b ein)^{*} = 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*}$ Der minimale Automat

$[1]$

Bearbeiten . (5. April 2015) Ich habe gerade eine ähnliche Frage entdeckt: Welche Algorithmen gibt es für die Erstellung eines DFA, der die von einem bestimmten Regex beschriebene Sprache erkennt? wurde auf cstheory gefragt. Die Antwort befasst sich teilweise mit Komplexitätsproblemen.

— J.-E. Stift
quelle

Können Sie mehr über die Komplexität dieses Algorithmus sagen?

— Babou

@babou Das Umwandeln eines RE in einen DFA ist PSPACE-schwer, also definitiv exponentiell.

— jmite

Dies sollte wahrscheinlich in die Antwort gehen. Das OP beginnt mit "Die Standardkonstruktionen über NFA sind zu langsam" und ein Teil der Antwort scheint "Pech, es gibt keine wirklich schnelle Lösung" zu sein. Es bleibt zu diskutieren, ob dies hier besser ist als die Standardkonstruktion. (cc @jmite)

— Raphael

@jmite Ja, das habe ich erwartet. Der Grund für meine Frage ist, warum diese Art der Erstellung des DFA dann als einfacher angesehen werden sollte. (Hinweis: Das System hat einen ganzen Tag gebraucht, um mich über die @ jmite-Antwort zu benachrichtigen.)

— Babou

2

J.-E. Pin liefert die bessere Antwort in Bezug auf Formalität und Vollständigkeit, aber ich denke, es gibt etwas zu sagen für die "Intuition", auf die Ihr Professor hinweist.

In den meisten Fällen ist es am einfachsten, einen regulären Ausdruck zu betrachten, zu verstehen, welche Sprache akzeptiert wird, und dann mit Ihrer Kreativität / Cleverness einen DFA zu erstellen, der diese Sprache akzeptiert.

Es gibt keinen einfachen Weg, dies zu tun, außer den Algorithmen, die andere gegeben haben, aber hier sind einige Richtlinien, die sich als nützlich erweisen könnten.

Stellen Sie sich die Frage, ob ich ein Programm schreiben kann, das diese RE nur mit booleschen oder sehr kleinen Integer-Variablen akzeptiert. Schreiben Sie dann dieses Programm und konvertieren Sie es in einen DFA, in dem für jede Wertekombination ein Status angegeben ist.
Suchen Sie nach Teilen des regulären Ausdrucks, von denen Sie wissen, dass Sie ihn deterministisch akzeptieren können, wobei Sie wissen: "Wenn ich das sehe, muss ich mit diesem Teil der RE übereinstimmen." Es wird nicht immer Unmengen davon geben, aber das Identifizieren dieser Teile kann zeigen, welche Teile leicht zu einem DFA werden, sodass Sie mehr Zeit mit den Teilen verbringen können, die wirklich Nichtdeterminismus erfordern.
Die Teilmengenkonstruktion für NFA-> DFA ist eigentlich nicht so kompliziert wie ein Algorithmus. Wenn es sich also um eine Aufgabe und nicht um eine Prüfungsfrage handelt, ist es möglicherweise schneller, eine Implementierung zu codieren und Ihr Programm NFA in DFA konvertieren zu lassen. Wenn Sie Ihren eigenen Code verwendet haben, sollte es keine Probleme mit dem Plagarismus geben.

$P=NP=PSPACE$

Versuchen Sie, nach vorne zu schauen, und schneiden Sie Ecken ab, wenn Sie Ihre Intuition an Stellen einsetzen können, an denen der Algorithmus viele Schritte erfordern würde, das Ergebnis jedoch klar ist.

— jmite
quelle

-2

Dies ist zwar nicht der richtige Weg, funktioniert aber die meiste Zeit.

Erster Schritt : Suchen Sie die kleinste Zeichenfolge, die vom regulären Ausdruck akzeptiert werden kann. Zweiter Schritt : Zeichnen Sie die erforderlichen Zustände mit der Transaktion des Mindestautomaten für die Zeichenkettenannahme. Dritter Schritt : Zeichnen Sie für alle Status die verbleibenden Alphabet-Transaktionen.

Zum Beispiel: Regulärer Ausdruck (0 + 1) * 1 "Zeichenfolge endet mit 1" Schritt 1: Kleinste Zeichenfolge: 1 Schritt 2: Zwei Zustände Q0 und Q1. mit der Transaktion von 1 von Q0 bis Q1. und Q1 ist der akzeptierende Zustand. Schritt 3: für Q0 Status Q0 1 Transaktion ist zu Q1. Machen Sie jetzt 0 Transaktion in Q0 selbst. Für Q1 State Q1 1 bleibt die Transaktion in Q1. Und 0 Transaktion wird in Q0 gehen.

— Naveen CS
quelle