Autómatas Finitos.

Autómatas Finitos

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

MEF CPU RAM 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.

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

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.

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.

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)

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: a b d c

Máquinas con input input MEF * Q
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 -Input con alfabeto ={0,1}
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 OFF ON 1 “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 ? PILA 2 00 10 01 11 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.

Máquinas con input 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 1  Usaremos nombres más neutros para los estados: q0, q1, q2, q3. q0 q2 q1 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 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 1 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 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

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

1 0,1 q0 1 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 1 q0 q0 q1 estados q1 q2 q1 q2 q2 q2

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

1 0,1 q0 1 q1 q2 (q0, )  (q0, )  (q0, 10011)  (q1, 0011)  (q2, 011)  (q2, 11)  (q2, 1)  (q2, )

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

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.

’(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 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 }

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

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

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

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, 1 1 1 1 1 q0 q1 q2 q3 q4 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
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. 1 … qe q0 q1 q00 q10 q01 q11 q000 q001 q101 q111 Bosquejo (incompleto) de la solución:

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. q1 q2 q3 1 q0 0,1 Si en q0 leemos un “1”, tenemos dos posibles opciones. Si “adivinamos” que estamos a tres letras del final, entonces escojo irme hacia q1.

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.

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,)=.

Otro ejemplo: reconocer los strings que incluyen 010 en alguna parte. q1 q2 q3 1 q0 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).

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} q0 q1 q2 q3 q4 a b a b b a a b b a

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} q0 q1 q2 q3 q4 a b a b b a a b b a

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} q0 q1 q2 q3 q4 a b a b b a a b b a

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} q0 q1 q2 q3 q4 a b a b b a a b b a

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 q2 q3 1 q0 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”

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.

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} ? a L = {aa, }

¿Y este, con  = {a,b} ? a b a,b q0 q1 q2 q3 q4 q5 0,1 1 ¿Y aquí, con  = {0,1} ? Más ejercicio: ver qué pasa si cambiamos a: (q3,0) =  , (q3,1) =  (q3,0) =  , (q3,1) = q5

Construir un AFND que acepte palabras que contienen dos pares de 0’s adyacentes, separados por una cantidad par de 1’s: está, también, pero no. 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é.]

(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. q1 q2 q3 1 q0 0,1 Veamos los posibles recorridos al leer la palabra 0101: (q0, 0101) (q0, 101) (q1, 101) (q0, 01) (q2, 01) (q0, 1) (q1, 1) (q3, 1) (q0, ) rechaza (q2, ) rechaza (q3, ) acepta

consideremos de nuevo el AFND que acepta el lenguaje de strings que incluyen 010. 0,1 0,1 q0 q1 1 q2 q3 Veamos los posibles recorridos al leer la palabra 0101: 1 1 q0 q0 q0 q0 q0 rechaza 1 q1 q2 rechaza q1 1 q2 q3 1 q3 acepta

consideremos de nuevo el AFND que acepta el lenguaje de strings que incluyen 010. 0,1 0,1 q0 q1 1 q2 q3 Veamos los posibles recorridos al leer la palabra 0101: q0 q0 q0 q0 q0 1 1 q1 q2 q1 q2 q3 q3

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

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 q0 q0 q0 q0 1 1 q0 q1 q2 q1 q2 q3 q3

AFND  AFD Otro ejemplo: AFND AFD 1 0, 1 q0 q1 q2 1 q0 {q0, q1}
0, 1 q0 q1 q2 AFND 1 q0 {q0, q1} {q0, q2} AFD

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

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

AFND  AFD De nuevo el ejemplo: dado el AFND
1 0, 1 q0 q1 q2 sólo esa parte es relevante (el resto no es accesible!) {q0, q1} {q0, q2} {q0, q1, q2} {q1, q2} {q0} {q1} {q2} Æ 0, 1 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 {q0}, 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 2Q.

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({})2Q q1 q2 1 q3 q4 q0  La idea es que son transiciones “gratis”, que permiten pasar de un estado a otro sin leer ningún input.

AFND+ 1 q2 q3 q4 q0 q1  S = {0,1} A la izquierda: palabras consistentes en 0 o más repeticiones de 10, seguidas por 0 o más repeticiones de 110. q1 q2 q3 q0  S = {0,1,2} 0,1 0,2 1,2 Derecha: palabras que sólo usan dos de las 3 letras disponibles.

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, , , q0, 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’ = 2Q , ’ =  , F’ = { AQ : AF } pero ahora q’0 = {q0} 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.

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.

Sean L1 y L2 lenguajes regulares, y sean M1 y M2 AFND+, de la forma previa, que los reconocen. L1  L2 también es un lenguaje regular. Demostración:

L1L2 también es un lenguaje regular: L1+ también es un lenguaje regular:

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

L1C también es un lenguaje regular. Demostración: sea M = (Q, , , q0, F) un AFD que reconoce a L1 (ojo: determinista). Definimos M’ = (Q, , , q0, F’), con F’=Q\F.  L(M’)=L1C

L1  L2 también es un lenguaje regular: Demostración 1: Notamos que, por ley de Morgan, L1L2=(L1C L2C)C y aplicamos los resultados previos. Demostración 2: Sean A1 = (Q1, , 1, q0,1, F1) y A2 = (Q2, , 2, q0,2, F2) dos AFD que reconocen L1 y L2 respectivamente. Definimos M=(Q, , , q0, F) con Q = Q1Q2 q0 = (q0,1,q0,2) F= F1F2 ((q1,q2),) = (1(q1,), 2(q2,)) Idea: al leer w con M, estaremos leyendo w con A1 y A2 simultaneamente; la aceptamos sólo si ambos la aceptan (“a la vez”).

Sean L1, L2, ..., 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.

Sean L1, L2, ... 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!

Ejercicios: Sean L1 y L2 regulares. Entonces L1\L2 [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.

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

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.

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 , 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 r1 y r2 son ER, entonces (r1) r1* r1+r2 r1r2 también son ER.

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(r1*) = L(r1)* 2. Unión, L(r1+r2) = L(r1)L(r2) 3. Concatenación, L(r1r2) = L(r1)L(r2) Tal como en el álgebra, los paréntesis se usan para agrupar e imponer orden de evaluación. Trivialmente, L((r1)) = L(r1)

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

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

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: e+10* (00+11)* 0*1 q0 q1 q2 01 q3 0*11 1010 Claramente generalizan a los AFD La descripción formal del funcionamiento es un cacho. Pero la idea es simple: parto de q0 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. e+10* 0*11 0*1 q0 q1 q2 01 q0 q2 01 (e+10*)(0*1)*0*11 q0 q2 (e+10*)(0*1)*0*

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 r9 Principio general: si al estado entran n arcos y salen m, habrá nm expresiones resultantes. Entran Loop Salen r2 desde 1 r4 r3 hacia 1 r6 desde 3 r5 hacia 3 r8

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 que 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 2Q: Nota: hay que agregar el estado “basurero”, pues en AFD toda transición (q,) debe estar definida (y eso incluye =b).

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

aa,complemento

y crecen y crecen... Entonces, para el complemento de una ER o para intersectar dos ER, lo que hacemos es pasar ER  AFND+  AFD  AFD  ER En este y otros casos, las construcciones tienden 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).

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

Tanto a partir de q1 como q2 el AFD aceptará ssi el resto del string consiste sólo en a’s.  Son equivalentes, y los podemos combinar.

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:
q0 q1 q2 q0,2 q1

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,q0) = b*aa* L(M,q1) = a* L(M,q2) = a*
 q1  q2 q3  q4 q0 q1 q2 L(M,q0) = cantidad impar de 0’s L(M,q1) = cantidad par de 0’s L(M,q2) = cantidad impar de 0’s  q0  q2

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. q1 q2 En este caso, ba distingue q0 de q1 a distingue q0 de q2 a distingue q1 de q2

Minimización de AFD Algoritmo de minimización:
Eliminar todos los estados no alcanzables desde q0. Determinar los pares de estados equivalentes. 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). Marcamos todos los pares en los que un estado es de aceptación y el otro no. Para todo (p,q) no marcado y para todo , si ((p, ), (q, ) ) está marcado  marcar (p,q). Si en (2) se marcó algo, repetir (2).

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= w1w2...wn. La palabra w2...wn distingue (p, w1) de (q, w1), pues de lo contrario w no distinguiría p de q. Si ((p, w1),(q, w1)) no está marcado, entonces w no era de largo mínimo  Si ((p, w1),(q, w1)) no está marcado, entonces el algoritmo marcó (p,q) 

Minimización de AFD Ejemplo:
q0 q00 q1 q0 1 1 q01 q00 qe 1 q01 q10 1 1 q10 q1 1 q11 q11 qe q0 q1 q00 q01 q10 1 AFD que reconoce las palabras terminadas en 11. ¿Será el más chico posible?  Hacemos la tabla.

Minimización de AFD Ejemplo: x x x x x x
q0 q00 q1 q0 1 1 q01 q00 qe 1 q01 q10 1 1 q10 q1 1 q11 q11 x x x x x x qe q0 q1 q00 q01 q10 1 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: x x x x x x x x x x
q0 q00 q1 x x q0 1 1 q01 q00 x qe 1 q01 q10 1 1 q10 x q1 1 q11 q11 x x x x x x qe q0 q1 q00 q01 q10 1 (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: x x x x x x x x x x x x x x
q0 q00 q1 x x q0 1 1 q01 q00 x qe 1 q01 x x x q10 1 1 q10 x x q1 1 q11 q11 x x x x x x qe q0 q1 q00 q01 q10 1 Aplicamos de nuevo.

Minimización de AFD Ejemplo: x x x x x x x x x x x x x x
q0 q00 q1 x x q0 1 1 q01 q00 x qe 1 q01 x x x q10 1 1 q10 x x q1 1 q11 q11 x x x x x x qe q0 q1 q00 q01 q10 1 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: x x x x x x x x x x x Fusiono q0 con q.
q00 q1 x 1 q01 q00 x qe 1 q01 x x q10 1 1 q10 x x q1 1 q11 q11 x x x x x qe q1 q00 q01 q10 1 Fusiono q0 con q.

Minimización de AFD Ejemplo: x x x x x x x x Fusiono q00 con q. q01
q01 q1 x qe 1 q01 x q10 1 1 q10 x x q1 1 q11 q11 x x x x qe q1 q01 q10 1 Fusiono q00 con q.

Minimización de AFD Ejemplo: x x x x x Fusiono q10 con q. q01 qe q1 1
q01 qe q1 x 1 1 q01 x q1 1 q11 q11 x x x qe q1 q01 1 Fusiono q10 con q.

Minimización de AFD Finalmente fusiono q01 con q1 (aunque en el fondo sólo tengo que borrarlo, pues no era alcanzable). qe 1 q1 x q1 1 q11 q11 x x qe q1 1 1 1 qA qB qC 1

Minimización de AFD De hecho pueden convertirse las clases en estados directamente (en lugar de ir fusionando de a pares): q0 A B q00 q1 x x A q0 1 1 q01 q00 x qe 1 q01 x x x q10 1 1 q10 x x q1 B 1 q11 q11 x x x x x x C qe q0 q1 q00 q01 q10 1 1 qA qB qC

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 q1 B q5 q2 C q6  w

[ ¿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 1 0,1 0,1 1 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 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, , , q0, 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 (q0 , 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 ((q0 , wp), u) y ((q0 , wq), u) uno y sólo uno  F  de (q0 , wpu) y (q0 , 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

Minimización de AFD: ¿por qué funciona?
Para entender un poco mejor lo que está pasando, consideremos M =(Q, , , q0, 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  (q0,u)= (q0,v) u L v  no existe w que distinga u de v respecto a L

uM v  (q0,u)= (q0,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  (q0,u)= (q0,v)  (q0,uw)= (q0,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].

uM v  (q0,u)= (q0,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.

uM v  (q0,u)= (q0,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).

uM v  (q0,u)= (q0,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
LC L 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é?] 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...

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

q0 = [], 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 

q0 = [], 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? 1 [v] [v1]
1 [v] [v1] [v0] 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.

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.

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 qe q1 q11  -1 1 A C B

Dados dos AFD M=(Q, , , q0, F) y M’=(Q’, , ’, q’0, F’), son “el mismo” ssi existe :QQ’ biyectiva tal que (q0) = q’0 (F) = F’ ((q,)) = ((q),) En el ejemplo de abajo, (q)=A, (q11)=B, (q1)=C.  es un isomorfismo entre M y M’.  -1 1 qe B 1 A q1 1 1 q11 1 C 1

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 wp una palabra tal que (q0 , wp)=p. Sea A el AFD entregado por Myhill-Nerode para L(M). Entonces (p)=[wp] 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.
L1 = { palabras con la misma cantidad de 0’s y 1’s } L2 = { 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: S0 = {an bn: n > 0} S1 = {an bn-1: n > 1} S2 = {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.

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 aN+1bN+1.

Lema del bombeo aN+1bN+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). M a akbN+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 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: nosotros 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!

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+1bn+1. Sea xyz cualquier desglose de w, con |xy|<n y |y|>0. Necesariamente, tanto x como y están dentro de an+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=0n10n1 ={0,1}, L={ uuR: u *}. Hint: w=0n12n0n ={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=0n1n-1. Nuevamente, al hacer w=xyz necesariamente x e y son sólo 0’s: x=0p y=0q z=0n-p-q1n-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 xy0z = xz = 0p0n-p-q1n-1 = 0n-q1n-1  Como q1, n-q  n-1  xy0z  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.

Fin de la materia que entra en el certamen 1

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.

Respuesta 1: construimos el AF (sirven D y ND) para L, y vemos acaso existe un camino desde q0 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!]

Ojo: recordar en este contexto que  es una palabra: si lo que nos queda es , entonces no es vacío. ¿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 cualquiera, p.ej., 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)

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

¿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  2n Por lo tanto, podemos probar todas esas, et voilà. Razón de que eso sea cierto: ejercicio. Pero también es vía bombeo.

Dados dos lenguajes regulares L1 y L2. ¿Son iguales? Respuesta 1: Construimos un AFD para cada uno. Los minimizamos. Vemos si los AFD resultantes son isomorfos. Respuesta 2: Ver acaso L1L2 =  A\B AB L1L2 = (L1\L2)  (L2\L1) = (L1L2C)  (L1CL2) ]  Es regular y podemos construirle un AFD, según vimos en las propiedades de clausura. Luego aplicamos lo de la transparencia 173.

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.

Lo que va quedando del tema "regular"
Algunos “parientes cercanos” de los AF Aplicaciones? Un par de comentarios sobre 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.

[Vale la pena imaginarlo así: es un esquema que se repetirá dentro del curso.] . . . x x x x 1 2 n - 1 n 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. AF D Agregamos unos símbolos que marcan el comienzo y fin de la palabra. El cabezal recorre de izquierda a derecha, hasta encontrar el final.

. . . x x x x 1 2 n - 1 n En un "2-AFD" (AFD bidireccional) el cabezal puede retroceder. 2 AF D 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".

. . . x x x x 1 2 n - 1 n  Desaparece “F” (el conjunto de estados de aceptación). 2 AF D 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. Demostración: Hopcroft (teo. 2.5 en 1ªed, esp.)

Un tipo de variante que sí cambia (un poco) las cosas: autómatas traductores (transducers). input MEF estado actual output 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.

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

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, , , ', , q0). :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=w1,...,wm, y pasar por los estados p0, p1, ..., pm donde p0 = q0 p1 = (q0,w1) p2 = (q0,w1w2) = (p1,w2) ... pm = (q0,w) = (pm-1,wm) el autómata escribirá el output (p0)(p1)(p2)...(pm) q1 q2 1 0,1 q0 a b input aaaababa output

Máquina de Mealy La máquina de Mealy será M=(Q, , , ', , q0), pero ahora :Q ', y para la misma palabra w=w1,...,wm anterior que hace pasar al autómata por p0, p1, ..., pm, el output será (q0,w1)(p1,w2)...(pm-1, wm) input bbaabab output q1 q2 1 0,1 q0 1/a 0/a,1/b 0/b 1/b Nótese que Mealy escribe una letra menos que Moore (pues Moore escribe algo ya en q0, antes de leer nada).

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.

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 r1 escribamos algo según una ER r2. Lo escribimos r1:r2, 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}
Todas las transiciones no mostradas van al estado 0. c c a c c t 1 2 3 4 5 6 c c 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.

Algo más sobre expresiones regulares
Las ER se usan para describir patrones en el texto (no palabras específicas, sino conjuntos de palabras que siguen un mismo esquema). Aparecen por muchos lados: editores de texto, compiladores, bases de datos, motores de búsqueda, catálogos... No nos detendremos mayormente en ellas, pero insisto: sepan escribir ER. Sacan de apuros en muchos contextos.

Escribir ER no es demasiado difícil; lo importante es saber cuál es la sintaxis precisa en el programa o lenguaje en cuestión. También es bueno conocer los eventuales “superpoderes” (extensiones no estándar; en muchos casos, exceden lo estrictamente regular). Algunos ámbitos en que es bueno saber que existen: comando grep en Unix, módulo re en Python, java.util.regex, perl, búsquedas en code.google.com...

La sintaxis suele ser similar a la de Perl, excepto en grep y otras herramientas Unix, que siguen el estándar POSIX. Los detalles en todo caso pueden ser bastante enredados. En todo caso, las cosas más simples son comunes a casi todas las sintaxis: . : comodín (un único carácter, que puede ser cualquiera) x*: cero o más repeticiones de x (estrella de Kleene) x+: una o más repeticiones de x x?: x puede aparecer una vez, o ninguna

xy: concatenación x|y: x ó y (lo que aquí anotamos x+y) (xy): agrupa caracteres [abc] : agrupa caracteres; equivale a (a|b|c), o sea, a+b+c [a-c]: equivale a [abc] [a-zA-Z]: cualquier letra x{n}: n repeticiones de x, es decir, xxx...x, n veces. Hay caracteres que indican "comienzo de string" o "fin de string": ^ y $, respectivamente, en Perl.

Ejemplo, patentes de autos: [A-Z]{2} ([A-Z]{2}|[0-9]{2})[0-9]{2} Todo eso calza dentro del esquema de las ER "clásicas". También hay abreviaturas (con "\", o con [:algo:] en posix) para conjuntos de caracteres que se usan con frecuencia, y para representar caracteres usados en la sintaxis (como el "["). Mientras estemos en ER "correctas", la implementación suele ser vía AFD.

Perl se sale de eso y permite "capturar" parte del string reconocido, y luego hacer referencia a la parte capturada (fuera o dentro de la ER). Eso a su vez permite reconocer cosas del tipo {uu:u*}, que no son regulares. Por eso Perl no usa AFD (como sí hace grep) para buscar sus “expresiones regulares”, sino backtracking. Se suele llamar expresiones regulares (regexp) a esas expresiones extendidas, aunque técnicamente no lo sean.

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 (de los antiguos, que se llamaban con una línea de texto). O al preparar el código de un programa para ser compilado.

Análisis léxico Analizador léxico Parser asignación Expresión Total :=
+ v ; Total = precio + iva ; Parser asignación Expresión Total := id id 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 Output Identifier: Var Operand: = Integer: 12
Uso típico de un programa creado por lex: Output Identifier: Var Operand: = Integer: 12 Operand: + Integer: 9 Semicolon: ; Keyword: if Parenthesis: ( Identifier: test .... Input Var = ; if (test > 20) temp = 0; else while (a < 20) temp++; programa generado por lex

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

¿Parseo? Analizador léxico T o t a l = p r e c i + v ; Total = precio + iva ; Esta fase por lo general requiere más poder que el que dan los lenguajes regulares. Allá vamos. Parser asignación Expresión Total := id id precio iva

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 Una derivación de "un niño corre":
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  A T P  A T V  un T V  un T corre  un niño corre

Gramáticas O  S P Lenguaje descrito por esta gramática:
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"}

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

Gramáticas Otro ejemplo: Lenguaje: Algunas derivaciones:

Autómatas Finitos.

Presentaciones similares

Presentación del tema: "Autómatas Finitos."— 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.

Presentaciones similares

Presentación del tema: "Autómatas Finitos."— Transcripción de la presentación:

Presentaciones similares

Sobre el proyecto

Feedback