AUTOMATAS FINITOS

3. AUTOMATAS FINITOS
En este captulo estudiaremos un tipo de mquinas abstractas
de computacin en donde la entrada consiste de una cadena de un
determinado alfabeto, y la salida o resultado de la computacin
es la aceptacin o no de la cadena de entrada. El conjunto de
cadenas aceptadas por la mquina es el lenguaje reconocido por
la mquina. De esta forma, asociamos lenguajes y mquinas, los
dos tpicos principales de esta materia.


3.1 Autmatas Fintos Determinsticos (AFD)

Un AFD es un quintuple M = (Q, S, d, q
0
, F), donde Q es
una mquina de estados finta, S es el alfabeto, q
0
es el
estado inicial, F es el estado(s) final(es) y d es una funcin
de Q x S a Q llamada la funcin de transicin.

Ejemplo: El siguiente AFD acepta el conjunto de cadenas
que contienen la subcadena bb y donde S={a,b}. Esto
quiere decir que L(M) = (a|b)*bb(a|b)* .

M: Q = {q
0
, q
1
,

q
2
}
S = {a, b}
F = {q
2
}

(Continuacin)

M: Q = {q
0
, q
1
,

q
2
}
S = {a, b}
F = {q
2
}

La funcin de transicin d es dada en forma tabular y
llamada tabla de transicin.

d a b
q
0
q
0
q
1
q
1
q
0
q
2

q
2
q
2
q
2

Para las cadenas abba y abab tenemos las siguientes
operaciones (computaciones) en la tabla:

[q0, abba] [q0, abab]
-[q0, bba] -[q0, bab]
-[q1, ba] -[q1, ab]
-[q2, a] -[q0, b]
-[q2, l] -[q1, l]
acepta rechazado

La cadena abba es aceptada ya que la computacin se
para (halts) en estado q2.
Una cadena de entrada es aceptada si existe una
computacin que procesa toda la cadena de entrada y
para en un estado final o aceptador.

Diagramas de Estado
El diagrama de estado de un AFD es un grafo dirigido-etiquetado
en el cual los nodos representan los estados de la mquina y los
arcos son obtenidos de la funcin de transicin.
Otra definicin es la siguiente:

El diagrama de estado de un AFD M = (Q, S, d, q
0
, F) es un
grafo etiquetado G definido por las sig. condiciones:
i) Los nodos de G son los elementos de Q.
ii) Las etiquetas sobre los arcos de G son elementos de S.
iii) q
0
es el nodo inicial, representado con >
iv) F es el conjunto de nodos aceptadores; cada nodo acaptador
se representa con


v) Existe un arco desde nodo q
i
a q
j
etiquetado a si d(q
i
,a)=q
j
.
vi) Por cada nodo q
i
y smbolo a es miembro de S, existe
exactamente un arco etiquetado a que sale de q
i.

Ejemplo: El diagrama de estados para el DFA del
ejemplo anterior:


a
b
q
0
q
1
q
2
a,b
b
a
Ejemplo: El DFA siguiente acepta el lenguaje que no
contiene la subcadena aa y donde S={a,b}.

q
0
q
1
q
2
a,b
a
b
a
b
Ejercicios:
1. Sea M un AFD
M: Q = {q
0
, q
1
,

q
2
}
S = {a, b}
F = {q
2
}
d a b
q
0
q
0
q
1
q
1
q
2
q
1

q
2
q
2
q
0

a) Realizar el diagrama de estados de M.
b) Hacer las computaciones de M que procesan las cadenas
abaa
bbbabb
Bababa
c) Cul de las cadenas anteriores son aceptados por M?
d) Escribir la expresin regular para L(M)
Ejercicios:
2. Construye AFD en forma de diagrama de estados que
acepte el lenguaje descrito:
El conjunto de cadenas para alfabeto {a,b} en
donde la subcadena aa ocurra al menos dos veces.
El conjunto de cadenas para alfabeto {a,b,c} que
comienzan con a, contienen exactamente dos bs y
terminan con cc.
(ab)*ba
(ab)*(ba)*


3.2 Autmatas Fintos No determinsticos (AFN)
La diferencia es el no determinismo de esta clase de
autmatas. Esto se manifiesta en la funcin de transicin
que en los AFD significa moverse de un estado a otro bajo
un smbolo de entrada. En un AFN la funcin de transicin
tambin contempla lo anterior, pero adems contempla
otras dos transiciones: moverse de un estado a varios
estados bajo una sola entrada o smbolo; y moverse de un
estado a otro bajo no entrada o smbolo. Estas tres
transiciones se dan como:
a
q
n
q
i

a
a
a
q
n

q
i

q
j

q
n

La relacin entre AFD y AFN se sumariza con la siguiente
frase: Cada AFD es AFN. La funcin de transicin de un
AFD especifca exactamente que con una entrada solo se
puede ir a un estado. Mientras en un AFN con una entrada
se puede ir a cero, uno o mas estados. Esto quiere decir que
la familia de AFDs es un subconjunto de los AFN.

Una cadena de entrada para un AFN puede generar distintas
computaciones. En unos casos el automata para (halt) sin
aceptar la cadena, en otros la rechaza o las acepta.
Ejemplo: El AFN M para la cadena ababb con tres
diferentes computaciones.

M: Q = {q
0
, q
1
,

q
2
}
S = {a, b}
F = {q
2
}

d a b
q
0
q
0
{q
0,
q
1}
q
1
0

q
2
q
2
0 0
[q
0
,ababb]
-[q
0
,babb]
-[q
0
,abb]
-[q
0
,bb]
-[q
0
,b]
-[q
0
, l]
[q
0
,ababb]
-[q
0
,babb]
-[q
1
,abb]
[q
0
, ababb]
-[q
0
, babb]
-[q
0
, abb]
-[q
0
, bb]
-[q
1
, b]
-[q
2
, l]
La primera computacin procesa toda la entrada y para
en un estado de rechazar. La segunda computacin,
para (halt) despus de ejecutar tres instrucciones ya
que no existe accin cuando la mquina esta en estado
q
1
y leyendo una a. Por ltimo, la tercera computacin
acepta la entrada.
Una cadena de entrada es aceptada si existe una
computacin que procesa toda la cadena de entrada y
para en un estado final o aceptador. Una cadena de
entrada est en el lenguaje de un AFN si existe una
computacin que lo acepte. El lenguaje de un AFN M,
denotado L(M), es el conjunto de cadenas aceptadas
por M.

El diagrama de estados para el AFN del ejemplo anterior es
el siguiente:
q
0
q
1
q
2
a,b
b b
El diagrama aceptado por este ltimo AFN es (a | b)*bb
Es AFN porqu existen dos transiciones de q
0
a q
0
y de q
0
a
q
1
ante una misma entrada: b
El siguiente diagrama de estados para un AFN acepta el
lenguaje expresado por (ab)* | a*
a
q
0
q
1
q
2
b a
a
q3
a
Es AFN porqu existen dos transiciones de q
0
a q
1
y de q
0
a
q
3
ante una misma entrada: a
Transiciones Lambda
Las transiciones de estado a estado en AFD y AFN se llevan a
cabo al procesar o leer un smbolo de entrada. Podemos
tambin redefinir a un AFN de tal manera que admita
transiciones de estado a estado sin leer un smbolo de entrada.
Una transicin de esta forma es llamada transicin lambda.
A este tipo de mquinas se les llama AFN- l.
Por medio de movimientos lambda se puede construr
mquinas complejas a partir de mquinas mas simples.
La definicin de halting (cuando parar) se extiende para
incluir la posibilidad que una computacin puede continuar
usando transiciones lambda despus de que toda la cadena de
entrada ha sido leda. Tambin se pide, al igual que en los
anteriores autmatas, que termine en un estado final, esto para
finalizar el AFN-l con xito.
M
1
q
1,0
Q
1,1
Q
1,2
a,b
b b
a,b
Ejemplo: Sea M1 y M2 las siguientes mquinas que
aceptan los lenguajes descritos por (a | b)*bb (a | b)*
y (b | ab)* (a | l).

Q
2,0
Q
2,1
b
a
b
M
2

Podemos construr mquinas compuestas combinando los
doagramas de estado M
1
y M
2
.

a,b
q
1,0
Q
1,1
Q
1,2
b b
a,b
Q
2,0
Q
2,1
b
a
b
l
l
El lenguaje del AFN-l M es L(M
1
) U L(M
2
)
Una computacin en la mquina M comienza siguiendo un
arco lambda a un estado inicial de M
1
o M
2
.
Ejemplo: Un AFN-l M que acepta L(M
1
) L(M
2
), la
concatenacin de dos lenguajes se construye juntando las
dos mquinas con un arco lambda.

M
1
q
1,0
Q
1,1
Q
1,2
a,b
b b
a,b
Q
2,0
Q
2,1
b
a
b
M
2
l
Una cadena de entrada es aceptada solo si consiste de
una cadena de L(M
1
) seguido de una cadena de L(M
2
) .
3.3 Equivalencia de AFN y AFD
Tres clases de autmatas finitos se han estudiado. En esta
seccin demostraremos que los tres tipos de autmatas
aceptan el mismo tipo de lenguajes; mejor dicho, el lenguaje
aceptado por un AFN- l es aceptado por un equivalente
AFN y tambin por un equivalente AFD. Demostraremos
como a un AFN- l y aun AFN le podemos quitar su no
determinismo mediante la construccin de un AFD
equivalente.
q
2 Q
3
Q
4,
Q
5
a
a
l
l
l
q
1
Q
6
En la figura anterior las transiciones de el estado q
1
ante
entrada a son el conjunto {q
2
, q
3
, q
5
, q
6
}. Esto debido a
que podemos alcanzar o llegar a esos estados desde el
estado q
1
y solo leyendo a. Al estado q
4
llegamos
leyendo solo l.
La funcin de transicin t de un NFA- l es una funcin un
poco diferente a la funcin de transicin d de un AFD o un
AFN. En la funcin t, las transiciones ante l son vlidas
para moverse de un estado a otro y juntndola con una
entrada del alfabeto.

Ejemplo: Las tablas de transicin siguientes ejemplifican
las funciones de transicin d y t para el siguiente AFN- l
(diagrama de estado M). El lenguaje de M es a
+
c*b*.

d a b c l
q
0
{q
0,
q
1,
q
2
}

0

0 0
q
1
0

{q
1
}

0
q
2
0 0 {q
2
} {q
1
}
t a b c
q
0
{q
0,
q
1,
q
2
}

0

0
q
1
0

{q
1
}

0
q
2
0 {q
1
}


{

q
1,
q
2
}
a b
a
a
l
c
q
0
q
1
q
2
La funcin de transicin t es usada para construir un
autmata finito determinstico equivalente. El
procedimiento usa el diagrama de estados de el AFN- l
para construir el diagrama de estados de el equivalente
AFD.
Ejemplo: Construir un AFD equivalente para el siguiente
AFN- l.
a b
a
a
l
c
q
0
q
1
q
2
a b
a
a
l
c
q
0
q
1
q
2
t a b c
q
0
{q
0,
q
1,
q
2
}

0

0
q
1
0

{q
1
}

0
q
2
0 {q
1
}


{

q
1,
q
2
}
{q
1
}


0 {q
1
}


0
{

q
1,
q
2
}

0 {q
1
}


{

q
1,
q
2
}

{q
0,
q
1,
q
2
}


{q
0,
q
1,
q
2
}


{q
1
}


{

q
1,
q
2
}

Su correspondiente diagrama de
estados:
Se crean tres nuevos estados
a los cuales se les aplica el
mismo procedimiento para
obtener hacia que estados se
mover. Este procedimiento
termina hasta que no hay no
se genere un nuevo estado
t a b c
q
0
{q
0,
q
1,
q
2
}

0

0
q
1
0

{q
1
}

0
q
2
0
{q
1
}
{

q
1,
q
2
}
{q
1
}

0 {q
1
}


0
{

q
1,
q
2
}

0 {q
1
}


{

q
1,
q
2
}
{q
0,
q
1,
q
2
}

{q
0,
q
1,
q
2
}


{q
1
}


{

q
1,
q
2
}
{q
0
}

{q
0,
q
1,
q
2
}

{q
1,
q
2
}

{q
1
}

0
a
a
b
b,c
a,c
a,b,c
a
b
c
b
c
A partir del diagrama de estados se puede construir el AFD
equivalente.
El AFN M acepta el lenguaje a
+
b
+
. Procedemos a
convertirlo a un equivalente AFD.
a
q
2
q
1
q
0
a
b
M:
{q
0
}
{q
0,
q
1
}

a
{q
1,
q
2
}

b

a, b
b
b a
M:
a a
Las mquinas M
1
and M
2
aceptan a(ba)* and a*
respectivamente.
M
1
: q
1 q
2
a
b
M
2
: q
3
a
Usando arcos lambda para conectar un nuevo estado inicial a
los estados iniciales de las mquinas originales creamos un
NFA- l M que acepta a(ba)* | a*.
q
0
M:
q
1
q
2
a
b l
q
3
l
a
La funcin de transicin para M es
t a b
q
0
{q
2,
q
3
}

0

q
1
{q
2
} 0

q
2
0 {q
1
}


q
3
{q
3
}

0
El equivalente AFD obtenido es
{q
0,
q
1,
q
3
}
{q
2,
q
3
}

{q
3
}
{q
1
}
{q
2
}
a a
b
b

b
b
b
a
a,b
a
3.4 Propiedades de los Lenguajes aceptados por un
Autmata Finito.
Cada autmata finito con alfabeto S acepta un lenguaje
para S. Podemos probar que la familia de lenguajes
aceptados por un autmata finito consiste precisamente
de los conjuntos o lenguajes regulares para S.
Primero demostramos que cada conjunto o lenguaje
regular es aceptado por algn AFN- l. La demostracin
va de acuerdo a una definicin recursiva. Los lenguajes
o conjuntos regulares se construyen a partir de los
elementos bsicos 0 (conjunto o estado vaco), l (cadena
vaca) y conjuntos individuales que contienen elementos
del alfabeto.
Los diagramas de estado para las mquinas que aceptan
dichos conjuntos son:
q
0
q
0
q
0
q
1
q
1
q
1
a
l
Conjuntos regulares se construyen de los elementos bsicos
usando unin, concatenacin y operacin Kleene Star. Al
igual que los conjuntos regulares, autmatas fintos mas
complejos se pueden construir a partir de los diagramas
anteriores y que acepten la unin, concatenacin y
operacin Kleene Star de lenguajes regulares.
Ejemplo: El lenguaje L(M
1
) U L(M
2
) es aceptado por la
mquina siguiente:
SM
1
FM
1
SM
2
FM
2
l
l
S
M
1
M
2
l
l
F
La concatenacin de dos lenguajes L(M
1
) L(M
2
) regulares
puede ser aceptado por la mquina siguiente:
SM
1
M
1
FM
1
SM
2
M
2
FM
2
l
Una mquina que acepta L(M1)* es la siguiente:
S
SM
1
M
1
FM
1
F
l
l
l l
CONCLUSION
Usando los autmatas finitos anteriores podemos construir
una mquina para cualquier expresin regular que describa
a un lenguaje o conjunto regular. Por lo tanto, la
conclusin es de que la familia de lenguajes aceptados por
una mquina o autmata finito son del tipo regular.

Ejercicio: Construir un AFN- l que acepte el lenguaje
denotado por (a|b)*ba.
a b
b a l
l
l
l
l
a
b
(a|b)
ba
l
l
l
l
b
l
a
l
l
l
(a|b)*
l
l
l
l
b
l
a
l
l
l
b a l
l
(a|b)*ba
3.5 Autmatas Finitos y Expresiones Regulares.
Los lenguajes regulares son definidos por medio de expresiones
regulares y aceptados por medio de autmatas finitos. Podemos
establecer que un lenguaje es regular si
Es una expresin regular bajo un S.
Es aceptado por un AFD, AFN o AFN- l.
Es generado por una gramtica regular.

En cuanto a las expresiones regulares y autmatas, hemos ya
comprobado en la seccin anterior que podemos construir un
autmata finito para cualquier expresin regular dada. Por otra
parte existen mtodos para producir una expresin regular a
partir de un autmata finito.
3.6 Determinacin de lenguajes regulares y no regulares.
Dado el lenguaje {a
i
b
i
| i<=n} podemos construir un AFD
que acepte dicho lenguaje?
El siguiente AFD acepta dicho lenguaje pero est
incompleto.
a
a
a
a
b
b
b
b
b b
b
El AFD anterior est incompleto puesto que es imposible
construir un AFD para un lenguaje que no es regular. De
hecho dicho lenguaje es del tipo contexto libre, o es un
lenguaje no regular.
Se puede demostrar que un lenguaje es regular al construir
un autmata finito que lo acepte. Pero para demostrar que no
es regular necesitamos usar otras tcnicas (e.g. Pumping
lemma) que veremos en otro captulo.
4. AUTOMATAS DE PUSH-
DOWN
Los lenguajes regulares se caracterizan por ser lenguajes
generados por gramticas regulares y aceptados por
autmatas finitos. En este captulo estudiaremos un tipo
de mquina usada para aceptar lenguajes de contexto
libre. Esta mquina recibe el nombre de autmata de
push-down (APD).
4.1 Definicin.
Un Autmata de Push-Down (APD) es una mquina de estado
finto aumentada o extendida con una pila de memoria externa.
La adicin de la pila al autmata le proporciona a este un medio
de almacenamiento de memoria LIFO (last-in, first-out). Esta
combinacin de pila con estados le da la posibilidad a un APD
de aceptar lenguajes como {a
i
b
i
| i>=0}.
Un APD es un sextuple (Q, S, G, d, q
0
, F), donde Q es el
conjunto finito de estados, S es un conjunto finito de el alfabeto
de entrada, G es un conjunto finito llamado el alfabeto de la pila,
q
0
es el estado inicial, F (un subconjunto de Q) es el conjunto de
estados finales y es la funcin de transicin de Q x (S U {l}) x
(G U {l}) a subconjuntos Q x (G U {l}) .
Un APD consulta el estado actual, el smbolo de entrada y el el
smbolo en el tope de la pila para determinar la transicin en la
mquina. La funcin de transicin lista todas las posibles
transiciones dada una determinada combinacin de estado,
smbolo y tope de la pila. El valor de la funcin de transicin
d(q
i
,a,A) = {[q
j
,B], [q
k
,C]}
Indica que dos transiciones son posibles cuando el autmata esta
en estado q
i
y leyendo una a con A en el tope de la pila. Si
tomamos la primera opcin [qj,B],esto causar que la mquina
cambie de estado q
i
a estado q
j

procese el smbolo a (leer el siguiente smbolo)
Remover A del tope de la pila
Meter B dentro de la pila

Un APD tambin puede representarse por medio de un diagrama
de estados (nuestros ejemplos los utilizaran).
La transicin d(q
i
,a,A) = {[qj,B]} es representada por


a A/B
qi qj
El smbolo / representa reemplazo (reemplazar A en el
tope de la pila por B).
El dominio de la funcin de transicin permite transiciones
lambda en el smbolo de entrada y en el tope de la pila.

Ejemplo:

1. d(q
i
, l,A) = [q
i
, l]




2. d(q
i
, l, l) = [q
i
, A]




3. d(q
i
,a, l) = [q
j
, l]


l A/l
l l/A
q
i
q
i
q
i
q
j
a l/l
*Pop una A
*Push una A
*Lee una a
4.2 Lenguajes aceptados por un Autmata de Push-Down
La adicin o extensin al autmata finto al manejar una pila
(APD) le permite a este ser un aceptador no solo de lenguajes
regulares sino tambin de lenguajes de contexto libre. Esto
nos permite establecer que existe una correspondencia entre
un APD y una gramtica de contexto libre.
Lo anterior es demostrable y la forma de hacerlo es por medio
de ir construyendo un APD a partir de cada produccin de una
gramtica de contexto libre. Para cada regla existe una
transicin dentro del APD.
Por otra parte un APD podra implementarse con puras
transiciones de leer los smbolos de entrada pero sin
movimientos en la pila (l/l). Esto nos dara una mquina
similar a un autmata finito la cual obviamente va a aceptar
cualquier gramtica regular.
4.3 APD determinstico.
Un APD es determinstico si existe no mas de una
transicin que es aplicable por cada combinacin de
estado, smbolo de entrada y tope de la pila. A
continuacin construimos un APD M determinstico
para aceptar el lenguaje {a
i
b
i
| i>=0}.

M: Q = {q
0
,q
1
}
S = {a,b}
G = {A}
F = {q
0
,q
1
}
d(q
0
,a, l) = {[q
0
, A]}
d(q
0
,b, A) = {[q
1
, l]}
d(q
1
,b, A) = {[q
1
, l]}


q
0
q
1
b A/l
a l/A b A/l
Ejercicios:

Construir un APD que acepte el lenguaje {wcw
R
| w es un
miembro de {a,b}*}.

Construir un APD que acepte el lenguaje {a
i
c
j
b
i
| i,j>=0}.

Construir un APD que acepte el lenguaje {a
i
b
j
c
k
| i+k=j}.

4.4 APD y Gramticas de Contexto Libre
Podemos probar que cada lenguaje libre de contexto es
aceptado por un APD. Para llevar a cabo esto, las reglas de la
gramtica se usan para generar las transiciones de un APD
equivalente. Sea L un lenguaje libre de contextos y G una
gramtica para ese lenguaje en forma normal de Greibach. En
esta forma de Greibach todas las producciones de una
gramtica tienen una de las siguientes formas:
A aA
1
A
2
.A
n
A a
A l

La gramtica G en forma de Greibach que acepta {a
i
b
i
| i>=0}
es usada para ilustrar la construccin de un APD equivalente.
G: S aAB | aB
A aAB | aB
B b
El APD tiene dos estados: un estado inicial q
0
y un estado
aceptador o final q
1
. Una regla S de la forma S aA
1
A
2
A
n

genera una transicin que procesa el smbolo terminal a, mete
(push) las variables A
1
A
2
A
n
a la pila y se mueve al estado q
1
.
El resto de las operaciones usan el smbolo de entrada y el tope
de la pila para determinar la transicin apropiada. La funcin de
transicin de el APD es definido directamente de las reglas de
G. d(q
0
,a, l) = {[q
1
,AB], [q
1
,B]}
d(q
1
,a,A) = {[q
1
,AB], [q
1
,B]}
d(q
1
,a,B) = {[q
1
, l]}
Por otra parte es tambin posible construr una gramtica de
contexto libre a partir de un APD.


5. MAQUINAS DE TURING
La mquina de Turing nos proporciona muchas de las
caractersticas comnmente asociadas con una computadora
moderna. De hecho, la mquina de Turing fue el modelo
utilizado para disear y construir la primer computadora de
programa almacenado. Esta mquina utiliza una secuencia
de operaciones elementales para acceder y alterar una
posicin de memoria. A diferencia de una computadora, una
mquina de Turing no tiene un lmite de memoria o de
tiempo para realizar un clculo. Por ltimo, la mquina de
Turing representa lo mximo dentro de los dispositivos de
computacin abstractos.
5.1 Definicin de Mquina de Turing.
Una mquina de Turing es una mquina de estado finto en
donde en una transicin se escribe un smbolo en la cinta
(tape). La cabeza de la cinta puede moverse en cualquier
direccin, permitiendo que la mquina lea y manipule la
entrada tantas veces como se desee.
Mas formalmente, una mquina de Turing es un quintuple
M = (Q, S, G, d, q0) donde Q es un conjunto finito de
estados, G es un conjunto finito llamado el alfabeto de la
cinta y contiene un smbolo especial B que representa un
blanco, S es un subconjunto de S {B} llamado el alfabeto
de entrada, d es una funcin parcial de Q x G a Q x G x
{L,R} llamado la funcin de transicin y q
0
(miembro de Q)
es un estado distinguido llamado estado inicial.
5.2 funcionamiento de la mquina de Turing.
La cinta de una mquina de Turing se extiende
indefinidamente en una direccin. Las posiciones de la cinta
estn numeradas por los nmeros naturales siendo la
posicin mas a la izquierda la nmero cero.
q0
0 1 2 3 4 5 6
.
Una computacin comienza con la mquina en estado q
0
y
la cabeza de la cinta leyendo la posicin mas a la izquierda.
La entrada, una cadena de S
*
se escribe en la cinta
comenzando en posicin uno. Posicin cero y el resto de la
cinta es asumido que estn iniciadas con blancos.


El alfabeto de la cinta proporciona smbolos adicionales que
pueden ser usados durante la computacin.
Una transicin consiste de tres acciones: cambiar el estado,
escribir un smbolo en el cuadro ledo por la cabeza de la cinta
y mover la cabeza de la cinta. La direccin del movimiento de
la cabeza de la cinta puede ser a la izquierda (L) o a la
derecha (R). La configuracin de la mquina
q
1
.
x
y transicin d(q
i
,x) = [q
j
,y,L] se combinan para producir la
nueva configuracin
q
j
y
La transicin cambi el estado de q
i
a q
j
, reemplaz el
smbolo x con y y movi la cabeza de la cinta un cuadro a la
izquierda.
Una mquina de Turing halts (termina) cuando encuentra
un estado (par de smbolos) para los cuales no existe
definida una transicin. Esto es una terminacin normal.
Una transicin de la posicin cero en la cinta puede
especificar un movimiento a la izquierda de los lmites de la
cinta. Cuando esto ocurre, la computacin se dice termina
anormalmente.
Mquina de Turing Standard
Son diseadas para ejecutar computaciones en cadenas del
alfabeto de entrada. Una computacin comienza con la cabeza
de la cinta leyendo el cuadro mas a la izquierda y la cadena de
entrada posicin uno. Todos los cuadros a la derecha de la
cadena de entrada es asumido estn en blanco.

Ejemplo: La funcin de transicin de una mquina de Turing
standard con alfabeto de entrad {a,b} es mostrada a
continuacin. La transicin del estado q
0
mueve la cabeza de
la cinta a posicin uno para leer la entrada. Las transiciones en
estado q
1
leen la cadena de entrada e intercambian los
smbolos a y b. Las transiciones en q
2
retornan la mquina a
la posicin inicial.
d B a b
q
0
q
1
,B,R
q
1
q
2
,B,L q
1
,b,R q
1
,a,R
q
2
q
2
,a,L q
2
,b,L
Una mquina de Turing puede representarse grficamente por
un diagrama de estados.
Ejemplo (tabla anterior): Intercambia as y bs en la cadena de
entrada.
B/B R
B/B L
a/b R
b/a R
b/b L
a/a L
q
0
q
1
q
2
Ejemplo: La siguiente Mquina de Turing con alfabeto de
entrada {a,b} produce una copia de la cadena de entrada. Esto
quiere decir que una computacin que comienza con la cinta
teniendo la forma BuB termina con la cinta BuBuB.

B/B R
a/X R
B/B L
X/a L
Y/b L
a/a R
b/b R
b/Y R
a/a R
b/b R
B/B R
B/b L
a/a R
b/b R
B/B R
b/b R
a/a R
B/a L
X/X R
Y/Y R
a/a L
b/b L
B/B L
COPY: q
0
q
1
q
2
q
3
q
4
q
5
q
6
q
7
Ejercicios:
Construir una mquina de Turing para mover la entrada
un espacio a la derecha. La configuracin de entrada
q
0
BuB resulta en q
f
BBuB.
Construir una mquina de Turing para concatenar una
copia de la cadena de entrada en reversa. La
configuracin de entrada q
0
BuB resulta en q
f
Buu
R
B.
5.3 Lenguajes aceptados por la mquina de Turing
Una mquina de Turing puede ser usada para calcular
funciones y para aceptar lenguajes. En el primer caso el
resultado de una computacin se define in trminos del estado
en donde termina la computacin o la configuracin de la
cinta. En el segundo caso, una computacin acepta o rechaza
la cadena de entrada. A diferencia de un autmata finto o de
Push Down, la mquina de Turing no necesita leer toda la
cadena de entrada para aceptar la cadena. Una mquina de
Turing aumentada con estados finales es un sextuple (Q, S, G,
d, q0, F) donde F es un subconjunto de Q y contiene los
estados finales.
Un lenguaje aceptado por una mquina de Turing es llamado
lenguaje recursivamente enumerable. La hablidad de una
mquina de Turing para moverse en ambas direcciones y
procesar blancos introduce la posibilidad de no parar (halt)
ante ciertas entradas. Un lenguaje que es aceptado por una
mquina de Turing y que termina (halt) ante todas las cadenas
de entrada es llamado lenguaje recursivo. Existen muchas
mquinas de Turing que aceptan un lenguaje en particular;
algunas pueden parar (halt) para todas las entradas mientras
otras no. La existencia de una mquina de Turing que para
(halt) con todas las entradas es suficiente para demostrar que
el lenguaje es recursivo.
B/B R
a/a R
b/b R
q
0
q
1
q
2
Ejemplo: La mquina de Turing
acepta el lenguaje (a U b)*aa(a U b)*. La computacin para
la cadena aabb examina solo la mitad de la entrada antes de
aceptar la cadena completa. El lenguaje (a U b)*aa(a U b)*
es recursivo; las computaciones en la mquina terminan
(halt) para cada cadena de entrada. Una computacin exitosa
termina cuando una subcadena aa es encontrada.
b/b R
a/a R
q
3
5.4 Ejemplo de mayor fuerza de la Mquina de Turing

5.5 Extensiones de la Mquina de Turing
Existen variaciones al modelo de la mquina de Turing
standard. Cada variacin o extensin parece incrementar la
capacidad de la mquina, pero la realidad es que los lenguajes
aceptados por esas mquinas de Turing extendidas son tambin
aceptados por mquinas de Turing Standard.

Mquinas de Turing de Multipistas
En este tipo de mquinas la cinta es dividida en varias pistas.
Una posicin en la multipista-cinta contiene n smbolos del
alfabeto de la cinta.
q
j
PISTA 1
PISTA 2
Una posicin en la cinta en una mquina de 2 pistas es
representada por un par ordenado [x,y] donde x es el smbolo
en pista 1 y y en pista 2. Una transicin lee y escribe la
posicin completa de la cinta y se escribe como:

d(q
i
,[x,y]) = [q
j
,[z,w],d] donde d es {L,R}

La entrada es puesta en la pista 1. Todas las posiciones en la
pista 2 estn en blanco. Aceptacin en este tipo de mquinas
de Turing es por medio de estado final.
Este tipo de mquinas de Turing, al ser equivalentes a la
mquina de Turing standard, acepta lenguajes recursivamente
enumerables.
Mquinas de Turing de dos direcciones (two-way)
Este tipo de mquinas es identico a una mquina de Turing
standard excepto que la cinta se extiende indefinidamente en
ambas direcciones (izquierda y derecha). En este tipo de
mquinas la cadena de entrad puede ser puesta en cualquier
lugar de la cinta. Todas las dems posiciones de la cinta se
asume que estn en blanco.
q0
. .
Se puede colocar un smbolo especial (#) en una posicin para
que sea el lmite de la izquierda (como en una mquina
standard). Este tipo de mquinas es tambin equivalente al de
la mquina standard (aceptan Lenguajes Rec. Enumerables).
Mquinas de Mltiple Cintas
Consiste de k cintas y k cabezas de cintas independientes. Los
estados y alfabetos son los mismos que en la mquina
standard. La mquina lee las cintas simultneamente pero solo
tiene un estado.
CINTA 1

CINTA 2

CINTA 3
q
i
Una transicin es determinada por el estado y el smbolo
ledo por cada cabeza de cinta. Una transicin puede
cambiar el estado
escribir un smbolo en cada cinta
independientemente reposicionar cada cabeza de cinta.

El reposicionamiento consiste de mover la cabeza de la
cinta un cuadro a la izquierda o la derecha o incluso dejar la
cabeza en su posicin actual. La entrada a la mquina es
puesta en la cinta 1. Todas las dems cintas estarn en
blanco.
Al igual que en las mquinas anteriores este tipo de
mquinas acepta lenguajes Rec. Enumerables.
5.6 Mquinas de Turing No Determinsticas
Estas mquinas pueden especificar cualquier nmero finito de
transiciones para una configuracin dada. Los componentes de
una mquina no determinstica, con excepcin de la funcin de
transicin, son idnticos a los de una mquina de Turing
standard. Las transiciones en una mquina no determinstica
son definidas por una funcin de Q x G a los subconjuntos Q x
G x {L,R}.
Cundo una transicin indica que mas de una accin es
posible, una computacin arbitrariamente escoge una de las
transiciones. Una cadena de entrada es aceptada por una
mquina no determinstica si existe una computacin que
termina en un estado aceptador.
5.7 El problema de Halting para las Mquinas de Turing
Un problema de decisin consiste de un conjunto de preguntas
cuyas respuestas son si o no. Una solucin a un problema de
decisin es un procedimiento efectivo que determine la respuesta
para cada una de las preguntas. Una mquina de turing es un
sistema matemtico ideal para solucionar problemas de decisin.
La teora de Church-Turing dice que se puede disear siempre
una mquina de Turing para resolver cualquier problema de
decisin que tenga solucin por un procedimiento efectivo.
Entonces, para establecer que un problema no tiene solucin es
suficiente con mostrar que no existe solucin en una mquina de
Turing (Undecidability).
El mas famoso de los problemas sin solucin (undecidable
problem) es el problema de Halting.
El problema de Halting se formula de la forma siguiente:
Dada una mquina de Turing arbitraria M con alfabeto de
entrada S y una cadena w que pertenece a S
*
, Parara la
computacin de M con la entrada w ?
Es importante entender la declaracin del problema. Debemos
ser capaces de determinar si una mquina de Turing en
particular parar (halt) con una cadena determinada. Por
ejemplo la ltima mquina de Turing revisada para (halt) con
todas las cadenas conteniendo la subcadena aa. Sin embargo,
una solucin del problema halting requiere un algoritmo
general que responda la pregunta de halting que para cada
combinacin posible de mquina de Turing y cadena de
entrada la mquina va a parar.
Ejemplo: Tenemos una mquina de Turing H que resuelve el
problema de parada Halting.

H
R(M)w
acepta

rechaza
M hace parada con entrada w
M no hace parada con entrada w
La entrada consiste de la representacin de la mquina de
Turing M seguido de cadena w. La computacin de M con
entrada w hace parada.
La mquina H es modificada para construir H. Las
computaciones de H son las mismas que H excepto que H se
cicla indefinidamente cuando H termina en un estado aceptador.
Las transiciones de H son construidas agregandole a H que
causan que H se mueva indefinidamente a la derecha cuando H
entre a un estado aceptador.
H es combinado con una mquina de Turing que copia otra
mquina de Turing para formar una nueva mquina D.

R(M)
ciclo

para
M para con entrada R(M)
M no para con entrada R(M)
copy
R(M)R(M)
H
La entrada a la mquina D puede representarse por cualquier
mquina Turing. Considera una computacin de D con entrada
R(D). Entonces tendriamos lo siguiente:

R(D)
ciclo

para
D para con entrada R(D)
D no para con entrada R(D)
copy
R(D)R(D)
H
D
D
En esta ltima mquina D, vemos que D hace parada con
entrada R(D), si y solo si, D no hace parada con entrada
R(D). Esto es una contradiccin. Sin embargo, mquina D
puede construirse desde mquina H que resuelve el
problema de parada. La premisa que el problema de parada
tiene solucin nos lleva a la contradiccin. Podemos
concluir que el problema de parada no tiene solucin.
6. GRAMATICAS Y AUTOMATAS
Las gramticas fueron estudiadas en el captulo 2 donde se
introdujo la clasificacin de estas dada por Chomsky. En esta
clasificacin las gramticas eran divididas en 4 clases de
gramticas: regulares, de contexto libre, de contexto sensitivo
y de estructura de frase o sin restricciones. En esta unidad 6
regresamos a estudiar las tres primeras gramticas con un poco
mas de profundidad.
6.1 Lenguajes Regulares.
Teorema de Kleene.
Este teorema establece que un lenguaje L es aceptado por un
AFD con alfabeto S si y solo si, L es un conjunto regular
para S.

Para demostrar esto haremos uso de dos propiedades:
1. La primera ya explicada durante el tema 3.4, se refiere a
que cada conjunto regular es aceptado por algn AFN- l.
2. La segunda dice que cada lenguaje aceptado por un
autmata finito es un conjunto regular.

Y de acuerdo a lo establecido anteriormente sobre la
equivalencia de autmatas determinsticos y no
determinsticos conclumos con la validez del teorema de
Kleene.

Para demostrar la segunda afirmacin, extenderemos la
nocin de diagrama de estado.
Un grafo de expresin es un grafo dirigido con etiquetas
en donde los arcos estn etiquetados por expresiones
regulares y contiene un nodo inicial y nodos aceptadores o
finales.

El lenguaje de un grafo de expresin es la unin de los
conjuntos representados por las expresiones regulares
aceptadas. Los caminos (paths) en un grafo de expresin
generan expresiones regulares.
Ejemplo: Los sig. grafos aceptan las exp. reg. u* y u*vw*.
u
u
w
v
Para los grafos anteriores los cuales son muy sencillos es
simple determinar las expresiones regulares aceptadas. Existe
un procedimiento para reducir un grafo de expresin a una de
dos formas simples. Esta reduccin se lleva a cabo por medio
de repetir remover nodos de el grafo de tal manera que produce
la expresin aceptada por el grafo.
El diagrama de estados de un autmata finito puede tener
cualquier nmero de estados aceptadores. Cada uno de esos
estados exhibe la aceptacin de un conjunto de cadenas. El
lenguaje de la mquina es la unin de esos conjuntos. Para
determinar el lenguaje de un autmata, la observacin anterior
nos permite considerar los estados aceptadores separadamente.
El algoritmo para construir una expresin regular desde un
diagrama de estados hace exactamente eso; construye una
expresin para un conjunto de cadenas aceptadas por cada
estado aceptador individual.
Los nodos de un AFN- l en el algoritmo se asumen estn
numerados. La etiqueta de un arco de nodo i a nodo j se
denota como w
i,j
. Si no hay arco de nodo i a j, w
i,j
= 0.


Algoritmo: Construccin de una expresin regular desde un autmata finito.
Entrada: Diagrama de estados G de un autmata finito
Los nodos de G numerados 1,2,,n
1. Sea M el nmero de estados aceptadores de G. Hacer m copias de G, cada una de cual tiene un
estado aceptador. Nombra a cada una G
1
,G
2
,,G
m
. Cada estado aceptador de G es el estado
aceptador de algn G
t
, para t= 1,2,.,m.
2. Para cada G
t
Hacer
2.1 Repetir
2.1.1 Escoger un nodo i en G
t
que no sea ni el nodo incial ni un nodo
aceptador de G
t.

2.1.2 Borrar el nodo i en G
t
de acuerdo al siguiente procedimiento:
Para cada j,k no igual a i (esto incluye j = k) Hacer
i. Si w
j,i
<> 0, w
i,k
<>0 y w
i,i
= 0 Entonces
agregar un arco desde nodo j hasta nodo k etiquetado w
j,i
w
i,k

ii. Si w
j,i
<> 0, w
i,k
<>0 y w
i,i
<>0 Entonces
agregar un arco desde nodo j hasta nodo k etiquetado
w
j,i
(w
i,i
)*w
i,k
iii. Si nodos j y k tienen arcos etiquetados w
1
,w
2
,.,w
s
conectandose
Entonces reemplazarlos por un solo arco etiquetado w
1
Uw
2
U.W
s

iv. Remover el nodo i y todos los arcos que inciden en nodo i en G
t


Hasta que los nicos nodos en G
t
sean el nodo inicial y un nico estado aceptador
2.2 Determinar la expresin aceptada por G
t

Fin End
3. La expresin regular aceptada por G es obtenida juntando las expresiones para cada G
t
con U
(unin)



Ejemplo:
b
c
b
c
G:
b
c
b
c
b
c
b
c
G1:
G2:
De G se construyen dos grafos de expresin G1 y G2::
Se reduce G1 borrando nodos 2 y 3:
b
cc
b
b
La expresin aceptada por G1 es b*. Se remueve nodo 2 de G2
y se tiene:
b
cc
b
con expresin asociada b*ccb*.
La expresin aceptada por G, construida desde las
expresiones G1 y G2, es b*| b*ccb*.
Y con esto se prueba lo establecido en el teorema de
Kleene.

Las Aplicaciones del Lema de Pumping
El lema de Pumping es usado para demostrar o
establecer que un lenguaje no es regular y se basa en
ciertas reglas de descomposicin que se aplican a las
cadenas de los lenguajes regulares.
Bombear (Pumping) una cadena se refiere a construir
nuevas cadenas repitiendo (bombeando) subcadenas de la
cadena original.
Ejemplo:
M:
b a
a
a
b
a,b
b
q0
q1
q2
q3
Considere la cadena z=ababbaaab en L(M). Esta cadena
puede descomponerse en subcadenas u, v y w donde u=a,
v=bab, w=baaab y z=uvw. Las cadenas a(bab)
i
baaab son
obtenidas al bombear (pumping) la subcadena bab en
ababbaaab.
El lenguaje L(M) es regular pues producimos un autmata
finito para el. Si las cadenas producidas al bomberase la
cadena original tambin pertenecen a L(M), entonces L(M)
es regular, si no, entonces L(M) no es regular. El lema de
Pumping para lenguajes regulares tiene como objetivo
principal demostrar que un lenguaje no es regular.

Ejemplo: Para demostrar que L={a
i
b
i
| i>=0} no es regular
probaremos con una cadena z=a
k
b
k
y descomponiendo esta
en subcadenas u=a
i
,v=a
j
y w=a
k-i-j
b
k
, donde i+j<=k y j>0.
Si bombeamos cualquier cadena de esta forma produce
uvw=a
i
a
j
a
j
a
k-i-j
b
k
, que no pertenece a L. Por lo tanto, ya que z
pertenece a L y no tiene descomposicin que satisface las
condiciones del lema de pumping, concluimos que L no es
regular.
El Teorema Myhill-Nerode
As como el teorema de Kleene establece la relacin entre
lenguajes regulares y autmatas finitos, el teorema Myhill-
Nerode caracteriza la regularidad por medio de la existencia
de una relacin de equivalencia en las cadenas del lenguaje.
Esta caracterizacin proporciona un mtodo para obtener un
AFD mnimo que acepta un lenguaje.
Este teorema se utiliza, al igual que el lema de Pumping,
para demostrar que un lenguaje no es regular.


6.2 Lenguajes de Contexto Libre
Forma Normal de Chomsky.
Una gramtica de contexto libre est en forma normal de
Chomsky si cada regla tiene una de las siguientes formas:
A BC
A a
S l
Donde B,C son smbolos no terminales y no son smbolo
inicial.
El rbol de derivacin asociado con una derivacin en una
gramtica en forma normal de Chomsky es un arbol binario.

Autmata de Push-Down.
(tema cubierto en captulo IV)
Compilador de Lenguajes Formales
Un compilador es un programa que traduce otro programa
escrito en un lenguaje de alto nivel (java, C++, Ada, etc.)
produciendo como salida un programa objeto usualmente en
cdigo mquina. El compilador para realizar su tarea divide
todo el trabajo en varias fases, las cuales pueden ser:
Anlisis de lxico
Anlisis de sintaxis
Anlisis de semntica
Generacin de cdigo intermedio
Generacin de cdigo objeto
Optimizacin de cdigo

Las dos primeras fases utilizan lenguages formales como
especificacin de entrada a la fase.
Anlisis de lxico. En esta fase el compilador descompone
el programa fuente en tokens (identificadores, constantes,
operadores, etc.) los cules son especificados por medio de
expresiones regulares.
Ejemplo:
Identificador = letra (letra | digito)*
Nmero entero = digito digito*

Anlisis de sintxis. En esta fase el compilador revisa si los
estatutos, expresiones o declaraciones del programa fuente
cumplen con las especificaciones definidas por una
gramtica de contexto libre para el lenguaje siendo
compilado. Existen muchas tcnicas para implementar un
analizador de sintaxis, los cules son llamadas Parsers.
Ejemplos de Parsers son:
Recursivo descendente
LL(1)
Operador precedencia
LR
SLR
LALR

Tambin existen herramientas para producir por medio de
especificaciones analizadores de lxico y sintaxis. Algunas de
estas herramientas son:
Lex
Yacc
JavaCC
Sable