JFLAP: Simulación de autómatas finitos y herramientas de lenguajes formales

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
¿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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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, 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
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

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
Después de
varios pasos

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
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
AFλAFDAFN
Son equivalentes mutuamente

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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
La siguiente ejecución nos ayudará a clarificar el funcionamiento de la
máquina:
...
...

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
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
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
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
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
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
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
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

JFLAP: Simulación de autómatas finitos y herramientas de lenguajes formales

Recomendados

Recomendados

Más contenido relacionado

La actualidad más candente

La actualidad más candente (20)

Destacado

Destacado (7)

Similar a JFLAP: Simulación de autómatas finitos y herramientas de lenguajes formales

Similar a JFLAP: Simulación de autómatas finitos y herramientas de lenguajes formales (20)

JFLAP: Simulación de autómatas finitos y herramientas de lenguajes formales