1

TRADUCTOR DE MÁQUINAS DE TURING ENTRE

ESTADOS Y OPERACIONES

DOCUMENTO PROYECTO DE GRADO

Daniel Ramos Díaz

27/11/2013

2

Tabla de Contenido 1. INTRODUCCIÓN ..................................................................................................................... 4

2. DEFINICIÓN Y ESTADO DEL ARTE ..................................................................................... 5

3. DESCRIPCIÓN DEL PROBLEMA Y ESTRATEGIA DE SOLUCIÓN .................................... 6

4. DISEÑO DE LA SOLUCIÓN ................................................................................................... 7

a. Metalenguaje ....................................................................................................................... 7

b. Traductor .............................................................................................................................. 9

5. EJEMPLOS ............................................................................................................................ 11

a. Primer Ejemplo .................................................................................................................. 11

b. Segundo Ejemplo ............................................................................................................... 13

6. LIMITACIONES ..................................................................................................................... 14

7. CONCLUSIONES Y TRABAJO FUTURO ............................................................................ 15

8. BIBLIOGRAFIA ...................................................................................................................... 15

9. APENDICE ............................................................................................................................ 16

3

Tabla de imágenes Imagen 2.1 – Editor Máquina de Turing GOLD .............................................................................. 5

Imagen 2.2 – Reglas Máquina de Turing GOLD ............................................................................ 6

Imagen 4.a.1 - Metalenguaje .......................................................................................................... 9

Imagen 4.b.1 – Estructura Grafo .................................................................................................. 10

Imagen 5.a.1 – Primer ejemplo .................................................................................................... 11

Imagen 5.a.2 – Gráfico primer ejemplo ........................................................................................ 11

Imagen 5.a.3 – Primer ejemplo resultado .................................................................................... 12

Imagen 5.b.1 – Segundo ejemplo ................................................................................................ 13

Imagen 5.b.2 – Segundo ejemplo ................................................................................................ 13

Imagen 5.b.2 – Segundo ejemplo resultado ................................................................................ 14

4

1. INTRODUCCIÓN

Las máquinas de Turing [1] son simuladores que fueron creados por Alan Turing en la época antecesora

de la segunda guerra mundial, en 1936. Este concepto, que es tan simple y sencillo, es un modelo

matemático que simula una máquina que opera mecánicamente sobre una cinta, es decir, al leer un

comando o carácter en una cinta de entrada, la máquina realiza internamente algún tipo de operación

sobre esta cinta de entrada u otra cinta de salida.

La definición formal más completa de la máquina de Turing de una sola cinta se describe como una 7-

tupla. Dependiendo del contexto en el cual se trabaje puede haber más o menos tuplas. Estas tuplas se

componen de:

● Un conjunto finito de estados.

● Un conjunto finito de símbolos diferentes al espacio en blanco pertenecientes al alfabeto de

entrada.

● Un conjunto finito de símbolos pertenecientes al alfabeto de cinta.

● El estado Inicial, que debe pertenecer al conjunto finito de estados.

● El símbolo blanco perteneciente al alfabeto de cinta.

● Un conjunto de estados finales que pertenece al conjunto de estados.

● Un conjunto de funciones parciales, donde dado un estado y un carácter ejecuta una operación

(R = Right, L= Left).

Las máquinas de Turing se pueden describir de dos posibles maneras, una descripción por estados y otra

descripción por operaciones, las cuales se describirán brevemente a continuación usando el contexto de

desarrollo. Las dos máquinas de Turing no tienen la misma cantidad de tuplas, las descritas por estados

tienen una tupla más que las descritas por operaciones, pues estas cuentan con un conjunto de estados

finales, los cuales indican que hay una terminación corecta. Ambas máquinas tienen un conjunto de

estados, un alfabeto de entrada, un estado inicial, el símbolo vacío que es predeterminado para ambas

máquinas y el conjunto de funciones parciales. Otra diferencia entre estas máquinas está en que la

primera tiene el conjunto de estados con el nombre que se le desee poner, mientras que los nombres de

la segunda máquina están sujetos a las operaciones que esta pueda realizar (L,R,W,etc). Mientras que

las transiciones entre estados, o mejor conocidas como las funciones parciales, difieren entre ambas

5

máquinas. Para la primera se tiene una transición con tres condicionales: lectura, escritura y operación;

mientras que para la segunda se tiene transiciones con solo una condición de lectura.

Para el contexto en el cual se está trabajando este proyecto de grado, vamos a trabajar una definición

formal de máquina de Turing de 4 tuplas. Solo tendremos un conjunto finito de estados, el estado de

inicio, un conjunto de estados finales y el conjunto de funciones parciales. El alfabeto sobre el cual

vamos a trabajar constara de todos los posibles caracteres y el símbolo vacío se representa de dos

posibles maneras (‘λ’,’empty’).

2. DEFINICIÓN Y ESTADO DEL ARTE

En el curso de Lenguajes y Máquinas dictado en la Universidad de los Andes se ha contado con

diferentes simuladores para los temas que se trabajan, algunos de ellos para no nombrarlos todos son el

VAS [2] y el jFlap [3].

Recientemente se creó un simulador de máquinas de Turing en la tercera iteración del proyecto GOLD

[4]. Este editor es totalmente visual y trabaja sobre máquinas de Turing por operaciones. Está definido

sobre un metalenguaje que define el lenguaje descriptivo sobre el cual se va a guardar la máquina en un

archivo de texto.

Imagen 2.1 – Editor Máquina de Turing GOLD

6

Como se puede observar, este editor es bastante completo y tiene las opciones necesarias para poder

simular una máquina de Turing por estados. Todas sus transiciones tienen un carácter de entrada,

incluyendo un carácter vacío que corresponde a “sin importar lo que lea ejecute”. Tiene la visualización

para indicar al usuario cual es el estado inicial y como esta será iterada. Sus estados también tienen

nombres que corresponden a un rango de posibles operaciones que la máquina de Turing debe ejecutar.

Este conjunto de operaciones es el siguiente:

Imagen 2.2 – Reglas Máquina de Turing GOLD

Cabe resaltar que la operación del llamado a otra máquina funciona si y solo sí esta otra máquina se

encuentra en el workspace del editor de máquinas de Turing.

3. DESCRIPCIÓN DEL PROBLEMA Y ESTRATEGIA DE SOLUCIÓN

Actualmente solo se cuenta con un editor para máquinas de Turing por operaciones desarrollado en la

Universidad. El objetivo es poder contar con dos editores de máquinas de Turing interconectados que

puedan expresar la misma máquina en sus respectivos lenguajes. El primer paso para lograr esto es

desarrollar tanto un editor textual de máquinas de Turing por estados y un traductor que sea capaz de

traducir desde este último al lenguaje definido por el editor que ya se tiene en el curso. Para poder

desarrollar esto toca entender a fondo la gramática propuesta en el editor de GOLD y saber cómo esta

funciona. Se necesita conocer también las limitaciones que este lenguaje tiene.

Aparte de estos problemas, el editor que se va a desarrollar debe acoplarse al lenguaje propuesto por

GOLD y ser capaz de asemejarse para que no ocurran inconsistencias al momento de hacer la

traducción, y no solo esto, este lenguaje debe incorporar expresiones abstractas que sean capaz de

expresar más de una transición a la vez por medio de condicionales y operaciones booleanas.

7

Para poder abordar este problema se plantea realizar todo este desarrollo por pasos descritos y

documentados. El primer paso es estudiar a fondo la herramienta de GOLD y el editor de máquinas de

Turing que esta tiene, analizar el lenguaje y saber este editor se comporta, realizando algunos ejemplos

para la documentación.

Seguido a esto se propondrá un metalenguaje en el cual se pueda describir algunas máquinas de Turing

por estados. Se buscará alguna herramienta sobre la cual desarrollar esto y se pueda realizar pruebas

algunas.

Seguido a esto se desarrollara un programa independiente que sea capaz de realizar una interpretación

del lenguaje escrito, y basado en esto realizar la traducción correspondiente al otro lenguaje.

4. DISEÑO DE LA SOLUCIÓN

a. Metalenguaje

El metalenguaje se va a desarrollar en una herramienta que se llama Xtext [5], el cual es un editor

bastante potente, flexible y capaz en cuanto a la definición de metalenguajes. Para tener un mayor

conocimiento de esta herramienta se hará una breve explicación de cómo esta funciona.

Xtext es un proyecto en el cual encontramos tres proyectos (o más dependiendo de la versión)

dependientes entre sí. Todos estos proyectos generaran sus clases correspondientes a partir de dos

pequeños archivos que encontramos en el primer proyecto. El primer archivo define la gramática y el

segundo define como se generaran las otras clases.

Para la gramática, Xtext usa algo parecido a los métodos y atributos en java y son llamados las reglas.

Cada regla está compuesta de 0 o más atributos internos y tiene su notación específica para definir la

cantidad de veces que aparece en el lenguaje. Algo similar a lo que se usa en los temas de lenguajes en

el curso de la universidad, a diferencia que un poco más estructurado. También tiene unas clases

predeterminadas en unos archivos importados, llamados terminales. Cabe resaltar que no son las únicas

terminales, pues estas las puede también definir el usuario, pero son las básicas para un proyecto en

8

Xtext, tales como un identificador, una cadena de caracteres, otros posibles caracteres, por no nombrar

más ejemplos.

Xtext tiene la capacidad de poder hacer llamados a reglas que ya se han definido dentro del lenguaje, es

decir, se define un objeto (llamémoslo objetoIdentificador) en el metalenguaje y en el lenguaje este es

creado e instanciado con un identificador, más adelante otra regla del mismo metalenguaje requiere

que la referencia a ese objeto (objetoIdentificador) exista; Xtext se encarga de verificar si ese objeto

existe tanto en el archivo sobre el cual se trabaja o sobre el mismo workspace si es necesario.

El metalenguaje diseñado consta de seis reglas en total. La primera que es la que abarcara todo el

lenguaje, en el cual podremos encontrar 1 o más máquinas de Turing definidas, seguido de un <EOF>

(End of File) con palabra reservada ‘end’.

Cada máquina de Turing tiene una estructura fija que está separada o definida por palabras reservadas

como se podrá ver en la imagen 4.a.1. En esta estructura podremos definir una máquina de Turing con

un identificador único, un conjunto de estados, el estado de inicio que es sólo uno, un posible conjunto

de estados finales, y las transiciones. Los estados, al igual que la máquina de Turing, tienen un

identificador en su regla. Dentro de la estructura de la máquina de Turing, aquellas reglas que van entre

corchetes hace referencia a un llamado a objetos ya instanciados dentro del lenguaje.

Las transiciones también tienen una estructura fija, empezando por una palabra fija, y en su interior está

separado por caracteres reservados, como la coma ‘,’ y el igual ‘=’. Esta llama una regla que se llama

Condición. La condición es la descripción de cómo se va a ejecutar cada transición, es decir, el

condicional de lectura si este existe, la posible escritura que se debe hacer sobre la cinta y la operación a

ejecutar sobre la cinta. Para asemejarse al editor de Gold, se definió un conjunto de operaciones, como

el ‘R’ (Right), ‘R[#]’ (Right until #) ó ‘R[!#]’ (Right until not #). Finalmente se añadió un terminal llamado

CHAR, es una regla similar al char en Java, esta simula los caracteres minúsculos, mayúsculos y un

número entre 0 y 9.

9

Aquí está el metalenguaje:

Imagen 4.a.1 - Metalenguaje

b. Traductor

El traductor es un programa totalmente independiente al anterior y está construido en su totalidad en

Java. Consta de tres grandes partes para que esto funcione.

La primer y segunda parte son muy similares y son clases que simulan unos grafos definidos, uno para

almacenar el lenguaje escrito, y el otro almacenará el resultado obtenido después de la traducción.

Como se puede ver en la imagen, este grafo describe de manera similar el metalenguaje. Una clase

principal contiene varias máquinas de Turing, las cuales contienen estados y transiciones, y tienen un

estado Inicial. Los estados conocen las transiciones que están ligadas a ellos, y las transiciones conocen

10

el estado donde inician y el estado donde terminan. Se creó una clase adicional para simular las

operaciones que se hacen sobre la cinta llamada Función.

Imagen 4.b.1 – Estructura Grafo

La tercera parte de este traductor es una clase donde se ejecuta toda la magia del programa. Esta clase

consiste de tres métodos secuenciales, el primero que es el interpretador del archivo de entrada, el

segundo que se encarga de realizar la traducción para cada elemento del grafo, y el tercero y último

realiza la impresión del grafo traducido en el lenguaje propuesto por GOLD.

Para poder correr el programa, se requiere de un archivo creado en el workspace con una extensión

.tme. De esta manera Xtext puede validar que lo que se esté escribiendo corresponda al metalenguaje

definido anteriormente. Una vez esté terminado este archivo, se procede a darle clic derecho al archivo

y en la opción de traductor le damos traducir. Esto nos genera uno o más archivos de texto

11

correspondientes al lenguaje del editor de GOLD, cada uno describiendo las máquinas que habían en el

archivo .tme.

5. EJEMPLOS

Para poder ilustrar mejor el funcionamiento del traductor, se han diseñado dos ejemplos totalmente

diferentes para saber cómo es el resultado de cada uno de ellos.

a. Primer Ejemplo

Para el primer ejemplo vamos a trabajar una máquina de Turing capaz de cambiar las minúsculas por

mayúsculas, el alfabeto de entrada solo consta de dos posibles caracteres, ‘a’ y ‘b’. La máquina está

descrita a continuación:

Imagen 5.a.1 – Primer ejemplo

Imagen 5.a.2 – Gráfico primer ejemplo

12

Al correr este archivo obtenemos lo siguiente:

Imagen 5.a.3 – Primer ejemplo resultado

Este primer ejemplo es una de las máquinas más sencillas y básicas que se pueden crear. Como

podemos ver en el resultado, tenemos una máquina con una cantidad diferente de nodos, pues hay

nodos adicionales a una operación que existe solo en las transiciones, que es la escritura. También

tenemos los ciclos de proceso a proceso definidos al otro lado, que van desde el nodo 0 y 1 y el nodo 0 y

2.

13

b. Segundo Ejemplo

El segundo ejemplo es una máquina más compleja y grande, que consta de 8 máquinas en total. Es un

simulador de una calculadora trinaría, se le ingresa solo un número y este botara el número multiplicado

por dos.

Imagen 5.b.1 – Segundo ejemplo

Imagen 5.b.2 – Segundo ejemplo

La imagen anterior solo nos muestra una de las ocho máquinas que hay descritas, pues el archivo es

bastante largo. Para este ejemplo traduciremos todo el archivo y nos arrojara ocho archivos en total,

pero solo mostraremos el resultado de la imagen anterior.

14

Imagen 5.b.2 – Segundo ejemplo resultado

Como podemos ver, se crea la máquina inicioCarry, la cual es una máquina secuencial hasta el estado 3,

en el cual dependiendo de lo que lea, tomara un camino diferente a otros nodos, que son llamados a

otras máquinas de Turing.

6. LIMITACIONES

El programa tiene sus limitaciones, aunque estos no afectan su principal funcionalidad. Una de las

limitaciones que el programa tiene está en la cantidad de caracteres que este puede llegar a simular

dentro de su lenguaje, esto fue derivado de un problema de codificación de caracteres que había entre

los diferentes computadores en los que fue desarrollado. La solución a este problema se puede resolver

en las propiedades de eclipse, abriendo todos los archivos en UTF-8.

Aparte de esto, el plugin desarrollado en este caso está disponible para la versión Juno Modeling de

eclipse, ya que al momento de generar el plugin se crean unas dependencias especificas con ciertos JAR

internos de cada eclipse y esto no es estándar entre todos los eclipse.

15

7. CONCLUSIONES Y TRABAJO FUTURO Después de un proceso completo de análisis al editor que se tenía en GOLD y de una iteración de diseño

para el traductor, el software resultante es bastante completo y satisfactorio, sin embargo no alcanzó a

tener el alcance que se deseaba en un principio, pues este requería de expresiones abstractas para

describir matemáticamente un conjunto de transiciones, sin tener que ser tan rígidos en el lenguaje. Sin

embargo el programa resultante es flexible a este problema para tratarlo en un futuro.

Para poder adicionar las expresiones abstractas se requiere tocar dos partes del programa, la primera

consiste en adicionar la regla correspondiente en el metalenguaje para que estas puedan escribirse

teniendo una estructura fija, y la segunda consiste en modificar el método del intérprete, para que al

llegar a las transiciones e identificar una transición abstracta, sea capaz de interpretarla, y recorrer

todos los estados que cumplen con la condición y agregar la transición correspondiente. El resto queda

intacto y seguirá funcional con estos dos cambios.

Sería interesante también poder completar estas funcionalidades con un editor visual, pues a los

usuarios les queda más fácil guiarse por lo visible, aparte de ser un poco más entendible. Adaptar esta

visualización al lenguaje que se tiene y allí mismo poder traducir el archivo correspondiente. Incluso

sería aún más interesante tener un programa con ambos editores acoplados, en el cual el usuario decida

hacer la máquina en uno y traducirlo al otro allí mismo y sea visualizado al instante. No necesariamente

tiene que ser del editor existente al que se crea, puede ser desde cualquier punto de origen.

8. BIBLIOGRAFIA [1] Takahashi Silvia. Lenguajes y Máquinas.

http://sistemas.uniandes.edu.co/~isis1106/dokuwiki/lib/exe/fetch.php?media=bibliografia:mts.pdf

[2] Visual Automata Simulator Version 1.2.2. Noviembre 24 de 2006. Copyright © 2004-2006 Jean

Bovet

[3] JFLAP 7.0. Agosto 28 de 2009. Copyright 2009.

[4] Sotelo A. Alejandro. GOLD 3. Un lenguaje de programación imperative para la manipulación de

grafos y otras estructuras de datos.

http://sistemas.uniandes.edu.co/~isis1106/dokuwiki/lib/exe/fetch.php?media=tutoriales:gold3_d

ocumento.pdf

[5] Xtext 2.4.3 Documentation.

http://www.eclipse.org/Xtext/documentation/2.4.3/Documentation.pdf

16

9. APENDICE