apuntes fundamento

-

Universidad San Sebastián

Facultad de Ingeniería y Tecnología

Ingeniería Civil Informática

APUNTES DE LA ASIGNATURA

FUNDAMENTOS DE CIENCIAS DE

LA COMPUTACIÓN

Mag. Jacqueline Köhler C.

2

Fundamentos de Ciencias de la Computación

Jacqueline Köhler C. - USS

TABLA DE CONTENIDOS

1 INTRODUCCIÓN ................................................................................................................................. 5

1.1 SÍMBOLOS Y ALFABETOS ......................................................................................................... 6

1.2 PALABRAS .................................................................................................................................... 7

1.2.1 DEFINICIÓN ........................................................................................................................... 7

1.2.2 OPERACIONES SOBRE PALABRAS ................................................................................... 7

1.2.3 PROPIEDADES DE LAS OPERACIONES SOBRE PALABRAS ...................................... 10

1.3 LENGUAJES ................................................................................................................................ 11

1.3.1 DEFINICIÓN ......................................................................................................................... 11

1.3.2 OPERACIONES SOBRE LENGUAJES ............................................................................... 12

1.3.2.1 Operaciones de conjuntos ................................................................................................ 12

1.3.2.2 Operaciones basadas en la concatenación de palabras ..................................................... 12

1.3.2.3 Otras operaciones sobre lenguajes ................................................................................... 13

1.3.3 JERARQUÍA DE LOS LENGUAJES ................................................................................... 14

1.4 EJERCICIOS ................................................................................................................................. 15

2 LENGUAJES REGULARES .............................................................................................................. 17

2.1 GRAMÁTICAS............................................................................................................................. 17

2.2 GRAMÁTICAS REGULARES .................................................................................................... 21

2.3 EXPRESIONES REGULARES .................................................................................................... 21

2.3.1 PROPIEDADES BÁSICAS DE LAS EXPRESIONES REGULARES ................................ 23

2.3.2 NOTACIONES PARA EXPRESIONES REGULARES ....................................................... 24

2.4 AUTÓMATAS FINITOS.............................................................................................................. 26

2.4.1 DEFINICIÓN ......................................................................................................................... 26

2.4.2 TIPOS DE AUTÓMATAS FINITOS .................................................................................... 28

2.4.2.1 Autómata finito determinístico (AFD) ............................................................................. 28

2.4.2.2 Autómata finito no determinístico (AFND) ..................................................................... 31

2.4.3 EQUIVALENCIA ENTRE AFD Y AFND ............................................................................ 33

2.4.4 MINIMIZACIÓN DE AFD .................................................................................................... 36

2.5 OPERACIONES CON AF ............................................................................................................ 37

2.5.1 UNIÓN ................................................................................................................................... 37

3



2.5.2 CONCATENACIÓN .............................................................................................................. 37

2.5.3 ESTRELLA DE KLEENE ..................................................................................................... 38

2.5.4 COMPLEMENTACIÓN (SOLO PARA AFD) ..................................................................... 39

2.5.5 INTERSECCIÓN (SOLO PARA AFD) ................................................................................. 39

2.6 EQUIVALENCIAS ....................................................................................................................... 42

2.6.1 EQUIVALENCIA ENTRE ER Y AF .................................................................................... 42

2.6.1.1 Método de Thompson ...................................................................................................... 43

2.6.1.2 Método de ecuaciones lineales (método de Arden) ......................................................... 47

2.6.1.3 Método recursivo ............................................................................................................. 49

2.6.2 EQUIVALENCIA ENTRE AF Y GR .................................................................................... 50

2.6.2.1 Obtención de una GR a partir de un AF........................................................................... 50

2.6.2.2 Obtención de un AF a partir de una GR........................................................................... 51

2.7 LEMA DEL BOMBEO ................................................................................................................. 52

2.8 TRANSDUCTORES FINITOS .................................................................................................... 53

2.8.1 Máquina de Mealy .................................................................................................................. 53

2.8.2 Máquina de Moore .................................................................................................................. 54

2.9 EJERCICIOS ................................................................................................................................. 55

3 LENGUAJES LIBRES DE CONTEXTO ........................................................................................... 60

3.1 GRAMÁTICAS LIBRES DE CONTEXTO ................................................................................. 60

3.1.1 AMBIGÜEDAD ..................................................................................................................... 60

3.1.2 SIMPLIFICACIÓN DE GLC Y FORMAS NORMALES ..................................................... 62

3.1.2.1 Eliminación de símbolos inútiles ..................................................................................... 62

3.1.2.2 Eliminación de producciones ........................................................................................ 64

3.1.2.3 Eliminación de producciones unitarias ............................................................................ 65

3.1.2.4 Forma normal de Chomsky .............................................................................................. 66

3.1.2.5 Forma normal de Greibach .............................................................................................. 68

3.1.2.6 Factorización por la izquierda .......................................................................................... 69

3.2 AUTÓMATAS APILADORES .................................................................................................... 71

3.3 EQUIVALENCIA ENTRE CLG Y AA ....................................................................................... 74

3.3.1 PASO DE AA A GLC ............................................................................................................ 74

3.3.2 PASO DE GLC A AA ............................................................................................................ 76

4



3.4 EJERCICIOS ................................................................................................................................. 77

4 MÁQUINAS DE TURING .................................................................................................................. 79

4.1 DEFINICIÓN Y OPERACIÓN .................................................................................................... 79

4.2 ¿SON LAS MT MÁS POTENTES QUE LOS AF Y LOS AA? .................................................. 82

4.3 OTROS EJEMPLOS Y APLICACIONES DE MT ...................................................................... 85

4.4 EXTENSIONES AL MODELO DE MT ...................................................................................... 86

4.4.1 MT CON MOVIMIENTO DE ESPERAR ............................................................................. 86

4.4.2 MT CON CINTA MULTIPISTA ........................................................................................... 86

4.4.3 MT MULTI CINTA ............................................................................................................... 86

4.4.3 MT MULTI DIMENSIONAL ................................................................................................ 87

4.5 HIPÓTESIS DE CHURCH ........................................................................................................... 87

4.6 EJERCICIOS ................................................................................................................................. 88

5 COMPLEJIDAD COMPUTACIONAL .............................................................................................. 89

5.1 COMPLEJIDAD DE ALGORITMOS .......................................................................................... 89

5.1.1 LA BÚSQUEDA DE LA EFICIENCIA ................................................................................ 90

5.1.2 CÁLCULO DE LA COMPLEJIDAD .................................................................................... 91

5.2 MODELO DE MÁQUINA ........................................................................................................... 93

5.3 NOTACIÓN O .......................................................................................................................... 94

5.4 COMPLEJIDAD DE ALGORITMOS RECURSIVOS .......................................................... 100

5.5 CLASES DE PROBLEMAS ....................................................................................................... 103

5.5.1 CLASE P .............................................................................................................................. 104

5.5.2 CLASE NP ........................................................................................................................... 105

5.5.3 TRANSFORMACIÓN POLINOMIAL ............................................................................... 106

5.6 EJERCICIOS ............................................................................................................................... 106

BIBLIOGRAFÍA .................................................................................................................................. 107

5



1 INTRODUCCIÓN

Un lenguaje es una abstracción que permite la comunicación y coordinación mediante la creación de

conceptos que pueden ser entendidos de la misma forma por los distintos participantes. Así, un

lenguaje puede entenderse como una forma de hablar o de describir algo.

Para poder hablar de lenguaje es importante conocer algunos elementos. Por ejemplo, ¿cómo se crean

los conceptos? ¿Cómo hacer que todos entiendan lo mismo? El primer paso para responder esta

pregunta está en el concepto de símbolo. En el caso del castellano, se puede pensar en las letras como

símbolos elementales, que se emplean para construir conceptos sencillos denominados palabras. El

conjunto de todos los símbolos se conoce como alfabeto. Ahora bien, las palabras también pueden

formar parte de estructuras más complejas: frases y oraciones. A su vez, éstas pueden conformar

párrafos, etc.

A partir de los conceptos anteriores podría pensarse que cualquier secuencia de letras es una palabra o

que una oración podría ser una secuencia aleatoria de palabras. Pero de nuestra experiencia previa

sabemos que no es así. Existe una serie de reglas que limitan la forma de las palabras o la estructura de

un texto:

Reglas léxicas: corresponden a las reglas de ortografía de un lenguaje, e indican la forma que deben

tener las palabras. Por ejemplo, en castellano no puede haber palabras que contengan una n seguida

de una b.

Reglas sintácticas: definen la forma en que se debe estructurar un texto. Por ejemplo, una oración

debe tener sujeto y predicado. El predicado debe tener un núcleo que puede ir acompañado de

diversos complementos.

Reglas semánticas: determinan el significado de lo que se dice en el texto sintácticamente correcto

y guardan relación con el contexto. Por ejemplo, la frase “ése árbol” puede referirse a un árbol de

un parque, o bien a una estructura de datos empleada en la resolución de un problema

computacional.

Con todo lo anterior, ya tenemos una primera noción de qué es un lenguaje. Ahora bien, sabemos que

existen muchos lenguajes y que en ocasiones es necesario pasar un mensaje o texto de un lenguaje a

otro. De aquí surgen los conceptos de traducción (generar una copia escrita del mensaje original en un

idioma distinto) e interpretación (repetir verbalmente un mensaje en un lenguaje diferente al empleado

por el emisor).

Ahora bien, existen diferentes tipos de lenguajes. Por ahora, nos basta distinguir entre:

Lenguajes naturales: son aquellos que las personas utilizan para comunicarse entre ellas, como el

castellano, el inglés o el chino. Son muy complejos, tienen una gran cantidad de reglas y sin

embargo presentan situaciones de ambigüedad que los hablantes resuelven recurriendo al contexto

tanto de espacio como de tiempo.

Lenguajes formales: son lenguajes artificiales, diseñados para lograr una comunicación

(unidireccional) entre personas y máquinas. Estas últimas deben comprender los mensajes y

ejecutarlos, por lo que las reglas de los lenguajes formales deben estar muy bien definidas y no

pueden dar lugar a ambigüedades.

6



En ciencias de la computación, el estudio de los lenguajes formales se limita a sus características

intrínsecas e internas, sin tener en cuenta su significado ni su uso como herramienta de comunicación,

puesto que esto último corresponde a una atribución asignada por un observador externo al lenguaje.

No obstante, también resulta fundamental abordar algunos aspectos prácticos que se desprenden de la

teoría anterior: ¿cómo aplicar la teoría de lenguajes formales para poder comunicarnos con las

máquinas?

El resto de esta unidad se ocupa de responder a esta pregunta en forma general, mientras las unidades

siguientes detallan los conceptos teóricos necesarios para llevar a cabo las principales etapas del

proceso de compilación.

1.1 SÍMBOLOS Y ALFABETOS

El fundamento para cualquier lenguaje es el símbolo: una unidad u objeto representacional primitivo

(indivisible), estable y distinguible en un espacio determinado. En otras palabras, un símbolo es un

objeto concreto, discreto y bien definido. Algunos ejemplos de símbolos son: 1, 3, a, r, *, (, +, , ,

etc. Para denotar un símbolo genérico se usa el símbolo 𝜎.

El primer uso que podemos dar a los símbolos es la conformación de alfabetos. Estos últimos son

conjuntos finitos no vacíos de símbolos. En general, un alfabeto con 𝑛 símbolos se denota por Σ, es

decir, Σ = {𝜎1, 𝜎2, … , 𝜎𝑛}, donde 𝜎𝑖 es un símbolo y 𝑛 > 0. Algunos ejemplos de alfabetos son:

{𝐼} Un alfabeto unario.

{0, 1} Un alfabeto binario.

{0, 1, 2, 3, 4, 5, 6, 7} Un alfabeto octal.

{0, 1, 2, 3, 4, 5, 6, 7, 8, 9} Un alfabeto decimal.

{0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 𝐴, 𝐵, 𝐶, 𝐷, 𝐸, 𝐹} Un alfabeto hexadecimal.

{A, B, … , Y, Z, 𝑎, 𝑏, … , 𝑦, 𝑧} El alfabeto castellano.

{Α, Β, … , Ψ, Θ, 𝛼, 𝛽, … , 𝜓, 𝜃} El alfabeto griego.

{𝑎, 𝑒, 𝑖, 𝑜, 𝑢} Las vocales del castellano.

{. , −} El alfabeto Morse (otro alfabeto binario).

ASCII, un alfabeto usado en computadores, conformado por 128 símbolos que incluyen caracteres

imprimibles o que pueden ser vistos por humanos: alfabéticos (mayúsculas y minúsculas de

alfabetos latinos), dígitos, símbolos de uso frecuente (puntuación, por ejemplo) y caracteres

especiales para la comunicación y control de dispositivos.

UNICODE, otro alfabeto de computadores que cuenta con 216 caracteres. Además del alfabeto

ASCII, integra también símbolos pertenecientes a la mayoría de los idiomas del mundo.

A partir de los ejemplos anteriores, resulta natural afirmar que, en general, un alfabeto puede ser

cualquier conjunto arbitrario finito no vacío de símbolos. Esto nos lleva al dominio de la teoría de

conjuntos: un conjunto es una colección no ordenada de objetos conformada por elementos únicos.

Los alfabetos sirven para representar cosas. Por ejemplo, el alfabeto castellano representa sonidos y el

alfabeto de los dígitos representa cantidades. También podemos usar alfabetos para representar

conjuntos finitos de objetos primitivos de otros dominios, por ejemplo: la tabla periódica de los

7



elementos, conjunto de símbolos eléctricos y electrónicos, bases del ADN, operaciones de la lógica

proposicional, etc.

La principal utilidad de los alfabetos es ser una fuente inagotable de símbolos para crear estructuras

más complejas: secuencias o cadenas, llamadas palabras, que se consrtruyen mediante el uso de

operaciones bien definidas.

1.2 PALABRAS

1.2.1 DEFINICIÓN

Podemos definir la idea de palabra como un objeto compuesto, un contenedor en que los componentes

tienen un orden definido por la posición que ocupan y pueden repetirse en las diferentes posiciones de

la secuencia. Dicho de otro modo, una palabra es un objeto compuesto lineal. Una forma más elegante

es que una palabra 𝑤 corresponde a una secuencia finita no vacía de símbolos pertenecientes a un

alfabeto Σ, es decir, 𝑤 = 𝜎1𝜎2 … 𝜎𝑛, 𝜎𝑖 ∈ Σ. En esta definición, el subíndce i señala la posición relativa

del símbolo 𝜎𝑖 en la secuencia. Así, 𝜎𝑖 = 𝑤(𝑖) denota al i-ésimo caracter de la secuencia. Esta

definición corresponde a la definición de un string en programación: una estructura lineal de caracteres

donde se puede acceder a cada elemento en forma directa.

Ahora bien: Consideremos la siguiente línea de código:

String s="";

¿Qué ocurre con la definición anterior? Una palabra es una secuencia no vacía de símbolos. Sin

embargo, el string s no contiene símbolos. Esto crea la necesidad de definir una palabra especial: la

palabra vacía, denotada por 휀. Así, la palabra vacía es aquella que no tiene símbolos.

Denotaremos por Σ∗ al conjunto (infinito) de todas las palabras que es posible formar sobre un alfabeto

Σ. Σ∗ es libre sobre Σ, lo que significa que cada elemento de tiene una única representación con

elementos de Σ. Más formalmente:

Si 𝑥, 𝑦 ∈ Σ∗, con 𝑥 = 𝑎1𝑎2 … 𝑎𝑚 e 𝑦 = 𝑏1𝑏2 … 𝑏𝑛; 𝑚, 𝑛 ≥ 0 entonces 𝑥 = 𝑦 ⇔ 𝑛 = 𝑚 ∧ 𝑎𝑖 = 𝑏𝑖; 0 ≤𝑖 ≤ 𝑚 = 𝑛.

Es importante destacar que la palabra vacía tiene una característica especial: forma parte de los

universos de palabras generados por todos los distintos alfabetos.

1.2.2 OPERACIONES SOBRE PALABRAS

Existe una gran variedad de operaciones que podemos definir sobre palabras. Las hay abiertas, cerradas

y de diferentes aridades (cantidades de argumentos). Las principales son:

8



1. Longitud: para una palabra 𝑤, devuelve la cantidad de caracteres que la conforman. Es una

operación unaria abierta, que toma como argumento una palabra y retorna un valor natural, es decir,

su signatura es 𝑓: Σ∗ → ℕ. Esta operación se denota por |𝑤|.

Adicionalmente, se puede extender esta operación para determinar la cantidad de veces que aparece

un símbolo dado en una palabra. Esto se denota por |𝑤|𝜎.

Ejemplo 1.1:

Sea 𝑤 = 001010. |𝑤| = 6 y |𝑤|0 = 4.

2. Concatenación: es una operación binaria cerrada, que toma dos palabras como argumento y retorna

una tercera. En otras palabras, su signatura es 𝑓: Σ∗ × Σ∗ → Σ∗. Se define de la siguiente manera:

dadas 𝑢, 𝑣 ∈ Σ∗ tales que 𝑢 = 𝑎1𝑎2 … 𝑎𝑚 y 𝑣 = 𝑏1𝑏2 … 𝑏𝑛, 𝑢𝑣 = 𝑎1𝑎2 … 𝑎𝑚𝑏1𝑏2 … 𝑏𝑛.

Habitualmente no se utiliza ningún símbolo para esta operación, aunque en ocasiones se denota con

un punto.

Ejemplo 1.2:

Sean Σ = {0,1,2}, 𝑢 = 0110 y 𝑣 = 202. 𝑢𝑣 = 0110202. 𝑣𝑢 = 2020110.

3. Potencia de la concatenación: sea 𝑤 una palabra, entonces 𝑤𝑖 (𝑖 ≥ 0), denota 𝑖 concatenaciones de

𝑤, de modo que 𝑤𝑖 = 𝑤𝑤 … 𝑤 (𝑖 veces). Es importante recordar que 𝑤0 = 휀 y 𝑤1 = 𝑤.

Ejemplo 1.3:

Sea w = aba. 𝑤0 = 휀, 𝑤1 = 𝑎𝑏𝑎, 𝑤2 = 𝑎𝑏𝑎𝑎𝑏𝑎, 𝑤3 = 𝑎𝑏𝑎𝑎𝑏𝑎𝑎𝑏𝑎, etc.

La operación de concatenación permite definir inductivamente la noción de palabra:

a. 휀 y cada 𝜎 ∈ Σ son palabras.

b. Si 𝑤1 y 𝑤2 son palabras, entonces 𝑤3 = 𝑤1𝑤2 y 𝑤4 = 𝑤2𝑤1 también son palabras.

4. Segmentos de una palabra: estas operaciones unarias también son cerradas, es decir, también

retornan una palabra. La signatura para todas ellas es su signatura es 𝑓: Σ∗ → Σ∗.

Sean 𝑤, 𝑥, 𝑦, 𝑧 ∈ Σ∗ tales que 𝑤 = 𝑥𝑦𝑧. Entonces:

a. 𝑥 es prefijo de 𝑤. Corresponde a los primeros símbolos de 𝑤, y normalmente se especifica con

una longitud determinada 𝑙 menor o igual que la longitud de la palabra original, es decir, 0 ≤𝑙 ≤ |𝑤|.

b. 𝑧 es sufijo de 𝑤. Corresponde a los últimos símbolos de 𝑤, y también se especifica con una

longitud 𝑙 menor o igual que la longitud de la palabra original, es decir, 0 ≤ 𝑙 ≤ |𝑤|. c. 𝑦 es subcadena o segmento intermedio de 𝑤. Puede especificarse de dos maneras: con la

posición inicial en la palabra original y la longitud del segmento o bien con las posiciones

inicial y final en la palabra original.

Ejemplo 1.4:

Sea w = hola:

𝑃𝑟𝑒𝑓𝑖𝑗𝑜(𝑤, 0) = 휀

𝑃𝑟𝑒𝑓𝑖𝑗𝑜(𝑤, 1) = ℎ

9



𝑃𝑟𝑒𝑓𝑖𝑗𝑜(𝑤, 2) = ℎ𝑜

𝑃𝑟𝑒𝑓𝑖𝑗𝑜(𝑤, 3) = ℎ𝑜𝑙 𝑃𝑟𝑒𝑓𝑖𝑗𝑜(𝑤, 4) = ℎ𝑜𝑙𝑎

𝑆𝑢𝑓𝑖𝑗𝑜(𝑤, 0) = 휀

𝑆𝑢𝑓𝑖𝑗𝑜(𝑤, 1) = 𝑎

𝑆𝑢𝑓𝑖𝑗𝑜(𝑤, 2) = 𝑙𝑎

𝑆𝑢𝑓𝑖𝑗𝑜(𝑤, 3) = 𝑜𝑙𝑎

𝑆𝑢𝑓𝑖𝑗𝑜(𝑤, 4) = ℎ𝑜𝑙𝑎

𝑆𝑢𝑏𝑐𝑎𝑑𝑒𝑛𝑎(𝑤, 0, 0) = 휀

𝑆𝑢𝑏𝑐𝑎𝑑𝑒𝑛𝑎(𝑤, 2, 3) = 𝑜𝑙 𝑆𝑢𝑏𝑐𝑎𝑑𝑒𝑛𝑎(𝑤, 1, 4) = ℎ𝑜𝑙𝑎

𝑆𝑢𝑏𝑐𝑎𝑑𝑒𝑛𝑎(𝑤, 3, 3) = 𝑙

Es habitual que a los prefijos, sufijos y subcadenas que no son iguales a la palabra vacía o a la

palabra completa se les apellide como “propios”. Es importante señalar que prefijos y sufijos son

también subcadenas.

5. Reverso: es una operación unaria cerrada, es decir, de signatura 𝑓: Σ∗ → Σ∗. Se denota por 𝑤𝑅 y

retorna una palabra de igual longitud que 𝑤 pero con los caracteres en orden invertido.

Ejemplo 1.5:

Sea w = hola. 𝑤𝑅 = 𝑎𝑙𝑜ℎ.

Se denomina palíndromos a aquellas palabras tales que 𝑤 = 𝑤𝑅, como por ejemplo 휀, 𝑏, 𝑎𝑙𝑎 y

𝑠𝑜𝑙𝑜𝑠.

6. Subsecuencia de una palabra: es una nueva palabra que se obtiene eliminando una o más

subpalabras no vacías de la palabra original.

Ejemplo 1.6:

Sea w = hola. ℎ𝑎 es una subsecuencia.

7. Comparaciones: son operaciones relacionales entre dos palabras.

a. Igualdad: dos palabras son iguales si y solo si tienen igual longitud y contienen el mismo

símbolo en cada posición. Más formalmente, dadas 𝑤1 = 𝑎1𝑎2 … 𝑎𝑚, 𝑤2 = 𝑏1𝑎2 … 𝑏𝑛 ∈ Σ∗,

𝑤1 = 𝑤2 ⇔ 𝑚 = 𝑛 ∧ 𝑎𝑖 = 𝑏𝑖∀𝑖: 1 ≤ 𝑖 ≤ 𝑛. Así, esta operación binaria tendrá como resultado

un valor de verdad, por lo que su signatura es 𝑓: Σ∗ × Σ∗ → {verdadero, falso}. Cabe señalar

que la desigualdad o distinción equivale a la negación de la igualdad.

b. Menoridad y mayoridad: si los símbolos del alfabeto Σ tienen asociada una relación de orden

(es decir, Σ es un conjunto ordenado), es posible establecer una relación de orden lexicográfico

entre palabras. Así, una palabra 𝑤1 es menor que otra palabra 𝑤2 si y solo si:

𝑤1 es prefijo propio de 𝑤2.

10



𝑤1 y 𝑤2 tienen un prefijo común y el símbolo siguiente al prefijo en 𝑤1 es

lexicográficamente menor que el símbolo correspondiente en 𝑤2.

La mayoridad se define de manera similar.

Ejemplo 1.7:

hola = hola

hola ≠ chao

hola < ℎ𝑜𝑙𝑎𝑝

holap < ℎ𝑜𝑙𝑎𝑠

Existen muchas otras operaciones que se pueden definir sobre palabras, pero no serán consideradas en

este curso.

1.2.3 PROPIEDADES DE LAS OPERACIONES SOBRE PALABRAS

Es posible establecer relaciones entre algunas de las operaciones descritas en la sección anterior:

|휀| = 0 La longitud de la palabra vacía es 0.

|𝑢𝑣| = |𝑢| + |𝑣| La longitud de la concatenación es la suma de las parciales.

|𝑤𝑅| = |𝑤| El reverso no afecta a la longitud.

(𝑢𝑣)𝑤 = 𝑢(𝑣𝑤) Asociatividad de la concatenación.

𝑢𝑣 ≠ 𝑣𝑢 En general, la concatenación no es conmutativa.

휀𝑤 = 𝑤 = 𝑤휀 휀 es elemento neutro para la concatenación.

(𝑤𝑅)𝑅 = 𝑤 En general, una potencia par del reverso no altera la palabra.

((𝑤𝑅)𝑅)𝑅 = 𝑤 En general, una potencia impar del reverso entrega la palabra reversa.

(𝑢𝑣)𝑅 = 𝑣𝑅𝑢𝑅 Reverso de la concatenación de dos palabras.

(𝑢𝑣𝑤)𝑅 = 𝑤𝑅𝑣𝑅𝑢𝑅 Reverso de la concatenación de tres palabras (similar para más palabras).

휀𝑅 = 휀 Reverso de la palabra vacía.

𝜎𝑅 = 𝜎 Reverso de palabras de longitud 1.

Las demostraciones de estas propiedades pueden hacerse, principalmente, por inducción sobre la

longitud de las palabras.

Ejemplo 1.8:

Demostrar que (𝑢𝑣)𝑅 = 𝑣𝑅𝑢𝑅, con 𝑢𝑣 ∈ Σ∗.

a) Caso base:

Si |𝑣| = 0 ⇒ 𝑣 = 휀 y (𝑢휀)𝑅 = 𝑢𝑅 = 휀𝑅𝑢𝑅.

b) Definición de hipótesis de inducción:

Si |𝑣| = 𝑛, se asume que la proposición es verdadera.

c) Paso inductivo: demostrar que si |𝑣| = 𝑛 + 1, la proposición es verdadera.

Sea |𝑣| = 𝑛 + 1. Entonces 𝑣 = 𝑣′𝑎; 𝑎 ∈ Σ; 𝑣, 𝑣′ ∈ Σ∗; |𝑣′| = 𝑛.

(𝑢𝑣)𝑅 = (𝑢𝑣′𝑎)𝑅 = 𝑎(𝑢𝑣′)𝑅

11



Por hipótesis de inducción:

𝑎(𝑢𝑣′)𝑅 = 𝑎(𝑣′𝑅𝑢𝑅) = (𝑣′𝑎)𝑅𝑢𝑅

Problema propuesto: demuestre las demás propiedades.

1.3 LENGUAJES

1.3.1 DEFINICIÓN

Definición:

Un lenguaje es un conjunto de palabras sobre un alfabeto.

Se puede apreciar que la definición formal de lenguaje es muy simple. Solo señala que tenemos una

colección de palabras construidas sobre un conjunto dado de símbolos, pero no incorpora ningún tipo

de condición o restricción adicional. Así pues, los siguientes conjuntos de palabras son, en efecto,

lenguajes:

{ } El lenguaje vacío.

{휀} El lenguaje que contiene únicamente a la palabra vacía.

Σ∗ El lenguaje universo sobre un alfabeto Σ.

Conjuntos finitos de palabras {𝑤1, 𝑤2, … , 𝑤𝑛}; 𝑤𝑖 ∈ Σ∗. Por ejemplo, {0, 000, 010, 001, 1110} es

un lenguaje finito definido sobre el alfabeto {0, 1}.

Conjuntos infinitos de palabras {𝑤1, 𝑤2, 𝑤3, … }; 𝑤𝑖 ∈ Σ∗. Por ejemplo, el conjunto de todas las

secuencias binarias que comienzan y terminan con un 1 es un lenguaje infinito definido sobre el

alfabeto {0, 1}.

Otro aspecto importante es que, de acuerdo la definición anterior, no importa el significado de las

palabras o lo que ellas representen, pues esto corresponde a una asociación arbitraria que un observador

externo realiza entre el conjunto de palabras y un conjunto de “cosas” (objetos, acciones, etc.). Así, el

significado no es un atributo propio de las palabras en sí mismas.

Los lenguajes pueden usarse para representar muy variados objetos, concretos o abstractos, del mundo

real, incluyendo a los propios lenguajes. En este último caso, las palabras representan a los objetos que

conforman el conjunto. También es posible representar un objeto o un conjunto de objetos mediante

diferentes lenguajes, como ocurre por ejemplo con los números naturales (objetos abstractos). Estos

últimos pueden ser representados por diferentes lenguajes construidos sobre alfabetos distintos, cada

cual con sus propias reglas para asociar valores a las palabras. Algunos ejemplos son:

Palabras construidas sobre el alfabeto decimal {0, 1, 2, 3, 4 ,5 ,6 ,7, 8, 9}, donde los valores se

asocian mediante la notación posicional.

Los números romanos, construidos sobre el alfabeto {𝐼, 𝑉, 𝑋, 𝐿, 𝐶, 𝐷, 𝑀}. En este caso existen

palabras de Σ∗ que no representan ningún valor.

Números binarios, octales y hexadecimales, donde las palabras se construyen sobre los alfabetos {0, 1, }, {0, 1, 2, 3, 4 ,5 ,6 ,7} y {0, 1, 2, 3, 4 ,5 ,6 ,7, 8, 9, 𝐴, 𝐵, 𝐶, 𝐷, 𝐸, 𝐹} respectivamente y los

valores se asocian mediante la notación posicional.

12



1.3.2 OPERACIONES SOBRE LENGUAJES

Al igual que ocurre con las palabras, hay diversas operaciones, tanto abiertas como cerradas, que se

pueden realizar sobre los lenguajes. Las principales pueden ser agrupadas en dos categorías que se

muestran a continuación.

1.3.2.1 Operaciones de conjuntos

Son las operaciones típicas de la teoría de conjuntos, aplicadas teniendo en consideración que un

lenguaje no es más que un conjunto de palabras. El resultado es un nuevo lenguaje (conjunto).

1. Unión: retorna un lenguaje que contiene todas las palabras de los lenguajes implicados. Se define

como 𝐿1 ∪ 𝐿2 = {𝑤 ∈ Σ∗: 𝑤 ∈ 𝐿1 ∨ 𝑤 ∈ 𝐿2}.

2. Intersección: retorna el lenguaje conformado únicamente por las palabras comunes a ambos

lenguajes, es decir, 𝐿1 ∩ 𝐿2 = {𝑤 ∈ Σ∗: 𝑤 ∈ 𝐿1 ∧ 𝑤 ∈ 𝐿2}.

3. Diferencia: retorna el lenguaje conformado únicamente por las palabras del primer lenguaje que no

están contenidas en el segundo, es decir, 𝐿1 − 𝐿2 = {𝑤 ∈ Σ∗: 𝑤 ∈ 𝐿1 ∧ 𝑤 ∉ 𝐿2}.

4. Diferencia simétrica: retorna el lenguaje conformado únicamente por las palabras de ambos

lenguajes que no están contenidas en el otro, es decir, 𝐿1 △ 𝐿2 = (𝐿1 ∪ 𝐿2) − (𝐿1 ∩ 𝐿2).

5. Complemento: retorna el lenguaje conformado por todas las palabras que no están contenidas en el

lenguaje, es decir, 𝐿𝑐 = {𝑤 ∈ Σ∗: 𝑤 ∉ 𝐿}.

Ejemplo 1.9:

Sean 𝐿1 = {00, 01, 10, 11} y 𝐿2 = {0, 1, 00, 11}.

𝐿1 ∪ 𝐿2 = {0, 1, 00, 01, 10, 11}

𝐿1 ∩ 𝐿2 = {00, 11}

𝐿1 − 𝐿2 = {01, 10}

𝐿2 − 𝐿1 = {0, 1}

𝐿1 △ 𝐿2 = {0, 1, 01, 10}

𝐿1𝑐 = {𝑤 ∈ {0, 1}∗: |𝑤| ≠ 2}

1.3.2.2 Operaciones basadas en la concatenación de palabras

1. Concatenación de lenguajes: esta operación es similar al producto cartesiano. Entrega el lenguaje

resultante de concatenar todas las palabras del primer lenguaje como prefijo con todas las palabras

del segundo lenguaje como sufijo, es decir, 𝐿1𝐿2 = {𝑣𝑤 ∈ Σ∗: 𝑣 ∈ 𝐿1 ∧ 𝑤 ∈ 𝐿2}. En general,

𝐿1𝐿2 ≠ 𝐿2𝐿1.

13



Ejemplo 1.10:

Sean 𝐿1 = {01, 10} y 𝐿2 = {0, 1, 00, 11}.

𝐿1𝐿2 = {010, 100, 011, 101, 0100, 1000, 0111, 1011}

𝐿2𝐿1 = {001, 101, 0001, 1101, 010, 110, 0010, 1110}

Existen dos casos especiales a tener en consideración para esta operación: la concatenación con el

lenguaje vacío y la concatenación con el lenguaje que solo contiene a la palabra vacía:

𝐿𝜙 = 𝜙𝐿 = 𝜙.

{휀}𝐿 = 𝐿{휀} = 𝐿.

Nada impide la concatenación de un lenguaje consigo mismo, por lo que 𝐿𝐿 = 𝐿2. Esto lleva a la

noción de potencia de la concatenación de un lenguaje:

𝐿0 = {휀}

𝐿1 = 𝐿

𝐿2 = 𝐿𝐿

𝐿3 = 𝐿𝐿𝐿

…

Ejemplo 1.11:

Sea 𝐿 = {00, 11}.

𝐿0 = {휀}

𝐿1 = {00, 11}

𝐿2 = {0000, 0011, 1100, 1111}

𝐿3 = {000000, 001100, 110000, 111100, 000011, 001111, 110011, 111111}

2. Clausura reflexiva y transitiva de la concatenación (estrella de Kleene): se define como el conjunto

de todas las palabras que son concatenaciones múltiples de palabras del lenguaje. En notación

formal, 𝐿∗ = {𝑤 ∈ Σ∗: 𝑤 = 𝑤1𝑤2 … 𝑤𝑘; 𝑘 ≥ 0; 𝑤𝑖 ∈ 𝐿 ∀𝑖}. Dicho de otro modo, La clausura de un

lenguaje 𝐿 es la unión infinita de todas sus potencias de concatenación, es decir, 𝐿∗ = ⋃ 𝐿𝑖∞𝑖=0 .

Adicionalmente, se define la clausura positiva 𝐿+ como 𝐿+ = 𝐿∗ − {휀} = ⋃ 𝐿𝑖∞𝑖=1 .

1.3.2.3 Otras operaciones sobre lenguajes

Es posible definir diversas operaciones que generan otros lenguajes a partir de las operaciones sobre

palabras, entre las cuales se encuentran:

1. Reverso: 𝐿𝑅 = {𝑤: 𝑤𝑅 ∈ 𝐿}.

2. Prefijo: 𝑃𝑟𝑒𝑓𝑖𝑗𝑜(𝐿) = {𝑣 ∈ Σ∗: 𝑣𝑤 ∈ 𝐿}.

3. Sufijo: 𝑆𝑢𝑓𝑖𝑗𝑜(𝐿) = {𝑤 ∈ Σ∗: 𝑣𝑤 ∈ 𝐿}.

4. Prefijo: 𝑃𝑟𝑒𝑓𝑖𝑗𝑜(𝐿) = {𝑣 ∈ Σ∗: 𝑣𝑤 ∈ 𝐿}.

14



5. Subsecuencia: 𝑆𝑢𝑏𝑠𝑒𝑐𝑢𝑒𝑛𝑐𝑖𝑎(𝐿) = {𝑤 ∈ Σ∗: 𝑣𝑤𝑥 ∈ 𝐿}.

6. Cuociente derecho de un lenguaje por una palabra: 𝑣\𝐿 = {𝑤 ∈ Σ∗: 𝑣𝑤 ∈ 𝐿}.

7. Cuociente izquierdo de un lenguaje por una palabra: 𝐿/𝑤 = {𝑣 ∈ Σ∗: 𝑣𝑤 ∈ 𝐿}.

8. Cuociente derecho entre lenguajes: 𝐿1\𝐿2 = {𝑤 ∈ Σ∗: 𝑣𝑤 ∈ 𝐿2 ∧ 𝑣 ∈ 𝐿1}.

9. Cuociente izquierdo entre lenguajes: 𝐿1/𝐿2 = {𝑣 ∈ Σ∗: 𝑣𝑤 ∈ 𝐿1 ∧ 𝑤 ∈ 𝐿2}.

1.3.3 JERARQUÍA DE LOS LENGUAJES

Hasta ahora hemos visto que un lenguaje es un conjunto, normalmente infinito, de palabras. En

consecuencia, no es posible procesarlo directamente mediante un algoritmo, sino que hay que hacerlo

indirectamente mediante una representación o descripción finita (por comprensión en vez de por

extensión). De este modo, podemos tener un algoritmo para el cual podemos afirmar que termina.

No obstante, el problema de la representación de un lenguaje es, a su vez, el problema de su

generación. Así, el algoritmo representativo debe generar todas las palabras del lenguaje y ninguna que

no pertenezca a éste. Para este fin existen dos modelos finitos:

Expresiones regulares: corresponden a combinaciones de operandos y operadores para generar las

palabras de un lenguaje.

Gramáticas: son un conjunto de reglas de reescritura o reemplazo que permiten la generación de

palabras pertenecientes a un lenguaje.

Un problema importante a este respecto es el de la capacidad de estos mecanismos de representación

para abarcar el universo de lenguajes. Para comprender este problema, es necesario tener en

consideración lo siguiente:

El universo de palabras Σ∗ que se puede construir sobre un alfabeto Σ es infinito contable (Σ∗ ∼ N).

El conjunto de todos los lenguajes que se pueden crear sobre un alfabeto Σ, es decir, el conjunto

potencia de Σ∗, es infinito incontable (2Σ∗∼ 2𝑁).

Como tenemos una cantidad finita de representaciones y un número infinito de lenguajes, quedan

infinitos lenguajes sin representación.

En Ciencias de la Computación solo nos interesan aquellos lenguajes que podemos representar. Este

universo puede además ser dividido en clases o familias que comparten alguna propiedad. La principal

clasificación es la jerarquía de Chomsky, que establece 4 tipos de lenguajes representables de acuerdo a

los tipos de gramáticas que las generan:

Generales o tipo 0.

Sensibles al contexto (recursivamente enumerables) o tipo 1.

Libres de contexto o tipo 2.

Regulares o tipo 3.

Entre los tipos de lenguajes de esta clasificación existe además una jerarquía de inclusión, como se

puede apreciar en la figura 1.1, donde 𝑇𝑖𝑝𝑜 3 ⊂ 𝑇𝑖𝑝𝑜 2 ⊂ 𝑇𝑖𝑝𝑜 1 ⊂ 𝑇𝑖𝑝𝑜 0.

15



FIGURA 1.1: Jerarquía de Chomsky para los tipos de lenguajes representables.

1.4 EJERCICIOS

1. Defina alfabetos para representar:

a. Las caras de un dado.

b. Las tiradas simultáneas de 2 monedas.

2. Defina un alfabeto de 3 símbolos y muestre Σ, Σ2, Σ3 y Σ∗.

3. Sean Σ = {0, 1, 2}, 𝑥 = 00, 𝑦 = 1, 𝑧 = 210. Defina e indique las longitudes de las siguientes

palabras: 𝑥𝑦, 𝑥𝑧, 𝑦𝑧, 𝑥𝑦𝑧, (𝑥𝑦)𝑅, 𝑥3, 𝑥2𝑦2, (𝑥𝑦)2, (𝑧𝑥𝑥)3.

4. Describir en lenguaje natural las palabras pertenecientes al lenguaje 𝐿 = {0𝑛1𝑛: 𝑛 ≥ 1}.

5. Describir en lenguaje natural las palabras pertenecientes al lenguaje 𝐿 = {0𝑖1𝑗: 0 ≤ 𝑖 ≤ 𝑗}.

6. Describir formalmente (en notación de conjuntos) el lenguaje de las palabras formadas por ceros y

unos, en las que hay el doble de ceros que de unos y todos los ceros van delante de los unos.

7. Describir formalmente el lenguaje formado por palabras que comienzan y terminan en a teniendo

entre medios tres o más bes.

8. Describa formalmente el lenguaje de todas las palabras en {#, &}∗ que comienzan y terminan con #,

y tienen todos los & juntos.

16



9. Dado el lenguaje 𝐿 = {𝑎, 𝑎𝑏, 𝑏𝑎}, muestre las palabras pertenecientes a los lenguajes 𝐿0, 𝐿1 y 𝐿2.

10. Para el alfabeto Σ = {1, 2, 3, 𝑎, 𝑏, 𝑐}, y los lenguajes 𝐿1 = {1, 2, 3} y 𝐿2 = {𝑎, 𝑏, 𝑐}, defina los

lenguajes 𝐿1 ∪ 𝐿2, 𝐿1𝐿2 y (𝐿1𝐿2)2.

11. Sea el lenguaje 𝐿 = {𝑎𝑏, 𝑎𝑎, 𝑏𝑎𝑎} ⊆ {𝑎, 𝑏}∗. Indique cuáles de las siguientes palabras pertenecen a

𝐿+: 𝑎𝑏𝑎𝑎, 𝑎𝑏𝑎𝑏, 𝑎𝑏𝑎𝑎𝑏𝑎𝑎𝑎𝑏𝑎𝑎, 𝑎𝑎𝑎𝑎𝑏𝑎𝑎𝑎𝑎, 𝑏𝑎𝑎𝑎𝑎𝑎𝑏𝑎𝑎𝑎𝑎𝑏, 𝑏𝑎𝑎𝑎𝑎𝑎𝑏𝑎𝑎, ε.

12. Sean 𝐿1 = {𝑎𝑛𝑏𝑛+1: 𝑛 ≥ 1} y 𝐿2 = {𝑤 ∈ {𝑎, 𝑏}∗: |𝑤|𝑎 = |𝑤|𝑏}. ¿Es 𝐿1 = 𝐿1∗? ¿Es 𝐿2 = 𝐿2

∗?

13. Demostrar que para todo lenguaje 𝐿 se verifica que 𝐿∗ = 𝐿∗𝐿∗.

14. Dado el lenguaje 𝐿 = {𝑎, 𝑎𝑏𝑏, 𝑏𝑎, 𝑏𝑏𝑏𝑎, 𝑏}, especifique el conjunto de todas las palabras en 𝐿∗ con

una longitud menor que 3.

15. Dados 𝐿1 = {𝑟𝑟, 𝑠𝑠, 𝑡𝑡, 𝑟𝑠, 𝑠𝑡}, 𝐿2 = {𝑟𝑠, 𝑠𝑟, 𝑠𝑡, 𝑡𝑠} y 𝑤 = 𝑟𝑟𝑠𝑡𝑠𝑡𝑟𝑟𝑡𝑠𝑠𝑡𝑟, muestre:

a. 𝐿3 = 𝐿1 ∪ 𝐿1.

b. 𝐿4 = 𝐿1 ∩ 𝐿1𝑅.

c. 𝐿5 = 𝐿4𝐿2.

d. |𝑤|, |𝑤|𝑟, |𝑤|𝑠, |𝑤|𝑡.

17



2 LENGUAJES REGULARES

En la unidad anterior se definieron diversas operaciones sobre lenguajes y se dio a conocer la jerarquía

de los lenguajes que pueden ser representados de manera finita. La clase más simple corresponde a los

lenguajes regulares, que pueden ser definidos como aquellos que son originados por las operaciones de

unión, concatenación y estrella de Kleene.

Definición:

Un lenguaje es regular si y solo si puede ser generado constructivamente por composición de

operaciones regulares y operandos de lenguajes regulares a partir de los lenguajes básicos 𝜙, {휀} y {𝜎}∀𝜎 ∈ Σ.

2.1 GRAMÁTICAS

Se había mencionado anteriormente que uno de los mecanismos para representar lenguajes de manera

finita son las gramáticas. Éstas pueden definirse como un sistema o algoritmo para la generación de

palabras basado en el reemplazo de subsecuencias de acuerdo a determinadas reglas o producciones.

Una producción está conformada por un lado izquierdo o antecedente y un lado derecho o consecuente.

El mecanismo de funcionamiento es simple: cada vez que se encuentre el antecedente en alguna

palabra parcialmente generada, éste debe ser reemplazado por el consecuente formando, en

consecuencia, una nueva palabra total o parcialmente generada.

Definición:

Una gramática 𝐺 es una tupla de 4 elementos, 𝐺 = (Σ, N, P, S), donde:

Σ es un conjunto finito no vacío que contiene los símbolos que conforman el alfabeto del lenguaje

generado. También se conoce como conjunto de terminales.

N es un conjunto finito no vacío que contiene símbolos auxiliares variables o de reemplazo

denominados no terminales, que facilitan la escritura de las producciones. Σ ∪ N conforman el

vocabulario de la gramática.

P es un conjunto finito no vacío de producciones.

S ∈ N es el símbolo inicial a partir del cual, mediante la aplicación sucesiva de producciones, se

puede generar cualquier palabra válida del lenguaje.

Ejemplo 2.1:

La siguiente gramática genera palíndromos sobre el alfabeto binario. Es importante destacar que

la palabra vacía no pertenece al vocabulario de 𝐺.

𝐺 = (Σ, N, P, S): Σ = {0, 1}

N = {A}

P = {A → 0A0 | 1A1 | 0 | 1 | ε}

S = A

A continuación se muestra una notación alternativa para el mismo ejemplo.

18



𝐺 = (Σ, N, P, S): Σ = {0, 1}

N = {⟨secuencia⟩}

P = {⟨secuencia⟩ ∷= 0⟨secuencia⟩0 | 1⟨secuencia⟩1 | 0 | 1 | ε}

S = ⟨secuencia⟩

Es importante destacar algunos aspectos de notación, pues es fundamental en la escritura de gramáticas

poder distinguir claramente entre símbolos terminales y no terminales. Las convenciones que se

emplean son las siguientes:

1. Los terminales o elementos de Σ se denotan por:

Letras latinas minúsculas (𝑎, 𝑏, 𝑐, …).

Palabras en negrita o subrayado (𝒊𝒇, 𝑤ℎ𝑖𝑙𝑒 , … ).

Palabras encerradas entre comillas simples o dobles (‘ab’, “0110”, …).

2. Los no terminales o elementos de N se denotan por:

Letras latinas mayúsculas (𝐴, 𝐵, 𝐶, …).

Palabras encerradas entre paréntesis triangulares (⟨secuencia⟩, ⟨entero⟩, …).

3. Se usan letras griegas minúsculas (𝛼, 𝛽, 𝛾, …) para designar indistintamente símbolos terminales o

no terminales, o incluso secuencias de ellos.

4. Una producción de 𝑃 se denota por 𝛼 → 𝛽 ó bien por 𝛼 ∷= 𝛽. Tanto el antecedente como el

consecuente pueden estar conformados por cualquier secuencia no vacía de terminales y no

terminales. En el caso del consecuente, puede aparecer también la palabra vacía.

5. Las reglas 𝛼 → 𝛽, 𝛼 → 𝛾, 𝛼 → 𝛿 se denotan también por 𝛼 → 𝛽 | 𝛾 | 𝛿.

Ahora que está bien definida la idea de gramática, es importante estudiar cómo se generan las palabras.

Para una gramática 𝐺, se dice que una secuencia 𝛼′ = 𝛼1𝛼𝛼2 ∈ (Σ ∪ N)∗ genera o deriva otra

secuencia 𝛽′ = 𝛼1𝛽𝛼2 ∈ (Σ ∪ N)∗, operación denotada por 𝛼′ ⇒ 𝛽′, si y solo si ∃𝛼 → 𝛽 ∈ 𝑃 para

𝛼1, 𝛼2, 𝛼, 𝛽 ∈ (Σ ∪ N)∗.

Observación:

1. ⇒n es una derivación de n pasos y ⇒∗ corresponde a la clausura reflexiva y transitiva de ⇒.

2. El conjunto de las palabras generadas sobre (Σ ∪ N)∗ a partir del símbolo inicial 𝑆 se denota por

𝑆(𝐺).

Ejemplo 2.2:

Retomemos la gramática del ejemplo anterior, 𝐺 = ({0, 1}, {A}, {A → 0A0 | 1A1 | 0 | 1 | ε}, A).

Para generar la secuencia 001101100, se tienen los siguientes pasos:

A ⇒ 0A0 ⇒ 00A00 ⇒ 001A100 ⇒ 0011A1100 ⇒ 001101100.

Las derivaciones para la palabra 11, en cambio, son las siguientes:

A ⇒ 1A1 ⇒ 11.

En este caso, para la segunda derivación se hace uso de la producción A → ε.

19



También es posible representar las derivaciones en forma gráfica mediante un árbol. Si bien en

ocasiones este mecanismo resulta más cómodo y claro, puede ser inadecuado en ocasiones porque no

muestra el orden en que se realizan las sustituciones. La figura 2.1 muestra esta representación para las

secuencias generadas en el ejemplo anterior.

FIGURA 2.1: Árboles de derivación para las palabras (a) 001101100 y (b) 11 con 𝐺 =

({0, 1}, {A}, {A → 0A0 | 1A1 | 0 | 1 | ε}, A).

El ejemplo anterior es bastante sencillo, puesto que se trata de una gramática con un único no terminal.

Pero podemos tener una gran cantidad de ellos, como ocurre al crear la gramática de un lenguaje de

programación. Así pues, el siguiente ejemplo muestra una gramática que genera el lenguaje de los

números naturales.

Ejemplo 2.3:

𝐺 = (Σ, N, P, S): Σ = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9}

N = {⟨significativo⟩, ⟨digito⟩, ⟨secuencia⟩, ⟨natural⟩}

P = {⟨significativo⟩ → 1 | 2 | 3 | 4 | 5 |6 | 7 |8 | 9, ⟨digito⟩ →0 |1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9, ⟨secuencia⟩ → ⟨digito⟩⟨secuencia⟩ | ε, ⟨natural⟩ →0 | ⟨significativo⟩⟨secuencia⟩}

S = ⟨natural⟩

Note que 𝐺 respeta las convenciones de notación habituales al no permitir ceros a la izquierda.

La figura 2.2 muestra los árboles de derivación para generar varios números.

20



FIGURA 2.2: Árboles de derivación para las palabras (a) 0, (b) 5 y (c) 3907.

La noción de derivación de palabras conduce a la definición de lenguaje generado por una gramática 𝐺,

denotado por 𝐿(𝐺). Corresponde al conjunto de palabras generadas a partir del símbolo inicial 𝑆 y que

solo contienen símbolos terminales. Matemáticamente: 𝐿(𝐺) = 𝑆(𝐺) ∩ Σ∗ = {𝑤 ∈ Σ∗: 𝑆 ⇒∗ w}.

En general, pueden existir varias gramáticas que generen un mismo lenguaje, lo que las hace

equivalentes. Así, 𝐺 ≡ 𝐺′𝑠𝑠𝑖 𝐿(𝐺) = 𝐿(𝐺′).

21



2.2 GRAMÁTICAS REGULARES

Anteriormente habíamos estudiado la jerarquía de lenguajes de Chomsky, y definimos además lo que

es un lenguaje regular. Una manera de representar este tipo de lenguajes es mediante gramáticas

regulares.

Se dice que una gramática 𝐺 = (Σ, N, P, S) es lineal si y solo si en cada regla de producción existe a lo

más un no terminal en el lado derecho. En otras palabras, todas las producciones son de la forma A →uBv o bien A → w, con A, B ∈ 𝑁 y 𝑢, 𝑣, 𝑤 ∈ Σ∗. Hay dos casos interesantes a considerar en esta

definición:

𝑢 = ε: las producciones son de la forma A → B𝑣 o bien A → w. En este caso, se dice que 𝐺 es

lineal izquierda.

𝑣 = ε: las producciones son de la forma A → uB o bien A → w. En este caso, se dice que 𝐺 es lineal

derecha.

Las gramáticas lineales derechas se denominan también gramáticas regulares, y son las que generan los

lenguajes regulares.

Ejemplo 2.4:

𝐺 = ({a, b}, {S, A, B, C}, {S → aC, A → aA|b, B → bB|b, C → A|B}, s)

Esta gramática genera el lenguaje sobre el alfabeto {a, b} cuyas palabras comienzan con a y

terminan con b, y entre medio pueden contener solo as o solo bes:

𝐿 = {𝑎𝑏, 𝑎𝑎𝑏, 𝑎𝑏𝑏, 𝑎𝑎𝑎𝑏, 𝑎𝑏𝑏𝑏, 𝑎𝑎𝑎𝑎𝑏, 𝑎𝑏𝑏𝑏𝑏, … }

2.3 EXPRESIONES REGULARES

Las expresiones regulares (ER) son otro mecanismo finito de representación para los lenguajes

regulares. Trabajan mediante operandos y operadores que pueden estar agrupados mediante paréntesis,

en forma similar a las expresiones algebraicas. No obstante, en lugar de representar números, las

expresiones regulares representan conjuntos de palabras.

Las expresiones regulares cuentan con las tres operaciones regulares básicas de los lenguajes:

Unión, denotada por +.

Concatenación: no se denota con operador o bien se utiliza un punto.

Clausura o estrella de Kleene, denotada por *.

Los operadores anteriores pueden ser aplicados a diversos operandos:

Palabra nula o conjunto vacío (𝜙).

Palabra vacía (휀).

Subexpresiones regulares delimitadas por paréntesis.

Una definición más formal es que una ER 𝑟 que representa un lenguaje 𝐿 sobre un alfabeto Σ es una

palabra construida sobre el alfabeto Σ ∪ {(, ), ∅, ε, +,∗}. No obstante, no toda palabra construida sobre

22



este alfabeto extendido es una expresión regular. Solo lo son aquellas palabras construidas siguiendo

las siguientes reglas de construcción inductiva:

1. 𝜙, 휀 y cada 𝜎 ∈ Σ son expresiones regulares (caso base).

2. Si 𝑟1 y 𝑟2 son ER, entonces:

a. 𝑟1 + 𝑟2 es una ER.

b. 𝑟1𝑟2 es una ER.

3. Si 𝑟 es una ER, entonces:

a. 𝑟∗ es una ER.

b. (𝑟) es una ER. { } {𝜎} 𝐿1 ∪ 𝐿2 𝐿1𝐿2 𝐿∗

4. Solo aquellas palabras que cumplan las reglas anteriores son ER.

Podemos representar el lenguaje de las expresiones regulares sobre un alfabeto Σ mediante el modelo

de gramática estudiado en la sección anterior:

𝐺 = (ΣG, N, P, S): ΣG = {(, ), ∅, ε, +,∗, 𝐬í𝐦𝐛𝐨𝐥𝐨}

N = {R}

P = {R → RR | R + R | R∗ | (R) | ε | ∅ | 𝐬í𝐦𝐛𝐨𝐥𝐨}

S = R

Note que, en este caso, el terminal símbolo representa cualquier 𝜎 ∈ Σ.

Se puede utilizar la definición vista anteriormente para visualizar cómo las ER representan (o generan)

lenguajes, según se muestra en la tabla 2.1.

TABLA 2.1: ER y lenguaje generado.

ER Lenguaje generado

∅ { } El lenguaje vacío.

ε {ε} El lenguaje que solo contiene la palabra vacía.

𝜎 ∈ Σ {𝜎} El lenguaje que solo contiene la palabra conformada por el símbolo σ.

𝑟1 + 𝑟2 𝐿1 ∪ 𝐿2 La unión de los lenguajes generados por cada subexpresión.

𝑟1𝑟2 𝐿1𝐿2 La concatenación de los lenguajes generados por cada subexpresión.

𝑟∗ 𝐿∗ El lenguaje estrella de Kleene del lenguaje representado por r.

(𝑟) 𝐿 No se altera el lenguje representado.

Ejemplo 2.5:

Habíamos mostrado anteriormente una gramática regular que genera el lenguaje sobre el

alfabeto {a, b} cuyas palabras comienzan con a y terminan con b, y entre medio pueden contener

solo as o solo bes:

𝐺 = ({a, b}, {S, A, B, C}, {S → aC, A → aA|b, B → bB|b, C → A|B}, s)

23



Este mismo lenguaje puede ser representado de manera mucho más sencilla mediante una

expresión regular:

𝑟 = 𝑎(𝑎∗ + 𝑏∗)𝑏

Una restricción importante de las expresiones regulares es que no podemos trabajar con cantidades fijas

de símbolos, a menos que los incluyamos explícitamente.

Ejemplo 2.6:

No podemos representar mediante una ER el lenguaje sobre el alfabeto {a, b} cuyas palabras

tienen igual cantidad de as que de bes, y tienen todas las as al principio.

La primera aproximación que podríamos considerar es la ER 𝑟1 = 𝑎∗𝑏∗. En ella podemos tener

0 ó más as y 0 ó más bes, y además aparecen todas las as al comienzo. No obstante, nada

garantiza que necesariamente tenemos que tener igual cantidad de ambos símbolos. La palabra

𝑢 = 𝑎𝑎𝑎𝑏𝑏𝑏 pertenece al lenguaje descrito y al lenguaje representado por 𝑟1. No obstante, las

palabras 𝑣 = 𝑏𝑏𝑏𝑏 y 𝑤 = 𝑎𝑎𝑏𝑏𝑏𝑏𝑏 no pertenecen al lenguaje descrito pero sí al lenguaje

representado por 𝑟1.

La segunda opción sería explicitar cada subexpresión y hacer la unión de ellas, lo que resulta

equivalente a escribir el lenguaje por extensión, es decir, 𝑟2 = 휀 + 𝑎𝑏 + 𝑎𝑎𝑏𝑏 + 𝑎𝑎𝑎𝑏𝑏𝑏 + ⋯.

2.3.1 PROPIEDADES BÁSICAS DE LAS EXPRESIONES REGULARES

Sean r, s, t expresiones regulares. Entonces, se cumplen las siguientes propiedades:

𝑟 + 𝑠 = 𝑠 + 𝑟 + es conmutativa.

𝑟 + (𝑠 + 𝑡) = (𝑟 + 𝑠) + 𝑡 + es asociativa.

∅ + 𝑟 = 𝑟 ∅ es neutro para +.

𝑟(𝑠𝑡) = (𝑟𝑠)𝑡 La concatenación es asociativa.

𝑟𝑠 ≠ 𝑠𝑟 En general, la concatenación no es conmutativa.

휀𝑟 = 𝑟 = 𝑟휀 휀 es elemento neutro para la concatenación.

∅𝑟 = ∅ = 𝑟∅ ∅ es elemento nulo para la concatenación.

𝑟(𝑠 + 𝑡) = 𝑟𝑠 + 𝑟𝑡 Distributividad entre + y concatenación.

(𝑟 + 𝑠)𝑡 = 𝑟𝑡 + 𝑠𝑡 Distributividad entre + y concatenación.

∅∗ = 휀∗ = 휀

(𝑟 + 𝑠)∗ = (𝑟∗ + 𝑠∗)∗ = (𝑟∗𝑠∗)∗ = (𝑠∗𝑟∗)∗ = 𝑟∗(𝑠𝑟∗)∗ = 𝑠∗(𝑟𝑠∗)∗ = (𝑟∗𝑠)∗𝑟∗ = (𝑠∗𝑟)∗𝑠∗

(𝑟 + 휀)∗ = 𝑟∗ Relación entre * y 휀.

𝑟∗𝑟∗ = 𝑟∗∗ = 𝑟∗ * es idempotente.

𝑟+ = 𝑟𝑟∗

𝑟+ + 휀 = 𝑟∗

(𝑟∗)+ = (𝑟+)∗ = 𝑟∗

Las propiedades anteriores conducen a pensar que pueden existir diversas expresiones regulares que

representen el mismo lenguaje, es decir, que sean equivalentes: 𝑟1 ≡ 𝑟2 ⇔ 𝐿(𝑟1) = 𝐿(𝑟2).

24



Ejemplo 2.7:

Pruebe, usando propiedades básicas, que 𝑟1 = (01 + 10)∗ y 𝑟2 = (01 + 10 +휀)∗(01)∗(10)∗∗(01(10)∗)∗ + 0∅1 son equivalentes.

𝑟2 = (01 + 10 + 휀)∗(01)∗(10)∗∗(01(10)∗)∗ + 0∅1 =

= (01 + 10 + 휀)∗(01)∗(10)∗∗(01(10)∗)∗ + ∅ =

= (01 + 10 + 휀)∗(01)∗(10)∗∗(01(10)∗)∗ =

= (01 + 10)∗(01)∗(10)∗∗(01(10)∗)∗ =

= (01 + 10)∗(01)∗(10)∗∗(01(10)∗)∗ =

= (01 + 10)∗(01)∗(10)∗(01(10)∗)∗ =

= (01 + 10)∗(01)∗(10)∗(01(10)∗)∗ =

= (01 + 10)∗(01)∗(01 + 10)∗ =

= (01 + 10)∗(01)∗(01 + 10)∗ =

= (01 + 10)∗(01)∗(01)∗(10(01)∗)∗ =

= (01 + 10)∗(01)∗(10(01)∗)∗ =

= (01 + 10)∗(01 + 10)∗ =

= (01 + 10)∗ =

= 𝑟1

2.3.2 NOTACIONES PARA EXPRESIONES REGULARES

Existen diversas notaciones, tanto textuales como gráficas, para representar expresiones regulares,

además de la que hemos empleado hasta ahora.

1. Texto:

a. Unión o selección (condicional):

If C then A else B;

b. Concatenación (secuencia incondicional):

A;B;

c. Clausura o estrella de Kleene (iteración o repetición):

while C do A; (0 ó más veces)

do A while C; (clausura positiva: 1 ó más veces)

2. Jackson:


X sel

alt A;

alt B;

endsel;

25




X seq A; B endseq;


X iter A enditer;

3. Diagramas de sintaxis o de ferrocarril (Conway):



26




(0 ó más veces)

(1 ó más veces)

4. Yourdon:


A | B


A + B


{A} (0 ó más veces)

1{A} (clausura positiva: 1 ó más veces)

2.4 AUTÓMATAS FINITOS

Hasta ahora, hemos estudiado mecanismos para generar y representar lenguajes regulares. Sin

embargo, no hemos abordado mecanismos de reconocimiento de lenguajes regulares que nos permitan

automatizar esta tarea. Para este fin estudiaremos los autómatas finitos, correspondientes a un tipo

particular de máquinas de estados y transiciones.

2.4.1 DEFINICIÓN

Un autómata finito (AF) es una máquina discreta de estados que tiene las siguientes características:

Es sensible al medio, es decir, puede leer (recibir entradas).

Cuenta con un número finito de estados internos.

Puede reaccionar frente a las entradas cambiando su estado.

En general, no tiene mecanismos explícitos para emitir una salida, es decir, No tiene salidas; es

decir, no es capaz de modificar su medio.

El esquema general de funcionamiento es que, en todo momento, el autómata se encuentra en algún

estado o (conjunto de estados) activo o actual, a la espera de recibir una nueva entrada. Cuando esto

ocurre, reacciona cambiando su estado actual de acuerdo a transiciones bien definidas y espera una

nueva entrada, y así sucesivamente. A cada instante, el AF solo conoce su estado actual, y no lleva un

27



registro de sus estados anteriores. No obstante, el estado actual actúa como síntesis de esa trayectoria,

pues el alcanzar un estado depende de los estados anteriores.

Un ejemplo adecuado para comprender esta idea es el funcionamiento de un ascensor: Cada piso

corresponde a un estado, y en todo momento el ascensor sabe dónde se encuentra. Al apretarse un

botón, el ascensor debe dirigirse a un nuevo piso de acuerdo a la entrada recibida.

Además de los AF descritos, existen máquinas semejantes que incorporan la capacidad de proporcionar

una salida. Éstas últimas reciben el nombre de transductores finitos.

Desde una perspectiva de implementación física, un AF puede verse como un dispositivo conformado

por los siguientes elementos, algunos de los cuales se ilustran en la figura 2.3:

Una cinta infinita que contiene símbolos pertenecientes a un alfabeto, formando una secuencia de

entrada.

Un cabezal Un cabezal capaz de leer un símbolo de la cinta y desplazarse automáticamente hacia la

derecha.

Un control finito, compuesto de una cantidad, también finita, de estados y una especificación

(transición) que permite determinar el estado siguiente de acuerdo a la lectura realizada en la cinta.

Algunos estados distinguibles dentro del conjunto de estados:

Un estado inicial.

Uno o más estados finales o de aceptación (que indican que la secuencia pertenece a un

lenguaje dado).

FIGURA 2.3: modelo de un autómata finito.

Una vez conocidos los elementos de un AF, estamos en condiciones de describir el proceso de

aceptación o reconocimiento de una palabra como parte de un lenguaje regular dado, aunque no se

tocará aún el tema de la construcción de estas máquinas.

Inicialmente, el cabezal lector debe estar situado en el primer símbolo de la cadena de entrada y el AF

debe encontrarse en su estado inicial. A continuación, el cabezal lee el símbolo y se desplaza hacia la

derecha en una posición, y el AF modifica su estado de acuerdo a la entrada recibida y a una

especificación de transición. La lectura de símbolos y el cambio de estado se repiten sucesivamente

hasta que no queden símbolos por leer en la entrada y, en consecuencia, el AF no realice nuevos

28



cambios de estado. Una vez alcanzado este punto, es el observador quien debe determinar si la palabra

leída pertenece o no al lenguaje regular dado. Para este fin, basta observar el estado en que se encuentra

el autómata. Si es uno de los distinguidos como final o de aceptación, entonces la palabra de la entrada

pertenece al lenguaje. En caso contrario, la palabra no se acepta.

Definición:

Un AF M es una tupla de 5 elementos, 𝑀 = (𝑄, Σ, 𝛿, 𝑞0, 𝐹), donde:

𝑄 ≠ ∅ es un conjunto finito no vacío de estados.

Σ es el alfabeto del lenguaje reconocido y contiene los símbolos que conforman las palabras de la

entrada.

𝛿 corresponde a la especificación de transición entre estados en base al estado actual y al símbolo

leído desde la entrada.

𝑞0 ∈ 𝑄 es el estado inicial.

F ⊆ Q es el conjunto de estados finales.

2.4.2 TIPOS DE AUTÓMATAS FINITOS

Podemos distinguir dos grandes clases de AF, dependiendo de la forma que tenga la definición de

transición 𝛿: determinísticos y no determinísticos.

2.4.2.1 Autómata finito determinístico (AFD)

Su función de transición 𝛿 es de la forma 𝛿: 𝑄 × Σ → Q. En otras palabras, dado un estado actual y un

símbolo de entrada, retorna el nuevo estado al que debe pasar el AFD. Así, la transición 𝛿(𝑞, 𝜎) = 𝑞′ indica que, al estar en el estado 𝑞 y leer el símbolo 𝜎, el AFD pasa al siguiente estado 𝑞′. El cabezal

pasa automáticamente al símbolo siguiente.

Cabe destacar que de esta definición de 𝛿 se desprenden las siguientes conclusiones:

Al encontrarse el AFD en un estado y leer un símbolo de entrada, hay uno y solo un estado al que

puede avanzar.

No puede haber un cambio de estado si no se ha leído un símbolo desde la entrada.

Para todo estado y todo símbolo del alfabeto debe existir una transición definida, por lo que la

cantidad de transiciones de un AFD es de |𝑄| × |Σ|.

Ejemplo 2.8:

Considere el AFD 𝑀 = (𝑄, Σ, 𝛿, 𝑞0, 𝐹), donde:

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

Σ = {𝑎, 𝑏}

𝛿 = {𝛿(𝑞0, 𝑎) = 𝑞1, 𝛿(𝑞0, 𝑏) = 𝑞3, 𝛿(𝑞1, 𝑎) = 𝑞1, 𝛿(𝑞1, 𝑏) = 𝑞2, 𝛿(𝑞2, 𝑎) = 𝑞1,𝛿(𝑞2, 𝑏) = 𝑞2, 𝛿(𝑞3, 𝑎) = 𝑞3, 𝛿(𝑞3, 𝑏) = 𝑞3}

𝑞0 = 𝑞0

𝐹 = {𝑞2}

29



Otra manera de representar la función de transición es mediante una tabla, como se muestra en

la tabla 2.2.

TABLA 2.2: Función de transición para el AFD M.

𝑞 \ 𝜎 𝑎 𝑏

𝑞0 𝑞1 𝑞3

𝑞1 𝑞1 𝑞2

𝑞2 𝑞1 𝑞2

𝑞3 𝑞3 𝑞3

Gráficamente, se puede mostrar M como en la figura 2.4.

FIGURA 2.4: Representación gráfica de M.

Resulta interesante destacar que la figura 2.4 ilustra todos los elementos presentes en la

definición formal de M:

El conjunto de estados 𝑄 está denotado por el conjunto de círculos rotulados.

El alfabeto Σ aparece tácitamente reflejado en las transiciones.

Cada transición de 𝛿 tiene un estado de origen, señalado por la base de la flecha; un estado

de destino, señalado por la cabeza de la flecha, y un símbolo asociado.

El estado inicial 𝑞0 está señalado con una flecha no rotulada que incide en él.

Cada estado final de 𝐹, en este caso solo 𝑞2, se denota por un doble círculo.

Como punto de partida para algunas definiciones debemos considerar que el concepto básico necesario

para describir la operación de un AFD es la configuración o descripción instantánea, es decir, el estado

en que se encuentra el sistema completo en un instante de tiempo. Así, la configuración del AFD en un

instante dado está determinada por dos variables: el estado del AFD en que se encuentra el control

finito y la posición del cabezal de lectura, dada por el sufijo aún no leído de la palabra de entrada

(incluido el símbolo en que se encuentra el cabezal). Así, una configuración es un par ordenado (𝑞, 𝑤) ∈ 𝑄 × Σ∗, donde 𝑞 es el estado actual y 𝑤 es el sufijo de la entrada que aún no ha sido leído,

incluyendo el símbolo señalado por el cabezal. La configuración inicial siempre está dada por el estado

inicial del autómata y el primer símbolo de la entrada.

30



La siguiente noción importante es la de paso de computación, correspondiente a un cambio elemental

de configuración. En otras palabras, es una relación binaria entre dos configuraciones sucesivas de un

AFD M, denotada por el símbolo ⊢. Estas dos configuraciones están relacionadas mediante una

transición, es decir:

(𝑞, 𝑤) ⊢ (𝑞′, 𝑤′) ⇔ ∃𝜎 ∈ Σ ∶ 𝑤 = 𝜎𝑤′ ∧ 𝛿(𝑞, 𝜎) = 𝑞′

Cabe destacar que ⊢𝑛 denota 𝑛 pasos de computación y que ⊢∗ corresponde a la clausura reflexiva y

transitiva de ⊢.

En tercer lugar, es necesario definir el concepto de aceptación de una palabra 𝑤 ∈ Σ∗. Se dice que es

aceptada por un AFD M si y solo si, comenzando desde la configuración inicial, al terminar de leer 𝑤

el AFD se encuentra en un estado final, es decir:

𝑤 ∈ Σ∗ es aceptada por M ⇔ (𝑞0, 𝑤) ⊢∗ (𝑞, 휀) ∧ 𝑞 ∈ 𝐹

Ejemplo 2.9:

Consideremos el AFD del ejemplo 2.8 y la entrada 𝑤 = abbaab. La configuración inicial de M

está dada por (𝑞0, abbaab). Tras el primer paso de computación, se tiene:

(𝑞0, abbaab) ⊢ (𝑞1, bbaab)

La secuencia de pasos de computación siguientes corresponde a:

(𝑞1, bbaab) ⊢ (𝑞2, baab) ⊢ (𝑞2, aab) ⊢ (𝑞1, ab) ⊢ (𝑞1, b) ⊢ (𝑞2, 휀)

Así, (𝑞0, abbaab) ⊢∗ (𝑞2, 휀) y además 𝑞2 ∈ 𝐹, por lo que M acepta la palabra 𝑤.

Ejemplo 2.10:

Consideremos ahora el AFD del ejemplo 2.8 y la entrada 𝑤 = bab. La configuración inicial de

M está dada por (𝑞0, bab). La secuencia de pasos de computación para determinar la aceptación

de 𝑤 es:

(𝑞0, bab) ⊢ (𝑞3, ab) ⊢ (𝑞3, b) ⊢ (𝑞3, 휀)

Así, (𝑞0, bab) ⊢∗ (𝑞3, 휀) y además 𝑞3 ∉ 𝐹, por lo que M no acepta la palabra 𝑤.

La noción de aceptación de una palabra conduce a la noción de lenguaje aceptado por un AFD M,

denotado por 𝐿(𝑀), que corresponde al conjunto de todas las palabras aceptadas por M, es decir

𝐿(𝑀) = {𝑤 ∈ Σ∗: 𝑤 es aceptada por M}.

Ejemplo 2.11:

Si estudiamos el AFD del ejemplo 2.8, podemos notar que 𝐿(𝑀) corresponde al lenguaje

representado por la ER del ejemplo 2.5: 𝑟 = 𝑎(𝑎∗ + 𝑏∗)𝑏.

31



Una vez conocido 𝐿(𝑀), es posible definir la equivalencia entre dos AF: se dice que dos AF 𝑀1 y 𝑀2

son equivalentes si aceptan el mismo lenguaje, es decir:

𝑀1 ≡ 𝑀2 ⇔ 𝐿(𝑀1) = 𝐿(𝑀2)

Otra definición importante es la de alcanzabilidad de un estado, para la cual se requiere previamente la

noción de transición extendida. Una función de transición extendida 𝛿′ entre dos estados distantes (no

vecinos) 𝑞 y 𝑞′ y que involucra la lectura de una secuencia de símbolos puede ser definida como una

función 𝛿′: 𝑄 × Σ∗ → Q tal que:

𝛿′(𝑞, 𝑤) = 𝑞′ ⇔ ∃𝑤 ∈ Σ∗ ∶ (𝑞, 𝑤) ⊢∗ (𝑞′, 휀)

Así, se tiene que un estado 𝑞′ es alcanzable desde otro estado 𝑞 si existe una palabra 𝑤 ∈ Σ∗ tal que la

secuencia de pasos de computación comenzando desde 𝑞 y el primer símbolo de 𝑤 culmina en 𝑞′ cuando no quedan símbolos por leer. Cabe destacar que 𝛿′ tiene las siguientes propiedades:

𝛿′(𝑞, 휀) = 𝑞

𝛿′(𝑞, 𝜎) = 𝛿(𝑞, 𝜎)

𝛿′(𝑞, 𝜎𝑤) = 𝛿′(𝛿(𝑞, 𝜎), 𝑤)

𝛿′(𝑞, 𝑣𝑤) = 𝛿′(𝛿′(𝑞, 𝑣), 𝑤)

2.4.2.2 Autómata finito no determinístico (AFND)

Habíamos estudiado que el estado al que va un AFD al leer un símbolo de la entrada está

completamente determinado, puesto que cada estado cuenta con una y solo una transición por cada

símbolo del alfabeto. En el caso del AFND, en cambio, el cambio de estado solo está parcialmente

especificado, puesto que puede ocurrir lo siguiente:

Las transiciones entre estados están dadas por palabras más que por símbolos individuales,

pudiendo incluso haber transiciones con 휀, denominadas transiciones vacías, en que el AF puede

cambiar de estado sin necesidad de haber leído algo desde la entrada.

Puede haber más de una transición definida desde un estado determinado con alguna lectura dada

(transiciones múltiples). En consecuencia, el AFND debe ir a alguno cualquiera de los estados de

destino, de manera no determinada.

De lo anterior podemos concluir que, en realidad, el AFD estudiado no es más que un caso particular

del AFND. En estos últimos, la especificación de transición 𝛿 es una relación 𝛿 ⊆ 𝑄 × Σ∗ × 𝑄,

conformada por un conjunto de tríos (𝑞, 𝑤, 𝑞′) donde cada trío indica que, estando en el estado 𝑞, al

leer en la entrada una secuencia de símbolos 𝑤, el AFND puede quedar en el estado 𝑞′. No obstante,

como pueden existir dos o más transiciones que compartan los dos primeros componentes, por ejemplo (𝑞, 𝑤, 𝑞′), (𝑞, 𝑤, 𝑞′′), esto puede reformularse de modo tal que el tercer elemento del trío sea un

conjunto de estados: (𝑞, 𝑤, {𝑞′, 𝑞′′}).

En el caso de los AFND, las nociones de configuración, paso de computación, aceptación de palabra,

aceptación de lenguaje y equivalencia son semejantes al caso de los AFD. No obstante, la existencia de

transiciones vacías da origen a una nueva definición: la clausura- 휀. Corresponde al conjunto de estados

alcanzables desde el estado 𝑞 mediante transiciones vacías, es decir:

32



𝐶 − 휀(𝑞) = 𝑠 ∈ 𝑄: (𝑞, 휀) ⊢∗ (𝑠, 휀)

Se puede extender la noción de clausura- 휀 para un conjunto de estados 𝑇, que corresponde

simplemente a la unión de las clausuras- 휀 de cada estado en 𝑇:

𝐶 − 휀(𝑇) = ⋃ 𝐶 − 휀(𝑞) ∀𝑞 ∈ 𝑇

Ejemplo 2.12:

Considere el AFND 𝑀 = (𝑄, Σ, 𝛿, 𝑞0, 𝐹), donde:

𝑄 = {𝑞0, 𝑞1, 𝑞2, 𝑞3, 𝑞4}

Σ = {𝑎, 𝑏}

𝛿 = {(𝑞0, 𝑎𝑏, 𝑞1), (𝑞0, 𝑎𝑏, 𝑞2), (𝑞0, 𝑏𝑎, 𝑞3), (𝑞1, 𝑏𝑎, 𝑞3), (𝑞1, 휀, 𝑞3),(𝑞1, 휀, 𝑞3), (𝑞2, 휀, 𝑞0), (𝑞2, 𝑎, 𝑞3), (𝑞3, 𝑎𝑏, 𝑞2), (𝑞3, 𝑏𝑎, 𝑞3), (𝑞3, 𝑏𝑎, 𝑞4), (𝑞4, 𝑎, 𝑞1), (𝑞4, 휀, 𝑞3)}

𝑞0 = 𝑞0

𝐹 = {𝑞0, 𝑞3}

Otra manera de representar la función de transición es mediante una tabla, como se muestra en

la tabla 2.3.

TABLA 2.3: Función de transición para el AFND M.

𝑞 \ 𝑤 𝑎𝑏 𝑏𝑎 𝑎 휀

𝑞0 {𝑞1, 𝑞2} {𝑞3} 𝜙 𝜙

𝑞1 𝜙 {𝑞3} 𝜙 {𝑞4}

𝑞2 𝜙 𝜙 {𝑞3} {𝑞0}

𝑞3 {𝑞2} {𝑞3, 𝑞4} 𝜙 𝜙

𝑞4 𝜙 𝜙 {𝑞1} {𝑞3}

Gráficamente, se puede mostrar M como en la figura 2.5.

33



FIGURA 2.5: Representación gráfica de M.

Además, las clausuras- 휀 para los diferentes estados son:

𝐶 − 휀(𝑞0) = {𝑞0}

𝐶 − 휀(𝑞1) = {𝑞1, 𝑞3, 𝑞4}

𝐶 − 휀(𝑞2) = {𝑞0, 𝑞2}

𝐶 − 휀(𝑞3) = {𝑞3}

𝐶 − 휀(𝑞4) = {𝑞3, 𝑞4}

2.4.3 EQUIVALENCIA ENTRE AFD Y AFND

La incorporación del no determinismo, a pesar de facilitar la capacidad de abstracción al diseñar un AF,

no aumenta el poder de aceptación de estos reconocedores, es decir, no incrementa el conjunto de

lenguajes que pueden ser reconocidos usando máquinas de estados finitos. Así pues, es posible

demostrar que para cada AFND existe un AFD equivalente.

Para construir un AFD equivalente a un AFND dado, se deben seguir dos grandes pasos:

1. Eliminar aquellas transiciones que avanzan con secuencias cuya longitud es mayor que 1.

2. Eliminar transiciones vacías y transiciones múltiples.

Para eliminar las transiciones con secuencias de longitud mayor a 1, se incorporan nuevos estados al

AFND a fin de descomponer las transiciones para que solo tengan un símbolo.

Sea 𝑀 = (𝑄, Σ, 𝛿, 𝑞0, 𝐹) un AFND tal que sus transiciones son de la forma (𝑞, 𝑢, 𝑞′), donde 𝑞, 𝑞′ ∈ 𝑄 y

u ∈ Σ∗. Entonces, existe un AFND 𝑀′ = (𝑄′, Σ, 𝛿′, 𝑞0, 𝐹) tal que:

𝛿′ ⊆ 𝑄′ × ({휀} ∪ Σ) × 𝑄′. 𝑄′ = 𝑄 ∪ 𝑃𝑖, con 𝑃𝑖 = {𝑝1, 𝑝2, … , 𝑝𝑘−1}∀(𝑞, 𝑢, 𝑞′) ∈ 𝛿 tal que |𝑢| = 𝑘 > 1.

Note que 𝑀 y 𝑀′ comparten Σ, 𝑞0 y 𝐹.

La nueva relación de transición 𝛿′ se obtiene como 𝛿′ = {(𝑞, 𝑢, 𝑞′) ∈ 𝛿: |𝑢| ≤ 1} ∪{(𝑞, 𝜎1, 𝑝1), (𝑝1, 𝜎2, 𝑝2), … , (𝑝𝑘−1, 𝜎𝑘 , 𝑞′)} para cada (𝑞, 𝑢, 𝑞′) ∈ 𝛿 tal que 𝑢 = 𝜎1𝜎2 … 𝜎𝑘 y |𝑢| = 𝑘 >1, como se ilustra en la figura 2.6.

34



El segundo paso, entonces, consiste en eliminar las transiciones vacías y las transiciones múltiples.

Para este fin, creamos un conjunto de estados para el AFD 𝑀′′ = (𝑄′, Σ, 𝛿′′, 𝑞0′′, 𝐹′′) tal que cada uno

de sus estados corresponde a un conjunto de estados del AFND 𝑀′ = (𝑄′, Σ, 𝛿′, 𝑞0, 𝐹), que sintetiza

todos los caminos posibles para reconocer una determinada secuencia. Se puede garantizar que es

posible realizar esta tarea, ya que para un conjunto de estados de tamaño 𝑛 se tienen 2𝑛 subconjuntos.

El primer estado del AFD 𝑀′′ que debemos determinar es el inicial, 𝑞0′′ dado por la clausura-휀 de 𝑞0,

el estado inicial de 𝑀′.

Los nuevos estados de 𝑀′′ se determinan junto con las transiciones. Para cada símbolo de Σ se

determina el conjunto de estados de 𝑀′ que es posible alcanzar desde 𝑞0′′ y se les incorporan sus

respectivas clausuras-휀. Cada nuevo conjunto forma un nuevo estado del AFD. Se repite este proceso

hasta que no queden estados sin transiciones definidas. Los estados finales de 𝑀′′ serán todos aquellos

conjuntos de estados que contengan algún estado final de 𝑀′.

FIGURA 2.6: Eliminación de transiciones con secuencias de longitud mayor a 1 para un AFND M.

Ejemplo 2.13:

35



Consideremos el AFND 𝑀′ de la figura 2.6 y determinemos su AFD equivalente 𝑀′′. El estado

inicial de 𝑀′′ está dado por la clausura-휀 del estado inicial de 𝑀′:

𝐶 − 휀(𝐴) = {𝐴} = 𝑞0

Ahora debemos determinar las transiciones de 𝑞0 y sus respectivas clausuras:

𝛿(𝑞0, 0) = {𝐵, 𝐺} 𝐶 − 휀({𝐵, 𝐺}) = {𝐴, 𝐵, 𝐷, 𝐸, 𝐺} = 𝑞1

𝛿(𝑞0, 1) = 𝜙 𝐶 − 휀(𝜙) = 𝜙 = 𝑞2

Repetimos el proceso anterior para los nuevos estados:

𝛿(𝑞1, 0) = {𝐵, 𝐶, 𝐺} 𝐶 − 휀({𝐵, 𝐶, 𝐺}) = {𝐴, 𝐵, 𝐶, 𝐷, 𝐸, 𝐺} = 𝑞3

𝛿(𝑞1, 1) = {𝐶, 𝐻} 𝐶 − 휀({𝐶, 𝐻}) = {𝐶, 𝐻} = 𝑞4

𝛿(𝑞2, 0) = 𝜙 𝐶 − 휀(𝜙) = 𝑞2

𝛿(𝑞2, 1) = 𝜙 𝐶 − 휀(𝜙) = 𝑞2

𝛿(𝑞3, 0) = {𝐵, 𝐶, 𝐺} 𝐶 − 휀({𝐵, 𝐶, 𝐺}) = {𝐴, 𝐵, 𝐶, 𝐷, 𝐸, 𝐺} = 𝑞3

𝛿(𝑞3, 1) = {𝐶, 𝐹, 𝐻} 𝐶 − 휀({𝐶, 𝐹, 𝐻}) = {𝐶, 𝐹, 𝐻} = 𝑞5

𝛿(𝑞4, 0) = {𝐷} 𝐶 − 휀({𝐷}) = {𝐷, 𝐸} = 𝑞6

𝛿(𝑞4, 1) = {𝐹} 𝐶 − 휀({𝐹}) = {𝐹} = 𝑞7

𝛿(𝑞5, 0) = {𝐷} 𝐶 − 휀({𝐷}) = 𝑞6

𝛿(𝑞5, 1) = {𝐸, 𝐹} 𝐶 − 휀({𝐸, 𝐹}) = {𝐸, 𝐹} = 𝑞8

𝛿(𝑞6, 0) = 𝜙 𝐶 − 휀(𝜙) = 𝑞2

𝛿(𝑞6, 1) = {𝐶} 𝐶 − 휀({𝐶}) = {𝐶} = 𝑞9

𝛿(𝑞7, 0) = 𝜙 𝐶 − 휀(𝜙) = 𝑞2

𝛿(𝑞7, 1) = {𝐸} 𝐶 − 휀({𝐸}) = {𝐸} = 𝑞10

𝛿(𝑞8, 0) = {𝐶, 𝐸} 𝐶 − 휀({𝐶, 𝐸}) = {𝐶, 𝐸} = 𝑞11

𝛿(𝑞8, 1) = 𝜙 𝐶 − 휀(𝜙) = 𝑞2

𝛿(𝑞9, 0) = 𝜙 𝐶 − 휀(𝜙) = 𝑞2

𝛿(𝑞9, 1) = {𝐹} 𝐶 − 휀({𝐹}) = 𝑞7

𝛿(𝑞10, 0) = 𝜙 𝐶 − 휀(𝜙) = 𝑞2

𝛿(𝑞10, 1) = {𝐶} 𝐶 − 휀({𝐶}) = 𝑞9

𝛿(𝑞11, 0) = 𝜙 𝐶 − 휀(𝜙) = 𝑞2

𝛿(𝑞11, 1) = {𝐶, 𝐹} 𝐶 − 휀({𝐶, 𝐹}) = {𝐶, 𝐹} = 𝑞12

𝛿(𝑞12, 0) = 𝜙 𝐶 − 휀(𝜙) = 𝑞2

𝛿(𝑞12, 1) = {𝐸, 𝐹} 𝐶 − 휀({𝐸, 𝐹}) = 𝑞8

36



Note que 𝑞2 es el conjunto vacío, por lo que al haber leído una secuencia no válida se convierte

en un estado trampa.

El conjunto de estados finales del AFD es 𝐹′′ = {𝑞1, 𝑞3, 𝑞4, 𝑞5, 𝑞6, 𝑞8, 𝑞9, 𝑞10, 𝑞11, 𝑞12}

2.4.4 MINIMIZACIÓN DE AFD

En muchas ocasiones, al construir un AFD obtenemos una cantidad de estados superior a la necesaria,

por lo que resulta útil determinar el AFD equivalente más pequeño. Para este fin, debemos determinar

si hay estados que tengan igual significado.

Uno de los métodos existentes para minimizar un AFD es el de las particiones, en que se van creando

grupos cada vez más pequeños de estados potencialmente equivalentes. Para explicar este método,

tomaremos como ejemplo el AFD obtenido en el ejemplo 2.13.

Para la partición, sabemos que un estado final no puede ser equivalente a otro no final, por lo que

creamos un grupo para los estados finales y otro para los no finales:

𝑃0 = (𝑞0, 𝑞2, 𝑞7)(𝑞1, 𝑞3, 𝑞4, 𝑞5, 𝑞6, 𝑞8, 𝑞9, 𝑞10, 𝑞11, 𝑞12)

Ahora asignamos un nombre a cada grupo y estudiamos el comportamiento de cada estado para cada

uno de los símbolos del alfabeto. Llamemos 1 al grupo que contiene a los estados no finales y 2 al

grupo de estados finales. 𝑞0 va a 𝑞1 al leer un 0, y 𝑞1 está en el grupo b. Además, 𝑞0 va a 𝑞2 al leer un

0, y 𝑞2 está en el grupo a.

𝑃0 = (𝑏𝑎𝑞0

,𝑎𝑎𝑞2

,𝑎𝑏𝑞7

)

𝑎

(𝑏𝑏𝑞1

,𝑏𝑏𝑞3

,𝑏𝑎𝑞4

,𝑏𝑏𝑞5

,𝑎𝑏𝑞6

,𝑏𝑎𝑞8

,𝑎𝑎𝑞9

,𝑎𝑏𝑞10

,𝑎𝑏𝑞11

,𝑎𝑏𝑞12

)

𝑏

Para la siguiente partición, podemos descomponer los grupos de acuerdo a su comportamiento. Son

potencialmente equivalentes aquellos estados de un mismo grupo que vayan a las mismas particiones

con los mismos símbolos. Es importante destacar que lo que ya estaba separado no puede juntarse

nuevamente. Así, tenemos que todos los estados se comportan de manera diferente en el grupo a,

mientras que hay algunos del grupo b que siguen siendo potencialmente equivalentes. Ahora, tras la

nueva partición, repetimos el proceso para ver si hay más grupos que se puedan separar:

𝑃1 =(𝑞0)

𝑎(𝑞2)

𝑏(𝑞7)

𝑐(

𝑑𝑒𝑞1

,𝑑𝑑𝑞3

,𝑓𝑒𝑞5

)

𝑑

(𝑓𝑐𝑞4

,𝑓𝑏𝑞8

)

𝑒

(𝑏𝑔𝑞6

,𝑏𝑔𝑞10

,𝑏𝑓𝑞11

,𝑏𝑒𝑞12

)

𝑓

(𝑞9)𝑔

De acuerdo al resultado anterior, la nueva partición queda:

𝑃2 =(𝑞0)

𝑎(𝑞2)

𝑏(𝑞7)

𝑐(𝑞1)

𝑑(𝑞3)

𝑒

(𝑞5)

𝑓(𝑞4)

𝑔(𝑞8)

ℎ(

𝑏𝑙𝑞6

,𝑏𝑙

𝑞10)

𝑖

(𝑞11)𝑗

(𝑞12)

𝑘

(𝑞9)

𝑙

37



Tras el análisis de comportamiento de los grupos, se tiene que 𝑃3 = 𝑃2, por lo que 𝑞6 ≡ 𝑞10. En

consecuencia, podemos tener el AFD mínimo quitando 𝑞10 y redirigiendo sus transiciones entrantes a

𝑞6.

2.5 OPERACIONES CON AF

Una vez estudiada la equivalencia entre AFD y AFND, es posible señalar que la clase de los lenguajes

regulares (aceptados por AF) es cerrada con respecto a diversas operaciones. En otras palabras, dados

los AF 𝑀1 = (𝑄1, Σ, 𝛿1, 𝑞01, 𝐹1) y 𝑀2 = (𝑄2, Σ, 𝛿2, 𝑞02, 𝐹2 ), reconocedores de los lenguajes 𝐿1 y 𝐿2

respectivamente, basta con encontrar, mediante algún algoritmo, un AF que reconozca el lenguaje

resultante de una operación.

2.5.1 UNIÓN

Para encontrar un AF reconocedor de 𝐿 = 𝐿1 ∪ 𝐿2 basta con crear un nuevo AF 𝑀 = (𝑄, Σ, 𝛿, 𝑞0, 𝐹)

con:

𝑄 = 𝑄1 ∪ 𝑄2 ∪ {𝑞0}, donde 𝑞0 es un nuevo estado.

𝛿 = 𝛿1 ∪ 𝛿2 ∪ {(𝑞0, 휀, 𝑞01), (𝑞0, 휀, 𝑞02)}.

𝑞0 = 𝑞0.

𝐹 = 𝐹1 ∪ 𝐹2.

Ejemplo 2.14:

2.5.2 CONCATENACIÓN

Para encontrar un AF reconocedor de 𝐿 = 𝐿1𝐿2 basta con crear un nuevo AF 𝑀 = (𝑄, Σ, 𝛿, 𝑞0, 𝐹) con:

38



𝑄 = 𝑄1 ∪ 𝑄2.

𝛿 = 𝛿1 ∪ 𝛿2 ∪ 𝐹1 × {휀} × {𝑞02}.

𝑞0 = 𝑞01.

𝐹 = 𝐹2.

Ejemplo 2.15:

2.5.3 ESTRELLA DE KLEENE

Para encontrar un AF reconocedor de 𝐿 = 𝐿1∗ basta con crear un nuevo AF 𝑀 = (𝑄, Σ, 𝛿, 𝑞0, 𝐹) con:

𝑄 = 𝑄1 ∪ {𝑞0}, donde 𝑞0 es un nuevo estado.

𝛿 = 𝛿1 ∪ {(𝑞0, 휀 , 𝑞01)} ∪ 𝐹1 × {휀} × {𝑞01}.

𝑞0 = 𝑞0.

𝐹 = 𝐹1 ∪ {𝑞0}.

39



Ejemplo 2.16:

2.5.4 COMPLEMENTACIÓN (SOLO PARA AFD)

Para encontrar un AF reconocedor de 𝐿 = 𝐿1𝐶, donde se cuenta con un AFD reconocedor de 𝐿1, basta

con crear un nuevo AF 𝑀 = (𝑄1, Σ, 𝛿1, 𝑞01, 𝐹) con 𝐹 = 𝑄1 − 𝐹1.

Ejemplo 2.17:

2.5.5 INTERSECCIÓN (SOLO PARA AFD)

Para encontrar un AF reconocedor de 𝐿 = 𝐿1 ∩ 𝐿2, donde se cuenta con AFD reconocedores de 𝐿1 y

𝐿2, basta con crear un nuevo AF 𝑀 = (𝑄, Σ, 𝛿, 𝑞0, 𝐹) dado por 𝑀 = (𝑀1𝐶 ∪ 𝑀2

𝐶)𝐶

.

Ejemplo 2.18:

Consideremos los AFD 𝑀1 y 𝑀2 que se muestran a continuación.

En primer lugar, debemos determinar sus complementos:

40



A continuación realizamos la unión de los complementos, y luego determinamos el AFD

mínimo equivalente:

Paso a AFD:

𝐶 − 휀(𝐻) = {𝐻, 𝐴, 𝐷} = 𝑞0

𝛿(𝑞0, 0) = {𝐵, 𝐸} 𝐶 − 휀({𝐵, 𝐸}) = {𝐵, 𝐸} = 𝑞1

𝛿(𝑞0, 1) = {𝐶, 𝐹} 𝐶 − 휀({𝐶, 𝐹}) = {𝐶, 𝐹} = 𝑞2

𝛿(𝑞1, 0) = {𝐴, 𝐸} 𝐶 − 휀({𝐴, 𝐸}) = {𝐴, 𝐸} = 𝑞3

𝛿(𝑞1, 1) = {𝐵, 𝐺} 𝐶 − 휀({𝐵, 𝐺}) = {𝐵, 𝐺} = 𝑞4

𝛿(𝑞2, 0) = {𝐶, 𝐸} 𝐶 − 휀({𝐶, 𝐸}) = {𝐶, 𝐸} = 𝑞5

𝛿(𝑞2, 1) = {𝐵, 𝐹} 𝐶 − 휀({𝐵, 𝐹}) = {𝐵, 𝐹} = 𝑞6

𝛿(𝑞3, 0) = {𝐵, 𝐸} 𝐶 − 휀({𝐵, 𝐸}) = 𝑞1

𝛿(𝑞3, 1) = {𝐶, 𝐺} 𝐶 − 휀({𝐶, 𝐺}) = {𝐶, 𝐺} = 𝑞7

41



𝛿(𝑞4, 0) = {𝐴, 𝐺} 𝐶 − 휀({𝐴, 𝐺}) = {𝐴, 𝐺} = 𝑞8

𝛿(𝑞4, 1) = {𝐵, 𝐺} 𝐶 − 휀({𝐵, 𝐺}) = 𝑞4

𝛿(𝑞5, 0) = {𝐶, 𝐸} 𝐶 − 휀({𝐶, 𝐸}) = 𝑞5

𝛿(𝑞5, 1) = {𝐵, 𝐺} 𝐶 − 휀({𝐵, 𝐺}) = 𝑞4

𝛿(𝑞6, 0) = {𝐴, 𝐸} 𝐶 − 휀({𝐴, 𝐸}) = 𝑞3

𝛿(𝑞6, 1) = {𝐵, 𝐹} 𝐶 − 휀({𝐵, 𝐹}) = 𝑞6

𝛿(𝑞7, 0) = {𝐶, 𝐺} 𝐶 − 휀({𝐶, 𝐺}) = 𝑞7

𝛿(𝑞7, 1) = {𝐵, 𝐺} 𝐶 − 휀({𝐵, 𝐺}) = 𝑞4

𝛿(𝑞8, 0) = {𝐵, 𝐺} 𝐶 − 휀({𝐵, 𝐺}) = 𝑞4

𝛿(𝑞8, 1) = {𝐶, 𝐺} 𝐶 − 휀({𝐶, 𝐺}) = 𝑞7

𝐹 = {𝑞0, 𝑞2, 𝑞3, 𝑞4, 𝑞5, 𝑞6, 𝑞7, 𝑞8}

Minimizamos el AFD:

𝑃0 = (𝑏𝑎𝑞0

,𝑎𝑎𝑞2

,𝑏𝑎𝑞3

,𝑎𝑎𝑞4

,𝑎𝑎𝑞5

,𝑎𝑎𝑞6

,𝑎𝑎𝑞7

,𝑎𝑎𝑞8

)

𝑎

(𝑞1)

𝑏

𝑃1 = (𝑏𝑐𝑞0

,𝑏𝑐𝑞3

)

𝑎

(𝑞1)

𝑏(

𝑐𝑐𝑞2

,𝑐𝑐𝑞4

,𝑐𝑐𝑞5

,𝑎𝑐𝑞6

,𝑐𝑐𝑞7

,𝑐𝑐𝑞8

)

𝑐


,𝑏𝑐𝑞3

)

𝑎

(𝑞1)

𝑏(

𝑐𝑑𝑞2

,𝑐𝑐𝑞4

,𝑐𝑐𝑞5

,𝑐𝑐𝑞7

,𝑐𝑐𝑞8

)

𝑐

(𝑞6)

𝑑


,𝑏𝑑𝑞3

)

𝑎

(𝑞1)

𝑏(𝑞2)

𝑐(

𝑑𝑑𝑞4

,𝑑𝑑𝑞5

,𝑑𝑑𝑞7

,𝑑𝑑𝑞8

)

𝑑

(𝑞6)𝑒

𝑃4 =(𝑞0)

𝑎(𝑞1)

𝑏(𝑞2)

𝑐(𝑞3)

𝑑(

𝑒𝑒𝑞4

,𝑒𝑒𝑞5

,𝑒𝑒𝑞7

,𝑒𝑒𝑞8

)

𝑒

(𝑞6)

𝑓

𝑃5 = 𝑃4 ∴ 𝑞4 ≡ 𝑞5 ≡ 𝑞7 ≡ 𝑞8

Así, el AFD mínimo para 𝑀1𝐶 ∪ 𝑀2

𝐶 es:

42



Finalmente, complementamos el resultado anterior:

Problema propuesto:

Busque algoritmos para encontrar el AF correspondiente a las siguientes operaciones:

𝐿1 − 𝐿2

𝐿1 △ 𝐿2

𝐿𝑅

𝐿 ∪ {휀}

𝐿 − {휀}

2.6 EQUIVALENCIAS

Hasta ahora hemos visto que las gramáticas regulares permiten generar lenguajes regulares, las

expresiones regulares los representan y los autómatas finitos los reconocen. Resulta sencillo, en

consecuencia, pensar que existen métodos para pasar de alguno de estos elementos a otro.

2.6.1 EQUIVALENCIA ENTRE ER Y AF

43



En esta sección se muestra en primer lugar el método de Thompson para construir un AFND a partir de

una ER dada. A continuación se describen los métodos de ecuaciones lineales (Arden) y recursivo para

determinar la ER del lenguaje reconocido por un AF.

2.6.1.1 Método de Thompson

Sirve para construir un AFND reconocedor para alguna expresión regular dada. Opera de manera

constructiva, creando AFNDs para subexpresiones sencillas y combinándolos luego de acuerdo a

ciertas reglas. Una ventaja de este método es que resulta sencillo de implementar computacionalmente,

y facilita las operaciones de unión, concatenación y clausura al garantizar que cada AFND tiene un

único estado final. De más está decir que este método se complementa con otros ya estudiados a fin de

obtener el AFD mínimo reconocedor.

Sea 𝜎 ∈ Σ y sean 𝑀𝐴 y 𝑀𝐵 AFNDs reconocedores de los lenguajes representados por las expresiones

regulares 𝑟𝐴 y 𝑟𝐵, respectivamente. Ambos AF han sido construidos mediante el método de Thompson,

por lo que solo tienen un estado final.

Los esquemas básicos que usa este método:

𝑟 = 휀

El AFND reconocedor para la palabra vacía se construye creando dos estados, uno de ellos inicial que

no es de aceptación y el otro final. Para llegar desde el estado inicial al final, se crea una transición

vacía.

𝑟 = 𝜎

Análogo al anterior, cuando la expresión regular consiste en un solo símbolo, basta con que la

transición del estado inicial al estado final tenga asociado el mismo símbolo.

𝑟 = 𝑟𝐴 + 𝑟𝐵

El mecanismo para construir un autómata reconocedor correspondiente a la unión de dos

subexpresiones regulares es bastante sencillo. Basta con tomar los dos autómatas reconocedores, crear

un nuevo estado inicial que vaya con transiciones vacías a los que fueran los estados iniciales y crear

un nuevo estado final alcanzable con transiciones vacías desde el que fuera el estado final.

44



𝑟 = 𝑟𝐴𝑟𝐵

Para la concatenación, basta con hacer que el estado final del primer autómata se fusione con el estado

inicial del segundo en un estado no final.

𝑟 = 𝑟𝐴∗

Para la clausura reflexiva y transitiva, el mecanismo consiste en incorporar un nuevo estado inicial y un

nuevo estado final, a fin de poder reconocer la secuencia vacía. Para dar la opción de reconocer el

lenguaje representado por la subexpresión una única vez, basta con pasar desde el nuevo estado inicial

al estado inicial previo con una transición vacía, y del estado final previo al nuevo con otra. Por último,

para establecer la repetición de la clausura, basta con pasar con una transición vacía desde el estado

final previo al estado inicial previo.

Ejemplo 2.19:

Construir un AF reconocedor para el lenguaje representado por la siguiente expresión regular:

𝑟 = 011(00 + 11)∗ + 01(휀 + 0).

𝑟1 = 휀

45



𝑟2 = 0

𝑟3 = 1

𝑟4 = 𝑟2𝑟3

𝑟5 = 𝑟4𝑟3

𝑟6 = 𝑟2𝑟2

𝑟7 = 𝑟3𝑟3

𝑟8 = 𝑟6 + 𝑟7

46



𝑟9 = 𝑟8∗

𝑟10 = 𝑟5𝑟9

𝑟11 = 𝑟1 + 𝑟2

𝑟12 = 𝑟4𝑟11

47



𝑟 = 𝑟13 = 𝑟10 + 𝑟12

Problema propuesto:

Determine el AFD mínimo equivalente para el AFND obtenido en el ejemplo 2.14.

2.6.1.2 Método de ecuaciones lineales (método de Arden)

En este método se plantea una ecuación para cada estado del AF, de la forma:

𝑋𝑖 = ∑ 𝑋𝑗𝜎𝑗 + 𝑒𝑖

𝑛

𝑗=1

Donde:

𝑋𝑗 corresponde al estado 𝑗.

𝜎𝑗 es tal que 𝛿(𝑞𝑗 , 𝜎𝑗) = 𝑞𝑖.

𝑒𝑖 = {휀 𝑞𝑖 𝑒𝑠𝑡𝑎𝑑𝑜 𝑖𝑛𝑖𝑐𝑖𝑎𝑙𝜙 𝑒𝑛 𝑜𝑡𝑟𝑜 𝑐𝑎𝑠𝑜

La ER está dada por la unión de las soluciones obtenidas para todos los estados finales.

48



Además, se debe tener en consideración la regla de Arden:

𝑋 = 𝑋𝛼 + 𝛽 ⇒ 𝑋 = 𝛽𝛼∗

Ejemplo 2.20:

Plantear y resolver el sistema de ecuaciones lineales asociado al AF de la figura 2.7. Determinar

la ER que representa el lenguaje aceptado.

FIGURA 2.7: Un AF para determinar su ER correspondiente.

𝑋1 = 𝑋1𝜙 + 𝑋2𝜙 + 𝑋30 + 휀 (1)

𝑋2 = 𝑋11 + 𝑋21 + 𝑋3 + 𝜙 (2)

𝑋3 = 𝑋1𝜙 + 𝑋2(0 + 1) + 𝑋3𝜙 + 𝜙 (3)⌋

𝑋1 = 𝑋30 + 휀 (1)

𝑋2 = 𝑋11 + 𝑋21 (2)

𝑋3 = 𝑋2(0 + 1) (3)⌋

Arden en (2):

𝑋2 = 𝑋111∗ (4)

(4) en (3):

𝑋3 = 𝑋111∗(0 + 1) (5)

(5) en (1):

𝑋1 = 𝑋111∗(0 + 1)0 + 휀 (6)

Arden en (6):

𝑋1 = [11∗(0 + 1)0]∗ (7)

(7) en (4):

𝑋2 = [11∗(0 + 1)0]∗11∗ (8)

(7) en (5):

𝑋3 = [11∗(0 + 1)0]∗11∗(0 + 1) (9)

Así, la solución del sistema de ecuaciones lineales es:

𝑋1 = [11∗(0 + 1)0]∗

𝑋2 = [11∗(0 + 1)0]∗11∗

49



𝑋3 = [11∗(0 + 1)0]∗11∗(0 + 1)

La ER buscada corresponde a la unión de lo que aceptan los estados 𝑞2 y 𝑞3:

𝐸𝑅 = 𝑋2 + 𝑋3 = [11∗(0 + 1)0]∗11∗ + [11∗(0 + 1)0]∗11∗(0 + 1) =

= [11∗(0 + 1)0]∗11∗(휀 + 0 + 1)

2.6.1.3 Método recursivo

Este método toma un AF y determina la expresión regular del lenguaje reconocido mediante una

descomposición sucesiva en subautómatas. El planteamiento general para determinar la ER asociada a

un estado del AF es:

𝑅𝑖𝑗𝑘 = 𝑅𝑖𝑗

𝑘−1 + 𝑅𝑖𝑘𝑘−1(𝑅𝑘𝑘

𝑘−1)∗𝑅𝑘𝑗

𝑘−1

Además, la condición de término está dada por:

𝑅𝑖𝑗0 = {

𝜎 ∶ 𝛿(𝑞𝑖 , 𝜎) = 𝑞𝑗 𝑖 ≠ 𝑗

휀 + 𝜎 ∶ 𝛿(𝑞𝑖 , 𝜎) = 𝑞𝑗 𝑖 = 𝑗

Para plantear el problema, se debe considerar inicialmente la unión de todos elementos 𝑅𝑖𝑗𝑘 tales que:

𝑖 es el estado inicial.

𝑗 es un estado final.

𝑘 es la cantidad de estados que tiene el autómata.

Luego, se aplica la fórmula recursivamente hasta llegar a la condición de término y luego se

reemplazan los resultados parciales obtenidos.

Ejemplo 2.21:

Determinar la ER que representa el lenguaje reconocido por el AF de la figura 2.7.

Al plantear el problema, se tiene que el lenguaje reconocido corresponde a lo que aceptan los

estados 𝑞2 y 𝑞3. Así, la ER está dada por:

𝐸𝑅 = 𝑅123 + 𝑅13

3

Desarrollando los términos recursivos se tiene:

𝑅123 = 𝑅12

2 + 𝑅132 (𝑅33

2 )∗𝑅322

𝑅133 = 𝑅13

2 + 𝑅132 (𝑅33

2 )∗𝑅332

𝑅122 = 𝑅12

1 + 𝑅121 (𝑅22

1 )∗𝑅221

𝑅132 = 𝑅13

1 + 𝑅121 (𝑅22

1 )∗𝑅231

𝑅332 = 𝑅33

1 + 𝑅321 (𝑅22

1 )∗𝑅231

𝑅322 = 𝑅32

1 + 𝑅321 (𝑅22

1 )∗𝑅221

50



𝑅121 = 𝑅12

0 + 𝑅110 (𝑅11

1 )∗𝑅120

𝑅221 = 𝑅22

0 + 𝑅210 (𝑅11

1 )∗𝑅120

𝑅131 = 𝑅13

0 + 𝑅110 (𝑅11

1 )∗𝑅130

𝑅231 = 𝑅23

0 + 𝑅210 (𝑅11

1 )∗𝑅130

𝑅331 = 𝑅33

0 + 𝑅310 (𝑅11

1 )∗𝑅130

𝑅321 = 𝑅32

0 + 𝑅310 (𝑅11

1 )∗𝑅120

𝑅110 = 휀 𝑅12

0 = 1 𝑅130 = 𝜙

𝑅210 = 𝜙 𝑅22

0 = 휀 + 1 𝑅230 = 0 + 1

𝑅310 = 0 𝑅32

0 = 𝜙 𝑅330 = 휀

Ahora, reemplazamos los resultados parciales en las expresiones recursivas:

𝑅121 = 𝑅12

0 + 𝑅110 (𝑅11

1 )∗𝑅120 = 1 + 휀(휀)∗1 = 1

𝑅221 = 𝑅22

0 + 𝑅210 (𝑅11

1 )∗𝑅120 = 휀 + 1 + 𝜙(휀)∗1 = 휀 + 1

𝑅131 = 𝑅13

0 + 𝑅110 (𝑅11

1 )∗𝑅130 = 𝜙 + 휀(휀)∗𝜙 = 𝜙

𝑅231 = 𝑅23

0 + 𝑅210 (𝑅11

1 )∗𝑅130 = 0 + 1 + 𝜙(휀)∗𝜙 = 0 + 1

𝑅331 = 𝑅33

0 + 𝑅310 (𝑅11

1 )∗𝑅130 = 휀 + 0(휀)∗𝜙 = 휀

𝑅321 = 𝑅32

0 + 𝑅310 (𝑅11

1 )∗𝑅120 = 𝜙 + 0(휀)∗1 = 01

𝑅122 = 𝑅12

1 + 𝑅121 (𝑅22

1 )∗𝑅221 = 1 + 1(휀 + 1)∗(휀 + 1) = 11∗

𝑅132 = 𝑅13

1 + 𝑅121 (𝑅22

1 )∗𝑅231 = 𝜙 + 1(휀 + 1)∗(0 + 1) = 11∗(0 + 1)

𝑅332 = 𝑅33

1 + 𝑅321 (𝑅22

1 )∗𝑅231 = 휀 + 01(휀 + 1)∗(0 + 1) = 휀 + 011∗(0 + 1)

𝑅322 = 𝑅32

1 + 𝑅321 (𝑅22

1 )∗𝑅221 = 01 + 01(휀 + 1)∗(휀 + 1) = 011∗

𝑅123 = 𝑅12

2 + 𝑅132 (𝑅33

2 )∗𝑅322 = 11∗ + 11∗(0 + 1)[휀 + 011∗(0 + 1)]∗011∗ =

= 11∗ + 11∗(0 + 1)[011∗(0 + 1)]∗011∗

𝑅133 = 𝑅13

2 + 𝑅132 (𝑅33

2 )∗𝑅332 =

= 11∗(0 + 1) + 11∗(0 + 1)[휀 + 011∗(0 + 1)]∗[휀 + 011∗(0 + 1)] =

= 11∗(0 + 1)[011∗(0 + 1)]∗

𝐸𝑅 = 𝑅123 + 𝑅13

3 = 11∗ + 11∗(0 + 1)[011∗(0 + 1)]∗011∗ + 11∗(0 + 1)[011∗(0 + 1)]∗ =

= 11∗ + 11∗(0 + 1)[011∗(0 + 1)]∗(휀 + 011∗) =

= 11∗{휀 + (0 + 1)[011∗(0 + 1)]∗(휀 + 011∗)}

Problema propuesto:

Pruebe que las ER obtenidas en los ejemplos ejemplo 2.15 y 2.16 son equivalentes.

2.6.2 EQUIVALENCIA ENTRE AF Y GR

En esta sección se muestran dos métodos sencillos, que permiten obtener un AF a partir de una GR y a

la inversa.

2.6.2.1 Obtención de una GR a partir de un AF

51



Dado un autómata finito 𝑀 = (𝑄, ΣM, 𝛿, 𝑞0, 𝐹), existe un algoritmo muy sencillo para determinar una

gramática regular 𝐺 = (ΣG, 𝑁, 𝑃, 𝑆) que genere el lenguaje aceptado. Los pasos son los siguientes:

1. Hacer ΣG = ΣM. Es decir, el conjunto de símbolos terminales de 𝐺 corresponde al alfabeto de 𝑀.

2. Hacer N = Q. En otras palabras, los estados de 𝑀 conforman el conjunto de no terminales de 𝐺.

3. Hacer 𝑃 = {𝑞 → 𝜎𝛿(𝑞, 𝜎): 𝑞 ∈ 𝑄, 𝜎 ∈ ΣM} ∪ {𝑞 → 휀: 𝑞 ∈ 𝐹}. Las producciones corresponden a las

transiciones entre dos estados de M, y además se agregan producciones vacías para los estados

finales.

4. Hacer 𝑆 = 𝑞0. El símbolo inicial corresponde al estado inicial.

Resulta sencillo comprobar que este algoritmo es correcto, puesto que las derivaciones realizadas para

generar una palabra imitan las transiciones efectuadas por el AF para reconocerla.

Ejemplo 2.22:

Obtenga una gramática regular que reconozca el lenguaje aceptado por el AFND de la figura

2.8.

𝐺 = (Σ, 𝑁, 𝑃, 𝑆):

Σ = {0, 1}

N = {A, B, C, D, E}

P = {A → 0B | 010D, B → A | 0C | D, C → 11E | 휀, D → E, E → 1B | 휀}

𝑆 = 𝐴

FIGURA 2.8: Un AF para determinar su ER correspondiente.

2.6.2.2 Obtención de un AF a partir de una GR

Dada una gramática regular 𝐺 = (ΣG, 𝑁, 𝑃, 𝑆), existe un algoritmo sencillo semejante al descrito en el

punto anterior para determinar un autómata finito 𝑀 = (𝑄, ΣM, 𝛿, 𝑞0, 𝐹) que acepte el lenguaje

generado. Los pasos son los siguientes:

1. Hacer ΣM = ΣG.

2. Hacer 𝑄 = N ∪ {𝑓}. Es decir, los no terminales de 𝐺 conforman el conjunto de estados de 𝑀,

aunque es necesario agregar un estado adicional 𝑓.

3. Hacer 𝑞0 = 𝑆.

4. Hacer 𝐹 = {𝑓}. En otras palabras, el AF tiene un único estado final que corresponde al estado

adicional agregado en el paso 2.

5. Hacer 𝛿 = {(𝐴, 𝑤, 𝐵): 𝐴 → 𝑤𝐵 ∈ 𝑃} ∪ {(𝐴, 𝑤, 𝑓): 𝐴 → 𝑤 ∈ 𝑃}, donde 𝑤 ∈ ΣG∗ y 𝐴, 𝐵 ∈ 𝑁.

52



Al igual que en el método inverso, la comprobación del correcto funcionamiento de este algoritmo

resulta muy simple. Las transiciones efectuadas por el AF para reconocer una palabra imitan las

derivaciones realizadas por la GR para generarla.

Ejemplo 2.23:

Construya un AF reconocedor del lenguaje generado por la siguiente gramática regular:

𝐺 = (Σ, 𝑁, 𝑃, 𝑆):

Σ = {0, 1}

N = {A, B, C, D, E}

P = {A → 01A | 1B | 01, B → C | 0A | 0D, C → 10C | 1D, D → 1 | 1E, E → 0E | 1D | 휀}

𝑆 = 𝐴

El AF reconocedor para la gramática dada se muestra en la figura 2.9.

Problema propuesto:

Obtenga el AFD mínimo equivalente para el AFND de la figura 2.9.

FIGURA 2.9: AF reconocedor para el lenguaje generado por la gramática regular del ejemplo 2.18.

2.7 LEMA DEL BOMBEO

Una propiedad esencial de los lenguajes regulares es que se puede descomponer cualquier palabra lo

suficientemente larga en tres secciones diferentes y repetir (bombear) la sección central una cantidad

arbitraria de de veces para formar una nueva palabra perteneciente al lenguaje. El lema del bombeo se

sirve de esta propiedad para demostrar que algún lenguaje dado no es regular (no sirve a la inversa).

Formalmente, el lema del bombeo plantea que, si 𝐿 es un lenguaje regular, entonces existe un entero

𝑛 ≥ 1 (denominado longitud de bombeo y dependiente exclusivamente de 𝐿) tal que cualquier palabra

𝑧 ∈ 𝐿, con |𝑧| ≥ 𝑛, puede ser escrita como 𝑧 = 𝑢𝑣𝑤 de forma tal que se cumplan las siguientes

condiciones:

1. |𝑣| ≥ 1.

2. |𝑢𝑣| ≤ 𝑛.

3. 𝑢𝑣𝑖𝑤 ∈ 𝐿∀𝑖 ≥ 0.

53



Este lema se utiliza para demostrar que un lenguaje dado no es regular mediante reducción al absurdo.

En otras palabras, basta con encontrar una palabra con la longitud requerida y que carezca de las

propiedades descritas en el lema del bombeo.

Ejemplo 2.24:

Demuestre, usando el lema del bombeo, que 𝐿 = {𝑎𝑛𝑏𝑛 ∶ 𝑛 ≥ 0} no es regular.

Comenzamos por asumir que 𝐿 es regular. Luego escogemos 𝑧 ∈ 𝐿 con |𝑧| = 2𝑛 ≥ 𝑛. Luego

hacemos la descomposición 𝑧 = 𝑢𝑣𝑤. Si bien no conocemos su forma exacta, sabemos que si 𝐿

es regular se deben cumplir determinadas condiciones:

|𝑢𝑣| ≤ 𝑛 indica que 𝑣 no contiene ninguna 𝑏.

|𝑣| ≥ 1 significa que 𝑣 contiene a lo menos una 𝑎.

Todas las 𝑏 están en 𝑤.

Según el lema del bombeo, para que 𝐿 sea regular debe cumplirse que 𝑧′ = 𝑢𝑣𝑖𝑤 ∈ 𝐿∀𝑖 ≥ 0.

Pero si tomamos 𝑧′ = 𝑢𝑣0𝑤 = 𝑢𝑤, habremos quitado a lo menos una 𝑎 de 𝑧 y ninguna 𝑏, con

lo que |𝑧′|𝑎 ≠ |𝑧′|𝑏. Esto es una contradicción, puesto que supusimos que 𝑧′ ∈ 𝐿 pero 𝑧′ no

cumple con las condiciones necesarias. En consecuencia, 𝐿 no es regular.

2.8 TRANSDUCTORES FINITOS

Otra clase de máquinas de estado interesantes, utilizadas en diseño de circuitos, son los transductores

finitos de TF). Pueden ser consideradas como un autómata finito que no tiene estados finales, sino una

cinta donde puede escribir un cabezal y una especificación para generar las salidas. Así, cada entrada

puede generar una salida. Podemos distinguir dos tipos de TF:

Máquinas de Mealy: entregan su salida al momento de realizar una transición.

Máquinas de Moore: entregan su salida en los estados.

Formalmente, un TF es una tupla de 6 elementos 𝑀 = (𝑄, Σ, Δ, 𝛿, 𝜆, 𝑞0), donde:

𝑄 ≠ ∅ es un conjunto finito no vacío de estados.

Σ es el alfabeto de entrada (lectura).

Δ es el alfabeto de salida (escritura).

𝛿 corresponde a la especificación de transición entre estados en base al estado actual y al símbolo

leído desde la entrada, 𝛿: 𝑄 × Σ → Q.


𝜆 corresponde a la especificación de generación de la salida. Difiere entre las máquinas de Mealy y

de Moore.

2.8.1 Máquina de Mealy

Lleva asociadas las salidas a las transiciones, es decir, 𝜆: 𝑄 × Σ → Δ. Así, para una entrada 𝑤 tal que |𝑤| = 𝑛, se genera una secuencia de transiciones de igual longitud que lleva asociada entonces una

salida también de largo 𝑛.

54



2.8.2 Máquina de Moore

En este caso, las salidas están asociadas al estado en que permanece. Es decir, 𝜆: 𝑄 → Δ. Así, para una

entrada 𝑤 tal que |𝑤| = 𝑛, se genera una secuencia de transiciones de igual longitud que lleva asociada

entonces una salida de largo 𝑛 + 1 (el primer símbolo de la salida corresponde al estado inicial cuando

aún no se ha leído nada desde la entrada.

Ejemplo 2.25:

Construya una máquina de Mealy y otra de Moore que entregue las siguientes salidas para una

entrada sobre el alfabeto binario:

A si la entrada termina en 101.

B si termina en 010.

C en otro caso.

Muestre, además, la salida de ambas máquinas para la entrada 1100101011100110100.

Moore:

Mealy:

55



Salidas: Entrada 1 1 0 0 1 0 1 0 1 1 1 0 0 1 1 0 1 0 0

Mealy C C C C C B A B A C C C C C C C A B C

Moore C C C C C C B A B A C C C C C C C A B C

2.9 EJERCICIOS

1. Diseñe gramáticas para representar los siguientes lenguajes:

a. Números reales.

b. Expresiones aritméticas sobre los números reales.

c. Direcciones IP.

2. Diseñe gramáticas regulares para representar los siguientes lenguajes sobre Σ = {0,1}:

a. Todas las palabras que tienen todos los 1s delante de todos los 0s.

b. Todas las palabras que tienen todos los 1s delante de todos los 0s, con excepción de la palabra

vacía.

c. Todas las palabras conformadas por pares de 0s y pares de 1s.

d. Todas las palabras que terminan con un par de 0s o un par de 1s.

3. Indique si las siguientes aseveraciones son verdaderas o falsas:

a. 𝑏𝑎𝑎 ∈ 𝐿(𝑎∗𝑏∗𝑎∗𝑏∗(휀 + 𝑎)).

b. 𝑏∗𝑎∗ ∩ 𝑎∗𝑏∗ = 𝑎∗ + 𝑏∗.

c. 𝑎𝑏𝑐𝑑 ∈ 𝐿((𝑎(𝑐𝑑)∗𝑏)∗).

4. Describa en lenguaje natural los lenguajes representados por las siguientes ER:

a. 0(0 + 1)∗0.

b. ((휀 + 0)1∗)∗.

c. (0 + 1)∗0(0 + 1)(0 + 1).

d. 0∗10∗10∗10∗.

56



5. Para un alfabeto de tamaño 4, escriba las ER que especifican los siguientes lenguajes:

a. Todas las palabras de largo 2.

b. Todas las palabras de largo 4.

c. Todas las palabras sin símbolos repetidos.

6. Simplifique la ER (𝑎∗ + 휀)∗𝑏(𝑎∅ + 휀)+∗.

7. Escriba las ER que describan los siguientes lenguajes:

a. Todas las palabras sobre el alfabeto {0, 1} que contienen a lo más dos 0s.

b. Todas las palabras sobre el alfabeto {0, 1} que comienzan con dos símbolos iguales y terminan

con dos símbolos distintos.

c. Todas las palabras sobre el alfabeto {#, &} que comienzan y terminan con # y tienen todos los

& juntos.

8. Reduzca las siguientes ER a su mínima expresión:

a. ((𝑎 + 휀)∅)∗

+ 𝑏휀 + (𝑏 + 휀)+ + ((𝑎𝑏 + 𝑏)∗)∗.

b. ((𝑥𝑦)∗휀(𝑦𝑥)∗)∗(𝑦∗ + 𝑥∗)∗𝑦∗𝑦∗ + ∅(𝑥 + 𝑦).

c. (01 + 11)∗∅ + (휀 + (00)∗)∗(11)∗((11)∗ + (00)∗)∗.

9. Considere el lenguaje sobre el alfabeto binario cuyas palabras comienzan con 0 y terminan con 1 y

que tienen todos los 0s al comienzo y todos los 1s al final.

a. Muestre el lenguaje con notación de conjuntos.

b. Encuentre la expresión regular que representa dicho lenguaje.

c. Dibuje el diagrama de Conway (ferrocarril) para la expresión regular obtenida en el punto

anterior.

10. Sea 𝐿 el lenguaje de todas las secuencias en {𝑥, 𝑦}∗ que tienen igual cantidad de 𝑥 que de 𝑦, con un

tercio de las 𝑥 al comienzo, todas las 𝑦 juntas y los restantes dos tercios de las 𝑥 al final.

a. Muestre L en notación de conjuntos.

b. Muestre L por extensión.

c. Muestre L como expresión regular. En caso de no ser posible, explique el motivo.

11. Pruebe que las ER 𝑟1 = 0(0 + 1)∗ + (01 + 10)011 y 𝑟2 = 0(0 + 1)∗(01∗)∗ + (0101 + 1001)1

son equivalentes.

12. Dado el alfabeto Σ = {𝑎, 𝑏}, construya un AF para cada uno de los siguientes lenguajes:

a. Las palabras que terminan en 𝑏𝑏𝑏.

b. Las palabras que no contengan la secuencia 𝑎𝑏𝑎𝑏.

c. Las palabras tales que cada bloque de cinco símbolos consecutivos contengan a lo menos dos 𝑏.

d. Las palabras que contengan una cantidad de 𝑎 que sea múltiplo de tres.

e. Las palabras cuya cantidad de 𝑎 sea par y su cantidad de 𝑏 sea múltiplo de tres.

13. Sea 𝐿 = {휀, 01,10,000,111}:

a. Construya un AFD mínimo reconocedor.

57



b. Resuelva el sistema de ecuaciones lineales para el AFD obtenido y determine la ER del

lenguaje aceptado.

c. Determine la ER del lenguaje aceptado usando el método recursivo.

d. Obtenga la GR que genera el lenguaje.

14. Dados los AFND 𝑀1 y 𝑀2 de la figura 2.10, determine el AFD mínimo equivalente para cada uno

de ellos y la gramática que genera los lenguajes aceptados.

FIGURA 2.10: AFND para el ejercicio 14.

15. Determine los AFD mínimos reconocedores y las GR generadoras para los lenguajes representados

por las siguientes ER:

a. 0(11 + 00)∗1 + 010(11 + 00)∗101∗. b. 0(10(0 + 1)∗01)∗1.

c. (11 + 00)∗ + (01 + 10)0.

16. Obtenga los AF reconocedores para los lenguajes generados por las siguientes gramáticas:

a. 𝐺1 = ({𝑎, 𝑏}, {𝐴, 𝐵, 𝑆}, {𝑆 → 𝑎𝑏 | 𝐵 | 𝑏𝑎 |휀 , 𝐴 → 𝑏𝑆 | 𝑏, 𝐵 → 𝑎𝑆}, 𝑆). b. 𝐺2 = ({𝑎, 𝑏}, {𝐴, 𝐵, 𝑆}, {𝑆 → 𝑏𝑏𝐴 | 𝑎𝑎𝐵 | 𝐴, 𝐴 → 𝑏𝑆 | 𝑎, 𝐵 → 𝑎𝐴 | 𝑏 | 휀}, 𝑆).

17. Dados los AF 𝑀1y 𝑀2 de la figura 2.11, determine las ER de los lenguajes aceptados usando el

método recursivo.

58



FIGURA 2.11: AF para el ejercicio 17.

18. Resuelva los sistemas de ecuaciones lineales y determine las ER de los lenguajes aceptados por los

AF de la figura 2.10.

19. Dados los AF 𝑀1 y 𝑀2 de la figura 2.12, determine los AF correspondientes a las siguientes

operaciones:

a. 𝑀1 ∪ 𝑀2.

b. 𝑀1𝑀2.

c. 𝑀1∗.

d. 𝑀1 ∩ 𝑀2.

e. 𝑀2𝐶.

f. 𝑀2 − 𝑀1.

g. 𝑀1∆𝑀2.

h. 𝑀1 − {휀}.

i. 𝑀2 ∪ {휀}.

FIGURA 2.12: AFND para el ejercicio 19.

20. Pruebe, usando el lema de bombeo, que los siguientes lenguajes no son regulares:

a. 𝐿1 = {𝑤 = 𝑥𝑛𝑦2𝑛 ∶ 𝑛 ≥ 0}.

b. 𝐿2 = {𝑤 = 𝑣𝑣𝑅 ∶ 𝑣 ∈ {0, 1}∗}.

c. 𝐿3 = {𝑤 = 𝑎𝑖𝑏𝑗𝑐𝑛 ∶ 𝑖 + 𝑗 = 𝑛, 𝑛 ≥ 0}.

21. Construya una máquina de Mealy y otra de Moore que entregue las siguientes salidas para una

entrada sobre el alfabeto Σ = {𝑎, 𝑏}:

A si la entrada termina en 𝑎𝑏𝑏.

B si termina en 𝑎𝑎𝑏.

C si termina en 𝑏𝑎𝑎.

D si termina en 𝑏𝑎.

E en otro caso.

Muestre, además, la salida de ambas máquinas para la entrada 𝑎𝑎𝑎𝑏𝑎𝑎𝑏𝑏𝑎𝑏𝑎𝑎𝑏𝑏𝑏𝑏𝑎𝑎𝑏.

59



22. Construya una máquina de Mealy y otra de Moore que entregue el resto módulo 5 para un entero

binario. Muestre, además, la salida de ambas máquinas para las entradas 1010, 1101010 y

0100110.

60



3 LENGUAJES LIBRES DE CONTEXTO

En la unidad anterior se definieron los lenguajes regulares, la clase más simple de lenguajes formales.

En esta unidad se dan a conocer los lenguajes libres de contexto, sus reconocedores y su aplicación en

la construcción de compiladores.

3.1 GRAMÁTICAS LIBRES DE CONTEXTO

En la unidad anterior conocimos el modelo de gramática dado por la tupla 𝐺 = (Σ, N, P, S). Conocimos

cómo operan las gramáticas para generar una palabra, e introdujimos la noción de derivación y su

representación mediante un árbol.

Las gramáticas libres de contexto (GLC) son aquellas en que todas las producciones tienen la forma

𝐴 → 𝛼, con 𝐴 ∈ 𝑁 y 𝛼 ∈ (Σ ∪ 𝑁)∗. Cabe destacar que el conjunto de las gramáticas regulares es un

subconjunto de las gramáticas libres de contexto. Todos los ejemplos de gramática dados en el capítulo

anterior corresponden a gramáticas libres de contexto.

3.1.1 AMBIGÜEDAD

En la unidad anterior conocimos la noción de derivación, dada por el reemplazo de un no terminal por

alguna de sus producciones. En el caso de las gramáticas lineales (y en particular de las gramáticas

regulares), en que toda producción tiene a lo más un no terminal, no es necesario preocuparse del orden

en que se realicen las derivaciones o de si existen árboles distintos para generar una misma palabra,

pues hay uno solo por cada secuencia. En el caso de las GLC, como podemos tener más no terminales

en una producción, sí es necesario tomar en consideración el orden en que se efectúan las derivaciones.

Por la derecha: siempre se reemplaza el no terminal de más a la derecha.

Por la izquierda: siempre se reemplaza el no terminal de más a la izquierda.

Ejemplo 3.1:

Dada la GLC 𝐺 = ({𝑥, (, ), +,∗}, {𝐸}, {𝐸 → 𝐸 + 𝐸 | 𝐸 ∗ 𝐸 |(𝐸)| 𝑥}, 𝐸), muestre una derivación

por la derecha y otra por la izquierda para la palabra 𝑥 + 𝑥 ∗ 𝑥. Muestre además sus árboles de

derivación.

Derivación por la derecha:

𝐸 → 𝐸 + 𝐸 → 𝐸 + 𝐸 ∗ 𝐸 → 𝐸 + 𝐸 ∗ 𝑥 → 𝐸 + 𝑥 ∗ 𝑥 → 𝑥 + 𝑥 ∗ 𝑥

Derivación por la izquierda:

𝐸 → 𝐸 + 𝐸 → 𝑥 + 𝐸 → 𝑥 + 𝐸 ∗ 𝐸 → 𝑥 + 𝑥 ∗ 𝐸 → 𝑥 + 𝑥 ∗ 𝑥

61



Árbol de derivación (es el mismo para ambas):

Ahora que está clara la idea de derivación por la derecha y por la izquierda, es importante introducir el

concepto de gramática ambigua.

Definición:

Una gramática 𝐺 ∈GLC es ambigua ⇔ ∃𝑤 ∈ 𝐿(𝐺) ∶ 𝑤 tiene dos derivaciones por la izquierda ∨ 𝑤

tiene dos derivaciones por la derecha 𝑤 ∨ tiene dos árboles de derivación.

Ejemplo 3.2:

Consideremos como base el ejemplo 3.1. Ahora podemos buscar nuevas derivaciones por la

izquierda y por la derecha para la misma palabra, así como un nuevo árbol de derivación, y así

probar que 𝐺 es ambigua.

Derivación por la derecha:

𝐸 → 𝐸 ∗ 𝐸 → 𝐸 ∗ 𝑥 → 𝐸 + 𝐸 ∗ 𝑥 → 𝐸 + 𝑥 ∗ 𝑥 → 𝑥 + 𝑥 ∗ 𝑥

Derivación por la izquierda:

𝐸 → 𝐸 ∗ 𝐸 → 𝐸 + 𝐸 ∗ 𝐸 → 𝑥 + 𝐸 ∗ 𝐸 → 𝑥 + 𝑥 ∗ 𝐸 → 𝑥 + 𝑥 ∗ 𝑥

Árbol de derivación (es el mismo para ambas):

En consecuencia, 𝐺 es ambigua porque existen dos árboles de derivación diferentes para la

misma palabra.

62



3.1.2 SIMPLIFICACIÓN DE GLC Y FORMAS NORMALES

En ocasiones puede ocurrir que una gramática contenga símbolos inútiles o que contenga producciones

vacías innecesarias. También puede ser útil en ocasiones escribir las producciones de una gramática de

alguna forma específica.

3.1.2.1 Eliminación de símbolos inútiles

Dada una GLC 𝐺 = (Σ, N, P, S), se dice que un símbolo 𝑋 es útil si existe una derivación

S ⇒∗ α𝑋β ⇒∗ 𝑤, donde 𝑋 ∈ (Σ ∪ 𝑁); α, β ∈ (Σ ∪ 𝑁)∗; 𝑤 ∈ Σ∗. En otras palabras, para que el símbolo

𝑋 sea útil, es necesario que:

𝑋 sea un terminal o bien se puedan generar secuencias de terminales a partir de él.

𝑋 aparezca en una secuencia generada a partir de S.

𝑋 debe ocurrir en alguna forma oracional que pueda derivar una secuencia terminal.

Podemos distinguir dos clases de símbolos inútiles:

Símbolo muerto: 𝐴 ∈ 𝑁 tal que no es posible derivar una cadena v ∈ Σ∗ a partir de 𝐴.

Símbolo inaccesible: 𝑋 ∈ (Σ ∪ 𝑁) tal que no se cumple que S ⇒∗ α𝑋β.

Ahora que está claro qué es un símbolo útil, podemos establecer un método para encontrar una

gramática 𝐺′ equivalente a 𝐺 que solo contenga símbolos útiles.

El algoritmo para eliminar símbolos muertos es bastante sencillo, y crea una gramática equivalente a 𝐺:

𝐺′ = (Σ, N′, P′, S). Los pasos a seguir son:

1. Determinar N′: a. Para toda producción de la forma 𝐴 → 𝑤, con 𝑤 ∈ Σ∗, entonces añadir el símbolo 𝐴 a N′. b. Si una producción es de la forma 𝐴 → 𝑋1𝑋2 … 𝑋𝑛, con 𝑋𝑖 ∈ Σ ∨ 𝑋𝑖 ∈ N′, 1 ≤ i ≤ n, entonces

añadir el símbolo 𝐴 a N′. Repetir este paso hasta que no puedan agregarse nuevos símbolos a

N′. 2. Determinar P′: dado por todas las producciones de P que solo contienen símbolos en Σ ∪ 𝑁′.

También existe un algoritmo para eliminar símbolos inaccesibles, que construye una gramática 𝐺′ =(Σ′, N′, P′, S) equivalente a 𝐺:

1. Determinar N′: a. Agregar S a 𝑁′. b. Si 𝐴 ∈ N′ y 𝐴 → α1 | α2 | … | α𝑛, añadir a 𝑁′ todo símbolo 𝐵 ∈ N presente en cada α𝑖 y añadir a

Σ′ todo símbolo 𝑎 ∈ Σ presente en cada α𝑖. Repetir este paso hasta que no puedan agregarse

símbolos a N′ y Σ′. 2. Determinar P′: dado por todas las producciones de P que solo contienen símbolos en Σ′ ∪ 𝑁′.

Para construir una gramática equivalente libre de símbolos inútiles, se deben seguir los siguientes pasos

(no funciona en orden inverso):

1. Eliminar símbolos muertos.

2. Eliminar símbolos inaccesibles.

63



Ejemplo 3.3:

Sea 𝐺 = (Σ, N, P, S): Σ = {a, b, c}

N = {S, A, B, C, D, E}

P = {S → aBB | CED, A → BS, B → A | b | ε, C → bEa | BB, D → AB | cc | ε, E → EB | DE}

S = S

Construya una gramática equivalente que solo contenga símbolos útiles.

En primer lugar, se eliminan los símbolos muertos:

Las producciones que generan secuencias en Σ∗ son: B → b, B → ε, D → cc y D → ε. En

consecuencia, inicialmente se tiene N′ = {B, D}.

Las producciones que solo contienen símbolos en Σ ∪ 𝑁′ y que no han sido consideradas

aún son S → aBB y C → BB, por lo que ahora N′ = {S, B, C, D}.

Repitiendo el paso anterior, las producciones que solo contienen símbolos en Σ ∪ 𝑁′ y que

no han sido consideradas aún son A → BS y D → AB, por lo que ahora N′ = {S, A, B, C, D}.

Repitiendo una vez más, aparecen ahora las producciones B → A y D → AB, que no

incorporan ningún símbolo nuevo a N′. Ahora formamos P′ tal que todos sus símbolos estén en Σ ∪ 𝑁′:

P′ = {S → aBB, A → BS, B → A | b | ε, C → BB, D → AB | cc | ε}

Así, nuestra gramática equivalente sin símbolos muertos es 𝐺′ = (Σ, N′, P′, S):

Σ = {a, b, c}

N′ = {S, A, B, C, D}

P′ = {S → aBB, A → BS, B → A | b | ε, C → BB, D → AB | cc | ε}

S = S

Ahora eliminamos los símbolos inaccesibles:

Para comenzar, hacemos N′′ = {S}.

Incorporamos a Σ′ y N′′ los símbolos presentes en las producciones de S: Σ′ = {a} y N′′ ={S, B}.

Incorporamos a Σ′ y N′′ los símbolos presentes en las producciones de B: Σ′ = {a, b} y N′′ ={S, A, B}.

64



Incorporamos a Σ′ y N′′ los símbolos presentes en las producciones de A: Σ′ = {a, b} y N′′ ={S, A, B}. No se incluyó nada más a ninguno de los dos conjuntos.

Ahora formamos P′′ tal que todos sus símbolos estén en Σ′ ∪ 𝑁′′: P′ = {S → aBB,

A → BS, B → A | b | ε, C → BB}

Así, nuestra gramática equivalente sin símbolos inútiles es 𝐺′′ = (Σ′, N′′, P′′, S):

Σ′ = {a, b}

N′ = {S, A, B}

P′ = {S → aBB, A → BS, B → A | b | ε}

S = S

3.1.2.2 Eliminación de producciones

Si un lenguaje 𝐿 es generado por una GLC 𝐺, entonces 𝐿 − {휀} es generado por una GLC 𝐺′ sin

símbolos inútiles ni producciones 휀.

Definición:

El conjunto de símbolos anulables 𝑁𝜀 está conformado por todo 𝐴 ∈ N tal que A ⇒∗ ε.

Los pasos para obtener una GLC 𝐺′ = (Σ, N, P′, S) sin producciones son:

1. Determinar 𝑁𝜀.

2. Incluir en P′ todas las producciones de P menos las producciones 휀.

3. Si A → αBβ ∈ P y 𝐵 ∈ 𝑁𝜀, entonces añadir A → αβ a P′ a menos que A → αβ sea una producción

vacía. Repetir este paso hasta que no se pueda agregar nada más.

Ejemplo 3.4:

Sea 𝐺 = (Σ, N, P, S): Σ = {a, b, c}

N = {S, A, B, C}

P = {S → aBB | bCc, A → BC | BCa | CbS, B → A | b | ε, C → bCa | c | ε}

S = S

Construya una gramática equivalente que no contenga producciones 휀.

En primer lugar, se determina 𝑁𝜀. Incorporamos B y C porque B → ε y C → ε. Ahora bien, dado

que A → BC → C → ε, también debe ser incluido. Así, 𝑁𝜀 = {A, B, C}.

65



Ahora creamos P′ tomando solo las producciones no vacías de P:

P′ = {S → aBB | bCc, A → BC | BCa | CbS, B → A | b, C → bCa | c}

Luego se incluyen las producciones faltantes según el paso 3 del algoritmo:

Para C → bCa | c es necesario incluir C → ba.

Para B → A | b habría que agregar B → ε, que no se considera según el algortimo.

Para A → BC | BCa | CbS se tiene un caso más complejo. Debido a A → BC se agregan

también A → B y A → C, descartándose A → ε. Por causa de A → BCa, se agregan A → Ba,

A → Ca y A → a. Finalmente, se debe agregar A → bS.

Para S → aBB | bCc se agregan S → aB, S → a y S → aBB | bc.

Así, se tiene finalmente 𝐺′ = (Σ, N, P′, S), con:

P′ = {S → aBB |aB | a | bCc | bc, A → BC | B | C | BCa | Ba | Ca | a | CbS | bS, B → A | b, C → bCa | ba | c}

3.1.2.3 Eliminación de producciones unitarias

Las producciones unitarias o de redenominación son aquellas producciones de la forma A → B, con

A, B ∈ N. En otras palabras, su lado derecho contiene un único no terminal.

Dada una gramática 𝐺, el algoritmo para encontrar la gramática equivalente 𝐺′ = (Σ, N, P′, S) que no

tiene producciones unitarias es el siguiente:

1. Eliminar producciones ε.

2. Para toda producción A → B, con B → α1 | α2 | … αn, sustituir A → B por A → α1 | α2 | … αn.

Repetir este paso hasta que no queden producciones unitarias.

Ejemplo 3.5:

Sea 𝐺 = (Σ, N, P, S): Σ = {~, [, ],∨,∧, t, f}

N = {A, B, C}

P = {A → A ∨ B | B, B → B ∧ C | C, C → ~C | [C] | t | f}

S = A

Construya una gramática equivalente que no contenga producciones unitarias.

En este caso no tenemos producciones tenemos producciones ε, por lo que solo debemos

preocuparnos de las producciones unitarias.

66



Comencemos por A → B, que debe ser reemplazada por A → B ∧ C | C, con lo que las

producciones de A son ahora A → A ∨ B | B ∧ C | C.

Ahora tenemos A → C, que debemos reemplazar por A → ~C | [C] | t | f, con lo que las

producciones de A son ahora A → A ∨ B | B ∧ C | ~C | [C] | t | f.

Solo nos queda ahora B → C, que debe ser reemplazada por B → ~C | [C] | t | f. Así, se tiene que

B → B ∧ C | ~C | [C] | t | f.

Así, se tiene 𝐺′ = (Σ, N, P′, S), donde:

P′ = {A → A ∨ B | B ∧ C | ~C | [C] | t | f, B → B ∧ C | ~C | [C] | t | f, C → ~C | [C] | t | f}

3.1.2.4 Forma normal de Chomsky

Todo lenguaje libre de contexto que no incluye ε puede ser generado por una gramática G que no tiene

símbolos inútiles, producciones ε ni producciones unitarias. Además, cualquier lenguaje de estas

características puede ser escrito de forma tal que todas sus producciones sean de la forma A → BC o

A → a, donde A, B, C ∈ 𝑁 y a ∈ Σ. Se dice que una gramática escrita de este modo se encuentra en

forma normal de Chomsky.

El algoritmo para obtener la forma normal de Chomsky de una gramática de un lenguaje que no incluye

ε es el siguiente:

1. Eliminar producciones ε.

2. Eliminar producciones unitarias.

3. Eliminar símbolos inútiles.

4. Para cada producción de la forma A → X1X2 … Xn, n ≥ 2 (si n = 1 dicha producción ya está en

forma normal de Chomsky, puesto que X1 solo puede ser un terminal al no existir producciones

unitarias), hacer:

a. Si Xi = 𝑎 ∈ Σ, crear un nuevo no terminal Ca y una producción Ca → a. Reemplazar Xi por Ca.

Este paso se repite para cada terminal y para cada producción.

b. Ahora todas las producciones A → X1X2 … Xn tienen la forma A → B1B2 … Bn, con n ≥ 2 y Bi ∈N′. Si n = 2, dicha producción ya está en forma normal de Chomsky. En caso contrario, se

crean los no terminales D1, D2, … , Dm−2 y se reemplaza A → B1B2 … Bn por el conjunto de

producciones {A → B1D1, D1 → B2D2, … , Dn−3 → Bn−3Dn−2, Dn−2 → Bn−1Bn}.

Ejemplo 3.6:

Sea 𝐺 = (Σ, N, P, S): Σ = {a, b, c}

N = {S, A, B, C}

P = {S → ASA | aC, A → C | S, B → c |BA, C → b | ε}

S = S

Construya una gramática equivalente en la forma normal de Chomsky.

67



Para comenzar, eliminamos las producciones vacías:

Como primer paso de esta tarea debemos determinar 𝑁𝜀, dado por 𝑁𝜀 = {𝐴, 𝐶} (puesto que

C → ε y A → C → ε).

Construimos un nuevo conjunto de producciones en el que no se incluyen las

producciones vacías, dado por P′ = {S → ASA | aC, A → C | S, B → c |BA, C → b}.

Ahora es necesario incorporar las producciones en que se suprimen los símbolos

anulables (excepto aquellas que resulten ser vacías): P′ = {S → SA | AS |S | ASA |aC | a,A → C | S, B → c |BA | B, C → b}.

En segundo lugar, debemos eliminar las producciones unitarias:

En el caso de S → S y B → B, simplemente se eliminan (no tiene sentido reemplazar un

símbolo por él mismo).

En el caso de A → C, se debe reemplazar por A → b.

En el caso de A → S, el reemplazo queda A → SA | AS | ASA | aC | a.

En consecuencia, el conjunto de producciones es ahora P′ = {S → SA | AS | ASA | aC |a,A → b | SA | AS | ASA |aC | a, B → c |BA, C → b}.

A continuación eliminamos los símbolos inútiles:

Comenzamos por los símbolos muertos:

Creamos N′ que contenga solo los no terminales que tienen secuencias formadas solo

por terminales: N′ = {S, A, B, C}.

En este caso, no es necesario continuar con el algoritmo puesto que N′ = N, con lo que

P′ no sufre modificaciones.

Ahora eliminamos los símbolos inaccesibles:

Nuestro nuevo conjunto N′ comienza teniendo únicamente al símbolo inicial: N′ = {S}.

Ahora incorporamos a N′ todos los no terminales que aparezcan en las producciones de

S y a Σ′ todos los no terminales que aparezcan en las citadas producciones, con lo que

N′ = {S, A, C} y Σ′ = {a}.

A continuación incorporamos a N′ todos los no terminales que aparezcan en las

producciones de A y C, y a Σ′ todos los no terminales que aparezcan en las citadas

producciones: N′ = {S, A, C} y Σ′ = {a, b}.

Como N′ no fue modificado ahora determinamos el nuevo conjunto de producciones, del

cual se eliminan aquellas reglas que contengan símbolos que no se encuentren en Σ′ o

N′: P′ = {S → SA | AS | ASA | aC |a, A → b | SA | AS | ASA |aC | a, C → b}.

Por último, reescribimos las producciones para llevarlas a la forma normal de Chomsky:

En primer lugar, creamos un nuevo no terminal para poder modificar las producciones S →aC y A → aC. Así, N′ = {S, A, B, C} y creamos la producción B → a, con lo que nuestras

producciones modificadas son S → BC y A → BC, que ya están en forma normal de

Chomsky.

Ahora debemos crear un nuevo no terminal para poder reescribir las producciones S → ASA

y A → ASA. Así, N′ = {S, A, B, C, D}. Creamos la producción D → SA, con lo que nuestras

producciones modificadas son S → AD y A → AD, que ya están en forma normal de

Chomsky.

Así, se tiene que P′ = {S → SA | AS | AD | BC |a, A → b | SA | AS | AD |BC | a, B → a, C →b, D → SA}

68



Así, la gramática equivalente en forma normal de Chomsky es 𝐺′ = (Σ′, N′, P′, S): Σ′ = {a, b}

N′ = {S, A, B, C, D}

P′ = {S → SA | AS | AD | BC |a, A → b | SA | AS | AD |BC | a, B → a, C → b, D → SA}

S = S.

3.1.2.5 Forma normal de Greibach

Una GLC está en forma normal de Greibach cuando todas sus producciones son de la forma A → aα,

con A ∈ N, a ∈ Σ y α ∈ (Σ ∪ N)∗. Además, se puede encontrar una gramática equivalente en forma

normal de Greibach para toda GLC 𝐺 que genere un lenguaje 𝐿 tal que 휀 ∉ 𝐿(𝐺).

El algoritmo para obtener la forma normal de Greibach de una gramática 𝐺 = (Σ, N, P, S) es el

siguiente, asumiendo N = {A1, A2, … , An}:

1. Llevar 𝐺 a la forma normal de Chomsky.

2. Modificar las producciones de P para que, si Ai → Ajα ∈ P, entonces j ≥ i.

3. Eliminar producciones de la forma Ai → Aiα (recursivas por la izquierda) . Si las producciones

recursivas por la izquierda de un no terminal Ai son Ai → Aiα1 | Aiα2 | … | Aiαm y las

producciones no recursivas por la izquierda del mismo no terminal son Ai → β1 | β2 | … | βm, hacer:

a. Crear un nuevo no terminal Bi.

b. Crear para Bi las producciones Bi → αj | αjBi, 1 ≤ j ≤ 𝑚.

c. Reemplazar las producciones de Ai por Ai → βj | βjBi, 1 ≤ j ≤ 𝑛.

4. Llevar las producciones resultantes a la forma A → aα mediante reemplazos.

Ejemplo 3.7:

Determine la forma normal de Greibach para la gramática 𝐺 = (Σ, N, P, S): Σ = {a, b}

N = {A, B, C}

P = {A → BC, B → CA | b, C → AB | a}

S = A.

La gramática ya está en forma normal de Chomsky.

Modificar las producciones de P para que, si Ai → Ajα ∈ P, entonces j ≥ i. La única producción

que no cumple con este criterio es C → AB, por lo que hacemos:

C → AB ⟹ C → BCB ⟹ C → CACB | bCB | a

Con lo que se tiene:

𝑃 = {𝐴 → 𝐵𝐶, 𝐵 → 𝐶𝐴 | 𝑏, 𝐶 → 𝐶𝐴𝐶𝐵 | 𝑏𝐶𝐵 | 𝑎}

Se elimina la recursión por la izquierda. La única producción que requiere modificación es 𝐶 →𝐶𝐴𝐶𝐵, por lo que creamos las producciones:

𝐷 → 𝐴𝐶𝐵 | 𝐴𝐶𝐵𝐷

Y se reemplazan las producciones de 𝐶 por:

𝐶 → 𝑏𝐶𝐵 | 𝑏𝐶𝐵𝐷 | 𝑎 | 𝑎𝐷

69



Con lo que se tiene:

𝑃 = {𝐴 → 𝐵𝐶, 𝐵 → 𝐶𝐴 | 𝑏, 𝐶 → 𝑏𝐶𝐵 | 𝑏𝐶𝐵𝐷 | 𝑎 | 𝑎𝐷, 𝐷 → 𝐴𝐶𝐵 | 𝐴𝐶𝐵𝐷}

Ahora debemos llevar las producciones a la forma normal de Greibach. Las producciones de 𝐶

ya cumplen con la condición. Ahora podemos modificar las producciones de 𝐵 haciendo:

𝐵 → 𝑏𝐶𝐵𝐴 | 𝑏𝐶𝐵𝐷𝐴 | 𝑎𝐴 | 𝑎𝐷𝐴 | 𝑏

Ahora podemos modificar las producciones de 𝐴 haciendo:

𝐴 → 𝑏𝐶𝐵𝐴𝐶 | 𝑏𝐶𝐵𝐷𝐴𝐶 | 𝑎𝐴𝐶 | 𝑎𝐷𝐴𝐶 | 𝑏𝐶

Por último, modificamos las producciones de 𝐷 haciendo:

𝐷 → 𝑏𝐶𝐵𝐴𝐶𝐶𝐵 | 𝑏𝐶𝐵𝐷𝐴𝐶𝐶𝐵 | 𝑎𝐴𝐶𝐶𝐵 | 𝑎𝐷𝐴𝐶𝐶𝐵 | 𝑏𝐶𝐶𝐵 | | 𝑏𝐶𝐵𝐴𝐶𝐶𝐵𝐷 | 𝑏𝐶𝐵𝐷𝐴𝐶𝐶𝐵𝐷 | 𝑎𝐴𝐶𝐶𝐵𝐷 | 𝑎𝐷𝐴𝐶𝐶𝐵𝐷 | 𝑏𝐶𝐶𝐵𝐷

Así, la gramática equivalente en forma normal de Greibach es 𝐺′ = (Σ, N′, P′, S): Σ = {a, b}

N′ = {A, B, C, D}

P′ = { 𝐴 → 𝑏𝐶𝐵𝐴𝐶 | 𝑏𝐶𝐵𝐷𝐴𝐶 | 𝑎𝐴𝐶 | 𝑎𝐷𝐴𝐶 | 𝑏𝐶, 𝐵 → 𝑏𝐶𝐵𝐴 | 𝑏𝐶𝐵𝐷𝐴 | 𝑎𝐴 | 𝑎𝐷𝐴 | 𝑏, 𝐶 → 𝑏𝐶𝐵 | 𝑏𝐶𝐵𝐷 | 𝑎 | 𝑎𝐷,

𝐷 → 𝑏𝐶𝐵𝐴𝐶𝐶𝐵 | 𝑏𝐶𝐵𝐷𝐴𝐶𝐶𝐵 | 𝑎𝐴𝐶𝐶𝐵 | 𝑎𝐷𝐴𝐶𝐶𝐵 | 𝑏𝐶𝐶𝐵 | | 𝑏𝐶𝐵𝐴𝐶𝐶𝐵𝐷 | 𝑏𝐶𝐵𝐷𝐴𝐶𝐶𝐵𝐷 | 𝑎𝐴𝐶𝐶𝐵𝐷 | 𝑎𝐷𝐴𝐶𝐶𝐵𝐷 | 𝑏𝐶𝐶𝐵𝐷}

S = A.

3.1.2.6 Factorización por la izquierda

La factorización por la izquierda se ocupa de agrupar producciones semejantes, descomponiéndolas en

un fragmento común y otro diferente. Esto es de utilidad al momento de construir algunos analizadores

sintácticos, pues sirve en aquellos casos en que no está claro cuál de dos o más producciones

alternativas utilizar para ampliar un no terminal 𝐴. Así, las producciones de 𝐴 pueden reescribirse para

postergar la decisión hasta haber visto lo suficiente de la entrada como para tomar la decisión correcta.

Tómense por ejemplo las producciones A → αβ1 | αβ2. Como puede ser difícil saber si escoger αβ1 o

αβ2, se pueden crear las siguientes producciones para postergar la decisión: A → αB y B → β1 | β2.

El algoritmo para factorizar completamente una gramática es el siguiente:

1. Repetir:

a. Para cada no terminal A, encontrar el prefijo α más largo común a dos o más de sus

producciones.

b. Si α ≠ ε, sustituir todas las producciones de A, A → αβ1 | αβ2 | … | αβn | γ (donde γ representa

a todas las producciones de A que no comienzan por α) por A → αB | γ y B → β1 | β2 | … | αβn,

donde B es un nuevo no terminal.

Mientras haya dos producciones para un no terminal con un prefijo común.

Ejemplo 3.8:

Factorice por la izquierda la gramática 𝐺 = (Σ, N, P, S): Σ = {a, b}

N = {A, B, C, D}

70



P = { 𝐴 → 𝑏𝐶𝐵𝐴𝐶 | 𝑏𝐶𝐵𝐷𝐴𝐶 | 𝑎𝐴𝐶 | 𝑎𝐷𝐴𝐶 | 𝑏𝐶, 𝐵 → 𝑏𝐶𝐵𝐴 | 𝑏𝐶𝐵𝐷𝐴 | 𝑎𝐴 | 𝑎𝐷𝐴 | 𝑏, 𝐶 → 𝑏𝐶𝐵 | 𝑏𝐶𝐵𝐷 | 𝑎 | 𝑎𝐷,

𝐷 → 𝑏𝐶𝐵𝐴𝐶𝐶𝐵 | 𝑏𝐶𝐵𝐷𝐴𝐶𝐶𝐵 | 𝑎𝐴𝐶𝐶𝐵 | 𝑎𝐷𝐴𝐶𝐶𝐵 | 𝑏𝐶𝐶𝐵 | | 𝑏𝐶𝐵𝐴𝐶𝐶𝐵𝐷 | 𝑏𝐶𝐵𝐷𝐴𝐶𝐶𝐵𝐷 | 𝑎𝐴𝐶𝐶𝐵𝐷 | 𝑎𝐷𝐴𝐶𝐶𝐵𝐷 | 𝑏𝐶𝐶𝐵𝐷}

S = A.

En el caso de 𝐴, podemos comenzar por las producciones de la forma 𝐴 → 𝑏𝐶𝐵β, de donde se

obtiene:

𝐴 → 𝑏𝐶𝐵𝐸 | 𝑎𝐴𝐶 | 𝑎𝐷𝐴𝐶 | 𝑏𝐶

𝐸 → 𝐴𝐶 | 𝐷𝐴𝐶

Ahora podemos factorizar aquellas producciones de la forma 𝐴 → 𝑏𝐶β, quedando:

𝐴 → 𝑏𝐶𝐹 | 𝑎𝐴𝐶 | 𝑎𝐷𝐴𝐶

𝐹 → 𝐵𝐸 | 휀

Y terminar la factorización de este no terminal con las producciones de la forma 𝐴 → 𝑎β, de

donde se obtiene:

𝐴 → 𝑏𝐶𝐹 | 𝑎𝐸

𝐸 → 𝐴𝐶 | 𝐷𝐴𝐶

Nótese que no se creó un no terminal nuevo porque ya existía uno con exactamente las mismas

producciones.

Para el no terminal 𝐵, podemos comenzar con las producciones de la forma 𝐵 → 𝑏𝐶𝐵β:

𝐵 → 𝑏𝐶𝐵𝐺 | 𝑎𝐴 | 𝑎𝐷𝐴 | 𝑏

𝐺 → 𝐴 | 𝐷𝐴

Continuar con las de la forma 𝐵 → 𝑏β:

𝐵 → 𝑏𝐻 | 𝑎𝐴 | 𝑎𝐷𝐴

𝐻 → 𝐶𝐵𝐺 | 휀

Y terminar con las de la forma 𝐵 → 𝑎β:

𝐵 → 𝑏𝐻 | 𝑎𝐺

Para el no terminal 𝐶, podemos comenzar con las producciones de la forma 𝐶 → 𝑏𝐶𝐵β:

𝐶 → 𝑏𝐶𝐵𝐼 | 𝑎 | 𝑎𝐷

𝐼 → 𝐷 | 휀

Y terminar con las de la forma 𝐶 → 𝑎β:

𝐶 → 𝑏𝐶𝐵𝐼 | 𝑎𝐼

Para el no terminal 𝐷, podemos comenzar con las producciones de la forma 𝐷 → 𝑏𝐶𝐵𝐴𝐶𝐶𝐵β:

𝐷 → 𝑏𝐶𝐵𝐴𝐶𝐶𝐵𝐼 | 𝑏𝐶𝐵𝐷𝐴𝐶𝐶𝐵 | 𝑎𝐴𝐶𝐶𝐵 | 𝑎𝐷𝐴𝐶𝐶𝐵 | 𝑏𝐶𝐶𝐵 | | 𝑏𝐶𝐵𝐷𝐴𝐶𝐶𝐵𝐷 | 𝑎𝐴𝐶𝐶𝐵𝐷 | 𝑎𝐷𝐴𝐶𝐶𝐵𝐷 | 𝑏𝐶𝐶𝐵𝐷

Continuar con aquellas de la forma 𝐷 → 𝑏𝐶𝐵𝐷𝐴𝐶𝐶𝐵β:

𝐷 → 𝑏𝐶𝐵𝐴𝐶𝐶𝐵𝐼 | 𝑏𝐶𝐵𝐷𝐴𝐶𝐶𝐵𝐼 | 𝑎𝐴𝐶𝐶𝐵 | 𝑎𝐷𝐴𝐶𝐶𝐵 | 𝑏𝐶𝐶𝐵 | 𝑎𝐴𝐶𝐶𝐵𝐷 | 𝑎𝐷𝐴𝐶𝐶𝐵𝐷 | 𝑏𝐶𝐶𝐵𝐷

Seguir con aquellas de la forma 𝐷 → 𝑏𝐶𝐶𝐵β:

𝐷 → 𝑏𝐶𝐵𝐴𝐶𝐶𝐵𝐼 | 𝑏𝐶𝐵𝐷𝐴𝐶𝐶𝐵𝐼 | 𝑎𝐴𝐶𝐶𝐵 | 𝑎𝐷𝐴𝐶𝐶𝐵 | 𝑏𝐶𝐶𝐵𝐼 | 𝑎𝐴𝐶𝐶𝐵𝐷 | 𝑎𝐷𝐴𝐶𝐶𝐵𝐷

Seguir con aquellas de la forma 𝐷 → 𝑏𝐶𝐵β:

𝐷 → 𝑏𝐶𝐵𝐽 | 𝑎𝐴𝐶𝐶𝐵 | 𝑎𝐷𝐴𝐶𝐶𝐵 | 𝑏𝐶𝐶𝐵𝐼 | 𝑎𝐴𝐶𝐶𝐵𝐷 | 𝑎𝐷𝐴𝐶𝐶𝐵𝐷

𝐽 → 𝐴𝐶𝐶𝐵𝐼 | 𝐷𝐴𝐶𝐶𝐵𝐼

71



Y ahora tomar las de forma 𝐷 → 𝑏𝐶β:

𝐷 → 𝑏𝐶𝐾 | 𝑎𝐴𝐶𝐶𝐵 | 𝑎𝐷𝐴𝐶𝐶𝐵 | 𝑎𝐴𝐶𝐶𝐵𝐷 | 𝑎𝐷𝐴𝐶𝐶𝐵𝐷

𝐾 → 𝐵𝐽 | 𝐶𝐵𝐼

Para seguir con aquellas de forma 𝐷 → 𝑎𝐴𝐶𝐶𝐵β:

𝐷 → 𝑏𝐶𝐾 | 𝑎𝐴𝐶𝐶𝐵𝐼 | 𝑎𝐷𝐴𝐶𝐶𝐵 | 𝑎𝐷𝐴𝐶𝐶𝐵𝐷

Y luego las de forma 𝐷 → 𝑎𝐷𝐴𝐶𝐶𝐵β:

𝐷 → 𝑏𝐶𝐾 | 𝑎𝐴𝐶𝐶𝐵𝐼 | 𝑎𝐷𝐴𝐶𝐶𝐵𝐼

Para terminar con aquellas de la forma 𝐷 → 𝑎β:

𝐷 → 𝑏𝐶𝐾 | 𝑎𝐽

Así, la gramática factorizada por la izquierda es 𝐺′ = (Σ, N′, P′, S): Σ = {a, b}

N′ = {A, B, C, D, E, F, G, H, I, J, K}

P′ = { 𝐴 → 𝑏𝐶𝐹 | 𝑎𝐸 , 𝐵 → 𝑏𝐻 | 𝑎𝐺, 𝐶 → 𝑏𝐶𝐵𝐼 | 𝑎𝐼,

𝐷 → 𝑏𝐶𝐾 | 𝑎𝐽, 𝐸 → 𝐴𝐶 | 𝐷𝐴𝐶, 𝐹 → 𝐵𝐸 | 휀, 𝐺 → 𝐴 | 𝐷𝐴, 𝐻 → 𝐶𝐵𝐺 | 휀, 𝐼 → 𝐷 | 휀, 𝐽 → 𝐴𝐶𝐶𝐵𝐼 | 𝐷𝐴𝐶𝐶𝐵𝐼,

𝐾 → 𝐵𝐽 | 𝐶𝐵𝐼}

S = A.

3.2 AUTÓMATAS APILADORES

Los lenguajes que no son regulares no pueden ser reconocidos usando los AF que ya conocemos. Por lo

tanto, para el reconocimiento de lenguajes libres de contexto (no regulares, pues 𝐿𝑅 ⊂ 𝐿𝐿𝐶) y que

representan estructuras con anidamientos se requiere de un mecanismo que tenga la capacidad de

recordar la historia de la entrada leída, en forma explícita y accesible, para tomar una decisión del

movimiento a efectuar.

Esta capacidad de memoria se logra dotando al AF de una memoria de pila, en la cual se van

almacenando símbolos de la entrada que en algún momento son recuperados para su utilización. Este

modelo de autómata se denomina autómata apilador (AP) o Push-Down Automaton, pues al momento

de leer un símbolo de la entrada, puede empujarlo a la pila (push) o bien extraer información de esta

última (pop), además de efectuar una transición de un estado a otro. La figura 3.1 muestra el modelo de

AA como dispositivo físico.

72



FIGURA 3.1: Modelo de un autómata apilador.

Formalmente, un AA es una 7-tupla 𝑀 = (𝑄, Σ, Γ, 𝛿, 𝑞0, 𝑧0, 𝐹), donde:

𝑄 es un conjunto finito de estados.

Σ es el alfabeto de entrada.

Γ es el alfabeto de la pila.

𝛿: (𝑄 × Σ∗ × Γ∗) → (𝑄 × Γ∗).


𝑧0 ∈ Γ es el símbolo inicial de la pila.

𝐹 ⊆ 𝑄 es el conjunto de estados finales.

Para comprender adecuadamente este modelo es necesario explicar con detenimiento la relación de

transición 𝛿. Por definición, un AA corresponde a un AFND con una pila asociada. Además, si se tiene

𝛿(𝑞𝑖 , 𝑤, 𝛼) = (𝑞𝑗 , 𝛽), entonces:

El estado actual del AA es 𝑞𝑖, debe leer desde la entrada la secuencia 𝑤 y la secuencia 𝛼 se

encuentra al tope de la pila.

Una vez efectuada la lectura, pasa al estado 𝑞𝑗 y reemplaza 𝛼 por 𝛽 al tope de la pila.

Cabe destacar como casos particulares a dos operaciones especiales:

Push(a): 𝛿(𝑞𝑖 , 𝑤, 휀) = (𝑞𝑗 , 𝑎), inserta el símbolo 𝑎 al tope de la pila.

Pop: 𝛿(𝑞𝑖 , 𝑤, 𝑎) = (𝑞𝑗 , 휀), quita el símbolo que se encuentre al tope de la pila.

Se define como configuración de un AA al estado en que se encuentra, la porción no leída de la entrada

y el contenido de su pila, es decir, a un elemento de (𝑄 × Σ∗ × Γ∗).

Un paso de computación, denotado por ⊢, corresponde a un cambio en la configuración del AA:

(𝑞𝑖 , 𝑎𝑤, 𝛽𝛼) ⊢ (𝑞𝑗 , 𝑤, 𝛾𝛼). Además, ⊢∗ corresponde a la clausura reflexiva y transitiva de ⊢.

Se dice que un AA 𝑀 acepta o reconoce una entrada 𝑤 ∈ Σ∗ si y solo si, comenzando desde el estado

inicial y al momento de terminar de leer 𝑤, cumple con a lo menos uno de los siguientes criterios:

1. 𝑀 se encuentra en un estado final. Es decir, (𝑞0, 𝑤, 휀) ⊢∗ (𝑞𝑖 , 휀, 𝛼), con 𝑞𝑖 ∈ 𝐹.

2. 𝑀 tiene su pila vacía, es decir, (𝑞0, 𝑤, 휀) ⊢∗ (𝑞𝑖 , 휀, 휀).

Resulta interesante la conclusión de que, al bastar con uno solo de los criterios para la aceptación,

puede darse que para un AA se tenga 𝐹 = 𝜙.

73



Otra observación interesante es que, puesto que 𝐿𝑅 ⊂ 𝐿𝐿𝐶, se tiene que un AF corresponde a un caso

especial de AA en que no se realizan operaciones sobre la pila.

El lenguaje aceptado por un AA 𝑀, 𝐿(𝑀), está dado por: 𝐿(𝑀) = {𝑤: 𝑒𝑠 𝑎𝑐𝑒𝑝𝑡𝑎𝑑𝑎 𝑝𝑜𝑟 𝑀}.

Dos AA 𝑀1 y 𝑀2 son equivalentes si y solo sí 𝐿(𝑀1) = 𝐿(𝑀2).

Ejemplo 3.9:

Sea el AA 𝑀 = (𝑄, Σ, Γ, 𝛿, 𝑞0, 𝑧0, 𝐹), donde:

𝑄 = {𝑞1, 𝑞2}.

Σ = {0, 1, 𝑐}.

Γ = {𝑅, 𝐵, 𝐺}.

𝑞0 = 𝑞1.

𝑧0 = 𝑅.

𝐹 = ∅.

𝛿:

𝛿(𝑞1, 0, 𝑅) = (𝑞1, 𝐵𝑅)

𝛿(𝑞1, 0, 𝐵) = (𝑞1, 𝐵𝐵)

𝛿(𝑞1, 0, 𝐺) = (𝑞1, 𝐵𝐺)

𝛿(𝑞1, 1, 𝑅) = (𝑞1, 𝐺𝑅)

𝛿(𝑞1, 1, 𝐵) = (𝑞1, 𝐺𝐵)

𝛿(𝑞1, 1, 𝐺) = (𝑞1, 𝐺𝐺)

𝛿(𝑞1, 𝑐, 𝑅) = (𝑞2, 𝑅)

𝛿(𝑞1, 𝑐, 𝐵) = (𝑞2, 𝐵)

𝛿(𝑞1, 𝑐, 𝐺) = (𝑞2, 𝐺)

𝛿(𝑞2, 0, 𝐵) = (𝑞2, 휀)

𝛿(𝑞2, 1, 𝐺) = (𝑞2, 휀)

𝛿(𝑞2, 휀, 𝑅) = (𝑞2, 휀)

𝐿(𝑀) = {𝑤𝑐𝑤𝑅: 𝑤 ∈ {0, 1}∗}.

Nótese que este AA solo puede aceptar una palabra por medio de la pila vacía. Para ver su

funcionamiento, veamos en primer lugar la traza para la entrada 𝑤1 = 011𝑐110.

Estado actual Entrada Pila

𝑞1 011𝑐110 𝑅

𝑞1 11𝑐110 𝐵𝑅

𝑞1 1𝑐110 𝐺𝐵𝑅

𝑞1 𝑐110 𝐺𝐺𝐵𝑅

𝑞2 110 𝐺𝐺𝐵𝑅

𝑞2 10 𝐺𝐵𝑅

𝑞2 0 𝐵𝑅

𝑞2 휀 𝑅

𝑞2 휀 휀

Veamos qué ocurre con la entrada 𝑤2 = 01𝑐11.

74



Estado actual Entrada Pila

𝑞1 01𝑐11 𝑅

𝑞1 1𝑐11 𝐵𝑅

𝑞1 𝑐11 𝐺𝐵𝑅

𝑞2 11 𝐺𝐵𝑅

𝑞2 1 𝐵𝑅

ERROR

Así, vemos que 𝑤1 ∈ 𝐿(𝑀), pero 𝑤2 ∉ 𝐿(𝑀).

3.3 EQUIVALENCIA ENTRE CLG Y AA

Existe un teorema que establece que todo lenguaje aceptado por un AA es un LLC y que todo LLC es

aceptado por un AA. Como resultado de la demostración, existen algoritmos que permiten convertir de

AA a GLC y a la inversa.

3.3.1 PASO DE AA A GLC

El algoritmo que permite construir una gramática libre de contexto 𝐺 = (ΣG, N, 𝑃, 𝑆) a partir de un

autómata apilador 𝑀 = (𝑄, ΣM, Γ, 𝛿, 𝑞0, 𝑧0, 𝐹) es el siguiente:

1. Hacer ΣG = ΣM.

2. Hacer N = {𝑆} ∪ {⟨𝑞𝑖 , 𝐴, 𝑞𝑗⟩} ∀𝑞𝑖 , 𝑞𝑗 ∈ Q y todo 𝐴 ∈ Γ.

3. Hacer 𝑆 = 𝑆.

4. Para construir 𝑃, hacer:

a. Agregar 𝑆 → ⟨𝑞0, 𝑧0, 𝑞⟩ ∀𝑞 ∈ Q.

b. Para cada transición de la forma 𝛿(𝑞𝑖 , 𝜎, 𝑧) = (𝑞𝑗 , 휀), crear la producción ⟨𝑞𝑖 , 𝑧, 𝑞𝑗⟩ → 𝜎.

c. Para cada transición de la forma 𝛿(𝑞, 𝜎, 𝑧) = (𝑟, 𝑧1𝑧2 … 𝑧𝑛), crear las producciones ⟨𝑞, 𝑧, 𝑞𝑛⟩ →𝜎⟨𝑟, 𝑧1, 𝑞1⟩⟨𝑞1, 𝑧2, 𝑞2⟩ … ⟨𝑞𝑛−1, 𝑧𝑛, 𝑞𝑛⟩ para todas las combinaciones de 𝑞1, 𝑞2, …, 𝑞𝑛.

5. Eliminar símbolos inútiles.

Ejemplo 3.10:

Construya la GLC lenguaje aceptado por 𝑀 = (𝑄, Σ, Γ, 𝛿, 𝑞0, 𝑧0, 𝐹), donde:

𝑄 = {𝑞, 𝑟}.

Σ = {0, 1}.

Γ = {𝑍, 𝑋}.

𝑞0 = 𝑞.

𝑧0 = 𝑍.

𝐹 = ∅.

𝛿:

𝛿(𝑞, 0, 𝑍) = (𝑞, 𝑋𝑍)

𝛿(𝑞, 0, 𝑋) = (𝑞, 𝑋𝑋)

𝛿(𝑞, 1, 𝑋) = (𝑟, 휀)

75



𝛿(𝑟, 1, 𝑋) = (𝑟, 휀)

𝛿(𝑟, 휀, 𝑍) = (𝑟, 휀)

Inicialmente, con los pasos 1 a 3, tenemos que:

Σ = {0, 1}.

N = {𝑆, ⟨𝑞, 𝑍, 𝑞⟩, ⟨𝑞, 𝑍, 𝑟⟩, ⟨𝑟, 𝑍, 𝑞⟩, ⟨𝑟, 𝑍, 𝑟⟩, ⟨𝑞, 𝑋, 𝑞⟩, ⟨𝑞, 𝑋, 𝑟⟩, ⟨𝑟, 𝑋, 𝑞⟩, ⟨𝑟, 𝑋, 𝑟⟩}.

𝑆 = 𝑆.

Ahora creamos las producciones de 𝑆:

𝑆 → ⟨𝑞, 𝑍, 𝑞⟩ | ⟨𝑞, 𝑍, 𝑟⟩

Ahora creamos las producciones correspondientes a las transiciones de tipo pop:

𝛿(𝑞, 1, 𝑋) = (𝑟, 휀) genera ⟨𝑞, 𝑋, 𝑟⟩ → 1.

𝛿(𝑟, 1, 𝑋) = (𝑟, 휀) genera ⟨𝑟, 𝑋, 𝑟⟩ → 1.

𝛿(𝑟, 휀, 𝑍) = (𝑟, 휀) genera ⟨𝑟, 𝑍, 𝑟⟩ → 휀.

A continuación se construyen las producciones para las transiciones de tipo push:

𝛿(𝑞, 0, 𝑍) = (𝑞, 𝑋𝑍) nos hace agregar producciones de la forma ⟨𝑞, 𝑍, 𝑞2⟩ →0⟨𝑞, 𝑋, 𝑞1⟩⟨𝑞1, 𝑍, 𝑞2⟩. Así, tenemos que:

⟨𝑞, 𝑍, 𝑞⟩ → 0⟨𝑞, 𝑋, 𝑞⟩⟨𝑞, 𝑍, 𝑞⟩ | 0⟨𝑞, 𝑋, 𝑟⟩⟨𝑟, 𝑍, 𝑞⟩ ⟨𝑞, 𝑍, 𝑟⟩ → 0⟨𝑞, 𝑋, 𝑞⟩⟨𝑞, 𝑍, 𝑟⟩ | 0⟨𝑞, 𝑋, 𝑟⟩⟨𝑟, 𝑍, 𝑟⟩

Del mismo modo, para 𝛿(𝑞, 0, 𝑋) = (𝑞, 𝑋𝑋) se tiene:

⟨𝑞, 𝑋, 𝑞⟩ → 0⟨𝑞, 𝑋, 𝑞⟩⟨𝑞, 𝑋, 𝑞⟩ | 0⟨𝑞, 𝑋, 𝑟⟩⟨𝑟, 𝑋, 𝑞⟩ ⟨𝑞, 𝑋, 𝑟⟩ → 0⟨𝑞, 𝑋, 𝑞⟩⟨𝑞, 𝑋, 𝑟⟩ | 0⟨𝑞, 𝑋, 𝑟⟩⟨𝑟, 𝑋, 𝑟⟩

Así, juntando todo anterior, tenemos:

P = {𝑆 → ⟨𝑞, 𝑍, 𝑞⟩ | ⟨𝑞, 𝑍, 𝑟⟩, ⟨𝑞, 𝑍, 𝑞⟩ → 0⟨𝑞, 𝑋, 𝑞⟩⟨𝑞, 𝑍, 𝑞⟩ | 0⟨𝑞, 𝑋, 𝑟⟩⟨𝑟, 𝑍, 𝑞⟩, ⟨𝑞, 𝑍, 𝑟⟩ → 0⟨𝑞, 𝑋, 𝑞⟩⟨𝑞, 𝑍, 𝑟⟩ | 0⟨𝑞, 𝑋, 𝑟⟩⟨𝑟, 𝑍, 𝑟⟩, ⟨𝑟, 𝑍, 𝑞⟩ →, ⟨𝑟, 𝑍, 𝑟⟩ → 휀, ⟨𝑞, 𝑋, 𝑞⟩ → 0⟨𝑞, 𝑋, 𝑞⟩⟨𝑞, 𝑋, 𝑞⟩ | 0⟨𝑞, 𝑋, 𝑟⟩⟨𝑟, 𝑋, 𝑞⟩, ⟨𝑞, 𝑋, 𝑟⟩ → 1 | 0⟨𝑞, 𝑋, 𝑞⟩⟨𝑞, 𝑋, 𝑟⟩ | 0⟨𝑞, 𝑋, 𝑟⟩⟨𝑟, 𝑋, 𝑟⟩, ⟨𝑟, 𝑋, 𝑞⟩ →, ⟨𝑟, 𝑋, 𝑟⟩ → 1}

Para terminar, debemos eliminar símbolos inútiles. Puede resultar cómodo en este punto

renombrar los no terminales. Sean:

𝐴 = ⟨𝑞, 𝑍, 𝑞⟩, 𝐵 = ⟨𝑞, 𝑍, 𝑟⟩, 𝐶 = ⟨𝑟, 𝑍, 𝑞⟩, 𝐷 = ⟨𝑟, 𝑍, 𝑟⟩, 𝐸 = ⟨𝑞, 𝑋, 𝑞⟩, 𝐹 = ⟨𝑞, 𝑋, 𝑟⟩, 𝐺 = ⟨𝑟, 𝑋, 𝑞⟩, 𝐻 = ⟨𝑟, 𝑋, 𝑟⟩.

Así, nos queda:

P = {𝑆 → 𝐴 | 𝐵, 𝐴 → 0𝐸𝐴 | 0𝐹𝐶, 𝐵 → 0𝐸𝐵 | 0𝐹𝐷,

76



𝐶 →, 𝐷 → 휀, 𝐸 → 0𝐸𝐸 | 0𝐹𝐺, 𝐹 → 1 | 0𝐸𝐹 | 0𝐹𝐻, 𝐺 →, 𝐻 → 1}

Comenzamos por eliminar los símbolos muertos:

N′ = {𝐷, 𝐹, 𝐻, 𝐵, 𝑆}

P′ = {𝑆 → 𝐵, 𝐵 → 0𝐹𝐷, 𝐷 → 휀, 𝐹 → 1 | 0𝐹𝐻, 𝐻 → 1}

Para luego eliminar los símbolos inaccesibles:

Σ′ = {0, 1}

N′′ = {𝑆, 𝐵, 𝐹, 𝐷, 𝐻}

P′′ = {𝑆 → 𝐵, 𝐵 → 0𝐹𝐷, 𝐷 → 휀, 𝐹 → 1 | 0𝐹𝐻, 𝐻 → 1}

3.3.2 PASO DE GLC A AA

El algoritmo que permite construir un autómata apilador 𝑀 = (𝑄, ΣM, Γ, 𝛿, 𝑞0, 𝑧0, 𝐹) a partir de una

gramática libre de contexto 𝐺 = (ΣG, N, 𝑃, 𝑆) es el siguiente:

1. Hacer Q = {𝑞0, 𝑞1}.

2. Hacer ΣM = ΣG.

3. Hacer Γ = ΣG ∪ N.

4. Hacer 𝑞0 = 𝑞0.

5. Hacer 𝑧0 = 휀.

6. Hacer F = {𝑞1}.

7. Para construir 𝛿, hacer:

a. Agregar 𝛿(𝑞0, 휀, 휀) = (𝑞1, 𝑆).

b. ∀𝐴 → 𝛼 ∈ 𝑃, agregar 𝛿(𝑞1, 휀, 𝐴) = (𝑞1, 𝛼).

c. ∀𝜎 ∈ ΣM, agregar 𝛿(𝑞1, 𝜎, 𝜎) = (𝑞1, 휀).

El algoritmo anterior construye un AA que simula el comportamiento de las reglas de derivación para

generar la palabra a reconocer. Para esto, comienza por poner en la pila el símbolo inicial de la

gramática, para luego reemplazar no terminales por sus producciones y descartar terminales. La entrada

será válida si la pila se encuentra vacía al término de la entrada.

77



Ejemplo 3.11:

Construya el AA reconocedor del lenguaje generado por 𝐺 = (Σ, N, 𝑃, 𝑆), donde:

Σ = {𝑎, 𝑏, 𝑐}.

N = {𝑆, 𝐴, 𝐵, 𝐶}.

P = {𝑆 → 𝐴𝑆𝐴 | 𝑎𝐶, 𝐴 → 𝐶 | 𝑆, 𝐵 → 𝑐 | 𝐵𝐴, 𝐶 → 𝑏 | 휀}.

𝑆 = 𝑆.

𝑀 = (𝑄, Σ, Γ, 𝛿, 𝑞0, 𝑧0, 𝐹), donde:

𝑄 = {𝑞0, 𝑞1}.

Σ = {𝑎, 𝑏, 𝑐}.

Γ = {𝑎, 𝑏, 𝑐, 𝑆, 𝐴, 𝐵, 𝐶}.

𝑞0 = 𝑞0.

𝑧0 = ∅.

𝐹 = {𝑞1}.

𝛿:

𝛿(𝑞0, 휀, 휀) = (𝑞1, 𝑆)

𝛿(𝑞1, 휀, 𝑆) = (𝑞1, 𝐴𝑆𝐴)

𝛿(𝑞1, 휀, 𝑆) = (𝑞1, 𝑎𝐶)

𝛿(𝑞1, 휀, 𝐴) = (𝑞1, 𝐶)

𝛿(𝑞1, 휀, 𝐴) = (𝑞1, 𝑆)

𝛿(𝑞1, 휀, 𝐵) = (𝑞1, 𝐵𝐴)

𝛿(𝑞1, 휀, 𝐵) = (𝑞1, 𝑐)

𝛿(𝑞1, 휀, 𝐶) = (𝑞1, 𝑏)

𝛿(𝑞1, 휀, 𝐶) = (𝑞1, 휀)

𝛿(𝑞1, 𝑎, 𝑎) = (𝑞1, 휀)

𝛿(𝑞1, 𝑏, 𝑏) = (𝑞1, 휀)

𝛿(𝑞1, 𝑐, 𝑐) = (𝑞1, 휀)

3.4 EJERCICIOS

1. Construya un autómata apilador que reconozca el lenguaje generado por 𝐺 = (Σ, N, 𝑃, 𝑆), con: 𝛴 = {𝑎, 𝑏}

N = {𝑆, 𝐴} 𝑃 = {𝑆 → 𝑎𝐴𝐴, 𝐴 → 𝑎𝑆 | 𝑏𝑆 |𝑎}

𝑆 = 𝑆

2. Construya una GLC que genere el lenguaje 𝐿 = {0𝑛1𝑛: 𝑛 ≥ 1} ∪ {1𝑛0𝑛: 𝑛 ≥ 1}. Obtenga un AA

apilador para el lenguaje generado. Muestre el árbol de derivación y la traza para las entradas 𝑤1 =111000 y 𝑤2 = 00111.

78



3. Obtenga una GLC que genere el lenguaje aceptado por el AA 𝑀 = (𝑄, Σ, Γ, 𝛿, 𝑞0, 𝑧0, 𝐹), donde:

𝑄 = {𝑞0, 𝑞1}

Σ = {0, 1}

Γ = {𝑍0, 𝑋}

𝛿 está dada por:

𝛿(𝑞0, 1, 𝑍0) = (𝑞0, 𝑋𝑍0)

𝛿(𝑞0, 1, 𝑋) = (𝑞0, 𝑋𝑋)

𝛿(𝑞0, 0, 𝑋) = (𝑞1, 𝑋)

𝛿(𝑞0, 휀, 𝑍0) = (𝑞0, 휀) 𝛿(𝑞1, 1, 𝑋) = (𝑞1, 휀)

𝛿(𝑞1, 0, 𝑍0) = (𝑞0, 𝑍0)

𝑞0 = 𝑞0

𝑧0 = 𝑍0

𝐹 = ∅ es el conjunto de estados finales.

4. Obtenga las formas normales de Chomsky y Greibach para la gramática obtenida en el ejercicio

anterior.

5. Factorice por la izquierda las gramáticas obtenidas en el ejercicio anterior.

6. Sea 𝐺 = (Σ, N, 𝑃, 𝑆), con: 𝛴 = {𝑎,∗, . , +, (, )}

N = {𝐴, } 𝑃 = {𝐴 → 𝐴. 𝐴 | 𝐴 + 𝐴 | 𝐴 ∗ | (𝐴) | 𝑎}

𝑆 = 𝐴

a) Construya un AA que reconozca el lenguaje generado.

b) Determine la forma normal de Chomsky y, en caso de haber, elimine símbolos inútiles.

c) Determine la forma normal de Greibach y, en caso de haber, elimine símbolos inútiles.

d) Factorice por la izquierda las gramáticas obtenidas en los puntos b y c.

79



4 MÁQUINAS DE TURING

La máquina de Turing es un modelo abstracto de computador muy útil y sencillo, que es lo

suficientemente general como para representar cualquier programa computacional y, en consecuencia,

la capacidad de computación de un computador de uso general. Su importancia radica en que es la base

de las ciencias teóricas de la computación. Gracias a la sencillez de su descripción y funcionamiento, es

muy adecuada para el análisis matemático, y este último ha conducido a una mejor comprensión de la

computación (y, en consecuencia, de los computadores digitales). Una de las grandes consecuencias de

esta comprensión es el descubrimiento de que existen problemas de cómputo que no pueden ser

resueltos por los computadores, sin importar cuán rápido sea el procesador ni cuanta memoria esté

disponible.

4.1 DEFINICIÓN Y OPERACIÓN

Una MT consiste en una cinta infinita donde se puede leer o escribir información mediante un cabezal

de lectura-escritura. Se define mediante una tupla de 7 elementos, 𝑀 = (𝑄, Σ, Γ, q0, B, F, δ), donde:

𝑄: conjunto finito de estados.

Σ: alfabeto de entrada.

Γ: alfabeto de la cinta.

q0: estado inicial, con q0 ∈ Q.

B: símbolo en blanco, el cual pertenece al alfabeto de la cinta pero no al alfabeto de entrada. Es

decir, B ∈ Γ y B ∉ Σ.

F: conjunto de estados de aceptación, con 𝐹 ⊂ 𝑄.

δ: relación de transición, donde δ: Q × Γ → Q × Γ × {I, D}. Así, un movimiento de la MT considera

el estado actual de la máquina (q) y el símbolo existente en la cinta (𝜎); para así obtener el nuevo

estado (f); el símbolo que se escribe en la cinta (γ), y la dirección en que debe moverse la cinta (m),

que puede tomar los valores izquierda o derecha, denotados por I y D respectivamente. Cabe

señalar que la relación de transición puede ser indefinida para algunos argumentos.

Ejemplo 4.1:

Para comprender mejor el funcionamiento de la MT, se explica aquí el comportamiento de

algunos elementos de una relación de transición:

δ(q0, x) = (q1, y, D): cambia el símbolo x, que se encuentra en la celda de la cinta señalada

por el cabezal, por el símbolo y; pasa del estado q0 al estado q1 y mueve el cabezal una

posición hacia la derecha.

δ(q1, x) = (q2, x, I): reescribe el símbolo x, que se encuentra en la celda de la cinta señalada

por el cabezal; pasa del estado q1 al estado q2 y mueve el cabezal una posición hacia la

izquierda.

δ(q1, B) = (q1, B, I): reescribe el símbolo blanco B, que se encuentra en la celda de la cinta

señalada por el cabezal; permanece en el estado q1 y mueve el cabezal una posición hacia la

izquierda.

Ahora que se ha explicado más claramente el comportamiento de las relaciones de transición, es

interesante mostrar un ejemplo más concreto de MT y su funcionamiento.

80



Ejemplo 4.2:

Sea 𝑀 una MT que encuentra el complemento de una cadena binaria y luego vuelve al principio

de la entrada, dada por 𝑀 = (𝑄, Σ, Γ, q0, B, F, δ), donde:

𝑄 = {q0, q1, q2}.

Σ = {0, 1}.

Γ = {0, 1, B}.

q0 = q0.

B = B.

F = {q2}.

δ = { δ(q0, 0) = (q0, 1, D), δ(q0, 1) = (q0, 0, D), δ(q0, B) = (q1, B, I), δ(q1, 0) = (q1, 0, I), δ(q1, 1) = (q1, 1, I), δ(q1, B) = (q2, B, D)}

Sea además la entrada 1001011. Considere que el cabezal se encuentra sobre el primer 1 de la

palabra y que la MT se encuentra en el estado inicial. Esto puede representarse como:

Como la MT se encuentra en q0 y el cabezal lee un 1, se usa la movida δ(q0, 1) = (q0, 0, D),

por lo que se reemplaza el 1 leído por un 0, se mueve el cabezal hacia la derecha y la MT

permanece en q0:

A continuación es posible aplicar dos veces la movida δ(q0, 0) = (q0, 1, D):

Luego se aplican las movidas δ(q0, 1) = (q0, 0, D) y δ(q0, 0) = (q0, 1, D), en ese orden:

81



Ahora se aplica dos veces la movida δ(q0, 1) = (q0, 0, D):

En este punto, se utiliza la movida δ(q0, B) = (q1, B, I), que conserva el símbolo leído, desplaza

el cabezal hacia la izquierda y cambia el estado de la MT a q1:

Luego se utilizan varias veces las movidas δ(q1, 0) = (q1, 0, I) y δ(q1, 1) = (q1, 1, I):

82



Finalmente, se usa la movida δ(q1, B) = (q2, B, D), que conserva el espacio leído, desplaza el

cabezal hacia la derecha y cambia el estado de la MT a q2:

Como la relación de transición no especifica qué hacer cuando la MT se encuentra en el estado

q2, ésta se detiene. No obstante, como q2 es un estado final, indica que el proceso para

encontrar el complemento de la cadena de entrada terminó satisfactoriamente.

Una observación importante del ejemplo anterior es que no es necesario que el cabezal de la MT vuelva

al inicio de la entrada, siempre y cuando termine en un estado aceptación. De ser así, se entiende que su

operación fue satisfactoria.

La notación empleada en el ejemplo 4.2 para mostrar el funcionamiento de la MT es muy ilustrativa,

aunque informal y ocupa mucho espacio. Así, se vuelve necesario introducir una nueva notación que

resulte más eficiente. Los dos primeros pasos de la operación anterior pueden denotarse como

Bq01001011B → B0q0001011B. Esto significa que, inicialmente, la MT se encuentra en el estado q0

y su cabezal se encuentra situado sobre el primer símbolo de la entrada (el 1 a la derecha del estado).

La flecha indica que la MT pasa a una nueva configuración al usar una de sus movidas. En este caso, la

movida empleada es δ(q0, 1) = (q0, 0, D), por lo que la MT permanece en q0, cambia el 1 leído por

un 0 y desplaza el cabezal en una posición a la derecha.

Ejemplo 4.3:

La secuencia completa de pasos (traza) del ejemplo 4.2 en la nueva notación está dada por:

Bq01001011B → B0q0001011B → B01q001011B → B011q01011B → B0110q0011B →

→ B01101q011B → B011010q01B → B0110100q0B → B011010q10B → B01101q100B →

→ B0110q1100B → B011q10100B → B01q110100B → B0q1110100B → Bq10110100B →

→ q1B0110100B → Bq20110100B

4.2 ¿SON LAS MT MÁS POTENTES QUE LOS AF Y LOS AA?

Ya se ha comprobado que los AA son más poderosos que los AF, puesto que son capaces de reconocer

LLC (cabe recordar que todo LR es también LLC). Ahora es el momento de comprobar que la MT

también es capaz de reconocer LR.

Ejemplo 4.4:

Construya una MT que reconozca las palabras del lenguaje regular denotado por 𝑟 = 0∗1 (no es

necesario volver al comienzo de la palabra). Muestre la traza para las entradas 𝑤1 = 001 y

𝑤2 = 010.

83



𝑀 = (𝑄, Σ, Γ, q0, B, F, δ), donde:

𝑄 = {q0, q1, q2}.

Σ = {0, 1}.

Γ = {0, 1, B}.

q0 = q0.

B = B.

F = {q2}.

δ = { δ(q0, 0) = (q0, 0, D), δ(q0, 1) = (q1, 1, D), δ(q1, B) = (q2, B, I)}

Traza para 𝑤1 = 001: Bq0001B → B0q001B → B00q01B → B001q1B → B00q21B. Como q2

es estado final, se acepta w1 como perteneciente al lenguaje.

Traza para 𝑤2 = 010: Bq0010B → B0q010B → B01q11B. Como δ(q1, 1) no está definida y

q1 no es estado final, no se acepta w2 como perteneciente al lenguaje.

El ejemplo 4.4 muestra claramente que es sencillo construir MTs que reconozcan lenguajes regulares.

El ejemplo 4.5 muestra un ejemplo de MT reconocedora de LLC.

Ejemplo 4.5:

Construya una MT que reconozca las palabras del lenguaje libre de contexto definido por 𝐿 ={0𝑛1𝑛, 𝑛 ≥ 1} (no es necesario volver al comienzo de la palabra). Muestre la traza para las

entradas 𝑤1 = 0011 y 𝑤2 = 001.

Una buena estrategia en este caso es reemplazar símbolos por otros para marcarlos como ya

leídos. Así, se usará x para reemplazar los ceros e y para los unos. Si bien existen diferentes

modos de resolver este problema, acá se modificarán los símbolos extremos, emparejándolos, y

luego se repetirá el proceso con parejas hacia el interior.

𝑀 = (𝑄, Σ, Γ, q0, B, F, δ), donde:

𝑄 = {q0, q1, q2, q3, q4}.

Σ = {0, 1}.

Γ = {0, 1, x, y, B}.

q0 = q0.

B = B.

F = {q4}.

δ = { δ(q0, 0) = (q1, x, D), δ(q0, y) = (q4, y, D), δ(q1, 0) = (q1, 0, D), δ(q1, 1) = (q1, 1, D), δ(q1, y) = (q2, y, I), δ(q1, B) = (q2, B, I), δ(q2, 1) = (q3, y, I), δ(q3, 0) = (q3, 0, I), δ(q3, 1) = (q3, 1, I), δ(q3, x) = (q0, x, D)}

Traza para 𝑤1 = 0011: Bq00011B → Bxq1011B → Bx0q111B → Bx01q11B → Bx011q1B →

→ Bx01q21B → Bx0q31yB → Bxq301yB → Bq3x01yB → Bxq001yB → Bxxq11yB →

→ Bxx1q1yB → Bxxq21yB → Bxq3xyyB → Bxxq0yyB → Bxxyq4yB. Como q4 es estado final,

se acepta w1 como perteneciente al lenguaje.

84



Traza para 𝑤2 = 001: Bq0001B → Bxq101B → Bx0q11B → Bx01q1B → Bx0q21B →

→ Bxq30yB → Bq3x0yB → Bxq00yB → Bxxq1yB → Bxq2xyB. Como δ(q2, x) no está definida

y q2 no es estado final, no se acepta w2 como perteneciente al lenguaje.

Finalmente, queda por ver si las MT son más poderosas que los AA. De unidades anteriores sabemos

que 𝐿1 = {0𝑛1𝑛, 𝑛 ≥ 1} es libre de contexto. No obstante, 𝐿2 = {0𝑛1𝑛2𝑛, 𝑛 ≥ 1} no es libre de

contexto, pues la operación del AA retira cada 0 de la pila al emparejarla con un 1 y, en consecuencia,

no queda ningún mecanismo para contar la cantidad de 2. El ejemplo 4.6 muestra que las MT sí son

capaces de reconocer esta clase de lenguajes.

Ejemplo 4.6:

Construya una MT que reconozca las palabras del lenguaje libre de contexto definido por 𝐿 ={0𝑛1𝑛2𝑛, 𝑛 ≥ 1} (no es necesario volver al comienzo de la palabra). Muestre la traza para las

entradas 𝑤1 = 001122 y 𝑤2 = 0112.

En este caso se emplea una estrategia semejante al ejemplo 4.5, por lo que no se explica en gran

detalle.

𝑀 = (𝑄, Σ, Γ, q0, B, F, δ), donde:

𝑄 = {q0, q1, q2, q3, q4}.

Σ = {0, 1, 2}.

Γ = {0, 1, 2, x, y, z, B}.

q0 = q0.

B = B.

F = {q4}.

δ = { δ(q0, 0) = (q1, x, D), δ(q0, y) = (q0, y, D), δ(q0, z) = (q0, z, D), δ(q0, B) = (q4, B, I), δ(q1, 0) = (q1, 0, D), δ(q1, 1) = (q2, y, D), δ(q1, y) = (q1, y, D), δ(q1, y) = (q2, y, I), δ(q2, 1) = (q2, 1, D), δ(q2, 2) = (q3, z, I), δ(q2, z) = (q2, z, D), δ(q3, 0) = (q3, 0, I), δ(q3, 1) = (q3, 1, I), δ(q3, x) = (q0, x, D), δ(q3, y) = (q3, y, I), δ(q3, z) = (q3, z, I)}

Traza para 𝑤1 = 001122: Bq0001122B → Bxq101122B → Bx0q11122B → Bx0𝑦q2122B →

→ Bx0𝑦1q222B → Bx0𝑦q31𝑧2B → Bx0q3𝑦1𝑧2B → Bxq30𝑦1𝑧2B → Bq3x0𝑦1𝑧2B →

→ Bxq00𝑦1𝑧2B → Bxxq1𝑦1𝑧2B → Bxx𝑦q11𝑧2B → Bxx𝑦𝑦q2𝑧2B → Bxx𝑦𝑦𝑧q22B →

→ Bxx𝑦𝑦q3𝑧𝑧B → Bxx𝑦q3𝑦𝑧𝑧B → Bxxq3𝑦𝑦𝑧𝑧B → Bxq3x𝑦𝑦𝑧𝑧B → Bxxq0𝑦𝑦𝑧𝑧B →

→ Bxx𝑦q0𝑦𝑧𝑧B → Bxx𝑦𝑦q0𝑧𝑧B → Bxx𝑦𝑦𝑧q0𝑧B → Bxx𝑦𝑦𝑧𝑧q0B → Bxx𝑦𝑦𝑧q4𝑧B. Como q4 es

estado final, se acepta w1 como perteneciente al lenguaje.

Traza para 𝑤2 = 0112: Bq00112B → Bxq1112B → Bxyq212B → Bxy1q22B → Bxyq31zB →Bxq3y1zB → Bq3xy1zB → Bxq0y1zB → Bxyq01zB. Como δ(q0, 1) no está definida y q0 no

es estado final, no se acepta w2 como perteneciente al lenguaje.

El ejemplo 4.6 muestra que las MT permiten reconocer un conjunto de lenguajes más amplio que el de

los LLC: los lenguajes recursivamente enumerables.

85



4.3 OTROS EJEMPLOS Y APLICACIONES DE MT

Las MT no solo sirven como reconocedoras de lenguajes. Al ser equivalentes a cualquier computador

de uso general, también resultan útiles como traductoras de lenguajes y evaluadores de funciones, para

dar algunos ejemplos. De hecho, la MT del ejemplo 4.2 implementa la complementación. A

continuación se muestran otros ejemplos en que la MT no actúa como reconocedora de un lenguaje.

Ejemplo 4.7:

Construya una MT que lea un número escrito en sistema unario cuyo único símbolo es A, y lo

reescriba en binario, borrando cualquier otro símbolo de la cinta (recuerde que la cinta de la MT

es infinita hacia ambos lados). Muestre además la traza para la entrada 𝑤 = 𝐴𝐴𝐴.

𝑀 = (𝑄, Σ, Γ, q0, B, F, δ), donde:

𝑄 = {q0, q1, q2, q3}.

Σ = {A}.

Γ = {A, 0, 1, x, B}.

q0 = q0.

B = B.

F = {q3}.

δ = { δ(q0, A) = (q1, x, I), δ(q0, 0) = (q0, 0, D), δ(q0, x) = (q0, x, D), δ(q0, B) = (q2, B, I), δ(q1, 0) = (q0, 1, D), δ(q1, 1) = (q1, 0, I), δ(q1, x) = (q1, x, I), δ(q1, B) = (q0, 1, D), δ(q2, 0) = (q3, 0, D), δ(q2, 1) = (q3, 1, D), δ(q2, x) = (q2, B, I)}

Traza para 𝑤 = 𝐴𝐴𝐴: Bq0𝐴𝐴𝐴B → Bq1𝐵𝑥𝐴𝐴B → B1q0𝑥𝐴𝐴B → B1xq0𝐴𝐴B → B1q1x𝑥𝐴B →

→ Bq11x𝑥𝐴B → Bq1B0x𝑥𝐴B → B1q00x𝑥𝐴B → B10q0x𝑥𝐴B → B10xq0𝑥𝐴B →

→ B10x𝑥q0𝐴B → B10xq1𝑥𝑥B → B10q1𝑥𝑥𝑥B → B1q10𝑥𝑥𝑥B → B11q0𝑥𝑥𝑥B →

→ B11𝑥q0𝑥𝑥B → B11𝑥𝑥q0𝑥B → B11𝑥𝑥𝑥q0B → B11𝑥𝑥q2𝑥B → B11𝑥q2𝑥B → B11q2𝑥B →

→ B1q21B → B11q3B. Como q3 es estado final, se acepta la conversión de w como exitosa.

Ejemplo 4.8:

Construya una MT que lea un entero binario y determine si la cantidad de 1s es par o impar y

escriba el resultado al final de la entrada (0 si es par, 1 si es impar). Considere que el 0 es par.

Muestre además la traza para las entradas 𝑤1 = 101 y 𝑤2 = 010011.

𝑀 = (𝑄, Σ, Γ, q0, B, F, δ), donde:

𝑄 = {q0, q1, q2}.

Σ = {A}.

Γ = {0, 1 B}.

q0 = q0.

B = B.

F = {q2}.

δ = {δ(q0, 0) = (q0, 0, D), δ(q0, 1) = (q1, 1, D), δ(q0, B) = (q2, 0, I), δ(q1, 0) = (q1, 0, D), δ(q1, 1) = (q0, 1, D), δ(q1, B) = (q2, 1, I)}

86



Traza para 𝑤1 = 101: Bq0101B → B1q101B → B10q11B → B101q0B → B1010q2B. Como

q2 es estado final, se acepta la comprobación de paridad como exitosa.

Traza para 𝑤2 = 010011: Bq0010011B → B0q010011B → B01q10011B → B010q1011B →

→ B0100q111B → B01001q01B → B010011q1B → B0100111q2B. Como q2 es estado final,

se acepta la comprobación de paridad como exitosa.

4.4 EXTENSIONES AL MODELO DE MT

Existen diversas variantes al modelo de MT descrito en las secciones anteriores, todas ellas

equivalentes.

4.4.1 MT CON MOVIMIENTO DE ESPERAR

En este caso se modifica la definición de la relación de transición para que tenga ahora la forma δ: Q ×Γ → Q × Γ × {I, D, E}, donde E corresponde a esperar. Si se tiene un movimiento de la forma δ(p, σ) =(q, σ′, E), significa que desde el estado p, al leer el símbolo σ, se pasa al estado q, se escribe el símbolo

σ′ en la cinta y el cabezal permanece en la posición actual.

4.4.2 MT CON CINTA MULTIPISTA

En esta variante, cada celda de la cinta se divide en sub-celdas. Así, cada celda puede contener varios

símbolos de Γ a la vez, como muestra la figura 4.1.

FIGURA 4.1: MT con cinta de tres pistas.

Como cada celda de la cinta contiene varios símbolos, el contenido de una celda se representa mediante

𝑛-tuplas ordenadas (𝑛 corresponde a la cantidad de sub-celdas). Esta MT también posee solo un

cabezal, y sus movimientos dependen del contenido total de la celda. Un ejemplo de movida para la

MT de la figura 4.1 puede ser δ(p, (0, 0, B)) = (q, (B, 1, 1), D).

4.4.3 MT MULTI CINTA

En esta variante, la MT consiste de 𝑘 cintas y un control finito que cuenta con 𝑘 cabezales. Cada cinta

es infinita en ambas direcciones, y la MT define su movimiento en función del símbolo leído por cada

uno de los cabezales, proporciona reglas de sustitución para cada uno de los símbolos leídos y señala la

87



dirección de movimiento para cada uno de los cabezales. Inicialmente, este modelo de MT comienza

con la entrada en la primera cinta y con las cintas restantes en blanco.

4.4.3 MT MULTI DIMENSIONAL

Es una MT cuya cinta se extiende infinitamente en más de una dirección. El ejemplo más simple

corresponde a la máquina bidimensional, cuya cinta se extiende infinitamente hacia arriba, abajo,

derecha e izquierda (ver figura 4.2).

FIGURA 4.2: MT bidimensonal.

La MT bidimensional de la figura 4.2 requiere que se incorporen dos nuevos movimientos para el

cabezal: hacia arriba y hacia abajo (𝑈 y 𝐴, respectivamente). Así, la definición de los movimientos del

cabezal es ahora {𝐼, 𝐷, 𝑈, 𝐴}.

4.5 TESIS DE CHURCH-TURING

La teoría de la computabilidad analiza y determina qué problemas pueden ser resueltos mediante un

algoritmo o bien usando una MT. Esto conduce a la noción de que no todos los problemas pueden ser

resueltos usando un computador, sin importar si se cuenta incluso con tiempo y memoria ilimitados. El

estudio de esta rama de la ciencia se inicia hacia la década de 1930. En 1928, Hilbert plantea el

problema de decisión (conocido como Entscheidungsproblem), consistente en encontrar un sistema

matemático formal, complejo y consistente que sea capaz de probar la validez de todas las

proposiciones matemáticas. La idea era que, si se obtenía este algoritmo, ya no sería necesario hacer

demostraciones, pues esta tarea sería realizada por el algoritmo.

Gödel plantea posteriormente el teorema de la incompletitud, que establece que “ningún teorema que

contenga los teoremas de la aritmética con axiomas recursivamente enumerables puede ser consistente

y completo a la vez”, lo que sugiere que, aunque es posible obtener algoritmos que permitan probar la

veracidad de algunas proposiciones matemáticas, es imposible encontrar uno que pueda demostrar la

validez de todos los teoremas. Este teorema echa por tierra la propuesta del Entscheidungsproblem.

En 1932, Church emplea una notación formal a fin de llevar todas las fórmulas matemáticas a una

notación estándar, para que así un teorema matemático pudiera ser probado mediante un algoritmo

88



general. Sin embargo, solo una parte de los teoremas conocidos pudo ser transformada. A éstos se los

llamó funciones -computables. Posteriormente, Gödel demuestra que una función 𝑓 puede definirse

con un conjunto de términos y símbolos matemáticos previamente definidos, incluyéndose a sí misma,

dando así origen a las funciones recursivas de Herbrand-Gödel.

En 1936, Church demuestra la equivalencia entre las funciones -computables y las funciones

recursivas de Herbrand-Gödel, y establece que solo éstas pueden ser probadas mediante un algoritmo,

sugiriendo así su famosa hipótesis, que establece que “la clase de funciones que pueden ser calculadas

mediante un algoritmo, coinciden con las funciones recursivas”. Con esto, Church demostró que el

Entscheidungsproblem y otros problemas no son computables.

También en 1936, paralelamente a Church, Turing publica un trabajo en el cual postula la tesis que

establece que “las funciones que pueden ser calculadas mediante un algoritmo, son las funciones que

pueden ser calculadas por medio de una máquina de Turing”. También demostró que el

Entscheidungsproblem no es computable.

Las conclusiones de los trabajos paralelos de Church y Turing, junto a sus resultados en cuanto al

Entscheidungsproblem, forman lo que hoy se conoce como tesis de Church-Turing: “si una MT no

puede resolver un problema, ningún otro computador puede hacerlo, puesto que no existe un algoritmo

que pueda realizar esta tarea”.

4.6 EJERCICIOS

1. Considere la MT del ejemplo 4.5:

a. Construya una MT equivalente.

b. Modifique la MT del ejemplo para que conserve la entrada original y devuelva el cabezal al

inicio de la palabra. Muestre la traza para las entradas del ejemplo 4.5.

2. Construya las siguientes MT. Para todas ellas, muestre trazas de ejemplo.

a. Que reconozca el lenguaje 𝐿 = {𝑤 ∈ {0, 1}∗: |𝑤|0 = |𝑤|1}.

b. Que sume 1 a un entero binario 𝑛.

c. Que reste 1 a un entero binario 𝑛 ≥ 1.

d. Que reconozca secuencias conformadas por paréntesis balanceados.

e. Que lea dos enteros binarios, separados por $, y que escriba el resultado de su suma.

f. Que reconozca el lenguaje de los enteros binarios que son potencias de 2.

g. Que reconozca el lenguaje de los enteros binarios que son palíndromos. La entrada puede tener

0s a la izquierda.

h. Que reconozca el lenguaje representado por 𝑟 = 𝑎𝑎∗(𝑏 + 𝑎)∗𝑐.

89



5 COMPLEJIDAD COMPUTACIONAL

5.1 COMPLEJIDAD DE ALGORITMOS

Un algoritmo es una secuencia de instrucciones que se debe seguir para resolver un determinado

problema, que además garantiza la obtención de una respuesta al terminar. Debe ser preciso y

detallado, es decir, no usa intuición ni creatividad, ni tampoco requiere de decisiones subjetivas. Los

algoritmos se remontan hasta muy atrás en la historia. El más antiguo conocido, el algoritmo para

determinar el máximo común divisor de dos números, se atribuye a Euclides.

En el párrafo anterior se mencionó que los algoritmos garantizan la obtención de una respuesta al

terminar de seguir sus pasos para resolver un problema dado. Esto se traduce, entonces, en que los

algoritmos ofrecen una solución general para un problema dado que esté acotado a un dominio

determinado. Se denomina instancia de un problema a un caso particular de éste, y un algoritmo debe

funcionar correctamente para todas las instancias del problema, sin considerar las restricciones propias

de la implementación: capacidad de memoria, rangos de valores, etc.

En muchas ocasiones ocurre que un problema puede ser resuelto por muchos algoritmos. Entonces

surge el problema de escoger cuál de ellos utilizar. Si solo se requiere resolver unas pocas instancias

sencillas del problema, no importa cuál sea el algoritmo seleccionado. No obstante, si la instancia a

resolver es muy difícil o bien se requiere resolver muchas instancias, es importante escoger el mejor.

Existen dos enfoques para determinar cuál algoritmo escoger:

Empírico (a posteriori): consiste en programar todas las alternativas, probarlas con diversas

instancias y comparar su desempeño. Por supuesto, este enfoque resulta muy poco práctico.

Teórico (a priori): consiste en determinar matemáticamente cuántos recursos se necesitan para cada

algoritmo. Esta tarea se denomina estudio de la complejidad y consiste en la obtención de una

expresión matemática que refleja el comportamiento del algoritmo en función de los datos de

entrada.

La complejidad o eficiencia de un algoritmo debe ser estudiada con respecto a algún recurso crítico: el

tiempo de computación (cuánto tiempo toma ejecutar la implementación de un algoritmo), la cantidad

de espacio necesaria para almacenar los datos requeridos, la cantidad de procesadores necesarios, etc.

En general, la complejidad de tiempo es mayor que la complejidad de espacio ya que cualquier

información almacenada debe ser leída o guardada en algún instante. Por ese motivo, generalmente se

trabaja con la complejidad de tiempo.

Se señaló anteriormente la complejidad de un algoritmo se determina en función de los datos de

entrada. En efecto, se debe buscar una expresión matemática en función del tamaño de estos datos.

Formalmente, el tamaño de un dato se refiere a la cantidad de bits necesarios para su almacenamiento.

No obstante, esa noción depende de la implementación del algoritmo, por lo que no es adecuada para

una evaluación teórica. En consecuencia, se considera simplemente que el tamaño es un número natural

que indica la cantidad de elementos de un objeto, por ejemplo, la cantidad de elementos de un arreglo o

bien el número de nodos y aristas de un grafo.

El comportamiento real de un algoritmo depende de muchos factores propios de su implementación.

Entre ellos se encuentran las restricciones de arquitectura, es decir, el compilador o intérprete utilizado,

90



el lenguaje de programación y la máquina en que se ejecute. También influyen algunos factores

humanos, como la forma de escribir el código fuente o las estructuras de datos seleccionadas. En

consecuencia, se hace necesario evaluar el comportamiento del algoritmo en forma independiente de

factores humanos y de máquina.

Ahora surge el problema de determinar la eficiencia de un algoritmo de algún modo estándar. Si el

tiempo de ejecución depende de la implementación, no es posible medirlo en segundos, pues no todos

los computadores tardan lo mismo en ejecutar un mismo programa. Este problema puede ser resuelto

gracias al principio de invariancia, que indica que dos implementaciones diferentes de un mismo

algoritmo no difieren en su eficiencia más que en una constante multiplicativa 𝑐. Así, es posible

expresar la complejidad en términos del tamaño de la entrada como 𝑐 · 𝑡(𝑛). Más adelante, con el

estudio de la notación asintótica, se verá que es posible ignorar la constante y decir, simplemente, que

el algoritmo está en el orden de 𝑡(𝑛). En algunos casos, la complejidad recibe un nombre especial. Un

algoritmo es:

Lineal si está en el orden de 𝑛.

Cuadrático se está en el orden de 𝑛2.

Polinomial si está en el orden de 𝑛𝑘.

Exponencial si está en el orden de 𝑐𝑛.

Otro aspecto importante al evaluar la complejidad de un algoritmo es que frecuentemente los

problemas tienen diversas instancias de un mismo tamaño y el tiempo que tarda un algoritmo en

resolverlas puede variar mucho. En consecuencia, no tiene sentido evaluar la eficiencia de un algoritmo

solo en función del tamaño de la instancia, pues el algoritmo debe funcionar correctamente para todas

las instancias. En el mejor escenario, el tiempo requerido suele ser poco. Sin embargo, si el tiempo de

respuesta es crítico, es necesario considerar el tiempo requerido para el peor escenario posible.

También puede ser útil analizar el caso promedio, aunque resulta muy difícil pues esto requiere conocer

a priori la distribución de los casos a resolver. En consecuencia, el análisis de la complejidad del caso

medio no será considerado en este curso.

5.1.1 LA BÚSQUEDA DE LA EFICIENCIA

Es sabido que los computadores son cada vez más rápidos. Esto podría conducir a la idea de que la

eficiencia de los algoritmos es cada vez menos importante. Sin embargo, no necesariamente es así.

Suponga que se tiene un algoritmo exponencial 𝐴1 para resolver un problema y una máquina 𝑀1 que

tarda 10−4 × 2𝑛 segundos en resolver una instancia de tamaño 𝑛:

Para una instancia de tamaño 10 se necesitan 0,1024 segundos.

Para otra de tamaño 20, 104,8576 segundos (cerca de 2 minutos).

Para una tercera de tamaño 38, algo más de 318 días.

Si 𝑀1 es reemplazada por una máquina𝑀2 que tarda 10−6 × 2𝑛 segundos en resolver una instancia de

tamaño 𝑛, se tiene que:


Para la de tamaño 20, 1,048576 segundos.

Para la de tamaño 38, algo más de 76 horas.

91



Considere ahora un algoritmo cúbico 𝐴2 y suponga que 𝑀1 tarda 10−2 × 𝑛3 segundos en resolver una

instancia de tamaño 𝑛:

Para una instancia de tamaño 10 se necesitan 10 segundos.

Para la de tamaño 20, 80 segundos.

Para la de tamaño 38, algo más de 9 minutos.

Si ahora se evalúa el algoritmo 𝐴2 en la máquina 𝑀2 , que tarda 10−4 × 𝑛3 segundos en resolver una

instancia de tamaño 𝑛, se tiene que:




La figura 5.1 refleja el análisis anterior.

FIGURA 5.1: Comparación del desempeño de dos algoritmos.

Se puede concluir que para instancias pequeñas es mejor el algoritmo original 𝐴1, pero para instancias

grandes, el algoritmo cúbico (𝐴2) es muchísimo mejor. En ocasiones, dependiendo del tipo de

instancias con las que se requiera trabajar, resulta adecuado proponer un tercer algoritmo que los

combine a ambos.

5.1.2 CÁLCULO DE LA COMPLEJIDAD

Se denomina operación elemental o instrucción básica a una instrucción cuyo tiempo de ejecución está

acotado superiormente por una constante que solo depende de la implementación usada (la máquina

que ejecute el programa, el lenguaje de programación empleado, etc.), por lo que se asume que tienen

un tiempo de ejecución unitario. El ejemplo 5.1 muestra una justificación para esta simplificación.

Ejemplo 5.1: Cota superior para el tiempo de ejecución de instrucciones básicas.

Considere que un algoritmo requiere efectuar 𝑎 operaciones de adición, 𝑚 operaciones de

multiplicación y 𝑠 operaciones de asignación. Además, se sabe que una suma nunca requiere

más de 𝑡𝑎 microsegundos, una multiplicación nunca requiere más de 𝑡𝑚 microsegundos y una

asignación nunca requiere más de 𝑡𝑠 segundos.

92



Por la definición anterior se tiene que el tiempo 𝑡 de ejecución del algoritmo está acotado por

𝑡 ≤ 𝑎𝑡𝑎 + 𝑚𝑡𝑚 + 𝑠𝑡𝑠. Esto quiere decir que 𝑡 ≤ max{𝑡𝑎, 𝑡𝑚, 𝑡𝑠} × (𝑎 + 𝑚 + 𝑠). Pero se sabe

que el tiempo requerido por cada operación elemental no es importante pues se descartan las

constantes, por lo que se asume que pueden ser ejecutadas en tiempo unitario. Por tanto, se

puede afirmar que el algoritmo en cuestión es del orden de 𝑎 + 𝑚 + 𝑠.

Formalizando la idea del ejemplo 5.1, se tiene que, para un algoritmo dado, la complejidad de tiempo

queda determinada por el tiempo de ejecución de cada instrucción básica y el número de veces que se

ejecuta esa instrucción.

Sea:

𝐴: un algoritmo para resolver un problema dado,

𝐼1, … , 𝐼𝑘: una secuencia de instrucciones básicas del algoritmo 𝐴,

𝑡𝑗: el tiempo de ejecución de la instrucción 𝐼𝑗 , 1 ≤ 𝑗 ≤ 𝑘,

𝑓𝑗: el número de veces que se ejecuta 𝐼𝑗 , 1 ≤ 𝑗 ≤ 𝑘.

La complejidad de tiempo del algoritmo A está dada por:

𝑇𝐴 = ∑ 𝑓𝑗

·

𝑗

𝑡𝑗

Como todas las instrucciones básicas requieren un tiempo constante, se puede suponer que esos

tiempos son iguales, es decir: 𝑡1 = 𝑡2 = ⋯ = 𝑡𝑘 = 1. Luego, se tiene:

𝑇𝐴 = ∑ 𝑓𝑗

𝑗

Es decir, la complejidad de tiempo corresponde al número total de instrucciones básicas necesarias de

ejecutar para una computación completa del algoritmo.

Ejemplo 5.2: Suma de matrices.

El problema consiste en, dadas 𝐴, 𝐵 ∈ 𝑀𝑛×𝑚, calcular 𝐶 = 𝐴 + 𝐵 ∈ 𝑀𝑛×𝑚. Podemos resolver

este problema usando el algoritmo 5.1 que se muestra a continuación.

Algoritmo 5.1:

Dadas 𝐴, 𝐵 ∈ 𝑀𝑛×𝑚:

Para 𝑖 = 1 a 𝑛 hacer:

Para 𝑗 = 1 a 𝑚 hacer:

𝑐𝑖𝑗 = 𝑎𝑖𝑗 + 𝑏𝑖𝑗

Devolver 𝐶.

Complejidad:

Aquí se observan dos ciclos Para y una asignación, que es una instrucción básica.

El primer ciclo Para se ejecuta 𝑛 veces.

Además, el ciclo Para anidado dentro del primero se ejecuta 𝑚 veces.

93



Luego, la instrucción básica anidada en los dos ciclos se ejecuta 𝑚 veces (por el segundo

ciclo) por las 𝑛 veces que se ejecuta el primer ciclo.

La asignación tiene lugar en un tiempo 𝑡.

∴ La complejidad de tiempo del algoritmo 5.1 queda definida por 𝑇𝐴 = 𝑚 × 𝑛 × 𝑡. Asumiendo

𝑡 = 1 ⇒ t=1 ⇒𝑇𝐴 = 𝑚 × 𝑛. En particular, si 𝑚 = 𝑛 entonces 𝑇𝐴 = 𝑛2.

Del ejemplo 5.2 se desprenden las siguientes conclusiones, que se resumen en la figura 5.2:

Las instrucciones simples se ejecutan en un tiempo constante que se aproxima a 1.

Las instrucciones condicionales se consideran como una instrucción simple.

Los ciclos iterativos se ejecutan la cantidad de veces que tienen establecido repetirse. Esto es, si el

ciclo Para repite sus instrucciones desde 1 a 𝑛, su tiempo es 𝑛.

Los ciclos iterativos anidados se ejecutan en su tiempo correspondiente, multiplicado por las veces

que se repita el ciclo en el cual están anidados.

FIGURA 5.2: Resumen para el cálculo de complejidad computacional.

5.2 MODELO DE MÁQUINA

Se utiliza el modelo RAM (Máquina de Acceso Aleaotrio, Random Access Machine en inglés),

definido por el esquema de la figura 5.3.

FIGURA 5.3: Modelo RAM.

Se denomina entrada a los datos del problema que se entregan al algoritmo y salida a la respuesta

entregada por éste.

94



El análisis de complejidad de un algoritmo se hace respecto al mejor caso (sus entradas más favorables

en cuanto al tiempo requerido), al peor caso (las entradas menos favorables) y al caso medio.

Antes de seguir adelante, es necesario conocer algunas definiciones:

Paso: tiempo de una instrucción básica.

Complejidad local: número total de pasos de la ejecución completa del algoritmo para una entrada

dada.

Complejidad asintótica: menor cota superior de la complejidad local.

Complejidad del mejor caso: tiempo para ejecutar el algoritmo con la entrada más favorable.

Complejidad del peor caso: tiempo en ejecutar el algoritmo con la entrada más desfavorable.

Complejidad del caso medio: tiempo promedio en ejecutar el algoritmo con todas las entradas

posibles.

Dado un algoritmo A para resolver un problema 𝜋, sean:

𝐸1, 𝐸2, 𝐸3, . . . , 𝐸𝑘 todas las posibles entradas,

𝑇1, 𝑇2, 𝑇3, . . . , 𝑇𝑘 tiempo de ejecutar 𝐴 para la entrada 𝑗, 1 ≤ 𝑗 ≤ 𝑘,

𝑃1, 𝑃2, 𝑃3, . . . , 𝑃𝑘 probabilidad de que ocurra la entrada 𝑗, 1 ≤ 𝑗 ≤ 𝑘.

La complejidad del mejor caso es 𝐶𝑀𝐶 = 𝑚𝑖𝑛{𝑇𝑗 / 1 ≤ 𝑗 ≤ 𝑘},

La complejidad del peor caso es 𝐶𝑃𝐶 = 𝑚𝑎𝑥{𝑇𝑗 / 1 ≤ 𝑗 ≤ 𝑘},

La complejidad del caso medio está dada por:

∑ 𝑃𝑗𝑇𝑗

𝑗

La complejidad más utilizada para confrontar los rendimientos de los algoritmos es la del peor caso.

Una de las razones es que da una cota para todas las entradas, incluyendo aquellas muy malas, que el

análisis del caso promedio no puede ofrecer. Otra razón es que la complejidad del caso medio es más

difícil de calcular, dado que es necesario conocer todas las posibles entradas del algoritmo y sus

probabilidades.

5.3 NOTACIÓN O

Dadas 𝑓: ℝ → ℝ+ y 𝑔: ℝ → ℝ+, se dice que 𝑓 es del orden de de 𝑔, (𝑓 ∼ Ω(𝑔)) si existen constantes 𝑐

y 𝑛0 tales que 𝑓(𝑛) ≤ 𝑐 · 𝑔(𝑛) ∀ 𝑛 ≥ 𝑛0 (figura 5.4). En otras palabras, 𝑓 está acotada inferiormente

por 𝑐 · 𝑔(𝑛) para todo valor 𝑛 ≥ 𝑛0. La figura 5.4 muestra un ejemplo.

95



FIGURA 5.4: Ejemplo de notación O.

Ejemplo 5.3: Aproximaciones de funciones.

3𝑛 + 1 ∼ 𝑂(𝑛) 3𝑛2 + 𝑛 ∼ 𝑂(𝑛2) 5𝑛4 ∼ 𝑂(𝑛4)

10 · 2𝑛 ∼ 𝑂(2𝑛)

Propiedades de la notación O:

1. 𝑂(𝑓) + 𝑂(𝑔) = 𝑂(𝑓 + 𝑔) Regla de la suma

2. 𝑂(𝑘 · 𝑓) = 𝑘 · 𝑂(𝑓) = 𝑂(𝑓), 𝑘 𝑐𝑡𝑒. Constantes multiplicativas 3. 𝑂(𝑓) · 𝑂(𝑔) = 𝑂(𝑓 · 𝑔) Regla de la multiplicación 4. 𝑓 ≥ 𝑔 ⇒ 𝑂(𝑓 + 𝑔) = 𝑂(𝑓) Cotas 5. 𝑓 ≥ 𝑔 ⇒ (ℎ ∼ 𝑂(𝑔) 𝑒𝑛𝑡𝑜𝑛𝑐𝑒𝑠 ℎ ∼ 𝑂(𝑓)) Transitividad

Observaciones:

La notación O desprecia las constantes aditivas y multiplicativas.

La medida de la complejidad es una aproximación al tiempo real que el algoritmo requiere para

encontrar la solución. Por ello aparece el símbolo ~ en lugar de =.

Ejemplo 5.4: Multiplicación de matrices.

Problema: dadas 𝐴 ∈ 𝑀𝑛×𝑝 y 𝐵 ∈ 𝑀𝑝×𝑚, calcular 𝐶 = 𝐴𝐵 ∈ 𝑀𝑛×𝑚.

Entrada: 𝐴 ∈ 𝑀𝑛×𝑝, 𝐵 ∈ 𝑀𝑝×𝑚.

Salida: 𝐶 ∈ 𝑀𝑛×𝑚.

Algoritmo 5.2:

Para 𝑖 = 1 a 𝑛 hacer:

Para 𝑗 = 1 a 𝑚 hacer:

𝑐𝑖𝑗 = 𝑎𝑖1 + 𝑏1𝑗

Para 𝑘 = 2 a 𝑝 hacer:

𝑐𝑖𝑗 = 𝑐𝑖𝑗 + 𝑎𝑖𝑘 + 𝑏𝑘𝑗

Complejidad:

Aquí se observan tres ciclos Para anidados.

El primer ciclo Para se ejecuta 𝑛 veces.

96



Por cada vez que se ejecuta el primer ciclo, el segundo ciclo Para se ejecuta 𝑚 veces.

Por cada vez que se ejecuta el segundo ciclo, se tiene una instrucción básica y un tercer ciclo

que se ejecuta 𝑝 − 1 veces.

∴ La complejidad de tiempo del algoritmo 5.2 queda definida por 𝑇2 ∼ 𝑂(𝑚 · 𝑛 · 𝑝). En

particular, si 𝑚 = 𝑛 = 𝑝, entonces 𝑇2 ∼ 𝑂(𝑛3).

En este caso, la complejidad del mejor caso es igual a la complejidad del peor caso y a la

complejidad del caso medio, ya que cualquiera sea la entrada el algoritmo ejecuta todos los

pasos.

Ejemplo 5.5: Factorial.

El factorial de un número natural 𝑛 se define por la multiplicación desde 1 al número 𝑛: 𝑛! = 1 · 2 · 3 · … · 𝑛.

Problema: dado 𝑛, calcular 𝑛!. Entrada: 𝑛 ∈ ℕ.

Salida: 𝑛!.

Algoritmo 5.3: Factorial.

Si 𝑛 = 0 ó 𝑛 = 1 entonces:

𝐹𝑎𝑐𝑡 = 1 En caso contrario hacer:

𝐹𝑎𝑐𝑡 = 1

Para 𝑗 = 2 a 𝑛 hacer:

𝐹𝑎𝑐𝑡 = 𝐹𝑎𝑐𝑡 · 𝑗

Complejidad:

Para la instrucción condicional (Si) y la asignación se considera un tiempo unitario.

Para el caso contrario de la instrucción condicional se tiene:

Asignación con tiempo 1.

Ciclo Para que se ejecuta n-1 veces.

Dentro del ciclo Para, una asignación con tiempo 1.

Con los tiempos de cada instrucción y por las propiedades de la notación O, la complejidad del

algoritmo 5.3 es 𝐶(𝐹𝐴𝐶𝑇) = 1 + 1 · [1 + (𝑛 − 1) · 1] = 1 + 1 + (n − 1) . Aplicando las

propiedades de la notación O se tiene que 𝐶(𝐹𝐴𝐶𝑇) = 𝑂(1) + 𝑂(1) + 𝑂(𝑛 − 1). Aquí se

podría ocupar la regla de la suma, pero se debe recordar que la notación O desprecia las

constantes aditivas y multiplicativas, por tanto: 𝐶𝑃𝐶(𝐹𝐴𝐶𝑇)~𝑂(𝑛).

Ejemplo 5.6: Comparación de algoritmos.

La utilidad del uso de la complejidad aparece en su mayor expresión cuando se necesita optar

por alguna alternativa entre diferentes algoritmos para resolver un problema determinado. Para

esto, se debe saber discriminar entre un algoritmo y otro, para poder tomar la mejor decisión.

Suponga que la entrada de cierto problema 𝜋 tiene tamaño 𝑛 y que, para resolverlo se encuentra

en la literatura las siguientes alternativas:

a. Algoritmo de tiempo 𝑂(𝑛3).

97



b. Transformarlo en otro problema para el cual se conoce un algoritmo de tiempo 𝑂(𝑛). La

transformación demora 𝑂(𝑛 log 𝑛).

c. Modelarlo en un árbol de decisión de 𝑛 vértices y ejecutar por cada vértice del árbol un

algoritmo de tiempo 𝑂(𝑛).

La alternativa a no tiene mayor análisis.

En la alternativa b se encuentra una transformación. Esto no es más que la aplicación de un

algoritmo seguido de otro. Se puede observar entonces que la complejidad es 𝑂(𝑛 + 𝑛 log 𝑛).

Entre estas dos funciones se debe determinar la mayor para que la alternativa quede acotada a su

peor caso. Por ello, la complejidad de la alternativa b es ~𝑂(𝑛 log 𝑛).

La alternativa c del ejemplo 5.6 presenta un modelamiento con un árbol, por cada vértice del

árbol se ejecuta un algoritmo de tiempo 𝑂(𝑛). Ahora bien, siendo 𝑛 los vértices del árbol y

utilizando la regla de la multiplicación, la alternativa c queda con complejidad ~𝑂(𝑛2).

Se tiene entonces:

a. 𝑂(𝑛3)

b. 𝑂(𝑛 log 𝑛)

c. 𝑂(𝑛2).

Se debe elegir la alternativa cuyo valor de función sea menor, esto es, porque el algoritmo

elegido debe ser el más rápido, es decir que ocupe menor tiempo de ejecución. Luego, en el

ejemplo 5.6 la alternativa elegida es la b.

Ejemplo 5.7: Búsqueda.

El problema de búsqueda es uno de los más comunes que se encuentra en todo ámbito de

informática; se buscan palabras dentro de un archivo, archivos en un disco o en una red, datos

personales en una base de datos de una empresa, etc. Es por esto que se debe buscar el mejor

algoritmo para resolver este problema.

Problema: Dado 𝑆 = {𝑥1, 𝑥2, … , 𝑥𝑛} y 𝑥, determinar si 𝑥 ∈ 𝑆.

Entrada: 𝑛, 𝑆 = {𝑥1, 𝑥2, … , 𝑥𝑛}, 𝑥.

Salida: Sí o No. Se puede necesitar, en caso afirmativo, como salida que entregue la posición en

la cual está el elemento 𝑥.

Podemos considerar varios métodos diferentes para resolver este problema. Comencemos por la

búsqueda secuencial, que compara 𝑥 con cada uno de los elementos del conjunto.

Algoritmo5.4: Búsqueda lineal.

Para 𝑗 = 1 a 𝑛 hacer:

Si 𝑥𝑗 = 𝑥 entonces:

Devolver Sí y posición 𝑗

En caso contrario hacer:

Devolver No.

98



Complejidad:

Si el elemento buscado coincide con el primer elemento que se compara (𝑥 = 𝑥1), se tiene el

mejor caso, con una complejidad 𝐶𝑀𝐶(𝐵𝑆)~𝑂(1).

Si se tiene que revisar todos los elementos ya que el elemento buscado se encuentra al final

o no está en el conjunto (𝑥 = 𝑥𝑛 o 𝑥 ∉ 𝑆), el ciclo Para se realiza 𝑛 veces, luego, en el peor

caso se tiene una complejidad 𝐶𝑃𝐶(𝐵𝑆)~𝑂(𝑛).

El segundo método a considerar es la búsqueda secuencial ordenada. Si los datos están

ordenados, es posible evitar comparaciones ya que si 𝑥𝑗 < 𝑥 < 𝑥𝑗+1 entonces 𝑥 ∉ 𝑆.

Algoritmo 5.5: Búsqueda secuencial ordenada.

𝑗 = 1 Mientras (𝑥𝑗 < 𝑥) y (𝑗 < 𝑛) hacer:

𝑗 = 𝑗 + 1

Si 𝑥𝑗 = 𝑥 entonces:



Devolver No

Complejidad:

Si el elemento buscado coincide con el primer elemento o es menor que éste (𝑥 ≤ 𝑥1), se

tiene el mejor caso, con una complejidad 𝐶𝑀𝐶(𝐵𝑆𝑂)~𝑂(1) con respuesta Sí cuando el

número buscado es encontrado de inmediato (coincide con el primer elemento del conjunto

ordenado), pero adicionalmente, con respuesta No cuando el número buscado es menor que

el primer elemento del conjunto ordenado.

Si el elemento buscado coincide con el último elemento o es mayor que éste (𝑥 ≥ 𝑥1), se

tiene el peor caso, con una complejidad 𝐶𝑃𝐶(𝐵𝑆𝑂)~𝑂(𝑛) con respuesta Sí cuando el

número buscado coincide con el último elemento del conjunto ordenado y con respuesta No

cuando el número buscado es mayor que el último elemento del conjunto ordenado.

El tercer método a considerar es la búsqueda binaria. Si los datos están ordenados se disminuye

el conjunto de búsqueda comparando el elemento buscado con el central. En caso de no ser

iguales se redefinen los extremos del intervalo, según si el elemento central es mayor o menor

que el buscado, eliminando la mitad de las comparaciones. Se repite el proceso con el nuevo

intervalo. El proceso concluye cuando el elemento es encontrado o cuando el intervalo de

búsqueda es vacío.

Algoritmo 5.6: Búsqueda binaria.

Dados 𝑛, 𝑥1 < 𝑥2 < ⋯ < 𝑥𝑛, 𝑥

𝐼𝑛𝑓𝑖𝑚𝑜 = 1

𝑆𝑢𝑝𝑟𝑒𝑚𝑜 = 𝑛

𝑗 = ⌊𝐼𝑛𝑓𝑖𝑚𝑜+𝑆𝑢𝑝𝑟𝑒𝑚𝑜

2⌋

Mientras 𝑥 ≠ 𝑥𝑗 y 𝐼𝑛𝑓𝑖𝑚𝑜 < 𝑆𝑢𝑝𝑟𝑒𝑚𝑜 hacer:

Si 𝑥 < 𝑥𝑗 entonces:

𝑆𝑢𝑝𝑟𝑒𝑚𝑜 = 𝑗 − 1

99




𝐼𝑛𝑓𝑖𝑚𝑜 = 𝑗 + 1

𝑗 = ⌊𝐼𝑛𝑓𝑖𝑚𝑜+𝑆𝑢𝑝𝑟𝑒𝑚𝑜

2⌋

Si 𝑥 = 𝑥𝑗 entonces:



Devolver No

Complejidad:

Si el elemento buscado coincide con el elemento central del conjunto se tiene el mejor caso,

con una complejidad 𝐶𝑀𝐶(𝐵𝐵)~𝑂(1) con respuesta Sí.

En caso contrario, debemos comparar el valor buscado con el elemento central del

subconjunto que no descartamos en el paso anterior. El peor caso ocurre cuando se debe

considerar un subconjunto de tamaño 1, donde se obtiene respuesta Sí cuando el elemento

buscado coincide con el elemento del conjunto y respuesta No en caso contrario (el

elemento no se encuentra en el conjunto). Así pues, 𝐶𝑃𝐶(𝐵𝐵) = log2 𝑛 ~𝑂(log 𝑛).

Si se analizan las complejidades de los algoritmos 5.4, 5.5 y 5.6, se observa que todos ellos

tienen una complejidad ~𝑂(1) para el mejor caso. No obstante, para el peor caso solo coinciden

las complejidades de la búsqueda secuencial y la búsqueda secuencial ordenada, que es ~𝑂(𝑛),

mientras que la búsqueda binaria tiene complejidad ~𝑂(log 𝑛). En consecuencia, para un

conjunto ordenado de datos, el algoritmo más eficiente es la búsqueda binaria.

Ahora que ya se tienen las herramientas para analizar la complejidad de un algoritmo, es pertinente dar

algunas definiciones adicionales relativas a la eficiencia de algoritmos:

Un algoritmo es eficiente si su complejidad es un polinomio de la entrada, es decir, es de la forma

𝐶~𝑂(𝑛 · 𝑘), donde 𝑘 es una constante.

Para algunos problemas es posible determinar el límite inferior del problema que corresponde al

tiempo mínimo para resolverlo. Este límite es una característica del problema y refleja su dificultad

intrínseca para resolverlo. Cualquier algoritmo que lo resuelva utilizará por lo menos ese tiempo.

Un algoritmo es óptimo si su complejidad es ~𝑂(𝐿), donde 𝐿 es el límite inferior del problema.

Otro comentario importante es que, además de la notación O, existen otras dos notaciones asintóticas

que ayudan a acotar la complejidad de un algoritmo: la notación Ω, que brinda cotas inferiores, y la

notación Θ.

Dadas 𝑓: ℝ → ℝ+ y 𝑔: ℝ → ℝ+, se dice que 𝑓 es omega de 𝑔, denotado por 𝑓 ∼ Ω(𝑔), si existen

constantes 𝑐 y 𝑛0 tales que 𝑓(𝑛) ≥ 𝑐 · 𝑔(𝑛) ∀ 𝑛 ≥ 𝑛0. En otras palabras, 𝑓 está acotada inferiormente

por 𝑐 · 𝑔(𝑛) para todo valor 𝑛 ≥ 𝑛0.

Dadas 𝑓: ℝ → ℝ+ y 𝑔: ℝ → ℝ+, si 𝑓~O(g) y 𝑓~Ω(g) a la vez se dice que 𝑓~Θ(g). Expresado de otro

modo, 𝑓~Θ(g) si existen constantes 𝑐1, 𝑐2 y 𝑛0 tales que 𝑐2 · 𝑔(𝑛) ≤ 𝑓(𝑛) ≤ 𝑐1 · 𝑔(𝑛) ∀ 𝑛 ≥ 𝑛0.

Una observación importante

Hay un aspecto del cálculo de la complejidad que suele dar origen a confusión, y está ligado a la noción de

instrucción básica. Había quedado establecido que las instrucciones básicas son aquellas cuyo tiempo de

100



ejecución está acotado superiormente por una constante que solo depende de la implementación usada. En

otras palabras, pueden asociarse a las operaciones unarias y binarias que incorpora el procesador (asignación,

cambio de signo, operaciones aritméticas, operaciones lógicas, comparaciones, etc.). Sin embargo, en los

ejemplos anteriores pareciera que no se hubiese considerado la condición de la sentencia Si o de los ciclos

Para y Mientras, o bien que se hubiese considerado como instrucción simple a alguna sentencia que en

realidad contiene varias operaciones.

En efecto, si se tiene una sentencia como:

𝑥 = 3 · (5 + 𝑥)/(−𝑦 − 6)

Al momento de compilar o interpretar el programa se traduce en una serie de sentencias (los términos 𝑡𝑗

corresponden a variables temporales creadas por el compilador o intérprete):

𝑡0 = 5 + 𝑥

𝑡1 = 3 ∗ 𝑡0

𝑡2 = −𝑦

𝑡3 = 𝑡2 − 6

𝑥 = 𝑡1/𝑡3

No obstante, como se asume que cada una de ellas tiene un tiempo de ejecución unitario y la notación

asintótica descarta las constantes aditivas y multiplicativas, es posible ignorar este aspecto.

En el caso de las comparaciones y operaciones lógicas se observa el mismo fenómeno. Considere la

expresión:

𝑥 ≠ 3 𝑦 𝑥 < 8

Cuando se compila o interpreta el programa, esto se traduce en una secuencia de operaciones de la forma (los

números agregados al comienzo de cada instrucción simplemente permiten identificar cada línea para dirigir

los saltos):

0: si 𝑥 ≠ 3 𝑠𝑎𝑙𝑡𝑎𝑟 𝑎 3

1: 𝑡0= falso

2: 𝑠𝑎𝑙𝑡𝑎𝑟 𝑎 4

3: 𝑡0= verdadero

4: si 𝑥 < 8 𝑠𝑎𝑙𝑡𝑎𝑟 𝑎 7

5: 𝑡1= falso

6: 𝑠𝑎𝑙𝑡𝑎𝑟 𝑎 8

7: 𝑡1= verdadero

8: 𝑡2=𝑡0 y 𝑡1

5.4 COMPLEJIDAD DE ALGORITMOS RECURSIVOS

Se denomina recursión al proceso de resolver un problema grande descomponiéndolo en uno o más

subproblemas que son de estructura idéntica a la del problema original pero más simples de resolver

que aquel. Cada subproblema se resuelve de forma similar, repitiendo la descomposición hasta generar

subproblemas tan simples que se resuelven sin necesidad de descomponerlos. La solución del problema

original se obtiene combinando las soluciones de los subproblemas en un proceso inverso a la

descomposición realizada.

101



La recursión está muy ligada a la recurrencia matemática, que en cuando se define una función f en

términos de ella misma. Dos ejemplos clásicos de recurrencia matemática son el cálculo del factorial y

los números de Fibonacci, que se muestran en los ejemplos 5.8 y 5.9, respectivamente.

Ejemplo 5.8: Función recurrente para el factorial.

𝐹𝑎𝑐𝑡(𝑛) = {𝑛 · (𝑛 − 1)! 𝑛 ≥ 11 𝑛 = 0

Ejemplo 5.9: Función recurrente para los números de Fibonacci.

𝐹𝑖𝑏(𝑛) = {𝐹𝑖𝑏(𝑛 − 1) + 𝐹𝑖𝑏(𝑛 − 2) 𝑛 ≥ 2

1 𝑛 = 11 𝑛 = 0

Cabe destacar que la recursividad es una propiedad de la estrategia para resolver un problema y no del

problema en sí. Así pues, se dice que un algoritmo es recursivo si corresponde a un procedimiento que

se invoca a sí mismo hasta recibir como entrada un caso base.

En programación, la recursión puede darse de dos formas:

1. Directa: en algún paso del conjunto de instrucciones aparece una invocación al propio

procedimiento.

2. Indirecta: el procedimiento llama a otro procedimiento, y este último llama a su vez al primero.

Asimismo, si un procedimiento llama a otros y, en algún momento, alguno de ellos llama al

primero, también es un caso de recursión indirecta.

En toda definición recursiva de un problema se debe establecer una condición de borde, es decir, una

condición que no requiera otra definición recursiva para su resolución. Ésta condición determina el

criterio de parada del algoritmo recursivo.

Para el ejemplo 5.8, por definición se tiene que:

0! = 1 1! = 0! · 1 = 1 · 1 2! = 1! · 2 = 1 · 1 · 2 3! = 2! · 3 = 1 · 1 · 2 · 3

etc.

Al definir 3! estamos usando 2!, y así hasta llegar al 0. En este caso, la condición de borde es el

factorial de cero (0! = 1). En este punto se observa que la función ya no se llama a sí misma, sino que

entrega el resultado y se detiene. En otras palabras, se asigna un valor directamente.

Algoritmo 5.7: Factorial recursivo.

Dado 𝑛

𝐹𝑎𝑐𝑡𝑜𝑟𝑖𝑎𝑙 = 𝑛 · 𝐹(𝑛 − 1)

Devolver Factorial.

Procedimiento 𝐹(𝑘)

Si 𝑘 = 0 ó 1 entonces:

Devolver 1

102




Devolver 𝑘 · 𝐹(𝑘 − 1).

La complejidad de un algoritmo recursivo se expresa mediante una ecuación de recurrencia. Por

ejemplo, sea 𝑇(𝑛) el tiempo para calcular 𝑛!. Entonces:

𝑇(𝑛) = {𝑇(𝑛 − 1) + 1 𝑛 > 01 𝑛 = 0

Si se resuelve esa ecuación por sustitución se encuentra:

𝑇(𝑛) = 𝑇(𝑛 − 1) + 1 =

= (𝑇(𝑛 − 2) + 1) + 1 = 𝑇(𝑛 − 2) + 2 =

= ((𝑇(𝑛 − 3) + 1) + 1) + 1 = 𝑇(𝑛 − 3) + 3 =

…

= 𝑇(𝑛 − 𝑘) + 𝑘 =

…

= 𝑇(1) + 𝑛 − 1 =

= 𝑇(0) + 𝑛 = 𝑛 + 1

Luego, la complejidad del Algoritmo Factorial Recursivo es ~𝑂(𝑛).

Una observación importante es que, en este caso, la complejidad del algoritmo iterativo es igual a la del

algoritmo recursivo. No obstante, esto no siempre es así. Para algunos problemas es más eficiente el

algoritmo recursivo; para otros, el algoritmo iterativo es mejor. Más aún, existen problemas para los

cuales es imposible desarrollar un algoritmo iterativo que no sea una simulación de la recursión. La

secuencia de Fibonacci del ejemplo 5.9 es un caso en que el algoritmo iterativo es más eficiente.

Complejidad:

Dado que un algoritmo recursivo se invoca a sí mismo, al expresar el orden 𝑇(𝑛) de su complejidad se

obtiene una ecuación de recurrencia. Esta ecuación depende del proceso de descomposición del

problema en subproblemas.

Reducción por sustracción: si el tamaño 𝑛 del problema decrece en una cantidad constante 𝑏 en cada

llamada, se realizan 𝑎 llamadas recursivas y las operaciones correspondientes a la parte no recursiva

del algoritmo toman un tiempo 𝑂(𝑛𝑘), entonces:

𝑇(𝑛) = 𝑎𝑇(𝑛 − 𝑏) + 𝑂(𝑛𝑘) si 𝑛 ≥ 𝑏.

Una observación importante es que se considera un tiempo polinomial para la resolución de un

problema solamente porque interesa que la solución recursiva sea eficiente. Un tiempo exponencial,

por ejemplo, sería mucho más costoso que un caso iterativo.

La solución de esta ecuación de recurrencia es de la forma:

103



𝑇(𝑛) = {

𝑛𝑘 𝑠𝑖 𝑎 < 1𝑛𝑘+1 𝑠𝑖 𝑎 = 1

𝑎𝑛𝑏 𝑠𝑖 𝑎 > 1

Reducción por división: si el algoritmo con un problema de tamaño 𝑛 realiza 𝑎 llamadas recursivas con

subproblemas de tamaño 𝑛

𝑏 y las operaciones correspondientes a la parte no recursiva, que corresponde

a descomponer el problema en los subproblemas y luego combinar las soluciones de éstos, toman un

tiempo 𝑂(𝑛𝑘) entonces:

𝑇(𝑛) = 𝑎𝑇 (𝑛

𝑏) + 𝑂(𝑛𝑘) si 𝑛 ≥ 𝑏.

La solución de esta ecuación de recurrencia es de la forma:

𝑇(𝑛) = {𝑛𝑘 𝑠𝑖 𝑎 < 𝑏𝑘

𝑛𝑘 log 𝑛 𝑠𝑖 𝑎 = 𝑏𝑘

𝑛log𝑏 𝑎 𝑠𝑖 𝑎 > 𝑏𝑘

5.5 CLASES DE PROBLEMAS

En unidades anteriores se había explicado que un algoritmo se considera eficiente si su complejidad es

polinomial con respecto al tamaño de la entrada. Como consecuencia de esto es posible distinguir dos

clases de problemas:

Problema tratable: es aquel para el cual existe un algoritmo eficiente que lo resuelva.

Problema intratable: es un problema tal que cualquier algoritmo que lo resuelva no es eficiente.

Los problemas algorítmicos se pueden también clasificar en tres categorías:

Problema de decisión (P.D.): es aquel en que se decide si una estructura satisface o no una

determinada propiedad. En consecuencia, su respuesta es sí o no.

Problema de localización (P.L.): es aquel en que se encuentra una estructura que satisface una

determinada propiedad.

Problema de optimización (P.O.): es aquel en que, de entre todas las estructuras que satisfacen una

determinada propiedad, se elige la mejor de acuerdo a un criterio predefinido.

Ejemplo 5.10: Cliques.

En el estudio de grafos, las cliques sirven para ejemplificar las tres clases de problemas

algorítmicos. Dado un grafo 𝐺(𝑉, 𝐴) y un entero 𝑘 > 0:

P.D.: ¿∃ clique 𝐾 con 𝑐𝑎𝑟𝑑(𝐾) ≥ 𝑘?

P.L.: encontrar una clique 𝐾 con 𝑐𝑎𝑟𝑑(𝐾) ≥ 𝑘.

P.O.: encontrar una clique máxima.

Para el grafo de la figura 5.5 se tienen las siguientes respuestas para los diferentes problemas:

P.D.: Sí.

P.L.: 𝐾 = {𝑏, 𝑐, 𝑖} (por ejemplo).

P.O.: 𝐾 = {𝑐, 𝑑, ℎ, 𝑖}

104



FIGURA 5.5: Un grafo 𝐺.

Con respecto a las categorías anteriores se sabe que:

P.D. es al menos tan difícil como P.L.

P.L. es al menos tan difícil como P.O.

Por tanto, Si se resuelve el P.O. se tiene también la solución del P.L. y, en consecuencia, la del P.D. Es

decir:

𝑃. 𝑂. ⟹ 𝑃. 𝐿. ⟹ 𝑃. 𝐷.

Pero, ¿qué ocurre si el P.D. es intratable?

𝑃. 𝐷. 𝑖𝑛𝑡𝑟𝑎𝑡𝑎𝑏𝑙𝑒 ⟹ 𝑃. 𝐿. 𝑖𝑛𝑡𝑟𝑎𝑡𝑎𝑏𝑙𝑒 ⟹ 𝑃. 𝑂. 𝑖𝑛𝑡𝑟𝑎𝑡𝑎𝑏𝑙𝑒

La pregunta anterior resulta útil porque existe una clasificación para los problemas de decisión: la clase

P y la clase NP.

5.5.1 CLASE P

Es la clase que contiene a los problemas de decisión que admiten algoritmos polinomiales.

Ejemplo 5.11: Sistema de ecuaciones lineales.

El problema de decisión asociado a un sistema de ecuaciones es, dada una matriz 𝐴 y un vector

𝑏, determinar si ∃𝑥 tal que 𝐴𝑥 = 𝑏.

La decisión depende únicamente de si 𝐴 es una matriz singular (una matriz cuadrada es singular

únicamente si su determinante es 0). Si lo es, la respuesta es no. En caso contrario, la respuesta

es sí.

105



Este problema es P, puesto que se conoce un algoritmo para el cálculo de determinantes cuya

complejidad es ~𝑂(𝑛3).

Una observación importante es que, si todo algoritmo conocido para resolver un problema π requiere

tiempo exponencial, entonces no es posible asegurar que 𝜋 ∉ 𝑃. Para poder hacer esta afirmación se

debe tener una prueba de que cualquier algoritmo conocido o por conocer que resuelva el problema π

no es polinomial.

En el caso contrario, en cambio, dado un problema 𝜋𝑃 ∈ 𝑃, entonces necesariamente se tiene una

justificativa que permita verificar la respuesta afirmativa o negativa. Para esta justificación se deben

seguir dos pasos:

1. Exhibición: mostrar la justificativa.

2. Reconocimiento: comprobar que la justificativa es satisfactoria, es decir, que satisface la propiedad

requerida).

5.5.2 CLASE NP

La clase NP contiene los problemas de decisión para los que existe un algoritmo no determinista

polinomial (un algoritmo no determinista es un algoritmo que, con la misma entrada, ofrece muchos

posibles resultados, por lo que no se puede saber de antemano cuál será el resultado de su ejecución) o,

equivalentemente, contiene los problemas de decisión para los cuales la etapa de reconocimiento de la

justificativa se hace en tiempo polinomial para la respuesta afirmativa.

Ejemplo 5.12: Clique.

¿Pertenece el problema de la clique a la clase NP?

En este caso, la justificativa de la respuesta afirmativa para el P.D. (¿∃ clique 𝐾 con 𝑐𝑎𝑟𝑑(𝐾) ≥𝑘?) es la clique 𝐾 = {𝑣1, … , 𝑣𝑟}. El algoritmo 5.8 muestra el modo de reconocer dicha

justificativa.

Algoritmo 5.8: Reconocimiento de justificativa de clique.

Dados 𝐺(𝑉, 𝐴) y 𝑟:

Para todo 𝑖 entre 1 y 𝑟 − 1 hacer:

Para todo 𝑗 entre 𝑖 + 1 y 𝑟 hacer:

Si (𝑣𝑖 , 𝑣𝑗) ∉ 𝐴 entonces:

Devolver no

Devolver sí

El algoritmo 5.8 tiene complejidad ~𝑂(𝑟2), que es polinomial. En consecuencia, se puede

afirmar que Clique ∈ NP.

106



5.5.3 TRANSFORMACIÓN POLINOMIAL

Dados 𝜋1 y 𝜋2 problemas de decisión y 𝐴2 algoritmo que resuelve 𝜋2, se dice que 𝜋1 es transformable

polinomialmente en 𝜋2 (𝜋1 𝛼 𝜋2) si es posible transformar el problema 𝜋1 en 𝜋2 y la solución de 𝜋2 en

solución de 𝜋1 en tiempo polinomial.

Clase NP-Duro:

𝜋 ∈ 𝑁𝑃 − 𝑑𝑢𝑟𝑜 si 𝜋′ 𝛼 𝜋 ∀𝜋′ ∈ 𝑁𝑃

Clase NP-Completo:

𝜋 ∈ 𝑁𝑃 − 𝑐𝑜𝑚𝑝𝑙𝑒𝑡𝑜 si 𝜋 ∈ 𝑁𝑃 y 𝜋 ∈ 𝑁𝑃 − 𝑑𝑢𝑟𝑜

Propiedad: sean 𝜋1, 𝜋2 ∈ 𝑁𝑃. Si 𝜋1 ∈ 𝑁𝑃 − 𝑐𝑜𝑚𝑝𝑙𝑒𝑡𝑜 y 𝜋1 𝛼 𝜋2, entonces 𝜋2 ∈ 𝑁𝑃 − 𝑐𝑜𝑚𝑝𝑙𝑒𝑡𝑜.

5.6 EJERCICIOS

1. Determine la complejidad de a lo menos 5 algoritmos de ordenamiento. ¿Cuál es mejor? ¿Por qué?

2. Determine la complejidad del algoritmo de Ford para el problema de flujo en redes.

3. Investigue acerca de los problemas de corte de piezas y asignación horaria. ¿Existen algoritmos

eficientes para resolverlos? ¿Qué técnicas se utilizan?

107



BIBLIOGRAFÍA

1. AHO, A. V.; LAM, M. S.; SETHI, R.; ULLMAN, J. D. (2008) Compiladores. Principios, técnicas

y herramientas (2ª ed.), Pearson Educación, México. ISBN 978-970-26-1133-2.

2. ÁLVAREZ, J. (2005). Apuntes de la Asignatura Programación de Lenguajes Formales,

Departamento de Ingeniería Informática, Facultad de Ingeniería, Universidad de Santiago de Chile.

3. BRASSARD, G.; BRATLEY, P. (1997). Fundamentos de Algoritmia, Prentice Hall, Madrid.

ISBN 84-89660-00-X.

4. CAMPOS, A. E. (1995). Teoría de Autómatas y Lenguajes Formales, Departamento de Ciencia de

la Computación, Escuela de Ingeniería, Pontificia Universidad Católica de Chile.

5. HOPCROFT, J. E.; ULLMAN, J. D. (1993). INTRODUCCIÓN A LA TEORÍA DE

AUTÓMATAS, LENGUAJES Y COMPUTACIÓN, Compañía Editorial Continental S. A.,

México. ISBN 968-26-1222-5.

6. JIMÉNEZ, J. A. (2009). Matemáticas para la computación, Alfaomega, México. ISBN: 978-970-

15-1401-6.

7. KOLMAN, B.; BUSBY, R. C. (1986). Estructuras de Matemáticas Discretas para la

Computación, Prentice-Hall Hispanoamericana S. A., México. ISBN 968-880-080-5.

8. VILLANUEVA, M. (2010). Apuntes de la Asignatura Algoritmos Avanzados, Departamento de

Ingeniería Informática, Facultad de Ingeniería, Universidad de Santiago de Chile.

apuntes fundamento

Education