Portafolio lenguajes y automatas unidad 3 - Autómatas finitos

INSTITUTO TECNOLÓGICO DE TEPIC
Ingeniería en Sistemas Computacionales
LENGUAJES Y AUTÓMATAS 1
UNIDAD 3, Autómatas finitos
PORTAFOLIO UNIDAD 3
Alumno: Luis Adrian Parra Avellaneda
Docente: Sonia Alvarado Mares

1 | L e n g u a j e s y A u t ó m a t a s I
Introducción
En el proceso para crear un lenguaje de programación es importante definir cuáles serán
las cadenas, alfabeto, su sintaxis, semántica y más elementos que deberá tener el lenguaje
que se está desarrollando. En esta unidad se analizó el proceso de validar cadenas sobre
una expresión regular, para validar cadenas recurriremos al uso de autómatas finitos.
La validación de cadenas es sumamente importante ya que cada cadena representa
ciertas funciones que realizarán la computadora y las variables que se están declarando en
el momento de programar, una cadena que no esté establecida producirá errores en el
momento de ejecución, por lo tanto estos posibles errores deben de detectarse
previamente antes de ejecutar el programa.
En este portafolio veremos los temas relacionados con los autómatas finitos, sus
clasificaciones y aplicaciones, a su vez que se mostrarán los trabajos realizados en clase
que aportarán al mejor entendimiento del tema.

INDICE
Introducción........................................................................................................................................ 1
CONTENIDO…………………………………………………………………………………………………………………………………3
¿Qué es un autómata finito?........................................................................................................... 3
Clasificación de autómatas.............................................................................................................. 4
Conversión de autómata no determinista sin ambigüedad a determinista ................................... 5
Autómata con finito no determinista con transiciones de vacio.................................................... 7
Conversión de autómata finito no determinista con transiciones de vacio a un autómata finito
no determinista común................................................................................................................... 8
Conversión de No determinista a Determinista............................................................................ 10
Minimización de estados en un AFD............................................................................................. 11
Conversión de una expresión regular a un autómata finito ......................................................... 13
APLICACIÓN DE LOS AUTÓMATAS ................................................................................................ 14
Autómatas celulares.................................................................................................................. 14
Aplicaciones de los autómatas finitos y probabilísticos............................................................ 15
Autómatas programables.......................................................................................................... 16
ANEXOS: ............................................................................................................................................ 18
Tarea 1........................................................................................................................................... 18
TAREA2.......................................................................................................................................... 19
TAREA 3......................................................................................................................................... 21
TAREA 4......................................................................................................................................... 22
Conclusiones: .................................................................................................................................... 32
Referencias y Bibliografia.................................................................................................................. 32

¿Qué es un autómata finito?
Un autómata finito según Hopcroft y Ullman(1993) es un modelo matemático de un sistema, con
entradas y salidas discretas. El sistema puede estar en cualquier número finito de configuraciones
o estados. El estado resume la información de entradas anteriores y que es necesaria para
determinar el comportamiento del sistema para las posteriores entradas
Un autómata finito consiste en un conjunto finito de estados y transiciones de estado a estado,
con símbolos de entrada tomados de un alfabeto. Isasi, Martínez y Borrajo (1997) agregan que
existe un estado inicial donde comienza el recorrido y uno o más estados finales. Elisa Vilso (2002)
y los demás autores coinciden en que es un conjunto de varios elementos, los cuales son estados,
alfabeto
Representación de un autómata y estados
Representación de un autómata
Para representar un autómata tenemos que indicar cuáles son los elementos de este
-Estados
-Alfabeto
-Estado Inicial
-Conjunto de estados finales
-Tabla de transiciones

Ejemplo de un autómata con sus elementos:
Clasificación de autómatas
Un autómata finito determinista según Isasi, Martínez y Borrajo (1997) y Vilso (2002) es un
autómata en que la salida en cada momento se limita a dos valores: aceptada la palabra de
entrada o no aceptada
En un autómata finito no determinista según Isasi, Martínez y Borrajo (1997) en los que puede
existir más de una transición por cada par (estado, entrada) o ninguna transición por cada par, de
forma que, en cada momento, el autómata puede realizar varias transiciones diferentes entre las
que deberá optar o no poder realizar ninguna. Otro rasgo que les diferencia de los deterministas,
es que pueden realizar transiciones de un estado a otro sin leer ningún símbolo de entrada,
mediante las denominadas transiciones de vacío.

Conversión de autómata no determinista sin ambigüedad a determinista
Para que un autómata sea determinista cada estado deberá tener todas las salidas del alfabeto
nos argumenta Brookshear (1989), en este caso para convertir un autómata no determinista
podemos agregar estados. En esta ocasión los autómatas que se convertirán no tendrán
ambigüedades, es decir que salgan 2 o más transiciones con el mismo símbolo del alfabeto
Ejemplo
Elaborar un autómata de todas las cadenas de [c] y [d] que inicien con una [d] seguidas de 1 o más
veces la subcadena [cd] y que termine con [c]
Primero podemos realizar el autómata no determinista
d
Después agregamos un estado extra, y agregamos las salidas que faltan a los estados que lo
requieran
Con este nuevo estado si vamos por la letra que no llega al estado final, se ciclará sin llegar al
estado final, lo cual es más fácil al programar

Ahora observemos la tabla de transiciones, está llena y con un solo estado en cada celda
Ejemplo 2
Como podemos ver, los estados q4 y q5 los podemos conectar a un nuevo estado para
convertirlo a determinista

Autómata con finito no determinista con transiciones de vacio
También puede haber autómatas que al pasar por una transición no consuman letras del
alfabeto, o que al pasar por una transición de como resultado un vacio
Ejemplo:
La expresión que representa este autómata es a*
La manera de representarlo con sus elementos es
A={a}
Q={q1,q2}

I=q1
F={q2}
Q/A a ∈
q1 q1 q2
q2 - -
Conversión de autómata finito no determinista con transiciones de
vacio a un autómata finito no determinista común
Para convertir realizar esta conversión necesitamos saber diversas operaciones, las cuales
son:
 Cerradura de vacio
𝜀 − 𝑐 = {𝑝|𝑝 𝑒𝑠 𝑎𝑐𝑐𝑒𝑠𝑖𝑏𝑙𝑒 𝑑𝑒𝑠𝑑𝑒 𝑄 sin 𝑐𝑜𝑛𝑠𝑢𝑚𝑖𝑟 𝑛𝑎𝑑𝑎 𝑒𝑛 𝑙𝑎 𝑒𝑛𝑡𝑟𝑎𝑑𝑎}
Ejemplo:
𝜀 − 𝑐 𝑞1 = 𝑞1 , 𝑦𝑎 𝑞𝑢𝑒 𝑝𝑢𝑒𝑑𝑒 𝑖𝑟 𝑎 𝑞1 sin 𝑐𝑜𝑛𝑠𝑢𝑚𝑖𝑟 𝑛𝑎𝑑𝑎
Ahora teniendo a:
𝜀 − 𝑐 𝑞2 = 𝑞2, 𝑞3
Distancia
𝑑 𝑞, 𝑥
= {𝑝|𝑝 𝑒𝑠 𝑖𝑔𝑢𝑎𝑙 𝑎𝑙 𝑐𝑜𝑛𝑗𝑢𝑛𝑡𝑜 𝑑𝑒 𝑝 𝑡𝑎𝑙 𝑞𝑢𝑒 ℎ𝑎𝑦 𝑢𝑛𝑎 𝑡𝑟𝑎𝑛𝑠𝑖𝑐𝑖ó𝑛 𝑑𝑒 𝑞 𝑎 𝑝 𝑒𝑡𝑖𝑞𝑢𝑒𝑡𝑎𝑑𝑎 𝑝𝑜𝑟 𝑥}

𝑑 𝑞1, 𝑎 = 𝑞2
Por lo tanto la formula por estado para quitar las transiciones de vacio es:
𝜀 − 𝑐(𝑑 𝜀 − 𝑐 𝑞𝑥 , 𝑋 )
Ejemplo:

Conversión de No determinista a Determinista
Para realizar esta conversión analizamos las transiciones del estado inicial, el
resultado será un nuevo estado, ese nuevo estado servirá para crear nuevos
estados. Veamos el ejemplo:
∆ 𝑞0, 𝑐 = 𝑞1, 𝑞4
∆ 𝑞0, 𝑑 = {∅}
∆ 𝑞1, 𝑞4 , 𝑐 = 𝑞5
∆ 𝑞1, 𝑞4 , 𝑑 = 𝑞2
𝑆𝑖 𝑛𝑜 𝑒𝑥𝑖𝑠𝑡𝑒 𝑢𝑛𝑎 𝑐𝑖𝑒𝑟𝑡𝑎 𝑠𝑎𝑙𝑖𝑑𝑎 𝑑𝑒 𝑢𝑛 𝑒𝑠𝑡𝑎𝑑𝑜 𝑙𝑜 𝑚𝑎𝑛𝑑𝑎𝑚𝑜𝑠 𝑎 𝑢𝑛𝑜 𝑛𝑢𝑒𝑣𝑜 𝑙𝑙𝑎𝑚𝑎𝑑𝑜 ∅
∆ 𝑞5, 𝑐 = ∅
∆ 𝑞5, 𝑑 = ∅
∆ 𝑞2, 𝑐 = 𝑞3
∆ 𝑞2, 𝑑 = 𝑞4
∆ 𝑞4, 𝑐 = 𝑞5
∆ 𝑞4, 𝑑 = ∅
∆ ∅, 𝑐 = ∅
∆ ∅, 𝑑 = ∅
∆ 𝑞3, 𝑐 = ∅
∆ 𝑞3, 𝑑 = ∅
𝐶𝑜𝑚𝑜 𝑎𝑞𝑢í 𝑠𝑒 𝑟𝑒𝑝𝑖𝑡𝑒𝑛 𝑙𝑜𝑠 𝑒𝑠𝑡𝑎𝑑𝑜𝑠 𝑦𝑎 𝑝𝑜𝑑𝑒𝑚𝑜𝑠 𝑑𝑒𝑡𝑒𝑛𝑒𝑟 𝑒𝑙 𝑎𝑛á𝑙𝑖𝑠𝑖𝑠
Por lo tanto los estados del autómata determinista serán:
𝑞0, 𝑞1, 𝑞4 , ∅, 𝑞5, 𝑞2, 𝑞3, 𝑞4

Q/A c d
q0 q1,q4 ∅
q1,q4 q5 q2
q2 q3 q4
q5 ∅ ∅
q4 q5 ∅
q3 ∅ ∅
∅ ∅ ∅
Q= {𝑞0, 𝑞1, 𝑞4 , ∅, 𝑞5, 𝑞2, 𝑞3, 𝑞4}
I=q0
F={q3, q5}
Alf={c,d}
Minimización de estados en un AFD
Este tema no se vio en clase, pero se platicará de él en este portafolio
Menciona Louden (2004) que dos estados de un autómata finito determinista son estados
equivalentes si al unirse en un sólo estado, pueden reconocer el mismo lenguaje regular que si
estuviesen separados. Esta unión de estados implica la unión tanto de sus transiciones de entrada
como de salida. Si dos estados no son equivalentes, se dice que son estados distinguibles. Un
estado final con un estado no-final nunca serán equivalentes.
Un AFD está minimizado, si todos sus estados son distinguibles y alcanzables. Un algoritmo de
minimización de AFD es el siguiente:
Eliminar los estados inaccesibles del autómata.
Construir una tabla con todos los pares (p, q) de estados restantes.
c,d

Marcar en la tabla aquellas entradas donde un estado es final y el otro es no-final, es decir,
aquellos pares de estados que son claramente distinguibles.
Para cada par (p, q) y cada símbolo a del alfabeto, tal que r = δ(p,a) y s = δ(q,a):
Si (r, s) ya ha sido marcado, entonces p y q también son distinguibles, por lo tanto marcar la
entrada (p, q).
De lo contrario, colocar (p, q) en una lista asociada a la entrada (r, s).
Agrupar los pares de estados no marcados.

Conversión de una expresión regular a un autómata finito
Un autómata sirve para validar cualquier lenguaje regular menciona Hopcroft y Ullman(1993), y a
su vez un lenguaje regular es aceptado por un autómata finito, un autómata finito es programable
en una computadora y con ello podemos validar todas las cadenas basadas en una expresión
regular. Veamos los siguientes ejemplos, en los cuales solo se harán los diagramas:
Después agregamos los elementos faltantes como definir alfabeto, tabla de transiciones y escribir
cuales son los estados, aunque en el diagrama esa información se aprecia claramente

APLICACIÓN DE LOS AUTÓMATAS
Introducción
En este trabajo veremos la importancia y la aplicación de los autómatas, como se sabe, la teoría de
autómatas involucra 3 principales autómatas, los finitos, los de pila y las máquinas de Turing.
A través de estos se han desarrollado otros más complejos como los autómatas celulares, y se han
inventado los PLC, que tienen su fundamento en la teoría de autómatas y lenguajes formales
Autómatas celulares
Un autómata celular según Reyes (2008) es una red de autómatas simples que se conectan
localmente. A partir de varias entradas el autómata simple produce una salida, modificando en el
proceso el estado según una función de transición.
A través de los autómatas celulares se ha querido representar el funcionamiento de las células del
cerebro o neuronas, eso fue el origen de lo que se conoce como redes neuronales. El modelo era
una aproximación muy sencilla al comportamiento real de las neuronas, pero tenía grandes
aplicaciones en otros contextos. En el campo puramente matemático, Kleene redefinió el modelo
y dio lugar a los autómatas finitos, especie de máquinas ideales o modelos matemáticos, al modo
de la máquina de Turing, con posibilidades bastante más reducen la máquina de Turing, Von
Neumann trabajó en una máquina auto reproductiva que llamó kinematon y en la idea de
autómata celular.
Modelo de Vehículos Siguiéndose.
El modelo para implementar el simulador es un modelo de simulación microscópica llamado
Modelo de Autos Siguiéndose (MAS) (Car Following Modelestos modelos modelan el
comportamiento de cada vehículo individual dependiendo del vehículo que lo antecede en la calle.
Se seleccionó un modelo que utiliza autómatas celulares, propuesto originalmente por Nagel y
Schreckenberg. Aunque en el trabajo original se modela el tráfico en carreteras de alta velocidad
con una sola vía de circulación, puede ser adaptado al tráfico de una ciudad.
El modelo utiliza calles y vehículos que circulan por ellas. Un tramo de una calle, que va desde una
esquina a la siguiente, es representado por un arreglo de celdas, donde cada celda puede estar
vacía u ocupada por un solo vehículo. La cantidad de celdas Lc por cada tramo de la calle, depende
del largo de la calle y de la forma en que se escala el modelo. Los vehículos solo se mueven en una
dirección por las celdas a una velocidad discreta que va de cero a velocidad max. La velocidad
significa la cantidad de celdas que un vehículo puede avanzar en una actualización de tiempo. Los
vehículos circulan desde la primera celda hasta llegar a la última celda en la que son traspasados a
otra calle.
Arquitectura

La conexión que se hace con la arquitectura, es la capacidad de los AC de generar patrones o
modelos y, de una forma organizada, estos modelos nos pueden sugerir formas arquitectónicas.
Sabemos que un AC difiere de los modelos deterministas en que los resultados obtenidos son la
base para el siguiente grupo de resultados. El método de sustitución recursivo conti- nua hasta
que llegamos a una configuración final. Muchos métodos digitales en arquitectura han tenido un
acercamiento del tipo paramétrico, donde un grupo inicial de parámetros se usan para llegar a un
solo resultado. Si se desea un resultado distinto, los parámetros necesitan ser modificados y el
método se repite. La diferencia esta entonces, en que los resultados de los métodos paramétricos
pueden ser fácilmente anticipados, mientras que en los métodos recursivos de un autómata
usualmente no tarea sencilla. Esto ofrece una interesante y rica plataforma donde desarrollar
modelos arquitectónicos.1
Biología (El juego de la vida)
Otra aplicación de los autómatas celulares es la biología, para simular el comportamiento de las
células vivas a través de generaciones, en este caso existe un ejemplo llamado juego de la vida, el
cual tiene las siguientes reglas:
1. Sobrevivencia.- Si una célula está rodeada por 2 o 3 células vidas en la generación actual,
esta sobrevivirá a la siguiente
2. Nacimiento.- Si hay una celda vacía rodeada por exactamente 3 vecinos, esta célula nacerá
en la siguiente generación
3. Muerte por soledad.- Si una célula viva no tiene vecinos o solo tiene una célula viva como
vecino, esta morirá de soledad en la siguiente generación
4. Muerte por sobrepoblación.- Si una célula vida tiene 4 o más vecinos, esta morirá por
sobrepoblación
Esta simulación se puede representar a través de un tablero como en la siguiente imagen
Aplicaciones de los autómatas finitos y probabilísticos
Existen gran número de problemas de diseño de sistemas que se pueden simplificar a travez de la
conversión automática de la notación de expresiones regulares.
Analizadores léxicos
Los tokens se pueden expresar a travez de conjuntos regulares, por ejemplo existen
ciertos lenguajes de programación como ALGOL, donde cada palabra debe empezar con una letra
seguida de una letra o un número varias veces

(letra)(letra|número)*
En FORTRAN las palabras tienen un límite de 6 caracteres.
Los analizadores léxicos toman como entrada una secuencia de expresiones regulares las cuales
describen a los tokens y producen un autómata finito que reconoce cualquier token.
La expresión regular a un Autómata finito no determinista con transiciones de vacio, después
construyen subconjuntos de estado para producir autómatas finitos deterministas.2
Editores de texto
Existen editores de texto y programas parecidos que permiten sustituir una cadena por otra
cadena, tal que la primera cadena concuerde con una expresión regular dada3
Lenguajes de programación
Menciona Brookshear(1989) las siguientes aplicaciones
Debido a que las Expresiones Regulares, son formas concisas de describir Lenguajes Regulares, se
suelen utilizar mucho sus variantes para describir lenguajes de programación, como, por ejemplo,
la notación denominada BNF (Bachus Normal Form). Esta notación permite representar
cómodamente las expresiones válidas de cualquier lenguaje de programación.
Reconocimiento de voz
Donde una persona dice algo a un micrófono y el sistema computacional genera como salida la
secuencia de palabras dichas por la persona.
Robótica
Cuando se da la orden a un robot de que avance en alguna dirección, o que perciba lo que le
rodea, debido a que se pueden producir errores por el rozamiento de las ruedas con el suelo o por
los sensores, es posible que el robot no pueda resolver todas las tareas satisfactoriamente. Una
forma de llevar a cabo las tareas, pese al no determinismo asociado a tales errores, consiste en
utilizar Autómatas Probabilísticos para modelar las transiciones entre un estado y otro al aplicar
una determinada acción, modificando las probabilidades a medida que va observando las
consecuencias de las acciones en el entorno.4
Autómatas programables
Un autómata es la primera máquina que contiene un lenguaje, estos se basan en los autómatas
finitos, de pila y máquinas de turing. En los años 50 se introdujo la lógica programada para los
sistemas de control, pero el sistema de cableado tenía inconvenientes, por eso se invento el
autómata programable.
Las principales aplicaciones de los autómatas programables están en

Industria automotriz:
Son usados para el ensamble en las cadenas de montaje, soldaduras, pintura, el uso de pesadas
herramientas como taladros y tornos para agilizar el proceso de fabricación de automóviles
Metalurgia:
Sirven para controlar la temperatura de los hornos, ayudan a automatizar el proceso de laminado,
fundido, soldadura y máquinas pesadas
Alimentación:
Automatización del proceso de envase, empaquetado, embotellado, almacenaje entre otros
Tráfico:
Ayudan a su regulación y control de tráfico de automóviles, ferrocarriles, metro, etc.
Química:
Control de los procesos químicos y de baños en sustancias.

ANEXOS:
Tarea 1
Realizar los siguientes autómatas

TAREA2

TAREA 3.
Hacer un autómata directamente determinista para la expresión regular
(ab|aa)(a|b)*(ab|ba)|aa|ab|aaa|aab

TAREA 4.
Convertir las expresiones regulares en un AFD directo, después en AFND con
transiciones de vacío, después en AFD y por último en AFD

Conclusiones:
Los autómatas como se vio anteriormente, tienen gran importancia en la creación de un lenguaje
de programación, ya que para la validación de cadenas basadas en lenguajes regulares son
necesarios, entendiendo como funcionan podemos programarlos, ya que el propósito de la
materia es que el análisis de las cadenas, palabras y sintaxis se hagan en una computadora.
También se analizó los procesos de conversión de autómatas, ya que existen tipos de autómatas
como los no deterministas que son más difíciles de programar que un autómata no determinista,
por lo tanto se puede realizar un proceso de conversión para la programación sea mas fácil
Como hemos visto los autómatas tienen mucha utilidad en todos los aspectos de la vida humana,
ya que la computación es muy usada para muchas labores, necesitamos de máquinas, programas
que automaticen ciertos procesos, desde la detección de cadenas validas a través de un autómata
finito, hasta la programación de aparatos automatizados los cuales tienen principios en los
autómatas vistos anteriormente
Referencias y Bibliografia
 Reyes Gómez (2008), Descripción y Aplicaciones de los Autómatas Celulares. FES Acatlán,
U. N. A. M.
 Hopcroft, Ullman (1993). Introducción a la teoría de autómatas, lenguajes y computación.
Editorial CECSA
 Isasi, Martínez, Borrajo (1997). Lenguajes, gramáticas y autómatas, un enfoque práctico.
México. Editorial Addison-wesley
 Brookshear(1989). Teoría de la Computación, Lenguajes Formales, Autómatas y
Complejidad. Addison Wesley.
 Viso (2002). Teoría de la computación. México. Facultad de Ciencias UNAM
 Louden (2004). Construcción de compiladores, principios y práctica. Ed Thomson Kelley,
Dean, Teoría de Automatas y Lenguajes Formales, Prentice Hall.

Portafolio lenguajes y automatas unidad 3 - Autómatas finitos

Recomendados

Recomendados

Más contenido relacionado

La actualidad más candente

La actualidad más candente (20)

Similar a Portafolio lenguajes y automatas unidad 3 - Autómatas finitos

Similar a Portafolio lenguajes y automatas unidad 3 - Autómatas finitos (20)

Más de Humano Terricola

Más de Humano Terricola (8)

Último

Último (20)

Portafolio lenguajes y automatas unidad 3 - Autómatas finitos