Aut matas finitos
This presentation is the property of its rightful owner.
Sponsored Links
1 / 211

Autómatas Finitos PowerPoint PPT Presentation


  • 71 Views
  • Uploaded on
  • Presentation posted in: General

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.

Download Presentation

Autómatas Finitos

An Image/Link below is provided (as is) to download presentation

Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author.While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server.


- - - - - - - - - - - - - - - - - - - - - - - - - - E N D - - - - - - - - - - - - - - - - - - - - - - - - - -

Presentation Transcript


Aut matas finitos

Autómatas Finitos


M quinas simplifiquemos

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.


M quinas simplifiquemos1

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 simplifiquemos2

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 simplifiquemos3

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 simplifiquemos4

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 simplifiquemos5

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)


M quinas simplifiquemos6

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}


M quinas con input

*

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


M quinas con input1

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”


M quinas con input2

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.


M quinas con input3

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 input4

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

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 deterministas1

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 deterministas2

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 deterministas3

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 deterministas4

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, )


Afd aut matas finitos deterministas5

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 deterministas6

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 deterministas7

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 deterministas8

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 }


Afd aut matas finitos deterministas9

¿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}


Afd aut matas finitos deterministas10

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 = {}


Afd aut matas finitos deterministas11

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 deterministas12

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

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 regulares1

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

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

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.


Afnd aut matas finitos no deterministas1

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 deterministas2

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 deterministas3

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


Afnd aut matas finitos no deterministas4

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


Clase pasada afd

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


Clase pasada afd1

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


Clase pasada afd2

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


Clase pasada afd3

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


Clase pasada afd4

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


Clase pasada afd5

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


Clase pasada afd6

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


Clase pasada afd7

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


Afnd aut matas finitos no deterministas5

  • ’(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.


Afnd aut matas finitos no deterministas6

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, }


Afnd aut matas finitos no deterministas7

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


Afnd aut matas finitos no deterministas8

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


Afnd aut matas finitos no deterministas9

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


Afnd afd

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 afd1

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 afd2

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


Afnd afd3

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

0

1

0

q0

q1

q2

q3

q0

q0

q0

q0

q0

0

1

1

0

q1

q2

q1

q2

q3

q3


Afnd afd4

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

0

1

1

0

q0

q1

q2

q1

q2

q3

q3


Afnd afd5

0, 1

AFND

1

0

q0

q1

q2

AFD

0

0

0

1

{q0, q1}

{q0, q2}

q0

1

1

AFND  AFD

Otro ejemplo:


Afnd afd6

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 afd7

Definición de F’

’( q’0, w) = ’( ’(q0,w), ) = ’( (q0,w), ) =

= (q0,w)

Definición (recursiva) de ’

Hipótesis de inducción

Definición de ’

Definición (recursiva) de 

AFND  AFD

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


Afnd afd8

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 afd9

De nuevo el ejemplo: dado el AFND

0, 1

1

0

q0

q1

q2

la construcción da el AFD:

sólo esa parte es relevante (el resto no es accesible!)

AFND  AFD

0

1

1

{q0}

{q0, q1}

1

0, 1

0

0

1

0

1

Æ

{q0, q2}

{q0, q1, q2}

{q1}

0

0, 1

0

{q2}

{q1, q2}

1


Afnd afd10

Para el AFND de la derecha (que vimos antes), el programa dio el AFD de abajo.

Feo, pero nótese que sólo usa 14 de los 64 subconjuntos de 2Q.

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.

1

1


Aut matas finitos

1

1

0

q2

q1

0

0

0

1

q4

q3

1

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

q0

La idea es que son transiciones “gratis”, que permiten pasar de un estado a otro sin leer ningún input.


Aut matas finitos

1

S= {0,1}

q0

q1

0

1

1

q2

q3

q4

0

S= {0,1,2}

q0

q1

q2

q3

0,1

0,2

1,2

AFND+

A la izquierda: palabras consistentes en 0 o más repeticiones de 10, seguidas por 0 o más repeticiones de 110.

Derecha: palabras que sólo usan dos de las 3 letras disponibles.


Aut matas finitos

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


Aut matas finitos

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.


Aut matas finitos

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.


Aut matas finitos

AFND+

Ejemplo:

 Palabras que comienzan y terminan en a, y no tienen dos b consecutivas.


Af fa

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

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 clausura1

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 clausura2

Propiedades de clausura

  • 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:


Propiedades de clausura3

Propiedades de clausura

  • L1L2 también es un lenguaje regular:

  • L1+ también es un lenguaje regular:


Propiedades de clausura4

Propiedades de clausura

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


Propiedades de clausura5

Propiedades de clausura

  • 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


Propiedades de clausura6

Propiedades de clausura

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


Propiedades de clausura7

  • Sean L1, L2, ..., Ln lenguajes regulares. Entonces

también es un lenguaje regular.

Propiedades de clausura

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 clausura8

Propiedades de clausura

  • 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!


Propiedades de clausura9

Propiedades de clausura

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


Propiedades de clausura10

Propiedades de clausura

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


Propiedades de clausura11

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 clausura12

Propiedades de clausura

  • Ejemplo de homomorfismo:

    • 1={0,1}

    • 2={a,b}

    • h definida por h(0)=ab, h(1)=

    • h(0011)=h(0)h(0)h(1)h(1)=abab=abab

    • L = palabras de la forma 100...001, con al menos un 0.

    • h(L) = palabras de la forma ababab...ab, con al menos un ab.


Expresiones regulares

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.


Expresiones regulares1

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


Expresiones regulares2

(0+1

 {0, 1}

(0+1)*

 {e, 0, 1, 00, 01, 10, 11, …}

Expresiones regulares

Ejemplos:

Strings de largo 1

Cualquier string

(0+1)*010

Cualquier string terminado en 010

(0+1)*01(0+1)*

Cualquier string que incluya 01


Expresiones regulares3

((0+1)2)*+((0+1)3)*

Expresiones regulares

Ejemplos:

((0+1)(0+1))*

Strings de largo par

((0+1)(0+1))*+((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:

Strings de largo > 1.

((0+1)2+(0+1)3)*


Er regular

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

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 er1

q3

0*1

1010

0*11

e+10*

(00+11)*

q0

q1

q2

01

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:

  • 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 er2

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 er3

Regular  ER

0*1

Cuando sólo queden los extremos, la etiqueta del arco sobreviviente es la ER que andábamos buscando.

e+10*

0*11

q0

q1

q2

01

(e+10*)(0*1)*0*11

q0

q2

01

(e+10*)(0*1)*0*11 + 01

q0

q2


Regular er4

da la expresión final.

Regular  ER

En algunos textos la situación final se muestra como aquí, con loops.

En tal caso,

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 er5

Regular  ER

  • Los mágicos pasos intermedios.

  • Si llega a haber más de un arco entre dos nodos, los juntamos en uno:


Regular er6

Regular  ER


Regular er7

Regular  ER


Regular er8

Regular  ER


Regular er9

Regular  ER

r9

  • Principio general: si al estado entran n arcos y salen m, habrá nm expresiones resultantes.

r8


Regular er10

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

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 complemento1

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 complemento2

aa,complemento

  • Invertimos los estados de aceptación

  • Convertimos el AFD en una ER:


Aa complemento3

aa,complemento


Y crecen y crecen

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

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

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 afd1

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 rutero1

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 afd2

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.


Minimizaci n de afd3

Minimización de AFD

Idea: pueden haber estados equivalentes

q3,4

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


Minimizaci n de afd4

Minimización de AFD

Idea: pueden haber estados equivalentes

q1,2

q3,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 afd5

q0

q1

q2

q0,2

q1

Minimización de AFD

No siempre es tan obvio como en el ejemplo previo:


Minimizaci n de afd6

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 afd7

q0

q1

q2

Minimización de AFD

L(M,q0) = b*aa*

L(M,q1) = a*

L(M,q2) = a*

L(M,q3) = 

L(M,q4) = 

q1 q2

q3 q4

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


Mapa rutero2

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 afd8

q1

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.

  • En este caso,

    • ba distingue q0 de q1

    • a distingue q0 de q2

    • a distingue q1 de q2


Minimizaci n de afd9

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 afd10

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


Mapa rutero3

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 afd11

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 afd12

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) 


Mapa rutero4

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 afd13

Minimización de AFD

Ejemplo:

0

q0

0

q00

q1

q0

1

0

1

q00

q01

0

qe

1

0

q01

q10

0

1

1

q10

q1

0

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 afd14

Minimización de AFD

Ejemplo:

0

q0

0

q00

q1

q0

1

0

1

q00

q01

0

qe

1

0

q01

q10

0

1

1

q10

q1

0

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 afd15

Minimización de AFD

Ejemplo:

0

q0

0

q00

q1

x

x

q0

1

0

1

q00

x

q01

0

qe

1

0

q01

q10

0

1

1

x

q10

q1

0

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 afd16

Minimización de AFD

Ejemplo:

0

q0

0

q00

q1

x

x

q0

1

0

1

q00

x

q01

0

qe

1

0

x

x

x

q01

q10

0

1

1

x

x

q10

q1

0

1

q11

q11

x

x

x

x

x

x

qe

q0

q1

q00

q01

q10

1

Aplicamos de nuevo.


Minimizaci n de afd17

Minimización de AFD

Ejemplo:

0

q0

0

q00

q1

x

x

q0

1

0

1

q00

x

q01

0

qe

1

0

x

x

x

q01

q10

0

1

1

x

x

q10

q1

0

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 afd18

Minimización de AFD

Ejemplo:

0

q00

q1

x

1

0

q00

x

q01

0

qe

1

0

x

x

q01

q10

0

1

1

x

x

q10

q1

0

1

q11

q11

x

x

x

x

x

qe

q1

q00

q01

q10

1

Fusiono q0 con q.


Minimizaci n de afd19

Minimización de AFD

Ejemplo:

0

q01

q1

x

qe

1

0

0

x

q01

q10

0

1

1

x

x

q10

q1

0

1

q11

q11

x

x

x

x

qe

q1

q01

q10

1

Fusiono q00 con q.


Minimizaci n de afd20

Minimización de AFD

Ejemplo:

0

q01

0

qe

q1

x

0

1

1

x

q01

0

q1

0

1

q11

x

x

x

q11

qe

q1

q01

1

Fusiono q10 con q.


Minimizaci n de afd21

Minimización de AFD

Finalmente fusiono q01 con q1 (aunque en el fondo sólo tengo que borrarlo, pues no era alcanzable).

0

qe

0

1

q1

x

0

q1

1

q11

x

x

q11

qe

q1

1

0

1

1

qA

qB

qC

1

0

0


Minimizaci n de afd22

A

A

A

B

A

A

A

0

1

1

qA

qB

qC

1

0

0

Minimización de AFD

De hecho pueden convertirse las clases en estados directamente (en lugar de ir fusionando de a pares):

0

q0

0

q00

q1

x

x

A

q0

1

0

1

q00

x

q01

0

qe

1

0

x

x

x

q01

q10

0

1

1

x

x

q10

q1

0

1

B

q11

q11

x

x

x

x

x

x

C

qe

q0

q1

q00

q01

q10

1


Minimizaci n de afd23

B

q5

A

q2

p

q1

q

C

q6

Minimización de AFD

No se producen inconsistencias con , pues

pq  (p, )(q, ) 

(de lo contrario,  distinguiría p y q !)

w

w


Mapa rutero5

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 af nd

0,1

1

0,1

0,1

0,1

1

0

0

0

[ ¿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.

Por ejemplo, estos tres AFND aceptan el mismo lenguaje, y claramente son mínimos (no se puede con 1 solo estado!).


Minimizaci n de af nd1

[ ¿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.


Mapa rutero6

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

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 nimo1

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


Mapa rutero7

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

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 “wdistingue 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


Minimizaci n de afd por qu funciona1

Minimización de AFD: ¿por qué funciona?

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


Minimizaci n de afd por qu funciona2

Minimización de AFD: ¿por qué funciona?

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.


Minimizaci n de afd por qu funciona3

Minimización de AFD: ¿por qué funciona?

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


Minimizaci n de afd por qu funciona4

Minimización de AFD: ¿por qué funciona?

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 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é?]

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


Mapa rutero8

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

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 nerode1

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 nerode2

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]


Myhill nerode3

Definición (recursiva) de 

Hipótesis de inducción

Definición de 

Myhill-Nerode

Q = */L, [conjunto de clases de equivalencia de L ]

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]


Myhill nerode4

Myhill-Nerode

Q = */L, [conjunto de clases de equivalencia de L ]

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 nerode5

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 nerode6

0

1

[v]

[v1]

[v0]

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.


Mapa rutero9

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

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 nimo1

0

1

0

qe

0

B

0

1

A

0

q1

-1

1

1

0

q11

1

C

1

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.


La unicidad del afd m nimo2

-1

La unicidad del AFD mínimo.

  • 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’.

0

1

0

qe

0

B

0

1

A

0

q1

1

1

0

q11

1

C

1


La unicidad del afd m nimo3

ejercicio

La unicidad del AFD mínimo.

  • Ser isomorfos (“ser el mismo”) es claramente una relación de equivalencia entre AFD.

    • Para probar que dos AFD son isomorfos, sirve probar que ambos son isomorfos a un tercero.

  • Para demostrar la unicidad del AFD mínimo, se demuestra que es isomorfo al AFD construido en la demostración de Myhill-Nerode:

    • Sea M un AFD minimizado, y para cada estado p de M, sea 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.


Mapa rutero10

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

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 nerode1

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 nerode2

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.


Mapa rutero11

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

M

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.

  • Sea N la cantidad de estados de M.

  • Usemos M para reconocer aN+1bN+1.


Lema del bombeo1

a

M

a

a

a

a

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

  • 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 bombeo2

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 bombeo3

y

z

x

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:

QED


Lema del bombeo4

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 bombeo5

Lema del bombeo

Se suele aconsejar concebirlo como una competencia entre nosotros y un adversario:

adversario

nosotros

¡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 bombeo6

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 bombeo7

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 bombeo8

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 bombeo9

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 bombeo10

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

Fin de la materia que entra en el certamen 1


Mapa rutero12

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

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 lr1

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 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!]


Problemas de decisi n para lr2

Problemas de decisión para LR

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)


Problemas de decisi n para lr3

Problemas de decisión para LR

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


Problemas de decisi n para lr4

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


Problemas de decisi n para lr5

A\B AB

Problemas de decisión para LR

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 = 

  • 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

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

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

Variantes respecto a los AF

  • Hay un montón de variaciones respecto a los AF que hemos visto, de acuerdo a los distintos usos prácticos o teóricos que se les quieran dar.

  • En la medida en que la memoria siga siendo finita, el poder de cómputo no cambia.

  • Un ejemplo: AF bidireccionales (“2-way FA”).

  • Primero que nada, pensemos en un AF como una maquinita que va recorriendo una cinta con su input.


Variantes respecto a los af1

Variantes respecto a los AF

[Vale la pena imaginarlo así: es un esquema que se repetirá dentro del curso.]

.

.

.

x

x

x

x

n

n

1

2

-

1

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


Variantes respecto a los af2

Variantes respecto a los AF

.

.

.

x

x

x

x

n

n

1

2

-

1

  • 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".


Variantes respecto a los af3

Demostración: Hopcroft (teo. 2.5 en 1ªed, esp.)

Variantes respecto a los AF

.

.

.

x

x

x

x

n

n

1

2

-

1

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


Variantes respecto a los af4

MEF

input

estado actual

Variantes respecto a los AF

  • Un tipo de variante que sí cambia (un poco) las cosas: autómatas traductores (transducers).

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.


Variantes respecto a los af5

a

Moore escribe cuando pasa por un estado (asocia letras a los nodos del grafo de transición).

a

0

0

q0

q0

0/b

b

1

1

1/a

q1

q1

Mealy escribe al pasar de un estado a otro (asocia letras a los arcos del grafo de transición).

1

1/b

0/a,1/b

0,1

0,1

0/b

0

0

q2

q2

Variantes respecto a los AF

Los dos sabores más conocidos son las máquinas de Moore y las máquinas de Mealy. La diferencia:

0

q0

1

q1

1

0,1

0

q2

1


Variantes respecto a los af6

Variantes respecto a los AF

  • Se usa un alfabeto de salida ', que puede ser o no distinto del de entrada.

  • Nótese que no ponemos estados de aceptación: ya no nos interesa eso, nos interesa la transformación de una palabra en otra.

  • Formalmente, una máquina de Moore será una tupla M=(Q, , , ', , q0).

  • :Q ' indica qué letra debe escribirse al pasar por cada estado.


M quina de moore

a

a

0

q0

b

1

q1

1

0,1

0

q2

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)

0010101 input

aaaababa output


M quina de mealy

0

q0

0/b

1

1/a

q1

1

1/b

0/a,1/b

0,1

0/b

0

q2

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)

0010101 input

bbaabab output

  • Nótese que Mealy escribe una letra menos que Moore (pues Moore escribe algo ya en q0, antes de leer nada).


Variantes respecto a los af7

Variantes respecto a los AF

  • Cada máquina de Moore (o de Mealy) define una función * ' *. Si se agrega no-determinismo, será una relación (entre palabras).

  • En principio Mealy se ve más poderoso que Moore (pues distingue qué transición se usa). Sin embargo, para cada máquina de Mealy existe una de Moore equivalente y viceversa (ver Hopcroft).

  • Las relaciones (entre palabras) que pueden ser descritas de esta forma se llaman relaciones regulares, y tienen propiedades de clausura (y definición recursiva) análogas a los lenguajes regulares.


Variantes respecto a los af8

(a*:b)(ab:a)*

ab:a

a*:b

Variantes respecto a los AF

  • Es posible combinar con autómatas aceptadores. En ese caso, ponemos además un conjunto de estados de aceptación. El AFD funcionará como siempre, pero irá escribiendo mientras lee.

  • También es posible extender el formalismo de las expresiones regulares, para que al reconocer una ER r1 escribamos algo según una ER r2. Lo escribimos r1:r2, y en general será no-determinista.

  • Etc, etc...


Aplicaciones

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


Aplicaciones1

acaggccaccaac

ccacct

¿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!

 Cuando detecto esa diferencia, no necesito probar con ccacct ubicada 1 o 2 posiciones a la derecha: puedo avanzar 3 altiro.


Aplicaciones2

¿Aplicaciones?

ccacct, ={a,c,g,t}

c

a

Todas las transiciones no mostradas van al estado 0.

a

c

c

t

c

c

0

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

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.


Algo m s sobre expresiones regulares1

Algo más sobre expresiones regulares

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


Algo m s sobre expresiones regulares2

Algo más sobre expresiones regulares

  • 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


Algo m s sobre expresiones regulares3

Algo más sobre expresiones regulares

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


Algo m s sobre expresiones regulares4

Algo más sobre expresiones regulares

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


Algo m s sobre expresiones regulares5

Algo más sobre expresiones regulares

  • 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

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 xico1

Análisis léxico

Analizador léxico

Parser

asignación

Expresión

Total

:=

id + id

precio

iva


An lisis l xico lex

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 lex1

Análisis léxico: LEX

  • 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 = 12 + 9;

if (test > 20)

temp = 0;

else

while (a < 20)

temp++;

programa

generado

por lex


An lisis l xico lex2

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

Esta fase por lo general requiere más poder que el que dan los lenguajes regulares.

Allá vamos.

¿Parseo?

Analizador léxico

Parser

asignación

Expresión

Total

:=

id + id

precio

iva


Gram ticas

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 ticas1

Gramáticas

O  SP

S  AT

P  V

A  el

A  un

T  niño

T  perro

V  corre

V  camina

Una derivación de "un niño corre":

O  SP

 AT P

 AT V

 unT V

 unT corre

 unniño corre


Gram ticas2

Gramáticas

O  SP

S  AT

P  V

A  el

A  un

T  niño

T  perro

V  corre

V  camina

Lenguaje descrito por esta gramática:

L={"el niño corre", "el niño camina", "un niño corre", "un niño camina", "el perro corre, el perro camina", "un perro corre", "un perro camina"}


Gram ticas3

Gramáticas

T  niño

Variable o "no-terminal"

Regla de producción

Terminal


Gram ticas4

Gramáticas

Otro ejemplo:

Lenguaje:

Algunas derivaciones:


  • Login