Teoría de La Computación (2017) CAPITULO 2 (2.1 A 2.9)

Notas de clase para el curso
Introducción a la Teorı́a de la Computación

II Semestre 2017
Profesor: Rodrigo De Castro K.
Capı́tulo 2
Autómatas Finitos
Los autómatas son máquinas abstractas muy simples que tienen la capacidad de reconocer
lenguajes. Históricamente, su estudio se originó con la llamada “máquina de Turing”,
que fue propuesta en 1936 por el matemático británico Alan Turing (1912–1954) con el
propósito de precisar las caracterı́sticas y las limitaciones de un dispositivo de computación
mecánica. En los años 40 y 50 del siglo XX se adelantaron investigaciones sobre máquinas
de Turing con capacidad restringida, lo que dio lugar a la noción de autómata finito.
2.1. Autómatas finitos deterministas (AFD)

Los autómatas finitos son máquinas abstractas que procesan cadenas de entrada, las cuales
son aceptadas o rechazadas. El autómata actú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 autómata posee una unidad de control (también
llamada cabeza lectora, control finito o unidad de memoria) que tiene un número finito de
configuraciones internas, llamadas estados del autómata. Entre los estados de un autómata
se destacan el estado inicial y los estados finales o estados de aceptación.
Formalmente, un autómata finito M posee cinco parámetros o 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 aceptación. F debe ser distinto de ∅; es

decir, debe haber por lo menos un estado de aceptación.
23
Introducción a la Teorı́a de la Computación. Capı́tulo 2 24
5. La función δ de transición del autó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 está inicialmente en el estado
q0 escaneando la primera casilla:
u
a a ··· b ≡ ···
Unidad q
de control 0
La función de transición δ, también llamada dinámica del autómata, es la lista de ins-

trucciones que utiliza M para procesar todas las entradas. Ası́, la instrucción δ(q, s) = q 0
significa que, 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 acción constituye
un paso computacional :
δ(q, s) = q 0
··· s ··· ··· s ···
q q0
La unidad de control de un autómata siempre se desplaza hacia la derecha una vez procesa
o “consume” un sı́mbolo; no puede retornar ni tampoco sobre-escribir sı́mbolos sobre la
cinta.
Puesto que δ está definida para toda combinación estado-sı́mbolo, una cadena de en-
trada u cualquiera es procesada completamente, hasta que la unidad de control encuentra
la primera casilla vacı́a. 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).

Ejemplo Consideremos el autómata definido por los siguientes cinco componentes:

Σ = {a, b}.
Q = {q0 , q1 , q2 }.
q0 : estado inicial.
F = {q0 , q2 }, estados de aceptación.
Función de transición δ:
δ a b
δ(q0 , a) = q0 δ(q0 , b) = q1
q 0 q0 q1
δ(q1 , a) = q1 δ(q1 , b) = q2
q 1 q1 q2
δ(q2 , a) = q1 δ(q2 , b) = q1 .
q 2 q1 q1
Vamos a ilustrar el procesamiento de tres cadenas de entrada.

1. u = aabab.
u
a a b a b ≡ ···
q 0 q 0 q 0 q 1 q 1 q 2
Como q2 es un estado de aceptación, la cadena de entrada u es aceptada.

2. v = aababa.
u
a a b a b a ≡ ···
q 0 q 0 q 0 q
1 q 1 q 2 q 1
Puesto que q1 no es un estado de aceptación, la entrada v es rechazada.

3. Caso especial: la cadena λ es la cadena de entrada.
≡ ≡ ···
q 0
Como q0 es un estado de aceptación, la cadena λ es aceptada.

En general se tiene lo siguiente: la cadena vacı́a λ es aceptada por un autómata M si
y solamente si el estado inicial q0 también es un estado de aceptación.
Los autómatas finitos descritos anteriormente se denominan autómatas finitos deter-
ministas (AFD) ya que para cada estado q y para cada sı́mbolo a ∈ Σ, la función de
transición δ(q, a) siempre está definida y es un único estado. Esto implica que cualquier
cadena de entrada se procesa completamente y de manera única.
Un autómata M es entonces un mecanismo que clasifica todas las cadenas de Σ∗ en
dos grupos disyuntos: las que son aceptadas y las que son rechazadas. El conjunto de las
cadenas aceptadas por M se llama lenguaje aceptado o 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 autómata

Un autómata finito se puede representar por medio de un grafo dirigido y etiquetado.
Recuérdese que un grafo es un conjunto de vértices o nodos unidos por arcos o conectores;
si los arcos tienen tanto dirección como etiquetas, el grafo se denomina grafo dirigido y
etiquetado o digrafo etiquetado.
El digrafo etiquetado de un autómata se obtiene siguiendo las siguientes convenciones:
Los vértices o nodos son los estados del autómata.
El estado q se representa por: q
El estado inicial q0 se representa por: q0
Un estado de aceptación q se representa por: q
La transición δ(q, s) = q 0 se representa en la forma
s
q q0
Las etiquetas de los arcos entre nodos (estados) son entonces sı́mbolos del alfabeto de
entrada Σ. Si dos estados están unidos por dos arcos que tienen la misma dirección, basta
trazar un solo arco con doble etiqueta, separando los sı́mbolos con comas. Ası́ por ejemplo,
s
q q0
se representa simplemente como
s, t
q q0
El grafo de un autómata es muy útil para hacer el seguimiento o rastreo completo del pro-
cesamiento 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
aceptación.

Ejemplo Grafo del autómata presentado en la sección anterior.

Σ = {a, b}.
Q = {q0 , q1 , q2 }.
q0 : estado inicial.
F = {q0 , q2 }, estados de aceptación.
Función de transición δ:
δ a b
δ(q0 , a) = q0 δ(q0 , b) = q1
q0 q0 q1
δ(q1 , a) = q1 δ(q1 , b) = q2
q1 q1 q2
δ(q2 , a) = q1 δ(q2 , b) = q1
q2 q1 q1
a a
q0 b q1
a, b b
q2
Examinando directamente el grafo podemos observar fácilmente que, por ejemplo, la en-
trada aaababbb es aceptada mientras que aabaaba es rechazada.
2.3. Diseño de autómatas

En esta sección abordaremos el siguiente tipo de problemas: dado un lenguaje L diseñar un
autómata finito M que acepte o reconozca a L, es decir, tal que L(M ) = L. Más adelante
se demostrará en toda su generalidad que, si L es regular, estos problemas siempre tienen
solución.
Para los grafos de autómatas deterministas se adopta la siguiente convención adicional:
se supone que los arcos no dibujadas explı́citamente conducen a un estado “limbo” de no-
aceptación. Es decir, en el grafo de un autómata se indican únicamente los arcos que
intervengan en trayectorias de aceptación. Esto permite simplificar considerablemente la
presentación de los grafos.

Ejemplo Sea Σ = {a, b} y L = a∗ = {λ, a, a2 , a3 , . . .}. AFD M tal que L(M ) = L:

a a
q0 b q1
b
a
En la versión simplificada omitimos el estado limbo q1 : q0

Ejemplo 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 a q1
En la versión simplificada omitimos el estado limbo q2 :

Ejemplo Σ =∗ {a, b}. L = lenguaje de las cadenas que contienen exactamente dos aes
= b ab∗ ab∗ . AFD M tal que L(M ) = L, omitiendo el estado limbo:
b b b
q0 a q1 a q2

Ejemplo Σ = {0, 1}. L = lenguaje de las cadenas sobre Σ que tienen un número par
de sı́mbolos (cadenas de longitud par ≥ 0). AFD M tal que L(M ) = L:
0, 1
q0 q1
0, 1

Ejemplo Σ = {0, 1}. L = lenguaje de las cadenas sobre Σ que contienen un número
par de ceros. AFD M tal que L(M ) = L:
1 1
0
q0 q1
0
∗
Ejemplo Sean Σ = {a, b} y L = (b ∪ ab) . Construimos un AFD de tal forma que
el estado inicial q sea el único estado de aceptación y en él confluyan las
0
trayectorias b y ab. De esta forma L(M ) = L:
b
a
q0 q1

Ejercicios de la sección 2.3

À Sea Σ = {a, b}. Diseñar AFD (autómatas finitos deterministas) que acepten los
siguientes lenguajes:
(i) a∗ b∗ . (ii) a∗ ∪ b∗ .
(iii) (ab)∗ . (iv) (ab)+ .
(v) ab∗ ∪ b∗ a. (vi) a(a ∪ ab)∗ .
(vii) ab+ a∗ . Un AFD que acepte este lenguaje requiere como mı́nimo 5 estados más
un estado limbo (6 estados en total).
(vii) = a∗ b ∪ b∗ a. Un AFD que acepte este lenguaje requiere como mı́nimo 6 estados
más un estado limbo (7 estados en total).
(ix) b∗ (ab ∪ ba).
(x) b∗ (ab ∪ ba)a+ .
Á Sea Σ = {a, b}.
(i) Diseñar un AFD que acepte el lenguaje de todas las cadenas que contienen un
número par de aes y un número par de bes. Se entiende que par incluye a 0.
Ayuda: utilizar 4 estados.
(ii) Para cada combinación de las condiciones “par” e “impar” y de las conectivas
“o” e “y”, diseñar un AFD que acepte el lenguaje L definido por
L = lenguaje de las cadenas con un número par/impar de aes

y/o un número par/impar de bes.
Ayuda: utilizar el autómata de 4 estados diseñado en la parte (i), modificando

adecuadamente el conjunto de estados de aceptación.
Â Sea Σ = {0, 1}. Diseñar AFD (autómatas finitos deterministas) que acepten los
(i) El lenguaje de todas las cadenas que terminan en 01.

(ii) El lenguaje de todas las cadenas que tienen un nú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 conse-
cutivos.
(v) (0 ∪ 10)+ .
(vi) (01 ∪ 101)∗ .
(vii) 1+ (10 ∪ 01+ )∗ .
Ã Sea Σ = {a, b, c}. Diseñar AFD (autómatas finitos deterministas) que acepten los
(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
expresión regular para L y un AFD M tal que L(M ) = L.
2.4. Autómatas finitos no-deterministas (AFN)

En el modelo determinista una entrada u se procesa de manera ú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 (Autómata Finito No-determinista) M = (Σ, Q, q0 , F, ∆) po-
see cinco componentes, los primeros cuatro con el mismo significado que en el caso deter-
minista:
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 aceptación. F debe ser distinto de ∅; es

decir, debe haber por lo menos un estado de aceptación.
5. La función ∆ de transición del autó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 , después de lo cual se desplaza a la derecha.
Puede suceder que ∆(q, s) = ∅, lo cual significa que, si durante el procesamiento 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 noción de digrafo etiquetado para un AFN se define de manera análoga al caso
AFD, pero puede suceder que desde un mismo nodo (estado) salgan dos o más arcos con
la misma etiqueta:
s qi3
q
s s
qi2
q i1
Un AFN M puede procesar una cadena de entrada u ∈ Σ∗ de varias maneras. Sobre el

grafo del autó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 noción de aceptación para autó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 algún procesamiento en el que
u sea procesada completamente y que finalice estando M en un estado de aceptación. En
té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
aceptación.

Ejemplo Sea M el siguiente AFN:

a a b
b
a ∆ a b
q0 q1 q2
q0 {q0 , q1 , q3 } ∅
a b q1 {q1 } {q2 }
q2 ∅ {q1 , q2 }
q3
q3 ∅ {q3 }
Para la cadena de entrada u = abb, existen procesamientos que conducen al rechazo,

procesamientos abortados y procesamientos que terminan en estados de aceptación. Según
la definición de lenguaje aceptado, u ∈ L(M ).
u
Procesamiento de rechazo: a b b ≡ ···
q0 q 1 q 2 q 2
u
Procesamiento de aceptación: a b b ≡ ···
q 0 q 3 q 3 q 3
u
Otro procesamiento de aceptación: a b b ≡ ···
q 0 q 1 q 2 q 1
u
Procesamiento abortado: a b b ≡ ···
q 0 q 0
El grafo de M nos permite ver que la cadena aabbaa es aceptada mientras que aabaa es
rechazada. También son rechazadas todas las cadenas que comienzan con b.
∗ +
Ejemplo Considérese el lenguaje L = ab ∪a sobre el alfabeto Σ = {a, b}. El siguiente
AFN M satisface L(M ) = L.
b
a
q0 q1
a
a
q2
Un AFD que acepte a L requiere como mı́nimo cuatro estados má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 q3
1
Otro AFN que acepta el mismo lenguaje y que tiene sólo tres estados es el siguiente:
0
q0 q1 1 q2
0


À Sea Σ = {a, b}. Diseñar AFN (autómatas finitos no-deterministas) que acepten los
(i) a(a ∪ ab)∗ .

(ii) ab+ a∗ .
(iii) a∗ b ∪ b∗ a.
(iv) b∗ (ab ∪ ba)∗ .
(v) b∗ (ab ∪ ba)∗ a∗ .
Á Sea Σ = {0, 1}. Diseñar AFN (autómatas finitos no-deterministas) que acepten los
(i) (01 ∪ 001)∗ .

(ii) (01∗ 0 ∪ 10∗ )∗ .
(iii) 1∗ 01 ∪ 10∗ 1.
2.5. Equivalencia computacional entre los AFD y los

AFN
En esta sección se mostrará que los modelos AFD y AFN son computacionalmente equiva-
lentes en el sentido de que aceptan los mismos lenguajes. En primer lugar, es fá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 afirmació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 demostración detallada de este teorema se presentará más adelante. La idea de la
demostración consiste en considerar cada conjunto de estados ∆(q, s) = {qi1 , qi2 , . . . , qik }
que aparezca en la tabla de la función ∆ del autómata no-determinista M como un
único estado del nuevo autómata determinista M 0 . La tabla de ∆ se completa hasta
que no aparezcan nuevas combinaciones de estados. Los estados de aceptación del nuevo
autómata son los conjuntos de estados en los que aparece por lo menos un estado de
aceptación del autó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.

Ejemplo El siguiente AFN M , presentado en el último ejemplo de la sección 2.4, acepta
el lenguaje L = (01 ∪ 010)∗ sobre Σ = {0, 1}.
0
q0 q1 1 q2
La tabla original de la función de transición ∆ de M contiene la combinación {q0 , q2 } que

adquiere el estatus de nuevo estado en M 0 . Al extender la tabla de ∆ aparece también el
nuevo estado {q0 , q1 }:
∆ 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 }
La tabla original de la función ∆ y su extensión.

La tabla de la derecha corresponde a un AFD ya que cada combinación de estados de M
se considera ahora como un único estado en M 0 . El grafo del nuevo autómata M 0 es:
0
{q0 } {q1 } {q2 }
1 0
0
{q0 , q2 } {q0 , q1 }
Los estados de aceptación son aquéllos en los que aparezca q0 ya que q0 es el único estado
de aceptación del autómata original.
Puesto que el estado {q2 } en el nuevo autómata no interviene en la aceptación de
cadenas, es inútil y puede ser eliminado. El autómata M 0 se puede simplificar en la
siguiente forma:
p0 0 p1
1 0
0
p2 p3

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 expresión
regular para este lenguaje es (0 ∪ 1)∗ 1(0 ∪ 1) y es fácil diseñar un AFN M que acepte a
L2 :
0, 1
1 0, 1
q0 q1 q2
Por simple inspección no es tan fácil diseñar un AFD que acepte a L2 , pero aplicando el
procedimiento de conversión podemos encontrar uno. Hacemos la tabla de la función de
transició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 autómata los estados {q1 } y {q2 } resultan inútiles; una vez eliminados obte-
nemos el siguiente AFD equivalente al AFN M :
0
0
1
1 0
{q0 } {q0 , q1 } {q0 , q2 }
1 0
{q0 , q1 , q2 }
Para la demostración del Teorema 2.5.1, conviene extender la definición de la función de

transición, tanto de los autómatas deterministas como de los no-deterministas.
2.5.2 Definición. Sea M = (Σ, Q, q0 , F, δ) un AFD. La función de transición δ,
δ : Q × Σ −→ Q se extiende a una función δb : Q × Σ∗ −→ Q por medio de la siguiente
definición recursiva:

δ(q, λ) = q, q ∈ Q,
 b
b a) = δ(q, a), q ∈ Q, a ∈ Σ,
δ(q,

b b u), a), q ∈ Q, a ∈ Σ, u ∈ Σ∗ .
δ(q, ua) = δ(δ(q,
Según esta definición, para una cadena cualquiera u ∈ Σ∗ , δ(q,

b u) es el estado en el que el
autómata termina el procesamiento de u a partir del estado q. En particular, δ(q
b 0 , u) es
el estado en el que el autó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:
L(M ) = {u ∈ Σ∗ : δ(q
b 0 , u) ∈ F }.
Notación. La función extendida δ(q,

b u) se puede escribir simplemente δ(q, u). Esto no
crea confusión ni ambigüedad.
2.5.3 Definición. Sea M = (Σ, Q, q0 , F, ∆) un AFN. La función de transició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.

Luego se extiende ∆ a una función ∆ b : Q × Σ∗ −→ ℘(Q), de manera similar a como
se hace para los AFD. Recursivamente,

 b λ) = {q}, q ∈ Q,
∆(q,


∆(q, a) = ∆(q, a), q ∈ Q, a ∈ Σ,
b
[


 ∆(q,
b ua) = ∆(∆(q,
b u), a) = ∆(p, a), q ∈ Q, a ∈ Σ, u ∈ Σ∗ .

p∈∆(q,u)
b
Según esta definición, para una cadena cualquiera u ∈ Σ∗ , ∆(q,

b u) es el conjunto de los
posibles estados en los que terminan los procesamientos completos de u a partir del estado
q. En particular, para una cadena de entrada u ∈ Σ∗ , ∆(q
b 0 , u) es el conjunto de los posibles
estados en los que terminan los procesamientos completos de u desde el estado inicial q0 .
Si todos los procesamientos de u se abortan en algún momento, se tendrı́a ∆(q b 0 , u) = ∅.
Usando la función extendida ∆,b el lenguaje aceptado por M se puede describir de la
siguiente forma:
L(M ) = {u ∈ Σ∗ : ∆(q
b 0 , u) contiene por lo menos un estado de aceptación}.
Notación. La función extendida ∆(q,

b u) se puede escribir simplemente ∆(q, u). Esto no
crea confusión ni ambigüedad.
Demostració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 aceptación de M }.
Razonando por recursión sobre u, se demostrará 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).
Supóngase (hipótesis recursiva) que δ({q0 }, u) = ∆(q0 , u), y que a ∈ Σ. Entonces
δ({q0 }, ua) = δ(δ({q0 }, u), a) (definición de la extensión de δ)

= δ(∆(q0 , u), a) (hipótesis recursiva)
= ∆(∆(q0 , u), a) (definición de δ)
= ∆(q0 , ua) (definición de la extensió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 aceptación de M
⇐⇒ u ∈ L(M ).


À Utilizando el procedimiento de conversión presentado en esta sección, encontrar

AFD equivalentes a los siguientes AFN:
(i)
4
b
3 q0 a q1
b b
1
0 q2 q3
−5 −4 −3 −2 −1 0 1 2 a 3 4 5 6 7 8 9
a
(ii)
4
b
3 q0 a q1
b b
1
0 q2 q3
−5 −4 −3 −2 −1 0 1 2 a 3 4 5 6 7 8 9
b a
(iii)
3
a
q0 b q1 q2
2
1
b
−1 0 1 2 3 4 5 6 7 8 9 10 11 12 13
a
(iv)
3
b
q0 a q1 q2
2
a
1
0
−1 0 1 2 3 4 5 6
a 7 8 9 10 11 12 13
Á 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. Diseñar un AFN con cuatro estados
que acepte a L3 y aplicar luego el procedimiento de conversión para encontrar un
AFD equivalente.
Â Sea M = (Σ, Q, q0 , F, δ) un AFD. Demostrar por recursión sobre cadenas que la

extensió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 recursión sobre cadenas que la

extensión de ∆ satisface
∆(q, uv) = ∆(∆(q, u), v),
para todo estado q ∈ Q, y todas las cadenas u, v ∈ Σ∗ .
2.6. Autómatas con transiciones λ (AFN-λ)

Un autómata finito con transiciones λ (AFN-λ) es un autómata no-determinista M =
(Σ, Q, q0 , F, ∆) en el que la función de transición está definida como:
∆ : Q × (Σ ∪ {λ}) → ℘(Q).
∆ permite, además de las instrucciones no-deterministas usuales, transiciones de la for-

ma ∆(q, λ) = {qi1 , . . . , qik }, llamadas transiciones λ, transiciones nulas o transiciones
espontáneas. Sobre la cinta de entrada, el significado computacional de la instrucción
∆(q, λ) = {qi1 , . . . , qik }
es el siguiente: estando en el estado q, el autó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 autó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 aceptación.
En el grafo del autó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 más λs.
En los autómatas AFN-λ, al igual que en los AFN, puede haber múltiples procesa-
mientos para una misma cadena de entrada, ası́ como procesamientos abortados.

Ejemplo Consideremos el siguiente AFN-λ, M :

q0 a q1 b q2
λ λ
q5 q3 a
b
a
q4
b
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 transición λ
para cambiar internamente del estado q2 al estado q3 , sin desplazar la cabeza lectora a la
derecha.
u
a b a b ≡ ···
q0 q 1 q 2 q 3 q 4
q 3
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 es-
pontá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 ≡ ···
q0 q 3 q 3 q 3 q 4 q 4
q2
q3
También puede observarse sobre el grafo de M que para la cadena abbb hay dos trayectorias
de aceptación diferentes, a saber, abλbb y λλabbb.
Los AFN-λ permiten aún más libertad en el diseño de autómatas, especialmente cuando
hay numerosas uniones y concatenaciones.

Ejemplo Diseñ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 fácil diseñar autómatas.
a
1
0
−11 −10
Autómata
−9 −8
que
−7
acepta
−6
a−5∗ : −4 −3 −2 −1
q1
0 1 2
q3
4
a
3 b
∗ q2
Autómata que acepta (ab ∪ ba) :
2 a
1 b
q4
0
−5 −4 −3 −2 −1 0 1 2 3 4 5 6 7 8 9 10
b
1
+ q5 b q6
0
−11 −10
Autómata
−9 −8
que
−7
acepta
−6
b−5 : −4 −3 −2 −1 0 1 2 3 4 5
(1) Para aceptar a∗ ∪(ab∪ba)∗ ∪b+ utilizamos un nuevo estado inicial q0 y tres transicio-
nes λ que lo conectan con los tres autómatas anteriores. Los estados de aceptación
se mantienen. Esta manera de unir autómatas la llamaremos “conexión en parale-
lo”. Desde el estado inicial q0 el autómata puede proseguir el procesamiento de una
entrada por tres caminos diferentes para aceptar a∗ , (ab∪ba)∗ y b+ , respectivamente:
a
7
6 q1
λ q3
4
a
3 b
q0 λ q2
2 a
1 b
q4
0
λ
b
−1
−2 q5 b q6
2 3 4 5 6 7 8 9 10 11 12
(2) Para aceptar a∗ (ab ∪ ba)∗ b+ unimos linealmente los tres autómatas por medio de
transiciones λ. Esta manera de unir autómatas la llamaremos “conexión en serie”.
Nótese que hay un único estado de aceptación correspondiente al bucle final b∗ . Los
estados q1 y q2 no pueden ser de aceptación en el nuevo autómata:
5
q3
4
a a b
3 b
q1 λ q2 λ q5 b q6
2 a
1 b
q4
0
2 3 4 5 6 7 8 9 10 11 12 13 14


À Sea Σ = {a, b}. Diseñar AFN-λ (autómatas finitos no-deterministas con transicio-
nes λ) 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}. Diseñar AFN-λ (autómatas finitos no-deterministas con transicio-
nes λ) 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 sección se mostrará 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 proce-
dimiento algorı́tmico de conversión de un AFN-λ en un AFN que consiste en eliminar las
transiciones λ añadiendo transiciones que las simulen, sin alterar el lenguaje aceptado.
El procedimiento se basa en la noció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 más transiciones λ. Según esta definición, un
estado q siempre pertenece a su λ-clausura, es decir, q ∈ λ[q]. Además, si desde q no hay
transiciones λ, se tendrá λ[q] = {q}. La λ-clausura de un conjunto de estados {q1 , . . . , qk }
se define por:
λ[{q1 , . . . , qk }] := λ[q1 ] ∪ · · · ∪ λ[qk ].
También se define λ[∅] := ∅.
2.7.1 Teorema. Dado un AFN-λ M = (Σ, Q, q0 , F, ∆), se puede construir un AFN M 0

equivalente a M , es decir, tal que L(M ) = L(M 0 ).
Bosquejo de la demostración. Se construye M 0 = (Σ, Q, q0 , F 0 , ∆0 ) a partir de M man-

teniendo el conjunto de estados Q y el estado inicial q0 . M 0 tiene una nueva función de
transición ∆0 y un nuevo conjunto de estados de aceptación F 0 definidos por:
∆0 : Q × Σ −→ ℘(Q)
∆0 (q, a) := λ ∆(λ[q], a) .

(q, a) 7−→
F 0 = {q ∈ Q : λ[q] contiene al menos un estado de aceptación}.

Es decir, los estados de aceptación de M 0 incluyen los estados de aceptación de M y
aquellos estados desde los cuales se puede llegar a un estado de aceptación por medio de
una o más transiciones λ.
El significado de la fórmula ∆0 (q, a) = λ ∆(λ[q], a) se puede apreciar considerando el

grafo que aparece a continuación, que es una porción de un AFN-λ. Por simple inspección
observamos que, una vez procesada una a, el autómata puede pasar desde el estado q
a uno de los siguientes estados: {q9 , q10 , q11 , q12 , q3 , q4 , q5 , q6 , q8 }. Para obtener esta lista de
estados se tienen en cuenta todas las posibilidades, o sea las transiciones λ que preceden
o siguen el procesamiento del sı́mbolo a.
a
q9 q7 q8 q4
a λ λ
λ λ a
q q1 q2 q3
a
a
λ
q10 q11 q5
λ λ
q12 q6
Por la definición de λ-clausura se tiene que λ[q] = {q, q1 , q2 , q7 } y
∆0 (q, a) = λ ∆(λ[q], a) = λ[∆({q, q1 , q2 , q7 }, a)]

= λ[{q9 , q10 , q11 , q3 , q8 }] = λ[q9 ] ∪ λ[q10 ] ∪ λ[q11 ] ∪ λ[q3 ] ∪ λ[q8 ]

= {q9 , q10 , q11 , q12 , q3 , q4 , q5 , q6 , q8 }.
En conclusión, al aplicar la fórmula ∆0 (q, a) = λ ∆(λ[q], a) se llega a la lista de estados

obtenida arriba por simple inspección. De esta forma M 0 simula las transiciones λ de M
teniendo en cuenta todas las posibles trayectorias.

Ejemplo Utilizar la construcción del Teorema 2.7.1 para encontrar un AFN equivalente
al siguiente AFN-λ M .
q1
a b a b
q0 λ q2 λ q3
Las λ-clausuras de los estados vienen dadas por:

λ[q0 ] = {q0 , q2 , q3 }.
λ[q1 ] = {q1 }.
λ[q2 ] = {q2 , q3 }.
λ[q3 ] = {q3 }.
La función de transición ∆0 : Q × {a, b} → ℘({q0 , q1 , q2 , q3 }) es:
∆0 (q0 , a) = λ [∆(λ[q0 ], a)] = λ [∆({q0 , q2 , q3 }, a)] = λ[{q0 }] = {q0 , q2 , q3 }.
∆0 (q0 , b) = λ [∆(λ[q0 ], b)] = λ [∆({q0 , q2 , q3 }, b)] = λ[{q1 , q3 }] = {q1 , q3 }.
∆0 (q1 , a) = λ [∆(λ[q1 ], a)] = λ [∆({q1 }, a)] = λ[{q2 }] = {q2 , q3 }.
∆0 (q1 , b) = λ [∆(λ[q1 ], b)] = λ [∆({q1 }, b)] = λ[∅] = ∅.
∆0 (q2 , a) = λ [∆(λ[q2 ], a)] = λ [∆({q2 , q3 }, a)] = λ[∅] = ∅.
∆0 (q2 , b) = λ [∆(λ[q2 ], b)] = λ [∆({q2 , q3 }, b)] = λ[{q3 }] = {q3 }.
∆0 (q3 , a) = λ [∆(λ[q3 ], a)] = λ [∆({q3 }, a)] = λ[∅] = ∅.
∆0 (q3 , b) = λ [∆(λ[q3 ], b)] = λ [∆({q3 }, b)] = λ[{q3 }] = {q3 }.
El autómata M 0 ası́ obtenido es el siguiente:
3 q1
2
a b a b
b a
1
q0 a q2 b q3
0
−1
0 1 2 3
a,4 b 5 6 7 8
Puesto que q3 , que es el único estado de aceptación del autómata original M , pertenece
a λ[q0 ], a λ[q2 ] y a λ[q3 ], los tres estados q0 , q2 y q3 son estados de aceptación en el
autómata M 0 .


Utilizando el procedimiento presentado en esta sección, construir AFN equivalentes a los
siguientes AFN-λ:
b a
À
3
a
q0 λ q1 q2
2
1
b
0
−1 0 1 2 3 4 5 6 λ 7 8 9 10 11 12 13
6 Á λ
a
5
q0 λ q1 b q2
4
2
λ a
q3
1
0 b
−3 −2 −1 0 1 2 3 4 5 6 7 8 9 10
2.8. Complemento de un autó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
aceptación con los de no-aceptación, manteniendo los demá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 aceptació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 está definido por medio de una condición negativa puede ser más
fácil diseñar primero un AFD que acepte su complemento L.

Ejemplo Sea Σ = {0, 1}. Encontrar un AFD que acepte el lenguaje L de todas las
cadenas que no tienen dos ceros consecutivos.
Diseñamos primero un AFD M que acepte el lenguaje de todas las cadenas que tienen
dos ceros consecutivos. Esto lo conseguimos forzando la trayectoria de aceptación 00:
1 0, 1
M: 0
q0 q1 0 q2
Para aceptar a L formamos el complemento de M , intercambiando aceptación con no-

aceptación:
1 0, 1
M: 0
q0 q1 0 q2
En M , q2 es estado limbo y L(M ) = L.

La noción de complemento no es útil para AFN ya que si M es un AFN tal que L(M ) = L,
no necesariamente se tendrá que L(M ) = L, como se aprecia en el siguiente ejemplo.

Ejemplo Sea Σ = {a, b} y L el lenguaje de todas las cadenas que terminan en b. El
siguiente AFN acepta a L:
a, b
q0 b q1
Pero al intercambiar aceptación con no-aceptación se obtiene el AFN:
a, b
q0 b q1
cuyo lenguaje aceptado es (a ∪ b)∗ , diferente de L.


Utilizar la noción de complemento de un AFD para diseñar AFD que acepten los siguientes
lenguajes:
À 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 autómatas deterministas

Dados dos autómatas deterministas M1 = (Σ, Q1 , q1 , F1 , δ1 ) y M2 = (Σ, Q2 , q2 , F2 , δ2 ) se
puede formar un nuevo autómata determinista cuyos estados son todas las parejas de
la forma (qi , qj ), donde qi ∈ Q1 y qj ∈ Q2 . Este nuevo autó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 ) está conformado por los estados iniciales de los dos autóma-
tas, y la función de transición δ está dada por
δ : (Q1 × Q2 ) × Σ −→ Q1 × Q2
δ((qi , qj ), a) = (δ1 (qi , a), δ2 (qj , a)).
El conjunto F de estados de aceptación se puede escoger según la conveniencia de la

situació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 autómata M1 × M2 se escogen como estados de aceptación
los pares de estados (qi , qj ) en los que alguno de los dos es de aceptación.
(ii) Si F = {(qi , qj ) : qi ∈ Fi y qj ∈ F2 } entonces L(M1 × M2 ) = L1 ∩ L2 . Es decir, para

aceptar L1 ∩ L2 , en el autómata M1 × M2 se escogen como estados de aceptación
los pares de estados (qi , qj ) en los que ambos son estados de aceptación.
(iii) Si F = {(qi , qj ) : qi ∈ F1 ó qj ∈
/ F2 } entonces L(M1 × M2 ) = L1 − L2 . Es decir, para
aceptar L1 − L2 , en el autómata M1 × M2 se escogen como estados de aceptación
los pares de estados (qi , qj ) en los que el primero es de aceptación y el segundo no
lo es.
Demostración. . Las conclusiones del teorema se obtienen demostrando primero que la

definición de la funció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 , según la definición 2.5.2. La igual-

dad (2.9.1) se puede demostrar por recursión sobre u tal como se hace a continuación.
Para u = λ, el resultado es inmediato, y para u = a, la igualdad se reduce a la definición
de la función δ de M = M1 × M2 . Para el paso recursivo, suponemos como hipó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
δ((q
b i , qj ), ua) = δ(δ((q
b i , qj ), u), a) (definición de δ)
b
= δ((δb1 (qi , u), δb2 (qj , u)), a) (hipótesis recursiva)
= (δ1 (δb1 (qi , u), a), δ2 (δb2 (qj , u), a)) (definición de δ)
= (δb1 (qi , ua), δb2 (qj , ua)) (definición de δb1 y δb2 ).
Este razonamiento por recursión sobre cadenas concluye la demostració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 ∈ Σ∗ ,
u ∈ L(M ) ⇐⇒ δ((q
b 1 , q2 ), u) ∈ F ⇐⇒ (δb1 (q1 , u), δb2 (q2 , u)) ∈ F.
Por consiguiente, si F = {(qi , qj ) : qi ∈ F1 ó qj ∈ F2 }, entonces para toda cadena u ∈ Σ∗ ,

se tendrá
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
tendrá
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).

/ F2 }, entonces para toda cadena u ∈ Σ∗ , se
Finalmente, si F = {(qi , qj ) : qi ∈ F1 y qj ∈
tendrá
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 número par de
aes y un número par de bes.
Solución. En el ejercicio Á de la sección 2.3 se pidió diseñar, por ensayo y error, un
AFD para aceptar este lenguaje. Ahora podemos proceder sistemáticamente siguiendo el
mé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 número par de aes y L2 es el lenguaje de las
cadenas con un número de par de bes. Esto nos permite utilizar la parte (ii) del Teorema
a partir de autómatas que acepten a L1 y L2 , respectivamente.
AFD M1 que acepta L1 (cadenas con un número par de aes):
b b
a
q1 q3
AFD M2 que acepta L2 (cadenas con un número par de bes):

a a
b
q2 q4
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 único estado de aceptación es (q1 , q2 ) ya que es el único
par de estados en el cual ambos estados son de aceptación. Su función de transición δ se
obtiene utilizando la definició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 autómata ası́ obtenido es:

b
(q1 , q2 ) (q1 , q4 )
b
a a a a
b
(q3 , q2 ) (q3 , q4 )
b

todas las cadenas sobre el alfabeto Σ = {a, b} que tienen un número par de
bes pero que no contienen la subcadena bb.
Este problema se puede resolver de dos maneras ya que el lenguaje L se puede expresar ya
sea como una diferencia o como una intersección de lenguajes. Consideremos los lenguajes:
L1 = lenguaje de todas las cadenas que tienen un número de par bes.

L2 = lenguaje de todas las cadenas que contienen la subcadena bb.
L3 = lenguaje de todas las cadenas que no contienen la subcadena bb.
Entonces L = L1 − L2 y también L = L1 ∩ L3 .
Solución 1. Utilizamos la parte (iii) del Teorema 2.9.1 expresando L como L = L1 − L2 .
Para ello encontramos fácilmente un AFD M1 que acepta el lenguaje L1 :
a a
M1 : b
q1 q3
Y un AFD M2 que acepta L2 :
a a, b
M2 : b
q2 q4 b q5
Entonces L = L(M1 ) − L(M2 ) = L1 − L2 . El producto cartesiano M1 × M2 tiene 6 estados:

(q1 , q2 ), (q1 , q4 ), (q1 , q5 ), (q3 , q2 ), (q3 , q4 ) y (q3 , q5 ). Los estados de aceptación son (q1 , q2 ) y
(q1 , q4 ) ya que q1 es de aceptación en M1 mientras que q2 y q4 no son de aceptación en M2 .
Utilizando la definición de la función de transición δ de M1 × M2 se obtiene el siguiente
AFD:
(q1 , q2 )
a a b
b a
(q1 , q4 ) (q3 , q2 ) (q3 , q4 )
b b
b
(q3 , q5 ) (q1 , q5 )
Se observa que los estados (q3 , q5 ) y (q1 , q5 ) son “estados limbo” que no conducen a la
aceptación. El autómata simplificado se reduce al mostrado en el siguiente grafo.
a
(q1 , q2 )
a a b
b a
(q1 , q4 ) (q3 , q2 ) (q3 , q4 )
Solución 2. Utilizamos la parte (ii) del Teorema 2.9.1 expresando L como L = L1 ∩L3 . Para
obtener un AFD que acepte L3 basta formar el complemento del autómata M2 (mostrado
en la página 53). Obtenemos ası́ el siguiente AFD M3 :
a a, b
M3 : b
q2 q4 b q5
Al formar el producto cartesiano M1 × M3 obtenemos exactamente el mismo AFD con

seis estados que aparece en la página anterior. Los estados de aceptación son los pares
(q1 , q2 ) y (q1 , q4 ) formados por los estados de aceptación de M1 y M3 .

todas las cadenas sobre el alfabeto Σ = {a, b} que o bien tienen un número
par de bes, o bien no contienen la subcadena bb.
Solución. Se tiene que L = L1 ∪ L3 donde L1 y L3 son los lenguajes definidos en el ejemplo
anterior. El producto cartesiano M = M1 × M3 tiene los mismos seis estados mostrados
en la página 54, pero ahora los estados de aceptación son (q1 , q2 ), (q1 , q4 ), (q1 , q5 ) y (q3 , q5 ).
Ası́ que M requiere seis estados y no hay estado limbo, a pesar de que q5 es un estado
limbo en el autómata M3 .
Este ú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.


À 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.
(iii) El lenguaje L de todas las cadenas que tienen longitud impar y que no terminan
en 11.
Á 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
número impar de c’s.
(iii) El lenguaje L de todas las cadenas que tienen longitud impar y que tienen un
nú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 el
conjunto de estados de aceptación F para que el producto cartesiano M1 × M2 =
(Σ, Q1 × Q2 , (q1 , q2 ), F, δ) acepte la diferencia simétrica L1 / L2 . Recuérdese que la
diferencia simétrica se define como
L1 / L2 = (L1 ∪ L2 ) − (L1 ∩ L2 ) = (L1 − L2 ) ∪ (L2 − L1 ).

Teoría de La Computación (2017) CAPITULO 2 (2.1 A 2.9)

Uploaded by

Document Information

Original Title

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

Teoría de La Computación (2017) CAPITULO 2 (2.1 A 2.9)

Uploaded by

Copyright:

Available Formats

Notas de clase para el curso

Introducción a la Teorı́a de la Computación

2.1. Autómatas finitos deterministas (AFD)

2. Q = {q0 , q1 , . . . , qn }, el conjunto (finito) de los estados internos de la unidad de

4. F ⊆ Q, conjunto de estados finales o de aceptación. F debe ser distinto de ∅; es

5. La función δ de transición del autómata

La función de transición δ, también llamada dinámica del autómata, es la lista de ins-

··· s ··· ··· s ···

Vamos a ilustrar el procesamiento de tres cadenas de entrada.

Como q2 es un estado de aceptación, la cadena de entrada u es aceptada.

Puesto que q1 no es un estado de aceptación, la entrada v es rechazada.

Como q0 es un estado de aceptación, la cadena λ es aceptada.

L(M ) := {u ∈ Σ∗ : u es aceptada por M }

2.2. Grafo de un autómata

Los vértices o nodos son los estados del autómata.

El estado q se representa por: q

El estado inicial q0 se representa por: q0

Un estado de aceptación q se representa por: q

La transición δ(q, s) = q 0 se representa en la forma

se representa simplemente como

2.3. Diseño de autómatas

En la versión simplificada omitimos el estado limbo q1 : q0

trayectorias b y ab. De esta forma L(M ) = L:

Á Sea Σ = {a, b}.

L = lenguaje de las cadenas con un número par/impar de aes

Ayuda: utilizar el autómata de 4 estados diseñado en la parte (i), modificando

(i) El lenguaje de todas las cadenas que terminan en 01.

2.4. Autómatas finitos no-deterministas (AFN)

2. Q = {q0 , q1 , . . . , qn }, el conjunto (finito) de los estados internos de la unidad de

4. F ⊆ Q, conjunto de estados finales o de aceptación. F debe ser distinto de ∅; es

5. La función ∆ de transición del autómata

donde ℘(Q) es el conjunto de subconjunto de Q.

Un AFN M puede procesar una cadena de entrada u ∈ Σ∗ de varias maneras. Sobre el

L(M ) = {u ∈ Σ∗ : existe por lo menos un procesamiento completo

Para la cadena de entrada u = abb, existen procesamientos que conducen al rechazo,

(i) a(a ∪ ab)∗ .

(i) (01 ∪ 001)∗ .

2.5. Equivalencia computacional entre los AFD y los

La tabla original de la función de transición ∆ de M contiene la combinación {q0 , q2 } que

La tabla original de la función ∆ y su extensión.

Para la demostración del Teorema 2.5.1, conviene extender la definición de la función de

Según esta definición, para una cadena cualquiera u ∈ Σ∗ , δ(q,

Notación. La función extendida δ(q,

2.5.3 Definición. Sea M = (Σ, Q, q0 , F, ∆) un AFN. La función de transición ∆,

Se tendrı́a ∆(S, a) = ∅ en el caso en que ∆(q, a) = ∅ para todo q ∈ S.

Según esta definición, para una cadena cualquiera u ∈ Σ∗ , ∆(q,

Notación. La función extendida ∆(q,

Demostración del Teorema 2.5.1:

M 0 = (Σ, ℘(Q), {q0 }, F 0 , δ)

δ({q0 }, ua) = δ(δ({q0 }, u), a) (definición de la extensión de δ)

Finalmente podemos demostrar que L(M 0 ) = L(M ):

À Utilizando el procedimiento de conversión presentado en esta sección, encontrar

Á Sean Σ = {0, 1} y L3 el lenguaje de todas las cadenas de longitud ≥ 3 en las que el

Â Sea M = (Σ, Q, q0 , F, δ) un AFD. Demostrar por recursión sobre cadenas que la

Ã Sea M = (Σ, Q, q0 , F, ∆) un AFN. Demostrar por recursión sobre cadenas que la

2.6. Autómatas con transiciones λ (AFN-λ)

∆ permite, además de las instrucciones no-deterministas usuales, transiciones de la for-

∆(q, λ) = {qi1 , . . . , qik }

es el siguiente: estando en el estado q, el autómata puede cambiar aleatoriamente a uno

La entrada u = abab es aceptada siguiendo sobre el grafo de M la trayectoria abλab.

La entrada v = aaabb es aceptada siguiendo sobre el grafo de M la trayectoria λλaaabb.

(1) a∗ ∪ (ab ∪ ba)∗ ∪ b+ .

(ii) ab∗ ∪ ba∗ ∪ b(ab ∪ ba)∗ .