Teoría de Autómatas y Lenguajes Formales. Leopoldo Altamirano, Miguel Arias, Jesús González, Eduardo Morales, Gustavo Rodríguez

Teoría de Autómatas y Lenguajes Formales Leopoldo Altamirano, Miguel Arias, Jesús González, Eduardo Morales, Gustavo Rodríguez

Objetivo General Proporcionar al estudiante los fundamentos de la teoría de autómatas así como los de lenguajes formales. También se incluye una introducción a las máquinas de Turing. Temario 1. Introducción 2. Autómatas Finitos 3. Expresiones Regulares y Lenguajes 4. Propiedades de los Lenguajes Regulares 5. Gramáticas Libres de Contexto y Lenguajes 6. Autómata de Pila 7. Propiedades de los Lenguajes Libres de Contexto 8. Introducción a las Máquinas de Turing Modalidad del Proceso de Enseñanza El material del curso es impartido por el instructor con resolución de algunos problemas en clase. También se asignarn tareas prácticas a los estudiantes cuya solución será en algunos casos discutida en clase. Se tendrán sesiones de asesoría con los asistentes de curso. Horario: Clase: Martes 9:30 a 12:00 Jueves 9:30 a 12:00 Asosoria: Martes 12:00 a 13:00 Jueves 12:00 a 13:00 i

Evaluación: Tareas 1/3 Examenes Parciales (2) 2/3 1 er Parcial 19-Junio-2008 2 o Parcial 15-Julio-2008 Calendarización. Sem. Fecha Tema 1 27 y 29 mayo Introducción 2 3 y 5 junio Autómatas Finitos 3 10 y 12 junio Expresiones Regulares y Lenguajes 4 17 y 19 junio Props. Lenguajes Regulares (Primer examen) 5 24 y 26 junio Gramáticas y Lenguajes Libres de Contexto 6 1 y 3 julio Pushdown Automata 7 8 y 10 julio Props. Lenguajes Libres de Contexto 8 15 y 17 julio Intro. Máquina de Turing (Segundo examen) ii

Referencias 1. John E. Hopcroft, Rajeev Motwani and Jeffrey D. Ullman (2001). Automata Theory, Language and Computation. Addison-Wesley Publishing. 2. Michael Sipser (1997). Introduction to the Theory of Computation. PWS publishing company. iii

Capítulo 1 Introducción 1.1 Teoría de Autómatas Estudio de dispositivos o máquinas de cómputo abstractas Turing en los 30 s estudió una máquina abstracta con las capacidades de las de hoy (en lo que podían calcular) La meta de Turing era describir la frontera entre lo que una máquina podía hacer y lo que no, su conclusión aplica no solo a las máquinas de Turing, sino a las máquinas actuales En los 40 s y 50 s se estudiaron los Autómatas Finitos Finales de los 50 s, N. Chomsky inicia el estudio formal de las gramáticas En 1969 S. Cook extiende el trabajo de Turing para estudiar lo que se podía y no calcular (compute), y lo que se podía resolver eficientemente o no (NP-duros). 1.2 Introducción a Pruebas Formales Para qué pruebas? 1

Hacer hipótesis inductivas sobre partes de nuestros programas (iteración o recursión) Hipótesis consistente con la iteración o recursión Entender como trabaja un programa correcto es esencialmente lo mismo que la prueba de teoremas por inducción Pruebas deductivas (secuencia de pasos justificados) Pruebas inductivas (pruebas recursivas de un estatuto parametrizado que se usa a sí mismo con valores más bajos del parámetro) 1.2.1 Pruebas Deductivas Secuencia de enunciados cuya verdad nos lleva de un enunciado inicil (hipótesis) a una conclusión. Son del tipo If H Then C. Por ejemplo, probar que: Si x 4 Entonces 2 x x 2. La idea general es probar que se cumple para 4 y probar que mientras x crece, el lado izquierdo duplica su valor con cada incremento, mientras que el lado derecho crece a una razón de ( x+1 x )2. También existen otras pruebas como pruebas por contradicción, por contraejemplos y de conjuntos, pero nos vamos a enfocar en las pruebas por inducción. 1.2.2 Pruebas por Inducción Para objetos definidos recursivamente La mayoría maneja enteros, pero en autómatas se trabaja con árboles y expresiones de varios tipos (expresiones regulares) 2

1.2.2.1 Inducciones estructurales Probar el enunciado S(X) respecto a una familia de objetos X (i.e., enteros, árboles) en dos partes: 1. Base: Probar directamente para uno o varios valores pequeños de X. 2. Paso de Inducción: Asumir S(Y ) para Y más pequeña que X; probar S(X) a partir de lo que se asumió. Un árbol binario con n hojas tiene 2n 1 nodos. Formalmente, S(T): Si T es un árbol binario con n hojas, entonces T tiene 2n 1 nodos. Inducción respecto al tamaño = número de nodos de T. Base: Si T tiene 1 hoja, se trata de un árbol de un nodo. 1 = 2 1 1, está bien. Inducción: Asumir S(U) para árboles con menos nodos que T. En particular, asumir para los sub-árboles de T: T debe consistir de una raíz más dos subárboles U y V. Si U y V tienen u y v hojas, respectivamente, y T tiene t hojas, entonces u + v = t. Por la hipótesis de inducción, U y V tienen 2u 1 y 2v 1 nodos, respectivamente. Entonces T tiene 1 + (2u 1) + (2v 1) nodos. = 2(u + v) 1. = 2t 1, probando con el paso de inducción. Frecuentemente el enunciado que tenemos que probar es de la forma X si y sólo si Y. Esto requiere hacer dos cosas: 3

1. Probar la parte-si: Asumir Y y probar X. 2. Probar la parte-si-y-sólo-si: Asumir X y probar Y. 1.2.3 Equivalencia de Conjuntos Muchos hechos importantes en la teoría del lenguaje son de la forma de dos conjuntos de cadenas, descritas de dos maneras diferentes y que realmente son el mismo conjunto. Para probar que los conjuntos S y T son los mismos, probar: x S si y sólo si x T. Esto es: Asumir que x S; probar que x T. Asumir que x T; probar que x S. Ejemplo: Probar que 1 + 3 + 5 +... + (2n 1) = n 2. Base: P(1) 1 = 1 2 Inducción: Suponemos P(k) : 1 + 3 + 5 +... + (2k 1) = k 2. Para probar que P(k + 1) es verdadera: P(k + 1) 1 + 3 + 5 +... + [2(k + 1) 1] = (k + 1) 2 y esto se puede escribir como: 1 + 3 + 5 +... + (2k 1) + [2(k + 1) 1] = (k + 1) 2 y la parte izquierda es igual a: k 2 + [2(k + 1) 1] = k 2 + 2k + 1 = (k + 1) 2 por lo tanto, 1 + 3 + 5 +... + [2(k + 1) 1] = (k + 1) 2 esto verifica P(k + 1) y prueba que la ecuación es verdadera para cualquier entero positivo n. 4

Ejemplo: Probar que 1 + 2 + 2 2 +... + 2 n = 2 n+1 1 para toda n 1. Base: P(1) 1 + 2 = 2 1+1 1, 3 = 2 2 1, lo cual es verdadero. Inducción: Asumimos que P(k) : 1+2+2 2 +...+2 k = 2 k+1 1, es verdadero e intentamos probar que P(k + 1) también lo es: P(k + 1) : 1 + 2 + 2 2 +... + 2 k+1 = 2 (k+1)+1 1 Rescribiendo la ecuación anterior tenemos: 1 + 2 + 2 2 +... + 2 k + 2 k+1 = 2 k+1 1 + 2 k+1 Por lo tanto: = 2(2 k+1 ) 1 = 2 k+1+1 1 1 + 2 + 2 2 +... + 2 k+1 = 2 (k+1)+1 1 Ejercicio: Probar que x 0 + x 1 + x 2 +... + x n = (x n+1 1)/(x 1) Base: P(1) : x 0 +x 1 = x+1, y (x 2 1)/(x 1) = ((x+1)(x 1))/(x 1) = (x + 1), por lo tanto, la base si se cumple. Inducción: Asumimos que P(k) : x 0 +x 1 +x 2 +...+x k = (x k+1 1)/(x 1) se cumple. Probamos que también P(k + 1) se cumple: P(k + 1) : x 0 + x 1 + x 2 +... + x k + x k+1 = xk+1+1 1 (x 1) Demostramos que el lado izquierdo es igual al lado derecho: x k+1 1 + x k+1 = (xk+1 1)+(x 1)(x k+1 ) (x 1) (x 1) = xk+2 1 x 1 Ejercicio: Probar que n 2 > 3n para n 4. Base: P(4) : 4 2 > 3(4) ó 16 > 12, lo cual es cierto Inducción: Asumimos P(k) : k 2 > 3k para k > 4 y tratamos de probar que P(k + 1) : (k + 1) 2 > 3(k + 1) 5

(k + 1) 2 = k 2 + 2k + 1 > 3k + 2k + 1 (por la Hipótesis de Inducción) > 3k + 2(4) + 1 (porque k > 4) > 3k + 3 > 3(k + 1). Ejercicios a resolver en clase: 1. 2 + 6 + 10 +... + (4n 2) = 2n 2 2. 1 + 5 + 9 +... + (4n 3) = n(2n 1) 3. 1 + 3 + 6 +... + n(n + 1)/2 = n(n+1)(n+2) 6 4. 5 + 10 + 15 +... + 5n = 5n(n+1) 2 5. 1 2 + 2 2 +... + n 2 = n(n+1)(2n+1) 6 6. 1 3 + 2 3 +... + n 3 = n2 (n+1) 2 7. n 2 > n + 1 para n > 2 Ejercicios de tarea para la siguiente clase: 1. 2 + 4 + 6 +... + 2n = n(n + 1) 2. 1 2 + 3 2 +... + (2n 1) 2 = n(2n 1)(2n+1) 3 3. Probar que 2 n < n!, para n 4 4 1.3 Teoría de Autómatas 1.3.1 Motivación Los autómatas finitos se utilizan como modelos para: 6

Software para diseñar circuitos digitales Analizador léxico de un compilador Buscar palabras clave en un archivo ó en el web Software para verificar sistemas de estados finitos, como protocolos de comunicaciones 1.4 Conceptos de Teoría de Autómatas Alfabeto = conjunto finito de símbolos (Σ) Σ = {0, 1}, alfabeto binario. Σ = {a, b, c, d,..., z}, alfabeto del abecedario en minúsculas. Conjunto de los caracteres ASCII. Cadena = secuencia finita de símbolos elegidos de un alfabeto. 01101 abracadabra La cadena vacía se denota como: ǫ, Todas las cadenas de un alfabeto Σ de longitud k se denotan como Σ k. E.g., Σ 0 = {ǫ}, si Σ = {0, 1}, entonces, Σ 1 = {0, 1}, Σ 2 = {00, 01, 10, 11}, etc. El conjunto de todas las cadenas de un alfabeto Σ se denota como Σ. Σ = Σ 0 Σ 1 Σ 2.... Sin la cadena vacía: Σ +. Por lo que: Σ = Σ 0 Σ +. Lenguaje = conjunto de cadenas elegidas de algún alfabeto. Nota: El lenguaje puede ser infinito, pero existe algún conjunto finito de símbolos de los cuales se componen todas sus cadenas. El conjunto de todas las cadenas binarias que consisten de algún número de 0 s seguidos por un número igual de 1 s; esto es: {ǫ, 01, 0011, 000111,...}. 7

C ( el conjunto de programas compilables en C). Español. Una manera importante de describir ciertos lenguajes simples, pero altamente útiles es la llamada lenguajes regulares. Un grafo con un número finito de nodos, llamados estados. Los arcos se etiquetan con uno o más símbolos de algún alfabeto. Un estado es designado como el estado de comienzo ó estado inicial. Algunos estados son estados finales o estados de aceptación. El lenguaje de los AF (Autómata Finito) es el conjunto de cadenas que etiquetan rutas que van desde el estado inicial a algún estado de aceptación. Abajo, el AF explora documentos HTML, busca una lista de lo que podrían ser los pares de título-autor, quizás en una lista de lectura para algún curso de literatura. 8

Acepta cuando encuentra el final de un elemento de la lista. En una aplicación, las cadenas que casan con el título (antes de by ) y autor (después) serían almacenadas en una tabla de pares de títuloautor que son acumulados. 1.4.1 Ejemplos de Autómatas Finitos Autómata Finito para modelar un switch de encendido/apagado: Autómata Finito para reconocer la cadena hola : 1.4.2 Representaciones Estructurales Gramáticas: Modelos útiles para diseñar SW que procesa datos con una estructura recursiva Un parser de un compilador Expresiones aritméticas, condicionales, etc. Una regla: E E + E Expresiones Regulares: Denotan la estructura de los datos, especialmente cadenas de texto Autómatas pueden describir lo mismo que puede describir un autómata finito 9

El estilo difiere del de las gramáticas Estilo de expresiones regulares de UNIX [A Z][a z] [ ][A Z][A Z] Representa palabras que inician con mayúscula seguidas de un espacio y dos letras mayúsculas (e.g., Ithaca NY) No incluye ciudades con nombres compuestos ([A Z][a z] [ ]) [A Z][A Z] 1.5 Autómatas y Complejidad Los autómatas son esenciales para el estudio de los límites de la computación Qué puede hacer una computadora? Decidibilidad (decidability) Problema decidible Qué puede hacer una computadora eficientemente? Intractabilidad (intractability) Polinomial vs Exponencial Ejercicios en clase: 1. Modelar un AF para cadenas de 0 s y 1 s que terminen siempre en 010. 2. Modelar un AF para las cadenas que terminan con tres 0 s consecutivos. 3. Modelar un AF para todas las cadenas en donde cada bloque de 5 caracteres consecutivos contengan al menos dos 0 s. Ejercicios de tarea para la siguiente clase: 1. Modelar un AF donde el décimo símbolo de derecha a izquierda sea un 1. 10

2. Describir con palabras los conjuntos aceptados por los autómatas finitos de los diagramas de transiciones de las siguientes figuras: 11

Capítulo 2 Introducción a los Autómatas Autómata: Conjunto de estados + Control Cambio de estados en respuesta a una entrada. Tipo de Control: Determinístico: Para cada entrada, hay sólo un estado al que el autómata puede ir desde el estado en que se encuentre. No determinístico: Un autómata finito es no-determinístico cuando se permite que el AF tenga 0 o más estados siguientes para cada par estado-entrada. Si añadimos la propiedad de no-determinismo, no añadimos poder al autómata. Osea que no podemos definir ningún lenguaje que no se pueda definir con el autómata determinístico. Con la propiedad de no-determinismo se agrega eficiencia al describir una aplicación: Permite programar soluciones en un lenguaje de más alto nivel Hay un algoritmo para compilar un N-DFA en un DFA y poder ser ejecutado en una computadora convencional 12

Extensión del N-DFA para hacer saltos de un estado a otro espontáneamente, con la cadena vacía (ǫ) como entrada: ǫn-dfa. Estos autómatas también aceptan lenguajes regulares. Ejemplo: Compra con dinero-electrónico. El cliente utiliza un archivo (envío por internet) para pagar al comerciante. El comerciante al recibir el archivo pide al banco que le transfieran el dinero. Tarea: Leer la sección 2.1.1 2.1.5 del libro 2.1 Definición formal de un Autómata Finito Determinístico Un AF se representa como la 5-tupla: A = (Q, Σ, δ, q 0, F). Donde: 1. Q es un conjunto finito de estados. 2. Σ es un alfabeto de símbolos de entrada. 3. q 0 es el estado inicial/de comienzo. 13

4. F representa cero o más estados finales/de aceptación. 5. δ es una función de transición. Esta función: Toma un estado y un símbolo de entrada como argumentos. Regresa un estado. Una regla de δ se escribe como δ(q, a) = p, donde q y p son estados, y a es un símbolo de entrada. Intuitivamente: Si el AF está en un estado q, y recibe una entrada a, entonces el AF va al estado p (nota: q = p OK). Ejemplo: Un Autómata A que acepta L = {x01y x, y {0, 1} } El DFA acepta cadenas que tienen 01 en alguna parte de la cadena El lenguaje del DFA es el conjunto de cadenas que acepta {w w tiene la forma x01y para algunas cadenas x y y que consisten sólo de 0 s y 1 s. El Autómata A = (q 0, q 1, q 2, 0, 1, δ, q 0, q 1 ) Autómata representado con una tabla de transiciones: 0 1 q 0 q 2 q 0 q 1 q 1 q 1 q 2 q 2 q 1 Autómata representado con un diagrama de transiciones: Convenciones 14

Se utilizan algunas convenciones para evitar mencionar el tipo de cada nombre, para esto utilizamos las siguientes reglas: Los símbolos de entrada son a, b, etc., o dígitos. Las cadenas de símbolos de entrada son u, v,..., z. Los estados son q, p, etc. Diagrama de Transiciones Un AF se puede representar por medio de un grafo; los nodos representan estados; un arco de p a q se etiqueta con el conjunto de símbolos de entrada a tal que δ(q, a) = p. No hay arco si a no existe. El estado de inicio se indica con la palabra start con una flecha. Los estados de aceptación tienen doble círculo. Funciones de transición extendidas (ˆδ) Intuitivamente, un FA acepta una cadena w = a 1 a 2... a n si hay una ruta en el diagrama de transiciones que: 1. Empieza en el estado de inicio, 2. Termina en un estado de aceptación, y 3. Tiene una secuencia de etiquetas a 1, a 2,...,a n. 15

Ejemplo: El siguiente AF acepta la cadena 01101: Formalmente, extendemos la función de transición δ a ˆδ(q, w), donde w puede ser cualquier cadena de símbolos de entrada: Base: ˆδ(q, ǫ) = q (i.e., nos quedamos en el mismo lugar si no recibimos una entrada). Inducción: ˆδ(q, w) = δ(ˆδ(q, x), a), donde x es una cadena, y a es un solo símbolo (i.e., ver a dónde va el AF con x, luego buscar la transición para el último símbolo a partir de ese estado). Hecho importante con una prueba inductiva directa: ˆδ realmente representa rutas. Esto es, si w = a 1 a 2...a n, y δ(p i, a i ) = p i+1, i = 0, 1,..., n 1, entonces ˆδ(p 0, w) = p n. Aceptación de Cadenas: Un AF A = (Q, Σ, δ, q 0, F) acepta la cadena w si ˆδ(p 0, w) está en F. Lenguaje de un AF: Un AF acepta el lenguaje L(A) = w ˆδ(p0, w) F. Algunas confusiones frecuentes Una gran fuente de confusión cuando se trabaja con autómatas (o matemáticas en general) son los errores de tipo : Ejemplo: No confundir A, un FA, i.e., un programa, con L(A), el cual es del tipo conjunto de cadenas. Ejemplo: El estado de inicio q 0 es del tipo estado pero los estados de aceptación F son del tipo conjunto de estados. Ejemplo engañoso: Es a un símbolo o una cadena de longitud 1? Respuesta: Depende del contexto, i.e., se usa en δ(q, a), donde es un símbolo, o en ˆδ(q, a), donde es una cadena? 16

Ejemplo: DFA que acepta todas y sólo las cadenas que tienen un número par de 0 s y también un número par de 1 s Representación tabular del autómata anterior: 0 1 q 0 q 2 q 1 q 1 q 3 q 0 q 2 q 0 q 3 q 3 q 1 q 2 Ejemplo: Problema 2.2.1.a Ejemplo: Problema 2.2.4.a 17

2.2 Autómata Finito No-Determinístico Un autómata finito es no-determinístico cuando se permite que el AF tenga 0 o más estados siguientes para cada par estado-entrada: En el ejemplo anterior, se puede apreciar que de q 0 se puede ir a q 0 ó a q 1 con la entrada 0, y esto hace al AF ser no-determinista. Un NFA puede estar en varios estados a la vez o se puede ver que adivina a qué estado ir. Por ejemplo, el siguiente autómata acepta todas las cadenas que terminan en 01: Lo que pasa al procesar como entrada a 00101 es: Un NFA es una herramienta importante para diseñar procesadores de 18

cadenas, e.g., grep, analizadores léxicos, etc. Es fácil diseñar NFAs que encuentren secuencias de palabras en texto. NFA: Formalmente, un NFA es una quíntupla A = (Q, Σ, δ, q 0, F), donde todo es un DFA, pero δ(q, a) nos regresa un conjunto de estados en lugar de un solo estado. De hecho puede ser vacío, tener un solo estado o tener más estados. Un NFA acepta, al igual que un DFA, lenguajes regulares Por ejemplo, para el NFA que acepta cadenas que acaban en 01 su función de transición δ es: 0 1 q 0 {q 0, q 1 } {q 0 } q 1 {q 2 } q 2 Como puede observarse, todo se especifica en conjuntos. 2.2.1 Extensión a ˆδ Similarmente a un DFA, podemos definir la función de transición extendida ˆδ como sigue: Base: ˆδ(q, ǫ) = q Inducción: Supongamos w es de la forma w = xa, donde a es el símbolo terminal y x es el resto de w. Supongamos también que: ˆδ(q, x) = {p 1, p 2,...,p k }. k i=1 δ(p i, a) = {r 1, r 2,...,r m }. Entonces δ(q, w) = {r 1, r 2,...,r m }. En otras palabras calculamos ˆδ(q, w) primero calculando ˆδ(q, x) y después siguiendo cualquier transición de algunos de esos estados etiquetada con a. Por ejemplo, podemos calcular ˆδ(q 0, 00101) para el autómata anterior: ˆδ(q 0, ǫ) = {q 0 } 19

ˆδ(q 0, 0) = δ(q 0, 0) = {q 0, q 1 } ˆδ(q 0, 00) = δ(q 0, 0) δ(q 1, 0) = {q 0, q 1 } ˆδ(q 0, 001) = δ(q 0, 1) δ(q 1, 1) = {q 0 } {q 2 } = {q 0, q 2 } ˆδ(q 0, 0010) = δ(q 0, 0) δ(q 2, 0) = {q 0, q 1 } = {q 0, q 1 } ˆδ(q 0, 00101) = δ(q 0, 1) δ(q 1, 1) = {q 0 } {q 2 } = {q 0, q 2 } Que tiene un estado final. 2.2.2 Lenguajes de un NFA El lenguaje aceptado por un NFA, A, es: L(A) = {w ˆδ(q 0, w) F }. 2.2.3 Equivalencia entre un DFA y un NFA Un NFA es normalmente más fácil de definir, aunque al mismo tiempo, para cualquier NFA N existe un DFA D tal que L(D) = L(N) y viceversa. Para esto se usa la construcción de subconjunto que muestra un ejemplo de cómo un autómata se puede construir a partir de otro. 2.2.4 Construcción de Subconjunto Para cada NFA existe un DFA equivalente (acepta el mismo lenguaje). Pero el DFA puede tener un número exponencial de estados. Sea N = (Q N, Σ, δ N, q 0, F N ) un NFA. El DFA equivalente construido a partir del subconjunto de construcción es D = (Q D, Σ, δ D, {q 0 }, F D ), donde: Q D = 2 Q N ; i.e., Q D es el conjunto de todos los subconjuntos de Q N. F D es el conjunto de conjuntos S en Q D tal que S F N. Para cualquier S Q N y a Σ, δ D (S, a) = p S δ N(p, a), osea, la unión de todos los estados a partir de p con entrada a. δ D ({q 1, q 2,...,q k }, a) = δ N (p 1, a) δ N (p 2, a)... δ N (p k, a). 20

La función de transición δ D del NFA anterior es: Al existir 3 estados, tenemos 8 subconjuntos. Esto mismo lo podemos poner como: Lo cual es un DFA (simplemente cambiando la notación). También es importante notar que no todos los estados pueden ser alcanzados. En particular, sólo los estados B, E y F son accesibles, por lo que los demás los podemos eliminar. Una forma de no construir todos los subconjuntos para después encontrar que sólo unos cuantos son accesibles, es construir la tabla sólo para los estados accesibles (lazy evaluation). Para el ejemplo anterior: δ D (q 0, 0) = q 0, q 1 δ D (q 0, 1) = q 1 δ D (q 0, q 1, 0) = q 0, q 1 21

δ D (q 0, q 1, 1) = q 0, q 2 = δ N (q 0, 1) δ N (q 1, 1) δ D (q 0, q 2, 0) = q 0, q 1 δ D (q 0, q 2, 1) = q 0 Lo que nos queda: Teorema clave: inducción de w (la prueba está en el libro): ˆδ D ({q 0 }, w) = ˆδ N (q 0, w). Lo que queremos probar es que si D = (Q D, Σ, δ D, {q 0 }, F D ) es construido a partir del NFA N = (Q N, Σ, δ N, q 0, F N ) usando construcción de subconjuntos, entonces L(D) = L(N). Queremos probar por inducción en w que ˆδ D ({q 0 }, w) = ˆδ N (q 0, w). Las dos funciones de transición regresan conjuntos de estados de Q N, pero la determinística lo interpreta como uno solo de sus estados Q D. Base: w = ǫ, en este caso ˆδ D ({q 0 }, ǫ) = ˆδ N (q 0, ǫ). Inducción: Tomamos w de longitud n + 1 y asumimos que se cumple el enunciado para n, o sea que ˆδ D ({q 0 }, x) = ˆδ N (q 0, x). Sean estos dos conjuntos de estados = {p 1, p 2,...,p k }. Dividimos a w en xa. La definición de ˆδ para el NFA nos dice que: ˆδ N (q 0, w) = k i=1 δ N(p i, a). Por la construcción de subconjuntos: δ D ({p 1, p 2,...,p k }, a) = k i=1 δ N(p i, a) Usando esto, y que ˆδ D ({q 0 }, x) = {p 1, p 2,...,p k } tenemos que: ˆδ D ({q 0 }, w) = δ D (ˆδ D ({q 0 }, x), a) = δ D ({p 1, p 2,...,p k }, a) = k i=1 δ N(p i, a) 22

Tanto D como N aceptan w cuando contiene un estado en FN. Consecuencia: L(D) = L(N). Ejemplo: Problema 2.3.1 Ejemplo: En este ejemplo un tanto imaginario, se diseñará un NFA para aceptar cadenas sobre el alfabeto {1, 2, 3} de tal manera que el último símbolo aparezca previamente, sin ninguna intervención de un símbolo más alto entre esa previa aparición del símbolo, e.g.,... 11,...21112,...312123. Truco: Utilizar el estado de inicio con el significado Creo que todavía no se ha visto el símbolo que corresponde al símbolo final. Otros tres estados representando una elección de que el símbolo con que acaba la cadena se ha visto y se recuerda de que símbolo se trata. Ejemplo: Subconjunto de Construcción del NFA Previo. Un truco práctico importante utilizado por analizadores léxicos y otros procesadores de texto es ignorar los (frecuentemente muchos) estados que no son accesibles desde el estado de inicio (i.e., no hay ruta que lleve a ellos). Para el ejemplo anterior de NFA, de los 32 subconjuntos posibles, solo 15 son accesibles. Calculando las transiciones por demanda obtenemos el siguiente δ D : 23

1 2 3 p pq pr Ps pq pqt pr Ps pqt pqt pr Ps pr pqr prt Ps prt pqr prt Ps ps pqs prs Pst pst pqs prs Pst prs pqrs prst Pst prst pqrs prst Pst pqs pqst prs Pst pqst pqst prs Pst pqr pqrt prt Ps pqrt pqrt prt Ps pqrs pqrst prst Pst pqrst pqrst prst Pst Ejemplo: Problema 2.4.1.a 2.3 Autómatas Finitos y Lenguajes Formales 2.3.1 Autómata Finito con Transiciones-ǫ Sea ǫ una etiqueta en arcos. No hay ningún cambio extra: la aceptación de w todavía se da como la existencia de la ruta desde un estado de inicio a un estado de aceptación con etiqueta w. Pero ǫ puede aparecer en los arcos, y significa que hay una cadena vacía (i.e., no tiene una contribución visible para w). 24

Ejemplo: 001 es aceptado siguiendo la ruta q, s, r, q, r, s, con la etiqueta 0ǫ01ǫ = 001. Podemos diseñar un autómata que acepte cadenas de números que tengan un signo al inicio opcional, seguida posiblemente de una cadena de decimales, seguida de un punto decimal y posiblemente de otra cadena de decimales. Más formalmente: Un ǫ-nfa es una quíntupla (Q, Σ, δ, q 0, F), donde δ es una función de Q Σ {ǫ} al conjunto potencia de Q. 25

La tabla de transición del ǫ-nfa del ejemplo anterior es: 2.4 Eliminación de las Transiciones-ǫ Las transiciones-ǫ son una conveniencia, pero no incrementan la potencia de los FA s. Para eliminar las transiciones-ǫ: 1. Calcular la cerradura transitiva sólo para los arcos ǫ Ejemplo: q {q}; r {r, s}; s {r, s}. 2. Si un estado p puede alcanzar al estado q por medio de arcos ǫ, y existe una transición de q a r en la entrada a (no ǫ), entonces añádase una transición de p a r con la entrada a. 3. Convertir el estado p en un estado de aceptación siempre y cuando p pueda alcanzar algún estado de aceptación q por medio de arcos ǫ. 26

4. Eliminar todas las transiciones-ǫ. Ejemplo: De la misma forma como lo hicimos anteriormente, podemos definir las transiciones extendidas para ǫ-nfa. Base: ˆδ(q, ǫ) = ECLOSE(q) Inducción: ˆδ(q, xa) = p δ(ˆδ(q,x),a) ECLOSE(p) Por ejemplo, ˆδ(q 0, 5.6) es: ˆδ(q 0, ǫ) = {q 0, q 1 } = ECLOSE(q 0 ) δ(q 0, 5) δ(q 1, 5) = {q 1, q 4 } ECLOSE(q 1 ) ECLOSE(q 4 ) = {q 2, q 3 } δ)q 1,.) δ(q 4,.) = {q 1, q 4 } ECLOSE(q 2 ) ECLOSE(q 3 ) = {q 2, q 3, q 5 } = ˆδ(q 0, 5.) δ)q 2, 6) δ(q 3, 6) δ(q 5, 6) = {q 3 } δ(q 3 ) = {q 3, q 5 } = ˆδ(q 0, 5.6) Como antes, el lenguaje aceptado por un ǫ-nfa, E, es: L(E) = {w ˆδ(q 0, w) F }, osea todas las cadenas w que van de un estado inicial q 0 a al menos un estado final. Se puede demostrar que se puede construir un DFA a partir de un ǫ-nfa siguiendo un esquema parecido al de construcción de subconjuntos visto para NFA. Q D = {S S Q E S = ECLOSE(S)} q D = ECLOSE(q 0 ) 27

F D = {S S Q D S F E } δ D (S, a) = ECLOSE(p) p δ(t, a), t S} lo que se calcula para todos los a Σ y conjuntos S Q D. Ejemplo: Problema 2.5.6 Por ejemplo, el DFA correspondiente al ǫ-nfa de números decimales (omitiendo todas las transiciones a estados muertos ) es: Se puede demostrar que un lenguaje L es aceptado por algún ǫ-nfa E si y solo si L es aceptado por un DFA. Para esto, hacia un sentido es fácil (cambiando un DFA a un ǫ-nfa) y para el otro sentido se hace lo mismo que hemos hecho antes, probando con el caso base y el caso inductivo, donde partimos w = xa, asumimos que es verdad para x y probamos para w, solo que ahora tomando la cerradura ǫ o ECLOSE para los estados. 28

Capítulo 3 Expresiones Regulares Es un equivalente algebraico para un autómata. Utilizado en muchos lugares como un lenguaje para describir patrones en texto que son sencillos pero muy útiles. Pueden definir exactamente los mismos lenguajes que los autómatas pueden describir: Lenguajes regulares Ofrecen algo que los autómatas no: Manera declarativa de expresar las cadenas que queremos aceptar Ejemplos de sus usos Comandos de búsqueda, e.g., grep de UNIX Sistemas de formateo de texto: Usan notación de tipo expresión regular para describir patrones Convierte la expresión regular a un DFA o un NFA y simula el autómata en el archivo de búsqueda Generadores de analizadores-léxicos. Como Lex o Flex. Los analizadores léxicos son parte de un compilador. Dividen el programa fuente en unidades lógicas (tokens). okens como while, números, signos (+,, <, etc.) Produce un DFA que reconoce el token 29

3.1 Operadores y Operandos Si E es una expresión regular, entonces L(E) denota el lenguaje que define E. Las expresiones se construyen de la manera siguiente: Un operando puede ser: 1. Una variable, que pertenece o se representa por medio de un lenguaje. 2. Un símbolo, que se representa a sí mismo como un conjunto de cadenas, i.e., a representa al lenguaje {a} (formalmente, L(a) = {a}). 3. ǫ, representado por {ǫ} (un lenguaje). 4., representando a (el lenguaje vacío). Los operadores son: 1. +, que representa la unión. L(E + F) = L(E) L(F). 2. Yuxtaposición (i.e., símbolo de no operador, como en xy que significa x y) para representar la concatenación. L(EF) = L(E)L(F), donde la concatenación de los lenguajes L y M es {xy x L y y M}, la concatenación también se representa por un punto ó como dot. 3. para representar la cerradura. L(E ) = (L(E)), donde L = {ǫ} L LL LLL.... 4. Si E es una expresión regular, entonces E es una expresión regular, que denota la cerradura de L(E). Esto es, L(E ) = (L(E)). 5. Si E es una expresión regular, entonces (E), E entre paréntesis, también es una expresión regular que denota el mismo lenguaje que E. Formalmente: L((E)) = L(E). Precedencia de los operadores de Expresiones-Regulares 1. El asterisco de la cerradura tiene la mayor precedencia. Aplica sólo a la secuencia de símbolos a su izquierda que es una expresión regular bien formada 30

2. Concatenación sigue en precedencia a la cerradura, el operador dot. 3. Después de agrupar los asteriscos a sus operandos, se agrupan los operadores de concatenación a sus operandos 4. Se agrupan todas las expresiones yuxtapuestas (adyacentes sin operador interviniendo) 5. Concatenación es asociativa y se sugiere agrupar desde la izquierda (i.e. 012 se agrupa (01)2). 6. La unión (operador +) tiene la siguiente precedencia, también es asociativa. 7. Los paréntesis pueden ser utilizados para alterar el agrupamiento Ejemplos L(001) = 001. L(0 + 10 ) = {0, 1, 10, 100, 1000,...}. L((0(0 + 1)) ) = el conjunto de cadenas de 0 s y 1 s, de longitud par, de tal manera que cada posición impar tenga un 0. Ejemplo 3.2: Expresión regular para el conjunto de cadenas que alterna 0 s y 1 s: (01) + (10) + 0(10) + 1(01) (ǫ + 1)(01) (ǫ + 0) 3.2 Equivalencia de Lenguajes de FA y Lenguajes RE Se mostrará que un NFA con transiciones-ǫ puede aceptar el lenguaje de una RE. 31

Después, se mostrará que un RE puede describir el lenguaje de un DFA (la misma construcción funciona para un NFA). Los lenguajes aceptados por DFA, NFA, ǫ-nfa, RE son llamados lenguajes regulares. 3.2.1 De DFA s a Expresiones Regulares Teorema 3.4: Si L = L(A) para algún DFA A, entonces existe una expresión regular R tal que L = L(R). Prueba: Suponiendo que A tiene estados {1, 2,..., n}, n finito. Tratemos de construir una colección de RE que describan progresivamente conjuntos de rutas del diagrama de transiciones de A R (k) ij es el nombre de la RE con lenguaje el conjunto de cadenas w w es la etiqueta de la ruta del estado i al estado j de A. Esta ruta no tiene estado intermedio mayor a k. Los estados inicial y terminal no son intermedios, i y/o j pueden ser igual o menores que k Para construir R (k) ij k = n se utiliza una definición inductiva de k = 0 hasta BASE: k = 0, implica que no hay estados intermedios. Sólo dos clases de rutas cumplen con esta condición: 1. Un arco del nodo (estado) i al nodo j 2. Una ruta de longitud 0 con un solo nodo i Si i j, solo el caso 1 es posible. Examinar el DFA A y encontrar los símbolos de entrada a tal que hay una transición del estado i al estado j con el símbolo a Si no hay símbolo a, entonces R (0) ij =. 32

Si hay sólo un símbolo a, entonces R (0) ij = a. Si hay varios símbolos a 1, a 2,...,a k, entonces R (0) ij = a 1 +a 2 +...+a k. Si i = j, sólo se permiten rutas de longitud 0 y loops del estado i a él mismo. La ruta de longitud 0 se representa con ǫ Si no hay símbolo a, entonces R (0) ij = ǫ. Si hay sólo un símbolo a, entonces R (0) ij = ǫ + a. Si hay varios símbolos a 1, a 2,...,a k, entonces R (0) ij = ǫ+a 1 +a 2 +...+a k. INDUCCIÓN: Suponemos que hay una ruta del estado i al estado j que no pasa por ningún estado mayor que k. Se consideran 2 casos. 1. La ruta no pasa por el estado k: Etiqueta de la ruta esta en el lenguaje R (k 1) ij. 2. La ruta pasa por el estado k al menos una vez: Se divide la ruta en varias partes, una división cada que se pasa por el estado k Primero del estado i al estado k, después, varios pasos del estado k a sí mismo, finalmente, del estado k al estado j. Las etiquetas de estas rutas se representan con la RE R (k 1) ik (R (k 1) kk ) R (k 1) kj Si combinamos las expresiones de las rutas de los dos tipos: R (k) ij = R (k 1) ij +R (k 1) ik (R (k 1) kk ) R (k 1) kj para todas las etiquetas de las rutas del estado i al j que no pasan por estados mayores que k. Eventualmente tendremos R (n) ij. 33

Asumimos que 1 es el estado inicial. El estado de aceptación puede ser un conjunto de estados La expresión regular para el lenguaje del autómata es la suma (unión) de todas las expresiones R (n) 1j tal que j es un estado de aceptación. Ejemplo: Un DFA que acepta todas las cadenas que tienen al menos un 0 Inicialmente sustituimos para la base: R i j (0) = ǫ R (0) ij = ǫ + a R (0) ij = ǫ + a 1 + a 2 +... + a k R (0) R (0) 12 0 R (0) 21 R (0) 11 ǫ + 1 22 (ǫ + 0 + 1) Ahora para el paso de inducción: R (1) ij = R (0) ij + R (0) i1 (R(0) 11 ) R (0) 1j Por sustitución directa Simplificado R (1) 11 ǫ + 1 + (ǫ + 1)(ǫ + 1) (ǫ + 1) 1 R (1) R (1) R (1) 12 0 + (ǫ + 1)(ǫ + 1) 0 1 0 21 + (ǫ + 1) (ǫ + 1) 22 ǫ + 0 + 1 + (ǫ + 1) 0 ǫ + 0 + 1 R (2) ij = R (1) ij + R (1) i2 (R(1) 22 ) R (1) 2j Por sustitución directa Simplificado R (2) 11 1 + 1 0(ǫ + 0 + 1) 1 R (2) 12 1 0 + 1 0(ǫ + 0 + 1) (ǫ + 0 + 1) 1 0(0 + 1) R (2) 21 + (ǫ + 0 + 1)(ǫ + 0 + 1) R (2) 22 ǫ + 0 + 1 + (ǫ + 0 + 1)(ǫ + 0 + 1) (ǫ + 0 + 1) (0 + 1) Construcción de la RE final: 34

Unión de todas las expresiones donde el primer estado es el estado inicial y el segundo el estado de aceptación Estado inicial: 1 Estado final: 2 Sólo necesitamos R (2) 12 1 0(0 + 1) Este método funciona también para NFA y ǫ-nfa pero su construcción es muy costoso, hasta en el orden de 4 n símbolos. 3.2.2 Conversión de un DFA a una RE por Eliminación de Estados Evita duplicar trabajo en algunos puntos del teorema 3.4. Ahora utilizaremos autómatas que podrán tener RE como etiquetas. El lenguaje del autómata es la unión de todas las rutas que van del estado inicial a un estado de aceptación. Concatenando los lenguajes de las RE que van a través de la ruta. En la siguiente figura se muestra un autómata al cual se va a eliminar el estado s. 35

Se eliminan todos los arcos que incluyen a s Se introducen, para cada predecesor q i de s y cada sucesor p j de s, una RE que representa todas las rutas que inician en q i, van a s, quizás hacen un loop en s cero o más veces, y finalmente van a p j. La expresión para estas rutas es Q i S P j. Esta expresión se suma (con el operador unión) al arco que va de q i a p j. Si este arco no existe, se añade primero uno con la RE El autómata resultante después de la eliminación de s es el siguiente 3.2.2.1 Estrategia para construir el autómata 1. Para cada estado de aceptación q, aplicar el proceso de reducción para producir un autómata equivalente con RE como etiquetas en los arcos. Eliminar todos los estados excepto q y el estado inicial q 0. 2. Si q q 0, se genera un autómata con 2 estados como el siguiente, una forma de describir la RE de este autómata es (R + SU T) SU 36

3. Si el estado inicial también es un estado de aceptación, también se debe hacer una eliminación de estados del autómata original que elimine todos los estados menos el inicial y dejamos un autómata como el siguiente: 4. La RE final es la suma (unión) de todas las expresiones derivadas del autómata reducido para cada estado de aceptación por las reglas 2 y 3. Ejemplo: para el siguiente NFA que acepta cadenas de 0 s y 1 s de manera que tienen un 1 dos o tres posiciones antes del final. 37

3.2.3 Convirtiendo una RE a un Autómata Teorema 3.7: Todo lenguaje definido por una RE también esta definido por un autómata finito. Prueba: Suponemos L = L(R) para la expresión regular R. Mostramos que L = L(E) para algún ǫ-nfa E con: 1. Exactamente un estado de aceptación 2. Sin arcos que lleguen al estado inicial 3. Sin arcos que salgan del estado de aceptación 38

Base: cumpliendo las condiciones 1, 2, y 3. Inducción: a) b) c) d) 39

Ejemplo 3.8: Convertir la RE (0 + 1) 1(0 + 1) a un ǫ-nfa. 40

3.3 Leyes Algebraicas de las Expresiones Regulares 3.3.1 Asociatividad y Conmutatividad Ley conmutativa para la unión: L + M = M + L Ley asociativa para la unión: (L + M) + N = L + (M + N) Ley asociativa para la concatenación: (LM)N = L(MN) NOTA: La concatenación no es conmutativa, es decir LM ML 3.3.2 Identidades y Aniquiladores Una identidad para un operador es un valor tal que cuando el operador se aplica a la identidad y a algún otro valor, el resultado es el otro valor. 0 es la identidad para la adición: 0 + x = x + 0 = x. 1 es la identidad para la multiplicación: 1 x = x 1 = x Un aniquilador para un operador es un valor tal que cuando el operador se aplica al aniquilador y algún otro valor, el resultado es el aniquilador. 0 es el aniquilador para la multiplicación: 0 x = x 0 = 0 no hay aniquilador para la suma 3.3.3 Leyes es la identidad para la unión: + L = L + = L ǫ es la identidad para la concatenación: ǫl = Lǫ = L es el aniquilador para la concatenación: L = L = NOTA: Estas leyes las utilizamos para simplificaciones 41

3.3.3.1 Leyes Distributivas Como la concatenación no es conmutativa, tenemos dos formas de la ley distributiva para la concatenación: Ley Distributiva Izquierda para la concatenación sobre unión: L(M + N) = LM + LN Ley Distributiva Derecha para la concatenación sobre unión: (M + N)L = ML + NL 3.3.3.2 Ley de Idempotencia Se dice que un operador es idempotente si el resultado de aplicarlo a dos argumentos con el mismo valor es el mismo valor En general la suma no es idempotente: x+x x (aunque para algunos valores sí aplica como 0 + 0 = 0) En general la multiplicación tampoco es idempotente: x x x La unión e intersección son ejemplos comunes de operadores idempotentes Ley idempotente para la unión: L + L = L 3.3.3.3 Leyes que involucran la cerradura (L ) = L (Idempotencia para la cerradura) = ǫ ǫ = ǫ L+ = LL = L L, L+ se define como L + LL + LLL +... L = ǫ + L + LL + LLL +... LL = Lǫ + LL + LLL + LLLL +... L = L + +ǫ L? = ǫ + L 42

3.3.3.4 Descubriendo leyes para RE Se puede proponer una variedad infinita de leyes para RE Hay una metodología general para hacer estas pruebas más fácilmente? Se reduce a probar la igualdad de dos lenguajes específicos Técnica ligada a los operadores para RE, no se puede extender a otros operadores (como intersección) Para probar que (L + M) = (L M ) Probamos que las cadenas que están en (L + M) también están en (L M ) Probamos que las cadenas que están en (L M ) también están en (L + M) Cualquier RE con variables se puede ver como una RE concreta sin variables Ver cada variable como si fuera un símbolo diferente La expresión (L + M) se puede ver como (a + b) Utilizamos esta forma como una guía para concluir sobre los lenguajes Teorema 3.13: Sea E una RE con variables L 1, L 2,...,L m. Se forma una RE concreta C reemplazando cara ocurrencia de L i por un símbolo a i, para i = 1, 2,..., m. Luego para cada lenguaje L 1, L 2,...,L m, cada cadena w en L(E) puede escribirse como w 1 w 2...w k, donde cada w i esta en uno de los lenguajes, como L ji, y la cadena a j1 a j2...a jk esta en el lenguaje L(C). Menos formal, podemos construir L(E) iniciando con cada cadena en L(C), como a j1 a j2...a jk, y sustituyendo por cada a ji s cualquier cadena del lenguaje correspondiente L ji. Base (3 casos): Si E = ǫ, la expresión congelada (concreta) también es ǫ Si E =, la expresión congelada también es 43

Si E = a, la expresión congelada es también a. Ahora wǫl(e) sí y solo sí existe uǫl(a), tal que w = u y u está en el lenguaje de la expresión congelada, i.e. uǫa. Inducción (3 casos): Caso 1 (Unión): E = F + G, L(E) = L(F) + L(G). Utilizamos las expresiones concretas C y D formadas de F y G respectivamente y las sustituimos en todas sus apariciones. Obtenemos: L(C + D) = L(C) + L(D) Suponemos que w es una cadena en L(E) cuando las variables de E se reemplazan por lenguajes específicos. Entonces w esta en L(F) o en L(G). Caso 2 (Concatenación): Case 3 (Cerradura): La prueba de una Ley Algebraica para una RE Probar si E = F es verdadero. E y F son dos RE con el mismo conjunto de variables. PASOS: 1. Convertir E y F a RE concretas C y D, respectivamente, reemplazando cada variable por un símbolo concreto. 2. Probar si L(C) = L(D). Si es cierto, entonces E = F es una ley verdadera y si no, la ley es falsa. NOTA: No se verán las pruebas para decidir si dos RE denotan el mismo lenguaje hasta la sección 4.4. 44

Capítulo 4 Propiedades de los Lenguajes Regulares Existen diferentes herramientas que se pueden utilizar sobre los lenguajes regulares: El lema de Pumping: cualquier lenguaje regular satisface el pumping lemma, el cual se puede usar para probar que un lenguaje no es regular. Propiedades de cerradura: se pueden construir autómatas a partir de componentes usando operaciones, v.g., dado un lenguaje L y M construir un autómata para L M. Propiedades de decisión: análisis computacional de autómatas, v.g., probar si dos autómatas son equivalentes. Técnicas de minimización: útiles para construir máquinas más pequeñas. La clase de lenguajes conocidos como lenguajes regulares tienen al menos 4 descripciones: DFA, NFA, ǫ NFA y RE. No todos los lenguajes son regulares, por ejemplo, L = {0 n 1 n n 1}. Si suponemos que el lenguaje es regular y es aceptado por un DFA A de k estados, si lee al menos k 0s se tiene que cumplir que dos estados se repitan, 45

esto es que para i < j, p i = p j. Llamemos a este estado q. Si δ(q, 1 i ) F entonces el máquina acepta erróneamente 0 j 1 i, y si / F entonces la máquina rechaza erróneamente 0 i 1 i. El problema es que el DFA tiene que tener historia de cuántos 0 s lleva para poder aceptar el mismo número de 1 s y que este número es variable. 4.1 Lema de Pumping Si L es un lenguaje regular, entonces existe una constante n tal que cada cadena w L, de longitud n o más, puede ser escrita como w = xyz, donde: 1. y ǫ 2. xy n 3. Para toda i 0, wy i z también está en L. Notese que y i = y repetida i veces; y 0 = ǫ. Lo que dice es que si tenemos una cadena con una longitud mayor al número de estados del autómata, entonces una cadena no vacía y puede ser repetida (pumped) un número arbitrario de veces. 4.1.1 Prueba del Lema de Pumping Como se da por hecho que L es regular, debe haber un DFA A tal que L = L(A). Si A tiene n estados; escogemos esta n para el lema de pumping. Sea w una cadena de longitud n en L, como en w = a 1 a 2...a m, donde m n. w. Sea q i el estado en que A esta después de leer los primeros i símbolos de q 0 = estado de inicio, q 1 = δ(q 0, a 1 ), q2 = δ (q 0, a 1 a 2 ), etc. 46

Como sólo hay n estados diferentes, dos de q 0, q 1,...,q n deben ser los mismos; digamos q i = q j, donde 0 i < j n. Sea x = a 1...a i ; y = a i+1... a j ; z = a j+1...a m. Entonces, si repetimos el ciclo desde q i a q i con la etiqueta a i+1... a j cero veces por una ocasión, o más, se puede probar que xy i z es aceptado por A. 4.1.2 Uso del Lema de Pumping El Lema de Pumping se utiliza para mostrar que un lenguaje L no es regular. Se inicia asumiendo que L es regular. Luego, debe haber alguna n que sirva como la constante de PL. Puede que no sepamos el valor de n, pero podemos seguir con el resto del juego con n como un parámetro. Escogemos una w que sabemos que está en L. Típicamente, w depende de n. Aplicando el PL, sabemos que w puede descomponerse en xyz, satisfaciendo las propiedades del PL. De nuevo, puede que no sepamos como descomponer w, así que utilizaremos x, y, z como parámetros. Derivamos una contradicción escogiendo i (la cual puede depender de n, x, y, y/ó z) tal que xy i z no está en L. Ejemplo: considere el lenguaje de cadenas con el mismo número de 0 s y 1 s. Por el pumping lemma, w = xyz, xy n, y ǫ y xy k z L. 47

w = } 000 {{..}..}{{}..0 0111 } {{...11} x y z En particular, xz L, pero xz tiene menos 0 s que 1 s. Ejemplo 2: Supongamos que L = 1 p : p es primo es regular. Sea n el parámetro del pumping lemma y seleccionemos un primo p n + 2. y = m { }} { w = 111 } {{..}..}{{}..1111 } {{...11} x y z Ahora xy p m z está en L. xp p m z = xz +(p m) y = p m+(p m)m = (1 + m)(p m) Que no es un número primo, a menos que uno de los factores sea 1. Pero: y ǫ 1+m > 1 y m = y xy n, p n+2 p m n+2 n = 2 Problema 1: Considere el problema 0 n 10 n y demuestre que no es regular. Problema 2: Considere que el conjunto de cadenas de 0 s cuya longitud es un cuadrado perfecto; formalmente L = {0 i i es un cuadrado}. Suponemos que L es regular. Entonces hay una n constante que satisface las condiciones del PL. Considere w = 0 n2, que seguramente estará en L. Entonces w = xyz, donde xy n y y ǫ Por PL xyyz está en L. Pero la longitud de xyyz es más grande que n 2 y no más grande que n 2 + n. Sin embargo, el próximo cuadrado perfecto después de n 2 es (n + 1) 2 = n 2 + 2n + 1. Así, xyyz no es de longitud cuadrada y no está en L. 48 p

Como hemos derivado una contradicción, la única asunción que no se ha probado que L es regular debe ser una falla, y tenemos una prueba por contradicción que L no es regular. 4.1.3 Propiedades de Cerradura Algunas operaciones sobre lenguajes regulares garantizan producir lenguajes regulares: Unión: L M lenguajes con cadenas en L, M o en ambos. Intersección: L M lenguajes con cadenas en ambos. Complemento: L cadenas que no están en L. Diferencia: L\M o L M. Inversión: L R = {w R : w L} Cerradura: L Concatenación: L.M Homomorfismo (substitución): h(l) = {h(w) L}h es un homomorfismo. Homomorfismo inverso (substitución inversa): h 1 (L) = {w Σ : h(w) L, h : Σ } es un homomorfismo. Unión: la unión de lenguajes regulares es regular. Sea L = L(E) y M = L(F). Entonces L(E + F) = L M, por la definición de + en RE. Complemento: Si L es un lenguaje regular sobre Σ, entonces también lo es L = Σ L. Todos los estados son de aceptación excepto los F. 49

Ejemplo: Sea L definido por el siguiente DFA (el lenguaje de cadenas que terminan en 01): Entonces L es descrito por (el lenguaje de cadenas que no terminan en 01): Las cadenas de un número diferente de 0 s y 1 s es difícil probarlo con el pumping lemma. Sin embargo, ya probamos que L = 0 n 1 n no es regular. M = 0 n 1 m, n m es L. Como L no es regular su complemento tampoco. Intersección: Si L y M son regulares, entonces también L M. Usando las leyes de Morgan: L M = L M. Para esto también se puede construir un autómata que simula A L y A M en paralelo y llega a un estado de aceptación si A L y A M también lo hacen. 50

Ejemplo: (a) todos las cadenas con un 0, (b) todas las cadenas con un 1, (c) todas las cadenas con un 0 y un 1. Diferencia: L\M lenguaje en L pero no en M, L\M = L M. Inversión: w R es la cadena invertida w. Ejemplo: 0010 R = 0100. Inversión de un lenguaje L es el lenguaje con todas las cadenas de L invertidas. Por ejemplo: L = {001, 10, 111}, L R = {100, 01, 111}. Se puede probar que L(E R ) = (L(E)) R. En particular, E R = E para conjunto vacío y a. Si E = F + G, entonces, E R = F R + G R Si E = F G, entonces E R = G R F R Por ejemplo, L(E 1 ) = {01, 111} y L(E 2 ) = {00, 10}. 51

L(E 1 )L(E 2 ) = {0100, 0110, 11100, 11110} L R (E 1 ) = {10, 111} y L R (E 2 ) = {00, 01} L R (E 1 )L R (E 2 ) = {0010, 00111, 0110, 01111} = (L(E 1 )L(E 2 )) R Si L = (0 + 1)0, L R = (0 ) R (0 + 1) R = 0 (0 + 1) Si E = F, entonces E R = (F R ) Homomorfismo Un homomorfismo sobre Σ es una función h : Σ Θ, donde Σ y Θ son alfabetos. Sea w = a 1 a 2...a n Σ. Entonces h(w) = h(a 1 )h(a 2 )...h(a n ) y h(l) = {h(w) L}. Ejemplo: sea h : {0, 1} {a, b} definido como h(0) = ab, y h(1) = ǫ. Entonces h(0011) = abab y h(l(10 1)) = L((ab) ). h(l) es regular si L es regular. Sea L = L(E) para una RE E, queremos probar que L(h(E)) = h(l). Base: E es ǫ ó, h(e) = E y L(h(E)) = L(E) = h(l(e)). E es un solo símbolo, a. Entonces L(E) = a, y L(h(E)) = L(h(a)) = {h(a)} = h(l(e)). Inducción: Hay tres casos, dependiendo de si R = R 1 + R 2, R = R 1 R 2, ó R = R 1. L = E + F, L(h(E + F)) = L(h(E) + h(f)) = L(h(E)) L(h(F)) = h(l(e)) h(l(f)) = h(l(e) L(F)) = h(l(e + F)) L = E F, L(h(E F)) = L(h(E)) L(h(F)) = h(l(e)) h(l(f)) = h(l(e) L(F)) L = E, L(h(E )) = L(h(E) ) = h(l(e)) = h(l(e )) 52

Homomorfismo Inverso: Sea h : Σ Θ un homomorfismo. Sea L Θ, entonces h 1 (L) = {w w Σ : h(w) L}. Sea h : Σ Θ un homomorfismo. Sea L Θ un lenguaje regular, entonces h 1 (L) es regular. El DFA del homomorfismo inverso usa los estados del DFA original, pero cambia los símbolos de entrada de acuerdo a la función h antes de decidir el siguiente estado. En la prueba lo importante es que los estados de aceptación de los dos autómatas son los mismos y que h(a), para cualquier símbolo a dentro del alfabeto del DFA original puede ser ǫ, un símbolo o muchos símbolos. γ(q, a) = ˆδ(q, h(a)). 53

La prueba se hace por inducción sobre w. ˆγ(q 0, w) = ˆδ(q 0, h(w)). 4.1.4 Propiedades de decisión Algunas de las preguntas que nos podemos hacer acerca de lenguajes son si el lenguaje es vacío, si una cadena particular pertenece al lenguaje o si dos descripciones definen el mismo lenguaje. También podemos cuestionarnos acerca del costo computacional requerido para resolver estas preguntas o por ejemplo el requerido para hacer la conversión entre una representación a otra. Transformar un ǫ-nfa a un DFA: Si el ǫ-nfa tiene n arcos. Para calcular ECLOSE(p) se requieren seguir a lo más n 2 arcos. El DFA tiene a lo más 2 n estados. Para cada símbolo y cada subconjunto el calcular la función de transición para todos los estados, requiere a lo más n 3 pasos, lo cual nos da una complejidad total de O(n 3 2 n ). En general el número de estados del DFA es de orden lineal (digamos s), por lo que en la práctica la complejidad se reduce a O(n 3 s). 54

Transformar un DFA a un NFA: Sólo se requiere poner corchetes a los estados, lo cual nos da O(n). Transformar un FA a una RE: O(n 3 4 n ). Es todavía peor si el FA es NFA. Si lo convertimos primero a un DFA nos da: O(n 3 4 n3 2 n ). Transformar de una RE a un FA: se puede construir un autómata en n pasos. Si eliminamos transiciones ǫ toma O(n 3 ). Si se requiere un DFA puede tomar un número exponencial de pasos. Decidir si un lenguaje es vacío: el probar si existe un camino entre un estado inicial a uno final o de aceptación, es simplemente un problema de ver si un nodo está conectado en un grafo, lo cual tiene una complejidad de O(n 2 ). Probar por pertenencia a un lenguaje regular: ver si una cadena es miembro del lenguaje. Si la cadena w es de longitud n para un DFA, esto es de complejidad O(n). Si es un NFA de s estados, entonces la complejidad es: O(ns 2 ). Si es un ǫ-nfa entonces la complejidad es O(ns 3 ). 4.2 Equivalencia y minimización de autómatas Lo que queremos saber es si dos autómatas diferentes definen el mismo lenguaje. Primero definiremos lo que son estados equivalentes. Dos estados p y q dentro de un autómata son equivalentes: p q w Σ : ˆδ(p, w) F ˆδ(q, w) F. Si no, entonces se dice que son distinguibles. Osea que p y q son distinguibles si: w : ˆδ(p, w) F ˆδ(q, w) / F o viceversa. 55