Autómatas Finitos. 1. Motivación 2. Autómatas finitos deterministas y sus lenguajes 3. Autómatas finitos no deterministas 4. Propiedades de clausura 5.

Autómatas Finitos

1. Motivación 2. Autómatas finitos deterministas y sus lenguajes 3. Autómatas finitos no deterministas 4. Propiedades de clausura 5. Relación con expresiones regulares 6. Minimización de AF 7. Lema de bombeo 8. Problemas de decisión asociados 9. Complementos Autómatas Finitos

Máquinas: simplifiquemos Volvamos al modelo conceptual de una máquina que procesa información. inputoutput Computador El computador estará siempre en algún estado. La cantidad de estados posibles es finita.  Hablamos de una máquina de estados finitos. MEF

Máquinas: simplifiquemos MEF Se suele distinguir CPU y memoria (RAM). CPU RAM Cada una tiene cierta cantidad de estados posibles: N CPU, N RAM.  Lo vemos como una MEF con N CPU  N RAM estados posibles.  La distinción CPU/RAM no es esencial (sólo es “útil”).

Máquinas: simplifiquemos inputoutput MEF Memoria finita será una fuerte limitación. Luego dotaremos a la MEF de una memoria ilimitada.

Máquinas: simplifiquemos inputoutput MEF Miraremos el “estado interno” de la máquina. estado actual  Usaremos eso como “respuesta” de la MEF  No necesitamos el output.

Máquinas: simplifiquemos input MEF Por un momento quitemos el input. Tiempo discreto. MEF es determinista (por ahora) estado actual el estado en tiempo T+1 está completamente determinado por el estado en tiempo T.

Máquinas: simplifiquemos input MEF Q : estados internos.  :Q  Q : “función de transición” s T : estado en tiempo  s T+1 =  (s T ) estado actual

Máquinas: simplifiquemos Lavadora estado actual Mi lavadora (simplificada): Q = {remojo, lavado, enjuague, centrifugado, apagada} = {r,l,e,c,a} rleca

Máquinas: simplifiquemos Lavadora estado actual En general (Q,  ) definirán un grafo dirigido, en que el grado de salida de cada nodo es 1: a b d c Al agregar ahora un input, éste influirá en el cambio de estado: el grado de salida ya no será 1.

Máquinas con input MEF estado actual Leemos sólo un símbolo del input a la vez. En el instante T, conocemos s T y además la T-ésima letra del input. Ahora  :Q  Q input  * QQ

Máquinas con input -Input con alfabeto  ={0,1} 0: no aprieto el interruptor 1: sí lo aprieto -Estados de la MEF: ON y OFF interruptor Transiciones:  (ON,0)=ON  (OFF,0)=OFF  (ON,1)=OFF  (OFF,1)=ON OFF ON 1 1 0 0 “grafo de transiciones”

Máquinas con input -Input con alfabeto  ={0,1,2} 1: aprieto el interruptor 1 2: aprieto el interruptor 2 0: no aprieto ninguno -Estados de la MEF ? 1 2 Podemos usar Q={00,01,10,11}, donde cada carácter representa el estado de un interruptor. Sólo en el estado 11 la ampolleta está ON. 0010 0111 1 1 1 1 2222 0 0 00 0010 0111 1 1 1 1 2222 0 0 00 q0q0 q2q2 q1q1 q3q3

Estados “de aceptación” (los que encienden la ampolleta): Los marcamos con un doble círculo. Podría haber más de uno. Máquinas con input q0q0 q2q2 q1q1 q3q3 1 1 1 1 2222 Lenguaje “aceptado”: L = { w  * : w contiene cantidades impares de 1 y de 2} 0 0 00 1 2 Estado inicial, será uno solo

1. Motivación 2. Autómatas finitos deterministas y sus lenguajes 3. Autómatas finitos no deterministas 4. Propiedades de clausura 5. Relación con expresiones regulares 6. Minimización de AF 7. Lema de bombeo 8. Problemas de decisión asociados 9. Complementos Autómatas Finitos

AFD: Autómatas finitos deterministas Un AFD está definido por: Q={q 0,..., q n }   :Q  Q q 0  Q F  Q  conjunto finito de estados internos  alfabeto de entrada  función de transición de estados  estado inicial  estados de aceptación

AFD: Autómatas finitos deterministas AFD: M = (Q, , , q 0, F) Dibujamos su grafo de transiciones: Un nodo por cada estado Marcamos el estado inicial con un “>” Doble círculo para los estados de F Si  (q i,  )=q j, ponemos arco de q i a q j, etiquetado con .

AFD, grafo de transiciones Ejemplo: M = (Q, , , q 0, F) donde Q: estados internos  : alfabeto de entrada  :Q  Q: función de transición q 0  Q: estado inicial F  Q: estados de aceptación q0q0 q1q1 q2q2 q3q3 q4q4 a a a a a b b b b b  = {a, b}

AFD, grafo de transiciones q0q0 q1q1 q2q2 10 00,11 Alfabeto  = {0, 1} Estados Q = {q 0, q 1, q 2 } Estado inicial q 0 Estados de aceptación F = {q 0, q 1 } estados input 0 1 q0q0 q1q1 q2q2 q0q0 q1q1 q2q2 q2q2 q2q2 q1q1 Función de transición  : Otro ejemplo:

AFD: Configuración en un momento dado Configuración del AFD en instante dado: estado interno + string que queda por leer (q  Q) (w  * ) Si el autómata recibe w=w 1...w m como input, las transiciones serán (q 0, w 1...w m )  (  (q 0,w 1 ), w 2...w m ) ...  ( q k, w m )  ( q r,  ) para algún q k y q r (q,w)

AFD: Configuración en un momento dado q0q0 q1q1 q2q2 10 00,11 (q 0, 0010011)  (q 0, 010011)  (q 0, 10011)  (q 1, 0011)  (q 2, 011)  (q 2, 11)  (q 2, 1)  (q 2,  )

AFD: Autómatas finitos deterministas q0q0 q1q1 q2q2 10 00,11 OJO, no confundirse: los nodos del grafo no son “partes” del autómata; son sus posibles estados. q0q0 001001101001110011 q1q1 0011 q2q2 011 111 

AFD: extensión de  Construyamos  ’ de la siguiente manera (recursiva):  ’(q,  )=q  ’(q,w  )=  (  ’(q,w),  )  La función  ’ toma un estado y una palabra, y me dice a qué estado voy a llegar, una vez que haya procesado con  todas las letras de la palabra.

AFD: extensión de  En particular se tiene  ’(q,  ) =  (  ’(q,  ),  ) =  (q,  ) de modo que  ’ es una extensión de   por lo tanto no necesitamos distinguirla  escribiremos  para ambas.  ’(q,  )=q  ’(q,w  )=  (  ’(q,w),  )

AFD: extensión de   (q 0,011) = ?  (q 0,011) =  (  (q 0,01),1) =  (  (  (q 0,0),1),1) =  (  (q 0,1),1) =  (q 1,1) = q 1  ’(q,  )=q  ’(q,w  )=  (  ’(q,w),  ) q0q0 q1q1 q2q2 10 00,11

AFD y lenguajes Lenguaje aceptado (o “reconocido”) por un AFD: es el conjunto de palabras que lo llevan desde el estado inicial hasta un estado de aceptación. En otras palabras, L(M) = { w:  (q 0, w)  F }

AFD y lenguajes ¿Que lenguaje acepta este autómata? q0q0 q1q1 q2q2 10 00,11 L= {w  {0,1} * : w no incluye 10}

AFD y lenguajes q0q0 q1q1 1 1 ¿Y este, con  ={1}? L= {w  {1} * : |w| es impar} Usando ER, L = 1(11)*

AFD y lenguajes q0q0 q1q1 0 1 1 0 ¿Y este, con  ={0,1}? L= {w  {0,1} * : w termina en 1} Usando ER, L = (0+1)*1

AFD y lenguajes ¿Y aquí? q4q4 q2q2 q3q3 q1q1 q0q0 a a a a a b b b b b L = palabras no vacías de {a,b} *, que empiezan y terminan con la misma letra. Ejercicio: escribir una ER

AFD y lenguajes ¿Y en estos? q0q0 0,1 q0q0 q0q0 q1q1 O,1 0,1 L = {  } L =  L = {0,1} *

AFD y lenguajes Otro tipo de problema: construir un AFD que acepte un lenguaje dado. Por ejemplo: con  ={0,1}, reconocer el lenguaje de los strings con a lo más tres 1’s. q0q0 q1q1 0 1 1 q2q2 0 q3q3 1 q4q4 0, 1 0 1 0

Aplicaciones para jugar con AFD http://www.cs.usfca.edu/~jbovet/vas.html Permite construir AFD. Permite ejecutarlos. Avisa si está mal construido. Java, licencia BSD Otra, parece que mejor: http://www.cs.duke.edu/csed/jflap/

AFD y lenguajes Si L es un lenguaje, y existe un AFD M tal que L = L(M) decimos que L es regular. ¿Serán todos los lenguajes regulares? Respuesta: NO. Contraejemplo: L = { a n b n : n > 0 }

AFD y lenguajes L = { a n b n : n > 0 } ¿Por qué no es regular? Idea:  Necesito saber cuantas a he leído.  Esa cantidad puede ser arbitrariamente grande.  No puedo distinguir entre un conjunto arbitrariamente grande de opciones, si tengo un conjunto finito de estados.

AFD y lenguajes Podemos pensar en un AFD: Como la formalización de una máquina (MEF) Como un programa Como la descripción de un lenguaje 1 qq qq q2q2 1 1 0 0 0

AFD y lenguajes Si es como descripción de lenguaje, podemos verlo como reconocedor del lenguaje, o como generador. ¿Generador? Hacemos un paseo al azar por el grafo: Partimos de q 0. Nos detenemos en algún estado de aceptación. Output : la secuencia de letras de los arcos usados.  El conjunto de posibles outputs corresponde a L(M). 1 qq qq q2q2 1 1 0 0 0

AFD y lenguajes Si lo vemos así, no es problema pensar en caminos que se bifurquen. Por ejemplo, 1 qq qq q2q2 1 1 0 0 0 1 qq qq q2q2 1 1 0 0 0 0 A eso se le llama AF no determinista.

1. Motivación 2. Autómatas finitos deterministas y sus lenguajes 3. Autómatas finitos no deterministas 4. Propiedades de clausura 5. Relación con expresiones regulares 6. Lema de bombeo 7. Minimización de AF 8. Problemas de decisión asociados 9. Complementos Autómatas Finitos

AFND: Autómatas finitos no deterministas Veamos un ejemplo más de AFD. Con  ={0,1}, queremos que acepte el lenguaje de los strings que terminan en 101. 0 1 … … … … qq qq qq q  q  q  q  q  q  q  q  0 1 0 1 0 1 1 1 1 1 0 Bosquejo (incompleto) de la solución:

AFND: Autómatas finitos no deterministas Sería más cómodo poder adivinar en que momento faltan sólo tres letras, y en ese momento comparar con 101. qq qq qq 0 1 qq 1 0,1 Si en q 0 leemos un “1”, tenemos dos posibles opciones. Si “adivinamos” que estamos a tres letras del final, entonces escojo irme hacia q 1.

AFND: Autómatas finitos no deterministas qq qq qq 0 1 qq 1 0,1 Además, hay transiciones no definidas, como  (q 1,1).  En ese caso el autómata “se cae”.

AFND: Autómatas finitos no deterministas qq qq qq 0 1 qq 1 0,1 Es más fácil verlo como generador: su lenguaje son las palabras que podemos obtener al recorrerlo y terminar en q 3.

AFND: Autómatas finitos no deterministas Un AFND admite “bifurcaciones” en el comportamiento del autómata, y transiciones indefinidas. Podemos interpretar el “no determinismo” como que existe un “oráculo” que permite adivinar el camino correcto o bien como que exploramos todas las opciones. Diremos que el AFND acepta una palabra si existe algún camino posible que permite leer esa palabra y llegar a un estado de aceptación.

AFND: Autómatas finitos no deterministas  ya no es función  :Q  Q pues desde un mismo q, leyendo un mismo , podemos pasar a más de un estado, o a ninguno  ahora será una función  :Q  P (Q) donde P (Q), también anotado 2 Q, son “las partes de Q” (o sea,  (q,  ) entrega un subconjunto de Q). En particular, las transiciones indefinidas son  (q,  )= .

AFND: Autómatas finitos no deterministas Otro ejemplo: reconocer los strings que incluyen 010 en alguna parte. qq qq qq 1 0 qq 0 0,1 :: {q 3 } q3q3  q2q2 {q 2 }  q1q1 {q 0 }{q 0,q 1 }q0q0 10

AFND: Autómatas finitos no deterministas Otro ejemplo: reconocer los strings que incluyen 010 en alguna parte. qq qq qq 1 0 qq 0 0,1 Ejercicio: hacer lo mismo con un AFD (también se puede), y hacerlo también para strings que incluyan 111, 101, 110, respectivamente. Verán que los AFND son iguales, pero los AFD son más variados (y menos obvios).

AFD, AFND En AFD, p =  (q,  ) “del estado q, leyendo , se pasa al estado p” En AFND, p   (q,  ) “del estado q, leyendo , se puede pasar al estado p” qq qq 1 0 qq 0,1 Insistamos: en ambos casos se puede interpretar el AF como un descriptor de posibles “paseos”, cada cual tiene asociada una palabra.

AFND: Autómatas finitos no deterministas  ’(q,w) es entonces el conjunto de estados a los que puedo llegar a partir del estado q, leyendo en el camino la palabra w desde el input. Nuevamente  ’ resulta ser una generalización de , de modo que el apóstrofe no es necesario. Nuevamente podemos extender  para que lea más de una letra a la vez.  ’(q,  )={q}  ’(q,w  )= { p :  r  ’(q,w) tal que p  (r,  ) } =

AFND: Autómatas finitos no deterministas  ’(q,  )={q}  ’(q,w  )= { p :  r  ’(q,w) tal que p  (r,  ) } = qq qq qq 1 0 qq 0 0,1 :: {q 3 } q3q3  q2q2 {q 2 }  q1q1 {q 0 }{q 0,q 1 }q0q0 10  (q 0, 01) = ? { q 0, q 2 }

AFND: Autómatas finitos no deterministas El lenguaje del AFND será L(M) = { w:  (q 0, w)  F   } O sea: “w pertenece al lenguaje, si a partir del estado inicial, y leyendo w, es posible llegar a algún estado que sea de aceptación”. ¿Qué acepta este AFND, con  = {a} ? L = {aa,  } a a a

AFND: Autómatas finitos no deterministas ¿Y este, con  = {a,b} ? abb a,b q0q0 q1q1 q2q2 q3q3 q4q4 q5q5 0,1 0 1 0 0 1 1 q3q3 ¿Y aquí, con  = {0,1} ? Más ejercicio: ver qué pasa si cambiamos a: (1)  (q 3,0) = ,  (q 3,1) =  (2)  (q 3,0) = ,  (q 3,1) = q 5

AFND: Autómatas finitos no deterministas Construir un AFND que acepte palabras que contienen dos pares de 0’s adyacentes, separados por una cantidad par de 1’s: 01001100001 está, 1100111100 también, pero 0101001110010 no. 1 1 0,1

AFND: Autómatas finitos no deterministas Anotemos LR = { L: L es reconocido por algún AFD} LN = {L: L es reconocido por algún AFND} ¿Qué relación existirá entre estas clases?  Todo AFD es un AFND (es el caso particular en que |  (q,  )|=1 para cualquier q,  )  LR  LN Veremos que además LN  LR (y por lo tanto, LN = LR). (dijimos que esos se llamaban “regulares”)

AFND  AFD Idea de por qué LN  LR : consideremos de nuevo el AFND que acepta el lenguaje de strings que incluyen 010. qq qq qq 1 0 qq 0 0,1 Veamos los posibles recorridos al leer la palabra 0101: (q 0, 0101)(q 0, 101) (q 1, 101) (q 0,  ) rechaza (q 2,  ) rechaza (q 3,  ) acepta (q 0, 1) (q 1, 1) (q 3, 1) (q 0, 01) (q 2, 01)

AFND  AFD Idea de por qué LN  LR : consideremos de nuevo el AFND que acepta el lenguaje de strings que incluyen 010. qq qq qq 1 0 qq 0 0,1 Veamos los posibles recorridos al leer la palabra 0101: q0q0 q0q0 q1q1 q0q0 q2q2 q0q0 q1q1 q3q3 q 0 rechaza q 2 rechaza q 3 acepta 0 0 1 1 0 0 0 1 1 1

AFND  AFD Idea de por qué LN  LR : consideremos de nuevo el AFND que acepta el lenguaje de strings que incluyen 010. qq qq qq 1 0 qq 0 0,1 Veamos los posibles recorridos al leer la palabra 0101: q0q0 q0q0 q1q1 q0q0 q2q2 q0q0 q1q1 q3q3 q0q0 q2q2 q3q3 0 1 0 1

AFND  AFD Entonces: el conjunto de posibles recorridos para la palabra 0101, se convierte en un único recorrido, que va pasando por distintos subconjuntos de Q. qq qq qq 1 0 qq 0 0,1 q0q0 q0q0 q1q1 q0q0 q2q2 q0q0 q1q1 q3q3 q0q0 q2q2 q3q3 0 1 0 1

AFND  AFD A partir del AFND M, construimos un AFD M’ en que  los estados son los conjuntos de estados de M  la función de transición de M’,  M’, une los resultados de la función transición de M,  M  un estado de M’ será de aceptación si incluye algún estado de aceptación de M q0q0 q0q0 q1q1 q0q0 q2q2 q0q0 q1q1 q3q3 q0q0 q2q2 q3q3 0 1 0 1

AFND  AFD Otro ejemplo: 1 0 0, 1 qq qq qq AFND 1 qq {q 0, q 1 } 1 {q 0, q 2 } 1 0 0 0 AFD

AFND  AFD Método general para construir el AFD M’ equivalente a un AFND M=(Q, , , q 0, F): Q’ = 2 Q  ’ =  q’ 0 = {q 0 } F’ = { A  Q : A  F  }  ’( A,  ) = { q:  p  A, q  (p,  ) } = ¿Será cierto que L(M’)=L(M)?

AFND  AFD L(M) = { w:  (q 0, w)  F   } L(M’) = { w:  ’( q’ 0, w)  F’ } = { w:  ’( q’ 0, w)  F   } =  (q 0,w  )  ’( q’ 0, w  ) =  ’(  ’(q 0,w),  ) =  ’(  (q 0,w),  ) = Definición de F’ Demostremos por inducción que  ’( q’ 0, w) =  (q 0,w) BASE: Si |w|=0, w= .  ’(q’ 0,  ) = {q 0 } =  (q 0,  ) PASO INDUCTIVO: Supongamos para |w| y demostremos para |w|+1. Definición (recursiva) de  ’ Hipótesis de inducción Definición de  ’ Definición (recursiva) de 

AFND  AFD Hemos demostrado: Teorema: la clase de lenguajes reconocidos por AFND es la misma que la clase de lenguajes reconocidos por AFD (y se llaman lenguajes regulares).  Los AFND son capaces de hacer exactamente lo mismo que los AFD, a pesar de su “poder de adivinación”.  Sirven, entre otras cosas, para construir AF más rápido.

sólo esa parte es relevante (el resto no es accesible!) AFND  AFD De nuevo el ejemplo: dado el AFND 1 0 0, 1 qq qq qq {q 0, q 1 } {q 0, q 2 }{q 0, q 1, q 2 } {q 1, q 2 } {q 0 } {q 1 } {q 2 }  0, 1 0 1 0 1 0 1 0 1 0 1 0 1 la construcción da el AFD:

AFND  AFD  Suele ocurrir que muchos de los subconjuntos de Q no sean accesibles en el AFD. Las implementaciones lo que hacen es partir de {q 0 }, e ir agregando sólo lo accesible. Para el AFND de la derecha (que vimos antes), el programa dio el AFD de abajo. 1 1 Feo, pero nótese que sólo usa 14 de los 64 subconjuntos de 2 Q.

AFND+  Antes habíamos definido (al extender  ) que en un AFND,  (q,  ) = {q} En un AFND+ , ese lado derecho puede incluir otros estados. Por lo tanto,  se define como una función  :Q  (  {  })  2 Q La idea es que son transiciones “gratis”, que permiten pasar de un estado a otro sin leer ningún input. q1q1 q2q2 1 1 0 0 q3q3 q4q4 0 0 1 1 q0q0  

AFND+  A la izquierda: palabras consistentes en 0 o más repeticiones de 10, seguidas por 0 o más repeticiones de 110. Derecha: palabras que sólo usan dos de las 3 letras disponibles. 1 1 qq qq qq 1 qq qq 0  0  = {0,1} qq qq qq qq     = {0,1,2} 0,10,21,2

AFND+  Nuevamente, es claro que los AFND son caso particular de los AFND+ . ¿Y al revés? ¿Será posible reconocer un lenguaje no regular con un AFND+  ? Respuesta: NO. La clase de lenguajes queda igual. Demostración: veamos que dado un AFND+ , podemos construir un AFD equivalente (es decir, con el mismo lenguaje).

AFND+  Consideremos un AFND+  M = (Q, , , q 0, F), y definamos una relación  mediante p  q  q   (p,  ), ó p=q Sea   la clausura transitiva de R, y dado A  Q sea A  =A  { q:  p  A, p   q} Es decir, A  le agrega a A todo aquello que se puede alcanzar desde A mediante transiciones nulas.

AFND+  Se hace una variante de la construcción previa, con Q’ = 2 Q,  ’ = , F’ = { A  Q : A  F  } pero ahora q’ 0 = {q 0 }  y  ’( A,  ) = { q:  p  A, q  (p,  ) }  Nótese que sólo los A  Q que sean cerrados para   (es decir, A  =A) serán accesibles.

AFND+  Ejemplo:  Palabras que comienzan y terminan en a, y no tienen dos b consecutivas.

AF  FA Las siglas en inglés para lo que hemos tratado son, por lo general: AFD  (D)FA : (deterministic) finite automaton AFND  NFA: non-deterministic finite automaton AFND+    -NFA: non-deterministic finite automaton with  -transitions OJO: en inglés el singular es automaton, plural es automata (en castellano, autómata y autómatas).

Propiedades de clausura Dado cualquier AF, siempre es posible construir un AFND+  equivalente tal que: No haya flechas que entren al estado inicial. Exista un solo estado de aceptación, y no haya flechas que salgan de él.

Propiedades de clausura En efecto: si no es el caso, agregamos estados de inicio o término, y los conectamos con los que habían mediante transiciones nulas.

Propiedades de clausura Sean L 1 y L 2 lenguajes regulares, y sean M 1 y M 2 AFND+ , de la forma previa, que los reconocen. L 1  L 2 también es un lenguaje regular. Demostración:

Propiedades de clausura L 1 L 2 también es un lenguaje regular: L 1 + también es un lenguaje regular:

Propiedades de clausura L 1 * también es un lenguaje regular. Demostración: L 1 * = L 1 +  {  }. {  } es regular (ya le vimos un AF), L 1 + es regular por la diapo previa, ergo L 1 * es regular por la diapo previa a la previa. L 1 n (n concatenaciones) es también un lenguaje regular. Demostración: inducción sobre n, y usamos la clausura bajo concatenación.

Propiedades de clausura L 1 C también es un lenguaje regular. Demostración: sea M = (Q, , , q 0, F) un AFD que reconoce a L 1 (ojo: determinista). Definimos M’ = (Q, , , q 0, F’), con F’=Q\F.  L(M’)=L 1 C

Propiedades de clausura L 1  L 2 también es un lenguaje regular: Demostración 1: Notamos que, por ley de Morgan, L 1  L 2 =(L 1 C  L 2 C ) C y aplicamos los resultados previos. Demostración 2: Sean A 1 = (Q 1, ,  1, q 0,1, F 1 ) y A 2 = (Q 2, ,  2, q 0,2, F 2 ) dos AFD que reconocen L 1 y L 2 respectivamente. Definimos M=(Q, , , q 0, F) con Q = Q 1  Q 2 q 0 = (q 0,1,q 0,2 ) F= F 1  F 2  ((q 1,q 2 ),  ) = (  1 (q 1,  ),  2 (q 2,  )) Idea: al leer w con M, estaremos leyendo w con A 1 y A 2 simultaneamente; la aceptamos sólo si ambos la aceptan (“a la vez”).

Propiedades de clausura Sean L 1, L 2,..., L n lenguajes regulares. Entonces también es un lenguaje regular. Demostración: inducción. Sean L un lenguaje finito. Entonces L es regular. Demostración: ejercicio. Idea: Construir un AF por palabra (es fácil), y unirlos con el resultado previo.

Propiedades de clausura Sean L 1, L 2,... una sucesión infinita de lenguajes regulares. Entonces no necesariamente es regular. Demostración: Supongamos que lo anterior siempre es regular y consideremos un lenguaje cualquiera L  *. Definamos L n = L   n Cada L n es finito  cada L n es regular. L es la unión de todos los L n Por lo tanto L sería regular. Pero L es cualquiera, y sabemos que existen lenguajes no regulares.  Contradicción!

Propiedades de clausura Ejercicios: Sean L 1 y L 2 regulares. Entonces L 1 \L 2 [resta de conjuntos] es regular. Sea L regular. Entonces L R es regular (L R : lenguaje formado por la transposición de las palabras de L). Idea: invertir flechas, transformar aceptación en inicio y viceversa.

Propiedades de clausura Ejercicios: Sean L 1 regular y L 2 cualquier lenguaje. Se define el cuociente [derecho] como L 1 /L 2 = { u:  v  L 2 tal que uv  L 1 } O sea: son las palabras formadas al quitarles, a palabras de L 1, sufijos pertenecientes a L 2. Demuestre que L 1 /L 2 es regular.

Propiedades de clausura Ejercicios: Sean  1 y  2 dos alfabetos (eventualmente el mismo). Un homomorfismo es una función h:  1 *   2 * tal que h(uv) = h(u)h(v) para todo u,v  1 * h(  ) = . Demuestre que h queda determinada de manera única por sus valores sobre  1. Sea L regular, y sea h un homomorfismo. Demuestre que h(L)={h(w): w  L} es regular.

Propiedades de clausura Ejemplo de homomorfismo:  1 ={0,1}  2 ={a,b} h definida por h(0)=ab, h(1)=  h(0011)=h(0)h(0)h(1)h(1)=abab  =abab L = palabras de la forma 100...001, con al menos un 0.  h(L) = palabras de la forma ababab...ab, con al menos un ab.

Expresiones regulares, lenguajes regulares Definimos las expresiones regulares (ER) de forma recursiva: Primitivas: , , y todo . Dadas r 1 y r 2 ER, se construyen (r 1 ) r 1 * r 1 +r 2 r 1 r 2

ER  regular Es fácil ver que todo lenguaje descrito por una ER es un lenguaje regular: Hay AF triviales para las ER primitivas. Vimos que la unión, concatenación y estrella de Kleene de lenguajes regulares era regular.  Por inducción estructural, toda ER describe un lenguaje regular. Por otro lado, dado un lenguaje regular, siempre existe una ER que lo describe. Para demostrarlo, tenemos que hacer el camino AF  ER.

Regular  ER Sea L un lenguaje regular. Existe un AFD. Queremos una ER equivalente a él. Demostraremos algo más fuerte: que para todo “Generalized Transition Graph” (GTG), existe una ER equivalente.  Y los AF son un caso particular de GTG.

GTGGTG GTG: como AFND+ , pero podemos usar ER en los arcos. Además pediremos que sean de la forma:  +10* (00+11)* 0*1 qq qq qq 01 qq 0*11 1010 Ejemplo:

GTGGTG Claramente generalizan a los AFD (y los AFND+  ) Descripción formal : un cacho Idea : simple  +10* (00+11)* 0*1 qq qq qq 01 qq 0*11 1010 Ejemplo:

Regular  ER Idea: a partir de un GTG, ir eliminando estados intermedios, hasta que sólo queden el de inicio y el de aceptación.

Regular  ER Cuando sólo queden los extremos, la etiqueta del arco sobreviviente es la ER que andábamos buscando.  +10* 0*11 0*1 qq qq qq 01 qq qq  +10*)(0*1)*0*11 qq qq  +10*)(0*1)*0*11 + 01

[Nota: en algunos textos...] En algunos textos la situación final se muestra como aquí, con loops. En tal caso, da la expresión final. No es nuestro caso, aquí basta

Regular  ER Los mágicos pasos intermedios. Si llega a haber más de un arco entre dos nodos, los juntamos en uno:

Regular  ER Arcos continuados: concatenación

Regular  ER Si había loop, estrella de Kleene

Regular  ER Una entrada y dos salidas  dos arcos

Regular  ER En general: n arcos de entrada m arcos de salida  nm arcos EntranLoopSalen r2 desde 1 r4 r3 hacia 1 r6 desde 3r5 hacia 3

Regular  ER Hemos demostrado: Las ER describen exactamente el mismo tipo de lenguajes que los AF. Es decir, los lenguajes regulares. A veces es más fácil trabajar con ER, a veces con AF. Preferible ER, p.ej., si como usuarios estamos describiendo lo que queremos buscar en un archivo de texto o en una base de datos. Preferible AFD, p.ej., si quiero intersectar dos lenguajes regulares.

Ejemplo: complemento de una ER O bien, otro ejemplo: dada una ER, ¿cómo encontrar una ER que represente su complemento? 1.Creamos un AFND+  equivalente a la ER 2.Lo convertimos en un AFD 3.Invertimos los estados de aceptación 4.Convertimos el AFD en una ER Hagámoslo para la ER “aa”, para el alfabeto {a,b}. Creamos un AFND+  equivalente a la ER

Ejemplo: complemento de una ER Lo convertimos en un AFD  Es fácil hacerlo “a dedo”, sin pasar por 2 Q :

Ejemplo: complemento de una ER Invertimos los estados de aceptación Convertimos el AFD en una ER:    

Ejemplo: complemento de una ER        

y crecen y crecen... ER  AFND+   AFD  AFD  ER También sería el caso para intersectar dos ER. En cada paso, la cantidad de estados del AF (o la longitud de las ER) tiende a crecer. Pero puede haber ER y/o AF más chicos que los que obtenemos de ese modo.  Veremos un algoritmo para minimizar AFD

Lema del bombeo L = { a n b n : n > 0 } no es un lenguaje regular. La idea era la siguiente: Si fuera regular, habría un AFD M con L(M)=L : M Sea N la cantidad de estados de M. a N+1 b N+1 está en el lenguaje, así que se acepta.

Lema del bombeo Antes de terminar de leer las “a”, algún estado de M se tiene que repetir (porque sólo hay N estados distintos!). Por lo tanto, existe un loop. M aaaa a a k b N+1 Pero entonces una palabra que repita ese loop varias veces también se aceptaría... Pero tendrá más a’s que b’s !!! 

Lema del bombeo [para lenguajes regulares] Lema del bombeo para lenguajes regulares: Sea L un lenguaje regular. Entonces existe n>0 tal que cualquier w con |w|  n se puede descomponer como w=xyz, de forma que: |y| > 0 |xy| < n xy k z  L  k  0 …… x y z Demostración: QED

Lema del bombeo Escrito de manera compacta: si L es regular, entonces:  n>0 tal que  w, |w|  n,  x,y,z, w=xyz, con |y|>0, |xy|<n, tal que  k  0, xy k z  L Para probar que L no es regular, hay que mostrar que:  n>0  w, |w|  n,  desglose w=xyz con |y|>0 y |xy|< n,  k  0 tal que xy k z  L. “  ”  considerar cualquier caso “  ”  podemos elegir

Lema del bombeo Es útil verlo como una competencia, entre nosotros y un adversario : ¡L no es regular! Sí, si es regular. Tengo un AFD. ¿En serio? ¿De cuántos estados? n Ya poh. Aquí tienes w, |w|>n, que está en L. Para aceptarla tu AFD tiene que hacer un loop. ¿En qué parte lo hace? Aquí en el y... queda w=xyz ¡Ja! Pero si le damos 3 vueltas al loop con xyyyz, tu AFD acepta, pero eso no está en L. ¡Toma!...  #@?ç! nosotros adversario

Lema del bombeo La gracia de pensarlo así es recordar que podemos elegir el w (pero debe ser con |w|>n para cualquier n). Y lo escogemos estratégicamente, pensando en después poder escoger un k que haga que xy k z se salga de L... para cualquier desglose w=xyz (con |y|>0, |xy|<n). Al “n” se le llama “la constante del lema de bombeo” o “la longitud de bombeo”. ¿Por qué “bombeo”?  La idea es que “inflamos” la parte del loop hasta “reventar” el string.

Lema del bombeo El ejemplo de {a n b n :n>0}: Sea n la constante del bombeo. Tomamos w=a n+1 b n+1. Sea xyz cualquier desglose de w, con |xy| 0. Necesariamente, tanto x como y están dentro de a n+1.  Sean p y q tales que x=a p, y=a q (p  0, q  1).  z será de la forma a n+1-p-q b n+1. El teorema dice entonces que xy k z = a p a qk a n+1-p-q b n+1  L para todo k  0, Pero eso requeriría que n+1+q(k-1)=n+1 para todo k, y nop.

Lema del bombeo Ejercicios:  ={0,1}, L={ uu: u   * }. Hint: tomar w=0 n 10 n 1  ={0,1}, L={ uu R : u   * }. Hint: w=0 n 1 2n 0 n  ={0,1}, L={ u: u tiene la misma cantidad de 0 y 1}  ={a,b,c}, L={ u: |u| es un cuadrado perfecto}  ={0}, L={ u: |u| es primo} Recordar que si no les resulta ganarle al “adversario”, no implica que L sea regular... Puede significar simplemente que escogieron mal el w o el k. Del mismo modo, fracasar al construir un AFD o ER no implica que L no sea regular!

Lema del bombeo Es útil recordar la parte del “  k  0”. Veamos otro ejemplo:  ={0,1}, L={ u: u tiene más 0’s que 1’s} Sea n la constante de bombeo, y tomemos w=0 n 1 n-1. Nuevamente, al hacer w=xyz necesariamente x e y son sólo 0’s: x=0 p y=0 q z=0 n-p-q 1 n-1 Si bombeamos el y con cualquier k>0, no se sale de L. Pero si usamos k=0 (no dar ninguna vuelta al loop!), entonces obtenemos xy 0 z = xz = 0 p 0 n-p-q 1 n-1 = 0 n-q 1 n-1  Como q  1, n-q  n-1  xy 0 z  L.

Lema del bombeo Finalmente, a la hora de demostrar que un lenguaje no es regular también sirve recordar las propiedades de clausura. Ejemplo: L={ u: u tiene cantidad distinta de 0’s y 1’s} Si uno ya hizo el ejercicio de dos transparencias atrás, entonces ya sabe que L C no es regular.  L no puede serlo, pues si lo fuera, su complemento también debería serlo.

1. Motivación 2. Autómatas finitos deterministas y sus lenguajes 3. Autómatas finitos no deterministas 4. Propiedades de clausura 5. Relación con expresiones regulares 6. Lema de bombeo 7. Minimización de AF y teorema de Myhill-Nerode 8. Problemas de decisión asociados 9. Complementos Autómatas Finitos

Minimización de AFD Motivos para querer minimizar AFD: Al trabajar con AFD, AFND+ , ER, etc., y hacer las conversiones de unos a otros, la cantidad de estados tiende a crecer (a veces mucho más allá del mínimo necesario para el lenguaje que nos interesa). Al construir circuitos físicos que son AFD, minimizarlos puede abaratar costos y consumos. Al implementar AFD en código (por ejemplo, para buscar una ER en un texto), podemos ganar eficiencia.

Minimización de AFD Motivos para querer minimizar AFD: El AFD minimal resulta ser único (a lo sumo cambian los nombres de los estados, pero la estructura es la misma).  Por lo tanto, minimizando dos AFD podemos saber si su lenguaje es el mismo. Nos da una noción, comparable, de “complejidad” de lenguajes regulares (comparo el tamaño de los AFD minimales respectivos).

Mapa rutero dentro del punto 7 Minimización de AFD Motivación vía motivos Motivación e idea, vía ejemplo Algoritmo Demostración de parte del algoritmo (el “marcado”) Ejemplo El problema con AFND Demostración de que el algoritmo da el mínimo Idea de por qué funciona Teorema de Myhill-Nerode Myhill-Nerode  unicidad del AFD mínimo Uso de Myhill-Nerode para demostrar no-regularidad

Minimización de AFD Idea: puede haber estados equivalentes En este caso q 3 y q 4 son “basureros”: el AFD rechazará, sea lo que sea lo que venga después.  Son equivalentes, y los podemos combinar.

Minimización de AFD Idea: puede haber estados equivalentes Tanto a partir de q 1 como q 2 el AFD aceptará ssi el resto del string consiste sólo en a’s.  Son equivalentes, y los podemos combinar. q 3,4

Minimización de AFD Idea: puede haber estados equivalentes Ya no quedan estado equivalentes: para cualquier par de estados, hay alguna continuación del string que puede llevarme a aceptar desde un estado, rechazar desde otro. q 3,4 q 1,2

Minimización de AFD No siempre es tan obvio como en el ejemplo previo: q0q0 q1q1 q2q2 q 0,2 q1q1

Minimización de AFD Informalmente: dos estados p y q son equivalentes (p  q), si la decisión del AFD sobre cualquier input restante es la misma para los dos estados. O sea: p  q ssi  w  *,  (p,w)  F   (q,w)  F Otra forma de escribirlo: Definamos L(M,q) como el lenguaje aceptado por M, si imponemos que q sea el estado de inicio. Entonces p  q ssi L(M,p)=L(M,q)

Minimización de AFD L(M,q 0 ) = b * aa * L(M,q 1 ) = a * L(M,q 2 ) = a * L(M,q 3 ) =  L(M,q 4 ) =   q 1  q 2 q 3  q 4 q0q0 q1q1 q2q2 L(M,q 0 ) = cantidad impar de 0’s L(M,q 1 ) = cantidad par de 0’s L(M,q 2 ) = cantidad impar de 0’s  q 0  q 2

Mapa rutero Minimización de AFD Motivación vía motivos Motivación e idea, vía ejemplo Algoritmo Demostración de parte del algoritmo (el “marcado”) Ejemplo El problema con AFND Demostración de que el algoritmo da el mínimo Idea de por qué funciona Teorema de Myhill-Nerode Myhill-Nerode  unicidad del AFD mínimo Uso de Myhill-Nerode para demostrar no-regularidad

Minimización de AFD Decimos que una palabra w distingue dos estados p,q si w es la “culpable” de que no sean equivalentes: w se aceptaría a partir de uno, pero no del otro. En este caso, ba distingue q 0 de q 1 a distingue q 0 de q 2 a distingue q 1 de q 2 qq qq

Minimización de AFD Algoritmo de minimización: 1)Eliminar todos los estados no alcanzables desde q 0. 2)Determinar los pares de estados equivalentes. 3)Mientras quede un par p  q, redirigir hacia p todos los arcos que llegaban a q, y luego eliminar q. Teorema (sólo enunciado, por ahora): Sea L un lenguaje regular. Entonces dentro de los AFD que reconocen a L, existe un único AFD que tiene la cantidad mínima de estados, y es el que se obtiene a partir de cualquier otro mediante la aplicación del algoritmo de arriba.

Minimización de AFD 1.Marcamos todos los pares en los que un estado es de aceptación y el otro no. 2.Para todo (p,q) no marcado y para todo , si (  (p,  ),  (q,  ) ) está marcado  marcar (p,q). 3.Si en (2) se marcó algo, repetir (2). Para determinar los pares equivalentes, usamos el siguiente “algoritmo de llenado de tabla”. La tabla contiene los pares (p,q), p  q. Iremos marcando los pares distinguibles (  no equivalentes).

Mapa rutero Minimización de AFD Motivación vía motivos Motivación e idea, vía ejemplo Algoritmo Demostración de parte del algoritmo (el “marcado”) Ejemplo El problema con AFND Demostración de que el algoritmo da el mínimo Idea de por qué funciona Teorema de Myhill-Nerode Myhill-Nerode  unicidad del AFD mínimo Uso de Myhill-Nerode para demostrar no-regularidad

Minimización de AFD El algoritmo marca (p,q)  p es distinguible de q Dem.: (  ) Inducción sobre los pasos del algoritmo. Base: Si en el paso 1 marco un par, entonces  los distingue. Paso inductivo: Supongamos que hasta la k-ésima iteración del paso 2, las marcas son en estados distinguibles. Si en la (k+1)-ésima iteración del paso 2 marcamos (p,q), es porque  tal que (  (p,  ),  (q,  ) ) está marcado. Por hip. de ind.,  (p,  ) y  (q,  ) son distinguibles. Sea w que los distingue. Entonces  w distingue p y q.

Minimización de AFD El algoritmo marca (p,q)  p es distinguible de q Dem.: (  ) Supongamos que existen pares distinguibles, pero no marcados por el algoritmo, y sea W={w:w distingue alguno par no marcado}. Escojamos en W una palabra w de largo mínimo, y sean p y q los estados que distingue. Nótese que |w|>0. Escribamos w= w 1 w 2...w n. La palabra w 2...w n distingue  (p, w 1 ) de  (q, w 1 ), pues de lo contrario w no distinguiría p de q. Si (  (p, w 1 ),  (q, w 1 )) no está marcado, entonces w no era de largo mínimo  Si (  (p, w 1 ),  (q, w 1 )) está marcado, entonces el algoritmo marcó (p,q) 

Minimización de AFD Ejemplo: 0 1 qq qq qq q  q  q  q  0 1 0 1 1 0 0 1 1 0 0 1 qq qq q  q  q  q  qq qq qq q  q  AFD que reconoce las palabras terminadas en 11. ¿Será el más chico posible?  Hacemos la tabla.

Minimización de AFD 0 1 qq qq qq q  q  q  q  0 1 0 1 1 0 0 1 1 0 0 1 xxxxxx qq qq q  q  q  q  qq qq qq q  q  Ejemplo: Marcamos los pares en los que un estado está en F y el otro no. Motivo: los distingue la palabra .

Minimización de AFD 0 1 qq qq qq q  q  q  q  0 1 0 1 1 0 0 1 1 0 0 1 x x x x x x xxxx qq qq q  q  q  q  qq qq qq q  q  Ejemplo:  (p,q) no marcado, y , si (  (p,  ),  (q,  ) ) está marcado  marcar (p,q). Motivo: alguna palabra w distinguía a  (p,  ) y  (q,  ). Por lo tanto,  w distingue a p y q.

Minimización de AFD 0 1 qq qq qq q  q  q  q  0 1 0 1 1 0 0 1 1 0 0 1 x x x x x x x x x x x x xx qq qq q  q  q  q  qq qq qq q  q  Ejemplo: Aplicamos de nuevo.

Minimización de AFD 0 1 qq qq qq q  q  q  q  0 1 0 1 1 0 0 1 1 0 0 1 x x x x x x x x x x x x xx qq qq q  q  q  q  qq qq qq q  q  Ejemplo: Ya no queda nada más que marcar:  (p,q) no marcado, y , (  (p,  ),  (q,  ) ) está no marcado. Todos los pares no marcados son equivalentes; podemos empezar a minimizar.

Minimización de AFD 1 qq qq q  q  q  q  0 1 1 0 0 1 1 0 0 1 x x x x x x x x x xx qq q  q  q  q  qq qq q  q  0 Ejemplo: Fusiono q 0 con q .

Minimización de AFD 1 qq qq q  q  q  0 1 0 1 1 0 1 x x x x x x xx qq q  q  q  qq qq q  0 0 Ejemplo: Fusiono q 00 con q .

Minimización de AFD 1 qq qq q  q  0 1 0 1 0 1 x x xxx qq q  q  qq qq q  0 0 Ejemplo: Fusiono q 10 con q .

Minimización de AFD 1 qq qq q  0 1 1 x xx qq qq qq 0 0 1 qq qq qCqC 1 1 0 0 0 Finalmente fusiono q 01 con q 1 (aunque en el fondo sólo tengo que borrarlo, pues no era alcanzable).

Minimización de AFD 0 1 qq qq qq q  q  q  q  0 1 0 1 1 0 0 1 1 0 0 1 x x x x x x x x x x x x xx qq qq q  q  q  q  qq qq qq q  q  A B C De hecho pueden convertirse las clases en estados directamente (en lugar de ir fusionando de a pares): 1 qq qq qCqC 1 1 0 0 0 A A A A A B A

Minimización de AFD No se producen inconsistencias con , pues p  q   (p,  )  (q,  )  (de lo contrario,  distinguiría p y q !) A p q q1q1 B q5q5 q2q2 C q6q6   w w

[ ¿Minimización de AFND ? ] El algoritmo de minimización es para AFD. 0 0,1 0 1 0 1 Por ejemplo, estos tres AFND aceptan el mismo lenguaje, y claramente son mínimos (no se puede con 1 solo estado!). D Para ellos funciona, y para ellos es cierto que para un mismo lenguaje, el AFD mínimo es siempre el mismo. Para AFND[+  ] eso no es cierto.

[ ¿Minimización de AFND ? ] También puede pasar esto: todos los estados son distinguibles, pero el AFND no es mínimo: eliminando el estado C, el AFND que queda acepta el mismo lenguaje. Algoritmo para minimizar AFND no veremos. Es tema peludo (y sin solución corta; sigue siendo investigado). Por suerte la minimización de AF, cuando interesa, interesa con AFD (casi siempre): los circuitos físicos que queramos construir, o el software que queramos correr, no son adivinos.

Minimización de AFD: da mínimo Demostremos que el AFD minimizado (producto del algoritmo) tiene la cantidad mínima posible de estados. Sea M=(Q, , , q 0, F) el AFD minimizado, y supongamos que existe M’=(Q’, ,  ’, q’ 0, F’) con menos estados, que reconoce el mismo lenguaje. Para cada estado p de M, sea w p una palabra tal que  (q 0, w p )=p. Esas palabras existen, pues todos los estados de M son alcanzables. Como M’ tiene menos estados que M   p,q tales que  ’(q’ 0, w p )=  ’(q’ 0, w q ).

Minimización de AFD: da mínimo Como p y q son estados de M, son distinguibles (de lo contrario, el algoritmo los habría fundido),   u, tal que de  (p, u) y  (q, u) uno y sólo uno  F  de  (  (q 0, w p ), u) y  (  (q 0, w q ), u) uno y sólo uno  F  de  (q 0, w p u) y  (q 0, w q u) uno y sólo uno  F  de w p u y w q u, uno y sólo uno  L(M). Pero en M’,  ’(q’ 0, w p )=  ’(q’ 0, w q )   ’(q’ 0, w p u)=  ’(q’ 0, w q u)  w p u y w q u, o están ambas en L(M’), o ninguna.  L(M)  L(M’) QED

Minimización de AFD: ¿por qué funciona? Para entender un poco mejor lo que está pasando, consideremos M =(Q, , , q 0, F) un AFD (no necesariamente minimal) y L=L(M). Dadas tres palabras u,v,w  *, tales que de uw y vw, una y sólo una pertenece a L, diremos que “w distingue u de v respecto a L“. Definamos dos relaciones entre palabras de  * : u  M v   (q 0,u)=  (q 0,v) u  L v  no existe w que distinga u de v respecto a L

Minimización de AFD: ¿por qué funciona? u  M v   (q 0,u)=  (q 0,v) u  L v  no existe w que las distinga respecto a L Es fácil ver que u  M v  u  L v En efecto, sea w una palabra cualquiera. Tenemos u  M v   (q 0,u)=  (q 0,v)   (q 0,uw)=  (q 0,vw) De modo que uw y vw, o bien están ambas en L, o ninguna lo está.  w no distingue u de v respecto a L. También es fácil ver que ambas son relaciones de equivalencia [ejercicio, trivial].

Minimización de AFD: ¿por qué funciona? Pero si son de equivalencia, y u  M v  u  L v, entonces la partición que  M induce en  * es un refinamiento de la partición que induce  L.  Cada clase de equivalencia de  M está contenida en una clase de equivalencia de  L.  Cada clase de equivalencia de  L es la unión de una o más clases de equivalencia de  M. u  M v   (q 0,u)=  (q 0,v) u  L v  no existe w que las distinga respecto a L

Minimización de AFD: ¿por qué funciona? Cada clase de equivalencia de  M corresponde a un estado de M. u  M v   (q 0,u)=  (q 0,v) u  L v  no existe w que las distinga respecto a L Cuando una clase de equivalencia de  L contiene dos clases de equivalencia de  M (correspondientes a, digamos, los estados p y q), entonces p  q (son equivalentes en el sentido del algoritmo).

Minimización de AFD: ¿por qué funciona? u  M v   (q 0,u)=  (q 0,v) u  L v  no existe w que las distinga respecto a L  Lo que hace el algoritmo de minimización, en el fondo, es fundir estados para ir uniendo esas clases, hasta que quedan las de  L. Por lo tanto la partición inducida por el AFD minimizado es exactamente la misma de  L... Que no depende del AFD de partida, sino sólo del lenguaje L.

Una observación y una definición Una observación: las clases de equivalencia de  L (y por lo tanto también las de  M ) están contenidas en L, o bien en L C. [¿Por qué?] Por lo tanto, ambas inducen refinamientos de la partición (L,L C ). Definición (olvidé darla cuando vimos relaciones): dada una relación de equivalencia, su índice es la cantidad de clases de equivalencia en la partición que induce. LCLC L Estamos listos para...

Myhill-Nerode Teorema de Myhill-Nerode: Sea L  * un lenguaje y sea u  L v definida como antes. Entonces L es regular ssi  L es de índice finito. Dem.: ( , La dirección fácil ) L es regular   AFD M=(Q, , , q 0, F), L=L(M)  el índice de  M es |Q|. Como cada clase de equivalencia de  L está formada por una o más clases de equivalencia de  M, el índice de  L debe ser |Q| o menor.

Myhill-Nerode Teorema de Myhill-Nerode: Sea L  * un lenguaje y sea u  L v definida como antes. Entonces L es regular ssi  L es de índice finito. Dem.: (  ) Definimos el AFD M=(Q, , , q 0, F) mediante Q =  * /  L, [el conjunto de clases de equivalencia de  L ] q 0 = [  ] F = { q  Q: q  L}  ( [u],  ) = [u  ] PDQ: L(M)=L. Además veremos que M es mínimo.

Myhill-Nerode Q =  * /  L, [conjunto de clases de equivalencia de  L ] q 0 = [  ], F = { q  Q: q  L},  ( [u],  ) = [u  ] PDQ  L(M)=L. Es decir, que  u  *, u  L(M)  [u]  L Pero u  L(M)   (q 0,u)  F   ([  ],u)  L así que estamos listos si demostramos que  ([  ],u)=[u]. Demostraremos, más en general, que  u,v  *,  ([v],u)=[vu]

Myhill-Nerode PDQ  u,v  *,  ([v],u)=[vu] Inducción sobre |u| : Base: |u|=1. Cierto, por definición de . Paso inductivo: |u|>1, u=w  para algún , w con |w|<|u|.  ([v],u) =  ([v],w  ) =  (  ([v],w),  ) =  ([vw],  ) = [vw  ] = [vu] Q =  * /  L, [conjunto de clases de equivalencia de  L ] q 0 = [  ], F = { q  Q: q  L},  ( [u],  ) = [u  ] Definición (recursiva) de  Hipótesis de inducción Definición de 

Myhill-Nerode Lo único que falta ver es que M es mínimo. Recordemos que sus estados son las clases de equivalencia de  L.  Para cada par de estados [u], [v], existe una palabra w que distingue las clases de equivalencia (si no, serían la misma clase).  uw y vw están una fuera y la otra dentro de L.  [uw] y [vw] están uno fuera y otro dentro de F.  w también distingue los estados correspondientes. Q =  * /  L, [conjunto de clases de equivalencia de  L ] q 0 = [  ], F = { q  Q: q  L},  ( [u],  ) = [u  ] QED

Myhill-Nerode ¿Cuál es la intuición tras Myhill-Nerode? Recibimos el input: u=vw Al terminar de verlo, debemos decidir acaso u  L. Hemos leído v, falta w. La relación  L está definida de tal forma que lo único que necesitamos saber (para cumplir con la tarea final) es en cuál clase de equivalencia está v.

Myhill-Nerode ¿Cuál es la intuición tras Myhill-Nerode? La función  define como voy actualizando esa información con cada nueva letra que pasa. 0 1 [v] [v1][v0] Myhill-Nerode lo que me dice es que un lenguaje es regular ssi eso que tengo que saber, momento a momento, cabe en una memoria finita.

La unicidad del AFD mínimo. Dijimos antes: Teorema de minimización: Sea L un lenguaje regular. Entonces dentro de los AFD que reconocen a L, existe un único AFD que tiene la cantidad mínima de estados, y es el que se obtiene a partir de cualquier otro mediante la aplicación del algoritmode minimización. Falta demostrar la parte en itálica : que siempre llegamos al mismo AFD. No lo haremos, sólo daremos la idea de por qué. Los detalles técnicos  ejercicio.

La unicidad del AFD mínimo. Supongamos que partimos de dos AFD distintos, ambos con el mismo lenguaje, y llegamos a dos AFD minimales M y M’. ¿Qué significa que sean el mismo? Significa que salvo “cambio de nombre”, los estados son los mismos. Llamemos  al cambio de nombre. 1 qq qq q  0 1 1 0 0 1 A C B 0 1 1 0 0   -1

La unicidad del AFD mínimo. Dados dos AFD M=(Q, , , q 0, F) y M’=(Q’, ,  ’, q’ 0, F’), son “el mismo” ssi existe  :Q  Q’ biyectiva tal que  (q 0 ) = q’ 0  (F) = F’  (  (q,  )) =  (  (q),  ) En el ejemplo de abajo,  (q  )=A,  (q 11 )=B,  (q 1 )=C. 1 qq qq q  0 1 1 0 0 1 A C B 0 1 1 0 0   -1  es un isomorfismo entre M y M’.

La unicidad del AFD mínimo. Ser isomorfos (“ser el mismo”) es claramente una relación de equivalencia entre AFD.  Para probar que dos AFD son isomorfos, sirve probar que ambos son isomorfos a un tercero. Para demostrar la unicidad del AFD mínimo, se demuestra que es isomorfo al AFD construido en la demostración de Myhill-Nerode: Sea M un AFD minimizado, y para cada estado p de M, sea w p una palabra tal que  (q 0, w p )=p. Sea A el AFD entregado por Myhill-Nerode para L(M).  Entonces  (p)=[w p ] es un isomorfismo entre M y A. ejercicio

Usando Myhill-Nerode Myhill-Nerode sirve por lo tanto para explicar el algoritmo de minimización y su resultado. Sin embargo, también se puede usar directamente, como herramienta para demostrar que un cierto lenguaje NO es regular. ¿Por qué puede ser útil eso? Hasta ahora lo único que tenemos es un ejemplo de lenguaje no regular, y para “demostrarlo” apelamos en parte a la intuición.

Usando Myhill-Nerode Pero la intuición a veces es engañosa. L 1 = { palabras con la misma cantidad de 0’s y 1’s } L 2 = { palabras con la misma cantidad de 01’s y 10’s } Uno es regular, el otro no! Así que es útil tener teoremas para demostrar que algo no es regular. [Para demostrar que algo sí es regular, ya tenemos herramientas: construir AF, ER, usar las propiedades de clausura, etc...]

Usando Myhill-Nerode Apliquemos Myhill-Nerode al ejemplo que vimos alguna vez: L={a n b n :n>0}. Consideremos los conjuntos de palabras: S 0 = {a n b n : n > 0} S 1 = {a n b n-1 : n > 1} S 2 = {a n b n-2 : n > 2}... Dados k  j, tomamos algún n>j, n>k, y las palabras u=a n b n-k  S k, v=a n b n-j  S j Claramente uw  L ssi w=b k, vw  L ssi w=b j. Como k  j, tanto b k como b j distinguen entre u y v, respecto a L.  El índice de  L no es finito (hay  clases de equiv.)  L no es regular.

Problemas de decisión para LR Sea L un lenguaje regular, que conocemos de alguna forma (ER, AFND, descripción verbal...). Hay varias preguntas típicas, que quisiéramos poder contestar. Dada una palabra w, ¿w  L? Respuesta: construimos el AFD para L, y vemos si acepta w.

Problemas de decisión para LR Alternativa 1: construimos el AF (sirven D y ND) para L L=  ssi no hay camino desde q 0 hasta algún q  F Alternativa 2: construimos el AFD. Sea n =|Q| probar todas las palabras de largo  n L=  ssi ninguna de esas se acepta [¿Razón de eso? Lema de bombeo!] ¿L   ?

Problemas de decisión para LR Alternativa 3: construimos una ER para L. Desde ahí es fácil encontrar alguna palabra de L. Borramos las * En cada “+”, eliminamos un lado (si alguno es , borramos ese; si no, borramos el lado derecho). Borramos los paréntesis.  Lo que queda [ejercicio] es una palabra de L. r = (a+  )(ab * +ba * ) * (  +b * ) *  (a+  )(ab+ba)(  +b)  (a)(ab)(  )  aab  L(r) ¿L   ?

Problemas de decisión para LR Alternativa 1: construimos un AFD para L vemos acaso existe un camino desde q 0 hasta algún q  F que incluya algún ciclo. ¿Es L infinito? Nota: Funciona con AFND+ , siempre que no consideremos los ciclos formados por puras transiciones .

Problemas de decisión para LR Alternativa 2: construimos el AFD. Sea n =|Q| probamos todas las palabras de largo n  m  2n L es infinito ssi alguna de esas se acepta. Razón de que eso sea cierto: ejercicio. Pero también es vía bombeo. ¿Es L infinito?

Problemas de decisión para LR Dados dos lenguajes regulares L 1 y L 2. ¿Son iguales? L 1  L 2 = (L 1 \L 2 )  (L 2 \L 1 ) = (L 1  L 2 C )  (L 1 C  L 2 ) A\B A  B Alternativa 1: construimos un AFD para cada uno. los minimizamos. vemos si los AFD resultantes son isomorfos.  Es regular y podemos construirle un AFD, según vimos en las propiedades de clausura. Alternativa 2: Ver acaso L 1  L 2 = 

Problemas “decidibles” Las preguntas previas tienen algo en común: todas piden una respuesta del tipo sí/no.  Se habla de problemas de decisión.  Si existe un algoritmo para resolver un problema de decisión, decimos que el problema es decidible.  Por lo tanto decimos que los problemas anteriores son decidibles para lenguajes regulares.  Más adelante veremos que, para otras clases de lenguajes, pueden ser indecidibles.

Complementos Algunos “parientes cercanos” de los AF Aplicaciones? Herramientas para parsear ER Gramáticas regulares Gramáticas de libre contexto

Variantes respecto a los AF Hay un montón de variaciones respecto a los AF que hemos visto, de acuerdo a los distintos usos prácticos o teóricos que se les quieran dar. En la medida en que la memoria siga siendo finita, el poder de cómputo no cambia. Un ejemplo: AF bidireccionales (“2-way FA”). Primero que nada, pensemos en un AF como una maquinita que va recorriendo una cinta con su input.

Variantes respecto a los AF x 1 x 2 x n -1 x n... AFAFD [Vale la pena imaginarlo así: es un esquema que se repetirá dentro del curso.] El cabezal recorre de izquierda a derecha, hasta encontrar el final. El autómata es una máquina que va cambiando su estado interno, y tiene un "cabezal" situado sobre la cinta, donde lee la palabra. Agregamos unos símbolos que marcan el comienzo y fin de la palabra.

Variantes respecto a los AF x 1 x 2 x n -1 x n... 2AFAFD En un "2-AFD" (AFD bidireccional) el cabezal puede retroceder. Para eso, se agrega una función m:(Q,  )  {L,R,S}. Esa función indica, en cada paso, si el cabezal debe moverse a la izquierda, a la derecha, o quedarse quieto. Como el input ya no "termina", se requiere una nueva definición del "lenguaje reconocido".

Variantes respecto a los AF x 1 x 2 x n -1 x n... AFAFD  Desaparece “F” (el conjunto de estados de aceptación). Se crean dos estados finales, uno de aceptación y otro de rechazo. Si el 2-AFD cae en uno de ellos, se detiene (y decide). L es un lenguaje reconocible por un 2-AFD ssi L es regular. 2 Demostración: Hopcroft (teo. 2.5 en 1ªed, esp.)

Variantes respecto a los AF Un tipo de variante que sí cambia (un poco) las cosas: autómatas traductores (transducers). output input MEF estado actual Hasta aquí hemos leído el "output" a través del estado interno final, e incluso entonces sólo miramos acaso acepta o rechaza ("autómatas aceptadores"). En los autómatas traductores, agregamos la posibilidad de que escriban mientras van leyendo.

Variantes respecto a los AF Los dos sabores más conocidos son las máquinas de Moore y las máquinas de Mealy. La diferencia: qq qq 1 0,1 qq 0 0 qq qq 1 qq 0 0 Moore escribe cuando pasa por un estado (asocia letras a los nodos del grafo de transición). a a b 1 1 Mealy escribe al pasar de un estado a otro (asocia letras a los arcos del grafo de transición). qq qq 1 0,1 qq 0 0 1 1/a 0/a,1/b 0/b 1/b

Variantes respecto a los AF Se usa un alfabeto de salida  ', que puede ser o no distinto del de entrada. Nótese que no ponemos estados de aceptación: ya no nos interesa eso, nos interesa la transformación de una palabra en otra. Formalmente, una máquina de Moore será una tupla M=(Q, , ,  ',, q 0 ). :Q   ' indica qué letra debe escribirse al pasar por cada estado.

Máquina de Moore El autómata va cambiando de estados como siempre; la única diferencia es que al leer la palabra w=w 1,...,w m, y pasar por los estados p 0, p 1,..., p m donde p 0 = q 0 p 1 =  (q 0,w 1 ) p 2 =  (q 0,w 1 w 2 ) =  (p 1,w 2 )... p m =  (q 0,w) =  (p m-1,w m ) el autómata escribirá el output (p 0 ) (p 1 ) (p 2 )... (p m ) qq qq 1 0,1 qq 0 0 a a b 1 0010101 input aaaababa output

Máquina de Mealy La máquina de Mealy será M=(Q, , ,  ',, q 0 ), pero ahora :Q   ', y para la misma palabra w=w 1,...,w m anterior que hace pasar al autómata por p 0, p 1,..., p m, el output será (q 0,w 1 ) (p 1,w 2 )... (p m-1, w m ) qq qq 1 0,1 qq 0 0 1 1/a 0/a,1/b 0/b 1/b 0010101 input bbaabab output Nótese que Mealy escribe una letra menos que Moore (pues Moore escribe algo ya en q 0, antes de leer nada).

Variantes respecto a los AF Cada máquina de Moore (o de Mealy) define una función  *   ' *. Si se agrega no-determinismo, será una relación (entre palabras). En principio Mealy se ve más poderoso que Moore (pues distingue qué transición se usa). Sin embargo, para cada máquina de Mealy existe una de Moore equivalente y viceversa (ver Hopcroft). Las relaciones (entre palabras) que pueden ser descritas de esta forma se llaman relaciones regulares, y tienen propiedades de clausura (y definición recursiva) análogas a los lenguajes regulares.

Variantes respecto a los AF Es posible combinar con autómatas aceptadores. En ese caso, ponemos además un conjunto de estados de aceptación. El AFD funcionará como siempre, pero irá escribiendo mientras lee. También es posible extender el formalismo de las expresiones regulares, para que al reconocer una ER r 1 escribamos algo según una ER r 2. Lo escribimos r 1 :r 2, y en general será no-determinista. a*:b ab:a (a * :b)(ab:a) * Etc, etc...

¿Aplicaciones? Si bien el curso es de informática teórica, no todo el interés es teórico.  AF traductores se usan, por ejemplo, en procesamiento de lenguaje natural (escrito), o en reconocimiento y síntesis de habla.  Además se aplican en diseño de circuitos electrónicos de control. AF aceptadores también.  En general los AF son una buena forma de modelar, diseñar, o mantener información respecto a objetos finitos.

¿Aplicaciones? Un área en que los AFD y las ER se usan mucho es al buscar palabras específicas, o patrones genéricos, en textos. Un ejemplo de AFD para búsqueda de una palabra específica: buscar ocurrencias de la palabra ccacct en un texto laaaaargo escrito en alfabeto {a,c,g,t}. Idea naïve: para cada posición del texto, hacer la comparación de las 6 letras siguientes con las de la palabra. ¡Pero no es lo más eficiente! acaggccaccaac ccacct  Cuando detecto esa diferencia, no necesito probar con ccacct ubicada 1 o 2 posiciones a la derecha: puedo avanzar 3 altiro.

¿Aplicaciones? ccacct,  ={a,c,g,t} 123450 cc acct 6 c a c c Todas las transiciones no mostradas van al estado 0. Evitamos comparaciones inútiles. Con palabras más largas el AFD puede quedar harto más complejo. Se puede extender la idea para buscar varias palabras a la vez. El preprocesamiento puede ser pesado, pero después la búsqueda en el texto es rápida. Detalles: googlear algoritmo Knuth-Morris-Pratt.

Análisis léxico Un uso de ER es para separar un texto en sus "átomos" sintácticos, que luego se procesarán de alguna forma.  Se transforma el texto en una lista de "tokens". Por ejemplo, al procesar los argumentos de un programa. O al preparar el código de un programa para ser compilado.

Análisis léxico Analizador léxico Parser precio id + id Expresión asignación :=Total iva Total=precio+iva; Total=precio+iva;

Análisis léxico: LEX Lex: utilidad en Unix para generar analizadores léxicos. Input de lex: un listado de ER, y para cada una de ellas, un segmento de código en C indicando qué hacer con ella. Además el input de lex incluye otros trozos de código en C que uno pueda necesitar. Con eso lex genera un programa en C. Al compilarlo, ese programa reconocerá las ER en su input, y ejecutará el código apropiado.

Análisis léxico: LEX Var = 12 + 9; if (test > 20) temp = 0; else while (a < 20) temp++; programa generado por lex Identifier: Var Operand: = Integer: 12 Operand: + Integer: 9 Semicolon: ; Keyword: if Parenthesis: ( Identifier: test.... Input Output Uso típico de un programa creado por lex:

Análisis léxico: LEX Ejemplo de input para que lex genere un programa: % [a-zA-Z]+printf(“Identifier: \s\n”, yytext); [0-9]+printf(“Integer: \s\n”, yytext); [ \t\n] ; /*saltarse tabs, espacios y cambios de líneas*/ Hoy en día se usa flex ("fast lex") más que lex mismo.

¿Parseo? Analizador léxico Parser precio id + id Expresión asignación :=Total iva Total=precio+iva; Total=precio+iva; Esta fase por lo general requiere más poder que el que dan los lenguajes regulares. Allá vamos.

Gramáticas Una gramática es otra forma de describir un lenguaje. Ejemplo:  O    S   P   S    A   T   P    V   A   el  A   un  T   niño  T   perro  V   corre  V   camina

Gramáticas  O    S   P   S    A   T   P    V   A   el  A   un  T   niño  T   perro  V   corre  V   camina Una derivación de "un niño corre": O  S PO  S P  A T P A T P  A T V  A T V  un  T   V   un  T  corre  un niño corre

Gramáticas  O    S   P   S    A   T   P    V   A   el  A   un  T   niño  T   perro  V   corre  V   camina Lenguaje descrito por esta gramática: L={"el niño corre", "el niño camina", "un niño corre", "un niño camina", "el perro corre, el perro camina", "un perro corre", "un perro camina"}

Gramáticas Variable o "no- terminal"  T   niño Regla de producción Terminal

Gramáticas Otro ejemplo: Algunas derivaciones: Lenguaje:

Gramática: forma general Una gramática es una tupla G=(V,T,S,P) donde T es un conjunto finito de símbolos terminales (es el alfabeto en que estarán escritas las palabras). V es un conjunto finito de variables (símbolos que no aparecerán en la palabra final). S  V es la variable de inicio. P es un conjunto finito de reglas de producción de la forma p  q, donde p es de la forma (V+T) * V(V+T) * y q es de la forma (V+T) *.

Derivaciones T={a,b} V={S} S=S P={S  aSb, S  } Una derivación es la obtención de una palabra u a partir de una palabra v, ambas pertenecientes a (V+T) *, aplicando una regla de producción: Si la regla es p  q, será aplicable sólo si p está incluida en u, o sea, u=xpy. El resultado será v=xqy. Escribimos u  v.

Derivaciones Definimos  * como la cerradura transitiva de . Es decir, u  * v ssi  u 1,u 2,...,u k tales que u  u 1  u 2 ...  u k  v Además definimos que u  * u para todo u. Definimos el lenguaje descrito por la gramática como el conjunto de todas las palabras de terminales que pueden derivarse a partir de S: L(G) = { w  T * : S  * w } A veces cuando no haya confusión posible, anotaremos  * simplemente como 

Convención sobre notación Notación: se suelen usar en este contexto Letras minúsculas del comienzo del alfabeto para los terminales. Letras minúsculas del final del alfabeto para las palabras (de terminales, o de terminales mezclados con variables). Letras mayúsculas para las variables. Cuando por algún motivo esto pueda inducir a confusión, entonces se usan con corchetes:  S . Casos típicos: cuando es inevitable usar mayúsculas en los terminales, o cuando una variable tiene un nombre natural (ejemplo:  predicado  ).

Gramáticas de libre contexto El formalismo general de gramáticas es demasiado poderoso :  puede describir lenguajes más complejos que los que nos interesan (por ahora). Estudiaremos en este capítulo las gramáticas de libre contexto y sus lenguajes asociados (lenguajes de libre contexto). Nota: también lo traducen como “de contexto libre”, “independientes del contexto”, etc, etc.

Gramáticas de libre contexto Def.: una gramática se dice de libre contexto (GLC) ssi en toda regla de producción p  q, se tiene que p  V. Es decir, las reglas son de la forma X  w con w  (V+T) *. ¿Por qué interesan?  Los lenguajes de programación, y (salvo algunas construcciones particulares) los lenguajes naturales, son de libre contexto!!

(Gramáticas regulares Un caso aún más particular son las GLC en que se pide que todas las reglas de producción sean de las formas S  aT ó S  a Se les llama gramáticas lineales por la derecha. Análogamente se definen las gramáticas lineales por la izquierda, que tienen reglas de la forma S  Ta, ó bien S  a. Una gramática es regular si es lineal por la derecha, o es lineal por la izquierda.

Gramáticas regulares L es un lenguaje regular ssi L=L(G) para una gramática regular G. Ir derivando la palabra corresponde a ir cambiando de estado interno (la variable), y escribiendo.

Gramáticas regulares) Ojo: para que G sea regular debe ser lineal por la derecha o por la izquierda, pero no puede mezclar las dos formas. Si las mezcla, puede que lo que sale ya no sea regular: S  aT T  Sb S  genera {a n b n, n  0}, que es el clásico ejemplo de lenguaje no regular.

Autómatas Finitos. 1. Motivación 2. Autómatas finitos deterministas y sus lenguajes 3. Autómatas finitos no deterministas 4. Propiedades de clausura 5.

Presentaciones similares

Presentación del tema: "Autómatas Finitos. 1. Motivación 2. Autómatas finitos deterministas y sus lenguajes 3. Autómatas finitos no deterministas 4. Propiedades de clausura 5."— Transcripción de la presentación:

Presentaciones similares

Sobre el proyecto

Feedback

Iniciar la sesión

Autorizarse a través de una red social:

Autómatas Finitos. 1. Motivación 2. Autómatas finitos deterministas y sus lenguajes 3. Autómatas finitos no deterministas 4. Propiedades de clausura 5.

Presentaciones similares

Presentación del tema: "Autómatas Finitos. 1. Motivación 2. Autómatas finitos deterministas y sus lenguajes 3. Autómatas finitos no deterministas 4. Propiedades de clausura 5."— Transcripción de la presentación:

Presentaciones similares

Sobre el proyecto

Feedback