Documenti di Didattica
Documenti di Professioni
Documenti di Cultura
Índice
¿Qué es?............................................................................................................ 3
Historia ............................................................................................................... 3
Autómatas .......................................................................................................... 4
Autómatas finitos............................................................................................. 5
Gramáticas ....................................................................................................... 19
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
2
JFLAP Sara Martínez Gómez
¿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.
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.
3
JFLAP Sara Martínez Gómez
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.
4
JFLAP Sara Martínez Gómez
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.
Σ = alfabeto finito
q0 ϵ Q = estado inicial
δ: Q x Σ Q = función de transición
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.
5
JFLAP Sara Martínez Gómez
Añadir
transición a
los estados
Marcar
los
estados
inicial y
final
Resaltar las
transiciones λ
6
JFLAP Sara Martínez Gómez
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.
7
JFLAP Sara Martínez Gómez
8
JFLAP Sara Martínez Gómez
Seleccionamos
y pulsamos
View trace
9
JFLAP Sara Martínez Gómez
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:
...
10
JFLAP Sara Martínez Gómez
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):
11
JFLAP Sara Martínez Gómez
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
12
JFLAP Sara Martínez Gómez
Seleccionamos
varias entradas
y pulsamos en
View Trace
13
JFLAP Sara Martínez Gómez
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):
14
JFLAP Sara Martínez Gómez
15
JFLAP Sara Martínez Gómez
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:
s ϵ Q = estado inicial
b ϵ Γ = blanco
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
16
JFLAP Sara Martínez Gómez
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.
17
JFLAP Sara Martínez Gómez
Bloque1 Bloque2
18
JFLAP Sara Martínez Gómez
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:
Q0 ∈ V = símbolo inicial.
19
JFLAP Sara Martínez Gómez
20
JFLAP Sara Martínez Gómez
21
JFLAP Sara Martínez Gómez
22
JFLAP Sara Martínez Gómez
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).
23
JFLAP Sara Martínez Gómez
24
JFLAP Sara Martínez Gómez
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 = α*
25
JFLAP Sara Martínez Gómez
Después de
varios pasos
26
JFLAP Sara Martínez Gómez
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.
27
JFLAP Sara Martínez Gómez
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 A 1 = (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 (s 1, 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.
28
JFLAP Sara Martínez Gómez
29
JFLAP Sara Martínez Gómez
Práctica 1
Utilizando JFLAP, dada la siguiente expresión regular:
(a+b+c)*baba(a+b+c)*
J baba J a
K λ J b
J c K J
30
JFLAP Sara Martínez Gómez
Solución
a)
Lo primero que vamos a hacer es abrir el editor para expresiones regulares. En
él introducimos la expresión dada
31
JFLAP Sara Martínez Gómez
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.
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:
32
JFLAP Sara Martínez Gómez
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:
33
JFLAP Sara Martínez Gómez
34
JFLAP Sara Martínez Gómez
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.
35
JFLAP Sara Martínez Gómez
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
36
JFLAP Sara Martínez Gómez
37
JFLAP Sara Martínez Gómez
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, □}
38
JFLAP Sara Martínez Gómez
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.
39
JFLAP Sara Martínez Gómez
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.
40
JFLAP Sara Martínez Gómez
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
41
JFLAP Sara Martínez Gómez
42
JFLAP Sara Martínez Gómez
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.
43
JFLAP Sara Martínez Gómez
...
44
JFLAP Sara Martínez Gómez
...
45
JFLAP Sara Martínez Gómez
...
46
JFLAP Sara Martínez Gómez
...
...
47
JFLAP Sara Martínez Gómez
48
JFLAP Sara Martínez Gómez
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.
En q3 ha comprabado si el
número de unos es par y ha En q2 ha quitado los ceros
impreso el resultado, dejando existentes en el número
la cinta en la forma pedida en calculado por q1, dejando
el enunciado el resultado en la cinta
49
JFLAP Sara Martínez Gómez
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 A nBnCn 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:
50
JFLAP Sara Martínez Gómez
51
JFLAP Sara Martínez Gómez
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).
52
JFLAP Sara Martínez Gómez
En la ejecución paso a paso anterior solo hemos mostrado los pasos más
relevantes.
Pasa de q0 a q1
porque el número
de As, Bs y Cs es
igual
53
JFLAP Sara Martínez Gómez
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
54
JFLAP Sara Martínez Gómez
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
55