traductor de mÁquinas de turing entre estados y …
Post on 26-Jun-2022
5 Views
Preview:
TRANSCRIPT
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
top related