Tutorial de JFLAP

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


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λ AFD AFN

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

que n>0, y por otro que la duplique. El resultado final debe tener la forma

AnBnCnAnBnCn, o dicho de otra manera (AnBnCn)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

http://www.jflap.org/

https://www.google.es/url?sa=t&rct=j&q=&esrc=s&source=web&cd=8&ved=0CFoQFjAHahUKEwj83Kvgt-LIAhUHNhoKHTI9BQg&url=http%3A%2F%2Fwww.mcvts.net%2Fsite%2Fhandlers%2Ffiledownload.ashx%3Fmoduleinstanceid%3D7219%26dataid%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

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

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://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://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://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/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_tiny.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

https://upload.wikimedia.org/wikipedia/commons/thumb/5/51/D%C3%BCrer_graph.svg/220px-D%C3%BCrer_graph.svg.png

https://upload.wikimedia.org/wikipedia/commons/thumb/5/51/D%C3%BCrer_graph.svg/220px-D%C3%BCrer_graph.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

Tutorial de JFLAP

Software

Transcript of Tutorial de JFLAP