SlideShare una empresa de Scribd logo
1 de 55
Descargar para leer sin conexión
Sara Martínez Gómez
JFLAP Sara Martínez Gómez
2
Índice
¿Qué es?............................................................................................................ 3
Historia ............................................................................................................... 3
Autómatas .......................................................................................................... 4
Autómatas finitos............................................................................................. 5
Máquina de Mealy ..................................................................................... 11
Máquina de Moore..................................................................................... 14
Máquina de Turing ........................................................................................ 16
Máquina de Turing compuesta compuesta................................................ 18
Gramáticas....................................................................................................... 19
Expresiones regulares...................................................................................... 25
Equivalencia..................................................................................................... 28
Práctica 1 ......................................................................................................... 30
Solución ........................................................................................................ 31
Practica 2 ......................................................................................................... 38
Solución ........................................................................................................ 39
Práctica 3 ......................................................................................................... 43
Solución ........................................................................................................ 43
Práctica 4...................................................................................................... 50
Solución ........................................................................................................ 50
Fuentes de información.................................................................................... 54
JFLAP Sara Martínez Gómez
3
¿Qué es?
JFLAP (Java Formal Languages and Automata Package) es una extensa
herramienta visual e interactiva que hace posible crear y
simular autómatas con el objetivo de experimentar con
ellos y con sus lenguajes y gramáticas, la cual requiere
la instalación previa de Java para poder ejecutarla
correctamente.
Proporciona una forma fácil para visualizar y
experimentar con conceptos teóricos al permitir
construir, probar y depurar diagramas de transición de los tres tipos de
autómatas, además de posibilitar el análisis sintáctico de los árboles para las
gramáticas creadas.
Su principal objetivo es evitar o corregir los errores en una materia tan
propensa a ellos como es la creación de DFAs y NFAs, expresiones regulares,
lenguajes, máquinas de Turing o gramáticas.
Historia
El desarrollo de JFLAP comenzó en 1990, cuando Susan H. Rodger vio la
necesidad de desarrollar una herramienta para que sus alumnos pudieran
resolver los problemas relacionados con la asignatura de complejidad
computacional, que ella impartía, en un ordenador, en lugar de en papel como
se hacía hasta ese momento. Esta necesidad fue instada por lo tedioso que
resultaba rastrear las rutas de los modelos escritos a mano para ver sus fallos.
FLAP comenzó como varias herramientas más pequeñas (NPDA, LR
Analizador, LL Analizador, Tubb, FLAP) para diferentes conceptos de lenguajes
formales, escritos en C ++ y X Window, todas ellas de software libre.
En 1996 FLAP fue rescrito en Java en la Universidad de Duke y se convirtió en
ese momento en JFLAP, herramienta de instalación mucho más fácil que su
JFLAP Sara Martínez Gómez
4
predecesora. En 2002, fue rescrita de nuevo utilizando Swing, lo que la ha
provisto de una mejor interfaz gráfica.
Desde entonces, se ha incrementado mucho el uso de esta herramienta hasta
llegar a las 64.000 descargas en 2008 por personas que se encontraban en
161 países diferentes. El siguiente mapa muestra dichos países coloreados en
verde:
Autómatas
Los autómatas o máquinas de estados son un modelo de comportamiento de
un sistema con entradas y salidas, cuyos intermediarios son un conjunto de
estados que hacen que el historial de señales de entrada determine para cada
instante un estado de la máquina provocando que la salida de la misma
dependa solamente de sus estados y entradas actuales.
Con JFLAP se pueden diseñar y animar tres tipos de autómatas: autómatas
finitos, autómatas pushdown y máquinas de Turing multicinta. Todas estas
máquinas pueden ser deterministas o no deterministas. En el uso de la
herramienta, se traza gráficamente una de las máquinas como un diagrama de
transición, se introduce una cadena de entrada, y a continuación, se controla la
trazabilidad dicha cadena a través de la máquina gracias a los diferentes
modos de simulación de los que está dotada la herramienta que nos atañe.
JFLAP Sara Martínez Gómez
5
Autómatas finitos
Un autómata finito es un sistema que realiza cómputos sobre una entrada para
producir una salida. Está formado por una 5-tupla: un alfabeto, un conjunto
de estados finito, una función de transición, un estado inicial y un conjunto de
estados finales.
Q = conjunto finito de estados
Σ = alfabeto finito
q0 ϵ Q = estado inicial
δ: Q x Σ Q = función de transición
F ⊆ Q = conjunto de estados finales
Su funcionamiento consiste en que el autómata recibe una cadena de
caracteres que pertenecen al alfabeto y va leyendo dicha entrada para
procesarla según la función de transición de forma que va cambiando de
estado hasta llegar a un estado final, es decir, hasta proporcionar una salida.
Todo ello se representa mediante grafos, que son los diagramas utilizados por
JFLAP para hacer las simulaciones del funcionamiento anterior. El conjunto de
estados se representa como un cúmulo de vértices, unidos mediante vectores
etiquetados que representan cada una de las transiciones de la función δ. El
estado inicial se diferencia del resto por tener un vector que llega a él sin un
origen. Los estados finales pertenecientes a F tienen una doble circunferencia
en su representación.
JFLAP permite la creación de los estados pulsando el botón que representa el
vértice, situado en la parte superior y los enumera de forma automática. Para
representar los vectores existe un botón que tras ser pulsado obliga al usuario
a situarse en el estado origen de la transición, pulsar sobre él y, a continuación,
pulsar sobre el estado destino. Una vez dibujado, se debe indicar el carácter o
caracteres correspondientes a la misma, si no se indica nada se considerará
que es el carácter vacío representado por λ. Si queremos indicar que el estado
en el que nos encontramos es inicial, deberemos pulsar el botón derecho e
indicarlo, de esta forma aparecerá una flecha indicándolo. El mismo
procedimiento deberemos realizar para indicar que el estado en el que nos
JFLAP Sara Martínez Gómez
6
encontramos es final, de tal manera que aparecerá con una doble
circunferencia. Además podemos resaltar las transiciones vacías y las no
deterministas.
JFLAP provee cuatro modos de simulación para los autómatas dibujados
anteriormente que tratan de diversas maneras las cadenas de entrada
introducidas. El primero es la ejecución paso a paso con cierre para ver los
Añadir
transición a
los estados
Marcar
los
estados
inicial y
final
Resaltar las
transiciones λ
JFLAP Sara Martínez Gómez
7
estados por los que cruza la cadena introducida a través del autómata hasta
llegar al final. El segundo es la ejecución paso a paso simple, en la que el
usuario puede ir eligiendo los estados por los que cruza la cadena introducida
en caso de que sea un autómata no determinista y si es determinista realiza la
misma función que el anterior. El tercero es la ejecución rápida que consiste en
ver simplemente el valor de retorno del autómata para comprobar si ha
quedado en un estado de aceptación o no. El cuarto posibilita la entrada
múltiple de cadenas con el fin de ver las diferentes salidas del autómata.
En la siguiente imagen podemos ver la ejecución paso a paso, vemos como
cada vez que pulsamos sobre el botón “step”, el autómata lee una nueva letra
de la cadena de entrada y cambia de estado o se queda en el mismo. Las
letras ya leídas se pueden ver en la parte inferior coloreadas en gris y el estado
en el que se encuentra el autómata en ese momento se pude ver sombreado.
Asimismo, si la entrada no es contemplada por la máquina o la máquina
termina en un estado de no aceptación la parte inferior será coloreada en rojo.
Si por el contrario la máquina termina en un estado de aceptación la parte
inferior será coloreada en verde. Si pulsáramos sobre el botón “reset” el
autómata comenzaría a leer la cadena introducida de nuevo desde el principio.
JFLAP Sara Martínez Gómez
8
En la ejecución rápida una vez introducida la cadena de entrada y pulsado el
botón de “OK”, veremos una alerta informándonos del estado final de la
máquina: aceptación o rechazo. Si el estado es de aceptación veremos que
además se muestra una descripción de los estados por los que ha ido pasando
la máquina al leer la cadena.
JFLAP Sara Martínez Gómez
9
En la ejecución de múltiples cadenas de entrada podemos introducir diversas
cadenas en la parte derecha y ver el estado en el que queda la máquina tras su
ejecución al pulsar el botón “Run inputs”. Si pulsamos el botón “Clear” se
borrarán todas las cadenas que hemos introducido. Asimismo, podemos ver la
descripción de los distintos estados por los que ha pasado la máquina al leer
cada una de las cadenas introducidas si las seleccionamos y pulsamos el botón
“View trace”. Además para facilitar la entrada de la cadena vacía existe el botón
“Enter λ” y para restaurar entradas ya guardadas deberemos pulsar el botón
“Load inputs”.
Seleccionamos
y pulsamos
View trace
JFLAP Sara Martínez Gómez
10
Todos los ejemplos puestos hasta ahora son deterministas, por ello creemos
conveniente explicar más detalladamente la forma de ejecución del programa
con autómatas finitos no deterministas. Con el no determinismo, JFLAP crea un
árbol de todas las configuraciones posibles (no se muestran al usuario). En
cada paso se expande cualquier configuración que es un nodo hoja en el árbol
(con la poda), y luego muestra las configuraciones actuales (los nodos hoja
actuales). Si elegimos la ejecución paso a paso con cierre, según el camino
elegido el autómata llegara a final de la cadena de entrada quedándose en
diferentes estados y dando una salida distinta según el camino elegido. Este
ejemplo lo clarifica:
En la ejecución paso a paso, además se permite al usuario ir eligiendo la ruta a
través de los posibles estados, como ya hemos comentado anteriormente.
...
JFLAP Sara Martínez Gómez
11
Máquina de Mealy
Una máquina de Mealy es un tipo de autómata finito que genera una salida
basándose en una entrada y su estado actual. Formalmente se puede definir
como una séxtupla (S, S0, Σ, Ʌ, T, G):
S = conjunto finito de estados
S0 = estado inicial
Σ = alfabeto de entrada (conjunto finito)
Ʌ = alfabeto de salida (conjunto finito)
T : S x Σ  S = función de transición
G : S x Σ  Ʌ = función de salida
La principal aplicación de este tipo de máquinas es el cifrado de información,
pero constituyen un modelo matemático demasiado rudimentario como para
implementarse en un caso real como podría ser la Máquina Enigma. El motivo
es que el diagrama de estados de dicha máquina sería demasiado complejo.
No obstante, su funcionamiento es muy similar al de los autómatas finitos
explicados anteriormente, con la diferencia de que en lugar de ser aceptadora,
es decir, producir una salida binaria de aceptación o rechazo; es una máquina
transductora, esto es, que convierte la cadena de entrada en una cadena de
salida.
JFLAP reduce la funcionalidad ya explicada cuando pulsamos en el editor de
las máquinas de Mealy. Como en estas máquinas no hay un estado final, ya
que son transductoras y no aceptadoras, al pulsar el botón derecho sobre un
estado no tenemos la opción de marcarlo como estado final. Por otro lado,
cuando creamos una transición, es decir, cuando dibujamos el vector que une
dos estados, JFLAP nos obliga rellenar dos campos en lugar de uno como
antes, esto es porque el primer campo corresponde con el carácter de entrada
y el segundo con el de salida. Si los dejamos en blanco introducirá el carácter
λ, que como ya sabemos corresponde al carácter vacío. Además, JFLAP solo
permite dos modos de ejecución, ya que el resto no tendrían sentido en este
tipo de máquinas. El primero es la ejecución paso a paso, igual que en los
casos anteriores de autómatas finitos, con la diferencia de que JFLAP va
escribiendo en la parte inferior, debajo de la cadena de entrada, la cadena de
JFLAP Sara Martínez Gómez
12
salida que se va generando en cada lectura. En este caso, la única forma de
que la máquina no quede en un estado de aceptación es si algún carácter de la
cadena de entrada no pertenece al alfabeto de la máquina.
En este ejemplo hay dos estados (q0 y q1) donde el estado inicial es q0. Esta
máquina si se encuentra en el estado q0 significa que ha procesado un número
par de unos y si se encuentra en el estado q1 significa que ha procesado un
número impar de unos. Si en la salida de la misma vemos el carácter S
implicará que la máquina ha procesado un número impar de unos, si el número
de unos fuera par en la salida veríamos el carácter A. Para clarificarlo, es
conveniente observar las siguientes capturas de pantalla:
...
Pulsamos
Step hata
llegar al
final de la
cadena
Si la cadena no
es aceptada
JFLAP Sara Martínez Gómez
13
La segunda forma de simulación provista por JFLAP es la ejecución de
múltiples cadenas al mismo tiempo, cuyo funcionamiento es idéntico al ya
explicado.
Seleccionamos
varias entradas
y pulsamos en
View Trace
JFLAP Sara Martínez Gómez
14
Máquina de Moore
Una Máquina de Moore es un autómata de estados finitos donde las salidas
están determinadas exclusivamente por el estado actual de la misma y no
dependen directamente de la entrada. El diagrama de estados para una
máquina Moore, a diferencia de la de Mealy, incluirá una señal de salida para
cada estado. Formalmente, se define como una séxtupla (S, S0, Σ, Ʌ, T, G):
S = conjunto finito de estados
S0 = estado inicial
Σ = alfabeto de entrada (conjunto finito)
Ʌ = alfabeto de salida (conjunto finito)
T : S x Σ  S = función de transición
G : S  Ʌ = función de salida
Se puede ver que esta definición es idéntica a la anterior de Mealy, excepto
por la función de salida. Por tanto, es deducible que existe una
correspondencia tal que para cada máquina de Mealy hay una máquina de
Moore equivalente cuyos estados son la unión de los estados de la máquina de
Mealy y el producto cartesiano de los estados de la máquina de Mealy y el
alfabeto de entrada. Por consiguiente, el número de estados en una máquina
de Moore será mayor o igual al número de estados en una máquina de Mealy.
Al crear un autómata en el editor de máquinas de Moore, JFLAP cuando
creamos cada estado (representado por un vértice del grafo) nos obliga a
introducir su salida (si no introducimos nada la salida por defecto es λ), a
diferencia del caso anterior en el que esta era requerida en la creación del
vector y no del vértice. Es más, cuando creamos el vector solamente debemos
introducir el carácter correspondiente a esa transición. Asimismo, cabe
destacar una funcionalidad de JFLAP que poseen todos sus editores, pero que
suele ser más útil a medida que se complican los autómatas, como es el caso.
Esta funcionalidad corresponde a la posibilidad de cambiar de nombre los
estados pulsando el botón derecho y después eligiendo “Set name”. Para
clarificar el uso de una máquina de Moore crearemos una que trunca números
binarios procesando los símbolos anterior y actual pero mostrando únicamente
el anterior. Este hecho se ve muy claro en la imagen, ya que hemos
JFLAP Sara Martínez Gómez
15
renombrado los estados de forma que existen todas las posibles
combinaciones de cadenas de dos caracteres de ceros y unos, cuya
correspondiente salida es el carácter que más a la izquierda del nombre del
estado se encuentra. Los modos de simulación son los dos explicados en el
apartado anterior.
JFLAP Sara Martínez Gómez
16
Máquina de Turing
Una máquina de Turing es un modelo computacional que consta de un cabezal
lector/escritor y una cinta infinita en la que el cabezal lee el contenido, borra el
contenido anterior y escribe un nuevo valor. Formalmente, se puede definir
como una séptupla M=(Q, Σ, Γ, s, b, F, δ) donde:
Q = conjunto finito de estados
Σ = alfabeto de entrada (conjunto finito) en el que b ∉ Σ
Γ = alfabeto de la cinta (conjunto finito) tal que Σ ⊆ Γ
s ϵ Q = estado inicial
b ϵ Γ = blanco
F ⊆ Q = conjunto finito de estados finales de aceptación
δ : Q x Γ  Q x Γ < {L, R} = función (parcial) de transición donde L es el
movimiento a la izquierda y R es el movimiento a la derecha
Como podemos comprobar en la definición anterior solo existe una cinta, pero
creemos que es conveniente mencionar las máquinas de Turing multicinta. Una
máquina de Turing multicinta es simplemente una máquina de Turing normal
con varias cintas, las cuales poseen su propio cabezal. En ellas, inicialmente la
cadena de entrada se encuentra en la primera cinta y las demás permanecen
en blanco. La función de transición está modificada para permitir la lectura,
escritura y movimiento de todas las cintas simultáneamente. Formalmente, se
define como δ: Q x Γk  Q x Γk x {L, R} donde k es el número de cintas.
La expresión δ(qi, a1, …, a k) = (qj, b1, …, bk, L, R, …,L) por tanto, significa que
si la máquina se encuentra en el estado qi y las cabezales 1 a la k están
leyendo los símbolos desde a1 hasta ak, la máquina va al estado qi, escribe los
símbolos desde b1 hasta bk y mueve cada cabezal a la izquierda o derecha
según se especifica. Es interesante resaltar que cualquier máquina de Turing
multicinta es equivalente a una máquina de Turing normal de una sola cinta.
Si queremos simular una máquina de Turing normal, es decir, de una sola cinta
con JFLAP, deberemos elegir el editor “Multi-Tape Turing Maching” e introducir
un 1 cuando nos requiere el número de cintas. En el editor podremos crear los
JFLAP Sara Martínez Gómez
17
estados de la forma habitual, pero al crear las transiciones JFLAP nos requerirá
tres campos. El primero es el carácter leído, el segundo es el carácter escrito y
el tercero es el movimiento que a su vez puede ser L (izquierda), R (derecha) o
S (en el mismo lugar). Si no introducimos nada, JFLAP no introducirá el
carácter λ, introducirá un cuadrado vacío simulando que la cinta en ese
momento está vacía. Asimismo, debemos señalar cuál es el estado inicial y el
final pulsando el botón derecho.
Para clarificar lo anterior, hemos diseñado una máquina de Turing normal, es
decir, con una sola cinta que solo queda en estado de aceptación si la entrada
es “ab”. La funcionalidad que JFLAP provee para la simulación es la misma que
para cualquier autómata finito, añadiendo una ejecución múltiple para
autómatas transductores, en la que se muestra si el autómata ha quedado en
estado de aceptación o no y la cadena de salida.
En la siguiente ejecución paso a paso, podemos comprobar que la simulación
de la máquina de Turing es correcta, ya que si lee un carácter “b”, escribe una
“a” y viceversa. Al terminar de leer la cadena “ab”, queda en un estado de
aceptación si el siguiente carácter de la cinta es un blanco.
JFLAP Sara Martínez Gómez
18
Máquina de Turing compuesta
Las máquinas de Turing se pueden enlazar para obtener resultados más
completos o complicados. Las máquinas de Turing compuestas están formadas
por varios bloques, cada uno de los cuales corresponde a una máquina de
Turing simple. Esos bloques están enlazados entre sí mediante transiciones, al
igual que cualquier autómata. El funcionamiento es igual que el de cualquier
otro autómata, con la diferencia de que aquí en lugar de haber estados simples
hay máquinas de Turing, que si quedan en estado de aceptación podrán pasar
la cadena de entrada a otro bloque (correspondiente con otra máquina de
Turing). Este tipo de autómatas son de gran utilidad, ya que permiten una
mayor variedad de cómputos. JFLAP solo permite la utilización de bloques con
el mismo número de cintas, lo que limita un poco su uso. Para editar el
funcionamiento de cada bloque basta con pulsar el botón derecho y elegir “Edit
Block”, entonces se nos abrirá una nueva pestaña en la que podremos diseñar
la máquina de Turing correspondiente a ese bloque o importarla desde un
archivo ya creado.
En el siguiente ejemplo se muestra una máquina de Turing compuesta que solo
acepta cadenas de a’s seguidas de b’s y que sustituye las a’s por ceros y las
b’s por unos. Los modos de simulación son los mismos que los que hay para
las máquinas de Turing simples. En el siguiente ejemplo hemos usado la
simulación paso a paso.
Bloque1 Bloque2
JFLAP Sara Martínez Gómez
19
Gramáticas
Una gramática es una estructura matemática con un conjunto de reglas de
formación que definen las cadenas de caracteres aceptables en un
determinado lenguaje, es decir, las palabras del lenguaje. Formalmente,
diremos que una gramática es una cuaterna G = (V, Σ, Q0, P), donde:
V = alfabeto de símbolos no terminales (conjunto finito)
Σ = alfabeto de símbolos terminales (conjunto finito) tal que V ∩ Σ = ∅
Q0 ∈ V = símbolo inicial.
P ⊆ (V ∪ Σ)∗ × (V ∪ Σ)∗ = conjunto de producciones (conjunto finito)
JFLAP permite la creación de gramáticas con un editor diferenciado en el que
únicamente deberemos introducir las producciones de la gramática que
queramos crear. En el
siguiente ejemplo
introduciremos todas las
producciones necesarias
para generar una
gramática que defina
todos los palíndromos
del sistema binario, es
decir, todas las
combinaciones de ceros
y unos que sean
capicúa. Como es
habitual, si no
introducimos nada el
carácter por defecto es
λ.
Chomsky hizo una clasificación de las gramáticas dividiéndolas en cuatro tipos:
Tipo 0 (sin restricciones), que incluye a todas las gramáticas. Las
gramáticas de este tipo generan todos los lenguajes capaces de ser
JFLAP Sara Martínez Gómez
20
reconocidos por una máquina de Turing, es decir, aquellos que son
recursivamente enumerables.
Tipo 1 (gramáticas sensibles al contexto), que abarca aquellas que
tienen reglas de la forma αAβ  αγβ con A un no terminal y α,
β y γ cadenas de terminales y no terminales, donde α y β pueden ser
vacías, pero no puede serlo. La regla S  λ está permitida si S no
aparece en la parte derecha de ninguna regla. Los lenguajes descritos
por estas son reconocidos por autómatas linealmente acotados.
Tipo 2 (gramáticas libres del contexto), que incluye aquellas gramáticas
que generan los lenguajes independientes del contexto y cuyas reglas
son de la forma A γ con A un no terminal y γ una cadena de terminales
y no terminales.
Tipo 3 (gramáticas regulares), que abarcan las gramáticas que generan
los lenguajes regulares y que tienen en la parte izquierda un no terminal,
y en la parte derecha un solo terminal, posiblemente seguido de un no
terminal. Aceptan reglas del tipo S  λ. Este tipo de gramáticas son las
reconocidas por los autómatas finitos.
JFLAP tras haber introducido una gramática da al usuario la posibilidad de
saber de qué tipo de gramática se trata de
una forma fácil: solamente hay que pulsar en
el menú “Test” y, a continuación, en “Test for
Gramar type”. En la captura podemos ver
que la gramática explicada anteriormente es
una gramática libre de contexto y, por tanto,
es de tipo 2.
JFLAP, además permite varios modos de simulación o testeo de cadenas de
caracteres para saber si son aceptadas por la gramática introducida o no. Por
un lado, está la ejecución por fuerza bruta. Que requiere una cadena de
entrada para ir formando o bien el árbol dado tanto por la entrada como por la
JFLAP Sara Martínez Gómez
21
gramática, o bien la tabla de derivación. Una vez introducida la cadena
deberemos ir pulsando primero el botón “start” y después el botón “step” si nos
encontramos en la vista del árbol.
Cuando termine la ejecución si la cadena es aceptada, veremos que cada uno
de sus caracteres corresponde con un nodo hoja. De lo contrario, si no es
aceptada, será indicado en la parte superior, debajo de la cadena de entrada
junto con el número de nodos generados hasta llegar a esa conclusión.
Si pulsamos en la pestaña de la tabla de derivación, podremos ver todos los
pasos seguidos hasta que la cadena ha sido aceptada o rechazada. En este
caso también podremos realizar el seguimiento paso a paso.
JFLAP Sara Martínez Gómez
22
JFLAP, como es habitual, permite una ejecución simultánea de múltiples
cadenas por el método anterior, herramienta muy útil para tener una visión más
amplia de la gramática que nos ataña y, por consiguiente, para una mejor
definición del lenguaje correspondiente.
En el caso anterior no podemos ver ni el árbol ni la tabla de derivación. Una
tercera opción de simulación provista por JFLAP para las gramáticas es “User
Control Parse”, en este modo el usuario puede elegir la producción que prefiera
para ese determinado paso y cuando se haya llegado a un estado de
JFLAP Sara Martínez Gómez
23
aceptación será indicado por JFLAP. Este tipo de simulación es muy útil para
ver el funcionamiento de una gramática determinada. En el ejemplo siguiente
hemos ido creando un árbol, eligiendo la producción que más nos convenía en
ese momento y pulsando a continuación “step”. Cuando llegamos a un estado
de aceptación habíamos generado la cadena “1100011”, como se muestra en
la parte inferior de la pantalla (la cadena generada en cada instante del proceso
también se muestra en este lugar durante toda la simulación).
JFLAP, asimismo, provee la opción de transformar una gramática a la forma
normal de Chomsky. Una vez en el editor de “Transform gramar”, nos pide
permiso para modificar la gramática con el objetivo de eliminar los caracteres λ.
Nos informa de que va a haber una eliminación y dos adiciones, si estamos de
acuerdo deberemos pulsar el botón “step”. A continuación, nos vuelve a pedir
confirmación para eliminar los caracteres λ por completo. Si queremos llegar a
la forma normal de Chomsky, deberemos pulsar el botón “proceed”. Todos
estos pasos, se podrían haber realizado en uno solo si hubiéramos pulsado en
el botón “do all”. Como nuestra finalidad es convertir la gramática
completamente a la forma normal de Chomsky será ese botón el que
pulsemos. En ese momento, veremos nuestra gramática totalmente
transformada en una gramática con la forma normal de Chomsky.
JFLAP Sara Martínez Gómez
24
JFLAP Sara Martínez Gómez
25
Expresiones regulares
Una expresión regular es una fórmula cuyo propósito es representar un
lenguaje. Formalmente, se puede definir de manera recursiva donde las
expresiones regulares primitivas son Φ, λ y a ϵ Σ y las derivadas siguen las
siguientes reglas:
Unión = α + β
Concatenación = αβ
Clausura de Kleene = α*
JFLAP proporciona la opción de generación de un autómata a partir del editor
de expresiones regulares. Simplemente tenemos que introducir la expresión
que queramos y a continuación pulsar el botón “Convert to NFA”. Una vez que
veamos el diagrama de transición que representa el autómata, debemos pulsar
el botón “step” de tal forma que veremos el autómata más expandido con
expresiones regulares menos complejas en su interior. Cuando dichas
expresiones regulares ya no se puedan simplificar más, el botón “step” será
desactivado y significará que ese será el autómata final de la expresión regular
que habíamos introducido en primera instancia. Si preferimos saltarnos todos
los pasos podemos pulsar el botón “do all”. La expresión regular introducida en
el ejemplo representa todas las cadenas de a’s y b’s que tienen un número
impar de símbolos y el autómata obtenido es el que acepta dicho lenguaje.
JFLAP Sara Martínez Gómez
26
Después de
varios pasos
JFLAP Sara Martínez Gómez
27
Finalmente, si pulsamos el botón “export” podremos trabajar con el autómata
anterior de forma normal. Como el editor de expresiones regulares solo nos da
la posibilidad de convertirlas a un NFA, si queremos convertirla en un DFA
basta con darle al botón que corresponde a esta conversión y obtendremos
algo como lo siguiente.
Para ver más claro el autómata anterior podemos pulsar en el menú “Minimize
DFA” y visualizaremos de forma resumida los estados iniciales, finales y las
transiciones.
JFLAP Sara Martínez Gómez
28
Equivalencia
Se puede decir que dos autómatas A1 y A2 son equivalentes si aceptan
exactamente el mismo lenguaje. Como la comparación de las cadenas
pertenecientes a un lenguaje sería impensable, Moore propuso un teorema que
consiste en la creación de un árbol de comparación con las distintas
combinaciones de estados, para el cual dados dos autómtas A1 = (K1, Σ1, δ1, s1,
F1) y A2 =(K2, Σ2, δ2, s2, F2) hay que seguir las siguientes reglas:
La raiz del arbol generado es el par ordenado (s1, s2) que contiene los
estdos iniciales de A1 y A2.
Si existiera un par (r1, r2) de estados incompatibles se interrumpiría la
elaboración del árbol concluyendo que los autómatas en cuestión son
incompatibles.
Si existiera un par (r1, r2) en el árbol, para cada carácter en σ se añaden
como hojas suyas los pares (r1σ, r2σ) donde r1σ = δ1 (r1, σ), r2σ = δ2 (r2,
σ), si no existen ya.
En el caso de que no aparezcan nuevos pares (r1σ, r2σ) que no se
encuentren previamente en el árbol, se termina el proceso, concluyendo
que los dos autómatas son equivalentes.
Esta comparación es utilizada por JFLAP para saber si dos autómatas son
equivalentes, utilidad muy conveniente para los usuarios, ya que basta con
pulsar “Compare Equivalence” del menú “Test”. Decimos que es muy
conveniente, ya que permite explotar al máximo las posibilidades explicadas
anteriormente, como por ejemplo para saber si una gramática o una expresión
regular corresponden a un autómata ya dibujado previamente, bastaría con
convertirlas a autómatas y utilizar la herramienta de comparación. En el
siguiente ejemplo vamos a comparar tres autómatas simples un AFD, un AFN,
y un AFλ, cuya apariencia a simple vista se parece pero no tenemos la certeza
de que sean equivalentes. JFLAP nos evita hacer los árboles correspondientes
utilizando su herramienta de comparación.
JFLAP Sara Martínez Gómez
29
AFλAFDAFN
Son equivalentes mutuamente
JFLAP Sara Martínez Gómez
30
Práctica 1
Utilizando JFLAP, dada la siguiente expresión regular:
(a+b+c)*baba(a+b+c)*
a) Decir a qué lenguaje pertenece
b) Obtener un AFN que acepte la gramática definida por dicha expresión
regular.
c) Obtener un AFλ que acepte la gramática definida por dicha expresión
regular.
d) Obtener un AFD que acepte la gramática definida por dicha expresión
regular.
e) Decidir si los autómatas anteriores son equivalentes.
f) Decidir si es equivalente a la siguiente gramática
J  baba J  a
K  λ J  b
J  c K  J
JFLAP Sara Martínez Gómez
31
Solución
a)
Lo primero que vamos a hacer es abrir el editor para expresiones regulares. En
él introducimos la expresión dada
A continuación, lo convertimos en un AFN y lo exportamos.
JFLAP Sara Martínez Gómez
32
Introducimos varias cadenas de entrada en ese AFN para hacernos una idea
de cuál podría ser el lenguaje al que corresponde la expresión regular. Si nos
fijamos en la expresión dada vemos que está implícita la cadena “baba” por lo
que probaremos con palabras relacionadas con esa cadena y otras que no lo
estén, con el objetivo de saber cuál es el lenguaje exacto al que corresponde la
expresión que nos concierne.
Podemos comprobar que nuestras sospechas era ciertas: el lenguaje
corresponde a todas las palabras que contengan la cadena “baba”.
Formalmente:
L = {∀ w / w= (todas las palabras que contengan la cadena “baba”) ^ λ ϵ w}
b)
Este apartado estaría ya resuelto en el anterior, pero lo vamos a colocar un
poco, para ver con más claridad el funcionamiento y la estructura del autómata.
Así obtenemos lo siguiente:
JFLAP Sara Martínez Gómez
33
c)
Como ya tenemos un AFN que acepta la expresión regular dada, seguimos la
regla de que cualquier AFN es equivalente a un AFλ. Al observar que varias
transiciones del AFN son λ, podemos pensar que cuando pulsemos la opción
de convertir a un AFD, lo que nos generará realmente será un AFλ. Por tanto,
seguimos dicho procedimiento para obtenerlo:
JFLAP Sara Martínez Gómez
34
Con el paso anterior hemos comprobado que nuestras sospechas eran
erróneas y al pasar nuestro AFN a un AFD, JFLAP no ha generado un AFλ.
Para solventar esta cuestión, lo que vamos a hacer será crear dos estados
adicionales “a1” y “a2” que tendrán transiciones λ, esto convertirá el AFD
anterior en un AFλ y no afectará a la gramática que acepta el autómata.
Además vamos a eliminar todas las etiquetas para ver mejor la estructura del
mismo.
Para comprobar si estamos en lo cierto, comprobaremos su equivalencia con
JFLAP.
JFLAP Sara Martínez Gómez
35
d)
El AFD creado en el apartado c) es válido, ya que no tiene ninguna transición λ
y acepta la gramática definida por la expresión regular dada, debido a que lo
hemos creado a partir de la misma. Por tanto, eliminaremos los estados y las
transiciones λ que añadimos en el apartado c) y obtendremos el siguiente AFD.
e)
Comprobamos la equivalencia del AFN, AFD y AFλ comparándolos dos a dos.
AFN con AFD:
JFLAP Sara Martínez Gómez
36
AFN con AFλ:
AFD con AFλ:
Concluimos, por tanto, que son equivalentes.
f)
A simple vista, la gramática dada se podría parecer mucho a la expresión
regular del enunciado y, por tanto, ser equivalente a la misma. Para
comprobarlo vamos a introducir la nueva gramática en el editor correspondiente
de JFLAP. A continuación escogeremos la opción de convertirla en un
autómata finito (FA) con el fin de comparar la equivalencia de este con uno de
los que ya habíamos obtenido anteriormente. Nos basamos en que si dos
autómatas son equivalentes es porque admiten la misma gramática y, por
JFLAP Sara Martínez Gómez
37
consiguiente, podríamos comprobar si la expresión regular y la gramática que
nos atañen son equivalentes.
Gracias a JFLAP hemos podido comprobar que nuestras sospechas eran
erróneas y que la gramática dada y la expresión regular del enunciado no son
equivalentes.
JFLAP Sara Martínez Gómez
38
Practica 2
a) Dibujar una máquina de Turing de una sola cinta que solo quede en
estado de aceptación si el número de unos es par teniendo como
alfabeto de entrada Σ = {0, 1} y como alfabeto de cinta Γ = {0, 1, □}
b) Dibujar una máquina de Turing de una sola cinta cuyo alfabeto de
entrada sea Σ = {0, 1}, cuyo alfabeto de cinta sea Γ = {0, 1, □} y que solo
acepte cadenas de unos seguidos de ceros, excluyendo la cadena
vacía.
c) Modelar una máquina de Turing compuesta por bloques formados por
las máquinas de los apartados b) y c).
JFLAP Sara Martínez Gómez
39
Solución
a)
Para construir la máquina de Turing pedida en este apartado iremos al editor
de máquinas de Turing y diremos que tenga una única cinta. Crearemos en un
principio dos estados “q0” y “q1”, que estarán unidos por transiciones que leen
unos y escriben unos y que tendrán transiciones propias que harán lo mismo
pero con ceros. De esta forma nos aseguramos que cuando estemos en el
estado “q0” la máquina habrá leído un número par de unos. Por tanto, creamos
otro estado “q2”, final, que estará unido con “q0” con una transición tal que si
lee la cadena vacía, es decir, si se ha llegado al final de la entrada escriba un 0
y, por consiguiente, si ha habido un número par de unos la máquina quedará
en estado de aceptación. Haremos lo homólogo con los ceros creando un
estado “q3” que no será final, y si la máquina llega a él, quedará en estado de
no aceptación, lo que significará que la entrada tenía un número impar de unos.
Hay que tener en cuenta que consideramos el 0 cómo un número par, por
tanto, si no hay ningún 1 en la cadena, la máquina de Turing quedará en
estado de aceptación.Para comprobar el correcto funcionamiento de lo
explicado anteriormente, hemos simulado el funcionamiento con varias
cadenas.
JFLAP Sara Martínez Gómez
40
b)
Para construir la máquina de Turing pedida en este apartado iremos al editor
de máquinas de Turing y elegiremos una sola cinta. Crearemos dos estados,
uno que acepte ceros y otro que acepte unos. El que acepte los unos será el
inicial y el que acepte los ceros será el que conducirá a un tercer estado que
será el final. Este tercer estado es necesario porque sino la máquina cuando
leyera un cero quedaría en estado de aceptación y se pararía. La máquina
cambiará de estado cuando lea un cero. Si después de haber leído un cero, lee
un uno quedará en estado de no aceptación, ya que no pasará al estado final.
Haremos varias ejecuciones paso a paso para ver su funcionamiento.
Vemos que efectivamente no acepta cadenas que tengan un cero seguido por
un uno. En la siguiente ejecución introduciremos una cadena de unos seguida
de ceros para ver que queda en estado de aceptación.
JFLAP Sara Martínez Gómez
41
c)
Para construir la máquina de Turing compuesta pedida en este apartado, nos
fijaremos en que la máquina de Turing del apartado c) solo acepta cadenas que
empiecen por 1, por tanto esta será la transición que nos servirá para unir los
dos bloques del autómata compuesto. Por lo demás, ya tenemos todo el trabajo
hecho. El primer bloque corresponderá a la máquina del apartado b) y será el
JFLAP Sara Martínez Gómez
42
inicial. Y el segundo bloque corresponderá a la máquina del apartado c) y será
el final. Haremos una ejecución paso a paso para ver si la unión de las dos
máquinas es correcta y cumple con las restricciones de las máquinas
individuales.
JFLAP Sara Martínez Gómez
43
Práctica 3
Utilizando JFLAP, diseñar una máquina de Turing que solo acepte palíndromos
en binario mayores que 0 y que calcule si el número de unos de su sucesor en
binario es par o impar imprimiendo el resultado con la forma “número de unos
en unario”+”blanco”+ “PAR” o “IMPAR”, por ejemplo “11111□IMPAR” o
“111111□PAR”.
Solución
A simple vista, nos podría parecer una máquina sumamente complicada, ya
que tiene que comprobar varias cosas y realizar algunos cálculos. Por ello,
vamos a dividirla en cuatro subproblemas: comprobar si la entrada es un
palíndromo en binario, hallar el sucesor de la entrada en binario, eliminar los
ceros de un número en binario, y comprobar si un número en unario es par o
impar e imprimir el resultado. Una vez tengamos resuelto cada problema por
separado, los uniremos utilizando una máquina de Turing compuesta por varios
bloques teniendo en cuenta que los números en binario siempre empiezan por
1, al igual que en unario. Por tanto, utilizaremos esta propiedad para unir los
diferentes bloques de la máquina.
Para resolver el primer subproblema procederemos de la siguiente forma.
Como para ser un palíndromo la cadena tiene que ser igual tanto en el inicio
como en el final, la máquina leerá el primer carácter de la entrada, recorrerá la
cadena hasta el final y comprobará si el último es el mismo carácter que el ya
leído. Ambos los sustituirá por un blanco y realizará esta tarea hasta que la
cinta esté formada solo por blancos y si solo quedara un carácter (porque la
longitud de la cadena de entrada fuera impar), lo sustituiría por un blanco
también. Si la cadena está formada solo por blancos será señal de que la
entrada era un palíndromo en binario y la máquina quedará en estado de
aceptación en ese momento.
En la siguiente ejecución paso a paso comprobaremos que si la entrada no es
un palíndromo en binario la máquina quedaría en estado de no aceptación.
JFLAP Sara Martínez Gómez
44
En la ejecución paso a paso que vemos a continuación, podemos clarificar el
funcionamiento de la máquina cuando queda en un estado de aceptación:
...
JFLAP Sara Martínez Gómez
45
Para resolver el segundo subproblema nos fijaremos en que siempre el sucesor
de un número en binario que termina en 0 es el mismo número pero cambiando
el último 0 por un 1 y en que si el número termina en 1, su sucesor es el mismo
número pero cambiando desde la parte derecha a la izquierda todos los unos
por ceros hasta encontrar un 0 que se cambia por un 1. Por tanto, nuestra
máquina de Turing seguirá este razonamiento para hallar el sucesor de la
entrada. Con el fin de aclarar esta regla general vamos a poner dos ejemplos,
uno que termine en 0 y otro que termine en 1.
Elegimos un número binario cualquiera que termine en 0 y ejecutamos la
máquina de Turing que nos atañe paso a paso:
Hemos comprobado que efectivamente ha calculado el sucesor cambiando el 0
por un 1. Si el número termina en 1 la ejecución es un poco más compleja por
lo que la ejecución paso a paso requerirá de más movimientos hasta llegar al
resultado final.
...
JFLAP Sara Martínez Gómez
46
Para resolver el tercer subproblema recorreremos la cadena de entrada hasta
llegar al primer 0, que cambiaremos por una X. A continuación, seguiremos
leyendo ceros hasta encontrar otro 1, este lo cambiaremos por un 0 y
retrocederemos a la izquierda hasta encontrar la X que habíamos puesto como
marca. En este punto sustituiremos la marca que habíamos puesto por un 1.
Realizaremos esta tarea mientras queden unos en la cadena. Una vez que
veamos que no hay más unos en la cadena a la derecha del control finito,
sustituiremos todos los ceros por blancos y terminaremos. Si la cadena
estuviese formada únicamente por unos, iríamos directamente al final.
...
JFLAP Sara Martínez Gómez
47
La siguiente ejecución nos ayudará a clarificar el funcionamiento de la
máquina:
...
...
JFLAP Sara Martínez Gómez
48
Para resolver el cuarto subproblema, utilizaremos dos estados, uno que
represente un número impar de unos y otro que represente un número par de
unos. Cuando el autómata haya terminado de leer la cadena unos, imprimirá en
la cinta el resultado dependiendo de en el estado que haya quedado.
El funcionamiento de esta máquina de Turing es muy simple. Las siguientes
imágenes corresponden a una ejecución paso a paso de un número impar:
JFLAP Sara Martínez Gómez
49
Una vez que tenemos cada subproblema resuelto vamos a proceder a unirlos
todos en una máquina de Turing compuesta, en la que cada bloque
corresponderá a una máquina de las anteriores. Estos bloques irán unidos por
transiciones que solo aceptarán un 1, ya que cualquier número en binario o en
unario mayor que cero debe comenzar por 1. Está claro que el alfabeto de la
máquina final será la unión de cada uno de los alfabetos de las máquinas por
las que está compuesta.
Realizaremos una ejecución paso a paso para comprobar si la unión que
hemos realizado es correcta:
Como es un palíndromo
pasa a q1, de lo contrario
se quedaría en q0
En q1 ya ha calculado el
sucesor, que es el número
que aparece en la cinta
En q2 ha quitado los ceros
existentes en el número
calculado por q1, dejando
el resultado en la cinta
En q3 ha comprabado si el
número de unos es par y ha
impreso el resultado, dejando
la cinta en la forma pedida en
el enunciado
JFLAP Sara Martínez Gómez
50
Práctica 4
Utilizando JFLAP, diseñar una máquina de Turing compuesta por un bloque,
que con varias cintas compruebe si la cadena de entrada es del tipo An
Bn
Cn
tal
que n>0, y por otro que la duplique. El resultado final debe tener la forma
An
Bn
Cn
An
Bn
Cn
, o dicho de otra manera (An
Bn
Cn
)2
.
Solución
Siguiendo el enunciado vemos que el ejercicio consiste en realizar dos
máquinas de Turing por separado y luego unirlas, sabiendo que empiezan por
“A”.
Para el diseño de la primera máquina utilizaremos tres cintas, ya que hay tres
caracteres distintos. Para ello iremos el editor de máquinas de Turing multicinta
e introduciremos un 3 cuando nos pide el número de cintas. Solo
introduciremos una entrada en la primera cinta para que la máquina, si se
cumplen las condiciones del enunciado, quede en estado de aceptación. El
funcionamiento de nuestra máquina se basará en que si lee una “A” en la
primera cinta, la escribirá en la segunda y si lee una “B” en la primera cinta la
escribirá en la tercera. Todo ello bajo la restricción de que la entrada debe
comenzar por A, que todas las A’s solo pueden estar seguidas por una “A” o
una “B”, que todas las B’s solo pueden estar seguidas por una “B” o una “C” y
que todas las C’s solo pueden ir seguidas de otra “C” o de la cadena vacía.
Una vez que tengamos rellenadas las tres cintas, las dos cintas inferiores se
moverán a la izquierda y la primera mantendrá su posición, de forma que en la
primera cinta tiene que haber una “C”, en la segunda una “A” y en la tercera
una “B”. Cuando la primera llegue a la cadena vacía, es decir, cuando se haya
acabado la entrada si el número de A’s y B’s es igual que el de C’s e igual
entre sí, entonces todas las cintas leerán la cadena vacía y la máquina quedará
en estado de aceptación. Aquí mostramos dos ejecuciones erróneas:
JFLAP Sara Martínez Gómez
51
Hemos podido comprobar que si el número de los caracteres de distinto tipo es
el mismo, la máquina quedará en estado de aceptación cuando lee un blanco
en cada una de las cintas que la forman.
JFLAP Sara Martínez Gómez
52
Para el diseño de la segunda máquina vamos a utilizar una única cinta, que
marcará el final de la cadena de entrada con una “Y”. A continuación, leerá el
segundo carácter (ya que el primero lo dejamos para el final), lo marcará con
una “X” (para saber a dónde regresar tras la escritura) y lo escribirá después
del último carácter que haya tras la “Y”, entonces regresará a la “X” y la
cambiará por el símbolo que había leído. Para realizar esta tarea
necesitaremos tres ramas que harán lo mismo exceptuando el símbolo de
escritura, es decir, hacer una rama es la forma de “guardar” el símbolo leído.
Se realizará este proceso hasta que la máquina se encuentre con la “Y”,
entonces la sustituirá por el su símbolo correspondiente, utilizando para ello
otras tres ramas (una por cada carácter diferente).
JFLAP Sara Martínez Gómez
53
En la ejecución paso a paso anterior solo hemos mostrado los pasos más
relevantes.
Finalmente, no debemos olvidar que el objetivo del ejercicio es realizar una
máquina de Turing compuesta. Por tanto, uniremos las máquinas ya creadas
con una transición “A”, ya que el formato de cadena del primer bloque obliga a
ello.
Pasa de q0 a q1
porque el número
de As, Bs y Cs es
igual
Una vez que ha
terminado la ejecución
de q2, la cadena de
entrada queda
duplicada en la cinta
JFLAP Sara Martínez Gómez
54
Fuentes de información
http://www.jflap.org/
https://www.google.es/url?sa=t&rct=j&q=&esrc=s&source=web&cd=8&ve
d=0CFoQFjAHahUKEwj83Kvgt-
LIAhUHNhoKHTI9BQg&url=http%3A%2F%2Fwww.mcvts.net%2Fsite%2
Fhandlers%2Ffiledownload.ashx%3Fmoduleinstanceid%3D7219%26dat
aid%3D4882%26FileName%3DJFLAP.pdf&usg=AFQjCNGmOHs-
t2x4UjhxWJrF3Zku8uaOLg&bvm=bv.106130839,d.d2s&cad=rja
http://ocw.uc3m.es/ingenieria-informatica/teoria-de-automatas-y-
lenguajes-formales/practicas-1/solucion-a-las-practicas-de-jflap
https://ritdml.rit.edu/bitstream/handle/1850/8712/DNortonUsersGuide02-
2008.pdf?sequence=2
http://www.cs.duke.edu/csed/rodger/papers/iticse2011tips.pdf
http://www.cs.duke.edu/csed/rodger/papers/pviswk02.pdf
http://www.idt.mdh.se/kurser/cd5560/14_11/LABS/JFLAP%20MANUAL%
20AND%20EXERCISES-20130311.pdf
http://ecx.images-
amazon.com/images/I/513QBC0B57L._SX389_BO1,204,203,200_.jpg
http://maquinaturing.blogspot.com.es/p/maquina-turing-multicintas.html
http://es.slideshare.net/JesusDavid13/maquinas-de-
turing?next_slideshow=1
http://ocw.unican.es/ensenanzas-tecnicas/teoria-de-automatas-y-
lenguajes-formales/material-de-clase-nuevo/nuevo/1-
3_Gramaticas_formales.pdf
https://es.wikipedia.org/wiki/Teorema_de_Moore
https://es.wikipedia.org/wiki/Expresi%C3%B3n_regular
https://es.wikipedia.org/wiki/Gram%C3%A1tica_formal#Gram.C3.A1ticas
_formales_en_matem.C3.A1ticas_y_l.C3.B3gica
https://es.wikipedia.org/wiki/Jerarqu%C3%ADa_de_Chomsky
http://es.slideshare.net/iscrquinter/parte-4-mquinas-de-turing
http://www.mast.queensu.ca/~ggsmith/Math401/images/petersen3.png
https://upload.wikimedia.org/wikipedia/commons/thumb/9/97/Petersen2_t
iny.svg/220px-Petersen2_tiny.svg.png
JFLAP Sara Martínez Gómez
55
https://upload.wikimedia.org/wikipedia/commons/thumb/5/51/D%C3%BC
rer_graph.svg/220px-D%C3%BCrer_graph.svg.png
https://upload.wikimedia.org/wikipedia/commons/thumb/9/91/Petersen1_t
iny.svg/200px-Petersen1_tiny.svg.png
http://www.uhu.es/francisco.moreno/talf/docs/tema4_1.pdf
https://es.wikipedia.org/wiki/Aut%C3%B3mata_finito
https://es.wikipedia.org/wiki/M%C3%A1quina_de_estados
https://es.wikipedia.org/wiki/M%C3%A1quina_de_Moore
https://es.wikipedia.org/wiki/M%C3%A1quina_de_Mealy

Más contenido relacionado

La actualidad más candente

1.3 lenguajes de simulacion y simuladores
1.3 lenguajes de simulacion y simuladores1.3 lenguajes de simulacion y simuladores
1.3 lenguajes de simulacion y simuladores
JoOsee Kette
 
Autómatas de Pila
Autómatas de PilaAutómatas de Pila
Autómatas de Pila
Pablo Guerra
 
Notación infija postfija
Notación infija postfijaNotación infija postfija
Notación infija postfija
Omarzingm
 
Unidad 3 topicos avanzados de programacion
Unidad 3 topicos avanzados de programacionUnidad 3 topicos avanzados de programacion
Unidad 3 topicos avanzados de programacion
Irving Che
 

La actualidad más candente (20)

Unidad1 Lenguajes y automatas
Unidad1 Lenguajes y automatasUnidad1 Lenguajes y automatas
Unidad1 Lenguajes y automatas
 
Tipos de gramatica y arboles de derivacion
Tipos de gramatica y arboles de derivacionTipos de gramatica y arboles de derivacion
Tipos de gramatica y arboles de derivacion
 
Los lenguajes aceptados para una maquina de turing
Los lenguajes aceptados para una maquina de turingLos lenguajes aceptados para una maquina de turing
Los lenguajes aceptados para una maquina de turing
 
Tipos de Autómatas 
Tipos de Autómatas Tipos de Autómatas 
Tipos de Autómatas 
 
1.3 lenguajes de simulacion y simuladores
1.3 lenguajes de simulacion y simuladores1.3 lenguajes de simulacion y simuladores
1.3 lenguajes de simulacion y simuladores
 
Estándares para el Modelado de Procesos de Negocios
Estándares para el Modelado de Procesos de NegociosEstándares para el Modelado de Procesos de Negocios
Estándares para el Modelado de Procesos de Negocios
 
Autómatas de Pila
Autómatas de PilaAutómatas de Pila
Autómatas de Pila
 
Jerarquia de chomsky
Jerarquia de chomskyJerarquia de chomsky
Jerarquia de chomsky
 
GRAMATICAS AMBIGUAS
GRAMATICAS AMBIGUASGRAMATICAS AMBIGUAS
GRAMATICAS AMBIGUAS
 
Traductor y su estructura
Traductor y su estructuraTraductor y su estructura
Traductor y su estructura
 
Analizador léxico
Analizador léxicoAnalizador léxico
Analizador léxico
 
Automata de Pila y Maquina de Turing No Deterministas
Automata de Pila y Maquina de Turing No DeterministasAutomata de Pila y Maquina de Turing No Deterministas
Automata de Pila y Maquina de Turing No Deterministas
 
Modelos de arquitecturas de computadoras
Modelos de arquitecturas de computadorasModelos de arquitecturas de computadoras
Modelos de arquitecturas de computadoras
 
La maquina de Turing, sus tipos y aplicaciones.
La maquina de Turing, sus tipos y aplicaciones.La maquina de Turing, sus tipos y aplicaciones.
La maquina de Turing, sus tipos y aplicaciones.
 
Automata Finito No Determinista
Automata Finito No DeterministaAutomata Finito No Determinista
Automata Finito No Determinista
 
Analizador Sintáctico
Analizador SintácticoAnalizador Sintáctico
Analizador Sintáctico
 
Gramática Libre de Contexto
Gramática Libre de ContextoGramática Libre de Contexto
Gramática Libre de Contexto
 
Automatas Finitos Deterministicos y No Deterministicos
Automatas Finitos Deterministicos y No DeterministicosAutomatas Finitos Deterministicos y No Deterministicos
Automatas Finitos Deterministicos y No Deterministicos
 
Notación infija postfija
Notación infija postfijaNotación infija postfija
Notación infija postfija
 
Unidad 3 topicos avanzados de programacion
Unidad 3 topicos avanzados de programacionUnidad 3 topicos avanzados de programacion
Unidad 3 topicos avanzados de programacion
 

Destacado (7)

Spin. problemas resueltos 1
Spin. problemas resueltos 1Spin. problemas resueltos 1
Spin. problemas resueltos 1
 
305851 resistencia-de-materiales-problemas-resueltos
305851 resistencia-de-materiales-problemas-resueltos305851 resistencia-de-materiales-problemas-resueltos
305851 resistencia-de-materiales-problemas-resueltos
 
Resistencia de materiales - tomo II - Timoshenko
Resistencia de materiales - tomo II - TimoshenkoResistencia de materiales - tomo II - Timoshenko
Resistencia de materiales - tomo II - Timoshenko
 
Resistencia de materiales - tomo I - Timoshenko
Resistencia de materiales - tomo I  - TimoshenkoResistencia de materiales - tomo I  - Timoshenko
Resistencia de materiales - tomo I - Timoshenko
 
Ejercicios de resistencia_de_materiales_resueltos
Ejercicios de resistencia_de_materiales_resueltosEjercicios de resistencia_de_materiales_resueltos
Ejercicios de resistencia_de_materiales_resueltos
 
Resistencia de materiales luis berrocal
Resistencia de materiales   luis berrocalResistencia de materiales   luis berrocal
Resistencia de materiales luis berrocal
 
Problemas resueltos resistencia(1)
Problemas resueltos resistencia(1)Problemas resueltos resistencia(1)
Problemas resueltos resistencia(1)
 

Similar a Tutorial de JFLAP

Maquina de turing
Maquina de turingMaquina de turing
Maquina de turing
diego
 
Automatas 2014 s1 guía
Automatas 2014 s1 guíaAutomatas 2014 s1 guía
Automatas 2014 s1 guía
raflhax
 
Máquina de turing
Máquina de turingMáquina de turing
Máquina de turing
Ivan
 
Maquinas de estado
Maquinas de estadoMaquinas de estado
Maquinas de estado
_05mauricio
 
presentacionalgoritmos-111003021701-phpapp01.pdf
presentacionalgoritmos-111003021701-phpapp01.pdfpresentacionalgoritmos-111003021701-phpapp01.pdf
presentacionalgoritmos-111003021701-phpapp01.pdf
MariselaBardales1
 
Algoritmos
AlgoritmosAlgoritmos
Algoritmos
Carlos
 

Similar a Tutorial de JFLAP (20)

Presentacion 2 - Maquinas de Estado Finito
Presentacion 2 - Maquinas de Estado FinitoPresentacion 2 - Maquinas de Estado Finito
Presentacion 2 - Maquinas de Estado Finito
 
Maquina de turing
Maquina de turingMaquina de turing
Maquina de turing
 
Automatas 2014 s1 guía
Automatas 2014 s1 guíaAutomatas 2014 s1 guía
Automatas 2014 s1 guía
 
Maquina de turing
Maquina de turingMaquina de turing
Maquina de turing
 
Portafolio lenguajes y automatas unidad 3 - Autómatas finitos
Portafolio lenguajes y automatas unidad 3 - Autómatas finitosPortafolio lenguajes y automatas unidad 3 - Autómatas finitos
Portafolio lenguajes y automatas unidad 3 - Autómatas finitos
 
Máquina de turing
Máquina de turingMáquina de turing
Máquina de turing
 
Automatas[1]
Automatas[1]Automatas[1]
Automatas[1]
 
Maquinas de estado
Maquinas de estadoMaquinas de estado
Maquinas de estado
 
Reny galaviz web quest
Reny galaviz web questReny galaviz web quest
Reny galaviz web quest
 
Reny Galaviz Web Quest
Reny Galaviz Web QuestReny Galaviz Web Quest
Reny Galaviz Web Quest
 
Automatas de estado finito
Automatas de estado finitoAutomatas de estado finito
Automatas de estado finito
 
Mini manual de JFlap
Mini manual de JFlapMini manual de JFlap
Mini manual de JFlap
 
Máquinas de turing kendra, webster, yasselys
Máquinas de turing kendra, webster, yasselysMáquinas de turing kendra, webster, yasselys
Máquinas de turing kendra, webster, yasselys
 
Webquest
WebquestWebquest
Webquest
 
MANDALA
MANDALAMANDALA
MANDALA
 
Teoría de autómatas
Teoría de autómatasTeoría de autómatas
Teoría de autómatas
 
presentacionalgoritmos-111003021701-phpapp01.pdf
presentacionalgoritmos-111003021701-phpapp01.pdfpresentacionalgoritmos-111003021701-phpapp01.pdf
presentacionalgoritmos-111003021701-phpapp01.pdf
 
1 conceptos algoritmos
1 conceptos algoritmos1 conceptos algoritmos
1 conceptos algoritmos
 
Presentacion algoritmos
Presentacion algoritmosPresentacion algoritmos
Presentacion algoritmos
 
Algoritmos
AlgoritmosAlgoritmos
Algoritmos
 

Último

TECNOLOGÍA DE LA INFORMACIÓN SLIDESHARE INVESTIGACION.pdf
TECNOLOGÍA DE LA INFORMACIÓN SLIDESHARE INVESTIGACION.pdfTECNOLOGÍA DE LA INFORMACIÓN SLIDESHARE INVESTIGACION.pdf
TECNOLOGÍA DE LA INFORMACIÓN SLIDESHARE INVESTIGACION.pdf
UPSE
 
TECNOLOGIA DE LA INFORMACION Y MULTIMEDIA 15 MAYO.pptx
TECNOLOGIA DE LA INFORMACION Y MULTIMEDIA 15 MAYO.pptxTECNOLOGIA DE LA INFORMACION Y MULTIMEDIA 15 MAYO.pptx
TECNOLOGIA DE LA INFORMACION Y MULTIMEDIA 15 MAYO.pptx
UPSE
 

Último (10)

Especificación casos de uso del negocio
Especificación  casos de uso del negocioEspecificación  casos de uso del negocio
Especificación casos de uso del negocio
 
CIBERSEGURIDAD Y SEGURIDAD INFORMÁTICA.pptx
CIBERSEGURIDAD  Y SEGURIDAD INFORMÁTICA.pptxCIBERSEGURIDAD  Y SEGURIDAD INFORMÁTICA.pptx
CIBERSEGURIDAD Y SEGURIDAD INFORMÁTICA.pptx
 
Modelado de Casos de uso del negocio
Modelado de  Casos  de  uso  del negocioModelado de  Casos  de  uso  del negocio
Modelado de Casos de uso del negocio
 
serenidad APP presentacion.pdfes una innovadora aplicación móvil diseñada par...
serenidad APP presentacion.pdfes una innovadora aplicación móvil diseñada par...serenidad APP presentacion.pdfes una innovadora aplicación móvil diseñada par...
serenidad APP presentacion.pdfes una innovadora aplicación móvil diseñada par...
 
Ciberseguridad y Seguridad Informática Franco Correa Grupo B.pptx
Ciberseguridad y Seguridad Informática Franco Correa Grupo B.pptxCiberseguridad y Seguridad Informática Franco Correa Grupo B.pptx
Ciberseguridad y Seguridad Informática Franco Correa Grupo B.pptx
 
El necesario mal del Legacy Code (Drupal Iberia 2024)
El necesario mal del Legacy Code (Drupal Iberia 2024)El necesario mal del Legacy Code (Drupal Iberia 2024)
El necesario mal del Legacy Code (Drupal Iberia 2024)
 
TECNOLOGÍA DE LA INFORMACIÓN SLIDESHARE INVESTIGACION.pdf
TECNOLOGÍA DE LA INFORMACIÓN SLIDESHARE INVESTIGACION.pdfTECNOLOGÍA DE LA INFORMACIÓN SLIDESHARE INVESTIGACION.pdf
TECNOLOGÍA DE LA INFORMACIÓN SLIDESHARE INVESTIGACION.pdf
 
LA CALIDAD DE LA INFORMACION EN LA NUEVA ERA DEL INTERNET
LA CALIDAD DE LA INFORMACION  EN LA NUEVA ERA DEL INTERNETLA CALIDAD DE LA INFORMACION  EN LA NUEVA ERA DEL INTERNET
LA CALIDAD DE LA INFORMACION EN LA NUEVA ERA DEL INTERNET
 
TECNOLOGIA DE LA INFORMACION Y MULTIMEDIA 15 MAYO.pptx
TECNOLOGIA DE LA INFORMACION Y MULTIMEDIA 15 MAYO.pptxTECNOLOGIA DE LA INFORMACION Y MULTIMEDIA 15 MAYO.pptx
TECNOLOGIA DE LA INFORMACION Y MULTIMEDIA 15 MAYO.pptx
 
Tipos de datos en Microsoft Access definiciones.pdf
Tipos de datos en Microsoft Access definiciones.pdfTipos de datos en Microsoft Access definiciones.pdf
Tipos de datos en Microsoft Access definiciones.pdf
 

Tutorial de JFLAP

  • 2. JFLAP Sara Martínez Gómez 2 Índice ¿Qué es?............................................................................................................ 3 Historia ............................................................................................................... 3 Autómatas .......................................................................................................... 4 Autómatas finitos............................................................................................. 5 Máquina de Mealy ..................................................................................... 11 Máquina de Moore..................................................................................... 14 Máquina de Turing ........................................................................................ 16 Máquina de Turing compuesta compuesta................................................ 18 Gramáticas....................................................................................................... 19 Expresiones regulares...................................................................................... 25 Equivalencia..................................................................................................... 28 Práctica 1 ......................................................................................................... 30 Solución ........................................................................................................ 31 Practica 2 ......................................................................................................... 38 Solución ........................................................................................................ 39 Práctica 3 ......................................................................................................... 43 Solución ........................................................................................................ 43 Práctica 4...................................................................................................... 50 Solución ........................................................................................................ 50 Fuentes de información.................................................................................... 54
  • 3. JFLAP Sara Martínez Gómez 3 ¿Qué es? JFLAP (Java Formal Languages and Automata Package) es una extensa herramienta visual e interactiva que hace posible crear y simular autómatas con el objetivo de experimentar con ellos y con sus lenguajes y gramáticas, la cual requiere la instalación previa de Java para poder ejecutarla correctamente. Proporciona una forma fácil para visualizar y experimentar con conceptos teóricos al permitir construir, probar y depurar diagramas de transición de los tres tipos de autómatas, además de posibilitar el análisis sintáctico de los árboles para las gramáticas creadas. Su principal objetivo es evitar o corregir los errores en una materia tan propensa a ellos como es la creación de DFAs y NFAs, expresiones regulares, lenguajes, máquinas de Turing o gramáticas. Historia El desarrollo de JFLAP comenzó en 1990, cuando Susan H. Rodger vio la necesidad de desarrollar una herramienta para que sus alumnos pudieran resolver los problemas relacionados con la asignatura de complejidad computacional, que ella impartía, en un ordenador, en lugar de en papel como se hacía hasta ese momento. Esta necesidad fue instada por lo tedioso que resultaba rastrear las rutas de los modelos escritos a mano para ver sus fallos. FLAP comenzó como varias herramientas más pequeñas (NPDA, LR Analizador, LL Analizador, Tubb, FLAP) para diferentes conceptos de lenguajes formales, escritos en C ++ y X Window, todas ellas de software libre. En 1996 FLAP fue rescrito en Java en la Universidad de Duke y se convirtió en ese momento en JFLAP, herramienta de instalación mucho más fácil que su
  • 4. JFLAP Sara Martínez Gómez 4 predecesora. En 2002, fue rescrita de nuevo utilizando Swing, lo que la ha provisto de una mejor interfaz gráfica. Desde entonces, se ha incrementado mucho el uso de esta herramienta hasta llegar a las 64.000 descargas en 2008 por personas que se encontraban en 161 países diferentes. El siguiente mapa muestra dichos países coloreados en verde: Autómatas Los autómatas o máquinas de estados son un modelo de comportamiento de un sistema con entradas y salidas, cuyos intermediarios son un conjunto de estados que hacen que el historial de señales de entrada determine para cada instante un estado de la máquina provocando que la salida de la misma dependa solamente de sus estados y entradas actuales. Con JFLAP se pueden diseñar y animar tres tipos de autómatas: autómatas finitos, autómatas pushdown y máquinas de Turing multicinta. Todas estas máquinas pueden ser deterministas o no deterministas. En el uso de la herramienta, se traza gráficamente una de las máquinas como un diagrama de transición, se introduce una cadena de entrada, y a continuación, se controla la trazabilidad dicha cadena a través de la máquina gracias a los diferentes modos de simulación de los que está dotada la herramienta que nos atañe.
  • 5. JFLAP Sara Martínez Gómez 5 Autómatas finitos Un autómata finito es un sistema que realiza cómputos sobre una entrada para producir una salida. Está formado por una 5-tupla: un alfabeto, un conjunto de estados finito, una función de transición, un estado inicial y un conjunto de estados finales. Q = conjunto finito de estados Σ = alfabeto finito q0 ϵ Q = estado inicial δ: Q x Σ Q = función de transición F ⊆ Q = conjunto de estados finales Su funcionamiento consiste en que el autómata recibe una cadena de caracteres que pertenecen al alfabeto y va leyendo dicha entrada para procesarla según la función de transición de forma que va cambiando de estado hasta llegar a un estado final, es decir, hasta proporcionar una salida. Todo ello se representa mediante grafos, que son los diagramas utilizados por JFLAP para hacer las simulaciones del funcionamiento anterior. El conjunto de estados se representa como un cúmulo de vértices, unidos mediante vectores etiquetados que representan cada una de las transiciones de la función δ. El estado inicial se diferencia del resto por tener un vector que llega a él sin un origen. Los estados finales pertenecientes a F tienen una doble circunferencia en su representación. JFLAP permite la creación de los estados pulsando el botón que representa el vértice, situado en la parte superior y los enumera de forma automática. Para representar los vectores existe un botón que tras ser pulsado obliga al usuario a situarse en el estado origen de la transición, pulsar sobre él y, a continuación, pulsar sobre el estado destino. Una vez dibujado, se debe indicar el carácter o caracteres correspondientes a la misma, si no se indica nada se considerará que es el carácter vacío representado por λ. Si queremos indicar que el estado en el que nos encontramos es inicial, deberemos pulsar el botón derecho e indicarlo, de esta forma aparecerá una flecha indicándolo. El mismo procedimiento deberemos realizar para indicar que el estado en el que nos
  • 6. JFLAP Sara Martínez Gómez 6 encontramos es final, de tal manera que aparecerá con una doble circunferencia. Además podemos resaltar las transiciones vacías y las no deterministas. JFLAP provee cuatro modos de simulación para los autómatas dibujados anteriormente que tratan de diversas maneras las cadenas de entrada introducidas. El primero es la ejecución paso a paso con cierre para ver los Añadir transición a los estados Marcar los estados inicial y final Resaltar las transiciones λ
  • 7. JFLAP Sara Martínez Gómez 7 estados por los que cruza la cadena introducida a través del autómata hasta llegar al final. El segundo es la ejecución paso a paso simple, en la que el usuario puede ir eligiendo los estados por los que cruza la cadena introducida en caso de que sea un autómata no determinista y si es determinista realiza la misma función que el anterior. El tercero es la ejecución rápida que consiste en ver simplemente el valor de retorno del autómata para comprobar si ha quedado en un estado de aceptación o no. El cuarto posibilita la entrada múltiple de cadenas con el fin de ver las diferentes salidas del autómata. En la siguiente imagen podemos ver la ejecución paso a paso, vemos como cada vez que pulsamos sobre el botón “step”, el autómata lee una nueva letra de la cadena de entrada y cambia de estado o se queda en el mismo. Las letras ya leídas se pueden ver en la parte inferior coloreadas en gris y el estado en el que se encuentra el autómata en ese momento se pude ver sombreado. Asimismo, si la entrada no es contemplada por la máquina o la máquina termina en un estado de no aceptación la parte inferior será coloreada en rojo. Si por el contrario la máquina termina en un estado de aceptación la parte inferior será coloreada en verde. Si pulsáramos sobre el botón “reset” el autómata comenzaría a leer la cadena introducida de nuevo desde el principio.
  • 8. JFLAP Sara Martínez Gómez 8 En la ejecución rápida una vez introducida la cadena de entrada y pulsado el botón de “OK”, veremos una alerta informándonos del estado final de la máquina: aceptación o rechazo. Si el estado es de aceptación veremos que además se muestra una descripción de los estados por los que ha ido pasando la máquina al leer la cadena.
  • 9. JFLAP Sara Martínez Gómez 9 En la ejecución de múltiples cadenas de entrada podemos introducir diversas cadenas en la parte derecha y ver el estado en el que queda la máquina tras su ejecución al pulsar el botón “Run inputs”. Si pulsamos el botón “Clear” se borrarán todas las cadenas que hemos introducido. Asimismo, podemos ver la descripción de los distintos estados por los que ha pasado la máquina al leer cada una de las cadenas introducidas si las seleccionamos y pulsamos el botón “View trace”. Además para facilitar la entrada de la cadena vacía existe el botón “Enter λ” y para restaurar entradas ya guardadas deberemos pulsar el botón “Load inputs”. Seleccionamos y pulsamos View trace
  • 10. JFLAP Sara Martínez Gómez 10 Todos los ejemplos puestos hasta ahora son deterministas, por ello creemos conveniente explicar más detalladamente la forma de ejecución del programa con autómatas finitos no deterministas. Con el no determinismo, JFLAP crea un árbol de todas las configuraciones posibles (no se muestran al usuario). En cada paso se expande cualquier configuración que es un nodo hoja en el árbol (con la poda), y luego muestra las configuraciones actuales (los nodos hoja actuales). Si elegimos la ejecución paso a paso con cierre, según el camino elegido el autómata llegara a final de la cadena de entrada quedándose en diferentes estados y dando una salida distinta según el camino elegido. Este ejemplo lo clarifica: En la ejecución paso a paso, además se permite al usuario ir eligiendo la ruta a través de los posibles estados, como ya hemos comentado anteriormente. ...
  • 11. JFLAP Sara Martínez Gómez 11 Máquina de Mealy Una máquina de Mealy es un tipo de autómata finito que genera una salida basándose en una entrada y su estado actual. Formalmente se puede definir como una séxtupla (S, S0, Σ, Ʌ, T, G): S = conjunto finito de estados S0 = estado inicial Σ = alfabeto de entrada (conjunto finito) Ʌ = alfabeto de salida (conjunto finito) T : S x Σ  S = función de transición G : S x Σ  Ʌ = función de salida La principal aplicación de este tipo de máquinas es el cifrado de información, pero constituyen un modelo matemático demasiado rudimentario como para implementarse en un caso real como podría ser la Máquina Enigma. El motivo es que el diagrama de estados de dicha máquina sería demasiado complejo. No obstante, su funcionamiento es muy similar al de los autómatas finitos explicados anteriormente, con la diferencia de que en lugar de ser aceptadora, es decir, producir una salida binaria de aceptación o rechazo; es una máquina transductora, esto es, que convierte la cadena de entrada en una cadena de salida. JFLAP reduce la funcionalidad ya explicada cuando pulsamos en el editor de las máquinas de Mealy. Como en estas máquinas no hay un estado final, ya que son transductoras y no aceptadoras, al pulsar el botón derecho sobre un estado no tenemos la opción de marcarlo como estado final. Por otro lado, cuando creamos una transición, es decir, cuando dibujamos el vector que une dos estados, JFLAP nos obliga rellenar dos campos en lugar de uno como antes, esto es porque el primer campo corresponde con el carácter de entrada y el segundo con el de salida. Si los dejamos en blanco introducirá el carácter λ, que como ya sabemos corresponde al carácter vacío. Además, JFLAP solo permite dos modos de ejecución, ya que el resto no tendrían sentido en este tipo de máquinas. El primero es la ejecución paso a paso, igual que en los casos anteriores de autómatas finitos, con la diferencia de que JFLAP va escribiendo en la parte inferior, debajo de la cadena de entrada, la cadena de
  • 12. JFLAP Sara Martínez Gómez 12 salida que se va generando en cada lectura. En este caso, la única forma de que la máquina no quede en un estado de aceptación es si algún carácter de la cadena de entrada no pertenece al alfabeto de la máquina. En este ejemplo hay dos estados (q0 y q1) donde el estado inicial es q0. Esta máquina si se encuentra en el estado q0 significa que ha procesado un número par de unos y si se encuentra en el estado q1 significa que ha procesado un número impar de unos. Si en la salida de la misma vemos el carácter S implicará que la máquina ha procesado un número impar de unos, si el número de unos fuera par en la salida veríamos el carácter A. Para clarificarlo, es conveniente observar las siguientes capturas de pantalla: ... Pulsamos Step hata llegar al final de la cadena Si la cadena no es aceptada
  • 13. JFLAP Sara Martínez Gómez 13 La segunda forma de simulación provista por JFLAP es la ejecución de múltiples cadenas al mismo tiempo, cuyo funcionamiento es idéntico al ya explicado. Seleccionamos varias entradas y pulsamos en View Trace
  • 14. JFLAP Sara Martínez Gómez 14 Máquina de Moore Una Máquina de Moore es un autómata de estados finitos donde las salidas están determinadas exclusivamente por el estado actual de la misma y no dependen directamente de la entrada. El diagrama de estados para una máquina Moore, a diferencia de la de Mealy, incluirá una señal de salida para cada estado. Formalmente, se define como una séxtupla (S, S0, Σ, Ʌ, T, G): S = conjunto finito de estados S0 = estado inicial Σ = alfabeto de entrada (conjunto finito) Ʌ = alfabeto de salida (conjunto finito) T : S x Σ  S = función de transición G : S  Ʌ = función de salida Se puede ver que esta definición es idéntica a la anterior de Mealy, excepto por la función de salida. Por tanto, es deducible que existe una correspondencia tal que para cada máquina de Mealy hay una máquina de Moore equivalente cuyos estados son la unión de los estados de la máquina de Mealy y el producto cartesiano de los estados de la máquina de Mealy y el alfabeto de entrada. Por consiguiente, el número de estados en una máquina de Moore será mayor o igual al número de estados en una máquina de Mealy. Al crear un autómata en el editor de máquinas de Moore, JFLAP cuando creamos cada estado (representado por un vértice del grafo) nos obliga a introducir su salida (si no introducimos nada la salida por defecto es λ), a diferencia del caso anterior en el que esta era requerida en la creación del vector y no del vértice. Es más, cuando creamos el vector solamente debemos introducir el carácter correspondiente a esa transición. Asimismo, cabe destacar una funcionalidad de JFLAP que poseen todos sus editores, pero que suele ser más útil a medida que se complican los autómatas, como es el caso. Esta funcionalidad corresponde a la posibilidad de cambiar de nombre los estados pulsando el botón derecho y después eligiendo “Set name”. Para clarificar el uso de una máquina de Moore crearemos una que trunca números binarios procesando los símbolos anterior y actual pero mostrando únicamente el anterior. Este hecho se ve muy claro en la imagen, ya que hemos
  • 15. JFLAP Sara Martínez Gómez 15 renombrado los estados de forma que existen todas las posibles combinaciones de cadenas de dos caracteres de ceros y unos, cuya correspondiente salida es el carácter que más a la izquierda del nombre del estado se encuentra. Los modos de simulación son los dos explicados en el apartado anterior.
  • 16. JFLAP Sara Martínez Gómez 16 Máquina de Turing Una máquina de Turing es un modelo computacional que consta de un cabezal lector/escritor y una cinta infinita en la que el cabezal lee el contenido, borra el contenido anterior y escribe un nuevo valor. Formalmente, se puede definir como una séptupla M=(Q, Σ, Γ, s, b, F, δ) donde: Q = conjunto finito de estados Σ = alfabeto de entrada (conjunto finito) en el que b ∉ Σ Γ = alfabeto de la cinta (conjunto finito) tal que Σ ⊆ Γ s ϵ Q = estado inicial b ϵ Γ = blanco F ⊆ Q = conjunto finito de estados finales de aceptación δ : Q x Γ  Q x Γ < {L, R} = función (parcial) de transición donde L es el movimiento a la izquierda y R es el movimiento a la derecha Como podemos comprobar en la definición anterior solo existe una cinta, pero creemos que es conveniente mencionar las máquinas de Turing multicinta. Una máquina de Turing multicinta es simplemente una máquina de Turing normal con varias cintas, las cuales poseen su propio cabezal. En ellas, inicialmente la cadena de entrada se encuentra en la primera cinta y las demás permanecen en blanco. La función de transición está modificada para permitir la lectura, escritura y movimiento de todas las cintas simultáneamente. Formalmente, se define como δ: Q x Γk  Q x Γk x {L, R} donde k es el número de cintas. La expresión δ(qi, a1, …, a k) = (qj, b1, …, bk, L, R, …,L) por tanto, significa que si la máquina se encuentra en el estado qi y las cabezales 1 a la k están leyendo los símbolos desde a1 hasta ak, la máquina va al estado qi, escribe los símbolos desde b1 hasta bk y mueve cada cabezal a la izquierda o derecha según se especifica. Es interesante resaltar que cualquier máquina de Turing multicinta es equivalente a una máquina de Turing normal de una sola cinta. Si queremos simular una máquina de Turing normal, es decir, de una sola cinta con JFLAP, deberemos elegir el editor “Multi-Tape Turing Maching” e introducir un 1 cuando nos requiere el número de cintas. En el editor podremos crear los
  • 17. JFLAP Sara Martínez Gómez 17 estados de la forma habitual, pero al crear las transiciones JFLAP nos requerirá tres campos. El primero es el carácter leído, el segundo es el carácter escrito y el tercero es el movimiento que a su vez puede ser L (izquierda), R (derecha) o S (en el mismo lugar). Si no introducimos nada, JFLAP no introducirá el carácter λ, introducirá un cuadrado vacío simulando que la cinta en ese momento está vacía. Asimismo, debemos señalar cuál es el estado inicial y el final pulsando el botón derecho. Para clarificar lo anterior, hemos diseñado una máquina de Turing normal, es decir, con una sola cinta que solo queda en estado de aceptación si la entrada es “ab”. La funcionalidad que JFLAP provee para la simulación es la misma que para cualquier autómata finito, añadiendo una ejecución múltiple para autómatas transductores, en la que se muestra si el autómata ha quedado en estado de aceptación o no y la cadena de salida. En la siguiente ejecución paso a paso, podemos comprobar que la simulación de la máquina de Turing es correcta, ya que si lee un carácter “b”, escribe una “a” y viceversa. Al terminar de leer la cadena “ab”, queda en un estado de aceptación si el siguiente carácter de la cinta es un blanco.
  • 18. JFLAP Sara Martínez Gómez 18 Máquina de Turing compuesta Las máquinas de Turing se pueden enlazar para obtener resultados más completos o complicados. Las máquinas de Turing compuestas están formadas por varios bloques, cada uno de los cuales corresponde a una máquina de Turing simple. Esos bloques están enlazados entre sí mediante transiciones, al igual que cualquier autómata. El funcionamiento es igual que el de cualquier otro autómata, con la diferencia de que aquí en lugar de haber estados simples hay máquinas de Turing, que si quedan en estado de aceptación podrán pasar la cadena de entrada a otro bloque (correspondiente con otra máquina de Turing). Este tipo de autómatas son de gran utilidad, ya que permiten una mayor variedad de cómputos. JFLAP solo permite la utilización de bloques con el mismo número de cintas, lo que limita un poco su uso. Para editar el funcionamiento de cada bloque basta con pulsar el botón derecho y elegir “Edit Block”, entonces se nos abrirá una nueva pestaña en la que podremos diseñar la máquina de Turing correspondiente a ese bloque o importarla desde un archivo ya creado. En el siguiente ejemplo se muestra una máquina de Turing compuesta que solo acepta cadenas de a’s seguidas de b’s y que sustituye las a’s por ceros y las b’s por unos. Los modos de simulación son los mismos que los que hay para las máquinas de Turing simples. En el siguiente ejemplo hemos usado la simulación paso a paso. Bloque1 Bloque2
  • 19. JFLAP Sara Martínez Gómez 19 Gramáticas Una gramática es una estructura matemática con un conjunto de reglas de formación que definen las cadenas de caracteres aceptables en un determinado lenguaje, es decir, las palabras del lenguaje. Formalmente, diremos que una gramática es una cuaterna G = (V, Σ, Q0, P), donde: V = alfabeto de símbolos no terminales (conjunto finito) Σ = alfabeto de símbolos terminales (conjunto finito) tal que V ∩ Σ = ∅ Q0 ∈ V = símbolo inicial. P ⊆ (V ∪ Σ)∗ × (V ∪ Σ)∗ = conjunto de producciones (conjunto finito) JFLAP permite la creación de gramáticas con un editor diferenciado en el que únicamente deberemos introducir las producciones de la gramática que queramos crear. En el siguiente ejemplo introduciremos todas las producciones necesarias para generar una gramática que defina todos los palíndromos del sistema binario, es decir, todas las combinaciones de ceros y unos que sean capicúa. Como es habitual, si no introducimos nada el carácter por defecto es λ. Chomsky hizo una clasificación de las gramáticas dividiéndolas en cuatro tipos: Tipo 0 (sin restricciones), que incluye a todas las gramáticas. Las gramáticas de este tipo generan todos los lenguajes capaces de ser
  • 20. JFLAP Sara Martínez Gómez 20 reconocidos por una máquina de Turing, es decir, aquellos que son recursivamente enumerables. Tipo 1 (gramáticas sensibles al contexto), que abarca aquellas que tienen reglas de la forma αAβ  αγβ con A un no terminal y α, β y γ cadenas de terminales y no terminales, donde α y β pueden ser vacías, pero no puede serlo. La regla S  λ está permitida si S no aparece en la parte derecha de ninguna regla. Los lenguajes descritos por estas son reconocidos por autómatas linealmente acotados. Tipo 2 (gramáticas libres del contexto), que incluye aquellas gramáticas que generan los lenguajes independientes del contexto y cuyas reglas son de la forma A γ con A un no terminal y γ una cadena de terminales y no terminales. Tipo 3 (gramáticas regulares), que abarcan las gramáticas que generan los lenguajes regulares y que tienen en la parte izquierda un no terminal, y en la parte derecha un solo terminal, posiblemente seguido de un no terminal. Aceptan reglas del tipo S  λ. Este tipo de gramáticas son las reconocidas por los autómatas finitos. JFLAP tras haber introducido una gramática da al usuario la posibilidad de saber de qué tipo de gramática se trata de una forma fácil: solamente hay que pulsar en el menú “Test” y, a continuación, en “Test for Gramar type”. En la captura podemos ver que la gramática explicada anteriormente es una gramática libre de contexto y, por tanto, es de tipo 2. JFLAP, además permite varios modos de simulación o testeo de cadenas de caracteres para saber si son aceptadas por la gramática introducida o no. Por un lado, está la ejecución por fuerza bruta. Que requiere una cadena de entrada para ir formando o bien el árbol dado tanto por la entrada como por la
  • 21. JFLAP Sara Martínez Gómez 21 gramática, o bien la tabla de derivación. Una vez introducida la cadena deberemos ir pulsando primero el botón “start” y después el botón “step” si nos encontramos en la vista del árbol. Cuando termine la ejecución si la cadena es aceptada, veremos que cada uno de sus caracteres corresponde con un nodo hoja. De lo contrario, si no es aceptada, será indicado en la parte superior, debajo de la cadena de entrada junto con el número de nodos generados hasta llegar a esa conclusión. Si pulsamos en la pestaña de la tabla de derivación, podremos ver todos los pasos seguidos hasta que la cadena ha sido aceptada o rechazada. En este caso también podremos realizar el seguimiento paso a paso.
  • 22. JFLAP Sara Martínez Gómez 22 JFLAP, como es habitual, permite una ejecución simultánea de múltiples cadenas por el método anterior, herramienta muy útil para tener una visión más amplia de la gramática que nos ataña y, por consiguiente, para una mejor definición del lenguaje correspondiente. En el caso anterior no podemos ver ni el árbol ni la tabla de derivación. Una tercera opción de simulación provista por JFLAP para las gramáticas es “User Control Parse”, en este modo el usuario puede elegir la producción que prefiera para ese determinado paso y cuando se haya llegado a un estado de
  • 23. JFLAP Sara Martínez Gómez 23 aceptación será indicado por JFLAP. Este tipo de simulación es muy útil para ver el funcionamiento de una gramática determinada. En el ejemplo siguiente hemos ido creando un árbol, eligiendo la producción que más nos convenía en ese momento y pulsando a continuación “step”. Cuando llegamos a un estado de aceptación habíamos generado la cadena “1100011”, como se muestra en la parte inferior de la pantalla (la cadena generada en cada instante del proceso también se muestra en este lugar durante toda la simulación). JFLAP, asimismo, provee la opción de transformar una gramática a la forma normal de Chomsky. Una vez en el editor de “Transform gramar”, nos pide permiso para modificar la gramática con el objetivo de eliminar los caracteres λ. Nos informa de que va a haber una eliminación y dos adiciones, si estamos de acuerdo deberemos pulsar el botón “step”. A continuación, nos vuelve a pedir confirmación para eliminar los caracteres λ por completo. Si queremos llegar a la forma normal de Chomsky, deberemos pulsar el botón “proceed”. Todos estos pasos, se podrían haber realizado en uno solo si hubiéramos pulsado en el botón “do all”. Como nuestra finalidad es convertir la gramática completamente a la forma normal de Chomsky será ese botón el que pulsemos. En ese momento, veremos nuestra gramática totalmente transformada en una gramática con la forma normal de Chomsky.
  • 24. JFLAP Sara Martínez Gómez 24
  • 25. JFLAP Sara Martínez Gómez 25 Expresiones regulares Una expresión regular es una fórmula cuyo propósito es representar un lenguaje. Formalmente, se puede definir de manera recursiva donde las expresiones regulares primitivas son Φ, λ y a ϵ Σ y las derivadas siguen las siguientes reglas: Unión = α + β Concatenación = αβ Clausura de Kleene = α* JFLAP proporciona la opción de generación de un autómata a partir del editor de expresiones regulares. Simplemente tenemos que introducir la expresión que queramos y a continuación pulsar el botón “Convert to NFA”. Una vez que veamos el diagrama de transición que representa el autómata, debemos pulsar el botón “step” de tal forma que veremos el autómata más expandido con expresiones regulares menos complejas en su interior. Cuando dichas expresiones regulares ya no se puedan simplificar más, el botón “step” será desactivado y significará que ese será el autómata final de la expresión regular que habíamos introducido en primera instancia. Si preferimos saltarnos todos los pasos podemos pulsar el botón “do all”. La expresión regular introducida en el ejemplo representa todas las cadenas de a’s y b’s que tienen un número impar de símbolos y el autómata obtenido es el que acepta dicho lenguaje.
  • 26. JFLAP Sara Martínez Gómez 26 Después de varios pasos
  • 27. JFLAP Sara Martínez Gómez 27 Finalmente, si pulsamos el botón “export” podremos trabajar con el autómata anterior de forma normal. Como el editor de expresiones regulares solo nos da la posibilidad de convertirlas a un NFA, si queremos convertirla en un DFA basta con darle al botón que corresponde a esta conversión y obtendremos algo como lo siguiente. Para ver más claro el autómata anterior podemos pulsar en el menú “Minimize DFA” y visualizaremos de forma resumida los estados iniciales, finales y las transiciones.
  • 28. JFLAP Sara Martínez Gómez 28 Equivalencia Se puede decir que dos autómatas A1 y A2 son equivalentes si aceptan exactamente el mismo lenguaje. Como la comparación de las cadenas pertenecientes a un lenguaje sería impensable, Moore propuso un teorema que consiste en la creación de un árbol de comparación con las distintas combinaciones de estados, para el cual dados dos autómtas A1 = (K1, Σ1, δ1, s1, F1) y A2 =(K2, Σ2, δ2, s2, F2) hay que seguir las siguientes reglas: La raiz del arbol generado es el par ordenado (s1, s2) que contiene los estdos iniciales de A1 y A2. Si existiera un par (r1, r2) de estados incompatibles se interrumpiría la elaboración del árbol concluyendo que los autómatas en cuestión son incompatibles. Si existiera un par (r1, r2) en el árbol, para cada carácter en σ se añaden como hojas suyas los pares (r1σ, r2σ) donde r1σ = δ1 (r1, σ), r2σ = δ2 (r2, σ), si no existen ya. En el caso de que no aparezcan nuevos pares (r1σ, r2σ) que no se encuentren previamente en el árbol, se termina el proceso, concluyendo que los dos autómatas son equivalentes. Esta comparación es utilizada por JFLAP para saber si dos autómatas son equivalentes, utilidad muy conveniente para los usuarios, ya que basta con pulsar “Compare Equivalence” del menú “Test”. Decimos que es muy conveniente, ya que permite explotar al máximo las posibilidades explicadas anteriormente, como por ejemplo para saber si una gramática o una expresión regular corresponden a un autómata ya dibujado previamente, bastaría con convertirlas a autómatas y utilizar la herramienta de comparación. En el siguiente ejemplo vamos a comparar tres autómatas simples un AFD, un AFN, y un AFλ, cuya apariencia a simple vista se parece pero no tenemos la certeza de que sean equivalentes. JFLAP nos evita hacer los árboles correspondientes utilizando su herramienta de comparación.
  • 29. JFLAP Sara Martínez Gómez 29 AFλAFDAFN Son equivalentes mutuamente
  • 30. JFLAP Sara Martínez Gómez 30 Práctica 1 Utilizando JFLAP, dada la siguiente expresión regular: (a+b+c)*baba(a+b+c)* a) Decir a qué lenguaje pertenece b) Obtener un AFN que acepte la gramática definida por dicha expresión regular. c) Obtener un AFλ que acepte la gramática definida por dicha expresión regular. d) Obtener un AFD que acepte la gramática definida por dicha expresión regular. e) Decidir si los autómatas anteriores son equivalentes. f) Decidir si es equivalente a la siguiente gramática J  baba J  a K  λ J  b J  c K  J
  • 31. JFLAP Sara Martínez Gómez 31 Solución a) Lo primero que vamos a hacer es abrir el editor para expresiones regulares. En él introducimos la expresión dada A continuación, lo convertimos en un AFN y lo exportamos.
  • 32. JFLAP Sara Martínez Gómez 32 Introducimos varias cadenas de entrada en ese AFN para hacernos una idea de cuál podría ser el lenguaje al que corresponde la expresión regular. Si nos fijamos en la expresión dada vemos que está implícita la cadena “baba” por lo que probaremos con palabras relacionadas con esa cadena y otras que no lo estén, con el objetivo de saber cuál es el lenguaje exacto al que corresponde la expresión que nos concierne. Podemos comprobar que nuestras sospechas era ciertas: el lenguaje corresponde a todas las palabras que contengan la cadena “baba”. Formalmente: L = {∀ w / w= (todas las palabras que contengan la cadena “baba”) ^ λ ϵ w} b) Este apartado estaría ya resuelto en el anterior, pero lo vamos a colocar un poco, para ver con más claridad el funcionamiento y la estructura del autómata. Así obtenemos lo siguiente:
  • 33. JFLAP Sara Martínez Gómez 33 c) Como ya tenemos un AFN que acepta la expresión regular dada, seguimos la regla de que cualquier AFN es equivalente a un AFλ. Al observar que varias transiciones del AFN son λ, podemos pensar que cuando pulsemos la opción de convertir a un AFD, lo que nos generará realmente será un AFλ. Por tanto, seguimos dicho procedimiento para obtenerlo:
  • 34. JFLAP Sara Martínez Gómez 34 Con el paso anterior hemos comprobado que nuestras sospechas eran erróneas y al pasar nuestro AFN a un AFD, JFLAP no ha generado un AFλ. Para solventar esta cuestión, lo que vamos a hacer será crear dos estados adicionales “a1” y “a2” que tendrán transiciones λ, esto convertirá el AFD anterior en un AFλ y no afectará a la gramática que acepta el autómata. Además vamos a eliminar todas las etiquetas para ver mejor la estructura del mismo. Para comprobar si estamos en lo cierto, comprobaremos su equivalencia con JFLAP.
  • 35. JFLAP Sara Martínez Gómez 35 d) El AFD creado en el apartado c) es válido, ya que no tiene ninguna transición λ y acepta la gramática definida por la expresión regular dada, debido a que lo hemos creado a partir de la misma. Por tanto, eliminaremos los estados y las transiciones λ que añadimos en el apartado c) y obtendremos el siguiente AFD. e) Comprobamos la equivalencia del AFN, AFD y AFλ comparándolos dos a dos. AFN con AFD:
  • 36. JFLAP Sara Martínez Gómez 36 AFN con AFλ: AFD con AFλ: Concluimos, por tanto, que son equivalentes. f) A simple vista, la gramática dada se podría parecer mucho a la expresión regular del enunciado y, por tanto, ser equivalente a la misma. Para comprobarlo vamos a introducir la nueva gramática en el editor correspondiente de JFLAP. A continuación escogeremos la opción de convertirla en un autómata finito (FA) con el fin de comparar la equivalencia de este con uno de los que ya habíamos obtenido anteriormente. Nos basamos en que si dos autómatas son equivalentes es porque admiten la misma gramática y, por
  • 37. JFLAP Sara Martínez Gómez 37 consiguiente, podríamos comprobar si la expresión regular y la gramática que nos atañen son equivalentes. Gracias a JFLAP hemos podido comprobar que nuestras sospechas eran erróneas y que la gramática dada y la expresión regular del enunciado no son equivalentes.
  • 38. JFLAP Sara Martínez Gómez 38 Practica 2 a) Dibujar una máquina de Turing de una sola cinta que solo quede en estado de aceptación si el número de unos es par teniendo como alfabeto de entrada Σ = {0, 1} y como alfabeto de cinta Γ = {0, 1, □} b) Dibujar una máquina de Turing de una sola cinta cuyo alfabeto de entrada sea Σ = {0, 1}, cuyo alfabeto de cinta sea Γ = {0, 1, □} y que solo acepte cadenas de unos seguidos de ceros, excluyendo la cadena vacía. c) Modelar una máquina de Turing compuesta por bloques formados por las máquinas de los apartados b) y c).
  • 39. JFLAP Sara Martínez Gómez 39 Solución a) Para construir la máquina de Turing pedida en este apartado iremos al editor de máquinas de Turing y diremos que tenga una única cinta. Crearemos en un principio dos estados “q0” y “q1”, que estarán unidos por transiciones que leen unos y escriben unos y que tendrán transiciones propias que harán lo mismo pero con ceros. De esta forma nos aseguramos que cuando estemos en el estado “q0” la máquina habrá leído un número par de unos. Por tanto, creamos otro estado “q2”, final, que estará unido con “q0” con una transición tal que si lee la cadena vacía, es decir, si se ha llegado al final de la entrada escriba un 0 y, por consiguiente, si ha habido un número par de unos la máquina quedará en estado de aceptación. Haremos lo homólogo con los ceros creando un estado “q3” que no será final, y si la máquina llega a él, quedará en estado de no aceptación, lo que significará que la entrada tenía un número impar de unos. Hay que tener en cuenta que consideramos el 0 cómo un número par, por tanto, si no hay ningún 1 en la cadena, la máquina de Turing quedará en estado de aceptación.Para comprobar el correcto funcionamiento de lo explicado anteriormente, hemos simulado el funcionamiento con varias cadenas.
  • 40. JFLAP Sara Martínez Gómez 40 b) Para construir la máquina de Turing pedida en este apartado iremos al editor de máquinas de Turing y elegiremos una sola cinta. Crearemos dos estados, uno que acepte ceros y otro que acepte unos. El que acepte los unos será el inicial y el que acepte los ceros será el que conducirá a un tercer estado que será el final. Este tercer estado es necesario porque sino la máquina cuando leyera un cero quedaría en estado de aceptación y se pararía. La máquina cambiará de estado cuando lea un cero. Si después de haber leído un cero, lee un uno quedará en estado de no aceptación, ya que no pasará al estado final. Haremos varias ejecuciones paso a paso para ver su funcionamiento. Vemos que efectivamente no acepta cadenas que tengan un cero seguido por un uno. En la siguiente ejecución introduciremos una cadena de unos seguida de ceros para ver que queda en estado de aceptación.
  • 41. JFLAP Sara Martínez Gómez 41 c) Para construir la máquina de Turing compuesta pedida en este apartado, nos fijaremos en que la máquina de Turing del apartado c) solo acepta cadenas que empiecen por 1, por tanto esta será la transición que nos servirá para unir los dos bloques del autómata compuesto. Por lo demás, ya tenemos todo el trabajo hecho. El primer bloque corresponderá a la máquina del apartado b) y será el
  • 42. JFLAP Sara Martínez Gómez 42 inicial. Y el segundo bloque corresponderá a la máquina del apartado c) y será el final. Haremos una ejecución paso a paso para ver si la unión de las dos máquinas es correcta y cumple con las restricciones de las máquinas individuales.
  • 43. JFLAP Sara Martínez Gómez 43 Práctica 3 Utilizando JFLAP, diseñar una máquina de Turing que solo acepte palíndromos en binario mayores que 0 y que calcule si el número de unos de su sucesor en binario es par o impar imprimiendo el resultado con la forma “número de unos en unario”+”blanco”+ “PAR” o “IMPAR”, por ejemplo “11111□IMPAR” o “111111□PAR”. Solución A simple vista, nos podría parecer una máquina sumamente complicada, ya que tiene que comprobar varias cosas y realizar algunos cálculos. Por ello, vamos a dividirla en cuatro subproblemas: comprobar si la entrada es un palíndromo en binario, hallar el sucesor de la entrada en binario, eliminar los ceros de un número en binario, y comprobar si un número en unario es par o impar e imprimir el resultado. Una vez tengamos resuelto cada problema por separado, los uniremos utilizando una máquina de Turing compuesta por varios bloques teniendo en cuenta que los números en binario siempre empiezan por 1, al igual que en unario. Por tanto, utilizaremos esta propiedad para unir los diferentes bloques de la máquina. Para resolver el primer subproblema procederemos de la siguiente forma. Como para ser un palíndromo la cadena tiene que ser igual tanto en el inicio como en el final, la máquina leerá el primer carácter de la entrada, recorrerá la cadena hasta el final y comprobará si el último es el mismo carácter que el ya leído. Ambos los sustituirá por un blanco y realizará esta tarea hasta que la cinta esté formada solo por blancos y si solo quedara un carácter (porque la longitud de la cadena de entrada fuera impar), lo sustituiría por un blanco también. Si la cadena está formada solo por blancos será señal de que la entrada era un palíndromo en binario y la máquina quedará en estado de aceptación en ese momento. En la siguiente ejecución paso a paso comprobaremos que si la entrada no es un palíndromo en binario la máquina quedaría en estado de no aceptación.
  • 44. JFLAP Sara Martínez Gómez 44 En la ejecución paso a paso que vemos a continuación, podemos clarificar el funcionamiento de la máquina cuando queda en un estado de aceptación: ...
  • 45. JFLAP Sara Martínez Gómez 45 Para resolver el segundo subproblema nos fijaremos en que siempre el sucesor de un número en binario que termina en 0 es el mismo número pero cambiando el último 0 por un 1 y en que si el número termina en 1, su sucesor es el mismo número pero cambiando desde la parte derecha a la izquierda todos los unos por ceros hasta encontrar un 0 que se cambia por un 1. Por tanto, nuestra máquina de Turing seguirá este razonamiento para hallar el sucesor de la entrada. Con el fin de aclarar esta regla general vamos a poner dos ejemplos, uno que termine en 0 y otro que termine en 1. Elegimos un número binario cualquiera que termine en 0 y ejecutamos la máquina de Turing que nos atañe paso a paso: Hemos comprobado que efectivamente ha calculado el sucesor cambiando el 0 por un 1. Si el número termina en 1 la ejecución es un poco más compleja por lo que la ejecución paso a paso requerirá de más movimientos hasta llegar al resultado final. ...
  • 46. JFLAP Sara Martínez Gómez 46 Para resolver el tercer subproblema recorreremos la cadena de entrada hasta llegar al primer 0, que cambiaremos por una X. A continuación, seguiremos leyendo ceros hasta encontrar otro 1, este lo cambiaremos por un 0 y retrocederemos a la izquierda hasta encontrar la X que habíamos puesto como marca. En este punto sustituiremos la marca que habíamos puesto por un 1. Realizaremos esta tarea mientras queden unos en la cadena. Una vez que veamos que no hay más unos en la cadena a la derecha del control finito, sustituiremos todos los ceros por blancos y terminaremos. Si la cadena estuviese formada únicamente por unos, iríamos directamente al final. ...
  • 47. JFLAP Sara Martínez Gómez 47 La siguiente ejecución nos ayudará a clarificar el funcionamiento de la máquina: ... ...
  • 48. JFLAP Sara Martínez Gómez 48 Para resolver el cuarto subproblema, utilizaremos dos estados, uno que represente un número impar de unos y otro que represente un número par de unos. Cuando el autómata haya terminado de leer la cadena unos, imprimirá en la cinta el resultado dependiendo de en el estado que haya quedado. El funcionamiento de esta máquina de Turing es muy simple. Las siguientes imágenes corresponden a una ejecución paso a paso de un número impar:
  • 49. JFLAP Sara Martínez Gómez 49 Una vez que tenemos cada subproblema resuelto vamos a proceder a unirlos todos en una máquina de Turing compuesta, en la que cada bloque corresponderá a una máquina de las anteriores. Estos bloques irán unidos por transiciones que solo aceptarán un 1, ya que cualquier número en binario o en unario mayor que cero debe comenzar por 1. Está claro que el alfabeto de la máquina final será la unión de cada uno de los alfabetos de las máquinas por las que está compuesta. Realizaremos una ejecución paso a paso para comprobar si la unión que hemos realizado es correcta: Como es un palíndromo pasa a q1, de lo contrario se quedaría en q0 En q1 ya ha calculado el sucesor, que es el número que aparece en la cinta En q2 ha quitado los ceros existentes en el número calculado por q1, dejando el resultado en la cinta En q3 ha comprabado si el número de unos es par y ha impreso el resultado, dejando la cinta en la forma pedida en el enunciado
  • 50. JFLAP Sara Martínez Gómez 50 Práctica 4 Utilizando JFLAP, diseñar una máquina de Turing compuesta por un bloque, que con varias cintas compruebe si la cadena de entrada es del tipo An Bn Cn tal que n>0, y por otro que la duplique. El resultado final debe tener la forma An Bn Cn An Bn Cn , o dicho de otra manera (An Bn Cn )2 . Solución Siguiendo el enunciado vemos que el ejercicio consiste en realizar dos máquinas de Turing por separado y luego unirlas, sabiendo que empiezan por “A”. Para el diseño de la primera máquina utilizaremos tres cintas, ya que hay tres caracteres distintos. Para ello iremos el editor de máquinas de Turing multicinta e introduciremos un 3 cuando nos pide el número de cintas. Solo introduciremos una entrada en la primera cinta para que la máquina, si se cumplen las condiciones del enunciado, quede en estado de aceptación. El funcionamiento de nuestra máquina se basará en que si lee una “A” en la primera cinta, la escribirá en la segunda y si lee una “B” en la primera cinta la escribirá en la tercera. Todo ello bajo la restricción de que la entrada debe comenzar por A, que todas las A’s solo pueden estar seguidas por una “A” o una “B”, que todas las B’s solo pueden estar seguidas por una “B” o una “C” y que todas las C’s solo pueden ir seguidas de otra “C” o de la cadena vacía. Una vez que tengamos rellenadas las tres cintas, las dos cintas inferiores se moverán a la izquierda y la primera mantendrá su posición, de forma que en la primera cinta tiene que haber una “C”, en la segunda una “A” y en la tercera una “B”. Cuando la primera llegue a la cadena vacía, es decir, cuando se haya acabado la entrada si el número de A’s y B’s es igual que el de C’s e igual entre sí, entonces todas las cintas leerán la cadena vacía y la máquina quedará en estado de aceptación. Aquí mostramos dos ejecuciones erróneas:
  • 51. JFLAP Sara Martínez Gómez 51 Hemos podido comprobar que si el número de los caracteres de distinto tipo es el mismo, la máquina quedará en estado de aceptación cuando lee un blanco en cada una de las cintas que la forman.
  • 52. JFLAP Sara Martínez Gómez 52 Para el diseño de la segunda máquina vamos a utilizar una única cinta, que marcará el final de la cadena de entrada con una “Y”. A continuación, leerá el segundo carácter (ya que el primero lo dejamos para el final), lo marcará con una “X” (para saber a dónde regresar tras la escritura) y lo escribirá después del último carácter que haya tras la “Y”, entonces regresará a la “X” y la cambiará por el símbolo que había leído. Para realizar esta tarea necesitaremos tres ramas que harán lo mismo exceptuando el símbolo de escritura, es decir, hacer una rama es la forma de “guardar” el símbolo leído. Se realizará este proceso hasta que la máquina se encuentre con la “Y”, entonces la sustituirá por el su símbolo correspondiente, utilizando para ello otras tres ramas (una por cada carácter diferente).
  • 53. JFLAP Sara Martínez Gómez 53 En la ejecución paso a paso anterior solo hemos mostrado los pasos más relevantes. Finalmente, no debemos olvidar que el objetivo del ejercicio es realizar una máquina de Turing compuesta. Por tanto, uniremos las máquinas ya creadas con una transición “A”, ya que el formato de cadena del primer bloque obliga a ello. Pasa de q0 a q1 porque el número de As, Bs y Cs es igual Una vez que ha terminado la ejecución de q2, la cadena de entrada queda duplicada en la cinta
  • 54. JFLAP Sara Martínez Gómez 54 Fuentes de información http://www.jflap.org/ https://www.google.es/url?sa=t&rct=j&q=&esrc=s&source=web&cd=8&ve d=0CFoQFjAHahUKEwj83Kvgt- LIAhUHNhoKHTI9BQg&url=http%3A%2F%2Fwww.mcvts.net%2Fsite%2 Fhandlers%2Ffiledownload.ashx%3Fmoduleinstanceid%3D7219%26dat aid%3D4882%26FileName%3DJFLAP.pdf&usg=AFQjCNGmOHs- t2x4UjhxWJrF3Zku8uaOLg&bvm=bv.106130839,d.d2s&cad=rja http://ocw.uc3m.es/ingenieria-informatica/teoria-de-automatas-y- lenguajes-formales/practicas-1/solucion-a-las-practicas-de-jflap https://ritdml.rit.edu/bitstream/handle/1850/8712/DNortonUsersGuide02- 2008.pdf?sequence=2 http://www.cs.duke.edu/csed/rodger/papers/iticse2011tips.pdf http://www.cs.duke.edu/csed/rodger/papers/pviswk02.pdf http://www.idt.mdh.se/kurser/cd5560/14_11/LABS/JFLAP%20MANUAL% 20AND%20EXERCISES-20130311.pdf http://ecx.images- amazon.com/images/I/513QBC0B57L._SX389_BO1,204,203,200_.jpg http://maquinaturing.blogspot.com.es/p/maquina-turing-multicintas.html http://es.slideshare.net/JesusDavid13/maquinas-de- turing?next_slideshow=1 http://ocw.unican.es/ensenanzas-tecnicas/teoria-de-automatas-y- lenguajes-formales/material-de-clase-nuevo/nuevo/1- 3_Gramaticas_formales.pdf https://es.wikipedia.org/wiki/Teorema_de_Moore https://es.wikipedia.org/wiki/Expresi%C3%B3n_regular https://es.wikipedia.org/wiki/Gram%C3%A1tica_formal#Gram.C3.A1ticas _formales_en_matem.C3.A1ticas_y_l.C3.B3gica https://es.wikipedia.org/wiki/Jerarqu%C3%ADa_de_Chomsky http://es.slideshare.net/iscrquinter/parte-4-mquinas-de-turing http://www.mast.queensu.ca/~ggsmith/Math401/images/petersen3.png https://upload.wikimedia.org/wikipedia/commons/thumb/9/97/Petersen2_t iny.svg/220px-Petersen2_tiny.svg.png
  • 55. JFLAP Sara Martínez Gómez 55 https://upload.wikimedia.org/wikipedia/commons/thumb/5/51/D%C3%BC rer_graph.svg/220px-D%C3%BCrer_graph.svg.png https://upload.wikimedia.org/wikipedia/commons/thumb/9/91/Petersen1_t iny.svg/200px-Petersen1_tiny.svg.png http://www.uhu.es/francisco.moreno/talf/docs/tema4_1.pdf https://es.wikipedia.org/wiki/Aut%C3%B3mata_finito https://es.wikipedia.org/wiki/M%C3%A1quina_de_estados https://es.wikipedia.org/wiki/M%C3%A1quina_de_Moore https://es.wikipedia.org/wiki/M%C3%A1quina_de_Mealy