Máquinas de Turing

Aumentando el poder

Hasta aquí:

•Autómatas finitos (lenguajes regulares), el poder

de cómputo de los sistemas con memoria finita.

Bastante limitados: pueden describir

patrones “simples” en texto.

•Autómatas de pila (lenguajes de libre contexto),

memoria no acotada pero de acceso limitado.

Pueden describir lenguajes de programación, humanos...

Pero ciertamente un computador puede hacer más.
Como reconocer {w=anbncn}, o {w=uu}
 Aumentando el poder

n n n ?
a b c ww ?

lenguajes de libre contexto

n n R
a b ww
lenguajes regulares
a* a *b *
 Memoria más accesible

Ahora agregaremos la posibilidad de moverse con

libertad por la memoria (sin ir borrando lo que se lee,
como en el PDA).

•La memoria será una cinta potencialmente infinita,

en la que podemos escribir y leer símbolos.

•Movemos la cinta una posición a la izquierda o a la

derecha, para acceder a otras posiciones de
memoria.

•Alternativamente, podemos pensarlo como que

estamos moviendo un “cabezal” sobre la cinta.
 Memoria y unidad de control

Cinta
...... ......

Cabezal para leer y escribir

“Unidad de control”
Al igual que antes, la
máquina tiene una
cantidad finita de
estados, que
representamos con un
grafo de transiciones.
 Memoria y unidad de control

… …

•Este esquema de “unidad de control” interactuando

con una memoria de acceso “libre” suena familiar para
un informático, y no es casualidad.

Pero notemos que es una extensión de los modelos de

cómputo anteriores:
•En los AF, no había memoria externa.
•En los PDA, estaba restringida a una pila.
 Input en cinta; posición inicial

•Hasta ahora el input lo hemos estado leyendo de una

“cinta” aparte. Ahora no será necesario: podemos
asumir que viene escrito en la cinta.

input casillas en blanco

......   w0 w1 w2 ... wn   ......

posición inicial del cabezal

En cada paso, •Lee un símbolo de la cinta

la máquina •Escribe un símbolo en la cinta
•Mueve el cabezal a izquierda o derecha
• Actualiza su estado interno
 Representando transiciones

lo que el movimiento
lo que leo escribo del cabezal
(L:left, R:right)

q1 a  b, L q2

el cambio de estado
de la máquina
Nota: también se usa la
notación (a,b,L), en lugar
de ab,L.
 Representando transiciones

•Aparte del contenido de la cinta, lo único que

necesitamos para conocer el estado del sistema es la
ubicación del cabezal y el estado de la máquina.

•Por eso se suelen anotar juntos:

......   a b a c    ......

q1
 Representando transiciones

Si la descripción de la máquina incluye un transición

q1 a  b, R q2

lo que ocurrirá será

Tiempo k ......   a b a c    ......

q1

Tiempo k+1 ......   a b b c    ......

q2
 Representando transiciones

Otro ejemplo, aplicando

q1   g, L q2

......   a b a c    ......

q1

......   a b b c g   ......

q2
 Determinismo

Hasta que indiquemos lo contrario, las máquinas de

Turing serán deterministas:
•Para un mismo estado y símbolo en la cinta, sólo
hay una transición posible.
•Nada de transiciones .

a  b, R q2 a  b, R q2
q1 q1
b  d, L q3 a  d, L q3
 Función parcial

Pero a diferencia de los AFD, no exigiremos que

todos los casos estén cubiertos.

Por lo tanto, puede ser que para un cierto símbolo

leído, y cierto estado, no haya ninguna transición.

 Si eso ocurre, la máquina se detiene.

En particular, los estados de aceptación no tienen

transiciones de salida. Por lo tanto, son estados
finales: la máquina acepta y se detiene.
 Rechazo o aceptación

Cuando la máquina se ejecuta partiendo con una

palabra w en la cinta, decimos que la máquina

Acepta w:
•si se detiene en algún momento en un estado de
aceptación

Rechaza w:
Cuando no acepta. Esto puede ocurrir:
•si se detiene en algún momento en un estado
que no es de aceptación
•...o si nunca se detiene
 Un ejemplo

T=0  a a a  a  a, R
q0
  , L
 a a a  q0 q1
T=1

q0 Consideremos la máquina de
la arriba, y hagámosla
T=2  a a a  correr sobre el input aaa.

q0

 a a a  T=4  a a a 
T=3
Stop y
q0 q1 acepta
 Un ejemplo de rechazo

T=0  a b a 
a  a, R
q0
  , L
q0 q1 T=1  a b a 

q0
La misma máquina pero
con input aba, rechaza. Stop y
rechaza
 Otro tipo de rechazo

T=0  a b a 
b  b, L
a  a, R q0

T=1  a b a 
  , L
q0 q1
q0

Para ver un caso de T=2  a b a 

rechazo por loop
infinito, modificamos un q0
poco la máquina.
T=4  a b a 

q0 ...etc
 Formalmente

Una máquina de Turing queda definida por

M = ( Q, , , , q0, F, )

donde

•Q es un conjunto finito de estados

• es el alfabeto de la cinta
• es el alfabeto leído por la máquina
•\ es el carácter “blanco” de la cinta
(también se usa B, o )
•q0Q es el estado inicial
•F son los estados de aceptación
 Formalmente

Una máquina de Turing queda definida por

M = ( Q, , , , q0, F, )

donde

•: QQ{L,R} es la función de transición

Como dijimos antes, se permite que para algunos

pares (q,a) el valor de (q,a) no esté definido.

 Lo podemos interpretar como que en esos casos

(q,a) vale “stop” (y algunos libros lo tratan así).
 Descripción instantanea

El sistema se echa a andar con

•el input w* escrito en la cinta
•el resto de la cinta en blanco
•la máquina en estado q0
•el cabezal apuntando al comienzo de w

Por lo tanto, en cualquier momento T la máquina no

habrá visitado aún las casillas que estén a distancia
mayor que T respecto a la posición inicial.

 En todo instante el tramo de la cinta que no está

en blanco es finito.
 Descripción instantanea

Eso permite dar una descripción finita del estado del

sistema en un momento dado:
•Sea v el contenido de la cinta desde la posición del
cabezal hasta el último símbolo no blanco.
•Sea u el contenido de la cinta desde el primer símbolo
no blanco hasta la casilla anterior a la del cabezal.
•Sea q el estado interno de la máquina.

u v •Entonces anotamos la
descripción instantánea o
configuración como uqv.
  c a b a  
•Si hay que evitar alguna
q confusión, escribimos [u,q,v].
 Descripción instantanea

Como antes, escribimos

u q v  u’ p v’
si  lleva el sistema de uqv a u’pv’

•Usamos la misma “” para denotar su clausura

transitiva (aplicación reiterada de ).

Podemos entonces definir el lenguaje aceptado por M

como
L(M) = { w*: q0w  uqv, qF }
 Una convención práctica
área de trabajo
Llamémosle "área de trabajo"
a la zona de la cinta que no
  c ... a  
está en blanco.

•Es recomendable no usar el símbolo  dentro del área de

trabajo; así siempre podemos usarlo para identificar los
bordes. Seguiremos ese consejo.

•El área de trabajo puede crecer y crecer, pero en cualquier

momento dado será finita (pues partió siendo finita).

•La descripción instantanea uqv da el contenido del área de

trabajo (uv), el estado interno de la máquina (q) y su ubicación
(entre u y v, apuntando al comienzo de u).
 Volvamos al ejemplo: una observación

•Claramente, el lenguaje a  a, R
aceptado por el ejemplo que
vimos es a*
  , L
q0 q1
•Ese es un lenguaje regular.

•Nótese además que esta MT no escribe.

No es casualidad: no es dificil ver que cualquier

lenguaje regular puede ser aceptado por una MT
que no altera su cinta.
 MT para lenguajes regulares

Idea:
•La MT simplemente lee la palabra como lo haría el AFD,
avanzando siempre hacia la derecha.
•Sus estados corresponden a los del AFD.
•Se agrega un estado extra para la aceptación (pues los del
AFD no eran de detención; pierden su condición de estado
de aceptación al pasar a la MT), y para llegar a él se
chequea el fin del input..

Detalles: ejercicio.

De hecho es un ssi:
•Si a la MT le prohibimos escribir, sólo puede aceptar
lenguajes regulares.
 Otro ejemplo

Veamos un MT para el lenguaje {anbn}

q4 y  y, R y  y, L
y  y, R a  a, R a  a, L
  , L
y  y, R a  x, R b  y, L
q3 q0 q1 q2
x  x, R
 T= 0  a a b b  

q0

q4 y  y, R y  y, L
y  y, R a  a, R a  a, L
  , L
y  y, R a  x, R b  y, L
q3 q0 q1 q2
x  x, R
 T= 1  x a b b  

q1

q4 y  y, R y  y, L
y  y, R a  a, R a  a, L
  , L
y  y, R a  x, R b  y, L
q3 q0 q1 q2
x  x, R
 T= 2  x a b b  

q1

q4 y  y, R y  y, L
y  y, R a  a, R a  a, L
  , L
y  y, R a  x, R b  y, L
q3 q0 q1 q2
x  x, R
 T= 3  x a y b  

q2

q4 y  y, R y  y, L
y  y, R a  a, R a  a, L
  , L
y  y, R a  x, R b  y, L
q3 q0 q1 q2
x  x, R
 T= 4  x a y b  

q2

q4 y  y, R y  y, L
y  y, R a  a, R a  a, L
  , L
y  y, R a  x, R b  y, L
q3 q0 q1 q2
x  x, R
 T= 5  x a y b  

q0

q4 y  y, R y  y, L
y  y, R a  a, R a  a, L
  , L
y  y, R a  x, R b  y, L
q3 q0 q1 q2
x  x, R
 T= 6  x x y b  

q1

q4 y  y, R y  y, L
y  y, R a  a, R a  a, L
  , L
y  y, R a  x, R b  y, L
q3 q0 q1 q2
x  x, R
 T= 7  x x y b  

q1

q4 y  y, R y  y, L
y  y, R a  a, R a  a, L
  , L
y  y, R a  x, R b  y, L
q3 q0 q1 q2
x  x, R
 T= 8  x x y y  

q2

q4 y  y, R y  y, L
y  y, R a  a, R a  a, L
  , L
y  y, R a  x, R b  y, L
q3 q0 q1 q2
x  x, R
 T= 9  x x y y  

q2

q4 y  y, R y  y, L
y  y, R a  a, R a  a, L
  , L
y  y, R a  x, R b  y, L
q3 q0 q1 q2
x  x, R
 T= 10  x x y y  

q0

q4 y  y, R y  y, L
y  y, R a  a, R a  a, L
  , L
y  y, R a  x, R b  y, L
q3 q0 q1 q2
x  x, R
 T= 11  x x y y  

q3

q4 y  y, R y  y, L
y  y, R a  a, R a  a, L
  , L
y  y, R a  x, R b  y, L
q3 q0 q1 q2
x  x, R
 T= 12  x x y y  

q3

q4 y  y, R y  y, L
y  y, R a  a, R a  a, L
  , L
y  y, R a  x, R b  y, L
q3 q0 q1 q2
x  x, R
 T= 13  x x y y  

q4

Para & acepta

q4 y  y, R y  y, L
y  y, R a  a, R a  a, L
  , L
y  y, R a  x, R b  y, L
q3 q0 q1 q2
x  x, R
 El segundo ejemplo

Podemos resumir el funcionamiento de esa máquina

de Turing mediante pseudocódigo:

While veo a
•ax
•Avanzar (R) saltando {a,y}, hasta ver b
•by
•Avanzar (L) saltando {a,y}, hasta ver x
•Avanzar (R)
Avanzar (R) saltando {y} hasta ver 
Aceptar

La gracia: nada nos impide extender la idea

para reconocer {anbncn}.
 {anbncn}, pseudocódigo

While veo a
•ax
•Avanzar (R) saltando {a,y}, hasta ver b
•by
•Avanzar (R) saltando {b,z}, hasta ver c
•cz
•Avanzar (L) saltando {a,y,b,z}, hasta ver x
•Avanzar (R)
Avanzar (R) saltando {y,z} hasta ver 
Aceptar

Ejercicio:
•Hacer la MT
•Proponer alternativa que use sólo {a,b,c,x,}
como alfabeto en la cinta.
 LR:decidido; LRE:aceptado

Decimos que una máquina de Turing M decide un

lenguaje L si M acepta L, y además M siempre se
detiene.

•Los lenguajes que son decididos por alguna MT

se llaman lenguajes recursivos (LR).

•Los lenguajes que son aceptados por alguna MT

se llaman lenguajes recursivos enumerables
(LRE).

Nótese que, por definición, LR  LRE.

 Funciones Turing-computables

Otra forma de “usar” una MT es mirando lo que deja

en la cinta cuando se detiene.

•Como la MT es determinista, el estado final de la

cinta está determinado completamente por el
estado inicial: es una función del estado inicial.

Dada una MT M y un input w*, hay dos casos:

•Si M se detiene con configuración upv,
definimos fM(w)=uv.
•Si M nunca se detiene, definimos fM(w)=
(decimos que para w, fM diverge).
 Funciones Turing-computables

Config. inicial Config. final

 w   f M (w) 

q0 q
Loop ()

Entonces, toda MT M induce una función

fM:**{}

Decimos que una función f es Turing-computable si

existe una MT que la induce.
 Funciones Turing-computables

Observaciones:

•Sin perder generalidad, podemos suponer que el

dominio de f está restringido a un dominio D  *.

•Algunos autores exigen que al terminar el

cómputo el cabezal esté en el inicio de f(w).
No es difícil modificar la MT para cumplir
con eso, si hace falta.

•Para efectos prácticos, los argumentos de fM se

suelen codificar en * (i.e., en general no los
escribimos tal cual como los leeríamos nosotros).
 Ejemplo: x+y

•Para simplificar, codificaremos números enteros en

sistema unario.

5 101 11111
decimal binario unario

Demostremos que la suma de números naturales es

una función computable.

f ( x, y )  x  y
Input: x0y
Aprovecharemos que x concatenado
Output: xy0 con y da x+y, en unario
 Ejemplo: x+y

1  1, R 1  1, R 1  1, L

q0 0  1, R q1   , L q 1  0, L q3
2

  , R
q4
 T= 0  1 1 0 1 1 

q0

1  1, R 1  1, R 1  1, L

q0 0  1, R q1   , L q 1  0, L q3
2

  , R
q4
 T= 1  1 1 0 1 1 

q0

1  1, R 1  1, R 1  1, L

q0 0  1, R q1   , L q 1  0, L q3
2

  , R
q4
 T= 2  1 1 0 1 1 

q0

1  1, R 1  1, R 1  1, L

q0 0  1, R q1   , L q 1  0, L q3
2

  , R
q4
 T= 3  1 1 1 1 1 

q1

1  1, R 1  1, R 1  1, L

q0 0  1, R q1   , L q 1  0, L q3
2

  , R
q4
 T= 4  1 1 1 1 1 

q1

1  1, R 1  1, R 1  1, L

q0 0  1, R q1   , L q 1  0, L q3
2

  , R
q4
 T= 5  1 1 1 1 1 

q1

1  1, R 1  1, R 1  1, L

q0 0  1, R q1   , L q 1  0, L q3
2

  , R
q4
 T= 6  1 1 1 1 1 

q2

1  1, R 1  1, R 1  1, L

q0 0  1, R q1   , L q 1  0, L q3
2

  , R
q4
 T= 7  1 1 1 1 0 

q3

1  1, R 1  1, R 1  1, L

q0 0  1, R q1   , L q 1  0, L q3
2

  , R
q4
 T= 8  1 1 1 1 0 

q3

1  1, R 1  1, R 1  1, L

q0 0  1, R q1   , L q 1  0, L q3
2

  , R
q4
 T= 9  1 1 1 1 0 

q3

1  1, R 1  1, R 1  1, L

q0 0  1, R q1   , L q 1  0, L q3
2

  , R
q4
 T= 10  1 1 1 1 0 

q3

1  1, R 1  1, R 1  1, L

q0 0  1, R q1   , L q 1  0, L q3
2

  , R
q4
 T= 11  1 1 1 1 0 

q3

1  1, R 1  1, R 1  1, L

q0 0  1, R q1   , L q 1  0, L q3
2

  , R
q4
 T= 12  1 1 1 1 0 

q4

1  1, R 1  1, R 1  1, L

q0 0  1, R q1   , L q 1  0, L q3
2

Parar y
  , R
aceptar q4
 Otro ejemplo: 2x

Esta MT calcula 2x, para x en unario:

1 $, R 1 1, L 1  1, R

q0   , L q1 $  1, R q2
  , R
  1, L
q3
 Otro ejemplo: 2x

Describamos su
funcionamiento en 1  $, R 1  1, L 1  1, R
pseudocódigo informal:

q0   , L q1 $  1, R q2
  , R   1, L
•Reemplazar cada 1 por un $.
q3
•REPETIR
•Encontrar el $ de más a la derecha,
cambiarlo a 1.
•Ir al extremo derecho, insertar un 1.
HASTA que no queden $

¿Cómo calcularíamos xy? ¿Y n!?

 Más cómputos

Si quisiéramos calcular 1 x y
f ( x, y ) 
0 x y
el “pseudocódigo” sería:

•Para cada 1 en x, ir borrándolo y borrando un 1 del y.

•Si en algún momento busco un 1 en y, y no encuentro,
entonces borrar todo y escribir un 1.
•Si eso nunca ocurre, y es x el que se acaba, borrar
todo y escribir un 0.

Ejercicio: construir la MT.

 Combinación de máquinas

•Programar MT es engorroso, pero esencialmente

fácil.

•El paradigma resulta sorprendentemente flexible.

•También es notablemente robusto: es posible

agregar muchas “features” (por ejemplo, una segunda
cinta) a una MT sin que su poder de cómputo cambie.

•Veremos varios de esos “features”; con ellos en

mano, es más fácil construir MT más ambiciosas.
 Combinación de máquinas

input MT output

•En particular, será posible ver cada MT como una

“caja negra”, que se puede usar como subrutina en
otra MT.

x, y
MT sumadora x y
x, y x y
MT comparadora

x y MT borradora 0
 Variaciones c/r a las MT estándar

Nuestro modelo estándar:

1 cinta, infinita en ambas direcciones

 aababbcac a
cabezal que (movimiento es a
escribe y lee izquierda o derecha)

transiciones entre los

estados internos de la
MT son determinísticas
 Variaciones c/r a las MT estándar

Algunas variantes:

•Cinta semi-infinita.
•Varias cintas.
•“Cinta” bidimensional.
•Opción de no mover el cabezal.
•Opción de insertar símbolos.
•Transiciones no deterministas.
•MT “offline” (el input queda sin tocar, en su
propia cinta).
•Largo Etc.
 Variaciones c/r a las MT estándar

Ninguna de estas variantes altera el poder de

cómputo de las MT.

¿Qué significa eso?

Que los lenguajes que se pueden aceptar o

decidir son los mismos.

En cada caso se demuestra que si MT

estándar M, entonces MT M’ del tipo
modificado que es equivalente, y viceversa.
 Variaciones c/r a las MT estándar

¿Qué significa que las máquinas sean equivalentes?

•Si estamos viendo la MT como un reconocedor

de lenguajes, significa dos cosas:

que L(M)=L(M’)
que M se detiene con input w ssi M’ se
detiene con input w.

•Si en cambio vemos la MT como el cómputo de

una función, significa que fM=fM’
(Pues en la opción fM(w)= ya está incluida la
información sobre la detención)
 MT con opción “Stay”

Una MT+stay (máquina de Turing con opción “stay”)

es similar a la MT estándar, pero además de poder
mover el cabezal a izquierda o derecha (“L” o “R”),
tiene la opción de dejarlo donde está (“S”).

Por ejemplo, una transición podría ser

q1 a  b, S q2
y al aplicarla ocurrirán cosas del tipo

  a a b a b b c ...   b a b a b b c ...
q1 q2
 MT con opción “Stay”

Teorema: las MT+stay tienen el mismo poder de

cómputo que las MT estándar.

Demostración: demostraremos que

1. Las MT+stay tienen al menos el poder de

cómputo de las MT estándar.

2. Las MT estándar tienen al menos el poder de

cómputo de las MT+stay.
 MT con opción “Stay”

1. Las MT+stay tienen al menos el poder de

cómputo de las MT estándar.

Demostración: directo, pues la MT estándar es un

caso particular de MT+stay.

2. Las MT estándar tienen al menos el poder de

cómputo de las MT+stay.

Para eso, veremos cómo convertir una MT+stay en

una MT estándar, sin alterar su funcionamiento.
 MT con opción “Stay”

Para cada transición que use el “S” (stay),

agregamos un estado auxiliar, y reemplazamos la
transición por 1+|| transiciones:

a  b, S
q1 q2

a  b, L x  x, R
q1 qaux q2

Una de esas por cada x  

QED
 MT con opción “Stay”

q1 a  b, S q2 q1
a  b, L
qaux
x  x, R
q2

T=1 T=2
aaba  baba  en M, la
MT+stay
q1 q2

T=1 T=2 T=3 en M’,

aaba  baba  baba  la MT
estándar
q1 qaux q2
Ejercicio: MT con movimiento en dos pasos

A sugerencia del público, ejercicio:

Diremos que una MT es de "dos pasos" si sus opciones

de movimiento son {L, L2, R, R2}, donde L y R se
entienden como antes, L2 mueve el cabezal dos
posiciones hacia la izquierda, y R2 lo mueve posiciones
a la derecha.

EJ: Demostrar que las MT de "dos pasos" tienen el

mismo poder de cómputo de las MT estándar.

De hecho, dado kN, una MT con movimientos {L,

L2,..., Lk, R, R2,...,Rk} también sigue siendo equivalente.
 MT con varias “pistas”

Una MT “multitrack” (varias pistas) tiene una única

cinta de memoria, pero esa cinta tiene más de una
pista de información:

  a b a b  pista 1
  b a c d  pista 2

Habrá transiciones de la forma

b, a  c, d ; L
q1 q2
 MT con varias “pistas”

Claramente las MT multitrack son una generalización

de las MT estándar (basta con ignorar las pistas
adicionales para volver al caso estándar).

  a b a b  pista 1
  b a c d  pista 2

•Por otro lado, para simular una MT multitrack con

alfabeto  y k pistas, usando una MT estándar,
basta que tomemos ’ = k.
•Cada casilla de la cinta nueva contendrá lo que
había en las k pistas, en esa posición.
 MT con varias “pistas”

M, multitrack M’, estándar

b, a  c, d ; L (b, a)  (c, d ), L
q1 q2 q1 q2

  a b a b  T=0 (, ) (, ) (a, b) (b, a )(a, c)(b, d ) (, )

  b a c d 
q1 q1

  a c a b  T=1 (, ) (, ) (a, b) (c, d )(a, c)(b, d ) (, )

  b d c d 
q2 q2
 MT con memoria "interna" finita

Una MT con memoria interna posee una o más variables

cuyo valor se guarda dentro del estado interno (no en la
cinta); cada variable debe tener un rango finito.

Por ejemplo: una MT podría tener las variables

• m1  D1 = {0, 1}
• m2  D2 = {blanco, azul, rojo}
• m3  D3 = {,}

Los valores se pueden consultar y modificar en las

transiciones (si no se modifican, quedan como estaban).
m2  blanco , a  b; L; m1  1  m1
q1 q2
 MT con memoria "interna" finita

Sin perder generalidad, podemos verlo como que fuese

una sola variable:

m = (m1,m2,m3)  D = D1D2D3

Claramente, es una extensión c/r a las MT estándar.

Pero: no cambia el poder de cómputo. Para simular una
MT con memoria interna mediante una MT estándar, la
idea es:

Reemplazar Q por Q' = QD.

 MT con memoria "interna" finita

Q' = Q  D
estado estado "de variables
interno control" internas

La condición sobre valores de variables se convierte

simplemente en condición sobre el estado interno, y la
modificación de valores, en elegir a qué estado paso.

•Es importante que el rango (valores posibles) de las

variables internas sea finito; de lo contrario, Q' quedaría
infinito.

•Nótese que esta extensión también funciona para AFD y

para PDA.
 MT con cinta semi-infinita

Una MT con cinta semi-infinita tiene una cinta que

es infinita en una sola dirección: en lugar de

... aababbcac a ...

se tiene

# a b a c   .........

•Aquí el # marca el fin de la cinta (como el "$" que

marcaba el fondo de la pila en los PDA).

•Algunos textos (p.ej. el Hopcroft) usan este tipo de MT

como "estándar".
 MT con cinta semi-infinita

# a b a c   .........

A diferencia de las modificaciones previas, esta no

es una "generalización", sino una "restricción"
respecto a nuestras MT estándar.

Las restricciones pueden restringir el poder de

cómputo (por ejemplo, si la MT no puede escribir, su
poder se reduce al de los AFD).

Sin embargo, esta restricción particular no cambia

el poder de cómputo:
 MT con cinta semi-infinita

Es directo ver que toda MT con cinta semi-infinita

puede ser simulada por una MT estándar:
simplemente no usamos la cinta a la izquierda.

En dirección contraria: necesitamos probar que

dada una MT estándar, la podemos simular en una
con cinta semi-infinita.
 MT con cinta semi-infinita

Fijamos un punto de referencia en nuestra cinta

infinita (puede ser la posición de inicio del cabezal).

......... .........
 a b c d e  

"Doblamos" la cinta infinita en torno a ese punto,

dejando una cinta semi-infinita de dos pistas:

lado derecho # d e    .........

lado izquierdo # c b a  
 MT con cinta semi-infinita

lado derecho # d e    .........

lado izquierdo # c b a  

•Los movimientos L, R se invierten si estamos "abajo".

•Al pasar por el punto de referencia, "viramos".

•Aplicamos el método previo para pasar a una única cinta.

•Para saber si hay que mirar arriba o abajo, guardamos

una variable en memoria interna ("arriba", "abajo").
 MT con marcas en la cinta

Podemos agregar a la MT la posibilidad de poner y

quitar marcas en la cinta (aparte del símbolo contenido
en la celda).
......... .........
 a b c d e  
Y luego podemos usar la marca para reconocer la celda.

La condición es que la variedad de marcas sea finita:

por ejemplo, M={,,} (donde  es "sin marca").

¿Cómo hacemos esto con una MT estándar?

 Reemplazamos  por ' =   M
 MT con Insert/Delete

Una MT con insert puede hacer transiciones del tipo

q1 a  dup , L q2

.........   a b a c    .......

q1

.........   a b a a c    .......

q1
(Duplica la celda, y se sitúa a la izquierda).
 MT con Insert/Delete

Una MT con delete puede hacer transiciones del tipo

q1 a  del, L q2

.........   a b a c    .......

q1

.........   a b c    .......

q1
(Borra la celda, y se sitúa a la izquierda).
 MT con Insert/Delete

Ambas operaciones se pueden implementar en una MT

estándar:

Para duplicar:
•Marcamos la celda
•Avanzamos hasta el final del área de trabajo
•Retrocedemos copiando cada celda en la siguiente
•...hasta llegar a la celda marcada.

Para borrar:
•Marco la celda y copia en ella el valor de la celda vecina.
•Sigo copiando hasta llegar al final del área de trabajo
•Me devuelvo hasta la celda marcada.
 MT con varias cintas

Unidad de
control

Cinta 1 Cinta 2
 a b c   e f g 

•A diferencia de la máquina "con varias pistas" que

vimos antes, en la MT "multicinta" cada cinta tiene su
propio cabezal.

•Las transiciones miran ambas cintas, y deciden

escritura y movimiento en ambas cintas.
 MT con varias cintas
Cinta 1 Cinta 2

T=1  a b c   e f g 
q1 q1

T=2  a g c   e d g 
q2 q2

(b, f )  ( g , d ), L, R
q1 q2
 MT con varias cintas

¿Cómo podemos simular una MT multicinta, usando una

MT estándar?

Lo que haremos será simularla usando una MT con una

cinta, pero varias pistas (y esa ya sabemos que es
equivalente a la estándar).

Idea:

Por cada cinta de la MT multicinta, ponemos dos pistas:

•Una con los datos
•Otra que indica dónde está el cabezal.
 MT con varias cintas

Cinta 1 Cinta 2

 a b c   e f g h 

a b c Cinta 1

0 1 0 "Cabezal" de la cinta 1
e f g h Cinta 2
0 0 1 0 "Cabezal" de la cinta 2
 Cabezal de la
MT multipista
 MT con varias cintas
a b c
Para simular un paso de la MT 0 1 0
multicinta, la MT multipista e f g h
hace lo siguiente:
0 0 1 0
•Sitúa su cabezal a la izquierda de todos los "cabezales".

•Avanza hacia la derecha hasta ver todos los "cabezales", y

guardando en variables internas el símbolo apuntado por cada
uno de ellos.

•Aplica la regla de la MT multicinta, y guarda en variables

internas los nuevos símbolos y los movimientos de cada cinta.

•Avanza a la izquierda, aplicando eso a cada cinta a medida que

va encontrando los cabezales.
 MT con varias cintas

Por lo tanto, toda MT multipista se puede simular con

una MT estándar, y viceversa.

Observaciones:

•Obviamente esta construcción es poco práctica: la

máquina multipista requiere muchos pasos para
simular cada paso de la máquina multicinta.

•Sin embargo, por ahora no nos interesa la

velocidad.

•Lo que interesa: es que lo computable (lenguajes,

funciones) no cambia.
 MT multidimensionales

En una MT multidimensional, en lugar de tener una cinta

infinita (que se puede ver como una función Z),
tenemos un plano, volumen, o algo de dimensión mayor
(que se pueden ver como funciones Z2, Z3, etc).
y
En dimensión 2, los
movimientos serán
L,R,U,D (agregamos

up y down).  c a x
 b


 El poder de cómputo tampoco

aumenta (pero no lo demostraremos!).
 MT no-deterministas

En una MT no determinista, a  b, L q2
existe más de una transición
posible a partir de una
configuración dada. q1

 a b c  a  c, R q3
T=1
q1
Opción 1 Opción 2
T=2  b b c   c b c 
q2 q3
 MT no-deterministas

Como de costumbre, el lenguaje asociado a una MT no-

determinista será el conjunto de palabras para las
cuales existe alguna cadena de decisiones que conduce
a un estado de aceptación.

Nuevamente se tiene la equivalencia: todo lenguaje

aceptado por una MT no-determinista, es aceptado por
una MT estándar (determinista).

Hay varias construcciones posibles; aquí solo

bosquejaremos una. Sea M la MT no-determinista, y
veamos como construir M' estándar, equivalente a M.
 MT no-deterministas

Idea: a la usanza de los viejos sistemas operativos,

simularemos una máquina paralela usando una máquina
secuencial.

En la cinta habrá una serie (finita) de áreas de trabajo,

cada una con la posición de su "cabezal" marcada.

......  $ área 1 $ área 2 $  ......

En cada vuelta, M' recorrerá todas las áreas,

ejecutando una iteración de M en cada una de ellas.
 MT no-deterministas

......  $ área 1 $ área 2 $  ......

......  $ área 1a $ área 1b $ área 2 $  ......

Cada vez que toque "adivinar" un paso, el área de

trabajo se bifurcará (usamos un "insert"), y ahora
habrá un área por cada opción.

Si en algún momento en alguna versión del área de

trabajo M llega a aceptar el input, M' lo aceptará.
 MT offline

Una MT offline tiene dos cintas: el input, que sólo se

lee, y otra para trabajar.

Cinta de entrada a b c c $
sólo lectura

Unidad de control

lectura/escritura
Cinta de trabajo   g d e  
Claramente, el poder de cómputo tampoco cambia.
 LLC  LRE

•Ya vimos que los lenguajes regulares pueden ser

aceptados por MT (y sin siquiera escribir en la cinta).

•Para ver que los lenguajes de libre contexto son

aceptados por MT, tomamos un PDA cualquiera...

Input ...y lo podemos ver

como una MT no-
determinista con
Estados Pila dos cintas:
internos •una de sólo lectura
(con el input)
PDA •la otra (la pila)
inicialmente vacía.
 Jerarquía de lenguajes

•Sabíamos que los lenguajes regulares eran un caso

particular de los lenguajes de libre contexto; ahora
vemos que los de libre contexto son caso particular de
los recursivos.

•Vimos un lenguaje ( {anbncn} ) que es recursivo pero no

es LLC.

•E hicimos notar que recursivo  recursivo enumerable

(es decir, que ser decidido por una MT implica ser
aceptado por una MT).

•Tenemos entonces las siguientes inclusiones:

 Jerarquía de lenguajes

•Pronto veremos
Lenguajes
ejemplos concretos
que muestran que
Lenguajes recursivos
cada una de estas
enumerables (r.e.)
inclusiones es
Lenguajes recursivos propia.

Lenguajes de libre
contexto
Lenguajes
regulares
 Dos teoremas sobre complementos

Teorema: L es recursivo ssi LC es recursivo.

Demostración:
•Usamos la misma MT, pero cambiamos sus estados
de aceptación: F' = Q \ F.

Teorema: Si L es r.e. y LC es r.e., entonces L es

recursivo.

Demostración:
•Dado un input w, ejecutamos simultáneamente las
MT de L y de LC (un paso a la vez para cada una).
•Tarde o temprano una de las dos se tiene que
detener, y sabremos si wL.
 Enumeración

Dijimos que un conjunto es numerable si es finito, o si

tiene el cardinal de los números naturales (N). Para
evitar confusión le llamaremos a eso contable.

Ejemplos de infinitos contables:

•Z (enteros)
•Q (racionales)
•Z (pares ordenados de enteros)
•2Z (números pares)

Ejemplos de infinitos no contables:

•R (reales)
•[0,1] (o cualquier intervalo con más de 1 elemento)
•P(N) (cjto. formado por los subconjuntos de N).
 Enumeración

Por lo general para demostrar que un conjunto es

contable lo que se hace es describir un procedimiento
de enumeración.

Sea L un conjunto de palabras. Definiremos un

procedimiento de enumeración para L como una
máquina de Turing que:

•no recibe ningún input

•genera todas las palabras de L
•cada palabra es generada en tiempo finito

Podemos suponer que hay una cinta de trabajo, y otra

en la cual escribir las palabras de L.
 Enumeración

......  área de trabajo    ......

   w1 # w2 # w3 #    ......

Es útil pensar en la cinta de salida como una "impresora",

donde la MT va agregando palabras.
Que la MT enumere L significa que:
•wL, tw en que w es impresa.
•Si w es impresa, wL.
 Enumeración

OJO:

Diremos que un lenguaje es enumerable (con "e") si

hay una MT que lo enumere.

Si un conjunto (en particular, un lenguaje) es

enumerable, entonces necesariamente es contable (de
hecho, cualquier lenguaje es contable).

Sin embargo, lo contrario no es necesariamente

cierto: puede que un conjunto sea contable y sin
embargo no exista una MT que lo enumere.
 Enumeración

Sea  un alfabeto (es decir, un conjunto finito

cualquiera). Entonces * es un conjunto infinito
enumerable. ¿Por qué?

 Hay que describir una forma de enumerar las

palabras de *

No toda idea es buena. Tomemos ={a,b} como ejemplo.

•Una idea que no funciona es listarlas en orden

alfabético (poniéndole algún orden alfabético a ):
como hay infinitas palabras que parten con a, jamás
llegaremos a listar las que parten con b.
 Enumeración

•En cambio, sí podemos enumerar * si primero

listamos todas las palabras de largo 0, luego las de
largo 1, luego las de largo 2, etc.
•Dentro de las de un mismo largo, podemos seguir
orden alfabético.

 # a # b # aa # ab # ba # bb # aaa #...

A este tipo de orden (en longitud creciente, y orden

alfabético dentro de la misma longitud) se le llama
orden canónico.
 Enumeración

Teorema: L* es recursivo enumerable ssi existe

una MT que lo enumera.

Demostración:
() Existe una MT ME que enumera L, y queremos
crear una MT MA que acepte L.

MA:
•Recibe un input w, y lo deja intacto en una cinta.
•Usa dos cintas más para echar a correr ME.
•Cada vez que ME imprime una palabra, MA la
compara con w. Si es igual, acepta w y se detiene.
De lo contrario, continúa.
 Enumeración

Teorema: L* es recursivo enumerable ssi existe

una MT que lo enumera.

Demostración:
() Existe una MT MA que acepta L, y queremos
crear una MT ME que enumere L.

Tentación: que ME vaya listando las palabras de *

en orden canónico, y ejecutando MA para cada una,
para ver acaso están en L (e imprimiéndolas, cuando
la respuesta es sí).

Problema: para alguna palabra MA puede no detenerse,

y ME se quedará pegada (y nunca seguirá listando).
 Enumeración

Teorema: L* es recursivo enumerable ssi existe

una MT que lo enumera.

Solución a eso: Construimos ME para que funcione

de acuerdo al siguiente algoritmo:

•Para k=0,1,2,...
•Listar las primeras k palabras (del orden
canónico): w1,...,wk
•Para cada wi,
•Ejecutar MA con input wi durante k pasos.
•Si MA aceptó wi, imprimir wi.

QED
 Enumeración

Teorema: L* es recursivo enumerable ssi existe

una MT que lo enumera.

Teorema: L* es recursivo ssi existe una MT que

lo enumera en orden canónico.

Demostración: ejercicio.

Otros ejercicios: construir MT para enumerar:

• {anbn, n>0}
•los números naturales, en binario
•los números enteros, en decimal
 Codificación

Para efectos de enumerar, pero también para efectos

de calcular funciones, y/o decidir propiedades,
necesitamos convertir el input en un string.
Sólo así puede ser input para una MT

Eso puede requerir una codificación no trivial, pero en

principio es siempre posible (con información digital).
Después de todo, los mp3, avi, jpg, son precisamente
información convertida a strings.

Lo importante es precisar qué codificación se usa.

Luego nuestra MT se ocupará de entenderla.
 Codificación

Ejemplo: codificar un grafo dirigido.

Una opción: codificar la cantidad

de nodos, y la matriz de
adyacencia, en que Aij=1 si hay A B
arco de i a j, Aij=0 si no.
C
A B C
A 0 1 1
B 0 1 0
C 0 1 0
111#011010010

Cantidad de nodos Matriz de

(en unario) adyacencia
 Codificación

Ejemplo: codificar un grafo dirigido.

Otra opción: codificar la cantidad

de nodos, y luego los arcos.
A B

111#1#11#11#11#1#111#111#11 C

Cantidad de
nodos (en
unario) (A,B) (B,B) (A,C) (C,B)

Ejercicios:
•codificar AFD
•codificar GLC
 Codificación

Algo más complicado: las propias máquinas de Turing.

Podemos codificar en unario los símbolos de  y los

estados de Q (usaremos el contexto para evitar
ambigüedad). También los movimientos del cabezal: 1
para L, 11 para R.

símbolos a b c d 

codificación 1 11 111 1111

estados q1 
q2 q3 q4
 Codificación

Codificando una transición:

 (q1, a)  (q2 , b, L)

1 # 1 # 11 # 11 # 1

Codificando las transiciones:

 (q1, a)  (q2 , b, L)  (q2 , b)  (q3 , c, R)

1 # 1 # 11 # 11 # 1 # # 11 # 11 # 111 # 111 # 11
 Codificación

Podemos codificar la máquina entera dando:

[cantidad de estados] #
[cantidad de símbolos en ] #
[lista de transiciones] #
[lista de estados que son de aceptación]

Y tendremos un lenguaje LMT sobre el alfabeto {#,1},

formado por todas las posibles MT.
 Codificación

LMT es un lenguaje recursivo:

•podemos construir una MT que vaya generando las

palabras de {#,1}* en orden canónico

•para cada una, chequeará si es una MT válida

(basta ver que siga el formato que describimos) y
los números calcen

•si es válida, imprime la palabra; si no, la ignora.

LMT se puede enumerar, y más aún, se puede

enumerar en orden canónico.
 Codificación

Se deduce que existen lenguajes que no son r.e. (es

decir, no son aceptados por ninguna MT):

•Fijemos el alfabeto, .
•Como vimos, * es un infinito contable.
 P(*) es un infinito no contable: es decir, existe
una infinidad no contable de lenguajes distintos.
•Las MT sobre el alfabeto  son un conjunto
enumerable, ergo contable.
 No puede haber una MT (distinta) para cada
lenguaje. ¡No alcanzan!
 Un lenguaje fuera de LRE

Sin embargo, podemos ser un poco más explícitos:

usaremos el método diagonal de Cantor para
construir:

•un lenguaje que no es r.e.

•un lenguaje que es r.e., pero no recursivo

Consideremos el alfabeto  = {a}.

Consideremos también las MT que aceptan

lenguajes sobre . Son enumerables: llamémoslas
M1, M2, M3, ...
 Un lenguaje fuera de LRE

Cada L(Mi) es un conjunto de palabras de la forma an.

Podemos entonces hacer una "tabla" infinita anotando
qué palabras están en qué lenguajes.

a1 a2 a3 a4 

L( M1) 0 1 0 1 

L( M 2 ) 1 0 0 1 

L( M 3 ) 0 1 1 1  Definamos el
lenguaje L como
L( M 4 ) 0 0 0 1  { ak: ak L(Mk) }
  
 Un lenguaje fuera de LRE

Por construcción, LC (ojo, el complemento de L) no

coincide con L(Mk) para ningún k.
 LC no es recursivo enumerable

a1 a2 a3 a4 

L( M1) 0 1 0 1 

L( M 2 ) 1 0 0 1 

L( M 3 ) 0 1 1 1 

L( M 4 ) 0 0 0 1 
   L
 Un lenguaje fuera de LRE

•LC no es recursivo enumerable.

Por otro lado, L sí es recursivo enumerable.

En efecto, existe una MT que lo acepta, y la

construímos de la siguiente forma:
•Dado un input w=ak, identificamos el valor de k.
•Usando la MT que enumera las M1, M2,...,
encontramos Mk.
•Echamos a correr Mk, dándole el input w. Si se
detiene y acepta, aceptamos w.
 Un lenguaje fuera de LRE

•L es recursivo enumerable.
•LC no es recursivo enumerable.

Por lo tanto, L no es recursivo.

•Si lo fuera, LC sería recursivo también.

•Pero en tal caso sería r.e.

 contradicción
 Un lenguaje fuera de LRE

•LC no es recursivo
Lenguajes LC enumerable.

Lenguajes recursivos •L es recursivo

enumerables (r.e.) L
enumerable pero no
Lenguajes recursivos recursivo.

Lenguajes de libre
contexto
Lenguajes
regulares
 MT y PDAs “aumentados”

Puede parecer un poco brusco el salto desde los LLC y los

PDA, a las máquinas de Turing (en las que se puede
programar prácticamente lo que se nos ocurra).

Sin embargo:

•Definamos los "autómatas de cola", como autómatas

finitos a los que en lugar de agregarles una pila, les
agregamos una cola.

•Definamos los "2PDA", autómatas finitos a los que en

lugar de agregarles una pila, les agregamos 2 pilas.

Ejr.: cada una de esas clases es equivalente a las MT.

 Gramáticas generales

Dijimos que una gramática, en su forma más general,

admitía producciones de la forma

abbacXaYb  bbabXX
Xa  baa | Y

A diferencia de la GLC, en el caso general no hay

restricción sobre el lado izquierdo de las producciones.

Al derivar una palabra se usan las reglas para ir

reemplazando lo que está a la izquierda por lo que esté
a la derecha.
 Gramáticas generales

Ejemplo: una gramática para un lenguaje que no es de

libre contexto.

S  XYZS | 
XY  YX
YZ  ZY
XZ  ZX
Xa
Yb
Zc

Teorema [no veremos la demo.]: un lenguaje es recursivo

enumerable ssi existe una gramática que lo genera.
 Otros modelos de cómputo

•Por distintos lados (gramáticas, autómatas con

cola, autómatas con dos pilas, MT) se llega a la
misma clase de lenguajes (el mismo poder de
cómputo).

•Y al agregar más cosas (más cintas, más pilas, no

determinismo, etc etc), ya no aumenta.

* Es la punta del iceberg: todos los otros modelos

de computo que se han inventado han resultado ser
equivalente (o inferiores) al poder de cómputo de
las máquinas de Turing.
•Continuará...