Maquinas de Turing

MQUINAS DE TURING:
PROBLEMAS INDECIDIBLES
Roberto J. de la Fuente Lpez
VERSION 20100922
Mquinas de Turing
Problemas indecidibles
PRESENTACIN
El presente documento surge de los apuntes tomados de diversas fuentes durante mi
paso por la Ingeniera Tcnica en Informtica de Sistemas de la Universidad Nacional de
Educacin a Distancia.
Tiene pocos ejemplos y ningn ejercicio propuesto: solo es un tratado terico, poco
formal pero riguroso. Este inconveniente se puede solventar ampliamente si se consulta la
bibliografa del apndice A.
Por ltimo, aunque el documento est enfocado a las asignaturas de teora de
autmatas y computacin de la UNED, el lector no tendr problemas en su compresin si
tiene conocimientos previos de lgebra elemental, teora de conjuntos grafos y,
complementariamente, autmatas finitos y de pila.
AVISO DE DERECHOS DE AUTOR

El autor se reserva todos los derechos. No obstante, el lector lo puede imprimir
cuantas veces necesite y tambin lo puede transmitir por cualquier medio. Cualquier otro
uso precisa del permiso previo y por escrito del autor.
Roberto J. de la Fuente Lpez
Mquinas de Turing
INDICE
1.- INTRODUCCIN ............................................................................................................ 7

1.1.- UN POCO DE HISTORIA ....................................................................................... 8
1.1.1.- 2 problema de Hilbert.......................................................................................... 8
1.2.- LA TESIS DE CHURCH-TURING ........................................................................ 9
1.3.- ALGORITMO ......................................................................................................... 10
1.4.- CONJUNTOS RECURSIVOS Y CONJUNTOS RECURSIVOS
ENUMERABLES ............................................................................................................ 10
2.- DEFINIENDO LA MQUINA DE TURING (MT) ................................................... 11
2.1. CMO OPERA LA MT? ...................................................................................... 13
2.2. DEFINICIN FORMAL DE LA MT..................................................................... 14
2.3. MUESTRA INFORMAL DEL FUNCIONAMIENTO DE UNA MT ................. 16
2.4. CONFIGURACIONES ............................................................................................ 19
2.5. TRANSICIONES ...................................................................................................... 21
2.6. REPRESENTANDO LA MT................................................................................... 24
2.7. DEFINICIN FORMAL DE LENGUAJE ACEPTADO POR UNA MT ...... 29
3.- VARIACIONES A LA MT DEFINIDA ....................................................................... 29
3.1. RETOMANDO LA MT QUE REALIZA CALCULOS ....................................... 30
3.2. OTRAS VARIANTES DE MT ................................................................................ 33
3.2.2. Que tenga un conjunto R de estados de rechazo.................................................. 34
3.2.3. Una vez aceptada la cadena, el contenido de la cinta sea un mensaje de
aceptacin ...................................................................................................................... 35
3.2.4. Que se permita no mover la cabeza en una transicin ......................................... 36
3.2.4. Que la Unidad de control tenga una memoria finita de smbolos........................ 37
3.2.5 Cinta con varias pistas .......................................................................................... 40
3.2.6. MT con varias cintas ............................................................................................ 44
3.3.7. MT no determinista (MTN) ................................................................................. 50
3.3.8 MT con cintas semi infinitas................................................................................. 52
4.- LENGUAJES DECIDIBLES Y RECONOCIBLES POR UNA MT ......................... 55
5. ALGORITMO (y 2) ......................................................................................................... 57
Mquinas de Turing
6. CODIFICACIN DE LAS MT ......................................................................................57

7.- LMITE DE LAS MQUINAS DE TURING .............................................................61
8.- CONJUNTOS RECURSIVOS Y RECURSIVOS ENUMERABLES (y II)..............65
9.- MAQUINA UNIVERSAL DE TURING ......................................................................66
9.1. LMITE DE LOS COMPUTADORES ACTUALES .................................................69
9.2. UN PROBLEMA REAL .............................................................................................71
10. DETERMINAR LA INDECIBILIDAD. MTODO DE REDUCCIN .................71
APNDICE A.- BIBLIOGRAFA Y REFERENCIAS ....................................................74
1.- INTRODUCCIN
La primera pregunta que nos vamos a plantear es Qu clase de problemas es capaz
de resolver un computador? O, de forma ms genrica qu clase de problemas es capaz de
computar una mquina? Para contestarla primero tenemos que definir en trminos tericos
esta pregunta y su posterior respuesta.
Un problema es una pregunta precisa sobre un conjunto de elementos, que arroja
como solucin otro conjunto de elementos. De manera informal hemos dado la definicin de
una funcin de un conjunto origen (dominio) sobre un conjunto imagen (rango).
Si
cambiamos la pregunta o el conjunto origen, estamos definiendo otro problema, otra

funcin.
Resolver el problema consiste en aplicar una secuencia finita de acciones no
ambiguas sobre los datos de entrada para obtener unos datos de salida, es decir, consiste en
aplicar un algoritmo que nos calcule la solucin. Se dice que un problema es computable
si el problema definido (la funcin) se puede calcular mediante algn algoritmo.
Por mquina vamos a considerar cualquier modelo computacional de resolucin de
problemas. Un modelo estar definido por unas primitivas y unas reglas de aplicacin de
las mismas, que adems definir su capacidad computacional (que tipo de problemas es
capaz de resolver). Dos modelos son equivalentes, computacionalmente hablando, si son
capaces de resolver los mismos problemas.
Para poder utilizar un modelo computacional, lo primero que hay que hacer es
representar simblicamente los elementos del conjunto origen para que la mquina los
entienda. En las mquinas que vamos a considerar siempre vamos a tomar como entrada una
cadena de smbolos en el alfabeto de la mquina, la cual pertenece a un lenguaje
determinado. As el conjunto origen lo podemos definir como un lenguaje y cada uno de sus
elementos se representa por las cadenas de entrada a la mquina.
El que se haga una u otra representacin simblica de la mquina es indiferente, pues
siempre se va a poder convertir de una a otra representacin. Lo importante de esta
Mquinas de Turing
conversin es que, con la representacin en cadenas y lenguajes a los que pertenecen,

podemos representar cualquier clase de problema: funciones, grafos, gramticas, autmatas,
mquinas de Turing,.
Los problemas se pueden clasificar segn sus caractersticas. Una posible
clasificacin es si un problema es de decisin o no. Un problema es de este tipo si el
conjunto imagen (rango) solo tiene dos elementos dicotmicos posibles: {s, no}, {0,1},
{encendido, apagado}, {alto, bajo}.Se puede demostrar que cualquier problema que no
sea de decisin se puede reformular para que as lo sea; es decir, todos los problemas
pueden plantearse como de decisin.
Dado que se han codificado los elementos como cadenas que pertenecen a un
lenguaje, el problema se puede reformular en trminos de encontrar un algoritmo que sea
capaz de decidir si una cadena a la entrada de la mquina pertenece o no al lenguaje.
Para contestar las cuestiones del principio, primero hay que contestar a esta son
computables todos los problemas?, es decir, existe al menos un algoritmo para cada uno de
los problemas posibles? Como se demostrar ms tarde, la respuesta es no.
1.1.- UN POCO DE HISTORIA

Paris 1900: David Hilbert propuso a la comunidad matemtica una serie de
problemas para resolver en el nuevo siglo que entraba. Inicialmente fueron 10 los problemas
expuestos, aunque la lista, finalmente, fue de 23.
1.1.1.- 2 problema de Hilbert
Propona probar si un sistema axiomtico es consistente, es decir, probar si hay un
procedimiento para determinar la verdad o falsedad de una proposicin (decidir si es
verdadera o falsa). En realidad por procedimiento se refera a un algoritmo, concepto que
definiremos formalmente mas adelante.
En 1931 Kurth Gdel public el famoso teorema de incompletud. Este se enunci

para la lgica formal y dice que un sistema axiomtico siempre esta incompleto y que no se
puede demostrar su validez con esos axiomas que lo definen.
Basndose en los trabajos de Gdel, por un lado Alonzo Church y por otro Alan M.
Turing, definieron formalmente el algoritmo, demostrando que no exista uno capaz de
decidir (verdad o falsedad) una proposicin matemtica en la teora de nmeros.
Church desarroll la definicin del clculo lambda (-calculus, utilizado en el
modelo de programacin lgica) y Turing desarroll la mquina de su mismo nombre.
Ambos modelos son computacionalmente equivalentes y concluyeron en la TESIS DE
CHURCH-TURING.
Una vez que se defini formalmente el trmino algoritmo, ya se poda intentar
probar el 10 problema propuesto por Hibert. El estudio de este le llev a Julia Robinson
casi toda su carrera (junto con Martin Davis y Hillary Putnam), pero no lleg a encontrar la
solucin. Fue en 1970 cuando, un joven estudiante Yuri Matijasevic, basndose en los
estudios de Julia Robinson, quien la encontr (prob que no existe un mtodo general para
resolver el problema propuesto por Hilbert).
1.2.- LA TESIS DE CHURCH-TURING

Como se ha dicho, ambos matemticos llegaron a la misma conclusin: Church
afirmaba que no exista un mtodo de clculo ms avanzado, ms poderoso, que el calculo
y Turing afirmaba que no exista una mquina de computacin ms potente que la mquina
de Turing. Se puede demostrar que las mquinas de Turing y el clculo- son modelos con
el mismo poder computacional.
Es una tesis pues nadie ha sido capaz de rebatir esta afirmacin y es tan importante
porque nos muestra cual es el lmite de la computacin actual, y por ende, cuales son los
lmites de los computadores actuales. A partir de esta tesis se desarrolla la teora de
computacin y decidibilidad (un problema que una mquina de Turing no es capaz de
decidir, es un problema que no es computable).
10
Mquinas de Turing
1.3.- ALGORITMO
La definicin formal de algoritmo viene dada por la definicin formal de la mquina

de Turing y de cmo esta realiza los cmputos. Al ser la mquina de Turing el modelo
computacional ms poderoso que existe (no debemos de olvidar que es conceptual, no real),
se puede convertir cualquier computador actual en una mquina de Turing, y por lo tanto se
puede describir el comportamiento del algoritmo que en l se ejecuta de una manera formal.
1.4.-
CONJUNTOS
RECURSIVOS
CONJUNTOS
RECURSIVOS
ENUMERABLES
Como sabemos
es un conjunto infinito contable. Un subconjunto S
que es recursivo si existe una funcin en

f(x)=1 si x
S y f(x)=0 si
X se dice
tal que
S (en este caso se dice que la funcin es
recursiva primitiva)
es decir, un conjunto es recursivo si tenemos un medio de determinar si un elemento

pertenece o no a dicho conjunto. Un ejemplo claro, aplicable directamente a la definicin, es
que y
son conjuntos recursivos. Como consecuencia, cualquier conjunto contable
(finito o infinito) es recursivo1. Tanto S como
(complementario de S, elementos que no
pertenecen a S, teniendo en cuenta aqu que la complementacin es una operacin cerrada)

son recursivos. Observar que es el complementario de
Un conjunto S es recursivamente enumerable si existe una funcin recursiva por la
cual los elementos de S son el conjunto imagen de la funcin. En otras palabras, un conjunto
es recursivamente enumerable si tenemos un medio de enumerar los elementos del mismo.
Como se puede observar, este segundo tipo de conjuntos es menos restrictivo que el
recursivo, por lo que se puede afirmar que cualquier conjunto S recursivo, tambin es
recursivamente enumerable. De hecho,
para que S sea recursivo,
recursivamente enumerables.
1
No confundir esta recursividad con la recursividad de un lenguaje de programacin
S y
han de ser
11
Se denominarn recursivamente enumerable (RE) a los conjuntos en los que S es RE

pero el conjunto complementario
de S, no lo es (RE no es cerrado para la
complementacin).
Qu tiene que ver esto con las Mquinas de Turing? Antes se ha dicho que Turing
lleg a la conclusin de que no se puede decidir la verdad o falsedad de una proposicin
matemtica. Esto es lo mismo que decir que el conjunto de las proposiciones matemticas
(basadas en un sistema axiomtico) no es recursivo.
Una mquina de Turing slo es capaz de reconocer conjuntos recursivos
enumerables (luego se ver la diferencia entre decidir y reconocer). En trminos de teora de
computacin y lenguajes formales, conjunto aqu es equivalente a lenguaje aceptado
(conjunto de cadenas que acepta la mquina). Cuando se defina formalmente la Mquina de
Turing, retomaremos la capacidad computacional de esta, utilizndola para demostrar todas
estas afirmaciones.
2.- DEFINIENDO LA MQUINA DE TURING (MT)

La Mquina de Turing (MT) es conceptual, y se ide antes de la aparicin de los
computadores electrnicos. Est basada en cmo un ser humano es capaz de realizar
computaciones. Suponer que se va a realizar un clculo con lpiz y papel. El papel va a
ser el soporte de almacenamiento y el lpiz es el mecanismo que realiza los cambios en
aquel. Al principio el papel estar en blanco, donde se ir escribiendo sucesivamente el
enunciado de lo que vamos a computar. En un momento del clculo, la mente estar en
una condicin determinada (un estado determinado) de entre un conjunto de ellas (que se
puede considerar finito). En esta condicin (estado) la atencin estar centrada en uno de los
smbolos escritos en el papel (este smbolo no tiene porqu ser slo un carcter). Para
avanzar en nuestro clculo, se har alguna accin (leer o escribir otros smbolos) basndola
en el estado y el smbolo en los que se est centrado, lo que llevar a una condicin nueva
(un nuevo estado). Cuando se considere que lo que se ha plasmado en el papel es la
solucin, se deja el lpiz en la mesa, es decir, paramos de calcular. Adems, en nuestro
Mquinas de Turing
12
avance tambin podremos memorizar algn valor intermedio de nuestro clculo para su
posterior uso durante la computacin.
Aunque esta mquina fue descrita para realizar clculos sobre nmeros computables
(esto es, nmeros reales cuya parte decimal es calculable en intervalos finitos) de manera
que aceptaba la solucin cuando esta estaba escrita, se va a definir la Mquina de Turing
(MT) en los trminos descritos en la introduccin: aceptacin de una cadena que pertenece a
un lenguaje (es otra forma de decir que soluciona un problema).
As la MT va a estar compuesta por una unidad de control (la mente) que va estar
en uno de entre un conjunto finito de estados (qi) y que va a tener asociada una cabeza de
lectura/escritura (el lpiz). Como soporte de almacenamiento va a tener una cinta (para
hacernos una idea podemos pensar en una cinta de papel), sobre la que apunta la cabeza de
lectura/escritura. Esta cinta, que tendr una longitud infinita por ambos lados (lo que hace
que la MT tenga una capacidad infinita de almacenamiento), va a estar dividida en casillas o
celdas (a una de ellas, y slo una, apunta la cabeza) y cada una de estas casillas va a
contener un smbolo (que puede ser ms de un carcter). La unidad de control solo puede
considerar, en cada paso de clculo, el smbolo de la casilla a la que apunta la cabeza y el
estado en el que se encuentre la unidad de control (UC). Si esta unidad tiene la capacidad de
almacenar un conjunto finito de smbolos de entre los que ya se visitaron durante el proceso
de computacin, entonces tendr que considerar, adems del estado en el que se encuentra,
tanto los smbolos almacenados como al que apunta la cabeza (ver variante de MT en 4.2.4).
13
La figura representa una MT con la unidad de control en el estado qi, con m celdas
de almacenamiento temporal y cuya cabeza apunta a un smbolo Sk en una cinta infinita.
Realmente, la forma de representar la MT es indiferente, pues se trata de una mquina
conceptual. De momento, vamos a considerar la mquina sin memoria en la UC.
2.1. CMO OPERA LA MT?
Primero hay que inicializar la mquina. Al principio, la cinta est en blanco. A
continuacin se introduce la cadena de entrada en la cinta, que ser una secuencia de
smbolos del alfabeto que entiende, se pone la unidad de control en el estado inicial y se
posiciona la cabeza sobre la primera letra de la cadena introducida.
El cambio de condicin (de estado), es decir el avance en el clculo, es lo que vamos a
llamar transicin2). Este, como ya hemos dicho, depende del estado actual y del smbolo al
que apunta la cabeza. La transicin se producir en el siguiente orden:
La cabeza lee el smbolo de la casilla a la que est sealando. Teniendo en cuenta

este smbolo y el estado en que se encuentra:
o Cambiamos al siguiente estado. Si resulta que la operacin es repetitiva, el
estado ser el mismo.
o Escribir un smbolo en la cinta (los smbolos que se pueden escribir son los
del alfabeto y algunos ms). Este tambin puede ser el mismo (esto es
equivalente a una operacin de solo lectura).
o Mover la cabeza a la izquierda o a la derecha (segn se necesite) una y solo
una casilla.
Durante el clculo se pueden producir dos situaciones:
Que se llegue a una solucin, en cuyo caso la mquina se parar.
En la bibliografa a esto lo suelen llamar movimiento, por la analoga con el movimiento de la cabeza de
lectura/escritura. Sin embargo este nombre no es del todo adecuado, pues se puede definir un modelo de MT
que permita el no movimiento de la cabeza, efectuando, sin embargo, una transicin de la mquina.
14
Mquinas de Turing
Que el problema no tenga solucin, en cuyo caso la mquina puede pararse o entrar
en un bucle infinito y no parar nunca. Este comportamiento depender
exclusivamente del problema que se est intentando computar.
2.2. DEFINICIN FORMAL DE LA MT

El modelo de MT que se va a definir no incluye la posibilidad de almacenar un
nmero finito de smbolos en la unidad de control y los smbolos van a estar compuestos por
un solo carcter. Adems, se utilizar la MT como una mquina que acepta una cadena
perteneciente a un lenguaje dado (en el mismo sentido de los autmatas finitos y de pila).
As una MT se define por una sptupla:
M = (Q, , , , q0, B, F ) donde:
Q .- Conjunto finito de estados qi
.- Alfabeto de la mquina. Es un conjunto finito de smbolos
.- Alfabeto de cinta. Es un conjunto finito de smbolos. Por definicin el alfabeto

de la mquina est incluido en el alfabeto de cinta (
.- Funcin de transicin. Es un conjunto finito y define el comportamiento de la

mquina. Dado un estado qi y un smbolo de cinta, la MT pasar al estado
determinado por la transicin, escribir un smbolo de cinta y se desplazar a la
derecha o izquierda segn se indique.
q0 .- Es el estado inicial de la mquina y es en el que esta empieza a computar. Es

decir, q0
15
B.- Smbolo de cinta que representa la casilla en blanco3. Este, que no puede
pertenecer al alfabeto de la mquina, puede representarse tambin con los smbolos
, o
segn convenga. Por definicin B pertenece al alfabeto de cinta pero no al
de la mquina (B
/B
).
F.- Subconjunto de Q, y por tanto finito, que contiene los estados finales o de
aceptacin. Es decir, (F
Q).
Cuando se inicializa M, las casillas de la cinta estn en blanco, estando representadas

por el smbolo de casilla en blanco. A continuacin se produce la entrada (cadena de
smbolos en el alfabeto de la mquina) que se introducir en la cinta a partir de la posicin a
la que apunta la Cabeza de lectura/escritura (esta posicin es indiferente, pues la cinta es
infinita). A partir de aqu se realizan las transiciones que determine la funcin de transicin
y la mquina parar cuando, para un estado y un smbolo de cinta, la funcin de transicin
no est definida, aceptando la cadena si el estado es de aceptacin.
Se puede decir que una MT siempre parar cuando acepte la cadena. Sin embargo,
como ya se ha dicho, dependiendo del lenguaje (del problema), no se puede garantizar que
la mquina pare cuando la cadena no pertenezca al mismo.
Sea Q el conjunto de estados de Q exceptuando los de aceptacin (Q = Q F) y sea
S = {I, D} el conjunto de direcciones de movimiento posibles, donde I y D son el
movimiento a la Izquierda o a la Derecha respectivamente, la funcin de transicin se define
como:
: Q x Q x x S
Por ejemplo, si tenemos la transicin (q0,a) (q1,b,I), esto significa que si estamos
en el estado q0 y sobre el smbolo de cinta a, procedemos en el orden indicado en el punto
2.1: se pasa al estado q1, se sustituye el smbolo actual, a, por b, y la unidad de control se
mueve una casilla a la izquierda.
En las publicaciones consultadas, a B se le llama espacio en blanco a lo que aqu llamamos smbolo de casilla
en blanco. Esta diferenciacin la hacemos para distinguir el caso de que el alfabeto contenga el espacio en
blanco como tal (separacin entre palabras).
16
Mquinas de Turing
Porqu necesitamos Q? Cuando se llega a un estado de aceptacin, la mquina

debe parar, ya que en un estado de aceptacin no se deben hacer ms clculos y por lo tanto
no puede ser argumento de la funcin (no existe una transicin desde este estado). Una
consecuencia de esto es que el estado inicial no puede ser de aceptacin: si as fuera, la
mquina, directamente, no hara nada (en este caso acepta el lenguaje vaco). Es decir, para
que una mquina de Turing acepte alguna cadena debe tener, como mnimo, dos estados:
inicial y de aceptacin.
Ejemplo: Sea la mquina de Turing que va a tener 5 estados, numerados de q0 a q4;
como alfabeto las letras a, b, c y el espacio en blanco
(en el sentido de espacio
entre palabras); como smbolos de cinta, los del alfabeto ms el de casilla en blanco
(que denotamos aqu con , para no confundir con el alfabeto de la mquina), el
estado inicial es q0, y los estados de aceptacin son q2 y q4. As la definicin formal
de la mquina (incompleta, porque nos falta al funcin de transicin) ser:
M=({ q0, q1, q2, q3, q4 }, {a,b,c, }, {a,b,c, , },
{: (Q x ) Q x x S}, q0, ,{ q2, q4})
-Se podr tener una MT que, aunque tenga dos o ms estados, ninguno lo sea de
aceptacin: en este caso la MT no acepta ninguna cadena, con lo que se dice que acepta el
lenguaje vaco .
2.3. MUESTRA INFORMAL DEL FUNCIONAMIENTO DE UNA MT

Se mostrar con un ejemplo: Disear una MT que compruebe (que se pare) si la
cadena de entrada pertenece al siguiente lenguaje
L={$ /
{a + b}* }
Es decir, comprobar si la cadena de a,s y b,s a la izquierda de $ es igual a la cadena

de la derecha. As podemos definir
= {a,b,$}
17
= {a,b,$, ,X}
Hemos utilizado el smbolo para no confundir el smbolo de casilla en blanco con

la b del alfabeto de la mquina, y X un smbolo de cinta adicional necesario para la
operacin.
Inicializacin de la mquina: Al principio, la cinta est en blanco. A continuacin se
introduce la cadena de entrada, por ejemplo abaa$abaa, se pone la unidad de control en el
estado inicial y se posiciona la cabeza sobre la primera letra de la cadena introducida.
Puesta en marcha de la mquina: Slo podemos movernos de celda en celda, y lo har

con arreglo a lo que marque la funcin de transicin. La estrategia utilizada en este ejemplo
consistir en realizar un movimiento de ida y vuelta, de manera que vamos comprobando,
smbolo a smbolo uno de la subcadena a la izquierda de $ con su correspondiente, en la
misma posicin, de la subcadena de la derecha. Esto lo conseguiremos mediante la
tcnica del marcado. En nuestro ejemplo, se marca el primer smbolo (la primera a con
una X), luego se recorre la cinta hasta la primera letra despus de $ y se comprueba si es
una a; si no lo es la maquina se para en un estado que no es de aceptacin, y si lo es, se la
marca con una X y se vuelve a la primera letra sin marcar de la subcadena de la izquierda.
La mquina se parar:
Aceptando la cadena, si se han marcado todas las letras y las subcadenas son
iguales, es decir, parndose en un estado de aceptacin.
Rechazando la cadena si se produjo una discrepancia entre subcadenas (letras

distintas, longitudes distintas), es decir, parndose en cualquier estado que no es de
aceptacin).
Algunas instantneas de la mquina a lo largo de la computacin son:
Mquinas de Turing
18
El marcado y el movimiento hacia delante y hacia atrs y viceversa,

caracterizan el funcionamiento de una MT.
19
2.4. CONFIGURACIONES
En el ejemplo anterior se han mostrado unas cuantas instantneas de la MT. A cada
una de estas se la llama configuracin. En esta tenemos representadas tres cosas: el
contenido de la cinta, el smbolo que contiene la casilla a la que apunta la cabeza de
lectura/escritura y el estado en el que se encuentra la unidad de control de la maquina en ese
instante.
Para no tener que realizar un dibujo de la mquina con cada configuracin que se
pueden dar en la aceptacin/rechazo de una cadena, se va a definir una notacin ms concisa
para representarlas: con cadenas de texto.
El primer problema que se plantea en esta nueva representacin es cmo se puede
representar el contenido de una cinta si su longitud es infinita?. Como se ha dicho, al
principio la cinta est en blanco y a continuacin slo tendr la cadena de entrada. En este
caso los smbolos de casilla en blanco son irrelevantes para representar una configuracin, y
por lo tanto no se van a representar. Es decir, solo se escribir desde el primer smbolo de la
izquierda de la cadena de entrada hasta el ltimo de esta.
Antes de continuar, es necesario fijar un convenio de notacin para las
configuraciones:
Smbolos de entrada.- a, b, c primeras letras de abecedario en minscula o una a

(minscula) con subndices.
Smbolos de cinta.- Adems de B (smbolo de casilla en blanco), Z,Y,X ltimas

letras de abecedario en mayscula o una X (mayscula) con subndices.
Cadena del lenguaje.- z, y, x. ltimas letras de abecedario en minsculas o una x

(minscula) con subndice.
Cadena de smbolos de cinta.- letras griegas minsculas.
Estados.- p, q, r, cuando son pocos. Si son muchos, se suele denotar como q

(minscula) con subndices (como los mostrados en el ejemplo), empezando
20
Mquinas de Turing
normalmente por el cero. No obstante, y para evitar ambigedades, hay que tener
cuidado con que la notacin de los estados no pertenezca al alfabeto de la cinta.
Una configuracin se representar de la siguiente manera: la cinta contiene una cadena
de smbolos de cinta = , donde y son dos subcadenas que, concatenadas, forman .
Dado un estado qi y la cabeza de lectura/escritura posicionada sobre el primer smbolo de la
subcadena , la configuracin se representa como
qi
As, la primera instantnea del ejemplo anterior en texto estar representada por:
X q1 baa$abaa
Que es mucho ms conciso que dibujar la mquina en cada configuracin.
Una configuracin especial es la configuracin de inicio: Si es la cadena de entrada,
y q0 el estado inicial, la posicin de inicio ser el primer smbolo de . Se representa por
q0
En nuestro ejemplo, la configuracin de inicio estar representada por
q0 abaa$abaa
Una configuracin de aceptacin es aquella cuyo estado es de aceptacin. En el
ejemplo, es la ltima instantnea dibujada.
XXXX$XXXX qa
Una configuracin de rechazo es aquella cuyo estado es cualquiera que no sea de
aceptacin y para el que no hay definida una transicin.
21
2.5. TRANSICIONES
Se dice que una configuracin Ci produce otra Ci+1 cuando, por aplicacin de la
funcin de transicin a Ci se obtiene Ci+1.
Para una mquina M, vamos a definir el operador transicin con el smbolo
, donde
el subndice M es opcional si sabemos cual es la mquina para la que describimos la

transicin. Podremos denotar cero, una o ms transiciones aplicando la estrella de Kleene
sobre el operador
*
M
Dado que el modelo de MT que se ha definido es obligatorio mover la cabeza a la

derecha o a la izquierda, una produccin (transicin) ser sinnimo de movimiento, el cual
se efectuar de forma distinta, dependiendo de si es a la derecha o a la izquierda.
Dados q y p, dos estados para los que existe una transicin, Xi es cada uno de los
smbolos de cinta en la configuracin, Y es el smbolo de cinta que sustituye al que apunta
la cabeza de lectura/escritura, X0, y la UC en el estado q, su configuracin es
X -n X -(n-1)X -2 X -1 q X0 X1 X2 X3. Xm-1 Xm
Podremos realizar un movimiento:
A la izquierda.- Si la funcin de transicin es (q, X0) (p, Y, I), es decir, se est en

el estado q sealando el smbolo X0, debiendo sustituirlo por Y, pasar al estado p y
mover una casilla a la izquierda, la cabeza apuntar al smbolo de cinta anterior al
sustituido
X-n X-(n-1)X-2 X-1 q X0 X1 X2 X3. Xm-1 Xm
X-n X-(n-1)X-2 p X-1 Y X1 X2 X3. Xm-1 Xm
A la derecha.- Si la funcin de transicin es (q, Xo) (p, Y, D), es decir, se est en

el estado q sealando el smbolo X0, debiendo sustituirlo por Y, pasar al estado p y
22
Mquinas de Turing
mover una casilla a la derecha, la cabeza apuntar al siguiente smbolo de cinta al

sustituido.
X-n X-(n-1)X-2 X-1 q X0 X1 X2 X3. Xm-1 Xm
X-n X-(n-1)X-2 X-1 Y p X1 X2 X3. Xm-1 Xm
Tomando la configuracin de inicio del ejemplo informal, se va a mostrar el

movimiento desde el estado inicial hacia la primera instantnea. As:
qo abaa$abaa
X q1 baa$abaa
Y tomando la tercera y la cuarta instantnea, no siendo la segunda una produccin de

la primera, sino despus de varias de ellas:
XX q5 aa$abaa
XXaa$ q7 XXaa
Cuando se termine de definir la mquina del ejemplo se ver de forma ms clara la

representacin de los movimientos.
Cada tipo de movimiento (izquierda o derecha) puede dar lugar a dos situaciones
especiales en la notacin: cuando la cabeza est en alguno de los extremos de la cadena
representable de smbolos de cinta.
Situaciones para movimiento a la izquierda:

o Que la cabeza apunte al primer smbolo de cinta que no es casilla en blanco.
Habr que representar la primera casilla en blanco en la configuracin
(suponer B como smbolo de casilla en blanco). Para la transicin (q, Xn)
(p,Y,I), con la configuracin mostrada, su produccin ser :
q X-n X-(n-1)X-2 X-1 X0 X1 X2 X3. Xm-1 Xm
23
p B Y X-(n-1)X-2 X-1 X0 X1 X2 X3. Xm-1 Xm
o Que la cabeza apunte al ltimo smbolo de cinta que no es casilla en blanco y

la transicin sea de sustituir el smbolo actual por la casilla en blanco, en
cuyo caso esta ltima la podemos eliminar de la representacin, ya que se
concatena con el resto de casillas en blanco de la parte derecha de la cinta.
Para (q, Xm) (p,B,I) :
X-n X-(n-1)X-2 X-1 X0 X1 X2 X3. Xm-1 q Xm
X-n X-(n-1)X-2 X-1 X0 X1 X2 X3. p Xm-1
Situaciones para movimiento a la derecha

o Que la cabeza apunte al primer smbolo de cinta que no es casilla en blanco y
se tenga que sustituir el smbolo actual por la casilla en blanco, en cuyo caso
esta ltima la podemos eliminar de la representacin, ya que se concatena
con el resto de casillas en blanco de la parte izquierda de la cinta. Para (q,
Xn) (p,B,D) :
q X-n X-(n-1)X-2 X-1 X0 X1 X2 X3. Xm-1 Xm
p X-(n-1)X-2 X-1 X0 X1 X2 X3. Xm-1 Xm
o Que la cabeza apunte al ltimo smbolo de cinta que no es casilla en blanco.

Hay que incluir en la representacin la primera casilla en blanco de la
derecha. Para (q, Xm) (p,B,D):
X-n X-(n-1)X-2 X-1 X0 X1 X2 X3. Xm-1 q Xm
X-n X-(n-1)X-2 X-1 X0 X1 X2 X3.Xm-1 Y p B
Mquinas de Turing
24
2.6. REPRESENTANDO LA MT
Cuando se ha definido el modelo de MT, se ha dicho que la funcin de transicin es
la que define el comportamiento (produce el conjunto de producciones- transiciones) de la
mquina. No se ha dicho que, al ser una funcin de transicin, por cada par (estado, smbolo
de cinta) vamos a tener una sola transicin (no un conjunto de transiciones posibles), con lo
que estamos definiendo una MT determinista. Al igual que en los autmatas finitos y de
pila, esta definicin no es estrictamente cierta, pues se necesitara tener definidas las
transiciones para todas las posibles combinaciones de smbolo de cinta-estado. Este punto se
tratar cuando se vean las MT no deterministas.
Por tanto, representar este conjunto funcin de transicin es equivalente a
representar la MT que describe, que puede ser mediante una tabla de transiciones o
mediante un diagrama de transiciones. Como ocurre en los autmatas finitos y de pila, la
representacin mediante el diagrama de transiciones es adecuada mientras la mquina sea
sencilla, pues en caso contrario puede llegar a ser ilegible.
Representacin tabular.- Tendr tantas columnas como smbolos de cinta y tantas

filas como estados posibles. Una entrada de la tabla podr:
o Estar en blanco, en cuyo caso corresponde a una situacin con la funcin de
transicin sin definir (parada).
o Contener la terna que describe la produccin (transicin). Si una transicin
dada se define por (q, Xk) (p,Y,I), la entrada de la tabla para la columna
Xk y la fila q, contendr la terna (p,Y,I).
Representacin mediante diagrama de transiciones.- Ser un pseudo-grafo dirigido

donde cada nodo se corresponde con cada estado de la mquina, dibujndose para
ello una pequea circunferencia etiquetada en su interior con el nombre del estado.
Uno de ellos ser de inicio, estando sealado por una flecha etiquetada con el
nombre INICIO, y uno o ms sern de aceptacin, dibujndose el nodo con dos
circunferencias concntricas etiquetado en su interior con el nombre del estado.
25
Cada una de las aristas dirigidas representar cada una de las transiciones definidas
para la mquina. Se permiten transiciones sobre el mismo estado o desde un estado
hacia otro. Estas aristas estarn etiquetadas con: smbolo de cinta actual, smbolo de
cinta que lo sustituye y la direccin del movimiento. Si X es el smbolo actual de
cinta, Y el que lo sustituye y S la direccin del movimiento, para la transicin
(q,X)=(p,Y,S), se podrn encontrar las siguientes notaciones, dependiendo de los
autores
X/Y S X/Y, S X;Y,S
X Y,S
Tambin se puede simplificar si X e Y son iguales (el smbolo se deja como est)
X/S X/X, S
XS X Y,S
O la simplificacin cuando hay varias transiciones del mismo tipo entre dos mismos
estados.
X1 , X2 /S { X1/S , X2/S }
X1 , X2 S { X1S , X2S }
Antes se ha definido el conjunto S = {I, D} de las posibles direcciones de

movimiento. Pues bien, en la etiqueta de la arista, podremos encontrarnos para
Izquierda con I (inicial en espaol), con L (inicial en ingls) o incluso en modo
grfico con y para la Derecha con D (inicial en espaol), con R (inicial en ingls)
o en modo grfico .
El smbolo de casilla en blanco, dependiendo del alfabeto de la cinta, se puede
representar con B o con cualquiera de los smbolos , o .
Ejemplo: definir formalmente y representar la mquina de Turing que acepta cadenas
que pertenecen al lenguaje L={$ /
{a + b}* }, es decir, comprobar si la
cadena de a,s y b,s a la izquierda de $ es igual a la cadena de la derecha.

Como se habr deducido, se trata de la MT que se introdujo de manera informal,
luego ya se tienen definidos los alfabetos de la mquina y de cinta:
26
Mquinas de Turing
= {a,b,$}
y
= {a,b,$, ,X}
La funcin de transicin se va a representar mediante la siguiente tabla
a
q0 q1,X,D q5,X,D q8,$,D
q1
q1,a,D
q1,b,D
q2,$,D
q2
q7,X,I
q2,X,D
q3
q3,a,I
q3,b,I
q4,X,D
q4 q1,X,D q5,X,D q8,$,D

q5
q5,a,D
q5,b,D
q6,$,D
q6
q7,X,I
q6,X,D
q7
q3,$,I
q7,X,I
q8
qa
qa, ,D q8,X,D
-
Si la mquina se para en un estado para el que no hay transicin pueden ocurrir dos
cosas: que la cadena se rechace si se para en uno que no es de aceptacin o que la
cadena se acepte si lo era de aceptacin (de hecho, esta mquina parar siempre).
As, ya se puede mostrar la definicin formal completa4 de esta mquina:
M=({ q0, q1, q2, q3, q4 ,q5, q6, q7, q8, qa }, {a, b, $} {a, b, $, , X },
{(q0,a ) (q1,X,D), , (q8,X) (q8,X,D )}, q0, ,{ qa})
Al ser esta una mquina sencilla, tambin se poede representar mediante un
diagrama de transiciones (en este diagrama representamos la casilla en blanco con
):
Realmente es una definicin formal resumida, pues para que fuera estrictamente completa se deberan haber
explicitado todas las transiciones de la mquina.
27
Analizando este diagrama podemos ver que:

La rama q1, q2 y q7 comprueba para el smbolo a si el smbolo de posicin i de
es igual al smbolo de posicin i de la subcadena de la derecha.
La rama q5, q6 y q7 comprueba lo mismo para el smbolo b.
La rama q7, q3 y q4 vuelve al principio de la subcadena de la izquierda que queda
por comprobar para volver a empezar el proceso con el siguiente smbolo.
La rama q4 y q8 comprueba que, si no quedan ms smbolos de la primera
subcadena, tampoco queden ms smbolos en la segunda cadena. Si no quedan
entonces entra en el estado de aceptacin.
Cadenas que acepta: $ ; abaa $abaa ; a$a ; b$b
Cadenas que no acepta : $a ; 5 ;ab$a ; ab%ab ; ab $ba ; ab$a
Recordar que es la representacin de la cadena vaca. Otros autores la denotan como .
28
Mquinas de Turing
Ahora se va a simular la secuencia de transiciones para la cadena de entrada

abaa$abaa (se han sealado en negrita las configuraciones que corresponden al
dibujo de las instantneas de la introduccin informal.)
q0 abaa$abaa
X q1 baa$abaa
Xbaa q1 $abaa Xbaa $ q2 abaa

Xb q3 aa$Xabaa
Xb q1 aa$abaa
Xbaa q7 $Xabaa
Xba q1 a$abaa
Xba q3 a$Xabaa
X q3 baa$Xabaa
q3 Xbaa$Xabaa
X q4 baa$Xabaa
XX q5 aa$Xabaa XXa q5 a$Xbaa
XXaa q5 $Xbaa
XXaa$ q6 Xbaa
XXaa$X q6 baa XXaa$ q7 XXaa
XXaa q7 $XXaa
XXa q3 a$XXaa
XX q3 aa$XXaa X q3 Xaa$XXaa
XX q4 aa$XXaa
XXX q1 a$XXaa
XXXa q1 $XXaa
XXXa$ q2 XXaa
XXXa$X q2 Xaa
XXXa$XX q2 aa
XXXa$X q7 XXa
XXXa$ q7 XXXa
XXXa q7 $XXXa
XXX q3 a$XXXa
XX q3 Xa$XXXa
XXX q4 a$XXXa
XXXX q1 $XXXa
XXXX$ q2 XXXa
XXXX$X q2 XXa
XXXX$XX q2 Xa
XXXX$XX q7 XX
XXXX$X q7 XXX
XXXX$ q7 XXXX
XXXX q7 $XXXX
XXX q3 X$XXXX
XXXX q4 $XXXX
XXXX$ q8 XXXX
XXXX$X q8 XXX
XXXX$XX q8 XX
XXXX$XXX q8 X
XXXX$XXXX q8
XXXX$XXX q2 a
XXXX$XXXX qa
La mquina se parar con una configuracin de aceptacin (estado qa), luego la

cadena pertenece al lenguaje.
Consideremos ahora la cadena ab$ba, su computacin ser la secuencia de las
siguientes configuraciones:
q0 ab$ba
X q1 b$ba
Xb q1 $ba
Xba$ q2 ba
La cadena no pertenece al lenguaje porque la mquina se parar en una

configuracin de rechazo, ya que no hay definida ninguna transicin para el estado
q2 y el smbolo b y adems q2 no es de aceptacin.
--
29
A la secuencia finita de configuraciones que la mquina recorre en la aceptacin o

rechazo de una cadena, se le llama historial de cmputo de la mquina. Si la mquina entra
en un bucle infinito no podemos decir que exista un historial de computo (no sera finito).
2.7. DEFINICIN FORMAL DE LENGUAJE ACEPTADO POR UNA MT

Se acaba de ver como una MT acepta una cadena. Formalmente se dir que una MT
acepta la cadena si existe una secuencia de configuraciones en la que, si q0 es el estado de
inicio, la primera configuracin es
q0 , cada Ci+1 es una produccin de Ci , y la
configuracin final es de aceptacin de la forma qa , donde qa es un estado de

aceptacin, y y son subcadenas de smbolos de cinta. Simblicamente
q0
qa
Dicho de otra forma, una MT, M, acepta la cadena si la mquina para en un estado
de aceptacin. El conjunto de cadenas aceptadas por la MT es el lenguaje L(M) que
acepta esta MT. Ojo hemos definido un lenguaje aceptado por una MT, no decidido. Ms
adelante se ver esta matizacin.
3.- VARIACIONES A LA MT DEFINIDA

La descripcin mediante MT es un sistema muy robusto, pues admite mltiples
variantes sin por ello perder su potencia de computacin (aunque tampoco se ha conseguido
ampliar). Se van a ver diversas variaciones de MT, las cuales, segn la definicin dada,
sern un modelo computacional distinto. Como la entrada de un modelo computacional se
puede codificar para ser la entrada de otro modelo, el problema no cambiar. Se demostrar
que las distintas variantes de MT son computacionalmente equivalentes.
Se dice que una MT M simula a otra MT M, si para cada transicin de M hay una
secuencia de transiciones de M que realizan la misma operacin. De esta manera M realiza
lo mismo que M y quizs alguna operacin ms, es decir, el lenguaje aceptado por M est
incluido en el lenguaje aceptado por M.
Mquinas de Turing
30
Para demostrar que cualquier variante es equivalente en potencia computacional con la

mquina definida originalmente, se proceder de manera que, dadas dos mquinas M y M
primero demostramos que M simula a M y segundo que M simula a M. De esta manera
demostramos que M y M aceptan exactamente las mismas cadenas y, por tanto, el mismo
lenguaje.
Por la forma en que estn construidas las MT, generalmente solo se va a tener que
demostrar la simulacin en una direccin, pues la otra est implcita en la definicin de
forma general:
Si M es una ampliacin de M, M aceptar cualquier lenguaje de M.
Si M es una restriccin de M, M aceptar cualquier lenguaje que acepte M.
3.1. RETOMANDO LA MT QUE REALIZA CALCULOS

Cuando se defini la MT se hizo una introduccin a su concepto y posteriormente se
defini como aceptadora de un lenguaje. Hasta ahora lo que se ha hecho es comprobar que
la cadena pertenece al lenguaje, y para ello el procedimiento es parar en un estado de
aceptacin, no importando el contenido final de la cinta. La MT calculadora original utiliza
el concepto de aceptacin por parada: no existe un estado de aceptacin: parar siempre
cuanto termine el clculo, pudiendo ser en cualquier estado. El resultado se evala por el
contenido de la cinta cuando se para: La configuracin de la cinta muestra la solucin
buscada (si existe).
Un detalle importante de esta mquina es que, como es un clculo, la mquina
siempre parar con el resultado en su cinta. Este comportamiento coincide con la definicin
de algoritmo basado en la MT, ya que un clculo matemtico no deja de ser un
procedimiento (algoritmo) ya conocido de realizar algn computo.
La definicin formal de esta MT, donde se observa que no hay conjunto de estados
de aceptacin, ser
31
C=(Q, , , , q0, B)
Para introducir en la mquina los nmeros del clculo, primero se deben convertir
(codificar). Un mtodo muy utilizado es la notacin unaria6: dado un nmero natural con
valor n se codifica con n smbolos consecutivos (n unos o n ceros) y se separa por otro
smbolo de marcado (un cero o un uno respectivamente).
Ejemplo: Construir una mquina que multiplique dos nmeros naturales n y m
(mayores que cero). La mquina tendr una cadena inicial de n ceros seguida de un 1
y seguido de m ceros (0n 1 0m ), y se parar con la cinta conteniendo n veces m ceros
(0nm ). Los componentes de la definicin formal de la mquina sern
Q={ q0 ,., q13}
= {0,1}
= {0,1,B,X} donde B es la casilla en blanco y X un marcador
=
Supongamos que n=2 y m=3, la configuracin inicial ser:
La notacin unaria es histricamente la anterior a la posicional: se corresponde con el concepto de contar por
palotes; cuando se llega a un nmero determinado (por regla general cinco), estos se agrupan (se dibuja una
lnea de tachado) y se continua aadiendo palotes.
32
Mquinas de Turing
q0 001000
1- Marcamos el final de la cadena de entrada con un 1, que utilizaremos como

marcador de fin de original. A partir de este uno vamos a construir la solucin
(estados: de q0 a q1).
001000 q101
2- Retrocedemos hasta la izquierda de la cadena y eliminamos el primer cero (estados:
de q1 a q3).
q3 010001
3- Vamos al primer 1de la cadena. copiamos los m ceros que hay entre los dos unos, al
final de la cadena (utilizando la tcnica del marcado) (estados: de q4 a q5 y m veces
el bucle de estados q5 q6 q7 - q8).
01XXX10 q6 00
4- Una vez copiado hay que desmarcarlos (estados: q8, q9 y q10).
q10 010001000
5- Repetimos los pasos 2, 3 y 4 (m-1) veces ms, hasta que el principio de la cadena
sea un uno (estados: de q10 a q1 y el bucle de los anteriores).
q10 10001000000
6- Cuando terminemos las m veces, nos posicionamos en el segundo 1 de la cadena y
desde este incluido sustituimos el contenido de la cinta por smbolos de casilla en
blanco (estados: q10 a q13).
7- La mquina termina con el contenido en la cinta de 0nm .
1000 q12 1000000
q13 BBBBB000000
33
-Para demostrar que esta mquina tiene el mismo poder computacional que el modelo
con estado de aceptacin, se puede convertir esta mquina calculadora en una mquina
aceptadora de cadenas aadiendo, primero, un estado de aceptacin y luego relacionando
cada estado en el que paraba con la solucin en la cinta con el de aceptacin, aadiendo,
para cada uno de aquellos, tantas transiciones como smbolos de cinta tenga la mquina
original. Si el clculo termina siempre en el mismo estado, se marca este como de
aceptacin, no necesitndose aadir ninguno ms. De esta forma esta mquina simular el
funcionamiento de la mquina calculadora, aceptando cuando se pare con resultado sea
positivo y rechazando cuando el resultado sea negativo.
Ahora hay que demostrar lo contrario: una mquina que acepta un lenguaje
parndose en un estado de aceptacin, con cualquier configuracin en la cinta (se dijo que
no nos importaba lo que haba en ella cuando se paraba), se puede convertir, en una primera
fase, en otra MT que acepta el lenguaje con un contenido de cinta determinado (solucin),
que precisamente es el resultado del clculo. En una segunda fase se elimina el estado de
aceptacin, pues con el contenido en la cinta como solucin, se da por vlido el clculo (ver
variantes de MT, punto 3.2.3 para ver como se procede). As, la mquina calculadora
obtenida aceptar si tiene la solucin en la cinta y rechazar si tiene cualquier otro contenido
en la misma.
Por tanto, se ha encontrado la forma de simular, en una y otra direccin, las dos
mquinas, de manera que se ha demostrado que las dos aceptan el mismo lenguaje. En
conclusin, ambas mquinas tienen la misma potencia computacional. A partir de ahora se
van a considerar todas las MT como aceptadoras de cadenas.
3.2. OTRAS VARIANTES DE MT

Todas las variantes van a tener en comn una capacidad de almacenamiento infinito
y se van a diferenciar por una notacin distinta para la definicin formal y/o la funcin de
transicin. Por ejemplo, se puede observar que la definicin formal de
la mquina
calculadora no tena conjunto de estados de aceptacin. Cada una de las variantes que se
34
Mquinas de Turing
mostrarn se podrn utilizar tal cual o construir otras que sean una mezcla de varias de ellas
segn convenga, habida cuenta de que, con las debidas transformaciones, todas van a ser
computacionalmente equivalentes entre s.
3.2.1. Que solo tenga un estado de aceptacin y slo uno.
La definicin formal con esta restriccin sera
M= (Q, , , , q0, B, qa )
Es fcil convertir la MT original M en una que slo tenga un estado de aceptacin,
M, creando un estado de aceptacin nuevo, quitando la caracterstica de aceptacin a los
que antes la tenan y definir, desde cada uno de estos y para cada smbolo de cinta, una
transicin al nuevo estado de aceptacin (para que se pueda mover a este, sea el que sea el
contenido de la cinta) sin sustituir el smbolo actual, siendo la direccin del movimiento de
la cabeza indiferente. Por tanto M aceptar los lenguajes que acepte M.
Al ser un caso particular de la MT original en el que F slo tiene un estado de
aceptacin, tanto cualquier lenguaje aceptado por M tambin lo es por M. Por tanto M y M
aceptan exactamente los mismos lenguajes.
3.2.2. Que tenga un conjunto R de estados de rechazo
Si la mquina para, en lugar de hacerlo en cualquier estado que no sea de aceptacin
cuando la cadena no pertenezca al lenguaje, esta lo har en algn estado de rechazo. As, la
MT con esta ampliacin se define formalmente:
M= (Q, , , , q0, B, F, R )
donde R es un conjunto al que pertenecen los estados de rechazo.
Con esta variacin lo que realmente se est haciendo es definir completamente una
mquina determinista, de manera que, para cada par (estado, smbolo de cinta), hay una
transicin.
35
Para convertir la MT original M a esta, M.se aade a M un conjunto de estados R de

rechazo y, para cada entrada de la tabla de transiciones vaca, se aade una transicin a
cualquiera de los estados de R (la direccin del movimiento de la cabeza es de nuevo
irrelevante). M aceptar o rechazar la cadena si M lo haca originalmente, luego M
aceptar los lenguajes que acepte M.
Convertir M en la original, M, bastara con eliminar los estados de rechazo y las
transiciones hacia ellos, de manera que M parar en cualquier estado que no es de
aceptacin si la mquina con R paraba en un estado de rechazo y continuar aceptando
cuando M acepte la cadena, luego M aceptar los lenguajes que acepte M. Por tanto, M y
M aceptarn exactamente los mismos lenguajes.
Una variante basada en esta misma, es aquella en la que la mquina tiene slo un
estado de rechazo, donde la mquina se define como
M= (Q, , , , q0, B, F, qr )
Es fcil demostrar que esta es equivalente a la anterior utilizando el mismo mtodo
que para la variante de un solo estado de aceptacin.
3.2.3. Una vez aceptada la cadena, el contenido de la cinta sea un mensaje de aceptacin
Esta variante es la que hemos utilizado para convertir una MT que acepta un
lenguaje en una MT que realiza un clculo. Es posible convertir una MT, M, que se para con
cualquier contenido en la cinta en otra MT, M, que acepta con un contenido especial, que
llamamos mensaje de aceptacin.
Diremos que acepta la cadena con un mensaje de confirmacin y la rechaza con
cualquier contenido en la cinta. Convertir M en M es fcil de hacer, sustituyendo el estado
de aceptacin original (si son varios se convierte primero para que solo tenga uno) por una
ampliacin de la MT que borre la cinta y escriba un mensaje de aceptacin. M aceptar el
lenguaje si lo haca M, es decir los lenguajes aceptados por M tambin lo sern por M.
36
Mquinas de Turing
En el ejemplo del lenguaje L={$ /
{a + b}* } con una entrada abaa$abaa, la
mquina termina aceptndola, teniendo una configuracin en la cinta XXXX$XXXX qa .

Se puede modificar la MT para que borre esta configuracin al final y la sustituya por un
mensaje de aceptacin, por ejemplo Y, donde Y es un nuevo smbolo de cinta.
La mquina original es una generalizacin de esta variacin, por lo que cualquier
lenguaje que acepta M tambin ser aceptado por M. Por tanto M y M aceptan
exactamente los mismos lenguajes.
3.2.4. Que se permita no mover la cabeza en una transicin
Se permite a la cabeza no moverse cuando se cambia el valor de la casilla actual. En
este caso, no es vlido utilizar el trmino movimiento para una transicin (se dijo que se
poda utilizar como sinnimo en algunos supuestos). As la mquina queda definida
formalmente con
M= (Q, , , , q0, B, F )
(igual que la original) y la funcin de transicin cambia su notacin por
: Q x Q x x S
con S= {I, D, E} donde E es la inicial en espaol de Estacionario (tambin se puede ver S
de Stationary en ingls)
Otra posible funcin de transicin equivalente podra ser (o se realiza un movimiento
con sustitucin o se deja estacionaria la cabeza):
: Q x Q x (
S)
Como se observa en la tabla siguiente, la equivalencia de transiciones entre las

funciones de transicin mostradas y la de la MT es casi inmediata, por lo que M aceptar los
lenguajes que acepte M, y viceversa. Una transicin sin movimiento se puede simular, en la
mquina original, con una transicin adicional que haga una vuelta atrs al smbolo anterior.
37
Una transicin de la mquina original (sustitucin y movimiento) se puede simular, en la

segunda fila, con dos transiciones y un estado adicional simulando primero la sustitucin de
smbolo y luego el movimiento.
(Q x )
(q,a)(p,b,E)
(q,a)(p,a,I)
(q,a)(p,b,I)
(q,a)(p,a,D)
(q,a)(p,a,D)
(q,a)(p,b)
(q,a)(p,I)
(q,a)(p,b)
(q,a)(p,D)
(q,a)(p,b)
Q x x S
(Q x )
Q x ( u S)
(p,b)(p,I)
(Q x )
(q,a)(p,b,D)
QxxS
(p,b)(p,b,I)
(q,a)(p,a,I)
(q,a)(p,b,I)
(p,b)(p,D)
(q,a)(p,a,D)
(q,a)(p,a,D)
3.2.4. Que la Unidad de control tenga una memoria finita de smbolos

En el punto 2 se ha definido la MT con la unidad de control en el estado qi, y con un
nmero finito m de celdas de almacenamiento temporal. Estas celdas podrn memorizar
algn smbolo de cinta en algn momento de la computacin para utilizarla en otro
momento de la misma.
Antes de definir formalmente la MT que simula esta unidad de control, primero se
debe redefinir el conjunto de estados. Si Mi representa cada una de las celdas de
almacenamiento, se define un estado como
Qm = {Q x M1 x M2 x M3 xx Mm}
donde cada Mi podr contener cualquier smbolo de cinta de la mquina. Es decir, cada
estado ahora ser una tupla del producto cartesiano de cada estado original por el alfabeto de
cinta para cada una de las celdas de memoria. As, se define la mquina M como
M= (Qm, , , , (q0,B1,B2, B3,Bm),B, Fm)
donde Fm
Qm y cada Bi en el estado inicial (para 0 < i m), es el contenido de cada
memoria, que en el estado inicial ser el smbolo de casilla en blanco.
38
Mquinas de Turing
La funcin de transicin ahora ser

: Qm x Qm x x S
donde Qm = Qm - Fm y en cada transicin se podr cambiar, o no, el contenido de alguna o
todas las memorias.
Para mostrar el funcionamiento de esta mquina, se va a utilizar el ejemplo informal,
el cual se va a modificar para que tenga una celda de memoria en su unidad de control. Si
L ={$ /
donde
{a+b}*}
= {a,b,$}
y donde = {a,b,$, ,X}

Se va a utilizar la memoria para identificar si el elemento i-simo de la subcadena
de la izquierda es igual al elemento i-simo de la subcadena de la derecha. Los smbolos
de cinta para la memoria sern {a,b, }. La tabla de transiciones ser la siguiente (observar
que no se han dibujado todas las filas correspondientes a Qm, ya que algunas no tienen
trasiciones definidas):
39
a
q0, [q1,a],X,D [q1,b],X,D
[q8,],$,D
q1,a
[q1,a],a,D
[q1,a],b,D
[q2,a],$,D
q1,b
[q1,b],a,D
[q1,b],b,D
[q2,b],$,D
q2,a
[q7,a],X,I
[q2,a],X,D
q2,b
[q7,b],X,I
[q2,b],X,D
q7,a
[q3,a],$,I
[q7,a],X,I
q7,b
[q3,b],$,I
[q7,b],X,I
q3,a
[q3,a],a,I
[q3,a],b,I
[q4,a],X,D
q3,b
[q3,b],a,I
[q3,b],b,I
[q4,b],X,D
q4,a
[q1,a],X,D [q1,b],X,D [q8, ],$,D
q4,b
[q1,a],X,D [q1,b],X,D [q8, ],$,D
q8,
qa,
[qa, ], ,D [q8, ],X,D

-
Las transiciones se pueden representar de una manera ms concisa. Si Z e Y son la

representacin de un smbolo de cinta cualquiera, pudiendo ser en este caso a o b
indistintamente, se pueden agrupar las transiciones. Por ejemplo, las transiciones [q0, ], a =
[q1, a],X,D y [q0, ], b = [q1, b],X,D tienen la misma estructura, diferencindose solo por el
smbolo en la cinta. Si se sustituye por Z, se podrn agrupar las dos transiciones en una: [q0,
], Z = [q1, Z],X,D.
Para la tabla anterior las transiciones agrupadas podrn ser (se marca en negrilla las
transiciones que realmente utilizan la memoria):
[q0, ], Z = [q1, Z],X,D
[q0, ], Z = [q8,],$,D
[q1,Z],Y = [q1,Z],Y,D
[q1,Z], $ = [q2, Z],$,D
[q2, Z],X = [q2, Z],X,D
[q2, Z],Z = [q7,Z],X,I
[q7,Z], $ = [q3, Z],$,I
[q7,Z], X = [q7, Z],X,I
[q3,Z],Y = [q3,Z],Y,I
[q3,Z], X = [q4, Z],X,D
[q4, Z],Y = [[q1, Y],X,D
[q4, Z], $ = [q8, ],$,D
[q8, ], = [qa, ], ,D
[q8, ], X = [q8, ], X,D
Para convertir esta mquina M con transiciones agrupadas en una que no tenga
memoria, M, procedemos de la siguiente forma:
Mquinas de Turing
40
Se expanden las representaciones de smbolos de cinta agrupados (en nuestro caso Z

e Y). El resultado se plasma en una tabla de transiciones (como la que se ha
mostrado en el ejemplo).
Para cada estado de Qm, se le asigna un nombre de estado de la mquina sin

memoria y se sustituye esta asignacin en la tabla. El resultado es una tabla de
transiciones sin memoria.
Se comprueban las filas de la tabla para eliminar aquellos estados que tengan las
mismas transiciones.
Toda cadena aceptada por M ser aceptada por M, luego M aceptar los lenguajes que
acepte M. La mquina original M es un caso particular de M sin memoria, luego M
aceptar cualquier lenguaje que acepte M. Por tanto, M y M aceptan exactamente los
mismos lenguajes.
Continuando con el ejemplo, si se aplican estos pasos, el resultado es la tabla de
transiciones de la mquina original (no tiene porqu ser as).
La representacin con el diagrama de transiciones ser igual que sin memoria, con la
salvedad de que los estados estarn etiquetados ahora por la tupla estado (qi , Z1, Z2, . Zm)
donde cada Zi ser el contenido de la memoria i.
3.2.5 Cinta con varias pistas
Con anterioridad se dijo que un smbolo de cinta no tiene porqu ser un solo
carcter; pues bien, este es el caso. Se divide la cinta en bandas paralelas, que se van a
llamar pistas, y, a su vez, se van a dividir en casillas tal como se hizo con la cinta nica,
resultando en una matriz con tantas filas como pistas y con un nmero infinito de columnas
a ambos lados de la cabeza.
Hay que tener en cuenta que no es lo mismo un smbolo de cinta y un smbolo de
pista. Ahora un smbolo de cinta va a ser una tupla de i smbolos de pista, donde i es el
nmero de pistas. Para ello, la mquina acceder solidariamente al contenido de todas las
casillas de la misma columna, es decir, acceder a la i-tupla de smbolos de pista.
41
El conjunto de smbolos, para cada pista, podr ser el mismo o distinto y el conjunto
de smbolos de cinta de la mquina sern las tuplas pertenecientes al producto cartesiano de
los conjuntos de smbolos de todas las pistas. Si se tienen i pistas, y cada k (para 1 k i)
es el conjunto de smbolos de la pista k, el alfabeto de cinta de M ser el conjunto de ituplas
= {1 x 2 x 3 xx i}
Y un smbolo de cinta de M ser, si estamos en la columna k, una i-tupla de
smbolos atmicos de la forma
(Sk1, Sk2, Sk3,.Ski)
Una posible presentacin de la MT de varias pistas podra ser
Una forma tpica de utilizar una mquina de este tipo es colocar la cadena de entrada
en la primera pista y utilizar el resto para marcar lo que se necesite (que se ha visitado un
smbolo, recordar una posicin, dar un mensaje de aceptacin.). Al principio, todas las
pistas estn en blanco, y a continuacin se introduce la cadena de entrada. En este instante
todas las pistas, a excepcin de la primera, estn vacas. As cada smbolo del alfabeto de la
mquina ser una i-tupla del conjunto
= { x B2 x B3 x.xBi}
42
Mquinas de Turing
donde es el alfabeto de la cadena de entrada en smbolos atmicos. La definicin formal

de la mquina de varias pistas ser
M= (Q, , , , q0, (B1,B2,B3,.Bi), F )
donde (B1, B2, B3 ,., Bi) es el smbolo de casilla en blanco. La funcin de transicin sera
: Q x Q x x S
que, desglosada en las partes descritas, queda como
: Q x (1 x 2 x 3 xx i ) Q x (1 x 2 x 3 xx i ) x S
Por ejemplo:
(p, (Z1,Z2,Z3,..,Zk ))
(q , (Y1, Y2, Y3, .., Yk ), I)
Significa que una MT en un estado p y smbolo de cinta (Z1,Z2,Z3,..,Zk), realizar un

movimiento al estado q, escribiendo en la cinta el smbolo (Y1, Y2, Y3, .., Yk ) y moviendo
su cabeza a la Izquierda.
Para simular una mquina de Turing M de varias pistas con una M de una sola pista
con smbolos de cinta atmicos, para M se definir:
Si = { x B2 x B3 x.xBi}, es el alfabeto de mquina de M
= 1
{#,@}. Estas ltimas son smbolos de marca
adicionales.
La unidad de control va a tener i celdas de memoria. Esto es vlido dado que el

nmero de pistas es finito.
Primero se concatena el contenido de cada una de las pistas en la cinta de M, separadas

por el delimitador #. El principio de la primera cadena y el final de la ltima tambin se
43
delimitan con #. Para denotar la posicin de la cabeza en la cinta de M, se introducir la

como marca @ y se har en cada uno de los contenidos de las pistas introducidas en la cinta
de M. Si est en la tupla de entrada (,B2,B3,.Bi) para M, la cinta de M quedar con
(i+1) delimitadores e i cadenas entre ellos, cada una marcada con la posicin de la cabeza.
En el estado inicial la cinta de M ser:
#@#@ B2#....# @ Bi #
Para cada transicin de M se simular la siguiente secuencia de transiciones en M:
M recorrer la cinta hasta el ltimo delimitador #, procediendo en su recorrido a

almacenar en la celda de memoria Mk (para 1 k i) el smbolo actual de la cinta k
(elemento k de la i-tupla de M). De esta forma la unidad de control tiene acceso al
smbolo de cinta actual de M (i-tupla).
Aplicar la transicin de M. M recorrer de nuevo la cinta y en cada subcadena que

representa cada pista, en la posicin de la marca de cabeza, se escribe, dependiendo
del smbolo en la memoria y el estado, el smbolo que indica la transicin, y realiza
el movimiento que determina S. Utilizar la memoria para almacenar el smbolo de
pista de M despus de la transicin.
Si en una subcadena que representa una pista, despus del movimiento la cabeza,
esta apuntara al delimitador, a partir de este (inclusive) hay que desplazar una casilla
a la derecha el resto de subcadena, y aadir un smbolo de casilla vaca en el hueco
que hemos hecho. Por ejemplo, se ha marcado en negrilla la situacin y subrayada la
subcadena desplazada a la derecha
# @ #@ Bqx#....# @ B #
# @ #@ BqxB#....# @ B #
M acepta la cadena en el mismo estado en el que lo hara M, luego M aceptar los

mismos lenguajes que aceptara M.
Se dijo con anterioridad que la codificacin de la entrada a una MT es indiferente, ya
que se puede convertir con otra MT. La ampliacin de la cinta a varias pistas no deja de ser
eso mismo: una codificacin distinta para una misma entrada y por tanto esta MT tampoco
44
Mquinas de Turing
ofrece una mejora con respecto a la MT original: la mquina de varias pistas es una
generalizacin de la mquina de una pista (tuplas de un solo elemento) y por tanto cualquier
lenguaje aceptado por la mquina de pista nica (ya se vio que la MT con memoria es
equivalente a la MT sin memoria), lo ser por una mquina de una cinta con varias pistas.
Por tanto, aceptan exactamente los mismos lenguajes.
3.2.6. MT con varias cintas
Esta variante, que es una generalizacin de la MT con una cinta, es importante
porque con ella se simula de manera directa el comportamiento de un computador. El
hecho de que la MT de una cinta sea un caso particular de la de varias cintas hace que el
lenguaje aceptado por la primera tambin sea aceptado por la segunda. Despus de definir
esta mquina se proceder a demostrar que existe una MT de una cinta que simula el
funcionamiento de una mquina con varias cintas, y por tanto cualquier lenguaje aceptado
por una MT de una cinta tambin lo ser por la MT de varias cintas. Esto demuestra que una
mquina con una cinta acepta exactamente los mismo lenguajes que una mquina con varias
cintas.
Esta MT estar compuesta por varias cintas como soporte de almacenamiento y una
unidad de control
que estar en uno de entre un conjunto finito de estados. Tendr
asociadas tantas cabezas de lectura/escritura como cintas, independientes todas ellas entre s.
En cada paso del clculo la unidad de control va a tener en cuenta el estado en el que se
encuentra y el contenido de la casilla a la que apunta cada una de las cabezas.
45
En el estado inicial, la primera cinta contendr la cadena de entrada, codificada en el

alfabeto de entrada, y el resto de cintas estarn en blanco (se podrn utilizar durante la
computacin para comprobar que se ha visitado un smbolo, recordar una posicin, dar un
mensaje de aceptacin.). La cabeza de la cinta 1 estar apuntando al primer smbolo de la
entrada y la cabeza en el resto de cintas podr apuntar a cualquier casilla, dado que aquellas
siguen en blanco.
Se define un nico alfabeto de cinta para la mquina, de manera que cualquier cinta
podrn contener cualquier smbolo de este. A este alfabeto de cinta, pertenece el alfabeto de
la mquina (en el que estar codificada la entrada en la primera cinta). Podramos haber
definido un alfabeto de cinta para cada una de ellas, pero esto, adems de innecesario, solo
complicara la mquina, ya que el alfabeto de cinta para la mquina se podra obtener por la
unin de todos los alfabetos independientes de cinta (como se hizo en la definicin de MT
de varias pistas).
La MT de varias cintas se define formalmente como
M= (Q, , , , q0, B, F )
Se ha dicho que cada cabeza es independiente; esto nos lleva a que, para cada cinta,
haya una funcin de transicin de la forma
: Q x Q x x S
(es la misma que hemos definido para la mquina de una cinta, con la excepcin de S,
definida anteriormente con la transicin estacionaria7). Si la mquina tiene k cintas, se podr
generalizar la funcin de transicin a
': Q x k Q x k x Sk
Una MT con transicin estacionaria se puede simular con una MT si transicin estacionaria. Se define as la
mquina para que esta sea ms simple.
Mquinas de Turing
46
As, la funcin de transicin en una MT con k cintas pertenecer al producto

cartesiano de (la notacin subndice se debe identificar como nmero de cinta y no como un
alfabeto de cinta distinto):
': Q x 1 x 2 x 3 xx k Q x 1 x 2 x 3 xx k x S1 x S2 x S3 xx Sk
Por ejemplo, la transicin:
(p, Z1, Z2,Z3,.., Zk ) (q, Y1, Y2,Y3,.., Yk, I1, D2, D3,..,Ek)
significa que una MT con k cintas que est en un estado p y con cada cabeza i de
lectura/escritura apuntando al smbolo Zi de cinta, realizar un movimiento a un estado q,
sustituyendo cada Zi por el Yi que corresponda y realizando el movimiento que corresponda
a cada cabeza i.
Ya se ha mencionado que esta mquina va a tener la misma potencia que la de una
cinta con pista nica. Para demostrarlo, se utilizar un paso intermedio: simular esta MT con
k cintas, M, con una MT, M, de una cinta dividida en 2k pistas y que adems va a tener
k+1 memorias (antes ya se demostr que la MT de varias pistas es equivalente a una MT de
una cinta con pista unitaria, y que la MT sin memoria es equivalente a la MT con ella).
Primero se visualizan las k cintas en una cinta de 2k pistas, de manera que la pista 2i
(para 1 i k) es el contenido de la cinta i y la pista 2i-1 es un marcador a la posicin actual
de la cabeza (pistas impares marcadores, pistas pares contenido de la cinta).
El alfabeto de pista para las impares ser {B,@} y para las impares ser el mismo
que para las pistas de M, . El alfabeto de cinta de M ser un conjunto de tuplas del
producto cartesiano de la forma (la notacin subndice se debe identificar como nmero de
cinta y no como un alfabeto de cinta distinto)
={ {B,@}x 1 x {B,@}x 2 x {B,@}x 3 x x {B,@} x k }
47
En el dibujo de M con 2k pistas, el smbolo de cinta actual ser la tupla

( @,S(1,0), B,S(2,0), B, S(3,0) , ... , B, S(k,0) )
Para cada movimiento de M, M tendr las siguientes transiciones:
La cabeza de M buscar consecutivamente a los k marcadores de posicin de las k

cintas, y almacenar en cada memoria de la UC el contenido de la casilla que marca.
Para saber en qu cinta est (pista 2i = cinta i) utiliza la ltima celda de memoria de
la UC. Una vez hecho esto, tenemos el estado y el smbolo actual de cada cabeza de
M almacenado en M.
Para las pistas correspondientes a cada cinta i, M vuelve a leer el contenido del
marcador de la pista 2i-1 y la casilla correspondiente de la pista 2i: Escribe el
smbolo que determina la transicin correspondiente a la cinta i y mueve la marca
(izquierda, derecha o estacionaria) a la casilla que determine la transicin. Al final
de las 2k pistas, M tendr varias tuplas que representan el contenido de las k cintas
y la posicin de cada cabeza sobre ellas despus del movimiento. Utilizar la
memoria para almacenar el smbolo de cada cinta de M despus de cada transicin.
Mquinas de Turing
48
Los estados de aceptacin de M sern los estados de aceptacin de M, luego

cualquier lenguaje aceptado por M tambin lo ser por M.
En el ejemplo del dibujo, dada la transicin de M:

( p, S(1,0), S(2,-1), S(3,1), ,S(k,+2) ) (q, S(1,0), Z, S(3,1), ,S(k,+2) ,I,I,D,,E)
M buscar primero la tupla S(1,0), (@, S(1,0), B, S(2,0), B, S(3,0), ,B , S(k,0)),

almacenando S(1,0), en la memoria 1, luego la tupla correspondiente a la segunda
cinta (B, S(1,-1), @ , S(2,-1), B, S(3,-1,.,B,Sk-1), almacenando S(2-1) en la memoria 2 y
as sucesivamente hasta tener en las k primeras memorias los smbolos actuales de
M.
La transicin que se est computando modifica el contenido de la segunda cinta, y

mueve cada uno de los marcadores. As el contenido de la cinta en M quedar:
Para reducir M a una MT con una sola cinta, M, se aplicara la demostracin antes
dada para la MT de varias pistas: Las distintas pistas 2i se concatenan en una sola pista,
introduciendo el marcado de posicin de cabeza en cada pista 2i. As, en nuestro ejemplo
partiramos del contenido en la cinta de M con8
Aunque aqu se represente una columna con una fila por cada pista, realmente es una sola cinta con todas
concatenadas en el orden de las filas
49
#S1,-3 S1,-2 S1,-1@ S1,0 S1,+1 S1,+2 S1,+3
# S2,-3 S2,-2 @ S2,-1S2,0 S2,+1 S2,+2 S2,+3
# S3,-3 S3,-2 S3,-1S3,0 @ S3,+1 S3,+2 S3,+3
.
.
# Sk-3 Sk-2 Sk-1Sk Sk+1 @Sk+2 Sk+3#

y despus de los sucesivos movimientos de M, que simulan un movimiento de M, M
tendr un contenido en su cinta
#S1,-3 S1,-2 @ S1,-1 S1,0 S1,+1 S1,+2 S1,+3
# S2,-3 @ S2,-2 Z S2,0 S2,+1 S2,+2 S2,+3
# S3,-3 S3,-2 S3,-1S3,0 S3,+1 @ S3,+2 S3,+3
.
.
# Sk-3 Sk-2 Sk-1Sk Sk+1 @Sk+2 Sk+3#

Para representar las transiciones de una MT de varias cintas tambin se utilizarn
tablas y diagramas de transiciones:
Tabla de transiciones.- Tendr una fila por cada uno de los estados y tendr una
columna por cada tupla del producto cartesiano de los k alfabetos de cinta. Cada
entrada contendr la 2k-tupla con los smbolos a sustituir y el desplazamiento de las
cabezas correspondiente.
Diagrama de transiciones.- El diagrama ser el mismo que la MT con una cinta, con
la excepcin de que la relacin entre estados (arista del grafo) se etiqueta con todas
las transiciones posibles para esos dos estados en cada una de las cintas, separados
por una barra.
50
Mquinas de Turing
3.3.7. MT no determinista (MTN)
Como ya es sabido, el no determinismo de una mquina puede ser de dos tipos: que
la mquina no est totalmente definida y que, para un estado y un smbolo de cinta, la
mquina pueda tener ms de una opcin posible.
Ya se ha dicho que el modelo de la mquina original podra incurrir en el primer tipo
de no determinismo y que la consideramos determinista ya que se define con una funcin
(solo una posible transicin) y sin estados de rechazo para simplificar su representacin. Por
tanto, se considerarn no deterministas a las del segundo caso, en las que cada transicin,
para un estado y un smbolo de cinta, ser un conjunto de movimientos posibles, en lugar de
un solo movimiento. As, una mquina no determinista, MTN, para un mismo estado y
mismo smbolo de cinta puede no tener transicin definida, tener un nico movimiento o
tener la posibilidad de varios movimientos. En los dos primeros casos se comporta como la
MT ya vista, mientras que cuando ocurre el tercero, la mquina sigue todos los posibles
caminos en paralelo hasta un estado de aceptacin. En paralelo significa que no se coge un
camino y se sigue hasta que se rechace o se acepte, sino que se producen las configuraciones
sucesoras de cada camino a la vez. Si uno de los caminos llega a un estado de rechazo, este
camino se desecha y si es el ltimo posible, entonces se rechaza la cadena.
Se dice que una MTN acepta un lenguaje, si existe algn camino que lleve desde la
configuracin inicial a una configuracin de aceptacin. Observar que se habla de
posibilidad de existencia de un camino, no de produccin por la funcin de transicin.
La definicin formal de la MTN, M, ser
M = (Q, , , , q0, B, F)
donde es el conjunto de transiciones
{Q x (Q x x S) / para todo Q ,, S }
Para representar el funcionamiento de M, se representan los posibles

movimientos y los posibles caminos mediante el recorrido en amplitud de un grafo: los
51
nodos sern las configuraciones y las aristas las transiciones. El nodo raz va a ser la
configuracin de inicio. Cuando la transicin tenga varios posibles movimientos, cada una
de las configuraciones resultantes ser un nodo hijo del anterior. Los distintos caminos se
seguirn en paralelo, desechndose aquel para el que no haya transicin posible. Se aceptar
la cadena si llegamos por algn camino a un estado de aceptacin. Esta aceptacin ser la de
menor profundidad en el grafo.
Para obtener la MT determinista (MTD) M, que simule la MTN, M, se construye
una MT de tres cintas (ya sabemos que es equivalente a una MT de una cinta) que va a
simular el recorrido en anchura del grafo implcito asociado a las transiciones de M.
Definimos M = (Q, , , , q0, B, F) donde
Q es el conjunto de estados que resulte de la conversin
, q0, B y F igual que en M.
{#,@} .- donde # es un separador de configuraciones y @ es un
separador de configuraciones que indica que es la actual.
{Q x (Q x x S) / para todo Q ,, S }
La primera cinta contendr la cadena de entrada y no se va a modificar. La segunda cinta

contendr una cola FIFO de configuraciones de la mquina que aun no se han evaluado. La
tercera cinta servir para evaluar la configuracin actual de M. El algoritmo de M realizar
la siguiente secuencia:
Copia en la cinta 1 la cadena de entrada y en las cintas 2 y 3 la configuracin inicial

de M, esto es, el contenido de la cinta junto con el estado inicial de M. En la cinta 2
se copiar precedida por la izquierda con @ (configuracin actual).
(2) Para la configuracin de la cinta 3, se comprueba si es de aceptacin, en cuyo

caso M se detiene aceptando la cadena. Si no es de aceptacin obtiene de la UC las
Mquinas de Turing
52
transiciones para esta, y guarda las configuraciones resultantes al final del contenido
de la cinta 2, precedidas por # como separador de configuraciones.
En la cinta 2 desmarcamos la configuracin actual (sustituimos @ por #) y

marcamos como actual la siguiente configuracin. Si no hay una configuracin al
final de la cinta, entonces es que la mquina debe parar rechazando la cadena.
Borramos el contenido de la cinta 3, copiamos el ella la configuracin actual y

pasamos al segundo punto anterior (2).
Como ya se ha dicho, el recorrido en anchura simula el funcionamiento de M, en cuyo

cas M aceptar con la misma configuracin que aceptaba M, por lo que hemos demostrado
que los lenguajes aceptados por una MTN tambin lo sern por una MT determinista.
Una consecuencia inmediata de la definicin de la MTN es que la MT determinista es un
caso especial de esta (conjuntos de transiciones de solo un elemento), luego los lenguajes
aceptados por la MT determinista, tambin lo sern por la MTN. Por tanto, MTN y MTD
aceptarn exactamente las mismas cadenas.
Para representar una MTN en una tabla de transiciones habr que modificarla para
que en cada entrada de la tabla, en lugar de una tupla con la transicin, puede contener
varias tuplas. Para hacerlo con el diagrama de transiciones, la diferencia estar en que una
arista podr tener ms de una transicin en su etiqueta (hay que etiquetarlas de forma
distinta a la mquina de varias cintas, por ejemplo en lneas distintas). A la hora de simular
el funcionamiento, lo haremos con el grafo antes descrito y realizando el recorrido en
anchura.
3.3.8 MT con cintas semi infinitas
Esta mquina es una restriccin a la MT original, de manera que ahora la cinta es
infinita slo por el lado derecho, y no por los dos lados. La cadena se introducir en las
casillas ms a la izquierda de la cinta y la posicin inicial de la cabeza ser la primera casilla
de la izquierda. Otra restriccin de esta mquina es que no est permitido escribir smbolos
de casilla en blanco.
53
Para convertir una MT original M, en una MT de cinta semi infinita M, que descrita
formalmente es
M= (Q, , , , q0, (B,B), F)
lo primero que hay que hacer es partir la cinta de M en dos mitades por la posicin indicada
por la configuracin inicial de M. Despus se convierten las dos mitades en una cinta semi
infinita de dos pistas, de manera que, si asociamos las posiciones de la cinta de M con un
nmero entero, la pista superior sern las posiciones positivas incluido el cero y el resto en
la segunda pista, pero en orden invertido y precedidas por * como marcador de comienzo de
cinta. As, para la cinta de M con los subndices como posiciones, X como smbolos de cinta
y B como smbolo de casilla en blanco
B -m B -(m-1) B -3 B -2 B -1 X0 X1 X2 X3. Xm-1 Xm B m+1
dar como resultado, para M, una cinta de dos pistas semi infinitas de la siguiente forma
El segundo paso es modificar M para convertirla en una mquina que no escriba

casilla de espacio en blanco. Esto se har aadindole un smbolo de cinta B para simular
los smbolos de casilla vaca, de manera que una transicin de M (p, X)(q,B,S), se
conviertir en (p, X)(q,B,S), lo cual no afectar al funcionamiento de M.
El alfabeto de M ser = x B, dado que los smbolos de cinta ahora son duplas: para
cualquier elemento a
, el equivalente en es (a,B).
Al principio la cinta en M est vaca (las dos pistas). Se introduce la entrada a partir de
la primera casilla, que sern pares del tipo (a,B), y se posiciona la cabeza sobre la primera
columna. Antes de simular los estados de M, se debe marcar el principio de cinta con * en la
primera casilla de la segunda pista. Para ello se define Q como { q0, q1}
{Q x P},
donde q0y q1 son los estados que marcan el principio de cinta, en la segunda pista, con *,
Q es el conjunto de estados de M, y P es una memoria que indica si la mquina se encuentra
54
Mquinas de Turing
en la pista Superior o la Inferior; as el contenido de P = {S,I} o, si son las iniciales de las

palabras en ingls Up y Down, P = {U,D}.
El alfabeto de cinta de M, sern pares de smbolos de cinta de M al que se le aaden
pares de la forma (X,*) para todo X de . Formalmente
= ( x )
( x *)
Una vez definidos los estados y los smbolos de cinta de M, se puede especificar q0 y
q1 de manera que, al iniciar la ejecucin, las dos primeras transiciones sean
((q0,B),(a, B)) (q1,B), (a, *), D) que marca la primera casilla de la cinta inferior
con * .
((q1,B),(X, B)) ((q0,S), (X, B), I) para volver a la primera casilla de la cinta
superior.
Ahora ya se pueden simular las transiciones de M en estas dos pistas de M, de manera

que, para una transicin (p,X) (q,Y,S)
Todas las transiciones de M que se realicen a la derecha de la posicin inicial de la

configuracin de inicio sern iguales a las de M, marcando la memoria como S y
modificando slo el smbolo correspondiente a la primera pista.
((p,S),(Y,X)) ((q, S) , (Z, X),S) para cualquier smbolo de cinta de M.
Todas las transiciones de M que se realicen a la izquierda de la posicin inicial de la

configuracin de inicio lo sern en direccin contraria, marcando la memoria como I
y modificando slo el smbolo correspondiente a la segunda pista.
((p,I),(X, Y)) ((q, S) , (X, Z), )
para cualquier smbolo de cinta de M, siendo
el complementario de S (si la
transicin de M es a la izquierda, en M es a la derecha y viceversa)
55
El punto crtico de M est cuando pasamos de una pista a otra, y esto lo hacemos
utilizando el marcador *. Esta situacin se da cuando M ha vuelto a la posicin inicial, ya
sea desde la izquierda (por la segunda pista) o desde la derecha (por la primera pista).
Para una transicin de M de la forma (p,X)(q,Y,D), en la posicin inicial en la que

se viene desde izquierda de la cinta, M estar en un estado (p, I) con smbolo actual
(X,*), para cualquier X de smbolos de cinta de M, y la transicin cambiar el estado
de la memora a S y realiza la sustitucin de la transicin de M
((p, I), (X,*))((q,S),(Y,*),D)
Para una transicin de M de la forma (p,X)(q,Y,I), en la posicin inicial en la que

se viene desde la derecha de la cinta, M estar en un estado (p, S) con smbolo
actual (X,*), para cualquier X de smbolos de cinta de M, y la transicin cambiar el
estado de la memora a I y realiza la sustitucin de la transicin de M
((p, S), (X,*))((q,I),(Y,*),D)
Por ltimo el conjunto de estados de aceptacin F de M sern duplas del producto

cartesiano F x P.
Podemos decir que M simula el funcionamiento de M en todo momento, aceptando la
cadena en los mismos estados que lo hara M y no escribiendo en ningn momento el
smbolo de casilla en blanco (B, B) que es una de las restricciones que tenamos. Por tanto
M aceptar los mismos lenguajes que acepta M. Al ser una restriccin sobre M, cualquier
lenguaje aceptado por M lo ser tambin por M y por tanto aceptarn exactamente los
mismos lenguajes.
4.- LENGUAJES DECIDIBLES Y RECONOCIBLES POR UNA MT

El hecho de que la MT que decida (que se pare) si la cadena de entrada pertenece o
no al lenguaje depende de este mismo y no de cmo se defina el modelo de la mquina. Si
identificamos las caractersticas del lenguaje del ejemplo del principio
56
Mquinas de Turing
L={$ /
{a + b}* }
se puede llegar fcilmente a la conclusin de que el conjunto de cadenas aceptadas es un

conjunto infinito contable (se puede definir una aplicacin sobre el conjunto
de los
nmero naturales). As mismo, si se analiza el lenguaje complementario al anterior (las

cadenas que no pertenecen al lenguaje), tambin se podr demostrar que se trata de un
conjunto infinito contable. Por tanto, se puede decir que este lenguaje es un conjunto
recursivo o, simplemente, que el lenguaje es recursivo. En el ejemplo propuesto, la MT
siempre va a parar: siempre identifica si la cadena pertenece o no al lenguaje. Este
comportamiento ser siempre el mismo al margen de la variante de MT utilizada.
Pero, recordemos, una MT tambin puede tener otro comportamiento: entrar en un
bucle sin fin. As, segn el comportamiento que tenga una MT se puede afirmar que
El lenguaje es decidible si la MT que lo acepta siempre se para: en estado de

aceptacin si la cadena es vlida y en cualquier otro estado si no lo es (se rechaza la
cadena). Los lenguajes decidibles por MT son precisamente los lenguajes recursivos.
El lenguaje es reconocible si la MT que lo acepta se para cuando la cadena

pertenece al lenguaje, pero, si la cadena no pertenece al lenguaje, no se sabe si la
mquina parar o si entrar en un bucle infinito. Los lenguajes reconocibles por MT
son precisamente los lenguajes enumerados recursivamente (RE).
Dentro de la jerarqua de lenguajes, los aceptados por las MT se denominan

estructurados por frases. Esto es as porque su estructura gramatical no tiene restricciones
(excepto que en el antecedente debe tener algn no terminal). Estos pueden ser decidibles o
solo reconocibles por la MT. Como se ver ms tarde, existen lenguajes que no son
reconocidos por las MT, los cuales no tienen ninguna estructura gramatical. El resto de
lenguajes inferiores en la jerarqua (los regulares y los independientes del contexto) son
todos decidibles. Para demostrar esto ltimo solo se tendr que construir una MT que simule
el funcionamiento de autmata finito o uno de pila respectivamente.
57
5. ALGORITMO (y 2)
El hecho de que un problema decidible (un lenguaje decidible) se pueda resolver con
una MT que siempre se para, constituye un punto importante en la teora de la decidibilidad.
Es ms, una MT que resuelve un problema decidible es la definicin formal de
algoritmo. De esta forma se puede afirmar que si, para un problema existe un algoritmo
que lo resuelve, entonces se dice que el problema (el lenguaje que lo representa) es
decidible por una MT.
Precisamente aqu es donde empiezan los problemas, ya que hay problemas
(lenguajes) para los que no hay un algoritmo que los solucione (que los decida) e incluso
hay otros para los que no existe ni siquiera una MT que los reconozca (luego se ver
porqu). Una MT que slo reconozca un lenguaje (un lenguaje RE), soluciona un problema
a medias, por lo que realmente no ser til en la resolucin de un problema.
Un algoritmo es el procedimiento seguido para resolver un problema por una
MT que siempre se para, y ya se ha visto que estos lenguajes son llamados decididibles.
Todo lenguaje para el que no haya esta MT, se dice que es indecidible (ya sea un
lenguaje reconocible o no por una MT).
6. CODIFICACIN DE LAS MT
Para demostrar que existen lenguajes que no son ni siquiera aceptados por las MT, se
va a proceder primero a codificar la entrada para que las cadenas sean binarias, esto es que
= {0, 1} (ya se ha dicho que el formato que tenga la entrada es irrelevante, pues se puede
codificar como se precise). Luego se codificar tambin la descripcin de la mquina como
una cadena binaria. Esta codificacin no es nica, pudiendo haber otras variantes. Un detalle
que servir ms adelante es que la longitud del cdigo resultante de la mquina ser finita,
pues su descripcin tiene un nmero finito de elementos.
Ejemplo: Volvamos a la MT que acepta el lenguaje L ={$ /
{a + b}* }. Lo
primero que hacemos es listar los elementos del alfabeto de la mquina y codificarlos en
binario: Cada smbolo se codificar con una cadena i ceros, donde i es la posicin dentro
de la lista ordenada, as, si ={a,b,$}
58
Mquinas de Turing
Orden
Smbolo
cdigo
00
000
Una cadena de entrada se codificar concatenando los cdigos de cada smbolo

separados por un uno. Esta codificacin es vlida porque cada smbolo tiene al menos
algn cero. As la cadena abaa$abaa se codificar como 010010101000101001010.
Ahora habra que construir una MT, M, cuya entrada fuese binaria, y que determinase
que hay el mismo nmero de grupos de ceros en el mismo orden y a su vez con el
mismo nmero de ceros (como se ve, el problema ahora es totalmente distinto, aunque
equivalente).
-Una vez obtenida la MT con alfabeto de entrada binario, que adems solo tendr un
estado de aceptacin (si tuviera ms de uno, se realizaran los cambios en la mquina que
correspondan) se va a codificar, tambin en binario, el modelo de MT definido por
M= (Q, , , , q0, B, qa )
Cdigo de los estados.- Poner los estados en una lista ordenada, de forma que el
primero sea el estado de inicio y el segundo el de aceptacin. Cada estado se
codificar con una cadena i ceros, donde i es la posicin dentro de la lista ordenada.
Smbolos de cinta.- Poner los smbolos de cinta en una lista ordenada, de forma que
los tres primeros smbolos de la lista sern 0, 1 y B, si estos existen en la mquina, y
a continuacin los dems. Cada smbolo de cinta se codificar con una cadena de i
ceros, donde i es la posicin dentro de la lista ordenada.
Sentido del movimiento.- Codificar con un cero a la izquierda y con dos ceros a la
derecha.
59
Transiciones.- Con la codificacin de sus elementos, su cdigo resultante se

obtendr concatenando la representacin de cada elemento e intercalando un 1 entre
cada uno de ellos. Esta codificacin es vlida pues cada elemento est representado
al menos con un cero.
Funcin de transicin.- Se ordenan las transiciones (el orden puede ser arbitrario), y
se concatenan, intercalando dos unos consecutivos entre cada una de ellas. Esta
codificacin es vlida pues en cada transicin nunca va a haber dos unos
consecutivos.
Ejemplo: supongamos la siguiente mquina, que acepta cadenas con solo unos y
cadenas con solo ceros:
M= ({q0, q1, q2, qa}, {0,1}, {0,1,B}, {[(q0,0) = (q1,0,D)], [(q0,1) = (q2,1,D)], [(q1,0) =
( q1,0,D)], [(q2,1) = (q2,1,D)], [(q1,B) = (qa, B, D)]}, [(q2,B) = (qa, B, D)]}, q0, B, qa)
Primero hacemos una lista ordenada tanto de los estados como de los smbolos de
cinta (el orden de los estados no es nico):
Estado
Cdigo
q0
qa
00
q1
000
q2
0000
Smbolo
0
00
000
Dada esta codificacin de elementos, la mquina quedar codificada:

M=
010100010100 11 010010000100100 11 00010100010100 11
000010010000100100 11 00010001001000100 11 000010001001000100

--
60
Mquinas de Turing
En este ejemplo se puede observar que esta es una de las muchas posibles
codificaciones para la misma mquina M. De hecho, el nmero de codificaciones para una
mquina M que acepte alguna cadena ser, si esta tiene un estado de aceptacin y en la cinta
tiene al menos los smbolos 0,1 y B:
(N estados-2)! * (N smbolos de cinta-3)! * (nmero de transiciones)!
Cmo identificamos cada codificacin? Porque plasmar cada cadena binaria es
tedioso adems de ilegible (ya sea de entrada o la codificacin de una mquina). Dado un
alfabeto = {0,1}, el conjunto de todas las cadenas binarias posibles (*) es infinito
contable ya que podemos asociar un nmero natural a cada una de las cadenas, es decir,
existe la funcin (f: *
). As, se ordenan todas las cadenas de * primero por longitud
y dentro de esta por orden binario, asignando en orden, a cada una, un nmero natural. As,
dada una cadena i , esta ser la i-sima cadena de *. Las primeras cadenas correspondern
al nmero:
9 = 1, 0 =2, 1=3; 00=4; 01=5; 10=6; 11=7; 000=8; 001=9; .
Para obtener la cadena binaria a partir del valor de i, decimos que la cadena isima es el valor decimal de la cadena obtenida de la concatenacin de 1 y :
i (10 = 1 (2
Dado que cualquier MT se codifica con una cadena binaria, i , entonces se puede
asociar a cada codificacin un nmero natural, de manera que podemos hablar de la MT isima, Mi. As mismo se puede asociar un nmero natural a cada una de las cadenas de
entrada de la mquina. Se puede observar que, al ser cadenas binarias, una cadena de
entrada cualquiera con nmero de orden n, sea la codificacin de la mquina Mn.
Smbolo de cadena vaca. Otros autores la denotan con
61
7.- LMITE DE LAS MQUINAS DE TURING

Si se comparan todas las cadenas de * con las codificaciones de MT, se puede
observar que hay muchas cadenas que no se corresponden con ningn cdigo correcto de la
descripcin de una MT. En este caso se considera que la cadena es el cdigo de una MT que
no hace nada (ya se dijo que era un estado sin transiciones), es decir L(MT) = . De esta
forma tenemos tantas MT posibles como nmeros naturales, luego podemos decir que el
nmero de MT es infinito contable.
Dado que el conjunto de todos los posibles subconjuntos de cadenas (todos los
posibles lenguajes) es el conjunto potencia de *, del que se sabe que es infinito incontable,
se llega a la conclusin de que hay ms lenguajes que MT posibles, es decir, habr lenguajes
que una MT no podr reconocer (aceptar).
En conclusin, vamos a tener problemas que son decidibles (recursivos), problemas
que no son decidibles, aunque aceptables por MT (enumerables recursivamente, RE), y
problemas indecidibles para los que no existe una MT capaz de aceptarlos (no RE).
Para demostrar la afirmacin de que hay ms lenguajes que mquinas de Turing, se
va a utilizar el mtodo de diagonalizacin de Cantor. Este matemtico lo utiliz para
demostrar que el cuerpo de los nmeros Reales era un conjunto infinito incontable. Un
sencillo ejemplo: Sean tres cadenas de nmeros decimales de tres dgitos, las cuales se
organizan en una lista. Para encontrar una cadena de tres dgitos que no est en la lista
utilizamos el mtodo de la diagonal como se describe a continuacin.
Suponer el conjunto X={0,1,2,3,4,5,6,7,8,9} y, dado un digito yi, el conjunto Yi

={yi}; el conjunto complementario de Yi ser Yi = X - Yi.
Se coge el primer dgito de la primera cadena, y1: para la nueva cadena no listada se
elige un dgito cualquiera de Y1. De esta manera se asegura que la nueva cadena no
puede ser igual a la primera.
62
Mquinas de Turing
Se coge el segundo dgito de la segunda cadena y2: para la nueva cadena no listada
se elige un dgito cualquiera de Y2. De esta manera se asegura que la nueva cadena
no puede ser igual a la primera.
Se coge el dgito i de la cadena i-sima, yi: para la nueva cadena no listada se elige
un dgito cualquiera de Yi. De esta manera se asegura que la nueva cadena no puede
ser igual a la i-sima.
De esta forma se ha obtenido una cadena de 3 dgitos que no es igual a ninguna de las
existentes en la lista.
Ejemplo: dada la lista 455, 273, 921, encontrar una cadena que no est en esta lista. Si
o 455 y1 = 4, escogemos y1=7
La nueva cadena, 725, no est en la lista.
-Cantor demostr que el intervalo (0,1) es incontable, extrapolando, posteriormente, su
resultado a todo el conjunto R: Suponiendo cierto que para el intervalo (0,1) tenemos la
funcin f: (0,1)
, se tendrn n nmeros con n decimales, todos distintos entre s. Si se
aplica el mtodo de diagonalizacin a la parte fraccionaria, encontraremos al menos un

nmero en el intervalo (0,1) que no estaban en la lista; de esta manera la afirmacin de que
existe f es falsa, y por lo tanto el conjunto R es infinito incontable.
Utilizando la misma tcnica, se va a encontrar un lenguaje, denominado de
diagonalizacin Ld, que no puede ser aceptado por ninguna MT, esto es, que no es RE, de
manera que se demostrar que hay ms lenguajes que mquinas de Turing.
63
Para ello listaremos en una columna todas las MT, que hemos asociado con un nmero
natural. El resto de columnas (j) son cada una de las cadenas de *, asociadas tambin con
un nmero natural. As una porcin de la lista podra quedar
j
Mi
44
45
46
47
44
45
46
47
En este momento se est ya en condiciones de definir lo que es la secuencia o vector

caracterstico de un lenguaje: ser una cadena de unos y ceros, donde la posicin j de la
cadena resultante, iniciando desde la izquierda, ser:
1, si la cadena j pertence al lenguaje L(Mi).
0, si la cadena j no pertenece al lenguaje L(Mi)
As, cada fila de la tabla ser el vector caracterstico del lenguaje aceptado por la
mquina correspondiente, donde se reflejan las cadenas que pertenecen al lenguaje de cada
mquina.
Suponer el lenguaje compuesto por cada una de las cadenas que representan el cdigo de
la Mi cuya codificacin es aceptada por ellas mismas. Como se puede observar, el vector
caracterstico de este lenguaje se corresponde con la diagonal de la tabla (la M45 y M46
aceptan 45 y 46, es decir, aceptan su propia codificacin, mientras que M44 y M47 no). Se
puede demostrar que la mquina que acepta este lenguaje existe, siendo el vector
caracterstico de alguna Mk de la lista.
Mquinas de Turing
64
Para obtener el lenguaje de diagonalizacin, Ld, se proceder con el mtodo descrito

anteriormente (obtiene el complementario del anterior), complementando cada una de las
entradas en la diagonal de la lista. De esta forma obtendremos el vector caracterstico de Ld :
Si j pertenece a L(Mj), entonces j no pertenece a Ld
Si j no pertenece a L(Mj), entonces j pertenece a Ld
Es decir Ld, es el lenguaje compuesto por cada una de las cadenas que representan el
cdigo de la Mi cuya codificacin no es aceptada por ella misma.
Con este mtodo se ha encontrado un conjunto de cadenas que no es el vector
caracterstico de ninguna MT, es decir, no hay ninguna MT que acepte Ld. Para aclarar esta
afirmacin, suponer que existe una MT, Mk, que acepta el lenguaje Ld. Entonces esta
mquina debera estar en la lista. Si la cadena k es el cdigo de Mk, pueden ocurrir dos
cosas:
Que k pertenezca a Ld. En este caso Mk debera aceptar la cadena. Sin embargo, se
ha demostrado que Ld no contiene k si existe alguna mquina que acepte su propia
codificacin, debiendo Mk rechazarla. Luego se produce una contradiccin.
Que k no pertenezca a Ld. En este caso Mk debera rechazar la cadena. Sin

embargo, se ha demostrado que Ld contiene k si existe alguna mquina que no
acepte su propia codificacin, debiendo Mk aceptarla. Luego se produce una
contradiccin de nuevo.
Como se produce la paradoja de que k deber pertenecer y no pertenecer a la vez a Ld,

se concluye que no hay ninguna MT que acepte este lenguaje.
65
8.- CONJUNTOS RECURSIVOS Y RECURSIVOS ENUMERABLES (y II)
Ya se ha comentado que, para los lenguajes recursivos, la complementacin es una

operacin cerrada. Tambin se ha dicho que si un lenguaje L es recursivo tambin lo es .
Para demostrar esto ltimo, basta con construir una MT que decida :
Sea L(M) un lenguaje recursivo decidido por M, que ser una mquina con una
cinta, un estado de aceptacin y otro de rechazo. Se puede construir M que decida (M) a
partir de M, cambiando la caracterstica de aceptacin a rechazo y viceversa. De esta forma,
cuando M acepta la cadena, M siempre parar rechazndola y como M siempre para
rechazando la cadena, M parar aceptndola.
Anteriormente tambin se afirm que para que un lenguaje L sea recursivo, tanto L
como
han de ser recursivamente enumerables. Para demostrar esto, se construir una MT,
Mr, de dos cintas, donde la primera sirve para simular M, que acepta L(M), y la segunda
sirva para simular M, que acepta
(M). Mr simular en paralelo M y M (ejecutar
alternativamente transiciones de una y otra mquina). Si M acepta la entrada, entonces Mr

acepta la entrada. Si M acepta la entrada, entonces Mr rechaza la entrada. As Mr siempre
parar ante cualquier entrada al problema. Esta demostracin tambin es vlida si se parte
del hecho de que si
es recursivo, tanto L como
han de ser recursivamente enumerables.
Hasta ahora se han demostrado los casos en los que el lenguaje y su complementario
son simtricos (decidibles por una MT). En este caso se puede considerar que el problema
es el mismo.
Sin embargo, tambin hay casos en los que no lo son, como se demostr en con el
lenguaje de diagonalizacin Ld y su complementario. En este caso cada lenguaje es un
problema diferente. Es ms, el complementario a Ld es RE (es aceptado por alguna Mk),
mientras que Ld no, de lo que se demuestra que la complementacin para RE no es cerrada.
En resumen, podemos relacionar un lenguaje y su complementario de la siguiente
manera:
Ly
son recursivos.
66
Mquinas de Turing
Ly
L es RE pero
son no RE. Por tanto no se pueden aceptar con una MT.

es no RE.
es RE pero L es no RE.
A modo de ilustracin, Ld y su complementario estn en el tercer caso (recordar que

hemos complementado la diagonal de la tabla),
9.- MAQUINA UNIVERSAL DE TURING

Suponer el siguiente problema: determinar si una MT cualquiera acepta una cadena
de entrada. Para ello se va a utilizar como entrada a la MT, que resuelve este problema, el
par (M, ): la codificacin de la mquina M que acepta la cadena . Este par, codificado
como lo hemos hecho antes, es la concatenacin del cdigo de M y la cadena separados
por tres unos consecutivos. Esta separacin es correcta dado que la codificacin de la
mquina terminar siempre con algn cero, y adems no va a tener ms de dos unos
consecutivos; as mismo la cadena no va a tener nunca dos unos consecutivos.
El lenguaje que acepta esta mquina ser el conjunto de todas las codificaciones de
mquinas de Turing junto con todas las cadenas que aceptan; as, el problema se reduce a
resolver si un par (M, ) pertenece a este nuevo lenguaje, que llamamos universal
Lu = {(M, ) / M es una MT que acepta }
La MT, U, que acepta Lu se la llama mquina de Turing Universal, y recibe este
nombre debido a que es una mquina que es capaz de simular cualquier otra MT, M, con la
cadena entrada, a partir de la descripcin codificada de la misma. Este es el motivo por el
que se dice que U es una mquina programable, pues a la entrada tiene el cdigo de
cualquier MT con sus datos de entrada.
67
Esta mquina, podr tener el siguiente comportamiento, mientras simula M:
Parar aceptando si M para aceptando o
Parar rechazando si M para rechazando o
Entrar en un bucle si M entra en un bucle. Este hecho, el de no saber si la mquina

parar con una entrada determinada, a veces se le llama problema de la parada10.
Por este comportamiento ltimo, es por el que, intuitivamente, se puede observar que Lu
es indecidible. Sin embargo, este lenguaje s es RE, ya que Lu es precisamente lo que
representa toda la lista de mquinas con todas las cadenas que acepta cada una. Luego se
puede construir una MT, U, de tres cintas que simule cualquier otra MT, M, con una cadena
de entrada determinada:
Cinta 1.- Se almacena el par (M, ).
Cinta 2.- Simula el contenido de la cinta de M (en el mismo cdigo binario utilizado
para codificar la mquina, es decir, un cero para el cero, dos ceros para el 1, tres
ceros para B,.). El cdigo de cada smbolo se precede con un uno. Esto es correcto
porque ningn smbolo de cinta de M se va a codificar con un uno.
Cinta 3.- Contendr el estado en el que se encuentra M. Al igual que antes, con el
mismo cdigo que la mquina.
Esta mquina tendr el siguiente comportamiento:
Primero se comprueba el tipo de mquina que se va a simular. Si el cdigo

introducido no se corresponde con el cdigo correcto de alguna mquina, la mquina
parar rechazando la cadena (ya se dijo que se considera que un cdigo mal formado
representa una MT con un estado y ninguna transicin).
10
Como ya se ha dicho, Turing dise la MT calculadora con aceptacin por parada. Para esta mquina el
problema equivalente al de la parada es si la mquina sera capaz de parar para todas las cadenas a su entrada.
Dado que el modelo es distinto, el problema es distinto. Ms concretamente, a este problema, para U, se le
debera llamar el problema de la aceptacin, pues se trata de un modelo de aceptacin de cadenas. Las
conclusiones que sacaremos son las mismas.
68
Mquinas de Turing
Se codifica la cadena de entrada y se introduce en la cinta 2. Por ejemplo, si la

cadena de entrada fuera 01101, en la cinta 2 se almacenara
1010010010100. Un
caso especial ser el espacio en blanco: U considerar que la casilla en blanco de la

cinta 2 es el cdigo de casilla en blanco de M. De esta manera en la cinta nunca
habr tres ceros seguidos, pero s una casilla en blanco. Colocamos la cabeza de la
segunda cinta en la primera casilla en la empieza el cdigo de .
Almacenamos en la cinta 3 el estado inicial de M.
Se busca en la cinta 1 la transicin correspondiente al estado de la cinta 3 y el

smbolo actual de la cinta 2, y se aplica:
o Se sustituye el estado de la cinta 3 por la codificacin del siguiente estado (el
que marca la transicin).
o Se sustituye el cdigo del smbolo de cinta actual de M en U por el que
marque la transicin. Cuando hay una sustitucin puede ocurrir que el cdigo
del smbolo nuevo tenga una mayor longitud que el cdigo del smbolo a
sustituir, en cuyo caso hay que desplazar, en la cinta 2, el resto de la cadena a
la derecha las casillas que sean necesarias (igualmente, si el cdigo del
smbolo nuevo es de menor longitud, habr que desplaza a la izquierda el
resto de la cadena, y evitar as espacios en blanco). Estos desplazamientos se
podran evitar si se codifican los estados y los smbolos como cadenas
binarias de longitud fija (si x es el nmero de estados/smbolos, x 2n, donde
n es el nmero de bits para un estado/smbolo).
o Se realiza el movimiento que marque la transicin, posicionando la cabeza de
la cinta 2 al principio del cdigo del siguiente smbolo (en el 1 que lo marca).
Si no hay transicin definida en M, esta para, luego U se para sin aceptar.
Si M acepta , entonces U terminar en su estado de aceptacin.
69
Una vez que se ha demostrado que hay una MT que simula cualquier MT que acepta una
cadena, y por tanto que es RE, ahora hay que demostrar que Lu es indecidible, es decir que
no hay una MT para el lenguaje
. De forma intuitiva se puede observar que
subconjunto de Lu. Por esto mismo, Ld estar incluido en
es un
; sabemos que no hay ninguna
MT que acepte Ld, por lo tanto no habr ninguna mquina que acepte
Para demostrar esta afirmacin, suponer que Lu es recursivo; esto es lo mismo que
suponer que existe una MT, Mk, que con una entrada (M, ) acepta Lu, aceptando si la
cadena est en el lenguaje y rechazando si no lo est.
Tomando como base Mk, se va a construir una MT,
, que acepte
con una entrada
(M, ), igual que hicimos antes: Cuando Mk acepta la cadena de entrada,
la rechazar y
cuando Mk rechace la cadena,
, para obtener
la aceptar. A continuacin se modifica
, que en lugar de tener como entrada el par (M, ) tenga el par (M,M), es decir, una M
que acepte su propia codificacin. As,
rechazar el par (M,M) si M acepta su propia
codificacin y aceptar el par (M,M) si M rechaza su propia codificacin. Como se puede

observar,
es la mquina que acepta Ld, la cual ya se demostr que no exista. Es fcil
ver que si se introduce en

(
) si
su propia codificacin como entrada, debera rechazar el par
acepta su propia codificacin (lo que es una contradiccin) y, por otro
lado, debera aceptar el par (
) si
es una contradiccin). Al demostrar que
rechaza su propia codificacin (lo que tambin

no existe, se est demostrando que
existe y por tanto la afirmacin de que existe Mk es falsa. Es decir, el par (

pertenecer y no pertenecer a
tampoco
,
) debe
, con lo que se concluye que no hay una MT que acepte
Como corolario a toda esta demostracin, y al ser
un subconjunto de Lu, se puede
afirmar que, como Lu es RE, cualquier subconjunto suyo tambin lo es, entre ellos
9.1. LMITE DE LOS COMPUTADORES ACTUALES

Se ha demostrado que hay infinitos problemas para los que no se va a tener una MT que
los resuelva (ni siquiera los reconozca). Tambin se ha formulado la tesis de Church-Turing,
que determina el lmite de los computadores actuales. Si esto es as Qu tipo de mquina es
Mquinas de Turing
70
un computador actual? Como ya se habr supuesto, es una mquina programable en el

sentido de la Mquina Universal de Turing. Para demostrar esta afirmacin, se proceder
como siempre: primero simular una MT con un computador y segundo simular un
computador con una MT.
Para el primer paso, si tenemos una MT con cinta semi-infinita, la unidad de control se
simula por el procesador, cada uno de los smbolos de cinta se codifican como la
informacin que se permiten guardar en la memoria del computador. Los estados, al ser
finitos, se pueden guardar en una tabla (en realidad sera el estado del procesador, que
incluye el contador de programa) y las transiciones se simulan mediante un programa. La
cinta se simulara con la memoria. El inconveniente de que un computador tiene una
memoria finita se soluciona suponiendo que siempre es posible aadirle, de forma
indefinida, ms memoria. De esta forma un computador simulara el funcionamiento de una
MT cualquiera.
El segundo paso, pasar de un computador a una MT de varias cintas, es tambin casi
inmediato. El programa y los datos de entrada al programa que se introducen en la memoria
antes de ejecutarse en el computador se pueden codificar como un par (M, ), donde M es la
secuencia de instrucciones que hay que computar y son los datos de entrada al programa,
almacenndose en la primera cinta. En la segunda cinta almacenaremos las posiciones de
memoria a las que va a acceder el programa para su lectura/escritura. En la tercera cinta
almacenaremos el contador de programa (el estado), que es el que determina la direccin de
la computacin. De esta forma la MT simulara el funcionamiento de un computador muy
bsico. La memoria cach, los registros, la UAL son ampliaciones que se han hecho para
mejorar la eficiencia.
Sin embargo, un computador admitir solo un subconjunto de Lu, exactamente el
conjunto de aquellas para las que el par (M, ) sea la codificacin de la MT que acepta un
lenguaje recursivo, esto es, solo aquellos problemas para los que pueda existir un algoritmo.
71
9.2. UN PROBLEMA REAL

La verificacin formal de un programa es decidible?. Podemos enunciar este problema
de otra manera existe alguna MT que decida si su propia definicin es vlida o no? Por la
demostracin de la indecidibilidad de Lu, podemos decir que no.
Otro problema que corrobora esta afirmacin es que la lgica de predicados, en la que se
basa la verificacin formal, tampoco es decidible.
10. DETERMINAR LA INDECIBILIDAD. MTODO DE REDUCCIN

Hasta ahora hemos utilizado un mtodo laborioso para demostrar que un lenguaje es
indecidible. Una manera ms simple de hacer esta operacin es utilizando el mtodo de
reduccin, el cual est implcito en nuestra manera de pensar a la hora de solucionar ciertos
problemas: dado un problema P1, este se reduce a solucionar P2. Es decir, si solucionamos
P2, tenemos solucionado P1. De esta manera hemos convertido un problema en otro.
Pongamos un ejemplo:
P1.- Hay hambre en el mundo.
P2.- Hay que redistribuir parte de la riqueza
El problema del hambre en el mundo se reduce a redistribuir riqueza. P2 es un problema
mucho ms general, pues adems de solucionar el hambre tambin solucionara otros ms.
Hay que hacer notar que este mtodo no hace referencia a la manera en la que se
soluciona P1 o P2, sino que determina como la solucin de P2 conduce a solucionar P1.
Tambin se puede ver que P2 es un problema ms general que P1. De hecho este mtodo no
funcionara en el sentido inverso: siempre se reduce un problema a otro ms general.
Mquinas de Turing
72
Otro ejemplo ms mundano: El jefe al fin se ha decidido a dar las vacaciones, pero
estamos a 30 de julio y queremos ir con la familia, que resulta que est en Australia. El
problema entonces se reduce a encontrar un billete de avin a este destino.
En trminos de mquinas de Turing, dado un lenguaje L1, que define un problema,
su decisin se reduce a otro lenguaje L2 que es decidible. Para ello se debe encontrar un
algoritmo que convierta una cadena de L1 en otra cadena de L2 (L2 puede tener ms
cadenas aceptables, pero nos interesan las que se pueden obtener por el algoritmo desde L1),
decidindose entonces si pertenece a L2.
Para demostrar la indecidibilidad de un lenguaje L, se va a utilizar la reduccin ante
dos situaciones distintas:
Que P1 sea RE, el problema se reduce a otro P2 que tambin es RE.
Que P1 no sea RE, el problema se reduce a otro P2 que tampoco es RE.
Demostrar que un lenguaje L2 es recursivamente enumerable / noRE, se har por

reduccin al absurdo. Para ello partimos de un lenguaje L1 del que conoceremos de
antemano su no decidibilidad (normalmente se utilizarn Lu o Ld, aunque puede ser
cualquier otro del que se haya demostrado su indecidibilidad). Tenemos, en las dos
situaciones antes descritas:
Que haya que demostrar que L2 es RE. Para ello partimos de la certeza de que L1 es
RE (por ejemplo Lu) y lo reducimos a L2. Se supondr que este ltimo es decidible,
es decir, que se puede encontrar una MT que, siendo la entrada una cadena de L1,
esta se puede convertir en una cadena de L2, y decidir si esta ltima pertenece a
L2 o no. Si se encuentra al algoritmo de conversin, se habr encontrado una MT que
es capaz de reducir L1 a L2, y por tanto, la manera de decidir L1. Pero esto es una
contradiccin, pues sabemos de antemano que L1 es RE, por lo que, forzosamente,
L2 no puede ser decidible. Se llega a la conclusin de que L2 tambin es RE.
Que haya que demostrar que L2 no es RE. Para ello partimos de la certeza de que L1
no es RE (por ejemplo Ld) y lo reducimos a L2. Se supondr que este ltimo es RE,
73
es decir, que se puede encontrar una MT que, siendo la entrada una cadena de L1,
esta se puede convertir en una cadena de L2, y aceptarla si esta ltima pertenece a
L2. Si se encuentra un algoritmo de conversin, se habr encontrado una MT que es
capaz de reducir L1 a L2, y por tanto la manera de aceptar L1. Pero esto es una
contradiccin, pues sabemos de antemano que L1 no es RE (ninguna MT puede
aceptarlo), por lo que, forzosamente, L2 no puede ser RE. Se llega a la conclusin de
que L2 tampoco es RE.
Mquinas de Turing
74
75
APENDICE A.- BIBLIOGRAFA Y REFERENCIAS

[Alegre et al, 1997] Alegre Gil, C., Martnez Pastor, A., Pedraza Aguilera, M.C. Problemas
de matemtica discreta. 1 Edicin. Valencia (Espaa): Servicio de publicaciones de la
Universidad Politcnica de Valencia, 1997. ISBN. 84-7721-495-6
[Brena 2003]. Brena, R. Autmatas y lenguajes. Un enfoque de diseo.[en lnea]. Campus
Monterrey. Tecnolgico de Monterrey. 1 edicin. Monterrey (Mxico), 2003 [consulta 2010-2009]. Disponible en http://homepages.mty.itesm.mx/rbrena/AyL.html.
ISBN 970-
94484-0-4.
[Brookshear, 1993]. Brookshear, J., G. Teora de la computacin. Lenguajes formales,
autmatas y complejidad. 1 edicin. Mxico, Addison Wesley Iberoamericana, 1993. ISBN
9789684443846
[de la Fuente, 2010] de la Fuente Lpez, R.,J. Matemtica discreta: Conjuntos,
combinatoria y grafos. [en lnea]. Divulgacin web, 2010. [consulta 17-07-2010].
Disponible en:
http://www.innova.uned.es/webpages/aconute/matematicas/documentos/Matematica%20dis
creta_conjuntos_combinatoria_grafos_v20100712-r.pdf
[Fernndez 1997]. Fernndez Vindel, J., L. Computabilidad y complejidad. Resumen
informal de conceptos bsicos [en lnea]. Universidad Nacional de Educacin a Distancia
UNED
1997.[consulta
15-10-2002].
Actualmente
no
disponible.
Obtenido
en
http://www.ia.uned.es/asignaturas/autmatas-2
[Hernndez et al 2009] Hernndez Fernndez, I., Mateos Contreras, C., Nez Valds, J.
Diofanto, Hilbert y Robinson: Alguna relacin entre ellos?. Nmeros, revista didctica de
las matemticas [on-line]. Abril 2009, volumen 70 [consulta 15-12-2009]. Pgs 75-87.
Publicacin disponible en http://www.sinewton.org/numeros, artculo disponible en
http://www.sinewton.org/numeros/numeros/70/Volumen%2070.pdf
ISSN: 1887-1984
Mquinas de Turing
76
[Hopcroft 2002] Hopcroft, J., Motwani, R. , Ullman, J.D.. Introduccin a la teora de

Autmatas, Lenguajes y Computacin. 2 edicin. Madrid (Espaa): Pearson Educacin
S.A, impresin de 2007. ISBN 9788478290567
[Rogers 1967] Rogers, H. Theory of recursive Functions and effective Computability. 1
edicin. MIT press, reimpresin de 1987. ISBN 9780262680523
[Sipser 2006] Sipser M. Introduction to the Theory of Computation. Second Edition,
international edition. USA: Thomson Course Technology Inc 2006. ISBN 9780619217648
[Turing 1936] Turing, A., M. ON computable numbers with an application to the
entsheidugsproblem. London Math. Soc, Ser. 2, Vol. 43, No. 2198. ao 1936. Disponible
http://www.thocp.net/biographies/papers/turing_oncomputablenumbers_1936.pdf
Diagramas de transiciones capturados de:
Rodger, S.,H. Jflap[programa]. Universidad de Duke. Durham. Versin 7.0. agosto 2009
[consulta 10-10-2009] Disponible en http://www.cs.duke.edu/csed/jflap/

Maquinas de Turing

Cargado por

Copyright:

Formatos disponibles

Maquinas de Turing

Cargado por

Información del documento

Derechos de autor

Formatos disponibles

Compartir este documento

Compartir o incrustar documentos

Opciones para compartir

¿Le pareció útil este documento?

¿Este contenido es inapropiado?

Copyright:

Formatos disponibles

Maquinas de Turing

Cargado por

Copyright:

Formatos disponibles

MQUINAS DE TURING:

AVISO DE DERECHOS DE AUTOR

1.- INTRODUCCIN ............................................................................................................ 7

6. CODIFICACIN DE LAS MT ......................................................................................57

cambiamos la pregunta o el conjunto origen, estamos definiendo otro problema, otra

conversin es que, con la representacin en cadenas y lenguajes a los que pertenecen,

1.1.- UN POCO DE HISTORIA

En 1931 Kurth Gdel public el famoso teorema de incompletud. Este se enunci

1.2.- LA TESIS DE CHURCH-TURING

La definicin formal de algoritmo viene dada por la definicin formal de la mquina

es un conjunto infinito contable. Un subconjunto S

que es recursivo si existe una funcin en

es decir, un conjunto es recursivo si tenemos un medio de determinar si un elemento

son conjuntos recursivos. Como consecuencia, cualquier conjunto contable

(finito o infinito) es recursivo1. Tanto S como

(complementario de S, elementos que no

pertenecen a S, teniendo en cuenta aqu que la complementacin es una operacin cerrada)

para que S sea recursivo,

No confundir esta recursividad con la recursividad de un lenguaje de programacin

Se denominarn recursivamente enumerable (RE) a los conjuntos en los que S es RE

de S, no lo es (RE no es cerrado para la

2.- DEFINIENDO LA MQUINA DE TURING (MT)

La cabeza lee el smbolo de la casilla a la que est sealando. Teniendo en cuenta

Durante el clculo se pueden producir dos situaciones:

Que se llegue a una solucin, en cuyo caso la mquina se parar.

2.2. DEFINICIN FORMAL DE LA MT

Q .- Conjunto finito de estados qi

.- Alfabeto de la mquina. Es un conjunto finito de smbolos

.- Alfabeto de cinta. Es un conjunto finito de smbolos. Por definicin el alfabeto

.- Funcin de transicin. Es un conjunto finito y define el comportamiento de la

q0 .- Es el estado inicial de la mquina y es en el que esta empieza a computar. Es

segn convenga. Por definicin B pertenece al alfabeto de cinta pero no al

Cuando se inicializa M, las casillas de la cinta estn en blanco, estando representadas

Porqu necesitamos Q? Cuando se llega a un estado de aceptacin, la mquina

(en el sentido de espacio

2.3. MUESTRA INFORMAL DEL FUNCIONAMIENTO DE UNA MT

Es decir, comprobar si la cadena de a,s y b,s a la izquierda de $ es igual a la cadena

Hemos utilizado el smbolo para no confundir el smbolo de casilla en blanco con

Puesta en marcha de la mquina: Slo podemos movernos de celda en celda, y lo har

Rechazando la cadena si se produjo una discrepancia entre subcadenas (letras

Algunas instantneas de la mquina a lo largo de la computacin son:

El marcado y el movimiento hacia delante y hacia atrs y viceversa,

Smbolos de entrada.- a, b, c primeras letras de abecedario en minscula o una a

Smbolos de cinta.- Adems de B (smbolo de casilla en blanco), Z,Y,X ltimas

Cadena del lenguaje.- z, y, x. ltimas letras de abecedario en minsculas o una x

Cadena de smbolos de cinta.- letras griegas minsculas.

Estados.- p, q, r, cuando son pocos. Si son muchos, se suele denotar como q

el subndice M es opcional si sabemos cual es la mquina para la que describimos la

Dado que el modelo de MT que se ha definido es obligatorio mover la cabeza a la

A la izquierda.- Si la funcin de transicin es (q, X0) (p, Y, I), es decir, se est en

A la derecha.- Si la funcin de transicin es (q, Xo) (p, Y, D), es decir, se est en

mover una casilla a la derecha, la cabeza apuntar al siguiente smbolo de cinta al

Tomando la configuracin de inicio del ejemplo informal, se va a mostrar el

Y tomando la tercera y la cuarta instantnea, no siendo la segunda una produccin de

Cuando se termine de definir la mquina del ejemplo se ver de forma ms clara la

Situaciones para movimiento a la izquierda:

o Que la cabeza apunte al ltimo smbolo de cinta que no es casilla en blanco y

Situaciones para movimiento a la derecha

o Que la cabeza apunte al ltimo smbolo de cinta que no es casilla en blanco.

Representacin tabular.- Tendr tantas columnas como smbolos de cinta y tantas