InformeTesis-YeinielAlfonso-Optimizacion ER - AFN

See discussions, stats, and author profiles for this publication at: https://www.researchgate.
net/publication/324114613
Optimización de expresiones regulares a partir del autómata ﬁnito

equivalente
Thesis · July 2010

DOI: 10.13140/RG.2.2.33423.69286
CITATIONS READS
0 2,770
2 authors:
Yeiniel Alfonso Abel Pérez

Universidad Técnica Federico Santa María University of Matanzas "Camilo Cienfuegos"
4 PUBLICATIONS 3 CITATIONS 2 PUBLICATIONS 0 CITATIONS
SEE PROFILE SEE PROFILE
All content following this page was uploaded by Yeiniel Alfonso on 30 March 2018.
The user has requested enhancement of the downloaded file.

Universidad de Matanzas “Camilo Cienfuegos”
Facultad de Informática
Optimización de expresiones regulares a partir del autómata finito

equivalente
Trabajo de Diploma en opción al Título de Ingeniería Informática
Autor: Yeiniel Alfonso Martínez.
Tutor: Ing. Abel Pérez Martínez.
Consultante: M.Sc. Antonio Fernández Orquín.
Matanzas, Cuba
Julio, 2010.
¿Por qué esta magnífica tecnología científica, que
ahorra trabajo y nos hace la vida más fácil, nos aporta
tan poca felicidad? La repuesta es esta, simplemente:
porque aún no hemos aprendido a usarla con tino.
Albert Einstein
“La ignorancia humana no permanece detrás de la ciencia, crece

tan rápidamente como ésta”.
Stanislaw Jerzy Lec

Dedicatoria
A mis padres, mi familia, y amigos.
Agradecimientos
A mi tutor Abel por su paciencia, exigencia y apoyo.
A mis padres que son la razón de mi ser.
A mis amigos, en especial a: Yamila, Gisela, Josval, Dianelysy Antonio
A quienes estuvieron atento y pendiente del proceso de mi tesis.
A quienes contribuyeron en el desarrollo del trabajo.

Declaración de autoría
Yo, Yeiniel Alfonso Martínez, declaro que soy el único autor de este trabajo y autorizo a la
Universidad de Matanzas “Camilo Cienfuegos”, especialmente a la Facultad de Informática, a que
hagan el uso que estimen pertinente de él.
Y para que así conste, firmo la presente a los 28 días del mes de junio del 2009.
______________ ______________
Firma del Autor Firma del Tutor

Opinión del tutor
Datos personales del tutor
Nombre y apellidos: Abel Pérez Martínez
Centro de trabajo: Facultad de Informática, Universidad de Matanzas “Camilo Cienfuegos”
Organismo al que pertenece: Ministerio de Educación Superior – MES.
Cargo que ocupa: Profesor adiestrado.
Especialidad de la que es graduado: Ingeniería Informática, Facultad de Informática de la

Universidad de Matanzas, 2009.
Categoría docente o investigativa: Instructor recién graduado.
Datos de la tesis y el diplomante
Nombre y apellidos: Yeiniel Alfonso Martínez
Centro de estudio: Facultad de Informática, Universidad de Matanzas "Camilo Cienfuegos"
Título de la Tesis: Optimización de expresiones regulares a partir del autómata finto.
Opinión sobre el trabajo:
Existen innumerables situaciones en las que se hace necesario comprobar, a partir de un patrón,
si un elemento se corresponde con la estructura deseada. En otros casos es preciso sustituir una
determinada estructura por otra o simplemente remplazarla totalmente. Para esto son buenas las
Expresiones Regulares (ER). Pero existe una gran variedad de formas en que pueden ser
implementadas, encontrar la óptima según la longitud de la cadena que la representa es una tarea
compleja porque requiere de estudios profundos sobre el tema.
La tesis titulada Optimización de expresiones regulares a partir del autómata finito equivalente
presentada por el estudiante Yeiniel Alfonso Martínez, en opción al título de Ingeniero Informático,
desarrollada en la UMCC, intenta resolver una problemática de gran actualidad, pues busca
solucionar un problema que aún no ha sido resuelto. Por lo que considero que es un tema que
permitiría ir más allá de un trabajo de diploma.
El tutor de este trabajo de diploma considera que, durante su ejecución, el estudiante mostró las
cualidades que a continuación se detallan:
Tenacidad y espíritu de investigación. Absoluta independencia en el desarrollo de su investigación

en el tema. Se ha involucrado en una temática de gran complejidad que exige del conocimiento de
varias especialidades, que el investigador no recibió en su formación como ingeniero. A pesar de
esto logró captar con rapidez y profesionalidad el conocimiento necesario para enfrentar el
problema planteado. Logrando ofrecer una solución importante alcanzada como investigador.
En su trabajo fue consecuente con los aspectos tanto metodológicos como de la investigación
científica propiamente. Desarrolló su investigación con disciplina. Gracias a esto logra una feliz
culminación de su propuesta, obteniendo no solo excelentes resultados de valor para la
comunidad de investigadores, sino también como valor agregado de nuevas funciones para un
producto informático que se utiliza como herramienta para la docencia en nuestra facultad. La
documentación y los experimentos realizados, tienen gran valor y están correctamente
estructurados. Demostró dominio sobre el tema y captó con rapidez los principales elementos
abordados, especialmente el trabajo con Expresiones Regulares y Autómatas Finitos. En el
trabajo se aprecia rigor, manifestado desde el tratamiento de los conceptos estudiados y
referenciados en la bibliografía, hasta las conclusiones, lo que ha contribuido a la correcta
solución de los problemas enfrentados y ha dejado planteados importantes elementos a tener en
consideración en futuras investigaciones.
Las pruebas realizadas de forma manual y automatizada para validar su hipótesis no sólo son la
vía para certificar su trabajo, sino una demostración de lo que se puede lograr cuando se trabaja
con pasión e interés por la excelencia. Es importante destacar el uso de herramientas para
automatizar el proceso de pruebas unitarias como elemento de ingeniería de software en la etapa
que más influye en la calidad del software resultante.
Las conclusiones están correctamente estructuradas y en concordancia con los objetivos a lograr.
El trabajo cumple con los objetivos propuestos, aborda un tópico de gran actualidad y rigor
científico. El producto obtenido es de gran importancia para la comunidad de investigadores en
PLN, pues permite realizar operaciones que en la primera versión de la herramienta no estaban
disponibles y han sido bien recibidas por sus usuarios.
Por todo lo anteriormente señalado, considero que el estudiante Yeiniel Alfonso Martínez reúne
los requisitos para el título de Ingeniero Informático y espero le sea otorgada la mejor calificación
de este Tribunal.
__________________________
Ing. Abel Pérez Martínez Emitida: 28 de junio de 2010.
Resumen
Las expresiones regulares o cadenas de texto para describir un patrón de búsqueda,
son útiles en compilación y desarrollo del Procesamiento de Lenguaje Natural. Estos
contienen un autómata finito equivalente. Por las ventajas que ofrecen las expresiones
regulares, se ha elaborado un método que permite definir los procesos de equivalencia
de los autómatas y optimizarlos, con el objetivo de obtener a partir de ellos su
expresión regular mínima, implementando una biblioteca de clase que se adicionó al
software ERAFPLN. Se recoge el estudio del estado del arte asociado a la temática.
Se realiza un historial de desarrollo para medir el esfuerzo. Para demostrar la hipótesis
departida se detallan los experimentos aplicados. El resultado más relevante de esta
investigación es haber obtenido un método y aplicarlo a un recurso informático para la
optimización de expresiones regulares a partir de su autómata finito.
Tabla de Contenidos
Introducción ................................................................................................................................. 1
Capítulo 1. Fundamentación teórica y tendencias tecnológicas ....................................... 4
1.1 Motivación ..................................................................................................................... 4
1.2 Fundamento científico o marco teórico ......................................................................... 4

1.2.1 Conceptos preliminares ......................................................................................... 4
1.2.2 Expresiones Regulares. ........................................................................................ 7
1.2.3 Autómatas finitos ................................................................................................... 9
1.2.4 Algoritmo de conversión de expresión regular a autómata finito no determinista
con transiciones vacías () .................................................................................................. 12
1.2.5 Algoritmo de conversión de Autómata finito no determinista a un Autómata finito
determinista ......................................................................................................................... 16
1.2.6 Algoritmo de Optimización del Autómata Finito Determinista ............................. 20
1.2.7 Algoritmo de conversión de autómata finito a expresión regular. ....................... 31
1.3 Antecedentes del trabajo y estado del arte ................................................................. 33
1.4 Ingeniería de software. UnitTesting............................................................................. 36
1.5 Conclusiones del capítulo ........................................................................................... 37
Capítulo 2. Descripción de la solución ............................................................................... 38
2.1 Motivación ................................................................................................................... 38
2.2 Conversión de expresión regular a autómata finito no determinista. .......................... 38
2.3 Conversión de autómata finito no determinista con transiciones vacías a autómata

finito no determinista sin transiciones vacías. ......................................................................... 45
2.4 Requisitos del software. .............................................................................................. 47
2.5 Descripción de la extensión implementada ................................................................. 48
2.6 Esquema general de la aplicación. ............................................................................. 48
2.7 Implementación del algoritmo de equivalencia de expresión regular a AFND ........... 49
2.8 Implementación del algoritmo de AFND- a AFND .................................................... 51
2.9 Implementación del algoritmo de AFND a AFD .......................................................... 51
2.10 Implementación del algoritmo de optimización del AFD ............................................. 52
2.11 Cambios en el componente JFrameMain ................................................................... 55

Capítulo 3. Experimentación, discusión y análisis de los resultados............................. 58
3.1 Motivación ................................................................................................................... 58
3.2 Historial de desarrollo .................................................................................................. 58
3.3 Pruebas ....................................................................................................................... 59

3.3.1 Pruebas manuales ............................................................................................... 61
3.3.2 Pruebas Automáticas .......................................................................................... 66
Conclusiones generales ........................................................................................................... 69
Recomendaciones ..................................................................................................................... 70
Referencias Bibliográficas ....................................................................................................... 71

Introducción
En todas las ramas de la ingeniería, ciencia o economía existe la necesidad de
resolver algún problema de optimización (control de sistema, optimización de recursos
o producción, etc.) y se preguntarán ¿qué es optimizar? Sin duda, buscar la mejor
manera de realizar una actividad.
Las Matemáticas lo enfocan en el estudio de los problemas o el proceso de encontrar

los mínimos y máximos de una función.
En Economía es la forma neoclásica de la racionalidad, o sea, se trata de elegir la

mejor opción entre distintas posibilidades.
En las Letras, optimizar sería lograr construcciones sintácticas y semánticas que

hagan posible una comunicación más clara y efectiva entre emisores y receptores.
De ahí que la optimización se pueda definir como la minimización de algo malo, o la

maximización de algo bueno.
En Informática, sería transformar un programa para que realice las mismas tareas en
menos tiempo, con menos requerimientos de memoria y empleando los recursos de
forma óptima. Siempre han existido (y existirán) situaciones que requieren la
optimización para resolver un problema dado. En el caso de los informáticos, si con
pocos códigos pudieran mejorar un software, ahorrarían tiempo y disminuiría el
desgaste físico e intelectual.
Durante la ingeniería se estudian, como parte del tema de Compiladores, las

expresiones regulares y los autómatas finitos. Se utiliza la herramienta
ERAFPLN(1)para resolver o comprobar ejercicios propuestos. La misma permite crear
expresiones regulares a través de autómatas que representan determinado patrón de
texto.
Para el programador las expresiones regulares son muy útiles. Esta poderosa
herramienta permite escribir códigos cortos y ahorrar tiempo, especialmente en
JavaScript cuando no se cuenta con una conexión a Internet de alta velocidad. La
mayor parte de la sintaxis de las expresiones regulares trabaja igual en una amplia
variedad de herramientas y lenguajes de programación.
Por lo general, el significado de los símbolos utilizados para la construcción de una

expresión, no tienen similitud con los del lenguaje natural o de programación, siendo la
1
sintaxis para un inexperto difícil de recordar y bastante compleja. Una expresión
regular tiene un autómata finito equivalente, o sea, al confeccionar un autómata finito
podemos generar una cadena de texto (una vía más cómoda para inexpertos).
Habitualmente las expresiones regulares funcionan rápido, pero si se optimizan se

logran mejores resultados. Ejemplo: acdd|acdf|acdp|acd8, acd(d|f|p|8) y
acd[dfp8] realizan la misma función. Al analizar sus longitudes 19, 12 y 9
respectivamente, la menor resulta más óptima, pues se logra una mayor potencia,
rapidez y eficiencia al efectuar un filtrado, disminuyendo la longitud de la cadena de
texto y manteniendo las mismas funciones.
Pero, ¿qué tan importante es la optimización de expresiones regulares? En la

programación web muchísimo, sobre todo si se dispone de un servidor con recursos
limitados. De conseguirse que el código sea más eficiente, se dispondrá de más
capacidad en el servidor (menos carga y mejor tiempo de respuesta).
De forma predeterminada, los motores de búsqueda de expresiones compilan una

expresión regular en una secuencia de instrucciones internas (códigos de bajo
nivel).Para mejorar el rendimiento, estos almacenan en caché todas las expresiones
regulares de la memoria, evitando analizar cada vez que se utilice, una expresión en
código de alto nivel. A fin de incrementar la eficiencia sería conveniente guardar en
caché estas expresiones regulares minimizadas.
Al procesar una tabla con una cantidad de registros del orden de los millones en una
base de datos de una aplicación, sería factible utilizar expresiones regulares pues
resulta más costoso e impreciso usar en una consulta un operador como LIKE. De
igual forma si se conecta un mayor número de usuarios, la simplificación de la
expresión regular contribuiría a incrementar la velocidad en el procesamiento de los
datos.
Se investigó un grupo de herramientas (incluida ERAFPLN). La mayoría no

optimizaban las expresiones regulares generadas por el autómata equivalente,
además de no originar el autómata de una expresión regular.
De la problemática anterior emergió el siguiente problema científico a resolver ¿Se

podrán optimizar expresiones regulares a través de la minimización del autómata finito
equivalente? Teniéndose como principal objeto de estudio, la optimización de
expresiones regulares. Como campo de acción, la optimización de expresiones
regulares a través de su autómata finito equivalente mínimo.
2
Para dar respuesta a este problema se elabora la siguiente hipótesis: la optimización
del autómata finito equivalente permitirá la minimización de expresiones regulares.
Como variables de investigación se definieron: la independiente (optimización del

autómata finito), y dependiente (minimización de las expresiones regulares).
Objetivo general: Desarrollar un método para optimizar expresiones regulares a

través de autómatas finitos.
Objetivos específicos:
 Estudiar definiciones y algoritmos matemáticos para la optimización de

autómatas finitos.
 Realizar un estudio del estado del arte a un grupo de herramientas informáticas

que tratan las expresiones regulares y los autómatas finitos.
 Programar un algoritmo que realice la conversión de expresión regular a

autómata finito.
 Programar un algoritmo que realice la optimización de un autómata finito.
 Validar la solución propuesta mediante experimentos.
La investigación se estructura de la siguiente forma:
 Capítulo 1: Fundamentación teórica y tendencias tecnológicas. Se abordan los

aspectos teóricos para entender la problemática planteada y proponer la
solución. Se hace un estudio del estado del arte de un grupo de herramientas
informáticas.
 Capítulo 2: Descripción de la solución. Se explican elementos de ingeniería de

software empleados en la solución (requisitos y pruebas automáticas). Se
abordan los algoritmos de equivalencia y optimización de autómatas finitos y se
describen las nuevas opciones implementadas para el funcionamiento de
ERAFPLN.
Capítulo 3: Experimentación, discusión y análisis de los resultados. Se exponen los

elementos que se tuvieron en cuenta para validar la propuesta de solución. Se
abordan las pruebas realizadas al software tales como las manuales y
automatizadas (JUnitTest).
3
Capítulo 1. Fundamentación teórica y tendencias
tecnológicas
1.1 Motivación
En este capítulo, en aras de comprender la problemática planteada para proponer la
solución, se exponen definiciones y algoritmos matemáticos sobre las
transformaciones de equivalencias de expresiones regulares y autómatas. Se realiza
un estudio del estado del arte a un grupo de herramientas informáticas que tratan las
expresiones regulares y los autómatas. Además, se aborda la fundamentación teórica
de las pruebas automáticas como elemento fundamental de ingeniería de software
utilizada en la construcción de la solución.
1.2 Fundamento científico o marco teórico

Para solucionar el problema planteado, ha sido preciso basarse en las definiciones y
algoritmos matemáticos sobre las transformaciones de equivalencias de expresiones
regulares y autómatas. Es necesario recordar la teoría de conjuntos, grafo y
comprender algunos axiomas como: optimizar, determinismo, símbolo, alfabeto,
palabra, lenguaje regular.
1.2.1 Conceptos preliminares
La palabra conjunto se asocia con la idea de agrupar objetos iguales o diferentes, o

sea, es una colección de elementos u objetos que guardan una relación entre sí. Un
conjunto es una colección de objetos que cumplen una propiedad específica. Cada
objeto del conjunto se llama elemento(2).
Existen diferentes tipos de conjuntos:
 Conjunto Vacío (): Cuando ninguno de sus elementos cumple una condición
dada.
 Conjunto Unitario: Cuando contiene un solo elemento.
 Conjunto finito: Cuando se puede contar la cantidad de elementos.
 Conjunto infinito: Cuando no es finito.
 Conjunto Universal: Contiene todos los elementos.
4
 Conjunto potencia: Todos los subconjuntos de un conjunto A.
Subconjunto: Es una parte del conjunto y a la vez es un conjunto per se. Ejemplo:
Sean los conjuntos A= {0, 1, 2, 3, 5, 6, 7, 8, 9} y B= {3, 4, 5}, en este caso decimos que B
es subconjunto de A porque B está contenido en A.
Operaciones entre conjuntos:
 Unión (∪): A∪B contiene los elementos de A y B. Ejemplo: A = {1, 2} y B = {2, 3,
4} siendo A∪B= {1, 2, 3, 4}. La unión de conjuntos es conmutativa y asociativa.
 Intersección (∩): A∩B contiene los elementos que son iguales en A y B.
Ejemplo: A= {1,2} y B= {2,3} siendo A∩B= {2}. La intersección es conmutativa y

asociativa.
 Diferencia (─): A−B contiene los elementos de A que no están en B. Ejemplo:
A= {1, 2,3} y B= {2, 4,5} siendo A−B= {1,3}. La diferencia de conjuntos no es ni

asociativa ni conmutativa.
Grafo: Estructura de datos. Un conjunto de objetos denominados nodos o vértices

unidos por arcos. G(V,E) es un par ordenado, siendo V un conjunto de nodos o
vértices y E, conjunto de arcos que relacionan a los nodos. Ejemplo: V = {Nodo1,
Nodo2}; E = {(Nodo1, Nodo2)}Figura 1.1.
Figura 1.1Representación Gráfica de un Grafo
V = {Nodo1, Nodo2}; E = {(Nodo1, Nodo2)}
Optimizar: Buscar la mejor manera de realizar una actividad, según la Real Academia
Española(3).En Informática, tratar de adaptar un programa o software que realice las
mismas funciones o tareas en menos tiempo y requerimiento de memoria. Utilizar los
recursos de forma rápida y eficiente.
Determinismo: No hay elección posible. Existe o no, una alternativa.
5
No Determinismo: Existen varias alternativas.
Símbolo: Tipo de abreviación de carácter científico o técnico; una representación de

una información, como a, 6, +, etc. Un símbolo es una entidad indivisible.
Alfabeto: Conjunto no vacío de símbolos. Se utiliza generalmente la notación ∑ para

representarlo.
El conjunto de cantidades u operaciones ordenadas donde cada una está determinada

por las anteriores, es la definición de secuencias o cadenas de caracteres. Las
mismas se forman con los símbolos de un alfabeto tales como casa, hola, a, etc.
También son conocidas como palabras. Un caso particular es la palabra vacía,, que
no contiene ninguna letra.
La cantidad de letras o longitud de una palabra, se denota por |w|. Ejemplo,

|adulto| = 6. Palabra nula o vacía: su longitudes cero. Algunos autores utilizan 
para denotarla.
La concatenación de dos o varias palabras origina la creación de palabras nuevas,

cuya longitud es la sumatoria de las palabras originales. Ejemplo, si X = ciem, Y =
piés, XY es la palabra ciempiés. Esta operación es asociativa, pero no conmutativa.
Un lenguaje es un conjunto de palabras y se pueden efectuar con ellas todas las

operaciones de los conjuntos (unión, intersección, diferencia). La operación de
concatenación de lenguajes, escrita como L1 • L2, resulta una extensión de la
concatenación de palabras: L1 • L2 = {w|w = xy, x  L1, y  L2}.
Un lenguaje finitoes aquel que contiene un número finito de palabras.
Un lenguaje infinitoestá determinado por la recursividad de sus requerimientos

sintácticos simples.
Definición: Un lenguaje (L) es regular, si y sólo si se cumple al menos una de las

condiciones siguientes:
 L, es finito.
 L, es la unión o la concatenación de otros lenguajes regulares R1 y R2, L = R1

U R2 o L = R1R2 respectivamente.
6
 L, es la estrella de Kleene de algún lenguaje regular, L = R*.
Teorema de Kleene: Un lenguaje es regular si y sólo si es aceptado por algún

autómata finito.(4).
Un lenguaje regular tiene su representación a través de una expresión regular.
1.2.2 Expresiones Regulares.
Una expresión regular es una cadena de texto para describir un patrón de búsqueda.
Es una fórmula que caracteriza un lenguaje ─un conjunto de cadenas. Resultan útiles
en compilación y desarrollo del Procesamiento de Lenguaje Natural. También permiten
sustituir textos, editar o generar nuevos ficheros, manipulando el contenido de otros.
Las expresiones regulares son convenientes, rápidas y potentes al efectuar un filtrado

sobre un caso dado, y lograr un resultado más reducido y específico. Usan poca
memoria y ahorran códigos. Importante en JavaScript, para conexiones lentas en
Internet.
Las siguientes definiciones son tomadas del libro Autómatas y Lenguajes(3)
Definición: Sea ∑ un alfabeto. El conjunto ER de las expresiones regulares sobre ∑

contiene las cadenas en el alfabeto ∑U {λ, |, •, *, (,), Ø} que cumplen con lo siguiente:
 λ y Ø  ER
 Si ζ  ∑, entonces ζ  ∑ ER.
 Si E1, E2  ER, entonces (E1 | E2) ER, (E1 • E2) ER, (E1)* ER.
Definición: El significado de una expresión regular es una función L: ER2∑* (una

función que toma como entrada una expresión regular y entrega como salida un
lenguaje), definido de la manera siguiente:
L(Ø) = Ø (el conjunto vacío)
L(λ) = { ε } (la palabra vacía)
L(ζ) = { ζ }, ζ ∑
L( ( R • S ) ) = L(R)L(S), R,S  ER
7
L( ( R | S ) ) = L(R) U L(S),R, S  ER
L( (R)* ) = L(R)*,R  ER
Las plataformas de desarrollo disponen de expresiones regulares, aunque cada una

usa su propio dialecto. Las expresiones regulares se basan en sus operadores básicos
(* + | () ?), Comodines (\w \s \d) y en las tres operaciones básicas: concatenación,
repetición y alternativas.
Operadores Básicos:
 Ninguna o más repeticiones (*): a* indica que acepta ninguna o más

repeticiones de a.
 Una o más repeticiones (+): a+ indica que acepta una o más repeticiones de
a.
 Opcionalidad (?): a? indica que a puede aparecer o no. De aparecer, sólo

una vez.
 O lógico (|): a|b indica que existe una alternativa que puede aceptar aob.
 Agrupación ( ): Este operador, los paréntesis, se utiliza cuando se desea

agrupar una parte de la expresión para un tratamiento especial. Ejemplo:
(a|b)?c, tiene las combinaciones de texto siguiente: ac, bc, c. debido a que
la subexpresión a|b se encuentra entre paréntesis, se le aplica el operador
opcional ?. Si esta subexpresión no estuviera agrupada a|b?c los textos
serían: a, c, bc, porque dicho operador se le aplica sólo a la b.
Existen otros metasímbolos:
 Cualquier carácter (.): .a.indica que cualquier cadena de longitud 3 contiene

la letra a en la posición del centro.
 Clase de caracteres [ ]: [0-9] indica cualquier carácter entre el cero y el

nueve.
Comodines y abreviaturas:
 \w: indica los alfanuméricos. ([A-Za-z_0-9])
8
 \s: indica los caracteres de separación (\t ,\n, \r y espacio).
 \d: indica los dígitos.
Teorema: Todo lenguaje definido por una expresión regular también es definido por un
autómata finito(5).
1.2.3 Autómatas finitos
En el artículo de M.V.Lawson(6) el término autómatas finitos describe una clase de

modelos de computación que se caracterizan por tener un número finito de estados.
Son dispositivos informáticos que aceptan o reconocen los idiomas regulares.
Según R. Brena(4), un autómata finito es el modelo matemático de un sistema. El

mismo recibe una cadena constituida por símbolos de un alfabeto, y determina si esa
cadena pertenece al lenguaje que él reconoce.
La definición formal de J.E.Hopcroft(5) plantea lo siguiente:
Definición: Un autómata finito (AF) es un quíntuplo (Q, ∑, δ, s, F), donde:
 Q es un conjunto de estados.
 ∑ es el alfabeto de entrada.
 s  K es el estado inicial.
 F  Q es un conjunto de estados finales.
δ: K ×∑ → Q es la función de transición, que a partir de un estado y un símbolo del

alfabeto obtiene un nuevo estado.
El diagrama de transición determinalas cadenas del lenguaje a través de un grafo

dirigido con información añadida. Los nodos del grafo representan los estados del
autómata finito y señalan hasta donde se analizó la cadena. El estado inicial (s) o
comienzo del autómata es marcado con una flecha; los estados finales o aceptación
(F) por un doble círculo. Las etiquetas de los arcos están definidas por los símbolos
del alfabeto. Cuando una cadena termina en un estado final es aceptada por el
lenguaje.
9
La palabra “ami’ en francés, significa “amigo” en español. Se puede notar que tienen
cierta similitud, “ami” es un subconjunto de “amigo”, A = {a, m, i}, B = {a, m, i, g, o},
A∪B= {a, m, i, g, o}; la expresión regular amigo|amioami(go)? reconocen esta

palabra en los idiomas mencionados. El autómata que lo representa se muestra en la
Figura 1.2Error! Reference source not found., donde q1 es el estado inicial o inicio,
q4 y q7 son los estados aceptados o finales. Al llegar al estado q4 se obtiene la
palabra “ami”, y en q7 “amigo”.
Figura 1.2Autómata finito que reconoce las cadenas "amigo" y "ami"
Si se le añaden las palabras en plural hay que agregar un estado,Figura 1.3. El

autómata cambia transformando la expresión regular en amigos|amis|amigo|amio
ami(go)?(s)?
Figura 1.3Autómata finito que reconoce las cadenas "amigo", “amigos”, "ami" y “amis”
Otra forma de representar un autómata es mediante Las Tablas de Transiciones:

Las filas muestran los estados del autómata finito, y las columnas los símbolos del
alfabeto. Las intersecciones de fila y columna muestran el próximo estado, la Tabla
1.1muestra un ejemplo de tabla de transiciones del autómata finito de la Figura 1.2.
10
Tabla 1.1 Transición del autómata finito Figura 1.2
a m i g o
q1 q2
q2 q3
q3 q4
q4 q5
q5 q7
q7
Los autómatas finitos pueden ser no deterministas o deterministas, existiendo tres

clasificaciones: AFND-, AFND y AFD.
A través de los autómatas finitos deterministas (AFD) se pueden generar las

expresiones regulares y viceversa.
La expresión regular ad*|ad|ad+ no es óptima al contener elementos redundantes

(|ad|ad+). Esta se puede transformar en un AFD a través de un modelo matemático,
y minimizarlo para obtener una nueva expresión regular equivalente o igual a la
anterior. Estos dos resultados se pueden comparar y escoger el más eficiente y
optimizado. En este ejemplo la expresión resultante sería ad*siendo la más óptima
porque realiza las mismas funciones que la anterior y su longitud es menor.
Partiendo de un estado y un símbolo del alfabeto hay un solo estado siguiente, o sea
si el estado qQ, para el símbolo d∑ existe una sola transición δ(q,d) posible,
entonces el autómata es determinista (AFD).
De un estado parten varias transiciones con el mismo símbolo del alfabeto, o sea el
estado qQ, para el símbolo d∑ existe más de una transición δ(q,d) posible,
entonces el autómata es no determinista (AFND).
Si contiene transiciones vacías o, permite cambiar de estado sin procesar ningún
símbolo de la entrada, entonces el autómata es no determinista con transiciones
vacías (AFND-). Es el que más estados posee.
Los AFND tienen menos restricciones que los AFD, siendo este último un caso
particular de los AFND. Todo AFD es un AFND.
Existen cuatro notaciones diferentes de equivalencia para expresiones regulares

(4):
11
Figura 1.4 Modelo de equivalencia entre expresiones regulares y autómatas; y entre los diferentes
autómatas
Definición: Dos autómatas A1 y A2 son equivalentes (A1  A2), cuando aceptan el

mismo lenguaje.
1.2.4 Algoritmo de conversión de expresión regular a autómata

finito no determinista con transiciones vacías ()
Para obtener el AFND- equivalente de la expresión regular se tienen en cuenta las

tres operaciones básicas: concatenación, repetición y alternativas. El método utilizado
lo describió por primera vez J. E. Thompson en su documento de 1968 del MCCA.
El AFND- de una expresión regular se construye a partir delAFND parcial de cada

subexpresión con una construcción diferente para cada operador básico. Después se
unen estas subexpresiones con transiciones .
El AFND- siempre contiene un estado inicial y otro final.
La expresión ab se divide en dos subexpresiones a y b. Este es un ejemplo simple de

concatenación en el cual no aparecen las transiciones. Aparecen cuando se utiliza el
operador paréntesis:
 ab:
Figura 1.5 AFND- equivalente, de la expresión regular ab
 (ab):
12
Figura 1.6 AFND- equivalente, de la expresión regular (ab)
La expresión a|b se divide también en dos subexpresiones a y b. El operador que la

contiene indica que existe una alternativa. Apareciendo las transiciones  para unir
estas dos expresiones:
Figura 1.7 AFND- equivalente, de la expresión regular a|b
La expresión regular a|b|c tiene dos formas de representar el autómata:
 Dividiendo esta expresión en tres subexpresiones a, b, c
Figura 1.8 AFND- equivalente, de la expresión regular a|b|c
 Dividiendo la expresión por primera vez, en dos subexpresiones a y b|c;

después se divide b|c en dos subexpresiones b y c.
13
Figura 1.9 AFND- equivalente de la expresión regular a|b|c
La expresión regular a?:
Figura 1.10 AFND- equivalente de la expresión regular a?
La expresión regular a* se representa casi igual que a+ pues son operaciones

básicas de repetición, la única diferencia radica en que a* tiene una transición  de
más:
 a*:
Figura 1.11 AFND- equivalente de la expresión regular a*
 a+:
14
Figura 1.12 AFND- equivalente de la expresión regular a+
Un ejemplo que se puede detallar y analizar sería el siguiente. Llamaremos a los

pasos iteraciones:
Expresión regular: ad|ad*
En la Iteración 1: se divide la expresión en dos subexpresiones y se aplica la

operación alternativa:
Figura 1.13 AFND- equivalente de la expresión regular ad|ad*(Iteración 1)
Iteración 2:se aplica la operación de concatenación a los nodos (q1, q3) y (q2, q4):
Figura 1.14 AFND- equivalente de la expresión regular ad|ad*(Iteración 2)
Iteración 3 y final: se aplica la operación de repetición a la subexpresión d*en el

nodo (q7, q4), obteniendo el siguiente AFND- equivalente:
15
Figura 1.15 AFND- equivalente de la expresión regular ad|ad*
1.2.5 Algoritmo de conversión de Autómata finito no determinista a

un Autómata finito determinista
La conversión de un AFND- o AFND en un AFD se basa en el concepto de clausura-

 (Operador estrella o Clausura de Kleene) que se describe como A*.
A es un subconjunto de A*que contiene la secuencia vacía () y este último es un

sistema de las secuencias que se forman con las concatenaciones de cero o más
secuencia de A.
Ejemplos:
 {a}* = {, a, aa, aaa, ...}
 {a, b}* = {, a, b,aa, ab, ba, bb}.
La clausura (q), siendo q un estado, es el conjunto de todos los estados que se
acceden a partir de q, con un símbolo de entrada.
La transformación de un AFND a AFD se realiza a través de la tabla de transición del

autómata finito no determinista, siendo cada entrada un conjunto de estado. Mientras
en la tabla de transición del autómata finito determinista (Error! Reference source not
found.), cada entrada del alfabeto es un solo estado. Cada estado del AFD deviene un
conjunto de estados del AFND. El estado inicial y el alfabeto del AFND es el mismo
para el AFD.
16
1.2.5.1 Conversión de AFND- a AFD
En Figura 1.15 se obtuvo el AFND-, cuya expresión regular es ad|ad*. A medida

que se obtienen los conjuntos del autómata, se calcula la tabla de transición.
Iteración 1: Al comenzar con q0 (estado inicial) se obtendría la clausura-(q0), es

decir, todos los estados alcanzados con transiciones  desde este estado. Los estados
serían {q1, q2}, a este Conjunto lo llamaremos A.
Tabla 1.2 Tabla de transición del autómata (Figura 1.15)
a d Aceptación
A={q0}∪{q1, q2}
Iteración 2: Se calculan todos los estados alcanzables con la letra a y d desde cada
elemento del Conjunto A.
Con la letra d desde q6 se llega a q3y no se alcanza ningún estado.
Con a desde q1 se llega a q6 y desde q2 se llega a q7 formando el conjunto {q6, q7} al
cual se le aplica la clausura a q6 y q7 siendo los estados alcanzables con transiciones
 el conjunto {q18, q4, q5}que forman el conjunto B. Como q5 es un estado de
aceptación adquiere B la condición de estado final.
a d Aceptación
A={q0}∪{q1, q2} B={q6, q7}∪{q18, q4, q5}
B={q6, q7}∪{q18, q4, q5} sí
elemento del Conjunto B.
Con la letra d desde q6 se llega a q3, desde q18 a q19 formando el conjunto {q3, q19}
al cual se aplica la clausura y forman el conjunto {q5, q18, q4}, y la unión de ambos
conjuntos da como resultado el conjunto C. Como q5 es un estado aceptación, C se

convierte en estado final.
Con la letra a no se alcanza ningún estado.
17
a d Aceptación
A={q0}∪{q1, q2} B={q6, q7}∪{q18, q4, q5}
C={q3, q19}∪{q5, sí
B={q6, q7}∪{q18, q4, q5} q18, q4}
C={q3, q19}∪{q5, q18, q4} sí
elemento del Conjunto C.
Con la letra a no alcanza ningún estado.
Con la letra d desde q18 se llega a q19, formando el conjunto {q19} al cual se le aplica
la clausura emergiendo el conjunto {q3, q5, q18, q4}. Al unir estos dos conjunto se
forma de nuevo el conjunto C.
a d Aceptación
B={q6, q7}∪{q18, q19, q4,
A={q0}∪{q1, q2} q5}
C={q3, q19}∪{q5, q18, sí
B={q6, q7}∪{q18, q4, q5} q4}
C={q19}∪{q3, q5, sí
C={q3, q19}∪{q5, q18, q4} q18, q4}
Iteración 5 y final: No existe conjunto nuevo a analizar. Obteniendo la tabla del AFD
equivalente.
Tabla 1.6 Tabla de transición del autómata determinista (Figura 1.16)
a d Aceptación
A B
B C sí
C C sí
Los conjuntos se transforman en estados. Aes el estado inicial, B y C son estados
aceptados o finales, porque como conjunto contienen a q5 y heredan sus propiedades.

Siendo el autómata finito determinista:
18
Figura 1.16 AFD equivalente del AFND (Figura 1.15)
1.2.5.2 Conversión de AFND a AFD
La expresión regular ad|ad* puede obtener un AFND equivalente:
Figura 1.17 AFND equivalente de la expresión regular ad|ad*
A medida que se obtienen los conjuntos del autómata, se calcula la tabla de transición.
Iteración 1: Al comenzar con q0 (estado inicial) denominado A, se calculan todos los

estados alcanzables con la letra a y d.
Con la letra a desde q0 se llega a q1 y q2, formando el conjunto {q1, q2} denominado
B.
Con la letra d no alcanza ningún estado.
Tabla 1.7 Tabla de transición del autómata (Figura 1.17) (iteración 1)
a d
A={q0} B={q1, q2}
B
Iteración 2: Se calculan todos los estados alcanzables con la letra a y d del conjunto
{q1, q2}
19
Con la letra d desde q1 se llega a q3 y desde q2 se llega a q4, formando el conjunto
C{q3, q4}.
a d
A={q0} B={q1, q2}
B C={q3, q4}
C
elemento del Conjunto C.
Con la letra d desde q3 se llega a q3, formando el conjunto {q3} que pertenece a C.
a d
A={q0} B={q1, q2}
B C={q3, q4}
C C
Iteración 4: No existe conjunto nuevo a analizar. Formando la misma tabla de

transición (Tabla 1.6) y el autómata finito determinista (Figura 1.16).
1.2.6 Algoritmo de Optimización del Autómata Finito Determinista
El objetivo es obtener el autómata finito determinista mínimo equivalente de un AFD,

mediante la eliminación del número de estados posibles. Para esto es necesario
buscar los estados equivalentes existentes.
En la Figura 1.16,B y C son equivalentes, porque al unirlos no cambia su configuración

en la aceptación o rechazo de palabras, o sea, los dos estados tienen la misma
condición de aceptación(son finales) y su alfabeto de entrada es el mismo (d), δ (B,
d)≡δ (C,d).
Definición: Dos estados son equivalente (p≡q) si tienen la misma condición de

aceptación, además, si y sólo si, para cada cadena de entrada x. δ(p, x) ≡ δ (q, x).
20
Dos estados son distinguibles cuando uno tiene la condición de aceptación o final, y el
otro no. Ejemplo: La Figura A y C son distinguibles.
Cuando dos estados son equivalentes, se elimina uno para evitar redundancias. El
problema de esta acción radica en qué hacer con las flechas que conectan el estado
eliminado con el resto. Esto se soluciona con los siguientes criterios (4):
 Las flechas que salen del estado eliminado son eliminadas.
 Las flechas que llegan al estado eliminado son redirigidas hacia su estado
equivalente.
Estas definiciones permiten comprender el Teorema de Myhill-Nerode al caracterizar

los subconjuntos reconocibles por un semi grupo.
Teorema (Myhill-Nerode): Una relación de equivalencia≡ sobre ∑ * es:
 Invariante por la derecha: Si u ≡ v implica que ∀ z ∈ ∑ * se cumple uz ≡vz.
 Invariante por la izquierda: Si u ≡ v implica que ∀ x ∈ ∑ * se cumple xu ≡ xv
 De congruencia: Si u ≡ v implica que ∀ x, z ∈ ∑ * se cumple xuz ≡xvz
1.2.6.1 Algoritmo para la minimización del AFD mediante una Tabla de

Estados Equivalentes.
Construir Tabla: Las filas y columnas están etiquetadas con estados. Representando
una pareja de estados del autómata. Ejemplo: Del AFD (Figura 1.16) su Tabla de
estados equivalentes es (Tabla 1.10).
Tabla 1.10 Tabla de Estados Equivalentes
A  simétrico simétrico
B  simétrico
C 
A B C
21
Esta tabla se construye de forma optimizada, o sea, triangular porque se buscan
relaciones de equivalencia:
Tabla 1.11 Tabla optimizada de Estados Equivalentes
A B
Marcar estados distinguibles en la tabla: Se realiza un recorrido de izquierda a

derecha y cada columna de arriba a abajo. En este caso los pares distinguibles son (A,
B) y (A, C). Siendo el par (B, C) posibles equivalentes. (Tabla 1.12).
B X
C X
A B
Analizar posibles estados equivalentes: Para analizar si los estados son

equivalentes, se utilizan sus alfabetos de entrada. En este caso sería (d).
Si se analiza el par (B, C), a la vez se analiza (C, B) porque se cumple la propiedad
simétrica de una relación binaria de equivalencia.
δ(B, d) = C , δ(C, d) = C se forma el par (C, C).Al analizar la Tabla 1.10, este par
equivalente se halla en la diagonal. Si el par formado en la tabla se encuentra marcado
entonces no es equivalente y se marca, de lo contrario, es equivalente. (Tabla 1.13)
B X
C X (B, C)
22
A B
Al terminar el recorrido, los estados equivalentes se unen, teniendo en cuenta los

criterios mencionados.
Figura 1.18 AFD optimizado, del AFD (Figura 1.16)
La tabla de estado equivalente (Tabla 1.14) contiene a A≡ B.
B (B, C)
C X
A B
Si se analiza la casilla (B, C) y no son equivalentes, la casilla (A, B) se marca como no

equivalente porque contiene a este par. (Tabla 1.15)
B √
C X √
A B
Ejemplo: El AFD siguiente (Figura 1.19):
23
Figura 1.19 AFD equivalente de la expresión regular c+|d|aac*|ba
Se construye la tabla y se marcan los distinguibles:
Tabla 1.16 Tabla de Estados Equivalentes del autómata (Figura 1.19)
q2 X
q3 X
q4 X X

q5 X X

q6 X X X
q7 X X X
q1 q2 q3 q4 q5 q6
Al analizar la casilla (q1, q4): los alfabetos de entrada son {a, b, c, d}, como para cada
cadena de entrada x, δ(q1, x) ≡ δ (q4, x), y se elabora la tabla de transición de
equivalencia (Tabla 1.17).
Tabla 1.17 Tabla de transición de equivalencia
a d c d
q1 q4 q5 q2 q3
q4 q6
24
Tabla de transición de equivalencia: Forma de representar δ(q, x) ≡ δ (p, x) siendo
(x) una cadena de entrada. Las intersecciones de fila y columna muestran el próximo
estado con la cadena de entrada específica. Si contiene la tabla una casilla vacía, los
estados q y p no son equivalentes. Pero cuando todas las casillas se marcan, o sea,
están ocupadas, los pares que se forman son responden a la unión del superior con el
inferior. Ejemplo: (q4,q6).
Como los estados q1 y q4 no son equivalentes, se marca la casilla (Tabla 1.18):
q2 X
q3 X
q4 √ X X
q5 X X

q6 X X X
q7 X X X
q1 q2 q3 q4 q5 q6
Al analizar la casilla (q1, q5): los alfabetos de entrada son {a, b, c, d}, como para cada
cadena de entrada x, δ(q1, x) ≡ δ (q5, x), elaborándose la siguiente tabla de transición
de equivalencia (Tabla 1.19).
a d c d
q1 q4 q5 q2 q3
q5 q7
Como los estados q1 y q5 no son equivalentes, se marca la casilla (Tabla 1.20):
25
q2 X
q3 X
q4 √ X X
q5 √ X X
q6 X X X
q7 X X X
q1 q2 q3 q4 q5 q6
Al analizar la casilla (q2, q3): el alfabeto de entrada es {c}, como para cada cadena de
entrada x,δ(q2, x) ≡ δ (q3, x), se elabora la tabla de transición de equivalencia (Tabla
1.21).
c
q2 q2
q3
Los estados q2 y q3 no son equivalentes, se marca la casilla (Tabla 1.22):
q2 X
q3 X √
q4 √ X X
q5 √ X X
q6 X X X
q7 X X X
26
q1 q2 q3 q4 q5 q6
entrada x,δ(q2, x) ≡ δ (q6, x), y se elabora la tabla de transición de equivalencia (Tabla
1.23)
c
q2 q2
q6 q6
Cuando se revisa en la tabla (Tabla 1.22) el par formado (q2, q6), no se encuentra
marcada la casilla. Por ende, los estados q2 y q6 son equivalentes, y se marca la

casilla (Tabla 1.24):
q2 X
q3 X √
q4 √ X X
q5 √ X X
q6 X (q2, q6) X X
q7 X X X
q1 q2 q3 q4 q5 q6
entrada x,δ(q2, x) ≡ δ (q7, x) y se elabora la tabla de transición de equivalencia (Tabla
1.25)
c
q2 q2
27
q7
Los estados q2 y q7 no son equivalentes, por lo que se marca la casilla (Tabla 1.26):
q2 X
q3 X √
q4 √ X X
q5 √ X X
q6 X (q2, q6) X X
q7 X √ X X
q1 q2 q3 q4 q5 q6
entrada x, δ(q3, x) ≡ δ (q6, x) y se elabora la tabla de transición de equivalencia (Tabla
1.27)
c
q3
q6 q6
Los estados q3 y q6 no son equivalentes, de ahí que se marque la casilla (Tabla 1.28):
q2 X
q3 X √
q4 √ X X
q5 √ X X
28
q6 X (q2, q6) √ X X
q7 X √ X X
q1 q2 q3 q4 q5 q6
Al analizar la casilla (q3, q7): no contienen alfabetos de entrada. En este caso los dos
estados tienen la condición de aceptación. Se marcan como equivalentes (Tabla 1.29):
q2 X
q3 X √
q4 √ X X
q5 √ X X
q6 X (q2, q6) √ X X
q7 X √ (q3, q7) X X
q1 q2 q3 q4 q5 q6
Al analizar la casilla (q4, q5): el alfabeto de entrada es {a}, como para cada cadena de
entrada x,δ(q4, x) ≡ δ (q5, x) y se elabora la tabla de transición de equivalencia (Tabla

1.30)
a
q4 q6
q5 q7
Al analizar los siguientes pares:
Si se revisa en la tabla (Tabla 1.29) el par (q6, q7) no se encuentra la casilla marcada,
por tanto q4 y q5 son equivalentes.(Tabla 1.31):
29
q2 X
q3 X √
q4 √ X X
q5 √ X X (q6, q7)
q6 X (q2, q6) √ X X
q7 X √ (q3, q7) X X
q1 q2 q3 q4 q5 q6
entrada x,δ(q6, x) ≡ δ (q7, x). y se elabora la tabla de transición de equivalencia (Tabla
1.32)
c
q6 q6
q7
Los estados q6 y q7 no son equivalentes, si se observa en la tabla (Tabla 1.31), en la
casilla (q4, q5) se encuentra el par (q6, q7) por ende q4 y q5 no son equivalentes y se
marca la casilla (Tabla 1.33):
q2 X
q3 X √
q4 √ X X
q5 √ X X √
q6 X (q2, q6) √ X X
30
q7 X √ (q3, q7) X X √
q1 q2 q3 q4 q5 q6
Los estados equivalentes son: q2 ≡ q6, q3 ≡ q7, siendo el autómata finito determinista
optimizado (Figura 1.20)
Figura 1.20 AFD optimo del AFD (Figura 1.19)
1.2.7 Algoritmo de conversión de autómata finito a expresión

regular.
La transformación de un autómata finito en una expresión regular equivalente, consiste

en eliminar gradualmente los estados del autómata, hasta que quede un sólo estado
inicial y uno final (5) (4).
Algoritmo:
Figura 1.21 AFD, su expresión regular equivalente (aa|bb)|a óa?a|bb
 Se adiciona un estado inicial (qi) al autómata (qi, ) = q0, con el objetivo de que
exista un estado inicial al cual no llegue ninguna transición,
 Se adiciona un estado final (qf), con varias transiciones de los antiguos

estados finales a él, con el objetivo de que exista un solo estado final del cual
no salga ninguna transición. (Figura 1.22)
31
Figura 1.22 El AFD (Figura 1.21) con los dos estados temporales.
Se eliminan los estados intermedios, o sea, todos los que estén en el camino entre qi y
qf. Al suprimir un estado, se reemplazan todos los caminos que pasan a través de él
como transiciones directas. Ejemplo (Figura 1.23). En el paso A se eliminóq0;en B, q1y
se forma el par (qi, qf). En el paso C al eliminar q2 se adiciona en el par (qi, q3) la
secuencia bb con el operador básico de alternativa (O lógico). El paso D y final, realiza
lo mismo que el paso C, siendo la expresión regular resultante (aa|bb)|a.
32
Figura 1.23Proceso de conversión de AFD a expresión regular
1.3 Antecedentes del trabajo y estado del arte

A través de la búsqueda bibliográfica se realizó el estudio de 15 herramientas que
facilitan el proceso de obtención y prueba con expresiones regulares, debido a su
complejidad.
33
En el análisis de las herramientas se tuvieron en cuenta los siguientes puntos:
A. Optimizar o minimizar expresiones regulares.
B. Aplicación Web
C. Aplicación de Escritorio
D. Comprobar la sintaxis de la expresión regular mediante pruebas de textos.
E. Proporcionar una biblioteca de expresiones regulares.
F. Almacenar o guardar expresiones regulares.
G. Dibujar autómatas.
H. Obtener un autómata finito no determinista con transiciones nulas a partir de

una expresión regular.
I. Obtener un autómata finito determinista mediante un autómata finito no

determinista con o sin transiciones nulas.
J. Optimizar autómatas finitos deterministas.
K. open source.
L. Pago
M. Gratis
N. Obtener la expresión regular de un autómata.
Tabla 1.34 Características de 15 herramientas que facilitan el proceso de obtención y prueba de

expresiones regulares
Herramientas A B C D E F G H I J K L M N
RegExlib(7) x x x x x
x x x x
Javascript Regular
34
ExpressionValidator(8)
RegexPal(9) x x x
Metriplica(10) x x x
Regular
ExpressionTool(11) x x x
Regexp Editor (12) x x x
Rad Software Regular

Expression Designer (13) x x x x x
Visual REGEXP 3,0 (14) x x x x x
Regulazy v1.0.3.0 (15) x x x
Regular
ExpressionWorkbench(16) x x x x x
RegexDesigner v1.0.2727
(17) x x x x x
Visual Automata Simulator

(18) x x x x x x
SP-PS1 (19) x x x x x x x
ERAFPLN (1) x x x x x x x
RegexBuddy3 (20) x x x x x
0 6 9 15 6 9 2 1 2 1 2 1 14 1
35
16
14
12
10
0
A B C D E F G H I J K L M N
Figura 1.24 Gráfico de barras sobre las características de un grupo de 15 herramientas que facilitan el
proceso de obtención y prueba de expresiones regulares.
Del grupo de herramientas analizadas, como muestra la Figura 1.24, no existen

evidencias de un software que optimice las expresiones regulares. Todas comprueban
la sintaxis de las expresiones regulares mediante pruebas de textos, siendo
prácticamente la única funcionalidad de las herramientas web. Carecen de las
funcionalidades G, H, I, J y N, que se basan en el modelo de John. E. Hopcroft(5)
Figura 1.4.
1.4 Ingeniería de software. UnitTesting.

Unit test (pruebas unitarias) es un procedimiento para verificar si funciona el módulo
de un código fuente. Con esta técnica se comprueba si dos valores son iguales, si una
sentencia es verdadera, si dos objetos son del mismo tipo o si un objeto existe, o sea,
la idea es escribir casos de pruebas para todas las funciones y métodos, con el
objetivo de que se puedan identificar y corregir, lo más rápido posible, los errores
derivados al realizar alguna modificación en el código. También acelera el desarrollo
del software porque simplifica la integración y facilita el cambio. Existen diferentes
UnitTestingFrameworks para los lenguajes de programación:
Tabla 1.35 Diferentes UnitTestingFrameworks para los lenguajes de programación
Lenguajes de programación UnitTestingFrameworks

Smalltalk Sunit
Java Junit
Ruby Test::Unit
Python PyUnit
Perl TAP
36
PHP PHPUnit
.NET NUnit
1.5 Conclusiones del capítulo

Hasta el momento se puede concluir que del grupo de herramientas analizadas no
existen evidencias de un software queresuelva el problema planteado (optimizar la
expresión regular).
Dicho problema puede ser resuelto, con una extensión para la herramienta
ERAFPLN(1), que siga el modelo matemático de equivalencia entre expresiones
regulares y autómatas; y entre los diferentes autómatas, como se muestra en la Figura
1.4de John. E. Hopcroft(5), haciendo mayor énfasis en la optimización del autómata
finito determinista.
37
Capítulo 2. Descripción de la solución
2.1 Motivación
La propuesta de solución es la optimización de las expresiones regulares a partir del
autómata finito determinista. Se procedió a la construcción de una biblioteca de clases
denominada AutomatonLib y se adicionó ala herramienta informática ERAFPLN.
Esta extensión implementa un proceso elaborado por el autor de la investigación
(Figura 2.1), basado en el modelo matemático (Figura 1.4) de John. E. Hopcroft.
Figura 2.1Modelo de equivalencia entre expresiones regulares y autómatas; y entre los diferentes
autómatas, propuesto por el autor, para la solución del problema planteado
En este acápite se explicará la conversión de expresión regular a AFND- y AFND.
Para el análisis de la construcción de la extensión se verán los requisitos del software

ERAFPLN y se explicará la elaboración de los nuevos requisitos.
Además de una breve descripción de la biblioteca de clases implementada, se

explicarán los elementos que se tuvieron en cuenta para la implementación de los
métodos mencionados en la propuesta de solución.
2.2 Conversión de expresión regular a autómata finito no

determinista.
El algoritmo explicado en el epígrafe 1.2.4 no se implementó como plantea la teoría
debido a que su costo computacional sería elevado por el uso de la recursividad y un
recorrido excesivo.
Se analizaron los epígrafes 1.2.4 y 1.2.5 mediante pruebas en la transformación de

expresiones regulares a autómatas finitos, demostrando una serie de patrones que
sirvieron de base para la creación del algoritmo.
38
Este método se basa en las operaciones básicas de las expresiones regulares, sin
tener en cuenta las transiciones, como se describe en el epígrafe1.2.4.
En el siguiente algoritmo se explica con detalle, en cada caso, los pasos a seguir.
Algoritmo:
 De las operaciones básicas, la concatenación no varía.
 Cuando la expresión está encerrada con paréntesis, estos se eliminan.

Ejemplo: La expresión regular (ab) se transforma en ab.
Cuando el operador fundamental es la alternativa se divide la expresión en dos

subexpresiones formando dos estados finales o de aceptación (
 Figura 2.2), si la longitud de la cadena es 3, se obtiene un estado final (Figura
2.3). Si la alternativa se encuentra en una subexpresión(Figura 2.4), (q1, q2) =
ab|bc, esta se divide en dos expresiones ab y bc, creándose un nuevo estado
formado por los pares (q1, q2) = ab y (q1, q4) = cd. Después se buscan todos los
pares que comiencen con q2, para formar los que se inicien con el nuevo
estado (q4) y los estados finales de q2 y sus valores, en este caso sería (q4,
q3) = b, (Figura 2.5)
Figura 2.2 AFND equivalente de la expresión regular a|(a|bc)
Figura 2.3 AFND equivalente de la expresión regular a|b
39
Figura 2.4 AFND equivalente de la expresión regular a(ab|cd)b
Figura 2.5 AFND equivalente de dividir la subexpresión ab|cd, de la expresión regular a(ab|cd)b
(Figura 2.4)
 Si el operador básico es + (Figura 2.6) se realiza un auto enlace en el último

estado (Figura 2.7).
Figura 2.6 AFND equivalente de la expresión regular a+
Figura 2.7 AFND equivalente de la expresión regular a+
 Figura 2.8) En este caso de q1 se transita a q2 y q3, formando los pares (q0,
q2) = b y (q0, q3) = c, y (q0, q1) = a (Figura 2.9). Si de q1 no se transita a ningún
estado, entonces q0 adquiere la condición de aceptación (Figura 2.10).
40
Figura 2.8 AFND equivalente de la expresión regular a?(b|c)
Figura 2.9 AFND equivalente de la expresión regular a?(b|c)
Figura 2.10 AFND equivalente de la expresión regular a?
 Si el operador fundamental es * este contiene elementos comunes con los

operadores + y ?. En este caso del autómata (Figura 2.11) en q1 se realiza un
auto enlace con el valor a, como de q1 se transita a q2, se forma el par (q0, q2)
= b formando el autómata de la Figura 2.12. Si de q1 no se transita a ningún
estado, entonces q0 adquiere la condición de aceptación (Figura 2.10).
41
Figura 2.11AFND equivalente de la expresión regular a*b
Figura 2.12 AFND equivalente de la expresión regular a*b
Figura 2.13 AFND equivalente de la expresión a*
Un ejemplo que se puede detallar y analizar sería la siguiente expresión

a|(b(c|d*e)). Los pasos lo llamaremos iteraciones:
Iteración 1: El operador fundamental es el Ó lógico, el cual realiza la operación de

alternativa. Se divide la expresión en dos subexpresiones a y (b(c|d*e)).Formando
el autómata siguiente (Figura 2.14).
Figura 2.14 AFND equivalente de la expresión a|(b(c|d*))
Iteración 2: El operador fundamental de la subexpresión(b(c|d*e) en el par (q0, q2)

es el paréntesis, eliminándose este. Formando el autómata siguiente (Figura 2.15).
42
Figura 2.15 AFND equivalente de la expresión a|(b(c|d*e))
Iteración 3: La operación fundamental de la subexpresión b(c|d*e) es la

concatenación y se forma el autómata siguiente (Figura 2.16).
Iteración 4: El operador fundamental de la subexpresión(c|d*e) en el par (q3, q2) es

el paréntesis, eliminándose este se forma el autómata siguiente (Figura 2.17).
Iteración 5: El operador fundamental de la subexpresión c|d*e, que contiene el par

(q3, q2), es el Ó lógico el cual implica una alternativa. Se divide la expresión en dos
subexpresionesc y d*e. Se crea un nuevo estado debido a que desde q2 no se

transita a ningún estado. Formando el autómata siguiente (Figura 2.18).
43
Iteración 6: La operación fundamental de la subexpresión d*e es la concatenación, y

se forma el autómata siguiente (Figura 2.19).
Iteración 7 y final: La operación fundamental de la subexpresión d* es la repetición

(*). Se construye un auto enlace en q5 con valor a. Se buscan todos los nodos que
comiencen con q5 y se crean los que comiencen con q3 y terminen con los estados
finales y sus valores de los nodos buscados. Así se forma el autómata siguiente
(Figura 2.20).
44
2.3 Conversión de autómata finito no determinista con

transiciones vacías a autómata finito no determinista sin
transiciones vacías.
En la Conversión de AFND- a AFD se basa en el concepto de clausura- (Operador

estrella o Clausura de Kleene). En este caso no se aplica dicha clausura, sino que se
recorre el grafo por todos los caminos donde la transición sea  hasta llegar a una
cadena de texto o un estado de aceptación. Ejemplo: (Figura 1.15) siendo su
expresión regular ad|ad*.
Se comienza por el estado inicial {q0}:
Caminos () = {q1, q2}; de q1 a q6 y de q2 a q7 se encuentra la cadena a, formando
los pares (q0, q6) = a y (q0, q7) = a. (Tabla 2.1).
Tabla 2.1Tabla de transición del autómata (Figura 1.15)
a d Aceptación
q0 {q6, q7}
q7
q6
Se comienza por el estado {q7}:
Caminos () = {q4, q5, q18}; como q5 es un estado de aceptación q7 adquiere esta
característica, de q18 a q19se encuentra la cadena d formando el par (q7, q19) = d.

(Tabla 2.2).
45
a d Aceptación
q0 {q6, q7}
q7 q19 sí
q6
q19
Caminos () no tiene valor, pero de q6 a q3 se encuentra la cadena d y se forma el
par (q6, q3) = d. (Tabla 2.3).
a d Aceptación
q0 {q6, q7}
q7 q19 sí
q6 q3
q19
q3
Caminos () = {q4, q5, q18}; como q5 es un estado de aceptación q19 adquiere esta
característica, de q18 a q19 se encuentra la cadena d y constituye el par (q19, q19) =
d. (Tabla 2.4).
a d Aceptación
q0 {q6, q7}
q7 q19 sí
q6 q3
q19 q19 sí
q3
Caminos () = {q5}; como q5 es un estado de aceptación, q3 adquiere esta

característica. No encuentra ningún alfabeto. (Tabla 2.5).
46
a d Aceptación
q0 {q6, q7}
q7 q19 sí
q6 q3
q19 q19 sí
q3 sí
Se forma el autómata de la Figura 2.21
Figura 2.21 AFND equivalente de la expresión regular ad|ad*
2.4 Requisitos del software.

Una de las funcionalidades de la herramienta ERAFPLN es la obtención de la
expresión regular a partir de la representación del autómata finito, la expresión regular
puede llegar a ser bastante compleja según el tamaño del autómata que la origina, y
en la mayoría de los casos ésta no es óptima. Además, no contempla la posibilidad de
encontrar el autómata finito determinista equivalente de tamaño mínimo. Basado en el
proceso que se muestra en laFigura 2.1, se originaron los siguientes requisitosy se
adicionaron a ERAFPLN:
 Obtener el autómata finito no determinista con o sin transiciones vacías a partir

de la expresión regular.
 Convertir el autómata finito no determinista con transiciones  a autómata finito

no determinista sin transiciones .
 Transformar el autómata finito no determinista a autómata finito determinista.
 Minimizar el autómata finito determinista.
47
 Ofrecer opciones que permitan realizar el proceso descrito en la Figura 2.1y
poder guardar el autómata con la opción donde se quedó.
2.5 Descripción de la extensión implementada

La biblioteca de clase AutomatonLib permite obtener la equivalencia entre
expresiones regulares y autómatas; y entre los diferentes autómatas, además de la
optimización del autómata ampliando las opciones que realiza el software ERAFPLN.
El usuario puede introducir una expresión regular y obtener su autómata equivalente
que se muestra en un editor de forma muy sencilla y realizar, paso a paso, las
opciones de la Figura 2.1.
AutomatonLib, brinda también la opción de optimizar el autómata dibujado con el

objetivo de obtener una expresión regular mínima. Además se puede guardar el
autómata con la condición en la cual se encuentra, y después cargarlo y seguir en el
paso en el que se quedó.
2.6 Esquema general de la aplicación.

Originalmente la herramienta ERAFPLN contenía un solo proyecto. El mismo se dividió
en dos proyectos como se muestra en la Figura 2.22 con el objetivo de organizar y
hacerlo más extensible y adicionar la extensión AutomatonLib. En el proyecto
erafpln se encuentran los componentes de la interfaz que usan a AutomatonLib y
a erafpln.core. Este último contiene la clase AutomatonElement que a su vez
posee la obtención de la expresión regular. AutomatonLib usa a erafpln.core.
Figura 2.22Esquema general de la aplicación.
LaFigura 2.23 muestra el diseño de las clases principales y su relación entre ellas. La
clase principal AutomatonElementBase hereda de AutomatonElement,
aprovechando las características de éste AutomatonElementBase usa la clase
48
Conjunto como elemento para realizar un proceso. Heredan de
AutomatonElementBaselas clases AutomatonAFND y AutomatonAFD, y esta
última usa a AutomatonAFND, y como elementos para realizar cálculos a ElemTable
y TableAFDElem. La clase AutomatonHelper contiene los procesos necesarios
utilizados en la interfaz, y tiene como objetivo organizar y concentrar los métodos en
una sola clase, para que el usuario que utilice esta biblioteca de clases, no tenga
necesidad de instanciar los diferentes autómatas. (Figura 2.24).
Figura 2.23Diagrama general de clases.
Figura 2.24 Diagrama de la clase AutomatonHelper
2.7 Implementación del algoritmo de equivalencia de

expresión regular a AFND
La implementación de este algoritmo se basa en el método descrito en el epígrafe
2.2.En la Figura se muestra el diagrama de actividades de la clase AutomatonAFND.
El procedimiento de dividir una cadena de caracteres en subconjuntos se hereda de la
49
clase AutomatonElementBase. Esta acción divide la expresión regular según su
operador básico fundamental, guardando esta subexpresión en el objeto Conjunto.
La clase AutomatonAFND(Figura 2.26) crea los estados con su relación y valor según
el operador principal del Conjunto, formando el autómata finito no determinista, si
cada subexpresión se puede obtener o dividir en subexpresiones se comienza de
nuevo el procedimiento hasta que no existan más divisiones. Este proceso es
prácticamente el mismo para obtener el autómata finito no determinista con
transiciones vacías, varía en la forma de implementar las operaciones básicas.
Figura 2.25Diagrama de actividades donde se implementa el algoritmo de equivalencia de una expresión

regular a AFND
Figura 2.26 Diagrama de Clase denominada AutomatonAFND
50
2.8 Implementación del algoritmo de AFND- a AFND
La implementación de este algoritmo se basa en el método descrito en el epígrafe 2.3
y la Figura 2.27muestra el diagrama de actividades. Este procedimiento se encuentra
en la clase AutomatonAFND. Se comienza recibiendo un AFND- y se eliminan las
transiciones  formando un AFND equivalente.
Figura 2.27Diagrama de actividades donde se implementa el algoritmo de equivalencia de AFND- a

AFND
El constructor de la clase AutomatonAFND recibe un autómata (AutomatonElement)

este contiene una lista de estado (list_states) y otra con la relación entre estados
(list_links). Dentro del constructor se guarda una copia del autómata para que el
método denominado CrearAFND (Figura 2.28) recorra este autómata, creando el
AFND equivalente.
Figura 2.28 Código del método de transformación de AFND- a AFND
2.9 Implementación del algoritmo de AFND a AFD

1.2.5.2 y la Figura 2.29muestra el diagrama de actividades. Este procedimiento se
encuentra en la clase AutomatonAFD. Se comienza recibiendo un AFND y se
eliminan los estados innecesarios formando un AFD equivalente.
51
Figura 2.29Diagrama de actividades donde se implementa el algoritmo de equivalencia de AFND a AFD
El constructor de la clase AutomatonAFD recibe un autómata (AutomatonElement)

y se ejecuta el método linkNeedRemove eliminando las transiciones y los nodos que
no lleguen a ningún estado de aceptación (Figura 2.30). Después se ejecuta el método
Convert_AFD donde se utiliza la clase TableAFDElem(Figura 2.31) la cual guarda
los conjuntos de estados que contienen la misma cadena, siendo la unión de estos el
nuevo estado del AFD.
Figura 2.30 Estados innecesarios de un autómata
Figura 2.31 Diagrama de Clase denominada TableAFDElem
2.10 Implementación del algoritmo de optimización del AFD

1.2.6 y la Figura 2.32 muestra el diagrama de actividades. Este procedimiento se
encuentra en la clase AutomatonAFD. Se comienza recibiendo un AFD y se buscan
los estados equivalentes para formar un AFD equivalente mínimo.
52
Figura 2.32Diagrama de actividades donde se implementa el algoritmo de optimización del AFD
El constructor de la clase AutomatonAFD recibe un autómata (AutomatonElement)

y se ejecuta el método Optimizar realizando una búsqueda de los estados
equivalentes y utiliza la clase ElemTable(Figura 2.34) que guarda los posibles
equivalentes, para después procesar cuáles de ellos son los equivalentes y así poder
crear el AFD mínimo.
En la clase ElemTable el atributo inicio indica la relación entre las filas y columnas
de la tabla de equivalencia, y el atributo nodo, los pares que son posibles
equivalentes.
En el método Optimizar se obtienen dos listas de objetos. La primera guarda los

objetos de tipo ElemTable que representan los posibles equivalentes y el otro de tipo
AbstractLinkElement, los no equivalentes. Estos son recibidos por el método
53
findEquivalenteel cual devuelve los pares de nodos equivalentes, como se explica
a continuación (Figura 2.33:)
De la lista noequivalencia (los estados no equivalentes) se toma el primer valor y

se elimina (termina la iteración cuando no haya más elementos). Se buscan en la lista
posibles equivalentes (posibles estados equivalentes) aquellos ElemTable
que su atributo nodo sea igual al objeto de la lista no equivalencia, aplicando la
propiedad simétrica de una relación binaria de equivalencia. De existir, se elimina de la
lista posibles equivalentes, quedándose en la lista posiblesequivalentes,
los estados equivalentes.
Figura 2.33 Código del método findEquivalente de la clase AutomatonAFD
54
Figura 2.34 Diagrama de Clase denominada ElemTable
2.11 Cambios en el componente JFrameMain

En el paquete erafpln se utiliza el editor gráfico, dentro del componente
JFrameMain, para representar los autómatas finitos. A este componente se le
agregaron seis botones denominados: jButtonExReg, jButtonAFND, jAFND_N,
AFNDAction, AFDAction y OptimizeAFDAction(Figura 2.35) Según su función, es
el orden descrito en la Figura 2.1
Figura 2.35 Los botones señalados son jButtonExReg, jButtonAFND, jAFND_N,
AFNDAction, AFDAction y OptimizeAFDAction.
En la clase AutomatonHelper(Figura 2.24) contiene cinco métodos que son

utilizados en estos botones jButtonExReg, jButtonAFND, jAFND_N,
AFNDActionsiendo, además, atributos de JFrameMain mientras que los restantes
pertenecen a la clase MainToolAction (Figura 2.36).
55
Figura 2.36 Relación de clases en el paquete erafpln

La recopilación de información permitió capturar los nuevos requisitos y aplicarlos en
la herramienta ERAFPLN, mediante el modelo propuesto por el autor (Figura 2.1).
Fundamentalmente la optimización del AFD.
Mediante el análisis de los epígrafes 1.2.4 y 1.2.5a través de pruebas en la

transformación de expresiones regulares a autómatas finitos, se logró implementar un
algoritmo que convierte una expresión regular a un AFND sin transiciones vacías,
utilizando una serie de patrones establecidos.
Se modificó el método teórico del epígrafe 1.2.5.1 debido al costo computacional,

logrando crear a partir de un AFND- un AFND.
56
Debido a las modificaciones operadas en el diseño de la herramienta se logró
adicionar la extensión programada.
57
Capítulo 3. Experimentación, discusión y análisis de
los resultados
3.1 Motivación
En este capítulo se exponen los elementos que se tuvieron en cuenta para validar la
propuesta de solución. Se abordan las pruebas manuales y automáticas realizadas al
software. Además de un historial sobre el desarrollo de la extensión, con el cual se
demuestra la validez de la hipótesis planteada.
3.2 Historial de desarrollo

Esta extensión del software se realiza por interés del Grupo de Investigación ANUBIS
de la Facultad de Informática de la UMCC. Para medir el esfuerzo y calidad se utilizó
la herramienta ProcessDashboard versión 1.6.5 (21) (Figura 3.1). Se realizó un
historial que refleja la cantidad de días, horas, comentarios, cantidad de interrupciones
y faces de desarrollo (Tabla 3.1). (Figura 3.2). En un período de 188 días que contiene
1 180 horas laborables (De Lunes a Viernes un día laboral contiene 8 horas y los
Sábados 4 horas) se trabajó 299.7 horas con 419 interrupciones, representando el
25.40% de las horas laborables.
Figura 3.1 Herramienta ProcessDashboard versión 1.6.5
Tabla 3.1 Historial que refleja la cantidad de días, horas, comentarios, cantidad de interrupciones y faces
de desarrollo
Fase Comienzo Duración Interrupción

(Horas)
Planificación diciembre 16, 125.12 219  Elaboración de la
2009 documentación.
05:44:00 PM  Reuniones con el tutor.
 Búsqueda de materiales en
Internet.
 Estudio de los materiales.
Código febrero 20, 79.3 133  Se comenzó a codificar en C#.
2010  Se cambió códigos en C# a
09:06:26 PM Java.
 Se implementó código en
Java.
 Se realizó seudocódigos en
papel.
58
Diseño febrero 22, 16.72 8  Estudio y elaboración de
2010 diseño en papel.
02:02:48 PM  Diseño en NetBeans 6.1
 Diseño gráfico.
Revisar febrero 23, 70.63 33  Se revisó código en C# y se

Código 2010 corrigieron los errores.
02:02:26 PM  Se corrigieron los errores
provocados por el cambio de
C# a Java.
 Se revisó código en java y se
corrigieron los errores.
Revisar mayo 29, 0.48 0  Se revisó el diseño.
Diseño 2010
05:28:46 PM
Pruebas mayo 30, 7.45 26  Preparación de un grupo de
2010 pruebas
03:29:45 PM  Pruebas y sus análisis.
7.45
0.48 Planificación
70.63 125.12 Código
Diseño
79.3
16.72 Revisar Código
Revisar Diseño
Figura 3.2 Gráfica que representa la cantidad de horas por fases.
33 0 26 Planificación
8
Código
219 Diseño
133
Revisar Código
Revisar Diseño
Pruebas
Figura 3.3Gráfica que representa la cantidad de interrupciones por fases
3.3 Pruebas
AutomatonLib fue sometido a un experimento con datos reales, como parte del
ineludible proceso de pruebas por el que debe pasar todo software en sus fases
finales antes de ser liberado como versión definitiva.
El experimento realizado puede ser clasificado por el tiempo de duración como breve,
pues duró en todo el proceso de investigación aproximadamente siete horas. Por las
59
funciones de los métodos empíricos de investigación como verificador porque se
orienta hacia la comprobación de una hipótesis. En función de las condiciones para la
realización se clasifica como de laboratorio, debido a que los datos seleccionados
fueron escogidos teniendo en cuenta si existe o no optimización de los autómatas y
expresiones regulares.
La función básica del muestreo (herramienta de la investigación científica) es

determinar que parte de una realidad en estudio (población o universo) debe
examinarse con el fin de hacer inferencias sobre dicha población. Obtener una
muestra adecuada significa lograr una versión simplificada de la población, que
reproduzca de algún modo sus rasgos básicos.
Las expresiones regulares están estructuradas por un alfabeto finito donde no se

puede determinar la cantidad de repeticiones y combinaciones que se pueden formar.
Por tal motivo, se asume que el tamaño de la población es desconocido o infinito,
empleando el método de muestreo correspondiente para este caso.
Según (22) la ecuación pertinente es:
Figura 3.4Tamaño de la población infinito o desconocido
Donde:
 n es el tamaño de muestra.
 Z es el valor correspondiente a la distribución de Gauss 1,962 (nivel de

confianza 95%).
 p es prevalencia o proporción esperada del parámetro a evaluar (como se

desconoce se aplica la opción más desfavorable (p=0,5))
 q es 1 – p (en este caso 1 – 0.5 = 0.5)
 i es el error que se prevé cometer (precisión, en este caso se espera un 0.5%

de error).
Evaluando la ecuación se determina que la muestra significativa para la población

descrita es de 384 casos a verificar.
60
Como no se dispone de un grupo de expertos en este tema, se verificarán solo 41
casos, 21 por pruebas manuales y 20 por pruebas automáticas.
3.3.1 Pruebas manuales
Se realizó una serie de pruebas manuales (21 autómatas finitos) basado en la solución
propuesta (Figura 2.1) siguiendo las secuencias siguientes:
 Obtener AFD óptimo a partir de un AFD.
 Convertir de AFND a AFD.
 Seguimiento en todos los pasos de un grupo de expresiones regulares hasta

un AFD optimizado.
Estas pruebas se realizaron visualmente, o sea, en el caso de optimizar se realizó en

papel y después se verificó a través de la extensión realizada. Además de crearse
autómatas finitos deterministas en la herramienta ERAFPLN, de las bibliografías
consultadas y verificarlas.
En todos los casos de equivalencia entre autómatas y la optimización dan un

resultados de un 100% efectivo.
Ejemplos de la optimización del AFD,Figura 3.5(23).Se creó un AFD idéntico en la

herramienta ERAFPLN (Figura 3.6), y se optimizó, obteniendo el mismo autómata, lo
que cambia es el nombre de los estados (Figura 3.7).Este tipo de prueba se aplicó a
11 autómatas finitos deterministas.
61
Figura 3.5Proceso de Optimización de un AFD.
Figura 3.6 El AFD de la
Figura 3.5 creado en la herramienta ERAFPLN
62
Figura 3.7 El AFD óptimo de la Figura 3.6
A la expresión regular ab*|ase le aplicó el Modelo. Los autómatas dibujados en papel

y en la herramienta son idénticos, sólo varían en el nombre de los estados. Prueba
aplicada (Tabla 3.2).
Tabla 3.2 Tabla de prueba manual a la expresión regular ab*|a
Expresión Regular: ab*|a

Método Papel Herramienta Éxito
Expresión regular a AFND-λ (Figura 3.8) (Figura 3.9) 100%
AFND- λ a AFND (Figura 3.10) (Figura 3.11) 100%
AFND a AFD (Figura 3.12) (Figura 3.13) 100%
AFD óptimo (Figura 3.14) (Figura 3.15) 100%
Figura 3.8AFND-λ equivalente de la expresión regular ab*|a
63
Figura 3.9AFND-λ equivalente de la expresión regular ab*|a
Figura 3.10AFND equivalente de la expresión regular ab*|a
Figura 3.11AFND equivalente de la expresión regular ab*|a
64
Figura 3.12AFD equivalente de la expresión regular ab*|a
Figura 3.13AFD equivalente de la expresión regular ab*|a
Figura 3.14AFD equivalente óptimo de la expresión regular ab*|a
65
Figura 3.15AFD equivalente óptimo de la expresión regular ab*|a
3.3.2 Pruebas Automáticas
Se realizaron pruebas automáticas a 20 expresiones regulares (1.4) en JUnitTest(Ver

anexo 4)con el objetivo de optimizar una expresión regular. Obteniendo los siguientes
resultados.
Tabla 3.3: La columna denominada ExReg contiene las expresiones regulares a

optimizar. El parámetro nombrado Óptimo es el resultado esperado. El parámetro
Nulo indica que pasa por el AFND-λ y el No Nulo por el AFND. La casilla, en la
columna Exitosas, que esté coloreada y marcada significa que la expresión regular
resultante está minimizada, pero no es la más óptima.
Si se analiza la Tabla 3.3 se obtuvo un promedio de un 70% de casos exitosos (Figura

3.16).
Dentro de los casos exitosos, se encuentran expresiones regulares que con respecto
al original son mínimas, pero no son las más óptimas.
Se demuestra que aunque la velocidad de ejecución a partir del AFND-λ es lenta

(Figura 3.17), con respecto al AFND, genera expresiones regulares más óptimas.
Para verificar aún más la efectividad de estas pruebas, se realizaron pruebas

manuales, además de comprobar la sintaxis de la expresión resultante mediante
pruebas de texto.
Tabla 3.3Pruebas automáticas a un grupo de 20 expresiones regulares
JUnitTest
Resultado
Pruebas ExReg Óptimo Nulo No Nulo Exitosas
1 ab*|ab+|ab ab* ab* x
2 (ab)(ab)* (ab)+ (ab)+ x
3 a|a|a|a+ a+ a+ x
4 b?b* b* b* x
66
5 a|ab? ab? ((ab)|a)
6 abc|abc(a|b)*|abc(a|b)? abc(a|b)* abc(a|b)* x
7 (a|b)|a?|b? (a|b) ((a|b)) x
8 (casa)|(casa)?|(casa)* (casa)* ((cas(acas)*a)) x
9 (ab)?cd|cd (ab)?cd ((abcd)|(cd)) (((cd))|(abcd))
10 (ab*|ab+)?d|(ab+)?d|(ab*)?d (ab*)?d ((ab*d)|(d) x
11 (ab)?d|d (ab)?d ((abd)|d) ((d)|(abd))
12 (ab*|ab+|ab)*|(ab)? (ab*)* ((a(a|b)*)) ((a+b((a+b)|b)*)) x
13 a.b a.b a.b x
14 [abc] [abc] [abc] x
15 [0-9]* [0-9]* ([0-9]*)
16 [0-9]+ [0-9]+ ([0-9])+
17 (a|b)*d (a|b)*d (a|b)*d x
18 aaaaa* aaaa+ aaaa+ x
19 a?a+ a+ a+ x
20 amigo|ami ami(go)? ((amigo)|(ami))
45.546 34.421
segundos segundos 14
14
Existosas
Fallidas
Figura 3.16 Pruebas realizadas
67
45.546
34.421
Nulo No Nulo
Figura 3.17 Velocidad de ejecución

Mediante el empleo de la herramienta ProcessDashboard se obtuvo un estimado del
esfuerzo, además de organizar y controlar el trabajo a nivel personal, su significación
radica en determinar la correspondencia entre el esfuerzo físico y mental empleado en
un proyecto y el incremento de la calidad en su elaboración.
Las pruebas abordadas, mediante las técnicas manuales (comprobación visual) y

automáticas, permitieron comprobar y validar el funcionamiento de la extensión
desarrollada.
A través de las pruebas manuales se demostró la efectividad de transformación de

equivalencia y optimización de los autómatas finitos (100%).
También se demostró una efectividad de un 70% en las pruebas automáticas para

optimizar la expresión regular a través de los autómatas. Esto se debe a que el paso
de transformación de un autómata finito a expresión regular no es el más óptimo
porque no decide cuál es el camino más adecuado a recorrer en el grafo.
68
Conclusiones generales
Mediante los conocimientos teóricos adquiridos asociados a las expresiones regulares
y autómatas, se elaboró un método basado en el modelo matemático para la solución
del problema.
Del grupo de herramientas analizadas se demostró la inexistencia de un software que

resolviera el problema planteado a través de la optimización del autómata finito
equivalente.
Se logró implementar un algoritmo que convierte una expresión regular a un AFND sin
transiciones vacías, a través de una serie de patrones establecidos.
Debido al costo computacional del método teórico para convertir un AFND-λ a un AFD,
fue necesario modificarlo para obtener de un AFND-λ un AFND.
A través de las pruebas manuales se demostró la efectividad al cien por ciento, de la

transformación de equivalencia y optimización de los autómatas finitos.
También se demostró una efectividad de un 70% en las pruebas automáticas para

optimizar la expresión regular a través de los autómatas. Esto se debe a que el paso
de transformación de un autómata finito a expresión regular no es el más óptimo
porque no decide cuál es el camino más adecuado a recorrer en el grafo.
69
Recomendaciones
Investigar cómo optimizar la transformación de un autómata finito a su expresión
regular equivalente.
Encontrar otra vía de optimización de la expresión regular basada en sus propiedades

algebraicas.
Implementar la comparación de equivalencia de dos autómatas.
70
Referencias Bibliográficas
1. Pérez Martínez, Abel. ERAFPLN. 2009.
2. PÉREZ, NALLY CAMPO. INTRODUCCIÓN A LA TEORÍA DE CONJUNTOS. [En

línea] http://www.e-socrates.org/mod/resource/view.php?id=4398.
3. REAL ACADEMIA ESPAÑOLA. [En línea] http://buscon.rae.es/draeI/.
4. Brena, Ramón.AUTOMATAS Y LENGUAJES. Monterrey : s.n., 2003.
5. Hopcroft, John E.Introducion to automata theory, languages, and computation. s.l. :

Addison-Wesley, 2001.
6. Lawson, M. V. Finite automata.

http://www.ma.hw.ac.uk/~markl/preprints/Lawson.pdf. [En línea]
7. RegExlib. [En línea] http://regexlib.com/default.aspx.
8. Javascript Regular Expression Validator. [En línea]

http://tools.netshiftmedia.com/regexlibrary/.
9. RegexPal. [En línea] http://regexpal.com/.
10. metriplica.com, Grupo. ¡Prueba tus Expresiones Regulares!

http://www.metriplica.com/4_4_herramientas.asp. 2008.
11. Regular Expression Tool. [En línea]

http://erik.eae.net/playground/regexp/regexp.html.
12. Regexp Editor. [En línea] http://myregexp.com/.
13. Rad Software Regular Expression Designer 1.4.7528.27091. [En línea]

http://www.radsoftware.com.au/?from=RegexDesigner.
14. Visual REGEXP 3,0. [En línea] http://www.softpedia.com/get/Programming/Other-

Programming-Files/Visual-REGEXP.shtml.
15. Regulazy v1.0.3.0 (Beta). [En línea] http://tools.osherove.com/Default.aspx.
16. Regular Expression Workbench. [En línea] EricGu@Microsoft.Com.
71
17. Sells, Chris and Weinhardt, Michael.RegexDesigner v1.0.2727. [En línea]
http://www.sellsbrothers.com/tools/.
18. Visual Automata Simulator. [En línea] http://www.cs.usfca.edu/~jbovet/.
19. Acosta, Francisco Ríos. SP-PS1. [En línea] http://www.friosa.com.mx.
20. RegexBuddy3. [En línea] http://www.regexbuddy.com/.
21. The Software Process Dashboard Initiative. [En línea]

http://www.processdash.com/.
22. METODOLOGÍA DE MUESTREO. [En línea]

http://www.hsa.es/id/investigacion/uai/uai_docs/muestreo/muestreo.htm.
23. Modelos Abstractos de Cómputo I. [En línea]

http://www.sc.ehu.es/jiwnagom/MAC1/MAC-archivos/Tema2-parte3.pdf.
72
Anexo 3
Ventana delSP-PS1 que muestra un AFND-λ

Anexo 4
Pruebas automáticas (JUnitTest) del programa NetBeans
View publication stats

InformeTesis-YeinielAlfonso-Optimizacion ER - AFN

Cargado por

Copyright:

Formatos disponibles

InformeTesis-YeinielAlfonso-Optimizacion ER - AFN

Cargado por

Información del documento

Derechos de autor

Formatos disponibles

Compartir este documento

Compartir o incrustar documentos

Opciones para compartir

¿Le pareció útil este documento?

¿Este contenido es inapropiado?

Copyright:

Formatos disponibles

InformeTesis-YeinielAlfonso-Optimizacion ER - AFN

Cargado por

Copyright:

Formatos disponibles

See discussions, stats, and author profiles for this publication at: https://www.researchgate.

Optimización de expresiones regulares a partir del autómata ﬁnito

Thesis · July 2010

Yeiniel Alfonso Abel Pérez

SEE PROFILE SEE PROFILE

The user has requested enhancement of the downloaded file.

Optimización de expresiones regulares a partir del autómata finito

Trabajo de Diploma en opción al Título de Ingeniería Informática

Autor: Yeiniel Alfonso Martínez.

Tutor: Ing. Abel Pérez Martínez.

Consultante: M.Sc. Antonio Fernández Orquín.

“La ignorancia humana no permanece detrás de la ciencia, crece

Stanislaw Jerzy Lec

A mis padres que son la razón de mi ser.

A mis amigos, en especial a: Yamila, Gisela, Josval, Dianelysy Antonio

A quienes estuvieron atento y pendiente del proceso de mi tesis.

A quienes contribuyeron en el desarrollo del trabajo.

Firma del Autor Firma del Tutor

Nombre y apellidos: Abel Pérez Martínez

Centro de trabajo: Facultad de Informática, Universidad de Matanzas “Camilo Cienfuegos”

Organismo al que pertenece: Ministerio de Educación Superior – MES.

Cargo que ocupa: Profesor adiestrado.

Especialidad de la que es graduado: Ingeniería Informática, Facultad de Informática de la

Categoría docente o investigativa: Instructor recién graduado.

Datos de la tesis y el diplomante

Nombre y apellidos: Yeiniel Alfonso Martínez

Centro de estudio: Facultad de Informática, Universidad de Matanzas "Camilo Cienfuegos"

Título de la Tesis: Optimización de expresiones regulares a partir del autómata finto.

Opinión sobre el trabajo:

Tenacidad y espíritu de investigación. Absoluta independencia en el desarrollo de su investigación

Capítulo 1. Fundamentación teórica y tendencias tecnológicas ....................................... 4

1.1 Motivación ..................................................................................................................... 4

1.2 Fundamento científico o marco teórico ......................................................................... 4

1.3 Antecedentes del trabajo y estado del arte ................................................................. 33

1.4 Ingeniería de software. UnitTesting............................................................................. 36

1.5 Conclusiones del capítulo ........................................................................................... 37

Capítulo 2. Descripción de la solución ............................................................................... 38

2.1 Motivación ................................................................................................................... 38

2.2 Conversión de expresión regular a autómata finito no determinista. .......................... 38

2.3 Conversión de autómata finito no determinista con transiciones vacías a autómata

2.4 Requisitos del software. .............................................................................................. 47

2.5 Descripción de la extensión implementada ................................................................. 48

2.6 Esquema general de la aplicación. ............................................................................. 48

2.7 Implementación del algoritmo de equivalencia de expresión regular a AFND ........... 49

2.8 Implementación del algoritmo de AFND- a AFND .................................................... 51

2.9 Implementación del algoritmo de AFND a AFD .......................................................... 51

2.10 Implementación del algoritmo de optimización del AFD ............................................. 52

2.11 Cambios en el componente JFrameMain ................................................................... 55

2.12 Conclusiones del capítulo ........................................................................................... 56

3.1 Motivación ................................................................................................................... 58

3.2 Historial de desarrollo .................................................................................................. 58

3.3 Pruebas ....................................................................................................................... 59

3.4 Conclusiones del capítulo ........................................................................................... 68

Conclusiones generales ........................................................................................................... 69

Referencias Bibliográficas ....................................................................................................... 71

Las Matemáticas lo enfocan en el estudio de los problemas o el proceso de encontrar

En Economía es la forma neoclásica de la racionalidad, o sea, se trata de elegir la

En las Letras, optimizar sería lograr construcciones sintácticas y semánticas que

De ahí que la optimización se pueda definir como la minimización de algo malo, o la

Durante la ingeniería se estudian, como parte del tema de Compiladores, las

 Ninguna o más repeticiones (): a indica que acepta ninguna o más