Convertir expresiones regulares en NFA (mínimo) que acepten el mismo lenguaje es fácil con algoritmos estándar, por ejemplo, el algoritmo de Thompson . Sin embargo, la otra dirección parece ser más tediosa, y a veces las expresiones resultantes son desordenadas.

¿Qué algoritmos existen para convertir NFA en expresiones regulares equivalentes? ¿Hay ventajas con respecto a la complejidad del tiempo o el tamaño del resultado?

^{Se supone que esta es una pregunta de referencia. Incluya una descripción general de su método, así como un ejemplo no trivial.}

Existen varios métodos para realizar la conversión de autómatas finitos a expresiones regulares. Aquí describiré el que generalmente se enseña en la escuela y que es muy visual. Creo que es el más usado en la práctica. Sin embargo, escribir el algoritmo no es una buena idea.

Método de eliminación del estado

Este algoritmo se trata de manejar el gráfico del autómata y, por lo tanto, no es muy adecuado para los algoritmos, ya que necesita primitivas de gráficos como ... la eliminación del estado. Lo describiré usando primitivas de nivel superior.

La idea clave

La idea es considerar expresiones regulares en los bordes y luego eliminar estados intermedios mientras se mantienen las etiquetas de los bordes consistentes.

El patrón principal se puede ver a continuación en las figuras. El primero tiene etiquetas entre que son expresiones regulares e , f , g , h , i y queremos eliminar q .$p,q,r$$e,f,g,h,i$$q$

Una vez eliminados, componimos juntos (conservando los otros bordes entre p y r, pero esto no se muestra en esto):$e,f,g,h,i$$p$$r$

Ejemplo

Usando el mismo ejemplo que en la respuesta de Raphael :

eliminamos sucesivamente :$q_2$

y luego :$q_3$

entonces todavía tenemos que aplicar una estrella en la expresión de a q 1 . En este caso, el estado final también es inicial, por lo que realmente solo necesitamos agregar una estrella:$q_1$$q_1$

Algoritmo

L[i,j]es la expresión regular del lenguaje de a q j . Primero, eliminamos todos los bordes múltiples:$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

Ahora, la eliminación del estado. Supongamos que queremos eliminar el estado :$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$

Ahora, ¿cómo usarlo remove(k)? No debe eliminar a la ligera los estados finales o iniciales, de lo contrario, perderá partes del lenguaje.

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

Si solo tiene un estado final y un estado inicial , la expresión final es: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])

Si tiene varios estados finales (o incluso estados iniciales), entonces no hay una forma simple de fusionarlos, aparte de aplicar el método de cierre transitivo. Por lo general, esto no es un problema a mano, pero es incómodo al escribir el algoritmo. Una solución mucho más simple es enumerar todos los pares y ejecutar el algoritmo en el gráfico (ya eliminado) para obtener todas las expresiones suponiendo que es el único estado inicial es el único final estado, luego haciendo la unión de todos .e s , f s f e s , $(s,f)$$e_{s,f}$$s$$f$$e_{s,f}$

Esto, y el hecho de que esto está modificando los lenguajes más dinámicamente que el primer método lo hace más propenso a errores al programar. Sugiero usar cualquier otro método.

Contras

Hay muchos casos en este algoritmo, por ejemplo, para elegir qué nodo debemos eliminar, el número de estados finales al final, el hecho de que un estado final también puede ser inicial, etc.

Tenga en cuenta que ahora que el algoritmo está escrito, esto se parece mucho al método de cierre transitivo. Solo el contexto del uso es diferente. No recomiendo implementar el algoritmo, pero usar el método para hacerlo a mano es una buena idea.

Método

El mejor método que he visto es uno que expresa el autómata como sistema de ecuaciones de lenguajes (regulares) que se pueden resolver. Es particularmente agradable, ya que parece producir expresiones más concisas que otros métodos.

Deje un NFA sin -transitions. Para cada estado , crea la ecuaciónε q $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}$

donde es el conjunto de estados finales y significa que hay una transición de a etiquetada con . Si lee como o (dependiendo de su definición de expresión regular), verá que esta es una ecuación de expresiones regulares.$F$$q_i \overset{a}{\to} q_j$$q_i$$q_j$$a$$\cup$$+$$\mid$

Para resolver el sistema necesita asociatividad y distributividad de y (concatenación de cadenas), conmutatividad de y Lema de Arden ¹:$\cup$$\cdot$$\cup$

Let lenguajes regulares con . Entonces,$L,U,V \subseteq \Sigma^*$$\varepsilon \notin U$

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

La solución es un conjunto de expresiones regulares , una para cada estado . describe exactamente esas palabras que pueden ser aceptadas por cuando se inicia en ; por lo tanto, (si es el estado inicial) es la expresión deseada.$Q_i$$q_i$$Q_i$$A$$q_i$$Q_0$$q_0$

Ejemplo

^{En aras de la claridad, denotamos conjuntos singleton por su elemento, es decir, . El ejemplo se debe a Georg Zetzsche.$a = \{a\}$}

Considere este NFA:

^{[ fuente ]}

El sistema de ecuaciones correspondiente es:

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

Ahora conecta la tercera ecuación en la segunda:

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

Para el último paso, aplicamos el Lema de Arden con , y . Tenga en cuenta que los tres idiomas son regulares y , lo que nos permite aplicar el lema. Ahora conectamos este resultado en la primera ecuación:$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}$

Por lo tanto, hemos encontrado una expresión regular para el lenguaje aceptado por el autómata anterior, a saber

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

Tenga en cuenta que es bastante sucinto (compárese con el resultado de otros métodos) pero no está determinado de forma exclusiva; resolver el sistema de ecuaciones con una secuencia diferente de manipulaciones conduce a otro - ¡equivalente! - expresiones.

1. Para una prueba del Lema de Arden, vea aquí .

Método algebraico de Brzozowski

Este es el mismo método que el descrito en la respuesta de Raphael , pero desde el punto de vista de un algoritmo sistemático, y luego, de hecho, el algoritmo. Resulta fácil y natural de implementar una vez que sabes por dónde empezar. También puede ser más fácil a mano si dibujar algún autómata no es práctico por alguna razón.

Al escribir un algoritmo, debe recordar que las ecuaciones deben ser siempre lineales para que tenga una buena representación abstracta de las ecuaciones, algo que puede olvidar cuando resuelve a mano.

La idea del algoritmo.

No describiré cómo funciona, ya que está bien hecho en la respuesta de Raphael, que sugiero leer antes. En cambio, me concentro en el orden en que debe resolver las ecuaciones sin hacer demasiados cálculos adicionales o casos adicionales.

A partir de la ingeniosa solución de la regla de Arden a la ecuación del lenguaje , podemos considerar el autómata como un conjunto de ecuaciones de la forma:$X=A^*B$$X=AX∪B$

podemos resolver esto por inducción en actualizando las matrices y consecuencia. En el paso , tenemos:$n$$A_{i,j}$$B_{i,j}$$n$

y la regla de Arden nos da:

y configurando y obtenemos:$B'_n = A_{n,n}^* B_n$$A'_{n,i}=A_{n,n}^*A_{n,i}$

y luego podemos eliminar todas las necesidades de en el sistema configurando, para :$X_n$$i,j<n$

Cuando hemos resuelto cuando , obtenemos una ecuación como esta:$X_n$$n=1$

sin . Así obtuvimos nuestra expresión regular.$A'_{1,i}$

El algoritmo

Gracias a esto, podemos construir el algoritmo. Para tener la misma convención que en la inducción anterior, diremos que el estado inicial es y que el número de estado es . Primero, la inicialización para llenar :$q_1$$m$$B$

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

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

y luego la resolución:

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]

la expresión final es entonces:

e := B[1]

Implementación

Incluso si parece un sistema de ecuaciones que parece demasiado simbólico para un algoritmo, este es adecuado para una implementación. Aquí hay una implementación de este algoritmo en Ocaml (enlace roto) . Tenga en cuenta que, aparte de la función brzozowski, todo es imprimir o usar para el ejemplo de Raphael. Tenga en cuenta que existe una función sorprendentemente eficiente de simplificación de expresiones regulares simple_re.

Método de cierre transitivo

Este método es fácil de escribir en forma de algoritmo, pero genera expresiones regulares absurdamente grandes y no es práctico si lo hace a mano, principalmente porque esto es demasiado sistemático. Sin embargo, es una solución buena y simple para un algoritmo.

La idea clave

Deje que represente la expresión regular para las cadenas que van de a usando los estados . Sea el número de estados del autómata.$R^k_{i,j}$$q_i$$q_j$$\{q_1, …, q_k\}$$n$

Suponga que ya conoce la expresión regular de a sin el estado intermedio (excepto las extremidades), para todo . Entonces puede adivinar cómo agregar otro estado afectará la nueva expresión regular : solo cambia si tiene transiciones directas a , y se puede expresar así:$R_{i,j}$$q_i$$q_j$$q_k$$i,j$$R'_{i,j}$$q_k$

( es y es .)$R$$R^{k-1}$$R'$$R^k$

Ejemplo

Usaremos el mismo ejemplo que en la respuesta de Raphael . Al principio, solo puedes usar las transiciones directas.

Aquí está el primer paso (tenga en cuenta que un bucle automático con una etiqueta habría transformado el primer en .$a$$ε$$(ε+a)$

En el segundo paso podemos usar (que se renombra en para nosotros, porque ya se usa para el propósito anterior). Veremos cómo funciona .$q_0$$q_1$$R^0$$R^1$

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

¿Porqué es eso? Esto se debe a que pasar de a usando solo como estado intermedio puede realizarse permaneciendo aquí ( ) o yendo a ( ), girando allí ( ) y volviendo ( ).$q_2$$q_2$$q_1$$ε$$q_1$$a$$ε^*$$b$

También puede calcular así y , y le dará la expresión final porque es inicial y final. Tenga en cuenta que aquí se ha hecho mucha simplificación de expresiones. De lo contrario, la primera de sería y la primera de sería .$R^2$$R^3$$R^3_{1,1}$$1$$a$$R^0$$(∅+a)$$a$$R^1$$((∅+a)+ε(ε)^*a)$

Algoritmo

Inicializacion:

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

Clausura 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)

Entonces la expresión final es (suponiendo que es el estado inicial):$q_s$

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

Pero puedes imaginar que genera expresiones regulares feas. De hecho, puede esperar cosas como que representa el mismo lenguaje que . Tenga en cuenta que simplificar una expresión regular es útil en la práctica.a $(∅)^*+(a+(∅)^*)(ε)^*(a + ∅)$$aa$