¿Cómo crear DFA a partir de expresiones regulares sin usar NFA?

12

El objetivo es crear DFA a partir de una expresión regular y usar "Exp. Regular> NFA> Conversión de DFA" no es una opción. ¿Cómo debería uno hacer eso?

Le hice esta pregunta a nuestro profesor, pero él me dijo que podemos usar la intuición y amablemente se negó a dar ninguna explicación. Entonces quería preguntarte.

"Conversión exp. Normal> NFA> DFA" no es una opción porque tal conversión lleva mucho tiempo convertir una expresión regular bastante compleja. Por ejemplo, para un cierto regex "regex> NFA> DFA" toma 1 hora para un ser humano. Necesito convertir regex a DFA en menos de 30 minutos.

— Rafael
fuente

2

Necesita proporcionar más contexto. ¿Qué algoritmo (informal) estás usando actualmente para traducir expresiones regulares? Puede ser útil explicar su proceso con un ejemplo como a(a|ab|ac)*a+. Puede traducirlo directamente a un NDFA que reduce a un DFA, o puede normalizarlo a algo que se asigne inmediatamente a un DFA.

— amon

¿Tiene que hacerlo en ejemplos específicos por cualquier medio, o tiene que proporcionar un procedimiento general para que lo aplique una computadora?

— babou

18

Como quiere "convertir expresiones regulares a DFA en menos de 30 minutos", supongo que está trabajando a mano en ejemplos relativamente pequeños.

En este caso, puede usar el algoritmo de Brzozowski , que calcula directamente el autómata Nerode de un lenguaje (que se sabe que es igual a su autómata determinista mínimo). Se basa en un cálculo directo de las derivadas y también funciona para expresiones regulares extendidas que permiten la intersección y la complementación. El inconveniente de este algoritmo es que requiere verificar la equivalencia de las expresiones calculadas en el camino, un proceso costoso. Pero en la práctica, y para pequeños ejemplos, es muy eficiente. $[1]$

Cocientes izquierdos . Deje que sea una lengua de y dejar ser una palabra. Entonces El idioma se denomina cociente izquierda (o dejó derivado ) 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$

Autómata Nerode . El autómata Nerode de es el autómata determinista donde , y la función de transición se define, para cada , por la fórmula Cuidado con esta definición bastante abstracta. Cada estado de es un cociente izquierdo de por una palabra, y por lo tanto es un lenguaje de . El estado inicial es el lenguaje , y el conjunto de estados finales es el conjunto de todos los cocientes izquierdos de $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 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$ por una palabra de .

L

$L$

Algoritmo de Brzozowski . Deje ser letras. Se pueden calcular los cocientes izquierdos utilizando las siguientes fórmulas: $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*}$

Ejemplo . Para , obtenemos sucesivamente: que proporciona el siguiente autómata mínimo. $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*}$ El autómata mínimo

$[1]$ J. Brzozowski, Derivados de expresiones regulares, J.ACM 11 (4), 481-494, 1964.

Editar . (5 de abril de 2015) Acabo de descubrir una pregunta similar: ¿Qué algoritmos existen para construir un DFA que reconozca el lenguaje descrito por una expresión regular dada? fue preguntado en teoría. La respuesta aborda en parte los problemas de complejidad.

— J.-E. Alfiler
fuente

¿Puedes decir más sobre la complejidad de este algoritmo?

— babou

@babou Convertir un RE en un DFA es difícil para PSPACE, por lo que es definitivamente exponencial.

— jmite

Esto probablemente debería ir en la respuesta. El OP comienza con "las construcciones estándar a través de NFA son demasiado lentas" y parte de la respuesta parece ser "mala suerte, realmente no hay una solución rápida". Queda por discutir si esto aquí es mejor que la construcción estándar. (cc @jmite)

— Raphael

@ jmite Sí, esperaba eso. La razón de mi pregunta es por qué esta forma de construir el DFA debería considerarse más fácil. (nota: el sistema tardó un día completo en notificarme la respuesta de @ jmite).

— babou

2

J.-E. Pin proporciona la mejor respuesta en términos de formalidad e integridad, pero creo que hay algo que decir sobre la "intuición" que su profesor está insinuando.

En la mayoría de estos casos, lo más fácil es mirar una expresión regular, comprender qué idioma está aceptando, luego usar su creatividad / inteligencia para construir un DFA que acepte ese idioma.

No hay una forma directa de hacer esto, aparte de los algoritmos que otros han dado, pero aquí hay algunas pautas que pueden resultar útiles.

Pregúntese, ¿podría escribir un programa que acepte este RE utilizando solo variables enteras booleanas o muy pequeñas? Luego escriba ese programa y conviértalo en un DFA donde haya un estado para cada combinación de valores.
Busque partes de la expresión regular que sepa que puede aceptar de manera determinista, donde sepa "Si veo esto, entonces debo estar haciendo coincidir esta parte del RE". No siempre habrá toneladas de estos, pero identificar estas partes puede mostrar las partes que serán fáciles de hacer un DFA, por lo que puede pasar más tiempo en las partes que realmente requieren no determinismo.
La construcción del subconjunto para NFA-> DFA no es realmente un algoritmo tan complicado. Entonces, si esta es una tarea, no una pregunta de examen, podría ser más rápido simplemente codificar una implementación y dejar que su programa convierta NFA a DFA. Si usó su propio código, no debería haber problemas de plagarismo.

$P=NP=PSPACE$

Intente "mirar hacia adelante", corte las esquinas cuando pueda usar su intuición en lugares donde el algoritmo requeriría muchos pasos pero su resultado es claro.

— jmite
fuente

-2

Aunque esta no es la forma correcta, funciona la mayor parte del tiempo.

Primer paso : encuentre la cadena más pequeña que puede ser aceptada por la expresión regular. Segundo paso : Dibuje los estados necesarios con la transacción de la máquina que acepta la cadena mínima. Tercer paso : para todos los estados, dibuje las transacciones restantes de alfabetos.

Por ejemplo: Expresión regular (0 + 1) * 1 "Cadena que termina con 1" Paso 1: Cadena más pequeña: 1 Paso 2: dos estados Q0 y Q1. teniendo la transacción de 1 de Q0 a Q1. y Q1 es el estado de aceptación. Paso 3: para el estado Q0, la transacción Q0 1 es a Q1. Ahora haga 0 transacción en Q0 sí mismo. Para el estado Q1, la transacción Q1 1 permanecerá en Q1. Y la transacción 0 irá en Q0.

— Naveen CS
fuente