Autómatas Finitos

Autómatas Finitos

Máquinas: simplifiquemos Computador MEF input 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.

CPU RAM Máquinas: simplifiquemos 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 MEF input 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: no acotada).

Máquinas: simplifiquemos MEF input 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 MEF input 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 MEF input 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)

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 a b d Máquinas: simplifiquemos Lavadora estado actual • Mi lavadora (simplificada): • Q = {remojo, lavado, enjuague, centrifugado, apagada} • = {r,l,e,c,a}

* Q Máquinas con input MEF input estado actual • 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

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

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

q0 q2 q1 q3 Máquinas con input 1 • 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. PILA 2 0 1 0  Usaremos nombres más neutros para los estados: q0, q1, q2, q3. 00 10 1 2 2 2 2 • Si el estado qi tiene un significado intuitivo, en general es preferible anotarlo aparte: “q1 corresponde al interruptor 1 abierto y el 2 cerrado”... 1 01 11 0 0 1

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

AFD: Autómatas finitos deterministas Un autómata finito determinista está definido por: • Un conjunto finito de estados internos, • Q={q0,..., qn} • Un alfabeto de entrada •  • Una función de transición de estados, • :QQ • Un estado inicial • q0  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, , , q0, 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 0 1 0,1 1 0 q0 q1 q2 Función de transición : Alfabeto  = {0, 1} Estados Q = {q0, q1, q2} Estado inicial q0 Estados de aceptación F = {q0, q1} input 0 1 q0 q0 q1 estados q1 q2 q1 q2 q2 q2

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=w1...wm como input, serán (q0, w1...wm)  ((q0,w1), w2...wm)  ...  ( qk, wm )  ( qr,  ) 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 1 0,1 1 0 q0 q1 q2 (q0, 0010011)  (q0, 010011)  (q0, 10011)  (q1, 0011)  (q2, 011)  (q2, 11)  (q2, 1)  (q2, )

011 0011 q2 q1 AFD: Autómatas finitos deterministas 0 1 0,1 1 0 q0 q1 q2 OJO, no confundirse: los nodos del grafo no son “partes” del autómata; son sus posibles estados. 11  010011 0010011 1 10011 q0

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 las 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: ( q0, w)  F }

¿Y este, con ={1}? ¿Y este, con ={0,1}? 1 0 1 q1 1 q0 q0 q1 1 0 AFD: Autómatas finitos deterministas ¿Que lenguaje acepta este autómata? 0 1 0,1 1 0 q0 q1 q2 L= {w{0,1}*: w no incluye 10} L= {w{1}*: |w| es impar} L= {w{0,1}*: w termina en 1}

q0 q2 q1 a b a b b b a a q3 q4 b a AFD: Autómatas finitos deterministas ¿Y aquí? ¿Y en estos? 0,1 q0 L = {0,1}* 0,1 L =  q0 0,1 O,1 q0 q1 L = palabras no vacías de {a,b}* que empiezan y terminan con la misma letra. L = {}

0 0 0, 1 0 0 1 1 1 1 q4 q2 q3 q0 q1 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.

AFD: Autómatas finitos deterministas Un estado “basurero” es un estado de rechazo (Q\F) 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 0, 1 0 0 1 1 1 1 q4 q2 q3 q0 q1 Se subentiende que las transiciones que no aparezcan en el grafo, son “prohibidas” y mandan a un estado basurero (el AFD “se cae”).

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

Bosquejo (incompleto) de la solución: 0 0 q000 1 0 q00 1 q001 q0 1 … 0 q01 … qe 1 q101 q10 0 … 1 q1 … 1 q11 1 q111 1 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 1 0 1 q0 q1 q2 q3 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. • Si en q0 leemos un “1”, tenemos dos posibles opciones. • Si “adivinamos” que estamos a tres letras del final, entonces escojo irme hacia q1.

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2Q. [Recordatorio: 2Q 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 transiciones, (q,)=.

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

q0 q3 q1 q2 q4 Clase pasada: AFD Definimos un autómata finito determinista como M = (Q, , , q0, F) donde Q: estados internos : alfabeto de entrada :QQ: función de transición q0  Q: estado inicial F  Q: estados de aceptación S= {a, b} b a b a b a a b b a

q0 q3 q1 q2 q4 Clase pasada: AFD Definimos un autómata finito determinista como M = (Q, , , q0, F) donde Q: estados internos : alfabeto de entrada :QQ: función de transición q0  Q: estado inicial F  Q: estados de aceptación  = {a, b} b a b a b a a b b a

q0 q3 q1 q2 q4 Clase pasada: AFD Definimos un autómata finito determinista como M = (Q, , , q0, F) donde Q: estados internos : alfabeto de entrada :QQ: función de transición q0  Q: estado inicial F  Q: estados de aceptación S= {a, b} b a b a b a a b b a

q0 q3 q1 q2 q4 Clase pasada: AFD  se extiende inductivamente a palabras: • (q,)=q • (q,w)= ( (q,w), ) Y definimos el lenguaje asociado al AFD como L(M) = { w: ( q0, w)  F } En este ejemplo, L={ w: |w|1, w1=w|w|} S= {a, b} b a b a b a a b b a

0,1 q0 1 q2 0 0,1 q3 “del estado q, leyendo , se pasa al estado p” En AFD, p = (q,) “del estado q, leyendo , se puede pasar al estado p” En AFND, p  (q,) Clase pasada: AFD Luego definimos un autómata finito no determinista como (nuevamente) M = (Q, , , q0, F) donde todo se interpreta como antes, excepto que ahora :Q2Q

’(q,)={q} • ’(q,w)= { p : r’(q,w) tal que p(r,) } = AFND: Autómatas finitos no deterministas Nuevamente podemos extender  para que lea más de una letra a la vez. • ’(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.

a a a AFND: Autómatas finitos no deterministas El lenguaje del AFND será L(M) = { w: (q0, 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,b ¿Y este, con  = {a,b} ? a b b 1 q4 q5 0,1 0,1 1 1 q0 0 q1 0 q2 q3 0 q3 ¿Y aquí, con  = {0,1} ? AFND: Autómatas finitos no deterministas • Más ejercicio: ver qué pasa si cambiamos a: • (q3,0) =  , (q3,1) =  • (q3,0) =  , (q3,1) = q5

1 1 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. [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é.]

(dijimos que esos se llamaban “regulares”) 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).

0,1 0,1 0 1 0 q0 q1 q2 q3 (q0, 101) (q0, 01) (q0, 1) (q0, ) rechaza (q1, 1) (q2, ) rechaza (q1, 101) (q2, 01) (q3, 1) (q3, ) acepta AFND  AFD Idea de por qué LN  LR : consideremos de nuevo el AFND que acepta el lenguaje de strings que incluyen 010. Veamos los posibles recorridos al leer la palabra 0101: (q0, 0101)

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,1 0 1 0 q0 q1 q2 q3 Veamos los posibles recorridos al leer la palabra 0101: 0 1 1 0 q0 q0 q0 q0 q0 rechaza 0 0 1 q1 q2 rechaza 1 0 1 q1 q2 q3 q3 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,1 0 1 0 q0 q1 q2 q3 Veamos los posibles recorridos al leer la palabra 0101: q0 q0 q0 q0 q0 0 1 1 0 q1 q2 q1 q2 q3 q3

Autómatas Finitos