Uploaded by Jhon Edison Bravo Buitrago

Notas de clase (2019). Capitulo 2 (secciones 2.1 a 2.9

advertisement
Notas de clase para el curso
Introducción a la Teorı́a de la Computación
I Semestre 2019
Profesor: Rodrigo De Castro K.
Capı́tulo 2
Autómatas Finitos
Los autómatas son máquinas abstractas muy simples que tienen la capacidad de reconocer
lenguajes. Históricamente, su estudio se originó con la llamada “máquina de Turing”,
que fue propuesta en 1936 por el matemático británico Alan Turing (1912–1954) con el
propósito de precisar las caracterı́sticas y las limitaciones de un dispositivo de computación
mecánica. En los años 40 y 50 del siglo XX se adelantaron investigaciones sobre máquinas
de Turing con capacidad restringida, lo que dio lugar a la noción de autómata finito.
2.1.
Autómatas finitos deterministas (AFD)
Los autómatas finitos son máquinas abstractas que leen de izquierda a derecha cadenas de
entrada, las cuales son aceptadas o rechazadas. El autómata actúa leyendo los sı́mbolos
escritos sobre una cinta semi-infinita, dividida en celdas o casillas, sobre la cual se escribe
una cadena de entrada u, un sı́mbolo por casilla. El autómata posee una unidad de control
(también llamada cabeza lectora, control finito o unidad de memoria) que tiene un número
finito de configuraciones internas, llamadas estados del autómata. Entre los estados de un
autómata se destacan el estado inicial y los estados finales o estados de aceptación.
Formalmente, un autómata finito M posee cinco componentes, M = (Σ, Q, q0 , F, δ), a
saber:
1. Un alfabeto Σ, llamado alfabeto de entrada o alfabeto de cinta. Todas las cadenas
que procesa M pertenecen a Σ∗ .
2. Q = {q0 , q1 , . . . , qn }, el conjunto (finito) de los estados internos de la unidad de
control.
3. q0 ∈ Q, estado inicial.
4. F ⊆ Q, conjunto de estados finales o de aceptación. F debe ser distinto de ∅; es
decir, debe haber por lo menos un estado de aceptación.
25
Introducción a la Teorı́a de la Computación.
Capı́tulo 2
26
5. La función δ de transición del autómata
δ : Q × Σ −→
Q
(q, s) 7−→ δ(q, s)
Una cadena de entrada u se coloca en la cinta de tal manera que el primer sı́mbolo de u
ocupa la primera casilla de la cinta. La unidad de control está inicialmente en el estado
q0 escaneando la primera casilla:
u
a a
Unidad
de control
b
···
≡
···
q
0
La función de transición δ, también llamada dinámica del autómata, es la lista de instrucciones que utiliza M para procesar todas las entradas. Las únicas instrucciones son
de la forma δ(q, s) = q 0 , la cual tiene el siguiente significado: en presencia del sı́mbolo s,
la unidad de control pasa del estado q al estado q 0 y se desplaza hacia la casilla situada
inmediatamente a la derecha. Esta acción constituye un paso computacional :
δ(q, s) = q 0
···
s
q
···
···
s
···
q0
La unidad de control de un autómata siempre se desplaza hacia la derecha una vez escanea
o “consume” un sı́mbolo; no puede retornar ni tampoco sobre-escribir sı́mbolos sobre la
cinta.
Puesto que δ está definida para toda combinación estado-sı́mbolo, una cadena de entrada u cualquiera es procesada completamente, hasta que la unidad de control encuentra
la primera casilla vacı́a; en ese momento la unidad de control se detiene. Si el estado en
el cual termina el procesamiento de u pertenece a F , se dice que la entrada u es aceptada
(o reconocida) por M ; de lo contrario, se dice que u es rechazada (o no aceptada o no
reconocida).
Introducción a la Teorı́a de la Computación.
Capı́tulo 2
Ejemplo Consideremos el autómata definido por los siguientes cinco componentes:
Σ = {a, b}.
Q = {q0 , q1 , q2 }.
q0 : estado inicial.
F = {q0 , q2 }, estados de aceptación.
Función de transición δ:
δ
a
b
q 0 q0 q1
q 1 q1 q2
q 2 q1 q1
δ(q0 , a) = q0
δ(q0 , b) = q1
δ(q1 , a) = q1
δ(q1 , b) = q2
δ(q2 , a) = q1
δ(q2 , b) = q1 .
Vamos a ilustrar el procesamiento de tres cadenas de entrada.
1. u = aabab.
u
a a b a b
≡
q
q
q
0
q
0
q
0
q
1
1
···
2
Como q2 es un estado de aceptación, la cadena de entrada u es aceptada.
2. v = aababa.
u
a a b a b a
≡
q
q
0
q
0
q
q
0
1
q
1
q
2
···
1
Puesto que q1 no es un estado de aceptación, la entrada v es rechazada.
3. Caso especial: la cadena λ es la cadena de entrada.
≡ ≡
q
0
···
27
Introducción a la Teorı́a de la Computación.
Capı́tulo 2
28
Como q0 es un estado de aceptación, la cadena λ es aceptada.
En general se tiene lo siguiente: la cadena vacı́a λ es aceptada por un autómata M si
y solamente si el estado inicial q0 también es un estado de aceptación.
Los autómatas finitos descritos anteriormente se denominan autómatas finitos deterministas (AFD) ya que para cada estado q y para cada sı́mbolo s ∈ Σ, la función de
transición δ(q, s) siempre está definida y es un único estado. Esto implica que cualquier
cadena de entrada se procesa completamente y de manera única.
Un autómata M es entonces un mecanismo que clasifica todas las cadenas de Σ∗ en
dos clases disyuntas: las que son aceptadas y las que son rechazadas. El conjunto de las
cadenas aceptadas por M se llama lenguaje aceptado o lenguaje reconocido por M y se
denota por L(M ). Es decir,
L(M ) := {u ∈ Σ∗ : u es aceptada por M }
= {u ∈ Σ∗ : M termina el procesamiento de u en un estado q ∈ F }
2.2.
Grafo de un autómata
Un autómata finito se puede representar por medio de un grafo dirigido y etiquetado.
Recuérdese que un grafo es un conjunto de vértices o nodos unidos por arcos o conectores;
si los arcos tienen tanto dirección como etiquetas, el grafo se denomina grafo dirigido y
etiquetado o digrafo etiquetado.
El digrafo etiquetado de un autómata M = (Σ, Q, q0 , F, δ) se obtiene siguiendo las
siguientes convenciones:
Los vértices o nodos son los estados del autómata.
Un estado q ∈ Q se representa por un cı́rculo con nombre q:
q
El estado inicial q0 se destaca mediante una “bandera” o “flecha”:
q0
Un estado de aceptación q se representa por un cı́rculo doble con nombre q:
q
La transición δ(q, s) = q 0 se representa por medio de un arco entre el estado q y el
estado q 0 con etiqueta s:
q
s
q0
Si δ(q, s) = q se obtiene lo que se llama un “bucle”(loop, en inglés):
Introducción a la Teorı́a de la Computación.
Capı́tulo 2
29
s
q
Las etiquetas de los arcos entre estados son entonces sı́mbolos del alfabeto de entrada Σ.
Si dos estados están unidos por dos arcos que tienen la misma dirección, basta trazar un
solo arco con doble etiqueta, separando los sı́mbolos con comas. Ası́ por ejemplo,
s
q0
q
t
donde s, t ∈ Σ, se representa simplemente como
s, t
q
q0
El grafo de un autómata es muy útil para hacer el seguimiento o rastreo completo del
procesamiento de una cadena de entrada. Una cadena u ∈ Σ∗ es aceptada si existe una
trayectoria etiquetada con los sı́mbolos de u, que comienza en el estado q0 y termina en
un estado de aceptación.
El grafo de un autómata determinista M = (Σ, Q, q0 , F, δ) tiene la siguiente caracterı́stica: desde cada estado salen tantos arcos como sı́mbolos tiene el alfabeto de entrada
Σ. Esto se debe al hecho de que la función de transición δ está definida para cada combinación estado-sı́mbolo (q, s), con q ∈ Q y s ∈ Σ.
Ejemplo En la sección anterior se presentó el siguiente autómata M = (Σ, Q, q0 , F, δ):
Σ = {a, b}.
Q = {q0 , q1 , q2 }.
q0 : estado inicial.
F = {q0 , q2 }, estados de aceptación.
Función de transición δ:
δ
a
b
q0 q0 q1
q1 q1 q2
q2 q1 q1
El grafo de M es:
δ(q0 , a) = q0
δ(q0 , b) = q1
δ(q1 , a) = q1
δ(q1 , b) = q2
δ(q2 , a) = q1
δ(q2 , b) = q1
Introducción a la Teorı́a de la Computación.
Capı́tulo 2
a
q0
30
a
b
q1
a, b
b
q2
Examinando directamente el grafo podemos observar fácilmente que, por ejemplo, las
entradas bbab y aaababbb son aceptadas mientras que baabb y aabaaba son rechazadas.
2.3.
Diseño de autómatas
En esta sección abordaremos el siguiente tipo de problemas: dado un lenguaje L, diseñar
un autómata finito M que acepte o reconozca a L, es decir, tal que L(M ) = L. Más
adelante se demostrará en toda su generalidad que, si L es regular, estos problemas siempre
tienen solución. Para encontrar un autómata M tal que L(M ) = L hay que tener en cuenta
que esta igualdad es estricta y, por tanto, se deben cumplir las dos siguientes condiciones:
1. Si una cadena u es aceptada por M , entonces u debe pertenecer a L.
2. Recı́procamente, si u ∈ L, entonces u debe ser aceptada por M .
Un estado q en un autómata M se llama estado limbo si q no es un estado de aceptación
y desde q no salen trayectorias que conduzcan a estados de aceptación. Puesto que los
estados limbo no hacen parte de las trayectorias de aceptación se suprimen, por conveniencia, al presentar un autómata. No obstante, los estados limbo (si los hay) hacen parte
integrante del autómata y solo se omiten para simplificar los grafos.
Ejemplo
Sea Σ = {a, b} y L = a∗ = {λ, a, a2 , a3 , . . .}. AFD M tal que L(M ) = L:
a
q0
a
b
q1
b
a
En la versión simplificada omitimos el estado limbo q1 :
q0
Introducción a la Teorı́a de la Computación.
Ejemplo
Capı́tulo 2
31
Sea Σ = {a, b} y L = a+ = {a, a2 , a3 , . . .}. AFD M tal que L(M ) = L:
a
a
q0
q1
a
b
b
q2
b
a
q0
En la versión simplificada omitimos el estado limbo q2 :
a
q1
b}. L = lenguaje de las cadenas que contienen exactamente dos aes
Ejemplo Σ =∗ {a,
= b ab∗ ab∗ . AFD M tal que L(M ) = L, omitiendo el estado limbo:
b
a
q0
b
b
q1
a
q2
Ejemplo Σ = {a, b}. L = lenguaje de las cadenas sobre Σ que tienen un número par
de sı́mbolos (cadenas de longitud par ≥ 0). AFD M tal que L(M ) = L:
a, b
q0
q1
a, b
Ejemplo Σ = {0, 1}. L = lenguaje de las cadenas sobre Σ que contienen un número
par de aes. AFD M tal que L(M ) = L:
b
b
a
q0
q1
a
Introducción a la Teorı́a de la Computación.
Capı́tulo 2
32
∗
Ejemplo Sean Σ = {0, 1} y L = (1 ∪ 01) . Construimos un AFD de tal forma que
el estado inicial q sea el único estado de aceptación y en él confluyan las
0
trayectorias 1 y 01. Omitiendo el estado limbo obtenemos el siguiente autómata:
1
0
q0
q1
1
Ejemplo ¿Cuál es el autómata más sencillo que se puede construir con el alfabeto de
entrada Σ = {a, b}? Tal autómata M tiene un único estado que debe ser
tanto estado inicial como estado de aceptación. Se tiene entonces que M acepta todas las
cadenas, es decir, L(M ) = (a ∪ b)∗
a, b
q0
Por otro lado, podemos construir un autómata M 0 que no acepte ninguna cadena, es decir,
tal que L(M 0 ) = ∅. El estado inicial de M 0 no puede ser estado de aceptación (ya que
aceptarı́a λ), pero como todo autómata debe tener por lo menos un estado de aceptación,
M 0 debe tener dos estados:
Ejercicios de la sección 2.3
a, b
a, b
q0
q1
À Sea Σ = {a, b}. Diseñar AFD (autómatas finitos deterministas) que acepten los
siguientes lenguajes:
(i) a∗ b∗ .
(iii) (ab)∗ .
(v) ab∗ ∪ b∗ a.
(ii) a∗ ∪ b∗ .
(iv) (ab)+ .
(vi) a(a ∪ ab)∗ .
(vii) ab+ a∗ . Un AFD que acepte este lenguaje requiere como mı́nimo 5 estados más
un estado limbo (6 estados en total).
Introducción a la Teorı́a de la Computación.
Capı́tulo 2
33
(vii) = a∗ b ∪ b∗ a. Un AFD que acepte este lenguaje requiere como mı́nimo 6 estados
más un estado limbo (7 estados en total).
(ix) b∗ (ab ∪ ba).
(x) b∗ (ab ∪ ba)a+ .
Á Sea Σ = {a, b}.
(i) Diseñar un AFD que acepte el lenguaje de todas las cadenas que contienen un
número par de aes y un número par de bes. Se entiende que par incluye a 0.
Ayuda: utilizar 4 estados.
(ii) Para cada combinación de las condiciones “par” e “impar” y de las conectivas
“o” e “y”, diseñar un AFD que acepte el lenguaje L definido por
L = lenguaje de las cadenas con un número par/impar de aes
y/o un número par/impar de bes.
Ayuda: utilizar el autómata de 4 estados diseñado en la parte (i), modificando
adecuadamente el conjunto de estados de aceptación.
 Sea Σ = {0, 1}. Diseñar AFD (autómatas finitos deterministas) que acepten los
siguientes lenguajes:
(i) El lenguaje de todas las cadenas que terminan en 01.
(ii) El lenguaje de todas las cadenas que tienen un número par ≥ 2 de unos.
(iii) El lenguaje de todas las cadenas con longitud ≥ 4.
(iv) El lenguaje de todas las cadenas que contienen por lo menos dos unos consecutivos.
(v) El lenguaje de todas las cadenas que tienen un número par de ceros pero no
tienen dos ceros consecutivos.
(vi) (01 ∪ 101)∗ .
(vii) 1+ (10 ∪ 01+ )∗ .
à Sea Σ = {a, b, c}. Diseñar AFD (autómatas finitos deterministas) que acepten los
siguientes lenguajes:
(i) a∗ b∗ c∗ .
(ii) a+ b∗ ∪ ac∗ ∪ b∗ ca∗ .
(iii) a∗ (ba ∪ ca)+ .
Ä Sea L = {a2i b3j : i, j ≥ 0} definido sobre el alfabeto Σ = {a, b}. Encontrar una
expresión regular para L y un AFD M tal que L(M ) = L.
Introducción a la Teorı́a de la Computación.
2.4.
Capı́tulo 2
34
Autómatas finitos no-deterministas (AFN)
En el modelo determinista una entrada u se procesa de manera única y el estado en el cual
finaliza tal procesamiento determina si u es o no aceptada. En contraste, en el modelo
no-determinista es posible que una entrada se pueda procesar de varias formas o que haya
procesamientos abortados.
Concretamente, un AFN (Autómata Finito No-determinista) M = (Σ, Q, q0 , F, ∆) posee cinco componentes, los primeros cuatro con el mismo significado que en el caso determinista:
1. Un alfabeto Σ, llamado alfabeto de entrada o alfabeto de cinta. Todas las cadenas
que procesa M pertenecen a Σ∗ .
2. Q = {q0 , q1 , . . . , qn }, el conjunto (finito) de los estados internos de la unidad de
control.
3. q0 ∈ Q, estado inicial.
4. F ⊆ Q, conjunto de estados finales o de aceptación. F debe ser distinto de ∅; es
decir, debe haber por lo menos un estado de aceptación.
5. La función ∆ de transición del autómata
∆ : Q × Σ −→ ℘(Q)
(q, s) 7−→ ∆(q, s) = {qi1 , qi2 , . . . , qik }
donde ℘(Q) es el conjunto de subconjunto de Q.
El significado de ∆(q, s) = {qi1 , qi2 , . . . , qik } es el siguiente: estando en el estado q, en
presencia del sı́mbolo s, la unidad de control puede pasar (aleatoriamente) a uno cualquiera
de los estados qi1 , qi2 ,. . . , qik , después de lo cual se desplaza a la derecha.
Puede suceder que ∆(q, s) = ∅, lo cual significa que, si durante la lectura de una
cadena de entrada u, la cabeza lectora de M ingresa al estado q leyendo sobre la cinta el
sı́mbolo s, el procesamiento se aborta.
La noción de digrafo etiquetado para un AFN se define de manera análoga al caso
AFD, pero puede suceder que desde un mismo nodo (estado) salgan dos o más arcos con
la misma etiqueta:
s
qi3
q
s
q i1
s
qi2
Introducción a la Teorı́a de la Computación.
Capı́tulo 2
35
Un AFN M puede procesar una cadena de entrada u ∈ Σ∗ de varias maneras. Sobre el
grafo del autómata, esto significa que pueden existir varias trayectorias, desde el estado
q0 , etiquetadas con los sı́mbolos de u.
Igual que en el caso determinista, L(M ) denota el lenguaje aceptado o reconocido por
M . La siguiente es la noción de aceptación para autómatas no-deterministas:
L(M ) = {u ∈ Σ∗ : existe por lo menos un procesamiento completo
de u desde q0 , que termina en un estado q ∈ F }
Es decir, para que una cadena u sea aceptada, debe existir algún procesamiento en el que
u sea procesada completamente y que finalice estando M en un estado de aceptación. En
términos del grafo del AFN, una cadena de entrada u es aceptada si existe por lo menos
una trayectoria etiquetada con los sı́mbolos de u, desde el estado q0 hasta un estado de
aceptación.
Ejemplo
Sea M el siguiente AFN:
a
a
b
b
q0
a
q1
q2
b
a
q3
∆
a
b
q0
{q0 , q1 , q3 }
∅
q1
{q1 }
{q2 }
q2
∅
{q1 , q2 }
q3
∅
{q3 }
b
Para la cadena de entrada u = abb, existen procesamientos que conducen al rechazo,
procesamientos abortados y procesamientos que terminan en estados de aceptación. Según
la definición de lenguaje aceptado, u ∈ L(M ).
u
Procesamiento de rechazo:
a
b
b
≡
q
q
q
q
0
1
2
2
···
Introducción a la Teorı́a de la Computación.
Capı́tulo 2
36
u
Procesamiento de aceptación:
a
b
b
≡
q
q
q
q
0
3
3
···
3
u
Otro procesamiento de aceptación:
a
b
b
≡
q
q
q
q
0
1
2
···
1
u
Procesamiento abortado:
a
b
q
q
0
b
≡
···
0
El grafo de M nos permite ver que la cadena aabbaa es aceptada mientras que aabaa es
rechazada. Todas las cadenas que comienzan con b son rechazadas. También es rechazada
la cadena aba; uno de sus procesamientos posibles es el siguiente:
Procesamiento abortado:
a
b
a
q
q
q
0
3
≡
···
3
A pesar de que el procesamiento anterior termina en el estado de aceptación q3 , la entrada
no es aceptada porque no se consume completamente.
∗
+
Ejemplo Considérese el lenguaje L = ab ∪a sobre el alfabeto Σ = {a, b}. El siguiente
AFN M satisface L(M ) = L.
Introducción a la Teorı́a de la Computación.
Capı́tulo 2
37
b
a
q0
q1
a
a
q2
Un AFD que acepte a L requiere como mı́nimo cuatro estados más un estado limbo (cinco
estados en total).
Ejemplo Σ = {0, 1}, L = (01 ∪ 010)∗ . El siguiente AFN acepta a L.
0
q0
1
q1
0
0
q2
1
q3
Otro AFN que acepta el mismo lenguaje y que tiene sólo tres estados es el siguiente:
0
q0
q1
1
q2
1
0
Ejercicios de la sección 2.4
À Sea Σ = {a, b}. Diseñar AFN (autómatas finitos no-deterministas) que acepten los
siguientes lenguajes:
(i) a(a ∪ ab)∗ .
(ii) a+ b∗ a.
(iii) a∗ b ∪ b∗ a.
(iv) b∗ (ab ∪ ba)∗ .
Introducción a la Teorı́a de la Computación.
Capı́tulo 2
38
(v) b∗ (ab ∪ ba)∗ a∗ .
Á Sea Σ = {0, 1}. Diseñar AFN (autómatas finitos no-deterministas) que acepten los
siguientes lenguajes:
(i) (01 ∪ 001)∗ .
(ii) (01∗ 0 ∪ 10∗ )∗ .
(iii) 1∗ 01 ∪ 10∗ 1.
2.5.
Equivalencia computacional entre los AFD y los
AFN
En esta sección se mostrará que los modelos AFD y AFN son computacionalmente equivalentes en el sentido de que aceptan los mismos lenguajes. En primer lugar, es fácil ver que
un AFD M = (Σ, Q, q0 , F, δ) puede ser considerado como un AFN M 0 = (Σ, Q, q0 , F, ∆)
definiendo ∆(q, a) = {δ(q, a)} para cada q ∈ Q y cada a ∈ Σ. Para la afirmación recı́proca
tenemos el siguiente teorema.
2.5.1 Teorema. Dado un AFN M = (Σ, Q, q0 , F, ∆) se puede construir un AFD M 0
equivalente a M , es decir, tal que L(M ) = L(M 0 ).
La demostración detallada de este teorema se presentará más adelante. La idea de la
demostración consiste en considerar cada conjunto de estados ∆(q, s) = {qi1 , qi2 , . . . , qik }
que aparezca en la tabla de la función ∆ del autómata no-determinista M como un
único estado del nuevo autómata determinista M 0 . La tabla de ∆ se completa hasta
que no aparezcan nuevas combinaciones de estados. Los estados de aceptación del nuevo
autómata son los conjuntos de estados en los que aparece por lo menos un estado de
aceptación del autómata original.
Se obtiene ası́ un procedimiento algorı́tmico que convierte un AFN dado en un AFD
equivalente. En los siguientes dos ejemplos ilustramos el procedimiento.
en el último ejemplo de la sección 2.4, acepta
Ejemplo El siguiente AFN M , presentado
el lenguaje L = (01 ∪ 010)∗ sobre Σ = {0, 1}.
0
q0
q1
1
q2
1
0
La tabla original de la función de transición ∆ de M contiene la combinación {q0 , q2 } que
adquiere el estatus de nuevo estado en M 0 . Al extender la tabla de ∆ aparece también el
nuevo estado {q0 , q1 }:
Introducción a la Teorı́a de la Computación.
Capı́tulo 2
∆
0
1
∆
0
1
q0
{q1 }
∅
q0
{q1 }
∅
q1
∅
{q0 , q2 }
q1
∅
{q0 , q2 }
q2
{q0 }
∅
q2
{q0 }
∅
{q0 , q2 }
{q0 , q1 }
∅
{q0 , q1 }
{q1 }
{q0 , q2 }
39
La tabla original de la función ∆ y su extensión.
La tabla de la derecha corresponde a un AFD ya que cada combinación de estados de M
se considera ahora como un único estado en M 0 . El grafo del nuevo autómata M 0 es:
0
{q0 }
0
{q1 }
{q2 }
0
1
0
{q0 , q2 }
{q0 , q1 }
1
Los estados de aceptación son aquéllos en los que aparezca q0 ya que q0 es el único estado
de aceptación del autómata original.
Puesto que el estado {q2 } en el nuevo autómata no interviene en la aceptación de
cadenas, es inútil y puede ser eliminado. El autómata M 0 se puede simplificar en la
siguiente forma:
p0
0
p1
1
0
0
p2
p3
1
Introducción a la Teorı́a de la Computación.
Capı́tulo 2
40
Ejemplo Sean Σ = {0, 1} y L2 el lenguaje de todas las cadenas de longitud ≥ 2 en
las que el segundo sı́mbolo, de derecha a izquierda es un 1. Una expresión
regular para este lenguaje es (0 ∪ 1)∗ 1(0 ∪ 1) y es fácil diseñar un AFN M que acepte a
L2 :
0, 1
q0
1
0, 1
q1
q2
Por simple inspección no es tan fácil diseñar un AFD que acepte a L2 , pero aplicando el
procedimiento de conversión podemos encontrar uno. Hacemos la tabla de la función de
transición ∆ y la extendemos con las nuevas combinaciones de estados.
∆
0
1
q0
{q0 }
{q0 , q1 }
q1
{q2 }
{q2 }
q2
∅
∅
{q0 , q1 }
{q0 , q2 }
{q0 , q1 , q2 }
{q0 , q2 }
{q0 }
{q0 , q1 }
{q0 , q1 , q2 }
{q0 , q2 }
{q0 , q1 , q2 }
En el nuevo autómata los estados {q1 } y {q2 } resultan inútiles; una vez eliminados obtenemos el siguiente AFD equivalente al AFN M :
0
0
{q0 }
1
1
0
{q0 , q1 }
{q0 , q2 }
0
1
{q0 , q1 , q2 }
1
Introducción a la Teorı́a de la Computación.
Capı́tulo 2
41
Para la demostración del Teorema 2.5.1, conviene extender la definición de la función de
transición, tanto de los autómatas deterministas como de los no-deterministas.
2.5.2 Definición. Sea M = (Σ, Q, q0 , F, δ) un AFD. La función de transición δ,
δ : Q × Σ −→ Q se extiende a una función δb : Q × Σ∗ −→ Q por medio de la siguiente
definición recursiva:

b

δ(q, λ) = q, q ∈ Q,
b a) = δ(q, a), q ∈ Q, a ∈ Σ,
δ(q,

b
b u), a), q ∈ Q, a ∈ Σ, u ∈ Σ∗ .
δ(q, ua) = δ(δ(q,
b u) es el estado en el que el
Según esta definición, para una cadena cualquiera u ∈ Σ∗ , δ(q,
b 0 , u) es
autómata termina el procesamiento de u a partir del estado q. En particular, δ(q
el estado en el que el autómata termina el procesamiento de la entrada u desde el estado
inicial q0 . Por lo tanto, podemos describir el lenguaje aceptado por M de la siguiente
forma:
b 0 , u) ∈ F }.
L(M ) = {u ∈ Σ∗ : δ(q
b u) se puede escribir simplemente δ(q, u). Esto no
Notación. La función extendida δ(q,
crea confusión ni ambigüedad.
2.5.3 Definición. Sea M = (Σ, Q, q0 , F, ∆) un AFN. La función de transición ∆,
∆ : Q × Σ −→ ℘(Q) se extiende inicialmente a conjuntos de estados. Para a ∈ Σ y
S ⊆ Q se define
[
∆(S, a) :=
∆(q, a).
q∈S
Se tendrı́a ∆(S, a) = ∅ en el caso en que ∆(q, a) = ∅ para todo q ∈ S.
b : Q × Σ∗ −→ ℘(Q), de manera similar a como
Luego se extiende ∆ a una función ∆
se hace para los AFD. Recursivamente,

b λ) = {q}, q ∈ Q,

∆(q,


b
∆(q, a) = ∆(q, a), q ∈ Q, a ∈ Σ,
[

b ua) = ∆(∆(q,
b u), a) =
∆(q,
∆(p, a), q ∈ Q, a ∈ Σ, u ∈ Σ∗ .



b
p∈∆(q,u)
b u) es el conjunto de los
Según esta definición, para una cadena cualquiera u ∈ Σ∗ , ∆(q,
posibles estados en los que terminan los procesamientos completos de u a partir del estado
b 0 , u) es el conjunto de los posibles
q. En particular, para una cadena de entrada u ∈ Σ∗ , ∆(q
estados en los que terminan los procesamientos completos de u desde el estado inicial q0 .
b 0 , u) = ∅.
Si todos los procesamientos de u se abortan en algún momento, se tendrı́a ∆(q
b el lenguaje aceptado por M se puede describir de la
Usando la función extendida ∆,
siguiente forma:
b 0 , u) contiene por lo menos un estado de aceptación}.
L(M ) = {u ∈ Σ∗ : ∆(q
Introducción a la Teorı́a de la Computación.
Capı́tulo 2
42
b u) se puede escribir simplemente ∆(q, u). Esto no
Notación. La función extendida ∆(q,
crea confusión ni ambigüedad.
Demostración del Teorema 2.5.1:
Dado el AFN M = (Σ, Q, q0 , F, ∆), construimos el AFD M 0 ası́:
M 0 = (Σ, ℘(Q), {q0 }, F 0 , δ)
donde
δ : ℘(Q) × Σ −→ ℘(Q)
(S, a) 7−→ δ(S, a) := ∆(S, a).
F 0 = {S ⊆ Q : S contiene por lo menos un estado de aceptación de M }.
Razonando por recursión sobre u, se demostrará para toda cadena u ∈ Σ∗ , δ({q0 }, u) =
∆(q0 , u). Para u = λ, claramente se tiene δ({q0 }, λ) = {q0 } = ∆(q0 , λ). Para u = a, a ∈ Σ,
se tiene
δ({q0 }, a) = ∆({q0 }, a) = ∆(q0 , a).
Supóngase (hipótesis recursiva) que δ({q0 }, u) = ∆(q0 , u), y que a ∈ Σ. Entonces
δ({q0 }, ua) = δ(δ({q0 }, u), a)
= δ(∆(q0 , u), a)
= ∆(∆(q0 , u), a)
= ∆(q0 , ua)
(definición de la extensión de δ)
(hipótesis recursiva)
(definición de δ)
(definición de la extensión de ∆).
Finalmente podemos demostrar que L(M 0 ) = L(M ):
u ∈ L(M 0 ) ⇐⇒ δ({q0 }, u) ∈ F 0
⇐⇒ ∆(q0 , u) ∈ F 0
⇐⇒ ∆(q0 , u) contiene un estado de aceptación de M
⇐⇒ u ∈ L(M ).
Ejercicios de la sección 2.5
À Utilizando el procedimiento de conversión presentado en esta sección, encontrar
AFD equivalentes a los siguientes AFN:
(i)
4
b
q0
3
q1
a
2
b
b
1
0
−5
−4
−3
−2
−1
0
q2
1
2
a
3
q3
4
5
6
7
8
9
Introducción a la Teorı́a de la Computación.
Capı́tulo 2
43
a
4
(ii)
b
q0
3
q1
a
2
b
b
1
0
−5
−4
−3
−2
−1
q2
1
2
a
q3
3
4
5
6
7
8
9
10
11
12
13
10
11
12
13
a
b
3
(iii)
a
b
q0
2
1
−1
0
q1
q2
b
0
1
2
3
4
5
6
7
8
9
a
3
(iv)
b
a
q0
2
q1
q2
a
1
0
−1
0
1
2
3
4
5
6
a
7
8
9
Á Sean Σ = {0, 1} y L3 el lenguaje de todas las cadenas de longitud ≥ 3 en las que el
tercer sı́mbolo, de derecha a izquierda es un 1. Diseñar un AFN con cuatro estados
que acepte a L3 y aplicar luego el procedimiento de conversión para encontrar un
AFD equivalente.
 Sea M = (Σ, Q, q0 , F, δ) un AFD. Demostrar por recursión sobre cadenas que la
extensión de δ satisface
δ(q, uv) = δ(δ(q, u), v),
para todo estado q ∈ Q, y todas las cadenas u, v ∈ Σ∗ .
à Sea M = (Σ, Q, q0 , F, ∆) un AFN. Demostrar por recursión sobre cadenas que la
extensión de ∆ satisface
∆(q, uv) = ∆(∆(q, u), v),
para todo estado q ∈ Q, y todas las cadenas u, v ∈ Σ∗ .
Introducción a la Teorı́a de la Computación.
2.6.
Capı́tulo 2
44
Autómatas con transiciones λ (AFN-λ)
Un autómata finito con transiciones λ (AFN-λ) es un autómata no-determinista M =
(Σ, Q, q0 , F, ∆) en el que la función de transición está definida como:
∆ : Q × (Σ ∪ {λ}) → ℘(Q).
∆ permite, además de las instrucciones no-deterministas usuales, transiciones de la forma ∆(q, λ) = {qi1 , . . . , qik }, llamadas transiciones λ, transiciones nulas o transiciones
espontáneas. Sobre la cinta de entrada, el significado computacional de la instrucción
∆(q, λ) = {qi1 , . . . , qik }
es el siguiente: estando en el estado q, el autómata puede cambiar aleatoriamente a uno
cualquiera de los estados qi1 , . . . , qik , independientemente del sı́mbolo leı́do y sin mover
la unidad de control a la derecha. Dicho de otra manera, las transiciones λ permiten a la
unidad de control del autómata cambiar internamente de estado sin procesar o “consumir”
el sı́mbolo leı́do sobre la cinta.
Como sucede en el caso AFN, una cadena de entrada u ∈ Σ∗ es aceptada si existe por lo
menos un procesamiento completo de u, desde q0 , que termina en un estado de aceptación.
En el grafo del autómata, las transiciones λ dan lugar a arcos con etiquetas λ. Una cadena
de entrada u es aceptada por un AFN-λ si existe por lo menos una trayectoria, desde el
estado q0 , cuyas etiquetas son exactamente los sı́mbolos de u, intercalados con cero, uno
o más λs.
En los autómatas AFN-λ, al igual que en los AFN, puede haber múltiples procesamientos para una misma cadena de entrada, ası́ como procesamientos abortados.
Ejemplo
Consideremos el siguiente AFN-λ, M :
λ
q0
a
q1
b
q2
λ
q5
λ
q3
b
a
q4
b
a
Introducción a la Teorı́a de la Computación.
Capı́tulo 2
45
La entrada u = abab es aceptada siguiendo sobre el grafo de M la trayectoria abλab.
Si miramos este procesamiento sobre la cinta de entrada, M utiliza una transición λ
para cambiar internamente del estado q2 al estado q3 , sin desplazar la cabeza lectora a la
derecha.
u
a b a b
≡
q
q
0
q
1
q
2
q
3
q
3
···
4
La entrada v = aaabb es aceptada siguiendo sobre el grafo de M la trayectoria λλaaabb.
Sobre la cinta de entrada, este procesamiento de v corresponde a dos transiciones espontáneas consecutivas: de q0 a q2 y luego de q2 a q3 . Al utilizar estas transiciones λ, la
cabeza lectora no se desplaza a la derecha.
v
a a a b b
≡
q
q
0
q
3
q
3
q
3
q
4
···
4
q
2
q
3
También puede observarse sobre el grafo de M que para la cadena abbb hay dos trayectorias
de aceptación diferentes, a saber, abλbb y λλabbb.
Los AFN-λ permiten aún más libertad en el diseño de autómatas, especialmente cuando
hay numerosas uniones y concatenaciones.
Introducción a la Teorı́a de la Computación.
Ejemplo
Capı́tulo 2
46
Diseñar AFN-λ que acepten los siguientes lenguajes:
(1) a∗ ∪ (ab ∪ ba)∗ ∪ b+ .
(2) a∗ (ab ∪ ba)∗ b+ .
Las expresiones regulares para estos dos lenguajes se pueden obtener a partir de las tres
sub-expresiones a∗ , (ab ∪ ba)∗ y b+ , para las cuales es fácil diseñar autómatas.
a
1
0
−11
−10
Autómata
que
acepta
a−5∗ :
−9
−8
−7
−6
−4
−3
−2
−1
q1
0
1
2
5
q3
4
a
b
3
∗
q2
Autómata que acepta (ab ∪ ba) :
a
2
b
1
q4
0
−5
−4
−3
−2
−1
0
1
2
3
4
5
6
7
8
9
10
b
1
0
−11
−10
+
Autómata
que
acepta
b−5
:
−9
−8
−7
−6
−4
−3
−2
−1
q5
0
b
1
2
q6
3
4
(1) Para aceptar a∗ ∪(ab∪ba)∗ ∪b+ utilizamos un nuevo estado inicial q0 y tres transiciones λ que lo conectan con los tres autómatas anteriores. Los estados de aceptación se
mantienen. Esta manera de conectar autómatas la llamaremos “conexión en paralelo”. Desde el estado inicial q0 el autómata puede proseguir el procesamiento de una
entrada por tres caminos diferentes para aceptar a∗ , (ab∪ba)∗ y b+ , respectivamente:
5
Introducción a la Teorı́a de la Computación.
Capı́tulo 2
47
a
7
q1
6
5
q3
λ
4
a
b
3
λ
q0
q2
a
2
b
1
q4
λ
0
b
−1
2
3
4
5
b
q5
−2
6
7
8
9
q6
10
11
12
(2) Para aceptar a∗ (ab ∪ ba)∗ b+ conectamos linealmente los tres autómatas mediante
transiciones λ. Esta manera de conectar autómatas la llamaremos “conexión en
serie”. Nótese que hay un único estado de aceptación correspondiente al bucle final
b∗ . Los estados q1 y q2 no pueden ser de aceptación en el nuevo autómata:
5
q3
4
a
b
a
b
3
λ
q1
λ
q2
b
q5
q6
a
2
b
1
q4
0
2
3
4
5
6
7
8
9
10
11
12
13
14
En la sección 2.10 veremos que los procedimientos de conexión en paralelo y en serie
se pueden sistematizar para diseñar algorı́tmicamente un AFN-λ que acepte el lenguaje
representado por una expresión regular dada.
Introducción a la Teorı́a de la Computación.
Ejercicios de la sección 2.6
Capı́tulo 2
48
À Sea Σ = {a, b}. Diseñar AFN-λ (autómatas finitos no-deterministas con transiciones λ) que acepten los siguientes lenguajes:
(i) (ab ∪ b)∗ ab∗ a∗ .
(ii) ab∗ ∪ ba∗ ∪ b(ab ∪ ba)∗ .
(iii) (a ∪ aba)∗ b∗ (ab ∪ ba)∗ a∗ .
Á Sea Σ = {0, 1}. Diseñar AFN-λ (autómatas finitos no-deterministas con transiciones λ) que acepten los siguientes lenguajes:
(i) (1 ∪ 01 ∪ 001)∗ 0∗ 1∗ 0+ .
(ii) 0+ 1(010)∗ (01 ∪ 10)∗ 1+ .
(iii) (101)∗ ∪ 1∗ (1 ∪ 10)∗ 0+ (01 ∪ 10)∗ .
2.7.
Equivalencia computacional entre los AFN-λ y
los AFN
En esta sección se mostrará que el modelo AFN-λ es computacionalmente equivalente
al modelo AFN. En primer lugar, un AFN puede ser considerado como un AFN-λ en el
que, simplemente, hay cero transiciones λ. Recı́procamente, vamos a presentar un procedimiento algorı́tmico de conversión de un AFN-λ en un AFN que consiste en eliminar las
transiciones λ añadiendo transiciones que las simulen, sin alterar el lenguaje aceptado. El
procedimiento se basa en la noción de λ-clausura de un estado. Dado un AFN-λ M y un
estado q de M , la λ-clausura de q, notada λ[q], es el conjunto de estados de M a los que
se puede llegar desde q por 0, 1 o más transiciones λ. Según esta definición, un estado q
siempre pertenece a su λ-clausura, es decir, q ∈ λ[q]. Si desde q no hay transiciones λ, se
tendrá λ[q] = {q}. La λ-clausura de un conjunto de estados {q1 , . . . , qk } se define como la
unión de las λ-clausuras, esto es,
λ[{q1 , . . . , qk }] := λ[q1 ] ∪ · · · ∪ λ[qk ].
También se define λ[∅] := ∅.
2.7.1 Teorema. Dado un AFN-λ M = (Σ, Q, q0 , F, ∆), se puede construir un AFN M 0
(sin transiciones λ) equivalente a M , es decir, tal que L(M ) = L(M 0 ).
Bosquejo de la demostración. Se construye M 0 = (Σ, Q, q0 , F 0 , ∆0 ) a partir de M manteniendo el conjunto de estados Q y el estado inicial q0 . M 0 tiene una nueva función de
transición ∆0 y un nuevo conjunto de estados de aceptación F 0 definidos por:
∆0 : Q × Σ
(q, a)
−→
7−→
℘(Q)
∆0 (q, a) := λ ∆(λ[q], a) .
Introducción a la Teorı́a de la Computación.
Capı́tulo 2
49
F 0 = {q ∈ Q : λ[q] contiene al menos un estado de aceptación}.
Es decir, los estados de aceptación de M 0 incluyen los estados de aceptación de M y
aquellos estados desde los cuales se puede llegar a un estado de aceptación por medio de
una o más transiciones λ.
La construcción de M 0 a partir
de M es puramente algorı́tmica. El significado de la
0
fórmula ∆ (q, a) = λ ∆(λ[q], a) se puede apreciar considerando el grafo que aparece a
continuación, que es una porción de un AFN-λ M .
q1
Porción de M :
a
q
a
q2
λ
q3
q4
λ
q5
a
q6
λ
λ
q7
Por simple inspección observamos que, una vez procesada una a, el autómata puede
pasar desde el estado q a uno de los siguientes estados: q1 , q2 , q3 , q6 , q7 . Para obtener esta
lista de estados se tienen en cuenta todas las transiciones λ que preceden o prosiguen el
procesamiento del sı́mbolo a desde el estado q.
Al aplicar la fórmula ∆0 (q, a) = λ ∆(λ[q], a) se llega a esta misma lista de estados.
En efecto, por la definición de λ-clausura se tiene que λ[q] = {q, q4 , q5 }, y se obtiene que
∆0 (q, a) = λ ∆(λ[q], a) = λ[∆({q, q4 , q5 }, a)]
= λ[{q1 , q2 , q6 }] = λ[q1 ] ∪ λ[q2 ] ∪ λ[q6 ]
= {q1 } ∪ {q2 , q3 } ∪ {q6 , q7 } = {q1 , q2 , q3 , q6 , q7 }.
La porción correspondiente del grafo de M 0 se exhibe en la siguiente gráfica. De esta forma
M 0 simula, sin transiciones λ, todas las transiciones λ de M añadiendo nuevas transiciones
con etiqueta a.
Introducción a la Teorı́a de la Computación.
Capı́tulo 2
50
q1
0
Porción de M :
a
a
a
q
q2
q4
q3
a
a
q5
a
q6
q7
Ejemplo Utilizar la construcción del Teorema 2.7.1 para encontrar un AFN equivalente
al siguiente AFN-λ M .
q1
a
q0
b
a
b
λ
q2
λ
q3
Las λ-clausuras de los estados vienen dadas por:
λ[q0 ]
λ[q1 ]
λ[q2 ]
λ[q3 ]
=
=
=
=
{q0 , q2 , q3 }.
{q1 }.
{q2 , q3 }.
{q3 }.
La función de transición ∆0 : Q × {a, b} → ℘({q0 , q1 , q2 , q3 }) es:
∆0 (q0 , a)
∆0 (q0 , b)
∆0 (q1 , a)
∆0 (q1 , b)
∆0 (q2 , a)
∆0 (q2 , b)
∆0 (q3 , a)
∆0 (q3 , b)
=
=
=
=
=
=
=
=
λ [∆(λ[q0 ], a)] = λ [∆({q0 , q2 , q3 }, a)] = λ[{q0 }] = {q0 , q2 , q3 }.
λ [∆(λ[q0 ], b)] = λ [∆({q0 , q2 , q3 }, b)] = λ[{q1 , q3 }] = {q1 , q3 }.
λ [∆(λ[q1 ], a)] = λ [∆({q1 }, a)] = λ[{q2 }] = {q2 , q3 }.
λ [∆(λ[q1 ], b)] = λ [∆({q1 }, b)] = λ[∅] = ∅.
λ [∆(λ[q2 ], a)] = λ [∆({q2 , q3 }, a)] = λ[∅] = ∅.
λ [∆(λ[q2 ], b)] = λ [∆({q2 , q3 }, b)] = λ[{q1 , q3 }] = λ[{q1 }] ∪ λ[{q3 }] = {q1 , q3 }.
λ [∆(λ[q3 ], a)] = λ [∆({q3 }, a)] = λ[∅] = ∅.
λ [∆(λ[q3 ], b)] = λ [∆({q3 }, b)] = λ[{q3 }] = {q3 }.
El autómata M 0 ası́ obtenido es el siguiente:
Introducción a la Teorı́a de la Computación.
Capı́tulo 2
51
q1
3
a
b
q0
a
2
1
a
b
q2
a
b
b
q3
0
−1
0
1
2
3
a,4 b
5
6
7
8
Puesto que q3 , que es el único estado de aceptación del autómata original M , pertenece
a λ[q0 ], a λ[q2 ] y a λ[q3 ], los tres estados q0 , q2 y q3 son estados de aceptación en el
autómata M 0 .
Es importante recalcar que para autómatas sencillos como el autómata M de este
ejemplo, es posible obtener M 0 procediendo por simple inspección. Para ello es necesario
tener en cuenta todas las transiciones λ que preceden o prosiguen el procesamiento de
cada sı́mbolo de entrada, desde cada estado.
Ejercicios de la sección 2.7
Utilizando el procedimiento presentado en esta sección, construir AFN equivalentes a los
siguientes AFN-λ. Proceder
ya sea por simple inspección o aplicando explı́citamente la
fórmula ∆0 (q, a) = λ ∆(λ[q], a) para todo q ∈ Q y todo a ∈ Σ.
À
a
a
b
λ
q0
q1
λ
q2
Á
b
a
q1
λ
q2
a
q0
b
λ
q3
q4
a
Introducción a la Teorı́a de la Computación.
Capı́tulo 2
52
Â
a
q1
q3
λ
a
b
λ
q0
q2
a
b
q4
Ã
q4
a
b
λ
a
b
q0
2.8.
λ
q1
a
q2
λ
q3
Complemento de un autómata determinista
El complemento de un AFD M = (Σ, Q, q0 , F, δ) es el AFD M = (Σ, Q, q0 , F , δ) donde
F = Q − F . Es decir, el complemento de M se obtiene intercambiando los estados de
aceptación con los de no-aceptación, manteniendo los demás componentes de M . M acepta
lo que M rechaza y viceversa; se concluye que si L(M ) = L entonces L(M ) = L = Σ∗ − L.
NOTA: Si en M todos los estados son de aceptación, entonces L(M ) = Σ∗ . En tal caso,
se define el complemento de M como el AFD M con dos estados tal que L(M ) = ∅.
Cuando un lenguaje L está definido por medio de una condición negativa puede ser
más fácil diseñar primero un AFD que acepte su complemento L.
Ejemplo Sea Σ = {a, b}. Encontrar un AFD que acepte el lenguaje L de todas las ca
denas que no tienen dos bes consecutivas (es decir, no contienen la subcadena
Introducción a la Teorı́a de la Computación.
Capı́tulo 2
53
bb).
Diseñamos primero un AFD M que acepte el lenguaje de todas las cadenas que tienen
dos bes consecutivas. Esto lo conseguimos forzando la trayectoria de aceptación bb:
a, b
a
M:
b
q0
b
q1
q2
a
Para aceptar a L formamos el complemento de M , intercambiando aceptación con noaceptación:
a, b
a
M:
b
q0
b
q1
q2
a
En M , q2 es estado limbo y L(M ) = L.
La noción de complemento no es útil para AFN ya que si M es un AFN tal que
L(M ) = L, no necesariamente se tendrá que L(M ) = L, como se aprecia en el siguiente
ejemplo.
Ejemplo Sea Σ = {0, 1} y L el lenguaje de todas las cadenas que terminan en 1. El
siguiente AFN acepta a L:
0, 1
q0
1
q1
Pero al intercambiar aceptación con no-aceptación se obtiene el AFN:
0, 1
q0
1
q1
cuyo lenguaje aceptado es (0 ∪ 1)∗ , diferente de L.
Ejercicios de la sección 2.8
Utilizar la noción de complemento de un AFD para diseñar AFD que acepten los siguientes
lenguajes:
Introducción a la Teorı́a de la Computación.
Capı́tulo 2
54
À El lenguaje de todas las cadenas que no contienen la subcadena bc. Alfabeto: {a, b, c}.
Á El lenguaje de todas las cadenas que no tienen tres unos consecutivos. Alfabeto:
{0, 1}.
 El lenguaje de todas las cadenas que no terminan en 01. Alfabeto: {0, 1}.
à El lenguaje de todas las cadenas que no terminan en 22. Alfabeto: {0, 1, 2}.
2.9.
Producto cartesiano de autómatas deterministas
Dados dos autómatas deterministas M1 = (Σ, Q1 , q1 , F1 , δ1 ) y M2 = (Σ, Q2 , q2 , F2 , δ2 ) se
puede formar un nuevo autómata determinista cuyos estados son todas las parejas de
la forma (qi , qj ), donde qi ∈ Q1 y qj ∈ Q2 . Este nuevo autómata se denomina producto
cartesiano de M1 y M2 y se denota por M1 × M2 . Concretamente,
M1 × M2 = (Σ, Q1 × Q2 , (q1 , q2 ), F, δ)
donde el estado inicial (q1 , q2 ) está conformado por los estados iniciales de los dos autómatas, y la función de transición δ está dada por
δ : (Q1 × Q2 ) × Σ −→ Q1 × Q2
δ((qi , qj ), a) = (δ1 (qi , a), δ2 (qj , a)).
El conjunto F de estados de aceptación se puede escoger según la conveniencia de la
situación. En el siguiente teorema se muestra que es posible escoger F adecuadamente
para que M1 × M2 acepte ya sea L1 ∪ L2 o L1 ∩ L2 o L1 − L2 .
2.9.1 Teorema. Sean M1 = (Σ, Q1 , q1 , F1 , δ1 ) y M2 = (Σ, Q2 , q2 , F2 , δ2 ) dos AFD tales
que L(M1 ) = L1 y L(M2 ) = L2 , y sea M = M1 × M2 = (Σ, Q1 × Q2 , q1 , q2 ), F, δ) el
producto cartesiano definido arriba.
(i) Si F = {(qi , qj ) : qi ∈ F1 o qj ∈ F2 } entonces L(M1 × M2 ) = L1 ∪ L2 . Es decir, para
aceptar L1 ∪ L2 , en el autómata M1 × M2 se escogen como estados de aceptación los
pares de estados (qi , qj ) en los que alguno de los dos es de aceptación. Formalmente,
F = (F1 × Q2 ) ∪ (Q1 × F2 ).
(ii) Si F = {(qi , qj ) : qi ∈ Fi y qj ∈ F2 } entonces L(M1 × M2 ) = L1 ∩ L2 . Es decir, para
aceptar L1 ∩ L2 , en el autómata M1 × M2 se escogen como estados de aceptación los
pares de estados (qi , qj ) en los que ambos son estados de aceptación. Formalmente,
F = F1 × F2 .
(iii) Si F = {(qi , qj ) : qi ∈ F1 ó qj ∈
/ F2 } entonces L(M1 × M2 ) = L1 − L2 . Es decir, para
aceptar L1 − L2 , en el autómata M1 × M2 se escogen como estados de aceptación los
pares de estados (qi , qj ) en los que el primero es de aceptación en M1 y el segundo
no lo es en M2 . Formalmente, F = F1 × (Q2 − F2 ).
Introducción a la Teorı́a de la Computación.
Capı́tulo 2
55
Demostración. . Las conclusiones del teorema se obtienen demostrando primero que la
definición de la función δ de M = M1 × M2 se puede extender a cadenas arbitrarias:
(2.9.1)
b i , qj ), u) = (δb1 (qi , u), δb2 (qj , u)) para toda cadena u ∈ Σ∗ , qi ∈ Q1 , qj ∈ Q2 .
δ((q
Aquı́ se usan las funciones extendidas de δ, δ1 y δ2 , según la definición 2.5.2. La igualdad (2.9.1) se puede demostrar por recursión sobre u tal como se hace a continuación.
Para u = λ, el resultado es inmediato, y para u = a, la igualdad se reduce a la definición
de la función δ de M = M1 × M2 . Para el paso recursivo, suponemos como hipótesis
recursiva que (2.9.1) se cumple para una cadena arbitraria u; se pretende establecer la
igualdad para la cadena de entrada ua, donde a ∈ Σ. Se tiene
b i , qj ), ua) = δ(δ((q
b i , qj ), u), a)
δ((q
= δ((δb1 (qi , u), δb2 (qj , u)), a)
= (δ1 (δb1 (qi , u), a), δ2 (δb2 (qj , u), a))
= (δb1 (qi , ua), δb2 (qj , ua))
b
(definición de δ)
(hipótesis recursiva)
(definición de δ)
(definición de δb1 y δb2 ).
Este razonamiento por recursión sobre cadenas concluye la demostración de (2.9.1).
Procedemos ahora a demostrar las afirmaciones (i), (ii) y (iii) del teorema. Usando la
igualdad (2.9.1) se tiene que, para toda cadena u ∈ Σ∗ ,
b 1 , q2 ), u) ∈ F ⇐⇒ (δb1 (q1 , u), δb2 (q2 , u)) ∈ F.
u ∈ L(M ) ⇐⇒ δ((q
Por consiguiente, si F = {(qi , qj ) : qi ∈ F1 ó qj ∈ F2 }, entonces para toda cadena u ∈ Σ∗ ,
se tendrá
u ∈ L(M ) ⇐⇒ (δb1 (q1 , u), δb2 (q2 , u)) ∈ F
⇐⇒ δb1 (q1 , u) ∈ F1 ∨ δb2 (q2 , u) ∈ F2
⇐⇒ u ∈ L(M1 ) ∨ u ∈ L(M2 )
⇐⇒ u ∈ L(M1 ) ∪ L(M2 ) = L1 ∪ L2 .
Esto demuestra (i).
Ahora bien, si F = {(qi , qj ) : qi ∈ F1 y qj ∈ F2 }, entonces para toda cadena u ∈ Σ∗ , se
tendrá
u ∈ L(M ) ⇐⇒ (δb1 (q1 , u), δb2 (q2 , u)) ∈ F
⇐⇒ δb1 (q1 , u) ∈ F1 ∧ δb2 (q2 , u) ∈ F2
⇐⇒ u ∈ L(M1 ) ∧ u ∈ L(M2 )
⇐⇒ u ∈ L(M1 ) ∩ L(M2 ) = L1 ∩ L2 .
Esto demuestra (iii).
Introducción a la Teorı́a de la Computación.
Capı́tulo 2
56
Finalmente, si F = {(qi , qj ) : qi ∈ F1 y qj ∈
/ F2 }, entonces para toda cadena u ∈ Σ∗ , se
tendrá
w ∈ L(M ) ⇐⇒ (δb1 (q1 , u), δb2 (q2 , u)) ∈ F
⇐⇒ δb1 (q1 , u) ∈ F1 ∧ δb2 (q2 , u) ∈
/ F2
⇐⇒ u ∈ L(M1 ) ∧ u ∈
/ L(M2 )
⇐⇒ u ∈ L(M1 ) − L(M2 ) = L1 − L2 .
Esto demuestra (iii).
Ejemplo Utilizar el Teorema 2.9.1 para construir un AFD que acepte el lenguaje L de
todas las cadenas sobre el alfabeto Σ = {a, b} que tienen un número par de
aes y un número par de bes.
Solución. En el ejercicio Á de la sección 2.3 se pidió diseñar, por ensayo y error, un
AFD para aceptar este lenguaje. Ahora podemos proceder sistemáticamente siguiendo el
método del teorema Teorema 2.9.1 ya que el lenguaje L se puede escribir como L = L1 ∩L2
donde L1 es el lenguaje de las cadenas con un número par de aes y L2 es el lenguaje de las
cadenas con un número de par de bes. Esto nos permite utilizar la parte (ii) del Teorema
a partir de autómatas que acepten a L1 y L2 , respectivamente.
AFD M1 que acepta L1 (cadenas con un número par de aes):
b
b
a
q1
q3
a
AFD M2 que acepta L2 (cadenas con un número par de bes):
a
a
b
q2
q4
b
Entonces L = L(M1 ) ∩ L(M2 ) = L1 ∩ L2 . El producto cartesiano M1 × M2 tiene 4 estados:
(q1 , q2 ), (q1 , q4 ), (q3 , q2 ) y (q3 , q4 ); el único estado de aceptación es (q1 , q2 ) ya que es el único
par de estados en el cual ambos estados son de aceptación. Su función de transición δ se
Introducción a la Teorı́a de la Computación.
Capı́tulo 2
57
obtiene utilizando la definición de M1 × M2 .
δ((q1 , q2 ), a) = (δ1 (q1 , a), δ2 (q2 , a)) = (q3 , q2 ),
δ((q1 , q2 ), b) = (δ1 (q1 , b), δ2 (q2 , b)) = (q1 , q4 ),
δ((q1 , q4 ), a) = (δ1 (q1 , a), δ2 (q4 , a)) = (q3 , q4 ),
δ((q1 , q4 ), b) = (δ1 (q1 , b), δ2 (q4 , b)) = (q1 , q2 ),
δ((q3 , q2 ), a) = (δ1 (q3 , a), δ2 (q2 , a)) = (q1 , q2 ),
δ((q3 , q2 ), b) = (δ1 (q3 , b), δ2 (q2 , b)) = (q3 , q4 ),
δ((q3 , q4 ), a) = (δ1 (q3 , a), δ2 (q4 , a)) = (q1 , q4 ),
δ((q3 , q4 ), b) = (δ1 (q3 , b), δ2 (q4 , b)) = (q3 , q2 ).
El grafo del autómata ası́ obtenido es:
b
(q1 , q2 )
(q1 , q4 )
b
a
a
a
a
b
(q3 , q2 )
(q3 , q4 )
b
Ejemplo Utilizar el Teorema 2.9.1 para construir un AFD que acepte el lenguaje L de
todas las cadenas sobre el alfabeto Σ = {a, b} que tienen longitud impar y
que no contienen dos bes consecutivas, es decir, no contienen la subcadena bb.
Solución. Utilizamos la parte (ii) del Teorema 2.9.1 expresando L como L = L1 ∩L2 , donde
L1 = lenguaje de todas las cadenas que tienen longitud impar.
L2 = lenguaje de todas las cadenas que no contienen la subcadena bb.
Encontramos fácilmente un AFD M1 que acepta el lenguaje L1 :
M1 :
a, b
q1
q3
a, b
Y un AFD M2 que acepta L2 :
Introducción a la Teorı́a de la Computación.
Capı́tulo 2
58
a
M2 :
b
q2
q4
a
El autómata M2 fue obtenido a partir de su complemento en el primer ejemplo de la
sección 2.8. Aquı́ hemos suprimido el estado limbo ya que no interviene en la aceptación
de cadenas, y en el producto cartesiano los estados de aceptación para el lenguaje L1 ∩ L2
son los pares de estados (qi , qj ) en los que ambos son estados de aceptación.
Entonces L = L(M1 ) ∩ L(M2 ) = L1 ∩ L2 . El producto cartesiano M1 × M2 tiene 4
estados: (q1 , q2 ), (q1 , q4 ), (q3 , q2 ) y (q3 , q4 ). Los estados de aceptación son (q3 , q2 ) y (q3 , q4 ) ya
que q3 es de aceptación en M1 mientras que q2 y q4 son de aceptación en M2 . Utilizando
la definición de la función de transición δ de M1 × M2 se obtiene el siguiente AFD:
b
(q1 , q2 )
(q3 , q4 )
a
a
a
b
(q3 , q2 )
(q1 , q4 )
a
Este problema también se puede resolver expresando el lenguaje L como diferencia de dos
lenguajes (véase el Ejercicio À al final de la presente sección).
Ejemplo Utilizar el Teorema 2.9.1 para construir un AFD que acepte el lenguaje L de
todas las cadenas sobre el alfabeto Σ = {a, b} que tienen longitud impar o
que no contienen dos bes consecutivas.
Solución. Se tiene que L = L1 ∪ L2 donde L1 y L2 son los lenguajes definidos en el ejemplo
anterior. Utilizamos la parte (i) del Teorema 2.9.1: en el producto cartesiano los estados
de aceptación para el lenguaje L1 ∪ L2 son los pares (qi , qj ) en los que alguno de los dos
es un estado de aceptación. Por lo tanto, hay que tener en cuenta los estados limbo de
M1 y M2 , si los hay:
M1 :
a, b
q1
q3
a, b
Introducción a la Teorı́a de la Computación.
Capı́tulo 2
a, b
a
M2 :
59
b
q2
b
q4
q5
a
El producto cartesiano M = M1 × M3 tiene seis estados y los estados de aceptación son
(q1 , q2 ), (q3 , q2 ), (q3 , q4 ) y (q3 , q5 ).
b
(q1 , q2 )
(q3 , q4 )
b
(q1 , q5 )
a
a
a
a, b
a, b
b
(q3 , q2 )
(q1 , q4 )
b
(q3 , q5 )
a
Ası́ que M requiere seis estados y no hay estado limbo, a pesar de que q5 es un estado
limbo en el autómata M2 .
Este último ejemplo ilustra que, en general, para construir el producto cartesiano
M1 × M2 , los AFD originales M1 y M2 deben ser completos, es decir, deben incluir los
estados limbo, si los hay. Los estados limbo en los autómatas M1 y M2 se pueden omitir
únicamente cuando se desea aceptar el lenguaje L1 ∩ L2 .
Ejercicios de la sección 2.9
À Utilizar el Teorema 2.9.1 (iii) para construir un AFD que acepte el lenguaje L de
todas las cadenas sobre el alfabeto Σ = {a, b} que tienen longitud impar y que no
contienen dos bes consecutivas, expresando L como diferencia de dos lenguajes.
Á Utilizar el Teorema 2.9.1 para construir AFD que acepten los siguientes lenguajes
sobre el alfabeto {0, 1}:
(i) El lenguaje L de todas las cadenas que tienen longitud par o que terminan en
10.
(ii) El lenguaje L de todas las cadenas que tienen longitud impar y que terminan
en 01.
Introducción a la Teorı́a de la Computación.
Capı́tulo 2
60
(iii) El lenguaje L de todas las cadenas que tienen longitud impar y que no terminan
en 11.
(i) El lenguaje L de todas las cadenas que tienen un número par de ceros o que
no tienen dos ceros consecutivos.
 Utilizar el Teorema 2.9.1 para construir AFD que acepten los siguientes lenguajes
sobre el alfabeto {a, b, c}:
(i) El lenguaje L de todas las cadenas que tienen longitud par y terminan en a.
(ii) El lenguaje L de todas las cadenas que tienen longitud par o que tienen un
número impar de c’s.
(iii) El lenguaje L de todas las cadenas que tienen longitud impar y que tienen un
número par de ces.
(iv) El lenguaje L de todas las cadenas que tienen longitud impar y que no terminan
en c.
(v) El lenguaje L de todas las cadenas de longitud impar que tengan exactamente
dos aes.
à En el contexto del Teorema 2.9.1, dados dos AFD, M1 = (Σ, Q1 , q1 , F1 , δ1 ) y M2
(Σ, Q2 , q2 , F2 , δ2 ) tales que L(M1 ) = L1 y L(M2 ) = L2 , escoger adecuadamente
conjunto de estados de aceptación F para que el producto cartesiano M1 × M2
(Σ, Q1 × Q2 , (q1 , q2 ), F, δ) acepte la diferencia simétrica L1 / L2 . Recuérdese que
diferencia simétrica se define como
L1 / L2 = (L1 ∪ L2 ) − (L1 ∩ L2 ) = (L1 − L2 ) ∪ (L2 − L1 ).
=
el
=
la
Download
Random flashcards
Pastoralists

20 Cards

Create flashcards