Comment créer DFA à partir d'une expression régulière sans utiliser NFA?

12

L'objectif est de créer DFA à partir d'une expression régulière et l'utilisation de "Exp régulière> NFA> Conversion DFA" n'est pas une option. Comment faut-il s'y prendre?

J'ai posé cette question à notre professeur mais il m'a dit que nous pouvions utiliser l'intuition et a gentiment refusé de fournir des explications. Je voulais donc vous demander.

"Regular exp> NFA> DFA conversion" n'est pas une option car une telle conversion prend beaucoup de temps pour convertir une expression régulière plutôt complexe. Par exemple, pour un certain regex "regex> NFA> DFA" prend 1 heure pour un être humain. J'ai besoin de convertir regex en DFA en moins de 30 minutes.

— Raphael
source

2

Vous devez fournir plus de contexte. Quel algorithme (informel) utilisez-vous actuellement pour traduire les expressions régulières? Il pourrait être utile d'expliquer votre processus avec un exemple tel que a(a|ab|ac)*a+. Vous pouvez soit traduire cela directement en NDFA que vous réduisez en DFA, soit le normaliser en quelque chose qui correspond immédiatement à un DFA.

— amon

Devez-vous le faire sur des exemples spécifiques par quelque moyen que ce soit, ou devez-vous fournir une procédure générale à appliquer par un ordinateur?

— babou

18

Puisque vous voulez "convertir des regex en DFA en moins de 30 minutes", je suppose que vous travaillez à la main sur des exemples relativement petits.

Dans ce cas, vous pouvez utiliser l'algorithme de Brzozowski , qui calcule directement l'automate Nérode d'un langage (connu pour être égal à son automate déterministe minimal). Il est basé sur un calcul direct des dérivées et fonctionne également pour les expressions régulières étendues permettant l'intersection et la complémentation. L'inconvénient de cet algorithme est qu'il nécessite de vérifier l'équivalence des expressions calculées en cours de route, un processus coûteux. Mais en pratique, et pour les petits exemples, c'est très efficace. $[1]$

Quotients de gauche . Soit un langage de et soit un mot. Alors La langue est appelé quotient gauche (ou à gauche dérivé ) de . $L$ $A^*$ $u$

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

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

u^{- 1} L

$u^{-1}L$

L

$L$

Automate Nérode . L' automate nérode de est l'automate déterministe où , et la fonction de transition est définie, pour chacun $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\}$ , par la formule Attention à cette définition plutôt abstraite. Chaque état de est un quotient gauche de par un mot, et est donc un langage de . L'état initial est la langue , et l'ensemble des états finaux est l'ensemble de tousquotients gauche de par un mot de . $a \in A$

(u^{- 1} L) \cdot a = a^{- 1} (u^{- 1} L) = (u a)^{- 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} a^{- 1} 1 & = 0 & a^{- 1} b & = {\begin{cases} 1 & if a = b \\ 0 & if a \neq b \end{cases} \\ a^{- 1} (L_{1} \cup L_{2}) & = a^{- 1} L_{1} \cup u^{- 1} L_{2}, & a^{- 1} (L_{1} ∖ L_{2}) & = a^{- 1} L_{1} ∖ 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{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} a^{- 1} (L_{1} L_{2}) & = {\begin{cases} (a^{- 1} L_{1}) L_{2} & si 1 \notin L_{1}, \\ (a^{- 1} L_{1}) L_{2} \cup a^{- 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} \\ a^{- 1} L_{1} & = (a b)^{*} (a (a b)^{*})^{*} = L_{2} \\ b^{- 1} L_{1} & = a (b a)^{*} = L_{3} \\ a^{- 1} L_{2} & = b (a b)^{*} (a (a b)^{*})^{*} \cup (a b)^{*} (a (a b)^{*})^{*} = b L_{2} \cup L_{2} = L_{4} \\ b^{- 1} L_{2} & = \emptyset \\ a^{- 1} L_{3} & = (b a)^{*} = L_{5} \\ b^{- 1} L_{3} & = \emptyset \\ a^{- 1} L_{4} & = a^{- 1} (b L_{2} \cup L_{2}) = a^{- 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} \\ a^{- 1} L_{5} & = \emptyset \\ b^{- 1} L_{5} & = a (b a)^{*} = 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'automate minimal

$[1]$

Modifier . (5 avril 2015) Je viens de découvrir qu'une question similaire: Quels algorithmes existent pour construire un DFA qui reconnaît le langage décrit par une expression régulière donnée? a été demandé sur cstheory. La réponse traite en partie des problèmes de complexité.

— J.-E. Épingle
source

Pouvez-vous en dire plus sur la complexité de cet algorithme?

— babou

@babou La conversion d'un RE en DFA est difficile pour PSPACE, donc c'est définitivement exponentiel.

— jmite

Cela devrait probablement entrer dans la réponse. L'OP commence par "les constructions standard via NFA sont trop lentes" et une partie de la réponse semble être "pas de chance, il n'y a pas vraiment de solution rapide". Il reste à voir si cela est meilleur ici que la construction standard. (cc @jmite)

— Raphael

@jmite Oui, je m'y attendais. La raison de ma question est pourquoi cette façon de construire le DFA devrait alors être considérée comme plus facile. (note: le système a pris une journée entière pour m'informer de la réponse @ jmite).

— babou

2

J.-E. Pin fournit la meilleure réponse en termes de formalité et d'exhaustivité, mais je pense qu'il y a quelque chose à dire pour "l'intuition" à laquelle votre professeur fait allusion.

Dans la plupart de ces cas, la chose la plus simple à faire est de regarder une expression régulière, de comprendre quelle langue elle accepte, puis d'utiliser votre créativité / intelligence pour construire un DFA acceptant cette langue.

Il n'y a pas de moyen simple de le faire, à part les algorithmes que d'autres ont donnés, mais voici quelques lignes directrices qui pourraient s'avérer utiles.

Demandez-vous, pourrais-je écrire un programme qui accepte cette RE en utilisant uniquement des variables booléennes ou de très petits nombres entiers? Ensuite, écrivez ce programme et convertissez-le en DFA où il existe un état pour chaque combinaison de valeurs.
Recherchez les parties de l'expression régulière que vous savez que vous pouvez accepter de façon déterministe, où vous savez "Si je vois cela, alors je dois correspondre à cette partie de l'ER". Il n'y en aura pas toujours des tonnes, mais l'identification de ces pièces peut montrer les pièces qui seront faciles à créer un DFA, vous pouvez donc passer plus de temps sur les pièces qui nécessitent vraiment du non-déterminisme.
La construction du sous-ensemble pour NFA-> DFA n'est pas vraiment compliquée d'un algorithme. Donc, s'il s'agit d'un devoir, et non d'une question d'examen, il peut être plus rapide de coder une implémentation et de laisser votre programme convertir NFA en DFA. Si vous avez utilisé votre propre code, il ne devrait pas y avoir de problème de plagarisme.

$P=NP=PSPACE$

Essayez de «regarder vers l'avenir», coupez les coins lorsque vous pouvez utiliser votre intuition dans des endroits où l'algorithme nécessiterait de nombreuses étapes mais son résultat est clair.

— jmite
source

-2

Bien que ce ne soit pas la bonne façon, mais cela fonctionne la plupart du temps.

Première étape : recherchez la plus petite chaîne pouvant être acceptée par l'expression régulière. Deuxième étape : dessinez les états nécessaires avec la transaction de la machine acceptant la chaîne minimale. Troisième étape : pour tous les États, dessinez les transactions alphabétiques restantes.

Par exemple: Expression régulière (0 + 1) * Chaîne de 1 "se terminant par 1" Étape 1: Chaîne la plus petite: 1 Étape 2: deux états Q0 et Q1. ayant la transaction de 1 de Q0 à Q1. et Q1 est l'état acceptant. Étape 3: pour l'état Q0, la transaction Q0 1 est vers Q1. Faites maintenant 0 transaction dans Q0 lui-même. Pour Q1 State Q1 1, la transaction restera au T1. Et 0 transaction ira au Q0.

— Naveen CS
source