UNIDAD 1, 2 Y 3: FASE 5 - DESARROLLAR APLICACIONES CON

AUTÓMATAS.
LENGUAJES FORMALES

AUTOMATAS Y LENGUAJES FORMALES

PRESENTADO:
MICHAEL BRAYAN PINILLA COY CODIGO: 1033735495
FABIAN PINZON RODRIGUEZ CODIGO: 80818364
EDITH JHOANA GUZMAN CODIGO: 1105781012
DIEGO ALBERTO RIOS PENALOZA CODIGO: 80723035

PRESENTADO A:
JHEIMER JULIAN SEPULVEDA

UNIVERSIDAD NACIONAL ABIERTA Y A DISTANCIA UNAD

MAYO 2019
CONTENIDO

INTRODUCCION .............................................................................................................................. 3
OBJETIVOS ....................................................................................................................................... 4
ACTIVIDADES A DESARROLLAR ................................................................................................ 5
BIBLIOGRAFÍA............................................................................................................................... 27
 INTRODUCCION

El trabajo presentado a continuación consta de una serie de actividades que tienen como
propósito aplicar los conocimientos adquiridos con las fuentes de apoyo suministradas por el
tutor de curso, las cuales son pieza fundamental para la realización de las actividades
planteadas.
 OBJETIVOS

 Revisa el material requerido para el desarrollo de la actividad.

 Presenta respuestas e información de los temas propuestos.
 Realiza comentarios a los aportes de sus compañeros, fundamentados en la lectura y
análisis de la información.
 Compila sus aportes individuales en un documento en PDF que presenta en el entorno
de aprendizaje colaborativo.
 Elaborar un informe de investigación que se presenta en el entorno de seguimiento y
evaluación.
 ACTIVIDAD COLABORATIVA

ACTIVIDADES QUE DESARROLLAR

El trabajo se desarrolla demostrando el procedimiento realizado paso a paso, no se tendrá

en cuenta las respuestas o simulaciones en jFlap o VAS.

Ejercicio 1:

De cada uno de los siguientes autómatas, realizar el procedimiento paso a paso de hallar la
expresión regular, el lenguaje regular y explicar el tipo de autómata que es:

1.

EJERCICIO A
TRABAJAR
Caracterización del - Identificación
autómata Autómata de tipo no determinista (AFND)
q0,q1,q2
Estado Inicial q0
Estado final q2

Lenguajes reconocidos 0 y 1
Procedimiento de Expresión(1 ∗ (0 + 001 ∗)) ∗ 1(1 ∗ (0 + 001 ∗))
conversión de
Autómata Finito a
Expresión Regular
paso a paso

5-Tupla:

𝑀 = ({𝑞0, 𝑞1, 𝑞2}, {0,1}, 𝜚, 𝑞0, 𝑞2)

𝐾 = {𝑞0, 𝑞1, 𝑞2}

Σ = {0,1}

𝑠 = 𝑞0

𝐹 = 𝑞2
 2.

EJERCICIO A
TRABAJAR

Caracterización del - Identificación

autómata Autómata de tipo no determinista AFND

q0,q1,q2

Estado Inicial: q0

Estado Final: q2

Lenguajes reconocidos 0 y 1
Procedimiento de Expresión:
conversión de
Autómata Finito a (0(1 + 0) ∗ 00 ∗) ∗ (0 + 1(1 + 0)) ∗ 0(1 + 0) ∗ 00 ∗)
Expresión Regular
paso a paso
5-Tupla:

𝑀 = ({𝑞0, 𝑞1, 𝑞2}, {0,1}, 𝜚, 𝑞1, 𝑞2)

𝐾 = {𝑞0, 𝑞1, 𝑞2}

Σ = {0,1}

𝑠 = 𝑞1

𝐹 = 𝑞2
 3.

EJERCICIO A
TRABAJAR

Caracterización del  Identificación:

autómata
autómata es de tipo no determinista (AFND)

q0, q1

Estado Inicial q0

Estado final q1

Lenguaje reconocido 0 y1

Procedimiento de Expresión((1 + 0) ∗ 00 ∗) ∗ (0(1 + 0) ∗ 00 ∗)

conversión de
Autómata Finito a
Expresión Regular
paso a paso
5-Tupla:

𝑀 = ({𝑞0, 𝑞1}, {0,1}, 𝜚, 𝑞1, 𝑞2)

𝐾 = {𝑞0, 𝑞1}

Σ = {0,1}

𝑠 = 𝑞0

𝐹 = 𝑞1
 4.

EJERCICIO A
TRABAJAR

Caracterización del - Identificación:

autómata
Autómata es de tipo no determinista (AFND)

q0, q1, q2, q3

Estado inicial q0

Estado final q3

Lenguaje reconocido 0 y1
Procedimiento de Expresión:
conversión de
Autómata Finito a 1 ∗ (0(0 + 1) + 10
Expresión Regular
paso a paso

5-Tupla:

𝑀 = ({𝑞0, 𝑞1, 𝑞2, 𝑞3}, {0,1}, 𝜚, 𝑞0, 𝑞3)

𝐾 = {𝑞0, 𝑞1, 𝑞2, 𝑞3}

Σ = {0,1}

𝑠 = 𝑞0

𝐹 = 𝑞3
Teniendo en cuenta el siguiente autómata realizar los puntos
siguientes:

Ejercicio 2: Realizar la conversión de AFD a AFND o de AFND a AFD según

corresponda.
Paso 1. Realizar tabla de transiciones:

0 1
𝑞0 𝑞3 𝑞6
𝑞1 𝑞0 𝑞6
𝑞2 𝑞1 𝑞5
𝑞3 𝑞4 𝑞3
𝑞4 - -
𝑞5 𝑞6 𝑞4
𝑞6 - -

Paso 2. Se crean dos conjuntos, un conjunto de estados finales X o

aceptadores y otro de estados no aceptadores Y:
𝑋 = {𝑞4 , 𝑞6, } = 𝑐𝑜𝑛𝑗𝑢𝑛𝑡𝑜 𝑑𝑒 𝑒𝑠𝑡𝑎𝑑𝑜𝑠 𝑎𝑐𝑒𝑝𝑡𝑎𝑑𝑜𝑟𝑒𝑠

𝑌 = {𝑞0 , 𝑞1 , 𝑞2, , 𝑞3 , 𝑞5 , } = 𝑐𝑜𝑛𝑗𝑢𝑛𝑡𝑜 𝑑𝑒 𝑒𝑠𝑡𝑎𝑑𝑜𝑠 𝑛𝑜 𝑎𝑐𝑒𝑝𝑡𝑎𝑑𝑜𝑟𝑒𝑠

Paso 3. Validación en el autómata de los conjuntos de acuerdo a las transiciones

Validación del conjunto X

0 1
𝑞4 ----- -----
𝑞6 ------ -----

Validación del conjunto Y determinando equivalencias

0 1
𝑞0 Y X
Son equivalentes
𝑞1 Y X
𝑞2 Y Y
𝑞3 X Y
𝑞5 X X

Del conjunto original Y se crean nuevos conjuntos con las equivalencias.

𝑋 = {𝑞4 , 𝑞6, } 𝐴 = {𝑞0 , 𝑞1, } 𝐵 = {𝑞2 } 𝐶 = {𝑞3 } 𝐷 = {𝑞5 }

Validación de los nuevos conjuntos.

Validamos en el autómata el conjunto X

0 1
𝑞4 ----- -----
𝑞6 ------ -----
Validación conjunto A

0 1
𝑞0 C X
𝑞1 A X

Validación conjunto B

0 1
𝑞2 A D
Validación conjunto C

0 1
𝑞3 X C

Validamos conjunto D

0 1
𝑞5 X X
Nueva tabla de transición.
0 1
X ---- ----
A C X
A A X
B A D
C X C
D X X

Como se puede evidencias en la nueva tabla de transiciones el autómata

ya no es determinista, ya que el conjunto A con su estado 0 tiene dos
transiciones tanto al conjunto A como al conjunto C.

Paso 4. Comprobación
Autómata no determinista:
Autómata determinista:

Ejercicio 3. Realice la minimización paso a paso del autómata finito

determinista:
Paso 1. Definición de Quíntuplas
 , K, 𝛿, 𝑆, 𝐹

M = {𝑞 0 , 𝑞1, 𝑞 2 , 𝑞 3 , 𝑞 4 , 𝑞 5 , 𝑞 6 } {0 1}
𝛿 = 𝑞 0 {𝑞 4 , 𝑞 6 }
𝑆 = 𝑞0 Estado Inicial
𝐹 = 𝑞 4 , 𝑞 6 Estados Finales
𝐾 = {𝑞 0 , 𝑞1, 𝑞 2 , 𝑞 3 , 𝑞 4 , 𝑞 5 , 𝑞 6 }
 = {0 1} Alfabeto

𝛿(𝑞 0 0) = 𝑞 3 𝛿(𝑞 0 1) = 𝑞 6 𝛿(𝑞1 0) = 𝑞 0 𝛿(𝑞1 1) = 𝑞 6 𝛿(𝑞 2 0)

= 𝑞1 𝛿(𝑞 2 1) = 𝑞 5
𝛿(𝑞 3 0) = 𝑞 4 𝛿(𝑞 3 1) = 𝑞 3 𝛿(𝑞 4 0) = − 𝛿(𝑞 4 1) = − 𝛿(𝑞 5 0)
= 𝑞 6 𝛿(𝑞 5 1) = 𝑞 4

𝛿(𝑞 6 0) = − 𝛿(𝑞 6 1) = −

Paso 2. Validación nuevos conjuntos (aceptadores – no aceptadores)

Estados Aceptadores
X = {𝑞 4 , 𝑞 6 }

Estados no Aceptadores
Y = {𝑞 0 , 𝑞1, 𝑞 2 , 𝑞 3 , 𝑞 5 , }
X 0 1
𝒒𝟒 - -
𝒒𝟔 - -

Y 0 1
𝒒𝟎 Y X Equivalentes
𝒒𝟏 Y X 𝑞0 , 𝑞1 . 𝑞2 , 𝑞5
𝒒𝟐 Y Y
𝒒𝟑 X Y No Equivalentes
𝒒𝟓 X X 𝑞3
Nuevos conjuntos
X = {𝑞 4 , 𝑞 6 } M = {𝑞 0 , 𝑞1 , 𝑞 2 , 𝑞 5 } Z = {𝑞 3 }
X 0 1
𝒒𝟒 - -
𝒒𝟔 - -

M 0 1
𝒒𝟎 Z X
𝒒𝟏 M X
𝒒𝟐 M M
𝒒𝟓 X X

z 0 1
𝒒𝟑 X Z
X = {𝑞 4 , 𝑞 6 } N = { 𝑞2, 𝑞5} A = {𝑞 0 , 𝑞1 } Z = {𝑞 3 }

X 0 1
𝒒𝟒 - -
𝒒𝟔 - -

N 0 1
𝒒𝟐 A N
𝒒𝟓 X X

A 0 1
𝒒𝟎 Z X
𝒒𝟏 A Z

z 0 1
𝒒𝟑 X Z

X = {𝑞 4 , 𝑞 6 } Z = {𝑞 3 } A = {𝑞 0 } B = { 𝑞1 } C = { 𝑞2} D = { 𝑞5}
X 0 1
𝒒𝟒 - -
𝒒𝟔 - -

Z 0 1
𝒒𝟑 X Z

A 0 1
𝒒𝟎 Z X

B 0 1
𝒒𝟏 A X

C 0 1
𝒒𝟐 B D

D 0 1
𝒒𝟓 X X
 Paso 3. Creación nueva Tabla de Transición
0 1
X - -
Z X Z
A Z X
B A X
C B D
D X X

Ejercicio 4. Realizar el autómata a Pila de L = {(a+bn)*}

Conjunto de estados del autómata

K= {q0, q1}
Alfabeto ∑= {a,b}
Contenido de la Pila Γ= {V}
Estado Inicial s=q0
Símbolo Inicial de pila Z= V
Estado Final F=q1 𝐿= {𝑤 ϵ (𝑎*𝑏*) | 𝑤=

Todas las cadenas que empiezan por el símbolo a seguidas por muchas
{a} o seguidas de una o muchas cadenas con el símbolo { b}

Paso 1. Validaciones
Para Estado Final
Para Pila Vacía

Paso 2. Comprobacion cadenas

Ejercicio 5. Realizar una máquina de Turing de autoría propia y
realice:

a) Recorra la máquina con al menos una cadena válida explicando

lo sucedido tanto en la cinta como en la secuencia de entrada.
b) Identifique una cadena que no sea válida y justifíquela porque
c) Ejecute el RunTest a una cadena aceptada que tenga al menos
cinco símbolos
d) Identifique en qué momento la máquina se detiene.

La MT (M):

Y se define así:

M = {Q, Σ, Γ, δ, s, B, F}, donde:

Q: es el conjunto de estados de la MT.

Σ: es el conjunto de los símbolos de entrada.
Γ: es el conjunto de símbolos de la cinta.
s: es el estado inicial.
B: es el símbolo de espacio en blanco.
F: es el conjunto de estados finales.
δ: es la función de transición.
Así:
Q = {q0, q1, q2}
Σ = {a,b,”}
Γ = {a,b,”,0,1,□}, 0 no error y 1 error.
s = q0
B=□
F = {q2}
δ:QxΓ → QxΓx{R,L,S}

δ(q0,a) = (q0,a,R)
δ(q0,b) = (q0,b,R)
δ(q0,c) = (q0,c,R)
δ(q0,”) = (q1,”,R)
δ(q0,□) = (q2,0,S)
δ(q1,a) = (q1,a,R)
δ(q1,b) = (q1,b,R)
δ(q1,c) = (q1,c,R)
δ(q1,”) = (q0,”,R)
δ(q1,□) = (q2,1,S)

a. Recorrido de la MT(M) con la cadena válida a”b”c.

Inicia la lectura de símbolos de izquierda a derecha. Lee el primer símbolo
[a], la sobrescribe en la cinta y permanece en el mismo estado q0.
Se mueve la cabeza de lectura/escritura una posición a la derecha de la
cadena de entrada, lee [“], lo sobrescribe en la cinta y pasa al estado q1.
Queriendo decir que faltan las comillas de cierre:

Se mueve la cabeza de lectura/escritura una posición a la derecha, lee

[□], la sobrescribe en la cinta y permanece en el mismo estado q1 porque
todavía no recibe las comillas de cierre:

Se mueve la cabeza de lectura/escritura una posición a la derecha, lee

[“], la sobrescribe en la cinta, cambia al estado q0, porque se completa
ese string con las comillas de cierre:

Se mueve la cabeza de lectura/escritura una posición a la derecha, lee

[c], la sobrescribe en la cinta, permanece en el estado q0:

Se mueve la cabeza de lectura/escritura una posición a la derecha, lee [□]

estando en q0, lo sobrescribe con 0 en la cinta para posteriormente
cambiar al estado de aceptación q2 y detener los movimientos (S):
La secuencia de entrada a”b”c es válida para el lenguaje en cuestión,
contiene un string bien formado (entre comillas) de acuerdo a las reglas
del autómata.
 CONCLUSIONES

Como resultado de la actividad desarrollada, se puede concluir que los conceptos básicos son
fundamentales y cumplen un papel fundamental para el desarrollo y análisis de las
actividades propuestas para el periodo académico.
 REFERENCIAS BIBLIOGRAFICAS

 Carrasco, R., Calera, R., Forcada, M. (2016). Teoría De Lenguajes, Gramáticas Y

Autómatas Para Informáticos. (pp. 127 - 142). Recuperado de
http://bibliotecavirtual.unad.edu.co:2051/login.aspx?direct=true&db=nlebk&AN=3
18032&lang=es&site=edslive&ebv=EB&ppid=pp_Cover
 Hernández, R. (2010). Practique la teoría de autómatas y lenguajes formales. (pp. 1
-124). Recuperado de
http://bibliotecavirtual.unad.edu.co:2077/lib/unadsp/reader.action?docID=10566114
&ppg=10
 Alfonseca, C., Alfonseca, M., Mariyón, S. (2009). Teoría de autómatas y lenguajes
formales. (pp. 71 - 115). Recuperado de
http://bibliotecavirtual.unad.edu.co:2077/lib/unadsp/reader.action?docID=10498456
&ppg=6
 Millán, J., Antonio J. (2009). Compiladores y procesadores de lenguajes. (pp. 28-
62). Recuperado de
http://bibliotecavirtual.unad.edu.co:2077/lib/unadsp/detail.action?docID=10844351
 Ferrando, J.C., and Gregori, V. (2012). Matemática discreta (2a. ed.). (pp. 207-232).
Recuperado de
http://bibliotecavirtual.unad.edu.co:2077/lib/unadsp/reader.action?ppg=260&docID
=10751543&tm=1481476339478
 Alemán. H. [Helena]. (2017, Junio 19). Conceptualización de automáta [Archivo de
video]. Recuperado de https://youtu.be/zMhwYlXAHE4
 Alemán. H. [Helena]. (2018, mayo 23). Expresión Regular [Archivo de video].
Recuperado de https://youtu.be/65B5QUNHfaM
 González, A. [Ángela]. (2016, mayo 30). Conversión de Autómata Finito No
Determinista a Autómata Finito Determinista [Archivo de video]. Recuperado de
https://youtu.be/29Qp_AWXFt4
 González, A. [Ángela]. (2016, mayo 30). Conversión de Autómata Finito No
Determinista a Autómata Finito Determinista con transiciones vacías – Método 1.
[Archivo de video]. Recuperado de https://youtu.be/NF47BSorRfU
 González, A. [Ángela]. (2016, junio 6). Conversión de Autómata Finito No
Determinista a Autómata Finito Determinista con transiciones vacías – Método 2.
[Archivo de video]. Recuperado de https://youtu.be/KhgMam0DMmM
 González, A. [Ángela]. (2016, junio 6). Conversión de Autómata Finito No
Determinista a Autómata Finito Determinista con transiciones vacías – Ejemplo 2.
[Archivo de video]. Recuperado de https://youtu.be/uLOXjZUTYyc
 Carrasco, R., Calera, R., Forcada, M. (2016). Teoría De Lenguajes, Gramáticas Y
Autómatas Para Informáticos. (pp. 119 - 127). Recuperado de
http://bibliotecavirtual.unad.edu.co:2051/login.aspx?direct=true&db=nlebk&AN=3
18032&lang=es&site=edslive&ebv=EB&ppid=pp_Cover
 Hernández, R. (2010). Practique la teoría de autómatas y lenguajes formales. (pp. 1
- 124). Recuperado de
http://bibliotecavirtual.unad.edu.co:2077/lib/unadsp/reader.action?docID=10566114
&ppg=10
 Alfonseca C, E., Alfonseca M, M., Mariyón S, R. (2009). (pp. 249 - 276). Teoría de
autómatas y lenguajes formales. Recuperado de
http://bibliotecavirtual.unad.edu.co:2077/lib/unadsp/reader.action?docID=10498456
&ppg=6
 Millán, J., Antonio J. (2009). Compiladores y procesadores de lenguajes. (pp. 73 -
126). Recuperado de
http://bibliotecavirtual.unad.edu.co:2077/lib/unadsp/detail.action?docID=10844351
 González, A. [Ángela] (2017, mayo 16). Minimización de un autómata. [Archivo de
video]. Recuperado de https://youtu.be/eOynYG8Ibk0
 Carrasco, R., Calera, R., Forcada, M. (2016). Teoría De Lenguajes, Gramáticas Y
Autómatas Para Informáticos. (pp. 11 - 80). Recuperado de
 http://bibliotecavirtual.unad.edu.co:2051/login.aspx?direct=true&db=nlebk&AN=3
18032&lang=es&site=edslive&ebv=EB&ppid=pp_Cover
 Hernández, R. (2010). Practique la teoría de autómatas y lenguajes formales. (pp. 1
-124). Recuperado de
http://bibliotecavirtual.unad.edu.co:2077/lib/unadsp/reader.action?docID=10566114
&ppg=10
 Alfonseca C, E., Alfonseca M, M., Mariyón S, R. (2009). Teoría de autómatas y
lenguajes formales. (pp. 19 - 65). Recuperado de
http://bibliotecavirtual.unad.edu.co:2077/lib/unadsp/reader.action?docID=10498456
&ppg=6
 Rosenfeld, D. (2016). Computabilidad, Complejidad computacional y verificación
de programas. (pp. 7 - 27). Recuperado de
http://bibliotecavirtual.unad.edu.co:2077/lib/unadsp/reader.action?docID=11201616
&ppg=12
 Bonilla, L. [Luis] (2018, mayo 23). Códigos Convolucionales Tellis y Viterbi.
[Archivo de video]. Recuperado de https://youtu.be/Oe9WEAOLeyc
 Bonilla, L. [Luis] (2018, mayo 23). Diagrama de árbol. [Archivo de video].
Recuperado de https://youtu.be/HNS4IQw64Sk
 Bonilla, L. [Luis] (2018, mayo 23). Diagrama de estados. [Archivo de video].
Recuperado de https://youtu.be/JTJkNco2tjQ
 Bonilla, L. [Luis] (2018, mayo 23). Diagrama de trellis. [Archivo de video].
Recuperado de Bonilla, L. [Luis] (2018, mayo 23). Diagrama de trellis. [Archivo de
video]. Recuperado de https://youtu.be/21JKzST2ZJY