Apunte 1

TEORIA DE AUTOMATAS Y LENGUAJES FORMALES

Teoría de Autómatas y Lenguajes Formales
1. Introducción
La ciencia de la Computación es una agrupación ordenada de conocimientos,

formada por dos componentes principales: las ideas y modelos fundamentales tras la
computación y las técnicas de ingeniería para el diseño de sistemas computacionales, tanto
hardware como software. Se intenta aquí dar una introducción al área teórica, tratando de
aportar algunas aplicaciones prácticas en cada tema.
Los comienzos de esta ciencia se realizaron en diferentes campos, como son:

modelos de estudio en Biología para redes de neuronas, la teoría de circuitos en ingeniería
eléctrica para el diseño de hardware, los fundamentos de lógica estudiados por
matemáticos y la investigación de lingüistas sobre gramáticas para lenguajes naturales.
Las nociones de Autómatas Finitos (A.F.) y Expresiones Regulares (E.R.) fueron

desarrolladas originalmente considerando redes neuronales y circuitos de conmutación.
Últimamente ellas han servido como herramientas útiles en el diseño de Analizadores
Léxicos, que es aquella parte de un Compilador que agrupa caracteres en tokens (o
unidades indivisibles que representan una palabra clave de un lenguaje computacional).
Los Compiladores transforman automáticamente E.R. en A.F. para usarlos como
analizadores léxicos. Otros usos de los A.F. son en la construcción de editores de textos, en
programas de búsqueda en textos o archivos, y en la lógica matemática.
Las nociones de Gramáticas de Libre Contexto (G.L.C.) y de Autómatas Pushdown

(A.P.) han ayudado mucho a la especificación de lenguajes de programación y en el diseño
de parsers o Analizadores Sintácticos, que es aquella parte de un Compilador que chequea
si la instrucción analizada está correcta respecto al lenguaje que se compila.
Por último, las máquinas de Turing corresponden al más completo tipo de

autómata, el cual permite desarrollar la teoría de la computabilidad de funciones, así como
definir los problemas que no tienen solución en tiempo polinomial (o problemas NP-
completos).
1.1 Definiciones Básicas y Fundamentos Matemáticos
1.1.1 Strings, Alfabetos y Lenguajes
Un símbolo es una entidad abstracta que no tiene definición. Por ejemplo, las letras del
alfabeto castellano y los dígitos son símbolos frecuentemente utilizados. Un alfabeto es un
conjunto finito no vacío de símbolos. Por ejemplo, el alfabeto castellano está formado por
27 símbolos. Otro ejemplo es el de todos los símbolos legales del lenguaje de
programación Pascal (los identificadores, palabras claves y reservadas y caracteres
especiales). Si  es un alfabeto, entonces a denota que a es un símbolo del alfabeto .
Por ejemplo, si  = {0,1,2,3,4,5,6,7,8,9}, entonces se puede decir que 0.
Un string o palabra es una sucesión finita de símbolos yuxtapuestos. Por ejemplo, si

a, b y c son símbolos, entonces cab es un string. El largo de un string w, llamado |w|, es la
cantidad de símbolos que componen el string. Por ejemplo, |cab| = 3. Existe un string
especial, llamado string vacío, denotado por , definido como aquel string que no tiene
símbolos, o sea || = 0, y que es un string sobre cualquier alfabeto.
Un prefijo de un string es una sucesión finita de símbolos que forme parte del string
y esté ubicada delante de ese string y un sufijo es lo mismo pero atrás del string. Por
ejemplo, para el string cab sus prefijos son: , c, ca y cab. Sus sufijos son: , b, ab y cab.
Un prefijo o sufijo distinto del string mismo, se llama prefijo o sufijo propio.
1

La concatenación de dos strings es el string formado por la yuxtaposición de ambos

sin espacios vacíos entre ellos. Por ejemplo, la concatenación de w1 = ab y w2 = bc es el
string w = w1w2 = abbc. El string vacío es el símbolo identidad para la concatenación ya
que w = w = w.
Un lenguaje (formal) es un conjunto de strings de símbolos de algún alfabeto. Por

tanto el conjunto {1, 12, 123, 1234, 12345} es un lenguaje sobre el alfabeto compuesto por
dígitos. Se observa que si  es un alfabeto, también es un lenguaje formado por los strings
con un único símbolo. Asimismo, el conjunto vacío  y el conjunto {} son lenguajes.
Los lenguajes pueden ser bastante grandes, los hay hasta de cardinalidad infinita,
como en el caso de todas las palabras en castellano “correctas” y el del lenguaje de los
palíndromes sobre el alfabeto {0,1}, el cual corresponde al conjunto {, 0, 1, 00, 11, 000,
010, 111,...} formado por todos los strings que se escriben igual al invertirlos.
Sea  un alfabeto y w un string sobre . Si L es el lenguaje formado por algunos de

los strings sobre  y si w está en L, entonces se tiene que wL y se dice que w es un
elemento de L, o que w es miembro de L. Por ejemplo,
010  {, 0, 1, 00, 11, 000, 010, 111, ...}
Es necesario tener en cuenta el lenguaje compuesto por todas los strings sobre el
alfabeto , el que se conoce como cerradura de  o lenguaje universal sobre  al conjunto
*. Por ejemplo, si se tiene que  = {1}, entonces:
* = {, 1, 11, 111, 1111,...}
Para cualquier alfabeto * es infinito (ya que los alfabetos son no vacíos).
1.2 Grafos y árboles
Un grafo no dirigido G = (V,E) consiste de un conjunto finito de vértices (o nodos)

V y un conjunto de pares de vértices E llamados bordes. Por ejemplo, si V = {1,2,3,4,5} y
E = {(1,3), (3,4), (3,5), (4,2)} entonces el grafo es:

|
----
|
----
Figura 1: Grafo no dirigido
Un camino en un grafo es una sucesión de vértices v1, v2,...,vk, k  1, tales que

existe un borde (vi,vi+1) para cada i, 1  i < k. El largo de este camino es k-1. Por ejemplo,
en el grafo de la figura anterior, un camino de largo 3 es 1,3,4,2. Si v1 = vk entonces el
camino se llama ciclo.
Un grafo dirigido (o digrafo) G = (V,E) consiste de un conjunto finito de vértices V

y un conjunto de pares ordenados de vértices E llamados arcos. Denotaremos un arco del
vértice v al w como v  w. Por ejemplo, si V = {1,2,3} y E = {(i,j) / i = j+1} entonces:
2


Figura 2: Digrafo
Un camino en un digrafo es una sucesión de vértices v1,..., vk en que k  1, y tales

que vi  vi+1 es un arco para cada i, 1  i < k. Por ejemplo, 3  2  1 es un camino en el
ejemplo anterior. Si v  w es un arco, se dirá que v es un predecesor de w y que w es un
sucesor de v.
Un árbol es un digrafo con las siguientes propiedades:
1) Existe un vértice, llamado raíz, que no tiene predecesores y desde el cual hay un
camino a cada vértice.
2) Cada vértice distinto de la raíz posee exactamente un predecesor.
3) Los sucesores de cada vértice están ordenados desde la izquierda.
Ejemplo: Para los vértices V = {1,2,3,4,5} se tiene el siguiente árbol:
1
2 4
13 5
1
Figura 3: Árbol 1
1.3 Relaciones de equivalencia

1
q
Una relación es un conjunto de pares ordenados, subconjunto de algún producto
1
cartesiano de conjuntos. Su primera componente pertenece a un dominio y la segunda al
recorrido o rango. Se verán solo relaciones en que dominio y rango son el mismo conjunto
S. Si R es una relación y (a,b) está en R, se escribirá que aRb.
Una relación se dice de equivalencia si ella verifica las siguientes propiedades sobre
el conjunto S:
1) Reflexiva: aRa, aS

2) Simétrica: aRb  bRa, a,bS
3) Transitiva: aRb y bRc  aRc, a,b,cS
Una importante propiedad de una relación de equivalencia R sobre un conjunto S es

que R particiona a S en clases de equivalencia disjuntas y no vacías. O sea, S = S1  S2
..., en que para cada i y j, ij, se tiene:
i) Si  Sj = 
ii) a,bSi, aRb es Verdadero
iii) aSi, bSj, aRb es Falso
3

Por ejemplo: si S = {x / x|N, x < 10} entonces una partición de S es P = {{0,2,4},

{1,3,5}, {6,8}, {7,9}}.
El número de clases de equivalencia Si, i > 0, puede ser infinito.
Ejemplo. Sea la relación de congruencia módulo m, en que m es un entero positivo. Se

define esta relación como sigue:
i  j mod m ssi i y j son enteros tales que i-j es divisible por m
Se observa que esta es una relación de equivalencia pues:
i) Es reflexiva ya que i  i mod m pues 0 es divisible por m.

ii) Es simétrica pues i  j mod m ssi i-j es divisible por m ssi j-i es divisible por m ssi j
 i mod m.
iii) Es transitiva ya que si i  j mod m y j  k mod m entonces i-j es divisible por m y j-
k es divisible por m. Luego se tiene que existen p y q enteros tales que:
i – j = pm y j – k = qm  j = i – pm y j = k + qm
 i – pm = k + qm  i – k = (p+q)m
 i  k mod m.
Las clases de equivalencia de  son m en total. Por ejemplo, si m = 3 se tiene:
P0 = {...,-3, 0, 3, 6, ...}
P1 = {...,-5,-2,1,4,7,...}
P2 = {...,-4,-1,2,5,8,...}
1.3.1. Clausura de Relaciones.
Sea P un conjunto de propiedades de relaciones. La P-clausura de una relación R

es la más pequeña relación R’ que incluye todos los pares de R y posee las propiedades de
P. Por ejemplo, la clausura transitiva de R, llamada R+, se define por:
(1) Si (a,b)R entonces (a,b)R+.

(2) Si (a,b)R+ y (b,c)  R entonces (a,c)R+.
(3) Ningún par está en R+ a menos que verifique (1) o (2).
La clausura reflexiva y transitiva de R, llamada R* es:

R* = R+  {(a,a)/aS}.
Ejemplo: Si R = {(1,2), (2,2), (2,3)} es una relación en S = {1,2,3}, entonces:
R+ = {(1,2), (2,2), (2,3), (1,3)}
R* = {(1,1), (1,2), (1,3), (2,2), (2,3), (3,3)}
1.4 Inducción
Dada una proposición P(n) sobre un entero no negativo n, el principio de inducción

matemática es que P(n) se verifica ssi:
a) (Base) P(k) es válido, k  0, y
4

b) (Principio de inducción) si se supone P(n) válida entonces se debe probar que P(n+1) es
válida también para n  1.
n
Ejemplo: Compruebe que: 2
k 0
k
 2n 1  1
a) Para n = 0 se verifica que 20 = 20+1 – 1 = 1.
b) Para n > 0 se supone válida la proposición dada. Entonces:
n 1 n
2  2
i 0
i
i 0
i
 2n 1  2n 1  1  2n 1  2n  2  1
Ejercicios del Capítulo
1. Determine si cada una de las siguientes relaciones es una relación de equivalencia

sobre el conjunto A = {0,1,2,3,4,5}:
a) R1 = {(0,0),(1,1),(1,2),(2,2),(3,3),(4,4),(5,5)}
b) R2 = R1  {(2,1)}
c) R3 = R1 – {(1,2)}
d) R4 = R2  {(2,3),(1,3),(3,1),(3,2)}
2. Se define potencia de un string w, para n entero positivo o nulo de la siguiente manera:
w0 = 
wn = w wn-1, para n > 0
Escriba una expresión para el tamaño del string wi+j en términos de i, j y |w|.
3. Se define la inversa de un string w de la siguiente manera:
wI = w si w = 
wI = uIa si w = au para a y para u*
en que * denota el lenguaje universal sobre  y está formado por todos los strings posibles
de obtener a partir de los símbolos del alfabeto . Demuestre que (wu)I = uI wI.
4. Se define la potencia de un lenguaje L sobre el alfabeto  como sigue:
L0 = {}
Ln = L·Ln-1, sí n > 0
Entonces conteste las siguientes consultas:
a) Si L = {}, determine Ln para n  0.

b) Sean L = {,ab} y M = {cd}. ¿Cuántos strings hay en LnM para un n cualquiera?

c) Si se define L* =  L , y L+ = L·L*, ¿bajo qué condiciones se verifica que L*= L+?
i 0
i
d) Sean A = {a} y B = {b}. Determine An·B, A·Bn y (AB)n.
5. Demuestre por inducción que la suma de los n primeros impares positivos, o sea 1 + 2
+... + (2n-1) es igual a n2.
6. Encontrar la clausura transitiva, la clausura transitiva y reflexiva y la clausura simétrica

de la relación R = {(1,2),(2,3),(3,4),(5,4)}.
5

2. Autómatas Finitos y Expresiones Regulares
2.1 Introducción
El autómata finito es un modelo matemático de un sistema, con inputs y outputs

discretos. El sistema mencionado puede estar en cualquiera de una cantidad finita de
configuraciones o estados. El estado del sistema resume la información de los inputs
pasados, la cual es necesaria para determinar la conducta del sistema para los inputs
siguientes. El objetivo del autómata finito es determinar si un string de símbolos de algún
alfabeto es válido para el lenguaje representado por éste.
Como ejemplo de un sistema de estados finitos se tiene el mecanismo de control de

un ascensor, el cual solo controla el piso en que se encuentra, la dirección del movimiento
a realizar para satisfacer la demanda actual y los pisos que aún le quedan por recorrer.
Otro ejemplo es el de una máquina que vende dulces (o bebidas) luego de recibir
monedas de distintas denominaciones. El problema es controlar que la máquina reciba la
cantidad exacta (o mayor) de monedas para luego satisfacer el requerimiento.
2.2 Autómata Finito Determinístico
Un autómata finito determinístico (AFD) consiste de un conjunto finito de estados y

un conjunto de transiciones de un estado a otro, las que ocurren sobre símbolos presentes
en el string analizado. Para cada símbolo existe solo una transición fuera de cada estado o
de regreso al mismo estado. Se define uno de los estados, usualmente llamado q0, como
estado inicial del AFD. Existen además algunos llamados finales o de aceptación.
Asociado a cada AFD existe un diagrama de transición, que es un digrafo en el cual

los vértices corresponden a los estados del AFD. Si existe una transición desde el estado q
al estado p para un símbolo a, entonces existe un arco rotulado a desde q a p en el diagrama
de transición. Los AFD reconocen un string x si la sucesión de transiciones
correspondientes a los símbolos de x conducen desde el estado inicial a un estado final y
no quedan más símbolos del string por analizar.
Formalmente, un AFD será la 5-tupla M = (Q,,,q0,F), en que Q es el conjunto

finito de estados del AFD,  es el alfabeto del input, q0Q es el estado inicial, FQ es el
conjunto de estados finales y  es la función de transición, definida entre el producto
cartesiano Qx y Q. O sea que (q,a) es un estado para cada estado q y símbolo a. Se
observa que  no contiene el string vacío .
Si (q,a) es un estado final, y no hay más símbolos por analizar en el input,

entonces se dice que el AFD reconoce el string de entrada. Gráficamente un AFD se puede
representar por medio de una cinta de entrada que contiene el string a analizar y de un
control finito que está enlazado con un símbolo de la cinta, como se observa en la siguiente
figura:
a0 a1 a3 . . . .
qi
Figura 3: Representación gráfica de un AFD
6

Para describir formalmente la conducta de un AFD sobre un string, se extiende la

función de transición  para aplicarla a un estado y a un string en lugar de a un estado y un
símbolo. Se define entonces la función ’ entre Qx* y Q, de modo que ’(q,w) es el único
estado p del AFD alcanzado, luego de leer w y estando en el estado q, tal que existe un
camino en el diagrama de transición desde q a p rotulado w. Formalmente se tiene que:
1) ’(q,) = q
2) w*, a ’(q,wa) = (’(q,w),a)
La primera condición asegura que sin leer un símbolo en el input el AFD no cambie de
estado, y la segunda indica como hallar el estado después de leer un string no vacío. Se
observa que:
’(q,a) = (’(q,),a) = (q,a)
Por lo anterior se usará  en lugar de ’ en lo sucesivo. Un string x se dice aceptado

por un AFD M = (Q,, ,q0,F) si (q0,x) = p para algún pF. El lenguaje aceptado por M,
llamado L(M), es el conjunto siguiente:
L(M) = {x / (q0,x)F, x*}
Un lenguaje se dirá que es un conjunto regular si éste es aceptado por algún

autómata finito. En realidad, más adelante se introduce el concepto de conjunto regular, el
cual corresponderá al conjunto de strings aceptado por un autómata finito.
Ejemplos de AFD
En los siguientes ejemplos se usará  = {0,1}.
1) Un AFD que reconozca cualquier cantidad de unos y ceros.
Q = F = {q0} 0,1
(q0,0) = q0 0,1
q0
(q0,1) = q0
2) Un AFD que reconozca cero o más unos, seguido de un cero y de cualquier cantidad de
unos y ceros.
Q = {q0, q1} 1
F = {q1} q0
(q0,0) = q1
(q0,1) = q0 0
(q1,0) = q1 q1
(q1,1) = q1
0,1
3) Un AFD que acepte cantidades pares de unos.
Q = {q0, q1}
F = {q0}
(q0,0) = q0
7

(q0,1) = q1
(q1,0) = q1
(q1,1) = q0
q0
1 1
q1
2.3 Autómata Finito no Determinístico
Los AFD se llaman determinísticos debido a que, para determinar si un string w es

reconocido es suficiente chequear que existe un único camino rotulado w a partir de q0 tal
que (q0,w)F.
Se estudiará ahora la noción de autómata finito no determinístico (AFND), en el

que existirá más de un camino para verificar si el string es aceptado por el autómata o no.
Más adelante se probará que ambas nociones de autómatas finitos son equivalentes. La
teoría del no-determinismo juega un importante papel en la teoría de lenguajes y en la de
Computación, ya que permite la demostración de distintos Teoremas relacionados. Un
AFND es un autómata finito que permite cero, una o más transiciones a partir de un estado
y un símbolo. La aceptación se tiene cuando existe algún camino desde el estado inicial
que conduzca a un estado final.
Ejemplo 1: Sea el autómata finito que acepta todos los strings que contengan dos ceros
consecutivos o dos unos consecutivos.
0,1 1
q0 0 q3 0 q4
1
q1
1
q2 0
Formalmente un AFND es una 5-tupla M = (Q,,,q0,F), en que Q, , q0, y F tienen

el mismo significado que para el AFD. Pero la función de transición  está definida entre el
producto cartesiano Qx y el conjunto(Q), en que (Q) es el conjunto potencia de Q, y
asocia a cada estado q y símbolo a el conjunto de todos los estados p = (q,a) tales que
existe una transición rotulada a desde el estado q al estado p.
Ejemplo 2: La función de transición  para el AFND del ejemplo 1 es:
8

Inputs
Estados 0 1
q0 {q0,q3} {q0,q1}
q1  {q2}
q2 {q2} 
q3 {q4} 
q4  {q4}
En este caso también es posible extender la función  de modo de ser evaluada

sobre strings de *. La extensión está dada por la función ’:Qx*  (Q), y es tal que:
1) ’(q,) = {q}
2) ’(q,wa) = (’(q,w),a)
La primera condición impide un cambio de estado sin un input y la segunda indica

que a partir de un estado q y leyendo un string wa, se puede alcanzar un conjunto de
estados dado por (’(q,w),a). Se observa que ’(q,a) = (q,a), para a pues:
’(q, a) = (’(q, ),a) = (q,a)
Luego se escribirá  en vez de ’ cuando no haya lugar a error.
Es útil extender la función de transición  a argumentos definidos sobre (Q)x*

mediante la siguiente definición para cada conjunto de estados PQ:
3) (P,w) =  (q, w)
qP
4) (,w) =  para cualquier string w considerado.
Luego, se define el lenguaje aceptado por un autómata finito no determinístico M =

(Q,,,q0,F) como el conjunto:
L(M) = {w / pF y p(q0,w)}
Ejemplo 3: Para el ejemplo 2 se verifica si el string 01001 es o no aceptado:
(q0,01001) = ((q0,0100),1) = (((q0,010),0),1)
pero: (q0,010) = ((q0,01),0) = (((q0,0),1),0)
y como (q0,0) = {q0,q3} entonces:
(q0,01) = (q0,1)  (q3,1) = {q0,q1}   = {q0,q1}, luego:
(q0,010) = (q0,0)  (q1,0) = {q0,q3}   = {q0,q3}
(q0,0100) = (q0,0)  (q3,0) = {q0,q3}  {q4} = {q0,q3,q4}
Finalmente se verifica que:
(q0,01001) = (q0,0)  (q3,0)  (q4,0) = {q0,q1,q4}
y como q4 es estado final se verifica que el string 01001 es aceptado por este autómata.
Asimismo, se observa que los strings 0, 01 y 010 no son aceptados y que el string 0100 si
lo es.
9

2.4 Equivalencia de AFD’s y AFND’s
Dado que cada AFD es un AFND en que existe una única transición desde cada
estado para cada símbolo, queda por analizar si los AFND pueden ser equivalentes a un
AFD, en el sentido que reconozcan el mismo lenguaje. La prueba de esta aseveración está
en el hecho que un AFD puede simular a un AFND sobre el string que se esté analizando
siguiendo los estados del AFD correspondientes a conjuntos de estados del AFND. El
teorema que asegura este resultado es el siguiente.
Teorema 2.1 Equivalencia de AFD’s y AFND’s
Sea L un lenguaje aceptado por un AFND. Entonces existe un AFD que reconoce
L.
Demostración. Sea M = (Q,,,q0,F) un AFND que reconoce L. Se define un AFND M’ =

(Q’, ,’, q0’,F’) como sigue:
- Los estados de Q’ son todos los subconjuntos de Q, o sea que Q’ es el conjunto

potencia, es decir Q’ = (Q). Un estado de Q’ se denota por [q1,q2,...,qi], en que cada
estado qj está en Q, 1 j  i. Se observa que este es un estado simple que representa al
conjunto de estados {q1,q2,...,qi}.
- F’ es el conjunto de todos los estados en Q’ que contiene un estado de F.
- q0’ = [q0]
- La función de transición ’ se define según la siguiente relación para estados de Q’ y

símbolos a:
’([q1,q2,...,qi],a) = [p1,p2,...,pj] ssi ({q1,q2,...,qi},a) = {p1,p2,...,pj}
Primero se probará la relación sobre strings x*, que es:
’(q0’,x) = [q1,q2,...,qi] ssi (q0,x) = {q1,q2,...,qi}
Por inducción sobre la longitud del string x.
Base: si |x| = 0, o sea x =  y se tiene:
’(q0’, ) = q0’ = [q0] y por otro lado (q0, ) = {q0}, luego se verifica la relación.
Parte inductiva: se supone válida la hipótesis para strings de longitud n o menor. Sea x de
longitud n y analicemos el valor de la función de transición sobre el string xa, con a.
’(q0’,xa) = ’(’(q0’,x),a)
Por hipótesis de inducción:
’(q0’,x) = [q1,q2,...,qi] ssi (q0,x) = {q1,q2,...,qi}
luego, usando la definición de ’:
’(q0’,xa) = ’([q1,q2,...,qi],a) = [p1,p2,...,pj] ssi

({q1,q2,...,qi},a) = {p1,p2,...,pj}, o sea que:
10

’(q0’,xa) = [p1,p2,...,pj] ssi (q0,xa) = {p1,p2,...,pj}, por lo que se observa que ’(q0’,xa)
existe ssi (q0,xa) existe y verifican la relación planteada, lo que establece el resultado a
probar.
Finalmente se debe comprobar que L(M’) = L(M) = L. Para esto se ve que:

xL(M’) ssi ’(q0’,x)F’ ssi (q0,x) contiene un estado de F, por lo que se verifica esta
relación.

Ejemplo 4: Sea el AFND siguiente:
0
q0 1 q1
1 0 1
1 q2
Se llaman conjuntos alcanzables a aquellos subconjuntos de estados a los cuales se

puede llegar desde el estado inicial. En este caso:
{q0} 1 {q1,q2} 1 {q2} 0 {q1} 0 {q1}

0 0 1 1
 {q1} {q2} {q2}
Agregando el estado vacío se obtiene el siguiente AFD:
1 0
[q0] [q1,q2] [q1] 0
0 1 0
 1 [q2] 1
0,1
2.5 Autómata Finito con transiciones vacías AFND-
El modelo de AFND se puede extender para incluir transiciones sobre el string

vacío . Se estudiará este tipo de autómata y se demostrará que es equivalente con un
AFND sin transiciones vacías y, por el teorema anterior, será equivalente con un AFD.
Ejemplo 1: Sea el AFND- siguiente, que permite reconocer strings con cualquier cantidad
de ceros, seguido de cualquier cantidad de unos, seguido de cualquier cantidad de dos.
Luego, el lenguaje aceptado es 0*1*2*.
11

0 1 2
q0  q1  q2
Formalmente se define un autómata finito no determinístico con transiciones

vacías, que llamaremos AFND-, como la 5-tupla M = (Q,,,q0,F) con todas sus
componentes como en el AFND, excepto que la función de transición  está ahora definida
entre los conjuntos Qx( {}) en el conjunto potencia de Q, (Q). Luego, (q,a)
consiste de todos los estados p tales que haya una trayectoria rotulada “a” desde q a p, en
que “a” puede ser  o un símbolo de . La aceptación de un string ocurrirá por la presencia
de algún estado final al analizar el string completo a partir del estado inicial q0.
Ejemplo 2. Para el ejemplo 1 la función de transición está dada por:
 0 1 2 
q0 {q0}   {q1}
q1  {q1}  {q2}
q2   {q2} 
Para ver que el string 002 es aceptado se observa que hay un camino desde el
estado inicial q0 al final q2, que es: q0, q0, q0, q1, q2, q2 el cual está rotulado por los arcos 0,
0, , , 2.
Extendiendo  a la función ’ entre Qx* y (Q), se desea que ’(q,w) sean todos los
estados p tales que se puede ir desde q a p a lo largo de un camino rotulado w, incluyendo
arcos rotulados  en el camino. Al construir ’ es importante considerar el cálculo de los
estados alcanzables desde un estado dado q usando sólo transiciones vacías, lo cual es
equivalente a determinar qué vértices pueden ser alcanzados desde un vértice dado (fuente)
en un digrafo. El vértice fuente es el vértice del estado q en el diagrama de transición, y el
digrafo consiste de todos los arcos rotulados . Se llamará a este conjunto -CLOSURE(q).
Ejemplo 3. En el AFND del ejemplo 1 se verifica que:
-CLOSURE(q0) = {q0, q1, q2}

-CLOSURE(q1) = {q1, q2}
-CLOSURE(q2) = {q2}
Para un conjunto de estados P se define:
-CLOSURE(P) =  -CLOSURE(q).
qP
La función de transición extendida ’ se define entonces por:
1) ’(q,) = -CLOSURE(q)
2) w* , a , ’(q,wa) = -CLOSURE((’(q,w),a)).
Se observa que (q,a) y ’(q,a) no coinciden en símbolos del alfabeto, ya que en el caso
de ’ se deben considerar los estados agregados por el conjunto -CLOSURE(q). Por lo
anterior será necesario distinguir  de ’ cuando nos referimos a un AFND-.
Ejemplo 4. En el autómata del ej. 1 se ve que: (q0,0) = {q0} y que ’(q0,0) = {q0, q1, q2}.
12

Es conveniente extender la función de transición  y su extensión ’ a conjuntos de

estados P mediante la definición:
3) (P,a) =  (q,a)
qP
4) ’(P,w) =  ’(q,w)
qP
5) Se observa que (,a) = ’(,w) = .
Un AFND es equivalente a un AFND- como veremos en el siguiente teorema.
Teorema 2.2 Equivalencia de AFND y AFND-
Si L es aceptado por un AFND- entonces es aceptado por un AFND.
Demostración. Sea M = (Q,,,q0,F) un AFND-. Se construye un AFND M’ =

(Q,,`,q0,F’) en que F’ = F {q0} si -CLOSURE(q0) contiene un estado de F, y es igual
a F si no es así. La función de transición ` se define tal que: `(q,a) = ’(q,a) para todo
estado qQ y todo símbolo a. Luego se puede usar ` para representar la extensión de
esta función de transición (ya que está definida sólo sobre símbolos y no sobre transiciones
vacías), pero se debe seguir distinguiendo entre  y ’ para el AFND-.
Se probará por inducción sobre el largo del string x que se verifica que `(q0,x) =
’(q0,x). Esta igualdad no es necesariamente cierta para x =  pues `(q0,) = {q0}, mientras
que `(q0,) es el conjunto -CLOSURE(q0).
Base: Para strings x de largo 1, o sea x = a se verifica la proposición por la definición dada
anteriormente, o sea: `(q,a) = ’(q,a).
Parte inductiva: Sea válida la proposición para strings de largo mayor a cero. Sea x = wa
con a. Entonces:
`(q0,wa) = `(`(q0,w),a)
= `(’(q0,w),a) por hipótesis de inducción
=  `(q,a) en que P = ’(q0,w)
q P
=  ’(q,a) por definición (base de inducción)

q P
= ’(P,a) por regla 4 vista antes con P = ’(q0,w)

= ’(’(q0,w),a) reemplazando
= ’(q0,wa) por definición de la extensión ’.
Finalmente se debe probar que L(M’) = L(M). Para ello se debe comprobar que:
`(q0,x) contiene un estado de F’ ssi (q0,x) contiene un estado de F, para x*. Si x = 
esta proposición es directa a partir de la definición de F’, pues `(q0,) = {q0} y q0F’
cuando (q0,) contiene un estado final de F (aunque no sea q0). Si x no es el string vacío
entonces si (q0,x) contiene un estado de F, entonces `(q0,x) contiene el mismo estado en
F’. Inversamente, si `(q0,x) contiene un estado de F’ distinto de q0, entonces (q0,x)
contiene un estado de F. Si `(q0,x) contiene a q0 y q0F, entonces como ’(q0,x) = -
CLOSURE((`(q0,w),a)), el estado en -CLOSURE(q0) y en F debe estar en ’(q0,x).

13

Ejemplo 5. Se aplicará la construcción de este Teorema al AFND- del ejemplo 1, o sea el

que reconoce al lenguaje L = 0*1*2*. La tabla de transiciones de ’ (extensión de la función
de transición ) es en este caso:
` 0 1 2
q0 {q0, q1, q2} {q1, q2} {q2}
q1  {q1, q2} {q2}
q2   {q2}
Esta tabla coincide con la de la función de transición ` del AFND- construida por
el Teorema. Como el estado q2 está en F y en la -CLOSURE(q0) entonces F’ = {q0, q2}. El
diagrama de transiciones del AFND M’ sin transiciones vacías es entonces:
0,1 1,2
0 q0 q1 q2 2
0,1,2 1
2.6 Expresiones Regulares
Los lenguajes aceptados por los autómatas finitos son fácilmente descritos por
expresiones simples llamadas expresiones regulares, las que se definen como sigue.
2.6.1 Definición Lenguajes Regulares
Sea  un alfabeto. El conjunto de los lenguajes regulares sobre  se define

recursivamente como sigue:
a)  es un lenguaje regular.
b) {} es un lenguaje regular.
c) a, {a} es un lenguaje regular.
d) Si R y S son lenguajes regulares, entonces RS, RS y R* son lenguajes regulares.
e) Ningún otro lenguaje sobre  es lenguaje regular.
Ejemplo 1. Dado  = {a,b} se tienen los siguientes lenguajes regulares: , {}, {a}, {b},
{a}  {b} = {a,b}, {aa, ab, ba, bb}, etc.
Además son lenguajes regulares los siguientes conjuntos:
{ai / i  0} = {, a, aa, aaa, aaaa,...}

{ai bj / i,j  0} = {, a, b, aa, ab, bb, aaa, abb, aab, bbb, ...}
Para simplificar la especificación de un lenguaje regular se usa una abreviación

llamada expresión regular (e.r.). Se define recursivamente una e.r. sobre un alfabeto 
como sigue:
a)  y  son e.r. y representan al lenguaje regular  y {} respectivamente.

b) a, a es una e.r. y representa al lenguaje regular {a}.
c) Si r y s son e.r. que representan a los lenguajes regulares R y S respectivamente,
entonces r+s, rs y r* también lo son y representan a la unión de conjuntos RS, la
concatenación RS y la clausura del conjunto R llamada R* respectivamente.
d) Ninguna otra secuencia de símbolos es una expresión regular.
14

Ejemplo 2. Sea el alfabeto  = {a,b}. Entonces se tienen las siguientes e.r.: a+b que
representa al lenguaje regular {a, b}; ab que representa al lenguaje regular {ab}; a* que
representa al lenguaje regular {a}* = {ai / i  0} visto en el ejemplo 1; y la expresión a* b*
que representa al conjunto {ai bj / i,j  0}.
Observación. Existe un orden de precedencia de los operadores de una expresión regular

dado por: clausura primero, luego la concatenación y finalmente la unión de expresiones
regulares. Luego, la e.r. a* b + c representa al lenguaje regular ({a}*{b}){c}.
Si r es una e.r., se dirá que el lenguaje regular representado por r será L(r). Si r y s
son e.r. sobre  y si L(r) = L(s), entonces se dice que las e.r. r y s son equivalentes y se
anota que r = s.
2.6.2 Equivalencias entre Expresiones Regulares.
Para cualesquier e.r. r, s y t se verifican las siguientes equivalencias:
1) (r*)* = r*
2) * = 
3) r r* = r* r = r+ (se llama clausura positiva)
4) r* = r++  = r*r* = ( + r)* = r* (r + ) = (r + ) r*
5) r + r = r
6) r +  =  + r = r
7) r = r = 
8) r + s = s + r
9) r + (s + t) = (r + s) + t
10) r(s + t) = rs + rt
11) (r + s)t = rt + st
12) (r + s)* = (r* + s*)* = (r* s*)* = r* (s r*)* = (r* s)* r*
13) r(s r)* = (r s)* r
La validez de cada equivalencia se obtiene directamente de las propiedades de unión,

concatenación, clausura y la teoría de conjuntos.
Ejemplo 3: Demuestre que r(sr)* = (rs)*r.
Sea el string w en L(r(sr)*). Entonces: w = uv con uL(r) y vL((sr)*), o sea v =

(s0r0)(s1r1)...(snrn) con n  0 y siL(s) y riL(r), y en que n = 0 indica que v = . Luego,
como la concatenación de strings es asociativa, se obtiene:
w = u (s0r0)(s1r1)...(snrn) = (us0)(r0s1)(r1s2)...(rn-1sn) rn
Luego se deduce que wL((rs)*r).
Definición. Dada una expresión regular s, que describe al lenguaje regular S, se define el
reverso de s como aquella expresión regular que describe el reverso de los strings de S, o
sea al lenguaje Sr, y que se define como sigue:
1) Sí s = ,  o un símbolo a entonces sr = s.
2) Sí s = w1w2 entonces sr = w2r w1r.
3) Sí s = w1 + w2 entonces sr = w1r + w2r.
15

4) Sí s = w* entonces sr = wr *.
Entonces, si se desea construir la e.r. del reverso de un lenguaje regular, es necesario tan
solo invertir el orden de las subexpresiones unidas por la operación concatenación.
Ejemplo 4.
Sí s = 01(0*11 + 1*00)01 entonces: sr = 10(110* + 001*)10.
Otra utilidad práctica del reverso de una expresión regular es que permite demostrar
algunas de las equivalencias dadas anteriormente.
Ejemplo 5. Demuestre que (r + s)* = (r*s)* r*.
Se conoce que: (r + s)* = r* (sr*)*. Luego, tomando el reverso de las e.r. de esta
equivalencia se tendrá:
(rr + sr)* = (r*(s r*)*)r = (rr * sr)* rr *
De la igualdad anterior se deduce el resultado, considerando que rr y sr son e.r.

individuales.
2.7 Equivalencia entre Autómatas Finitos y Expresiones Regulares.
Se verá que los lenguajes aceptados por autómatas finitos son precisamente los
lenguajes denotados por las expresiones regulares. Esta equivalencia es el motivo para
llamar lenguajes (o conjuntos) regulares a los lenguajes aceptados por los autómatas
finitos. Los teoremas que se analizarán permiten obtener la siguiente relación entre los
tipos de autómatas estudiados y las expresiones regulares:
AFND
AFD AFND-
e.r.
Teorema 2.3 Una e.r. es equivalente a un AFND-.
Sea r una e.r. Entonces existe un AFND- que acepta L(r).
Demostración. Se mostrará por inducción sobre el número de operadores en la e.r. r que

existe un AFND- M que posee un estado final (sin transiciones fuera de este estado) tal
que L(M) = L(r).
Base. Supongamos una e.r. con cero operadores. Esta expresión sólo puede ser , , o un
símbolo a. Los AFND’s que reconocen estas e.r. son:
16

1) r = 
q0 qf
2) r = 
q0
3) r = a a
q0 qf
Parte inductiva. Suponemos ahora que el teorema es válido para e.r. con menos de i
operadores. Sea r una e.r. con i operadores (en que i  1). Entonces hay tres casos que
dependen de la forma de la e.r. r considerada.
Caso 1. La expresión regular es r = r1 + r2. Como r1 y r2 deben tener menos de i operadores

cada uno, por hipótesis de inducción existen los autómatas AFND- siguientes:
M1 = (Q1, 1, 1, q1, {f1})

M2 = (Q2, 2, 2, q2, {f2})
en que L(M1) = L(r1) y L(M2) = L(r2). Como se pueden renumerar los estados de un
autómata, se supondrá que los conjuntos Q1 y Q2 son disjuntos. Sea q0 un nuevo estado
inicial y f0 un nuevo estado final. Sea el AFND- M = (Q1Q2{q0,f0},12,,q0,{f0}).
La función de transición  se define como sigue:
i) (q0,) = {q1,q2}
ii) (q,a) = 1(q,a) , qQ1-{f1}, a1{}
iii) (q,a) = 2(q,a) , qQ2-{f2}, a2{}
iv) (f1,) = (f2,) = {f0}
Se observa que, por la hipótesis de inducción, no hay movimientos fuera de los

estados f1 o f2 en M1 o M2. Luego todos los movimientos de estos dos autómatas están
presentes en M. En forma gráfica M es el siguiente autómata:
 q1 M1 f1 
q0 f0
 q2 M2 f2 
Se observa que cualquier camino rotulado por un string x en M entre q0 y f0, o bien
va por M1 o por M2, y luego, habrá un camino rotulado x en M1, entre q1 y f1, o en M2,
entre q2 y f2, por lo que el lenguaje aceptado por M es L(M) = L(M1)  L(M2).
Caso 2. La expresión regular es r = r1r2. Sean M1 y M2 como en el caso 1 y se construye el

siguiente AFND-:
M = (Q1Q2,12,,q1,{f2})
17

i) (q,a) = 1(q,a) , qQ1-{f1}, a1{}

ii) (f1,) = {q2}
iii) (q,a) = 2(q,a) , qQ2, a2{}
En forma gráfica el autómata M es el siguiente:

q1 M1 f1 q2 M2 f2
Se observa que cada camino en M, entre q1 y f2 es un camino rotulado por algún

string x entre los estados q1 y f1, seguido de la transición vacía entre f1 y q2, y seguido de
un camino rotulado por algún string u entre q2 y f2. Luego:
L(M) = {xu / xL(M1) y uL(M2)} = L(M1) L(M2).

Caso 3. La expresión regular es r = r1*. Sea M1 el autómata definido en el caso 1. Se
construye el siguiente AFND-:
M = (Q1{q0,f0},1, ,q0,{f0})
i) (q0,) = (f1,) = {q1,f0}

ii) (q,a) = 1(q,a) , qQ1-{f1}, a1{}
En forma gráfica el autómata M es el siguiente:

 
q0 q1 M1 f1 f0

Cualquier camino desde q0 a f0 consiste, o bien de un camino entre estos estados
rotulado  (se reconoce el string vacío) o bien de un camino entre q0 y q1 sobre , seguido
de una cierta cantidad (posiblemente cero) de caminos entre q1 y f1, en los que se reconoce
un string de L(M1), seguido de un retorno a q1 por una transición vacía, para terminar en la
transición vacía que une el estado f1 con f0. Luego, si xL(M), entonces, o bien x =  o
bien x = x1x2...xj, con j > 0, tal que cada xiL(M1). Luego se verifica que L(M) = L(M1)*.
Ejemplo 6. Dada la expresión regular 01* + 1 construir el AFND- equivalente. La e.r.

anterior se describe como (0(1*)) + 1, así que tiene la forma r1 + r2, con r1 = 01* y r2 = 1.
Asimismo, r1 = r3 r4, con r3 = 0 y r4 = 1*. Finalmente r4 = r5* con r5 = 1. Luego queda:
Para r2 = 1: 1
q1 q2
Para r3 = 0: 0
q3 q4
18

Para r5 = 1. q5 q6
Usando las reglas descritas en la demostración del Teorema 2.3 se obtienen:
 1 
*
Para r4 = 1 : q7 q5 q6 q8
 
Para r1 = 01*:

q3 q4 q7 q5 q6 q8
0   1 

Finalmente para r = 01* + 1 se obtiene:

1 
 q1 q2 q9
q0
 
 q3 0 q4  q7  q5 1 q6  q8

Teorema 2.4 El lenguaje aceptado por un AFD es equivalente a una e.r.
Si L es aceptado por un AFD entonces existe una e. r. r tal que L(r) = L.
Demostración. Sea L el conjunto aceptado por el siguiente AFD:
M = ({q1,q2,...,qn}, , , q1, F)
Sea Rkij el conjunto de todos los strings x tales que (qi,x) = qj y si se tiene que
(qi,y) = qm, para cualquier y que sea prefijo de x (con y  x e y  ) entonces m  k, o sea
que este conjunto contiene todos los strings que permiten ir desde el estado qi al qj sin
pasar por estados numerados mayores que qk. Si se puede dar que i o j sean mayores que k.
Además, como no existe un estado numerado mayor que qn, entonces Rnij contiene todos
los strings que unen qi con qj. Recursivamente este conjunto se define como:
Rkij = Rk-1ik (Rk-1kk)* Rk-1kj  Rk-1ij
Los conjuntos mencionados en esta definición son:
Rkij = {strings que unen qi con qj pasando por qk o estados numerados menores} 
{strings que unen qi con qj sin pasar por qk}
19

Rk-1ij = {strings que unen qi con qj sin pasar por qk}
Rk-1ik = {strings que unen qi con qk pasando por estados numerados menores a qk}
Rk-1kk = {strings que unen qk consigo mismo pasando por estados numerados
menores a qk}
Rk-1kj = {strings que unen qk con qj sin pasar por estados numerados menores que
qk}
Además se define el conjunto R0ij como sigue:
R0ij = {a / (qi,a) = qj} si i  j
R0ij = {a / (qi,a) = qj}  {} si i = j
R0ij = {} si i = j y no hay transiciones sobre algún símbolo de 

R0ij =  si i  j y no hay transiciones sobre algún símbolo de 
Primero se mostrará, usando inducción sobre k, que i,j,k existe una expresión
regular rkij cuyo lenguaje regular asociado representa al conjunto Rkij.
Base. Sea k = 0. El conjunto R0ij está formado por las expresiones regulares básicas, ya sea
, {} o por conjuntos de símbolos del alfabeto . Entonces las expresiones regulares
asociadas son:
r0ij = a1 + a2 +...+ ap si i  j y (qi,am) = qj con 1  m  p
r0ij = a1 + a2 +...+ ap +  si i = j y (qi,am) = qj con 1  m  p
r0ij =  si i = j y no hay transición sobre algún símbolo de 
r0ij =  si i  j y no hay transición sobre algún símbolo de 
Parte inductiva. Sea k > 0. Como la fórmula recursiva dada anteriormente para el
conjunto Rkij solo considera operadores presentes entre expresiones regulares, o sea
clausura, concatenaciones y unión de conjuntos, y asumiendo por la hipótesis de inducción
que para el conjunto Rk-1lm existe la expresión regular rk-1lm que la representa, l,m,
entonces se obtiene la siguiente expresión regular para Rkij:
rkij = rk-1ik (rk-1kk)* rk-1kj + rk-1ij
Esto completa esta parte de la demostración. Finalmente se debe probar que el

lenguaje asociado al autómata M se puede representar a través de las expresiones regulares
definidas. Se observa que:
L(M) = 
q j F
Rn1j
En esta igualdad Rn1j denota a todos los strings que unen el estado inicial q1 con el
estado final qj, j  1. Luego, el lenguaje L(M) está representado por la expresión regular:
r= 
q j F
rn1j
20

Ejemplo 7. Sea M el AFD siguiente que representa a los strings de 0 y 1 con una cantidad
positiva de ceros:
1 1 1
0 0
q1 q2 q3
0
El estado final son F = {q3} y la función de transición es:
 0 1
q1 q2 Q1
q2 q3 Q2
q3 q2 Q3
Entonces la tabla de las expresiones regulares rkij es la siguiente:
rkij \ k 0 1 2
rk11 1+ 1* 1*
rk12 0 1*0 1*01*
rk13   1*01*0
rk21   
rk22 1+ 1 + 1*
rk23 0 0 1*0
rk31   
rk32 0 0 01*
rk33 1+ 1+ 01 0 + 1 + 
*
El lenguaje aceptado se representa entonces por la siguiente expresión regular:
r313 = r213 (r233)* r233 + r213 = 1*01*0(01*0+1+)* (01*0+1+) + 1*01*0
Luego, con las equivalencias estudiadas para expresiones regulares:
r313 = 1*01*0(01*0+1+)* factorizando por 1*01*0 a la izquierda

= 1*01*0 (01*0+1)* (r + )* = r*
= 1*01*0(1*01*0)*1* (s + r)* = (r*s)*r*
= 1*01*(01*01*)*01* r(sr)* = (rs)*r
= 1*0(01*0 + 1)*01* r*(sr*)* = (r + s)*
Luego L(M) se representa por la e.r. r = 1*0(01*0 + 1)*01*.
2.8 Búsqueda de strings en Expresiones Regulares.
Para toda expresión regular r, y según el Teorema 2.3, existe un AFND-

M=(Q,,,q0,{qf}) tal que L(M) = L(r), y en el que se verifican las siguientes condiciones:
1) El número de estados no es mayor que el doble del largo de la expresión medido en

cantidad de símbolos.
21

2) No hay transiciones desde el estado final qf.
3) La cantidad de transiciones desde cualquier estado de Q no es mayor a dos.
Lo descrito antes permite determinar si un prefijo del archivo calza con una expresión
regular r dada. Para ello se reemplaza r por la expresión s = *r, en que  es el alfabeto. Se
puede determinar la primera ocurrencia del string x = a1a2...an en r encontrando el prefijo
más corto de x que esté en el lenguaje dado por s. Esto se hace construyendo un AFND-
que reconozca el conjunto denotado por s y luego aplicando un algoritmo para reconocer la
secuencia de estados Qi en que el AFND- puede estar luego de analizar a1a2...ai, con 1  i
 n. Si Qj contiene un estado final, se deduce que a1a2...aj tiene un sufijo akak+1...aj que está
en el lenguaje denotado por r, con 1  k  j. Se definen:
Q0 = -CLOSURE(q0)
Qi = -CLOSURE((Qi-1,ai)), 1  i  n
El algoritmo que se verá a continuación recibe como input el AFND- definido

antes y el string x a analizar. Su output es la secuencia de estados Q0, Q1,..., Qn.
for(i = 0; i  n; i++)
{ if(i == 0)
Q0  {q0};
else
Qi  (Qi-1,ai);
<marcar qQi como “considerado”>;
<marcar qQ-Qi como “no considerado”>;
COLA  Qi;
while(COLA  )
{ <hallar q, primer elemento de COLA>;
<borrar q de COLA>;
for(cada p(q,))
if(p es “no considerado”)
{ <marcar p como “considerado”>;
<agregar p a COLA y a Qi>;
}
}
}
Ejemplo 8. Sea la e.r. r = ab* + c. El AFND- asociado, según Teorema 2.3, es:
 
 q1 a q2  q3  q4 b q5  q6
q0
 
q7 c q8  q9
Para el input x = ab se aplica el algoritmo anterior y se obtiene:
Q0 = {q0,q1,q7}
Q1 = {q2,q3,q4,q6,q9}
22

Q2 = {q4,q5,q6,q9}
Como q9Q2 entonces x = ab es un string aceptado por el lenguaje representado por

la expresión regular dada.
2.9 Autómatas Finitos con Output
Una limitación de los autómatas finitos, tal como se han definido, es que su output
está limitado a una señal binaria: “aceptado” o “no aceptado”. Los modelos que se
considerarán ahora eligen su output de otro alfabeto por lo que pueden emitir una salida
diferente para un string de entrada dado. Estudiaremos dos tipos de autómatas distintos
según si su output está asociado con el estado o con la transición. Más adelante se verá que
ambos modelos son equivalentes entre sí.
2.9.1 Autómata de Moore
Un autómata de Moore es una 6-tupla M = (Q,,,,,q0), en que Q, ,  y q0

tienen la misma definición que en un autómata finito determinístico. El conjunto  es el
alfabeto de salida y  es una función, llamada de output, definida entre Q y  que
determina el output asociado con cada estado del autómata. El output de M en respuesta al
input x1x2...xn, para n  0, es el string de * (q0) (q1)... (qn), en que los estados qi son
tales que (qi-1,xi) = qi, 1  i  n. Se observa que un autómata de Moore siempre tiene el
output (q0) para el string . Así también, se puede ver que un AFD es un caso particular
de un autómata de Moore, en que el alfabeto de salida es  = {0,1}, por ejemplo, y el
estado q es de aceptación ssi (q) = 1 por ejemplo, y de rechazo si este valor es cero.
Ejemplo 1. Se desea modelar, mediante un autómata de Moore, el cálculo del residuo

módulo 3 de un entero tratado como número binario. O sea que  = {0,1} y  = {0,1,2}. Se
deben tener en cuenta las siguientes consideraciones:
- Si i es un entero en binario y le sigue un 0, el string resultante tiene valor 2i.

- Si i es un entero en binario y le sigue un 1, el string resultante tiene valor 2i+1.
- Si el resto de i/3 es p, entonces el resto de 2i/3 es 2p mod 3, o sea que si p es 0,1,2
entonces 2p mod 3 es 0,2,1 respectivamente.
- Si el resto de i/3 es p, entonces el resto de (2i+1)/3 es (2p+1)mod 3, o sea que si p es
0,1,2 entonces (2p+1)mod 3 es 1,0,2 respectivamente.
Entonces basta con diseñar un autómata de Moore con tres estados q0, q1 y q2, tales que
qj es alcanzado ssi el string de entrada tiene residuo j. Se define entonces: (qj) = j, con j =
0,1,2. El autómata tendrá las siguientes transiciones:
 0 1
q0 q0 q1
q1 q2 q0
q2 q1 q2
Gráficamente el autómata es:
0 1 2
q0 1 q1 0 q2
1 0
0 1
23

Se observa que el último símbolo alcanzado en el output corresponderá al residuo

del string analizado. Por ejemplo, para el string 1010 el output es 01221, o sea que el
residuo del entero 10 es 1, lo cual es correcto.
2.9.2 Autómata de Mealy
Un autómata de Mealy M = (Q,,,,,q0) tiene las mismas componentes que el de

Moore, excepto que la función de output  está definida entre los conjuntos Qx y , o sea
que (q,a) es el output asociado con la transición desde el estado q dado que hay un input
a. El output de M en respuesta al input x1x2...xn, para n  0, es: (q0,a1) (q1,a2)... (qn-1,an),
en que los estados qi son tales que se verifica (qi-1,ai) = qi, con 1  i  n. Se observa que
este string es de largo n y no n+1 como es el output del autómata de Moore, y para el input
 el autómata de Mealy tiene output .
Ejemplo 2. Se desea simular la aceptación de los strings del lenguaje representado por la
expresión regular (0 + 1)*(00 + 11), o sea de todos los strings binarios cuyos dos últimos
símbolos sean iguales. Un AFD que reconozca este lenguaje no puede tener menos de
cinco estados. Sin embargo, mediante un autómata de Mealy es posible reconocer estos
strings con tres estados, que usa cada estado para recordar cuál fue el último símbolo leído
e informa con un output “s” si el símbolo actual coincide con el previo, y una “n” si no es
así. Para ello se define M = ({q0,q1,q2},{0,1},{s,n},,,q0), el autómata de Mealy en que
sus transiciones son:
 0 1
q0 q1 q2
q1 q1 q2
q2 q1 q2
Y la función de salida es:
 0 1
q0 n n
q1 s n
q2 n s
En la representación gráfica se usa un arco rotulado a/b sobre un arco del estado p
al q para indicar que (p,a) = q y (p,a) = b.
0/s
0/n q1
q0 1/n 0/n
1/n q2 1/s
Se observa que el output para el string 01100 es nnsns, con la secuencia de estados
q0q1q2q2q1q1.
2.9.3 Equivalencia entre autómatas de Moore y Mealy
Sea M un autómata con output. Se define TM(w), para un string w, el output

producido por M sobre el input w. Si M es un autómata de Mealy y M’ es el de Moore,
TM(w) y TM’(w) no son de igual largo pues |TM(w)| < |TM’(w)|, debido al output extra
asociado al string  en el autómata de Moore. Sin embargo, se puede despreciar la
24

respuesta del autómata de Moore al string vacío y decir que ambos autómatas son
equivalentes sí: w* se verifica que bTM(w) = TM’(w), en que b es (q0) en Moore.
Entonces se tienen los siguientes resultados:
Teorema 2.5 Un autómata de Moore equivale a uno de Mealy
Si M1 = (Q,,,,,q0) es un autómata de Moore entonces existe un autómata de

Mealy M2 equivalente a M1.
Demostración. Sea M2 = (Q,,,,’,q0) el autómata de Mealy a construir, en que el único

cambio respecto a M1 es en la función de transición definida por: ’(q,a) = ((q,a)),
qQ, a. Entonces M1 y M2 entregan la misma sucesión de estados para un mismo
input, ya que si el input es x = x1x2...xn entonces su output por M1 es (q0) (q1)... (qn) y
en M2 es: ’(q0,a1) ’(q1,a2)... ’(qn-1,an) que es igual a (q1)... (qn), por lo que la
equivalencia mencionada anteriormente se verifica.

Ejemplo 3. Para el autómata de Moore M1 del ejemplo 1, el autómata de Mealy M2

equivalente es:
’ 0 1
q0 0 1
q1 2 0
q2 1 2
Y el autómata queda gráficamente como sigue:
0/0 1/1 0/2 1/2

q0 q1 q2
1/0 0/1
Teorema 2.6 Un autómata de Mealy equivale a uno de Moore
Sea M1 = (Q,,,,,q0) un autómata de Mealy. Entonces existe un autómata de

Moore equivalente a M1.
Demostración. Sea M2 = (Qx,,,’,’,[q0,b0]), en que b0 es un elemento del alfabeto de

salida  seleccionado arbitrariamente. Los estados de M2 son pares del tipo [q,b] que
consisten de un estado de M1 y de un símbolo de . Se define la función de transición
’([q,b],a) = [(q,a), (q,a)] y la función de salida ’([q,b]) = b. El segundo componente de
un estado [q,b] de M2 es el output dado por M1 en alguna transición al estado q. Solo las
primeras componentes de los estados de M2 determinan los movimientos realizados por
M2. Por inducción sobre n se puede probar que si M1 alcanza los estados q0, q1,..., qn para
el input x1x2...xn y emite el output b1b2...bn, entonces M2 alcanza los estados [q0,b0],
[q1,b1],..., [qn,bn] y emite el output b0b1...bn.

Ejemplo 4. Para el autómata de Mealy M1 del ejemplo 2 se tendrá que los estados de Qx
del autómata de Moore equivalente M2 son:
Qx = {[q0,s],[q0,n],[q1,s],[q1,n],[q2,s],[q2,n]}
Se elegirá arbitrariamente b0 = n y se tiene entonces que [q0,n] es el estado inicial

de M2. Gráficamente el autómata es:
25

n 1 n n
[q0,n] 0 [q1,n] 1 [q2,n]
0 1
0 0
[q1,s] [q2,s] 1
s s
0 1
Se observa que el estado [q0,s] nunca es alcanzado y luego no es considerado (se

puede remover del autómata).
Es posible verificar que este autómata es equivalente al original. Para el string

01100 el output de M1 era nnsns (ver ejemplo 2). En el autómata actual el output para este
mismo string es nnnsns, con lo cual se verifica la equivalencia.
2.10 Sistemas de Ecuaciones Regulares
Se estudiará en este Capítulo una manera alternativa de determinar el lenguaje

regular asociado a un autómata. Este método permite, a partir de las transiciones del
autómata, obtener un sistema de ecuaciones regular asociado, el cual conduce a obtener la
expresión regular que representa al lenguaje aceptado.
Teorema 2.7 Lema de Arden
Sean X, T y E conjuntos regulares, definidos sobre un alfabeto . Entonces, si E,

la ecuación X = EX + T tiene una única solución dada por X = E*T.
Demostración. Se observa que X = E*T es solución de la ecuación planteada pues:
X = EX + T = E(E*T) + T = (E E* + )T = E*T
Para ver que esta solución es única se desarrolla recursivamente como sigue:
X = EX + T = E(EX + T) + T = EEX + ET + T
= E2(EX + T) + ET + T = E2EX + E2T + ET + T
= E3(EX + T) + E2T + ET + T
... = Ei+1X + EiT +... + E2T + ET + T, con i  0
Luego:
X = ( + E + E2 +...+Ei)T + Ei+1X (1)
Para demostrar que X = E*T se tienen los siguientes pasos.
() Sea wX con |w| = k. Para i = k, reemplazando en la ecuación (1) se tendrá que:
X = ( + E + E2 +...+Ek)T + Ek+1X
Como E, w no puede estar en Ek+1X (la longitud del string más corto en este
conjunto es, al menos, k+1), entonces el string w debe estar en ( + E + E2 +...+Ek)T, y
26

como ( + E + E2 +...+Ek)T es subconjunto de E*T entonces wE*T. Luego se verifica: X

 E*T.
() Sea ahora wE*T. Entonces existe k tal que wEkT. Luego se tendrá que w( + E +
E2 +...+Ek)T, de donde se deduce que wX (por la proposición (2)). Luego se verifica que:
E*T  X.
Por lo tanto: X = E*T.


Ejemplo 1. Sea la ecuación sobre  = {0,1}:
X = 0 + (0+)X  X = (0+)*0 = 0*0 = 0+.
Se estudiarán sistemas de ecuaciones regulares lineales, cuyos coeficientes e

incógnitas son subconjuntos de *, o sea que, dado un n  1 y los subconjuntos de *: Eij y
Ti, 1  i,j  n, se desea determinar las incógnitas Xi (1  i  n), subconjuntos de * que
satisfagan el sistema de n ecuaciones siguiente:
n
Xi = Ti   Eij Xj, i = 1,2,...,n (2)
j 1
Teorema 2.8 Existencia de solución única para sistema (2)
Si Eij, 1  i,j  n, entonces el sistema (2) admite una única solución.
Demostración. Suponemos que los subconjuntos X1,...,Xn e Y1,...,Yn de * son soluciones

del sistema (1). Se mostrará por inducción sobre |w|, con w*, que: wXi ssi wYi, con
1  i  n (o sea que Xi = Yi).
Base. Si w = , y como Eij por hipótesis, entonces se deduce del sistema (2) que: Xi
ssi Ti ssi Yi para 1  i  n, con lo cual Xi = Yi en este caso.
Parte inductiva. Sea w* con |w| > 0, y supongamos que wXi. Entonces por el sistema
(2) se tiene:
n
wTi   Eij Xj
j 1
n
Si wTi entonces wTi   Eij Yj = Yi. En caso contrario, para algún j entre 1 y
j 1
n, wEijXj. Entonces existen t1Eij y t2Xj tales que w = t1t2. Por hipótesis Eij, luego se
cumple que |t1| > 0, por lo que se verifica que |t2| < |w|, y, debido a la hipótesis de
inducción, t2Yj. Entonces:
n
w = t1t2  Eij Yj  Ti   Eij Yj = Yi
j 1
Como en ambos casos wYi, se verifica que Xi  Yi. Inversamente, los mismos
pasos permiten verificar que Yi  Xi. Luego se verifica que Xi = Yi, para i = 1,...,n.

27

Teorema 2.9 Solución del sistema (2)
Si Eij y Ti (1  i,j  n) son subconjuntos regulares de *, entonces el sistema (2)

tiene una solución Xi, 1  i  n, constituida por conjuntos regulares de *.
Demostración. Se procede por inducción sobre n.
Base. Sea n = 1. Entonces se tiene una ecuación a resolver que es: X1 = T1  E11 X1, cuya
solución por el Lema de Arden (teorema 2.7) es X1 = E*11T1. Luego, si E11 y T1 son
lenguajes regulares, la solución para X1 también lo es.
Parte Inductiva. Sea n > 1 y sea el sistema de ecuaciones con n-1 ecuaciones siguiente:
n -1
Xi = Ti’   Eij’ Xj 1  i  n-1 (3)
j 1
Eij’ = Eij  Ein E*nn Enj 1  i,j  n-1 (4)
Ti’ = Ti  Ein E*nn Tn 1  i  n-1 (5)
Por la hipótesis de inducción, el sistema (3) tiene una solución Xi, 1  i  n-1. Sea
ahora:
n -1
Xn = E*nn (Tn   Enj Xj) (6)
j 1
Los Xi, 1  i  n, que se obtienen satisfacen la ecuación (2). De hecho, si 1  i  n-1

entonces:
n -1 n -1
Xi = Ti’   Eij’ Xj = (Ti  Ein E*nn Tn)   (Eij  Ein E*nn Enj) Xj
j 1 j 1
n -1 n -1 n
Xi = Ti   Enj Xj  Ein E*nn (Tn   Eij Xj) = Ti   Eij Xj.
j 1 j 1 j 1
Por otro lado, como E*nn = {}  Enn E*nn, entonces:
n -1 n -1
Xn = E*nn (Tn   Enj Xj) = ({}  Enn E*nn) (Tn   Enj Xj)
j 1 j 1
n -1 n -1 n
Xn = Tn   Enj Xj  Enn E*nn (Tn   Enj Xj) = Tn   Enj Xj.
j 1 j 1 j 1
Si Eij y Ti son lenguajes regulares, entonces de (4) y (5) se tiene que Eij’ y Ti’
también lo son. Por la hipótesis de inducción el sistema (3) tiene una solución Xi, 1  i  n,
que está constituida por lenguajes regulares (subconjuntos de *). Por (6) Xn es también un
lenguaje regular. Luego se verifica el resultado.

Ejemplo 2. Sea el siguiente sistema de ecuaciones lineales regulares:
X1 = 0X2 + 1X3
X2 = 0X2 + 1X3
28

X3 =  + (0+1)X3
Su solución es entonces (resolviendo desde X3 hasta X1):
X3 = (0+1)*
X2 = 0X2 + 1(0+1)*  X2 = 0*1(0+1)*
X1 = 00*1(0+1)* + 1(0+1)*  X1 = 0*1(0+1)*.
Aplicación. Para cada autómata finito M = (Q,,,q0,F) se puede construir un sistema de

ecuaciones lineales regulares y determinar a partir de él la expresión regular que representa
el lenguaje aceptado por M. Si Q = {q1,q2,...,qn}, el conjunto de ecuaciones es:
n
Xi = Ti   Eij Xj, i = 1,2,...,n (7)
j 1
En que:
Xi = {w* / (qi,w)F}
Eij = {a / (qi,a) = qj}
Ti =  si qiF
Ti =  si no
Y finalmente L(M) = X1 = { w* / (qi,w)F}.
Ejemplo 3. Para el autómata finito siguiente determinar el lenguaje aceptado usando un

sistema de ecuaciones lineales regulares.
0
0
q1 q2
1 1 1
q3
El sistema es entonces:
X1 = 0X2 + 1X3
X2 = 0X2 + 1X3
X3 =  + 0X3 + 1X1
Su solución es:
X3 = 0*( + 1X1)
X2 = 0X2 + 10*( + 1X1) = 0*10*( + 1X1)
X1 = 00*10*( + 1X1) + 10*( + 1X1) = 00*10* + 10* + (00*10*1 + 10*1)X1
X1 = 0*10* + (0*10*1)X1
 L(M) = X1 = (0*10*1)*0*10* = (0 + 10*1)*10* usando la equivalencia (r + s)* = (r*s)*r*.
29

1. Si  es la función de transición de un AFD, pruebe por inducción sobre el largo del

string v que para cualesquier strings u,v se verifica que (q,uv) =((q,u),v).
2. Sea el AFD M = (Q,,,q0,F). Se define la relación sobre los estados de Q siguiente:
p R q ssi w*, (p,w)F ssi (q,w)F
a) Pruebe que R es una relación de equivalencia.
Sea M’ = (Q’, ,’,[q0],F’) tal que [q] es la clase de equivalencia de q por R y se tiene:
Q’ ={[q] / w*, (q0,w) = q}

F’ = {[q] / qF}
Además se define ’([q],a) = [(q,a)], a, qQ. Entonces:
b) Pruebe por inducción sobre el largo del string w que ’([q],w) = [(q,w)].
c) Verifique que L(M) = L(M’), o sea que M y M’ son autómatas equivalentes.
3. El lenguaje de la lógica proposicional es el conjunto de expresiones lógicas formadas

de variables lógicas simples (como p, q y r), paréntesis y los operadores:  (que
corresponde a la disyunción),  (que corresponde a la conjunción) y  (que
corresponde a la negación). Sea el alfabeto:  = {p, q, r, (, ), , , }. Escriba un
AFND sobre este alfabeto para que acepte sentencias válidas de la lógica proposicional
con un solo nivel de paréntesis como máximo. Ejemplos de sentencias válidas: p, p  q,
 p  (q  r), etc.
4. Escriba AFD’s sobre  = {0,1} que acepten los lenguajes formados por los strings tales
que:
a) Terminan con dos símbolos iguales.

b) Están formados por un cero y un uno alternado.
c) Poseen la propiedad de contener como prefijo el substring 0101 o bien el substring
1010.
d) Pertenecen al conjunto L = {0i1j0k / i + k > 0, j  0 es divisible por 3}.
e) Poseen la propiedad de tener como prefijo el substring 101 y la propiedad de contener
una cantidad impar de unos. En este caso construir un AFD que acepte ambas
propiedades, una o la otra o ambas, y una o la otra solamente.
5. Diseñe un AFD que modele el comportamiento de una máquina vendedora de dulces.

Suponga que cada dulce vale $ 100, que la máquina puede recibir monedas de $ 10, $
50 y de $ 100, y que no da vuelto pero acepta cualquier sobrepago.
6. Escriba un AFD que reconozca números reales con signo, parte entera no vacía y
decimal posiblemente vacía, separadas por un punto, y con notación científica.
Números válidos son: 3.1415, -2.8, 1.5E-10, etc.
7. Sean los AFD M1 = (Q1,,1,q1,F1) y M2 = (Q2,,2,q2,F2). Se define el producto

directo de M1 y M2 como el AFD: M1x M2 = {Q1 x Q2, ,,(q1,q2),F1x F2). La función
de transición se define: ((q,p),a) = (1(q,a),2(p,a)). Demuestre que el lenguaje
aceptado es L(M1 x M2) = L(M1)  L(M2). Aplique al caso de las expresiones regulares
r1 = 0*1(0+1)* y r2 = 1*0(0+1)* para obtener el lenguaje regular de su intersección.
30

8. Para los siguientes AFND- determine la función extendida de transición , el AFND

sin transiciones vacías equivalente, y luego el AFD equivalente a este último. Por
último, determine la expresión regular representada por estos AFD usando el Teorema
2.4.
a)
 0 1 
q0 {q0} {q2} {q1}
q1 {q3} {q1} 
q2 {q0} {q2} {q3}
q3 {q3} {q1} 
b)
 0 1 
q0   {q1}
q1 {q4} {q4} {q2}
q2 {q2,q5} {q3} 
q3   
q4   
q5 {q4} {q3,q4} 
c)
 0 1 
Q0 {q1}  {q1}
Q1 {q3} {q2,q3} {q2}
Q2   {q3}
q3   {q2}
9. Demuestre las siguientes equivalencias usando las propiedades de teoría de conjuntos y

de la concatenación de strings que Ud. conoce:
a) r* =  + r r*
b) (r + s)* = (r* s*)*
c) (r + s) t = rt + st
10. Demuestre las siguientes equivalencias indicando las equivalencias usadas:

a) (1+0)(1*0)* = 1 + (1(1+0)* + (01*)*) 0
b) b (ab + ac) = (ba + ba) (b + c)
c) ( + 00)* ( + 00) 0 + 0 = 0 (00)*
11. Para la expresión regular 1* (0 + 1*) 0 construya el AFND- correspondiente. Usando

el algoritmo de búsqueda de strings verifique si los strings 101 y 010 pertenecen o no al
lenguaje regular correspondiente.
12. Suponga que a los operadores de expresión regular visto en clases se le agregan los
siguientes operadores:
- Si r es una e.r. entonces r? también es una e.r. que representa cero o una vez r.
- Si r es una e.r. entonces r% también es una e.r. que representa una o más veces r.
a) Demuestre que r? y r% pueden ser reconocidos cada uno por un AFND- M tal que
L(r?) = L(M) y L(r%) = L(M) respectivamente (como indicación siga el teorema
visto en clases).
31

b) Considere la e.r. siguiente que representa a los números reales con signo, que
empiezan con un dígito y tienen parte exponencial optativa como sigue, en que d
representa un dígito entre 0 y 9 y s al signo + o -:
r = s? d% (. d%)? (E s? d d)?
Construya el AFND- que reconoce a r.
13. Construir un AFND M que acepte el conjunto de todos los strings sobre el alfabeto
binario en que exista un substring de unos y ceros o de ceros y unos intercalados. A
partir del autómata obtenido describa una expresión regular r tal que L( r ) = L(M).
14. Sean  =  = {0,1,2}. Construya un autómata de Mealy de tres estados que implemente
la suma de enteros módulo 3, o sea: s(i,j) = (i + j) mod 3, 0  i,j  2. Suponga que el
output asociado al string de entrada w corresponde a la suma de los símbolos de w,
cuyo valor se entrega en el último símbolo del output.
15. Describa un autómata de Moore, en que los alfabetos de input y output sean {0,1}, y
que verifique las siguientes condiciones:
a) El string wL(M) ssi el output para w termina con un 1.

b) El string w posee la propiedad de que cada ocurrencia de un cero es seguida por
exactamente un uno o por un string de, al menos, dos unos consecutivos.
16. Describa un autómata de Mealy tal que acepte L = {0m10n / m,n  0, m par y n impar}.
17. El siguiente comportamiento de inputs-outputs corresponde a un autómata de Mealy

que se sabe que tiene 3 estados. Determine la función de transición y de output y
grafique el autómata correspondiente:
Input: aa aabaaa baaa ba

Output: 010100001010 01
18. El siguiente comportamiento de inputs-outputs corresponde a un autómata de Moore

con 4 estados. Determine la función de transición y de output y grafique el autómata
correspondiente.
Input: 0 1 0 1 1 1 1 1 0 0 0 1
Output: s s n n n s n n s s n s n
19. Para todos los autómatas con output anteriores (problemas 14 a 18) determine el
autómata con output equivalente.
20. Para los AFD obtenidos en el problema 8 determine los sistemas de ecuaciones
regulares lineales y resuélvalos para obtener el lenguaje regular asociado. Compare los
resultados con los del Teorema 2.4 y verifique las equivalencias cuando corresponda.
21. Resuelva el siguiente sistema de ecuaciones lineales:
X1 =  + 0X2 + 1X1
X2 = 1X2 + 1X3
X3 = 1X1 + 0X2 + 1X3
Más ejercicios hay en el apéndice 1.
32

3. Propiedades de los Lenguajes Regulares
3.1 Introducción
Lo que se analizará en este Capítulo es la existencia de lenguajes que no son

regulares y como determinar esta condición dado un lenguaje L. También se estudian
distintas propiedades de los lenguajes regulares, como son: determinar qué otras
combinaciones de conjuntos, aparte de la unión, concatenación y clausura, forman un
lenguaje regular. Finalmente se estudiará como determinar cuando un conjunto L dado es
vacío, finito o infinito, y como minimizar la cantidad de estados de un lenguaje regular.
3.2 Determinación de Lenguajes no Regulares
El resultado que se probará a continuación permite determinar cuando un conjunto

dado L no es un lenguaje regular (o sea aceptado por un autómata finito).
Lema Pumping (o Lema de Bombeo)
Sea L un lenguaje regular. Entonces existe una constante n  0 tal que si zL, con |z|  n,
se puede describir z como la concatenación de los strings uvw de modo que se verifique
que |uv|  n, |v|  1, y i  0 se verifica que uviwL. Además, n no es mayor que el
número de estados del más pequeño AFD que reconozca el lenguaje L.
Demostración. Sea L un lenguaje regular. Entonces existe un AFD M = (Q,,,q0,F) en

que Q posea n estados. Sea un input de n o más símbolos a1a2...am, m  n, y sea
(q0,a1a2...ai) = qi en que 1  i  m. Se verifica entonces que no es posible que los n+1
estados q0, q1,...,qn sean todos distintos, ya que hay solo n estados diferentes. Luego, deben
existir dos enteros j y k, 0  j < k  n, tales que qj = qk. El camino rotulado a1a2...am en el
diagrama de transición de M debe ser entonces:
aj+1...ak
q0 a1...aj qj = qk ak+1...am qm
Como j < k, se observa que el string aj+1...ak es de longitud a lo menos 1 t, como se

tiene que k  n, su longitud total no es mayor que n. Entonces, si qmF, o sea que el string
a1a2...amL(M), entonces a1a2...ajak+1ak+2...am también pertenece a L(M), ya que existe un
camino entre q0 y qm que pasa por qj pero no por el nudo rotulado por aj+1...ak.
Formalmente esto se deduce de:
(q0,a1a2...ajak+1...am) = ((q0,a1a2...aj),ak+1...am) = (qj,ak+1...am) = (qk,ak+1...am) = qm
También es posible recorrer el nudo más de una vez, con lo que el string
a1...aj(aj+1...ak)iak+1...am pertenece también a L(M), i  0, lo cual se deduce de:
(q0,a1a2...aj(aj+1...ak)iak+1...am) = ((q0,a1a2...aj),(aj+1...ak)iak+1...am)
= (qj,( aj+1...ak)iak+1...am) = ((qj,aj+1...ak),( aj+1...ak)i-1 aj+1...am) = (qk,(aj+1...ak)i-1 aj+1...am)
= (qj,(aj+1...ak)i-1 aj+1...am) =...= qm
Se ha probado entonces, que dado cualquier string suficientemente largo, que sea
aceptado por un AFD, siempre es posible hallar un substring que puede ser “bombeado”, o
sea repetido tantas veces como se quiera y el string resultante será aceptado por el AFD.
33


Ejemplo 1. Sea el lenguaje regular L dado por la expresión regular 0*1(0+1)*, aceptada por
el AFD siguiente:
1
q0 q1
0 0,1
Sea z = 01. Entonces se descompone z = uvw tal que u = , v = 0 y w = 1, y se

verifica que  i  0, uviw = 0i1 es un string de L.
Observación: se puede comprobar que el Lema de Bombeo propone lo siguiente:
(L regular)(n0)(zL, |z|  n)  (u,v,w)(z = uvw, |uv|  n, |v|  1, y i  0 uviwL)
Por lo tanto, para comprobar que un conjunto no es regular bastará con proponer
que lo es, imponer las condiciones del Lema y llegar a la contradicción de que existe un
valor de i  0 para el que uviwL, lo cual contradice la hipótesis de que el lenguaje era
regular.
Ejemplo 2. Sea el conjunto L = {ambm / m  1}. Probaremos que este conjunto no es

regular usando el Lema. Para ello supongamos que lo es y sean m el entero del Lema y z =
ambm el string de L considerado. Entonces podemos descomponer z = uvw tal que u = am-k,
v = ak, con k  1, y w = bm. Si evaluamos para i = 2, se obtiene el string uv2w = am-k a2k bm
= am+k bm, que no pertenece a L pues m + k > m, ya que k  1. Luego L no puede ser
regular.
i2
Ejemplo 3. Sea el conjunto L = { 0 / i  1}, o sea el conjunto de strings de ceros
concatenados, cuya longitud es un cuadrado perfecto. Probaremos que L no es regular.
Suponiendo que lo es, sean n  1 la constante del Lema y z = uvw el string considerado, tal
que |z| = n2. Entonces para i = 2 se verifica: n2 < |uv2w|  n2 + n < (n+1)2, por lo que el
largo del string uv2w no es un cuadrado perfecto, así que no pertenece a L, por lo que L no
es regular.
Ejemplo 4. Sea el conjunto L = {0m / m > 0 primo}. Probaremos que L no es regular.

Suponiendo que lo es, sean m > 0 la constante del Lema y z = 0m el string considerado, que
se descompone en uvw con u = 0a, v = 0b y w = 0c, con b  1 y tal que a + b + c = m.
Entonces, se considera el string uviw con i = a + b + c + 1 y se verifica que este string tiene
largo m(b + 1), el cual no es un número primo, por lo que no pertenece a L, y luego L no es
regular.
3.3 Propiedades de Clausura de los Lenguajes Regulares
Hay muchas operaciones sobre lenguajes que preservan los conjuntos regulares, en
el sentido que estas operaciones aplicadas a lenguajes regulares entregan como resultado
lenguajes regulares. Si una clase de lenguaje es cerrada bajo una operación, se llama a ésta
propiedad de clausura de esa clase de lenguaje.
Teorema 3.1 La clase de lenguajes regulares son cerrados bajo la unión, concatenación y
clausura de conjuntos.
Demostración. Inmediata de la definición de expresiones regulares.
34

Teorema 3.2 La clase de lenguajes regulares es cerrada bajo complementación de

conjuntos.
Demostración. Sea L el lenguaje regular y sea M = (Q,1,,q0,F) el AFD tal que se

verifica L(M) = L, con L  *. Si hay símbolos en 1 que no estén en , se puede borrar
todas las transiciones en M sobre símbolos en 1-. Como L  * entonces no se produce
cambio en el lenguaje aceptado por M. Si, al revés, hay símbolos en  que no estén en 1,
entonces ninguno de estos símbolos aparece en strings de L. Se agrega al autómata un
estado trampa p tal que (p,a) = p, a y (q,a) = p, qQ y a-1. Si  = 1, para
aceptar *-L, se complementan los estados finales de M, o sea que el autómata que
reconoce el complemento de L será M’ = (Q,,,q0,Q-F), en que M’ acepta un string w ssi
(q0,w)Q-F ssi w*-L ssi wL. Es esencial en esta demostración que M sea AFD y no
tenga movimientos vacíos.

Ejemplo 5. Sea el lenguaje L dado por r = a*b(a + b)* y cuyo autómata sobre 1 = {a,b}
es:
a q b p a,b
Al considerar L  * con  = {a,b,c}, se agrega un estado trampa al autómata,

como sigue:
a q b p a,b
c c
q’
a,b,c
Por último, el autómata que reconoce el complemento de L es el anterior, en que los

estados finales son q y q’, y p no es final.
Teorema 3.3 La clase de conjuntos regulares es cerrada bajo la intersección y la diferencia

de conjuntos.
Demostración. Usando los resultados de Teoría de Conjuntos, se sabe que si LC es el

complemento del conjunto L, entonces: LK = (LCKC)C. La clausura bajo la intersección
de lenguajes regulares se obtiene entonces a partir de los Teoremas 3.1 y 3.2 antes vistos.
Además, como L-K = LKC, entonces las clausura bajo la diferencia de lenguajes se
obtiene de la clausura bajo la intersección y la complementación de lenguajes.

Observación. Para determinar el AFD de la intersección de dos lenguajes regulares L1 y

L2, se puede usar la definición dada en Ejercicio 7 de los problemas del Capítulo 2, página
30.
3.4 Sustituciones y Homomorfismos
3.4.1 Sustituciones
35

Una sustitución es una función f definida entre un alfabeto  y la clausura de otro

alfabeto *, tal que a cada símbolo le asocia un lenguaje regular, o sea que si aL, con
L*, entonces f(a) = Ra es un conjunto regular asociado al símbolo a. La función f se
extiende a strings y lenguajes como sigue:
1) f() = 
2) f(wa) = f(w) f(a), w*, a
3) f(L) =  f(x)
xL
Se verifica además que:
4) f(L*) = f(L)*
5) f(L1L2) = f(L1)f(L2)
Ejemplo 6. Sea  = {0,1} y la sustitución: f(0) = a y f(1) = b*. Entonces para el string 010
se tiene f(010) = f(0)f(1)f(0) = ab*a, y para el lenguaje L = 0*(0 + 1)1* se verifica que la
sustitución f(L) = a*(a + b*)(b*)* = a*b*.
Teorema 3.4 La clase de lenguajes regulares es cerrada bajo sustitución.
Demostración. Sea L  * un conjunto regular y a sea La  * un conjunto regular.

Sea f:   * una sustitución definida por f(a) = Ra. Seleccionamos expresiones regulares
para denotar a L y a cada La, y reemplazamos cada ocurrencia del símbolo a en la
expresión regular de L por la expresión regular de La. Por las propiedades 2), 4) y 5) se ve
que la sustitución de una unión, concatenación o clausura de lenguajes regulares es la
unión, concatenación o clausura de la sustitución. Luego, usando una inducción simple
sobre el número de operadores en la expresión regular de L se completa esta demostración.

3.4.2 Homomorfismos
Un tipo de sustitución especial es el homomorfismo, el cual se define como una

función entre el alfabeto  y la clausura de  tal que a cada símbolo de  le asocia un
string de *. Se define en este caso la imagen homomórfica inversa de un lenguaje L por
un homomorfismo h como:
h-1(L) = {x / h(x)L}
Para un string w* se define además: h-1(w) = {x / h(x) = w}.
Ejemplo 7. Sea el homomorfismo sobre  = {0,1} definido por: h(0) = aa y h(1) = aba.
Entonces: h(010) = aaabaaa. Para lenguajes L1 = (01)*, L2 = (ab + ba)*a y L3 = a(b* + aa)a*,
se verifica que:
h(L1) = (aaaba)*
h-1(L2) = 1
h-1(L3) = (1 + 0)0*
El segundo resultado se obtiene de que el único string de * cuya imagen pertenece

a L2 es el 1. En el tercer caso, los strings de (1 + 0)0* verifican que su imagen por h
pertenece a L3.
Por último, se observa que h(h-1(L2)) = {aba}  L2. Se deduce que h(h-1(L))  L, y
análogamente, que L  h-1(h(L)), para cualquier lenguaje regular L.
36

Teorema 3.5 La clase de lenguajes regulares es cerrada bajo homomorfismos y

homomorfismos inversos.
Demostración. La clausura bajo homomorfismos es inmediata del hecho que estos son
sustituciones y de aplicar el Teorema 3.4. Para mostrar la clausura bajo homomorfismos
inversos, sea M = (Q,,,q0,F) un AFD reconozca el lenguaje regular L, y sea h:  * un
homomorfismo. Se construye un AFD M’ que reconozca h-1(L) de modo que lea un
símbolo a y simulando M sobre h(a). Formalmente sea M’ = (Q,,’,q0,F) en que se
define ’(q,a) = (q,h(a)), qQ, a. Se verifica que esta definición es correcta debido
a la extensión de la función de transición . Por inducción sobre el largo del string w, se
verifica que ’(q0,w) = (q0,h(w)), como sigue:
Base: Para w =  se tiene: ’(q0,) = q0 por extensión. Además, (q0,h()) = (q0,) = q0.
Luego se verifica que:
’(q0,) = (q0,h()) = q0
Inducción. Por hipótesis para strings w tales que 0 < |w|  n, se verifica la proposición, o
sea:
’(q0,w) = (q0,h(w))
Probaremos que para wa, con a, también se verifica.
’(q0,wa) = ’(’(q0,w),a) por extensión de ’
= ’((q0,h(w)),a) por hipótesis de inducción

= ((q0,h(w)),h(a)) por definición de ’
= (q0,h(w)h(a)) por extensión de 
= (q0,h(wa)) por definición de h(wa) = h(w)h(a)
Por lo anterior se verifica la proposición. Ahora probamos que L(M’) = h-1(L(M)).
wL(M’) ssi ’(q0,w)F ssi (q0,h(w))F ssi h(w)L(M)
De lo anterior se deduce que L(M’) = h-1(L(M)).


Ejemplo 8. La importancia de los homomorfismos y homomorfismos inversos está en la

posibilidad de usarlos en las demostraciones de que ciertos conjuntos no son regulares. Por
ejemplo, a partir de que el conjunto {0n1n / n  1} no es regular (probado por el Lema de
Bombeo), se demostrará que el conjunto {anban / n  1} no es regular. Para ello sean los
homomorfismos h1:{a,b,c}  {a,b}* y h2:{a,b,c}  {0,1}* definidos por:
h1(a) = a h2(a) = 0
h1(b) = ba h2(b) = 1
h1(c) = a h2(c) = 1
Entonces:
h2(h1-1({anban / n  1})a*bc*) = {0n1n / n  1}
El conjunto h1-1({anban / n  1}) está formado por los strings en (a+c)+b(a+c)* tales
que el número de símbolos que preceden a b es uno mayor que la cantidad de símbolos que
siguen a b. Luego:
h1-1({anban / n  1})a*bc* = {anbcn-1 / n  1}
37

Aplicando el homomorfismo h2 a este conjunto se obtiene {0n1n / n  1}. Si el

conjunto {anban / n  1} fuera regular entonces, por los Teoremas 3.3 y 3.5 se tendría que
el conjunto {0n1n / n  1} sería regular, lo cual no es cierto, luego {anban / n  1} no es un
conjunto regular.
3.5 Cuocientes de Lenguajes
Se define el cuociente de los lenguajes L1 y L2, que se anota L1/L2, como el

conjunto de strings:
L1/L2 = {x / yL2 tal que xyL1}
Ejemplo 9. Sean los lenguajes L1 = 0*10*, L2 = 10*1 y L3 = 0*1. Entonces se verifica que
L1/L2 = , pues no hay strings que puedan cumplir la condición. En cambio L2/L1 = 10*.
Además L1/L3 = 0* y L2/L3 = 10*.
Teorema 3.6 La clase de conjuntos regulares es cerrada bajo el cuociente con conjuntos
cualesquiera.
Demostración. Sea M = (Q,,,q0,F) un AFD que reconozca un lenguaje regular L y sea R

un conjunto arbitrario de strings de *. El AFD M’ = (Q,,,q0,F’) reconoce el cuociente
L/R, en que los estados finales de M’ son todos los estados de Q tales que exista un string
yR para el que (q,y)F. Entonces (q0,x)F’ ssi existe yR tal que (q0,xy)F. Luego,
se deduce que M’ reconoce L/R.
3.6 Algoritmos de Decisión para Lenguajes Regulares
El objetivo de esta parte es establecer algoritmos para decidir si: ¿Es un lenguaje
regular dado vacío, finito o infinito?, ¿Es un conjunto regular equivalente a otro?, ¿Existe
un número mínimo de estados para un AFD?, y otras consultas similares. Para el propósito
de responder a estas consultas se supondrá que los lenguajes regulares se representan por
AFD.
Teorema 3.7 Propiedad de ser vacío, finito o infinito.
El conjunto de strings aceptados por un AFD M con n estados es:
1) No vacío ssi el AFD acepta un string de largo menor que n.

2) Infinito ssi el AFD acepta algún string de largo l, en que n  l < 2n.
Demostración.
1) () Es obvio que si el AFD M acepta un string su lenguaje es no vacío.
() Supongamos que el AFD acepta un conjunto no vacío L. Sea z el string más corto
aceptado. Si |z| < n estamos listos. Si no es así, por el Lema Pumping existe un string z tal
que |z|  n, y tal que z = uvw, con |v|  1. Entonces i  0, uviwL. Pero entonces, para el
caso i = 0 se tendrá que uwL y este string es tal que |uw| < |z|, lo que contradice el que z
era el string más corto que pertenecía a L con largo mayor a n. Luego debe existir un string
de largo menor que n.
2) () Si zL(M) y n  |z| < 2n, entonces por el Lema Pumping, L(M) es infinito, pues
existe una descomposición z = uvw, con |v|  1 y tal que i 0 uviwL(M).
() Si L(M) es infinito, existe zL(M) tal que |z|  n. Si |z| < 2n estamos listos. Si no
es así para ningún string de L(M), sea z el string más corto de largo mayor o igual a 2n.
Por el Lema Pumping, z = uvw, con 1  |v|  n y tal que i  0, uviwL, luego
38

uwL(M). Ahora bien, o z no es el string más corto de largo mayor o igual a 2n (sería
uw) o bien n  |uw| < 2n, y en ambos casos hay una contradicción.

Teorema 3.8 Equivalencia entre Lenguajes Regulares
Existe un algoritmo para determinar si dos AFD aceptan o no el mismo lenguaje

regular (o sea si ellos son equivalentes).
Demostración. Sean M y N dos AFD que aceptan los lenguajes L y K respectivamente. De

la Teoría de Conjuntos se sabe que:
(L  KC)  (LC  K) =   L = K
Por los teoremas 3.1, 3.2 y 3.3, sabemos que el conjunto (L  KC)  (LC  K) es
un lenguaje regular. Por teorema 3.7, se ve que existe un algoritmo para saber si este
lenguaje es vacío, con lo cual se comprueba que existe un algoritmo para comprobar si L y
K son equivalentes.

3.7 Minimización de estados de un AFD
Se desea comprobar que a cualquier AFD que reconoce un lenguaje regular, se le

puede aplicar un algoritmo que minimice la cantidad de estados de él.
Para ello sean las siguientes relaciones:
1) Sobre un lenguaje L  *: x,y* xRLy  z* xzL ssi yzL
2) Sobre un AFD M = (Q,,,q0,F): x,y* xRMy  (q0,x) = (q0,y)
Se puede probar que ambas son relaciones de equivalencia. Una relación de

equivalencia R se dice invariante a la derecha si z* xRy  xzRyz. Por ejemplo, RM y
RL son ambas invariantes a la derecha pues:
a) Si xRMy entonces: (q0,xz) = ((q0,x),z) = ((q0,y),z) = (q0,yz), luego xzRMyz.
b) Si xRLy entonces, si w* se debe probar que xwRLyw. Pero, por definición de RL se
tiene que v* xvL ssi yvL. Si v = wz se obtiene que: xwzL ssi ywzL, con lo
cual se prueba que xwRLyw.
Por último, se llama índice de una relación de equivalencia a la cantidad de clases de

equivalencia distintas producidas por la relación.
Teorema 3.9 (Teorema de Myhill – Nerode)
Las siguientes tres proposiciones son equivalentes:
a) El conjunto L  * es aceptado por algún AFD.
b) L es la unión de algunas de las clases de equivalencia de una relación de equivalencia

invariante a la derecha y de índice finito.
c) La relación de equivalencia RL definida anteriormente es de índice finito.
Demostración.
Probamos que (a)  (b).
39

Supongamos que L es aceptado por algún AFD M = (Q,,,q0,F) y sea RM la

relación de equivalencia asociada a M. Se probó que RM era invariante a la derecha. Su
índice es finito pues a lo más puede ser la cantidad de estados de Q. Por último se ve que L
es la unión de las clases de equivalencia de RM asociadas a los estados finales del
autómata, o sea:
L=  {x / (q0,x)F}
x *
Probamos que (b)  (c).

Sea E una relación de equivalencia invariante a la derecha y de índice finito que
verifica (b). Probaremos que E es un refinamiento de RL, o sea, que cada clase de
equivalencia de E está incluida en alguna clase de equivalencia de RL. Supongamos que
xEy. Entonces, como E es invariante a la derecha: z* se tiene que xzEyz. Luego, como
L es la unión de algunas clases de equivalencia de E, se tendrá que xzL ssi yzL, luego
xRLy, y luego la clase de equivalencia de x por E está incluida en la clase de equivalencia
de x por RL. Por lo tanto, el índice de RL no puede ser mayor que el de E, luego es finito.
Probamos que (c)  (a).

Sea el AFD M’ = (Q’,,’,q0’,F’) tal que:
Q’ = {clases de equivalencia de x por RL / x*}

q0’ = []
’([x],a) = [xa]
F’ = {[x] / xL}
Se observa que la cantidad de estados de Q’ es finita pues el índice de R L es finito.
Se prueba entonces, por inducción sobre |w|, que ’(q0’,w) = [w] como sigue:
Base. Sea w = . Entonces ’(q0’,) = q0’ = [].
Inducción. Sea válido el resultado para strings w con 0 < |w|  n. Se prueba para strings
wa, con a.
’(q0’,wa) = ’(’(q0’,w),a) = ’([w],a) = [wa]
Luego se verifica.
Por último: wL(M’) ssi ’(q0’,w)F’ ssi [w]F’ ssi wL, con lo que L(M’) = L,
o sea este AFD acepta los strings de L por lo que L(M’) es equivalente a L.

Ejemplo 10. Sea L = 0*10* aceptado por el siguiente AFD:
0
q0 q1
0
1 1
q2 q3
0
0 1 1
q4 1 q5 0,1
Para la relación RM se tienen seis clases de equivalencia dadas por:
40

[q0] = (00)*
[q1] = (00)*0
[q2] = (00)*1
[q3] = (00)*01
[q4] = 0*100*
[q5] = 0*10*1(0 + 1)*
Luego L = [q2]  [q3]  [q4] = 0*10*. Ahora bien, la relación RL tiene tres clases
de equivalencia posibles para este lenguaje:
a) Cada x e y en la relación no tienen ningún uno, o sea C1 = 0*.

b) Cada x e y en la relación tienen un solo uno, o sea C2 = 0*10*.
c) Cada x e y en la relación tienen más de un uno, o sea C3 = 0*10*1(0 + 1)*.
En este caso el lenguaje L consiste de una sola de estas clases, la cual es C2. La
relación entre las clases de RM y RL, a partir de la cual se observa que RM es un
refinamiento de RL, se obtiene a partir de:
C1 = [q0]  [q1] = (00)* + (00)*0 = 0*

C2 = [q2]  [q3]  [q4] = 0*10*
C3 = [q5] = 0*10*1(0 + 1)*
A partir de RL se construye el AFD mencionado en el Teorema 3.9 como se definió allí,

o sea: sean ,1 y 11, los strings representantes de las clases de equivalencia C1, C2, y C3.
Entonces se tiene:
Q’ = {[], [1], [11]}

F’ = {[1]}
’([x],a) = [xa], la cual queda definida como sigue y el AFD es:
’ 0 1
[] [] [1]
[1] [1] [11]
[11] [11] [11]
0 0 0,1
1 1
[] [1] [11]
Teorema 3.10 Minimización de estados.
El AFD con la menor cantidad de estados que acepta un conjunto regular L es único
y está dado por el AFD M’ de la demostración del Teorema 3.9.
Demostración. En la demostración del Teorema 3.9 se vió que cualquier AFD M que
acepta el lenguaje L define una relación de equivalencia que es un refinamiento de RL.
Luego, la cantidad de estados de M es mayor o igual a la cantidad de estados de M’. Si esta
cantidad es igual, entonces cada estado de M se identifica con alguno de los estados de M’.
O sea, si qQ, debe existir x* tal que (q0,x) = q (sino q puede ser removido de Q y
habría un AFD con menos estados). Se identifica q con ’(q0’,x)Q’. Si (q0,x) = (q0,y) =
q entonces xRLy, luego ’(q0’,x) = ’(q0’,y).

41

Observación: Sean M = (Q,,,q0,F) el AFD con L(M) = L, y M’ = (Q’,,’,q0’,F’) el

AFD del Teorema 3.9. Se define la relación:
p,qQ p  q  x* (p,x)F ssi (q,x)F
Se puede comprobar fácilmente que esta es una relación de equivalencia. Se prueba

además que los estados de M’ pueden identificarse con las clases de equivalencia de . Si
p  q, se dirá que p es equivalente a q. Se dirá que p es distinguible de q si existe x* tal
que (p,x)F y (q,x)F, o viceversa. El algoritmo que permite marcar pares de estados
distinguibles es:
begin
for(pF y qQ-F)
marcar (p,q);
for((p,q)FF o (p,q)(Q-F)(Q-F), p  q)
if(a tal que ((p,a),(q,a)) está marcado)
begin
marcar (p,q);
marcar recursivamente todos los pares no marcados sobre la lista
para (p,q) y de las listas de otros pares que se marcan en este paso;
end
else /* ningún par ((p,a),(q,a)) es marcado */
for(a)
ubicar (p,q) en la lista para ((p,a),(q,a)) salvo que (p,a) = (q,a);
end
Observación. Este algoritmo es O(kn2), en que n es la cantidad de estados de Q y k una

constante positiva.
Teorema 3.11 AFD de estados mínimos.
El AFD construido a partir del algoritmo anterior, habiendo removido los estados
inaccesibles, es el AFD con mínima cantidad de estados que reconoce el lenguaje.
Demostración. Sea M = (Q,,,q0,F) el AFD tal que L(M) = L y M’ = (Q’,,’,[q0],F’) el

AFD construido considerando:
Q’ = {[q] / q es accesible desde q0}

F’ = {[q] / qF}
’[q],a) = [(q,a)]
La función de transición ’ está bien definida puesto que p  q ssi (p,a)  (q,a).
Por inducción sobre |w| se muestra que ’[q0],w) = [(q0,w)] así como que L(M’) = L(M)
(ver Ejercicio 2 Capítulo anterior). Por último, es fácil comprobar, usando contradicción,
que la cantidad de estados de M’ es igual al índice de R L, por lo que M’ es el AFD de
menor cantidad de estados que acepta a L.

Ejemplo 11. Aplique el algoritmo anterior al AFD del Ejemplo 10.
Se construye la siguiente tabla, en que solo se considera la relación entre los

estados de la parte inferior de la tabla:
q1
q2 X X
q3 X X
42

q4 X X
q5 X X X X X
q0 q1 q2 q3 q4
Se observa entonces que los pares de estados (q0,q1), (q2,q3), (q2,q4) y (q3,q4) no son
marcados en la tabla, por lo que se obtiene que son equivalentes: q0  q1 y q2  q3  q4.
Luego el AFD de mínima cantidad de estados es el siguiente, en que Q’ = {[q0,q1],
[q2,q3,q4], [q5]}, el estado inicial es q0’ = [q0,q1] y los estados finales son F’ = {[q2,q3,q4]}:
0 0 0,1
1 1
[q0,q1] [q2,q3,q4] [q5]
1. Demuestre, usando el Lema de Bombeo, que los siguientes conjuntos no son regulares:
a) El conjunto de strings binarios con igual cantidad de ceros y unos.

b) L = {ww / w*}
c) L = {(k )k / k  1}
d) L = {ambnam+n / m,n > 0}
2. Sea L un conjunto regular sobre el alfabeto {0,1}. Se define la derivada de L respecto

al string x como el conjunto siguiente: Lx = {y / xyL}.
a) Para L = 01* + 100* determine: L0, L1, L10, L00, L01 y L11.
b) Demuestre que los conjuntos regulares son cerrados para la operación derivada.
3. Sean los homomorfismos h y k dados por:
h(a) = a k(a) = 0
h(b) = b k(b) = 0
h(c) = a k(c) = 1
Demuestre que el conjunto L = {ambnam+n / m,n > 0} no es regular, haciendo uso de los
homomorfismos anteriores y las relaciones entre conjuntos regulares conocidas por Ud.
4. Para los siguientes AFD’s asociados a los lenguajes L1 y L2 determinen el AFD de los
lenguajes: L1  L2, L1 – L2 y del complemento de L2 – L1, describiendo gráficamente
los autómatas intermedios.
Para L1 con F = {q1} la función de transición es:
1 0 1
q0 q1 q0
q1 q1 q2
q2 q2 q1
Para L2 con F = {q0,q2} la función de transición es:
2 0 1
43

q0 q0 q1
q1 q1 q2
q2 q2 q2
5. Para el siguiente AFD, con F = {b,e}, estado inicial a y función de transición siguiente,
minimice el número de estados del autómata, informando de la tabla de estados
distinguibles y equivalentes y del autómata equivalente resultante:
 0 1
a b d
b c e
c c b
d e a
e f e
f c e
6. Lo mismo anterior para el AFD siguiente, con F = {d,i} y la función de transición

siguiente:
 0 1
a b c
b f d
c d e
d d i
e d h
f g d
g i d
h d i
i d i
7. Sea h el homomorfismo h(a) = 01, h(b) = 0. Determine:
a) h-1(L1) para L1 = (10 + 1)*.

b) h(L2) para L2 = (a + b)*.
c) h-1(L3) en que L3 es el conjunto de todos los strings de ceros y unos con igual cantidad
de ceros y unos.
d) h-1(L4) para L4 = 0*(1 + 0).
8. Usando el Lema de Bombeo demuestre que los siguientes conjuntos no son regulares:
a) L1 = {0m / m = n! , n > 0}
b) L2 = {xyxr / x,y  (0+1)+}
c) L3 = {anb2kan / n,k  0}
9. Sea  = {a,b}. Pruebe que L = {wwr / w*} no es un conjunto regular, usando

intersección con conjuntos regulares y el resultado del problema 8 c).
10. Sea  = {a,b}. Demuestre que L = {x*/ x = xr} no es un conjunto regular usando el
Lema Pumping.
11. Verifique que el conjunto L = {am / m = 2n, n  0} no es un conjunto regular.
12. Construya los AFD asociados a las expresiones regulares a*b y b*a. A partir de estos
AFD construya los AFD de * - a*b y * - b*a. Luego construya el AFD de la unión de
los dos autómatas anteriores y deduzca el AFD del lenguaje a*b  b*a.
44

4. Gramáticas de Libre Contexto
4.1 Introducción
Se estudiarán en este Capítulo las gramáticas libres del contexto, las cuales son uno de
los cuatro tipos posibles de gramáticas. En lo que sigue se define una gramática y se
revisan los distintos tipos existentes, para luego centrarnos en la caracterización de las
gramáticas de libre contexto, hasta alcanzar una normalización en la presentación de sus
producciones.
4.2 Definición y Tipos de Gramáticas
4.2.1 Definición de Gramática y Ejemplos
Se define una gramática formal como la cuatro tupla G = (N,T,P,) en que:
- N es un conjunto símbolos llamados “no terminales” o variables de la gramática,

denotados por letras mayúsculas.
- T es el alfabeto del input, formado por “símbolos terminales” de la gramática, y
denotados por las primeras letras minúsculas del alfabeto español.
- P es el conjunto de reglas gramaticales, llamados “producciones”.
- N es el símbolo de partida o “raíz” de la gramática.
Se verifica que N y T son disjuntos, o sea NT = . Las producciones de P se definen

como el par ordenado (,) tal que:  = A y  =   , en las que ,  y  son strings,
posiblemente vacíos, de (NT)* y A es  o una variable de N. Más comúnmente, una
producción se escribe como   , o sea  produce . La sucesión de formas sentenciales
(strings de símbolos terminales y no terminales) generan una sentencia del lenguaje (string
de símbolos terminales solamente) construyendo una derivación de la sentencia de acuerdo
a la gramática. Formalmente, un string de símbolos de (NT)* se conoce como forma
sentencial.
Si    es una producción de G, y  =    y ’ =    son formas sentenciales,

decimos que ’ es inmediatamente derivado en G, relación que se indica por   ’.
Si 1, 2,..., n es una sucesión de formas sentenciales, tales que 1  2 ... n,

se dice que n es derivable desde 1, e indicamos esta relación por 1  n. La sucesión
1, 2,..., n se llama una derivación de n desde 1 de acuerdo a la gramática G.
El lenguaje generado por una gramática formal G = (N,T,P,), denotado por L(G), es el
conjunto de strings de símbolos terminales derivables desde , definido formalmente como
sigue:

L(G) = {T* /   }
Si L(G) decimos que  es un string, una sentencia o una palabra en el lenguaje

generado por la gramática G.
Si A  1 | 2 |...| k son las producciones de la variable A, la línea vertical se lee

como “o”.
45

Ejemplo 1. Para las siguientes gramáticas determine el lenguaje aceptado y una derivación
de los strings más cortos de éstos.
a) Sea G1 = ({A,B,C}, {a,b,c}, P1, ), en que P1 es:

A
A  aABC | abC
CB  BC
bB  bb
bC  bc
cC  cc
Luego:
  A  abC  abc
  A  aABC  aabCBC  aabBCC  aabbCC  aabbcC  aabbcc
Por lo anterior, el lenguaje aceptado es L(G1) = {ak bk ck / k > 0}.
b) Sea G2 = ({A,B,C}, {a,b}, P2, ) en que P2 es:
A
A  aABC | abC
CB  BC
bB  bb
bC  b
  A  abC  ab
  A  aABC  aabCBC  aabBCC  aabbCC  aabbC  aabb
Por lo anterior, el lenguaje aceptado es L(G2) = {ak bk / k > 0}.
c) Sea G3 = ({}, {a,b}, P3, ) en que P3 es:

  ab | ab
Entonces:
  ab
  ab  aabb
  ab  aabb  aaabbb
  ab  aabb ...(n-1 veces)... ak-1bk-1  ak bk
Por lo anterior, el lenguaje aceptado es L(G3) = {ak bk / k > 0}.
Observación: no existe un procedimiento general para determinar qué gramáticas generan

el mismo lenguaje, como ocurre en el caso de G2 y G3.
4.2.2 Tipos de Gramáticas
Restringiendo la forma de las producciones permitida a una gramática, se pueden

especificar cuatro tipos de ellas y sus correspondientes clases de lenguajes.
4.2.2.1 Gramáticas No Restringidas (tipo 0)
Son aquellas que producen formas sentenciales más cortas en su longitud, es decir,
si wi  wi+1 entonces |wi+1| < |wi|. Tales producciones se conocen como “producciones
contractantes”. Toda gramática que contiene al menos una producción contractante se dice
que es gramática contractante. Sólo las gramáticas tipo 0 pueden ser contractantes. Se
46

verifica que en una producción del tipo A  w, w puede ser  o sea el string vacío.
El ejemplo 1 b) muestra una gramática tipo 0.
4.2.2.2 Gramáticas de Contexto Sensitivo (tipo 1)
Son aquellas en que las producciones son del tipo A  w en que w  . La
gramática puede contener la producción   . Si G es una gramática tipo 1, entonces
L(G) es un lenguaje tipo 1 o de contexto sensitivo. En este caso, si w1  w2  ...  wn
entonces |w1|  |w2|  ...  |wn|, luego se dice que sus producciones son no contractantes. El
ejemplo 1 a) muestra una gramática tipo 1.
4.2.2.3 Gramáticas de Libre Contexto (tipo 2)
Es una gramática formal en la que todas sus producciones son de la forma A  w,

donde A es una variable y w un string de terminales y/o variables (menos el string vacío).
Esta gramática puede contener la producción   . Si G es u, na gramática tipo 2
entonces se dice que L(G) es un lenguaje de libre contexto o de tipo 2. El ejemplo 1 c)
muestra una gramática tipo 2. Las gramáticas tipo 2 son especialmente apropiadas para
definir lenguajes artificiales, en especial lenguajes de programación.
4.2.2.4 Gramáticas Regulares (tipo 3)
Es una subclase de las gramáticas tipo 2, en las que el lado derecho de una producción
puede contener a lo más un único símbolo no terminal y exactamente un símbolo terminal.
Su definición formal es: G = (N,T,P,), en que si AN{}, BN y aT, entonces:
- una producción de la forma A  aB | a se llama lineal a la derecha.

- una producción de la forma A Ba | a se llama lineal a la izquierda.
Si una gramática contiene sólo producciones lineales a la derecha se llama Gramática

Lineal a la Derecha. Si una gramática contiene sólo producciones lineales a la izquierda se
llama Gramática Lineal a la Izquierda.
Estas gramáticas se llaman regulares, luego el lenguaje asociado L(G) se dice regular o
de tipo 3.
Ejemplo 2. Sean G1 = (N,T,P1,) y G2 = (N,T,P2,) las siguientes gramáticas:
P1 corresponde a las siguientes producciones lineales a la derecha:
  1B | 1
B  0A
A  1B | 1
P2 corresponde a las siguientes producciones lineales a la izquierda:
  B1 | 1
B  A0
A  B1 | 1
Se prueba que L(G1) = (10)*1 y que L(G2) = 1(01)*, luego son gramáticas
equivalentes.
Un resumen de los tipos de gramáticas se tiene en el siguiente cuadro comparativo

que asocia los distintos tipos con el formato de sus producciones:
47

Tipo Formato Producciones Observaciones

0 A  w (w puede ser ) Contractante
1 A  w (w  ),  Contexto Sensitivo
2 A  w (w  ),  Libre Contexto
3 A  aB | a (lineal a la derecha) Regulares
A  Ba | a (lineal a la izquierda)
Ejercicios Propuestos
1. Para las siguientes gramáticas describa los lenguajes aceptados L(Gi), indique todas las
inclusiones posibles entre estos lenguajes, y describa una derivación de un string de
largo al menos cuatro usando las producciones y un árbol de derivación.
a) G1 dado por:
|S
S  SS | c
b) G2 dado por:
|S
S  cSd | cd
c) G3 dado por:
|S
S  Sd | cS | c | d
d) G4 dado por:
  cS
S  cS | Td | d
T  Td | d
e) G5 dado por:
   | S | ScS
Sc
2. Escriba una gramática que genere el lenguaje L(G) = {0m1n / m > n  0}
3. Escriba una gramática lineal a la izquierda que reconozca el lenguaje (10)*.
4. Se dice que una gramática es ambigua si ella genera algún string por dos o más
derivaciones distintas. Verifique que las siguientes gramáticas, que permiten definir
expresiones aritméticas, son ambiguas:
a) G1 dado por:
 S
S  SAS | a | b
A+|-
b) G2 dado por:
S+S|S–S
S a|b
c) G3 dado por:
  if E then  else  | if E then  | c
48

4.3 Gramáticas de Libre Contexto
4.3.1 Introducción y Definiciones
Una gramática de libre contexto, como se definió anteriormente, es un conjunto finito

de variables, relacionadas por reglas llamadas producciones, y cuyos lenguajes aceptados
se describen recursivamente en términos de símbolos primitivos llamados terminales, que
pertenecen a algún alfabeto. Formalmente, una g.l.c. se denota por la cuatro tupla G =
(N,T,P,), en que N es el conjunto de variables, T es el alfabeto (N y T son disjuntos), P es
un conjunto finito de producciones y  es el símbolo de partida de G. Las producciones de
P son de la forma: A  , en que AN y (NT)+. Si el string vacío pertenece al
lenguaje aceptado por la g.l.c. entonces se agrega la producción    al conjunto de
producciones P.
Por convención se define que:
1) Las letras mayúsculas A, B, C, D, E y  denotan variables.

2) Las letras minúsculas a, b, c, d, e, dígitos y strings de estos son terminales.
3) Las letras mayúsculas X, Y, Z denotan símbolos que pueden ser terminales o variables.
4) Las letras minúsculas u, v, w, x, y, z denotan strings de símbolos terminales.
5) Las letras minúsculas griegas , , y  denotan strings de variables y terminales.
Usando las convenciones anteriores, podemos deducir las variables y terminales de una
gramática, solo examinando sus producciones. Entonces se presentará una gramática
listando sus producciones (ver ejemplo 1 c) anterior y los ejercicios propuestos).
Se definen las siguientes dos relaciones entre strings de (NT)+. Si A   es una

producción de P y ,  son strings cualesquiera de (NT)+ entonces: A  , o sea
que la producción anterior aplicada al string A permite derivar  en la gramática G.
Luego, dos strings están relacionados por el símbolo  exactamente cuando el segundo se
obtiene del primero por una aplicación de alguna producción. Supongamos que se tienen
los strings 1, 2, ..., m, con m > 0, y que: 1  2, 2 3, ... , m-1  m. Entonces se
dice que 1 produce m en la gramática G a través de una cierta cantidad de derivaciones
usando producciones de G, lo que se representa por 1 * m, lo cual corresponde a la
clausura reflexiva y transitiva del operador . Si  se deriva del string  en exactamente i
pasos, se anota que  i .
El lenguaje generado por G es el conjunto L(G) = {wT* /  * w}, o sea que un

string está en L(G) si se verifica que está formado por símbolos terminales y que puede ser
derivado a partir de . Llamamos a L lenguaje de libre contexto (l.l.c.) si éste es L(G) para
alguna g.l.c. G dada. Un string de terminales y variables  se llama forma sentencial si es
derivable a partir del símbolo . Dos gramáticas G1 y G2 se dicen equivalentes si L(G1) es
igual a L(G2).
En este Capítulo se estudiarán las g.l.c. desde el punto de vista de la simplificación de

sus producciones, eliminando los símbolos inútiles que en ella aparecen, así como sacando
las producciones vacías (que producen el string vacío) y las unitarias (producciones que
derivan una variable a partir de otra). Finalmente se verán dos tipos de normalizaciones
para las producciones, llamadas de Chomsky y de Greibach.
4.3.2 Simplificación de g.l.c.
Hay varias maneras de restringir el formato de las producciones sin reducir el poder
generativo de las g.l.c. Si L es un l.l.c. no vacío, entonces este lenguaje puede generarse
por una g.l.c. que tenga las siguientes propiedades:
49

1. Cada variable y cada símbolo terminal de la gramática aparece en la derivación de

algún string de L.
2. No hay producciones unitarias ni vacías, o sea producciones de la forma A  B y

A  . Si L sólo se acepta la producción    como parte de las producciones
de la g.l.c.
4.3.2.1 Eliminación de Símbolos Inútiles
Se dice que un símbolo X de la gramática G = (N,T,P,) es útil si existe una

derivación del siguiente tipo:  tal que  * X *  en que T*. Si no es así el
símbolo X es inútil. Se observa que para ser útil entonces X debe producir algún string
terminal y, a la vez, X debe ser derivable desde la raíz  de la g.l.c.
Sin embargo, estas dos condiciones no son suficientes para garantizar que X es útil, ya
que podría ocurrir que X aparezca en formas sentenciales que, tal vez, contengan alguna
otra variable inútil, con lo que X pasa a ser inútil.
Ejemplo 3. Sea  * Z y la producción Z  XY. Si X *  pero desde Y no se

deriva ningún string en T* entonces X es un símbolo inútil.
Lema 4.1 Dada una g.l.c. G = (N,T,P,) , tal que L(G) , se puede determinar una g.l.c.
equivalente G’ = (N’,T,P’,) tal que AN’ exista algún T* tal que A * .
Demostración. Cada variable AN tal que A  , claramente está en N’. Si se tiene la
producción A  X1X2...Xn, en que cada Xi es, o una variable de N’ o un símbolo terminal,
entonces se puede derivar un string terminal desde A y luego AN’. P’ es el conjunto de
todas las producciones cuyos símbolos están en N’T. Para determinar N’ se usa el
siguiente algoritmo iterativo:
begin
OLDN = ;
NEWN = {A / A   para algún T*};
while OLDN  NEWN do
{ OLDN = NEWN;
NEWN = OLDN  {A / A   para algún (T  OLDN)*};
}
N’ = NEWN;
end
Se puede demostrar por inducción sobre el largo de la derivación que si A *  para

algún T*, entonces A se agrega a NEWN en el algoritmo anterior (hacerlo como
ejercicio). Sea N’ el conjunto obtenido por el algoritmo anterior y P’ el conjunto de todas
las producciones cuyos símbolos están en N’T. Entonces G’ = (N’,T,P’,) satisface que
si AN’ entonces A *  para algún T*. Entonces, si existe L(G) tal que no esté
en L(G’) quiere decir que toda derivación de  en G debe considerar alguna variable del
conjunto N-N’ o una producción de P-P’ (lo que implica que existe una variable en N-N’
usada). Pero entonces existe una variable en N-N’ que deriva un string terminal, lo cual es
una contradicción. Luego L(G) = L(G’).

Lema 4.2 Dada una g.l.c. G = (N,T,P,), se puede determinar una g.l.c. G’ = (N’,T’,P’,)
equivalente tal que se verifique que X(N’T’) existan , en (N’T’) tal que se tenga
 * X.
50

Demostración. Para determinar los conjuntos N’ y T’ se usa el siguiente algoritmo.

Primero se ubica  en N’. Luego, si A pertenece a N’ y A  1| 2 |...| n, entonces se
agregan todas las variables de 1, 2,..., n al conjunto N’ y todos los terminales de estas
formas sentenciales a T’. Finalmente P’ es el conjunto de producciones de P que contienen
sólo símbolos de N’T’.

Observación: para eliminar los símbolos inútiles de una gramática se deben aplicar los
Lemas 4.1 y 4.2 en ese orden. Si se altera el orden se puede fallar en eliminar todos los
símbolos inútiles como en el siguiente ejemplo:
Ejemplo 4. Sea la g.l.c. dada por las producciones:
  AC | BC | a | b
A  Aa | a
B  Bb | b
C  AC | BC
Por Lema 4.2 se tiene que N’ = {, A, B, C} y T’ = {a, b}. Luego, al aplicar Lema 4.1
se tiene que N’ = {, A, B} y T’ = {a, b}. Luego, las producciones son:
  AC | BC | a | b
A  Aa | a
B  Bb | b
Por lo que quedan dos variables inútiles que son A y B. Inversamente, al aplicar
primero Lema 4.1 se obtiene: N’ = {, A, B} y T’ = {a, b}. Luego, al aplicar Lema 4.2 se
obtiene que N’ = {} y T’ = {a, b}, quedando las producciones:   a | b, que es la g.l.c.
sin símbolos inútiles equivalente.
Teorema 4.1 Todo l.l.c. no vacío es generado por una g.l.c. sin símbolos inútiles.
Demostración. Sea L = L(G) un l.l.c. no vacío. Sea G1 el resultado de aplicar el Lema 4.1
a G y sea G2 el resultado de aplicar el Lema 4.2 a G1. Supongamos que G2 tiene un
símbolo inútil X. Por Lema 4.2 existe en G2 una derivación  * X. Dado que todos
los símbolos de G2 son símbolos de G1, se sigue del Lema 4.1 que  * X * w, para
wT*. Además, ningún símbolo en la derivación en G1 dada por X * w es eliminado
por Lema 4.2. Luego, X deriva un string terminal en G2 lo que contradice la suposición de
que X era un símbolo inútil.

4.3.2.2 Eliminación de Producciones Vacías
Las producciones vacías son de la forma A  , que también se llaman producciones-

. Si L(G), no podemos eliminar todas las producciones- de G, ya que debe quedar la
producción   , la cual no es considerada de este tipo para efectos del lenguaje
generado por G. Por lo tanto, para eliminar este tipo de producciones se considerará
lenguajes que no contengan el string vacío. El método comienza determinando cuando una
producción es vacía (o anulable). Una producción A  X1X2 ... Xn es anulable si todos los
símbolos no terminales Xi son anulables. En este caso se reemplaza esta producción por
todas las producciones que se pueden obtener eliminando algún subconjunto de todas las
Xi pero sin llegar a producir A  , aunque todas las Xi fueran anulables.
Teorema 4.2 Si L = L(G) para alguna g.l.c. G = (N,T,P,) entonces L – {} = L(G’) para
alguna g.l.c. G’ con ningún símbolo inútil o producción vacía.
51

Demostración. Los símbolos no terminales de G que son anulables se pueden determinar

usando el siguiente algoritmo iterativo. Si A   es una producción entonces A es
anulable. Si B   es una producción y todos los símbolos no terminales de  son
anulables, entonces B es anulable. Se repite este proceso hasta que no haya más símbolos
anulables.
El conjunto de producciones P’ se construye como sigue. Si A  X1X2...Xn está en P,

entonces se agregan a P’ todas las producciones de la forma A  12 ...n donde:
i) Si Xi no es anulable entonces i = Xi.
ii) Si Xi es anulable, entonces i es Xi o el string vacío.
iii) No todos los Xi son .
Sea G” = (N,T,P’,). Se demuestra, por inducción sobre el largo de la derivación

(propuesto al lector), que:
AN, wT* A *w en G  w y A * w en G”
Finalmente, aplicando el lema 4.2 a G” se deduce la g.l.c. G’ propuesta en este

Teorema y se comprueba que L(G’) = L(G) – {}.
Ejemplo 5. Sea la gramática G siguiente. Determine la gramática G’ sin producciones

vacías equivalente.
  ABC
Af
B  DEF
C  GH
Da|
Eb|
Fc|
Gd
He
1) Los símbolos anulables son: D, E, F y B.

2) La producción   ABC contiene a B como símbolo anulable, luego se producen las
producciones   ABC | AC.
3) La producción B  DEF contiene a D, E y F como símbolos anulables, luego se
producen a partir de ella: B  DEF | DE | DF | EF | D | E | F.
4) Las demás producciones quedan igual. No hay símbolos inútiles.
Finalmente, la gramática G’ queda como sigue:
  ABC | AC
Af
B  DEF | DE | DF | EF | D | E | F
C  GH
Da
Eb
Fc
Gd
He
4.3.2.3 Eliminación de Producciones Unitarias
Las producciones unitarias son del tipo A  B, en que el lado derecho consiste de una sola
variable. Las producciones del tipo A  a, A  , u otras distintas, no son unitarias.
52

Teorema 4.3 Todo l.l.c. que no incluya al string vacío está definido por una g.l.c. sin
símbolos inútiles, producciones vacías y producciones unitarias.
Demostración. Si la g.l.c. contiene una producción unitaria del tipo A  B, y se tiene que
las producciones de B son del tipo B * 1|2|...|k (con |i| > 1) entonces se reemplaza la
producción A  B por las producciones A  1|2|...|k. Finalmente se aplican los
Teoremas 4.1 y 4.2 para determinar la g.l.c. sin símbolos inútiles ni producciones vacías
equivalente.

Observación. Al simplificar una g.l.c. se deben ejecutar los siguientes pasos en el orden
dado:
i) Quitar las producciones vacías (si las hay).
ii) Quitar las producciones unitarias (si las hay).
iii) Quitar los símbolos inútiles (si los hay) usando los Lemas 4.1 y 4.2 en ese orden.
Ejemplo 6. Simplifique las producciones de la siguiente gramática:
A|B
A  B | C | aB | b
BC
C  B | Aa
1) No hay producciones vacías.

2) Las producciones no unitarias, que son: A  aB | b y C  Aa se ubican en el nuevo
conjunto de producciones P’.
3) Se analizan las producciones unitarias presentes y se reemplazan por las producciones
no unitarias derivadas:   A se reemplaza por   aB | b.   B no se reemplaza
por el momento. A  B no se reemplaza por el momento. A  C se reemplaza por la
producción A  Aa. B  C se reemplaza por B  Aa. Luego,   B y A  B se
reemplazan por   Aa y A  Aa (está agregada anteriormente a P’). Finalmente se
tiene:
  aB | b | Aa
A  aB | b | Aa
B  Aa
C  Aa
Finalmente, aplicando los Lemas 4.1 y 4.2 se deduce que C es un símbolo inútil por lo
que es eliminado y la g.l.c. sin producciones unitarias ni símbolos inútiles es:
  aB | b | Aa
A  aB | b | Aa
B  Aa
4.4 Forma Normal de Chomsky
Se trata de modificar las producciones de una gramática de libre contexto de modo que
queden todas normalizadas según A  BC | a. Las g.l.c. que verifiquen estas condiciones
se dirán en FNC (Forma Normal de Chomsky).
Teorema 4.4 Forma Normal de Chomsky (FNC)
Cualquier l.l.c. que no contenga el string vacío se puede generar por una gramática en
que todas sus producciones son de la forma A  BC | a.
53

Demostración. Sea G una g.l.c. que genere un l.l.c. que no contenga al string vacío. Por el
Teorema 4.3 siempre es posible hallar una g.l.c. equivalente G1 = (N,T,P,), tal que P no
contenga producciones unitarias ni producciones vacías. Luego, si una producción tiene en
su lado derecho un símbolo, éste debe ser terminal, por lo que esa producción cumple con
la condición solicitada.
Sea ahora una producción en P de la forma A  X1X2...Xm, donde m  2. Si Xi es un

símbolo terminal a, se introduce a N una nueva variable Ca y a P una producción Ca  a, la
cual está en la forma solicita para FNC. Entonces se reemplaza Xi por Ca. Sea el nuevo
conjunto de variables N’ y el nuevo conjunto de producciones P’. Sea la g.l.c. G2 tal que
G2 = (N’,T,P’,). Se observa que G2 no está aún en FNC. Probamos que L(G1) = L(G2).
Si    en G1 entonces  *  en G2, por lo que L(G1)  L(G2). Ahora mostramos

por inducción sobre el número de pasos en una derivación que si A *w en G2 para AN’
y wT* entonces A *w en G1. Para derivaciones de un paso es trivial. Supongamos que
esta proposición es verdadera para derivaciones de hasta k pasos. Sea A *w en G2 en
una derivación de k+1 pasos. Entonces el primero debe ser de la forma A  B1B2...Bm,
para m  2. Se puede escribir entonces que w = w1w2...wm, donde Bi *wi para 1  i  m.
Si Bi es Ca para algún aT, entonces wi = a. Por la construcción de P’, existe una
producción en P de la forma A  X1X2...Xm en que Xi = Bi si BiN y Xi = a si BiN’-N.
Para estos Bi en N sabemos que la derivación Bi *wi en G1, no tiene más que k pasos,
luego, por la hipótesis inductiva, Xi *wi en G1. Luego A *w en G1. Por lo tanto se
verifica que L(G2)  L(G1). Luego L(G1) = L(G2).
Se ha probado entonces que cualquier l.l.c. puede ser generado por una g.l.c. en la que
toda producción es, o de la forma A  a o de la forma A  B1B2...Bm para m  2. Sea esa
g.l.c. G2 = (N’,T,P’,). Se modifica esta gramática agregando algunos símbolos no
terminales adicionales a N’ y reemplazando algunas producciones de P’. Para cada
producción A  B1B2...Bm en P’, en que m  3, se crean las variables D1, D2,...,Dm-2 y se
reemplaza la producción anterior por el conjunto de producciones:
A  B1D1
D1 B2D2
D2  B3D3
.
.
Dm-3  Bm-2Dm-2
Dm-2  Bm-1Bm
Sea N” el nuevo conjunto de símbolos no terminales y P” el nuevo conjunto de

producciones. Sea G3 = (N”,T,P”,). Entonces G3 está en FNC. Es claro que si A * en
G2 entonces A * en G3, luego L(G2)  L(G3). Por inducción sobre el número de pasos
en la derivación se comprueba que L(G3)  L(G2). Luego ambas gramáticas son
equivalentes y el lenguaje aceptado es L(G) original. Luego G3 es la g.l.c. que verifica el
Teorema.

Ejemplo 7. Determine una g.l.c. en FNC equivalente a la gramática:
  bA | aB
A  bAA | a | a
B  aBB | b | b
1) Las producciones A  a y B  b están en FNC.

2) No hay producciones vacías ni unitarias, ni símbolos inútiles.
54

3) Se crean los símbolos no terminales Ca y Cb tales que Ca  a y Cb  b, y se modifican

las siguientes producciones:
  bA se reemplaza por   Cb A.
  aB se reemplaza por   Ca B.
A  a se reemplaza por A  Ca .
A  bAA se reemplaza por A  Cb AA.
B  b se reemplaza por B  Cb .
B  aBB se reemplaza por B  Ca BB.
4) Se crea el símbolo no terminal D1 y se reemplaza la producción A  Cb AA por la

producción A  Cb D1 y D1  AA.
5) Se crea el símbolo no terminal D2 y se reemplaza la producción B  Ca BB por la
producción B  Ca D2 y D2  BB.
6) Finalmente, la gramática en FNC es la siguiente, donde N’ = {, A, B, Ca, Cb, D1, D2}:
  Cb A | Ca B
A  Ca  | Cb D1 | a
B  Cb  | Ca D2 | b
D1  AA
D2  BB
Ca  a
Cb  b
4.5 Forma Normal de Greibach
Se trata de modificar las producciones de una gramática de libre contexto de modo que
queden todas normalizadas según A  a. Las g.l.c. que verifiquen estas condiciones se
dirán en FNG (Forma Normal de Greibach). Para ello se estudiarán dos Lemas que
permiten modificar las producciones de una g.l.c. para luego llevarlas a la FNG.
Lema 4.3 Se define una A-producción como toda producción cuya variable a su izquierda
sea A. Sea la g.l.c. G = (N,T,P,) y sea A  1B2 una A-producción en P y sean las B-
producciones B  1|2|...|r. Entonces, se puede construir la g.l.c. G1 = (N,T,P’,) a partir
de G eliminando la producción A  1B2 de P y agregando las producciones A  11
2 | 12 2 |...| 1r 2 a P se tiene que G y G1 son equivalentes, o sea L(G) = L(G1).
Demostración. Es fácil ver que L(G1)  L(G), ya que si A  1i 2 se usa en alguna
derivación en G1 entonces A  1B 2  1i 2 en G y los strings derivados son los
mismos en ambas gramáticas. Para mostrar que L(G)  L(G1) se observa que A  1B 2
es la única producción en G que no está en G1. Cuando esta producción se usa en una
derivación de G, el símbolo B debe ser reescrito en algún paso posterior usando una
producción de la forma B  i. Estos dos pasos se reemplazan por el paso A  1i 2.
Luego L(G)  L(G1), y por lo tanto L(G) = L(G1).

Lema 4.4 Sea la g.l.c. G = (N,T,P,). Sea A  A1| A2|...|Ar el conjunto de todas las
A-producciones para las que A es el símbolo más a la izquierda del lado derecho (son
recursivas a la izquierda). Sean A  1|2|...|s las A-producciones que no son recursivas a
la izquierda. Sea G1 = (N{B},T,P1,) la g.l.c. formada al agregar la variable B a N y
reemplazar todas las A-producciones por las A-producciones no recursivas a la izquierda
siguientes: A  i|iB con 1  i  s, y B  j|jB con 1  j  r. Entonces G y G1 son
equivalentes, o sea L(G) = L(G1).
55

Demostración. En una derivación más a la izquierda, una secuencia de producciones de la

forma A  Ai debe terminar con alguna producción A  j, luego se tiene la sucesión de
reemplazos siguiente en G:
A  A1  A21 ... App-1... 1  jpp-1... 1
En G1 se obtiene ahora:
A  jB  jpB  jpp-1B  ...  jpp-1...2B  jpp-1... 1
La transformación inversa también es válida, luego es fácil comprobar que los strings
derivados en G y G1 son los mismos, o sea L(G) = L(G1).

Teorema 4.5 Forma Normal de Greibach (FNG)
Todo l.l.c. que no contenga al string vacío puede ser generado por una g.l.c. para la
que cada producción sea de la forma A  a.
Demostración. Sea G = (N,T,P,) una g.l.c. en FNC que genere el l.l.c. y supongamos que
N = {A1, A2,..., Am}. El primer paso para transformar las producciones de P a FNG es
modificar éstas de modo que si Ai  Aj está en P entonces se tenga j > i. Partiendo con
A1 y procediendo hasta Am, se siguen los siguientes pasos. Supondremos que las
producciones se han modificado para 1  i < k, tal que Ai  Aj es una producción de P
solo si j > i. Entonces se revisan las Ak-producciones.
Si Ak  Aj es una producción en que j < k, se genera un nuevo conjunto de

producciones sustituyendo por Aj el lado derecho de cada Aj-producción de acuerdo al
Lema 4.3. Repitiendo este proceso k-1 veces a lo más, se obtienen producciones del tipo
Ak  Al con l  k. Las producciones con l = k (recursivas a la izquierda) son cambiadas
de acuerdo al Lema 4.4, introduciendo una nueva variable Bk. El algoritmo a aplicar es:
{
for (k = 1, k  m, k++)
{
for (j = 1, j  k-1, j++)
{ for (cada producción de la forma Ak  Al)
{
for (todas las producciones Aj  )
{
agregar producción Ak  ;
remover producción Ak  Aj;
}
} }
for (cada producción de la forma Ak  Ak)
{
agregar producciones Bk  |Bk;
remover producción Ak  Ak;
}
for (cada producción Ak  , en que  no empieza con Ak)
{
agregar producción Ak  Bk;
}
}
56

Repitiendo el proceso anterior para cada variable original se tendrá solo producciones
de la forma:
1) Ai  Aj con j > i

2) Ai  a con aT
3) Bi   con (N{B1, B2,..., Bi-1})*
Se observa que toda Am-producción debe tener como símbolo de más a la izquierda un
símbolo terminal. Para una Am-1-producción debe tener como símbolo de más a la
izquierda o a Am o a un símbolo terminal. Si se aplica el Lema 4.3 para estas producciones,
y luego se reitera para las siguientes, entre Am-1 y A1, todas quedan en FNG (o sea su lado
derecho tiene un símbolo terminal como símbolo de más a la izquierda).
Finalmente se examinan las producciones para las nuevas variables B1, B2,..., Bm. Ya
que comenzamos con una g.l.c. en FNC, es fácil probar por inducción sobre la cantidad de
aplicaciones de los Lemas 4.3 y 4.4 que el lado derecho de cada Ai-producción, 1  i  m,
empieza con un símbolo terminal o con AjAk para algún j y k (propuesto como ejercicio).
Luego ninguna Bj-producción puede empezar con otra Bj. Además todas las Bi-
producciones tienen sus lados derechos empezando con símbolos terminales o con algún
símbolo Ai y aplicando una vez más el Lema 4.3 para cada Bi-producción se completa la
demostración.

Ejemplo 8. Normalice según Greibach la g.l.c. G = ({A1, A2, A3}, {a,b}, P, A1), en que sus
producciones son:
A1  A2A3
A2  A3A1 | b
A3  A1A2 | a
1) La g.l.c. está en FNC.

2) Para las producciones de A1 y A2 sus lados derechos empiezan con símbolos terminales
o con variables de mayor numeración. Pero para A3  A1A2 se aplica Lema 4.3 y
queda A3  A2A3A2 | a.
3) Se repite el proceso pues la A3-producción aún no cumple tener su lado derecho
empezando con una variable numerada mayor o igual. Se reemplaza A3  A2A3A2 por
A3  A3A1A3A2 | b A3A2 | a.
4) Se aplica ahora el Lema 4.4 para eliminar la recursividad izquierda de la A 3-producción
A3  A3A1A3A2. Para ello se crea la variable B3 y se reemplaza esta producción por
las siguientes:
A3  bA3A2B3 | aB3
B3  A1A3A2 | A1A3A2B3
Luego, las producciones de la gramática son ahora:
A1  A2A3
A2  A3A1 | b
A3  bA3A2B3 | aB3 | bA3A2 | a
B3  A1A3A2 | A1A3A2B3
5) Todas las A3-producciones comienzan a su lado derecho con símbolos terminales. Se

usan estas para reemplazar A3 en la producción A2  A3A1, y su resultado se usa para
reemplazar A2 en la producción A1  A2A3. El resultado de esto es:
A1  bA3A2B3A1A3 | aB3A1A3 | bA3A2A1A3 | bA3 | aA1A3

A2  bA3A2B3A1 | bA3A2A1 | aB3A1 | aA1 | b
57

A3  bA3A2B3 | aB3 | bA3A2 | a

B3  A1A3A2 | A1A3A2B3
6) Finalmente se convierten las B3-producciones reemplazando las A1-producciones y se

obtiene:
A1  bA3A2B3A1A3 | aB3A1A3 | bA3A2A1A3 | bA3 | aA1A3

A2  bA3A2B3A1 | bA3A2A1 | aB3A1 | aA1 | b
A3  bA3A2B3 | aB3 | bA3A2 | a
B3  bA3A2B3A1A3A3A2 | bA3A2B3A1A3A3A2B3 | aB3A1A3A3A2 | aB3A1A3A3A2B3
| bA3A2A1A3A3A2 | bA3A2A1A3A3A2B3 | bA3A3A2 | bA3A3A2B3 | aA1A3A3A2 |
aA1A3A3A2B3
Esta es la g.l.c. en FNG.
1. Determine si las siguientes gramáticas de libre contexto son ambiguas, su lenguaje

aceptado, elimine producciones vacías, unitarias y símbolos inútiles y normalícelas
según Chomsky y Greibach:
e)   aABC | bABC b)   AbC | BaC | AB | C

A  aaA | bA |  A  aB | Cb | 
B  bbB | aB |  B  bB | Ca | 
C  ab | ba C  ab | AB
c)   AC | A d)   WC | C | aX
A  BA |  X  Xab | ab
B  aB | b W a
C  Ca | Cb C  Bab | Daa
B  BdW | DWD | bb
D  DDb | Wba | XaX
2. Demuestre que cualquier lenguaje de libre contexto L, sin incluir a , puede ser
generado por una g.l.c. G = (N,T,P,) cuyas producciones son todas de la forma A  a
| aB | aBC, en que A,B y C son símbolos no terminales (de N) y aT.
3. Sea G la g.l.c. dada por:   aa | bb |  | a | b. Demuestre por inducción sobre el
largo del string derivado que L(G) = {x / x es palíndrome en (a+b)*}.
4. Escriba una g.l.c. que genere el conjunto de todos los strings sobre el alfabeto {a,b}
con exactamente el doble de b’s que a’s.
5. Elimine los símbolos inútiles de la siguiente g.l.c.:
  AB | CA
Aa
B  BC | AB
C  aB | b
6. Determine la g.l.c. en FNC equivalente a la g.l.c. que genera fórmulas del cálculo
proposicional con predicados p y q, dada por     |    |    | ( ) | p | q.
7. Escriba un g.l.c. en FNG equivalente a la g.l.c.
58

  AA | 0
A   | 1
8. Determine la g.l.c. en FNG equivalente a la g.l.c.:
  AB
A  BB | C | 1 | 
B  0A1 | 0
C  BB
9. Escriba una g.l.c. para generar los siguientes lenguajes:
a) el conjunto de strings sobre el alfabeto {0,1} tal que:
L = {0i1j0k / i > 0 es impar, j  0 es par y k  0 es divisible por 3}
b) el conjunto L = {w#wr# / w  (0 + 1)*} en que wr es el reverso de w.
10. Para la g.l.c. siguiente obtenga una gramática equivalente en FNG, compruebe si es
ambigua y determine el lenguaje aceptado:
  AC | A
A  BA | 
B  aB | b
C  Ca | Cb
5. Autómatas Pushdown
5.1 Introducción
Así como las expresiones regulares tienen un autómata equivalente (el AFD), las g.l.c.
tienen su contraparte: el autómata pushdown (APD). En este caso se considerará que el
APD es no determinístico, pues la versión determinística de este autómata solo acepta un
subconjunto de todos los l.l.c., aunque en este subconjunto están incluidos la mayoría de
los lenguajes de programación.
5.2 Definición de un APD
Este tipo de autómata comprende una cinta de entrada y un control finito (como en los
autómatas finitos) más una pila, formada por un string de símbolos de un alfabeto. El
símbolo de más a la izquierda de la pila se considera el que está al tope de la pila. Como el
autómata es no determinístico, habrá un número finito de elecciones de movimientos en
cada situación.
Los movimientos a considerar serán de dos tipos: en el primer caso se lee un símbolo
del input y dependiendo de éste, del símbolo al tope de la pila y del estado del control
finito, se tendrá una cierta cantidad de elecciones de movimientos posibles. Cada elección
consiste de un próximo estado para el control finito y de un string de símbolos (que puede
ser vacío) para reemplazar el símbolo al tope del stack. Además, la lectora del input avanza
al siguiente símbolo. En el segundo tipo de movimiento (llamado movimiento-) también
se accede a alguna cantidad de elecciones de movimientos pero sin considerar el símbolo a
la entrada y la lectora del input no avanza sobre éste. Con este tipo de movimiento el APD
puede manejar la pila (vaciarla por ejemplo) sin leer símbolos del input.
59

Formalmente, un APD M = (Q, S, , , q0, Z0, F) es tal que:
1) Q es el conjunto finito de estados;

2) S es el alfabeto del input;
3)  es el alfabeto de la pila;
4) q0Q es el estado inicial;
5) Z0 es el símbolo inicial en el stack;
6) F  Q es el conjunto de estados finales;
7) :Q(S{})  Q* es la función de transición de este autómata.
Por convención se usarán las primeras letras minúsculas (a, b, c, d, e) para denotar a
símbolos del input, las últimas letras minúsculas (u, v, w, x, y, z) para denotar strings de
símbolos del input, letras mayúsculas para representar a símbolos de la pila y letras griegas
para representar strings de símbolos de la pila. Los dos movimientos antes mencionados y
que son definidos por la función de transición son entonces:
a) (q, a, Z) = {(p1, 1), (p2, 2),...,(pm,m)}, en que q y pi son estados de Q, aS, Z y
i* (1  i  m), indica que estando en el estado q, leyendo a en el input y con Z en la
pila, el APD puede entrar al estado pi, reemplazar Z por el string i y avanzar la lectora
del input un símbolo. Por convención, el símbolo de más a la izquierda de i será el
ubicado más alto en la pila y su símbolo de más a la derecha será el menor en el stack.
Nótese que no se puede elegir un estado pi y un string j para algún j  i en un
movimiento.
b) (q, , Z) = {(p1, 1), (p2, 2),...,(pm,m)}, en que no se considera el símbolo al tope de la

pila (movimiento-), se está en estado q y con Z al tope de la pila, se entra a algún
estado pi y se reemplaza Z por i para 1  i  m. La lectora no avanza en este caso.
Para describir la configuración de un APD en un instante dado se define una

descripción instantánea (DI). La DI debe registrar el estado actual, el resto del string del
input por analizar en ese instante y el contenido del stack. Luego, una DI se define como el
trío (q, w, ), en que qQ, wS* y *. Si M = (Q, S, , , q0, Z0, F) es un APD, se dirá
que (q, aw, Z) M (p, w, ) si (p, )  (q, a, Z). Se observa que a puede ser el string
vacío o un símbolo del input. Se usará * para indicar la clausura reflexiva y transitiva del
símbolo M. O sea que para cada DI I se verifica que I * I y si I M J y J *M K
entonces se cumple I *M K, para tres DI I, J y K cualesquiera.
Para definir el lenguaje aceptado por el APD tenemos dos maneras. La primera es
definirlo como el conjunto de todos los inputs para los que alguna secuencia de
movimientos cause que el APD vacíe su pila, el cual se llama lenguaje aceptado por pila
vacía. La segunda manera es aceptar un input al alcanzar un estado final por alguna
sucesión de movimientos (manera que es similar a la usada por los autómatas finitos) y se
llama lenguaje aceptado por estado final. Más adelante se verá que ambas maneras de
definir el lenguaje aceptado por un APD son equivalentes.
Entonces, para el APD M = (Q, S, , , q0, Z0, F) se define el lenguaje aceptado por
pila vacía como el conjunto:
N(M) = {w / (q0, w, Z0) * (p, , ) para algún pQ}
Y el lenguaje aceptado por estado final como el conjunto:
L(M) = {w / (q0, w, Z0) * (p, , ) para algún pF y algún *}
Cuando la aceptación es por pila vacía el conjunto de estados finales es irrelevante y

se considera entonces que F = .
60

Ejemplo 1. Sea el APD M = ({q1, q2}, {0, 1, c}, {R, B, G}, , q1, R, ) que reconoce por
pila vacía el conjunto de strings N(M) = {wcwr / w(0 + 1)*}. Los movimientos de este
APD, que es determinístico, son:
(q1,0,R) = {(q1, BR)}

(q1,0,B) = {(q1, BB)}
(q1,0,G) = {(q1, BG)}
(q1,1,R) = {(q1, GR)}
(q1,1,B) = {(q1, GB)}
(q1,1,G) = {(q1, GG)}
(q1,c,R) = {(q2, R)}
(q1,c,B) = {(q2, B)}
(q1,c,G) = {(q2, G)}
(q2,0,B) = {(q2, )}
(q2,1,G) = {(q2, )}
(q2,,R) = {(q2, )}
Este APD trabaja como sigue:
1) Debe registrar el string leído hasta que encuentra el símbolo c.

2) Se compara el string leído antes de c con el string que se encuentra después de este
símbolo. Si este es su reverso se detiene y acepta.
3) El símbolo inicial en la pila es R. Si lee un 0 registra B en la pila. Si lee un 1 registra G,
independiente del contenido de la pila.
4) Si lee un 0 en el input, en la pila debe haber una B, y si viene un 1 debe haber una G.
En ambos casos se eliminan los símbolos de la pila. En cualquier otro caso se rechaza
pues no hay movimiento posible.
La secuencia de DI para el input w = 01c10 es:
(q1, 01c10, R)  (q1, 1c10, BR)  (q1, c10, GBR)  (q2, 10, GBR)  (q2, 0, BR) 
(q2, , R)  (q2, , ) (aceptación)
Para un input no válido como u = 0c1 se tiene la siguiente secuencia de DI:
(q1, 0c1, R)  (q1, c1, BR)  (q2, 1, BR) (rechazo)
Ejemplo 2. El APD M = ({q1, q2}, {0, 1}, {R, B, G}, , q1, R, ) acepta por pila vacía el
conjunto N(M) = {wwr / w(0 + 1)*}. Es no determinístico y sus movimientos son:
(q1,0,R) = {(q1, BR)}

(q1,1,R) = {(q1, GR)}
(q1,0,B) = {(q1, BB), (q2, )}
(q1,0,G) = {(q1, BG)}
(q1,1,B) = {(q1, GB)}
(q1,1,G) = {(q1, GG), (q2, )}
(q2,0,B) = {(q2, )}
(q2,1,G) = {(q2, )}
(q1,,R) = {(q2, )}
(q2,,R) = {(q2, )}
En este caso el APD primero almacena en la pila la información del input que está
leyendo (movimientos primero al sexto). En el tercer y sexto movimientos M puede decidir
que ya ha leído la mitad del string y pasa al estado q2 para chequear si el resto del input
61

coincide con el reverso del input ya analizado. Si esto ocurre entonces M vacía su pila y
acepta el input. Si no es así el input es rechazado. Por ejemplo, para el input w = 001100 se
tiene la siguiente secuencia de DI (se recuerda que el APD acepta el string si en alguno de
los caminos posibles alcanza la condición de aceptación, en este caso vacía su pila):
(q1, 001100, R)  (q2, 001100, )


(q1, 01100, BR)  (q2, 1100, R)  (q2, 1100, )

(q1, 1100, BBR)

(q1, 100, GBBR)  (q2, 00, BBR)  (q2, 0, BR)  (q2, , R)  (q2, , ) (aceptado)

(q1, 00, GGBBR)

(q1, 0, BGGBBR)  (q2, , GGBBR)

(q1, , BBGGBBR)
5.3 Definición de un APD determinístico
El APD del Ejemplo 1 es determinístico en el sentido que a lo más existe un

movimiento posible desde alguna DI. Se dice que un APD M = (Q, S, , , q0, Z0, F) es
determinístico si:
1) qQ, Z, cuando (q,,Z)  entonces (q,a,Z) = , aS;

2) Para ningún qQ, Z y aS{} se verifica que (q,a,Z) contenga más de un
elemento.
La primera condición previene la posibilidad de que existan dos movimientos

asociados al mismo símbolo de la pila, uno que no considere el símbolo del input y otro
que no (movimiento-). La segunda condición asegura que hay un solo movimiento posible
para cada símbolo de input (o el string vacío) y símbolo de la pila que esté definido para el
APD. Se observa que los modelos determinísticos y no determinísticos de APD no son
equivalentes, a diferencia de lo que ocurría con los AFD que si lo eran. Por ejemplo, el
lenguaje analizado en el Ejemplo 2 sólo es aceptado por un APD no determinístico y no
existe uno determinístico equivalente que lo reconozca.
5.4 Relación entre APD y LLC
Se estudiará en este capítulo la relación existente entre los APD y los lenguajes de
libre contexto (l.l.c.) asociados a una gramática de libre contexto (g.l.c.), observando
primeramente que las dos definiciones dadas de lenguajes aceptados por un APD son
equivalentes. Luego se verá que los lenguajes aceptados por pila vacía son exactamente los
LLC.
Teorema 5.1 Si L = L(M2) para algún APD M2 entonces L = N(M1) para algún APD M1.
Demostración. Sea M2 = (Q, S, , , q0, Z0, F) un APD tal que L = L(M2). Se define
entonces M1 = (Q{qe,q0´} , S, {X0}, `, q0`, X0, ), en que la función de transición `
se define como:
1) `(q0`,, X0) = {(q0, Z0X0)}: con este movimiento M1 accede a la DI inicial de M2

excepto que mantiene marcado el fondo de la pila con su símbolo inicial X0.
62

2) `(q, a, Z) = (q, a Z) qQ, aS{} y Z: M1 simula a M2.
3) (qe, )`(q, , Z), qF y Z{X0}: Se vacía la pila, pasando a estado qe si se

alcanza un estado final.
4) (qe, )`(qe, , Z), Z{X0}: Finalmente, al estar en estado qe se termina de vaciar

la pila.
Para terminar se prueba que ambos APD son equivalentes. Sea xL(M2). Entonces
qF tal que (q0, x, Z0) * (q, , ) en M2. Sea M1 con el mismo input x. Por regla (1)
anterior (q0´, x, X0) * (q0, x, Z0X0). Por regla (2) cada movimiento de M2 es un
movimiento legal para M1, luego: (q0, x, Z0) * (q, , ), luego en M1:
(q0´, x, X0)  (q0, x, Z0X0) * (q, , X0)
Por las reglas (3) y (4) se obtiene entonces: (q0´, x, X0) * (qe, , ) y luego M1 acepta
a x por pila vacía, o sea xN(M1). Inversamente, si M1 acepta a x por pila vacía, se ve
fácilmente que la secuencia de movimientos debe ser: una vez la regla (1), luego la
secuencia dada por la regla (2) en que M1 simula a M2, seguida del vaciado de la pila de
M1 por reglas (3) y (4). Luego x debe estar en L(M2).

Teorema 5.2 Si L = N(M1) para algún APD M1 entonces L = L(M2) para algún APD M2.
Demostración. Sea M1 = (Q, S, , , q0, Z0, ) una APD tal que L = N(M1). Se define
entonces M2 = (Q{q0´, qf}, S, {X0}, ´, q0´, X0, {qf}), en que la función de transición
´ se define como:
1) ´(q0´, , X0) = {(q0, Z0X0)}: M2 ingresa a la DI inicial de M1, excepto que mantiene
marcado el fondo de la pila con su símbolo inicial X0.
2) ´(q, a, Z) = (q, a, Z), qQ, aS{}, Z: M2 simula a M1 completamente.
3) (qf, ) ´(q, , X0), qQ: Al aparecer X0 en la pila permite acceder al estado final qf.
La prueba de que L(M2) = N(M1) es similar a la realizada en el Teorema 5.1 y se deja

propuesta al lector.

Teorema 5.3 Si L es un l.l.c. entonces existe un APD M tal que L = N(M).
Demostración. Sea L = L(G) y supongamos que L(G), para G = (N, T, P, ) en FNG.

Sea el APD M = ({q}, T, N, , q, , ), en que (q, a, A) contiene a (q, ) cuando A  a
es una producción de P. El APD M simula derivaciones de más a la izquierda de los strings
reconocidos por G. Dado que G está en FNG, cada forma sentencial en una derivación más
a la izquierda consiste de un string de símbolos terminales x seguido por un string de
símbolos no terminales . M almacena el sufijo  de la forma sentencial izquierda en su
pila después de procesar el prefijo x. Formalmente  * x por una derivación más a la
izquierda  (q, x, ) * (q, , ) en M, lo cual se puede probar por inducción sobre la
longitud de la derivación (propuesto). Para concluir, se observa que si  =  entonces se
tiene que:  * x por una derivación más a la izquierda  (q, x, ) * (q, , ) en M,
luego xL(G) ssi xN(M).

63

Ejemplo 3. Sea la g.l.c. G = ({, X1, X2, X3), {a, b, c}, P, ) en que P tiene las
producciones:
  aX1X2
X1  aX3 | b
X2  aX3 | c
X3  a
M = ({q}, {a, b, c}, {, X1, X2, X3}, , q, , ) en que la función de transición  es la
siguiente:
(q, a, ) = {(q, X1X2)}
(q, a,X1) = {(q, X3)}
(q, b,X1) = {(q, )}
(q, a,X2) = {(q, X3)}
(q, c,X2) = {(q, )}
(q, a,X3) = {(q, )}
Para este ejemplo se puede comprobar que w = aaac es aceptado por G pues:
  aX1X2  aaX3X2  aaaX2  aaac
Por otro lado, en el APD se tiene que:
(q, aaac, )  (q, aac, X1X2)  (q, ac, X3X2)  (q, c, X2)  (q, , )
Luego, aaacL(G) ssi aaacN(M).
Teorema 5.4 Si L = N(M) para algún APD M entonces L es un l.l.c.
Demostración. Sea el APD M = (Q, S, , , q0, Z0, ). Sea G = (N, S, P, ) una g.l.c. en
que N es el conjunto de objetos de la forma [q, A, p], con q y p en Q y A en , además del
nuevo símbolo . P es el conjunto de producciones siguiente:
1)   [q0, Z0, q], qQ
2) [q, A, qm+1]  a[q1, B1, q2][q2, B2, q3]...[qm, Bm, qm+1] para cada q, q1,...,qm+1 en Q y
cada aS{} y cada A, B1, B2,...,Bm en , tal que (q1, B1B2...Bm)(q, a, A). Si m = 0
la producción es [q, A, q1]  a.
La intención es que [q, A, p] derive el string x ssi x causa que M borre una A de su pila
por alguna secuencia de movimientos que comienzan en q y terminan en p. Para probar que
L(G) = N(M), primero se comprueba por inducción sobre el número de pasos en la
derivación de G (o el número de movimientos en M) (propuesto) que:
[q, A, p] * x en G ssi (q, x, A)  (p, , ) en M
Si q = q0 y A = Z0 entonces: [q0 , Z0, p] * x en G ssi (q0, x, Z0)  (p, , ) en M para

algún estado p. Luego xL(G) ssi xN(M).

Ejemplo 4. Sea M = ({q0, q1}, {0, 1}, {X, Z0}, , q0, Z0, ) en que  es:
(q0, 0, Z0) = {(q0, XZ0)}

(q0, 0, X) = {(q0, XX)}
64

(q0, 1, X) = {(q0, )}

(q1, 1, X) = {(q1, )}
(q1, , X) = {(q1, )}
(q1, , Z0) = {(q1, )}
Construir la gramática G = (N, T, P, ) sin símbolos inútiles y en FNG que genere

N(M). Para ello sea:
N = {, [q0, X, q0], [q0, X, q1], [q1, X, q0], [q1, X, q1], [q0, Z0, q0], [q0, Z0, q1], [q1, Z0,
q0], [q1, Z0, q1]}
T = {0, 1}
Las producciones de G son entonces:
  [q0, Z0, q0] | [q0, Z0, q1]
Se agregan producciones para [q0, Z0, q0] y [q0, Z0, q1] que están asociadas al
movimiento (q0, XZ0)(q0, 0, Z0):
[q0, Z0, q0]  0[q0, X, q0][q0, Z0, q0] | 0[q0, X, q1][q1, Z0, q0]
[q0, Z0, q1]  0[q0, X, q0][q0, Z0, q1] | 0[q0, X, q1][q1, Z0, q1]
Análogamente, para los restantes movimientos del APD se obtienen las siguientes
producciones. Para (q0, 0, X) = {(q0, XX)}:
[q0, X, q0]  0[q0, X, q0][q0, X, q0] | 0[q0, X, q1][q1, X, q0]

[q0, X, q1]  0[q0, X, q0][q0, X, q1] | 0[q0, X, q1][q1, X, q1]
Para (q0, 1, X) = {(q0, )} se tiene: [q0, X, q1]  1.
Para (q1, 1, X) = {(q1, )} se tiene: [q1, X, q1]  1.
Para (q1, , X) = {(q1, )} se tiene: [q1, X, q1]  .
Para (q1, , Z0) = {(q1, )} se tiene: [q1, Z0, q1]  .
Se eliminan todas las variables inútiles y las producciones asociadas, aplicando los
Lemas 4.1 y 4.2. Por ejemplo, las variables [q1, X, q0] y [q1, Z0, q0] no tienen producciones
asociadas. Asimismo, no es posible derivar strings de terminales a partir de las variables
[q0, X, q0] y [q0, Z0, q0]. Eliminando estas producciones queda:
  [q0, Z0, q1]

[q0, Z0, q1]  0[q0, X, q1][q1, Z0, q1]
[q0, X, q1]  0[q0, X, q1][q1, X, q1] | 1
[q1, X, q1]  1 | 
[q1, Z0, q1]  
Por último se eliminan las producciones vacías y se lleva la gramática a FNG. Al

hacerlo resultan inútiles las variables [q0, Z0, q1] y [q1, Z0, q1] y queda finalmente:
  0[q0, X, q1]
[q0, X, q1]  0[q0, X, q1][q1, X, q1] | 1
[q1, X, q1]  1
65

1. Sea L = {0n 12n 0m / n,m > 0}. Escriba un APD M que acepte L por stack vacío.
2. Para el sgte. APD determine el lenguaje aceptado y la gramática en FNG equivalente a

M = ({q,p}, {a,b}, {S,C}, , q, S, {p}) donde:
(q,a,S) = {(q,SC), (q,C)}

(q,b,C) = {(p,)}
(p,b,C) = {(p,)}
3. Para la g.l.c. en FNC siguiente normalice sus producciones según Greibach y determine
el APD equivalente:
A1  A2 A3
A2  A4 A3
A3  A1 A4 | a
A4  b
4. Dada la g.l.c. siguiente determine el APD equivalente y su lenguaje aceptado:
  bAB | aBC
A  aBA | a
B  bCC | b
C  aAB | a
5. Para el APD M = ({q0}, {a, b}, {A, B, C}, , q0, A, ) determine la g.l.c. en FNG sin
símbolos inútiles equivalente y el lenguaje aceptado:
(q0, a, A) = {(q0, AB), (q0, BA)}

(q0, b, B) = {(q0, CA), (q0, CB)}
(q0, a, C) = {(q0, CC), (q0, )}
6. Escriba un APD que reconozca los strings de los siguientes lenguajes:
a) L = {w / w  (0 + 1)* y la cantidad de ceros es igual a la de unos}
b) El lenguaje de paréntesis balanceados, considerando estos como (, ), [ y ]. Ejemplo

de estos strings son: (()()), [([])], etc.
c) L = {0n 1 0m / n > m; n,m > 0}
d) L = {an bn / n  0}
e) L = {w  (0 + 1)* / w contiene un cero más que unos}
f) L = {u2v / u,v  (0 + 1)* y u  vr}
g) El lenguaje dado por la expresión regular aa*ba.
h) El lenguaje dado por la expresión regular a*(b + b*a).
i) L = {0n 1m / n  m  3n}
66

6. Máquinas de Turing
6.1 Introducción
La máquina de Turing (MT) es un modelo matemático simple que permite modelar la

habilidad de cálculo de un Computador, y que fue introducido en el ámbito de la ciencia de
la computación por Alan Turing en 1936. Este ha llegado a ser la formalización aceptada
de un procedimiento efectivo, o sea de un procedimiento que permite responder a una
consulta con seguridad. Aunque aún no se ha podido probar que este modelo es
equivalente a nuestra noción intuitiva de un Computador, hay argumentos suficientes en
apoyo de esta equivalencia, la que ha llegado a ser conocida como hipótesis de Church y
que enunciaremos al final del Capítulo. En particular, esta hipótesis menciona que la
máquina de Turing es equivalente en potencia de cálculo al Computador digital, tal como
se le conoce hoy, o sea que cualquier algoritmo que se pueda programar y ejecutar en uno
de estos computadores es posible resolverlo usando una máquina de Turing.
6.2 Modelo Formal de la Máquina de Turing
El modelo básico de una MT posee un control finito, una cinta de entrada que está
dividida en celdas, y una cabeza lectora que “lee” una celda de la cinta a la vez. La cinta
tiene una celda de más a la izquierda pero es infinita a la derecha, y cada una de sus celdas
puede contener exactamente uno de un número finito de símbolos del alfabeto de la cinta.
Inicialmente, las n celdas de más a la izquierda, para un n  0 finito, contendrán el input a
analizar, el cual es un string de símbolos elegidos de un alfabeto asociado a la entrada de
datos. Las restantes celdas contienen un símbolo blanco, que es un símbolo especial de la
cinta y no pertenece al alfabeto del input.
a1 a2 a3 ...... ai ....... an B ...

...
Control
Finito
En un movimiento la MT, dependiendo solo del símbolo “leído” por la cabeza lectora
y del estado del control finito, puede:
1) cambiar de estado;
2) imprimir un símbolo sobre la celda leída, reemplazando el que estaba allí, y
3) mover su cabeza lectora, a la izquierda o a la derecha, una celda.
Formalmente, una MT es M = (Q, , , , q0, B, F) en que:
Q: es el conjunto finito de estados,

: es el alfabeto de símbolos de cinta admisibles,
B: es el símbolo especial blanco y pertenece a ,
: es el alfabeto de símbolos del input y es subconjunto de ,
q0: es el estado de partida y pertenece a Q,
F: es el conjunto de estados finales y es subconjunto de Q,
67

: es la función de transición que indica el próximo movimiento de la MT y está

definida entre los conjuntos Q y Q{L,R}, pero pudiera estar indefinida para
algunos argumentos específicos.
Llamamos una Descripción Instantánea (DI) de la MT M al string 1q 2, en que q es

un estado de Q, y es el estado actual del control finito, 12 es el string en * que
corresponde al contenido de la cinta desde el símbolo a la izquierda de la cabeza lectora
hasta el símbolo no blanco de más a la derecha. Puede ocurrir que este string sea un blanco
B. Para evitar confusión supondremos que Q y  son disjuntos. Entonces, en la DI 1q 2
se supone que la cabeza lectora está leyendo el símbolo más a la izquierda de 2, o si este
string es blanco, la cabeza está frente a un blanco.
Se define un movimiento de M como sigue. Sea la DI X1X2 ... Xi-1 q Xi ... Xn y

supongamos una DI. Hay dos posibilidades:
1) Si (q, Xi) = (p, Y, L), en que si i = n+1 entonces Xi es B. Si i = 1 entonces no hay una
próxima DI, pues la lectora de cinta no puede salirse de ella. Si i > 1 se tiene:
X1X2 ... Xi-1 q Xi Xi+1 ... Xn M X1X2 ... Xi-2 p Xi-1 Y Xi+1 ... Xn
Si cualquier sufijo del string Xi-1 Y Xi+1 ... Xn es blanco (o concatenación de blancos)
este sufijo no se considera en la expresión anterior.
2) Si (q, Xi) = (p, Y, R), entonces se tiene:
X1X2 ... Xi-1 q Xi Xi+1 ... Xn M X1X2 ... Xi-1 Y p Xi+1 ... Xn
Se observa que si i = n + 1 el string Xi Xi+1 ... Xn es blanco (o vacío), y el lado derecho

de esta expresión es mayor en longitud que su lado izquierdo.
Si dos DI están relacionadas por el símbolo M se dice que la segunda resulta de la

primera por un movimiento. Si una DI resulta de otra por algún número finito de
movimientos, incluyendo movimientos nulos, ellos están relacionados por el símbolo
M*. No se considerará el subíndice M de M y M* cuando no haya confusión.
El lenguaje aceptado por una MT M, llamado L(M) es el conjunto de aquellos strings

en * que causan que M alcance un estado final cuando están sobre la cinta de M, con M
inicialmente en estado q0 y la cabeza lectora de M en la celda de más a la izquierda.
Formalmente, el lenguaje aceptado por la MT M = (Q, , , , q0, B, F) es:
L(M) = {w / pF, 1,2* tal que w* y se verifica que: q0w* 1 p 2}
Dada una MT que reconozca el lenguaje L, se supone, sin pérdida de generalidad que
la MT se detiene, es decir no tiene movimiento, cuando el input es aceptado. Sin embargo,
para strings no aceptados podría ocurrir que la MT no se detenga nunca.
Es importante considerar que la MT no tiene movimiento a la izquierda de su primer

símbolo, por lo que debe marcarse éste en el primer movimiento para poderlo reconocer al
retroceder.
Ejemplo 1. Sea L = {0n1n / n > 0}. La MT que reconoce este lenguaje es la siguiente.
Inicialmente en la cinta está el input 0n1n seguido de infinitos blancos. Repetidamente M
reemplaza el 0 de más a la izquierda por el símbolo X, avanza a la derecha hasta el 1 más a
la derecha, lo reemplaza por el símbolo Y, y retrocede a la izquierda hasta hallar el X más
a la derecha. Entonces avanza una celda a la derecha hasta el 0 de más a la izquierda y
repite el ciclo mencionado. Si ocurre que al buscar el 1 M encuentra un blanco entonces M
68

se detiene sin aceptar. Si luego de cambiar un 1 por una Y no se encuentran más ceros a la
izquierda, entonces se chequea que no haya más unos y se detiene aceptando si esto ocurre.
La MT es la siguiente: Q = {q0, q1, q2, q3, q4, q5},  = {0, 1}, F = {q4},  = {0, 1, X, Y, B}.
La función de transición  de este ejemplo está definida en la siguiente tabla:
 0 1 X Y B
q0 (q1, X, R) - - (q3, Y, R) -
q1 (q1, 0, R) (q2, Y, L) - (q1, Y, R) -
q2 (q2, 0, L) - (q0, X, R) (q2, Y, L) -
q3 - - - (q3, Y, R) (q4, B, R)
q4 - - - - -
Para el string válido 0011 se tienen las siguientes transiciones:
q0 0011  X q1 011  X0 q1 11  X q2 0Y1  q2 X0Y1  X q0 0Y1  XX q1 Y1 

XXY q1 1  XX q2 YY  X q2 XYY  XX q0 YY  XXY q3 Y  XXYY q3 B 
XXYYB q4 (aceptación).
Para el string no válido 001 se tendrá:
q0 001  X q1 01  X0 q1 1  X q2 0Y  q2 X0Y  X q0 0Y  XX q1 Y  XXY q1 B

(la MT se detiene y no acepta este string).
6.3 La Máquina de Turing como calculadora de funciones enteras
Además de dedicarse a aceptar lenguajes (se observa que reconoce todos los lenguajes
que ya hemos estudiado, o sea los regulares y los de libre contexto), la MT puede usarse
para evaluar funciones enteras (o sea funciones matemáticas con argumentos enteros). En
este caso, el entero i  0 se representa por el string 0i. Si una función tiene k argumentos, o
sea i1, i2,..., ik, entonces estos enteros se ubican inicialmente en la cinta separados por
unos, o sea se ingresa el input 0i110i21...10ik al comienzo de la cinta. Si la MT se detiene
(independiente del estado en que lo haga) y en la cinta se tiene el valor 0m para m  0,
entonces se informa que f(i1, i2,..., ik) = m, en que f es la función de k argumentos enteros
calculada por esta MT.
Si esta función está definida para todos los argumentos posibles se dice que ella es una
función recursiva total, y son calculadas por MT que siempre se detienen y retornan un
resultado. Todas las funciones aritméticas comunes son recursivas totales. Por ejemplo: la
suma, resta propia, multiplicación, división, factorial de un entero positivo, potencia de
dos, etc.
Ejemplo 2. La resta propia se define como m  n = m – n si m  n y es cero si m < n. La

MT M = ({q0, q1, q2, q3, q4, q5, q6}, {0, 1}, {0, 1, B}, , q0, B, ) calcula esta función,
empezando con el string 0m 1 0n en su input y se detiene con 0m  n en su output. No posee
estado final. M reemplaza repetidamente su primer cero por blanco, luego busca a la
derecha por un 1 seguido de un cero y cambia el 0 por el 1. Luego M retrocede hasta hallar
un blanco y repite el ciclo. Este termina si:
a) Buscando a la derecha un cero M encuentra un blanco. Entonces los n ceros de 0m 1 0n

han sido cambiados a unos y n+1 de los m ceros han sido cambiados a B. M reemplaza
los n+1 unos por un cero y n blancos, dejando m  n ceros en la cinta.
69

b) Comenzando el ciclo M no puede encontrar un cero para cambiar a blanco, debido a

que los primeros m ceros han sido cambiados. Entonces n  m asi que m  n = 0. M
reemplaza entonces todos los restantes unos y ceros por blancos.
La función de transición  es la siguiente:
 0 1 B
q0 (q1, B, R) (q5, B, R) -
q1 (q1, 0, R) (q2, 1, R) -
q2 (q3, 1, L) (q2, 1, R) (q4, B, L)
q3 (q3, 0, L) (q3, 1, L) (q0, B, R)
q4 (q4, 0, L) (q4, B, L) (q6, 0, R)
q5 (q5, B, R) (q5, B, R) (q6, B,R)
Para el input 0010 se tienen las siguientes transiciones:
q00010  Bq1010  B0q110  B01q20  B0q311  Bq3011  q3B011  Bq0011 

BBq111  BB1q21  BB11q2B  BB1q41  BBq41  Bq4  B0q6 (2  1 = 1).
Para el input 0100 se tendrá:
q00100  Bq1100  B1q200  Bq3110  q3B110  Bq0110  BBq510  BBBq00 

BBBBq5B BBBBBq6 (retorna cero pues 1  2 = 0).
6.4 Técnicas para construir Máquinas de Turing
Para describir Máquinas de Turing más complicadas se necesitan algunas herramientas

conceptuales especiales. Las que se verán en este capítulo son la de almacenaje en el
control finito, el chequeo de símbolos, y el uso de subrutinas.
6.4.1 Almacenaje en el control finito
El control finito puede usarse para mantener una cantidad finita de información. Para
lograr esto, el estado se redefine como un par de elementos pertenecientes al producto
cartesiano Qk, uno que ejerce el control y el otro para almacenar de uno a k símbolos de
cinta. Se aclara que esta definición es teórica y no significa realizar ninguna modificación a
la definición de la MT.
Ejemplo 3. La siguiente MT reconoce strings sobre el alfabeto  = {0, 1} dados por el

lenguaje L(M) = {ax / a, x *, cantidad de a’s en el string x es cero}. Al realizar sus
movimientos la MT lee el primer símbolo del input, lo registra en su control finito y
chequea que este símbolo no aparezca en el resto del input. La MT estará dada por la
siguiente definición: M = (Q, {0, 1}, {0, 1, B},  , [q0, B], B, F), en que Q es el producto
cartesiano dado por {q0, q1} {0, 1, B} y F será el conjunto {[q1, B]}. La función de
transición  se define como sigue:
 0 1 B
[q0, B] ([q1, 0], 0, R) ([q1, 1], 1, R) -
[q0, 0] - - -
[q0, 1] - - -
[q1, B] - - -
[q1, 0] - ([q1, 0], 1, R) ([q1, B], 0, L)
[q1, 1] ([q1, 1], 0, R) - ([q1, B], 1, L)
70

Inicialmente el estado inicial [q0, B] lee un símbolo y lo “guarda” en su segunda

componente, cambia su componente de control al estado q1 y avanza. Si no encuentra otro
símbolo igual al primero la MT se detiene al final del input (cuando encuentra un blanco) y
acepta entrando al estado [q1, B]. Si no es así se detiene y rechaza el input. Por ejemplo,
para los strings 10 y 00 se tienen las siguientes transiciones:
[q0, B] 01  0 [q1, 0] 1  01 [q1, 0] B  0 [q1, B] 10 (acepta)
[q0, B] 00  0 [q1, 0] 0 (no acepta)
6.4.2 Chequeo de símbolos
El chequeo de símbolos permite escribir MT que reconocen strings concatenados dos o

más veces, como: L1 = {ww / w*}, L2 = {wwr/ w*}, L3 = {wcy/ w,y*, wy}. Es
útil además cuando las longitudes de substrings deben ser comparadas, tales como en los
lenguajes: L4 = {aibi/ i  1} y L5 = {aibjck/ i  j o j  k}. Se introduce un símbolo extra
sobre la cinta, que puede ser un  o un blanco. El símbolo  aparece cuando el símbolo
asociado es considerado por la MT en una de sus comparaciones.
Ejemplo 4. Sea la MT M = (Q, , , , q0, B, F) que permite reconocer el lenguaje dado

por L = {wcw / w (a+b)*}. Sea Q = {[q, d]/q = qi, 1  i  9, d = a, b, B}. La segunda
componente del estado se usa para almacenar un símbolo de entrada. El alfabeto del input
es  = {[B,d] / d = a,b,c}, en cuyo caso el símbolo de entrada se identifica con d (o sea
[B,d] es solo otro nombre para el símbolo d). Además: q0 = [q1, B], F = {[q9, B]} y el
alfabeto de la cinta es  = {[X, d] / X  {B, }, d  {a, b, c, B}}. [B, B] se identifica con
el símbolo blanco B. Para d  {a, b} y e  {a, b} se define la función de transición  es:
 [B,d] [B,e] [B,c] [,e] [,d]

[q1,B] ([q2,d],[,d],R) - - - -
[q2,d] - ([q2,d],[B,e],R) ([q3,d],[B,c],R) - -
[q3,d] ([q4,B],[,d],L) - - ([q3,d],[ ,e],R) -
[q4,B] - - ([q5,B],[B,c],L) - ([q4,B],[ ,d],R)
[q5,B] ([q6,B],[B,d],L) - - - ([q7,B],[ ,d],R)
[q6,B] ([q6,B],[B,d],L) - - - ([q1,B],[ ,d],R)
[q7,B] - - ([q8,B],[B,c],R) - -
[q8,B] - - - - ([q8,B],[ ,d],R)
Además se verifica que: ([q8,B],[B,B]) = ([q9,B],[,B],L), en cuyo caso la MT ha

encontrado el símbolo blanco en la cinta, representado por [B,B], y se detiene aceptando el
string analizado. Si encontrara un símbolo no revisado, cuando el estado dado por su
primera componente es q8, la MT se detiene sin aceptar.
Como ejemplo se analizan las transiciones realizadas sobre el string válido bcb. Estas
son:
[q1,B][B,b][B,c][B,b]  [,b][q2,b][B,c][B,b]  [,b][B,c][q3,b][B,b] 

[,b][q4,B][B,c][,b]  [q5,B][,b][B,c][,b]  [,b][q4,B][B,c][,b] 
[,b][B,c][q8,b][,b]  [,b][B,c][,b][q8,b][B,B]  [,b][B,c][q9,b][,b] (acepta)
6.4.3 Subrutinas
71

Como en los programas tradicionales de cálculo, un diseño modular o “top-down”

simplifica, por ejemplo, la repetición de operaciones, usando subprogramas llamados
subrutinas, en una MT también es posible hacer eso. Una MT puede simular cualquier tipo
de subrutina, incluyendo procedimientos recursivos y cualquiera de los mecanismos de
paso de parámetros conocido (evaluación de una función por ejemplo).
La idea es escribir parte del programa de la MT para servir como subrutina. Este
tendrá un estado inicial y uno de retorno definidos. Este último no tendrá movimientos
temporalmente y sólo será usado para efectuar un retorno desde la subrutina llamada. Para
diseñar una MT que “llame” a una subrutina, se establece un nuevo conjunto de estados
exclusivos de ella y se especifica un movimiento desde el estado de retorno. El llamado se
realiza accesando el estado inicial de la subrutina y el retorno es a través del movimiento
desde el estado de retorno. Como ejemplo se verá la operación de multiplicación de dos
enteros positivos no nulos.
Ejemplo 5. Para calcular el producto de los enteros positivos no nulos m y n se diseña la

siguiente MT. El input es 0m10n y el output debe ser 0mn. El programa principal agrega un 1
al final del input, llevando a cabo las transiciones q00m10n * B0m-11q10n1 y luego llama a
la subrutina COPIA, cuyo estado inicial es q1, la cual realiza las siguientes transiciones: a
partir de 0m-i1q10n10i alcanza 0m-i1q50n10i+n, donde q5 es el estado de retorno. El programa
se completa con la eliminación del prefijo 10n1 de la cinta y termina con el resultado del
producto, o sea con el string 0mn.
El programa principal que realiza las transiciones q00m10n * B0m-11q10n1 es:
 0 1 B
q0 (q6, B, R) - -
q6 (q6, 0, R) (q14, 1, R) -
q14 (q14, 0, R) (q15, 1, L) (q15, 1, L)
q15 (q15, 0, L) (q1, 1, R) -
La subrutina COPIA que realiza las transiciones 0m-i1q10n10i * 0m-i1q50n10i+n es:
 0 1 2 B
q1 (q2, 2, R) (q4, 1, L) - -
q2 (q2, 0, R) (q2, 1, R) - (q3, 0, L)
q3 (q3, 0, L) (q3, 1, L) (q1, 2, R) -
q4 - (q5, 1, R) (q4, 0, L) -
Finalmente, se agregan las transiciones para convertir la DI Bi0m-i1q50n10ni en la DI

B 0 1q10n10ni, y chequear cuando i = m, o sea cuando todos los ceros iniciales se
i+1 m-i-1
hayan borrado. Si esto no ocurre aún se llama a COPIA otra vez y si ya ocurrió se borra el
prefijo 10n1 y se termina el cálculo del producto en el estado q12. Estas transiciones son:
 0 1 B
q5 (q7, 0, L) - -
q7 - (q8, 1, L) -
q8 (q9, 0, L) - (q10, B, R)
q9 (q9, 0, L) - (q0, B, R)
q10 - (q11, B, R) -
q11 (q11, B, R) (q12, B, R) -
Se puede comprobar que funciona con el siguiente ejemplo:
q000100  Bq60100  B0q6100  B01q1400  B010q140  B0100q14  B010q1501 

B01q15001  B0q151001  B01q1001  B012q201  B0120q21  B01201q2 
72

B0120q310  B012q3010  B01q32010  B012q1010  B0122q210  B01221q20 

B012210q2  B01221q300  B0122q3100  B012q32100  B0122q1100 
B012q42100  B01q420100  B0q4100100  B01q500100  B0q7100100 
Bq80100100  q9B0100100  Bq00100100  BBq6100100  BB1q1400100 
BB10q140100  BB100q14100  BB10q150100  BB1q1500100  BBq15100100 
BB1q100100  BB12q20100  BB120q2100  BB1201q200  BB12010q20 
BB122100q20  BB1221000q2  BB122100q300  BB12210q3000  BB1221q310000
 BB122q310000  BB12q3210000  BB122q110000  BB12q4210000 
BB1q42010000  BBq410010000  BB1q50010000  BBq710010000 
Bq8B10010000  BBq1010010000  BBBq110010000  BBBBq11010000 
BBBBBq1110000  BBBBBBq120000 (termina)
El resultado indica que 22 son 4.
6.5 Hipótesis de Church
Toda función entera que se puede calcular a través de una MT se llama función
recursiva parcial. La suposición de que la noción intuitiva de “función computable” puede
ser identificada con la clase de funciones recursivas parciales se conoce como Hipótesis de
Church, o Tesis de Church-Turing. No ha sido posible probarla esta hipótesis, pero mucha
evidencia de que ella es cierta.
Se llama RAM a un número infinito de palabras de memoria, numeradas desde el cero

en adelante, cada una de las cuales puede contener algún entero, y un número finito de
registros aritméticos, capaces de contener cualquier entero. Es claro que si se elige un
conjunto conveniente de instrucciones este RAM así definido puede simular cualquier
instrucción de computador existente.
Teorema. Una MT puede simular una RAM, bajo la condición que las instrucciones RAM
elementales puedan, ellas mismas, ser simuladas por una MT.
No se verá la demostración, la que puede ser consultada en [1], ya que no es atinente a

este curso. Pero lo anterior enuncia lo propuesto por Church en su hipótesis. Con esto se
concluye este capítulo.
1. Escriba una MT que reconozca strings sobre el alfabeto {0, 1} tales que la cantidad de
ceros sea igual a la de unos.
2. Escriba una MT que acepte los strings de L = {wwr/ w  (0 + 1)*}, en que wr es el

reverso del string w.
3. Escriba una MT que reconozca strings de L = {ww/ w  (0 + 1)*}.
4. Escriba una MT que calcule n! (n factorial) para n > 0.
5. Escriba una MT que evalúe  log2 n  para n > 0.
73

Apéndice
Se presentan en este Apéndice distintos Controles que han sido parte del curso:
“Teoría de Autómatas y Lenguajes Formales” en los últimos Semestres, y cuya pauta es
conocida por los alumnos de dicha asignatura.
Controles 1
Versión 1
1. El siguiente comportamiento de inputs-outputs corresponde a un autómata de Moore

con 4 estados. Determine la función de transición y de output y grafique el autómata
correspondiente.
Input  0 1 0 1 1 1 1 1 0 0 0 1
Output s s n n n s n n s s n s n
2. Escriba un AFND- que reconozca la expresión regular dada por (10* + 101*)*. Use el
algoritmo de búsqueda de strings para determinar los conjuntos Qi asociados al string
1101. ¿Es aceptado este string por el autómata?
3. Demuestre la siguiente equivalencia sobre expresiones regulares, indicando en cada

paso las equivalencias usadas por Ud.:
(1 + 0+1)0*(10*10*)*0 + 1(0 + 10*1)*10*1 + 1 + 00*1((10*1)*0)*(10*1)*10*1 + 0+1 =

0*10*(10*10*)*
Versión 2
1. Escriba un autómata finito determinístico que acepte el conjunto de strings binarios

(alfabeto {0,1}) correspondiente a los enteros positivos tales que su relación de
congruencia módulo 2 los haga pertenecer a la clase de equivalencia del 1.
2. Sea M1 = (Q,,,,,q0) un autómata de Mealy y sea el autómata de Moore equivalente

M2 = (Qx,,,’,’,[q0,b0]), como se vió en clases, en que:
’([q,b],a) = [(q,a), (q,a)]
’([q,b]) = b
Demuestre usando inducción que w*, a, se verifica que:
’([q0,b0],wa) = [(q0,wa), ((q0,w),a)]
3. Sea el AFND- con la función de transición sgte. y F = {q3}:
 0 1 
q0 {q1} {q2} {q1}
q1 {q0} {q3} {q0}
q2 {q3} {q0} {q3}
q3 {q2} {q1} 
74

a) Determine la función de transición extendida correspondiente.

b) A partir del resultado anterior determine el AFD equivalente.
c) Con un sistema de ecuaciones y con las equivalencias conocidas (indicando las usadas)
muestre que el lenguaje aceptado por este autómata es L = (0*10*1)*0*10*.
Versión 3
1. Demostrar la siguiente equivalencia, usando las que se vieron en clases (indicando las
usadas en cada paso):
(0101 + ) (01)* 0 + (01 + ) 0 = 0 (10)*
2. Sean  =  = {0, 1, 2}. Construya un AF de Mealy de 3 estados que implemente la

suma de enteros módulo 3, o sea: s(i,j) = (i + j) mod 3, 0  i,j  2.
3. Para el AFND- dado por la función de transición siguiente, en que F = {q3}

determinar:
a) El AFND equivalente
b) Con un sistema de ecuaciones adecuado mostrar que la e.r. asociada es 0*1.
 0 1 
q0   {q1}
q1 {q4} {q4} {q2}
q2 {q2} {q3} 
q3   
q4   
q5 {q4} {q3, q4} 
4. Sea M = (Q, , , q0, F) un AFD que reconoce el lenguaje L. Sea el AFD M’ definido
por M’ = (Q  Q, , ’, q0, F) en que:
a) ’(q,a) = [q,a] para todo qQ y todo a.

b) ’([q,a],b) = (q, ba) para todo qQ y todo a,b.
Demuestre por inducción sobre n par que ’(q, a2a1a4a3...anan-1) = (q, a1a2...an).
Versión 4
1. Diseñar un AFD que exprese la aceptación de los strings que representan a números
reales y enteros usando notación decimal. Por ejemplo, valores válidos son: 3.14159,
6457, etc.
2. Para el siguiente AFD, con F = {b, e, h}, estado inicial a y la función de transición 
dada:
 0 1 2
a b d g
b c b h
c c b i
d e a g
e f e h
f c e i
g h d g
h i e h
75

i f h i
a) Minimizar el número de estados del autómata, exhibiendo la tabla de estados

distinguibles y equivalentes.
b) Determinar la expresión regular asociada usando un sistema de ecuaciones lineales
adecuado.
3. Sea M un autómata finito de Mealy con estado inicial q0 y alfabeto {0, 1}. Sea el
output z1z2...zn producido por M en respuesta al input x1x2...xn. Se define el conjunto
SM como el de todos los strings w tales que w = z1x1z2x2...znxn, para cualesquier input
en la clausura del alfabeto. Demuestre que SM es un conjunto regular.
Ind. Construya un AFN que reconozca los strings del conjunto. Dése un ejemplo para
aclarar su trabajo.
4. Dada la expresión regular: 0(11 + 0(00 + 1)*)*, chequee si el string 01 pertenece o no a

este lenguaje usando el algoritmo de búsqueda en expresiones regulares visto en clases.
Controles 2
Versión 1
1. Demuestre, usando el Lema Pumping, que el conjunto L = {x(0 + 1)+ / x = xr} no es

un conjunto regular, en que xr corresponde al reverso del string x.
2. Para el AFD dado por la siguiente tabla de transiciones y con estados finales q2 y q4:
 0 1
q0 q1 q2
q1 q1 q3
q2 q0 q1
q3 q1 q4
q4 q3 q1
a) Establezca las clases de equivalencia de la relación dada por:

xRMy  (q0,x) = (q0,y).
b) Determine el AFD de menor cantidad de estados (en que los estados corresponden a las
clases de equivalencia de: xRLy  z* xzL ssi yzL). Puede hacer uso del
algoritmo visto en clases.
3. Escriba una gramática libre del contexto que reconozca los strings del lenguaje sobre el
alfabeto {a,b} dado por (abab + baba)*. Escriba un árbol de derivación para el string
babaabab.
Versión 2
1. Sea L un conjunto regular. Se define INIT(L) = {x / y* tal que xyL}. Demuestre
que INIT(L) es también un conjunto regular.
2. Escriba una gramática de libre contexto que reconozca los strings sobre el alfabeto
{a,b} tales que la cantidad de a’s es exactamente el doble que la de b’s. Escriba un
árbol de derivación para el string abaaab.
76

3. Escriba el AFD M que reconoce el complemento de la intersección entre los AFD de

los lenguajes regulares L1 = (0*1 + 0)* y L2 = (1*0 + 1)*.
Versión 3
1. Demuestre, usando el Lema Pumping, que el conjunto L = {x(0+1)* / C0(x) = C1(x)}

no es un conjunto regular, en que Ci(x) indica la cantidad de i en x, i = 0,1.
2. Sean los homomorfismos dados por:
h(a) = a, h(b) = a, h(c) = b

k(a) = 0, k(b) = 0, k(c) = 1
Demuestre que el conjunto L = {ambnam+n / m,n > 0} no es regular, haciendo uso de los
homomorfismos dados.
Ind. Considere la regularidad de homomorfismos, homomorfismos inversos e

intersección con el conjunto regular a*b*c*, para transformar L en un conjunto
conocido que no es regular y deduzca el resultado.
3. Determine una g.l.c. en FNC tal que acepte L = {0i1j2k / j = i o k = j}.
4. Dada la g.l.c. siguiente:
S  AC | A
A  BA | 
B  aB | b
C  Ca | Cb
a) Obtenga la g.l.c. en FNG equivalente sin símbolos inútiles.

b) Compruebe si esta gramática es ambigua.
c) ¿ Cuál será el lenguaje aceptado por esta gramática? Proponga un conjunto regular
solución.
Versión 4
1. Demuestre, usando el Lema Pumping, que el conjunto L = {xx / x*} no es regular.
2. Sea L un conjunto regular sobre el alfabeto {0, 1}. Se define la derivada de L

respecto al string x como el conjunto Lx = {y / xyL}.
a) Para L = 01* + 100* determine: L0, L1, L10,, L00, L01 y L11.
b) Pruebe que los conjuntos regulares son cerrados para la operación derivada.
3. Determine una g.l.c. en FNC que acepte L = {0i1j2k / 0  k  i o bien 0  k  j}.
4. Dada la g.l.c. siguiente:
S  AbC | BaC | AB | CS
A  aB | Cb | 
B  bB | Ca | 
C  ab | AB
a) Elimine las producciones vacías, unitarias y los símbolos inútiles (si los hay).
b) Compruebe si esta gramática es ambigua.
77

c) ¿ Cuál será el lenguaje aceptado por esta gramática? Proponga un conjunto

solución.
Controles 3
Versión 1
1. Escribir un APD que reconozca por stack vacío los strings del lenguaje:
L = {an bm ck /n > 0, m > 0 impar, k = n/2 si n es par y k = n+m si n es impar}
2. Escriba una Máquina de Turing que calcule n/2, o sea la función que retorna el piso
de la mitad de n (el mayor entero menor o igual a n/2), considerando n > 0. Su input es
el string 0n y su output debe ser 0n/2.
Indicación: Una vez iniciado el proceso escriba una subrutina que ejecute los
siguientes pasos:
B2i-1 q 0n-2i+1 1 0i-1 * B2i+1 q 0n-2i-1 1 0i
Lo anterior es para 1  i   n/2  controlando los casos de n par e impar. El caso n = 1

es particular. Finalmente se borra el 1 y detiene el proceso.
3. Para el APD siguiente, que acepta por stack vacío, determine el lenguaje aceptado y la
gramática de libre contexto equivalente en Forma Normal de Greibach sin
producciones vacías ni unitarias ni símbolos inútiles:
(q0,,Z0) = {(q1,SZ0)}
(q1,,S) = {(q1,ASA), (q1,BSB),(q1,C)}
(q1,a,A) = {(q1,)}
(q1,b,B) = {(q1,)}
(q1,c,C) = {(q1,)}
(q1,,Z0) = {(q1,)}
Versión 2
1. Escriba un APD que reconozca strings del siguiente conjunto usando stack vacío:
L = {anbm / n par, m impar, n > m > 0}
2. En la demostración del Teorema que permite asegurar que un lenguaje aceptado por
una g.l.c. también es aceptado por un APD, se propone que si la g.l.c. G = (N,T,P,)
está en FNG, y tal que L(G), entonces el APD equivalente es M =
({q},T,N,,q,,), en que si Aa entonces (q,)(q,a,A). Se pide que demuestre
por inducción sobre el número de pasos en la derivación la siguiente proposición,
que es previa a la demostración de que G y M son equivalentes: para xT+ y N* se
tiene:
 * x por una derivación más a la izquierda ssi (q,x,) * (q,,)
3. Escriba una MT que calcule la división de dos números enteros positivos m y n, tal que
m  n, informando de su resultado y el resto de la división. Su input debe ser 0m10n y
su output debe ser 0r10d, en que r es el resto de dividir m por n y d es el resultado de la
división.
78

Ind.: Considere los siguientes pasos: q0 0m10n * Bn 0m-n10n10 * Binq0m-in10n10i, en

que r = m – in es el resto de la división e i = m/n. Para esto escriba una subrutina que
realice los pasos intermedios cada vez y que controle el resto. Finalmente debe borrar
el string 10n para obtener el resultado.
Versión 3
1. Escriba un APD que acepte strings de (0 + 1)* que terminen en 01 o en 10.
2. En la demostración del Teorema que permite asegurar que un lenguaje aceptado por
una g.l.c. también es aceptado por un APD, se tiene que si la g.l.c. G = (N,T,P,) está
en FNG, tal que L(G), entonces el APD equivalente es M = ({q},T,N,,q,,), en
que si Aa entonces (q,)(q,a,A). Se pide que demuestre por inducción sobre el
número de pasos en la derivación la siguiente proposición, que es previa a la prueba de
que G y M son equivalentes:
 * x por una derivación más a la izquierda ssi (q,x,) * (q,,)
3. Construya una MT que acepte el conjunto L = {0i1j0i+j / i  0, j > 0}.
4. Determine la g.l.c. equivalente al APD siguiente:
M = ({q0, q1}, {a, b}, {A, B, Z0}, , q0, Z0, )
(q0, a, Z0) = {(q1, AZ0), (q1, A)}

(q0, b, Z0) = {(q1, BZ0), (q1, B)}
(q1, a, A) = {(q1, AA), (q0, )}
(q1, b, B) = {(q1, BB), (q0, )}
(q0, , Z0) = {(q0, )}
(q0, , A) = {(q0, )}
(q0, , B) = {(q0, )}
Exámenes
Versión 1
1. Escribir un APD que reconozca por stack vacío los strings del lenguaje:
L = {an bm ck/n > 0, m > 0 impar, k = n/2 si n es par y k = n+m si n es impar}
2. Escriba una Máquina de Turing que determine el m-ésimo término de la sucesión de

Fibonacci. Debe recibir el input 0m10i10j y retornar el string de am ceros que
corresponde al valor de am, con m > 0. Suponga que a1 = i y a2 = j, con i,j > 0. No
olvide que la sucesión de Fibonacci es: am+2 = am+1 + am, para m > 0, con a1 y a2 datos
de partida.
3. Sea el AFD siguiente, con F = {q1, q2, q4, q6}:
 a b
q0 q2 q1
q1 q5 q5
q2 q3 q6
q3 q3 q4
q4 q5 q5
q5 q5 q5
79

q6 q5 q6
a) Mediante un sistema de ecuaciones adecuado y usando las equivalencias de

expresiones regulares conocidas (indicándolas), verifique que el lenguaje aceptado por
este autómata es a ((aa* + b*) b + ) + b.
b) Minimice, si ello es posible, el número de estados del AFD, describiendo

completamente la tabla de estados y graficando el AFD de mínima cantidad de estados
equivalente (si es distinto al original).
Versión 2
1. Informe si los siguientes conjuntos es (son) o no regular(es), usando el Lema Pumping

para probarlo si no lo es (son) o describiendo un autómata finito que lo(s) acepte si lo
es (son):
a) L = {anbm/ n + m > 0}
b) L’ = {an w an / w  (a + b)*, n > 0}
2. Sean  =  = {0, 1}. Construya un AF de Moore que implemente como output la

réplica de una secuencia de entrada (input) retardada en una unidad de tiempo, o sea si
s(t) es la secuencia de entrada del AF entonces su output debe ser r(t) = s(t – 1), t > 0.
Suponga que r(0) = 0.
3. Escriba una máquina de Turing que calcule la potencia 2n para un n  0 entero. Su

n
input debe ser 0n y su output 02 .
Indicación: Una vez iniciado el proceso debe escribir una subrutina que realice los
siguientes pasos:
i 1
Bi-1 q 0n-i+1 1 02 * Bi q 0n – i 1 02
i
Con i = n, se borra el 1 intermedio y se obtiene el resultado.
Versión 3
1. Sean los strings de (0 + 1)* tales que:
a) Cada cero es seguido de otro cero o bien de al menos dos unos consecutivos.
b) La cantidad de ceros es par o un uno va seguido de un cero.
Describa:
1) El AFD con la menor cantidad de estados que reconozca la 1ª propiedad.

2) El AFD con la menor cantidad de estados que reconozca la 2ª propiedad.
3) La expresión regular asociada al AFD (1) anterior usando un sistema de ecuaciones
lineales adecuado.
4) La expresión regular asociada al AFD (2) anterior usando un sistema de ecuaciones
lineales adecuado.
5) El AFD que representa a la intersección de los AFD anteriores, usando la definición
vista en clases para construir la intersección de dos AFD.
2. Para la siguiente gramática, que genera expresiones aritméticas con sumas, productos y
paréntesis, determine la g.l.c. en FNG equivalente y el APD equivalente a ésta:
80

G = ({E, E’, T, T’, F}, {+, *, (, ), id}, P, E), en que P son las producciones:
E  T E’
E’  + T E’ | 
T  F T’
T’  * F T’ | 
F  ( E ) | id
3. Construya una máquina de Turing que reconozca strings del conjunto:
L = {0n 1m 0n 1m / n > 0, m > 0}
Versión 4
1. Sean los strings sobre el alfabeto {0, 1} tales que:
a) Pertenezcan al conjunto regular dado por (01 + 10)* + 10*1.

b) Pertenezcan al conjunto regular dado por (010)* + (101)*.
Determine los AFN sin transiciones vacías asociadas a cada uno de estos conjuntos.
2. Usando el Lema Pumping verifique que el conjunto L = {0m 1n 0mn / m > 0, n > 0} no
es un conjunto regular.
3. Construya una máquina de Turing que reconozca los strings del conjunto:
L = {0n 12n 2n / n > 0}
81

Apunte 1

Cargado por

Información del documento

Título original

Derechos de autor

Formatos disponibles

Compartir este documento

Compartir o incrustar documentos

Opciones para compartir

¿Le pareció útil este documento?

¿Este contenido es inapropiado?

Copyright:

Formatos disponibles

Apunte 1

Cargado por

Copyright:

Formatos disponibles

TEORIA DE AUTOMATAS Y LENGUAJES FORMALES

Teoría de Autómatas y Lenguajes Formales

La ciencia de la Computación es una agrupación ordenada de conocimientos,

Los comienzos de esta ciencia se realizaron en diferentes campos, como son:

Las nociones de Autómatas Finitos (A.F.) y Expresiones Regulares (E.R.) fueron

Las nociones de Gramáticas de Libre Contexto (G.L.C.) y de Autómatas Pushdown

Por último, las máquinas de Turing corresponden al más completo tipo de

1.1 Definiciones Básicas y Fundamentos Matemáticos

1.1.1 Strings, Alfabetos y Lenguajes

Un string o palabra es una sucesión finita de símbolos yuxtapuestos. Por ejemplo, si

La concatenación de dos strings es el string formado por la yuxtaposición de ambos

Un lenguaje (formal) es un conjunto de strings de símbolos de algún alfabeto. Por

Sea  un alfabeto y w un string sobre . Si L es el lenguaje formado por algunos de

010  {, 0, 1, 00, 11, 000, 010, 111, ...}

* = {, 1, 11, 111, 1111,...}

1.2 Grafos y árboles

Un grafo no dirigido G = (V,E) consiste de un conjunto finito de vértices (o nodos)

Figura 1: Grafo no dirigido

Un camino en un grafo es una sucesión de vértices v1, v2,...,vk, k  1, tales que

Un grafo dirigido (o digrafo) G = (V,E) consiste de un conjunto finito de vértices V

Un camino en un digrafo es una sucesión de vértices v1,..., vk en que k  1, y tales

Un árbol es un digrafo con las siguientes propiedades:

2) Cada vértice distinto de la raíz posee exactamente un predecesor.

3) Los sucesores de cada vértice están ordenados desde la izquierda.

Ejemplo: Para los vértices V = {1,2,3,4,5} se tiene el siguiente árbol:

1.3 Relaciones de equivalencia

1) Reflexiva: aRa, aS

Una importante propiedad de una relación de equivalencia R sobre un conjunto S es

ii) a,bSi, aRb es Verdadero

iii) aSi, bSj, aRb es Falso

Por ejemplo: si S = {x / x|N, x < 10} entonces una partición de S es P = {{0,2,4},

El número de clases de equivalencia Si, i > 0, puede ser infinito.

Ejemplo. Sea la relación de congruencia módulo m, en que m es un entero positivo. Se

i  j mod m ssi i y j son enteros tales que i-j es divisible por m

Se observa que esta es una relación de equivalencia pues:

i) Es reflexiva ya que i  i mod m pues 0 es divisible por m.

Las clases de equivalencia de  son m en total. Por ejemplo, si m = 3 se tiene:

1.3.1. Clausura de Relaciones.

Sea P un conjunto de propiedades de relaciones. La P-clausura de una relación R

(1) Si (a,b)R entonces (a,b)R+.

La clausura reflexiva y transitiva de R, llamada R* es:

Ejemplo: Si R = {(1,2), (2,2), (2,3)} es una relación en S = {1,2,3}, entonces:

R+ = {(1,2), (2,2), (2,3), (1,3)}

R* = {(1,1), (1,2), (1,3), (2,2), (2,3), (3,3)}

Dada una proposición P(n) sobre un entero no negativo n, el principio de inducción

a) (Base) P(k) es válido, k  0, y

a) Para n = 0 se verifica que 20 = 20+1 – 1 = 1.

b) Para n > 0 se supone válida la proposición dada. Entonces:

Ejercicios del Capítulo

1. Determine si cada una de las siguientes relaciones es una relación de equivalencia

2. Se define potencia de un string w, para n entero positivo o nulo de la siguiente manera:

3. Se define la inversa de un string w de la siguiente manera:

4. Se define la potencia de un lenguaje L sobre el alfabeto  como sigue:

Entonces conteste las siguientes consultas:

a) Si L = {}, determine Ln para n  0.

d) Sean A = {a} y B = {b}. Determine An·B, A·Bn y (AB)n.

6. Encontrar la clausura transitiva, la clausura transitiva y reflexiva y la clausura simétrica

2. Autómatas Finitos y Expresiones Regulares

El autómata finito es un modelo matemático de un sistema, con inputs y outputs

Como ejemplo de un sistema de estados finitos se tiene el mecanismo de control de

2.2 Autómata Finito Determinístico

Un autómata finito determinístico (AFD) consiste de un conjunto finito de estados y

Asociado a cada AFD existe un diagrama de transición, que es un digrafo en el cual