Autómatas Finitos

Autómatas FinitosAutómatas Finitos

Máquinas: simplifiquemosMáquinas: simplifiquemosMáquinas: simplifiquemosMáquinas: simplifiquemos

Volvamos al modelo conceptual de una máquina que procesa información.

input outputComputador

•El computador estará siempre en algún estado.

•La cantidad de estados posibles es finita.

Hablamos de una máquina de estados finitos.

MEF


MEF

Cuando se habla de computadores se suele hacer la distinción entre CPU y memoria (RAM).

CPURAM

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


input outputMEF

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


input outputMEF

•Sigamos simplificando. Supongamos ahora que podemos ver en qué estado está la MEF en un momento dado.

estado actual

Usaremos eso para ver la “respuesta” de la MEF al input.

O sea, no necesitamos el output.


input MEF

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

estado actual


input MEF

•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” :QQ.

Si anotamos el estado en tiempo t mediante st, lo que tenemos es: st+1 = (st)

estado actual


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

ab

d

c

Máquinas con inputMáquinas con inputMáquinas con inputMáquinas con input

MEFestado 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 :QQ

input

* Q


-Input con alfabeto ={0,1}•0: no aprieto el interruptor•1: sí lo aprieto

-Estados de la MEF: ON y OFF

PILA

interruptor

Transiciones:(ON,0)=ON(OFF,0)=OFF(ON,1)=OFF(OFF,1)=ON

OFF ON

1

1

00

“grafo de transiciones”


-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

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.

00 10

01 11

1

1

1

1

2 2 2 2

0 0

00

•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

1

2

00 10

01 11

1

1

1

1

2 2 2 2

Usaremos nombres más neutros para los estados: q0, q1, q2, q3.

•Si el estado qi tiene un significado intuitivo, en general es preferible anotarlo aparte: “q1 corresponde al interruptor 1 abierto y el 2 cerrado”...

0 0

00

q0 q2

q1 q3

•Marquemos el conjunto de estados “de aceptación” (los que encienden la ampolleta) con un doble círculo.


PILA

1

2

q0 q2

q1 q3

1

1

1

1

2 2 2 2

•Señalemos el estado inicial del sistema con una flecha (a veces sólo se pone un “>”).

•Esta máquina “acepta” el lenguaje L = { w*: w contiene una cantidad impar de 1 y de 2}

0 0

00

AFD: Autómatas finitos deterministasAFD: Autómatas finitos deterministasAFD: Autómatas finitos deterministasAFD: 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,:QQ

•Un estado inicialq0 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


q0 q1 q21 0

0 0,11

Alfabeto = {0, 1}Estados Q = {q0, q1, q2}Estado inicial q0

Estados de aceptación F = {q0, q1}

est

ados

input

0 1q0

q1

q2

q0 q1

q2

q2q2

q1

Función de transición :


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


q0 q1 q21 0

0 0,11

(q0, 0010011) (q0, 010011) (q0, 10011) (q1, 0011) (q2, 011) (q2, 11) (q2, 1) (q2, )


q0 q1 q21 0

0 0,11

OJO, no confundirse: los nodos del grafo no son “partes” del autómata; son sus posibles estados. q0

001001101001110011

q1

0011

q2

011111


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.


En particular se tiene

’(q,) = ( ’(q,), ) = ( q, )

de modo que ’ es una extensión de

por lo tanto no necesitamos distinguirla

escribiremos para ambas.

’(q,)=q’(q,w)= ( ’(q,w), )


AFD 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?

q0 q1 q21 0

0 0,11

q0q1

1

1

¿Y este, con ={1}?

q0 q1

0 1

1

0

¿Y este, con ={0,1}?

L= {w{0,1}*: w no incluye 10}

L= {w{1}*: |w| es impar} L= {w{0,1}*: w termina en 1}


¿Y aquí?

q4

q2

q3

q1

q0a

a

a

a

a

b

b b

b

b

¿Y en estos?

q0

0,1

q0

0,1

q0 q1O,1

0,1

L = {}

L =

L = {0,1}*

L = palabras no vacías de {a,b}* que empiezan y terminan con la misma letra.


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

0

1 1 q2

0

q31 q4

0, 1

0

1

0


Un estado “basurero” es un estado de rechazo (Q\F) desde el cual no hay forma de llegar a uno de aceptación.

q0 q1

0

1 1 1 q4

0, 1

0

Se subentiende que las transiciones que no aparezcan en el grafo, son “prohibidas” y mandan a un estado basurero (el AFD “se cae”).

Para simplificar notación, por lo general los estados “basureros” no se dibujan; tampoco se anotan las transiciones que llevan a ellos.

q2

0

1

0

q3

Lenguajes regularesLenguajes regularesLenguajes regularesLenguajes 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 regularesLenguajes regularesLenguajes regularesLenguajes 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 AFDUna aplicación para AFDUna aplicación para AFDUna 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 AFND: Autómatas finitos no no deterministasdeterministas


Veamos un ejemplo más de AFD. Con ={0,1}, queremos que acepte el lenguaje de los strings que terminan en 101.

0

1

…

…

……

q

q

q

q

q

q

q

q

q

q

q

0

1

0

1

0

1

1

1

1

1

0Bosquejo (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.

q q q0 1q

1

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.

AFND: Autómatas finitos no AFND: Autómatas finitos no deterministasdeterministas


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 :QQ, pues desde un mismo q podemos pasar a más de un estado, leyendo el mismo .

Por lo tanto, ahora será una función :Q2Q.

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

q q q1 0q

0

0,1 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: AFDClase pasada: AFDClase pasada: AFDClase pasada: AFD

Definimos un autómata finito determinista como

M = (Q, , , q0, F)

donde

Q: estados internos : alfabeto de entrada :QQ: función de transición q0 Q: estado inicial F Q: estados de aceptación

q0

q1

q2

q3

q4

a

a

a a

a

b

b

bb

b

= {a, b}


se extiende inductivamente a palabras:

q0

q1

q2

q3

q4

a

a

a a

a

b

b

bb

b

= {a, b}

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


Luego definimos un autómata finito no determinista como (nuevamente)

M = (Q, , , q0, F)

donde todo se interpreta como antes, excepto que ahora

:Q2Q

En AFD, p = (q,)

“del estado q, leyendo , se pasa al estado p”

En AFND, p (q,) “del estado q, leyendo , se puede pasar al estado p”

q

q

1

0

q

0,1

0,1



’(q,w) es entonces el conjunto de estados a los que puedo llegar a partir del estado q, leyendo en el camino la palabra w desde el input.

•Nuevamente ’ resulta ser una generalización de , de modo que el apóstrofe no es necesario.

Nuevamente podemos extender para que lea más de una letra a la vez.

’(q,)={q}’(q,w)= { p : r’(q,w) tal que p(r,) } =

(q,w)δr

r

)α,(δ



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

1q 2q

3q

0q

a

a

a



¿Y este, con = {a,b} ? 1q 2q0q 3qa b b

a,b

q0 q1 q2 q3

q4 q50,1

0

1

0 0

0,1

1

1q3

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

1 1



Anotemos

•LR = { L: L es reconocido por algún AFD}

•LN = {L: L es reconocido por algún AFND}

¿Qué relación existirá entre estas clases?

Todo AFD es un AFND (es el caso particular en que |(q,)|=1 para cualquier q, )

LR LN

Veremos que además LN LR (y por lo tanto, LN = LR).

(dijimos que esos se llamaban “regulares”)

AFND AFND AFD AFDAFND AFND AFD AFD

Idea de por qué LN LR : consideremos de nuevo el AFND que acepta el lenguaje de strings que incluyen 010.

q q q1 0q

0

0,1 0,1

Veamos los posibles recorridos al leer la palabra 0101:

(q0, 0101)

(q0, 101)

(q1, 101)

(q0, ) rechaza

(q2, ) rechaza

(q3, ) acepta

(q0, 1)

(q1, 1)

(q3, 1)

(q0, 01)

(q2, 01)



q q q1 0q

0

0,1 0,1


q0 q0

q1

q0

q2

q0

q1

q3

q0 rechaza

q2 rechaza

q3 acepta

0

0

1

1

0

0

0

1

1

1



q q q1 0q

0

0,1 0,1


q0 q0

q1

q0

q2

q0

q1

q3

q0

q2

q3

0 1 0 1


Entonces: el conjunto de posibles recorridos para la palabra 0101, se convierte en un único recorrido, que va pasando por distintos subconjuntos de Q.

q q q1 0q

0

0,1 0,1

q0 q0

q1

q0

q2

q0

q1

q3

q0

q2

q3

0 1 0 1


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

q1

q0

q2

q0

q1

q3

q0 q2

q3

0 1 0 1


Otro ejemplo:

1 0

0, 1

q q q

AFND

1q {q0, q1}

1

{q0, q2}

1

0 0

0

AFD


Método general para construir el AFD M’ equivalente a un AFND M=(Q, , , q0, F):

•Q’ = 2Q

’ =

•q’0 = {q0}

•F’ = { AQ : AF }

’( A, ) = { q: pA, q(p,) } =

Ap

)α,p(δ

¿Será cierto que L(M’)=L(M)?


•L(M) = { w: (q0, w) F }

•L(M’) = { w: ’( q’0, w) F’ } = { w: ’( q’0, w) F }

)w,q(δp 0

)α,p(δ

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

Definición de 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.

Definición (recursiva) de ’

Hipótesis de inducción

Definición de ’

Definición (recursiva) de


Hemos demostrado:

Teorema: la clase de lenguajes reconocidos por AFND es la misma que la clase de lenguajes reconocidos por AFD (y se llaman lenguajes regulares).

Los AFND son capaces de hacer exactamente lo mismo que los AFD, a pesar de su “poder de adivinación”.

Sirven, entre otras cosas, para construir AF más rápido.

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


De nuevo el ejemplo: dado el AFND

1 0

0, 1

q q q

{q0, q1}

{q0, q2} {q0, q1, q2}

{q1, q2}

{q0}

{q1}

{q2}

0, 1

0

1

0

1

0, 1

0

1

0 1

01

0

1

la construcción da el 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+AFND+AFND+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 La idea es que son transiciones “gratis”, que permiten pasar de un estado a otro sin leer ningún input.

q1 q2

1 10

0

q3 q4

0 01

1

q0


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

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

1 1q q q

1q q0

0

= {0,1}

q q q

q

= {0,1,2}

0,1 0,2 1,2


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

a

b

a

0q 1q 2q


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 AQ sea

A =A { q: pA, p q}

Es decir, A le agrega a A todo aquello que se puede alcanzar desde A mediante transiciones nulas.


Se hace una variante de la construcción previa, con

Q’ = 2Q , ’ = , F’ = { AQ : AF }

pero ahora

q’0 = {q0}

y

’( A, ) = { q: pA, q(p,) }

Nótese que sólo los AQ que sean cerrados para (es decir, A=A) serán accesibles.


a

b

a

0q 1q 2q

0q

b

ab

ba,

21,qqa

Ejemplo:

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

AF AF FA FAAF AF FA 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 clausuraPropiedades de clausuraPropiedades de clausuraPropiedades 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.


a

b

b

a

a

b

b

a

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:

1M

2M


•L1L2 también es un lenguaje regular:

1M 2M

1M

•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, L1L2=(L1

C 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 = Q1Q2

q0 = (q0,1,q0,2)F= F1F2

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

n

iiL

1tambié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

1iiL 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: vL2 tal que uvL1 }

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,v1

*

•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): wL} 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 100...001, con al menos un 0.h(L) = palabras de la forma ababab...ab, con al menos un ab.

Expresiones regularesExpresiones regularesExpresiones regularesExpresiones 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, 00, 01, 10, 11, …}

(0+1 {0, 1}

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

(0+1)*010

Strings de largo 1

Cualquier string

Cualquier string terminado en 010

Cualquier string que incluya 01


Ejemplos:

Strings de largo par

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

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

Strings de largo divisible por dos o por

tresNota: cuando no haya confusión posible, es posible usar exponentes:

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

((0+1)2+(0+1)3)* Strings de largo > 1.

ER ER regular regularER ER regular 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 AFER.

Regular Regular ER ERRegular Regular ER 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.


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.

+10* (00+11)*

0*1

q q q

01

q

0*111010


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

ba a

b

b

0q 1q 2q

b

0q 2q

babb*

)(* babb


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

+10* 0*11

0*1

q q q

01

q q

01

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

q q

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


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

En tal caso,0q fq

1r

2r

3r4r

*)*(* 213421 rrrrrrr

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

r


Los mágicos pasos intermedios.

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


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

Entran Loop Salen

r2 desde 1r4

r3 hacia 1

r6 desde 3 r5 hacia 3

r8

r9


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,complementoaa,complementoaa,complementoaa,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


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


•Invertimos los estados de aceptación

•Convertimos el AFD en una ER:

y crecen y crecen...y crecen y crecen...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 ruteroMapa ruteroMapa ruteroMapa 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 AFDMinimización de AFDMinimización de AFDMinimizació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.


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


Idea: pueden haber estados equivalentes

q0 q1

a

a

q3

a,b

b

q2

q4

a,b

b b

a

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

q0 q1

a

a

a,b

b

q2

b b

a

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.

q0 a

a

a,b

b b

q3,4

q1,2


No siempre es tan obvio como en el ejemplo previo:

q0 q1

q2

q0,2 q1


Informalmente: dos estados p y q son equivalentes (pq), 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)


q0 q1

a

a

q3

a,b

b

q2

q4

a,b

b b

a

L(M,q0) = b*aa*

L(M,q1) = a*

L(M,q2) = a*

L(M,q3) = L(M,q4) =

q1 q2

q3 q4

q0 q1

q2

L(M,q0) = cantidad impar de 0’sL(M,q1) = cantidad par de 0’sL(M,q2) = cantidad impar de 0’s

q0 q2


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

q0 a

a

a,b

b b

q

q


Algoritmo de minimización:

1) Eliminar todos los estados no alcanzables desde q0.

2) Determinar los pares de estados equivalentes.3) Mientras quede un par pq, 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.


1. Marcamos todos los pares en los que un estado es de aceptación y el otro no.

2. Para todo (p,q) no marcado y para todo , si ((p, ), (q, ) ) está marcado marcar (p,q).

3. Si en (2) se marcó algo, repetir (2).

Para determinar los pares equivalentes, usamos el siguiente “algoritmo de llenado de tabla”.

La tabla contiene los pares (p,q), pq. Iremos marcando los pares distinguibles (no equivalentes).


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.


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)


Ejemplo:

0

1

q

q

q

q

q

q

q

0

1

0

1

1

0

01

1

0

0

1

q

q

q

q

q

q

qq q q qq

AFD que reconoce las palabras terminadas en 11. ¿Será el más chico posible?

Hacemos la tabla.


0

1

q

q

q

q

q

q

q

0

1

0

1

1

0

01

1

0

0

1

x x x x x x

q

q

q

q

q

q

qq q q qq

Ejemplo:

Marcamos los pares en los que un estado está en F y el otro no.

Motivo: los distingue la palabra .


0

1

q

q

q

q

q

q

q

0

1

0

1

1

0

01

1

0

0

1

x

x

x

x

x

xx x x x

q

q

q

q

q

q

qq q q qq

Ejemplo:

(p,q) no marcado, y , si ((p, ), (q, ) ) está marcado marcar (p,q).

Motivo: alguna palabra w distinguía a (p, ) y (q, ). Por lo tanto, w distingue a p y q.


0

1

q

q

q

q

q

q

q

0

1

0

1

1

0

01

1

0

0

1

x

x

x

x

x

x

x

xx

x

xxx x

q

q

q

q

q

q

qq q q qq

Ejemplo:

Aplicamos de nuevo.


0

1

q

q

q

q

q

q

q

0

1

0

1

1

0

01

1

0

0

1

x

x

x

x

x

x

x

xx

x

xxx x

q

q

q

q

q

q

qq q q qq

Ejemplo:

Ya no queda nada más que marcar: (p,q) no marcado, y , ((p, ), (q, ) ) está no marcado.

Todos los pares no marcados son equivalentes; podemos empezar a minimizar.


1

q

q

q

q

q

q

0

1

1

0

01

1

0

0

1

x

x

x

x

xx

x

xxx x

q

q

q

q

q

qq q qq

0

Ejemplo:

Fusiono q0 con q.


1

q

q

q

q

q

0

1

01

1

01

xx

xxx

xx x

q

q

q

q

qq q q

0

0

Ejemplo:

Fusiono q00 con q.


1

q

q

q

q

0

1

0

1

01

xxx x x

q

q

q

q q q

0

0

Ejemplo:

Fusiono q10 con q.


1

q

q

q

0

1

1

xx x

q

q

q q

0

0

1q q qC

11

0

00

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


0

1

q

q

q

q

q

q

q

0

1

0

1

1

0

01

1

0

0

1

x

x

x

x

x

x

x

xx

x

xxx x

q

q

q

q

q

q

qq q q qq

A

BC

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

1q q qC

11

0

00

A

A

A

A

AB

A


No se producen inconsistencias con , pues

pq (p, )(q, )

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

Ap

qq1

Bq5

q2

Cq6

w

w

[ ¿Minimización de AF[ ¿Minimización de AFNDND ? ] ? ][ ¿Minimización de AF[ ¿Minimización de AFNDND ? ] ? ]

El algoritmo de minimización es para AFD.

0

0,1 0,1

0

1 0,1

0

0,1 1

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

D

Para ellos funciona, y para ellos es cierto que para un mismo lenguaje, el AFD mínimo es siempre el mismo.

Para AFND[+] eso no es cierto.

[ ¿Minimización de AF[ ¿Minimización de AFNDND ? ] ? ][ ¿Minimización de AF[ ¿Minimización de AFNDND ? ] ? ]

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ínimoMinimización de AFD: da mínimoMinimización de AFD: da mínimoMinimizació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ínimoMinimización de AFD: da mínimoMinimización de AFD: da mínimoMinimizació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é Minimización de AFD: ¿por qué funciona?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 *:

•uM v (q0,u)= (q0,v)

•u L v no existe w que distinga u de v respecto a L



uM v (q0,u)= (q0,v)u L v no existe w que las distinga respecto a L•Es fácil ver que uM v u L v

En efecto, sea w una palabra cualquiera. Tenemos

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



Pero si son de equivalencia, y uM 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.

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

uM v (q0,u)= (q0,v)u L v no existe w que las distinga respecto a L

•Cuando una clase de equivalencia de L contiene dos clases de equivalencia de M (correspondientes a, digamos, los estados p y q), entonces pq (son equivalentes en el sentido del algoritmo).



uM 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ónUna observación y una definiciónUna observación y una definiciónUna 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.

LC L

Estamos listos para...

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


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 = { qQ: qL}( [u], ) = [u]

PDQ: L(M)=L. Además veremos que M es mínimo.


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

q0 = [], F = { qQ: qL}, ( [u], ) = [u]

PDQ L(M)=L.

Es decir, que u*, uL(M) [u]L

Pero uL(M) (q0,u)F ([],u)Lasí que estamos listos si demostramos que ([],u)=[u].

Demostraremos, más en general, que u,v*, ([v],u)=[vu]


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]


q0 = [], F = { qQ: qL}, ( [u], ) = [u]

Definición (recursiva) de

Hipótesis de inducción

Definición de


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.


q0 = [], F = { qQ: qL}, ( [u], ) = [u]

QED


¿Cuál es la intuición tras Myhill-Nerode?

•Recibimos el input: u=vw

•Al terminar de verlo, debemos decidir acaso uL.

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


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

01 [v]

[v1] [v0]

•Myhill-Nerode lo que me dice es que un lenguaje es regular ssi eso que tengo que saber, momento a momento, cabe en una memoria finita.

La unicidad del AFD mínimo.La unicidad del AFD mínimo.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.


Supongamos que partimos de dos AFD distintos, ambos con el mismo lenguaje, y llegamos a dos AFD minimales M y M’.

¿Qué significa que sean el mismo?

Significa que salvo “cambio de nombre”, los estados son los mismos. Llamemos al cambio de nombre.

1

q

q

q

0

1

1

0

0

1

A

C

B

0 1

10

0

-1


Dados dos AFD M=(Q, , , q0, F) y M’=(Q’, , ’, q’0, F’), son “el mismo” ssi existe :QQ’ biyectiva tal que

• (q0) = q’0

• (F) = F’• ((q,)) = ((q),)

En el ejemplo de abajo, (q)=A, (q11)=B, (q1)=C.

1

q

q

q

0

1

1

0

0

1

A

C

B

0 1

10

0

-1

es un isomorfismo entre M y M’.


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


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


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 kj, tomamos algún n>j, n>k, y las palabras

u=anbn-kSk, v=anbn-jSj

Claramente uw L ssi w=bk, vw L ssi w=bj. Como kj, 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 bombeoLema del bombeoLema del bombeoLema 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.


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

Ma a a a

a

akbN+1

•Pero entonces una palabra que repita ese loop varias veces también se aceptaría... Pero tendrá más a’s que b’s !!!


Esta idea funciona en general para lenguajes regulares, y se usa más que Myhill-Nerode en las demostraciones de no-regularidad de lenguajes.

Se le conoce como lema del bombeo.

[Ojo: por algún extraño motivo, la 1ª edición del Hopcroft en español traduce “sondeo”. Pero no.]

Más adelante veremos que existe una versión que se aplica a otro tipo de lenguajes. Por eso esta versión se llamará:


Lema del bombeo para lenguajes regulares:

Sea L un lenguaje regular. Entonces existe n>0 tal que cualquier w con |w|n se puede descomponer como w=xyz, de forma que:

•|y| > 0•|xy| < n•xykz L k0

……

x

y

z

Demostración:

QED


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 quek0, 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 xykzL.

•Los “” implican que en esas partes hay que considerar cualquier valor de n, cualquier desglose de w.

•Los significan que esos los podemos elegir.


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

¡L no es regular!Sí, si es regular. Tengo un

AFD.¿En serio? ¿De cuántos

estados? n

Ya poh. Aquí tienes w, |w|>n, que está en L. Para aceptarla tu AFD tiene que hacer un loop. ¿En qué

parte lo hace?

Aquí en el y... queda w=xyz

¡Ja! Pero si le damos 3 vueltas al loop con xyyyz, tu AFD acepta, pero eso no está en L.

¡Toma!...#@?

ç!

nosotros adversario


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.


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 (p0, q1). z será de la forma an+1-p-qbn+1.

El teorema dice entonces que xykz = apaqkan+1-p-qbn+1 L para todo k0,

Pero eso requeriría que n+1+q(k-1)=n+1 para todo k, y nop.


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!


Es útil recordar la parte del “k0”. 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 q1, n-q n-1 xy0z L.


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 Fin de la materia que entra en el que entra en el

certamen 1certamen 1

Fin de la materia Fin de la materia que entra en el que entra en el

certamen 1certamen 1

Problemas de decisión para LRProblemas de decisión para LRProblemas de decisión para LRProblemas 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, ¿wL?

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

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

¿L ?

Ojo: recordar en este contexto que es una palabra: si lo que nos queda es , entonces no es vacío.


Respuesta 1: Construimos un AFD para L, y vemos acaso existe un camino desde q0 hasta algún qF que incluya algún ciclo.

¿Es L infinito?

Recordar que eso significa: “¿Contiene L una cantidad infinita de palabras?”

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 .


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.

¿Es L infinito?


Dados dos lenguajes regulares L1 y L2. ¿Son iguales?

L1L2 = (L1\L2) (L2\L1) = (L1L2C) (L1

CL2) ]

A\B AB

Respuesta 1:

•Construimos un AFD para cada uno.•Los minimizamos.•Vemos si los AFD resultantes son isomorfos.

Respuesta 2:

•Ver acaso L1L2 =

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”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 Lo que va quedando del tema "regular""regular"

Lo que va quedando del tema Lo que va quedando del tema "regular""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 AFVariantes respecto a los AFVariantes respecto a los AFVariantes 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.


x1 x2 xn-1 xn ...

AFD

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

•El cabezal recorre de izquierda a derecha, hasta encontrar el final.

•El autómata es una máquina que va cambiando su estado interno, y tiene un "cabezal" situado sobre la cinta, donde lee la palabra.•Agregamos unos símbolos que marcan el comienzo y fin de la palabra.


x1 x2 xn-1 xn ...

2AFD

•En un "2-AFD" (AFD bidireccional) el cabezal puede retroceder.•Para eso, se agrega una función m:(Q,){L,R,S}.

•Esa función indica, en cada paso, si el cabezal debe moverse a la izquierda, a la derecha, o quedarse quieto.•Como el input ya no "termina", se requiere una nueva definición del "lenguaje reconocido".


x1 x2 xn-1 xn ...

AFD

Desaparece “F” (el conjunto de estados de aceptación).

•Se crean dos estados finales, uno de aceptación y otro de rechazo.

•Si el 2-AFD cae en uno de ellos, se detiene (y decide).

L es un lenguaje reconocible por un 2-AFD ssi L es regular.

2

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


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

outputinput MEFestado actual

•Hasta aquí hemos leído el "output" a través del estado interno final, e incluso entonces sólo miramos acaso acepta o rechaza ("autómatas aceptadores").

•En los autómatas traductores, agregamos la posibilidad de que escriban mientras van leyendo.


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

q

q

1

0,1

q

0

0

q

q

1

0,1

q

0

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

a

a

b

1

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

q

q

1

0,1

q

0

0

1

1/a

0/a,1/b0/b

0/b

1/b


•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 MooreMáquina de MooreMáquina de MooreMá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)

q

q

1

0,1

q

0

0a

a

b

1 0010101 inputaaaababa output

Máquina de MealyMáquina de MealyMáquina de MealyMá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)

q

q

1

0,1

q

0

0

1

1/a

0/a,1/b0/b

0/b

1/b

0010101 input bbaabab output

•Nótese que Mealy escribe una letra menos que Moore (pues Moore escribe algo ya en 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?¿Aplicaciones?¿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.


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!

acaggccaccaacccacct

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


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

1 2 3 4 50c c a c c t

6

c a

cc

Todas las transiciones no mostradas van al estado 0.

•Evitamos comparaciones inútiles.

•Con palabras más largas el AFD puede quedar harto más complejo.

•Se puede extender la idea para buscar varias palabras a la vez.

•El preprocesamiento puede ser pesado, pero después la búsqueda en el texto es rápida.

•Detalles: googlear algoritmo Knuth-Morris-Pratt.

Algo más sobre expresiones Algo más sobre expresiones regularesregulares


•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éxicoAnálisis léxicoAnálisis léxicoAná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éxicoAnálisis léxicoAnálisis léxicoAnálisis léxico

Analizador léxico

Parser

precio

id + id

Expresión

asignación

:=Total

iva

Total = precio + iva ;

T o t a l = p r e c i o + i v a ;

Análisis léxico: LEXAnálisis léxico: LEXAnálisis léxico: LEXAná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.


Var = 12 + 9;

if (test > 20)

temp = 0;

else

while (a < 20)

temp++;

programageneradopor lex

Identifier: Var

Operand: =

Integer: 12

Operand: +

Integer: 9

Semicolon: ;

Keyword: if

Parenthesis: (

Identifier: test

....

Input

Output•Uso típico de un programa creado por lex:


•Ejemplo de input para que lex genere un programa:

%%

[a-zA-Z]+ printf(“Identifier: \s\n”, yytext);

[0-9]+ printf(“Integer: \s\n”, yytext);

[ \t\n] ; /*saltarse tabs, espacios y cambios de líneas*/

•Hoy en día se usa flex ("fast lex") más que lex mismo.

¿Parseo?¿Parseo?¿Parseo?¿Parseo?

Analizador léxico

Parser

precio

id + id

Expresión

asignación

:=Total

iva

Total = precio + iva ;

T o t a l = p r e c i o + i v a ;

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

GramáticasGramáticasGramáticasGramá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


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 un niño corre


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


Variable o "no-terminal"

T niño

Regla de producción

Terminal


S

aSbS

abaSbS aabbaaSbbaSbS

aaaabbbbaaaaSbbbb

aaaSbbbaaSbbaSbS

}0:{ nbaL nn

Otro ejemplo:

Algunas derivaciones:

Lenguaje:

Autómatas Finitos

Documents

Transcript of Autómatas Finitos