Autmatas Finitos Mquinas simplifiquemos input Computador MEF output

Autómatas Finitos

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

Máquinas: simplifiquemos CPU RAM MEF Cuando se habla de computadores se suele hacer la distinción entre CPU y memoria (RAM). • Pero estamos suponiendo que tanto la CPU como la RAM tienen una cantidad finita de estados posibles (NCPU, NRAM). Entonces la distinción CPU/RAM no es fundamental: lo vemos como una MEF con NCPU NRAM estados posibles. NOTA: La distinción CPU/memoria, para memoria finita, es a veces conceptualmente útil al diseñar máquinas.

Máquinas: simplifiquemos input MEF output • Veremos luego que al asumir memoria finita estamos limitando (y mucho) la capacidad del computador. • Para recuperar esa capacidad (en unas semanas) tendremos que dotar a la MEF con una memoria infinita (al menos “potencialmente” infinita).

Máquinas: simplifiquemos input MEF output estado actual • Sigamos simplificando. Supongamos ahora que podemos ver en qué estado está la MEF en un momento dado. Usaremos eso para ver “la respuesta” de la MEF al input. O sea, no necesitamos el output.

Máquinas: simplifiquemos input MEF estado actual • Por un momento supongamos que además no hay input. • El tiempo será discreto: tendremos el instante 0, luego el instante 1, luego el 2, etc. . . • Supondremos (por ahora) que la MEF es determinista : es decir, el estado en tiempo t+1 está completamente determinado por el estado en el tiempo t.

Máquinas: simplifiquemos input MEF estado actual • Sea Q el conjunto de estados internos de la MEF. • La forma en que la MEF pasa de un estado a otro la anotaremos como una “función de transición” : Q Q. Si anotamos el estado en tiempo t mediante st, lo que tenemos es: st+1 = (st)

Máquinas: simplifiquemos Lavadora estado actual • Mi lavadora (simplificada): Q = {remojo, lavado, enjuague, centrifugado, apagada} = {r, l, e, c, a} r l e c a • En general (Q, ) definirán un grafo dirigido, en que el grado de salida de cada nodo es 1: c b d a

Máquinas con input MEF estado actual * Q Como no tenemos memoria en la MEF (más allá de la dada por el estado interno) no leeremos el input de un viaje, sino un símbolo a la vez. • En cada instante t, además de conocer el estado interno, conocemos la t-ésima letra del input. • Ahora el cambio de estado (la función ) dependerá de ambas cosas: si el alfabeto del input es , entonces : Q Q

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

Máquinas con input 1 PILA 2 -Input con alfabeto ={0, 1, 2} • 1: aprieto el interruptor 1 • 2: aprieto el interruptor 2 • 0: no aprieto ninguno -Estados de la MEF ? 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. 0 1 00 2 0 10 1 2 01 0 2 1 1 2 11 0

Máquinas con input 1 PILA 2 • Los 00, 01, 10, 11 de los estados confunden un poco. • Además, no siempre será tan concreta la interpretación de los estados internos. 0 Usaremos nombres más neutros para los estados: q 0, q 1, q 2 , q 3. • Si el estado qi tiene un significado intuitivo, lo anotamos aparte: “q 1 corresponde al interruptor 1 abierto y el 2 cerrado”. . . 1 q 0 00 2 0 q 2 10 1 2 01 q 1 0 2 1 1 2 11 q 3 0

Máquinas con input 1 PILA • Marquemos el conjunto de estados “de aceptación” (los que encienden la ampolleta) con un doble círculo. 2 0 • Señalemos el estado inicial del sistema con una flecha (a veces sólo se pone un “>”). • Esta máquina “acepta” el lenguaje L = { w *: w contiene una cantidad impar de 1 y de 2} 1 q 0 2 0 q 2 1 2 q 1 0 2 1 1 2 q 3 0

AFD: Autómatas finitos deterministas Un autómata finito determinista está definido por: • Un conjunto finito de estados internos, Q={q 0, . . . , qn} • Un alfabeto de entrada • Una función de transición de estados, : Q Q • Un estado inicial q 0 Q • Un subconjunto de estados de aceptación, F Q

AFD: Autómatas finitos deterministas De modo que un AFD es una tupla M = (Q, , , q 0, F) Una forma de representarlo de manera intuitiva es mediante grafos de transiciones (como el anterior). • Un nodo por cada estado. • Marcamos el estado inicial con un “>” • Doble círculo para los estados de F. • Arco de qi a qj, etiquetado con , si (qi, )=qj

AFD: Autómatas finitos deterministas q 0 1 1 q 1 Alfabeto = {0, 1} Estados Q = {q 0, q 1, q 2} Estado inicial q 0 Estados de aceptación F = {q 0, q 1} 0, 1 0 q 2 Función de transición : input estados 0 q 1 q 2 0 q 2 q 2 1 q 1 q 2

AFD: Autómatas finitos deterministas La configuración del AFD en un instante dado estará dada por su estado interno y por el string que le queda por leer: (q, w), con q Q y w *. De modo que las transiciones del autómata, cuando le damos la palabra w=w 1. . . wm como input, serán (q 0, w 1. . . wm) ( (q 0, w 1), w 2. . . wm). . . ( q k, w m ) ( q r, ) para algún qk y qr. O sea: el AFD se va “comiendo” el input de a una letra, y va cambiando su estado interno según eso

AFD: Autómatas finitos deterministas 0 q 0 (q 0, 0010011) (q 0, 10011) (q 1, 0011) (q 2, ) 1 1 q 1 0, 1 0 q 2

AFD: Autómatas finitos deterministas 0 q 0 1 1 OJO, no confundirse: los nodos del grafo no son “partes” del autómata; son sus posibles estados. q 1 0, 1 0 q 2 0010011 011 11 1 q 201

AFD: Autómatas finitos deterministas 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 letras de la palabra.

AFD: Autómatas finitos deterministas • ’(q, )=q • ’(q, w )= ( ’(q, w), ) En particular se tiene ’(q, ) = ( ’(q, ), ) = ( q, ) de modo que ’ es una extensión de por lo tanto no necesitamos distinguirla escribiremos para ambas.

AFD: Autómatas finitos deterministas AFD y Lenguajes: El lenguaje aceptado (o “reconocido”) por un AFD es el conjunto de palabras en * tales que, a partir del estado inicial y siguiendo la función de transición, se llega a un estado de aceptación. En otras palabras, L(M) = { w: ( q 0, w) F }

AFD: Autómatas finitos deterministas ¿Que lenguaje acepta este autómata? 0 q 0 1 1 q 1 0, 1 0 q 2 L = {aa, } ¿Y este, con ={1}? ¿Y este, con ={0, 1}? 1 0 q 1 q 0 1 1 1 q 0 0 q 1

AFD: Autómatas finitos deterministas ¿Y aquí? ¿Y en estos? 0, 1 a q 0 a b q 2 a q 3 b b q 1 q 0 b 0, 1 b a q 4 L = {0, 1}* L= q 0 a L = palabras no vacías de {a, b}* que empiezan y terminan con la misma letra. 0, 1 q 0 O, 1 q 1 L = { }

AFD: Autómatas finitos deterministas 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. 0 0 q 0 1 q 1 0 1 q 2 0, 1 0 1 q 3 1 q 4

AFD: Autómatas finitos deterministas Un estado “basurero” es un estado de rechazo ( QF) desde el cual no hay forma de llegar a uno de aceptación. Para simplificar notación, por lo general los estados “basureros” no se dibujan; tampoco se anotan las transiciones que llevan a ellos. 0 0 q 0 1 q 1 0 1 q 2 0, 1 0 1 q 3 1 Se subentiende que las transiciones que no aparezcan en el grafo, son “prohibidas” y mandan a un estado basurero (el AFD “se cae”). q 4

Lenguajes regulares Definición: decimos que un lenguaje es regular si existe un AFD que lo reconoce. • El nombre viene de las expresiones regulares, que, como veremos, definen la misma clase de lenguajes. • ¿Serán todos lenguajes regulares? Respuesta: NO. Contraejemplo: L={anbn: n>0}

Lenguajes regulares L={anbn: n>0} ¿Por qué no es regular? Idea: Mientras voy leyendo a’s, tengo que saber cuántas he leído (de otro modo no podré saber si las b’s son la misma cantidad). Esa cantidad puede ser arbitrariamente grande. No puedo distinguir entre una cantidad arbitrariamente grande de strings leídos, si tengo una gama finita de estados! Esta idea la precisaremos pronto, como el “lema de bombeo”.

Una aplicación para AFD http: //www. cs. usfca. edu/~jbovet/vas. html • Permite construir AFD. • Permite ejecutarlos. • Avisa si está mal construido. • Java, licencia BSD Le faltan diversas funciones; si alguien encuentra alguno mejor por ahí en la wec, que avise.

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. Bosquejo (incompleto) de la solución: 1 q 1 0 q 1 1 q 00 1 q 01 … q 10 q 11 1 … 1 q 000 1 q 001 … 0 q 0 0 q 101 … 0 0 q 111 1

AFND: Autómatas finitos no deterministas Sería bastante más cómodo si pudieramos adivinar en que momento faltan sólo tres letras, y en ese momento comparar con 101. 0, 1 q 0 1 q 1 0 q 2 1 q 3 • 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 En un autómata finito no determinista existen este tipo de “bifurcaciones” en el comportamiento del autómata. 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 La función ya no es función : Q Q, pues desde un mismo q podemos pasar a más de un estado, leyendo el mismo . Por lo tanto, ahora será una función : Q 2 Q. [Recordatorio: 2 Q es el conjunto potencia de Q, o sea, el conjunto formado por todos los subconjuntos de Q. ] De paso se obvía el tema de los estados basura: simplemente se tendrá que para algunas configuraciones, (q, )=.

AFND: Autómatas finitos no deterministas Otro ejemplo: reconocer los strings que incluyen 010 en alguna parte. 0, 1 q 0 0, 1 0 q 1 1 q 2 0 q 3 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).

Clase pasada: AFD Definimos un autómata finito determinista como M = (Q, , , q 0, F) donde = {a, b} Q: estados internos : alfabeto de entrada : Q Q: función de transición q 0 Q: estado inicial a F Q: estados de aceptación b q 0 a b b a q 2 b q 3 q 1 a b q 4 a

Clase pasada: AFD Definimos un autómata finito determinista como M = (Q, , , q 0, F) donde = {a, b} Q: estados internos : alfabeto de entrada : Q Q: función de transición q 0 Q: estado inicial a F Q: estados de aceptación b q 0 a b b a q 2 b q 3 q 1 a b q 4 a

Clase pasada: AFD Definimos un autómata finito determinista como M = (Q, , , q 0, F) donde = {a, b} Q: estados internos : alfabeto de entrada : Q Q: función de transición q 0 Q: estado inicial a F Q: estados de aceptación b q 0 a b b a q 2 b q 3 q 1 a b q 4 a

Clase pasada: AFD Definimos un autómata finito determinista como M = (Q, , , q 0, F) donde = {a, b} Q: estados internos : alfabeto de entrada : Q Q: función de transición q 0 Q: estado inicial a F Q: estados de aceptación b q 0 a b b a q 2 b q 3 q 1 a b q 4 a

Clase pasada: AFD Definimos un autómata finito determinista como M = (Q, , , q 0, F) donde = {a, b} Q: estados internos : alfabeto de entrada : Q Q: función de transición q 0 Q: estado inicial a F Q: estados de aceptación b q 0 a b b a q 2 b q 3 q 1 a b q 4 a

Clase pasada: AFD Definimos un autómata finito determinista como M = (Q, , , q 0, F) donde = {a, b} Q: estados internos : alfabeto de entrada : Q Q: función de transición q 0 Q: estado inicial a F Q: estados de aceptación b q 0 a b b a q 2 b q 3 q 1 a b q 4 a

Clase pasada: AFD se extiende inductivamente a palabras: • (q, )=q • (q, w )= ( (q, w), ) Y definimos el lenguaje asociado al AFD como = {a, b} q 0 L(M) = { w: ( q 0, w) F } En este ejemplo, L={ w: |w| 1, w 1=w|w|} a b a q 2 b q 3 q 1 a b b a b q 4 a

Clase pasada: AFD Luego definimos un autómata finito no determinista como (nuevamente) M = (Q, , , q 0, F) pero donde todo se interpreta como antes, excepto que ahora : Q 2 Q q 0 0, 1 1 q 2 0 q 3 0, 1 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”

AFND: Autómatas finitos no deterministas 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, ) } = • ’(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.

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 a, b ¿Y este, con = {a, b} ? a q 4 0, 1 1 q 0 0 q 1 0 q 2 0 b 1 q 5 0, 1 q 3 b 1 ¿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 [Aquí el “>” indica el estado de inicio, y los “ 01” debieran ser “ 0, 1”. Conclusión: para hacer dibujos no recomiendo el programa que mostré. ]

AFND: Autómatas finitos no deterministas (dijimos que esos se llamaban “regulares”) 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).

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

AFND AFD Idea de por qué LN LR : consideremos de nuevo el AFND que acepta el lenguaje de strings que incluyen 010. 0, 1 0 q 0 1 q 1 0 q 2 q 3 Veamos los posibles recorridos al leer la palabra 0101: q 0 0 0 q 0 1 q 1 1 q 0 q 2 1 0 0 q 1 1 0 q 3 1 q 0 rechaza q 2 rechaza q 3 acepta

AFND AFD Idea de por qué LN LR : consideremos de nuevo el AFND que acepta el lenguaje de strings que incluyen 010. 0, 1 0 q 0 1 q 1 0 q 2 q 3 Veamos los posibles recorridos al leer la palabra 0101: q 0 0 q 1 1 q 0 0 q 2 q 1 q 3 1 q 0 q 2 q 3

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. 0, 1 0 q 0 0 0, 1 q 0 q 1 1 q 0 0 q 2 q 1 q 3 1 q 0 q 2 q 3

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’, 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 q 0 0 q 1 1 q 0 q 2 0 q 1 q 3 1 q 0 q 2 q 3

AFND AFD Otro ejemplo: 0, 1 AFND 1 q 0 AFD q 2 0 0 q 1 1 {q 0, q 1} 1 0 1 {q 0, q 2}

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 } Definición de F’ • L(M’) = { w: ’( q’ 0, w) F’ } = { w: ’( q’ 0, w) 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. ’( q’ 0, w ) = ’( ’(q 0, w), ) = ’( (q 0, w), ) = Definición (recursiva) de ’ Hipótesis de inducción Definición de ’ = (q 0, w ) 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.

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

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+ , el 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. 1 1 0 q 2 q 0 0 q 3 0 1 1 q 4

AFND+ q 0 1 = {0, 1} q 1 0 q 2 1 q 3 1 q 4 A la izquierda: palabras consistentes en 0 o más repeticiones de 10, seguidas por 0 o más repeticiones de 110. 0 = {0, 1, 2} q 0 Derecha: palabras que sólo usan dos de las 3 letras disponibles. q 1 q 2 q 3 0, 1 0, 2 1, 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 y q’ 0 = {q 0} ’( 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’=QF. 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, ))

Propiedades de clausura • Sean L 1, L 2, . . . , Ln 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 Ln = L n • Cada Ln es finito cada Ln es regular. • L es la unión de todos los Ln • 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 1L 2 [resta de conjuntos] es regular. • Sea L regular. Entonces LR es regular (LR : 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(1)=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 Las expresiones regulares (ER) son una forma compacta (y que ya conocen) de definir lenguajes. Formalmente, definimos las ER de manera recursiva. Para el alfabeto , definimos: • Las ER primitivas son , (= ) y todo . • Si r 1 y r 2 son ER, entonces (r 1) r 1* r 1+r 2 r 1 r 2 también son ER.

Expresiones regulares Cada ER r describe un lenguaje L(r); los operadores corresponden a aplicarle a esos lenguajes los siguientes operadores, listados según su orden de precendencia: 1. Estrella de Kleene, L(r 1*) = L(r 1)* 2. Unión, L(r 1+r 2) = L(r 1) L(r 2) 3. Concatenación, L(r 1 r 2) = L(r 1)L(r 2) Tal como en el álgebra, los paréntesis se usan para agrupar e imponer orden de evaluación. Trivialmente, L((r 1)) = L(r 1)

Expresiones regulares Ejemplos: (0+1 Strings de largo 1 {0, 1} (0+1)* { , 0, 1, 00, 01, 10, 11, …} (0+1)*010 (0+1)*01(0+1)* Cualquier string terminado en 010 Cualquier string que incluya 01

Expresiones regulares Ejemplos: ((0+1))* Strings de largo par ((0+1))*+((0+1)(0+1)) * Strings de largo divisible por dos o por tres Nota: cuando no haya confusión posible, es posible usar exponentes: ((0+1)2)*+((0+1)3)* ((0+1)2+(0+1)3)* Strings de largo > 1.

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. • Queremos construir una ER que lo describa. • Sabemos que L es reconocido por un AF. • Demostraremos que para todo AF, existe una ER equivalente. En realidad, demostraremos que para todo GTG existe una ER equivalente. Y los AF son caso particular de GTG.

Regular ER GTG: la misma idea que un AFND+ , pero los arcos están etiquetados por ER. Además pediremos que sean de la forma: q 3 0*11 q 0 +10* 0*1 (00+11)* q 1 1010 q 2 01 • Claramente generalizan a los AFD • La descripción formal del funcionamiento es un cacho. • Pero la idea es simple: parto de q 0 y voy “comiéndome” el input usando las etiquetas.

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. 0*1 q 0 +10* q 1 0*11 q 2 01 q 0 ( +10*)(0*1)*0*11 + 01 q 2

Regular ER En algunos textos la situación final se muestra como aquí, con loops. En tal caso, da la expresión final. Pero al pedir la forma inicial sin arcos que lleguen al inicio, ni salgan del final, esos loops se evitan, y el mono final es

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

Regular ER

Regular ER

Regular ER r 9 r 8 • Principio general: si al estado entran n arcos y salen m, habrá nm expresiones resultantes. Entran r 2 desde 1 r 6 desde 3 Loop r 4 Salen r 3 hacia 1 r 5 hacia 3

Regular ER Por lo tanto: la clase de lenguajes describibles mediante ER es exactamente la clase de lenguajes reconocibles mediante AF. A veces es más fácil trabajar con ER, a veces con AF. • Preferible ER, p. ej. , si como usuarios estamos describiendo lo queremos buscar en un archivo de texto o en una base de datos. • Preferible AFD, p. ej. , si quiero intersectar dos lenguajes regulares.

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

aa, complemento • Lo convertimos en un AFD Es fácil hacerlo “a dedo”, sin pasar por 2 Q:

aa, complemento • Invertimos los estados de aceptación • Convertimos el AFD en una ER:

aa, complemento

y crecen. . . Entonces, para el complemento de una ER o para intersectar dos ER, lo que hacemos es pasar ER AFND+ AFD ER En este y otros casos, las construcciones tienen a ir haciendo crecer (en principio, exponencialmente) la cantidad de estados de los AF con que se trabaja. Sin embargo, existe más de un AF para cada lenguaje regular. Y puede que un AF resulte ser mucho más grande que otro que es equivalente! Veremos el algoritmo para minimizar AFD

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 • Lema de bombeo para demostrar no-regularidad • Problemas de decisión

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 • 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 • Lema de bombeo para demostrar no-regularidad • Problemas de decisión

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

Minimización de AFD Idea: pueden haber estados equivalentes q 3, 4 • 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.

Minimización de AFD Idea: pueden haber estados equivalentes q 1, 2 q 3, 4 • 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.

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

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) = 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 q 1 q 2 q 3 q 4 q 0 q 1 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 • Lema de bombeo para demostrar no-regularidad • Problemas de decisión

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, q 1 q 2 • ba distingue q 0 de q 1 • a distingue q 0 de q 2 • a distingue q 1 de q 2

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

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 • Lema de bombeo para demostrar no-regularidad • Problemas de decisión

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. . . wn. La palabra w 2. . . wn 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)) no está marcado, entonces el algoritmo marcó (p, q)

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 • Lema de bombeo para demostrar no-regularidad • Problemas de decisión

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

Minimización de AFD Ejemplo: 0 0 0 q 00 q 01 1 1 0 q 1 1 1 q q 0 q 10 0 q 11 1 q 00 q 01 q 10 q 11 1 x x x q q 0 q 1 q 00 q 01 q 10 Marcamos los pares en los que un estado está en F y el otro no. Motivo: los distingue la palabra .

Minimización de AFD Ejemplo: 0 0 0 q 00 q 01 1 1 0 q 1 1 1 q q 0 q 10 0 q 11 1 q 00 x q 01 q 10 q 11 1 x x x x x q q 0 q 1 q 00 q 01 q 10 (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 Ejemplo: 0 0 0 q 00 q 01 1 1 0 q 1 1 1 q q 0 q 10 0 q 11 x q 00 q 01 x x q 10 x x x x q 11 1 Aplicamos de nuevo. 1 x x x q q 0 q 1 q 00 q 01 q 10

Minimización de AFD Ejemplo: 0 0 0 q 00 q 01 1 1 0 q 1 1 1 q q 0 q 10 0 q 11 1 x q 00 q 01 x x q 10 x x x x q 11 1 x x x q q 0 q 1 q 00 q 01 q 10 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 Ejemplo: 0 q 00 0 q 01 q 1 1 q 1 1 0 q 1 1 q 10 0 q 11 x q 00 q 01 x q 10 x x x x q 11 1 Fusiono q 0 con q. 1 x x q q 1 q 00 q 01 q 10

Minimización de AFD Ejemplo: 0 q 01 q 0 1 q 1 1 0 1 q 10 q 1 0 0 q 11 q 10 q 11 1 Fusiono q 00 con q. 1 q 01 x x x x q q 1 q 01 q 10

Minimización de AFD Ejemplo: 0 q 1 0 q 01 0 q 1 1 0 0 q 11 1 Fusiono q 10 con q. 1 q 01 q 11 x x x q q 1 q 01

Minimización de AFD Finalmente fusiono q 01 con q 1 (aunque en el fondo sólo tengo que borrarlo, pues no era alcanzable). 0 q 1 1 q 1 0 q 11 x x x q q 1 1 0 q. A 1 0 q. B 0 1 q. C 1

Minimización de AFD De hecho pueden convertirse las clases en estados directamente (en lugar de ir fusionando de a pares): 0 0 A 0 q 00 q 01 1 1 B 0 q 1 1 1 q q 0 q 10 0 C q 01 1 0 1 q 00 0 q 11 A x A x x B x x A x x x q q 0 q 1 q 00 q 01 q 10 1 0 q. A 1 0 q. B 0 1 q. C 1

Minimización de AFD No se producen inconsistencias con , pues p q (p, ) (q, ) (de lo contrario, distinguiría p y q !) B A q 2 p q 1 q w q 5 C q 6 w

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 • Lema de bombeo para demostrar no-regularidad • Problemas de decisión

[ ¿Minimización de AFND ? ] El algoritmo de minimización es para AFD. 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. 0, 1 0 1 0, 1 0 0, 1 1 0 Por ejemplo, estos tres AFND aceptan el mismo lenguaje, y claramente son mínimos (no se puede con 1 solo estado!).

[ ¿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 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 queramos construir, o el software queramos correr, no son adivinos.

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 • Lema de bombeo para demostrar no-regularidad • Problemas de decisión

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 wp una palabra tal que (q 0 , wp)=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 , wp)= ’(q’ 0 , wq).

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 , wp), u) y ( (q 0 , wq), u) uno y sólo uno F de (q 0 , wpu) y (q 0 , wqu) uno y sólo uno F de wpu y wqu, uno y sólo uno L(M). Pero en M’, ’(q’ 0 , wp)= ’(q’ 0 , wq) ’(q’ 0 , wpu)= ’(q’ 0 , wqu) wpu y wqu, o están ambas en L(M’), o ninguna. L(M) L(M’) QED

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 • Lema de bombeo para demostrar no-regularidad • Problemas de decisión

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? u M v (q 0, u)= (q 0, v) u L v no existe w que las distinga respecto a L 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.

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 • Cada clase de equivalencia de M corresponde a un estado de M. • 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 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 LC. [¿Por qué? ] LC Por lo tanto, ambas inducen refinamientos de la partición (L, LC). 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. Estamos listos para. . . L

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 • Lema de bombeo para demostrar no-regularidad • Problemas de decisión

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 Q = */ L, [conjunto de clases de equivalencia de L ] q 0 = [ ], F = { q Q: q L}, ( [u], ) = [u ] 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] Definición (recursiva) de Hipótesis de inducción Definición de

Myhill-Nerode Q = */ L, [conjunto de clases de equivalencia de L ] q 0 = [ ], F = { q Q: q L}, ( [u], ) = [u ] 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. 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. • 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. 1 0 [v] [v 1] [v 0]

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 • Lema de bombeo para demostrar no-regularidad • Problemas de decisión

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. 0 q 1 1 1 0 0 B 0 1 A 0 -1 q 11 1 1 C

La unicidad del AFD mínimo. Dados 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), ) es un isomorfismo entre M y M’. En el ejemplo de abajo, (q )=A, (q 11)=B, (q 1)=C. 0 q 1 1 1 0 0 B 0 1 A 0 -1 q 11 1 1 C

La unicidad del AFD mínimo. • Ser isomorfos (“ser el mismo”) es 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 wp una palabra tal que (q 0 , wp)=p. Sea A el AFD entregado por Myhill-Nerode para L(M). Entonces (p)=[wp] es un isomorfismo entre M y A. ejercicio

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 • Lema de bombeo para demostrar no-regularidad • Problemas de decisión

Usando 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={anbn: n>0}. Consideremos los conjuntos de palabras: S 0 = {an bn: n > 0} S 1 = {an bn-1: n > 1} S 2 = {an bn-2: n > 2}. . . Dados k j, tomamos algún n>j, n>k, y las palabras u=anbn-k Sk, v=anbn-j Sj Claramente uw L ssi w=bk, vw L ssi w=bj. Como k j, tanto bk como bj distinguen entre u y v, respecto a L. El índice de L no es finito (hay clases de equiv. ) L no es regular.

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 • Lema de bombeo para demostrar no-regularidad • Problemas de decisión

Lema del bombeo Una forma alternativa para demostrar que {anbn: n>0} no es regular es la siguiente: • Supongamos que es regular, y que M es un AF que lo reconoce. M • Sea N la cantidad de estados de M. • Usemos M para reconocer a. N+1 b. N+1.

Lema del bombeo • a. N+1 b. N+1 está en el lenguaje, así que se acepta. • Antes de terminar de leer las a’s, algún estado de M se tiene que repetir (porque sólo hay N). a a M a akb. N+1 • Por lo tanto, existe un loop. • 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 Esta idea funciona en general para lenguajes regulares, y se usa más que Myhill-Nerode en las demostraciones de no-regularidad de lenguajes. Se le conoce como lema del bombeo. [Ojo: por algún extraño motivo, la 1ª edición del Hopcroft en español traduce “sondeo”. Pero no. ] Más adelante veremos que existe una versión que se aplica a otro tipo de lenguajes. Por eso esta versión se llamará:

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 • xykz L k 0 Demostración: … x y … z QED

Lema del bombeo Escrito de manera compacta: si L es regular, entonces: n>0: w, |w| n, x, y, z, w=xyz, con |y|>0, |xy|<n, tal que k 0, xykz L Para probar que L no es regular, hay que mostrar que: n>0 w, |w| n, tal que para cualquier desglose w=xyz con |y|>0 y |xy|< n, k tal que xykz L. • Los “ ” implican que en esas partes hay que considerar cualquier valor de n, cualquier desglose de w. • Los significan que esos los podemos elegir.

Lema del bombeo Se suele aconsejar concebirlo como una competencia entre nosotros y un adversario: adversario ¡L no es regular! Sí, si es regular. Tengo un AFD. ¿En serio? ¿De cuántos estados? 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? n 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! . . . shashu

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 xykz 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 {anbn: n>0}: • Sea n la constante del bombeo. • Tomamos w=an+1 bn+1. • Sea xyz cualquier desglose de w, con |xy|<n y |y|>0. • Necesariamente, tanto x como y están dentro de a n+1. Sean p y q tales que x=ap, y=aq (p 0, q 1). z será de la forma an+1 -p-qbn+1. El teorema dice entonces que xykz = apaqkan+1 -p-qbn+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 1 • ={0, 1}, L={ uu. R: u *}. Hint: w=0 n 12 n 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 LC no es regular. L no puede serlo, pues si lo fuera, su complemento también debería serlo.

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 • Lema de bombeo para demostrar no-regularidad • Problemas de decisión

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 interesa poder contestar; a continuación, veremos formas de contestarlas. Dada una palabra w, ¿w L? Respuesta: construimos el AFD para L, y vemos si acepta w.

Problemas de decisión para LR ¿L ? Respuesta 1: construimos el AF (sirven D y ND) para L, y vemos acaso existe un camino desde q 0 hasta algún q F. Para eso podemos usar los algoritmos de recorrido de grafos vistos es EDA. Otra forma: si el AF tiene K estados, podemos hacer la prueba con todas las palabras de largo K. Si ninguna de esas se acepta, entonces L=. [¿Razón de eso? Lema de bombeo!]

Problemas de decisión para LR ¿L ? Respuesta 2: 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 queda [ejercicio] es una palabra de L. r = (a+ )(ab*+ba*)*( +b*)* (a+ )(ab+ba)( +b) (a)(ab)(b) aabb L(r)

Problemas de decisión para LR ¿Es L infinito? Recordar que eso significa: “¿Contiene L una cantidad infinita de palabras? ” Respuesta 1: Construimos un AFD para L, y vemos acaso existe un camino desde q 0 hasta algún q F que incluya algún ciclo. Nota: Funciona con AFND+ , pero no se consideran los ciclos formados por transiciones . También es EDA: Borramos todo lo que no sea alcanzable desde q 0, y todo lo que no sea alcanzable desde F siguiendo arcos al revés. En lo queda, vemos acaso hay ciclos.

Problemas de decisión para LR ¿Es L infinito? Respuesta 2: • Sea M un AFD de n estados que reconoce L. • L es infinito ssi reconoce alguna palabra de largo n m 2 n Por lo tanto, podemos probar todas esas, et voilà. Razón de que eso sea cierto: ejercicio. Pero también es vía bombeo.

Problemas de decisión para LR Dados lenguajes regulares L 1 y L 2. ¿Son iguales? Respuesta 1: • Construimos un AFD para cada uno. • Los minimizamos. • Vemos si los AFD resultantes son isomorfos. Respuesta 2: • Ver acaso L 1 L 2 = AB L 1 L 2 = (L 1L 2) (L 2L 1) = (L 1 L 2 C) (L 1 C L 2) ] A B

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.